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

Preparing to add register windows and function calls

Browse Source
This commit is contained in:
Krzosa Karol
2022-06-23 09:26:40 +02:00
parent f7e03e5d2a
commit b8bcdab073
2 changed files with 232 additions and 234 deletions
Download Patch File Download Diff File Expand all files Collapse all files

446
bytecode_interpreter.cpp
View File

@@ -153,7 +153,7 @@ union Register{
U32 *pointer_u32; U32 *pointer_u32;
U16 *pointer_u16; U16 *pointer_u16;
U8 *pointer_u8; U8 *pointer_u8;
U64 u64; U64 u64;
U32 u32; U32 u32;
U16 u16; U16 u16;
@@ -185,23 +185,22 @@ struct Call_Frame{
}; };
struct Bc{ struct Bc{
U32 dis; // @debug_id U32 dis; // @debug_ids
Call_Frame *top_call;
U64 *stack_bottom; U64 *stack_bottom;
U64 *stack_pointer; U64 *stack_pointer;
U64 *stack_top; U64 *stack_top;
Instruction *instruction_pointer; // @todo Array can change location !!!!!!
Register *registers; Call_Frame *top_call;
Register *register_end; Register_Index first_register_index_in_window;
Array<Register> registers;
Array<Register> all_registers;
Array<Register_Index> used_registers; Array<Register_Index> used_registers;
Array<Register_Index> free_registers; Array<Register_Index> free_registers;
Arena memory; Instruction *instruction_pointer;
Arena instructions; Arena instructions;
Arena memory;
Arena stack; // We reserve 4 gibs and allocate only 4 kibs to make sure we know when we 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 // accidently overshoot the stack by 2 gigabytes woo yeee
}; };
@@ -213,7 +212,7 @@ function Register_Index
allocate_register(Bc *b){ allocate_register(Bc *b){
Register_Index result = -1; Register_Index result = -1;
if(b->free_registers.len == 0) if(b->free_registers.len == 0)
result = b->all_registers.addi({}); result = b->registers.addi({});
else else
result = b->free_registers.pop(); result = b->free_registers.pop();
@@ -240,7 +239,7 @@ function Bc
create_bytecode_interp(){ create_bytecode_interp(){
Bc b = {}; Bc b = {};
b.all_registers = array_make<Register>(pctx->heap, 1024); b.registers = array_make<Register>(pctx->heap, 1024);
b.free_registers = array_make<Register_Index>(pctx->heap, 1024); b.free_registers = array_make<Register_Index>(pctx->heap, 1024);
b.used_registers = array_make<Register_Index>(pctx->heap, 1024); b.used_registers = array_make<Register_Index>(pctx->heap, 1024);
@@ -363,18 +362,17 @@ run_bytecode_interp(Bc *b){
b->instruction_pointer = (Instruction *)b->instructions.memory.data; b->instruction_pointer = (Instruction *)b->instructions.memory.data;
b->stack_pointer = b->stack_bottom = (U64 *)b->stack.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->stack_top = (U64 *)(b->stack.memory.data + b->stack.len);
b->registers = &b->all_registers[0]; b->first_register_index_in_window = 0;
b->register_end = b->all_registers.end();
#define R(x) (b->registers[b->first_register_index_in_window + (x)]) // Get register
for(;;){ for(;;){
Instruction *instr = b->instruction_pointer++; Instruction *instr = b->instruction_pointer++;
#if BC_ASSERTS #if BC_ASSERTS
print_token_line(instr->debug_pos); print_token_line(instr->debug_pos);
assert_msg(b->stack_pointer < b->stack_top, "Bytecode stack overflow"); 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->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 #endif
bc_log("i%u[0x%llx] %s ", instr->di, instr, op_name[instr->operation]); 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:{ case BC_PUSH_STACK:{
U64 *stack = b->stack_pointer++; 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); bc_log("r%u(src) [0x%llx|%lld|%f]", instr->index_a, src, src, src);
*stack = src; *stack = src;
}break; }break;
@@ -392,7 +390,7 @@ run_bytecode_interp(Bc *b){
case BC_POP_STACK:{ case BC_POP_STACK:{
U64 *stack = --b->stack_pointer; U64 *stack = --b->stack_pointer;
bc_log("r%u(dst) [0x%llx|%lld|%f]", instr->index_c, *stack, *stack, *stack); 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; }break;
case BC_END_OF_INSTRUCTIONS:{ case BC_END_OF_INSTRUCTIONS:{
@@ -400,7 +398,7 @@ run_bytecode_interp(Bc *b){
}break; }break;
case BC_LOAD_CONSTANT: { case BC_LOAD_CONSTANT: {
b->registers[instr->index_c] = instr->constant; R(instr->index_c) = instr->constant;
#if BC_LOG #if BC_LOG
switch(instr->debug_type_flag){ switch(instr->debug_type_flag){
case TYPE_S64: bc_log("dst[r%u] S64[%lld]", instr->index_c, instr->constant.s64); break; 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:{ case BC_LOAD_FROM_MEMORY64:{
U64 *load_address = b->registers[instr->index_a].pointer_u64; U64 *load_address = R(instr->index_a).pointer_u64;
b->registers[instr->index_c].u64 = *load_address; 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, b->registers[instr->index_c].u64, b->registers[instr->index_c].u64, b->registers[instr->index_c].u64); 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; }break;
case BC_STORE_TO_MEMORY64:{ case BC_STORE_TO_MEMORY64:{
U64 *store_address = b->registers[instr->index_c].pointer_u64; U64 *store_address = R(instr->index_c).pointer_u64;
*store_address = b->registers[instr->index_a].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); 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; }break;
case BC_LOAD_FROM_MEMORY32:{ case BC_LOAD_FROM_MEMORY32:{
U32 *load_address = b->registers[instr->index_a].pointer_u32; U32 *load_address = R(instr->index_a).pointer_u32;
b->registers[instr->index_c].u32 = *load_address; 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, b->registers[instr->index_c].u32, b->registers[instr->index_c].u32, b->registers[instr->index_c].u32); 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; }break;
case BC_STORE_TO_MEMORY32:{ case BC_STORE_TO_MEMORY32:{
U32 *store_address = b->registers[instr->index_c].pointer_u32; U32 *store_address = R(instr->index_c).pointer_u32;
*store_address = b->registers[instr->index_a].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); 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; }break;
case BC_LOAD_FROM_MEMORY16:{ case BC_LOAD_FROM_MEMORY16:{
U16 *load_address = b->registers[instr->index_a].pointer_u16; U16 *load_address = R(instr->index_a).pointer_u16;
b->registers[instr->index_c].u16 = *load_address; 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, b->registers[instr->index_c].u16, b->registers[instr->index_c].u16, b->registers[instr->index_c].u16); 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; }break;
case BC_STORE_TO_MEMORY16:{ case BC_STORE_TO_MEMORY16:{
U16 *store_address = b->registers[instr->index_c].pointer_u16; U16 *store_address = R(instr->index_c).pointer_u16;
*store_address = b->registers[instr->index_a].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); 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; }break;
case BC_LOAD_FROM_MEMORY8:{ case BC_LOAD_FROM_MEMORY8:{
U8 *load_address = b->registers[instr->index_a].pointer_u8; U8 *load_address = R(instr->index_a).pointer_u8;
b->registers[instr->index_c].u8 = *load_address; 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, b->registers[instr->index_c].u8, b->registers[instr->index_c].u8, b->registers[instr->index_c].u8); 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; }break;
case BC_STORE_TO_MEMORY8:{ case BC_STORE_TO_MEMORY8:{
U8 *store_address = b->registers[instr->index_c].pointer_u8; U8 *store_address = R(instr->index_c).pointer_u8;
*store_address = b->registers[instr->index_a].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); 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; }break;
case BC_ADD_S64:{ case BC_ADD_S64:{
S64 left = b->registers[instr->index_a].s64; S64 left = R(instr->index_a).s64;
S64 right = b->registers[instr->index_b].s64; S64 right = R(instr->index_b).s64;
S64 result = left + right; 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); bc_log("[r%s, %lld] + [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_SUB_S64:{ case BC_SUB_S64:{
S64 left = b->registers[instr->index_a].s64; S64 left = R(instr->index_a).s64;
S64 right = b->registers[instr->index_b].s64; S64 right = R(instr->index_b).s64;
S64 result = left - right; 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); bc_log("[r%s, %lld] - [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_DIV_S64:{ case BC_DIV_S64:{
S64 left = b->registers[instr->index_a].s64; S64 left = R(instr->index_a).s64;
S64 right = b->registers[instr->index_b].s64; S64 right = R(instr->index_b).s64;
S64 result = left / right; 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); bc_log("[r%s, %lld] / [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_MUL_S64:{ case BC_MUL_S64:{
S64 left = b->registers[instr->index_a].s64; S64 left = R(instr->index_a).s64;
S64 right = b->registers[instr->index_b].s64; S64 right = R(instr->index_b).s64;
S64 result = left * right; 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); bc_log("[r%s, %lld] * [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_MOD_S64:{ case BC_MOD_S64:{
S64 left = b->registers[instr->index_a].s64; S64 left = R(instr->index_a).s64;
S64 right = b->registers[instr->index_b].s64; S64 right = R(instr->index_b).s64;
S64 result = left % right; 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); bc_log("[r%s, %lld] % [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_SHR_S64:{ case BC_SHR_S64:{
S64 left = b->registers[instr->index_a].s64; S64 left = R(instr->index_a).s64;
S64 right = b->registers[instr->index_b].s64; S64 right = R(instr->index_b).s64;
S64 result = left >> right; 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); bc_log("[r%s, %lld] >> [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_SHL_S64:{ case BC_SHL_S64:{
S64 left = b->registers[instr->index_a].s64; S64 left = R(instr->index_a).s64;
S64 right = b->registers[instr->index_b].s64; S64 right = R(instr->index_b).s64;
S64 result = left << right; 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); bc_log("[r%s, %lld] << [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_BITAND_S64:{ case BC_BITAND_S64:{
S64 left = b->registers[instr->index_a].s64; S64 left = R(instr->index_a).s64;
S64 right = b->registers[instr->index_b].s64; S64 right = R(instr->index_b).s64;
S64 result = left & right; 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); bc_log("[r%s, %lld] & [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_BITOR_S64:{ case BC_BITOR_S64:{
S64 left = b->registers[instr->index_a].s64; S64 left = R(instr->index_a).s64;
S64 right = b->registers[instr->index_b].s64; S64 right = R(instr->index_b).s64;
S64 result = left | right; 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); bc_log("[r%s, %lld] | [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_BITXOR_S64:{ case BC_BITXOR_S64:{
S64 left = b->registers[instr->index_a].s64; S64 left = R(instr->index_a).s64;
S64 right = b->registers[instr->index_b].s64; S64 right = R(instr->index_b).s64;
S64 result = left ^ right; 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); bc_log("[r%s, %lld] ^ [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_BITNOT_S64:{ 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 result = ~left;
S64 *dst = b->registers[instr->index_c].pointer_s64; S64 *dst = R(instr->index_c).pointer_s64;
*dst = result; *dst = result;
bc_log("~ [%lld] = [%lld]", left, result); bc_log("~ [%lld] = [%lld]", left, result);
}break; }break;
case BC_EQ_S64:{ case BC_EQ_S64:{
S64 left = b->registers[instr->index_a].s64; S64 left = R(instr->index_a).s64;
S64 right = b->registers[instr->index_b].s64; S64 right = R(instr->index_b).s64;
S64 result = left == right; 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); bc_log("[r%s, %lld] == [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_NEQ_S64:{ case BC_NEQ_S64:{
S64 left = b->registers[instr->index_a].s64; S64 left = R(instr->index_a).s64;
S64 right = b->registers[instr->index_b].s64; S64 right = R(instr->index_b).s64;
S64 result = left != right; 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); bc_log("[r%s, %lld] != [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_GT_S64:{ case BC_GT_S64:{
S64 left = b->registers[instr->index_a].s64; S64 left = R(instr->index_a).s64;
S64 right = b->registers[instr->index_b].s64; S64 right = R(instr->index_b).s64;
S64 result = left > right; 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); bc_log("[r%s, %lld] > [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_LT_S64:{ case BC_LT_S64:{
S64 left = b->registers[instr->index_a].s64; S64 left = R(instr->index_a).s64;
S64 right = b->registers[instr->index_b].s64; S64 right = R(instr->index_b).s64;
S64 result = left < right; 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); bc_log("[r%s, %lld] < [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_OR_S64:{ case BC_OR_S64:{
S64 left = b->registers[instr->index_a].s64; S64 left = R(instr->index_a).s64;
S64 right = b->registers[instr->index_b].s64; S64 right = R(instr->index_b).s64;
S64 result = left || right; 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); bc_log("[r%s, %lld] || [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_GTE_S64:{ case BC_GTE_S64:{
S64 left = b->registers[instr->index_a].s64; S64 left = R(instr->index_a).s64;
S64 right = b->registers[instr->index_b].s64; S64 right = R(instr->index_b).s64;
S64 result = left >= right; 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); bc_log("[r%s, %lld] >= [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_LTE_S64:{ case BC_LTE_S64:{
S64 left = b->registers[instr->index_a].s64; S64 left = R(instr->index_a).s64;
S64 right = b->registers[instr->index_b].s64; S64 right = R(instr->index_b).s64;
S64 result = left <= right; 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); bc_log("[r%s, %lld] <= [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_ADD_U64:{ case BC_ADD_U64:{
U64 left = b->registers[instr->index_a].u64; U64 left = R(instr->index_a).u64;
U64 right = b->registers[instr->index_b].u64; U64 right = R(instr->index_b).u64;
U64 result = left + right; 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); bc_log("[r%s, %llu] + [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_SUB_U64:{ case BC_SUB_U64:{
U64 left = b->registers[instr->index_a].u64; U64 left = R(instr->index_a).u64;
U64 right = b->registers[instr->index_b].u64; U64 right = R(instr->index_b).u64;
U64 result = left - right; 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); bc_log("[r%s, %llu] - [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_DIV_U64:{ case BC_DIV_U64:{
U64 left = b->registers[instr->index_a].u64; U64 left = R(instr->index_a).u64;
U64 right = b->registers[instr->index_b].u64; U64 right = R(instr->index_b).u64;
U64 result = left / right; 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); bc_log("[r%s, %llu] / [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_MUL_U64:{ case BC_MUL_U64:{
U64 left = b->registers[instr->index_a].u64; U64 left = R(instr->index_a).u64;
U64 right = b->registers[instr->index_b].u64; U64 right = R(instr->index_b).u64;
U64 result = left * right; 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); bc_log("[r%s, %llu] * [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_MOD_U64:{ case BC_MOD_U64:{
U64 left = b->registers[instr->index_a].u64; U64 left = R(instr->index_a).u64;
U64 right = b->registers[instr->index_b].u64; U64 right = R(instr->index_b).u64;
U64 result = left % right; 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); bc_log("[r%s, %llu] % [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_SHR_U64:{ case BC_SHR_U64:{
U64 left = b->registers[instr->index_a].u64; U64 left = R(instr->index_a).u64;
U64 right = b->registers[instr->index_b].u64; U64 right = R(instr->index_b).u64;
U64 result = left >> right; 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); bc_log("[r%s, %llu] >> [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_SHL_U64:{ case BC_SHL_U64:{
U64 left = b->registers[instr->index_a].u64; U64 left = R(instr->index_a).u64;
U64 right = b->registers[instr->index_b].u64; U64 right = R(instr->index_b).u64;
U64 result = left << right; 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); bc_log("[r%s, %llu] << [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_BITAND_U64:{ case BC_BITAND_U64:{
U64 left = b->registers[instr->index_a].u64; U64 left = R(instr->index_a).u64;
U64 right = b->registers[instr->index_b].u64; U64 right = R(instr->index_b).u64;
U64 result = left & right; 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); bc_log("[r%s, %llu] & [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_BITOR_U64:{ case BC_BITOR_U64:{
U64 left = b->registers[instr->index_a].u64; U64 left = R(instr->index_a).u64;
U64 right = b->registers[instr->index_b].u64; U64 right = R(instr->index_b).u64;
U64 result = left | right; 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); bc_log("[r%s, %llu] | [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_BITXOR_U64:{ case BC_BITXOR_U64:{
U64 left = b->registers[instr->index_a].u64; U64 left = R(instr->index_a).u64;
U64 right = b->registers[instr->index_b].u64; U64 right = R(instr->index_b).u64;
U64 result = left ^ right; 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); bc_log("[r%s, %llu] ^ [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_BITNOT_U64:{ 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 result = ~left;
U64 *dst = b->registers[instr->index_c].pointer_u64; U64 *dst = R(instr->index_c).pointer_u64;
*dst = result; *dst = result;
bc_log("~ [%llu] = [%llu]", left, result); bc_log("~ [%llu] = [%llu]", left, result);
}break; }break;
case BC_EQ_U64:{ case BC_EQ_U64:{
U64 left = b->registers[instr->index_a].u64; U64 left = R(instr->index_a).u64;
U64 right = b->registers[instr->index_b].u64; U64 right = R(instr->index_b).u64;
U64 result = left == right; 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); bc_log("[r%s, %llu] == [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_NEQ_U64:{ case BC_NEQ_U64:{
U64 left = b->registers[instr->index_a].u64; U64 left = R(instr->index_a).u64;
U64 right = b->registers[instr->index_b].u64; U64 right = R(instr->index_b).u64;
U64 result = left != right; 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); bc_log("[r%s, %llu] != [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_GT_U64:{ case BC_GT_U64:{
U64 left = b->registers[instr->index_a].u64; U64 left = R(instr->index_a).u64;
U64 right = b->registers[instr->index_b].u64; U64 right = R(instr->index_b).u64;
U64 result = left > right; 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); bc_log("[r%s, %llu] > [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_LT_U64:{ case BC_LT_U64:{
U64 left = b->registers[instr->index_a].u64; U64 left = R(instr->index_a).u64;
U64 right = b->registers[instr->index_b].u64; U64 right = R(instr->index_b).u64;
U64 result = left < right; 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); bc_log("[r%s, %llu] < [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_OR_U64:{ case BC_OR_U64:{
U64 left = b->registers[instr->index_a].u64; U64 left = R(instr->index_a).u64;
U64 right = b->registers[instr->index_b].u64; U64 right = R(instr->index_b).u64;
U64 result = left || right; 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); bc_log("[r%s, %llu] || [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_GTE_U64:{ case BC_GTE_U64:{
U64 left = b->registers[instr->index_a].u64; U64 left = R(instr->index_a).u64;
U64 right = b->registers[instr->index_b].u64; U64 right = R(instr->index_b).u64;
U64 result = left >= right; 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); bc_log("[r%s, %llu] >= [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_LTE_U64:{ case BC_LTE_U64:{
U64 left = b->registers[instr->index_a].u64; U64 left = R(instr->index_a).u64;
U64 right = b->registers[instr->index_b].u64; U64 right = R(instr->index_b).u64;
U64 result = left <= right; 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); bc_log("[r%s, %llu] <= [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_ADD_F64:{ case BC_ADD_F64:{
F64 left = b->registers[instr->index_a].f64; F64 left = R(instr->index_a).f64;
F64 right = b->registers[instr->index_b].f64; F64 right = R(instr->index_b).f64;
F64 result = left + right; 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); bc_log("[r%s, %f] + [r%s, %f] = [r%s, %f]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_SUB_F64:{ case BC_SUB_F64:{
F64 left = b->registers[instr->index_a].f64; F64 left = R(instr->index_a).f64;
F64 right = b->registers[instr->index_b].f64; F64 right = R(instr->index_b).f64;
F64 result = left - right; 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); bc_log("[r%s, %f] - [r%s, %f] = [r%s, %f]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_DIV_F64:{ case BC_DIV_F64:{
F64 left = b->registers[instr->index_a].f64; F64 left = R(instr->index_a).f64;
F64 right = b->registers[instr->index_b].f64; F64 right = R(instr->index_b).f64;
F64 result = left / right; 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); bc_log("[r%s, %f] / [r%s, %f] = [r%s, %f]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_MUL_F64:{ case BC_MUL_F64:{
F64 left = b->registers[instr->index_a].f64; F64 left = R(instr->index_a).f64;
F64 right = b->registers[instr->index_b].f64; F64 right = R(instr->index_b).f64;
F64 result = left * right; 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); bc_log("[r%s, %f] * [r%s, %f] = [r%s, %f]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_EQ_F64:{ case BC_EQ_F64:{
F64 left = b->registers[instr->index_a].f64; F64 left = R(instr->index_a).f64;
F64 right = b->registers[instr->index_b].f64; F64 right = R(instr->index_b).f64;
F64 result = left == right; 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); bc_log("[r%s, %f] == [r%s, %f] = [r%s, %f]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_NEQ_F64:{ case BC_NEQ_F64:{
F64 left = b->registers[instr->index_a].f64; F64 left = R(instr->index_a).f64;
F64 right = b->registers[instr->index_b].f64; F64 right = R(instr->index_b).f64;
F64 result = left != right; 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); bc_log("[r%s, %f] != [r%s, %f] = [r%s, %f]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_GT_F64:{ case BC_GT_F64:{
F64 left = b->registers[instr->index_a].f64; F64 left = R(instr->index_a).f64;
F64 right = b->registers[instr->index_b].f64; F64 right = R(instr->index_b).f64;
F64 result = left > right; 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); bc_log("[r%s, %f] > [r%s, %f] = [r%s, %f]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_LT_F64:{ case BC_LT_F64:{
F64 left = b->registers[instr->index_a].f64; F64 left = R(instr->index_a).f64;
F64 right = b->registers[instr->index_b].f64; F64 right = R(instr->index_b).f64;
F64 result = left < right; 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); bc_log("[r%s, %f] < [r%s, %f] = [r%s, %f]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_GTE_F64:{ case BC_GTE_F64:{
F64 left = b->registers[instr->index_a].f64; F64 left = R(instr->index_a).f64;
F64 right = b->registers[instr->index_b].f64; F64 right = R(instr->index_b).f64;
F64 result = left >= right; 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); bc_log("[r%s, %f] >= [r%s, %f] = [r%s, %f]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
case BC_LTE_F64:{ case BC_LTE_F64:{
F64 left = b->registers[instr->index_a].f64; F64 left = R(instr->index_a).f64;
F64 right = b->registers[instr->index_b].f64; F64 right = R(instr->index_b).f64;
F64 result = left <= right; 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); bc_log("[r%s, %f] <= [r%s, %f] = [r%s, %f]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
}break; }break;
// //
// *End* of switch_cases generated using code_generating_script.py // *End* of switch_cases generated using code_generating_script.py
// //

20
code_generating_script.py
View File

@@ -94,14 +94,14 @@ if True:
for size in sizes: for size in sizes:
result += f""" result += f"""
case BC_LOAD_FROM_MEMORY{size}:{{ case BC_LOAD_FROM_MEMORY{size}:{{
U{size} *load_address = b->registers[instr->index_a].pointer{size}; U{size} *load_address = R(instr->index_a).pointer_u{size};
b->registers[instr->index_c].u{size} = *load_address; 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, b->registers[instr->index_c].u{size}, b->registers[instr->index_c].u{size}, b->registers[instr->index_c].u{size}); 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; }}break;
case BC_STORE_TO_MEMORY{size}:{{ case BC_STORE_TO_MEMORY{size}:{{
U{size} *store_address = b->registers[instr->index_c].pointer{size}; U{size} *store_address = R(instr->index_c).pointer_u{size};
*store_address = b->registers[instr->index_a].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); 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; }}break;
""" """
@@ -119,9 +119,9 @@ if True:
if symbol == "~": if symbol == "~":
result += f""" result += f"""
case BC_{op_name}_{T}:{{ 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} result = {symbol}left;
{T} *dst = b->registers[instr->index_c].pointer_{t}; {T} *dst = R(instr->index_c).pointer_{t};
*dst = result; *dst = result;
bc_log("{symbol} [{sign}] = [{sign}]", left, result); bc_log("{symbol} [{sign}] = [{sign}]", left, result);
}}break; }}break;
@@ -133,10 +133,10 @@ if True:
# Binary operation # Binary operation
result += f""" result += f"""
case BC_{op_name}_{T}:{{ case BC_{op_name}_{T}:{{
{T} left = b->registers[instr->index_a].{t}; {T} left = R(instr->index_a).{t};
{T} right = b->registers[instr->index_b].{t}; {T} right = R(instr->index_b).{t};
{T} result = left {symbol} right; {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); 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; }}break;
""" """