@encharm/cws 4.4.1 → 4.5.2

package/src/headers/22/node_sea.h

@@ -0,0 +1,64 @@
+#ifndef SRC_NODE_SEA_H_
+#define SRC_NODE_SEA_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <cinttypes>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <tuple>
+#include <unordered_map>
+#include <vector>
+
+#include "node_exit_code.h"
+
+namespace node {
+class Environment;
+namespace sea {
+// A special number that will appear at the beginning of the single executable
+// preparation blobs ready to be injected into the binary. We use this to check
+// that the data given to us are intended for building single executable
+// applications.
+const uint32_t kMagic = 0x143da20;
+
+enum class SeaFlags : uint32_t {
+  kDefault = 0,
+  kDisableExperimentalSeaWarning = 1 << 0,
+  kUseSnapshot = 1 << 1,
+  kUseCodeCache = 1 << 2,
+  kIncludeAssets = 1 << 3,
+};
+
+struct SeaResource {
+  SeaFlags flags = SeaFlags::kDefault;
+  std::string_view code_path;
+  std::string_view main_code_or_snapshot;
+  std::optional<std::string_view> code_cache;
+  std::unordered_map<std::string_view, std::string_view> assets;
+
+  bool use_snapshot() const;
+  bool use_code_cache() const;
+
+  static constexpr size_t kHeaderSize = sizeof(kMagic) + sizeof(SeaFlags);
+};
+
+bool IsSingleExecutable();
+SeaResource FindSingleExecutableResource();
+std::tuple<int, char**> FixupArgsForSEA(int argc, char** argv);
+node::ExitCode BuildSingleExecutableBlob(
+    const std::string& config_path,
+    const std::vector<std::string>& args,
+    const std::vector<std::string>& exec_args);
+
+// Try loading the Environment as a single-executable application.
+// Returns true if it is loaded as a single-executable application.
+// Otherwise returns false and the caller is expected to call LoadEnvironment()
+// differently.
+bool MaybeLoadSingleExecutableApplication(Environment* env);
+}  // namespace sea
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_SEA_H_

package/src/headers/22/node_shadow_realm.h

@@ -0,0 +1,46 @@
+#ifndef SRC_NODE_SHADOW_REALM_H_
+#define SRC_NODE_SHADOW_REALM_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "node_realm.h"
+#include "v8.h"
+
+namespace node {
+namespace shadow_realm {
+
+class ShadowRealm : public Realm {
+ public:
+  static ShadowRealm* New(Environment* env);
+
+  SET_MEMORY_INFO_NAME(ShadowRealm)
+  SET_SELF_SIZE(ShadowRealm)
+
+  v8::Local<v8::Context> context() const override;
+
+#define V(PropertyName, TypeName)                                              \
+  v8::Local<TypeName> PropertyName() const override;                           \
+  void set_##PropertyName(v8::Local<TypeName> value) override;
+  PER_REALM_STRONG_PERSISTENT_VALUES(V)
+#undef V
+
+ protected:
+  v8::MaybeLocal<v8::Value> BootstrapRealm() override;
+
+ private:
+  static void WeakCallback(const v8::WeakCallbackInfo<ShadowRealm>& data);
+  static void DeleteMe(void* data);
+
+  explicit ShadowRealm(Environment* env);
+  ~ShadowRealm();
+};
+
+v8::MaybeLocal<v8::Context> HostCreateShadowRealmContextCallback(
+    v8::Local<v8::Context> initiator_context);
+
+}  // namespace shadow_realm
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_SHADOW_REALM_H_

package/src/headers/22/node_snapshot_builder.h

@@ -0,0 +1,57 @@
+
+#ifndef SRC_NODE_SNAPSHOT_BUILDER_H_
+#define SRC_NODE_SNAPSHOT_BUILDER_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <cstdint>
+#include <optional>
+#include <string_view>
+#include "node_exit_code.h"
+#include "node_mutex.h"
+#include "v8.h"
+
+namespace node {
+
+class ExternalReferenceRegistry;
+struct SnapshotData;
+
+std::optional<SnapshotConfig> ReadSnapshotConfig(const char* path);
+
+class NODE_EXTERN_PRIVATE SnapshotBuilder {
+ public:
+  static ExitCode GenerateAsSource(const char* out_path,
+                                   const std::vector<std::string>& args,
+                                   const std::vector<std::string>& exec_args,
+                                   const SnapshotConfig& config,
+                                   bool use_array_literals = false);
+
+  // Generate the snapshot into out. builder_script_content should match
+  // config.builder_script_path. This is passed separately
+  // in case the script is already read for other purposes.
+  static ExitCode Generate(
+      SnapshotData* out,
+      const std::vector<std::string>& args,
+      const std::vector<std::string>& exec_args,
+      std::optional<std::string_view> builder_script_content,
+      const SnapshotConfig& config);
+
+  // If nullptr is returned, the binary is not built with embedded
+  // snapshot.
+  static const SnapshotData* GetEmbeddedSnapshotData();
+  static void InitializeIsolateParams(const SnapshotData* data,
+                                      v8::Isolate::CreateParams* params);
+
+  static const std::vector<intptr_t>& CollectExternalReferences();
+
+  static ExitCode CreateSnapshot(SnapshotData* out,
+                                 CommonEnvironmentSetup* setup);
+
+ private:
+  static std::unique_ptr<ExternalReferenceRegistry> registry_;
+};
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_SNAPSHOT_BUILDER_H_

package/src/headers/22/node_snapshotable.h

@@ -0,0 +1,174 @@
+
+#ifndef SRC_NODE_SNAPSHOTABLE_H_
+#define SRC_NODE_SNAPSHOTABLE_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "aliased_buffer.h"
+#include "base_object.h"
+#include "util.h"
+
+namespace node {
+
+class Environment;
+struct RealmSerializeInfo;
+struct SnapshotData;
+class ExternalReferenceRegistry;
+
+using SnapshotIndex = size_t;
+
+struct PropInfo {
+  std::string name;     // name for debugging
+  uint32_t id;          // In the list - in case there are any empty entries
+  SnapshotIndex index;  // In the snapshot
+};
+
+typedef size_t SnapshotIndex;
+
+bool WithoutCodeCache(const SnapshotFlags& flags);
+bool WithoutCodeCache(const SnapshotConfig& config);
+
+// When serializing an embedder object, we'll serialize the native states
+// into a chunk that can be mapped into a subclass of InternalFieldInfoBase,
+// and pass it into the V8 callback as the payload of StartupData.
+// The memory chunk looks like this:
+//
+// [   type   ] - EmbedderObjectType (a uint8_t)
+// [  length  ] - a size_t
+// [    ...   ] - custom bytes of size |length - header size|
+struct InternalFieldInfoBase {
+ public:
+  EmbedderObjectType type;
+  size_t length;
+
+  template <typename T>
+  static T* New(EmbedderObjectType type) {
+    static_assert(std::is_base_of_v<InternalFieldInfoBase, T> ||
+                      std::is_same_v<InternalFieldInfoBase, T>,
+                  "Can only accept InternalFieldInfoBase subclasses");
+    void* buf = ::operator new[](sizeof(T));
+    memset(buf, 0, sizeof(T));  // Make the padding reproducible.
+    T* result = new (buf) T;
+    result->type = type;
+    result->length = sizeof(T);
+    return result;
+  }
+
+  template <typename T>
+  T* Copy() const {
+    static_assert(std::is_base_of_v<InternalFieldInfoBase, T> ||
+                      std::is_same_v<InternalFieldInfoBase, T>,
+                  "Can only accept InternalFieldInfoBase subclasses");
+    static_assert(std::is_trivially_copyable_v<T>,
+                  "Can only memcpy trivially copyable class");
+    void* buf = ::operator new[](sizeof(T));
+    T* result = new (buf) T;
+    memcpy(result, this, sizeof(T));
+    return result;
+  }
+
+  void Delete() { ::operator delete[](this); }
+
+  InternalFieldInfoBase() = default;
+};
+
+struct EmbedderTypeInfo {
+  enum class MemoryMode : uint8_t { kBaseObject, kCppGC };
+  EmbedderTypeInfo(EmbedderObjectType t, MemoryMode m) : type(t), mode(m) {}
+  EmbedderTypeInfo() = default;
+  EmbedderObjectType type;
+  MemoryMode mode;
+};
+
+// An interface for snapshotable native objects to inherit from.
+// Use the SERIALIZABLE_OBJECT_METHODS() macro in the class to define
+// the following methods to implement:
+//
+// - PrepareForSerialization(): This would be run prior to context
+//   serialization. Use this method to e.g. release references that
+//   can be re-initialized, or perform property store operations
+//   that needs a V8 context.
+// - Serialize(): This would be called during context serialization,
+//   once for each embedder field of the object.
+//   Allocate and construct an InternalFieldInfoBase object that contains
+//   data that can be used to deserialize native states.
+// - Deserialize(): This would be called after the context is
+//   deserialized and the object graph is complete, once for each
+//   embedder field of the object. Use this to restore native states
+//   in the object.
+class SnapshotableObject : public BaseObject {
+ public:
+  SnapshotableObject(Realm* realm,
+                     v8::Local<v8::Object> wrap,
+                     EmbedderObjectType type);
+  std::string GetTypeName() const;
+
+  // If returns false, the object will not be serialized.
+  virtual bool PrepareForSerialization(v8::Local<v8::Context> context,
+                                       v8::SnapshotCreator* creator) = 0;
+  virtual InternalFieldInfoBase* Serialize(int index) = 0;
+  bool is_snapshotable() const override { return true; }
+  // We'll make sure that the type is set in the constructor
+  EmbedderObjectType type() { return type_; }
+
+ private:
+  EmbedderObjectType type_;
+};
+
+#define SERIALIZABLE_OBJECT_METHODS()                                          \
+  bool PrepareForSerialization(v8::Local<v8::Context> context,                 \
+                               v8::SnapshotCreator* creator) override;         \
+  InternalFieldInfoBase* Serialize(int index) override;                        \
+  static void Deserialize(v8::Local<v8::Context> context,                      \
+                          v8::Local<v8::Object> holder,                        \
+                          int index,                                           \
+                          InternalFieldInfoBase* info);
+
+v8::StartupData SerializeNodeContextInternalFields(v8::Local<v8::Object> holder,
+                                                   int index,
+                                                   void* env);
+v8::StartupData SerializeNodeContextData(v8::Local<v8::Context> holder,
+                                         int index,
+                                         void* env);
+void DeserializeNodeInternalFields(v8::Local<v8::Object> holder,
+                                   int index,
+                                   v8::StartupData payload,
+                                   void* env);
+void DeserializeNodeContextData(v8::Local<v8::Context> holder,
+                                int index,
+                                v8::StartupData payload,
+                                void* env);
+void SerializeSnapshotableObjects(Realm* realm,
+                                  v8::SnapshotCreator* creator,
+                                  RealmSerializeInfo* info);
+
+#define DCHECK_IS_SNAPSHOT_SLOT(index) DCHECK_EQ(index, BaseObject::kSlot)
+
+namespace mksnapshot {
+class BindingData : public SnapshotableObject {
+ public:
+  struct InternalFieldInfo : public node::InternalFieldInfoBase {
+    AliasedBufferIndex is_building_snapshot_buffer;
+  };
+
+  BindingData(Realm* realm,
+              v8::Local<v8::Object> obj,
+              InternalFieldInfo* info = nullptr);
+  SET_BINDING_ID(mksnapshot_binding_data)
+  SERIALIZABLE_OBJECT_METHODS()
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_SELF_SIZE(BindingData)
+  SET_MEMORY_INFO_NAME(BindingData)
+
+ private:
+  AliasedUint8Array is_building_snapshot_buffer_;
+  InternalFieldInfo* internal_field_info_ = nullptr;
+};
+}  // namespace mksnapshot
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_SNAPSHOTABLE_H_

package/src/headers/{18 → 22}/node_sockaddr.h

@@ -176,7 +176,7 @@ class SocketAddressBase : public BaseObject {
   SET_MEMORY_INFO_NAME(SocketAddressBase)
   SET_SELF_SIZE(SocketAddressBase)
 
-  TransferMode GetTransferMode() const override {
+  BaseObject::TransferMode GetTransferMode() const override {
     return TransferMode::kCloneable;
   }
   std::unique_ptr<worker::TransferData> CloneForMessaging() const override;
@@ -367,7 +367,7 @@ class SocketAddressBlockListWrap : public BaseObject {
   SET_MEMORY_INFO_NAME(SocketAddressBlockListWrap)
   SET_SELF_SIZE(SocketAddressBlockListWrap)
 
-  TransferMode GetTransferMode() const override {
+  BaseObject::TransferMode GetTransferMode() const override {
     return TransferMode::kCloneable;
   }
   std::unique_ptr<worker::TransferData> CloneForMessaging() const override;

package/src/headers/{16 → 22}/node_stat_watcher.h

@@ -39,7 +39,8 @@ class ExternalReferenceRegistry;
 
 class StatWatcher : public HandleWrap {
  public:
-  static void Initialize(Environment* env, v8::Local<v8::Object> target);
+  static void CreatePerIsolateProperties(IsolateData* isolate_data,
+                                         v8::Local<v8::ObjectTemplate> ctor);
   static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
 
  protected:

package/src/headers/22/node_threadsafe_cow-inl.h

@@ -0,0 +1,54 @@
+#ifndef SRC_NODE_THREADSAFE_COW_INL_H_
+#define SRC_NODE_THREADSAFE_COW_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+namespace node {
+
+template <typename T>
+T* CopyOnWrite<T>::write() {
+  if (data_.use_count() > 1l) {
+    data_ = std::make_shared<T>(*data_);
+  }
+  return data_.get();
+}
+
+template <typename T>
+ThreadsafeCopyOnWrite<T>::Read::Read(const ThreadsafeCopyOnWrite<T>* cow)
+    : cow_(cow), lock_(cow->impl_->mutex) {}
+
+template <typename T>
+const T& ThreadsafeCopyOnWrite<T>::Read::operator*() const {
+  return cow_->impl_->data;
+}
+
+template <typename T>
+const T* ThreadsafeCopyOnWrite<T>::Read::operator->() const {
+  return &cow_->impl_->data;
+}
+
+template <typename T>
+ThreadsafeCopyOnWrite<T>::Write::Write(ThreadsafeCopyOnWrite<T>* cow)
+    : cow_(cow), impl_(cow->impl_.write()), lock_(impl_->mutex) {}
+
+template <typename T>
+T& ThreadsafeCopyOnWrite<T>::Write::operator*() {
+  return impl_->data;
+}
+
+template <typename T>
+T* ThreadsafeCopyOnWrite<T>::Write::operator->() {
+  return &impl_->data;
+}
+
+template <typename T>
+ThreadsafeCopyOnWrite<T>::Impl::Impl(const Impl& other) {
+  RwLock::ScopedReadLock lock(other.mutex);
+  data = other.data;
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_THREADSAFE_COW_INL_H_

package/src/headers/22/node_threadsafe_cow.h

@@ -0,0 +1,105 @@
+#ifndef SRC_NODE_THREADSAFE_COW_H_
+#define SRC_NODE_THREADSAFE_COW_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "util.h"
+#include "uv.h"
+
+#include <memory>   // std::shared_ptr<T>
+#include <utility>  // std::forward<T>
+
+namespace node {
+
+// Copy-on-write utility. Not threadsafe, i.e. there is no synchronization
+// of the copy operation with other operations.
+template <typename T>
+class CopyOnWrite final {
+ public:
+  template <typename... Args>
+  explicit CopyOnWrite(Args&&... args)
+      : data_(std::make_shared<T>(std::forward<Args>(args)...)) {}
+
+  CopyOnWrite(const CopyOnWrite<T>& other) = default;
+  CopyOnWrite& operator=(const CopyOnWrite<T>& other) = default;
+  CopyOnWrite(CopyOnWrite<T>&& other) = default;
+  CopyOnWrite& operator=(CopyOnWrite<T>&& other) = default;
+
+  const T* read() const { return data_.get(); }
+  T* write();
+
+  const T& operator*() const { return *read(); }
+  const T* operator->() const { return read(); }
+
+ private:
+  std::shared_ptr<T> data_;
+};
+
+// Threadsafe copy-on-write utility. Consumers need to use the Read and
+// Write helpers to access the target data structure.
+template <typename T>
+class ThreadsafeCopyOnWrite final {
+ private:
+  // Define this early since some of the public members depend on it
+  // and some compilers need it to be defined first in that case.
+  struct Impl {
+    explicit Impl(const T& data) : data(data) {}
+    explicit Impl(T&& data) : data(std::move(data)) {}
+
+    Impl(const Impl& other);
+    Impl& operator=(const Impl& other) = delete;
+    Impl(Impl&& other) = delete;
+    Impl& operator=(Impl&& other) = delete;
+
+    RwLock mutex;
+    T data;
+  };
+
+ public:
+  template <typename... Args>
+  ThreadsafeCopyOnWrite(Args&&... args)
+      : impl_(T(std::forward<Args>(args)...)) {}
+
+  ThreadsafeCopyOnWrite(const ThreadsafeCopyOnWrite<T>& other) = default;
+  ThreadsafeCopyOnWrite& operator=(const ThreadsafeCopyOnWrite<T>& other) =
+      default;
+  ThreadsafeCopyOnWrite(ThreadsafeCopyOnWrite<T>&& other) = default;
+  ThreadsafeCopyOnWrite& operator=(ThreadsafeCopyOnWrite<T>&& other) = default;
+
+  class Read {
+   public:
+    explicit Read(const ThreadsafeCopyOnWrite<T>* cow);
+
+    const T& operator*() const;
+    const T* operator->() const;
+
+   private:
+    const ThreadsafeCopyOnWrite<T>* cow_;
+    RwLock::ScopedReadLock lock_;
+  };
+
+  class Write {
+   public:
+    explicit Write(ThreadsafeCopyOnWrite<T>* cow);
+
+    T& operator*();
+    T* operator->();
+
+   private:
+    ThreadsafeCopyOnWrite<T>* cow_;
+    typename ThreadsafeCopyOnWrite<T>::Impl* impl_;
+    RwLock::ScopedLock lock_;
+  };
+
+  Read read() const { return Read(this); }
+  Write write() { return Write(this); }
+
+ private:
+  CopyOnWrite<Impl> impl_;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_THREADSAFE_COW_H_

package/src/headers/22/node_union_bytes.h

@@ -0,0 +1,81 @@
+
+#ifndef SRC_NODE_UNION_BYTES_H_
+#define SRC_NODE_UNION_BYTES_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "v8.h"
+
+namespace node {
+
+// An external resource intended to be used with static lifetime.
+template <typename Char, typename IChar, typename Base>
+class StaticExternalByteResource : public Base {
+  static_assert(sizeof(IChar) == sizeof(Char),
+                "incompatible interface and internal pointers");
+
+ public:
+  explicit StaticExternalByteResource(const Char* data,
+                                      size_t length,
+                                      std::shared_ptr<void> owning_ptr)
+      : data_(data), length_(length), owning_ptr_(owning_ptr) {}
+
+  const IChar* data() const override {
+    return reinterpret_cast<const IChar*>(data_);
+  }
+  size_t length() const override { return length_; }
+
+  void Dispose() override {
+    // We ignore Dispose calls from V8, even if we "own" a resource via
+    // owning_ptr_. All instantiations of this class are static or owned by a
+    // static map, and will be destructed when static variables are destructed.
+  }
+
+  StaticExternalByteResource(const StaticExternalByteResource&) = delete;
+  StaticExternalByteResource& operator=(const StaticExternalByteResource&) =
+      delete;
+
+ private:
+  const Char* data_;
+  const size_t length_;
+  std::shared_ptr<void> owning_ptr_;
+};
+
+using StaticExternalOneByteResource =
+    StaticExternalByteResource<uint8_t,
+                               char,
+                               v8::String::ExternalOneByteStringResource>;
+using StaticExternalTwoByteResource =
+    StaticExternalByteResource<uint16_t,
+                               uint16_t,
+                               v8::String::ExternalStringResource>;
+
+// Similar to a v8::String, but it's independent from Isolates
+// and can be materialized in Isolates as external Strings
+// via ToStringChecked.
+class UnionBytes {
+ public:
+  explicit UnionBytes(StaticExternalOneByteResource* one_byte_resource)
+      : one_byte_resource_(one_byte_resource), two_byte_resource_(nullptr) {}
+  explicit UnionBytes(StaticExternalTwoByteResource* two_byte_resource)
+      : one_byte_resource_(nullptr), two_byte_resource_(two_byte_resource) {}
+
+  UnionBytes(const UnionBytes&) = default;
+  UnionBytes& operator=(const UnionBytes&) = default;
+  UnionBytes(UnionBytes&&) = default;
+  UnionBytes& operator=(UnionBytes&&) = default;
+
+  bool is_one_byte() const { return one_byte_resource_ != nullptr; }
+
+  v8::Local<v8::String> ToStringChecked(v8::Isolate* isolate) const;
+
+ private:
+  StaticExternalOneByteResource* one_byte_resource_;
+  StaticExternalTwoByteResource* two_byte_resource_;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_UNION_BYTES_H_