libv8-node 16.10.0.0-aarch64-linux → 18.8.0.0-aarch64-linux
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +4 -4
- data/ext/libv8-node/paths.rb +5 -1
- data/lib/libv8/node/version.rb +3 -3
- data/vendor/v8/aarch64-linux/libv8/obj/libv8_monolith.a +0 -0
- data/vendor/v8/include/cppgc/allocation.h +100 -22
- data/vendor/v8/include/cppgc/cross-thread-persistent.h +114 -33
- data/vendor/v8/include/cppgc/default-platform.h +2 -10
- data/vendor/v8/include/cppgc/explicit-management.h +22 -4
- data/vendor/v8/include/cppgc/garbage-collected.h +15 -26
- data/vendor/v8/include/cppgc/heap-consistency.h +30 -0
- data/vendor/v8/include/cppgc/heap-state.h +12 -0
- data/vendor/v8/include/cppgc/heap.h +7 -2
- data/vendor/v8/include/cppgc/internal/api-constants.h +8 -0
- data/vendor/v8/include/cppgc/internal/caged-heap-local-data.h +25 -14
- data/vendor/v8/include/cppgc/internal/finalizer-trait.h +4 -1
- data/vendor/v8/include/cppgc/internal/gc-info.h +90 -10
- data/vendor/v8/include/cppgc/internal/logging.h +3 -3
- data/vendor/v8/include/cppgc/internal/name-trait.h +11 -0
- data/vendor/v8/include/cppgc/internal/persistent-node.h +73 -29
- data/vendor/v8/include/cppgc/internal/pointer-policies.h +26 -15
- data/vendor/v8/include/cppgc/internal/write-barrier.h +62 -23
- data/vendor/v8/include/cppgc/liveness-broker.h +4 -1
- data/vendor/v8/include/cppgc/member.h +7 -2
- data/vendor/v8/include/cppgc/persistent.h +38 -33
- data/vendor/v8/include/cppgc/platform.h +4 -1
- data/vendor/v8/include/cppgc/prefinalizer.h +35 -12
- data/vendor/v8/include/cppgc/testing.h +9 -2
- data/vendor/v8/include/cppgc/type-traits.h +6 -13
- data/vendor/v8/include/cppgc/visitor.h +9 -7
- data/vendor/v8/include/libplatform/libplatform.h +0 -11
- data/vendor/v8/include/libplatform/v8-tracing.h +0 -1
- data/vendor/v8/include/v8-array-buffer.h +445 -0
- data/vendor/v8/include/v8-callbacks.h +397 -0
- data/vendor/v8/include/v8-container.h +129 -0
- data/vendor/v8/include/v8-context.h +407 -0
- data/vendor/v8/include/v8-cppgc.h +21 -128
- data/vendor/v8/include/v8-data.h +80 -0
- data/vendor/v8/include/v8-date.h +43 -0
- data/vendor/v8/include/v8-debug.h +168 -0
- data/vendor/v8/include/v8-embedder-heap.h +218 -0
- data/vendor/v8/include/v8-embedder-state-scope.h +51 -0
- data/vendor/v8/include/v8-exception.h +217 -0
- data/vendor/v8/include/v8-extension.h +62 -0
- data/vendor/v8/include/v8-external.h +37 -0
- data/vendor/v8/include/v8-fast-api-calls.h +172 -24
- data/vendor/v8/include/v8-forward.h +81 -0
- data/vendor/v8/include/v8-function-callback.h +475 -0
- data/vendor/v8/include/v8-function.h +125 -0
- data/vendor/v8/include/v8-initialization.h +315 -0
- data/vendor/v8/include/v8-inspector.h +56 -28
- data/vendor/v8/include/v8-internal.h +217 -55
- data/vendor/v8/include/v8-isolate.h +1709 -0
- data/vendor/v8/include/v8-json.h +47 -0
- data/vendor/v8/include/v8-local-handle.h +455 -0
- data/vendor/v8/include/v8-locker.h +149 -0
- data/vendor/v8/include/v8-maybe.h +137 -0
- data/vendor/v8/include/v8-memory-span.h +43 -0
- data/vendor/v8/include/v8-message.h +216 -0
- data/vendor/v8/include/v8-metrics.h +69 -16
- data/vendor/v8/include/v8-microtask-queue.h +152 -0
- data/vendor/v8/include/v8-microtask.h +28 -0
- data/vendor/v8/include/v8-object.h +775 -0
- data/vendor/v8/include/v8-persistent-handle.h +590 -0
- data/vendor/v8/include/v8-platform.h +400 -17
- data/vendor/v8/include/v8-primitive-object.h +118 -0
- data/vendor/v8/include/v8-primitive.h +866 -0
- data/vendor/v8/include/v8-profiler.h +88 -13
- data/vendor/v8/include/v8-promise.h +174 -0
- data/vendor/v8/include/v8-proxy.h +50 -0
- data/vendor/v8/include/v8-regexp.h +105 -0
- data/vendor/v8/include/v8-script.h +747 -0
- data/vendor/v8/include/v8-snapshot.h +196 -0
- data/vendor/v8/include/v8-statistics.h +217 -0
- data/vendor/v8/include/v8-template.h +1079 -0
- data/vendor/v8/include/v8-traced-handle.h +420 -0
- data/vendor/v8/include/v8-typed-array.h +282 -0
- data/vendor/v8/include/v8-unwinder-state.h +4 -3
- data/vendor/v8/include/v8-unwinder.h +132 -0
- data/vendor/v8/include/v8-util.h +7 -1
- data/vendor/v8/include/v8-value-serializer-version.h +1 -1
- data/vendor/v8/include/v8-value-serializer.h +279 -0
- data/vendor/v8/include/v8-value.h +526 -0
- data/vendor/v8/include/v8-version.h +4 -4
- data/vendor/v8/include/v8-wasm.h +257 -0
- data/vendor/v8/include/v8-weak-callback-info.h +87 -0
- data/vendor/v8/include/v8.h +41 -12601
- data/vendor/v8/include/v8config.h +102 -12
- metadata +47 -5
- data/vendor/v8/include/cppgc/internal/prefinalizer-handler.h +0 -30
@@ -0,0 +1,420 @@
|
|
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_V8_TRACED_HANDLE_H_
|
6
|
+
#define INCLUDE_V8_TRACED_HANDLE_H_
|
7
|
+
|
8
|
+
#include <stddef.h>
|
9
|
+
#include <stdint.h>
|
10
|
+
#include <stdio.h>
|
11
|
+
|
12
|
+
#include <atomic>
|
13
|
+
#include <memory>
|
14
|
+
#include <type_traits>
|
15
|
+
#include <utility>
|
16
|
+
|
17
|
+
#include "v8-internal.h" // NOLINT(build/include_directory)
|
18
|
+
#include "v8-local-handle.h" // NOLINT(build/include_directory)
|
19
|
+
#include "v8-weak-callback-info.h" // NOLINT(build/include_directory)
|
20
|
+
#include "v8config.h" // NOLINT(build/include_directory)
|
21
|
+
|
22
|
+
namespace v8 {
|
23
|
+
|
24
|
+
class Value;
|
25
|
+
|
26
|
+
namespace internal {
|
27
|
+
|
28
|
+
class BasicTracedReferenceExtractor;
|
29
|
+
|
30
|
+
enum class GlobalHandleStoreMode {
|
31
|
+
kInitializingStore,
|
32
|
+
kAssigningStore,
|
33
|
+
};
|
34
|
+
|
35
|
+
V8_EXPORT internal::Address* GlobalizeTracedReference(
|
36
|
+
internal::Isolate* isolate, internal::Address* handle,
|
37
|
+
internal::Address* slot, GlobalHandleStoreMode store_mode);
|
38
|
+
V8_EXPORT void MoveTracedReference(internal::Address** from,
|
39
|
+
internal::Address** to);
|
40
|
+
V8_EXPORT void CopyTracedReference(const internal::Address* const* from,
|
41
|
+
internal::Address** to);
|
42
|
+
V8_EXPORT void DisposeTracedReference(internal::Address* global_handle);
|
43
|
+
|
44
|
+
} // namespace internal
|
45
|
+
|
46
|
+
class TracedReferenceBase {
|
47
|
+
public:
|
48
|
+
/**
|
49
|
+
* Returns true if the reference is empty, i.e., has not been assigned
|
50
|
+
* object.
|
51
|
+
*/
|
52
|
+
bool IsEmpty() const { return val_ == nullptr; }
|
53
|
+
|
54
|
+
/**
|
55
|
+
* If non-empty, destroy the underlying storage cell. |IsEmpty| will return
|
56
|
+
* true after this call.
|
57
|
+
*/
|
58
|
+
V8_INLINE void Reset();
|
59
|
+
|
60
|
+
/**
|
61
|
+
* Construct a Local<Value> from this handle.
|
62
|
+
*/
|
63
|
+
V8_INLINE v8::Local<v8::Value> Get(v8::Isolate* isolate) const {
|
64
|
+
if (IsEmpty()) return Local<Value>();
|
65
|
+
return Local<Value>::New(isolate, reinterpret_cast<Value*>(val_));
|
66
|
+
}
|
67
|
+
|
68
|
+
/**
|
69
|
+
* Returns true if this TracedReference is empty, i.e., has not been
|
70
|
+
* assigned an object. This version of IsEmpty is thread-safe.
|
71
|
+
*/
|
72
|
+
bool IsEmptyThreadSafe() const {
|
73
|
+
return this->GetSlotThreadSafe() == nullptr;
|
74
|
+
}
|
75
|
+
|
76
|
+
/**
|
77
|
+
* Assigns a wrapper class ID to the handle.
|
78
|
+
*/
|
79
|
+
V8_INLINE void SetWrapperClassId(uint16_t class_id);
|
80
|
+
|
81
|
+
/**
|
82
|
+
* Returns the class ID previously assigned to this handle or 0 if no class ID
|
83
|
+
* was previously assigned.
|
84
|
+
*/
|
85
|
+
V8_INLINE uint16_t WrapperClassId() const;
|
86
|
+
|
87
|
+
protected:
|
88
|
+
/**
|
89
|
+
* Update this reference in a thread-safe way.
|
90
|
+
*/
|
91
|
+
void SetSlotThreadSafe(void* new_val) {
|
92
|
+
reinterpret_cast<std::atomic<void*>*>(&val_)->store(
|
93
|
+
new_val, std::memory_order_relaxed);
|
94
|
+
}
|
95
|
+
|
96
|
+
/**
|
97
|
+
* Get this reference in a thread-safe way
|
98
|
+
*/
|
99
|
+
const void* GetSlotThreadSafe() const {
|
100
|
+
return reinterpret_cast<std::atomic<const void*> const*>(&val_)->load(
|
101
|
+
std::memory_order_relaxed);
|
102
|
+
}
|
103
|
+
|
104
|
+
V8_EXPORT void CheckValue() const;
|
105
|
+
|
106
|
+
// val_ points to a GlobalHandles node.
|
107
|
+
internal::Address* val_ = nullptr;
|
108
|
+
|
109
|
+
friend class internal::BasicTracedReferenceExtractor;
|
110
|
+
template <typename F>
|
111
|
+
friend class Local;
|
112
|
+
template <typename U>
|
113
|
+
friend bool operator==(const TracedReferenceBase&, const Local<U>&);
|
114
|
+
friend bool operator==(const TracedReferenceBase&,
|
115
|
+
const TracedReferenceBase&);
|
116
|
+
};
|
117
|
+
|
118
|
+
/**
|
119
|
+
* A traced handle with copy and move semantics. The handle is to be used
|
120
|
+
* together with |v8::EmbedderHeapTracer| or as part of GarbageCollected objects
|
121
|
+
* (see v8-cppgc.h) and specifies edges from C++ objects to JavaScript.
|
122
|
+
*
|
123
|
+
* The exact semantics are:
|
124
|
+
* - Tracing garbage collections use |v8::EmbedderHeapTracer| or cppgc.
|
125
|
+
* - Non-tracing garbage collections refer to
|
126
|
+
* |v8::EmbedderRootsHandler::IsRoot()| whether the handle should
|
127
|
+
* be treated as root or not.
|
128
|
+
*
|
129
|
+
* Note that the base class cannot be instantiated itself, use |TracedReference|
|
130
|
+
* instead.
|
131
|
+
*/
|
132
|
+
template <typename T>
|
133
|
+
class BasicTracedReference : public TracedReferenceBase {
|
134
|
+
public:
|
135
|
+
/**
|
136
|
+
* Construct a Local<T> from this handle.
|
137
|
+
*/
|
138
|
+
Local<T> Get(Isolate* isolate) const { return Local<T>::New(isolate, *this); }
|
139
|
+
|
140
|
+
template <class S>
|
141
|
+
V8_INLINE BasicTracedReference<S>& As() const {
|
142
|
+
return reinterpret_cast<BasicTracedReference<S>&>(
|
143
|
+
const_cast<BasicTracedReference<T>&>(*this));
|
144
|
+
}
|
145
|
+
|
146
|
+
T* operator->() const {
|
147
|
+
#ifdef V8_ENABLE_CHECKS
|
148
|
+
CheckValue();
|
149
|
+
#endif // V8_ENABLE_CHECKS
|
150
|
+
return reinterpret_cast<T*>(val_);
|
151
|
+
}
|
152
|
+
T* operator*() const {
|
153
|
+
#ifdef V8_ENABLE_CHECKS
|
154
|
+
CheckValue();
|
155
|
+
#endif // V8_ENABLE_CHECKS
|
156
|
+
return reinterpret_cast<T*>(val_);
|
157
|
+
}
|
158
|
+
|
159
|
+
private:
|
160
|
+
/**
|
161
|
+
* An empty BasicTracedReference without storage cell.
|
162
|
+
*/
|
163
|
+
BasicTracedReference() = default;
|
164
|
+
|
165
|
+
V8_INLINE static internal::Address* New(
|
166
|
+
Isolate* isolate, T* that, void* slot,
|
167
|
+
internal::GlobalHandleStoreMode store_mode);
|
168
|
+
|
169
|
+
friend class EmbedderHeapTracer;
|
170
|
+
template <typename F>
|
171
|
+
friend class Local;
|
172
|
+
friend class Object;
|
173
|
+
template <typename F>
|
174
|
+
friend class TracedReference;
|
175
|
+
template <typename F>
|
176
|
+
friend class BasicTracedReference;
|
177
|
+
template <typename F>
|
178
|
+
friend class ReturnValue;
|
179
|
+
};
|
180
|
+
|
181
|
+
/**
|
182
|
+
* A traced handle without destructor that clears the handle. The embedder needs
|
183
|
+
* to ensure that the handle is not accessed once the V8 object has been
|
184
|
+
* reclaimed. This can happen when the handle is not passed through the
|
185
|
+
* EmbedderHeapTracer. For more details see BasicTracedReference.
|
186
|
+
*
|
187
|
+
* The reference assumes the embedder has precise knowledge about references at
|
188
|
+
* all times. In case V8 needs to separately handle on-stack references, the
|
189
|
+
* embedder is required to set the stack start through
|
190
|
+
* |EmbedderHeapTracer::SetStackStart|.
|
191
|
+
*/
|
192
|
+
template <typename T>
|
193
|
+
class TracedReference : public BasicTracedReference<T> {
|
194
|
+
public:
|
195
|
+
using BasicTracedReference<T>::Reset;
|
196
|
+
|
197
|
+
/**
|
198
|
+
* An empty TracedReference without storage cell.
|
199
|
+
*/
|
200
|
+
TracedReference() : BasicTracedReference<T>() {}
|
201
|
+
|
202
|
+
/**
|
203
|
+
* Construct a TracedReference from a Local.
|
204
|
+
*
|
205
|
+
* When the Local is non-empty, a new storage cell is created
|
206
|
+
* pointing to the same object.
|
207
|
+
*/
|
208
|
+
template <class S>
|
209
|
+
TracedReference(Isolate* isolate, Local<S> that) : BasicTracedReference<T>() {
|
210
|
+
this->val_ = this->New(isolate, that.val_, &this->val_,
|
211
|
+
internal::GlobalHandleStoreMode::kInitializingStore);
|
212
|
+
static_assert(std::is_base_of<T, S>::value, "type check");
|
213
|
+
}
|
214
|
+
|
215
|
+
/**
|
216
|
+
* Move constructor initializing TracedReference from an
|
217
|
+
* existing one.
|
218
|
+
*/
|
219
|
+
V8_INLINE TracedReference(TracedReference&& other) noexcept {
|
220
|
+
// Forward to operator=.
|
221
|
+
*this = std::move(other);
|
222
|
+
}
|
223
|
+
|
224
|
+
/**
|
225
|
+
* Move constructor initializing TracedReference from an
|
226
|
+
* existing one.
|
227
|
+
*/
|
228
|
+
template <typename S>
|
229
|
+
V8_INLINE TracedReference(TracedReference<S>&& other) noexcept {
|
230
|
+
// Forward to operator=.
|
231
|
+
*this = std::move(other);
|
232
|
+
}
|
233
|
+
|
234
|
+
/**
|
235
|
+
* Copy constructor initializing TracedReference from an
|
236
|
+
* existing one.
|
237
|
+
*/
|
238
|
+
V8_INLINE TracedReference(const TracedReference& other) {
|
239
|
+
// Forward to operator=;
|
240
|
+
*this = other;
|
241
|
+
}
|
242
|
+
|
243
|
+
/**
|
244
|
+
* Copy constructor initializing TracedReference from an
|
245
|
+
* existing one.
|
246
|
+
*/
|
247
|
+
template <typename S>
|
248
|
+
V8_INLINE TracedReference(const TracedReference<S>& other) {
|
249
|
+
// Forward to operator=;
|
250
|
+
*this = other;
|
251
|
+
}
|
252
|
+
|
253
|
+
/**
|
254
|
+
* Move assignment operator initializing TracedReference from an existing one.
|
255
|
+
*/
|
256
|
+
V8_INLINE TracedReference& operator=(TracedReference&& rhs) noexcept;
|
257
|
+
|
258
|
+
/**
|
259
|
+
* Move assignment operator initializing TracedReference from an existing one.
|
260
|
+
*/
|
261
|
+
template <class S>
|
262
|
+
V8_INLINE TracedReference& operator=(TracedReference<S>&& rhs) noexcept;
|
263
|
+
|
264
|
+
/**
|
265
|
+
* Copy assignment operator initializing TracedReference from an existing one.
|
266
|
+
*/
|
267
|
+
V8_INLINE TracedReference& operator=(const TracedReference& rhs);
|
268
|
+
|
269
|
+
/**
|
270
|
+
* Copy assignment operator initializing TracedReference from an existing one.
|
271
|
+
*/
|
272
|
+
template <class S>
|
273
|
+
V8_INLINE TracedReference& operator=(const TracedReference<S>& rhs);
|
274
|
+
|
275
|
+
/**
|
276
|
+
* If non-empty, destroy the underlying storage cell and create a new one with
|
277
|
+
* the contents of other if other is non empty
|
278
|
+
*/
|
279
|
+
template <class S>
|
280
|
+
V8_INLINE void Reset(Isolate* isolate, const Local<S>& other);
|
281
|
+
|
282
|
+
template <class S>
|
283
|
+
V8_INLINE TracedReference<S>& As() const {
|
284
|
+
return reinterpret_cast<TracedReference<S>&>(
|
285
|
+
const_cast<TracedReference<T>&>(*this));
|
286
|
+
}
|
287
|
+
};
|
288
|
+
|
289
|
+
// --- Implementation ---
|
290
|
+
template <class T>
|
291
|
+
internal::Address* BasicTracedReference<T>::New(
|
292
|
+
Isolate* isolate, T* that, void* slot,
|
293
|
+
internal::GlobalHandleStoreMode store_mode) {
|
294
|
+
if (that == nullptr) return nullptr;
|
295
|
+
internal::Address* p = reinterpret_cast<internal::Address*>(that);
|
296
|
+
return internal::GlobalizeTracedReference(
|
297
|
+
reinterpret_cast<internal::Isolate*>(isolate), p,
|
298
|
+
reinterpret_cast<internal::Address*>(slot), store_mode);
|
299
|
+
}
|
300
|
+
|
301
|
+
void TracedReferenceBase::Reset() {
|
302
|
+
if (IsEmpty()) return;
|
303
|
+
internal::DisposeTracedReference(reinterpret_cast<internal::Address*>(val_));
|
304
|
+
SetSlotThreadSafe(nullptr);
|
305
|
+
}
|
306
|
+
|
307
|
+
V8_INLINE bool operator==(const TracedReferenceBase& lhs,
|
308
|
+
const TracedReferenceBase& rhs) {
|
309
|
+
v8::internal::Address* a = reinterpret_cast<v8::internal::Address*>(lhs.val_);
|
310
|
+
v8::internal::Address* b = reinterpret_cast<v8::internal::Address*>(rhs.val_);
|
311
|
+
if (a == nullptr) return b == nullptr;
|
312
|
+
if (b == nullptr) return false;
|
313
|
+
return *a == *b;
|
314
|
+
}
|
315
|
+
|
316
|
+
template <typename U>
|
317
|
+
V8_INLINE bool operator==(const TracedReferenceBase& lhs,
|
318
|
+
const v8::Local<U>& rhs) {
|
319
|
+
v8::internal::Address* a = reinterpret_cast<v8::internal::Address*>(lhs.val_);
|
320
|
+
v8::internal::Address* b = reinterpret_cast<v8::internal::Address*>(*rhs);
|
321
|
+
if (a == nullptr) return b == nullptr;
|
322
|
+
if (b == nullptr) return false;
|
323
|
+
return *a == *b;
|
324
|
+
}
|
325
|
+
|
326
|
+
template <typename U>
|
327
|
+
V8_INLINE bool operator==(const v8::Local<U>& lhs,
|
328
|
+
const TracedReferenceBase& rhs) {
|
329
|
+
return rhs == lhs;
|
330
|
+
}
|
331
|
+
|
332
|
+
V8_INLINE bool operator!=(const TracedReferenceBase& lhs,
|
333
|
+
const TracedReferenceBase& rhs) {
|
334
|
+
return !(lhs == rhs);
|
335
|
+
}
|
336
|
+
|
337
|
+
template <typename U>
|
338
|
+
V8_INLINE bool operator!=(const TracedReferenceBase& lhs,
|
339
|
+
const v8::Local<U>& rhs) {
|
340
|
+
return !(lhs == rhs);
|
341
|
+
}
|
342
|
+
|
343
|
+
template <typename U>
|
344
|
+
V8_INLINE bool operator!=(const v8::Local<U>& lhs,
|
345
|
+
const TracedReferenceBase& rhs) {
|
346
|
+
return !(rhs == lhs);
|
347
|
+
}
|
348
|
+
|
349
|
+
template <class T>
|
350
|
+
template <class S>
|
351
|
+
void TracedReference<T>::Reset(Isolate* isolate, const Local<S>& other) {
|
352
|
+
static_assert(std::is_base_of<T, S>::value, "type check");
|
353
|
+
this->Reset();
|
354
|
+
if (other.IsEmpty()) return;
|
355
|
+
this->SetSlotThreadSafe(
|
356
|
+
this->New(isolate, other.val_, &this->val_,
|
357
|
+
internal::GlobalHandleStoreMode::kAssigningStore));
|
358
|
+
}
|
359
|
+
|
360
|
+
template <class T>
|
361
|
+
template <class S>
|
362
|
+
TracedReference<T>& TracedReference<T>::operator=(
|
363
|
+
TracedReference<S>&& rhs) noexcept {
|
364
|
+
static_assert(std::is_base_of<T, S>::value, "type check");
|
365
|
+
*this = std::move(rhs.template As<T>());
|
366
|
+
return *this;
|
367
|
+
}
|
368
|
+
|
369
|
+
template <class T>
|
370
|
+
template <class S>
|
371
|
+
TracedReference<T>& TracedReference<T>::operator=(
|
372
|
+
const TracedReference<S>& rhs) {
|
373
|
+
static_assert(std::is_base_of<T, S>::value, "type check");
|
374
|
+
*this = rhs.template As<T>();
|
375
|
+
return *this;
|
376
|
+
}
|
377
|
+
|
378
|
+
template <class T>
|
379
|
+
TracedReference<T>& TracedReference<T>::operator=(
|
380
|
+
TracedReference&& rhs) noexcept {
|
381
|
+
if (this != &rhs) {
|
382
|
+
internal::MoveTracedReference(
|
383
|
+
reinterpret_cast<internal::Address**>(&rhs.val_),
|
384
|
+
reinterpret_cast<internal::Address**>(&this->val_));
|
385
|
+
}
|
386
|
+
return *this;
|
387
|
+
}
|
388
|
+
|
389
|
+
template <class T>
|
390
|
+
TracedReference<T>& TracedReference<T>::operator=(const TracedReference& rhs) {
|
391
|
+
if (this != &rhs) {
|
392
|
+
this->Reset();
|
393
|
+
if (rhs.val_ != nullptr) {
|
394
|
+
internal::CopyTracedReference(
|
395
|
+
reinterpret_cast<const internal::Address* const*>(&rhs.val_),
|
396
|
+
reinterpret_cast<internal::Address**>(&this->val_));
|
397
|
+
}
|
398
|
+
}
|
399
|
+
return *this;
|
400
|
+
}
|
401
|
+
|
402
|
+
void TracedReferenceBase::SetWrapperClassId(uint16_t class_id) {
|
403
|
+
using I = internal::Internals;
|
404
|
+
if (IsEmpty()) return;
|
405
|
+
internal::Address* obj = reinterpret_cast<internal::Address*>(val_);
|
406
|
+
uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + I::kNodeClassIdOffset;
|
407
|
+
*reinterpret_cast<uint16_t*>(addr) = class_id;
|
408
|
+
}
|
409
|
+
|
410
|
+
uint16_t TracedReferenceBase::WrapperClassId() const {
|
411
|
+
using I = internal::Internals;
|
412
|
+
if (IsEmpty()) return 0;
|
413
|
+
internal::Address* obj = reinterpret_cast<internal::Address*>(val_);
|
414
|
+
uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + I::kNodeClassIdOffset;
|
415
|
+
return *reinterpret_cast<uint16_t*>(addr);
|
416
|
+
}
|
417
|
+
|
418
|
+
} // namespace v8
|
419
|
+
|
420
|
+
#endif // INCLUDE_V8_TRACED_HANDLE_H_
|
@@ -0,0 +1,282 @@
|
|
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_V8_TYPED_ARRAY_H_
|
6
|
+
#define INCLUDE_V8_TYPED_ARRAY_H_
|
7
|
+
|
8
|
+
#include "v8-array-buffer.h" // NOLINT(build/include_directory)
|
9
|
+
#include "v8-local-handle.h" // NOLINT(build/include_directory)
|
10
|
+
#include "v8config.h" // NOLINT(build/include_directory)
|
11
|
+
|
12
|
+
namespace v8 {
|
13
|
+
|
14
|
+
class SharedArrayBuffer;
|
15
|
+
|
16
|
+
/**
|
17
|
+
* A base class for an instance of TypedArray series of constructors
|
18
|
+
* (ES6 draft 15.13.6).
|
19
|
+
*/
|
20
|
+
class V8_EXPORT TypedArray : public ArrayBufferView {
|
21
|
+
public:
|
22
|
+
/*
|
23
|
+
* The largest typed array size that can be constructed using New.
|
24
|
+
*/
|
25
|
+
static constexpr size_t kMaxLength =
|
26
|
+
internal::kApiSystemPointerSize == 4
|
27
|
+
? internal::kSmiMaxValue
|
28
|
+
: static_cast<size_t>(uint64_t{1} << 32);
|
29
|
+
|
30
|
+
/**
|
31
|
+
* Number of elements in this typed array
|
32
|
+
* (e.g. for Int16Array, |ByteLength|/2).
|
33
|
+
*/
|
34
|
+
size_t Length();
|
35
|
+
|
36
|
+
V8_INLINE static TypedArray* Cast(Value* value) {
|
37
|
+
#ifdef V8_ENABLE_CHECKS
|
38
|
+
CheckCast(value);
|
39
|
+
#endif
|
40
|
+
return static_cast<TypedArray*>(value);
|
41
|
+
}
|
42
|
+
|
43
|
+
private:
|
44
|
+
TypedArray();
|
45
|
+
static void CheckCast(Value* obj);
|
46
|
+
};
|
47
|
+
|
48
|
+
/**
|
49
|
+
* An instance of Uint8Array constructor (ES6 draft 15.13.6).
|
50
|
+
*/
|
51
|
+
class V8_EXPORT Uint8Array : public TypedArray {
|
52
|
+
public:
|
53
|
+
static Local<Uint8Array> New(Local<ArrayBuffer> array_buffer,
|
54
|
+
size_t byte_offset, size_t length);
|
55
|
+
static Local<Uint8Array> New(Local<SharedArrayBuffer> shared_array_buffer,
|
56
|
+
size_t byte_offset, size_t length);
|
57
|
+
V8_INLINE static Uint8Array* Cast(Value* value) {
|
58
|
+
#ifdef V8_ENABLE_CHECKS
|
59
|
+
CheckCast(value);
|
60
|
+
#endif
|
61
|
+
return static_cast<Uint8Array*>(value);
|
62
|
+
}
|
63
|
+
|
64
|
+
private:
|
65
|
+
Uint8Array();
|
66
|
+
static void CheckCast(Value* obj);
|
67
|
+
};
|
68
|
+
|
69
|
+
/**
|
70
|
+
* An instance of Uint8ClampedArray constructor (ES6 draft 15.13.6).
|
71
|
+
*/
|
72
|
+
class V8_EXPORT Uint8ClampedArray : public TypedArray {
|
73
|
+
public:
|
74
|
+
static Local<Uint8ClampedArray> New(Local<ArrayBuffer> array_buffer,
|
75
|
+
size_t byte_offset, size_t length);
|
76
|
+
static Local<Uint8ClampedArray> New(
|
77
|
+
Local<SharedArrayBuffer> shared_array_buffer, size_t byte_offset,
|
78
|
+
size_t length);
|
79
|
+
V8_INLINE static Uint8ClampedArray* Cast(Value* value) {
|
80
|
+
#ifdef V8_ENABLE_CHECKS
|
81
|
+
CheckCast(value);
|
82
|
+
#endif
|
83
|
+
return static_cast<Uint8ClampedArray*>(value);
|
84
|
+
}
|
85
|
+
|
86
|
+
private:
|
87
|
+
Uint8ClampedArray();
|
88
|
+
static void CheckCast(Value* obj);
|
89
|
+
};
|
90
|
+
|
91
|
+
/**
|
92
|
+
* An instance of Int8Array constructor (ES6 draft 15.13.6).
|
93
|
+
*/
|
94
|
+
class V8_EXPORT Int8Array : public TypedArray {
|
95
|
+
public:
|
96
|
+
static Local<Int8Array> New(Local<ArrayBuffer> array_buffer,
|
97
|
+
size_t byte_offset, size_t length);
|
98
|
+
static Local<Int8Array> New(Local<SharedArrayBuffer> shared_array_buffer,
|
99
|
+
size_t byte_offset, size_t length);
|
100
|
+
V8_INLINE static Int8Array* Cast(Value* value) {
|
101
|
+
#ifdef V8_ENABLE_CHECKS
|
102
|
+
CheckCast(value);
|
103
|
+
#endif
|
104
|
+
return static_cast<Int8Array*>(value);
|
105
|
+
}
|
106
|
+
|
107
|
+
private:
|
108
|
+
Int8Array();
|
109
|
+
static void CheckCast(Value* obj);
|
110
|
+
};
|
111
|
+
|
112
|
+
/**
|
113
|
+
* An instance of Uint16Array constructor (ES6 draft 15.13.6).
|
114
|
+
*/
|
115
|
+
class V8_EXPORT Uint16Array : public TypedArray {
|
116
|
+
public:
|
117
|
+
static Local<Uint16Array> New(Local<ArrayBuffer> array_buffer,
|
118
|
+
size_t byte_offset, size_t length);
|
119
|
+
static Local<Uint16Array> New(Local<SharedArrayBuffer> shared_array_buffer,
|
120
|
+
size_t byte_offset, size_t length);
|
121
|
+
V8_INLINE static Uint16Array* Cast(Value* value) {
|
122
|
+
#ifdef V8_ENABLE_CHECKS
|
123
|
+
CheckCast(value);
|
124
|
+
#endif
|
125
|
+
return static_cast<Uint16Array*>(value);
|
126
|
+
}
|
127
|
+
|
128
|
+
private:
|
129
|
+
Uint16Array();
|
130
|
+
static void CheckCast(Value* obj);
|
131
|
+
};
|
132
|
+
|
133
|
+
/**
|
134
|
+
* An instance of Int16Array constructor (ES6 draft 15.13.6).
|
135
|
+
*/
|
136
|
+
class V8_EXPORT Int16Array : public TypedArray {
|
137
|
+
public:
|
138
|
+
static Local<Int16Array> New(Local<ArrayBuffer> array_buffer,
|
139
|
+
size_t byte_offset, size_t length);
|
140
|
+
static Local<Int16Array> New(Local<SharedArrayBuffer> shared_array_buffer,
|
141
|
+
size_t byte_offset, size_t length);
|
142
|
+
V8_INLINE static Int16Array* Cast(Value* value) {
|
143
|
+
#ifdef V8_ENABLE_CHECKS
|
144
|
+
CheckCast(value);
|
145
|
+
#endif
|
146
|
+
return static_cast<Int16Array*>(value);
|
147
|
+
}
|
148
|
+
|
149
|
+
private:
|
150
|
+
Int16Array();
|
151
|
+
static void CheckCast(Value* obj);
|
152
|
+
};
|
153
|
+
|
154
|
+
/**
|
155
|
+
* An instance of Uint32Array constructor (ES6 draft 15.13.6).
|
156
|
+
*/
|
157
|
+
class V8_EXPORT Uint32Array : public TypedArray {
|
158
|
+
public:
|
159
|
+
static Local<Uint32Array> New(Local<ArrayBuffer> array_buffer,
|
160
|
+
size_t byte_offset, size_t length);
|
161
|
+
static Local<Uint32Array> New(Local<SharedArrayBuffer> shared_array_buffer,
|
162
|
+
size_t byte_offset, size_t length);
|
163
|
+
V8_INLINE static Uint32Array* Cast(Value* value) {
|
164
|
+
#ifdef V8_ENABLE_CHECKS
|
165
|
+
CheckCast(value);
|
166
|
+
#endif
|
167
|
+
return static_cast<Uint32Array*>(value);
|
168
|
+
}
|
169
|
+
|
170
|
+
private:
|
171
|
+
Uint32Array();
|
172
|
+
static void CheckCast(Value* obj);
|
173
|
+
};
|
174
|
+
|
175
|
+
/**
|
176
|
+
* An instance of Int32Array constructor (ES6 draft 15.13.6).
|
177
|
+
*/
|
178
|
+
class V8_EXPORT Int32Array : public TypedArray {
|
179
|
+
public:
|
180
|
+
static Local<Int32Array> New(Local<ArrayBuffer> array_buffer,
|
181
|
+
size_t byte_offset, size_t length);
|
182
|
+
static Local<Int32Array> New(Local<SharedArrayBuffer> shared_array_buffer,
|
183
|
+
size_t byte_offset, size_t length);
|
184
|
+
V8_INLINE static Int32Array* Cast(Value* value) {
|
185
|
+
#ifdef V8_ENABLE_CHECKS
|
186
|
+
CheckCast(value);
|
187
|
+
#endif
|
188
|
+
return static_cast<Int32Array*>(value);
|
189
|
+
}
|
190
|
+
|
191
|
+
private:
|
192
|
+
Int32Array();
|
193
|
+
static void CheckCast(Value* obj);
|
194
|
+
};
|
195
|
+
|
196
|
+
/**
|
197
|
+
* An instance of Float32Array constructor (ES6 draft 15.13.6).
|
198
|
+
*/
|
199
|
+
class V8_EXPORT Float32Array : public TypedArray {
|
200
|
+
public:
|
201
|
+
static Local<Float32Array> New(Local<ArrayBuffer> array_buffer,
|
202
|
+
size_t byte_offset, size_t length);
|
203
|
+
static Local<Float32Array> New(Local<SharedArrayBuffer> shared_array_buffer,
|
204
|
+
size_t byte_offset, size_t length);
|
205
|
+
V8_INLINE static Float32Array* Cast(Value* value) {
|
206
|
+
#ifdef V8_ENABLE_CHECKS
|
207
|
+
CheckCast(value);
|
208
|
+
#endif
|
209
|
+
return static_cast<Float32Array*>(value);
|
210
|
+
}
|
211
|
+
|
212
|
+
private:
|
213
|
+
Float32Array();
|
214
|
+
static void CheckCast(Value* obj);
|
215
|
+
};
|
216
|
+
|
217
|
+
/**
|
218
|
+
* An instance of Float64Array constructor (ES6 draft 15.13.6).
|
219
|
+
*/
|
220
|
+
class V8_EXPORT Float64Array : public TypedArray {
|
221
|
+
public:
|
222
|
+
static Local<Float64Array> New(Local<ArrayBuffer> array_buffer,
|
223
|
+
size_t byte_offset, size_t length);
|
224
|
+
static Local<Float64Array> New(Local<SharedArrayBuffer> shared_array_buffer,
|
225
|
+
size_t byte_offset, size_t length);
|
226
|
+
V8_INLINE static Float64Array* Cast(Value* value) {
|
227
|
+
#ifdef V8_ENABLE_CHECKS
|
228
|
+
CheckCast(value);
|
229
|
+
#endif
|
230
|
+
return static_cast<Float64Array*>(value);
|
231
|
+
}
|
232
|
+
|
233
|
+
private:
|
234
|
+
Float64Array();
|
235
|
+
static void CheckCast(Value* obj);
|
236
|
+
};
|
237
|
+
|
238
|
+
/**
|
239
|
+
* An instance of BigInt64Array constructor.
|
240
|
+
*/
|
241
|
+
class V8_EXPORT BigInt64Array : public TypedArray {
|
242
|
+
public:
|
243
|
+
static Local<BigInt64Array> New(Local<ArrayBuffer> array_buffer,
|
244
|
+
size_t byte_offset, size_t length);
|
245
|
+
static Local<BigInt64Array> New(Local<SharedArrayBuffer> shared_array_buffer,
|
246
|
+
size_t byte_offset, size_t length);
|
247
|
+
V8_INLINE static BigInt64Array* Cast(Value* value) {
|
248
|
+
#ifdef V8_ENABLE_CHECKS
|
249
|
+
CheckCast(value);
|
250
|
+
#endif
|
251
|
+
return static_cast<BigInt64Array*>(value);
|
252
|
+
}
|
253
|
+
|
254
|
+
private:
|
255
|
+
BigInt64Array();
|
256
|
+
static void CheckCast(Value* obj);
|
257
|
+
};
|
258
|
+
|
259
|
+
/**
|
260
|
+
* An instance of BigUint64Array constructor.
|
261
|
+
*/
|
262
|
+
class V8_EXPORT BigUint64Array : public TypedArray {
|
263
|
+
public:
|
264
|
+
static Local<BigUint64Array> New(Local<ArrayBuffer> array_buffer,
|
265
|
+
size_t byte_offset, size_t length);
|
266
|
+
static Local<BigUint64Array> New(Local<SharedArrayBuffer> shared_array_buffer,
|
267
|
+
size_t byte_offset, size_t length);
|
268
|
+
V8_INLINE static BigUint64Array* Cast(Value* value) {
|
269
|
+
#ifdef V8_ENABLE_CHECKS
|
270
|
+
CheckCast(value);
|
271
|
+
#endif
|
272
|
+
return static_cast<BigUint64Array*>(value);
|
273
|
+
}
|
274
|
+
|
275
|
+
private:
|
276
|
+
BigUint64Array();
|
277
|
+
static void CheckCast(Value* obj);
|
278
|
+
};
|
279
|
+
|
280
|
+
} // namespace v8
|
281
|
+
|
282
|
+
#endif // INCLUDE_V8_TYPED_ARRAY_H_
|
@@ -17,9 +17,10 @@ struct CalleeSavedRegisters {
|
|
17
17
|
void* arm_r9;
|
18
18
|
void* arm_r10;
|
19
19
|
};
|
20
|
-
#elif V8_TARGET_ARCH_X64 || V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_ARM64 ||
|
21
|
-
V8_TARGET_ARCH_MIPS || V8_TARGET_ARCH_MIPS64 || V8_TARGET_ARCH_PPC ||
|
22
|
-
V8_TARGET_ARCH_PPC64 || V8_TARGET_ARCH_RISCV64 || V8_TARGET_ARCH_S390
|
20
|
+
#elif V8_TARGET_ARCH_X64 || V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_ARM64 || \
|
21
|
+
V8_TARGET_ARCH_MIPS || V8_TARGET_ARCH_MIPS64 || V8_TARGET_ARCH_PPC || \
|
22
|
+
V8_TARGET_ARCH_PPC64 || V8_TARGET_ARCH_RISCV64 || V8_TARGET_ARCH_S390 || \
|
23
|
+
V8_TARGET_ARCH_LOONG64
|
23
24
|
struct CalleeSavedRegisters {};
|
24
25
|
#else
|
25
26
|
#error Target architecture was not detected as supported by v8
|