Loading...
Searching...
No Matches
v8-fast-api-calls.h
Go to the documentation of this file.
1// Copyright 2020 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_FAST_API_CALLS_H_
6#define INCLUDE_V8_FAST_API_CALLS_H_
7
206#include <stddef.h>
207#include <stdint.h>
208
209#include <tuple>
210#include <type_traits>
211
212#include "v8-external.h" // NOLINT(build/include_directory)
213#include "v8-internal.h" // NOLINT(build/include_directory)
214#include "v8-local-handle.h" // NOLINT(build/include_directory)
215#include "v8-typed-array.h" // NOLINT(build/include_directory)
216#include "v8-value.h" // NOLINT(build/include_directory)
217#include "v8config.h" // NOLINT(build/include_directory)
218
219namespace v8 {
220
221class Isolate;
222
224 public:
225 enum class Type : uint8_t {
226 kVoid,
227 kBool,
228 kUint8,
229 kInt32,
230 kUint32,
231 kInt64,
232 kUint64,
233 kFloat32,
234 kFloat64,
235 kPointer,
236 kV8Value,
238 kApiObject, // This will be deprecated once all users have
239 // migrated from v8::ApiObject to v8::Local<v8::Value>.
240 kAny, // This is added to enable untyped representation of fast
241 // call arguments for test purposes. It can represent any of
242 // the other types stored in the same memory as a union
243 // (see AnyCType declared below). This allows for
244 // uniform passing of arguments w.r.t. their location
245 // (in a register or on the stack), independent of their
246 // actual type. It's currently used by the arm64 simulator
247 // and can be added to the other simulators as well when fast
248 // calls having both GP and FP params need to be supported.
249 };
250
251 // kCallbackOptionsType is not part of the Type enum
252 // because it is only used internally. Use value 255 that is larger
253 // than any valid Type enum.
254 static constexpr Type kCallbackOptionsType = Type(255);
255
256 enum class Flags : uint8_t {
257 kNone = 0,
259 "ArrayBuffers and TypedArrays are not supported directly anymore.") =
260 1 << 0, // Must be an ArrayBuffer or TypedArray
262 "Range checks should be done by the API function.") =
263 1 << 1, // T must be integral
264 kClampBit = 1 << 2, // T must be integral
266 "Restricted float checks should be done by the API function.") =
267 1 << 3, // T must be float or double
268 };
269
270 explicit constexpr CTypeInfo(Type type, Flags flags = Flags::kNone)
271 : type_(type), flags_(flags) {}
272
273 typedef uint32_t Identifier;
274 explicit constexpr CTypeInfo(Identifier identifier)
275 : type_(static_cast<Type>((identifier >> 8) & 255)),
276 flags_(static_cast<Flags>(identifier & 255)) {}
277 constexpr Identifier GetId() const {
278 return static_cast<uint8_t>(type_) << 8 |
279 static_cast<uint8_t>(flags_);
280 }
281
282 constexpr Type GetType() const { return type_; }
283 constexpr Flags GetFlags() const { return flags_; }
284
285 static constexpr bool IsIntegralType(Type type) {
286 return type == Type::kUint8 || type == Type::kInt32 ||
287 type == Type::kUint32 || type == Type::kInt64 ||
288 type == Type::kUint64;
289 }
290
291 static constexpr bool IsFloatingPointType(Type type) {
292 return type == Type::kFloat32 || type == Type::kFloat64;
293 }
294
295 static constexpr bool IsPrimitive(Type type) {
296 return IsIntegralType(type) || IsFloatingPointType(type) ||
297 type == Type::kBool;
298 }
299
300 private:
301 Type type_;
302 Flags flags_;
303};
304
306 const char* data;
307 uint32_t length;
308};
309
311 public:
312 enum class Int64Representation : uint8_t {
313 kNumber = 0, // Use numbers to represent 64 bit integers.
314 kBigInt = 1, // Use BigInts to represent 64 bit integers.
315 };
316
317 // Construct a struct to hold a CFunction's type information.
318 // |return_info| describes the function's return type.
319 // |arg_info| is an array of |arg_count| CTypeInfos describing the
320 // arguments. Only the last argument may be of the special type
321 // CTypeInfo::kCallbackOptionsType.
322 CFunctionInfo(const CTypeInfo& return_info, unsigned int arg_count,
323 const CTypeInfo* arg_info,
324 Int64Representation repr = Int64Representation::kNumber);
325
326 const CTypeInfo& ReturnInfo() const { return return_info_; }
327
328 // The argument count, not including the v8::FastApiCallbackOptions
329 // if present.
330 unsigned int ArgumentCount() const {
331 return HasOptions() ? arg_count_ - 1 : arg_count_;
332 }
333
335
336 // |index| must be less than ArgumentCount().
337 // Note: if the last argument passed on construction of CFunctionInfo
338 // has type CTypeInfo::kCallbackOptionsType, it is not included in
339 // ArgumentCount().
340 const CTypeInfo& ArgumentInfo(unsigned int index) const;
341
342 bool HasOptions() const {
343 // The options arg is always the last one.
344 return arg_count_ > 0 && arg_info_[arg_count_ - 1].GetType() ==
345 CTypeInfo::kCallbackOptionsType;
346 }
347
348 private:
349 const CTypeInfo return_info_;
350 const Int64Representation repr_;
351 const unsigned int arg_count_;
352 const CTypeInfo* arg_info_;
353};
354
355struct FastApiCallbackOptions;
356
357// Provided for testing.
359 AnyCType() : int64_value(0) {}
360
361#if defined(V8_ENABLE_LOCAL_OFF_STACK_CHECK) && V8_HAS_ATTRIBUTE_TRIVIAL_ABI
362 // In this case, Local<T> is not trivially copyable and the implicit
363 // copy constructor and copy assignment for the union are deleted.
364 AnyCType(const AnyCType& other) : int64_value(other.int64_value) {}
365 AnyCType& operator=(const AnyCType& other) {
366 int64_value = other.int64_value;
367 return *this;
368 }
369#endif
370
372 int32_t int32_value;
373 uint32_t uint32_value;
374 int64_t int64_value;
375 uint64_t uint64_value;
383};
384
385static_assert(
386 sizeof(AnyCType) == 8,
387 "The union AnyCType should have size == 64 bits, as this is assumed "
388 "by FastApiCallLoweringReducer.");
389
391 public:
392 constexpr CFunction() : address_(nullptr), type_info_(nullptr) {}
393
394 const CTypeInfo& ReturnInfo() const { return type_info_->ReturnInfo(); }
395
396 const CTypeInfo& ArgumentInfo(unsigned int index) const {
397 return type_info_->ArgumentInfo(index);
398 }
399
400 unsigned int ArgumentCount() const { return type_info_->ArgumentCount(); }
401
402 const void* GetAddress() const { return address_; }
404 return type_info_->GetInt64Representation();
405 }
406 const CFunctionInfo* GetTypeInfo() const { return type_info_; }
407
408 enum class OverloadResolution { kImpossible, kAtRuntime, kAtCompileTime };
409
410 template <typename F>
411 static CFunction Make(F* func,
413 CFunctionInfo::Int64Representation::kNumber) {
414 CFunction result = ArgUnwrap<F*>::Make(func, int64_rep);
415 result.GetInt64Representation();
416 return result;
417 }
418
419 // Provided for testing purposes.
420 template <typename R, typename... Args, typename R_Patch,
421 typename... Args_Patch>
422 static CFunction Make(R (*func)(Args...),
423 R_Patch (*patching_func)(Args_Patch...),
425 CFunctionInfo::Int64Representation::kNumber) {
426 CFunction c_func = ArgUnwrap<R (*)(Args...)>::Make(func, int64_rep);
427 static_assert(
428 sizeof...(Args_Patch) == sizeof...(Args),
429 "The patching function must have the same number of arguments.");
430 c_func.address_ = reinterpret_cast<void*>(patching_func);
431 return c_func;
432 }
433
434 CFunction(const void* address, const CFunctionInfo* type_info);
435
436 private:
437 const void* address_;
438 const CFunctionInfo* type_info_;
439
440 template <typename F>
441 class ArgUnwrap {
442 static_assert(sizeof(F) != sizeof(F),
443 "CFunction must be created from a function pointer.");
444 };
445
446 template <typename R, typename... Args>
447 class ArgUnwrap<R (*)(Args...)> {
448 public:
449 static CFunction Make(R (*func)(Args...),
451 CFunctionInfo::Int64Representation::kNumber);
452 };
453};
454
467 return {};
468 }
469
471
476
480 V8_DEPRECATE_SOON("Use data instead")
481 V8_INLINE v8::Local<v8::Data> DataV2() const { return data; }
482};
483
484namespace internal {
485
486// Helper to count the number of occurances of `T` in `List`
487template <typename T, typename... List>
488struct count : std::integral_constant<int, 0> {};
489template <typename T, typename... Args>
490struct count<T, T, Args...>
491 : std::integral_constant<std::size_t, 1 + count<T, Args...>::value> {};
492template <typename T, typename U, typename... Args>
493struct count<T, U, Args...> : count<T, Args...> {};
494
495template <CFunctionInfo::Int64Representation Representation,
496 typename RetBuilder, typename... ArgBuilders>
498 static constexpr int kOptionsArgCount =
499 count<FastApiCallbackOptions&, ArgBuilders...>();
500 static constexpr int kReceiverCount = 1;
501
502 static_assert(kOptionsArgCount == 0 || kOptionsArgCount == 1,
503 "Only one options parameter is supported.");
504
505 static_assert(sizeof...(ArgBuilders) >= kOptionsArgCount + kReceiverCount,
506 "The receiver or the options argument is missing.");
507
508 public:
510 : CFunctionInfo(RetBuilder::Build(), sizeof...(ArgBuilders),
511 arg_info_storage_, Representation),
512 arg_info_storage_{ArgBuilders::Build()...} {
513 constexpr CTypeInfo::Type kReturnType = RetBuilder::Build().GetType();
514 static_assert(kReturnType == CTypeInfo::Type::kVoid ||
515 kReturnType == CTypeInfo::Type::kBool ||
516 kReturnType == CTypeInfo::Type::kInt32 ||
517 kReturnType == CTypeInfo::Type::kUint32 ||
518 kReturnType == CTypeInfo::Type::kInt64 ||
519 kReturnType == CTypeInfo::Type::kUint64 ||
520 kReturnType == CTypeInfo::Type::kFloat32 ||
521 kReturnType == CTypeInfo::Type::kFloat64 ||
522 kReturnType == CTypeInfo::Type::kPointer ||
523 kReturnType == CTypeInfo::Type::kAny,
524 "String and api object values are not currently "
525 "supported return types.");
526 }
527
528 private:
529 const CTypeInfo arg_info_storage_[sizeof...(ArgBuilders)];
530};
531
532template <typename T>
534 static_assert(sizeof(T) != sizeof(T), "This type is not supported");
535};
536
537#define SPECIALIZE_GET_TYPE_INFO_HELPER_FOR(T, Enum) \
538 template <> \
539 struct TypeInfoHelper<T> { \
540 static constexpr CTypeInfo::Flags Flags() { \
541 return CTypeInfo::Flags::kNone; \
542 } \
543 \
544 static constexpr CTypeInfo::Type Type() { return CTypeInfo::Type::Enum; } \
545 };
546
547template <CTypeInfo::Type type>
549
550#define DEFINE_TYPE_INFO_TRAITS(CType, Enum) \
551 template <> \
552 struct CTypeInfoTraits<CTypeInfo::Type::Enum> { \
553 using ctype = CType; \
554 };
555
556#define PRIMITIVE_C_TYPES(V) \
557 V(bool, kBool) \
558 V(uint8_t, kUint8) \
559 V(int32_t, kInt32) \
560 V(uint32_t, kUint32) \
561 V(int64_t, kInt64) \
562 V(uint64_t, kUint64) \
563 V(float, kFloat32) \
564 V(double, kFloat64) \
565 V(void*, kPointer)
566
567// Same as above, but includes deprecated types for compatibility.
568#define ALL_C_TYPES(V) \
569 PRIMITIVE_C_TYPES(V) \
570 V(void, kVoid) \
571 V(v8::Local<v8::Value>, kV8Value) \
572 V(v8::Local<v8::Object>, kV8Value) \
573 V(v8::Local<v8::Array>, kV8Value) \
574 V(AnyCType, kAny)
575
576// ApiObject was a temporary solution to wrap the pointer to the v8::Value.
577// Please use v8::Local<v8::Value> in new code for the arguments and
578// v8::Local<v8::Object> for the receiver, as ApiObject will be deprecated.
579
582
583#undef PRIMITIVE_C_TYPES
584#undef ALL_C_TYPES
585
586#undef TYPED_ARRAY_C_TYPES
588template <>
590 static constexpr CTypeInfo::Flags Flags() { return CTypeInfo::Flags::kNone; }
591
592 static constexpr CTypeInfo::Type Type() {
594 }
597template <>
599 static constexpr CTypeInfo::Flags Flags() { return CTypeInfo::Flags::kNone; }
600
601 static constexpr CTypeInfo::Type Type() {
604};
605
606#define STATIC_ASSERT_IMPLIES(COND, ASSERTION, MSG) \
607 static_assert(((COND) == 0) || (ASSERTION), MSG)
608
609} // namespace internal
610
611template <typename T, CTypeInfo::Flags... Flags>
613 public:
614 using BaseType = T;
615
617 static constexpr CTypeInfo Build() {
618 constexpr CTypeInfo::Flags kFlags =
619 MergeFlags(internal::TypeInfoHelper<T>::Flags(), Flags...);
621
623 uint8_t(kFlags) & uint8_t(CTypeInfo::Flags::kEnforceRangeBit),
624 CTypeInfo::IsIntegralType(kType),
625 "kEnforceRangeBit is only allowed for integral types.");
627 uint8_t(kFlags) & uint8_t(CTypeInfo::Flags::kClampBit),
628 CTypeInfo::IsIntegralType(kType),
629 "kClampBit is only allowed for integral types.");
631 uint8_t(kFlags) & uint8_t(CTypeInfo::Flags::kIsRestrictedBit),
632 CTypeInfo::IsFloatingPointType(kType),
633 "kIsRestrictedBit is only allowed for floating point types.");
634
635 // Return the same type with the merged flags.
637 }
639
640 private:
641 template <typename... Rest>
642 static constexpr CTypeInfo::Flags MergeFlags(CTypeInfo::Flags flags,
643 Rest... rest) {
644 return CTypeInfo::Flags(uint8_t(flags) | uint8_t(MergeFlags(rest...)));
645 }
646 static constexpr CTypeInfo::Flags MergeFlags() { return CTypeInfo::Flags(0); }
647};
649namespace internal {
650template <typename RetBuilder, typename... ArgBuilders>
652 public:
653 explicit constexpr CFunctionBuilderWithFunction(const void* fn) : fn_(fn) {}
654
655 template <CTypeInfo::Flags... Flags>
656 constexpr auto Ret() {
658 CTypeInfoBuilder<typename RetBuilder::BaseType, Flags...>,
659 ArgBuilders...>(fn_);
661
662 template <unsigned int N, CTypeInfo::Flags... Flags>
663 constexpr auto Arg() {
664 // Return a copy of the builder with the Nth arg builder merged with
665 // template parameter pack Flags.
666 return ArgImpl<N, Flags...>(
667 std::make_index_sequence<sizeof...(ArgBuilders)>());
668 }
670 // Provided for testing purposes.
671 template <typename Ret, typename... Args>
672 auto Patch(Ret (*patching_func)(Args...)) {
673 static_assert(
674 sizeof...(Args) == sizeof...(ArgBuilders),
675 "The patching function must have the same number of arguments.");
676 fn_ = reinterpret_cast<void*>(patching_func);
677 return *this;
678 }
680 template <CFunctionInfo::Int64Representation Representation =
682 auto Build() {
683 static CFunctionInfoImpl<Representation, RetBuilder, ArgBuilders...>
684 instance;
685 return CFunction(fn_, &instance);
686 }
687
688 private:
689 template <bool Merge, unsigned int N, CTypeInfo::Flags... Flags>
690 struct GetArgBuilder;
691
692 // Returns the same ArgBuilder as the one at index N, including its flags.
693 // Flags in the template parameter pack are ignored.
694 template <unsigned int N, CTypeInfo::Flags... Flags>
695 struct GetArgBuilder<false, N, Flags...> {
696 using type = std::tuple_element_t<N, std::tuple<ArgBuilders...>>;
697 };
698
699 // Returns an ArgBuilder with the same base type as the one at index N,
700 // but merges the flags with the flags in the template parameter pack.
701 template <unsigned int N, CTypeInfo::Flags... Flags>
702 struct GetArgBuilder<true, N, Flags...> {
703 using type = CTypeInfoBuilder<
704 typename std::tuple_element_t<N, std::tuple<ArgBuilders...>>::BaseType,
705 std::tuple_element_t<N, std::tuple<ArgBuilders...>>::Build().GetFlags(),
706 Flags...>;
707 };
708
709 // Return a copy of the CFunctionBuilder, but merges the Flags on
710 // ArgBuilder index N with the new Flags passed in the template parameter
711 // pack.
712 template <unsigned int N, CTypeInfo::Flags... Flags, size_t... I>
713 constexpr auto ArgImpl(std::index_sequence<I...>) {
714 return CFunctionBuilderWithFunction<
715 RetBuilder, typename GetArgBuilder<N == I, I, Flags...>::type...>(fn_);
716 }
717
718 const void* fn_;
719};
721class CFunctionBuilder {
722 public:
723 constexpr CFunctionBuilder() {}
724
725 template <typename R, typename... Args>
726 constexpr auto Fn(R (*fn)(Args...)) {
729 reinterpret_cast<const void*>(fn));
730 }
731};
732
733} // namespace internal
734
735// static
736template <typename R, typename... Args>
737CFunction CFunction::ArgUnwrap<R (*)(Args...)>::Make(
738 R (*func)(Args...), CFunctionInfo::Int64Representation int64_rep) {
740 return internal::CFunctionBuilder().Fn(func).Build();
741 }
742 return internal::CFunctionBuilder()
743 .Fn(func)
744 .template Build<CFunctionInfo::Int64Representation::kBigInt>();
745}
746
747using CFunctionBuilder = internal::CFunctionBuilder;
748
749static constexpr CTypeInfo kTypeInfoInt32 = CTypeInfo(CTypeInfo::Type::kInt32);
750static constexpr CTypeInfo kTypeInfoFloat64 =
751 CTypeInfo(CTypeInfo::Type::kFloat64);
752
765template <CTypeInfo::Identifier type_info_id, typename T>
767 Local<Array> src, T* dst, uint32_t max_length);
768
769template <>
771TryToCopyAndConvertArrayToCppBuffer<CTypeInfoBuilder<int32_t>::Build().GetId(),
772 int32_t>(Local<Array> src, int32_t* dst,
773 uint32_t max_length);
774
775template <>
777TryToCopyAndConvertArrayToCppBuffer<CTypeInfoBuilder<uint32_t>::Build().GetId(),
778 uint32_t>(Local<Array> src, uint32_t* dst,
779 uint32_t max_length);
780
781template <>
783TryToCopyAndConvertArrayToCppBuffer<CTypeInfoBuilder<float>::Build().GetId(),
784 float>(Local<Array> src, float* dst,
785 uint32_t max_length);
786
787template <>
789TryToCopyAndConvertArrayToCppBuffer<CTypeInfoBuilder<double>::Build().GetId(),
790 double>(Local<Array> src, double* dst,
791 uint32_t max_length);
792
795
796} // namespace v8
797
798#endif // INCLUDE_V8_FAST_API_CALLS_H_
Definition: v8-fast-api-calls.h:310
Int64Representation GetInt64Representation() const
Definition: v8-fast-api-calls.h:334
Int64Representation
Definition: v8-fast-api-calls.h:312
const CTypeInfo & ReturnInfo() const
Definition: v8-fast-api-calls.h:326
const CTypeInfo & ArgumentInfo(unsigned int index) const
bool HasOptions() const
Definition: v8-fast-api-calls.h:342
unsigned int ArgumentCount() const
Definition: v8-fast-api-calls.h:330
CFunctionInfo(const CTypeInfo &return_info, unsigned int arg_count, const CTypeInfo *arg_info, Int64Representation repr=Int64Representation::kNumber)
Definition: v8-fast-api-calls.h:390
const CTypeInfo & ReturnInfo() const
Definition: v8-fast-api-calls.h:394
constexpr CFunction()
Definition: v8-fast-api-calls.h:392
const CTypeInfo & ArgumentInfo(unsigned int index) const
Definition: v8-fast-api-calls.h:396
unsigned int ArgumentCount() const
Definition: v8-fast-api-calls.h:400
CFunctionInfo::Int64Representation GetInt64Representation() const
Definition: v8-fast-api-calls.h:403
CFunction(const void *address, const CFunctionInfo *type_info)
static CFunction Make(R(*func)(Args...), R_Patch(*patching_func)(Args_Patch...), CFunctionInfo::Int64Representation int64_rep=CFunctionInfo::Int64Representation::kNumber)
Definition: v8-fast-api-calls.h:422
const void * GetAddress() const
Definition: v8-fast-api-calls.h:402
OverloadResolution
Definition: v8-fast-api-calls.h:408
const CFunctionInfo * GetTypeInfo() const
Definition: v8-fast-api-calls.h:406
static CFunction Make(F *func, CFunctionInfo::Int64Representation int64_rep=CFunctionInfo::Int64Representation::kNumber)
Definition: v8-fast-api-calls.h:411
Definition: v8-fast-api-calls.h:609
static constexpr CTypeInfo Build()
Definition: v8-fast-api-calls.h:614
T BaseType
Definition: v8-fast-api-calls.h:611
Definition: v8-fast-api-calls.h:223
Flags
Definition: v8-fast-api-calls.h:256
constexpr CTypeInfo(Type type, Flags flags=Flags::kNone)
Definition: v8-fast-api-calls.h:270
static constexpr bool IsFloatingPointType(Type type)
Definition: v8-fast-api-calls.h:291
static constexpr bool IsPrimitive(Type type)
Definition: v8-fast-api-calls.h:295
static constexpr Type kCallbackOptionsType
Definition: v8-fast-api-calls.h:254
static constexpr bool IsIntegralType(Type type)
Definition: v8-fast-api-calls.h:285
constexpr Identifier GetId() const
Definition: v8-fast-api-calls.h:277
constexpr Type GetType() const
Definition: v8-fast-api-calls.h:282
constexpr Flags GetFlags() const
Definition: v8-fast-api-calls.h:283
Type
Definition: v8-fast-api-calls.h:225
uint32_t Identifier
Definition: v8-fast-api-calls.h:273
constexpr CTypeInfo(Identifier identifier)
Definition: v8-fast-api-calls.h:274
Definition: v8-data.h:18
Definition: v8-isolate.h:305
Definition: v8-local-handle.h:356
Definition: v8-fast-api-calls.h:648
auto Build()
Definition: v8-fast-api-calls.h:679
constexpr auto Ret()
Definition: v8-fast-api-calls.h:653
constexpr auto Arg()
Definition: v8-fast-api-calls.h:660
auto Patch(Ret(*patching_func)(Args...))
Definition: v8-fast-api-calls.h:669
Definition: v8-fast-api-calls.h:718
constexpr CFunctionBuilder()
Definition: v8-fast-api-calls.h:720
constexpr auto Fn(R(*fn)(Args...))
Definition: v8-fast-api-calls.h:723
Definition: v8-fast-api-calls.h:497
constexpr CFunctionInfoImpl()
Definition: v8-fast-api-calls.h:509
Definition: libplatform.h:15
constexpr v8::ExternalPointerTypeTag kFastAPIPointerTag
Definition: v8-fast-api-calls.h:790
bool TryToCopyAndConvertArrayToCppBuffer(Local< Array > src, T *dst, uint32_t max_length)
uint16_t ExternalPointerTypeTag
Definition: v8-external.h:21
internal::CFunctionBuilder CFunctionBuilder
Definition: v8-fast-api-calls.h:744
Definition: v8-fast-api-calls.h:461
v8::Isolate * isolate
Definition: v8-fast-api-calls.h:470
v8::Local< v8::Data > data
Definition: v8-fast-api-calls.h:475
static FastApiCallbackOptions CreateForTesting(Isolate *isolate)
Definition: v8-fast-api-calls.h:466
v8::Local< v8::Data > DataV2() const
Definition: v8-fast-api-calls.h:481
Definition: v8-fast-api-calls.h:305
const char * data
Definition: v8-fast-api-calls.h:306
uint32_t length
Definition: v8-fast-api-calls.h:307
Definition: v8-fast-api-calls.h:548
Definition: v8-fast-api-calls.h:533
Definition: v8-fast-api-calls.h:488
Definition: v8-fast-api-calls.h:358
FastApiCallbackOptions * options_value
Definition: v8-fast-api-calls.h:382
AnyCType()
Definition: v8-fast-api-calls.h:359
const FastOneByteString * string_value
Definition: v8-fast-api-calls.h:381
Local< Array > sequence_value
Definition: v8-fast-api-calls.h:380
Local< Object > object_value
Definition: v8-fast-api-calls.h:379
double double_value
Definition: v8-fast-api-calls.h:377
void * pointer_value
Definition: v8-fast-api-calls.h:378
uint32_t uint32_value
Definition: v8-fast-api-calls.h:373
bool bool_value
Definition: v8-fast-api-calls.h:371
float float_value
Definition: v8-fast-api-calls.h:376
uint64_t uint64_value
Definition: v8-fast-api-calls.h:375
int32_t int32_value
Definition: v8-fast-api-calls.h:372
int64_t int64_value
Definition: v8-fast-api-calls.h:374
#define DEFINE_TYPE_INFO_TRAITS(CType, Enum)
Definition: v8-fast-api-calls.h:550
#define PRIMITIVE_C_TYPES(V)
Definition: v8-fast-api-calls.h:556
#define SPECIALIZE_GET_TYPE_INFO_HELPER_FOR(T, Enum)
Definition: v8-fast-api-calls.h:537
#define ALL_C_TYPES(V)
Definition: v8-fast-api-calls.h:568
#define STATIC_ASSERT_IMPLIES(COND, ASSERTION, MSG)
Definition: v8-fast-api-calls.h:603
#define V8_EXTERNAL_POINTER_TAG_COUNT
Definition: v8-internal.h:474
#define V8_EXPORT
Definition: v8config.h:875
#define V8_INLINE
Definition: v8config.h:519
#define V8_DEPRECATE_SOON(message)
Definition: v8config.h:632
#define END_ALLOW_USE_DEPRECATED()
Definition: v8config.h:652
#define V8_WARN_UNUSED_RESULT
Definition: v8config.h:689
#define V8_TRIVIAL_ABI
Definition: v8config.h:828
#define START_ALLOW_USE_DEPRECATED()
Definition: v8config.h:651