kit

c_abi.c (7336B)

---

 #include "abi/c_abi.h"
 
 #include <string.h>
 
 /* Size/align of a C type are a pure function of the type + the fixed target.
  * Both ride the per-id api_type_layout memo (and the cg_id cached on the Type
  * node by type_cg_id_in_pool), so a direct kit_cg_type_size/align off the
  * lowered id is already memoized — no second Type*-keyed cache is needed.
  * Record layouts (the O(M accesses x N fields) cost) are still memoized on the
  * Type node by c_abi_record_layout below. */
 static int abi_info_cacheable(const Type* t) {
   /* Incomplete records have no stable layout yet; everything else (scalars,
    * pointers, arrays, functions, enums, complete records) is fixed. */
   return !((t->kind == TY_STRUCT || t->kind == TY_UNION) && t->rec.incomplete);
 }
 
 u32 c_abi_sizeof(KitCompiler* a, Pool* p, const Type* t) {
   return (u32)kit_cg_type_size(a, type_cg_id_in_pool(a, p, t));
 }
 
 u32 c_abi_alignof(KitCompiler* a, Pool* p, const Type* t) {
   return kit_cg_type_align(a, type_cg_id_in_pool(a, p, t));
 }
 
 const ABIRecordLayout* c_abi_record_layout(KitCompiler* a, Pool* p,
                                            const Type* t) {
   KitCgTypeId id;
   const KitCgRecordLayout* view;
   ABIRecordLayout* L;
   ABIFieldLayout* fl = NULL;
   u32 nfields;
   /* Memoized on the Type node (mirrors cg_id). The layout is a pure function of
    * the complete record + the fixed target, so once built it never changes; an
    * incomplete record (no stable layout) is never cached. Collapses the former
    * O(M member-accesses x N fields) rebuild to one build per distinct record.
    */
   if (abi_info_cacheable(t) && t->abi_layout) return t->abi_layout;
   id = type_cg_id_in_pool(a, p, t);
   if (kit_cg_type_kind(a, id) != KIT_CG_TYPE_RECORD) return NULL;
   /* Borrow the CG-owned layout view once; every offset/bit value below is
    * sourced from it instead of N per-field queries. */
   view = kit_cg_type_record_layout(a, id);
   if (!view) return NULL;
   nfields = view->nfields;
   L = arena_znew(p->arena, ABIRecordLayout);
   if (!L) return NULL;
   if (nfields) {
     fl = arena_zarray(p->arena, ABIFieldLayout, nfields);
     if (!fl) return NULL;
     for (u32 i = 0; i < nfields; ++i) {
       const KitCgFieldLayout* f = &view->fields[i];
       fl[i].offset = (u32)f->offset;
       fl[i].storage_size = f->bit_storage_size
                                ? f->bit_storage_size
                                : (u32)kit_cg_type_size(a, f->type);
       if (t->rec.fields[i].flags & FIELD_BITFIELD) {
         fl[i].bit_width = t->rec.fields[i].bitfield_width;
         fl[i].bit_offset = f->bit_offset;
       }
     }
   }
   L->size = (u32)view->size;
   L->align = view->align;
   L->nfields = nfields;
   L->fields = fl;
   /* Cache for subsequent accesses. Only a complete record is cacheable; the
    * RECORD-kind check above already implies the id lowered, but guard anyway so
    * an incomplete record (which can't reach here via a RECORD id) never sticks.
    */
   if (abi_info_cacheable(t)) ((Type*)t)->abi_layout = L;
   return L;
 }
 
 const ABIFuncInfo* c_abi_func_info(KitCompiler* a, Pool* p,
                                    const Type* fn_type) {
   KitCgTypeId id = type_cg_id_in_pool(a, p, fn_type);
   ABIFuncInfo* info;
   uint32_t nparams;
   if (kit_cg_type_kind(a, id) != KIT_CG_TYPE_FUNC) return NULL;
   nparams = kit_cg_type_func_nparams(a, id);
   info = arena_znew(p->arena, ABIFuncInfo);
   if (!info) return NULL;
   info->nparams = (u16)nparams;
   if (nparams) {
     info->params = arena_zarray(p->arena, ABIArgInfo, nparams);
     if (!info->params) return NULL;
   }
   return info;
 }
 
 static const Type* c_size_or_uintptr(KitCompiler* a, Pool* p) {
   KitTargetSpec target = kit_compiler_target_spec(a);
   if (kit_target_uses_lp64(target)) return type_prim(p, TY_ULONG);
   return target.ptr_size == 8 ? type_prim(p, TY_ULLONG) : type_prim(p, TY_UINT);
 }
 
 const Type* c_abi_size_type(KitCompiler* a, Pool* p) {
   return c_size_or_uintptr(a, p);
 }
 
 const Type* c_abi_ptrdiff_type(KitCompiler* a, Pool* p) {
   KitTargetSpec target = kit_compiler_target_spec(a);
   if (kit_target_uses_lp64(target)) return type_prim(p, TY_LONG);
   return target.ptr_size == 8 ? type_prim(p, TY_LLONG) : type_prim(p, TY_INT);
 }
 
 const Type* c_abi_intptr_type(KitCompiler* a, Pool* p) {
   return c_abi_ptrdiff_type(a, p);
 }
 
 const Type* c_abi_uintptr_type(KitCompiler* a, Pool* p) {
   return c_size_or_uintptr(a, p);
 }
 
 const Type* c_abi_va_list_type(KitCompiler* a, Pool* p) {
   /* Key the frontend `__builtin_va_list` spelling on the abstract va_list
    * shape the target ABI reports, not on a re-derived arch/os ladder. The
    * record field definitions are unchanged; only the dispatch is abstract:
    *   SYSV_X64 -> the System V __va_list_tag register-save record;
    *   AAPCS64  -> the AArch64 __va_list register-save record;
    *   POINTER / OPAQUE -> a single pointer that walks the arg area.
    * The old Apple-vs-AAPCS64 arm64 split disappears (Apple is POINTER), as
    * does the x86_64/rv64 split (both follow the abstract kind). */
   switch (kit_cg_target_va_list_kind(a)) {
     case KIT_CG_VALIST_SYSV_X64: {
       const Type* vp = type_ptr(p, type_void(p));
       const Type* uit = type_prim(p, TY_UINT);
       Sym name = kit_sym_intern(p->c, KIT_SLICE_LIT("__va_list_tag"));
       SrcLoc nl = {0, 0, 0};
       TagId tg = type_tag_new(p, TAG_STRUCT, name, nl);
       TypeRecordBuilder* b = type_record_begin(p, TY_STRUCT, tg, name);
       type_record_field(
           b, (Field){.name = kit_sym_intern(p->c, KIT_SLICE_LIT("gp_offset")),
                      .type = uit});
       type_record_field(
           b, (Field){.name = kit_sym_intern(p->c, KIT_SLICE_LIT("fp_offset")),
                      .type = uit});
       type_record_field(
           b, (Field){.name = kit_sym_intern(p->c,
                                             KIT_SLICE_LIT("overflow_arg_area")),
                      .type = vp});
       type_record_field(b, (Field){.name = kit_sym_intern(
                                        p->c, KIT_SLICE_LIT("reg_save_area")),
                                    .type = vp});
       return type_record_end(p, b);
     }
     case KIT_CG_VALIST_AAPCS64: {
       const Type* vp = type_ptr(p, type_void(p));
       const Type* it = type_prim(p, TY_INT);
       Sym name = kit_sym_intern(p->c, KIT_SLICE_LIT("__va_list"));
       SrcLoc nl = {0, 0, 0};
       TagId tg = type_tag_new(p, TAG_STRUCT, name, nl);
       TypeRecordBuilder* b = type_record_begin(p, TY_STRUCT, tg, name);
       type_record_field(
           b, (Field){.name = kit_sym_intern(p->c, KIT_SLICE_LIT("__stack")),
                      .type = vp});
       type_record_field(
           b, (Field){.name = kit_sym_intern(p->c, KIT_SLICE_LIT("__gr_top")),
                      .type = vp});
       type_record_field(
           b, (Field){.name = kit_sym_intern(p->c, KIT_SLICE_LIT("__vr_top")),
                      .type = vp});
       type_record_field(
           b, (Field){.name = kit_sym_intern(p->c, KIT_SLICE_LIT("__gr_offs")),
                      .type = it});
       type_record_field(
           b, (Field){.name = kit_sym_intern(p->c, KIT_SLICE_LIT("__vr_offs")),
                      .type = it});
       return type_record_end(p, b);
     }
     case KIT_CG_VALIST_POINTER:
     case KIT_CG_VALIST_OPAQUE:
       break;
   }
   return type_ptr(p, type_void(p));
 }