libv8-node 22.7.0.4-x86_64-linux → 24.1.0.0-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 336c0ae682db5dc4f6f217accd174186b010ea7e3904283a10435857730c840b
-  data.tar.gz: 1b4bfba3017cc4ae48c834e89fff4a09768ee16f028f1de30a7fd7a59a2f5ef8
+  metadata.gz: ee09c619e80828aaeb2c7e2058adcfa5336b69a3b4daa9a2010ee516957018d4
+  data.tar.gz: 05c79c8073a9c02c707c80455208a820d7f593a19b3bebe8548a20f80b54f6ed
 SHA512:
-  metadata.gz: d6a4a07c40126edd2f0cbced0b7c626d2924736a1021ddf3b4822612a9144fd0baa64514b76513847ef6b382cd785f0b2bf892897e7d85108fc6ad523f4e77c3
-  data.tar.gz: e6b7927204c8a465694a4898634c73d1e0293e62b9f97196751b097e4155ee644d235374de539f3ffcec0c3e09d6f9cd27ae42cd37a9985359303ee7aeacce41
+  metadata.gz: 96a2d77d885fdb71db406980345d2630a9ecce05b91cb4030fac3ceb074912fd9a018b654c18f8e36a8001a76ab38f19f5d503a170b08576ebcb21eae8c5d8f2
+  data.tar.gz: ffb27f160c1942977bb41e40e75841938a129b78648d828bb75937e8c8f8666d5affd9f419f28192dd8148a4f6168e335de04c7887ccf72f1e9f3e90f9d05168

data/lib/libv8/node/version.rb

@@ -4,7 +4,7 @@ module Libv8
 end
 
 module Libv8::Node
-  VERSION = '22.7.0.4'
-  NODE_VERSION = '22.7.0'
-  LIBV8_VERSION = '12.4.254.21' # from src/node-.../deps/v8/include/v8-version.h
+  VERSION = '24.1.0.0'
+  NODE_VERSION = '24.1.0'
+  LIBV8_VERSION = '13.6.233.10' # from src/node-.../deps/v8/include/v8-version.h
 end

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

@@ -44,10 +44,9 @@ class AllocationHandle;
 
 namespace internal {
 
-// Similar to C++17 std::align_val_t;
-enum class AlignVal : size_t {};
+using AlignVal = std::align_val_t;
 
-class V8_EXPORT MakeGarbageCollectedTraitInternal {
+class MakeGarbageCollectedTraitInternal {
  protected:
   static inline void MarkObjectAsFullyConstructed(const void* payload) {
     // See api_constants for an explanation of the constants.
@@ -121,16 +120,15 @@ class V8_EXPORT MakeGarbageCollectedTraitInternal {
   };
 
  private:
-  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);
+  V8_EXPORT static void* CPPGC_DEFAULT_ALIGNED
+  Allocate(cppgc::AllocationHandle&, size_t, GCInfoIndex);
+  V8_EXPORT static void* CPPGC_DOUBLE_WORD_ALIGNED
+  Allocate(cppgc::AllocationHandle&, size_t, AlignVal, GCInfoIndex);
+  V8_EXPORT static void* CPPGC_DEFAULT_ALIGNED
+  Allocate(cppgc::AllocationHandle&, size_t, GCInfoIndex, CustomSpaceIndex);
+  V8_EXPORT static void* CPPGC_DOUBLE_WORD_ALIGNED
+  Allocate(cppgc::AllocationHandle&, size_t, AlignVal, GCInfoIndex,
+           CustomSpaceIndex);
 
   friend class HeapObjectHeader;
 };

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

@@ -37,11 +37,12 @@ class V8_EXPORT DefaultPlatform : public Platform {
     return v8_platform_->MonotonicallyIncreasingTime();
   }
 
-  std::shared_ptr<cppgc::TaskRunner> GetForegroundTaskRunner() override {
+  std::shared_ptr<cppgc::TaskRunner> GetForegroundTaskRunner(
+      TaskPriority priority) override {
     // V8's default platform creates a new task runner when passed the
     // `v8::Isolate` pointer the first time. For non-default platforms this will
     // require getting the appropriate task runner.
-    return v8_platform_->GetForegroundTaskRunner(kNoIsolate);
+    return v8_platform_->GetForegroundTaskRunner(kNoIsolate, priority);
   }
 
   std::unique_ptr<cppgc::JobHandle> PostJob(

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

@@ -94,6 +94,14 @@ class GarbageCollectedMixin {
  public:
   using IsGarbageCollectedMixinTypeMarker = void;
 
+  // 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.
+  // Not override the non-array varaint of `delete` to not conflict with the
+  // operator in GarbageCollected above.
+  void operator delete[](void*) = delete;
+
   /**
    * This Trace method must be overriden by objects inheriting from
    * GarbageCollectedMixin.

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

@@ -114,7 +114,7 @@ class HeapConsistency final {
    * has not yet been processed.
    *
    * \param params The parameters retrieved from `GetWriteBarrierType()`.
-   * \param object The pointer to the object. May be an interior pointer to a
+   * \param object The pointer to the object. May be an interior pointer to
    *   an interface of the actual object.
    */
   static V8_INLINE void DijkstraWriteBarrier(const WriteBarrierParams& params,

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

@@ -102,6 +102,8 @@ struct HeapStatistics final {
   size_t resident_size_bytes = 0;
   /** Amount of memory actually used on the heap. */
   size_t used_size_bytes = 0;
+  /** Memory retained in the page pool, not used directly by the heap. */
+  size_t pooled_memory_size_bytes = 0;
   /** Detail level of this HeapStatistics. */
   DetailLevel detail_level;
 

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

@@ -30,13 +30,8 @@ static constexpr size_t kFullyConstructedBitFieldOffsetFromPayload =
 // Mask for in-construction bit.
 static constexpr uint16_t kFullyConstructedBitMask = uint16_t{1};
 
-static constexpr size_t kPageSize = size_t{1} << 17;
-
-#if defined(V8_HOST_ARCH_ARM64) && defined(V8_OS_DARWIN)
-constexpr size_t kGuardPageSize = 0;
-#else
-constexpr size_t kGuardPageSize = 4096;
-#endif
+static constexpr size_t kPageSizeBits = 17;
+static constexpr size_t kPageSize = size_t{1} << kPageSizeBits;
 
 static constexpr size_t kLargeObjectSizeThreshold = kPageSize / 2;
 
@@ -49,12 +44,6 @@ constexpr unsigned kPointerCompressionShift = 1;
 #endif  // !defined(CPPGC_POINTER_COMPRESSION)
 
 #if defined(CPPGC_CAGED_HEAP)
-#if defined(CPPGC_2GB_CAGE)
-constexpr size_t kCagedHeapDefaultReservationSize =
-    static_cast<size_t>(2) * kGB;
-constexpr size_t kCagedHeapMaxReservationSize =
-    kCagedHeapDefaultReservationSize;
-#else  // !defined(CPPGC_2GB_CAGE)
 constexpr size_t kCagedHeapDefaultReservationSize =
     static_cast<size_t>(4) * kGB;
 #if defined(CPPGC_POINTER_COMPRESSION)
@@ -64,7 +53,6 @@ constexpr size_t kCagedHeapMaxReservationSize =
 constexpr size_t kCagedHeapMaxReservationSize =
     kCagedHeapDefaultReservationSize;
 #endif  // !defined(CPPGC_POINTER_COMPRESSION)
-#endif  // !defined(CPPGC_2GB_CAGE)
 constexpr size_t kCagedHeapReservationAlignment = kCagedHeapMaxReservationSize;
 #endif  // defined(CPPGC_CAGED_HEAP)
 

data/vendor/v8/include/cppgc/internal/base-page-handle.h

@@ -19,9 +19,7 @@ class BasePageHandle {
  public:
   static V8_INLINE BasePageHandle* FromPayload(void* payload) {
     return reinterpret_cast<BasePageHandle*>(
-        (reinterpret_cast<uintptr_t>(payload) &
-         ~(api_constants::kPageSize - 1)) +
-        api_constants::kGuardPageSize);
+        reinterpret_cast<uintptr_t>(payload) & ~(api_constants::kPageSize - 1));
   }
   static V8_INLINE const BasePageHandle* FromPayload(const void* payload) {
     return FromPayload(const_cast<void*>(payload));
@@ -33,7 +31,7 @@ class BasePageHandle {
  protected:
   explicit BasePageHandle(HeapHandle& heap_handle) : heap_handle_(heap_handle) {
     CPPGC_DCHECK(reinterpret_cast<uintptr_t>(this) % api_constants::kPageSize ==
-                 api_constants::kGuardPageSize);
+                 0);
   }
 
   HeapHandle& heap_handle_;

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

@@ -77,11 +77,7 @@ class V8_EXPORT AgeTable final {
         __builtin_ctz(static_cast<uint32_t>(kCardSizeInBytes));
 #else   //! V8_HAS_BUILTIN_CTZ
         // Hardcode and check with assert.
-#if defined(CPPGC_2GB_CAGE)
-        11;
-#else   // !defined(CPPGC_2GB_CAGE)
         12;
-#endif  // !defined(CPPGC_2GB_CAGE)
 #endif  // !V8_HAS_BUILTIN_CTZ
     static_assert((1 << kGranularityBits) == kCardSizeInBytes);
     const size_t entry = offset >> kGranularityBits;

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

@@ -32,16 +32,12 @@ class V8_EXPORT CagedHeapBase {
   }
 
   V8_INLINE static bool AreWithinCage(const void* addr1, const void* addr2) {
-#if defined(CPPGC_2GB_CAGE)
-    static constexpr size_t kHeapBaseShift = sizeof(uint32_t) * CHAR_BIT - 1;
-#else   //! defined(CPPGC_2GB_CAGE)
 #if defined(CPPGC_POINTER_COMPRESSION)
     static constexpr size_t kHeapBaseShift =
         31 + api_constants::kPointerCompressionShift;
 #else   // !defined(CPPGC_POINTER_COMPRESSION)
     static constexpr size_t kHeapBaseShift = sizeof(uint32_t) * CHAR_BIT;
 #endif  // !defined(CPPGC_POINTER_COMPRESSION)
-#endif  //! defined(CPPGC_2GB_CAGE)
     static_assert((static_cast<size_t>(1) << kHeapBaseShift) ==
                   api_constants::kCagedHeapMaxReservationSize);
     CPPGC_DCHECK(g_heap_base_);

data/vendor/v8/include/cppgc/internal/compiler-specific.h

@@ -5,6 +5,8 @@
 #ifndef INCLUDE_CPPGC_INTERNAL_COMPILER_SPECIFIC_H_
 #define INCLUDE_CPPGC_INTERNAL_COMPILER_SPECIFIC_H_
 
+#include "v8config.h"  // NOLINT(build/include_directory)
+
 namespace cppgc {
 
 #if defined(__has_attribute)
@@ -21,7 +23,13 @@ namespace cppgc {
 
 // [[no_unique_address]] comes in C++20 but supported in clang with -std >=
 // c++11.
-#if CPPGC_HAS_CPP_ATTRIBUTE(no_unique_address)
+#if defined(V8_CC_MSVC) && CPPGC_HAS_CPP_ATTRIBUTE(msvc::no_unique_address)
+// Unfortunately MSVC ignores [[no_unique_address]] (see
+// https://devblogs.microsoft.com/cppblog/msvc-cpp20-and-the-std-cpp20-switch/#msvc-extensions-and-abi),
+// and clang-cl matches it for ABI compatibility reasons. We need to prefer
+// [[msvc::no_unique_address]] when available if we actually want any effect.
+#define CPPGC_NO_UNIQUE_ADDRESS [[msvc::no_unique_address]]
+#elif CPPGC_HAS_CPP_ATTRIBUTE(no_unique_address)
 #define CPPGC_NO_UNIQUE_ADDRESS [[no_unique_address]]
 #else
 #define CPPGC_NO_UNIQUE_ADDRESS

data/vendor/v8/include/cppgc/internal/conditional-stack-allocated.h

@@ -0,0 +1,41 @@
+// Copyright 2025 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef INCLUDE_CPPGC_INTERNAL_CONDITIONAL_STACK_ALLOCATED_H_
+#define INCLUDE_CPPGC_INTERNAL_CONDITIONAL_STACK_ALLOCATED_H_
+
+#include <type_traits>
+
+#include "cppgc/macros.h"       // NOLINT(build/include_directory)
+#include "cppgc/type-traits.h"  // NOLINT(build/include_directory)
+
+namespace cppgc {
+namespace internal {
+
+// Base class that is marked as stack allocated if T is either marked as stack
+// allocated or a traceable type.
+template <typename T>
+class ConditionalStackAllocatedBase;
+
+template <typename T>
+concept RequiresStackAllocated =
+    !std::is_void_v<T> &&
+    (cppgc::IsStackAllocatedType<T> || cppgc::internal::IsTraceableV<T> ||
+     cppgc::IsGarbageCollectedOrMixinTypeV<T>);
+
+template <typename T>
+  requires(RequiresStackAllocated<T>)
+class ConditionalStackAllocatedBase<T> {
+ public:
+  CPPGC_STACK_ALLOCATED();
+};
+
+template <typename T>
+  requires(!RequiresStackAllocated<T>)
+class ConditionalStackAllocatedBase<T> {};
+
+}  // namespace internal
+}  // namespace cppgc
+
+#endif  // INCLUDE_CPPGC_INTERNAL_CONDITIONAL_STACK_ALLOCATED_H_

data/vendor/v8/include/cppgc/internal/gc-info.h

@@ -94,12 +94,11 @@ struct GCInfoTrait final {
     return index;
   }
 
-  static constexpr bool CheckCallbacksAreDefined() {
+  static constexpr void CheckCallbacksAreDefined() {
     // No USE() macro available.
     (void)static_cast<TraceCallback>(TraceTrait<T>::Trace);
     (void)static_cast<FinalizationCallback>(FinalizerTrait<T>::kCallback);
     (void)static_cast<NameCallback>(NameTrait<T>::GetName);
-    return true;
   }
 };
 
@@ -127,19 +126,22 @@ struct GCInfoFolding final {
   // configuration. Only a single GCInfo (for `ResultType` below) will actually
   // be instantiated but existence (and well-formedness) of all callbacks is
   // checked.
-  static constexpr bool kCheckTypeGuardAlwaysTrue =
-      GCInfoTrait<T>::CheckCallbacksAreDefined() &&
+  static constexpr bool WantToFold() {
+    if constexpr ((kHasVirtualDestructorAtBase ||
+                   kBothTypesAreTriviallyDestructible ||
+                   kHasCustomFinalizerDispatchAtBase) &&
+                  !kWantsDetailedObjectNames) {
+      GCInfoTrait<T>::CheckCallbacksAreDefined();
       GCInfoTrait<ParentMostGarbageCollectedType>::CheckCallbacksAreDefined();
+      return true;
+    }
+    return false;
+  }
 
   // Folding would regress name resolution when deriving names from C++
   // class names as it would just folds a name to the base class name.
   using ResultType =
-      std::conditional_t<kCheckTypeGuardAlwaysTrue &&
-                             (kHasVirtualDestructorAtBase ||
-                              kBothTypesAreTriviallyDestructible ||
-                              kHasCustomFinalizerDispatchAtBase) &&
-                             !kWantsDetailedObjectNames,
-                         ParentMostGarbageCollectedType, T>;
+      std::conditional_t<WantToFold(), ParentMostGarbageCollectedType, T>;
 };
 
 }  // namespace internal

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

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

data/vendor/v8/include/cppgc/internal/member-storage.h

@@ -10,6 +10,7 @@
 #include <type_traits>
 
 #include "cppgc/internal/api-constants.h"
+#include "cppgc/internal/caged-heap.h"
 #include "cppgc/internal/logging.h"
 #include "cppgc/sentinel-pointer.h"
 #include "v8config.h"  // NOLINT(build/include_directory)
@@ -71,11 +72,17 @@ class V8_EXPORT CageBaseGlobal final {
 
 class V8_TRIVIAL_ABI CompressedPointer final {
  public:
+  struct AtomicInitializerTag {};
+
   using IntegralType = uint32_t;
   static constexpr auto kWriteBarrierSlotType =
       WriteBarrierSlotType::kCompressed;
 
   V8_INLINE CompressedPointer() : value_(0u) {}
+  V8_INLINE explicit CompressedPointer(const void* value,
+                                       AtomicInitializerTag) {
+    StoreAtomic(value);
+  }
   V8_INLINE explicit CompressedPointer(const void* ptr)
       : value_(Compress(ptr)) {}
   V8_INLINE explicit CompressedPointer(std::nullptr_t) : value_(0u) {}
@@ -139,17 +146,12 @@ class V8_TRIVIAL_ABI CompressedPointer final {
     CPPGC_DCHECK(
         (reinterpret_cast<uintptr_t>(ptr) & kPointerCompressionShiftMask) == 0);
 
-#if defined(CPPGC_2GB_CAGE)
-    // Truncate the pointer.
-    auto compressed =
-        static_cast<IntegralType>(reinterpret_cast<uintptr_t>(ptr));
-#else   // !defined(CPPGC_2GB_CAGE)
     const auto uptr = reinterpret_cast<uintptr_t>(ptr);
     // Shift the pointer and truncate.
     auto compressed = static_cast<IntegralType>(
         uptr >> api_constants::kPointerCompressionShift);
-#endif  // !defined(CPPGC_2GB_CAGE)
-    // Normal compressed pointers must have the MSB set.
+    // Normal compressed pointers must have the MSB set. This is guaranteed by
+    // the cage alignment.
     CPPGC_DCHECK((!compressed || compressed == kCompressedSentinel) ||
                  (compressed & (1 << 31)));
     return compressed;
@@ -158,43 +160,83 @@ class V8_TRIVIAL_ABI CompressedPointer final {
   static V8_INLINE void* Decompress(IntegralType ptr) {
     CPPGC_DCHECK(CageBaseGlobal::IsSet());
     const uintptr_t base = CageBaseGlobal::Get();
-    // Treat compressed pointer as signed and cast it to uint64_t, which will
-    // sign-extend it.
-#if defined(CPPGC_2GB_CAGE)
-    const uint64_t mask = static_cast<uint64_t>(static_cast<int32_t>(ptr));
-#else   // !defined(CPPGC_2GB_CAGE)
-    // Then, shift the result. It's important to shift the unsigned
-    // value, as otherwise it would result in undefined behavior.
+    return Decompress(ptr, base);
+  }
+
+  static V8_INLINE void* Decompress(IntegralType ptr, uintptr_t base) {
+    CPPGC_DCHECK(CageBaseGlobal::IsSet());
+    CPPGC_DCHECK(base == CageBaseGlobal::Get());
+    // Sign-extend compressed pointer to full width. This ensure that normal
+    // pointers have only 1s in the base part of the address. It's also
+    // important to shift the unsigned value, as otherwise it would result in
+    // undefined behavior.
     const uint64_t mask = static_cast<uint64_t>(static_cast<int32_t>(ptr))
                           << api_constants::kPointerCompressionShift;
-#endif  // !defined(CPPGC_2GB_CAGE)
+    // Set the base part of the address for normal compressed pointers. Note
+    // that nullptr and the sentinel value do not have 1s in the base part and
+    // remain as-is in this operation.
     return reinterpret_cast<void*>(mask & base);
   }
 
+  // For a given memory `address`, this method iterates all possible pointers
+  // that can be reasonably recovered with the current compression scheme and
+  // passes them to `callback`.
+  template <typename Callback>
+  static V8_INLINE void VisitPossiblePointers(const void* address,
+                                              Callback callback);
+
  private:
-#if defined(CPPGC_2GB_CAGE)
-  static constexpr IntegralType kCompressedSentinel =
-      SentinelPointer::kSentinelValue;
-#else   // !defined(CPPGC_2GB_CAGE)
   static constexpr IntegralType kCompressedSentinel =
       SentinelPointer::kSentinelValue >>
       api_constants::kPointerCompressionShift;
-#endif  // !defined(CPPGC_2GB_CAGE)
   // All constructors initialize `value_`. 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.
   IntegralType value_;
 };
 
+template <typename Callback>
+// static
+void CompressedPointer::VisitPossiblePointers(const void* address,
+                                              Callback callback) {
+  const uintptr_t base = CageBaseGlobal::Get();
+  CPPGC_DCHECK(base);
+  // We may have random compressed pointers on stack (e.g. due to inlined
+  // collections). These could be present in both halfwords.
+  const uint32_t compressed_low =
+      static_cast<uint32_t>(reinterpret_cast<uintptr_t>(address));
+  callback(CompressedPointer::Decompress(compressed_low, base));
+  const uint32_t compressed_high = static_cast<uint32_t>(
+      reinterpret_cast<uintptr_t>(address) >> (sizeof(uint32_t) * CHAR_BIT));
+  callback(CompressedPointer::Decompress(compressed_high, base));
+  // Iterate possible intermediate values, see `Decompress()`. The intermediate
+  // value of decompressing is a 64-bit value where 35 bits are the offset. We
+  // don't assume sign extension is stored and recover that part.
+  //
+  // Note that this case conveniently also recovers the full pointer.
+  static constexpr uintptr_t kBitForIntermediateValue =
+      (sizeof(uint32_t) * CHAR_BIT) + api_constants::kPointerCompressionShift;
+  static constexpr uintptr_t kSignExtensionMask =
+      ~((uintptr_t{1} << kBitForIntermediateValue) - 1);
+  const uintptr_t intermediate_sign_extended =
+      reinterpret_cast<uintptr_t>(address) | kSignExtensionMask;
+  callback(reinterpret_cast<void*>(intermediate_sign_extended & base));
+}
+
 #endif  // defined(CPPGC_POINTER_COMPRESSION)
 
 class V8_TRIVIAL_ABI RawPointer final {
  public:
+  struct AtomicInitializerTag {};
+
   using IntegralType = uintptr_t;
   static constexpr auto kWriteBarrierSlotType =
       WriteBarrierSlotType::kUncompressed;
 
   V8_INLINE RawPointer() : ptr_(nullptr) {}
+  V8_INLINE explicit RawPointer(const void* ptr, AtomicInitializerTag) {
+    StoreAtomic(ptr);
+  }
   V8_INLINE explicit RawPointer(const void* ptr) : ptr_(ptr) {}
 
   V8_INLINE const void* Load() const { return ptr_; }
@@ -237,6 +279,13 @@ class V8_TRIVIAL_ABI RawPointer final {
     return a.ptr_ >= b.ptr_;
   }
 
+  template <typename Callback>
+  static V8_INLINE void VisitPossiblePointers(const void* address,
+                                              Callback callback) {
+    // Pass along the full pointer.
+    return callback(const_cast<void*>(address));
+  }
+
  private:
   // All constructors initialize `ptr_`. Do not add a default value here as it
   // results in a non-atomic write on some builds, even when the atomic version

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

@@ -121,7 +121,11 @@ class NameTrait final : public NameTraitBase {
 #undef PRETTY_FUNCTION_VALUE
 
 #else   // !CPPGC_SUPPORTS_OBJECT_NAMES
-    return {NameProvider::kHiddenName, true};
+    // We wanted to use a class name but were unable to provide one due to
+    // compiler limitations or build configuration. As such, return the hidden
+    // name with name_was_hidden=false, which will cause this object to be
+    // visible in the snapshot.
+    return {NameProvider::kHiddenName, false};
 #endif  // !CPPGC_SUPPORTS_OBJECT_NAMES
   }
 };

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

@@ -18,6 +18,7 @@ namespace internal {
 
 class CrossThreadPersistentRegion;
 class FatalOutOfMemoryHandler;
+class HeapBase;
 class RootVisitor;
 
 // PersistentNode represents a variant of two states:
@@ -133,10 +134,14 @@ class V8_EXPORT PersistentRegionBase {
 };
 
 // Variant of PersistentRegionBase that checks whether the allocation and
-// freeing happens only on the thread that created the region.
+// freeing happens only on the thread that created the heap.
 class V8_EXPORT PersistentRegion final : public PersistentRegionBase {
  public:
-  explicit PersistentRegion(const FatalOutOfMemoryHandler&);
+  V8_INLINE PersistentRegion(const HeapBase& heap,
+                             const FatalOutOfMemoryHandler& oom_handler)
+      : PersistentRegionBase(oom_handler), heap_(heap) {
+    CPPGC_DCHECK(IsCreationThread());
+  }
   // Clears Persistent fields to avoid stale pointers after heap teardown.
   ~PersistentRegion() = default;
 
@@ -161,7 +166,7 @@ class V8_EXPORT PersistentRegion final : public PersistentRegionBase {
  private:
   bool IsCreationThread();
 
-  int creation_thread_id_;
+  const HeapBase& heap_;
 };
 
 // CrossThreadPersistent uses PersistentRegionBase but protects it using this

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

@@ -28,13 +28,19 @@ class WeakMemberTag;
 class UntracedMemberTag;
 
 struct DijkstraWriteBarrierPolicy {
-  V8_INLINE static void InitializingBarrier(const void*, const void*) {
     // Since in initializing writes the source object is always white, having no
     // barrier doesn't break the tri-color invariant.
-  }
+    V8_INLINE static void InitializingBarrier(const void*, const void*) {}
+    V8_INLINE static void InitializingBarrier(const void*, RawPointer storage) {
+    }
+#if defined(CPPGC_POINTER_COMPRESSION)
+    V8_INLINE static void InitializingBarrier(const void*,
+                                              CompressedPointer storage) {}
+#endif
 
-  template <WriteBarrierSlotType SlotType>
-  V8_INLINE static void AssigningBarrier(const void* slot, const void* value) {
+    template <WriteBarrierSlotType SlotType>
+    V8_INLINE static void AssigningBarrier(const void* slot,
+                                           const void* value) {
 #ifdef CPPGC_SLIM_WRITE_BARRIER
     if (V8_UNLIKELY(WriteBarrier::IsEnabled()))
       WriteBarrier::CombinedWriteBarrierSlow<SlotType>(slot);
@@ -44,7 +50,7 @@ struct DijkstraWriteBarrierPolicy {
         WriteBarrier::GetWriteBarrierType(slot, value, params);
     WriteBarrier(type, params, slot, value);
 #endif  // !CPPGC_SLIM_WRITE_BARRIER
-  }
+    }
 
   template <WriteBarrierSlotType SlotType>
   V8_INLINE static void AssigningBarrier(const void* slot, RawPointer storage) {
@@ -101,6 +107,11 @@ struct DijkstraWriteBarrierPolicy {
 
 struct NoWriteBarrierPolicy {
   V8_INLINE static void InitializingBarrier(const void*, const void*) {}
+  V8_INLINE static void InitializingBarrier(const void*, RawPointer storage) {}
+#if defined(CPPGC_POINTER_COMPRESSION)
+  V8_INLINE static void InitializingBarrier(const void*,
+                                            CompressedPointer storage) {}
+#endif
   template <WriteBarrierSlotType>
   V8_INLINE static void AssigningBarrier(const void*, const void*) {}
   template <WriteBarrierSlotType, typename MemberStorage>
@@ -119,10 +130,29 @@ template <bool kCheckOffHeapAssignments>
 class V8_EXPORT SameThreadEnabledCheckingPolicy
     : private SameThreadEnabledCheckingPolicyBase {
  protected:
+  template <typename T>
+  V8_INLINE void CheckPointer(RawPointer raw_pointer) {
+    if (raw_pointer.IsCleared() || raw_pointer.IsSentinel()) {
+      return;
+    }
+    CheckPointersImplTrampoline<T>::Call(
+        this, static_cast<const T*>(raw_pointer.Load()));
+  }
+#if defined(CPPGC_POINTER_COMPRESSION)
+  template <typename T>
+  V8_INLINE void CheckPointer(CompressedPointer compressed_pointer) {
+    if (compressed_pointer.IsCleared() || compressed_pointer.IsSentinel()) {
+      return;
+    }
+    CheckPointersImplTrampoline<T>::Call(
+        this, static_cast<const T*>(compressed_pointer.Load()));
+  }
+#endif
   template <typename T>
   void CheckPointer(const T* ptr) {
-    if (!ptr || (kSentinelPointer == ptr)) return;
-
+    if (!ptr || (kSentinelPointer == ptr)) {
+      return;
+    }
     CheckPointersImplTrampoline<T>::Call(this, ptr);
   }
 
@@ -145,20 +175,27 @@ class V8_EXPORT SameThreadEnabledCheckingPolicy
 
 class DisabledCheckingPolicy {
  protected:
-  V8_INLINE void CheckPointer(const void*) {}
+  template <typename T>
+  V8_INLINE void CheckPointer(T*) {}
+  template <typename T>
+  V8_INLINE void CheckPointer(RawPointer) {}
+#if defined(CPPGC_POINTER_COMPRESSION)
+  template <typename T>
+  V8_INLINE void CheckPointer(CompressedPointer) {}
+#endif
 };
 
-#ifdef DEBUG
+#ifdef CPPGC_ENABLE_SLOW_API_CHECKS
 // Off heap members are not connected to object graph and thus cannot ressurect
 // dead objects.
 using DefaultMemberCheckingPolicy =
     SameThreadEnabledCheckingPolicy<false /* kCheckOffHeapAssignments*/>;
 using DefaultPersistentCheckingPolicy =
     SameThreadEnabledCheckingPolicy<true /* kCheckOffHeapAssignments*/>;
-#else   // !DEBUG
+#else   // !CPPGC_ENABLE_SLOW_API_CHECKS
 using DefaultMemberCheckingPolicy = DisabledCheckingPolicy;
 using DefaultPersistentCheckingPolicy = DisabledCheckingPolicy;
-#endif  // !DEBUG
+#endif  // !CPPGC_ENABLE_SLOW_API_CHECKS
 // For CT(W)P neither marking information (for value), nor objectstart bitmap
 // (for slot) are guaranteed to be present because there's no synchronization
 // between heaps after marking.