Function wrapWithSharedBuffer

lib/internal/ffi-shared-buffer.js:201–283

(rawFn, signature)

// reads the return value back only after, so nested/reentrant calls into
// the same function are safe.
function wrapWithSharedBuffer(rawFn, signature) {
  if (rawFn == null) return rawFn;
  const buffer = rawFn[kSbSharedBuffer];
  if (buffer === undefined) return rawFn;

  // Callers without explicit signature info (the `functions` accessor
  // patch below) rely on the `kSbArguments` / `kSbReturn` metadata attached
  // by the native `CreateFunction`.
  let argumentTypes, returnType;
  if (signature === undefined) {
    argumentTypes = rawFn[kSbArguments];
    returnType = rawFn[kSbReturn];

    // `CreateFunction` always attaches these for SB-eligible functions.
    // Missing here means the native side and this wrapper are out of sync.
    assert(argumentTypes !== undefined && returnType !== undefined,
           'FFI: shared-buffer raw function is missing kSbArguments or kSbReturn');
  } else {
    argumentTypes = signature.arguments ?? [];
    returnType = signature.return ?? 'void';
  }

  const slowInvoke = rawFn[kSbInvokeSlow];
  const view = new DataView(buffer);
  let retGetter = null;
  if (returnType !== 'void') {
    const retInfo = sbTypeInfo[returnType];
    assert(retInfo !== undefined,
           `FFI: shared-buffer type table missing entry for return type "${returnType}"`);
    retGetter = retInfo.get;
  }

  const nargs = argumentTypes.length;
  const argInfos = [];
  const argOffsets = [];
  let anyPointer = false;
  for (let i = 0; i < nargs; i++) {
    const info = sbTypeInfo[argumentTypes[i]];
    assert(info !== undefined,
           `FFI: shared-buffer type table missing entry for argument type "${argumentTypes[i]}"`);
    // Push the `sbTypeInfo` entry directly (entries with the same `kind`
    // share a shape, keeping `writeNumericArg`'s call sites
    // low-polymorphism) and store offsets in a parallel array to avoid
    // per-arg object cloning.
    argInfos.push(info);
    argOffsets.push(8 * (i + 1));
    if (info.kind === 'pointer') anyPointer = true;
  }

  let wrapper;
  if (anyPointer) {
    // Pointer signatures need a per-arg runtime type check and fall back
    // to the native slow-path invoker for non-BigInt pointer arguments,
    // so arity specialization wouldn't buy much here.
    assert(slowInvoke !== undefined,
           'FFI: shared-buffer raw function with pointer arguments is missing kSbInvokeSlow');
    wrapper = function(...args) {
      if (args.length !== nargs) {