register struct update

README.md

@@ -12,8 +12,8 @@ Machine code interpreter written in pure C. Can execute programs up to 1 MEGABYT
 | code | name | arguments | details |
 |------|------|-----------|---------|
 | 00 | NOP  |           | ignored instruction |
-| 01 | PUSH | `dst_register`, `value_size(bytes)`, `value` | push constant value into `dst_register` | 
-| 02 | MOV  | `dst_register`, `src_register` | copy value from `src_register` to `dst_register`
+| 01 | MOVC | `dst_register`, `value` | push constant value into `dst_register` | 
+| 02 | MOVR  | `dst_register`, `src_register` | copy value from `src_register` to `dst_register`
 | 03 | ADD  | `dst_register`, `src_register` | `dst` += `src` |
 | 04 | SUB  | `dst_register`, `src_register` | `dst` -= `src` |
 | 05 | MUL  | `dst_register`, `src_register` | `dst` *= `src` |

examples/s.tasm

@@ -4,13 +4,13 @@
 
 .data:
 // named array of 8-bit values
-const8 msg "Hello, World :3\0"
+const8 msg "Hello, World :3\n\0"
 
 .main:
-push ax 1; // sys_write
-push bx 1; // stdout
-push cx @msg; // address of msg data
-push dx #msg; // size of msg data
+movc ax 1; // sys_write
+movc bx 1; // stdout
+movc cx @msg; // address of msg data
+movc dx #msg; // size of msg data
 sys
-push ax 0
+movc ax 0
 exit

src/VM/VM.h

@@ -3,28 +3,31 @@
 #include "../string/str.h"
 
 typedef union Register {
-    u32 u32v;
-    i32 i32v;
-    f32 f32v;
+    u64 u64v;
+    f64 f64v;
+    struct {
+        u32 u32v0;
+        u32 u32v1;
+    };
+    struct {
+        f32 f32v0;
+        f32 f32v1;
+    };
     struct { 
         u16 u16v0;
         u16 u16v1;
-    };
-    struct {
-        i16 i16v0;
-        i16 i16v1;
+        u16 u16v2;
+        u16 u16v3;
     };
     struct { 
         u8 u8v0;
         u8 u8v1;
         u8 u8v2;
         u8 u8v3;
-    };
-    struct { 
-        i8 i8v0;
-        i8 i8v1;
-        i8 i8v2;
-        i8 i8v3;
+        u8 u8v4;
+        u8 u8v5;
+        u8 u8v6;
+        u8 u8v7;
     };
 } Register;
 
@@ -38,13 +41,13 @@ typedef enum VMState {
 typedef struct VM {
     union {
         struct {
-            Register ax;
-            Register bx;
-            Register cx;
-            Register dx;
-        };
-        Register registers[4];
+            Register a;
+            Register b;
+            Register c;
+            Register d;
         };
+        Register array[4];
+    } registers;
     
     VMState state;
     char* NULLABLE(error_message); // not null on if state == VMState_InternalError

src/compiler/Compiler.c

@@ -68,7 +68,7 @@ static bool compileSection(Compiler* cmp, Section* sec){
     CompiledSection* cs = List_CompiledSection_expand(&cmp->binary.section_list, 1);
     CompiledSection_construct(cs, sec->name);
     if(!HashMap_CompiledSectionPtr_tryPush(&cmp->binary.section_map, cs->name, cs)){
-        returnError("duplicate section '%s'", str_copy(sec->name));
+        returnError("duplicate section '%s'", str_copy(sec->name).data);
     }
 
     // compile code
@@ -308,6 +308,10 @@ bool Compiler_compile(Compiler* cmp, cstr source_file_name, cstr out_file_name,
             for(u32 j = 0; j < sec->code.len; j++){
                 Operation* op = &sec->code.data[j];
                 const Instruction* instr = Instruction_getByOpcode(op->opcode);
+                if(instr == NULL){
+                    returnError("unknown opcode: %i", op->opcode)
+                }
+
                 printf("    %s", instr->name.data);
                 for(u32 k = 0; k < op->args.len; k++){
                     Argument* arg = &op->args.data[k];

src/compiler/Parser.c

@@ -259,10 +259,12 @@ bool Compiler_parse(Compiler* cmp){
                 // data definition starts with const
                 if(str_startsWith(instr_name, STR("const"))){
                     DataDefinition* dataDefPtr = List_DataDefinition_expand(&sec->data, 1);
+                    memset(dataDefPtr, 0, sizeof(DataDefinition));
                     parseDataDefinition(cmp, instr_name, dataDefPtr);
                 }
                 else {
                     Operation* operPtr = List_Operation_expand(&sec->code, 1);
+                    memset(operPtr, 0, sizeof(Operation));
                     parseOperation(cmp, instr_name, operPtr);
                 }
                 break;

src/instructions/impl/MOVC.c

@@ -1,15 +1,15 @@
 #include "impl_macros.h"
 
-/// PUSH [dst_register] [value_size] [value]
-i32 PUSH_impl(VM* vm){
+/// MOVC [dst_register] [value_size] [value]
+i32 MOVC_impl(VM* vm){
     u8 dst_register_i = 0;
     readRegisterVar(dst_register_i);
     /*u8 value_size = 0;
     readValueSizeVar(value_size);*/
     u8 value_size = 4;\
     
-    vm->registers[dst_register_i].u32v = 0;
-    if(!VM_dataRead(vm, &vm->registers[dst_register_i].u32v, vm->current_pos, value_size))
+    vm->registers.array[dst_register_i].u64v = 0;
+    if(!VM_dataRead(vm, &vm->registers.array[dst_register_i].u64v, vm->current_pos, value_size))
         return -1;
     vm->current_pos += value_size;
 

src/instructions/impl/MOVR.c

@@ -1,7 +1,7 @@
 #include "impl_macros.h"
 
-/// MOV [dst_register] [src_register]
-i32 MOV_impl(VM* vm){
+/// MOVR [dst_register] [src_register]
+i32 MOVR_impl(VM* vm){
     u8 dst_register_i = 0;
     readRegisterVar(dst_register_i);
     u8 src_register_i = 0;
@@ -11,6 +11,6 @@ i32 MOV_impl(VM* vm){
         return -1;
     }
 
-    vm->registers[dst_register_i].u32v = vm->registers[src_register_i].u32v;
+    vm->registers.array[dst_register_i].u64v = vm->registers.array[src_register_i].u64v;
     return sizeof(dst_register_i) + sizeof(src_register_i);
 }

src/instructions/impl/SYS.c

@@ -19,9 +19,9 @@ FILE* NULLABLE(fileFromN)(VM* vm, u32 file_n){
 // cx - buffer ptr
 // dx - buffer size
 i32 SYS_read(VM* vm){
-    const u32 file_n = vm->bx.u32v;
-    u8* const buf = vm->data + vm->cx.u32v;
-    const u32 size = vm->dx.u32v;
+    const u32 file_n = vm->registers.b.u32v0;
+    u8* const buf = vm->data + vm->registers.c.u32v0;
+    const u32 size = vm->registers.d.u32v0;
 
     if(buf + size > vm->data + vm->data_size)
         return 40;
@@ -35,9 +35,9 @@ i32 SYS_read(VM* vm){
 // cx - buffer ptr
 // dx - buffer size
 i32 SYS_write(VM* vm){
-    const u32 file_n = vm->bx.u32v;
-    u8* const buf = vm->data + vm->cx.u32v;
-    const u32 size = vm->dx.u32v;
+    const u32 file_n = vm->registers.b.u32v0;
+    u8* const buf = vm->data + vm->registers.c.u32v0;
+    const u32 size = vm->registers.d.u32v0;
 
     if(buf + size > vm->data + vm->data_size)
         return 41;
@@ -50,13 +50,13 @@ i32 SYS_write(VM* vm){
 /// before call: ax - func code
 /// after  call: ax - result code
 i32 SYS_impl(VM* vm){
-    u8 func_code = vm->ax.u8v0;
-    u32 result_code = 0;
+    u32 func_code = vm->registers.a.u32v0;
+    i32 result_code = 0;
     switch(func_code){
         case 0:
             result_code = SYS_read(vm);
             break;
-        case 1:;
+        case 1:
             result_code = SYS_write(vm);
             break;
         default:
@@ -64,6 +64,6 @@ i32 SYS_impl(VM* vm){
             return -1;
     }
 
-    vm->ax.u32v = result_code;
+    vm->registers.a.u64v = result_code;
     return 0;
 }

src/instructions/impl/impl_macros.h

@@ -23,7 +23,7 @@
 
 /*
 #define validateValueSize(VAR) {\
-    if(VAR < 1 || VAR > 4){\
+    if(VAR < 1 || VAR > 8){\
         VM_setError(vm, "invalid value_size (%x)", VAR);\
         return -1;\
     }\

src/instructions/impl/math_operators.c

@@ -10,13 +10,16 @@
     \
     switch(value_size){\
         case 1: \
-            vm->registers[dst_register_i].u8v0 OPERATOR##= vm->registers[src_register_i].u8v0;\
+            vm->registers.array[dst_register_i].u8v0 OPERATOR##= vm->registers.array[src_register_i].u8v0;\
             break;\
         case 2: \
-            vm->registers[dst_register_i].u16v0 OPERATOR##= vm->registers[src_register_i].u16v0;\
+            vm->registers.array[dst_register_i].u16v0 OPERATOR##= vm->registers.array[src_register_i].u16v0;\
             break;\
         case 4: \
-            vm->registers[dst_register_i].u32v OPERATOR##= vm->registers[src_register_i].u32v;\
+            vm->registers.array[dst_register_i].u32v0 OPERATOR##= vm->registers.array[src_register_i].u32v0;\
+            break;\
+        case 8: \
+            vm->registers.array[dst_register_i].u64v OPERATOR##= vm->registers.array[src_register_i].u64v;\
             break;\
     }\
     return sizeof(dst_register_i) + sizeof(src_register_i) + sizeof(value_size);\

src/instructions/instructions.c

@@ -2,8 +2,8 @@
 #include "../collections/HashMap.h"
 
 i32 NOP_impl(VM* vm);
-i32 PUSH_impl(VM* vm);
-i32 MOV_impl(VM* vm);
+i32 MOVC_impl(VM* vm);
+i32 MOVR_impl(VM* vm);
 i32 ADD_impl(VM* vm);
 i32 SUB_impl(VM* vm);
 i32 MUL_impl(VM* vm);
@@ -17,8 +17,8 @@ i32 CALL_impl(VM* vm);
 Array_declare(Instruction);
 static const Array_Instruction instructions_array = ARRAY(Instruction, {
     Instruction_construct(NOP),
-    Instruction_construct(PUSH),
-    Instruction_construct(MOV),
+    Instruction_construct(MOVC),
+    Instruction_construct(MOVR),
     Instruction_construct(ADD),
     Instruction_construct(SUB),
     Instruction_construct(MUL),

src/instructions/instructions.h

@@ -7,8 +7,8 @@ typedef i32 (*InstructionImplFunc_t)(VM* vm);
 
 typedef enum __attribute__((__packed__)) Opcode {
     Opcode_NOP,
-    Opcode_PUSH,
-    Opcode_MOV,
+    Opcode_MOVC,
+    Opcode_MOVR,
     Opcode_ADD,
     Opcode_SUB,
     Opcode_MUL,