kit

abi_aapcs64.c (5440B)

---

 /* AAPCS64 (AArch64 SysV) ABI dispatch.
  *
  * v1 covers the cases the cg test harness exercises:
  *   void          -> IGNORE
  *   integer ≤ 8B  -> DIRECT, one INT part in a register
  *   integer 16B   -> DIRECT, two INT parts (X0+X1)
  *   pointer       -> DIRECT, one INT part in a register
  *   float/double  -> DIRECT, one FP part in a register
  *   small struct  -> DIRECT, INT parts (HFA/HVA refinement: TODO)
  *   large struct  -> INDIRECT (sret for return; passed by reference)
  * Variadics, HFA classification, and split GPR+stack tail still
  * land with the parser. */
 
 #include <string.h>
 
 #include "abi/abi_internal.h"
 #include "cg/type.h"
 #include "core/arena.h"
 #include "core/core.h"
 
 static void classify_scalar(TargetABI* a, KitCgTypeId t, ABIArgInfo* out) {
   ABITypeInfo ti = abi_internal_type_info(a, t);
   if (ti.scalar_kind == ABI_SC_INT && ti.size == 16) {
     ABIArgPart* parts = arena_array(a->c->tu, ABIArgPart, 2);
     memset(parts, 0, sizeof(ABIArgPart) * 2);
     for (u32 i = 0; i < 2; ++i) {
       parts[i].cls = ABI_CLASS_INT;
       parts[i].loc = ABI_LOC_REG;
       parts[i].size = 8;
       parts[i].align = 8;
       parts[i].src_offset = i * 8;
     }
     out->kind = ABI_ARG_DIRECT;
     out->flags = ABI_AF_NONE;
     out->parts = parts;
     out->nparts = 2;
     out->indirect_align = 0;
     return;
   }
   out->kind = ABI_ARG_DIRECT;
   out->flags = ABI_AF_NONE;
   out->indirect_align = 0;
 
   ABIArgPart* parts = arena_new(a->c->tu, ABIArgPart);
   memset(parts, 0, sizeof *parts);
   parts->cls = (ti.scalar_kind == ABI_SC_FLOAT) ? ABI_CLASS_FP : ABI_CLASS_INT;
   parts->loc = ABI_LOC_REG;
   parts->size = ti.size;
   parts->align = ti.align;
   parts->src_offset = 0;
 
   out->parts = parts;
   out->nparts = 1;
 }
 
 static void classify_void(ABIArgInfo* out) {
   memset(out, 0, sizeof *out);
   out->kind = ABI_ARG_IGNORE;
 }
 
 static void classify_aggregate(TargetABI* a, KitCgTypeId t, ABIArgInfo* out,
                                int is_return) {
   ABITypeInfo ti = abi_internal_type_info(a, t);
   if (ti.size == 0) {
     classify_void(out);
     return;
   }
   /* AAPCS64: aggregates ≤ 16 bytes pass in up to 2 GPRs (or HFA in FP regs;
    * v1 ignores HFA). Larger aggregates pass by reference (caller copy for
    * args, sret pointer for return). */
   if (ti.size <= 16) {
     u32 nparts = (ti.size + 7) / 8;
     ABIArgPart* parts = arena_array(a->c->tu, ABIArgPart, nparts);
     memset(parts, 0, sizeof(ABIArgPart) * nparts);
     u32 off = 0;
     for (u32 i = 0; i < nparts; ++i) {
       u32 chunk = (ti.size - off > 8) ? 8 : (ti.size - off);
       parts[i].cls = ABI_CLASS_INT;
       parts[i].loc = ABI_LOC_REG;
       parts[i].size = chunk;
       parts[i].align = 8;
       parts[i].src_offset = off;
       off += chunk;
     }
     out->kind = ABI_ARG_DIRECT;
     out->flags = ABI_AF_NONE;
     out->parts = parts;
     out->nparts = (u16)nparts;
     out->indirect_align = 0;
   } else {
     out->kind = ABI_ARG_INDIRECT;
     out->flags = is_return ? ABI_AF_SRET : ABI_AF_BYVAL;
     out->indirect_align = ti.align;
     out->parts = NULL;
     out->nparts = 0;
   }
 }
 
 static void classify_one(TargetABI* a, KitCgTypeId t, ABIArgInfo* out,
                          int is_return) {
   const CgType* ty = cg_type_get(a->c, t);
   if (!ty || ty->kind == KIT_CG_TYPE_VOID) {
     classify_void(out);
     return;
   }
   switch (ty->kind) {
     case KIT_CG_TYPE_RECORD:
       classify_aggregate(a, t, out, is_return);
       return;
     case KIT_CG_TYPE_ALIAS:
       classify_one(a, ty->alias.base, out, is_return);
       return;
     default:
       classify_scalar(a, t, out);
       return;
   }
 }
 
 /* Non-static so apple_arm64_compute_func_info can delegate to it during
  * the Phase 1 alias period — see abi_apple_arm64.c. */
 ABIFuncInfo* aapcs64_compute_func_info(TargetABI* a, KitCgTypeId fn) {
   ABIFuncInfo* info = arena_new(a->c->tu, ABIFuncInfo);
   const CgType* fnty = cg_type_get(a->c, fn);
   memset(info, 0, sizeof *info);
 
   classify_one(a, cg_func_ret_type(fnty), &info->ret, /*is_return=*/1);
   info->has_sret = (info->ret.kind == ABI_ARG_INDIRECT) ? 1 : 0;
   /* AArch64 returns the sret pointer in the dedicated x8 register, so it never
    * consumes an x0..x7 argument slot. (memset above already cleared the field;
    * set explicitly for documentation.) */
   info->sret_consumes_int_arg = 0;
   info->variadic = fnty->func.abi_variadic;
 
   info->nparams = (u16)fnty->func.nparams;
   if (fnty->func.nparams) {
     ABIArgInfo* arr = arena_array(a->c->tu, ABIArgInfo, fnty->func.nparams);
     memset(arr, 0, sizeof(ABIArgInfo) * fnty->func.nparams);
     for (u32 i = 0; i < fnty->func.nparams; ++i) {
       classify_one(a, fnty->func.params[i].type, &arr[i], /*is_return=*/0);
     }
     info->params = arr;
   } else {
     info->params = NULL;
   }
   return info;
 }
 
 const ABIVtable aapcs64_vtable = {
     .compute_func_info = aapcs64_compute_func_info,
     .va_list_info = {32, 8, ABI_SC_VOID, 0, 0, 0},
     .va_list_layout = {.type = {32, 8, ABI_SC_VOID, 0, 0, 0},
                        .kind = ABI_VA_LIST_AAPCS64,
                        .stack_offset = 0,
                        .gr_top_offset = 8,
                        .vr_top_offset = 16,
                        .gr_offs_offset = 24,
                        .vr_offs_offset = 28,
                        .gp_reg_count = 8,
                        .fp_reg_count = 8,
                        .gp_slot_size = 8,
                        .fp_slot_size = 16},
 };