Loading...
Searching...
No Matches
v8-function-callback.h
Go to the documentation of this file.
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_FUNCTION_CALLBACK_H_
6#define INCLUDE_V8_FUNCTION_CALLBACK_H_
7
8#include <cstdint>
9#include <limits>
10
11#include "v8-internal.h" // NOLINT(build/include_directory)
12#include "v8-local-handle.h" // NOLINT(build/include_directory)
13#include "v8-primitive.h" // NOLINT(build/include_directory)
14#include "v8config.h" // NOLINT(build/include_directory)
15
16namespace v8 {
17
18template <typename T>
19class BasicTracedReference;
20template <typename T>
21class Global;
22class Object;
23class Value;
24
25namespace internal {
26class FunctionCallbackArguments;
27class PropertyCallbackArguments;
28class Builtins;
29} // namespace internal
30
31namespace debug {
32class ConsoleCallArguments;
33} // namespace debug
34
35namespace api_internal {
37 v8::Isolate* isolate, v8::Local<v8::Data> raw_target);
38} // namespace api_internal
39
40template <typename T>
42 public:
43 template <class S>
44 V8_INLINE ReturnValue(const ReturnValue<S>& that) : value_(that.value_) {
45 static_assert(std::is_base_of<T, S>::value, "type check");
46 }
47 // Handle-based setters.
48 template <typename S>
49 V8_INLINE void Set(const Global<S>& handle);
50 template <typename S>
51 V8_INLINE void SetNonEmpty(const Global<S>& handle);
52 template <typename S>
53 V8_INLINE void Set(const BasicTracedReference<S>& handle);
54 template <typename S>
56 template <typename S>
57 V8_INLINE void Set(const Local<S> handle);
58 template <typename S>
59 V8_INLINE void SetNonEmpty(const Local<S> handle);
60 // Fast primitive number setters.
61 V8_INLINE void Set(bool value);
62 V8_INLINE void Set(double i);
63 V8_INLINE void Set(int16_t i);
64 V8_INLINE void Set(int32_t i);
65 V8_INLINE void Set(int64_t i);
66 V8_INLINE void Set(uint16_t i);
67 V8_INLINE void Set(uint32_t i);
68 V8_INLINE void Set(uint64_t i);
69 // Fast JS primitive setters
70 V8_INLINE void SetNull();
72 V8_INLINE void SetFalse();
74 // Convenience getter for Isolate
76
77 // Pointer setter: Uncompilable to prevent inadvertent misuse.
78 template <typename S>
79 V8_INLINE void Set(S* whatever);
80
81 // Getter. Creates a new Local<> so it comes with a certain performance
82 // hit. If the ReturnValue was not yet set, this will return the undefined
83 // value.
85
86 private:
87 template <class F>
88 friend class ReturnValue;
89 template <class F>
91 template <class F>
93 template <class F, class G, class H>
95 V8_INLINE void SetInternal(internal::Address value);
96 // Default value depends on <T>:
97 // - <void> -> true_value,
98 // - <v8::Boolean> -> true_value,
99 // - <v8::Integer> -> 0,
100 // - <v8::Value> -> undefined_value,
101 // - <v8::Array> -> undefined_value.
102 V8_INLINE void SetDefaultValue();
104
105 // See FunctionCallbackInfo.
106 static constexpr int kIsolateValueIndex = -2;
107
108 internal::Address* value_;
109};
110
117template <typename T>
119 public:
121 V8_INLINE int Length() const;
126 V8_INLINE Local<Value> operator[](int i) const;
140 "V8 will stop providing access to hidden prototype (i.e. "
141 "JSGlobalObject). Use This() instead. \n"
142 "DO NOT try to workaround this by accessing JSGlobalObject via "
143 "v8::Object::GetPrototype() - it'll be deprecated soon too. \n"
144 "See http://crbug.com/333672197. ")
149 V8_INLINE bool IsConstructCall() const;
156
157 // This is a temporary replacement for Holder() added just for the purpose
158 // of testing the deprecated Holder() machinery until it's removed for real.
159 // DO NOT use it.
161
162 private:
167
168 static constexpr int kHolderIndex = 0;
169 static constexpr int kIsolateIndex = 1;
170 static constexpr int kContextIndex = 2;
171 static constexpr int kReturnValueIndex = 3;
172 static constexpr int kTargetIndex = 4;
173 static constexpr int kNewTargetIndex = 5;
174 static constexpr int kArgsLength = 6;
175
176 static constexpr int kArgsLengthWithReceiver = kArgsLength + 1;
177
178 // Codegen constants:
179 static constexpr int kSize = 3 * internal::kApiSystemPointerSize;
180 static constexpr int kImplicitArgsOffset = 0;
181 static constexpr int kValuesOffset =
182 kImplicitArgsOffset + internal::kApiSystemPointerSize;
183 static constexpr int kLengthOffset =
184 kValuesOffset + internal::kApiSystemPointerSize;
185
186 static constexpr int kThisValuesIndex = -1;
188 kIsolateIndex - kReturnValueIndex);
189
191 internal::Address* values, int length);
192
193 // TODO(https://crbug.com/326505377): flatten the v8::FunctionCallbackInfo
194 // object to avoid indirect loads through values_ and implicit_args_ and
195 // reduce the number of instructions in the CallApiCallback builtin.
196 internal::Address* implicit_args_;
197 internal::Address* values_;
198 internal::Address length_;
199};
200
205template <typename T>
207 public:
212
219
262
273 "V8 will stop providing access to hidden prototype (i.e. "
274 "JSGlobalObject). Use HolderV2() instead. \n"
275 "DO NOT try to workaround this by accessing JSGlobalObject via "
276 "v8::Object::GetPrototype() - it'll be deprecated soon too. \n"
277 "See http://crbug.com/333672197. ")
279
288
298
307
308 private:
309 template <typename U>
311 friend class MacroAssembler;
312 friend class internal::PropertyCallbackArguments;
313 friend class internal::CustomArguments<PropertyCallbackInfo>;
314 friend void internal::PrintPropertyCallbackInfo(void*);
315
316 static constexpr int kPropertyKeyIndex = 0;
317 static constexpr int kShouldThrowOnErrorIndex = 1;
318 static constexpr int kHolderIndex = 2;
319 static constexpr int kIsolateIndex = 3;
320 static constexpr int kHolderV2Index = 4;
321 static constexpr int kReturnValueIndex = 5;
322 static constexpr int kDataIndex = 6;
323 static constexpr int kThisIndex = 7;
324 static constexpr int kArgsLength = 8;
325
326 static constexpr int kSize = kArgsLength * internal::kApiSystemPointerSize;
327
328 PropertyCallbackInfo() = default;
329
330 mutable internal::Address args_[kArgsLength];
331};
332
333using FunctionCallback = void (*)(const FunctionCallbackInfo<Value>& info);
334
335// --- Implementation ---
336
337template <typename T>
338ReturnValue<T>::ReturnValue(internal::Address* slot) : value_(slot) {}
339
340template <typename T>
341void ReturnValue<T>::SetInternal(internal::Address value) {
342#if V8_STATIC_ROOTS_BOOL
343 using I = internal::Internals;
344 // Ensure that the upper 32-bits are not modified. Compiler should be
345 // able to optimize this to a store of a lower 32-bits of the value.
346 // This is fine since the callback can return only JavaScript values which
347 // are either Smis or heap objects allocated in the main cage.
348 *value_ = I::DecompressTaggedField(*value_, I::CompressTagged(value));
349#else
350 *value_ = value;
351#endif // V8_STATIC_ROOTS_BOOL
352}
353
354template <typename T>
355template <typename S>
356void ReturnValue<T>::Set(const Global<S>& handle) {
357 static_assert(std::is_base_of<T, S>::value, "type check");
358 if (V8_UNLIKELY(handle.IsEmpty())) {
359 SetDefaultValue();
360 } else {
361 SetInternal(handle.ptr());
362 }
363}
364
365template <typename T>
366template <typename S>
368 static_assert(std::is_base_of<T, S>::value, "type check");
369#ifdef V8_ENABLE_CHECKS
371#endif // V8_ENABLE_CHECKS
372 SetInternal(handle.ptr());
373}
374
375template <typename T>
376template <typename S>
378 static_assert(std::is_base_of<T, S>::value, "type check");
379 if (V8_UNLIKELY(handle.IsEmpty())) {
380 SetDefaultValue();
381 } else {
382 SetInternal(handle.ptr());
383 }
384}
385
386template <typename T>
387template <typename S>
389 static_assert(std::is_base_of<T, S>::value, "type check");
390#ifdef V8_ENABLE_CHECKS
392#endif // V8_ENABLE_CHECKS
393 SetInternal(handle.ptr());
394}
395
396template <typename T>
397template <typename S>
398void ReturnValue<T>::Set(const Local<S> handle) {
399 // "V8_DEPRECATE_SOON" this method if |T| is |void|.
400#ifdef V8_IMMINENT_DEPRECATION_WARNINGS
401 static constexpr bool is_allowed_void = false;
402 static_assert(!std::is_void<T>::value,
403 "ReturnValue<void>::Set(const Local<S>) is deprecated. "
404 "Do nothing to indicate that the operation succeeded or use "
405 "SetFalse() to indicate that the operation failed (don't "
406 "forget to handle info.ShouldThrowOnError()). "
407 "See http://crbug.com/348660658 for details.");
408#else
409 static constexpr bool is_allowed_void = std::is_void<T>::value;
410#endif // V8_IMMINENT_DEPRECATION_WARNINGS
411 static_assert(is_allowed_void || std::is_base_of<T, S>::value, "type check");
412 if (V8_UNLIKELY(handle.IsEmpty())) {
413 SetDefaultValue();
414 } else if constexpr (is_allowed_void) {
415 // Simulate old behaviour for "v8::AccessorSetterCallback" for which
416 // it was possible to set the return value even for ReturnValue<void>.
417 Set(handle->BooleanValue(GetIsolate()));
418 } else {
419 SetInternal(handle.ptr());
420 }
421}
422
423template <typename T>
424template <typename S>
426 // "V8_DEPRECATE_SOON" this method if |T| is |void|.
427#ifdef V8_IMMINENT_DEPRECATION_WARNINGS
428 static constexpr bool is_allowed_void = false;
429 static_assert(!std::is_void<T>::value,
430 "ReturnValue<void>::SetNonEmpty(const Local<S>) is deprecated. "
431 "Do nothing to indicate that the operation succeeded or use "
432 "SetFalse() to indicate that the operation failed (don't "
433 "forget to handle info.ShouldThrowOnError()). "
434 "See http://crbug.com/348660658 for details.");
435#else
436 static constexpr bool is_allowed_void = std::is_void<T>::value;
437#endif // V8_IMMINENT_DEPRECATION_WARNINGS
438 static_assert(is_allowed_void || std::is_base_of<T, S>::value, "type check");
439#ifdef V8_ENABLE_CHECKS
441#endif // V8_ENABLE_CHECKS
442 if constexpr (is_allowed_void) {
443 // Simulate old behaviour for "v8::AccessorSetterCallback" for which
444 // it was possible to set the return value even for ReturnValue<void>.
445 Set(handle->BooleanValue(GetIsolate()));
446 } else {
447 SetInternal(handle.ptr());
448 }
449}
450
451template <typename T>
452void ReturnValue<T>::Set(double i) {
453 static_assert(std::is_base_of<T, Number>::value, "type check");
454 SetNonEmpty(Number::New(GetIsolate(), i));
455}
456
457template <typename T>
458void ReturnValue<T>::Set(int16_t i) {
459 static_assert(std::is_base_of<T, Integer>::value, "type check");
460 using I = internal::Internals;
461 static_assert(I::IsValidSmi(std::numeric_limits<int16_t>::min()));
462 static_assert(I::IsValidSmi(std::numeric_limits<int16_t>::max()));
463 SetInternal(I::IntegralToSmi(i));
464}
465
466template <typename T>
467void ReturnValue<T>::Set(int32_t i) {
468 static_assert(std::is_base_of<T, Integer>::value, "type check");
469 if (const auto result = internal::Internals::TryIntegralToSmi(i)) {
470 SetInternal(*result);
471 return;
472 }
473 SetNonEmpty(Integer::New(GetIsolate(), i));
474}
475
476template <typename T>
477void ReturnValue<T>::Set(int64_t i) {
478 static_assert(std::is_base_of<T, Integer>::value, "type check");
479 if (const auto result = internal::Internals::TryIntegralToSmi(i)) {
480 SetInternal(*result);
481 return;
482 }
483 SetNonEmpty(Number::New(GetIsolate(), static_cast<double>(i)));
484}
485
486template <typename T>
487void ReturnValue<T>::Set(uint16_t i) {
488 static_assert(std::is_base_of<T, Integer>::value, "type check");
489 using I = internal::Internals;
490 static_assert(I::IsValidSmi(std::numeric_limits<uint16_t>::min()));
491 static_assert(I::IsValidSmi(std::numeric_limits<uint16_t>::max()));
492 SetInternal(I::IntegralToSmi(i));
493}
494
495template <typename T>
496void ReturnValue<T>::Set(uint32_t i) {
497 static_assert(std::is_base_of<T, Integer>::value, "type check");
498 if (const auto result = internal::Internals::TryIntegralToSmi(i)) {
499 SetInternal(*result);
500 return;
501 }
502 SetNonEmpty(Integer::NewFromUnsigned(GetIsolate(), i));
503}
504
505template <typename T>
506void ReturnValue<T>::Set(uint64_t i) {
507 static_assert(std::is_base_of<T, Integer>::value, "type check");
508 if (const auto result = internal::Internals::TryIntegralToSmi(i)) {
509 SetInternal(*result);
510 return;
511 }
512 SetNonEmpty(Number::New(GetIsolate(), static_cast<double>(i)));
513}
514
515template <typename T>
516void ReturnValue<T>::Set(bool value) {
517 static_assert(std::is_void<T>::value || std::is_base_of<T, Boolean>::value,
518 "type check");
519 using I = internal::Internals;
520#if V8_STATIC_ROOTS_BOOL
521#ifdef V8_ENABLE_CHECKS
523 internal::ValueHelper::SlotAsValue<Value, true>(value_));
524#endif // V8_ENABLE_CHECKS
525 SetInternal(value ? I::StaticReadOnlyRoot::kTrueValue
526 : I::StaticReadOnlyRoot::kFalseValue);
527#else
528 int root_index;
529 if (value) {
530 root_index = I::kTrueValueRootIndex;
531 } else {
532 root_index = I::kFalseValueRootIndex;
533 }
534 *value_ = I::GetRoot(GetIsolate(), root_index);
535#endif // V8_STATIC_ROOTS_BOOL
536}
537
538template <typename T>
540 using I = internal::Internals;
541 if constexpr (std::is_same_v<void, T> || std::is_same_v<v8::Boolean, T>) {
542 Set(true);
543 } else if constexpr (std::is_same_v<v8::Integer, T>) {
544 SetInternal(I::IntegralToSmi(0));
545 } else {
546 static_assert(std::is_same_v<v8::Value, T> || std::is_same_v<v8::Array, T>);
547#if V8_STATIC_ROOTS_BOOL
548 SetInternal(I::StaticReadOnlyRoot::kUndefinedValue);
549#else
550 *value_ = I::GetRoot(GetIsolate(), I::kUndefinedValueRootIndex);
551#endif // V8_STATIC_ROOTS_BOOL
552 }
553}
554
555template <typename T>
557 static_assert(std::is_base_of<T, Primitive>::value, "type check");
558 using I = internal::Internals;
559#if V8_STATIC_ROOTS_BOOL
560#ifdef V8_ENABLE_CHECKS
562 internal::ValueHelper::SlotAsValue<Value, true>(value_));
563#endif // V8_ENABLE_CHECKS
564 SetInternal(I::StaticReadOnlyRoot::kNullValue);
565#else
566 *value_ = I::GetRoot(GetIsolate(), I::kNullValueRootIndex);
567#endif // V8_STATIC_ROOTS_BOOL
568}
569
570template <typename T>
572 static_assert(std::is_base_of<T, Primitive>::value, "type check");
573 using I = internal::Internals;
574#if V8_STATIC_ROOTS_BOOL
575#ifdef V8_ENABLE_CHECKS
577 internal::ValueHelper::SlotAsValue<Value, true>(value_));
578#endif // V8_ENABLE_CHECKS
579 SetInternal(I::StaticReadOnlyRoot::kUndefinedValue);
580#else
581 *value_ = I::GetRoot(GetIsolate(), I::kUndefinedValueRootIndex);
582#endif // V8_STATIC_ROOTS_BOOL
583}
584
585template <typename T>
587 static_assert(std::is_void<T>::value || std::is_base_of<T, Boolean>::value,
588 "type check");
589 using I = internal::Internals;
590#if V8_STATIC_ROOTS_BOOL
591#ifdef V8_ENABLE_CHECKS
593 internal::ValueHelper::SlotAsValue<Value, true>(value_));
594#endif // V8_ENABLE_CHECKS
595 SetInternal(I::StaticReadOnlyRoot::kFalseValue);
596#else
597 *value_ = I::GetRoot(GetIsolate(), I::kFalseValueRootIndex);
598#endif // V8_STATIC_ROOTS_BOOL
599}
600
601template <typename T>
603 static_assert(std::is_base_of<T, String>::value, "type check");
604 using I = internal::Internals;
605#if V8_STATIC_ROOTS_BOOL
606#ifdef V8_ENABLE_CHECKS
608 internal::ValueHelper::SlotAsValue<Value, true>(value_));
609#endif // V8_ENABLE_CHECKS
610 SetInternal(I::StaticReadOnlyRoot::kEmptyString);
611#else
612 *value_ = I::GetRoot(GetIsolate(), I::kEmptyStringRootIndex);
613#endif // V8_STATIC_ROOTS_BOOL
614}
615
616template <typename T>
618 return *reinterpret_cast<Isolate**>(&value_[kIsolateValueIndex]);
619}
620
621template <typename T>
624 internal::ValueHelper::SlotAsValue<Value>(value_));
625}
626
627template <typename T>
628template <typename S>
629void ReturnValue<T>::Set(S* whatever) {
630 static_assert(sizeof(S) < 0, "incompilable to prevent inadvertent misuse");
631}
632
633template <typename T>
635 internal::Address* values,
636 int length)
637 : implicit_args_(implicit_args), values_(values), length_(length) {}
638
639template <typename T>
641 // values_ points to the first argument (not the receiver).
642 if (i < 0 || Length() <= i) return Undefined(GetIsolate());
643 return Local<Value>::FromSlot(values_ + i);
644}
645
646template <typename T>
648 // values_ points to the first argument (not the receiver).
649 return Local<Object>::FromSlot(values_ + kThisValuesIndex);
650}
651
652template <typename T>
654 return Local<Object>::FromSlot(&implicit_args_[kHolderIndex]);
655}
656
657template <typename T>
659 return HolderSoonToBeDeprecated();
660}
661
662template <typename T>
664 return Local<Value>::FromSlot(&implicit_args_[kNewTargetIndex]);
665}
666
667template <typename T>
669 auto target = Local<v8::Data>::FromSlot(&implicit_args_[kTargetIndex]);
670 return api_internal::GetFunctionTemplateData(GetIsolate(), target);
671}
672
673template <typename T>
675 return *reinterpret_cast<Isolate**>(&implicit_args_[kIsolateIndex]);
676}
677
678template <typename T>
680 return ReturnValue<T>(&implicit_args_[kReturnValueIndex]);
681}
682
683template <typename T>
685 return !NewTarget()->IsUndefined();
686}
687
688template <typename T>
690 return static_cast<int>(length_);
691}
692
693template <typename T>
695 return *reinterpret_cast<Isolate**>(&args_[kIsolateIndex]);
696}
697
698template <typename T>
700 return Local<Value>::FromSlot(&args_[kDataIndex]);
701}
702
703template <typename T>
705 return Local<Object>::FromSlot(&args_[kThisIndex]);
706}
707
708template <typename T>
710 return Local<Object>::FromSlot(&args_[kHolderIndex]);
711}
712
713namespace api_internal {
714// Returns JSGlobalProxy if holder is JSGlobalObject or unmodified holder
715// otherwise.
717 internal::Address holder);
718} // namespace api_internal
719
720template <typename T>
722 using I = internal::Internals;
723 if (!I::HasHeapObjectTag(args_[kHolderV2Index])) {
724 args_[kHolderV2Index] =
726 }
727 return Local<Object>::FromSlot(&args_[kHolderV2Index]);
728}
729
730template <typename T>
732 return ReturnValue<T>(&args_[kReturnValueIndex]);
733}
734
735template <typename T>
737 using I = internal::Internals;
738 if (args_[kShouldThrowOnErrorIndex] !=
739 I::IntegralToSmi(I::kInferShouldThrowMode)) {
740 return args_[kShouldThrowOnErrorIndex] != I::IntegralToSmi(I::kDontThrow);
741 }
743 reinterpret_cast<v8::internal::Isolate*>(GetIsolate()));
744}
745
746} // namespace v8
747
748#endif // INCLUDE_V8_FUNCTION_CALLBACK_H_
Definition: v8-traced-handle.h:124
Definition: v8-function-callback.h:118
Local< Object > HolderSoonToBeDeprecated() const
Definition: v8-function-callback.h:653
ReturnValue< T > GetReturnValue() const
Definition: v8-function-callback.h:679
Local< Object > This() const
Definition: v8-function-callback.h:647
Local< Object > Holder() const
Definition: v8-function-callback.h:658
Local< Value > operator[](int i) const
Definition: v8-function-callback.h:640
Isolate * GetIsolate() const
Definition: v8-function-callback.h:674
Local< Value > NewTarget() const
Definition: v8-function-callback.h:663
friend class debug::ConsoleCallArguments
Definition: v8-function-callback.h:165
friend class internal::FunctionCallbackArguments
Definition: v8-function-callback.h:163
Local< Value > Data() const
Definition: v8-function-callback.h:668
bool IsConstructCall() const
Definition: v8-function-callback.h:684
int Length() const
Definition: v8-function-callback.h:689
Definition: v8-persistent-handle.h:347
static Local< Integer > New(Isolate *isolate, int32_t value)
static Local< Integer > NewFromUnsigned(Isolate *isolate, uint32_t value)
Definition: v8-isolate.h:261
Definition: v8-local-handle.h:266
static Local< T > New(Isolate *isolate, Local< T > that)
Definition: v8-local-handle.h:346
static Local< Number > New(Isolate *isolate, double value)
Definition: v8-object.h:233
Definition: v8-util.h:166
Definition: v8-function-callback.h:206
Local< Value > Data() const
Definition: v8-function-callback.h:699
friend class internal::PropertyCallbackArguments
Definition: v8-function-callback.h:312
Local< Object > Holder() const
Definition: v8-function-callback.h:709
bool ShouldThrowOnError() const
Definition: v8-function-callback.h:736
ReturnValue< T > GetReturnValue() const
Definition: v8-function-callback.h:731
Local< Object > HolderV2() const
Definition: v8-function-callback.h:721
friend void internal::PrintPropertyCallbackInfo(void *)
friend class MacroAssembler
Definition: v8-function-callback.h:311
Local< Object > This() const
Definition: v8-function-callback.h:704
Isolate * GetIsolate() const
Definition: v8-function-callback.h:694
Definition: v8-function-callback.h:41
void SetFalse()
Definition: v8-function-callback.h:586
void SetEmptyString()
Definition: v8-function-callback.h:602
friend class ReturnValue
Definition: v8-function-callback.h:88
void Set(const Global< S > &handle)
Definition: v8-function-callback.h:356
ReturnValue(const ReturnValue< S > &that)
Definition: v8-function-callback.h:44
void SetNonEmpty(const Global< S > &handle)
Definition: v8-function-callback.h:367
Local< Value > Get() const
Definition: v8-function-callback.h:622
void SetNull()
Definition: v8-function-callback.h:556
Isolate * GetIsolate() const
Definition: v8-function-callback.h:617
void SetUndefined()
Definition: v8-function-callback.h:571
Definition: v8-container.h:148
Definition: v8-value.h:32
internal::Address ptr() const
Definition: v8-handle-base.h:80
bool IsEmpty() const
Definition: v8-handle-base.h:60
Definition: v8-local-handle.h:72
Definition: v8-internal.h:794
static constexpr std::optional< Address > TryIntegralToSmi(T value)
Definition: v8-internal.h:1039
v8::Local< v8::Value > GetFunctionTemplateData(v8::Isolate *isolate, v8::Local< v8::Data > raw_target)
internal::Address ConvertToJSGlobalProxyIfNecessary(internal::Address holder)
const int kApiSystemPointerSize
Definition: v8-internal.h:65
void VerifyHandleIsNonEmpty(bool is_empty)
bool ShouldThrowOnError(internal::Isolate *isolate)
uintptr_t Address
Definition: v8-internal.h:52
void PerformCastCheck(T *data)
Definition: v8-internal.h:1290
void PrintFunctionCallbackInfo(void *function_callback_info)
Definition: libplatform.h:15
Local< Primitive > Undefined(Isolate *isolate)
Definition: v8-primitive.h:1021
void(*)(const FunctionCallbackInfo< Value > &info) FunctionCallback
Definition: v8-function-callback.h:333
#define V8_EXPORT
Definition: v8config.h:793
#define V8_INLINE
Definition: v8config.h:499
#define V8_DEPRECATE_SOON(message)
Definition: v8config.h:603
#define V8_DEPRECATED(message)
Definition: v8config.h:595
#define V8_UNLIKELY(condition)
Definition: v8config.h:649