kit

cg_type_test.c (51040B)

---

 #include <kit/cg.h>
 #include <kit/compile.h>
 #include <kit/core.h>
 #include <kit/frontend.h>
 #include <kit/object.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 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);
 }
 
 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;
   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);
   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");
   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;
   KitCgBuiltinTypes bi;
   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;
   KitCgFuncParam params[2];
   KitCgFuncSig sig;
   KitCgTypeId fn;
   KitCgTypeId alias;
   KitCgTypeId rec;
   KitCgTypeId rec_ex;
   KitCgTypeId enm;
   KitCgRecordDesc rdesc;
   KitCgField fields[2];
   KitCgField 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;
   }
 
   bi = kit_cg_builtin_types(c);
   void_ty = bi.id[KIT_CG_BUILTIN_VOID];
   i8_ty = bi.id[KIT_CG_BUILTIN_I8];
   i32_ty = bi.id[KIT_CG_BUILTIN_I32];
   i64_ty = bi.id[KIT_CG_BUILTIN_I64];
   f64_ty = bi.id[KIT_CG_BUILTIN_F64];
   va_list_ty = bi.id[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");
 
   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");
 
   alias = kit_cg_type_alias(c, kit_sym_intern(c, KIT_SLICE_LIT("I")), i32_ty);
   EXPECT(alias != KIT_CG_TYPE_NONE && alias != i32_ty,
          "alias id should be fresh");
   EXPECT(kit_cg_type_kind(c, alias) == KIT_CG_TYPE_ALIAS,
          "alias kind mismatch");
   EXPECT(kit_cg_type_size(c, alias) == kit_cg_type_size(c, i32_ty),
          "alias size mismatch");
 
   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;
   rec = kit_cg_type_record(c, kit_sym_intern(c, KIT_SLICE_LIT("R")), fields, 2);
   EXPECT(rec != KIT_CG_TYPE_NONE, "record type failed");
   EXPECT(kit_cg_type_record(c, kit_sym_intern(c, KIT_SLICE_LIT("Bad")), fields,
                             0) != 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");
   EXPECT(kit_cg_type_record_field(c, rec, 1, &field_out, &field_off) == 0,
          "record field query failed");
   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;
   rec_ex =
       kit_cg_type_record(c, kit_sym_intern(c, KIT_SLICE_LIT("BF")), fields, 2);
   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");
   EXPECT(kit_cg_type_record_field(c, rec_ex, 1, &field_out, &field_off) == 0,
          "bit-field record query failed");
   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_ex(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");
   EXPECT(kit_cg_type_record_field(c, rec_ex, 1, &field_out, &field_off) == 0,
          "record desc field query failed");
   EXPECT(field_off == 0, "union field offset mismatch");
 
   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");
 
   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");
   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_literal_folds(c, i32_ty);
   exercise_cg_constfold_phases(c, i32_ty, i8_ty);
   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);
 }