libv8-node 23.6.1.0-x86_64-linux-musl → 24.1.0.0-x86_64-linux-musl

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e81910422afe3366f5713dd24e7c6e7e07040416d86b7979cb1d044d56252a45
-  data.tar.gz: 6acd08d2e844c9979fb66f7fcf5af972be5a95b60f4dc32eee76329510d8bf86
+  metadata.gz: 3179d6eb51e824a6ff298674a6289d4bf94b30773ecd63fba733039848f3e830
+  data.tar.gz: a7c43ff53c1f074a2f53c485e759ae64288d2f8341c56ff5753b3a060660de64
 SHA512:
-  metadata.gz: 58dca831a52e52a9eaebbd636d9f90ac485fd0e6062da9d5496cbd4f1f97d499cd9ed5a02aa8246798fad5b3ae1ff1a73dd54db4f4884c2fbc9eb1c620351f18
-  data.tar.gz: '084bdd1d85f12512bb6faf0d4df626b39d9bfc2c3b73d47f7cd0a0317f8650104dea36aa5e1f01f7b9276b8839f3cbb8c49530625a7db186b0887f6c07f0a160'
+  metadata.gz: f366b90bdc9f341e4cc3e5bce39c67d587456a4bc748fbf6a7266449a8564cb5a8be8621169e944ad12ac44af78bd442d40731130599c749e5b13dfdf68ebbaf
+  data.tar.gz: 53fe2b96b3e8bbc3726f68a03bd1738a30fd66042f5b492837a7985dc0be59c55ee8cac9af8091e39d42c3262633b7007bec1090b02ba4c18458dc9f60523959

data/lib/libv8/node/version.rb

@@ -4,7 +4,7 @@ module Libv8
 end
 
 module Libv8::Node
-  VERSION = '23.6.1.0'
-  NODE_VERSION = '23.6.1'
-  LIBV8_VERSION = '12.9.202.28' # 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,8 +44,7 @@ class AllocationHandle;
 
 namespace internal {
 
-// Similar to C++17 std::align_val_t;
-enum class AlignVal : size_t {};
+using AlignVal = std::align_val_t;
 
 class MakeGarbageCollectedTraitInternal {
  protected:

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/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/internal/api-constants.h

@@ -33,16 +33,6 @@ static constexpr uint16_t kFullyConstructedBitMask = uint16_t{1};
 static constexpr size_t kPageSizeBits = 17;
 static constexpr size_t kPageSize = size_t{1} << kPageSizeBits;
 
-#if defined(V8_HOST_ARCH_ARM64) && defined(V8_OS_DARWIN)
-constexpr size_t kGuardPageSize = 0;
-#elif defined(V8_HOST_ARCH_PPC64)
-constexpr size_t kGuardPageSize = 0;
-#elif defined(V8_HOST_ARCH_LOONG64) || defined(V8_HOST_ARCH_MIPS64)
-constexpr size_t kGuardPageSize = 0;
-#else
-constexpr size_t kGuardPageSize = 4096;
-#endif
-
 static constexpr size_t kLargeObjectSizeThreshold = kPageSize / 2;
 
 #if defined(CPPGC_POINTER_COMPRESSION)
@@ -54,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)
@@ -69,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/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/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;
@@ -164,43 +166,77 @@ class V8_TRIVIAL_ABI CompressedPointer final {
   static V8_INLINE void* Decompress(IntegralType ptr, uintptr_t base) {
     CPPGC_DCHECK(CageBaseGlobal::IsSet());
     CPPGC_DCHECK(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.
+    // 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_; }
@@ -243,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/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.

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

@@ -11,10 +11,18 @@
 
 namespace cppgc {
 
+#define CPPGC_DISALLOW_NEW()                                      \
+ public:                                                          \
+  using IsDisallowNewMarker CPPGC_UNUSED = int;                   \
+  void* operator new(size_t, void* location) { return location; } \
+  void* operator new(size_t) = delete;                            \
+  static_assert(true, "Force semicolon.")
+
 // Use CPPGC_STACK_ALLOCATED if the object is only stack allocated.
 // Add the CPPGC_STACK_ALLOCATED_IGNORE annotation on a case-by-case basis when
 // enforcement of CPPGC_STACK_ALLOCATED should be suppressed.
 #if defined(__clang__)
+
 #define CPPGC_STACK_ALLOCATED()                        \
  public:                                               \
   using IsStackAllocatedTypeMarker CPPGC_UNUSED = int; \
@@ -23,13 +31,26 @@ namespace cppgc {
   void* operator new(size_t) = delete;                 \
   void* operator new(size_t, void*) = delete;          \
   static_assert(true, "Force semicolon.")
+
 #define CPPGC_STACK_ALLOCATED_IGNORE(bug_or_reason) \
   __attribute__((annotate("stack_allocated_ignore")))
+
+#define CPPGC_PLUGIN_IGNORE(bug_or_reason)           \
+  __attribute__((annotate("blink_gc_plugin_ignore"), \
+                 annotate("stack_allocated_ignore")))
+
 #else  // !defined(__clang__)
+
 #define CPPGC_STACK_ALLOCATED() static_assert(true, "Force semicolon.")
 #define CPPGC_STACK_ALLOCATED_IGNORE(bug_or_reason)
+#define CPPGC_PLUGIN_IGNORE(bug_or_reason)
+
 #endif  // !defined(__clang__)
 
+template <typename T>
+concept IsStackAllocatedType =
+    requires { typename T::IsStackAllocatedTypeMarker; };
+
 }  // namespace cppgc
 
 #endif  // INCLUDE_CPPGC_MACROS_H_