libv8-node 20.12.1.0-arm64-darwin → 21.7.2.0-arm64-darwin

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dda399fffad297a8a3a2bba429874e95e94693f1541549f311c13ceb2a96d525
-  data.tar.gz: 473244fdd30decefd0c5b918bd98e8900eecb991ee1cf254fa046cee79c2d7eb
+  metadata.gz: aa63687255404f025cf453ac2987406f98ec6cdc3218bde612e0659382d7290f
+  data.tar.gz: 848f8250e6d0e889426722e5c535806070240b3de1f0d30a99f514f828f80a8a
 SHA512:
-  metadata.gz: cb66566366e294b6a7cf0e3dc5a94631869cbceea21f42f5b6f02be94ada6dcffa3ccba9d9cbd119b01fca54ea6ec6e9765a288999404ce0869e9765386f22db
-  data.tar.gz: 1d7fd89a9ea00264dc87cd07074245da7409e275eae5eb4a6ff11d018c3b517480b3e71ef2121a8b1be9508d1ef00bc4961f8f75f5f9d6324487967e208a512f
+  metadata.gz: cbd77e21fcc48789ff9392ec223d2236eed9824e8beb02dcc79cc7e89b54ea3fc76076aef3c4a6c45607239b918e807a99db8bc8e256c97ec3df69fbe48dd161
+  data.tar.gz: fa5bb07d040c1b8ea6ef81395d51a417180f3cf688c54c3f01c7c8e8599bae3cfbfbd117433235e0d4e8c98bef14ea69f791d566f6e0c7d2ef5a8e72ff143c10

data/lib/libv8/node/version.rb

@@ -1,7 +1,7 @@
 module Libv8; end
 
 module Libv8::Node
-  VERSION = '20.12.1.0'.freeze
-  NODE_VERSION = '20.12.1'.freeze
-  LIBV8_VERSION = '11.3.244.8'.freeze # from v8/include/v8-version.h
+  VERSION = '21.7.2.0'.freeze
+  NODE_VERSION = '21.7.2'.freeze
+  LIBV8_VERSION = '11.8.172.17'.freeze # from v8/include/v8-version.h
 end

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

@@ -40,13 +40,32 @@ constexpr size_t kGuardPageSize = 4096;
 
 static constexpr size_t kLargeObjectSizeThreshold = kPageSize / 2;
 
+#if defined(CPPGC_POINTER_COMPRESSION)
+#if defined(CPPGC_ENABLE_LARGER_CAGE)
+constexpr unsigned kPointerCompressionShift = 3;
+#else   // !defined(CPPGC_ENABLE_LARGER_CAGE)
+constexpr unsigned kPointerCompressionShift = 1;
+#endif  // !defined(CPPGC_ENABLE_LARGER_CAGE)
+#endif  // !defined(CPPGC_POINTER_COMPRESSION)
+
 #if defined(CPPGC_CAGED_HEAP)
 #if defined(CPPGC_2GB_CAGE)
-constexpr size_t kCagedHeapReservationSize = static_cast<size_t>(2) * kGB;
-#else   // !defined(CPPGC_2GB_CAGE)
-constexpr size_t kCagedHeapReservationSize = static_cast<size_t>(4) * kGB;
+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)
+constexpr size_t kCagedHeapMaxReservationSize =
+    size_t{1} << (31 + kPointerCompressionShift);
+#else   // !defined(CPPGC_POINTER_COMPRESSION)
+constexpr size_t kCagedHeapMaxReservationSize =
+    kCagedHeapDefaultReservationSize;
+#endif  // !defined(CPPGC_POINTER_COMPRESSION)
 #endif  // !defined(CPPGC_2GB_CAGE)
-constexpr size_t kCagedHeapReservationAlignment = kCagedHeapReservationSize;
+constexpr size_t kCagedHeapReservationAlignment = kCagedHeapMaxReservationSize;
 #endif  // defined(CPPGC_CAGED_HEAP)
 
 static constexpr size_t kDefaultAlignment = sizeof(void*);

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

@@ -46,7 +46,11 @@ class V8_EXPORT AgeTable final {
   enum class AdjacentCardsPolicy : uint8_t { kConsider, kIgnore };
 
   static constexpr size_t kCardSizeInBytes =
-      api_constants::kCagedHeapReservationSize / kRequiredSize;
+      api_constants::kCagedHeapDefaultReservationSize / kRequiredSize;
+
+  static constexpr size_t CalculateAgeTableSizeForHeapSize(size_t heap_size) {
+    return heap_size / kCardSizeInBytes;
+  }
 
   void SetAge(uintptr_t cage_offset, Age age) {
     table_[card(cage_offset)] = age;
@@ -81,16 +85,18 @@ class V8_EXPORT AgeTable final {
 #endif  // !V8_HAS_BUILTIN_CTZ
     static_assert((1 << kGranularityBits) == kCardSizeInBytes);
     const size_t entry = offset >> kGranularityBits;
-    CPPGC_DCHECK(table_.size() > entry);
+    CPPGC_DCHECK(CagedHeapBase::GetAgeTableSize() > entry);
     return entry;
   }
 
-  std::array<Age, kRequiredSize> table_;
+#if defined(V8_CC_GNU)
+  // gcc disallows flexible arrays in otherwise empty classes.
+  Age table_[0];
+#else   // !defined(V8_CC_GNU)
+  Age table_[];
+#endif  // !defined(V8_CC_GNU)
 };
 
-static_assert(sizeof(AgeTable) == 1 * api_constants::kMB,
-              "Size of AgeTable is 1MB");
-
 #endif  // CPPGC_YOUNG_GENERATION
 
 struct CagedHeapLocalData final {
@@ -98,6 +104,10 @@ struct CagedHeapLocalData final {
     return *reinterpret_cast<CagedHeapLocalData*>(CagedHeapBase::GetBase());
   }
 
+  static constexpr size_t CalculateLocalDataSizeForHeapSize(size_t heap_size) {
+    return AgeTable::CalculateAgeTableSizeForHeapSize(heap_size);
+  }
+
 #if defined(CPPGC_YOUNG_GENERATION)
   AgeTable age_table;
 #endif

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

@@ -33,24 +33,31 @@ class V8_EXPORT CagedHeapBase {
 
   V8_INLINE static bool AreWithinCage(const void* addr1, const void* addr2) {
 #if defined(CPPGC_2GB_CAGE)
-    static constexpr size_t kHalfWordShift = sizeof(uint32_t) * CHAR_BIT - 1;
+    static constexpr size_t kHeapBaseShift = sizeof(uint32_t) * CHAR_BIT - 1;
 #else   //! defined(CPPGC_2GB_CAGE)
-    static constexpr size_t kHalfWordShift = sizeof(uint32_t) * CHAR_BIT;
+#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) << kHalfWordShift) ==
-                  api_constants::kCagedHeapReservationSize);
+    static_assert((static_cast<size_t>(1) << kHeapBaseShift) ==
+                  api_constants::kCagedHeapMaxReservationSize);
     CPPGC_DCHECK(g_heap_base_);
     return !(((reinterpret_cast<uintptr_t>(addr1) ^ g_heap_base_) |
               (reinterpret_cast<uintptr_t>(addr2) ^ g_heap_base_)) >>
-             kHalfWordShift);
+             kHeapBaseShift);
   }
 
   V8_INLINE static uintptr_t GetBase() { return g_heap_base_; }
+  V8_INLINE static size_t GetAgeTableSize() { return g_age_table_size_; }
 
  private:
   friend class CagedHeap;
 
   static uintptr_t g_heap_base_;
+  static size_t g_age_table_size_;
 };
 
 }  // namespace internal

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

@@ -24,89 +24,90 @@ struct V8_EXPORT EnsureGCInfoIndexTrait final {
   // Acquires a new GC info object and updates `registered_index` with the index
   // that identifies that new info accordingly.
   template <typename T>
-  V8_INLINE static void EnsureIndex(
+  V8_INLINE static GCInfoIndex EnsureIndex(
       std::atomic<GCInfoIndex>& registered_index) {
-    EnsureGCInfoIndexTraitDispatch<T>{}(registered_index);
+    return EnsureGCInfoIndexTraitDispatch<T>{}(registered_index);
   }
 
  private:
-  template <typename T, bool = std::is_polymorphic<T>::value,
-            bool = FinalizerTrait<T>::HasFinalizer(),
+  template <typename T, bool = FinalizerTrait<T>::HasFinalizer(),
             bool = NameTrait<T>::HasNonHiddenName()>
   struct EnsureGCInfoIndexTraitDispatch;
 
-  static void V8_PRESERVE_MOST
-  EnsureGCInfoIndexPolymorphic(std::atomic<GCInfoIndex>&, TraceCallback,
-                               FinalizationCallback, NameCallback);
-  static void V8_PRESERVE_MOST EnsureGCInfoIndexPolymorphic(
+  static GCInfoIndex V8_PRESERVE_MOST
+  EnsureGCInfoIndex(std::atomic<GCInfoIndex>&, TraceCallback,
+                    FinalizationCallback, NameCallback);
+  static GCInfoIndex V8_PRESERVE_MOST EnsureGCInfoIndex(
       std::atomic<GCInfoIndex>&, TraceCallback, FinalizationCallback);
-  static void V8_PRESERVE_MOST EnsureGCInfoIndexPolymorphic(
-      std::atomic<GCInfoIndex>&, TraceCallback, NameCallback);
-  static void V8_PRESERVE_MOST
-  EnsureGCInfoIndexPolymorphic(std::atomic<GCInfoIndex>&, TraceCallback);
-  static void V8_PRESERVE_MOST
-  EnsureGCInfoIndexNonPolymorphic(std::atomic<GCInfoIndex>&, TraceCallback,
-                                  FinalizationCallback, NameCallback);
-  static void V8_PRESERVE_MOST EnsureGCInfoIndexNonPolymorphic(
-      std::atomic<GCInfoIndex>&, TraceCallback, FinalizationCallback);
-  static void V8_PRESERVE_MOST EnsureGCInfoIndexNonPolymorphic(
-      std::atomic<GCInfoIndex>&, TraceCallback, NameCallback);
-  static void V8_PRESERVE_MOST
-  EnsureGCInfoIndexNonPolymorphic(std::atomic<GCInfoIndex>&, TraceCallback);
+  static GCInfoIndex V8_PRESERVE_MOST
+  EnsureGCInfoIndex(std::atomic<GCInfoIndex>&, TraceCallback, NameCallback);
+  static GCInfoIndex V8_PRESERVE_MOST
+  EnsureGCInfoIndex(std::atomic<GCInfoIndex>&, TraceCallback);
 };
 
-#define DISPATCH(is_polymorphic, has_finalizer, has_non_hidden_name, function) \
-  template <typename T>                                                        \
-  struct EnsureGCInfoIndexTrait::EnsureGCInfoIndexTraitDispatch<               \
-      T, is_polymorphic, has_finalizer, has_non_hidden_name> {                 \
-    V8_INLINE void operator()(std::atomic<GCInfoIndex>& registered_index) {    \
-      function;                                                                \
-    }                                                                          \
+#define DISPATCH(has_finalizer, has_non_hidden_name, function)   \
+  template <typename T>                                          \
+  struct EnsureGCInfoIndexTrait::EnsureGCInfoIndexTraitDispatch< \
+      T, has_finalizer, has_non_hidden_name> {                   \
+    V8_INLINE GCInfoIndex                                        \
+    operator()(std::atomic<GCInfoIndex>& registered_index) {     \
+      return function;                                           \
+    }                                                            \
   };
 
-// --------------------------------------------------------------------- //
-// DISPATCH(is_polymorphic, has_finalizer, has_non_hidden_name, function)
-// --------------------------------------------------------------------- //
-DISPATCH(true, true, true,                                               //
-         EnsureGCInfoIndexPolymorphic(registered_index,                  //
-                                      TraceTrait<T>::Trace,              //
-                                      FinalizerTrait<T>::kCallback,      //
-                                      NameTrait<T>::GetName))            //
-DISPATCH(true, true, false,                                              //
-         EnsureGCInfoIndexPolymorphic(registered_index,                  //
-                                      TraceTrait<T>::Trace,              //
-                                      FinalizerTrait<T>::kCallback))     //
-DISPATCH(true, false, true,                                              //
-         EnsureGCInfoIndexPolymorphic(registered_index,                  //
-                                      TraceTrait<T>::Trace,              //
-                                      NameTrait<T>::GetName))            //
-DISPATCH(true, false, false,                                             //
-         EnsureGCInfoIndexPolymorphic(registered_index,                  //
-                                      TraceTrait<T>::Trace))             //
-DISPATCH(false, true, true,                                              //
-         EnsureGCInfoIndexNonPolymorphic(registered_index,               //
-                                         TraceTrait<T>::Trace,           //
-                                         FinalizerTrait<T>::kCallback,   //
-                                         NameTrait<T>::GetName))         //
-DISPATCH(false, true, false,                                             //
-         EnsureGCInfoIndexNonPolymorphic(registered_index,               //
-                                         TraceTrait<T>::Trace,           //
-                                         FinalizerTrait<T>::kCallback))  //
-DISPATCH(false, false, true,                                             //
-         EnsureGCInfoIndexNonPolymorphic(registered_index,               //
-                                         TraceTrait<T>::Trace,           //
-                                         NameTrait<T>::GetName))         //
-DISPATCH(false, false, false,                                            //
-         EnsureGCInfoIndexNonPolymorphic(registered_index,               //
-                                         TraceTrait<T>::Trace))          //
+// ------------------------------------------------------- //
+// DISPATCH(has_finalizer, has_non_hidden_name, function)  //
+// ------------------------------------------------------- //
+DISPATCH(true, true,                                       //
+         EnsureGCInfoIndex(registered_index,               //
+                           TraceTrait<T>::Trace,           //
+                           FinalizerTrait<T>::kCallback,   //
+                           NameTrait<T>::GetName))         //
+DISPATCH(true, false,                                      //
+         EnsureGCInfoIndex(registered_index,               //
+                           TraceTrait<T>::Trace,           //
+                           FinalizerTrait<T>::kCallback))  //
+DISPATCH(false, true,                                      //
+         EnsureGCInfoIndex(registered_index,               //
+                           TraceTrait<T>::Trace,           //
+                           NameTrait<T>::GetName))         //
+DISPATCH(false, false,                                     //
+         EnsureGCInfoIndex(registered_index,               //
+                           TraceTrait<T>::Trace))          //
 
 #undef DISPATCH
 
+// Trait determines how the garbage collector treats objects wrt. to traversing,
+// finalization, and naming.
+template <typename T>
+struct GCInfoTrait final {
+  V8_INLINE static GCInfoIndex Index() {
+    static_assert(sizeof(T), "T must be fully defined");
+    static std::atomic<GCInfoIndex>
+        registered_index;  // Uses zero initialization.
+    GCInfoIndex index = registered_index.load(std::memory_order_acquire);
+    if (V8_UNLIKELY(!index)) {
+      index = EnsureGCInfoIndexTrait::EnsureIndex<T>(registered_index);
+      CPPGC_DCHECK(index != 0);
+      CPPGC_DCHECK(index == registered_index.load(std::memory_order_acquire));
+    }
+    return index;
+  }
+
+  static constexpr bool 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;
+  }
+};
+
 // Fold types based on finalizer behavior. Note that finalizer characteristics
 // align with trace behavior, i.e., destructors are virtual when trace methods
 // are and vice versa.
 template <typename T, typename ParentMostGarbageCollectedType>
-struct GCInfoFolding {
+struct GCInfoFolding final {
   static constexpr bool kHasVirtualDestructorAtBase =
       std::has_virtual_destructor<ParentMostGarbageCollectedType>::value;
   static constexpr bool kBothTypesAreTriviallyDestructible =
@@ -121,34 +122,24 @@ struct GCInfoFolding {
   static constexpr bool kWantsDetailedObjectNames = false;
 #endif  // !CPPGC_SUPPORTS_OBJECT_NAMES
 
-  // Folding would regresses 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<(kHasVirtualDestructorAtBase ||
-                                         kBothTypesAreTriviallyDestructible ||
-                                         kHasCustomFinalizerDispatchAtBase) &&
-                                            !kWantsDetailedObjectNames,
-                                        ParentMostGarbageCollectedType, T>;
-};
+  // Always true. Forces the compiler to resolve callbacks which ensures that
+  // both modes don't break without requiring compiling a separate
+  // 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() &&
+      GCInfoTrait<ParentMostGarbageCollectedType>::CheckCallbacksAreDefined();
 
-// Trait determines how the garbage collector treats objects wrt. to traversing,
-// finalization, and naming.
-template <typename T>
-struct GCInfoTrait final {
-  V8_INLINE static GCInfoIndex Index() {
-    static_assert(sizeof(T), "T must be fully defined");
-    static std::atomic<GCInfoIndex>
-        registered_index;  // Uses zero initialization.
-    GCInfoIndex index = registered_index.load(std::memory_order_acquire);
-    if (V8_UNLIKELY(!index)) {
-      EnsureGCInfoIndexTrait::EnsureIndex<T>(registered_index);
-      // Slow path call uses V8_PRESERVE_MOST which does not support return
-      // values (also preserves RAX). Avoid out parameter by just reloading the
-      // value here which at this point is guaranteed to be set.
-      index = registered_index.load(std::memory_order_acquire);
-      CPPGC_DCHECK(index != 0);
-    }
-    return index;
-  }
+  // 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>;
 };
 
 }  // namespace internal

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

@@ -122,17 +122,22 @@ class V8_TRIVIAL_ABI CompressedPointer final {
   }
 
   static V8_INLINE IntegralType Compress(const void* ptr) {
-    static_assert(
-        SentinelPointer::kSentinelValue == 0b10,
-        "The compression scheme relies on the sentinel encoded as 0b10");
+    static_assert(SentinelPointer::kSentinelValue ==
+                      1 << api_constants::kPointerCompressionShift,
+                  "The compression scheme relies on the sentinel encoded as 1 "
+                  "<< kPointerCompressionShift");
     static constexpr size_t kGigaCageMask =
         ~(api_constants::kCagedHeapReservationAlignment - 1);
+    static constexpr size_t kPointerCompressionShiftMask =
+        (1 << api_constants::kPointerCompressionShift) - 1;
 
     CPPGC_DCHECK(CageBaseGlobal::IsSet());
     const uintptr_t base = CageBaseGlobal::Get();
     CPPGC_DCHECK(!ptr || ptr == kSentinelPointer ||
                  (base & kGigaCageMask) ==
                      (reinterpret_cast<uintptr_t>(ptr) & kGigaCageMask));
+    CPPGC_DCHECK(
+        (reinterpret_cast<uintptr_t>(ptr) & kPointerCompressionShiftMask) == 0);
 
 #if defined(CPPGC_2GB_CAGE)
     // Truncate the pointer.
@@ -140,8 +145,9 @@ class V8_TRIVIAL_ABI CompressedPointer final {
         static_cast<IntegralType>(reinterpret_cast<uintptr_t>(ptr));
 #else   // !defined(CPPGC_2GB_CAGE)
     const auto uptr = reinterpret_cast<uintptr_t>(ptr);
-    // Shift the pointer by one and truncate.
-    auto compressed = static_cast<IntegralType>(uptr >> 1);
+    // 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.
     CPPGC_DCHECK((!compressed || compressed == kCompressedSentinel) ||
@@ -157,9 +163,10 @@ class V8_TRIVIAL_ABI CompressedPointer final {
 #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 by one. It's important to shift the unsigned
+    // Then, shift the result. It's 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)) << 1;
+    const uint64_t mask = static_cast<uint64_t>(static_cast<int32_t>(ptr))
+                          << api_constants::kPointerCompressionShift;
 #endif  // !defined(CPPGC_2GB_CAGE)
     return reinterpret_cast<void*>(mask & base);
   }
@@ -170,7 +177,8 @@ class V8_TRIVIAL_ABI CompressedPointer final {
       SentinelPointer::kSentinelValue;
 #else   // !defined(CPPGC_2GB_CAGE)
   static constexpr IntegralType kCompressedSentinel =
-      SentinelPointer::kSentinelValue >> 1;
+      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

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

@@ -597,8 +597,33 @@ using UncompressedMember = internal::BasicMember<
     T, internal::StrongMemberTag, internal::DijkstraWriteBarrierPolicy,
     internal::DefaultMemberCheckingPolicy, internal::RawPointer>;
 
+#if defined(CPPGC_POINTER_COMPRESSION)
+/**
+ * CompressedMember. Default implementation of cppgc::Member on builds with
+ * pointer compression.
+ */
+template <typename T>
+using CompressedMember = internal::BasicMember<
+    T, internal::StrongMemberTag, internal::DijkstraWriteBarrierPolicy,
+    internal::DefaultMemberCheckingPolicy, internal::CompressedPointer>;
+#endif  // defined(CPPGC_POINTER_COMPRESSION)
+
 }  // namespace subtle
 
+namespace internal {
+
+struct Dummy;
+
+static constexpr size_t kSizeOfMember = sizeof(Member<Dummy>);
+static constexpr size_t kSizeOfUncompressedMember =
+    sizeof(subtle::UncompressedMember<Dummy>);
+#if defined(CPPGC_POINTER_COMPRESSION)
+static constexpr size_t kSizeofCompressedMember =
+    sizeof(subtle::CompressedMember<Dummy>);
+#endif  // defined(CPPGC_POINTER_COMPRESSION)
+
+}  // namespace internal
+
 }  // namespace cppgc
 
 #endif  // INCLUDE_CPPGC_MEMBER_H_

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

@@ -92,6 +92,7 @@ class BasicPersistent final : public PersistentBase,
   template <typename U, typename OtherWeaknessPolicy,
             typename OtherLocationPolicy, typename OtherCheckingPolicy,
             typename = std::enable_if_t<std::is_base_of<T, U>::value>>
+  // NOLINTNEXTLINE
   BasicPersistent(
       const BasicPersistent<U, OtherWeaknessPolicy, OtherLocationPolicy,
                             OtherCheckingPolicy>& other,
@@ -116,6 +117,7 @@ class BasicPersistent final : public PersistentBase,
             typename MemberWeaknessTag, typename MemberCheckingPolicy,
             typename MemberStorageType,
             typename = std::enable_if_t<std::is_base_of<T, U>::value>>
+  // NOLINTNEXTLINE
   BasicPersistent(const internal::BasicMember<
                       U, MemberBarrierPolicy, MemberWeaknessTag,
                       MemberCheckingPolicy, MemberStorageType>& member,
@@ -180,6 +182,8 @@ class BasicPersistent final : public PersistentBase,
   }
 
   explicit operator bool() const { return Get(); }
+  // Historically we allow implicit conversions to T*.
+  // NOLINTNEXTLINE
   operator T*() const { return Get(); }
   T* operator->() const { return Get(); }
   T& operator*() const { return *Get(); }

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

@@ -136,8 +136,13 @@ class V8_EXPORT Platform {
  * \param page_allocator The allocator used for maintaining meta data. Must stay
  *   always alive and not change between multiple calls to InitializeProcess. If
  *   no allocator is provided, a default internal version will be used.
+ * \param desired_heap_size Desired amount of virtual address space to reserve
+ *   for the heap, in bytes. Actual size will be clamped to minimum and maximum
+ *   values based on compile-time settings and may be rounded up. If this
+ *   parameter is zero, a default value will be used.
  */
-V8_EXPORT void InitializeProcess(PageAllocator* page_allocator = nullptr);
+V8_EXPORT void InitializeProcess(PageAllocator* page_allocator = nullptr,
+                                 size_t desired_heap_size = 0);
 
 /**
  * Must be called after destroying the last used heap. Some process-global

data/vendor/v8/include/cppgc/sentinel-pointer.h

@@ -7,13 +7,20 @@
 
 #include <cstdint>
 
+#include "cppgc/internal/api-constants.h"
+
 namespace cppgc {
 namespace internal {
 
 // Special tag type used to denote some sentinel member. The semantics of the
 // sentinel is defined by the embedder.
 struct SentinelPointer {
+#if defined(CPPGC_POINTER_COMPRESSION)
+  static constexpr intptr_t kSentinelValue =
+      1 << api_constants::kPointerCompressionShift;
+#else   // !defined(CPPGC_POINTER_COMPRESSION)
   static constexpr intptr_t kSentinelValue = 0b10;
+#endif  // !defined(CPPGC_POINTER_COMPRESSION)
   template <typename T>
   operator T*() const {
     return reinterpret_cast<T*>(kSentinelValue);

data/vendor/v8/include/cppgc/source-location.h

@@ -5,87 +5,11 @@
 #ifndef INCLUDE_CPPGC_SOURCE_LOCATION_H_
 #define INCLUDE_CPPGC_SOURCE_LOCATION_H_
 
-#include <cstddef>
-#include <string>
-
-#include "v8config.h"  // NOLINT(build/include_directory)
-
-#if defined(__has_builtin)
-#define CPPGC_SUPPORTS_SOURCE_LOCATION                                   \
-  (__has_builtin(__builtin_FUNCTION) && __has_builtin(__builtin_FILE) && \
-   __has_builtin(__builtin_LINE))  // NOLINT
-#elif defined(V8_CC_GNU) && __GNUC__ >= 7
-#define CPPGC_SUPPORTS_SOURCE_LOCATION 1
-#elif defined(V8_CC_INTEL) && __ICC >= 1800
-#define CPPGC_SUPPORTS_SOURCE_LOCATION 1
-#else
-#define CPPGC_SUPPORTS_SOURCE_LOCATION 0
-#endif
+#include "v8-source-location.h"
 
 namespace cppgc {
 
-/**
- * Encapsulates source location information. Mimics C++20's
- * `std::source_location`.
- */
-class V8_EXPORT SourceLocation final {
- public:
-  /**
-   * Construct source location information corresponding to the location of the
-   * call site.
-   */
-#if CPPGC_SUPPORTS_SOURCE_LOCATION
-  static constexpr SourceLocation Current(
-      const char* function = __builtin_FUNCTION(),
-      const char* file = __builtin_FILE(), size_t line = __builtin_LINE()) {
-    return SourceLocation(function, file, line);
-  }
-#else
-  static constexpr SourceLocation Current() { return SourceLocation(); }
-#endif  // CPPGC_SUPPORTS_SOURCE_LOCATION
-
-  /**
-   * Constructs unspecified source location information.
-   */
-  constexpr SourceLocation() = default;
-
-  /**
-   * Returns the name of the function associated with the position represented
-   * by this object, if any.
-   *
-   * \returns the function name as cstring.
-   */
-  constexpr const char* Function() const { return function_; }
-
-  /**
-   * Returns the name of the current source file represented by this object.
-   *
-   * \returns the file name as cstring.
-   */
-  constexpr const char* FileName() const { return file_; }
-
-  /**
-   * Returns the line number represented by this object.
-   *
-   * \returns the line number.
-   */
-  constexpr size_t Line() const { return line_; }
-
-  /**
-   * Returns a human-readable string representing this object.
-   *
-   * \returns a human-readable string representing source location information.
-   */
-  std::string ToString() const;
-
- private:
-  constexpr SourceLocation(const char* function, const char* file, size_t line)
-      : function_(function), file_(file), line_(line) {}
-
-  const char* function_ = nullptr;
-  const char* file_ = nullptr;
-  size_t line_ = 0u;
-};
+using SourceLocation = v8::SourceLocation;
 
 }  // namespace cppgc
 

data/vendor/v8/include/cppgc/trace-trait.h

@@ -53,6 +53,14 @@ struct TraceDescriptor {
   TraceCallback callback;
 };
 
+/**
+ * Callback for getting a TraceDescriptor for a given address.
+ *
+ * \param address Possibly inner address of an object.
+ * \returns a TraceDescriptor for the provided address.
+ */
+using TraceDescriptorCallback = TraceDescriptor (*)(const void* address);
+
 namespace internal {
 
 struct V8_EXPORT TraceTraitFromInnerAddressImpl {