libv8-node 20.12.1.0-aarch64-linux-musl → 22.5.1.0-aarch64-linux-musl

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

@@ -27,14 +27,20 @@ namespace internal {
 
 class BasicTracedReferenceExtractor;
 
-enum class GlobalHandleStoreMode {
+enum class TracedReferenceStoreMode {
   kInitializingStore,
   kAssigningStore,
 };
 
+enum class TracedReferenceHandling {
+  kDefault,  // See EmbedderRootsHandler::IsRoot().
+  kDroppable
+};
+
 V8_EXPORT internal::Address* GlobalizeTracedReference(
-    internal::Isolate* isolate, internal::Address* handle,
-    internal::Address* slot, GlobalHandleStoreMode store_mode);
+    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,
@@ -43,14 +49,12 @@ V8_EXPORT void DisposeTracedReference(internal::Address* global_handle);
 
 }  // namespace internal
 
-class TracedReferenceBase {
+/**
+ * An indirect handle, where the indirect pointer points to a GlobalHandles
+ * node.
+ */
+class TracedReferenceBase : public api_internal::IndirectHandleBase {
  public:
-  /**
-   * Returns true if the reference is empty, i.e., has not been assigned
-   * object.
-   */
-  bool IsEmpty() const { return val_ == nullptr; }
-
   /**
    * If non-empty, destroy the underlying storage cell. |IsEmpty| will return
    * true after this call.
@@ -60,10 +64,9 @@ class TracedReferenceBase {
   /**
    * Construct a Local<Value> from this handle.
    */
-  V8_INLINE v8::Local<v8::Value> Get(v8::Isolate* isolate) const {
+  V8_INLINE Local<Value> Get(Isolate* isolate) const {
     if (IsEmpty()) return Local<Value>();
-    return Local<Value>::New(isolate,
-                             internal::ValueHelper::SlotAsValue<Value>(val_));
+    return Local<Value>::New(isolate, this->value<Value>());
   }
 
   /**
@@ -74,23 +77,14 @@ class TracedReferenceBase {
     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;
-
  protected:
+  V8_INLINE TracedReferenceBase() = default;
+
   /**
    * Update this reference in a thread-safe way.
    */
   void SetSlotThreadSafe(void* new_val) {
-    reinterpret_cast<std::atomic<void*>*>(&val_)->store(
+    reinterpret_cast<std::atomic<void*>*>(&slot())->store(
         new_val, std::memory_order_relaxed);
   }
 
@@ -98,19 +92,13 @@ class TracedReferenceBase {
    * Get this reference in a thread-safe way
    */
   const void* GetSlotThreadSafe() const {
-    return reinterpret_cast<std::atomic<const void*> const*>(&val_)->load(
+    return reinterpret_cast<std::atomic<const void*> const*>(&slot())->load(
         std::memory_order_relaxed);
   }
 
   V8_EXPORT void CheckValue() const;
 
-  V8_INLINE internal::Address address() const { return *val_; }
-
-  // val_ points to a GlobalHandles node.
-  internal::Address* val_ = nullptr;
-
   friend class internal::BasicTracedReferenceExtractor;
-  friend class internal::HandleHelper;
   template <typename F>
   friend class Local;
   template <typename U>
@@ -139,12 +127,7 @@ class BasicTracedReference : public TracedReferenceBase {
   /**
    * Construct a Local<T> from this handle.
    */
-  Local<T> Get(Isolate* isolate) const {
-#ifdef V8_ENABLE_CONSERVATIVE_STACK_SCANNING
-    if (val_ == nullptr) return Local<T>();
-#endif
-    return Local<T>::New(isolate, *this);
-  }
+  Local<T> Get(Isolate* isolate) const { return Local<T>::New(isolate, *this); }
 
   template <class S>
   V8_INLINE BasicTracedReference<S>& As() const {
@@ -152,28 +135,27 @@ class BasicTracedReference : public TracedReferenceBase {
         const_cast<BasicTracedReference<T>&>(*this));
   }
 
-  T* operator->() const {
+  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 reinterpret_cast<T*>(val_);
-  }
-  T* operator*() const {
-#ifdef V8_ENABLE_CHECKS
-    CheckValue();
-#endif  // V8_ENABLE_CHECKS
-    return reinterpret_cast<T*>(val_);
+    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(
-      Isolate* isolate, T* that, void* slot,
-      internal::GlobalHandleStoreMode store_mode);
+  V8_INLINE static internal::Address* NewFromNonEmptyValue(
+      Isolate* isolate, T* that, internal::Address** slot,
+      internal::TracedReferenceStoreMode store_mode,
+      internal::TracedReferenceHandling reference_handling);
 
   template <typename F>
   friend class Local;
@@ -194,12 +176,14 @@ class BasicTracedReference : public TracedReferenceBase {
 template <typename T>
 class TracedReference : public BasicTracedReference<T> {
  public:
+  struct IsDroppable {};
+
   using BasicTracedReference<T>::Reset;
 
   /**
    * An empty TracedReference without storage cell.
    */
-  TracedReference() : BasicTracedReference<T>() {}
+  V8_INLINE TracedReference() = default;
 
   /**
    * Construct a TracedReference from a Local.
@@ -209,9 +193,35 @@ class TracedReference : public BasicTracedReference<T> {
    */
   template <class S>
   TracedReference(Isolate* isolate, Local<S> that) : BasicTracedReference<T>() {
-    this->val_ = this->New(isolate, *that, &this->val_,
-                           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);
   }
 
   /**
@@ -275,12 +285,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>&>(
@@ -290,19 +307,22 @@ class TracedReference : public BasicTracedReference<T> {
 
 // --- Implementation ---
 template <class T>
-internal::Address* BasicTracedReference<T>::New(
-    Isolate* isolate, T* that, void* slot,
-    internal::GlobalHandleStoreMode store_mode) {
-  if (that == internal::ValueHelper::EmptyValue<T>()) return nullptr;
-  internal::Address* p = reinterpret_cast<internal::Address*>(that);
+internal::Address* BasicTracedReference<T>::NewFromNonEmptyValue(
+    Isolate* isolate, T* that, internal::Address** slot,
+    internal::TracedReferenceStoreMode store_mode,
+    internal::TracedReferenceHandling reference_handling) {
   return internal::GlobalizeTracedReference(
-      reinterpret_cast<internal::Isolate*>(isolate), p,
-      reinterpret_cast<internal::Address*>(slot), store_mode);
+      reinterpret_cast<internal::Isolate*>(isolate),
+      internal::ValueHelper::ValueAsAddress(that),
+      reinterpret_cast<internal::Address*>(slot), store_mode,
+      reference_handling);
 }
 
 void TracedReferenceBase::Reset() {
-  if (IsEmpty()) return;
-  internal::DisposeTracedReference(reinterpret_cast<internal::Address*>(val_));
+  if (V8_UNLIKELY(IsEmpty())) {
+    return;
+  }
+  internal::DisposeTracedReference(slot());
   SetSlotThreadSafe(nullptr);
 }
 
@@ -345,10 +365,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->val_,
-                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>
@@ -373,9 +411,7 @@ template <class T>
 TracedReference<T>& TracedReference<T>::operator=(
     TracedReference&& rhs) noexcept {
   if (this != &rhs) {
-    internal::MoveTracedReference(
-        reinterpret_cast<internal::Address**>(&rhs.val_),
-        reinterpret_cast<internal::Address**>(&this->val_));
+    internal::MoveTracedReference(&rhs.slot(), &this->slot());
   }
   return *this;
 }
@@ -384,31 +420,13 @@ template <class T>
 TracedReference<T>& TracedReference<T>::operator=(const TracedReference& rhs) {
   if (this != &rhs) {
     this->Reset();
-    if (rhs.val_ != nullptr) {
-      internal::CopyTracedReference(
-          reinterpret_cast<const internal::Address* const*>(&rhs.val_),
-          reinterpret_cast<internal::Address**>(&this->val_));
+    if (!rhs.IsEmpty()) {
+      internal::CopyTracedReference(&rhs.slot(), &this->slot());
     }
   }
   return *this;
 }
 
-void TracedReferenceBase::SetWrapperClassId(uint16_t class_id) {
-  using I = internal::Internals;
-  if (IsEmpty()) return;
-  internal::Address* obj = reinterpret_cast<internal::Address*>(val_);
-  uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + I::kTracedNodeClassIdOffset;
-  *reinterpret_cast<uint16_t*>(addr) = class_id;
-}
-
-uint16_t TracedReferenceBase::WrapperClassId() const {
-  using I = internal::Internals;
-  if (IsEmpty()) return 0;
-  internal::Address* obj = reinterpret_cast<internal::Address*>(val_);
-  uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + 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,19 @@ 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);
+#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);
+#endif
 
   /**
    * Number of elements in this typed array
@@ -50,6 +57,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 +85,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 +114,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 +142,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 +170,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 +198,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 +226,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 +249,42 @@ class V8_EXPORT Int32Array : public TypedArray {
   static void CheckCast(Value* obj);
 };
 
+/**
+ * An instance of Float16Array constructor.
+ */
+class V8_EXPORT Float16Array : public TypedArray {
+  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,
+                                 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 +306,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 +334,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 +362,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.h

@@ -33,7 +33,7 @@ struct V8_EXPORT RegisterState {
 };
 
 // A StateTag represents a possible state of the VM.
-enum StateTag : int {
+enum StateTag : uint16_t {
   JS,
   GC,
   PARSER,