kit

abi_aapcs64_windows.c (3096B)

---

 /* Windows-on-ARM64 ABI dispatch.
  *
  * Vtable selection keys on (target.arch, target.os); (ARM_64, WINDOWS)
  * lands here instead of AAPCS64.  The two ABIs diverge in:
  *
  *   1. va_list shape — Windows-ARM64 `__builtin_va_list` is plain
  *      `void*`; AAPCS64 is a five-field struct.
  *
  *   2. long double — 64-bit double on Windows-ARM64 (AAPCS64: 128-bit).
  *      Assumed lowered by the front end before classification.
  *
  * Variadics still use registers (NOT all-on-stack like Apple ARM64), but
  * FP arguments to variadic functions are routed through integer slots so
  * `va_list` can remain a plain pointer.
  *
  * Classification starts from aapcs64_compute_func_info, then adjusts FP
  * parameter parts for variadic functions. */
 
 #include <string.h>
 
 #include "abi/abi_internal.h"
 #include "core/arena.h"
 #include "core/core.h"
 
 extern ABIFuncInfo* aapcs64_compute_func_info(TargetABI*, KitCgTypeId);
 
 static void remap_fp_parts_to_int(TargetABI* a, ABIArgInfo* ai) {
   if (!ai || ai->kind != ABI_ARG_DIRECT || ai->nparts == 0) return;
   int needs_copy = 0;
   for (u16 i = 0; i < ai->nparts; ++i) {
     if (ai->parts[i].cls == ABI_CLASS_FP) {
       needs_copy = 1;
       break;
     }
   }
   if (!needs_copy) return;
 
   ABIArgPart* parts = arena_array(a->c->tu, ABIArgPart, ai->nparts);
   memcpy(parts, ai->parts, sizeof(ABIArgPart) * ai->nparts);
   for (u16 i = 0; i < ai->nparts; ++i) {
     if (parts[i].cls == ABI_CLASS_FP) parts[i].cls = ABI_CLASS_INT;
   }
   ai->parts = parts;
 }
 
 static ABIFuncInfo* aapcs64_windows_compute_func_info(TargetABI* a,
                                                       KitCgTypeId fn) {
   ABIFuncInfo* info = aapcs64_compute_func_info(a, fn);
   /* vararg_on_stack stays 0 — Windows-ARM64 variadics use registers,
    * unlike Apple.
    *
    * In a variadic function, Windows ARM64 routes floating-point arguments
    * through the integer argument slots. That applies to named FP parameters
    * too; trailing `...` arguments are handled by the call lowering path. */
   if (info && info->variadic) {
     /* Trait the aarch64 backend reads instead of checking target.os; the
      * named FP parameters are remapped here, trailing `...` FP args are
      * handled by the call lowering path off the same flag. */
     info->vararg_fp_via_int = 1;
     for (u16 i = 0; i < info->nparams; ++i) {
       remap_fp_parts_to_int(a, (ABIArgInfo*)&info->params[i]);
     }
   }
   return info;
 }
 
 const ABIVtable aapcs64_windows_vtable = {
     .compute_func_info = aapcs64_windows_compute_func_info,
     /* Windows commits stack one guard page at a time; large frames must be
      * probed page-by-page before the single `sub sp`. See aa_words_stack_probe
      * in src/arch/aa64/native.c. */
     .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,
                        .gp_reg_count = 8,
                        .fp_reg_count = 0,
                        .gp_slot_size = 8,
                        .fp_slot_size = 0},
 };