diff --git a/bytecode_codegen.cpp b/bytecode_codegen.cpp index 7270f90..be740d7 100644 --- a/bytecode_codegen.cpp +++ b/bytecode_codegen.cpp @@ -1,16 +1,57 @@ +function Register_Index +allocate_register(Bc *b){ + if(b->free_registers.len == 0){ + Register_Index result = b->registers.addi({}); + return result; + } + + Register_Index index = b->free_registers.pop(); + b->used_registers.add(index); + return index; +} + function void +release_register(Bc *b, Register_Index reg){ + if(reg == 0) return; + + B32 found = false; + For(b->used_registers){ + if(it == reg){ + b->used_registers.unordered_remove(&it); + found = true; + break; + } + } + + assert_msg(found, "Trying to release register that is not used"); +} + + +function Register_Index bc_emit_expr(Bc *b, Ast *ast){ - if(!ast) return; + if(!ast) return REG_NULL; if(!is_flag_set(ast->flags, AST_EXPR)) compiler_error(ast->pos, "Internal compiler error: Trying to emit expression but it doesn't have appropriate flag"); switch(ast->kind){ + CASE(VALUE, Atom){ + Register_Index dst = allocate_register(b); + U64 value = bigint_as_unsigned(&node->big_int_val); + emit_load_constant_s64(b, dst, value); + return dst; + BREAK(); + } CASE(BINARY, Binary){ - + Register_Index left = bc_emit_expr(b, node->left); + Register_Index right = bc_emit_expr(b, node->right); + emit_arithmetic(b, BC_ADD_S64, left, right, left); + release_register(b, right); + return left; BREAK(); } default:{} } + return REG_NULL; } function void @@ -25,10 +66,17 @@ compile_to_bc(){ } CASE(VAR, Decl){ node->bytecode_data_position = exp_alloc(&b->memory, node->type->size, AF_ZeroMemory); - bc_emit_assign(b, node); + Register_Index index = bc_emit_expr(b, node->expr); + if(index!=REG_NULL){ + // bc_emit_store(b, ) + } + release_register(b, index); BREAK(); } default: {} } } + emit_end(b); + run_bytecode_interp(b); + destroy_bytecode_interp(b); } \ No newline at end of file diff --git a/bytecode_interpreter.cpp b/bytecode_interpreter.cpp index 9014c95..c2b601c 100644 --- a/bytecode_interpreter.cpp +++ b/bytecode_interpreter.cpp @@ -1,11 +1,16 @@ + // // Generated using code_generating_script.py // -enum Operation: U16{ + + + +enum Operation: S32{ BC_END_OF_INSTRUCTIONS, BC_POP_STACK, BC_PUSH_STACK, BC_LOAD_CONSTANT, + BC_STORE_CONSTANT, BC_LOAD_FROM_MEMORY64, BC_LOAD_FROM_MEMORY32, BC_LOAD_FROM_MEMORY16, @@ -66,6 +71,7 @@ const char *op_name[] = { "BC_POP_STACK", "BC_PUSH_STACK", "BC_LOAD_CONSTANT", + "BC_STORE_CONSTANT", "BC_LOAD_FROM_MEMORY64", "BC_LOAD_FROM_MEMORY32", "BC_LOAD_FROM_MEMORY16", @@ -126,6 +132,7 @@ const char *op_name[] = { // **End** of generated using code_generating_script.py // +typedef S32 Register_Index; union Register{ F64 f64; S64 s64; @@ -138,38 +145,39 @@ union Register{ }; enum{ + REG_NULL, REG_STACK_POINTER, - REG_INS_POINTER, + REG_STACK_BOTTOM, + REG_INSTRUCTION_POINTER, + REG_SPECIAL_COUNT, }; struct Instruction{ - U64 di; // @debug_id Operation operation; - U16 left; - union{U16 right; U16 src;}; - U16 dst; + S32 dst; + union{ + struct{ + union{S32 src; S32 a;}; + S32 b; + }; + Register constant; + }; + U32 di; // @debug_id + U32 debug_type_flag; }; -struct Instruction_Constant{ - U64 di; // @debug_id - Operation operation; - U32 dst; - Register constant; - - U64 debug_type_flag; -}; - -static_assert(sizeof(Instruction)*2 == sizeof(Instruction_Constant), "Should be double the size"); -static_assert(sizeof(Instruction) % 8 == 0,"Should be 8 bit aligned"); -static_assert(sizeof(Instruction_Constant) % 8 == 0,"Should be 8 bit aligned"); // // Bytecode interpreter context // struct Bc{ - U64 dis; // @debug_id + U32 dis; // @debug_id U8 *stack_bottom; - Register registers[256]; + + Array registers; + Array used_registers; + Array free_registers; + Arena memory; Arena instructions; Arena stack; // We reserve 4 gibs and allocate only 4 kibs to make sure we know when we @@ -179,26 +187,26 @@ struct Bc{ function Bc create_bytecode_interp(){ Bc b = {}; + + b.registers = array_make(pctx->heap, 1024); + b.free_registers = array_make(pctx->heap, 1024); + b.used_registers = array_make(pctx->heap, 1024); + { arena_init(&b.instructions, "Bytecode instructions"_s); - - // Commit - arena_push_size(&b.instructions, 16); + arena_push_size(&b.instructions, 16); // Commit arena_clear(&b.instructions); - b.registers[REG_INS_POINTER].pointer = b.instructions.memory.data; + b.registers[REG_INSTRUCTION_POINTER].pointer = b.instructions.memory.data; } { arena_init(&b.stack, "Bytecode stack"_s); - - // Setup a 4 kilobyte stack - arena_push_size(&b.stack, kib(4)); + arena_push_size(&b.stack, kib(4)); // Setup a 4 kilobyte stack b.registers[REG_STACK_POINTER].pointer = b.stack_bottom = b.stack.memory.data; } arena_init(&b.memory, "Bytecode memory"_s); - return b; } @@ -206,12 +214,19 @@ function void destroy_bytecode_interp(Bc *b){ arena_release(&b->instructions); arena_release(&b->stack); + arena_release(&b->memory); +} + +function Instruction * +new_instruction(Bc *b){ + Instruction *i = exp_alloc_type(&b->instructions, Instruction); + i->di = b->dis++; + return i; } function void emit_load_constant_f64(Bc *b, U8 dst, F64 constant){ - auto i = exp_alloc_type(&b->instructions, Instruction_Constant); - i->di = b->dis++; + auto i = new_instruction(b); i->operation = BC_LOAD_CONSTANT; i->constant.f64 = constant; i->dst = dst; @@ -220,8 +235,7 @@ emit_load_constant_f64(Bc *b, U8 dst, F64 constant){ function void emit_load_constant_s64(Bc *b, U8 dst, S64 constant){ - auto i = exp_alloc_type(&b->instructions, Instruction_Constant); - i->di = b->dis++; + auto i = new_instruction(b); i->operation = BC_LOAD_CONSTANT; i->constant.s64 = constant; i->dst = dst; @@ -230,34 +244,38 @@ emit_load_constant_s64(Bc *b, U8 dst, S64 constant){ function void emit_load_constant_u64(Bc *b, U8 dst, U64 constant){ - auto i = exp_alloc_type(&b->instructions, Instruction_Constant); - i->di = b->dis++; + auto i = new_instruction(b); i->operation = BC_LOAD_CONSTANT; i->constant.u64 = constant; i->dst = dst; i->debug_type_flag = TYPE_U64; } +function void +emit_constant_store(Bc *b, U8 *address, Register_Index src){ + auto i = new_instruction(b); + i->operation = BC_STORE_CONSTANT; + i->constant.pointer = address; + i->src = src; +} + function void emit_push(Bc *b, U8 src){ - Instruction *i = exp_alloc_type(&b->instructions, Instruction); - i->di = b->dis++; + auto i = new_instruction(b); i->operation = BC_PUSH_STACK; i->src = src; } function void emit_pop(Bc *b, U8 dst){ - Instruction *i = exp_alloc_type(&b->instructions, Instruction); - i->di = b->dis++; + auto i = new_instruction(b); i->operation = BC_POP_STACK; i->dst = dst; } function void emit_memory(Bc *b, Operation ins, U8 dst, U8 src){ - Instruction *i = exp_alloc_type(&b->instructions, Instruction); - i->di = b->dis++; + auto i = new_instruction(b); i->operation = ins; i->dst = dst; i->src = src; @@ -265,11 +283,10 @@ emit_memory(Bc *b, Operation ins, U8 dst, U8 src){ function void emit_arithmetic(Bc *b, Operation ins, U8 left, U8 right, U8 dst){ - Instruction *i = exp_alloc_type(&b->instructions, Instruction); - i->di = b->dis++; + Instruction *i = new_instruction(b); i->operation = ins; - i->left = left; - i->right = right; + i->a = left; + i->b = right; i->dst = dst; } @@ -290,9 +307,9 @@ emit_end(Bc *b){ function void run_bytecode_interp(Bc *b){ for(;;){ - auto instr = (Instruction *)b->registers[REG_INS_POINTER].pointer64; - 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); + auto instr = (Instruction *)b->registers[REG_INSTRUCTION_POINTER].pointer64; + bc_log("%llu.[%llx] - %s ", instr->di, b->registers[REG_INSTRUCTION_POINTER].pointer64, op_name[instr->operation]); + b->registers[REG_INSTRUCTION_POINTER].pointer += sizeof(Instruction); switch(instr->operation){ default:{} @@ -326,14 +343,12 @@ run_bytecode_interp(Bc *b){ }break; case BC_LOAD_CONSTANT: { - b->registers[REG_INS_POINTER].pointer+=sizeof(Instruction); // Constant is twice the size of regular Instruction - auto i = (Instruction_Constant *)instr; - b->registers[i->dst] = i->constant; + b->registers[instr->dst] = instr->constant; #if BC_LOG - switch(i->debug_type_flag){ - 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; + switch(instr->debug_type_flag){ + case TYPE_S64: bc_log("r%u(dst) [%lld]", instr->dst, instr->constant.s64); break; + case TYPE_U64: bc_log("r%u(dst) [%llu]", instr->dst, instr->constant.u64); break; + case TYPE_F64: bc_log("r%u(dst) [%f]" , instr->dst, instr->constant.f64); break; invalid_default_case; } #endif @@ -344,87 +359,87 @@ run_bytecode_interp(Bc *b){ // case BC_ADD_S64:{ - S64 left = b->registers[instr->left].s64; - S64 right = b->registers[instr->right].s64; + S64 left = b->registers[instr->a].s64; + S64 right = b->registers[instr->b].s64; 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); + bc_log("r%u + r%u = r%u => [%lld] + [%lld] = [%lld]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_SUB_S64:{ - S64 left = b->registers[instr->left].s64; - S64 right = b->registers[instr->right].s64; + S64 left = b->registers[instr->a].s64; + S64 right = b->registers[instr->b].s64; 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); + bc_log("r%u + r%u = r%u => [%lld] - [%lld] = [%lld]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_DIV_S64:{ - S64 left = b->registers[instr->left].s64; - S64 right = b->registers[instr->right].s64; + S64 left = b->registers[instr->a].s64; + S64 right = b->registers[instr->b].s64; 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); + bc_log("r%u + r%u = r%u => [%lld] / [%lld] = [%lld]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_MUL_S64:{ - S64 left = b->registers[instr->left].s64; - S64 right = b->registers[instr->right].s64; + S64 left = b->registers[instr->a].s64; + S64 right = b->registers[instr->b].s64; 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); + bc_log("r%u + r%u = r%u => [%lld] * [%lld] = [%lld]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_MOD_S64:{ - S64 left = b->registers[instr->left].s64; - S64 right = b->registers[instr->right].s64; + S64 left = b->registers[instr->a].s64; + S64 right = b->registers[instr->b].s64; 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); + bc_log("r%u + r%u = r%u => [%lld] % [%lld] = [%lld]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_SHR_S64:{ - S64 left = b->registers[instr->left].s64; - S64 right = b->registers[instr->right].s64; + S64 left = b->registers[instr->a].s64; + S64 right = b->registers[instr->b].s64; 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); + bc_log("r%u + r%u = r%u => [%lld] >> [%lld] = [%lld]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_SHL_S64:{ - S64 left = b->registers[instr->left].s64; - S64 right = b->registers[instr->right].s64; + S64 left = b->registers[instr->a].s64; + S64 right = b->registers[instr->b].s64; 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); + bc_log("r%u + r%u = r%u => [%lld] << [%lld] = [%lld]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_BITAND_S64:{ - S64 left = b->registers[instr->left].s64; - S64 right = b->registers[instr->right].s64; + S64 left = b->registers[instr->a].s64; + S64 right = b->registers[instr->b].s64; 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); + bc_log("r%u + r%u = r%u => [%lld] & [%lld] = [%lld]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_BITOR_S64:{ - S64 left = b->registers[instr->left].s64; - S64 right = b->registers[instr->right].s64; + S64 left = b->registers[instr->a].s64; + S64 right = b->registers[instr->b].s64; 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); + bc_log("r%u + r%u = r%u => [%lld] | [%lld] = [%lld]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_BITXOR_S64:{ - S64 left = b->registers[instr->left].s64; - S64 right = b->registers[instr->right].s64; + S64 left = b->registers[instr->a].s64; + S64 right = b->registers[instr->b].s64; 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); + bc_log("r%u + r%u = r%u => [%lld] ^ [%lld] = [%lld]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_BITNOT_S64:{ - S64 left = (S64)b->registers[instr->left].s64; + S64 left = (S64)b->registers[instr->a].s64; S64 result = ~left; S64 *dst = b->registers[instr->dst].pointer_s64; *dst = result; @@ -432,143 +447,143 @@ run_bytecode_interp(Bc *b){ }break; case BC_EQ_S64:{ - S64 left = b->registers[instr->left].s64; - S64 right = b->registers[instr->right].s64; + S64 left = b->registers[instr->a].s64; + S64 right = b->registers[instr->b].s64; 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); + bc_log("r%u + r%u = r%u => [%lld] == [%lld] = [%lld]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_NEQ_S64:{ - S64 left = b->registers[instr->left].s64; - S64 right = b->registers[instr->right].s64; + S64 left = b->registers[instr->a].s64; + S64 right = b->registers[instr->b].s64; 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); + bc_log("r%u + r%u = r%u => [%lld] != [%lld] = [%lld]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_GT_S64:{ - S64 left = b->registers[instr->left].s64; - S64 right = b->registers[instr->right].s64; + S64 left = b->registers[instr->a].s64; + S64 right = b->registers[instr->b].s64; 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); + bc_log("r%u + r%u = r%u => [%lld] > [%lld] = [%lld]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_LT_S64:{ - S64 left = b->registers[instr->left].s64; - S64 right = b->registers[instr->right].s64; + S64 left = b->registers[instr->a].s64; + S64 right = b->registers[instr->b].s64; 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); + bc_log("r%u + r%u = r%u => [%lld] < [%lld] = [%lld]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_OR_S64:{ - S64 left = b->registers[instr->left].s64; - S64 right = b->registers[instr->right].s64; + S64 left = b->registers[instr->a].s64; + S64 right = b->registers[instr->b].s64; 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); + bc_log("r%u + r%u = r%u => [%lld] || [%lld] = [%lld]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_GTE_S64:{ - S64 left = b->registers[instr->left].s64; - S64 right = b->registers[instr->right].s64; + S64 left = b->registers[instr->a].s64; + S64 right = b->registers[instr->b].s64; 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); + bc_log("r%u + r%u = r%u => [%lld] >= [%lld] = [%lld]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_LTE_S64:{ - S64 left = b->registers[instr->left].s64; - S64 right = b->registers[instr->right].s64; + S64 left = b->registers[instr->a].s64; + S64 right = b->registers[instr->b].s64; 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); + bc_log("r%u + r%u = r%u => [%lld] <= [%lld] = [%lld]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_ADD_U64:{ - U64 left = b->registers[instr->left].u64; - U64 right = b->registers[instr->right].u64; + U64 left = b->registers[instr->a].u64; + U64 right = b->registers[instr->b].u64; 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); + bc_log("r%u + r%u = r%u => [%llu] + [%llu] = [%llu]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_SUB_U64:{ - U64 left = b->registers[instr->left].u64; - U64 right = b->registers[instr->right].u64; + U64 left = b->registers[instr->a].u64; + U64 right = b->registers[instr->b].u64; 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); + bc_log("r%u + r%u = r%u => [%llu] - [%llu] = [%llu]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_DIV_U64:{ - U64 left = b->registers[instr->left].u64; - U64 right = b->registers[instr->right].u64; + U64 left = b->registers[instr->a].u64; + U64 right = b->registers[instr->b].u64; 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); + bc_log("r%u + r%u = r%u => [%llu] / [%llu] = [%llu]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_MUL_U64:{ - U64 left = b->registers[instr->left].u64; - U64 right = b->registers[instr->right].u64; + U64 left = b->registers[instr->a].u64; + U64 right = b->registers[instr->b].u64; 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); + bc_log("r%u + r%u = r%u => [%llu] * [%llu] = [%llu]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_MOD_U64:{ - U64 left = b->registers[instr->left].u64; - U64 right = b->registers[instr->right].u64; + U64 left = b->registers[instr->a].u64; + U64 right = b->registers[instr->b].u64; 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); + bc_log("r%u + r%u = r%u => [%llu] % [%llu] = [%llu]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_SHR_U64:{ - U64 left = b->registers[instr->left].u64; - U64 right = b->registers[instr->right].u64; + U64 left = b->registers[instr->a].u64; + U64 right = b->registers[instr->b].u64; 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); + bc_log("r%u + r%u = r%u => [%llu] >> [%llu] = [%llu]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_SHL_U64:{ - U64 left = b->registers[instr->left].u64; - U64 right = b->registers[instr->right].u64; + U64 left = b->registers[instr->a].u64; + U64 right = b->registers[instr->b].u64; 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); + bc_log("r%u + r%u = r%u => [%llu] << [%llu] = [%llu]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_BITAND_U64:{ - U64 left = b->registers[instr->left].u64; - U64 right = b->registers[instr->right].u64; + U64 left = b->registers[instr->a].u64; + U64 right = b->registers[instr->b].u64; 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); + bc_log("r%u + r%u = r%u => [%llu] & [%llu] = [%llu]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_BITOR_U64:{ - U64 left = b->registers[instr->left].u64; - U64 right = b->registers[instr->right].u64; + U64 left = b->registers[instr->a].u64; + U64 right = b->registers[instr->b].u64; 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); + bc_log("r%u + r%u = r%u => [%llu] | [%llu] = [%llu]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_BITXOR_U64:{ - U64 left = b->registers[instr->left].u64; - U64 right = b->registers[instr->right].u64; + U64 left = b->registers[instr->a].u64; + U64 right = b->registers[instr->b].u64; 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); + bc_log("r%u + r%u = r%u => [%llu] ^ [%llu] = [%llu]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_BITNOT_U64:{ - U64 left = (U64)b->registers[instr->left].u64; + U64 left = (U64)b->registers[instr->a].u64; U64 result = ~left; U64 *dst = b->registers[instr->dst].pointer_u64; *dst = result; @@ -576,139 +591,139 @@ run_bytecode_interp(Bc *b){ }break; case BC_EQ_U64:{ - U64 left = b->registers[instr->left].u64; - U64 right = b->registers[instr->right].u64; + U64 left = b->registers[instr->a].u64; + U64 right = b->registers[instr->b].u64; 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); + bc_log("r%u + r%u = r%u => [%llu] == [%llu] = [%llu]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_NEQ_U64:{ - U64 left = b->registers[instr->left].u64; - U64 right = b->registers[instr->right].u64; + U64 left = b->registers[instr->a].u64; + U64 right = b->registers[instr->b].u64; 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); + bc_log("r%u + r%u = r%u => [%llu] != [%llu] = [%llu]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_GT_U64:{ - U64 left = b->registers[instr->left].u64; - U64 right = b->registers[instr->right].u64; + U64 left = b->registers[instr->a].u64; + U64 right = b->registers[instr->b].u64; 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); + bc_log("r%u + r%u = r%u => [%llu] > [%llu] = [%llu]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_LT_U64:{ - U64 left = b->registers[instr->left].u64; - U64 right = b->registers[instr->right].u64; + U64 left = b->registers[instr->a].u64; + U64 right = b->registers[instr->b].u64; 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); + bc_log("r%u + r%u = r%u => [%llu] < [%llu] = [%llu]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_OR_U64:{ - U64 left = b->registers[instr->left].u64; - U64 right = b->registers[instr->right].u64; + U64 left = b->registers[instr->a].u64; + U64 right = b->registers[instr->b].u64; 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); + bc_log("r%u + r%u = r%u => [%llu] || [%llu] = [%llu]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_GTE_U64:{ - U64 left = b->registers[instr->left].u64; - U64 right = b->registers[instr->right].u64; + U64 left = b->registers[instr->a].u64; + U64 right = b->registers[instr->b].u64; 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); + bc_log("r%u + r%u = r%u => [%llu] >= [%llu] = [%llu]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_LTE_U64:{ - U64 left = b->registers[instr->left].u64; - U64 right = b->registers[instr->right].u64; + U64 left = b->registers[instr->a].u64; + U64 right = b->registers[instr->b].u64; 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); + bc_log("r%u + r%u = r%u => [%llu] <= [%llu] = [%llu]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_ADD_F64:{ - F64 left = b->registers[instr->left].f64; - F64 right = b->registers[instr->right].f64; + F64 left = b->registers[instr->a].f64; + F64 right = b->registers[instr->b].f64; 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); + bc_log("r%u + r%u = r%u => [%f] + [%f] = [%f]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_SUB_F64:{ - F64 left = b->registers[instr->left].f64; - F64 right = b->registers[instr->right].f64; + F64 left = b->registers[instr->a].f64; + F64 right = b->registers[instr->b].f64; 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); + bc_log("r%u + r%u = r%u => [%f] - [%f] = [%f]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_DIV_F64:{ - F64 left = b->registers[instr->left].f64; - F64 right = b->registers[instr->right].f64; + F64 left = b->registers[instr->a].f64; + F64 right = b->registers[instr->b].f64; 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); + bc_log("r%u + r%u = r%u => [%f] / [%f] = [%f]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_MUL_F64:{ - F64 left = b->registers[instr->left].f64; - F64 right = b->registers[instr->right].f64; + F64 left = b->registers[instr->a].f64; + F64 right = b->registers[instr->b].f64; 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); + bc_log("r%u + r%u = r%u => [%f] * [%f] = [%f]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_EQ_F64:{ - F64 left = b->registers[instr->left].f64; - F64 right = b->registers[instr->right].f64; + F64 left = b->registers[instr->a].f64; + F64 right = b->registers[instr->b].f64; 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); + bc_log("r%u + r%u = r%u => [%f] == [%f] = [%f]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_NEQ_F64:{ - F64 left = b->registers[instr->left].f64; - F64 right = b->registers[instr->right].f64; + F64 left = b->registers[instr->a].f64; + F64 right = b->registers[instr->b].f64; 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); + bc_log("r%u + r%u = r%u => [%f] != [%f] = [%f]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_GT_F64:{ - F64 left = b->registers[instr->left].f64; - F64 right = b->registers[instr->right].f64; + F64 left = b->registers[instr->a].f64; + F64 right = b->registers[instr->b].f64; 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); + bc_log("r%u + r%u = r%u => [%f] > [%f] = [%f]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_LT_F64:{ - F64 left = b->registers[instr->left].f64; - F64 right = b->registers[instr->right].f64; + F64 left = b->registers[instr->a].f64; + F64 right = b->registers[instr->b].f64; 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); + bc_log("r%u + r%u = r%u => [%f] < [%f] = [%f]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_GTE_F64:{ - F64 left = b->registers[instr->left].f64; - F64 right = b->registers[instr->right].f64; + F64 left = b->registers[instr->a].f64; + F64 right = b->registers[instr->b].f64; 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); + bc_log("r%u + r%u = r%u => [%f] >= [%f] = [%f]", instr->a, instr->b, instr->dst, left, right, result); }break; case BC_LTE_F64:{ - F64 left = b->registers[instr->left].f64; - F64 right = b->registers[instr->right].f64; + F64 left = b->registers[instr->a].f64; + F64 right = b->registers[instr->b].f64; 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); + bc_log("r%u + r%u = r%u => [%f] <= [%f] = [%f]", instr->a, instr->b, instr->dst, left, right, result); }break; // @@ -724,11 +739,11 @@ run_bytecode_interp(Bc *b){ function void test_interpreter(){ Bc b = create_bytecode_interp(); - emit_load_constant_f64(&b, 2, 100.32); - emit_load_constant_f64(&b, 3, 200.68); - emit_arithmetic(&b, BC_ADD_F64, 2, 3, 4); - emit_push(&b, 4); - emit_pop(&b, 5); + emit_load_constant_f64(&b, 3, 100.32); + emit_load_constant_f64(&b, 4, 200.68); + emit_arithmetic(&b, BC_ADD_F64, 3, 4, 3); + emit_push(&b, 3); + emit_pop(&b, 3); emit_end(&b); run_bytecode_interp(&b); destroy_bytecode_interp(&b); diff --git a/code_generating_script.py b/code_generating_script.py index 3824781..4eb3e8e 100644 --- a/code_generating_script.py +++ b/code_generating_script.py @@ -30,6 +30,7 @@ if False: enum_members.append("BC_POP_STACK") enum_members.append("BC_PUSH_STACK") enum_members.append("BC_LOAD_CONSTANT") + enum_members.append("BC_STORE_CONSTANT") load_store = ["LOAD_FROM_MEMORY", "STORE_TO_MEMORY"] for op in load_store: @@ -70,7 +71,7 @@ if True: if symbol == "~": result += f""" case BC_{op_name}_{T}:{{ - {T} left = ({T})b->registers[instr->left].{t}; + {T} left = ({T})b->registers[instr->a].{t}; {T} result = {symbol}left; {T} *dst = b->registers[instr->dst].pointer_{t}; *dst = result; @@ -84,11 +85,11 @@ if True: # Binary operation result += f""" case BC_{op_name}_{T}:{{ - {T} left = b->registers[instr->left].{t}; - {T} right = b->registers[instr->right].{t}; + {T} left = b->registers[instr->a].{t}; + {T} right = b->registers[instr->b].{t}; {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); + bc_log("r%u + r%u = r%u => [{sign}] {symbol} [{sign}] = [{sign}]", instr->a, instr->b, instr->dst, left, right, result); }}break; """ ################################ diff --git a/main.cpp b/main.cpp index efc39c7..5aa469e 100644 --- a/main.cpp +++ b/main.cpp @@ -177,8 +177,6 @@ int main(int argument_count, char **arguments){ test_string_builder(); test_intern_table(); - test_interpreter(); - emit_line_directives = true; String program_name = "vm.kl"_s; if(argument_count > 1){