kit

cg_type_test.c (70466B)

---

 #include <kit/cg.h>
 #include <kit/compile.h>
 #include <kit/core.h>
 #include <kit/dwarf.h>
 #include <kit/frontend.h>
 #include <kit/object.h>
 #include <kit/source.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "lib/kit_unit.h"
 
 /* One shared test context replaces the per-file heap/diag/counter globals.
  * EXPECT is aliased to CU_EXPECT so the call sites below are unchanged; the
  * expected-panic helper uses g_u.suppress_fatal + g_u.last_diag. */
 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;
 }
 
 static int open_emitted_obj(KitCompiler* c, KitObjBuilder* ob,
                             KitWriter** writer_out, KitObjFile** file_out) {
   KitWriter* w = NULL;
   KitObjFile* f = NULL;
   KitSlice bytes;
   size_t len = 0;
   const KitContext* ctx;
 
   if (!writer_out || !file_out) return 0;
   *writer_out = NULL;
   *file_out = NULL;
   if (kit_writer_mem(&g_u.heap, &w) != KIT_OK || !w) return 0;
   if (kit_obj_builder_emit(ob, w) != KIT_OK) {
     kit_writer_close(w);
     return 0;
   }
   bytes.data = kit_writer_mem_bytes(w, &len);
   bytes.len = len;
   ctx = kit_compiler_context(c);
   if (kit_obj_open(ctx, KIT_SLICE_LIT("<cg-api-test>"), &bytes, &f) != KIT_OK) {
     kit_writer_close(w);
     return 0;
   }
   *writer_out = w;
   *file_out = f;
   return 1;
 }
 
 static void finish_cg(KitCg* cg, const char* tag) {
   EXPECT(kit_cg_finish(cg, NULL) == KIT_OK, "%s cg finish failed", tag);
   EXPECT(kit_cg_detach(cg) == KIT_OK, "%s cg detach failed", tag);
 }
 
 typedef struct PanicRunCtx {
   void (*fn)(void*);
   void* arg;
 } PanicRunCtx;
 
 static KitStatus run_expected_panic(KitCompiler* c, void* arg) {
   PanicRunCtx* ctx = (PanicRunCtx*)arg;
   (void)c;
   ctx->fn(ctx->arg);
   return KIT_OK;
 }
 
 static int expect_panic_contains(KitCompiler* c, void (*fn)(void*), void* arg,
                                  const char* expected) {
   PanicRunCtx ctx;
   KitStatus st;
   ctx.fn = fn;
   ctx.arg = arg;
   g_u.last_diag[0] = '\0';
   g_u.suppress_fatal++;
   st = kit_frontend_run(c, run_expected_panic, &ctx);
   g_u.suppress_fatal--;
   return st == KIT_ERR && strstr(g_u.last_diag, expected) != NULL;
 }
 
 static void exercise_cg_handles(KitCompiler* c, KitCgTypeId i32_ty,
                                 int opt_level) {
   char name_buf[32];
   KitCodeOptions opts;
   KitObjBuilder* ob;
   KitCg* cg;
   KitCgFuncParam param_desc;
   KitCgFuncSig sig;
   KitCgDecl decl;
   KitCgSym sym;
   KitCgLocalAttrs attrs;
   KitCgLocal local;
   KitCgLocal param;
   KitCgMemAccess mem;
 
   memset(&opts, 0, sizeof(opts));
   opts.opt_level = opt_level;
   ob = new_obj(c);
   EXPECT(ob != NULL, "obj builder allocation failed");
   if (!ob) return;
   cg = NULL;
   (void)kit_cg_new(c, &cg);
   if (cg) (void)kit_cg_begin(cg, ob, &opts);
   EXPECT(cg != NULL, "cg allocation failed");
   if (!cg) {
     kit_obj_builder_free(ob);
     return;
   }
 
   memset(&param_desc, 0, sizeof(param_desc));
   param_desc.type = i32_ty;
   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(name_buf, sizeof(name_buf), "cg_handles_o%d", opt_level);
   memset(&decl, 0, sizeof(decl));
   decl.kind = KIT_CG_DECL_FUNC;
   decl.linkage_name = kit_sym_intern(c, kit_slice_cstr(name_buf));
   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, "function decl failed");
 
   kit_cg_func_begin(cg, sym);
   memset(&attrs, 0, sizeof(attrs));
   attrs.name = kit_sym_intern(c, KIT_SLICE_LIT("p"));
   param = kit_cg_param(cg, 0, i32_ty, attrs);
   attrs.name = kit_sym_intern(c, KIT_SLICE_LIT("x"));
   local = kit_cg_local(cg, i32_ty, attrs);
   EXPECT(local != KIT_CG_LOCAL_NONE, "local handle is none");
   EXPECT(param != KIT_CG_LOCAL_NONE, "param handle is none");
   EXPECT((uint32_t)param == 1u, "first local id should be param");
   EXPECT((uint32_t)local == 2u, "local id should follow param");
   EXPECT((uint32_t)local != (uint32_t)param, "local and param handles collide");
 
   memset(&mem, 0, sizeof(mem));
   mem.type = i32_ty;
   mem.align = kit_cg_type_align(c, i32_ty);
 
   kit_cg_push_local(cg, local);
   kit_cg_push_local_addr(cg, param);
   kit_cg_deref(cg, 0); /* pointer VALUE -> PLACE for the load */
   kit_cg_load(cg, mem);
   kit_cg_store(cg, mem);
 
   kit_cg_push_local_addr(cg, local);
   kit_cg_deref(cg, 0); /* pointer VALUE -> PLACE for the load */
   kit_cg_load(cg, mem);
   kit_cg_ret(cg);
   kit_cg_func_end(cg);
 
   kit_cg_free(cg);
   kit_obj_builder_free(ob);
 }
 
 static void exercise_cg_scalar_local(KitCompiler* c, KitCgTypeId i32_ty,
                                      int opt_level) {
   char name_buf[40];
   KitCodeOptions opts;
   KitObjBuilder* ob;
   KitCg* cg;
   KitCgFuncSig sig;
   KitCgDecl decl;
   KitCgSym sym;
   KitCgLocalAttrs attrs;
   KitCgLocal local;
   KitCgMemAccess mem;
 
   memset(&opts, 0, sizeof opts);
   opts.opt_level = opt_level;
   ob = new_obj(c);
   EXPECT(ob != NULL, "obj builder allocation failed");
   if (!ob) return;
   cg = NULL;
   (void)kit_cg_new(c, &cg);
   if (cg) (void)kit_cg_begin(cg, ob, &opts);
   EXPECT(cg != NULL, "cg allocation failed");
   if (!cg) {
     kit_obj_builder_free(ob);
     return;
   }
 
   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.call_conv = KIT_CG_CC_TARGET_C;
 
   snprintf(name_buf, sizeof name_buf, "cg_scalar_local_o%d", opt_level);
   memset(&decl, 0, sizeof decl);
   decl.kind = KIT_CG_DECL_FUNC;
   decl.linkage_name = kit_sym_intern(c, kit_slice_cstr(name_buf));
   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, "scalar local decl failed");
 
   kit_cg_func_begin(cg, sym);
   memset(&attrs, 0, sizeof attrs);
   attrs.name = kit_sym_intern(c, KIT_SLICE_LIT("x"));
   local = kit_cg_local(cg, i32_ty, attrs);
   EXPECT(local != KIT_CG_LOCAL_NONE, "scalar local handle is none");
 
   memset(&mem, 0, sizeof mem);
   mem.type = i32_ty;
   mem.align = kit_cg_type_align(c, i32_ty);
 
   kit_cg_push_local(cg, local);
   kit_cg_push_int(cg, 40, i32_ty);
   kit_cg_store(cg, mem);
   kit_cg_push_local(cg, local);
   kit_cg_load(cg, mem);
   kit_cg_push_int(cg, 2, i32_ty);
   kit_cg_int_binop(cg, KIT_CG_INT_ADD, 0);
   kit_cg_ret(cg);
   kit_cg_func_end(cg);
 
   kit_cg_free(cg);
   kit_obj_builder_free(ob);
 }
 
 static void exercise_cg_late_local_addr(KitCompiler* c, KitCgTypeId i32_ty,
                                         int opt_level) {
   char name_buf[40];
   KitCodeOptions opts;
   KitObjBuilder* ob;
   KitCg* cg;
   KitCgFuncSig sig;
   KitCgDecl decl;
   KitCgSym sym;
   KitCgLocalAttrs attrs;
   KitCgLocal local;
   KitCgMemAccess mem;
 
   memset(&opts, 0, sizeof opts);
   opts.opt_level = opt_level;
   ob = new_obj(c);
   EXPECT(ob != NULL, "obj builder allocation failed");
   if (!ob) return;
   cg = NULL;
   (void)kit_cg_new(c, &cg);
   if (cg) (void)kit_cg_begin(cg, ob, &opts);
   EXPECT(cg != NULL, "cg allocation failed");
   if (!cg) {
     kit_obj_builder_free(ob);
     return;
   }
 
   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.call_conv = KIT_CG_CC_TARGET_C;
 
   snprintf(name_buf, sizeof name_buf, "cg_late_local_addr_o%d", opt_level);
   memset(&decl, 0, sizeof decl);
   decl.kind = KIT_CG_DECL_FUNC;
   decl.linkage_name = kit_sym_intern(c, kit_slice_cstr(name_buf));
   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, "late local addr decl failed");
 
   kit_cg_func_begin(cg, sym);
   memset(&attrs, 0, sizeof attrs);
   attrs.name = kit_sym_intern(c, KIT_SLICE_LIT("x"));
   local = kit_cg_local(cg, i32_ty, attrs);
   EXPECT(local != KIT_CG_LOCAL_NONE, "late addr local handle is none");
 
   memset(&mem, 0, sizeof mem);
   mem.type = i32_ty;
   mem.align = kit_cg_type_align(c, i32_ty);
 
   kit_cg_push_local(cg, local);
   kit_cg_push_int(cg, 41, i32_ty);
   kit_cg_store(cg, mem);
   kit_cg_push_local_addr(cg, local);
   kit_cg_deref(cg, 0); /* pointer VALUE -> PLACE for the load */
   kit_cg_load(cg, mem);
   kit_cg_push_int(cg, 1, i32_ty);
   kit_cg_int_binop(cg, KIT_CG_INT_ADD, 0);
   kit_cg_ret(cg);
   kit_cg_func_end(cg);
 
   kit_cg_free(cg);
   kit_obj_builder_free(ob);
 }
 
 static uint32_t text_size(KitCompiler* c, KitObjBuilder* ob) {
   uint32_t total = 0;
   KitWriter* w = NULL;
   KitObjFile* f = NULL;
   uint32_t n;
   if (!open_emitted_obj(c, ob, &w, &f)) {
     EXPECT(0, "failed to inspect emitted object");
     return 0;
   }
   n = kit_obj_nsections(f);
   for (uint32_t i = 0; i < n; ++i) {
     KitObjSecInfo sec;
     if (kit_obj_section(f, i, &sec) != KIT_OK) continue;
     if (sec.kind == KIT_SEC_TEXT) total += (uint32_t)sec.size;
   }
   kit_obj_free(f);
   kit_writer_close(w);
   return total;
 }
 
 static void exercise_cg_data_entsize(KitCompiler* c, KitCgTypeId i8_ty) {
   static const uint8_t bytes[] = {'t', 'o', 'y', '\0'};
   KitCodeOptions opts;
   KitObjBuilder* ob;
   KitCg* cg;
   KitCgDecl decl;
   KitCgSym sym;
   KitCgDataDefAttrs data_attrs;
   KitCgTypeId array_ty;
   int found = 0;
 
   memset(&opts, 0, sizeof opts);
   ob = new_obj(c);
   EXPECT(ob != NULL, "entsize obj builder allocation failed");
   if (!ob) return;
   cg = NULL;
   (void)kit_cg_new(c, &cg);
   if (cg) (void)kit_cg_begin(cg, ob, &opts);
   EXPECT(cg != NULL, "entsize cg allocation failed");
   if (!cg) {
     kit_obj_builder_free(ob);
     return;
   }
 
   array_ty = kit_cg_type_array(c, i8_ty, sizeof bytes);
   EXPECT(array_ty != KIT_CG_TYPE_NONE, "entsize array type failed");
 
   memset(&decl, 0, sizeof decl);
   decl.kind = KIT_CG_DECL_OBJECT;
   decl.linkage_name = kit_sym_intern(c, KIT_SLICE_LIT("cg_entsize_string"));
   decl.display_name = decl.linkage_name;
   decl.type = array_ty;
   decl.sym.bind = KIT_SB_GLOBAL;
   decl.sym.visibility = KIT_CG_VIS_DEFAULT;
   decl.as.object.flags = KIT_CG_OBJ_READONLY;
   decl.as.object.align = 1;
   sym = kit_cg_decl(cg, decl);
   EXPECT(sym != KIT_CG_SYM_NONE, "entsize object decl failed");
 
   memset(&data_attrs, 0, sizeof data_attrs);
   data_attrs.section = kit_sym_intern(c, KIT_SLICE_LIT(".rodata.kit.merge"));
   data_attrs.align = 1;
   data_attrs.entsize = 1;
   data_attrs.flags =
       KIT_CG_DATADEF_READONLY | KIT_CG_DATADEF_MERGE | KIT_CG_DATADEF_STRINGS;
   kit_cg_data_begin(cg, sym, data_attrs);
   kit_cg_data_bytes(cg, bytes, sizeof bytes);
   kit_cg_data_end(cg);
   finish_cg(cg, "entsize");
   kit_cg_free(cg);
 
   {
     KitWriter* w = NULL;
     KitObjFile* f = NULL;
     uint32_t n;
     if (!open_emitted_obj(c, ob, &w, &f)) {
       EXPECT(0, "failed to inspect entsize object");
       kit_obj_builder_free(ob);
       return;
     }
     n = kit_obj_nsections(f);
     for (uint32_t i = 0; i < n; ++i) {
       KitObjSecInfo sec;
       if (kit_obj_section(f, i, &sec) != KIT_OK) continue;
       if ((sec.flags & (KIT_SF_MERGE | KIT_SF_STRINGS)) ==
           (KIT_SF_MERGE | KIT_SF_STRINGS)) {
         found = 1;
         EXPECT(sec.entsize == 1,
                "merge string section entsize should be 1, got %u", sec.entsize);
       }
     }
     kit_obj_free(f);
     kit_writer_close(w);
   }
   EXPECT(found, "expected merge string data section");
 
   kit_obj_builder_free(ob);
 }
 
 static void exercise_cg_debug_global_object(KitCompiler* c,
                                             KitCgTypeId i32_ty) {
   KitCodeOptions opts;
   KitObjBuilder* ob;
   KitCg* cg;
   KitCgDecl decl;
   KitCgSym sym;
   KitCgDataDefAttrs data_attrs;
   KitSrcLoc loc;
   uint32_t file_id = 0;
 
   memset(&opts, 0, sizeof opts);
   opts.debug_info = true;
   ob = new_obj(c);
   EXPECT(ob != NULL, "debug global obj builder allocation failed");
   if (!ob) return;
   cg = NULL;
   EXPECT(kit_cg_new(c, &cg) == KIT_OK && cg != NULL,
          "debug global cg allocation failed");
   if (!cg) {
     kit_obj_builder_free(ob);
     return;
   }
   EXPECT(kit_cg_begin(cg, ob, &opts) == KIT_OK, "debug global cg begin failed");
 
   EXPECT(kit_source_add_memory(c, KIT_SLICE_LIT("cg_debug_global.c"),
                                &file_id) == KIT_OK,
          "debug global source file add failed");
   loc.file_id = file_id;
   loc.line = 7;
   loc.col = 3;
   kit_cg_set_loc(cg, loc);
 
   memset(&decl, 0, sizeof decl);
   decl.kind = KIT_CG_DECL_OBJECT;
   decl.linkage_name = kit_sym_intern(c, KIT_SLICE_LIT("cg_dbg_global_link"));
   decl.display_name = kit_sym_intern(c, KIT_SLICE_LIT("cg_dbg_global"));
   decl.type = i32_ty;
   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, "debug global object decl failed");
 
   memset(&data_attrs, 0, sizeof data_attrs);
   data_attrs.align = kit_cg_type_align(c, i32_ty);
   kit_cg_data_begin(cg, sym, data_attrs);
   kit_cg_data_int(cg, 42, i32_ty);
   kit_cg_data_end(cg);
   finish_cg(cg, "debug global");
   kit_cg_free(cg);
 
   {
     KitWriter* w = NULL;
     KitObjFile* f = NULL;
     KitDebugInfo* di = NULL;
     KitDwarfVarLoc vloc;
     KitDwarfVarIter* vit = NULL;
     KitDwarfVar var;
     int iter_found = 0;
 
     if (!open_emitted_obj(c, ob, &w, &f)) {
       EXPECT(0, "failed to inspect debug global object");
       kit_obj_builder_free(ob);
       return;
     }
     EXPECT(
         kit_dwarf_open(kit_compiler_context(c), f, &di) == KIT_OK && di != NULL,
         "debug global dwarf open failed");
     if (di) {
       EXPECT(kit_dwarf_var_at(di, 0, KIT_SLICE_LIT("cg_dbg_global"), &vloc) ==
                  KIT_OK,
              "debug global variable not found by display name");
       EXPECT(vloc.kind == KIT_DLOC_GLOBAL,
              "debug global location kind %d, expected global", (int)vloc.kind);
       EXPECT(vloc.byte_size == 4, "debug global byte size %u, expected 4",
              vloc.byte_size);
       EXPECT(vloc.type != NULL, "debug global type missing");
 
       EXPECT(kit_dwarf_vars_at_new(di, 0, KIT_DVRM_GLOBAL, &vit) == KIT_OK &&
                  vit != NULL,
              "debug global iterator allocation failed");
       if (vit) {
         while (kit_dwarf_vars_at_next(vit, &var) == KIT_ITER_ITEM) {
           if (kit_slice_eq_cstr(var.name, "cg_dbg_global") &&
               var.role == KIT_DVR_GLOBAL) {
             iter_found = 1;
             EXPECT(var.loc.kind == KIT_DLOC_GLOBAL,
                    "debug global iterator location kind %d", (int)var.loc.kind);
           }
         }
         kit_dwarf_vars_at_free(vit);
       }
       EXPECT(iter_found, "debug global iterator did not report global");
       kit_dwarf_free(di);
     }
     kit_obj_free(f);
     kit_writer_close(w);
   }
 
   kit_obj_builder_free(ob);
 }
 
 static KitCgSym begin_i32_func(KitCompiler* c, KitCg* cg, KitCgTypeId i32_ty,
                                const char* name) {
   KitCgFuncSig sig;
   KitCgDecl decl;
   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.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;
   return kit_cg_decl(cg, decl);
 }
 
 static void exercise_cg_literal_folds(KitCompiler* c, KitCgTypeId i32_ty) {
   static const char* names[] = {
       "cg_fold_add_o1",
       "cg_fold_shift_or_o1",
       "cg_fold_cmp_o1",
       "cg_fold_unop_o1",
   };
   KitCodeOptions opts;
   KitObjBuilder* ob;
   KitCg* cg;
 
   memset(&opts, 0, sizeof opts);
   opts.opt_level = 1;
   ob = new_obj(c);
   EXPECT(ob != NULL, "literal fold obj builder allocation failed");
   if (!ob) return;
   cg = NULL;
   (void)kit_cg_new(c, &cg);
   if (cg) (void)kit_cg_begin(cg, ob, &opts);
   EXPECT(cg != NULL, "literal fold cg allocation failed");
   if (!cg) {
     kit_obj_builder_free(ob);
     return;
   }
 
   for (uint32_t i = 0; i < 4; ++i) {
     KitCgSym sym = begin_i32_func(c, cg, i32_ty, names[i]);
     EXPECT(sym != KIT_CG_SYM_NONE, "literal fold decl failed");
     kit_cg_func_begin(cg, sym);
     switch (i) {
       case 0:
         kit_cg_push_int(cg, 40, i32_ty);
         kit_cg_push_int(cg, 2, i32_ty);
         kit_cg_int_binop(cg, KIT_CG_INT_ADD, 0);
         break;
       case 1:
         kit_cg_push_int(cg, 5, i32_ty);
         kit_cg_push_int(cg, 3, i32_ty);
         kit_cg_int_binop(cg, KIT_CG_INT_SHL, 0);
         kit_cg_push_int(cg, 2, i32_ty);
         kit_cg_int_binop(cg, KIT_CG_INT_OR, 0);
         break;
       case 2:
         kit_cg_push_int(cg, 40, i32_ty);
         kit_cg_push_int(cg, 2, i32_ty);
         kit_cg_int_binop(cg, KIT_CG_INT_ADD, 0);
         kit_cg_push_int(cg, 42, i32_ty);
         kit_cg_int_cmp(cg, KIT_CG_INT_EQ);
         break;
       case 3:
         kit_cg_push_int(cg, 41, i32_ty);
         kit_cg_int_unop(cg, KIT_CG_INT_BNOT, 0);
         kit_cg_int_unop(cg, KIT_CG_INT_BNOT, 0);
         kit_cg_push_int(cg, 1, i32_ty);
         kit_cg_int_binop(cg, KIT_CG_INT_ADD, 0);
         break;
     }
     kit_cg_ret(cg);
     kit_cg_func_end(cg);
   }
 
   finish_cg(cg, "literal fold");
   kit_cg_free(cg);
   EXPECT(text_size(c, ob) <= 128,
          "literal folds should avoid arithmetic materialization, text size=%u",
          text_size(c, ob));
   kit_obj_builder_free(ob);
 }
 
 static uint32_t cg_emit_delayed_chain(KitCompiler* c, KitCgTypeId i32_ty,
                                       const char* name) {
   KitCodeOptions opts;
   KitObjBuilder* ob;
   KitCg* cg;
   KitCgFuncParam param_desc;
   KitCgFuncSig sig;
   KitCgDecl decl;
   KitCgSym sym;
   KitCgLocalAttrs attrs;
   KitCgLocal param;
   KitCgMemAccess mem;
   uint32_t size;
 
   memset(&opts, 0, sizeof opts);
   opts.opt_level = 1;
   ob = new_obj(c);
   EXPECT(ob != NULL, "delayed chain obj builder allocation failed");
   if (!ob) return 0;
   cg = NULL;
   (void)kit_cg_new(c, &cg);
   if (cg) (void)kit_cg_begin(cg, ob, &opts);
   EXPECT(cg != NULL, "delayed chain cg allocation failed");
   if (!cg) {
     kit_obj_builder_free(ob);
     return 0;
   }
 
   memset(&param_desc, 0, sizeof param_desc);
   param_desc.type = i32_ty;
   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;
 
   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);
   EXPECT(sym != KIT_CG_SYM_NONE, "delayed chain decl failed");
 
   kit_cg_func_begin(cg, sym);
   memset(&attrs, 0, sizeof attrs);
   attrs.name = kit_sym_intern(c, KIT_SLICE_LIT("p"));
   param = kit_cg_param(cg, 0, i32_ty, attrs);
   EXPECT(param != KIT_CG_LOCAL_NONE, "delayed chain param failed");
   memset(&mem, 0, sizeof mem);
   mem.type = i32_ty;
   mem.align = kit_cg_type_align(c, i32_ty);
   kit_cg_push_local(cg, param);
   kit_cg_load(cg, mem);
   kit_cg_push_int(cg, 40, i32_ty);
   kit_cg_int_binop(cg, KIT_CG_INT_ADD, 0);
   kit_cg_push_int(cg, 2, i32_ty);
   kit_cg_int_binop(cg, KIT_CG_INT_ADD, 0);
   kit_cg_ret(cg);
   kit_cg_func_end(cg);
 
   finish_cg(cg, "delayed chain");
   kit_cg_free(cg);
   size = text_size(c, ob);
   kit_obj_builder_free(ob);
   return size;
 }
 
 static uint32_t cg_emit_unary_chain(KitCompiler* c, KitCgTypeId i32_ty,
                                     const char* name) {
   KitCodeOptions opts;
   KitObjBuilder* ob;
   KitCg* cg;
   KitCgFuncParam param_desc;
   KitCgFuncSig sig;
   KitCgDecl decl;
   KitCgSym sym;
   KitCgLocalAttrs attrs;
   KitCgLocal param;
   KitCgMemAccess mem;
   uint32_t size;
 
   memset(&opts, 0, sizeof opts);
   opts.opt_level = 1;
   ob = new_obj(c);
   EXPECT(ob != NULL, "unary chain obj builder allocation failed");
   if (!ob) return 0;
   cg = NULL;
   (void)kit_cg_new(c, &cg);
   if (cg) (void)kit_cg_begin(cg, ob, &opts);
   EXPECT(cg != NULL, "unary chain cg allocation failed");
   if (!cg) {
     kit_obj_builder_free(ob);
     return 0;
   }
 
   memset(&param_desc, 0, sizeof param_desc);
   param_desc.type = i32_ty;
   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;
 
   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);
   EXPECT(sym != KIT_CG_SYM_NONE, "unary chain decl failed");
 
   kit_cg_func_begin(cg, sym);
   memset(&attrs, 0, sizeof attrs);
   attrs.name = kit_sym_intern(c, KIT_SLICE_LIT("p"));
   param = kit_cg_param(cg, 0, i32_ty, attrs);
   EXPECT(param != KIT_CG_LOCAL_NONE, "unary chain param failed");
   memset(&mem, 0, sizeof mem);
   mem.type = i32_ty;
   mem.align = kit_cg_type_align(c, i32_ty);
   kit_cg_push_local(cg, param);
   kit_cg_load(cg, mem);
   kit_cg_int_unop(cg, KIT_CG_INT_BNOT, 0);
   kit_cg_int_unop(cg, KIT_CG_INT_BNOT, 0);
   kit_cg_ret(cg);
   kit_cg_func_end(cg);
 
   finish_cg(cg, "unary chain");
   kit_cg_free(cg);
   size = text_size(c, ob);
   kit_obj_builder_free(ob);
   return size;
 }
 
 static uint32_t cg_emit_local_shadow(KitCompiler* c, KitCgTypeId i32_ty,
                                      const char* name) {
   KitCodeOptions opts;
   KitObjBuilder* ob;
   KitCg* cg;
   KitCgFuncSig sig;
   KitCgDecl decl;
   KitCgSym sym;
   KitCgLocalAttrs attrs;
   KitCgLocal local;
   KitCgMemAccess mem;
   uint32_t size;
 
   memset(&opts, 0, sizeof opts);
   opts.opt_level = 1;
   ob = new_obj(c);
   EXPECT(ob != NULL, "local shadow obj builder allocation failed");
   if (!ob) return 0;
   cg = NULL;
   (void)kit_cg_new(c, &cg);
   if (cg) (void)kit_cg_begin(cg, ob, &opts);
   EXPECT(cg != NULL, "local shadow cg allocation failed");
   if (!cg) {
     kit_obj_builder_free(ob);
     return 0;
   }
 
   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.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);
   EXPECT(sym != KIT_CG_SYM_NONE, "local shadow decl failed");
 
   kit_cg_func_begin(cg, sym);
   memset(&attrs, 0, sizeof attrs);
   attrs.name = kit_sym_intern(c, KIT_SLICE_LIT("x"));
   local = kit_cg_local(cg, i32_ty, attrs);
   EXPECT(local != KIT_CG_LOCAL_NONE, "local shadow local failed");
   memset(&mem, 0, sizeof mem);
   mem.type = i32_ty;
   mem.align = kit_cg_type_align(c, i32_ty);
   kit_cg_push_local(cg, local);
   kit_cg_push_int(cg, 40, i32_ty);
   kit_cg_store(cg, mem);
   kit_cg_push_local(cg, local);
   kit_cg_load(cg, mem);
   kit_cg_push_int(cg, 2, i32_ty);
   kit_cg_int_binop(cg, KIT_CG_INT_ADD, 0);
   kit_cg_ret(cg);
   kit_cg_func_end(cg);
 
   finish_cg(cg, "local shadow");
   kit_cg_free(cg);
   size = text_size(c, ob);
   kit_obj_builder_free(ob);
   return size;
 }
 
 static uint32_t cg_emit_delayed_cmp(KitCompiler* c, KitCgTypeId i32_ty,
                                     const char* name) {
   KitCodeOptions opts;
   KitObjBuilder* ob;
   KitCg* cg;
   KitCgFuncParam param_desc;
   KitCgFuncSig sig;
   KitCgDecl decl;
   KitCgSym sym;
   KitCgLocalAttrs attrs;
   KitCgLocal param;
   KitCgMemAccess mem;
   uint32_t size;
 
   memset(&opts, 0, sizeof opts);
   opts.opt_level = 1;
   ob = new_obj(c);
   EXPECT(ob != NULL, "delayed cmp obj builder allocation failed");
   if (!ob) return 0;
   cg = NULL;
   (void)kit_cg_new(c, &cg);
   if (cg) (void)kit_cg_begin(cg, ob, &opts);
   EXPECT(cg != NULL, "delayed cmp cg allocation failed");
   if (!cg) {
     kit_obj_builder_free(ob);
     return 0;
   }
 
   memset(&param_desc, 0, sizeof param_desc);
   param_desc.type = i32_ty;
   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;
 
   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);
   EXPECT(sym != KIT_CG_SYM_NONE, "delayed cmp decl failed");
 
   kit_cg_func_begin(cg, sym);
   memset(&attrs, 0, sizeof attrs);
   attrs.name = kit_sym_intern(c, KIT_SLICE_LIT("p"));
   param = kit_cg_param(cg, 0, i32_ty, attrs);
   EXPECT(param != KIT_CG_LOCAL_NONE, "delayed cmp param failed");
   memset(&mem, 0, sizeof mem);
   mem.type = i32_ty;
   mem.align = kit_cg_type_align(c, i32_ty);
   kit_cg_push_local(cg, param);
   kit_cg_load(cg, mem);
   kit_cg_push_int(cg, 40, i32_ty);
   kit_cg_int_binop(cg, KIT_CG_INT_ADD, 0);
   kit_cg_push_int(cg, 2, i32_ty);
   kit_cg_int_binop(cg, KIT_CG_INT_ADD, 0);
   kit_cg_push_int(cg, 42, i32_ty);
   kit_cg_int_cmp(cg, KIT_CG_INT_EQ);
   kit_cg_ret(cg);
   kit_cg_func_end(cg);
 
   finish_cg(cg, "delayed cmp");
   kit_cg_free(cg);
   size = text_size(c, ob);
   kit_obj_builder_free(ob);
   return size;
 }
 
 static uint32_t cg_emit_delayed_store(KitCompiler* c, KitCgTypeId i32_ty,
                                       const char* name) {
   KitCodeOptions opts;
   KitObjBuilder* ob;
   KitCg* cg;
   KitCgFuncParam param_desc;
   KitCgFuncSig sig;
   KitCgDecl decl;
   KitCgSym sym;
   KitCgLocalAttrs attrs;
   KitCgLocal param;
   KitCgLocal local;
   KitCgMemAccess mem;
   uint32_t size;
 
   memset(&opts, 0, sizeof opts);
   opts.opt_level = 1;
   ob = new_obj(c);
   EXPECT(ob != NULL, "delayed store obj builder allocation failed");
   if (!ob) return 0;
   cg = NULL;
   (void)kit_cg_new(c, &cg);
   if (cg) (void)kit_cg_begin(cg, ob, &opts);
   EXPECT(cg != NULL, "delayed store cg allocation failed");
   if (!cg) {
     kit_obj_builder_free(ob);
     return 0;
   }
 
   memset(&param_desc, 0, sizeof param_desc);
   param_desc.type = i32_ty;
   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;
 
   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);
   EXPECT(sym != KIT_CG_SYM_NONE, "delayed store decl failed");
 
   kit_cg_func_begin(cg, sym);
   memset(&attrs, 0, sizeof attrs);
   attrs.name = kit_sym_intern(c, KIT_SLICE_LIT("p"));
   param = kit_cg_param(cg, 0, i32_ty, attrs);
   attrs.name = kit_sym_intern(c, KIT_SLICE_LIT("x"));
   local = kit_cg_local(cg, i32_ty, attrs);
   EXPECT(param != KIT_CG_LOCAL_NONE, "delayed store param failed");
   EXPECT(local != KIT_CG_LOCAL_NONE, "delayed store local failed");
   memset(&mem, 0, sizeof mem);
   mem.type = i32_ty;
   mem.align = kit_cg_type_align(c, i32_ty);
   kit_cg_push_local(cg, local);
   kit_cg_push_local(cg, param);
   kit_cg_load(cg, mem);
   kit_cg_push_int(cg, 40, i32_ty);
   kit_cg_int_binop(cg, KIT_CG_INT_ADD, 0);
   kit_cg_push_int(cg, 2, i32_ty);
   kit_cg_int_binop(cg, KIT_CG_INT_ADD, 0);
   kit_cg_store(cg, mem);
   kit_cg_push_local(cg, local);
   kit_cg_load(cg, mem);
   kit_cg_ret(cg);
   kit_cg_func_end(cg);
 
   finish_cg(cg, "delayed store");
   kit_cg_free(cg);
   size = text_size(c, ob);
   kit_obj_builder_free(ob);
   return size;
 }
 
 static uint32_t cg_emit_delayed_pressure(KitCompiler* c, KitCgTypeId i32_ty,
                                          const char* name) {
   enum { NPARAMS = 13 };
   KitCodeOptions opts;
   KitObjBuilder* ob;
   KitCg* cg;
   KitCgFuncParam param_desc[NPARAMS];
   KitCgFuncSig sig;
   KitCgDecl decl;
   KitCgSym sym;
   KitCgLocalAttrs attrs;
   KitCgLocal params[NPARAMS];
   KitCgMemAccess mem;
   uint32_t size;
 
   memset(&opts, 0, sizeof opts);
   opts.opt_level = 1;
   ob = new_obj(c);
   EXPECT(ob != NULL, "delayed pressure obj builder allocation failed");
   if (!ob) return 0;
   cg = NULL;
   (void)kit_cg_new(c, &cg);
   if (cg) (void)kit_cg_begin(cg, ob, &opts);
   EXPECT(cg != NULL, "delayed pressure cg allocation failed");
   if (!cg) {
     kit_obj_builder_free(ob);
     return 0;
   }
 
   memset(param_desc, 0, sizeof param_desc);
   for (uint32_t i = 0; i < NPARAMS; ++i) param_desc[i].type = i32_ty;
   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 = NPARAMS;
   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);
   EXPECT(sym != KIT_CG_SYM_NONE, "delayed pressure decl failed");
 
   kit_cg_func_begin(cg, sym);
   memset(&attrs, 0, sizeof attrs);
   memset(&mem, 0, sizeof mem);
   mem.type = i32_ty;
   mem.align = kit_cg_type_align(c, i32_ty);
   for (uint32_t i = 0; i < NPARAMS; ++i) {
     char pname[8];
     snprintf(pname, sizeof pname, "p%u", (unsigned)i);
     attrs.name = kit_sym_intern(c, kit_slice_cstr(pname));
     params[i] = kit_cg_param(cg, i, i32_ty, attrs);
     EXPECT(params[i] != KIT_CG_LOCAL_NONE, "delayed pressure param failed");
   }
 
   for (uint32_t i = 0; i + 1 < NPARAMS; ++i) {
     kit_cg_push_local(cg, params[i]);
     kit_cg_load(cg, mem);
     kit_cg_push_int(cg, 1, i32_ty);
     kit_cg_int_binop(cg, KIT_CG_INT_ADD, 0);
   }
   kit_cg_push_local(cg, params[NPARAMS - 1]);
   kit_cg_load(cg, mem);
   kit_cg_drop(cg);
   for (uint32_t i = 0; i + 1 < NPARAMS; ++i) kit_cg_drop(cg);
   kit_cg_push_int(cg, 0, i32_ty);
   kit_cg_ret(cg);
   kit_cg_func_end(cg);
 
   finish_cg(cg, "delayed pressure");
   kit_cg_free(cg);
   size = text_size(c, ob);
   kit_obj_builder_free(ob);
   return size;
 }
 
 typedef enum CgShadowBoundary {
   CG_SHADOW_LABEL,
   CG_SHADOW_BRANCH,
   CG_SHADOW_ADDR,
   CG_SHADOW_VOLATILE,
   CG_SHADOW_INDIRECT_STORE,
 } CgShadowBoundary;
 
 static uint32_t cg_emit_local_shadow_boundary(KitCompiler* c,
                                               KitCgTypeId i32_ty,
                                               const char* name,
                                               CgShadowBoundary boundary) {
   KitCodeOptions opts;
   KitObjBuilder* ob;
   KitCg* cg;
   KitCgFuncSig sig;
   KitCgDecl decl;
   KitCgSym sym;
   KitCgLocalAttrs attrs;
   KitCgLocal local;
   KitCgMemAccess mem;
   uint32_t size;
 
   memset(&opts, 0, sizeof opts);
   opts.opt_level = 1;
   ob = new_obj(c);
   EXPECT(ob != NULL, "local shadow boundary obj builder allocation failed");
   if (!ob) return 0;
   cg = NULL;
   (void)kit_cg_new(c, &cg);
   if (cg) (void)kit_cg_begin(cg, ob, &opts);
   EXPECT(cg != NULL, "local shadow boundary cg allocation failed");
   if (!cg) {
     kit_obj_builder_free(ob);
     return 0;
   }
 
   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.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);
   EXPECT(sym != KIT_CG_SYM_NONE, "local shadow boundary decl failed");
 
   kit_cg_func_begin(cg, sym);
   memset(&attrs, 0, sizeof attrs);
   attrs.name = kit_sym_intern(c, KIT_SLICE_LIT("x"));
   local = kit_cg_local(cg, i32_ty, attrs);
   EXPECT(local != KIT_CG_LOCAL_NONE, "local shadow boundary local failed");
   memset(&mem, 0, sizeof mem);
   mem.type = i32_ty;
   mem.align = kit_cg_type_align(c, i32_ty);
 
   kit_cg_push_local(cg, local);
   kit_cg_push_int(cg, 40, i32_ty);
   kit_cg_store(cg, mem);
 
   switch (boundary) {
     case CG_SHADOW_LABEL: {
       KitCgLabel label = kit_cg_label_new(cg);
       kit_cg_label_place(cg, label);
       break;
     }
     case CG_SHADOW_BRANCH: {
       KitCgLabel label = kit_cg_label_new(cg);
       kit_cg_push_int(cg, 0, i32_ty);
       kit_cg_branch_true(cg, label);
       kit_cg_label_place(cg, label);
       break;
     }
     case CG_SHADOW_ADDR:
       kit_cg_push_local_addr(cg, local);
       kit_cg_drop(cg);
       break;
     case CG_SHADOW_VOLATILE:
       mem.flags = KIT_CG_MEM_VOLATILE;
       kit_cg_push_local(cg, local);
       kit_cg_load(cg, mem);
       kit_cg_drop(cg);
       mem.flags = 0;
       break;
     case CG_SHADOW_INDIRECT_STORE:
       kit_cg_push_local_addr(cg, local);
       kit_cg_deref(cg, 0); /* pointer VALUE -> PLACE for the store */
       kit_cg_push_int(cg, 41, i32_ty);
       kit_cg_store(cg, mem);
       break;
   }
 
   kit_cg_push_local(cg, local);
   kit_cg_load(cg, mem);
   kit_cg_push_int(cg, 2, i32_ty);
   kit_cg_int_binop(cg, KIT_CG_INT_ADD, 0);
   kit_cg_ret(cg);
   kit_cg_func_end(cg);
 
   finish_cg(cg, "local shadow boundary");
   kit_cg_free(cg);
   size = text_size(c, ob);
   kit_obj_builder_free(ob);
   return size;
 }
 
 static uint32_t cg_emit_local_shadow_partial_store(KitCompiler* c,
                                                    KitCgTypeId i32_ty,
                                                    KitCgTypeId i8_ty,
                                                    const char* name) {
   KitCodeOptions opts;
   KitObjBuilder* ob;
   KitCg* cg;
   KitCgFuncSig sig;
   KitCgDecl decl;
   KitCgSym sym;
   KitCgLocalAttrs attrs;
   KitCgLocal local;
   KitCgMemAccess mem_i32;
   KitCgMemAccess mem_i8;
   uint32_t size;
 
   memset(&opts, 0, sizeof opts);
   opts.opt_level = 1;
   ob = new_obj(c);
   EXPECT(ob != NULL, "partial shadow obj builder allocation failed");
   if (!ob) return 0;
   cg = NULL;
   (void)kit_cg_new(c, &cg);
   if (cg) (void)kit_cg_begin(cg, ob, &opts);
   EXPECT(cg != NULL, "partial shadow cg allocation failed");
   if (!cg) {
     kit_obj_builder_free(ob);
     return 0;
   }
 
   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.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);
   EXPECT(sym != KIT_CG_SYM_NONE, "partial shadow decl failed");
 
   kit_cg_func_begin(cg, sym);
   memset(&attrs, 0, sizeof attrs);
   attrs.name = kit_sym_intern(c, KIT_SLICE_LIT("x"));
   local = kit_cg_local(cg, i32_ty, attrs);
   EXPECT(local != KIT_CG_LOCAL_NONE, "partial shadow local failed");
   memset(&mem_i32, 0, sizeof mem_i32);
   mem_i32.type = i32_ty;
   mem_i32.align = kit_cg_type_align(c, i32_ty);
   memset(&mem_i8, 0, sizeof mem_i8);
   mem_i8.type = i8_ty;
   mem_i8.align = kit_cg_type_align(c, i8_ty);
 
   kit_cg_push_local(cg, local);
   kit_cg_push_int(cg, 40, i32_ty);
   kit_cg_store(cg, mem_i32);
   kit_cg_push_local(cg, local);
   kit_cg_push_int(cg, 7, i8_ty);
   kit_cg_store(cg, mem_i8);
   kit_cg_push_local(cg, local);
   kit_cg_load(cg, mem_i32);
   kit_cg_push_int(cg, 2, i32_ty);
   kit_cg_int_binop(cg, KIT_CG_INT_ADD, 0);
   kit_cg_ret(cg);
   kit_cg_func_end(cg);
 
   finish_cg(cg, "partial shadow");
   kit_cg_free(cg);
   size = text_size(c, ob);
   kit_obj_builder_free(ob);
   return size;
 }
 
 static void exercise_cg_constfold_phases(KitCompiler* c, KitCgTypeId i32_ty,
                                          KitCgTypeId i8_ty) {
   uint32_t delayed_size =
       cg_emit_delayed_chain(c, i32_ty, "cg_delayed_chain_o1");
   uint32_t unary_size = cg_emit_unary_chain(c, i32_ty, "cg_unary_chain_o1");
   uint32_t local_size = cg_emit_local_shadow(c, i32_ty, "cg_local_shadow_o1");
   uint32_t delayed_cmp_size =
       cg_emit_delayed_cmp(c, i32_ty, "cg_delayed_cmp_o1");
   uint32_t delayed_store_size =
       cg_emit_delayed_store(c, i32_ty, "cg_delayed_store_o1");
   uint32_t pressure_size =
       cg_emit_delayed_pressure(c, i32_ty, "cg_delayed_pressure_o1");
   uint32_t label_size = cg_emit_local_shadow_boundary(
       c, i32_ty, "cg_shadow_label_o1", CG_SHADOW_LABEL);
   uint32_t branch_size = cg_emit_local_shadow_boundary(
       c, i32_ty, "cg_shadow_branch_o1", CG_SHADOW_BRANCH);
   uint32_t addr_size = cg_emit_local_shadow_boundary(
       c, i32_ty, "cg_shadow_addr_o1", CG_SHADOW_ADDR);
   uint32_t volatile_size = cg_emit_local_shadow_boundary(
       c, i32_ty, "cg_shadow_volatile_o1", CG_SHADOW_VOLATILE);
   uint32_t indirect_size = cg_emit_local_shadow_boundary(
       c, i32_ty, "cg_shadow_indirect_o1", CG_SHADOW_INDIRECT_STORE);
   uint32_t partial_size = cg_emit_local_shadow_partial_store(
       c, i32_ty, i8_ty, "cg_shadow_partial_o1");
 
   EXPECT(delayed_size <= 56,
          "delayed arithmetic chain should materialize as one add, text "
          "size=%u",
          delayed_size);
   EXPECT(unary_size <= 48,
          "delayed unary chain should collapse before return, text size=%u",
          unary_size);
   EXPECT(local_size <= 32,
          "local constant shadow should fold x=40; return x+2, text size=%u",
          local_size);
   EXPECT(delayed_cmp_size <= 64,
          "delayed arithmetic consumed by compare should stay compact, text "
          "size=%u",
          delayed_cmp_size);
   EXPECT(delayed_store_size <= 64,
          "delayed arithmetic forced by store should stay compact, text size=%u",
          delayed_store_size);
   EXPECT(pressure_size > 0,
          "delayed arithmetic pressure materialization should emit code");
   EXPECT(label_size > local_size,
          "label should clear local shadow, label=%u folded=%u", label_size,
          local_size);
   EXPECT(branch_size > local_size,
          "branch should clear local shadow, branch=%u folded=%u", branch_size,
          local_size);
   EXPECT(addr_size > local_size,
          "address-taking should clear local shadow, addr=%u folded=%u",
          addr_size, local_size);
   EXPECT(volatile_size > local_size,
          "volatile access should clear local shadow, volatile=%u folded=%u",
          volatile_size, local_size);
   EXPECT(indirect_size > local_size,
          "indirect store should clear local shadow, indirect=%u folded=%u",
          indirect_size, local_size);
   EXPECT(partial_size > local_size,
          "partial-width store should clear local shadow, partial=%u folded=%u",
          partial_size, local_size);
 }
 
 static void exercise_cg_memop_constfold_shape(KitCompiler* c,
                                               KitCgTypeId i32_ty,
                                               KitCgTypeId i64_ty,
                                               KitCgTypeId ptr_i32) {
   KitCodeOptions opts;
   KitObjBuilder* ob;
   KitWriter* dump = NULL;
   KitCg* cg;
   KitCgFuncParam params[2];
   KitCgFuncSig sig;
   KitCgDecl decl;
   KitCgSym fn_sym;
   KitCgSym data_sym;
   KitCgLocalAttrs attrs;
   KitCgLocal base_param;
   KitCgLocal idx_param;
   KitCgMemAccess mem_i32;
   KitCgMemAccess mem_i64;
   KitCgMemAccess mem_ptr;
   const uint8_t data[64] = {0};
   const uint8_t* bytes;
   size_t len = 0;
   char text[8192];
   size_t copy_len;
 
   memset(&opts, 0, sizeof opts);
   opts.opt_level = 1;
   opts.emit_ir = true;
   EXPECT(kit_writer_mem(&g_u.heap, &dump) == KIT_OK && dump != NULL,
          "memop fold dump writer allocation failed");
   if (!dump) return;
   opts.ir_dump_writer = dump;
 
   ob = new_obj(c);
   EXPECT(ob != NULL, "memop fold obj builder allocation failed");
   if (!ob) {
     kit_writer_close(dump);
     return;
   }
   cg = NULL;
   (void)kit_cg_new(c, &cg);
   if (cg) (void)kit_cg_begin(cg, ob, &opts);
   EXPECT(cg != NULL, "memop fold cg allocation failed");
   if (!cg) {
     kit_obj_builder_free(ob);
     kit_writer_close(dump);
     return;
   }
 
   data_sym = kit_cg_const_data(cg, data, sizeof data, 4, i32_ty);
   EXPECT(data_sym != KIT_CG_SYM_NONE, "memop fold const data failed");
 
   memset(params, 0, sizeof params);
   params[0].type = ptr_i32;
   params[1].type = i64_ty;
   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 = params;
   sig.nparams = 2;
   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_LIT("cg_memop_constfold_shape"));
   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;
   fn_sym = kit_cg_decl(cg, decl);
   EXPECT(fn_sym != KIT_CG_SYM_NONE, "memop fold function decl failed");
 
   memset(&mem_i32, 0, sizeof mem_i32);
   mem_i32.type = i32_ty;
   mem_i32.align = kit_cg_type_align(c, i32_ty);
   memset(&mem_i64, 0, sizeof mem_i64);
   mem_i64.type = i64_ty;
   mem_i64.align = kit_cg_type_align(c, i64_ty);
   memset(&mem_ptr, 0, sizeof mem_ptr);
   mem_ptr.type = ptr_i32;
   mem_ptr.align = kit_cg_type_align(c, ptr_i32);
 
   kit_cg_func_begin(cg, fn_sym);
   memset(&attrs, 0, sizeof attrs);
   attrs.name = kit_sym_intern(c, KIT_SLICE_LIT("base"));
   base_param = kit_cg_param(cg, 0, ptr_i32, attrs);
   attrs.name = kit_sym_intern(c, KIT_SLICE_LIT("idx"));
   idx_param = kit_cg_param(cg, 1, i64_ty, attrs);
   EXPECT(base_param != KIT_CG_LOCAL_NONE && idx_param != KIT_CG_LOCAL_NONE,
          "memop fold params failed");
 
   /* Constant base addend + constant index*scale + offset: 11 + 3*8 + 5. */
   kit_cg_push_symbol_addr(cg, data_sym, 11);
   kit_cg_push_int(cg, 3, i64_ty);
   kit_cg_elem_scaled(cg, 8, 5);
   kit_cg_load(cg, mem_i32);
   kit_cg_drop(cg);
 
   /* Non-global offsets wider than the memop displacement are materialized into
    * the base instead of truncated to i32. */
   kit_cg_push_local(cg, base_param);
   kit_cg_load(cg, mem_ptr);
   kit_cg_push_local(cg, idx_param);
   kit_cg_load(cg, mem_i64);
   kit_cg_elem_scaled(cg, 8, 2147483656LL);
   kit_cg_load(cg, mem_i32);
   kit_cg_drop(cg);
 
   /* Dynamic base and index keep the scale and offset on the memory operand. */
   kit_cg_push_local(cg, base_param);
   kit_cg_load(cg, mem_ptr);
   kit_cg_push_local(cg, idx_param);
   kit_cg_load(cg, mem_i64);
   kit_cg_elem_scaled(cg, 8, 5);
   kit_cg_load(cg, mem_i32);
   kit_cg_ret(cg);
   kit_cg_func_end(cg);
 
   EXPECT(kit_cg_finish(cg, NULL) == KIT_OK, "memop fold cg finish failed");
   bytes = kit_writer_mem_bytes(dump, &len);
   copy_len = len < sizeof text - 1u ? len : sizeof text - 1u;
   if (bytes && copy_len) memcpy(text, bytes, copy_len);
   text[copy_len] = '\0';
   EXPECT(bytes != NULL && len > 0 && len < sizeof text,
          "memop fold IR dump missing or too large");
   EXPECT(strstr(text, "addr_of") == NULL,
          "memop fold should not materialize folded addresses:\n%s", text);
   EXPECT(strstr(text, "sym#") != NULL && strstr(text, "+40") != NULL,
          "memop fold should fold symbol base/addend/index/offset:\n%s", text);
   EXPECT(strstr(text, "*8+5") != NULL,
          "memop fold should preserve dynamic index scale/offset:\n%s", text);
   EXPECT(strstr(text, "imm:2147483656") != NULL,
          "memop fold should materialize offsets wider than i32:\n%s", text);
 
   kit_cg_free(cg);
   kit_obj_builder_free(ob);
   kit_writer_close(dump);
 }
 
 static KitCg* begin_void_cg_func(KitCompiler* c, const char* name,
                                  KitObjBuilder** ob_out) {
   KitCodeOptions opts;
   KitObjBuilder* ob;
   KitCg* cg;
   KitCgFuncSig sig;
   KitCgFuncResult result;
   KitCgDecl decl;
   KitCgSym sym;
 
   if (ob_out) *ob_out = NULL;
   memset(&opts, 0, sizeof opts);
   ob = new_obj(c);
   EXPECT(ob != NULL, "%s obj builder allocation failed", name);
   if (!ob) return NULL;
   cg = NULL;
   EXPECT(kit_cg_new(c, &cg) == KIT_OK && cg != NULL, "%s cg allocation failed",
          name);
   if (!cg) {
     kit_obj_builder_free(ob);
     return NULL;
   }
   EXPECT(kit_cg_begin(cg, ob, &opts) == KIT_OK, "%s cg begin failed", name);
 
   memset(&sig, 0, sizeof sig);
   memset(&result, 0, sizeof result);
   result.type = kit_cg_type_builtin(c, KIT_CG_BUILTIN_VOID);
   sig.result = result;
   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_LOCAL;
   decl.sym.visibility = KIT_CG_VIS_DEFAULT;
   sym = kit_cg_decl(cg, decl);
   EXPECT(sym != KIT_CG_SYM_NONE, "%s decl failed", name);
   if (sym == KIT_CG_SYM_NONE) {
     kit_cg_free(cg);
     kit_obj_builder_free(ob);
     return NULL;
   }
   kit_cg_func_begin(cg, sym);
   if (ob_out) *ob_out = ob;
   return cg;
 }
 
 static void exercise_cg_slot_lang_facts(KitCompiler* c, KitCgTypeId i32_ty) {
   static const char tag_a[] = "slot-a";
   static const char tag_b[] = "slot-b";
   KitObjBuilder* ob;
   KitCg* cg = begin_void_cg_func(c, "cg_slot_lang_facts", &ob);
   KitCgSlotInfo info;
   KitCgScope scope;
   if (!cg) return;
 
   kit_cg_push_int(cg, 1, i32_ty);
   kit_cg_retag_top(cg, tag_a, 0x0003u);
   kit_cg_dup(cg);
   info = kit_cg_slot_info(cg, 0);
   EXPECT(info.cg_type == i32_ty && info.lang_type == tag_a &&
              info.lang_flags == 0x0003u,
          "dup should copy top slot facts");
   info = kit_cg_slot_info(cg, 1);
   EXPECT(info.lang_type == tag_a && info.lang_flags == 0x0003u,
          "dup should preserve original slot facts");
   kit_cg_retag_at(cg, 1, tag_b, 0x0010u);
   kit_cg_set_top_flags(cg, 0x0004u, 0x0001u);
   info = kit_cg_slot_info(cg, 0);
   EXPECT(info.lang_type == tag_a && info.lang_flags == 0x0006u,
          "set_top_flags should update only top flags");
   info = kit_cg_slot_info(cg, 1);
   EXPECT(info.lang_type == tag_b && info.lang_flags == 0x0010u,
          "retag_at should update depth-selected slot");
   kit_cg_drop(cg);
   kit_cg_drop(cg);
 
   kit_cg_push_int(cg, 2, i32_ty);
   kit_cg_retag_top(cg, tag_a, 0x00ffu);
   kit_cg_push_int(cg, 3, i32_ty);
   kit_cg_retag_top(cg, tag_b, 0x00eeu);
   kit_cg_int_binop(cg, KIT_CG_INT_ADD, 0);
   info = kit_cg_slot_info(cg, 0);
   EXPECT(
       info.cg_type == i32_ty && info.lang_type == NULL && info.lang_flags == 0,
       "fresh binop producer should clear slot facts");
   kit_cg_drop(cg);
 
   scope = kit_cg_block_begin_value(cg, i32_ty);
   kit_cg_push_int(cg, 4, i32_ty);
   kit_cg_retag_top(cg, tag_b, 0x0033u);
   kit_cg_scope_end(cg, scope);
   info = kit_cg_slot_info(cg, 0);
   EXPECT(info.cg_type == i32_ty && info.lang_type == tag_b &&
              info.lang_flags == 0x0033u,
          "scope result mover should preserve slot facts");
   kit_cg_drop(cg);
 
   kit_cg_ret(cg);
   kit_cg_func_end(cg);
   kit_cg_free(cg);
   kit_obj_builder_free(ob);
 }
 
 static void exercise_cg_field_at_store_keep(KitCompiler* c, KitCgTypeId i32_ty,
                                             KitCgTypeId rec_ty) {
   static const char value_tag[] = "assigned-value";
   KitObjBuilder* ob;
   KitCg* cg = begin_void_cg_func(c, "cg_field_at_store_keep", &ob);
   KitCgLocalAttrs attrs;
   KitCgLocal local;
   KitCgMemAccess mem;
   KitCgSlotInfo info;
   if (!cg) return;
 
   memset(&attrs, 0, sizeof attrs);
   attrs.name = kit_sym_intern(c, KIT_SLICE_LIT("r"));
   local = kit_cg_local(cg, rec_ty, attrs);
   EXPECT(local != KIT_CG_LOCAL_NONE, "field_at local allocation failed");
 
   memset(&mem, 0, sizeof mem);
   mem.type = i32_ty;
   mem.align = kit_cg_type_align(c, i32_ty);
 
   kit_cg_push_local(cg, local);
   kit_cg_field_at(cg, 4, i32_ty);
   kit_cg_push_int(cg, 42, i32_ty);
   kit_cg_retag_top(cg, value_tag, 0x0042u);
   kit_cg_store_keep(cg, mem);
   EXPECT(kit_cg_stack_depth(cg) == 1u, "store_keep should leave one value");
   info = kit_cg_slot_info(cg, 0);
   EXPECT(info.cg_type == i32_ty && info.lang_type == value_tag &&
              info.lang_flags == 0x0042u,
          "store_keep should preserve assigned value slot facts");
   kit_cg_drop(cg);
 
   kit_cg_push_local(cg, local);
   kit_cg_field_at(cg, 4, i32_ty);
   kit_cg_load(cg, mem);
   info = kit_cg_slot_info(cg, 0);
   EXPECT(
       info.cg_type == i32_ty && info.lang_type == NULL && info.lang_flags == 0,
       "load through field_at should produce a freshly untagged value");
   kit_cg_drop(cg);
 
   kit_cg_ret(cg);
   kit_cg_func_end(cg);
   kit_cg_free(cg);
   kit_obj_builder_free(ob);
 }
 
 typedef struct BadStoreCtx {
   KitCompiler* c;
   KitCgTypeId i32_ty;
   KitCgTypeId i64_ty;
   KitCgTypeId rec_ty;
 } BadStoreCtx;
 
 static KitCg* cg_begin_bad_store_func(KitCompiler* c, const char* name) {
   KitCodeOptions opts;
   KitObjBuilder* ob;
   KitCg* cg;
   KitCgFuncSig sig;
   KitCgFuncResult result;
   KitCgDecl decl;
   KitCgSym sym;
 
   memset(&opts, 0, sizeof opts);
   ob = new_obj(c);
   EXPECT(ob != NULL, "bad-store obj builder allocation failed");
   if (!ob) return NULL;
   cg = NULL;
   (void)kit_cg_new(c, &cg);
   if (cg) (void)kit_cg_begin(cg, ob, &opts);
   EXPECT(cg != NULL, "bad-store cg allocation failed");
   if (!cg) {
     kit_obj_builder_free(ob);
     return NULL;
   }
 
   memset(&sig, 0, sizeof sig);
   memset(&result, 0, sizeof result);
   result.type = kit_cg_type_builtin(c, KIT_CG_BUILTIN_VOID);
   sig.result = result;
   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_LOCAL;
   decl.sym.visibility = KIT_CG_VIS_DEFAULT;
   sym = kit_cg_decl(cg, decl);
   EXPECT(sym != KIT_CG_SYM_NONE, "bad-store function decl failed");
   if (sym == KIT_CG_SYM_NONE) {
     kit_cg_free(cg);
     kit_obj_builder_free(ob);
     return NULL;
   }
   kit_cg_func_begin(cg, sym);
   return cg;
 }
 
 static void run_bad_scalar_access_to_aggregate(void* arg) {
   BadStoreCtx* ctx = (BadStoreCtx*)arg;
   KitCgLocal local;
   KitCgLocalAttrs attrs;
   KitCgMemAccess mem;
   KitCg* cg =
       cg_begin_bad_store_func(ctx->c, "cg_bad_scalar_access_to_aggregate");
   if (!cg) return;
 
   memset(&attrs, 0, sizeof attrs);
   local = kit_cg_local(cg, ctx->rec_ty, attrs);
   memset(&mem, 0, sizeof mem);
   mem.type = ctx->i32_ty;
   mem.align = kit_cg_type_align(ctx->c, ctx->i32_ty);
   kit_cg_push_local(cg, local);
   kit_cg_push_int(cg, 42, ctx->i32_ty);
   kit_cg_store(cg, mem);
 }
 
 static void run_bad_store_value_size(void* arg) {
   BadStoreCtx* ctx = (BadStoreCtx*)arg;
   KitCgLocal local;
   KitCgLocalAttrs attrs;
   KitCgMemAccess mem;
   KitCg* cg = cg_begin_bad_store_func(ctx->c, "cg_bad_store_value_size");
   if (!cg) return;
 
   memset(&attrs, 0, sizeof attrs);
   local = kit_cg_local(cg, ctx->i64_ty, attrs);
   memset(&mem, 0, sizeof mem);
   mem.type = ctx->i64_ty;
   mem.align = kit_cg_type_align(ctx->c, ctx->i64_ty);
   kit_cg_push_local(cg, local);
   kit_cg_push_int(cg, 42, ctx->i32_ty);
   kit_cg_store(cg, mem);
 }
 
 static void exercise_cg_memory_mismatch_diags(KitCompiler* c,
                                               KitCgTypeId i32_ty,
                                               KitCgTypeId i64_ty,
                                               KitCgTypeId rec_ty) {
   BadStoreCtx ctx;
   ctx.c = c;
   ctx.i32_ty = i32_ty;
   ctx.i64_ty = i64_ty;
   ctx.rec_ty = rec_ty;
 
   /* Scalar store at offset 0 into an aggregate lvalue is now a field-store
    * under the EA model (see doc/INDIRECT.md), so no diagnostic fires. */
   (void)run_bad_scalar_access_to_aggregate;
   EXPECT(expect_panic_contains(c, run_bad_store_value_size, &ctx,
                                "store value type/size mismatch"),
          "store size mismatch should diagnose clearly, got '%s'",
          g_u.last_diag);
 }
 
 static void exercise_compile_session_two_deltas(KitCompiler* c) {
   KitCompileSessionOptions sopts;
   KitCompileSession* s = NULL;
   KitAsmCompileOptions aopts;
   KitSourceInput in;
   KitObjBuilder* ob1 = NULL;
   KitObjBuilder* ob2 = NULL;
   static const uint8_t empty[] = "";
 
   memset(&sopts, 0, sizeof(sopts));
   memset(&aopts, 0, sizeof(aopts));
   sopts.lang = KIT_LANG_ASM;
   sopts.compile.language_options = &aopts;
   memset(&in, 0, sizeof(in));
   in.name = KIT_SLICE_LIT("<api-session-asm>");
   in.bytes.data = empty;
   in.bytes.len = 0;
   in.lang = KIT_LANG_ASM;
 
   EXPECT(kit_compile_session_new(c, &sopts, &s) == KIT_OK && s,
          "compile session new failed");
   if (!s) return;
   EXPECT(kit_compile_session_compile(s, &in, &ob1) == KIT_OK && ob1,
          "compile session first delta failed");
   EXPECT(kit_compile_session_compile(s, &in, &ob2) == KIT_OK && ob2,
          "compile session second delta failed");
   kit_obj_builder_free(ob1);
   kit_obj_builder_free(ob2);
   kit_compile_session_free(s);
 }
 
 static void exercise_cg_begin_end_two_objects(KitCompiler* c) {
   KitCg* cg = NULL;
   KitObjBuilder* ob1 = NULL;
   KitObjBuilder* ob2 = NULL;
   KitCodeOptions opts;
 
   memset(&opts, 0, sizeof(opts));
   ob1 = new_obj(c);
   ob2 = new_obj(c);
   EXPECT(ob1 && ob2, "obj builder allocation failed for cg begin/end session");
   EXPECT(kit_cg_new(c, &cg) == KIT_OK && cg, "cg session new failed");
   if (cg && ob1) {
     EXPECT(kit_cg_begin(cg, ob1, &opts) == KIT_OK,
            "cg begin first object failed");
     EXPECT(kit_cg_finish(cg, NULL) == KIT_OK, "cg finish first object failed");
     EXPECT(kit_cg_detach(cg) == KIT_OK, "cg detach first object failed");
   }
   if (cg && ob2) {
     EXPECT(kit_cg_begin(cg, ob2, &opts) == KIT_OK,
            "cg begin second object failed");
     EXPECT(kit_cg_finish(cg, NULL) == KIT_OK, "cg finish second object failed");
     EXPECT(kit_cg_detach(cg) == KIT_OK, "cg detach second object failed");
   }
   kit_cg_free(cg);
   kit_obj_builder_free(ob1);
   kit_obj_builder_free(ob2);
 }
 
 static void exercise_cg_free_does_not_finish(KitCompiler* c,
                                              KitCgTypeId i32_ty) {
   KitCodeOptions opts;
   KitCgUnitOptions unit_opts;
   KitObjBuilder* ob = NULL;
   KitCg* cg = NULL;
   KitCgFuncSig sig;
   KitCgDecl decl;
   KitCgSym sym;
 
   memset(&opts, 0, sizeof opts);
   opts.opt_level = 1;
   ob = new_obj(c);
   EXPECT(ob != NULL, "no-finish obj builder allocation failed");
   if (!ob) return;
   EXPECT(kit_cg_new(c, &cg) == KIT_OK && cg, "no-finish cg new failed");
   if (!cg) {
     kit_obj_builder_free(ob);
     return;
   }
   EXPECT(kit_cg_begin(cg, ob, &opts) == KIT_OK, "no-finish cg begin failed");
   memset(&unit_opts, 0, sizeof unit_opts);
   unit_opts.source_name = KIT_SLICE_LIT("cg_free_does_not_finish.c");
   EXPECT(kit_cg_begin_unit(cg, &unit_opts) == KIT_OK,
          "no-finish begin unit failed");
 
   memset(&sig, 0, sizeof sig);
   {
     KitCgFuncResult result;
     memset(&result, 0, sizeof result);
     result.type = i32_ty;
     sig.result = result;
     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_LIT("cg_free_does_not_finish"));
     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, "no-finish decl failed");
   kit_cg_func_begin(cg, sym);
   kit_cg_push_int(cg, 42, i32_ty);
   kit_cg_ret(cg);
   kit_cg_func_end(cg);
   EXPECT(kit_cg_end_unit(cg) == KIT_OK, "no-finish end unit failed");
 
   kit_cg_free(cg);
   EXPECT(kit_obj_builder_finalize(ob) == KIT_OK,
          "no-finish explicit object finalize failed");
   EXPECT(text_size(c, ob) == 0,
          "kit_cg_free must not lower optimized IR into the object");
   kit_obj_builder_free(ob);
 }
 
 int main(void) {
   KitTargetSpec target;
   KitCompiler* c;
   KitCgTypeId void_ty;
   KitCgTypeId i8_ty;
   KitCgTypeId i32_ty;
   KitCgTypeId i64_ty;
   KitCgTypeId f64_ty;
   KitCgTypeId va_list_ty;
   KitCgTypeId ptr_i32;
   KitCgTypeId array_i32;
   KitCgTypeId huge_array_a;
   KitCgTypeId huge_array_b;
   KitCgFuncParam params[2];
   KitCgFuncSig sig;
   KitCgTypeId fn;
   KitCgTypeInfo info;
   KitCgTypeId rec;
   KitCgTypeId rec_ex;
   KitCgTypeId rec_decl;
   KitCgTypeId rec_ptr;
   KitCgTypeId rec_self_ptr;
   KitCgTypeId rec_bad;
   KitCgTypeId enm;
   KitCgRecordDesc rdesc;
   KitCgFieldDesc fields[2];
   const KitCgRecordLayout* rlayout;
   KitCgFieldLayout field_out;
   KitCgEnumValue vals[2];
   uint64_t field_off;
 
   kit_unit_init(&g_u);
   target = kit_unit_target(KIT_ARCH_ARM_64, KIT_OS_LINUX, KIT_OBJ_ELF);
 
   c = NULL;
   if (kit_unit_compiler_new(&g_u, target, &c) != KIT_OK || !c) {
     fprintf(stderr, "compiler_new failed\n");
     return 2;
   }
 
   void_ty = kit_cg_type_builtin(c, KIT_CG_BUILTIN_VOID);
   i8_ty = kit_cg_type_builtin(c, KIT_CG_BUILTIN_I8);
   i32_ty = kit_cg_type_builtin(c, KIT_CG_BUILTIN_I32);
   i64_ty = kit_cg_type_builtin(c, KIT_CG_BUILTIN_I64);
   f64_ty = kit_cg_type_builtin(c, KIT_CG_BUILTIN_F64);
   va_list_ty = kit_cg_type_builtin(c, KIT_CG_BUILTIN_VARARG_STATE);
   EXPECT(void_ty != KIT_CG_TYPE_NONE, "void builtin id is none");
   EXPECT(i8_ty != KIT_CG_TYPE_NONE, "i8 builtin id is none");
   EXPECT(i32_ty != KIT_CG_TYPE_NONE, "i32 builtin id is none");
   EXPECT(f64_ty != KIT_CG_TYPE_NONE, "f64 builtin id is none");
   EXPECT(va_list_ty != KIT_CG_TYPE_NONE, "va_list builtin id is none");
   EXPECT(void_ty != i32_ty && i32_ty != f64_ty, "builtin ids collide");
   EXPECT(void_ty == 1u, "void builtin should be first direct id");
   EXPECT(i8_ty == (KitCgTypeId)KIT_CG_BUILTIN_I8 + 1u,
          "builtin id should be direct enum+1");
   EXPECT(!kit_cg_type_is_void(c, KIT_CG_TYPE_NONE),
          "invalid type id must not masquerade as void");
   EXPECT(kit_cg_type_is_void(c, void_ty), "void builtin predicate failed");
   EXPECT(!kit_cg_type_is_sized(c, void_ty), "void should not be sized");
 
   ptr_i32 = kit_cg_type_ptr(c, i32_ty, 0);
   array_i32 = kit_cg_type_array(c, i32_ty, 4);
   EXPECT(ptr_i32 != KIT_CG_TYPE_NONE, "ptr type failed");
   EXPECT(array_i32 != KIT_CG_TYPE_NONE, "array type failed");
   EXPECT(kit_cg_type_ptr(c, i32_ty, 0) == ptr_i32,
          "ptr type id should be interned");
   EXPECT(kit_cg_type_array(c, i32_ty, 4) == array_i32,
          "array type id should be interned");
   EXPECT(kit_cg_type_ptr(c, KIT_CG_TYPE_NONE, 0) == KIT_CG_TYPE_NONE,
          "invalid pointer pointee should fail");
   EXPECT(kit_cg_type_size(c, ptr_i32) == 8, "ptr size mismatch");
   EXPECT(kit_cg_type_align(c, ptr_i32) == 8, "ptr align mismatch");
   EXPECT(kit_cg_type_ptr_pointee(c, ptr_i32) == i32_ty, "ptr pointee mismatch");
   EXPECT(kit_cg_type_array_elem(c, array_i32) == i32_ty, "array elem mismatch");
   EXPECT(kit_cg_type_array_count(c, array_i32) == 4, "array count mismatch");
   huge_array_a = kit_cg_type_array(c, i32_ty, (uint64_t)UINT32_MAX + 1u);
   huge_array_b = kit_cg_type_array(c, i32_ty, 1);
   EXPECT(huge_array_a == KIT_CG_TYPE_NONE,
          "out-of-range array object should be rejected");
   EXPECT(huge_array_b != KIT_CG_TYPE_NONE,
          "small array after huge rejection should still work");
 
   EXPECT(kit_cg_type_resolve_alias(c, i32_ty) == i32_ty,
          "storage identity should resolve to itself");
   EXPECT(kit_cg_type_info(c, i32_ty, &info) == KIT_OK, "i32 info failed");
   EXPECT(info.kind == KIT_CG_TYPE_INT && info.storage_id == i32_ty &&
              info.layout.valid &&
              info.layout.storage_kind == KIT_CG_STORAGE_INT &&
              info.layout.scalar_width == 32,
          "i32 info identity/layout mismatch");
   EXPECT(kit_cg_type_info(c, ptr_i32, &info) == KIT_OK, "ptr info failed");
   EXPECT(info.kind == KIT_CG_TYPE_PTR && info.storage_id == ptr_i32,
          "ptr info should keep storage identity");
   EXPECT(kit_cg_type_same_storage(c, i32_ty, i32_ty),
          "type should share storage with itself");
   EXPECT(!kit_cg_type_same_storage(c, ptr_i32, i32_ty),
          "unrelated types should not share storage");
 
   memset(fields, 0, sizeof fields);
   fields[0].name = kit_sym_intern(c, KIT_SLICE_LIT("a"));
   fields[0].type = i32_ty;
   fields[0].align_override = 0;
   fields[1].name = kit_sym_intern(c, KIT_SLICE_LIT("b"));
   fields[1].type = ptr_i32;
   fields[1].align_override = 1;
   memset(&rdesc, 0, sizeof rdesc);
   rdesc.tag = kit_sym_intern(c, KIT_SLICE_LIT("R"));
   rdesc.fields = fields;
   rdesc.nfields = 2;
   rec = kit_cg_type_record(c, &rdesc);
   EXPECT(rec != KIT_CG_TYPE_NONE, "record type failed");
   memset(&rdesc, 0, sizeof rdesc);
   rdesc.tag = kit_sym_intern(c, KIT_SLICE_LIT("Bad"));
   EXPECT(kit_cg_type_record(c, &rdesc) != KIT_CG_TYPE_NONE,
          "empty record type failed");
   EXPECT(kit_cg_type_kind(c, rec) == KIT_CG_TYPE_RECORD,
          "record kind mismatch");
   EXPECT(kit_cg_type_record_nfields(c, rec) == 2,
          "record field count mismatch");
   rlayout = kit_cg_type_record_layout(c, rec);
   EXPECT(rlayout && rlayout->nfields > 1, "record field query failed");
   field_out = rlayout->fields[1];
   field_off = field_out.offset;
   EXPECT(field_out.name == fields[1].name && field_out.type == ptr_i32,
          "record field data mismatch");
   EXPECT(field_off == 4, "record field offset mismatch");
 
   memset(fields, 0, sizeof fields);
   fields[0].name = kit_sym_intern(c, KIT_SLICE_LIT("lo"));
   fields[0].type = i32_ty;
   fields[0].flags = KIT_CG_FIELD_BITFIELD;
   fields[0].bit_width = 5;
   fields[1].name = kit_sym_intern(c, KIT_SLICE_LIT("hi"));
   fields[1].type = i32_ty;
   fields[1].flags = KIT_CG_FIELD_BITFIELD;
   fields[1].bit_width = 3;
   memset(&rdesc, 0, sizeof rdesc);
   rdesc.tag = kit_sym_intern(c, KIT_SLICE_LIT("BF"));
   rdesc.fields = fields;
   rdesc.nfields = 2;
   rec_ex = kit_cg_type_record(c, &rdesc);
   EXPECT(rec_ex != KIT_CG_TYPE_NONE, "bit-field record type failed");
   EXPECT(kit_cg_type_size(c, rec_ex) == 4, "bit-field record size mismatch");
   rlayout = kit_cg_type_record_layout(c, rec_ex);
   EXPECT(rlayout && rlayout->nfields > 1, "bit-field record query failed");
   field_out = rlayout->fields[1];
   field_off = field_out.offset;
   EXPECT(field_off == 0 && field_out.bit_offset == 5 &&
              field_out.bit_width == 3 && field_out.bit_storage_size == 4,
          "bit-field metadata mismatch");
 
   memset(fields, 0, sizeof fields);
   fields[0].name = kit_sym_intern(c, KIT_SLICE_LIT("a"));
   fields[0].type = i32_ty;
   fields[1].name = kit_sym_intern(c, KIT_SLICE_LIT("b"));
   fields[1].type = ptr_i32;
   fields[1].align_override = 1;
   memset(&rdesc, 0, sizeof rdesc);
   rdesc.tag = kit_sym_intern(c, KIT_SLICE_LIT("U"));
   rdesc.fields = fields;
   rdesc.nfields = 2;
   rdesc.is_union = 1;
   rdesc.align_override = 16;
   rec_ex = kit_cg_type_record(c, &rdesc);
   EXPECT(rec_ex != KIT_CG_TYPE_NONE, "record desc type failed");
   EXPECT(kit_cg_type_size(c, rec_ex) == 16, "record desc size mismatch");
   EXPECT(kit_cg_type_align(c, rec_ex) == 16, "record desc align mismatch");
   rlayout = kit_cg_type_record_layout(c, rec_ex);
   EXPECT(rlayout && rlayout->nfields > 1, "record desc field query failed");
   field_out = rlayout->fields[1];
   field_off = field_out.offset;
   EXPECT(field_off == 0, "union field offset mismatch");
 
   rec_decl =
       kit_cg_type_record_decl(c, kit_sym_intern(c, KIT_SLICE_LIT("Node")), 0);
   EXPECT(rec_decl != KIT_CG_TYPE_NONE, "record decl failed");
   EXPECT(kit_cg_type_kind(c, rec_decl) == KIT_CG_TYPE_RECORD,
          "record decl kind mismatch");
   EXPECT(!kit_cg_type_is_complete(c, rec_decl),
          "fresh record decl should be incomplete");
   EXPECT(!kit_cg_type_is_sized(c, rec_decl),
          "fresh record decl should be unsized");
   EXPECT(kit_cg_type_record_layout(c, rec_decl) == NULL,
          "incomplete record should not expose fields");
   rec_ptr = kit_cg_type_ptr(c, rec_decl, 0);
   EXPECT(rec_ptr != KIT_CG_TYPE_NONE,
          "pointer to incomplete record should be legal");
   EXPECT(kit_cg_type_array(c, rec_decl, 1) == KIT_CG_TYPE_NONE,
          "array of incomplete record should fail");
   memset(fields, 0, sizeof fields);
   fields[0].name = kit_sym_intern(c, KIT_SLICE_LIT("next"));
   fields[0].type = rec_ptr;
   memset(&rdesc, 0, sizeof rdesc);
   rdesc.tag = kit_cg_type_record_tag(c, rec_decl);
   rdesc.fields = fields;
   rdesc.nfields = 1;
   EXPECT(kit_cg_type_record_complete(c, rec_decl, &rdesc) == KIT_OK,
          "record completion with self pointer failed");
   EXPECT(kit_cg_type_is_complete(c, rec_decl),
          "completed record should be complete");
   EXPECT(kit_cg_type_is_sized(c, rec_decl), "completed record should be sized");
   EXPECT(kit_cg_type_record_complete(c, rec_decl, &rdesc) == KIT_INVALID,
          "record completion should be one-shot");
 
   rec_bad = kit_cg_type_record_decl(
       c, kit_sym_intern(c, KIT_SLICE_LIT("ByValueSelf")), 0);
   memset(fields, 0, sizeof fields);
   fields[0].name = kit_sym_intern(c, KIT_SLICE_LIT("self"));
   fields[0].type = rec_bad;
   memset(&rdesc, 0, sizeof rdesc);
   rdesc.tag = kit_cg_type_record_tag(c, rec_bad);
   rdesc.fields = fields;
   rdesc.nfields = 1;
   EXPECT(kit_cg_type_record_complete(c, rec_bad, &rdesc) == KIT_INVALID,
          "recursive by-value record should fail");
   rec_self_ptr = kit_cg_type_ptr(c, rec_bad, 0);
   EXPECT(rec_self_ptr != KIT_CG_TYPE_NONE,
          "pointer to failed incomplete record should still be legal");
 
   vals[0].name = kit_sym_intern(c, KIT_SLICE_LIT("A"));
   vals[0].value = 1;
   vals[1].name = kit_sym_intern(c, KIT_SLICE_LIT("B"));
   vals[1].value = 2;
   enm = kit_cg_type_enum(c, kit_sym_intern(c, KIT_SLICE_LIT("E")),
                          KIT_CG_TYPE_NONE, vals, 2);
   EXPECT(enm != KIT_CG_TYPE_NONE, "enum type failed");
   /* Enumerators must be preserved so debug info can emit DW_TAG_enumerator
    * children rather than collapsing the enum to a bare integer. */
   EXPECT(kit_cg_type_enum_nvalues(c, enm) == 2,
          "enum should preserve its enumerator count");
   {
     KitCgEnumValue ev;
     EXPECT(kit_cg_type_enum_value(c, enm, 1, &ev) == KIT_OK &&
                ev.name == vals[1].name && ev.value == 2,
            "enum should preserve enumerator name/value pairs");
   }
   /* An enum with an explicit integer underlying type must construct and retain
    * that operational base exactly. Source spellings now travel through the
    * debug type channel rather than wrapper type ids. */
   {
     KitCgTypeId enm_u = kit_cg_type_enum(
         c, kit_sym_intern(c, KIT_SLICE_LIT("EU")), i8_ty, vals, 2);
     EXPECT(enm_u != KIT_CG_TYPE_NONE,
            "enum over an explicit integer underlying type should construct");
     EXPECT(kit_cg_type_enum_base(c, enm_u) == i8_ty,
            "enum should retain its explicit underlying type id");
     EXPECT(kit_cg_type_int_width(c, enm_u) == 8,
            "enum width should follow its explicit underlying type");
   }
 
   memset(params, 0, sizeof(params));
   params[0].type = i32_ty;
   params[1].type = ptr_i32;
   memset(&sig, 0, sizeof(sig));
   KitCgFuncResult sig_result;
   memset(&sig_result, 0, sizeof sig_result);
   sig_result.type = i64_ty;
   sig.result = sig_result;
   sig.params = params;
   sig.nparams = 2;
   sig.abi_variadic = 1;
   sig.call_conv = KIT_CG_CC_TARGET_C;
   fn = kit_cg_type_func(c, sig);
   EXPECT(fn != KIT_CG_TYPE_NONE, "function type failed");
   EXPECT(kit_cg_type_func(c, sig) == fn, "function type id should be interned");
   EXPECT(kit_cg_type_func_result(c, fn).type == i64_ty,
          "function return mismatch");
   EXPECT(kit_cg_type_func_nparams(c, fn) == 2, "function param count mismatch");
   EXPECT(kit_cg_type_func_param(c, fn, 1).type == ptr_i32,
          "function param mismatch");
   memset(&sig, 0, sizeof sig);
   sig.result.type = void_ty;
   fn = kit_cg_type_func(c, sig);
   EXPECT(fn != KIT_CG_TYPE_NONE, "void function type failed");
   EXPECT(kit_cg_type_func_result(c, fn).type == void_ty,
          "void function result should use void builtin");
   EXPECT(!kit_cg_func_result_has_value(c, kit_cg_type_func_result(c, fn)),
          "void function should not have a value result");
   memset(&sig, 0, sizeof sig);
   EXPECT(kit_cg_type_func(c, sig) == KIT_CG_TYPE_NONE,
          "function result NONE should be rejected");
   sig.nparams = 70000;
   EXPECT(kit_cg_type_func(c, sig) == KIT_CG_TYPE_NONE,
          "oversized function param list should fail");
 
   exercise_cg_handles(c, i32_ty, 0);
   exercise_cg_handles(c, i32_ty, 1);
   exercise_cg_scalar_local(c, i32_ty, 0);
   exercise_cg_scalar_local(c, i32_ty, 1);
   exercise_cg_late_local_addr(c, i32_ty, 0);
   exercise_cg_late_local_addr(c, i32_ty, 1);
   exercise_cg_data_entsize(c, i8_ty);
   exercise_cg_debug_global_object(c, i32_ty);
   exercise_cg_literal_folds(c, i32_ty);
   exercise_cg_constfold_phases(c, i32_ty, i8_ty);
   exercise_cg_memop_constfold_shape(c, i32_ty, i64_ty, ptr_i32);
   exercise_cg_slot_lang_facts(c, i32_ty);
   exercise_cg_field_at_store_keep(c, i32_ty, rec);
   exercise_cg_memory_mismatch_diags(c, i32_ty, i64_ty, rec);
   exercise_compile_session_two_deltas(c);
   exercise_cg_begin_end_two_objects(c);
   exercise_cg_free_does_not_finish(c, i32_ty);
 
   kit_compiler_free(c);
   kit_unit_summary(&g_u, "cg_api_test");
   return kit_unit_status(&g_u);
 }