libv8-node 18.19.1.0-aarch64-linux → 19.9.0.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9678456001a26c1f3a7043a9960bc7cd667d0c86b2a58029121f60814ff2e93e
-  data.tar.gz: '0286ee8f91c86ba626374d9bfff4da625b921e03f66d3abc9f6c79b06358fdbe'
+  metadata.gz: b495e11b5d666fe87c9698e6e606e87a049f3120c0401f878120ee3787cffaf4
+  data.tar.gz: 00a157c57a8fd08b0fd9626f90fe948e2895c3a315fe23c771147085bf699679
 SHA512:
-  metadata.gz: 31cf6c8ca9372dbdd5e8096e93c8b8836bcc28c4c5901d48c4bca88e444062d98d586b11be71a5229050def84aa8a47522c02b46c23e38481cb975f0e1bec737
-  data.tar.gz: 040b73f0b42c9c2b19dd60769eb8ee3d47be693dfaf2354ff10a4275479d3fc92e4d13dd4dda3f0eb307928a6efacf74cf2a6861154a107e02d7f7faf5d87668
+  metadata.gz: 78b246fc4665da8ebf8cb2e34daf0ea75ac4a9b9d0dbd3527404b4901f6ec70eaa142e6df12854d9afe286d2da4be7b07420e26ddc2a2ed755c07345caffaf3f
+  data.tar.gz: 310606d848dd00f32d41434f71195c8d52aaea4ae1eb20495508f63522a89f1bf85eece8d72add9bb489d6d29f753d10c09b5ef5fde18f94db547a8b57d02d1f

data/lib/libv8/node/version.rb

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

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

@@ -5,7 +5,6 @@
 #ifndef INCLUDE_CPPGC_COMMON_H_
 #define INCLUDE_CPPGC_COMMON_H_
 
-// TODO(chromium:1056170): Remove dependency on v8.
 #include "v8config.h"  // NOLINT(build/include_directory)
 
 namespace cppgc {

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

@@ -120,7 +120,7 @@ class BasicCrossThreadPersistent final : public CrossThreadPersistentBase,
     if (!IsValid(raw)) return;
     PersistentRegionLock guard;
     CrossThreadPersistentRegion& region = this->GetPersistentRegion(raw);
-    SetNode(region.AllocateNode(this, &Trace));
+    SetNode(region.AllocateNode(this, &TraceAsRoot));
     this->CheckPointer(raw);
   }
 
@@ -138,7 +138,7 @@ class BasicCrossThreadPersistent final : public CrossThreadPersistentBase,
       : CrossThreadPersistentBase(raw), LocationPolicy(loc) {
     if (!IsValid(raw)) return;
     CrossThreadPersistentRegion& region = this->GetPersistentRegion(raw);
-    SetNode(region.AllocateNode(this, &Trace));
+    SetNode(region.AllocateNode(this, &TraceAsRoot));
     this->CheckPointer(raw);
   }
 
@@ -349,9 +349,8 @@ class BasicCrossThreadPersistent final : public CrossThreadPersistentBase,
     return ptr && ptr != kSentinelPointer;
   }
 
-  static void Trace(Visitor* v, const void* ptr) {
-    const auto* handle = static_cast<const BasicCrossThreadPersistent*>(ptr);
-    v->TraceRoot(*handle, handle->Location());
+  static void TraceAsRoot(RootVisitor& root_visitor, const void* ptr) {
+    root_visitor.Trace(*static_cast<const BasicCrossThreadPersistent*>(ptr));
   }
 
   void AssignUnsafe(T* ptr) {
@@ -378,7 +377,7 @@ class BasicCrossThreadPersistent final : public CrossThreadPersistentBase,
     SetValue(ptr);
     if (!IsValid(ptr)) return;
     PersistentRegionLock guard;
-    SetNode(this->GetPersistentRegion(ptr).AllocateNode(this, &Trace));
+    SetNode(this->GetPersistentRegion(ptr).AllocateNode(this, &TraceAsRoot));
     this->CheckPointer(ptr);
   }
 
@@ -398,7 +397,7 @@ class BasicCrossThreadPersistent final : public CrossThreadPersistentBase,
     }
     SetValue(ptr);
     if (!IsValid(ptr)) return;
-    SetNode(this->GetPersistentRegion(ptr).AllocateNode(this, &Trace));
+    SetNode(this->GetPersistentRegion(ptr).AllocateNode(this, &TraceAsRoot));
     this->CheckPointer(ptr);
   }
 
@@ -416,7 +415,7 @@ class BasicCrossThreadPersistent final : public CrossThreadPersistentBase,
     return static_cast<T*>(const_cast<void*>(GetValueFromGC()));
   }
 
-  friend class cppgc::Visitor;
+  friend class internal::RootVisitor;
 };
 
 template <typename T, typename LocationPolicy, typename CheckingPolicy>

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

@@ -9,6 +9,7 @@
 
 #include "cppgc/internal/write-barrier.h"
 #include "cppgc/macros.h"
+#include "cppgc/member.h"
 #include "cppgc/trace-trait.h"
 #include "v8config.h"  // NOLINT(build/include_directory)
 
@@ -47,6 +48,29 @@ class HeapConsistency final {
     return internal::WriteBarrier::GetWriteBarrierType(slot, value, params);
   }
 
+  /**
+   * Gets the required write barrier type for a specific write. This override is
+   * only used for all the BasicMember types.
+   *
+   * \param slot Slot containing the pointer to the object. The slot itself
+   *   must reside in an object that has been allocated using
+   *   `MakeGarbageCollected()`.
+   * \param value The pointer to the object held via `BasicMember`.
+   * \param params Parameters that may be used for actual write barrier calls.
+   *   Only filled if return value indicates that a write barrier is needed. The
+   *   contents of the `params` are an implementation detail.
+   * \returns whether a write barrier is needed and which barrier to invoke.
+   */
+  template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
+            typename CheckingPolicy>
+  static V8_INLINE WriteBarrierType GetWriteBarrierType(
+      const internal::BasicMember<T, WeaknessTag, WriteBarrierPolicy,
+                                  CheckingPolicy>& value,
+      WriteBarrierParams& params) {
+    return internal::WriteBarrier::GetWriteBarrierType(
+        value.GetRawSlot(), value.GetRawStorage(), params);
+  }
+
   /**
    * Gets the required write barrier type for a specific write.
    *
@@ -146,7 +170,25 @@ class HeapConsistency final {
    */
   static V8_INLINE void GenerationalBarrier(const WriteBarrierParams& params,
                                             const void* slot) {
-    internal::WriteBarrier::GenerationalBarrier(params, slot);
+    internal::WriteBarrier::GenerationalBarrier<
+        internal::WriteBarrier::GenerationalBarrierType::kPreciseSlot>(params,
+                                                                       slot);
+  }
+
+  /**
+   * Generational barrier for maintaining consistency when running with multiple
+   * generations. This version is used when slot contains uncompressed pointer.
+   *
+   * \param params The parameters retrieved from `GetWriteBarrierType()`.
+   * \param slot Uncompressed slot containing the direct pointer to the object.
+   * The slot itself must reside in an object that has been allocated using
+   *   `MakeGarbageCollected()`.
+   */
+  static V8_INLINE void GenerationalBarrierForUncompressedSlot(
+      const WriteBarrierParams& params, const void* uncompressed_slot) {
+    internal::WriteBarrier::GenerationalBarrier<
+        internal::WriteBarrier::GenerationalBarrierType::
+            kPreciseUncompressedSlot>(params, uncompressed_slot);
   }
 
   /**
@@ -158,8 +200,9 @@ class HeapConsistency final {
    */
   static V8_INLINE void GenerationalBarrierForSourceObject(
       const WriteBarrierParams& params, const void* inner_pointer) {
-    internal::WriteBarrier::GenerationalBarrierForSourceObject(params,
-                                                               inner_pointer);
+    internal::WriteBarrier::GenerationalBarrier<
+        internal::WriteBarrier::GenerationalBarrierType::kImpreciseSlot>(
+        params, inner_pointer);
   }
 
  private:

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

@@ -0,0 +1,43 @@
+// Copyright 2022 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_HEAP_HANDLE_H_
+#define INCLUDE_CPPGC_HEAP_HANDLE_H_
+
+#include "v8config.h"  // NOLINT(build/include_directory)
+
+namespace cppgc {
+
+namespace internal {
+class HeapBase;
+class WriteBarrierTypeForCagedHeapPolicy;
+class WriteBarrierTypeForNonCagedHeapPolicy;
+}  // namespace internal
+
+/**
+ * Opaque handle used for additional heap APIs.
+ */
+class HeapHandle {
+ private:
+  HeapHandle() = default;
+
+  V8_INLINE bool is_incremental_marking_in_progress() const {
+    return is_incremental_marking_in_progress_;
+  }
+
+  V8_INLINE bool is_young_generation_enabled() const {
+    return is_young_generation_enabled_;
+  }
+
+  bool is_incremental_marking_in_progress_ = false;
+  bool is_young_generation_enabled_ = false;
+
+  friend class internal::HeapBase;
+  friend class internal::WriteBarrierTypeForCagedHeapPolicy;
+  friend class internal::WriteBarrierTypeForNonCagedHeapPolicy;
+};
+
+}  // namespace cppgc
+
+#endif  // INCLUDE_CPPGC_HEAP_HANDLE_H_

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

@@ -56,7 +56,7 @@ struct HeapStatistics final {
     /** Amount of memory actually used on the page. */
     size_t used_size_bytes = 0;
     /** Statistics for object allocated on the page. Filled only when
-     * NameProvider::HideInternalNames() is false. */
+     * NameProvider::SupportsCppClassNamesAsObjectNames() is true. */
     std::vector<ObjectStatsEntry> object_statistics;
   };
 
@@ -98,7 +98,7 @@ struct HeapStatistics final {
 
   /** Overall committed amount of memory for the heap. */
   size_t committed_size_bytes = 0;
-  /** Resident amount of memory help by the heap. */
+  /** Resident amount of memory held by the heap. */
   size_t resident_size_bytes = 0;
   /** Amount of memory actually used on the heap. */
   size_t used_size_bytes = 0;

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

@@ -21,6 +21,7 @@
 namespace cppgc {
 
 class AllocationHandle;
+class HeapHandle;
 
 /**
  * Implementation details of cppgc. Those details are considered internal and
@@ -31,11 +32,6 @@ namespace internal {
 class Heap;
 }  // namespace internal
 
-/**
- * Used for additional heap APIs.
- */
-class HeapHandle;
-
 class V8_EXPORT Heap {
  public:
   /**
@@ -59,7 +55,7 @@ class V8_EXPORT Heap {
   };
 
   /**
-   * Specifies supported marking types
+   * Specifies supported marking types.
    */
   enum class MarkingType : uint8_t {
     /**
@@ -79,7 +75,7 @@ class V8_EXPORT Heap {
   };
 
   /**
-   * Specifies supported sweeping types
+   * Specifies supported sweeping types.
    */
   enum class SweepingType : uint8_t {
     /**

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

@@ -32,12 +32,22 @@ 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)
+constexpr size_t kGuardPageSize = 0;
+#else
+constexpr size_t kGuardPageSize = 4096;
+#endif
+
 static constexpr size_t kLargeObjectSizeThreshold = kPageSize / 2;
 
 #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;
+#endif  // !defined(CPPGC_2GB_CAGE)
 constexpr size_t kCagedHeapReservationAlignment = kCagedHeapReservationSize;
-#endif
+#endif  // defined(CPPGC_CAGED_HEAP)
 
 static constexpr size_t kDefaultAlignment = sizeof(void*);
 

data/vendor/v8/include/cppgc/internal/base-page-handle.h

@@ -0,0 +1,45 @@
+// Copyright 2022 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_BASE_PAGE_HANDLE_H_
+#define INCLUDE_CPPGC_INTERNAL_BASE_PAGE_HANDLE_H_
+
+#include "cppgc/heap-handle.h"
+#include "cppgc/internal/api-constants.h"
+#include "cppgc/internal/logging.h"
+#include "v8config.h"  // NOLINT(build/include_directory)
+
+namespace cppgc {
+namespace internal {
+
+// The class is needed in the header to allow for fast access to HeapHandle in
+// the write barrier.
+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);
+  }
+  static V8_INLINE const BasePageHandle* FromPayload(const void* payload) {
+    return FromPayload(const_cast<void*>(payload));
+  }
+
+  HeapHandle& heap_handle() { return heap_handle_; }
+  const HeapHandle& heap_handle() const { return heap_handle_; }
+
+ protected:
+  explicit BasePageHandle(HeapHandle& heap_handle) : heap_handle_(heap_handle) {
+    CPPGC_DCHECK(reinterpret_cast<uintptr_t>(this) % api_constants::kPageSize ==
+                 api_constants::kGuardPageSize);
+  }
+
+  HeapHandle& heap_handle_;
+};
+
+}  // namespace internal
+}  // namespace cppgc
+
+#endif  // INCLUDE_CPPGC_INTERNAL_BASE_PAGE_HANDLE_H_

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

@@ -10,46 +10,76 @@
 #include <cstdint>
 
 #include "cppgc/internal/api-constants.h"
+#include "cppgc/internal/caged-heap.h"
 #include "cppgc/internal/logging.h"
 #include "cppgc/platform.h"
 #include "v8config.h"  // NOLINT(build/include_directory)
 
+#if __cpp_lib_bitopts
+#include <bit>
+#endif  // __cpp_lib_bitopts
+
+#if defined(CPPGC_CAGED_HEAP)
+
 namespace cppgc {
 namespace internal {
 
 class HeapBase;
+class HeapBaseHandle;
 
 #if defined(CPPGC_YOUNG_GENERATION)
 
 // AgeTable is the bytemap needed for the fast generation check in the write
-// barrier. AgeTable contains entries that correspond to 512 bytes memory
+// barrier. AgeTable contains entries that correspond to 4096 bytes memory
 // regions (cards). Each entry in the table represents generation of the objects
 // that reside on the corresponding card (young, old or mixed).
-class AgeTable final {
+class V8_EXPORT AgeTable final {
   static constexpr size_t kRequiredSize = 1 * api_constants::kMB;
   static constexpr size_t kAllocationGranularity =
       api_constants::kAllocationGranularity;
 
  public:
+  // Represents age of the objects living on a single card.
   enum class Age : uint8_t { kOld, kYoung, kMixed };
+  // When setting age for a range, consider or ignore ages of the adjacent
+  // cards.
+  enum class AdjacentCardsPolicy : uint8_t { kConsider, kIgnore };
 
   static constexpr size_t kCardSizeInBytes =
-      (api_constants::kCagedHeapReservationSize / kAllocationGranularity) /
-      kRequiredSize;
+      api_constants::kCagedHeapReservationSize / kRequiredSize;
 
   void SetAge(uintptr_t cage_offset, Age age) {
     table_[card(cage_offset)] = age;
   }
+
   V8_INLINE Age GetAge(uintptr_t cage_offset) const {
     return table_[card(cage_offset)];
   }
 
-  void Reset(PageAllocator* allocator);
+  void SetAgeForRange(uintptr_t cage_offset_begin, uintptr_t cage_offset_end,
+                      Age age, AdjacentCardsPolicy adjacent_cards_policy);
+
+  Age GetAgeForRange(uintptr_t cage_offset_begin,
+                     uintptr_t cage_offset_end) const;
+
+  void ResetForTesting();
 
  private:
   V8_INLINE size_t card(uintptr_t offset) const {
     constexpr size_t kGranularityBits =
+#if __cpp_lib_bitopts
+        std::countr_zero(static_cast<uint32_t>(kCardSizeInBytes));
+#elif V8_HAS_BUILTIN_CTZ
         __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;
     CPPGC_DCHECK(table_.size() > entry);
     return entry;
@@ -64,10 +94,10 @@ static_assert(sizeof(AgeTable) == 1 * api_constants::kMB,
 #endif  // CPPGC_YOUNG_GENERATION
 
 struct CagedHeapLocalData final {
-  CagedHeapLocalData(HeapBase&, PageAllocator&);
+  V8_INLINE static CagedHeapLocalData& Get() {
+    return *reinterpret_cast<CagedHeapLocalData*>(CagedHeapBase::GetBase());
+  }
 
-  bool is_incremental_marking_in_progress = false;
-  HeapBase& heap_base;
 #if defined(CPPGC_YOUNG_GENERATION)
   AgeTable age_table;
 #endif
@@ -76,4 +106,6 @@ struct CagedHeapLocalData final {
 }  // namespace internal
 }  // namespace cppgc
 
+#endif  // defined(CPPGC_CAGED_HEAP)
+
 #endif  // INCLUDE_CPPGC_INTERNAL_CAGED_HEAP_LOCAL_DATA_H_

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

@@ -0,0 +1,61 @@
+// Copyright 2022 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_CAGED_HEAP_H_
+#define INCLUDE_CPPGC_INTERNAL_CAGED_HEAP_H_
+
+#include <climits>
+#include <cstddef>
+
+#include "cppgc/internal/api-constants.h"
+#include "cppgc/internal/base-page-handle.h"
+#include "v8config.h"  // NOLINT(build/include_directory)
+
+#if defined(CPPGC_CAGED_HEAP)
+
+namespace cppgc {
+namespace internal {
+
+class V8_EXPORT CagedHeapBase {
+ public:
+  V8_INLINE static uintptr_t OffsetFromAddress(const void* address) {
+    return reinterpret_cast<uintptr_t>(address) &
+           (api_constants::kCagedHeapReservationAlignment - 1);
+  }
+
+  V8_INLINE static bool IsWithinCage(const void* address) {
+    CPPGC_DCHECK(g_heap_base_);
+    return (reinterpret_cast<uintptr_t>(address) &
+            ~(api_constants::kCagedHeapReservationAlignment - 1)) ==
+           g_heap_base_;
+  }
+
+  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;
+#else   //! defined(CPPGC_2GB_CAGE)
+    static constexpr size_t kHalfWordShift = sizeof(uint32_t) * CHAR_BIT;
+#endif  //! defined(CPPGC_2GB_CAGE)
+    static_assert((static_cast<size_t>(1) << kHalfWordShift) ==
+                  api_constants::kCagedHeapReservationSize);
+    CPPGC_DCHECK(g_heap_base_);
+    return !(((reinterpret_cast<uintptr_t>(addr1) ^ g_heap_base_) |
+              (reinterpret_cast<uintptr_t>(addr2) ^ g_heap_base_)) >>
+             kHalfWordShift);
+  }
+
+  V8_INLINE static uintptr_t GetBase() { return g_heap_base_; }
+
+ private:
+  friend class CagedHeap;
+
+  static uintptr_t g_heap_base_;
+};
+
+}  // namespace internal
+}  // namespace cppgc
+
+#endif  // defined(CPPGC_CAGED_HEAP)
+
+#endif  // INCLUDE_CPPGC_INTERNAL_CAGED_HEAP_H_

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

@@ -48,7 +48,6 @@ struct V8_EXPORT EnsureGCInfoIndexTrait final {
   static GCInfoIndex EnsureGCInfoIndexNonPolymorphic(std::atomic<GCInfoIndex>&,
                                                      TraceCallback,
                                                      FinalizationCallback,
-
                                                      NameCallback);
   static GCInfoIndex EnsureGCInfoIndexNonPolymorphic(std::atomic<GCInfoIndex>&,
                                                      TraceCallback,