libv8-node 22.7.0.3-x86_64-linux → 23.6.1.0-x86_64-linux

data/vendor/v8/include/v8-primitive.h

@@ -223,6 +223,12 @@ class V8_EXPORT String : public Name {
    */
   bool IsExternalOneByte() const;
 
+  /**
+   * Returns the internalized string. See `NewStringType::kInternalized` for
+   * details on internalized strings.
+   */
+  Local<String> InternalizeString(Isolate* isolate);
+
   class V8_EXPORT ExternalStringResourceBase {
    public:
     virtual ~ExternalStringResourceBase() = default;
@@ -382,6 +388,8 @@ class V8_EXPORT String : public Name {
    * regardless of the encoding, otherwise return NULL.  The encoding of the
    * string is returned in encoding_out.
    */
+  V8_INLINE ExternalStringResourceBase* GetExternalStringResourceBase(
+      v8::Isolate* isolate, Encoding* encoding_out) const;
   V8_INLINE ExternalStringResourceBase* GetExternalStringResourceBase(
       Encoding* encoding_out) const;
 
@@ -507,10 +515,15 @@ class V8_EXPORT String : public Name {
    * (e.g. due to an exception in the toString() method of the object)
    * then the length() method returns 0 and the * operator returns
    * NULL.
+   *
+   * WARNING: This will unconditionally copy the contents of the JavaScript
+   * string, and should be avoided in situations where performance is a concern.
+   * Consider using WriteUtf8() instead.
    */
   class V8_EXPORT Utf8Value {
    public:
-    Utf8Value(Isolate* isolate, Local<v8::Value> obj);
+    Utf8Value(Isolate* isolate, Local<v8::Value> obj,
+              WriteOptions options = REPLACE_INVALID_UTF8);
     ~Utf8Value();
     char* operator*() { return str_; }
     const char* operator*() const { return str_; }
@@ -527,12 +540,19 @@ class V8_EXPORT String : public Name {
 
   /**
    * Converts an object to a two-byte (UTF-16-encoded) string.
+   *
    * If conversion to a string fails (eg. due to an exception in the toString()
    * method of the object) then the length() method returns 0 and the * operator
    * returns NULL.
+   *
+   * WARNING: This will unconditionally copy the contents of the JavaScript
+   * string, and should be avoided in situations where performance is a concern.
    */
   class V8_EXPORT Value {
    public:
+    V8_DEPRECATE_SOON(
+        "Prefer using String::ValueView if you can, or string->Write to a "
+        "buffer if you cannot.")
     Value(Isolate* isolate, Local<v8::Value> obj);
     ~Value();
     uint16_t* operator*() { return str_; }
@@ -548,6 +568,55 @@ class V8_EXPORT String : public Name {
     int length_;
   };
 
+  /**
+   * Returns a view onto a string's contents.
+   *
+   * WARNING: This does not copy the string's contents, and will therefore be
+   * invalidated if the GC can move the string while the ValueView is alive. It
+   * is therefore required that no GC or allocation can happen while there is an
+   * active ValueView. This requirement may be relaxed in the future.
+   *
+   * V8 strings are either encoded as one-byte or two-bytes per character.
+   */
+  class V8_EXPORT ValueView {
+   public:
+    ValueView(Isolate* isolate, Local<v8::String> str);
+    ~ValueView();
+    const uint8_t* data8() const {
+#if V8_ENABLE_CHECKS
+      CheckOneByte(true);
+#endif
+      return data8_;
+    }
+    const uint16_t* data16() const {
+#if V8_ENABLE_CHECKS
+      CheckOneByte(false);
+#endif
+      return data16_;
+    }
+    int length() const { return length_; }
+    bool is_one_byte() const { return is_one_byte_; }
+
+    // Disallow copying and assigning.
+    ValueView(const ValueView&) = delete;
+    void operator=(const ValueView&) = delete;
+
+   private:
+    void CheckOneByte(bool is_one_byte) const;
+
+    Local<v8::String> flat_str_;
+    union {
+      const uint8_t* data8_;
+      const uint16_t* data16_;
+    };
+    int length_;
+    bool is_one_byte_;
+    // Avoid exposing the internal DisallowGarbageCollection scope.
+    alignas(internal::Internals::
+                kDisallowGarbageCollectionAlign) char no_gc_debug_scope_
+        [internal::Internals::kDisallowGarbageCollectionSize];
+  };
+
  private:
   void VerifyExternalStringResourceBase(ExternalStringResourceBase* v,
                                         Encoding encoding) const;
@@ -811,6 +880,28 @@ String::ExternalStringResource* String::GetExternalStringResource() const {
   return result;
 }
 
+String::ExternalStringResourceBase* String::GetExternalStringResourceBase(
+    v8::Isolate* isolate, String::Encoding* encoding_out) const {
+  using A = internal::Address;
+  using I = internal::Internals;
+  A obj = internal::ValueHelper::ValueAsAddress(this);
+  int type = I::GetInstanceType(obj) & I::kStringRepresentationAndEncodingMask;
+  *encoding_out = static_cast<Encoding>(type & I::kStringEncodingMask);
+  ExternalStringResourceBase* resource;
+  if (type == I::kExternalOneByteRepresentationTag ||
+      type == I::kExternalTwoByteRepresentationTag) {
+    A value = I::ReadExternalPointerField<internal::kExternalStringResourceTag>(
+        isolate, obj, I::kStringResourceOffset);
+    resource = reinterpret_cast<ExternalStringResourceBase*>(value);
+  } else {
+    resource = GetExternalStringResourceBaseSlow(encoding_out);
+  }
+#ifdef V8_ENABLE_CHECKS
+  VerifyExternalStringResourceBase(resource, *encoding_out);
+#endif
+  return resource;
+}
+
 String::ExternalStringResourceBase* String::GetExternalStringResourceBase(
     String::Encoding* encoding_out) const {
   using A = internal::Address;

data/vendor/v8/include/v8-profiler.h

@@ -899,9 +899,28 @@ class V8_EXPORT EmbedderGraph {
   /**
    * Returns a node corresponding to the given V8 value. Ownership is not
    * transferred. The result pointer is valid while the graph is alive.
+   *
+   * For now the variant that takes v8::Data is not marked as abstract for
+   * compatibility, but embedders who subclass EmbedderGraph are expected to
+   * implement it. Then in the implementation of the variant that takes
+   * v8::Value, they can simply forward the call to the one that takes
+   * v8::Local<v8::Data>.
    */
   virtual Node* V8Node(const v8::Local<v8::Value>& value) = 0;
 
+  /**
+   * Returns a node corresponding to the given V8 value. Ownership is not
+   * transferred. The result pointer is valid while the graph is alive.
+   *
+   * For API compatibility, this default implementation just checks that the
+   * data is a v8::Value and forward it to the variant that takes v8::Value,
+   * which is currently required to be implemented. In the future we'll remove
+   * the v8::Value variant, and make this variant that takes v8::Data abstract
+   * instead. If the embedder subclasses v8::EmbedderGraph and also use
+   * v8::TracedReference<v8::Data>, they must override this variant.
+   */
+  virtual Node* V8Node(const v8::Local<v8::Data>& value);
+
   /**
    * Adds the given node to the graph and takes ownership of the node.
    * Returns a raw pointer to the node that is valid while the graph is alive.
@@ -956,7 +975,7 @@ class V8_EXPORT HeapProfiler {
 
   /**
    * Callback function invoked during heap snapshot generation to retrieve
-   * the detachedness state of an object referenced by a TracedReference.
+   * the detachedness state of a JS object referenced by a TracedReference.
    *
    * The callback takes Local<Value> as parameter to allow the embedder to
    * unpack the TracedReference into a Local and reuse that Local for different
@@ -1090,6 +1109,12 @@ class V8_EXPORT HeapProfiler {
       ObjectNameResolver* global_object_name_resolver = nullptr,
       bool hide_internals = true, bool capture_numeric_value = false);
 
+  /**
+   * Obtains list of Detached JS Wrapper Objects. This functon calls garbage
+   * collection, then iterates over traced handles in the isolate
+   */
+  std::vector<v8::Local<v8::Value>> GetDetachedJSWrapperObjects();
+
   /**
    * Starts tracking of heap objects population statistics. After calling
    * this method, all heap objects relocations done by the garbage collector
@@ -1179,6 +1204,18 @@ class V8_EXPORT HeapProfiler {
 
   void SetGetDetachednessCallback(GetDetachednessCallback callback, void* data);
 
+  /**
+   * Returns whether the heap profiler is currently taking a snapshot.
+   */
+  bool IsTakingSnapshot();
+
+  /**
+   * Allocates a copy of the provided string within the heap snapshot generator
+   * and returns a pointer to the copy. May only be called during heap snapshot
+   * generation.
+   */
+  const char* CopyNameForHeapSnapshot(const char* name);
+
   /**
    * Default value of persistent handle class ID. Must not be used to
    * define a class. Can be used to reset a class of a persistent

data/vendor/v8/include/v8-promise.h

@@ -14,7 +14,7 @@ namespace v8 {
 class Context;
 
 #ifndef V8_PROMISE_INTERNAL_FIELD_COUNT
-// The number of required internal fields can be defined by embedder.
+// Defined using gn arg `v8_promise_internal_field_count`.
 #define V8_PROMISE_INTERNAL_FIELD_COUNT 0
 #endif
 
@@ -115,7 +115,7 @@ class V8_EXPORT Promise : public Object {
     return static_cast<Promise*>(value);
   }
 
-  static const int kEmbedderFieldCount = V8_PROMISE_INTERNAL_FIELD_COUNT;
+  static constexpr int kEmbedderFieldCount = V8_PROMISE_INTERNAL_FIELD_COUNT;
 
  private:
   Promise();

data/vendor/v8/include/v8-sandbox.h

@@ -0,0 +1,173 @@
+// Copyright 2024 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef INCLUDE_V8_SANDBOX_H_
+#define INCLUDE_V8_SANDBOX_H_
+
+#include <cstdint>
+
+#include "v8-internal.h"  // NOLINT(build/include_directory)
+#include "v8config.h"     // NOLINT(build/include_directory)
+
+namespace v8 {
+
+/**
+ * A pointer tag used for wrapping and unwrapping `CppHeap` pointers as used
+ * with JS API wrapper objects that rely on `v8::Object::Wrap()` and
+ * `v8::Object::Unwrap()`.
+ *
+ * The CppHeapPointers use a range-based type checking scheme, where on access
+ * to a pointer, the actual type of the pointer is checked to be within a
+ * specified range of types. This allows supporting type hierarchies, where a
+ * type check for a supertype must succeed for any subtype.
+ *
+ * The tag is currently in practice limited to 15 bits since it needs to fit
+ * together with a marking bit into the unused parts of a pointer (the top 16
+ * bits).
+ */
+enum class CppHeapPointerTag : uint16_t {
+  kFirstTag = 0,
+  kNullTag = 0,
+
+  /**
+   *  The lower type ids are reserved for the embedder to assign. For that, the
+   * main requirement is that all (transitive) child classes of a given parent
+   * class have type ids in the same range, and that there are no unrelated
+   * types in that range. For example, given the following type hierarchy:
+   *
+   *          A     F
+   *         / \
+   *        B   E
+   *       / \
+   *      C   D
+   *
+   * a potential type id assignment that satistifes these requirements is
+   * {C: 0, D: 1, B: 2, A: 3, E: 4, F: 5}. With that, the type check for type A
+   * would check for the range [0, 4], while the check for B would check range
+   * [0, 2], and for F it would simply check [5, 5].
+   *
+   * In addition, there is an option for performance tweaks: if the size of the
+   * type range corresponding to a supertype is a power of two and starts at a
+   * power of two (e.g. [0x100, 0x13f]), then the compiler can often optimize
+   * the type check to use even fewer instructions (essentially replace a AND +
+   * SUB with a single AND).
+   */
+
+  kDefaultTag = 0x7000,
+
+  kZappedEntryTag = 0x7ffd,
+  kEvacuationEntryTag = 0x7ffe,
+  kFreeEntryTag = 0x7fff,
+  // The tags are limited to 15 bits, so the last tag is 0x7fff.
+  kLastTag = 0x7fff,
+};
+
+// Convenience struct to represent tag ranges. This is used for type checks
+// against supertypes, which cover a range of types (their subtypes).
+// Both the lower- and the upper bound are inclusive. In other words, this
+// struct represents the range [lower_bound, upper_bound].
+struct CppHeapPointerTagRange {
+  constexpr CppHeapPointerTagRange(CppHeapPointerTag lower,
+                                   CppHeapPointerTag upper)
+      : lower_bound(lower), upper_bound(upper) {}
+  CppHeapPointerTag lower_bound;
+  CppHeapPointerTag upper_bound;
+
+  // Check whether the tag of the given CppHeapPointerTable entry is within
+  // this range. This method encodes implementation details of the
+  // CppHeapPointerTable, which is necessary as it is used by
+  // ReadCppHeapPointerField below.
+  // Returns true if the check is successful and the tag of the given entry is
+  // within this range, false otherwise.
+  bool CheckTagOf(uint64_t entry) {
+    // Note: the cast to uint32_t is important here. Otherwise, the uint16_t's
+    // would be promoted to int in the range check below, which would result in
+    // undefined behavior (signed integer undeflow) if the actual value is less
+    // than the lower bound. Then, the compiler would take advantage of the
+    // undefined behavior and turn the range check into a simple
+    // `actual_tag <= last_tag` comparison, which is incorrect.
+    uint32_t actual_tag = static_cast<uint16_t>(entry);
+    // The actual_tag is shifted to the left by one and contains the marking
+    // bit in the LSB. To ignore that during the type check, simply add one to
+    // the (shifted) range.
+    constexpr int kTagShift = internal::kCppHeapPointerTagShift;
+    uint32_t first_tag = static_cast<uint32_t>(lower_bound) << kTagShift;
+    uint32_t last_tag = (static_cast<uint32_t>(upper_bound) << kTagShift) + 1;
+    return actual_tag >= first_tag && actual_tag <= last_tag;
+  }
+};
+
+constexpr CppHeapPointerTagRange kAnyCppHeapPointer(
+    CppHeapPointerTag::kFirstTag, CppHeapPointerTag::kLastTag);
+
+class SandboxHardwareSupport {
+ public:
+  /**
+   * Initialize sandbox hardware support. This needs to be called before
+   * creating any thread that might access sandbox memory since it sets up
+   * hardware permissions to the memory that will be inherited on clone.
+   */
+  V8_EXPORT static void InitializeBeforeThreadCreation();
+};
+
+namespace internal {
+
+#ifdef V8_COMPRESS_POINTERS
+V8_INLINE static Address* GetCppHeapPointerTableBase(v8::Isolate* isolate) {
+  Address addr = reinterpret_cast<Address>(isolate) +
+                 Internals::kIsolateCppHeapPointerTableOffset +
+                 Internals::kExternalPointerTableBasePointerOffset;
+  return *reinterpret_cast<Address**>(addr);
+}
+#endif  // V8_COMPRESS_POINTERS
+
+template <typename T>
+V8_INLINE static T* ReadCppHeapPointerField(v8::Isolate* isolate,
+                                            Address heap_object_ptr, int offset,
+                                            CppHeapPointerTagRange tag_range) {
+#ifdef V8_COMPRESS_POINTERS
+  // See src/sandbox/cppheap-pointer-table-inl.h. Logic duplicated here so
+  // it can be inlined and doesn't require an additional call.
+  const CppHeapPointerHandle handle =
+      Internals::ReadRawField<CppHeapPointerHandle>(heap_object_ptr, offset);
+  const uint32_t index = handle >> kExternalPointerIndexShift;
+  const Address* table = GetCppHeapPointerTableBase(isolate);
+  const std::atomic<Address>* ptr =
+      reinterpret_cast<const std::atomic<Address>*>(&table[index]);
+  Address entry = std::atomic_load_explicit(ptr, std::memory_order_relaxed);
+
+  Address pointer = entry;
+  if (V8_LIKELY(tag_range.CheckTagOf(entry))) {
+    pointer = entry >> kCppHeapPointerPayloadShift;
+  } else {
+    // If the type check failed, we simply return nullptr here. That way:
+    //  1. The null handle always results in nullptr being returned here, which
+    //     is a desired property. Otherwise, we would need an explicit check for
+    //     the null handle above, and therefore an additional branch. This
+    //     works because the 0th entry of the table always contains nullptr
+    //     tagged with the null tag (i.e. an all-zeros entry). As such,
+    //     regardless of whether the type check succeeds, the result will
+    //     always be nullptr.
+    //  2. The returned pointer is guaranteed to crash even on platforms with
+    //     top byte ignore (TBI), such as Arm64. The alternative would be to
+    //     simply return the original entry with the left-shifted payload.
+    //     However, due to TBI, an access to that may not always result in a
+    //     crash (specifically, if the second most significant byte happens to
+    //     be zero). In addition, there shouldn't be a difference on Arm64
+    //     between returning nullptr or the original entry, since it will
+    //     simply compile to a `csel x0, x8, xzr, lo` instead of a
+    //     `csel x0, x10, x8, lo` instruction.
+    pointer = 0;
+  }
+  return reinterpret_cast<T*>(pointer);
+#else   // !V8_COMPRESS_POINTERS
+  return reinterpret_cast<T*>(
+      Internals::ReadRawField<Address>(heap_object_ptr, offset));
+#endif  // !V8_COMPRESS_POINTERS
+}
+
+}  // namespace internal
+}  // namespace v8
+
+#endif  // INCLUDE_V8_SANDBOX_H_

data/vendor/v8/include/v8-script.h

@@ -210,7 +210,7 @@ class V8_EXPORT Module : public Data {
 
   using ResolveModuleCallback = MaybeLocal<Module> (*)(
       Local<Context> context, Local<String> specifier,
-      Local<FixedArray> import_assertions, Local<Module> referrer);
+      Local<FixedArray> import_attributes, Local<Module> referrer);
 
   /**
    * Instantiates the module and its dependencies.
@@ -322,6 +322,14 @@ class V8_EXPORT Module : public Data {
   static void CheckCast(Data* obj);
 };
 
+class V8_EXPORT CompileHintsCollector : public Data {
+ public:
+  /**
+   * Returns the positions of lazy functions which were compiled and executed.
+   */
+  std::vector<int> GetCompileHints(Isolate* isolate) const;
+};
+
 /**
  * A compiled JavaScript script, tied to a Context which was active when the
  * script was compiled.
@@ -359,7 +367,15 @@ class V8_EXPORT Script : public Data {
    * If the script was compiled, returns the positions of lazy functions which
    * were eventually compiled and executed.
    */
+  V8_DEPRECATE_SOON("Use GetCompileHintsCollector instead")
   std::vector<int> GetProducedCompileHints() const;
+
+  /**
+   * Get a compile hints collector object which we can use later for retrieving
+   * compile hints (= positions of lazy functions which were compiled and
+   * executed).
+   */
+  Local<CompileHintsCollector> GetCompileHintsCollector() const;
 };
 
 enum class ScriptType { kClassic, kModule };
@@ -640,12 +656,33 @@ class V8_EXPORT ScriptCompiler {
 
   enum CompileOptions {
     kNoCompileOptions = 0,
-    kConsumeCodeCache,
-    kEagerCompile,
-    kProduceCompileHints,
-    kConsumeCompileHints
+    kConsumeCodeCache = 1 << 0,
+    kEagerCompile = 1 << 1,
+    kProduceCompileHints = 1 << 2,
+    kConsumeCompileHints = 1 << 3,
+    kFollowCompileHintsMagicComment = 1 << 4,
   };
 
+  static inline bool CompileOptionsIsValid(CompileOptions compile_options) {
+    // kConsumeCodeCache is mutually exclusive with all other flag bits.
+    if ((compile_options & kConsumeCodeCache) &&
+        compile_options != kConsumeCodeCache) {
+      return false;
+    }
+    // kEagerCompile is mutually exclusive with all other flag bits.
+    if ((compile_options & kEagerCompile) && compile_options != kEagerCompile) {
+      return false;
+    }
+    // We don't currently support producing and consuming compile hints at the
+    // same time.
+    constexpr int produce_and_consume = CompileOptions::kProduceCompileHints |
+                                        CompileOptions::kConsumeCompileHints;
+    if ((compile_options & produce_and_consume) == produce_and_consume) {
+      return false;
+    }
+    return true;
+  }
+
   /**
    * The reason for which we are not requesting or providing a code cache.
    */
@@ -722,6 +759,8 @@ class V8_EXPORT ScriptCompiler {
 
   static ConsumeCodeCacheTask* StartConsumingCodeCache(
       Isolate* isolate, std::unique_ptr<CachedData> source);
+  static ConsumeCodeCacheTask* StartConsumingCodeCacheOnBackground(
+      Isolate* isolate, std::unique_ptr<CachedData> source);
 
   /**
    * Compiles a streamed script (bound to current context).
@@ -787,15 +826,6 @@ class V8_EXPORT ScriptCompiler {
    * It is possible to specify multiple context extensions (obj in the above
    * example).
    */
-  V8_DEPRECATED("Use CompileFunction")
-  static V8_WARN_UNUSED_RESULT MaybeLocal<Function> CompileFunctionInContext(
-      Local<Context> context, Source* source, size_t arguments_count,
-      Local<String> arguments[], size_t context_extension_count,
-      Local<Object> context_extensions[],
-      CompileOptions options = kNoCompileOptions,
-      NoCacheReason no_cache_reason = kNoCacheNoReason,
-      Local<ScriptOrModule>* script_or_module_out = nullptr);
-
   static V8_WARN_UNUSED_RESULT MaybeLocal<Function> CompileFunction(
       Local<Context> context, Source* source, size_t arguments_count = 0,
       Local<String> arguments[] = nullptr, size_t context_extension_count = 0,

data/vendor/v8/include/v8-snapshot.h

@@ -68,6 +68,22 @@ struct SerializeContextDataCallback {
   void* data;
 };
 
+/**
+ * Similar to `SerializeInternalFieldsCallback`, but is used exclusively to
+ * serialize API wrappers. The pointers for API wrappers always point into the
+ * CppHeap.
+ */
+struct SerializeAPIWrapperCallback {
+  using CallbackFunction = StartupData (*)(Local<Object> holder,
+                                           void* cpp_heap_pointer, void* data);
+  explicit SerializeAPIWrapperCallback(CallbackFunction function = nullptr,
+                                       void* data = nullptr)
+      : callback(function), data(data) {}
+
+  CallbackFunction callback;
+  void* data;
+};
+
 /**
  * Callback and supporting data used to implement embedder logic to deserialize
  * internal fields of v8::Objects.
@@ -97,6 +113,17 @@ struct DeserializeContextDataCallback {
   void* data;
 };
 
+struct DeserializeAPIWrapperCallback {
+  using CallbackFunction = void (*)(Local<Object> holder, StartupData payload,
+                                    void* data);
+  explicit DeserializeAPIWrapperCallback(CallbackFunction function = nullptr,
+                                         void* data = nullptr)
+      : callback(function), data(data) {}
+
+  CallbackFunction callback;
+  void* data;
+};
+
 /**
  * Helper class to create a snapshot data blob.
  *
@@ -187,13 +214,17 @@ class V8_EXPORT SnapshotCreator {
    * context embedder data set by
    * v8::Context::SetAlignedPointerInEmbedderData().
    *
+   * \param api_wrapper_serializer An optional callback used to serialize API
+   * wrapper references set via `v8::Object::Wrap()`.
    */
   void SetDefaultContext(
       Local<Context> context,
       SerializeInternalFieldsCallback internal_fields_serializer =
           SerializeInternalFieldsCallback(),
       SerializeContextDataCallback context_data_serializer =
-          SerializeContextDataCallback());
+          SerializeContextDataCallback(),
+      SerializeAPIWrapperCallback api_wrapper_serializer =
+          SerializeAPIWrapperCallback());
 
   /**
    * Add additional context to be included in the snapshot blob.
@@ -204,12 +235,17 @@ class V8_EXPORT SnapshotCreator {
    *
    * \param context_data_serializer Similar to context_data_serializer
    * in SetDefaultContext() but only applies to the context being added.
+   *
+   * \param api_wrapper_serializer Similar to api_wrapper_serializer
+   * in SetDefaultContext() but only applies to the context being added.
    */
   size_t AddContext(Local<Context> context,
                     SerializeInternalFieldsCallback internal_fields_serializer =
                         SerializeInternalFieldsCallback(),
                     SerializeContextDataCallback context_data_serializer =
-                        SerializeContextDataCallback());
+                        SerializeContextDataCallback(),
+                    SerializeAPIWrapperCallback api_wrapper_serializer =
+                        SerializeAPIWrapperCallback());
 
   /**
    * Attach arbitrary V8::Data to the context snapshot, which can be retrieved