libv8-node 15.5.1.0.beta1-aarch64-linux-musl

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

@@ -0,0 +1,90 @@
+// Copyright 2020 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_FINALIZER_TRAIT_H_
+#define INCLUDE_CPPGC_INTERNAL_FINALIZER_TRAIT_H_
+
+#include <type_traits>
+
+#include "cppgc/type-traits.h"
+
+namespace cppgc {
+namespace internal {
+
+using FinalizationCallback = void (*)(void*);
+
+template <typename T, typename = void>
+struct HasFinalizeGarbageCollectedObject : std::false_type {};
+
+template <typename T>
+struct HasFinalizeGarbageCollectedObject<
+    T, void_t<decltype(std::declval<T>().FinalizeGarbageCollectedObject())>>
+    : std::true_type {};
+
+// The FinalizerTraitImpl specifies how to finalize objects.
+template <typename T, bool isFinalized>
+struct FinalizerTraitImpl;
+
+template <typename T>
+struct FinalizerTraitImpl<T, true> {
+ private:
+  // Dispatch to custom FinalizeGarbageCollectedObject().
+  struct Custom {
+    static void Call(void* obj) {
+      static_cast<T*>(obj)->FinalizeGarbageCollectedObject();
+    }
+  };
+
+  // Dispatch to regular destructor.
+  struct Destructor {
+    static void Call(void* obj) { static_cast<T*>(obj)->~T(); }
+  };
+
+  using FinalizeImpl =
+      std::conditional_t<HasFinalizeGarbageCollectedObject<T>::value, Custom,
+                         Destructor>;
+
+ public:
+  static void Finalize(void* obj) {
+    static_assert(sizeof(T), "T must be fully defined");
+    FinalizeImpl::Call(obj);
+  }
+};
+
+template <typename T>
+struct FinalizerTraitImpl<T, false> {
+  static void Finalize(void* obj) {
+    static_assert(sizeof(T), "T must be fully defined");
+  }
+};
+
+// The FinalizerTrait is used to determine if a type requires finalization and
+// what finalization means.
+template <typename T>
+struct FinalizerTrait {
+ private:
+  // Object has a finalizer if it has
+  // - a custom FinalizeGarbageCollectedObject method, or
+  // - a destructor.
+  static constexpr bool kNonTrivialFinalizer =
+      internal::HasFinalizeGarbageCollectedObject<T>::value ||
+      !std::is_trivially_destructible<typename std::remove_cv<T>::type>::value;
+
+  static void Finalize(void* obj) {
+    internal::FinalizerTraitImpl<T, kNonTrivialFinalizer>::Finalize(obj);
+  }
+
+ public:
+  // The callback used to finalize an object of type T.
+  static constexpr FinalizationCallback kCallback =
+      kNonTrivialFinalizer ? Finalize : nullptr;
+};
+
+template <typename T>
+constexpr FinalizationCallback FinalizerTrait<T>::kCallback;
+
+}  // namespace internal
+}  // namespace cppgc
+
+#endif  // INCLUDE_CPPGC_INTERNAL_FINALIZER_TRAIT_H_

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

@@ -0,0 +1,45 @@
+// Copyright 2020 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_GC_INFO_H_
+#define INCLUDE_CPPGC_INTERNAL_GC_INFO_H_
+
+#include <stdint.h>
+
+#include "cppgc/internal/finalizer-trait.h"
+#include "cppgc/trace-trait.h"
+#include "v8config.h"  // NOLINT(build/include_directory)
+
+namespace cppgc {
+namespace internal {
+
+using GCInfoIndex = uint16_t;
+
+class V8_EXPORT RegisteredGCInfoIndex final {
+ public:
+  RegisteredGCInfoIndex(FinalizationCallback finalization_callback,
+                        TraceCallback trace_callback, bool has_v_table);
+  GCInfoIndex GetIndex() const { return index_; }
+
+ private:
+  const GCInfoIndex index_;
+};
+
+// Trait determines how the garbage collector treats objects wrt. to traversing,
+// finalization, and naming.
+template <typename T>
+struct GCInfoTrait {
+  static GCInfoIndex Index() {
+    static_assert(sizeof(T), "T must be fully defined");
+    static const RegisteredGCInfoIndex registered_index(
+        FinalizerTrait<T>::kCallback, TraceTrait<T>::Trace,
+        std::is_polymorphic<T>::value);
+    return registered_index.GetIndex();
+  }
+};
+
+}  // namespace internal
+}  // namespace cppgc
+
+#endif  // INCLUDE_CPPGC_INTERNAL_GC_INFO_H_

data/vendor/v8/include/cppgc/internal/logging.h

@@ -0,0 +1,50 @@
+// Copyright 2020 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_LOGGING_H_
+#define INCLUDE_CPPGC_INTERNAL_LOGGING_H_
+
+#include "cppgc/source-location.h"
+#include "v8config.h"  // NOLINT(build/include_directory)
+
+namespace cppgc {
+namespace internal {
+
+void V8_EXPORT DCheckImpl(const char*,
+                          const SourceLocation& = SourceLocation::Current());
+[[noreturn]] void V8_EXPORT
+FatalImpl(const char*, const SourceLocation& = SourceLocation::Current());
+
+// Used to ignore -Wunused-variable.
+template <typename>
+struct EatParams {};
+
+#if DEBUG
+#define CPPGC_DCHECK_MSG(condition, message)  \
+  do {                                        \
+    if (V8_UNLIKELY(!(condition))) {          \
+      ::cppgc::internal::DCheckImpl(message); \
+    }                                         \
+  } while (false)
+#else
+#define CPPGC_DCHECK_MSG(condition, message)                \
+  (static_cast<void>(::cppgc::internal::EatParams<decltype( \
+                         static_cast<void>(condition), message)>{}))
+#endif
+
+#define CPPGC_DCHECK(condition) CPPGC_DCHECK_MSG(condition, #condition)
+
+#define CPPGC_CHECK_MSG(condition, message)  \
+  do {                                       \
+    if (V8_UNLIKELY(!(condition))) {         \
+      ::cppgc::internal::FatalImpl(message); \
+    }                                        \
+  } while (false)
+
+#define CPPGC_CHECK(condition) CPPGC_CHECK_MSG(condition, #condition)
+
+}  // namespace internal
+}  // namespace cppgc
+
+#endif  // INCLUDE_CPPGC_INTERNAL_LOGGING_H_

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

@@ -0,0 +1,116 @@
+// Copyright 2020 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_PERSISTENT_NODE_H_
+#define INCLUDE_CPPGC_INTERNAL_PERSISTENT_NODE_H_
+
+#include <array>
+#include <memory>
+#include <vector>
+
+#include "cppgc/internal/logging.h"
+#include "cppgc/trace-trait.h"
+#include "v8config.h"  // NOLINT(build/include_directory)
+
+namespace cppgc {
+
+class Visitor;
+
+namespace internal {
+
+// PersistentNode represesents a variant of two states:
+// 1) traceable node with a back pointer to the Persistent object;
+// 2) freelist entry.
+class PersistentNode final {
+ public:
+  PersistentNode() = default;
+
+  PersistentNode(const PersistentNode&) = delete;
+  PersistentNode& operator=(const PersistentNode&) = delete;
+
+  void InitializeAsUsedNode(void* owner, TraceCallback trace) {
+    owner_ = owner;
+    trace_ = trace;
+  }
+
+  void InitializeAsFreeNode(PersistentNode* next) {
+    next_ = next;
+    trace_ = nullptr;
+  }
+
+  void UpdateOwner(void* owner) {
+    CPPGC_DCHECK(IsUsed());
+    owner_ = owner;
+  }
+
+  PersistentNode* FreeListNext() const {
+    CPPGC_DCHECK(!IsUsed());
+    return next_;
+  }
+
+  void Trace(Visitor* visitor) const {
+    CPPGC_DCHECK(IsUsed());
+    trace_(visitor, owner_);
+  }
+
+  bool IsUsed() const { return trace_; }
+
+  void* owner() const {
+    CPPGC_DCHECK(IsUsed());
+    return owner_;
+  }
+
+ private:
+  // PersistentNode acts as a designated union:
+  // If trace_ != nullptr, owner_ points to the corresponding Persistent handle.
+  // Otherwise, next_ points to the next freed PersistentNode.
+  union {
+    void* owner_ = nullptr;
+    PersistentNode* next_;
+  };
+  TraceCallback trace_ = nullptr;
+};
+
+class V8_EXPORT PersistentRegion final {
+  using PersistentNodeSlots = std::array<PersistentNode, 256u>;
+
+ public:
+  PersistentRegion() = default;
+  // Clears Persistent fields to avoid stale pointers after heap teardown.
+  ~PersistentRegion();
+
+  PersistentRegion(const PersistentRegion&) = delete;
+  PersistentRegion& operator=(const PersistentRegion&) = delete;
+
+  PersistentNode* AllocateNode(void* owner, TraceCallback trace) {
+    if (!free_list_head_) {
+      EnsureNodeSlots();
+    }
+    PersistentNode* node = free_list_head_;
+    free_list_head_ = free_list_head_->FreeListNext();
+    node->InitializeAsUsedNode(owner, trace);
+    return node;
+  }
+
+  void FreeNode(PersistentNode* node) {
+    node->InitializeAsFreeNode(free_list_head_);
+    free_list_head_ = node;
+  }
+
+  void Trace(Visitor*);
+
+  size_t NodesInUse() const;
+
+ private:
+  void EnsureNodeSlots();
+
+  std::vector<std::unique_ptr<PersistentNodeSlots>> nodes_;
+  PersistentNode* free_list_head_ = nullptr;
+};
+
+}  // namespace internal
+
+}  // namespace cppgc
+
+#endif  // INCLUDE_CPPGC_INTERNAL_PERSISTENT_NODE_H_

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

@@ -0,0 +1,134 @@
+// Copyright 2020 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_POINTER_POLICIES_H_
+#define INCLUDE_CPPGC_INTERNAL_POINTER_POLICIES_H_
+
+#include <cstdint>
+#include <type_traits>
+
+#include "cppgc/internal/write-barrier.h"
+#include "cppgc/source-location.h"
+#include "v8config.h"  // NOLINT(build/include_directory)
+
+namespace cppgc {
+namespace internal {
+
+class PersistentRegion;
+
+// Tags to distinguish between strong and weak member types.
+class StrongMemberTag;
+class WeakMemberTag;
+class UntracedMemberTag;
+
+struct DijkstraWriteBarrierPolicy {
+  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) {
+    WriteBarrier::MarkingBarrier(slot, value);
+  }
+};
+
+struct NoWriteBarrierPolicy {
+  static void InitializingBarrier(const void*, const void*) {}
+  static void AssigningBarrier(const void*, const void*) {}
+};
+
+class V8_EXPORT EnabledCheckingPolicy {
+ protected:
+  EnabledCheckingPolicy();
+  void CheckPointer(const void* ptr);
+
+ private:
+  void* impl_;
+};
+
+class DisabledCheckingPolicy {
+ protected:
+  void CheckPointer(const void* raw) {}
+};
+
+#if V8_ENABLE_CHECKS
+using DefaultCheckingPolicy = EnabledCheckingPolicy;
+#else
+using DefaultCheckingPolicy = DisabledCheckingPolicy;
+#endif
+
+class KeepLocationPolicy {
+ public:
+  constexpr const SourceLocation& Location() const { return location_; }
+
+ protected:
+  constexpr explicit KeepLocationPolicy(const SourceLocation& location)
+      : location_(location) {}
+
+  // KeepLocationPolicy must not copy underlying source locations.
+  KeepLocationPolicy(const KeepLocationPolicy&) = delete;
+  KeepLocationPolicy& operator=(const KeepLocationPolicy&) = delete;
+
+  // Location of the original moved from object should be preserved.
+  KeepLocationPolicy(KeepLocationPolicy&&) = default;
+  KeepLocationPolicy& operator=(KeepLocationPolicy&&) = default;
+
+ private:
+  SourceLocation location_;
+};
+
+class IgnoreLocationPolicy {
+ public:
+  constexpr SourceLocation Location() const { return {}; }
+
+ protected:
+  constexpr explicit IgnoreLocationPolicy(const SourceLocation&) {}
+};
+
+#if CPPGC_SUPPORTS_OBJECT_NAMES
+using DefaultLocationPolicy = KeepLocationPolicy;
+#else
+using DefaultLocationPolicy = IgnoreLocationPolicy;
+#endif
+
+struct StrongPersistentPolicy {
+  using IsStrongPersistent = std::true_type;
+
+  static V8_EXPORT PersistentRegion& GetPersistentRegion(void* object);
+};
+
+struct WeakPersistentPolicy {
+  using IsStrongPersistent = std::false_type;
+
+  static V8_EXPORT PersistentRegion& GetPersistentRegion(void* object);
+};
+
+// Persistent/Member forward declarations.
+template <typename T, typename WeaknessPolicy,
+          typename LocationPolicy = DefaultLocationPolicy,
+          typename CheckingPolicy = DefaultCheckingPolicy>
+class BasicPersistent;
+template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
+          typename CheckingPolicy = DefaultCheckingPolicy>
+class BasicMember;
+
+// Special tag type used to denote some sentinel member. The semantics of the
+// sentinel is defined by the embedder.
+struct SentinelPointer {
+  template <typename T>
+  operator T*() const {  // NOLINT
+    static constexpr intptr_t kSentinelValue = 1;
+    return reinterpret_cast<T*>(kSentinelValue);
+  }
+  // Hidden friends.
+  friend bool operator==(SentinelPointer, SentinelPointer) { return true; }
+  friend bool operator!=(SentinelPointer, SentinelPointer) { return false; }
+};
+
+}  // namespace internal
+
+constexpr internal::SentinelPointer kSentinelPointer;
+
+}  // namespace cppgc
+
+#endif  // INCLUDE_CPPGC_INTERNAL_POINTER_POLICIES_H_

data/vendor/v8/include/cppgc/internal/prefinalizer-handler.h

@@ -0,0 +1,30 @@
+// Copyright 2020 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_PREFINALIZER_HANDLER_H_
+#define INCLUDE_CPPGC_INTERNAL_PREFINALIZER_HANDLER_H_
+
+#include "cppgc/heap.h"
+#include "cppgc/liveness-broker.h"
+
+namespace cppgc {
+namespace internal {
+
+class V8_EXPORT PreFinalizerRegistrationDispatcher final {
+ public:
+  using PreFinalizerCallback = bool (*)(const LivenessBroker&, void*);
+  struct PreFinalizer {
+    void* object;
+    PreFinalizerCallback callback;
+
+    bool operator==(const PreFinalizer& other);
+  };
+
+  static void RegisterPrefinalizer(PreFinalizer pre_finalizer);
+};
+
+}  // namespace internal
+}  // namespace cppgc
+
+#endif  // INCLUDE_CPPGC_INTERNAL_PREFINALIZER_HANDLER_H_