From 6ed17a3c1c54fbc538e3ee1ea78ee6ca3192c00f Mon Sep 17 00:00:00 2001 From: Krzosa Karol Date: Tue, 21 Jun 2022 14:29:15 +0200 Subject: [PATCH] Comprehensive execution logging --- base.kl | 24 ---- bytecode_interpreter.cpp | 251 ++++++++++++++++++++++---------------- code_generating_script.py | 10 +- 3 files changed, 154 insertions(+), 131 deletions(-) delete mode 100644 base.kl diff --git a/base.kl b/base.kl deleted file mode 100644 index 47abfd6..0000000 --- a/base.kl +++ /dev/null @@ -1,24 +0,0 @@ -Os :: #import "os_windows.kl" - -SizeU :: #strict U64 - -Arena :: struct - memory: Os.Memory - alignment: U64 - len: U64 - -clamp_top_sizeu :: (val: SizeU, max: SizeU): SizeU - if val > max - return max - return val - -get_align_offset :: (size: SizeU, align: SizeU): SizeU - mask := align - 1 - val := size & mask - if val != 0 - val = align - val - return val - -align_up :: (size: SizeU, align: SizeU): SizeU - result := size + get_align_offset(size, align) - return result diff --git a/bytecode_interpreter.cpp b/bytecode_interpreter.cpp index e088c8e..2e7bdfc 100644 --- a/bytecode_interpreter.cpp +++ b/bytecode_interpreter.cpp @@ -1,12 +1,6 @@ -// REG - Register -// INS - Instruction - // // Generated using code_generating_script.py // - - - enum Operation: U16{ BC_END_OF_INSTRUCTIONS, BC_POP_STACK, @@ -149,20 +143,20 @@ enum{ }; struct Instruction{ + U64 di; // @debug_id Operation operation; U16 left; union{U16 right; U16 src;}; U16 dst; - U64 di; // @debug_id }; struct Instruction_Constant{ + U64 di; // @debug_id Operation operation; U32 dst; Register constant; - U64 di; // @debug_id U64 debug_type_flag; }; @@ -289,29 +283,32 @@ function void run_bytecode_interp(Bc *b){ for(;;){ auto instr = (Instruction *)b->registers[REG_INS_POINTER].pointer64; - bc_log("[%llx] - %s ", b->registers[REG_INS_POINTER].pointer64, op_name[instr->operation]); + bc_log("%llu.[%llx] - %s ", instr->di, b->registers[REG_INS_POINTER].pointer64, op_name[instr->operation]); b->registers[REG_INS_POINTER].pointer += sizeof(Instruction); switch(instr->operation){ case BC_LOAD_FROM_MEMORY64:{ U64 *load_address = b->registers[instr->src].pointer64; b->registers[instr->dst].u64 = *load_address; + bc_log("r%u(dst) [%llx|%lld|%f]", instr->dst, b->registers[instr->dst].u64, b->registers[instr->dst].u64, b->registers[instr->dst].u64); }break; case BC_STORE_TO_MEMORY64:{ U64 *store_address = b->registers[instr->dst].pointer64; *store_address = b->registers[instr->src].u64; + bc_log("r%u(src) [%llx|%lld|%f]", instr->src, *store_address, *store_address, *store_address); }break; case BC_PUSH_STACK:{ U64 *stack = b->registers[REG_STACK_POINTER].pointer64++; U64 src = b->registers[instr->src].u64; - bc_log("r%u ", instr->src); + bc_log("r%u(src) [%llx|%lld|%f]", instr->src, src, src, src); *stack = src; }break; case BC_POP_STACK:{ U64 *stack = --b->registers[REG_STACK_POINTER].pointer64; + bc_log("r%u(dst) [%llx|%lld|%f]", instr->dst, *stack, *stack, *stack); b->registers[instr->dst].u64 = *stack; }break; @@ -325,9 +322,9 @@ run_bytecode_interp(Bc *b){ b->registers[i->dst] = i->constant; #if BC_LOG switch(i->debug_type_flag){ - case TYPE_S64: bc_log("r%u v%lld", i->dst, i->constant.s64); break; - case TYPE_U64: bc_log("r%u v%llu", i->dst, i->constant.u64); break; - case TYPE_F64: bc_log("r%u v%f" , i->dst, i->constant.f64); break; + case TYPE_S64: bc_log("r%u(dst) [%lld]", i->dst, i->constant.s64); break; + case TYPE_U64: bc_log("r%u(dst) [%llu]", i->dst, i->constant.u64); break; + case TYPE_F64: bc_log("r%u(dst) [%f]" , i->dst, i->constant.f64); break; invalid_default_case; } #endif @@ -340,321 +337,369 @@ run_bytecode_interp(Bc *b){ case BC_ADD_S64:{ S64 left = b->registers[instr->left].s64; S64 right = b->registers[instr->right].s64; - bc_log(" %lld + %lld", left, right); - b->registers[instr->dst].s64 = left + right; break; + S64 result = left + right; + b->registers[instr->dst].s64 = result; + bc_log("r%u + r%u = r%u => [%lld] + [%lld] = [%lld]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_SUB_S64:{ S64 left = b->registers[instr->left].s64; S64 right = b->registers[instr->right].s64; - bc_log(" %lld - %lld", left, right); - b->registers[instr->dst].s64 = left - right; break; + S64 result = left - right; + b->registers[instr->dst].s64 = result; + bc_log("r%u + r%u = r%u => [%lld] - [%lld] = [%lld]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_DIV_S64:{ S64 left = b->registers[instr->left].s64; S64 right = b->registers[instr->right].s64; - bc_log(" %lld / %lld", left, right); - b->registers[instr->dst].s64 = left / right; break; + S64 result = left / right; + b->registers[instr->dst].s64 = result; + bc_log("r%u + r%u = r%u => [%lld] / [%lld] = [%lld]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_MUL_S64:{ S64 left = b->registers[instr->left].s64; S64 right = b->registers[instr->right].s64; - bc_log(" %lld * %lld", left, right); - b->registers[instr->dst].s64 = left * right; break; + S64 result = left * right; + b->registers[instr->dst].s64 = result; + bc_log("r%u + r%u = r%u => [%lld] * [%lld] = [%lld]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_MOD_S64:{ S64 left = b->registers[instr->left].s64; S64 right = b->registers[instr->right].s64; - bc_log(" %lld % %lld", left, right); - b->registers[instr->dst].s64 = left % right; break; + S64 result = left % right; + b->registers[instr->dst].s64 = result; + bc_log("r%u + r%u = r%u => [%lld] % [%lld] = [%lld]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_SHR_S64:{ S64 left = b->registers[instr->left].s64; S64 right = b->registers[instr->right].s64; - bc_log(" %lld >> %lld", left, right); - b->registers[instr->dst].s64 = left >> right; break; + S64 result = left >> right; + b->registers[instr->dst].s64 = result; + bc_log("r%u + r%u = r%u => [%lld] >> [%lld] = [%lld]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_SHL_S64:{ S64 left = b->registers[instr->left].s64; S64 right = b->registers[instr->right].s64; - bc_log(" %lld << %lld", left, right); - b->registers[instr->dst].s64 = left << right; break; + S64 result = left << right; + b->registers[instr->dst].s64 = result; + bc_log("r%u + r%u = r%u => [%lld] << [%lld] = [%lld]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_BITAND_S64:{ S64 left = b->registers[instr->left].s64; S64 right = b->registers[instr->right].s64; - bc_log(" %lld & %lld", left, right); - b->registers[instr->dst].s64 = left & right; break; + S64 result = left & right; + b->registers[instr->dst].s64 = result; + bc_log("r%u + r%u = r%u => [%lld] & [%lld] = [%lld]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_BITOR_S64:{ S64 left = b->registers[instr->left].s64; S64 right = b->registers[instr->right].s64; - bc_log(" %lld | %lld", left, right); - b->registers[instr->dst].s64 = left | right; break; + S64 result = left | right; + b->registers[instr->dst].s64 = result; + bc_log("r%u + r%u = r%u => [%lld] | [%lld] = [%lld]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_BITXOR_S64:{ S64 left = b->registers[instr->left].s64; S64 right = b->registers[instr->right].s64; - bc_log(" %lld ^ %lld", left, right); - b->registers[instr->dst].s64 = left ^ right; break; + S64 result = left ^ right; + b->registers[instr->dst].s64 = result; + bc_log("r%u + r%u = r%u => [%lld] ^ [%lld] = [%lld]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_BITNOT_S64:{ S64 left = (S64)b->registers[instr->left].s64; + S64 result = ~left; S64 *dst = b->registers[instr->dst].pointer_s64; - *dst = ~left; + *dst = result; + bc_log("~ [%lld] = [%lld]", left, result); }break; case BC_EQ_S64:{ S64 left = b->registers[instr->left].s64; S64 right = b->registers[instr->right].s64; - bc_log(" %lld == %lld", left, right); - b->registers[instr->dst].s64 = left == right; break; + S64 result = left == right; + b->registers[instr->dst].s64 = result; + bc_log("r%u + r%u = r%u => [%lld] == [%lld] = [%lld]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_NEQ_S64:{ S64 left = b->registers[instr->left].s64; S64 right = b->registers[instr->right].s64; - bc_log(" %lld != %lld", left, right); - b->registers[instr->dst].s64 = left != right; break; + S64 result = left != right; + b->registers[instr->dst].s64 = result; + bc_log("r%u + r%u = r%u => [%lld] != [%lld] = [%lld]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_GT_S64:{ S64 left = b->registers[instr->left].s64; S64 right = b->registers[instr->right].s64; - bc_log(" %lld > %lld", left, right); - b->registers[instr->dst].s64 = left > right; break; + S64 result = left > right; + b->registers[instr->dst].s64 = result; + bc_log("r%u + r%u = r%u => [%lld] > [%lld] = [%lld]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_LT_S64:{ S64 left = b->registers[instr->left].s64; S64 right = b->registers[instr->right].s64; - bc_log(" %lld < %lld", left, right); - b->registers[instr->dst].s64 = left < right; break; + S64 result = left < right; + b->registers[instr->dst].s64 = result; + bc_log("r%u + r%u = r%u => [%lld] < [%lld] = [%lld]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_OR_S64:{ S64 left = b->registers[instr->left].s64; S64 right = b->registers[instr->right].s64; - bc_log(" %lld || %lld", left, right); - b->registers[instr->dst].s64 = left || right; break; + S64 result = left || right; + b->registers[instr->dst].s64 = result; + bc_log("r%u + r%u = r%u => [%lld] || [%lld] = [%lld]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_GTE_S64:{ S64 left = b->registers[instr->left].s64; S64 right = b->registers[instr->right].s64; - bc_log(" %lld >= %lld", left, right); - b->registers[instr->dst].s64 = left >= right; break; + S64 result = left >= right; + b->registers[instr->dst].s64 = result; + bc_log("r%u + r%u = r%u => [%lld] >= [%lld] = [%lld]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_LTE_S64:{ S64 left = b->registers[instr->left].s64; S64 right = b->registers[instr->right].s64; - bc_log(" %lld <= %lld", left, right); - b->registers[instr->dst].s64 = left <= right; break; + S64 result = left <= right; + b->registers[instr->dst].s64 = result; + bc_log("r%u + r%u = r%u => [%lld] <= [%lld] = [%lld]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_ADD_U64:{ U64 left = b->registers[instr->left].u64; U64 right = b->registers[instr->right].u64; - bc_log(" %llu + %llu", left, right); - b->registers[instr->dst].u64 = left + right; break; + U64 result = left + right; + b->registers[instr->dst].u64 = result; + bc_log("r%u + r%u = r%u => [%llu] + [%llu] = [%llu]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_SUB_U64:{ U64 left = b->registers[instr->left].u64; U64 right = b->registers[instr->right].u64; - bc_log(" %llu - %llu", left, right); - b->registers[instr->dst].u64 = left - right; break; + U64 result = left - right; + b->registers[instr->dst].u64 = result; + bc_log("r%u + r%u = r%u => [%llu] - [%llu] = [%llu]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_DIV_U64:{ U64 left = b->registers[instr->left].u64; U64 right = b->registers[instr->right].u64; - bc_log(" %llu / %llu", left, right); - b->registers[instr->dst].u64 = left / right; break; + U64 result = left / right; + b->registers[instr->dst].u64 = result; + bc_log("r%u + r%u = r%u => [%llu] / [%llu] = [%llu]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_MUL_U64:{ U64 left = b->registers[instr->left].u64; U64 right = b->registers[instr->right].u64; - bc_log(" %llu * %llu", left, right); - b->registers[instr->dst].u64 = left * right; break; + U64 result = left * right; + b->registers[instr->dst].u64 = result; + bc_log("r%u + r%u = r%u => [%llu] * [%llu] = [%llu]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_MOD_U64:{ U64 left = b->registers[instr->left].u64; U64 right = b->registers[instr->right].u64; - bc_log(" %llu % %llu", left, right); - b->registers[instr->dst].u64 = left % right; break; + U64 result = left % right; + b->registers[instr->dst].u64 = result; + bc_log("r%u + r%u = r%u => [%llu] % [%llu] = [%llu]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_SHR_U64:{ U64 left = b->registers[instr->left].u64; U64 right = b->registers[instr->right].u64; - bc_log(" %llu >> %llu", left, right); - b->registers[instr->dst].u64 = left >> right; break; + U64 result = left >> right; + b->registers[instr->dst].u64 = result; + bc_log("r%u + r%u = r%u => [%llu] >> [%llu] = [%llu]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_SHL_U64:{ U64 left = b->registers[instr->left].u64; U64 right = b->registers[instr->right].u64; - bc_log(" %llu << %llu", left, right); - b->registers[instr->dst].u64 = left << right; break; + U64 result = left << right; + b->registers[instr->dst].u64 = result; + bc_log("r%u + r%u = r%u => [%llu] << [%llu] = [%llu]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_BITAND_U64:{ U64 left = b->registers[instr->left].u64; U64 right = b->registers[instr->right].u64; - bc_log(" %llu & %llu", left, right); - b->registers[instr->dst].u64 = left & right; break; + U64 result = left & right; + b->registers[instr->dst].u64 = result; + bc_log("r%u + r%u = r%u => [%llu] & [%llu] = [%llu]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_BITOR_U64:{ U64 left = b->registers[instr->left].u64; U64 right = b->registers[instr->right].u64; - bc_log(" %llu | %llu", left, right); - b->registers[instr->dst].u64 = left | right; break; + U64 result = left | right; + b->registers[instr->dst].u64 = result; + bc_log("r%u + r%u = r%u => [%llu] | [%llu] = [%llu]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_BITXOR_U64:{ U64 left = b->registers[instr->left].u64; U64 right = b->registers[instr->right].u64; - bc_log(" %llu ^ %llu", left, right); - b->registers[instr->dst].u64 = left ^ right; break; + U64 result = left ^ right; + b->registers[instr->dst].u64 = result; + bc_log("r%u + r%u = r%u => [%llu] ^ [%llu] = [%llu]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_BITNOT_U64:{ U64 left = (U64)b->registers[instr->left].u64; + U64 result = ~left; U64 *dst = b->registers[instr->dst].pointer_u64; - *dst = ~left; + *dst = result; + bc_log("~ [%llu] = [%llu]", left, result); }break; case BC_EQ_U64:{ U64 left = b->registers[instr->left].u64; U64 right = b->registers[instr->right].u64; - bc_log(" %llu == %llu", left, right); - b->registers[instr->dst].u64 = left == right; break; + U64 result = left == right; + b->registers[instr->dst].u64 = result; + bc_log("r%u + r%u = r%u => [%llu] == [%llu] = [%llu]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_NEQ_U64:{ U64 left = b->registers[instr->left].u64; U64 right = b->registers[instr->right].u64; - bc_log(" %llu != %llu", left, right); - b->registers[instr->dst].u64 = left != right; break; + U64 result = left != right; + b->registers[instr->dst].u64 = result; + bc_log("r%u + r%u = r%u => [%llu] != [%llu] = [%llu]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_GT_U64:{ U64 left = b->registers[instr->left].u64; U64 right = b->registers[instr->right].u64; - bc_log(" %llu > %llu", left, right); - b->registers[instr->dst].u64 = left > right; break; + U64 result = left > right; + b->registers[instr->dst].u64 = result; + bc_log("r%u + r%u = r%u => [%llu] > [%llu] = [%llu]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_LT_U64:{ U64 left = b->registers[instr->left].u64; U64 right = b->registers[instr->right].u64; - bc_log(" %llu < %llu", left, right); - b->registers[instr->dst].u64 = left < right; break; + U64 result = left < right; + b->registers[instr->dst].u64 = result; + bc_log("r%u + r%u = r%u => [%llu] < [%llu] = [%llu]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_OR_U64:{ U64 left = b->registers[instr->left].u64; U64 right = b->registers[instr->right].u64; - bc_log(" %llu || %llu", left, right); - b->registers[instr->dst].u64 = left || right; break; + U64 result = left || right; + b->registers[instr->dst].u64 = result; + bc_log("r%u + r%u = r%u => [%llu] || [%llu] = [%llu]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_GTE_U64:{ U64 left = b->registers[instr->left].u64; U64 right = b->registers[instr->right].u64; - bc_log(" %llu >= %llu", left, right); - b->registers[instr->dst].u64 = left >= right; break; + U64 result = left >= right; + b->registers[instr->dst].u64 = result; + bc_log("r%u + r%u = r%u => [%llu] >= [%llu] = [%llu]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_LTE_U64:{ U64 left = b->registers[instr->left].u64; U64 right = b->registers[instr->right].u64; - bc_log(" %llu <= %llu", left, right); - b->registers[instr->dst].u64 = left <= right; break; + U64 result = left <= right; + b->registers[instr->dst].u64 = result; + bc_log("r%u + r%u = r%u => [%llu] <= [%llu] = [%llu]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_ADD_F64:{ F64 left = b->registers[instr->left].f64; F64 right = b->registers[instr->right].f64; - bc_log(" %f + %f", left, right); - b->registers[instr->dst].f64 = left + right; break; + F64 result = left + right; + b->registers[instr->dst].f64 = result; + bc_log("r%u + r%u = r%u => [%f] + [%f] = [%f]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_SUB_F64:{ F64 left = b->registers[instr->left].f64; F64 right = b->registers[instr->right].f64; - bc_log(" %f - %f", left, right); - b->registers[instr->dst].f64 = left - right; break; + F64 result = left - right; + b->registers[instr->dst].f64 = result; + bc_log("r%u + r%u = r%u => [%f] - [%f] = [%f]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_DIV_F64:{ F64 left = b->registers[instr->left].f64; F64 right = b->registers[instr->right].f64; - bc_log(" %f / %f", left, right); - b->registers[instr->dst].f64 = left / right; break; + F64 result = left / right; + b->registers[instr->dst].f64 = result; + bc_log("r%u + r%u = r%u => [%f] / [%f] = [%f]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_MUL_F64:{ F64 left = b->registers[instr->left].f64; F64 right = b->registers[instr->right].f64; - bc_log(" %f * %f", left, right); - b->registers[instr->dst].f64 = left * right; break; + F64 result = left * right; + b->registers[instr->dst].f64 = result; + bc_log("r%u + r%u = r%u => [%f] * [%f] = [%f]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_EQ_F64:{ F64 left = b->registers[instr->left].f64; F64 right = b->registers[instr->right].f64; - bc_log(" %f == %f", left, right); - b->registers[instr->dst].f64 = left == right; break; + F64 result = left == right; + b->registers[instr->dst].f64 = result; + bc_log("r%u + r%u = r%u => [%f] == [%f] = [%f]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_NEQ_F64:{ F64 left = b->registers[instr->left].f64; F64 right = b->registers[instr->right].f64; - bc_log(" %f != %f", left, right); - b->registers[instr->dst].f64 = left != right; break; + F64 result = left != right; + b->registers[instr->dst].f64 = result; + bc_log("r%u + r%u = r%u => [%f] != [%f] = [%f]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_GT_F64:{ F64 left = b->registers[instr->left].f64; F64 right = b->registers[instr->right].f64; - bc_log(" %f > %f", left, right); - b->registers[instr->dst].f64 = left > right; break; + F64 result = left > right; + b->registers[instr->dst].f64 = result; + bc_log("r%u + r%u = r%u => [%f] > [%f] = [%f]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_LT_F64:{ F64 left = b->registers[instr->left].f64; F64 right = b->registers[instr->right].f64; - bc_log(" %f < %f", left, right); - b->registers[instr->dst].f64 = left < right; break; + F64 result = left < right; + b->registers[instr->dst].f64 = result; + bc_log("r%u + r%u = r%u => [%f] < [%f] = [%f]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_GTE_F64:{ F64 left = b->registers[instr->left].f64; F64 right = b->registers[instr->right].f64; - bc_log(" %f >= %f", left, right); - b->registers[instr->dst].f64 = left >= right; break; + F64 result = left >= right; + b->registers[instr->dst].f64 = result; + bc_log("r%u + r%u = r%u => [%f] >= [%f] = [%f]", instr->left, instr->right, instr->dst, left, right, result); }break; case BC_LTE_F64:{ F64 left = b->registers[instr->left].f64; F64 right = b->registers[instr->right].f64; - bc_log(" %f <= %f", left, right); - b->registers[instr->dst].f64 = left <= right; break; + F64 result = left <= right; + b->registers[instr->dst].f64 = result; + bc_log("r%u + r%u = r%u => [%f] <= [%f] = [%f]", instr->left, instr->right, instr->dst, left, right, result); }break; // diff --git a/code_generating_script.py b/code_generating_script.py index 380df85..3824781 100644 --- a/code_generating_script.py +++ b/code_generating_script.py @@ -71,9 +71,10 @@ if True: result += f""" case BC_{op_name}_{T}:{{ {T} left = ({T})b->registers[instr->left].{t}; - bc_log("{symbol} v{sign}", left); + {T} result = {symbol}left; {T} *dst = b->registers[instr->dst].pointer_{t}; - *dst = {symbol}left; + *dst = result; + bc_log("{symbol} [{sign}] = [{sign}]", left, result); }}break; """ continue @@ -85,8 +86,9 @@ if True: case BC_{op_name}_{T}:{{ {T} left = b->registers[instr->left].{t}; {T} right = b->registers[instr->right].{t}; - bc_log("v{sign} {symbol} v{sign}", left, right); - b->registers[instr->dst].{t} = left {symbol} right; break; + {T} result = left {symbol} right; + b->registers[instr->dst].{t} = result; + bc_log("r%u + r%u = r%u => [{sign}] {symbol} [{sign}] = [{sign}]", instr->left, instr->right, instr->dst, left, right, result); }}break; """ ################################