libv8-node 15.5.1.0.beta1-x86_64-linux → 16.10.0.0-x86_64-linux

data/vendor/v8/include/cppgc/internal/write-barrier.h

@@ -5,8 +5,14 @@
 #ifndef INCLUDE_CPPGC_INTERNAL_WRITE_BARRIER_H_
 #define INCLUDE_CPPGC_INTERNAL_WRITE_BARRIER_H_
 
+#include <cstddef>
+#include <cstdint>
+
+#include "cppgc/heap-state.h"
 #include "cppgc/internal/api-constants.h"
-#include "cppgc/internal/process-heap.h"
+#include "cppgc/internal/atomic-entry-flag.h"
+#include "cppgc/sentinel-pointer.h"
+#include "cppgc/trace-trait.h"
 #include "v8config.h"  // NOLINT(build/include_directory)
 
 #if defined(CPPGC_CAGED_HEAP)
@@ -14,64 +20,376 @@
 #endif
 
 namespace cppgc {
+
+class HeapHandle;
+
 namespace internal {
 
+#if defined(CPPGC_CAGED_HEAP)
+class WriteBarrierTypeForCagedHeapPolicy;
+#else   // !CPPGC_CAGED_HEAP
+class WriteBarrierTypeForNonCagedHeapPolicy;
+#endif  // !CPPGC_CAGED_HEAP
+
 class V8_EXPORT WriteBarrier final {
  public:
-  static V8_INLINE void MarkingBarrier(const void* slot, const void* value) {
+  enum class Type : uint8_t {
+    kNone,
+    kMarking,
+    kGenerational,
+  };
+
+  struct Params {
+    HeapHandle* heap = nullptr;
+#if V8_ENABLE_CHECKS
+    Type type = Type::kNone;
+#endif  // !V8_ENABLE_CHECKS
+#if defined(CPPGC_CAGED_HEAP)
+    uintptr_t start = 0;
+    CagedHeapLocalData& caged_heap() const {
+      return *reinterpret_cast<CagedHeapLocalData*>(start);
+    }
+    uintptr_t slot_offset = 0;
+    uintptr_t value_offset = 0;
+#endif  // CPPGC_CAGED_HEAP
+  };
+
+  enum class ValueMode {
+    kValuePresent,
+    kNoValuePresent,
+  };
+
+  // Returns the required write barrier for a given `slot` and `value`.
+  static V8_INLINE Type GetWriteBarrierType(const void* slot, const void* value,
+                                            Params& params);
+  // Returns the required write barrier for a given `slot`.
+  template <typename HeapHandleCallback>
+  static V8_INLINE Type GetWriteBarrierType(const void* slot, Params& params,
+                                            HeapHandleCallback callback);
+
+  template <typename HeapHandleCallback>
+  static V8_INLINE Type GetWriteBarrierTypeForExternallyReferencedObject(
+      const void* value, Params& params, HeapHandleCallback callback);
+
+  static V8_INLINE void DijkstraMarkingBarrier(const Params& params,
+                                               const void* object);
+  static V8_INLINE void DijkstraMarkingBarrierRange(
+      const Params& params, const void* first_element, size_t element_size,
+      size_t number_of_elements, TraceCallback trace_callback);
+  static V8_INLINE void SteeleMarkingBarrier(const Params& params,
+                                             const void* object);
+#if defined(CPPGC_YOUNG_GENERATION)
+  static V8_INLINE void GenerationalBarrier(const Params& params,
+                                            const void* slot);
+#else   // !CPPGC_YOUNG_GENERATION
+  static V8_INLINE void GenerationalBarrier(const Params& params,
+                                            const void* slot) {}
+#endif  // CPPGC_YOUNG_GENERATION
+
+#if V8_ENABLE_CHECKS
+  static void CheckParams(Type expected_type, const Params& params);
+#else   // !V8_ENABLE_CHECKS
+  static void CheckParams(Type expected_type, const Params& params) {}
+#endif  // !V8_ENABLE_CHECKS
+
+  // The IncrementalOrConcurrentUpdater class allows cppgc internal to update
+  // |incremental_or_concurrent_marking_flag_|.
+  class IncrementalOrConcurrentMarkingFlagUpdater;
+  static bool IsAnyIncrementalOrConcurrentMarking() {
+    return incremental_or_concurrent_marking_flag_.MightBeEntered();
+  }
+
+ private:
+  WriteBarrier() = delete;
+
 #if defined(CPPGC_CAGED_HEAP)
-    const uintptr_t start =
-        reinterpret_cast<uintptr_t>(value) &
-        ~(api_constants::kCagedHeapReservationAlignment - 1);
-    const uintptr_t slot_offset = reinterpret_cast<uintptr_t>(slot) - start;
+  using WriteBarrierTypePolicy = WriteBarrierTypeForCagedHeapPolicy;
+#else   // !CPPGC_CAGED_HEAP
+  using WriteBarrierTypePolicy = WriteBarrierTypeForNonCagedHeapPolicy;
+#endif  // !CPPGC_CAGED_HEAP
+
+  static void DijkstraMarkingBarrierSlow(const void* value);
+  static void DijkstraMarkingBarrierSlowWithSentinelCheck(const void* value);
+  static void DijkstraMarkingBarrierRangeSlow(HeapHandle& heap_handle,
+                                              const void* first_element,
+                                              size_t element_size,
+                                              size_t number_of_elements,
+                                              TraceCallback trace_callback);
+  static void SteeleMarkingBarrierSlow(const void* value);
+  static void SteeleMarkingBarrierSlowWithSentinelCheck(const void* value);
+
+#if defined(CPPGC_YOUNG_GENERATION)
+  static CagedHeapLocalData& GetLocalData(HeapHandle&);
+  static void GenerationalBarrierSlow(const CagedHeapLocalData& local_data,
+                                      const AgeTable& ageTable,
+                                      const void* slot, uintptr_t value_offset);
+#endif  // CPPGC_YOUNG_GENERATION
+
+  static AtomicEntryFlag incremental_or_concurrent_marking_flag_;
+};
+
+template <WriteBarrier::Type type>
+V8_INLINE WriteBarrier::Type SetAndReturnType(WriteBarrier::Params& params) {
+  if (type == WriteBarrier::Type::kNone) return WriteBarrier::Type::kNone;
+#if V8_ENABLE_CHECKS
+  params.type = type;
+#endif  // !V8_ENABLE_CHECKS
+  return type;
+}
+
+#if defined(CPPGC_CAGED_HEAP)
+class V8_EXPORT WriteBarrierTypeForCagedHeapPolicy final {
+ public:
+  template <WriteBarrier::ValueMode value_mode, typename HeapHandleCallback>
+  static V8_INLINE WriteBarrier::Type Get(const void* slot, const void* value,
+                                          WriteBarrier::Params& params,
+                                          HeapHandleCallback callback) {
+    return ValueModeDispatch<value_mode>::Get(slot, value, params, callback);
+  }
+
+  template <typename HeapHandleCallback>
+  static V8_INLINE WriteBarrier::Type GetForExternallyReferenced(
+      const void* value, WriteBarrier::Params& params, HeapHandleCallback) {
+    if (!TryGetCagedHeap(value, value, params)) {
+      return WriteBarrier::Type::kNone;
+    }
+    if (V8_UNLIKELY(params.caged_heap().is_incremental_marking_in_progress)) {
+      return SetAndReturnType<WriteBarrier::Type::kMarking>(params);
+    }
+    return SetAndReturnType<WriteBarrier::Type::kNone>(params);
+  }
+
+ private:
+  WriteBarrierTypeForCagedHeapPolicy() = delete;
+
+  template <WriteBarrier::ValueMode value_mode>
+  struct ValueModeDispatch;
+
+  static V8_INLINE bool TryGetCagedHeap(const void* slot, const void* value,
+                                        WriteBarrier::Params& params) {
+    params.start = reinterpret_cast<uintptr_t>(value) &
+                   ~(api_constants::kCagedHeapReservationAlignment - 1);
+    const uintptr_t slot_offset =
+        reinterpret_cast<uintptr_t>(slot) - params.start;
     if (slot_offset > api_constants::kCagedHeapReservationSize) {
       // Check if slot is on stack or value is sentinel or nullptr. This relies
       // on the fact that kSentinelPointer is encoded as 0x1.
-      return;
+      return false;
     }
+    return true;
+  }
 
-    CagedHeapLocalData* local_data =
-        reinterpret_cast<CagedHeapLocalData*>(start);
-    if (V8_UNLIKELY(local_data->is_marking_in_progress)) {
-      MarkingBarrierSlow(value);
-      return;
+  // Returns whether marking is in progress. If marking is not in progress
+  // sets the start of the cage accordingly.
+  //
+  // TODO(chromium:1056170): Create fast path on API.
+  static bool IsMarking(const HeapHandle&, WriteBarrier::Params&);
+};
+
+template <>
+struct WriteBarrierTypeForCagedHeapPolicy::ValueModeDispatch<
+    WriteBarrier::ValueMode::kValuePresent> {
+  template <typename HeapHandleCallback>
+  static V8_INLINE WriteBarrier::Type Get(const void* slot, const void* value,
+                                          WriteBarrier::Params& params,
+                                          HeapHandleCallback) {
+    bool within_cage = TryGetCagedHeap(slot, value, params);
+    if (!within_cage) {
+      return WriteBarrier::Type::kNone;
     }
+    if (V8_LIKELY(!params.caged_heap().is_incremental_marking_in_progress)) {
 #if defined(CPPGC_YOUNG_GENERATION)
-    GenerationalBarrier(local_data, slot, slot_offset,
-                        reinterpret_cast<uintptr_t>(value) - start);
-#endif
-#else
-    if (V8_LIKELY(!ProcessHeap::IsAnyIncrementalOrConcurrentMarking())) return;
+      params.heap = reinterpret_cast<HeapHandle*>(params.start);
+      params.slot_offset = reinterpret_cast<uintptr_t>(slot) - params.start;
+      params.value_offset = reinterpret_cast<uintptr_t>(value) - params.start;
+      return SetAndReturnType<WriteBarrier::Type::kGenerational>(params);
+#else   // !CPPGC_YOUNG_GENERATION
+      return SetAndReturnType<WriteBarrier::Type::kNone>(params);
+#endif  // !CPPGC_YOUNG_GENERATION
+    }
+    params.heap = reinterpret_cast<HeapHandle*>(params.start);
+    return SetAndReturnType<WriteBarrier::Type::kMarking>(params);
+  }
+};
+
+template <>
+struct WriteBarrierTypeForCagedHeapPolicy::ValueModeDispatch<
+    WriteBarrier::ValueMode::kNoValuePresent> {
+  template <typename HeapHandleCallback>
+  static V8_INLINE WriteBarrier::Type Get(const void* slot, const void*,
+                                          WriteBarrier::Params& params,
+                                          HeapHandleCallback callback) {
+#if defined(CPPGC_YOUNG_GENERATION)
+    HeapHandle& handle = callback();
+    if (V8_LIKELY(!IsMarking(handle, params))) {
+      // params.start is populated by IsMarking().
+      params.heap = &handle;
+      params.slot_offset = reinterpret_cast<uintptr_t>(slot) - params.start;
+      // params.value_offset stays 0.
+      if (params.slot_offset > api_constants::kCagedHeapReservationSize) {
+        // Check if slot is on stack.
+        return SetAndReturnType<WriteBarrier::Type::kNone>(params);
+      }
+      return SetAndReturnType<WriteBarrier::Type::kGenerational>(params);
+    }
+#else   // !CPPGC_YOUNG_GENERATION
+    if (V8_LIKELY(!WriteBarrier::IsAnyIncrementalOrConcurrentMarking())) {
+      return SetAndReturnType<WriteBarrier::Type::kNone>(params);
+    }
+    HeapHandle& handle = callback();
+    if (V8_UNLIKELY(!subtle::HeapState::IsMarking(handle))) {
+      return SetAndReturnType<WriteBarrier::Type::kNone>(params);
+    }
+#endif  // !CPPGC_YOUNG_GENERATION
+    params.heap = &handle;
+    return SetAndReturnType<WriteBarrier::Type::kMarking>(params);
+  }
+};
 
-    MarkingBarrierSlowWithSentinelCheck(value);
 #endif  // CPPGC_CAGED_HEAP
+
+class V8_EXPORT WriteBarrierTypeForNonCagedHeapPolicy final {
+ public:
+  template <WriteBarrier::ValueMode value_mode, typename HeapHandleCallback>
+  static V8_INLINE WriteBarrier::Type Get(const void* slot, const void* value,
+                                          WriteBarrier::Params& params,
+                                          HeapHandleCallback callback) {
+    return ValueModeDispatch<value_mode>::Get(slot, value, params, callback);
   }
 
- private:
-  WriteBarrier() = delete;
+  template <typename HeapHandleCallback>
+  static V8_INLINE WriteBarrier::Type GetForExternallyReferenced(
+      const void* value, WriteBarrier::Params& params,
+      HeapHandleCallback callback) {
+    // The slot will never be used in `Get()` below.
+    return Get<WriteBarrier::ValueMode::kValuePresent>(nullptr, value, params,
+                                                       callback);
+  }
 
-  static void MarkingBarrierSlow(const void* value);
-  static void MarkingBarrierSlowWithSentinelCheck(const void* value);
+ private:
+  template <WriteBarrier::ValueMode value_mode>
+  struct ValueModeDispatch;
 
-#if defined(CPPGC_YOUNG_GENERATION)
-  static V8_INLINE void GenerationalBarrier(CagedHeapLocalData* local_data,
-                                            const void* slot,
-                                            uintptr_t slot_offset,
-                                            uintptr_t value_offset) {
-    const AgeTable& age_table = local_data->age_table;
+  // TODO(chromium:1056170): Create fast path on API.
+  static bool IsMarking(const void*, HeapHandle**);
+  // TODO(chromium:1056170): Create fast path on API.
+  static bool IsMarking(HeapHandle&);
 
-    // Bail out if the slot is in young generation.
-    if (V8_LIKELY(age_table[slot_offset] == AgeTable::Age::kYoung)) return;
+  WriteBarrierTypeForNonCagedHeapPolicy() = delete;
+};
 
-    GenerationalBarrierSlow(local_data, age_table, slot, value_offset);
+template <>
+struct WriteBarrierTypeForNonCagedHeapPolicy::ValueModeDispatch<
+    WriteBarrier::ValueMode::kValuePresent> {
+  template <typename HeapHandleCallback>
+  static V8_INLINE WriteBarrier::Type Get(const void*, const void* object,
+                                          WriteBarrier::Params& params,
+                                          HeapHandleCallback callback) {
+    // The following check covers nullptr as well as sentinel pointer.
+    if (object <= static_cast<void*>(kSentinelPointer)) {
+      return WriteBarrier::Type::kNone;
+    }
+    if (IsMarking(object, &params.heap)) {
+      return SetAndReturnType<WriteBarrier::Type::kMarking>(params);
+    }
+    return SetAndReturnType<WriteBarrier::Type::kNone>(params);
   }
+};
 
-  static void GenerationalBarrierSlow(CagedHeapLocalData* local_data,
-                                      const AgeTable& ageTable,
-                                      const void* slot, uintptr_t value_offset);
-#endif
+template <>
+struct WriteBarrierTypeForNonCagedHeapPolicy::ValueModeDispatch<
+    WriteBarrier::ValueMode::kNoValuePresent> {
+  template <typename HeapHandleCallback>
+  static V8_INLINE WriteBarrier::Type Get(const void*, const void*,
+                                          WriteBarrier::Params& params,
+                                          HeapHandleCallback callback) {
+    if (V8_UNLIKELY(WriteBarrier::IsAnyIncrementalOrConcurrentMarking())) {
+      HeapHandle& handle = callback();
+      if (IsMarking(handle)) {
+        params.heap = &handle;
+        return SetAndReturnType<WriteBarrier::Type::kMarking>(params);
+      }
+    }
+    return WriteBarrier::Type::kNone;
+  }
 };
 
+// static
+WriteBarrier::Type WriteBarrier::GetWriteBarrierType(
+    const void* slot, const void* value, WriteBarrier::Params& params) {
+  return WriteBarrierTypePolicy::Get<ValueMode::kValuePresent>(slot, value,
+                                                               params, []() {});
+}
+
+// static
+template <typename HeapHandleCallback>
+WriteBarrier::Type WriteBarrier::GetWriteBarrierType(
+    const void* slot, WriteBarrier::Params& params,
+    HeapHandleCallback callback) {
+  return WriteBarrierTypePolicy::Get<ValueMode::kNoValuePresent>(
+      slot, nullptr, params, callback);
+}
+
+// static
+template <typename HeapHandleCallback>
+WriteBarrier::Type
+WriteBarrier::GetWriteBarrierTypeForExternallyReferencedObject(
+    const void* value, Params& params, HeapHandleCallback callback) {
+  return WriteBarrierTypePolicy::GetForExternallyReferenced(value, params,
+                                                            callback);
+}
+
+// static
+void WriteBarrier::DijkstraMarkingBarrier(const Params& params,
+                                          const void* object) {
+  CheckParams(Type::kMarking, params);
+#if defined(CPPGC_CAGED_HEAP)
+  // Caged heap already filters out sentinels.
+  DijkstraMarkingBarrierSlow(object);
+#else   // !CPPGC_CAGED_HEAP
+  DijkstraMarkingBarrierSlowWithSentinelCheck(object);
+#endif  // !CPPGC_CAGED_HEAP
+}
+
+// static
+void WriteBarrier::DijkstraMarkingBarrierRange(const Params& params,
+                                               const void* first_element,
+                                               size_t element_size,
+                                               size_t number_of_elements,
+                                               TraceCallback trace_callback) {
+  CheckParams(Type::kMarking, params);
+  DijkstraMarkingBarrierRangeSlow(*params.heap, first_element, element_size,
+                                  number_of_elements, trace_callback);
+}
+
+// static
+void WriteBarrier::SteeleMarkingBarrier(const Params& params,
+                                        const void* object) {
+  CheckParams(Type::kMarking, params);
+#if defined(CPPGC_CAGED_HEAP)
+  // Caged heap already filters out sentinels.
+  SteeleMarkingBarrierSlow(object);
+#else   // !CPPGC_CAGED_HEAP
+  SteeleMarkingBarrierSlowWithSentinelCheck(object);
+#endif  // !CPPGC_CAGED_HEAP
+}
+
+#if defined(CPPGC_YOUNG_GENERATION)
+// static
+void WriteBarrier::GenerationalBarrier(const Params& params, const void* slot) {
+  CheckParams(Type::kGenerational, params);
+
+  const CagedHeapLocalData& local_data = params.caged_heap();
+  const AgeTable& age_table = local_data.age_table;
+
+  // Bail out if the slot is in young generation.
+  if (V8_LIKELY(age_table[params.slot_offset] == AgeTable::Age::kYoung)) return;
+
+  GenerationalBarrierSlow(local_data, age_table, slot, params.value_offset);
+}
+
+#endif  // !CPPGC_YOUNG_GENERATION
+
 }  // namespace internal
 }  // namespace cppgc
 

data/vendor/v8/include/cppgc/liveness-broker.h

@@ -19,7 +19,7 @@ class LivenessBrokerFactory;
 /**
  * The broker is passed to weak callbacks to allow (temporarily) querying
  * the liveness state of an object. References to non-live objects must be
- * cleared when IsHeapObjectAlive() returns false.
+ * cleared when `IsHeapObjectAlive()` returns false.
  *
  * \code
  * class GCedWithCustomWeakCallback final
@@ -49,6 +49,12 @@ class V8_EXPORT LivenessBroker final {
                TraceTrait<T>::GetTraceDescriptor(object).base_object_payload);
   }
 
+  template <typename T>
+  bool IsHeapObjectAlive(const WeakMember<T>& weak_member) const {
+    return (weak_member != kSentinelPointer) &&
+           IsHeapObjectAlive<T>(weak_member.Get());
+  }
+
   template <typename T>
   bool IsHeapObjectAlive(const UntracedMember<T>& untraced_member) const {
     return (untraced_member != kSentinelPointer) &&

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

@@ -5,6 +5,8 @@
 #ifndef INCLUDE_CPPGC_MACROS_H_
 #define INCLUDE_CPPGC_MACROS_H_
 
+#include <cstddef>
+
 #include "cppgc/internal/compiler-specific.h"
 
 namespace cppgc {

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

@@ -10,6 +10,7 @@
 #include <type_traits>
 
 #include "cppgc/internal/pointer-policies.h"
+#include "cppgc/sentinel-pointer.h"
 #include "cppgc/type-traits.h"
 #include "v8config.h"  // NOLINT(build/include_directory)
 
@@ -19,28 +20,33 @@ 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 {
  protected:
+  struct AtomicInitializerTag {};
+
   MemberBase() = default;
-  explicit MemberBase(void* value) : raw_(value) {}
+  explicit MemberBase(const void* value) : raw_(value) {}
+  MemberBase(const void* value, AtomicInitializerTag) { SetRawAtomic(value); }
 
-  void* const* GetRawSlot() const { return &raw_; }
-  void* GetRaw() const { return raw_; }
+  const void** GetRawSlot() const { return &raw_; }
+  const void* GetRaw() const { return raw_; }
   void SetRaw(void* value) { raw_ = value; }
 
-  void* GetRawAtomic() const {
-    return reinterpret_cast<const std::atomic<void*>*>(&raw_)->load(
+  const void* GetRawAtomic() const {
+    return reinterpret_cast<const std::atomic<const void*>*>(&raw_)->load(
         std::memory_order_relaxed);
   }
-  void SetRawAtomic(void* value) {
-    reinterpret_cast<std::atomic<void*>*>(&raw_)->store(
+  void SetRawAtomic(const void* value) {
+    reinterpret_cast<std::atomic<const void*>*>(&raw_)->store(
         value, std::memory_order_relaxed);
   }
 
   void ClearFromGC() const { raw_ = nullptr; }
 
  private:
-  mutable void* raw_ = nullptr;
+  mutable const void* raw_ = nullptr;
 };
 
 // The basic class from which all Member classes are 'generated'.
@@ -58,6 +64,21 @@ class BasicMember final : private MemberBase, private CheckingPolicy {
     this->CheckPointer(Get());
   }
   BasicMember(T& raw) : BasicMember(&raw) {}  // NOLINT
+  // 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)
+      : MemberBase(nullptr, atomic) {}
+  BasicMember(SentinelPointer s, AtomicInitializerTag atomic)
+      : MemberBase(s, atomic) {}
+  BasicMember(T* raw, AtomicInitializerTag atomic) : MemberBase(raw, atomic) {
+    InitializingWriteBarrier();
+    this->CheckPointer(Get());
+  }
+  BasicMember(T& raw, AtomicInitializerTag atomic)
+      : BasicMember(&raw, atomic) {}
+  // Copy ctor.
   BasicMember(const BasicMember& other) : BasicMember(other.Get()) {}
   // Allow heterogeneous construction.
   template <typename U, typename OtherBarrierPolicy, typename OtherWeaknessTag,
@@ -67,21 +88,34 @@ class BasicMember final : private MemberBase, private CheckingPolicy {
       const BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
                         OtherCheckingPolicy>& other)
       : BasicMember(other.Get()) {}
+  // Move ctor.
+  BasicMember(BasicMember&& other) noexcept : BasicMember(other.Get()) {
+    other.Clear();
+  }
+  // Allow heterogeneous move construction.
+  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
+      : 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(  // NOLINT
-      const BasicPersistent<U, PersistentWeaknessPolicy,
-                            PersistentLocationPolicy, PersistentCheckingPolicy>&
-          p)
+  BasicMember(const BasicPersistent<U, PersistentWeaknessPolicy,
+                                    PersistentLocationPolicy,
+                                    PersistentCheckingPolicy>& p)
       : BasicMember(p.Get()) {}
 
+  // Copy assignment.
   BasicMember& operator=(const BasicMember& other) {
     return operator=(other.Get());
   }
-  // Allow heterogeneous assignment.
+  // Allow heterogeneous copy assignment.
   template <typename U, typename OtherWeaknessTag, typename OtherBarrierPolicy,
             typename OtherCheckingPolicy,
             typename = std::enable_if_t<std::is_base_of<T, U>::value>>
@@ -90,6 +124,22 @@ class BasicMember final : private MemberBase, private CheckingPolicy {
                         OtherCheckingPolicy>& other) {
     return operator=(other.Get());
   }
+  // Move assignment.
+  BasicMember& operator=(BasicMember&& other) noexcept {
+    operator=(other.Get());
+    other.Clear();
+    return *this;
+  }
+  // Heterogeneous move assignment.
+  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());
+    other.Clear();
+    return *this;
+  }
   // Assignment from Persistent.
   template <typename U, typename PersistentWeaknessPolicy,
             typename PersistentLocationPolicy,
@@ -126,7 +176,7 @@ class BasicMember final : private MemberBase, private CheckingPolicy {
   }
 
   explicit operator bool() const { return Get(); }
-  operator T*() const { return Get(); }  // NOLINT
+  operator T*() const { return Get(); }
   T* operator->() const { return Get(); }
   T& operator*() const { return *Get(); }
 
@@ -135,7 +185,11 @@ class BasicMember final : private MemberBase, private CheckingPolicy {
   // based on their actual types.
   V8_CLANG_NO_SANITIZE("cfi-unrelated-cast") T* Get() const {
     // Executed by the mutator, hence non atomic load.
-    return static_cast<T*>(MemberBase::GetRaw());
+    //
+    // The const_cast below removes the constness from MemberBase storage. The
+    // following static_cast re-adds any constness if specified through the
+    // user-visible template parameter T.
+    return static_cast<T*>(const_cast<void*>(MemberBase::GetRaw()));
   }
 
   void Clear() { SetRawAtomic(nullptr); }
@@ -146,9 +200,13 @@ class BasicMember final : private MemberBase, private CheckingPolicy {
     return result;
   }
 
+  const T** GetSlotForTesting() const {
+    return reinterpret_cast<const T**>(GetRawSlot());
+  }
+
  private:
-  T* GetRawAtomic() const {
-    return static_cast<T*>(MemberBase::GetRawAtomic());
+  const T* GetRawAtomic() const {
+    return static_cast<const T*>(MemberBase::GetRawAtomic());
   }
 
   void InitializingWriteBarrier() const {
@@ -161,25 +219,27 @@ class BasicMember final : private MemberBase, private CheckingPolicy {
   void ClearFromGC() const { MemberBase::ClearFromGC(); }
 
   friend class cppgc::Visitor;
+  template <typename U>
+  friend struct cppgc::TraceTrait;
 };
 
 template <typename T1, typename WeaknessTag1, typename WriteBarrierPolicy1,
           typename CheckingPolicy1, typename T2, typename WeaknessTag2,
           typename WriteBarrierPolicy2, typename CheckingPolicy2>
-bool operator==(
-    BasicMember<T1, WeaknessTag1, WriteBarrierPolicy1, CheckingPolicy1> member1,
-    BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2, CheckingPolicy2>
-        member2) {
+bool operator==(const BasicMember<T1, WeaknessTag1, WriteBarrierPolicy1,
+                                  CheckingPolicy1>& member1,
+                const BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2,
+                                  CheckingPolicy2>& member2) {
   return member1.Get() == member2.Get();
 }
 
 template <typename T1, typename WeaknessTag1, typename WriteBarrierPolicy1,
           typename CheckingPolicy1, typename T2, typename WeaknessTag2,
           typename WriteBarrierPolicy2, typename CheckingPolicy2>
-bool operator!=(
-    BasicMember<T1, WeaknessTag1, WriteBarrierPolicy1, CheckingPolicy1> member1,
-    BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2, CheckingPolicy2>
-        member2) {
+bool operator!=(const BasicMember<T1, WeaknessTag1, WriteBarrierPolicy1,
+                                  CheckingPolicy1>& member1,
+                const BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2,
+                                  CheckingPolicy2>& member2) {
   return !(member1 == member2);
 }