libv8-node 19.9.0.0-x86_64-darwin → 20.12.1.0-x86_64-darwin

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28d71ca26868fe1be286e18102e1fb1ed1363ae5fadcb27644d3efdee37475d6
-  data.tar.gz: fc94ef7a64310dbe4bdb2d86502f6f23d089b4af3c315e3b05aceeb0ce3cbf19
+  metadata.gz: 1234cc139bd0d657a834399f0130fe12d5588041b27130c7503fa5997cee31c8
+  data.tar.gz: 8eaa289e367eefe28924dad118dabf348129c0bc98466abb27187722a02671b1
 SHA512:
-  metadata.gz: 7c4064234a7a30146dffe5e0cbb4d699c6818723669efb296d9382c13a23bcdac5f69b0cfbdeb00a8012718157a97cbecc9e8068317cdc435606f52af309683a
-  data.tar.gz: a302f8dbdafec0d7add511a573eacc1ee4e27b893bc1ba3a0b2cab890fab7bd8800c2e68f30dcb2f48401e6423983b2002b656dff7151e8304b673999d260aae
+  metadata.gz: 28cb1c107148542812e05c7915f3419b7184c7d5c8fe6c45ee1cbcd634fd22448e7db7757d1dca7425e7bbd7ea7e22f6f5e3f2b10956f24d7a2cc1637322dcdb
+  data.tar.gz: 7c1180e267aef5462f5b645a7c9e358ca893c8590a88d7a55d1e2fa5343ba35e4c3c3bf4f082facbea5f210d618e3974b147e8ffce8878ef7126c77b974081e3

data/lib/libv8/node/version.rb

@@ -1,7 +1,7 @@
 module Libv8; end
 
 module Libv8::Node
-  VERSION = '19.9.0.0'.freeze
-  NODE_VERSION = '19.9.0'.freeze
-  LIBV8_VERSION = '10.8.168.25'.freeze # from v8/include/v8-version.h
+  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
 end

data/vendor/v8/include/cppgc/cross-thread-persistent.h

@@ -148,10 +148,11 @@ class BasicCrossThreadPersistent final : public CrossThreadPersistentBase,
 
   template <typename U, typename MemberBarrierPolicy,
             typename MemberWeaknessTag, typename MemberCheckingPolicy,
+            typename MemberStorageType,
             typename = std::enable_if_t<std::is_base_of<T, U>::value>>
   BasicCrossThreadPersistent(
       internal::BasicMember<U, MemberBarrierPolicy, MemberWeaknessTag,
-                            MemberCheckingPolicy>
+                            MemberCheckingPolicy, MemberStorageType>
           member,
       const SourceLocation& loc = SourceLocation::Current())
       : BasicCrossThreadPersistent(member.Get(), loc) {}
@@ -230,10 +231,11 @@ class BasicCrossThreadPersistent final : public CrossThreadPersistentBase,
   // Assignment from member.
   template <typename U, typename MemberBarrierPolicy,
             typename MemberWeaknessTag, typename MemberCheckingPolicy,
+            typename MemberStorageType,
             typename = std::enable_if_t<std::is_base_of<T, U>::value>>
   BasicCrossThreadPersistent& operator=(
       internal::BasicMember<U, MemberBarrierPolicy, MemberWeaknessTag,
-                            MemberCheckingPolicy>
+                            MemberCheckingPolicy, MemberStorageType>
           member) {
     return operator=(member.Get());
   }

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

@@ -62,10 +62,10 @@ class HeapConsistency final {
    * \returns whether a write barrier is needed and which barrier to invoke.
    */
   template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
-            typename CheckingPolicy>
+            typename CheckingPolicy, typename StorageType>
   static V8_INLINE WriteBarrierType GetWriteBarrierType(
       const internal::BasicMember<T, WeaknessTag, WriteBarrierPolicy,
-                                  CheckingPolicy>& value,
+                                  CheckingPolicy, StorageType>& value,
       WriteBarrierParams& params) {
     return internal::WriteBarrier::GetWriteBarrierType(
         value.GetRawSlot(), value.GetRawStorage(), params);

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

@@ -19,6 +19,11 @@ class WriteBarrierTypeForNonCagedHeapPolicy;
  * Opaque handle used for additional heap APIs.
  */
 class HeapHandle {
+ public:
+  // Deleted copy ctor to avoid treating the type by value.
+  HeapHandle(const HeapHandle&) = delete;
+  HeapHandle& operator=(const HeapHandle&) = delete;
+
  private:
   HeapHandle() = default;
 

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

@@ -32,7 +32,7 @@ static constexpr uint16_t kFullyConstructedBitMask = uint16_t{1};
 
 static constexpr size_t kPageSize = size_t{1} << 17;
 
-#if defined(V8_TARGET_ARCH_ARM64) && defined(V8_OS_MACOS)
+#if defined(V8_TARGET_ARCH_ARM64) && defined(V8_OS_DARWIN)
 constexpr size_t kGuardPageSize = 0;
 #else
 constexpr size_t kGuardPageSize = 4096;
@@ -57,6 +57,9 @@ static constexpr size_t kMaxSupportedAlignment = 2 * kDefaultAlignment;
 // Granularity of heap allocations.
 constexpr size_t kAllocationGranularity = sizeof(void*);
 
+// Default cacheline size.
+constexpr size_t kCachelineSize = 64;
+
 }  // namespace api_constants
 
 }  // namespace internal

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

@@ -10,6 +10,7 @@
 #include <type_traits>
 
 #include "cppgc/internal/finalizer-trait.h"
+#include "cppgc/internal/logging.h"
 #include "cppgc/internal/name-trait.h"
 #include "cppgc/trace-trait.h"
 #include "v8config.h"  // NOLINT(build/include_directory)
@@ -20,12 +21,12 @@ namespace internal {
 using GCInfoIndex = uint16_t;
 
 struct V8_EXPORT EnsureGCInfoIndexTrait final {
-  // Acquires a new GC info object and returns the index. In addition, also
-  // updates `registered_index` atomically.
+  // 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 GCInfoIndex EnsureIndex(
+  V8_INLINE static void EnsureIndex(
       std::atomic<GCInfoIndex>& registered_index) {
-    return EnsureGCInfoIndexTraitDispatch<T>{}(registered_index);
+    EnsureGCInfoIndexTraitDispatch<T>{}(registered_index);
   }
 
  private:
@@ -34,38 +35,32 @@ struct V8_EXPORT EnsureGCInfoIndexTrait final {
             bool = NameTrait<T>::HasNonHiddenName()>
   struct EnsureGCInfoIndexTraitDispatch;
 
-  static GCInfoIndex EnsureGCInfoIndexPolymorphic(std::atomic<GCInfoIndex>&,
-                                                  TraceCallback,
-                                                  FinalizationCallback,
-                                                  NameCallback);
-  static GCInfoIndex EnsureGCInfoIndexPolymorphic(std::atomic<GCInfoIndex>&,
-                                                  TraceCallback,
-                                                  FinalizationCallback);
-  static GCInfoIndex EnsureGCInfoIndexPolymorphic(std::atomic<GCInfoIndex>&,
-                                                  TraceCallback, NameCallback);
-  static GCInfoIndex EnsureGCInfoIndexPolymorphic(std::atomic<GCInfoIndex>&,
-                                                  TraceCallback);
-  static GCInfoIndex EnsureGCInfoIndexNonPolymorphic(std::atomic<GCInfoIndex>&,
-                                                     TraceCallback,
-                                                     FinalizationCallback,
-                                                     NameCallback);
-  static GCInfoIndex EnsureGCInfoIndexNonPolymorphic(std::atomic<GCInfoIndex>&,
-                                                     TraceCallback,
-                                                     FinalizationCallback);
-  static GCInfoIndex EnsureGCInfoIndexNonPolymorphic(std::atomic<GCInfoIndex>&,
-                                                     TraceCallback,
-                                                     NameCallback);
-  static GCInfoIndex EnsureGCInfoIndexNonPolymorphic(std::atomic<GCInfoIndex>&,
-                                                     TraceCallback);
+  static void V8_PRESERVE_MOST
+  EnsureGCInfoIndexPolymorphic(std::atomic<GCInfoIndex>&, TraceCallback,
+                               FinalizationCallback, NameCallback);
+  static void V8_PRESERVE_MOST EnsureGCInfoIndexPolymorphic(
+      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);
 };
 
 #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 GCInfoIndex                                                      \
-    operator()(std::atomic<GCInfoIndex>& registered_index) {                   \
-      return function;                                                         \
+    V8_INLINE void operator()(std::atomic<GCInfoIndex>& registered_index) {    \
+      function;                                                                \
     }                                                                          \
   };
 
@@ -143,9 +138,16 @@ struct GCInfoTrait final {
     static_assert(sizeof(T), "T must be fully defined");
     static std::atomic<GCInfoIndex>
         registered_index;  // Uses zero initialization.
-    const GCInfoIndex index = registered_index.load(std::memory_order_acquire);
-    return index ? index
-                 : EnsureGCInfoIndexTrait::EnsureIndex<T>(registered_index);
+    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;
   }
 };
 

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

@@ -17,6 +17,11 @@
 namespace cppgc {
 namespace internal {
 
+enum class WriteBarrierSlotType {
+  kCompressed,
+  kUncompressed,
+};
+
 #if defined(CPPGC_POINTER_COMPRESSION)
 
 #if defined(__clang__)
@@ -30,16 +35,16 @@ namespace internal {
 #define CPPGC_REQUIRE_CONSTANT_INIT
 #endif  // defined(__clang__)
 
-class CageBaseGlobal final {
+class V8_EXPORT CageBaseGlobal final {
  public:
   V8_INLINE CPPGC_CONST static uintptr_t Get() {
     CPPGC_DCHECK(IsBaseConsistent());
-    return g_base_;
+    return g_base_.base;
   }
 
   V8_INLINE CPPGC_CONST static bool IsSet() {
     CPPGC_DCHECK(IsBaseConsistent());
-    return (g_base_ & ~kLowerHalfWordMask) != 0;
+    return (g_base_.base & ~kLowerHalfWordMask) != 0;
   }
 
  private:
@@ -47,12 +52,15 @@ class CageBaseGlobal final {
   static constexpr uintptr_t kLowerHalfWordMask =
       (api_constants::kCagedHeapReservationAlignment - 1);
 
-  static V8_EXPORT uintptr_t g_base_ CPPGC_REQUIRE_CONSTANT_INIT;
+  static union alignas(api_constants::kCachelineSize) Base {
+    uintptr_t base;
+    char cache_line[api_constants::kCachelineSize];
+  } g_base_ CPPGC_REQUIRE_CONSTANT_INIT;
 
   CageBaseGlobal() = delete;
 
   V8_INLINE static bool IsBaseConsistent() {
-    return kLowerHalfWordMask == (g_base_ & kLowerHalfWordMask);
+    return kLowerHalfWordMask == (g_base_.base & kLowerHalfWordMask);
   }
 
   friend class CageBaseGlobalUpdater;
@@ -64,6 +72,8 @@ class CageBaseGlobal final {
 class V8_TRIVIAL_ABI CompressedPointer final {
  public:
   using IntegralType = uint32_t;
+  static constexpr auto kWriteBarrierSlotType =
+      WriteBarrierSlotType::kCompressed;
 
   V8_INLINE CompressedPointer() : value_(0u) {}
   V8_INLINE explicit CompressedPointer(const void* ptr)
@@ -173,6 +183,8 @@ class V8_TRIVIAL_ABI CompressedPointer final {
 class V8_TRIVIAL_ABI RawPointer final {
  public:
   using IntegralType = uintptr_t;
+  static constexpr auto kWriteBarrierSlotType =
+      WriteBarrierSlotType::kUncompressed;
 
   V8_INLINE RawPointer() : ptr_(nullptr) {}
   V8_INLINE explicit RawPointer(const void* ptr) : ptr_(ptr) {}
@@ -225,9 +237,9 @@ class V8_TRIVIAL_ABI RawPointer final {
 };
 
 #if defined(CPPGC_POINTER_COMPRESSION)
-using MemberStorage = CompressedPointer;
+using DefaultMemberStorage = CompressedPointer;
 #else   // !defined(CPPGC_POINTER_COMPRESSION)
-using MemberStorage = RawPointer;
+using DefaultMemberStorage = RawPointer;
 #endif  // !defined(CPPGC_POINTER_COMPRESSION)
 
 }  // namespace internal

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

@@ -33,20 +33,53 @@ struct DijkstraWriteBarrierPolicy {
     // barrier doesn't break the tri-color invariant.
   }
 
+  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);
+#else   // !CPPGC_SLIM_WRITE_BARRIER
     WriteBarrier::Params params;
     const WriteBarrier::Type type =
         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) {
+    static_assert(
+        SlotType == WriteBarrierSlotType::kUncompressed,
+        "Assigning storages of Member and UncompressedMember is not supported");
+#ifdef CPPGC_SLIM_WRITE_BARRIER
+    if (V8_UNLIKELY(WriteBarrier::IsEnabled()))
+      WriteBarrier::CombinedWriteBarrierSlow<SlotType>(slot);
+#else   // !CPPGC_SLIM_WRITE_BARRIER
+    WriteBarrier::Params params;
+    const WriteBarrier::Type type =
+        WriteBarrier::GetWriteBarrierType(slot, storage, params);
+    WriteBarrier(type, params, slot, storage.Load());
+#endif  // !CPPGC_SLIM_WRITE_BARRIER
+  }
+
+#if defined(CPPGC_POINTER_COMPRESSION)
+  template <WriteBarrierSlotType SlotType>
   V8_INLINE static void AssigningBarrier(const void* slot,
-                                         MemberStorage storage) {
+                                         CompressedPointer storage) {
+    static_assert(
+        SlotType == WriteBarrierSlotType::kCompressed,
+        "Assigning storages of Member and UncompressedMember is not supported");
+#ifdef CPPGC_SLIM_WRITE_BARRIER
+    if (V8_UNLIKELY(WriteBarrier::IsEnabled()))
+      WriteBarrier::CombinedWriteBarrierSlow<SlotType>(slot);
+#else   // !CPPGC_SLIM_WRITE_BARRIER
     WriteBarrier::Params params;
     const WriteBarrier::Type type =
         WriteBarrier::GetWriteBarrierType(slot, storage, params);
     WriteBarrier(type, params, slot, storage.Load());
+#endif  // !CPPGC_SLIM_WRITE_BARRIER
   }
+#endif  // defined(CPPGC_POINTER_COMPRESSION)
 
  private:
   V8_INLINE static void WriteBarrier(WriteBarrier::Type type,
@@ -68,7 +101,9 @@ struct DijkstraWriteBarrierPolicy {
 
 struct NoWriteBarrierPolicy {
   V8_INLINE static void InitializingBarrier(const void*, const void*) {}
+  template <WriteBarrierSlotType>
   V8_INLINE static void AssigningBarrier(const void*, const void*) {}
+  template <WriteBarrierSlotType, typename MemberStorage>
   V8_INLINE static void AssigningBarrier(const void*, MemberStorage) {}
 };
 
@@ -197,7 +232,8 @@ template <typename T, typename WeaknessPolicy,
           typename CheckingPolicy = DefaultPersistentCheckingPolicy>
 class BasicPersistent;
 template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
-          typename CheckingPolicy = DefaultMemberCheckingPolicy>
+          typename CheckingPolicy = DefaultMemberCheckingPolicy,
+          typename StorageType = DefaultMemberStorage>
 class BasicMember;
 
 }  // namespace internal

data/vendor/v8/include/cppgc/internal/write-barrier.h

@@ -70,6 +70,7 @@ class V8_EXPORT WriteBarrier final {
   static V8_INLINE Type GetWriteBarrierType(const void* slot, const void* value,
                                             Params& params);
   // Returns the required write barrier for a given `slot` and `value`.
+  template <typename MemberStorage>
   static V8_INLINE Type GetWriteBarrierType(const void* slot, MemberStorage,
                                             Params& params);
   // Returns the required write barrier for a given `slot`.
@@ -79,6 +80,15 @@ class V8_EXPORT WriteBarrier final {
   // Returns the required write barrier for a given  `value`.
   static V8_INLINE Type GetWriteBarrierType(const void* value, Params& params);
 
+#ifdef CPPGC_SLIM_WRITE_BARRIER
+  // A write barrier that combines `GenerationalBarrier()` and
+  // `DijkstraMarkingBarrier()`. We only pass a single parameter here to clobber
+  // as few registers as possible.
+  template <WriteBarrierSlotType>
+  static V8_NOINLINE void V8_PRESERVE_MOST
+  CombinedWriteBarrierSlow(const void* slot);
+#endif  // CPPGC_SLIM_WRITE_BARRIER
+
   static V8_INLINE void DijkstraMarkingBarrier(const Params& params,
                                                const void* object);
   static V8_INLINE void DijkstraMarkingBarrierRange(
@@ -163,7 +173,8 @@ class V8_EXPORT WriteBarrierTypeForCagedHeapPolicy final {
     return ValueModeDispatch<value_mode>::Get(slot, value, params, callback);
   }
 
-  template <WriteBarrier::ValueMode value_mode, typename HeapHandleCallback>
+  template <WriteBarrier::ValueMode value_mode, typename HeapHandleCallback,
+            typename MemberStorage>
   static V8_INLINE WriteBarrier::Type Get(const void* slot, MemberStorage value,
                                           WriteBarrier::Params& params,
                                           HeapHandleCallback callback) {
@@ -207,7 +218,7 @@ class V8_EXPORT WriteBarrierTypeForCagedHeapPolicy final {
 template <>
 struct WriteBarrierTypeForCagedHeapPolicy::ValueModeDispatch<
     WriteBarrier::ValueMode::kValuePresent> {
-  template <typename HeapHandleCallback>
+  template <typename HeapHandleCallback, typename MemberStorage>
   static V8_INLINE WriteBarrier::Type Get(const void* slot,
                                           MemberStorage storage,
                                           WriteBarrier::Params& params,
@@ -305,11 +316,9 @@ class V8_EXPORT WriteBarrierTypeForNonCagedHeapPolicy final {
   }
 
   template <WriteBarrier::ValueMode value_mode, typename HeapHandleCallback>
-  static V8_INLINE WriteBarrier::Type Get(const void* slot, MemberStorage value,
+  static V8_INLINE WriteBarrier::Type Get(const void* slot, RawPointer value,
                                           WriteBarrier::Params& params,
                                           HeapHandleCallback callback) {
-    // `MemberStorage` will always be `RawPointer` for non-caged heap builds.
-    // Just convert to `void*` in this case.
     return ValueModeDispatch<value_mode>::Get(slot, value.Load(), params,
                                               callback);
   }
@@ -383,6 +392,7 @@ WriteBarrier::Type WriteBarrier::GetWriteBarrierType(
 }
 
 // static
+template <typename MemberStorage>
 WriteBarrier::Type WriteBarrier::GetWriteBarrierType(
     const void* slot, MemberStorage value, WriteBarrier::Params& params) {
   return WriteBarrierTypePolicy::Get<ValueMode::kValuePresent>(slot, value,

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

@@ -11,7 +11,10 @@
 
 namespace cppgc {
 
-// Use if the object is only stack allocated.
+// 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; \
@@ -20,6 +23,12 @@ 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")))
+#else  // !defined(__clang__)
+#define CPPGC_STACK_ALLOCATED() static_assert(true, "Force semicolon.")
+#define CPPGC_STACK_ALLOCATED_IGNORE(bug_or_reason)
+#endif  // !defined(__clang__)
 
 }  // namespace cppgc