libv8-node 22.7.0.4-x86_64-linux-musl → 24.1.0.0-x86_64-linux-musl

data/vendor/v8/include/v8-traced-handle.h

@@ -37,15 +37,13 @@ enum class TracedReferenceHandling {
   kDroppable
 };
 
-V8_EXPORT internal::Address* GlobalizeTracedReference(
-    internal::Isolate* isolate, internal::Address value,
-    internal::Address* slot, TracedReferenceStoreMode store_mode,
-    internal::TracedReferenceHandling reference_handling);
-V8_EXPORT void MoveTracedReference(internal::Address** from,
-                                   internal::Address** to);
-V8_EXPORT void CopyTracedReference(const internal::Address* const* from,
-                                   internal::Address** to);
-V8_EXPORT void DisposeTracedReference(internal::Address* global_handle);
+V8_EXPORT Address* GlobalizeTracedReference(
+    Isolate* isolate, Address value, Address* slot,
+    TracedReferenceStoreMode store_mode,
+    TracedReferenceHandling reference_handling);
+V8_EXPORT void MoveTracedReference(Address** from, Address** to);
+V8_EXPORT void CopyTracedReference(const Address* const* from, Address** to);
+V8_EXPORT void DisposeTracedReference(Address* global_handle);
 
 }  // namespace internal
 
@@ -55,6 +53,9 @@ V8_EXPORT void DisposeTracedReference(internal::Address* global_handle);
  */
 class TracedReferenceBase : public api_internal::IndirectHandleBase {
  public:
+  static_assert(sizeof(std::atomic<internal::Address*>) ==
+                sizeof(internal::Address*));
+
   /**
    * If non-empty, destroy the underlying storage cell. |IsEmpty| will return
    * true after this call.
@@ -62,20 +63,18 @@ class TracedReferenceBase : public api_internal::IndirectHandleBase {
   V8_INLINE void Reset();
 
   /**
-   * Construct a Local<Value> from this handle.
+   * Construct a Local<Data> from this handle.
    */
-  V8_INLINE Local<Value> Get(Isolate* isolate) const {
-    if (IsEmpty()) return Local<Value>();
-    return Local<Value>::New(isolate, this->value<Value>());
+  V8_INLINE Local<Data> Get(Isolate* isolate) const {
+    if (IsEmpty()) return Local<Data>();
+    return Local<Data>::New(isolate, this->value<Data>());
   }
 
   /**
    * Returns true if this TracedReference is empty, i.e., has not been
    * assigned an object. This version of IsEmpty is thread-safe.
    */
-  bool IsEmptyThreadSafe() const {
-    return this->GetSlotThreadSafe() == nullptr;
-  }
+  bool IsEmptyThreadSafe() const { return GetSlotThreadSafe() == nullptr; }
 
  protected:
   V8_INLINE TracedReferenceBase() = default;
@@ -83,17 +82,17 @@ class TracedReferenceBase : public api_internal::IndirectHandleBase {
   /**
    * Update this reference in a thread-safe way.
    */
-  void SetSlotThreadSafe(void* new_val) {
-    reinterpret_cast<std::atomic<void*>*>(&slot())->store(
+  void SetSlotThreadSafe(internal::Address* new_val) {
+    reinterpret_cast<std::atomic<internal::Address*>*>(&slot())->store(
         new_val, std::memory_order_relaxed);
   }
 
   /**
    * Get this reference in a thread-safe way
    */
-  const void* GetSlotThreadSafe() const {
-    return reinterpret_cast<std::atomic<const void*> const*>(&slot())->load(
-        std::memory_order_relaxed);
+  const internal::Address* GetSlotThreadSafe() const {
+    return reinterpret_cast<const std::atomic<internal::Address*>*>(&slot())
+        ->load(std::memory_order_relaxed);
   }
 
   V8_EXPORT void CheckValue() const;
@@ -135,17 +134,6 @@ class BasicTracedReference : public TracedReferenceBase {
         const_cast<BasicTracedReference<T>&>(*this));
   }
 
-  V8_DEPRECATE_SOON("Use Get to convert to Local instead")
-  V8_INLINE T* operator->() const {
-#ifdef V8_ENABLE_CHECKS
-    CheckValue();
-#endif  // V8_ENABLE_CHECKS
-    return this->template value<T>();
-  }
-
-  V8_DEPRECATE_SOON("Use Get to convert to Local instead")
-  V8_INLINE T* operator*() const { return this->operator->(); }
-
  private:
   /**
    * An empty BasicTracedReference without storage cell.

data/vendor/v8/include/v8-typed-array.h

@@ -23,15 +23,11 @@ class V8_EXPORT TypedArray : public ArrayBufferView {
    * The largest supported typed array byte size. Each subclass defines a
    * type-specific kMaxLength for the maximum length that can be passed to New.
    */
-#if V8_ENABLE_SANDBOX
-  static constexpr size_t kMaxByteLength =
-      internal::kMaxSafeBufferSizeForSandbox;
-#elif V8_HOST_ARCH_32_BIT
-  static constexpr size_t kMaxByteLength = std::numeric_limits<int>::max();
-#else
-  // The maximum safe integer (2^53 - 1).
-  static constexpr size_t kMaxByteLength =
-      static_cast<size_t>((uint64_t{1} << 53) - 1);
+  static constexpr size_t kMaxByteLength = ArrayBuffer::kMaxByteLength;
+
+#ifdef V8_ENABLE_SANDBOX
+  static_assert(v8::TypedArray::kMaxByteLength <=
+                v8::internal::kMaxSafeBufferSizeForSandbox);
 #endif
 
   /**
@@ -253,10 +249,10 @@ class V8_EXPORT Int32Array : public TypedArray {
  * An instance of Float16Array constructor.
  */
 class V8_EXPORT Float16Array : public TypedArray {
+ public:
   static constexpr size_t kMaxLength =
       TypedArray::kMaxByteLength / sizeof(uint16_t);
 
- public:
   static Local<Float16Array> New(Local<ArrayBuffer> array_buffer,
                                  size_t byte_offset, size_t length);
   static Local<Float16Array> New(Local<SharedArrayBuffer> shared_array_buffer,

data/vendor/v8/include/v8-unwinder-state.h

@@ -18,9 +18,8 @@ struct CalleeSavedRegisters {
   void* arm_r10;
 };
 #elif V8_TARGET_ARCH_X64 || V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_ARM64 ||     \
-    V8_TARGET_ARCH_MIPS64 || V8_TARGET_ARCH_PPC || V8_TARGET_ARCH_PPC64 ||     \
-    V8_TARGET_ARCH_RISCV64 || V8_TARGET_ARCH_S390 || V8_TARGET_ARCH_LOONG64 || \
-    V8_TARGET_ARCH_RISCV32
+    V8_TARGET_ARCH_MIPS64 || V8_TARGET_ARCH_PPC64 || V8_TARGET_ARCH_RISCV64 || \
+    V8_TARGET_ARCH_S390X || V8_TARGET_ARCH_LOONG64 || V8_TARGET_ARCH_RISCV32
 struct CalleeSavedRegisters {};
 #else
 #error Target architecture was not detected as supported by v8

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

@@ -42,7 +42,8 @@ enum StateTag : uint16_t {
   OTHER,
   EXTERNAL,
   ATOMICS_WAIT,
-  IDLE
+  IDLE,
+  LOGGING,
 };
 
 // The output structure filled up by GetStackSample API function.

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

@@ -182,7 +182,7 @@ class PersistentValueMapBase {
    */
   Local<V> Get(const K& key) {
     V* p = FromVal(Traits::Get(&impl_, key));
-#ifdef V8_ENABLE_DIRECT_LOCAL
+#ifdef V8_ENABLE_DIRECT_HANDLE
     if (p == nullptr) return Local<V>();
 #endif
     return Local<V>::New(isolate_, p);
@@ -544,122 +544,6 @@ class StdGlobalValueMap : public GlobalValueMap<K, V, Traits> {
       : GlobalValueMap<K, V, Traits>(isolate) {}
 };
 
-class DefaultPersistentValueVectorTraits {
- public:
-  typedef std::vector<PersistentContainerValue> Impl;
-
-  static void Append(Impl* impl, PersistentContainerValue value) {
-    impl->push_back(value);
-  }
-  static bool IsEmpty(const Impl* impl) {
-    return impl->empty();
-  }
-  static size_t Size(const Impl* impl) {
-    return impl->size();
-  }
-  static PersistentContainerValue Get(const Impl* impl, size_t i) {
-    return (i < impl->size()) ? impl->at(i) : kPersistentContainerNotFound;
-  }
-  static void ReserveCapacity(Impl* impl, size_t capacity) {
-    impl->reserve(capacity);
-  }
-  static void Clear(Impl* impl) {
-    impl->clear();
-  }
-};
-
-/**
- * A vector wrapper that safely stores Global values.
- * C++11 embedders don't need this class, as they can use Global
- * directly in std containers.
- *
- * This class relies on a backing vector implementation, whose type and methods
- * are described by the Traits class. The backing map will handle values of type
- * PersistentContainerValue, with all conversion into and out of V8
- * handles being transparently handled by this class.
- */
-template <typename V, typename Traits = DefaultPersistentValueVectorTraits>
-class V8_DEPRECATE_SOON("Use std::vector<Global<V>>.") PersistentValueVector {
- public:
-  explicit PersistentValueVector(Isolate* isolate) : isolate_(isolate) { }
-
-  ~PersistentValueVector() {
-    Clear();
-  }
-
-  /**
-   * Append a value to the vector.
-   */
-  void Append(Local<V> value) {
-    Global<V> persistent(isolate_, value);
-    Traits::Append(&impl_, ClearAndLeak(&persistent));
-  }
-
-  /**
-   * Append a persistent's value to the vector.
-   */
-  void Append(Global<V> persistent) {
-    Traits::Append(&impl_, ClearAndLeak(&persistent));
-  }
-
-  /**
-   * Are there any values in the vector?
-   */
-  bool IsEmpty() const {
-    return Traits::IsEmpty(&impl_);
-  }
-
-  /**
-   * How many elements are in the vector?
-   */
-  size_t Size() const {
-    return Traits::Size(&impl_);
-  }
-
-  /**
-   * Retrieve the i-th value in the vector.
-   */
-  Local<V> Get(size_t index) const {
-    return Local<V>::New(isolate_, internal::ValueHelper::SlotAsValue<V>(
-                                       Traits::Get(&impl_, index)));
-  }
-
-  /**
-   * Remove all elements from the vector.
-   */
-  void Clear() {
-    size_t length = Traits::Size(&impl_);
-    for (size_t i = 0; i < length; i++) {
-      Global<V> p;
-      p.slot() = reinterpret_cast<internal::Address>(Traits::Get(&impl_, i));
-    }
-    Traits::Clear(&impl_);
-  }
-
-  /**
-   * Reserve capacity in the vector.
-   * (Efficiency gains depend on the backing implementation.)
-   */
-  void ReserveCapacity(size_t capacity) {
-    Traits::ReserveCapacity(&impl_, capacity);
-  }
-
- private:
-  static PersistentContainerValue ClearAndLeak(Global<V>* persistent) {
-    auto slot = persistent->slot();
-    persistent->Clear();
-    return reinterpret_cast<PersistentContainerValue>(slot);
-  }
-
-  static V* FromVal(PersistentContainerValue v) {
-    return internal::ValueHelper::SlotAsValue<V>(
-        reinterpret_cast<internal::Address*>(v));
-  }
-
-  Isolate* isolate_;
-  typename Traits::Impl impl_;
-};
-
 }  // namespace v8
 
 #endif  // V8_UTIL_H

data/vendor/v8/include/v8-value-serializer-version.h

@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#ifndef INCLUDE_V8_VALUE_SERIALIZER_VERSION_H_
+#define INCLUDE_V8_VALUE_SERIALIZER_VERSION_H_
+
 /**
  * Compile-time constants.
  *
@@ -10,9 +13,6 @@
  * to V8.
  */
 
-#ifndef INCLUDE_V8_VALUE_SERIALIZER_VERSION_H_
-#define INCLUDE_V8_VALUE_SERIALIZER_VERSION_H_
-
 #include <stdint.h>
 
 namespace v8 {

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

@@ -346,6 +346,11 @@ class V8_EXPORT Value : public Data {
    */
   bool IsWasmMemoryObject() const;
 
+  /**
+   * Returns true if this value is a WasmMemoryMapDescriptor.
+   */
+  bool IsWasmMemoryMapDescriptor() const;
+
   /**
    * Returns true if this value is a WasmModuleObject.
    */
@@ -361,6 +366,11 @@ class V8_EXPORT Value : public Data {
    */
   bool IsModuleNamespaceObject() const;
 
+  /**
+   * Returns true if the value is a primitive.
+   */
+  bool IsPrimitive() const;
+
   /**
    * Perform `ToPrimitive(value)` as specified in:
    * https://tc39.es/ecma262/#sec-toprimitive.
@@ -462,6 +472,14 @@ class V8_EXPORT Value : public Data {
 
   Maybe<bool> InstanceOf(Local<Context> context, Local<Object> object);
 
+  /**
+   * Get the hash of this value. The hash is not guaranteed to be
+   * unique. For |Object| and |Name| instances the result is equal to
+   * |GetIdentityHash|. Hashes are not guaranteed to be stable across
+   * different isolates or processes.
+   */
+  uint32_t GetHash();
+
  private:
   V8_INLINE bool QuickIsUndefined() const;
   V8_INLINE bool QuickIsNull() const;
@@ -635,8 +653,9 @@ bool Value::QuickIsString() const {
   A obj = internal::ValueHelper::ValueAsAddress(this);
   if (!I::HasHeapObjectTag(obj)) return false;
 #if V8_STATIC_ROOTS_BOOL && !V8_MAP_PACKING
-  return I::CheckInstanceMapRange(obj, I::StaticReadOnlyRoot::kFirstStringMap,
-                                  I::StaticReadOnlyRoot::kLastStringMap);
+  return I::CheckInstanceMapRange(obj,
+                                  I::StaticReadOnlyRoot::kStringMapLowerBound,
+                                  I::StaticReadOnlyRoot::kStringMapUpperBound);
 #else
   return (I::GetInstanceType(obj) < I::kFirstNonstringType);
 #endif  // V8_STATIC_ROOTS_BOOL

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

@@ -8,10 +8,10 @@
 // These macros define the version number for the current version.
 // NOTE these macros are used by some of the tool scripts and the build
 // system so their names cannot be changed without changing the scripts.
-#define V8_MAJOR_VERSION 12
-#define V8_MINOR_VERSION 4
-#define V8_BUILD_NUMBER 254
-#define V8_PATCH_LEVEL 21
+#define V8_MAJOR_VERSION 13
+#define V8_MINOR_VERSION 6
+#define V8_BUILD_NUMBER 233
+#define V8_PATCH_LEVEL 10
 
 // Use 1 for candidates and 0 otherwise.
 // (Boolean macro values are not supported by all preprocessors.)

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

@@ -9,6 +9,7 @@
 #include <memory>
 #include <string>
 
+#include "v8-internal.h"      // NOLINT(build/include_directory)
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
 #include "v8-memory-span.h"   // NOLINT(build/include_directory)
 #include "v8-object.h"        // NOLINT(build/include_directory)
@@ -129,6 +130,8 @@ class V8_EXPORT WasmModuleObject : public Object {
  */
 class V8_EXPORT WasmStreaming final {
  public:
+  static constexpr internal::ExternalPointerTag kManagedTag =
+      internal::kWasmWasmStreamingTag;
   class WasmStreamingImpl;
 
   explicit WasmStreaming(std::unique_ptr<WasmStreamingImpl> impl);
@@ -196,6 +199,30 @@ class V8_EXPORT WasmStreaming final {
   std::unique_ptr<WasmStreamingImpl> impl_;
 };
 
+/**
+ * The V8 interface for a WebAssembly memory map descriptor. This is an
+ * experimental feature that may change and be removed without further
+ * communication.
+ */
+class V8_EXPORT WasmMemoryMapDescriptor : public Object {
+ public:
+  WasmMemoryMapDescriptor() = delete;
+
+  V8_INLINE static WasmMemoryMapDescriptor* Cast(Value* value) {
+#ifdef V8_ENABLE_CHECKS
+    CheckCast(value);
+#endif
+    return static_cast<WasmMemoryMapDescriptor*>(value);
+  }
+
+  using WasmFileDescriptor = int32_t;
+
+  static Local<WasmMemoryMapDescriptor> New(Isolate* isolate,
+                                            WasmFileDescriptor fd);
+
+ private:
+  static void CheckCast(Value* object);
+};
 }  // namespace v8
 
 #endif  // INCLUDE_V8_WASM_H_

data/vendor/v8/include/v8-weak-callback-info.h

@@ -5,6 +5,9 @@
 #ifndef INCLUDE_V8_WEAK_CALLBACK_INFO_H_
 #define INCLUDE_V8_WEAK_CALLBACK_INFO_H_
 
+#include <cstring>
+
+#include "cppgc/internal/conditional-stack-allocated.h"  // NOLINT(build/include_directory)
 #include "v8config.h"  // NOLINT(build/include_directory)
 
 namespace v8 {
@@ -15,11 +18,12 @@ namespace api_internal {
 V8_EXPORT void InternalFieldOutOfBounds(int index);
 }  // namespace api_internal
 
-static const int kInternalFieldsInWeakCallback = 2;
-static const int kEmbedderFieldsInWeakCallback = 2;
+static constexpr int kInternalFieldsInWeakCallback = 2;
+static constexpr int kEmbedderFieldsInWeakCallback = 2;
 
 template <typename T>
-class WeakCallbackInfo {
+class WeakCallbackInfo
+    : public cppgc::internal::ConditionalStackAllocatedBase<T> {
  public:
   using Callback = void (*)(const WeakCallbackInfo<T>& data);
 
@@ -27,21 +31,25 @@ class WeakCallbackInfo {
                    void* embedder_fields[kEmbedderFieldsInWeakCallback],
                    Callback* callback)
       : isolate_(isolate), parameter_(parameter), callback_(callback) {
-    for (int i = 0; i < kEmbedderFieldsInWeakCallback; ++i) {
-      embedder_fields_[i] = embedder_fields[i];
-    }
+    memcpy(embedder_fields_, embedder_fields,
+           sizeof(embedder_fields[0]) * kEmbedderFieldsInWeakCallback);
   }
 
   V8_INLINE Isolate* GetIsolate() const { return isolate_; }
   V8_INLINE T* GetParameter() const { return parameter_; }
   V8_INLINE void* GetInternalField(int index) const;
 
-  // When first called, the embedder MUST Reset() the Global which triggered the
-  // callback. The Global itself is unusable for anything else. No v8 other api
-  // calls may be called in the first callback. Should additional work be
-  // required, the embedder must set a second pass callback, which will be
-  // called after all the initial callbacks are processed.
-  // Calling SetSecondPassCallback on the second pass will immediately crash.
+  /**
+   * When a weak callback is first invoked the embedders _must_ Reset() the
+   * handle which triggered the callback. The handle itself is unusable for
+   * anything else. No other V8 API calls may be called in the first callback.
+   * Additional work requires scheduling a second invocation via
+   * `SetSecondPassCallback()` which will be called some time after all the
+   * initial callbacks are processed.
+   *
+   * The second pass callback is prohibited from executing JavaScript. Embedders
+   * should schedule another callback in case this is required.
+   */
   void SetSecondPassCallback(Callback callback) const { *callback_ = callback; }
 
  private:

data/vendor/v8/include/v8.h

@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#ifndef INCLUDE_V8_H_
+#define INCLUDE_V8_H_
+
 /** \mainpage V8 API Reference Guide
  *
  * V8 is Google's open source JavaScript engine.
@@ -12,9 +15,6 @@
  * For other documentation see https://v8.dev/.
  */
 
-#ifndef INCLUDE_V8_H_
-#define INCLUDE_V8_H_
-
 #include <stddef.h>
 #include <stdint.h>