kit

type.c (52900B)

---

 #include "arch/arch.h"
 #include "cg/internal.h"
 #include "core/hashmap.h"
 #include "obj/obj.h"
 
 typedef struct CgApiType {
   /* Public identity view (kit/cg.h). Kept as the FIRST member so a pointer to
    * the entry is a valid `const KitCgTypeInfo*` and kit_cg_type_view can hand
    * it back without a copy. Identity (id/storage_id/kind/flags) is filled once,
    * lazily, by kit_cg_type_view; layout and the COMPLETE/SIZED flags are not
    * maintained here (see the view's contract) — kit_cg_type_info computes
    * those. info.id == 0 marks the entry as not yet filled (a valid id is
    * never 0, and segvec slots are zero-initialized). */
   KitCgTypeInfo info;
   CgType cg;
   /* Lazily-filled packed API_TYPE_CLASS_* memo (0 == not yet computed; the
    * VALID bit distinguishes a computed all-zero class from unfilled). */
   u8 cached_class;
   /* Lazily-filled abi_cg_type_info memo (see api_type_layout_ref/put): `abi`
    * holds the cached size/align/scalar profile, valid iff abi_cached. */
   u8 abi_cached;
   /* Lazily-filled flat predicate descriptor. Extends the cached_class
    * mechanism: pred_bits is a bitset of API_PRED_* computed on the exact
    * operational type, and pred_valid distinguishes a computed all-zero set from
    * unfilled. */
   u8 pred_bits;
   u8 pred_valid;
   ABITypeInfo abi;
   /* This entry's own type id (set by type_alloc). Lets a structural hashset of
    * CgApiType* recover the id without maintaining a reverse index. */
   KitCgTypeId self_id;
 } CgApiType;
 
 /* The flat per-id predicate bitset (API_PRED_*) and api_type_pred_bits live in
  * cg/type.h so multi-predicate-on-same-id call sites can decode an id once. */
 
 /* High bit of CgApiType.cached_class: set once the class has been computed, so
  * a genuine {WK_NARROW, non-aggregate} (packed 0) is told apart from unfilled.
  */
 #define API_TYPE_CLASS_CACHED 0x80u
 
 enum { CG_API_TYPES_SEG_SHIFT = 6 };
 
 SEGVEC_DEFINE(CgApiTypes, CgApiType, CG_API_TYPES_SEG_SHIFT);
 
 /* Structural dedup of derived ptr/array types, O(1) instead of a linear scan of
  * the whole type table on every derivation (which made each derived-type use
  * O(#types) — the dominant frontend hotspot on type-heavy input like sqlite).
  * Pointer keys fit in a u64: ptr = (pointee<<32)|addr_sp. Arrays use the
  * structural hashset below so their full uint64_t count participates in
  * identity. */
 static inline u64 cg_ptr_key(KitCgTypeId pointee, u32 address_space) {
   return ((u64)pointee << 32) | (u64)address_space;
 }
 KIT_HASHMAP_DEFINE(CgPtrMap, u64, KitCgTypeId, hash_u64);
 
 /* Array and function types have structural keys that a scalar hashmap cannot
  * express (array counts are full uint64_t; function keys include attrs), so
  * dedup them through structural hashsets of the stored CgApiType* (SEGVEC
  * entries have stable addresses). The callbacks are defined further down. */
 static u32 cg_array_hash(CgApiType* const e);
 static int cg_array_eq(CgApiType* const a, CgApiType* const b);
 static u32 cg_func_hash(CgApiType* const e);
 static int cg_func_eq(CgApiType* const a, CgApiType* const b);
 KIT_HASHSET_DEFINE(CgArraySet, CgApiType*, cg_array_hash, cg_array_eq);
 KIT_HASHSET_DEFINE(CgFuncSet, CgApiType*, cg_func_hash, cg_func_eq);
 
 typedef struct CgApiState {
   Heap* heap;
   CgApiTypes types;
   /* Structural dedup indexes for derived ptr/array/func types (see above). */
   CgPtrMap ptr_index;
   CgArraySet array_index;
   CgFuncSet func_index;
   CgType builtins[KIT_CG_BUILTIN_COUNT];
   /* Per-builtin identity view returned by kit_cg_type_view: builtins are stored
    * as bare CgType (no CgApiType entry to point at), so their stable
    * KitCgTypeInfo backing lives here, precomputed at init. */
   KitCgTypeInfo builtin_info[KIT_CG_BUILTIN_COUNT];
   /* Packed API_TYPE_CLASS_* per builtin, precomputed at init so the hottest
    * operand types (i32/i64/f64/ptr/...) classify with a single indexed load. */
   u8 builtin_class[KIT_CG_BUILTIN_COUNT];
   /* Packed API_PRED_* bitset per builtin, precomputed at init so the (very hot)
    * cg_type_is_* predicate queries on the most-frequent operand types resolve
    * with a single indexed load instead of a cg_type_get + per-kind re-classify
    * on every call. Builtins are never aliases, so the bitset is exact. */
   u8 builtin_pred[KIT_CG_BUILTIN_COUNT];
   /* Per-builtin ABI layout, precomputed at init so abi_cg_type_info can hit the
    * same memo path for builtin scalars as it does for user types. */
   ABITypeInfo builtin_layout[KIT_CG_BUILTIN_COUNT];
   u8 builtins_init;
   u8 pad[3];
 } CgApiState;
 
 KitCgTypeId builtin_id(KitCgBuiltinType t) {
   if ((u32)t >= KIT_CG_BUILTIN_COUNT) return KIT_CG_TYPE_NONE;
   return (KitCgTypeId)((u32)t + 1u);
 }
 
 static int decode_user_id(KitCgTypeId id, u32* index_out) {
   if (!index_out) return 0;
   if (id <= KIT_CG_BUILTIN_COUNT) return 0;
   *index_out = id - (KitCgTypeId)KIT_CG_BUILTIN_COUNT - 1u;
   return 1;
 }
 
 static KitCgTypeId user_id_from_index(u32 index) {
   if (index > UINT32_MAX - (u32)KIT_CG_BUILTIN_COUNT - 1u)
     return KIT_CG_TYPE_NONE;
   return (KitCgTypeId)((u32)KIT_CG_BUILTIN_COUNT + 1u + index);
 }
 
 static u64 cg_align_to(u64 n, u32 align) {
   u64 a = align ? (u64)align : 1u;
   return ((n + a - 1u) / a) * a;
 }
 
 static void builtin_cg_type_init(Compiler* c, CgType* out, KitCgBuiltinType t) {
   memset(out, 0, sizeof(*out));
   switch (t) {
     case KIT_CG_BUILTIN_VOID:
       out->kind = KIT_CG_TYPE_VOID;
       out->align = 1;
       break;
     case KIT_CG_BUILTIN_BOOL:
       out->kind = KIT_CG_TYPE_BOOL;
       out->size = 1;
       out->align = 1;
       out->integer.width = 8;
       break;
     case KIT_CG_BUILTIN_I8:
       out->kind = KIT_CG_TYPE_INT;
       out->size = 1;
       out->align = 1;
       out->integer.width = 8;
       break;
     case KIT_CG_BUILTIN_I16:
       out->kind = KIT_CG_TYPE_INT;
       out->size = 2;
       out->align = 2;
       out->integer.width = 16;
       break;
     case KIT_CG_BUILTIN_I32:
       out->kind = KIT_CG_TYPE_INT;
       out->size = 4;
       out->align = 4;
       out->integer.width = 32;
       break;
     case KIT_CG_BUILTIN_I64:
       out->kind = KIT_CG_TYPE_INT;
       out->size = 8;
       out->align = 8;
       out->integer.width = 64;
       break;
     case KIT_CG_BUILTIN_I128:
       out->kind = KIT_CG_TYPE_INT;
       out->size = 16;
       out->align = 16;
       out->integer.width = 128;
       break;
     case KIT_CG_BUILTIN_F32:
       out->kind = KIT_CG_TYPE_FLOAT;
       out->size = 4;
       out->align = 4;
       out->fp.width = 32;
       break;
     case KIT_CG_BUILTIN_F64:
       out->kind = KIT_CG_TYPE_FLOAT;
       out->size = 8;
       out->align = 8;
       out->fp.width = 64;
       break;
     case KIT_CG_BUILTIN_F128:
       out->kind = KIT_CG_TYPE_FLOAT;
       out->size = 16;
       out->align = 16;
       out->fp.width = 128;
       break;
     case KIT_CG_BUILTIN_VARARG_STATE: {
       ABITypeInfo info = abi_va_list_info(c->abi);
       out->kind = KIT_CG_TYPE_VARARG_STATE;
       out->size = info.size;
       out->align = info.align ? info.align : 1;
       break;
     }
     case KIT_CG_BUILTIN_COUNT:
       break;
   }
 }
 
 static CgApiState* cg_api_get(Compiler* c);
 static CgApiType* api_type_from_id(Compiler* c, KitCgTypeId id);
 static u8 api_pred_bits_for_kind(const CgType* ty);
 
 static ABITypeInfo api_builtin_layout_info(Compiler* c, const CgType* t) {
   ABITypeInfo r = {0, 0, ABI_SC_VOID, 0, 0, 0};
   if (!t) return r;
   switch (t->kind) {
     case KIT_CG_TYPE_PTR:
       r.size = c->target.ptr_size ? c->target.ptr_size : 8;
       r.align = c->target.ptr_align ? c->target.ptr_align : 8;
       r.scalar_kind = ABI_SC_PTR;
       return r;
     case KIT_CG_TYPE_VOID:
       r.align = 1;
       r.scalar_kind = ABI_SC_VOID;
       return r;
     case KIT_CG_TYPE_BOOL:
       r.size = t->size;
       r.align = t->align;
       r.scalar_kind = ABI_SC_BOOL;
       return r;
     case KIT_CG_TYPE_INT:
       r.size = t->size;
       r.align = t->align;
       r.scalar_kind = ABI_SC_INT;
       return r;
     case KIT_CG_TYPE_FLOAT:
       r.size = t->size;
       r.align = t->align;
       r.scalar_kind = ABI_SC_FLOAT;
       return r;
     case KIT_CG_TYPE_VARARG_STATE:
       r.size = t->size;
       r.align = t->align;
       return r;
     default:
       return r;
   }
 }
 
 /* ---- codegen scalar type-property predicates ----
  * Thin queries over the resolved CgType / target ABI; pure functions of
  * (type, target). The wide-class predicates below feed api_wide_kind_for, which
  * feeds the memoized api_type_class. */
 
 int api_type_is_float(Compiler* c, KitCgTypeId ty) {
   const CgType* cg;
   cg = cg_type_get(c, ty);
   return cg && cg->kind == KIT_CG_TYPE_FLOAT;
 }
 
 int api_is_f128_type(Compiler* c, KitCgTypeId ty) {
   const CgType* cg;
   cg = cg_type_get(c, ty);
   return cg && cg->kind == KIT_CG_TYPE_FLOAT && cg->fp.width == 128;
 }
 
 int api_is_i128_type(Compiler* c, KitCgTypeId ty) {
   const CgType* cg;
   cg = cg_type_get(c, ty);
   return cg && cg->kind == KIT_CG_TYPE_INT && cg->integer.width == 128;
 }
 
 int api_is_wide16_scalar_type(Compiler* c, KitCgTypeId ty) {
   return api_is_f128_type(c, ty) || api_is_i128_type(c, ty);
 }
 
 /* 8-byte scalar split into two 4-byte lanes by the selected ABI. This covers
  * 32-bit native ABIs whose generic CG path cannot keep the value in a single
  * scalar register/value. Such values are forced memory-resident so operations
  * can be legalized as lane sequences or runtime calls. */
 int api_is_wide8_scalar_type(Compiler* c, KitCgTypeId ty) {
   ABITypeInfo ti;
   if (!c || !c->abi || !ty) return 0;
   if (abi_cg_scalar_split_lane_size(c->abi, ty) != 4u) return 0;
   ti = abi_cg_type_info(c->abi, ty);
   return ti.size == 8u &&
          (ti.scalar_kind == ABI_SC_INT || ti.scalar_kind == ABI_SC_FLOAT);
 }
 
 /* Classify a scalar into its mutually-exclusive wide / soft-float dispatch
  * class. Reproduces the predicates exactly: WK_I128/WK_F128 are the 128-bit
  * scalars; WK_WIDE8 is an int-width-bearing split-lane scalar (excluding i128,
  * handled above; a split-lane *float* bears int width 0 and falls through to a
  * soft class); WK_SOFT_DOUBLE/WK_SOFT_SINGLE are f64/f32 with no hardware FP of
  * that width. Only api_compute_type_class calls this. */
 static u8 api_wide_kind_for(Compiler* c, KitCgTypeId ty) {
   u8 fa;
   if (!c || !ty) return WK_NARROW;
   if (api_is_i128_type(c, ty)) return WK_I128;
   if (api_is_f128_type(c, ty)) return WK_F128;
   if (kit_cg_type_int_width((KitCompiler*)c, ty) != 0 &&
       api_is_wide8_scalar_type(c, ty)) {
     return WK_WIDE8;
   }
   fa = c->target.float_abi;
   if ((fa == KIT_FLOAT_ABI_SOFT || fa == KIT_FLOAT_ABI_SINGLE) &&
       kit_cg_type_float_width((KitCompiler*)c, ty) == 64) {
     return WK_SOFT_DOUBLE;
   }
   if (fa == KIT_FLOAT_ABI_SOFT &&
       kit_cg_type_float_width((KitCompiler*)c, ty) == 32) {
     return WK_SOFT_SINGLE;
   }
   return WK_NARROW;
 }
 
 /* Compute the packed API_TYPE_CLASS_* byte for `ty` from scratch: the wide /
  * soft-float dispatch class plus the aggregate-place bit. Both are pure
  * functions of (type, target), so callers memoize the result (per builtin at
  * init, per user type lazily) rather than re-run this on every value push. */
 static u8 api_compute_type_class(Compiler* c, KitCgTypeId ty) {
   u8 cls = api_wide_kind_for(c, ty) & API_TYPE_CLASS_WIDE_MASK;
   if (cg_type_is_aggregate(c, ty)) cls |= API_TYPE_CLASS_AGGREGATE;
   return cls;
 }
 
 static void cg_api_init_builtins(Compiler* c, CgApiState* s) {
   if (s->builtins_init) return;
   for (u32 i = 0; i < KIT_CG_BUILTIN_COUNT; ++i) {
     builtin_cg_type_init(c, &s->builtins[i], (KitCgBuiltinType)i);
   }
   for (u32 i = 0; i < KIT_CG_BUILTIN_COUNT; ++i) {
     s->builtin_layout[i] = api_builtin_layout_info(c, &s->builtins[i]);
   }
   /* Publish the filled table so abi_cg_type_info can index it inline (one load,
    * no cross-TU call) for the common builtin case. NULLed in cg_api_fini. */
   c->cg_builtin_layout = s->builtin_layout;
   /* Precompute each builtin's class now that the builtin table and the ABI are
    * both live (builtin_cg_type_init already consults c->abi for the va_list
    * builtin, so it is ready). */
   for (u32 i = 0; i < KIT_CG_BUILTIN_COUNT; ++i) {
     s->builtin_class[i] =
         api_compute_type_class(c, builtin_id((KitCgBuiltinType)i));
     /* Builtins are never aliases, so the kind-derived predicate bitset is the
      * exact, final value — classify the node once here, then every predicate
      * query is one indexed load (see api_type_pred). */
     s->builtin_pred[i] = api_pred_bits_for_kind(&s->builtins[i]);
     /* Stable identity view for kit_cg_type_view. storage_id == id;
      * layout/complete/sized are left to kit_cg_type_info. */
     s->builtin_info[i].id = builtin_id((KitCgBuiltinType)i);
     s->builtin_info[i].storage_id = s->builtin_info[i].id;
     s->builtin_info[i].kind = s->builtins[i].kind;
     s->builtin_info[i].flags = KIT_CG_TYPEF_BUILTIN;
   }
   s->builtins_init = 1;
 }
 
 u8 api_type_class(Compiler* c, KitCgTypeId ty) {
   CgApiState* s;
   CgApiType* e;
   if (ty == KIT_CG_TYPE_NONE) return 0;
   s = c->cg_api ? (CgApiState*)c->cg_api : cg_api_get(c);
   if (!s) return api_compute_type_class(c, ty);
   if (ty <= KIT_CG_BUILTIN_COUNT) {
     u32 off = ty - 1u;
     if (off < KIT_CG_BUILTIN_COUNT) return s->builtin_class[off];
     return api_compute_type_class(c, ty);
   }
   e = api_type_from_id(c, ty);
   if (!e) return api_compute_type_class(c, ty);
   if (!(e->cached_class & API_TYPE_CLASS_CACHED))
     e->cached_class = API_TYPE_CLASS_CACHED | api_compute_type_class(c, ty);
   return (u8)(e->cached_class & ~API_TYPE_CLASS_CACHED);
 }
 
 const ABITypeInfo* api_type_layout_ref(Compiler* c, KitCgTypeId ty) {
   CgApiState* s;
   CgApiType* e;
   if (!c || ty == KIT_CG_TYPE_NONE) return NULL;
   if (ty <= KIT_CG_BUILTIN_COUNT) {
     s = c->cg_api ? (CgApiState*)c->cg_api : cg_api_get(c);
     return s ? &s->builtin_layout[ty - 1u] : NULL;
   }
   e = api_type_from_id(c, ty);
   return (e && e->abi_cached) ? &e->abi : NULL;
 }
 
 void api_type_layout_put(Compiler* c, KitCgTypeId ty, ABITypeInfo info) {
   CgApiType* e;
   if (!c || ty == KIT_CG_TYPE_NONE) return;
   if (ty <= KIT_CG_BUILTIN_COUNT) return;
   if (!info.align && info.scalar_kind == ABI_SC_VOID) return;
   e = api_type_from_id(c, ty);
   if (!e) return;
   e->abi = info;
   e->abi_cached = 1;
 }
 
 static CgApiState* cg_api_get(Compiler* c) {
   Heap* h;
   CgApiState* s;
   if (!c) return NULL;
   if (c->cg_api) return (CgApiState*)c->cg_api;
   h = (Heap*)c->ctx->heap;
   s = (CgApiState*)h->alloc(h, sizeof(*s), _Alignof(CgApiState));
   if (!s) return NULL;
   memset(s, 0, sizeof(*s));
   s->heap = h;
   CgApiTypes_init(&s->types, h);
   CgPtrMap_init(&s->ptr_index, h);
   CgArraySet_init(&s->array_index, h);
   CgFuncSet_init(&s->func_index, h);
   c->cg_api = s;
   c->cg_api_free = cg_api_fini;
   cg_api_init_builtins(c, s);
   return s;
 }
 
 const CgType* cg_type_get(Compiler* c, KitCgTypeId id) {
   u32 off;
   CgApiState* s;
   CgApiType* e;
   if (!c || id == KIT_CG_TYPE_NONE) return NULL;
   if (id <= KIT_CG_BUILTIN_COUNT) {
     off = id - 1u;
     /* Fast path: the per-compiler state (with its builtin table) is created
      * on first use and then stays put, so inline the already-initialized case
      * -- the hot per-op type query becomes a load + index instead of a call
      * into cg_api_get. cg_api_get still handles lazy first-time creation. */
     s = c->cg_api ? (CgApiState*)c->cg_api : cg_api_get(c);
     if (!s) return NULL;
     return &s->builtins[off];
   }
   e = api_type_from_id(c, id);
   return e ? &e->cg : NULL;
 }
 
 uint64_t cg_type_size(Compiler* c, KitCgTypeId id) {
   return c && c->abi ? abi_cg_sizeof(c->abi, id) : 0;
 }
 
 uint32_t cg_type_align(Compiler* c, KitCgTypeId id) {
   return c && c->abi ? abi_cg_alignof(c->abi, id) : 0;
 }
 
 /* Predicate bitset of a single (already-unaliased) CgType node. The kind->bit
  * mapping reproduces the legacy cg_type_is_* predicates exactly. */
 static u8 api_pred_bits_for_kind(const CgType* ty) {
   if (!ty) return 0;
   switch (ty->kind) {
     case KIT_CG_TYPE_INT:
     case KIT_CG_TYPE_BOOL:
     case KIT_CG_TYPE_ENUM:
       return API_PRED_INT;
     case KIT_CG_TYPE_FLOAT:
       return API_PRED_FLOAT;
     case KIT_CG_TYPE_PTR:
       return API_PRED_PTR;
     case KIT_CG_TYPE_VOID:
       return API_PRED_VOID;
     case KIT_CG_TYPE_RECORD:
       return API_PRED_RECORD | API_PRED_AGGREGATE;
     default:
       return 0;
   }
 }
 
 /* Full API_PRED_* bitset for `id` via exactly one decode: builtin fast path (no
  * aliasing, no entry) or a descriptor load off the user-type entry, filled
  * lazily on first miss. Multi-predicate-on-the-same-id call sites read this
  * once and then test the masks locally instead of decoding `id` per predicate.
  */
 u8 api_type_pred_bits(Compiler* c, KitCgTypeId id) {
   CgApiType* e;
   if (id == KIT_CG_TYPE_NONE) return 0;
   if (id <= KIT_CG_BUILTIN_COUNT) {
     /* Builtin predicate bitsets are precomputed at init, so this is one indexed
      * load (no cg_type_get + re-classify). */
     u32 off = id - 1u;
     CgApiState* s = c->cg_api ? (CgApiState*)c->cg_api : cg_api_get(c);
     if (s && off < KIT_CG_BUILTIN_COUNT) return s->builtin_pred[off];
     return api_pred_bits_for_kind(cg_type_get(c, id));
   }
   e = api_type_from_id(c, id);
   if (!e) return 0;
   if (!e->pred_valid) {
     e->pred_bits = api_pred_bits_for_kind(cg_type_get(c, id));
     e->pred_valid = 1;
   }
   return e->pred_bits;
 }
 
 /* One predicate query for `id`: returns (bits & mask) != 0 off the
  * single-decode bitset. Mirrors api_type_class's CACHED-bit memo. */
 static int api_type_pred(Compiler* c, KitCgTypeId id, u8 mask) {
   return (api_type_pred_bits(c, id) & mask) != 0;
 }
 
 int cg_type_is_int(Compiler* c, KitCgTypeId id) {
   return api_type_pred(c, id, API_PRED_INT);
 }
 
 int cg_type_is_float(Compiler* c, KitCgTypeId id) {
   return api_type_pred(c, id, API_PRED_FLOAT);
 }
 
 int cg_type_is_ptr(Compiler* c, KitCgTypeId id) {
   return api_type_pred(c, id, API_PRED_PTR);
 }
 
 int cg_type_is_record(Compiler* c, KitCgTypeId id) {
   return api_type_pred(c, id, API_PRED_RECORD);
 }
 
 int cg_type_is_void(Compiler* c, KitCgTypeId id) {
   return api_type_pred(c, id, API_PRED_VOID);
 }
 
 int cg_type_is_aggregate(Compiler* c, KitCgTypeId id) {
   return api_type_pred(c, id, API_PRED_AGGREGATE);
 }
 
 KitCgTypeId cg_type_ptr_to(Compiler* c, KitCgTypeId pointee) {
   return kit_cg_type_ptr(c, pointee, 0);
 }
 
 KitCgTypeId cg_type_pointee(Compiler* c, KitCgTypeId id) {
   const CgType* ty = cg_type_get(c, id);
   return ty && ty->kind == KIT_CG_TYPE_PTR ? ty->ptr.pointee : KIT_CG_TYPE_NONE;
 }
 
 KitCgTypeId cg_type_func_ret_id(Compiler* c, KitCgTypeId id) {
   const CgType* ty = cg_type_get(c, id);
   if (!ty || ty->kind != KIT_CG_TYPE_FUNC) return KIT_CG_TYPE_NONE;
   return ty->func.result.type;
 }
 
 KitCgTypeId cg_func_ret_type(const CgType* fnty) {
   return fnty->func.result.type;
 }
 
 KitCgTypeId cg_type_func_result_id(Compiler* c, KitCgTypeId id) {
   const CgType* ty = cg_type_get(c, id);
   if (!ty || ty->kind != KIT_CG_TYPE_FUNC) return KIT_CG_TYPE_NONE;
   return ty->func.result.type;
 }
 
 KitCgTypeId cg_type_func_param_id(Compiler* c, KitCgTypeId id, u32 index) {
   const CgType* ty = cg_type_get(c, id);
   if (!ty || ty->kind != KIT_CG_TYPE_FUNC || index >= ty->func.nparams)
     return KIT_CG_TYPE_NONE;
   return ty->func.params[index].type;
 }
 
 static CgApiType* type_alloc(Compiler* c, KitCgTypeId* id_out) {
   CgApiState* s = cg_api_get(c);
   CgApiType* e;
   u32 index;
   if (!s) return NULL;
   e = CgApiTypes_push(&s->types, &index);
   if (!e) return NULL;
   *id_out = user_id_from_index(index);
   if (*id_out == KIT_CG_TYPE_NONE) return NULL;
   e->self_id = *id_out;
   return e;
 }
 
 static KitCgTypeId find_ptr_type_id(Compiler* c, KitCgTypeId pointee,
                                     u32 address_space) {
   CgApiState* s;
   const KitCgTypeId* hit;
   if (!c || !c->cg_api) return KIT_CG_TYPE_NONE;
   s = (CgApiState*)c->cg_api;
   hit = CgPtrMap_get(&s->ptr_index, cg_ptr_key(pointee, address_space));
   return hit ? *hit : KIT_CG_TYPE_NONE;
 }
 
 static KitCgTypeId find_array_type_id(Compiler* c, KitCgTypeId elem,
                                       u64 count) {
   CgApiState* s;
   CgApiType probe;
   CgApiType* hit;
   if (!c || !c->cg_api) return KIT_CG_TYPE_NONE;
   s = (CgApiState*)c->cg_api;
   memset(&probe, 0, sizeof probe);
   probe.cg.kind = KIT_CG_TYPE_ARRAY;
   probe.cg.array.elem = elem;
   probe.cg.array.count = count;
   hit = CgArraySet_find(&s->array_index, &probe);
   return hit ? hit->self_id : KIT_CG_TYPE_NONE;
 }
 
 static int cg_params_eq(const KitCgFuncParam* a, const KitCgFuncParam* b,
                         u32 n) {
   for (u32 i = 0; i < n; ++i)
     if (a[i].type != b[i].type ||
         memcmp(&a[i].attrs, &b[i].attrs, sizeof(a[i].attrs)) != 0) {
       return 0;
     }
   return 1;
 }
 
 static int cg_result_eq(const KitCgFuncResult* a, const KitCgFuncResult* b) {
   return a->type == b->type &&
          memcmp(&a->attrs, &b->attrs, sizeof(a->attrs)) == 0;
 }
 
 static u32 cg_array_hash(CgApiType* const e) {
   u32 h = hash_u32((u32)e->cg.array.elem);
   h ^= hash_u64(e->cg.array.count) + 0x9e3779b9u + (h << 6) + (h >> 2);
   return h;
 }
 
 static int cg_array_eq(CgApiType* const a, CgApiType* const b) {
   return a->cg.array.elem == b->cg.array.elem &&
          a->cg.array.count == b->cg.array.count;
 }
 
 /* Structural hash/eq over a function type's identity — the same fields the old
  * linear scan compared. Only function types enter this set, so neither callback
  * needs to re-check kind. The result/param attrs are compared (not hashed):
  * fewer hash inputs just means eq resolves the (rare) collision. */
 static u32 cg_func_hash(CgApiType* const e) {
   u32 h = 2166136261u;
   h = (h ^ (u32)e->cg.func.nparams) * 16777619u;
   h = (h ^ (u32)e->cg.func.abi_variadic) * 16777619u;
   h = (h ^ (u32)e->cg.func.call_conv) * 16777619u;
   h = (h ^ (u32)e->cg.func.result.type) * 16777619u;
   for (u32 i = 0; i < e->cg.func.nparams; ++i)
     h = (h ^ (u32)e->cg.func.params[i].type) * 16777619u;
   return h;
 }
 
 static int cg_func_eq(CgApiType* const a, CgApiType* const b) {
   if (a->cg.func.nparams != b->cg.func.nparams) return 0;
   if (a->cg.func.abi_variadic != b->cg.func.abi_variadic) return 0;
   if (a->cg.func.call_conv != b->cg.func.call_conv) return 0;
   if (!cg_result_eq(&a->cg.func.result, &b->cg.func.result)) return 0;
   if (a->cg.func.nparams &&
       !cg_params_eq(a->cg.func.params, b->cg.func.params, a->cg.func.nparams)) {
     return 0;
   }
   return 1;
 }
 
 static KitCgTypeId find_func_type_id(Compiler* c, KitCgFuncSig sig) {
   CgApiState* s;
   CgApiType probe;
   CgApiType* hit;
   if (!c || !c->cg_api) return KIT_CG_TYPE_NONE;
   s = (CgApiState*)c->cg_api;
   memset(&probe, 0, sizeof probe);
   probe.cg.kind = KIT_CG_TYPE_FUNC;
   probe.cg.func.nparams = sig.nparams;
   probe.cg.func.abi_variadic = sig.abi_variadic != 0;
   probe.cg.func.call_conv = sig.call_conv;
   probe.cg.func.result = sig.result;
   probe.cg.func.params = sig.params;
   hit = CgFuncSet_find(&s->func_index, &probe);
   return hit ? hit->self_id : KIT_CG_TYPE_NONE;
 }
 
 static CgApiType* api_type_from_id(Compiler* c, KitCgTypeId id) {
   u32 index;
   CgApiState* s;
   CgApiType* e;
   if (!c || id == KIT_CG_TYPE_NONE) return NULL;
   if (!decode_user_id(id, &index)) return NULL;
   s = (CgApiState*)c->cg_api;
   if (!s) return NULL;
   e = CgApiTypes_at(&s->types, index);
   return e;
 }
 
 KitCgTypeId resolve_type(Compiler* c, KitCgTypeId id) {
   if (!c || id == KIT_CG_TYPE_NONE) return KIT_CG_TYPE_NONE;
   if (id <= KIT_CG_BUILTIN_COUNT) return id;
   return api_type_from_id(c, id) ? id : KIT_CG_TYPE_NONE;
 }
 
 /* Fill an entry's identity prefix (the kit/cg.h KitCgTypeInfo) once. Identity
  * is immutable after creation, so this runs at most once per entry
  * (info.id != 0 thereafter). */
 static void api_type_info_fill(Compiler* c, CgApiType* e, KitCgTypeId id) {
   (void)c;
   e->info.id = id;
   e->info.kind = e->cg.kind;
   if (e->cg.kind == KIT_CG_TYPE_RECORD || e->cg.kind == KIT_CG_TYPE_ENUM)
     e->info.flags = KIT_CG_TYPEF_NOMINAL;
   e->info.storage_id = id;
 }
 
 /* The CgApiType for a user id with its identity prefix filled, or NULL. */
 static CgApiType* api_type_entry_filled(Compiler* c, KitCgTypeId id) {
   CgApiType* e = api_type_from_id(c, id);
   if (!e) return NULL;
   if (e->info.id == 0) api_type_info_fill(c, e, id);
   return e;
 }
 
 static KitCgFuncParam* copy_cg_params(Compiler* c, const KitCgFuncParam* src,
                                       u32 n) {
   KitCgFuncParam* dst;
   if (!n) return NULL;
   if (!src) return NULL;
   dst = arena_array(&c->global->arena, KitCgFuncParam, n);
   if (!dst) return NULL;
   memcpy(dst, src, sizeof(*dst) * n);
   return dst;
 }
 
 static CgTypeField* copy_cg_fields(Compiler* c, const KitCgFieldDesc* src,
                                    u32 n) {
   CgTypeField* dst;
   if (!n) return NULL;
   if (!src) return NULL;
   dst = arena_array(&c->global->arena, CgTypeField, n);
   if (!dst) return NULL;
   memset(dst, 0, sizeof(*dst) * n);
   for (u32 i = 0; i < n; ++i) {
     dst[i].name = src[i].name;
     dst[i].type = src[i].type;
     dst[i].align_override = src[i].align_override;
     dst[i].max_align = src[i].max_align;
     dst[i].flags = src[i].flags;
     dst[i].bit_width = src[i].bit_width;
     dst[i].bit_signed = src[i].bit_signed != 0;
   }
   return dst;
 }
 
 static int cg_type_record_complete(const CgType* ty) {
   return ty && ty->kind == KIT_CG_TYPE_RECORD &&
          (ty->record.flags & CG_TYPE_RECORD_COMPLETE) != 0;
 }
 
 static int cg_type_complete_id(Compiler* c, KitCgTypeId id) {
   const CgType* ty = cg_type_get(c, id);
   if (!ty) return 0;
   switch (ty->kind) {
     case KIT_CG_TYPE_ARRAY:
       return cg_type_complete_id(c, ty->array.elem);
     case KIT_CG_TYPE_RECORD:
       return cg_type_record_complete(ty);
     default:
       return 1;
   }
 }
 
 static int cg_type_sized_id(Compiler* c, KitCgTypeId id) {
   ABITypeInfo ti;
   const CgType* ty;
   ty = cg_type_get(c, id);
   if (!ty) return 0;
   switch (ty->kind) {
     case KIT_CG_TYPE_VOID:
       return 0;
     case KIT_CG_TYPE_FUNC:
       return 0;
     case KIT_CG_TYPE_RECORD:
       if (!cg_type_record_complete(ty)) return 0;
       break;
     case KIT_CG_TYPE_ARRAY:
       if (!cg_type_sized_id(c, ty->array.elem)) return 0;
       break;
     default:
       break;
   }
   ti = abi_cg_type_info(c->abi, id);
   return ti.align != 0;
 }
 
 static int cg_type_valid_by_value(Compiler* c, KitCgTypeId id) {
   const CgType* ty = cg_type_get(c, id);
   if (!ty) return 0;
   if (ty->kind == KIT_CG_TYPE_VOID || ty->kind == KIT_CG_TYPE_FUNC) return 0;
   return cg_type_sized_id(c, id);
 }
 
 static int cg_type_contains_by_value(Compiler* c, KitCgTypeId id,
                                      KitCgTypeId needle) {
   const CgType* ty;
   if (!id) return 0;
   if (id == needle) return 1;
   ty = cg_type_get(c, id);
   if (!ty) return 0;
   switch (ty->kind) {
     case KIT_CG_TYPE_ARRAY:
       return cg_type_contains_by_value(c, ty->array.elem, needle);
     case KIT_CG_TYPE_RECORD:
       if (!cg_type_record_complete(ty)) return 0;
       for (u32 i = 0; i < ty->record.nfields; ++i) {
         if (cg_type_contains_by_value(c, ty->record.fields[i].type, needle))
           return 1;
       }
       return 0;
     default:
       return 0;
   }
 }
 
 static int cg_type_layout_record(Compiler* c, CgType* cg) {
   u32 max_align = 1;
   u64 size = 0;
   if (!c || !cg || cg->kind != KIT_CG_TYPE_RECORD) return 0;
   if (cg->record.nfields && !cg->record.fields) return 0;
   if (cg->record.is_union) {
     for (u32 i = 0; i < cg->record.nfields; ++i) {
       CgTypeField* f = &cg->record.fields[i];
       u64 fsize = cg_type_size(c, f->type);
       u32 falign = cg_type_align(c, f->type);
       if (!falign) return 0;
       if (f->max_align && falign > f->max_align) falign = f->max_align;
       if (f->align_override == 1u) {
         falign = 1;
       } else if (f->align_override > falign) {
         falign = f->align_override;
       }
       if (falign > max_align) max_align = falign;
       if ((f->flags & KIT_CG_FIELD_BITFIELD) != 0) {
         f->offset = 0;
         f->bit_offset = 0;
         f->bit_storage_size = (u32)fsize;
         if (f->bit_width == 0) continue;
       }
       if (fsize > size) size = fsize;
       f->offset = 0;
     }
   } else {
     u64 off = 0;
     int active_bitfield_unit = 0;
     u64 unit_off = 0;
     u32 unit_bits = 0;
     u32 unit_size = 0;
     u32 next_bit = 0;
     for (u32 i = 0; i < cg->record.nfields; ++i) {
       CgTypeField* f = &cg->record.fields[i];
       u64 fsize = cg_type_size(c, f->type);
       u32 falign = cg_type_align(c, f->type);
       if (!falign) return 0;
       if (f->max_align && falign > f->max_align) falign = f->max_align;
       if (f->align_override == 1u) {
         falign = 1;
       } else if (f->align_override > falign) {
         falign = f->align_override;
       }
       if (falign > max_align) max_align = falign;
       if ((f->flags & KIT_CG_FIELD_BITFIELD) != 0) {
         if (fsize > UINT32_MAX / 8u) return 0;
         if (f->bit_width == 0) {
           if (active_bitfield_unit) off = unit_off + unit_size;
           off = cg_align_to(off, falign);
           f->offset = off;
           f->bit_offset = 0;
           f->bit_storage_size = (u32)fsize;
           active_bitfield_unit = 0;
           next_bit = 0;
           continue;
         }
         if (f->bit_width > fsize * 8u) return 0;
         if (!active_bitfield_unit || unit_size != (u32)fsize ||
             next_bit + f->bit_width > unit_bits) {
           if (active_bitfield_unit) off = unit_off + unit_size;
           off = cg_align_to(off, falign);
           unit_off = off;
           unit_size = (u32)fsize;
           unit_bits = unit_size * 8u;
           next_bit = 0;
           active_bitfield_unit = 1;
         }
         f->offset = unit_off;
         f->bit_offset = (u16)next_bit;
         f->bit_storage_size = unit_size;
         next_bit += f->bit_width;
         off = unit_off + unit_size;
         continue;
       }
       active_bitfield_unit = 0;
       off = cg_align_to(off, falign);
       f->offset = off;
       off += fsize;
     }
     size = off;
   }
   if (cg->record.align_override > max_align) {
     max_align = cg->record.align_override;
   }
   cg->align = max_align;
   cg->size = cg_align_to(size, max_align);
   return 1;
 }
 
 static int cg_type_set_ptr(Compiler* c, CgApiType* e, KitCgTypeId pointee,
                            u32 address_space) {
   u32 ptr_size;
   u32 ptr_align;
   if (!cg_type_get(c, pointee)) return 0;
   memset(&e->cg, 0, sizeof(e->cg));
   ptr_size = c->target.ptr_size ? c->target.ptr_size : 8;
   ptr_align = c->target.ptr_align ? c->target.ptr_align : ptr_size;
   e->cg.kind = KIT_CG_TYPE_PTR;
   e->cg.size = ptr_size;
   e->cg.align = ptr_align;
   e->cg.ptr.pointee = pointee;
   e->cg.ptr.address_space = address_space;
   return 1;
 }
 
 static int cg_type_set_array(Compiler* c, CgApiType* e, KitCgTypeId elem,
                              u64 count) {
   ABITypeInfo ety;
   if (!cg_type_sized_id(c, elem)) return 0;
   ety = abi_cg_type_info(c->abi, elem);
   if (ety.size && count > UINT32_MAX / ety.size) return 0;
   memset(&e->cg, 0, sizeof(e->cg));
   e->cg.kind = KIT_CG_TYPE_ARRAY;
   e->cg.size = (u64)ety.size * count;
   e->cg.align = ety.align;
   e->cg.array.elem = elem;
   e->cg.array.count = count;
   return 1;
 }
 
 static int cg_type_set_record(Compiler* c, CgApiType* e, KitSym tag,
                               const KitCgFieldDesc* fields, u32 nfields,
                               int is_union, u32 align_override, u32 flags) {
   CgTypeField* copied = copy_cg_fields(c, fields, nfields);
   if (nfields && !copied) return 0;
   memset(&e->cg, 0, sizeof(e->cg));
   e->cg.kind = KIT_CG_TYPE_RECORD;
   e->cg.record.tag = tag;
   e->cg.record.fields = copied;
   e->cg.record.nfields = nfields;
   e->cg.record.is_union = is_union != 0;
   e->cg.record.align_override = align_override;
   e->cg.record.flags = flags;
   return cg_type_layout_record(c, &e->cg);
 }
 
 static int cg_type_set_enum(Compiler* c, CgApiType* e, KitSym tag,
                             KitCgTypeId base, KitCgEnumValue* values,
                             u32 nvalues) {
   const CgType* sty;
   ABITypeInfo ti;
   if (base == KIT_CG_TYPE_NONE) base = builtin_id(KIT_CG_BUILTIN_I32);
   sty = cg_type_get(c, base);
   if (!sty ||
       !(sty->kind == KIT_CG_TYPE_INT || sty->kind == KIT_CG_TYPE_BOOL)) {
     return 0;
   }
   ti = abi_cg_type_info(c->abi, base);
   memset(&e->cg, 0, sizeof(e->cg));
   e->cg.kind = KIT_CG_TYPE_ENUM;
   e->cg.size = ti.size;
   e->cg.align = ti.align;
   e->cg.enum_.tag = tag;
   e->cg.enum_.base = base;
   e->cg.enum_.values = values;
   e->cg.enum_.nvalues = nvalues;
   return 1;
 }
 
 static int cg_type_set_func(Compiler* c, CgApiType* e, KitCgFuncSig sig,
                             KitCgFuncParam* params) {
   KitCgTypeId void_ty = builtin_id(KIT_CG_BUILTIN_VOID);
   if (!sig.result.type || !cg_type_get(c, sig.result.type)) return 0;
   if (sig.result.type != void_ty && !cg_type_valid_by_value(c, sig.result.type))
     return 0;
   for (u32 i = 0; i < sig.nparams; ++i) {
     if (!cg_type_valid_by_value(c, sig.params[i].type)) return 0;
   }
   memset(&e->cg, 0, sizeof(e->cg));
   e->cg.kind = KIT_CG_TYPE_FUNC;
   e->cg.size = 1;
   e->cg.align = 1;
   e->cg.func.result = sig.result;
   e->cg.func.params = params;
   e->cg.func.nparams = sig.nparams;
   e->cg.func.call_conv = sig.call_conv;
   e->cg.func.abi_variadic = sig.abi_variadic != 0;
   return 1;
 }
 
 KitCgTypeId kit_cg_type_builtin(KitCompiler* c, KitCgBuiltinType which) {
   (void)c;
   if ((u32)which >= KIT_CG_BUILTIN_COUNT) return KIT_CG_TYPE_NONE;
   return builtin_id(which);
 }
 
 KitCgTypeId kit_cg_type_ptr(KitCompiler* c, KitCgTypeId pointee,
                             uint32_t address_space) {
   KitCgTypeId id;
   CgApiType* e;
   if (!cg_type_get(c, pointee)) return KIT_CG_TYPE_NONE;
   id = find_ptr_type_id(c, pointee, address_space);
   if (id != KIT_CG_TYPE_NONE) return id;
   e = type_alloc(c, &id);
   if (!e) return KIT_CG_TYPE_NONE;
   if (!cg_type_set_ptr(c, e, pointee, address_space)) {
     return KIT_CG_TYPE_NONE;
   }
   CgPtrMap_set(&((CgApiState*)c->cg_api)->ptr_index,
                cg_ptr_key(pointee, address_space), id);
   return id;
 }
 
 KitCgTypeId kit_cg_type_array(KitCompiler* c, KitCgTypeId elem,
                               uint64_t count) {
   KitCgTypeId id;
   CgApiType* e;
   if (!cg_type_sized_id(c, elem)) return KIT_CG_TYPE_NONE;
   id = find_array_type_id(c, elem, count);
   if (id != KIT_CG_TYPE_NONE) return id;
   e = type_alloc(c, &id);
   if (!e) return KIT_CG_TYPE_NONE;
   if (!cg_type_set_array(c, e, elem, count)) {
     return KIT_CG_TYPE_NONE;
   }
   CgArraySet_add(&((CgApiState*)c->cg_api)->array_index, e);
   return id;
 }
 
 KitCgTypeId kit_cg_type_record_decl(KitCompiler* c, KitSym tag, int is_union) {
   KitCgTypeId id;
   CgApiType* e;
   if (!c) return KIT_CG_TYPE_NONE;
   e = type_alloc(c, &id);
   if (!e) return KIT_CG_TYPE_NONE;
   memset(&e->cg, 0, sizeof(e->cg));
   e->cg.kind = KIT_CG_TYPE_RECORD;
   e->cg.record.tag = tag;
   e->cg.record.is_union = is_union != 0;
   return id;
 }
 
 KitStatus kit_cg_type_record_complete(KitCompiler* c, KitCgTypeId record,
                                       const KitCgRecordDesc* desc) {
   CgApiType* e;
   KitSym tag;
   if (!c || !desc || (desc->nfields && !desc->fields) ||
       desc->nfields > UINT16_MAX) {
     return KIT_INVALID;
   }
   e = api_type_from_id(c, record);
   if (!e || e->cg.kind != KIT_CG_TYPE_RECORD) return KIT_INVALID;
   if (e->cg.record.flags & CG_TYPE_RECORD_COMPLETE) return KIT_INVALID;
   if (e->cg.record.is_union != (desc->is_union != 0)) return KIT_INVALID;
 
   for (u32 i = 0; i < desc->nfields; ++i) {
     KitCgTypeId fty = desc->fields[i].type;
     if (!cg_type_valid_by_value(c, fty)) return KIT_INVALID;
     if (cg_type_contains_by_value(c, fty, record)) return KIT_INVALID;
   }
 
   tag = desc->tag ? desc->tag : e->cg.record.tag;
   if (!cg_type_set_record(c, e, tag, desc->fields, desc->nfields,
                           desc->is_union, desc->align_override,
                           CG_TYPE_RECORD_COMPLETE)) {
     return KIT_INVALID;
   }
   return KIT_OK;
 }
 
 KitCgTypeId kit_cg_type_enum(KitCompiler* c, KitSym tag, KitCgTypeId base,
                              const KitCgEnumValue* values, uint32_t nvalues) {
   KitCgEnumValue* copied = NULL;
   KitCgTypeId id;
   CgApiType* e;
   if (!c || (nvalues && !values)) return KIT_CG_TYPE_NONE;
   if (base == KIT_CG_TYPE_NONE) base = builtin_id(KIT_CG_BUILTIN_I32);
   if (!cg_type_is_int(c, base)) return KIT_CG_TYPE_NONE;
   if (nvalues) {
     copied = arena_array(&c->global->arena, KitCgEnumValue, nvalues);
     if (!copied) return KIT_CG_TYPE_NONE;
     memcpy(copied, values, sizeof(*copied) * nvalues);
   }
   e = type_alloc(c, &id);
   if (!e) return KIT_CG_TYPE_NONE;
   if (!cg_type_set_enum(c, e, tag, base, copied, nvalues)) {
     return KIT_CG_TYPE_NONE;
   }
   return id;
 }
 
 KitCgTypeId kit_cg_type_func(KitCompiler* c, KitCgFuncSig sig) {
   KitCgFuncParam* copied = NULL;
   KitCgTypeId id;
   CgApiType* e;
   if (!c || (sig.nparams && !sig.params) || sig.nparams > UINT16_MAX) {
     return KIT_CG_TYPE_NONE;
   }
   if (!sig.result.type || !cg_type_get(c, sig.result.type))
     return KIT_CG_TYPE_NONE;
   if (sig.result.type != builtin_id(KIT_CG_BUILTIN_VOID) &&
       !cg_type_valid_by_value(c, sig.result.type))
     return KIT_CG_TYPE_NONE;
   for (u32 i = 0; i < sig.nparams; ++i) {
     if (!cg_type_valid_by_value(c, sig.params[i].type)) return KIT_CG_TYPE_NONE;
   }
   id = find_func_type_id(c, sig);
   if (id != KIT_CG_TYPE_NONE) return id;
   if (sig.nparams) {
     copied = copy_cg_params(c, sig.params, sig.nparams);
     if (!copied) return KIT_CG_TYPE_NONE;
   }
   e = type_alloc(c, &id);
   if (!e) return KIT_CG_TYPE_NONE;
   if (!cg_type_set_func(c, e, sig, copied)) {
     return KIT_CG_TYPE_NONE;
   }
   CgFuncSet_add(&((CgApiState*)c->cg_api)->func_index, e);
   return id;
 }
 
 uint64_t kit_cg_type_size(KitCompiler* c, KitCgTypeId id) {
   return cg_type_size(c, id);
 }
 
 uint32_t kit_cg_type_align(KitCompiler* c, KitCgTypeId id) {
   return cg_type_align(c, id);
 }
 
 /* Identity view backing the inline kit_cg_type_{kind,resolve_alias,is_void} and
  * kit_cg_func_result_has_value queries in kit/cg.h. Builtins read the
  * precomputed table; user entries fill their identity prefix once (immutable
  * thereafter: kind and storage identity are stable, NOMINAL is fixed at
  * creation), then hand back the entry's first member. Layout and the
  * COMPLETE/SIZED flags are deliberately left to kit_cg_type_info. */
 const KitCgTypeInfo* kit_cg_type_view(KitCompiler* kc, KitCgTypeId id) {
   Compiler* c = (Compiler*)kc;
   CgApiState* s;
   CgApiType* e;
   if (!c || id == KIT_CG_TYPE_NONE) return NULL;
   s = c->cg_api ? (CgApiState*)c->cg_api : cg_api_get(c);
   if (!s) return NULL;
   if (id <= KIT_CG_BUILTIN_COUNT) return &s->builtin_info[id - 1u];
   e = api_type_entry_filled(c, id);
   return e ? &e->info : NULL;
 }
 
 int kit_cg_type_is_complete(KitCompiler* c, KitCgTypeId id) {
   return cg_type_complete_id(c, id);
 }
 
 int kit_cg_type_is_sized(KitCompiler* c, KitCgTypeId id) {
   return cg_type_sized_id(c, id);
 }
 
 static KitCgStorageKind cg_storage_kind_from_abi(const CgType* ty,
                                                  ABITypeInfo ti) {
   switch ((ABIScalarKind)ti.scalar_kind) {
     case ABI_SC_VOID:
       if (ty &&
           (ty->kind == KIT_CG_TYPE_ARRAY || ty->kind == KIT_CG_TYPE_RECORD))
         return KIT_CG_STORAGE_AGGREGATE;
       return KIT_CG_STORAGE_VOID;
     case ABI_SC_BOOL:
       return KIT_CG_STORAGE_BOOL;
     case ABI_SC_INT:
       return KIT_CG_STORAGE_INT;
     case ABI_SC_FLOAT:
       return KIT_CG_STORAGE_FLOAT;
     case ABI_SC_PTR:
       return KIT_CG_STORAGE_PTR;
   }
   return KIT_CG_STORAGE_VOID;
 }
 
 static uint16_t cg_type_scalar_width(Compiler* c, const CgType* ty) {
   if (!ty) return 0;
   switch (ty->kind) {
     case KIT_CG_TYPE_BOOL:
     case KIT_CG_TYPE_INT:
       return (uint16_t)ty->integer.width;
     case KIT_CG_TYPE_FLOAT:
       return (uint16_t)ty->fp.width;
     case KIT_CG_TYPE_ENUM:
       return (uint16_t)kit_cg_type_int_width((KitCompiler*)c, ty->enum_.base);
     default:
       return 0;
   }
 }
 
 KitStatus kit_cg_type_info(KitCompiler* kc, KitCgTypeId id,
                            KitCgTypeInfo* out) {
   Compiler* c = (Compiler*)kc;
   const KitCgTypeInfo* v;
   const CgType* storage;
   ABITypeInfo ti;
   if (!out) return KIT_INVALID;
   v = kit_cg_type_view(kc, id);
   if (!v) {
     memset(out, 0, sizeof(*out));
     return KIT_INVALID;
   }
   storage = cg_type_get(c, v->storage_id);
   if (!storage) {
     memset(out, 0, sizeof(*out));
     return KIT_INVALID;
   }
 
   /* Identity (id/storage_id/kind and the BUILTIN/NOMINAL flags) comes straight
    * from the view's interned prefix; only the completion/sizing flags and the
    * ABI layout are computed per call (they are not maintained on the view). */
   *out = *v;
   if (cg_type_complete_id(c, id)) out->flags |= KIT_CG_TYPEF_COMPLETE;
   if (cg_type_sized_id(c, id)) out->flags |= KIT_CG_TYPEF_SIZED;
 
   ti = abi_cg_type_info(c->abi, v->storage_id);
   if (ti.align || storage->kind == KIT_CG_TYPE_VOID) {
     out->layout.size = ti.size;
     out->layout.align = ti.align;
     out->layout.scalar_width = cg_type_scalar_width(c, storage);
     out->layout.storage_kind = (uint8_t)cg_storage_kind_from_abi(storage, ti);
     out->layout.valid = 1;
   }
   return KIT_OK;
 }
 
 static int cg_type_same_storage_rec(Compiler* c, KitCgTypeId a, KitCgTypeId b) {
   const CgType* ta;
   const CgType* tb;
   if (!a || !b) return 0;
   if (a == b) return 1;
   ta = cg_type_get(c, a);
   tb = cg_type_get(c, b);
   if (!ta || !tb) return 0;
   if (ta->kind == KIT_CG_TYPE_ENUM)
     return cg_type_same_storage_rec(c, ta->enum_.base, b);
   if (tb->kind == KIT_CG_TYPE_ENUM)
     return cg_type_same_storage_rec(c, a, tb->enum_.base);
   if (ta->kind != tb->kind) return 0;
   switch (ta->kind) {
     case KIT_CG_TYPE_VOID:
     case KIT_CG_TYPE_BOOL:
     case KIT_CG_TYPE_INT:
     case KIT_CG_TYPE_FLOAT: {
       ABITypeInfo ai = abi_cg_type_info(c->abi, a);
       ABITypeInfo bi = abi_cg_type_info(c->abi, b);
       return ai.scalar_kind == bi.scalar_kind && ai.size == bi.size &&
              ai.align == bi.align;
     }
     case KIT_CG_TYPE_PTR:
       return ta->ptr.address_space == tb->ptr.address_space &&
              cg_type_same_storage_rec(c, ta->ptr.pointee, tb->ptr.pointee);
     case KIT_CG_TYPE_ARRAY:
       return ta->array.count == tb->array.count &&
              cg_type_same_storage_rec(c, ta->array.elem, tb->array.elem);
     case KIT_CG_TYPE_FUNC:
       if (ta->func.nparams != tb->func.nparams ||
           ta->func.call_conv != tb->func.call_conv ||
           ta->func.abi_variadic != tb->func.abi_variadic ||
           memcmp(&ta->func.result.attrs, &tb->func.result.attrs,
                  sizeof(ta->func.result.attrs)) != 0)
         return 0;
       if (!cg_type_same_storage_rec(c, ta->func.result.type,
                                     tb->func.result.type))
         return 0;
       for (u32 i = 0; i < ta->func.nparams; ++i) {
         if (memcmp(&ta->func.params[i].attrs, &tb->func.params[i].attrs,
                    sizeof(ta->func.params[i].attrs)) != 0)
           return 0;
         if (!cg_type_same_storage_rec(c, ta->func.params[i].type,
                                       tb->func.params[i].type))
           return 0;
       }
       return 1;
     case KIT_CG_TYPE_RECORD:
       return 0;
     case KIT_CG_TYPE_ENUM:
       return 0;
     case KIT_CG_TYPE_VARARG_STATE: {
       ABITypeInfo ai = abi_cg_type_info(c->abi, a);
       ABITypeInfo bi = abi_cg_type_info(c->abi, b);
       return ai.size == bi.size && ai.align == bi.align;
     }
   }
   return 0;
 }
 
 int kit_cg_type_same_storage(KitCompiler* c, KitCgTypeId a, KitCgTypeId b) {
   return cg_type_same_storage_rec((Compiler*)c, a, b);
 }
 
 uint32_t kit_cg_type_int_width(KitCompiler* c, KitCgTypeId id) {
   const CgType* ty = cg_type_get(c, id);
   if (!ty) return 0;
   if (ty->kind == KIT_CG_TYPE_INT || ty->kind == KIT_CG_TYPE_BOOL) {
     return ty->integer.width;
   }
   if (ty->kind == KIT_CG_TYPE_ENUM) {
     return kit_cg_type_int_width(c, ty->enum_.base);
   }
   return 0;
 }
 
 uint32_t kit_cg_type_float_width(KitCompiler* c, KitCgTypeId id) {
   const CgType* ty = cg_type_get(c, id);
   if (!ty) return 0;
   if (ty->kind == KIT_CG_TYPE_FLOAT) return ty->fp.width;
   return 0;
 }
 
 KitCgTypeId kit_cg_type_ptr_pointee(KitCompiler* c, KitCgTypeId id) {
   const CgType* ty = cg_type_get(c, id);
   return (ty && ty->kind == KIT_CG_TYPE_PTR) ? ty->ptr.pointee
                                              : KIT_CG_TYPE_NONE;
 }
 
 KitCgTypeId kit_cg_type_array_elem(KitCompiler* c, KitCgTypeId id) {
   const CgType* ty = cg_type_get(c, id);
   return (ty && ty->kind == KIT_CG_TYPE_ARRAY) ? ty->array.elem
                                                : KIT_CG_TYPE_NONE;
 }
 
 uint32_t kit_cg_type_ptr_address_space(KitCompiler* c, KitCgTypeId id) {
   const CgType* ty = cg_type_get(c, id);
   return (ty && ty->kind == KIT_CG_TYPE_PTR) ? ty->ptr.address_space : 0u;
 }
 
 uint64_t kit_cg_type_array_count(KitCompiler* c, KitCgTypeId id) {
   const CgType* ty = cg_type_get(c, id);
   return (ty && ty->kind == KIT_CG_TYPE_ARRAY) ? ty->array.count : 0u;
 }
 
 KitCgFuncResult kit_cg_type_func_result(KitCompiler* c, KitCgTypeId id) {
   const CgType* ty = cg_type_get(c, id);
   KitCgFuncResult empty;
   memset(&empty, 0, sizeof(empty));
   if (!ty || ty->kind != KIT_CG_TYPE_FUNC) return empty;
   return ty->func.result;
 }
 
 uint32_t kit_cg_type_func_nparams(KitCompiler* c, KitCgTypeId id) {
   const CgType* ty = cg_type_get(c, id);
   return (ty && ty->kind == KIT_CG_TYPE_FUNC) ? ty->func.nparams : 0;
 }
 
 KitCgFuncParam kit_cg_type_func_param(KitCompiler* c, KitCgTypeId id,
                                       uint32_t index) {
   const CgType* ty = cg_type_get(c, id);
   KitCgFuncParam empty;
   memset(&empty, 0, sizeof(empty));
   if (!ty || ty->kind != KIT_CG_TYPE_FUNC || index >= ty->func.nparams) {
     return empty;
   }
   return ty->func.params[index];
 }
 
 KitCgCallConv kit_cg_type_func_call_conv(KitCompiler* c, KitCgTypeId id) {
   const CgType* ty = cg_type_get(c, id);
   return (ty && ty->kind == KIT_CG_TYPE_FUNC) ? ty->func.call_conv
                                               : KIT_CG_CC_TARGET_C;
 }
 
 int kit_cg_type_func_is_variadic(KitCompiler* c, KitCgTypeId id) {
   const CgType* ty = cg_type_get(c, id);
   return ty && ty->kind == KIT_CG_TYPE_FUNC && ty->func.abi_variadic;
 }
 
 KitSym kit_cg_type_record_tag(KitCompiler* c, KitCgTypeId id) {
   const CgType* ty = cg_type_get(c, id);
   return (ty && ty->kind == KIT_CG_TYPE_RECORD) ? ty->record.tag : 0;
 }
 
 int kit_cg_type_record_is_union(KitCompiler* c, KitCgTypeId id) {
   const CgType* ty = cg_type_get(c, id);
   return ty && ty->kind == KIT_CG_TYPE_RECORD && ty->record.is_union;
 }
 
 uint32_t kit_cg_type_record_nfields(KitCompiler* c, KitCgTypeId id) {
   const CgType* ty = cg_type_get(c, id);
   return (ty && ty->kind == KIT_CG_TYPE_RECORD && cg_type_record_complete(ty))
              ? ty->record.nfields
              : 0;
 }
 
 const KitCgRecordLayout* kit_cg_type_record_layout(KitCompiler* c,
                                                    KitCgTypeId id) {
   CgApiType* e;
   CgType* ty;
   KitCgRecordLayout* view;
   KitCgFieldLayout* fields;
   u32 n;
   e = api_type_from_id(c, id);
   if (!e || e->cg.kind != KIT_CG_TYPE_RECORD) return NULL;
   ty = &e->cg;
   if (!cg_type_record_complete(ty)) return NULL;
   /* Force/confirm sizing through the same path size/align queries use; an
    * unsized record (e.g. a field that never sized) has no borrowable layout. */
   if (!cg_type_sized_id(c, id)) return NULL;
   if (ty->record.layout_view) return ty->record.layout_view;
 
   n = ty->record.nfields;
   view = arena_new(&c->global->arena, KitCgRecordLayout);
   if (!view) return NULL;
   fields = n ? arena_array(&c->global->arena, KitCgFieldLayout, n) : NULL;
   if (n && !fields) return NULL;
   for (u32 i = 0; i < n; ++i) {
     const CgTypeField* f = &ty->record.fields[i];
     fields[i].name = f->name;
     fields[i].type = f->type;
     fields[i].offset = f->offset;
     fields[i].flags = f->flags;
     fields[i].bit_storage_size = f->bit_storage_size;
     fields[i].bit_offset = f->bit_offset;
     fields[i].bit_width = f->bit_width;
     fields[i].bit_signed = f->bit_signed;
   }
   view->size = ty->size;
   view->align = ty->align;
   view->nfields = n;
   view->fields = fields;
   ty->record.layout_view = view;
   return view;
 }
 
 KitSym kit_cg_type_enum_tag(KitCompiler* c, KitCgTypeId id) {
   const CgType* ty = cg_type_get(c, id);
   return (ty && ty->kind == KIT_CG_TYPE_ENUM) ? ty->enum_.tag : 0;
 }
 
 KitCgTypeId kit_cg_type_enum_base(KitCompiler* c, KitCgTypeId id) {
   const CgType* ty = cg_type_get(c, id);
   return (ty && ty->kind == KIT_CG_TYPE_ENUM) ? ty->enum_.base
                                               : KIT_CG_TYPE_NONE;
 }
 
 uint32_t kit_cg_type_enum_nvalues(KitCompiler* c, KitCgTypeId id) {
   const CgType* ty = cg_type_get(c, id);
   return (ty && ty->kind == KIT_CG_TYPE_ENUM) ? ty->enum_.nvalues : 0;
 }
 
 KitStatus kit_cg_type_enum_value(KitCompiler* c, KitCgTypeId id, uint32_t index,
                                  KitCgEnumValue* out) {
   const CgType* ty = cg_type_get(c, id);
   if (!ty || ty->kind != KIT_CG_TYPE_ENUM || index >= ty->enum_.nvalues)
     return KIT_NOT_FOUND;
   if (out) *out = ty->enum_.values[index];
   return KIT_OK;
 }
 
 int kit_cg_target_supports_call_conv(KitCompiler* c, KitCgCallConv cc) {
   const ArchImpl* a;
   if (!c) return 0;
   /* TARGET_C is always available, including for arches with no codegen backend
    * (x86_32/arm_32, where arch_for_compiler is NULL). */
   if (cc == KIT_CG_CC_TARGET_C) return 1;
   a = arch_for_compiler(c);
   if (!a || !a->supports_call_conv) return 0;
   return a->supports_call_conv(c, cc);
 }
 
 int kit_cg_target_supports_symbol_feature(KitCompiler* c,
                                           KitCgSymbolFeature feat) {
   if (!c) return 0;
   switch (feat) {
     case KIT_CG_SYMFEAT_WEAK:
     case KIT_CG_SYMFEAT_PROTECTED_VISIBILITY:
     case KIT_CG_SYMFEAT_COMDAT:
     case KIT_CG_SYMFEAT_COMMON:
       return 1;
     case KIT_CG_SYMFEAT_TLS_LOCAL_EXEC:
       /* Local-exec is the only TLS model kit emits.  Whether it is actually
        * available still depends on the object format being able to represent a
        * TLS access at all (ELF/Mach-O yes; COFF/Wasm no). */
       return obj_format_supports_symbol_feature(c, (int)feat);
     case KIT_CG_SYMFEAT_TLS_INITIAL_EXEC:
     case KIT_CG_SYMFEAT_TLS_LOCAL_DYNAMIC:
     case KIT_CG_SYMFEAT_TLS_GENERAL_DYNAMIC:
       /* kit has no initial-exec / local-dynamic / general-dynamic codegen and
        * no dynamic-TLS runtime (__tls_get_addr), so it never emits these even
        * where the object format could represent them.  Report the truth so a
        * caller can't request a dynamic model and silently get local-exec; the
        * linker enforces the same contract (see link_require_local_tls). */
       return 0;
     case KIT_CG_SYMFEAT_DLLIMPORT:
     case KIT_CG_SYMFEAT_DLLEXPORT:
     case KIT_CG_SYMFEAT_MERGE_SECTIONS:
     case KIT_CG_SYMFEAT_CONSTRUCTOR_PRIORITY:
       return 0;
   }
   return 0;
 }
 
 KitCgVaListKind kit_cg_target_va_list_kind(const KitCompiler* c) {
   ABIVaListInfo va;
   if (!c) return KIT_CG_VALIST_OPAQUE;
   va = abi_va_list_layout(c->abi);
   switch ((ABIVaListKind)va.kind) {
     case ABI_VA_LIST_OPAQUE:
       return KIT_CG_VALIST_OPAQUE;
     case ABI_VA_LIST_POINTER:
       return KIT_CG_VALIST_POINTER;
     case ABI_VA_LIST_AAPCS64:
       return KIT_CG_VALIST_AAPCS64;
     case ABI_VA_LIST_SYSV_X64:
       return KIT_CG_VALIST_SYSV_X64;
   }
   return KIT_CG_VALIST_OPAQUE;
 }
 
 const char* kit_cg_target_c_label_prefix(const KitCompiler* c) {
   return obj_format_c_label_prefix(c);
 }
 
 int kit_cg_target_supports_intrinsic(KitCompiler* c, KitCgIntrinsic intrin) {
   const ArchImpl* a;
   if (!c) return 0;
   a = arch_for_compiler(c);
   if (!a || !a->supports_intrinsic) return 0;
   return a->supports_intrinsic(c, intrin);
 }
 
 uint64_t kit_cg_target_backend_features(KitCompiler* c) {
   const ArchImpl* a;
   if (!c) return 0;
   a = arch_for_compiler(c);
   /* Arches with no registered codegen backend (x86_32) fall back to the
    * conservative strict-alignment baseline. */
   if (!a) return KIT_CG_BACKEND_STRICT_ALIGNMENT;
   return a->backend_features;
 }
 
 void cg_api_fini(Compiler* c) {
   CgApiState* s;
   if (!c || !c->cg_api) return;
   s = (CgApiState*)c->cg_api;
   CgApiTypes_fini(&s->types);
   CgPtrMap_fini(&s->ptr_index);
   CgArraySet_fini(&s->array_index);
   CgFuncSet_fini(&s->func_index);
   s->heap->free(s->heap, s, sizeof(*s));
   c->cg_api = NULL;
   c->cg_api_free = NULL;
   c->cg_builtin_layout = NULL;
 }
 
 /* ============================================================
  * KitCg: public codegen API implementation
  *
  * Drives CgTarget directly with its own value stack.
  * ============================================================ */