kit

abi.c (7024B)

---

 /* TargetABI dispatch and shared codegen type layout.
  *
  * The single authority for target-dependent storage layout and calling
  * convention decisions. Frontends lower source-language types to CgType
  * before calling into this layer.
  *
  * Per-ABI bits (function classification, __va_list shape) live in
  * abi_aapcs64.c, abi_sysv_x64.c, ... The ABI registry selects the vtable
  * for (target.arch, target.obj). The C-standard-driven scalar profile and
  * record layout stay here so all ABIs share one impl. */
 
 #include "abi/abi.h"
 
 #include <string.h>
 
 #include "abi/abi_internal.h"
 #include "cg/type.h"
 #include "core/arena.h"
 #include "core/core.h"
 
 /* ---- scalar profile ----
  *
  * Shared by all currently supported ABIs (LP64 on Linux for both
  * aarch64 and x86_64). When a Windows-x64 (LLP64) or 32-bit ABI lands,
  * promote prim_info into the vtable. */
 
 ABITypeInfo abi_cg_type_info(TargetABI* a, KitCgTypeId id) {
   ABITypeInfo r = {0, 0, ABI_SC_VOID, 0, 0, 0};
   const CgType* t;
   if (!id) return r;
   t = cg_type_get(a->c, id);
   if (!t) return r;
   switch (t->kind) {
     case KIT_CG_TYPE_ALIAS:
       return abi_cg_type_info(a, t->alias.base);
     case KIT_CG_TYPE_PTR:
       r.size = a->c->target.ptr_size ? a->c->target.ptr_size : 8;
       r.align = a->c->target.ptr_align ? a->c->target.ptr_align : 8;
       r.scalar_kind = ABI_SC_PTR;
       return r;
     case KIT_CG_TYPE_ARRAY: {
       ABITypeInfo e = abi_cg_type_info(a, t->array.elem);
       r.size = e.size * t->array.count;
       r.align = e.align;
       return r;
     }
     case KIT_CG_TYPE_RECORD: {
       const ABIRecordLayout* L = abi_cg_record_layout(a, id);
       if (L) {
         r.size = L->size;
         r.align = L->align;
       }
       return r;
     }
     case KIT_CG_TYPE_ENUM:
       return abi_cg_type_info(a, t->enum_.base);
     case KIT_CG_TYPE_FUNC:
       /* sizeof(function) is undefined in C; use 1 for arithmetic. */
       r.size = 1;
       r.align = 1;
       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;
   }
 }
 
 ABITypeInfo abi_internal_type_info(TargetABI* a, KitCgTypeId id) {
   return abi_cg_type_info(a, id);
 }
 
 u32 abi_cg_sizeof(TargetABI* a, KitCgTypeId id) {
   return abi_cg_type_info(a, id).size;
 }
 u32 abi_cg_alignof(TargetABI* a, KitCgTypeId id) {
   return abi_cg_type_info(a, id).align;
 }
 
 u32 abi_cg_scalar_split_lane_size(TargetABI* a, KitCgTypeId id) {
   if (!a || !a->vt || !a->vt->scalar_split_lane_size) return 0;
   return a->vt->scalar_split_lane_size(a, id);
 }
 
 /* ---- record layout (struct/union) ----
  *
  * The CG type constructor computes the shared source-facing record layout.
  * The ABI cache exposes that immutable layout to codegen passes. When an ABI
  * with different source bit-field rules lands, record construction should be
  * routed through an ABI-specific layout hook before the type is committed. */
 
 static ABIRecordLayout* compute_record_layout(TargetABI* a, KitCgTypeId id) {
   ABIRecordLayout* L = arena_new(a->c->tu, ABIRecordLayout);
   const CgType* t = cg_type_get(a->c, id);
   if (!L) return NULL;
   if (!t || t->kind != KIT_CG_TYPE_RECORD) return NULL;
   memset(L, 0, sizeof *L);
   ABIFieldLayout* fl = NULL;
   if (t->record.nfields) {
     fl = arena_array(a->c->tu, ABIFieldLayout, t->record.nfields);
     memset(fl, 0, sizeof(ABIFieldLayout) * t->record.nfields);
   }
 
   for (u32 i = 0; i < t->record.nfields; ++i) {
     const CgTypeField* f = &t->record.fields[i];
     fl[i].offset = (u32)f->offset;
     fl[i].bit_offset = f->bit_offset;
     fl[i].bit_width = (f->flags & KIT_CG_FIELD_BITFIELD) ? f->bit_width : 0;
     fl[i].storage_size = f->bit_storage_size ? f->bit_storage_size
                                              : (u32)abi_cg_sizeof(a, f->type);
   }
   L->size = (u32)t->size;
   L->align = t->align;
   L->nfields = t->record.nfields;
   L->fields = fl;
   return L;
 }
 
 const ABIRecordLayout* abi_cg_record_layout(TargetABI* a, KitCgTypeId id) {
   const CgType* t = cg_type_get(a->c, id);
   if (!t || t->kind != KIT_CG_TYPE_RECORD) return NULL;
   for (RecordLayoutCacheEntry* e = a->rec_cache; e; e = e->next) {
     if (e->ty == id) return e->layout;
   }
   ABIRecordLayout* L = compute_record_layout(a, id);
   if (!L) return NULL;
   RecordLayoutCacheEntry* e = arena_new(a->c->tu, RecordLayoutCacheEntry);
   e->ty = id;
   e->layout = L;
   e->next = a->rec_cache;
   a->rec_cache = e;
   return L;
 }
 
 /* ---- function classification (vtabled) ---- */
 
 const ABIFuncInfo* abi_cg_func_info(TargetABI* a, KitCgTypeId fn_type) {
   const CgType* fn = cg_type_get(a->c, fn_type);
   if (!fn || fn->kind != KIT_CG_TYPE_FUNC) return NULL;
   for (FuncInfoCacheEntry* e = a->fn_cache; e; e = e->next) {
     if (e->fn == fn_type) return e->info;
   }
   ABIFuncInfo* info = a->vt->compute_func_info(a, fn_type);
   if (!info) return NULL;
   FuncInfoCacheEntry* e = arena_new(a->c->tu, FuncInfoCacheEntry);
   e->fn = fn_type;
   e->info = info;
   e->next = a->fn_cache;
   a->fn_cache = e;
   return info;
 }
 
 u32 abi_stack_probe_interval(TargetABI* a) {
   return a->vt->stack_probe_interval;
 }
 
 ABITypeInfo abi_va_list_info(TargetABI* a) { return a->vt->va_list_info; }
 
 ABIVaListInfo abi_va_list_layout(TargetABI* a) {
   ABIVaListInfo out = a->vt->va_list_layout;
   if (out.kind == ABI_VA_LIST_OPAQUE) {
     out.type = a->vt->va_list_info;
     if (out.type.scalar_kind == ABI_SC_PTR && out.type.size == 8u)
       out.kind = ABI_VA_LIST_POINTER;
   }
   return out;
 }
 
 /* ---- lifecycle ---- */
 
 static const ABIVtable* select_vtable(Compiler* c) {
   const ABIVtable* vt = abi_vtable_lookup(c->target.arch, c->target.obj);
   if (vt) return vt;
   {
     SrcLoc loc = {0, 0, 0};
     compiler_panic(c, loc, "abi_init: unsupported target arch/obj %d/%d",
                    (int)c->target.arch, (int)c->target.obj);
   }
 }
 
 void abi_init(TargetABI* a, Compiler* c) {
   memset(a, 0, sizeof *a);
   a->c = c;
   a->vt = select_vtable(c);
 }
 
 void abi_fini(TargetABI* a) {
   /* Arena-backed; nothing to release. */
   if (!a) return;
   a->fn_cache = NULL;
   a->rec_cache = NULL;
   a->vt = NULL;
   a->c = NULL;
 }
 
 TargetABI* abi_new(Compiler* c) {
   Heap* h = (Heap*)c->ctx->heap;
   TargetABI* a =
       (TargetABI*)h->alloc(h, sizeof(TargetABI), _Alignof(TargetABI));
   if (!a) return NULL;
   abi_init(a, c);
   return a;
 }
 
 void abi_free(TargetABI* a) {
   if (!a) return;
   Heap* h = (Heap*)a->c->ctx->heap;
   abi_fini(a);
   h->free(h, a, sizeof(TargetABI));
 }
 
 Compiler* abi_compiler(TargetABI* a) { return a ? a->c : NULL; }