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

Propagating short addition to data types into instructions

Browse Source 
(De)Serialising routines now can deal with shorts.
This commit is contained in:
Aryadev Chavali
2024-06-19 21:36:39 +01:00
parent f2addcef0a
commit 1ae28bdb3b
2 changed files with 184 additions and 79 deletions
Download Patch File Download Diff File Expand all files Collapse all files

233
lib/inst.c
View File

@@ -11,6 +11,7 @@
*/
#include "./inst.h"
#include "lib/base.h"
#include <assert.h>
#include <stdbool.h>
@@ -23,68 +24,92 @@ const char *opcode_as_cstr(opcode_t code)
{
case OP_NOOP:
return "NOOP";
case OP_HALT:
return "HALT";
case OP_PUSH_BYTE:
return "PUSH_BYTE";
case OP_PUSH_WORD:
return "PUSH_WORD";
case OP_PUSH_SHORT:
return "PUSH_SHORT";
case OP_PUSH_HWORD:
return "PUSH_HWORD";
case OP_PUSH_REGISTER_BYTE:
return "PUSH_REGISTER_BYTE";
case OP_PUSH_REGISTER_WORD:
return "PUSH_REGISTER_WORD";
case OP_PUSH_REGISTER_HWORD:
return "PUSH_REGISTER_HWORD";
case OP_PUSH_WORD:
return "PUSH_WORD";
case OP_POP_BYTE:
return "POP_BYTE";
case OP_POP_WORD:
return "POP_WORD";
case OP_POP_SHORT:
return "POP_SHORT";
case OP_POP_HWORD:
return "POP_HWORD";
case OP_POP_WORD:
return "POP_WORD";
case OP_PUSH_REGISTER_BYTE:
return "PUSH_REGISTER_BYTE";
case OP_PUSH_REGISTER_SHORT:
return "PUSH_REGISTER_SHORT";
case OP_PUSH_REGISTER_HWORD:
return "PUSH_REGISTER_HWORD";
case OP_PUSH_REGISTER_WORD:
return "PUSH_REGISTER_WORD";
case OP_MOV_BYTE:
return "MOV_BYTE";
case OP_MOV_WORD:
return "MOV_WORD";
case OP_MOV_SHORT:
return "MOV_SHORT";
case OP_MOV_HWORD:
return "MOV_HWORD";
case OP_MOV_WORD:
return "MOV_WORD";
case OP_DUP_BYTE:
return "DUP_BYTE";
case OP_DUP_SHORT:
return "DUP_SHORT";
case OP_DUP_HWORD:
return "DUP_HWORD";
case OP_DUP_WORD:
return "DUP_WORD";
case OP_MALLOC_BYTE:
return "MALLOC_BYTE";
case OP_MALLOC_SHORT:
return "MALLOC_SHORT";
case OP_MALLOC_HWORD:
return "MALLOC_HWORD";
case OP_MALLOC_WORD:
return "MALLOC_WORD";
case OP_MALLOC_STACK_BYTE:
return "MALLOC_STACK_BYTE";
case OP_MALLOC_STACK_SHORT:
return "MALLOC_STACK_SHORT";
case OP_MALLOC_STACK_HWORD:
return "MALLOC_STACK_HWORD";
case OP_MALLOC_STACK_WORD:
return "MALLOC_STACK_WORD";
case OP_MSET_BYTE:
return "MSET_BYTE";
case OP_MSET_SHORT:
return "MSET_SHORT";
case OP_MSET_HWORD:
return "MSET_HWORD";
case OP_MSET_WORD:
return "MSET_WORD";
case OP_MSET_STACK_BYTE:
return "MSET_STACK_BYTE";
case OP_MSET_STACK_SHORT:
return "MSET_STACK_SHORT";
case OP_MSET_STACK_HWORD:
return "MSET_STACK_HWORD";
case OP_MSET_STACK_WORD:
return "MSET_STACK_WORD";
case OP_MGET_BYTE:
return "MGET_BYTE";
case OP_MGET_SHORT:
return "MGET_SHORT";
case OP_MGET_HWORD:
return "MGET_HWORD";
case OP_MGET_WORD:
return "MGET_WORD";
case OP_MGET_STACK_BYTE:
return "MGET_STACK_BYTE";
case OP_MGET_STACK_SHORT:
return "MGET_STACK_SHORT";
case OP_MGET_STACK_HWORD:
return "MGET_STACK_HWORD";
case OP_MGET_STACK_WORD:
@@ -92,109 +117,159 @@ const char *opcode_as_cstr(opcode_t code)
case OP_MDELETE:
return "MDELETE";
case OP_MSIZE:
return "MDELETE";
return "MSIZE";
case OP_NOT_BYTE:
return "NOT_BYTE";
case OP_NOT_SHORT:
return "NOT_SHORT";
case OP_NOT_HWORD:
return "NOT_HWORD";
case OP_NOT_WORD:
return "NOT_WORD";
case OP_OR_BYTE:
return "OR_BYTE";
case OP_OR_SHORT:
return "OR_SHORT";
case OP_OR_HWORD:
return "OR_HWORD";
case OP_OR_WORD:
return "OR_WORD";
case OP_AND_BYTE:
return "AND_BYTE";
case OP_AND_SHORT:
return "AND_SHORT";
case OP_AND_HWORD:
return "AND_HWORD";
case OP_AND_WORD:
return "AND_WORD";
case OP_XOR_BYTE:
return "XOR_BYTE";
case OP_XOR_SHORT:
return "XOR_SHORT";
case OP_XOR_HWORD:
return "XOR_HWORD";
case OP_XOR_WORD:
return "XOR_WORD";
case OP_EQ_BYTE:
return "EQ_BYTE";
case OP_EQ_SHORT:
return "EQ_SHORT";
case OP_EQ_HWORD:
return "EQ_HWORD";
case OP_EQ_WORD:
return "EQ_WORD";
case OP_LT_BYTE:
return "LT_BYTE";
case OP_LT_SBYTE:
return "LT_SBYTE";
case OP_LT_HWORD:
return "LT_HWORD";
case OP_LT_SHWORD:
return "LT_SHWORD";
case OP_LT_SWORD:
return "LT_SWORD";
case OP_LT_WORD:
return "LT_WORD";
case OP_LTE_BYTE:
return "LTE_BYTE";
case OP_LTE_SBYTE:
return "LTE_SBYTE";
case OP_LTE_HWORD:
return "LTE_HWORD";
case OP_LTE_SHWORD:
return "LTE_SHWORD";
case OP_LTE_SWORD:
return "LTE_SWORD";
case OP_LTE_WORD:
return "LTE_WORD";
case OP_GT_BYTE:
return "GT_BYTE";
case OP_GT_SBYTE:
return "GT_SBYTE";
case OP_GT_HWORD:
return "GT_HWORD";
case OP_GT_SHWORD:
return "GT_SHWORD";
case OP_GT_SWORD:
return "GT_SWORD";
case OP_GT_WORD:
return "GT_WORD";
case OP_GTE_BYTE:
return "GTE_BYTE";
case OP_GTE_SBYTE:
return "GTE_SBYTE";
case OP_GTE_HWORD:
return "GTE_HWORD";
case OP_GTE_SHWORD:
return "GTE_SHWORD";
case OP_GTE_SWORD:
return "GTE_SWORD";
case OP_GTE_WORD:
return "GTE_WORD";
case OP_PLUS_BYTE:
return "PLUS_BYTE";
case OP_PLUS_SHORT:
return "PLUS_SHORT";
case OP_PLUS_HWORD:
return "PLUS_HWORD";
case OP_PLUS_WORD:
return "PLUS_WORD";
case OP_SUB_BYTE:
return "SUB_BYTE";
case OP_SUB_SHORT:
return "SUB_SHORT";
case OP_SUB_HWORD:
return "SUB_HWORD";
case OP_SUB_WORD:
return "SUB_WORD";
case OP_MULT_BYTE:
return "MULT_BYTE";
case OP_MULT_SHORT:
return "MULT_SHORT";
case OP_MULT_HWORD:
return "MULT_HWORD";
case OP_MULT_WORD:
return "MULT_WORD";
case OP_LT_BYTE:
return "LT_BYTE";
case OP_LT_SBYTE:
return "LT_SBYTE";
case OP_LT_SHORT:
return "LT_SHORT";
case OP_LT_SSHORT:
return "LT_SSHORT";
case OP_LT_HWORD:
return "LT_HWORD";
case OP_LT_SHWORD:
return "LT_SHWORD";
case OP_LT_WORD:
return "LT_WORD";
case OP_LT_SWORD:
return "LT_SWORD";
case OP_LTE_BYTE:
return "LTE_BYTE";
case OP_LTE_SBYTE:
return "LTE_SBYTE";
case OP_LTE_SHORT:
return "LTE_SHORT";
case OP_LTE_SSHORT:
return "LTE_SSHORT";
case OP_LTE_HWORD:
return "LTE_HWORD";
case OP_LTE_SHWORD:
return "LTE_SHWORD";
case OP_LTE_WORD:
return "LTE_WORD";
case OP_LTE_SWORD:
return "LTE_SWORD";
case OP_GT_BYTE:
return "GT_BYTE";
case OP_GT_SBYTE:
return "GT_SBYTE";
case OP_GT_SHORT:
return "GT_SHORT";
case OP_GT_SSHORT:
return "GT_SSHORT";
case OP_GT_HWORD:
return "GT_HWORD";
case OP_GT_SHWORD:
return "GT_SHWORD";
case OP_GT_WORD:
return "GT_WORD";
case OP_GT_SWORD:
return "GT_SWORD";
case OP_GTE_BYTE:
return "GTE_BYTE";
case OP_GTE_SBYTE:
return "GTE_SBYTE";
case OP_GTE_SHORT:
return "GTE_SHORT";
case OP_GTE_SSHORT:
return "GTE_SSHORT";
case OP_GTE_HWORD:
return "GTE_HWORD";
case OP_GTE_SHWORD:
return "GTE_SHWORD";
case OP_GTE_WORD:
return "GTE_WORD";
case OP_GTE_SWORD:
return "GTE_SWORD";
case OP_PRINT_BYTE:
return "PRINT_BYTE";
case OP_PRINT_SBYTE:
return "PRINT_SBYTE";
case OP_PRINT_SHORT:
return "PRINT_SHORT";
case OP_PRINT_SSHORT:
return "PRINT_SSHORT";
case OP_PRINT_HWORD:
return "PRINT_HWORD";
case OP_PRINT_SHWORD:
return "PRINT_SHWORD";
case OP_PRINT_WORD:
return "PRINT_WORD";
case OP_PRINT_SWORD:
return "PRINT_SWORD";
case OP_JUMP_ABS:
return "JUMP_ABS";
case OP_JUMP_STACK:
return "JUMP_STACK";
case OP_JUMP_IF_BYTE:
return "JUMP_IF_BYTE";
case OP_JUMP_IF_SHORT:
return "JUMP_IF_SHORT";
case OP_JUMP_IF_HWORD:
return "JUMP_IF_HWORD";
case OP_JUMP_IF_WORD:
@@ -205,20 +280,6 @@ const char *opcode_as_cstr(opcode_t code)
return "CALL_STACK";
case OP_RET:
return "RET";
case OP_PRINT_SBYTE:
return "PRINT_SBYTE";
case OP_PRINT_BYTE:
return "PRINT_BYTE";
case OP_PRINT_SHWORD:
return "PRINT_SHWORD";
case OP_PRINT_HWORD:
return "PRINT_HWORD";
case OP_PRINT_SWORD:
return "PRINT_SWORD";
case OP_PRINT_WORD:
return "PRINT_WORD";
case OP_HALT:
return "HALT";
case NUMBER_OF_OPCODES:
return "";
}
@@ -234,6 +295,9 @@ void data_print(data_t datum, data_type_t type, FILE *fp)
case DATA_TYPE_BYTE:
fprintf(fp, "%X", datum.as_byte);
break;
case DATA_TYPE_SHORT:
fprintf(fp, "%X", datum.as_short);
break;
case DATA_TYPE_HWORD:
fprintf(fp, "%X", datum.as_hword);
break;
@@ -245,7 +309,7 @@ void data_print(data_t datum, data_type_t type, FILE *fp)
void inst_print(inst_t instruction, FILE *fp)
{
static_assert(NUMBER_OF_OPCODES == 99, "inst_print: Out of date");
static_assert(NUMBER_OF_OPCODES == 129, "inst_print: Out of date");
fprintf(fp, "%s(", opcode_as_cstr(instruction.opcode));
if (UNSIGNED_OPCODE_IS_TYPE(instruction.opcode, OP_PUSH))
{
@@ -278,7 +342,7 @@ void inst_print(inst_t instruction, FILE *fp)
size_t opcode_bytecode_size(opcode_t opcode)
{
static_assert(NUMBER_OF_OPCODES == 99, "inst_bytecode_size: Out of date");
static_assert(NUMBER_OF_OPCODES == 129, "inst_bytecode_size: Out of date");
size_t size = 1; // for opcode
if (UNSIGNED_OPCODE_IS_TYPE(opcode, OP_PUSH))
{
@@ -303,7 +367,7 @@ size_t opcode_bytecode_size(opcode_t opcode)
size_t inst_write_bytecode(inst_t inst, byte_t *bytes)
{
static_assert(NUMBER_OF_OPCODES == 99, "inst_write_bytecode: Out of date");
static_assert(NUMBER_OF_OPCODES == 129, "inst_write_bytecode: Out of date");
bytes[0] = inst.opcode;
size_t written = 1;
@@ -331,6 +395,11 @@ size_t inst_write_bytecode(inst_t inst, byte_t *bytes)
written += 1;
break;
}
case DATA_TYPE_SHORT: {
convert_short_to_bytes(inst.operand.as_short, bytes + 1);
written += SHORT_SIZE;
break;
}
case DATA_TYPE_HWORD: {
convert_hword_to_bytes(inst.operand.as_hword, bytes + 1);
written += HWORD_SIZE;
@@ -358,6 +427,12 @@ bool read_type_from_darr(byte_t *bytes, size_t size, data_type_t type,
return false;
datum = DBYTE(bytes[0]);
break;
case DATA_TYPE_SHORT:
if (size < SHORT_SIZE)
return false;
short s = convert_bytes_to_short(bytes);
datum = DSHORT(s);
break;
case DATA_TYPE_HWORD:
if (size < HWORD_SIZE)
return false;
@@ -379,7 +454,7 @@ bool read_type_from_darr(byte_t *bytes, size_t size, data_type_t type,
int inst_read_bytecode(inst_t *ptr, byte_t *bytes, size_t size_bytes)
{
static_assert(NUMBER_OF_OPCODES == 99, "inst_read_bytecode: Out of date");
static_assert(NUMBER_OF_OPCODES == 129, "inst_read_bytecode: Out of date");
opcode_t opcode = *(bytes++);
if (opcode >= NUMBER_OF_OPCODES || opcode < OP_NOOP)

30
lib/inst.h
View File

@@ -31,47 +31,58 @@ typedef enum
// Dealing with data and registers
OP_PUSH_BYTE,
OP_PUSH_SHORT,
OP_PUSH_HWORD,
OP_PUSH_WORD,
OP_POP_BYTE,
OP_POP_SHORT,
OP_POP_HWORD,
OP_POP_WORD,
OP_PUSH_REGISTER_BYTE,
OP_PUSH_REGISTER_SHORT,
OP_PUSH_REGISTER_HWORD,
OP_PUSH_REGISTER_WORD,
OP_MOV_BYTE,
OP_MOV_SHORT,
OP_MOV_HWORD,
OP_MOV_WORD,
OP_DUP_BYTE,
OP_DUP_SHORT,
OP_DUP_HWORD,
OP_DUP_WORD,
// Dealing with the heap
OP_MALLOC_BYTE,
OP_MALLOC_SHORT,
OP_MALLOC_HWORD,
OP_MALLOC_WORD,
OP_MALLOC_STACK_BYTE,
OP_MALLOC_STACK_SHORT,
OP_MALLOC_STACK_HWORD,
OP_MALLOC_STACK_WORD,
OP_MSET_BYTE,
OP_MSET_SHORT,
OP_MSET_HWORD,
OP_MSET_WORD,
OP_MSET_STACK_BYTE,
OP_MSET_STACK_SHORT,
OP_MSET_STACK_HWORD,
OP_MSET_STACK_WORD,
OP_MGET_BYTE,
OP_MGET_SHORT,
OP_MGET_HWORD,
OP_MGET_WORD,
OP_MGET_STACK_BYTE,
OP_MGET_STACK_SHORT,
OP_MGET_STACK_HWORD,
OP_MGET_STACK_WORD,
@@ -80,41 +91,51 @@ typedef enum
// Boolean operations
OP_NOT_BYTE,
OP_NOT_SHORT,
OP_NOT_HWORD,
OP_NOT_WORD,
OP_OR_BYTE,
OP_OR_SHORT,
OP_OR_HWORD,
OP_OR_WORD,
OP_AND_BYTE,
OP_AND_SHORT,
OP_AND_HWORD,
OP_AND_WORD,
OP_XOR_BYTE,
OP_XOR_SHORT,
OP_XOR_HWORD,
OP_XOR_WORD,
OP_EQ_BYTE,
OP_EQ_SHORT,
OP_EQ_HWORD,
OP_EQ_WORD,
// Mathematical operations
OP_PLUS_BYTE,
OP_PLUS_SHORT,
OP_PLUS_HWORD,
OP_PLUS_WORD,
OP_SUB_BYTE,
OP_SUB_SHORT,
OP_SUB_HWORD,
OP_SUB_WORD,
OP_MULT_BYTE,
OP_MULT_SHORT,
OP_MULT_HWORD,
OP_MULT_WORD,
// Comparison operations
OP_LT_BYTE,
OP_LT_SBYTE,
OP_LT_SHORT,
OP_LT_SSHORT,
OP_LT_HWORD,
OP_LT_SHWORD,
OP_LT_WORD,
@@ -122,6 +143,8 @@ typedef enum
OP_LTE_BYTE,
OP_LTE_SBYTE,
OP_LTE_SHORT,
OP_LTE_SSHORT,
OP_LTE_HWORD,
OP_LTE_SHWORD,
OP_LTE_WORD,
@@ -129,6 +152,8 @@ typedef enum
OP_GT_BYTE,
OP_GT_SBYTE,
OP_GT_SHORT,
OP_GT_SSHORT,
OP_GT_HWORD,
OP_GT_SHWORD,
OP_GT_WORD,
@@ -136,6 +161,8 @@ typedef enum
OP_GTE_BYTE,
OP_GTE_SBYTE,
OP_GTE_SHORT,
OP_GTE_SSHORT,
OP_GTE_HWORD,
OP_GTE_SHWORD,
OP_GTE_WORD,
@@ -144,6 +171,8 @@ typedef enum
// Simple I/O
OP_PRINT_BYTE,
OP_PRINT_SBYTE,
OP_PRINT_SHORT,
OP_PRINT_SSHORT,
OP_PRINT_HWORD,
OP_PRINT_SHWORD,
OP_PRINT_WORD,
@@ -153,6 +182,7 @@ typedef enum
OP_JUMP_ABS,
OP_JUMP_STACK,
OP_JUMP_IF_BYTE,
OP_JUMP_IF_SHORT,
OP_JUMP_IF_HWORD,
OP_JUMP_IF_WORD,