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

Rewrite VM, only capable to work on 64bit arithmetic

Browse Source
This commit is contained in:
Krzosa Karol
2022-06-20 22:14:46 +02:00
parent fd66781afb
commit 101970f62e
4 changed files with 436 additions and 651 deletions
Download Patch File Download Diff File Expand all files Collapse all files

667
bytecode_interpreter.cpp
View File

@@ -8,66 +8,58 @@ enum{
//
// Generated using code_generating_script.py
//
INS_PUSH_S64,
INS_ADD_S64,
INS_SUB_S64,
INS_DIV_S64,
INS_MUL_S64,
INS_MOD_S64,
INS_PUSH_S64,
INS_ADD_S32,
INS_SUB_S32,
INS_DIV_S32,
INS_MUL_S32,
INS_MOD_S32,
INS_PUSH_S32,
INS_ADD_S16,
INS_SUB_S16,
INS_DIV_S16,
INS_MUL_S16,
INS_MOD_S16,
INS_PUSH_S16,
INS_ADD_S8,
INS_SUB_S8,
INS_DIV_S8,
INS_MUL_S8,
INS_MOD_S8,
INS_PUSH_S8,
INS_SHR_S64,
INS_SHL_S64,
INS_BITAND_S64,
INS_BITOR_S64,
INS_BITXOR_S64,
INS_BITNOT_S64,
INS_EQ_S64,
INS_NEQ_S64,
INS_GT_S64,
INS_LT_S64,
INS_OR_S64,
INS_GTE_S64,
INS_LTE_S64,
INS_PUSH_U64,
INS_ADD_U64,
INS_SUB_U64,
INS_DIV_U64,
INS_MUL_U64,
INS_MOD_U64,
INS_PUSH_U64,
INS_ADD_U32,
INS_SUB_U32,
INS_DIV_U32,
INS_MUL_U32,
INS_MOD_U32,
INS_PUSH_U32,
INS_ADD_U16,
INS_SUB_U16,
INS_DIV_U16,
INS_MUL_U16,
INS_MOD_U16,
INS_PUSH_U16,
INS_ADD_U8,
INS_SUB_U8,
INS_DIV_U8,
INS_MUL_U8,
INS_MOD_U8,
INS_PUSH_U8,
INS_ADD_F32,
INS_SUB_F32,
INS_DIV_F32,
INS_MUL_F32,
INS_MOD_F32,
INS_PUSH_F32,
INS_SHR_U64,
INS_SHL_U64,
INS_BITAND_U64,
INS_BITOR_U64,
INS_BITXOR_U64,
INS_BITNOT_U64,
INS_EQ_U64,
INS_NEQ_U64,
INS_GT_U64,
INS_LT_U64,
INS_OR_U64,
INS_GTE_U64,
INS_LTE_U64,
INS_PUSH_F64,
INS_ADD_F64,
INS_SUB_F64,
INS_DIV_F64,
INS_MUL_F64,
INS_MOD_F64,
INS_PUSH_F64,
INS_EQ_F64,
INS_NEQ_F64,
INS_GT_F64,
INS_LT_F64,
INS_GTE_F64,
INS_LTE_F64,
//
// **End** of generated using code_generating_script.py
@@ -126,7 +118,7 @@ emit_end(Bc *bc){
}
#define ins_pop_t(b, T) (*((T *)ins_pop(b)))
static void *
force_inline void *
ins_pop(Bc *b){
assert_msg(b->stack_pointer != b->stack_bottom, "Reached bottom of bytecode interpreter stack");
b->stack_pointer -= sizeof(U64);
@@ -157,10 +149,20 @@ run_bytecode_interp(Bc *b){
goto interp_loop_breakout;
} break;
//
// Generated using code_generating_script.py
//
case INS_PUSH_S64:{
// Fetch value from the instruction.
// instructions are tightly packed so we
// move pointer by the type size
auto value = (S64 *)b->ins_pointer;
b->ins_pointer += sizeof(S64);
ins_push_s64(b, *value);
} break;
case INS_ADD_S64:{
S64 l = ins_pop_t(b, S64);
S64 r = ins_pop_t(b, S64);
@@ -196,145 +198,103 @@ case INS_MOD_S64:{
ins_push_s64(b, result);
}break;
case INS_PUSH_S64:{
// Fetch value from instruction
case INS_SHR_S64:{
S64 l = ins_pop_t(b, S64);
S64 r = ins_pop_t(b, S64);
S64 result = l >> r;
ins_push_s64(b, result);
}break;
case INS_SHL_S64:{
S64 l = ins_pop_t(b, S64);
S64 r = ins_pop_t(b, S64);
S64 result = l << r;
ins_push_s64(b, result);
}break;
case INS_BITAND_S64:{
S64 l = ins_pop_t(b, S64);
S64 r = ins_pop_t(b, S64);
S64 result = l & r;
ins_push_s64(b, result);
}break;
case INS_BITOR_S64:{
S64 l = ins_pop_t(b, S64);
S64 r = ins_pop_t(b, S64);
S64 result = l | r;
ins_push_s64(b, result);
}break;
case INS_BITXOR_S64:{
S64 l = ins_pop_t(b, S64);
S64 r = ins_pop_t(b, S64);
S64 result = l | r;
ins_push_s64(b, result);
}break;
case INS_BITNOT_S64:{
S64 l = ins_pop_t(b, S64);
S64 result = ~l;
ins_push_s64(b, result);
}break;
case INS_EQ_S64:{
S64 l = ins_pop_t(b, S64);
S64 r = ins_pop_t(b, S64);
S64 result = l == r;
ins_push_s64(b, result);
}break;
case INS_NEQ_S64:{
S64 l = ins_pop_t(b, S64);
S64 r = ins_pop_t(b, S64);
S64 result = l != r;
ins_push_s64(b, result);
}break;
case INS_GT_S64:{
S64 l = ins_pop_t(b, S64);
S64 r = ins_pop_t(b, S64);
S64 result = l > r;
ins_push_s64(b, result);
}break;
case INS_LT_S64:{
S64 l = ins_pop_t(b, S64);
S64 r = ins_pop_t(b, S64);
S64 result = l < r;
ins_push_s64(b, result);
}break;
case INS_OR_S64:{
S64 l = ins_pop_t(b, S64);
S64 r = ins_pop_t(b, S64);
S64 result = l || r;
ins_push_s64(b, result);
}break;
case INS_GTE_S64:{
S64 l = ins_pop_t(b, S64);
S64 r = ins_pop_t(b, S64);
S64 result = l >= r;
ins_push_s64(b, result);
}break;
case INS_LTE_S64:{
S64 l = ins_pop_t(b, S64);
S64 r = ins_pop_t(b, S64);
S64 result = l <= r;
ins_push_s64(b, result);
}break;
case INS_PUSH_U64:{
// Fetch value from the instruction.
// instructions are tightly packed so we
// move pointer by the type size
auto value = (S64 *)b->ins_pointer;
b->ins_pointer += sizeof(S64);
ins_push_s64(b, *value);
} break;
case INS_ADD_S32:{
S32 l = ins_pop_t(b, S32);
S32 r = ins_pop_t(b, S32);
S32 result = l + r;
ins_push_s32(b, result);
}break;
case INS_SUB_S32:{
S32 l = ins_pop_t(b, S32);
S32 r = ins_pop_t(b, S32);
S32 result = l - r;
ins_push_s32(b, result);
}break;
case INS_DIV_S32:{
S32 l = ins_pop_t(b, S32);
S32 r = ins_pop_t(b, S32);
S32 result = l / r;
ins_push_s32(b, result);
}break;
case INS_MUL_S32:{
S32 l = ins_pop_t(b, S32);
S32 r = ins_pop_t(b, S32);
S32 result = l * r;
ins_push_s32(b, result);
}break;
case INS_MOD_S32:{
S32 l = ins_pop_t(b, S32);
S32 r = ins_pop_t(b, S32);
S32 result = l % r;
ins_push_s32(b, result);
}break;
case INS_PUSH_S32:{
// Fetch value from instruction
// instructions are tightly packed so we
// move pointer by the type size
auto value = (S32 *)b->ins_pointer;
b->ins_pointer += sizeof(S32);
ins_push_s32(b, *value);
} break;
case INS_ADD_S16:{
S16 l = ins_pop_t(b, S16);
S16 r = ins_pop_t(b, S16);
S16 result = l + r;
ins_push_s16(b, result);
}break;
case INS_SUB_S16:{
S16 l = ins_pop_t(b, S16);
S16 r = ins_pop_t(b, S16);
S16 result = l - r;
ins_push_s16(b, result);
}break;
case INS_DIV_S16:{
S16 l = ins_pop_t(b, S16);
S16 r = ins_pop_t(b, S16);
S16 result = l / r;
ins_push_s16(b, result);
}break;
case INS_MUL_S16:{
S16 l = ins_pop_t(b, S16);
S16 r = ins_pop_t(b, S16);
S16 result = l * r;
ins_push_s16(b, result);
}break;
case INS_MOD_S16:{
S16 l = ins_pop_t(b, S16);
S16 r = ins_pop_t(b, S16);
S16 result = l % r;
ins_push_s16(b, result);
}break;
case INS_PUSH_S16:{
// Fetch value from instruction
// instructions are tightly packed so we
// move pointer by the type size
auto value = (S16 *)b->ins_pointer;
b->ins_pointer += sizeof(S16);
ins_push_s16(b, *value);
} break;
case INS_ADD_S8:{
S8 l = ins_pop_t(b, S8);
S8 r = ins_pop_t(b, S8);
S8 result = l + r;
ins_push_s8(b, result);
}break;
case INS_SUB_S8:{
S8 l = ins_pop_t(b, S8);
S8 r = ins_pop_t(b, S8);
S8 result = l - r;
ins_push_s8(b, result);
}break;
case INS_DIV_S8:{
S8 l = ins_pop_t(b, S8);
S8 r = ins_pop_t(b, S8);
S8 result = l / r;
ins_push_s8(b, result);
}break;
case INS_MUL_S8:{
S8 l = ins_pop_t(b, S8);
S8 r = ins_pop_t(b, S8);
S8 result = l * r;
ins_push_s8(b, result);
}break;
case INS_MOD_S8:{
S8 l = ins_pop_t(b, S8);
S8 r = ins_pop_t(b, S8);
S8 result = l % r;
ins_push_s8(b, result);
}break;
case INS_PUSH_S8:{
// Fetch value from instruction
// instructions are tightly packed so we
// move pointer by the type size
auto value = (S8 *)b->ins_pointer;
b->ins_pointer += sizeof(S8);
ins_push_s8(b, *value);
auto value = (U64 *)b->ins_pointer;
b->ins_pointer += sizeof(U64);
ins_push_u64(b, *value);
} break;
case INS_ADD_U64:{
@@ -372,182 +332,103 @@ case INS_MOD_U64:{
ins_push_u64(b, result);
}break;
case INS_PUSH_U64:{
// Fetch value from instruction
case INS_SHR_U64:{
U64 l = ins_pop_t(b, U64);
U64 r = ins_pop_t(b, U64);
U64 result = l >> r;
ins_push_u64(b, result);
}break;
case INS_SHL_U64:{
U64 l = ins_pop_t(b, U64);
U64 r = ins_pop_t(b, U64);
U64 result = l << r;
ins_push_u64(b, result);
}break;
case INS_BITAND_U64:{
U64 l = ins_pop_t(b, U64);
U64 r = ins_pop_t(b, U64);
U64 result = l & r;
ins_push_u64(b, result);
}break;
case INS_BITOR_U64:{
U64 l = ins_pop_t(b, U64);
U64 r = ins_pop_t(b, U64);
U64 result = l | r;
ins_push_u64(b, result);
}break;
case INS_BITXOR_U64:{
U64 l = ins_pop_t(b, U64);
U64 r = ins_pop_t(b, U64);
U64 result = l | r;
ins_push_u64(b, result);
}break;
case INS_BITNOT_U64:{
U64 l = ins_pop_t(b, U64);
U64 result = ~l;
ins_push_u64(b, result);
}break;
case INS_EQ_U64:{
U64 l = ins_pop_t(b, U64);
U64 r = ins_pop_t(b, U64);
U64 result = l == r;
ins_push_u64(b, result);
}break;
case INS_NEQ_U64:{
U64 l = ins_pop_t(b, U64);
U64 r = ins_pop_t(b, U64);
U64 result = l != r;
ins_push_u64(b, result);
}break;
case INS_GT_U64:{
U64 l = ins_pop_t(b, U64);
U64 r = ins_pop_t(b, U64);
U64 result = l > r;
ins_push_u64(b, result);
}break;
case INS_LT_U64:{
U64 l = ins_pop_t(b, U64);
U64 r = ins_pop_t(b, U64);
U64 result = l < r;
ins_push_u64(b, result);
}break;
case INS_OR_U64:{
U64 l = ins_pop_t(b, U64);
U64 r = ins_pop_t(b, U64);
U64 result = l || r;
ins_push_u64(b, result);
}break;
case INS_GTE_U64:{
U64 l = ins_pop_t(b, U64);
U64 r = ins_pop_t(b, U64);
U64 result = l >= r;
ins_push_u64(b, result);
}break;
case INS_LTE_U64:{
U64 l = ins_pop_t(b, U64);
U64 r = ins_pop_t(b, U64);
U64 result = l <= r;
ins_push_u64(b, result);
}break;
case INS_PUSH_F64:{
// Fetch value from the instruction.
// instructions are tightly packed so we
// move pointer by the type size
auto value = (U64 *)b->ins_pointer;
b->ins_pointer += sizeof(U64);
ins_push_u64(b, *value);
} break;
case INS_ADD_U32:{
U32 l = ins_pop_t(b, U32);
U32 r = ins_pop_t(b, U32);
U32 result = l + r;
ins_push_u32(b, result);
}break;
case INS_SUB_U32:{
U32 l = ins_pop_t(b, U32);
U32 r = ins_pop_t(b, U32);
U32 result = l - r;
ins_push_u32(b, result);
}break;
case INS_DIV_U32:{
U32 l = ins_pop_t(b, U32);
U32 r = ins_pop_t(b, U32);
U32 result = l / r;
ins_push_u32(b, result);
}break;
case INS_MUL_U32:{
U32 l = ins_pop_t(b, U32);
U32 r = ins_pop_t(b, U32);
U32 result = l * r;
ins_push_u32(b, result);
}break;
case INS_MOD_U32:{
U32 l = ins_pop_t(b, U32);
U32 r = ins_pop_t(b, U32);
U32 result = l % r;
ins_push_u32(b, result);
}break;
case INS_PUSH_U32:{
// Fetch value from instruction
// instructions are tightly packed so we
// move pointer by the type size
auto value = (U32 *)b->ins_pointer;
b->ins_pointer += sizeof(U32);
ins_push_u32(b, *value);
} break;
case INS_ADD_U16:{
U16 l = ins_pop_t(b, U16);
U16 r = ins_pop_t(b, U16);
U16 result = l + r;
ins_push_u16(b, result);
}break;
case INS_SUB_U16:{
U16 l = ins_pop_t(b, U16);
U16 r = ins_pop_t(b, U16);
U16 result = l - r;
ins_push_u16(b, result);
}break;
case INS_DIV_U16:{
U16 l = ins_pop_t(b, U16);
U16 r = ins_pop_t(b, U16);
U16 result = l / r;
ins_push_u16(b, result);
}break;
case INS_MUL_U16:{
U16 l = ins_pop_t(b, U16);
U16 r = ins_pop_t(b, U16);
U16 result = l * r;
ins_push_u16(b, result);
}break;
case INS_MOD_U16:{
U16 l = ins_pop_t(b, U16);
U16 r = ins_pop_t(b, U16);
U16 result = l % r;
ins_push_u16(b, result);
}break;
case INS_PUSH_U16:{
// Fetch value from instruction
// instructions are tightly packed so we
// move pointer by the type size
auto value = (U16 *)b->ins_pointer;
b->ins_pointer += sizeof(U16);
ins_push_u16(b, *value);
} break;
case INS_ADD_U8:{
U8 l = ins_pop_t(b, U8);
U8 r = ins_pop_t(b, U8);
U8 result = l + r;
ins_push_u8(b, result);
}break;
case INS_SUB_U8:{
U8 l = ins_pop_t(b, U8);
U8 r = ins_pop_t(b, U8);
U8 result = l - r;
ins_push_u8(b, result);
}break;
case INS_DIV_U8:{
U8 l = ins_pop_t(b, U8);
U8 r = ins_pop_t(b, U8);
U8 result = l / r;
ins_push_u8(b, result);
}break;
case INS_MUL_U8:{
U8 l = ins_pop_t(b, U8);
U8 r = ins_pop_t(b, U8);
U8 result = l * r;
ins_push_u8(b, result);
}break;
case INS_MOD_U8:{
U8 l = ins_pop_t(b, U8);
U8 r = ins_pop_t(b, U8);
U8 result = l % r;
ins_push_u8(b, result);
}break;
case INS_PUSH_U8:{
// Fetch value from instruction
// instructions are tightly packed so we
// move pointer by the type size
auto value = (U8 *)b->ins_pointer;
b->ins_pointer += sizeof(U8);
ins_push_u8(b, *value);
} break;
case INS_ADD_F32:{
F32 l = ins_pop_t(b, F32);
F32 r = ins_pop_t(b, F32);
F32 result = l + r;
ins_push_f32(b, result);
}break;
case INS_SUB_F32:{
F32 l = ins_pop_t(b, F32);
F32 r = ins_pop_t(b, F32);
F32 result = l - r;
ins_push_f32(b, result);
}break;
case INS_DIV_F32:{
F32 l = ins_pop_t(b, F32);
F32 r = ins_pop_t(b, F32);
F32 result = l / r;
ins_push_f32(b, result);
}break;
case INS_MUL_F32:{
F32 l = ins_pop_t(b, F32);
F32 r = ins_pop_t(b, F32);
F32 result = l * r;
ins_push_f32(b, result);
}break;
case INS_PUSH_F32:{
// Fetch value from instruction
// instructions are tightly packed so we
// move pointer by the type size
auto value = (F32 *)b->ins_pointer;
b->ins_pointer += sizeof(F32);
ins_push_f32(b, *value);
auto value = (F64 *)b->ins_pointer;
b->ins_pointer += sizeof(F64);
ins_push_f64(b, *value);
} break;
case INS_ADD_F64:{
@@ -578,19 +459,53 @@ case INS_MUL_F64:{
ins_push_f64(b, result);
}break;
case INS_PUSH_F64:{
// Fetch value from instruction
// instructions are tightly packed so we
// move pointer by the type size
auto value = (F64 *)b->ins_pointer;
b->ins_pointer += sizeof(F64);
ins_push_f64(b, *value);
} break;
case INS_EQ_F64:{
F64 l = ins_pop_t(b, F64);
F64 r = ins_pop_t(b, F64);
F64 result = l == r;
ins_push_f64(b, result);
}break;
case INS_NEQ_F64:{
F64 l = ins_pop_t(b, F64);
F64 r = ins_pop_t(b, F64);
F64 result = l != r;
ins_push_f64(b, result);
}break;
case INS_GT_F64:{
F64 l = ins_pop_t(b, F64);
F64 r = ins_pop_t(b, F64);
F64 result = l > r;
ins_push_f64(b, result);
}break;
case INS_LT_F64:{
F64 l = ins_pop_t(b, F64);
F64 r = ins_pop_t(b, F64);
F64 result = l < r;
ins_push_f64(b, result);
}break;
case INS_GTE_F64:{
F64 l = ins_pop_t(b, F64);
F64 r = ins_pop_t(b, F64);
F64 result = l >= r;
ins_push_f64(b, result);
}break;
case INS_LTE_F64:{
F64 l = ins_pop_t(b, F64);
F64 r = ins_pop_t(b, F64);
F64 result = l <= r;
ins_push_f64(b, result);
}break;
//
// **End** of generated using code_generating_script.py
//
default: invalid_codepath;
}
}
@@ -600,16 +515,18 @@ case INS_PUSH_F64:{
function void
test_interpreter(){
Bc b = create_bytecode_interp();
emit_push_s64(&b, 1);
emit_push_s8(&b, 3);
emit_add_s64(&b);
emit_push_f64(&b, 64);
emit_push_f64(&b, 32);
emit_neq_f64(&b);
emit_pop(&b);
// emit_push_f64(&b, 2.42f);
// emit_push_u16(&b, 4);
// emit_pop(&b);
// emit_pop(&b);
// emit_pop(&b);
// emit_pop(&b);
emit_push_f64(&b, 64);
emit_push_f64(&b, 32);
emit_add_f64(&b);
emit_pop(&b);
emit_end(&b);
run_bytecode_interp(&b);
}