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

Reworking VM into infinite stack machine

Browse Source
This commit is contained in:
Krzosa Karol
2022-06-21 23:13:07 +02:00
parent 2c3a8dc764
commit eee9e24cfc
4 changed files with 264 additions and 202 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
bytecode_codegen.cpp
View File

@@ -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 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){ bc_emit_expr(Bc *b, Ast *ast){
if(!ast) return; if(!ast) return REG_NULL;
if(!is_flag_set(ast->flags, AST_EXPR)) 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"); compiler_error(ast->pos, "Internal compiler error: Trying to emit expression but it doesn't have appropriate flag");
switch(ast->kind){ 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){ 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(); BREAK();
} }
default:{} default:{}
} }
return REG_NULL;
} }
function void function void
@@ -25,10 +66,17 @@ compile_to_bc(){
} }
CASE(VAR, Decl){ CASE(VAR, Decl){
node->bytecode_data_position = exp_alloc(&b->memory, node->type->size, AF_ZeroMemory); 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(); BREAK();
} }
default: {} default: {}
} }
} }
emit_end(b);
run_bytecode_interp(b);
destroy_bytecode_interp(b);
} }

399
bytecode_interpreter.cpp
View File

@@ -1,11 +1,16 @@
// //
// Generated using code_generating_script.py // Generated using code_generating_script.py
// //
enum Operation: U16{
enum Operation: S32{
BC_END_OF_INSTRUCTIONS, BC_END_OF_INSTRUCTIONS,
BC_POP_STACK, BC_POP_STACK,
BC_PUSH_STACK, BC_PUSH_STACK,
BC_LOAD_CONSTANT, BC_LOAD_CONSTANT,
BC_STORE_CONSTANT,
BC_LOAD_FROM_MEMORY64, BC_LOAD_FROM_MEMORY64,
BC_LOAD_FROM_MEMORY32, BC_LOAD_FROM_MEMORY32,
BC_LOAD_FROM_MEMORY16, BC_LOAD_FROM_MEMORY16,
@@ -66,6 +71,7 @@ const char *op_name[] = {
"BC_POP_STACK", "BC_POP_STACK",
"BC_PUSH_STACK", "BC_PUSH_STACK",
"BC_LOAD_CONSTANT", "BC_LOAD_CONSTANT",
"BC_STORE_CONSTANT",
"BC_LOAD_FROM_MEMORY64", "BC_LOAD_FROM_MEMORY64",
"BC_LOAD_FROM_MEMORY32", "BC_LOAD_FROM_MEMORY32",
"BC_LOAD_FROM_MEMORY16", "BC_LOAD_FROM_MEMORY16",
@@ -126,6 +132,7 @@ const char *op_name[] = {
// **End** of generated using code_generating_script.py // **End** of generated using code_generating_script.py
// //
typedef S32 Register_Index;
union Register{ union Register{
F64 f64; F64 f64;
S64 s64; S64 s64;
@@ -138,38 +145,39 @@ union Register{
}; };
enum{ enum{
REG_NULL,
REG_STACK_POINTER, REG_STACK_POINTER,
REG_INS_POINTER, REG_STACK_BOTTOM,
REG_INSTRUCTION_POINTER,
REG_SPECIAL_COUNT,
}; };
struct Instruction{ struct Instruction{
U64 di; // @debug_id
Operation operation; Operation operation;
U16 left; S32 dst;
union{U16 right; U16 src;}; union{
U16 dst; struct{
union{S32 src; S32 a;};
S32 b;
}; };
struct Instruction_Constant{
U64 di; // @debug_id
Operation operation;
U32 dst;
Register constant; Register constant;
U64 debug_type_flag;
}; };
static_assert(sizeof(Instruction)*2 == sizeof(Instruction_Constant), "Should be double the size"); U32 di; // @debug_id
static_assert(sizeof(Instruction) % 8 == 0,"Should be 8 bit aligned"); U32 debug_type_flag;
static_assert(sizeof(Instruction_Constant) % 8 == 0,"Should be 8 bit aligned"); };
// //
// Bytecode interpreter context // Bytecode interpreter context
// //
struct Bc{ struct Bc{
U64 dis; // @debug_id U32 dis; // @debug_id
U8 *stack_bottom; U8 *stack_bottom;
Register registers[256];
Array<Register> registers;
Array<Register_Index> used_registers;
Array<Register_Index> free_registers;
Arena memory; Arena memory;
Arena instructions; Arena instructions;
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
@@ -179,26 +187,26 @@ struct Bc{
function Bc function Bc
create_bytecode_interp(){ create_bytecode_interp(){
Bc b = {}; Bc b = {};
b.registers = array_make<Register>(pctx->heap, 1024);
b.free_registers = array_make<Register_Index>(pctx->heap, 1024);
b.used_registers = array_make<Register_Index>(pctx->heap, 1024);
{ {
arena_init(&b.instructions, "Bytecode instructions"_s); arena_init(&b.instructions, "Bytecode instructions"_s);
arena_push_size(&b.instructions, 16); // Commit
// Commit
arena_push_size(&b.instructions, 16);
arena_clear(&b.instructions); 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); arena_init(&b.stack, "Bytecode stack"_s);
arena_push_size(&b.stack, kib(4)); // Setup a 4 kilobyte stack
// Setup a 4 kilobyte stack
arena_push_size(&b.stack, kib(4));
b.registers[REG_STACK_POINTER].pointer = b.stack_bottom = b.stack.memory.data; b.registers[REG_STACK_POINTER].pointer = b.stack_bottom = b.stack.memory.data;
} }
arena_init(&b.memory, "Bytecode memory"_s); arena_init(&b.memory, "Bytecode memory"_s);
return b; return b;
} }
@@ -206,12 +214,19 @@ function void
destroy_bytecode_interp(Bc *b){ destroy_bytecode_interp(Bc *b){
arena_release(&b->instructions); arena_release(&b->instructions);
arena_release(&b->stack); 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 function void
emit_load_constant_f64(Bc *b, U8 dst, F64 constant){ emit_load_constant_f64(Bc *b, U8 dst, F64 constant){
auto i = exp_alloc_type(&b->instructions, Instruction_Constant); auto i = new_instruction(b);
i->di = b->dis++;
i->operation = BC_LOAD_CONSTANT; i->operation = BC_LOAD_CONSTANT;
i->constant.f64 = constant; i->constant.f64 = constant;
i->dst = dst; i->dst = dst;
@@ -220,8 +235,7 @@ emit_load_constant_f64(Bc *b, U8 dst, F64 constant){
function void function void
emit_load_constant_s64(Bc *b, U8 dst, S64 constant){ emit_load_constant_s64(Bc *b, U8 dst, S64 constant){
auto i = exp_alloc_type(&b->instructions, Instruction_Constant); auto i = new_instruction(b);
i->di = b->dis++;
i->operation = BC_LOAD_CONSTANT; i->operation = BC_LOAD_CONSTANT;
i->constant.s64 = constant; i->constant.s64 = constant;
i->dst = dst; i->dst = dst;
@@ -230,34 +244,38 @@ emit_load_constant_s64(Bc *b, U8 dst, S64 constant){
function void function void
emit_load_constant_u64(Bc *b, U8 dst, U64 constant){ emit_load_constant_u64(Bc *b, U8 dst, U64 constant){
auto i = exp_alloc_type(&b->instructions, Instruction_Constant); auto i = new_instruction(b);
i->di = b->dis++;
i->operation = BC_LOAD_CONSTANT; i->operation = BC_LOAD_CONSTANT;
i->constant.u64 = constant; i->constant.u64 = constant;
i->dst = dst; i->dst = dst;
i->debug_type_flag = TYPE_U64; 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 function void
emit_push(Bc *b, U8 src){ emit_push(Bc *b, U8 src){
Instruction *i = exp_alloc_type(&b->instructions, Instruction); auto i = new_instruction(b);
i->di = b->dis++;
i->operation = BC_PUSH_STACK; i->operation = BC_PUSH_STACK;
i->src = src; i->src = src;
} }
function void function void
emit_pop(Bc *b, U8 dst){ emit_pop(Bc *b, U8 dst){
Instruction *i = exp_alloc_type(&b->instructions, Instruction); auto i = new_instruction(b);
i->di = b->dis++;
i->operation = BC_POP_STACK; i->operation = BC_POP_STACK;
i->dst = dst; i->dst = dst;
} }
function void function void
emit_memory(Bc *b, Operation ins, U8 dst, U8 src){ emit_memory(Bc *b, Operation ins, U8 dst, U8 src){
Instruction *i = exp_alloc_type(&b->instructions, Instruction); auto i = new_instruction(b);
i->di = b->dis++;
i->operation = ins; i->operation = ins;
i->dst = dst; i->dst = dst;
i->src = src; i->src = src;
@@ -265,11 +283,10 @@ emit_memory(Bc *b, Operation ins, U8 dst, U8 src){
function void function void
emit_arithmetic(Bc *b, Operation ins, U8 left, U8 right, U8 dst){ emit_arithmetic(Bc *b, Operation ins, U8 left, U8 right, U8 dst){
Instruction *i = exp_alloc_type(&b->instructions, Instruction); Instruction *i = new_instruction(b);
i->di = b->dis++;
i->operation = ins; i->operation = ins;
i->left = left; i->a = left;
i->right = right; i->b = right;
i->dst = dst; i->dst = dst;
} }
@@ -290,9 +307,9 @@ emit_end(Bc *b){
function void function void
run_bytecode_interp(Bc *b){ run_bytecode_interp(Bc *b){
for(;;){ for(;;){
auto instr = (Instruction *)b->registers[REG_INS_POINTER].pointer64; auto instr = (Instruction *)b->registers[REG_INSTRUCTION_POINTER].pointer64;
bc_log("%llu.[%llx] - %s ", instr->di, b->registers[REG_INS_POINTER].pointer64, op_name[instr->operation]); bc_log("%llu.[%llx] - %s ", instr->di, b->registers[REG_INSTRUCTION_POINTER].pointer64, op_name[instr->operation]);
b->registers[REG_INS_POINTER].pointer += sizeof(Instruction); b->registers[REG_INSTRUCTION_POINTER].pointer += sizeof(Instruction);
switch(instr->operation){ switch(instr->operation){
default:{} default:{}
@@ -326,14 +343,12 @@ run_bytecode_interp(Bc *b){
}break; }break;
case BC_LOAD_CONSTANT: { case BC_LOAD_CONSTANT: {
b->registers[REG_INS_POINTER].pointer+=sizeof(Instruction); // Constant is twice the size of regular Instruction b->registers[instr->dst] = instr->constant;
auto i = (Instruction_Constant *)instr;
b->registers[i->dst] = i->constant;
#if BC_LOG #if BC_LOG
switch(i->debug_type_flag){ switch(instr->debug_type_flag){
case TYPE_S64: bc_log("r%u(dst) [%lld]", i->dst, i->constant.s64); break; case TYPE_S64: bc_log("r%u(dst) [%lld]", instr->dst, instr->constant.s64); break;
case TYPE_U64: bc_log("r%u(dst) [%llu]", i->dst, i->constant.u64); 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]" , i->dst, i->constant.f64); break; case TYPE_F64: bc_log("r%u(dst) [%f]" , instr->dst, instr->constant.f64); break;
invalid_default_case; invalid_default_case;
} }
#endif #endif
@@ -344,87 +359,87 @@ run_bytecode_interp(Bc *b){
// //
case BC_ADD_S64:{ case BC_ADD_S64:{
S64 left = b->registers[instr->left].s64; S64 left = b->registers[instr->a].s64;
S64 right = b->registers[instr->right].s64; S64 right = b->registers[instr->b].s64;
S64 result = left + right; S64 result = left + right;
b->registers[instr->dst].s64 = result; 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; }break;
case BC_SUB_S64:{ case BC_SUB_S64:{
S64 left = b->registers[instr->left].s64; S64 left = b->registers[instr->a].s64;
S64 right = b->registers[instr->right].s64; S64 right = b->registers[instr->b].s64;
S64 result = left - right; S64 result = left - right;
b->registers[instr->dst].s64 = result; 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; }break;
case BC_DIV_S64:{ case BC_DIV_S64:{
S64 left = b->registers[instr->left].s64; S64 left = b->registers[instr->a].s64;
S64 right = b->registers[instr->right].s64; S64 right = b->registers[instr->b].s64;
S64 result = left / right; S64 result = left / right;
b->registers[instr->dst].s64 = result; 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; }break;
case BC_MUL_S64:{ case BC_MUL_S64:{
S64 left = b->registers[instr->left].s64; S64 left = b->registers[instr->a].s64;
S64 right = b->registers[instr->right].s64; S64 right = b->registers[instr->b].s64;
S64 result = left * right; S64 result = left * right;
b->registers[instr->dst].s64 = result; 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; }break;
case BC_MOD_S64:{ case BC_MOD_S64:{
S64 left = b->registers[instr->left].s64; S64 left = b->registers[instr->a].s64;
S64 right = b->registers[instr->right].s64; S64 right = b->registers[instr->b].s64;
S64 result = left % right; S64 result = left % right;
b->registers[instr->dst].s64 = result; 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; }break;
case BC_SHR_S64:{ case BC_SHR_S64:{
S64 left = b->registers[instr->left].s64; S64 left = b->registers[instr->a].s64;
S64 right = b->registers[instr->right].s64; S64 right = b->registers[instr->b].s64;
S64 result = left >> right; S64 result = left >> right;
b->registers[instr->dst].s64 = result; 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; }break;
case BC_SHL_S64:{ case BC_SHL_S64:{
S64 left = b->registers[instr->left].s64; S64 left = b->registers[instr->a].s64;
S64 right = b->registers[instr->right].s64; S64 right = b->registers[instr->b].s64;
S64 result = left << right; S64 result = left << right;
b->registers[instr->dst].s64 = result; 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; }break;
case BC_BITAND_S64:{ case BC_BITAND_S64:{
S64 left = b->registers[instr->left].s64; S64 left = b->registers[instr->a].s64;
S64 right = b->registers[instr->right].s64; S64 right = b->registers[instr->b].s64;
S64 result = left & right; S64 result = left & right;
b->registers[instr->dst].s64 = result; 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; }break;
case BC_BITOR_S64:{ case BC_BITOR_S64:{
S64 left = b->registers[instr->left].s64; S64 left = b->registers[instr->a].s64;
S64 right = b->registers[instr->right].s64; S64 right = b->registers[instr->b].s64;
S64 result = left | right; S64 result = left | right;
b->registers[instr->dst].s64 = result; 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; }break;
case BC_BITXOR_S64:{ case BC_BITXOR_S64:{
S64 left = b->registers[instr->left].s64; S64 left = b->registers[instr->a].s64;
S64 right = b->registers[instr->right].s64; S64 right = b->registers[instr->b].s64;
S64 result = left ^ right; S64 result = left ^ right;
b->registers[instr->dst].s64 = result; 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; }break;
case BC_BITNOT_S64:{ case BC_BITNOT_S64:{
S64 left = (S64)b->registers[instr->left].s64; S64 left = (S64)b->registers[instr->a].s64;
S64 result = ~left; S64 result = ~left;
S64 *dst = b->registers[instr->dst].pointer_s64; S64 *dst = b->registers[instr->dst].pointer_s64;
*dst = result; *dst = result;
@@ -432,143 +447,143 @@ run_bytecode_interp(Bc *b){
}break; }break;
case BC_EQ_S64:{ case BC_EQ_S64:{
S64 left = b->registers[instr->left].s64; S64 left = b->registers[instr->a].s64;
S64 right = b->registers[instr->right].s64; S64 right = b->registers[instr->b].s64;
S64 result = left == right; S64 result = left == right;
b->registers[instr->dst].s64 = result; 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; }break;
case BC_NEQ_S64:{ case BC_NEQ_S64:{
S64 left = b->registers[instr->left].s64; S64 left = b->registers[instr->a].s64;
S64 right = b->registers[instr->right].s64; S64 right = b->registers[instr->b].s64;
S64 result = left != right; S64 result = left != right;
b->registers[instr->dst].s64 = result; 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; }break;
case BC_GT_S64:{ case BC_GT_S64:{
S64 left = b->registers[instr->left].s64; S64 left = b->registers[instr->a].s64;
S64 right = b->registers[instr->right].s64; S64 right = b->registers[instr->b].s64;
S64 result = left > right; S64 result = left > right;
b->registers[instr->dst].s64 = result; 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; }break;
case BC_LT_S64:{ case BC_LT_S64:{
S64 left = b->registers[instr->left].s64; S64 left = b->registers[instr->a].s64;
S64 right = b->registers[instr->right].s64; S64 right = b->registers[instr->b].s64;
S64 result = left < right; S64 result = left < right;
b->registers[instr->dst].s64 = result; 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; }break;
case BC_OR_S64:{ case BC_OR_S64:{
S64 left = b->registers[instr->left].s64; S64 left = b->registers[instr->a].s64;
S64 right = b->registers[instr->right].s64; S64 right = b->registers[instr->b].s64;
S64 result = left || right; S64 result = left || right;
b->registers[instr->dst].s64 = result; 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; }break;
case BC_GTE_S64:{ case BC_GTE_S64:{
S64 left = b->registers[instr->left].s64; S64 left = b->registers[instr->a].s64;
S64 right = b->registers[instr->right].s64; S64 right = b->registers[instr->b].s64;
S64 result = left >= right; S64 result = left >= right;
b->registers[instr->dst].s64 = result; 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; }break;
case BC_LTE_S64:{ case BC_LTE_S64:{
S64 left = b->registers[instr->left].s64; S64 left = b->registers[instr->a].s64;
S64 right = b->registers[instr->right].s64; S64 right = b->registers[instr->b].s64;
S64 result = left <= right; S64 result = left <= right;
b->registers[instr->dst].s64 = result; 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; }break;
case BC_ADD_U64:{ case BC_ADD_U64:{
U64 left = b->registers[instr->left].u64; U64 left = b->registers[instr->a].u64;
U64 right = b->registers[instr->right].u64; U64 right = b->registers[instr->b].u64;
U64 result = left + right; U64 result = left + right;
b->registers[instr->dst].u64 = result; 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; }break;
case BC_SUB_U64:{ case BC_SUB_U64:{
U64 left = b->registers[instr->left].u64; U64 left = b->registers[instr->a].u64;
U64 right = b->registers[instr->right].u64; U64 right = b->registers[instr->b].u64;
U64 result = left - right; U64 result = left - right;
b->registers[instr->dst].u64 = result; 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; }break;
case BC_DIV_U64:{ case BC_DIV_U64:{
U64 left = b->registers[instr->left].u64; U64 left = b->registers[instr->a].u64;
U64 right = b->registers[instr->right].u64; U64 right = b->registers[instr->b].u64;
U64 result = left / right; U64 result = left / right;
b->registers[instr->dst].u64 = result; 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; }break;
case BC_MUL_U64:{ case BC_MUL_U64:{
U64 left = b->registers[instr->left].u64; U64 left = b->registers[instr->a].u64;
U64 right = b->registers[instr->right].u64; U64 right = b->registers[instr->b].u64;
U64 result = left * right; U64 result = left * right;
b->registers[instr->dst].u64 = result; 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; }break;
case BC_MOD_U64:{ case BC_MOD_U64:{
U64 left = b->registers[instr->left].u64; U64 left = b->registers[instr->a].u64;
U64 right = b->registers[instr->right].u64; U64 right = b->registers[instr->b].u64;
U64 result = left % right; U64 result = left % right;
b->registers[instr->dst].u64 = result; 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; }break;
case BC_SHR_U64:{ case BC_SHR_U64:{
U64 left = b->registers[instr->left].u64; U64 left = b->registers[instr->a].u64;
U64 right = b->registers[instr->right].u64; U64 right = b->registers[instr->b].u64;
U64 result = left >> right; U64 result = left >> right;
b->registers[instr->dst].u64 = result; 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; }break;
case BC_SHL_U64:{ case BC_SHL_U64:{
U64 left = b->registers[instr->left].u64; U64 left = b->registers[instr->a].u64;
U64 right = b->registers[instr->right].u64; U64 right = b->registers[instr->b].u64;
U64 result = left << right; U64 result = left << right;
b->registers[instr->dst].u64 = result; 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; }break;
case BC_BITAND_U64:{ case BC_BITAND_U64:{
U64 left = b->registers[instr->left].u64; U64 left = b->registers[instr->a].u64;
U64 right = b->registers[instr->right].u64; U64 right = b->registers[instr->b].u64;
U64 result = left & right; U64 result = left & right;
b->registers[instr->dst].u64 = result; 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; }break;
case BC_BITOR_U64:{ case BC_BITOR_U64:{
U64 left = b->registers[instr->left].u64; U64 left = b->registers[instr->a].u64;
U64 right = b->registers[instr->right].u64; U64 right = b->registers[instr->b].u64;
U64 result = left | right; U64 result = left | right;
b->registers[instr->dst].u64 = result; 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; }break;
case BC_BITXOR_U64:{ case BC_BITXOR_U64:{
U64 left = b->registers[instr->left].u64; U64 left = b->registers[instr->a].u64;
U64 right = b->registers[instr->right].u64; U64 right = b->registers[instr->b].u64;
U64 result = left ^ right; U64 result = left ^ right;
b->registers[instr->dst].u64 = result; 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; }break;
case BC_BITNOT_U64:{ case BC_BITNOT_U64:{
U64 left = (U64)b->registers[instr->left].u64; U64 left = (U64)b->registers[instr->a].u64;
U64 result = ~left; U64 result = ~left;
U64 *dst = b->registers[instr->dst].pointer_u64; U64 *dst = b->registers[instr->dst].pointer_u64;
*dst = result; *dst = result;
@@ -576,139 +591,139 @@ run_bytecode_interp(Bc *b){
}break; }break;
case BC_EQ_U64:{ case BC_EQ_U64:{
U64 left = b->registers[instr->left].u64; U64 left = b->registers[instr->a].u64;
U64 right = b->registers[instr->right].u64; U64 right = b->registers[instr->b].u64;
U64 result = left == right; U64 result = left == right;
b->registers[instr->dst].u64 = result; 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; }break;
case BC_NEQ_U64:{ case BC_NEQ_U64:{
U64 left = b->registers[instr->left].u64; U64 left = b->registers[instr->a].u64;
U64 right = b->registers[instr->right].u64; U64 right = b->registers[instr->b].u64;
U64 result = left != right; U64 result = left != right;
b->registers[instr->dst].u64 = result; 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; }break;
case BC_GT_U64:{ case BC_GT_U64:{
U64 left = b->registers[instr->left].u64; U64 left = b->registers[instr->a].u64;
U64 right = b->registers[instr->right].u64; U64 right = b->registers[instr->b].u64;
U64 result = left > right; U64 result = left > right;
b->registers[instr->dst].u64 = result; 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; }break;
case BC_LT_U64:{ case BC_LT_U64:{
U64 left = b->registers[instr->left].u64; U64 left = b->registers[instr->a].u64;
U64 right = b->registers[instr->right].u64; U64 right = b->registers[instr->b].u64;
U64 result = left < right; U64 result = left < right;
b->registers[instr->dst].u64 = result; 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; }break;
case BC_OR_U64:{ case BC_OR_U64:{
U64 left = b->registers[instr->left].u64; U64 left = b->registers[instr->a].u64;
U64 right = b->registers[instr->right].u64; U64 right = b->registers[instr->b].u64;
U64 result = left || right; U64 result = left || right;
b->registers[instr->dst].u64 = result; 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; }break;
case BC_GTE_U64:{ case BC_GTE_U64:{
U64 left = b->registers[instr->left].u64; U64 left = b->registers[instr->a].u64;
U64 right = b->registers[instr->right].u64; U64 right = b->registers[instr->b].u64;
U64 result = left >= right; U64 result = left >= right;
b->registers[instr->dst].u64 = result; 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; }break;
case BC_LTE_U64:{ case BC_LTE_U64:{
U64 left = b->registers[instr->left].u64; U64 left = b->registers[instr->a].u64;
U64 right = b->registers[instr->right].u64; U64 right = b->registers[instr->b].u64;
U64 result = left <= right; U64 result = left <= right;
b->registers[instr->dst].u64 = result; 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; }break;
case BC_ADD_F64:{ case BC_ADD_F64:{
F64 left = b->registers[instr->left].f64; F64 left = b->registers[instr->a].f64;
F64 right = b->registers[instr->right].f64; F64 right = b->registers[instr->b].f64;
F64 result = left + right; F64 result = left + right;
b->registers[instr->dst].f64 = result; 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; }break;
case BC_SUB_F64:{ case BC_SUB_F64:{
F64 left = b->registers[instr->left].f64; F64 left = b->registers[instr->a].f64;
F64 right = b->registers[instr->right].f64; F64 right = b->registers[instr->b].f64;
F64 result = left - right; F64 result = left - right;
b->registers[instr->dst].f64 = result; 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; }break;
case BC_DIV_F64:{ case BC_DIV_F64:{
F64 left = b->registers[instr->left].f64; F64 left = b->registers[instr->a].f64;
F64 right = b->registers[instr->right].f64; F64 right = b->registers[instr->b].f64;
F64 result = left / right; F64 result = left / right;
b->registers[instr->dst].f64 = result; 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; }break;
case BC_MUL_F64:{ case BC_MUL_F64:{
F64 left = b->registers[instr->left].f64; F64 left = b->registers[instr->a].f64;
F64 right = b->registers[instr->right].f64; F64 right = b->registers[instr->b].f64;
F64 result = left * right; F64 result = left * right;
b->registers[instr->dst].f64 = result; 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; }break;
case BC_EQ_F64:{ case BC_EQ_F64:{
F64 left = b->registers[instr->left].f64; F64 left = b->registers[instr->a].f64;
F64 right = b->registers[instr->right].f64; F64 right = b->registers[instr->b].f64;
F64 result = left == right; F64 result = left == right;
b->registers[instr->dst].f64 = result; 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; }break;
case BC_NEQ_F64:{ case BC_NEQ_F64:{
F64 left = b->registers[instr->left].f64; F64 left = b->registers[instr->a].f64;
F64 right = b->registers[instr->right].f64; F64 right = b->registers[instr->b].f64;
F64 result = left != right; F64 result = left != right;
b->registers[instr->dst].f64 = result; 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; }break;
case BC_GT_F64:{ case BC_GT_F64:{
F64 left = b->registers[instr->left].f64; F64 left = b->registers[instr->a].f64;
F64 right = b->registers[instr->right].f64; F64 right = b->registers[instr->b].f64;
F64 result = left > right; F64 result = left > right;
b->registers[instr->dst].f64 = result; 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; }break;
case BC_LT_F64:{ case BC_LT_F64:{
F64 left = b->registers[instr->left].f64; F64 left = b->registers[instr->a].f64;
F64 right = b->registers[instr->right].f64; F64 right = b->registers[instr->b].f64;
F64 result = left < right; F64 result = left < right;
b->registers[instr->dst].f64 = result; 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; }break;
case BC_GTE_F64:{ case BC_GTE_F64:{
F64 left = b->registers[instr->left].f64; F64 left = b->registers[instr->a].f64;
F64 right = b->registers[instr->right].f64; F64 right = b->registers[instr->b].f64;
F64 result = left >= right; F64 result = left >= right;
b->registers[instr->dst].f64 = result; 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; }break;
case BC_LTE_F64:{ case BC_LTE_F64:{
F64 left = b->registers[instr->left].f64; F64 left = b->registers[instr->a].f64;
F64 right = b->registers[instr->right].f64; F64 right = b->registers[instr->b].f64;
F64 result = left <= right; F64 result = left <= right;
b->registers[instr->dst].f64 = result; 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; }break;
// //
@@ -724,11 +739,11 @@ run_bytecode_interp(Bc *b){
function void function void
test_interpreter(){ test_interpreter(){
Bc b = create_bytecode_interp(); Bc b = create_bytecode_interp();
emit_load_constant_f64(&b, 2, 100.32); emit_load_constant_f64(&b, 3, 100.32);
emit_load_constant_f64(&b, 3, 200.68); emit_load_constant_f64(&b, 4, 200.68);
emit_arithmetic(&b, BC_ADD_F64, 2, 3, 4); emit_arithmetic(&b, BC_ADD_F64, 3, 4, 3);
emit_push(&b, 4); emit_push(&b, 3);
emit_pop(&b, 5); emit_pop(&b, 3);
emit_end(&b); emit_end(&b);
run_bytecode_interp(&b); run_bytecode_interp(&b);
destroy_bytecode_interp(&b); destroy_bytecode_interp(&b);

9
code_generating_script.py
View File

@@ -30,6 +30,7 @@ if False:
enum_members.append("BC_POP_STACK") enum_members.append("BC_POP_STACK")
enum_members.append("BC_PUSH_STACK") enum_members.append("BC_PUSH_STACK")
enum_members.append("BC_LOAD_CONSTANT") enum_members.append("BC_LOAD_CONSTANT")
enum_members.append("BC_STORE_CONSTANT")
load_store = ["LOAD_FROM_MEMORY", "STORE_TO_MEMORY"] load_store = ["LOAD_FROM_MEMORY", "STORE_TO_MEMORY"]
for op in load_store: for op in load_store:
@@ -70,7 +71,7 @@ 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->left].{t}; {T} left = ({T})b->registers[instr->a].{t};
{T} result = {symbol}left; {T} result = {symbol}left;
{T} *dst = b->registers[instr->dst].pointer_{t}; {T} *dst = b->registers[instr->dst].pointer_{t};
*dst = result; *dst = result;
@@ -84,11 +85,11 @@ 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->left].{t}; {T} left = b->registers[instr->a].{t};
{T} right = b->registers[instr->right].{t}; {T} right = b->registers[instr->b].{t};
{T} result = left {symbol} right; {T} result = left {symbol} right;
b->registers[instr->dst].{t} = result; 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; }}break;
""" """
################################ ################################

2
main.cpp
View File

@@ -177,8 +177,6 @@ int main(int argument_count, char **arguments){
test_string_builder(); test_string_builder();
test_intern_table(); test_intern_table();
test_interpreter();
emit_line_directives = true; emit_line_directives = true;
String program_name = "vm.kl"_s; String program_name = "vm.kl"_s;
if(argument_count > 1){ if(argument_count > 1){