libv8-node 21.7.2.0-aarch64-linux-musl → 24.12.0.0-aarch64-linux-musl

data/vendor/v8/include/v8-trace-categories.h

@@ -0,0 +1,23 @@
+// Copyright 2025 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_TRACE_CATEGORIES_H_
+#define INCLUDE_V8_TRACE_CATEGORIES_H_
+
+#if defined(V8_USE_PERFETTO)
+
+#include "perfetto/tracing/track_event.h"
+#include "v8config.h"
+
+namespace v8 {
+
+// Returns the perfeto TrackEventCategoryRegistry for v8 tracing categories.
+V8_EXPORT const perfetto::internal::TrackEventCategoryRegistry&
+GetTrackEventCategoryRegistry();
+
+}  // namespace v8
+
+#endif  // defined(V8_USE_PERFETTO)
+
+#endif  // INCLUDE_V8_TRACE_CATEGORIES_H_

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

@@ -27,19 +27,23 @@ namespace internal {
 
 class BasicTracedReferenceExtractor;
 
-enum class GlobalHandleStoreMode {
+enum class TracedReferenceStoreMode {
   kInitializingStore,
   kAssigningStore,
 };
 
-V8_EXPORT internal::Address* GlobalizeTracedReference(
-    internal::Isolate* isolate, internal::Address value,
-    internal::Address* slot, GlobalHandleStoreMode store_mode);
-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);
+enum class TracedReferenceHandling {
+  kDefault,  // See EmbedderRootsHandler::IsRoot().
+  kDroppable
+};
+
+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
 
@@ -47,8 +51,11 @@ V8_EXPORT void DisposeTracedReference(internal::Address* global_handle);
  * An indirect handle, where the indirect pointer points to a GlobalHandles
  * node.
  */
-class TracedReferenceBase : public IndirectHandleBase {
+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.
@@ -56,31 +63,18 @@ class TracedReferenceBase : public 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;
-  }
-
-  /**
-   * Assigns a wrapper class ID to the handle.
-   */
-  V8_INLINE void SetWrapperClassId(uint16_t class_id);
-
-  /**
-   * Returns the class ID previously assigned to this handle or 0 if no class ID
-   * was previously assigned.
-   */
-  V8_INLINE uint16_t WrapperClassId() const;
+  bool IsEmptyThreadSafe() const { return GetSlotThreadSafe() == nullptr; }
 
  protected:
   V8_INLINE TracedReferenceBase() = default;
@@ -88,17 +82,17 @@ class TracedReferenceBase : public 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;
@@ -140,26 +134,16 @@ 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.
    */
   BasicTracedReference() = default;
 
-  V8_INLINE static internal::Address* New(
+  V8_INLINE static internal::Address* NewFromNonEmptyValue(
       Isolate* isolate, T* that, internal::Address** slot,
-      internal::GlobalHandleStoreMode store_mode);
+      internal::TracedReferenceStoreMode store_mode,
+      internal::TracedReferenceHandling reference_handling);
 
   template <typename F>
   friend class Local;
@@ -180,6 +164,8 @@ class BasicTracedReference : public TracedReferenceBase {
 template <typename T>
 class TracedReference : public BasicTracedReference<T> {
  public:
+  struct IsDroppable {};
+
   using BasicTracedReference<T>::Reset;
 
   /**
@@ -195,10 +181,35 @@ class TracedReference : public BasicTracedReference<T> {
    */
   template <class S>
   TracedReference(Isolate* isolate, Local<S> that) : BasicTracedReference<T>() {
-    this->slot() =
-        this->New(isolate, *that, &this->slot(),
-                  internal::GlobalHandleStoreMode::kInitializingStore);
     static_assert(std::is_base_of<T, S>::value, "type check");
+    if (V8_UNLIKELY(that.IsEmpty())) {
+      return;
+    }
+    this->slot() = this->NewFromNonEmptyValue(
+        isolate, *that, &this->slot(),
+        internal::TracedReferenceStoreMode::kInitializingStore,
+        internal::TracedReferenceHandling::kDefault);
+  }
+
+  /**
+   * Construct a droppable TracedReference from a Local. Droppable means that V8
+   * is free to reclaim the pointee if it is unmodified and otherwise
+   * unreachable
+   *
+   * When the Local is non-empty, a new storage cell is created
+   * pointing to the same object.
+   */
+  template <class S>
+  TracedReference(Isolate* isolate, Local<S> that, IsDroppable)
+      : BasicTracedReference<T>() {
+    static_assert(std::is_base_of<T, S>::value, "type check");
+    if (V8_UNLIKELY(that.IsEmpty())) {
+      return;
+    }
+    this->slot() = this->NewFromNonEmptyValue(
+        isolate, *that, &this->slot(),
+        internal::TracedReferenceStoreMode::kInitializingStore,
+        internal::TracedReferenceHandling::kDroppable);
   }
 
   /**
@@ -262,12 +273,19 @@ class TracedReference : public BasicTracedReference<T> {
   V8_INLINE TracedReference& operator=(const TracedReference<S>& rhs);
 
   /**
-   * If non-empty, destroy the underlying storage cell and create a new one with
-   * the contents of other if other is non empty
+   * Always resets the reference. Creates a new reference from `other` if it is
+   * non-empty.
    */
   template <class S>
   V8_INLINE void Reset(Isolate* isolate, const Local<S>& other);
 
+  /**
+   * Always resets the reference. Creates a new reference from `other` if it is
+   * non-empty. The new reference is droppable, see constructor.
+   */
+  template <class S>
+  V8_INLINE void Reset(Isolate* isolate, const Local<S>& other, IsDroppable);
+
   template <class S>
   V8_INLINE TracedReference<S>& As() const {
     return reinterpret_cast<TracedReference<S>&>(
@@ -277,18 +295,21 @@ class TracedReference : public BasicTracedReference<T> {
 
 // --- Implementation ---
 template <class T>
-internal::Address* BasicTracedReference<T>::New(
+internal::Address* BasicTracedReference<T>::NewFromNonEmptyValue(
     Isolate* isolate, T* that, internal::Address** slot,
-    internal::GlobalHandleStoreMode store_mode) {
-  if (internal::ValueHelper::IsEmpty(that)) return nullptr;
+    internal::TracedReferenceStoreMode store_mode,
+    internal::TracedReferenceHandling reference_handling) {
   return internal::GlobalizeTracedReference(
       reinterpret_cast<internal::Isolate*>(isolate),
       internal::ValueHelper::ValueAsAddress(that),
-      reinterpret_cast<internal::Address*>(slot), store_mode);
+      reinterpret_cast<internal::Address*>(slot), store_mode,
+      reference_handling);
 }
 
 void TracedReferenceBase::Reset() {
-  if (IsEmpty()) return;
+  if (V8_UNLIKELY(IsEmpty())) {
+    return;
+  }
   internal::DisposeTracedReference(slot());
   SetSlotThreadSafe(nullptr);
 }
@@ -332,10 +353,28 @@ template <class S>
 void TracedReference<T>::Reset(Isolate* isolate, const Local<S>& other) {
   static_assert(std::is_base_of<T, S>::value, "type check");
   this->Reset();
-  if (other.IsEmpty()) return;
-  this->SetSlotThreadSafe(
-      this->New(isolate, *other, &this->slot(),
-                internal::GlobalHandleStoreMode::kAssigningStore));
+  if (V8_UNLIKELY(other.IsEmpty())) {
+    return;
+  }
+  this->SetSlotThreadSafe(this->NewFromNonEmptyValue(
+      isolate, *other, &this->slot(),
+      internal::TracedReferenceStoreMode::kAssigningStore,
+      internal::TracedReferenceHandling::kDefault));
+}
+
+template <class T>
+template <class S>
+void TracedReference<T>::Reset(Isolate* isolate, const Local<S>& other,
+                               IsDroppable) {
+  static_assert(std::is_base_of<T, S>::value, "type check");
+  this->Reset();
+  if (V8_UNLIKELY(other.IsEmpty())) {
+    return;
+  }
+  this->SetSlotThreadSafe(this->NewFromNonEmptyValue(
+      isolate, *other, &this->slot(),
+      internal::TracedReferenceStoreMode::kAssigningStore,
+      internal::TracedReferenceHandling::kDroppable));
 }
 
 template <class T>
@@ -376,22 +415,6 @@ TracedReference<T>& TracedReference<T>::operator=(const TracedReference& rhs) {
   return *this;
 }
 
-void TracedReferenceBase::SetWrapperClassId(uint16_t class_id) {
-  using I = internal::Internals;
-  if (IsEmpty()) return;
-  uint8_t* addr =
-      reinterpret_cast<uint8_t*>(slot()) + I::kTracedNodeClassIdOffset;
-  *reinterpret_cast<uint16_t*>(addr) = class_id;
-}
-
-uint16_t TracedReferenceBase::WrapperClassId() const {
-  using I = internal::Internals;
-  if (IsEmpty()) return 0;
-  uint8_t* addr =
-      reinterpret_cast<uint8_t*>(slot()) + I::kTracedNodeClassIdOffset;
-  return *reinterpret_cast<uint16_t*>(addr);
-}
-
 }  // namespace v8
 
 #endif  // INCLUDE_V8_TRACED_HANDLE_H_

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

@@ -5,14 +5,14 @@
 #ifndef INCLUDE_V8_TYPED_ARRAY_H_
 #define INCLUDE_V8_TYPED_ARRAY_H_
 
+#include <limits>
+
 #include "v8-array-buffer.h"  // NOLINT(build/include_directory)
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
 #include "v8config.h"         // NOLINT(build/include_directory)
 
 namespace v8 {
 
-class SharedArrayBuffer;
-
 /**
  * A base class for an instance of TypedArray series of constructors
  * (ES6 draft 15.13.6).
@@ -20,12 +20,15 @@ class SharedArrayBuffer;
 class V8_EXPORT TypedArray : public ArrayBufferView {
  public:
   /*
-   * The largest typed array size that can be constructed using New.
+   * The largest supported typed array byte size. Each subclass defines a
+   * type-specific kMaxLength for the maximum length that can be passed to New.
    */
-  static constexpr size_t kMaxLength =
-      internal::kApiSystemPointerSize == 4
-          ? internal::kSmiMaxValue
-          : static_cast<size_t>(uint64_t{1} << 32);
+  static constexpr size_t kMaxByteLength = ArrayBuffer::kMaxByteLength;
+
+#ifdef V8_ENABLE_SANDBOX
+  static_assert(v8::TypedArray::kMaxByteLength <=
+                v8::internal::kMaxSafeBufferSizeForSandbox);
+#endif
 
   /**
    * Number of elements in this typed array
@@ -50,6 +53,13 @@ class V8_EXPORT TypedArray : public ArrayBufferView {
  */
 class V8_EXPORT Uint8Array : public TypedArray {
  public:
+  /*
+   * The largest Uint8Array size that can be constructed using New.
+   */
+  static constexpr size_t kMaxLength =
+      TypedArray::kMaxByteLength / sizeof(uint8_t);
+  static_assert(sizeof(uint8_t) == 1);
+
   static Local<Uint8Array> New(Local<ArrayBuffer> array_buffer,
                                size_t byte_offset, size_t length);
   static Local<Uint8Array> New(Local<SharedArrayBuffer> shared_array_buffer,
@@ -71,6 +81,13 @@ class V8_EXPORT Uint8Array : public TypedArray {
  */
 class V8_EXPORT Uint8ClampedArray : public TypedArray {
  public:
+  /*
+   * The largest Uint8ClampedArray size that can be constructed using New.
+   */
+  static constexpr size_t kMaxLength =
+      TypedArray::kMaxByteLength / sizeof(uint8_t);
+  static_assert(sizeof(uint8_t) == 1);
+
   static Local<Uint8ClampedArray> New(Local<ArrayBuffer> array_buffer,
                                       size_t byte_offset, size_t length);
   static Local<Uint8ClampedArray> New(
@@ -93,6 +110,13 @@ class V8_EXPORT Uint8ClampedArray : public TypedArray {
  */
 class V8_EXPORT Int8Array : public TypedArray {
  public:
+  /*
+   * The largest Int8Array size that can be constructed using New.
+   */
+  static constexpr size_t kMaxLength =
+      TypedArray::kMaxByteLength / sizeof(int8_t);
+  static_assert(sizeof(int8_t) == 1);
+
   static Local<Int8Array> New(Local<ArrayBuffer> array_buffer,
                               size_t byte_offset, size_t length);
   static Local<Int8Array> New(Local<SharedArrayBuffer> shared_array_buffer,
@@ -114,6 +138,13 @@ class V8_EXPORT Int8Array : public TypedArray {
  */
 class V8_EXPORT Uint16Array : public TypedArray {
  public:
+  /*
+   * The largest Uint16Array size that can be constructed using New.
+   */
+  static constexpr size_t kMaxLength =
+      TypedArray::kMaxByteLength / sizeof(uint16_t);
+  static_assert(sizeof(uint16_t) == 2);
+
   static Local<Uint16Array> New(Local<ArrayBuffer> array_buffer,
                                 size_t byte_offset, size_t length);
   static Local<Uint16Array> New(Local<SharedArrayBuffer> shared_array_buffer,
@@ -135,6 +166,13 @@ class V8_EXPORT Uint16Array : public TypedArray {
  */
 class V8_EXPORT Int16Array : public TypedArray {
  public:
+  /*
+   * The largest Int16Array size that can be constructed using New.
+   */
+  static constexpr size_t kMaxLength =
+      TypedArray::kMaxByteLength / sizeof(int16_t);
+  static_assert(sizeof(int16_t) == 2);
+
   static Local<Int16Array> New(Local<ArrayBuffer> array_buffer,
                                size_t byte_offset, size_t length);
   static Local<Int16Array> New(Local<SharedArrayBuffer> shared_array_buffer,
@@ -156,6 +194,13 @@ class V8_EXPORT Int16Array : public TypedArray {
  */
 class V8_EXPORT Uint32Array : public TypedArray {
  public:
+  /*
+   * The largest Uint32Array size that can be constructed using New.
+   */
+  static constexpr size_t kMaxLength =
+      TypedArray::kMaxByteLength / sizeof(uint32_t);
+  static_assert(sizeof(uint32_t) == 4);
+
   static Local<Uint32Array> New(Local<ArrayBuffer> array_buffer,
                                 size_t byte_offset, size_t length);
   static Local<Uint32Array> New(Local<SharedArrayBuffer> shared_array_buffer,
@@ -177,6 +222,13 @@ class V8_EXPORT Uint32Array : public TypedArray {
  */
 class V8_EXPORT Int32Array : public TypedArray {
  public:
+  /*
+   * The largest Int32Array size that can be constructed using New.
+   */
+  static constexpr size_t kMaxLength =
+      TypedArray::kMaxByteLength / sizeof(int32_t);
+  static_assert(sizeof(int32_t) == 4);
+
   static Local<Int32Array> New(Local<ArrayBuffer> array_buffer,
                                size_t byte_offset, size_t length);
   static Local<Int32Array> New(Local<SharedArrayBuffer> shared_array_buffer,
@@ -193,11 +245,42 @@ class V8_EXPORT Int32Array : public TypedArray {
   static void CheckCast(Value* obj);
 };
 
+/**
+ * An instance of Float16Array constructor.
+ */
+class V8_EXPORT Float16Array : public TypedArray {
+ public:
+  static constexpr size_t kMaxLength =
+      TypedArray::kMaxByteLength / sizeof(uint16_t);
+
+  static Local<Float16Array> New(Local<ArrayBuffer> array_buffer,
+                                 size_t byte_offset, size_t length);
+  static Local<Float16Array> New(Local<SharedArrayBuffer> shared_array_buffer,
+                                 size_t byte_offset, size_t length);
+  V8_INLINE static Float16Array* Cast(Value* value) {
+#ifdef V8_ENABLE_CHECKS
+    CheckCast(value);
+#endif
+    return static_cast<Float16Array*>(value);
+  }
+
+ private:
+  Float16Array();
+  static void CheckCast(Value* obj);
+};
+
 /**
  * An instance of Float32Array constructor (ES6 draft 15.13.6).
  */
 class V8_EXPORT Float32Array : public TypedArray {
  public:
+  /*
+   * The largest Float32Array size that can be constructed using New.
+   */
+  static constexpr size_t kMaxLength =
+      TypedArray::kMaxByteLength / sizeof(float);
+  static_assert(sizeof(float) == 4);
+
   static Local<Float32Array> New(Local<ArrayBuffer> array_buffer,
                                  size_t byte_offset, size_t length);
   static Local<Float32Array> New(Local<SharedArrayBuffer> shared_array_buffer,
@@ -219,6 +302,13 @@ class V8_EXPORT Float32Array : public TypedArray {
  */
 class V8_EXPORT Float64Array : public TypedArray {
  public:
+  /*
+   * The largest Float64Array size that can be constructed using New.
+   */
+  static constexpr size_t kMaxLength =
+      TypedArray::kMaxByteLength / sizeof(double);
+  static_assert(sizeof(double) == 8);
+
   static Local<Float64Array> New(Local<ArrayBuffer> array_buffer,
                                  size_t byte_offset, size_t length);
   static Local<Float64Array> New(Local<SharedArrayBuffer> shared_array_buffer,
@@ -240,6 +330,13 @@ class V8_EXPORT Float64Array : public TypedArray {
  */
 class V8_EXPORT BigInt64Array : public TypedArray {
  public:
+  /*
+   * The largest BigInt64Array size that can be constructed using New.
+   */
+  static constexpr size_t kMaxLength =
+      TypedArray::kMaxByteLength / sizeof(int64_t);
+  static_assert(sizeof(int64_t) == 8);
+
   static Local<BigInt64Array> New(Local<ArrayBuffer> array_buffer,
                                   size_t byte_offset, size_t length);
   static Local<BigInt64Array> New(Local<SharedArrayBuffer> shared_array_buffer,
@@ -261,6 +358,13 @@ class V8_EXPORT BigInt64Array : public TypedArray {
  */
 class V8_EXPORT BigUint64Array : public TypedArray {
  public:
+  /*
+   * The largest BigUint64Array size that can be constructed using New.
+   */
+  static constexpr size_t kMaxLength =
+      TypedArray::kMaxByteLength / sizeof(uint64_t);
+  static_assert(sizeof(uint64_t) == 8);
+
   static Local<BigUint64Array> New(Local<ArrayBuffer> array_buffer,
                                    size_t byte_offset, size_t length);
   static Local<BigUint64Array> 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.