kit

abi_win64_x64.c (6524B)

---

 /* Win64 (Microsoft x86_64) ABI classifier.
  *
  * Selected when (target.arch == X86_64, target.os == WINDOWS).
  *
  * Win64 vs SysV-x64 deltas:
  *   - Arg slots: RCX/RDX/R8/R9 share index with XMM0..3 (codegen
  *     assigns by index; classifier emits per-slot INT or FP parts).
  *   - Aggregates: pass-by-value only for sizes in {1,2,4,8}; otherwise
  *     hidden-pointer (byval for args, sret for returns).
  *   - __int128: passed as two INTEGER eightbytes (mingw convention;
  *     differs from MSVC spec which says by reference).
  *   - long double: 64-bit double (no x87).
  *   - va_list: void* (single pointer; no struct).
  *   - varargs: still in regs; FP-args duplicated in matching GPR slot
  *     by the call-site codegen (not encoded here).
  *
  * Shadow-space (32 B above return addr) is a call-site reservation,
  * not an ABI classifier concern -- see arch/x64/call.c.
  */
 
 #include <string.h>
 
 #include "abi/abi_internal.h"
 #include "cg/type.h"
 #include "core/arena.h"
 #include "core/core.h"
 
 static void classify_void(ABIArgInfo* out) {
   memset(out, 0, sizeof *out);
   out->kind = ABI_ARG_IGNORE;
 }
 
 static void classify_scalar(TargetABI* a, KitCgTypeId t, ABIArgInfo* out,
                             int is_return) {
   ABITypeInfo ti = abi_internal_type_info(a, t);
   (void)is_return;
   /* __int128 / __uint128: mingw/GCC convention emits two INTEGER
    * eightbytes (rcx+rdx for args, rax+rdx for return) -- same shape
    * as SysV.  MSVC's official spec says "by reference" for 16-byte
    * aggregates, but mingw is kit's interop target on Windows and
    * mingw matches SysV here. */
   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;
   }
   /* long double on Win64 is 64-bit double (both MSVC and mingw, unless
    * mingw's -mlong-double-80 is in effect -- not supported in v1).
    * The front end should already have lowered `long double` to a size-8
    * float for Windows targets.  Defensive path: if a size-16 FP slips
    * through, treat it as a size-8 double (one FP part) -- this stays
    * register-passed, unlike SysV which routes long double through
    * memory. */
   if (ti.scalar_kind == ABI_SC_FLOAT && ti.size == 16) {
     ABIArgPart* parts = arena_new(a->c->tu, ABIArgPart);
     memset(parts, 0, sizeof *parts);
     parts->cls = ABI_CLASS_FP;
     parts->loc = ABI_LOC_REG;
     parts->size = 8;
     parts->align = 8;
     parts->src_offset = 0;
     out->kind = ABI_ARG_DIRECT;
     out->flags = ABI_AF_NONE;
     out->parts = parts;
     out->nparts = 1;
     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_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;
   }
   /* Win64: aggregates pass by value only when the size is exactly one
    * of {1, 2, 4, 8}.  A 3-byte struct is NOT a 3-byte INT part -- it
    * goes by hidden pointer.  A 16-byte struct is also hidden-pointer
    * (no two-register pair, unlike SysV's <=16B path). */
   if (ti.size == 1 || ti.size == 2 || ti.size == 4 || ti.size == 8) {
     ABIArgPart* parts = arena_new(a->c->tu, ABIArgPart);
     memset(parts, 0, sizeof *parts);
     parts->cls = ABI_CLASS_INT;
     parts->loc = ABI_LOC_REG;
     parts->size = ti.size;
     parts->align = ti.align ? ti.align : ti.size;
     parts->src_offset = 0;
     out->kind = ABI_ARG_DIRECT;
     out->flags = ABI_AF_NONE;
     out->parts = parts;
     out->nparts = 1;
     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 ? ti.align : 8;
     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, is_return);
       return;
   }
 }
 
 static ABIFuncInfo* win64_x64_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;
   /* Win64 passes the sret pointer in rcx (the first integer arg register),
    * consuming that slot. */
   info->sret_consumes_int_arg = info->has_sret;
   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 win64_x64_vtable = {
     .compute_func_info = win64_x64_compute_func_info,
     /* Windows commits stack one guard page at a time; the x64 backend gates its
      * __chkstk call on this (frame_size > one page). See x64_build_prologue. */
     .stack_probe_interval = 4096,
     .va_list_info = {8, 8, ABI_SC_PTR, 0, 0, 0},
     .va_list_layout = {.type = {8, 8, ABI_SC_PTR, 0, 0, 0},
                        .kind = ABI_VA_LIST_POINTER},
 };