libv8-node 16.10.0.0-arm64-darwin

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (68) hide show
  1. checksums.yaml +7 -0
  2. data/ext/libv8-node/.location.yml +1 -0
  3. data/ext/libv8-node/location.rb +76 -0
  4. data/ext/libv8-node/paths.rb +34 -0
  5. data/lib/libv8/node/version.rb +7 -0
  6. data/lib/libv8/node.rb +11 -0
  7. data/lib/libv8-node.rb +1 -0
  8. data/vendor/v8/arm64-darwin/libv8/obj/libv8_monolith.a +0 -0
  9. data/vendor/v8/include/cppgc/allocation.h +232 -0
  10. data/vendor/v8/include/cppgc/common.h +29 -0
  11. data/vendor/v8/include/cppgc/cross-thread-persistent.h +384 -0
  12. data/vendor/v8/include/cppgc/custom-space.h +97 -0
  13. data/vendor/v8/include/cppgc/default-platform.h +75 -0
  14. data/vendor/v8/include/cppgc/ephemeron-pair.h +30 -0
  15. data/vendor/v8/include/cppgc/explicit-management.h +82 -0
  16. data/vendor/v8/include/cppgc/garbage-collected.h +117 -0
  17. data/vendor/v8/include/cppgc/heap-consistency.h +236 -0
  18. data/vendor/v8/include/cppgc/heap-state.h +70 -0
  19. data/vendor/v8/include/cppgc/heap-statistics.h +120 -0
  20. data/vendor/v8/include/cppgc/heap.h +201 -0
  21. data/vendor/v8/include/cppgc/internal/api-constants.h +47 -0
  22. data/vendor/v8/include/cppgc/internal/atomic-entry-flag.h +48 -0
  23. data/vendor/v8/include/cppgc/internal/caged-heap-local-data.h +68 -0
  24. data/vendor/v8/include/cppgc/internal/compiler-specific.h +38 -0
  25. data/vendor/v8/include/cppgc/internal/finalizer-trait.h +90 -0
  26. data/vendor/v8/include/cppgc/internal/gc-info.h +76 -0
  27. data/vendor/v8/include/cppgc/internal/logging.h +50 -0
  28. data/vendor/v8/include/cppgc/internal/name-trait.h +111 -0
  29. data/vendor/v8/include/cppgc/internal/persistent-node.h +172 -0
  30. data/vendor/v8/include/cppgc/internal/pointer-policies.h +175 -0
  31. data/vendor/v8/include/cppgc/internal/prefinalizer-handler.h +30 -0
  32. data/vendor/v8/include/cppgc/internal/write-barrier.h +396 -0
  33. data/vendor/v8/include/cppgc/liveness-broker.h +74 -0
  34. data/vendor/v8/include/cppgc/macros.h +26 -0
  35. data/vendor/v8/include/cppgc/member.h +286 -0
  36. data/vendor/v8/include/cppgc/name-provider.h +65 -0
  37. data/vendor/v8/include/cppgc/object-size-trait.h +58 -0
  38. data/vendor/v8/include/cppgc/persistent.h +365 -0
  39. data/vendor/v8/include/cppgc/platform.h +153 -0
  40. data/vendor/v8/include/cppgc/prefinalizer.h +52 -0
  41. data/vendor/v8/include/cppgc/process-heap-statistics.h +36 -0
  42. data/vendor/v8/include/cppgc/sentinel-pointer.h +32 -0
  43. data/vendor/v8/include/cppgc/source-location.h +92 -0
  44. data/vendor/v8/include/cppgc/testing.h +99 -0
  45. data/vendor/v8/include/cppgc/trace-trait.h +116 -0
  46. data/vendor/v8/include/cppgc/type-traits.h +247 -0
  47. data/vendor/v8/include/cppgc/visitor.h +377 -0
  48. data/vendor/v8/include/libplatform/libplatform-export.h +29 -0
  49. data/vendor/v8/include/libplatform/libplatform.h +117 -0
  50. data/vendor/v8/include/libplatform/v8-tracing.h +334 -0
  51. data/vendor/v8/include/v8-cppgc.h +325 -0
  52. data/vendor/v8/include/v8-fast-api-calls.h +791 -0
  53. data/vendor/v8/include/v8-inspector-protocol.h +13 -0
  54. data/vendor/v8/include/v8-inspector.h +348 -0
  55. data/vendor/v8/include/v8-internal.h +499 -0
  56. data/vendor/v8/include/v8-metrics.h +202 -0
  57. data/vendor/v8/include/v8-platform.h +709 -0
  58. data/vendor/v8/include/v8-profiler.h +1123 -0
  59. data/vendor/v8/include/v8-unwinder-state.h +30 -0
  60. data/vendor/v8/include/v8-util.h +652 -0
  61. data/vendor/v8/include/v8-value-serializer-version.h +24 -0
  62. data/vendor/v8/include/v8-version-string.h +38 -0
  63. data/vendor/v8/include/v8-version.h +20 -0
  64. data/vendor/v8/include/v8-wasm-trap-handler-posix.h +31 -0
  65. data/vendor/v8/include/v8-wasm-trap-handler-win.h +28 -0
  66. data/vendor/v8/include/v8.h +12648 -0
  67. data/vendor/v8/include/v8config.h +515 -0
  68. metadata +138 -0
@@ -0,0 +1,286 @@
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/sentinel-pointer.h"
14
+ #include "cppgc/type-traits.h"
15
+ #include "v8config.h" // NOLINT(build/include_directory)
16
+
17
+ namespace cppgc {
18
+
19
+ class Visitor;
20
+
21
+ namespace internal {
22
+
23
+ // MemberBase always refers to the object as const object and defers to
24
+ // BasicMember on casting to the right type as needed.
25
+ class MemberBase {
26
+ protected:
27
+ struct AtomicInitializerTag {};
28
+
29
+ MemberBase() = default;
30
+ explicit MemberBase(const void* value) : raw_(value) {}
31
+ MemberBase(const void* value, AtomicInitializerTag) { SetRawAtomic(value); }
32
+
33
+ const void** GetRawSlot() const { return &raw_; }
34
+ const void* GetRaw() const { return raw_; }
35
+ void SetRaw(void* value) { raw_ = value; }
36
+
37
+ const void* GetRawAtomic() const {
38
+ return reinterpret_cast<const std::atomic<const void*>*>(&raw_)->load(
39
+ std::memory_order_relaxed);
40
+ }
41
+ void SetRawAtomic(const void* value) {
42
+ reinterpret_cast<std::atomic<const void*>*>(&raw_)->store(
43
+ value, std::memory_order_relaxed);
44
+ }
45
+
46
+ void ClearFromGC() const { raw_ = nullptr; }
47
+
48
+ private:
49
+ mutable const void* raw_ = nullptr;
50
+ };
51
+
52
+ // The basic class from which all Member classes are 'generated'.
53
+ template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
54
+ typename CheckingPolicy>
55
+ class BasicMember final : private MemberBase, private CheckingPolicy {
56
+ public:
57
+ using PointeeType = T;
58
+
59
+ constexpr BasicMember() = default;
60
+ constexpr BasicMember(std::nullptr_t) {} // NOLINT
61
+ BasicMember(SentinelPointer s) : MemberBase(s) {} // NOLINT
62
+ BasicMember(T* raw) : MemberBase(raw) { // NOLINT
63
+ InitializingWriteBarrier();
64
+ this->CheckPointer(Get());
65
+ }
66
+ BasicMember(T& raw) : BasicMember(&raw) {} // NOLINT
67
+ // Atomic ctor. Using the AtomicInitializerTag forces BasicMember to
68
+ // initialize using atomic assignments. This is required for preventing
69
+ // data races with concurrent marking.
70
+ using AtomicInitializerTag = MemberBase::AtomicInitializerTag;
71
+ BasicMember(std::nullptr_t, AtomicInitializerTag atomic)
72
+ : MemberBase(nullptr, atomic) {}
73
+ BasicMember(SentinelPointer s, AtomicInitializerTag atomic)
74
+ : MemberBase(s, atomic) {}
75
+ BasicMember(T* raw, AtomicInitializerTag atomic) : MemberBase(raw, atomic) {
76
+ InitializingWriteBarrier();
77
+ this->CheckPointer(Get());
78
+ }
79
+ BasicMember(T& raw, AtomicInitializerTag atomic)
80
+ : BasicMember(&raw, atomic) {}
81
+ // Copy ctor.
82
+ BasicMember(const BasicMember& other) : BasicMember(other.Get()) {}
83
+ // Allow heterogeneous construction.
84
+ template <typename U, typename OtherBarrierPolicy, typename OtherWeaknessTag,
85
+ typename OtherCheckingPolicy,
86
+ typename = std::enable_if_t<std::is_base_of<T, U>::value>>
87
+ BasicMember( // NOLINT
88
+ const BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
89
+ OtherCheckingPolicy>& other)
90
+ : BasicMember(other.Get()) {}
91
+ // Move ctor.
92
+ BasicMember(BasicMember&& other) noexcept : BasicMember(other.Get()) {
93
+ other.Clear();
94
+ }
95
+ // Allow heterogeneous move construction.
96
+ template <typename U, typename OtherBarrierPolicy, typename OtherWeaknessTag,
97
+ typename OtherCheckingPolicy,
98
+ typename = std::enable_if_t<std::is_base_of<T, U>::value>>
99
+ BasicMember(BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
100
+ OtherCheckingPolicy>&& other) noexcept
101
+ : BasicMember(other.Get()) {
102
+ other.Clear();
103
+ }
104
+ // Construction from Persistent.
105
+ template <typename U, typename PersistentWeaknessPolicy,
106
+ typename PersistentLocationPolicy,
107
+ typename PersistentCheckingPolicy,
108
+ typename = std::enable_if_t<std::is_base_of<T, U>::value>>
109
+ BasicMember(const BasicPersistent<U, PersistentWeaknessPolicy,
110
+ PersistentLocationPolicy,
111
+ PersistentCheckingPolicy>& p)
112
+ : BasicMember(p.Get()) {}
113
+
114
+ // Copy assignment.
115
+ BasicMember& operator=(const BasicMember& other) {
116
+ return operator=(other.Get());
117
+ }
118
+ // Allow heterogeneous copy assignment.
119
+ template <typename U, typename OtherWeaknessTag, typename OtherBarrierPolicy,
120
+ typename OtherCheckingPolicy,
121
+ typename = std::enable_if_t<std::is_base_of<T, U>::value>>
122
+ BasicMember& operator=(
123
+ const BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
124
+ OtherCheckingPolicy>& other) {
125
+ return operator=(other.Get());
126
+ }
127
+ // Move assignment.
128
+ BasicMember& operator=(BasicMember&& other) noexcept {
129
+ operator=(other.Get());
130
+ other.Clear();
131
+ return *this;
132
+ }
133
+ // Heterogeneous move assignment.
134
+ template <typename U, typename OtherWeaknessTag, typename OtherBarrierPolicy,
135
+ typename OtherCheckingPolicy,
136
+ typename = std::enable_if_t<std::is_base_of<T, U>::value>>
137
+ BasicMember& operator=(BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
138
+ OtherCheckingPolicy>&& other) noexcept {
139
+ operator=(other.Get());
140
+ other.Clear();
141
+ return *this;
142
+ }
143
+ // Assignment from Persistent.
144
+ template <typename U, typename PersistentWeaknessPolicy,
145
+ typename PersistentLocationPolicy,
146
+ typename PersistentCheckingPolicy,
147
+ typename = std::enable_if_t<std::is_base_of<T, U>::value>>
148
+ BasicMember& operator=(
149
+ const BasicPersistent<U, PersistentWeaknessPolicy,
150
+ PersistentLocationPolicy, PersistentCheckingPolicy>&
151
+ other) {
152
+ return operator=(other.Get());
153
+ }
154
+ BasicMember& operator=(T* other) {
155
+ SetRawAtomic(other);
156
+ AssigningWriteBarrier();
157
+ this->CheckPointer(Get());
158
+ return *this;
159
+ }
160
+ BasicMember& operator=(std::nullptr_t) {
161
+ Clear();
162
+ return *this;
163
+ }
164
+ BasicMember& operator=(SentinelPointer s) {
165
+ SetRawAtomic(s);
166
+ return *this;
167
+ }
168
+
169
+ template <typename OtherWeaknessTag, typename OtherBarrierPolicy,
170
+ typename OtherCheckingPolicy>
171
+ void Swap(BasicMember<T, OtherWeaknessTag, OtherBarrierPolicy,
172
+ OtherCheckingPolicy>& other) {
173
+ T* tmp = Get();
174
+ *this = other;
175
+ other = tmp;
176
+ }
177
+
178
+ explicit operator bool() const { return Get(); }
179
+ operator T*() const { return Get(); }
180
+ T* operator->() const { return Get(); }
181
+ T& operator*() const { return *Get(); }
182
+
183
+ // CFI cast exemption to allow passing SentinelPointer through T* and support
184
+ // heterogeneous assignments between different Member and Persistent handles
185
+ // based on their actual types.
186
+ V8_CLANG_NO_SANITIZE("cfi-unrelated-cast") T* Get() const {
187
+ // Executed by the mutator, hence non atomic load.
188
+ //
189
+ // The const_cast below removes the constness from MemberBase storage. The
190
+ // following static_cast re-adds any constness if specified through the
191
+ // user-visible template parameter T.
192
+ return static_cast<T*>(const_cast<void*>(MemberBase::GetRaw()));
193
+ }
194
+
195
+ void Clear() { SetRawAtomic(nullptr); }
196
+
197
+ T* Release() {
198
+ T* result = Get();
199
+ Clear();
200
+ return result;
201
+ }
202
+
203
+ const T** GetSlotForTesting() const {
204
+ return reinterpret_cast<const T**>(GetRawSlot());
205
+ }
206
+
207
+ private:
208
+ const T* GetRawAtomic() const {
209
+ return static_cast<const T*>(MemberBase::GetRawAtomic());
210
+ }
211
+
212
+ void InitializingWriteBarrier() const {
213
+ WriteBarrierPolicy::InitializingBarrier(GetRawSlot(), GetRaw());
214
+ }
215
+ void AssigningWriteBarrier() const {
216
+ WriteBarrierPolicy::AssigningBarrier(GetRawSlot(), GetRaw());
217
+ }
218
+
219
+ void ClearFromGC() const { MemberBase::ClearFromGC(); }
220
+
221
+ friend class cppgc::Visitor;
222
+ template <typename U>
223
+ friend struct cppgc::TraceTrait;
224
+ };
225
+
226
+ template <typename T1, typename WeaknessTag1, typename WriteBarrierPolicy1,
227
+ typename CheckingPolicy1, typename T2, typename WeaknessTag2,
228
+ typename WriteBarrierPolicy2, typename CheckingPolicy2>
229
+ bool operator==(const BasicMember<T1, WeaknessTag1, WriteBarrierPolicy1,
230
+ CheckingPolicy1>& member1,
231
+ const BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2,
232
+ CheckingPolicy2>& member2) {
233
+ return member1.Get() == member2.Get();
234
+ }
235
+
236
+ template <typename T1, typename WeaknessTag1, typename WriteBarrierPolicy1,
237
+ typename CheckingPolicy1, typename T2, typename WeaknessTag2,
238
+ typename WriteBarrierPolicy2, typename CheckingPolicy2>
239
+ bool operator!=(const BasicMember<T1, WeaknessTag1, WriteBarrierPolicy1,
240
+ CheckingPolicy1>& member1,
241
+ const BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2,
242
+ CheckingPolicy2>& member2) {
243
+ return !(member1 == member2);
244
+ }
245
+
246
+ template <typename T, typename WriteBarrierPolicy, typename CheckingPolicy>
247
+ struct IsWeak<
248
+ internal::BasicMember<T, WeakMemberTag, WriteBarrierPolicy, CheckingPolicy>>
249
+ : std::true_type {};
250
+
251
+ } // namespace internal
252
+
253
+ /**
254
+ * Members are used in classes to contain strong pointers to other garbage
255
+ * collected objects. All Member fields of a class must be traced in the class'
256
+ * trace method.
257
+ */
258
+ template <typename T>
259
+ using Member = internal::BasicMember<T, internal::StrongMemberTag,
260
+ internal::DijkstraWriteBarrierPolicy>;
261
+
262
+ /**
263
+ * WeakMember is similar to Member in that it is used to point to other garbage
264
+ * collected objects. However instead of creating a strong pointer to the
265
+ * object, the WeakMember creates a weak pointer, which does not keep the
266
+ * pointee alive. Hence if all pointers to to a heap allocated object are weak
267
+ * the object will be garbage collected. At the time of GC the weak pointers
268
+ * will automatically be set to null.
269
+ */
270
+ template <typename T>
271
+ using WeakMember = internal::BasicMember<T, internal::WeakMemberTag,
272
+ internal::DijkstraWriteBarrierPolicy>;
273
+
274
+ /**
275
+ * UntracedMember is a pointer to an on-heap object that is not traced for some
276
+ * reason. Do not use this unless you know what you are doing. Keeping raw
277
+ * pointers to on-heap objects is prohibited unless used from stack. Pointee
278
+ * must be kept alive through other means.
279
+ */
280
+ template <typename T>
281
+ using UntracedMember = internal::BasicMember<T, internal::UntracedMemberTag,
282
+ internal::NoWriteBarrierPolicy>;
283
+
284
+ } // namespace cppgc
285
+
286
+ #endif // INCLUDE_CPPGC_MEMBER_H_
@@ -0,0 +1,65 @@
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_NAME_PROVIDER_H_
6
+ #define INCLUDE_CPPGC_NAME_PROVIDER_H_
7
+
8
+ #include "v8config.h" // NOLINT(build/include_directory)
9
+
10
+ namespace cppgc {
11
+
12
+ /**
13
+ * NameProvider allows for providing a human-readable name for garbage-collected
14
+ * objects.
15
+ *
16
+ * There's two cases of names to distinguish:
17
+ * a. Explicitly specified names via using NameProvider. Such names are always
18
+ * preserved in the system.
19
+ * b. Internal names that Oilpan infers from a C++ type on the class hierarchy
20
+ * of the object. This is not necessarily the type of the actually
21
+ * instantiated object.
22
+ *
23
+ * Depending on the build configuration, Oilpan may hide names, i.e., represent
24
+ * them with kHiddenName, of case b. to avoid exposing internal details.
25
+ */
26
+ class V8_EXPORT NameProvider {
27
+ public:
28
+ /**
29
+ * Name that is used when hiding internals.
30
+ */
31
+ static constexpr const char kHiddenName[] = "InternalNode";
32
+
33
+ /**
34
+ * Name that is used in case compiler support is missing for composing a name
35
+ * from C++ types.
36
+ */
37
+ static constexpr const char kNoNameDeducible[] = "<No name>";
38
+
39
+ /**
40
+ * Indicating whether internal names are hidden or not.
41
+ *
42
+ * @returns true if C++ names should be hidden and represented by kHiddenName.
43
+ */
44
+ static constexpr bool HideInternalNames() {
45
+ #if CPPGC_SUPPORTS_OBJECT_NAMES
46
+ return false;
47
+ #else // !CPPGC_SUPPORTS_OBJECT_NAMES
48
+ return true;
49
+ #endif // !CPPGC_SUPPORTS_OBJECT_NAMES
50
+ }
51
+
52
+ virtual ~NameProvider() = default;
53
+
54
+ /**
55
+ * Specifies a name for the garbage-collected object. Such names will never
56
+ * be hidden, as they are explicitly specified by the user of this API.
57
+ *
58
+ * @returns a human readable name for the object.
59
+ */
60
+ virtual const char* GetHumanReadableName() const = 0;
61
+ };
62
+
63
+ } // namespace cppgc
64
+
65
+ #endif // INCLUDE_CPPGC_NAME_PROVIDER_H_
@@ -0,0 +1,58 @@
1
+ // Copyright 2021 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_OBJECT_SIZE_TRAIT_H_
6
+ #define INCLUDE_CPPGC_OBJECT_SIZE_TRAIT_H_
7
+
8
+ #include <cstddef>
9
+
10
+ #include "cppgc/type-traits.h"
11
+ #include "v8config.h" // NOLINT(build/include_directory)
12
+
13
+ namespace cppgc {
14
+
15
+ namespace internal {
16
+
17
+ struct V8_EXPORT BaseObjectSizeTrait {
18
+ protected:
19
+ static size_t GetObjectSizeForGarbageCollected(const void*);
20
+ static size_t GetObjectSizeForGarbageCollectedMixin(const void*);
21
+ };
22
+
23
+ } // namespace internal
24
+
25
+ namespace subtle {
26
+
27
+ /**
28
+ * Trait specifying how to get the size of an object that was allocated using
29
+ * `MakeGarbageCollected()`. Also supports querying the size with an inner
30
+ * pointer to a mixin.
31
+ */
32
+ template <typename T, bool = IsGarbageCollectedMixinTypeV<T>>
33
+ struct ObjectSizeTrait;
34
+
35
+ template <typename T>
36
+ struct ObjectSizeTrait<T, false> : cppgc::internal::BaseObjectSizeTrait {
37
+ static_assert(sizeof(T), "T must be fully defined");
38
+ static_assert(IsGarbageCollectedTypeV<T>,
39
+ "T must be of type GarbageCollected or GarbageCollectedMixin");
40
+
41
+ static size_t GetSize(const T& object) {
42
+ return GetObjectSizeForGarbageCollected(&object);
43
+ }
44
+ };
45
+
46
+ template <typename T>
47
+ struct ObjectSizeTrait<T, true> : cppgc::internal::BaseObjectSizeTrait {
48
+ static_assert(sizeof(T), "T must be fully defined");
49
+
50
+ static size_t GetSize(const T& object) {
51
+ return GetObjectSizeForGarbageCollectedMixin(&object);
52
+ }
53
+ };
54
+
55
+ } // namespace subtle
56
+ } // namespace cppgc
57
+
58
+ #endif // INCLUDE_CPPGC_OBJECT_SIZE_TRAIT_H_