kit

c_abi.c (6563B)

---

 #include "abi/c_abi.h"
 
 #include <string.h>
 
 ABITypeInfo c_abi_type_info(KitCompiler* a, const Type* t) {
   KitCgTypeId id = type_cg_id(a, t);
   KitCgTypeKind kind = kit_cg_type_kind(a, id);
   ABITypeInfo r;
   memset(&r, 0, sizeof(r));
   r.size = (u32)kit_cg_type_size(a, id);
   r.align = kit_cg_type_align(a, id);
   switch (kind) {
     case KIT_CG_TYPE_VOID:
       r.scalar_kind = ABI_SC_VOID;
       break;
     case KIT_CG_TYPE_BOOL:
       r.scalar_kind = ABI_SC_BOOL;
       break;
     case KIT_CG_TYPE_INT:
     case KIT_CG_TYPE_ENUM:
       r.scalar_kind = ABI_SC_INT;
       break;
     case KIT_CG_TYPE_FLOAT:
       r.scalar_kind = ABI_SC_FLOAT;
       break;
     case KIT_CG_TYPE_PTR:
       r.scalar_kind = ABI_SC_PTR;
       break;
     default:
       r.scalar_kind = ABI_SC_VOID;
       break;
   }
   r.signed_ = type_is_signed_integer(t);
   return r;
 }
 
 u32 c_abi_sizeof(KitCompiler* a, const Type* t) {
   return c_abi_type_info(a, t).size;
 }
 
 u32 c_abi_alignof(KitCompiler* a, const Type* t) {
   return c_abi_type_info(a, t).align;
 }
 
 const ABIRecordLayout* c_abi_record_layout(KitCompiler* a, Pool* p,
                                            const Type* t) {
   KitCgTypeId id = type_cg_id_in_pool(a, p, t);
   ABIRecordLayout* L;
   ABIFieldLayout* fl = NULL;
   u32 nfields;
   if (kit_cg_type_kind(a, id) != KIT_CG_TYPE_RECORD) return NULL;
   nfields = kit_cg_type_record_nfields(a, id);
   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) {
       KitCgField f;
       uint64_t off = 0;
       memset(&f, 0, sizeof(f));
       if (kit_cg_type_record_field(a, id, i, &f, &off) != 0) return NULL;
       fl[i].offset = (u32)off;
       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)kit_cg_type_size(a, id);
   L->align = kit_cg_type_align(a, id);
   L->nfields = nfields;
   L->fields = fl;
   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));
 }