ffi: add fast-call signature eligibility check

IsFastCallEligible() validates at parse time whether a signature can
use the fast-call path, covering:

- Return and argument type eligibility (numeric, pointer; no structs)
- Argument count cap (8, matching V8 fast-call limit)
- Per-ABI register pressure limits (AArch64, x86_64 SysV, Win64)
- AArch64 constraint: buffer/float args cannot coexist

Returns nullptr from CreateFastFFIMetadata() for ineligible signatures,
falling back to libffi.

Signed-off-by: Bryan English <bryan@bryanenglish.com>

Author: bengl

src/ffi/types.cc

@@ -230,6 +230,144 @@ bool SignaturesMatch(const FFIFunction& fn,
   return true;
 }
 
+namespace {
+
+bool IsFastCallEligibleFFIType(ffi_type* type) {
+  // Accept all numeric types, pointer, and void (void OK as return only).
+  // Rejects struct types (not yet supported in fast-call path).
+  return type == &ffi_type_void || type == &ffi_type_sint8 ||
+         type == &ffi_type_uint8 || type == &ffi_type_sint16 ||
+         type == &ffi_type_uint16 || type == &ffi_type_sint32 ||
+         type == &ffi_type_uint32 || type == &ffi_type_sint64 ||
+         type == &ffi_type_uint64 || type == &ffi_type_float ||
+         type == &ffi_type_double || type == &ffi_type_pointer;
+}
+
+bool IsFunctionTypeName(const std::string& name) {
+  return name == "function";
+}
+
+// Check if an FFI type occupies a floating-point register.
+bool IsFFITypeFloat(ffi_type* type) {
+  return type == &ffi_type_float || type == &ffi_type_double;
+}
+
+// Check if an FFI type name maps to a kBuffer (kV8Value) argument in the
+// fast-call path, which consumes an extra GP register for the helper call.
+bool IsBufferTypeName(const std::string& name) {
+  return name == "buffer" || name == "arraybuffer";
+}
+
+}  // namespace
+
+bool IsFastCallEligible(const FFIFunction& fn, const char** out_reason) {
+  static const char* dummy = "";
+  if (out_reason == nullptr) out_reason = &dummy;
+
+  // Check that a platform stub emitter exists for the current ABI.
+  // Stub emitters cover AArch64 (Linux/macOS/FreeBSD/Windows) and
+  // x86_64 (SysV: Linux/macOS/FreeBSD, Win64: Windows). Other platforms
+  // fall back to libffi.
+#if !defined(__aarch64__) && !defined(_M_ARM64) && !defined(__x86_64__)
+  *out_reason = "no platform stub emitter";
+  return false;
+#endif
+
+  // Check return type eligibility.
+  if (!IsFastCallEligibleFFIType(fn.return_type)) {
+    *out_reason = "unsupported return type";
+    return false;
+  }
+  if (IsFunctionTypeName(fn.return_type_name)) {
+    *out_reason = "return type is function";
+    return false;
+  }
+
+  // V8's fast-call lowering caps the C-side arg count. With HasReceiver=kNo
+  // there's no implicit receiver in the count, so this is the user-arg cap.
+  // V8's hard limit is 8 args; signatures over that fall back to libffi.
+  if (fn.args.size() > 8) {
+    *out_reason = "argument count exceeds V8 fast-call cap";
+    return false;
+  }
+
+  // Per-ABI register caps for arguments that must be passed in registers.
+  // If an arg can't fit in a register, it goes on the stack — which the
+  // current trampoline generators don't support.
+  size_t gp_count = 0;
+  size_t fp_count = 0;
+  bool has_buffer_arg = false;
+  for (size_t i = 0; i < fn.args.size(); ++i) {
+    ffi_type* t = fn.args[i];
+    const std::string& name = fn.arg_type_names[i];
+
+    if (!IsFastCallEligibleFFIType(t)) {
+      *out_reason = "unsupported arg type";
+      return false;
+    }
+    // `void` is fine as a return type but has no register slot, so it cannot
+    // appear in `args`.
+    if (t == &ffi_type_void) {
+      *out_reason = "void cannot be an argument type";
+      return false;
+    }
+    if (IsFunctionTypeName(name)) {
+      *out_reason = "arg is function";
+      return false;
+    }
+
+    // `buffer`/`arraybuffer` args arrive as kV8Value in the V8 fast-call
+    // signature, consuming an extra GP register for the helper call.
+    if (IsBufferTypeName(name)) {
+      has_buffer_arg = true;
+    }
+
+    // Count register classes used by each argument.
+    if (IsFFITypeFloat(t)) {
+      fp_count++;
+    } else {
+      gp_count++;
+    }
+  }
+
+  // Platform-specific register pressure limits.
+#if defined(__aarch64__) || defined(_M_ARM64)
+  // AArch64: 8 FP registers (v0-v7) + up to 7 GP registers per trampoline
+  // constraint (the 8th GP slot is consumed by the helper call for buffer
+  // args). Buffer args and float args can't coexist — the helper call would
+  // clobber FP state.
+  const size_t effective_gp = gp_count + (has_buffer_arg ? 1 : 0);
+  if (has_buffer_arg && fp_count != 0) {
+    *out_reason = "buffer and float args cannot coexist on AArch64";
+    return false;
+  }
+  if (effective_gp > 7 || fp_count > 8) {
+    *out_reason = "argument count exceeds AArch64 register limit";
+    return false;
+  }
+#elif defined(__x86_64__)
+#if defined(_WIN32)
+  // x86_64 Win64: 4 register slots total (rcx, rdx, r8, r9 for GP;
+  // xmm0-xmm3 for FP). GP + FP share the positional limit — once 4 slots
+  // are consumed, remaining args go to the stack.
+  if (gp_count + fp_count > 3) {
+    *out_reason = "argument count exceeds x86_64 Win64 register limit";
+    return false;
+  }
+#else
+  // x86_64 SysV: 6 GP registers (rdi, rsi, rdx, rcx, r8, r9) + 8 FP
+  // registers (xmm0-xmm7).
+  if (gp_count > 6 || fp_count > 8) {
+    *out_reason = "argument count exceeds x86_64 SysV register limit";
+    return false;
+  }
+#endif  // _WIN32
+#endif  // __x86_64__
+
+  *out_reason = "";
+  return true;
+}
+
 bool IsSBEligibleFFIType(ffi_type* type) {
   return type == &ffi_type_void || type == &ffi_type_sint8 ||
          type == &ffi_type_uint8 || type == &ffi_type_sint16 ||

src/ffi/types.h

@@ -53,6 +53,18 @@ bool SignaturesMatch(const FFIFunction& fn,
                      ffi_type* return_type,
                      const std::vector<ffi_type*>& args);
 
+// Returns true if `fn` can be invoked via the V8 fast-call path. On
+// false, `*out_reason` is set to a static string describing why
+// (never null after this returns; callers may pass nullptr to ignore).
+//
+// Eligibility checks: every arg type and the return type are
+// numeric-or-pointer, no `function`-typed args/return, arg count
+// within V8 fast-call cap (8), and register-passed arg counts within
+// per-ABI limits (AArch64: ≤ 7 GP + ≤ 8 FP, x86_64 SysV: ≤ 6 GP + ≤ 8 FP,
+// x86_64 Win64: GP+FP ≤ 3). Also checks that a platform stub emitter
+// exists for the current ABI.
+bool IsFastCallEligible(const FFIFunction& fn, const char** out_reason);
+
 // True if the FFI type can be read from / written to a raw byte buffer
 // without needing V8 operations (conversion, allocation, etc.).
 bool IsSBEligibleFFIType(ffi_type* type);