libv8-node 17.9.1.1-aarch64-linux-musl → 18.8.0.0-aarch64-linux-musl

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9b737a7c5e5a3547441ff6565dcfa308f28254c0465011f83361a8710f11add7
-  data.tar.gz: d09ea21146aae288130d847b74b3835e31718bcaf24c1a0ce1f99396ca204fad
+  metadata.gz: 4851a6d65632c1e8a4001087e3d8ef2c3b6229539a736560068bcc81d6b7c63a
+  data.tar.gz: 45508ecdb1d31f7decfa7b4fc890f8362deeda5585b43bf9a9128fc7984c6627
 SHA512:
-  metadata.gz: e227d3a41bb61d40175758a130aaff94b138b5646d77c8a91c4608eba1b7f98d261c25d9c1d33a3faa3ccfc9cd056fc4c22dc11470ca452c64ffef9dfb07cf93
-  data.tar.gz: f7a2d301788c52aa21b2a98c59edf168a583fd7a8277224039db47bd2bd48e309165254560e6ff0c0a726467ccde410ad8af5f49f085500202e51b6c29438e15
+  metadata.gz: a3f2b60b06e15dceaf8e72dcf4ecad18cecdd5cade42260341b1acb2b3e1f3cf88816e61eab0884946d54743f35f72b844bee637e316a38581784cccd6724790
+  data.tar.gz: 8592968b05d662495645552c428b05e4363902783a791cfc3ce011274ce40fd2d051e2a667d230c1ae09d508e79e079f2a75b31faa382112a53dee0c89aef76c

data/ext/libv8-node/location.rb

@@ -45,7 +45,7 @@ module Libv8::Node
       def verify_installation!
         include_paths = Libv8::Node::Paths.include_paths
 
-        unless include_paths.detect { |p| Pathname(p).join('v8.h').exist? } # rubocop:disable Style/IfUnlessModifier
+        unless include_paths.detect { |p| Pathname(p).join('v8.h').exist? }
           raise(HeaderNotFound, "Unable to locate 'v8.h' in the libv8 header paths: #{include_paths.inspect}")
         end
 

data/lib/libv8/node/version.rb

@@ -1,7 +1,7 @@
 module Libv8; end
 
 module Libv8::Node
-  VERSION = '17.9.1.1'.freeze
-  NODE_VERSION = '17.9.1'.freeze
-  LIBV8_VERSION = '9.6.180.15'.freeze # from v8/include/v8-version.h
+  VERSION = '18.8.0.0'.freeze
+  NODE_VERSION = '18.8.0'.freeze
+  LIBV8_VERSION = '10.2.154.13'.freeze # from v8/include/v8-version.h
 end

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

@@ -18,6 +18,23 @@
 #include "cppgc/type-traits.h"
 #include "v8config.h"  // NOLINT(build/include_directory)
 
+#if defined(__has_attribute)
+#if __has_attribute(assume_aligned)
+#define CPPGC_DEFAULT_ALIGNED \
+  __attribute__((assume_aligned(api_constants::kDefaultAlignment)))
+#define CPPGC_DOUBLE_WORD_ALIGNED \
+  __attribute__((assume_aligned(2 * api_constants::kDefaultAlignment)))
+#endif  // __has_attribute(assume_aligned)
+#endif  // defined(__has_attribute)
+
+#if !defined(CPPGC_DEFAULT_ALIGNED)
+#define CPPGC_DEFAULT_ALIGNED
+#endif
+
+#if !defined(CPPGC_DOUBLE_WORD_ALIGNED)
+#define CPPGC_DOUBLE_WORD_ALIGNED
+#endif
+
 namespace cppgc {
 
 /**
@@ -27,6 +44,9 @@ class AllocationHandle;
 
 namespace internal {
 
+// Similar to C++17 std::align_val_t;
+enum class AlignVal : size_t {};
+
 class V8_EXPORT MakeGarbageCollectedTraitInternal {
  protected:
   static inline void MarkObjectAsFullyConstructed(const void* payload) {
@@ -45,32 +65,72 @@ class V8_EXPORT MakeGarbageCollectedTraitInternal {
     atomic_mutable_bitfield->store(value, std::memory_order_release);
   }
 
-  template <typename U, typename CustomSpace>
-  struct SpacePolicy {
-    static void* Allocate(AllocationHandle& handle, size_t size) {
-      // Custom space.
+  // Dispatch based on compile-time information.
+  //
+  // Default implementation is for a custom space with >`kDefaultAlignment` byte
+  // alignment.
+  template <typename GCInfoType, typename CustomSpace, size_t alignment>
+  struct AllocationDispatcher final {
+    static void* Invoke(AllocationHandle& handle, size_t size) {
       static_assert(std::is_base_of<CustomSpaceBase, CustomSpace>::value,
                     "Custom space must inherit from CustomSpaceBase.");
+      static_assert(
+          !CustomSpace::kSupportsCompaction,
+          "Custom spaces that support compaction do not support allocating "
+          "objects with non-default (i.e. word-sized) alignment.");
       return MakeGarbageCollectedTraitInternal::Allocate(
-          handle, size, internal::GCInfoTrait<U>::Index(),
-          CustomSpace::kSpaceIndex);
+          handle, size, static_cast<AlignVal>(alignment),
+          internal::GCInfoTrait<GCInfoType>::Index(), CustomSpace::kSpaceIndex);
+    }
+  };
+
+  // Fast path for regular allocations for the default space with
+  // `kDefaultAlignment` byte alignment.
+  template <typename GCInfoType>
+  struct AllocationDispatcher<GCInfoType, void,
+                              api_constants::kDefaultAlignment>
+      final {
+    static void* Invoke(AllocationHandle& handle, size_t size) {
+      return MakeGarbageCollectedTraitInternal::Allocate(
+          handle, size, internal::GCInfoTrait<GCInfoType>::Index());
     }
   };
 
-  template <typename U>
-  struct SpacePolicy<U, void> {
-    static void* Allocate(AllocationHandle& handle, size_t size) {
-      // Default space.
+  // Default space with >`kDefaultAlignment` byte alignment.
+  template <typename GCInfoType, size_t alignment>
+  struct AllocationDispatcher<GCInfoType, void, alignment> final {
+    static void* Invoke(AllocationHandle& handle, size_t size) {
       return MakeGarbageCollectedTraitInternal::Allocate(
-          handle, size, internal::GCInfoTrait<U>::Index());
+          handle, size, static_cast<AlignVal>(alignment),
+          internal::GCInfoTrait<GCInfoType>::Index());
+    }
+  };
+
+  // Custom space with `kDefaultAlignment` byte alignment.
+  template <typename GCInfoType, typename CustomSpace>
+  struct AllocationDispatcher<GCInfoType, CustomSpace,
+                              api_constants::kDefaultAlignment>
+      final {
+    static void* Invoke(AllocationHandle& handle, size_t size) {
+      static_assert(std::is_base_of<CustomSpaceBase, CustomSpace>::value,
+                    "Custom space must inherit from CustomSpaceBase.");
+      return MakeGarbageCollectedTraitInternal::Allocate(
+          handle, size, internal::GCInfoTrait<GCInfoType>::Index(),
+          CustomSpace::kSpaceIndex);
     }
   };
 
  private:
-  static void* Allocate(cppgc::AllocationHandle& handle, size_t size,
-                        GCInfoIndex index);
-  static void* Allocate(cppgc::AllocationHandle& handle, size_t size,
-                        GCInfoIndex index, CustomSpaceIndex space_index);
+  static void* CPPGC_DEFAULT_ALIGNED Allocate(cppgc::AllocationHandle&, size_t,
+                                              GCInfoIndex);
+  static void* CPPGC_DOUBLE_WORD_ALIGNED Allocate(cppgc::AllocationHandle&,
+                                                  size_t, AlignVal,
+                                                  GCInfoIndex);
+  static void* CPPGC_DEFAULT_ALIGNED Allocate(cppgc::AllocationHandle&, size_t,
+                                              GCInfoIndex, CustomSpaceIndex);
+  static void* CPPGC_DOUBLE_WORD_ALIGNED Allocate(cppgc::AllocationHandle&,
+                                                  size_t, AlignVal, GCInfoIndex,
+                                                  CustomSpaceIndex);
 
   friend class HeapObjectHeader;
 };
@@ -109,10 +169,18 @@ class MakeGarbageCollectedTraitBase
         std::is_base_of<typename T::ParentMostGarbageCollectedType, T>::value,
         "U of GarbageCollected<U> must be a base of T. Check "
         "GarbageCollected<T> base class inheritance.");
-    return SpacePolicy<
+    static constexpr size_t kWantedAlignment =
+        alignof(T) < internal::api_constants::kDefaultAlignment
+            ? internal::api_constants::kDefaultAlignment
+            : alignof(T);
+    static_assert(
+        kWantedAlignment <= internal::api_constants::kMaxSupportedAlignment,
+        "Requested alignment larger than alignof(std::max_align_t) bytes. "
+        "Please file a bug to possibly get this restriction lifted.");
+    return AllocationDispatcher<
         typename internal::GCInfoFolding<
             T, typename T::ParentMostGarbageCollectedType>::ResultType,
-        typename SpaceTrait<T>::Space>::Allocate(handle, size);
+        typename SpaceTrait<T>::Space, kWantedAlignment>::Invoke(handle, size);
   }
 
   /**
@@ -236,4 +304,7 @@ V8_INLINE T* MakeGarbageCollected(AllocationHandle& handle,
 
 }  // namespace cppgc
 
+#undef CPPGC_DEFAULT_ALIGNED
+#undef CPPGC_DOUBLE_WORD_ALIGNED
+
 #endif  // INCLUDE_CPPGC_ALLOCATION_H_

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

@@ -6,7 +6,6 @@
 #define INCLUDE_CPPGC_DEFAULT_PLATFORM_H_
 
 #include <memory>
-#include <vector>
 
 #include "cppgc/platform.h"
 #include "libplatform/libplatform.h"
@@ -20,15 +19,6 @@ namespace cppgc {
  */
 class V8_EXPORT DefaultPlatform : public Platform {
  public:
-  /**
-   * Use this method instead of 'cppgc::InitializeProcess' when using
-   * 'cppgc::DefaultPlatform'. 'cppgc::DefaultPlatform::InitializeProcess'
-   * will initialize cppgc and v8 if needed (for non-standalone builds).
-   *
-   * \param platform DefaultPlatform instance used to initialize cppgc/v8.
-   */
-  static void InitializeProcess(DefaultPlatform* platform);
-
   using IdleTaskSupport = v8::platform::IdleTaskSupport;
   explicit DefaultPlatform(
       int thread_pool_size = 0,
@@ -64,6 +54,8 @@ class V8_EXPORT DefaultPlatform : public Platform {
     return v8_platform_->GetTracingController();
   }
 
+  v8::Platform* GetV8Platform() const { return v8_platform_.get(); }
+
  protected:
   static constexpr v8::Isolate* kNoIsolate = nullptr;
 

data/vendor/v8/include/cppgc/explicit-management.h

@@ -15,11 +15,27 @@ namespace cppgc {
 
 class HeapHandle;
 
+namespace subtle {
+
+template <typename T>
+void FreeUnreferencedObject(HeapHandle& heap_handle, T& object);
+template <typename T>
+bool Resize(T& object, AdditionalBytes additional_bytes);
+
+}  // namespace subtle
+
 namespace internal {
 
-V8_EXPORT void FreeUnreferencedObject(HeapHandle&, void*);
-V8_EXPORT bool Resize(void*, size_t);
+class ExplicitManagementImpl final {
+ private:
+  V8_EXPORT static void FreeUnreferencedObject(HeapHandle&, void*);
+  V8_EXPORT static bool Resize(void*, size_t);
 
+  template <typename T>
+  friend void subtle::FreeUnreferencedObject(HeapHandle&, T&);
+  template <typename T>
+  friend bool subtle::Resize(T&, AdditionalBytes);
+};
 }  // namespace internal
 
 namespace subtle {
@@ -45,7 +61,8 @@ template <typename T>
 void FreeUnreferencedObject(HeapHandle& heap_handle, T& object) {
   static_assert(IsGarbageCollectedTypeV<T>,
                 "Object must be of type GarbageCollected.");
-  internal::FreeUnreferencedObject(heap_handle, &object);
+  internal::ExplicitManagementImpl::FreeUnreferencedObject(heap_handle,
+                                                           &object);
 }
 
 /**
@@ -73,7 +90,8 @@ template <typename T>
 bool Resize(T& object, AdditionalBytes additional_bytes) {
   static_assert(IsGarbageCollectedTypeV<T>,
                 "Object must be of type GarbageCollected.");
-  return internal::Resize(&object, sizeof(T) + additional_bytes.value);
+  return internal::ExplicitManagementImpl::Resize(
+      &object, sizeof(T) + additional_bytes.value);
 }
 
 }  // namespace subtle

data/vendor/v8/include/cppgc/garbage-collected.h

@@ -5,8 +5,6 @@
 #ifndef INCLUDE_CPPGC_GARBAGE_COLLECTED_H_
 #define INCLUDE_CPPGC_GARBAGE_COLLECTED_H_
 
-#include <type_traits>
-
 #include "cppgc/internal/api-constants.h"
 #include "cppgc/platform.h"
 #include "cppgc/trace-trait.h"
@@ -16,28 +14,6 @@ namespace cppgc {
 
 class Visitor;
 
-namespace internal {
-
-class GarbageCollectedBase {
- public:
-  // Must use MakeGarbageCollected.
-  void* operator new(size_t) = delete;
-  void* operator new[](size_t) = delete;
-  // The garbage collector is taking care of reclaiming the object. Also,
-  // virtual destructor requires an unambiguous, accessible 'operator delete'.
-  void operator delete(void*) {
-#ifdef V8_ENABLE_CHECKS
-    internal::Abort();
-#endif  // V8_ENABLE_CHECKS
-  }
-  void operator delete[](void*) = delete;
-
- protected:
-  GarbageCollectedBase() = default;
-};
-
-}  // namespace internal
-
 /**
  * Base class for managed objects. Only descendent types of `GarbageCollected`
  * can be constructed using `MakeGarbageCollected()`. Must be inherited from as
@@ -74,11 +50,24 @@ class GarbageCollectedBase {
  * \endcode
  */
 template <typename T>
-class GarbageCollected : public internal::GarbageCollectedBase {
+class GarbageCollected {
  public:
   using IsGarbageCollectedTypeMarker = void;
   using ParentMostGarbageCollectedType = T;
 
+  // Must use MakeGarbageCollected.
+  void* operator new(size_t) = delete;
+  void* operator new[](size_t) = delete;
+  // The garbage collector is taking care of reclaiming the object. Also,
+  // virtual destructor requires an unambiguous, accessible 'operator delete'.
+  void operator delete(void*) {
+#ifdef V8_ENABLE_CHECKS
+    internal::Fatal(
+        "Manually deleting a garbage collected object is not allowed");
+#endif  // V8_ENABLE_CHECKS
+  }
+  void operator delete[](void*) = delete;
+
  protected:
   GarbageCollected() = default;
 };
@@ -101,7 +90,7 @@ class GarbageCollected : public internal::GarbageCollectedBase {
  * };
  * \endcode
  */
-class GarbageCollectedMixin : public internal::GarbageCollectedBase {
+class GarbageCollectedMixin {
  public:
   using IsGarbageCollectedMixinTypeMarker = void;
 

data/vendor/v8/include/cppgc/heap-consistency.h

@@ -149,6 +149,19 @@ class HeapConsistency final {
     internal::WriteBarrier::GenerationalBarrier(params, slot);
   }
 
+  /**
+   * Generational barrier for source object that may contain outgoing pointers
+   * to objects in young generation.
+   *
+   * \param params The parameters retrieved from `GetWriteBarrierType()`.
+   * \param inner_pointer Pointer to the source object.
+   */
+  static V8_INLINE void GenerationalBarrierForSourceObject(
+      const WriteBarrierParams& params, const void* inner_pointer) {
+    internal::WriteBarrier::GenerationalBarrierForSourceObject(params,
+                                                               inner_pointer);
+  }
+
  private:
   HeapConsistency() = delete;
 };

data/vendor/v8/include/cppgc/heap-state.h

@@ -38,6 +38,18 @@ class V8_EXPORT HeapState final {
    */
   static bool IsSweeping(const HeapHandle& heap_handle);
 
+  /*
+   * Returns whether the garbage collector is currently sweeping on the thread
+   * owning this heap. This API allows the caller to determine whether it has
+   * been called from a destructor of a managed object. This API is experimental
+   * and may be removed in future.
+   *
+   * \param heap_handle The corresponding heap.
+   * \returns true if the garbage collector is currently sweeping on this
+   *   thread, and false otherwise.
+   */
+  static bool IsSweepingOnOwningThread(const HeapHandle& heap_handle);
+
   /**
    * Returns whether the garbage collector is in the atomic pause, i.e., the
    * mutator is stopped from running. This API is experimental and is expected

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

@@ -68,8 +68,8 @@ class V8_EXPORT Heap {
      */
     kAtomic,
     /**
-     * Incremental marking, i.e. interleave marking is the rest of the
-     * application on the same thread.
+     * Incremental marking interleaves marking with the rest of the application
+     * workload on the same thread.
      */
     kIncremental,
     /**
@@ -86,6 +86,11 @@ class V8_EXPORT Heap {
      * Atomic stop-the-world sweeping. All of sweeping is performed at once.
      */
     kAtomic,
+    /**
+     * Incremental sweeping interleaves sweeping with the rest of the
+     * application workload on the same thread.
+     */
+    kIncremental,
     /**
      * Incremental and concurrent sweeping. Sweeping is split and interleaved
      * with the rest of the application.

data/vendor/v8/include/cppgc/internal/api-constants.h

@@ -39,6 +39,14 @@ constexpr size_t kCagedHeapReservationSize = static_cast<size_t>(4) * kGB;
 constexpr size_t kCagedHeapReservationAlignment = kCagedHeapReservationSize;
 #endif
 
+static constexpr size_t kDefaultAlignment = sizeof(void*);
+
+// Maximum support alignment for a type as in `alignof(T)`.
+static constexpr size_t kMaxSupportedAlignment = 2 * kDefaultAlignment;
+
+// Granularity of heap allocations.
+constexpr size_t kAllocationGranularity = sizeof(void*);
+
 }  // namespace api_constants
 
 }  // namespace internal

data/vendor/v8/include/cppgc/internal/caged-heap-local-data.h

@@ -6,6 +6,8 @@
 #define INCLUDE_CPPGC_INTERNAL_CAGED_HEAP_LOCAL_DATA_H_
 
 #include <array>
+#include <cstddef>
+#include <cstdint>
 
 #include "cppgc/internal/api-constants.h"
 #include "cppgc/internal/logging.h"
@@ -19,32 +21,41 @@ class HeapBase;
 
 #if defined(CPPGC_YOUNG_GENERATION)
 
-// AgeTable contains entries that correspond to 4KB memory regions. Each entry
-// can be in one of three states: kOld, kYoung or kUnknown.
+// AgeTable is the bytemap needed for the fast generation check in the write
+// barrier. AgeTable contains entries that correspond to 512 bytes memory
+// regions (cards). Each entry in the table represents generation of the objects
+// that reside on the corresponding card (young, old or mixed).
 class AgeTable final {
-  static constexpr size_t kGranularityBits = 12;  // 4KiB per byte.
+  static constexpr size_t kRequiredSize = 1 * api_constants::kMB;
+  static constexpr size_t kAllocationGranularity =
+      api_constants::kAllocationGranularity;
 
  public:
-  enum class Age : uint8_t { kOld, kYoung, kUnknown };
+  enum class Age : uint8_t { kOld, kYoung, kMixed };
 
-  static constexpr size_t kEntrySizeInBytes = 1 << kGranularityBits;
+  static constexpr size_t kCardSizeInBytes =
+      (api_constants::kCagedHeapReservationSize / kAllocationGranularity) /
+      kRequiredSize;
 
-  Age& operator[](uintptr_t offset) { return table_[entry(offset)]; }
-  Age operator[](uintptr_t offset) const { return table_[entry(offset)]; }
+  void SetAge(uintptr_t cage_offset, Age age) {
+    table_[card(cage_offset)] = age;
+  }
+  V8_INLINE Age GetAge(uintptr_t cage_offset) const {
+    return table_[card(cage_offset)];
+  }
 
   void Reset(PageAllocator* allocator);
 
  private:
-  static constexpr size_t kAgeTableSize =
-      api_constants::kCagedHeapReservationSize >> kGranularityBits;
-
-  size_t entry(uintptr_t offset) const {
+  V8_INLINE size_t card(uintptr_t offset) const {
+    constexpr size_t kGranularityBits =
+        __builtin_ctz(static_cast<uint32_t>(kCardSizeInBytes));
     const size_t entry = offset >> kGranularityBits;
     CPPGC_DCHECK(table_.size() > entry);
     return entry;
   }
 
-  std::array<Age, kAgeTableSize> table_;
+  std::array<Age, kRequiredSize> table_;
 };
 
 static_assert(sizeof(AgeTable) == 1 * api_constants::kMB,

data/vendor/v8/include/cppgc/internal/finalizer-trait.h

@@ -19,7 +19,8 @@ struct HasFinalizeGarbageCollectedObject : std::false_type {};
 
 template <typename T>
 struct HasFinalizeGarbageCollectedObject<
-    T, void_t<decltype(std::declval<T>().FinalizeGarbageCollectedObject())>>
+    T,
+    std::void_t<decltype(std::declval<T>().FinalizeGarbageCollectedObject())>>
     : std::true_type {};
 
 // The FinalizerTraitImpl specifies how to finalize objects.

data/vendor/v8/include/cppgc/internal/logging.h

@@ -20,18 +20,18 @@ FatalImpl(const char*, const SourceLocation& = SourceLocation::Current());
 template <typename>
 struct EatParams {};
 
-#if DEBUG
+#if defined(DEBUG)
 #define CPPGC_DCHECK_MSG(condition, message)  \
   do {                                        \
     if (V8_UNLIKELY(!(condition))) {          \
       ::cppgc::internal::DCheckImpl(message); \
     }                                         \
   } while (false)
-#else
+#else  // !defined(DEBUG)
 #define CPPGC_DCHECK_MSG(condition, message)                \
   (static_cast<void>(::cppgc::internal::EatParams<decltype( \
                          static_cast<void>(condition), message)>{}))
-#endif
+#endif  // !defined(DEBUG)
 
 #define CPPGC_DCHECK(condition) CPPGC_DCHECK_MSG(condition, #condition)
 

data/vendor/v8/include/cppgc/internal/persistent-node.h

@@ -20,6 +20,7 @@ class Visitor;
 namespace internal {
 
 class CrossThreadPersistentRegion;
+class FatalOutOfMemoryHandler;
 
 // PersistentNode represents a variant of two states:
 // 1) traceable node with a back pointer to the Persistent object;
@@ -79,22 +80,31 @@ class V8_EXPORT PersistentRegionBase {
   using PersistentNodeSlots = std::array<PersistentNode, 256u>;
 
  public:
-  PersistentRegionBase() = default;
   // Clears Persistent fields to avoid stale pointers after heap teardown.
   ~PersistentRegionBase();
 
   PersistentRegionBase(const PersistentRegionBase&) = delete;
   PersistentRegionBase& operator=(const PersistentRegionBase&) = delete;
 
-  PersistentNode* AllocateNode(void* owner, TraceCallback trace) {
-    if (!free_list_head_) {
-      EnsureNodeSlots();
+  void Trace(Visitor*);
+
+  size_t NodesInUse() const;
+
+  void ClearAllUsedNodes();
+
+ protected:
+  explicit PersistentRegionBase(const FatalOutOfMemoryHandler& oom_handler);
+
+  PersistentNode* TryAllocateNodeFromFreeList(void* owner,
+                                              TraceCallback trace) {
+    PersistentNode* node = nullptr;
+    if (V8_LIKELY(free_list_head_)) {
+      node = free_list_head_;
+      free_list_head_ = free_list_head_->FreeListNext();
+      CPPGC_DCHECK(!node->IsUsed());
+      node->InitializeAsUsedNode(owner, trace);
+      nodes_in_use_++;
     }
-    PersistentNode* node = free_list_head_;
-    free_list_head_ = free_list_head_->FreeListNext();
-    CPPGC_DCHECK(!node->IsUsed());
-    node->InitializeAsUsedNode(owner, trace);
-    nodes_in_use_++;
     return node;
   }
 
@@ -107,21 +117,19 @@ class V8_EXPORT PersistentRegionBase {
     nodes_in_use_--;
   }
 
-  void Trace(Visitor*);
-
-  size_t NodesInUse() const;
-
-  void ClearAllUsedNodes();
+  PersistentNode* RefillFreeListAndAllocateNode(void* owner,
+                                                TraceCallback trace);
 
  private:
-  void EnsureNodeSlots();
-
   template <typename PersistentBaseClass>
   void ClearAllUsedNodes();
 
+  void RefillFreeList();
+
   std::vector<std::unique_ptr<PersistentNodeSlots>> nodes_;
   PersistentNode* free_list_head_ = nullptr;
   size_t nodes_in_use_ = 0;
+  const FatalOutOfMemoryHandler& oom_handler_;
 
   friend class CrossThreadPersistentRegion;
 };
@@ -130,7 +138,7 @@ class V8_EXPORT PersistentRegionBase {
 // freeing happens only on the thread that created the region.
 class V8_EXPORT PersistentRegion final : public PersistentRegionBase {
  public:
-  PersistentRegion();
+  explicit PersistentRegion(const FatalOutOfMemoryHandler&);
   // Clears Persistent fields to avoid stale pointers after heap teardown.
   ~PersistentRegion() = default;
 
@@ -138,21 +146,22 @@ class V8_EXPORT PersistentRegion final : public PersistentRegionBase {
   PersistentRegion& operator=(const PersistentRegion&) = delete;
 
   V8_INLINE PersistentNode* AllocateNode(void* owner, TraceCallback trace) {
-#if V8_ENABLE_CHECKS
-    CheckIsCreationThread();
-#endif  // V8_ENABLE_CHECKS
-    return PersistentRegionBase::AllocateNode(owner, trace);
+    CPPGC_DCHECK(IsCreationThread());
+    auto* node = TryAllocateNodeFromFreeList(owner, trace);
+    if (V8_LIKELY(node)) return node;
+
+    // Slow path allocation allows for checking thread correspondence.
+    CPPGC_CHECK(IsCreationThread());
+    return RefillFreeListAndAllocateNode(owner, trace);
   }
 
   V8_INLINE void FreeNode(PersistentNode* node) {
-#if V8_ENABLE_CHECKS
-    CheckIsCreationThread();
-#endif  // V8_ENABLE_CHECKS
+    CPPGC_DCHECK(IsCreationThread());
     PersistentRegionBase::FreeNode(node);
   }
 
  private:
-  void CheckIsCreationThread();
+  bool IsCreationThread();
 
   int creation_thread_id_;
 };
@@ -172,7 +181,7 @@ class V8_EXPORT PersistentRegionLock final {
 class V8_EXPORT CrossThreadPersistentRegion final
     : protected PersistentRegionBase {
  public:
-  CrossThreadPersistentRegion() = default;
+  explicit CrossThreadPersistentRegion(const FatalOutOfMemoryHandler&);
   // Clears Persistent fields to avoid stale pointers after heap teardown.
   ~CrossThreadPersistentRegion();
 
@@ -182,7 +191,10 @@ class V8_EXPORT CrossThreadPersistentRegion final
 
   V8_INLINE PersistentNode* AllocateNode(void* owner, TraceCallback trace) {
     PersistentRegionLock::AssertLocked();
-    return PersistentRegionBase::AllocateNode(owner, trace);
+    auto* node = TryAllocateNodeFromFreeList(owner, trace);
+    if (V8_LIKELY(node)) return node;
+
+    return RefillFreeListAndAllocateNode(owner, trace);
   }
 
   V8_INLINE void FreeNode(PersistentNode* node) {