libv8 7.3.492.27.1-universal-darwin-18 → 8.4.255.0-universal-darwin-18

Sign up to get free protection for your applications and to get access to all the features.
Files changed (48) hide show
  1. checksums.yaml +4 -4
  2. data/lib/libv8/version.rb +1 -1
  3. data/vendor/v8/include/cppgc/allocation.h +124 -0
  4. data/vendor/v8/include/cppgc/garbage-collected.h +192 -0
  5. data/vendor/v8/include/cppgc/heap.h +50 -0
  6. data/vendor/v8/include/cppgc/internal/accessors.h +26 -0
  7. data/vendor/v8/include/cppgc/internal/api-constants.h +44 -0
  8. data/vendor/v8/include/cppgc/internal/compiler-specific.h +26 -0
  9. data/vendor/v8/include/cppgc/internal/finalizer-trait.h +90 -0
  10. data/vendor/v8/include/cppgc/internal/gc-info.h +43 -0
  11. data/vendor/v8/include/cppgc/internal/logging.h +50 -0
  12. data/vendor/v8/include/cppgc/internal/persistent-node.h +109 -0
  13. data/vendor/v8/include/cppgc/internal/pointer-policies.h +133 -0
  14. data/vendor/v8/include/cppgc/internal/prefinalizer-handler.h +31 -0
  15. data/vendor/v8/include/cppgc/liveness-broker.h +50 -0
  16. data/vendor/v8/include/cppgc/macros.h +26 -0
  17. data/vendor/v8/include/cppgc/member.h +206 -0
  18. data/vendor/v8/include/cppgc/persistent.h +304 -0
  19. data/vendor/v8/include/cppgc/platform.h +31 -0
  20. data/vendor/v8/include/cppgc/prefinalizer.h +54 -0
  21. data/vendor/v8/include/cppgc/source-location.h +59 -0
  22. data/vendor/v8/include/cppgc/trace-trait.h +67 -0
  23. data/vendor/v8/include/cppgc/type-traits.h +109 -0
  24. data/vendor/v8/include/cppgc/visitor.h +137 -0
  25. data/vendor/v8/include/libplatform/libplatform.h +13 -19
  26. data/vendor/v8/include/libplatform/v8-tracing.h +50 -15
  27. data/vendor/v8/include/v8-fast-api-calls.h +412 -0
  28. data/vendor/v8/include/v8-inspector-protocol.h +4 -4
  29. data/vendor/v8/include/v8-inspector.h +60 -29
  30. data/vendor/v8/include/v8-internal.h +98 -82
  31. data/vendor/v8/include/v8-platform.h +181 -42
  32. data/vendor/v8/include/v8-profiler.h +162 -224
  33. data/vendor/v8/include/v8-util.h +1 -13
  34. data/vendor/v8/include/v8-version-string.h +1 -1
  35. data/vendor/v8/include/v8-version.h +4 -4
  36. data/vendor/v8/include/v8-wasm-trap-handler-posix.h +1 -1
  37. data/vendor/v8/include/v8-wasm-trap-handler-win.h +1 -1
  38. data/vendor/v8/include/v8.h +1990 -611
  39. data/vendor/v8/include/v8config.h +129 -48
  40. data/vendor/v8/out.gn/libv8/obj/libv8_libbase.a +0 -0
  41. data/vendor/v8/out.gn/libv8/obj/libv8_libplatform.a +0 -0
  42. data/vendor/v8/out.gn/libv8/obj/libv8_monolith.a +0 -0
  43. data/vendor/v8/out.gn/libv8/obj/third_party/icu/libicui18n.a +0 -0
  44. data/vendor/v8/out.gn/libv8/obj/third_party/icu/libicuuc.a +0 -0
  45. data/vendor/v8/out.gn/libv8/obj/third_party/zlib/google/libcompression_utils_portable.a +0 -0
  46. data/vendor/v8/out.gn/libv8/obj/third_party/zlib/libchrome_zlib.a +0 -0
  47. metadata +34 -8
  48. data/vendor/v8/include/v8-testing.h +0 -48
@@ -0,0 +1,31 @@
1
+ // Copyright 2020 the V8 project authors. All rights reserved.
2
+ // Use of this source code is governed by a BSD-style license that can be
3
+ // found in the LICENSE file.
4
+
5
+ #ifndef INCLUDE_CPPGC_INTERNAL_PREFINALIZER_HANDLER_H_
6
+ #define INCLUDE_CPPGC_INTERNAL_PREFINALIZER_HANDLER_H_
7
+
8
+ #include "cppgc/heap.h"
9
+ #include "cppgc/liveness-broker.h"
10
+
11
+ namespace cppgc {
12
+ namespace internal {
13
+
14
+ class V8_EXPORT PreFinalizerRegistrationDispatcher final {
15
+ public:
16
+ using PreFinalizerCallback = bool (*)(const LivenessBroker&, void*);
17
+ struct PreFinalizer {
18
+ void* object_;
19
+ PreFinalizerCallback callback_;
20
+
21
+ bool operator==(const PreFinalizer& other);
22
+ };
23
+
24
+ static void RegisterPrefinalizer(cppgc::Heap* heap,
25
+ PreFinalizer prefinalzier);
26
+ };
27
+
28
+ } // namespace internal
29
+ } // namespace cppgc
30
+
31
+ #endif // INCLUDE_CPPGC_INTERNAL_PREFINALIZER_HANDLER_H_
@@ -0,0 +1,50 @@
1
+ // Copyright 2020 the V8 project authors. All rights reserved.
2
+ // Use of this source code is governed by a BSD-style license that can be
3
+ // found in the LICENSE file.
4
+
5
+ #ifndef INCLUDE_CPPGC_LIVENESS_BROKER_H_
6
+ #define INCLUDE_CPPGC_LIVENESS_BROKER_H_
7
+
8
+ #include "cppgc/heap.h"
9
+ #include "cppgc/member.h"
10
+ #include "cppgc/trace-trait.h"
11
+ #include "v8config.h" // NOLINT(build/include_directory)
12
+
13
+ namespace cppgc {
14
+
15
+ namespace internal {
16
+ class LivenessBrokerFactory;
17
+ } // namespace internal
18
+
19
+ class V8_EXPORT LivenessBroker final {
20
+ public:
21
+ template <typename T>
22
+ bool IsHeapObjectAlive(const T* object) const {
23
+ return object &&
24
+ IsHeapObjectAliveImpl(
25
+ TraceTrait<T>::GetTraceDescriptor(object).base_object_payload);
26
+ }
27
+
28
+ template <typename T>
29
+ bool IsHeapObjectAlive(const WeakMember<T>& weak_member) const {
30
+ return (weak_member != kSentinelPointer) &&
31
+ IsHeapObjectAlive<T>(weak_member.Get());
32
+ }
33
+
34
+ template <typename T>
35
+ bool IsHeapObjectAlive(const UntracedMember<T>& untraced_member) const {
36
+ return (untraced_member != kSentinelPointer) &&
37
+ IsHeapObjectAlive<T>(untraced_member.Get());
38
+ }
39
+
40
+ private:
41
+ LivenessBroker() = default;
42
+
43
+ bool IsHeapObjectAliveImpl(const void*) const;
44
+
45
+ friend class internal::LivenessBrokerFactory;
46
+ };
47
+
48
+ } // namespace cppgc
49
+
50
+ #endif // INCLUDE_CPPGC_LIVENESS_BROKER_H_
@@ -0,0 +1,26 @@
1
+ // Copyright 2020 the V8 project authors. All rights reserved.
2
+ // Use of this source code is governed by a BSD-style license that can be
3
+ // found in the LICENSE file.
4
+
5
+ #ifndef INCLUDE_CPPGC_MACROS_H_
6
+ #define INCLUDE_CPPGC_MACROS_H_
7
+
8
+ namespace cppgc {
9
+
10
+ namespace internal {
11
+ class __thisIsHereToForceASemicolonAfterThisMacro {};
12
+ } // namespace internal
13
+
14
+ // Use if the object is only stack allocated.
15
+ #define CPPGC_STACK_ALLOCATED() \
16
+ public: \
17
+ using IsStackAllocatedTypeMarker = int; \
18
+ \
19
+ private: \
20
+ void* operator new(size_t) = delete; \
21
+ void* operator new(size_t, void*) = delete; \
22
+ friend class internal::__thisIsHereToForceASemicolonAfterThisMacro
23
+
24
+ } // namespace cppgc
25
+
26
+ #endif // INCLUDE_CPPGC_MACROS_H_
@@ -0,0 +1,206 @@
1
+ // Copyright 2020 the V8 project authors. All rights reserved.
2
+ // Use of this source code is governed by a BSD-style license that can be
3
+ // found in the LICENSE file.
4
+
5
+ #ifndef INCLUDE_CPPGC_MEMBER_H_
6
+ #define INCLUDE_CPPGC_MEMBER_H_
7
+
8
+ #include <atomic>
9
+ #include <cstddef>
10
+ #include <type_traits>
11
+
12
+ #include "cppgc/internal/pointer-policies.h"
13
+ #include "cppgc/type-traits.h"
14
+ #include "v8config.h" // NOLINT(build/include_directory)
15
+
16
+ namespace cppgc {
17
+
18
+ class Visitor;
19
+
20
+ namespace internal {
21
+
22
+ // The basic class from which all Member classes are 'generated'.
23
+ template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
24
+ typename CheckingPolicy>
25
+ class BasicMember : private CheckingPolicy {
26
+ public:
27
+ using PointeeType = T;
28
+
29
+ constexpr BasicMember() = default;
30
+ constexpr BasicMember(std::nullptr_t) {} // NOLINT
31
+ BasicMember(SentinelPointer s) : raw_(s) {} // NOLINT
32
+ BasicMember(T* raw) : raw_(raw) { // NOLINT
33
+ InitializingWriteBarrier();
34
+ this->CheckPointer(raw_);
35
+ }
36
+ BasicMember(T& raw) : BasicMember(&raw) {} // NOLINT
37
+ BasicMember(const BasicMember& other) : BasicMember(other.Get()) {}
38
+ // Allow heterogeneous construction.
39
+ template <typename U, typename OtherBarrierPolicy, typename OtherWeaknessTag,
40
+ typename OtherCheckingPolicy,
41
+ typename = std::enable_if_t<std::is_base_of<T, U>::value>>
42
+ BasicMember( // NOLINT
43
+ const BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
44
+ OtherCheckingPolicy>& other)
45
+ : BasicMember(other.Get()) {}
46
+ // Construction from Persistent.
47
+ template <typename U, typename PersistentWeaknessPolicy,
48
+ typename PersistentLocationPolicy,
49
+ typename PersistentCheckingPolicy,
50
+ typename = std::enable_if_t<std::is_base_of<T, U>::value>>
51
+ BasicMember( // NOLINT
52
+ const BasicPersistent<U, PersistentWeaknessPolicy,
53
+ PersistentLocationPolicy, PersistentCheckingPolicy>&
54
+ p)
55
+ : BasicMember(p.Get()) {}
56
+
57
+ BasicMember& operator=(const BasicMember& other) {
58
+ return operator=(other.Get());
59
+ }
60
+ // Allow heterogeneous assignment.
61
+ template <typename U, typename OtherWeaknessTag, typename OtherBarrierPolicy,
62
+ typename OtherCheckingPolicy,
63
+ typename = std::enable_if_t<std::is_base_of<T, U>::value>>
64
+ BasicMember& operator=(
65
+ const BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
66
+ OtherCheckingPolicy>& other) {
67
+ return operator=(other.Get());
68
+ }
69
+ // Assignment from Persistent.
70
+ template <typename U, typename PersistentWeaknessPolicy,
71
+ typename PersistentLocationPolicy,
72
+ typename PersistentCheckingPolicy,
73
+ typename = std::enable_if_t<std::is_base_of<T, U>::value>>
74
+ BasicMember& operator=(
75
+ const BasicPersistent<U, PersistentWeaknessPolicy,
76
+ PersistentLocationPolicy, PersistentCheckingPolicy>&
77
+ other) {
78
+ return operator=(other.Get());
79
+ }
80
+ BasicMember& operator=(T* other) {
81
+ SetRawAtomic(other);
82
+ AssigningWriteBarrier();
83
+ this->CheckPointer(Get());
84
+ return *this;
85
+ }
86
+ BasicMember& operator=(std::nullptr_t) {
87
+ Clear();
88
+ return *this;
89
+ }
90
+ BasicMember& operator=(SentinelPointer s) {
91
+ SetRawAtomic(s);
92
+ return *this;
93
+ }
94
+
95
+ template <typename OtherWeaknessTag, typename OtherBarrierPolicy,
96
+ typename OtherCheckingPolicy>
97
+ void Swap(BasicMember<T, OtherWeaknessTag, OtherBarrierPolicy,
98
+ OtherCheckingPolicy>& other) {
99
+ T* tmp = Get();
100
+ *this = other;
101
+ other = tmp;
102
+ }
103
+
104
+ explicit operator bool() const { return Get(); }
105
+ operator T*() const { return Get(); } // NOLINT
106
+ T* operator->() const { return Get(); }
107
+ T& operator*() const { return *Get(); }
108
+
109
+ T* Get() const {
110
+ // Executed by the mutator, hence non atomic load.
111
+ return raw_;
112
+ }
113
+
114
+ void Clear() { SetRawAtomic(nullptr); }
115
+
116
+ T* Release() {
117
+ T* result = Get();
118
+ Clear();
119
+ return result;
120
+ }
121
+
122
+ private:
123
+ void SetRawAtomic(T* raw) {
124
+ reinterpret_cast<std::atomic<T*>*>(&raw_)->store(raw,
125
+ std::memory_order_relaxed);
126
+ }
127
+ T* GetRawAtomic() const {
128
+ return reinterpret_cast<const std::atomic<T*>*>(&raw_)->load(
129
+ std::memory_order_relaxed);
130
+ }
131
+
132
+ void InitializingWriteBarrier() const {
133
+ WriteBarrierPolicy::InitializingBarrier(
134
+ reinterpret_cast<const void*>(&raw_), static_cast<const void*>(raw_));
135
+ }
136
+ void AssigningWriteBarrier() const {
137
+ WriteBarrierPolicy::AssigningBarrier(reinterpret_cast<const void*>(&raw_),
138
+ static_cast<const void*>(raw_));
139
+ }
140
+
141
+ T* raw_ = nullptr;
142
+
143
+ friend class cppgc::Visitor;
144
+ };
145
+
146
+ template <typename T1, typename WeaknessTag1, typename WriteBarrierPolicy1,
147
+ typename CheckingPolicy1, typename T2, typename WeaknessTag2,
148
+ typename WriteBarrierPolicy2, typename CheckingPolicy2>
149
+ bool operator==(
150
+ BasicMember<T1, WeaknessTag1, WriteBarrierPolicy1, CheckingPolicy1> member1,
151
+ BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2, CheckingPolicy2>
152
+ member2) {
153
+ return member1.Get() == member2.Get();
154
+ }
155
+
156
+ template <typename T1, typename WeaknessTag1, typename WriteBarrierPolicy1,
157
+ typename CheckingPolicy1, typename T2, typename WeaknessTag2,
158
+ typename WriteBarrierPolicy2, typename CheckingPolicy2>
159
+ bool operator!=(
160
+ BasicMember<T1, WeaknessTag1, WriteBarrierPolicy1, CheckingPolicy1> member1,
161
+ BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2, CheckingPolicy2>
162
+ member2) {
163
+ return !(member1 == member2);
164
+ }
165
+
166
+ template <typename T, typename WriteBarrierPolicy, typename CheckingPolicy>
167
+ struct IsWeak<
168
+ internal::BasicMember<T, WeakMemberTag, WriteBarrierPolicy, CheckingPolicy>>
169
+ : std::true_type {};
170
+
171
+ } // namespace internal
172
+
173
+ /**
174
+ * Members are used in classes to contain strong pointers to other garbage
175
+ * collected objects. All Member fields of a class must be traced in the class'
176
+ * trace method.
177
+ */
178
+ template <typename T>
179
+ using Member = internal::BasicMember<T, internal::StrongMemberTag,
180
+ internal::DijkstraWriteBarrierPolicy>;
181
+
182
+ /**
183
+ * WeakMember is similar to Member in that it is used to point to other garbage
184
+ * collected objects. However instead of creating a strong pointer to the
185
+ * object, the WeakMember creates a weak pointer, which does not keep the
186
+ * pointee alive. Hence if all pointers to to a heap allocated object are weak
187
+ * the object will be garbage collected. At the time of GC the weak pointers
188
+ * will automatically be set to null.
189
+ */
190
+ template <typename T>
191
+ using WeakMember = internal::BasicMember<T, internal::WeakMemberTag,
192
+ internal::DijkstraWriteBarrierPolicy>;
193
+
194
+ /**
195
+ * UntracedMember is a pointer to an on-heap object that is not traced for some
196
+ * reason. Do not use this unless you know what you are doing. Keeping raw
197
+ * pointers to on-heap objects is prohibited unless used from stack. Pointee
198
+ * must be kept alive through other means.
199
+ */
200
+ template <typename T>
201
+ using UntracedMember = internal::BasicMember<T, internal::UntracedMemberTag,
202
+ internal::NoWriteBarrierPolicy>;
203
+
204
+ } // namespace cppgc
205
+
206
+ #endif // INCLUDE_CPPGC_MEMBER_H_
@@ -0,0 +1,304 @@
1
+ // Copyright 2020 the V8 project authors. All rights reserved.
2
+ // Use of this source code is governed by a BSD-style license that can be
3
+ // found in the LICENSE file.
4
+
5
+ #ifndef INCLUDE_CPPGC_PERSISTENT_H_
6
+ #define INCLUDE_CPPGC_PERSISTENT_H_
7
+
8
+ #include <type_traits>
9
+
10
+ #include "cppgc/internal/persistent-node.h"
11
+ #include "cppgc/internal/pointer-policies.h"
12
+ #include "cppgc/source-location.h"
13
+ #include "cppgc/type-traits.h"
14
+ #include "cppgc/visitor.h"
15
+ #include "v8config.h" // NOLINT(build/include_directory)
16
+
17
+ namespace cppgc {
18
+ namespace internal {
19
+
20
+ // The basic class from which all Persistent classes are generated.
21
+ template <typename T, typename WeaknessPolicy, typename LocationPolicy,
22
+ typename CheckingPolicy>
23
+ class BasicPersistent : public LocationPolicy,
24
+ private WeaknessPolicy,
25
+ private CheckingPolicy {
26
+ public:
27
+ using typename WeaknessPolicy::IsStrongPersistent;
28
+ using PointeeType = T;
29
+
30
+ // Null-state/sentinel constructors.
31
+ BasicPersistent( // NOLINT
32
+ const SourceLocation& loc = SourceLocation::Current())
33
+ : LocationPolicy(loc) {}
34
+
35
+ BasicPersistent(std::nullptr_t, // NOLINT
36
+ const SourceLocation& loc = SourceLocation::Current())
37
+ : LocationPolicy(loc) {}
38
+
39
+ BasicPersistent( // NOLINT
40
+ SentinelPointer s, const SourceLocation& loc = SourceLocation::Current())
41
+ : LocationPolicy(loc), raw_(s) {}
42
+
43
+ // Raw value contstructors.
44
+ BasicPersistent(T* raw, // NOLINT
45
+ const SourceLocation& loc = SourceLocation::Current())
46
+ : LocationPolicy(loc), raw_(raw) {
47
+ if (!IsValid()) return;
48
+ node_ = WeaknessPolicy::GetPersistentRegion(raw_).AllocateNode(
49
+ this, &BasicPersistent::Trace);
50
+ this->CheckPointer(Get());
51
+ }
52
+
53
+ BasicPersistent(T& raw, // NOLINT
54
+ const SourceLocation& loc = SourceLocation::Current())
55
+ : BasicPersistent(&raw, loc) {}
56
+
57
+ // Copy ctor.
58
+ BasicPersistent(const BasicPersistent& other,
59
+ const SourceLocation& loc = SourceLocation::Current())
60
+ : BasicPersistent(other.Get(), loc) {}
61
+
62
+ // Heterogeneous ctor.
63
+ template <typename U, typename OtherWeaknessPolicy,
64
+ typename OtherLocationPolicy, typename OtherCheckingPolicy,
65
+ typename = std::enable_if_t<std::is_base_of<T, U>::value>>
66
+ BasicPersistent( // NOLINT
67
+ const BasicPersistent<U, OtherWeaknessPolicy, OtherLocationPolicy,
68
+ OtherCheckingPolicy>& other,
69
+ const SourceLocation& loc = SourceLocation::Current())
70
+ : BasicPersistent(other.Get(), loc) {}
71
+
72
+ // Move ctor. The heterogeneous move ctor is not supported since e.g.
73
+ // persistent can't reuse persistent node from weak persistent.
74
+ BasicPersistent(
75
+ BasicPersistent&& other,
76
+ const SourceLocation& loc = SourceLocation::Current()) noexcept
77
+ : LocationPolicy(std::move(other)),
78
+ raw_(std::move(other.raw_)),
79
+ node_(std::move(other.node_)) {
80
+ if (!IsValid()) return;
81
+ node_->UpdateOwner(this);
82
+ other.raw_ = nullptr;
83
+ other.node_ = nullptr;
84
+ this->CheckPointer(Get());
85
+ }
86
+
87
+ // Constructor from member.
88
+ template <typename U, typename MemberBarrierPolicy,
89
+ typename MemberWeaknessTag, typename MemberCheckingPolicy,
90
+ typename = std::enable_if_t<std::is_base_of<T, U>::value>>
91
+ BasicPersistent(internal::BasicMember<U, MemberBarrierPolicy, // NOLINT
92
+ MemberWeaknessTag, MemberCheckingPolicy>
93
+ member,
94
+ const SourceLocation& loc = SourceLocation::Current())
95
+ : BasicPersistent(member.Get(), loc) {}
96
+
97
+ ~BasicPersistent() { Clear(); }
98
+
99
+ // Copy assignment.
100
+ BasicPersistent& operator=(const BasicPersistent& other) {
101
+ return operator=(other.Get());
102
+ }
103
+
104
+ template <typename U, typename OtherWeaknessPolicy,
105
+ typename OtherLocationPolicy, typename OtherCheckingPolicy,
106
+ typename = std::enable_if_t<std::is_base_of<T, U>::value>>
107
+ BasicPersistent& operator=(
108
+ const BasicPersistent<U, OtherWeaknessPolicy, OtherLocationPolicy,
109
+ OtherCheckingPolicy>& other) {
110
+ return operator=(other.Get());
111
+ }
112
+
113
+ // Move assignment.
114
+ BasicPersistent& operator=(BasicPersistent&& other) {
115
+ if (this == &other) return *this;
116
+ Clear();
117
+ LocationPolicy::operator=(std::move(other));
118
+ raw_ = std::move(other.raw_);
119
+ node_ = std::move(other.node_);
120
+ if (!IsValid()) return *this;
121
+ node_->UpdateOwner(this);
122
+ other.raw_ = nullptr;
123
+ other.node_ = nullptr;
124
+ this->CheckPointer(Get());
125
+ return *this;
126
+ }
127
+
128
+ // Assignment from member.
129
+ template <typename U, typename MemberBarrierPolicy,
130
+ typename MemberWeaknessTag, typename MemberCheckingPolicy,
131
+ typename = std::enable_if_t<std::is_base_of<T, U>::value>>
132
+ BasicPersistent& operator=(
133
+ internal::BasicMember<U, MemberBarrierPolicy, MemberWeaknessTag,
134
+ MemberCheckingPolicy>
135
+ member) {
136
+ return operator=(member.Get());
137
+ }
138
+
139
+ BasicPersistent& operator=(T* other) {
140
+ Assign(other);
141
+ return *this;
142
+ }
143
+
144
+ BasicPersistent& operator=(std::nullptr_t) {
145
+ Clear();
146
+ return *this;
147
+ }
148
+
149
+ BasicPersistent& operator=(SentinelPointer s) {
150
+ Assign(s);
151
+ return *this;
152
+ }
153
+
154
+ explicit operator bool() const { return Get(); }
155
+ operator T*() const { return Get(); }
156
+ T* operator->() const { return Get(); }
157
+ T& operator*() const { return *Get(); }
158
+
159
+ T* Get() const { return raw_; }
160
+
161
+ void Clear() { Assign(nullptr); }
162
+
163
+ T* Release() {
164
+ T* result = Get();
165
+ Clear();
166
+ return result;
167
+ }
168
+
169
+ private:
170
+ static void Trace(Visitor* v, const void* ptr) {
171
+ const auto* persistent = static_cast<const BasicPersistent*>(ptr);
172
+ v->TraceRoot(*persistent, persistent->Location());
173
+ }
174
+
175
+ bool IsValid() const {
176
+ // Ideally, handling kSentinelPointer would be done by the embedder. On the
177
+ // other hand, having Persistent aware of it is beneficial since no node
178
+ // gets wasted.
179
+ return raw_ != nullptr && raw_ != kSentinelPointer;
180
+ }
181
+
182
+ void Assign(T* ptr) {
183
+ if (IsValid()) {
184
+ if (ptr && ptr != kSentinelPointer) {
185
+ // Simply assign the pointer reusing the existing node.
186
+ raw_ = ptr;
187
+ this->CheckPointer(ptr);
188
+ return;
189
+ }
190
+ WeaknessPolicy::GetPersistentRegion(raw_).FreeNode(node_);
191
+ node_ = nullptr;
192
+ }
193
+ raw_ = ptr;
194
+ if (!IsValid()) return;
195
+ node_ = WeaknessPolicy::GetPersistentRegion(raw_).AllocateNode(
196
+ this, &BasicPersistent::Trace);
197
+ this->CheckPointer(Get());
198
+ }
199
+
200
+ T* raw_ = nullptr;
201
+ PersistentNode* node_ = nullptr;
202
+ };
203
+
204
+ template <typename T1, typename WeaknessPolicy1, typename LocationPolicy1,
205
+ typename CheckingPolicy1, typename T2, typename WeaknessPolicy2,
206
+ typename LocationPolicy2, typename CheckingPolicy2>
207
+ bool operator==(const BasicPersistent<T1, WeaknessPolicy1, LocationPolicy1,
208
+ CheckingPolicy1>& p1,
209
+ const BasicPersistent<T2, WeaknessPolicy2, LocationPolicy2,
210
+ CheckingPolicy2>& p2) {
211
+ return p1.Get() == p2.Get();
212
+ }
213
+
214
+ template <typename T1, typename WeaknessPolicy1, typename LocationPolicy1,
215
+ typename CheckingPolicy1, typename T2, typename WeaknessPolicy2,
216
+ typename LocationPolicy2, typename CheckingPolicy2>
217
+ bool operator!=(const BasicPersistent<T1, WeaknessPolicy1, LocationPolicy1,
218
+ CheckingPolicy1>& p1,
219
+ const BasicPersistent<T2, WeaknessPolicy2, LocationPolicy2,
220
+ CheckingPolicy2>& p2) {
221
+ return !(p1 == p2);
222
+ }
223
+
224
+ template <typename T1, typename PersistentWeaknessPolicy,
225
+ typename PersistentLocationPolicy, typename PersistentCheckingPolicy,
226
+ typename T2, typename MemberWriteBarrierPolicy,
227
+ typename MemberWeaknessTag, typename MemberCheckingPolicy>
228
+ bool operator==(const BasicPersistent<T1, PersistentWeaknessPolicy,
229
+ PersistentLocationPolicy,
230
+ PersistentCheckingPolicy>& p,
231
+ BasicMember<T2, MemberWeaknessTag, MemberWriteBarrierPolicy,
232
+ MemberCheckingPolicy>
233
+ m) {
234
+ return p.Get() == m.Get();
235
+ }
236
+
237
+ template <typename T1, typename PersistentWeaknessPolicy,
238
+ typename PersistentLocationPolicy, typename PersistentCheckingPolicy,
239
+ typename T2, typename MemberWriteBarrierPolicy,
240
+ typename MemberWeaknessTag, typename MemberCheckingPolicy>
241
+ bool operator!=(const BasicPersistent<T1, PersistentWeaknessPolicy,
242
+ PersistentLocationPolicy,
243
+ PersistentCheckingPolicy>& p,
244
+ BasicMember<T2, MemberWeaknessTag, MemberWriteBarrierPolicy,
245
+ MemberCheckingPolicy>
246
+ m) {
247
+ return !(p == m);
248
+ }
249
+
250
+ template <typename T1, typename MemberWriteBarrierPolicy,
251
+ typename MemberWeaknessTag, typename MemberCheckingPolicy,
252
+ typename T2, typename PersistentWeaknessPolicy,
253
+ typename PersistentLocationPolicy, typename PersistentCheckingPolicy>
254
+ bool operator==(BasicMember<T2, MemberWeaknessTag, MemberWriteBarrierPolicy,
255
+ MemberCheckingPolicy>
256
+ m,
257
+ const BasicPersistent<T1, PersistentWeaknessPolicy,
258
+ PersistentLocationPolicy,
259
+ PersistentCheckingPolicy>& p) {
260
+ return m.Get() == p.Get();
261
+ }
262
+
263
+ template <typename T1, typename MemberWriteBarrierPolicy,
264
+ typename MemberWeaknessTag, typename MemberCheckingPolicy,
265
+ typename T2, typename PersistentWeaknessPolicy,
266
+ typename PersistentLocationPolicy, typename PersistentCheckingPolicy>
267
+ bool operator!=(BasicMember<T2, MemberWeaknessTag, MemberWriteBarrierPolicy,
268
+ MemberCheckingPolicy>
269
+ m,
270
+ const BasicPersistent<T1, PersistentWeaknessPolicy,
271
+ PersistentLocationPolicy,
272
+ PersistentCheckingPolicy>& p) {
273
+ return !(m == p);
274
+ }
275
+
276
+ template <typename T, typename LocationPolicy, typename CheckingPolicy>
277
+ struct IsWeak<BasicPersistent<T, internal::WeakPersistentPolicy, LocationPolicy,
278
+ CheckingPolicy>> : std::true_type {};
279
+ } // namespace internal
280
+
281
+ /**
282
+ * Persistent is a way to create a strong pointer from an off-heap object to
283
+ * another on-heap object. As long as the Persistent handle is alive the GC will
284
+ * keep the object pointed to alive. The Persistent handle is always a GC root
285
+ * from the point of view of the GC. Persistent must be constructed and
286
+ * destructed in the same thread.
287
+ */
288
+ template <typename T>
289
+ using Persistent =
290
+ internal::BasicPersistent<T, internal::StrongPersistentPolicy>;
291
+
292
+ /**
293
+ * WeakPersistent is a way to create a weak pointer from an off-heap object to
294
+ * an on-heap object. The pointer is automatically cleared when the pointee gets
295
+ * collected. WeakPersistent must be constructed and destructed in the same
296
+ * thread.
297
+ */
298
+ template <typename T>
299
+ using WeakPersistent =
300
+ internal::BasicPersistent<T, internal::WeakPersistentPolicy>;
301
+
302
+ } // namespace cppgc
303
+
304
+ #endif // INCLUDE_CPPGC_PERSISTENT_H_