kit

abi_win64_x64.c (4910B)

---

 /* 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_scalar(TargetABI* a, KitCgTypeId t, ABIArgInfo* out,
                             int is_return) {
   ABITypeInfo ti = abi_cg_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) {
     abi_classify_int128_pair(a, out);
     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;
   }
 
   abi_classify_scalar_reg_part(a, out, ti, ti.scalar_kind == ABI_SC_FLOAT);
 }
 
 static void classify_aggregate(TargetABI* a, KitCgTypeId t, ABIArgInfo* out,
                                int is_return) {
   ABITypeInfo ti = abi_cg_type_info(a, t);
   if (ti.size == 0) {
     abi_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) {
     abi_classify_void(out);
     return;
   }
   switch (ty->kind) {
     case KIT_CG_TYPE_RECORD:
       classify_aggregate(a, t, out, is_return);
       return;
     default:
       classify_scalar(a, t, out, is_return);
       return;
   }
 }
 
 static ABIFuncInfo* win64_x64_compute_func_info(TargetABI* a, KitCgTypeId fn) {
   /* Win64 passes the sret pointer in rcx (the first integer arg register),
    * consuming that slot, so sret_consumes_int_arg follows has_sret. */
   return abi_compute_func_info_generic(a, fn, classify_one,
                                        /*sret_consumes_int_arg=*/1);
 }
 
 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 = {.kind = ABI_VA_LIST_POINTER},
 };