|
|
@@ -1,2 +1,356 @@
|
|
|
+#if 0
|
|
|
// TODO(bill): COMPLETELY REWORK THIS ENTIRE INTERPRETER
|
|
|
#include "dyncall/include/dyncall.h"
|
|
|
+
|
|
|
+struct vmInterpreter;
|
|
|
+
|
|
|
+/*
|
|
|
+Types:
|
|
|
+boolean
|
|
|
+integer
|
|
|
+float
|
|
|
+pointer
|
|
|
+string
|
|
|
+any
|
|
|
+array
|
|
|
+vector
|
|
|
+slice
|
|
|
+maybe
|
|
|
+struct
|
|
|
+union
|
|
|
+raw_union
|
|
|
+enum
|
|
|
+tuple
|
|
|
+proc
|
|
|
+*/
|
|
|
+
|
|
|
+struct vmProcedure {
|
|
|
+ Type * type;
|
|
|
+ String name;
|
|
|
+ b32 is_external;
|
|
|
+};
|
|
|
+
|
|
|
+struct vmValue {
|
|
|
+ void *data;
|
|
|
+ i32 id;
|
|
|
+ Type *type;
|
|
|
+ union {
|
|
|
+ i64 v_int;
|
|
|
+ f32 v_f32;
|
|
|
+ f64 v_f64;
|
|
|
+ vmProcedure * v_proc;
|
|
|
+ };
|
|
|
+};
|
|
|
+
|
|
|
+Array<vmValue> vm_empty_args = {};
|
|
|
+
|
|
|
+struct vmFrame {
|
|
|
+ vmInterpreter *i;
|
|
|
+ vmFrame * caller;
|
|
|
+ ssaProcedure * proc;
|
|
|
+ ssaBlock * block;
|
|
|
+ ssaBlock * prev_block;
|
|
|
+ isize instr_index; // For the current block
|
|
|
+
|
|
|
+ Array<void *> env; // Index == instr id
|
|
|
+ vmValue result;
|
|
|
+};
|
|
|
+
|
|
|
+struct vmInterpreter {
|
|
|
+ ssaModule * module;
|
|
|
+ BaseTypeSizes sizes;
|
|
|
+ gbArena stack_arena;
|
|
|
+ gbAllocator stack_allocator;
|
|
|
+ gbAllocator heap_allocator;
|
|
|
+
|
|
|
+ Array<vmFrame> frame_stack;
|
|
|
+ Map<vmValue> globals;
|
|
|
+};
|
|
|
+
|
|
|
+enum vmContinuation {
|
|
|
+ vmContinuation_Next,
|
|
|
+ vmContinuation_Return,
|
|
|
+ vmContinuation_Branch,
|
|
|
+};
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+i64 vm_size_of(vmInterpreter *i, Type *type) {
|
|
|
+ return type_size_of(i->sizes, i->heap_allocator, type);
|
|
|
+}
|
|
|
+i64 vm_align_of(vmInterpreter *i, Type *type) {
|
|
|
+ return type_align_of(i->sizes, i->heap_allocator, type);
|
|
|
+}
|
|
|
+i64 vm_offset_of(vmInterpreter *i, Type *type, i64 index) {
|
|
|
+ return type_offset_of(i->sizes, i->heap_allocator, type, index);
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+Array<vmValue> vm_prepare_call(vmFrame *f, ssaInstr *instr, vmValue *proc) {
|
|
|
+ GB_ASSERT(instr->kind == ssaInstr_Call);
|
|
|
+
|
|
|
+ *proc = vm_get_value(f, instr->Call.value);
|
|
|
+
|
|
|
+ Array<vmValue> args = {};
|
|
|
+ array_init_count(&args, f->i->stack_allocator, instr->Call.arg_count);
|
|
|
+
|
|
|
+ for (isize i = 0; i < instr->Call.arg_count; i++) {
|
|
|
+ args[i] = vm_get_value(f, instr->Call.args[i]);
|
|
|
+ }
|
|
|
+
|
|
|
+ return args;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+vmContinuation vm_visit_instr(vmFrame *f, ssaValue *value) {
|
|
|
+ ssaInstr *instr = &value->Instr;
|
|
|
+#if 1
|
|
|
+ if (instr->kind != ssaInstr_Comment) {
|
|
|
+ gb_printf("instr: %.*s\n", LIT(ssa_instr_strings[instr->kind]));
|
|
|
+ }
|
|
|
+#endif
|
|
|
+ switch (instr->kind) {
|
|
|
+ case ssaInstr_StartupRuntime: {
|
|
|
+
|
|
|
+ } break;
|
|
|
+
|
|
|
+ case ssaInstr_Comment: break;
|
|
|
+
|
|
|
+ case ssaInstr_Local: {
|
|
|
+ Type *type = ssa_type(value);
|
|
|
+ GB_ASSERT(is_type_pointer(type));
|
|
|
+ i64 size = gb_max(1, vm_size_of(f->i, type));
|
|
|
+ i64 align = gb_max(1, vm_align_of(f->i, type));
|
|
|
+ void *mem = gb_alloc_align(f->i->stack_allocator, size, align);
|
|
|
+
|
|
|
+ array_add(&f->locals, mem);
|
|
|
+ } break;
|
|
|
+
|
|
|
+ case ssaInstr_ZeroInit: {
|
|
|
+ Type *pt = ssa_type(instr->ZeroInit.address);
|
|
|
+ GB_ASSERT(is_type_pointer(pt));
|
|
|
+ vmValue addr = vm_get_value(f, instr->ZeroInit.address);
|
|
|
+ GB_ASSERT(are_types_identical(addr.type, ptr));
|
|
|
+ i64 size = vm_size_of(vm, type_deref(pt));
|
|
|
+ gb_zero(addr.v_ptr, size);
|
|
|
+ } break;
|
|
|
+
|
|
|
+ case ssaInstr_Store: {
|
|
|
+ ssaValue *addr = instr->Store.Address;
|
|
|
+ ssaValue *value = instr->Store.Value;
|
|
|
+ } break;
|
|
|
+
|
|
|
+ case ssaInstr_Load: {
|
|
|
+ ssaValue *addr = instr->Load.Address;
|
|
|
+ } break;
|
|
|
+
|
|
|
+ case ssaInstr_ArrayElementPtr: {
|
|
|
+
|
|
|
+ } break;
|
|
|
+
|
|
|
+ case ssaInstr_StructElementPtr: {
|
|
|
+
|
|
|
+ } break;
|
|
|
+
|
|
|
+ case ssaInstr_PtrOffset: {
|
|
|
+
|
|
|
+ } break;
|
|
|
+
|
|
|
+ case ssaInstr_Phi:
|
|
|
+ for_array(i, f->block->preds) {
|
|
|
+ ssaBlock *pred = f->block->preds[i];
|
|
|
+ if (f->prev_block == pred) {
|
|
|
+ vmValue edge = vm_get_value(f, instr->Phi.edges[i]);
|
|
|
+ // vm_set_value(f, value, edge);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+
|
|
|
+ case ssaInstr_ArrayExtractValue: {
|
|
|
+
|
|
|
+ } break;
|
|
|
+
|
|
|
+ case ssaInstr_StructExtractValue: {
|
|
|
+
|
|
|
+ } break;
|
|
|
+
|
|
|
+ case ssaInstr_Jump:
|
|
|
+ f->prev_block = f->block;
|
|
|
+ f->block = instr->Jump.block;
|
|
|
+ return vmContinuation_Branch;
|
|
|
+
|
|
|
+ case ssaInstr_If:
|
|
|
+ f->prev_block = f->block;
|
|
|
+ if (vm_get_value(f, instr->If.cond).v_int != 0) {
|
|
|
+ f->block = instr->If.true_block;
|
|
|
+ } else {
|
|
|
+ f->block = instr->If.false_block;
|
|
|
+ }
|
|
|
+ return vmContinuation_Branch;
|
|
|
+
|
|
|
+ case ssaInstr_Return:
|
|
|
+ if (instr->Return.value != NULL) {
|
|
|
+ Type *type = base_type(ssa_type(instr->Return.value));
|
|
|
+ GB_ASSERT(is_type_tuple(type));
|
|
|
+ f->result = vm_get_value(f, instr->Return.value);
|
|
|
+ if (type->Tuple.variable_count == 1) {
|
|
|
+ f->result.type = type->Tuple.variables[0]->type;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ f->block = NULL;
|
|
|
+ return vmContinuation_Return;
|
|
|
+
|
|
|
+ case ssaInstr_Conv: {
|
|
|
+
|
|
|
+ } break;
|
|
|
+
|
|
|
+ case ssaInstr_Unreachable: {
|
|
|
+ GB_PANIC("Unreachable");
|
|
|
+ } break;
|
|
|
+
|
|
|
+ case ssaInstr_BinaryOp: {
|
|
|
+
|
|
|
+ } break;
|
|
|
+
|
|
|
+ case ssaInstr_Call: {
|
|
|
+
|
|
|
+ } break;
|
|
|
+
|
|
|
+ case ssaInstr_Select: {
|
|
|
+
|
|
|
+ } break;
|
|
|
+
|
|
|
+ case ssaInstr_VectorExtractElement: {
|
|
|
+
|
|
|
+ } break;
|
|
|
+
|
|
|
+ case ssaInstr_VectorInsertElement: {
|
|
|
+
|
|
|
+ } break;
|
|
|
+
|
|
|
+ case ssaInstr_VectorShuffle: {
|
|
|
+
|
|
|
+ } break;
|
|
|
+
|
|
|
+ case ssaInstr_BoundsCheck: {
|
|
|
+
|
|
|
+ } break;
|
|
|
+
|
|
|
+ case ssaInstr_SliceBoundsCheck: {
|
|
|
+
|
|
|
+ } break;
|
|
|
+
|
|
|
+ default: {
|
|
|
+ GB_PANIC("<unknown instr> %d\n", instr->kind);
|
|
|
+ } break;
|
|
|
+ }
|
|
|
+
|
|
|
+ return vmContinuation_Next;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+void vm_run_frame(vmFrame *f) {
|
|
|
+ for (;;) {
|
|
|
+ for_array(i, f->block->instrs) {
|
|
|
+ ssaValue *v = f->block->instrs[i];
|
|
|
+ GB_ASSERT(v->kind == ssaValue_Instr);
|
|
|
+ switch (vm_visit_instr(f, v)) {
|
|
|
+ case vmContinuation_Return:
|
|
|
+ return;
|
|
|
+ case vmContinuation_Next:
|
|
|
+ // Do nothing
|
|
|
+ break;
|
|
|
+ case vmContinuation_Branch:
|
|
|
+ goto end;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ end:
|
|
|
+ ;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+ssaProcedure *vm_lookup_proc(vmInterpreter *i, String name) {
|
|
|
+ ssaValue **found = map_get(&i->module->members, hash_string(name));
|
|
|
+ if (found == NULL) {
|
|
|
+ return NULL;
|
|
|
+ }
|
|
|
+ ssaValue *v = *found;
|
|
|
+ if (v->kind != ssaValue_Proc) {
|
|
|
+ return NULL;
|
|
|
+ }
|
|
|
+
|
|
|
+ return &v->Proc;
|
|
|
+}
|
|
|
+
|
|
|
+vmValue vm_ext(vmFrame *caller, Array<vmValue> args) {
|
|
|
+ GB_PANIC("TODO(bill): vm_ext");
|
|
|
+ vmValue v = {};
|
|
|
+ return v;
|
|
|
+}
|
|
|
+
|
|
|
+vmValue vm_call(vmInterpreter *i, vmFrame *caller, ssaProcedure *proc, Array<vmValue> args) {
|
|
|
+ if (proc == NULL) {
|
|
|
+ GB_PANIC("Call to NULL procedure");
|
|
|
+ }
|
|
|
+
|
|
|
+ gb_printf("Call: %.*s", LIT(proc->name));
|
|
|
+
|
|
|
+ vmFrame f = {};
|
|
|
+ f.i = i;
|
|
|
+ f.caller = caller;
|
|
|
+ f.proc = proc;
|
|
|
+ if (proc->body == NULL) {
|
|
|
+ return vm_ext(&f, args);
|
|
|
+ }
|
|
|
+ f.block = proc->blocks[0];
|
|
|
+
|
|
|
+ map_init_with_reserve(&f.env, i->heap_allocator, 1.5*proc->instr_count);
|
|
|
+ defer (map_destroy(&f.env));
|
|
|
+
|
|
|
+ array_init_count(&f.locals, i->heap_allocator, proc->local_count);
|
|
|
+ defer (array_free(&f.locals));
|
|
|
+
|
|
|
+ for_array(i, proc->params) {
|
|
|
+ map_set(&f.env, hash_pointer(proc->params[i]), args[i]);
|
|
|
+ }
|
|
|
+
|
|
|
+ while (f.block != NULL) {
|
|
|
+ vm_run_frame(&f);
|
|
|
+ }
|
|
|
+
|
|
|
+ return f.result;
|
|
|
+}
|
|
|
+
|
|
|
+i32 vm_interpret(ssaModule *m) {
|
|
|
+ i32 exit_code = 2;
|
|
|
+
|
|
|
+ vmInterpreter i = {};
|
|
|
+
|
|
|
+ i.module = m;
|
|
|
+ i.sizes = m->sizes;
|
|
|
+
|
|
|
+ gb_arena_init_from_allocator(&i.stack_arena, heap_allocator(), gb_megabytes(64));
|
|
|
+ defer (gb_arena_free(&i.stack_arena));
|
|
|
+
|
|
|
+ i.stack_allocator = gb_arena_allocator(&i.stack_arena);
|
|
|
+ i.heap_allocator = heap_allocator();
|
|
|
+
|
|
|
+ ssaProcedure *main_proc = vm_lookup_proc(&i, make_string("main"));
|
|
|
+ if (main_proc != NULL) {
|
|
|
+ vm_call(&i, NULL, main_proc, vm_empty_args);
|
|
|
+ exit_code = 0;
|
|
|
+ } else {
|
|
|
+ gb_printf_err("No main procedure.");
|
|
|
+ exit_code = 1;
|
|
|
+ }
|
|
|
+
|
|
|
+ return exit_code;
|
|
|
+}
|
|
|
+
|
|
|
+#endif
|
Ginger Bill