Change AR layout

1 files changed, 67 insertions, 23 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;