kit

abi.c (4876B)

---

 /* wasm32 BasicCABI classifier.
  *
  * Reference:
  * https://github.com/WebAssembly/tool-conventions/blob/main/BasicCABI.md
  *
  * Coverage for v1:
  *   void          -> IGNORE
  *   scalar ≤ 8B   -> DIRECT, one part (i32/i64/f32/f64 per scalar kind)
  *   pointer       -> DIRECT, one INT part (4 bytes, ILP32)
  *   empty struct  -> IGNORE
  *   singleton struct (one scalar field, size matches) -> DIRECT, one part
  *   other aggregate -> INDIRECT (sret/byval)
  *   array         -> INDIRECT
  *
  * Wasm has no native 128-bit integer or x87 long-double; those panic on
  * classification rather than silently routing through memory. */
 
 #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) {
   ABITypeInfo ti = abi_internal_type_info(a, t);
   ABIArgPart* parts;
 
   if (ti.size > 8) {
     SrcLoc loc = {0, 0, 0};
     /* A >8-byte float is binary128 long double (the only such C scalar);
      * report it specifically. Wider integers are __int128. */
     if (ti.scalar_kind == ABI_SC_FLOAT) {
       compiler_panic(a->c, loc, "wasm: long double not supported");
     }
     compiler_panic(a->c, loc,
                    "wasm32 ABI: scalar %u-byte values are not supported",
                    (unsigned)ti.size);
   }
 
   out->kind = ABI_ARG_DIRECT;
   out->flags = ABI_AF_NONE;
   out->indirect_align = 0;
 
   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;
 }
 
 /* BasicCABI singleton rule: a record with exactly one scalar field whose size
  * equals the record's size is passed as that scalar. Otherwise the aggregate
  * is passed indirectly. */
 static int try_classify_singleton(TargetABI* a, KitCgTypeId t,
                                   ABIArgInfo* out) {
   const CgType* ty = cg_type_get(a->c, t);
   ABITypeInfo ti;
   KitCgTypeId field_ty;
   const CgType* field;
   if (!ty || ty->kind != KIT_CG_TYPE_RECORD || ty->record.nfields != 1)
     return 0;
   if (ty->record.is_union) return 0;
   field_ty = ty->record.fields[0].type;
   field = cg_type_get(a->c, field_ty);
   if (!field) return 0;
   if (field->kind == KIT_CG_TYPE_RECORD || field->kind == KIT_CG_TYPE_ARRAY)
     return 0;
   ti = abi_internal_type_info(a, field_ty);
   if (ti.size != (u32)ty->size) return 0;
   classify_scalar(a, field_ty, out);
   return 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;
   }
   if (try_classify_singleton(a, t, out)) return;
   out->kind = ABI_ARG_INDIRECT;
   out->flags = is_return ? ABI_AF_SRET : ABI_AF_BYVAL;
   out->indirect_align = ti.align ? ti.align : 4;
   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_ARRAY:
       /* Arrays decay to pointers in C function signatures; if one reaches
        * the classifier, route indirect. */
       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;
   }
 }
 
 static ABIFuncInfo* wasm32_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;
   info->variadic = fnty->func.abi_variadic ? 1u : 0u;
 
   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 wasm32_vtable = {
     .compute_func_info = wasm32_compute_func_info,
     .va_list_info = {4, 4, ABI_SC_PTR, 0, 0, 0},
 };