stage2 修复语义问题

gramma.pest

@@ -109,6 +109,10 @@ PostfixExpr = {
 
 ExprList = { (Expr ~ COMMA)* ~ Expr? }
 
+// 注：类型即表达式**仅限 comptime 上下文**（`comptime { ... }`、`comptime expr`、
+// `comptime fn` 的函数体）内。在这些上下文中，PrimaryExpr 额外接受
+// `AggregateTypeExpr`（如 `struct { ... }`）以及 `type` 元类型；其它上下文
+// 中类型只允许出现在 TypeExpr 位置。
 PrimaryExpr = {
     FLOAT_LITERAL
   | INTEGER_LITERAL
@@ -232,6 +236,7 @@ TypePrimary = {
   | KEYWORD_bool
   | KEYWORD_void
   | KEYWORD_ptr
+  | KEYWORD_type          // `type` 元类型（编译期类型的值类型）
   | FnTypeExpr
   | AggregateTypeExpr
   | TypeParenExpr

nob.c

@@ -5,9 +5,9 @@
 #define nob_cc_flags(cmd) nob_cmd_append(cmd, SPL_CFLAGS)
 #undef UNICODE
 #define NOB_IMPLEMENTATION
-#include "nob.h"
+#include "nob/nob.h"
 #undef NOB_IMPLEMENTATION
-#include "nob_popen.h"
+#include "nob/nob_popen.h"
 #ifdef _WIN32
 #include <consoleapi2.h>
 #endif
@@ -19,32 +19,7 @@
 // object files get rebuilt.
 static const char *CFLAGS_STAMP = BUILD_FOLDER ".cflags";
 
-/* clang-format off */
+#include "nob/nob_data.h"
-#define VM_SRCS "stage0/spl_mcode.c", "stage0/spl_syscall.c", "stage0/spl_vm.c",
-static const char *spl_cli_srcs[] = {"stage0/spl_cli.c", VM_SRCS};
-static const char *vm_test_srcs[] = {"stage0/test_spl_vm.c", VM_SRCS};
-static const char *splc0_srcs[] = {
-    "stage1/splc0.c",
-    "stage1/spl_diag.c",
-    "stage1/spl_tok.c",
-    "stage1/spl_lexer.c",
-    "stage1/spl_ast.c",
-    "stage1/spl_parser.c",
-    "stage1/spl_dumptree.c",
-    "stage1/spl_type.c",
-    "stage1/spl_fold.c",
-    "stage1/spl_lang_type.c",
-    "stage1/spl_attr.c",
-    "stage1/spl_scope.c",
-    "stage1/spl_sema.c",
-    "stage1/spl_intrin.c",
-    "stage1/spl_ir.c",
-    "stage1/spl_ast2ir.c",
-    "stage1/spl_layout.c",
-    "stage1/spl_ir2vm.c",
-    "stage0/spl_mcode.c",
-};
-/* clang-format on */
 
 static const char *obj_path(const char *src) {
     // "stage0/spl_vm.c" -> "build/stage0_spl_vm.o"
@@ -74,6 +49,8 @@ static const char *sir_path(const char *name) {
     return nob_temp_sprintf(BUILD_FOLDER "%s.sir", name);
 }
 
+static const char *c_path(const char *name) { return nob_temp_sprintf(BUILD_FOLDER "%s.c", name); }
+
 static bool sync_cflags_stamp(void) {
     Nob_String_View cflags = nob_sv_from_cstr(CFLAGS_STR);
     Nob_String_Builder old = {0};
@@ -99,38 +76,12 @@ static bool prepare_build(void) {
     return true;
 }
 
-typedef struct build {
-    const char *name;
-    enum {
-        BUILD_EXE,
-        BUILD_EXE_WITH_OPTIMIZATION,
-        BUILD_SIR,
-    } kind;
-    union {
-        struct {
-            const char **srcs;
-            size_t srcs_count;
-            const char **headers;
-            size_t headers_count;
-        } exe;
-        struct {
-            const char *src;
-            const char *compiler;
-        } sir;
-    };
-} build_t;
-
 typedef struct {
     const char **items;
     size_t count;
     size_t capacity;
 } str_da_t;
 
-typedef struct run {
-    const char *name;
-    const char *interpreter;
-} run_t;
-
 bool run_target(const char *name, Nob_Cmd *args);
 const char *build_target(const char *name);
 
@@ -199,56 +150,6 @@ defer:
     return NULL;
 }
 
-static build_t targets[] = {
-    {
-        "spl_cli",
-        BUILD_EXE_WITH_OPTIMIZATION,
-        .exe = {.srcs = spl_cli_srcs,
-                .srcs_count = NOB_ARRAY_LEN(spl_cli_srcs),
-                .headers = NULL,
-                .headers_count = 0},
-    },
-    {
-        "spl_cli_g",
-        BUILD_EXE,
-        .exe = {.srcs = spl_cli_srcs,
-                .srcs_count = NOB_ARRAY_LEN(spl_cli_srcs),
-                .headers = NULL,
-                .headers_count = 0},
-    },
-    {
-        "vm_test",
-        BUILD_EXE,
-        .exe = {.srcs = vm_test_srcs,
-                .srcs_count = NOB_ARRAY_LEN(vm_test_srcs),
-                .headers = NULL,
-                .headers_count = 0},
-    },
-    {
-        "splc0",
-        BUILD_EXE,
-        .exe = {.srcs = splc0_srcs,
-                .srcs_count = NOB_ARRAY_LEN(splc0_srcs),
-                .headers = NULL,
-                .headers_count = 0},
-    },
-    {
-        "splc1",
-        BUILD_SIR,
-        .sir = {.src = "stage2/splc1.spl", .compiler = "splc0"},
-    },
-    {
-        "splc1s",
-        BUILD_SIR,
-        .sir = {.src = "stage2/splc1.spl", .compiler = "splc1"},
-    },
-    {
-        "splc1r",
-        BUILD_SIR,
-        .sir = {.src = "stage2/splc1.spl", .compiler = "splc1s"},
-    },
-};
-
 const char *build_target(const char *name) {
     if (!prepare_build())
         return NULL;
@@ -274,6 +175,44 @@ const char *build_target(const char *name) {
             nob_cmd_free(cmd);
             return target_sir;
         }
+        case BUILD_NATIVE: {
+            Nob_Cmd cmd = {0};
+            const char *target_exe = exe_path(name);
+            const char *target_c = c_path(name);
+
+            // TODO need_rebuild
+            int needs = nob_needs_rebuild(target_c, target->native.deps, target->native.deps_count);
+            if (needs < 0)
+                return NULL;
+            if (needs != 0) {
+                nob_cmd_append(&cmd, "--dump", "c", target->native.src, target_c);
+                if (!run_target(target->native.compiler, &cmd)) {
+                    nob_log(NOB_ERROR, "failed to build `%s`", name);
+                    nob_cmd_free(cmd);
+                    return NULL;
+                }
+                cmd.count = 0;
+            }
+
+            needs = nob_needs_rebuild(target_exe, target->native.crt_deps,
+                                      target->native.crt_deps_count);
+            if (needs < 0)
+                return NULL;
+            if (needs == 0)
+                return target_exe;
+
+            nob_cc(&cmd);
+            nob_cmd_append(&cmd, "-I./stage0", "-O2", "-D_CRT_SECURE_NO_WARNINGS");
+            nob_cc_inputs(&cmd, target_c);
+            nob_cc_output(&cmd, target_exe);
+            if (!nob_cmd_run(&cmd)) {
+                nob_log(NOB_ERROR, "failed to build `%s`", name);
+                nob_cmd_free(cmd);
+                return NULL;
+            }
+            nob_cmd_free(cmd);
+            return target_exe;
+        }
         default:
             NOB_UNREACHABLE("build_t.kind");
         }
@@ -282,11 +221,6 @@ const char *build_target(const char *name) {
     return NULL;
 }
 
-static run_t runs[] = {
-    {"spl_cli", NULL},    {"vm_test", NULL},     {"splc0", NULL},
-    {"splc1", "spl_cli"}, {"splc1r", "spl_cli"}, {"splc1s", "spl_cli"},
-};
-
 bool run_target_dry(const char *name, Nob_Cmd *args, Nob_Cmd *result) {
     for (size_t i = 0; i < NOB_ARRAY_LEN(runs); ++i) {
         if (strcmp(runs[i].name, name) != 0) {
@@ -596,7 +530,7 @@ int main(int argc, char **argv) {
     SetConsoleOutputCP(CP_UTF8);
     SetConsoleCP(CP_UTF8);
 #endif
-    NOB_GO_REBUILD_URSELF_PLUS(argc, argv, "nob.h", "nob_popen.h");
+    NOB_GO_REBUILD_URSELF_PLUS(argc, argv, "nob/nob.h", "nob/nob_popen.h", "nob/nob_data.h");
     set_log_handler(nob_cancer_log_handler);
 
     const char *program_name = nob_shift(argv, argc);

nob/nob_data.h

@@ -0,0 +1,298 @@
+#ifndef __NOB_DATA_H__
+#define __NOB_DATA_H__
+
+/* clang-format off */
+#define VM_SRCS "stage0/spl_mcode.c", "stage0/spl_syscall.c", "stage0/spl_vm.c",
+
+static const char *stage0_headers[] = {
+    "stage0/spl_asp.h",   "stage0/spl_mcode.h",  "stage0/spl_syscall.h",
+    "stage0/spl_vm.h",    "stage0/spl_rt_core.h", "stage0/spl_rt.h",
+    "stage0/spl_vm_embed.h",
+};
+
+static const char *spl_cli_srcs[] = {"stage0/spl_cli.c", VM_SRCS};
+static const char *vm_test_srcs[] = {"stage0/test_spl_vm.c", VM_SRCS};
+static const char *splc0_srcs[] = {
+    "stage1/splc0.c",
+    "stage1/spl_diag.c",
+    "stage1/spl_tok.c",
+    "stage1/spl_lexer.c",
+    "stage1/spl_ast.c",
+    "stage1/spl_parser.c",
+    "stage1/spl_dumptree.c",
+    "stage1/spl_type.c",
+    "stage1/spl_fold.c",
+    "stage1/spl_lang_type.c",
+    "stage1/spl_attr.c",
+    "stage1/spl_scope.c",
+    "stage1/spl_sema.c",
+    "stage1/spl_intrin.c",
+    "stage1/spl_ir.c",
+    "stage1/spl_ast2ir.c",
+    "stage1/spl_layout.c",
+    "stage1/spl_ir2vm.c",
+    "stage1/ir_opt.c",
+    "stage1/vm_opt.c",
+    "stage0/spl_mcode.c",
+};
+
+static const char *splc1_crt_deps[] ={
+    "stage0/spl_rt.h",
+    "stage0/spl_vm_embed.h",
+    // TODO
+};
+
+static const char* splc1_deps[] = {
+    "stage2/sys/exit.spl",
+    "stage2/sys/file.spl",
+    "stage2/sys/mem.spl",
+    "stage2/sys/time.spl",
+    "stage2/sys/vm.spl",
+    "stage2/utils/algorithm.spl",
+    "stage2/utils/arena.spl",
+    "stage2/utils/ascii.spl",
+    "stage2/utils/byte_buffer.spl",
+    "stage2/utils/byte_view.spl",
+    "stage2/utils/error.spl",
+    "stage2/utils/fmt.spl",
+    "stage2/utils/hash.spl",
+    "stage2/utils/io.spl",
+    "stage2/utils/json.spl",
+    "stage2/utils/log.spl",
+    "stage2/utils/lsp_frame.spl",
+    "stage2/utils/map.spl",
+    "stage2/utils/memory.spl",
+    "stage2/utils/mp.spl",
+    "stage2/utils/path.spl",
+    "stage2/utils/profile.spl",
+    "stage2/utils/set.spl",
+    "stage2/utils/source.spl",
+    "stage2/utils/str.spl",
+    "stage2/utils/utf8.spl",
+    "stage2/utils/value.spl",
+    "stage2/utils/vec.spl",
+    "stage2/ast.spl",
+    "stage2/ast2ir.spl",
+    "stage2/attr.spl",
+    "stage2/def.spl",
+    "stage2/diag.spl",
+    "stage2/eval.spl",
+    "stage2/intrin.spl",
+    "stage2/ir.spl",
+    "stage2/ir2c.spl",
+    "stage2/ir2vm.spl",
+    "stage2/ir_builder.spl",
+    "stage2/lang_type.spl",
+    "stage2/layout.spl",
+    "stage2/lexer.spl",
+    "stage2/mcode.spl",
+    "stage2/parser.spl",
+    "stage2/scope.spl",
+    "stage2/sema.spl",
+    "stage2/splc1.spl",
+    "stage2/token.spl",
+    "stage2/type_table.spl",
+};
+
+static const char* splc2_deps[] = {
+    /* stage3 */
+    "stage3/builtin.spl",
+    "stage3/hir.spl",
+    "stage3/hir2ir.spl",
+    "stage3/lang_type.spl",
+    "stage3/lower.spl",
+    "stage3/scope.spl",
+    "stage3/sema.spl",
+    "stage3/splc2.spl",
+    "stage3/tag.spl",
+    /* stage2 */
+    "stage2/sys/exit.spl",
+    "stage2/sys/file.spl",
+    "stage2/sys/mem.spl",
+    "stage2/sys/time.spl",
+    "stage2/sys/vm.spl",
+    "stage2/utils/algorithm.spl",
+    "stage2/utils/arena.spl",
+    "stage2/utils/ascii.spl",
+    "stage2/utils/byte_buffer.spl",
+    "stage2/utils/byte_view.spl",
+    "stage2/utils/error.spl",
+    "stage2/utils/fmt.spl",
+    "stage2/utils/hash.spl",
+    "stage2/utils/io.spl",
+    "stage2/utils/json.spl",
+    "stage2/utils/log.spl",
+    "stage2/utils/lsp_frame.spl",
+    "stage2/utils/map.spl",
+    "stage2/utils/memory.spl",
+    "stage2/utils/mp.spl",
+    "stage2/utils/path.spl",
+    "stage2/utils/profile.spl",
+    "stage2/utils/set.spl",
+    "stage2/utils/source.spl",
+    "stage2/utils/str.spl",
+    "stage2/utils/utf8.spl",
+    "stage2/utils/value.spl",
+    "stage2/utils/vec.spl",
+    "stage2/ast.spl",
+    "stage2/ast2ir.spl",
+    "stage2/attr.spl",
+    "stage2/def.spl",
+    "stage2/diag.spl",
+    "stage2/eval.spl",
+    "stage2/intrin.spl",
+    "stage2/ir.spl",
+    "stage2/ir2c.spl",
+    "stage2/ir2vm.spl",
+    "stage2/ir_builder.spl",
+    "stage2/lang_type.spl",
+    "stage2/layout.spl",
+    "stage2/lexer.spl",
+    "stage2/mcode.spl",
+    "stage2/parser.spl",
+    "stage2/scope.spl",
+    "stage2/sema.spl",
+    "stage2/splc1.spl",
+    "stage2/token.spl",
+    "stage2/type_table.spl",
+};
+
+static const char *splc2_crt_deps[] = {
+    "stage0/spl_rt.h",     "stage0/spl_rt_core.h", "stage0/spl_asp.h",
+    "stage0/spl_mcode.h",  "stage0/spl_vm.h",      "stage0/spl_syscall.h",
+    "stage0/spl_vm_embed.h",
+};
+
+/* clang-format on */
+
+typedef struct build {
+    const char *name;
+    enum {
+        BUILD_EXE,
+        BUILD_EXE_WITH_OPTIMIZATION,
+        BUILD_SIR,
+        BUILD_NATIVE,
+    } kind;
+    union {
+        struct {
+            const char **srcs;
+            size_t srcs_count;
+            const char **headers;
+            size_t headers_count;
+        } exe;
+        struct {
+            const char *src;
+            const char *compiler;
+            const char **deps;
+            size_t deps_count;
+        } sir;
+        struct {
+            const char *src;
+            const char *compiler;
+            const char **deps;
+            size_t deps_count;
+            const char **crt_deps;
+            size_t crt_deps_count;
+        } native;
+    };
+} build_t;
+
+typedef struct run {
+    const char *name;
+    const char *interpreter;
+} run_t;
+
+static build_t targets[] = {
+    {
+        "spl_cli",
+        BUILD_EXE_WITH_OPTIMIZATION,
+        .exe = {.srcs = spl_cli_srcs,
+                .srcs_count = NOB_ARRAY_LEN(spl_cli_srcs),
+                .headers = stage0_headers,
+                .headers_count = NOB_ARRAY_LEN(stage0_headers)},
+    },
+    {
+        "spl_cli_g",
+        BUILD_EXE,
+        .exe = {.srcs = spl_cli_srcs,
+                .srcs_count = NOB_ARRAY_LEN(spl_cli_srcs),
+                .headers = stage0_headers,
+                .headers_count = NOB_ARRAY_LEN(stage0_headers)},
+    },
+    {
+        "vm_test",
+        BUILD_EXE,
+        .exe = {.srcs = vm_test_srcs,
+                .srcs_count = NOB_ARRAY_LEN(vm_test_srcs),
+                .headers = stage0_headers,
+                .headers_count = NOB_ARRAY_LEN(stage0_headers)},
+    },
+    {
+        "splc0",
+        BUILD_EXE,
+        .exe = {.srcs = splc0_srcs,
+                .srcs_count = NOB_ARRAY_LEN(splc0_srcs),
+                .headers = stage0_headers,
+                .headers_count = NOB_ARRAY_LEN(stage0_headers)},
+    },
+    {
+        "splc1",
+        BUILD_SIR,
+        .sir = {.src = "stage2/splc1.spl",
+                .compiler = "splc0",
+                .deps = splc1_deps,
+                .deps_count = NOB_ARRAY_LEN(splc1_deps)},
+    },
+    {
+        "splc1s",
+        BUILD_SIR,
+        .sir = {.src = "stage2/splc1.spl",
+                .compiler = "splc1",
+                .deps = splc1_deps,
+                .deps_count = NOB_ARRAY_LEN(splc1_deps)},
+    },
+    {
+        "splc1r",
+        BUILD_SIR,
+        .sir = {.src = "stage2/splc1.spl",
+                .compiler = "splc1s",
+                .deps = splc1_deps,
+                .deps_count = NOB_ARRAY_LEN(splc1_deps)},
+    },
+    {
+        "splc1n",
+        BUILD_NATIVE,
+        .native = {.src = "stage2/splc1.spl",
+                   .compiler = "splc1",
+                   .deps = splc1_deps,
+                   .deps_count = NOB_ARRAY_LEN(splc1_deps),
+                   .crt_deps = splc1_crt_deps,
+                   .crt_deps_count = NOB_ARRAY_LEN(splc1_crt_deps)},
+    },
+    {
+        "splc2",
+        BUILD_SIR,
+        .sir = {.src = "stage3/splc2.spl",
+                .compiler = "splc1n",
+                .deps = splc2_deps,
+                .deps_count = NOB_ARRAY_LEN(splc2_deps)},
+    },
+    {
+        "splc2n",
+        BUILD_NATIVE,
+        .native = {.src = "stage3/splc2.spl",
+                   .compiler = "splc1n",
+                   .deps = splc2_deps,
+                   .deps_count = NOB_ARRAY_LEN(splc2_deps),
+                   .crt_deps = splc2_crt_deps,
+                   .crt_deps_count = NOB_ARRAY_LEN(splc2_crt_deps)},
+    },
+};
+
+static run_t runs[] = {
+    {"spl_cli", NULL},    {"vm_test", NULL},     {"splc0", NULL},
+    {"splc1", "spl_cli"}, {"splc1r", "spl_cli"}, {"splc1s", "spl_cli"},
+    {"splc1n", NULL},     {"splc2", "spl_cli"},  {"splc2n", NULL},
+};
+
+#endif /* __NOB_DATA_H__ */

stage0/include/core_map.h

@@ -9,8 +9,16 @@
 #ifndef nullptr
 #define nullptr NULL
 #endif
+
+#ifndef SPL_USIZE_TYPEDEF
+#define SPL_USIZE_TYPEDEF
 typedef uintptr_t usize;
+#endif
+
+#ifndef SPL_ISIZE_TYPEDEF
+#define SPL_ISIZE_TYPEDEF
 typedef intptr_t isize;
+#endif
 
 #define MAP_TYPEOF __typeof__
 

stage0/include/core_vec.h

@@ -26,7 +26,10 @@
 #ifndef nullptr
 #define nullptr NULL
 #endif
-typedef size_t usize;
+#ifndef SPL_USIZE_TYPEDEF
+#define SPL_USIZE_TYPEDEF
+typedef uintptr_t usize;
+#endif
 #define __vec_realloc realloc
 #define __vec_free free
 #define __vec_memcpy memcpy

stage0/spl_asp.h

@@ -0,0 +1,38 @@
+#ifndef __SPL_ASP_H__
+#define __SPL_ASP_H__
+
+/* spl_asp.h - 地址空间抽象（Address SPace）
+ *
+ * SPL 侧指针语义由 spl_asp_t 统一描述：
+ *   - native（编译器自身）：identity，指针就是宿主地址。
+ *   - VM：句柄/偏移，offset = (handle<<32) | 区内字节偏移，0 为 null。
+ *
+ * runtime（spl_rt_core.h）的解引用/分配一律经此接口，从而同一份 SPL
+ * 源的 Vec/Map/mem 在两种后端下都自洽。
+ */
+
+#include <stdint.h>
+#include <stddef.h>
+
+#ifndef SPL_USIZE_TYPEDEF
+#define SPL_USIZE_TYPEDEF
+typedef uintptr_t usize;
+#endif
+
+typedef struct spl_asp spl_asp_t;
+
+struct spl_asp {
+    void *ctx;
+    /* offset -> 宿主地址；size>0 时做边界检查；失败返回 NULL。 */
+    unsigned char *(*xlate)(void *ctx, uintptr_t off, uintptr_t size);
+    /* 分配 size 字节，返回 offset（0=失败）。 */
+    uintptr_t (*alloc)(void *ctx, uintptr_t size);
+    /* 重新分配 offset@old，返回新 offset（0=失败）。 */
+    uintptr_t (*realloc)(void *ctx, uintptr_t off, uintptr_t size);
+    /* 释放 offset。 */
+    void (*free)(void *ctx, uintptr_t off);
+    /* 宿主地址 -> offset；size>0 时校验范围。不属于该空间返回 0。 */
+    uintptr_t (*to_off)(void *ctx, const void *host, uintptr_t size);
+};
+
+#endif /* __SPL_ASP_H__ */

stage0/spl_cli.c

@@ -33,6 +33,7 @@ typedef struct {
     int profile;
     int profile_interval;
     const char *profile_out;
+    int stats;
     const char *entry;
     const char *path;  /* file.sir */
     const char **args; /* spl 程序参数（file.sir 之后） */
@@ -48,6 +49,7 @@ static void usage(void) {
                     "  --trace           print every instruction\n"
                     "  --profile[=N]     native sampling profiler (every N insns, default 10000)\n"
                     "  --profile-out <p> profile output prefix (default build/profile)\n"
+                    "  --stats           print executed instructions / call count at exit\n"
                     "  -h, --help        show help\n");
 }
 
@@ -72,6 +74,8 @@ static int parse_args(int argc, const char **argv, cli_opts_t *o) {
                 o->trace = 1;
             } else if (strcmp(a, "--disasm") == 0) {
                 o->disasm = 1;
+            } else if (strcmp(a, "--stats") == 0) {
+                o->stats = 1;
             } else if (strcmp(a, "--profile") == 0) {
                 o->profile = 1;
             } else if (strncmp(a, "--profile=", 10) == 0) {
@@ -656,6 +660,8 @@ int main(int argc, const char **argv) {
     if (o.debug) {
         fprintf(stderr, "spl_cli: debug mode on\n");
         spl_vm_set_debug(&vm, 1);
+    } else {
+        spl_vm_set_debug(&vm, 0);
     }
     if (o.trace) {
         fprintf(stderr, "spl_cli: trace mode on\n");
@@ -710,6 +716,11 @@ int main(int argc, const char **argv) {
             fprintf(stderr, "spl_cli: hit breakpoint (run with -g to debug)\n");
     }
 
+    if (o.stats) {
+        fprintf(stderr, "spl_cli: stats steps=%llu calls=%llu\n", (unsigned long long)vm.steps,
+                (unsigned long long)vm.ncalls);
+    }
+
     if (o.profile) {
         const char *prefix = o.profile_out ? o.profile_out : "build/profile";
         char folded[1024];

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) {
+static int spl_prog_parse(const unsigned char *data, usize len, spl_prog_t *prog) {
-    FILE *f;
-    unsigned char *data;
-    long len;
     const unsigned char *p;
     spl_vm_val_t nfuncs, ninsns, nnatives, nstrs, ndata;
 
-    if (!fname || !prog)
+    if (!data || !prog)
         return -1;
-
+    if (len < 48)
-    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);
 
     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

@@ -9,8 +9,15 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#ifndef SPL_USIZE_TYPEDEF
+#define SPL_USIZE_TYPEDEF
 typedef uintptr_t usize;
+#endif
+
+#ifndef SPL_ISIZE_TYPEDEF
+#define SPL_ISIZE_TYPEDEF
 typedef intptr_t isize;
+#endif
 
 typedef enum {
     SPL_VOID,
@@ -90,6 +97,7 @@ typedef enum {
     /* 间接内存访问 */ \
     X(SPL_LOAD,      "load",        0,    1,   1,   "load sizeof(type)-bits zero-extended") \
     X(SPL_STORE,     "store",       0,    2,   0,   "store low sizeof(type)-bits") \
+    X(SPL_MEMCPY,    "memcpy",      0,    3,   0,   "copy n bytes: pop dst, src, n (VM address space)") \
     /* 原生接口 */ \
     X(SPL_NCALL,     "ncall",       1,    0,   1,   "call native function by index") \
     X(SPL_NLIB,      "nlib",        1,    0,   0,   "dlopen library (name idx)") \
@@ -103,6 +111,7 @@ typedef enum {
 #define X(opcode, name, argc, pop, push, desc) opcode,
     SPL_OPCODES(X)
 #undef X
+        SPL_OPCODE_COUNT,
 } spl_vm_opcode_t;
 
 /*
@@ -192,6 +201,7 @@ void spl_prog_drop(spl_prog_t *prog);
 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_rt.h

@@ -0,0 +1,90 @@
+#ifndef __SPL_RT_H__
+#define __SPL_RT_H__
+
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+#define SPL_FN static inline
+#elif defined(__GNUC__) || defined(__clang__)
+#define SPL_FN static __inline__
+#else
+#define SPL_FN static
+#endif
+
+#include <stdint.h>
+typedef uint8_t u8;
+typedef int8_t i8;
+typedef uint16_t u16;
+typedef int16_t i16;
+typedef uint32_t u32;
+typedef int32_t i32;
+typedef uint64_t u64;
+typedef int64_t i64;
+
+#ifndef SPL_USIZE_TYPEDEF
+#define SPL_USIZE_TYPEDEF
+typedef u64 usize;
+#endif
+
+#ifndef SPL_ISIZE_TYPEDEF
+#define SPL_ISIZE_TYPEDEF
+typedef i64 isize;
+#endif
+
+SPL_FN void spl_panic(const char *msg) {
+    fprintf(stderr, "%s\n", msg ? msg : "panic");
+    exit(1);
+}
+SPL_FN void spl_trap(void) { abort(); }
+
+#include "spl_rt_core.h"
+
+SPL_FN void *vm_fopen(void *path, void *mode) {
+    return (void *)fopen((const char *)path, (const char *)mode);
+}
+SPL_FN i32 vm_fclose(void *f) { return f ? fclose((FILE *)f) : 0; }
+SPL_FN u64 vm_fread(void *buf, u64 sz, u64 n, void *f) {
+    return f ? (u64)fread(buf, (size_t)sz, (size_t)n, (FILE *)f) : 0;
+}
+SPL_FN u64 vm_fwrite(void *buf, u64 sz, u64 n, void *f) {
+    return f ? (u64)fwrite(buf, (size_t)sz, (size_t)n, (FILE *)f) : 0;
+}
+SPL_FN u64 vm_fsize(void *f) {
+    long cur, end;
+    if (!f)
+        return 0;
+    cur = ftell((FILE *)f);
+    if (cur < 0)
+        return 0;
+    if (fseek((FILE *)f, 0, SEEK_END) != 0)
+        return 0;
+    end = ftell((FILE *)f);
+    fseek((FILE *)f, cur, SEEK_SET);
+    return end < 0 ? 0 : (u64)end;
+}
+SPL_FN void *vm_stdin(void) { return (void *)stdin; }
+SPL_FN void *vm_stdout(void) { return (void *)stdout; }
+SPL_FN void *vm_stderr(void) { return (void *)stderr; }
+SPL_FN i32 vm_putchar(i32 c) { return fputc(c, stdout); }
+SPL_FN i32 vm_getchar(void) { return fgetc(stdin); }
+
+SPL_FN void vm_exit(i32 code) { exit(code); }
+SPL_FN u64 vm_timestamp(u64 kind) {
+    time_t sec = time(NULL);
+    if (kind == 1)
+        return (u64)sec;
+    if (kind == 2)
+        return 0;
+    if (kind == 4)
+        return (u64)sec * 1000000000ull;
+    return 0;
+}
+
+#define SPL_VM_EMBED_IMPLIMENTATION
+#include "spl_vm_embed.h"
+
+#endif /* __SPL_RT_H__ */

stage0/spl_rt_core.h

@@ -0,0 +1,691 @@
+#ifndef __SPL_RT_CORE_H__
+#define __SPL_RT_CORE_H__
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "spl_asp.h"
+
+#ifndef SPL_CORE_FN
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+#define SPL_CORE_FN static inline
+#elif defined(__GNUC__) || defined(__clang__)
+#define SPL_CORE_FN static __inline__
+#else
+#define SPL_CORE_FN static
+#endif
+#endif
+
+/* ================================================================
+ * 地址空间：identity（native/编译器自身）
+ * ================================================================ */
+
+SPL_CORE_FN unsigned char *spl_asp_id_xlate(void *ctx, uintptr_t off, uintptr_t size) {
+    (void)ctx;
+    (void)size;
+    return (unsigned char *)off;
+}
+SPL_CORE_FN uintptr_t spl_asp_id_alloc(void *ctx, uintptr_t size) {
+    (void)ctx;
+    return (uintptr_t)malloc((size_t)size);
+}
+SPL_CORE_FN uintptr_t spl_asp_id_realloc(void *ctx, uintptr_t off, uintptr_t size) {
+    (void)ctx;
+    return (uintptr_t)realloc((void *)off, (size_t)size);
+}
+SPL_CORE_FN void spl_asp_id_free(void *ctx, uintptr_t off) {
+    (void)ctx;
+    free((void *)off);
+}
+SPL_CORE_FN uintptr_t spl_asp_id_to_off(void *ctx, const void *host, uintptr_t size) {
+    (void)ctx;
+    (void)size;
+    return (uintptr_t)host;
+}
+
+static const spl_asp_t spl_asp_identity = {
+    NULL, spl_asp_id_xlate, spl_asp_id_alloc, spl_asp_id_realloc, spl_asp_id_free,
+    spl_asp_id_to_off,
+};
+#define SPL_ASP_ID ((spl_asp_t *)&spl_asp_identity)
+
+/* 偏移 -> 宿主（不做边界检查）。 */
+SPL_CORE_FN unsigned char *spl_x(spl_asp_t *asp, uintptr_t off) {
+    return asp->xlate(asp->ctx, off, 0);
+}
+SPL_CORE_FN void *spl_xp(spl_asp_t *asp, uintptr_t off, uintptr_t size) {
+    return asp->xlate(asp->ctx, off, size);
+}
+
+/* ---------------- mem ---------------- */
+
+SPL_CORE_FN void *spl_alloc_ex(spl_asp_t *asp, uintptr_t sz) {
+    if (sz == 0)
+        return NULL;
+    return (void *)asp->alloc(asp->ctx, sz);
+}
+
+SPL_CORE_FN void spl_free_ex(spl_asp_t *asp, void *p) {
+    if (p)
+        asp->free(asp->ctx, (uintptr_t)p);
+}
+
+SPL_CORE_FN void *spl_realloc_ex(spl_asp_t *asp, void *p, uintptr_t sz) {
+    if (!p)
+        return spl_alloc_ex(asp, sz);
+    if (sz == 0) {
+        asp->free(asp->ctx, (uintptr_t)p);
+        return NULL;
+    }
+    return (void *)asp->realloc(asp->ctx, (uintptr_t)p, sz);
+}
+
+SPL_CORE_FN void *vm_memcpy(void *dst, const void *src, uintptr_t n) {
+    if (n)
+        memcpy(dst, src, (size_t)n);
+    return dst;
+}
+
+SPL_CORE_FN void *vm_memmove(void *dst, const void *src, uintptr_t n) {
+    if (n)
+        memmove(dst, src, (size_t)n);
+    return dst;
+}
+
+SPL_CORE_FN intptr_t vm_memcmp(const void *a, const void *b, uintptr_t n) {
+    if (n == 0)
+        return 0;
+    return (intptr_t)memcmp(a, b, (size_t)n);
+}
+
+SPL_CORE_FN int spl_bytes_eq_ex(spl_asp_t *asp, const void *a, uintptr_t alen, const void *b,
+                                uintptr_t blen) {
+    (void)asp;
+    if (alen != blen)
+        return 0;
+    if (alen == 0)
+        return 1;
+    if (!a || !b)
+        return 0;
+    return memcmp(a, b, (size_t)alen) == 0;
+}
+
+/* ---------------- Vec ---------------- */
+
+typedef struct {
+    uintptr_t raw;
+    uintptr_t data;
+    uintptr_t len;
+    uintptr_t cap;
+    uintptr_t elem_size;
+    uintptr_t elem_align;
+} spl_vec_t;
+
+SPL_CORE_FN int spl_align_ok(uintptr_t a) { return a != 0 && (a & (a - 1)) == 0; }
+
+SPL_CORE_FN int spl_vec_is_valid(const spl_vec_t *v) {
+    uintptr_t a;
+    if (v->elem_size == 0)
+        return 0;
+    a = v->elem_align;
+    if (a == 0 || (a & (a - 1)) != 0)
+        return 0;
+    if (v->len > v->cap)
+        return 0;
+    if (v->cap == 0)
+        return v->raw == 0 && v->data == 0 && v->len == 0;
+    if (v->raw == 0 || v->data == 0)
+        return 0;
+    return (v->data & (a - 1)) == 0;
+}
+
+SPL_CORE_FN void spl_grow_capacity(uintptr_t current, uintptr_t min_cap, uintptr_t need,
+                                   uintptr_t *out) {
+    uintptr_t cap = current < min_cap ? min_cap : current;
+    uintptr_t limit = ~(uintptr_t)0;
+    while (cap < need) {
+        if (cap > limit / 2) {
+            cap = need;
+            break;
+        }
+        cap = cap * 2;
+    }
+    *out = cap;
+}
+
+SPL_CORE_FN int spl_vec_allocate_ex(spl_asp_t *asp, spl_vec_t *out, uintptr_t capacity,
+                                    uintptr_t elem_size, uintptr_t elem_align) {
+    uintptr_t bytes, mask, addr;
+    uintptr_t raw;
+    if (elem_size == 0)
+        return 1;
+    if (!spl_align_ok(elem_align))
+        return 4;
+    out->raw = 0;
+    out->data = 0;
+    out->len = 0;
+    out->cap = 0;
+    out->elem_size = elem_size;
+    out->elem_align = elem_align;
+    if (capacity == 0)
+        return 0;
+    if (capacity > ~(uintptr_t)0 / elem_size)
+        return 3;
+    bytes = capacity * elem_size;
+    mask = elem_align - 1;
+    if (bytes > ~(uintptr_t)0 - mask)
+        return 3;
+    raw = asp->alloc(asp->ctx, bytes + mask);
+    if (!raw)
+        return 3;
+    addr = raw;
+    if (addr > ~(uintptr_t)0 - mask) {
+        asp->free(asp->ctx, raw);
+        return 3;
+    }
+    out->raw = raw;
+    out->data = (addr + mask) & ~mask;
+    out->cap = capacity;
+    return 0;
+}
+
+SPL_CORE_FN int spl_vec_reserve_raw_ex(spl_asp_t *asp, spl_vec_t *v, uintptr_t need) {
+    uintptr_t new_cap = 0, used = 0, old;
+    spl_vec_t fresh;
+    int rc;
+    if (need <= v->cap)
+        return 0;
+    spl_grow_capacity(v->cap, 8, need, &new_cap);
+    rc = spl_vec_allocate_ex(asp, &fresh, new_cap, v->elem_size, v->elem_align);
+    if (rc)
+        return rc;
+    if (v->len != 0) {
+        if (v->len > ~(uintptr_t)0 / v->elem_size) {
+            asp->free(asp->ctx, fresh.raw);
+            return 3;
+        }
+        used = v->len * v->elem_size;
+    }
+    if (used)
+        memcpy(spl_x(asp, fresh.data), spl_x(asp, v->data), used);
+    fresh.len = v->len;
+    old = v->raw;
+    *v = fresh;
+    if (old)
+        asp->free(asp->ctx, old);
+    return 0;
+}
+
+SPL_CORE_FN void spl_vec_release_ex(spl_asp_t *asp, spl_vec_t *v) {
+    uintptr_t es = v->elem_size, ea = v->elem_align;
+    if (v->raw)
+        asp->free(asp->ctx, v->raw);
+    v->raw = 0;
+    v->data = 0;
+    v->len = 0;
+    v->cap = 0;
+    v->elem_size = es;
+    v->elem_align = ea;
+}
+
+SPL_CORE_FN int spl_vec_valid_ex(const void *vv) {
+    return vv ? spl_vec_is_valid((const spl_vec_t *)vv) : 0;
+}
+
+SPL_CORE_FN int spl_vec_push_raw_ex(spl_asp_t *asp, void *vv, const void *elem) {
+    spl_vec_t *v = (spl_vec_t *)vv;
+    if (!v || !elem)
+        return 0;
+    if (v->len < v->cap) {
+        memcpy(spl_x(asp, v->data + v->len * v->elem_size), elem, v->elem_size);
+        v->len++;
+        return 1;
+    }
+    return 0;
+}
+
+SPL_CORE_FN int spl_vec_push_ex(spl_asp_t *asp, void *vv, const void *elem) {
+    spl_vec_t *v = (spl_vec_t *)vv;
+    int rc;
+    if (!v || !elem || !spl_vec_is_valid(v))
+        return 1;
+    if (v->len < v->cap) {
+        memcpy(spl_x(asp, v->data + v->len * v->elem_size), elem, v->elem_size);
+        v->len++;
+        return 0;
+    }
+    rc = spl_vec_reserve_raw_ex(asp, v, v->len + 1);
+    if (rc)
+        return rc;
+    memmove(spl_x(asp, v->data + v->len * v->elem_size), elem, v->elem_size);
+    v->len++;
+    return 0;
+}
+
+SPL_CORE_FN int spl_vec_get_ex(spl_asp_t *asp, const void *vv, uintptr_t index, void **out) {
+    const spl_vec_t *v = (const spl_vec_t *)vv;
+    unsigned char *p;
+    if (!v || !out)
+        return 1;
+    if (!spl_vec_is_valid(v))
+        return 1;
+    if (index >= v->len)
+        return 2;
+    p = spl_x(asp, v->data) + index * v->elem_size;
+    *out = (void *)(uintptr_t)asp->to_off(asp->ctx, p, v->elem_size);
+    return 0;
+}
+
+SPL_CORE_FN int spl_vec_allocate_out_ex(spl_asp_t *asp, void *out, uintptr_t capacity,
+                                         uintptr_t elem_size, uintptr_t elem_align) {
+    if (!out)
+        return 1;
+    return spl_vec_allocate_ex(asp, (spl_vec_t *)out, capacity, elem_size, elem_align);
+}
+
+SPL_CORE_FN int spl_vec_reserve_raw_void_ex(spl_asp_t *asp, void *vv, uintptr_t need) {
+    if (!vv)
+        return 1;
+    return spl_vec_reserve_raw_ex(asp, (spl_vec_t *)vv, need);
+}
+
+SPL_CORE_FN int spl_vec_append_ex(spl_asp_t *asp, void *vv, const void *elems, uintptr_t count) {
+    spl_vec_t *v = (spl_vec_t *)vv;
+    uintptr_t copy_bytes, new_len, used, source_offset = 0;
+    int source_inside = 0, rc;
+    if (!v || !spl_vec_is_valid(v))
+        return 1;
+    if (count == 0)
+        return 0;
+    if (!elems)
+        return 1;
+    if (count > ~(uintptr_t)0 / v->elem_size)
+        return 3;
+    copy_bytes = count * v->elem_size;
+    if (v->len > ~(uintptr_t)0 - count)
+        return 3;
+    new_len = v->len + count;
+    used = v->len * v->elem_size;
+    if (used) {
+        unsigned char *base = spl_x(asp, v->data);
+        uintptr_t source = (uintptr_t)elems;
+        if (source >= (uintptr_t)base && source - (uintptr_t)base < used) {
+            source_offset = source - (uintptr_t)base;
+            if (copy_bytes > used - source_offset)
+                return 2;
+            source_inside = 1;
+        }
+    }
+    rc = spl_vec_reserve_raw_ex(asp, v, new_len);
+    if (rc)
+        return rc;
+    if (source_inside)
+        elems = (const void *)(spl_x(asp, v->data) + source_offset);
+    memmove(spl_x(asp, v->data + used), elems, copy_bytes);
+    v->len = new_len;
+    return 0;
+}
+
+SPL_CORE_FN int spl_vec_set_ex(spl_asp_t *asp, void *vv, uintptr_t index, const void *elem) {
+    spl_vec_t *v = (spl_vec_t *)vv;
+    if (!v || !elem || !spl_vec_is_valid(v))
+        return 1;
+    if (index >= v->len)
+        return 2;
+    memmove(spl_x(asp, v->data + index * v->elem_size), elem, v->elem_size);
+    return 0;
+}
+
+SPL_CORE_FN int spl_vec_pop_ex(spl_asp_t *asp, void *vv, void *out) {
+    spl_vec_t *v = (spl_vec_t *)vv;
+    if (!v || !out || !spl_vec_is_valid(v))
+        return 1;
+    if (v->len == 0)
+        return 2;
+    memmove(out, spl_x(asp, v->data + (v->len - 1) * v->elem_size), v->elem_size);
+    v->len--;
+    return 0;
+}
+
+SPL_CORE_FN int spl_vec_clone_ex(spl_asp_t *asp, void *outp, const void *srcp) {
+    spl_vec_t *out = (spl_vec_t *)outp;
+    const spl_vec_t *src = (const spl_vec_t *)srcp;
+    spl_vec_t fresh;
+    uintptr_t bytes;
+    int rc;
+    if (!out || !src || !spl_vec_is_valid(out) || !spl_vec_is_valid(src))
+        return 1;
+    if (out->elem_size != src->elem_size || out->elem_align != src->elem_align)
+        return 1;
+    fresh.raw = 0;
+    fresh.data = 0;
+    fresh.len = 0;
+    fresh.cap = 0;
+    fresh.elem_size = src->elem_size;
+    fresh.elem_align = src->elem_align;
+    rc = spl_vec_reserve_raw_ex(asp, &fresh, src->len);
+    if (rc)
+        return rc;
+    bytes = src->len * src->elem_size;
+    if (bytes)
+        memcpy(spl_x(asp, fresh.data), spl_x(asp, src->data), bytes);
+    fresh.len = src->len;
+    if (out->raw)
+        asp->free(asp->ctx, out->raw);
+    *out = fresh;
+    return 0;
+}
+
+SPL_CORE_FN int spl_vec_drop_ex(spl_asp_t *asp, void *vv) {
+    if (vv)
+        spl_vec_release_ex(asp, (spl_vec_t *)vv);
+    return 0;
+}
+
+/* ---------------- Map ---------------- */
+
+typedef struct {
+    spl_vec_t keys;
+    spl_vec_t vals;
+    spl_vec_t states;
+    uintptr_t size;
+    uintptr_t key_size;
+    uintptr_t val_size;
+    uintptr_t hash_kind;
+} spl_map_t;
+
+SPL_CORE_FN uintptr_t spl_hash_usize_value(uintptr_t value) {
+    uintptr_t prime = 1099511628211ull;
+    uintptr_t h = value;
+    h = (h ^ (h >> 30)) * prime;
+    h = h ^ (h >> 27);
+    h = h * prime;
+    h = h ^ (h >> 31);
+    if (h == 0)
+        return prime;
+    return h;
+}
+
+SPL_CORE_FN uintptr_t spl_hash_bytes(const void *data, uintptr_t len) {
+    const unsigned char *p = (const unsigned char *)data;
+    uintptr_t h = 14695981039346656037ull;
+    uintptr_t prime = 1099511628211ull;
+    uintptr_t i;
+    for (i = 0; i < len; i++)
+        h = (h ^ (uintptr_t)p[i]) * prime;
+    return h;
+}
+
+SPL_CORE_FN uintptr_t spl_hash_bytes_ex(spl_asp_t *asp, const void *data, uintptr_t len) {
+    return spl_hash_bytes(spl_x(asp, (uintptr_t)data), len);
+}
+
+SPL_CORE_FN uintptr_t spl_map_hash_ex(spl_asp_t *asp, const spl_map_t *m, const void *key) {
+    const uintptr_t *v;
+    if (m->hash_kind == 0)
+        return spl_hash_usize_value(*(const uintptr_t *)key);
+    if (m->hash_kind == 2)
+        return 3;
+    v = (const uintptr_t *)key;
+    return spl_hash_bytes_ex(asp, (const void *)v[0], v[1]);
+}
+
+SPL_CORE_FN int spl_map_eq_ex(spl_asp_t *asp, const spl_map_t *m, const void *a, const void *b) {
+    const uintptr_t *x;
+    const uintptr_t *y;
+    if (m->hash_kind == 0 || m->hash_kind == 2)
+        return *(const uintptr_t *)a == *(const uintptr_t *)b;
+    x = (const uintptr_t *)a;
+    y = (const uintptr_t *)b;
+    if (x[1] != y[1])
+        return 0;
+    if (x[1] == 0)
+        return 1;
+    return memcmp(spl_x(asp, x[0]), spl_x(asp, y[0]), (size_t)x[1]) == 0;
+}
+
+SPL_CORE_FN int spl_map_valid(const spl_map_t *m) {
+    if (m->key_size == 0 || m->val_size == 0)
+        return 0;
+    if (m->keys.len != m->states.len || m->vals.len != m->states.len)
+        return 0;
+    if (m->size > m->states.len)
+        return 0;
+    return 1;
+}
+
+SPL_CORE_FN uintptr_t spl_map_find_slot_ex(spl_asp_t *asp, const spl_map_t *m, const void *key) {
+    uintptr_t mask, i, probes;
+    unsigned char *st;
+    if (m->states.cap == 0)
+        return ~(uintptr_t)0;
+    mask = m->states.cap - 1;
+    i = spl_map_hash_ex(asp, m, key) & mask;
+    st = spl_x(asp, m->states.data);
+    probes = 0;
+    while (probes < m->states.cap && st[i] != 0) {
+        if (st[i] == 1 &&
+            spl_map_eq_ex(asp, m, spl_x(asp, m->keys.data + i * m->key_size), key))
+            return i;
+        i = (i + 1) & mask;
+        probes++;
+    }
+    return ~(uintptr_t)0;
+}
+
+SPL_CORE_FN void spl_map_place_ex(spl_asp_t *asp, spl_map_t *m, const void *key, const void *val) {
+    uintptr_t mask = m->states.cap - 1;
+    uintptr_t i = spl_map_hash_ex(asp, m, key) & mask;
+    unsigned char *st = spl_x(asp, m->states.data);
+    uintptr_t first_deleted = ~(uintptr_t)0;
+    uintptr_t probes = 0;
+    while (probes < m->states.cap && st[i] != 0) {
+        if (st[i] == 2 && first_deleted == ~(uintptr_t)0)
+            first_deleted = i;
+        i = (i + 1) & mask;
+        probes++;
+    }
+    if (first_deleted != ~(uintptr_t)0)
+        i = first_deleted;
+    memcpy(spl_x(asp, m->keys.data + i * m->key_size), key, m->key_size);
+    memcpy(spl_x(asp, m->vals.data + i * m->val_size), val, m->val_size);
+    st[i] = 1;
+    m->size++;
+}
+
+SPL_CORE_FN int spl_map_reserve_ex(spl_asp_t *asp, spl_map_t *m, uintptr_t need) {
+    uintptr_t new_cap = 0, i;
+    spl_map_t fresh;
+    int rc;
+    if (!spl_map_valid(m))
+        return 1;
+    if (need <= m->states.cap)
+        return 0;
+    spl_grow_capacity(m->states.cap, 8, need, &new_cap);
+    fresh = *m;
+    fresh.keys.raw = 0;
+    fresh.keys.data = 0;
+    fresh.keys.len = 0;
+    fresh.keys.cap = 0;
+    fresh.vals.raw = 0;
+    fresh.vals.data = 0;
+    fresh.vals.len = 0;
+    fresh.vals.cap = 0;
+    fresh.states.raw = 0;
+    fresh.states.data = 0;
+    fresh.states.len = 0;
+    fresh.states.cap = 0;
+    fresh.size = 0;
+    rc = spl_vec_reserve_raw_ex(asp, &fresh.keys, new_cap);
+    if (rc)
+        goto fail;
+    rc = spl_vec_reserve_raw_ex(asp, &fresh.vals, new_cap);
+    if (rc)
+        goto fail;
+    rc = spl_vec_reserve_raw_ex(asp, &fresh.states, new_cap);
+    if (rc)
+        goto fail;
+    fresh.keys.len = new_cap;
+    fresh.vals.len = new_cap;
+    fresh.states.len = new_cap;
+    memset(spl_x(asp, fresh.states.data), 0, new_cap);
+    for (i = 0; i < m->states.len; i++) {
+        if (spl_x(asp, m->states.data)[i] == 1)
+            spl_map_place_ex(asp, &fresh, spl_x(asp, m->keys.data + i * m->key_size),
+                             spl_x(asp, m->vals.data + i * m->val_size));
+    }
+    spl_vec_release_ex(asp, &m->keys);
+    spl_vec_release_ex(asp, &m->vals);
+    spl_vec_release_ex(asp, &m->states);
+    *m = fresh;
+    return 0;
+fail:
+    spl_vec_release_ex(asp, &fresh.keys);
+    spl_vec_release_ex(asp, &fresh.vals);
+    spl_vec_release_ex(asp, &fresh.states);
+    return rc;
+}
+
+SPL_CORE_FN int spl_map_valid_ex(const void *mm) {
+    return mm ? spl_map_valid((const spl_map_t *)mm) : 0;
+}
+
+SPL_CORE_FN int spl_map_reserve_void_ex(spl_asp_t *asp, void *mm, uintptr_t need) {
+    if (!mm)
+        return 1;
+    return spl_map_reserve_ex(asp, (spl_map_t *)mm, need);
+}
+
+SPL_CORE_FN int spl_map_put_ex(spl_asp_t *asp, void *mm, const void *key, const void *val) {
+    spl_map_t *m = (spl_map_t *)mm;
+    uintptr_t existing;
+    if (!m || !key || !val || !spl_map_valid(m))
+        return 1;
+    existing = spl_map_find_slot_ex(asp, m, key);
+    if (existing != ~(uintptr_t)0) {
+        memcpy(spl_x(asp, m->vals.data + existing * m->val_size), val, m->val_size);
+        return 0;
+    }
+    if (m->states.cap == 0) {
+        int rc = spl_map_reserve_ex(asp, m, 8);
+        if (rc)
+            return rc;
+    } else {
+        uintptr_t next_size, scaled;
+        if (m->size > ~(uintptr_t)0 - 1)
+            return 3;
+        next_size = m->size + 1;
+        if (next_size > ~(uintptr_t)0 / 128)
+            return 3;
+        scaled = next_size * 128;
+        if (scaled / m->states.cap >= 70) {
+            int rc;
+            if (m->states.cap > ~(uintptr_t)0 / 2)
+                return 3;
+            rc = spl_map_reserve_ex(asp, m, m->states.cap * 2);
+            if (rc)
+                return rc;
+        }
+    }
+    spl_map_place_ex(asp, m, key, val);
+    return 0;
+}
+
+SPL_CORE_FN int spl_map_get_ex(spl_asp_t *asp, void *mm, const void *key, void *out) {
+    spl_map_t *m = (spl_map_t *)mm;
+    uintptr_t i;
+    if (!m || !key || !out || !spl_map_valid(m))
+        return 1;
+    i = spl_map_find_slot_ex(asp, m, key);
+    if (i == ~(uintptr_t)0)
+        return 1;
+    memcpy(out, spl_x(asp, m->vals.data + i * m->val_size), m->val_size);
+    return 0;
+}
+
+SPL_CORE_FN int spl_map_del_ex(spl_asp_t *asp, void *mm, const void *key) {
+    spl_map_t *m = (spl_map_t *)mm;
+    uintptr_t i;
+    if (!m || !key || !spl_map_valid(m))
+        return 1;
+    i = spl_map_find_slot_ex(asp, m, key);
+    if (i == ~(uintptr_t)0)
+        return 1;
+    spl_x(asp, m->states.data)[i] = 2;
+    m->size--;
+    return 0;
+}
+
+SPL_CORE_FN int spl_map_clear_ex(spl_asp_t *asp, void *mm) {
+    spl_map_t *m = (spl_map_t *)mm;
+    if (!m)
+        return 0;
+    if (m->states.data && m->states.len)
+        memset(spl_x(asp, m->states.data), 0, m->states.len);
+    m->size = 0;
+    return 0;
+}
+
+SPL_CORE_FN int spl_map_drop_ex(spl_asp_t *asp, void *mm) {
+    spl_map_t *m = (spl_map_t *)mm;
+    if (!m)
+        return 0;
+    spl_vec_release_ex(asp, &m->keys);
+    spl_vec_release_ex(asp, &m->vals);
+    spl_vec_release_ex(asp, &m->states);
+    m->size = 0;
+    return 0;
+}
+
+/* ================================================================
+ * 公开 C 符号（identity）：供 native 编译器直接调用
+ * ================================================================ */
+
+SPL_CORE_FN void *vm_alloc(uintptr_t sz) { return spl_alloc_ex(SPL_ASP_ID, sz); }
+SPL_CORE_FN void vm_free(void *p) { spl_free_ex(SPL_ASP_ID, p); }
+SPL_CORE_FN void *vm_realloc(void *p, uintptr_t sz) { return spl_realloc_ex(SPL_ASP_ID, p, sz); }
+SPL_CORE_FN int vm_bytes_eq(const void *a, uintptr_t alen, const void *b, uintptr_t blen) {
+    return spl_bytes_eq_ex(SPL_ASP_ID, a, alen, b, blen);
+}
+
+SPL_CORE_FN int vm_vec_valid(const void *v) { return spl_vec_valid_ex(v); }
+SPL_CORE_FN int vm_vec_push_raw(void *v, const void *e) {
+    return spl_vec_push_raw_ex(SPL_ASP_ID, v, e);
+}
+SPL_CORE_FN int vm_vec_push(void *v, const void *e) { return spl_vec_push_ex(SPL_ASP_ID, v, e); }
+SPL_CORE_FN int vm_vec_get(const void *v, uintptr_t i, void **o) {
+    return spl_vec_get_ex(SPL_ASP_ID, v, i, o);
+}
+SPL_CORE_FN int vm_vec_allocate(void *o, uintptr_t c, uintptr_t es, uintptr_t ea) {
+    return spl_vec_allocate_out_ex(SPL_ASP_ID, o, c, es, ea);
+}
+SPL_CORE_FN int vm_vec_reserve_raw(void *v, uintptr_t n) {
+    return spl_vec_reserve_raw_void_ex(SPL_ASP_ID, v, n);
+}
+SPL_CORE_FN int vm_vec_append(void *v, const void *e, uintptr_t n) {
+    return spl_vec_append_ex(SPL_ASP_ID, v, e, n);
+}
+SPL_CORE_FN int vm_vec_set(void *v, uintptr_t i, const void *e) {
+    return spl_vec_set_ex(SPL_ASP_ID, v, i, e);
+}
+SPL_CORE_FN int vm_vec_pop(void *v, void *o) { return spl_vec_pop_ex(SPL_ASP_ID, v, o); }
+SPL_CORE_FN int vm_vec_clone(void *o, const void *s) { return spl_vec_clone_ex(SPL_ASP_ID, o, s); }
+SPL_CORE_FN int vm_vec_drop(void *v) { return spl_vec_drop_ex(SPL_ASP_ID, v); }
+
+SPL_CORE_FN int vm_map_valid(const void *m) { return spl_map_valid_ex(m); }
+SPL_CORE_FN int vm_map_reserve(void *m, uintptr_t n) {
+    return spl_map_reserve_void_ex(SPL_ASP_ID, m, n);
+}
+SPL_CORE_FN int vm_map_put(void *m, const void *k, const void *v) {
+    return spl_map_put_ex(SPL_ASP_ID, m, k, v);
+}
+SPL_CORE_FN int vm_map_get(void *m, const void *k, void *o) {
+    return spl_map_get_ex(SPL_ASP_ID, m, k, o);
+}
+SPL_CORE_FN int vm_map_del(void *m, const void *k) { return spl_map_del_ex(SPL_ASP_ID, m, k); }
+SPL_CORE_FN int vm_map_clear(void *m) { return spl_map_clear_ex(SPL_ASP_ID, m); }
+SPL_CORE_FN int vm_map_drop(void *m) { return spl_map_drop_ex(SPL_ASP_ID, m); }
+
+#endif /* __SPL_RT_CORE_H__ */

stage0/spl_syscall.c

@@ -1,12 +1,3 @@
-/* spl_syscall.c - built-in syscall implementations + registration
- *
- * All syscalls validate nargs, cast spl_val_t args to the expected C types,
- * execute, and return the result as spl_val_t.
- *
- * Simple syscalls use the SYSCALL_N macros; complex ones are written
- * manually but follow the same template.
- */
-
 #include "spl_syscall.h"
 #include "include/core_map.h"
 #include "include/core_vec.h"
@@ -18,15 +9,10 @@
 #include <string.h>
 #include <time.h>
 
-/* =================================================================
+/* VM 偏移 -> 宿主地址；size=0 表示不做边界检查。 */
- * Macro templates
+#define VM_X(_vm, off) ((void *)spl_vm_xlate((_vm), (spl_vm_val_t)(off), 0))
- *
+#define VM_XN(_vm, off, n) ((void *)spl_vm_xlate((_vm), (spl_vm_val_t)(off), (usize)(n)))
- * Each SYSCALL_N macro:
+#define VM_ASP(_vm) spl_vm_asp(_vm)
- *  1. Validates nargs (prints error and returns -1 on mismatch)
- *  2. Casts args[n] from spl_val_t to the specified C type via
- *     (type)(uintptr_t) - this handles both integer and pointer types
- *  3. Evaluates the expression and returns the result as spl_val_t
- * ================================================================= */
 
 #define CHECK_NARGS(fname, expected)                                                               \
     do {                                                                                           \
@@ -82,9 +68,6 @@
         return (spl_vm_val_t)(uintptr_t)(ret_expr);                                                \
     }
 
-/* syscall / VM 内部统一地址检查宏。
- * 失败时打印 ctx + 地址 + size + ip，置 native_error，return 0。
- * 要求所在函数有可用的 _vm 变量。 */
 #define ADDRCHECK(vm, ptr, size, ctx)                                                              \
     do {                                                                                           \
         uintptr_t _acp = (uintptr_t)(ptr);                                                         \
@@ -98,7 +81,6 @@
         }                                                                                          \
     } while (0)
 
-/* syscall 内部：把当前栈和调用栈打印出来，供出错时定位 */
 #define SYSCALL_DUMP(vm)                                                                           \
     do {                                                                                           \
         fprintf(stderr, "  --- syscall dump (sp=%zu fp=%zu cp=%zu ip=%zu) ---\n", (vm)->sp,        \
@@ -107,7 +89,6 @@
         spl_vm_stackdump((vm), (vm)->sp);                                                          \
     } while (0)
 
-/* syscall 内部：报告致命错误，dump 后让 VM 停在当前 ip */
 #define SYSCALL_FAIL(vm, ...)                                                                      \
     do {                                                                                           \
         fprintf(stderr, "syscall error: ");                                                        \
@@ -118,153 +99,428 @@
         return 0;                                                                                  \
     } while (0)
 
+/* =================================================================
+ * 从共享核心 spl_rt_core.h 派生的 syscall 包装
+ * ================================================================= */
+
+#include "spl_rt_core.h"
+
+#define SPL_WRAP1(name, fn, t1)                                                                    \
+    static spl_vm_val_t name(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {                       \
+        (void)_vm;                                                                                 \
+        CHECK_NARGS(#name, 1);                                                                     \
+        return (spl_vm_val_t)(uintptr_t)fn((t1)(uintptr_t)args[0]);                                \
+    }
+
+#define SPL_WRAP1_V(name, fn, t1)                                                                  \
+    static spl_vm_val_t name(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {                       \
+        (void)_vm;                                                                                 \
+        CHECK_NARGS(#name, 1);                                                                     \
+        fn((t1)(uintptr_t)args[0]);                                                                \
+        return 0;                                                                                  \
+    }
+
+#define SPL_WRAP2(name, fn, t1, t2)                                                                \
+    static spl_vm_val_t name(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {                       \
+        (void)_vm;                                                                                 \
+        CHECK_NARGS(#name, 2);                                                                     \
+        return (spl_vm_val_t)(uintptr_t)fn((t1)(uintptr_t)args[0], (t2)(uintptr_t)args[1]);        \
+    }
+
+#define SPL_WRAP3(name, fn, t1, t2, t3)                                                            \
+    static spl_vm_val_t name(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {                       \
+        (void)_vm;                                                                                 \
+        CHECK_NARGS(#name, 3);                                                                     \
+        return (spl_vm_val_t)(uintptr_t)fn((t1)(uintptr_t)args[0], (t2)(uintptr_t)args[1],         \
+                                           (t3)(uintptr_t)args[2]);                                \
+    }
+
+#define SPL_WRAP4(name, fn, t1, t2, t3, t4)                                                        \
+    static spl_vm_val_t name(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {                       \
+        (void)_vm;                                                                                 \
+        CHECK_NARGS(#name, 4);                                                                     \
+        return (spl_vm_val_t)(uintptr_t)fn((t1)(uintptr_t)args[0], (t2)(uintptr_t)args[1],         \
+                                           (t3)(uintptr_t)args[2], (t4)(uintptr_t)args[3]);        \
+    }
+
 /* =================================================================
  * OS syscalls
  * ================================================================= */
 
-/* vm_exit - terminate process with the given exit code */
 SYSCALL_1(vm_exit, int, (exit(a1), (spl_vm_val_t)0))
-
-/* vm_putchar - write a single character to stdout */
 SYSCALL_1(vm_putchar, int, putchar(a1))
-
-/* vm_getchar - read a single character from stdin */
 SYSCALL_0(vm_getchar, getchar())
-
-/* vm_putint - print an integer to stdout */
 SYSCALL_1(vm_putint, int, (fprintf(stdout, "%d", a1), (spl_vm_val_t)0))
 
-/* vm_putstr - print a string to stdout (no trailing newline) */
+/* FILE* 存于 VM 空间，返回其偏移（不透明句柄）。 */
-SYSCALL_1(vm_putstr, const char *, (fputs(a1, stdout), (spl_vm_val_t)0))
+static spl_vm_val_t vm_file_handle(spl_vm_t *vm, FILE *f) {
-
+    spl_vm_val_t off;
-/* vm_fopen - open a file, returns FILE* as spl_val_t */
+    FILE **slot;
-SYSCALL_2(vm_fopen, const char *, const char *, (uintptr_t)fopen(a1, a2))
+    if (!f)
-
+        return 0;
-/* vm_fclose - close a file, returns 0 on success */
+    off = (spl_vm_val_t)(uintptr_t)spl_alloc_ex(VM_ASP(vm), sizeof(FILE *));
-SYSCALL_1(vm_fclose, FILE *, fclose(a1))
+    if (off == 0)
-
+        return 0;
-/* vm_fread - read from file, returns number of items read */
+    slot = (FILE **)VM_XN(vm, off, sizeof(FILE *));
-SYSCALL_4(vm_fread, void *, size_t, size_t, FILE *, fread(a1, a2, a3, a4))
+    if (!slot)
-
+        return 0;
-/* vm_fwrite - write to file, returns number of items written */
+    *slot = f;
-SYSCALL_4(vm_fwrite, const void *, size_t, size_t, FILE *, fwrite(a1, a2, a3, a4))
+    return off;
-
-/* vm_fsize - get file size in bytes */
-static spl_vm_val_t vm_fsize(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
-    (void)_vm;
-    CHECK_NARGS("vm_fsize", 1);
-    FILE *f = (FILE *)(uintptr_t)args[0];
-    long cur = ftell(f);
-    fseek(f, 0, SEEK_END);
-    long sz = ftell(f);
-    fseek(f, cur, SEEK_SET);
-    return (spl_vm_val_t)(uintptr_t)sz;
 }
 
-SYSCALL_0(vm_stdin, stdin)
+static FILE *vm_file_get(spl_vm_t *vm, spl_vm_val_t off) {
-SYSCALL_0(vm_stdout, stdout)
+    FILE **slot = (FILE **)VM_XN(vm, off, sizeof(FILE *));
-SYSCALL_0(vm_stderr, stderr)
+    return slot ? *slot : NULL;
+}
+
+static spl_vm_val_t vm_putstr(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    const char *s;
+    CHECK_NARGS("vm_putstr", 1);
+    s = (const char *)VM_X(_vm, args[0]);
+    if (s)
+        fputs(s, stdout);
+    return 0;
+}
+
+static spl_vm_val_t vm_fopen(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    const char *path, *mode;
+    CHECK_NARGS("vm_fopen", 2);
+    path = (const char *)VM_X(_vm, args[0]);
+    mode = (const char *)VM_X(_vm, args[1]);
+    return vm_file_handle(_vm, fopen(path, mode));
+}
+
+static spl_vm_val_t vm_fclose(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    FILE *f;
+    CHECK_NARGS("vm_fclose", 1);
+    f = vm_file_get(_vm, args[0]);
+    return f ? (spl_vm_val_t)fclose(f) : 0;
+}
+
+static spl_vm_val_t vm_fread(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    void *buf;
+    FILE *f;
+    CHECK_NARGS("vm_fread", 4);
+    buf = VM_X(_vm, args[0]);
+    f = vm_file_get(_vm, args[3]);
+    if (!buf || !f)
+        return 0;
+    return (spl_vm_val_t)fread(buf, (size_t)args[1], (size_t)args[2], f);
+}
+
+static spl_vm_val_t vm_fwrite(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    const void *buf;
+    FILE *f;
+    CHECK_NARGS("vm_fwrite", 4);
+    buf = VM_X(_vm, args[0]);
+    f = vm_file_get(_vm, args[3]);
+    if (!buf || !f)
+        return 0;
+    return (spl_vm_val_t)fwrite(buf, (size_t)args[1], (size_t)args[2], f);
+}
+
+static spl_vm_val_t vm_fsize(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    FILE *f;
+    long cur, sz;
+    CHECK_NARGS("vm_fsize", 1);
+    f = vm_file_get(_vm, args[0]);
+    if (!f)
+        return 0;
+    cur = ftell(f);
+    fseek(f, 0, SEEK_END);
+    sz = ftell(f);
+    fseek(f, cur, SEEK_SET);
+    return (spl_vm_val_t)(uintptr_t)(sz < 0 ? 0 : sz);
+}
+
+static spl_vm_val_t vm_std_handle(spl_vm_t *_vm, int which) {
+    if (_vm->stdio_off[which] == 0) {
+        FILE *f = which == 0 ? stdin : (which == 1 ? stdout : stderr);
+        _vm->stdio_off[which] = vm_file_handle(_vm, f);
+    }
+    return _vm->stdio_off[which];
+}
+
+static spl_vm_val_t vm_stdin(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    (void)args;
+    CHECK_NARGS("vm_stdin", 0);
+    return vm_std_handle(_vm, 0);
+}
+static spl_vm_val_t vm_stdout(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    (void)args;
+    CHECK_NARGS("vm_stdout", 0);
+    return vm_std_handle(_vm, 1);
+}
+static spl_vm_val_t vm_stderr(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    (void)args;
+    CHECK_NARGS("vm_stderr", 0);
+    return vm_std_handle(_vm, 2);
+}
 
-/* vm_read_file - read entire file into a malloc'd, null-terminated buffer */
 static spl_vm_val_t vm_read_file(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
-    (void)_vm;
     CHECK_NARGS("vm_read_file", 1);
-    const char *path = (const char *)(uintptr_t)args[0];
+    const char *path = (const char *)VM_X(_vm, args[0]);
+    FILE *f;
+    long sz;
+    spl_vm_val_t off;
+    char *buf;
     if (path == nullptr) {
         fprintf(stderr, "filepath can't be null");
         return 0;
     }
-    FILE *f = fopen(path, "rb");
+    f = fopen(path, "rb");
     if (!f) {
         fprintf(stderr, "filepath %s can't be open", path);
         return 1;
     }
     fseek(f, 0, SEEK_END);
-    long sz = ftell(f);
+    sz = ftell(f);
     fseek(f, 0, SEEK_SET);
-    char *buf = (char *)malloc((size_t)sz + 1);
+    off = (spl_vm_val_t)(uintptr_t)spl_alloc_ex(VM_ASP(_vm), (uintptr_t)sz + 1);
+    if (off == 0) {
+        fclose(f);
+        return 0;
+    }
+    buf = (char *)VM_XN(_vm, off, (uintptr_t)sz + 1);
     if (!buf) {
         fclose(f);
         return 0;
     }
+    {
         size_t nread = fread(buf, 1, (size_t)sz, f);
-    fclose(f);
         buf[nread] = '\0';
-    return (spl_vm_val_t)(uintptr_t)buf;
+    }
+    fclose(f);
+    return off;
 }
 
-static spl_vm_val_t vm_alloc(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+/* =================================================================
+ * mem syscalls —— 使用 spl_rt_core.h 中的实现
+ * ================================================================= */
+
+static spl_vm_val_t spl_sys_vm_alloc(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    uintptr_t sz;
+    spl_vm_val_t p;
     CHECK_NARGS("vm_alloc", 1);
-    size_t sz = (size_t)args[0];
+    sz = (uintptr_t)args[0];
     if (sz == 0)
         SYSCALL_FAIL(_vm, "vm_alloc: zero size");
-    if (sz > (size_t)1 << 32)
+    if (sz > ((uintptr_t)1 << 32))
-        SYSCALL_FAIL(_vm, "vm_alloc: size too large (%zu)", sz);
+        SYSCALL_FAIL(_vm, "vm_alloc: size too large (%zu)", (size_t)sz);
-    void *p = malloc(sz);
+    p = (spl_vm_val_t)(uintptr_t)spl_alloc_ex(VM_ASP(_vm), sz);
-    if (!p)
+    if (p == 0)
-        SYSCALL_FAIL(_vm, "vm_alloc: malloc(%zu) failed", sz);
+        SYSCALL_FAIL(_vm, "vm_alloc: alloc(%zu) failed", (size_t)sz);
-    return (spl_vm_val_t)(uintptr_t)p;
+    return p;
 }
 
-static spl_vm_val_t vm_free(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+static spl_vm_val_t spl_sys_vm_free(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
-    (void)_vm;
     CHECK_NARGS("vm_free", 1);
-    void *p = (void *)(uintptr_t)args[0];
+    spl_free_ex(VM_ASP(_vm), (void *)(uintptr_t)args[0]);
-    if (p)
-        free(p);
     return 0;
 }
 
-static spl_vm_val_t vm_realloc(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+static spl_vm_val_t spl_sys_vm_realloc(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    uintptr_t sz;
+    spl_vm_val_t np;
     CHECK_NARGS("vm_realloc", 2);
-    void *p = (void *)(uintptr_t)args[0];
+    sz = (uintptr_t)args[1];
-    size_t sz = (size_t)args[1];
+    if (args[0] == 0)
-    if (!p)
         SYSCALL_FAIL(_vm, "vm_realloc: NULL ptr");
     if (sz == 0)
         SYSCALL_FAIL(_vm, "vm_realloc: zero size");
-    ADDRCHECK(_vm, p, 1, "vm_realloc");
+    np = (spl_vm_val_t)(uintptr_t)spl_realloc_ex(VM_ASP(_vm), (void *)(uintptr_t)args[0], sz);
-    void *np = realloc(p, sz);
+    if (np == 0)
-    if (!np)
+        SYSCALL_FAIL(_vm, "vm_realloc: realloc failed");
-        SYSCALL_FAIL(_vm, "vm_realloc: realloc(%p, %zu) failed", p, sz);
+    return np;
-    return (spl_vm_val_t)(uintptr_t)np;
 }
 
-static spl_vm_val_t vm_memcpy(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+static spl_vm_val_t spl_sys_vm_memcpy(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    void *dst, *src;
+    uintptr_t n;
     CHECK_NARGS("vm_memcpy", 3);
-    void *dst = (void *)(uintptr_t)args[0];
+    n = (uintptr_t)args[2];
-    const void *src = (const void *)(uintptr_t)args[1];
+    if (n == 0)
-    size_t size = (size_t)args[2];
+        return args[0];
-    if (size == 0)
+    dst = VM_X(_vm, args[0]);
-        return (spl_vm_val_t)(uintptr_t)dst;
+    src = VM_X(_vm, args[1]);
-    ADDRCHECK(_vm, dst, size, "vm_memcpy(dst)");
+    if (!dst || !src)
-    ADDRCHECK(_vm, src, size, "vm_memcpy(src)");
+        SYSCALL_FAIL(_vm, "vm_memcpy: invalid address");
-    memcpy(dst, src, size);
+    vm_memcpy(dst, src, n);
-    return (spl_vm_val_t)(uintptr_t)dst;
+    return args[0];
 }
 
-static spl_vm_val_t vm_memcmp(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+static spl_vm_val_t spl_sys_vm_memmove(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
-    CHECK_NARGS("vm_memcmp", 3);
+    void *dst, *src;
-    const void *a = (const void *)(uintptr_t)args[0];
+    uintptr_t n;
-    const void *b = (const void *)(uintptr_t)args[1];
+    CHECK_NARGS("vm_memmove", 3);
-    size_t size = (size_t)args[2];
+    n = (uintptr_t)args[2];
-    if (size == 0)
+    if (n == 0)
-        return 0;
+        return args[0];
-    ADDRCHECK(_vm, a, size, "vm_memcmp(a)");
+    dst = VM_X(_vm, args[0]);
-    ADDRCHECK(_vm, b, size, "vm_memcmp(b)");
+    src = VM_X(_vm, args[1]);
-    return (spl_vm_val_t)memcmp(a, b, size);
+    if (!dst || !src)
+        SYSCALL_FAIL(_vm, "vm_memmove: invalid address");
+    vm_memmove(dst, src, n);
+    return args[0];
 }
 
+static spl_vm_val_t spl_sys_vm_memcmp(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    const void *a, *b;
+    uintptr_t n;
+    CHECK_NARGS("vm_memcmp", 3);
+    a = VM_X(_vm, args[0]);
+    b = VM_X(_vm, args[1]);
+    n = (uintptr_t)args[2];
+    if (n && (!a || !b))
+        SYSCALL_FAIL(_vm, "vm_memcmp: invalid address");
+    return (spl_vm_val_t)(uintptr_t)vm_memcmp(a, b, n);
+}
+
+/* =================================================================
+ * Vec syscalls（参数按 VM 偏移解释）
+ * ================================================================= */
+
+#define VM_VEC_BYTES ((uintptr_t)sizeof(spl_vec_t))
+#define VM_MAP_BYTES ((uintptr_t)sizeof(spl_map_t))
+
+static spl_vm_val_t spl_sys_vm_vec_valid(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    CHECK_NARGS("vm_vec_valid", 1);
+    return (spl_vm_val_t)(uintptr_t)spl_vec_valid_ex(VM_XN(_vm, args[0], VM_VEC_BYTES));
+}
+
+static spl_vm_val_t spl_sys_vm_vec_push_raw(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    CHECK_NARGS("vm_vec_push_raw", 2);
+    return (spl_vm_val_t)(uintptr_t)spl_vec_push_raw_ex(
+        VM_ASP(_vm), VM_XN(_vm, args[0], VM_VEC_BYTES), VM_X(_vm, args[1]));
+}
+
+static spl_vm_val_t spl_sys_vm_vec_push(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    CHECK_NARGS("vm_vec_push", 2);
+    return (spl_vm_val_t)(uintptr_t)spl_vec_push_ex(
+        VM_ASP(_vm), VM_XN(_vm, args[0], VM_VEC_BYTES), VM_X(_vm, args[1]));
+}
+
+static spl_vm_val_t spl_sys_vm_vec_get(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    CHECK_NARGS("vm_vec_get", 3);
+    return (spl_vm_val_t)(uintptr_t)spl_vec_get_ex(
+        VM_ASP(_vm), VM_XN(_vm, args[0], VM_VEC_BYTES), (uintptr_t)args[1],
+        (void **)VM_XN(_vm, args[2], sizeof(void *)));
+}
+
+static spl_vm_val_t spl_sys_vm_vec_allocate(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    CHECK_NARGS("vm_vec_allocate", 4);
+    return (spl_vm_val_t)(uintptr_t)spl_vec_allocate_out_ex(
+        VM_ASP(_vm), VM_XN(_vm, args[0], VM_VEC_BYTES), (uintptr_t)args[1], (uintptr_t)args[2],
+        (uintptr_t)args[3]);
+}
+
+static spl_vm_val_t spl_sys_vm_vec_reserve_raw(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    CHECK_NARGS("vm_vec_reserve_raw", 2);
+    return (spl_vm_val_t)(uintptr_t)spl_vec_reserve_raw_void_ex(
+        VM_ASP(_vm), VM_XN(_vm, args[0], VM_VEC_BYTES), (uintptr_t)args[1]);
+}
+
+static spl_vm_val_t spl_sys_vm_vec_append(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    CHECK_NARGS("vm_vec_append", 3);
+    return (spl_vm_val_t)(uintptr_t)spl_vec_append_ex(
+        VM_ASP(_vm), VM_XN(_vm, args[0], VM_VEC_BYTES), VM_X(_vm, args[1]), (uintptr_t)args[2]);
+}
+
+static spl_vm_val_t spl_sys_vm_vec_set(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    CHECK_NARGS("vm_vec_set", 3);
+    return (spl_vm_val_t)(uintptr_t)spl_vec_set_ex(
+        VM_ASP(_vm), VM_XN(_vm, args[0], VM_VEC_BYTES), (uintptr_t)args[1], VM_X(_vm, args[2]));
+}
+
+static spl_vm_val_t spl_sys_vm_vec_pop(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    CHECK_NARGS("vm_vec_pop", 2);
+    return (spl_vm_val_t)(uintptr_t)spl_vec_pop_ex(VM_ASP(_vm),
+                                                   VM_XN(_vm, args[0], VM_VEC_BYTES),
+                                                   VM_X(_vm, args[1]));
+}
+
+static spl_vm_val_t spl_sys_vm_vec_clone(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    CHECK_NARGS("vm_vec_clone", 2);
+    return (spl_vm_val_t)(uintptr_t)spl_vec_clone_ex(
+        VM_ASP(_vm), VM_XN(_vm, args[0], VM_VEC_BYTES), VM_XN(_vm, args[1], VM_VEC_BYTES));
+}
+
+static spl_vm_val_t spl_sys_vm_vec_drop(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    CHECK_NARGS("vm_vec_drop", 1);
+    return (spl_vm_val_t)(uintptr_t)spl_vec_drop_ex(VM_ASP(_vm),
+                                                    VM_XN(_vm, args[0], VM_VEC_BYTES));
+}
+
+static spl_vm_val_t spl_sys_vm_bytes_eq(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    CHECK_NARGS("vm_bytes_eq", 4);
+    return (spl_vm_val_t)(uintptr_t)spl_bytes_eq_ex(VM_ASP(_vm), VM_X(_vm, args[0]),
+                                                    (uintptr_t)args[1], VM_X(_vm, args[2]),
+                                                    (uintptr_t)args[3]);
+}
+
+/* =================================================================
+ * Map syscalls
+ * ================================================================= */
+
+static spl_vm_val_t spl_sys_vm_map_valid(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    CHECK_NARGS("vm_map_valid", 1);
+    return (spl_vm_val_t)(uintptr_t)spl_map_valid_ex(VM_XN(_vm, args[0], VM_MAP_BYTES));
+}
+
+static spl_vm_val_t spl_sys_vm_map_reserve(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    CHECK_NARGS("vm_map_reserve", 2);
+    return (spl_vm_val_t)(uintptr_t)spl_map_reserve_void_ex(
+        VM_ASP(_vm), VM_XN(_vm, args[0], VM_MAP_BYTES), (uintptr_t)args[1]);
+}
+
+static spl_vm_val_t spl_sys_vm_map_put(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    CHECK_NARGS("vm_map_put", 3);
+    return (spl_vm_val_t)(uintptr_t)spl_map_put_ex(
+        VM_ASP(_vm), VM_XN(_vm, args[0], VM_MAP_BYTES), VM_X(_vm, args[1]), VM_X(_vm, args[2]));
+}
+
+static spl_vm_val_t spl_sys_vm_map_get(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    CHECK_NARGS("vm_map_get", 3);
+    return (spl_vm_val_t)(uintptr_t)spl_map_get_ex(
+        VM_ASP(_vm), VM_XN(_vm, args[0], VM_MAP_BYTES), VM_X(_vm, args[1]), VM_X(_vm, args[2]));
+}
+
+static spl_vm_val_t spl_sys_vm_map_del(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    CHECK_NARGS("vm_map_del", 2);
+    return (spl_vm_val_t)(uintptr_t)spl_map_del_ex(
+        VM_ASP(_vm), VM_XN(_vm, args[0], VM_MAP_BYTES), VM_X(_vm, args[1]));
+}
+
+static spl_vm_val_t spl_sys_vm_map_clear(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    CHECK_NARGS("vm_map_clear", 1);
+    return (spl_vm_val_t)(uintptr_t)spl_map_clear_ex(VM_ASP(_vm),
+                                                     VM_XN(_vm, args[0], VM_MAP_BYTES));
+}
+
+static spl_vm_val_t spl_sys_vm_map_drop(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    CHECK_NARGS("vm_map_drop", 1);
+    return (spl_vm_val_t)(uintptr_t)spl_map_drop_ex(VM_ASP(_vm),
+                                                    VM_XN(_vm, args[0], VM_MAP_BYTES));
+}
+
+/* =================================================================
+ * printf / timestamp
+ * ================================================================= */
+
 static spl_vm_val_t vm_printf(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
-    (void)_vm;
     if (nargs <= 0)
         return 0;
 
-    /* args[0] 是 SPL 的 []u8 format 参数。VM 里 slice 作为参数传递时，
+    const spl_vm_val_t *fmt_slice =
-       栈上压的是"指向 slice 结构体的指针"，结构为 {ptr:*u8, len:u64} */
+        (const spl_vm_val_t *)VM_XN(_vm, args[0], 2 * sizeof(spl_vm_val_t));
-    const spl_vm_val_t *fmt_slice = (const spl_vm_val_t *)args[0];
+    const char *fmt;
-    const char *fmt = (const char *)fmt_slice[0];
+    usize fmt_len;
-    usize fmt_len = (usize)fmt_slice[1];
+    if (!fmt_slice)
+        return 0;
+    fmt = (const char *)VM_X(_vm, fmt_slice[0]);
+    fmt_len = (usize)fmt_slice[1];
+    if (!fmt && fmt_len)
+        return 0;
 
     if (nargs <= 1) {
         fwrite(fmt, 1, fmt_len, stdout);
@@ -275,7 +531,7 @@ static spl_vm_val_t vm_printf(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
     string_builder_t buffer;
     vec_init(buffer);
 
-    int arg_idx = 1; /* 0 是 format */
+    int arg_idx = 1;
     char tmp_buf[32];
 
     for (usize i = 0; i < fmt_len; ++i) {
@@ -302,9 +558,11 @@ static spl_vm_val_t vm_printf(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
             arg_idx++;
             break;
         case 's': {
-            const spl_vm_val_t *s = (const spl_vm_val_t *)args[arg_idx];
+            const spl_vm_val_t *s =
-            const char *p = (const char *)s[0];
+                (const spl_vm_val_t *)VM_XN(_vm, args[arg_idx], 2 * sizeof(spl_vm_val_t));
-            usize l = (usize)s[1];
+            const char *p = s ? (const char *)VM_X(_vm, s[0]) : NULL;
+            usize l = s ? (usize)s[1] : 0;
+            if (p)
                 for (usize j = 0; j < l; ++j)
                     vec_push(buffer, p[j]);
             arg_idx++;
@@ -323,15 +581,6 @@ static spl_vm_val_t vm_printf(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
     return (spl_vm_val_t)nargs;
 }
 
-/* 探测接口（syscall 风格，非必选，逐步扩展）。
- * 不假设一定可用：不支持时统一返回 0。
- *   case 0 -> 是否存在 time：1 = 存在（则 case 1/2 有效），0 = 不存在
- *   case 1 -> 当前秒（time_t）
- *   case 2 -> 当前纳秒部分（tv_nsec）
- *   case 3 -> VM 已执行指令数（参考量；解码/执行恒定时可换算时间）
- *   case 4 -> 完整纳秒时间戳（单次调用，避免 sec/ns 跨秒竞态；
- *             纪元纳秒约 1.8e18 < u64 上限，usize 足够，无需 i128）
- * 新增探测点先加 case，再在 SPL 侧逐步验证。 */
 static spl_vm_val_t vm_timestamp(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
     CHECK_NARGS("vm_timestamp", 1);
     spl_vm_val_t arg = args[0];
@@ -348,6 +597,10 @@ static spl_vm_val_t vm_timestamp(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
         if (!_vm)
             return 0;
         return (spl_vm_val_t)_vm->steps;
+    case 5:
+        if (!_vm)
+            return 0;
+        return (spl_vm_val_t)_vm->ncalls;
     case 4:
         return has_time ? (spl_vm_val_t)((unsigned long long)ts.tv_sec * 1000000000ull +
                                          (unsigned long long)ts.tv_nsec)
@@ -359,17 +612,60 @@ static spl_vm_val_t vm_timestamp(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
 }
 
 /* =================================================================
- * VM syscalls (for comptime - compile-time code execution)
+ * nested-VM syscalls
- *
- * These let SPL code create isolated sub-VMs, load compiled .sir
- * programs into them, push arguments, call functions, and run.
  * ================================================================= */
 
-/* vm_new - create a new sub-VM instance, returns spl_vm_t* */
+/* 通用双向桥（配置层策略，非 VM 平台 API）：
+ * 在子 VM 上安装「未解析 native 处理器」，把子 VM 的未解析调用按名转发到
+ * 宿主（调用者）VM 中由 `entry` 指定的函数。宿主函数收到：
+ *     (ctx, name_off, name_len, nested_vm, arg_base, nargs)
+ * 平台/C 侧**纯转发**：不复制实参、不限元数、不了解类型；聚合读写由宿主用
+ * vm_stack_get / vm_mem_read / vm_mem_alloc / vm_mem_write 自行完成。
+ * `entry` 由宿主显式给出，平台不预设任何函数名。 */
+typedef struct {
+    spl_vm_t *host;
+    void *ctx;
+    char entry[128];
+} spl_bridge_t;
+
+static spl_vm_val_t spl_bridge_forward(spl_vm_t *nested, const spl_vm_call_t *call, void *user) {
+    spl_bridge_t *b = (spl_bridge_t *)user;
+    spl_vm_val_t name_off;
+    spl_vm_val_t args[6];
+    spl_vm_call_t back;
+    usize n;
+    usize arg_base;
+    if (!b || !b->host || !call || !call->name || b->entry[0] == '\0')
+        return 0;
+    n = strlen(call->name);
+    /* 名拷进宿主 VM 内存，宿主按偏移读取。 */
+    name_off = spl_vm_mem_alloc(b->host, n + 1);
+    if (!name_off)
+        return 0;
+    if (spl_vm_mem_write(b->host, name_off, call->name, n + 1) != 0)
+        return 0;
+    arg_base = spl_vm_call_arg_base(nested, call);
+    if (arg_base == (usize)-1)
+        return 0;
+    args[0] = (spl_vm_val_t)(uintptr_t)b->ctx;
+    args[1] = name_off;
+    args[2] = (spl_vm_val_t)n;
+    args[3] = (spl_vm_val_t)(uintptr_t)nested;
+    args[4] = (spl_vm_val_t)arg_base;
+    args[5] = (spl_vm_val_t)call->nargs;
+    back.name = b->entry;
+    back.args = args;
+    back.nargs = 6;
+    back.ret = 0;
+    if (spl_vm_invoke(b->host, &back) != 0)
+        return 0;
+    return back.ret;
+}
+
 static spl_vm_val_t vm_new(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
-    (void)_vm;
     CHECK_NARGS("vm_new", 0);
     (void)args;
+    (void)_vm;
     spl_vm_t *vm = (spl_vm_t *)malloc(sizeof(spl_vm_t));
     if (!vm)
         return 0;
@@ -377,13 +673,43 @@ static spl_vm_val_t vm_new(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
     return (spl_vm_val_t)(uintptr_t)vm;
 }
 
-/* vm_drop - destroy a sub-VM and its loaded program */
+/* vm_set_foreign(vm, entry, ctx)：宿主显式指定处理器函数名。 */
+static spl_vm_val_t sc_vm_set_foreign(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    spl_vm_t *vm;
+    spl_bridge_t *b;
+    const spl_vm_val_t *entry;
+    const char *eptr;
+    usize elen;
+    CHECK_NARGS("vm_set_foreign", 3);
+    vm = (spl_vm_t *)(uintptr_t)args[0];
+    if (!vm || !_vm)
+        return -1;
+    entry = (const spl_vm_val_t *)VM_XN(_vm, args[1], 2 * sizeof(spl_vm_val_t));
+    if (!entry)
+        return -1;
+    eptr = (const char *)VM_X(_vm, entry[0]);
+    elen = (usize)entry[1];
+    if (!eptr || elen == 0 || elen >= sizeof(((spl_bridge_t *)0)->entry))
+        return -1;
+    b = (spl_bridge_t *)malloc(sizeof(*b));
+    if (!b)
+        return -1;
+    b->host = _vm;
+    b->ctx = (void *)(uintptr_t)args[2];
+    memcpy(b->entry, eptr, elen);
+    b->entry[elen] = '\0';
+    spl_vm_set_foreign(vm, spl_bridge_forward, b);
+    return 0;
+}
+
 static spl_vm_val_t vm_drop(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
     (void)_vm;
     CHECK_NARGS("vm_drop", 1);
     spl_vm_t *vm = (spl_vm_t *)(uintptr_t)args[0];
     if (!vm)
         return 0;
+    if (vm->foreign == spl_bridge_forward && vm->foreign_ctx)
+        free(vm->foreign_ctx);
     if (vm->prog) {
         spl_prog_drop(vm->prog);
         free(vm->prog);
@@ -394,12 +720,10 @@ static spl_vm_val_t vm_drop(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
     return 0;
 }
 
-/* vm_load - load a .sir file, register syscalls, return spl_prog_t* */
 static spl_vm_val_t vm_load(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
-    (void)_vm;
     CHECK_NARGS("vm_load", 2);
     spl_vm_t *vm = (spl_vm_t *)(uintptr_t)args[0];
-    const char *path = (const char *)(uintptr_t)args[1];
+    const char *path = (const char *)VM_X(_vm, args[1]);
     if (!vm || !path)
         return -1;
 
@@ -419,7 +743,30 @@ 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_push - push a value onto the sub-VM's stack (for passing arguments) */
+static spl_vm_val_t vm_load_from_buffer(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    CHECK_NARGS("vm_load_from_buffer", 3);
+    spl_vm_t *vm = (spl_vm_t *)(uintptr_t)args[0];
+    const char *buf = (const char *)VM_XN(_vm, args[1], (usize)args[2]);
+    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;
+    }
+    /* 不自动注入任何 native/syscall：解析策略由使用者配置。 */
+    if (spl_vm_load_prog(vm, prog) != 0) {
+        spl_prog_drop(prog);
+        free(prog);
+        return -1;
+    }
+    return 0;
+}
+
 static spl_vm_val_t vm_push(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
     (void)_vm;
     CHECK_NARGS("vm_push", 2);
@@ -435,67 +782,101 @@ static spl_vm_val_t vm_push(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
     return 0;
 }
 
-/* vm_call - call a function by name with pre-pushed arguments
- *
- * Args (3): vm, function_name, nargs
- * The arguments should already be on the sub-VM's stack via vm_push.
- *
- * Mirrors the CALL instruction's frame setup:
- *   - Pushes a sentinel frame (saved_ip=-1) if cp==0 so RET halts properly
- *   - Pushes the actual call frame
- *   - Sets fp = sp - nargs  (so arg0 = data[fp], arg1 = data[fp+1], ...)
- *   - Sets ip to the function address
- */
 static spl_vm_val_t vm_call(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
-    (void)_vm;
     CHECK_NARGS("vm_call", 3);
     spl_vm_t *vm = (spl_vm_t *)(uintptr_t)args[0];
-    const char *name = (const char *)(uintptr_t)args[1];
+    const char *name = (const char *)VM_X(_vm, args[1]);
     spl_vm_val_t call_nargs = args[2];
     if (!vm || !name)
         return -1;
 
-    spl_vm_func_t *func = spl_prog_get_func(vm->prog, name);
+    if (spl_vm_call_entry(vm, name, (int)call_nargs) != 0) {
-    if (!func) {
+        fprintf(stderr, "vm_call: function '%s' not found or bad ABI\n", name);
-        fprintf(stderr, "vm_call: function '%s' not found\n", name);
         return -1;
     }
-    if (vm->cp >= vm->config.max_call_depth - 1) {
-        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;
-    vm->ip = (uintptr_t)func->address;
     return 0;
 }
 
-/* vm_run - run a sub-VM to completion, returns exit_code */
+static spl_vm_val_t vm_run(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
-SYSCALL_1(vm_run, spl_vm_t *, spl_vm_run_until(a1, 0))
+    (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->ret_val;
+}
+
+/* ---- 栈 / 结果 / 内存 访问（不暴露宿主指针） ---- */
+
+static spl_vm_val_t sc_vm_ret_val(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    (void)_vm;
+    CHECK_NARGS("vm_ret_val", 1);
+    return spl_vm_ret_val((spl_vm_t *)(uintptr_t)args[0]);
+}
+
+static spl_vm_val_t sc_vm_sp(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    (void)_vm;
+    CHECK_NARGS("vm_sp", 1);
+    return (spl_vm_val_t)spl_vm_sp((spl_vm_t *)(uintptr_t)args[0]);
+}
+
+static spl_vm_val_t sc_vm_fp(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    (void)_vm;
+    CHECK_NARGS("vm_fp", 1);
+    return (spl_vm_val_t)spl_vm_fp((spl_vm_t *)(uintptr_t)args[0]);
+}
+
+static spl_vm_val_t sc_vm_stack_get(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    (void)_vm;
+    CHECK_NARGS("vm_stack_get", 2);
+    return spl_vm_stack_get((spl_vm_t *)(uintptr_t)args[0], (usize)args[1]);
+}
+
+static spl_vm_val_t sc_vm_stack_set(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    (void)_vm;
+    CHECK_NARGS("vm_stack_set", 3);
+    return (spl_vm_val_t)spl_vm_stack_set((spl_vm_t *)(uintptr_t)args[0], (usize)args[1], args[2]);
+}
+
+static spl_vm_val_t sc_vm_mem_alloc(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    (void)_vm;
+    CHECK_NARGS("vm_mem_alloc", 2);
+    return spl_vm_mem_alloc((spl_vm_t *)(uintptr_t)args[0], (usize)args[1]);
+}
+
+static spl_vm_val_t sc_vm_mem_read(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    spl_vm_t *vm;
+    void *dst;
+    usize n;
+    CHECK_NARGS("vm_mem_read", 4);
+    vm = (spl_vm_t *)(uintptr_t)args[0];
+    n = (usize)args[3];
+    dst = VM_XN(_vm, args[2], n);
+    if ((!dst) && n)
+        return -1;
+    return (spl_vm_val_t)spl_vm_mem_read(vm, (spl_vm_val_t)args[1], dst, n);
+}
+
+static spl_vm_val_t sc_vm_mem_write(spl_vm_t *_vm, int nargs, spl_vm_val_t *args) {
+    spl_vm_t *vm;
+    void *src;
+    usize n;
+    CHECK_NARGS("vm_mem_write", 4);
+    vm = (spl_vm_t *)(uintptr_t)args[0];
+    n = (usize)args[3];
+    src = VM_XN(_vm, args[2], n);
+    if ((!src) && n)
+        return -1;
+    return (spl_vm_val_t)spl_vm_mem_write(vm, (spl_vm_val_t)args[1], src, n);
+}
 
 /* =================================================================
  * Registration
- *
- * Called after loading a .sir file.  Matches native declarations in
- * prog->natives against known syscall names and hooks up impl_fn.
  * ================================================================= */
 
 void spl_syscall_register(spl_prog_t *prog) {
     static spl_vm_native_t table[] = {
-        /* OS operations */
         {"vm_exit", 0, vm_exit},
         {"vm_putchar", 0, vm_putchar},
         {"vm_getchar", 0, vm_getchar},
@@ -510,21 +891,55 @@ void spl_syscall_register(spl_prog_t *prog) {
         {"vm_stdout", 0, vm_stdout},
         {"vm_stderr", 0, vm_stderr},
         {"vm_read_file", 0, vm_read_file},
-        {"vm_alloc", 0, vm_alloc},
+
-        {"vm_free", 0, vm_free},
+        {"vm_alloc", 0, spl_sys_vm_alloc},
-        {"vm_realloc", 0, vm_realloc},
+        {"vm_free", 0, spl_sys_vm_free},
-        {"vm_memcpy", 0, vm_memcpy},
+        {"vm_realloc", 0, spl_sys_vm_realloc},
-        {"vm_memcmp", 0, vm_memcmp},
+        {"vm_memcpy", 0, spl_sys_vm_memcpy},
+        {"vm_memmove", 0, spl_sys_vm_memmove},
+        {"vm_memcmp", 0, spl_sys_vm_memcmp},
         {"vm_printf", 0, vm_printf},
 
+        {"vm_vec_valid", 0, spl_sys_vm_vec_valid},
+        {"vm_vec_push_raw", 0, spl_sys_vm_vec_push_raw},
+        {"vm_vec_push", 0, spl_sys_vm_vec_push},
+        {"vm_vec_get", 0, spl_sys_vm_vec_get},
+        {"vm_vec_allocate", 0, spl_sys_vm_vec_allocate},
+        {"vm_vec_reserve_raw", 0, spl_sys_vm_vec_reserve_raw},
+        {"vm_vec_append", 0, spl_sys_vm_vec_append},
+        {"vm_vec_set", 0, spl_sys_vm_vec_set},
+        {"vm_vec_pop", 0, spl_sys_vm_vec_pop},
+        {"vm_vec_clone", 0, spl_sys_vm_vec_clone},
+        {"vm_vec_drop", 0, spl_sys_vm_vec_drop},
+        {"vm_bytes_eq", 0, spl_sys_vm_bytes_eq},
+
+        {"vm_map_valid", 0, spl_sys_vm_map_valid},
+        {"vm_map_reserve", 0, spl_sys_vm_map_reserve},
+        {"vm_map_put", 0, spl_sys_vm_map_put},
+        {"vm_map_get", 0, spl_sys_vm_map_get},
+        {"vm_map_del", 0, spl_sys_vm_map_del},
+        {"vm_map_clear", 0, spl_sys_vm_map_clear},
+        {"vm_map_drop", 0, spl_sys_vm_map_drop},
+
         {"vm_timestamp", 0, vm_timestamp},
-        /* VM operations (comptime) */
+
         {"vm_new", 0, vm_new},
+        {"vm_set_foreign", 0, sc_vm_set_foreign},
         {"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},
+
+        {"vm_ret_val", 0, sc_vm_ret_val},
+        {"vm_sp", 0, sc_vm_sp},
+        {"vm_fp", 0, sc_vm_fp},
+        {"vm_stack_get", 0, sc_vm_stack_get},
+        {"vm_stack_set", 0, sc_vm_stack_set},
+        {"vm_mem_alloc", 0, sc_vm_mem_alloc},
+        {"vm_mem_read", 0, sc_vm_mem_read},
+        {"vm_mem_write", 0, sc_vm_mem_write},
     };
     int n = (int)(sizeof(table) / sizeof(table[0]));
     if (!prog)

stage0/spl_vm.h

@@ -5,11 +5,25 @@
 
 #include "include/core_map.h"
 #include "include/core_vec.h"
+#include "spl_asp.h"
 #include "spl_mcode.h"
 #include <stdint.h>
 
 #define SPL_STACK_CANARY ((spl_vm_val_t)0xDEADBEEFCAFEBABEull)
 
+/* 统一偏移地址空间：SPL 侧指针一律是句柄/偏移，0 保留为 null。
+ * offset = (handle<<32) | 区内字节偏移；handle 1 = 栈，handle>=2 = 堆分配。 */
+#define SPL_OFF_NULL ((spl_vm_val_t)0)
+#define SPL_ASP_HANDLE_STACK ((spl_vm_val_t)1)
+#define SPL_ASP_OFF(handle, byte) ((((spl_vm_val_t)(handle)) << 32) | (spl_vm_val_t)(byte))
+
+typedef struct {
+    unsigned char *base;
+    usize size;
+    int used;
+} spl_vm_region_t;
+typedef VEC(spl_vm_region_t) spl_vm_region_vec_t;
+
 typedef struct {
     uintptr_t saved_sp;
     uintptr_t saved_fp;
@@ -20,9 +34,24 @@ typedef struct {
 typedef VEC(spl_vm_val_t) spl_stack_vec_t;
 typedef VEC(spl_callframe_t) spl_frame_vec_t;
 
+/* 一次调用描述（VM <-> 外部两侧统一形状）。 */
+typedef struct {
+    const char *name;
+    const spl_vm_val_t *args;
+    usize nargs;
+    spl_vm_val_t ret;
+} spl_vm_call_t;
+
+/* 线 1 动态形态：VM 调“外部（非 VM）函数”的按名处理器。
+ * 当 NCALL 的 native 无 impl_fn 时调用；返回被调函数的返回值。 */
+typedef spl_vm_val_t (*spl_vm_foreign_fn)(spl_vm_t *vm, const spl_vm_call_t *call, void *ctx);
+
 typedef struct {
     MAP(const char *, usize) stacks;
     VEC(usize) self_samples;
+    VEC(uint64_t) self_ns; /* 每函数 time-slice 累加（纳秒） */
+    uint64_t last_ns;
+    uint64_t total_ns;
     usize samples;
 } spl_prof_t;
 
@@ -35,6 +64,7 @@ typedef struct spl_vm {
     uintptr_t cp;    // call pointer
     uintptr_t ip;    // instr pointer
     uint64_t steps;  // 已执行指令数（供性能分析参考）
+    uint64_t ncalls; // 已执行 CALL/CALLI 次数（供性能分析参考）
     int exit_code;
     int trace;                  /* non-zero to print each instruction */
     int debug;                  /* non-zero to enable canary checks */
@@ -45,6 +75,14 @@ typedef struct spl_vm {
     VEC(usize) breakpoints;     /* ip 断点（执行到该指令前暂停，run_once 返回 2） */
     VEC(char *) fn_breakpoints; /* 函数名断点（CALL/CALLI 目标函数入口暂停） */
     spl_prog_t *prog;
+    /* 统一偏移地址空间：regions[1]=栈，regions[i>=2]=堆分配。 */
+    spl_vm_region_vec_t regions;
+    VEC(usize) gdata_off; /* prog->gdata[i] 在本 VM 空间内的偏移 */
+    spl_asp_t asp; /* 本 VM 的地址空间描述符（按值持有，避免共享静态） */
+    spl_vm_val_t stdio_off[3]; /* stdin/stdout/stderr 的 VM 句柄（懒建） */
+    spl_vm_val_t ret_val; /* 最近一次完成的调用返回值（64 位） */
+    spl_vm_foreign_fn foreign; /* 线 1 动态处理器（可为 NULL） */
+    void *foreign_ctx;
     char error_msg[1024];
     struct {
         uintptr_t max_stack_depth;
@@ -64,6 +102,38 @@ void spl_vm_drop(spl_vm_t *vm);
 
 int spl_vm_addr_valid(uintptr_t p, usize size);
 
+/* 偏移地址空间：偏移 -> 宿主地址；越界/ null 返回 NULL。 */
+void *spl_vm_xlate(spl_vm_t *vm, spl_vm_val_t off, usize size);
+/* 宿主地址 -> 偏移；不属于本 VM 地址空间返回 0。 */
+spl_vm_val_t spl_vm_to_off(spl_vm_t *vm, const void *ptr);
+/* 本 VM 的地址空间描述符（供 runtime 解引用）。 */
+spl_asp_t *spl_vm_asp(spl_vm_t *vm);
+
+/* ---- 线 1：VM -> 外部函数 ---- */
+/* 安装“外部函数”按名处理器（NCALL 的 native 无 impl_fn 时使用）。 */
+void spl_vm_set_foreign(spl_vm_t *vm, spl_vm_foreign_fn fn, void *ctx);
+
+/* ---- 线 2：外部 -> VM 函数 ---- */
+/* 按 call->name 调用 VM 内函数（call->args/nargs 为实参），结果写入 call->ret。
+ * 可在 VM 运行中重入调用。返回 0 成功，-1 失败。 */
+int spl_vm_invoke(spl_vm_t *vm, spl_vm_call_t *call);
+
+/* 入口调用：调用方先按 ABI 压 2 个 pad 再压实参。 */
+int spl_vm_call_entry(spl_vm_t *vm, const char *name, int nargs);
+
+/* ---- 栈 / 结果 / 内存 访问（不暴露宿主指针） ---- */
+spl_vm_val_t spl_vm_ret_val(spl_vm_t *vm);
+usize spl_vm_sp(spl_vm_t *vm);
+usize spl_vm_fp(spl_vm_t *vm);
+spl_vm_val_t spl_vm_stack_get(spl_vm_t *vm, usize index);
+int spl_vm_stack_set(spl_vm_t *vm, usize index, spl_vm_val_t val);
+/* 本次调用实参在 VM 栈中的起始下标（外部处理器可按需用 stack_get 逐个读取，
+ * 无需在 C 侧了解参数类型/元数上限）。失败返回 (usize)-1。 */
+usize spl_vm_call_arg_base(spl_vm_t *vm, const spl_vm_call_t *call);
+spl_vm_val_t spl_vm_mem_alloc(spl_vm_t *vm, usize size);
+int spl_vm_mem_read(spl_vm_t *vm, spl_vm_val_t off, void *dst, usize n);
+int spl_vm_mem_write(spl_vm_t *vm, spl_vm_val_t off, const void *src, usize n);
+
 int spl_vm_load_prog(spl_vm_t *vm, spl_prog_t *prog);
 int spl_vm_prepare(spl_vm_t *vm, const char *entry, int argc, const char **argv, const char **envp);
 

stage0/spl_vm_embed.h

@@ -0,0 +1,116 @@
+/* spl_vm_embed.h - 裸机内嵌 VM（装载/运行，不含任何内置 native/syscall）。
+ *
+ * 单 TU 合并式：定义 SPL_VM_EMBED_IMPLIMENTATION 后 include 本头，会把 stage0 的
+ * spl_mcode.c / spl_vm.c 一并纳入当前翻译单元（不单独编译/链接）。
+ */
+
+#ifndef __SPL_VM_EMBED_H__
+#define __SPL_VM_EMBED_H__
+
+void *vm_new(void);
+void vm_drop(void *vm);
+int vm_load_from_buffer(void *vm, const void *buf, unsigned long long len);
+void vm_push(void *vm, unsigned long long val);
+int vm_call(void *vm, const char *name, unsigned long long nargs);
+int vm_run(void *vm);
+unsigned long long vm_ret_val(void *vm);
+unsigned long long vm_mem_alloc(void *vm, unsigned long long size);
+int vm_mem_read(void *vm, unsigned long long off, void *dst, unsigned long long n);
+int vm_mem_write(void *vm, unsigned long long off, const void *src, unsigned long long n);
+
+#ifdef SPL_VM_EMBED_IMPLIMENTATION
+
+/* 裸机内嵌 VM：只提供装载/运行 VM 的能力，不内置任何 native/syscall。
+ * 外部函数解析与注册属于配置端（调用方自行处理）。 */
+#include "spl_mcode.c"
+#include "spl_vm.c"
+
+void *vm_new(void) {
+    spl_vm_t *vm = (spl_vm_t *)malloc(sizeof(spl_vm_t));
+    if (!vm)
+        return 0;
+    spl_vm_init(vm);
+    return vm;
+}
+
+void vm_drop(void *p) {
+    spl_vm_t *vm = (spl_vm_t *)p;
+    if (!vm)
+        return;
+    if (vm->prog) {
+        spl_prog_drop(vm->prog);
+        free(vm->prog);
+        vm->prog = 0;
+    }
+    spl_vm_drop(vm);
+    free(vm);
+}
+
+int vm_load_from_buffer(void *p, const void *buf, unsigned long long len) {
+    spl_vm_t *vm = (spl_vm_t *)p;
+    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((const char *)buf, (usize)len, prog) != 0) {
+        free(prog);
+        return -1;
+    }
+    if (spl_vm_load_prog(vm, prog) != 0) {
+        spl_prog_drop(prog);
+        free(prog);
+        return -1;
+    }
+    return 0;
+}
+
+void vm_push(void *p, unsigned long long val) {
+    spl_vm_t *vm = (spl_vm_t *)p;
+    if (!vm)
+        return;
+    if (vm->sp >= vm->config.max_stack_depth)
+        return;
+    vm->stacks.data[vm->sp++] = (spl_vm_val_t)val;
+}
+
+int vm_call(void *p, const char *name, unsigned long long nargs) {
+    spl_vm_t *vm = (spl_vm_t *)p;
+    if (!vm || !name)
+        return -1;
+    /* 入口调用：调用方需先按 ABI 压 2 个 pad 再压实参。 */
+    return spl_vm_call_entry(vm, name, (int)nargs);
+}
+
+int vm_run(void *p) {
+    spl_vm_t *vm = (spl_vm_t *)p;
+    if (!vm)
+        return -1;
+    spl_vm_run_until(vm, 0);
+    return (int)vm->exit_code;
+}
+
+unsigned long long vm_ret_val(void *p) {
+    spl_vm_t *vm = (spl_vm_t *)p;
+    return vm ? (unsigned long long)vm->ret_val : 0;
+}
+
+unsigned long long vm_mem_alloc(void *p, unsigned long long size) {
+    spl_vm_t *vm = (spl_vm_t *)p;
+    return (unsigned long long)spl_vm_mem_alloc(vm, (usize)size);
+}
+
+int vm_mem_read(void *p, unsigned long long off, void *dst, unsigned long long n) {
+    spl_vm_t *vm = (spl_vm_t *)p;
+    return spl_vm_mem_read(vm, (spl_vm_val_t)off, dst, (usize)n);
+}
+
+int vm_mem_write(void *p, unsigned long long off, const void *src, unsigned long long n) {
+    spl_vm_t *vm = (spl_vm_t *)p;
+    return spl_vm_mem_write(vm, (spl_vm_val_t)off, src, (usize)n);
+}
+
+#endif /* SPL_VM_EMBED_IMPLIMENTATION */
+
+#endif /* __SPL_VM_EMBED_H__ */

stage0/test_spl_vm.c

@@ -6,6 +6,7 @@
 
 #include "include/acutest.h"
 #include "spl_mcode.h"
+#include "spl_syscall.h"
 #include "spl_vm.h"
 
 #include <stdio.h>
@@ -159,7 +160,8 @@ static int run_with_natives(const spl_vm_ins_t *instns, int ninsns, spl_vm_nativ
  * Native function for NCALL tests
  * ================================================================ */
 
-static spl_vm_val_t native_add_impl(int nargs, spl_vm_val_t *args) {
+static spl_vm_val_t native_add_impl(spl_vm_t *vm, int nargs, spl_vm_val_t *args) {
+    (void)vm;
     return (nargs >= 2) ? args[0] + args[1] : 0;
 }
 
@@ -479,7 +481,8 @@ void test_call_add(void) {
     spl_vm_ins_t add_insns[] = {ins(SPL_LADDR, SPL_VOID, 0), ins(SPL_LOAD, SPL_I64, 0),
                                 ins(SPL_LADDR, SPL_VOID, 8), ins(SPL_LOAD, SPL_I64, 0),
                                 ins(SPL_ADD, SPL_I64, 0),    ins(SPL_RET, SPL_I64, 0)};
-    spl_vm_ins_t main_insns[] = {ins(SPL_PUSH, SPL_I32, 10), ins(SPL_PUSH, SPL_I32, 20),
+    spl_vm_ins_t main_insns[] = {ins(SPL_PUSH, SPL_VOID, 0), ins(SPL_PUSH, SPL_VOID, 0),
+                                 ins(SPL_PUSH, SPL_I32, 10), ins(SPL_PUSH, SPL_I32, 20),
                                  ins(SPL_PUSH, SPL_VOID, 0), ins(SPL_CALL, SPL_VOID, 2),
                                  ins(SPL_RET, SPL_I64, 0)};
 
@@ -586,11 +589,12 @@ void test_calli(void) {
     spl_vm_ins_t add_insns[] = {ins(SPL_LADDR, SPL_VOID, 0), ins(SPL_LOAD, SPL_I64, 0),
                                 ins(SPL_LADDR, SPL_VOID, 8), ins(SPL_LOAD, SPL_I64, 0),
                                 ins(SPL_ADD, SPL_I64, 0),    ins(SPL_RET, SPL_I64, 0)};
-    spl_vm_ins_t main_insns[] = {ins(SPL_PUSH, SPL_I32, 10),  ins(SPL_PUSH, SPL_I32, 20),
+    spl_vm_ins_t main_insns[] = {ins(SPL_PUSH, SPL_VOID, 0),  ins(SPL_PUSH, SPL_VOID, 0),
+                                 ins(SPL_PUSH, SPL_I32, 10),  ins(SPL_PUSH, SPL_I32, 20),
                                  ins(SPL_PUSH, SPL_VOID, 2),  ins(SPL_PUSH, SPL_VOID, 0),
                                  ins(SPL_CALLI, SPL_VOID, 0), ins(SPL_RET, SPL_I64, 0)};
 
-    int ninsns_t = 6 + 6;
+    int ninsns_t = 6 + 8;
     size_t nlen0 = strlen("add") + 1;
     size_t npad0 = ((nlen0 + 7) / 8) * 8 - nlen0;
     size_t nlen1 = strlen("main") + 1;
@@ -627,7 +631,7 @@ void test_calli(void) {
     p += npad1;
     LE64(p, 0);
     LE64(p, 0);
-    LE64(p, 6);
+    LE64(p, 8);
     LE64(p, 6);
 
     for (int i = 0; i < 6; i++) {
@@ -637,7 +641,7 @@ void test_calli(void) {
         *p++ = (unsigned char)(add_insns[i].type >> 8);
         LE64(p, add_insns[i].imm);
     }
-    for (int i = 0; i < 6; i++) {
+    for (int i = 0; i < 8; i++) {
         *p++ = (unsigned char)(main_insns[i].opcode);
         *p++ = (unsigned char)(main_insns[i].opcode >> 8);
         *p++ = (unsigned char)(main_insns[i].type);
@@ -669,8 +673,9 @@ void test_calli(void) {
  * ================================================================ */
 
 void test_gaddr_ld32(void) {
-    /* Load program, add global data, GADDR + LD32 to read it back */
+    /* Load program, add global data, GADDR + LD32 to read it back.
-    spl_vm_ins_t p[] = {ins(SPL_GADDR, SPL_VOID, 0), ins(SPL_LOAD, SPL_U32, 0),
+     * gdata 索引 0 为哨兵；首次 add_data 得到索引 1。 */
+    spl_vm_ins_t p[] = {ins(SPL_GADDR, SPL_VOID, 1), ins(SPL_LOAD, SPL_U32, 0),
                         ins(SPL_RET, SPL_U32, 0)};
     size_t len;
     unsigned char *bin = build_binary("main", 0, p, 3, &len);
@@ -697,8 +702,8 @@ void test_gaddr_ld32(void) {
 }
 
 void test_gaddr_multi(void) {
-    /* Two global data entries: read second one via GADDR 1 */
+    /* Two global data entries: read second one via GADDR 2 (0 为哨兵) */
-    spl_vm_ins_t p[] = {ins(SPL_GADDR, SPL_VOID, 1), ins(SPL_LOAD, SPL_U32, 0),
+    spl_vm_ins_t p[] = {ins(SPL_GADDR, SPL_VOID, 2), ins(SPL_LOAD, SPL_U32, 0),
                         ins(SPL_RET, SPL_U32, 0)};
     size_t len;
     unsigned char *bin = build_binary("main", 0, p, 3, &len);
@@ -818,6 +823,127 @@ void test_empty(void) {
     TEST_CHECK(spl_prog_load_from_file("nonexistent_file_xyz.bin", NULL) != 0);
 }
 
+/* ================================================================
+ * 动态回调 / 重入 / 栈访问 API
+ * ================================================================ */
+
+static spl_vm_val_t foreign_add_cb(spl_vm_t *vm, const spl_vm_call_t *call, void *ctx) {
+    (void)vm;
+    (void)ctx;
+    if (!call || call->nargs < 2)
+        return 0;
+    return call->args[0] + call->args[1];
+}
+
+/* 线 1 动态：NCALL 的 native 无 impl_fn 时走 vm->foreign。 */
+void test_foreign_fallback(void) {
+    spl_vm_ins_t p[] = {ins(SPL_PUSH, SPL_I32, 30),  ins(SPL_PUSH, SPL_I32, 12),
+                        ins(SPL_PUSH, SPL_VOID, 0),  ins(SPL_NCALL, SPL_I32, 2),
+                        ins(SPL_RET, SPL_I32, 0)};
+    size_t len;
+    unsigned char *bin = build_binary("main", 0, p, 5, &len);
+    spl_prog_t prog;
+    spl_vm_t vm;
+    spl_vm_native_t nat[] = {{"host_add", 0, NULL}};
+    int rc = -1;
+
+    spl_vm_init(&vm);
+    if (write_temp(bin, len) == 0 && spl_prog_load_from_file(TMPFILE, &prog) == 0) {
+        for (int i = 0; i < 1; i++)
+            spl_prog_add_native(&prog, &nat[i]);
+        if (spl_vm_load_prog(&vm, &prog) == 0) {
+            spl_vm_set_foreign(&vm, foreign_add_cb, NULL);
+            if (spl_vm_prepare(&vm, "main", 0, NULL, NULL) == 0) {
+                int ret = spl_vm_run_until(&vm, 0);
+                if (ret == 1)
+                    rc = (int)vm.ret_val;
+            }
+        }
+    }
+    spl_vm_drop(&vm);
+    remove(TMPFILE);
+    free(bin);
+    TEST_CHECK(rc == 42);
+}
+
+/* 线 2：外部 -> VM 调用。 */
+void test_invoke(void) {
+    spl_vm_ins_t add_insns[] = {ins(SPL_LADDR, SPL_VOID, 0), ins(SPL_LOAD, SPL_I64, 0),
+                                ins(SPL_LADDR, SPL_VOID, 8), ins(SPL_LOAD, SPL_I64, 0),
+                                ins(SPL_ADD, SPL_I64, 0),    ins(SPL_RET, SPL_I64, 0)};
+    size_t len;
+    unsigned char *bin = build_binary("add", 2, add_insns, 6, &len);
+    spl_prog_t prog;
+    spl_vm_t vm;
+    spl_vm_val_t args[2];
+    spl_vm_call_t call;
+    int ok = 0;
+
+    spl_vm_init(&vm);
+    if (write_temp(bin, len) == 0 && spl_prog_load_from_file(TMPFILE, &prog) == 0) {
+        if (spl_vm_load_prog(&vm, &prog) == 0) {
+            args[0] = 40;
+            args[1] = 2;
+            call.name = "add";
+            call.args = args;
+            call.nargs = 2;
+            call.ret = 0;
+            ok = (spl_vm_invoke(&vm, &call) == 0) && (call.ret == 42);
+        }
+    }
+    spl_vm_drop(&vm);
+    remove(TMPFILE);
+    free(bin);
+    TEST_CHECK(ok);
+}
+
+/* 栈 / 结果访问 API 不依赖宿主指针。 */
+void test_stack_api(void) {
+    spl_vm_t vm;
+    spl_vm_init(&vm);
+    TEST_CHECK(spl_vm_stack_set(&vm, 0, 123) == 0);
+    TEST_CHECK(spl_vm_stack_get(&vm, 0) == 123);
+    TEST_CHECK(spl_vm_sp(&vm) == 0);
+    TEST_CHECK(spl_vm_fp(&vm) == 0);
+    TEST_CHECK(spl_vm_stack_get(&vm, (usize)-1) == 0);
+    spl_vm_drop(&vm);
+}
+
+/* syscall 注册 + 内存 API：NCALL vm_alloc 得到 VM 偏移，并经 mem_read/write 往返。 */
+void test_syscall_registration(void) {
+    spl_vm_ins_t p[] = {ins(SPL_PUSH, SPL_I64, 16), ins(SPL_PUSH, SPL_VOID, 0),
+                        ins(SPL_NCALL, SPL_I64, 1), ins(SPL_RET, SPL_I64, 0)};
+    size_t len;
+    unsigned char *bin = build_binary("main", 0, p, 4, &len);
+    spl_prog_t prog;
+    spl_vm_t vm;
+    spl_vm_native_t nat[] = {{"vm_alloc", 0, NULL}};
+    spl_vm_val_t off = 0;
+    int ok = 0;
+    char w[4] = {1, 2, 3, 0};
+    char r[4] = {0};
+
+    spl_vm_init(&vm);
+    if (write_temp(bin, len) == 0 && spl_prog_load_from_file(TMPFILE, &prog) == 0) {
+        for (int i = 0; i < 1; i++)
+            spl_prog_add_native(&prog, &nat[i]);
+        spl_syscall_register(&prog);
+        if (spl_vm_load_prog(&vm, &prog) == 0 && spl_vm_prepare(&vm, "main", 0, NULL, NULL) == 0) {
+            if (spl_vm_run_until(&vm, 0) == 1) {
+                off = vm.ret_val;
+                if (off != 0 && spl_vm_mem_write(&vm, off, w, 4) == 0 &&
+                    spl_vm_mem_read(&vm, off, r, 4) == 0 && memcmp(w, r, 4) == 0)
+                    ok = 1;
+            }
+        }
+    }
+    spl_vm_drop(&vm);
+    remove(TMPFILE);
+    free(bin);
+    TEST_CHECK(off != 0);
+    TEST_CHECK(ok);
+}
+
 /* ================================================================
  * Test list
  * ================================================================ */
@@ -872,6 +998,10 @@ TEST_LIST = {
     {"ld_st64", test_ld_st64},
     {"many_ops", test_many_ops},
     {"halt", test_halt},
+    {"foreign_fallback", test_foreign_fallback},
+    {"invoke", test_invoke},
+    {"stack_api", test_stack_api},
+    {"syscall_registration", test_syscall_registration},
     {"bad_magic", test_bad_magic},
     {"empty", test_empty},
     {NULL, NULL},

stage1/ir_opt.c

@@ -0,0 +1,612 @@
+/* ir_opt.c - IR 层优化 pass
+ *
+ * 通用函数内联（任意大小/形状的 callee，不再限叶子）：
+ *   - callee 体内允许 control.call（嵌套调用）、分支/循环、多个返回、unit 返回；
+ *   - 参数：克隆体内 Param 的“使用处”替换为调用实参 ref；
+ *   - 控制流：克隆体追加到调用者末尾，内部 br/jmp/label 整体 +shift；
+ *   - 返回：
+ *       * 有返回值：在调用者追加 ret 槽（MemAlloca）与常量 1；每个 Ret 改为
+ *         jmp 到“MemStore(槽, val) + jmp(join)”，join 处 MemLoad(槽) 供使用者；
+ *       * 无返回值（unit）：每个 Ret 直接 jmp 到调用点之后。
+ *   - 调用点改为 jmp 到克隆体入口；其使用者改指到 join 的 MemLoad（或 0）。
+ *   - 防环：若 callee（传递）可达 caller，则拒绝内联，保证调用图保持无环、
+ *     内联过程终止（直接/间接递归都不会被内联）。
+ *   - 迭代到不动点（无环调用图上轮数有上界）。
+ * 默认关闭（splc0 --opt 驱动），且只内联显式 `#inline` 标记的 callee。 */
+
+#include "ir_opt.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct {
+    spl_ir_t *ir;
+    spl_ir_func_ref_t caller;
+    spl_ir_func_ref_t callee;
+    spl_ir_node_ref_t shift; /* new = old + shift */
+    usize nparams;
+    spl_ir_node_ref_t *param_ref;
+    spl_ir_node_ref_t *param_arg;
+} inline_ctx_t;
+
+static spl_ir_node_t *nd(spl_ir_t *ir, spl_ir_func_ref_t fid, spl_ir_node_ref_t ref) {
+    return spl_ir_node(ir, fid, ref);
+}
+
+/* ---- 引用重写（克隆体旧 ref -> 新 ref） ---- */
+
+static spl_ir_node_ref_t rw(inline_ctx_t *c, spl_ir_node_ref_t r) {
+    if (r == 0)
+        return 0;
+    for (usize i = 0; i < c->nparams; i++)
+        if (c->param_ref[i] == r)
+            return c->param_arg[i];
+    return r + c->shift;
+}
+
+static void rw_vec(inline_ctx_t *c, spl_ir_node_ref_vec_t *v) {
+    for (usize i = 0; i < vec_size(*v); i++)
+        vec_at(*v, i) = rw(c, vec_at(*v, i));
+}
+
+static void rw_node(inline_ctx_t *c, spl_ir_node_t *n) {
+    switch (n->kind) {
+    case SPL_IR_ARITH_ADD: case SPL_IR_ARITH_SUB: case SPL_IR_ARITH_MUL:
+    case SPL_IR_ARITH_DIV: case SPL_IR_ARITH_REM: case SPL_IR_ARITH_NEG:
+    case SPL_IR_ARITH_ABS: case SPL_IR_ARITH_AND: case SPL_IR_ARITH_OR:
+    case SPL_IR_ARITH_XOR: case SPL_IR_ARITH_SHL: case SPL_IR_ARITH_SHR:
+    case SPL_IR_ARITH_NOT:
+        n->arith.left = rw(c, n->arith.left);
+        n->arith.right = rw(c, n->arith.right);
+        break;
+    case SPL_IR_CMP_EQ: case SPL_IR_CMP_NE: case SPL_IR_CMP_LT:
+    case SPL_IR_CMP_LE: case SPL_IR_CMP_GT: case SPL_IR_CMP_GE:
+        n->cmp.a = rw(c, n->cmp.a);
+        n->cmp.b = rw(c, n->cmp.b);
+        break;
+    case SPL_IR_CAST_TRUNC: case SPL_IR_CAST_ZEXT: case SPL_IR_CAST_SEXT:
+    case SPL_IR_CAST_FEXT: case SPL_IR_CAST_FTRUNC: case SPL_IR_CAST_BITCAST:
+    case SPL_IR_CAST_PTR2INT: case SPL_IR_CAST_INT2PTR: case SPL_IR_CAST_BOOL2INT:
+    case SPL_IR_CASE_INT2FLOAT: case SPL_IR_CASE_FLOAT2INT:
+        n->cast.val = rw(c, n->cast.val);
+        break;
+    case SPL_IR_MEM_ALLOCA:
+        n->mem_alloc.count = rw(c, n->mem_alloc.count);
+        break;
+    case SPL_IR_MEM_GLOBAL_ALLOC:
+        n->mem_global_alloc.const_node = rw(c, n->mem_global_alloc.const_node);
+        break;
+    case SPL_IR_MEM_LOAD:
+        n->mem_load.ptr = rw(c, n->mem_load.ptr);
+        break;
+    case SPL_IR_MEM_STORE:
+        n->mem_store.ptr = rw(c, n->mem_store.ptr);
+        n->mem_store.val = rw(c, n->mem_store.val);
+        break;
+    case SPL_IR_MEM_OFFSET:
+        n->mem_offset.ptr = rw(c, n->mem_offset.ptr);
+        n->mem_offset.offset = rw(c, n->mem_offset.offset);
+        break;
+    case SPL_IR_MEM_FIELD_PTR:
+        n->mem_field_ptr.agg = rw(c, n->mem_field_ptr.agg);
+        break;
+    case SPL_IR_MEM_COPY:
+        n->mem_copy.dst = rw(c, n->mem_copy.dst);
+        n->mem_copy.src = rw(c, n->mem_copy.src);
+        n->mem_copy.size = rw(c, n->mem_copy.size);
+        break;
+    case SPL_IR_MEM_SET:
+        n->mem_set.dst = rw(c, n->mem_set.dst);
+        n->mem_set.val = rw(c, n->mem_set.val);
+        n->mem_set.size = rw(c, n->mem_set.size);
+        break;
+    case SPL_IR_TYPE_OFFSETOF:
+        n->ir_offsetof.field_idx = rw(c, n->ir_offsetof.field_idx);
+        break;
+    case SPL_IR_AGG_CONSTRUCT:
+        rw_vec(c, &n->agg_construct.fields);
+        break;
+    case SPL_IR_AGG_EXTRACT:
+        n->agg_extract.val = rw(c, n->agg_extract.val);
+        break;
+    case SPL_IR_AGG_INSERT:
+        n->agg_insert.agg = rw(c, n->agg_insert.agg);
+        n->agg_insert.field = rw(c, n->agg_insert.field);
+        break;
+    case SPL_IR_CONTROL_SELECT:
+        n->control_select.cond = rw(c, n->control_select.cond);
+        n->control_select.true_val = rw(c, n->control_select.true_val);
+        n->control_select.false_val = rw(c, n->control_select.false_val);
+        break;
+    case SPL_IR_CONTROL_BR:
+        n->control_br.cond = rw(c, n->control_br.cond);
+        n->control_br.true_label = rw(c, n->control_br.true_label);
+        n->control_br.false_label = rw(c, n->control_br.false_label);
+        break;
+    case SPL_IR_CONTROL_JMP:
+        n->control_jmp.label = rw(c, n->control_jmp.label);
+        break;
+    case SPL_IR_CONTROL_PARAM:
+        n->control_param.idx = rw(c, n->control_param.idx);
+        break;
+    case SPL_IR_CONTROL_RET:
+        n->control_ret.val = rw(c, n->control_ret.val);
+        break;
+    case SPL_IR_CONTROL_CALL:
+        n->control_call.func = rw(c, n->control_call.func);
+        rw_vec(c, &n->control_call.params);
+        break;
+    default:
+        break;
+    }
+}
+
+/* ---- 克隆 ---- */
+
+static void clone_ref_vec(spl_ir_node_ref_vec_t *dst, const spl_ir_node_ref_vec_t *src) {
+    dst->size = 0;
+    dst->cap = 0;
+    dst->data = NULL;
+    usize n = vec_size(*src);
+    if (n == 0)
+        return;
+    spl_ir_node_ref_t *p = (spl_ir_node_ref_t *)malloc(sizeof(spl_ir_node_ref_t) * n);
+    if (!p)
+        return;
+    memcpy(p, src->data, sizeof(spl_ir_node_ref_t) * n);
+    dst->data = p;
+    dst->size = n;
+    dst->cap = n;
+}
+
+static void clone_node(spl_ir_t *ir, spl_ir_func_ref_t caller, spl_ir_node_ref_t dst_ref,
+                       const spl_ir_node_t *src) {
+    spl_ir_node_t *dst = nd(ir, caller, dst_ref);
+    memcpy(dst, src, sizeof(*dst));
+    dst->attrs.data = NULL;
+    dst->attrs.size = 0;
+    dst->attrs.cap = 0;
+    if (vec_size(src->attrs) != 0)
+        clone_ref_vec((spl_ir_node_ref_vec_t *)&dst->attrs,
+                      (const spl_ir_node_ref_vec_t *)&src->attrs);
+    if (src->kind == SPL_IR_AGG_CONSTRUCT)
+        clone_ref_vec(&dst->agg_construct.fields, &src->agg_construct.fields);
+    else if (src->kind == SPL_IR_CONTROL_CALL)
+        clone_ref_vec(&dst->control_call.params, &src->control_call.params);
+}
+
+/* ---- 调用图可达性（防环） ---- */
+
+static spl_ir_func_ref_t call_callee(spl_ir_t *ir, spl_ir_func_ref_t fid, spl_ir_node_t *call) {
+    spl_ir_node_t *fn = nd(ir, fid, call->control_call.func);
+    if (!fn || fn->kind != SPL_IR_TYPE_CONST)
+        return 0;
+    return fn->type_const.fn;
+}
+
+static bool reaches(spl_ir_t *ir, spl_ir_func_ref_t from, spl_ir_func_ref_t target,
+                    unsigned char *mark) {
+    if (from == 0)
+        return false;
+    if (from == target)
+        return true;
+    if (mark[from])
+        return false;
+    mark[from] = 1;
+    spl_ir_func_t *f = spl_ir_func(ir, from);
+    if (!f)
+        return false;
+    usize n = vec_size(f->nodes);
+    for (usize i = 1; i < n; i++) {
+        spl_ir_node_t *x = nd(ir, from, i);
+        if (x && x->kind == SPL_IR_CONTROL_CALL) {
+            spl_ir_func_ref_t c = call_callee(ir, from, x);
+            if (c != 0 && reaches(ir, c, target, mark))
+                return true;
+        }
+    }
+    return false;
+}
+
+/* 从 from 的直接被调者出发是否能到达 target（用于判断 from 自身是否递归/自可达）。 */
+static bool reaches_succ(spl_ir_t *ir, spl_ir_func_ref_t from, spl_ir_func_ref_t target,
+                         unsigned char *mark) {
+    spl_ir_func_t *f = spl_ir_func(ir, from);
+    if (!f)
+        return false;
+    usize n = vec_size(f->nodes);
+    for (usize i = 1; i < n; i++) {
+        spl_ir_node_t *x = nd(ir, from, i);
+        if (x && x->kind == SPL_IR_CONTROL_CALL) {
+            spl_ir_func_ref_t c = call_callee(ir, from, x);
+            if (c != 0 && reaches(ir, c, target, mark))
+                return true;
+        }
+    }
+    return false;
+}
+
+/* ---- 内联一个调用点 ---- */
+
+typedef struct {
+    spl_ir_node_ref_t clone_ref;
+    spl_ir_node_ref_t val;
+} ret_rec_t;
+
+static bool param_index(spl_ir_t *ir, spl_ir_func_ref_t fid, spl_ir_node_t *p, usize *out) {
+    spl_ir_node_t *idx = nd(ir, fid, p->control_param.idx);
+    if (!idx || idx->kind != SPL_IR_TYPE_CONST)
+        return false;
+    *out = idx->type_const.int_lit;
+    return true;
+}
+
+static spl_ir_node_ref_t find_const_src(spl_ir_t *ir, spl_ir_func_ref_t fid) {
+    spl_ir_func_t *f = spl_ir_func(ir, fid);
+    if (!f)
+        return 0;
+    for (usize i = 1; i < vec_size(f->nodes); i++) {
+        spl_ir_node_t *x = nd(ir, fid, i);
+        if (x && x->kind == SPL_IR_TYPE_CONST)
+            return i;
+    }
+    return 0;
+}
+
+static bool try_inline(spl_ir_t *ir, spl_ir_func_ref_t caller, spl_ir_node_ref_t ci,
+                       spl_ir_func_ref_t callee) {
+    spl_ir_func_t *cf = spl_ir_func(ir, caller);
+    spl_ir_func_t *calf = spl_ir_func(ir, callee);
+    if (!cf || !calf || callee == caller)
+        return false;
+
+    spl_ir_node_t *call = nd(ir, caller, ci);
+    if (!call || call->kind != SPL_IR_CONTROL_CALL)
+        return false;
+
+    usize orig_len = vec_size(cf->nodes);
+    if (ci + 1 >= orig_len)
+        return false;
+
+    usize nargs = vec_size(call->control_call.params);
+
+    /* 统计参数与返回，分配动态映射。 */
+    usize cnodes = vec_size(calf->nodes);
+    usize in_params = 0;
+    usize in_rets = 0;
+    for (usize i = 1; i < cnodes; i++) {
+        spl_ir_node_t *x = nd(ir, callee, i);
+        if (!x)
+            return false;
+        if (x->kind == SPL_IR_CONTROL_PARAM)
+            in_params++;
+        else if (x->kind == SPL_IR_CONTROL_RET)
+            in_rets++;
+    }
+    if (in_rets == 0 || in_params != nargs)
+        return false;
+
+    inline_ctx_t c;
+    memset(&c, 0, sizeof(c));
+    c.ir = ir;
+    c.caller = caller;
+    c.callee = callee;
+    c.nparams = in_params;
+    c.param_ref = (spl_ir_node_ref_t *)malloc(sizeof(spl_ir_node_ref_t) * (in_params ? in_params : 1));
+    c.param_arg = (spl_ir_node_ref_t *)malloc(sizeof(spl_ir_node_ref_t) * (in_params ? in_params : 1));
+    ret_rec_t *recs = (ret_rec_t *)malloc(sizeof(ret_rec_t) * (in_rets ? in_rets : 1));
+    if (!c.param_ref || !c.param_arg || !recs) {
+        free(c.param_ref);
+        free(c.param_arg);
+        free(recs);
+        return false;
+    }
+
+    spl_type_id_t ret_tid = call->control_call.tid;
+
+    /* 参数映射（旧 ref -> 实参 ref）。 */
+    usize pi = 0;
+    for (usize i = 1; i < cnodes; i++) {
+        spl_ir_node_t *x = nd(ir, callee, i);
+        if (x && x->kind == SPL_IR_CONTROL_PARAM) {
+            usize idx = 0;
+            if (!param_index(ir, callee, x, &idx) || idx >= nargs) {
+                free(c.param_ref);
+                free(c.param_arg);
+                free(recs);
+                return false;
+            }
+            c.param_ref[pi] = i;
+            c.param_arg[pi] = vec_at(call->control_call.params, idx);
+            pi++;
+        }
+    }
+
+    bool has_val = false;
+    for (usize i = 1; i < cnodes; i++) {
+        spl_ir_node_t *x = nd(ir, callee, i);
+        if (x && x->kind == SPL_IR_CONTROL_RET && x->control_ret.val != 0)
+            has_val = true;
+    }
+    spl_ir_node_ref_t const_src = find_const_src(ir, callee);
+    if (has_val && const_src == 0) {
+        free(c.param_ref);
+        free(c.param_arg);
+        free(recs);
+        return false;
+    }
+
+    /* 释放调用点原 params（随后 ci 改为 jmp） */
+    vec_free(call->control_call.params);
+
+    /* 克隆体入口前置：常量 1 + ret 槽 */
+    spl_ir_node_ref_t body_entry = 0;
+    spl_ir_node_ref_t slot_ref = 0;
+    if (has_val) {
+        spl_ir_node_ref_t c_ref = spl_ir_alloc_node(ir, caller);
+        clone_node(ir, caller, c_ref, nd(ir, callee, const_src));
+        spl_ir_node_t *cn = nd(ir, caller, c_ref);
+        cn->kind = SPL_IR_TYPE_CONST;
+        cn->type_const.int_lit = 1;
+
+        slot_ref = spl_ir_alloc_node(ir, caller);
+        spl_ir_node_t *sn = nd(ir, caller, slot_ref);
+        memset(sn, 0, sizeof(*sn));
+        sn->kind = SPL_IR_MEM_ALLOCA;
+        sn->mem_alloc.tid = ret_tid;
+        sn->mem_alloc.count = c_ref;
+
+        body_entry = c_ref;
+    }
+
+    c.shift = vec_size(cf->nodes) - 1;
+    if (!has_val)
+        body_entry = vec_size(cf->nodes);
+
+    /* 克隆体 */
+    usize nrec = 0;
+    for (usize i = 1; i < cnodes; i++) {
+        spl_ir_node_ref_t dst_ref = spl_ir_alloc_node(ir, caller);
+        if (dst_ref == 0) {
+            free(c.param_ref);
+            free(c.param_arg);
+            free(recs);
+            return false;
+        }
+        spl_ir_node_t *src = nd(ir, callee, i);
+        clone_node(ir, caller, dst_ref, src);
+        rw_node(&c, nd(ir, caller, dst_ref));
+        spl_ir_node_t *x = nd(ir, caller, dst_ref);
+        /* 克隆进来的 Param 使用处已替换为实参，节点本身不能留在调用者里
+         * 改变其参数个数；退化为无害常量。 */
+        if (src->kind == SPL_IR_CONTROL_PARAM) {
+            x->kind = SPL_IR_TYPE_CONST;
+            x->type_const.tid = 0;
+            x->type_const.int_lit = 0;
+            continue;
+        }
+        if (x->kind == SPL_IR_CONTROL_RET) {
+            recs[nrec].clone_ref = dst_ref;
+            recs[nrec].val = x->control_ret.val;
+            nrec++;
+            x->kind = SPL_IR_CONTROL_JMP;
+            x->control_jmp.label = 0; /* 稍后回填 */
+        }
+    }
+
+    spl_ir_node_ref_t ret_new = 0;
+    if (has_val) {
+        spl_ir_node_ref_t join = spl_ir_alloc_node(ir, caller);
+        spl_ir_node_t *jn = nd(ir, caller, join);
+        memset(jn, 0, sizeof(*jn));
+        jn->kind = SPL_IR_MEM_LOAD;
+        jn->mem_load.tid = ret_tid;
+        jn->mem_load.ptr = slot_ref;
+
+        /* join 之后跳回调用点的后继（原代码此处靠 fallthrough）。 */
+        spl_ir_node_ref_t jc = spl_ir_alloc_node(ir, caller);
+        spl_ir_node_t *jcn = nd(ir, caller, jc);
+        memset(jcn, 0, sizeof(*jcn));
+        jcn->kind = SPL_IR_CONTROL_JMP;
+        jcn->control_jmp.label = ci + 1;
+
+        for (usize k = 0; k < nrec; k++) {
+            spl_ir_node_ref_t st = spl_ir_alloc_node(ir, caller);
+            spl_ir_node_t *stn = nd(ir, caller, st);
+            memset(stn, 0, sizeof(*stn));
+            stn->kind = SPL_IR_MEM_STORE;
+            stn->mem_store.tid = ret_tid;
+            stn->mem_store.ptr = slot_ref;
+            stn->mem_store.val = recs[k].val;
+
+            spl_ir_node_ref_t jr = spl_ir_alloc_node(ir, caller);
+            spl_ir_node_t *jrn = nd(ir, caller, jr);
+            memset(jrn, 0, sizeof(*jrn));
+            jrn->kind = SPL_IR_CONTROL_JMP;
+            jrn->control_jmp.label = join;
+
+            spl_ir_node_t *rn = nd(ir, caller, recs[k].clone_ref);
+            rn->control_jmp.label = st;
+        }
+        ret_new = join;
+    } else {
+        for (usize k = 0; k < nrec; k++) {
+            spl_ir_node_t *rn = nd(ir, caller, recs[k].clone_ref);
+            rn->control_jmp.label = ci + 1;
+        }
+    }
+
+    /* 调用点 -> jmp 到克隆体入口 */
+    call = nd(ir, caller, ci);
+    call->kind = SPL_IR_CONTROL_JMP;
+    call->control_jmp.label = body_entry;
+
+    /* 使用者替换：只把等于 ci 的引用改为 ret_new（不动其它 ref） */
+    for (usize j = 1; j < orig_len; j++) {
+        spl_ir_node_t *x = nd(ir, caller, j);
+        if (!x)
+            continue;
+        switch (x->kind) {
+        case SPL_IR_ARITH_ADD: case SPL_IR_ARITH_SUB: case SPL_IR_ARITH_MUL:
+        case SPL_IR_ARITH_DIV: case SPL_IR_ARITH_REM: case SPL_IR_ARITH_NEG:
+        case SPL_IR_ARITH_ABS: case SPL_IR_ARITH_AND: case SPL_IR_ARITH_OR:
+        case SPL_IR_ARITH_XOR: case SPL_IR_ARITH_SHL: case SPL_IR_ARITH_SHR:
+        case SPL_IR_ARITH_NOT:
+            if (x->arith.left == ci) x->arith.left = ret_new;
+            if (x->arith.right == ci) x->arith.right = ret_new;
+            break;
+        case SPL_IR_CMP_EQ: case SPL_IR_CMP_NE: case SPL_IR_CMP_LT:
+        case SPL_IR_CMP_LE: case SPL_IR_CMP_GT: case SPL_IR_CMP_GE:
+            if (x->cmp.a == ci) x->cmp.a = ret_new;
+            if (x->cmp.b == ci) x->cmp.b = ret_new;
+            break;
+        case SPL_IR_CAST_TRUNC: case SPL_IR_CAST_ZEXT: case SPL_IR_CAST_SEXT:
+        case SPL_IR_CAST_FEXT: case SPL_IR_CAST_FTRUNC: case SPL_IR_CAST_BITCAST:
+        case SPL_IR_CAST_PTR2INT: case SPL_IR_CAST_INT2PTR: case SPL_IR_CAST_BOOL2INT:
+        case SPL_IR_CASE_INT2FLOAT: case SPL_IR_CASE_FLOAT2INT:
+            if (x->cast.val == ci) x->cast.val = ret_new;
+            break;
+        case SPL_IR_MEM_ALLOCA:
+            if (x->mem_alloc.count == ci) x->mem_alloc.count = ret_new;
+            break;
+        case SPL_IR_MEM_GLOBAL_ALLOC:
+            if (x->mem_global_alloc.const_node == ci) x->mem_global_alloc.const_node = ret_new;
+            break;
+        case SPL_IR_MEM_LOAD:
+            if (x->mem_load.ptr == ci) x->mem_load.ptr = ret_new;
+            break;
+        case SPL_IR_MEM_STORE:
+            if (x->mem_store.ptr == ci) x->mem_store.ptr = ret_new;
+            if (x->mem_store.val == ci) x->mem_store.val = ret_new;
+            break;
+        case SPL_IR_MEM_OFFSET:
+            if (x->mem_offset.ptr == ci) x->mem_offset.ptr = ret_new;
+            if (x->mem_offset.offset == ci) x->mem_offset.offset = ret_new;
+            break;
+        case SPL_IR_MEM_FIELD_PTR:
+            if (x->mem_field_ptr.agg == ci) x->mem_field_ptr.agg = ret_new;
+            break;
+        case SPL_IR_MEM_COPY:
+            if (x->mem_copy.dst == ci) x->mem_copy.dst = ret_new;
+            if (x->mem_copy.src == ci) x->mem_copy.src = ret_new;
+            if (x->mem_copy.size == ci) x->mem_copy.size = ret_new;
+            break;
+        case SPL_IR_MEM_SET:
+            if (x->mem_set.dst == ci) x->mem_set.dst = ret_new;
+            if (x->mem_set.val == ci) x->mem_set.val = ret_new;
+            if (x->mem_set.size == ci) x->mem_set.size = ret_new;
+            break;
+        case SPL_IR_TYPE_OFFSETOF:
+            if (x->ir_offsetof.field_idx == ci) x->ir_offsetof.field_idx = ret_new;
+            break;
+        case SPL_IR_AGG_CONSTRUCT:
+            for (usize k = 0; k < vec_size(x->agg_construct.fields); k++)
+                if (vec_at(x->agg_construct.fields, k) == ci)
+                    vec_at(x->agg_construct.fields, k) = ret_new;
+            break;
+        case SPL_IR_AGG_EXTRACT:
+            if (x->agg_extract.val == ci) x->agg_extract.val = ret_new;
+            break;
+        case SPL_IR_AGG_INSERT:
+            if (x->agg_insert.agg == ci) x->agg_insert.agg = ret_new;
+            if (x->agg_insert.field == ci) x->agg_insert.field = ret_new;
+            break;
+        case SPL_IR_CONTROL_SELECT:
+            if (x->control_select.cond == ci) x->control_select.cond = ret_new;
+            if (x->control_select.true_val == ci) x->control_select.true_val = ret_new;
+            if (x->control_select.false_val == ci) x->control_select.false_val = ret_new;
+            break;
+        case SPL_IR_CONTROL_BR:
+            if (x->control_br.cond == ci) x->control_br.cond = ret_new;
+            break;
+        case SPL_IR_CONTROL_CALL:
+            if (x->control_call.func == ci) x->control_call.func = ret_new;
+            for (usize k = 0; k < vec_size(x->control_call.params); k++)
+                if (vec_at(x->control_call.params, k) == ci)
+                    vec_at(x->control_call.params, k) = ret_new;
+            break;
+        case SPL_IR_CONTROL_PARAM:
+            if (x->control_param.idx == ci) x->control_param.idx = ret_new;
+            break;
+        case SPL_IR_CONTROL_RET:
+            if (x->control_ret.val == ci) x->control_ret.val = ret_new;
+            break;
+        default:
+            break;
+        }
+    }
+
+    free(c.param_ref);
+    free(c.param_arg);
+    free(recs);
+    return true;
+}
+
+static bool func_has_attr(const spl_attr_t *attr, const spl_ir_func_t *f, const char *name);
+
+static int opt_function(spl_ir_t *ir, spl_ir_func_ref_t fid, const spl_attr_t *attr,
+                        unsigned char *mark, usize nfuncs) {
+    spl_ir_func_t *f = spl_ir_func(ir, fid);
+    if (!f)
+        return 0;
+    int done = 0;
+    usize orig = vec_size(f->nodes);
+    for (usize ci = 1; ci < orig; ci++) {
+        spl_ir_node_t *x = nd(ir, fid, ci);
+        if (!x || x->kind != SPL_IR_CONTROL_CALL)
+            continue;
+        spl_ir_func_ref_t callee = call_callee(ir, fid, x);
+        if (callee == 0 || callee == fid || callee >= nfuncs)
+            continue;
+        spl_ir_func_t *calf = spl_ir_func(ir, callee);
+        if (!func_has_attr(attr, calf, "inline") || func_has_attr(attr, calf, "noinline"))
+            continue;
+        /* extern 是占位体，绝不能内联。 */
+        if (func_has_attr(attr, calf, "extern"))
+            continue;
+        /* 防环：callee 传递可达 caller 时拒绝（覆盖直接/间接互递归）。 */
+        memset(mark, 0, nfuncs);
+        if (reaches(ir, callee, fid, mark))
+            continue;
+        /* 防爆炸：callee 自身递归时拒绝（否则不动点会反复内联其内部调用）。 */
+        memset(mark, 0, nfuncs);
+        if (reaches_succ(ir, callee, callee, mark))
+            continue;
+        if (try_inline(ir, fid, ci, callee))
+            done++;
+    }
+    return done;
+}
+
+/* 是否带有指定名字的属性/tag。 */
+static bool func_has_attr(const spl_attr_t *attr, const spl_ir_func_t *f, const char *name) {
+    if (!attr || !f)
+        return false;
+    for (usize i = 0; i < vec_size(f->attrs); ++i) {
+        spl_attr_node_t *a = spl_attr_node((spl_attr_t *)attr, vec_at(f->attrs, i));
+        if (!a || !a->info)
+            continue;
+        if (strcmp(a->info->name, name) == 0)
+            return true;
+    }
+    return false;
+}
+
+void spl_ir_opt(spl_ir_t *ir, const spl_attr_t *attr) {
+    if (!ir)
+        return;
+    usize nfuncs = vec_size(ir->funcs);
+    unsigned char *mark = (unsigned char *)malloc(nfuncs ? nfuncs : 1);
+    if (!mark)
+        return;
+    /* 无环调用图上，最多 nfuncs 轮即可到不动点。 */
+    for (usize pass = 0; pass <= nfuncs; pass++) {
+        int total = 0;
+        usize n = vec_size(ir->funcs);
+        for (spl_ir_func_ref_t fid = 1; fid < n && fid < nfuncs; fid++)
+            total += opt_function(ir, fid, attr, mark, nfuncs);
+        if (total == 0)
+            break;
+    }
+    free(mark);
+}

stage1/ir_opt.h

@@ -0,0 +1,11 @@
+#ifndef __IR_OPT_H__
+#define __IR_OPT_H__
+
+/* IR 层优化 pass：输入输出都是 spl_ir_t（节点 arena），纯函数式、可开关。
+ * 由 splc0 --opt 在 ast2ir 之后、ir2vm 之前调用。 */
+
+#include "spl_ir.h"
+
+void spl_ir_opt(spl_ir_t *ir, const spl_attr_t *attr);
+
+#endif /* __IR_OPT_H__ */

stage1/spl_ast.c

@@ -424,6 +424,11 @@ static void dump_node(spl_ast_t *ast, spl_ast_node_ref_t node_ref, dump_stack_t
             dump_node(ast, node->pattern_field.pattern, stack, true);
         break;
 
+    case SPL_AST_PATTERN_REF:
+        if (node->pattern_ref.pat)
+            dump_node(ast, node->pattern_ref.pat, stack, true);
+        break;
+
     default:
         break;
     }

stage1/spl_ast.h

@@ -73,7 +73,8 @@
     X(SPL_AST_PATTERN_TUPLE,        V0, pattern_tuple)                \
     X(SPL_AST_PATTERN_LIST,         V0, pattern_list)                 \
     X(SPL_AST_PATTERN_AGGREGATE,    V0, pattern_aggregate)            \
-    X(SPL_AST_PATTERN_FIELD,        V0, pattern_field)
+    X(SPL_AST_PATTERN_FIELD,        V0, pattern_field)                \
+    X(SPL_AST_PATTERN_REF,          V0, pattern_ref)
 /* clang-format on */
 
 typedef enum {
@@ -452,6 +453,10 @@ struct spl_ast_node {
             const char *name;
             spl_ast_node_ref_t pattern;
         } pattern_field;
+
+        struct {
+            spl_ast_node_ref_t pat;
+        } pattern_ref;
     };
 };
 

stage1/spl_ast2ir.c

@@ -51,7 +51,8 @@ static void emit_deferred_until(spl_ast2ir_t *a, usize base) {
 static void emit_decl(spl_ast2ir_t *a, spl_ast_node_ref_t ref);
 static spl_ir_node_ref_t emit_var_decl(spl_ast2ir_t *a, spl_ast_node_t *n);
 static void emit_pattern_bind(spl_ast2ir_t *a, spl_ast_node_ref_t pat_ref,
-                              spl_ir_node_ref_t src_ptr, spl_type_id_t tid);
+                              spl_ir_node_ref_t src_ptr, spl_type_id_t tid, int place_mode);
+static int pattern_has_ref(spl_ast2ir_t *a, spl_ast_node_ref_t pat_ref);
 static spl_ir_node_ref_t emit_match_check(spl_ast2ir_t *a, spl_ast_node_ref_t pat_ref,
                                           spl_type_id_t scrut_ir, spl_ir_node_ref_t scrut_slot);
 
@@ -140,14 +141,52 @@ static spl_ir_node_ref_t emit_zero_value(spl_ast2ir_t *a, spl_type_id_t tid) {
     }
 }
 
+/* 判断 pattern 是否包含 `&` 引用绑定（PATTERN_REF）。 */
+static int pattern_has_ref(spl_ast2ir_t *a, spl_ast_node_ref_t pat_ref) {
+    if (!pat_ref)
+        return 0;
+    spl_ast_node_t *pat = spl_ast_node(a->ast, pat_ref);
+    if (!pat)
+        return 0;
+    switch (pat->kind) {
+    case SPL_AST_PATTERN_REF:
+        return 1;
+    case SPL_AST_PATTERN_LIST:
+        for (usize i = 0; i < vec_size(pat->pattern_list.patterns); ++i)
+            if (pattern_has_ref(a, vec_at(pat->pattern_list.patterns, i)))
+                return 1;
+        return 0;
+    case SPL_AST_PATTERN_TUPLE:
+        for (usize i = 0; i < vec_size(pat->pattern_tuple.patterns); ++i)
+            if (pattern_has_ref(a, vec_at(pat->pattern_tuple.patterns, i)))
+                return 1;
+        return 0;
+    case SPL_AST_PATTERN_DOT:
+        return pattern_has_ref(a, pat->pattern_dot.sub_pattern);
+    case SPL_AST_PATTERN_AGGREGATE:
+        for (usize i = 0; i < vec_size(pat->pattern_aggregate.fields); ++i) {
+            spl_ast_node_t *f =
+                spl_ast_node(a->ast, vec_at(pat->pattern_aggregate.fields, i));
+            if (f && f->kind == SPL_AST_PATTERN_FIELD &&
+                pattern_has_ref(a, f->pattern_field.pattern))
+                return 1;
+        }
+        return 0;
+    default:
+        return 0;
+    }
+}
+
 /* 把 pattern 里的 ident 绑到 src_ptr 指向内存的对应位置。
-   - PATTERN_IDENT: def2ir_map[def_id] = src_ptr
+   - PATTERN_IDENT: def2ir_map[def_id] = src_ptr（place_mode=0，值绑定别名源）；
+     place_mode=1 时强制拷贝到新 slot（源为真实左值，值绑定必须拷贝）。
+   - PATTERN_REF:   src_ptr 是该子位置的地址；分配 *T slot 存该地址，内层名绑到 slot。
    - PATTERN_DOT:   src_ptr 指向 enum，payload 在 mem_field(tid, src_ptr, vidx+1)
    - PATTERN_TUPLE / PATTERN_AGGREGATE: 递归 mem_field
    UB 语义：不做 tag 检查，调用者保证变体正确。
 */
 static void emit_pattern_bind(spl_ast2ir_t *a, spl_ast_node_ref_t pat_ref,
-                              spl_ir_node_ref_t src_ptr, spl_type_id_t tid) {
+                              spl_ir_node_ref_t src_ptr, spl_type_id_t tid, int place_mode) {
     if (!pat_ref || !src_ptr)
         return;
     spl_ast_node_t *pat = spl_ast_node(a->ast, pat_ref);
@@ -156,8 +195,30 @@ static void emit_pattern_bind(spl_ast2ir_t *a, spl_ast_node_ref_t pat_ref,
 
     switch (pat->kind) {
     case SPL_AST_PATTERN_IDENT: {
-        if (pat->resolved_def_id)
+        if (!pat->resolved_def_id)
+            return;
+        if (place_mode) {
+            spl_ir_node_ref_t slot =
+                spl_ir_builder_mem_alloca(a->ir, tid, const_usize(a, 1));
+            spl_ir_node_ref_t v = spl_ir_builder_mem_load(a->ir, tid, src_ptr);
+            spl_ir_builder_mem_store(a->ir, tid, slot, v);
+            map_put(a->def2ir_map, pat->resolved_def_id, slot);
+        } else {
             map_put(a->def2ir_map, pat->resolved_def_id, src_ptr);
+        }
+        return;
+    }
+
+    case SPL_AST_PATTERN_REF: {
+        spl_ast_node_ref_t inner = pat->pattern_ref.pat;
+        spl_ast_node_t *in = spl_ast_node(a->ast, inner);
+        spl_type_id_t ptr_tid = in ? node_ir(a, in) : 0;
+        if (!ptr_tid)
+            ptr_tid = spl_type_builder_ptr(&a->sema->type->ir, tid);
+        spl_ir_node_ref_t slot =
+            spl_ir_builder_mem_alloca(a->ir, ptr_tid, const_usize(a, 1));
+        spl_ir_builder_mem_store(a->ir, ptr_tid, slot, src_ptr);
+        emit_pattern_bind(a, inner, slot, ptr_tid, 0);
         return;
     }
 
@@ -174,7 +235,7 @@ static void emit_pattern_bind(spl_ast2ir_t *a, spl_ast_node_ref_t pat_ref,
 
     case SPL_AST_PATTERN_LIST:
         for (usize i = 0; i < vec_size(pat->pattern_list.patterns); ++i)
-            emit_pattern_bind(a, vec_at(pat->pattern_list.patterns, i), src_ptr, tid);
+            emit_pattern_bind(a, vec_at(pat->pattern_list.patterns, i), src_ptr, tid, place_mode);
         return;
 
     case SPL_AST_PATTERN_TUPLE: {
@@ -188,7 +249,7 @@ static void emit_pattern_bind(spl_ast2ir_t *a, spl_ast_node_ref_t pat_ref,
         for (usize i = 0; i < n; ++i) {
             spl_type_id_t ft = vec_at(tn->agg_type.variants, i).type_id;
             spl_ir_node_ref_t fp = spl_ir_builder_mem_field(a->ir, tid, src_ptr, i);
-            emit_pattern_bind(a, vec_at(pat->pattern_tuple.patterns, i), fp, ft);
+            emit_pattern_bind(a, vec_at(pat->pattern_tuple.patterns, i), fp, ft, place_mode);
         }
         return;
     }
@@ -206,7 +267,7 @@ static void emit_pattern_bind(spl_ast2ir_t *a, spl_ast_node_ref_t pat_ref,
         spl_type_id_t payload_ir = vec_at(tn->agg_type.variants, vidx).type_id;
         spl_ir_node_ref_t pptr = spl_ir_builder_mem_field(a->ir, tid, src_ptr, vidx + 1);
         if (pat->pattern_dot.sub_pattern)
-            emit_pattern_bind(a, pat->pattern_dot.sub_pattern, pptr, payload_ir);
+            emit_pattern_bind(a, pat->pattern_dot.sub_pattern, pptr, payload_ir, place_mode);
         return;
     }
 
@@ -224,7 +285,7 @@ static void emit_pattern_bind(spl_ast2ir_t *a, spl_ast_node_ref_t pat_ref,
             spl_type_id_t ft = vec_at(tn->agg_type.variants, idx).type_id;
             spl_ir_node_ref_t fp = spl_ir_builder_mem_field(a->ir, tid, src_ptr, idx);
             if (f->pattern_field.pattern)
-                emit_pattern_bind(a, f->pattern_field.pattern, fp, ft);
+                emit_pattern_bind(a, f->pattern_field.pattern, fp, ft, place_mode);
         }
         return;
     }
@@ -297,12 +358,32 @@ static spl_ir_node_ref_t emit_match_check(spl_ast2ir_t *a, spl_ast_node_ref_t pa
 }
 
 /* 分配 slot → store init 值 → bind pattern。
-   返回指向变量内存的指针（*tid），调用者可用于读取初值。 */
+   返回指向变量内存的指针（*tid），调用者可用于读取初值。
+   若 pattern 含 `&` 引用绑定：源必须是可寻址左值，直接在源 place 上绑定
+   （值绑定拷贝子值，引用绑定取子位置地址），返回该 place。 */
 static spl_ir_node_ref_t emit_var_decl(spl_ast2ir_t *a, spl_ast_node_t *n) {
     spl_type_id_t var_ir = node_ir(a, n);
     if (!var_ir)
         return 0;
 
+    spl_ast_node_ref_t pat_ref = n->var_const_decl.pattern;
+    if (pattern_has_ref(a, pat_ref)) {
+        if (!n->var_const_decl.init_expr) {
+            spl_diag_error(a->diag, SPL_DIAG_KIND_NO_LVALUE, &n->dbg,
+                           "reference binding requires an initialized place");
+            return 0;
+        }
+        spl_ir_node_ref_t place = emit_lvalue(a, n->var_const_decl.init_expr);
+        if (!place) {
+            spl_ast_node_t *in = spl_ast_node(a->ast, n->var_const_decl.init_expr);
+            spl_diag_error(a->diag, SPL_DIAG_KIND_NO_LVALUE, in ? &in->dbg : &n->dbg,
+                           "cannot bind by reference: initializer is not an lvalue");
+            return 0;
+        }
+        emit_pattern_bind(a, pat_ref, place, var_ir, 1);
+        return place;
+    }
+
     spl_ir_node_ref_t slot = spl_ir_builder_mem_alloca(a->ir, var_ir, const_usize(a, 1));
 
     if (n->var_const_decl.init_expr) {
@@ -311,7 +392,7 @@ static spl_ir_node_ref_t emit_var_decl(spl_ast2ir_t *a, spl_ast_node_t *n) {
             spl_ir_builder_mem_store(a->ir, var_ir, slot, v);
     }
 
-    emit_pattern_bind(a, n->var_const_decl.pattern, slot, var_ir);
+    emit_pattern_bind(a, pat_ref, slot, var_ir, 0);
     return slot;
 }
 
@@ -1396,12 +1477,32 @@ static spl_ir_node_ref_t emit_expr_raw(spl_ast2ir_t *a, spl_ast_node_ref_t ref)
         if (!matched_ir)
             return 0;
 
-        spl_ir_node_ref_t scrut_slot =
+        spl_ir_node_ref_t scrut_slot = 0;
-            spl_ir_builder_mem_alloca(a->ir, matched_ir, const_usize(a, 1));
+        int matched_place_mode = 0;
+        for (usize i = 0; i < vec_size(n->match_expr.arms); ++i) {
+            spl_ast_node_t *arm = spl_ast_node(a->ast, vec_at(n->match_expr.arms, i));
+            if (arm && arm->kind == SPL_AST_MATCH_ARM &&
+                pattern_has_ref(a, arm->match_arm.pattern)) {
+                matched_place_mode = 1;
+                break;
+            }
+        }
+
+        if (matched_place_mode) {
+            scrut_slot = emit_lvalue(a, matched_ref);
+            if (!scrut_slot) {
+                spl_diag_error(a->diag, SPL_DIAG_KIND_NO_LVALUE,
+                               matched_node ? &matched_node->dbg : &n->dbg,
+                               "cannot bind by reference: matched value is not an lvalue");
+                return 0;
+            }
+        } else {
+            scrut_slot = spl_ir_builder_mem_alloca(a->ir, matched_ir, const_usize(a, 1));
             spl_ir_node_ref_t scrut_val = emit_expr(a, matched_ref);
             if (!scrut_val)
                 return 0;
             spl_ir_builder_mem_store(a->ir, matched_ir, scrut_slot, scrut_val);
+        }
 
         usize narms = vec_size(n->match_expr.arms);
         spl_ir_node_ref_vec_t arm_branches;
@@ -1448,7 +1549,8 @@ static spl_ir_node_ref_t emit_expr_raw(spl_ast2ir_t *a, spl_ast_node_ref_t ref)
 
             spl_ast_node_t *arm = spl_ast_node(a->ast, vec_at(n->match_expr.arms, i));
             if (arm && arm->kind == SPL_AST_MATCH_ARM) {
-                emit_pattern_bind(a, arm->match_arm.pattern, scrut_slot, matched_ir);
+                emit_pattern_bind(a, arm->match_arm.pattern, scrut_slot, matched_ir,
+                                  matched_place_mode);
                 if (arm->match_arm.body)
                     emit_expr(a, arm->match_arm.body);
             }

stage1/spl_ir2vm.c

@@ -344,6 +344,13 @@ typedef struct {
     frame_layout_t frame;
     VEC(usize) node_ip;
     fix_vec_t *fixups;
+    /* 块内栈化（opt） */
+    int opt;
+    uint8_t *stk_loc;  /* per node: 1 = 值当前在操作数栈上 */
+    usize *stk_pos;    /* 在虚拟栈中的位置 */
+    usize *use_left;   /* 剩余使用次数 */
+    usize *at_pos;     /* 每个栈位置对应的 node ref */
+    usize tracked;     /* 当前栈上被跟踪的值个数 */
 } cgen_t;
 
 static void emit(cgen_t *cg, uint8_t op, uint8_t ty, spl_vm_val_t imm) {
@@ -378,6 +385,240 @@ static void cg_store_at(cgen_t *cg, usize addr, uint8_t k) {
     CG_STORE(cg, k);
 }
 
+/* ---------- 块内栈化（opt）辅助 ---------- */
+
+static uint8_t node_result_kind(cgen_t *cg, usize ref) {
+    const spl_ir_node_t *n = &vec_at(cg->irf->nodes, ref);
+    return vm_kind_of(cg->ctx, ir_result_tid(cg->ctx, n));
+}
+
+static bool node_stackable(cgen_t *cg, const spl_ir_node_t *n) {
+    switch (n->kind) {
+    case SPL_IR_ARITH_ADD:
+    case SPL_IR_ARITH_SUB:
+    case SPL_IR_ARITH_MUL:
+    case SPL_IR_ARITH_DIV:
+    case SPL_IR_ARITH_REM:
+    case SPL_IR_ARITH_NEG:
+    case SPL_IR_ARITH_AND:
+    case SPL_IR_ARITH_OR:
+    case SPL_IR_ARITH_XOR:
+    case SPL_IR_ARITH_SHL:
+    case SPL_IR_ARITH_SHR:
+    case SPL_IR_ARITH_NOT:
+    case SPL_IR_CMP_EQ:
+    case SPL_IR_CMP_NE:
+    case SPL_IR_CMP_LT:
+    case SPL_IR_CMP_LE:
+    case SPL_IR_CMP_GT:
+    case SPL_IR_CMP_GE:
+    case SPL_IR_CAST_TRUNC:
+    case SPL_IR_CAST_ZEXT:
+    case SPL_IR_CAST_SEXT:
+    case SPL_IR_CAST_FEXT:
+    case SPL_IR_CAST_FTRUNC:
+    case SPL_IR_CAST_BITCAST:
+    case SPL_IR_CAST_PTR2INT:
+    case SPL_IR_CAST_INT2PTR:
+    case SPL_IR_CAST_BOOL2INT:
+    case SPL_IR_CASE_INT2FLOAT:
+    case SPL_IR_CASE_FLOAT2INT:
+    case SPL_IR_TYPE_CONST: {
+        spl_type_node_t *tn = spl_type_node(cg->ctx->type, n->type_const.tid);
+        return tn && tn->kind != SPL_TYPE_UNIT;
+    }
+    case SPL_IR_TYPE_BITSIZEOF:
+    case SPL_IR_TYPE_SIZEOF:
+    case SPL_IR_TYPE_ALIGNOF:
+    case SPL_IR_TYPE_OFFSETOF:
+    case SPL_IR_TYPE_FIELD_COUNT:
+    case SPL_IR_MEM_OFFSET:
+    case SPL_IR_MEM_FIELD_PTR:
+        return true;
+    case SPL_IR_MEM_LOAD:
+        return !ir_is_aggregate(cg->ctx, n->mem_load.tid);
+    default:
+        return false;
+    }
+}
+
+/* 该节点必须使用槽（直接按槽偏移读写 / 控制转移 / 聚合数据），生成前需 flush。 */
+static bool node_needs_slots(cgen_t *cg, const spl_ir_node_t *n) {
+    switch (n->kind) {
+    case SPL_IR_MEM_ALLOCA:
+    case SPL_IR_MEM_GLOBAL_ALLOC:
+    case SPL_IR_MEM_COPY:
+    case SPL_IR_MEM_SET:
+    case SPL_IR_AGG_CONSTRUCT:
+    case SPL_IR_AGG_EXTRACT:
+    case SPL_IR_AGG_INSERT:
+    case SPL_IR_CONTROL_SELECT:
+    case SPL_IR_CONTROL_BR:
+    case SPL_IR_CONTROL_JMP:
+    case SPL_IR_CONTROL_RET:
+    case SPL_IR_CONTROL_UNREACHABLE:
+    case SPL_IR_CONTROL_TRAP:
+    case SPL_IR_DBG_PANIC:
+    case SPL_IR_DBG_BREAKPOINT:
+        return true;
+    case SPL_IR_MEM_LOAD:
+        return ir_is_aggregate(cg->ctx, n->mem_load.tid);
+    case SPL_IR_MEM_STORE:
+        return ir_is_aggregate(cg->ctx, n->mem_store.tid);
+    default:
+        return false;
+    }
+}
+
+/* 取操作数到 TOS：若在栈上就 PICK，否则从槽 load。j = 本节点已压入的操作数个数。 */
+static void cg_operand(cgen_t *cg, usize ref, uint8_t k, usize j) {
+    if (cg->opt) {
+        if (cg->use_left[ref] > 0)
+            cg->use_left[ref]--;
+        if (cg->stk_loc[ref]) {
+            /* 始终复制一份到 TOS，绝不消费栈上的“被跟踪原值”，否则位置模型失效。 */
+            usize dist = cg->tracked + j - 1 - cg->stk_pos[ref];
+            emit(cg, SPL_PICK, SPL_VOID, dist);
+            return;
+        }
+    }
+    cg_load_slot(cg, ref, k);
+}
+
+/* 节点结果：若仍会被使用则留在栈上，否则 DROP。 */
+static void cg_result(cgen_t *cg, usize ref, uint8_t k) {
+    if (cg->opt) {
+        if (cg->use_left[ref] > 0) {
+            cg->stk_loc[ref] = 1;
+            cg->stk_pos[ref] = cg->tracked;
+            cg->at_pos[cg->tracked] = ref;
+            cg->tracked++;
+        } else {
+            emit(cg, SPL_DROP, SPL_VOID, 0);
+        }
+        return;
+    }
+    cg_store_slot(cg, ref, k);
+}
+
+/* 把栈上仍存活的值溢出回各自槽（TOS 起），死值 DROP；清空跟踪。 */
+static void cg_flush(cgen_t *cg) {
+    if (!cg->opt)
+        return;
+    while (cg->tracked > 0) {
+        cg->tracked--;
+        usize r = cg->at_pos[cg->tracked];
+        cg->stk_loc[r] = 0;
+        if (cg->use_left[r] > 0) {
+            uint8_t k = node_result_kind(cg, r);
+            cg_store_slot(cg, r, k);
+        } else {
+            emit(cg, SPL_DROP, SPL_VOID, 0);
+        }
+    }
+}
+
+/* 统计被引用次数（所有节点载荷中的 node ref）。 */
+static void count_ref(cgen_t *cg, usize r) {
+    if (r != 0 && r < vec_size(cg->irf->nodes))
+        cg->use_left[r]++;
+}
+static void count_refs_vec(cgen_t *cg, const spl_ir_node_ref_vec_t *v) {
+    for (usize i = 0; i < vec_size(*v); i++)
+        count_ref(cg, vec_at(*v, i));
+}
+static void count_refs(cgen_t *cg, const spl_ir_node_t *n) {
+    switch (n->kind) {
+    case SPL_IR_ARITH_ADD: case SPL_IR_ARITH_SUB: case SPL_IR_ARITH_MUL:
+    case SPL_IR_ARITH_DIV: case SPL_IR_ARITH_REM: case SPL_IR_ARITH_NEG:
+    case SPL_IR_ARITH_ABS: case SPL_IR_ARITH_AND: case SPL_IR_ARITH_OR:
+    case SPL_IR_ARITH_XOR: case SPL_IR_ARITH_SHL: case SPL_IR_ARITH_SHR:
+    case SPL_IR_ARITH_NOT:
+        count_ref(cg, n->arith.left);
+        count_ref(cg, n->arith.right);
+        break;
+    case SPL_IR_CMP_EQ: case SPL_IR_CMP_NE: case SPL_IR_CMP_LT:
+    case SPL_IR_CMP_LE: case SPL_IR_CMP_GT: case SPL_IR_CMP_GE:
+        count_ref(cg, n->cmp.a);
+        count_ref(cg, n->cmp.b);
+        break;
+    case SPL_IR_CAST_TRUNC: case SPL_IR_CAST_ZEXT: case SPL_IR_CAST_SEXT:
+    case SPL_IR_CAST_FEXT: case SPL_IR_CAST_FTRUNC: case SPL_IR_CAST_BITCAST:
+    case SPL_IR_CAST_PTR2INT: case SPL_IR_CAST_INT2PTR: case SPL_IR_CAST_BOOL2INT:
+    case SPL_IR_CASE_INT2FLOAT: case SPL_IR_CASE_FLOAT2INT:
+        count_ref(cg, n->cast.val);
+        break;
+    case SPL_IR_MEM_ALLOCA:
+        count_ref(cg, n->mem_alloc.count);
+        break;
+    case SPL_IR_MEM_GLOBAL_ALLOC:
+        count_ref(cg, n->mem_global_alloc.const_node);
+        break;
+    case SPL_IR_MEM_LOAD:
+        count_ref(cg, n->mem_load.ptr);
+        break;
+    case SPL_IR_MEM_STORE:
+        count_ref(cg, n->mem_store.ptr);
+        count_ref(cg, n->mem_store.val);
+        break;
+    case SPL_IR_MEM_OFFSET:
+        count_ref(cg, n->mem_offset.ptr);
+        count_ref(cg, n->mem_offset.offset);
+        break;
+    case SPL_IR_MEM_FIELD_PTR:
+        count_ref(cg, n->mem_field_ptr.agg);
+        break;
+    case SPL_IR_MEM_COPY:
+        count_ref(cg, n->mem_copy.dst);
+        count_ref(cg, n->mem_copy.src);
+        count_ref(cg, n->mem_copy.size);
+        break;
+    case SPL_IR_MEM_SET:
+        count_ref(cg, n->mem_set.dst);
+        count_ref(cg, n->mem_set.val);
+        count_ref(cg, n->mem_set.size);
+        break;
+    case SPL_IR_TYPE_OFFSETOF:
+        count_ref(cg, n->ir_offsetof.field_idx);
+        break;
+    case SPL_IR_AGG_CONSTRUCT:
+        count_refs_vec(cg, &n->agg_construct.fields);
+        break;
+    case SPL_IR_AGG_EXTRACT:
+        count_ref(cg, n->agg_extract.val);
+        break;
+    case SPL_IR_AGG_INSERT:
+        count_ref(cg, n->agg_insert.agg);
+        count_ref(cg, n->agg_insert.field);
+        break;
+    case SPL_IR_CONTROL_SELECT:
+        count_ref(cg, n->control_select.cond);
+        count_ref(cg, n->control_select.true_val);
+        count_ref(cg, n->control_select.false_val);
+        break;
+    case SPL_IR_CONTROL_BR:
+        count_ref(cg, n->control_br.cond);
+        count_ref(cg, n->control_br.true_label);
+        count_ref(cg, n->control_br.false_label);
+        break;
+    case SPL_IR_CONTROL_JMP:
+        count_ref(cg, n->control_jmp.label);
+        break;
+    case SPL_IR_CONTROL_CALL:
+        count_ref(cg, n->control_call.func);
+        count_refs_vec(cg, &n->control_call.params);
+        break;
+    case SPL_IR_CONTROL_PARAM:
+        count_ref(cg, n->control_param.idx);
+        break;
+    case SPL_IR_CONTROL_RET:
+        count_ref(cg, n->control_ret.val);
+        break;
+    default:
+        break;
+    }
+}
+
 typedef struct {
     bool indirect;
     usize off;
@@ -439,25 +680,25 @@ static void cg_add_fix(cgen_t *cg, usize ins_idx, fix_kind_t kind, spl_ir_node_r
 
 static void cg_binop(cgen_t *cg, usize ref, const spl_ir_node_t *n, uint8_t op) {
     uint8_t k = vm_kind_of(cg->ctx, n->arith.tid);
-    cg_load_slot(cg, n->arith.left, k);
+    cg_operand(cg, n->arith.left, k, 0);
-    cg_load_slot(cg, n->arith.right, k);
+    cg_operand(cg, n->arith.right, k, 1);
     CG_OP(cg, op, k);
-    cg_store_slot(cg, ref, k);
+    cg_result(cg, ref, k);
 }
 
 static void cg_unop(cgen_t *cg, usize ref, const spl_ir_node_t *n, uint8_t op) {
     uint8_t k = vm_kind_of(cg->ctx, n->arith.tid);
-    cg_load_slot(cg, n->arith.left, k);
+    cg_operand(cg, n->arith.left, k, 0);
     CG_OP(cg, op, k);
-    cg_store_slot(cg, ref, k);
+    cg_result(cg, ref, k);
 }
 
 static void cg_cmp(cgen_t *cg, usize ref, const spl_ir_node_t *n, uint8_t op) {
     uint8_t k = vm_kind_of(cg->ctx, n->cmp.tid);
-    cg_load_slot(cg, n->cmp.a, k);
+    cg_operand(cg, n->cmp.a, k, 0);
-    cg_load_slot(cg, n->cmp.b, k);
+    cg_operand(cg, n->cmp.b, k, 1);
     CG_OP(cg, op, k);
-    cg_store_slot(cg, ref, SPL_BOOL);
+    cg_result(cg, ref, SPL_BOOL);
 }
 
 static void cg_const(cgen_t *cg, usize ref, const spl_ir_node_t *n) {
@@ -479,7 +720,7 @@ static void cg_const(cgen_t *cg, usize ref, const spl_ir_node_t *n) {
             CG_PUSH(cg, SPL_PTR, 0);
             cg_add_fix(cg, idx, FIX_FNADDR, 0, n->type_const.fn);
         }
-        cg_store_slot(cg, ref, SPL_PTR);
+        cg_result(cg, ref, SPL_PTR);
         return;
     }
 
@@ -507,7 +748,7 @@ static void cg_const(cgen_t *cg, usize ref, const spl_ir_node_t *n) {
         break;
     }
     CG_PUSH(cg, k, imm);
-    cg_store_slot(cg, ref, k);
+    cg_result(cg, ref, k);
 }
 
 static void cg_cast(cgen_t *cg, usize ref, const spl_ir_node_t *n) {
@@ -520,7 +761,7 @@ static void cg_cast(cgen_t *cg, usize ref, const spl_ir_node_t *n) {
     uint8_t fk = vm_kind_of(ctx, n->cast.from_tid);
     uint8_t tk = vm_kind_of(ctx, n->cast.to_tid);
 
-    cg_load_slot(cg, n->cast.val, fk);
+    cg_operand(cg, n->cast.val, fk, 0);
 
     if (ft->kind == SPL_TYPE_INT && tt->kind == SPL_TYPE_INT) {
         usize fb = ft->int_type.bits;
@@ -533,7 +774,7 @@ static void cg_cast(cgen_t *cg, usize ref, const spl_ir_node_t *n) {
         emit(cg, SPL_ZEXT, SPL_VOID, 1);
     }
 
-    cg_store_slot(cg, ref, tk);
+    cg_result(cg, ref, tk);
 }
 
 static void cg_mem(cgen_t *cg, usize ref, const spl_ir_node_t *n) {
@@ -571,9 +812,9 @@ static void cg_mem(cgen_t *cg, usize ref, const spl_ir_node_t *n) {
             cg_store_slot(cg, ref, SPL_PTR);
         } else {
             uint8_t k = vm_kind_of(ctx, tid);
-            cg_load_slot(cg, n->mem_load.ptr, SPL_PTR);
+            cg_operand(cg, n->mem_load.ptr, SPL_PTR, 0);
             CG_LOAD(cg, k);
-            cg_store_slot(cg, ref, k);
+            cg_result(cg, ref, k);
         }
         break;
     }
@@ -585,8 +826,8 @@ static void cg_mem(cgen_t *cg, usize ref, const spl_ir_node_t *n) {
                         ptr_slot(vec_at(cg->frame.slots, n->mem_store.ptr).result_off), tid);
         } else {
             uint8_t k = vm_kind_of(ctx, tid);
-            cg_load_slot(cg, n->mem_store.ptr, SPL_PTR);
+            cg_operand(cg, n->mem_store.ptr, SPL_PTR, 0);
-            cg_load_slot(cg, n->mem_store.val, k);
+            cg_operand(cg, n->mem_store.val, k, 1);
             CG_STORE(cg, k);
         }
         break;
@@ -596,24 +837,24 @@ static void cg_mem(cgen_t *cg, usize ref, const spl_ir_node_t *n) {
         usize elem_size = ir_type_size(ctx, n->mem_offset.tid);
         if (elem_size == 0)
             elem_size = 1;
-        cg_load_slot(cg, n->mem_offset.ptr, SPL_PTR);
+        cg_operand(cg, n->mem_offset.ptr, SPL_PTR, 0);
-        cg_load_slot(cg, n->mem_offset.offset, SPL_U64);
+        cg_operand(cg, n->mem_offset.offset, SPL_U64, 1);
         CG_PUSH(cg, SPL_U64, elem_size);
         CG_OP(cg, SPL_MUL, SPL_U64);
         CG_OP(cg, SPL_ADD, SPL_PTR);
-        cg_store_slot(cg, ref, SPL_PTR);
+        cg_result(cg, ref, SPL_PTR);
         break;
     }
 
     case SPL_IR_MEM_FIELD_PTR: {
         spl_type_id_t agg_tid = n->mem_field_ptr.tid;
         usize off = ir_agg_field_off(ctx, agg_tid, n->mem_field_ptr.field_idx);
-        cg_load_slot(cg, n->mem_field_ptr.agg, SPL_PTR);
+        cg_operand(cg, n->mem_field_ptr.agg, SPL_PTR, 0);
         if (off) {
             CG_PUSH(cg, SPL_U64, off);
             CG_OP(cg, SPL_ADD, SPL_PTR);
         }
-        cg_store_slot(cg, ref, SPL_PTR);
+        cg_result(cg, ref, SPL_PTR);
         break;
     }
 
@@ -742,7 +983,7 @@ static void cg_typeop(cgen_t *cg, usize ref, const spl_ir_node_t *n) {
         return;
     }
     CG_PUSH(cg, SPL_U64, v);
-    cg_store_slot(cg, ref, SPL_U64);
+    cg_result(cg, ref, SPL_U64);
 }
 
 static void cg_control(cgen_t *cg, usize ref, const spl_ir_node_t *n) {
@@ -775,10 +1016,7 @@ static void cg_control(cgen_t *cg, usize ref, const spl_ir_node_t *n) {
                 CG_LOAD(cg, SPL_PTR);
                 cg_load_slot(cg, n->control_ret.val, SPL_PTR);
                 CG_PUSH(cg, SPL_U64, sz);
-                int nat = get_or_add_native(ctx, "vm_memcpy");
+                emit(cg, SPL_MEMCPY, SPL_VOID, 0);
-                CG_PUSH(cg, SPL_U64, (spl_vm_val_t)nat);
-                emit(cg, SPL_NCALL, SPL_VOID, 3);
-                emit(cg, SPL_DROP, SPL_VOID, 0);
             }
             emit(cg, SPL_RET, SPL_VOID, 0);
             break;
@@ -829,44 +1067,53 @@ static void cg_control(cgen_t *cg, usize ref, const spl_ir_node_t *n) {
                 const spl_ir_node_t *pn = &vec_at(cg->irf->nodes, pref);
                 spl_type_id_t ptid = ir_result_tid(ctx, pn);
                 uint8_t pk = vm_kind_of(ctx, ptid);
-                cg_load_slot(cg, pref, pk);
+                cg_operand(cg, pref, pk, i);
             }
             CG_PUSH(cg, SPL_U64, (spl_vm_val_t)nat_idx);
             emit(cg, SPL_NCALL, SPL_VOID, (spl_vm_val_t)nargs);
 
             uint8_t rk = vm_kind_of(ctx, n->control_call.tid);
             if (rk == SPL_VOID)
-                emit(cg, SPL_DROP, SPL_VOID, 0); /* NCALL 总是 push 一个结果 */
+                emit(cg, SPL_DROP, SPL_VOID, 0); /* NCALL always push result */
             else
-                cg_store_slot(cg, ref, rk);
+                cg_result(cg, ref, rk);
         } else {
             spl_type_id_t ret_t = n->control_call.tid;
             bool ret_is_sret = ir_is_aggregate(ctx, ret_t);
             usize sret_off = 0;
+            /* j = 本节点已压入 tracked 块之上的值的个数（用于栈化 PICK 距离）。
+               先压 2 个 ABI 空闲 slot，故从 2 起算。 */
+            usize j = 2;
+
+            /* ABI：实参下方预留 2 个空闲 slot（PAD0/PAD1）。 */
+            CG_PUSH(cg, SPL_U64, 0);
+            CG_PUSH(cg, SPL_U64, 0);
 
             if (ret_is_sret) {
                 sret_off = vec_at(cg->frame.slots, ref).data_off;
                 CG_LADDR(cg, sret_off);
+                j = 3;
             }
             for (usize i = 0; i < nargs; ++i) {
                 spl_ir_node_ref_t pref = vec_at(n->control_call.params, i);
                 const spl_ir_node_t *pn = &vec_at(cg->irf->nodes, pref);
                 spl_type_id_t ptid = ir_result_tid(ctx, pn);
                 uint8_t pk = vm_kind_of(ctx, ptid);
-                cg_load_slot(cg, pref, pk);
+                cg_operand(cg, pref, pk, j);
+                j++;
             }
-            cg_load_slot(cg, fref, SPL_PTR);
+            cg_operand(cg, fref, SPL_PTR, j);
             spl_vm_val_t actual_nargs = nargs + (ret_is_sret ? 1 : 0);
             emit(cg, SPL_CALL, SPL_VOID, actual_nargs);
 
             if (ret_is_sret) {
-                /* 结果槽保存 sret 指针，后续 agg_extract 把它当聚合首地址 */
+                /* result slot saves sret pointer */
                 CG_LADDR(cg, sret_off);
-                cg_store_slot(cg, ref, SPL_PTR);
+                cg_result(cg, ref, SPL_PTR);
             } else {
                 uint8_t rk = vm_kind_of(ctx, ret_t);
                 if (rk != SPL_VOID)
-                    cg_store_slot(cg, ref, rk);
+                    cg_result(cg, ref, rk);
             }
         }
         break;
@@ -933,10 +1180,10 @@ static void cg_node(cgen_t *cg, usize ref, const spl_ir_node_t *n) {
     case SPL_IR_ARITH_NOT: {
         spl_type_node_t *tn = spl_type_node(cg->ctx->type, n->arith.tid);
         if (tn && tn->kind == SPL_TYPE_BOOL) {
-            cg_load_slot(cg, n->arith.left, SPL_BOOL);
+            cg_operand(cg, n->arith.left, SPL_BOOL, 0);
             CG_PUSH(cg, SPL_BOOL, 0);
             CG_OP(cg, SPL_EQ, SPL_BOOL);
-            cg_store_slot(cg, ref, SPL_BOOL);
+            cg_result(cg, ref, SPL_BOOL);
         } else {
             cg_unop(cg, ref, n, SPL_NOT);
         }
@@ -1098,9 +1345,49 @@ static usize translate_function(spl_ir2vm_t *ctx, spl_ir_func_ref_t fid, fix_vec
     for (usize i = 0; i < nnodes; ++i)
         vec_push(cg.node_ip, 0);
 
+    unsigned char *leader = NULL;
+    cg.opt = ctx->opt;
+    if (ctx->opt) {
+        cg.stk_loc = (uint8_t *)calloc(nnodes, 1);
+        cg.stk_pos = (usize *)calloc(nnodes, sizeof(usize));
+        cg.use_left = (usize *)calloc(nnodes, sizeof(usize));
+        cg.at_pos = (usize *)calloc(nnodes, sizeof(usize));
+        leader = (unsigned char *)calloc(nnodes, 1);
+        cg.tracked = 0;
+        for (usize i = 1; i < nnodes; ++i)
+            count_refs(&cg, &vec_at(irf->nodes, i));
+        if (nnodes > 1)
+            leader[1] = 1;
         for (usize i = 1; i < nnodes; ++i) {
+            const spl_ir_node_t *n = &vec_at(irf->nodes, i);
+            if (n->kind == SPL_IR_CONTROL_BR) {
+                if (n->control_br.true_label < nnodes)
+                    leader[n->control_br.true_label] = 1;
+                if (n->control_br.false_label < nnodes)
+                    leader[n->control_br.false_label] = 1;
+            } else if (n->kind == SPL_IR_CONTROL_JMP) {
+                if (n->control_jmp.label < nnodes)
+                    leader[n->control_jmp.label] = 1;
+            }
+        }
+    }
+
+    for (usize i = 1; i < nnodes; ++i) {
+        const spl_ir_node_t *n = &vec_at(irf->nodes, i);
+        if (cg.opt) {
+            if (leader[i] || node_needs_slots(&cg, n))
+                cg_flush(&cg);
+        }
         vec_at(cg.node_ip, i) = ip_of(&cg);
-        cg_node(&cg, i, &vec_at(irf->nodes, i));
+        cg_node(&cg, i, n);
+    }
+    if (cg.opt) {
+        cg_flush(&cg);
+        free(cg.stk_loc);
+        free(cg.stk_pos);
+        free(cg.use_left);
+        free(cg.at_pos);
+        free(leader);
     }
 
     for (usize i = 0; i < vec_size(local_fixups); ++i) {
@@ -1124,12 +1411,13 @@ static usize spl_map_hash(usize k) { return MAP_HASH_INT(k); }
 static int spl_map_cmp(usize a, usize b) { return MAP_CMP_INT(a, b); }
 
 void spl_ir2vm_init(spl_ir2vm_t *ctx, const spl_ir_t *ir, const spl_type_t *type,
-                    spl_layout_t *layout, const spl_attr_t *attr) {
+                    spl_layout_t *layout, const spl_attr_t *attr, int opt) {
     Assert(ir != NULL && type != NULL && attr != NULL);
     ctx->ir = ir;
     ctx->type = type;
     ctx->attr = attr;
     ctx->layout = layout;
+    ctx->opt = opt;
     map_init(ctx->extern_native, spl_map_hash, spl_map_cmp);
     spl_prog_init(&ctx->prog);
 

stage1/spl_ir2vm.h

@@ -25,10 +25,11 @@ typedef struct {
     spl_layout_t *layout; /* 借用 splc0 的 layout（size/align/offset 唯一来源） */
 
     spl_diag_t *diag;
+    int opt; /* 非 0：块内操作数栈化（表达式临时值留栈，块边界溢出回槽） */
 } spl_ir2vm_t;
 
 void spl_ir2vm_init(spl_ir2vm_t *ctx, const spl_ir_t *ir, const spl_type_t *type,
-                    spl_layout_t *layout, const spl_attr_t *attr);
+                    spl_layout_t *layout, const spl_attr_t *attr, int opt);
 void spl_ir2vm_drop(spl_ir2vm_t *ctx);
 
 int spl_ir2vm_run_func(spl_ir2vm_t *ctx, spl_ir_func_ref_t ref);

stage1/spl_parser.c

@@ -417,6 +417,20 @@ static spl_ast_node_ref_t parse_pattern_atom(spl_parser_t *p) {
         return ref;
     }
 
+    case TOK_AND: {
+        /* `&name`：解包左值引用绑定。仅允许作用于绑定名。 */
+        advance(p);
+        const spl_tok_t *nx = peek(p);
+        if (!nx || nx->type != TOK_IDENT) {
+            PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_EXPECTED, nx, "expected binding name after '&'");
+            return 0;
+        }
+        spl_ast_node_ref_t inner = parse_pattern_atom(p);
+        spl_ast_node_ref_t ref = new_node(p, SPL_AST_PATTERN_REF, t);
+        node_at(p->ast, ref)->pattern_ref.pat = inner;
+        return ref;
+    }
+
     default:
         PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_UNRECOGNIZED, t, "unexpected token in pattern");
         return 0;

stage1/spl_sema.c

@@ -302,27 +302,23 @@ static spl_lang_type_id_t sema_build_aggregate(spl_sema_t *sema, spl_ast_node_t
 
     spl_lang_type_id_t saved_agg = sema->current_aggregate_lang;
     sema->current_aggregate_lang = agg_lang;
+    /* 聚合体自成命名空间：成员类型可引用同体声明的嵌套类型（裸名）。 */
+    sema_push_scope(sema);
 
     spl_type_member_vec_t members;
     vec_init(members);
     spl_lang_method_vec_t methods;
     vec_init(methods);
 
+    /* 第一遍：登记嵌套类型/函数的 def，挂进 methods 与聚合作用域。成员类型可能引用它们，
+       必须早于成员类型推断，否则限定名（经 methods）与裸名（经作用域）都解析不到。 */
     for (usize i = 0; i < vec_size(te->type_aggregate.members); ++i) {
         spl_ast_node_ref_t mref = vec_at(te->type_aggregate.members, i);
         spl_ast_node_t *mn = spl_ast_node(sema->ast, mref);
         if (!mn)
             continue;
 
-        if (mn->kind == SPL_AST_MEMBER_DECL) {
+        if (mn->kind == SPL_AST_FN_DECL) {
-            spl_lang_type_id_t mtid = 0;
-            if (mn->member_decl.type_expr)
-                mtid = sema_infer(sema, mn->member_decl.type_expr);
-            spl_type_member_t m = {.name = mn->member_decl.name,
-                                   .type_id = spl_lang_type_get_ir_type(sema->type, mtid),
-                                   .ast_node_ref = mref};
-            vec_push(members, m);
-        } else if (mn->kind == SPL_AST_FN_DECL) {
             spl_def_id_t fn_def = mn->resolved_def_id;
             if (!fn_def) {
                 fn_def = spl_def_alloc(sema->type, SPL_DEF_FN, mn->fn_decl.name, mn->dbg, sema->ast,
@@ -334,6 +330,9 @@ static spl_lang_type_id_t sema_build_aggregate(spl_sema_t *sema, spl_ast_node_t
                 fn_d->owner_def = owner_def_id;
             spl_lang_method_t meth = {.name = mn->fn_decl.name, .def_id = fn_def};
             vec_push(methods, meth);
+            spl_symbol_t fsym = {.name = mn->fn_decl.name, .kind = SPL_SYMBOL_KIND_FN};
+            fsym.node = fn_def;
+            spl_scope_insert(sema->scope, sema->scope->current_scope, fsym);
         } else if (mn->kind == SPL_AST_TYPE_DECL) {
             spl_ast_node_t *tpat = spl_ast_node(sema->ast, mn->type_decl.pattern);
             if (!tpat || tpat->kind != SPL_AST_PATTERN_IDENT)
@@ -352,9 +351,37 @@ static spl_lang_type_id_t sema_build_aggregate(spl_sema_t *sema, spl_ast_node_t
             }
             spl_lang_method_t meth = {.name = tname, .def_id = tdef};
             vec_push(methods, meth);
+            spl_symbol_t tsym = {.name = tname, .kind = SPL_SYMBOL_KIND_TYPE};
+            tsym.node = tdef;
+            spl_scope_insert(sema->scope, sema->scope->current_scope, tsym);
         }
     }
 
+    spl_lang_type_node_t *lslot = spl_lang_type_node(sema->type, agg_lang);
+    if (lslot) {
+        vec_free(lslot->methods);
+        lslot->methods = methods;
+        vec_init(methods);
+    }
+
+    /* 第二遍：成员（字段/变体）类型推断；此时嵌套名字已可解析。 */
+    for (usize i = 0; i < vec_size(te->type_aggregate.members); ++i) {
+        spl_ast_node_ref_t mref = vec_at(te->type_aggregate.members, i);
+        spl_ast_node_t *mn = spl_ast_node(sema->ast, mref);
+        if (!mn)
+            continue;
+        if (mn->kind == SPL_AST_MEMBER_DECL) {
+            spl_lang_type_id_t mtid = 0;
+            if (mn->member_decl.type_expr)
+                mtid = sema_infer(sema, mn->member_decl.type_expr);
+            spl_type_member_t m = {.name = mn->member_decl.name,
+                                   .type_id = spl_lang_type_get_ir_type(sema->type, mtid),
+                                   .ast_node_ref = mref};
+            vec_push(members, m);
+        }
+    }
+
+    sema_pop_scope(sema);
     sema->current_aggregate_lang = saved_agg;
 
     spl_type_node_t tn = {0};
@@ -366,13 +393,6 @@ static spl_lang_type_id_t sema_build_aggregate(spl_sema_t *sema, spl_ast_node_t
     vec_init(members);
     spl_lang_define_ir(sema->type, agg_ir, &tn);
 
-    spl_lang_type_node_t *lslot = spl_lang_type_node(sema->type, agg_lang);
-    if (lslot) {
-        vec_free(lslot->methods);
-        lslot->methods = methods;
-        vec_init(methods);
-    }
-
     return agg_lang;
 }
 
@@ -764,8 +784,7 @@ static void sema_collect_signatures(spl_sema_t *sema) {
         spl_def_node_t *d = &vec_at(sema->type->def_table, i);
         /* Nested imports share def_table, but each module has its own scope.
          * Resolve other modules' signatures only when processing their AST. */
-        if (d->owner_ast == sema->ast && d->kind == SPL_DEF_FN &&
+        if (d->owner_ast == sema->ast && d->kind == SPL_DEF_FN && d->state == SPL_DECL_UNRESOLVED)
-            d->state == SPL_DECL_UNRESOLVED)
             sema_eval_decl(sema, i);
     }
 }
@@ -830,14 +849,14 @@ static spl_lang_type_id_t sema_infer_type_context(spl_sema_t *sema, spl_ast_node
         spl_symbol_t symbol;
         if (!spl_scope_find(sema->scope, n->ident.name, &symbol) ||
             symbol.kind != SPL_SYMBOL_KIND_TYPE) {
-            spl_diag_error(sema->diag, SPL_DIAG_KIND_TYPE_MISMATCH, &n->dbg,
+            spl_diag_error(sema->diag, SPL_DIAG_KIND_TYPE_MISMATCH, &n->dbg, "`%s` is not a type",
-                           "`%s` is not a type", n->ident.name);
+                           n->ident.name);
             return 0;
         }
         spl_def_node_t *def = spl_def_node(sema->type, symbol.node);
         if (!sema_def_is_type(def)) {
-            spl_diag_error(sema->diag, SPL_DIAG_KIND_TYPE_MISMATCH, &n->dbg,
+            spl_diag_error(sema->diag, SPL_DIAG_KIND_TYPE_MISMATCH, &n->dbg, "`%s` is not a type",
-                           "`%s` is not a type", n->ident.name);
+                           n->ident.name);
             return 0;
         }
         n->resolved_def_id = symbol.node;
@@ -880,16 +899,15 @@ static spl_lang_type_id_t sema_infer_type_context(spl_sema_t *sema, spl_ast_node
         spl_lang_type_id_vec_t elements;
         vec_init(elements);
         for (usize i = 0; i < vec_size(n->tuple.elems); ++i) {
-            spl_lang_type_id_t element =
+            spl_lang_type_id_t element = sema_infer_type_context(sema, vec_at(n->tuple.elems, i));
-                sema_infer_type_context(sema, vec_at(n->tuple.elems, i));
             if (!element) {
                 vec_free(elements);
                 return 0;
             }
             vec_push(elements, element);
         }
-        spl_lang_type_id_t result = spl_lang_make_tuple(
+        spl_lang_type_id_t result =
-            sema->type, vec_unsafe_get_data(elements), vec_size(elements));
+            spl_lang_make_tuple(sema->type, vec_unsafe_get_data(elements), vec_size(elements));
         vec_free(elements);
         n->resolved_lang_tid = result;
         return result;
@@ -1138,6 +1156,18 @@ static void sema_bind_pattern(spl_sema_t *sema, spl_ast_node_ref_t pat_ref,
     case SPL_AST_PATTERN_UNDERSCORE:
         return;
 
+    case SPL_AST_PATTERN_REF: {
+        if (!matched_tid) {
+            spl_diag_error(sema->diag, SPL_DIAG_KIND_TYPE_MISMATCH, &pat->dbg,
+                           "ref pattern requires a concrete type");
+            return;
+        }
+        spl_lang_type_id_t ptr = spl_lang_make_ptr(sema->type, matched_tid);
+        sema_bind_pattern(sema, pat->pattern_ref.pat, ptr);
+        pat->resolved_lang_tid = ptr;
+        return;
+    }
+
     case SPL_AST_PATTERN_LIST: {
         for (usize i = 0; i < vec_size(pat->pattern_list.patterns); ++i)
             sema_bind_pattern(sema, vec_at(pat->pattern_list.patterns, i), matched_tid);
@@ -2866,6 +2896,7 @@ void spl_sema_dump(spl_sema_t *sema) {
     printf("Scopes:\n");
     for (usize i = 1; i < vec_size(sema->scope->scopes); ++i) {
         spl_scope_node_t *scope = &vec_at(sema->scope->scopes, i);
+        Assert(scope != NULL);
         printf("scope[%zu] parent=%zu\n", i, scope->parent);
 
         /* 按符号名排序输出：与哈希表内部布局解耦，保证确定顺序。 */
@@ -2873,6 +2904,7 @@ void spl_sema_dump(spl_sema_t *sema) {
         spl_sema_sym_t *arr = nsyms ? malloc(nsyms * sizeof(*arr)) : NULL;
         usize k = 0;
         map_for(scope->symbols, j) {
+            Assert(arr != NULL);
             arr[k].key = unsafe_map_at(scope->symbols, j).key;
             arr[k].sym = unsafe_map_at(scope->symbols, j).val;
             k++;
@@ -2880,6 +2912,7 @@ void spl_sema_dump(spl_sema_t *sema) {
         if (arr && nsyms > 1)
             qsort(arr, nsyms, sizeof(*arr), spl_sema_sym_cmp);
         for (k = 0; k < nsyms; ++k) {
+            Assert(arr != NULL);
             printf("  %s -> def`%s`#%zu\n", arr[k].key, arr[k].sym.name, arr[k].sym.node);
         }
         free(arr);

stage1/splc0.c

@@ -10,6 +10,9 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include "ir_opt.h"
+#include "vm_opt.h"
+
 #include "spl_ast.h"
 #include "spl_ast2ir.h"
 #include "spl_diag.h"
@@ -217,7 +220,7 @@ static spl_ast_t *driver_load(void *user, const char *from_fname, const char *pa
 }
 
 static int compile_spl(const char *src, const char *fname, const char *outpath, int gen_debug,
-                       dump_t dump) {
+                       dump_t dump, int opt) {
     (void)gen_debug;
 
     spl_diag_t diag;
@@ -326,6 +329,10 @@ static int compile_spl(const char *src, const char *fname, const char *outpath,
         rc = 1;
         goto cleanup;
     }
+    /* IR 层优化 pass（默认关闭，--opt 开启）。 */
+    if (opt)
+        spl_ir_opt(&ir_builder.ir, &attr);
+
     if (dump == DUMP_IR) {
         spl_ir_dump(&ir_builder.ir, &lang_type.ir, &attr);
         goto cleanup;
@@ -334,7 +341,7 @@ static int compile_spl(const char *src, const char *fname, const char *outpath,
     /* 类型已全部就绪：解析 layout，供 ir2vm 的 size/align/offset 使用。 */
     spl_layout_resolve(&layout, &lang_type.ir);
 
-    spl_ir2vm_init(&ir2vm, &a2ir.ir->ir, &lang_type.ir, &layout, &attr);
+    spl_ir2vm_init(&ir2vm, &a2ir.ir->ir, &lang_type.ir, &layout, &attr, opt);
     ir2vm_ok = 1;
     spl_diag_set_stage(&diag, SPL_STAGE_IR2VM);
     ir2vm.diag = &diag;
@@ -348,6 +355,10 @@ static int compile_spl(const char *src, const char *fname, const char *outpath,
         goto cleanup;
     }
 
+    /* ir2vm 之后的字节码优化 pass（默认关闭，--opt 开启）。 */
+    if (opt)
+        spl_prog_opt(&ir2vm.prog);
+
     spl_prog_store_to_file(outpath, &ir2vm.prog);
     rc = 0;
 
@@ -397,6 +408,11 @@ int main(int argc, char **argv) {
         LOG_INFO("splc0 --dump <flags> <file>   dump: lex,ast,sema,ir,vm,none");
         return 0;
     }
+    int opt = 0;
+    for (int ai = 1; ai < argc; ai++)
+        if (strcmp(argv[ai], "--opt") == 0)
+            opt = 1;
+
     int argi = 1;
     if (argi >= argc) {
         LOG_FATAL("Usage: splc0 [--dump <flags>] <in> [out]");
@@ -435,19 +451,26 @@ int main(int argc, char **argv) {
         return 1;
     }
     int gen_debug = 0;
+    while (argi < argc - 1) {
         if (strcmp(argv[argi], "-g") == 0) {
             gen_debug = 1;
             argi++;
+        } else if (strcmp(argv[argi], "--opt") == 0) {
+            opt = 1;
+            argi++;
+        } else {
+            break;
+        }
     }
     if (argc < argi + 2) {
-        LOG_FATAL("Usage: splc0 <in> <out> [-g]  or  splc0 --dump <flags> <file>\n");
+        LOG_FATAL("Usage: splc0 <in> <out> [-g] [--opt]  or  splc0 --dump <flags> <file>\n");
         return 1;
     }
     long len;
     char *src = read_file(argv[argi], &len);
     if (!src)
         return 1;
-    int rc = compile_spl(src, argv[argi], argv[argi + 1], gen_debug, dump);
+    int rc = compile_spl(src, argv[argi], argv[argi + 1], gen_debug, dump, opt);
     free(src);
     return rc;
 }

stage1/vm_opt.c

@@ -0,0 +1,165 @@
+/* vm_opt.c - 字节码（VM 层）优化 pass
+ *
+ * 从 stage0/spl_mcode.c 迁出：对已生成的 spl_prog_t 做 prog->prog 优化。
+ * 默认不启用（由 splc0 --opt 驱动）。 */
+
+#include "vm_opt.h"
+
+#include "../stage0/include/core_map.h"
+
+#include <stdlib.h>
+
+/* 消除“store 后立刻 load 同一槽位”的往返。
+ *
+ * 模式（5 条）：laddr X; swap; store k; laddr X; load k
+ * 变换（3 条）：laddr X; pick 1; store k
+ *   [.., v] -> laddr X   => [.., v, X]
+ *           -> pick 1    => [.., v, X, v]
+ *           -> store k   => [.., v]        （存 v 到 X，同时栈上保留 v）
+ * 与原来 store 后再 load 的效果等价，但去掉 2 条指令与一次内存读。
+ *
+ * 会真的删除指令，因此必须重定位：相对跳转、函数表 address、
+ * 以及作为函数指针的 `push ptr <addr>`。仅当被删/被改写的指令不是
+ * 跳转目标或函数入口时才变换（已收集 mark）。 */
+static usize peep_hash_int(usize k) { return MAP_HASH_INT(k); }
+static int peep_cmp_int(usize a, usize b) { return MAP_CMP_INT(a, b); }
+
+void spl_prog_peephole(spl_prog_t *prog) {
+    if (!prog)
+        return;
+    usize n = vec_size(prog->insns);
+    if (n < 5)
+        return;
+    spl_vm_ins_t *ins = prog->insns.data;
+
+    unsigned char *mark = (unsigned char *)calloc(n, 1); /* 跳转目标/函数入口，受保护 */
+    unsigned char *rem = (unsigned char *)calloc(n, 1);
+    if (!mark || !rem) {
+        free(mark);
+        free(rem);
+        return;
+    }
+
+    for (usize i = 0; i < n; i++) {
+        spl_vm_ins_t *x = &ins[i];
+        if (x->opcode == SPL_JMP || x->opcode == SPL_BZ || x->opcode == SPL_BNZ) {
+            isize t = (isize)i + 1 + (isize)x->imm;
+            if (t >= 0 && (usize)t < n)
+                mark[(usize)t] = 1;
+        }
+    }
+    vec_for(prog->funcs, fi) {
+        spl_vm_func_t *f = &vec_at(prog->funcs, fi);
+        if (f->address < n)
+            mark[f->address] = 1;
+    }
+
+    for (usize i = 0; i + 4 < n; i++) {
+        spl_vm_ins_t *a = &ins[i];
+        spl_vm_ins_t *b = &ins[i + 1];
+        spl_vm_ins_t *c = &ins[i + 2];
+        spl_vm_ins_t *d = &ins[i + 3];
+        spl_vm_ins_t *e = &ins[i + 4];
+        if (a->opcode == SPL_LADDR && b->opcode == SPL_SWAP && c->opcode == SPL_STORE &&
+            d->opcode == SPL_LADDR && e->opcode == SPL_LOAD && a->imm == d->imm &&
+            c->type == e->type) {
+            if (mark[i + 1] || mark[i + 3] || mark[i + 4])
+                continue;
+            b->opcode = SPL_PICK;
+            b->type = SPL_VOID;
+            b->imm = 1;
+            rem[i + 3] = 1;
+            rem[i + 4] = 1;
+            i += 4;
+        }
+    }
+
+    usize kept = 0;
+    for (usize i = 0; i < n; i++)
+        if (!rem[i])
+            kept++;
+    if (kept == n) {
+        free(mark);
+        free(rem);
+        return;
+    }
+
+    spl_vm_ins_t *fresh = (spl_vm_ins_t *)malloc(sizeof(spl_vm_ins_t) * (kept ? kept : 1));
+    usize *map = (usize *)malloc(sizeof(usize) * (n + 1)); /* old index -> new index */
+    usize *old_of_new = (usize *)malloc(sizeof(usize) * (kept ? kept : 1));
+    if (!fresh || !map || !old_of_new) {
+        free(mark);
+        free(rem);
+        free(fresh);
+        free(map);
+        free(old_of_new);
+        return;
+    }
+
+    usize out = 0;
+    for (usize i = 0; i < n; i++) {
+        if (!rem[i]) {
+            map[i] = out;
+            old_of_new[out] = i;
+            fresh[out] = ins[i];
+            out++;
+        }
+    }
+    map[n] = kept;
+    for (usize i = n; i-- > 0;)
+        if (rem[i])
+            map[i] = map[i + 1];
+
+    /* 函数地址 old->new */
+    MAP(usize, usize) addr_map;
+    map_init(addr_map, peep_hash_int, peep_cmp_int);
+    vec_for(prog->funcs, fi) {
+        spl_vm_func_t *f = &vec_at(prog->funcs, fi);
+        usize old_a = f->address;
+        if (old_a < n) {
+            usize new_a = map[old_a];
+            map_put(addr_map, old_a, new_a);
+            f->address = new_a;
+        }
+    }
+
+    /* 修正相对跳转与函数指针常量 */
+    for (usize j = 0; j < kept; j++) {
+        spl_vm_ins_t *x = &fresh[j];
+        if (x->opcode == SPL_JMP || x->opcode == SPL_BZ || x->opcode == SPL_BNZ) {
+            isize t = (isize)old_of_new[j] + 1 + (isize)x->imm;
+            if (t >= 0 && (usize)t <= n) {
+                usize nt = map[(usize)t];
+                x->imm = (spl_vm_val_t)(isize)((isize)nt - (isize)(j + 1));
+            }
+        } else if (x->opcode == SPL_PUSH && x->type == SPL_PTR && x->imm != 0) {
+            usize nv = 0;
+            if (map_get(addr_map, (usize)x->imm, &nv))
+                x->imm = nv;
+        }
+    }
+    map_free(addr_map);
+
+    /* 指令删除后函数长度变化，重算 ninsns（函数按地址升序排列）。 */
+    {
+        usize nf = vec_size(prog->funcs);
+        for (usize i = 0; i < nf; i++) {
+            spl_vm_func_t *f = &vec_at(prog->funcs, i);
+            usize next = (i + 1 < nf) ? vec_at(prog->funcs, i + 1).address : kept;
+            f->ninsns = next > f->address ? (spl_vm_val_t)(next - f->address) : 0;
+        }
+    }
+
+    free(prog->insns.data);
+    prog->insns.data = fresh;
+    prog->insns.size = kept;
+    prog->insns.cap = kept;
+
+    free(mark);
+    free(rem);
+    free(map);
+    free(old_of_new);
+}
+
+/* 优化 pass 流水线（纯 prog->prog）：当前 P1，后续可追加。 */
+void spl_prog_opt(spl_prog_t *prog) { spl_prog_peephole(prog); }

stage1/vm_opt.h

@@ -0,0 +1,11 @@
+#ifndef __VM_OPT_H__
+#define __VM_OPT_H__
+
+/* 字节码（VM 层）优化 pass：输入输出都是 spl_prog_t，纯函数式、可开关。 */
+
+#include "../stage0/spl_mcode.h"
+
+void spl_prog_peephole(spl_prog_t *prog);
+void spl_prog_opt(spl_prog_t *prog);
+
+#endif /* __VM_OPT_H__ */

stage2/ast.spl

@@ -1,9 +1,7 @@
 // Expect retcode = 0
 
-// AST：用 ADT（enum 带载荷）表达节点，节点引用是 arena 序号 usize。
+// AST：节点为带载荷 ADT，节点引用是 arena 序号（0 为 NONE 哨兵）。最终 dump/语义须与
-// stage1 的 C 结构只是「手写 union 模拟 ADT」；这里直接用 SPL 的 enum 载荷，
+// splc0 一致。
-// 不照抄 union 布局，只要求最终 dump / 语义与 stage1 一致。
-// 索引 0 为 NONE 哨兵（与 stage1 一致）。
 
 type .{ .Error } = @import("utils/error.spl");
 type .{ .Vec } = @import("utils/vec.spl");
@@ -18,7 +16,6 @@ type .{ .Sources, .Source, .set_at } = @import("utils/source.spl");
 // 算子不另立 enum：AST 直接存词法 Punct。一元/二元由节点 kind 区分
 // （一元：Sub=负 / Not=! / BitNot=~ / And=& / Mul=.*；二元即对应 Punct）。
 
-// ---- 节点体（ADT；variant 名 = stage1 的 kind 名；载荷用内联匿名 struct）----
 
 type Body = enum {
     None,
@@ -45,11 +42,12 @@ type Body = enum {
         type_expr: usize,
         init_expr: usize,
     },
-    ParamDecl: struct { attr_list: Vec, name: ByteView, type_expr: usize },
+    ParamDecl: struct { attr_list: Vec, is_comptime: bool, name: ByteView, type_expr: usize },
     StatementRet: struct { expr: usize },
     StatementBreak: struct { label: usize, expr: usize },
     StatementContinue: struct { label: usize },
     StatementDefer: struct { body: usize },
+    StatementErrdefer: struct { body: usize }, // errdefer：仅错误退出时执行
     StatementComptime: struct { body: usize },
     StatementDecl: struct { decl: usize },
     StatementExpr: struct { expr: usize },
@@ -87,6 +85,8 @@ type Body = enum {
     },
     ExprAggregateLit: struct { name: ByteView, fields: Vec },
     ExprComptimeCall: struct { name: ByteView, args: Vec },
+    ExprTry: struct { value: usize }, // `try expr`
+    ExprCatch: struct { value: usize, pattern: usize, handler: usize }, // `expr catch <pat> { }`
     ExprBlock: struct { stmts: Vec, tail_expr: usize },
     ExprIf: struct { cond: usize, then_block: usize, else_branch: usize },
     ExprIfvar: struct { var_decl: usize, then_block: usize, else_branch: usize },
@@ -121,6 +121,9 @@ type Body = enum {
     PatternList: struct { items: Vec },
     PatternAggregate: struct { items: Vec },
     PatternField: struct { name: ByteView, pattern: usize },
+    PatternRef: struct { pat: usize },
+    ExprComptime: struct { body: usize },
+    ExprComptimeInit: struct { name: ByteView, args: Vec, fields: Vec },
 }
 
 fn kind_name(body: Body): []u8 {
@@ -142,7 +145,9 @@ fn kind_name(body: Body): []u8 {
         .StatementBreak(_) => { ret "statement_break"; },
         .StatementContinue(_) => { ret "statement_continue"; },
         .StatementDefer(_) => { ret "statement_defer"; },
+        .StatementErrdefer(_) => { ret "statement_errdefer"; },
         .StatementComptime(_) => { ret "statement_comptime"; },
+        .ExprComptime(_) => { ret "expr_comptime"; },
         .StatementDecl(_) => { ret "statement_decl"; },
         .StatementExpr(_) => { ret "statement_expr"; },
         .AggregateMember(_) => { ret "aggregate_member"; },
@@ -168,6 +173,9 @@ fn kind_name(body: Body): []u8 {
         .ExprArrayLit(_) => { ret "array_literal"; },
         .ExprAggregateLit(_) => { ret "aggregate_literal"; },
         .ExprComptimeCall(_) => { ret "comptime_call"; },
+        .ExprTry(_) => { ret "try_expr"; },
+        .ExprCatch(_) => { ret "catch_expr"; },
+        .ExprComptimeInit(_) => { ret "comptime_init"; },
         .ExprBlock(_) => { ret "block"; },
         .ExprIf(_) => { ret "if_expr"; },
         .ExprIfvar(_) => { ret "ifvar_expr"; },
@@ -191,6 +199,7 @@ fn kind_name(body: Body): []u8 {
         .PatternList(_) => { ret "pattern_list"; },
         .PatternAggregate(_) => { ret "pattern_aggregate"; },
         .PatternField(_) => { ret "pattern_field"; },
+        .PatternRef(_) => { ret "pattern_ref"; },
     }
     ret "?";
 }
@@ -272,11 +281,8 @@ fn drop(self: *Ast) {
 }
 
 fn node(self: *Ast, ref: usize): *Node {
-    match Vec.get(&self.nodes, ref) {
+    if ref >= self.nodes.len { ret null; }
-        .Ok(ptr) => { ret ptr as *Node; },
+    ret (self.nodes.data as *Node) + ref;
-        .Err(error) => { ret null; },
-    }
-    ret null;
 }
 
 // 追加节点，返回其引用（失败返回 0）。
@@ -293,11 +299,11 @@ fn alloc(self: *Ast, body: Body, span: Span): usize {
 }
 
 // 注册一段已解码的字符串字节（Ast 拥有；ByteView 指向其中，生命周期同 Ast）。
-// 空字符串也保证非空 data 指针（镜像 stage1：空字面量仍有稳定的非空字节地址）。
+// 空字符串也保证非空 data 指针（空字面量仍有稳定非空地址）。
 fn push_string(self: *Ast, bytes: ByteBuffer): ByteView {
     var b = bytes;
     if b.storage.len == 0 {
-        match ByteBuffer.reserve(&b, 1) { .Ok => {}, .Err(error) => {} }
+        ByteBuffer.reserve(&b, 1);
     }
     @assert(b.storage.data != null, "ast string pool must be non-null");
     // 直接构造，避免 from_slice 把空串规范成 null 视图。
@@ -320,7 +326,6 @@ fn ref_vec(): Vec {
     ret Vec.blank(@sizeof(usize), @alignof(usize));
 }
 
-// ---- dump（镜像 stage1 spl_ast_dump）----
 //
 // AST:
 // <indent>`-/|-kind #ref [line:col]
@@ -465,7 +470,9 @@ fn dump_node(ast: *Ast, buf: *ByteBuffer, stack: *Vec, ref: usize, last: bool):
         },
         .StatementContinue(x) => { ok = dump_opt(ast, buf, stack, x.label, true); },
         .StatementDefer(x) => { ok = dump_opt(ast, buf, stack, x.body, true); },
+        .StatementErrdefer(x) => { ok = dump_opt(ast, buf, stack, x.body, true); },
         .StatementComptime(x) => { ok = dump_opt(ast, buf, stack, x.body, true); },
+        .ExprComptime(x) => { ok = dump_opt(ast, buf, stack, x.body, true); },
         .StatementDecl(d) => { ok = dump_opt(ast, buf, stack, d.decl, true); },
         .StatementExpr(e) => { ok = dump_opt(ast, buf, stack, e.expr, true); },
         .AggregateMember(d) => {
@@ -517,6 +524,13 @@ fn dump_node(ast: *Ast, buf: *ByteBuffer, stack: *Vec, ref: usize, last: bool):
         },
         .ExprAggregateLit(a) => { ok = dump_list(ast, buf, stack, a.fields); },
         .ExprComptimeCall(c) => { ok = dump_list(ast, buf, stack, c.args); },
+        .ExprTry(t2) => { ok = dump_opt(ast, buf, stack, t2.value, true); },
+        .ExprCatch(c2) => {
+            ok = dump_opt(ast, buf, stack, c2.value, false) &&
+                 dump_opt(ast, buf, stack, c2.pattern, false) &&
+                 dump_opt(ast, buf, stack, c2.handler, true);
+        },
+        .ExprComptimeInit(x) => { ok = dump_list(ast, buf, stack, x.fields); },
         .ExprBlock(b) => {
             ok = dump_list(ast, buf, stack, b.stmts) &&
                  dump_opt(ast, buf, stack, b.tail_expr, true);
@@ -574,6 +588,7 @@ fn dump_node(ast: *Ast, buf: *ByteBuffer, stack: *Vec, ref: usize, last: bool):
         .PatternList(v) => { ok = dump_list(ast, buf, stack, v.items); },
         .PatternAggregate(v) => { ok = dump_list(ast, buf, stack, v.items); },
         .PatternField(p) => { ok = dump_opt(ast, buf, stack, p.pattern, true); },
+        .PatternRef(p) => { ok = dump_opt(ast, buf, stack, p.pat, true); },
     }
 
     stack.len = stack.len - 1;
@@ -588,7 +603,6 @@ fn dump(ast: *Ast, out: *ByteBuffer): bool {
     ret dump_node(ast, out, &stack, ast.root, true);
 }
 
-// ---- 测试 ----
 
 fn test_kind_names() {
     @assert(ByteView.eq(ByteView.from_slice(kind_name(.None)), ByteView.from_slice("none")),

stage2/attr.spl

@@ -1,8 +1,7 @@
 // Expect retcode = 0
 
-// 属性注册表与属性节点（移植自 stage1/spl_attr.c）。注册表是数据：内置属性
+// 属性注册表：内置属性在 register_builtins 登记，按 (ns, name) 查找。新增属性只加
-// 在 register_builtins 里登记，查找按 (ns, name)。节点记录命中信息 + 实参。
+// 注册项，不改 sema 逻辑（SPL.md 的 @/# 扩展点）。
-// 新增属性只加注册项，不改 sema 逻辑（对应 SPL.md 的 @/# 扩展点）。
 
 type .{ .Error } = @import("utils/error.spl");
 type .{ .Vec } = @import("utils/vec.spl");
@@ -132,11 +131,7 @@ fn drop(self: *Attr) {
 
 fn node(self: *Attr, id: usize): *AttrNode {
     if id == 0 || id >= self.table.len { ret null; }
-    match Vec.get(&self.table, id) {
+    ret (self.table.data as *AttrNode) + id;
-        .Ok(ptr) => { ret ptr as *AttrNode; },
-        .Err(error) => { ret null; },
-    }
-    ret null;
 }
 
 fn info_at(self: *Attr, index: usize): *AttrInfo {
@@ -167,10 +162,7 @@ fn alloc(self: *Attr, info_index: usize, args: Vec): usize {
 }
 
 fn registry_add(self: *Attr, info: AttrInfo) {
-    match Vec.push(&self.registry, &info as *u8) {
+    Vec.push(&self.registry, &info as *u8);
-        .Ok => {},
-        .Err(error) => {},
-    }
 }
 
 // 返回注册表下标（>=1）或 0。
@@ -206,9 +198,9 @@ fn register_builtins(self: *Attr) {
     registry_add(self, make_info("", "align", .Layout, .Type, .Required, 1, 1));
     registry_add(self, make_info("", "volatile", .Ir, .Expr, .Required, 0, 0));
     registry_add(self, make_info("", "atomic", .Ir, .Expr, .Required, 0, 1));
+    registry_add(self, make_info("", "export", .Ir, .Decl, .Optional, 1, 1));
 }
 
-// ---- dump（镜像 stage1 spl_attr_dump / spl_attr_dump_id）----
 
 fn push_out(buf: *ByteBuffer, bytes: []u8): bool {
     match ByteBuffer.append(buf, bytes) {
@@ -344,7 +336,6 @@ fn dump(self: *Attr, out: *ByteBuffer): bool {
     ret true;
 }
 
-// ---- 测试 ----
 
 fn expect_text(buf: ByteBuffer, expected: []u8) {
     var got = ByteBuffer.as_slice(buf);
@@ -364,7 +355,7 @@ fn test_registry() {
     }
     defer { drop(&at); }
 
-    @assert(at.registry.len == 7, "1 sentinel + 6 builtins");
+    @assert(at.registry.len == 8, "1 sentinel + 7 builtins");
 
     var i = lookup(&at, ByteView.empty(), ByteView.from_slice("extern"));
     @assert(i != 0, "extern found");

stage2/def.spl

@@ -1,12 +1,7 @@
 // Expect retcode = 0
 
-// 声明句柄表（移植自 stage1/spl_lang_type.h 的 spl_def_node_t 部分）。
+// 声明句柄表。DefId 是声明的稳定身份：作用域符号、节点 resolved_def_id、comptime
-// DefId 是「声明」的稳定身份：作用域符号、AST 节点 resolved_def_id、以及将来
+// 生成的声明都用它；前向/环形引用由 state 状态机表达。owner_ast 为不透明 *any。
-// comptime 生成的声明都用它。前向引用/环形引用由 state 状态机表达。
-//
-// 与 stage1 的差异：owner_ast 改为不透明 `*any`（借用），使本表不依赖具体 AST
-// 表示，便于将来 comptime/序列化复用；sema 侧自行 cast 回 *Ast。
-// 名称是 ByteView（借用源/AST），本表不做拥有。
 
 type .{ .Error } = @import("utils/error.spl");
 type .{ .Vec } = @import("utils/vec.spl");
@@ -84,14 +79,10 @@ fn drop(self: *DefTable) {
     Vec.drop(&self.table);
 }
 
-// id 0 与越界均返回 null（对应 stage1 spl_def_node）。
+// id 0 与越界均返回 null。
 fn node(self: *DefTable, id: usize): *DefNode {
     if id == 0 || id >= self.table.len { ret null; }
-    match Vec.get(&self.table, id) {
+    ret (self.table.data as *DefNode) + id;
-        .Ok(ptr) => { ret ptr as *DefNode; },
-        .Err(error) => { ret null; },
-    }
-    ret null;
 }
 
 fn count(self: *DefTable): usize {
@@ -133,7 +124,6 @@ fn get_lang_id(self: *DefTable, id: usize): usize {
     ret d.lang_id;
 }
 
-// ---- 分类 ----
 
 fn kind_name(kind: DefKind): []u8 {
     match kind {
@@ -160,7 +150,7 @@ fn state_name(state: DeclState): []u8 {
     ret "unknown";
 }
 
-// 能作为类型使用的 def（对应 stage1 sema_def_is_type）。
+// 能作为类型使用的 def。
 fn is_type_kind(kind: DefKind): bool {
     match kind {
         .Scalar => { ret true; },
@@ -173,7 +163,6 @@ fn is_type_kind(kind: DefKind): bool {
     ret false;
 }
 
-// ---- dump（镜像 stage1 spl_type_def_dump 的文本）----
 
 fn push_out(buf: *ByteBuffer, bytes: []u8): bool {
     match ByteBuffer.append(buf, bytes) {
@@ -207,7 +196,6 @@ fn dump(self: *DefTable, id: usize, out: *ByteBuffer): bool {
     ret push_out(out, ByteView.as_slice(d.name));
 }
 
-// ---- 测试 ----
 
 fn test_alloc_and_state() {
     var dt: DefTable = undefined;

stage2/diag.spl

@@ -1,14 +1,7 @@
 // Expect retcode = 0
 
-// 丰富诊断（参考 rustc / Clang / Swift 的设计，不照搬 stage1 C 实现）：
+// 丰富诊断：Severity / 稳定 E 码 / Span / Label / Child，渲染为人类可读或 JSON。
-//   Severity  Note/Help/Warning/Error/Fatal
+// 位置只存下标，渲染时经 Sources 解析行列；条目拥有其字符串与 labels/children。
-//   Code      固定语义枚举 + 稳定 E 码；集中管理，利于 diff
-//   Span      字节区间 {file,start,end}；file 是 Sources 的下标，NO_FILE 表示无位置
-//   Label     主/次标签（span + 文本），可多个
-//   Child     子诊断（note/help，可带 span），挂在条目上
-// 渲染：人类可读（源码行 + caret 下划线）与 JSON（字段稳定）双格式。
-// 位置只存下标，渲染时经 Sources 解析行列/取行，避免复制文件名。
-// 消息按拥有型 Str 保存；条目拥有其 labels/children；clear/drop 释放全部内部资源。
 
 type .{ .Error, .Status, .make } = @import("./utils/error.spl");
 type .{ .Vec } = @import("./utils/vec.spl");
@@ -181,7 +174,6 @@ fn has_error(self: Diag): bool { ret self.errors > 0; }
 
 fn has_fatal(self: Diag): bool { ret self.fatals > 0; }
 
-// ---- 采集 ----
 
 // 追加一条诊断，返回其下标（失败返回 no_file()）。span 为主位置。
 fn emit(self: *Diag, severity: Severity, stage: Stage, code: Code, span: Span,
@@ -265,7 +257,6 @@ fn attach_child(self: *Diag, severity: Severity, span: Span, msg: []u8): Status
     ret .Ok;
 }
 
-// ---- 名称 ----
 
 fn severity_name(severity: Severity): []u8 {
     match severity {
@@ -370,7 +361,6 @@ fn code_name(code: Code): []u8 {
     ret "none";
 }
 
-// ---- 渲染：公共小工具 ----
 
 fn append_num(out: *ByteBuffer, value: usize): Status {
     ret append_usize(out, value, 10, false);
@@ -519,7 +509,6 @@ fn render_human(self: *Diag, out: *ByteBuffer): Status {
     ret .Ok;
 }
 
-// ---- JSON 渲染（字段稳定，供 LSP / diff 工具）----
 
 fn append_json_hex4(out: *ByteBuffer, b: u8): Status {
     var hex: []u8 = "0123456789abcdef";
@@ -661,7 +650,6 @@ fn render_json(self: *Diag, out: *ByteBuffer): Status {
     ret ByteBuffer.append_byte(out, ']');
 }
 
-// ---- 生命周期 ----
 
 fn drop_item(it: *Item) {
     Str.drop(&it.message);
@@ -700,7 +688,6 @@ fn drop(self: *Diag) {
     self.sources = null;
 }
 
-// ---- 测试辅助 ----
 
 fn view(text: []u8): ByteView {
     ret ByteView.from_slice(text);

stage2/eval.spl

@@ -1,22 +1,16 @@
 // Expect retcode = 0
 
-// comptime / const 求值的**接口 seam**（本轮只占位，不实现求值）。
+// comptime/const 求值的接口 seam：sema 只在此调用，未实现时返回 NotConst（放弃折叠、
-//
+// 不报错）。编译期生成的声明经 DeclSink 登记，不改 sema 表。
-// 目标：把「编译期求值」从 sema 主体里隔离出来，将来接一个解释器（可直接复用
-// VM 或 AST 求值器）时不动 sema 结构。sema 只在 comptime 语句 / const 初始化 /
-// @import 等点调用这里；未实现时统一返回 NotConst（= 放弃折叠，不报错）。
-//
-// 分块编译相关：eval 未来的产物是「编译期生成的声明」，统一经 DeclSink 登记，
-// 由驱动在固定点循环里插入并触发重跑；eval 自己不直接改 sema 表，避免重入。
 
 type .{ .Error } = @import("utils/error.spl");
 type .{ .Vec } = @import("utils/vec.spl");
 type Ast = @import("./ast.spl");
 type Diag = @import("./diag.spl");
 
-// 编译期值：占位。未来扩展为 BigInt / 聚合 / 类型句柄等。
+// 编译期值（当前仅标量）。
 type EvalValue = enum {
-    Int: usize, // TODO: BigInt
+    Int: usize,
     Bool: bool,
 }
 
@@ -36,14 +30,13 @@ type DeclSinkResult = enum {
     Err: Error,
 }
 
-// 求值上下文（借用 sink 与 diag；本轮不持有所有权）。
+// 求值上下文：sink/diag 均借用，不持有所有权。
 type Eval = @self;
 
 sink: *DeclSink, // 借用，可为 null
 diag: *Diag,     // 借用，可为 null
-enabled: bool,   // false = 完全不求值（等价旧行为）
+enabled: bool,   // false = 完全不求值
 
-// ---- DeclSink ----
 
 fn sink_new(): DeclSinkResult {
     var s = DeclSink { .items = Vec.blank(@sizeof(usize), @alignof(usize)) };
@@ -66,7 +59,6 @@ fn sink_len(self: *DeclSink): usize {
     ret self.items.len;
 }
 
-// ---- Eval ----
 
 fn new(sink: *DeclSink, diag: *Diag, enabled: bool): Eval {
     ret Eval {
@@ -80,25 +72,24 @@ fn is_enabled(self: *Eval): bool {
     ret self.enabled;
 }
 
-// 求值一个表达式。本轮一律 NotConst（可由调用方作为「放弃折叠」处理）。
+// 求值表达式：当前一律 NotConst（调用方按“放弃折叠”处理）。
 fn eval_expr(self: *Eval, ast: *Ast, ref: usize): EvalOutcome {
     if !self.enabled { ret .NotConst; }
     ret .NotConst;
 }
 
-// 执行一个 comptime 块（可能产生声明，登记到 sink）。本轮不做。
+// 执行 comptime 块；当前不实现，直接 NotConst。
 fn run_block(self: *Eval, ast: *Ast, ref: usize): EvalOutcome {
     if !self.enabled { ret .NotConst; }
     ret .NotConst;
 }
 
-// 顶层 const 初始化求值。本轮不做。
+// 顶层 const 初始化求值；当前不实现。
 fn eval_const_init(self: *Eval, ast: *Ast, ref: usize): EvalOutcome {
     if !self.enabled { ret .NotConst; }
     ret .NotConst;
 }
 
-// ---- 测试 ----
 
 fn test_sink() {
     var sink: DeclSink = undefined;

stage2/intrin.spl

@@ -1,8 +1,7 @@
 // Expect retcode = 0
 
-// 内建（intrinsic）注册表（移植自 stage1/spl_intrin.c）。表是数据：按 kind 查
+// 内建注册表：按 Intrin 查描述信息，按名字/字段/`as` 规则反查 Intrin。新增内建只改
-// 描述信息，按名字/字段/`as` 转换规则反查 kind。新增内建只改 info_at，
+// info_at，不改 sema 逻辑（SPL.md 的 @/# 扩展点）。
-// 不改 sema 逻辑（对应 SPL.md 的 @/# 扩展点）。
 
 type .{ .ByteView } = @import("utils/byte_view.spl");
 type TypeTable = @import("./type_table.spl");
@@ -63,7 +62,7 @@ fn kind_is(a: LangKind, b: LangKind): bool {
     ret @enum2int(a) == @enum2int(b);
 }
 
-// 与 stage1 表逐项对应（枚举顺序即 kind 数值）。
+// 枚举顺序即 kind 数值（与 splc0 表一致）。
 fn info_at(index: usize): IntrinInfo {
     match index {
         1 => {
@@ -161,10 +160,7 @@ fn table_count(): usize {
 
 fn strip_at(name: ByteView): ByteView {
     if name.len > 0 && name.ptr[0] == '@' {
-        match ByteView.slice(name, 1, name.len) {
+        ret ByteView { .ptr = name.ptr + 1, .len = name.len - 1 };
-            .Ok(rest) => { ret rest; },
-            .Err(error) => { ret name; },
-        }
     }
     ret name;
 }
@@ -253,7 +249,6 @@ fn lookup_cast(ir: *TypeTable, ft: usize, tt: usize): Intrin {
     ret .None;
 }
 
-// ---- 测试 ----
 
 fn test_info_table() {
     var d = info(.Sizeof);

stage2/ir.spl

@@ -1,10 +1,7 @@
 // Expect retcode = 0
 
-// SIR 中间表示（移植自 stage1/spl_ir.c/.h）。节点用 arena 序号引用（0 = error），
+// SIR 中间表示：节点用 arena 序号引用（0=error），按函数分桶；公共字段在 IrEntry，
-// 按函数分桶。节点公共字段（kind/dbg/attrs）在外层 entry，kind 专属载荷在 ADT
+// kind 专属载荷在 IrBody ADT（kind 与载荷一一对应）。builder 负责发射与跳转回填。
-// IrBody；kind 与载荷变体一一对应（多种 kind 可共享同一载荷形状）。
-//
-// builder 维护当前函数/基本块/fixup 表，负责发射节点与回填跳转。
 
 type .{ .Error } = @import("utils/error.spl");
 type .{ .Vec } = @import("utils/vec.spl");
@@ -82,6 +79,14 @@ type ConstLit = enum {
     Float: f64,
     Char: u8,
     Fn: usize,
+    Global: usize, // 全局变量下标（Ir.globals）；值 = 指向该全局的 *T
+}
+
+// 模块级全局变量：编译期分配的静态存储，引用时是一个 *T 指针常量（同 LLVM GlobalVariable）。
+type Global = struct {
+    tid: usize,
+    zero: bool, // true = 零初始化（BSS，不携带字节）
+    data: Vec,  // u8 初始字节（zero=false 时使用）
 }
 
 type IrBody = enum {
@@ -128,8 +133,8 @@ type IrFunc = struct {
 type Ir = @self;
 
 funcs: Vec, // IrFunc
+globals: Vec, // Global
 
-// ---- 生命周期 ----
 
 fn new_entry(): IrEntry {
     ret IrEntry {
@@ -141,7 +146,8 @@ fn new_entry(): IrEntry {
 }
 
 fn new(): Ir {
-    var ir = Ir { .funcs = Vec.blank(@sizeof(IrFunc), @alignof(IrFunc)) };
+    var ir = Ir { .funcs = Vec.blank(@sizeof(IrFunc), @alignof(IrFunc)),
+                  .globals = Vec.blank(@sizeof(Global), @alignof(Global)) };
     var sentinel = IrFunc {
         .name = ByteView.empty(),
         .attrs = Vec.blank(@sizeof(usize), @alignof(usize)),
@@ -149,8 +155,8 @@ fn new(): Ir {
         .nodes = Vec.blank(@sizeof(IrEntry), @alignof(IrEntry)),
     };
     var sn = new_entry();
-    match Vec.push(&sentinel.nodes, &sn as *u8) { .Ok => {}, .Err(error) => {} }
+    Vec.push(&sentinel.nodes, &sn as *u8);
-    match Vec.push(&ir.funcs, &sentinel as *u8) { .Ok => {}, .Err(error) => {} }
+    Vec.push(&ir.funcs, &sentinel as *u8);
     ret ir;
 }
 
@@ -167,29 +173,38 @@ fn drop_body(body: IrBody) {
 fn drop(self: *Ir) {
     var i: usize = 0;
     while i < self.funcs.len {
-        match Vec.get(&self.funcs, i) {
+        var f = (self.funcs.data as *IrFunc) + i;
-            .Ok(ptr) => {
-                var f = ptr as *IrFunc;
         var j: usize = 0;
         while j < f.nodes.len {
-                    match Vec.get(&f.nodes, j) {
+            var e = (f.nodes.data as *IrEntry) + j;
-                        .Ok(np) => {
-                            var e = np as *IrEntry;
             Vec.drop(&e.attrs);
             drop_body(e.body);
-                        },
-                        .Err(error) => {},
-                    }
             j = j + 1;
         }
         Vec.drop(&f.attrs);
         Vec.drop(&f.nodes);
-            },
-            .Err(error) => {},
-        }
         i = i + 1;
     }
     Vec.drop(&self.funcs);
+    var g: usize = 0;
+    while g < self.globals.len {
+        var ge = (self.globals.data as *Global) + g;
+        Vec.drop(&ge.data);
+        g = g + 1;
+    }
+    Vec.drop(&self.globals);
+}
+
+// 追加一个全局变量；返回其下标（gidx）。bytes 的所有权转移进表。
+fn add_global(self: *Ir, tid: usize, zero: bool, bytes: Vec): usize {
+    var g = Global { .tid = tid, .zero = zero, .data = bytes };
+    match Vec.push(&self.globals, &g as *u8) { .Ok => {}, .Err(error) => { ret 0; } }
+    ret self.globals.len - 1;
+}
+
+fn global_at(self: *Ir, gidx: usize): *Global {
+    if gidx >= self.globals.len { ret null; }
+    ret (self.globals.data as *Global) + gidx;
 }
 
 fn alloc_fn(self: *Ir): usize {
@@ -207,36 +222,22 @@ fn alloc_fn(self: *Ir): usize {
 
 fn alloc_node(self: *Ir, fn_id: usize): usize {
     if fn_id == 0 || fn_id >= self.funcs.len { ret 0; }
-    match Vec.get(&self.funcs, fn_id) {
+    var f = (self.funcs.data as *IrFunc) + fn_id;
-        .Ok(ptr) => {
-            var f = ptr as *IrFunc;
     var n = new_entry();
     match Vec.push(&f.nodes, &n as *u8) { .Ok => {}, .Err(error) => { ret 0; } }
     ret f.nodes.len - 1;
-        },
-        .Err(error) => {},
-    }
-    ret 0;
 }
 
 fn func(self: *Ir, fn_id: usize): *IrFunc {
     if fn_id == 0 || fn_id >= self.funcs.len { ret null; }
-    match Vec.get(&self.funcs, fn_id) {
+    ret (self.funcs.data as *IrFunc) + fn_id;
-        .Ok(ptr) => { ret ptr as *IrFunc; },
-        .Err(error) => { ret null; },
-    }
-    ret null;
 }
 
 fn node(self: *Ir, fn_id: usize, node_id: usize): *IrEntry {
     var f = func(self, fn_id);
     if f == null { ret null; }
     if node_id == 0 || node_id >= f.nodes.len { ret null; }
-    match Vec.get(&f.nodes, node_id) {
+    ret (f.nodes.data as *IrEntry) + node_id;
-        .Ok(ptr) => { ret ptr as *IrEntry; },
-        .Err(error) => { ret null; },
-    }
-    ret null;
 }
 
 fn kind_name(kind: IrKind): []u8 {
@@ -302,7 +303,6 @@ fn kind_name(kind: IrKind): []u8 {
     ret "?";
 }
 
-// ---- dump ----
 
 fn out_str(out: *ByteBuffer, s: []u8): bool {
     match ByteBuffer.append(out, s) { .Ok => { ret true; }, .Err(error) => { ret false; } }
@@ -345,8 +345,8 @@ fn dump_attrs(out: *ByteBuffer, attr: *Attr, ids: Vec): bool {
 }
 
 fn list_at(v: Vec, i: usize): usize {
-    match Vec.get(&v, i) { .Ok(p) => { ret (p as *usize).*; }, .Err(e) => { ret 0; } }
+    if i >= v.len { ret 0; }
-    ret 0;
+    ret ((v.data as *usize) + i).*;
 }
 
 fn dump_body(out: *ByteBuffer, ty: *TypeTable, e: *IrEntry): bool {
@@ -355,11 +355,10 @@ fn dump_body(out: *ByteBuffer, ty: *TypeTable, e: *IrEntry): bool {
         .Arith(a) => {
             if !dump_type(out, ty, a.tid) { ret false; }
             if !dump_ref(out, a.left) { ret false; }
-            // 一元 arith（neg/abs/not）不打印 right（镜像 stage1）。
+            // 一元 arith（neg/abs/not）不打印 right。
-            if @enum2int(e.kind) == @enum2int(IrKind.ArithNeg) ||
+            match e.kind {
-               @enum2int(e.kind) == @enum2int(IrKind.ArithAbs) ||
+                .ArithNeg, .ArithAbs, .ArithNot => { ret true; },
-               @enum2int(e.kind) == @enum2int(IrKind.ArithNot) {
+                _ => {},
-                ret true;
             }
             ret dump_ref(out, a.right);
         },
@@ -418,6 +417,13 @@ fn dump_body(out: *ByteBuffer, ty: *TypeTable, e: *IrEntry): bool {
         },
         .Const(c) => {
             if !dump_type(out, ty, c.tid) { ret false; }
+            match c.lit {
+                .Global(g) => {
+                    if !out_str(out, " global#") { ret false; }
+                    ret out_u(out, g);
+                },
+                _ => {},
+            }
             var te = TypeTable.node(ty, c.tid);
             var is_float = false;
             var is_fn = false;
@@ -453,7 +459,7 @@ fn dump_body(out: *ByteBuffer, ty: *TypeTable, e: *IrEntry): bool {
                 match ByteBuffer.append_byte(out, cv as u8) { .Ok => {}, .Err(error) => { ret false; } }
                 ret out_str(out, "'");
             }
-            // stage1 对其他常量统一按 int_lit 打印（union 别名）。
+            // 其他常量统一按 int_lit 打印（union 别名）。
             var iv: usize = 0;
             match c.lit {
                 .Int(v) => { iv = v; },
@@ -570,7 +576,6 @@ fn dump(self: *Ir, ty: *TypeTable, attr: *Attr, out: *ByteBuffer): bool {
     ret true;
 }
 
-// ---- 测试 ----
 
 fn test_kinds() {
     @assert(ByteView.eq(ByteView.from_slice(kind_name(.ArithAdd)), ByteView.from_slice("arith.add")),

stage2/ir2vm.spl

@@ -1,11 +1,7 @@
 // Expect retcode = 0
 
-// IR -> VM 机器码（移植自 stage1/spl_ir2vm.c）。
+// IR -> VM 字节码。extern_native 是按函数 ref 下标的 isize 数组：-1 非 extern，
-// 依赖：IR（ir.spl）、IR 类型表（type_table.spl）、布局（layout.spl）、
+// >=0 为 native 索引。
-// 属性（attr.spl）、字节码容器（mcode.spl）。
-//
-// extern_native 用「按函数 ref 下标的 isize 数组」代替 stage1 的 map：
-// 默认 -1 表示非 extern，>=0 表示 native 索引（语义等价）。
 
 type .{ .Vec } = @import("utils/vec.spl");
 type .{ .ByteView } = @import("utils/byte_view.spl");
@@ -16,10 +12,10 @@ type .{ .Layout } = @import("./layout.spl");
 type AttrM = @import("./attr.spl");
 type .{ .Attr, .AttrArg } = @import("./attr.spl");
 type IrM = @import("./ir.spl");
-type .{ .Ir, .IrFunc, .IrEntry } = @import("./ir.spl");
+type .{ .Ir, .IrFunc, .IrEntry, .Global } = @import("./ir.spl");
 type Mcode = @import("./mcode.spl");
 type .{ .Prog, .Op, .VmKind, .VmIns, .VmFunc } = @import("./mcode.spl");
-type Mem = @import("sys/mem.spl");
+type Mem = @import("utils/memory.spl");
 
 type Ir2Vm = @self;
 
@@ -28,9 +24,9 @@ ty: *TypeTable,
 attr: *Attr,
 layout: *Layout,
 extern_native: Vec, // isize
+global_gaddr: Vec,  // usize：每个全局变量在 prog.gdata 的下标
 prog: Prog,
 
-// ---- 类型/布局查询 ----
 
 fn info_of(ctx: *Ir2Vm, tid: usize): *LayoutM.LayoutInfo {
     ret LayoutM.info_of(ctx.layout, tid);
@@ -186,7 +182,6 @@ fn ir_result_tid(ctx: *Ir2Vm, n: *IrEntry): usize {
     ret 0;
 }
 
-// ---- 小工具 ----
 
 // 内部热路径：假定索引有效，直接取址（省去 Vec.get/valid）。
 fn usize_at(v: *Vec, i: usize): usize {
@@ -194,7 +189,7 @@ fn usize_at(v: *Vec, i: usize): usize {
 }
 
 fn push_usize(v: *Vec, x: usize) {
-    ignore_bool(Vec.push_raw(v, &x as *u8));
+    Vec.push_raw(v, &x as *u8);
 }
 
 fn fnode(f: *IrFunc, i: usize): *IrEntry {
@@ -238,7 +233,6 @@ fn const_fn(n: *IrEntry): usize {
     ret 0;
 }
 
-// ---- extern ----
 
 fn fn_check_extern(ctx: *Ir2Vm, f: *IrFunc): bool {
     if ctx.attr == null || f == null { ret false; }
@@ -274,7 +268,6 @@ fn extern_set(ctx: *Ir2Vm, ref: usize, value: isize) {
     }
 }
 
-// ---- 帧布局 ----
 
 type Slot = struct {
     result_off: usize,
@@ -362,7 +355,7 @@ fn frame_build(fl: *FrameLayout, ctx: *Ir2Vm, fid: usize) {
     var i: usize = 0;
     while i < n {
         var blank: Slot = .{ .result_off = 0, .data_off = 0 };
-        match Vec.push(&fl.slots, &blank as *u8) { .Ok => {}, .Err(error) => {} }
+        Vec.push_raw(&fl.slots, &blank as *u8);
         i = i + 1;
     }
 
@@ -396,7 +389,6 @@ fn frame_drop(fl: *FrameLayout) {
     Vec.drop(&fl.slots);
 }
 
-// ---- cgen ----
 
 type FixKind = enum {
     Jmp,
@@ -421,7 +413,17 @@ fixups: *Vec,
 terminated: bool,
 
 fn emit(cg: *Cgen, op: Op, ty: VmKind, imm: usize) {
-    ignore_usize(Mcode.add_instr(&cg.ctx.prog, op, ty, imm));
+    var prog = &cg.ctx.prog;
+    var i = prog.insns.len;
+    if i < prog.insns.cap {
+        var p = (prog.insns.data as *VmIns) + i;
+        p.opcode = op;
+        p.ty = ty;
+        p.imm = imm;
+        prog.insns.len = i + 1;
+        ret;
+    }
+    Mcode.add_instr(prog, op, ty, imm);
 }
 
 fn ip_of(cg: *Cgen): usize {
@@ -445,20 +447,20 @@ fn cg_swap(cg: *Cgen) { emit(cg, .Swap, .Void, 0); }
 fn cg_gaddr(cg: *Cgen, idx: usize) { emit(cg, .Gaddr, .Void, idx); }
 
 fn cg_load_slot(cg: *Cgen, ref: usize, k: VmKind) {
-    cg_laddr(cg, slot_result(&cg.frame, ref));
+    emit(cg, .Laddr, .Void, slot_result(&cg.frame, ref));
-    cg_load(cg, k);
+    emit(cg, .Load, k, 0);
 }
 
 fn cg_store_slot(cg: *Cgen, ref: usize, k: VmKind) {
-    cg_laddr(cg, slot_result(&cg.frame, ref));
+    emit(cg, .Laddr, .Void, slot_result(&cg.frame, ref));
-    cg_swap(cg);
+    emit(cg, .Swap, .Void, 0);
-    cg_store(cg, k);
+    emit(cg, .Store, k, 0);
 }
 
 fn cg_store_at(cg: *Cgen, addr: usize, k: VmKind) {
-    cg_laddr(cg, addr);
+    emit(cg, .Laddr, .Void, addr);
-    cg_swap(cg);
+    emit(cg, .Swap, .Void, 0);
-    cg_store(cg, k);
+    emit(cg, .Store, k, 0);
 }
 
 type DataLoc = struct {
@@ -523,7 +525,7 @@ fn cg_add_fix(cg: *Cgen, ins_idx: usize, kind: FixKind, node_target: usize, fn_t
         .node_target = node_target,
         .fn_target = fn_target,
     };
-    match Vec.push(cg.fixups, &fx as *u8) { .Ok => {}, .Err(error) => {} }
+    Vec.push(cg.fixups, &fx as *u8);
 }
 
 fn arith_tid(n: *IrEntry): usize {
@@ -579,6 +581,23 @@ fn cg_const(cg: *Cgen, ref: usize, n: *IrEntry) {
     var te = TypeTable.node(ctx.ty, tid);
     if te == null { ret; }
 
+    // 全局变量引用：Const{ lit = Global(gidx) } → GADDR（该全局的运行时地址）。
+    match n.body {
+        .Const(c) => {
+            match c.lit {
+                .Global(g) => {
+                    var di: usize = 0;
+                    if g < ctx.global_gaddr.len { di = (ctx.global_gaddr.data as *usize)[g]; }
+                    emit(cg, .Gaddr, .Void, di);
+                    cg_store_slot(cg, ref, .Ptr);
+                    ret;
+                },
+                _ => {},
+            }
+        },
+        _ => {},
+    }
+
     match te.node {
         .Fn(f) => {
             var cref = const_fn(n);
@@ -610,6 +629,7 @@ fn cg_const(cg: *Cgen, ref: usize, n: *IrEntry) {
             }
         },
         .Int(x) => { imm = const_usize(n); },
+        .Any => { imm = const_usize(n); },
         .Float => {
             var fv: f64 = 0.0;
             match n.body {
@@ -667,7 +687,7 @@ fn cg_cast(cg: *Cgen, ref: usize, n: *IrEntry) {
             } else if f_bool && t_int {
                 emit(cg, .Zext, .Void, 1);
             }
-            ignore_bool(t_bool);
+            t_bool;
             cg_store_slot(cg, ref, tk);
         },
         _ => {},
@@ -887,10 +907,7 @@ fn cg_control(cg: *Cgen, ref: usize, n: *IrEntry) {
                     cg_load(cg, .Ptr);
                     cg_load_slot(cg, r.val, .Ptr);
                     cg_push(cg, .U64, sz);
-                    var nat = Mcode.get_or_add_native(&ctx.prog, ByteView.from_slice("vm_memcpy"));
+                    emit(cg, .Memcpy, .Void, 0);
-                    cg_push(cg, .U64, nat as usize);
-                    emit(cg, .Ncall, .Void, 3);
-                    emit(cg, .Drop, .Void, 0);
                 }
                 emit(cg, .Ret, .Void, 0);
             } else {
@@ -942,6 +959,9 @@ fn cg_control(cg: *Cgen, ref: usize, n: *IrEntry) {
                     cg_store_slot(cg, ref, rk);
                 }
             } else {
+                /* ABI：实参下方预留 2 个空闲 slot（PAD0/PAD1）。 */
+                cg_push(cg, .U64, 0);
+                cg_push(cg, .U64, 0);
                 var ret_t = cl.tid;
                 var ret_is_sret = ir_is_aggregate(ctx, ret_t);
                 var sret_off: usize = 0;
@@ -1119,7 +1139,6 @@ fn cmp_tid(n: *IrEntry): usize {
     ret 0;
 }
 
-// ---- 翻译 ----
 
 fn translate_function(ctx: *Ir2Vm, fid: usize, all_fixups: *Vec): usize {
     var irf = IrM.func(ctx.ir, fid);
@@ -1143,7 +1162,7 @@ fn translate_function(ctx: *Ir2Vm, fid: usize, all_fixups: *Vec): usize {
 
     var func_ip = ip_of(&cg);
 
-    ignore_usize(Mcode.add_func(&ctx.prog, irf.name, fn_nargs(ctx, irf.fn_tid), func_ip));
+    Mcode.add_func(&ctx.prog, irf.name, fn_nargs(ctx, irf.fn_tid), func_ip);
 
     var local_slots = (cg.frame.frame_bytes - cg.frame.args_bytes + 7) / 8;
     emit(&cg, .Alloc, .Void, local_slots);
@@ -1164,10 +1183,9 @@ fn translate_function(ctx: *Ir2Vm, fid: usize, all_fixups: *Vec): usize {
 
     i = 0;
     while i < local_fixups.len {
-        match Vec.get(&local_fixups, i) {
+        var fx = (local_fixups.data as *Fix) + i;
-            .Ok(ptr) => {
+        match fx.kind {
-                var fx = ptr as *Fix;
+            .Jmp => {
-                if @enum2int(fx.kind) == @enum2int(FixKind.Jmp) {
                 var ins = ins_ptr(&ctx.prog, fx.ins_idx);
                 if ins != null {
                     var target_ip: usize = 0;
@@ -1176,11 +1194,8 @@ fn translate_function(ctx: *Ir2Vm, fid: usize, all_fixups: *Vec): usize {
                     }
                     ins.imm = target_ip - fx.ins_idx - 1;
                 }
-                } else if @enum2int(fx.kind) == @enum2int(FixKind.Fnaddr) {
-                    match Vec.push(all_fixups, ptr as *u8) { .Ok => {}, .Err(error) => {} }
-                }
             },
-            .Err(error) => {},
+            .Fnaddr => { Vec.push(all_fixups, fx as *u8); },
         }
         i = i + 1;
     }
@@ -1191,15 +1206,15 @@ fn translate_function(ctx: *Ir2Vm, fid: usize, all_fixups: *Vec): usize {
     ret func_ip;
 }
 
-// ---- 生命周期 / 入口 ----
 
-// 就地初始化（避免返回含 Prog 的大聚合；对应 stage1 spl_ir2vm_init）。
+// 就地初始化，避免返回含 Prog 的大聚合。
 fn init(ctx: *Ir2Vm, ir: *Ir, ty: *TypeTable, layout: *Layout, attr: *Attr) {
     ctx.ir = ir;
     ctx.ty = ty;
     ctx.attr = attr;
     ctx.layout = layout;
     ctx.extern_native = Vec.blank(@sizeof(isize), @alignof(isize));
+    ctx.global_gaddr = Vec.blank(@sizeof(usize), @alignof(usize));
 
     match Mcode.new() {
         .Ok(v) => { ctx.prog = v; },
@@ -1210,12 +1225,13 @@ fn init(ctx: *Ir2Vm, ir: *Ir, ty: *TypeTable, layout: *Layout, attr: *Attr) {
 fn drop(ctx: *Ir2Vm) {
     Mcode.drop(&ctx.prog);
     Vec.drop(&ctx.extern_native);
+    Vec.drop(&ctx.global_gaddr);
 }
 
 fn run_func(ctx: *Ir2Vm, ref: usize): i32 {
     var all_fixups = Vec.blank(@sizeof(Fix), @alignof(Fix));
     defer { Vec.drop(&all_fixups); }
-    ignore_usize(translate_function(ctx, ref, &all_fixups));
+    translate_function(ctx, ref, &all_fixups);
     ret 0;
 }
 
@@ -1227,7 +1243,7 @@ fn run(ctx: *Ir2Vm): i32 {
     var i: usize = 0;
     while i < n {
         var v: isize = -1;
-        match Vec.push(&ctx.extern_native, &v as *u8) { .Ok => {}, .Err(error) => {} }
+        Vec.push(&ctx.extern_native, &v as *u8);
         i = i + 1;
     }
     i = 1;
@@ -1240,8 +1256,24 @@ fn run(ctx: *Ir2Vm): i32 {
         i = i + 1;
     }
 
+    // 登记全局变量到 prog.gdata（Zero→零填/BSS，Bytes→拷贝），记下运行时下标。
+    var gi: usize = 0;
+    while gi < ctx.ir.globals.len {
+        var g = (ctx.ir.globals.data as *Global) + gi;
+        var gsize = ir_type_size(ctx, g.tid);
+        var didx: usize = 0;
+        if g.zero {
+            didx = Mcode.add_zero_data(&ctx.prog, gsize);
+        } else {
+            didx = Mcode.add_data(&ctx.prog, g.data.data as usize, gsize);
+        }
+        var dv = didx;
+        Vec.push(&ctx.global_gaddr, &dv as *u8);
+        gi = gi + 1;
+    }
+
     // 哨兵：保证真实函数入口地址非零。
-    ignore_usize(Mcode.add_instr(&ctx.prog, .Halt, .Void, 0));
+    Mcode.add_instr(&ctx.prog, .Halt, .Void, 0);
 
     // 预分配指令容量（按 IR 节点数粗略估计），减少逐条 append 的扩容/拷贝。
     var est: usize = 16;
@@ -1251,7 +1283,7 @@ fn run(ctx: *Ir2Vm): i32 {
         if irf != null { est = est + irf.nodes.len * 8 + 32; }
         i = i + 1;
     }
-    match Vec.reserve(&ctx.prog.insns, est) { .Ok => {}, .Err(error) => {} }
+    Vec.reserve(&ctx.prog.insns, est);
 
     // Pass 2：翻译非 extern 函数。
     var fid_ip = Vec.blank(@sizeof(usize), @alignof(usize));
@@ -1317,6 +1349,15 @@ fn dump(ctx: *Ir2Vm, out: *ByteBuffer): bool {
     ret Mcode.dump(&ctx.prog, out);
 }
 
+// 序列化到内存 ByteBuffer（不落盘），供内嵌 VM 直接加载。
+fn encode(ctx: *Ir2Vm, out: *ByteBuffer): bool {
+    match Mcode.encode(&ctx.prog, out) {
+        .Ok => { ret true; },
+        .Err(error) => { ret false; },
+    }
+    ret false;
+}
+
 // 把翻译结果写成 .sir（二进制）。
 fn store(ctx: *Ir2Vm, path: ByteView): bool {
     match Mcode.store(&ctx.prog, path) {
@@ -1326,12 +1367,8 @@ fn store(ctx: *Ir2Vm, path: ByteView): bool {
     ret false;
 }
 
-// ---- 工具 ----
 
-fn ignore_usize(v: usize) {}
-fn ignore_bool(b: bool) {}
 
-// ---- 测试 ----
 
 fn main() {
     var ir = IrM.new();

stage2/ir_builder.spl

@@ -1,7 +1,6 @@
 // Expect retcode = 0
 
-// SIR builder (IrBuilder). Split from ir.spl: stage1 ast2ir
+// IR 构建器：单独成文件，以免 ast2ir 在同文件 @self 嵌套时无限递归。
-// infinitely recurses on same-file @self nesting; cross-file is fine.
 
 type .{ .Error } = @import("utils/error.spl");
 type .{ .Vec } = @import("utils/vec.spl");
@@ -14,12 +13,10 @@ type Ir = @import("./ir.spl");
 type .{ .IrKind, .ConstLit, .IrEntry, .IrFunc, .IrBody } = @import("./ir.spl");
 
 fn list_at(v: Vec, i: usize): usize {
-    match Vec.get(&v, i) { .Ok(p) => { ret (p as *usize).*; }, .Err(e) => { ret 0; } }
+    if i >= v.len { ret 0; }
-    ret 0;
+    ret ((v.data as *usize) + i).*;
 }
 
-// ---- builder ----
-
 type FixKind = enum { BrTrue, BrFalse, Jmp }
 
 type Fix = struct {
@@ -46,13 +43,9 @@ fn builder_alloc(self: *IrBuilder, kind: IrKind): usize {
         e.kind = kind;
         e.dbg = self.dbg;
     }
-    if self.current_block >= self.blocks.len { ret ref; }
+    if self.current_block < self.blocks.len {
-    match Vec.get(&self.blocks, self.current_block) {
+        var slot = (self.blocks.data as *usize) + self.current_block;
-        .Ok(p) => {
-            var slot = p as *usize;
         if slot.* == 0 { slot.* = ref; }
-        },
-        .Err(error) => {},
     }
     ret ref;
 }
@@ -113,26 +106,19 @@ fn fn_begin_at(self: *IrBuilder, fid: usize) {
 fn fn_end(self: *IrBuilder) {
     var k: usize = 0;
     while k < self.fixups.len {
-        match Vec.get(&self.fixups, k) {
+        var fx = (self.fixups.data as *Fix) + k;
-            .Ok(fp) => {
-                var fx = fp as *Fix;
         var e = Ir.node(&self.ir, self.current_fn, fx.node);
         if e != null {
             var target: usize = 0;
             if fx.block < self.blocks.len { target = list_at(self.blocks, fx.block); }
             if target != 0 {
-                        if @enum2int(fx.slot) == @enum2int(FixKind.BrTrue) {
+                match fx.slot {
-                            match e.body { .Br(b) => { b.true_label = target; e.body = .Br(b); }, _ => {} }
+                    .BrTrue => { match e.body { .Br(&b) => { b.true_label = target; }, _ => {} } },
-                        } else if @enum2int(fx.slot) == @enum2int(FixKind.BrFalse) {
+                    .BrFalse => { match e.body { .Br(&b) => { b.false_label = target; }, _ => {} } },
-                            match e.body { .Br(b) => { b.false_label = target; e.body = .Br(b); }, _ => {} }
+                    .Jmp => { match e.body { .Jmp(&j) => { j.label = target; }, _ => {} } },
-                        } else {
-                            match e.body { .Jmp(j) => { j.label = target; e.body = .Jmp(j); }, _ => {} }
                 }
             }
         }
-            },
-            .Err(error) => {},
-        }
         k = k + 1;
     }
     self.current_block = 0;
@@ -143,7 +129,7 @@ fn fn_end(self: *IrBuilder) {
 
 fn block_begin(self: *IrBuilder): usize {
     var zero: usize = 0;
-    match Vec.push(&self.blocks, &zero as *u8) { .Ok => {}, .Err(error) => {} }
+    Vec.push(&self.blocks, &zero as *u8);
     var block = self.blocks.len - 1;
     self.current_block = block;
     self.terminated = false;
@@ -151,10 +137,9 @@ fn block_begin(self: *IrBuilder): usize {
 }
 
 fn block_end(self: *IrBuilder) {
-    // terminated 与空块校验在 stage1 为 Panic；这里保持同样约束但不终止进程。
+    // 空实现：本实现不做 terminated/空块校验（不终止进程）。
 }
 
-// ---- arith / cmp / cast ----
 
 fn set_arith(self: *IrBuilder, kind: IrKind, tid: usize, left: usize, right: usize): usize {
     var ref = builder_alloc(self, kind);
@@ -211,7 +196,6 @@ fn cast_bool2int(self: *IrBuilder, f: usize, t: usize, v: usize): usize { ret se
 fn case_int2float(self: *IrBuilder, f: usize, t: usize, v: usize): usize { ret set_cast(self, .CaseInt2float, f, t, v); }
 fn case_float2int(self: *IrBuilder, f: usize, t: usize, v: usize): usize { ret set_cast(self, .CaseFloat2int, f, t, v); }
 
-// ---- memory ----
 
 fn mem_alloca(self: *IrBuilder, tid: usize, count: usize): usize {
     var ref = builder_alloc(self, .MemAlloca);
@@ -269,7 +253,6 @@ fn mem_set(self: *IrBuilder, tid: usize, dst: usize, val: usize, size: usize): u
     ret ref;
 }
 
-// ---- type const ----
 
 fn const_node(self: *IrBuilder, tid: usize, lit: ConstLit): usize {
     var ref = builder_alloc(self, .TypeConst);
@@ -285,8 +268,13 @@ fn type_const_float(self: *IrBuilder, tid: usize, val: f64): usize { ret const_n
 fn type_const_char(self: *IrBuilder, tid: usize, val: u8): usize { ret const_node(self, tid, .Char(val)); }
 fn type_const_fn(self: *IrBuilder, tid: usize, val: usize): usize { ret const_node(self, tid, .Fn(val)); }
 fn type_const_bytes(self: *IrBuilder, tid: usize, data: usize): usize { ret const_node(self, tid, .Ptr(data)); }
+fn type_const_global(self: *IrBuilder, tid: usize, gidx: usize): usize { ret const_node(self, tid, .Global(gidx)); }
+
+// 追加模块级全局变量；返回 gidx。bytes 所有权转移进 Ir。
+fn add_global(self: *IrBuilder, tid: usize, zero: bool, bytes: Vec): usize {
+    ret Ir.add_global(&self.ir, tid, zero, bytes);
+}
 
-// ---- type ops ----
 
 fn type_bitsizeof(self: *IrBuilder, tid: usize): usize {
     var ref = builder_alloc(self, .TypeBitsizeof);
@@ -323,7 +311,6 @@ fn type_field_count(self: *IrBuilder, tid: usize): usize {
     ret ref;
 }
 
-// ---- agg ----
 
 fn agg_construct(self: *IrBuilder, tid: usize): usize {
     var ref = builder_alloc(self, .AggConstruct);
@@ -337,12 +324,8 @@ fn agg_construct(self: *IrBuilder, tid: usize): usize {
 fn agg_construct_field(self: *IrBuilder, node_ref: usize, field: usize) {
     var e = Ir.node(&self.ir, self.current_fn, node_ref);
     if e == null { ret; }
-    // 载荷按值绑定：改副本后写回。
     match e.body {
-        .AggConstruct(a) => {
+        .AggConstruct(&a) => { Vec.push(&a.fields, &field as *u8); },
-            match Vec.push(&a.fields, &field as *u8) { .Ok => {}, .Err(error) => {} }
-            e.body = .AggConstruct(a);
-        },
         _ => {},
     }
 }
@@ -363,7 +346,6 @@ fn agg_insert(self: *IrBuilder, tid: usize, field_idx: usize, agg: usize, field:
     ret ref;
 }
 
-// ---- control ----
 
 fn control_select(self: *IrBuilder, tid: usize, cond: usize, tv: usize, fv: usize): usize {
     var ref = builder_alloc(self, .ControlSelect);
@@ -382,9 +364,9 @@ fn control_br(self: *IrBuilder, cond: usize): usize {
 
 fn control_br_fixup(self: *IrBuilder, ref: usize, true_block: usize, false_block: usize) {
     var f1 = Fix { .node = ref, .slot = .BrTrue, .block = true_block };
-    match Vec.push(&self.fixups, &f1 as *u8) { .Ok => {}, .Err(error) => {} }
+    Vec.push(&self.fixups, &f1 as *u8);
     var f2 = Fix { .node = ref, .slot = .BrFalse, .block = false_block };
-    match Vec.push(&self.fixups, &f2 as *u8) { .Ok => {}, .Err(error) => {} }
+    Vec.push(&self.fixups, &f2 as *u8);
 }
 
 fn control_jmp(self: *IrBuilder): usize {
@@ -397,7 +379,7 @@ fn control_jmp(self: *IrBuilder): usize {
 
 fn control_jmp_fixup(self: *IrBuilder, ref: usize, target_block: usize) {
     var fx = Fix { .node = ref, .slot = .Jmp, .block = target_block };
-    match Vec.push(&self.fixups, &fx as *u8) { .Ok => {}, .Err(error) => {} }
+    Vec.push(&self.fixups, &fx as *u8);
 }
 
 fn control_call(self: *IrBuilder, tid: usize, fn_ref: usize): usize {
@@ -413,12 +395,8 @@ fn control_call(self: *IrBuilder, tid: usize, fn_ref: usize): usize {
 fn control_call_param(self: *IrBuilder, call_node: usize, arg: usize) {
     var e = Ir.node(&self.ir, self.current_fn, call_node);
     if e == null { ret; }
-    // 载荷按值绑定：改副本后写回。
     match e.body {
-        .Call(c) => {
+        .Call(&c) => { Vec.push(&c.params, &arg as *u8); },
-            match Vec.push(&c.params, &arg as *u8) { .Ok => {}, .Err(error) => {} }
-            e.body = .Call(c);
-        },
         _ => {},
     }
 }

stage2/lang_type.spl

@@ -1,15 +1,11 @@
 // Expect retcode = 0
 
-// 语言类型表（移植自 stage1/spl_lang_type.c）：在 IR 类型表（type_table.spl）
+// 语言类型表：在 IR 类型表之上登记「语言层类型」（IR 类型 id + 种类 + 聚合成员），
-// 之上，登记「语言层类型」= IR 类型 id + 语言种类 + 聚合方法表，同样 hash-consing。
+// 按结构 hash-consing。sema 的 resolved_lang_tid / def.lang_id 都指向这里。
-// 另持有声明句柄表（def.spl）与语言类型子类型/求交/字面量适配。
-//
-// 语言类型是 sema 的主类型：AST 节点 resolved_lang_tid、def.lang_id 都指这里。
-// 名称/方法名是 ByteView（借用）；聚合方法表与 tuple/fn 的载荷 Vec 由本表拥有。
 
 type .{ .Error } = @import("utils/error.spl");
 type .{ .Vec } = @import("utils/vec.spl");
-type .{ .Map } = @import("utils/map.spl");
+type .{ .Map, .hash_kind_usize } = @import("utils/map.spl");
 type .{ .ByteView } = @import("utils/byte_view.spl");
 type .{ .ByteBuffer } = @import("utils/byte_buffer.spl");
 type .{ .append_usize } = @import("utils/fmt.spl");
@@ -77,7 +73,6 @@ type LangTypeResult = enum {
     Err: Error,
 }
 
-// ---- 小工具 ----
 
 fn seed(): usize {
     ret 14695981039346656037;
@@ -142,7 +137,6 @@ fn elem_of(entry: LangEntry): usize {
     ret 0;
 }
 
-// ---- 生命周期 ----
 
 fn new_entry(kind: LangKind, ir_type_id: usize): LangEntry {
     ret LangEntry {
@@ -183,7 +177,7 @@ fn new(): LangTypeResult {
         .ir = ir,
         .lang_table = lang_table,
         .fold = Map.new(@sizeof(usize), @alignof(usize), @sizeof(usize), @alignof(usize),
-                        hash_usize, eq_usize),
+                        hash_kind_usize()),
         .defs = defs,
         .owned_names = Vec.blank(@sizeof(ByteBuffer), @alignof(ByteBuffer)),
     };
@@ -215,14 +209,10 @@ fn drop(self: *LangType) {
     TypeTable.drop(&self.ir);
 }
 
-// id 0 与越界返回 null（对应 stage1 spl_lang_type_node）。
+// id 0 与越界返回 null。
 fn lang_node(self: *LangType, id: usize): *LangEntry {
     if id == 0 || id >= self.lang_table.len { ret null; }
-    match Vec.get(&self.lang_table, id) {
+    ret (self.lang_table.data as *LangEntry) + id;
-        .Ok(ptr) => { ret ptr as *LangEntry; },
-        .Err(error) => { ret null; },
-    }
-    ret null;
 }
 
 fn ir_type(self: *LangType, lang_id: usize): usize {
@@ -235,7 +225,6 @@ fn get_ir_type(self: *LangType, lang_id: usize): usize {
     ret ir_type(self, lang_id);
 }
 
-// ---- IR 类型槽位预留（自引用聚合）----
 
 fn reserve_ir(self: *LangType): usize {
     ret TypeTable.reserve(&self.ir);
@@ -245,7 +234,6 @@ fn define_ir(self: *LangType, id: usize, src: *TypeNode) {
     TypeTable.define(&self.ir, id, src);
 }
 
-// ---- def 便捷封装（sema 侧只用 LangType）----
 
 fn alloc_def(self: *LangType, kind: DefKind, name: ByteView, span: Span, owner: *any,
              ast_node_ref: usize): usize {
@@ -270,7 +258,6 @@ fn def_is_type(self: *LangType, id: usize): bool {
     ret DefTable.is_type_kind(d.kind);
 }
 
-// ---- intern ----
 
 fn free_extra(e: *LangEntry) {
     match e.extra {
@@ -427,10 +414,7 @@ fn fold_insert(self: *LangType, hash: usize, id: usize) {
     var e = lang_node(self, id);
     if e == null { ret; }
     e.hash_next = old;
-    match Map.put(&self.fold, &hash as *u8, &id as *u8) {
+    Map.put(&self.fold, &hash as *u8, &id as *u8);
-        .Ok => {},
-        .Err(error) => {},
-    }
 }
 
 // intern 一个 probe：命中释放载荷并返回已有 id；否则复制入表。probe 返回后失效。
@@ -464,7 +448,6 @@ fn push_simple(self: *LangType, kind: LangKind, ir: usize): usize {
     ret push(self, &e);
 }
 
-// ---- builders ----
 
 fn make_error(self: *LangType): usize {
     ret push_simple(self, .Error, TypeTable.make_error(&self.ir));
@@ -564,13 +547,10 @@ fn make_range(self: *LangType, elem_lang: usize): usize {
     ret push(self, &e);
 }
 
-// 为 tuple 字段生成稳定的十进制名字（"0"/"1"/...），镜像 stage1。
+// tuple 字段用稳定的十进制名（"0"/"1"/...）。
 fn intern_index_name(self: *LangType, value: usize): ByteView {
     var b = ByteBuffer.new();
-    match append_usize(&b, value, 10, false) {
+    append_usize(&b, value, 10, false);
-        .Ok => {},
-        .Err(error) => {},
-    }
     var view = ByteView.from_slice(ByteBuffer.as_slice(b));
     match Vec.push(&self.owned_names, &b as *u8) {
         .Ok => {},
@@ -650,7 +630,7 @@ fn parse_bits(rest: []u8): usize {
     ret value;
 }
 
-// 内置类型名：bool/void/isize/usize/any/iN/uN/fN（对应 stage1 spl_type_lookup_builtin）。
+// 内置类型名：bool/void/isize/usize/any/iN/uN/fN。
 fn lookup_builtin(self: *LangType, name: ByteView): usize {
     if name.len == 0 { ret 0; }
     if ByteView.eq(name, ByteView.from_slice("bool")) { ret make_bool(self); }
@@ -679,7 +659,6 @@ fn lookup_builtin(self: *LangType, name: ByteView): usize {
     ret 0;
 }
 
-// ---- IR 位宽读取 ----
 
 fn int_bits(self: *LangType, ir_id: usize): usize {
     var te = TypeTable.node(&self.ir, ir_id);
@@ -711,7 +690,6 @@ fn float_bits(self: *LangType, ir_id: usize): usize {
     ret 0;
 }
 
-// ---- 语言层子类型 / 求交 / 字面量适配 ----
 
 fn is_subtype(self: *LangType, sub: usize, super: usize): bool {
     if sub == 0 || super == 0 { ret false; }
@@ -842,7 +820,7 @@ fn int_fits(self: *LangType, target: usize, value: BigInt): bool {
         .Err(error) => { ret false; },
     }
 
-    // 镜像 stage1：目标位宽 >= 64 时不做边界检查（其 mpa 只存低 64 位）。
+    // 目标位宽 >= 64 时不做边界检查（mpa 只存低 64 位）。
     if bits >= 64 { ret true; }
 
     var u: u64 = 0;
@@ -864,7 +842,6 @@ fn int_fits(self: *LangType, target: usize, value: BigInt): bool {
     ret false;
 }
 
-// ---- dump（镜像 stage1 spl_lang_type_dump）----
 
 fn push_out(buf: *ByteBuffer, bytes: []u8): bool {
     match ByteBuffer.append(buf, bytes) {
@@ -902,10 +879,7 @@ fn dump_rec(self: *LangType, id: usize, out: *ByteBuffer, stack: *Vec): bool {
     if e == null {
         if !push_out(out, "none") { ret false; }
         var dropped: usize = 0;
-        match Vec.pop(stack, &dropped as *u8) {
+        Vec.pop(stack, &dropped as *u8);
-            .Ok => {},
-            .Err(error) => {},
-        }
         ret true;
     }
 
@@ -945,7 +919,7 @@ fn dump_rec(self: *LangType, id: usize, out: *ByteBuffer, stack: *Vec): bool {
             if !push_out(out, "[") { ok = false; }
             if ok && !push_usize(out, len) { ok = false; }
             if ok && !push_out(out, "]") { ok = false; }
-            // 镜像 stage1：数组直接 dump IR 类型（会重复一次 [N]）。
+            // 数组直接 dump IR 类型（会重复一次 [N]）。
             if ok { ok = TypeTable.pure_dump(&self.ir, e.ir_type_id, out); }
         },
         .Slice => {
@@ -999,10 +973,7 @@ fn dump_rec(self: *LangType, id: usize, out: *ByteBuffer, stack: *Vec): bool {
     }
 
     var dropped2: usize = 0;
-    match Vec.pop(stack, &dropped2 as *u8) {
+    Vec.pop(stack, &dropped2 as *u8);
-        .Ok => {},
-        .Err(error) => {},
-    }
     ret ok;
 }
 
@@ -1012,7 +983,6 @@ fn dump(self: *LangType, id: usize, out: *ByteBuffer): bool {
     ret dump_rec(self, id, out, &stack);
 }
 
-// ---- 测试 ----
 
 fn expect_text(buf: ByteBuffer, expected: []u8) {
     var got = ByteBuffer.as_slice(buf);

stage2/layout.spl

@@ -1,9 +1,7 @@
 // Expect retcode = 0
 
-// 目标布局（移植自 stage1/spl_layout.c）。输入是 IR 类型表 TypeTable；
+// 目标布局：由 IR 类型表计算 size/align/字段位偏移，供 ir2vm 使用。默认 64 位平台，
-// 为每个类型计算 size_bits / align_bits / 字段位偏移，供 ir2vm 使用。
+// 聚合按最大字段对齐且不重排。
-// 默认 64 位平台：标量按 1/2/4/8 字节对齐，指针 = usize，聚合按最大字段对齐
-// 且不允许重排（与 stage1 的默认策略一致）。
 
 type .{ .Error } = @import("utils/error.spl");
 type .{ .Vec } = @import("utils/vec.spl");
@@ -44,14 +42,10 @@ fn new(): LayoutResult {
 
 fn info_at(self: *Layout, id: usize): *LayoutInfo {
     if id == 0 || id >= self.infos.len { ret null; }
-    match Vec.get(&self.infos, id) {
+    ret (self.infos.data as *LayoutInfo) + id;
-        .Ok(ptr) => { ret ptr as *LayoutInfo; },
-        .Err(error) => { ret null; },
-    }
-    ret null;
 }
 
-// 未解析或越界返回 null（对应 stage1 spl_layout_info_of）。
+// 未解析或越界返回 null。
 fn info_of(self: *Layout, id: usize): *LayoutInfo {
     var info = info_at(self, id);
     if info == null || !info.resolved { ret null; }
@@ -88,10 +82,7 @@ fn ensure(self: *Layout, n: usize) {
 }
 
 fn push_usize(v: *Vec, x: usize) {
-    match Vec.push(v, &x as *u8) {
+    Vec.push(v, &x as *u8);
-        .Ok => {},
-        .Err(error) => {},
-    }
 }
 
 fn usize_at(v: *Vec, i: usize): usize {

stage2/lexer.spl

@@ -1,9 +1,7 @@
 // Expect retcode = 0
 
-// 词法分析器：字节流 -> Vec<Token>。镜像 stage1/spl_lexer.c 的行为：
+// 字节流 -> Vec<Token>。行为镜像 splc0（保证 diff）：行注释作为 token 产出，块注释
-// 行注释作为 token 产出；块注释（可嵌套）整体跳过；换行产出 Endline；EOF 产出 Eof。
+//（可嵌套）跳过，换行产 Endline，EOF 产 Eof。Token.text 借用输入，不复制。
-// 复用 utils/ascii 做字符分类；整型/字符在词法期解码后放进 TokenKind 载荷。
-// Token.text 借用输入字节，不复制。
 
 type .{ .Vec, .VecResult } = @import("utils/vec.spl");
 type .{ .ByteView } = @import("utils/byte_view.spl");
@@ -80,7 +78,6 @@ fn decode_char(text: ByteView): u8 {
     ret e;
 }
 
-// ---- 读取辅助 ----
 
 fn has2(self: *Lexer, ch: u8): bool {
     ret self.pos + 1 < self.src.len && self.src.ptr[self.pos + 1] == ch;
@@ -92,11 +89,8 @@ fn has3(self: *Lexer, ch1: u8, ch2: u8): bool {
 }
 
 fn sub(self: *Lexer, start: usize, end: usize): ByteView {
-    match ByteView.slice(self.src, start, end) {
+    if start >= end { ret ByteView.empty(); }
-        .Ok(v) => { ret v; },
+    ret ByteView { .ptr = self.src.ptr + start, .len = end - start };
-        .Err(error) => { ret ByteView.empty(); },
-    }
-    ret ByteView.empty();
 }
 
 // 产出 token 并把 pos/col 推进到 end。Vec.push 失败视为致命（同 vec.make_vec 风格）。
@@ -123,7 +117,6 @@ fn op3(self: *Lexer, out: *Vec, punct: Punct, start: usize, line: usize, col: us
     emit_to(self, out, .Punct(punct), start, start + 3, line, col);
 }
 
-// ---- 复合扫描 ----
 
 fn scan_int(self: *Lexer, out: *Vec, start: usize, line: usize, col: usize) {
     var p = self.pos;
@@ -456,7 +449,6 @@ fn lex(src: ByteView, diag: *Diag, file: usize): VecResult {
     ret .Ok(out);
 }
 
-// ---- 测试辅助 ----
 
 fn view(text: []u8): ByteView {
     ret ByteView.from_slice(text);

stage2/mcode.spl

@@ -1,28 +1,15 @@
 // Expect retcode = 0
 
-// SPL VM 机器码容器（移植自 stage0/spl_mcode.c 的构建/序列化/dump 部分）。
+// VM 字节码容器：内存中的 Prog 与 .sir 序列化（反序列化在 C 侧 spl_cli）。
-// 只负责「内存中的 prog」与「写入 .sir」，不包含反序列化（由 C 侧 spl_cli 读）。
+// 字符串用 ByteView 借用、不拥有；gdata 条目为 ByteBuffer，由本模块拥有释放。
-//
-// 字符串一律是 ByteView（借用上层 IR/attr 的名称，本模块不复制、不释放）；
-// gdata 条目是 ByteBuffer，由本模块拥有并释放。
-//
-// 二进制格式（元数据字段均为 u64 小端）：
-//   [HEADER]  magic(8) nfuncs(8) ninsns(8) nnatives(8) nstrs(8) ndata(8)
-//   [FUNCS]   每项: name_len(8) name(pad8, 含结尾 NUL) idx_of_strtab(8)
-//                   nargs(8) ninsns(8) address(8)
-//   [INSTRS]  每项: opcode(2) type(2) imm(8) = 12 字节
-//   [NATIVES] 每项: name_len(8) name(pad8, 含结尾 NUL) idx_of_strtab(8)
-//   [STRTAB]  每项: slen(8) str(pad8)
-//   [GDATA]   每项: dsize(8) data(pad8)
 
 type .{ .Error, .Status, .make } = @import("utils/error.spl");
 type .{ .Vec } = @import("utils/vec.spl");
 type .{ .ByteView } = @import("utils/byte_view.spl");
 type .{ .ByteBuffer } = @import("utils/byte_buffer.spl");
 type .{ .append_usize, .append_i64 } = @import("utils/fmt.spl");
-type Mem = @import("sys/mem.spl");
+type Mem = @import("utils/memory.spl");
-type File = @import("sys/file.spl");
+type .{ .open_cstr, .write_all, .read_all, .File } = @import("utils/io.spl");
-type .{ .open_cstr, .write_all, .read_all } = @import("utils/io.spl");
 
 type Op = enum {
     Error,
@@ -72,6 +59,7 @@ type Op = enum {
     Gaddr,
     Load,
     Store,
+    Memcpy,
     Ncall,
     Nlib,
     Bk,
@@ -177,6 +165,7 @@ fn op_name(op: Op): []u8 {
         .Gaddr => { ret "gaddr"; },
         .Load => { ret "load"; },
         .Store => { ret "store"; },
+        .Memcpy => { ret "memcpy"; },
         .Ncall => { ret "ncall"; },
         .Nlib => { ret "nlib"; },
         .Bk => { ret "breakpoint"; },
@@ -206,7 +195,6 @@ fn kind_name(k: VmKind): []u8 {
     ret "???";
 }
 
-// ---- 生命周期 ----
 
 fn new(): ProgResult {
     var prog = Prog {
@@ -262,9 +250,17 @@ fn drop(self: *Prog) {
     Vec.drop(&self.insns);
 }
 
-// ---- 构建 ----
 
 fn add_instr(self: *Prog, op: Op, ty: VmKind, imm: usize): usize {
+    var i = self.insns.len;
+    if i < self.insns.cap {
+        var p = (self.insns.data as *VmIns) + i;
+        p.opcode = op;
+        p.ty = ty;
+        p.imm = imm;
+        self.insns.len = i + 1;
+        ret i + 1;
+    }
     var ins = VmIns { .opcode = op, .ty = ty, .imm = imm };
     if !Vec.push_raw(&self.insns, &ins as *u8) { ret 0; }
     ret self.insns.len;
@@ -295,7 +291,7 @@ fn add_data(self: *Prog, ptr: usize, size: usize): usize {
     }
     if size != 0 {
         if ptr == 0 { ByteBuffer.drop(&entry); ret 0; }
-        ignore_ptr(Mem.copy(entry.storage.data as *any, ptr as *any, size));
+        Mem.copy(entry.storage.data as *any, ptr as *any, size);
         entry.storage.len = size;
     }
     match Vec.push(&self.gdata, &entry as *u8) {
@@ -305,6 +301,26 @@ fn add_data(self: *Prog, ptr: usize, size: usize): usize {
     ret self.gdata.len - 1;
 }
 
+// 追加一条 size 字节的零初始化全局数据（BSS 语义）；返回其索引。
+fn add_zero_data(self: *Prog, size: usize): usize {
+    var entry = ByteBuffer.new();
+    match ByteBuffer.reserve(&entry, size) {
+        .Ok => {},
+        .Err(error) => { ByteBuffer.drop(&entry); ret 0; },
+    }
+    if size != 0 {
+        entry.storage.len = size;
+        var p = entry.storage.data as *u8;
+        var i: usize = 0;
+        while i < size { p[i] = 0; i = i + 1; }
+    }
+    match Vec.push(&self.gdata, &entry as *u8) {
+        .Ok => {},
+        .Err(error) => { ByteBuffer.drop(&entry); ret 0; },
+    }
+    ret self.gdata.len - 1;
+}
+
 // 返回 name 对应的 native 索引；不存在则登记。name 为空指针时返回 -1。
 fn get_or_add_native(self: *Prog, name: ByteView): isize {
     if name.ptr == null { ret -1; }
@@ -322,7 +338,6 @@ fn get_or_add_native(self: *Prog, name: ByteView): isize {
     ret (self.natives.len - 1) as isize;
 }
 
-// ---- dump（输出必须与 stage0 spl_prog_dump 逐字节一致）----
 
 fn out_s(out: *ByteBuffer, s: []u8): bool {
     match ByteBuffer.append(out, s) { .Ok => { ret true; }, .Err(error) => { ret false; } }
@@ -439,21 +454,23 @@ fn dump(self: *Prog, out: *ByteBuffer): bool {
         if !out_s(out, " ") { ret false; }
         if !out_i(out, ins.imm as i64) { ret false; }
 
-        if @enum2int(ins.opcode) == @enum2int(Op.Jmp) ||
+        match ins.opcode {
-           @enum2int(ins.opcode) == @enum2int(Op.Bz) ||
+            .Jmp, .Bz, .Bnz => {
-           @enum2int(ins.opcode) == @enum2int(Op.Bnz) {
                 if !out_s(out, "  ; -> ") { ret false; }
                 if !out_u(out, i + 1 + ins.imm) { ret false; }
-        } else if @enum2int(ins.opcode) == @enum2int(Op.Call) {
+            },
+            .Call => {
                 if !out_s(out, "  ; nargs=") { ret false; }
                 if !out_u(out, ins.imm) { ret false; }
                 if !out_s(out, ", from stack") { ret false; }
-        } else if @enum2int(ins.opcode) == @enum2int(Op.Calli) {
+            },
-            if !out_s(out, "  ; indirect call") { ret false; }
+            .Calli => { if !out_s(out, "  ; indirect call") { ret false; } },
-        } else if @enum2int(ins.opcode) == @enum2int(Op.Gaddr) {
+            .Gaddr => {
                 if !out_s(out, "  ; gdata[") { ret false; }
                 if !out_u(out, ins.imm) { ret false; }
                 if !out_s(out, "]") { ret false; }
+            },
+            _ => {},
         }
         if !out_s(out, "\n") { ret false; }
         i = i + 1;
@@ -462,11 +479,8 @@ fn dump(self: *Prog, out: *ByteBuffer): bool {
 }
 
 fn ins_at(self: *Prog, i: usize): VmIns {
-    match Vec.get(&self.insns, i) {
+    if i >= self.insns.len { ret VmIns { .opcode = .Error, .ty = .Void, .imm = 0 }; }
-        .Ok(ptr) => { ret (ptr as *VmIns).*; },
+    ret ((self.insns.data as *VmIns) + i).*;
-        .Err(error) => { ret VmIns { .opcode = .Error, .ty = .Void, .imm = 0 }; },
-    }
-    ret VmIns { .opcode = .Error, .ty = .Void, .imm = 0 };
 }
 
 fn func_at(self: *Prog, i: usize): *VmFunc {
@@ -485,47 +499,48 @@ fn str_at(self: *Prog, i: usize): ByteView {
     ret ByteView.empty();
 }
 
-// ---- 序列化 ----
 
 fn align8(n: usize): usize {
     ret (n + 7) & (~(7 as usize));
 }
 
+// put_* 直接写入已预留容量的 ByteBuffer 存储（store 已按精确总大小 reserve），跳过
+// append 的校验/拷贝；容量不足会越界，故 store 先校验容量。
+
 fn put_u8(out: *ByteBuffer, b: u8): bool {
-    match ByteBuffer.append_byte(out, b) { .Ok => { ret true; }, .Err(error) => { ret false; } }
+    out.storage.data[out.storage.len] = b;
-    ret false;
+    out.storage.len = out.storage.len + 1;
+    ret true;
 }
 
+// 直接按小端整型写（x86 小端；VM 的 STORE 用 memcpy，未对齐也安全）。
 fn put_u16(out: *ByteBuffer, v: usize): bool {
-    if !put_u8(out, (v & 255) as u8) { ret false; }
+    var d = out.storage.data + out.storage.len;
-    ret put_u8(out, ((v >> 8) & 255) as u8);
+    (d as *u16).* = v as u16;
+    out.storage.len = out.storage.len + 2;
+    ret true;
 }
 
 fn put_u64(out: *ByteBuffer, v: usize): bool {
-    var i: usize = 0;
+    var d = out.storage.data + out.storage.len;
-    while i < 8 {
+    (d as *u64).* = v as u64;
-        if !put_u8(out, ((v >> (i * 8)) & 255) as u8) { ret false; }
+    out.storage.len = out.storage.len + 8;
-        i = i + 1;
-    }
     ret true;
 }
 
 fn put_zeros(out: *ByteBuffer, n: usize): bool {
-    var i: usize = 0;
+    if n != 0 {
-    while i < n {
+        Mem.set((out.storage.data + out.storage.len) as *any, 0, n);
-        if !put_u8(out, 0) { ret false; }
+        out.storage.len = out.storage.len + n;
-        i = i + 1;
     }
     ret true;
 }
 
 fn put_view(out: *ByteBuffer, v: ByteView): bool {
     if v.len == 0 { ret true; }
-    match ByteBuffer.append(out, ByteView.as_slice(v)) {
+    Mem.copy((out.storage.data + out.storage.len) as *any, v.ptr as *any, v.len);
-        .Ok => { ret true; },
+    out.storage.len = out.storage.len + v.len;
-        .Err(error) => { ret false; },
+    ret true;
-    }
-    ret false;
 }
 
 // 写入「带结尾 NUL、再按 8 对齐」的名称字段（对应 C 侧 nlen = strlen+1）。
@@ -537,12 +552,46 @@ fn put_name_field(out: *ByteBuffer, name: ByteView): bool {
     ret put_zeros(out, align8(nlen) - nlen);
 }
 
-fn store(self: *Prog, path: ByteView): Status {
+// 把 prog 序列化为二进制写入 out（不落盘，供内嵌 VM 直接用）。
-    var out = ByteBuffer.new();
+fn encode(self: *Prog, out: *ByteBuffer): Status {
-    defer { ByteBuffer.drop(&out); }
+    // 精确预估输出大小并一次性预留，避免大文件逐字节增长导致的重复拷贝。
+    var total: usize = 48;
+    var fi: usize = 0;
+    var func_base = self.funcs.data as *VmFunc;
+    var nat_base = self.natives.data as *VmNative;
+    var str_base = self.strtab.data as *ByteView;
+    var gd_base = self.gdata.data as *ByteBuffer;
+    while fi < self.funcs.len {
+        var f = func_base + fi;
+        var nlen = f.name.len + 1;
+        total = total + 8 + align8(nlen) + 32;
+        fi = fi + 1;
+    }
+    total = total + self.insns.len * 12;
+    fi = 0;
+    while fi < self.natives.len {
+        var n = nat_base + fi;
+        var nlen = n.name.len + 1;
+        total = total + 8 + align8(nlen) + 8;
+        fi = fi + 1;
+    }
+    fi = 0;
+    while fi < self.strtab.len {
+        var s = str_base + fi;
+        total = total + 8 + align8(s.len);
+        fi = fi + 1;
+    }
+    fi = 1;
+    while fi < self.gdata.len {
+        var e = gd_base + fi;
+        total = total + 8 + align8(e.storage.len);
+        fi = fi + 1;
+    }
+    ByteBuffer.reserve(out, total);
+    if out.storage.cap < total || out.storage.data == null { ret .Err(make(.Io)); }
 
-    if !put_view(&out, ByteView.from_slice("SPLBIN")) { ret .Err(make(.Io)); }
+    if !put_view(out, ByteView.from_slice("SPLBIN")) { ret .Err(make(.Io)); }
-    if !put_zeros(&out, 2) { ret .Err(make(.Io)); }
+    if !put_zeros(out, 2) { ret .Err(make(.Io)); }
 
     var nfuncs = self.funcs.len;
     var ninsns = self.insns.len;
@@ -551,61 +600,75 @@ fn store(self: *Prog, path: ByteView): Status {
     var ndata: usize = 0;
     if self.gdata.len > 0 { ndata = self.gdata.len - 1; }
 
-    if !put_u64(&out, nfuncs) { ret .Err(make(.Io)); }
+    if !put_u64(out, nfuncs) { ret .Err(make(.Io)); }
-    if !put_u64(&out, ninsns) { ret .Err(make(.Io)); }
+    if !put_u64(out, ninsns) { ret .Err(make(.Io)); }
-    if !put_u64(&out, nnatives) { ret .Err(make(.Io)); }
+    if !put_u64(out, nnatives) { ret .Err(make(.Io)); }
-    if !put_u64(&out, nstrs) { ret .Err(make(.Io)); }
+    if !put_u64(out, nstrs) { ret .Err(make(.Io)); }
-    if !put_u64(&out, ndata) { ret .Err(make(.Io)); }
+    if !put_u64(out, ndata) { ret .Err(make(.Io)); }
 
     var i: usize = 0;
     while i < nfuncs {
-        var f = func_at(self, i);
+        var f = func_base + i;
-        if f == null { ret .Err(make(.Io)); }
+        if !put_name_field(out, f.name) { ret .Err(make(.Io)); }
-        if !put_name_field(&out, f.name) { ret .Err(make(.Io)); }
+        if !put_u64(out, f.idx_of_strtab) { ret .Err(make(.Io)); }
-        if !put_u64(&out, f.idx_of_strtab) { ret .Err(make(.Io)); }
+        if !put_u64(out, f.nargs) { ret .Err(make(.Io)); }
-        if !put_u64(&out, f.nargs) { ret .Err(make(.Io)); }
+        if !put_u64(out, f.ninsns) { ret .Err(make(.Io)); }
-        if !put_u64(&out, f.ninsns) { ret .Err(make(.Io)); }
+        if !put_u64(out, f.address) { ret .Err(make(.Io)); }
-        if !put_u64(&out, f.address) { ret .Err(make(.Io)); }
         i = i + 1;
     }
 
     i = 0;
+    var ins_base = self.insns.data as *VmIns;
+    var out_base = out.storage.data;
+    var out_len = out.storage.len;
     while i < ninsns {
-        var ins = ins_at(self, i);
+        var p = ins_base + i;
-        if !put_u16(&out, @enum2int(ins.opcode) as usize) { ret .Err(make(.Io)); }
+        var d = out_base + out_len;
-        if !put_u16(&out, @enum2int(ins.ty) as usize) { ret .Err(make(.Io)); }
+        (d as *u16).* = @enum2int(p.opcode) as u16;
-        if !put_u64(&out, ins.imm) { ret .Err(make(.Io)); }
+        ((d + 2) as *u16).* = @enum2int(p.ty) as u16;
+        ((d + 4) as *u64).* = p.imm as u64;
+        out_len = out_len + 12;
         i = i + 1;
     }
+    out.storage.len = out_len;
 
     i = 0;
     while i < nnatives {
-        var n = native_at(self, i);
+        var n = nat_base + i;
-        if n == null { ret .Err(make(.Io)); }
+        if !put_name_field(out, n.name) { ret .Err(make(.Io)); }
-        if !put_name_field(&out, n.name) { ret .Err(make(.Io)); }
+        if !put_u64(out, n.idx_of_strtab) { ret .Err(make(.Io)); }
-        if !put_u64(&out, n.idx_of_strtab) { ret .Err(make(.Io)); }
         i = i + 1;
     }
 
     i = 0;
     while i < nstrs {
-        var s = str_at(self, i);
+        var s = str_base + i;
-        if !put_u64(&out, s.len) { ret .Err(make(.Io)); }
+        if !put_u64(out, s.len) { ret .Err(make(.Io)); }
-        if !put_view(&out, s) { ret .Err(make(.Io)); }
+        if !put_view(out, s.*) { ret .Err(make(.Io)); }
-        if !put_zeros(&out, align8(s.len) - s.len) { ret .Err(make(.Io)); }
+        if !put_zeros(out, align8(s.len) - s.len) { ret .Err(make(.Io)); }
         i = i + 1;
     }
 
     i = 1;
     while i < self.gdata.len {
-        var e = gdata_at(self, i);
+        var e = gd_base + i;
-        if e == null { ret .Err(make(.Io)); }
         var dsize = e.storage.len;
-        if !put_u64(&out, dsize) { ret .Err(make(.Io)); }
+        if !put_u64(out, dsize) { ret .Err(make(.Io)); }
-        if !put_view(&out, ByteView.from_slice(ByteBuffer.as_slice(e.*))) { ret .Err(make(.Io)); }
+        if !put_view(out, ByteView.from_slice(ByteBuffer.as_slice(e.*))) { ret .Err(make(.Io)); }
-        if !put_zeros(&out, align8(dsize) - dsize) { ret .Err(make(.Io)); }
+        if !put_zeros(out, align8(dsize) - dsize) { ret .Err(make(.Io)); }
         i = i + 1;
     }
+    ret .Ok;
+}
+
+fn store(self: *Prog, path: ByteView): Status {
+    var out = ByteBuffer.new();
+    defer { ByteBuffer.drop(&out); }
+
+    match encode(self, &out) {
+        .Ok => {},
+        .Err(error) => { ret .Err(error); },
+    }
 
     var f = open_cstr(path, ByteView.from_slice("wb"));
     if !File.valid(&f) { ret .Err(make(.Io)); }
@@ -619,10 +682,12 @@ fn store(self: *Prog, path: ByteView): Status {
     ret .Ok;
 }
 
-fn ignore_ptr(p: *any) {}
+// 序列化到内存缓冲（供内嵌 VM 直接装载）。
-fn ignore_usize(v: usize) {}
+fn serialize(self: *Prog, out: *ByteBuffer): Status {
+    ret encode(self, out);
+}
+
 
-// ---- 测试 ----
 
 fn test_dump_basic() {
     var pr: Prog = undefined;
@@ -632,7 +697,7 @@ fn test_dump_basic() {
     }
     defer { drop(&pr); }
 
-    ignore_usize(add_instr(&pr, .Halt, .Void, 0));
+    add_instr(&pr, .Halt, .Void, 0);
 
     var out = ByteBuffer.new();
     defer { ByteBuffer.drop(&out); }
@@ -680,8 +745,8 @@ fn test_store_roundtrip() {
     }
     defer { drop(&pr); }
 
-    ignore_usize(add_func(&pr, ByteView.from_slice("main"), 0, 0));
+    add_func(&pr, ByteView.from_slice("main"), 0, 0);
-    ignore_usize(add_instr(&pr, .Halt, .Void, 0));
+    add_instr(&pr, .Halt, .Void, 0);
 
     var path = ByteView.from_slice("build/_mcode_roundtrip.tmp");
     match store(&pr, path) {

stage2/parser.spl

@@ -1,7 +1,6 @@
 // Expect retcode = 0
 
-// Parser：token 流 -> Ast（ADT 节点）。C 版只作控制流参考，节点分配顺序需与 stage1
+// token 流 -> Ast。节点分配顺序必须与 splc0 一致，否则 dump 的 #ref 无法逐字节对比。
-// 一致，以保证 dump 的 #ref 可对比。pos 在 token 向量上移动，自动跳过 trivia。
 
 type .{ .Vec } = @import("utils/vec.spl");
 type .{ .ByteView } = @import("utils/byte_view.spl");
@@ -25,6 +24,7 @@ failed: bool,
 stop_agg: i32,
 error_count: usize,
 file: usize, // 当前源文件在 Sources 中的下标
+comptime_depth: usize, // >0 表示处于 comptime 上下文（类型可作为表达式）
 
 fn new(ast: *Ast, toks: Vec, diag: *Diag): Parser {
     ret Parser {
@@ -36,17 +36,14 @@ fn new(ast: *Ast, toks: Vec, diag: *Diag): Parser {
         .stop_agg = 0,
         .error_count = 0,
         .file = 0,
+        .comptime_depth = 0,
     };
 }
 
-// ---- token 访问 ----
 
 fn token_ptr(self: *Parser, index: usize): *Token {
-    match Vec.get(&self.toks, index) {
+    if index >= self.toks.len { ret null; }
-        .Ok(ptr) => { ret ptr as *Token; },
+    ret (self.toks.data as *Token) + index;
-        .Err(error) => { ret null; },
-    }
-    ret null;
 }
 
 fn is_trivia(kind: TokenKind): bool {
@@ -61,16 +58,32 @@ fn is_trivia(kind: TokenKind): bool {
 // 跳过 trivia；返回当前 token（含 EOF）。越界返回 null。
 fn peek(self: *Parser): *Token {
     var n = self.toks.len;
+    var base = self.toks.data as *Token;
     var i = self.pos;
     while i < n {
-        var t = token_ptr(self, i);
+        if base == null { break; }
-        if t == null { break; }
+        var t = base + i;
         if !is_trivia(t.kind) { break; }
         i = i + 1;
     }
     self.pos = i;
-    if i >= n { ret null; }
+    if i >= n || base == null { ret null; }
-    ret token_ptr(self, i);
+    ret base + i;
+}
+
+// 跳过 trivia，返回当前 token 之后的下一个非 trivia token（不移动 pos）。
+fn peek_next(self: *Parser): *Token {
+    var n = self.toks.len;
+    var base = self.toks.data as *Token;
+    var i = self.pos + 1;
+    while i < n {
+        if base == null { break; }
+        var t = base + i;
+        if !is_trivia(t.kind) { break; }
+        i = i + 1;
+    }
+    if i >= n || base == null { ret null; }
+    ret base + i;
 }
 
 fn advance(self: *Parser): *Token {
@@ -123,7 +136,6 @@ fn at_eof(self: *Parser): bool {
     ret false;
 }
 
-// ---- 错误 ----
 
 fn span_of(self: *Parser, tok: *Token): Span {
     if tok == null { ret span_none(); }
@@ -136,7 +148,7 @@ fn parse_error(self: *Parser, tok: *Token, what: []u8) {
     Diag.err(self.diag, span_of(self, tok), .ParseExpected, what);
 }
 
-// 转义解码（镜像 stage1 spl_decode_escape）：去掉引号，处理 \n \t \r \0 \\ \' \" \xHH。
+// 转义解码：去掉引号，处理 \n \t \r \0 \\ \' \" \xHH。
 fn hex_digit(c: u8): u8 {
     if c >= '0' && c <= '9' { ret c - '0'; }
     if c >= 'a' && c <= 'f' { ret (c - 'a') + 10; }
@@ -157,9 +169,7 @@ fn decode_str(t: ByteView): ByteBuffer {
             if e == 'x' && i + 3 < end {
                 var hi = hex_digit(t.ptr[i + 2]);
                 var lo = hex_digit(t.ptr[i + 3]);
-                match ByteBuffer.append_byte(&out, (hi * 16 + lo) as u8) {
+                ByteBuffer.append_byte(&out, (hi * 16 + lo) as u8);
-                    .Ok => {}, .Err(error) => {},
-                }
                 i = i + 4;
             } else {
                 var d: u8 = e;
@@ -167,11 +177,11 @@ fn decode_str(t: ByteView): ByteBuffer {
                 else if e == 't' { d = '\t'; }
                 else if e == 'r' { d = '\r'; }
                 else if e == '0' { d = 0; }
-                match ByteBuffer.append_byte(&out, d) { .Ok => {}, .Err(error) => {} }
+                ByteBuffer.append_byte(&out, d);
                 i = i + 2;
             }
         } else {
-            match ByteBuffer.append_byte(&out, c) { .Ok => {}, .Err(error) => {} }
+            ByteBuffer.append_byte(&out, c);
             i = i + 1;
         }
     }
@@ -188,7 +198,6 @@ fn expect_punct(self: *Parser, punct: Punct, what: []u8): bool {
     ret true;
 }
 
-// ---- 节点 ----
 
 fn new_node(self: *Parser, body: Body, tok: *Token): usize {
     ret Ast.alloc(self.ast, body, span_of(self, tok));
@@ -247,7 +256,6 @@ fn int_token_u64(self: *Parser, tok: *Token, radix: Radix): u64 {
     ret v;
 }
 
-// ---- 判定（stage1 can_start_*）----
 
 fn can_start_expr(kind: TokenKind): bool {
     match kind {
@@ -266,6 +274,8 @@ fn can_start_expr(kind: TokenKind): bool {
                 .Loop => { ret true; },
                 .For => { ret true; },
                 .Match => { ret true; },
+                .Comptime => { ret true; },
+                .Try => { ret true; },
                 _ => { ret false; },
             }
         },
@@ -305,6 +315,7 @@ fn can_start_statement(kind: TokenKind): bool {
                 .Break => { ret true; },
                 .Continue => { ret true; },
                 .Defer => { ret true; },
+                .Errdefer => { ret true; },
                 .Var => { ret true; },
                 .Const => { ret true; },
                 .Type => { ret true; },
@@ -317,11 +328,10 @@ fn can_start_statement(kind: TokenKind): bool {
     ret false;
 }
 
-// ---- 模式（M3.2 子集：ident / _ / .variant / tuple / .{ } ）----
 
 fn parse_pattern_aggregate(self: *Parser, start: *Token): usize {
     if !expect_punct(self, .LBrace, "'{' after '.'") { ret 0; }
-    // stage1 先分配 PATTERN_AGGREGATE，再解析字段。
+    // 先分配 PATTERN_AGGREGATE，再解析字段。
     var ref = new_node(self, .PatternAggregate(.{ .items = ref_vec() }), start);
     var fields = ref_vec();
     while !self.failed {
@@ -336,7 +346,7 @@ fn parse_pattern_aggregate(self: *Parser, start: *Token): usize {
         if name == null { break; }
         match name.kind { .Ident => {}, _ => { break; } }
         advance(self);
-        // stage1 先分配 PATTERN_FIELD，再解析可选子模式。
+        // 先分配 PATTERN_FIELD，再解析可选子模式。
         var fre = new_node(self, .PatternField(.{
                                .name = name.text,
                                .pattern = 0,
@@ -431,7 +441,7 @@ fn parse_pattern_atom(self: *Parser): usize {
                     if nx == null { ret 0; }
                     match nx.kind { .Ident => {}, _ => { ret 0; } }
                     advance(self);
-                    // stage1 先分配 PATTERN_DOT，再解析子模式。
+                    // 先分配 PATTERN_DOT，再解析子模式。
                     var ref = new_node(self, .PatternDot(.{
                                            .name = nx.text,
                                            .sub_pattern = 0,
@@ -442,9 +452,8 @@ fn parse_pattern_atom(self: *Parser): usize {
                             var sub = parse_pattern(self);
                             var pn = Ast.node(self.ast, ref);
                             match pn.body {
-                                .PatternDot(pd) => {
+                                .PatternDot(&pd) => {
                                     pd.sub_pattern = sub;
-                                    pn.body = .PatternDot(pd);
                                 },
                                 _ => {},
                             }
@@ -455,7 +464,7 @@ fn parse_pattern_atom(self: *Parser): usize {
                 },
                 .LParen => {
                     advance(self);
-                    // stage1 先分配 PATTERN_TUPLE，再解析内部模式。
+                    // 先分配 PATTERN_TUPLE，再解析内部模式。
                     var ref = new_node(self, .PatternTuple(.{ .items = ref_vec() }), t);
                     if at_punct(self, .RParen) {
                         advance(self);
@@ -490,6 +499,24 @@ fn parse_pattern_atom(self: *Parser): usize {
                     }
                     ret ref;
                 },
+                .And => {
+                    // `&name`：解包左值引用绑定。仅允许作用于绑定名。
+                    advance(self);
+                    var nx = peek(self);
+                    if nx == null {
+                        parse_error(self, nx, "expected binding name after '&'");
+                        ret 0;
+                    }
+                    match nx.kind {
+                        .Ident => {},
+                        _ => {
+                            parse_error(self, nx, "expected binding name after '&'");
+                            ret 0;
+                        },
+                    }
+                    var inner = parse_pattern_atom(self);
+                    ret new_node(self, .PatternRef(.{ .pat = inner }), t);
+                },
                 _ => {},
             }
         },
@@ -527,9 +554,8 @@ fn parse_pattern(self: *Parser): usize {
     ret new_node(self, .PatternList(.{ .items = atoms }), peek(self));
 }
 
-// ---- 声明 ----
 
-fn parse_tag_list(self: *Parser, out: *Vec, is_external: bool, allow_at: bool) {
+fn parse_tag_list(self: *Parser, out: *Vec, is_external: bool, allow_at: bool, bang_only: bool) {
     while !self.failed {
         var t = peek(self);
         if t == null { ret; }
@@ -538,30 +564,37 @@ fn parse_tag_list(self: *Parser, out: *Vec, is_external: bool, allow_at: bool) {
         else if kind_is_punct(t.kind, .Sharp) { is_at = false; }
         else { ret; }
         if !allow_at && is_at { ret; }
+        if bang_only {
+            // 仅消费 `#!`/`@!` 形式的当前层 tag；遇到普通 `#name` 即停。
+            var save = self.pos;
             advance(self);
-        if is_external {
+            var nt = peek(self);
-            t = peek(self);
+            var has_bang = nt != null && kind_is_punct(nt.kind, .Not);
-            if t == null || !kind_is_punct(t.kind, .Not) {
+            self.pos = save;
-                parse_error(self, t, "expected '!' in external tag");
+            if !has_bang { ret; }
-                ret;
         }
         advance(self);
+        t = peek(self);
+        var ext_here = is_external;
+        if t != null && kind_is_punct(t.kind, .Not) {
+            advance(self);
+            ext_here = true;
         }
         t = peek(self);
         if t == null { ret; }
         match t.kind { .Ident => {}, _ => { parse_error(self, t, "expected tag name"); ret; } }
         advance(self);
-        // stage1 先分配 tag 节点，再解析参数。
+        // 先分配 tag 节点，再解析参数。
         var body: Body = .TagItem(.{
             .is_at = is_at,
-            .is_external = is_external,
+            .is_external = ext_here,
             .name = t.text,
             .args = ref_vec(),
         });
-        if is_external {
+        if ext_here {
             body = .ExternalTagItem(.{
                 .is_at = is_at,
-                .is_external = is_external,
+                .is_external = ext_here,
                 .name = t.text,
                 .args = ref_vec(),
             });
@@ -590,7 +623,13 @@ fn parse_tag_list(self: *Parser, out: *Vec, is_external: bool, allow_at: bool) {
 
 fn parse_param_decl_impl(self: *Parser): usize {
     var attrs = ref_vec();
-    parse_tag_list(self, &attrs, false, true);
+    var is_comptime = false;
+    var c0 = peek(self);
+    if c0 != null && kind_is_keyword(c0.kind, .Comptime) {
+        advance(self);
+        is_comptime = true;
+    }
+    parse_tag_list(self, &attrs, false, true, false);
     var name = peek(self);
     if name == null { ret 0; }
     var ok = false;
@@ -602,10 +641,10 @@ fn parse_param_decl_impl(self: *Parser): usize {
     if !ok { ret 0; }
     advance(self);
     if !expect_punct(self, .Colon, "':' in parameter declaration") { ret 0; }
-    parse_tag_list(self, &attrs, false, false);
+    parse_tag_list(self, &attrs, false, false, false);
     var ty = parse_type_expr(self);
     ret new_node(self,
-                 .ParamDecl(.{ .attr_list = attrs, .name = name.text, .type_expr = ty }),
+                 .ParamDecl(.{ .attr_list = attrs, .is_comptime = is_comptime, .name = name.text, .type_expr = ty }),
                  name);
 }
 
@@ -633,11 +672,24 @@ fn parse_param_list(self: *Parser): Vec {
                 if at_punct(self, .Comma) { advance(self); continue; }
                 break;
             },
+            .Keyword(k) => {
+                if @enum2int(k) == @enum2int(Keyword.Comptime) {
+                    var pd2 = parse_param_decl_impl(self);
+                    if pd2 != 0 {
+                        match Vec.push(&out, &pd2 as *u8) { .Ok => {}, .Err(e) => { ret out; } }
+                    }
+                    if at_punct(self, .Comma) { advance(self); continue; }
+                    break;
+                }
+                parse_error(self, t, "unexpected token in parameter list");
+                break;
+            },
             .Punct(p) => {
                 if @enum2int(p) == @enum2int(Punct.Ellipsis) {
                     advance(self);
                     var pd = new_node(self, .ParamDecl(.{
                         .attr_list = ref_vec(),
+                        .is_comptime = false,
                         .name = ByteView.empty(),
                         .type_expr = 0,
                     }), t);
@@ -657,7 +709,29 @@ fn parse_param_list(self: *Parser): Vec {
     ret out;
 }
 
-fn parse_fn_decl(self: *Parser, tags: Vec): usize {
+// 该 token 是否可能开始一个类型表达式（用于省略冒号的返回类型）。
+fn token_starts_type(t: *Token): bool {
+    if t == null { ret false; }
+    match t.kind {
+        .Ident => { ret true; },
+        .Keyword(k) => {
+            match k {
+                .Type, .Bool, .Any, .Fn, .Struct, .Union, .Enum, .Shape => { ret true; },
+                _ => {},
+            }
+        },
+        .Punct(p) => {
+            match p {
+                .Mul, .LBracket, .At, .Sharp => { ret true; },
+                _ => {},
+            }
+        },
+        _ => {},
+    }
+    ret false;
+}
+
+fn parse_fn_decl(self: *Parser, tags: Vec, is_comptime: bool): usize {
     var kw = peek(self);
     if kw == null || !kind_is_keyword(kw.kind, .Fn) { ret 0; }
     advance(self);
@@ -674,19 +748,26 @@ fn parse_fn_decl(self: *Parser, tags: Vec): usize {
         advance(self);
         ret_type = parse_type_expr(self);
         t = peek(self);
+    } else if token_starts_type(t) {
+        // 省略冒号：`fn f() T { ... }`
+        ret_type = parse_type_expr(self);
+        t = peek(self);
     }
     var body: usize = 0;
+    if is_comptime { self.comptime_depth = self.comptime_depth + 1; }
     if t != null && kind_is_punct(t.kind, .LBrace) {
         body = parse_block(self);
     } else if t != null && kind_is_punct(t.kind, .Semicolon) {
         advance(self);
     } else {
+        if is_comptime { self.comptime_depth = self.comptime_depth - 1; }
         parse_error(self, t, "function declaration must end with ';' or block");
         ret 0;
     }
+    if is_comptime { self.comptime_depth = self.comptime_depth - 1; }
     ret new_node(self, .FnDecl(.{
                        .tag_list = tags,
-                       .is_comptime = false,
+                       .is_comptime = is_comptime,
                        .name = name.text,
                        .params = params,
                        .ret_type = ret_type,
@@ -701,7 +782,7 @@ fn parse_type_decl(self: *Parser, tags: Vec): usize {
     var pattern = parse_pattern(self);
     if pattern == 0 { ret 0; }
     if !expect_punct(self, .Assign, "'=' in type declaration") { ret 0; }
-    // stage1 先分配 TYPE_DECL 再解析 type_expr（影响 #ref 顺序）。
+    // 先分配 TYPE_DECL 再解析 type_expr（影响 #ref 顺序）。
     var ref = new_node(self, .TypeDecl(.{
                            .attr_list = tags,
                            .pattern = pattern,
@@ -774,7 +855,7 @@ fn parse_member_decl(self: *Parser, tags: Vec): usize {
     var t = peek(self);
     if t != null && kind_is_punct(t.kind, .Colon) {
         advance(self);
-        parse_tag_list(self, &tags, false, false);
+        parse_tag_list(self, &tags, false, false, false);
         te = parse_type_expr(self);
         t = peek(self);
         if t != null && kind_is_punct(t.kind, .Assign) {
@@ -804,37 +885,48 @@ fn parse_comptime_decl(self: *Parser): usize {
     advance(self);
     var body: usize = 0;
     var t = peek(self);
+    self.comptime_depth = self.comptime_depth + 1;
     if t != null && kind_is_punct(t.kind, .LBrace) { body = parse_block(self); }
     else { body = parse_expr(self); }
+    self.comptime_depth = self.comptime_depth - 1;
     ret new_node(self, .ComptimeDecl(.{ .body = body }), kw);
 }
 
 fn parse_container_declaration(self: *Parser): usize {
     var tags = ref_vec();
-    parse_tag_list(self, &tags, false, false);
+    parse_tag_list(self, &tags, false, false, false);
     var t = peek(self);
     if t == null { ret 0; }
     match t.kind {
         .Eof => { ret 0; },
         .Keyword(k) => {
-            if @enum2int(k) == @enum2int(Keyword.Fn) { ret parse_fn_decl(self, tags); }
+            match k {
-            if @enum2int(k) == @enum2int(Keyword.Type) { ret parse_type_decl(self, tags); }
+                .Fn => { ret parse_fn_decl(self, tags, false); },
-            if @enum2int(k) == @enum2int(Keyword.Var) {
+                .Type => { ret parse_type_decl(self, tags); },
-                ret parse_var_const_decl(self, tags, false);
+                .Var => { ret parse_var_const_decl(self, tags, false); },
+                .Const => { ret parse_var_const_decl(self, tags, true); },
+                .Comptime => {
+                    var nxt = peek_next(self);
+                    if nxt != null && kind_is_keyword(nxt.kind, .Fn) {
+                        advance(self);
+                        ret parse_fn_decl(self, tags, true);
                     }
-            if @enum2int(k) == @enum2int(Keyword.Const) {
+                    ret parse_comptime_decl(self);
-                ret parse_var_const_decl(self, tags, true);
+                },
+                _ => {},
             }
-            if @enum2int(k) == @enum2int(Keyword.Comptime) { ret parse_comptime_decl(self); }
         },
         .Ident => { ret parse_member_decl(self, tags); },
         .Punct(p) => {
-            if @enum2int(p) == @enum2int(Punct.LBrace) {
+            match p {
+                .LBrace => {
                     var block = parse_block(self);
                     ret new_node(self, .TopLevelBlock(.{
                                        .tag_list = tags,
                                        .block = block,
                                    }), t);
+                },
+                _ => {},
             }
         },
         _ => {},
@@ -844,7 +936,6 @@ fn parse_container_declaration(self: *Parser): usize {
     ret 0;
 }
 
-// ---- 类型 ----
 
 fn parse_type_comptime_call(self: *Parser): usize {
     var start = peek(self);
@@ -873,7 +964,7 @@ fn parse_type_base(self: *Parser): usize {
     if kind_is_keyword(bt.kind, .Fn) {
         advance(self);
         if !expect_punct(self, .LParen, "'(' in function type") { ret 0; }
-        // stage1 先分配 TYPE_FN，再解析参数与返回类型。
+        // 先分配 TYPE_FN，再解析参数与返回类型。
         var ref = new_node(self, .TypeFn(.{
                                .is_comptime = false,
                                .params = ref_vec(),
@@ -907,10 +998,13 @@ fn parse_type_base(self: *Parser): usize {
     match bt.kind {
         .Keyword(k) => {
             var kind_name: []u8 = "";
-            if @enum2int(k) == @enum2int(Keyword.Struct) { kind_name = "struct"; }
+            match k {
-            else if @enum2int(k) == @enum2int(Keyword.Union) { kind_name = "union"; }
+                .Struct => { kind_name = "struct"; },
-            else if @enum2int(k) == @enum2int(Keyword.Enum) { kind_name = "enum"; }
+                .Union => { kind_name = "union"; },
-            else if @enum2int(k) == @enum2int(Keyword.Shape) { kind_name = "shape"; }
+                .Enum => { kind_name = "enum"; },
+                .Shape => { kind_name = "shape"; },
+                _ => {},
+            }
             if kind_name.len != 0 {
                 advance(self);
                 if !expect_punct(self, .LBrace, "'{' in aggregate type") { ret 0; }
@@ -953,25 +1047,52 @@ fn parse_type_base(self: *Parser): usize {
     match bt.kind {
         .Ident => {
             advance(self);
+            // 类型调用 `Name(T, ...)`（comptime 类型构造，如 `vec(i32)`）。
+            if at_punct(self, .LParen) {
+                advance(self);
+                var ref = new_node(self, .TypePath(.{
+                                       .name = bt.text,
+                                       .generic_args = ref_vec(),
+                                   }), bt);
+                var args = ref_vec();
+                while !self.failed && !at_punct(self, .RParen) {
+                    var a = parse_type_expr(self);
+                    match Vec.push(&args, &a as *u8) { .Ok => {}, .Err(e) => { ret 0; } }
+                    if at_punct(self, .Comma) { advance(self); continue; }
+                    break;
+                }
+                expect_punct(self, .RParen, "')' in type call");
+                var tn = Ast.node(self.ast, ref);
+                match tn.body {
+                    .TypePath(tp) => {
+                        tp.generic_args = args;
+                        tn.body = .TypePath(tp);
+                    },
+                    _ => {},
+                }
+                ret ref;
+            }
             ret new_node(self, .TypePath(.{
                                .name = bt.text,
                                .generic_args = ref_vec(),
                            }), bt);
         },
         .Keyword(k) => {
-            // stage1 is_builtin_type_kw：bool / any 作为类型路径。
+            match k {
-            if @enum2int(k) == @enum2int(Keyword.Bool) ||
+                .Bool, .Any, .Type => {
-               @enum2int(k) == @enum2int(Keyword.Any) {
                     advance(self);
                     ret new_node(self, .TypePath(.{
                                        .name = bt.text,
                                        .generic_args = ref_vec(),
                                    }), bt);
+                },
+                _ => {},
             }
         },
         .Punct(p) => {
-            if @enum2int(p) == @enum2int(Punct.At) || @enum2int(p) == @enum2int(Punct.Sharp) {
+            match p {
-                ret parse_type_comptime_call(self);
+                .At, .Sharp => { ret parse_type_comptime_call(self); },
+                _ => {},
             }
         },
         _ => {},
@@ -986,7 +1107,7 @@ fn parse_type_expr(self: *Parser): usize {
 
     if kind_is_punct(t.kind, .Mul) {
         advance(self);
-        // stage1 先分配 POINTER，再解析 pointee。
+        // 先分配 POINTER，再解析 pointee。
         var ref = new_node(self, .TypePointer(.{ .pointee = 0 }), t);
         var pointee = parse_type_expr(self);
         var pn = Ast.node(self.ast, ref);
@@ -1070,7 +1191,6 @@ fn parse_type_expr(self: *Parser): usize {
     ret base;
 }
 
-// ---- 表达式 ----
 
 type BinInfo = struct { op: Punct, prec: i32, right: bool }
 type BinResult = enum { No, Yes: BinInfo }
@@ -1152,7 +1272,19 @@ fn parse_expr_prec(self: *Parser, min_prec: i32): usize {
 }
 
 fn parse_expr(self: *Parser): usize {
-    ret parse_expr_prec(self, 1);
+    var e = parse_expr_prec(self, 1);
+    // `expr catch <pattern> <block>`：catch 用解包语法绑定错误。
+    while !self.failed {
+        var t = peek(self);
+        if t == null { break; }
+        if !kind_is_keyword(t.kind, .Catch) { break; }
+        advance(self);
+        var pat = parse_pattern(self);
+        if pat == 0 { ret e; }
+        var handler = parse_block(self);
+        e = new_node(self, .ExprCatch(.{ .value = e, .pattern = pat, .handler = handler }), t);
+    }
+    ret e;
 }
 
 fn parse_cast(self: *Parser): usize {
@@ -1183,9 +1315,9 @@ fn parse_prefix(self: *Parser): usize {
         if ref == 0 { ret 0; }
         var n = Ast.node(self.ast, ref);
         match n.body {
-            .ExprWhile(w) => { w.label = label; n.body = .ExprWhile(w); },
+            .ExprWhile(&w) => { w.label = label; },
-            .ExprLoop(l) => { l.label = label; n.body = .ExprLoop(l); },
+            .ExprLoop(&l) => { l.label = label; },
-            .ExprFor(f) => { f.label = label; n.body = .ExprFor(f); },
+            .ExprFor(&f) => { f.label = label; },
             _ => {},
         }
         ret ref;
@@ -1225,7 +1357,7 @@ fn parse_postfix(self: *Parser): usize {
 
         if kind_is_punct(t.kind, .LParen) {
             advance(self);
-            // stage1 先分配 CALL，再解析实参（影响 #ref 顺序）。
+            // 先分配 CALL，再解析实参（影响 #ref 顺序）。
             var ref = new_node(self, .ExprCall(.{ .callee = expr, .args = ref_vec() }), t);
             var args = parse_expr_list(self);
             var cn = Ast.node(self.ast, ref);
@@ -1338,34 +1470,39 @@ fn parse_primary(self: *Parser): usize {
             ret new_node(self, .ExprStringLit(.{ .data = Ast.push_string(self.ast, decode_str(t.text)) }), t);
         },
         .Keyword(k) => {
-            if @enum2int(k) == @enum2int(Keyword.True) {
+            match k {
+                .True => { advance(self); ret new_node(self, .ExprBoolLit(.{ .value = true }), t); },
+                .False => { advance(self); ret new_node(self, .ExprBoolLit(.{ .value = false }), t); },
+                .Null => { advance(self); ret new_node(self, .ExprNullLit, t); },
+                .Undefined => { advance(self); ret new_node(self, .ExprUndefinedLit, t); },
+                .If => { ret parse_if_expr(self); },
+                .While => { ret parse_while_expr(self); },
+                .Loop => { ret parse_loop_expr(self); },
+                .For => { ret parse_for_expr(self); },
+                .Match => { ret parse_match_expr(self); },
+                .Try => {
                     advance(self);
-                ret new_node(self, .ExprBoolLit(.{ .value = true }), t);
+                    var tv = parse_expr(self);
-            }
+                    ret new_node(self, .ExprTry(.{ .value = tv }), t);
-            if @enum2int(k) == @enum2int(Keyword.False) {
+                },
+                .Comptime => {
                     advance(self);
-                ret new_node(self, .ExprBoolLit(.{ .value = false }), t);
+                    var cbody = parse_expr(self);
+                    ret new_node(self, .ExprComptime(.{ .body = cbody }), t);
+                },
+                .Struct, .Union, .Enum, .Shape => {
+                    // 类型即表达式仅限 comptime 上下文。
+                    if self.comptime_depth > 0 { ret parse_type_base(self); }
+                },
+                _ => {},
             }
-            if @enum2int(k) == @enum2int(Keyword.Null) {
-                advance(self);
-                ret new_node(self, .ExprNullLit, t);
-            }
-            if @enum2int(k) == @enum2int(Keyword.Undefined) {
-                advance(self);
-                ret new_node(self, .ExprUndefinedLit, t);
-            }
-            if @enum2int(k) == @enum2int(Keyword.If) { ret parse_if_expr(self); }
-            if @enum2int(k) == @enum2int(Keyword.While) { ret parse_while_expr(self); }
-            if @enum2int(k) == @enum2int(Keyword.Loop) { ret parse_loop_expr(self); }
-            if @enum2int(k) == @enum2int(Keyword.For) { ret parse_for_expr(self); }
-            if @enum2int(k) == @enum2int(Keyword.Match) { ret parse_match_expr(self); }
             parse_error(self, t, "unrecognized expression");
             ret 0;
         },
         .Ident => {
             advance(self);
             if at_punct(self, .LBrace) && self.stop_agg == 0 {
-                // stage1 先分配 AGGREGATE_LIT，再解析字段。
+                // 先分配 AGGREGATE_LIT，再解析字段。
                 var ref = new_node(self, .ExprAggregateLit(.{
                                        .name = t.text,
                                        .fields = ref_vec(),
@@ -1373,10 +1510,7 @@ fn parse_primary(self: *Parser): usize {
                 var fields = parse_aggregate_fields(self);
                 var an = Ast.node(self.ast, ref);
                 match an.body {
-                    .ExprAggregateLit(a) => {
+                    .ExprAggregateLit(&a) => { a.fields = fields; },
-                        a.fields = fields;
-                        an.body = .ExprAggregateLit(a);
-                    },
                     _ => {},
                 }
                 ret ref;
@@ -1384,7 +1518,8 @@ fn parse_primary(self: *Parser): usize {
             ret new_node(self, .ExprIdent(.{ .name = t.text }), t);
         },
         .Punct(p) => {
-            if @enum2int(p) == @enum2int(Punct.Dot) {
+            match p {
+                .Dot => {
                     advance(self);
                     var nx = peek(self);
                     if nx == null { parse_error(self, t, "unexpected '.'"); ret 0; }
@@ -1396,10 +1531,7 @@ fn parse_primary(self: *Parser): usize {
                         var fields = parse_aggregate_fields(self);
                         var an = Ast.node(self.ast, ref);
                         match an.body {
-                        .ExprAggregateLit(a) => {
+                            .ExprAggregateLit(&a) => { a.fields = fields; },
-                            a.fields = fields;
-                            an.body = .ExprAggregateLit(a);
-                        },
                             _ => {},
                         }
                         ret ref;
@@ -1421,13 +1553,11 @@ fn parse_primary(self: *Parser): usize {
                     if is_ident { ret parse_variant_construct(self, t); }
                     parse_error(self, nx, "expected '{', '[' or identifier after '.'");
                     ret 0;
-            }
+                },
-            if @enum2int(p) == @enum2int(Punct.LBracket) { ret parse_array_literal(self); }
+                .LBracket => { ret parse_array_literal(self); },
-            if @enum2int(p) == @enum2int(Punct.LBrace) { ret parse_block(self); }
+                .LBrace => { ret parse_block(self); },
-            if @enum2int(p) == @enum2int(Punct.At) || @enum2int(p) == @enum2int(Punct.Sharp) {
+                .At, .Sharp => { ret parse_comptime_call(self); },
-                ret parse_comptime_call(self);
+                .LParen => {
-            }
-            if @enum2int(p) == @enum2int(Punct.LParen) {
                     advance(self);
                     var elems = ref_vec();
                     if at_punct(self, .RParen) {
@@ -1436,12 +1566,12 @@ fn parse_primary(self: *Parser): usize {
                     }
                     var first = parse_expr(self);
                     if at_punct(self, .Comma) {
-                    match Vec.push(&elems, &first as *u8) { .Ok => {}, .Err(e) => { ret 0; } }
+                        Vec.push(&elems, &first as *u8);
                         while at_punct(self, .Comma) {
                             advance(self);
                             if at_punct(self, .RParen) { break; }
                             var nx = parse_expr(self);
-                        match Vec.push(&elems, &nx as *u8) { .Ok => {}, .Err(e) => { ret 0; } }
+                            Vec.push(&elems, &nx as *u8);
                         }
                         expect_punct(self, .RParen, "')' in tuple literal");
                         ret new_node(self, .ExprTuple(.{ .items = elems }), t);
@@ -1449,6 +1579,8 @@ fn parse_primary(self: *Parser): usize {
                     expect_punct(self, .RParen, "')' in paren expression");
                     Vec.drop(&elems);
                     ret first;
+                },
+                _ => {},
             }
         },
         _ => {},
@@ -1555,6 +1687,15 @@ fn parse_comptime_call(self: *Parser): usize {
         args = parse_expr_list(self);
         if !expect_punct(self, .RParen, "')' in comptime call") { ret 0; }
     }
+    // `@name(args){ ... }`：构造该编译期类型的值（聚合初始化）。
+    if at_punct(self, .LBrace) && self.stop_agg == 0 {
+        var fields = parse_aggregate_fields(self);
+        ret new_node(self, .ExprComptimeInit(.{
+                           .name = name.text,
+                           .args = args,
+                           .fields = fields,
+                       }), start);
+    }
     ret new_node(self, .ExprComptimeCall(.{ .name = name.text, .args = args }), start);
 }
 
@@ -1589,7 +1730,6 @@ fn parse_expr_list(self: *Parser): Vec {
     ret vec;
 }
 
-// ---- if / while / loop / for / match ----
 
 fn parse_if_expr(self: *Parser): usize {
     var kw = peek(self);
@@ -1756,7 +1896,7 @@ fn parse_match_expr(self: *Parser): usize {
         if at_punct(self, .Comma) { advance(self); }
     }
     if !expect_punct(self, .RBrace, "'}' in match") { ret 0; }
-    // stage1 先分配 MATCH_EXPR，再逐个分配 MATCH_ARM。
+    // 先分配 MATCH_EXPR，再逐个分配 MATCH_ARM。
     var ref = new_node(self, .ExprMatch(.{
                            .matched_expr = matched,
                            .arms = ref_vec(),
@@ -1785,7 +1925,6 @@ fn parse_match_expr(self: *Parser): usize {
     ret ref;
 }
 
-// ---- 语句 ----
 
 fn parse_ret_stmt(self: *Parser): usize {
     var kw = peek(self);
@@ -1793,7 +1932,18 @@ fn parse_ret_stmt(self: *Parser): usize {
     advance(self);
     var expr: usize = 0;
     var t = peek(self);
-    if t != null && can_start_expr(t.kind) { expr = parse_expr(self); }
+    var can = false;
+    if t != null {
+        can = can_start_expr(t.kind);
+        // comptime 上下文：允许返回类型表达式（如 `ret struct { ... };`）。
+        if !can && self.comptime_depth > 0 {
+            if kind_is_keyword(t.kind, .Struct) || kind_is_keyword(t.kind, .Union) ||
+               kind_is_keyword(t.kind, .Enum) || kind_is_keyword(t.kind, .Shape) {
+                can = true;
+            }
+        }
+    }
+    if can { expr = parse_expr(self); }
     t = peek(self);
     if t != null && kind_is_punct(t.kind, .Semicolon) { advance(self); }
     ret new_node(self, .StatementRet(.{ .expr = expr }), kw);
@@ -1838,6 +1988,22 @@ fn parse_defer_stmt(self: *Parser): usize {
     ret new_node(self, .StatementDefer(.{ .body = body }), kw);
 }
 
+fn parse_errdefer_stmt(self: *Parser): usize {
+    var kw = peek(self);
+    if kw == null || !kind_is_keyword(kw.kind, .Errdefer) { ret 0; }
+    advance(self);
+    var body: usize = 0;
+    var t = peek(self);
+    if t != null && kind_is_punct(t.kind, .LBrace) { body = parse_block(self); }
+    else if t != null && can_start_statement(t.kind) { body = parse_statement(self); }
+    else {
+        body = parse_expr(self);
+        t = peek(self);
+        if t != null && kind_is_punct(t.kind, .Semicolon) { advance(self); }
+    }
+    ret new_node(self, .StatementErrdefer(.{ .body = body }), kw);
+}
+
 fn parse_comptime_stmt(self: *Parser): usize {
     var kw = peek(self);
     if kw == null || !kind_is_keyword(kw.kind, .Comptime) { ret 0; }
@@ -1855,26 +2021,26 @@ fn parse_statement(self: *Parser): usize {
 
     match t.kind {
         .Keyword(k) => {
-            if @enum2int(k) == @enum2int(Keyword.Ret) { ret parse_ret_stmt(self); }
+            match k {
-            if @enum2int(k) == @enum2int(Keyword.Break) { ret parse_break_stmt(self); }
+                .Ret => { ret parse_ret_stmt(self); },
-            if @enum2int(k) == @enum2int(Keyword.Continue) { ret parse_continue_stmt(self); }
+                .Break => { ret parse_break_stmt(self); },
-            if @enum2int(k) == @enum2int(Keyword.Defer) { ret parse_defer_stmt(self); }
+                .Continue => { ret parse_continue_stmt(self); },
-            if @enum2int(k) == @enum2int(Keyword.Comptime) { ret parse_comptime_stmt(self); }
+                .Defer => { ret parse_defer_stmt(self); },
-            if @enum2int(k) == @enum2int(Keyword.Var) ||
+                .Errdefer => { ret parse_errdefer_stmt(self); },
-               @enum2int(k) == @enum2int(Keyword.Const) ||
+                .Comptime => { ret parse_comptime_stmt(self); },
-               @enum2int(k) == @enum2int(Keyword.Type) {
+                .Var, .Const, .Type => {
                     var tags = ref_vec();
-                parse_tag_list(self, &tags, false, false);
+                    parse_tag_list(self, &tags, false, false, false);
                     var decl: usize = 0;
-                if @enum2int(k) == @enum2int(Keyword.Var) {
+                    match k {
-                    decl = parse_var_const_decl(self, tags, false);
+                        .Var => { decl = parse_var_const_decl(self, tags, false); },
-                } else if @enum2int(k) == @enum2int(Keyword.Const) {
+                        .Const => { decl = parse_var_const_decl(self, tags, true); },
-                    decl = parse_var_const_decl(self, tags, true);
+                        _ => { decl = parse_type_decl(self, tags); },
-                } else {
-                    decl = parse_type_decl(self, tags);
                     }
                     if decl == 0 { ret 0; }
                     ret new_node(self, .StatementDecl(.{ .decl = decl }), t);
+                },
+                _ => {},
             }
         },
         _ => {},
@@ -1979,7 +2145,7 @@ fn block_push_stmt(self: *Parser, ref: usize, stmt: usize) {
     var n = Ast.node(self.ast, ref);
     match n.body {
         .ExprBlock(b) => {
-            match Vec.push(&b.stmts, &stmt as *u8) { .Ok => {}, .Err(e) => {} }
+            Vec.push(&b.stmts, &stmt as *u8);
             n.body = .ExprBlock(b);
         },
         _ => {},
@@ -2000,7 +2166,6 @@ fn block_set_tail(self: *Parser, ref: usize, expr: usize) {
     }
 }
 
-// ---- 入口 ----
 
 fn skip_to_sync(self: *Parser) {
     while !self.failed {
@@ -2015,7 +2180,7 @@ fn skip_to_sync(self: *Parser) {
     }
 }
 
-// 解析整个文件；Root/ContainerMembers 最后分配（与 stage1 一致）。
+// 解析整个文件；Root/ContainerMembers 最后分配（#ref 顺序须与 splc0 一致）。
 fn parse(self: *Parser) {
     var external_tags = ref_vec();
     var declarations = ref_vec();
@@ -2031,7 +2196,7 @@ fn parse(self: *Parser) {
             var t2 = peek(self);
             self.pos = save;
             if t2 != null && kind_is_punct(t2.kind, .Not) {
-                parse_tag_list(self, &external_tags, true, true);
+                parse_tag_list(self, &external_tags, true, true, true);
                 continue;
             }
         }
@@ -2058,7 +2223,6 @@ fn parse(self: *Parser) {
     self.ast.root = root;
 }
 
-// ---- 测试 ----
 
 fn lex_tokens(src: []u8): Vec {
     var out = Vec.blank(@sizeof(Token), @alignof(Token));
@@ -2122,7 +2286,7 @@ fn expect_text(buf: *ByteBuffer, expected: []u8) {
     }
 }
 
-// 与 stage1 `splc0 --dump ast` 输出逐字节一致（含 #ref 与 [line:col]）。
+// 与 splc0 --dump ast 逐字节一致（含 #ref 与 [line:col]）。
 fn test_parse_decls() {
     var src: []u8 = "type Point = struct { x: i32, y: i32 };\nfn f(a: i32): i32;\n";
     var toks = lex_tokens(src);
@@ -2154,7 +2318,7 @@ fn test_parse_decls() {
                 "AST:\n`-root #13\n  `-container_members #12\n    |-type_decl #2 [1:1]\n    | |-pattern_ident #1 [1:6]\n    | `-type_aggregate #3 [1:14]\n    |   |-member_decl #5 [1:23]\n    |   | |-type_path #4 [1:26]\n    |   `-member_decl #7 [1:31]\n    |     |-type_path #6 [1:34]\n    `-fn_decl #11 [2:1]\n      `-param_decl #9 [2:6]\n        `-type_path #8 [2:9]\n      |-type_path #10 [2:15]\n");
 }
 
-// 表达式/语句/块：与 001_main.spl 的 stage1 dump 逐字节一致。
+// 表达式/语句/块：与 splc0 dump 逐字节一致。
 fn test_parse_main() {
     var src: []u8 = "// Expect retcode = 0\n\nfn main(): i32 {\n    ret 0;\n}\n";
     var toks = lex_tokens(src);
@@ -2186,7 +2350,7 @@ fn test_parse_main() {
                 "AST:\n`-root #7\n  `-container_members #6\n    `-fn_decl #5 [3:1]\n      |-type_path #1 [3:12]\n      `-block #2 [3:16]\n        `-statement_ret #4 [4:5]\n          `-int_lit #3 [4:9]\n");
 }
 
-// 任意宽度整数：2^64 也能正确解析（stage1 u64 之外）；含分隔符与多进制。
+// 任意宽度整数：2^64 也能正确解析；含分隔符与多进制。
 fn check_int(src: []u8, expected: []u8) {
     var toks = lex_tokens(src);
     defer { Vec.drop(&toks); }
@@ -2225,10 +2389,60 @@ fn test_big_int_literal() {
     check_int("0o_17", "15");
 }
 
+fn expect_contains(buf: *ByteBuffer, needle: []u8) {
+    var actual = ByteBuffer.as_slice(buf.*);
+    if needle.len > actual.len { @assert(false, "contains length"); }
+    var i: usize = 0;
+    while i + needle.len <= actual.len {
+        var j: usize = 0;
+        var ok = true;
+        while j < needle.len {
+            if actual.ptr[i + j] != needle.ptr[j] { ok = false; break; }
+            j = j + 1;
+        }
+        if ok { ret; }
+        i = i + 1;
+    }
+    @assert(false, "expected substring not found");
+}
+
+// stage3 语法：`comptime fn ... (t: type) type { ... }` 与省略冒号的返回类型。
+fn test_parse_comptime_fn() {
+    var src: []u8 = "comptime fn vec(t: type) type { ret t; }\n";
+    var toks = lex_tokens(src);
+    defer { Vec.drop(&toks); }
+
+    var sources = set_new();
+    defer { set_drop(&sources); }
+    match set_add(&sources, ByteView.from_slice("test.spl"), ByteView.from_slice(src)) {
+        .Ok(index) => {},
+        .Err(error) => { @assert(false, "set_add"); },
+    }
+
+    var ast: Ast = undefined;
+    match Ast.new(&sources) {
+        .Ok(v) => { ast = v; },
+        .Err(error) => { @assert(false, "ast new"); },
+    }
+    defer { Ast.drop(&ast); }
+
+    var p = new(&ast, toks, null);
+    parse(&p);
+    @assert(!p.failed, "comptime fn parse ok");
+    @assert(p.error_count == 0, "comptime fn no errors");
+
+    var buf = ByteBuffer.new();
+    defer { ByteBuffer.drop(&buf); }
+    @assert(Ast.dump(&ast, &buf), "dump");
+    expect_contains(&buf, "fn_decl");
+    expect_contains(&buf, "type_path");
+}
+
 fn main() {
     test_peek_advance();
     test_new_node_span();
     test_parse_decls();
     test_parse_main();
     test_big_int_literal();
+    test_parse_comptime_fn();
 }

stage2/scope.spl

@@ -1,13 +1,11 @@
 // Expect retcode = 0
 
-// 作用域树（移植自 stage1/spl_scope.c）。每个作用域是一张名字 -> Symbol 表，
+// 作用域树：名字 -> Symbol，节点经 parent 上溯查找（支持遮蔽）。名字借用源字节，
-// 节点用 parent 指向父作用域；查找从 current_scope 沿父链上溯（支持遮蔽）。
+// 存活由调用方保证；node 为 def.spl 的 DefId。
-// 名字是 ByteView（借用源/AST）；Map 复制键值字节，但 ByteView 指向的字节由
-// 调用方保证存活。node 字段是 def.spl 的 DefId。
 
 type .{ .Error } = @import("utils/error.spl");
 type .{ .Vec } = @import("utils/vec.spl");
-type .{ .Map } = @import("utils/map.spl");
+type .{ .Map, .hash_kind_view } = @import("utils/map.spl");
 type .{ .ByteView } = @import("utils/byte_view.spl");
 type .{ .hash_view, .eq_view } = @import("utils/hash.spl");
 
@@ -43,7 +41,7 @@ type ScopeResult = enum {
 
 fn new_map(): Map {
     ret Map.new(@sizeof(ByteView), @alignof(ByteView), @sizeof(Symbol), @alignof(Symbol),
-                 hash_view, eq_view);
+                 hash_kind_view());
 }
 
 fn new(): ScopeResult {
@@ -81,11 +79,7 @@ fn drop(self: *Scope) {
 // id 0 与越界返回 null。
 fn node(self: *Scope, id: usize): *ScopeNode {
     if id == 0 || id >= self.scopes.len { ret null; }
-    match Vec.get(&self.scopes, id) {
+    ret (self.scopes.data as *ScopeNode) + id;
-        .Ok(ptr) => { ret ptr as *ScopeNode; },
-        .Err(error) => { ret null; },
-    }
-    ret null;
 }
 
 // 新作用域 parent = 当前作用域；不自动切换 current（调用方负责，见 sema）。
@@ -138,7 +132,6 @@ fn find(self: *Scope, name: ByteView, out: *Symbol): bool {
     ret false;
 }
 
-// ---- 测试 ----
 
 fn sym(name: []u8, kind: SymbolKind, node: usize): Symbol {
     ret Symbol {

stage2/splc1.spl

@@ -1,8 +1,7 @@
 // Expect retcode = 0
 
-// splc1 (stage2 自举编译器入口)。
+// splc1：自举编译器入口。`splc1 <in> <out>` 编译；`--dump <mode> <file>` 打印各阶段
-// 当前实现 `--dump <lex|ast|sema|ir|vm> <file> [out]`：读取源文件，按与 stage1
+// 产物，格式必须与 splc0 逐字节一致以通过 diff。
-// splc0 完全一致的格式打印各阶段产物，供 diff 测试逐字节比对。
 
 type .{ .ByteView } = @import("./utils/byte_view.spl");
 type .{ .ByteBuffer } = @import("./utils/byte_buffer.spl");
@@ -13,7 +12,7 @@ type Ast = @import("./ast.spl");
 type Parser = @import("./parser.spl");
 type Sema = @import("./sema.spl");
 type .{ .append_usize } = @import("./utils/fmt.spl");
-type .{ .read_all, .print, .eprint } = @import("./utils/io.spl");
+type .{ .read_all, .print, .eprint, .open_cstr, .write_all, .File } = @import("./utils/io.spl");
 type .{ .Sources, .Source, .set_new, .set_add, .set_at, .set_drop } = @import("./utils/source.spl");
 type .{ .Diag, .Code, .span_none } = @import("./diag.spl");
 type Logger = @import("./utils/log.spl");
@@ -25,7 +24,8 @@ type LayoutM = @import("./layout.spl");
 type .{ .Layout } = @import("./layout.spl");
 type Ir2VmM = @import("./ir2vm.spl");
 type .{ .Ir2Vm } = @import("./ir2vm.spl");
-type .{ .alloc, .free } = @import("./sys/mem.spl");
+type Ir2CM = @import("./ir2c.spl");
+type .{ .alloc, .free } = @import("./utils/memory.spl");
 
 fn token_at(tokens: *Vec, index: usize): Token {
     match Vec.get(tokens, index) {
@@ -129,14 +129,11 @@ fn dump_lex(log: *Logger, path: ByteView): i32 {
     }
     defer { Vec.drop(&tokens); }
 
-    // 非法输入：走诊断（stage1 在此处是宽容无视，stage2 显式报错）。
+    // 非法输入：走诊断（显式报错，不静默）。
     if Diag.has_error(diag) {
         var rendered = ByteBuffer.new();
         defer { ByteBuffer.drop(&rendered); }
-        match Diag.render_human(&diag, &rendered) {
+        Diag.render_human(&diag, &rendered);
-            .Ok => {},
-            .Err(error) => {},
-        }
         eprint(ByteBuffer.as_slice(rendered));
         ret 1;
     }
@@ -198,10 +195,7 @@ fn dump_ast(log: *Logger, path: ByteView): i32 {
     if Diag.has_error(diag) || p.failed {
         var rendered = ByteBuffer.new();
         defer { ByteBuffer.drop(&rendered); }
-        match Diag.render_human(&diag, &rendered) {
+        Diag.render_human(&diag, &rendered);
-            .Ok => {},
-            .Err(error) => {},
-        }
         eprint(ByteBuffer.as_slice(rendered));
         ret 1;
     }
@@ -219,7 +213,6 @@ fn dump_ast(log: *Logger, path: ByteView): i32 {
     ret 0;
 }
 
-// ---- @import 模块加载器（driver 侧）----
 
 type ModEntry = struct {
     path: ByteView,
@@ -234,7 +227,6 @@ type LoaderCtx = struct {
     diag: *Diag,
 }
 
-fn ignore_bool(b: bool) {}
 
 fn append_bytes(buf: *ByteBuffer, bytes: []u8): bool {
     match ByteBuffer.append(buf, bytes) {
@@ -261,7 +253,7 @@ fn sub(p: ByteView, a: usize, b: usize): []u8 {
 fn normalize_pop(out: *ByteBuffer) {
     var cur = ByteBuffer.as_slice(out.*);
     if cur.len == 0 {
-        ignore_bool(append_bytes(out, ".."));
+        append_bytes(out, "..");
         ret;
     }
     var end = cur.len;
@@ -272,7 +264,7 @@ fn normalize_pop(out: *ByteBuffer) {
     var start = end;
     while start > 0 && cur.ptr[start - 1] != '/' { start = start - 1; }
     if end - start == 2 && cur.ptr[start] == '.' && cur.ptr[start + 1] == '.' {
-        ignore_bool(append_bytes(out, ".."));
+        append_bytes(out, "..");
         ret;
     }
     var new_len: usize = 0;
@@ -284,7 +276,7 @@ fn normalize_pop(out: *ByteBuffer) {
 // 折叠重复分隔符、解析 "." 与 ".."、'\' 统一成 '/'。
 fn normalize_into(out: *ByteBuffer, p: ByteView) {
     if p.len > 0 && (p.ptr[0] == '/' || p.ptr[0] == '\\') {
-        ignore_bool(append_byte(out, '/'));
+        append_byte(out, '/');
     }
     var i: usize = 0;
     while i < p.len {
@@ -300,9 +292,9 @@ fn normalize_into(out: *ByteBuffer, p: ByteView) {
         }
         var cur = ByteBuffer.as_slice(out.*);
         if cur.len > 0 && cur.ptr[cur.len - 1] != '/' {
-            ignore_bool(append_byte(out, '/'));
+            append_byte(out, '/');
         }
-        ignore_bool(append_bytes(out, seg));
+        append_bytes(out, seg);
     }
 }
 
@@ -323,9 +315,9 @@ fn resolve_path(from: ByteView, path: ByteView): ByteBuffer {
         i = i + 1;
     }
     if last >= 0 {
-        ignore_bool(append_bytes(&out, sub(from, 0, (last as usize) + 1)));
+        append_bytes(&out, sub(from, 0, (last as usize) + 1));
     }
-    ignore_bool(append_bytes(&out, ByteView.as_slice(path)));
+    append_bytes(&out, ByteView.as_slice(path));
     var norm = ByteBuffer.new();
     normalize_into(&norm, ByteView.from_slice(ByteBuffer.as_slice(out)));
     ByteBuffer.drop(&out);
@@ -502,10 +494,7 @@ fn dump_sema(log: *Logger, path: ByteView): i32 {
     if Diag.has_error(diag) || p.failed {
         var rendered = ByteBuffer.new();
         defer { ByteBuffer.drop(&rendered); }
-        match Diag.render_human(&diag, &rendered) {
+        Diag.render_human(&diag, &rendered);
-            .Ok => {},
-            .Err(error) => {},
-        }
         eprint(ByteBuffer.as_slice(rendered));
         ret 1;
     }
@@ -536,10 +525,7 @@ fn dump_sema(log: *Logger, path: ByteView): i32 {
     if Diag.has_error(diag) {
         var rendered = ByteBuffer.new();
         defer { ByteBuffer.drop(&rendered); }
-        match Diag.render_human(&diag, &rendered) {
+        Diag.render_human(&diag, &rendered);
-            .Ok => {},
-            .Err(error) => {},
-        }
         eprint(ByteBuffer.as_slice(rendered));
         ret 1;
     }
@@ -566,11 +552,12 @@ type PipeMode = enum {
     Vm,      // 继续 layout + ir2vm，dump VM
     Compile, // 继续 layout + ir2vm，写 outpath
     State,   // 只逐步打日志（诊断“卡在哪一步”）
+    C,       // 继续 layout + ir2c，dump C
 }
 
 fn step(mode: PipeMode, s: []u8) {
     if @enum2int(mode) == @enum2int(PipeMode.State) {
-        match eprint(s) { .Ok => {}, .Err(error) => {} }
+        eprint(s);
     }
 }
 
@@ -628,7 +615,7 @@ fn run_pipeline(log: *Logger, path: ByteView, mode: PipeMode, outpath: ByteView)
     if Diag.has_error(diag) || p.failed {
         var rendered = ByteBuffer.new();
         defer { ByteBuffer.drop(&rendered); }
-        match Diag.render_human(&diag, &rendered) { .Ok => {}, .Err(error) => {} }
+        Diag.render_human(&diag, &rendered);
         eprint(ByteBuffer.as_slice(rendered));
         ret 1;
     }
@@ -659,7 +646,7 @@ fn run_pipeline(log: *Logger, path: ByteView, mode: PipeMode, outpath: ByteView)
     if Diag.has_error(diag) {
         var rendered = ByteBuffer.new();
         defer { ByteBuffer.drop(&rendered); }
-        match Diag.render_human(&diag, &rendered) { .Ok => {}, .Err(error) => {} }
+        Diag.render_human(&diag, &rendered);
         eprint(ByteBuffer.as_slice(rendered));
         ret 1;
     }
@@ -674,13 +661,13 @@ fn run_pipeline(log: *Logger, path: ByteView, mode: PipeMode, outpath: ByteView)
     var asts = Vec.blank(@sizeof(usize), @alignof(usize));
     defer { Vec.drop(&asts); }
     var ap: *Ast = &ast;
-    match Vec.push(&asts, &ap as *u8) { .Ok => {}, .Err(error) => {} }
+    Vec.push(&asts, &ap as *u8);
     var mi: usize = 0;
     while mi < ctx.mods.len {
         var m = mod_at(&ctx, mi);
         if m != null && m.ok && m.ast != null {
             var mp: *Ast = m.ast;
-            match Vec.push(&asts, &mp as *u8) { .Ok => {}, .Err(error) => {} }
+            Vec.push(&asts, &mp as *u8);
         }
         mi = mi + 1;
     }
@@ -689,7 +676,7 @@ fn run_pipeline(log: *Logger, path: ByteView, mode: PipeMode, outpath: ByteView)
     if Diag.has_error(diag) {
         var rendered = ByteBuffer.new();
         defer { ByteBuffer.drop(&rendered); }
-        match Diag.render_human(&diag, &rendered) { .Ok => {}, .Err(error) => {} }
+        Diag.render_human(&diag, &rendered);
         eprint(ByteBuffer.as_slice(rendered));
         ret 1;
     }
@@ -723,10 +710,35 @@ fn run_pipeline(log: *Logger, path: ByteView, mode: PipeMode, outpath: ByteView)
     LayoutM.resolve(&layout, &sema.types.ir);
     step(mode, "state: layout ok\n");
 
+    if @enum2int(mode) == @enum2int(PipeMode.C) {
+        var cout = ByteBuffer.new();
+        defer { ByteBuffer.drop(&cout); }
+        var ok = Ir2CM.compile(&builder.ir, &sema.types.ir, &layout, &sema.attr, &cout);
+        if outpath.len != 0 {
+            var f = open_cstr(outpath, ByteView.from_slice("wb"));
+            if !File.valid(&f) {
+                Logger.error(log, "cannot open C output file");
+                ret 1;
+            }
+            write_all(&f, ByteBuffer.as_slice(cout));
+            File.close(&f);
+        } else {
+            match print(ByteBuffer.as_slice(cout)) {
+                .Ok => {},
+                .Err(error) => { ret 1; },
+            }
+        }
+        if !ok {
+            Logger.error(log, "ir2c failed (see generated C for unsupported markers)");
+            ret 1;
+        }
+        ret 0;
+    }
+
     var ir2vm: Ir2Vm = undefined;
     Ir2VmM.init(&ir2vm, &builder.ir, &sema.types.ir, &layout, &sema.attr);
     defer { Ir2VmM.drop(&ir2vm); }
-    ignore_i32(Ir2VmM.run(&ir2vm));
+    Ir2VmM.run(&ir2vm);
     step(mode, "state: ir2vm ok\n");
 
     if @enum2int(mode) == @enum2int(PipeMode.Vm) {
@@ -754,7 +766,6 @@ fn run_pipeline(log: *Logger, path: ByteView, mode: PipeMode, outpath: ByteView)
     ret 0;
 }
 
-fn ignore_i32(v: i32) {}
 
 fn main(argc: i32, argv: **u8): i32 {
     // 无参数：自测运行（`nob test stage2`）视为成功。
@@ -776,11 +787,13 @@ fn main(argc: i32, argv: **u8): i32 {
     }
 
     if argc < 4 {
-        Logger.fatal(&log, "usage: splc1 --dump <lex|ast|sema|ir|vm> <file> [out]");
+        Logger.fatal(&log, "usage: splc1 --dump <lex|ast|sema|ir|vm|c> <file> [out]");
         ret 1;
     }
     var mode = ByteView.from_cstr(argv[2]);
     var path = ByteView.from_cstr(argv[3]);
+    var dout = ByteView.empty();
+    if argc >= 5 { dout = ByteView.from_cstr(argv[4]); }
 
     if ByteView.eq(mode, ByteView.from_slice("lex")) {
         ret dump_lex(&log, path);
@@ -800,6 +813,9 @@ fn main(argc: i32, argv: **u8): i32 {
     if ByteView.eq(mode, ByteView.from_slice("state")) {
         ret run_pipeline(&log, path, .State, ByteView.empty());
     }
+    if ByteView.eq(mode, ByteView.from_slice("c")) {
+        ret run_pipeline(&log, path, .C, dout);
+    }
     Logger.fatal(&log, "dump mode not implemented");
     ret 1;
 }

stage2/sys/time.spl

@@ -25,6 +25,10 @@ fn steps(): usize {
     ret vm_timestamp(3);
 }
 
+fn calls(): usize {
+    ret vm_timestamp(5);
+}
+
 fn now_ns(): usize {
     ret vm_timestamp(4);
 }

stage2/sys/vm.spl

@@ -5,9 +5,16 @@ type spl_vm_val_t = u64; // usize
 #extern(vm) fn vm_drop(vm: *any): void;
 
 #extern(vm) fn vm_load(vm: *any, fpath: *u8): void;
-#extern(vm) fn vm_load_from_buffer(vm: *any, buffer: []u8): void;
+#extern(vm) fn vm_load_from_buffer(vm: *any, buf: *any, len: usize): i32;
 
 #extern(vm) fn vm_push(vm: *any, val: spl_vm_val_t): void;
-// TODO
+#extern(vm) fn vm_call(vm: *any, name: *u8, nargs: u64): i32;
+#extern(vm) fn vm_run(vm: *any): i32;
+#extern(vm) fn vm_ret_val(vm: *any): spl_vm_val_t;
+#extern(vm) fn vm_mem_alloc(vm: *any, size: usize): spl_vm_val_t;
+#extern(vm) fn vm_mem_read(vm: *any, off: spl_vm_val_t, dst: *any, n: usize): i32;
+#extern(vm) fn vm_mem_write(vm: *any, off: spl_vm_val_t, src: *any, n: usize): i32;
+#extern(vm) fn vm_stack_get(vm: *any, index: usize): spl_vm_val_t;
+#extern(vm) fn vm_set_foreign(vm: *any, entry: []u8, ctx: u64): i32;
 
 fn main() {}

stage2/token.spl

@@ -1,7 +1,7 @@
 // Expect retcode = 0
 
-// 词法单元：用带载荷 ADT 表达 TokenKind；关键词/算符各自独立 enum。
+// 词法单元：TokenKind 为带载荷 ADT，关键词/算符各自独立 enum；整型/字符在词法期
-// 整型与字符在词法期解码并随载荷携带；文本一律借用源切片（不复制）。
+// 解码，文本一律借用源切片。
 
 type .{ .ByteView } = @import("utils/byte_view.spl");
 
@@ -66,41 +66,68 @@ fn is_trivia(kind: TokenKind): bool {
     }
 }
 
+// 先按长度与首字节分派，再做完整比较，避免对每个标识符做全表串比较。
 fn keyword_of(text: ByteView): KeywordResult {
-    if is(text, "any") { ret .Yes(.Any); }
+    var n = text.len;
-    if is(text, "as") { ret .Yes(.As); }
+    if n == 0 { ret .No; }
-    if is(text, "bool") { ret .Yes(.Bool); }
+    var c0 = text.ptr[0];
-    if is(text, "break") { ret .Yes(.Break); }
+    if n == 2 {
-    if is(text, "catch") { ret .Yes(.Catch); }
+        if c0 == 'a' && is(text, "as") { ret .Yes(.As); }
-    if is(text, "comptime") { ret .Yes(.Comptime); }
+        if c0 == 'f' && is(text, "fn") { ret .Yes(.Fn); }
-    if is(text, "const") { ret .Yes(.Const); }
+        if c0 == 'i' && is(text, "if") { ret .Yes(.If); }
-    if is(text, "continue") { ret .Yes(.Continue); }
+        ret .No;
-    if is(text, "defer") { ret .Yes(.Defer); }
+    }
-    if is(text, "else") { ret .Yes(.Else); }
+    if n == 3 {
-    if is(text, "enum") { ret .Yes(.Enum); }
+        if c0 == 'a' && is(text, "any") { ret .Yes(.Any); }
-    if is(text, "errdefer") { ret .Yes(.Errdefer); }
+        if c0 == 'f' && is(text, "for") { ret .Yes(.For); }
-    if is(text, "false") { ret .Yes(.False); }
+        if c0 == 'r' && is(text, "ret") { ret .Yes(.Ret); }
-    if is(text, "fn") { ret .Yes(.Fn); }
+        if c0 == 't' && is(text, "try") { ret .Yes(.Try); }
-    if is(text, "for") { ret .Yes(.For); }
+        if c0 == 'v' && is(text, "var") { ret .Yes(.Var); }
-    if is(text, "if") { ret .Yes(.If); }
+        ret .No;
-    if is(text, "loop") { ret .Yes(.Loop); }
+    }
-    if is(text, "match") { ret .Yes(.Match); }
+    if n == 4 {
-    if is(text, "null") { ret .Yes(.Null); }
+        if c0 == 'b' && is(text, "bool") { ret .Yes(.Bool); }
-    if is(text, "ret") { ret .Yes(.Ret); }
+        if c0 == 'e' && is(text, "else") { ret .Yes(.Else); }
-    if is(text, "shape") { ret .Yes(.Shape); }
+        if c0 == 'e' && is(text, "enum") { ret .Yes(.Enum); }
-    if is(text, "struct") { ret .Yes(.Struct); }
+        if c0 == 'l' && is(text, "loop") { ret .Yes(.Loop); }
-    if is(text, "true") { ret .Yes(.True); }
+        if c0 == 'n' && is(text, "null") { ret .Yes(.Null); }
-    if is(text, "try") { ret .Yes(.Try); }
+        if c0 == 't' && is(text, "true") { ret .Yes(.True); }
-    if is(text, "type") { ret .Yes(.Type); }
+        if c0 == 't' && is(text, "type") { ret .Yes(.Type); }
-    if is(text, "undefined") { ret .Yes(.Undefined); }
+        ret .No;
-    if is(text, "union") { ret .Yes(.Union); }
+    }
-    if is(text, "var") { ret .Yes(.Var); }
+    if n == 5 {
-    if is(text, "while") { ret .Yes(.While); }
+        if c0 == 'b' && is(text, "break") { ret .Yes(.Break); }
-    if is(text, "_") { ret .Yes(.Underscore); }
+        if c0 == 'c' && is(text, "catch") { ret .Yes(.Catch); }
+        if c0 == 'c' && is(text, "const") { ret .Yes(.Const); }
+        if c0 == 'd' && is(text, "defer") { ret .Yes(.Defer); }
+        if c0 == 'f' && is(text, "false") { ret .Yes(.False); }
+        if c0 == 'm' && is(text, "match") { ret .Yes(.Match); }
+        if c0 == 's' && is(text, "shape") { ret .Yes(.Shape); }
+        if c0 == 'u' && is(text, "union") { ret .Yes(.Union); }
+        if c0 == 'w' && is(text, "while") { ret .Yes(.While); }
+        ret .No;
+    }
+    if n == 6 {
+        if c0 == 's' && is(text, "struct") { ret .Yes(.Struct); }
+        ret .No;
+    }
+    if n == 8 {
+        if c0 == 'c' && is(text, "comptime") { ret .Yes(.Comptime); }
+        if c0 == 'c' && is(text, "continue") { ret .Yes(.Continue); }
+        if c0 == 'e' && is(text, "errdefer") { ret .Yes(.Errdefer); }
+        ret .No;
+    }
+    if n == 9 {
+        if c0 == 'u' && is(text, "undefined") { ret .Yes(.Undefined); }
+        ret .No;
+    }
+    if n == 1 {
+        if c0 == '_' && is(text, "_") { ret .Yes(.Underscore); }
+        ret .No;
+    }
     ret .No;
 }
 
-// ---- token 类型名（与 stage1 spl_tok_type_name 逐字一致，供 dump/diff 使用）----
 
 fn keyword_name(kw: Keyword): []u8 {
     match kw {
@@ -214,7 +241,6 @@ fn kind_name(kind: TokenKind): []u8 {
     ret "?";
 }
 
-// ---- 测试辅助 ----
 
 fn view(text: []u8): ByteView {
     ret ByteView.from_slice(text);

stage2/type_table.spl

@@ -1,15 +1,11 @@
 // Expect retcode = 0
 
-// IR 类型表（移植自 stage1/spl_type.c）。类型按结构 hash-consing（intern），
+// IR 类型表：按结构 hash-consing。id 0 为保留哨兵（Error）。成员/参数 Vec 由本表
-// id 0 为保留哨兵（Error）。节点借用式持有：名称是 ByteView（指向源/AST），
+// 拥有；hash 仅用于选桶，相等始终由结构比较决定。
-// 不复制字符串；聚合成员与函数参数的 Vec 由本表拥有，drop 时统一释放。
-//
-// hash 只用于选桶；相等永远由结构比较决定。桶以「完整 hash -> 链头 id」的
-// Map 存储，节点自带 hash_next 串链（对应 stage1 的 spl_fold）。
 
 type .{ .Error } = @import("utils/error.spl");
 type .{ .Vec } = @import("utils/vec.spl");
-type .{ .Map } = @import("utils/map.spl");
+type .{ .Map, .hash_kind_usize } = @import("utils/map.spl");
 type .{ .ByteView } = @import("utils/byte_view.spl");
 type .{ .ByteBuffer } = @import("utils/byte_buffer.spl");
 type .{ .append_usize } = @import("utils/fmt.spl");
@@ -41,7 +37,7 @@ type AggKind = enum {
     Shape,
 }
 
-// 与 stage1 spl_type_node_kind_t 一一对应；Forall/Exists 保留（暂打印 quant）。
+// 变体顺序即 kind 数值；Forall/Exists 暂按 quant 打印。
 type TypeNode = enum {
     Error,
     Never,
@@ -78,7 +74,6 @@ type TypeTableResult = enum {
     Err: Error,
 }
 
-// ---- hash（FNV 风格；值不必与 stage1 相同，只要结构一致即可）----
 
 fn seed(): usize {
     ret 14695981039346656037;
@@ -290,7 +285,6 @@ fn free_payload(n: *TypeNode) {
     }
 }
 
-// ---- 底层访问 ----
 
 fn usize_at(v: Vec, i: usize): usize {
     match Vec.get(&v, i) {
@@ -301,11 +295,8 @@ fn usize_at(v: Vec, i: usize): usize {
 }
 
 fn member_at(v: *Vec, i: usize): *Member {
-    match Vec.get(v, i) {
+    if i >= v.len { ret null; }
-        .Ok(ptr) => { ret ptr as *Member; },
+    ret (v.data as *Member) + i;
-        .Err(error) => { ret null; },
-    }
-    ret null;
 }
 
 fn push_member(v: *Vec, name: []u8, type_id: usize) {
@@ -320,23 +311,18 @@ fn push_member(v: *Vec, name: []u8, type_id: usize) {
     }
 }
 
-// id 0 与越界均返回 null（对应 stage1 spl_type_node）。
+// id 0 与越界均返回 null。
 fn node(self: *TypeTable, id: usize): *TypeEntry {
     if id == 0 || id >= self.table.len { ret null; }
-    match Vec.get(&self.table, id) {
+    ret (self.table.data as *TypeEntry) + id;
-        .Ok(ptr) => { ret ptr as *TypeEntry; },
-        .Err(error) => { ret null; },
-    }
-    ret null;
 }
 
-// ---- 生命周期 ----
 
 fn new(): TypeTableResult {
     var tt = TypeTable {
         .table = Vec.blank(@sizeof(TypeEntry), @alignof(TypeEntry)),
         .fold = Map.new(@sizeof(usize), @alignof(usize), @sizeof(usize), @alignof(usize),
-                        hash_usize, eq_usize),
+                        hash_kind_usize()),
     };
     var sentinel = TypeEntry { .hash_next = 0, .node = .Error };
     match Vec.push(&tt.table, &sentinel as *u8) {
@@ -383,7 +369,6 @@ fn define(self: *TypeTable, id: usize, src: *TypeNode) {
     src.* = .Error;
 }
 
-// ---- intern ----
 
 fn fold_find(self: *TypeTable, hash: usize, probe: *TypeNode): usize {
     var head: usize = 0;
@@ -410,10 +395,7 @@ fn fold_insert(self: *TypeTable, hash: usize, id: usize) {
     var n = node(self, id);
     if n == null { ret; }
     n.hash_next = old;
-    match Map.put(&self.fold, &hash as *u8, &id as *u8) {
+    Map.put(&self.fold, &hash as *u8, &id as *u8);
-        .Ok => {},
-        .Err(error) => {},
-    }
 }
 
 // intern 一个 probe：命中则释放 probe 载荷并返回已有 id；否则复制入表。
@@ -440,7 +422,6 @@ fn push(self: *TypeTable, probe: *TypeNode): usize {
     ret id;
 }
 
-// ---- builders ----
 
 fn make_error(self: *TypeTable): usize {
     var n: TypeNode = .Error;
@@ -520,7 +501,6 @@ fn make_agg(self: *TypeTable, kind: AggKind, agg: Agg): usize {
     ret push(self, &n);
 }
 
-// ---- 查询 ----
 
 fn is_subtype(self: *TypeTable, sub: usize, super: usize): bool {
     if sub == 0 || super == 0 { ret false; }
@@ -604,7 +584,6 @@ fn agg_member_idx(self: *TypeTable, tid: usize, name: ByteView, out_idx: *usize)
     ret false;
 }
 
-// ---- dump（镜像 stage1 spl_type_pure_dump）----
 
 fn push_out(buf: *ByteBuffer, bytes: []u8): bool {
     match ByteBuffer.append(buf, bytes) {
@@ -644,10 +623,7 @@ fn dump_rec(self: *TypeTable, id: usize, out: *ByteBuffer, stack: *Vec): bool {
     if n == null {
         if !push_out(out, "none") { ret false; }
         var popped: usize = 0;
-        match Vec.pop(stack, &popped as *u8) {
+        Vec.pop(stack, &popped as *u8);
-            .Ok => {},
-            .Err(error) => {},
-        }
         ret true;
     }
 
@@ -705,10 +681,7 @@ fn dump_rec(self: *TypeTable, id: usize, out: *ByteBuffer, stack: *Vec): bool {
     }
 
     var dropped: usize = 0;
-    match Vec.pop(stack, &dropped as *u8) {
+    Vec.pop(stack, &dropped as *u8);
-        .Ok => {},
-        .Err(error) => {},
-    }
     ret ok;
 }
 
@@ -746,7 +719,6 @@ fn pure_dump_text(self: *TypeTable, id: usize): ByteBuffer {
     ret out;
 }
 
-// ---- 测试 ----
 
 fn test_intern_simple() {
     var tt: TypeTable = undefined;

stage2/utils/algorithm.spl

@@ -155,7 +155,6 @@ fn stable_sort(data: *u8, len: usize, elem_size: usize,
     ret .Ok;
 }
 
-// ---- 测试 ----
 
 type Item = struct {
     key: i32,

stage2/utils/arena.spl

@@ -127,7 +127,6 @@ fn drop(self: *Arena) {
     self.current = 0;
 }
 
-// ---- 测试辅助 ----
 
 fn is_aligned(p: *u8, align: usize): bool {
     ret ((p as usize) & (align - 1)) == 0;

stage2/utils/byte_buffer.spl

@@ -26,7 +26,7 @@ fn new(): ByteBuffer {
 
 fn with_capacity(cap: usize): ByteBuffer {
     var b = new();
-    match reserve(&b, cap) { .Ok => {}, .Err(error) => {} }
+    reserve(&b, cap);
     ret b;
 }
 

stage2/utils/byte_view.spl

@@ -5,6 +5,8 @@
 
 type .{ .Error, .make } = @import("error.spl");
 
+#extern(vm) fn vm_bytes_eq(a: *any, alen: usize, b: *any, blen: usize): i32;
+
 type ByteView = @self;
 
 ptr: *u8,
@@ -62,13 +64,7 @@ fn byte_at(self: ByteView, index: usize): ByteResult {
 }
 
 fn eq(a: ByteView, b: ByteView): bool {
-    if a.len != b.len { ret false; }
+    ret vm_bytes_eq(a.ptr as *any, a.len, b.ptr as *any, b.len) != 0;
-    var i: usize = 0;
-    while i < a.len {
-        if a.ptr[i] != b.ptr[i] { ret false; }
-        i = i + 1;
-    }
-    ret true;
 }
 
 // 按无符号字节进行字典序比较，结果只承诺小于、等于或大于零。

stage2/utils/fmt.spl

@@ -9,8 +9,8 @@ type .{ .ByteView } = @import("byte_view.spl");
 type .{ .Value, .int, .uint, .char, .str, .addr } = @import("value.spl");
 type .{ .BigInt, .Bits } = @import("mp.spl");
 
-// 注意：radix 边界直接用字面量。stage1 刻意不做常量求值/折叠，
+// radix 边界直接用字面量：顶层 const 不参与运行时常量折叠。
-// 顶层 const 不应用于运行时表达式。
+
 fn valid_radix(radix: u8): bool {
     ret radix >= 2 && radix <= 36;
 }
@@ -71,7 +71,6 @@ fn append_bool(out: *ByteBuffer, value: bool): Status {
     ret ByteBuffer.append(out, "false");
 }
 
-// ---- 显式装箱值格式化 ----
 
 // Int/Uint 落到整数；signed 仅对 Int 的十进制生效，其余按无符号位模式输出。
 fn append_value_int(out: *ByteBuffer, value: Value, radix: u8, uppercase: bool,
@@ -223,7 +222,6 @@ fn format(out: *ByteBuffer, fmt: []u8, args: []Value): Status {
     ret ByteBuffer.append(out, ByteBuffer.as_slice(temp));
 }
 
-// ---- 测试辅助 ----
 
 fn expect_ok(result: Status) {
     match result {

stage2/utils/hash.spl

@@ -34,7 +34,6 @@ fn hash_usize_value(value: usize): usize {
     ret h;
 }
 
-// ---- map 回调 ----
 
 // 键按 usize 解释。
 fn hash_usize(key: *u8): usize {
@@ -55,7 +54,6 @@ fn eq_view(a: *u8, b: *u8): bool {
     ret ByteView.eq((a as *ByteView).*, (b as *ByteView).*);
 }
 
-// ---- 测试辅助 ----
 
 fn expect_hash(view: []u8, expected: usize) {
     var got = hash_bytes(view.ptr, view.len);

stage2/utils/io.spl

@@ -1,11 +1,7 @@
 // Expect retcode = 0
 
-// I/O 便利层（构建在 sys/file 之上）：
+// sys/file 之上的 I/O 便利层：C 字符串路径 open、精确读取/完整写入、整读、stdout/stderr 打印。
-//   - C 字符串路径/模式的 open 包装
+// 短读/短写零进展与关闭失败返回 Err(.Io)；写入失败不承诺回滚。
-//   - 精确读取、完整写入和普通文件整读
-//   - stdout/stderr 打印
-// 说明：read_all 会按文件大小一次性读入 ByteBuffer；不处理增长中的文件。
-// 短读、短写后的零进展及关闭失败返回 Err(.Io)；文件写入不承诺回滚。
 
 type .{ .Error, .Status, .make } = @import("error.spl");
 type .{ .ByteView } = @import("byte_view.spl");
@@ -130,7 +126,6 @@ fn read_all(path: ByteView, out: *ByteBuffer): Status {
     ret .Ok;
 }
 
-// ---- 测试辅助 ----
 
 fn view(text: []u8): ByteView {
     ret ByteView.from_slice(text);

stage2/utils/json.spl

@@ -1,10 +1,6 @@
 // Expect retcode = 0
-// 轻量 JSON 解析 / 输出器（递归下降 + 节点池），用于验证底层库的拼装，未来服务 LSP。
+// 轻量 JSON 解析/输出器：输入按源切片借用、不解码（round-trip 保真），数字不做数值化。
-// 设计：
+// 节点/子项存 Vec 保留插入顺序；输出写 ByteBuffer。递归/输出深度上限见 max_depth()。
-//   - 输入 ByteView，字符串/数字以“源切片”借用，不做解码，round-trip 保真；
-//   - 节点池 Vec[JsonNode]；数组/对象子项存 Vec[JsonChild]，保留插入顺序；
-//   - 错误带字节位置（error.spl）；输出写 ByteBuffer；缩进/数字用 ByteBuffer/fmt。
-// 限制：不做字符串转义解码、数字不做数值化（原样保存）；递归/输出深度上限见 max_depth()。
 
 type .{ .Error, .Status, .make, .at } = @import("error.spl");
 type .{ .ByteView, .ViewResult, .FindResult } = @import("byte_view.spl");
@@ -393,7 +389,7 @@ fn root_index(doc: *Json): usize {
     ret doc.root;
 }
 
-// 枚举 tag 取整（stage1 枚举 == 有缺陷，用 @enum2int 比较更稳妥）。
+// 枚举 tag 取整：枚举 == 不可靠，用 @enum2int 比较。
 fn kind_code(kind: JsonKind): usize {
     ret @enum2int(kind) as usize;
 }
@@ -578,7 +574,6 @@ fn emit_pretty(out: *ByteBuffer, doc: *Json, indent: usize): Status {
     ret emit(out, doc, doc.root, indent, 0);
 }
 
-// ---- 构造辅助（写 JSON 片段；字符串需由调用方保证已转义）----
 
 fn write_int(out: *ByteBuffer, value: i64): Status {
     ret append_i64(out, value, 10, false);
@@ -588,7 +583,6 @@ fn write_u64(out: *ByteBuffer, value: u64): Status {
     ret append_u64(out, value, 10, false);
 }
 
-// ---- 测试辅助 ----
 
 fn expect_ok(result: Status) {
     match result {

stage2/utils/log.spl

@@ -89,7 +89,6 @@ fn fatal(self: *Logger, message: []u8) {
     Exit.fail();
 }
 
-// ---- 格式化入口（显式装箱，见 value.spl / fmt.format）----
 
 // 先格式化到临时缓冲；格式错误在写出前返回 Err(.InvalidFormat)。
 fn logf(self: *Logger, level: Level, fmt: []u8, args: []Value): Status {
@@ -125,7 +124,6 @@ fn fatalf(self: *Logger, fmt: []u8, args: []Value) {
     Exit.fail();
 }
 
-// ---- 测试 ----
 
 fn expect_name(level: Level, expected: []u8) {
     @assert(ByteView.eq(ByteView.from_slice(level_name(level)),

stage2/utils/lsp_frame.spl

@@ -99,7 +99,6 @@ fn parse_frame(input: ByteView, body_out: *ByteBuffer): FrameResult {
     ret .Ok(body_start + content_len);
 }
 
-// ---- 测试辅助 ----
 
 fn expect_ok(result: Status) {
     match result {

stage2/utils/map.spl

@@ -7,9 +7,14 @@
 type .{ .Error, .Status, .make } = @import("error.spl");
 type .{ .Vec } = @import("vec.spl");
 type .{ .ByteView } = @import("byte_view.spl");
-type .{ .hash_usize, .eq_usize, .hash_view, .eq_view } = @import("hash.spl");
+
-type .{ .checked_add, .checked_mul, .grow_capacity } = @import("memory.spl");
+#extern(vm) fn vm_map_valid(m: *any): i32;
-type .{ .copy } = @import("../sys/mem.spl");
+#extern(vm) fn vm_map_reserve(m: *any, need: usize): i32;
+#extern(vm) fn vm_map_put(m: *any, key: *any, val: *any): i32;
+#extern(vm) fn vm_map_get(m: *any, key: *any, out: *any): i32;
+#extern(vm) fn vm_map_del(m: *any, key: *any): i32;
+#extern(vm) fn vm_map_clear(m: *any): void;
+#extern(vm) fn vm_map_drop(m: *any): void;
 
 // 槽位状态：Empty/Occupied/Deleted（墓碑，仅在扩容重哈希时清除）。
 // 负载因子 70/128。
@@ -20,11 +25,6 @@ type SlotState = enum {
     Deleted,
 }
 
-fn state_code(state: SlotState): u8 {
-    var s: SlotState = state;
-    ret @enum2int(s) as u8;
-}
-
 // 查找/删除结果：显式区分命中与缺失，替代 bool 哨兵。
 type LookupResult = enum {
     Found,
@@ -39,11 +39,15 @@ states: Vec,
 size: usize,
 key_size: usize,
 val_size: usize,
-hash_fn: fn(*u8): usize,
+hash_kind: usize,
-eq_fn: fn(*u8, *u8): bool,
+
+// 键解释：0 = usize；1 = ByteView（按内容哈希/比较）。
+fn hash_kind_usize(): usize { ret 0; }
+fn hash_kind_view(): usize { ret 1; }
+fn hash_kind_constant(): usize { ret 2; }
 
 fn blank(key_size: usize, key_align: usize, val_size: usize, val_align: usize,
-         hash_fn: fn(*u8): usize, eq_fn: fn(*u8, *u8): bool): Map {
+         hash_kind: usize): Map {
     ret Map {
         .keys = Vec.blank(key_size, key_align),
         .vals = Vec.blank(val_size, val_align),
@@ -51,23 +55,30 @@ fn blank(key_size: usize, key_align: usize, val_size: usize, val_align: usize,
         .size = 0,
         .key_size = key_size,
         .val_size = val_size,
-        .hash_fn = hash_fn,
+        .hash_kind = hash_kind,
-        .eq_fn = eq_fn,
     };
 }
 
 fn new(key_size: usize, key_align: usize, val_size: usize, val_align: usize,
-       hash_fn: fn(*u8): usize, eq_fn: fn(*u8, *u8): bool): Map {
+       hash_kind: usize): Map {
-    ret blank(key_size, key_align, val_size, val_align, hash_fn, eq_fn);
+    ret blank(key_size, key_align, val_size, val_align, hash_kind);
 }
 
-fn valid(self: Map): bool {
+fn status_from_code(code: i32): Status {
-    if self.key_size == 0 || self.val_size == 0 { ret false; }
+    if code == 0 { ret .Ok; }
-    if self.states.len != self.keys.len || self.states.len != self.vals.len {
+    if code == 2 { ret .Err(make(.OutOfRange)); }
-        ret false;
+    if code == 3 { ret .Err(make(.Overflow)); }
-    }
+    if code == 4 { ret .Err(make(.InvalidAlignment)); }
-    if self.size > self.states.len { ret false; }
+    ret .Err(make(.InvalidArgument));
-    ret true;
+}
+
+fn lookup_from_code(code: i32): LookupResult {
+    if code == 0 { ret .Found; }
+    ret .NotFound;
+}
+
+fn valid(self: *Map): bool {
+    ret vm_map_valid(self as *any) != 0;
 }
 
 fn size(self: Map): usize {
@@ -85,10 +96,8 @@ fn slot_count(self: Map): usize {
 
 fn slot_state(self: Map, index: usize): SlotState {
     var code = self.states.data[index];
-    var occupied: SlotState = .Occupied;
+    if code == 1 { ret .Occupied; }
-    var deleted_state: SlotState = .Deleted;
+    if code == 2 { ret .Deleted; }
-    if code == state_code(occupied) { ret .Occupied; }
-    if code == state_code(deleted_state) { ret .Deleted; }
     ret .Empty;
 }
 
@@ -109,186 +118,32 @@ fn val_at(self: *Map, index: usize): *u8 {
     ret self.vals.data + index * self.val_size;
 }
 
-// 返回占用键的槽位；未找到返回 ~0。容量为 0 时直接未找到。
-fn find_slot(self: *Map, key: *u8): usize {
-    if self.states.cap == 0 { ret ~(0 as usize); }
-    var mask = self.states.cap - 1;
-    var i = self.hash_fn(key) & mask;
-    var empty: SlotState = .Empty;
-    var occupied: SlotState = .Occupied;
-    var probes: usize = 0;
-    while probes < self.states.cap && self.states.data[i] != state_code(empty) {
-        if self.states.data[i] == state_code(occupied) &&
-           self.eq_fn(self.keys.data + i * self.key_size, key) {
-            ret i;
-        }
-        i = (i + 1) & mask;
-        probes = probes + 1;
-    }
-    ret ~(0 as usize);
-}
-
-// 要求容量非零且键不存在。优先复用探测链中的第一个墓碑。
-fn place(self: *Map, key: *u8, val: *u8) {
-    var mask = self.states.cap - 1;
-    var i = self.hash_fn(key) & mask;
-    var empty: SlotState = .Empty;
-    var deleted: SlotState = .Deleted;
-    var occupied: SlotState = .Occupied;
-    var first_deleted = ~(0 as usize);
-    var probes: usize = 0;
-    while probes < self.states.cap && self.states.data[i] != state_code(empty) {
-        if self.states.data[i] == state_code(deleted) && first_deleted == ~(0 as usize) {
-            first_deleted = i;
-        }
-        i = (i + 1) & mask;
-        probes = probes + 1;
-    }
-    if first_deleted != ~(0 as usize) {
-        i = first_deleted;
-    }
-    copy((self.keys.data + i * self.key_size) as *any, key as *any, self.key_size);
-    copy((self.vals.data + i * self.val_size) as *any, val as *any, self.val_size);
-    self.states.data[i] = state_code(occupied);
-    self.size = self.size + 1;
-}
-
 // 保证至少 need 个槽位。所有检查在旧表改动前完成，失败保持原表不变。
 fn reserve(self: *Map, need: usize): Status {
-    if !valid(self.*) { ret .Err(make(.InvalidArgument)); }
+    ret status_from_code(vm_map_reserve(self as *any, need));
-    if need <= self.states.cap { ret .Ok; }
-
-    var new_cap = grow_capacity(self.states.cap, 8, need);
-
-    var fresh = self.*;
-    fresh.keys = Vec.blank(self.key_size, self.keys.elem_align);
-    fresh.vals = Vec.blank(self.val_size, self.vals.elem_align);
-    fresh.states = Vec.blank(1, 1);
-    fresh.size = 0;
-
-    match Vec.reserve(&fresh.keys, new_cap) {
-        .Ok => {},
-        .Err(error) => { drop(&fresh); ret .Err(error); },
-    }
-    match Vec.reserve(&fresh.vals, new_cap) {
-        .Ok => {},
-        .Err(error) => { drop(&fresh); ret .Err(error); },
-    }
-    match Vec.reserve(&fresh.states, new_cap) {
-        .Ok => {},
-        .Err(error) => { drop(&fresh); ret .Err(error); },
-    }
-    fresh.keys.len = new_cap;
-    fresh.vals.len = new_cap;
-    fresh.states.len = new_cap;
-
-    var i: usize = 0;
-    var empty: SlotState = .Empty;
-    var occupied: SlotState = .Occupied;
-    while i < new_cap {
-        fresh.states.data[i] = state_code(empty);
-        i = i + 1;
-    }
-
-    i = 0;
-    while i < self.states.len {
-        if self.states.data[i] == state_code(occupied) {
-            place(&fresh, self.keys.data + i * self.key_size,
-                  self.vals.data + i * self.val_size);
-        }
-        i = i + 1;
-    }
-
-    var old_keys = self.keys;
-    var old_vals = self.vals;
-    var old_states = self.states;
-    self.* = fresh;
-    Vec.drop(&old_keys);
-    Vec.drop(&old_vals);
-    Vec.drop(&old_states);
-    ret .Ok;
 }
 
 // 覆盖已存在的键；否则插入并可能扩容。
 fn put(self: *Map, key: *u8, val: *u8): Status {
-    if !valid(self.*) || key == null || val == null {
+    ret status_from_code(vm_map_put(self as *any, key as *any, val as *any));
-        ret .Err(make(.InvalidArgument));
-    }
-
-    var existing = find_slot(self, key);
-    if existing != ~(0 as usize) {
-        copy((self.vals.data + existing * self.val_size) as *any, val as *any, self.val_size);
-        ret .Ok;
-    }
-
-    if self.states.cap == 0 {
-        match reserve(self, 8) {
-            .Ok => {},
-            .Err(error) => { ret .Err(error); },
-        }
-    } else {
-        var next_size: usize = 0;
-        match checked_add(self.size, 1) {
-            .Ok(value) => { next_size = value; },
-            .Err(error) => { ret .Err(error); },
-        }
-        var scaled: usize = 0;
-        match checked_mul(next_size, 128) {
-            .Ok(value) => { scaled = value; },
-            .Err(error) => { ret .Err(error); },
-        }
-        if scaled / self.states.cap >= 70 {
-            var need: usize = 0;
-            match checked_mul(self.states.cap, 2) {
-                .Ok(value) => { need = value; },
-                .Err(error) => { ret .Err(error); },
-            }
-            match reserve(self, need) {
-                .Ok => {},
-                .Err(error) => { ret .Err(error); },
-            }
-        }
-    }
-
-    place(self, key, val);
-    ret .Ok;
 }
 
 // 找到键则把值复制到 out 并返回 Found；否则 out 不变并返回 NotFound。
 fn get(self: *Map, key: *u8, out: *u8): LookupResult {
-    if !valid(self.*) || key == null || out == null { ret .NotFound; }
+    ret lookup_from_code(vm_map_get(self as *any, key as *any, out as *any));
-    var i = find_slot(self, key);
-    if i == ~(0 as usize) { ret .NotFound; }
-    copy(out as *any, (self.vals.data + i * self.val_size) as *any, self.val_size);
-    ret .Found;
 }
 
 fn del(self: *Map, key: *u8): LookupResult {
-    if !valid(self.*) || key == null { ret .NotFound; }
+    ret lookup_from_code(vm_map_del(self as *any, key as *any));
-    var i = find_slot(self, key);
-    if i == ~(0 as usize) { ret .NotFound; }
-    var deleted_state: SlotState = .Deleted;
-    self.states.data[i] = state_code(deleted_state);
-    self.size = self.size - 1;
-    ret .Found;
 }
 
 // 清空内容但保留容量。墓碑与负载计数一并复位。
 fn clear(self: *Map) {
-    var i: usize = 0;
+    vm_map_clear(self as *any);
-    var empty: SlotState = .Empty;
-    while i < self.states.len {
-        self.states.data[i] = state_code(empty);
-        i = i + 1;
-    }
-    self.size = 0;
 }
 
 fn drop(self: *Map) {
-    Vec.drop(&self.keys);
+    vm_map_drop(self as *any);
-    Vec.drop(&self.vals);
-    Vec.drop(&self.states);
-    self.size = 0;
 }
 
 fn take(source: *Map): Map {
@@ -300,7 +155,6 @@ fn take(source: *Map): Map {
     ret result;
 }
 
-// ---- 测试辅助 ----
 
 fn expect_ok(result: Status) {
     match result {
@@ -348,13 +202,13 @@ fn deleted(m: *Map, key: *u8): bool {
 }
 
 fn make_int_map(): Map {
-    ret new(@sizeof(usize), @alignof(usize), @sizeof(i32), @alignof(i32), hash_usize, eq_usize);
+    ret new(@sizeof(usize), @alignof(usize), @sizeof(i32), @alignof(i32), hash_kind_usize());
 }
 
 fn test_put_get_update() {
     var m = make_int_map();
     @assert(size(m) == 0 && capacity(m) == 0, "empty map");
-    @assert(valid(m));
+    @assert(valid(&m));
 
     var key: usize = 0;
     var value: i32 = 0;
@@ -367,7 +221,7 @@ fn test_put_get_update() {
     key = 7;
     value = 70;
     expect_ok(put(&m, &key as *u8, &value as *u8));
-    @assert(size(m) == 1 && valid(m));
+    @assert(size(m) == 1 && valid(&m));
 
     out = -1;
     @assert(found(&m, &key as *u8, &out as *u8) && out == 70, "insert then get");
@@ -463,7 +317,7 @@ fn test_take_and_self_put() {
 
 fn test_byte_view_keys() {
     var m = new(@sizeof(ByteView), @alignof(ByteView), @sizeof(i32), @alignof(i32),
-                hash_view, eq_view);
+                hash_kind_view());
     defer { drop(&m); }
 
     var alpha = ByteView.from_slice("alpha");

stage2/utils/memory.spl

@@ -1,12 +1,23 @@
 // Expect retcode = 0
 
-// 尺寸计算和字节移动；不分配、不释放内存，不改变任何资源的所有权。
+// 尺寸计算、字节移动与内存分配统一门面（分配/释放转发自 sys/mem）。
+// 本模块不改变任何资源的所有权。
 
 type .{ .Error, .Status, .make } = @import("error.spl");
+type SysMem = @import("../sys/mem.spl");
+
+// 分配/释放/字节操作转发（core 只经本模块使用内存，不直接依赖 sys）。
+fn alloc(sz: usize): *any { ret SysMem.alloc(sz); }
+fn free(p: *any) { SysMem.free(p); }
+fn realloc(p: *any, sz: usize): *any { ret SysMem.realloc(p, sz); }
+fn copy(dst: *any, src: *any, n: usize): *any { ret SysMem.copy(dst, src, n); }
+fn cmp(a: *any, b: *any, n: usize): isize { ret SysMem.cmp(a, b, n); }
+fn set(dst: *any, byte: u8, n: usize): *any { ret SysMem.set(dst, byte, n); }
+fn zero(dst: *any, n: usize): *any { ret SysMem.zero(dst, n); }
 
 #extern(vm) fn vm_memcpy(dst: *any, src: *any, n: usize): *any;
+#extern(vm) fn vm_memmove(dst: *any, src: *any, n: usize): *any;
 
-fn ignore_ptr(p: *any) {}
 
 type SizeResult = enum {
     Ok: usize,
@@ -73,31 +84,8 @@ fn move(dst: []u8, src: []u8): Status {
     }
     if dst_addr == src_addr { ret .Ok; }
 
-    // 非重叠且较大时走原生 memcpy（Vec 扩容复制是常见场景）。
+    // 重叠安全，统一走原生 memmove。
-    var non_overlap = false;
+    vm_memmove(dst.ptr as *any, src.ptr as *any, count);
-    if dst_addr < src_addr {
-        if src_addr - dst_addr >= count { non_overlap = true; }
-    } else {
-        if dst_addr - src_addr >= count { non_overlap = true; }
-    }
-    if non_overlap && count >= 16 {
-        ignore_ptr(vm_memcpy(dst.ptr as *any, src.ptr as *any, count));
-        ret .Ok;
-    }
-
-    if dst_addr < src_addr {
-        var i: usize = 0;
-        while i < count {
-            dst.ptr[i] = src.ptr[i];
-            i = i + 1;
-        }
-    } else {
-        var i = count;
-        while i > 0 {
-            i = i - 1;
-            dst.ptr[i] = src.ptr[i];
-        }
-    }
     ret .Ok;
 }
 

stage2/utils/path.spl

@@ -297,7 +297,6 @@ fn normalize_into(out: *ByteBuffer, path: ByteView, style: PathStyle): Status {
     ret .Ok;
 }
 
-// ---- 测试 ----
 fn expect_ok(result: Status) {
     match result { .Ok => {}, .Err(error) => { @assert(false, "unexpected path error"); }, }
 }

stage2/utils/profile.spl

@@ -1,10 +1,7 @@
 // Expect retcode = 0
 
-// 全量热点/耗时记录器（配合 @file_name()/@line()/@col() 与 sys/time.spl）。
+// 采样热点记录器：每个调用点聚合 count 与 self/total 的 steps/ns（self = total 减子区间）。
-// 每个调用点聚合：count、独占(self)与包含(total)的 steps/ns。
+// 严格 LIFO，用 defer 配对：
-//   - total_* 含被调用者（嵌套会重复，跨站点求和会超过墙钟）
-//   - self_*  = total_* - 子区间之和，用于定位真正的热点
-// 用法（严格 LIFO，defer 正好满足）：
 //     var tok = Profile.begin(&prof, @file_name(), @line(), @col());
 //     defer { Profile.end(&prof, tok); }
 
@@ -139,7 +136,7 @@ fn begin(self: *Profile, fname: []u8, line: usize, col: usize): usize {
         .Err(error) => { ret 0; },
     }
     var token = self.spans.len - 1;
-    match Vec.push(&self.stack, &token as *u8) { .Ok => {}, .Err(error) => {} }
+    Vec.push(&self.stack, &token as *u8);
     ret token;
 }
 
@@ -164,7 +161,7 @@ fn end(self: *Profile, token: usize) {
 
     // 弹栈并把区间计入父 span（LIFO）。
     var popped: usize = 0;
-    match Vec.pop(&self.stack, &popped as *u8) { .Ok => {}, .Err(error) => {} }
+    Vec.pop(&self.stack, &popped as *u8);
     var n = self.stack.len;
     if n > 0 {
         var p = span_at(self, usize_at(&self.stack, n - 1));
@@ -175,7 +172,6 @@ fn end(self: *Profile, token: usize) {
     }
 }
 
-// ---- dump / save ----
 
 fn out_s(out: *ByteBuffer, s: []u8): bool {
     match ByteBuffer.append(out, s) { .Ok => { ret true; }, .Err(error) => { ret false; } }
@@ -202,7 +198,7 @@ fn dump(self: *Profile, out: *ByteBuffer): bool {
     defer { Vec.drop(&idx); }
     var i: usize = 0;
     while i < self.sites.len {
-        match Vec.push(&idx, &i as *u8) { .Ok => {}, .Err(error) => {} }
+        Vec.push(&idx, &i as *u8);
         i = i + 1;
     }
 
@@ -271,7 +267,6 @@ fn save(self: *Profile, path: ByteView): bool {
     ret true;
 }
 
-// ---- 测试 ----
 
 fn spin(n: usize): usize {
     var i: usize = 0;
@@ -293,10 +288,9 @@ fn test_profile() {
     @assert(s != null && s.count >= 1, "count");
     @assert(s.total_steps > 0, "steps");
     @assert(s.self_steps > 0, "self steps");
-    if v == 0 { ignore_usize(v + 1); }
+    if v == 0 { v + 1; }
 }
 
-fn ignore_usize(v: usize) {}
 
 fn main() {
     test_profile();

stage2/utils/set.spl

@@ -3,7 +3,8 @@
 // 开放寻址集合。键按字节复制到集合自己的存储中；集合只释放自身存储，
 // 不释放键值内部引用的资源。哈希与相等回调的约定和 Map 一致。
 type .{ .Status } = @import("error.spl");
-type .{ .Map, .LookupResult } = @import("map.spl");
+type .{ .Map, .LookupResult, .hash_kind_usize, .hash_kind_view, .hash_kind_constant } =
+    @import("map.spl");
 type .{ .ByteView } = @import("byte_view.spl");
 type .{ .hash_usize, .eq_usize, .hash_view, .eq_view } = @import("hash.spl");
 
@@ -11,15 +12,14 @@ type Set = @self;
 
 map: Map,
 
-fn new(key_size: usize, key_align: usize,
+fn new(key_size: usize, key_align: usize, hash_kind: usize): Set {
-       hash_fn: fn(*u8): usize, eq_fn: fn(*u8, *u8): bool): Set {
     ret Set {
-        .map = Map.new(key_size, key_align, 1, 1, hash_fn, eq_fn),
+        .map = Map.new(key_size, key_align, 1, 1, hash_kind),
     };
 }
 
 fn valid(self: Set): bool {
-    ret Map.valid(self.map) && self.map.val_size == 1;
+    ret Map.valid(&self.map) && self.map.val_size == 1;
 }
 
 fn size(self: Set): usize {
@@ -74,7 +74,6 @@ fn drop(self: *Set) {
     Map.drop(&self.map);
 }
 
-// ---- 测试 ----
 
 fn expect_ok(result: Status) {
     match result {
@@ -104,7 +103,7 @@ fn constant_hash(key: *u8): usize {
 }
 
 fn test_insert_find_remove() {
-    var set = new(@sizeof(usize), @alignof(usize), hash_usize, eq_usize);
+    var set = new(@sizeof(usize), @alignof(usize), hash_kind_usize());
     defer { drop(&set); }
     @assert(valid(set));
     @assert(size(set) == 0 && capacity(set) == 0);
@@ -169,7 +168,7 @@ fn test_insert_find_remove() {
 }
 
 fn test_collisions_and_take() {
-    var set = new(@sizeof(usize), @alignof(usize), constant_hash, eq_usize);
+    var set = new(@sizeof(usize), @alignof(usize), hash_kind_constant());
     defer { drop(&set); }
 
     var i: usize = 0;
@@ -213,7 +212,7 @@ fn test_collisions_and_take() {
 }
 
 fn test_byte_view_keys() {
-    var set = new(@sizeof(ByteView), @alignof(ByteView), hash_view, eq_view);
+    var set = new(@sizeof(ByteView), @alignof(ByteView), hash_kind_view());
     defer { drop(&set); }
 
     var alpha = ByteView.from_slice("alpha");

stage2/utils/source.spl

@@ -6,7 +6,7 @@
 type .{ .Error, .Status, .make } = @import("error.spl");
 type .{ .ByteView, .FindResult } = @import("byte_view.spl");
 type .{ .Vec } = @import("vec.spl");
-type .{ .Map } = @import("map.spl");
+type .{ .Map, .hash_kind_view } = @import("map.spl");
 type .{ .hash_view, .eq_view } = @import("hash.spl");
 
 type Position = struct {
@@ -123,7 +123,6 @@ fn drop(self: *Source) {
     Vec.drop(&self.line_starts);
 }
 
-// ---- 多文件集合 ----
 
 type Sources = struct {
     items: Vec,   // Source
@@ -134,7 +133,7 @@ fn set_new(): Sources {
     ret Sources {
         .items = Vec.blank(@sizeof(Source), 8),
         .by_name = Map.blank(@sizeof(ByteView), @alignof(ByteView), @sizeof(usize),
-                             @alignof(usize), hash_view, eq_view),
+                             @alignof(usize), hash_kind_view()),
     };
 }
 
@@ -191,7 +190,6 @@ fn set_drop(set: *Sources) {
     Map.drop(&set.by_name);
 }
 
-// ---- 测试辅助 ----
 
 fn view(text: []u8): ByteView {
     ret ByteView.from_slice(text);

stage2/utils/str.spl

@@ -122,7 +122,6 @@ fn drop(self: *Str) {
     ByteBuffer.drop(&self.storage);
 }
 
-// ---- 测试辅助 ----
 
 fn expect_ok(result: Status) {
     match result {

stage2/utils/utf8.spl

@@ -181,7 +181,6 @@ fn utf16_to_byte(data: *u8, len: usize, utf16_off: usize): usize {
     ret i;
 }
 
-// ---- 测试辅助 ----
 
 fn expect_ok(result: Status) {
     match result {

stage2/utils/value.spl

@@ -43,7 +43,6 @@ fn addr(value: *any): Value {
     ret .Ptr(value);
 }
 
-// ---- 测试 ----
 
 fn test_int_and_uint() {
     match int(-5) {

stage2/utils/vec.spl

@@ -7,6 +7,18 @@ type .{ .Error, .Kind, .Status } = @import("error.spl");
 type .{ .SizeResult, .checked_add, .checked_mul, .grow_capacity, .move } = @import("memory.spl");
 type .{ .alloc, .copy, .free } = @import("../sys/mem.spl");
 
+#extern(vm) fn vm_vec_valid(v: *any): i32;
+#extern(vm) fn vm_vec_push_raw(v: *any, elem: *any): i32;
+#extern(vm) fn vm_vec_push(v: *any, elem: *any): i32;
+#extern(vm) fn vm_vec_get(v: *any, index: usize, out: *any): i32;
+#extern(vm) fn vm_vec_allocate(out: *any, capacity: usize, elem_size: usize, elem_align: usize): i32;
+#extern(vm) fn vm_vec_reserve_raw(v: *any, need: usize): i32;
+#extern(vm) fn vm_vec_append(v: *any, elems: *any, count: usize): i32;
+#extern(vm) fn vm_vec_set(v: *any, index: usize, elem: *any): i32;
+#extern(vm) fn vm_vec_pop(v: *any, out: *any): i32;
+#extern(vm) fn vm_vec_clone(out: *any, src: *any): i32;
+#extern(vm) fn vm_vec_drop(v: *any): void;
+
 type Vec = @self;
 
 raw: *u8,
@@ -51,95 +63,41 @@ fn new(elem_size: usize, elem_align: usize): VecResult {
 
 // 按指针接收，避免每次调用复制整个 Vec；内联对齐检查，省一次函数调用。
 fn valid(self: *Vec): bool {
-    if self.elem_size == 0 { ret false; }
+    ret vm_vec_valid(self as *any) != 0;
-    var a = self.elem_align;
-    if a == 0 || (a & (a - 1)) != 0 { ret false; }
-    if self.len > self.cap { ret false; }
-    if self.cap == 0 {
-        ret self.raw == null && self.data == null && self.len == 0;
-    }
-    if self.raw == null || self.data == null { ret false; }
-    ret (self.data as usize & (a - 1)) == 0;
 }
 
 fn status_error(kind: Kind): Status {
     ret .Err(Error.make(kind));
 }
 
+// native 错误码 -> Error.Kind（0 ok / 1 InvalidArgument / 2 OutOfRange / 3 Overflow / 4 InvalidAlignment）
+fn kind_from_code(code: i32): Kind {
+    if code == 2 { ret .OutOfRange; }
+    if code == 3 { ret .Overflow; }
+    if code == 4 { ret .InvalidAlignment; }
+    ret .InvalidArgument;
+}
+
+fn status_from_code(code: i32): Status {
+    if code == 0 { ret .Ok; }
+    ret status_error(kind_from_code(code));
+}
+
 // 计算元素区字节数。错误时不修改任何 Vec。
 fn byte_count(count: usize, elem_size: usize): SizeResult {
     ret checked_mul(count, elem_size);
 }
 
 fn allocate(capacity: usize, elem_size: usize, elem_align: usize): VecResult {
-    if elem_size == 0 { ret .Err(Error.make(.InvalidArgument)); }
+    var v: Vec = undefined;
-    if !valid_alignment(elem_align) {
+    var rc = vm_vec_allocate(&v as *any, capacity, elem_size, elem_align);
-        ret .Err(Error.make(.InvalidAlignment));
+    if rc == 0 { ret .Ok(v); }
-    }
+    ret .Err(Error.make(kind_from_code(rc)));
-    if capacity == 0 { ret .Ok(blank(elem_size, elem_align)); }
-
-    var bytes: usize = 0;
-    match byte_count(capacity, elem_size) {
-        .Ok(value) => { bytes = value; },
-        .Err(error) => { ret .Err(error); },
-    }
-
-    var total: usize = 0;
-    match checked_add(bytes, elem_align - 1) {
-        .Ok(value) => { total = value; },
-        .Err(error) => { ret .Err(error); },
-    }
-
-    var raw = alloc(total) as *u8;
-    if raw == null {
-        ret .Err(Error.make(.Overflow));
-    }
-    var address = raw as usize;
-    var mask = elem_align - 1;
-    if address > (~(0 as usize)) - mask {
-        free(raw as *any);
-        ret .Err(Error.make(.Overflow));
-    }
-    var aligned = (address + mask) & ~mask;
-    ret .Ok(Vec {
-        .raw = raw,
-        .data = aligned as *u8,
-        .len = 0,
-        .cap = capacity,
-        .elem_size = elem_size,
-        .elem_align = elem_align,
-    });
 }
 
 // 与 reserve 相同，但假定调用方已校验 self（内部热路径用，省去重复 valid）。
 fn reserve_raw(self: *Vec, need: usize): Status {
-    if need <= self.cap { ret .Ok; }
+    ret status_from_code(vm_vec_reserve_raw(self as *any, need));
-
-    var new_cap = grow_capacity(self.cap, 8, need);
-
-    var fresh: Vec = undefined;
-    match allocate(new_cap, self.elem_size, self.elem_align) {
-        .Ok(value) => { fresh = value; },
-        .Err(error) => { ret .Err(error); },
-    }
-
-    var used_bytes: usize = 0;
-    match byte_count(self.len, self.elem_size) {
-        .Ok(value) => { used_bytes = value; },
-        .Err(error) => {
-            drop(&fresh);
-            ret .Err(error);
-        },
-    }
-    if used_bytes != 0 {
-        copy(fresh.data as *any, self.data as *any, used_bytes);
-    }
-    fresh.len = self.len;
-
-    var old_raw = self.raw;
-    self.* = fresh;
-    free(old_raw as *any);
-    ret .Ok;
 }
 
 // 保证至少可容纳 need 个元素（外部入口，含校验）。
@@ -154,81 +112,30 @@ fn with_capacity(elem_size: usize, elem_align: usize, capacity: usize): VecResul
 }
 
 fn get(self: *Vec, index: usize): PtrResult {
-    if !valid(self) { ret .Err(Error.make(.InvalidArgument)); }
+    var out: *u8 = null;
-    if index >= self.len { ret .Err(Error.make(.OutOfRange)); }
+    var rc = vm_vec_get(self as *any, index, &out as *any);
-    ret .Ok(self.data + index * self.elem_size);
+    if rc == 0 { ret .Ok(out); }
+    if rc == 2 { ret .Err(Error.make(.OutOfRange)); }
+    ret .Err(Error.make(.InvalidArgument));
 }
 
 fn set(self: *Vec, index: usize, elem: *u8): Status {
-    if !valid(self) || elem == null { ret status_error(.InvalidArgument); }
+    ret status_from_code(vm_vec_set(self as *any, index, elem as *any));
-    if index >= self.len { ret status_error(.OutOfRange); }
-    var dst = self.data + index * self.elem_size;
-    ret move(dst[0..self.elem_size], elem[0..self.elem_size]);
 }
 
 // 追加 count 个连续元素。elems 可以指向 self 当前已初始化的元素区。
 fn append(self: *Vec, elems: *u8, count: usize): Status {
-    if !valid(self) { ret status_error(.InvalidArgument); }
+    ret status_from_code(vm_vec_append(self as *any, elems as *any, count));
-    if count == 0 { ret .Ok; }
-    if elems == null { ret status_error(.InvalidArgument); }
-
-    var copy_bytes: usize = 0;
-    match byte_count(count, self.elem_size) {
-        .Ok(value) => { copy_bytes = value; },
-        .Err(error) => { ret .Err(error); },
-    }
-    var new_len: usize = 0;
-    match checked_add(self.len, count) {
-        .Ok(value) => { new_len = value; },
-        .Err(error) => { ret .Err(error); },
-    }
-
-    var used_bytes: usize = 0;
-    match byte_count(self.len, self.elem_size) {
-        .Ok(value) => { used_bytes = value; },
-        .Err(error) => { ret .Err(error); },
-    }
-
-    var source_inside = false;
-    var source_offset: usize = 0;
-    if used_bytes != 0 {
-        var base = self.data as usize;
-        var source = elems as usize;
-        if source >= base && source - base < used_bytes {
-            source_offset = source - base;
-            if copy_bytes > used_bytes - source_offset {
-                ret status_error(.OutOfRange);
-            }
-            source_inside = true;
-        }
-    }
-
-    match reserve_raw(self, new_len) {
-        .Ok => {},
-        .Err(error) => { ret .Err(error); },
-    }
-    if source_inside { elems = self.data + source_offset; }
-
-    var dst = self.data + used_bytes;
-    match move(dst[0..copy_bytes], elems[0..copy_bytes]) {
-        .Ok => {},
-        .Err(error) => { ret .Err(error); },
-    }
-    self.len = new_len;
-    ret .Ok;
 }
 
 fn push(self: *Vec, elem: *u8): Status {
-    ret append(self, elem, 1);
+    ret status_from_code(vm_vec_push(self as *any, elem as *any));
 }
 
 // 热路径：假定 self 有效且已有容量时直接写入；容量不足才回退到 append。
 fn push_raw(self: *Vec, elem: *u8): bool {
-    if self.len < self.cap {
+    if elem == null { ret false; }
-        copy(self.data + self.len * self.elem_size, elem, self.elem_size);
+    if vm_vec_push_raw(self as *any, elem as *any) != 0 { ret true; }
-        self.len = self.len + 1;
-        ret true;
-    }
     match append(self, elem, 1) {
         .Ok => { ret true; },
         .Err(error) => { ret false; },
@@ -238,15 +145,7 @@ fn push_raw(self: *Vec, elem: *u8): bool {
 
 // 将末元素复制到 out，然后缩短数组。out 可以与元素区重叠。
 fn pop(self: *Vec, out: *u8): Status {
-    if !valid(self) || out == null { ret status_error(.InvalidArgument); }
+    ret status_from_code(vm_vec_pop(self as *any, out as *any));
-    if self.len == 0 { ret status_error(.OutOfRange); }
-    var source = self.data + (self.len - 1) * self.elem_size;
-    match move(out[0..self.elem_size], source[0..self.elem_size]) {
-        .Ok => {},
-        .Err(error) => { ret .Err(error); },
-    }
-    self.len = self.len - 1;
-    ret .Ok;
 }
 
 fn clear(self: *Vec) {
@@ -256,31 +155,7 @@ fn clear(self: *Vec) {
 // 成功时先释放 out 原有存储再提交副本；失败保持 out 不变。
 // out 与 src 指向同一个 Vec 也允许。
 fn clone(out: *Vec, src: Vec): Status {
-    if !valid(out) || !valid(&src) { ret status_error(.InvalidArgument); }
+    ret status_from_code(vm_vec_clone(out as *any, &src as *any));
-    if out.elem_size != src.elem_size || out.elem_align != src.elem_align {
-        ret status_error(.InvalidArgument);
-    }
-
-    var fresh = blank(src.elem_size, src.elem_align);
-    match reserve(&fresh, src.len) {
-        .Ok => {},
-        .Err(error) => { ret .Err(error); },
-    }
-    var bytes: usize = 0;
-    match byte_count(src.len, src.elem_size) {
-        .Ok(value) => { bytes = value; },
-        .Err(error) => {
-            drop(&fresh);
-            ret .Err(error);
-        },
-    }
-    if bytes != 0 {
-        copy(fresh.data as *any, src.data as *any, bytes);
-    }
-    fresh.len = src.len;
-    drop(out);
-    out.* = fresh;
-    ret .Ok;
 }
 
 // 显式转移所有权，返回值必须由接收方最终 drop。
@@ -291,10 +166,7 @@ fn take(source: *Vec): Vec {
 }
 
 fn drop(self: *Vec) {
-    var elem_size = self.elem_size;
+    vm_vec_drop(self as *any);
-    var elem_align = self.elem_align;
-    free(self.raw as *any);
-    self.* = blank(elem_size, elem_align);
 }
 
 fn expect_ok(result: Status) {

tests/stage1/001_main.spl

@@ -0,0 +1,5 @@
+// Expect retcode = 0
+
+fn main(): i32 {
+    ret 0;
+}

tests/stage1/002_ident.spl

@@ -0,0 +1,6 @@
+// Expect retcode = 1
+
+fn main(): i32 {
+    var x: i32 = 1;
+    ret x;
+}

tests/stage1/003_assign.spl

@@ -0,0 +1,7 @@
+// Expect retcode = 0
+
+fn main(): i32 {
+    var x: i32 = undefined;
+    x = 0;
+    ret x;
+}

tests/stage1/004_op.spl

@@ -0,0 +1,10 @@
+// Expect retcode = 42
+
+fn main(): i32 {
+    var x: i32 = undefined;
+    x = 1;
+    var y = 6 + x;
+    x -= y;
+    y *= x * -1;
+    ret y;
+}

tests/stage1/005_call.spl

@@ -0,0 +1,10 @@
+// Expect retcode = 6
+
+fn add(a: i32, b: i32): i32 {
+    ret a + b;
+}
+
+fn main(): i32 {
+    var a = add(1, 2);
+    ret add(a, 3);
+}

tests/stage1/006_cond.spl

@@ -0,0 +1,21 @@
+// Expect retcode = 10
+
+fn main(): i32 {
+    var result: i32 = 0;
+    var x: i32 = 0;
+    if x != 0 {
+        result += 1;
+    } else {
+        result += 2;
+    }
+
+    x = 2;
+    if x == 1 {
+        result += 4;
+    } else if x == 2 {
+        result += 8;
+    } else {
+        result += 16;
+    }
+    ret result;
+}

tests/stage1/007_while.spl

@@ -0,0 +1,9 @@
+// Expect retcode = 10
+
+fn main(): i32 {
+    var i: i32 = 0;
+    while i < 10 {
+        i = i + 1;
+    }
+    ret i;
+}

tests/stage1/008_slice.spl

@@ -0,0 +1,23 @@
+// Expect retcode = 20 
+
+fn main(): i32 {
+    var res: i32 = 0;
+    var array: [5]i32 = .[ 1, 2, 3, 4, 5 ];
+    var slice: []i32 = array[1..3];
+
+    var i: u64 = undefined;
+
+    i = 0;
+    while i < array.len {
+        res += array[i];
+        i += 1;
+    }
+
+    i = 0;
+    while i < slice.len {
+        res += slice[i];
+        i += 1;
+    }
+
+    ret res;
+}

tests/stage1/009_str.spl

@@ -0,0 +1,6 @@
+// Expect retcode = 4 
+
+fn main(): i32 {
+    var str = "hello world";
+    ret str[2] as i32 - str[0] as i32;
+}

tests/stage1/010_vmprintf.spl

@@ -0,0 +1,9 @@
+// Expect retcode = 0
+// Expect stdout = `hello vm_printf\n1 0 -1 65536\n`
+#extern(vm) fn vm_printf(fmt: []u8, ...);
+
+fn main(): () {
+    vm_printf("hello vm_printf\n");
+    vm_printf("%d %d %d %d\n", 1, 0, -1, 65536);
+    vm_printf("%s %d %s\n", "hello world", 666, "hello spl");
+}

tests/stage1/011_assert.spl

@@ -0,0 +1,11 @@
+// Expect retcode = 0
+
+fn main(): i32 {
+    @assert(0 == 0);
+    @assert(0 != 1);
+    @assert(1 != 0);
+    @assert(1 == 1);
+    @assert(true);
+    @assert(!false);
+    ret 0;
+}

tests/stage1/012_struct.spl

@@ -0,0 +1,19 @@
+// Expect retcode = 0
+
+type Vector2i = struct {
+    x: isize,
+    y: isize,
+}
+
+fn main() {
+    var v = Vector2i {};
+    v.x = -2;
+    v.y = 3;
+    @assert(v.x * v.y == -6);
+    @assert((v.x * v.y != -6) == false);
+    @assert((v.x * v.y * -1) as i32 == 6);
+
+    var a: Vector2i = .{ .y = 2 };
+    @assert(a.x == 0);
+    @assert(a.y == 2);
+}

tests/stage1/013_enum.spl

@@ -0,0 +1,21 @@
+// Expect retcode = 0
+// non-optimized
+
+type Rectangle = struct {
+    x: isize,
+    y: isize
+}
+
+type Shape = enum {
+    square: struct { x: isize },
+    rectangle: Rectangle,
+}
+
+fn main() {
+    var s: Shape = .{ .square = .{ .x = 6 } };
+    @assert(s.square.x == 6);
+    // non-optimized
+    @assert(s.rectangle.x == 6);
+    // non-optimized
+    @assert(s.rectangle.y == 0);
+}

tests/stage1/014_method.spl

@@ -0,0 +1,15 @@
+// Expect retcode = 0
+
+type Rectangle = struct {
+    fn area(self: *@self): isize {
+        ret self.x * self.y;
+    }
+    x: isize,
+    y: isize,
+}
+
+fn main() {
+    var r = Rectangle { .x = 2, .y = 3 };
+    @assert(r.area(&r) == 6, "method call");
+    @assert(Rectangle.area(&r) == 6, "type call");
+}

tests/stage1/015_order.spl

@@ -0,0 +1,30 @@
+// Expect retcode = 0
+
+type Outer = struct {
+    inner: Inner,
+    fn total(self: *@self): i32 {
+        ret self.compute(self) + constant_value();
+    }
+    fn compute(self: *@self): i32 {
+        ret self.inner.value;
+    }
+}
+
+type Inner = struct {
+    value: i32,
+    fn doubled(self: *@self): i32 {
+        ret self.value * 2;
+    }
+}
+
+fn main() {
+    var i: Inner = .{ .value = 21 };
+    @assert(i.doubled(&i) == 42);
+
+    var o: Outer = .{ .inner = i };
+    @assert(o.total(&o) == 21 + 7);
+}
+
+fn constant_value(): i32 {
+    ret 7;
+}

tests/stage1/016_tuple.spl

@@ -0,0 +1,12 @@
+// Expect retcode = 0
+
+fn main() {
+    var res = add((1, 2), (3, 4));
+    @assert(res[0] == 4);
+    @assert(res[1] == 6);
+    @assert(res[1] + res[0] == 10);
+}
+
+fn add(a: (i32, i32), b: (i32, i32)): (i32, i32) {
+    ret (a[0] + b[0], a[1] + b[1]);
+}

tests/stage1/017_label.spl

@@ -0,0 +1,54 @@
+// Expect retcode = 0
+
+fn main() {
+    var count: i32 = 0;
+    $outter while count < 10 {
+        $inner loop {
+            count = count + 1;
+            if count == 3 {
+                continue $outter;
+            }
+            if count == 7 {
+                break $outter;
+            }
+        }
+    }
+    @assert(count == 7);
+
+    count = 0;
+    while count < 10 {
+        count = count + 1;
+        if count == 5 {
+            break;
+        }
+    }
+    @assert(count == 5);
+
+    count = 0;
+    var sum: i32 = 0;
+    while count < 5 {
+        count = count + 1;
+        if count == 3 {
+            continue;
+        }
+        sum = sum + count;
+    }
+    @assert(sum == 12);
+
+    count = 0;
+    var outer_hits: i32 = 0;
+    $a loop {
+        $b loop {
+            count = count + 1;
+            if count == 2 {
+                continue;
+            }
+            break;
+        }
+        outer_hits = outer_hits + 1;
+        if outer_hits == 3 {
+            break;
+        }
+    }
+    @assert(outer_hits == 3);
+}

tests/stage1/018_defer.spl

@@ -0,0 +1,50 @@
+// Expect retcode = 0
+
+var g: i32 = 0;
+
+fn f1() {
+    defer { g = g + 1; }
+    defer { g = g * 10; }
+}
+
+fn f2(): i32 {
+    var x: i32 = 42;
+    defer { x = 100; }
+    ret x;
+}
+
+fn f3(): i32 {
+    defer { g = 999; }
+    ret 7;
+}
+
+fn f4(): i32 {
+    var acc: i32 = 0;
+    acc = acc + 1;
+    defer { acc = acc + 100; }
+    acc = acc + 10;
+    ret acc;
+}
+
+fn main() {
+    // 1. LIFO：先注册的 defer 最后执行
+    g = 0;
+    f1();
+    @assert(g == 1);   // 0 * 10 = 0, 0 + 1 = 1
+
+    // 2. ret 先求值再 defer，defer 改不了返回值
+    g = 0;
+    var r2: i32 = f2();
+    @assert(r2 == 42);
+    @assert(g == 0);
+
+    // 3. defer 在 ret 前执行
+    g = 0;
+    var r3: i32 = f3();
+    @assert(r3 == 7);
+    @assert(g == 999);
+
+    // 4. defer 里的代码对 ret 表达式的结果无影响
+    var r4: i32 = f4();
+    @assert(r4 == 11);   // acc = 1 + 10 = 11
+}

tests/stage1/019_null.spl

@@ -0,0 +1,15 @@
+// Expect retcode = 0
+
+fn main() {
+    var str: []u8 = undefined;
+    str = "hello world";
+    var p: *any = str.ptr;
+    @assert((p as *u8)[1] == 'e');
+    p = null;
+    @assert(p == null);
+    p = str.ptr as *u16 + 1;
+    @assert((p as *u8)[0] == 'l');
+    @assert((p as *u8).* == 'l');
+    @assert((&(p as *u8)[1])[1] == 'o');
+    @assert((&(p as *u8).*)[2] == 'o');
+}

tests/stage1/020_import.spl

@@ -0,0 +1,9 @@
+// Expect retcode = 0
+
+type Rectangle = @import("014_method.spl").Rectangle;
+
+fn main() {
+    var r = Rectangle { .x = 2, .y = 3 };
+    @assert(r.area(&r) == 6);
+    @assert(Rectangle.area(&r) == 6);
+}

tests/stage1/021_selfref.spl

@@ -0,0 +1,20 @@
+// Expect retcode = 0
+
+type Node = struct {
+    val: i32,
+    next: *Node,
+};
+
+fn sum(n: *Node): i32 {
+    if n == null {
+        ret 0;
+    }
+    ret n.val + sum(n.next);
+}
+
+fn main() {
+    var a = Node { .val = 1, .next = null };
+    var b = Node { .val = 2, .next = &a };
+    var c = Node { .val = 3, .next = &b };
+    @assert(sum(&c) == 6);
+}

tests/stage1/022_multiref.spl

@@ -0,0 +1,20 @@
+// Expect retcode = 0
+
+type A = struct {
+    tag: i32,
+    b: *B,
+};
+
+type B = struct {
+    tag: i32,
+    a: *A,
+};
+
+fn main() {
+    var a = A { .tag = 1, .b = null };
+    var b = B { .tag = 2, .a = &a };
+    a.b = &b;
+    @assert(a.b.tag == 2);
+    @assert(b.a.tag == 1);
+    @assert(a.b.a.tag == 1);
+}

tests/stage1/023_cross_agg.spl

@@ -0,0 +1,12 @@
+// Expect retcode = 0
+
+type Rectangle = @import("014_method.spl").Rectangle;
+
+fn make_rect(): Rectangle {
+    ret Rectangle { .x = 5, .y = 7 };
+}
+
+fn main() {
+    var r = make_rect();
+    @assert(r.area(&r) == 35);
+}

tests/stage1/024_bind.spl

@@ -0,0 +1,30 @@
+// Expect retcode = 0
+
+type Option = enum {
+    None,
+    Some: i32,
+}
+
+fn test_unit_variant() {
+    var x: Option = .{ .None };
+    var .None = x;
+}
+
+fn test_payload_variant() {
+    var x: Option = .{ .Some = 42 };
+    var .Some(n) = x;
+    @assert(n == 42, "some payload");
+}
+
+fn unwrap_some(o: Option): i32 {
+    var .Some(n) = o;
+    ret n;
+}
+
+fn main() {
+    test_unit_variant();
+    test_payload_variant();
+
+    var x: Option = .{ .Some = 7 };
+    @assert(unwrap_some(x) == 7, "cross-fn unwrap");
+}

tests/stage1/025_ifvar.spl

@@ -0,0 +1,67 @@
+// Expect retcode = 0
+
+type Option = enum {
+    None,
+    Some: i32,
+};
+
+fn make_pair(): (i32, i32) { ret (1, 2); }
+fn make_some(v: i32): Option { ret .Some(v); }
+
+fn test_ident() {
+    if var x = 42 {
+        @assert(x == 42, "ifvar ident x==42");
+    }
+}
+
+fn test_tuple() {
+    if var (a, b) = make_pair() {
+        @assert(a == 1, "ifvar tuple a==1");
+        @assert(b == 2, "ifvar tuple b==2");
+    }
+}
+
+fn test_enum_sugar() {
+    if var .Some(n) = make_some(7) {
+        @assert(n == 7, "ifvar enum sugar n==7");
+    }
+}
+
+fn test_enum_unified() {
+    if var .{ .Some = n } = make_some(9) {
+        @assert(n == 9, "ifvar enum unified n==9");
+    }
+}
+
+fn test_enum_unit() {
+    var o: Option = .None;
+    if var .None = o {
+        @assert(true, "ifvar enum unit reached");
+    }
+}
+
+fn test_else_path() {
+    var hit = 0;
+    if var x = 42 {
+        hit = 1;
+    } else {
+        hit = 2;
+    }
+    @assert(hit == 1, "ifvar else-path hit==1");
+}
+
+fn test_typed() {
+    if var x: i32 = 100 {
+        @assert(x == 100, "ifvar typed x==100");
+    }
+}
+
+fn main() {
+    test_ident();
+    test_tuple();
+    test_enum_sugar();
+    test_enum_unified();
+    test_enum_unit();
+    test_else_path();
+    test_typed();
+}

tests/stage1/026_match.spl

@@ -0,0 +1,64 @@
+// Expect retcode = 0
+
+type Option = enum {
+    None,
+    Some: i32,
+};
+
+fn test_literal() {
+    var x: i32 = 2;
+    var r: i32 = 0;
+    match x {
+        1 => { r = 10; },
+        2 => { r = 20; },
+        _ => { r = -1; },
+    }
+    @assert(r == 20, "match literal r==20");
+}
+
+fn test_wildcard_only() {
+    var x: i32 = 42;
+    var r: i32 = 0;
+    match x {
+        _ => { r = 1; },
+    }
+    @assert(r == 1, "match wildcard r==1");
+}
+
+fn test_enum_unit() {
+    var o: Option = .None;
+    var r: i32 = 0;
+    match o {
+        .None => { r = 1; },
+        .Some(n) => { r = n; },
+    }
+    @assert(r == 1, "match enum unit r==1");
+}
+
+fn test_enum_payload() {
+    var o: Option = .Some(42);
+    var r: i32 = 0;
+    match o {
+        .None => { r = 0; },
+        .Some(n) => { r = n; },
+    }
+    @assert(r == 42, "match enum payload r==42");
+}
+
+fn test_multi_pattern() {
+    var x: i32 = 3;
+    var r: i32 = 0;
+    match x {
+        1, 2, 3 => { r = 123; },
+        _ => { r = 0; },
+    }
+    @assert(r == 123, "match multi r==123");
+}
+
+fn main() {
+    test_literal();
+    test_wildcard_only();
+    test_enum_unit();
+    test_enum_payload();
+    test_multi_pattern();
+}

tests/stage1/027_unpack.spl

@@ -0,0 +1,70 @@
+// Expect retcode = 0
+
+type LibA = struct {
+    fn a1(): i32 { ret 1; }
+};
+
+type LibB = struct {
+    fn b1(): i32 { ret 10; }
+    fn b2(): i32 { ret 20; }
+};
+
+type LibC = struct {
+    fn c1(): i32 { ret 100; }
+    fn c2(): i32 { ret 200; }
+    fn c3(): i32 { ret 300; }
+};
+
+type LibMixed = struct {
+    type Byte = u8;
+    type Word = u16;
+    fn identity(v: i32): i32 { ret v; }
+};
+
+type MyInt = i32;
+
+type .a1 = LibA;
+
+type .{ .b1, .b2 } = LibB;
+
+type .c1, .c2, .c3 = LibC;
+
+type .{ .Byte, .Word, .identity } = LibMixed;
+
+fn test_alias_regression() {
+    var x: MyInt = 10;
+    @assert(x == 10, "type alias MyInt still works");
+}
+
+fn test_single_unpack() {
+    @assert(a1() == 1, "single unpack a1()=1");
+}
+
+fn test_aggregate_unpack() {
+    @assert(b1() == 10, "aggregate unpack b1()=10");
+    @assert(b2() == 20, "aggregate unpack b2()=20");
+}
+
+fn test_list_unpack() {
+    @assert(c1() == 100, "list unpack c1()=100");
+    @assert(c2() == 200, "list unpack c2()=200");
+    @assert(c3() == 300, "list unpack c3()=300");
+}
+
+fn test_type_and_fn_unpack() {
+    var b: Byte = 255;
+    @assert(b == 255, "Byte type unpack works");
+
+    var w: Word = 1000;
+    @assert(w == 1000, "Word type unpack works");
+
+    @assert(identity(42) == 42, "identity unpack works");
+}
+
+fn main() {
+    test_alias_regression();
+    test_single_unpack();
+    test_aggregate_unpack();
+    test_list_unpack();
+    test_type_and_fn_unpack();
+}