krzosa/corelang
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Comprehensive execution logging

Browse Source
This commit is contained in:
Krzosa Karol
2022-06-21 14:29:15 +02:00
parent 2cb9dbdb0c
commit 6ed17a3c1c
3 changed files with 154 additions and 131 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
base.kl
View File

@@ -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

251
bytecode_interpreter.cpp
View File

@@ -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;
//

10
code_generating_script.py
View File

@@ -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;
"""
################################