libv8-node 22.7.0.4-arm64-darwin → 24.1.0.0-arm64-darwin

data/vendor/v8/include/cppgc/macros.h

@@ -11,10 +11,18 @@
 
 namespace cppgc {
 
+#define CPPGC_DISALLOW_NEW()                                      \
+ public:                                                          \
+  using IsDisallowNewMarker CPPGC_UNUSED = int;                   \
+  void* operator new(size_t, void* location) { return location; } \
+  void* operator new(size_t) = delete;                            \
+  static_assert(true, "Force semicolon.")
+
 // Use CPPGC_STACK_ALLOCATED if the object is only stack allocated.
 // Add the CPPGC_STACK_ALLOCATED_IGNORE annotation on a case-by-case basis when
 // enforcement of CPPGC_STACK_ALLOCATED should be suppressed.
 #if defined(__clang__)
+
 #define CPPGC_STACK_ALLOCATED()                        \
  public:                                               \
   using IsStackAllocatedTypeMarker CPPGC_UNUSED = int; \
@@ -23,13 +31,26 @@ namespace cppgc {
   void* operator new(size_t) = delete;                 \
   void* operator new(size_t, void*) = delete;          \
   static_assert(true, "Force semicolon.")
+
 #define CPPGC_STACK_ALLOCATED_IGNORE(bug_or_reason) \
   __attribute__((annotate("stack_allocated_ignore")))
+
+#define CPPGC_PLUGIN_IGNORE(bug_or_reason)           \
+  __attribute__((annotate("blink_gc_plugin_ignore"), \
+                 annotate("stack_allocated_ignore")))
+
 #else  // !defined(__clang__)
+
 #define CPPGC_STACK_ALLOCATED() static_assert(true, "Force semicolon.")
 #define CPPGC_STACK_ALLOCATED_IGNORE(bug_or_reason)
+#define CPPGC_PLUGIN_IGNORE(bug_or_reason)
+
 #endif  // !defined(__clang__)
 
+template <typename T>
+concept IsStackAllocatedType =
+    requires { typename T::IsStackAllocatedTypeMarker; };
+
 }  // namespace cppgc
 
 #endif  // INCLUDE_CPPGC_MACROS_H_

data/vendor/v8/include/cppgc/member.h

@@ -38,9 +38,8 @@ class V8_TRIVIAL_ABI MemberBase {
 
   V8_INLINE MemberBase() = default;
   V8_INLINE explicit MemberBase(const void* value) : raw_(value) {}
-  V8_INLINE MemberBase(const void* value, AtomicInitializerTag) {
-    SetRawAtomic(value);
-  }
+  V8_INLINE MemberBase(const void* value, AtomicInitializerTag)
+      : raw_(value, typename RawStorage::AtomicInitializerTag{}) {}
 
   V8_INLINE explicit MemberBase(RawStorage raw) : raw_(raw) {}
   V8_INLINE explicit MemberBase(std::nullptr_t) : raw_(nullptr) {}
@@ -87,7 +86,7 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
   V8_INLINE BasicMember(SentinelPointer s) : Base(s) {}  // NOLINT
   V8_INLINE BasicMember(T* raw) : Base(raw) {            // NOLINT
     InitializingWriteBarrier(raw);
-    this->CheckPointer(Get());
+    CheckPointer(raw);
   }
   V8_INLINE BasicMember(T& raw)  // NOLINT
       : BasicMember(&raw) {}
@@ -103,7 +102,7 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
   V8_INLINE BasicMember(T* raw, AtomicInitializerTag atomic)
       : Base(raw, atomic) {
     InitializingWriteBarrier(raw);
-    this->CheckPointer(Get());
+    CheckPointer(raw);
   }
   V8_INLINE BasicMember(T& raw, AtomicInitializerTag atomic)
       : BasicMember(&raw, atomic) {}
@@ -117,7 +116,7 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
   // need to be adjusted.
   template <typename U, typename OtherBarrierPolicy, typename OtherWeaknessTag,
             typename OtherCheckingPolicy,
-            std::enable_if_t<internal::IsDecayedSameV<T, U>>* = nullptr>
+            std::enable_if_t<IsDecayedSameV<T, U>>* = nullptr>
   V8_INLINE BasicMember(  // NOLINT
       const BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
                         OtherCheckingPolicy, StorageType>& other)
@@ -125,7 +124,7 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
 
   template <typename U, typename OtherBarrierPolicy, typename OtherWeaknessTag,
             typename OtherCheckingPolicy,
-            std::enable_if_t<internal::IsStrictlyBaseOfV<T, U>>* = nullptr>
+            std::enable_if_t<IsStrictlyBaseOfV<T, U>>* = nullptr>
   V8_INLINE BasicMember(  // NOLINT
       const BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
                         OtherCheckingPolicy, StorageType>& other)
@@ -142,7 +141,7 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
   // need to be adjusted.
   template <typename U, typename OtherBarrierPolicy, typename OtherWeaknessTag,
             typename OtherCheckingPolicy,
-            std::enable_if_t<internal::IsDecayedSameV<T, U>>* = nullptr>
+            std::enable_if_t<IsDecayedSameV<T, U>>* = nullptr>
   V8_INLINE BasicMember(
       BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy, OtherCheckingPolicy,
                   StorageType>&& other) noexcept
@@ -152,7 +151,7 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
 
   template <typename U, typename OtherBarrierPolicy, typename OtherWeaknessTag,
             typename OtherCheckingPolicy,
-            std::enable_if_t<internal::IsStrictlyBaseOfV<T, U>>* = nullptr>
+            std::enable_if_t<IsStrictlyBaseOfV<T, U>>* = nullptr>
   V8_INLINE BasicMember(
       BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy, OtherCheckingPolicy,
                   StorageType>&& other) noexcept
@@ -183,10 +182,10 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
   V8_INLINE BasicMember& operator=(
       const BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
                         OtherCheckingPolicy, StorageType>& other) {
-    if constexpr (internal::IsDecayedSameV<T, U>) {
+    if constexpr (IsDecayedSameV<T, U>) {
       return operator=(other.GetRawStorage());
     } else {
-      static_assert(internal::IsStrictlyBaseOfV<T, U>);
+      static_assert(IsStrictlyBaseOfV<T, U>);
       return operator=(other.Get());
     }
   }
@@ -206,10 +205,10 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
   V8_INLINE BasicMember& operator=(
       BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy, OtherCheckingPolicy,
                   StorageType>&& other) noexcept {
-    if constexpr (internal::IsDecayedSameV<T, U>) {
+    if constexpr (IsDecayedSameV<T, U>) {
       operator=(other.GetRawStorage());
     } else {
-      static_assert(internal::IsStrictlyBaseOfV<T, U>);
+      static_assert(IsStrictlyBaseOfV<T, U>);
       operator=(other.Get());
     }
     other.Clear();
@@ -231,7 +230,7 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
   V8_INLINE BasicMember& operator=(T* other) {
     Base::SetRawAtomic(other);
     AssigningWriteBarrier(other);
-    this->CheckPointer(Get());
+    CheckPointer(other);
     return *this;
   }
 
@@ -270,9 +269,7 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
     return static_cast<T*>(const_cast<void*>(Base::GetRaw()));
   }
 
-  V8_INLINE void Clear() {
-    Base::SetRawStorageAtomic(RawStorage{});
-  }
+  V8_INLINE void Clear() { Base::SetRawStorageAtomic(RawStorage{}); }
 
   V8_INLINE T* Release() {
     T* result = Get();
@@ -284,20 +281,18 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
     return reinterpret_cast<const T**>(Base::GetRawSlot());
   }
 
-  V8_INLINE RawStorage GetRawStorage() const {
-    return Base::GetRawStorage();
-  }
+  V8_INLINE RawStorage GetRawStorage() const { return Base::GetRawStorage(); }
 
  private:
   V8_INLINE explicit BasicMember(RawStorage raw) : Base(raw) {
-    InitializingWriteBarrier(Get());
-    this->CheckPointer(Get());
+    InitializingWriteBarrier();
+    CheckPointer();
   }
 
   V8_INLINE BasicMember& operator=(RawStorage other) {
     Base::SetRawStorageAtomic(other);
     AssigningWriteBarrier();
-    this->CheckPointer(Get());
+    CheckPointer();
     return *this;
   }
 
@@ -308,6 +303,10 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
   V8_INLINE void InitializingWriteBarrier(T* value) const {
     WriteBarrierPolicy::InitializingBarrier(Base::GetRawSlot(), value);
   }
+  V8_INLINE void InitializingWriteBarrier() const {
+    WriteBarrierPolicy::InitializingBarrier(Base::GetRawSlot(),
+                                            Base::GetRawStorage());
+  }
   V8_INLINE void AssigningWriteBarrier(T* value) const {
     WriteBarrierPolicy::template AssigningBarrier<
         StorageType::kWriteBarrierSlotType>(Base::GetRawSlot(), value);
@@ -317,6 +316,12 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
         StorageType::kWriteBarrierSlotType>(Base::GetRawSlot(),
                                             Base::GetRawStorage());
   }
+  V8_INLINE void CheckPointer(T* value) {
+    CheckingPolicy::template CheckPointer<T>(value);
+  }
+  V8_INLINE void CheckPointer() {
+    CheckingPolicy::template CheckPointer<T>(Base::GetRawStorage());
+  }
 
   V8_INLINE void ClearFromGC() const { Base::ClearFromGC(); }
 
@@ -341,12 +346,11 @@ V8_INLINE bool operator==(
                       StorageType>& member1,
     const BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2, CheckingPolicy2,
                       StorageType>& member2) {
-  if constexpr (internal::IsDecayedSameV<T1, T2>) {
+  if constexpr (IsDecayedSameV<T1, T2>) {
     // Check compressed pointers if types are the same.
     return member1.GetRawStorage() == member2.GetRawStorage();
   } else {
-    static_assert(internal::IsStrictlyBaseOfV<T1, T2> ||
-                  internal::IsStrictlyBaseOfV<T2, T1>);
+    static_assert(IsStrictlyBaseOfV<T1, T2> || IsStrictlyBaseOfV<T2, T1>);
     // Otherwise, check decompressed pointers.
     return member1.Get() == member2.Get();
   }
@@ -372,12 +376,12 @@ V8_INLINE bool operator==(
                       StorageType>& member,
     U* raw) {
   // Never allow comparison with erased pointers.
-  static_assert(!internal::IsDecayedSameV<void, U>);
+  static_assert(!IsDecayedSameV<void, U>);
 
-  if constexpr (internal::IsDecayedSameV<T, U>) {
+  if constexpr (IsDecayedSameV<T, U>) {
     // Check compressed pointers if types are the same.
     return member.GetRawStorage() == StorageType(raw);
-  } else if constexpr (internal::IsStrictlyBaseOfV<T, U>) {
+  } else if constexpr (IsStrictlyBaseOfV<T, U>) {
     // Cast the raw pointer to T, which may adjust the pointer.
     return member.GetRawStorage() == StorageType(static_cast<T*>(raw));
   } else {
@@ -494,7 +498,7 @@ V8_INLINE bool operator<(
     const BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2, CheckingPolicy2,
                       StorageType>& member2) {
   static_assert(
-      internal::IsDecayedSameV<T1, T2>,
+      IsDecayedSameV<T1, T2>,
       "Comparison works only for same pointer type modulo cv-qualifiers");
   return member1.GetRawStorage() < member2.GetRawStorage();
 }
@@ -509,7 +513,7 @@ V8_INLINE bool operator<=(
     const BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2, CheckingPolicy2,
                       StorageType>& member2) {
   static_assert(
-      internal::IsDecayedSameV<T1, T2>,
+      IsDecayedSameV<T1, T2>,
       "Comparison works only for same pointer type modulo cv-qualifiers");
   return member1.GetRawStorage() <= member2.GetRawStorage();
 }
@@ -524,7 +528,7 @@ V8_INLINE bool operator>(
     const BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2, CheckingPolicy2,
                       StorageType>& member2) {
   static_assert(
-      internal::IsDecayedSameV<T1, T2>,
+      IsDecayedSameV<T1, T2>,
       "Comparison works only for same pointer type modulo cv-qualifiers");
   return member1.GetRawStorage() > member2.GetRawStorage();
 }
@@ -539,16 +543,15 @@ V8_INLINE bool operator>=(
     const BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2, CheckingPolicy2,
                       StorageType>& member2) {
   static_assert(
-      internal::IsDecayedSameV<T1, T2>,
+      IsDecayedSameV<T1, T2>,
       "Comparison works only for same pointer type modulo cv-qualifiers");
   return member1.GetRawStorage() >= member2.GetRawStorage();
 }
 
 template <typename T, typename WriteBarrierPolicy, typename CheckingPolicy,
           typename StorageType>
-struct IsWeak<internal::BasicMember<T, WeakMemberTag, WriteBarrierPolicy,
-                                    CheckingPolicy, StorageType>>
-    : std::true_type {};
+struct IsWeak<BasicMember<T, WeakMemberTag, WriteBarrierPolicy, CheckingPolicy,
+                          StorageType>> : std::true_type {};
 
 }  // namespace internal
 
@@ -626,4 +629,35 @@ static constexpr size_t kSizeofCompressedMember =
 
 }  // namespace cppgc
 
+// Mark `BasicMember<T>` and `T*` as having a common reference type of `T*` (the
+// type to which both can be converted or bound). This makes them satisfy
+// `std::equality_comparable`, which allows usage like the following:
+// ```
+//   HeapVector<Member<T>> v;
+//   T* e;
+//   auto it = std::ranges::find(v, e);
+// ```
+// Without this, the `find()` call above would fail to compile with an error
+// about being unable to invoke `std::ranges::equal_to()`.
+template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
+          typename CheckingPolicy, typename StorageType,
+          template <typename> typename TQ, template <typename> typename UQ>
+struct std::basic_common_reference<
+    cppgc::internal::BasicMember<T, WeaknessTag, WriteBarrierPolicy,
+                                 CheckingPolicy, StorageType>,
+    T*, TQ, UQ> {
+  using type = T*;
+};
+
+template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
+          typename CheckingPolicy, typename StorageType,
+          template <typename> typename TQ, template <typename> typename UQ>
+struct std::basic_common_reference<
+    T*,
+    cppgc::internal::BasicMember<T, WeaknessTag, WriteBarrierPolicy,
+                                 CheckingPolicy, StorageType>,
+    TQ, UQ> {
+  using type = T*;
+};
+
 #endif  // INCLUDE_CPPGC_MEMBER_H_

data/vendor/v8/include/cppgc/name-provider.h

@@ -55,6 +55,16 @@ class V8_EXPORT NameProvider {
    * Specifies a name for the garbage-collected object. Such names will never
    * be hidden, as they are explicitly specified by the user of this API.
    *
+   * Implementations of this function must not allocate garbage-collected
+   * objects or otherwise modify the cppgc heap.
+   *
+   * V8 may call this function while generating a heap snapshot or at other
+   * times. If V8 is currently generating a heap snapshot (according to
+   * HeapProfiler::IsTakingSnapshot), then the returned string must stay alive
+   * until the snapshot generation has completed. Otherwise, the returned string
+   * must stay alive forever. If you need a place to store a temporary string
+   * during snapshot generation, use HeapProfiler::CopyNameForHeapSnapshot.
+   *
    * @returns a human readable name for the object.
    */
   virtual const char* GetHumanReadableName() const = 0;

data/vendor/v8/include/cppgc/platform.h

@@ -52,6 +52,15 @@ class V8_EXPORT Platform {
    * Foreground task runner that should be used by a Heap.
    */
   virtual std::shared_ptr<TaskRunner> GetForegroundTaskRunner() {
+    return GetForegroundTaskRunner(TaskPriority::kUserBlocking);
+  }
+
+  /**
+   * Returns a TaskRunner with a specific |priority| which can be used to post a
+   * task on the foreground thread.
+   */
+  virtual std::shared_ptr<TaskRunner> GetForegroundTaskRunner(
+      TaskPriority priority) {
     return nullptr;
   }
 
@@ -127,6 +136,8 @@ class V8_EXPORT Platform {
   virtual TracingController* GetTracingController();
 };
 
+V8_EXPORT bool IsInitialized();
+
 /**
  * Process-global initialization of the garbage collector. Must be called before
  * creating a Heap.

data/vendor/v8/include/cppgc/type-traits.h

@@ -9,6 +9,7 @@
 // against Oilpan types without including any other parts.
 #include <cstddef>
 #include <type_traits>
+#include <utility>
 
 namespace cppgc {
 

data/vendor/v8/include/cppgc/visitor.h

@@ -8,12 +8,12 @@
 #include <type_traits>
 
 #include "cppgc/custom-space.h"
-#include "cppgc/ephemeron-pair.h"
 #include "cppgc/garbage-collected.h"
 #include "cppgc/internal/logging.h"
 #include "cppgc/internal/member-storage.h"
 #include "cppgc/internal/pointer-policies.h"
 #include "cppgc/liveness-broker.h"
+#include "cppgc/macros.h"
 #include "cppgc/member.h"
 #include "cppgc/sentinel-pointer.h"
 #include "cppgc/source-location.h"
@@ -36,6 +36,25 @@ class VisitorFactory;
 
 using WeakCallback = void (*)(const LivenessBroker&, const void*);
 
+/**
+ * An ephemeron pair is used to conditionally retain an object.
+ * The `value` will be kept alive only if the `key` is alive.
+ */
+template <typename K, typename V>
+struct EphemeronPair {
+  CPPGC_DISALLOW_NEW();
+
+  EphemeronPair(K* k, V* v) : key(k), value(v) {}
+  WeakMember<K> key;
+  Member<V> value;
+
+  void ClearValueIfKeyIsDead(const LivenessBroker& broker) {
+    if (!broker.IsHeapObjectAlive(key)) value = nullptr;
+  }
+
+  void Trace(Visitor* visitor) const;
+};
+
 /**
  * Visitor passed to trace methods. All managed pointers must have called the
  * Visitor's trace method on them.
@@ -436,6 +455,11 @@ class V8_EXPORT Visitor {
   friend class internal::VisitorBase;
 };
 
+template <typename K, typename V>
+void EphemeronPair<K, V>::Trace(Visitor* visitor) const {
+  visitor->TraceEphemeron(key, value);
+}
+
 namespace internal {
 
 class V8_EXPORT RootVisitor {

data/vendor/v8/include/libplatform/libplatform-export.h

@@ -18,11 +18,11 @@
 #else  // defined(_WIN32)
 
 // Setup for Linux shared library export.
-#ifdef BUILDING_V8_PLATFORM_SHARED
+#if defined(BUILDING_V8_PLATFORM_SHARED) || USING_V8_PLATFORM_SHARED
 #define V8_PLATFORM_EXPORT __attribute__((visibility("default")))
 #else
 #define V8_PLATFORM_EXPORT
-#endif
+#endif  // defined(BUILDING_V8_PLATFORM_SHARED) || ...
 
 #endif  // defined(_WIN32)
 

data/vendor/v8/include/libplatform/v8-tracing.h

@@ -6,7 +6,6 @@
 #define V8_LIBPLATFORM_V8_TRACING_H_
 
 #include <atomic>
-#include <fstream>
 #include <memory>
 #include <unordered_set>
 #include <vector>