v8  5.8.282(node8.0.0)
V8 is Google's open source JavaScript engine
Isolate Class Reference

#include <v8.h>

Data Structures

class  AllowJavascriptExecutionScope
 
struct  CreateParams
 
class  DisallowJavascriptExecutionScope
 
class  Scope
 
class  SuppressMicrotaskExecutionScope
 

Public Types

enum  GarbageCollectionType { kFullGarbageCollection, kMinorGarbageCollection }
 
enum  UseCounterFeature {
  kUseAsm = 0, kBreakIterator = 1, kLegacyConst = 2, kMarkDequeOverflow = 3,
  kStoreBufferOverflow = 4, kSlotsBufferOverflow = 5, kObjectObserve = 6, kForcedGC = 7,
  kSloppyMode = 8, kStrictMode = 9, kStrongMode = 10, kRegExpPrototypeStickyGetter = 11,
  kRegExpPrototypeToString = 12, kRegExpPrototypeUnicodeGetter = 13, kIntlV8Parse = 14, kIntlPattern = 15,
  kIntlResolved = 16, kPromiseChain = 17, kPromiseAccept = 18, kPromiseDefer = 19,
  kHtmlCommentInExternalScript = 20, kHtmlComment = 21, kSloppyModeBlockScopedFunctionRedefinition = 22, kForInInitializer = 23,
  kArrayProtectorDirtied = 24, kArraySpeciesModified = 25, kArrayPrototypeConstructorModified = 26, kArrayInstanceProtoModified = 27,
  kArrayInstanceConstructorModified = 28, kLegacyFunctionDeclaration = 29, kRegExpPrototypeSourceGetter = 30, kRegExpPrototypeOldFlagGetter = 31,
  kDecimalWithLeadingZeroInStrictMode = 32, kLegacyDateParser = 33, kDefineGetterOrSetterWouldThrow = 34, kFunctionConstructorReturnedUndefined = 35,
  kAssigmentExpressionLHSIsCallInSloppy = 36, kAssigmentExpressionLHSIsCallInStrict = 37, kPromiseConstructorReturnedUndefined = 38, kUseCounterFeatureCount
}
 
enum  MessageErrorLevel {
  kMessageLog = (1 << 0), kMessageDebug = (1 << 1), kMessageInfo = (1 << 2), kMessageError = (1 << 3),
  kMessageWarning = (1 << 4), kMessageAll
}
 
typedef void(* UseCounterCallback) (Isolate *isolate, UseCounterFeature feature)
 
typedef bool(* AbortOnUncaughtExceptionCallback) (Isolate *)
 
typedef void(* GCCallback) (Isolate *isolate, GCType type, GCCallbackFlags flags)
 

Public Member Functions

void SetAbortOnUncaughtExceptionCallback (AbortOnUncaughtExceptionCallback callback)
 
void MemoryPressureNotification (MemoryPressureLevel level)
 
void Enter ()
 
void Exit ()
 
void Dispose ()
 
void DiscardThreadSpecificMetadata ()
 
V8_INLINE void SetData (uint32_t slot, void *data)
 
V8_INLINE void * GetData (uint32_t slot)
 
void GetHeapStatistics (HeapStatistics *heap_statistics)
 
size_t NumberOfHeapSpaces ()
 
bool GetHeapSpaceStatistics (HeapSpaceStatistics *space_statistics, size_t index)
 
size_t NumberOfTrackedHeapObjectTypes ()
 
bool GetHeapObjectStatisticsAtLastGC (HeapObjectStatistics *object_statistics, size_t type_index)
 
bool GetHeapCodeAndMetadataStatistics (HeapCodeStatistics *object_statistics)
 
void GetStackSample (const RegisterState &state, void **frames, size_t frames_limit, SampleInfo *sample_info)
 
V8_INLINE int64_t AdjustAmountOfExternalAllocatedMemory (int64_t change_in_bytes)
 
size_t NumberOfPhantomHandleResetsSinceLastCall ()
 
HeapProfilerGetHeapProfiler ()
 
 V8_DEPRECATE_SOON ("CpuProfiler should be created with CpuProfiler::New call.", CpuProfiler *GetCpuProfiler())
 
bool InContext ()
 
Local< ContextGetCurrentContext ()
 
 V8_DEPRECATE_SOON ("Calling context concept is not compatible with tail calls, and will be ""removed.", Local< Context > GetCallingContext())
 
Local< ContextGetEnteredContext ()
 
Local< ContextGetEnteredOrMicrotaskContext ()
 
Local< ValueThrowException (Local< Value > exception)
 
template<typename T >
 V8_DEPRECATED ("Use EmbedderHeapTracer", void SetObjectGroupId(const Persistent< T > &object, UniqueId id))
 
template<typename T >
 V8_DEPRECATED ("Use EmbedderHeapTracer", void SetReferenceFromGroup(UniqueId id, const Persistent< T > &child))
 
template<typename T , typename S >
 V8_DEPRECATED ("Use EmbedderHeapTracer", void SetReference(const Persistent< T > &parent, const Persistent< S > &child))
 
void AddGCPrologueCallback (GCCallback callback, GCType gc_type_filter=kGCTypeAll)
 
void RemoveGCPrologueCallback (GCCallback callback)
 
void SetEmbedderHeapTracer (EmbedderHeapTracer *tracer)
 
void AddGCEpilogueCallback (GCCallback callback, GCType gc_type_filter=kGCTypeAll)
 
void RemoveGCEpilogueCallback (GCCallback callback)
 
void TerminateExecution ()
 
bool IsExecutionTerminating ()
 
void CancelTerminateExecution ()
 
void RequestInterrupt (InterruptCallback callback, void *data)
 
void RequestGarbageCollectionForTesting (GarbageCollectionType type)
 
void SetEventLogger (LogEventCallback that)
 
void AddBeforeCallEnteredCallback (BeforeCallEnteredCallback callback)
 
void RemoveBeforeCallEnteredCallback (BeforeCallEnteredCallback callback)
 
void AddCallCompletedCallback (CallCompletedCallback callback)
 
 V8_DEPRECATE_SOON ("Use callback with parameter", void AddCallCompletedCallback(DeprecatedCallCompletedCallback callback))
 
void RemoveCallCompletedCallback (CallCompletedCallback callback)
 
 V8_DEPRECATE_SOON ("Use callback with parameter", void RemoveCallCompletedCallback(DeprecatedCallCompletedCallback callback))
 
void SetPromiseHook (PromiseHook hook)
 
void SetPromiseRejectCallback (PromiseRejectCallback callback)
 
void RunMicrotasks ()
 
void EnqueueMicrotask (Local< Function > microtask)
 
void EnqueueMicrotask (MicrotaskCallback microtask, void *data=NULL)
 
void SetMicrotasksPolicy (MicrotasksPolicy policy)
 
 V8_DEPRECATE_SOON ("Use SetMicrotasksPolicy", void SetAutorunMicrotasks(bool autorun))
 
MicrotasksPolicy GetMicrotasksPolicy () const
 
 V8_DEPRECATE_SOON ("Use GetMicrotasksPolicy", bool WillAutorunMicrotasks() const)
 
void AddMicrotasksCompletedCallback (MicrotasksCompletedCallback callback)
 
void RemoveMicrotasksCompletedCallback (MicrotasksCompletedCallback callback)
 
void SetUseCounterCallback (UseCounterCallback callback)
 
void SetCounterFunction (CounterLookupCallback)
 
void SetCreateHistogramFunction (CreateHistogramCallback)
 
void SetAddHistogramSampleFunction (AddHistogramSampleCallback)
 
bool IdleNotificationDeadline (double deadline_in_seconds)
 
 V8_DEPRECATED ("use IdleNotificationDeadline()", bool IdleNotification(int idle_time_in_ms))
 
void LowMemoryNotification ()
 
int ContextDisposedNotification (bool dependant_context=true)
 
void IsolateInForegroundNotification ()
 
void IsolateInBackgroundNotification ()
 
void SetRAILMode (RAILMode rail_mode)
 
void IncreaseHeapLimitForDebugging ()
 
void RestoreOriginalHeapLimit ()
 
bool IsHeapLimitIncreasedForDebugging ()
 
void SetJitCodeEventHandler (JitCodeEventOptions options, JitCodeEventHandler event_handler)
 
void SetStackLimit (uintptr_t stack_limit)
 
void GetCodeRange (void **start, size_t *length_in_bytes)
 
void SetFatalErrorHandler (FatalErrorCallback that)
 
void SetOOMErrorHandler (OOMErrorCallback that)
 
void SetAllowCodeGenerationFromStringsCallback (AllowCodeGenerationFromStringsCallback callback)
 
void SetAllowWasmCompileCallback (AllowWasmCompileCallback callback)
 
void SetAllowWasmInstantiateCallback (AllowWasmInstantiateCallback callback)
 
bool IsDead ()
 
bool AddMessageListener (MessageCallback that, Local< Value > data=Local< Value >())
 
bool AddMessageListenerWithErrorLevel (MessageCallback that, int message_levels, Local< Value > data=Local< Value >())
 
void RemoveMessageListeners (MessageCallback that)
 
void SetFailedAccessCheckCallbackFunction (FailedAccessCheckCallback)
 
void SetCaptureStackTraceForUncaughtExceptions (bool capture, int frame_limit=10, StackTrace::StackTraceOptions options=StackTrace::kOverview)
 
void VisitExternalResources (ExternalResourceVisitor *visitor)
 
void VisitHandlesWithClassIds (PersistentHandleVisitor *visitor)
 
void VisitHandlesForPartialDependence (PersistentHandleVisitor *visitor)
 
void VisitWeakHandles (PersistentHandleVisitor *visitor)
 
bool IsInUse ()
 
 Isolate ()=delete
 
 ~Isolate ()=delete
 
 Isolate (const Isolate &)=delete
 
Isolateoperator= (const Isolate &)=delete
 
void * operator new (size_t size)=delete
 
void operator delete (void *, size_t)=delete
 

Static Public Member Functions

static IsolateNew (const CreateParams &params)
 
static IsolateGetCurrent ()
 
static V8_INLINE uint32_t GetNumberOfDataSlots ()
 

Friends

template<class K , class V , class Traits >
class PersistentValueMapBase
 

Detailed Description

Isolate represents an isolated instance of the V8 engine. V8 isolates have completely separate states. Objects from one isolate must not be used in other isolates. The embedder can create multiple isolates and use them in parallel in multiple threads. An isolate can be entered by at most one thread at any given time. The Locker/Unlocker API must be used to synchronize.

Definition at line 6361 of file v8.h.

Member Typedef Documentation

typedef bool(* AbortOnUncaughtExceptionCallback) (Isolate *)

Custom callback used by embedders to help V8 determine if it should abort when it throws and no internal handler is predicted to catch the exception. If –abort-on-uncaught-exception is used on the command line, then V8 will abort if either:

  • no custom callback is set.
  • the custom callback set returns true. Otherwise, the custom callback will not be called and V8 will not abort.

Definition at line 6624 of file v8.h.

typedef void(* GCCallback) (Isolate *isolate, GCType type, GCCallbackFlags flags)

Definition at line 6866 of file v8.h.

typedef void(* UseCounterCallback) (Isolate *isolate, UseCounterFeature feature)

Definition at line 6592 of file v8.h.

Member Enumeration Documentation

Types of garbage collections that can be requested via RequestGarbageCollectionForTesting.

Enumerator
kFullGarbageCollection 
kMinorGarbageCollection 

Definition at line 6526 of file v8.h.

Enumerator
kMessageLog 
kMessageDebug 
kMessageInfo 
kMessageError 
kMessageWarning 
kMessageAll 

Definition at line 6582 of file v8.h.

Features reported via the SetUseCounterCallback callback. Do not change assigned numbers of existing items; add new features to the end of this list.

Enumerator
kUseAsm 
kBreakIterator 
kLegacyConst 
kMarkDequeOverflow 
kStoreBufferOverflow 
kSlotsBufferOverflow 
kObjectObserve 
kForcedGC 
kSloppyMode 
kStrictMode 
kStrongMode 
kRegExpPrototypeStickyGetter 
kRegExpPrototypeToString 
kRegExpPrototypeUnicodeGetter 
kIntlV8Parse 
kIntlPattern 
kIntlResolved 
kPromiseChain 
kPromiseAccept 
kPromiseDefer 
kHtmlCommentInExternalScript 
kHtmlComment 
kSloppyModeBlockScopedFunctionRedefinition 
kForInInitializer 
kArrayProtectorDirtied 
kArraySpeciesModified 
kArrayPrototypeConstructorModified 
kArrayInstanceProtoModified 
kArrayInstanceConstructorModified 
kLegacyFunctionDeclaration 
kRegExpPrototypeSourceGetter 
kRegExpPrototypeOldFlagGetter 
kDecimalWithLeadingZeroInStrictMode 
kLegacyDateParser 
kDefineGetterOrSetterWouldThrow 
kFunctionConstructorReturnedUndefined 
kAssigmentExpressionLHSIsCallInSloppy 
kAssigmentExpressionLHSIsCallInStrict 
kPromiseConstructorReturnedUndefined 
kUseCounterFeatureCount 

Definition at line 6536 of file v8.h.

Constructor & Destructor Documentation

Isolate ( )
delete
~Isolate ( )
delete
Isolate ( const Isolate )
delete

Member Function Documentation

void AddBeforeCallEnteredCallback ( BeforeCallEnteredCallback  callback)

Adds a callback to notify the host application right before a script is about to run. If a script re-enters the runtime during executing, the BeforeCallEnteredCallback is invoked for each re-entrance. Executing scripts inside the callback will re-trigger the callback.

void AddCallCompletedCallback ( CallCompletedCallback  callback)

Adds a callback to notify the host application when a script finished running. If a script re-enters the runtime during executing, the CallCompletedCallback is only invoked when the outer-most script execution ends. Executing scripts inside the callback do not trigger further callbacks.

void AddGCEpilogueCallback ( GCCallback  callback,
GCType  gc_type_filter = kGCTypeAll 
)

Enables the host application to receive a notification after a garbage collection. Allocations are allowed in the callback function, but the callback is not re-entrant: if the allocation inside it will trigger the garbage collection, the callback won't be called again. It is possible to specify the GCType filter for your callback. But it is not possible to register the same callback function two times with different GCType filters.

void AddGCPrologueCallback ( GCCallback  callback,
GCType  gc_type_filter = kGCTypeAll 
)

Enables the host application to receive a notification before a garbage collection. Allocations are allowed in the callback function, but the callback is not re-entrant: if the allocation inside it will trigger the garbage collection, the callback won't be called again. It is possible to specify the GCType filter for your callback. But it is not possible to register the same callback function two times with different GCType filters.

bool AddMessageListener ( MessageCallback  that,
Local< Value data = LocalValue >() 
)

Adds a message listener (errors only).

The same message listener can be added more than once and in that case it will be called more than once for each message.

If data is specified, it will be passed to the callback when it is called. Otherwise, the exception object will be passed to the callback instead.

bool AddMessageListenerWithErrorLevel ( MessageCallback  that,
int  message_levels,
Local< Value data = LocalValue >() 
)

Adds a message listener.

The same message listener can be added more than once and in that case it will be called more than once for each message.

If data is specified, it will be passed to the callback when it is called. Otherwise, the exception object will be passed to the callback instead.

A listener can listen for particular error levels by providing a mask.

void AddMicrotasksCompletedCallback ( MicrotasksCompletedCallback  callback)

Experimental: adds a callback to notify the host application after microtasks were run. The callback is triggered by explicit RunMicrotasks call or automatic microtasks execution (see SetAutorunMicrotasks).

Callback will trigger even if microtasks were attempted to run, but the microtasks queue was empty and no single microtask was actually executed.

Executing scriptsinside the callback will not re-trigger microtasks and the callback.

int64_t AdjustAmountOfExternalAllocatedMemory ( int64_t  change_in_bytes)

Adjusts the amount of registered external memory. Used to give V8 an indication of the amount of externally allocated memory that is kept alive by JavaScript objects. V8 uses this to decide when to perform global garbage collections. Registering externally allocated memory will trigger global garbage collections more often than it would otherwise in an attempt to garbage collect the JavaScript objects that keep the externally allocated memory alive.

Parameters
change_in_bytesthe change in externally allocated memory that is kept alive by JavaScript objects.
Returns
the adjusted value.

Definition at line 9728 of file v8.h.

References Internals::kExternalMemoryLimitOffset, and Internals::kExternalMemoryOffset.

void CancelTerminateExecution ( )

Resume execution capability in the given isolate, whose execution was previously forcefully terminated using TerminateExecution().

When execution is forcefully terminated using TerminateExecution(), the isolate can not resume execution until all JavaScript frames have propagated the uncatchable exception which is generated. This method allows the program embedding the engine to handle the termination event and resume execution capability, even if JavaScript frames remain on the stack.

This method can be used by any thread even if that thread has not acquired the V8 lock with a Locker object.

int ContextDisposedNotification ( bool  dependant_context = true)

Optional notification that a context has been disposed. V8 uses these notifications to guide the GC heuristic. Returns the number of context disposals - including this one - since the last time V8 had a chance to clean up.

The optional parameter |dependant_context| specifies whether the disposed context was depending on state from other contexts or not.

void DiscardThreadSpecificMetadata ( )

Discards all V8 thread-specific data for the Isolate. Should be used if a thread is terminating and it has used an Isolate that will outlive the thread – all thread-specific data for an Isolate is discarded when an Isolate is disposed so this call is pointless if an Isolate is about to be Disposed.

void Dispose ( )

Disposes the isolate. The isolate must not be entered by any thread to be disposable.

void EnqueueMicrotask ( Local< Function microtask)

Experimental: Enqueues the callback to the Microtask Work Queue

void EnqueueMicrotask ( MicrotaskCallback  microtask,
void *  data = NULL 
)

Experimental: Enqueues the callback to the Microtask Work Queue

void Enter ( )

Methods below this point require holding a lock (using Locker) in a multi-threaded environment. Sets this isolate as the entered one for the current thread. Saves the previously entered one (if any), so that it can be restored when exiting. Re-entering an isolate is allowed.

Referenced by Isolate::Scope::Scope().

void Exit ( )

Exits this isolate by restoring the previously entered one in the current thread. The isolate may still stay the same, if it was entered more than once.

Requires: this == Isolate::GetCurrent().

Referenced by Isolate::Scope::~Scope().

void GetCodeRange ( void **  start,
size_t *  length_in_bytes 
)

Returns a memory range that can potentially contain jitted code.

On Win64, embedders are advised to install function table callbacks for these ranges, as default SEH won't be able to unwind through jitted code.

The first page of the code range is reserved for the embedder and is committed, writable, and executable.

Might be empty on other platforms.

https://code.google.com/p/v8/issues/detail?id=3598

static Isolate* GetCurrent ( )
static

Returns the entered isolate for the current thread or NULL in case there is no current isolate.

This method must not be invoked before V8::Initialize() was invoked.

Referenced by Value::ToDetailString(), and Value::ToObject().

Local<Context> GetCurrentContext ( )

Returns the context of the currently running JavaScript, or the context on the top of the stack if no JavaScript is running.

Referenced by Value::ToDetailString(), and Value::ToObject().

void * GetData ( uint32_t  slot)

Retrieve embedder-specific data from the isolate. Returns NULL if SetData has never been called for the given |slot|.

Definition at line 9716 of file v8.h.

References Internals::GetEmbedderData().

Local<Context> GetEnteredContext ( )

Returns the last context entered through V8's C++ API.

Local<Context> GetEnteredOrMicrotaskContext ( )

Returns either the last context entered through V8's C++ API, or the context of the currently running microtask while processing microtasks. If a context is entered while executing a microtask, that context is returned.

bool GetHeapCodeAndMetadataStatistics ( HeapCodeStatistics object_statistics)

Get statistics about code and its metadata in the heap.

Parameters
object_statisticsThe HeapCodeStatistics object to fill in statistics of code, bytecode and their metadata.
Returns
true on success.
bool GetHeapObjectStatisticsAtLastGC ( HeapObjectStatistics object_statistics,
size_t  type_index 
)

Get statistics about objects in the heap.

Parameters
object_statisticsThe HeapObjectStatistics object to fill in statistics of objects of given type, which were live in the previous GC.
type_indexThe index of the type of object to fill details about, which ranges from 0 to NumberOfTrackedHeapObjectTypes() - 1.
Returns
true on success.
HeapProfiler* GetHeapProfiler ( )

Returns heap profiler for this isolate. Will return NULL until the isolate is initialized.

bool GetHeapSpaceStatistics ( HeapSpaceStatistics space_statistics,
size_t  index 
)

Get the memory usage of a space in the heap.

Parameters
space_statisticsThe HeapSpaceStatistics object to fill in statistics.
indexThe index of the space to get statistics from, which ranges from 0 to NumberOfHeapSpaces() - 1.
Returns
true on success.
void GetHeapStatistics ( HeapStatistics heap_statistics)

Get statistics about the heap memory usage.

MicrotasksPolicy GetMicrotasksPolicy ( ) const

Experimental: Returns the policy controlling how Microtasks are invoked.

uint32_t GetNumberOfDataSlots ( )
static

Returns the maximum number of available embedder data slots. Valid slots are in the range of 0 - GetNumberOfDataSlots() - 1.

Definition at line 9722 of file v8.h.

References Internals::kNumIsolateDataSlots.

void GetStackSample ( const RegisterState state,
void **  frames,
size_t  frames_limit,
SampleInfo sample_info 
)

Get a call stack sample from the isolate.

Parameters
stateExecution state.
framesCaller allocated buffer to store stack frames.
frames_limitMaximum number of frames to capture. The buffer must be large enough to hold the number of frames.
sample_infoThe sample info is filled up by the function provides number of actual captured stack frames and the current VM state.
Note
GetStackSample should only be called when the JS thread is paused or interrupted. Otherwise the behavior is undefined.
bool IdleNotificationDeadline ( double  deadline_in_seconds)

Optional notification that the embedder is idle. V8 uses the notification to perform garbage collection. This call can be used repeatedly if the embedder remains idle. Returns true if the embedder should stop calling IdleNotificationDeadline until real work has been done. This indicates that V8 has done as much cleanup as it will be able to do.

The deadline_in_seconds argument specifies the deadline V8 has to finish garbage collection work. deadline_in_seconds is compared with MonotonicallyIncreasingTime() and should be based on the same timebase as that function. There is no guarantee that the actual work will be done within the time limit.

bool InContext ( )

Returns true if this isolate has a current context.

void IncreaseHeapLimitForDebugging ( )

Optional notification to tell V8 the current isolate is used for debugging and requires higher heap limit.

bool IsDead ( )

Check if V8 is dead and therefore unusable. This is the case after fatal errors such as out-of-memory situations.

bool IsExecutionTerminating ( )

Is V8 terminating JavaScript execution.

Returns true if JavaScript execution is currently terminating because of a call to TerminateExecution. In that case there are still JavaScript frames on the stack and the termination exception is still active.

bool IsHeapLimitIncreasedForDebugging ( )

Returns true if the heap limit was increased for debugging and the original heap limit was not restored yet.

bool IsInUse ( )

Check if this isolate is in use. True if at least one thread Enter'ed this isolate.

void IsolateInBackgroundNotification ( )

Optional notification that the isolate switched to the background. V8 uses these notifications to guide heuristics.

void IsolateInForegroundNotification ( )

Optional notification that the isolate switched to the foreground. V8 uses these notifications to guide heuristics.

void LowMemoryNotification ( )

Optional notification that the system is running low on memory. V8 uses these notifications to attempt to free memory.

void MemoryPressureNotification ( MemoryPressureLevel  level)

Optional notification that the system is running low on memory. V8 uses these notifications to guide heuristics. It is allowed to call this function from another thread while the isolate is executing long running JavaScript code.

static Isolate* New ( const CreateParams params)
static

Creates a new isolate. Does not change the currently entered isolate.

When an isolate is no longer used its resources should be freed by calling Dispose(). Using the delete operator is not allowed.

V8::Initialize() must have run prior to this.

size_t NumberOfHeapSpaces ( )

Returns the number of spaces in the heap.

size_t NumberOfPhantomHandleResetsSinceLastCall ( )

Returns the number of phantom handles without callbacks that were reset by the garbage collector since the last call to this function.

size_t NumberOfTrackedHeapObjectTypes ( )

Returns the number of types of objects tracked in the heap at GC.

void operator delete ( void *  ,
size_t   
)
delete
void* operator new ( size_t  size)
delete
Isolate& operator= ( const Isolate )
delete
void RemoveBeforeCallEnteredCallback ( BeforeCallEnteredCallback  callback)

Removes callback that was installed by AddBeforeCallEnteredCallback.

void RemoveCallCompletedCallback ( CallCompletedCallback  callback)

Removes callback that was installed by AddCallCompletedCallback.

void RemoveGCEpilogueCallback ( GCCallback  callback)

This function removes callback which was installed by AddGCEpilogueCallback function.

void RemoveGCPrologueCallback ( GCCallback  callback)

This function removes callback which was installed by AddGCPrologueCallback function.

void RemoveMessageListeners ( MessageCallback  that)

Remove all message listeners from the specified callback function.

void RemoveMicrotasksCompletedCallback ( MicrotasksCompletedCallback  callback)

Removes callback that was installed by AddMicrotasksCompletedCallback.

void RequestGarbageCollectionForTesting ( GarbageCollectionType  type)

Request garbage collection in this Isolate. It is only valid to call this function if –expose_gc was specified.

This should only be used for testing purposes and not to enforce a garbage collection schedule. It has strong negative impact on the garbage collection performance. Use IdleNotificationDeadline() or LowMemoryNotification() instead to influence the garbage collection schedule.

void RequestInterrupt ( InterruptCallback  callback,
void *  data 
)

Request V8 to interrupt long running JavaScript code and invoke the given |callback| passing the given |data| to it. After |callback| returns control will be returned to the JavaScript code. There may be a number of interrupt requests in flight. Can be called from another thread without acquiring a |Locker|. Registered |callback| must not reenter interrupted Isolate.

void RestoreOriginalHeapLimit ( )

Restores the original heap limit after IncreaseHeapLimitForDebugging().

void RunMicrotasks ( )

Experimental: Runs the Microtask Work Queue until empty Any exceptions thrown by microtask callbacks are swallowed.

void SetAbortOnUncaughtExceptionCallback ( AbortOnUncaughtExceptionCallback  callback)
void SetAddHistogramSampleFunction ( AddHistogramSampleCallback  )
void SetAllowCodeGenerationFromStringsCallback ( AllowCodeGenerationFromStringsCallback  callback)

Set the callback to invoke to check if code generation from strings should be allowed.

void SetAllowWasmCompileCallback ( AllowWasmCompileCallback  callback)

Set the callback to invoke to check if wasm compilation from the specified object is allowed. By default, wasm compilation is allowed.

Similar for instantiate.

void SetAllowWasmInstantiateCallback ( AllowWasmInstantiateCallback  callback)
void SetCaptureStackTraceForUncaughtExceptions ( bool  capture,
int  frame_limit = 10,
StackTrace::StackTraceOptions  options = StackTrace::kOverview 
)

Tells V8 to capture current stack trace when uncaught exception occurs and report it to the message listeners. The option is off by default.

void SetCounterFunction ( CounterLookupCallback  )

Enables the host application to provide a mechanism for recording statistics counters.

void SetCreateHistogramFunction ( CreateHistogramCallback  )

Enables the host application to provide a mechanism for recording histograms. The CreateHistogram function returns a histogram which will later be passed to the AddHistogramSample function.

void SetData ( uint32_t  slot,
void *  data 
)

Associate embedder-specific data with the isolate. |slot| has to be between 0 and GetNumberOfDataSlots() - 1.

Definition at line 9710 of file v8.h.

References Internals::SetEmbedderData().

void SetEmbedderHeapTracer ( EmbedderHeapTracer tracer)

Sets the embedder heap tracer for the isolate.

void SetEventLogger ( LogEventCallback  that)

Set the callback to invoke for logging event.

void SetFailedAccessCheckCallbackFunction ( FailedAccessCheckCallback  )

Callback function for reporting failed access checks.

void SetFatalErrorHandler ( FatalErrorCallback  that)

Set the callback to invoke in case of fatal errors.

void SetJitCodeEventHandler ( JitCodeEventOptions  options,
JitCodeEventHandler  event_handler 
)

Allows the host application to provide the address of a function that is notified each time code is added, moved or removed.

Parameters
optionsoptions for the JIT code event handler.
event_handlerthe JIT code event handler, which will be invoked each time code is added, moved or removed.
Note
event_handler won't get notified of existent code.
since code removal notifications are not currently issued, the event_handler may get notifications of code that overlaps earlier code notifications. This happens when code areas are reused, and the earlier overlapping code areas should therefore be discarded.
the events passed to event_handler and the strings they point to are not guaranteed to live past each call. The event_handler must copy strings and other parameters it needs to keep around.
the set of events declared in JitCodeEvent::EventType is expected to grow over time, and the JitCodeEvent structure is expected to accrue new members. The event_handler function must ignore event codes it does not recognize to maintain future compatibility.
Use Isolate::CreateParams to get events for code executed during Isolate setup.
void SetMicrotasksPolicy ( MicrotasksPolicy  policy)

Experimental: Controls how Microtasks are invoked. See MicrotasksPolicy for details.

void SetOOMErrorHandler ( OOMErrorCallback  that)

Set the callback to invoke in case of OOM errors.

void SetPromiseHook ( PromiseHook  hook)

Experimental: Set the PromiseHook callback for various promise lifecycle events.

void SetPromiseRejectCallback ( PromiseRejectCallback  callback)

Set callback to notify about promise reject with no handler, or revocation of such a previous notification once the handler is added.

void SetRAILMode ( RAILMode  rail_mode)

Optional notification to tell V8 the current performance requirements of the embedder based on RAIL. V8 uses these notifications to guide heuristics. This is an unfinished experimental feature. Semantics and implementation may change frequently.

void SetStackLimit ( uintptr_t  stack_limit)

Modifies the stack limit for this Isolate.

Parameters
stack_limitAn address beyond which the Vm's stack may not grow.
Note
If you are using threads then you should hold the V8::Locker lock while setting the stack limit and you must set a non-default stack limit separately for each thread.
void SetUseCounterCallback ( UseCounterCallback  callback)

Sets a callback for counting the number of times a feature of V8 is used.

void TerminateExecution ( )

Forcefully terminate the current thread of JavaScript execution in the given isolate.

This method can be used by any thread even if that thread has not acquired the V8 lock with a Locker object.

Local<Value> ThrowException ( Local< Value exception)

Schedules an exception to be thrown when returning to JavaScript. When an exception has been scheduled it is illegal to invoke any JavaScript operation; the caller must return immediately and only after the exception has been handled does it become legal to invoke JavaScript operations.

V8_DEPRECATE_SOON ( "CpuProfiler should be created with CpuProfiler::New call."  ,
CpuProfiler GetCpuProfiler() 
)

Returns CPU profiler for this isolate. Will return NULL unless the isolate is initialized. It is the embedder's responsibility to stop all CPU profiling activities if it has started any.

V8_DEPRECATE_SOON ( "Calling context concept is not compatible with tail  calls,
and will be""removed."  ,
Local< Context >   GetCallingContext() 
)

Returns the context of the calling JavaScript code. That is the context of the top-most JavaScript frame. If there are no JavaScript frames an empty handle is returned.

V8_DEPRECATE_SOON ( "Use callback with parameter"  ,
void   AddCallCompletedCallbackDeprecatedCallCompletedCallback callback 
)
V8_DEPRECATE_SOON ( "Use callback with parameter"  ,
void   RemoveCallCompletedCallbackDeprecatedCallCompletedCallback callback 
)
V8_DEPRECATE_SOON ( "Use SetMicrotasksPolicy ,
void   SetAutorunMicrotasksbool autorun 
)
V8_DEPRECATE_SOON ( "Use GetMicrotasksPolicy ,
bool WillAutorunMicrotasks()  const 
)
V8_DEPRECATED ( "Use EmbedderHeapTracer ,
void   SetObjectGroupIdconst Persistent< T > &object, UniqueId id 
)

Allows the host application to group objects together. If one object in the group is alive, all objects in the group are alive. After each garbage collection, object groups are removed. It is intended to be used in the before-garbage-collection callback function, for instance to simulate DOM tree connections among JS wrapper objects. Object groups for all dependent handles need to be provided for kGCTypeMarkSweepCompact collections, for all other garbage collection types it is sufficient to provide object groups for partially dependent handles only.

V8_DEPRECATED ( "Use EmbedderHeapTracer ,
void   SetReferenceFromGroupUniqueId id, const Persistent< T > &child 
)

Allows the host application to declare implicit references from an object group to an object. If the objects of the object group are alive, the child object is alive too. After each garbage collection, all implicit references are removed. It is intended to be used in the before-garbage-collection callback function.

V8_DEPRECATED ( "Use EmbedderHeapTracer ,
void   SetReferenceconst Persistent< T > &parent, const Persistent< S > &child 
)

Allows the host application to declare implicit references from an object to another object. If the parent object is alive, the child object is alive too. After each garbage collection, all implicit references are removed. It is intended to be used in the before-garbage-collection callback function.

V8_DEPRECATED ( "use IdleNotificationDeadline()"  ,
bool   IdleNotificationint idle_time_in_ms 
)
void VisitExternalResources ( ExternalResourceVisitor visitor)

Iterates through all external resources referenced from current isolate heap. GC is not invoked prior to iterating, therefore there is no guarantee that visited objects are still alive.

void VisitHandlesForPartialDependence ( PersistentHandleVisitor visitor)

Iterates through all the persistent handles in the current isolate's heap that have class_ids and are candidates to be marked as partially dependent handles. This will visit handles to young objects created since the last garbage collection but is free to visit an arbitrary superset of these objects.

void VisitHandlesWithClassIds ( PersistentHandleVisitor visitor)

Iterates through all the persistent handles in the current isolate's heap that have class_ids.

void VisitWeakHandles ( PersistentHandleVisitor visitor)

Iterates through all the persistent handles in the current isolate's heap that have class_ids and are weak to be marked as inactive if there is no pending activity for the handle.

Friends And Related Function Documentation

friend class PersistentValueMapBase
friend

Definition at line 7329 of file v8.h.


The documentation for this class was generated from the following file: