#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <atomic>
#include <memory>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
#include "cppgc/common.h"
#include "v8-internal.h"
#include "v8-version.h"
#include "v8config.h"

Include dependency graph for v8.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
class	Local< T >

class	MaybeLocal< T >

class	Eternal< T >

class	WeakCallbackInfo< T >

class	PersistentBase< T >

class	NonCopyablePersistentTraits< T >

struct	CopyablePersistentTraits< T >

class	Persistent< T, M >

class	Global< T >

struct	TracedGlobalTrait< T >

class	TracedReferenceBase

class	BasicTracedReference< T >

class	TracedGlobal< T >

class	TracedReference< T >

class	HandleScope

class	EscapableHandleScope

class	SealHandleScope

class	Data

class	ScriptOrModule

class	PrimitiveArray

class	ScriptOriginOptions

class	ScriptOrigin

class	UnboundScript

class	UnboundModuleScript

class	Location

class	FixedArray

class	ModuleRequest

class	Module

class	Script

class	ScriptCompiler

struct	ScriptCompiler::CachedData

class	ScriptCompiler::Source

class	ScriptCompiler::ExternalSourceStream

class	ScriptCompiler::StreamedSource

class	ScriptCompiler::ScriptStreamingTask

class	ScriptCompiler::ConsumeCodeCacheTask

class	Message

class	StackTrace

class	StackFrame

struct	RegisterState

struct	SampleInfo

struct	MemoryRange

struct	JSEntryStub

struct	JSEntryStubs

class	JSON

class	ValueSerializer

class	ValueSerializer::Delegate

class	ValueDeserializer

class	ValueDeserializer::Delegate

class	Value

class	Primitive

class	Boolean

class	Name

class	String

class	String::ExternalStringResourceBase

class	String::ExternalStringResource

class	String::ExternalOneByteStringResource

class	String::Utf8Value

class	String::Value

class	Symbol

class	Private

class	Number

class	Integer

class	Int32

class	Uint32

class	BigInt

class	Object

class	Array

class	Map

class	Set

class	ReturnValue< T >

class	FunctionCallbackInfo< T >

class	PropertyCallbackInfo< T >

class	Function

class	Promise

class	Promise::Resolver

class	PropertyDescriptor

class	Proxy

class	MemorySpan< T >

struct	OwnedBuffer

class	CompiledWasmModule

class	WasmMemoryObject

class	WasmModuleObject

class	WasmStreaming

class	WasmStreaming::Client

class	WasmModuleObjectBuilderStreaming

class	BackingStore

class	ArrayBuffer

class	ArrayBuffer::Allocator

class	ArrayBufferView

class	TypedArray

class	Uint8Array

class	Uint8ClampedArray

class	Int8Array

class	Uint16Array

class	Int16Array

class	Uint32Array

class	Int32Array

class	Float32Array

class	Float64Array

class	BigInt64Array

class	BigUint64Array

class	DataView

class	SharedArrayBuffer

class	Date

class	NumberObject

class	BigIntObject

class	BooleanObject

class	StringObject

class	SymbolObject

class	RegExp

class	External

class	Template

class	FunctionTemplate

struct	NamedPropertyHandlerConfiguration

struct	IndexedPropertyHandlerConfiguration

class	ObjectTemplate

class	Signature

class	AccessorSignature

class	Extension

class	ResourceConstraints

class	Exception

class	PromiseRejectMessage

class	MicrotaskQueue

class	MicrotasksScope

struct	ModifyCodeGenerationFromStringsResult

class	SharedMemoryStatistics

class	HeapStatistics

class	HeapSpaceStatistics

class	HeapObjectStatistics

class	HeapCodeStatistics

struct	JitCodeEvent

struct	JitCodeEvent::name_t

struct	JitCodeEvent::line_info_t

struct	JitCodeEvent::wasm_source_info_t

class	ExternalResourceVisitor

class	PersistentHandleVisitor

class	EmbedderRootsHandler

class	EmbedderHeapTracer

class	EmbedderHeapTracer::TracedGlobalHandleVisitor

struct	EmbedderHeapTracer::TraceSummary

struct	SerializeInternalFieldsCallback

struct	DeserializeInternalFieldsCallback

class	MeasureMemoryDelegate

class	Isolate

struct	Isolate::CreateParams

class	Isolate::Scope

class	Isolate::DisallowJavascriptExecutionScope

class	Isolate::AllowJavascriptExecutionScope

class	Isolate::SuppressMicrotaskExecutionScope

class	Isolate::SafeForTerminationScope

class	Isolate::AtomicsWaitWakeHandle

class	StartupData

class	V8

class	SnapshotCreator

class	Maybe< T >

class	Maybe< void >

class	TryCatch

class	ExtensionConfiguration

class	Context

class	Context::Scope

class	Context::BackupIncumbentScope

class	Unlocker

class	Locker

class	Unwinder

Namespaces
	v8

	v8::internal

	v8::internal::wasm

	v8::metrics

	v8::debug

Macros
#define	V8_PROMISE_INTERNAL_FIELD_COUNT 0

#define	V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT 2

#define	V8_ARRAY_BUFFER_VIEW_INTERNAL_FIELD_COUNT 2

#define	V8_INTRINSICS_LIST(F)

#define	V8_DECL_INTRINSIC(name, iname) k##name,

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

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

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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

using	IndexedPropertyDefinerCallback = void(*)(uint32_t index, const PropertyDescriptor &desc, 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)

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

using	OOMErrorCallback = void()(const char location, bool is_heap_oom)

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

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

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

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	AddCrashKeyCallback = void(*)(CrashKeyId id, const std::string &value)

using	BeforeCallEnteredCallback = void()(Isolate )

using	CallCompletedCallback = void()(Isolate )

using	instead = MaybeLocal< Promise >(*)(Local< Context > context, Local< ScriptOrModule > referrer, Local< String > specifier)

using	HostImportModuleDynamicallyWithImportAssertionsCallback = MaybeLocal< Promise >(*)(Local< Context > context, Local< ScriptOrModule > referrer, Local< String > specifier, Local< FixedArray > import_assertions)

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

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

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

using	PromiseRejectCallback = void(*)(PromiseRejectMessage message)

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

using	MicrotaskCallback = void()(void data)

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

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

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	WasmLoadSourceMapCallback = Local< String >()(Isolate isolate, const char *name)

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

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

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

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	JitCodeEventHandler = void()(const JitCodeEvent event)

using	SerializeEmbedderFieldsCallback = SerializeInternalFieldsCallback

using	DeserializeEmbedderFieldsCallback = DeserializeInternalFieldsCallback

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

using	ReturnAddressLocationResolver = uintptr_t(*)(uintptr_t return_addr_location)

Enumerations
enum class	WeakCallbackType { kParameter , kInternalFields , kFinalizer }

enum class	ScriptType { kClassic , kModule }

enum	StateTag { JS , GC , PARSER , BYTECODE_COMPILER , COMPILER , OTHER , EXTERNAL , ATOMICS_WAIT , IDLE }

enum class	NewStringType { kNormal , kInternalized }

enum	PropertyAttribute { None = 0 , ReadOnly = 1 << 0 , DontEnum = 1 << 1 , DontDelete = 1 << 2 }

enum	AccessControl { DEFAULT = 0 , ALL_CAN_READ = 1 , ALL_CAN_WRITE = 1 << 1 , PROHIBITS_OVERWRITING = 1 << 2 }

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	ConstructorBehavior { kThrow , kAllow }

enum class	ArrayBufferCreationMode { kInternalized , kExternalized }

enum	Intrinsic

enum	AccessType { ACCESS_GET , ACCESS_SET , ACCESS_HAS , ACCESS_DELETE , ACCESS_KEYS }

enum class	PropertyHandlerFlags { kNone = 0 , kAllCanRead = 1 , kNonMasking = 1 << 1 , kOnlyInterceptStrings = 1 << 2 , kHasNoSideEffect = 1 << 3 }

enum	LogEventStatus : int { kStart = 0 , kEnd = 1 , kStamp = 2 }

enum class	CrashKeyId { kIsolateAddress , kReadonlySpaceFirstPageAddress , kMapSpaceFirstPageAddress , kCodeSpaceFirstPageAddress , kDumpType }

enum class	PromiseHookType { kInit , kResolve , kBefore , kAfter }

enum	PromiseRejectEvent { kPromiseRejectWithNoHandler = 0 , kPromiseHandlerAddedAfterReject = 1 , kPromiseRejectAfterResolved = 2 , kPromiseResolveAfterResolved = 3 }

enum class	MicrotasksPolicy { kExplicit , kScoped , kAuto }

enum	GCType { kGCTypeScavenge = 1 << 0 , kGCTypeMarkSweepCompact = 1 << 1 , kGCTypeIncrementalMarking = 1 << 2 , kGCTypeProcessWeakCallbacks = 1 << 3 , kGCTypeAll }

enum	GCCallbackFlags { kNoGCCallbackFlags = 0 , kGCCallbackFlagConstructRetainedObjectInfos = 1 << 1 , kGCCallbackFlagForced = 1 << 2 , kGCCallbackFlagSynchronousPhantomCallbackProcessing = 1 << 3 , kGCCallbackFlagCollectAllAvailableGarbage = 1 << 4 , kGCCallbackFlagCollectAllExternalMemory = 1 << 5 , kGCCallbackScheduleIdleGarbageCollection = 1 << 6 }

enum	RAILMode : unsigned { PERFORMANCE_RESPONSE , PERFORMANCE_ANIMATION , PERFORMANCE_IDLE , PERFORMANCE_LOAD }

enum	JitCodeEventOptions { kJitCodeEventDefault = 0 , kJitCodeEventEnumExisting = 1 }

enum class	MemoryPressureLevel { kNone , kModerate , kCritical }

enum class	MeasureMemoryMode { kSummary , kDetailed }

enum class	MeasureMemoryExecution { kDefault , kEager , kLazy }

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

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)

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

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

Maybe< void >	JustVoid ()

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)

Macro Definition Documentation

◆ V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT

#define V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT 2

Definition at line 5272 of file v8.h.

◆ V8_ARRAY_BUFFER_VIEW_INTERNAL_FIELD_COUNT

#define V8_ARRAY_BUFFER_VIEW_INTERNAL_FIELD_COUNT 2

Definition at line 5520 of file v8.h.

◆ V8_DECL_INTRINSIC

#define V8_DECL_INTRINSIC	(	name,
		iname
	)	k##name,

Definition at line 6080 of file v8.h.

◆ V8_INTRINSICS_LIST

#define V8_INTRINSICS_LIST ( F )

Value:

  F(ArrayProto_entries, array_entries_iterator)               \
  F(ArrayProto_forEach, array_for_each_iterator)              \
  F(ArrayProto_keys, array_keys_iterator)                     \
  F(ArrayProto_values, array_values_iterator)                 \
  F(AsyncIteratorPrototype, initial_async_iterator_prototype) \
  F(ErrorPrototype, initial_error_prototype)                  \
  F(IteratorPrototype, initial_iterator_prototype)            \
  F(ObjProto_valueOf, object_value_of_function)

Definition at line 6069 of file v8.h.

◆ V8_PROMISE_INTERNAL_FIELD_COUNT

#define V8_PROMISE_INTERNAL_FIELD_COUNT 0

Definition at line 4842 of file v8.h.

Data Structures

Namespaces

Macros

Typedefs