stage2 提供c后端 提交stage1的测试

stage0/spl_mcode.c

@@ -127,44 +127,20 @@ static inline void wr64(unsigned char **p, spl_vm_val_t v) {
 /* Round n up to next multiple of 8 */
 #define ALIGN8(n) (((n) + 7) & ~7)
 
-int spl_prog_load_from_file(const char *fname, spl_prog_t *prog) {
-    FILE *f;
-    unsigned char *data;
-    long len;
+static int spl_prog_parse(const unsigned char *data, usize len, spl_prog_t *prog) {
     const unsigned char *p;
     spl_vm_val_t nfuncs, ninsns, nnatives, nstrs, ndata;
 
-    if (!fname || !prog)
+    if (!data || !prog)
         return -1;
-
-    f = fopen(fname, "rb");
-    if (!f)
+    if (len < 48)
         return -1;
-    fseek(f, 0, SEEK_END);
-    len = ftell(f);
-    fseek(f, 0, SEEK_SET);
-    if (len < 48) {
-        fclose(f);
-        return -1;
-    }
-    data = (unsigned char *)malloc((size_t)len);
-    if (!data) {
-        fclose(f);
-        return -1;
-    }
-    if (fread(data, 1, (size_t)len, f) != (size_t)len) {
-        free(data);
-        fclose(f);
-        return -1;
-    }
-    fclose(f);
 
     p = data;
 
     /* magic */
     if (p[0] != 'S' || p[1] != 'P' || p[2] != 'L' || p[3] != 'B' || p[4] != 'I' || p[5] != 'N' ||
         p[6] != '\0' || p[7] != '\0') {
-        free(data);
         return -1;
     }
     p += 8;
@@ -186,7 +162,6 @@ int spl_prog_load_from_file(const char *fname, spl_prog_t *prog) {
 
         func.name = (char *)malloc((usize)nlen);
         if (!func.name) {
-            free(data);
             return -1;
         }
         memcpy(func.name, p, (usize)nlen);
@@ -202,7 +177,6 @@ int spl_prog_load_from_file(const char *fname, spl_prog_t *prog) {
     /* ---- instructions ---- */
     for (spl_vm_val_t i = 0; i < ninsns; i++) {
         if ((size_t)(p - data) + 12 > (size_t)len) {
-            free(data);
             return -1;
         }
         spl_vm_ins_t ins;
@@ -221,7 +195,6 @@ int spl_prog_load_from_file(const char *fname, spl_prog_t *prog) {
 
         nat.name = (char *)malloc((usize)nlen);
         if (!nat.name) {
-            free(data);
             return -1;
         }
         memcpy(nat.name, p, (usize)nlen);
@@ -238,7 +211,6 @@ int spl_prog_load_from_file(const char *fname, spl_prog_t *prog) {
         usize pad = ALIGN8((usize)slen) - (usize)slen;
         char *s = (char *)malloc((usize)slen + 1);
         if (!s) {
-            free(data);
             return -1;
         }
         memcpy(s, p, (usize)slen);
@@ -254,7 +226,6 @@ int spl_prog_load_from_file(const char *fname, spl_prog_t *prog) {
         usize pad = ALIGN8(entry.size) - entry.size;
         entry.data = (unsigned char *)malloc(entry.size);
         if (!entry.data) {
-            free(data);
             return -1;
         }
         memcpy(entry.data, p, entry.size);
@@ -279,11 +250,46 @@ int spl_prog_load_from_file(const char *fname, spl_prog_t *prog) {
         }
     }
 
-    free(data);
     return 0;
 }
 
-int spl_prog_load_from_buffer(const char *buffer, usize len, spl_prog_t *prog) {}
+int spl_prog_load_from_file(const char *fname, spl_prog_t *prog) {
+    FILE *f;
+    unsigned char *data;
+    long len;
+    int rc;
+
+    if (!fname || !prog)
+        return -1;
+    f = fopen(fname, "rb");
+    if (!f)
+        return -1;
+    fseek(f, 0, SEEK_END);
+    len = ftell(f);
+    fseek(f, 0, SEEK_SET);
+    if (len < 48) {
+        fclose(f);
+        return -1;
+    }
+    data = (unsigned char *)malloc((size_t)len);
+    if (!data) {
+        fclose(f);
+        return -1;
+    }
+    if (fread(data, 1, (size_t)len, f) != (size_t)len) {
+        free(data);
+        fclose(f);
+        return -1;
+    }
+    fclose(f);
+    rc = spl_prog_parse(data, (usize)len, prog);
+    free(data);
+    return rc;
+}
+
+int spl_prog_load_from_buffer(const char *buffer, usize len, spl_prog_t *prog) {
+    return spl_prog_parse((const unsigned char *)buffer, len, prog);
+}
 
 int spl_prog_store_to_file(const char *fname, spl_prog_t *prog) {
     unsigned char *buf, *p;

stage0/spl_mcode.h

@@ -195,6 +195,7 @@ void spl_prog_dump(spl_prog_t *prog);
 
 
 int spl_prog_load_from_file(const char *fname, spl_prog_t *prog);
+int spl_prog_load_from_buffer(const char *buffer, usize len, spl_prog_t *prog);
 int spl_prog_store_to_file(const char *fname, spl_prog_t *prog);
 
 int spl_prog_add_instr(spl_prog_t *prog, uint8_t opcode, uint8_t type, spl_vm_val_t imm);

stage0/spl_syscall.c

@@ -423,6 +423,33 @@ static spl_vm_val_t vm_load(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
     return (spl_vm_val_t)(uintptr_t)prog;
 }
 
+/* vm_load_from_buffer - 从内存加载字节码（comptime 内嵌 VM 用）。
+ * 参数 1 是 slice 结构 { ptr, len } 的地址（聚合参数按指针传递）。 */
+static spl_vm_val_t vm_load_from_buffer(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    (void)_vm;
+    CHECK_NARGS("vm_load_from_buffer", 3);
+    spl_vm_t *vm = (spl_vm_t *)(uintptr_t)args[0];
+    const char *buf = (const char *)(uintptr_t)args[1];
+    usize len = (usize)args[2];
+    spl_prog_t *prog;
+    if (!vm || !buf)
+        return -1;
+    prog = (spl_prog_t *)malloc(sizeof(spl_prog_t));
+    if (!prog)
+        return -1;
+    if (spl_prog_load_from_buffer(buf, len, prog) != 0) {
+        free(prog);
+        return -1;
+    }
+    spl_syscall_register(prog);
+    if (spl_vm_load_prog(vm, prog) != 0) {
+        spl_prog_drop(prog);
+        free(prog);
+        return -1;
+    }
+    return 0;
+}
+
 /* vm_push - push a value onto the sub-VM's stack (for passing arguments) */
 static spl_vm_val_t vm_push(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
     (void)_vm;
@@ -464,31 +491,36 @@ static spl_vm_val_t vm_call(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
         fprintf(stderr, "vm_call: function '%s' not found\n", name);
         return -1;
     }
-    if (vm->cp >= vm->config.max_call_depth - 1) {
+    if (vm->cp >= vm->config.max_call_depth) {
         fprintf(stderr, "vm_call: call stack overflow\n");
         return -1;
     }
 
-    /* Sentinel frame so the entry function's RET halts cleanly */
-    if (vm->cp == 0) {
-        vm->frames.data[vm->cp].saved_fp = 0;
-        vm->frames.data[vm->cp].saved_ip = (uintptr_t)-1;
-        vm->frames.data[vm->cp].nargs = 0;
-        vm->cp++;
-    }
-
-    /* Actual call frame (same logic as the CALL instruction) */
-    vm->frames.data[vm->cp].saved_fp = vm->fp;
-    vm->frames.data[vm->cp].saved_ip = vm->ip;
-    vm->frames.data[vm->cp].nargs = call_nargs;
-    vm->cp++;
-    vm->fp = vm->sp - call_nargs;
+    /* 入口调用：ip 置 -1 作为 sentinel，RET 时 halt 并把返回值写入 exit_code。
+     * 实参须已由 vm_push 压栈（sp = nargs）。 */
+    vm->ip = (uintptr_t)-1;
+    vm->cp = 0;
+    vm->fp = 0;
+    vm->frames.data[0].saved_sp = vm->sp - call_nargs;
+    vm->frames.data[0].saved_fp = vm->fp;
+    vm->frames.data[0].saved_ip = vm->ip;
+    vm->frames.data[0].nargs = call_nargs;
+    vm->cp = 1;
     vm->ip = (uintptr_t)func->address;
+    vm->fp = vm->sp - call_nargs;
     return 0;
 }
 
-/* vm_run - run a sub-VM to completion, returns exit_code */
-SYSCALL_1(vm_run, spl_vm_t *, spl_vm_run_until(a1, 0))
+/* vm_run - run a sub-VM to completion, returns exit_code（入口 RET 的值） */
+static spl_vm_val_t vm_run(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    (void)_vm;
+    CHECK_NARGS("vm_run", 1);
+    spl_vm_t *vm = (spl_vm_t *)(uintptr_t)args[0];
+    if (!vm)
+        return -1;
+    spl_vm_run_until(vm, 0);
+    return (spl_vm_val_t)vm->exit_code;
+}
 
 /* =================================================================
  * Registration
@@ -1163,6 +1195,7 @@ void spl_syscall_register(spl_prog_t *prog) {
         {"vm_new", 0, vm_new},
         {"vm_drop", 0, vm_drop},
         {"vm_load", 0, vm_load},
+        {"vm_load_from_buffer", 0, vm_load_from_buffer},
         {"vm_push", 0, vm_push},
         {"vm_call", 0, vm_call},
         {"vm_run", 0, vm_run},

stage0/spl_vm.c

@@ -824,7 +824,7 @@ static void spl_vm_sample(spl_vm_t *vm) {
 
     char buf[8192];
     usize len = 0;
-    for (isize i = 0; i < vm->cp; i++) {
+    for (usize i = 0; i < vm->cp; i++) {
         intptr_t s = (intptr_t)vm->frames.data[i].saved_ip;
         if (s <= 0)
             continue;