v8 12.4.254 (node 22.4.1)
V8 is Google's open source JavaScript engine
Loading...
Searching...
No Matches
Namespaces | Data Structures | Typedefs | Enumerations | Functions
v8 Namespace Reference

Namespaces

namespace  api_internal
 
namespace  base
 
namespace  debug
 
namespace  detail
 
namespace  internal
 
namespace  metrics
 
namespace  platform
 

Data Structures

class  ActivityControl
 
class  AllocationProfile
 
union  AnyCType
 
class  Array
 
class  ArrayBuffer
 
class  ArrayBufferView
 
class  BackingStore
 
class  BasicTracedReference
 
class  BigInt
 
class  BigInt64Array
 
class  BigIntObject
 
class  BigUint64Array
 
class  Boolean
 
class  BooleanObject
 
class  CFunction
 
class  CFunctionInfo
 
class  CodeEvent
 
class  CodeEventHandler
 
class  CompiledWasmModule
 
class  Context
 
class  ConvertableToTraceFormat
 
class  CppHeap
 
struct  CppHeapCreateParams
 
class  CpuProfile
 
struct  CpuProfileDeoptFrame
 
struct  CpuProfileDeoptInfo
 
class  CpuProfileNode
 
class  CpuProfiler
 
class  CpuProfilingOptions
 
struct  CpuProfilingResult
 
class  CTypeInfo
 
class  CTypeInfoBuilder
 
class  CustomSpaceStatisticsReceiver
 
class  Data
 
class  DataView
 
class  Date
 
class  DefaultGlobalMapTraits
 
class  DefaultPersistentValueMapTraits
 
class  DefaultPersistentValueVectorTraits
 
struct  DeserializeContextDataCallback
 
struct  DeserializeInternalFieldsCallback
 
class  DictionaryTemplate
 
class  DiscardedSamplesDelegate
 
class  EmbedderGraph
 
class  EmbedderRootsHandler
 
class  EmbedderStateScope
 
class  EscapableHandleScope
 
class  EscapableHandleScopeBase
 
class  Eternal
 
class  Exception
 
class  Extension
 
class  ExtensionConfiguration
 
class  External
 
class  ExternalResourceVisitor
 
struct  FastApiArrayBuffer
 
struct  FastApiArrayBufferView
 
struct  FastApiCallbackOptions
 
struct  FastApiTypedArray
 
struct  FastApiTypedArrayBase
 
struct  FastOneByteString
 
class  FixedArray
 
class  Float16Array
 
class  Float32Array
 
class  Float64Array
 
class  Function
 
class  FunctionCallbackInfo
 
class  FunctionTemplate
 
class  Global
 
class  GlobalValueMap
 
class  HandleScope
 
class  HeapCodeStatistics
 
class  HeapGraphEdge
 
class  HeapGraphNode
 
class  HeapObjectStatistics
 
class  HeapProfiler
 
class  HeapSnapshot
 
class  HeapSpaceStatistics
 
class  HeapStatistics
 
struct  HeapStatsUpdate
 
class  HighAllocationThroughputObserver
 
class  IdleTask
 
struct  IndexedPropertyHandlerConfiguration
 
class  Int16Array
 
class  Int32
 
class  Int32Array
 
class  Int8Array
 
class  Integer
 
class  Isolate
 
struct  JitCodeEvent
 
class  JobDelegate
 
class  JobHandle
 
class  JobTask
 
struct  JSEntryStub
 
struct  JSEntryStubs
 
class  JSON
 
class  JSVisitor
 
class  Local
 
class  LocalBase
 
class  LocalVector
 
class  Location
 
class  Locker
 
class  Map
 
class  Maybe
 
class  Maybe< void >
 
class  MaybeLocal
 
class  MeasureMemoryDelegate
 
struct  MemoryRange
 
class  MemorySpan
 
class  Message
 
class  MicrotaskQueue
 
class  MicrotasksScope
 
struct  ModifyCodeGenerationFromStringsResult
 
class  Module
 
class  ModuleRequest
 
class  Name
 
struct  NamedPropertyHandlerConfiguration
 
class  NonCopyablePersistentTraits
 
class  Number
 
class  NumberObject
 
class  Numeric
 
class  Object
 
class  ObjectTemplate
 
struct  OOMDetails
 
class  OutputStream
 
struct  OwnedBuffer
 
class  PageAllocator
 
class  Persistent
 
class  PersistentBase
 
class  PersistentHandleVisitor
 
class  PersistentValueMap
 
class  PersistentValueMapBase
 
class  PersistentValueVector
 
class  Platform
 
class  Primitive
 
class  PrimitiveArray
 
class  Private
 
class  Promise
 
class  PromiseRejectMessage
 
class  PropertyCallbackInfo
 
class  PropertyDescriptor
 
class  Proxy
 
class  QueryObjectPredicate
 
class  RegExp
 
struct  RegisterState
 
class  ResourceConstraints
 
class  ReturnValue
 
struct  SampleInfo
 
class  ScopedBlockingCall
 
class  Script
 
class  ScriptCompiler
 
class  ScriptOrigin
 
class  ScriptOriginOptions
 
class  ScriptOrModule
 
class  SealHandleScope
 
struct  SerializeContextDataCallback
 
struct  SerializeInternalFieldsCallback
 
class  Set
 
class  SharedArrayBuffer
 
class  SharedMemoryStatistics
 
class  SharedValueConveyor
 
class  Signature
 
class  SnapshotCreator
 
class  SourceLocation
 
class  StackFrame
 
class  StackTrace
 
class  StartupData
 
class  StdGlobalValueMap
 
class  StdMapTraits
 
class  StdPersistentValueMap
 
class  String
 
class  StringObject
 
class  Symbol
 
class  SymbolObject
 
class  Task
 
class  TaskRunner
 
class  Template
 
class  ThreadIsolatedAllocator
 
class  Traced
 
class  TracedReference
 
class  TracedReferenceBase
 
class  TracingController
 
class  TryCatch
 
class  TypecheckWitness
 
class  TypedArray
 
class  Uint16Array
 
class  Uint32
 
class  Uint32Array
 
class  Uint8Array
 
class  Uint8ClampedArray
 
class  UnboundModuleScript
 
class  UnboundScript
 
class  Unlocker
 
class  Unwinder
 
class  V8
 
class  Value
 
class  ValueDeserializer
 
class  ValueSerializer
 
class  VirtualAddressSpace
 
class  WasmMemoryObject
 
class  WasmModuleObject
 
class  WasmStreaming
 
class  WeakCallbackInfo
 
struct  WrapperDescriptor
 
class  ZoneBackingAllocator
 

Typedefs

using BackingStoreDeleterCallback = void(*)(void *data, size_t length, void *deleter_data)
 
using JitCodeEventHandler = void(*)(const JitCodeEvent *event)
 
using GCCallback = void(*)(GCType type, GCCallbackFlags flags)
 
using InterruptCallback = void(*)(Isolate *isolate, void *data)
 
using NearHeapLimitCallback = size_t(*)(void *data, size_t current_heap_limit, size_t initial_heap_limit)
 
using CounterLookupCallback = int *(*)(const char *name)
 
using CreateHistogramCallback = void *(*)(const char *name, int min, int max, size_t buckets)
 
using AddHistogramSampleCallback = void(*)(void *histogram, int sample)
 
using FatalErrorCallback = void(*)(const char *location, const char *message)
 
using OOMErrorCallback = void(*)(const char *location, const OOMDetails &details)
 
using MessageCallback = void(*)(Local< Message > message, Local< Value > data)
 
using LogEventCallback = void(*)(const char *name, int status)
 
using AddCrashKeyCallback = void(*)(CrashKeyId id, const std::string &value)
 
using BeforeCallEnteredCallback = void(*)(Isolate *)
 
using CallCompletedCallback = void(*)(Isolate *)
 
using AllowCodeGenerationFromStringsCallback = bool(*)(Local< Context > context, Local< String > source)
 
using FailedAccessCheckCallback = void(*)(Local< Object > target, AccessType type, Local< Value > data)
 
using ModifyCodeGenerationFromStringsCallback = ModifyCodeGenerationFromStringsResult(*)(Local< Context > context, Local< Value > source)
 
using ModifyCodeGenerationFromStringsCallback2 = ModifyCodeGenerationFromStringsResult(*)(Local< Context > context, Local< Value > source, bool is_code_like)
 
using ExtensionCallback = bool(*)(const FunctionCallbackInfo< Value > &)
 
using AllowWasmCodeGenerationCallback = bool(*)(Local< Context > context, Local< String > source)
 
using ApiImplementationCallback = void(*)(const FunctionCallbackInfo< Value > &)
 
using WasmStreamingCallback = void(*)(const FunctionCallbackInfo< Value > &)
 
using WasmAsyncResolvePromiseCallback = void(*)(Isolate *isolate, Local< Context > context, Local< Promise::Resolver > resolver, Local< Value > result, WasmAsyncSuccess success)
 
using WasmLoadSourceMapCallback = Local< String >(*)(Isolate *isolate, const char *name)
 
using WasmImportedStringsEnabledCallback = bool(*)(Local< Context > context)
 
using SharedArrayBufferConstructorEnabledCallback = bool(*)(Local< Context > context)
 
using JavaScriptCompileHintsMagicEnabledCallback = bool(*)(Local< Context > context)
 
using WasmJSPIEnabledCallback = bool(*)(Local< Context > context)
 
using HostImportModuleDynamicallyCallback = MaybeLocal< Promise >(*)(Local< Context > context, Local< Data > host_defined_options, Local< Value > resource_name, Local< String > specifier, Local< FixedArray > import_attributes)
 
using CompileHintCallback = bool(*)(int, void *)
 
using HostInitializeImportMetaObjectCallback = void(*)(Local< Context > context, Local< Module > module, Local< Object > meta)
 
using HostCreateShadowRealmContextCallback = MaybeLocal< Context >(*)(Local< Context > initiator_context)
 
using PrepareStackTraceCallback = MaybeLocal< Value >(*)(Local< Context > context, Local< Value > error, Local< Array > sites)
 
using CFunctionBuilder = internal::CFunctionBuilder
 
using FunctionCallback = void(*)(const FunctionCallbackInfo< Value > &info)
 
using EntropySource = bool(*)(unsigned char *buffer, size_t length)
 
using ReturnAddressLocationResolver = uintptr_t(*)(uintptr_t return_addr_location)
 
using DcheckErrorCallback = void(*)(const char *file, int line, const char *message)
 
using StackState = cppgc::EmbedderStackState
 
template<class T >
using Handle = Local< T >
 
using MicrotasksCompletedCallbackWithData = void(*)(Isolate *, void *)
 
using MicrotaskCallback = void(*)(void *data)
 
using AccessorGetterCallback = void(*)(Local< String > property, const PropertyCallbackInfo< Value > &info)
 
using AccessorNameGetterCallback = void(*)(Local< Name > property, const PropertyCallbackInfo< Value > &info)
 
using AccessorSetterCallback = void(*)(Local< String > property, Local< Value > value, const PropertyCallbackInfo< void > &info)
 
using AccessorNameSetterCallback = void(*)(Local< Name > property, Local< Value > value, const PropertyCallbackInfo< void > &info)
 
template<class T >
using UniquePersistent = Global< T >
 
using PlatformSharedMemoryHandle = intptr_t
 
using NativeObject = void *
 
using SnapshotObjectId = uint32_t
 
using ProfilerId = uint32_t
 
using PromiseHook = void(*)(PromiseHookType type, Local< Promise > promise, Local< Value > parent)
 
using PromiseRejectCallback = void(*)(PromiseRejectMessage message)
 
using NamedPropertyGetterCallback = Intercepted(*)(Local< Name > property, const PropertyCallbackInfo< Value > &info)
 
using GenericNamedPropertyGetterCallback = void(*)(Local< Name > property, const PropertyCallbackInfo< Value > &info)
 
using NamedPropertySetterCallback = Intercepted(*)(Local< Name > property, Local< Value > value, const PropertyCallbackInfo< void > &info)
 
using GenericNamedPropertySetterCallback = void(*)(Local< Name > property, Local< Value > value, const PropertyCallbackInfo< Value > &info)
 
using NamedPropertyQueryCallback = Intercepted(*)(Local< Name > property, const PropertyCallbackInfo< Integer > &info)
 
using GenericNamedPropertyQueryCallback = void(*)(Local< Name > property, const PropertyCallbackInfo< Integer > &info)
 
using NamedPropertyDeleterCallback = Intercepted(*)(Local< Name > property, const PropertyCallbackInfo< Boolean > &info)
 
using GenericNamedPropertyDeleterCallback = void(*)(Local< Name > property, const PropertyCallbackInfo< Boolean > &info)
 
using NamedPropertyEnumeratorCallback = void(*)(const PropertyCallbackInfo< Array > &info)
 
using GenericNamedPropertyEnumeratorCallback = NamedPropertyEnumeratorCallback
 
using NamedPropertyDefinerCallback = Intercepted(*)(Local< Name > property, const PropertyDescriptor &desc, const PropertyCallbackInfo< void > &info)
 
using GenericNamedPropertyDefinerCallback = void(*)(Local< Name > property, const PropertyDescriptor &desc, const PropertyCallbackInfo< Value > &info)
 
using NamedPropertyDescriptorCallback = Intercepted(*)(Local< Name > property, const PropertyCallbackInfo< Value > &info)
 
using GenericNamedPropertyDescriptorCallback = void(*)(Local< Name > property, const PropertyCallbackInfo< Value > &info)
 
using IndexedPropertyGetterCallbackV2 = Intercepted(*)(uint32_t index, const PropertyCallbackInfo< Value > &info)
 
using IndexedPropertyGetterCallback = void(*)(uint32_t index, const PropertyCallbackInfo< Value > &info)
 
using IndexedPropertySetterCallbackV2 = Intercepted(*)(uint32_t index, Local< Value > value, const PropertyCallbackInfo< void > &info)
 
using IndexedPropertySetterCallback = void(*)(uint32_t index, Local< Value > value, const PropertyCallbackInfo< Value > &info)
 
using IndexedPropertyQueryCallbackV2 = Intercepted(*)(uint32_t index, const PropertyCallbackInfo< Integer > &info)
 
using IndexedPropertyQueryCallback = void(*)(uint32_t index, const PropertyCallbackInfo< Integer > &info)
 
using IndexedPropertyDeleterCallbackV2 = Intercepted(*)(uint32_t index, const PropertyCallbackInfo< Boolean > &info)
 
using IndexedPropertyDeleterCallback = void(*)(uint32_t index, const PropertyCallbackInfo< Boolean > &info)
 
using IndexedPropertyEnumeratorCallback = void(*)(const PropertyCallbackInfo< Array > &info)
 
using IndexedPropertyDefinerCallbackV2 = Intercepted(*)(uint32_t index, const PropertyDescriptor &desc, const PropertyCallbackInfo< void > &info)
 
using IndexedPropertyDefinerCallback = void(*)(uint32_t index, const PropertyDescriptor &desc, const PropertyCallbackInfo< Value > &info)
 
using IndexedPropertyDescriptorCallbackV2 = Intercepted(*)(uint32_t index, const PropertyCallbackInfo< Value > &info)
 
using IndexedPropertyDescriptorCallback = void(*)(uint32_t index, const PropertyCallbackInfo< Value > &info)
 
using AccessCheckCallback = bool(*)(Local< Context > accessing_context, Local< Object > accessed_object, Local< Value > data)
 
typedef uintptr_t PersistentContainerValue
 

Enumerations

enum class  ArrayBufferCreationMode { kInternalized , kExternalized }
 
enum  JitCodeEventOptions { kJitCodeEventDefault = 0 , kJitCodeEventEnumExisting = 1 }
 
enum  GCType {
  kGCTypeScavenge = 1 << 0 , kGCTypeMinorMarkSweep = 1 << 1 , V8_DEPRECATE_SOON , kGCTypeMarkSweepCompact = 1 << 2 ,
  kGCTypeIncrementalMarking = 1 << 3 , kGCTypeProcessWeakCallbacks = 1 << 4 , kGCTypeAll
}
 
enum  GCCallbackFlags {
  kNoGCCallbackFlags = 0 , kGCCallbackFlagConstructRetainedObjectInfos = 1 << 1 , kGCCallbackFlagForced = 1 << 2 , kGCCallbackFlagSynchronousPhantomCallbackProcessing = 1 << 3 ,
  kGCCallbackFlagCollectAllAvailableGarbage = 1 << 4 , kGCCallbackFlagCollectAllExternalMemory = 1 << 5 , kGCCallbackScheduleIdleGarbageCollection = 1 << 6
}
 
enum  LogEventStatus : int { kStart = 0 , kEnd = 1 , kStamp = 2 }
 
enum class  CrashKeyId {
  kIsolateAddress , kReadonlySpaceFirstPageAddress , V8_ENUM_DEPRECATE_SOON =("Map space got removed") , kOldSpaceFirstPageAddress ,
  kCodeRangeBaseAddress , kCodeSpaceFirstPageAddress , kDumpType , kSnapshotChecksumCalculated ,
  kSnapshotChecksumExpected
}
 
enum  AccessType {
  ACCESS_GET , ACCESS_SET , ACCESS_HAS , ACCESS_DELETE ,
  ACCESS_KEYS
}
 
enum class  WasmAsyncSuccess { kSuccess , kFail }
 
enum class  EmbedderStateTag : uint8_t { EMPTY = 0 , OTHER = 1 }
 
enum  RAILMode : unsigned { PERFORMANCE_RESPONSE , PERFORMANCE_ANIMATION , PERFORMANCE_IDLE , PERFORMANCE_LOAD }
 
enum class  MemoryPressureLevel { kNone , kModerate , kCritical }
 
enum class  MicrotasksPolicy { kExplicit , kScoped , kAuto }
 
enum  PropertyAttribute { None = 0 , ReadOnly = 1 << 0 , DontEnum = 1 << 1 , DontDelete = 1 << 2 }
 
enum  AccessControl { DEFAULT = 0 }
 
enum  PropertyFilter {
  ALL_PROPERTIES = 0 , ONLY_WRITABLE = 1 , ONLY_ENUMERABLE = 2 , ONLY_CONFIGURABLE = 4 ,
  SKIP_STRINGS = 8 , SKIP_SYMBOLS = 16
}
 
enum class  SideEffectType { kHasSideEffect , kHasNoSideEffect , kHasSideEffectToReceiver }
 
enum class  KeyCollectionMode { kOwnOnly , kIncludePrototypes }
 
enum class  IndexFilter { kIncludeIndices , kSkipIndices }
 
enum class  KeyConversionMode { kConvertToString , kKeepNumbers , kNoNumbers }
 
enum class  IntegrityLevel { kFrozen , kSealed }
 
enum class  TaskPriority : uint8_t { kBestEffort , kUserVisible , kUserBlocking , kMaxPriority = kUserBlocking }
 
enum class  BlockingType { kMayBlock , kWillBlock }
 
enum class  PagePermissions {
  kNoAccess , kRead , kReadWrite , kReadWriteExecute ,
  kReadExecute
}
 
enum class  NewStringType { kNormal , kInternalized }
 
enum  CpuProfilingMode { kLeafNodeLineNumbers , kCallerLineNumbers }
 
enum  CpuProfilingNamingMode { kStandardNaming , kDebugNaming }
 
enum  CpuProfilingLoggingMode { kLazyLogging , kEagerLogging }
 
enum class  CpuProfilingStatus { kStarted , kAlreadyStarted , kErrorTooManyProfilers }
 
enum  CodeEventType { kUnknownType }
 
enum class  PromiseHookType { kInit , kResolve , kBefore , kAfter }
 
enum  PromiseRejectEvent { kPromiseRejectWithNoHandler = 0 , kPromiseHandlerAddedAfterReject = 1 , kPromiseRejectAfterResolved = 2 , kPromiseResolveAfterResolved = 3 }
 
enum class  ScriptType { kClassic , kModule }
 
enum class  MeasureMemoryMode { kSummary , kDetailed }
 
enum class  MeasureMemoryExecution { kDefault , kEager , kLazy }
 
enum  Intrinsic
 
enum class  Intercepted : uint8_t { kNo = 0 , kYes = 1 }
 
enum class  ConstructorBehavior { kThrow , kAllow }
 
enum class  PropertyHandlerFlags {
  kNone = 0 , kNonMasking = 1 , kOnlyInterceptStrings = 1 << 1 , kHasNoSideEffect = 1 << 2 ,
  kInternalNewCallbacksSignatures = 1 << 10
}
 
enum  StateTag : uint16_t {
  JS , GC , PARSER , BYTECODE_COMPILER ,
  COMPILER , OTHER , EXTERNAL , ATOMICS_WAIT ,
  IDLE
}
 
enum  PersistentContainerCallbackType { kNotWeak , kWeakWithParameter , kWeakWithInternalFields }
 
enum class  WeakCallbackType { kParameter , kInternalFields }
 

Functions

void V8_EXPORT RegisterExtension (std::unique_ptr< Extension >)
 
template<CTypeInfo::Identifier type_info_id, typename T >
bool V8_EXPORT V8_WARN_UNUSED_RESULT TryToCopyAndConvertArrayToCppBuffer (Local< Array > src, T *dst, uint32_t max_length)
 
template<class T >
Maybe< T > Nothing ()
 
template<class T >
Maybe< T > Just (const T &t)
 
template<class T , std::enable_if_t<!std::is_lvalue_reference_v< T > > * = nullptr>
Maybe< T > Just (T &&t)
 
Maybe< void > JustVoid ()
 
template<class T , std::size_t N>
constexpr std::array< std::remove_cv_t< T >, N > to_array (T(&a)[N])
 
template<class T , std::size_t N>
constexpr std::array< std::remove_cv_t< T >, N > to_array (T(&&a)[N])
 
template<class T >
struct V8_DEPRECATED ("Use v8::Global instead") CopyablePersistentTraits
 
PlatformSharedMemoryHandle SharedMemoryHandleFromFileDescriptor (int fd)
 
int FileDescriptorFromSharedMemoryHandle (PlatformSharedMemoryHandle handle)
 
V8_INLINE Local< Primitive > Undefined (Isolate *isolate)
 
V8_INLINE Local< Primitive > Null (Isolate *isolate)
 
V8_INLINE Local< Boolean > True (Isolate *isolate)
 
V8_INLINE Local< Boolean > False (Isolate *isolate)
 
V8_INLINE bool operator== (const TracedReferenceBase &lhs, const TracedReferenceBase &rhs)
 
template<typename U >
V8_INLINE bool operator== (const TracedReferenceBase &lhs, const v8::Local< U > &rhs)
 
template<typename U >
V8_INLINE bool operator== (const v8::Local< U > &lhs, const TracedReferenceBase &rhs)
 
V8_INLINE bool operator!= (const TracedReferenceBase &lhs, const TracedReferenceBase &rhs)
 
template<typename U >
V8_INLINE bool operator!= (const TracedReferenceBase &lhs, const v8::Local< U > &rhs)
 
template<typename U >
V8_INLINE bool operator!= (const v8::Local< U > &lhs, const TracedReferenceBase &rhs)
 
template<typename V , typename Traits = DefaultPersistentValueVectorTraits>
class V8_DEPRECATE_SOON ("Use std::vector<Global<V>>.") PersistentValueVector
 
constexpr uint32_t CurrentValueSerializerFormatVersion ()
 
V8_EXPORT bool TryHandleWebAssemblyTrapPosix (int sig_code, siginfo_t *info, void *context)
 
V8_EXPORT bool TryHandleWebAssemblyTrapWindows (EXCEPTION_POINTERS *exception)
 

Detailed Description

This file provides additional API on top of the default one for making API calls, which come from embedder C++ functions. The functions are being called directly from optimized code, doing all the necessary typechecks in the compiler itself, instead of on the embedder side. Hence the "fast" in the name. Example usage might look like:

void FastMethod(int param, bool another_param);
v8::FunctionTemplate::New(isolate, SlowCallback, data,
signature, length, constructor_behavior
side_effect_type,
&v8::CFunction::Make(FastMethod));
v8::CFunction::Make
static CFunction Make(F *func)
Definition v8-fast-api-calls.h:532
v8::FunctionTemplate::New
static Local< FunctionTemplate > New(Isolate *isolate, FunctionCallback callback=nullptr, Local< Value > data=Local< Value >(), Local< Signature > signature=Local< Signature >(), int length=0, ConstructorBehavior behavior=ConstructorBehavior::kAllow, SideEffectType side_effect_type=SideEffectType::kHasSideEffect, const CFunction *c_function=nullptr, uint16_t instance_type=0, uint16_t allowed_receiver_instance_type_range_start=0, uint16_t allowed_receiver_instance_type_range_end=0)

By design, fast calls are limited by the following requirements, which the embedder should enforce themselves:

Due to these limitations, it's not directly possible to report errors by throwing a JS exception or to otherwise do an allocation. There is an alternative way of creating fast calls that supports falling back to the slow call and then performing the necessary allocation. When one creates the fast method by using CFunction::MakeWithFallbackSupport instead of CFunction::Make, the fast callback gets as last parameter an output variable, through which it can request falling back to the slow call. So one might declare their method like:

void FastMethodWithFallback(int param, FastApiCallbackOptions& options);

If the callback wants to signal an error condition or to perform an allocation, it must set options.fallback to true and do an early return from the fast method. Then V8 checks the value of options.fallback and if it's true, falls back to executing the SlowCallback, which is capable of reporting the error (either by throwing a JS exception or logging to the console) or doing the allocation. It's the embedder's responsibility to ensure that the fast callback is idempotent up to the point where error and fallback conditions are checked, because otherwise executing the slow callback might produce visible side-effects twice.

An example for custom embedder type support might employ a way to wrap/ unwrap various C++ types in JSObject instances, e.g:

// Helper method with a check for field count.
template <typename T, int offset>
inline T* GetInternalField(v8::Local<v8::Object> wrapper) {
assert(offset < wrapper->InternalFieldCount());
return reinterpret_cast<T*>(
wrapper->GetAlignedPointerFromInternalField(offset));
}
class CustomEmbedderType {
public:
// Returns the raw C object from a wrapper JS object.
static CustomEmbedderType* Unwrap(v8::Local<v8::Object> wrapper) {
return GetInternalField<CustomEmbedderType,
kV8EmbedderWrapperObjectIndex>(wrapper);
}
static void FastMethod(v8::Local<v8::Object> receiver_obj, int param) {
CustomEmbedderType* receiver = static_cast<CustomEmbedderType*>(
receiver_obj->GetAlignedPointerFromInternalField(
kV8EmbedderWrapperObjectIndex));
// Type checks are already done by the optimized code.
// Then call some performance-critical method like:
// receiver->Method(param);
}
static void SlowMethod(
const v8::FunctionCallbackInfo<v8::Value>& info) {
v8::Local<v8::Object> instance =
v8::Local<v8::Object>::Cast(info.Holder());
CustomEmbedderType* receiver = Unwrap(instance);
// TODO: Do type checks and extract {param}.
receiver->Method(param);
}
};
// TODO(mslekova): Clean-up these constants
// The constants kV8EmbedderWrapperTypeIndex and
// kV8EmbedderWrapperObjectIndex describe the offsets for the type info
// struct and the native object, when expressed as internal field indices
// within a JSObject. The existance of this helper function assumes that
// all embedder objects have their JSObject-side type info at the same
// offset, but this is not a limitation of the API itself. For a detailed
// use case, see the third example.
static constexpr int kV8EmbedderWrapperTypeIndex = 0;
static constexpr int kV8EmbedderWrapperObjectIndex = 1;
// The following setup function can be templatized based on
// the {embedder_object} argument.
void SetupCustomEmbedderObject(v8::Isolate* isolate,
v8::Local<v8::Context> context,
CustomEmbedderType* embedder_object) {
isolate->set_embedder_wrapper_type_index(
kV8EmbedderWrapperTypeIndex);
isolate->set_embedder_wrapper_object_index(
kV8EmbedderWrapperObjectIndex);
v8::CFunction c_func =
MakeV8CFunction(CustomEmbedderType::FastMethod);
Local<v8::FunctionTemplate> method_template =
v8::FunctionTemplate::New(
isolate, CustomEmbedderType::SlowMethod, v8::Local<v8::Value>(),
v8::Local<v8::Signature>(), 1, v8::ConstructorBehavior::kAllow,
v8::SideEffectType::kHasSideEffect, &c_func);
v8::Local<v8::ObjectTemplate> object_template =
v8::ObjectTemplate::New(isolate);
object_template->SetInternalFieldCount(
kV8EmbedderWrapperObjectIndex + 1);
object_template->Set(isolate, "method", method_template);
// Instantiate the wrapper JS object.
v8::Local<v8::Object> object =
object_template->NewInstance(context).ToLocalChecked();
object->SetAlignedPointerInInternalField(
kV8EmbedderWrapperObjectIndex,
reinterpret_cast<void*>(embedder_object));
// TODO: Expose {object} where it's necessary.
}
v8::FunctionCallbackInfo::Holder
V8_INLINE Local< Object > Holder() const
Definition v8-function-callback.h:535
v8::Local::Cast
static V8_INLINE Local< T > Cast(Local< S > that)
Definition v8-local-handle.h:313
v8::ObjectTemplate::New
static Local< ObjectTemplate > New(Isolate *isolate, Local< FunctionTemplate > constructor=Local< FunctionTemplate >())

For instance if {object} is exposed via a global "obj" variable, one could write in JS: function hot_func() { obj.method(42); } and once {hot_func} gets optimized, CustomEmbedderType::FastMethod will be called instead of the slow version, with the following arguments: receiver := the {embedder_object} from above param := 42

Currently supported return types:

  • void
  • bool
  • int32_t
  • uint32_t
  • float32_t
  • float64_t Currently supported argument types:

pointer to an embedder type

  • JavaScript array of primitive types
  • bool
  • int32_t
  • uint32_t
  • int64_t
  • uint64_t
  • float32_t
  • float64_t

The 64-bit integer types currently have the IDL (unsigned) long long semantics: https://heycam.github.io/webidl/#abstract-opdef-converttoint In the future we'll extend the API to also provide conversions from/to BigInt to preserve full precision. The floating point types currently have the IDL (unrestricted) semantics, which is the only one used by WebGL. We plan to add support also for restricted floats/doubles, similarly to the BigInt conversion policies. We also differ from the specific NaN bit pattern that WebIDL prescribes (https://heycam.github.io/webidl/#es-unrestricted-float) in that Blink passes NaN values as-is, i.e. doesn't normalize them.

To be supported types:

  • TypedArrays and ArrayBuffers
  • arrays of embedder types

The API offers a limited support for function overloads:

void FastMethod_2Args(int param, bool another_param);
void FastMethod_3Args(int param, bool another_param, int third_param);
v8::CFunction fast_method_2args_c_func =
MakeV8CFunction(FastMethod_2Args);
v8::CFunction fast_method_3args_c_func =
MakeV8CFunction(FastMethod_3Args);
const v8::CFunction fast_method_overloads[] = {fast_method_2args_c_func,
fast_method_3args_c_func};
Local<v8::FunctionTemplate> method_template =
v8::FunctionTemplate::NewWithCFunctionOverloads(
isolate, SlowCallback, data, signature, length,
constructor_behavior, side_effect_type,
{fast_method_overloads, 2});
v8::FunctionTemplate::NewWithCFunctionOverloads
static Local< FunctionTemplate > NewWithCFunctionOverloads(Isolate *isolate, FunctionCallback callback=nullptr, Local< Value > data=Local< Value >(), Local< Signature > signature=Local< Signature >(), int length=0, ConstructorBehavior behavior=ConstructorBehavior::kAllow, SideEffectType side_effect_type=SideEffectType::kHasSideEffect, const MemorySpan< const CFunction > &c_function_overloads={})

In this example a single FunctionTemplate is associated to multiple C++ functions. The overload resolution is currently only based on the number of arguments passed in a call. For example, if this method_template is registered with a wrapper JS object as described above, a call with two arguments: obj.method(42, true); will result in a fast call to FastMethod_2Args, while a call with three or more arguments: obj.method(42, true, 11); will result in a fast call to FastMethod_3Args. Instead a call with less than two arguments, like: obj.method(42); would not result in a fast call but would fall back to executing the associated SlowCallback.

The v8 JavaScript engine.

Profiler support for the V8 JavaScript engine.

Support for Persistent containers.

C++11 embedders can use STL containers with Global values, but pre-C++11 does not support the required move semantic and hence may want these container classes.

Compile-time constants.

This header provides access to information about the value serializer at compile time, without declaring or defining any symbols that require linking to V8.

Typedef Documentation

◆ AccessCheckCallback

using AccessCheckCallback = bool (*)(Local<Context> accessing_context, Local<Object> accessed_object, Local<Value> data)

Returns true if the given context should be allowed to access the given object.

Definition at line 451 of file v8-template.h.

◆ AccessorGetterCallback

using AccessorGetterCallback = void (*)(Local<String> property, const PropertyCallbackInfo<Value>& info)

Accessor[Getter|Setter] are used as callback functions when setting|getting a particular property. See Object and ObjectTemplate's method SetAccessor.

Definition at line 153 of file v8-object.h.

◆ AccessorNameGetterCallback

using AccessorNameGetterCallback = void (*)(Local<Name> property, const PropertyCallbackInfo<Value>& info)

Definition at line 155 of file v8-object.h.

◆ AccessorNameSetterCallback

using AccessorNameSetterCallback = void (*)(Local<Name> property, Local<Value> value, const PropertyCallbackInfo<void>& info)

Definition at line 161 of file v8-object.h.

◆ AccessorSetterCallback

using AccessorSetterCallback = void (*)(Local<String> property, Local<Value> value, const PropertyCallbackInfo<void>& info)

Definition at line 158 of file v8-object.h.

◆ AddCrashKeyCallback

using AddCrashKeyCallback = void (*)(CrashKeyId id, const std::string& value)

Definition at line 254 of file v8-callbacks.h.

◆ AddHistogramSampleCallback

using AddHistogramSampleCallback = void (*)(void* histogram, int sample)

Definition at line 219 of file v8-callbacks.h.

◆ AllowCodeGenerationFromStringsCallback

using AllowCodeGenerationFromStringsCallback = bool (*)(Local<Context> context, Local<String> source)

Callback to check if code generation from strings is allowed. See Context::AllowCodeGenerationFromStrings.

Definition at line 266 of file v8-callbacks.h.

◆ AllowWasmCodeGenerationCallback

using AllowWasmCodeGenerationCallback = bool (*)(Local<Context> context, Local<String> source)

Definition at line 309 of file v8-callbacks.h.

◆ ApiImplementationCallback

using ApiImplementationCallback = void (*)(const FunctionCallbackInfo<Value>&)

Definition at line 314 of file v8-callbacks.h.

◆ BackingStoreDeleterCallback

using BackingStoreDeleterCallback = void (*)(void* data, size_t length, void* deleter_data)

Definition at line 123 of file v8-array-buffer.h.

◆ BeforeCallEnteredCallback

using BeforeCallEnteredCallback = void (*)(Isolate*)

Definition at line 257 of file v8-callbacks.h.

◆ CallCompletedCallback

using CallCompletedCallback = void (*)(Isolate*)

Definition at line 258 of file v8-callbacks.h.

◆ CFunctionBuilder

using CFunctionBuilder = internal::CFunctionBuilder

Definition at line 936 of file v8-fast-api-calls.h.

◆ CompileHintCallback

using CompileHintCallback = bool (*)(int, void*)

Callback for requesting a compile hint for a function from the embedder. The first parameter is the position of the function in source code and the second parameter is embedder data to be passed back.

Definition at line 380 of file v8-callbacks.h.

◆ CounterLookupCallback

using CounterLookupCallback = int* (*)(const char* name)

Callback function passed to SetUnhandledExceptionCallback.

Definition at line 214 of file v8-callbacks.h.

◆ CreateHistogramCallback

using CreateHistogramCallback = void* (*)(const char* name, int min, int max, size_t buckets)

Definition at line 216 of file v8-callbacks.h.

◆ DcheckErrorCallback

using DcheckErrorCallback = void (*)(const char* file, int line, const char* message)

Definition at line 52 of file v8-initialization.h.

◆ EntropySource

using EntropySource = bool (*)(unsigned char* buffer, size_t length)

EntropySource is used as a callback function when v8 needs a source of entropy.

Definition at line 34 of file v8-initialization.h.

◆ ExtensionCallback

using ExtensionCallback = bool (*)(const FunctionCallbackInfo<Value>&)

Definition at line 307 of file v8-callbacks.h.

◆ FailedAccessCheckCallback

using FailedAccessCheckCallback = void (*)(Local<Object> target, AccessType type, Local<Value> data)

Definition at line 291 of file v8-callbacks.h.

◆ FatalErrorCallback

using FatalErrorCallback = void (*)(const char* location, const char* message)

Definition at line 223 of file v8-callbacks.h.

◆ FunctionCallback

using FunctionCallback = void (*)(const FunctionCallbackInfo<Value>& info)

Definition at line 289 of file v8-function-callback.h.

◆ GCCallback

using GCCallback = void (*)(GCType type, GCCallbackFlags flags)

Definition at line 190 of file v8-callbacks.h.

◆ GenericNamedPropertyDefinerCallback

using GenericNamedPropertyDefinerCallback = void (*)(Local<Name> property, const PropertyDescriptor& desc, const PropertyCallbackInfo<Value>& info)

Definition at line 339 of file v8-template.h.

◆ GenericNamedPropertyDeleterCallback

using GenericNamedPropertyDeleterCallback = void (*)(Local<Name> property, const PropertyCallbackInfo<Boolean>& info)

Definition at line 295 of file v8-template.h.

◆ GenericNamedPropertyDescriptorCallback

using GenericNamedPropertyDescriptorCallback = void (*)(Local<Name> property, const PropertyCallbackInfo<Value>& info)

Definition at line 374 of file v8-template.h.

◆ GenericNamedPropertyEnumeratorCallback

using GenericNamedPropertyEnumeratorCallback = NamedPropertyEnumeratorCallback

Definition at line 308 of file v8-template.h.

◆ GenericNamedPropertyGetterCallback

using GenericNamedPropertyGetterCallback = void (*)(Local<Name> property, const PropertyCallbackInfo<Value>& info)

Definition at line 190 of file v8-template.h.

◆ GenericNamedPropertyQueryCallback

using GenericNamedPropertyQueryCallback = void (*)(Local<Name> property, const PropertyCallbackInfo<Integer>& info)

Definition at line 259 of file v8-template.h.

◆ GenericNamedPropertySetterCallback

using GenericNamedPropertySetterCallback = void (*)(Local<Name> property, Local<Value> value, const PropertyCallbackInfo<Value>& info)

Definition at line 222 of file v8-template.h.

◆ Handle

template<class T >
using Handle = Local<T>

Definition at line 602 of file v8-local-handle.h.

◆ HostCreateShadowRealmContextCallback

using HostCreateShadowRealmContextCallback = MaybeLocal<Context> (*)(Local<Context> initiator_context)

HostCreateShadowRealmContextCallback is called each time a ShadowRealm is being constructed in the initiator_context.

The method combines Context creation and implementation defined abstract operation HostInitializeShadowRealm into one.

The embedder should use v8::Context::New or v8::Context:NewFromSnapshot to create a new context. If the creation fails, the embedder must propagate that exception by returning an empty MaybeLocal.

Definition at line 407 of file v8-callbacks.h.

◆ HostImportModuleDynamicallyCallback

using HostImportModuleDynamicallyCallback = MaybeLocal<Promise> (*)( Local<Context> context, Local<Data> host_defined_options, Local<Value> resource_name, Local<String> specifier, Local<FixedArray> import_attributes)

HostImportModuleDynamicallyCallback is called when we require the embedder to load a module. This is used as part of the dynamic import syntax.

The referrer contains metadata about the script/module that calls import.

The specifier is the name of the module that should be imported.

The import_attributes are import attributes for this request in the form: [key1, value1, key2, value2, ...] where the keys and values are of type v8::String. Note, unlike the FixedArray passed to ResolveModuleCallback and returned from ModuleRequest::GetImportAssertions(), this array does not contain the source Locations of the attributes.

The embedder must compile, instantiate, evaluate the Module, and obtain its namespace object.

The Promise returned from this function is forwarded to userland JavaScript. The embedder must resolve this promise with the module namespace object. In case of an exception, the embedder must reject this promise with the exception. If the promise creation itself fails (e.g. due to stack overflow), the embedder must propagate that exception by returning an empty MaybeLocal.

Definition at line 370 of file v8-callbacks.h.

◆ HostInitializeImportMetaObjectCallback

using HostInitializeImportMetaObjectCallback = void (*)(Local<Context> context, Local<Module> module, Local<Object> meta)

HostInitializeImportMetaObjectCallback is called the first time import.meta is accessed for a module. Subsequent access will reuse the same value.

The method combines two implementation-defined abstract operations into one: HostGetImportMetaProperties and HostFinalizeImportMeta.

The embedder should use v8::Object::CreateDataProperty to add properties on the meta object.

Definition at line 392 of file v8-callbacks.h.

◆ IndexedPropertyDefinerCallback

using IndexedPropertyDefinerCallback = void (*)(uint32_t index, const PropertyDescriptor& desc, const PropertyCallbackInfo<Value>& info)

Definition at line 434 of file v8-template.h.

◆ IndexedPropertyDefinerCallbackV2

using IndexedPropertyDefinerCallbackV2 = Intercepted (*)(uint32_t index, const PropertyDescriptor& desc, const PropertyCallbackInfo<void>& info)

See v8::GenericNamedPropertyDefinerCallback.

Definition at line 430 of file v8-template.h.

◆ IndexedPropertyDeleterCallback

using IndexedPropertyDeleterCallback = void (*)(uint32_t index, const PropertyCallbackInfo<Boolean>& info)

Definition at line 415 of file v8-template.h.

◆ IndexedPropertyDeleterCallbackV2

using IndexedPropertyDeleterCallbackV2 = Intercepted (*)(uint32_t index, const PropertyCallbackInfo<Boolean>& info)

See v8::GenericNamedPropertyDeleterCallback.

Definition at line 412 of file v8-template.h.

◆ IndexedPropertyDescriptorCallback

using IndexedPropertyDescriptorCallback = void (*)(uint32_t index, const PropertyCallbackInfo<Value>& info)

Definition at line 444 of file v8-template.h.

◆ IndexedPropertyDescriptorCallbackV2

using IndexedPropertyDescriptorCallbackV2 = Intercepted (*)(uint32_t index, const PropertyCallbackInfo<Value>& info)

See v8::GenericNamedPropertyDescriptorCallback.

Definition at line 441 of file v8-template.h.

◆ IndexedPropertyEnumeratorCallback

using IndexedPropertyEnumeratorCallback = void (*)(const PropertyCallbackInfo<Array>& info)

Returns an array containing the indices of the properties the indexed property getter intercepts.

Note: The values in the array must be uint32_t.

Definition at line 424 of file v8-template.h.

◆ IndexedPropertyGetterCallback

using IndexedPropertyGetterCallback = void (*)(uint32_t index, const PropertyCallbackInfo<Value>& info)

Definition at line 387 of file v8-template.h.

◆ IndexedPropertyGetterCallbackV2

using IndexedPropertyGetterCallbackV2 = Intercepted (*)(uint32_t index, const PropertyCallbackInfo<Value>& info)

See v8::GenericNamedPropertyGetterCallback.

Definition at line 384 of file v8-template.h.

◆ IndexedPropertyQueryCallback

using IndexedPropertyQueryCallback = void (*)(uint32_t index, const PropertyCallbackInfo<Integer>& info)

Definition at line 406 of file v8-template.h.

◆ IndexedPropertyQueryCallbackV2

using IndexedPropertyQueryCallbackV2 = Intercepted (*)(uint32_t index, const PropertyCallbackInfo<Integer>& info)

See v8::GenericNamedPropertyQueryCallback.

Definition at line 403 of file v8-template.h.

◆ IndexedPropertySetterCallback

using IndexedPropertySetterCallback = void (*)(uint32_t index, Local<Value> value, const PropertyCallbackInfo<Value>& info)

Definition at line 396 of file v8-template.h.

◆ IndexedPropertySetterCallbackV2

using IndexedPropertySetterCallbackV2 = Intercepted (*)( uint32_t index, Local<Value> value, const PropertyCallbackInfo<void>& info)

See v8::GenericNamedPropertySetterCallback.

Definition at line 393 of file v8-template.h.

◆ InterruptCallback

using InterruptCallback = void (*)(Isolate* isolate, void* data)

Definition at line 192 of file v8-callbacks.h.

◆ JavaScriptCompileHintsMagicEnabledCallback

using JavaScriptCompileHintsMagicEnabledCallback = bool (*)(Local<Context> context)

Definition at line 338 of file v8-callbacks.h.

◆ JitCodeEventHandler

using JitCodeEventHandler = void (*)(const JitCodeEvent* event)

Callback function passed to SetJitCodeEventHandler.

Parameters
eventcode add, move or removal event.

Definition at line 140 of file v8-callbacks.h.

◆ LogEventCallback

using LogEventCallback = void (*)(const char* name, int status)

Definition at line 238 of file v8-callbacks.h.

◆ MessageCallback

using MessageCallback = void (*)(Local<Message> message, Local<Value> data)

Definition at line 233 of file v8-callbacks.h.

◆ MicrotaskCallback

using MicrotaskCallback = void (*)(void* data)

Definition at line 14 of file v8-microtask.h.

◆ MicrotasksCompletedCallbackWithData

using MicrotasksCompletedCallbackWithData = void (*)(Isolate*, void*)

Definition at line 13 of file v8-microtask.h.

◆ ModifyCodeGenerationFromStringsCallback

using ModifyCodeGenerationFromStringsCallback = ModifyCodeGenerationFromStringsResult (*)(Local<Context> context, Local<Value> source)

Callback to check if codegen is allowed from a source object, and convert the source to string if necessary. See: ModifyCodeGenerationFromStrings.

Definition at line 298 of file v8-callbacks.h.

◆ ModifyCodeGenerationFromStringsCallback2

using ModifyCodeGenerationFromStringsCallback2 = ModifyCodeGenerationFromStringsResult (*)(Local<Context> context, Local<Value> source, bool is_code_like)

Definition at line 301 of file v8-callbacks.h.

◆ NamedPropertyDefinerCallback

using NamedPropertyDefinerCallback = Intercepted (*)(Local<Name> property, const PropertyDescriptor& desc, const PropertyCallbackInfo<void>& info)

Interceptor for defineProperty requests on an object.

If the interceptor handles the request (i.e. the property should not be looked up beyond the interceptor) it should return Intercepted::kYes. If the interceptor does not handle the request it must return Intercepted::kNo and it must not produce side effects.

Parameters
propertyThe name of the property for which the request was intercepted.
descThe property descriptor which is used to define the property if the request is not intercepted.
infoInformation about the intercepted request, such as isolate, receiver, return value, or whether running in ‘'use strict’mode. SeePropertyCallbackInfo`.

See also ObjectTemplate::SetHandler.

Definition at line 328 of file v8-template.h.

◆ NamedPropertyDeleterCallback

using NamedPropertyDeleterCallback = Intercepted (*)( Local<Name> property, const PropertyCallbackInfo<Boolean>& info)

Interceptor for delete requests on an object.

If the interceptor handles the request (i.e. the property should not be looked up beyond the interceptor) it should

  • use info.GetReturnValue().Set() to set to a Boolean value indicating whether the property deletion was successful or not,
  • return Intercepted::kYes. If the interceptor does not handle the request it must return Intercepted::kNo and it must not produce side effects.
Parameters
propertyThe name of the property for which the request was intercepted.
infoInformation about the intercepted request, such as isolate, receiver, return value, or whether running in ‘'use strict’mode. SeePropertyCallbackInfo`.
Note
If you need to mimic the behavior of delete, i.e., throw in strict mode instead of returning false, use info.ShouldThrowOnError() to determine if you are in strict mode.

See also ObjectTemplate::SetHandler.

Definition at line 285 of file v8-template.h.

◆ NamedPropertyDescriptorCallback

using NamedPropertyDescriptorCallback = Intercepted (*)( Local<Name> property, const PropertyCallbackInfo<Value>& info)

Interceptor for getOwnPropertyDescriptor requests on an object.

If the interceptor handles the request (i.e. the property should not be looked up beyond the interceptor) it should

  • use info.GetReturnValue().Set() to set the return value which must be object that can be converted to a PropertyDescriptor (for example, a value returned by v8::Object::getOwnPropertyDescriptor),
  • return Intercepted::kYes. If the interceptor does not handle the request it must return Intercepted::kNo and it must not produce side effects.
Parameters
propertyThe name of the property for which the request was intercepted. \info Information about the intercepted request, such as isolate, receiver, return value, or whether running in ‘'use strict’mode. SeePropertyCallbackInfo`.
Note
If GetOwnPropertyDescriptor is intercepted, it will always return true, i.e., indicate that the property was found.

See also ObjectTemplate::SetHandler.

Definition at line 366 of file v8-template.h.

◆ NamedPropertyEnumeratorCallback

using NamedPropertyEnumeratorCallback = void (*)(const PropertyCallbackInfo<Array>& info)

Returns an array containing the names of the properties the named property getter intercepts.

Note: The values in the array must be of type v8::Name.

Definition at line 304 of file v8-template.h.

◆ NamedPropertyGetterCallback

using NamedPropertyGetterCallback = Intercepted (*)( Local<Name> property, const PropertyCallbackInfo<Value>& info)

Interceptor for get requests on an object.

If the interceptor handles the request (i.e. the property should not be looked up beyond the interceptor) it should

  • (optionally) use info.GetReturnValue().Set()to set the return value (by default the result is set to v8::Undefined),
  • returnIntercepted::kYes. If the interceptor does not handle the request it must return Intercepted::kNo` and it must not produce side effects.
Parameters
propertyThe name of the property for which the request was intercepted.
infoInformation about the intercepted request, such as isolate, receiver, return value, or whether running in ‘'use strict’mode. SeePropertyCallbackInfo`.
Intercepted GetterCallback(
Local<Name> name, const v8::PropertyCallbackInfo<v8::Value>& info) {
if (!IsKnownProperty(info.GetIsolate(), name)) return Intercepted::kNo;
info.GetReturnValue().Set(v8_num(42));
return Intercepted::kYes;
}
v8::Local<v8::FunctionTemplate> templ =
v8::FunctionTemplate::New(isolate);
templ->InstanceTemplate()->SetHandler(
v8::NamedPropertyHandlerConfiguration(GetterCallback));
LocalContext env;
env->Global()
->Set(env.local(), v8_str("obj"), templ->GetFunction(env.local())
.ToLocalChecked()
->NewInstance(env.local())
.ToLocalChecked())
.FromJust();
v8::Local<v8::Value> result = CompileRun("obj.a = 17; obj.a");
CHECK(v8_num(42)->Equals(env.local(), result).FromJust());
v8::Local::Global
friend class Global
Definition v8-local-handle.h:358
v8::PropertyCallbackInfo::GetReturnValue
V8_INLINE ReturnValue< T > GetReturnValue() const
Definition v8-function-callback.h:590
v8::PropertyCallbackInfo::GetIsolate
V8_INLINE Isolate * GetIsolate() const
Definition v8-function-callback.h:570
v8::Intercepted
Intercepted
Definition v8-template.h:139

See also ObjectTemplate::SetHandler.

Definition at line 183 of file v8-template.h.

◆ NamedPropertyQueryCallback

using NamedPropertyQueryCallback = Intercepted (*)( Local<Name> property, const PropertyCallbackInfo<Integer>& info)

Intercepts all requests that query the attributes of the property, e.g., getOwnPropertyDescriptor(), propertyIsEnumerable(), and defineProperty().

If the interceptor handles the request (i.e. the property should not be looked up beyond the interceptor) it should

Parameters
propertyThe name of the property for which the request was intercepted.
infoInformation about the intercepted request, such as isolate, receiver, return value, or whether running in ‘'use strict’mode. SeePropertyCallbackInfo`.
Note
Some functions query the property attributes internally, even though they do not return the attributes. For example, hasOwnProperty() can trigger this interceptor depending on the state of the object.

See also ObjectTemplate::SetHandler.

Definition at line 251 of file v8-template.h.

◆ NamedPropertySetterCallback

using NamedPropertySetterCallback = Intercepted (*)(Local<Name> property, Local<Value> value, const PropertyCallbackInfo<void>& info)

Interceptor for set requests on an object.

If the interceptor handles the request (i.e. the property should not be looked up beyond the interceptor) it should return Intercepted::kYes. If the interceptor does not handle the request it must return Intercepted::kNo and it must not produce side effects.

Parameters
propertyThe name of the property for which the request was intercepted.
valueThe value which the property will have if the request is not intercepted.
infoInformation about the intercepted request, such as isolate, receiver, return value, or whether running in ‘'use strict’mode. SeePropertyCallbackInfo`.

See also ObjectTemplate::SetHandler.

Definition at line 211 of file v8-template.h.

◆ NativeObject

using NativeObject = void*

Definition at line 30 of file v8-profiler.h.

◆ NearHeapLimitCallback

using NearHeapLimitCallback = size_t (*)(void* data, size_t current_heap_limit, size_t initial_heap_limit)

This callback is invoked when the heap size is close to the heap limit and V8 is likely to abort with out-of-memory error. The callback can extend the heap limit by returning a value that is greater than the current_heap_limit. The initial heap limit is the limit that was set after heap setup.

Definition at line 201 of file v8-callbacks.h.

◆ OOMErrorCallback

using OOMErrorCallback = void (*)(const char* location, const OOMDetails& details)

Definition at line 230 of file v8-callbacks.h.

◆ PersistentContainerValue

typedef uintptr_t PersistentContainerValue

Definition at line 28 of file v8-util.h.

◆ PlatformSharedMemoryHandle

using PlatformSharedMemoryHandle = intptr_t

Definition at line 651 of file v8-platform.h.

◆ PrepareStackTraceCallback

using PrepareStackTraceCallback = MaybeLocal<Value> (*)(Local<Context> context, Local<Value> error, Local<Array> sites)

PrepareStackTraceCallback is called when the stack property of an error is first accessed. The return value will be used as the stack value. If this callback is registed, the |Error.prepareStackTrace| API will be disabled. |sites| is an array of call sites, specified in https://v8.dev/docs/stack-trace-api

Definition at line 417 of file v8-callbacks.h.

◆ ProfilerId

using ProfilerId = uint32_t

Definition at line 32 of file v8-profiler.h.

◆ PromiseHook

using PromiseHook = void (*)(PromiseHookType type, Local<Promise> promise, Local<Value> parent)

Definition at line 143 of file v8-promise.h.

◆ PromiseRejectCallback

using PromiseRejectCallback = void (*)(PromiseRejectMessage message)

Definition at line 170 of file v8-promise.h.

◆ ReturnAddressLocationResolver

using ReturnAddressLocationResolver = uintptr_t (*)(uintptr_t return_addr_location)

ReturnAddressLocationResolver is used as a callback function when v8 is resolving the location of a return address on the stack. Profilers that change the return address on the stack can use this to resolve the stack location to wherever the profiler stashed the original return address.

Parameters
return_addr_locationA location on stack where a machine return address resides.
Returns
Either return_addr_location, or else a pointer to the profiler's copy of the original return address.
Note
The resolver function must not cause garbage collection.

Definition at line 49 of file v8-initialization.h.

◆ SharedArrayBufferConstructorEnabledCallback

using SharedArrayBufferConstructorEnabledCallback = bool (*)(Local<Context> context)

Definition at line 334 of file v8-callbacks.h.

◆ SnapshotObjectId

using SnapshotObjectId = uint32_t

Definition at line 31 of file v8-profiler.h.

◆ StackState

using StackState = cppgc::EmbedderStackState

Indicator for the stack state.

Definition at line 200 of file v8-isolate.h.

◆ UniquePersistent

template<class T >
using UniquePersistent = Global<T>

Definition at line 430 of file v8-persistent-handle.h.

◆ WasmAsyncResolvePromiseCallback

using WasmAsyncResolvePromiseCallback = void (*)( Isolate* isolate, Local<Context> context, Local<Promise::Resolver> resolver, Local<Value> result, WasmAsyncSuccess success)

Definition at line 322 of file v8-callbacks.h.

◆ WasmImportedStringsEnabledCallback

using WasmImportedStringsEnabledCallback = bool (*)(Local<Context> context)

Definition at line 331 of file v8-callbacks.h.

◆ WasmJSPIEnabledCallback

using WasmJSPIEnabledCallback = bool (*)(Local<Context> context)

Definition at line 342 of file v8-callbacks.h.

◆ WasmLoadSourceMapCallback

using WasmLoadSourceMapCallback = Local<String> (*)(Isolate* isolate, const char* name)

Definition at line 327 of file v8-callbacks.h.

◆ WasmStreamingCallback

using WasmStreamingCallback = void (*)(const FunctionCallbackInfo<Value>&)

Definition at line 317 of file v8-callbacks.h.

Enumeration Type Documentation

◆ AccessControl

enum AccessControl

Access control specifications.

Some accessors should be accessible across contexts. These accessors have an explicit access control parameter which specifies the kind of cross-context access that should be allowed.

Enumerator
DEFAULT 

Definition at line 173 of file v8-object.h.

◆ AccessType

enum AccessType

Access type specification.

Enumerator
ACCESS_GET 
ACCESS_SET 
ACCESS_HAS 
ACCESS_DELETE 
ACCESS_KEYS 

Definition at line 281 of file v8-callbacks.h.

◆ ArrayBufferCreationMode

enum class ArrayBufferCreationMode
strong
Enumerator
kInternalized 
kExternalized 

Definition at line 25 of file v8-array-buffer.h.

◆ BlockingType

enum class BlockingType
strong

A "blocking call" refers to any call that causes the calling thread to wait off-CPU. It includes but is not limited to calls that wait on synchronous file I/O operations: read or write a file from disk, interact with a pipe or a socket, rename or delete a file, enumerate files in a directory, etc. Acquiring a low contention lock is not considered a blocking call. BlockingType indicates the likelihood that a blocking call will actually block.

Enumerator
kMayBlock 
kWillBlock 

Definition at line 327 of file v8-platform.h.

◆ CodeEventType

enum CodeEventType

Note that this enum may be extended in the future. Please include a default case if this enum is used in a switch statement.

Enumerator
kUnknownType 

Definition at line 1226 of file v8-profiler.h.

◆ ConstructorBehavior

enum class ConstructorBehavior
strong
Enumerator
kThrow 
kAllow 

Definition at line 455 of file v8-template.h.

◆ CpuProfilingLoggingMode

enum CpuProfilingLoggingMode
Enumerator
kLazyLogging 
kEagerLogging 

Definition at line 308 of file v8-profiler.h.

◆ CpuProfilingMode

enum CpuProfilingMode
Enumerator
kLeafNodeLineNumbers 
kCallerLineNumbers 

Definition at line 289 of file v8-profiler.h.

◆ CpuProfilingNamingMode

enum CpuProfilingNamingMode
Enumerator
kStandardNaming 
kDebugNaming 

Definition at line 300 of file v8-profiler.h.

◆ CpuProfilingStatus

enum class CpuProfilingStatus
strong
Enumerator
kStarted 
kAlreadyStarted 
kErrorTooManyProfilers 

Definition at line 320 of file v8-profiler.h.

◆ CrashKeyId

enum class CrashKeyId
strong
Enumerator
kIsolateAddress 
kReadonlySpaceFirstPageAddress 
V8_ENUM_DEPRECATE_SOON 
kOldSpaceFirstPageAddress 
kCodeRangeBaseAddress 
kCodeSpaceFirstPageAddress 
kDumpType 
kSnapshotChecksumCalculated 
kSnapshotChecksumExpected 

Definition at line 242 of file v8-callbacks.h.

◆ EmbedderStateTag

enum class EmbedderStateTag : uint8_t
strong
Enumerator
EMPTY 
OTHER 

Definition at line 22 of file v8-embedder-state-scope.h.

◆ GCCallbackFlags

enum GCCallbackFlags

GCCallbackFlags is used to notify additional information about the GC callback.

  • kGCCallbackFlagConstructRetainedObjectInfos: The GC callback is for constructing retained object infos.
  • kGCCallbackFlagForced: The GC callback is for a forced GC for testing.
  • kGCCallbackFlagSynchronousPhantomCallbackProcessing: The GC callback is called synchronously without getting posted to an idle task.
  • kGCCallbackFlagCollectAllAvailableGarbage: The GC callback is called in a phase where V8 is trying to collect all available garbage (e.g., handling a low memory notification).
  • kGCCallbackScheduleIdleGarbageCollection: The GC callback is called to trigger an idle garbage collection.
Enumerator
kNoGCCallbackFlags 
kGCCallbackFlagConstructRetainedObjectInfos 
kGCCallbackFlagForced 
kGCCallbackFlagSynchronousPhantomCallbackProcessing 
kGCCallbackFlagCollectAllAvailableGarbage 
kGCCallbackFlagCollectAllExternalMemory 
kGCCallbackScheduleIdleGarbageCollection 

Definition at line 180 of file v8-callbacks.h.

◆ GCType

enum GCType

Applications can register callback functions which will be called before and after certain garbage collection operations. Allocations are not allowed in the callback functions, you therefore cannot manipulate objects (set or delete properties for example) since it is possible such operations will result in the allocation of objects. TODO(v8:12612): Deprecate kGCTypeMinorMarkSweep after updating blink.

Enumerator
kGCTypeScavenge 
kGCTypeMinorMarkSweep 
V8_DEPRECATE_SOON 
kGCTypeMarkSweepCompact 
kGCTypeIncrementalMarking 
kGCTypeProcessWeakCallbacks 
kGCTypeAll 

Definition at line 152 of file v8-callbacks.h.

◆ IndexFilter

enum class IndexFilter
strong

kIncludesIndices allows for integer indices to be collected, while kSkipIndices will exclude integer indices from being collected.

Enumerator
kIncludeIndices 
kSkipIndices 

Definition at line 218 of file v8-object.h.

◆ IntegrityLevel

enum class IntegrityLevel
strong

Integrity level for objects.

Enumerator
kFrozen 
kSealed 

Definition at line 229 of file v8-object.h.

◆ Intercepted

enum class Intercepted : uint8_t
strong

Interceptor callbacks use this value to indicate whether the request was intercepted or not.

Enumerator
kNo 
kYes 

Definition at line 139 of file v8-template.h.

◆ Intrinsic

enum Intrinsic

Definition at line 40 of file v8-template.h.

◆ JitCodeEventOptions

enum JitCodeEventOptions

Option flags passed to the SetJitCodeEventHandler function.

Enumerator
kJitCodeEventDefault 
kJitCodeEventEnumExisting 

Definition at line 129 of file v8-callbacks.h.

◆ KeyCollectionMode

enum class KeyCollectionMode
strong

Keys/Properties filter enums:

KeyCollectionMode limits the range of collected properties. kOwnOnly limits the collected properties to the given Object only. kIncludesPrototypes will include all keys of the objects's prototype chain as well.

Enumerator
kOwnOnly 
kIncludePrototypes 

Definition at line 212 of file v8-object.h.

◆ KeyConversionMode

enum class KeyConversionMode
strong

kConvertToString will convert integer indices to strings. kKeepNumbers will return numbers for integer indices.

Enumerator
kConvertToString 
kKeepNumbers 
kNoNumbers 

Definition at line 224 of file v8-object.h.

◆ LogEventStatus

enum LogEventStatus : int
Enumerator
kStart 
kEnd 
kStamp 

Definition at line 237 of file v8-callbacks.h.

◆ MeasureMemoryExecution

enum class MeasureMemoryExecution
strong

Controls how promptly a memory measurement request is executed. By default the measurement is folded with the next scheduled GC which may happen after a while and is forced after some timeout. The kEager mode starts incremental GC right away and is useful for testing. The kLazy mode does not force GC.

Enumerator
kDefault 
kEager 
kLazy 

Definition at line 43 of file v8-statistics.h.

◆ MeasureMemoryMode

enum class MeasureMemoryMode
strong

Controls how the default MeasureMemoryDelegate reports the result of the memory measurement to JS. With kSummary only the total size is reported. With kDetailed the result includes the size of each native context.

Enumerator
kSummary 
kDetailed 

Definition at line 34 of file v8-statistics.h.

◆ MemoryPressureLevel

enum class MemoryPressureLevel
strong

Memory pressure level for the MemoryPressureNotification. kNone hints V8 that there is no memory pressure. kModerate hints V8 to speed up incremental garbage collection at the cost of of higher latency due to garbage collection pauses. kCritical hints V8 to free memory as soon as possible. Garbage collection pauses at this level will be large.

Enumerator
kNone 
kModerate 
kCritical 

Definition at line 195 of file v8-isolate.h.

◆ MicrotasksPolicy

enum class MicrotasksPolicy
strong

Policy for running microtasks:

Enumerator
kExplicit 
kScoped 
kAuto 

Definition at line 24 of file v8-microtask.h.

◆ NewStringType

enum class NewStringType
strong

A flag describing different modes of string creation.

Aside from performance implications there are no differences between the two creation modes.

Enumerator
kNormal 

Create a new string, always allocating new storage memory.

kInternalized 

Acts as a hint that the string should be created in the old generation heap space and be deduplicated if an identical string already exists.

Definition at line 107 of file v8-primitive.h.

◆ PagePermissions

enum class PagePermissions
strong

Possible permissions for memory pages.

Enumerator
kNoAccess 
kRead 
kReadWrite 
kReadWriteExecute 
kReadExecute 

Definition at line 704 of file v8-platform.h.

◆ PersistentContainerCallbackType

enum PersistentContainerCallbackType
Enumerator
kNotWeak 
kWeakWithParameter 
kWeakWithInternalFields 

Definition at line 30 of file v8-util.h.

◆ PromiseHookType

enum class PromiseHookType
strong

PromiseHook with type kInit is called when a new promise is created. When a new promise is created as part of the chain in the case of Promise.then or in the intermediate promises created by Promise.{race, all}/AsyncFunctionAwait, we pass the parent promise otherwise we pass undefined.

PromiseHook with type kResolve is called at the beginning of resolve or reject function defined by CreateResolvingFunctions.

PromiseHook with type kBefore is called at the beginning of the PromiseReactionJob.

PromiseHook with type kAfter is called right at the end of the PromiseReactionJob.

Enumerator
kInit 
kResolve 
kBefore 
kAfter 

Definition at line 141 of file v8-promise.h.

◆ PromiseRejectEvent

enum PromiseRejectEvent
Enumerator
kPromiseRejectWithNoHandler 
kPromiseHandlerAddedAfterReject 
kPromiseRejectAfterResolved 
kPromiseResolveAfterResolved 

Definition at line 147 of file v8-promise.h.

◆ PropertyAttribute

enum PropertyAttribute

PropertyAttribute.

Enumerator
None 

None.

ReadOnly 

ReadOnly, i.e., not writable.

DontEnum 

DontEnum, i.e., not enumerable.

DontDelete 

DontDelete, i.e., not configurable.

Definition at line 137 of file v8-object.h.

◆ PropertyFilter

enum PropertyFilter

Property filter bits. They can be or'ed to build a composite filter.

Enumerator
ALL_PROPERTIES 
ONLY_WRITABLE 
ONLY_ENUMERABLE 
ONLY_CONFIGURABLE 
SKIP_STRINGS 
SKIP_SYMBOLS 

Definition at line 180 of file v8-object.h.

◆ PropertyHandlerFlags

enum class PropertyHandlerFlags
strong

Configuration flags for v8::NamedPropertyHandlerConfiguration or v8::IndexedPropertyHandlerConfiguration.

Enumerator
kNone 

None.

kNonMasking 

Will not call into interceptor for properties on the receiver or prototype chain, i.e., only call into interceptor for properties that do not exist. Currently only valid for named interceptors.

kOnlyInterceptStrings 

Will not call into interceptor for symbol lookup. Only meaningful for named interceptors.

kHasNoSideEffect 

The getter, query, enumerator callbacks do not produce side effects.

kInternalNewCallbacksSignatures 

This flag is used to distinguish which callbacks were provided - GenericNamedPropertyXXXCallback (old signature) or NamedPropertyXXXCallback (new signature). DO NOT use this flag, it'll be removed once embedders migrate to new callbacks signatures.

Definition at line 700 of file v8-template.h.

◆ RAILMode

enum RAILMode : unsigned

Option flags passed to the SetRAILMode function. See documentation https://developers.google.com/web/tools/chrome-devtools/ profile/evaluate-performance/rail

Enumerator
PERFORMANCE_RESPONSE 
PERFORMANCE_ANIMATION 
PERFORMANCE_IDLE 
PERFORMANCE_LOAD 

Definition at line 170 of file v8-isolate.h.

◆ ScriptType

enum class ScriptType
strong
Enumerator
kClassic 
kModule 

Definition at line 365 of file v8-script.h.

◆ SideEffectType

enum class SideEffectType
strong

Options for marking whether callbacks may trigger JS-observable side effects. Side-effect-free callbacks are allowlisted during debug evaluation with throwOnSideEffect. It applies when calling a Function, FunctionTemplate, or an Accessor callback. For Interceptors, please see PropertyHandlerFlags's kHasNoSideEffect. Callbacks that only cause side effects to the receiver are allowlisted if invoked on receiver objects that are created within the same debug-evaluate call, as these objects are temporary and the side effect does not escape.

Enumerator
kHasSideEffect 
kHasNoSideEffect 
kHasSideEffectToReceiver 

Definition at line 199 of file v8-object.h.

◆ StateTag

enum StateTag : uint16_t
Enumerator
JS 
GC 
PARSER 
BYTECODE_COMPILER 
COMPILER 
OTHER 
EXTERNAL 
ATOMICS_WAIT 
IDLE 

Definition at line 36 of file v8-unwinder.h.

◆ TaskPriority

enum class TaskPriority : uint8_t
strong
Enumerator
kBestEffort 

Best effort tasks are not critical for performance of the application. The platform implementation should preempt such tasks if higher priority tasks arrive.

kUserVisible 

User visible tasks are long running background tasks that will improve performance and memory usage of the application upon completion. Example: background compilation and garbage collection.

kUserBlocking 

User blocking tasks are highest priority tasks that block the execution thread (e.g. major garbage collection). They must be finished as soon as possible.

kMaxPriority 

Definition at line 24 of file v8-platform.h.

◆ WasmAsyncSuccess

enum class WasmAsyncSuccess
strong
Enumerator
kSuccess 
kFail 

Definition at line 319 of file v8-callbacks.h.

◆ WeakCallbackType

enum class WeakCallbackType
strong

Weakness type for weak handles.

Enumerator
kParameter 

Passes a user-defined void* parameter back to the callback.

kInternalFields 

Passes the first two internal fields of the object back to the callback.

Definition at line 57 of file v8-weak-callback-info.h.

Function Documentation

◆ CurrentValueSerializerFormatVersion()

constexpr uint32_t CurrentValueSerializerFormatVersion ( )
constexpr

Definition at line 20 of file v8-value-serializer-version.h.

◆ False()

V8_INLINE Local< Boolean > False ( Isolate *  isolate)

Definition at line 863 of file v8-primitive.h.

Referenced by Boolean::New().

◆ FileDescriptorFromSharedMemoryHandle()

int FileDescriptorFromSharedMemoryHandle ( PlatformSharedMemoryHandle  handle)
inline

Definition at line 695 of file v8-platform.h.

◆ Just() [1/2]

template<class T >
Maybe< T > Just ( const T &  t)
inline

Definition at line 116 of file v8-maybe.h.

◆ Just() [2/2]

template<class T , std::enable_if_t<!std::is_lvalue_reference_v< T > > * = nullptr>
Maybe< T > Just ( T &&  t)
inline

Definition at line 124 of file v8-maybe.h.

◆ JustVoid()

Maybe< void > JustVoid ( )
inline

Definition at line 156 of file v8-maybe.h.

◆ Nothing()

template<class T >
Maybe< T > Nothing ( )
inline

Definition at line 111 of file v8-maybe.h.

◆ Null()

V8_INLINE Local< Primitive > Null ( Isolate *  isolate)

Definition at line 847 of file v8-primitive.h.

◆ operator!=() [1/3]

V8_INLINE bool operator!= ( const TracedReferenceBase &  lhs,
const TracedReferenceBase &  rhs 
)

Definition at line 346 of file v8-traced-handle.h.

◆ operator!=() [2/3]

template<typename U >
V8_INLINE bool operator!= ( const TracedReferenceBase &  lhs,
const v8::Local< U > &  rhs 
)

Definition at line 352 of file v8-traced-handle.h.

◆ operator!=() [3/3]

template<typename U >
V8_INLINE bool operator!= ( const v8::Local< U > &  lhs,
const TracedReferenceBase &  rhs 
)

Definition at line 358 of file v8-traced-handle.h.

◆ operator==() [1/3]

V8_INLINE bool operator== ( const TracedReferenceBase &  lhs,
const TracedReferenceBase &  rhs 
)

Definition at line 329 of file v8-traced-handle.h.

◆ operator==() [2/3]

template<typename U >
V8_INLINE bool operator== ( const TracedReferenceBase &  lhs,
const v8::Local< U > &  rhs 
)

Definition at line 335 of file v8-traced-handle.h.

◆ operator==() [3/3]

template<typename U >
V8_INLINE bool operator== ( const v8::Local< U > &  lhs,
const TracedReferenceBase &  rhs 
)

Definition at line 341 of file v8-traced-handle.h.

◆ RegisterExtension()

void V8_EXPORT RegisterExtension ( std::unique_ptr< Extension >  )

◆ SharedMemoryHandleFromFileDescriptor()

PlatformSharedMemoryHandle SharedMemoryHandleFromFileDescriptor ( int  fd)
inline

Definition at line 692 of file v8-platform.h.

◆ to_array() [1/2]

template<class T , std::size_t N>
constexpr std::array< std::remove_cv_t< T >, N > to_array ( T(&&)  a[N])
constexpr

Definition at line 192 of file v8-memory-span.h.

References v8::detail::to_array_rvalue_impl().

◆ to_array() [2/2]

template<class T , std::size_t N>
constexpr std::array< std::remove_cv_t< T >, N > to_array ( T(&)  a[N])
constexpr

Definition at line 187 of file v8-memory-span.h.

References v8::detail::to_array_lvalue_impl().

◆ True()

V8_INLINE Local< Boolean > True ( Isolate *  isolate)

Definition at line 855 of file v8-primitive.h.

Referenced by Boolean::New().

◆ TryHandleWebAssemblyTrapPosix()

V8_EXPORT bool TryHandleWebAssemblyTrapPosix ( int  sig_code,
siginfo_t *  info,
void *  context 
)

This function determines whether a memory access violation has been an out-of-bounds memory access in WebAssembly. If so, it will modify the context parameter and add a return address where the execution can continue after the signal handling, and return true. Otherwise, false will be returned.

The parameters to this function correspond to those passed to a Posix signal handler. Use this function only on Linux and Mac.

Parameters
sig_codeThe signal code, e.g. SIGSEGV.
infoA pointer to the siginfo_t struct provided to the signal handler.
contextA pointer to a ucontext_t struct provided to the signal handler.

◆ TryHandleWebAssemblyTrapWindows()

V8_EXPORT bool TryHandleWebAssemblyTrapWindows ( EXCEPTION_POINTERS *  exception)

This function determines whether a memory access violation has been an out-of-bounds memory access in WebAssembly. If so, it will modify the exception parameter and add a return address where the execution can continue after the exception handling, and return true. Otherwise the return value will be false.

The parameter to this function corresponds to the one passed to a Windows vectored exception handler. Use this function only on Windows.

Parameters
exceptionAn EXCEPTION_POINTERS* as provided to the exception handler.

◆ TryToCopyAndConvertArrayToCppBuffer()

template<CTypeInfo::Identifier type_info_id, typename T >
bool V8_EXPORT V8_WARN_UNUSED_RESULT TryToCopyAndConvertArrayToCppBuffer ( Local< Array >  src,
T *  dst,
uint32_t  max_length 
)

Copies the contents of this JavaScript array to a C++ buffer with a given max_length. A CTypeInfo is passed as an argument, instructing different rules for conversion (e.g. restricted float/double). The element type T of the destination array must match the C type corresponding to the CTypeInfo (specified by CTypeInfoTraits). If the array length is larger than max_length or the array is of unsupported type, the operation will fail, returning false. Generally, an array which contains objects, undefined, null or anything not convertible to the requested destination type, is considered unsupported. The operation returns true on success. type_info will be used for conversions.

◆ Undefined()

V8_INLINE Local< Primitive > Undefined ( Isolate *  isolate)

Definition at line 839 of file v8-primitive.h.

Referenced by ReturnValue< T >::Get(), and FunctionCallbackInfo< T >::operator[]().

◆ V8_DEPRECATE_SOON()

template<typename V , typename Traits = DefaultPersistentValueVectorTraits>
class V8_DEPRECATE_SOON ( "Use std::vector<Global<V>>."  )

A vector wrapper that safely stores Global values. C++11 embedders don't need this class, as they can use Global directly in std containers.

This class relies on a backing vector implementation, whose type and methods are described by the Traits class. The backing map will handle values of type PersistentContainerValue, with all conversion into and out of V8 handles being transparently handled by this class.

Append a value to the vector.

Append a persistent's value to the vector.

Are there any values in the vector?

How many elements are in the vector?

Retrieve the i-th value in the vector.

Remove all elements from the vector.

Reserve capacity in the vector. (Efficiency gains depend on the backing implementation.)

Definition at line 29 of file v8-util.h.

◆ V8_DEPRECATED()

template<class T >
struct V8_DEPRECATED ( "Use v8::Global instead"  )

Helper class traits to allow copying and assignment of Persistent. This will clone the contents of storage cell, but not any of the flags, etc.

Definition at line 1 of file v8-persistent-handle.h.