githubmirror/node

src/ffi/fast.h
96 строк3 KB
Trivikram Kamat
ffi: reject fast calls after library close
05 авг 2026, 12:15
05 авг 2026, 12:153391210
#pragma once

#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

#include "ffi.h"
#include "v8-fast-api-calls.h"

#include <cstddef>
#include <cstdint>
#include <memory>
#include <string>
#include <vector>

namespace node::ffi {

struct FFIFunction;

enum class FastFFIType : uint8_t {
  kVoid,
  kInt8,
  kUint8,
  kInt16,
  kUint16,
  kInt32,
  kUint32,
  kInt64,
  kUint64,
  kFloat32,
  kFloat64,
  kPointer,
  kBuffer,
};

struct FastFFITrampoline {
  void* code = nullptr;
  size_t size = 0;
};

struct FastFFITrampolineConfig {
  void* target;
  const bool* closed;
  v8::Isolate* isolate;
};

struct FastFFIMetadata {
  FastFFIMetadata() = default;
  ~FastFFIMetadata();

  FastFFIMetadata(const FastFFIMetadata&) = delete;
  FastFFIMetadata& operator=(const FastFFIMetadata&) = delete;

  FastFFITrampoline trampoline;
  std::vector<v8::CTypeInfo> arg_info;
  std::unique_ptr<v8::CFunctionInfo> c_function_info;
  v8::CFunction c_function;
  bool guards_library = false;
};

// Public detection queries.

// Returns true if the fast-call path is available at all on this process
// (platform stub emitter exists + JIT memory self-test passed). Independent
// of any particular signature — if this returns false, no signature can
// use the fast-call path.
bool IsFastCallSupported();
bool IsFastLibraryGuardSupported();

bool SignatureNeedsRawPointerConversions(const FFIFunction& fn);
bool SignatureNeedsFastIntegerValidation(const FFIFunction& fn);
bool IsPointerTypeName(const std::string& name);
bool SignatureNeedsFastBufferInvoke(const FFIFunction& fn);
std::shared_ptr<FFIFunction> CloneWithRawPointerArgNames(
    const std::shared_ptr<FFIFunction>& fn);
std::shared_ptr<FFIFunction> CloneWithFastBufferArgNames(
    const std::shared_ptr<FFIFunction>& fn);
std::unique_ptr<FastFFIMetadata> CreateFastFFIMetadata(const FFIFunction& fn,
                                                       const bool* closed,
                                                       v8::Isolate* isolate);

}  // namespace node::ffi

extern "C" {
uintptr_t node_ffi_fast_buffer_data(v8::Local<v8::Value> value,
                                    v8::FastApiCallbackOptions* options,
                                    uint32_t index);
void node_ffi_fast_library_closed(v8::Isolate* isolate);
bool node_ffi_create_fast_trampoline(
    const node::ffi::FastFFITrampolineConfig& config,
    const node::ffi::FastFFIType* args,
    size_t argc,
    node::ffi::FastFFIType result,
    node::ffi::FastFFITrampoline* out);
void node_ffi_free_fast_trampoline(node::ffi::FastFFITrampoline* trampoline);
}

#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS