oreodave/avm
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Propagate addition of short based instructions to runtime

Browse Source 
Lots of busy work
This commit is contained in:
Aryadev Chavali
2024-06-19 21:48:13 +01:00
parent 1ae28bdb3b
commit 05235497dc
2 changed files with 281 additions and 72 deletions
Download Patch File Download Diff File Expand all files Collapse all files

214
vm/runtime.c
View File

@@ -38,6 +38,8 @@ const char *err_as_cstr(err_t err)
return "INVALID_OPCODE";
case ERR_INVALID_REGISTER_BYTE:
return "INVALID_REGISTER_BYTE";
case ERR_INVALID_REGISTER_SHORT:
return "INVALID_REGISTER_SHORT";
case ERR_INVALID_REGISTER_HWORD:
return "INVALID_REGISTER_HWORD";
case ERR_INVALID_REGISTER_WORD:
@@ -55,14 +57,7 @@ const char *err_as_cstr(err_t err)
}
}
static_assert(NUMBER_OF_OPCODES == 99, "vm_execute: Out of date");
static_assert(DATA_TYPE_NIL == -1 && DATA_TYPE_WORD == 2,
"Code using OPCODE_DATA_TYPE for quick same type opcode "
"conversion may be out of date.");
static_assert(OP_PRINT_SWORD - OP_PRINT_BYTE == 5,
"Implementation of OP_PRINT is out of date");
static_assert(NUMBER_OF_OPCODES == 129, "vm_execute: Out of date");
err_t vm_execute(vm_t *vm)
{
@@ -94,6 +89,10 @@ err_t vm_execute(vm_t *vm)
}
else if (UNSIGNED_OPCODE_IS_TYPE(instruction.opcode, OP_POP))
{
static_assert(DATA_TYPE_NIL == -1 && DATA_TYPE_WORD == 3,
"Code using OPCODE_DATA_TYPE for quick same type opcode "
"conversion may be out of date.");
// NOTE: We always use the first register to hold the result of
// this pop.
@@ -144,8 +143,11 @@ err_t vm_execute(vm_t *vm)
{
data_t datum = {0};
static_assert(DATA_TYPE_NIL == -1 && DATA_TYPE_WORD == 3,
"Code using OPCODE_DATA_TYPE for quick same type opcode "
"conversion may be out of date.");
// Here we add OP_POP_BYTE and the data_type_t of the opcode to
// get the right typed OP_POP opcode.
// get the right OP_POP opcode.
opcode_t pop_opcode =
OPCODE_DATA_TYPE(instruction.opcode, OP_JUMP_IF) + OP_POP_BYTE;
@@ -157,8 +159,7 @@ err_t vm_execute(vm_t *vm)
// If datum != 0 then jump, else go to the next instruction
if (datum.as_word != 0)
return vm_jump(vm, instruction.operand.as_word);
else
++prog->ptr;
++prog->ptr;
}
else if (instruction.opcode == OP_CALL)
{
@@ -191,6 +192,11 @@ err_t vm_execute(vm_t *vm)
}
else if (SIGNED_OPCODE_IS_TYPE(instruction.opcode, OP_PRINT))
{
static_assert(DATA_TYPE_NIL == -1 && DATA_TYPE_WORD == 3,
"Code using OPCODE_DATA_TYPE for quick same type opcode "
"conversion may be out of date.");
static_assert(OP_PRINT_SWORD - OP_PRINT_BYTE == 7,
"Implementation of OP_PRINT is out of date");
/* 1) Pop
2) Format
3) Print
@@ -198,13 +204,14 @@ err_t vm_execute(vm_t *vm)
// 1) figure out what datum type to pop
// type in [0, 5] representing [byte, char, hword, int, word,
// long]
// type in [0, 7] representing [byte, sbyte, short, sshort, hword, shword,
// word, sword]
int type = OPCODE_DATA_TYPE(instruction.opcode, OP_PRINT);
/* Byte and Char -> POP_BYTE
HWord and Int -> POP_HWORD
Word and Long -> POP_WORD
/* Byte and SByte -> POP_BYTE
Short and SShort -> POP_SHORT
HWord and SHword -> POP_HWORD
Word and SWord -> POP_WORD
*/
opcode_t pop_opcode = OP_POP_BYTE + (type / 2);
@@ -217,14 +224,16 @@ err_t vm_execute(vm_t *vm)
// 2) create a format string for each datum type possible
// TODO: Figure out a way to ensure the ordering of OP_PRINT_* is
// exactly BYTE, CHAR, HWORD, INTEGER, WORD, LONG. Perhaps via
// static_assert
// exactly BYTE, SBYTE, SHORT, SSHORT, HWORD, SHWORD, WORD, SWORD
// via static_assert
// lookup table
const char *format_strings[] = {
"0x%x",
"0x%X",
"%c",
#if PRINT_HEX == 1
"0x%X",
"0x%X",
"0x%X",
"0x%X",
"0x%lX",
@@ -350,6 +359,22 @@ err_t vm_push_byte(vm_t *vm, data_t b)
return ERR_OK;
}
err_t vm_push_short(vm_t *vm, data_t f)
{
if (vm->stack.ptr + SHORT_SIZE >= vm->stack.max)
return ERR_STACK_OVERFLOW;
byte_t bytes[SHORT_SIZE] = {0};
convert_short_to_bytes(f.as_short, bytes);
for (size_t i = 0; i < SHORT_SIZE; ++i)
{
byte_t b = bytes[SHORT_SIZE - i - 1];
err_t err = vm_push_byte(vm, DBYTE(b));
if (err)
return err;
}
return ERR_OK;
}
err_t vm_push_hword(vm_t *vm, data_t f)
{
if (vm->stack.ptr + HWORD_SIZE >= vm->stack.max)
@@ -393,6 +418,15 @@ err_t vm_push_byte_register(vm_t *vm, word_t reg)
return vm_push_byte(vm, DBYTE(b));
}
err_t vm_push_short_register(vm_t *vm, word_t reg)
{
if (reg > (vm->registers.used / SHORT_SIZE))
return ERR_INVALID_REGISTER_SHORT;
// Interpret the bytes at point reg * SHORT_SIZE as an short
short_t sh = *(short_t *)(vm->registers.data + (reg * SHORT_SIZE));
return vm_push_short(vm, DSHORT(sh));
}
err_t vm_push_hword_register(vm_t *vm, word_t reg)
{
if (reg > (vm->registers.used / HWORD_SIZE))
@@ -425,6 +459,31 @@ err_t vm_mov_byte(vm_t *vm, word_t reg)
return ERR_OK;
}
err_t vm_mov_short(vm_t *vm, word_t reg)
{
if (reg >= (vm->registers.used / SHORT_SIZE))
{
// Expand capacity till we can ensure that this is a valid
// register to use
// Number of shorts needed ontop of what is allocated:
const size_t shorts = (reg - (vm->registers.used / SHORT_SIZE));
// Number of bytes needed ontop of what is allocated
const size_t diff = (shorts + 1) * SHORT_SIZE;
darr_ensure_capacity(&vm->registers, diff);
vm->registers.used = MAX(vm->registers.used, (reg + 1) * SHORT_SIZE);
}
data_t ret = {0};
err_t err = vm_pop_short(vm, &ret);
if (err)
return err;
// Here we treat vm->registers as a set of shorts
short_t *short_ptr = (short_t *)(vm->registers.data + (reg * SHORT_SIZE));
*short_ptr = ret.as_short;
return ERR_OK;
}
err_t vm_mov_hword(vm_t *vm, word_t reg)
{
if (reg >= (vm->registers.used / HWORD_SIZE))
@@ -479,6 +538,17 @@ err_t vm_dup_byte(vm_t *vm, word_t w)
return vm_push_byte(vm, DBYTE(vm->stack.data[vm->stack.ptr - 1 - w]));
}
err_t vm_dup_short(vm_t *vm, word_t w)
{
if (vm->stack.ptr < SHORT_SIZE * (w + 1))
return ERR_STACK_UNDERFLOW;
byte_t bytes[SHORT_SIZE] = {0};
for (size_t i = 0; i < SHORT_SIZE; ++i)
bytes[SHORT_SIZE - i - 1] =
vm->stack.data[vm->stack.ptr - (SHORT_SIZE * (w + 1)) + i];
return vm_push_short(vm, DSHORT(convert_bytes_to_short(bytes)));
}
err_t vm_dup_hword(vm_t *vm, word_t w)
{
if (vm->stack.ptr < HWORD_SIZE * (w + 1))
@@ -507,6 +577,12 @@ err_t vm_malloc_byte(vm_t *vm, word_t n)
return vm_push_word(vm, DWORD((word_t)page));
}
err_t vm_malloc_short(vm_t *vm, word_t n)
{
page_t *page = heap_allocate(&vm->heap, n * SHORT_SIZE);
return vm_push_word(vm, DWORD((word_t)page));
}
err_t vm_malloc_hword(vm_t *vm, word_t n)
{
page_t *page = heap_allocate(&vm->heap, n * HWORD_SIZE);
@@ -539,6 +615,26 @@ err_t vm_mset_byte(vm_t *vm, word_t nth)
return ERR_OK;
}
err_t vm_mset_short(vm_t *vm, word_t nth)
{
// Stack layout should be [SHORT, PTR]
data_t byte = {0};
err_t err = vm_pop_short(vm, &byte);
if (err)
return err;
data_t ptr = {0};
err = vm_pop_word(vm, &ptr);
if (err)
return err;
page_t *page = (page_t *)ptr.as_word;
if (nth >= (page->available / SHORT_SIZE))
return ERR_OUT_OF_BOUNDS;
((short_t *)page->data)[nth] = byte.as_short;
return ERR_OK;
}
err_t vm_mset_hword(vm_t *vm, word_t nth)
{
// Stack layout should be [HWORD, PTR]
@@ -592,6 +688,19 @@ err_t vm_mget_byte(vm_t *vm, word_t n)
return vm_push_byte(vm, DBYTE(page->data[n]));
}
err_t vm_mget_short(vm_t *vm, word_t n)
{
// Stack layout should be [PTR]
data_t ptr = {0};
err_t err = vm_pop_word(vm, &ptr);
if (err)
return err;
page_t *page = (page_t *)ptr.as_word;
if (n >= (page->available / SHORT_SIZE))
return ERR_OUT_OF_BOUNDS;
return vm_push_short(vm, DSHORT(((short_t *)page->data)[n]));
}
err_t vm_mget_hword(vm_t *vm, word_t n)
{
// Stack layout should be [PTR]
@@ -627,6 +736,21 @@ err_t vm_pop_byte(vm_t *vm, data_t *ret)
return ERR_OK;
}
err_t vm_pop_short(vm_t *vm, data_t *ret)
{
if (vm->stack.ptr < SHORT_SIZE)
return ERR_STACK_UNDERFLOW;
byte_t bytes[SHORT_SIZE] = {0};
for (size_t i = 0; i < SHORT_SIZE; ++i)
{
data_t b = {0};
vm_pop_byte(vm, &b);
bytes[i] = b.as_byte;
}
*ret = DSHORT(convert_bytes_to_short(bytes));
return ERR_OK;
}
err_t vm_pop_hword(vm_t *vm, data_t *ret)
{
if (vm->stack.ptr < HWORD_SIZE)
@@ -669,12 +793,15 @@ err_t vm_pop_word(vm_t *vm, data_t *ret)
}
VM_MEMORY_STACK_CONSTR(malloc, byte)
VM_MEMORY_STACK_CONSTR(malloc, short)
VM_MEMORY_STACK_CONSTR(malloc, hword)
VM_MEMORY_STACK_CONSTR(malloc, word)
VM_MEMORY_STACK_CONSTR(mset, byte)
VM_MEMORY_STACK_CONSTR(mset, short)
VM_MEMORY_STACK_CONSTR(mset, hword)
VM_MEMORY_STACK_CONSTR(mset, word)
VM_MEMORY_STACK_CONSTR(mget, byte)
VM_MEMORY_STACK_CONSTR(mget, short)
VM_MEMORY_STACK_CONSTR(mget, hword)
VM_MEMORY_STACK_CONSTR(mget, word)
@@ -713,6 +840,7 @@ err_t vm_msize(vm_t *vm)
}
VM_NOT_TYPE(byte, BYTE)
VM_NOT_TYPE(short, SHORT)
VM_NOT_TYPE(hword, HWORD)
VM_NOT_TYPE(word, WORD)
@@ -745,58 +873,76 @@ VM_NOT_TYPE(word, WORD)
}
VM_SAME_TYPE(or, |, byte, BYTE)
VM_SAME_TYPE(or, |, short, SHORT)
VM_SAME_TYPE(or, |, hword, HWORD)
VM_SAME_TYPE(or, |, word, WORD)
VM_SAME_TYPE(and, &, byte, BYTE)
VM_SAME_TYPE(and, &, short, SHORT)
VM_SAME_TYPE(and, &, hword, HWORD)
VM_SAME_TYPE(and, &, word, WORD)
VM_SAME_TYPE(xor, ^, byte, BYTE)
VM_SAME_TYPE(xor, ^, short, SHORT)
VM_SAME_TYPE(xor, ^, hword, HWORD)
VM_SAME_TYPE(xor, ^, word, WORD)
VM_SAME_TYPE(plus, +, byte, BYTE)
VM_SAME_TYPE(plus, +, short, SHORT)
VM_SAME_TYPE(plus, +, hword, HWORD)
VM_SAME_TYPE(plus, +, word, WORD)
VM_SAME_TYPE(sub, -, byte, BYTE)
VM_SAME_TYPE(sub, -, short, SHORT)
VM_SAME_TYPE(sub, -, hword, HWORD)
VM_SAME_TYPE(sub, -, word, WORD)
VM_SAME_TYPE(mult, *, byte, BYTE)
VM_SAME_TYPE(mult, *, short, SHORT)
VM_SAME_TYPE(mult, *, hword, HWORD)
VM_SAME_TYPE(mult, *, word, WORD)
VM_COMPARATOR_TYPE(eq, ==, byte, byte)
VM_COMPARATOR_TYPE(eq, ==, byte, char)
VM_COMPARATOR_TYPE(eq, ==, byte, sbyte)
VM_COMPARATOR_TYPE(eq, ==, short, short)
VM_COMPARATOR_TYPE(eq, ==, short, sshort)
VM_COMPARATOR_TYPE(eq, ==, hword, hword)
VM_COMPARATOR_TYPE(eq, ==, hword, int)
VM_COMPARATOR_TYPE(eq, ==, hword, shword)
VM_COMPARATOR_TYPE(eq, ==, word, word)
VM_COMPARATOR_TYPE(eq, ==, word, long)
VM_COMPARATOR_TYPE(eq, ==, word, sword)
VM_COMPARATOR_TYPE(lt, <, byte, byte)
VM_COMPARATOR_TYPE(lt, <, byte, char)
VM_COMPARATOR_TYPE(lt, <, byte, sbyte)
VM_COMPARATOR_TYPE(lt, <, short, short)
VM_COMPARATOR_TYPE(lt, <, short, sshort)
VM_COMPARATOR_TYPE(lt, <, hword, hword)
VM_COMPARATOR_TYPE(lt, <, hword, int)
VM_COMPARATOR_TYPE(lt, <, hword, shword)
VM_COMPARATOR_TYPE(lt, <, word, word)
VM_COMPARATOR_TYPE(lt, <, word, long)
VM_COMPARATOR_TYPE(lt, <, word, sword)
VM_COMPARATOR_TYPE(lte, <=, byte, byte)
VM_COMPARATOR_TYPE(lte, <=, byte, char)
VM_COMPARATOR_TYPE(lte, <=, byte, sbyte)
VM_COMPARATOR_TYPE(lte, <=, short, short)
VM_COMPARATOR_TYPE(lte, <=, short, sshort)
VM_COMPARATOR_TYPE(lte, <=, hword, hword)
VM_COMPARATOR_TYPE(lte, <=, hword, int)
VM_COMPARATOR_TYPE(lte, <=, hword, shword)
VM_COMPARATOR_TYPE(lte, <=, word, word)
VM_COMPARATOR_TYPE(lte, <=, word, long)
VM_COMPARATOR_TYPE(lte, <=, word, sword)
VM_COMPARATOR_TYPE(gt, >, byte, byte)
VM_COMPARATOR_TYPE(gt, >, byte, char)
VM_COMPARATOR_TYPE(gt, >, byte, sbyte)
VM_COMPARATOR_TYPE(gt, >, short, short)
VM_COMPARATOR_TYPE(gt, >, short, sshort)
VM_COMPARATOR_TYPE(gt, >, hword, hword)
VM_COMPARATOR_TYPE(gt, >, hword, int)
VM_COMPARATOR_TYPE(gt, >, hword, shword)
VM_COMPARATOR_TYPE(gt, >, word, word)
VM_COMPARATOR_TYPE(gt, >, word, long)
VM_COMPARATOR_TYPE(gt, >, word, sword)
VM_COMPARATOR_TYPE(gte, >=, byte, byte)
VM_COMPARATOR_TYPE(gte, >=, byte, char)
VM_COMPARATOR_TYPE(gte, >=, byte, sbyte)
VM_COMPARATOR_TYPE(gte, >=, short, short)
VM_COMPARATOR_TYPE(gte, >=, short, sshort)
VM_COMPARATOR_TYPE(gte, >=, hword, hword)
VM_COMPARATOR_TYPE(gte, >=, hword, int)
VM_COMPARATOR_TYPE(gte, >=, hword, shword)
VM_COMPARATOR_TYPE(gte, >=, word, word)
VM_COMPARATOR_TYPE(gte, >=, word, long)
VM_COMPARATOR_TYPE(gte, >=, word, sword)

139
vm/runtime.h
View File

@@ -26,6 +26,7 @@ typedef enum
ERR_CALL_STACK_OVERFLOW,
ERR_INVALID_OPCODE,
ERR_INVALID_REGISTER_BYTE,
ERR_INVALID_REGISTER_SHORT,
ERR_INVALID_REGISTER_HWORD,
ERR_INVALID_REGISTER_WORD,
ERR_INVALID_PROGRAM_ADDRESS,
@@ -42,84 +43,108 @@ err_t vm_execute_all(vm_t *);
err_t vm_jump(vm_t *, word_t);
err_t vm_pop_byte(vm_t *, data_t *);
err_t vm_pop_short(vm_t *, data_t *);
err_t vm_pop_hword(vm_t *, data_t *);
err_t vm_pop_word(vm_t *, data_t *);
typedef err_t (*pop_f)(vm_t *, data_t *);
static const pop_f POP_ROUTINES[] = {
[OP_POP_BYTE] = vm_pop_byte,
[OP_POP_SHORT] = vm_pop_short,
[OP_POP_HWORD] = vm_pop_hword,
[OP_POP_WORD] = vm_pop_word,
};
err_t vm_push_byte(vm_t *, data_t);
err_t vm_push_short(vm_t *, data_t);
err_t vm_push_hword(vm_t *, data_t);
err_t vm_push_word(vm_t *, data_t);
typedef err_t (*push_f)(vm_t *, data_t);
static const push_f PUSH_ROUTINES[] = {
[OP_PUSH_BYTE] = vm_push_byte,
[OP_PUSH_SHORT] = vm_push_short,
[OP_PUSH_HWORD] = vm_push_hword,
[OP_PUSH_WORD] = vm_push_word,
};
/* Operations where operand is a word from inst_t.operand */
err_t vm_push_byte_register(vm_t *, word_t);
err_t vm_push_short_register(vm_t *, word_t);
err_t vm_push_hword_register(vm_t *, word_t);
err_t vm_push_word_register(vm_t *, word_t);
err_t vm_mov_byte(vm_t *, word_t);
err_t vm_mov_short(vm_t *, word_t);
err_t vm_mov_hword(vm_t *, word_t);
err_t vm_mov_word(vm_t *, word_t);
err_t vm_dup_byte(vm_t *, word_t);
err_t vm_dup_short(vm_t *, word_t);
err_t vm_dup_hword(vm_t *, word_t);
err_t vm_dup_word(vm_t *, word_t);
err_t vm_malloc_byte(vm_t *, word_t);
err_t vm_malloc_short(vm_t *, word_t);
err_t vm_malloc_hword(vm_t *, word_t);
err_t vm_malloc_word(vm_t *, word_t);
err_t vm_mset_byte(vm_t *, word_t);
err_t vm_mset_short(vm_t *, word_t);
err_t vm_mset_hword(vm_t *, word_t);
err_t vm_mset_word(vm_t *, word_t);
err_t vm_mget_byte(vm_t *, word_t);
err_t vm_mget_short(vm_t *, word_t);
err_t vm_mget_hword(vm_t *, word_t);
err_t vm_mget_word(vm_t *, word_t);
typedef err_t (*word_f)(vm_t *, word_t);
static const word_f WORD_ROUTINES[] = {
[OP_PUSH_REGISTER_BYTE] = vm_push_byte_register,
[OP_PUSH_REGISTER_SHORT] = vm_push_short_register,
[OP_PUSH_REGISTER_HWORD] = vm_push_hword_register,
[OP_PUSH_REGISTER_WORD] = vm_push_word_register,
[OP_MOV_BYTE] = vm_mov_byte,
[OP_MOV_HWORD] = vm_mov_hword,
[OP_MOV_WORD] = vm_mov_word,
[OP_DUP_BYTE] = vm_dup_byte,
[OP_DUP_HWORD] = vm_dup_hword,
[OP_DUP_WORD] = vm_dup_word,
[OP_MALLOC_BYTE] = vm_malloc_byte,
[OP_MALLOC_HWORD] = vm_malloc_hword,
[OP_MALLOC_WORD] = vm_malloc_word,
[OP_MGET_BYTE] = vm_mget_byte,
[OP_MGET_HWORD] = vm_mget_hword,
[OP_MGET_WORD] = vm_mget_word,
[OP_MSET_BYTE] = vm_mset_byte,
[OP_MSET_HWORD] = vm_mset_hword,
[OP_MSET_WORD] = vm_mset_word,
[OP_MOV_BYTE] = vm_mov_byte,
[OP_MOV_SHORT] = vm_mov_short,
[OP_MOV_HWORD] = vm_mov_hword,
[OP_MOV_WORD] = vm_mov_word,
[OP_DUP_BYTE] = vm_dup_byte,
[OP_DUP_SHORT] = vm_dup_short,
[OP_DUP_HWORD] = vm_dup_hword,
[OP_DUP_WORD] = vm_dup_word,
[OP_MALLOC_BYTE] = vm_malloc_byte,
[OP_MALLOC_SHORT] = vm_malloc_short,
[OP_MALLOC_HWORD] = vm_malloc_hword,
[OP_MALLOC_WORD] = vm_malloc_word,
[OP_MGET_BYTE] = vm_mget_byte,
[OP_MGET_SHORT] = vm_mget_short,
[OP_MGET_HWORD] = vm_mget_hword,
[OP_MGET_WORD] = vm_mget_word,
[OP_MSET_BYTE] = vm_mset_byte,
[OP_MSET_SHORT] = vm_mset_short,
[OP_MSET_HWORD] = vm_mset_hword,
[OP_MSET_WORD] = vm_mset_word,
};
/* Operations that take input from the stack */
err_t vm_malloc_stack_byte(vm_t *);
err_t vm_malloc_stack_short(vm_t *);
err_t vm_malloc_stack_hword(vm_t *);
err_t vm_malloc_stack_word(vm_t *);
err_t vm_mset_stack_byte(vm_t *);
err_t vm_mset_stack_short(vm_t *);
err_t vm_mset_stack_hword(vm_t *);
err_t vm_mset_stack_word(vm_t *);
err_t vm_mget_stack_byte(vm_t *);
err_t vm_mget_stack_short(vm_t *);
err_t vm_mget_stack_hword(vm_t *);
err_t vm_mget_stack_word(vm_t *);
@@ -127,104 +152,133 @@ err_t vm_mdelete(vm_t *);
err_t vm_msize(vm_t *);
err_t vm_not_byte(vm_t *);
err_t vm_not_short(vm_t *);
err_t vm_not_hword(vm_t *);
err_t vm_not_word(vm_t *);
err_t vm_or_byte(vm_t *);
err_t vm_or_short(vm_t *);
err_t vm_or_hword(vm_t *);
err_t vm_or_word(vm_t *);
err_t vm_and_byte(vm_t *);
err_t vm_and_short(vm_t *);
err_t vm_and_hword(vm_t *);
err_t vm_and_word(vm_t *);
err_t vm_xor_byte(vm_t *);
err_t vm_xor_short(vm_t *);
err_t vm_xor_hword(vm_t *);
err_t vm_xor_word(vm_t *);
err_t vm_eq_byte(vm_t *);
err_t vm_eq_char(vm_t *);
err_t vm_eq_int(vm_t *);
err_t vm_eq_sbyte(vm_t *);
err_t vm_eq_short(vm_t *);
err_t vm_eq_sshort(vm_t *);
err_t vm_eq_shword(vm_t *);
err_t vm_eq_hword(vm_t *);
err_t vm_eq_long(vm_t *);
err_t vm_eq_sword(vm_t *);
err_t vm_eq_word(vm_t *);
err_t vm_lt_byte(vm_t *);
err_t vm_lt_char(vm_t *);
err_t vm_lt_int(vm_t *);
err_t vm_lt_sbyte(vm_t *);
err_t vm_lt_short(vm_t *);
err_t vm_lt_sshort(vm_t *);
err_t vm_lt_shword(vm_t *);
err_t vm_lt_hword(vm_t *);
err_t vm_lt_long(vm_t *);
err_t vm_lt_sword(vm_t *);
err_t vm_lt_word(vm_t *);
err_t vm_lte_byte(vm_t *);
err_t vm_lte_char(vm_t *);
err_t vm_lte_int(vm_t *);
err_t vm_lte_sbyte(vm_t *);
err_t vm_lte_short(vm_t *);
err_t vm_lte_sshort(vm_t *);
err_t vm_lte_shword(vm_t *);
err_t vm_lte_hword(vm_t *);
err_t vm_lte_long(vm_t *);
err_t vm_lte_sword(vm_t *);
err_t vm_lte_word(vm_t *);
err_t vm_gt_byte(vm_t *);
err_t vm_gt_char(vm_t *);
err_t vm_gt_int(vm_t *);
err_t vm_gt_sbyte(vm_t *);
err_t vm_gt_short(vm_t *);
err_t vm_gt_sshort(vm_t *);
err_t vm_gt_shword(vm_t *);
err_t vm_gt_hword(vm_t *);
err_t vm_gt_long(vm_t *);
err_t vm_gt_sword(vm_t *);
err_t vm_gt_word(vm_t *);
err_t vm_gte_byte(vm_t *);
err_t vm_gte_char(vm_t *);
err_t vm_gte_int(vm_t *);
err_t vm_gte_sbyte(vm_t *);
err_t vm_gte_short(vm_t *);
err_t vm_gte_sshort(vm_t *);
err_t vm_gte_shword(vm_t *);
err_t vm_gte_hword(vm_t *);
err_t vm_gte_long(vm_t *);
err_t vm_gte_sword(vm_t *);
err_t vm_gte_word(vm_t *);
err_t vm_plus_byte(vm_t *);
err_t vm_plus_short(vm_t *);
err_t vm_plus_hword(vm_t *);
err_t vm_plus_word(vm_t *);
err_t vm_sub_byte(vm_t *);
err_t vm_sub_short(vm_t *);
err_t vm_sub_hword(vm_t *);
err_t vm_sub_word(vm_t *);
err_t vm_mult_byte(vm_t *);
err_t vm_mult_short(vm_t *);
err_t vm_mult_hword(vm_t *);
err_t vm_mult_word(vm_t *);
typedef err_t (*stack_f)(vm_t *);
static const stack_f STACK_ROUTINES[] = {
[OP_MALLOC_STACK_BYTE] = vm_malloc_stack_byte,
[OP_MALLOC_STACK_SHORT] = vm_malloc_stack_short,
[OP_MALLOC_STACK_HWORD] = vm_malloc_stack_hword,
[OP_MALLOC_STACK_WORD] = vm_malloc_stack_word,
[OP_MGET_STACK_BYTE] = vm_mget_stack_byte,
[OP_MGET_STACK_HWORD] = vm_mget_stack_hword,
[OP_MGET_STACK_WORD] = vm_mget_stack_word,
[OP_MSET_STACK_BYTE] = vm_mset_stack_byte,
[OP_MSET_STACK_HWORD] = vm_mset_stack_hword,
[OP_MSET_STACK_WORD] = vm_mset_stack_word,
[OP_MDELETE] = vm_mdelete,
[OP_MSIZE] = vm_msize,
[OP_MGET_STACK_BYTE] = vm_mget_stack_byte,
[OP_MGET_STACK_SHORT] = vm_mget_stack_short,
[OP_MGET_STACK_HWORD] = vm_mget_stack_hword,
[OP_MGET_STACK_WORD] = vm_mget_stack_word,
[OP_MSET_STACK_BYTE] = vm_mset_stack_byte,
[OP_MSET_STACK_SHORT] = vm_mset_stack_short,
[OP_MSET_STACK_HWORD] = vm_mset_stack_hword,
[OP_MSET_STACK_WORD] = vm_mset_stack_word,
[OP_MDELETE] = vm_mdelete,
[OP_MSIZE] = vm_msize,
[OP_NOT_BYTE] = vm_not_byte,
[OP_NOT_SHORT] = vm_not_short,
[OP_NOT_HWORD] = vm_not_hword,
[OP_NOT_WORD] = vm_not_word,
[OP_OR_BYTE] = vm_or_byte,
[OP_OR_SHORT] = vm_or_short,
[OP_OR_HWORD] = vm_or_hword,
[OP_OR_WORD] = vm_or_word,
[OP_AND_BYTE] = vm_and_byte,
[OP_AND_SHORT] = vm_and_short,
[OP_AND_HWORD] = vm_and_hword,
[OP_AND_WORD] = vm_and_word,
[OP_XOR_BYTE] = vm_xor_byte,
[OP_XOR_SHORT] = vm_xor_short,
[OP_XOR_HWORD] = vm_xor_hword,
[OP_XOR_WORD] = vm_xor_word,
[OP_EQ_BYTE] = vm_eq_byte,
[OP_EQ_SHORT] = vm_eq_short,
[OP_EQ_HWORD] = vm_eq_hword,
[OP_EQ_WORD] = vm_eq_word,
[OP_LT_BYTE] = vm_lt_byte,
[OP_LT_SBYTE] = vm_lt_sbyte,
[OP_LT_SHORT] = vm_lt_short,
[OP_LT_SSHORT] = vm_lt_sshort,
[OP_LT_SHWORD] = vm_lt_shword,
[OP_LT_HWORD] = vm_lt_hword,
[OP_LT_SWORD] = vm_lt_sword,
@@ -232,6 +286,8 @@ static const stack_f STACK_ROUTINES[] = {
[OP_LTE_BYTE] = vm_lte_byte,
[OP_LTE_SBYTE] = vm_lte_sbyte,
[OP_LTE_SHORT] = vm_lte_short,
[OP_LTE_SSHORT] = vm_lte_sshort,
[OP_LTE_SHWORD] = vm_lte_shword,
[OP_LTE_HWORD] = vm_lte_hword,
[OP_LTE_SWORD] = vm_lte_sword,
@@ -239,6 +295,8 @@ static const stack_f STACK_ROUTINES[] = {
[OP_GT_BYTE] = vm_gt_byte,
[OP_GT_SBYTE] = vm_gt_sbyte,
[OP_GT_SHORT] = vm_gt_short,
[OP_GT_SSHORT] = vm_gt_sshort,
[OP_GT_SHWORD] = vm_gt_shword,
[OP_GT_HWORD] = vm_gt_hword,
[OP_GT_SWORD] = vm_gt_sword,
@@ -246,19 +304,24 @@ static const stack_f STACK_ROUTINES[] = {
[OP_GTE_BYTE] = vm_gte_byte,
[OP_GTE_SBYTE] = vm_gte_sbyte,
[OP_GTE_SHORT] = vm_gte_short,
[OP_GTE_SSHORT] = vm_gte_sshort,
[OP_GTE_SHWORD] = vm_gte_shword,
[OP_GTE_HWORD] = vm_gte_hword,
[OP_GTE_SWORD] = vm_gte_sword,
[OP_GTE_WORD] = vm_gte_word,
[OP_PLUS_BYTE] = vm_plus_byte,
[OP_PLUS_SHORT] = vm_plus_short,
[OP_PLUS_HWORD] = vm_plus_hword,
[OP_PLUS_WORD] = vm_plus_word,
[OP_SUB_BYTE] = vm_sub_byte,
[OP_SUB_SHORT] = vm_sub_short,
[OP_SUB_HWORD] = vm_sub_hword,
[OP_SUB_WORD] = vm_sub_word,
[OP_MULT_BYTE] = vm_mult_byte,
[OP_MULT_SHORT] = vm_mult_short,
[OP_MULT_HWORD] = vm_mult_hword,
[OP_MULT_WORD] = vm_mult_word,
};