24 #include <type_traits>
28 #include "cppgc/common.h"
56 class ImplementationUtilities;
67 class ObjectOperationDescriptor;
74 class RawOperationDescriptor;
91 template <
class T>
class Local;
94 template <
class T>
class Eternal;
95 template<
class T>
class NonCopyablePersistentTraits;
97 template <
class T,
class M = NonCopyablePersistentTraits<T> >
108 template <
class K,
class V,
class T>
110 template <
class K,
class V,
class T>
113 template<
class T,
class P>
class WeakCallbackObject;
121 class CallHandlerHelper;
126 enum class ArgumentsType;
127 template <ArgumentsType>
129 template <
typename T>
131 class FunctionCallbackArguments;
135 class ExternalString;
137 class LocalEmbedderHeapTracer;
138 class MicrotaskQueue;
139 class PropertyCallbackArguments;
141 class ScopedExternalStringLock;
142 struct ScriptStreamingData;
143 class ThreadLocalTop;
147 class StreamingDecoder;
157 class ConsoleCallArguments;
199 : val_(
reinterpret_cast<T*>(*that)) {
205 static_assert(std::is_base_of<T, S>::value,
"type check");
236 if (a ==
nullptr)
return b ==
nullptr;
237 if (b ==
nullptr)
return false;
245 if (a ==
nullptr)
return b ==
nullptr;
246 if (b ==
nullptr)
return false;
262 return !operator==(that);
267 return !operator==(that);
276 #ifdef V8_ENABLE_CHECKS
279 if (that.IsEmpty())
return Local<T>();
281 return Local<T>(T::Cast(*that));
291 return Local<S>::Cast(*
this);
310 template<
class F>
friend class Local;
327 template <
class F1,
class F2,
class F3>
341 explicit V8_INLINE Local(T* that) : val_(that) {}
347 #if !defined(V8_IMMINENT_DEPRECATION_WARNINGS)
370 : val_(
reinterpret_cast<T*>(*that)) {
371 static_assert(std::is_base_of<T, S>::value,
"type check");
382 out->val_ =
IsEmpty() ?
nullptr :
this->val_;
414 Set(isolate, handle);
426 static const int kInternalFieldsInWeakCallback = 2;
427 static const int kEmbedderFieldsInWeakCallback = 2;
429 template <
typename T>
435 void* embedder_fields[kEmbedderFieldsInWeakCallback],
437 : isolate_(isolate), parameter_(parameter), callback_(callback) {
438 for (
int i = 0; i < kEmbedderFieldsInWeakCallback; ++i) {
439 embedder_fields_[i] = embedder_fields[i];
459 void* embedder_fields_[kEmbedderFieldsInWeakCallback];
508 return Local<T>::New(isolate, *
this);
515 if (a ==
nullptr)
return b ==
nullptr;
516 if (b ==
nullptr)
return false;
524 if (a ==
nullptr)
return b ==
nullptr;
525 if (b ==
nullptr)
return false;
531 return !operator==(that);
536 return !operator==(that);
551 template <
typename P>
599 template<
class F>
friend class Local;
605 template <
class F1,
class F2,
class F3>
610 explicit V8_INLINE PersistentBase(T* val) : val_(val) {}
624 class NonCopyablePersistentTraits {
628 template<
class S,
class M>
631 static_assert(
sizeof(S) < 0,
632 "NonCopyablePersistentTraits::Copy is not instantiable");
645 template<
class S,
class M>
675 static_assert(std::is_base_of<T, S>::value,
"type check");
682 template <
class S,
class M2>
685 static_assert(std::is_base_of<T, S>::value,
"type check");
696 template <
class S,
class M2>
704 template <
class S,
class M2>
715 if (M::kResetInDestructor)
this->Reset();
721 #ifdef V8_ENABLE_CHECKS
724 if (!that.IsEmpty()) T::Cast(*that);
738 template<
class F>
friend class Local;
743 V8_INLINE T* operator*()
const {
return this->val_; }
744 template<
class S,
class M2>
770 static_assert(std::is_base_of<T, S>::value,
"type check");
781 static_assert(std::is_base_of<T, S>::value,
"type check");
813 V8_INLINE T* operator*()
const {
return this->val_; }
824 template <
typename T>
842 template <
typename T>
849 bool IsEmpty()
const {
return val_ ==
nullptr; }
866 if (a ==
nullptr)
return b ==
nullptr;
867 if (b ==
nullptr)
return false;
875 if (a ==
nullptr)
return b ==
nullptr;
876 if (b ==
nullptr)
return false;
882 return !operator==(that);
887 return !operator==(that);
912 reinterpret_cast<std::atomic<T*>*>(&val_)->store(new_val,
913 std::memory_order_relaxed);
920 return reinterpret_cast<std::atomic<
const T*>
const*>(&val_)->load(
921 std::memory_order_relaxed);
925 enum DestructionMode { kWithDestructor, kWithoutDestructor };
930 TracedReferenceBase() =
default;
933 DestructionMode destruction_mode);
938 template <
typename F>
941 template <
typename F>
943 template <
typename F>
945 template <
typename F>
953 template <
typename T>
976 this->val_ =
this->New(isolate, that.val_, &
this->val_,
978 static_assert(std::is_base_of<T, S>::value,
"type check");
986 *
this = std::move(other);
992 template <
typename S>
995 *
this = std::move(other);
1009 template <
typename S>
1081 template <
typename T>
1099 this->val_ =
this->New(isolate, that.val_, &
this->val_,
1101 static_assert(std::is_base_of<T, S>::value,
"type check");
1110 *
this = std::move(other);
1117 template <
typename S>
1120 *
this = std::move(other);
1136 template <
typename S>
1182 return this->GetSlotThreadSafe() ==
nullptr;
1212 return reinterpret_cast<
Isolate*>(isolate_);
1229 void* operator
new(size_t size);
1230 void* operator
new[](size_t size);
1231 void operator
delete(
void*, size_t);
1232 void operator
delete[](
void*, size_t);
1265 return Local<T>(
reinterpret_cast<T*>(slot));
1270 return Escape(value.FromMaybe(
Local<T>()));
1279 void* operator
new(size_t size);
1280 void* operator
new[](size_t size);
1281 void operator
delete(
void*, size_t);
1282 void operator
delete[](
void*, size_t);
1304 void* operator
new(size_t size);
1305 void* operator
new[](size_t size);
1306 void operator
delete(
void*, size_t);
1307 void operator
delete[](
void*, size_t);
1311 int prev_sealed_level_;
1368 bool is_opaque =
false,
bool is_wasm =
false,
1369 bool is_module =
false)
1370 : flags_((is_shared_cross_origin ? kIsSharedCrossOrigin : 0) |
1371 (is_wasm ? kIsWasm : 0) | (is_opaque ? kIsOpaque : 0) |
1372 (is_module ? kIsModule : 0)) {}
1375 (kIsSharedCrossOrigin | kIsOpaque | kIsWasm | kIsModule)) {}
1378 return (flags_ & kIsSharedCrossOrigin) != 0;
1380 bool IsOpaque()
const {
return (flags_ & kIsOpaque) != 0; }
1381 bool IsWasm()
const {
return (flags_ & kIsWasm) != 0; }
1382 bool IsModule()
const {
return (flags_ & kIsModule) != 0; }
1388 kIsSharedCrossOrigin = 1,
1478 : line_number_(line_number), column_number_(column_number) {}
1626 "Use the preceding SetSyntheticModuleExport with an Isolate parameter, "
1627 "instead of the one that follows. The former will throw a runtime "
1628 "error if called for an export that doesn't exist (as per spec); "
1629 "the latter will crash with a failed CHECK().")
1630 void SetSyntheticModuleExport(
Local<
String> export_name,
1806 "This class takes ownership of source_stream, so use the constructor "
1807 "taking a unique_ptr to make these semantics clearer")
1820 std::unique_ptr<
internal::ScriptStreamingData> impl_;
1834 explicit ScriptStreamingTask(
internal::ScriptStreamingData* data)
1837 internal::ScriptStreamingData* data_;
1971 Local<
String> arguments[], size_t context_extension_count,
2356 size_t* actual_size);
2422 PrivateData* private_;
2447 Isolate* isolate, uint32_t transfer_id);
2454 Isolate* isolate, uint32_t clone_id);
2519 PrivateData* private_;
2928 V8_INLINE bool QuickIsUndefined()
const;
2930 V8_INLINE bool QuickIsNullOrUndefined()
const;
2932 bool FullIsUndefined()
const;
2933 bool FullIsNull()
const;
2934 bool FullIsString()
const;
2955 static void CheckCast(
v8::
Value* obj);
2976 static void CheckCast(
Value* obj);
3075 int Write(
Isolate* isolate, uint16_t* buffer,
int start = 0,
int length = -1,
3079 int length = -1,
int options =
NO_OPTIONS)
const;
3082 int* nchars_ref =
nullptr,
int options =
NO_OPTIONS)
const;
3167 virtual const uint16_t*
data()
const = 0;
3197 virtual const char*
data()
const = 0;
3237 Isolate* isolate,
const char (&literal)[N],
3239 static_assert(N <=
kMaxLength,
"String is too long");
3240 return NewFromUtf8Literal(isolate, literal, type, N - 1);
3246 Isolate* isolate,
const char* data,
3252 Isolate* isolate,
const uint8_t* data,
3258 Isolate* isolate,
const uint16_t* data,
3378 const char* literal,
3381 static void CheckCast(
v8::
Value* obj);
3445 static void CheckCast(
Value* obj);
3483 static void CheckCast(
Data* that);
3497 static void CheckCast(
v8::
Value* obj);
3512 static void CheckCast(
v8::
Value* obj);
3526 static void CheckCast(
v8::
Value* obj);
3540 static void CheckCast(
v8::
Value* obj);
3558 int word_count,
const uint64_t* words);
3595 static void CheckCast(
v8::
Value* obj);
4155 static void CheckCast(
Value* obj);
4156 Local<
Value> SlowGetInternalField(
int index);
4157 void* SlowGetAlignedPointerFromInternalField(
int index);
4183 static void CheckCast(
Value* obj);
4219 static void CheckCast(
Value* obj);
4251 static void CheckCast(
Value* obj);
4255 template<
typename T>
4259 : value_(that.value_) {
4260 static_assert(std::is_base_of<T, S>::value,
"type check");
4263 template <
typename S>
4265 template <
typename S>
4267 template <
typename S>
4282 template <
typename S>
4294 template <
class F,
class G,
class H>
4309 template<
typename T>
4348 friend class debug::ConsoleCallArguments;
4368 template<
typename T>
4460 friend class MacroAssembler;
4567 static void CheckCast(
Value* obj);
4570 #ifndef V8_PROMISE_INTERNAL_FIELD_COUNT
4572 #define V8_PROMISE_INTERNAL_FIELD_COUNT 0
4613 static void CheckCast(
Value* obj);
4660 static void CheckCast(
Value* obj);