1 files changed, 231 insertions, 31 deletions

diff --git a/src/vm.c b/src/vm.c
index 205c15a..0791706 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -5,12 +5,15 @@
 #include "compiler.c"
 
 #define N_CONST 256
-#define STACK_SIZE KB(64)
+#define STACK_SIZE MB(4)
 typedef struct VM {
+    Chunk *main;
     Chunk *chunk;
-    Constant regs[N_CONST];
     u8 stack[STACK_SIZE];
     Instruction *ip;
+    u8 *sp;
+    u64 *fp;
+    Constant *regs;
 } VM;
 
 void
@@ -18,8 +21,13 @@ vm_init(VM *vm, Chunk *chunk) {
     assert(vm);
     assert(chunk);
     assert(chunk->code);
+    vm->main = chunk;
     vm->chunk = chunk;
     vm->ip = vm->chunk->code;
+    vm->fp = (u64 *)vm->stack;
+    vm->sp = vm->stack + chunk->var_off;
+    vm->regs = (Constant *)vm->sp;
+    vm->sp += sizeof(Constant) * chunk->reg_idx;
 }
 
 #define OP_UNARY(OP, TYPE)                            \
@@ -77,6 +85,7 @@ vm_run(VM *vm) {
             case OP_NOT: OP_UNARY(!, i) break;
             case OP_BITNOT: OP_UNARY(~, i) break;
             case OP_BITOR: OP_BINARY(|, i) break;
+            case OP_BITXOR: OP_BINARY(^, i) break;
             case OP_BITAND: OP_BINARY(&, i) break;
             case OP_BITLSHIFT: OP_BINARY(<<, i) break;
             case OP_BITRSHIFT: OP_BINARY(>>, i) break;
@@ -107,6 +116,7 @@ vm_run(VM *vm) {
             case OP_NOTI: OP_UNARY_CONST(!, i) break;
             case OP_BITNOTI: OP_UNARY_CONST(~, i) break;
             case OP_BITORI: OP_BINARY_CONST(|, i) break;
+            case OP_BITXORI: OP_BINARY_CONST(^, i) break;
             case OP_BITANDI: OP_BINARY_CONST(&, i) break;
             case OP_BITLSHIFTI: OP_BINARY_CONST(<<, i) break;
             case OP_BITRSHIFTI: OP_BINARY_CONST(>>, i) break;
@@ -134,61 +144,121 @@ vm_run(VM *vm) {
                 vm->regs[dst].f =
                     fmod(vm->regs[src_a].f, vm->chunk->constants[src_b].f);
             } break;
+            case OP_STGVAR: {
+                u8 dst = instruction.dst;
+                u8 src = instruction.a;
+                Variable var = vm->main->vars[dst];
+                s64 *stack = (s64 *)&vm->stack[var.offset];
+                *stack = vm->regs[src].i;
+            } break;
+            case OP_STGVARI: {
+                u8 dst = instruction.dst;
+                u8 src = instruction.a;
+                Variable var = vm->main->vars[dst];
+                s64 *stack = (s64 *)&vm->stack[var.offset];
+                *stack = vm->chunk->constants[src].i;
+            } break;
             case OP_LDGVAR: {
                 u8 dst = instruction.dst;
                 u8 src = instruction.a;
-                Variable var = vm->chunk->vars[src];
+                Variable var = vm->main->vars[src];
                 s64 *stack = (s64 *)&vm->stack[var.offset];
                 vm->regs[dst].i = *stack;
             } break;
-            case OP_STGVAR: {
+            case OP_LDGADDR: {
                 u8 dst = instruction.dst;
                 u8 src = instruction.a;
-                Variable var = vm->chunk->vars[dst];
+                Variable var = vm->main->vars[src];
                 s64 *stack = (s64 *)&vm->stack[var.offset];
-                *stack = vm->regs[src].i;
+                vm->regs[dst].ptr = (ptrsize)stack;
             } break;
-            case OP_STGVARI: {
+            case OP_STLVAR: {
                 u8 dst = instruction.dst;
                 u8 src = instruction.a;
                 Variable var = vm->chunk->vars[dst];
-                s64 *stack = (s64 *)&vm->stack[var.offset];
-                *stack = vm->chunk->constants[src].i;
+                vm->fp[var.offset / 8] = vm->regs[src].i;
             } break;
-            case OP_JMPI: {
-                sz offset = vm->chunk->constants[instruction.dst].i;
-                vm->ip += offset - 1;
+            case OP_STLVARI: {
+                u8 dst = instruction.dst;
+                u8 src = instruction.a;
+                Variable var = vm->chunk->vars[dst];
+                vm->fp[var.offset / 8] = vm->chunk->constants[src].i;
+            } break;
+            case OP_LDLVAR: {
+                u8 dst = instruction.dst;
+                u8 src = instruction.a;
+                Variable var = vm->chunk->vars[src];
+                vm->regs[dst].i = vm->fp[var.offset / 8];
+            } break;
+            case OP_LDLADDR: {
+                u8 dst = instruction.dst;
+                u8 src = instruction.a;
+                Variable var = vm->chunk->vars[src];
+                vm->regs[dst].i = (ptrsize)&vm->fp[var.offset / 8];
+            } break;
+            case OP_LDSTR: {
+                u8 dst = instruction.dst;
+                u8 src = instruction.a;
+                Str *str = &vm->chunk->strings[src];
+                vm->regs[dst].ptr = (ptrsize)str;
+            } break;
+            case OP_ST64I: {
+                sz value = vm->regs[instruction.dst].ptr;
+                s64 *addr = (s64 *)vm->regs[instruction.a].ptr;
+                sz offset = vm->chunk->constants[instruction.b].i;
+                addr[offset] = value;
+            } break;
+            case OP_ST64: {
+                sz value = vm->regs[instruction.dst].i;
+                s64 *addr = (s64 *)vm->regs[instruction.a].ptr;
+                sz offset = vm->regs[instruction.b].i;
+                addr[offset] = value;
+            } break;
+            case OP_LD64I: {
+                s64 *addr = (s64 *)vm->regs[instruction.a].ptr;
+                sz offset = vm->chunk->constants[instruction.b].i;
+                vm->regs[instruction.dst].i = addr[offset];
+            } break;
+            case OP_LD64: {
+                s64 *addr = (s64 *)vm->regs[instruction.a].ptr;
+                sz offset = vm->regs[instruction.b].i;
+                vm->regs[instruction.dst].i = addr[offset];
+            } break;
+            case OP_JMP: {
+                u8 dst = instruction.dst;
+                sz pos = intintmap_lookup(&vm->chunk->labels, dst)->val;
+                vm->ip = vm->chunk->code + pos;
             } break;
             case OP_JMPFI: {
-                bool cond = vm->chunk->constants[instruction.dst].i;
-                sz offset = vm->chunk->constants[instruction.a].i;
+                u8 dst = instruction.dst;
+                sz pos = intintmap_lookup(&vm->chunk->labels, dst)->val;
+                bool cond = vm->chunk->constants[instruction.a].i;
                 if (!cond) {
-                    vm->ip += offset - 1;
+                    vm->ip = vm->chunk->code + pos;
                 }
             } break;
             case OP_JMPTI: {
-                bool cond = vm->chunk->constants[instruction.dst].i;
-                sz offset = vm->chunk->constants[instruction.a].i;
+                u8 dst = instruction.dst;
+                sz pos = intintmap_lookup(&vm->chunk->labels, dst)->val;
+                bool cond = vm->chunk->constants[instruction.a].i;
                 if (cond) {
-                    vm->ip += offset - 1;
+                    vm->ip = vm->chunk->code + pos;
                 }
             } break;
-            case OP_JMP: {
-                sz offset = vm->chunk->constants[instruction.dst].i;
-                vm->ip += offset - 1;
-            } break;
             case OP_JMPF: {
-                bool cond = vm->regs[instruction.dst].i;
-                sz offset = vm->chunk->constants[instruction.a].i;
+                u8 dst = instruction.dst;
+                sz pos = intintmap_lookup(&vm->chunk->labels, dst)->val;
+                bool cond = vm->regs[instruction.a].i;
                 if (!cond) {
-                    vm->ip += offset - 1;
+                    vm->ip = vm->chunk->code + pos;
                 }
             } break;
             case OP_JMPT: {
-                bool cond = vm->regs[instruction.dst].i;
-                sz offset = vm->chunk->constants[instruction.a].i;
+                u8 dst = instruction.dst;
+                sz pos = intintmap_lookup(&vm->chunk->labels, dst)->val;
+                bool cond = vm->regs[instruction.a].i;
                 if (cond) {
-                    vm->ip += offset - 1;
+                    vm->ip = vm->chunk->code + pos;
                 }
             } break;
             case OP_MOV64: {
@@ -211,10 +281,140 @@ vm_run(VM *vm) {
                 u8 src = instruction.a;
                 vm->regs[dst].i = vm->regs[src].i & 0xFF;
             } break;
+            case OP_PRINTS64: {
+                u8 idx = instruction.dst;
+                print("%d", vm->regs[idx].i);
+            } break;
+            case OP_PRINTS64I: {
+                u8 idx = instruction.dst;
+                print("%d", vm->chunk->constants[idx].i);
+            } break;
+            case OP_PRINTBOOL: {
+                u8 idx = instruction.dst;
+                bool val = vm->regs[idx].i;
+                if (val) {
+                    print("true");
+                } else {
+                    print("false");
+                }
+            } break;
+            case OP_PRINTBOOLI: {
+                u8 idx = instruction.dst;
+                bool val = vm->chunk->constants[idx].i;
+                if (val) {
+                    print("true");
+                } else {
+                    print("false");
+                }
+            } break;
+            case OP_PRINTF64: {
+                u8 idx = instruction.dst;
+                printf("%f", vm->regs[idx].f);
+            } break;
+            case OP_PRINTF64I: {
+                u8 idx = instruction.dst;
+                printf("%f", vm->chunk->constants[idx].f);
+            } break;
+            case OP_PRINTSTR: {
+                u8 idx = instruction.dst;
+                Str *string = (Str *)vm->regs[idx].ptr;
+                print("%s", *string);
+            } break;
+            case OP_PRINTSTRI: {
+                u8 idx = instruction.dst;
+                Str string = vm->chunk->strings[idx];
+                print("%s", string);
+            } break;
+            case OP_RESERVE: {
+                sz offset = vm->chunk->constants[instruction.dst].i;
+                vm->sp += offset;
+            } break;
+            case OP_PUSH: {
+                sz val = vm->regs[instruction.dst].i;
+                u64 *p = (u64 *)vm->sp;
+                *p = val;
+                vm->sp += sizeof(ptrsize);
+            } break;
+            case OP_PUSHI: {
+                sz val = vm->chunk->constants[instruction.dst].i;
+                u64 *p = (u64 *)vm->sp;
+                *p = val;
+                vm->sp += sizeof(ptrsize);
+            } break;
+            case OP_POP: {
+                vm->sp -= sizeof(ptrsize);
+                u64 *p = (u64 *)vm->sp;
+                vm->regs[instruction.dst].i = *p;
+            } break;
+            case OP_PUTRET: {
+                sz val = vm->regs[instruction.dst].i;
+                vm->fp[-1] = val;
+            } break;
+            case OP_PUTRETI: {
+                sz val = vm->chunk->constants[instruction.dst].i;
+                vm->fp[-1] = val;
+            } break;
+            case OP_CALL: {
+                u8 dst = instruction.dst;
+                Chunk *func = vm->main->functions[dst];
+
+                ptrsize chunk_addr = (ptrsize)vm->chunk;
+                ptrsize ip_addr = (ptrsize)vm->ip;
+                ptrsize reg_addr = (ptrsize)vm->regs;
+                ptrsize old_fp = (ptrsize)vm->fp;
+
+                // Allocate space for the locals.
+                memset(vm->sp, 0, func->var_off - func->param_off);
+                vm->fp = (u64 *)(vm->sp - func->param_off);
+                vm->sp += func->var_off - func->param_off;
+                vm->chunk = func;
+                vm->ip = func->code;
+                vm->regs = (Constant *)vm->sp;
+
+                // Allocate registers.
+                vm->sp += sizeof(Constant) * func->reg_idx;
+
+                // Store memory addresses we need to return to this function.
+                u64 *p = (u64 *)vm->sp;
+                p[0] = chunk_addr;
+                p[1] = ip_addr;
+                p[2] = reg_addr;
+                p[3] = old_fp;
+                vm->sp += sizeof(ptrsize) * 4;
+            } break;
+            case OP_RECUR: {
+                vm->ip = vm->chunk->code;
+            } break;
+            case OP_RET: {
+                u64 *p = (u64 *)vm->sp;
+                ptrsize chunk_addr = p[-4];
+                ptrsize ip_addr = p[-3];
+                ptrsize reg_addr = p[-2];
+                ptrsize old_fp = p[-1];
+                vm->sp -= sizeof(ptrsize) * 4;
+
+                // Deallocate registers.
+                vm->sp -= sizeof(Constant) * vm->chunk->reg_idx;
+
+                // Deallocate locals.
+                vm->sp -= vm->chunk->var_off;
+
+                // Restore previous activation record.
+                vm->regs = (Constant *)reg_addr;
+                vm->ip = (Instruction *)ip_addr;
+                vm->chunk = (Chunk *)chunk_addr;
+                vm->fp = (u64 *)old_fp;
+            } break;
             case OP_HALT: {
-                println("VM HALT (int)   -> %d", vm->regs[instruction.dst]);
-                println("VM HALT (float) -> %f", vm->regs[instruction.dst]);
-                println("VM HALT (hex)   -> %x", vm->regs[instruction.dst]);
+                println("VM halt...");
+                if (instruction.a != 0) {
+                    println("Result:");
+                    Constant result = vm->regs[instruction.dst];
+                    printf("\tint    -> %lld\n", result.i);
+                    printf("\tfloat  -> %.10e\n", result.f);
+                    printf("\thex    -> %llx\n", (u64)result.i);
+                    println("\tbinary -> %b", result.i);
+                }
                 return;
             }
             default: {