node-linux-arm64 23.10.0 → 24.0.0

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_

package/include/node/cppgc/member.h

@@ -38,9 +38,8 @@ class V8_TRIVIAL_ABI MemberBase {
 
   V8_INLINE MemberBase() = default;
   V8_INLINE explicit MemberBase(const void* value) : raw_(value) {}
-  V8_INLINE MemberBase(const void* value, AtomicInitializerTag) {
-    SetRawAtomic(value);
-  }
+  V8_INLINE MemberBase(const void* value, AtomicInitializerTag)
+      : raw_(value, typename RawStorage::AtomicInitializerTag{}) {}
 
   V8_INLINE explicit MemberBase(RawStorage raw) : raw_(raw) {}
   V8_INLINE explicit MemberBase(std::nullptr_t) : raw_(nullptr) {}
@@ -87,7 +86,7 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
   V8_INLINE BasicMember(SentinelPointer s) : Base(s) {}  // NOLINT
   V8_INLINE BasicMember(T* raw) : Base(raw) {            // NOLINT
     InitializingWriteBarrier(raw);
-    this->CheckPointer(Get());
+    CheckPointer(raw);
   }
   V8_INLINE BasicMember(T& raw)  // NOLINT
       : BasicMember(&raw) {}
@@ -103,7 +102,7 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
   V8_INLINE BasicMember(T* raw, AtomicInitializerTag atomic)
       : Base(raw, atomic) {
     InitializingWriteBarrier(raw);
-    this->CheckPointer(Get());
+    CheckPointer(raw);
   }
   V8_INLINE BasicMember(T& raw, AtomicInitializerTag atomic)
       : BasicMember(&raw, atomic) {}
@@ -117,7 +116,7 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
   // need to be adjusted.
   template <typename U, typename OtherBarrierPolicy, typename OtherWeaknessTag,
             typename OtherCheckingPolicy,
-            std::enable_if_t<internal::IsDecayedSameV<T, U>>* = nullptr>
+            std::enable_if_t<IsDecayedSameV<T, U>>* = nullptr>
   V8_INLINE BasicMember(  // NOLINT
       const BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
                         OtherCheckingPolicy, StorageType>& other)
@@ -125,7 +124,7 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
 
   template <typename U, typename OtherBarrierPolicy, typename OtherWeaknessTag,
             typename OtherCheckingPolicy,
-            std::enable_if_t<internal::IsStrictlyBaseOfV<T, U>>* = nullptr>
+            std::enable_if_t<IsStrictlyBaseOfV<T, U>>* = nullptr>
   V8_INLINE BasicMember(  // NOLINT
       const BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
                         OtherCheckingPolicy, StorageType>& other)
@@ -142,7 +141,7 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
   // need to be adjusted.
   template <typename U, typename OtherBarrierPolicy, typename OtherWeaknessTag,
             typename OtherCheckingPolicy,
-            std::enable_if_t<internal::IsDecayedSameV<T, U>>* = nullptr>
+            std::enable_if_t<IsDecayedSameV<T, U>>* = nullptr>
   V8_INLINE BasicMember(
       BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy, OtherCheckingPolicy,
                   StorageType>&& other) noexcept
@@ -152,7 +151,7 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
 
   template <typename U, typename OtherBarrierPolicy, typename OtherWeaknessTag,
             typename OtherCheckingPolicy,
-            std::enable_if_t<internal::IsStrictlyBaseOfV<T, U>>* = nullptr>
+            std::enable_if_t<IsStrictlyBaseOfV<T, U>>* = nullptr>
   V8_INLINE BasicMember(
       BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy, OtherCheckingPolicy,
                   StorageType>&& other) noexcept
@@ -183,10 +182,10 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
   V8_INLINE BasicMember& operator=(
       const BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
                         OtherCheckingPolicy, StorageType>& other) {
-    if constexpr (internal::IsDecayedSameV<T, U>) {
+    if constexpr (IsDecayedSameV<T, U>) {
       return operator=(other.GetRawStorage());
     } else {
-      static_assert(internal::IsStrictlyBaseOfV<T, U>);
+      static_assert(IsStrictlyBaseOfV<T, U>);
       return operator=(other.Get());
     }
   }
@@ -206,10 +205,10 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
   V8_INLINE BasicMember& operator=(
       BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy, OtherCheckingPolicy,
                   StorageType>&& other) noexcept {
-    if constexpr (internal::IsDecayedSameV<T, U>) {
+    if constexpr (IsDecayedSameV<T, U>) {
       operator=(other.GetRawStorage());
     } else {
-      static_assert(internal::IsStrictlyBaseOfV<T, U>);
+      static_assert(IsStrictlyBaseOfV<T, U>);
       operator=(other.Get());
     }
     other.Clear();
@@ -231,7 +230,7 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
   V8_INLINE BasicMember& operator=(T* other) {
     Base::SetRawAtomic(other);
     AssigningWriteBarrier(other);
-    this->CheckPointer(Get());
+    CheckPointer(other);
     return *this;
   }
 
@@ -270,9 +269,7 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
     return static_cast<T*>(const_cast<void*>(Base::GetRaw()));
   }
 
-  V8_INLINE void Clear() {
-    Base::SetRawStorageAtomic(RawStorage{});
-  }
+  V8_INLINE void Clear() { Base::SetRawStorageAtomic(RawStorage{}); }
 
   V8_INLINE T* Release() {
     T* result = Get();
@@ -284,20 +281,18 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
     return reinterpret_cast<const T**>(Base::GetRawSlot());
   }
 
-  V8_INLINE RawStorage GetRawStorage() const {
-    return Base::GetRawStorage();
-  }
+  V8_INLINE RawStorage GetRawStorage() const { return Base::GetRawStorage(); }
 
  private:
   V8_INLINE explicit BasicMember(RawStorage raw) : Base(raw) {
-    InitializingWriteBarrier(Get());
-    this->CheckPointer(Get());
+    InitializingWriteBarrier();
+    CheckPointer();
   }
 
   V8_INLINE BasicMember& operator=(RawStorage other) {
     Base::SetRawStorageAtomic(other);
     AssigningWriteBarrier();
-    this->CheckPointer(Get());
+    CheckPointer();
     return *this;
   }
 
@@ -308,6 +303,10 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
   V8_INLINE void InitializingWriteBarrier(T* value) const {
     WriteBarrierPolicy::InitializingBarrier(Base::GetRawSlot(), value);
   }
+  V8_INLINE void InitializingWriteBarrier() const {
+    WriteBarrierPolicy::InitializingBarrier(Base::GetRawSlot(),
+                                            Base::GetRawStorage());
+  }
   V8_INLINE void AssigningWriteBarrier(T* value) const {
     WriteBarrierPolicy::template AssigningBarrier<
         StorageType::kWriteBarrierSlotType>(Base::GetRawSlot(), value);
@@ -317,6 +316,12 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
         StorageType::kWriteBarrierSlotType>(Base::GetRawSlot(),
                                             Base::GetRawStorage());
   }
+  V8_INLINE void CheckPointer(T* value) {
+    CheckingPolicy::template CheckPointer<T>(value);
+  }
+  V8_INLINE void CheckPointer() {
+    CheckingPolicy::template CheckPointer<T>(Base::GetRawStorage());
+  }
 
   V8_INLINE void ClearFromGC() const { Base::ClearFromGC(); }
 
@@ -341,12 +346,11 @@ V8_INLINE bool operator==(
                       StorageType>& member1,
     const BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2, CheckingPolicy2,
                       StorageType>& member2) {
-  if constexpr (internal::IsDecayedSameV<T1, T2>) {
+  if constexpr (IsDecayedSameV<T1, T2>) {
     // Check compressed pointers if types are the same.
     return member1.GetRawStorage() == member2.GetRawStorage();
   } else {
-    static_assert(internal::IsStrictlyBaseOfV<T1, T2> ||
-                  internal::IsStrictlyBaseOfV<T2, T1>);
+    static_assert(IsStrictlyBaseOfV<T1, T2> || IsStrictlyBaseOfV<T2, T1>);
     // Otherwise, check decompressed pointers.
     return member1.Get() == member2.Get();
   }
@@ -372,12 +376,12 @@ V8_INLINE bool operator==(
                       StorageType>& member,
     U* raw) {
   // Never allow comparison with erased pointers.
-  static_assert(!internal::IsDecayedSameV<void, U>);
+  static_assert(!IsDecayedSameV<void, U>);
 
-  if constexpr (internal::IsDecayedSameV<T, U>) {
+  if constexpr (IsDecayedSameV<T, U>) {
     // Check compressed pointers if types are the same.
     return member.GetRawStorage() == StorageType(raw);
-  } else if constexpr (internal::IsStrictlyBaseOfV<T, U>) {
+  } else if constexpr (IsStrictlyBaseOfV<T, U>) {
     // Cast the raw pointer to T, which may adjust the pointer.
     return member.GetRawStorage() == StorageType(static_cast<T*>(raw));
   } else {
@@ -494,7 +498,7 @@ V8_INLINE bool operator<(
     const BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2, CheckingPolicy2,
                       StorageType>& member2) {
   static_assert(
-      internal::IsDecayedSameV<T1, T2>,
+      IsDecayedSameV<T1, T2>,
       "Comparison works only for same pointer type modulo cv-qualifiers");
   return member1.GetRawStorage() < member2.GetRawStorage();
 }
@@ -509,7 +513,7 @@ V8_INLINE bool operator<=(
     const BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2, CheckingPolicy2,
                       StorageType>& member2) {
   static_assert(
-      internal::IsDecayedSameV<T1, T2>,
+      IsDecayedSameV<T1, T2>,
       "Comparison works only for same pointer type modulo cv-qualifiers");
   return member1.GetRawStorage() <= member2.GetRawStorage();
 }
@@ -524,7 +528,7 @@ V8_INLINE bool operator>(
     const BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2, CheckingPolicy2,
                       StorageType>& member2) {
   static_assert(
-      internal::IsDecayedSameV<T1, T2>,
+      IsDecayedSameV<T1, T2>,
       "Comparison works only for same pointer type modulo cv-qualifiers");
   return member1.GetRawStorage() > member2.GetRawStorage();
 }
@@ -539,16 +543,15 @@ V8_INLINE bool operator>=(
     const BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2, CheckingPolicy2,
                       StorageType>& member2) {
   static_assert(
-      internal::IsDecayedSameV<T1, T2>,
+      IsDecayedSameV<T1, T2>,
       "Comparison works only for same pointer type modulo cv-qualifiers");
   return member1.GetRawStorage() >= member2.GetRawStorage();
 }
 
 template <typename T, typename WriteBarrierPolicy, typename CheckingPolicy,
           typename StorageType>
-struct IsWeak<internal::BasicMember<T, WeakMemberTag, WriteBarrierPolicy,
-                                    CheckingPolicy, StorageType>>
-    : std::true_type {};
+struct IsWeak<BasicMember<T, WeakMemberTag, WriteBarrierPolicy, CheckingPolicy,
+                          StorageType>> : std::true_type {};
 
 }  // namespace internal
 
@@ -626,4 +629,35 @@ static constexpr size_t kSizeofCompressedMember =
 
 }  // namespace cppgc
 
+// Mark `BasicMember<T>` and `T*` as having a common reference type of `T*` (the
+// type to which both can be converted or bound). This makes them satisfy
+// `std::equality_comparable`, which allows usage like the following:
+// ```
+//   HeapVector<Member<T>> v;
+//   T* e;
+//   auto it = std::ranges::find(v, e);
+// ```
+// Without this, the `find()` call above would fail to compile with an error
+// about being unable to invoke `std::ranges::equal_to()`.
+template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
+          typename CheckingPolicy, typename StorageType,
+          template <typename> typename TQ, template <typename> typename UQ>
+struct std::basic_common_reference<
+    cppgc::internal::BasicMember<T, WeaknessTag, WriteBarrierPolicy,
+                                 CheckingPolicy, StorageType>,
+    T*, TQ, UQ> {
+  using type = T*;
+};
+
+template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
+          typename CheckingPolicy, typename StorageType,
+          template <typename> typename TQ, template <typename> typename UQ>
+struct std::basic_common_reference<
+    T*,
+    cppgc::internal::BasicMember<T, WeaknessTag, WriteBarrierPolicy,
+                                 CheckingPolicy, StorageType>,
+    TQ, UQ> {
+  using type = T*;
+};
+
 #endif  // INCLUDE_CPPGC_MEMBER_H_

package/include/node/cppgc/name-provider.h

@@ -55,6 +55,9 @@ class V8_EXPORT NameProvider {
    * Specifies a name for the garbage-collected object. Such names will never
    * be hidden, as they are explicitly specified by the user of this API.
    *
+   * Implementations of this function must not allocate garbage-collected
+   * objects or otherwise modify the cppgc heap.
+   *
    * V8 may call this function while generating a heap snapshot or at other
    * times. If V8 is currently generating a heap snapshot (according to
    * HeapProfiler::IsTakingSnapshot), then the returned string must stay alive

package/include/node/cppgc/platform.h

@@ -52,6 +52,15 @@ class V8_EXPORT Platform {
    * Foreground task runner that should be used by a Heap.
    */
   virtual std::shared_ptr<TaskRunner> GetForegroundTaskRunner() {
+    return GetForegroundTaskRunner(TaskPriority::kUserBlocking);
+  }
+
+  /**
+   * Returns a TaskRunner with a specific |priority| which can be used to post a
+   * task on the foreground thread.
+   */
+  virtual std::shared_ptr<TaskRunner> GetForegroundTaskRunner(
+      TaskPriority priority) {
     return nullptr;
   }
 
@@ -127,6 +136,8 @@ class V8_EXPORT Platform {
   virtual TracingController* GetTracingController();
 };
 
+V8_EXPORT bool IsInitialized();
+
 /**
  * Process-global initialization of the garbage collector. Must be called before
  * creating a Heap.

package/include/node/cppgc/type-traits.h

@@ -9,6 +9,7 @@
 // against Oilpan types without including any other parts.
 #include <cstddef>
 #include <type_traits>
+#include <utility>
 
 namespace cppgc {
 

package/include/node/cppgc/visitor.h

@@ -8,12 +8,12 @@
 #include <type_traits>
 
 #include "cppgc/custom-space.h"
-#include "cppgc/ephemeron-pair.h"
 #include "cppgc/garbage-collected.h"
 #include "cppgc/internal/logging.h"
 #include "cppgc/internal/member-storage.h"
 #include "cppgc/internal/pointer-policies.h"
 #include "cppgc/liveness-broker.h"
+#include "cppgc/macros.h"
 #include "cppgc/member.h"
 #include "cppgc/sentinel-pointer.h"
 #include "cppgc/source-location.h"
@@ -36,6 +36,25 @@ class VisitorFactory;
 
 using WeakCallback = void (*)(const LivenessBroker&, const void*);
 
+/**
+ * An ephemeron pair is used to conditionally retain an object.
+ * The `value` will be kept alive only if the `key` is alive.
+ */
+template <typename K, typename V>
+struct EphemeronPair {
+  CPPGC_DISALLOW_NEW();
+
+  EphemeronPair(K* k, V* v) : key(k), value(v) {}
+  WeakMember<K> key;
+  Member<V> value;
+
+  void ClearValueIfKeyIsDead(const LivenessBroker& broker) {
+    if (!broker.IsHeapObjectAlive(key)) value = nullptr;
+  }
+
+  void Trace(Visitor* visitor) const;
+};
+
 /**
  * Visitor passed to trace methods. All managed pointers must have called the
  * Visitor's trace method on them.
@@ -436,6 +455,11 @@ class V8_EXPORT Visitor {
   friend class internal::VisitorBase;
 };
 
+template <typename K, typename V>
+void EphemeronPair<K, V>::Trace(Visitor* visitor) const {
+  visitor->TraceEphemeron(key, value);
+}
+
 namespace internal {
 
 class V8_EXPORT RootVisitor {

package/include/node/libplatform/libplatform-export.h

@@ -18,11 +18,11 @@
 #else  // defined(_WIN32)
 
 // Setup for Linux shared library export.
-#ifdef BUILDING_V8_PLATFORM_SHARED
+#if defined(BUILDING_V8_PLATFORM_SHARED) || USING_V8_PLATFORM_SHARED
 #define V8_PLATFORM_EXPORT __attribute__((visibility("default")))
 #else
 #define V8_PLATFORM_EXPORT
-#endif
+#endif  // defined(BUILDING_V8_PLATFORM_SHARED) || ...
 
 #endif  // defined(_WIN32)
 

package/include/node/libplatform/v8-tracing.h

@@ -6,7 +6,6 @@
 #define V8_LIBPLATFORM_V8_TRACING_H_
 
 #include <atomic>
-#include <fstream>
 #include <memory>
 #include <unordered_set>
 #include <vector>

package/include/node/node.h

@@ -67,7 +67,8 @@
 #endif
 
 #ifdef _WIN32
-# define SIGKILL 9
+#define SIGQUIT 3
+#define SIGKILL 9
 #endif
 
 #include "v8.h"  // NOLINT(build/include_order)
@@ -374,10 +375,6 @@ enum OptionEnvvarSettings {
   // Disallow the options to be set via the environment variable, like
   // `NODE_OPTIONS`.
   kDisallowedInEnvvar = 1,
-  // Deprecated, use kAllowedInEnvvar instead.
-  kAllowedInEnvironment = kAllowedInEnvvar,
-  // Deprecated, use kDisallowedInEnvvar instead.
-  kDisallowedInEnvironment = kDisallowedInEnvvar,
 };
 
 // Process the arguments and set up the per-process options.
@@ -450,8 +447,11 @@ class NODE_EXTERN MultiIsolatePlatform : public v8::Platform {
 
   // This function may only be called once per `Isolate`, and discard any
   // pending delayed tasks scheduled for that isolate.
-  // This needs to be called right before calling `Isolate::Dispose()`.
+  // This needs to be called right after calling `Isolate::Dispose()`.
   virtual void UnregisterIsolate(v8::Isolate* isolate) = 0;
+  // This disposes, unregisters and frees up an isolate that's allocated using
+  // v8::Isolate::Allocate() in the correct order to prevent race conditions.
+  void DisposeIsolate(v8::Isolate* isolate);
 
   // The platform should call the passed function once all state associated
   // with the given isolate has been cleaned up. This can, but does not have to,
@@ -492,6 +492,21 @@ struct IsolateSettings {
       allow_wasm_code_generation_callback = nullptr;
   v8::ModifyCodeGenerationFromStringsCallback2
       modify_code_generation_from_strings_callback = nullptr;
+
+  // When the settings is passed to NewIsolate():
+  // - If cpp_heap is not nullptr, this CppHeap will be used to create
+  //   the isolate and its ownership will be passed to V8.
+  // - If this is nullptr, Node.js will create a CppHeap that will be
+  //   owned by V8.
+  //
+  // When the settings is passed to SetIsolateUpForNode():
+  // cpp_heap will be ignored. Embedders must ensure that the
+  // v8::Isolate has a CppHeap attached while it's still used by
+  // Node.js, for example using v8::CreateParams.
+  //
+  // See https://issues.chromium.org/issues/42203693. In future version
+  // of V8, this CppHeap will be created by V8 if not provided.
+  v8::CppHeap* cpp_heap = nullptr;
 };
 
 // Represents a startup snapshot blob, e.g. created by passing
@@ -546,8 +561,8 @@ class EmbedderSnapshotData {
   void ToFile(FILE* out) const;
   std::vector<char> ToBlob() const;
 
-  // Returns whether custom snapshots can be used. Currently, this means
-  // that V8 was configured without the shared-readonly-heap feature.
+  // Returns whether custom snapshots can be used. Currently, this always
+  // returns false since V8 enforces shared readonly-heap.
   static bool CanUseCustomSnapshotPerIsolate();
 
   EmbedderSnapshotData(const EmbedderSnapshotData&) = delete;
@@ -1127,16 +1142,37 @@ NODE_EXTERN enum encoding ParseEncoding(
 NODE_EXTERN void FatalException(v8::Isolate* isolate,
                                 const v8::TryCatch& try_catch);
 
-NODE_EXTERN v8::Local<v8::Value> Encode(v8::Isolate* isolate,
-                                        const char* buf,
-                                        size_t len,
-                                        enum encoding encoding = LATIN1);
+NODE_EXTERN v8::MaybeLocal<v8::Value> TryEncode(
+    v8::Isolate* isolate,
+    const char* buf,
+    size_t len,
+    enum encoding encoding = LATIN1);
 
 // Warning: This reverses endianness on Big Endian platforms, even though the
 // signature using uint16_t implies that it should not.
-NODE_EXTERN v8::Local<v8::Value> Encode(v8::Isolate* isolate,
-                                        const uint16_t* buf,
-                                        size_t len);
+NODE_EXTERN v8::MaybeLocal<v8::Value> TryEncode(v8::Isolate* isolate,
+                                                const uint16_t* buf,
+                                                size_t len);
+
+// The original Encode(...) functions are deprecated because they do not
+// appropriately propagate exceptions and instead rely on ToLocalChecked()
+// which crashes the process if an exception occurs. We cannot just remove
+// these as it would break ABI compatibility, so we keep them around but
+// deprecate them in favor of the TryEncode(...) variations which return
+// a MaybeLocal<> and do not crash the process if an exception occurs.
+NODE_DEPRECATED(
+    "Use TryEncode(...) instead",
+    NODE_EXTERN v8::Local<v8::Value> Encode(v8::Isolate* isolate,
+                                            const char* buf,
+                                            size_t len,
+                                            enum encoding encoding = LATIN1));
+
+// Warning: This reverses endianness on Big Endian platforms, even though the
+// signature using uint16_t implies that it should not.
+NODE_DEPRECATED("Use TryEncode(...) instead",
+                NODE_EXTERN v8::Local<v8::Value> Encode(v8::Isolate* isolate,
+                                                        const uint16_t* buf,
+                                                        size_t len));
 
 // Returns -1 if the handle was not valid for decoding
 NODE_EXTERN ssize_t DecodeBytes(v8::Isolate* isolate,
@@ -1386,6 +1422,12 @@ NODE_EXTERN void RequestInterrupt(Environment* env,
  * I/O from native code. */
 NODE_EXTERN async_id AsyncHooksGetExecutionAsyncId(v8::Isolate* isolate);
 
+/* Returns the id of the current execution context. If the return value is
+ * zero then no execution has been set. This will happen if the user handles
+ * I/O from native code. */
+NODE_EXTERN async_id
+AsyncHooksGetExecutionAsyncId(v8::Local<v8::Context> context);
+
 /* Return same value as async_hooks.triggerAsyncId(); */
 NODE_EXTERN async_id AsyncHooksGetTriggerAsyncId(v8::Isolate* isolate);
 
@@ -1529,6 +1571,7 @@ class NODE_EXTERN AsyncResource {
  private:
   Environment* env_;
   v8::Global<v8::Object> resource_;
+  v8::Global<v8::Value> context_frame_;
   async_context async_context_;
 };