kit

cg_switch_test.c (20991B)

---

 /* cg_switch_test — drives kit_cg_switch with hand-built descriptors
  * covering the shapes the lowering must handle. Structural: asserts that
  * each shape lowers without panic and produces a defined function
  * symbol. Behavior under different lowering strategies (chain vs table)
  * is covered end-to-end by test/toy and test/parse — this file targets
  * the API surface itself.
  *
  * Shapes covered:
  *   - hint = TARGET_DEFAULT  / BRANCH_CHAIN  / JUMP_TABLE
  *   - dense range, sparse range, signed dense range straddling zero
  *   - default present / default absent
  *   - single case, empty cases (default-only)
  *   - both opt levels (0 and 1)
  *
  * Run by:  make test-cg-api
  */
 
 #include <kit/cg.h>
 #include <kit/core.h>
 #include <kit/disasm.h>
 #include <kit/interp.h>
 #include <kit/object.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "lib/kit_unit.h"
 
 /* Shared test context replaces the per-file heap/diag/counter globals;
  * EXPECT aliases CU_EXPECT so the call sites are unchanged. */
 static KitUnit g_u;
 #define EXPECT(cond, ...) CU_EXPECT(&g_u, cond, __VA_ARGS__)
 
 static KitObjBuilder* new_obj(KitCompiler* c) {
   KitObjBuilder* ob = NULL;
   if (kit_obj_builder_new(c, &ob) != KIT_OK) return NULL;
   return ob;
 }
 
 /* ---- Helpers --------------------------------------------------------- */
 
 typedef struct SwitchShape {
   const char* name;
   KitCgTypeId selector_type;
   /* values[] interpreted by selector_type; arm i is reached when the
    * selector equals values[i]. Each arm returns (uint32_t)results[i]. */
   const int64_t* values;
   const int32_t* results;
   uint32_t ncases;
   int has_default;
   int32_t default_result; /* used if has_default; otherwise arm falls past */
   KitCgSwitchHint hint;
 } SwitchShape;
 
 /* Build:
  *   int32_t f(<selector_type> x) {
  *     switch (x) {
  *       case values[0]: return results[0];
  *       ...
  *       default: return default_result;        // if has_default
  *     }
  *     return -1;                               // fall-through past switch
  *   }
  */
 static void build_switch_fn(KitCompiler* c, KitCgTypeId i32_ty,
                             const SwitchShape* sh, int opt_level) {
   char fn_name[96];
   KitCodeOptions opts;
   KitObjBuilder* ob;
   KitCg* cg;
   KitCgFuncParam param_desc;
   KitCgFuncSig sig;
   KitCgDecl decl;
   KitCgSym sym;
   KitCgLocalAttrs attrs;
   KitCgLocal param;
   KitCgLabel default_lbl;
   KitCgLabel end_lbl;
   KitCgLabel* case_lbls = NULL;
   KitCgSwitchCase* cases = NULL;
   KitCgSwitch sw;
   uint32_t i;
 
   memset(&opts, 0, sizeof opts);
   opts.opt_level = opt_level;
   ob = new_obj(c);
   EXPECT(ob != NULL, "[%s/O%d] obj builder allocation failed", sh->name,
          opt_level);
   if (!ob) return;
   cg = NULL;
   (void)kit_cg_new(c, &cg);
   if (cg) (void)kit_cg_begin(cg, ob, &opts);
   EXPECT(cg != NULL, "[%s/O%d] cg_new failed", sh->name, opt_level);
   if (!cg) {
     kit_obj_builder_free(ob);
     return;
   }
 
   memset(&param_desc, 0, sizeof param_desc);
   param_desc.type = sh->selector_type;
   memset(&sig, 0, sizeof sig);
   KitCgFuncResult sig_result;
   memset(&sig_result, 0, sizeof sig_result);
   sig_result.type = i32_ty;
   sig.result = sig_result;
   sig.params = &param_desc;
   sig.nparams = 1;
   sig.call_conv = KIT_CG_CC_TARGET_C;
 
   snprintf(fn_name, sizeof fn_name, "switch_%s_o%d", sh->name, opt_level);
   memset(&decl, 0, sizeof decl);
   decl.kind = KIT_CG_DECL_FUNC;
   decl.linkage_name = kit_sym_intern(c, kit_slice_cstr(fn_name));
   decl.display_name = decl.linkage_name;
   decl.type = kit_cg_type_func(c, sig);
   decl.sym.bind = KIT_SB_GLOBAL;
   decl.sym.visibility = KIT_CG_VIS_DEFAULT;
   sym = kit_cg_decl(cg, decl);
   EXPECT(sym != KIT_CG_SYM_NONE, "[%s/O%d] decl failed", sh->name, opt_level);
 
   kit_cg_func_begin(cg, sym);
 
   memset(&attrs, 0, sizeof attrs);
   attrs.name = kit_sym_intern(c, KIT_SLICE_LIT("x"));
   param = kit_cg_param(cg, 0, sh->selector_type, attrs);
   EXPECT(param != KIT_CG_LOCAL_NONE, "[%s/O%d] param failed", sh->name,
          opt_level);
 
   end_lbl = kit_cg_label_new(cg);
   default_lbl = sh->has_default ? kit_cg_label_new(cg) : end_lbl;
   if (sh->ncases) {
     case_lbls = (KitCgLabel*)malloc(sh->ncases * sizeof *case_lbls);
     cases = (KitCgSwitchCase*)malloc(sh->ncases * sizeof *cases);
     EXPECT(case_lbls && cases, "[%s/O%d] alloc failed", sh->name, opt_level);
     for (i = 0; i < sh->ncases; ++i) {
       case_lbls[i] = kit_cg_label_new(cg);
       cases[i].value = (uint64_t)sh->values[i];
       cases[i].label = case_lbls[i];
     }
   }
 
   /* Push selector, dispatch. */
   kit_cg_push_local(cg, param);
   kit_cg_load(
       cg, (KitCgMemAccess){.type = sh->selector_type,
                            .align = kit_cg_type_align(c, sh->selector_type)});
   memset(&sw, 0, sizeof sw);
   sw.selector_type = sh->selector_type;
   sw.default_label = default_lbl;
   sw.cases = cases;
   sw.ncases = sh->ncases;
   sw.hint = sh->hint;
   kit_cg_switch(cg, sw);
 
   /* Each arm: push result, jump to end_lbl. The cg API always materializes
    * the return through `kit_cg_ret` consuming the stack top; jump to a
    * single ret epilogue at end_lbl. */
   for (i = 0; i < sh->ncases; ++i) {
     kit_cg_label_place(cg, case_lbls[i]);
     kit_cg_push_int(cg, (uint64_t)(int64_t)sh->results[i], i32_ty);
     kit_cg_ret(cg);
   }
   if (sh->has_default) {
     kit_cg_label_place(cg, default_lbl);
     kit_cg_push_int(cg, (uint64_t)(int64_t)sh->default_result, i32_ty);
     kit_cg_ret(cg);
   }
   kit_cg_label_place(cg, end_lbl);
   kit_cg_push_int(cg, (uint64_t)(int64_t)-1, i32_ty);
   kit_cg_ret(cg);
   kit_cg_func_end(cg);
 
   EXPECT(g_u.fails == 0 || g_u.fails > 0, "shape-build sentinel"); /* no-op */
 
   free(case_lbls);
   free(cases);
   kit_cg_free(cg);
   kit_obj_builder_free(ob);
 }
 
 /* ---- Shapes ---------------------------------------------------------- */
 
 static void run_all_shapes(KitCompiler* c, KitCgTypeId i32_ty,
                            KitCgTypeId i64_ty, int opt_level) {
   /* Dense unsigned range 10..15 + default. */
   static const int64_t dense_vals[] = {10, 11, 12, 13, 14, 15};
   static const int32_t dense_res[] = {100, 101, 102, 103, 104, 105};
 
   /* Sparse: {1, 50, 1000}. */
   static const int64_t sparse_vals[] = {1, 50, 1000};
   static const int32_t sparse_res[] = {11, 22, 33};
 
   /* Signed dense around zero: -3..3. */
   static const int64_t signed_vals[] = {-3, -2, -1, 0, 1, 2, 3};
   static const int32_t signed_res[] = {30, 31, 32, 33, 34, 35, 36};
 
   /* Singleton. */
   static const int64_t single_vals[] = {42};
   static const int32_t single_res[] = {7};
 
   SwitchShape shapes[] = {
       /* TARGET_DEFAULT × shape × default-present/absent. */
       {"dense_def_target", i32_ty, dense_vals, dense_res, 6, 1, 999,
        KIT_CG_SWITCH_TARGET_DEFAULT},
       {"dense_nodef_target", i32_ty, dense_vals, dense_res, 6, 0, 0,
        KIT_CG_SWITCH_TARGET_DEFAULT},
       {"sparse_def_target", i32_ty, sparse_vals, sparse_res, 3, 1, 99,
        KIT_CG_SWITCH_TARGET_DEFAULT},
       {"signed_def_target", i32_ty, signed_vals, signed_res, 7, 1, 999,
        KIT_CG_SWITCH_TARGET_DEFAULT},
       {"signed64_def_target", i64_ty, signed_vals, signed_res, 7, 1, 999,
        KIT_CG_SWITCH_TARGET_DEFAULT},
 
       /* Forced hint variants. JUMP_TABLE is advisory; lowering may
        * accept it or fall back to chain — both must produce a valid
        * function. */
       {"dense_def_jump_table", i32_ty, dense_vals, dense_res, 6, 1, 999,
        KIT_CG_SWITCH_JUMP_TABLE},
       {"dense_nodef_jump_table", i32_ty, dense_vals, dense_res, 6, 0, 0,
        KIT_CG_SWITCH_JUMP_TABLE},
       {"sparse_def_jump_table", i32_ty, sparse_vals, sparse_res, 3, 1, 99,
        KIT_CG_SWITCH_JUMP_TABLE},
       {"signed_def_jump_table", i32_ty, signed_vals, signed_res, 7, 1, 999,
        KIT_CG_SWITCH_JUMP_TABLE},
 
       {"dense_def_branch_chain", i32_ty, dense_vals, dense_res, 6, 1, 999,
        KIT_CG_SWITCH_BRANCH_CHAIN},
       {"sparse_def_branch_chain", i32_ty, sparse_vals, sparse_res, 3, 1, 99,
        KIT_CG_SWITCH_BRANCH_CHAIN},
 
       /* Singleton: minimum case count. Both hints. */
       {"single_def_target", i32_ty, single_vals, single_res, 1, 1, 99,
        KIT_CG_SWITCH_TARGET_DEFAULT},
       {"single_def_jump_table", i32_ty, single_vals, single_res, 1, 1, 99,
        KIT_CG_SWITCH_JUMP_TABLE},
 
       /* Empty (default-only). kit_cg_switch on an empty case array is
        * tested for clean acceptance — frontends emit this from
        * `switch (x) { default: ...; }`. */
       {"empty_def_target", i32_ty, NULL, NULL, 0, 1, 7,
        KIT_CG_SWITCH_TARGET_DEFAULT},
   };
 
   size_t n = sizeof shapes / sizeof shapes[0];
   size_t i;
   for (i = 0; i < n; ++i) {
     build_switch_fn(c, i32_ty, &shapes[i], opt_level);
   }
 }
 
 /* ---- Jump-table decision -------------------------------------------- *
  *
  * The shape checks above only assert that lowering succeeds. These build a
  * function, emit an ELF object for the test compiler's (aa64) target,
  * disassemble .text, and report whether the dispatch became a real jump
  * table — detectable as the AArch64 indirect register branch `br`, which
  * the cmp/branch chain never emits. This is what lets us assert the
  * *policy* decision (table vs chain), not just structural success. */
 
 /* Build `int32_t <name>(<sel> x){ switch(x){...} }` from `sh` into an
  * already-begun cg, shared by the disasm and interpreter checks. Returns 0
  * on success, -1 on a harness failure. */
 static int emit_switch_fn(KitCompiler* c, KitCg* cg, const char* name,
                           KitCgTypeId i32_ty, const SwitchShape* sh) {
   KitCgFuncParam param_desc;
   KitCgFuncResult sig_result;
   KitCgFuncSig sig;
   KitCgDecl decl;
   KitCgSym sym;
   KitCgLocalAttrs attrs;
   KitCgLocal param;
   KitCgLabel default_lbl;
   KitCgLabel end_lbl;
   KitCgLabel* case_lbls = NULL;
   KitCgSwitchCase* cases = NULL;
   KitCgSwitch sw;
   int rc = -1;
   uint32_t i;
 
   memset(&param_desc, 0, sizeof param_desc);
   param_desc.type = sh->selector_type;
   memset(&sig_result, 0, sizeof sig_result);
   sig_result.type = i32_ty;
   memset(&sig, 0, sizeof sig);
   sig.result = sig_result;
   sig.params = &param_desc;
   sig.nparams = 1;
   sig.call_conv = KIT_CG_CC_TARGET_C;
 
   memset(&decl, 0, sizeof decl);
   decl.kind = KIT_CG_DECL_FUNC;
   decl.linkage_name = kit_sym_intern(c, kit_slice_cstr(name));
   decl.display_name = decl.linkage_name;
   decl.type = kit_cg_type_func(c, sig);
   decl.sym.bind = KIT_SB_GLOBAL;
   decl.sym.visibility = KIT_CG_VIS_DEFAULT;
   sym = kit_cg_decl(cg, decl);
   if (sym == KIT_CG_SYM_NONE) return -1;
 
   kit_cg_func_begin(cg, sym);
   memset(&attrs, 0, sizeof attrs);
   attrs.name = kit_sym_intern(c, KIT_SLICE_LIT("x"));
   param = kit_cg_param(cg, 0, sh->selector_type, attrs);
   if (param == KIT_CG_LOCAL_NONE) return -1;
 
   end_lbl = kit_cg_label_new(cg);
   default_lbl = sh->has_default ? kit_cg_label_new(cg) : end_lbl;
   if (sh->ncases) {
     case_lbls = (KitCgLabel*)malloc(sh->ncases * sizeof *case_lbls);
     cases = (KitCgSwitchCase*)malloc(sh->ncases * sizeof *cases);
     if (!case_lbls || !cases) goto done;
     for (i = 0; i < sh->ncases; ++i) {
       case_lbls[i] = kit_cg_label_new(cg);
       cases[i].value = (uint64_t)sh->values[i];
       cases[i].label = case_lbls[i];
     }
   }
 
   kit_cg_push_local(cg, param);
   kit_cg_load(
       cg, (KitCgMemAccess){.type = sh->selector_type,
                            .align = kit_cg_type_align(c, sh->selector_type)});
   memset(&sw, 0, sizeof sw);
   sw.selector_type = sh->selector_type;
   sw.default_label = default_lbl;
   sw.cases = cases;
   sw.ncases = sh->ncases;
   sw.hint = sh->hint;
   kit_cg_switch(cg, sw);
 
   for (i = 0; i < sh->ncases; ++i) {
     kit_cg_label_place(cg, case_lbls[i]);
     kit_cg_push_int(cg, (uint64_t)(int64_t)sh->results[i], i32_ty);
     kit_cg_ret(cg);
   }
   if (sh->has_default) {
     kit_cg_label_place(cg, default_lbl);
     kit_cg_push_int(cg, (uint64_t)(int64_t)sh->default_result, i32_ty);
     kit_cg_ret(cg);
   }
   kit_cg_label_place(cg, end_lbl);
   kit_cg_push_int(cg, (uint64_t)(int64_t)-1, i32_ty);
   kit_cg_ret(cg);
   kit_cg_func_end(cg);
   rc = 0;
 
 done:
   free(case_lbls);
   free(cases);
   return rc;
 }
 
 /* 1 iff .text contains an aa64 indirect register branch (BR). -1 on harness
  * failure. */
 static int switch_lowers_to_table(KitCompiler* c, KitCgTypeId i32_ty,
                                   const SwitchShape* sh, int opt_level) {
   KitCodeOptions opts;
   KitObjBuilder* ob;
   KitCg* cg = NULL;
   KitWriter* writer = NULL;
   KitObjFile* file = NULL;
   KitSlice bytes;
   KitObjSection text_sec;
   const uint8_t* data = NULL;
   size_t len = 0;
   KitDisasmContext dc;
   KitDisasmIter* it = NULL;
   KitInsn insn;
   int found = -1;
 
   memset(&opts, 0, sizeof opts);
   opts.opt_level = opt_level;
   ob = new_obj(c);
   if (!ob) return -1;
   if (kit_cg_new(c, &cg) != KIT_OK || !cg) {
     kit_obj_builder_free(ob);
     return -1;
   }
   if (kit_cg_begin(cg, ob, &opts) != KIT_OK) goto done;
   if (emit_switch_fn(c, cg, "f", i32_ty, sh) != 0) goto done;
 
   if (kit_cg_finish(cg, NULL) != KIT_OK) goto done;
   if (kit_cg_detach(cg) != KIT_OK) goto done;
 
   if (kit_writer_mem(&g_u.heap, &writer) != KIT_OK || !writer) goto done;
   if (kit_obj_builder_emit(ob, writer) != KIT_OK) goto done;
   bytes.data = kit_writer_mem_bytes(writer, &len);
   bytes.len = len;
   if (kit_obj_open(&g_u.ctx, KIT_SLICE_LIT("<sw-test>"), &bytes, &file) !=
       KIT_OK)
     goto done;
   if (kit_obj_section_by_name(file, KIT_SLICE_LIT(".text"), &text_sec) !=
       KIT_OK)
     goto done;
   if (kit_obj_section_data(file, text_sec, &data, &len) != KIT_OK) goto done;
 
   memset(&dc, 0, sizeof dc);
   dc.target = kit_compiler_target(c);
   dc.context = g_u.ctx;
   if (kit_disasm_iter_new(&dc, data, len, 0, file, &it) != KIT_OK || !it)
     goto done;
   found = 0;
   while (kit_disasm_iter_next(it, &insn) == KIT_ITER_ITEM) {
     if (insn.mnemonic.len == 2 && insn.mnemonic.s &&
         insn.mnemonic.s[0] == 'b' && insn.mnemonic.s[1] == 'r') {
       found = 1;
       break;
     }
   }
 
 done:
   if (it) kit_disasm_iter_free(it);
   if (file) kit_obj_free(file);
   if (writer) kit_writer_close(writer);
   if (cg) kit_cg_free(cg);
   kit_obj_builder_free(ob);
   return found;
 }
 
 static void run_table_decision_checks(KitCompiler* c, KitCgTypeId i32_ty,
                                       KitCgTypeId i64_ty) {
   /* Six contiguous 64-bit values straddling the signed midpoint 2^63.
    * As *unsigned* they span just [2^63-3, 2^63+2] (span 6, table-friendly),
    * but a signed-only reading sees them at both ends of the i64 range and
    * the table is rejected. The selector signedness isn't even visible to
    * the lowering (CG has only I64), so the planner must take the tighter of
    * the signed- and unsigned-seam windows. */
   static const uint64_t MID = (uint64_t)1 << 63;
   static int64_t mid_vals[6];
   static const int32_t mid_res[] = {200, 201, 202, 203, 204, 205};
   /* Dense small positive values: a table under either reading — the
    * positive control that the detector reports tables when one is emitted. */
   static const int64_t lo_vals[] = {10, 11, 12, 13, 14, 15};
   static const int32_t lo_res[] = {100, 101, 102, 103, 104, 105};
   /* Genuinely sparse: span far exceeds MAX_SPAN under either window, so no
    * table even with the JUMP_TABLE hint — the negative control. */
   static const int64_t sparse_vals[] = {0, 1ll << 20, 1ll << 40, 1ll << 60};
   static const int32_t sparse_res[] = {1, 2, 3, 4};
   SwitchShape mid;
   SwitchShape lo;
   SwitchShape sparse;
   int r;
   uint32_t i;
 
   for (i = 0; i < 6; ++i) mid_vals[i] = (int64_t)(MID - 3 + i);
 
   memset(&mid, 0, sizeof mid);
   mid.name = "u64_midpoint";
   mid.selector_type = i64_ty;
   mid.values = mid_vals;
   mid.results = mid_res;
   mid.ncases = 6;
   mid.has_default = 1;
   mid.default_result = 999;
   mid.hint = KIT_CG_SWITCH_JUMP_TABLE;
 
   lo = mid;
   lo.name = "dense_low";
   lo.values = lo_vals;
   lo.results = lo_res;
 
   sparse = mid;
   sparse.name = "sparse";
   sparse.values = sparse_vals;
   sparse.results = sparse_res;
   sparse.ncases = 4;
 
   /* Positive control: a dense low switch must produce a table. */
   r = switch_lowers_to_table(c, i32_ty, &lo, /*opt_level=*/0);
   EXPECT(r == 1, "dense low switch should lower to a jump table (got %d)", r);
 
   /* The fix: midpoint-straddling 64-bit cases are dense under the unsigned
    * window and must lower to a table rather than a cmp/branch chain. */
   r = switch_lowers_to_table(c, i32_ty, &mid, /*opt_level=*/0);
   EXPECT(r == 1,
          "u64 midpoint-straddling switch should lower to a jump table (got %d)",
          r);
 
   /* Negative control: a truly sparse switch stays a chain even when the
    * frontend forces the jump-table hint. */
   r = switch_lowers_to_table(c, i32_ty, &sparse, /*opt_level=*/0);
   EXPECT(r == 0, "sparse switch must not lower to a jump table (got %d)", r);
 }
 
 /* Execute the midpoint switch through the target-independent interpreter.
  * At O1 the JUMP_TABLE plan reaches cg_emit_switch_table, which records the
  * `idx = sel - vmin` / unsigned-bounds / table-load / indirect-branch IR; the
  * interp materializes the table as interp pcs and runs those very ops, so this
  * exercises the new unsigned-window index math end to end (not just that a
  * table was chosen). Every in-set selector must reach its arm and every
  * out-of-set selector must reach default. */
 static void run_table_exec_check(KitCompiler* c, KitCgTypeId i32_ty,
                                  KitCgTypeId i64_ty) {
   static const uint64_t MID = (uint64_t)1 << 63;
   static int64_t mid_vals[6];
   static const int32_t mid_res[] = {200, 201, 202, 203, 204, 205};
   SwitchShape mid;
   KitInterpProgram* pp;
   KitObjBuilder* ob = NULL;
   KitCg* cg = NULL;
   KitCodeOptions opts;
   KitInterpFunc* fn;
   uint32_t i;
 
   for (i = 0; i < 6; ++i) mid_vals[i] = (int64_t)(MID - 3 + i);
   memset(&mid, 0, sizeof mid);
   mid.name = "u64_midpoint_exec";
   mid.selector_type = i64_ty;
   mid.values = mid_vals;
   mid.results = mid_res;
   mid.ncases = 6;
   mid.has_default = 1;
   mid.default_result = 999;
   mid.hint = KIT_CG_SWITCH_JUMP_TABLE;
 
   pp = kit_interp_program_new(c);
   EXPECT(pp != NULL, "exec: interp_program_new failed");
   if (!pp) return;
   kit_interp_program_attach(pp, c);
 
   ob = new_obj(c);
   EXPECT(ob != NULL, "exec: obj_new");
   EXPECT(kit_cg_new(c, &cg) == KIT_OK && cg, "exec: cg_new");
   if (ob && cg) {
     memset(&opts, 0, sizeof opts);
     opts.opt_level = 1; /* interp capture requires the optimizer pass */
     kit_cg_begin(cg, ob, &opts);
     EXPECT(emit_switch_fn(c, cg, "mid", i32_ty, &mid) == 0, "exec: build");
     EXPECT(kit_cg_finish(cg, NULL) == KIT_OK, "exec: finish");
     EXPECT(kit_cg_detach(cg) == KIT_OK, "exec: detach");
 
     fn = kit_interp_lookup(pp, kit_slice_cstr("mid"));
     EXPECT(fn != NULL, "exec: mid not captured");
     if (fn) {
       for (i = 0; i < 6; ++i) {
         uint64_t args[1] = {(uint64_t)mid_vals[i]};
         int64_t ret = 0;
         KitInterpStatus s = kit_interp_call_args(pp, fn, args, 1, &ret);
         EXPECT(s == KIT_INTERP_DONE && ret == mid_res[i],
                "mid(%#llx): want %d got %lld (status %d)",
                (unsigned long long)args[0], mid_res[i], (long long)ret, (int)s);
       }
       /* Out-of-set selectors stress both bounds edges (just below vmin, just
        * above vmax) and a far-away value — all must reach default. */
       {
         uint64_t outs[] = {MID - 4, MID + 3, 0, MID + 1000};
         uint32_t no = (uint32_t)(sizeof outs / sizeof outs[0]);
         for (i = 0; i < no; ++i) {
           uint64_t args[1] = {outs[i]};
           int64_t ret = 0;
           KitInterpStatus s = kit_interp_call_args(pp, fn, args, 1, &ret);
           EXPECT(s == KIT_INTERP_DONE && ret == 999,
                  "mid(%#llx): want default 999 got %lld (status %d)",
                  (unsigned long long)outs[i], (long long)ret, (int)s);
         }
       }
     }
   }
 
   if (cg) kit_cg_free(cg);
   if (ob) kit_obj_builder_free(ob);
   kit_interp_program_free(pp);
 }
 
 /* ---- Entry ----------------------------------------------------------- */
 
 int main(void) {
   KitTargetSpec target;
   KitCompiler* c = NULL;
   KitCgTypeId i32_ty;
   KitCgTypeId i64_ty;
 
   kit_unit_init(&g_u);
   target = kit_unit_target(KIT_ARCH_ARM_64, KIT_OS_LINUX, KIT_OBJ_ELF);
 
   if (kit_unit_compiler_new(&g_u, target, &c) != KIT_OK || !c) {
     fprintf(stderr, "compiler_new failed\n");
     return 2;
   }
 
   i32_ty = kit_cg_type_builtin(c, KIT_CG_BUILTIN_I32);
   i64_ty = kit_cg_type_builtin(c, KIT_CG_BUILTIN_I64);
   EXPECT(i32_ty != KIT_CG_TYPE_NONE, "i32 builtin id is none");
   EXPECT(i64_ty != KIT_CG_TYPE_NONE, "i64 builtin id is none");
 
   run_all_shapes(c, i32_ty, i64_ty, /*opt_level=*/0);
   run_all_shapes(c, i32_ty, i64_ty, /*opt_level=*/1);
   run_table_decision_checks(c, i32_ty, i64_ty);
   run_table_exec_check(c, i32_ty, i64_ty);
 
   kit_compiler_free(c);
   kit_unit_summary(&g_u, "cg_switch_test");
   return kit_unit_status(&g_u);
 }