@encharm/cws 4.5.3 → 4.6.0

package/src/headers/26/node_external_reference.h

@@ -0,0 +1,171 @@
+#ifndef SRC_NODE_EXTERNAL_REFERENCE_H_
+#define SRC_NODE_EXTERNAL_REFERENCE_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <cinttypes>
+#include <vector>
+#include "quic/guard.h"
+#include "v8-fast-api-calls.h"
+#include "v8.h"
+
+namespace node {
+
+// This class manages the external references from the V8 heap
+// to the C++ addresses in Node.js.
+class ExternalReferenceRegistry {
+ public:
+  ExternalReferenceRegistry();
+
+#define ALLOWED_EXTERNAL_REFERENCE_TYPES(V)                                    \
+  V(v8::FunctionCallback)                                                      \
+  V(v8::AccessorNameGetterCallback)                                            \
+  V(v8::AccessorNameSetterCallback)                                            \
+  V(v8::NamedPropertyGetterCallback)                                           \
+  V(v8::NamedPropertyDefinerCallback)                                          \
+  V(v8::NamedPropertyDeleterCallback)                                          \
+  V(v8::NamedPropertyEnumeratorCallback)                                       \
+  V(v8::NamedPropertyQueryCallback)                                            \
+  V(v8::NamedPropertySetterCallback)                                           \
+  V(v8::IndexedPropertyGetterCallbackV2)                                       \
+  V(v8::IndexedPropertySetterCallbackV2)                                       \
+  V(v8::IndexedPropertyDefinerCallbackV2)                                      \
+  V(v8::IndexedPropertyDeleterCallbackV2)                                      \
+  V(v8::IndexedPropertyQueryCallbackV2)                                        \
+  V(const v8::String::ExternalStringResourceBase*)
+
+#define V(ExternalReferenceType)                                               \
+  void Register(ExternalReferenceType addr) { RegisterT(addr); }
+  ALLOWED_EXTERNAL_REFERENCE_TYPES(V)
+#undef V
+
+  // Registers both the underlying function pointer
+  // and the corresponding CFunctionInfo.
+  void Register(const v8::CFunction& c_func) {
+    RegisterT(c_func.GetAddress());
+    RegisterT(c_func.GetTypeInfo());
+  }
+
+  // This can be called only once.
+  const std::vector<intptr_t>& external_references();
+
+  bool is_empty() { return external_references_.empty(); }
+
+ private:
+  template <typename T>
+  void RegisterT(T* address) {
+    external_references_.push_back(reinterpret_cast<intptr_t>(address));
+  }
+  bool is_finalized_ = false;
+  std::vector<intptr_t> external_references_;
+};
+
+#define EXTERNAL_REFERENCE_BINDING_LIST_BASE(V)                                \
+  V(async_wrap)                                                                \
+  V(binding)                                                                   \
+  V(blob)                                                                      \
+  V(buffer)                                                                    \
+  V(builtins)                                                                  \
+  V(cares_wrap)                                                                \
+  V(cjs_lexer)                                                                 \
+  V(config)                                                                    \
+  V(contextify)                                                                \
+  V(credentials)                                                               \
+  V(diagnostics_channel)                                                       \
+  V(encoding_binding)                                                          \
+  V(env_var)                                                                   \
+  V(errors)                                                                    \
+  V(fs)                                                                        \
+  V(fs_dir)                                                                    \
+  V(fs_event_wrap)                                                             \
+  V(handle_wrap)                                                               \
+  V(heap_utils)                                                                \
+  V(http_parser)                                                               \
+  V(internal_only_v8)                                                          \
+  V(ipc_serdes)                                                                \
+  V(locks)                                                                     \
+  V(messaging)                                                                 \
+  V(mksnapshot)                                                                \
+  V(module_wrap)                                                               \
+  V(modules)                                                                   \
+  V(options)                                                                   \
+  V(os)                                                                        \
+  V(performance)                                                               \
+  V(permission)                                                                \
+  V(process_methods)                                                           \
+  V(process_object)                                                            \
+  V(process_wrap)                                                              \
+  V(report)                                                                    \
+  V(task_queue)                                                                \
+  V(tcp_wrap)                                                                  \
+  V(tty_wrap)                                                                  \
+  V(udp_wrap)                                                                  \
+  V(url)                                                                       \
+  V(url_pattern)                                                               \
+  V(util)                                                                      \
+  V(pipe_wrap)                                                                 \
+  V(sea)                                                                       \
+  V(serdes)                                                                    \
+  V(string_decoder)                                                            \
+  V(stream_wrap)                                                               \
+  V(signal_wrap)                                                               \
+  V(spawn_sync)                                                                \
+  V(trace_events)                                                              \
+  V(timers)                                                                    \
+  V(types)                                                                     \
+  V(uv)                                                                        \
+  V(v8)                                                                        \
+  V(zlib)                                                                      \
+  V(wasm_web_api)                                                              \
+  V(worker)
+
+#if NODE_HAVE_I18N_SUPPORT
+#define EXTERNAL_REFERENCE_BINDING_LIST_I18N(V) V(icu)
+#else
+#define EXTERNAL_REFERENCE_BINDING_LIST_I18N(V)
+#endif  // NODE_HAVE_I18N_SUPPORT
+
+#if HAVE_INSPECTOR
+#define EXTERNAL_REFERENCE_BINDING_LIST_INSPECTOR(V)                           \
+  V(inspector)                                                                 \
+  V(profiler)
+#else
+#define EXTERNAL_REFERENCE_BINDING_LIST_INSPECTOR(V)
+#endif  // HAVE_INSPECTOR
+
+#if HAVE_OPENSSL
+#define EXTERNAL_REFERENCE_BINDING_LIST_CRYPTO(V) V(crypto) V(tls_wrap)
+#else
+#define EXTERNAL_REFERENCE_BINDING_LIST_CRYPTO(V)
+#endif  // HAVE_OPENSSL
+
+#if HAVE_OPENSSL && OPENSSL_NO_QUIC != 1
+#define EXTERNAL_REFERENCE_BINDING_LIST_QUIC(V) V(quic)
+#else
+#define EXTERNAL_REFERENCE_BINDING_LIST_QUIC(V)
+#endif
+
+#define EXTERNAL_REFERENCE_BINDING_LIST(V)                                     \
+  EXTERNAL_REFERENCE_BINDING_LIST_BASE(V)                                      \
+  EXTERNAL_REFERENCE_BINDING_LIST_INSPECTOR(V)                                 \
+  EXTERNAL_REFERENCE_BINDING_LIST_I18N(V)                                      \
+  EXTERNAL_REFERENCE_BINDING_LIST_CRYPTO(V)                                    \
+  EXTERNAL_REFERENCE_BINDING_LIST_QUIC(V)
+
+}  // namespace node
+
+// Declare all the external reference registration functions here,
+// and define them later with #NODE_BINDING_EXTERNAL_REFERENCE(modname, func);
+#define V(modname)                                                             \
+  void _register_external_reference_##modname(                                 \
+      node::ExternalReferenceRegistry* registry);
+EXTERNAL_REFERENCE_BINDING_LIST(V)
+#undef V
+
+#define NODE_BINDING_EXTERNAL_REFERENCE(modname, func)                         \
+  void _register_external_reference_##modname(                                 \
+      node::ExternalReferenceRegistry* registry) {                             \
+    func(registry);                                                            \
+  }
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_NODE_EXTERNAL_REFERENCE_H_

package/src/headers/26/node_ffi.h

@@ -0,0 +1,212 @@
+#pragma once
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "base_object.h"
+#include "ffi.h"
+#include "ffi/fast.h"
+#include "uv.h"
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <thread>
+#include <unordered_map>
+#include <vector>
+
+// libffi only accelerates reusable call plans on x86-64 System V. Other
+// targets implement the API by calling ffi_call(), which adds no benefit.
+#if defined(FFI_VERSION_NUMBER) && FFI_VERSION_NUMBER >= 30700 &&              \
+    defined(__x86_64__) && !defined(__ILP32__) && !defined(X86_WIN64) &&       \
+    !defined(_WIN32)
+#define NODE_FFI_HAS_FAST_CALL_PLAN 1
+#endif
+
+namespace node::ffi {
+
+class DynamicLibrary;
+struct FFIFunction;
+
+struct FFIFunction {
+  FFIFunction() = default;
+  FFIFunction(const FFIFunction&) = delete;
+  FFIFunction& operator=(const FFIFunction&) = delete;
+  FFIFunction(FFIFunction&&) = delete;
+  FFIFunction& operator=(FFIFunction&&) = delete;
+
+  bool closed = false;
+
+  void* ptr = nullptr;
+  ffi_cif cif = {};
+  std::vector<ffi_type*> args;
+  ffi_type* return_type = nullptr;
+  std::vector<std::string> arg_type_names;
+  std::string return_type_name;
+#if defined(NODE_FFI_HAS_FAST_CALL_PLAN)
+  // The plan borrows cif, so it must remain uniquely owned by this instance.
+  std::unique_ptr<ffi_call_plan, decltype(&ffi_call_plan_free)> call_plan{
+      nullptr, ffi_call_plan_free};
+#endif
+
+  void Invoke(void* result, void** values);
+};
+
+class FFIFunctionInfo final : public BaseObject {
+ public:
+  enum InternalFields {
+    kLibrary = BaseObject::kInternalFieldCount,
+    kInternalFieldCount
+  };
+
+  FFIFunctionInfo(Environment* env,
+                  v8::Local<v8::Object> object,
+                  std::shared_ptr<FFIFunction> fn,
+                  DynamicLibrary* library);
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(FFIFunctionInfo)
+  SET_SELF_SIZE(FFIFunctionInfo)
+
+  static BaseObjectPtr<FFIFunctionInfo> Create(Environment* env,
+                                               std::shared_ptr<FFIFunction> fn,
+                                               DynamicLibrary* library);
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      IsolateData* isolate_data);
+
+ private:
+  std::shared_ptr<FFIFunction> fn;
+  std::shared_ptr<v8::BackingStore> sb_backing;
+  std::unique_ptr<FastFFIMetadata> fast_metadata;
+  std::unique_ptr<FastFFIMetadata> fast_buffer_metadata;
+
+  friend class DynamicLibrary;
+};
+
+struct FFICallback {
+  DynamicLibrary* owner;
+  Environment* env;
+  std::thread::id thread_id;
+  v8::Global<v8::Function> fn;
+  ffi_closure* closure;
+
+  void* ptr;
+  ffi_cif cif;
+  std::vector<ffi_type*> args;
+  ffi_type* return_type;
+
+  ~FFICallback() {
+    if (!fn.IsEmpty()) {
+      fn.Reset();
+    }
+
+    if (closure != nullptr) {
+      ffi_closure_free(closure);
+      closure = nullptr;
+    }
+  }
+};
+
+struct ResolvedFunction {
+  std::string name;
+  std::shared_ptr<FFIFunction> fn;
+  bool should_cache_symbol;
+  bool should_cache_function;
+};
+
+class DynamicLibrary : public BaseObject {
+ public:
+  DynamicLibrary(Environment* env, v8::Local<v8::Object> object);
+  ~DynamicLibrary() override;
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      Environment* env);
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Close(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void InvokeFunction(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void InvokeFunctionSB(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void InvokeCallback(ffi_cif* cif,
+                             void* ret,
+                             void** args,
+                             void* user_data);
+
+  static void GetPath(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetFunction(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetFunctions(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetSymbol(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetSymbols(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static void RegisterCallback(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void UnregisterCallback(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void RefCallback(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void UnrefCallback(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  SET_MEMORY_INFO_NAME(DynamicLibrary)
+  SET_SELF_SIZE(DynamicLibrary)
+
+ private:
+  void Close();
+  v8::Maybe<void*> ResolveSymbol(Environment* env, const std::string& name);
+  struct PreparedFunction {
+    std::shared_ptr<FFIFunction> fn;
+    bool should_cache_symbol;
+    bool should_cache_function;
+  };
+  v8::Maybe<PreparedFunction> PrepareFunction(Environment* env,
+                                              const std::string& name,
+                                              v8::Local<v8::Object> signature);
+  v8::MaybeLocal<v8::Function> CreateFunction(
+      Environment* env,
+      const std::string& name,
+      const std::shared_ptr<FFIFunction>& fn);
+  static void CleanupFunctionInfo(
+      const v8::WeakCallbackInfo<FFIFunctionInfo>& data);
+  bool is_closed() const;
+
+  uv_lib_t lib_ = {};
+  std::string path_;
+  std::unordered_map<std::string, void*> symbols_;
+  std::unordered_map<std::string, std::shared_ptr<FFIFunction>> functions_;
+  // Callables created for `functions_`, so repeated resolution of the same
+  // symbol reuses one wrapper instead of emitting another trampoline. The
+  // handles are weak: an entry disappears once user code drops the wrapper,
+  // which keeps the map from rooting the library through the wrapper's
+  // FFIFunctionInfo.
+  std::unordered_map<std::string, v8::Global<v8::Function>> function_wrappers_;
+  std::unordered_map<void*, std::unique_ptr<FFICallback>> callbacks_;
+};
+
+void GetInt8(const v8::FunctionCallbackInfo<v8::Value>& args);
+void GetUint8(const v8::FunctionCallbackInfo<v8::Value>& args);
+void GetInt16(const v8::FunctionCallbackInfo<v8::Value>& args);
+void GetUint16(const v8::FunctionCallbackInfo<v8::Value>& args);
+void GetInt32(const v8::FunctionCallbackInfo<v8::Value>& args);
+void GetUint32(const v8::FunctionCallbackInfo<v8::Value>& args);
+void GetInt64(const v8::FunctionCallbackInfo<v8::Value>& args);
+void GetUint64(const v8::FunctionCallbackInfo<v8::Value>& args);
+void GetFloat32(const v8::FunctionCallbackInfo<v8::Value>& args);
+void GetFloat64(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+void SetInt8(const v8::FunctionCallbackInfo<v8::Value>& args);
+void SetUint8(const v8::FunctionCallbackInfo<v8::Value>& args);
+void SetInt16(const v8::FunctionCallbackInfo<v8::Value>& args);
+void SetUint16(const v8::FunctionCallbackInfo<v8::Value>& args);
+void SetInt32(const v8::FunctionCallbackInfo<v8::Value>& args);
+void SetUint32(const v8::FunctionCallbackInfo<v8::Value>& args);
+void SetInt64(const v8::FunctionCallbackInfo<v8::Value>& args);
+void SetUint64(const v8::FunctionCallbackInfo<v8::Value>& args);
+void SetFloat32(const v8::FunctionCallbackInfo<v8::Value>& args);
+void SetFloat64(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+void ToString(const v8::FunctionCallbackInfo<v8::Value>& args);
+void ToBuffer(const v8::FunctionCallbackInfo<v8::Value>& args);
+void ToArrayBuffer(const v8::FunctionCallbackInfo<v8::Value>& args);
+void ExportBytes(const v8::FunctionCallbackInfo<v8::Value>& args);
+void GetRawPointer(const v8::FunctionCallbackInfo<v8::Value>& args);
+void GetCurrentEventLoop(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+}  // namespace node::ffi
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS