kit

ffi.c (5450B)

---

 /* External (host-ABI) call marshaller.
  *
  * The engine has already classified arguments into integer-register and
  * fp-register slots per the call's ABIFuncInfo (sret pointer first, byval as a
  * pointer, aggregate-in-regs split into chunks). On the supported ABIs (SysV
  * x64, AAPCS64, RV64 LP64D) integer and fp arguments are assigned from
  * independent register sequences, so calling through one maximal prototype
  * `T(u64 x8, <fp> x8)` places the first `nint` integers and `nfp` fp values in
  * the correct registers regardless of their original interleaving; unused
  * trailing slots are zero and ignored by the callee.
  *
  * Two fp-argument shapes are needed because a 32-bit `float` and a 64-bit
  * `double` occupy the fp register differently (single vs double precision): the
  * engine picks `args_fp_is_float` when every fp arg is a 4-byte single, and the
  * dispatcher selects the `float`-parameter thunk family. A call mixing float
  * and double fp args within one signature is rejected upstream.
  *
  * Returns mirror this: a value comes back in one or two registers, classified
  * into int/fp parts. Two-register returns dispatch through struct-returning
  * thunks whose field types steer the ABI to the right return registers; the
  * caller copies each part's bytes into the aggregate destination.
  *
  * The casts deliberately mismatch the callee's real prototype — the classic
  * libffi-lite trick. That trips clang's -fsanitize=function, so the dispatcher
  * opts out of that one check (clang only; kit self-host never enables it). */
 
 #include <string.h>
 
 #include "core/core.h"
 #include "interp/interp.h"
 
 /* 8 integer + 8 fp register slots, fp as double or as single. */
 #define IPARAMS u64, u64, u64, u64, u64, u64, u64, u64
 #define DPARAMS double, double, double, double, double, double, double, double
 #define FPARAMS float, float, float, float, float, float, float, float
 
 #define IVALS(a)                                                             \
   (a)->iargs[0], (a)->iargs[1], (a)->iargs[2], (a)->iargs[3], (a)->iargs[4], \
       (a)->iargs[5], (a)->iargs[6], (a)->iargs[7]
 #define DVALS(a)                                                             \
   (a)->fargs[0], (a)->fargs[1], (a)->fargs[2], (a)->fargs[3], (a)->fargs[4], \
       (a)->fargs[5], (a)->fargs[6], (a)->fargs[7]
 #define FVALS(a)                                                      \
   (a)->fargs_f[0], (a)->fargs_f[1], (a)->fargs_f[2], (a)->fargs_f[3], \
       (a)->fargs_f[4], (a)->fargs_f[5], (a)->fargs_f[6], (a)->fargs_f[7]
 
 /* Two-register return shapes; the field types pick the return-register classes
  * (e.g. {u64,u64}=RAX,RDX / X0,X1; {u64,double}=RAX,XMM0 / X0,V0; etc). */
 typedef struct {
   u64 a, b;
 } R_ii;
 typedef struct {
   u64 a;
   double b;
 } R_id;
 typedef struct {
   double a;
   u64 b;
 } R_di;
 typedef struct {
   double a, b;
 } R_dd;
 
 /* double-fp-arg thunks, by return shape */
 typedef u64 (*t_i_d)(IPARAMS, DPARAMS);
 typedef double (*t_d_d)(IPARAMS, DPARAMS);
 typedef float (*t_f_d)(IPARAMS, DPARAMS);
 typedef R_ii (*t_ii_d)(IPARAMS, DPARAMS);
 typedef R_id (*t_id_d)(IPARAMS, DPARAMS);
 typedef R_di (*t_di_d)(IPARAMS, DPARAMS);
 typedef R_dd (*t_dd_d)(IPARAMS, DPARAMS);
 /* float-fp-arg thunks, scalar returns only (mixed signatures are rare) */
 typedef u64 (*t_i_f)(IPARAMS, FPARAMS);
 typedef double (*t_d_f)(IPARAMS, FPARAMS);
 typedef float (*t_f_f)(IPARAMS, FPARAMS);
 
 #if defined(__clang__)
 __attribute__((no_sanitize("function")))
 #endif
 int interp_ffi_invoke(void* fp, const InterpFfiArgs* a, u64 out[2],
                       const char** reason) {
   int flt;
   out[0] = 0;
   out[1] = 0;
   if (!fp) {
     *reason = "external call target is null";
     return 1;
   }
   if (a->nint > 8u || a->nfp > 8u) {
     *reason = "external call has too many register arguments";
     return 1;
   }
   flt = a->args_fp_is_float;
 
   /* void return */
   if (a->ret_is_void || a->ret_nparts == 0u) {
     if (flt)
       ((t_i_f)fp)(IVALS(a), FVALS(a));
     else
       ((t_i_d)fp)(IVALS(a), DVALS(a));
     return 0;
   }
 
   /* single-register return */
   if (a->ret_nparts == 1u) {
     if (a->ret_fp[0]) {
       if (a->ret_size[0] == 4u) {
         float r = flt ? ((t_f_f)fp)(IVALS(a), FVALS(a))
                       : ((t_f_d)fp)(IVALS(a), DVALS(a));
         u32 b;
         memcpy(&b, &r, 4);
         out[0] = b;
       } else {
         double r = flt ? ((t_d_f)fp)(IVALS(a), FVALS(a))
                        : ((t_d_d)fp)(IVALS(a), DVALS(a));
         memcpy(&out[0], &r, 8);
       }
     } else {
       out[0] = flt ? ((t_i_f)fp)(IVALS(a), FVALS(a))
                    : ((t_i_d)fp)(IVALS(a), DVALS(a));
     }
     return 0;
   }
 
   /* two-register return. A float fp arg combined with a struct return is rare;
    * require double fp args here (engine also rejects 4-byte fp return parts).
    */
   if (flt) {
     *reason = "external call: float args with multi-register return";
     return 1;
   }
   if (!a->ret_fp[0] && !a->ret_fp[1]) {
     R_ii r = ((t_ii_d)fp)(IVALS(a), DVALS(a));
     out[0] = r.a;
     out[1] = r.b;
   } else if (!a->ret_fp[0] && a->ret_fp[1]) {
     R_id r = ((t_id_d)fp)(IVALS(a), DVALS(a));
     out[0] = r.a;
     memcpy(&out[1], &r.b, 8);
   } else if (a->ret_fp[0] && !a->ret_fp[1]) {
     R_di r = ((t_di_d)fp)(IVALS(a), DVALS(a));
     memcpy(&out[0], &r.a, 8);
     out[1] = r.b;
   } else {
     R_dd r = ((t_dd_d)fp)(IVALS(a), DVALS(a));
     memcpy(&out[0], &r.a, 8);
     memcpy(&out[1], &r.b, 8);
   }
   return 0;
 }