Change AR layout

3 files changed, 131 insertions, 47 deletions

diff --git a/src/compiler.c b/src/compiler.c
index d1c56b3..9b6a458 100644
--- a/src/compiler.c
+++ b/src/compiler.c
@@ -96,8 +96,11 @@ typedef enum OpCode {
     OP_CALL,     // call fx        ; Bumps the stack pointer by cx
     OP_RET,      // ret            ; Returns from current function
     OP_RESERVE,  // reserve cx     ; Increments the stack pointer by cx bytes
-    OP_POP,      // pop     cx     ; Decrements the stack pointer by cx bytes
-    OP_SPVAL,    // val     rx, cx ; u64 *stack; rx = stack[cx]
+    OP_POP,      // pop     rx     ; Pops the last value of the stack into rx.
+    OP_PUSH,     // push    rx     ; Push the rx value to the stack.
+    OP_PUSHI,    // pushi   cx     ; Push the cx value to the stack.
+    OP_PUTRET,   // putret  rx     ; Put rx into the return value memory.
+    OP_PUTRETI,  // putreti cx     ; Put cx into the return value memory.
     // Printing values with builtin print/println functions.
     OP_PRINTSTR,   // p  rx
     OP_PRINTS64,   // p  rx
@@ -202,12 +205,15 @@ Str op_str[] = {
     [OP_PRINTF64] = cstr("PRNTF64 "),
     [OP_PRINTS64I] = cstr("PRNTS64I"),
     [OP_PRINTF64I] = cstr("PRNTF64I"),
+    [OP_PUTRET] = cstr("PUTRET  "),
+    [OP_PUTRETI] = cstr("PUTRETI "),
     // Functions.
     [OP_CALL] = cstr("CALL    "),
     [OP_RET] = cstr("RET     "),
     [OP_RESERVE] = cstr("RESERVE "),
     [OP_POP] = cstr("POP     "),
-    [OP_SPVAL] = cstr("SPVAL   "),
+    [OP_PUSH] = cstr("PUSH    "),
+    [OP_PUSHI] = cstr("PUSHI   "),
     // Load ops.
     [OP_LD8K] = cstr("LD8K    "),
     [OP_LD16K] = cstr("LD16K   "),
@@ -831,33 +837,57 @@ compile_funcall(Chunk *chunk, Node *node) {
     }
     Function fun = map->val;
 
-    // TODO: prologue (how much space do we actually need)? we need the symbol
-    // table, arity and return parameters boy.
-    // FIXME: assuming all values are 8 bytes for now...
-    sz alloc_size = (fun.param_arity + fun.return_arity) * 8;
-    sz alloc_const = add_constant(chunk, alloc_size);
-    if (alloc_size > 0) {
-        EMIT_OP(OP_RESERVE, alloc_const, 0, 0, node, chunk);
+    // Reserve space for the return value if needed.
+    if (fun.return_arity > 0) {
+        // Put the return data into a register
+        sz ret_size = add_constant(chunk, 8);
+        EMIT_OP(OP_RESERVE, ret_size, 0, 0, node, chunk);
+    }
+
+    // Send parameters to the stack.
+    for (sz i = 0; i < array_size(node->elements); i++) {
+        Node *expr = node->elements[i];
+        CompResult result = compile_expr(chunk, expr);
+        // TODO: Assuming all values are 8 bytes... again.
+        switch (result.type) {
+            case COMP_CONST: {
+                EMIT_OP(OP_PUSHI, result.idx, 0, 0, expr, chunk);
+            } break;
+            case COMP_REG: {
+                EMIT_OP(OP_PUSH, result.idx, 0, 0, expr, chunk);
+            } break;
+            default: {
+                return (CompResult){.type = COMP_ERR};
+            } break;
+        }
     }
 
-    // println("FUNCALL: unique name: %s", node->unique_name);
-    // println("FUN: param_arity: %d", fun.param_arity);
-    // println("FUN: return_arity: %d", fun.return_arity);
+    // // TODO: prologue (how much space do we actually need)? we need the
+    // symbol
+    // // table, arity and return parameters boy.
+    // // FIXME: assuming all values are 8 bytes for now...
+    // sz alloc_size = (fun.param_arity + fun.return_arity) * 8;
+    // sz alloc_const = add_constant(chunk, alloc_size);
+    // if (alloc_size > 0) {
+    //     // EMIT_OP(OP_RESERVE, alloc_const, 0, 0, node, chunk);
+    // }
+
+    // // println("FUNCALL: unique name: %s", node->unique_name);
+    // // println("FUN: param_arity: %d", fun.param_arity);
+    // // println("FUN: return_arity: %d", fun.return_arity);
     EMIT_OP(OP_CALL, fun.index, 0, 0, node, chunk);
 
     // Only one return parameter for now.
     if (fun.return_arity > 0) {
         // Put the return data into a register
         sz reg_dst = chunk->reg_idx++;
-        sz ret_offset = add_constant(chunk, -fun.return_arity);
-        EMIT_OP(OP_SPVAL, reg_dst, ret_offset, 0, node, chunk);
-        EMIT_OP(OP_POP, alloc_const, 0, 0, node, chunk);
+        EMIT_OP(OP_POP, reg_dst, 0, 0, node, chunk);
         return (CompResult){.type = COMP_REG, .idx = reg_dst};
     }
 
-    if (alloc_size > 0) {
-        EMIT_OP(OP_POP, alloc_const, 0, 0, node, chunk);
-    }
+    // if (alloc_size > 0) {
+    //     // EMIT_OP(OP_POP, alloc_const, 0, 0, node, chunk);
+    // }
     // TODO: epilogue (how much space do we actually need)? we need to remove
     // the AR data here after using it. If we only have one return parameter we
     // can put it in a register but what if that's not actually the case?
@@ -887,8 +917,19 @@ compile_function(Chunk *chunk, Node *node) {
     };
     funcmap_insert(&chunk->funmap, func->name, fun, chunk->storage);
     array_push(chunk->functions, func, chunk->storage);
-    // TODO: put return values into memory.
-    compile_expr(func, node->func_body);
+
+    // Put return values into memory.
+    CompResult res = compile_expr(func, node->func_body);
+    switch (res.type) {
+        case COMP_CONST: {
+            EMIT_OP(OP_PUTRETI, res.idx, 0, 0, node, func);
+        } break;
+        case COMP_REG: {
+            EMIT_OP(OP_PUTRET, res.idx, 0, 0, node, func);
+        } break;
+        default: break;
+    }
+
     // TODO: handle captured locals/globals?
     EMIT_OP(OP_RET, 0, 0, 0, node, func);
     return (CompResult){.type = COMP_NIL};
@@ -1159,7 +1200,6 @@ disassemble_instruction(Instruction instruction) {
         case OP_LD16K:
         case OP_LD32K:
         case OP_LD64K:
-        case OP_SPVAL:
             println("%s r%d, c%d", op_str[instruction.op], instruction.dst,
                     instruction.a, instruction.b);
             break;
@@ -1264,13 +1304,17 @@ disassemble_instruction(Instruction instruction) {
         case OP_PRINTS64:
         case OP_PRINTF64:
         case OP_PRINTSTR:
+        case OP_PUSH:
+        case OP_POP:
+        case OP_PUTRET:
             println("%s r%d", op_str[instruction.op], instruction.dst,
                     instruction.a, instruction.b);
             break;
         case OP_PRINTS64I:
         case OP_PRINTF64I:
         case OP_RESERVE:
-        case OP_POP:
+        case OP_PUSHI:
+        case OP_PUTRETI:
             println("%s c%d", op_str[instruction.op], instruction.dst,
                     instruction.a, instruction.b);
             break;
diff --git a/src/vm.c b/src/vm.c
index 72887ea..2992a18 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -11,6 +11,7 @@ typedef struct VM {
     u8 stack[STACK_SIZE];
     Instruction *ip;
     u8 *sp;
+    u64 *fp;
     Constant *regs;
 } VM;
 
@@ -21,6 +22,7 @@ vm_init(VM *vm, Chunk *chunk) {
     assert(chunk->code);
     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;
@@ -266,49 +268,81 @@ vm_run(VM *vm) {
                 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->chunk->functions[dst];
 
-                // Store memory addresses we need to return to this function.
                 ptrsize chunk_addr = (ptrsize)vm->chunk;
                 ptrsize ip_addr = (ptrsize)vm->ip;
                 ptrsize reg_addr = (ptrsize)vm->regs;
-                u64 *p = (u64 *)vm->sp;
-                p[0] = chunk_addr;
-                p[1] = ip_addr;
-                p[2] = reg_addr;
-                vm->sp += sizeof(ptrsize);
-                vm->sp += sizeof(ptrsize);
-                vm->sp += sizeof(ptrsize);
+                ptrsize old_fp = (ptrsize)vm->fp;
 
                 // Allocate space for the locals.
-                vm->sp += func->var_off;
+                vm->fp = (u64 *)vm->sp;
+                vm->sp += func->var_off;  // FIXME: - func->n_params!
                 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_RET: {
-                // Deallocate locals.
-                vm->sp -= vm->chunk->var_off;
+                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.
-                u64 *p = (u64 *)vm->sp;
-                ptrsize chunk_addr = p[-3];
-                ptrsize ip_addr = p[-2];
-                ptrsize reg_addr = p[-1];
-                vm->sp -= sizeof(ptrsize);
-                vm->sp -= sizeof(ptrsize);
-                vm->sp -= sizeof(ptrsize);
                 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...");
diff --git a/tests/compilation.bad b/tests/compilation.bad
index c0da031..ea467d2 100644
--- a/tests/compilation.bad
+++ b/tests/compilation.bad
@@ -1,15 +1,21 @@
+fun adder(a: int): int {
+    ; a + 1
+    4
+}
+adder(2)
 ; let a = 1
 ; let b = 8
 
 ; a + b
 ; 1 + 2
-fun greet(): nil {
-    println("hello world")
-    ; 7
-}
+; fun greet(name: str): nil {
+; fun greet(name: str): nil {
+;     println("hello ")
+; }
 
-greet()
-greet()
+; greet("alex")
+; greet("ding")
+; greet()
 ; if true {
 ;     1
 ;     nil