libv8-node 15.14.0.1-aarch64-linux → 16.10.0.0-aarch64-linux

data/vendor/v8/include/cppgc/internal/pointer-policies.h

@@ -9,13 +9,17 @@
 #include <type_traits>
 
 #include "cppgc/internal/write-barrier.h"
+#include "cppgc/sentinel-pointer.h"
 #include "cppgc/source-location.h"
+#include "cppgc/type-traits.h"
 #include "v8config.h"  // NOLINT(build/include_directory)
 
 namespace cppgc {
 namespace internal {
 
+class HeapBase;
 class PersistentRegion;
+class CrossThreadPersistentRegion;
 
 // Tags to distinguish between strong and weak member types.
 class StrongMemberTag;
@@ -28,7 +32,17 @@ struct DijkstraWriteBarrierPolicy {
     // barrier doesn't break the tri-color invariant.
   }
   static void AssigningBarrier(const void* slot, const void* value) {
-    WriteBarrier::MarkingBarrier(slot, value);
+    WriteBarrier::Params params;
+    switch (WriteBarrier::GetWriteBarrierType(slot, value, params)) {
+      case WriteBarrier::Type::kGenerational:
+        WriteBarrier::GenerationalBarrier(params, slot);
+        break;
+      case WriteBarrier::Type::kMarking:
+        WriteBarrier::DijkstraMarkingBarrier(params, value);
+        break;
+      case WriteBarrier::Type::kNone:
+        break;
+    }
   }
 };
 
@@ -39,29 +53,56 @@ struct NoWriteBarrierPolicy {
 
 class V8_EXPORT EnabledCheckingPolicy {
  protected:
-  EnabledCheckingPolicy();
-  void CheckPointer(const void* ptr);
+  template <typename T>
+  void CheckPointer(const T* ptr) {
+    if (!ptr || (kSentinelPointer == ptr)) return;
+
+    CheckPointersImplTrampoline<T>::Call(this, ptr);
+  }
 
  private:
-  void* impl_;
+  void CheckPointerImpl(const void* ptr, bool points_to_payload);
+
+  template <typename T, bool = IsCompleteV<T>>
+  struct CheckPointersImplTrampoline {
+    static void Call(EnabledCheckingPolicy* policy, const T* ptr) {
+      policy->CheckPointerImpl(ptr, false);
+    }
+  };
+
+  template <typename T>
+  struct CheckPointersImplTrampoline<T, true> {
+    static void Call(EnabledCheckingPolicy* policy, const T* ptr) {
+      policy->CheckPointerImpl(ptr, IsGarbageCollectedTypeV<T>);
+    }
+  };
+
+  const HeapBase* heap_ = nullptr;
 };
 
 class DisabledCheckingPolicy {
  protected:
-  void CheckPointer(const void* raw) {}
+  void CheckPointer(const void*) {}
 };
 
 #if V8_ENABLE_CHECKS
-using DefaultCheckingPolicy = EnabledCheckingPolicy;
+using DefaultMemberCheckingPolicy = EnabledCheckingPolicy;
+using DefaultPersistentCheckingPolicy = EnabledCheckingPolicy;
 #else
-using DefaultCheckingPolicy = DisabledCheckingPolicy;
+using DefaultMemberCheckingPolicy = DisabledCheckingPolicy;
+using DefaultPersistentCheckingPolicy = DisabledCheckingPolicy;
 #endif
+// For CT(W)P neither marking information (for value), nor objectstart bitmap
+// (for slot) are guaranteed to be present because there's no synchonization
+// between heaps after marking.
+using DefaultCrossThreadPersistentCheckingPolicy = DisabledCheckingPolicy;
 
 class KeepLocationPolicy {
  public:
   constexpr const SourceLocation& Location() const { return location_; }
 
  protected:
+  constexpr KeepLocationPolicy() = default;
   constexpr explicit KeepLocationPolicy(const SourceLocation& location)
       : location_(location) {}
 
@@ -82,6 +123,7 @@ class IgnoreLocationPolicy {
   constexpr SourceLocation Location() const { return {}; }
 
  protected:
+  constexpr IgnoreLocationPolicy() = default;
   constexpr explicit IgnoreLocationPolicy(const SourceLocation&) {}
 };
 
@@ -93,42 +135,41 @@ using DefaultLocationPolicy = IgnoreLocationPolicy;
 
 struct StrongPersistentPolicy {
   using IsStrongPersistent = std::true_type;
-
-  static V8_EXPORT PersistentRegion& GetPersistentRegion(void* object);
+  static V8_EXPORT PersistentRegion& GetPersistentRegion(const void* object);
 };
 
 struct WeakPersistentPolicy {
   using IsStrongPersistent = std::false_type;
+  static V8_EXPORT PersistentRegion& GetPersistentRegion(const void* object);
+};
+
+struct StrongCrossThreadPersistentPolicy {
+  using IsStrongPersistent = std::true_type;
+  static V8_EXPORT CrossThreadPersistentRegion& GetPersistentRegion(
+      const void* object);
+};
 
-  static V8_EXPORT PersistentRegion& GetPersistentRegion(void* object);
+struct WeakCrossThreadPersistentPolicy {
+  using IsStrongPersistent = std::false_type;
+  static V8_EXPORT CrossThreadPersistentRegion& GetPersistentRegion(
+      const void* object);
 };
 
-// Persistent/Member forward declarations.
+// Forward declarations setting up the default policies.
+template <typename T, typename WeaknessPolicy,
+          typename LocationPolicy = DefaultLocationPolicy,
+          typename CheckingPolicy = DefaultCrossThreadPersistentCheckingPolicy>
+class BasicCrossThreadPersistent;
 template <typename T, typename WeaknessPolicy,
           typename LocationPolicy = DefaultLocationPolicy,
-          typename CheckingPolicy = DefaultCheckingPolicy>
+          typename CheckingPolicy = DefaultPersistentCheckingPolicy>
 class BasicPersistent;
 template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
-          typename CheckingPolicy = DefaultCheckingPolicy>
+          typename CheckingPolicy = DefaultMemberCheckingPolicy>
 class BasicMember;
 
-// Special tag type used to denote some sentinel member. The semantics of the
-// sentinel is defined by the embedder.
-struct SentinelPointer {
-  template <typename T>
-  operator T*() const {  // NOLINT
-    static constexpr intptr_t kSentinelValue = 1;
-    return reinterpret_cast<T*>(kSentinelValue);
-  }
-  // Hidden friends.
-  friend bool operator==(SentinelPointer, SentinelPointer) { return true; }
-  friend bool operator!=(SentinelPointer, SentinelPointer) { return false; }
-};
-
 }  // namespace internal
 
-constexpr internal::SentinelPointer kSentinelPointer;
-
 }  // namespace cppgc
 
 #endif  // INCLUDE_CPPGC_INTERNAL_POINTER_POLICIES_H_

data/vendor/v8/include/cppgc/internal/prefinalizer-handler.h

@@ -18,7 +18,7 @@ class V8_EXPORT PreFinalizerRegistrationDispatcher final {
     void* object;
     PreFinalizerCallback callback;
 
-    bool operator==(const PreFinalizer& other);
+    bool operator==(const PreFinalizer& other) const;
   };
 
   static void RegisterPrefinalizer(PreFinalizer pre_finalizer);

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 {