From b8bcdab0730d6e9570ff85611b3ce9508206e5c5 Mon Sep 17 00:00:00 2001 From: Krzosa Karol Date: Thu, 23 Jun 2022 09:26:40 +0200 Subject: [PATCH] Preparing to add register windows and function calls --- bytecode_interpreter.cpp | 446 +++++++++++++++++++------------------- code_generating_script.py | 20 +- 2 files changed, 232 insertions(+), 234 deletions(-) diff --git a/bytecode_interpreter.cpp b/bytecode_interpreter.cpp index 499bbc8..11a2d41 100644 --- a/bytecode_interpreter.cpp +++ b/bytecode_interpreter.cpp @@ -153,7 +153,7 @@ union Register{ U32 *pointer_u32; U16 *pointer_u16; U8 *pointer_u8; - + U64 u64; U32 u32; U16 u16; @@ -185,23 +185,22 @@ struct Call_Frame{ }; struct Bc{ - U32 dis; // @debug_id + U32 dis; // @debug_ids - Call_Frame *top_call; U64 *stack_bottom; U64 *stack_pointer; U64 *stack_top; - Instruction *instruction_pointer; // @todo Array can change location !!!!!! - Register *registers; - Register *register_end; - - Array all_registers; + Call_Frame *top_call; + Register_Index first_register_index_in_window; + Array registers; Array used_registers; Array free_registers; - Arena memory; + Instruction *instruction_pointer; Arena instructions; + + Arena memory; Arena stack; // We reserve 4 gibs and allocate only 4 kibs to make sure we know when we // accidently overshoot the stack by 2 gigabytes woo yeee }; @@ -213,7 +212,7 @@ function Register_Index allocate_register(Bc *b){ Register_Index result = -1; if(b->free_registers.len == 0) - result = b->all_registers.addi({}); + result = b->registers.addi({}); else result = b->free_registers.pop(); @@ -240,7 +239,7 @@ function Bc create_bytecode_interp(){ Bc b = {}; - b.all_registers = array_make(pctx->heap, 1024); + b.registers = array_make(pctx->heap, 1024); b.free_registers = array_make(pctx->heap, 1024); b.used_registers = array_make(pctx->heap, 1024); @@ -363,18 +362,17 @@ run_bytecode_interp(Bc *b){ b->instruction_pointer = (Instruction *)b->instructions.memory.data; b->stack_pointer = b->stack_bottom = (U64 *)b->stack.memory.data; b->stack_top = (U64 *)(b->stack.memory.data + b->stack.len); - b->registers = &b->all_registers[0]; - b->register_end = b->all_registers.end(); + b->first_register_index_in_window = 0; +#define R(x) (b->registers[b->first_register_index_in_window + (x)]) // Get register for(;;){ Instruction *instr = b->instruction_pointer++; - #if BC_ASSERTS print_token_line(instr->debug_pos); assert_msg(b->stack_pointer < b->stack_top, "Bytecode stack overflow"); assert_msg(b->stack_pointer >= b->stack_bottom, "Bytecode stack underflow"); - assert_msg(b->registers < b->register_end, "Bytecode interpreter bug, register pointer is pointing over last possible register"); + assert_msg(b->first_register_index_in_window < b->registers.cap, "Bytecode interpreter bug, register pointer is pointing over last possible register"); #endif bc_log("i%u[0x%llx] %s ", instr->di, instr, op_name[instr->operation]); @@ -384,7 +382,7 @@ run_bytecode_interp(Bc *b){ case BC_PUSH_STACK:{ U64 *stack = b->stack_pointer++; - U64 src = b->registers[instr->index_a].u64; + U64 src = R(instr->index_a).u64; bc_log("r%u(src) [0x%llx|%lld|%f]", instr->index_a, src, src, src); *stack = src; }break; @@ -392,7 +390,7 @@ run_bytecode_interp(Bc *b){ case BC_POP_STACK:{ U64 *stack = --b->stack_pointer; bc_log("r%u(dst) [0x%llx|%lld|%f]", instr->index_c, *stack, *stack, *stack); - b->registers[instr->index_c].u64 = *stack; + R(instr->index_c).u64 = *stack; }break; case BC_END_OF_INSTRUCTIONS:{ @@ -400,7 +398,7 @@ run_bytecode_interp(Bc *b){ }break; case BC_LOAD_CONSTANT: { - b->registers[instr->index_c] = instr->constant; + R(instr->index_c) = instr->constant; #if BC_LOG switch(instr->debug_type_flag){ case TYPE_S64: bc_log("dst[r%u] S64[%lld]", instr->index_c, instr->constant.s64); break; @@ -417,421 +415,421 @@ run_bytecode_interp(Bc *b){ // case BC_LOAD_FROM_MEMORY64:{ - U64 *load_address = b->registers[instr->index_a].pointer_u64; - b->registers[instr->index_c].u64 = *load_address; - bc_log("load_address[r%u, %llx] dst[r%u] [0x%llx|%lld|%f]", instr->index_a, load_address, instr->index_c, b->registers[instr->index_c].u64, b->registers[instr->index_c].u64, b->registers[instr->index_c].u64); + U64 *load_address = R(instr->index_a).pointer_u64; + R(instr->index_c).u64 = *load_address; + bc_log("load_address[r%u, %llx] dst[r%u] [0x%llx|%lld|%f]", instr->index_a, load_address, instr->index_c, R(instr->index_c).u64, R(instr->index_c).u64, R(instr->index_c).u64); }break; case BC_STORE_TO_MEMORY64:{ - U64 *store_address = b->registers[instr->index_c].pointer_u64; - *store_address = b->registers[instr->index_a].u64; + U64 *store_address = R(instr->index_c).pointer_u64; + *store_address = R(instr->index_a).u64; bc_log("src[r%u] store_address[r%u, %llx] value_written[0x%llx|%lld|%f]", instr->index_a, instr->index_c, store_address, *store_address, *store_address, *store_address); }break; - + case BC_LOAD_FROM_MEMORY32:{ - U32 *load_address = b->registers[instr->index_a].pointer_u32; - b->registers[instr->index_c].u32 = *load_address; - bc_log("load_address[r%u, %llx] dst[r%u] [0x%llx|%lld|%f]", instr->index_a, load_address, instr->index_c, b->registers[instr->index_c].u32, b->registers[instr->index_c].u32, b->registers[instr->index_c].u32); + U32 *load_address = R(instr->index_a).pointer_u32; + R(instr->index_c).u32 = *load_address; + bc_log("load_address[r%u, %llx] dst[r%u] [0x%llx|%lld|%f]", instr->index_a, load_address, instr->index_c, R(instr->index_c).u32, R(instr->index_c).u32, R(instr->index_c).u32); }break; case BC_STORE_TO_MEMORY32:{ - U32 *store_address = b->registers[instr->index_c].pointer_u32; - *store_address = b->registers[instr->index_a].u32; + U32 *store_address = R(instr->index_c).pointer_u32; + *store_address = R(instr->index_a).u32; bc_log("src[r%u] store_address[r%u, %llx] value_written[0x%llx|%lld|%f]", instr->index_a, instr->index_c, store_address, *store_address, *store_address, *store_address); }break; - + case BC_LOAD_FROM_MEMORY16:{ - U16 *load_address = b->registers[instr->index_a].pointer_u16; - b->registers[instr->index_c].u16 = *load_address; - bc_log("load_address[r%u, %llx] dst[r%u] [0x%llx|%lld|%f]", instr->index_a, load_address, instr->index_c, b->registers[instr->index_c].u16, b->registers[instr->index_c].u16, b->registers[instr->index_c].u16); + U16 *load_address = R(instr->index_a).pointer_u16; + R(instr->index_c).u16 = *load_address; + bc_log("load_address[r%u, %llx] dst[r%u] [0x%llx|%lld|%f]", instr->index_a, load_address, instr->index_c, R(instr->index_c).u16, R(instr->index_c).u16, R(instr->index_c).u16); }break; case BC_STORE_TO_MEMORY16:{ - U16 *store_address = b->registers[instr->index_c].pointer_u16; - *store_address = b->registers[instr->index_a].u16; + U16 *store_address = R(instr->index_c).pointer_u16; + *store_address = R(instr->index_a).u16; bc_log("src[r%u] store_address[r%u, %llx] value_written[0x%llx|%lld|%f]", instr->index_a, instr->index_c, store_address, *store_address, *store_address, *store_address); }break; - + case BC_LOAD_FROM_MEMORY8:{ - U8 *load_address = b->registers[instr->index_a].pointer_u8; - b->registers[instr->index_c].u8 = *load_address; - bc_log("load_address[r%u, %llx] dst[r%u] [0x%llx|%lld|%f]", instr->index_a, load_address, instr->index_c, b->registers[instr->index_c].u8, b->registers[instr->index_c].u8, b->registers[instr->index_c].u8); + U8 *load_address = R(instr->index_a).pointer_u8; + R(instr->index_c).u8 = *load_address; + bc_log("load_address[r%u, %llx] dst[r%u] [0x%llx|%lld|%f]", instr->index_a, load_address, instr->index_c, R(instr->index_c).u8, R(instr->index_c).u8, R(instr->index_c).u8); }break; case BC_STORE_TO_MEMORY8:{ - U8 *store_address = b->registers[instr->index_c].pointer_u8; - *store_address = b->registers[instr->index_a].u8; + U8 *store_address = R(instr->index_c).pointer_u8; + *store_address = R(instr->index_a).u8; bc_log("src[r%u] store_address[r%u, %llx] value_written[0x%llx|%lld|%f]", instr->index_a, instr->index_c, store_address, *store_address, *store_address, *store_address); }break; - + case BC_ADD_S64:{ - S64 left = b->registers[instr->index_a].s64; - S64 right = b->registers[instr->index_b].s64; + S64 left = R(instr->index_a).s64; + S64 right = R(instr->index_b).s64; S64 result = left + right; - b->registers[instr->index_c].s64 = result; + R(instr->index_c).s64 = result; bc_log("[r%s, %lld] + [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_SUB_S64:{ - S64 left = b->registers[instr->index_a].s64; - S64 right = b->registers[instr->index_b].s64; + S64 left = R(instr->index_a).s64; + S64 right = R(instr->index_b).s64; S64 result = left - right; - b->registers[instr->index_c].s64 = result; + R(instr->index_c).s64 = result; bc_log("[r%s, %lld] - [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_DIV_S64:{ - S64 left = b->registers[instr->index_a].s64; - S64 right = b->registers[instr->index_b].s64; + S64 left = R(instr->index_a).s64; + S64 right = R(instr->index_b).s64; S64 result = left / right; - b->registers[instr->index_c].s64 = result; + R(instr->index_c).s64 = result; bc_log("[r%s, %lld] / [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_MUL_S64:{ - S64 left = b->registers[instr->index_a].s64; - S64 right = b->registers[instr->index_b].s64; + S64 left = R(instr->index_a).s64; + S64 right = R(instr->index_b).s64; S64 result = left * right; - b->registers[instr->index_c].s64 = result; + R(instr->index_c).s64 = result; bc_log("[r%s, %lld] * [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_MOD_S64:{ - S64 left = b->registers[instr->index_a].s64; - S64 right = b->registers[instr->index_b].s64; + S64 left = R(instr->index_a).s64; + S64 right = R(instr->index_b).s64; S64 result = left % right; - b->registers[instr->index_c].s64 = result; + R(instr->index_c).s64 = result; bc_log("[r%s, %lld] % [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_SHR_S64:{ - S64 left = b->registers[instr->index_a].s64; - S64 right = b->registers[instr->index_b].s64; + S64 left = R(instr->index_a).s64; + S64 right = R(instr->index_b).s64; S64 result = left >> right; - b->registers[instr->index_c].s64 = result; + R(instr->index_c).s64 = result; bc_log("[r%s, %lld] >> [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_SHL_S64:{ - S64 left = b->registers[instr->index_a].s64; - S64 right = b->registers[instr->index_b].s64; + S64 left = R(instr->index_a).s64; + S64 right = R(instr->index_b).s64; S64 result = left << right; - b->registers[instr->index_c].s64 = result; + R(instr->index_c).s64 = result; bc_log("[r%s, %lld] << [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_BITAND_S64:{ - S64 left = b->registers[instr->index_a].s64; - S64 right = b->registers[instr->index_b].s64; + S64 left = R(instr->index_a).s64; + S64 right = R(instr->index_b).s64; S64 result = left & right; - b->registers[instr->index_c].s64 = result; + R(instr->index_c).s64 = result; bc_log("[r%s, %lld] & [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_BITOR_S64:{ - S64 left = b->registers[instr->index_a].s64; - S64 right = b->registers[instr->index_b].s64; + S64 left = R(instr->index_a).s64; + S64 right = R(instr->index_b).s64; S64 result = left | right; - b->registers[instr->index_c].s64 = result; + R(instr->index_c).s64 = result; bc_log("[r%s, %lld] | [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_BITXOR_S64:{ - S64 left = b->registers[instr->index_a].s64; - S64 right = b->registers[instr->index_b].s64; + S64 left = R(instr->index_a).s64; + S64 right = R(instr->index_b).s64; S64 result = left ^ right; - b->registers[instr->index_c].s64 = result; + R(instr->index_c).s64 = result; bc_log("[r%s, %lld] ^ [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_BITNOT_S64:{ - S64 left = (S64)b->registers[instr->index_a].s64; + S64 left = (S64)R(instr->index_a).s64; S64 result = ~left; - S64 *dst = b->registers[instr->index_c].pointer_s64; + S64 *dst = R(instr->index_c).pointer_s64; *dst = result; bc_log("~ [%lld] = [%lld]", left, result); }break; - + case BC_EQ_S64:{ - S64 left = b->registers[instr->index_a].s64; - S64 right = b->registers[instr->index_b].s64; + S64 left = R(instr->index_a).s64; + S64 right = R(instr->index_b).s64; S64 result = left == right; - b->registers[instr->index_c].s64 = result; + R(instr->index_c).s64 = result; bc_log("[r%s, %lld] == [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_NEQ_S64:{ - S64 left = b->registers[instr->index_a].s64; - S64 right = b->registers[instr->index_b].s64; + S64 left = R(instr->index_a).s64; + S64 right = R(instr->index_b).s64; S64 result = left != right; - b->registers[instr->index_c].s64 = result; + R(instr->index_c).s64 = result; bc_log("[r%s, %lld] != [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_GT_S64:{ - S64 left = b->registers[instr->index_a].s64; - S64 right = b->registers[instr->index_b].s64; + S64 left = R(instr->index_a).s64; + S64 right = R(instr->index_b).s64; S64 result = left > right; - b->registers[instr->index_c].s64 = result; + R(instr->index_c).s64 = result; bc_log("[r%s, %lld] > [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_LT_S64:{ - S64 left = b->registers[instr->index_a].s64; - S64 right = b->registers[instr->index_b].s64; + S64 left = R(instr->index_a).s64; + S64 right = R(instr->index_b).s64; S64 result = left < right; - b->registers[instr->index_c].s64 = result; + R(instr->index_c).s64 = result; bc_log("[r%s, %lld] < [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_OR_S64:{ - S64 left = b->registers[instr->index_a].s64; - S64 right = b->registers[instr->index_b].s64; + S64 left = R(instr->index_a).s64; + S64 right = R(instr->index_b).s64; S64 result = left || right; - b->registers[instr->index_c].s64 = result; + R(instr->index_c).s64 = result; bc_log("[r%s, %lld] || [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_GTE_S64:{ - S64 left = b->registers[instr->index_a].s64; - S64 right = b->registers[instr->index_b].s64; + S64 left = R(instr->index_a).s64; + S64 right = R(instr->index_b).s64; S64 result = left >= right; - b->registers[instr->index_c].s64 = result; + R(instr->index_c).s64 = result; bc_log("[r%s, %lld] >= [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_LTE_S64:{ - S64 left = b->registers[instr->index_a].s64; - S64 right = b->registers[instr->index_b].s64; + S64 left = R(instr->index_a).s64; + S64 right = R(instr->index_b).s64; S64 result = left <= right; - b->registers[instr->index_c].s64 = result; + R(instr->index_c).s64 = result; bc_log("[r%s, %lld] <= [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_ADD_U64:{ - U64 left = b->registers[instr->index_a].u64; - U64 right = b->registers[instr->index_b].u64; + U64 left = R(instr->index_a).u64; + U64 right = R(instr->index_b).u64; U64 result = left + right; - b->registers[instr->index_c].u64 = result; + R(instr->index_c).u64 = result; bc_log("[r%s, %llu] + [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_SUB_U64:{ - U64 left = b->registers[instr->index_a].u64; - U64 right = b->registers[instr->index_b].u64; + U64 left = R(instr->index_a).u64; + U64 right = R(instr->index_b).u64; U64 result = left - right; - b->registers[instr->index_c].u64 = result; + R(instr->index_c).u64 = result; bc_log("[r%s, %llu] - [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_DIV_U64:{ - U64 left = b->registers[instr->index_a].u64; - U64 right = b->registers[instr->index_b].u64; + U64 left = R(instr->index_a).u64; + U64 right = R(instr->index_b).u64; U64 result = left / right; - b->registers[instr->index_c].u64 = result; + R(instr->index_c).u64 = result; bc_log("[r%s, %llu] / [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_MUL_U64:{ - U64 left = b->registers[instr->index_a].u64; - U64 right = b->registers[instr->index_b].u64; + U64 left = R(instr->index_a).u64; + U64 right = R(instr->index_b).u64; U64 result = left * right; - b->registers[instr->index_c].u64 = result; + R(instr->index_c).u64 = result; bc_log("[r%s, %llu] * [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_MOD_U64:{ - U64 left = b->registers[instr->index_a].u64; - U64 right = b->registers[instr->index_b].u64; + U64 left = R(instr->index_a).u64; + U64 right = R(instr->index_b).u64; U64 result = left % right; - b->registers[instr->index_c].u64 = result; + R(instr->index_c).u64 = result; bc_log("[r%s, %llu] % [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_SHR_U64:{ - U64 left = b->registers[instr->index_a].u64; - U64 right = b->registers[instr->index_b].u64; + U64 left = R(instr->index_a).u64; + U64 right = R(instr->index_b).u64; U64 result = left >> right; - b->registers[instr->index_c].u64 = result; + R(instr->index_c).u64 = result; bc_log("[r%s, %llu] >> [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_SHL_U64:{ - U64 left = b->registers[instr->index_a].u64; - U64 right = b->registers[instr->index_b].u64; + U64 left = R(instr->index_a).u64; + U64 right = R(instr->index_b).u64; U64 result = left << right; - b->registers[instr->index_c].u64 = result; + R(instr->index_c).u64 = result; bc_log("[r%s, %llu] << [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_BITAND_U64:{ - U64 left = b->registers[instr->index_a].u64; - U64 right = b->registers[instr->index_b].u64; + U64 left = R(instr->index_a).u64; + U64 right = R(instr->index_b).u64; U64 result = left & right; - b->registers[instr->index_c].u64 = result; + R(instr->index_c).u64 = result; bc_log("[r%s, %llu] & [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_BITOR_U64:{ - U64 left = b->registers[instr->index_a].u64; - U64 right = b->registers[instr->index_b].u64; + U64 left = R(instr->index_a).u64; + U64 right = R(instr->index_b).u64; U64 result = left | right; - b->registers[instr->index_c].u64 = result; + R(instr->index_c).u64 = result; bc_log("[r%s, %llu] | [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_BITXOR_U64:{ - U64 left = b->registers[instr->index_a].u64; - U64 right = b->registers[instr->index_b].u64; + U64 left = R(instr->index_a).u64; + U64 right = R(instr->index_b).u64; U64 result = left ^ right; - b->registers[instr->index_c].u64 = result; + R(instr->index_c).u64 = result; bc_log("[r%s, %llu] ^ [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_BITNOT_U64:{ - U64 left = (U64)b->registers[instr->index_a].u64; + U64 left = (U64)R(instr->index_a).u64; U64 result = ~left; - U64 *dst = b->registers[instr->index_c].pointer_u64; + U64 *dst = R(instr->index_c).pointer_u64; *dst = result; bc_log("~ [%llu] = [%llu]", left, result); }break; - + case BC_EQ_U64:{ - U64 left = b->registers[instr->index_a].u64; - U64 right = b->registers[instr->index_b].u64; + U64 left = R(instr->index_a).u64; + U64 right = R(instr->index_b).u64; U64 result = left == right; - b->registers[instr->index_c].u64 = result; + R(instr->index_c).u64 = result; bc_log("[r%s, %llu] == [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_NEQ_U64:{ - U64 left = b->registers[instr->index_a].u64; - U64 right = b->registers[instr->index_b].u64; + U64 left = R(instr->index_a).u64; + U64 right = R(instr->index_b).u64; U64 result = left != right; - b->registers[instr->index_c].u64 = result; + R(instr->index_c).u64 = result; bc_log("[r%s, %llu] != [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_GT_U64:{ - U64 left = b->registers[instr->index_a].u64; - U64 right = b->registers[instr->index_b].u64; + U64 left = R(instr->index_a).u64; + U64 right = R(instr->index_b).u64; U64 result = left > right; - b->registers[instr->index_c].u64 = result; + R(instr->index_c).u64 = result; bc_log("[r%s, %llu] > [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_LT_U64:{ - U64 left = b->registers[instr->index_a].u64; - U64 right = b->registers[instr->index_b].u64; + U64 left = R(instr->index_a).u64; + U64 right = R(instr->index_b).u64; U64 result = left < right; - b->registers[instr->index_c].u64 = result; + R(instr->index_c).u64 = result; bc_log("[r%s, %llu] < [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_OR_U64:{ - U64 left = b->registers[instr->index_a].u64; - U64 right = b->registers[instr->index_b].u64; + U64 left = R(instr->index_a).u64; + U64 right = R(instr->index_b).u64; U64 result = left || right; - b->registers[instr->index_c].u64 = result; + R(instr->index_c).u64 = result; bc_log("[r%s, %llu] || [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_GTE_U64:{ - U64 left = b->registers[instr->index_a].u64; - U64 right = b->registers[instr->index_b].u64; + U64 left = R(instr->index_a).u64; + U64 right = R(instr->index_b).u64; U64 result = left >= right; - b->registers[instr->index_c].u64 = result; + R(instr->index_c).u64 = result; bc_log("[r%s, %llu] >= [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_LTE_U64:{ - U64 left = b->registers[instr->index_a].u64; - U64 right = b->registers[instr->index_b].u64; + U64 left = R(instr->index_a).u64; + U64 right = R(instr->index_b).u64; U64 result = left <= right; - b->registers[instr->index_c].u64 = result; + R(instr->index_c).u64 = result; bc_log("[r%s, %llu] <= [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_ADD_F64:{ - F64 left = b->registers[instr->index_a].f64; - F64 right = b->registers[instr->index_b].f64; + F64 left = R(instr->index_a).f64; + F64 right = R(instr->index_b).f64; F64 result = left + right; - b->registers[instr->index_c].f64 = result; + R(instr->index_c).f64 = result; bc_log("[r%s, %f] + [r%s, %f] = [r%s, %f]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_SUB_F64:{ - F64 left = b->registers[instr->index_a].f64; - F64 right = b->registers[instr->index_b].f64; + F64 left = R(instr->index_a).f64; + F64 right = R(instr->index_b).f64; F64 result = left - right; - b->registers[instr->index_c].f64 = result; + R(instr->index_c).f64 = result; bc_log("[r%s, %f] - [r%s, %f] = [r%s, %f]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_DIV_F64:{ - F64 left = b->registers[instr->index_a].f64; - F64 right = b->registers[instr->index_b].f64; + F64 left = R(instr->index_a).f64; + F64 right = R(instr->index_b).f64; F64 result = left / right; - b->registers[instr->index_c].f64 = result; + R(instr->index_c).f64 = result; bc_log("[r%s, %f] / [r%s, %f] = [r%s, %f]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_MUL_F64:{ - F64 left = b->registers[instr->index_a].f64; - F64 right = b->registers[instr->index_b].f64; + F64 left = R(instr->index_a).f64; + F64 right = R(instr->index_b).f64; F64 result = left * right; - b->registers[instr->index_c].f64 = result; + R(instr->index_c).f64 = result; bc_log("[r%s, %f] * [r%s, %f] = [r%s, %f]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_EQ_F64:{ - F64 left = b->registers[instr->index_a].f64; - F64 right = b->registers[instr->index_b].f64; + F64 left = R(instr->index_a).f64; + F64 right = R(instr->index_b).f64; F64 result = left == right; - b->registers[instr->index_c].f64 = result; + R(instr->index_c).f64 = result; bc_log("[r%s, %f] == [r%s, %f] = [r%s, %f]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_NEQ_F64:{ - F64 left = b->registers[instr->index_a].f64; - F64 right = b->registers[instr->index_b].f64; + F64 left = R(instr->index_a).f64; + F64 right = R(instr->index_b).f64; F64 result = left != right; - b->registers[instr->index_c].f64 = result; + R(instr->index_c).f64 = result; bc_log("[r%s, %f] != [r%s, %f] = [r%s, %f]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_GT_F64:{ - F64 left = b->registers[instr->index_a].f64; - F64 right = b->registers[instr->index_b].f64; + F64 left = R(instr->index_a).f64; + F64 right = R(instr->index_b).f64; F64 result = left > right; - b->registers[instr->index_c].f64 = result; + R(instr->index_c).f64 = result; bc_log("[r%s, %f] > [r%s, %f] = [r%s, %f]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_LT_F64:{ - F64 left = b->registers[instr->index_a].f64; - F64 right = b->registers[instr->index_b].f64; + F64 left = R(instr->index_a).f64; + F64 right = R(instr->index_b).f64; F64 result = left < right; - b->registers[instr->index_c].f64 = result; + R(instr->index_c).f64 = result; bc_log("[r%s, %f] < [r%s, %f] = [r%s, %f]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_GTE_F64:{ - F64 left = b->registers[instr->index_a].f64; - F64 right = b->registers[instr->index_b].f64; + F64 left = R(instr->index_a).f64; + F64 right = R(instr->index_b).f64; F64 result = left >= right; - b->registers[instr->index_c].f64 = result; + R(instr->index_c).f64 = result; bc_log("[r%s, %f] >= [r%s, %f] = [r%s, %f]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + case BC_LTE_F64:{ - F64 left = b->registers[instr->index_a].f64; - F64 right = b->registers[instr->index_b].f64; + F64 left = R(instr->index_a).f64; + F64 right = R(instr->index_b).f64; F64 result = left <= right; - b->registers[instr->index_c].f64 = result; + R(instr->index_c).f64 = result; bc_log("[r%s, %f] <= [r%s, %f] = [r%s, %f]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }break; - + // // *End* of switch_cases generated using code_generating_script.py // diff --git a/code_generating_script.py b/code_generating_script.py index 20a1161..5ce439f 100644 --- a/code_generating_script.py +++ b/code_generating_script.py @@ -94,14 +94,14 @@ if True: for size in sizes: result += f""" case BC_LOAD_FROM_MEMORY{size}:{{ - U{size} *load_address = b->registers[instr->index_a].pointer{size}; - b->registers[instr->index_c].u{size} = *load_address; - bc_log("load_address[r%u, %llx] dst[r%u] [0x%llx|%lld|%f]", instr->index_a, load_address, instr->index_c, b->registers[instr->index_c].u{size}, b->registers[instr->index_c].u{size}, b->registers[instr->index_c].u{size}); + U{size} *load_address = R(instr->index_a).pointer_u{size}; + R(instr->index_c).u{size} = *load_address; + bc_log("load_address[r%u, %llx] dst[r%u] [0x%llx|%lld|%f]", instr->index_a, load_address, instr->index_c, R(instr->index_c).u{size}, R(instr->index_c).u{size}, R(instr->index_c).u{size}); }}break; case BC_STORE_TO_MEMORY{size}:{{ - U{size} *store_address = b->registers[instr->index_c].pointer{size}; - *store_address = b->registers[instr->index_a].u{size}; + U{size} *store_address = R(instr->index_c).pointer_u{size}; + *store_address = R(instr->index_a).u{size}; bc_log("src[r%u] store_address[r%u, %llx] value_written[0x%llx|%lld|%f]", instr->index_a, instr->index_c, store_address, *store_address, *store_address, *store_address); }}break; """ @@ -119,9 +119,9 @@ if True: if symbol == "~": result += f""" case BC_{op_name}_{T}:{{ - {T} left = ({T})b->registers[instr->index_a].{t}; + {T} left = ({T})R(instr->index_a).{t}; {T} result = {symbol}left; - {T} *dst = b->registers[instr->index_c].pointer_{t}; + {T} *dst = R(instr->index_c).pointer_{t}; *dst = result; bc_log("{symbol} [{sign}] = [{sign}]", left, result); }}break; @@ -133,10 +133,10 @@ if True: # Binary operation result += f""" case BC_{op_name}_{T}:{{ - {T} left = b->registers[instr->index_a].{t}; - {T} right = b->registers[instr->index_b].{t}; + {T} left = R(instr->index_a).{t}; + {T} right = R(instr->index_b).{t}; {T} result = left {symbol} right; - b->registers[instr->index_c].{t} = result; + R(instr->index_c).{t} = result; bc_log("[r%s, {sign}] {symbol} [r%s, {sign}] = [r%s, {sign}]", instr->index_a, left, instr->index_b, right, instr->index_c, result); }}break; """