libv8 8.4.255.0-universal-darwin-20

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

@@ -0,0 +1,304 @@
+// 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_PERSISTENT_H_
+#define INCLUDE_CPPGC_PERSISTENT_H_
+
+#include <type_traits>
+
+#include "cppgc/internal/persistent-node.h"
+#include "cppgc/internal/pointer-policies.h"
+#include "cppgc/source-location.h"
+#include "cppgc/type-traits.h"
+#include "cppgc/visitor.h"
+#include "v8config.h"  // NOLINT(build/include_directory)
+
+namespace cppgc {
+namespace internal {
+
+// The basic class from which all Persistent classes are generated.
+template <typename T, typename WeaknessPolicy, typename LocationPolicy,
+          typename CheckingPolicy>
+class BasicPersistent : public LocationPolicy,
+                        private WeaknessPolicy,
+                        private CheckingPolicy {
+ public:
+  using typename WeaknessPolicy::IsStrongPersistent;
+  using PointeeType = T;
+
+  // Null-state/sentinel constructors.
+  BasicPersistent(  // NOLINT
+      const SourceLocation& loc = SourceLocation::Current())
+      : LocationPolicy(loc) {}
+
+  BasicPersistent(std::nullptr_t,  // NOLINT
+                  const SourceLocation& loc = SourceLocation::Current())
+      : LocationPolicy(loc) {}
+
+  BasicPersistent(  // NOLINT
+      SentinelPointer s, const SourceLocation& loc = SourceLocation::Current())
+      : LocationPolicy(loc), raw_(s) {}
+
+  // Raw value contstructors.
+  BasicPersistent(T* raw,  // NOLINT
+                  const SourceLocation& loc = SourceLocation::Current())
+      : LocationPolicy(loc), raw_(raw) {
+    if (!IsValid()) return;
+    node_ = WeaknessPolicy::GetPersistentRegion(raw_).AllocateNode(
+        this, &BasicPersistent::Trace);
+    this->CheckPointer(Get());
+  }
+
+  BasicPersistent(T& raw,  // NOLINT
+                  const SourceLocation& loc = SourceLocation::Current())
+      : BasicPersistent(&raw, loc) {}
+
+  // Copy ctor.
+  BasicPersistent(const BasicPersistent& other,
+                  const SourceLocation& loc = SourceLocation::Current())
+      : BasicPersistent(other.Get(), loc) {}
+
+  // Heterogeneous ctor.
+  template <typename U, typename OtherWeaknessPolicy,
+            typename OtherLocationPolicy, typename OtherCheckingPolicy,
+            typename = std::enable_if_t<std::is_base_of<T, U>::value>>
+  BasicPersistent(  // NOLINT
+      const BasicPersistent<U, OtherWeaknessPolicy, OtherLocationPolicy,
+                            OtherCheckingPolicy>& other,
+      const SourceLocation& loc = SourceLocation::Current())
+      : BasicPersistent(other.Get(), loc) {}
+
+  // Move ctor. The heterogeneous move ctor is not supported since e.g.
+  // persistent can't reuse persistent node from weak persistent.
+  BasicPersistent(
+      BasicPersistent&& other,
+      const SourceLocation& loc = SourceLocation::Current()) noexcept
+      : LocationPolicy(std::move(other)),
+        raw_(std::move(other.raw_)),
+        node_(std::move(other.node_)) {
+    if (!IsValid()) return;
+    node_->UpdateOwner(this);
+    other.raw_ = nullptr;
+    other.node_ = nullptr;
+    this->CheckPointer(Get());
+  }
+
+  // Constructor from member.
+  template <typename U, typename MemberBarrierPolicy,
+            typename MemberWeaknessTag, typename MemberCheckingPolicy,
+            typename = std::enable_if_t<std::is_base_of<T, U>::value>>
+  BasicPersistent(internal::BasicMember<U, MemberBarrierPolicy,  // NOLINT
+                                        MemberWeaknessTag, MemberCheckingPolicy>
+                      member,
+                  const SourceLocation& loc = SourceLocation::Current())
+      : BasicPersistent(member.Get(), loc) {}
+
+  ~BasicPersistent() { Clear(); }
+
+  // Copy assignment.
+  BasicPersistent& operator=(const BasicPersistent& other) {
+    return operator=(other.Get());
+  }
+
+  template <typename U, typename OtherWeaknessPolicy,
+            typename OtherLocationPolicy, typename OtherCheckingPolicy,
+            typename = std::enable_if_t<std::is_base_of<T, U>::value>>
+  BasicPersistent& operator=(
+      const BasicPersistent<U, OtherWeaknessPolicy, OtherLocationPolicy,
+                            OtherCheckingPolicy>& other) {
+    return operator=(other.Get());
+  }
+
+  // Move assignment.
+  BasicPersistent& operator=(BasicPersistent&& other) {
+    if (this == &other) return *this;
+    Clear();
+    LocationPolicy::operator=(std::move(other));
+    raw_ = std::move(other.raw_);
+    node_ = std::move(other.node_);
+    if (!IsValid()) return *this;
+    node_->UpdateOwner(this);
+    other.raw_ = nullptr;
+    other.node_ = nullptr;
+    this->CheckPointer(Get());
+    return *this;
+  }
+
+  // Assignment from member.
+  template <typename U, typename MemberBarrierPolicy,
+            typename MemberWeaknessTag, typename MemberCheckingPolicy,
+            typename = std::enable_if_t<std::is_base_of<T, U>::value>>
+  BasicPersistent& operator=(
+      internal::BasicMember<U, MemberBarrierPolicy, MemberWeaknessTag,
+                            MemberCheckingPolicy>
+          member) {
+    return operator=(member.Get());
+  }
+
+  BasicPersistent& operator=(T* other) {
+    Assign(other);
+    return *this;
+  }
+
+  BasicPersistent& operator=(std::nullptr_t) {
+    Clear();
+    return *this;
+  }
+
+  BasicPersistent& operator=(SentinelPointer s) {
+    Assign(s);
+    return *this;
+  }
+
+  explicit operator bool() const { return Get(); }
+  operator T*() const { return Get(); }
+  T* operator->() const { return Get(); }
+  T& operator*() const { return *Get(); }
+
+  T* Get() const { return raw_; }
+
+  void Clear() { Assign(nullptr); }
+
+  T* Release() {
+    T* result = Get();
+    Clear();
+    return result;
+  }
+
+ private:
+  static void Trace(Visitor* v, const void* ptr) {
+    const auto* persistent = static_cast<const BasicPersistent*>(ptr);
+    v->TraceRoot(*persistent, persistent->Location());
+  }
+
+  bool IsValid() const {
+    // Ideally, handling kSentinelPointer would be done by the embedder. On the
+    // other hand, having Persistent aware of it is beneficial since no node
+    // gets wasted.
+    return raw_ != nullptr && raw_ != kSentinelPointer;
+  }
+
+  void Assign(T* ptr) {
+    if (IsValid()) {
+      if (ptr && ptr != kSentinelPointer) {
+        // Simply assign the pointer reusing the existing node.
+        raw_ = ptr;
+        this->CheckPointer(ptr);
+        return;
+      }
+      WeaknessPolicy::GetPersistentRegion(raw_).FreeNode(node_);
+      node_ = nullptr;
+    }
+    raw_ = ptr;
+    if (!IsValid()) return;
+    node_ = WeaknessPolicy::GetPersistentRegion(raw_).AllocateNode(
+        this, &BasicPersistent::Trace);
+    this->CheckPointer(Get());
+  }
+
+  T* raw_ = nullptr;
+  PersistentNode* node_ = nullptr;
+};
+
+template <typename T1, typename WeaknessPolicy1, typename LocationPolicy1,
+          typename CheckingPolicy1, typename T2, typename WeaknessPolicy2,
+          typename LocationPolicy2, typename CheckingPolicy2>
+bool operator==(const BasicPersistent<T1, WeaknessPolicy1, LocationPolicy1,
+                                      CheckingPolicy1>& p1,
+                const BasicPersistent<T2, WeaknessPolicy2, LocationPolicy2,
+                                      CheckingPolicy2>& p2) {
+  return p1.Get() == p2.Get();
+}
+
+template <typename T1, typename WeaknessPolicy1, typename LocationPolicy1,
+          typename CheckingPolicy1, typename T2, typename WeaknessPolicy2,
+          typename LocationPolicy2, typename CheckingPolicy2>
+bool operator!=(const BasicPersistent<T1, WeaknessPolicy1, LocationPolicy1,
+                                      CheckingPolicy1>& p1,
+                const BasicPersistent<T2, WeaknessPolicy2, LocationPolicy2,
+                                      CheckingPolicy2>& p2) {
+  return !(p1 == p2);
+}
+
+template <typename T1, typename PersistentWeaknessPolicy,
+          typename PersistentLocationPolicy, typename PersistentCheckingPolicy,
+          typename T2, typename MemberWriteBarrierPolicy,
+          typename MemberWeaknessTag, typename MemberCheckingPolicy>
+bool operator==(const BasicPersistent<T1, PersistentWeaknessPolicy,
+                                      PersistentLocationPolicy,
+                                      PersistentCheckingPolicy>& p,
+                BasicMember<T2, MemberWeaknessTag, MemberWriteBarrierPolicy,
+                            MemberCheckingPolicy>
+                    m) {
+  return p.Get() == m.Get();
+}
+
+template <typename T1, typename PersistentWeaknessPolicy,
+          typename PersistentLocationPolicy, typename PersistentCheckingPolicy,
+          typename T2, typename MemberWriteBarrierPolicy,
+          typename MemberWeaknessTag, typename MemberCheckingPolicy>
+bool operator!=(const BasicPersistent<T1, PersistentWeaknessPolicy,
+                                      PersistentLocationPolicy,
+                                      PersistentCheckingPolicy>& p,
+                BasicMember<T2, MemberWeaknessTag, MemberWriteBarrierPolicy,
+                            MemberCheckingPolicy>
+                    m) {
+  return !(p == m);
+}
+
+template <typename T1, typename MemberWriteBarrierPolicy,
+          typename MemberWeaknessTag, typename MemberCheckingPolicy,
+          typename T2, typename PersistentWeaknessPolicy,
+          typename PersistentLocationPolicy, typename PersistentCheckingPolicy>
+bool operator==(BasicMember<T2, MemberWeaknessTag, MemberWriteBarrierPolicy,
+                            MemberCheckingPolicy>
+                    m,
+                const BasicPersistent<T1, PersistentWeaknessPolicy,
+                                      PersistentLocationPolicy,
+                                      PersistentCheckingPolicy>& p) {
+  return m.Get() == p.Get();
+}
+
+template <typename T1, typename MemberWriteBarrierPolicy,
+          typename MemberWeaknessTag, typename MemberCheckingPolicy,
+          typename T2, typename PersistentWeaknessPolicy,
+          typename PersistentLocationPolicy, typename PersistentCheckingPolicy>
+bool operator!=(BasicMember<T2, MemberWeaknessTag, MemberWriteBarrierPolicy,
+                            MemberCheckingPolicy>
+                    m,
+                const BasicPersistent<T1, PersistentWeaknessPolicy,
+                                      PersistentLocationPolicy,
+                                      PersistentCheckingPolicy>& p) {
+  return !(m == p);
+}
+
+template <typename T, typename LocationPolicy, typename CheckingPolicy>
+struct IsWeak<BasicPersistent<T, internal::WeakPersistentPolicy, LocationPolicy,
+                              CheckingPolicy>> : std::true_type {};
+}  // namespace internal
+
+/**
+ * Persistent is a way to create a strong pointer from an off-heap object to
+ * another on-heap object. As long as the Persistent handle is alive the GC will
+ * keep the object pointed to alive. The Persistent handle is always a GC root
+ * from the point of view of the GC. Persistent must be constructed and
+ * destructed in the same thread.
+ */
+template <typename T>
+using Persistent =
+    internal::BasicPersistent<T, internal::StrongPersistentPolicy>;
+
+/**
+ * WeakPersistent is a way to create a weak pointer from an off-heap object to
+ * an on-heap object. The pointer is automatically cleared when the pointee gets
+ * collected. WeakPersistent must be constructed and destructed in the same
+ * thread.
+ */
+template <typename T>
+using WeakPersistent =
+    internal::BasicPersistent<T, internal::WeakPersistentPolicy>;
+
+}  // namespace cppgc
+
+#endif  // INCLUDE_CPPGC_PERSISTENT_H_

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

@@ -0,0 +1,31 @@
+// 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_PLATFORM_H_
+#define INCLUDE_CPPGC_PLATFORM_H_
+
+#include "v8-platform.h"  // NOLINT(build/include_directory)
+#include "v8config.h"     // NOLINT(build/include_directory)
+
+namespace cppgc {
+
+// TODO(v8:10346): Put PageAllocator in a non-V8 include header to avoid
+// depending on namespace v8.
+using PageAllocator = v8::PageAllocator;
+
+// Initializes the garbage collector with the provided platform. Must be called
+// before creating a Heap.
+V8_EXPORT void InitializePlatform(PageAllocator* page_allocator);
+
+// Must be called after destroying the last used heap.
+V8_EXPORT void ShutdownPlatform();
+
+namespace internal {
+
+V8_EXPORT void Abort();
+
+}  // namespace internal
+}  // namespace cppgc
+
+#endif  // INCLUDE_CPPGC_PLATFORM_H_

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

@@ -0,0 +1,54 @@
+// 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_PREFINALIZER_H_
+#define INCLUDE_CPPGC_PREFINALIZER_H_
+
+#include "cppgc/internal/accessors.h"
+#include "cppgc/internal/compiler-specific.h"
+#include "cppgc/internal/prefinalizer-handler.h"
+#include "cppgc/liveness-broker.h"
+#include "cppgc/macros.h"
+
+namespace cppgc {
+
+namespace internal {
+
+template <typename T>
+class PrefinalizerRegistration final {
+ public:
+  explicit PrefinalizerRegistration(T* self) {
+    static_assert(sizeof(&T::InvokePreFinalizer) > 0,
+                  "USING_PRE_FINALIZER(T) must be defined.");
+
+    cppgc::internal::PreFinalizerRegistrationDispatcher::RegisterPrefinalizer(
+        internal::GetHeapFromPayload(self), {self, T::InvokePreFinalizer});
+  }
+
+  void* operator new(size_t, void* location) = delete;
+  void* operator new(size_t) = delete;
+};
+
+}  // namespace internal
+
+#define CPPGC_USING_PRE_FINALIZER(Class, PreFinalizer)                      \
+ public:                                                                    \
+  static bool InvokePreFinalizer(const LivenessBroker& liveness_broker,     \
+                                 void* object) {                            \
+    static_assert(internal::IsGarbageCollectedTypeV<Class>,                 \
+                  "Only garbage collected objects can have prefinalizers"); \
+    Class* self = static_cast<Class*>(object);                              \
+    if (liveness_broker.IsHeapObjectAlive(self)) return false;              \
+    self->Class::PreFinalizer();                                            \
+    return true;                                                            \
+  }                                                                         \
+                                                                            \
+ private:                                                                   \
+  CPPGC_NO_UNIQUE_ADDRESS internal::PrefinalizerRegistration<Class>         \
+      prefinalizer_dummy_{this};                                            \
+  friend class internal::__thisIsHereToForceASemicolonAfterThisMacro
+
+}  // namespace cppgc
+
+#endif  // INCLUDE_CPPGC_PREFINALIZER_H_

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

@@ -0,0 +1,59 @@
+// 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_SOURCE_LOCATION_H_
+#define INCLUDE_CPPGC_SOURCE_LOCATION_H_
+
+#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
+
+namespace cppgc {
+
+// Encapsulates source location information. Mimics C++20's
+// std::source_location.
+class V8_EXPORT SourceLocation final {
+ public:
+#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
+
+  constexpr SourceLocation() = default;
+
+  constexpr const char* Function() const { return function_; }
+  constexpr const char* FileName() const { return file_; }
+  constexpr size_t Line() const { return line_; }
+
+  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;
+};
+
+}  // namespace cppgc
+
+#endif  // INCLUDE_CPPGC_SOURCE_LOCATION_H_