libv8-node 16.19.0.1-aarch64-linux → 17.9.1.1-aarch64-linux
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +4 -4
- 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 +11 -5
- data/vendor/v8/include/cppgc/cross-thread-persistent.h +78 -26
- data/vendor/v8/include/cppgc/internal/caged-heap-local-data.h +2 -2
- data/vendor/v8/include/cppgc/internal/finalizer-trait.h +2 -0
- data/vendor/v8/include/cppgc/internal/gc-info.h +90 -10
- data/vendor/v8/include/cppgc/internal/name-trait.h +11 -0
- data/vendor/v8/include/cppgc/internal/persistent-node.h +44 -12
- data/vendor/v8/include/cppgc/internal/pointer-policies.h +22 -11
- data/vendor/v8/include/cppgc/internal/write-barrier.h +9 -1
- data/vendor/v8/include/cppgc/persistent.h +1 -1
- data/vendor/v8/include/cppgc/prefinalizer.h +1 -1
- data/vendor/v8/include/v8-array-buffer.h +433 -0
- data/vendor/v8/include/v8-callbacks.h +377 -0
- data/vendor/v8/include/v8-container.h +129 -0
- data/vendor/v8/include/v8-context.h +418 -0
- data/vendor/v8/include/v8-cppgc.h +5 -2
- data/vendor/v8/include/v8-data.h +65 -0
- data/vendor/v8/include/v8-date.h +43 -0
- data/vendor/v8/include/v8-debug.h +151 -0
- data/vendor/v8/include/v8-embedder-heap.h +238 -0
- data/vendor/v8/include/v8-exception.h +224 -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 +63 -11
- 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 +122 -0
- data/vendor/v8/include/v8-initialization.h +282 -0
- data/vendor/v8/include/v8-inspector.h +11 -21
- data/vendor/v8/include/v8-internal.h +85 -22
- data/vendor/v8/include/v8-isolate.h +1662 -0
- data/vendor/v8/include/v8-json.h +47 -0
- data/vendor/v8/include/v8-local-handle.h +459 -0
- data/vendor/v8/include/v8-locker.h +148 -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 +241 -0
- data/vendor/v8/include/v8-metrics.h +37 -1
- 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 +770 -0
- data/vendor/v8/include/v8-persistent-handle.h +590 -0
- data/vendor/v8/include/v8-platform.h +41 -17
- data/vendor/v8/include/v8-primitive-object.h +118 -0
- data/vendor/v8/include/v8-primitive.h +858 -0
- data/vendor/v8/include/v8-profiler.h +10 -11
- 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 +771 -0
- data/vendor/v8/include/v8-snapshot.h +198 -0
- data/vendor/v8/include/v8-statistics.h +215 -0
- data/vendor/v8/include/v8-template.h +1052 -0
- data/vendor/v8/include/v8-traced-handle.h +605 -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 +129 -0
- data/vendor/v8/include/v8-util.h +7 -1
- data/vendor/v8/include/v8-value-serializer.h +249 -0
- data/vendor/v8/include/v8-value.h +526 -0
- data/vendor/v8/include/v8-version.h +3 -3
- data/vendor/v8/include/v8-wasm.h +245 -0
- data/vendor/v8/include/v8-weak-callback-info.h +73 -0
- data/vendor/v8/include/v8.h +41 -12604
- metadata +43 -1
@@ -0,0 +1,590 @@
|
|
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_PERSISTENT_HANDLE_H_
|
6
|
+
#define INCLUDE_V8_PERSISTENT_HANDLE_H_
|
7
|
+
|
8
|
+
#include "v8-internal.h" // NOLINT(build/include_directory)
|
9
|
+
#include "v8-local-handle.h" // NOLINT(build/include_directory)
|
10
|
+
#include "v8-weak-callback-info.h" // NOLINT(build/include_directory)
|
11
|
+
#include "v8config.h" // NOLINT(build/include_directory)
|
12
|
+
|
13
|
+
namespace v8 {
|
14
|
+
|
15
|
+
class Isolate;
|
16
|
+
template <class K, class V, class T>
|
17
|
+
class PersistentValueMapBase;
|
18
|
+
template <class V, class T>
|
19
|
+
class PersistentValueVector;
|
20
|
+
template <class T>
|
21
|
+
class Global;
|
22
|
+
template <class T>
|
23
|
+
class PersistentBase;
|
24
|
+
template <class K, class V, class T>
|
25
|
+
class PersistentValueMap;
|
26
|
+
class Value;
|
27
|
+
|
28
|
+
namespace api_internal {
|
29
|
+
V8_EXPORT Value* Eternalize(v8::Isolate* isolate, Value* handle);
|
30
|
+
V8_EXPORT internal::Address* CopyGlobalReference(internal::Address* from);
|
31
|
+
V8_EXPORT void DisposeGlobal(internal::Address* global_handle);
|
32
|
+
V8_EXPORT void MakeWeak(internal::Address** location_addr);
|
33
|
+
V8_EXPORT void* ClearWeak(internal::Address* location);
|
34
|
+
V8_EXPORT void AnnotateStrongRetainer(internal::Address* location,
|
35
|
+
const char* label);
|
36
|
+
V8_EXPORT internal::Address* GlobalizeReference(internal::Isolate* isolate,
|
37
|
+
internal::Address* handle);
|
38
|
+
V8_EXPORT void MoveGlobalReference(internal::Address** from,
|
39
|
+
internal::Address** to);
|
40
|
+
} // namespace api_internal
|
41
|
+
|
42
|
+
/**
|
43
|
+
* Eternal handles are set-once handles that live for the lifetime of the
|
44
|
+
* isolate.
|
45
|
+
*/
|
46
|
+
template <class T>
|
47
|
+
class Eternal {
|
48
|
+
public:
|
49
|
+
V8_INLINE Eternal() : val_(nullptr) {}
|
50
|
+
template <class S>
|
51
|
+
V8_INLINE Eternal(Isolate* isolate, Local<S> handle) : val_(nullptr) {
|
52
|
+
Set(isolate, handle);
|
53
|
+
}
|
54
|
+
// Can only be safely called if already set.
|
55
|
+
V8_INLINE Local<T> Get(Isolate* isolate) const {
|
56
|
+
// The eternal handle will never go away, so as with the roots, we don't
|
57
|
+
// even need to open a handle.
|
58
|
+
return Local<T>(val_);
|
59
|
+
}
|
60
|
+
|
61
|
+
V8_INLINE bool IsEmpty() const { return val_ == nullptr; }
|
62
|
+
|
63
|
+
template <class S>
|
64
|
+
void Set(Isolate* isolate, Local<S> handle) {
|
65
|
+
static_assert(std::is_base_of<T, S>::value, "type check");
|
66
|
+
val_ = reinterpret_cast<T*>(
|
67
|
+
api_internal::Eternalize(isolate, reinterpret_cast<Value*>(*handle)));
|
68
|
+
}
|
69
|
+
|
70
|
+
private:
|
71
|
+
T* val_;
|
72
|
+
};
|
73
|
+
|
74
|
+
namespace api_internal {
|
75
|
+
V8_EXPORT void MakeWeak(internal::Address* location, void* data,
|
76
|
+
WeakCallbackInfo<void>::Callback weak_callback,
|
77
|
+
WeakCallbackType type);
|
78
|
+
} // namespace api_internal
|
79
|
+
|
80
|
+
/**
|
81
|
+
* An object reference that is independent of any handle scope. Where
|
82
|
+
* a Local handle only lives as long as the HandleScope in which it was
|
83
|
+
* allocated, a PersistentBase handle remains valid until it is explicitly
|
84
|
+
* disposed using Reset().
|
85
|
+
*
|
86
|
+
* A persistent handle contains a reference to a storage cell within
|
87
|
+
* the V8 engine which holds an object value and which is updated by
|
88
|
+
* the garbage collector whenever the object is moved. A new storage
|
89
|
+
* cell can be created using the constructor or PersistentBase::Reset and
|
90
|
+
* existing handles can be disposed using PersistentBase::Reset.
|
91
|
+
*
|
92
|
+
*/
|
93
|
+
template <class T>
|
94
|
+
class PersistentBase {
|
95
|
+
public:
|
96
|
+
/**
|
97
|
+
* If non-empty, destroy the underlying storage cell
|
98
|
+
* IsEmpty() will return true after this call.
|
99
|
+
*/
|
100
|
+
V8_INLINE void Reset();
|
101
|
+
|
102
|
+
/**
|
103
|
+
* If non-empty, destroy the underlying storage cell
|
104
|
+
* and create a new one with the contents of other if other is non empty
|
105
|
+
*/
|
106
|
+
template <class S>
|
107
|
+
V8_INLINE void Reset(Isolate* isolate, const Local<S>& other);
|
108
|
+
|
109
|
+
/**
|
110
|
+
* If non-empty, destroy the underlying storage cell
|
111
|
+
* and create a new one with the contents of other if other is non empty
|
112
|
+
*/
|
113
|
+
template <class S>
|
114
|
+
V8_INLINE void Reset(Isolate* isolate, const PersistentBase<S>& other);
|
115
|
+
|
116
|
+
V8_INLINE bool IsEmpty() const { return val_ == nullptr; }
|
117
|
+
V8_INLINE void Empty() { val_ = 0; }
|
118
|
+
|
119
|
+
V8_INLINE Local<T> Get(Isolate* isolate) const {
|
120
|
+
return Local<T>::New(isolate, *this);
|
121
|
+
}
|
122
|
+
|
123
|
+
template <class S>
|
124
|
+
V8_INLINE bool operator==(const PersistentBase<S>& that) const {
|
125
|
+
internal::Address* a = reinterpret_cast<internal::Address*>(this->val_);
|
126
|
+
internal::Address* b = reinterpret_cast<internal::Address*>(that.val_);
|
127
|
+
if (a == nullptr) return b == nullptr;
|
128
|
+
if (b == nullptr) return false;
|
129
|
+
return *a == *b;
|
130
|
+
}
|
131
|
+
|
132
|
+
template <class S>
|
133
|
+
V8_INLINE bool operator==(const Local<S>& that) const {
|
134
|
+
internal::Address* a = reinterpret_cast<internal::Address*>(this->val_);
|
135
|
+
internal::Address* b = reinterpret_cast<internal::Address*>(that.val_);
|
136
|
+
if (a == nullptr) return b == nullptr;
|
137
|
+
if (b == nullptr) return false;
|
138
|
+
return *a == *b;
|
139
|
+
}
|
140
|
+
|
141
|
+
template <class S>
|
142
|
+
V8_INLINE bool operator!=(const PersistentBase<S>& that) const {
|
143
|
+
return !operator==(that);
|
144
|
+
}
|
145
|
+
|
146
|
+
template <class S>
|
147
|
+
V8_INLINE bool operator!=(const Local<S>& that) const {
|
148
|
+
return !operator==(that);
|
149
|
+
}
|
150
|
+
|
151
|
+
/**
|
152
|
+
* Install a finalization callback on this object.
|
153
|
+
* NOTE: There is no guarantee as to *when* or even *if* the callback is
|
154
|
+
* invoked. The invocation is performed solely on a best effort basis.
|
155
|
+
* As always, GC-based finalization should *not* be relied upon for any
|
156
|
+
* critical form of resource management!
|
157
|
+
*
|
158
|
+
* The callback is supposed to reset the handle. No further V8 API may be
|
159
|
+
* called in this callback. In case additional work involving V8 needs to be
|
160
|
+
* done, a second callback can be scheduled using
|
161
|
+
* WeakCallbackInfo<void>::SetSecondPassCallback.
|
162
|
+
*/
|
163
|
+
template <typename P>
|
164
|
+
V8_INLINE void SetWeak(P* parameter,
|
165
|
+
typename WeakCallbackInfo<P>::Callback callback,
|
166
|
+
WeakCallbackType type);
|
167
|
+
|
168
|
+
/**
|
169
|
+
* Turns this handle into a weak phantom handle without finalization callback.
|
170
|
+
* The handle will be reset automatically when the garbage collector detects
|
171
|
+
* that the object is no longer reachable.
|
172
|
+
* A related function Isolate::NumberOfPhantomHandleResetsSinceLastCall
|
173
|
+
* returns how many phantom handles were reset by the garbage collector.
|
174
|
+
*/
|
175
|
+
V8_INLINE void SetWeak();
|
176
|
+
|
177
|
+
template <typename P>
|
178
|
+
V8_INLINE P* ClearWeak();
|
179
|
+
|
180
|
+
// TODO(dcarney): remove this.
|
181
|
+
V8_INLINE void ClearWeak() { ClearWeak<void>(); }
|
182
|
+
|
183
|
+
/**
|
184
|
+
* Annotates the strong handle with the given label, which is then used by the
|
185
|
+
* heap snapshot generator as a name of the edge from the root to the handle.
|
186
|
+
* The function does not take ownership of the label and assumes that the
|
187
|
+
* label is valid as long as the handle is valid.
|
188
|
+
*/
|
189
|
+
V8_INLINE void AnnotateStrongRetainer(const char* label);
|
190
|
+
|
191
|
+
/** Returns true if the handle's reference is weak. */
|
192
|
+
V8_INLINE bool IsWeak() const;
|
193
|
+
|
194
|
+
/**
|
195
|
+
* Assigns a wrapper class ID to the handle.
|
196
|
+
*/
|
197
|
+
V8_INLINE void SetWrapperClassId(uint16_t class_id);
|
198
|
+
|
199
|
+
/**
|
200
|
+
* Returns the class ID previously assigned to this handle or 0 if no class ID
|
201
|
+
* was previously assigned.
|
202
|
+
*/
|
203
|
+
V8_INLINE uint16_t WrapperClassId() const;
|
204
|
+
|
205
|
+
PersistentBase(const PersistentBase& other) = delete;
|
206
|
+
void operator=(const PersistentBase&) = delete;
|
207
|
+
|
208
|
+
private:
|
209
|
+
friend class Isolate;
|
210
|
+
friend class Utils;
|
211
|
+
template <class F>
|
212
|
+
friend class Local;
|
213
|
+
template <class F1, class F2>
|
214
|
+
friend class Persistent;
|
215
|
+
template <class F>
|
216
|
+
friend class Global;
|
217
|
+
template <class F>
|
218
|
+
friend class PersistentBase;
|
219
|
+
template <class F>
|
220
|
+
friend class ReturnValue;
|
221
|
+
template <class F1, class F2, class F3>
|
222
|
+
friend class PersistentValueMapBase;
|
223
|
+
template <class F1, class F2>
|
224
|
+
friend class PersistentValueVector;
|
225
|
+
friend class Object;
|
226
|
+
|
227
|
+
explicit V8_INLINE PersistentBase(T* val) : val_(val) {}
|
228
|
+
V8_INLINE static T* New(Isolate* isolate, T* that);
|
229
|
+
|
230
|
+
T* val_;
|
231
|
+
};
|
232
|
+
|
233
|
+
/**
|
234
|
+
* Default traits for Persistent. This class does not allow
|
235
|
+
* use of the copy constructor or assignment operator.
|
236
|
+
* At present kResetInDestructor is not set, but that will change in a future
|
237
|
+
* version.
|
238
|
+
*/
|
239
|
+
template <class T>
|
240
|
+
class NonCopyablePersistentTraits {
|
241
|
+
public:
|
242
|
+
using NonCopyablePersistent = Persistent<T, NonCopyablePersistentTraits<T>>;
|
243
|
+
static const bool kResetInDestructor = false;
|
244
|
+
template <class S, class M>
|
245
|
+
V8_INLINE static void Copy(const Persistent<S, M>& source,
|
246
|
+
NonCopyablePersistent* dest) {
|
247
|
+
static_assert(sizeof(S) < 0,
|
248
|
+
"NonCopyablePersistentTraits::Copy is not instantiable");
|
249
|
+
}
|
250
|
+
};
|
251
|
+
|
252
|
+
/**
|
253
|
+
* Helper class traits to allow copying and assignment of Persistent.
|
254
|
+
* This will clone the contents of storage cell, but not any of the flags, etc.
|
255
|
+
*/
|
256
|
+
template <class T>
|
257
|
+
struct CopyablePersistentTraits {
|
258
|
+
using CopyablePersistent = Persistent<T, CopyablePersistentTraits<T>>;
|
259
|
+
static const bool kResetInDestructor = true;
|
260
|
+
template <class S, class M>
|
261
|
+
static V8_INLINE void Copy(const Persistent<S, M>& source,
|
262
|
+
CopyablePersistent* dest) {
|
263
|
+
// do nothing, just allow copy
|
264
|
+
}
|
265
|
+
};
|
266
|
+
|
267
|
+
/**
|
268
|
+
* A PersistentBase which allows copy and assignment.
|
269
|
+
*
|
270
|
+
* Copy, assignment and destructor behavior is controlled by the traits
|
271
|
+
* class M.
|
272
|
+
*
|
273
|
+
* Note: Persistent class hierarchy is subject to future changes.
|
274
|
+
*/
|
275
|
+
template <class T, class M>
|
276
|
+
class Persistent : public PersistentBase<T> {
|
277
|
+
public:
|
278
|
+
/**
|
279
|
+
* A Persistent with no storage cell.
|
280
|
+
*/
|
281
|
+
V8_INLINE Persistent() : PersistentBase<T>(nullptr) {}
|
282
|
+
/**
|
283
|
+
* Construct a Persistent from a Local.
|
284
|
+
* When the Local is non-empty, a new storage cell is created
|
285
|
+
* pointing to the same object, and no flags are set.
|
286
|
+
*/
|
287
|
+
template <class S>
|
288
|
+
V8_INLINE Persistent(Isolate* isolate, Local<S> that)
|
289
|
+
: PersistentBase<T>(PersistentBase<T>::New(isolate, *that)) {
|
290
|
+
static_assert(std::is_base_of<T, S>::value, "type check");
|
291
|
+
}
|
292
|
+
/**
|
293
|
+
* Construct a Persistent from a Persistent.
|
294
|
+
* When the Persistent is non-empty, a new storage cell is created
|
295
|
+
* pointing to the same object, and no flags are set.
|
296
|
+
*/
|
297
|
+
template <class S, class M2>
|
298
|
+
V8_INLINE Persistent(Isolate* isolate, const Persistent<S, M2>& that)
|
299
|
+
: PersistentBase<T>(PersistentBase<T>::New(isolate, *that)) {
|
300
|
+
static_assert(std::is_base_of<T, S>::value, "type check");
|
301
|
+
}
|
302
|
+
/**
|
303
|
+
* The copy constructors and assignment operator create a Persistent
|
304
|
+
* exactly as the Persistent constructor, but the Copy function from the
|
305
|
+
* traits class is called, allowing the setting of flags based on the
|
306
|
+
* copied Persistent.
|
307
|
+
*/
|
308
|
+
V8_INLINE Persistent(const Persistent& that) : PersistentBase<T>(nullptr) {
|
309
|
+
Copy(that);
|
310
|
+
}
|
311
|
+
template <class S, class M2>
|
312
|
+
V8_INLINE Persistent(const Persistent<S, M2>& that) : PersistentBase<T>(0) {
|
313
|
+
Copy(that);
|
314
|
+
}
|
315
|
+
V8_INLINE Persistent& operator=(const Persistent& that) {
|
316
|
+
Copy(that);
|
317
|
+
return *this;
|
318
|
+
}
|
319
|
+
template <class S, class M2>
|
320
|
+
V8_INLINE Persistent& operator=(const Persistent<S, M2>& that) {
|
321
|
+
Copy(that);
|
322
|
+
return *this;
|
323
|
+
}
|
324
|
+
/**
|
325
|
+
* The destructor will dispose the Persistent based on the
|
326
|
+
* kResetInDestructor flags in the traits class. Since not calling dispose
|
327
|
+
* can result in a memory leak, it is recommended to always set this flag.
|
328
|
+
*/
|
329
|
+
V8_INLINE ~Persistent() {
|
330
|
+
if (M::kResetInDestructor) this->Reset();
|
331
|
+
}
|
332
|
+
|
333
|
+
// TODO(dcarney): this is pretty useless, fix or remove
|
334
|
+
template <class S>
|
335
|
+
V8_INLINE static Persistent<T>& Cast(const Persistent<S>& that) {
|
336
|
+
#ifdef V8_ENABLE_CHECKS
|
337
|
+
// If we're going to perform the type check then we have to check
|
338
|
+
// that the handle isn't empty before doing the checked cast.
|
339
|
+
if (!that.IsEmpty()) T::Cast(*that);
|
340
|
+
#endif
|
341
|
+
return reinterpret_cast<Persistent<T>&>(const_cast<Persistent<S>&>(that));
|
342
|
+
}
|
343
|
+
|
344
|
+
// TODO(dcarney): this is pretty useless, fix or remove
|
345
|
+
template <class S>
|
346
|
+
V8_INLINE Persistent<S>& As() const {
|
347
|
+
return Persistent<S>::Cast(*this);
|
348
|
+
}
|
349
|
+
|
350
|
+
private:
|
351
|
+
friend class Isolate;
|
352
|
+
friend class Utils;
|
353
|
+
template <class F>
|
354
|
+
friend class Local;
|
355
|
+
template <class F1, class F2>
|
356
|
+
friend class Persistent;
|
357
|
+
template <class F>
|
358
|
+
friend class ReturnValue;
|
359
|
+
|
360
|
+
explicit V8_INLINE Persistent(T* that) : PersistentBase<T>(that) {}
|
361
|
+
V8_INLINE T* operator*() const { return this->val_; }
|
362
|
+
template <class S, class M2>
|
363
|
+
V8_INLINE void Copy(const Persistent<S, M2>& that);
|
364
|
+
};
|
365
|
+
|
366
|
+
/**
|
367
|
+
* A PersistentBase which has move semantics.
|
368
|
+
*
|
369
|
+
* Note: Persistent class hierarchy is subject to future changes.
|
370
|
+
*/
|
371
|
+
template <class T>
|
372
|
+
class Global : public PersistentBase<T> {
|
373
|
+
public:
|
374
|
+
/**
|
375
|
+
* A Global with no storage cell.
|
376
|
+
*/
|
377
|
+
V8_INLINE Global() : PersistentBase<T>(nullptr) {}
|
378
|
+
|
379
|
+
/**
|
380
|
+
* Construct a Global from a Local.
|
381
|
+
* When the Local is non-empty, a new storage cell is created
|
382
|
+
* pointing to the same object, and no flags are set.
|
383
|
+
*/
|
384
|
+
template <class S>
|
385
|
+
V8_INLINE Global(Isolate* isolate, Local<S> that)
|
386
|
+
: PersistentBase<T>(PersistentBase<T>::New(isolate, *that)) {
|
387
|
+
static_assert(std::is_base_of<T, S>::value, "type check");
|
388
|
+
}
|
389
|
+
|
390
|
+
/**
|
391
|
+
* Construct a Global from a PersistentBase.
|
392
|
+
* When the Persistent is non-empty, a new storage cell is created
|
393
|
+
* pointing to the same object, and no flags are set.
|
394
|
+
*/
|
395
|
+
template <class S>
|
396
|
+
V8_INLINE Global(Isolate* isolate, const PersistentBase<S>& that)
|
397
|
+
: PersistentBase<T>(PersistentBase<T>::New(isolate, that.val_)) {
|
398
|
+
static_assert(std::is_base_of<T, S>::value, "type check");
|
399
|
+
}
|
400
|
+
|
401
|
+
/**
|
402
|
+
* Move constructor.
|
403
|
+
*/
|
404
|
+
V8_INLINE Global(Global&& other);
|
405
|
+
|
406
|
+
V8_INLINE ~Global() { this->Reset(); }
|
407
|
+
|
408
|
+
/**
|
409
|
+
* Move via assignment.
|
410
|
+
*/
|
411
|
+
template <class S>
|
412
|
+
V8_INLINE Global& operator=(Global<S>&& rhs);
|
413
|
+
|
414
|
+
/**
|
415
|
+
* Pass allows returning uniques from functions, etc.
|
416
|
+
*/
|
417
|
+
Global Pass() { return static_cast<Global&&>(*this); }
|
418
|
+
|
419
|
+
/*
|
420
|
+
* For compatibility with Chromium's base::Bind (base::Passed).
|
421
|
+
*/
|
422
|
+
using MoveOnlyTypeForCPP03 = void;
|
423
|
+
|
424
|
+
Global(const Global&) = delete;
|
425
|
+
void operator=(const Global&) = delete;
|
426
|
+
|
427
|
+
private:
|
428
|
+
template <class F>
|
429
|
+
friend class ReturnValue;
|
430
|
+
V8_INLINE T* operator*() const { return this->val_; }
|
431
|
+
};
|
432
|
+
|
433
|
+
// UniquePersistent is an alias for Global for historical reason.
|
434
|
+
template <class T>
|
435
|
+
using UniquePersistent = Global<T>;
|
436
|
+
|
437
|
+
/**
|
438
|
+
* Interface for iterating through all the persistent handles in the heap.
|
439
|
+
*/
|
440
|
+
class V8_EXPORT PersistentHandleVisitor {
|
441
|
+
public:
|
442
|
+
virtual ~PersistentHandleVisitor() = default;
|
443
|
+
virtual void VisitPersistentHandle(Persistent<Value>* value,
|
444
|
+
uint16_t class_id) {}
|
445
|
+
};
|
446
|
+
|
447
|
+
template <class T>
|
448
|
+
T* PersistentBase<T>::New(Isolate* isolate, T* that) {
|
449
|
+
if (that == nullptr) return nullptr;
|
450
|
+
internal::Address* p = reinterpret_cast<internal::Address*>(that);
|
451
|
+
return reinterpret_cast<T*>(api_internal::GlobalizeReference(
|
452
|
+
reinterpret_cast<internal::Isolate*>(isolate), p));
|
453
|
+
}
|
454
|
+
|
455
|
+
template <class T, class M>
|
456
|
+
template <class S, class M2>
|
457
|
+
void Persistent<T, M>::Copy(const Persistent<S, M2>& that) {
|
458
|
+
static_assert(std::is_base_of<T, S>::value, "type check");
|
459
|
+
this->Reset();
|
460
|
+
if (that.IsEmpty()) return;
|
461
|
+
internal::Address* p = reinterpret_cast<internal::Address*>(that.val_);
|
462
|
+
this->val_ = reinterpret_cast<T*>(api_internal::CopyGlobalReference(p));
|
463
|
+
M::Copy(that, this);
|
464
|
+
}
|
465
|
+
|
466
|
+
template <class T>
|
467
|
+
bool PersistentBase<T>::IsWeak() const {
|
468
|
+
using I = internal::Internals;
|
469
|
+
if (this->IsEmpty()) return false;
|
470
|
+
return I::GetNodeState(reinterpret_cast<internal::Address*>(this->val_)) ==
|
471
|
+
I::kNodeStateIsWeakValue;
|
472
|
+
}
|
473
|
+
|
474
|
+
template <class T>
|
475
|
+
void PersistentBase<T>::Reset() {
|
476
|
+
if (this->IsEmpty()) return;
|
477
|
+
api_internal::DisposeGlobal(reinterpret_cast<internal::Address*>(this->val_));
|
478
|
+
val_ = nullptr;
|
479
|
+
}
|
480
|
+
|
481
|
+
/**
|
482
|
+
* If non-empty, destroy the underlying storage cell
|
483
|
+
* and create a new one with the contents of other if other is non empty
|
484
|
+
*/
|
485
|
+
template <class T>
|
486
|
+
template <class S>
|
487
|
+
void PersistentBase<T>::Reset(Isolate* isolate, const Local<S>& other) {
|
488
|
+
static_assert(std::is_base_of<T, S>::value, "type check");
|
489
|
+
Reset();
|
490
|
+
if (other.IsEmpty()) return;
|
491
|
+
this->val_ = New(isolate, other.val_);
|
492
|
+
}
|
493
|
+
|
494
|
+
/**
|
495
|
+
* If non-empty, destroy the underlying storage cell
|
496
|
+
* and create a new one with the contents of other if other is non empty
|
497
|
+
*/
|
498
|
+
template <class T>
|
499
|
+
template <class S>
|
500
|
+
void PersistentBase<T>::Reset(Isolate* isolate,
|
501
|
+
const PersistentBase<S>& other) {
|
502
|
+
static_assert(std::is_base_of<T, S>::value, "type check");
|
503
|
+
Reset();
|
504
|
+
if (other.IsEmpty()) return;
|
505
|
+
this->val_ = New(isolate, other.val_);
|
506
|
+
}
|
507
|
+
|
508
|
+
template <class T>
|
509
|
+
template <typename P>
|
510
|
+
V8_INLINE void PersistentBase<T>::SetWeak(
|
511
|
+
P* parameter, typename WeakCallbackInfo<P>::Callback callback,
|
512
|
+
WeakCallbackType type) {
|
513
|
+
using Callback = WeakCallbackInfo<void>::Callback;
|
514
|
+
#if (__GNUC__ >= 8) && !defined(__clang__)
|
515
|
+
#pragma GCC diagnostic push
|
516
|
+
#pragma GCC diagnostic ignored "-Wcast-function-type"
|
517
|
+
#endif
|
518
|
+
api_internal::MakeWeak(reinterpret_cast<internal::Address*>(this->val_),
|
519
|
+
parameter, reinterpret_cast<Callback>(callback), type);
|
520
|
+
#if (__GNUC__ >= 8) && !defined(__clang__)
|
521
|
+
#pragma GCC diagnostic pop
|
522
|
+
#endif
|
523
|
+
}
|
524
|
+
|
525
|
+
template <class T>
|
526
|
+
void PersistentBase<T>::SetWeak() {
|
527
|
+
api_internal::MakeWeak(reinterpret_cast<internal::Address**>(&this->val_));
|
528
|
+
}
|
529
|
+
|
530
|
+
template <class T>
|
531
|
+
template <typename P>
|
532
|
+
P* PersistentBase<T>::ClearWeak() {
|
533
|
+
return reinterpret_cast<P*>(api_internal::ClearWeak(
|
534
|
+
reinterpret_cast<internal::Address*>(this->val_)));
|
535
|
+
}
|
536
|
+
|
537
|
+
template <class T>
|
538
|
+
void PersistentBase<T>::AnnotateStrongRetainer(const char* label) {
|
539
|
+
api_internal::AnnotateStrongRetainer(
|
540
|
+
reinterpret_cast<internal::Address*>(this->val_), label);
|
541
|
+
}
|
542
|
+
|
543
|
+
template <class T>
|
544
|
+
void PersistentBase<T>::SetWrapperClassId(uint16_t class_id) {
|
545
|
+
using I = internal::Internals;
|
546
|
+
if (this->IsEmpty()) return;
|
547
|
+
internal::Address* obj = reinterpret_cast<internal::Address*>(this->val_);
|
548
|
+
uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + I::kNodeClassIdOffset;
|
549
|
+
*reinterpret_cast<uint16_t*>(addr) = class_id;
|
550
|
+
}
|
551
|
+
|
552
|
+
template <class T>
|
553
|
+
uint16_t PersistentBase<T>::WrapperClassId() const {
|
554
|
+
using I = internal::Internals;
|
555
|
+
if (this->IsEmpty()) return 0;
|
556
|
+
internal::Address* obj = reinterpret_cast<internal::Address*>(this->val_);
|
557
|
+
uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + I::kNodeClassIdOffset;
|
558
|
+
return *reinterpret_cast<uint16_t*>(addr);
|
559
|
+
}
|
560
|
+
|
561
|
+
template <class T>
|
562
|
+
Global<T>::Global(Global&& other) : PersistentBase<T>(other.val_) {
|
563
|
+
if (other.val_ != nullptr) {
|
564
|
+
api_internal::MoveGlobalReference(
|
565
|
+
reinterpret_cast<internal::Address**>(&other.val_),
|
566
|
+
reinterpret_cast<internal::Address**>(&this->val_));
|
567
|
+
other.val_ = nullptr;
|
568
|
+
}
|
569
|
+
}
|
570
|
+
|
571
|
+
template <class T>
|
572
|
+
template <class S>
|
573
|
+
Global<T>& Global<T>::operator=(Global<S>&& rhs) {
|
574
|
+
static_assert(std::is_base_of<T, S>::value, "type check");
|
575
|
+
if (this != &rhs) {
|
576
|
+
this->Reset();
|
577
|
+
if (rhs.val_ != nullptr) {
|
578
|
+
this->val_ = rhs.val_;
|
579
|
+
api_internal::MoveGlobalReference(
|
580
|
+
reinterpret_cast<internal::Address**>(&rhs.val_),
|
581
|
+
reinterpret_cast<internal::Address**>(&this->val_));
|
582
|
+
rhs.val_ = nullptr;
|
583
|
+
}
|
584
|
+
}
|
585
|
+
return *this;
|
586
|
+
}
|
587
|
+
|
588
|
+
} // namespace v8
|
589
|
+
|
590
|
+
#endif // INCLUDE_V8_PERSISTENT_HANDLE_H_
|
@@ -181,9 +181,8 @@ class JobDelegate {
|
|
181
181
|
/**
|
182
182
|
* Returns true if the current task is called from the thread currently
|
183
183
|
* running JobHandle::Join().
|
184
|
-
* TODO(etiennep): Make pure virtual once custom embedders implement it.
|
185
184
|
*/
|
186
|
-
virtual bool IsJoiningThread() const
|
185
|
+
virtual bool IsJoiningThread() const = 0;
|
187
186
|
};
|
188
187
|
|
189
188
|
/**
|
@@ -220,19 +219,14 @@ class JobHandle {
|
|
220
219
|
* Forces all existing workers to yield ASAP but doesn’t wait for them.
|
221
220
|
* Warning, this is dangerous if the Job's callback is bound to or has access
|
222
221
|
* to state which may be deleted after this call.
|
223
|
-
* TODO(etiennep): Cleanup once implemented by all embedders.
|
224
222
|
*/
|
225
|
-
virtual void CancelAndDetach()
|
223
|
+
virtual void CancelAndDetach() = 0;
|
226
224
|
|
227
225
|
/**
|
228
226
|
* Returns true if there's any work pending or any worker running.
|
229
227
|
*/
|
230
228
|
virtual bool IsActive() = 0;
|
231
229
|
|
232
|
-
// TODO(etiennep): Clean up once all overrides are removed.
|
233
|
-
V8_DEPRECATED("Use !IsActive() instead.")
|
234
|
-
virtual bool IsCompleted() { return !IsActive(); }
|
235
|
-
|
236
230
|
/**
|
237
231
|
* Returns true if associated with a Job and other methods may be called.
|
238
232
|
* Returns false after Join() or Cancel() was called. This may return true
|
@@ -240,10 +234,6 @@ class JobHandle {
|
|
240
234
|
*/
|
241
235
|
virtual bool IsValid() = 0;
|
242
236
|
|
243
|
-
// TODO(etiennep): Clean up once all overrides are removed.
|
244
|
-
V8_DEPRECATED("Use IsValid() instead.")
|
245
|
-
virtual bool IsRunning() { return IsValid(); }
|
246
|
-
|
247
237
|
/**
|
248
238
|
* Returns true if job priority can be changed.
|
249
239
|
*/
|
@@ -272,10 +262,6 @@ class JobTask {
|
|
272
262
|
* it must not call back any JobHandle methods.
|
273
263
|
*/
|
274
264
|
virtual size_t GetMaxConcurrency(size_t worker_count) const = 0;
|
275
|
-
|
276
|
-
// TODO(1114823): Clean up once all overrides are removed.
|
277
|
-
V8_DEPRECATED("Use the version that takes |worker_count|.")
|
278
|
-
virtual size_t GetMaxConcurrency() const { return 0; }
|
279
265
|
};
|
280
266
|
|
281
267
|
/**
|
@@ -444,10 +430,28 @@ class PageAllocator {
|
|
444
430
|
/**
|
445
431
|
* Frees memory in the given [address, address + size) range. address and size
|
446
432
|
* should be operating system page-aligned. The next write to this
|
447
|
-
* memory area brings the memory transparently back.
|
433
|
+
* memory area brings the memory transparently back. This should be treated as
|
434
|
+
* a hint to the OS that the pages are no longer needed. It does not guarantee
|
435
|
+
* that the pages will be discarded immediately or at all.
|
448
436
|
*/
|
449
437
|
virtual bool DiscardSystemPages(void* address, size_t size) { return true; }
|
450
438
|
|
439
|
+
/**
|
440
|
+
* Decommits any wired memory pages in the given range, allowing the OS to
|
441
|
+
* reclaim them, and marks the region as inacessible (kNoAccess). The address
|
442
|
+
* range stays reserved and can be accessed again later by changing its
|
443
|
+
* permissions. However, in that case the memory content is guaranteed to be
|
444
|
+
* zero-initialized again. The memory must have been previously allocated by a
|
445
|
+
* call to AllocatePages. Returns true on success, false otherwise.
|
446
|
+
*/
|
447
|
+
#ifdef V8_VIRTUAL_MEMORY_CAGE
|
448
|
+
// Implementing this API is required when the virtual memory cage is enabled.
|
449
|
+
virtual bool DecommitPages(void* address, size_t size) = 0;
|
450
|
+
#else
|
451
|
+
// Otherwise, it is optional for now.
|
452
|
+
virtual bool DecommitPages(void* address, size_t size) { return false; }
|
453
|
+
#endif
|
454
|
+
|
451
455
|
/**
|
452
456
|
* INTERNAL ONLY: This interface has not been stabilised and may change
|
453
457
|
* without notice from one release to another without being deprecated first.
|
@@ -512,6 +516,18 @@ class PageAllocator {
|
|
512
516
|
virtual bool CanAllocateSharedPages() { return false; }
|
513
517
|
};
|
514
518
|
|
519
|
+
/**
|
520
|
+
* V8 Allocator used for allocating zone backings.
|
521
|
+
*/
|
522
|
+
class ZoneBackingAllocator {
|
523
|
+
public:
|
524
|
+
using MallocFn = void* (*)(size_t);
|
525
|
+
using FreeFn = void (*)(void*);
|
526
|
+
|
527
|
+
virtual MallocFn GetMallocFn() const { return ::malloc; }
|
528
|
+
virtual FreeFn GetFreeFn() const { return ::free; }
|
529
|
+
};
|
530
|
+
|
515
531
|
/**
|
516
532
|
* V8 Platform abstraction layer.
|
517
533
|
*
|
@@ -530,6 +546,14 @@ class Platform {
|
|
530
546
|
return nullptr;
|
531
547
|
}
|
532
548
|
|
549
|
+
/**
|
550
|
+
* Allows the embedder to specify a custom allocator used for zones.
|
551
|
+
*/
|
552
|
+
virtual ZoneBackingAllocator* GetZoneBackingAllocator() {
|
553
|
+
static ZoneBackingAllocator default_allocator;
|
554
|
+
return &default_allocator;
|
555
|
+
}
|
556
|
+
|
533
557
|
/**
|
534
558
|
* Enables the embedder to respond in cases where V8 can't allocate large
|
535
559
|
* blocks of memory. V8 retries the failed allocation once after calling this
|