Add barebones stack vm

2 files changed, 127 insertions, 3 deletions

diff --git a/Makefile b/Makefile
index 732766e..dd3f3ae 100644
--- a/Makefile
+++ b/Makefile
@@ -7,7 +7,7 @@ BUILD_DIR   := build
 TESTS_DIR   := tests
 TEST_FILES  := $(wildcard $(TESTS_DIR)/*.bad)
 SRC_MAIN    := $(SRC_DIR)/main.c
-SRC_RUN     := tests/loops.bad
+SRC_RUN     := tests/expressions.bad
 WATCH_SRC   := $(shell find $(SRC_DIR) -name "*.c" -or -name "*.s" -or -name "*.h")
 INC_DIRS    := $(shell find $(SRC_DIR) -type d)
 INC_FLAGS   := $(addprefix -I,$(INC_DIRS))
diff --git a/src/main.c b/src/main.c
index 66142bd..a6e1cf6 100644
--- a/src/main.c
+++ b/src/main.c
@@ -21,6 +21,104 @@ init(void) {
     log_init_default();
 }
 
+typedef struct Instruction {
+    u8 a;
+    u8 b;
+    u8 c;
+    u8 op;
+} Instruction;
+
+typedef union Constant {
+    s64 i;
+    u64 u;
+    double d;
+    ptrsize ptr;
+} Constant;
+
+typedef struct Chunk {
+    Instruction *code;
+    Constant *constants;
+    Str file_name;
+    // TODO: line/col info for debugging.
+} Chunk;
+
+typedef enum OpCode {
+    OP_HALT,
+    OP_ADD_INT,
+} OpCode;
+
+Str op_str[] = {
+    [OP_HALT]    = cstr("HALT   "),
+    [OP_ADD_INT] = cstr("ADD    "),
+};
+
+void
+disassemble_instruction(Instruction instruction) {
+    switch (instruction.op) {
+        case OP_ADD_INT:
+            println("%s %d %d %d", op_str[instruction.op], instruction.a,
+                    instruction.b, instruction.c);
+            break;
+        case OP_HALT: println("%s", op_str[instruction.op]); break;
+        default: println("Unknown opcode %d", instruction.op); break;
+    }
+}
+
+void
+disassemble_chunk(Chunk chunk) {
+    println("%s: ========= code =========", chunk.file_name);
+    for (sz i = 0; i < array_size(chunk.code); i++) {
+        print("%s: %x{4}:  ", chunk.file_name, i);
+        disassemble_instruction(chunk.code[i]);
+    }
+    if (array_size(chunk.constants) > 0) {
+        println("%s: ======= constants ======", chunk.file_name);
+        for (sz i = 0; i < array_size(chunk.constants); i++) {
+            println("%s: %x{2}:  %f", chunk.file_name, i, chunk.constants[i]);
+        }
+    }
+}
+
+typedef struct VM {
+    Chunk *chunk;
+    Constant regs[256];
+    Instruction *ip;
+} VM;
+
+void
+vm_init(VM *vm, Chunk *chunk) {
+    assert(vm);
+    assert(chunk);
+    vm->chunk = chunk;
+    for (sz i = 0; i < array_size(chunk->constants); i++) {
+        vm->regs[i] = chunk->constants[i];
+    }
+    vm->ip = vm->chunk->code;
+}
+
+void
+vm_run(VM *vm) {
+    println("VM running...");
+    while (true) {
+        Instruction instruction = *vm->ip++;
+#if DEBUG == 1
+        print("IP: %d  -> ", vm->ip - vm->chunk->code - 1);
+        disassemble_instruction(instruction);
+#endif
+        switch (instruction.op) {
+            case OP_ADD_INT: {
+                u8 dst = instruction.a;
+                u8 src_a = instruction.b;
+                u8 src_b = instruction.c;
+                vm->regs[dst].u = vm->regs[src_a].u + vm->regs[src_b].u;
+            } break;
+            case OP_HALT: {
+                return;
+            }
+        }
+    }
+}
+
 void
 process_file(Str path) {
     Arena lexer_arena = arena_create(LEXER_MEM, os_allocator);
@@ -73,6 +171,7 @@ process_file(Str path) {
             break;
         }
     }
+    parse_consume(&parser, TOK_EOF, cstr("expected end of file"));
     if (parser.err) {
         exit(EXIT_FAILURE);
     }
@@ -80,14 +179,39 @@ process_file(Str path) {
         graph_ast(parser.nodes);
         goto stop;
     }
-
+    // TODO: Semantic analysis.
+    // TODO: Type checking.
+    // TODO: Compile roots.
     sz n_roots = array_size(parser.nodes);
     for (sz i = 0; i < n_roots; i++) {
         // The parser stores the root nodes as a stack.
         Node *root = parser.nodes[i];
+        // compile_expr(Node *root)
         (void)root;
     }
-    parse_consume(&parser, TOK_EOF, cstr("expected end of file"));
+
+    // Run bytecode on VM.
+    Arena bytecode_arena = arena_create(LEXER_MEM, os_allocator);
+    Chunk chunk = {.file_name = path};
+    array_init(chunk.constants, 256, &bytecode_arena);
+    array_init(chunk.code, 0xffff, &bytecode_arena);
+
+    // FIXME: Some debugging instructions for now.
+    array_push(chunk.constants, (Constant){.u = 1}, &bytecode_arena);
+    array_push(chunk.constants, (Constant){.u = 2}, &bytecode_arena);
+    Instruction add = (Instruction){.op = OP_ADD_INT, .a = 2, .b = 0, .c = 1};
+    array_push(chunk.code, add, &bytecode_arena);
+    array_push(chunk.code, (Instruction){.op = OP_HALT}, &bytecode_arena);
+    disassemble_chunk(chunk);
+
+    // Testing VM execution here.
+    VM vm = {0};
+    vm_init(&vm, &chunk);
+    println("VM REGISTERS BEFORE:\n%{Mem}",
+            &(Array){.mem = (u8 *)&vm.regs, sizeof(vm.regs)});
+    vm_run(&vm);
+    println("VM REGISTERS AFTER:\n%{Mem}",
+            &(Array){.mem = (u8 *)&vm.regs, sizeof(vm.regs)});
 
 stop:
     // Free up resources.