libv8-node 18.13.0.0-x86_64-linux-musl → 19.9.0.0-x86_64-linux-musl

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

@@ -9,6 +9,8 @@
 #include <cstddef>
 #include <type_traits>
 
+#include "cppgc/internal/api-constants.h"
+#include "cppgc/internal/member-storage.h"
 #include "cppgc/internal/pointer-policies.h"
 #include "cppgc/sentinel-pointer.h"
 #include "cppgc/type-traits.h"
@@ -16,177 +18,247 @@
 
 namespace cppgc {
 
+namespace subtle {
+class HeapConsistency;
+}  // namespace subtle
+
 class Visitor;
 
 namespace internal {
 
 // MemberBase always refers to the object as const object and defers to
 // BasicMember on casting to the right type as needed.
-class MemberBase {
+class V8_TRIVIAL_ABI MemberBase {
+ public:
+#if defined(CPPGC_POINTER_COMPRESSION)
+  using RawStorage = CompressedPointer;
+#else   // !defined(CPPGC_POINTER_COMPRESSION)
+  using RawStorage = RawPointer;
+#endif  // !defined(CPPGC_POINTER_COMPRESSION)
  protected:
   struct AtomicInitializerTag {};
 
-  MemberBase() : raw_(nullptr) {}
-  explicit MemberBase(const void* value) : raw_(value) {}
-  MemberBase(const void* value, AtomicInitializerTag) { SetRawAtomic(value); }
+  V8_INLINE MemberBase() = default;
+  V8_INLINE explicit MemberBase(const void* value) : raw_(value) {}
+  V8_INLINE MemberBase(const void* value, AtomicInitializerTag) {
+    SetRawAtomic(value);
+  }
 
-  const void** GetRawSlot() const { return &raw_; }
-  const void* GetRaw() const { return raw_; }
-  void SetRaw(void* value) { raw_ = value; }
+  V8_INLINE explicit MemberBase(RawStorage raw) : raw_(raw) {}
+  V8_INLINE explicit MemberBase(std::nullptr_t) : raw_(nullptr) {}
+  V8_INLINE explicit MemberBase(SentinelPointer s) : raw_(s) {}
 
-  const void* GetRawAtomic() const {
-    return reinterpret_cast<const std::atomic<const void*>*>(&raw_)->load(
-        std::memory_order_relaxed);
+  V8_INLINE const void** GetRawSlot() const {
+    return reinterpret_cast<const void**>(const_cast<MemberBase*>(this));
   }
-  void SetRawAtomic(const void* value) {
-    reinterpret_cast<std::atomic<const void*>*>(&raw_)->store(
-        value, std::memory_order_relaxed);
+  V8_INLINE const void* GetRaw() const { return raw_.Load(); }
+  V8_INLINE void SetRaw(void* value) { raw_.Store(value); }
+
+  V8_INLINE const void* GetRawAtomic() const { return raw_.LoadAtomic(); }
+  V8_INLINE void SetRawAtomic(const void* value) { raw_.StoreAtomic(value); }
+
+  V8_INLINE RawStorage GetRawStorage() const { return raw_; }
+  V8_INLINE void SetRawStorageAtomic(RawStorage other) {
+    reinterpret_cast<std::atomic<RawStorage>&>(raw_).store(
+        other, std::memory_order_relaxed);
   }
 
-  void ClearFromGC() const { raw_ = nullptr; }
+  V8_INLINE bool IsCleared() const { return raw_.IsCleared(); }
+
+  V8_INLINE void ClearFromGC() const { raw_.Clear(); }
 
  private:
-  // All constructors initialize `raw_`. Do not add a default value here as it
-  // results in a non-atomic write on some builds, even when the atomic version
-  // of the constructor is used.
-  mutable const void* raw_;
+  friend class MemberDebugHelper;
+
+  mutable RawStorage raw_;
 };
 
 // The basic class from which all Member classes are 'generated'.
 template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
           typename CheckingPolicy>
-class BasicMember final : private MemberBase, private CheckingPolicy {
+class V8_TRIVIAL_ABI BasicMember final : private MemberBase,
+                                         private CheckingPolicy {
  public:
   using PointeeType = T;
 
-  constexpr BasicMember() = default;
-  constexpr BasicMember(std::nullptr_t) {}     // NOLINT
-  BasicMember(SentinelPointer s) : MemberBase(s) {}  // NOLINT
-  BasicMember(T* raw) : MemberBase(raw) {            // NOLINT
-    InitializingWriteBarrier();
+  V8_INLINE constexpr BasicMember() = default;
+  V8_INLINE constexpr BasicMember(std::nullptr_t) {}           // NOLINT
+  V8_INLINE BasicMember(SentinelPointer s) : MemberBase(s) {}  // NOLINT
+  V8_INLINE BasicMember(T* raw) : MemberBase(raw) {            // NOLINT
+    InitializingWriteBarrier(raw);
     this->CheckPointer(Get());
   }
-  BasicMember(T& raw) : BasicMember(&raw) {}  // NOLINT
+  V8_INLINE BasicMember(T& raw)  // NOLINT
+      : BasicMember(&raw) {}
+
   // Atomic ctor. Using the AtomicInitializerTag forces BasicMember to
   // initialize using atomic assignments. This is required for preventing
   // data races with concurrent marking.
   using AtomicInitializerTag = MemberBase::AtomicInitializerTag;
-  BasicMember(std::nullptr_t, AtomicInitializerTag atomic)
+  V8_INLINE BasicMember(std::nullptr_t, AtomicInitializerTag atomic)
       : MemberBase(nullptr, atomic) {}
-  BasicMember(SentinelPointer s, AtomicInitializerTag atomic)
+  V8_INLINE BasicMember(SentinelPointer s, AtomicInitializerTag atomic)
       : MemberBase(s, atomic) {}
-  BasicMember(T* raw, AtomicInitializerTag atomic) : MemberBase(raw, atomic) {
-    InitializingWriteBarrier();
+  V8_INLINE BasicMember(T* raw, AtomicInitializerTag atomic)
+      : MemberBase(raw, atomic) {
+    InitializingWriteBarrier(raw);
     this->CheckPointer(Get());
   }
-  BasicMember(T& raw, AtomicInitializerTag atomic)
+  V8_INLINE BasicMember(T& raw, AtomicInitializerTag atomic)
       : BasicMember(&raw, atomic) {}
+
   // Copy ctor.
-  BasicMember(const BasicMember& other) : BasicMember(other.Get()) {}
-  // Allow heterogeneous construction.
+  V8_INLINE BasicMember(const BasicMember& other)
+      : BasicMember(other.GetRawStorage()) {}
+
+  // Heterogeneous copy constructors. When the source pointer have a different
+  // type, perform a compress-decompress round, because the source pointer may
+  // need to be adjusted.
   template <typename U, typename OtherBarrierPolicy, typename OtherWeaknessTag,
             typename OtherCheckingPolicy,
-            typename = std::enable_if_t<std::is_base_of<T, U>::value>>
-  BasicMember(  // NOLINT
+            std::enable_if_t<internal::IsDecayedSameV<T, U>>* = nullptr>
+  V8_INLINE BasicMember(  // NOLINT
+      const BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
+                        OtherCheckingPolicy>& other)
+      : BasicMember(other.GetRawStorage()) {}
+
+  template <typename U, typename OtherBarrierPolicy, typename OtherWeaknessTag,
+            typename OtherCheckingPolicy,
+            std::enable_if_t<internal::IsStrictlyBaseOfV<T, U>>* = nullptr>
+  V8_INLINE BasicMember(  // NOLINT
       const BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
                         OtherCheckingPolicy>& other)
       : BasicMember(other.Get()) {}
+
   // Move ctor.
-  BasicMember(BasicMember&& other) noexcept : BasicMember(other.Get()) {
+  V8_INLINE BasicMember(BasicMember&& other) noexcept
+      : BasicMember(other.GetRawStorage()) {
     other.Clear();
   }
-  // Allow heterogeneous move construction.
+
+  // Heterogeneous move constructors. When the source pointer have a different
+  // type, perform a compress-decompress round, because the source pointer may
+  // need to be adjusted.
   template <typename U, typename OtherBarrierPolicy, typename OtherWeaknessTag,
             typename OtherCheckingPolicy,
-            typename = std::enable_if_t<std::is_base_of<T, U>::value>>
-  BasicMember(BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
-                          OtherCheckingPolicy>&& other) noexcept
+            std::enable_if_t<internal::IsDecayedSameV<T, U>>* = nullptr>
+  V8_INLINE BasicMember(BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
+                                    OtherCheckingPolicy>&& other) noexcept
+      : BasicMember(other.GetRawStorage()) {
+    other.Clear();
+  }
+
+  template <typename U, typename OtherBarrierPolicy, typename OtherWeaknessTag,
+            typename OtherCheckingPolicy,
+            std::enable_if_t<internal::IsStrictlyBaseOfV<T, U>>* = nullptr>
+  V8_INLINE BasicMember(BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
+                                    OtherCheckingPolicy>&& other) noexcept
       : BasicMember(other.Get()) {
     other.Clear();
   }
+
   // Construction from Persistent.
   template <typename U, typename PersistentWeaknessPolicy,
             typename PersistentLocationPolicy,
             typename PersistentCheckingPolicy,
             typename = std::enable_if_t<std::is_base_of<T, U>::value>>
-  BasicMember(const BasicPersistent<U, PersistentWeaknessPolicy,
-                                    PersistentLocationPolicy,
-                                    PersistentCheckingPolicy>& p)
+  V8_INLINE BasicMember(const BasicPersistent<U, PersistentWeaknessPolicy,
+                                              PersistentLocationPolicy,
+                                              PersistentCheckingPolicy>& p)
       : BasicMember(p.Get()) {}
 
   // Copy assignment.
-  BasicMember& operator=(const BasicMember& other) {
-    return operator=(other.Get());
+  V8_INLINE BasicMember& operator=(const BasicMember& other) {
+    return operator=(other.GetRawStorage());
   }
-  // Allow heterogeneous copy assignment.
+
+  // Heterogeneous copy assignment. When the source pointer have a different
+  // type, perform a compress-decompress round, because the source pointer may
+  // need to be adjusted.
   template <typename U, typename OtherWeaknessTag, typename OtherBarrierPolicy,
-            typename OtherCheckingPolicy,
-            typename = std::enable_if_t<std::is_base_of<T, U>::value>>
-  BasicMember& operator=(
+            typename OtherCheckingPolicy>
+  V8_INLINE BasicMember& operator=(
       const BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
                         OtherCheckingPolicy>& other) {
-    return operator=(other.Get());
+    if constexpr (internal::IsDecayedSameV<T, U>) {
+      return operator=(other.GetRawStorage());
+    } else {
+      static_assert(internal::IsStrictlyBaseOfV<T, U>);
+      return operator=(other.Get());
+    }
   }
+
   // Move assignment.
-  BasicMember& operator=(BasicMember&& other) noexcept {
-    operator=(other.Get());
+  V8_INLINE BasicMember& operator=(BasicMember&& other) noexcept {
+    operator=(other.GetRawStorage());
     other.Clear();
     return *this;
   }
-  // Heterogeneous move assignment.
+
+  // Heterogeneous move assignment. When the source pointer have a different
+  // type, perform a compress-decompress round, because the source pointer may
+  // need to be adjusted.
   template <typename U, typename OtherWeaknessTag, typename OtherBarrierPolicy,
-            typename OtherCheckingPolicy,
-            typename = std::enable_if_t<std::is_base_of<T, U>::value>>
-  BasicMember& operator=(BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
-                                     OtherCheckingPolicy>&& other) noexcept {
-    operator=(other.Get());
+            typename OtherCheckingPolicy>
+  V8_INLINE BasicMember& operator=(
+      BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
+                  OtherCheckingPolicy>&& other) noexcept {
+    if constexpr (internal::IsDecayedSameV<T, U>) {
+      operator=(other.GetRawStorage());
+    } else {
+      static_assert(internal::IsStrictlyBaseOfV<T, U>);
+      operator=(other.Get());
+    }
     other.Clear();
     return *this;
   }
+
   // Assignment from Persistent.
   template <typename U, typename PersistentWeaknessPolicy,
             typename PersistentLocationPolicy,
             typename PersistentCheckingPolicy,
             typename = std::enable_if_t<std::is_base_of<T, U>::value>>
-  BasicMember& operator=(
+  V8_INLINE BasicMember& operator=(
       const BasicPersistent<U, PersistentWeaknessPolicy,
                             PersistentLocationPolicy, PersistentCheckingPolicy>&
           other) {
     return operator=(other.Get());
   }
-  BasicMember& operator=(T* other) {
+
+  V8_INLINE BasicMember& operator=(T* other) {
     SetRawAtomic(other);
-    AssigningWriteBarrier();
+    AssigningWriteBarrier(other);
     this->CheckPointer(Get());
     return *this;
   }
-  BasicMember& operator=(std::nullptr_t) {
+
+  V8_INLINE BasicMember& operator=(std::nullptr_t) {
     Clear();
     return *this;
   }
-  BasicMember& operator=(SentinelPointer s) {
+  V8_INLINE BasicMember& operator=(SentinelPointer s) {
     SetRawAtomic(s);
     return *this;
   }
 
   template <typename OtherWeaknessTag, typename OtherBarrierPolicy,
             typename OtherCheckingPolicy>
-  void Swap(BasicMember<T, OtherWeaknessTag, OtherBarrierPolicy,
-                        OtherCheckingPolicy>& other) {
-    T* tmp = Get();
+  V8_INLINE void Swap(BasicMember<T, OtherWeaknessTag, OtherBarrierPolicy,
+                                  OtherCheckingPolicy>& other) {
+    auto tmp = GetRawStorage();
     *this = other;
     other = tmp;
   }
 
-  explicit operator bool() const { return Get(); }
-  operator T*() const { return Get(); }
-  T* operator->() const { return Get(); }
-  T& operator*() const { return *Get(); }
+  V8_INLINE explicit operator bool() const { return !IsCleared(); }
+  V8_INLINE operator T*() const { return Get(); }
+  V8_INLINE T* operator->() const { return Get(); }
+  V8_INLINE T& operator*() const { return *Get(); }
 
   // CFI cast exemption to allow passing SentinelPointer through T* and support
   // heterogeneous assignments between different Member and Persistent handles
   // based on their actual types.
-  V8_CLANG_NO_SANITIZE("cfi-unrelated-cast") T* Get() const {
+  V8_INLINE V8_CLANG_NO_SANITIZE("cfi-unrelated-cast") T* Get() const {
     // Executed by the mutator, hence non atomic load.
     //
     // The const_cast below removes the constness from MemberBase storage. The
@@ -195,59 +267,262 @@ class BasicMember final : private MemberBase, private CheckingPolicy {
     return static_cast<T*>(const_cast<void*>(MemberBase::GetRaw()));
   }
 
-  void Clear() { SetRawAtomic(nullptr); }
+  V8_INLINE void Clear() { SetRawStorageAtomic(RawStorage{}); }
 
-  T* Release() {
+  V8_INLINE T* Release() {
     T* result = Get();
     Clear();
     return result;
   }
 
-  const T** GetSlotForTesting() const {
+  V8_INLINE const T** GetSlotForTesting() const {
     return reinterpret_cast<const T**>(GetRawSlot());
   }
 
+  V8_INLINE RawStorage GetRawStorage() const {
+    return MemberBase::GetRawStorage();
+  }
+
  private:
-  const T* GetRawAtomic() const {
+  V8_INLINE explicit BasicMember(RawStorage raw) : MemberBase(raw) {
+    InitializingWriteBarrier(Get());
+    this->CheckPointer(Get());
+  }
+
+  V8_INLINE BasicMember& operator=(RawStorage other) {
+    SetRawStorageAtomic(other);
+    AssigningWriteBarrier();
+    this->CheckPointer(Get());
+    return *this;
+  }
+
+  V8_INLINE const T* GetRawAtomic() const {
     return static_cast<const T*>(MemberBase::GetRawAtomic());
   }
 
-  void InitializingWriteBarrier() const {
-    WriteBarrierPolicy::InitializingBarrier(GetRawSlot(), GetRaw());
+  V8_INLINE void InitializingWriteBarrier(T* value) const {
+    WriteBarrierPolicy::InitializingBarrier(GetRawSlot(), value);
   }
-  void AssigningWriteBarrier() const {
-    WriteBarrierPolicy::AssigningBarrier(GetRawSlot(), GetRaw());
+  V8_INLINE void AssigningWriteBarrier(T* value) const {
+    WriteBarrierPolicy::AssigningBarrier(GetRawSlot(), value);
+  }
+  V8_INLINE void AssigningWriteBarrier() const {
+    WriteBarrierPolicy::AssigningBarrier(GetRawSlot(), GetRawStorage());
   }
 
-  void ClearFromGC() const { MemberBase::ClearFromGC(); }
+  V8_INLINE void ClearFromGC() const { MemberBase::ClearFromGC(); }
 
-  T* GetFromGC() const { return Get(); }
+  V8_INLINE T* GetFromGC() const { return Get(); }
 
+  friend class cppgc::subtle::HeapConsistency;
   friend class cppgc::Visitor;
   template <typename U>
   friend struct cppgc::TraceTrait;
+  template <typename T1, typename WeaknessTag1, typename WriteBarrierPolicy1,
+            typename CheckingPolicy1>
+  friend class BasicMember;
 };
 
+// Member equality operators.
 template <typename T1, typename WeaknessTag1, typename WriteBarrierPolicy1,
           typename CheckingPolicy1, typename T2, typename WeaknessTag2,
           typename WriteBarrierPolicy2, typename CheckingPolicy2>
-bool operator==(const BasicMember<T1, WeaknessTag1, WriteBarrierPolicy1,
-                                  CheckingPolicy1>& member1,
-                const BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2,
-                                  CheckingPolicy2>& member2) {
-  return member1.Get() == member2.Get();
+V8_INLINE bool operator==(
+    const BasicMember<T1, WeaknessTag1, WriteBarrierPolicy1, CheckingPolicy1>&
+        member1,
+    const BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2, CheckingPolicy2>&
+        member2) {
+  if constexpr (internal::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>);
+    // Otherwise, check decompressed pointers.
+    return member1.Get() == member2.Get();
+  }
 }
 
 template <typename T1, typename WeaknessTag1, typename WriteBarrierPolicy1,
           typename CheckingPolicy1, typename T2, typename WeaknessTag2,
           typename WriteBarrierPolicy2, typename CheckingPolicy2>
-bool operator!=(const BasicMember<T1, WeaknessTag1, WriteBarrierPolicy1,
-                                  CheckingPolicy1>& member1,
-                const BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2,
-                                  CheckingPolicy2>& member2) {
+V8_INLINE bool operator!=(
+    const BasicMember<T1, WeaknessTag1, WriteBarrierPolicy1, CheckingPolicy1>&
+        member1,
+    const BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2, CheckingPolicy2>&
+        member2) {
   return !(member1 == member2);
 }
 
+// Equality with raw pointers.
+template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
+          typename CheckingPolicy, typename U>
+V8_INLINE bool operator==(const BasicMember<T, WeaknessTag, WriteBarrierPolicy,
+                                            CheckingPolicy>& member,
+                          U* raw) {
+  // Never allow comparison with erased pointers.
+  static_assert(!internal::IsDecayedSameV<void, U>);
+
+  if constexpr (internal::IsDecayedSameV<T, U>) {
+    // Check compressed pointers if types are the same.
+    return member.GetRawStorage() == MemberBase::RawStorage(raw);
+  } else if constexpr (internal::IsStrictlyBaseOfV<T, U>) {
+    // Cast the raw pointer to T, which may adjust the pointer.
+    return member.GetRawStorage() ==
+           MemberBase::RawStorage(static_cast<T*>(raw));
+  } else {
+    // Otherwise, decompressed the member.
+    return member.Get() == raw;
+  }
+}
+
+template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
+          typename CheckingPolicy, typename U>
+V8_INLINE bool operator!=(const BasicMember<T, WeaknessTag, WriteBarrierPolicy,
+                                            CheckingPolicy>& member,
+                          U* raw) {
+  return !(member == raw);
+}
+
+template <typename T, typename U, typename WeaknessTag,
+          typename WriteBarrierPolicy, typename CheckingPolicy>
+V8_INLINE bool operator==(T* raw,
+                          const BasicMember<U, WeaknessTag, WriteBarrierPolicy,
+                                            CheckingPolicy>& member) {
+  return member == raw;
+}
+
+template <typename T, typename U, typename WeaknessTag,
+          typename WriteBarrierPolicy, typename CheckingPolicy>
+V8_INLINE bool operator!=(T* raw,
+                          const BasicMember<U, WeaknessTag, WriteBarrierPolicy,
+                                            CheckingPolicy>& member) {
+  return !(raw == member);
+}
+
+// Equality with sentinel.
+template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
+          typename CheckingPolicy>
+V8_INLINE bool operator==(const BasicMember<T, WeaknessTag, WriteBarrierPolicy,
+                                            CheckingPolicy>& member,
+                          SentinelPointer) {
+  return member.GetRawStorage().IsSentinel();
+}
+
+template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
+          typename CheckingPolicy>
+V8_INLINE bool operator!=(const BasicMember<T, WeaknessTag, WriteBarrierPolicy,
+                                            CheckingPolicy>& member,
+                          SentinelPointer s) {
+  return !(member == s);
+}
+
+template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
+          typename CheckingPolicy>
+V8_INLINE bool operator==(SentinelPointer s,
+                          const BasicMember<T, WeaknessTag, WriteBarrierPolicy,
+                                            CheckingPolicy>& member) {
+  return member == s;
+}
+
+template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
+          typename CheckingPolicy>
+V8_INLINE bool operator!=(SentinelPointer s,
+                          const BasicMember<T, WeaknessTag, WriteBarrierPolicy,
+                                            CheckingPolicy>& member) {
+  return !(s == member);
+}
+
+// Equality with nullptr.
+template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
+          typename CheckingPolicy>
+V8_INLINE bool operator==(const BasicMember<T, WeaknessTag, WriteBarrierPolicy,
+                                            CheckingPolicy>& member,
+                          std::nullptr_t) {
+  return !static_cast<bool>(member);
+}
+
+template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
+          typename CheckingPolicy>
+V8_INLINE bool operator!=(const BasicMember<T, WeaknessTag, WriteBarrierPolicy,
+                                            CheckingPolicy>& member,
+                          std::nullptr_t n) {
+  return !(member == n);
+}
+
+template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
+          typename CheckingPolicy>
+V8_INLINE bool operator==(std::nullptr_t n,
+                          const BasicMember<T, WeaknessTag, WriteBarrierPolicy,
+                                            CheckingPolicy>& member) {
+  return member == n;
+}
+
+template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
+          typename CheckingPolicy>
+V8_INLINE bool operator!=(std::nullptr_t n,
+                          const BasicMember<T, WeaknessTag, WriteBarrierPolicy,
+                                            CheckingPolicy>& member) {
+  return !(n == member);
+}
+
+// Relational operators.
+template <typename T1, typename WeaknessTag1, typename WriteBarrierPolicy1,
+          typename CheckingPolicy1, typename T2, typename WeaknessTag2,
+          typename WriteBarrierPolicy2, typename CheckingPolicy2>
+V8_INLINE bool operator<(
+    const BasicMember<T1, WeaknessTag1, WriteBarrierPolicy1, CheckingPolicy1>&
+        member1,
+    const BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2, CheckingPolicy2>&
+        member2) {
+  static_assert(
+      internal::IsDecayedSameV<T1, T2>,
+      "Comparison works only for same pointer type modulo cv-qualifiers");
+  return member1.GetRawStorage() < member2.GetRawStorage();
+}
+
+template <typename T1, typename WeaknessTag1, typename WriteBarrierPolicy1,
+          typename CheckingPolicy1, typename T2, typename WeaknessTag2,
+          typename WriteBarrierPolicy2, typename CheckingPolicy2>
+V8_INLINE bool operator<=(
+    const BasicMember<T1, WeaknessTag1, WriteBarrierPolicy1, CheckingPolicy1>&
+        member1,
+    const BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2, CheckingPolicy2>&
+        member2) {
+  static_assert(
+      internal::IsDecayedSameV<T1, T2>,
+      "Comparison works only for same pointer type modulo cv-qualifiers");
+  return member1.GetRawStorage() <= member2.GetRawStorage();
+}
+
+template <typename T1, typename WeaknessTag1, typename WriteBarrierPolicy1,
+          typename CheckingPolicy1, typename T2, typename WeaknessTag2,
+          typename WriteBarrierPolicy2, typename CheckingPolicy2>
+V8_INLINE bool operator>(
+    const BasicMember<T1, WeaknessTag1, WriteBarrierPolicy1, CheckingPolicy1>&
+        member1,
+    const BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2, CheckingPolicy2>&
+        member2) {
+  static_assert(
+      internal::IsDecayedSameV<T1, T2>,
+      "Comparison works only for same pointer type modulo cv-qualifiers");
+  return member1.GetRawStorage() > member2.GetRawStorage();
+}
+
+template <typename T1, typename WeaknessTag1, typename WriteBarrierPolicy1,
+          typename CheckingPolicy1, typename T2, typename WeaknessTag2,
+          typename WriteBarrierPolicy2, typename CheckingPolicy2>
+V8_INLINE bool operator>=(
+    const BasicMember<T1, WeaknessTag1, WriteBarrierPolicy1, CheckingPolicy1>&
+        member1,
+    const BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2, CheckingPolicy2>&
+        member2) {
+  static_assert(
+      internal::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>
 struct IsWeak<
     internal::BasicMember<T, WeakMemberTag, WriteBarrierPolicy, CheckingPolicy>>

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

@@ -37,15 +37,15 @@ class V8_EXPORT NameProvider {
   static constexpr const char kNoNameDeducible[] = "<No name>";
 
   /**
-   * Indicating whether internal names are hidden or not.
+   * Indicating whether the build supports extracting C++ names as object names.
    *
    * @returns true if C++ names should be hidden and represented by kHiddenName.
    */
-  static constexpr bool HideInternalNames() {
+  static constexpr bool SupportsCppClassNamesAsObjectNames() {
 #if CPPGC_SUPPORTS_OBJECT_NAMES
-    return false;
-#else   // !CPPGC_SUPPORTS_OBJECT_NAMES
     return true;
+#else   // !CPPGC_SUPPORTS_OBJECT_NAMES
+    return false;
 #endif  // !CPPGC_SUPPORTS_OBJECT_NAMES
   }
 

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

@@ -16,9 +16,6 @@
 #include "v8config.h"  // NOLINT(build/include_directory)
 
 namespace cppgc {
-
-class Visitor;
-
 namespace internal {
 
 // PersistentBase always refers to the object as const object and defers to
@@ -78,7 +75,7 @@ class BasicPersistent final : public PersistentBase,
       : PersistentBase(raw), LocationPolicy(loc) {
     if (!IsValid()) return;
     SetNode(WeaknessPolicy::GetPersistentRegion(GetValue())
-                .AllocateNode(this, &BasicPersistent::Trace));
+                .AllocateNode(this, &TraceAsRoot));
     this->CheckPointer(Get());
   }
 
@@ -221,9 +218,8 @@ class BasicPersistent final : public PersistentBase,
   }
 
  private:
-  static void Trace(Visitor* v, const void* ptr) {
-    const auto* persistent = static_cast<const BasicPersistent*>(ptr);
-    v->TraceRoot(*persistent, persistent->Location());
+  static void TraceAsRoot(RootVisitor& root_visitor, const void* ptr) {
+    root_visitor.Trace(*static_cast<const BasicPersistent*>(ptr));
   }
 
   bool IsValid() const {
@@ -247,7 +243,7 @@ class BasicPersistent final : public PersistentBase,
     SetValue(ptr);
     if (!IsValid()) return;
     SetNode(WeaknessPolicy::GetPersistentRegion(GetValue())
-                .AllocateNode(this, &BasicPersistent::Trace));
+                .AllocateNode(this, &TraceAsRoot));
     this->CheckPointer(Get());
   }
 
@@ -264,7 +260,7 @@ class BasicPersistent final : public PersistentBase,
     return static_cast<T*>(const_cast<void*>(GetValue()));
   }
 
-  friend class cppgc::Visitor;
+  friend class internal::RootVisitor;
 };
 
 template <typename T1, typename WeaknessPolicy1, typename LocationPolicy1,