node-linux-s390x 23.11.0 → 24.0.0

package/LICENSE

@@ -1489,7 +1489,7 @@ The externally maintained libraries used by Node.js are:
         This code is copyrighted by Sun Microsystems Inc. and released
         under a 3-clause BSD license.
 
-      - Valgrind client API header, located at src/third_party/valgrind/valgrind.h
+      - Valgrind client API header, located at third_party/valgrind/valgrind.h
         This is released under the BSD license.
 
       - The Wasm C/C++ API headers, located at third_party/wasm-api/wasm.{h,hh}
@@ -1774,7 +1774,7 @@ The externally maintained libraries used by Node.js are:
        limitations under the License.
   """
 
-- simdutf, located at deps/simdutf, is licensed as follows:
+- simdutf, located at deps/v8/third_party/simdutf, is licensed as follows:
   """
     Copyright 2021 The simdutf authors
 

package/README.md

@@ -317,6 +317,8 @@ For information about the governance of the Node.js project, see
   **Kohei Ueno** <<kohei.ueno119@gmail.com>> (he/him)
 * [daeyeon](https://github.com/daeyeon) -
   **Daeyeon Jeong** <<daeyeon.dev@gmail.com>> (he/him)
+* [dario-piotrowicz](https://github.com/dario-piotrowicz) -
+  **Dario Piotrowicz** <<dario.piotrowicz@gmail.com>> (he/him)
 * [debadree25](https://github.com/debadree25) -
   **Debadree Chatterjee** <<debadree333@gmail.com>> (he/him)
 * [deokjinkim](https://github.com/deokjinkim) -

package/include/node/common.gypi

@@ -38,7 +38,7 @@
 
     # Reset this number to 0 on major V8 upgrades.
     # Increment by one for each non-official patch applied to deps/v8.
-    'v8_embedder_string': '-node.14',
+    'v8_embedder_string': '-node.10',
 
     ##### V8 defaults for Node.js #####
 
@@ -112,7 +112,7 @@
         'v8_base': '<(PRODUCT_DIR)/libv8_snapshot.a',
       }],
       # V8 pointer compression only supports 64bit architectures.
-      ['target_arch in "arm ia32 mips mipsel ppc"', {
+      ['target_arch in "arm ia32 mips mipsel"', {
         'v8_enable_pointer_compression': 0,
         'v8_enable_31bit_smis_on_64bit_arch': 0,
         'v8_enable_sandbox': 0
@@ -528,10 +528,6 @@
                 'cflags': [ '-m64' ],
                 'ldflags': [ '-m64' ],
               }],
-              [ 'host_arch=="ppc" and OS not in "aix os400"', {
-                'cflags': [ '-m32' ],
-                'ldflags': [ '-m32' ],
-              }],
               [ 'host_arch=="ppc64" and OS not in "aix os400"', {
                 'cflags': [ '-m64', '-mminimal-toc' ],
                 'ldflags': [ '-m64' ],
@@ -552,10 +548,6 @@
                 'cflags': [ '-m64' ],
                 'ldflags': [ '-m64' ],
               }],
-              [ 'target_arch=="ppc" and OS not in "aix os400"', {
-                'cflags': [ '-m32' ],
-                'ldflags': [ '-m32' ],
-              }],
               [ 'target_arch=="ppc64" and OS not in "aix os400"', {
                 'cflags': [ '-m64', '-mminimal-toc' ],
                 'ldflags': [ '-m64' ],
@@ -576,6 +568,7 @@
           }],
           [ 'node_shared=="true"', {
             'cflags': [ '-fPIC' ],
+            'ldflags': [ '-fPIC' ],
           }],
         ],
       }],
@@ -639,7 +632,7 @@
           'GCC_ENABLE_PASCAL_STRINGS': 'NO',        # No -mpascal-strings
           'GCC_STRICT_ALIASING': 'NO',              # -fno-strict-aliasing
           'PREBINDING': 'NO',                       # No -Wl,-prebind
-          'MACOSX_DEPLOYMENT_TARGET': '11.0',       # -mmacosx-version-min=11.0
+          'MACOSX_DEPLOYMENT_TARGET': '13.5',       # -mmacosx-version-min=13.5
           'USE_HEADERMAP': 'NO',
           'WARNING_CFLAGS': [
             '-Wall',

package/include/node/config.gypi

@@ -20,12 +20,12 @@
                  'force_dynamic_crt': 0,
                  'gas_version': '2.38',
                  'host_arch': 's390x',
-                 'icu_data_in': '../../deps/icu-tmp/icudt76l.dat',
+                 'icu_data_in': '../../deps/icu-tmp/icudt77l.dat',
                  'icu_endianness': 'b',
                  'icu_gyp_path': 'tools/icu/icu-generic.gyp',
                  'icu_path': 'deps/icu-small',
                  'icu_small': 'false',
-                 'icu_ver_major': '76',
+                 'icu_ver_major': '77',
                  'libdir': 'lib',
                  'llvm_version': '0.0',
                  'napi_build_version': '10',
@@ -330,7 +330,6 @@
                                          'lib/internal/test_runner/utils.js',
                                          'lib/internal/timers.js',
                                          'lib/internal/tls/secure-context.js',
-                                         'lib/internal/tls/secure-pair.js',
                                          'lib/internal/trace_events_async_hooks.js',
                                          'lib/internal/tty.js',
                                          'lib/internal/url.js',
@@ -405,7 +404,7 @@
                                          'lib/wasi.js',
                                          'lib/worker_threads.js',
                                          'lib/zlib.js'],
-                 'node_module_version': 131,
+                 'node_module_version': 137,
                  'node_no_browser_globals': 'false',
                  'node_prefix': '/',
                  'node_quic': 'false',
@@ -441,7 +440,7 @@
                  'openssl_is_fips': 'false',
                  'openssl_quic': 'false',
                  'ossfuzz': 'false',
-                 'shlib_suffix': 'so.131',
+                 'shlib_suffix': 'so.137',
                  'single_executable_application': 'true',
                  'suppress_all_error_on_warn': 'false',
                  'target_arch': 's390x',
@@ -460,7 +459,6 @@
                  'v8_enable_object_print': 1,
                  'v8_enable_pointer_compression': 0,
                  'v8_enable_sandbox': 0,
-                 'v8_enable_shared_ro_heap': 1,
                  'v8_enable_webassembly': 1,
                  'v8_optimized_debug': 1,
                  'v8_promise_internal_field_count': 1,

package/include/node/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:

package/include/node/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(

package/include/node/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,

package/include/node/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)
 

package/include/node/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_;

package/include/node/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;

package/include/node/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_);

package/include/node/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_

package/include/node/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)
 

package/include/node/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

package/include/node/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

package/include/node/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.

package/include/node/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_