libv8-node 18.13.0.1-x86_64-linux → 20.2.0.0-x86_64-linux

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

@@ -0,0 +1,248 @@
+// 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_MEMBER_STORAGE_H_
+#define INCLUDE_CPPGC_INTERNAL_MEMBER_STORAGE_H_
+
+#include <atomic>
+#include <cstddef>
+#include <type_traits>
+
+#include "cppgc/internal/api-constants.h"
+#include "cppgc/internal/logging.h"
+#include "cppgc/sentinel-pointer.h"
+#include "v8config.h"  // NOLINT(build/include_directory)
+
+namespace cppgc {
+namespace internal {
+
+enum class WriteBarrierSlotType {
+  kCompressed,
+  kUncompressed,
+};
+
+#if defined(CPPGC_POINTER_COMPRESSION)
+
+#if defined(__clang__)
+// Attribute const allows the compiler to assume that CageBaseGlobal::g_base_
+// doesn't change (e.g. across calls) and thereby avoid redundant loads.
+#define CPPGC_CONST __attribute__((const))
+#define CPPGC_REQUIRE_CONSTANT_INIT \
+  __attribute__((require_constant_initialization))
+#else  // defined(__clang__)
+#define CPPGC_CONST
+#define CPPGC_REQUIRE_CONSTANT_INIT
+#endif  // defined(__clang__)
+
+class V8_EXPORT CageBaseGlobal final {
+ public:
+  V8_INLINE CPPGC_CONST static uintptr_t Get() {
+    CPPGC_DCHECK(IsBaseConsistent());
+    return g_base_.base;
+  }
+
+  V8_INLINE CPPGC_CONST static bool IsSet() {
+    CPPGC_DCHECK(IsBaseConsistent());
+    return (g_base_.base & ~kLowerHalfWordMask) != 0;
+  }
+
+ private:
+  // We keep the lower halfword as ones to speed up decompression.
+  static constexpr uintptr_t kLowerHalfWordMask =
+      (api_constants::kCagedHeapReservationAlignment - 1);
+
+  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_.base & kLowerHalfWordMask);
+  }
+
+  friend class CageBaseGlobalUpdater;
+};
+
+#undef CPPGC_REQUIRE_CONSTANT_INIT
+#undef CPPGC_CONST
+
+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)
+      : value_(Compress(ptr)) {}
+  V8_INLINE explicit CompressedPointer(std::nullptr_t) : value_(0u) {}
+  V8_INLINE explicit CompressedPointer(SentinelPointer)
+      : value_(kCompressedSentinel) {}
+
+  V8_INLINE const void* Load() const { return Decompress(value_); }
+  V8_INLINE const void* LoadAtomic() const {
+    return Decompress(
+        reinterpret_cast<const std::atomic<IntegralType>&>(value_).load(
+            std::memory_order_relaxed));
+  }
+
+  V8_INLINE void Store(const void* ptr) { value_ = Compress(ptr); }
+  V8_INLINE void StoreAtomic(const void* value) {
+    reinterpret_cast<std::atomic<IntegralType>&>(value_).store(
+        Compress(value), std::memory_order_relaxed);
+  }
+
+  V8_INLINE void Clear() { value_ = 0u; }
+  V8_INLINE bool IsCleared() const { return !value_; }
+
+  V8_INLINE bool IsSentinel() const { return value_ == kCompressedSentinel; }
+
+  V8_INLINE uint32_t GetAsInteger() const { return value_; }
+
+  V8_INLINE friend bool operator==(CompressedPointer a, CompressedPointer b) {
+    return a.value_ == b.value_;
+  }
+  V8_INLINE friend bool operator!=(CompressedPointer a, CompressedPointer b) {
+    return a.value_ != b.value_;
+  }
+  V8_INLINE friend bool operator<(CompressedPointer a, CompressedPointer b) {
+    return a.value_ < b.value_;
+  }
+  V8_INLINE friend bool operator<=(CompressedPointer a, CompressedPointer b) {
+    return a.value_ <= b.value_;
+  }
+  V8_INLINE friend bool operator>(CompressedPointer a, CompressedPointer b) {
+    return a.value_ > b.value_;
+  }
+  V8_INLINE friend bool operator>=(CompressedPointer a, CompressedPointer b) {
+    return a.value_ >= b.value_;
+  }
+
+  static V8_INLINE IntegralType Compress(const void* ptr) {
+    static_assert(
+        SentinelPointer::kSentinelValue == 0b10,
+        "The compression scheme relies on the sentinel encoded as 0b10");
+    static constexpr size_t kGigaCageMask =
+        ~(api_constants::kCagedHeapReservationAlignment - 1);
+
+    CPPGC_DCHECK(CageBaseGlobal::IsSet());
+    const uintptr_t base = CageBaseGlobal::Get();
+    CPPGC_DCHECK(!ptr || ptr == kSentinelPointer ||
+                 (base & kGigaCageMask) ==
+                     (reinterpret_cast<uintptr_t>(ptr) & kGigaCageMask));
+
+#if defined(CPPGC_2GB_CAGE)
+    // Truncate the pointer.
+    auto compressed =
+        static_cast<IntegralType>(reinterpret_cast<uintptr_t>(ptr));
+#else   // !defined(CPPGC_2GB_CAGE)
+    const auto uptr = reinterpret_cast<uintptr_t>(ptr);
+    // Shift the pointer by one and truncate.
+    auto compressed = static_cast<IntegralType>(uptr >> 1);
+#endif  // !defined(CPPGC_2GB_CAGE)
+    // Normal compressed pointers must have the MSB set.
+    CPPGC_DCHECK((!compressed || compressed == kCompressedSentinel) ||
+                 (compressed & (1 << 31)));
+    return compressed;
+  }
+
+  static V8_INLINE void* Decompress(IntegralType ptr) {
+    CPPGC_DCHECK(CageBaseGlobal::IsSet());
+    const uintptr_t base = CageBaseGlobal::Get();
+    // Treat compressed pointer as signed and cast it to uint64_t, which will
+    // sign-extend it.
+#if defined(CPPGC_2GB_CAGE)
+    const uint64_t mask = static_cast<uint64_t>(static_cast<int32_t>(ptr));
+#else   // !defined(CPPGC_2GB_CAGE)
+    // Then, shift the result by one. 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;
+#endif  // !defined(CPPGC_2GB_CAGE)
+    return reinterpret_cast<void*>(mask & base);
+  }
+
+ private:
+#if defined(CPPGC_2GB_CAGE)
+  static constexpr IntegralType kCompressedSentinel =
+      SentinelPointer::kSentinelValue;
+#else   // !defined(CPPGC_2GB_CAGE)
+  static constexpr IntegralType kCompressedSentinel =
+      SentinelPointer::kSentinelValue >> 1;
+#endif  // !defined(CPPGC_2GB_CAGE)
+  // All constructors initialize `value_`. Do not add a default value here as it
+  // results in a non-atomic write on some builds, even when the atomic version
+  // of the constructor is used.
+  IntegralType value_;
+};
+
+#endif  // defined(CPPGC_POINTER_COMPRESSION)
+
+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) {}
+
+  V8_INLINE const void* Load() const { return ptr_; }
+  V8_INLINE const void* LoadAtomic() const {
+    return reinterpret_cast<const std::atomic<const void*>&>(ptr_).load(
+        std::memory_order_relaxed);
+  }
+
+  V8_INLINE void Store(const void* ptr) { ptr_ = ptr; }
+  V8_INLINE void StoreAtomic(const void* ptr) {
+    reinterpret_cast<std::atomic<const void*>&>(ptr_).store(
+        ptr, std::memory_order_relaxed);
+  }
+
+  V8_INLINE void Clear() { ptr_ = nullptr; }
+  V8_INLINE bool IsCleared() const { return !ptr_; }
+
+  V8_INLINE bool IsSentinel() const { return ptr_ == kSentinelPointer; }
+
+  V8_INLINE uintptr_t GetAsInteger() const {
+    return reinterpret_cast<uintptr_t>(ptr_);
+  }
+
+  V8_INLINE friend bool operator==(RawPointer a, RawPointer b) {
+    return a.ptr_ == b.ptr_;
+  }
+  V8_INLINE friend bool operator!=(RawPointer a, RawPointer b) {
+    return a.ptr_ != b.ptr_;
+  }
+  V8_INLINE friend bool operator<(RawPointer a, RawPointer b) {
+    return a.ptr_ < b.ptr_;
+  }
+  V8_INLINE friend bool operator<=(RawPointer a, RawPointer b) {
+    return a.ptr_ <= b.ptr_;
+  }
+  V8_INLINE friend bool operator>(RawPointer a, RawPointer b) {
+    return a.ptr_ > b.ptr_;
+  }
+  V8_INLINE friend bool operator>=(RawPointer a, RawPointer b) {
+    return a.ptr_ >= b.ptr_;
+  }
+
+ private:
+  // All constructors initialize `ptr_`. Do not add a default value here as it
+  // results in a non-atomic write on some builds, even when the atomic version
+  // of the constructor is used.
+  const void* ptr_;
+};
+
+#if defined(CPPGC_POINTER_COMPRESSION)
+using DefaultMemberStorage = CompressedPointer;
+#else   // !defined(CPPGC_POINTER_COMPRESSION)
+using DefaultMemberStorage = RawPointer;
+#endif  // !defined(CPPGC_POINTER_COMPRESSION)
+
+}  // namespace internal
+}  // namespace cppgc
+
+#endif  // INCLUDE_CPPGC_INTERNAL_MEMBER_STORAGE_H_

data/vendor/v8/include/cppgc/internal/name-trait.h

@@ -6,6 +6,7 @@
 #define INCLUDE_CPPGC_INTERNAL_NAME_TRAIT_H_
 
 #include <cstddef>
+#include <cstdint>
 #include <type_traits>
 
 #include "cppgc/name-provider.h"
@@ -58,6 +59,11 @@ struct HeapObjectName {
   bool name_was_hidden;
 };
 
+enum class HeapObjectNameForUnnamedObject : uint8_t {
+  kUseClassNameIfSupported,
+  kUseHiddenName,
+};
+
 class V8_EXPORT NameTraitBase {
  protected:
   static HeapObjectName GetNameFromTypeSignature(const char*);
@@ -78,16 +84,24 @@ class NameTrait final : public NameTraitBase {
 #endif  // !CPPGC_SUPPORTS_OBJECT_NAMES
   }
 
-  static HeapObjectName GetName(const void* obj) {
-    return GetNameFor(static_cast<const T*>(obj));
+  static HeapObjectName GetName(
+      const void* obj, HeapObjectNameForUnnamedObject name_retrieval_mode) {
+    return GetNameFor(static_cast<const T*>(obj), name_retrieval_mode);
   }
 
  private:
-  static HeapObjectName GetNameFor(const NameProvider* name_provider) {
+  static HeapObjectName GetNameFor(const NameProvider* name_provider,
+                                   HeapObjectNameForUnnamedObject) {
+    // Objects inheriting from `NameProvider` are not considered unnamed as
+    // users already provided a name for them.
     return {name_provider->GetHumanReadableName(), false};
   }
 
-  static HeapObjectName GetNameFor(...) {
+  static HeapObjectName GetNameFor(
+      const void*, HeapObjectNameForUnnamedObject name_retrieval_mode) {
+    if (name_retrieval_mode == HeapObjectNameForUnnamedObject::kUseHiddenName)
+      return {NameProvider::kHiddenName, true};
+
 #if CPPGC_SUPPORTS_COMPILE_TIME_TYPENAME
     return {GetTypename<T>(), false};
 #elif CPPGC_SUPPORTS_OBJECT_NAMES
@@ -102,7 +116,7 @@ class NameTrait final : public NameTraitBase {
 
     static const HeapObjectName leaky_name =
         GetNameFromTypeSignature(PRETTY_FUNCTION_VALUE);
-    return {leaky_name, false};
+    return leaky_name;
 
 #undef PRETTY_FUNCTION_VALUE
 
@@ -112,7 +126,8 @@ class NameTrait final : public NameTraitBase {
   }
 };
 
-using NameCallback = HeapObjectName (*)(const void*);
+using NameCallback = HeapObjectName (*)(const void*,
+                                        HeapObjectNameForUnnamedObject);
 
 }  // namespace internal
 }  // namespace cppgc

data/vendor/v8/include/cppgc/internal/persistent-node.h

@@ -14,13 +14,11 @@
 #include "v8config.h"  // NOLINT(build/include_directory)
 
 namespace cppgc {
-
-class Visitor;
-
 namespace internal {
 
 class CrossThreadPersistentRegion;
 class FatalOutOfMemoryHandler;
+class RootVisitor;
 
 // PersistentNode represents a variant of two states:
 // 1) traceable node with a back pointer to the Persistent object;
@@ -32,7 +30,7 @@ class PersistentNode final {
   PersistentNode(const PersistentNode&) = delete;
   PersistentNode& operator=(const PersistentNode&) = delete;
 
-  void InitializeAsUsedNode(void* owner, TraceCallback trace) {
+  void InitializeAsUsedNode(void* owner, TraceRootCallback trace) {
     CPPGC_DCHECK(trace);
     owner_ = owner;
     trace_ = trace;
@@ -53,9 +51,9 @@ class PersistentNode final {
     return next_;
   }
 
-  void Trace(Visitor* visitor) const {
+  void Trace(RootVisitor& root_visitor) const {
     CPPGC_DCHECK(IsUsed());
-    trace_(visitor, owner_);
+    trace_(root_visitor, owner_);
   }
 
   bool IsUsed() const { return trace_; }
@@ -73,7 +71,7 @@ class PersistentNode final {
     void* owner_ = nullptr;
     PersistentNode* next_;
   };
-  TraceCallback trace_ = nullptr;
+  TraceRootCallback trace_ = nullptr;
 };
 
 class V8_EXPORT PersistentRegionBase {
@@ -86,7 +84,7 @@ class V8_EXPORT PersistentRegionBase {
   PersistentRegionBase(const PersistentRegionBase&) = delete;
   PersistentRegionBase& operator=(const PersistentRegionBase&) = delete;
 
-  void Trace(Visitor*);
+  void Iterate(RootVisitor&);
 
   size_t NodesInUse() const;
 
@@ -96,7 +94,7 @@ class V8_EXPORT PersistentRegionBase {
   explicit PersistentRegionBase(const FatalOutOfMemoryHandler& oom_handler);
 
   PersistentNode* TryAllocateNodeFromFreeList(void* owner,
-                                              TraceCallback trace) {
+                                              TraceRootCallback trace) {
     PersistentNode* node = nullptr;
     if (V8_LIKELY(free_list_head_)) {
       node = free_list_head_;
@@ -118,7 +116,7 @@ class V8_EXPORT PersistentRegionBase {
   }
 
   PersistentNode* RefillFreeListAndAllocateNode(void* owner,
-                                                TraceCallback trace);
+                                                TraceRootCallback trace);
 
  private:
   template <typename PersistentBaseClass>
@@ -145,7 +143,7 @@ class V8_EXPORT PersistentRegion final : public PersistentRegionBase {
   PersistentRegion(const PersistentRegion&) = delete;
   PersistentRegion& operator=(const PersistentRegion&) = delete;
 
-  V8_INLINE PersistentNode* AllocateNode(void* owner, TraceCallback trace) {
+  V8_INLINE PersistentNode* AllocateNode(void* owner, TraceRootCallback trace) {
     CPPGC_DCHECK(IsCreationThread());
     auto* node = TryAllocateNodeFromFreeList(owner, trace);
     if (V8_LIKELY(node)) return node;
@@ -189,7 +187,7 @@ class V8_EXPORT CrossThreadPersistentRegion final
   CrossThreadPersistentRegion& operator=(const CrossThreadPersistentRegion&) =
       delete;
 
-  V8_INLINE PersistentNode* AllocateNode(void* owner, TraceCallback trace) {
+  V8_INLINE PersistentNode* AllocateNode(void* owner, TraceRootCallback trace) {
     PersistentRegionLock::AssertLocked();
     auto* node = TryAllocateNodeFromFreeList(owner, trace);
     if (V8_LIKELY(node)) return node;
@@ -202,7 +200,7 @@ class V8_EXPORT CrossThreadPersistentRegion final
     PersistentRegionBase::FreeNode(node);
   }
 
-  void Trace(Visitor*);
+  void Iterate(RootVisitor&);
 
   size_t NodesInUse() const;
 

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

@@ -8,6 +8,7 @@
 #include <cstdint>
 #include <type_traits>
 
+#include "cppgc/internal/member-storage.h"
 #include "cppgc/internal/write-barrier.h"
 #include "cppgc/sentinel-pointer.h"
 #include "cppgc/source-location.h"
@@ -27,15 +28,67 @@ class WeakMemberTag;
 class UntracedMemberTag;
 
 struct DijkstraWriteBarrierPolicy {
-  static void InitializingBarrier(const void*, const void*) {
+  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.
   }
-  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);
+#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,
+                                         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;
-    switch (WriteBarrier::GetWriteBarrierType(slot, value, 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,
+                                     const WriteBarrier::Params& params,
+                                     const void* slot, const void* value) {
+    switch (type) {
       case WriteBarrier::Type::kGenerational:
-        WriteBarrier::GenerationalBarrier(params, slot);
+        WriteBarrier::GenerationalBarrier<
+            WriteBarrier::GenerationalBarrierType::kPreciseSlot>(params, slot);
         break;
       case WriteBarrier::Type::kMarking:
         WriteBarrier::DijkstraMarkingBarrier(params, value);
@@ -47,8 +100,11 @@ struct DijkstraWriteBarrierPolicy {
 };
 
 struct NoWriteBarrierPolicy {
-  static void InitializingBarrier(const void*, const void*) {}
-  static void AssigningBarrier(const void*, const void*) {}
+  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) {}
 };
 
 class V8_EXPORT SameThreadEnabledCheckingPolicyBase {
@@ -89,7 +145,7 @@ class V8_EXPORT SameThreadEnabledCheckingPolicy
 
 class DisabledCheckingPolicy {
  protected:
-  void CheckPointer(const void*) {}
+  V8_INLINE void CheckPointer(const void*) {}
 };
 
 #ifdef DEBUG
@@ -176,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