libv8-node 21.7.2.0-aarch64-linux-musl → 22.5.1.0-aarch64-linux-musl
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-musl/libv8/obj/libv8_monolith.a +0 -0
- data/vendor/v8/include/cppgc/internal/api-constants.h +1 -1
- data/vendor/v8/include/cppgc/type-traits.h +25 -4
- data/vendor/v8/include/v8-array-buffer.h +6 -0
- data/vendor/v8/include/v8-callbacks.h +6 -12
- data/vendor/v8/include/v8-container.h +54 -0
- data/vendor/v8/include/v8-context.h +51 -22
- data/vendor/v8/include/v8-embedder-heap.h +19 -3
- data/vendor/v8/include/v8-embedder-state-scope.h +2 -1
- data/vendor/v8/include/v8-exception.h +15 -9
- data/vendor/v8/include/v8-fast-api-calls.h +35 -26
- data/vendor/v8/include/v8-forward.h +1 -0
- data/vendor/v8/include/v8-function-callback.h +129 -20
- data/vendor/v8/include/v8-handle-base.h +32 -80
- data/vendor/v8/include/v8-inspector.h +16 -24
- data/vendor/v8/include/v8-internal.h +472 -65
- data/vendor/v8/include/v8-isolate.h +86 -51
- data/vendor/v8/include/v8-local-handle.h +257 -31
- data/vendor/v8/include/v8-memory-span.h +157 -2
- data/vendor/v8/include/v8-message.h +22 -3
- data/vendor/v8/include/v8-metrics.h +1 -0
- data/vendor/v8/include/v8-object.h +29 -10
- data/vendor/v8/include/v8-persistent-handle.h +5 -3
- data/vendor/v8/include/v8-platform.h +81 -44
- data/vendor/v8/include/v8-script.h +61 -11
- data/vendor/v8/include/v8-snapshot.h +94 -23
- data/vendor/v8/include/v8-statistics.h +10 -24
- data/vendor/v8/include/v8-template.h +410 -131
- data/vendor/v8/include/v8-traced-handle.h +81 -46
- data/vendor/v8/include/v8-typed-array.h +115 -7
- data/vendor/v8/include/v8-util.h +13 -12
- data/vendor/v8/include/v8-value.h +92 -4
- data/vendor/v8/include/v8-version.h +4 -4
- data/vendor/v8/include/v8config.h +35 -10
- metadata +2 -2
@@ -8,8 +8,10 @@
|
|
8
8
|
#include <stddef.h>
|
9
9
|
|
10
10
|
#include <type_traits>
|
11
|
+
#include <vector>
|
11
12
|
|
12
13
|
#include "v8-handle-base.h" // NOLINT(build/include_directory)
|
14
|
+
#include "v8-internal.h" // NOLINT(build/include_directory)
|
13
15
|
|
14
16
|
namespace v8 {
|
15
17
|
|
@@ -17,6 +19,8 @@ template <class T>
|
|
17
19
|
class LocalBase;
|
18
20
|
template <class T>
|
19
21
|
class Local;
|
22
|
+
template <class T>
|
23
|
+
class LocalVector;
|
20
24
|
template <class F>
|
21
25
|
class MaybeLocal;
|
22
26
|
|
@@ -58,6 +62,7 @@ class ReturnValue;
|
|
58
62
|
class String;
|
59
63
|
template <class F>
|
60
64
|
class Traced;
|
65
|
+
class TypecheckWitness;
|
61
66
|
class Utils;
|
62
67
|
|
63
68
|
namespace debug {
|
@@ -67,6 +72,8 @@ class ConsoleCallArguments;
|
|
67
72
|
namespace internal {
|
68
73
|
template <typename T>
|
69
74
|
class CustomArguments;
|
75
|
+
template <typename T>
|
76
|
+
class LocalUnchecked;
|
70
77
|
class SamplingHeapProfiler;
|
71
78
|
} // namespace internal
|
72
79
|
|
@@ -129,6 +136,9 @@ class V8_EXPORT V8_NODISCARD HandleScope {
|
|
129
136
|
internal::Isolate* i_isolate_;
|
130
137
|
internal::Address* prev_next_;
|
131
138
|
internal::Address* prev_limit_;
|
139
|
+
#ifdef V8_ENABLE_CHECKS
|
140
|
+
int scope_level_ = 0;
|
141
|
+
#endif
|
132
142
|
|
133
143
|
// LocalBase<T>::New uses CreateHandle with an Isolate* parameter.
|
134
144
|
template <typename T>
|
@@ -149,7 +159,7 @@ class V8_EXPORT V8_NODISCARD HandleScope {
|
|
149
159
|
#ifdef V8_ENABLE_DIRECT_LOCAL
|
150
160
|
|
151
161
|
template <typename T>
|
152
|
-
class LocalBase : public DirectHandleBase {
|
162
|
+
class LocalBase : public api_internal::DirectHandleBase {
|
153
163
|
protected:
|
154
164
|
template <class F>
|
155
165
|
friend class Local;
|
@@ -178,7 +188,7 @@ class LocalBase : public DirectHandleBase {
|
|
178
188
|
#else // !V8_ENABLE_DIRECT_LOCAL
|
179
189
|
|
180
190
|
template <typename T>
|
181
|
-
class LocalBase : public IndirectHandleBase {
|
191
|
+
class LocalBase : public api_internal::IndirectHandleBase {
|
182
192
|
protected:
|
183
193
|
template <class F>
|
184
194
|
friend class Local;
|
@@ -239,7 +249,13 @@ class LocalBase : public IndirectHandleBase {
|
|
239
249
|
* to these values as to their handles.
|
240
250
|
*/
|
241
251
|
template <class T>
|
242
|
-
class Local : public LocalBase<T
|
252
|
+
class V8_TRIVIAL_ABI Local : public LocalBase<T>,
|
253
|
+
#ifdef V8_ENABLE_LOCAL_OFF_STACK_CHECK
|
254
|
+
public api_internal::StackAllocated<true>
|
255
|
+
#else
|
256
|
+
public api_internal::StackAllocated<false>
|
257
|
+
#endif
|
258
|
+
{
|
243
259
|
public:
|
244
260
|
V8_INLINE Local() = default;
|
245
261
|
|
@@ -320,17 +336,17 @@ class Local : public LocalBase<T> {
|
|
320
336
|
* the original handle is destroyed/disposed.
|
321
337
|
*/
|
322
338
|
V8_INLINE static Local<T> New(Isolate* isolate, Local<T> that) {
|
323
|
-
return New(isolate, that.template value<T>());
|
339
|
+
return New(isolate, that.template value<T, true>());
|
324
340
|
}
|
325
341
|
|
326
342
|
V8_INLINE static Local<T> New(Isolate* isolate,
|
327
343
|
const PersistentBase<T>& that) {
|
328
|
-
return New(isolate, that.template value<T>());
|
344
|
+
return New(isolate, that.template value<T, true>());
|
329
345
|
}
|
330
346
|
|
331
347
|
V8_INLINE static Local<T> New(Isolate* isolate,
|
332
348
|
const BasicTracedReference<T>& that) {
|
333
|
-
return New(isolate, that.template value<T>());
|
349
|
+
return New(isolate, that.template value<T, true>());
|
334
350
|
}
|
335
351
|
|
336
352
|
private:
|
@@ -363,6 +379,7 @@ class Local : public LocalBase<T> {
|
|
363
379
|
friend Local<Boolean> False(Isolate* isolate);
|
364
380
|
friend class HandleScope;
|
365
381
|
friend class EscapableHandleScope;
|
382
|
+
friend class InternalEscapableScope;
|
366
383
|
template <class F1, class F2, class F3>
|
367
384
|
friend class PersistentValueMapBase;
|
368
385
|
template <class F1, class F2>
|
@@ -374,6 +391,12 @@ class Local : public LocalBase<T> {
|
|
374
391
|
friend class internal::SamplingHeapProfiler;
|
375
392
|
friend class internal::HandleHelper;
|
376
393
|
friend class debug::ConsoleCallArguments;
|
394
|
+
friend class internal::LocalUnchecked<T>;
|
395
|
+
|
396
|
+
explicit Local(no_checking_tag do_not_check)
|
397
|
+
: LocalBase<T>(), StackAllocated(do_not_check) {}
|
398
|
+
explicit Local(const Local<T>& other, no_checking_tag do_not_check)
|
399
|
+
: LocalBase<T>(other), StackAllocated(do_not_check) {}
|
377
400
|
|
378
401
|
V8_INLINE explicit Local<T>(const LocalBase<T>& other)
|
379
402
|
: LocalBase<T>(other) {}
|
@@ -383,6 +406,8 @@ class Local : public LocalBase<T> {
|
|
383
406
|
}
|
384
407
|
|
385
408
|
#ifdef V8_ENABLE_DIRECT_LOCAL
|
409
|
+
friend class TypecheckWitness;
|
410
|
+
|
386
411
|
V8_INLINE static Local<T> FromAddress(internal::Address ptr) {
|
387
412
|
return Local<T>(LocalBase<T>(ptr));
|
388
413
|
}
|
@@ -403,6 +428,174 @@ class Local : public LocalBase<T> {
|
|
403
428
|
}
|
404
429
|
};
|
405
430
|
|
431
|
+
namespace internal {
|
432
|
+
// A local variant that is suitable for off-stack allocation.
|
433
|
+
// Used internally by LocalVector<T>. Not to be used directly!
|
434
|
+
template <typename T>
|
435
|
+
class V8_TRIVIAL_ABI LocalUnchecked : public Local<T> {
|
436
|
+
public:
|
437
|
+
LocalUnchecked() : Local<T>(Local<T>::do_not_check) {}
|
438
|
+
|
439
|
+
#if defined(V8_ENABLE_LOCAL_OFF_STACK_CHECK) && V8_HAS_ATTRIBUTE_TRIVIAL_ABI
|
440
|
+
// In this case, the check is also enforced in the copy constructor and we
|
441
|
+
// need to suppress it.
|
442
|
+
LocalUnchecked(const LocalUnchecked& other)
|
443
|
+
: Local<T>(other, Local<T>::do_not_check) {}
|
444
|
+
LocalUnchecked& operator=(const LocalUnchecked&) = default;
|
445
|
+
#endif
|
446
|
+
|
447
|
+
// Implicit conversion from Local.
|
448
|
+
LocalUnchecked(const Local<T>& other) // NOLINT(runtime/explicit)
|
449
|
+
: Local<T>(other, Local<T>::do_not_check) {}
|
450
|
+
};
|
451
|
+
|
452
|
+
#ifdef V8_ENABLE_DIRECT_LOCAL
|
453
|
+
// Off-stack allocated direct locals must be registered as strong roots.
|
454
|
+
// For off-stack indirect locals, this is not necessary.
|
455
|
+
|
456
|
+
template <typename T>
|
457
|
+
class StrongRootAllocator<LocalUnchecked<T>> : public StrongRootAllocatorBase {
|
458
|
+
public:
|
459
|
+
using value_type = LocalUnchecked<T>;
|
460
|
+
static_assert(std::is_standard_layout_v<value_type>);
|
461
|
+
static_assert(sizeof(value_type) == sizeof(Address));
|
462
|
+
|
463
|
+
explicit StrongRootAllocator(Heap* heap) : StrongRootAllocatorBase(heap) {}
|
464
|
+
explicit StrongRootAllocator(v8::Isolate* isolate)
|
465
|
+
: StrongRootAllocatorBase(isolate) {}
|
466
|
+
template <typename U>
|
467
|
+
StrongRootAllocator(const StrongRootAllocator<U>& other) noexcept
|
468
|
+
: StrongRootAllocatorBase(other) {}
|
469
|
+
|
470
|
+
value_type* allocate(size_t n) {
|
471
|
+
return reinterpret_cast<value_type*>(allocate_impl(n));
|
472
|
+
}
|
473
|
+
void deallocate(value_type* p, size_t n) noexcept {
|
474
|
+
return deallocate_impl(reinterpret_cast<Address*>(p), n);
|
475
|
+
}
|
476
|
+
};
|
477
|
+
#endif // V8_ENABLE_DIRECT_LOCAL
|
478
|
+
} // namespace internal
|
479
|
+
|
480
|
+
template <typename T>
|
481
|
+
class LocalVector {
|
482
|
+
private:
|
483
|
+
using element_type = internal::LocalUnchecked<T>;
|
484
|
+
|
485
|
+
#ifdef V8_ENABLE_DIRECT_LOCAL
|
486
|
+
using allocator_type = internal::StrongRootAllocator<element_type>;
|
487
|
+
|
488
|
+
static allocator_type make_allocator(Isolate* isolate) noexcept {
|
489
|
+
return allocator_type(isolate);
|
490
|
+
}
|
491
|
+
#else
|
492
|
+
using allocator_type = std::allocator<element_type>;
|
493
|
+
|
494
|
+
static allocator_type make_allocator(Isolate* isolate) noexcept {
|
495
|
+
return allocator_type();
|
496
|
+
}
|
497
|
+
#endif // V8_ENABLE_DIRECT_LOCAL
|
498
|
+
|
499
|
+
using vector_type = std::vector<element_type, allocator_type>;
|
500
|
+
|
501
|
+
public:
|
502
|
+
using value_type = Local<T>;
|
503
|
+
using reference = value_type&;
|
504
|
+
using const_reference = const value_type&;
|
505
|
+
using size_type = size_t;
|
506
|
+
using difference_type = ptrdiff_t;
|
507
|
+
using iterator =
|
508
|
+
internal::WrappedIterator<typename vector_type::iterator, Local<T>>;
|
509
|
+
using const_iterator =
|
510
|
+
internal::WrappedIterator<typename vector_type::const_iterator,
|
511
|
+
const Local<T>>;
|
512
|
+
|
513
|
+
explicit LocalVector(Isolate* isolate) : backing_(make_allocator(isolate)) {}
|
514
|
+
LocalVector(Isolate* isolate, size_t n)
|
515
|
+
: backing_(n, make_allocator(isolate)) {}
|
516
|
+
explicit LocalVector(Isolate* isolate, std::initializer_list<Local<T>> init)
|
517
|
+
: backing_(make_allocator(isolate)) {
|
518
|
+
if (init.size() == 0) return;
|
519
|
+
backing_.reserve(init.size());
|
520
|
+
backing_.insert(backing_.end(), init.begin(), init.end());
|
521
|
+
}
|
522
|
+
|
523
|
+
iterator begin() noexcept { return iterator(backing_.begin()); }
|
524
|
+
const_iterator begin() const noexcept {
|
525
|
+
return const_iterator(backing_.begin());
|
526
|
+
}
|
527
|
+
iterator end() noexcept { return iterator(backing_.end()); }
|
528
|
+
const_iterator end() const noexcept { return const_iterator(backing_.end()); }
|
529
|
+
|
530
|
+
size_t size() const noexcept { return backing_.size(); }
|
531
|
+
bool empty() const noexcept { return backing_.empty(); }
|
532
|
+
void reserve(size_t n) { backing_.reserve(n); }
|
533
|
+
void shrink_to_fit() { backing_.shrink_to_fit(); }
|
534
|
+
|
535
|
+
Local<T>& operator[](size_t n) { return backing_[n]; }
|
536
|
+
const Local<T>& operator[](size_t n) const { return backing_[n]; }
|
537
|
+
|
538
|
+
Local<T>& at(size_t n) { return backing_.at(n); }
|
539
|
+
const Local<T>& at(size_t n) const { return backing_.at(n); }
|
540
|
+
|
541
|
+
Local<T>& front() { return backing_.front(); }
|
542
|
+
const Local<T>& front() const { return backing_.front(); }
|
543
|
+
Local<T>& back() { return backing_.back(); }
|
544
|
+
const Local<T>& back() const { return backing_.back(); }
|
545
|
+
|
546
|
+
Local<T>* data() noexcept { return backing_.data(); }
|
547
|
+
const Local<T>* data() const noexcept { return backing_.data(); }
|
548
|
+
|
549
|
+
iterator insert(const_iterator pos, const Local<T>& value) {
|
550
|
+
return iterator(backing_.insert(pos.base(), value));
|
551
|
+
}
|
552
|
+
|
553
|
+
template <typename InputIt>
|
554
|
+
iterator insert(const_iterator pos, InputIt first, InputIt last) {
|
555
|
+
return iterator(backing_.insert(pos.base(), first, last));
|
556
|
+
}
|
557
|
+
|
558
|
+
iterator insert(const_iterator pos, std::initializer_list<Local<T>> init) {
|
559
|
+
return iterator(backing_.insert(pos.base(), init.begin(), init.end()));
|
560
|
+
}
|
561
|
+
|
562
|
+
LocalVector<T>& operator=(std::initializer_list<Local<T>> init) {
|
563
|
+
backing_.clear();
|
564
|
+
backing_.insert(backing_.end(), init.begin(), init.end());
|
565
|
+
return *this;
|
566
|
+
}
|
567
|
+
|
568
|
+
void push_back(const Local<T>& x) { backing_.push_back(x); }
|
569
|
+
void pop_back() { backing_.pop_back(); }
|
570
|
+
void emplace_back(const Local<T>& x) { backing_.emplace_back(x); }
|
571
|
+
|
572
|
+
void clear() noexcept { backing_.clear(); }
|
573
|
+
void resize(size_t n) { backing_.resize(n); }
|
574
|
+
void swap(LocalVector<T>& other) { backing_.swap(other.backing_); }
|
575
|
+
|
576
|
+
friend bool operator==(const LocalVector<T>& x, const LocalVector<T>& y) {
|
577
|
+
return x.backing_ == y.backing_;
|
578
|
+
}
|
579
|
+
friend bool operator!=(const LocalVector<T>& x, const LocalVector<T>& y) {
|
580
|
+
return x.backing_ != y.backing_;
|
581
|
+
}
|
582
|
+
friend bool operator<(const LocalVector<T>& x, const LocalVector<T>& y) {
|
583
|
+
return x.backing_ < y.backing_;
|
584
|
+
}
|
585
|
+
friend bool operator>(const LocalVector<T>& x, const LocalVector<T>& y) {
|
586
|
+
return x.backing_ > y.backing_;
|
587
|
+
}
|
588
|
+
friend bool operator<=(const LocalVector<T>& x, const LocalVector<T>& y) {
|
589
|
+
return x.backing_ <= y.backing_;
|
590
|
+
}
|
591
|
+
friend bool operator>=(const LocalVector<T>& x, const LocalVector<T>& y) {
|
592
|
+
return x.backing_ >= y.backing_;
|
593
|
+
}
|
594
|
+
|
595
|
+
private:
|
596
|
+
vector_type backing_;
|
597
|
+
};
|
598
|
+
|
406
599
|
#if !defined(V8_IMMINENT_DEPRECATION_WARNINGS)
|
407
600
|
// Handle is an alias for Local for historical reasons.
|
408
601
|
template <class T>
|
@@ -456,29 +649,79 @@ class MaybeLocal {
|
|
456
649
|
return IsEmpty() ? default_value : Local<S>(local_);
|
457
650
|
}
|
458
651
|
|
652
|
+
/**
|
653
|
+
* Cast a handle to a subclass, e.g. MaybeLocal<Value> to MaybeLocal<Object>.
|
654
|
+
* This is only valid if the handle actually refers to a value of the target
|
655
|
+
* type.
|
656
|
+
*/
|
657
|
+
template <class S>
|
658
|
+
V8_INLINE static MaybeLocal<T> Cast(MaybeLocal<S> that) {
|
659
|
+
#ifdef V8_ENABLE_CHECKS
|
660
|
+
// If we're going to perform the type check then we have to check
|
661
|
+
// that the handle isn't empty before doing the checked cast.
|
662
|
+
if (that.IsEmpty()) return MaybeLocal<T>();
|
663
|
+
T::Cast(that.local_.template value<S>());
|
664
|
+
#endif
|
665
|
+
return MaybeLocal<T>(that.local_);
|
666
|
+
}
|
667
|
+
|
668
|
+
/**
|
669
|
+
* Calling this is equivalent to MaybeLocal<S>::Cast().
|
670
|
+
* In particular, this is only valid if the handle actually refers to a value
|
671
|
+
* of the target type.
|
672
|
+
*/
|
673
|
+
template <class S>
|
674
|
+
V8_INLINE MaybeLocal<S> As() const {
|
675
|
+
return MaybeLocal<S>::Cast(*this);
|
676
|
+
}
|
677
|
+
|
459
678
|
private:
|
460
679
|
Local<T> local_;
|
680
|
+
|
681
|
+
template <typename S>
|
682
|
+
friend class MaybeLocal;
|
461
683
|
};
|
462
684
|
|
463
685
|
/**
|
464
686
|
* A HandleScope which first allocates a handle in the current scope
|
465
687
|
* which will be later filled with the escape value.
|
466
688
|
*/
|
467
|
-
class V8_EXPORT V8_NODISCARD
|
689
|
+
class V8_EXPORT V8_NODISCARD EscapableHandleScopeBase : public HandleScope {
|
468
690
|
public:
|
469
|
-
explicit
|
470
|
-
V8_INLINE ~
|
691
|
+
explicit EscapableHandleScopeBase(Isolate* isolate);
|
692
|
+
V8_INLINE ~EscapableHandleScopeBase() = default;
|
693
|
+
|
694
|
+
EscapableHandleScopeBase(const EscapableHandleScopeBase&) = delete;
|
695
|
+
void operator=(const EscapableHandleScopeBase&) = delete;
|
696
|
+
void* operator new(size_t size) = delete;
|
697
|
+
void* operator new[](size_t size) = delete;
|
698
|
+
void operator delete(void*, size_t) = delete;
|
699
|
+
void operator delete[](void*, size_t) = delete;
|
471
700
|
|
701
|
+
protected:
|
472
702
|
/**
|
473
703
|
* Pushes the value into the previous scope and returns a handle to it.
|
474
704
|
* Cannot be called twice.
|
475
705
|
*/
|
706
|
+
internal::Address* EscapeSlot(internal::Address* escape_value);
|
707
|
+
|
708
|
+
private:
|
709
|
+
internal::Address* escape_slot_;
|
710
|
+
};
|
711
|
+
|
712
|
+
class V8_EXPORT V8_NODISCARD EscapableHandleScope
|
713
|
+
: public EscapableHandleScopeBase {
|
714
|
+
public:
|
715
|
+
explicit EscapableHandleScope(Isolate* isolate)
|
716
|
+
: EscapableHandleScopeBase(isolate) {}
|
717
|
+
V8_INLINE ~EscapableHandleScope() = default;
|
476
718
|
template <class T>
|
477
719
|
V8_INLINE Local<T> Escape(Local<T> value) {
|
478
720
|
#ifdef V8_ENABLE_DIRECT_LOCAL
|
479
721
|
return value;
|
480
722
|
#else
|
481
|
-
|
723
|
+
if (value.IsEmpty()) return value;
|
724
|
+
return Local<T>::FromSlot(EscapeSlot(value.slot()));
|
482
725
|
#endif
|
483
726
|
}
|
484
727
|
|
@@ -486,20 +729,6 @@ class V8_EXPORT V8_NODISCARD EscapableHandleScope : public HandleScope {
|
|
486
729
|
V8_INLINE MaybeLocal<T> EscapeMaybe(MaybeLocal<T> value) {
|
487
730
|
return Escape(value.FromMaybe(Local<T>()));
|
488
731
|
}
|
489
|
-
|
490
|
-
EscapableHandleScope(const EscapableHandleScope&) = delete;
|
491
|
-
void operator=(const EscapableHandleScope&) = delete;
|
492
|
-
|
493
|
-
private:
|
494
|
-
// Declaring operator new and delete as deleted is not spec compliant.
|
495
|
-
// Therefore declare them private instead to disable dynamic alloc
|
496
|
-
void* operator new(size_t size);
|
497
|
-
void* operator new[](size_t size);
|
498
|
-
void operator delete(void*, size_t);
|
499
|
-
void operator delete[](void*, size_t);
|
500
|
-
|
501
|
-
internal::Address* Escape(internal::Address* escape_value);
|
502
|
-
internal::Address* escape_slot_;
|
503
732
|
};
|
504
733
|
|
505
734
|
/**
|
@@ -514,15 +743,12 @@ class V8_EXPORT V8_NODISCARD SealHandleScope {
|
|
514
743
|
|
515
744
|
SealHandleScope(const SealHandleScope&) = delete;
|
516
745
|
void operator=(const SealHandleScope&) = delete;
|
746
|
+
void* operator new(size_t size) = delete;
|
747
|
+
void* operator new[](size_t size) = delete;
|
748
|
+
void operator delete(void*, size_t) = delete;
|
749
|
+
void operator delete[](void*, size_t) = delete;
|
517
750
|
|
518
751
|
private:
|
519
|
-
// Declaring operator new and delete as deleted is not spec compliant.
|
520
|
-
// Therefore declare them private instead to disable dynamic alloc
|
521
|
-
void* operator new(size_t size);
|
522
|
-
void* operator new[](size_t size);
|
523
|
-
void operator delete(void*, size_t);
|
524
|
-
void operator delete[](void*, size_t);
|
525
|
-
|
526
752
|
internal::Isolate* const i_isolate_;
|
527
753
|
internal::Address* prev_limit_;
|
528
754
|
int prev_sealed_level_;
|
@@ -7,12 +7,16 @@
|
|
7
7
|
|
8
8
|
#include <stddef.h>
|
9
9
|
|
10
|
+
#include <array>
|
11
|
+
#include <iterator>
|
12
|
+
#include <type_traits>
|
13
|
+
|
10
14
|
#include "v8config.h" // NOLINT(build/include_directory)
|
11
15
|
|
12
16
|
namespace v8 {
|
13
17
|
|
14
18
|
/**
|
15
|
-
* Points to an unowned
|
19
|
+
* Points to an unowned contiguous buffer holding a known number of elements.
|
16
20
|
*
|
17
21
|
* This is similar to std::span (under consideration for C++20), but does not
|
18
22
|
* require advanced C++ support. In the (far) future, this may be replaced with
|
@@ -23,21 +27,172 @@ namespace v8 {
|
|
23
27
|
*/
|
24
28
|
template <typename T>
|
25
29
|
class V8_EXPORT MemorySpan {
|
30
|
+
private:
|
31
|
+
/** Some C++ machinery, brought from the future. */
|
32
|
+
template <typename From, typename To>
|
33
|
+
using is_array_convertible = std::is_convertible<From (*)[], To (*)[]>;
|
34
|
+
template <typename From, typename To>
|
35
|
+
static constexpr bool is_array_convertible_v =
|
36
|
+
is_array_convertible<From, To>::value;
|
37
|
+
|
38
|
+
template <typename It>
|
39
|
+
using iter_reference_t = decltype(*std::declval<It&>());
|
40
|
+
|
41
|
+
template <typename It, typename = void>
|
42
|
+
struct is_compatible_iterator : std::false_type {};
|
43
|
+
template <typename It>
|
44
|
+
struct is_compatible_iterator<
|
45
|
+
It,
|
46
|
+
std::void_t<
|
47
|
+
std::is_base_of<std::random_access_iterator_tag,
|
48
|
+
typename std::iterator_traits<It>::iterator_category>,
|
49
|
+
is_array_convertible<std::remove_reference_t<iter_reference_t<It>>,
|
50
|
+
T>>> : std::true_type {};
|
51
|
+
template <typename It>
|
52
|
+
static constexpr bool is_compatible_iterator_v =
|
53
|
+
is_compatible_iterator<It>::value;
|
54
|
+
|
55
|
+
template <typename U>
|
56
|
+
static constexpr U* to_address(U* p) noexcept {
|
57
|
+
return p;
|
58
|
+
}
|
59
|
+
|
60
|
+
template <typename It,
|
61
|
+
typename = std::void_t<decltype(std::declval<It&>().operator->())>>
|
62
|
+
static constexpr auto to_address(It it) noexcept {
|
63
|
+
return it.operator->();
|
64
|
+
}
|
65
|
+
|
26
66
|
public:
|
27
67
|
/** The default constructor creates an empty span. */
|
28
68
|
constexpr MemorySpan() = default;
|
29
69
|
|
30
|
-
|
70
|
+
/** Constructor from nullptr and count, for backwards compatibility.
|
71
|
+
* This is not compatible with C++20 std::span.
|
72
|
+
*/
|
73
|
+
constexpr MemorySpan(std::nullptr_t, size_t) {}
|
74
|
+
|
75
|
+
/** Constructor from "iterator" and count. */
|
76
|
+
template <typename Iterator,
|
77
|
+
std::enable_if_t<is_compatible_iterator_v<Iterator>, bool> = true>
|
78
|
+
constexpr MemorySpan(Iterator first,
|
79
|
+
size_t count) // NOLINT(runtime/explicit)
|
80
|
+
: data_(to_address(first)), size_(count) {}
|
81
|
+
|
82
|
+
/** Constructor from two "iterators". */
|
83
|
+
template <typename Iterator,
|
84
|
+
std::enable_if_t<is_compatible_iterator_v<Iterator> &&
|
85
|
+
!std::is_convertible_v<Iterator, size_t>,
|
86
|
+
bool> = true>
|
87
|
+
constexpr MemorySpan(Iterator first,
|
88
|
+
Iterator last) // NOLINT(runtime/explicit)
|
89
|
+
: data_(to_address(first)), size_(last - first) {}
|
90
|
+
|
91
|
+
/** Implicit conversion from C-style array. */
|
92
|
+
template <size_t N>
|
93
|
+
constexpr MemorySpan(T (&a)[N]) noexcept // NOLINT(runtime/explicit)
|
94
|
+
: data_(a), size_(N) {}
|
95
|
+
|
96
|
+
/** Implicit conversion from std::array. */
|
97
|
+
template <typename U, size_t N,
|
98
|
+
std::enable_if_t<is_array_convertible_v<U, T>, bool> = true>
|
99
|
+
constexpr MemorySpan(
|
100
|
+
std::array<U, N>& a) noexcept // NOLINT(runtime/explicit)
|
101
|
+
: data_(a.data()), size_{N} {}
|
102
|
+
|
103
|
+
/** Implicit conversion from const std::array. */
|
104
|
+
template <typename U, size_t N,
|
105
|
+
std::enable_if_t<is_array_convertible_v<const U, T>, bool> = true>
|
106
|
+
constexpr MemorySpan(
|
107
|
+
const std::array<U, N>& a) noexcept // NOLINT(runtime/explicit)
|
108
|
+
: data_(a.data()), size_{N} {}
|
31
109
|
|
32
110
|
/** Returns a pointer to the beginning of the buffer. */
|
33
111
|
constexpr T* data() const { return data_; }
|
34
112
|
/** Returns the number of elements that the buffer holds. */
|
35
113
|
constexpr size_t size() const { return size_; }
|
36
114
|
|
115
|
+
constexpr T& operator[](size_t i) const { return data_[i]; }
|
116
|
+
|
117
|
+
/** Returns true if the buffer is empty. */
|
118
|
+
constexpr bool empty() const { return size() == 0; }
|
119
|
+
|
120
|
+
class Iterator {
|
121
|
+
public:
|
122
|
+
using iterator_category = std::forward_iterator_tag;
|
123
|
+
using value_type = T;
|
124
|
+
using difference_type = std::ptrdiff_t;
|
125
|
+
using pointer = value_type*;
|
126
|
+
using reference = value_type&;
|
127
|
+
|
128
|
+
T& operator*() const { return *ptr_; }
|
129
|
+
T* operator->() const { return ptr_; }
|
130
|
+
|
131
|
+
bool operator==(Iterator other) const { return ptr_ == other.ptr_; }
|
132
|
+
bool operator!=(Iterator other) const { return !(*this == other); }
|
133
|
+
|
134
|
+
Iterator& operator++() {
|
135
|
+
++ptr_;
|
136
|
+
return *this;
|
137
|
+
}
|
138
|
+
|
139
|
+
Iterator operator++(int) {
|
140
|
+
Iterator temp(*this);
|
141
|
+
++(*this);
|
142
|
+
return temp;
|
143
|
+
}
|
144
|
+
|
145
|
+
private:
|
146
|
+
friend class MemorySpan<T>;
|
147
|
+
|
148
|
+
explicit Iterator(T* ptr) : ptr_(ptr) {}
|
149
|
+
|
150
|
+
T* ptr_ = nullptr;
|
151
|
+
};
|
152
|
+
|
153
|
+
Iterator begin() const { return Iterator(data_); }
|
154
|
+
Iterator end() const { return Iterator(data_ + size_); }
|
155
|
+
|
37
156
|
private:
|
38
157
|
T* data_ = nullptr;
|
39
158
|
size_t size_ = 0;
|
40
159
|
};
|
41
160
|
|
161
|
+
/**
|
162
|
+
* Helper function template to create an array of fixed length, initialized by
|
163
|
+
* the provided initializer list, without explicitly specifying the array size,
|
164
|
+
* e.g.
|
165
|
+
*
|
166
|
+
* auto arr = v8::to_array<Local<String>>({v8_str("one"), v8_str("two")});
|
167
|
+
*
|
168
|
+
* In the future, this may be replaced with or aliased to std::to_array (under
|
169
|
+
* consideration for C++20).
|
170
|
+
*/
|
171
|
+
|
172
|
+
namespace detail {
|
173
|
+
template <class T, std::size_t N, std::size_t... I>
|
174
|
+
constexpr std::array<std::remove_cv_t<T>, N> to_array_lvalue_impl(
|
175
|
+
T (&a)[N], std::index_sequence<I...>) {
|
176
|
+
return {{a[I]...}};
|
177
|
+
}
|
178
|
+
|
179
|
+
template <class T, std::size_t N, std::size_t... I>
|
180
|
+
constexpr std::array<std::remove_cv_t<T>, N> to_array_rvalue_impl(
|
181
|
+
T (&&a)[N], std::index_sequence<I...>) {
|
182
|
+
return {{std::move(a[I])...}};
|
183
|
+
}
|
184
|
+
} // namespace detail
|
185
|
+
|
186
|
+
template <class T, std::size_t N>
|
187
|
+
constexpr std::array<std::remove_cv_t<T>, N> to_array(T (&a)[N]) {
|
188
|
+
return detail::to_array_lvalue_impl(a, std::make_index_sequence<N>{});
|
189
|
+
}
|
190
|
+
|
191
|
+
template <class T, std::size_t N>
|
192
|
+
constexpr std::array<std::remove_cv_t<T>, N> to_array(T (&&a)[N]) {
|
193
|
+
return detail::to_array_rvalue_impl(std::move(a),
|
194
|
+
std::make_index_sequence<N>{});
|
195
|
+
}
|
196
|
+
|
42
197
|
} // namespace v8
|
43
198
|
#endif // INCLUDE_V8_MEMORY_SPAN_H_
|
@@ -61,6 +61,7 @@ class ScriptOriginOptions {
|
|
61
61
|
*/
|
62
62
|
class V8_EXPORT ScriptOrigin {
|
63
63
|
public:
|
64
|
+
V8_DEPRECATE_SOON("Use constructor without the isolate.")
|
64
65
|
V8_INLINE ScriptOrigin(Isolate* isolate, Local<Value> resource_name,
|
65
66
|
int resource_line_offset = 0,
|
66
67
|
int resource_column_offset = 0,
|
@@ -70,8 +71,27 @@ class V8_EXPORT ScriptOrigin {
|
|
70
71
|
bool resource_is_opaque = false, bool is_wasm = false,
|
71
72
|
bool is_module = false,
|
72
73
|
Local<Data> host_defined_options = Local<Data>())
|
73
|
-
:
|
74
|
-
|
74
|
+
: resource_name_(resource_name),
|
75
|
+
resource_line_offset_(resource_line_offset),
|
76
|
+
resource_column_offset_(resource_column_offset),
|
77
|
+
options_(resource_is_shared_cross_origin, resource_is_opaque, is_wasm,
|
78
|
+
is_module),
|
79
|
+
script_id_(script_id),
|
80
|
+
source_map_url_(source_map_url),
|
81
|
+
host_defined_options_(host_defined_options) {
|
82
|
+
VerifyHostDefinedOptions();
|
83
|
+
}
|
84
|
+
|
85
|
+
V8_INLINE ScriptOrigin(Local<Value> resource_name,
|
86
|
+
int resource_line_offset = 0,
|
87
|
+
int resource_column_offset = 0,
|
88
|
+
bool resource_is_shared_cross_origin = false,
|
89
|
+
int script_id = -1,
|
90
|
+
Local<Value> source_map_url = Local<Value>(),
|
91
|
+
bool resource_is_opaque = false, bool is_wasm = false,
|
92
|
+
bool is_module = false,
|
93
|
+
Local<Data> host_defined_options = Local<Data>())
|
94
|
+
: resource_name_(resource_name),
|
75
95
|
resource_line_offset_(resource_line_offset),
|
76
96
|
resource_column_offset_(resource_column_offset),
|
77
97
|
options_(resource_is_shared_cross_origin, resource_is_opaque, is_wasm,
|
@@ -92,7 +112,6 @@ class V8_EXPORT ScriptOrigin {
|
|
92
112
|
|
93
113
|
private:
|
94
114
|
void VerifyHostDefinedOptions() const;
|
95
|
-
Isolate* v8_isolate_;
|
96
115
|
Local<Value> resource_name_;
|
97
116
|
int resource_line_offset_;
|
98
117
|
int resource_column_offset_;
|
@@ -55,6 +55,7 @@ struct GarbageCollectionFullCycle {
|
|
55
55
|
double efficiency_cpp_in_bytes_per_us = -1.0;
|
56
56
|
double main_thread_efficiency_in_bytes_per_us = -1.0;
|
57
57
|
double main_thread_efficiency_cpp_in_bytes_per_us = -1.0;
|
58
|
+
int64_t incremental_marking_start_stop_wall_clock_duration_in_us = -1;
|
58
59
|
};
|
59
60
|
|
60
61
|
struct GarbageCollectionFullMainThreadIncrementalMark {
|