@encharm/cws 4.5.3 → 4.6.0

package/src/headers/26/base_object_types.h

@@ -0,0 +1,76 @@
+#ifndef SRC_BASE_OBJECT_TYPES_H_
+#define SRC_BASE_OBJECT_TYPES_H_
+
+#include <cinttypes>
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+namespace node {
+// List of internalBinding() data wrappers. The first argument should match
+// what the class passes to SET_BINDING_ID(), the second argument should match
+// the C++ class name.
+#define SERIALIZABLE_BINDING_TYPES(V)                                          \
+  V(diagnostics_channel_binding_data, diagnostics_channel::BindingData)        \
+  V(encoding_binding_data, encoding_binding::BindingData)                      \
+  V(fs_binding_data, fs::BindingData)                                          \
+  V(mksnapshot_binding_data, mksnapshot::BindingData)                          \
+  V(v8_binding_data, v8_utils::BindingData)                                    \
+  V(blob_binding_data, BlobBindingData)                                        \
+  V(process_binding_data, process::BindingData)                                \
+  V(timers_binding_data, timers::BindingData)                                  \
+  V(url_binding_data, url::BindingData)                                        \
+  V(modules_binding_data, modules::BindingData)
+
+#define UNSERIALIZABLE_BINDING_TYPES(V)                                        \
+  V(http2_binding_data, http2::BindingData)                                    \
+  V(http_parser_binding_data, http_parser::BindingData)                        \
+  V(quic_binding_data, quic::BindingData)                                      \
+  V(sqlite_binding_data, sqlite::BindingData)
+
+// List of (non-binding) BaseObjects that are serializable in the snapshot.
+// The first argument should match what the type passes to
+// SET_OBJECT_ID(), the second argument should match the C++ class
+// name.
+#define SERIALIZABLE_NON_BINDING_TYPES(V)
+
+// Helper list of all binding data wrapper types.
+#define BINDING_TYPES(V)                                                       \
+  SERIALIZABLE_BINDING_TYPES(V)                                                \
+  UNSERIALIZABLE_BINDING_TYPES(V)
+
+// Helper list of all BaseObjects that implement snapshot support.
+#define SERIALIZABLE_OBJECT_TYPES(V)                                           \
+  SERIALIZABLE_BINDING_TYPES(V)                                                \
+  SERIALIZABLE_NON_BINDING_TYPES(V)
+
+#define V(TypeId, NativeType) k_##TypeId,
+enum class BindingDataType : uint8_t { BINDING_TYPES(V) kBindingDataTypeCount };
+// Make sure that we put the bindings first so that we can also use the enums
+// for the bindings as index to the binding data store.
+enum class EmbedderObjectType : uint8_t {
+  BINDING_TYPES(V) SERIALIZABLE_NON_BINDING_TYPES(V)
+  // We do not need to know about all the unserializable non-binding types for
+  // now so we do not list them.
+  kEmbedderObjectTypeCount
+};
+#undef V
+
+// For now, BaseObjects only need to call this when they implement snapshot
+// support.
+#define SET_OBJECT_ID(TypeId)                                                  \
+  static constexpr EmbedderObjectType type_int = EmbedderObjectType::k_##TypeId;
+
+// Binding data should call this so that they can be looked up from the binding
+// data store.
+#define SET_BINDING_ID(TypeId)                                                 \
+  static constexpr BindingDataType binding_type_int =                          \
+      BindingDataType::k_##TypeId;                                             \
+  SET_OBJECT_ID(TypeId)                                                        \
+  static_assert(static_cast<uint8_t>(type_int) ==                              \
+                static_cast<uint8_t>(binding_type_int));
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_BASE_OBJECT_TYPES_H_

package/src/headers/26/blob_serializer_deserializer-inl.h

@@ -0,0 +1,385 @@
+#ifndef SRC_BLOB_SERIALIZER_DESERIALIZER_INL_H_
+#define SRC_BLOB_SERIALIZER_DESERIALIZER_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "blob_serializer_deserializer.h"
+
+#include <ostream>
+#include <sstream>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include "debug_utils-inl.h"
+
+// This is related to the blob that is used in snapshots and single executable
+// applications and has nothing to do with `node_blob.h`.
+
+namespace node {
+
+struct EnvSerializeInfo;
+struct PropInfo;
+struct RealmSerializeInfo;
+
+namespace builtins {
+struct CodeCacheInfo;
+}  // namespace builtins
+
+// These operator<< overload declarations are needed because
+// BlobSerializerDeserializer::ToStr() uses these.
+
+std::ostream& operator<<(std::ostream& output,
+                         const builtins::CodeCacheInfo& info);
+
+std::ostream& operator<<(std::ostream& output,
+                         const std::vector<builtins::CodeCacheInfo>& vec);
+
+std::ostream& operator<<(std::ostream& output, const std::vector<uint8_t>& vec);
+
+std::ostream& operator<<(std::ostream& output,
+                         const std::vector<PropInfo>& vec);
+
+std::ostream& operator<<(std::ostream& output, const PropInfo& info);
+
+std::ostream& operator<<(std::ostream& output,
+                         const std::vector<std::string>& vec);
+
+std::ostream& operator<<(std::ostream& output, const RealmSerializeInfo& i);
+
+std::ostream& operator<<(std::ostream& output, const EnvSerializeInfo& i);
+
+template <typename... Args>
+void BlobSerializerDeserializer::Debug(const char* format,
+                                       Args&&... args) const {
+  if (is_debug) {
+    FPrintF(stderr, format, std::forward<Args>(args)...);
+  }
+}
+
+template <typename T>
+std::string BlobSerializerDeserializer::ToStr(const T& arg) const {
+  std::stringstream ss;
+  ss << arg;
+  return ss.str();
+}
+
+template <typename T>
+std::string BlobSerializerDeserializer::GetName() const {
+#define TYPE_LIST(V)                                                           \
+  V(builtins::CodeCacheInfo)                                                   \
+  V(PropInfo)                                                                  \
+  V(std::string)
+
+#define V(TypeName)                                                            \
+  if constexpr (std::is_same_v<T, TypeName>) {                                 \
+    return #TypeName;                                                          \
+  } else  // NOLINT(readability/braces)
+  TYPE_LIST(V)
+#undef V
+
+  if constexpr (std::is_arithmetic_v<T>) {
+    return (std::is_unsigned_v<T>   ? "uint"
+            : std::is_integral_v<T> ? "int"
+                                    : "float") +
+           std::to_string(sizeof(T) * 8) + "_t";
+  }
+  return "";
+}
+
+// Helper for reading numeric types.
+template <typename Impl>
+template <typename T>
+  requires std::is_arithmetic_v<T>
+T BlobDeserializer<Impl>::ReadArithmetic() {
+  T result;
+  ReadArithmetic(&result, 1);
+  return result;
+}
+
+// Layout of vectors:
+// [ 4/8 bytes ] count
+// [   ...     ] contents (count * size of individual elements)
+template <typename Impl>
+template <typename T>
+std::vector<T> BlobDeserializer<Impl>::ReadVector() {
+  if (is_debug) {
+    std::string name = GetName<T>();
+    Debug("\nReadVector<%s>()(%d-byte)\n", name, sizeof(T));
+  }
+  size_t count = static_cast<size_t>(ReadArithmetic<size_t>());
+  if (count == 0) {
+    return std::vector<T>();
+  }
+  if (is_debug) {
+    Debug("Reading %d vector elements...\n", count);
+  }
+  std::vector<T> result;
+  if constexpr (std::is_arithmetic_v<T>) {
+    result = ReadArithmeticVector<T>(count);
+  } else {
+    result = ReadNonArithmeticVector<T>(count);
+  }
+  if (is_debug) {
+    std::string str = std::is_arithmetic_v<T> ? "" : ToStr(result);
+    std::string name = GetName<T>();
+    Debug("ReadVector<%s>() read %s\n", name, str);
+  }
+  return result;
+}
+
+template <typename Impl>
+std::string BlobDeserializer<Impl>::ReadString() {
+  std::string_view view = ReadStringView(StringLogMode::kAddressAndContent);
+  return std::string(view);
+}
+
+template <typename Impl>
+std::string_view BlobDeserializer<Impl>::ReadStringView(StringLogMode mode) {
+  size_t length = ReadArithmetic<size_t>();
+  Debug("ReadStringView(), length=%zu: ", length);
+
+  if (length == 0) {
+    Debug("ReadStringView() read an empty view\n");
+    return std::string_view();
+  }
+
+  std::string_view result(sink.data() + read_total, length);
+  Debug("%p, read %zu bytes", result.data(), result.size());
+  if (mode == StringLogMode::kAddressAndContent) {
+    Debug(", content:%s%s", length > 32 ? "\n" : " ", result);
+  }
+  Debug("\n");
+
+  read_total += length;
+  return result;
+}
+
+// Helper for reading an array of numeric types.
+template <typename Impl>
+template <typename T>
+  requires std::is_arithmetic_v<T>
+void BlobDeserializer<Impl>::ReadArithmetic(T* out, size_t count) {
+  DCHECK_GT(count, 0);  // Should not read contents for vectors of size 0.
+  if (is_debug) {
+    std::string name = GetName<T>();
+    Debug("Read<%s>()(%d-byte), count=%d: ", name, sizeof(T), count);
+  }
+
+  size_t size = sizeof(T) * count;
+  memcpy(out, sink.data() + read_total, size);
+
+  if (is_debug) {
+    std::string str =
+        "{ " + std::to_string(out[0]) + (count > 1 ? ", ... }" : " }");
+    Debug("%s, read %zu bytes\n", str, size);
+  }
+  read_total += size;
+}
+
+// Helper for reading numeric vectors.
+template <typename Impl>
+template <typename Number>
+  requires std::is_arithmetic_v<Number>
+std::vector<Number> BlobDeserializer<Impl>::ReadArithmeticVector(size_t count) {
+  DCHECK_GT(count, 0);  // Should not read contents for vectors of size 0.
+  std::vector<Number> result(count);
+  ReadArithmetic(result.data(), count);
+  return result;
+}
+
+// Helper for reading non-numeric vectors.
+template <typename Impl>
+template <typename T>
+  requires(!std::is_arithmetic_v<T>)
+std::vector<T> BlobDeserializer<Impl>::ReadNonArithmeticVector(size_t count) {
+  DCHECK_GT(count, 0);  // Should not read contents for vectors of size 0.
+  std::vector<T> result;
+  result.reserve(count);
+  bool original_is_debug = is_debug;
+  is_debug = original_is_debug && !std::is_same_v<T, std::string>;
+  for (size_t i = 0; i < count; ++i) {
+    if (is_debug) {
+      Debug("\n[%d] ", i);
+    }
+    result.push_back(ReadElement<T>());
+  }
+  is_debug = original_is_debug;
+
+  return result;
+}
+
+template <typename Impl>
+template <typename T>
+T BlobDeserializer<Impl>::ReadElement() {
+  if constexpr (std::is_arithmetic_v<T>) {
+    return ReadArithmetic<T>();
+  } else if constexpr (std::is_same_v<T, std::string>) {
+    return ReadString();
+  } else {
+    return impl()->template Read<T>();
+  }
+}
+
+// Helper for writing numeric types.
+template <typename Impl>
+template <typename T>
+  requires std::is_arithmetic_v<T>
+size_t BlobSerializer<Impl>::WriteArithmetic(const T& data) {
+  return WriteArithmetic(&data, 1);
+}
+
+// Layout of vectors:
+// [ 4/8 bytes ] count
+// [   ...     ] contents (count * size of individual elements)
+template <typename Impl>
+template <typename T>
+size_t BlobSerializer<Impl>::WriteVector(const std::vector<T>& data) {
+  if (is_debug) {
+    std::string str = std::is_arithmetic_v<T> ? "" : ToStr(data);
+    std::string name = GetName<T>();
+    Debug("\nAt 0x%x: WriteVector<%s>() (%d-byte), count=%d: %s\n",
+          sink.size(),
+          name,
+          sizeof(T),
+          data.size(),
+          str);
+  }
+
+  size_t written_total = WriteArithmetic<size_t>(data.size());
+  if (data.empty()) {
+    return written_total;
+  }
+
+  if constexpr (std::is_arithmetic_v<T>) {
+    written_total += WriteArithmeticVector<T>(data);
+  } else {
+    written_total += WriteNonArithmeticVector<T>(data);
+  }
+
+  if (is_debug) {
+    std::string name = GetName<T>();
+    Debug("WriteVector<%s>() wrote %d bytes\n", name, written_total);
+  }
+
+  return written_total;
+}
+
+// The layout of a written string:
+// [  4/8 bytes     ] length
+// [ |length| bytes ] contents
+template <typename Impl>
+size_t BlobSerializer<Impl>::WriteStringView(std::string_view data,
+                                             StringLogMode mode) {
+  Debug("At 0x%x: WriteStringView(), length=%zu: %p\n",
+        sink.size(),
+        data.size(),
+        data.data());
+  size_t written_total = WriteArithmetic<size_t>(data.size());
+
+  size_t length = data.size();
+  if (length == 0) {
+    Debug("WriteStringView() wrote an empty view\n");
+    return written_total;
+  }
+  sink.insert(sink.end(), data.data(), data.data() + length);
+  written_total += length;
+
+  Debug("WriteStringView() wrote %zu bytes\n", written_total);
+  if (mode == StringLogMode::kAddressAndContent) {
+    Debug("%s", data);
+  }
+
+  return written_total;
+}
+
+template <typename Impl>
+size_t BlobSerializer<Impl>::WriteString(const std::string& data) {
+  return WriteStringView(data, StringLogMode::kAddressAndContent);
+}
+
+static size_t kPreviewCount = 16;
+
+// Helper for writing an array of numeric types.
+template <typename Impl>
+template <typename T>
+  requires std::is_arithmetic_v<T>
+size_t BlobSerializer<Impl>::WriteArithmetic(const T* data, size_t count) {
+  DCHECK_GT(count, 0);  // Should not write contents for vectors of size 0.
+  if (is_debug) {
+    size_t preview_count = count < kPreviewCount ? count : kPreviewCount;
+    std::string str = "{ ";
+    for (size_t i = 0; i < preview_count; ++i) {
+      str += (std::to_string(data[i]) + ",");
+    }
+    if (count > preview_count) {
+      str += "...";
+    }
+    str += "}";
+    std::string name = GetName<T>();
+    Debug("At 0x%x: Write<%s>() (%zu-byte), count=%zu: %s",
+          sink.size(),
+          name,
+          sizeof(T),
+          count,
+          str);
+  }
+
+  size_t size = sizeof(T) * count;
+  const char* pos = reinterpret_cast<const char*>(data);
+  sink.insert(sink.end(), pos, pos + size);
+
+  if (is_debug) {
+    Debug(", wrote %zu bytes\n", size);
+  }
+  return size;
+}
+
+// Helper for writing numeric vectors.
+template <typename Impl>
+template <typename Number>
+  requires std::is_arithmetic_v<Number>
+size_t BlobSerializer<Impl>::WriteArithmeticVector(
+    const std::vector<Number>& data) {
+  return WriteArithmetic(data.data(), data.size());
+}
+
+// Helper for writing non-numeric vectors.
+template <typename Impl>
+template <typename T>
+  requires(!std::is_arithmetic_v<T>)
+size_t
+    BlobSerializer<Impl>::WriteNonArithmeticVector(const std::vector<T>& data) {
+  DCHECK_GT(data.size(),
+            0);  // Should not write contents for vectors of size 0.
+  size_t written_total = 0;
+  bool original_is_debug = is_debug;
+  is_debug = original_is_debug && !std::is_same_v<T, std::string>;
+  for (size_t i = 0; i < data.size(); ++i) {
+    if (is_debug) {
+      Debug("\n[%d] ", i);
+    }
+    written_total += WriteElement<T>(data[i]);
+  }
+  is_debug = original_is_debug;
+
+  return written_total;
+}
+
+template <typename Impl>
+template <typename T>
+size_t BlobSerializer<Impl>::WriteElement(const T& data) {
+  if constexpr (std::is_arithmetic_v<T>) {
+    return WriteArithmetic<T>(data);
+  } else if constexpr (std::is_same_v<T, std::string>) {
+    return WriteString(data);
+  } else {
+    return impl()->template Write<T>(data);
+  }
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_BLOB_SERIALIZER_DESERIALIZER_INL_H_

package/src/headers/26/blob_serializer_deserializer.h

@@ -0,0 +1,142 @@
+#ifndef SRC_BLOB_SERIALIZER_DESERIALIZER_H_
+#define SRC_BLOB_SERIALIZER_DESERIALIZER_H_
+
+#include <concepts>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+// This is related to the blob that is used in snapshots and single executable
+// applications and has nothing to do with `node_blob.h`.
+
+namespace node {
+
+class BlobSerializerDeserializer {
+ public:
+  explicit BlobSerializerDeserializer(bool is_debug_v) : is_debug(is_debug_v) {}
+
+  template <typename... Args>
+  void Debug(const char* format, Args&&... args) const;
+
+  template <typename T>
+  std::string ToStr(const T& arg) const;
+
+  template <typename T>
+  std::string GetName() const;
+
+  bool is_debug = false;
+};
+
+enum class StringLogMode {
+  kAddressOnly,  // Can be used when the string contains binary content.
+  kAddressAndContent,
+};
+
+// Child classes are expected to implement T Read<T>() where
+// !std::is_arithmetic_v<T> && !std::is_same_v<T, std::string>
+template <typename Impl>
+class BlobDeserializer : public BlobSerializerDeserializer {
+ public:
+  explicit BlobDeserializer(bool is_debug_v, std::string_view s)
+      : BlobSerializerDeserializer(is_debug_v), sink(s) {}
+  ~BlobDeserializer() = default;
+
+  size_t read_total = 0;
+  std::string_view sink;
+
+  Impl* impl() { return static_cast<Impl*>(this); }
+  const Impl* impl() const { return static_cast<const Impl*>(this); }
+
+  // Helper for reading numeric types.
+  template <typename T>
+    requires std::is_arithmetic_v<T>
+  T ReadArithmetic();
+
+  // Layout of vectors:
+  // [ 4/8 bytes ] count
+  // [   ...     ] contents (count * size of individual elements)
+  template <typename T>
+  std::vector<T> ReadVector();
+
+  // ReadString() creates a copy of the data. ReadStringView() doesn't.
+  std::string ReadString();
+  std::string_view ReadStringView(StringLogMode mode);
+
+  // Helper for reading an array of numeric types.
+  template <typename T>
+    requires std::is_arithmetic_v<T>
+  void ReadArithmetic(T* out, size_t count);
+
+  // Helper for reading numeric vectors.
+  template <typename Number>
+    requires std::is_arithmetic_v<Number>
+  std::vector<Number> ReadArithmeticVector(size_t count);
+
+ private:
+  // Helper for reading non-numeric vectors.
+  template <typename T>
+    requires(!std::is_arithmetic_v<T>)
+  std::vector<T> ReadNonArithmeticVector(size_t count);
+
+  template <typename T>
+  T ReadElement();
+};
+
+// Child classes are expected to implement size_t Write<T>(const T&) where
+// !std::is_arithmetic_v<T> && !std::is_same_v<T, std::string>
+template <typename Impl>
+class BlobSerializer : public BlobSerializerDeserializer {
+ public:
+  explicit BlobSerializer(bool is_debug_v)
+      : BlobSerializerDeserializer(is_debug_v) {}
+  ~BlobSerializer() = default;
+
+  Impl* impl() { return static_cast<Impl*>(this); }
+  const Impl* impl() const { return static_cast<const Impl*>(this); }
+
+  std::vector<char> sink;
+
+  // Helper for writing numeric types.
+  template <typename T>
+    requires std::is_arithmetic_v<T>
+  size_t WriteArithmetic(const T& data);
+
+  // Layout of vectors:
+  // [ 4/8 bytes ] count
+  // [   ...     ] contents (count * size of individual elements)
+  template <typename T>
+  size_t WriteVector(const std::vector<T>& data);
+
+  // The layout of a written string:
+  // [  4/8 bytes     ] length
+  // [ |length| bytes ] contents
+  size_t WriteStringView(std::string_view data, StringLogMode mode);
+  size_t WriteString(const std::string& data);
+
+  // Helper for writing an array of numeric types.
+  template <typename T>
+    requires std::is_arithmetic_v<T>
+  size_t WriteArithmetic(const T* data, size_t count);
+
+  // Helper for writing numeric vectors.
+  template <typename Number>
+    requires std::is_arithmetic_v<Number>
+  size_t WriteArithmeticVector(const std::vector<Number>& data);
+
+ private:
+  // Helper for writing non-numeric vectors.
+  template <typename T>
+    requires(!std::is_arithmetic_v<T>)
+  size_t WriteNonArithmeticVector(const std::vector<T>& data);
+
+  template <typename T>
+  size_t WriteElement(const T& data);
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_BLOB_SERIALIZER_DESERIALIZER_H_

package/src/headers/26/builtin_info.h

@@ -0,0 +1,57 @@
+#ifndef SRC_BUILTIN_INFO_H_
+#define SRC_BUILTIN_INFO_H_
+
+#include <cinttypes>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+// This file must not depend on node.h or other code that depends on
+// the full Node.js implementation because it is used during the
+// compilation of the Node.js implementation itself (especially js2c).
+
+namespace node {
+namespace builtins {
+
+enum class BuiltinSourceType {
+  kBootstrapRealm,    // internal/bootstrap/realm
+  kBootstrapScript,   // internal/bootstrap/*
+  kPerContextScript,  // internal/per_context/*
+  kMainScript,        // internal/main/*
+  kFunction,          // others
+  kSourceTextModule,  // selected modules, ends with .mjs in source
+};
+
+struct BuiltinInfo {
+  // C++17 inline static
+  inline static const std::unordered_map<BuiltinSourceType,
+                                         std::vector<std::string>>
+      parameter_map{
+          {BuiltinSourceType::kBootstrapRealm,
+           {"process",
+            "getLinkedBinding",
+            "getInternalBinding",
+            "primordials"}},
+          {BuiltinSourceType::kBootstrapScript,
+           {"process", "require", "internalBinding", "primordials"}},
+          {BuiltinSourceType::kPerContextScript,
+           {"exports", "primordials", "privateSymbols", "perIsolateSymbols"}},
+          {BuiltinSourceType::kMainScript,
+           {"process", "require", "internalBinding", "primordials"}},
+          {BuiltinSourceType::kFunction,
+           {"exports",
+            "require",
+            "module",
+            "process",
+            "internalBinding",
+            "primordials"}},
+      };
+};
+
+std::string GetBuiltinSourceTypeName(BuiltinSourceType type);
+BuiltinSourceType GetBuiltinSourceType(const std::string& id,
+                                       const std::string& filename);
+}  // namespace builtins
+}  // namespace node
+
+#endif  // SRC_BUILTIN_INFO_H_