#include <isolate.h>

Collaboration diagram for v8::internal::Isolate:

Classes
class	EntryStackItem

class	ExceptionScope

class	PerIsolateThreadData

class	ThreadDataTable

Public Types
enum	AddressId { kIsolateAddressCount }

Public Member Functions
	~Isolate ()

	INLINE (static Isolate *Current())

	INLINE (static Isolate *UncheckedCurrent())

	INLINE (static Isolate *UnsafeCurrent())

void	InitializeLoggingAndCounters ()

bool	Init (Deserializer *des)

bool	IsInitialized ()

bool	IsInUse ()

void	TearDown ()

PerIsolateThreadData *	FindPerThreadDataForThisThread ()

PerIsolateThreadData *	FindPerThreadDataForThread (ThreadId thread_id)

base::RecursiveMutex *	break_access ()

Address	get_address_from_id (AddressId id)

Context *	context ()

void	set_context (Context *context)

Context **	context_address ()

Object *	pending_exception ()

void	set_pending_exception (Object *exception_obj)

void	clear_pending_exception ()

Object **	pending_exception_address ()

bool	has_pending_exception ()

void	clear_pending_message ()

v8::TryCatch *	try_catch_handler ()

Address	try_catch_handler_address ()

bool *	external_caught_exception_address ()

Object **	scheduled_exception_address ()

Address	pending_message_obj_address ()

Address	has_pending_message_address ()

Address	pending_message_script_address ()

Object *	scheduled_exception ()

bool	has_scheduled_exception ()

void	clear_scheduled_exception ()

bool	HasExternalTryCatch ()

bool	IsFinallyOnTop ()

bool	is_catchable_by_javascript (Object *exception)

void	PushToPartialSnapshotCache (Object *obj)

Address *	c_entry_fp_address ()

Address *	handler_address ()

Address	js_entry_sp ()

Address *	js_entry_sp_address ()

void *	formal_count_address ()

Handle< GlobalObject >	global_object ()

JSObject *	global_proxy ()

Handle< JSBuiltinsObject >	js_builtins_object ()

void	FreeThreadResources ()

bool	OptionalRescheduleException (bool is_bottom_call)

void	PushPromise (Handle< JSObject > promise)

void	PopPromise ()

Handle< Object >	GetPromiseOnStackOnThrow ()

void	SetCaptureStackTraceForUncaughtExceptions (bool capture, int frame_limit, StackTrace::StackTraceOptions options)

void	PrintCurrentStackTrace (FILE *out)

void	PrintStack (StringStream *accumulator)

void	PrintStack (FILE *out)

Handle< String >	StackTraceString ()

	NO_INLINE (void PushStackTraceAndDie(unsigned int magic, Object object, Map map, unsigned int magic2))

Handle< JSArray >	CaptureCurrentStackTrace (int frame_limit, StackTrace::StackTraceOptions options)

Handle< Object >	CaptureSimpleStackTrace (Handle< JSObject > error_object, Handle< Object > caller)

void	CaptureAndSetDetailedStackTrace (Handle< JSObject > error_object)

void	CaptureAndSetSimpleStackTrace (Handle< JSObject > error_object, Handle< Object > caller)

bool	MayNamedAccess (Handle< JSObject > receiver, Handle< Object > key, v8::AccessType type)

bool	MayIndexedAccess (Handle< JSObject > receiver, uint32_t index, v8::AccessType type)

void	SetFailedAccessCheckCallback (v8::FailedAccessCheckCallback callback)

void	ReportFailedAccessCheck (Handle< JSObject > receiver, v8::AccessType type)

Object *	Throw (Object exception, MessageLocation location=NULL)

template<typename T >
MUST_USE_RESULT MaybeHandle< T >	Throw (Handle< Object > exception, MessageLocation *location=NULL)

Object *	ReThrow (Object *exception)

void	ScheduleThrow (Object *exception)

void	RestorePendingMessageFromTryCatch (v8::TryCatch *handler)

void	CancelScheduledExceptionFromTryCatch (v8::TryCatch *handler)

void	ReportPendingMessages ()

MessageLocation	GetMessageLocation ()

Object *	ThrowIllegalOperation ()

Object *	PromoteScheduledException ()

void	DoThrow (Object exception, MessageLocation location)

bool	ShouldReportException (bool *can_be_caught_externally, bool catchable_by_javascript)

void	ComputeLocation (MessageLocation *target)

Object *	StackOverflow ()

Object *	TerminateExecution ()

void	CancelTerminateExecution ()

void	InvokeApiInterruptCallback ()

void	Iterate (ObjectVisitor *v)

void	Iterate (ObjectVisitor v, ThreadLocalTop t)

char *	Iterate (ObjectVisitor v, char t)

void	IterateThread (ThreadVisitor v, char t)

Handle< Context >	native_context ()

Handle< Context >	global_context ()

Handle< Context >	GetCallingNativeContext ()

void	RegisterTryCatchHandler (v8::TryCatch *that)

void	UnregisterTryCatchHandler (v8::TryCatch *that)

char *	ArchiveThread (char *to)

char *	RestoreThread (char *from)

Bootstrapper *	bootstrapper ()

Counters *	counters ()

CodeRange *	code_range ()

RuntimeProfiler *	runtime_profiler ()

CompilationCache *	compilation_cache ()

Logger *	logger ()

StackGuard *	stack_guard ()

Heap *	heap ()

StatsTable *	stats_table ()

StubCache *	stub_cache ()

CodeAgingHelper *	code_aging_helper ()

DeoptimizerData *	deoptimizer_data ()

ThreadLocalTop *	thread_local_top ()

MaterializedObjectStore *	materialized_object_store ()

MemoryAllocator *	memory_allocator ()

KeyedLookupCache *	keyed_lookup_cache ()

ContextSlotCache *	context_slot_cache ()

DescriptorLookupCache *	descriptor_lookup_cache ()

HandleScopeData *	handle_scope_data ()

HandleScopeImplementer *	handle_scope_implementer ()

Zone *	runtime_zone ()

UnicodeCache *	unicode_cache ()

InnerPointerToCodeCache *	inner_pointer_to_code_cache ()

ConsStringIteratorOp *	write_iterator ()

GlobalHandles *	global_handles ()

EternalHandles *	eternal_handles ()

ThreadManager *	thread_manager ()

StringTracker *	string_tracker ()

unibrow::Mapping< unibrow::Ecma262UnCanonicalize > *	jsregexp_uncanonicalize ()

unibrow::Mapping< unibrow::CanonicalizationRange > *	jsregexp_canonrange ()

ConsStringIteratorOp *	objects_string_compare_iterator_a ()

ConsStringIteratorOp *	objects_string_compare_iterator_b ()

StaticResource< ConsStringIteratorOp > *	objects_string_iterator ()

RuntimeState *	runtime_state ()

Builtins *	builtins ()

void	NotifyExtensionInstalled ()

bool	has_installed_extensions ()

unibrow::Mapping< unibrow::Ecma262Canonicalize > *	regexp_macro_assembler_canonicalize ()

RegExpStack *	regexp_stack ()

unibrow::Mapping< unibrow::Ecma262Canonicalize > *	interp_canonicalize_mapping ()

Debug *	debug ()

bool	DebuggerHasBreakPoints ()

CpuProfiler *	cpu_profiler () const

HeapProfiler *	heap_profiler () const

Factory *	factory ()

void	SetData (uint32_t slot, void *data)

void *	GetData (uint32_t slot)

void	enable_serializer ()

bool	serializer_enabled () const

bool	IsDead ()

void	SignalFatalError ()

bool	use_crankshaft () const

bool	initialized_from_snapshot ()

double	time_millis_since_init ()

DateCache *	date_cache ()

void	set_date_cache (DateCache *date_cache)

Map *	get_initial_js_array_map (ElementsKind kind)

bool	IsFastArrayConstructorPrototypeChainIntact ()

CallInterfaceDescriptorData *	call_descriptor_data (int index)

void	IterateDeferredHandles (ObjectVisitor *visitor)

void	LinkDeferredHandles (DeferredHandles *deferred_handles)

void	UnlinkDeferredHandles (DeferredHandles *deferred_handles)

bool	concurrent_recompilation_enabled ()

bool	concurrent_osr_enabled () const

OptimizingCompilerThread *	optimizing_compiler_thread ()

int	num_sweeper_threads () const

SweeperThread **	sweeper_threads ()

int	id () const

HStatistics *	GetHStatistics ()

HStatistics *	GetTStatistics ()

HTracer *	GetHTracer ()

CodeTracer *	GetCodeTracer ()

FunctionEntryHook	function_entry_hook ()

void	set_function_entry_hook (FunctionEntryHook function_entry_hook)

void *	stress_deopt_count_address ()

base::RandomNumberGenerator *	random_number_generator ()

Object *	FindCodeObject (Address a)

int	NextOptimizationId ()

Handle< JSObject >	GetSymbolRegistry ()

void	AddCallCompletedCallback (CallCompletedCallback callback)

void	RemoveCallCompletedCallback (CallCompletedCallback callback)

void	FireCallCompletedCallback ()

void	EnqueueMicrotask (Handle< Object > microtask)

void	RunMicrotasks ()

void	SetUseCounterCallback (v8::Isolate::UseCounterCallback callback)

void	CountUsage (v8::Isolate::UseCounterFeature feature)

BasicBlockProfiler *	GetOrCreateBasicBlockProfiler ()

BasicBlockProfiler *	basic_block_profiler ()

Static Public Member Functions
static void	InitializeOncePerProcess ()

static PerIsolateThreadData *	CurrentPerIsolateThreadData ()

static void	GlobalTearDown ()

static base::Thread::LocalStorageKey	isolate_key ()

static base::Thread::LocalStorageKey	thread_id_key ()

static base::Thread::LocalStorageKey	per_isolate_thread_data_key ()

static Address	c_entry_fp (ThreadLocalTop *thread)

static Address	handler (ThreadLocalTop *thread)

static int	ArchiveSpacePerThread ()

static Isolate *	NewForTesting ()

Static Public Attributes
static const char *const	kStackOverflowMessage

static const int	kUC16AlphabetSize = 256

static const int	kBMMaxShift = 250

static const int	kJSRegexpStaticOffsetsVectorSize = 128

Private Types
enum	State { UNINITIALIZED , INITIALIZED }

Private Member Functions
	Isolate ()

void	Deinit ()

PerIsolateThreadData *	FindOrAllocatePerThreadDataForThisThread ()

void	Enter ()

void	Exit ()

void	InitializeThreadLocal ()

void	MarkCompactPrologue (bool is_compacting, ThreadLocalTop *archived_thread_data)

void	MarkCompactEpilogue (bool is_compacting, ThreadLocalTop *archived_thread_data)

void	FillCache ()

bool	PropagatePendingExceptionToExternalTryCatch ()

bool	IsErrorObject (Handle< Object > obj)

	DISALLOW_COPY_AND_ASSIGN (Isolate)

Static Private Member Functions
static void	SetIsolateThreadLocals (Isolate isolate, PerIsolateThreadData data)

Private Attributes
void *	embedder_data_ [Internals::kNumIsolateDataSlots]

Heap	heap_

State	state_

base::Atomic32	id_

EntryStackItem *	entry_stack_

int	stack_trace_nesting_level_

StringStream *	incomplete_message_

Address	isolate_addresses_ [kIsolateAddressCount+1]

Bootstrapper *	bootstrapper_

RuntimeProfiler *	runtime_profiler_

CompilationCache *	compilation_cache_

Counters *	counters_

CodeRange *	code_range_

base::RecursiveMutex	break_access_

base::Atomic32	debugger_initialized_

Logger *	logger_

StackGuard	stack_guard_

StatsTable *	stats_table_

StubCache *	stub_cache_

CodeAgingHelper *	code_aging_helper_

DeoptimizerData *	deoptimizer_data_

MaterializedObjectStore *	materialized_object_store_

ThreadLocalTop	thread_local_top_

bool	capture_stack_trace_for_uncaught_exceptions_

int	stack_trace_for_uncaught_exceptions_frame_limit_

StackTrace::StackTraceOptions	stack_trace_for_uncaught_exceptions_options_

MemoryAllocator *	memory_allocator_

KeyedLookupCache *	keyed_lookup_cache_

ContextSlotCache *	context_slot_cache_

DescriptorLookupCache *	descriptor_lookup_cache_

HandleScopeData	handle_scope_data_

HandleScopeImplementer *	handle_scope_implementer_

UnicodeCache *	unicode_cache_

Zone	runtime_zone_

InnerPointerToCodeCache *	inner_pointer_to_code_cache_

ConsStringIteratorOp *	write_iterator_

GlobalHandles *	global_handles_

EternalHandles *	eternal_handles_

ThreadManager *	thread_manager_

RuntimeState	runtime_state_

Builtins	builtins_

bool	has_installed_extensions_

StringTracker *	string_tracker_

unibrow::Mapping< unibrow::Ecma262UnCanonicalize >	jsregexp_uncanonicalize_

unibrow::Mapping< unibrow::CanonicalizationRange >	jsregexp_canonrange_

ConsStringIteratorOp	objects_string_compare_iterator_a_

ConsStringIteratorOp	objects_string_compare_iterator_b_

StaticResource< ConsStringIteratorOp >	objects_string_iterator_

unibrow::Mapping< unibrow::Ecma262Canonicalize >	regexp_macro_assembler_canonicalize_

RegExpStack *	regexp_stack_

DateCache *	date_cache_

unibrow::Mapping< unibrow::Ecma262Canonicalize >	interp_canonicalize_mapping_

CallInterfaceDescriptorData *	call_descriptor_data_

base::RandomNumberGenerator *	random_number_generator_

bool	serializer_enabled_

bool	has_fatal_error_

bool	initialized_from_snapshot_

double	time_millis_at_init_

Debug *	debug_

CpuProfiler *	cpu_profiler_

HeapProfiler *	heap_profiler_

FunctionEntryHook	function_entry_hook_

DeferredHandles *	deferred_handles_head_

OptimizingCompilerThread *	optimizing_compiler_thread_

SweeperThread **	sweeper_thread_

int	num_sweeper_threads_

unsigned int	stress_deopt_count_

int	next_optimization_id_

List< CallCompletedCallback >	call_completed_callbacks_

v8::Isolate::UseCounterCallback	use_counter_callback_

BasicBlockProfiler *	basic_block_profiler_

Static Private Attributes
static base::LazyMutex	thread_data_table_mutex_ = LAZY_MUTEX_INITIALIZER

static base::Thread::LocalStorageKey	per_isolate_thread_data_key_

static base::Thread::LocalStorageKey	isolate_key_

static base::Thread::LocalStorageKey	thread_id_key_

static ThreadDataTable *	thread_data_table_ = NULL

static base::Atomic32	isolate_counter_ = 0

Friends
struct	GlobalState

struct	InitializeGlobalState

class	ExecutionAccess

class	HandleScopeImplementer

class	IsolateInitializer

class	OptimizingCompilerThread

class	SweeperThread

class	ThreadManager

class	Simulator

class	StackGuard

class	ThreadId

class	TestMemoryAllocatorScope

class	TestCodeRangeScope

class	v8::Isolate

class	v8::Locker

class	v8::Unlocker

Detailed Description

Definition at line 395 of file isolate.h.

Member Enumeration Documentation

◆ AddressId

enum v8::internal::Isolate::AddressId

Enumerator
kIsolateAddressCount

Definition at line 463 of file isolate.h.

                  {
 #define DECLARE_ENUM(CamelName, hacker_name) k##CamelName##Address,
     FOR_EACH_ISOLATE_ADDRESS_NAME(DECLARE_ENUM)
 #undef DECLARE_ENUM
     kIsolateAddressCount
   };

◆ State

enum v8::internal::Isolate::State

private

Enumerator
UNINITIALIZED
INITIALIZED

Definition at line 1122 of file isolate.h.

              {
     UNINITIALIZED,    // Some components may not have been allocated.
     INITIALIZED       // All components are fully initialized.
   };

Constructor & Destructor Documentation

◆ ~Isolate()

v8::internal::Isolate::~Isolate ( )

Definition at line 1683 of file isolate.cc.

                   {
   TRACE_ISOLATE(destructor);
  
   // Has to be called while counters_ are still alive
   runtime_zone_.DeleteKeptSegment();
  
   // The entry stack must be empty when we get here.
   DCHECK(entry_stack_ == NULL || entry_stack_->previous_item == NULL);
  
   delete entry_stack_;
   entry_stack_ = NULL;
  
   delete unicode_cache_;
   unicode_cache_ = NULL;
  
   delete date_cache_;
   date_cache_ = NULL;
  
   delete[] call_descriptor_data_;
   call_descriptor_data_ = NULL;
  
   delete regexp_stack_;
   regexp_stack_ = NULL;
  
   delete descriptor_lookup_cache_;
   descriptor_lookup_cache_ = NULL;
   delete context_slot_cache_;
   context_slot_cache_ = NULL;
   delete keyed_lookup_cache_;
   keyed_lookup_cache_ = NULL;
  
   delete stub_cache_;
   stub_cache_ = NULL;
   delete code_aging_helper_;
   code_aging_helper_ = NULL;
   delete stats_table_;
   stats_table_ = NULL;
  
   delete materialized_object_store_;
   materialized_object_store_ = NULL;
  
   delete logger_;
   logger_ = NULL;
  
   delete counters_;
   counters_ = NULL;
  
   delete handle_scope_implementer_;
   handle_scope_implementer_ = NULL;
  
   delete compilation_cache_;
   compilation_cache_ = NULL;
   delete bootstrapper_;
   bootstrapper_ = NULL;
   delete inner_pointer_to_code_cache_;
   inner_pointer_to_code_cache_ = NULL;
   delete write_iterator_;
   write_iterator_ = NULL;
  
   delete thread_manager_;
   thread_manager_ = NULL;
  
   delete string_tracker_;
   string_tracker_ = NULL;
  
   delete memory_allocator_;
   memory_allocator_ = NULL;
   delete code_range_;
   code_range_ = NULL;
   delete global_handles_;
   global_handles_ = NULL;
   delete eternal_handles_;
   eternal_handles_ = NULL;
  
   delete string_stream_debug_object_cache_;
   string_stream_debug_object_cache_ = NULL;
  
   delete external_reference_table_;
   external_reference_table_ = NULL;
  
   delete random_number_generator_;
   random_number_generator_ = NULL;
  
   delete debug_;
   debug_ = NULL;
 }

References bootstrapper_, call_descriptor_data_, code_aging_helper_, code_range_, compilation_cache_, context_slot_cache_, counters_, date_cache_, DCHECK, debug_, v8::internal::Zone::DeleteKeptSegment(), descriptor_lookup_cache_, entry_stack_, eternal_handles_, global_handles_, handle_scope_implementer_, inner_pointer_to_code_cache_, keyed_lookup_cache_, logger_, materialized_object_store_, memory_allocator_, NULL, v8::internal::Isolate::EntryStackItem::previous_item, random_number_generator_, regexp_stack_, runtime_zone_, stats_table_, string_tracker_, stub_cache_, thread_manager_, TRACE_ISOLATE, unicode_cache_, and write_iterator_.

Here is the call graph for this function:

◆ Isolate()

v8::internal::Isolate::Isolate ( )

private

Definition at line 1461 of file isolate.cc.

     : embedder_data_(),
       state_(UNINITIALIZED),
       entry_stack_(NULL),
       stack_trace_nesting_level_(0),
       incomplete_message_(NULL),
       bootstrapper_(NULL),
       runtime_profiler_(NULL),
       compilation_cache_(NULL),
       counters_(NULL),
       code_range_(NULL),
       logger_(NULL),
       stats_table_(NULL),
       stub_cache_(NULL),
       code_aging_helper_(NULL),
       deoptimizer_data_(NULL),
       materialized_object_store_(NULL),
       capture_stack_trace_for_uncaught_exceptions_(false),
       stack_trace_for_uncaught_exceptions_frame_limit_(0),
       stack_trace_for_uncaught_exceptions_options_(StackTrace::kOverview),
       memory_allocator_(NULL),
       keyed_lookup_cache_(NULL),
       context_slot_cache_(NULL),
       descriptor_lookup_cache_(NULL),
       handle_scope_implementer_(NULL),
       unicode_cache_(NULL),
       runtime_zone_(this),
       inner_pointer_to_code_cache_(NULL),
       write_iterator_(NULL),
       global_handles_(NULL),
       eternal_handles_(NULL),
       thread_manager_(NULL),
       has_installed_extensions_(false),
       string_tracker_(NULL),
       regexp_stack_(NULL),
       date_cache_(NULL),
       call_descriptor_data_(NULL),
       // TODO(bmeurer) Initialized lazily because it depends on flags; can
       // be fixed once the default isolate cleanup is done.
       random_number_generator_(NULL),
       serializer_enabled_(false),
       has_fatal_error_(false),
       initialized_from_snapshot_(false),
       cpu_profiler_(NULL),
       heap_profiler_(NULL),
       function_entry_hook_(NULL),
       deferred_handles_head_(NULL),
       optimizing_compiler_thread_(NULL),
       sweeper_thread_(NULL),
       num_sweeper_threads_(0),
       stress_deopt_count_(0),
       next_optimization_id_(0),
       use_counter_callback_(NULL),
       basic_block_profiler_(NULL) {
   {
     base::LockGuard<base::Mutex> lock_guard(thread_data_table_mutex_.Pointer());
     CHECK(thread_data_table_);
   }
   id_ = base::NoBarrier_AtomicIncrement(&isolate_counter_, 1);
   TRACE_ISOLATE(constructor);
  
   memset(isolate_addresses_, 0,
       sizeof(isolate_addresses_[0]) * (kIsolateAddressCount + 1));
  
   heap_.isolate_ = this;
   stack_guard_.isolate_ = this;
  
   // ThreadManager is initialized early to support locking an isolate
   // before it is entered.
   thread_manager_ = new ThreadManager();
   thread_manager_->isolate_ = this;
  
 #ifdef DEBUG
   // heap_histograms_ initializes itself.
   memset(&js_spill_information_, 0, sizeof(js_spill_information_));
 #endif
  
   handle_scope_data_.Initialize();
  
 #define ISOLATE_INIT_EXECUTE(type, name, initial_value)                        \
   name##_ = (initial_value);
   ISOLATE_INIT_LIST(ISOLATE_INIT_EXECUTE)
 #undef ISOLATE_INIT_EXECUTE
  
 #define ISOLATE_INIT_ARRAY_EXECUTE(type, name, length)                         \
   memset(name##_, 0, sizeof(type) * length);
   ISOLATE_INIT_ARRAY_LIST(ISOLATE_INIT_ARRAY_EXECUTE)
 #undef ISOLATE_INIT_ARRAY_EXECUTE
  
   InitializeLoggingAndCounters();
   debug_ = new Debug(this);
 }

References CHECK, debug_, handle_scope_data_, heap_, id_, v8::internal::HandleScopeData::Initialize(), InitializeLoggingAndCounters(), v8::internal::Heap::isolate_, v8::internal::ThreadManager::isolate_, isolate_addresses_, isolate_counter_, ISOLATE_INIT_ARRAY_EXECUTE, ISOLATE_INIT_ARRAY_LIST, ISOLATE_INIT_EXECUTE, ISOLATE_INIT_LIST, kIsolateAddressCount, v8::base::NoBarrier_AtomicIncrement(), v8::base::LazyInstanceImpl< T, AllocationTrait, CreateTrait, InitOnceTrait, DestroyTrait >::Pointer(), stack_guard_, thread_data_table_, thread_data_table_mutex_, thread_manager_, ThreadManager, and TRACE_ISOLATE.

Referenced by NewForTesting().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

◆ AddCallCompletedCallback()

void v8::internal::Isolate::AddCallCompletedCallback ( CallCompletedCallback callback )

Definition at line 2248 of file isolate.cc.

                                                                      {
   for (int i = 0; i < call_completed_callbacks_.length(); i++) {
     if (callback == call_completed_callbacks_.at(i)) return;
   }
   call_completed_callbacks_.Add(callback);
 }

References v8::internal::List< T, AllocationPolicy >::Add(), v8::internal::List< T, AllocationPolicy >::at(), and call_completed_callbacks_.

Referenced by v8::Isolate::AddCallCompletedCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ArchiveSpacePerThread()

static int v8::internal::Isolate::ArchiveSpacePerThread ( )

inlinestatic

Definition at line 683 of file isolate.h.

683 { return sizeof(ThreadLocalTop); }

Referenced by v8::internal::ArchiveSpacePerThread().

Here is the caller graph for this function:

◆ ArchiveThread()

char * v8::internal::Isolate::ArchiveThread ( char * to )

Definition at line 1369 of file isolate.cc.

                                      {
   MemCopy(to, reinterpret_cast<char*>(thread_local_top()),
           sizeof(ThreadLocalTop));
   InitializeThreadLocal();
   clear_pending_exception();
   clear_pending_message();
   clear_scheduled_exception();
   return to + sizeof(ThreadLocalTop);
 }

References clear_pending_exception(), clear_pending_message(), clear_scheduled_exception(), InitializeThreadLocal(), v8::internal::MemCopy(), thread_local_top(), and to().

Referenced by v8::internal::ThreadManager::EagerlyArchiveThread().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ basic_block_profiler()

BasicBlockProfiler* v8::internal::Isolate::basic_block_profiler ( )

inline

Definition at line 1112 of file isolate.h.

1112 { return basic_block_profiler_; }

References basic_block_profiler_.

◆ bootstrapper()

Bootstrapper* v8::internal::Isolate::bootstrapper ( )

inline

Definition at line 856 of file isolate.h.

856 { return bootstrapper_; }

References bootstrapper_.

Referenced by v8::internal::Scope::Analyze(), v8::internal::Heap::ClearJSFunctionResultCaches(), v8::internal::Heap::ClearNormalizedMapCaches(), v8::internal::Debug::CompileDebuggerScript(), v8::CreateEnvironment(), v8::Context::DetachGlobal(), DoThrow(), v8::internal::ThreadManager::EagerlyArchiveThread(), v8::internal::ThreadManager::FreeThreadResources(), v8::internal::JSObject::GetElementAttributeWithReceiver(), v8::internal::Debug::HandleDebugBreak(), v8::internal::Heap::IterateStrongRoots(), v8::internal::Debug::Load(), main(), v8::internal::CodeGenerator::MakeCodePrologue(), v8::internal::MayAccessPreCheck(), v8::internal::RuntimeProfiler::Optimize(), v8::internal::CodeGenerator::PrintCode(), v8::internal::Deserializer::ReadChunk(), v8::internal::ThreadManager::RestoreThread(), and v8::internal::JSFunction::SetInstancePrototype().

Here is the caller graph for this function:

◆ break_access()

base::RecursiveMutex* v8::internal::Isolate::break_access ( )

inline

Definition at line 543 of file isolate.h.

543 { return &break_access_; }

v8::internal::Isolate::break_access_

base::RecursiveMutex break_access_

Definition: isolate.h:1233

References break_access_.

Referenced by v8::internal::BASE_EMBEDDED< Visitor >::Lock(), v8::internal::BASE_EMBEDDED< Visitor >::TryLock(), and v8::internal::BASE_EMBEDDED< Visitor >::Unlock().

Here is the caller graph for this function:

◆ builtins()

Builtins* v8::internal::Isolate::builtins ( )

inline

Definition at line 947 of file isolate.h.

947 { return &builtins_; }

v8::internal::Isolate::builtins_

Builtins builtins_

Definition: isolate.h:1260

References builtins_.

Here is the caller graph for this function:

◆ c_entry_fp()

static Address v8::internal::Isolate::c_entry_fp ( ThreadLocalTop * thread )

inlinestatic

Definition at line 647 of file isolate.h.

                                                     {
     return thread->c_entry_fp_;
   }

Referenced by v8::internal::IC::IC(), v8::internal::SafeStackFrameIterator::IsValidTop(), PrintStack(), v8::internal::StackFrameIterator::Reset(), and v8::internal::SafeStackFrameIterator::SafeStackFrameIterator().

Here is the caller graph for this function:

◆ c_entry_fp_address()

Address* v8::internal::Isolate::c_entry_fp_address ( )

inline

Definition at line 652 of file isolate.h.

                                        {
     return &thread_local_top_.c_entry_fp_;
   }

References thread_local_top_.

◆ call_descriptor_data()

CallInterfaceDescriptorData * v8::internal::Isolate::call_descriptor_data ( int index )

Definition at line 2208 of file isolate.cc.

                                                                     {
   DCHECK(0 <= index && index < CallDescriptors::NUMBER_OF_DESCRIPTORS);
   return &call_descriptor_data_[index];
 }

References call_descriptor_data_, DCHECK, and v8::internal::CallDescriptors::NUMBER_OF_DESCRIPTORS.

Referenced by v8::internal::CallInterfaceDescriptor::DebugName().

Here is the caller graph for this function:

◆ CancelScheduledExceptionFromTryCatch()

void v8::internal::Isolate::CancelScheduledExceptionFromTryCatch ( v8::TryCatch * handler )

Definition at line 887 of file isolate.cc.

                                                                       {
   DCHECK(has_scheduled_exception());
   if (scheduled_exception() == handler->exception_) {
     DCHECK(scheduled_exception() != heap()->termination_exception());
     clear_scheduled_exception();
   }
 }

References clear_scheduled_exception(), DCHECK, handler(), has_scheduled_exception(), heap(), and scheduled_exception().

Here is the call graph for this function:

◆ CancelTerminateExecution()

void v8::internal::Isolate::CancelTerminateExecution ( )

Definition at line 795 of file isolate.cc.

                                        {
   if (try_catch_handler()) {
     try_catch_handler()->has_terminated_ = false;
   }
   if (has_pending_exception() &&
       pending_exception() == heap_.termination_exception()) {
     thread_local_top()->external_caught_exception_ = false;
     clear_pending_exception();
   }
   if (has_scheduled_exception() &&
       scheduled_exception() == heap_.termination_exception()) {
     thread_local_top()->external_caught_exception_ = false;
     clear_scheduled_exception();
   }
 }

References clear_pending_exception(), clear_scheduled_exception(), has_pending_exception(), has_scheduled_exception(), v8::TryCatch::has_terminated_, heap_, pending_exception(), scheduled_exception(), thread_local_top(), and try_catch_handler().

Referenced by v8::V8::CancelTerminateExecution().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CaptureAndSetDetailedStackTrace()

void v8::internal::Isolate::CaptureAndSetDetailedStackTrace ( Handle< JSObject > error_object )

Definition at line 418 of file isolate.cc.

                                                                            {
   if (capture_stack_trace_for_uncaught_exceptions_) {
     // Capture stack trace for a detailed exception message.
     Handle<Name> key = factory()->detailed_stack_trace_symbol();
     Handle<JSArray> stack_trace = CaptureCurrentStackTrace(
         stack_trace_for_uncaught_exceptions_frame_limit_,
         stack_trace_for_uncaught_exceptions_options_);
     JSObject::SetProperty(error_object, key, stack_trace, STRICT).Assert();
   }
 }

References capture_stack_trace_for_uncaught_exceptions_, CaptureCurrentStackTrace(), factory(), v8::internal::Object::SetProperty(), stack_trace_for_uncaught_exceptions_frame_limit_, stack_trace_for_uncaught_exceptions_options_, and v8::internal::STRICT.

Here is the call graph for this function:

◆ CaptureAndSetSimpleStackTrace()

void v8::internal::Isolate::CaptureAndSetSimpleStackTrace	(	Handle< JSObject >	error_object,
		Handle< Object >	caller
	)

Definition at line 430 of file isolate.cc.

                                                                    {
   // Capture stack trace for simple stack trace string formatting.
   Handle<Name> key = factory()->stack_trace_symbol();
   Handle<Object> stack_trace = CaptureSimpleStackTrace(error_object, caller);
   JSObject::SetProperty(error_object, key, stack_trace, STRICT).Assert();
 }

References CaptureSimpleStackTrace(), factory(), v8::internal::Object::SetProperty(), and v8::internal::STRICT.

Referenced by StackOverflow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CaptureCurrentStackTrace()

Handle< JSArray > v8::internal::Isolate::CaptureCurrentStackTrace	(	int	frame_limit,
		StackTrace::StackTraceOptions	options
	)

Definition at line 439 of file isolate.cc.

                                                           {
   // Ensure no negative values.
   int limit = Max(frame_limit, 0);
   Handle<JSArray> stack_trace = factory()->NewJSArray(frame_limit);
  
   Handle<String> column_key =
       factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("column"));
   Handle<String> line_key =
       factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("lineNumber"));
   Handle<String> script_id_key =
       factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("scriptId"));
   Handle<String> script_name_key =
       factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("scriptName"));
   Handle<String> script_name_or_source_url_key =
       factory()->InternalizeOneByteString(
           STATIC_CHAR_VECTOR("scriptNameOrSourceURL"));
   Handle<String> function_key =
       factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("functionName"));
   Handle<String> eval_key =
       factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("isEval"));
   Handle<String> constructor_key =
       factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("isConstructor"));
  
   StackTraceFrameIterator it(this);
   int frames_seen = 0;
   while (!it.done() && (frames_seen < limit)) {
     JavaScriptFrame* frame = it.frame();
     // Set initial size to the maximum inlining level + 1 for the outermost
     // function.
     List<FrameSummary> frames(FLAG_max_inlining_levels + 1);
     frame->Summarize(&frames);
     for (int i = frames.length() - 1; i >= 0 && frames_seen < limit; i--) {
       Handle<JSFunction> fun = frames[i].function();
       // Filter frames from other security contexts.
       if (!(options & StackTrace::kExposeFramesAcrossSecurityOrigins) &&
           !this->context()->HasSameSecurityTokenAs(fun->context())) continue;
  
       // Create a JSObject to hold the information for the StackFrame.
       Handle<JSObject> stack_frame = factory()->NewJSObject(object_function());
  
       Handle<Script> script(Script::cast(fun->shared()->script()));
  
       if (options & StackTrace::kLineNumber) {
         int script_line_offset = script->line_offset()->value();
         int position = frames[i].code()->SourcePosition(frames[i].pc());
         int line_number = Script::GetLineNumber(script, position);
         // line_number is already shifted by the script_line_offset.
         int relative_line_number = line_number - script_line_offset;
         if (options & StackTrace::kColumnOffset && relative_line_number >= 0) {
           Handle<FixedArray> line_ends(FixedArray::cast(script->line_ends()));
           int start = (relative_line_number == 0) ? 0 :
               Smi::cast(line_ends->get(relative_line_number - 1))->value() + 1;
           int column_offset = position - start;
           if (relative_line_number == 0) {
             // For the case where the code is on the same line as the script
             // tag.
             column_offset += script->column_offset()->value();
           }
           JSObject::AddProperty(
               stack_frame, column_key,
               handle(Smi::FromInt(column_offset + 1), this), NONE);
         }
        JSObject::AddProperty(
             stack_frame, line_key,
             handle(Smi::FromInt(line_number + 1), this), NONE);
       }
  
       if (options & StackTrace::kScriptId) {
         JSObject::AddProperty(
             stack_frame, script_id_key, handle(script->id(), this), NONE);
       }
  
       if (options & StackTrace::kScriptName) {
         JSObject::AddProperty(
             stack_frame, script_name_key, handle(script->name(), this), NONE);
       }
  
       if (options & StackTrace::kScriptNameOrSourceURL) {
         Handle<Object> result = Script::GetNameOrSourceURL(script);
         JSObject::AddProperty(
             stack_frame, script_name_or_source_url_key, result, NONE);
       }
  
       if (options & StackTrace::kFunctionName) {
         Handle<Object> fun_name(fun->shared()->DebugName(), this);
         JSObject::AddProperty(stack_frame, function_key, fun_name, NONE);
       }
  
       if (options & StackTrace::kIsEval) {
         Handle<Object> is_eval =
             script->compilation_type() == Script::COMPILATION_TYPE_EVAL ?
                 factory()->true_value() : factory()->false_value();
         JSObject::AddProperty(stack_frame, eval_key, is_eval, NONE);
       }
  
       if (options & StackTrace::kIsConstructor) {
         Handle<Object> is_constructor = (frames[i].is_constructor()) ?
             factory()->true_value() : factory()->false_value();
         JSObject::AddProperty(
             stack_frame, constructor_key, is_constructor, NONE);
       }
  
       FixedArray::cast(stack_trace->elements())->set(frames_seen, *stack_frame);
       frames_seen++;
     }
     it.Advance();
   }
  
   stack_trace->set_length(Smi::FromInt(frames_seen));
   return stack_trace;
 }

References v8::internal::JSObject::AddProperty(), v8::internal::StackTraceFrameIterator::Advance(), v8::internal::Script::COMPILATION_TYPE_EVAL, context(), factory(), v8::internal::Smi::FromInt(), v8::internal::Script::GetLineNumber(), v8::internal::Script::GetNameOrSourceURL(), v8::internal::handle(), v8::StackTrace::kColumnOffset, v8::StackTrace::kExposeFramesAcrossSecurityOrigins, v8::StackTrace::kFunctionName, v8::StackTrace::kIsConstructor, v8::StackTrace::kIsEval, v8::StackTrace::kLineNumber, v8::StackTrace::kScriptId, v8::StackTrace::kScriptName, v8::StackTrace::kScriptNameOrSourceURL, v8::internal::Max(), NONE, v8::internal::pc, STATIC_CHAR_VECTOR, and v8::internal::JavaScriptFrame::Summarize().

Referenced by CaptureAndSetDetailedStackTrace(), v8::StackTrace::CurrentStackTrace(), and DoThrow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CaptureSimpleStackTrace()

Handle< Object > v8::internal::Isolate::CaptureSimpleStackTrace	(	Handle< JSObject >	error_object,
		Handle< Object >	caller
	)

Definition at line 335 of file isolate.cc.

                                                                        {
   // Get stack trace limit.
   Handle<Object> error = Object::GetProperty(
       this, js_builtins_object(), "$Error").ToHandleChecked();
   if (!error->IsJSObject()) return factory()->undefined_value();
  
   Handle<String> stackTraceLimit =
       factory()->InternalizeUtf8String("stackTraceLimit");
   DCHECK(!stackTraceLimit.is_null());
   Handle<Object> stack_trace_limit =
       JSObject::GetDataProperty(Handle<JSObject>::cast(error),
                                 stackTraceLimit);
   if (!stack_trace_limit->IsNumber()) return factory()->undefined_value();
   int limit = FastD2IChecked(stack_trace_limit->Number());
   limit = Max(limit, 0);  // Ensure that limit is not negative.
  
   int initial_size = Min(limit, 10);
   Handle<FixedArray> elements =
       factory()->NewFixedArrayWithHoles(initial_size * 4 + 1);
  
   // If the caller parameter is a function we skip frames until we're
   // under it before starting to collect.
   bool seen_caller = !caller->IsJSFunction();
   // First element is reserved to store the number of sloppy frames.
   int cursor = 1;
   int frames_seen = 0;
   int sloppy_frames = 0;
   bool encountered_strict_function = false;
   for (JavaScriptFrameIterator iter(this);
        !iter.done() && frames_seen < limit;
        iter.Advance()) {
     JavaScriptFrame* frame = iter.frame();
     // Set initial size to the maximum inlining level + 1 for the outermost
     // function.
     List<FrameSummary> frames(FLAG_max_inlining_levels + 1);
     frame->Summarize(&frames);
     for (int i = frames.length() - 1; i >= 0; i--) {
       Handle<JSFunction> fun = frames[i].function();
       Handle<Object> recv = frames[i].receiver();
       // Filter out internal frames that we do not want to show.
       if (!IsVisibleInStackTrace(*fun, *caller, *recv, &seen_caller)) continue;
       // Filter out frames from other security contexts.
       if (!this->context()->HasSameSecurityTokenAs(fun->context())) continue;
       if (cursor + 4 > elements->length()) {
         int new_capacity = JSObject::NewElementsCapacity(elements->length());
         Handle<FixedArray> new_elements =
             factory()->NewFixedArrayWithHoles(new_capacity);
         for (int i = 0; i < cursor; i++) {
           new_elements->set(i, elements->get(i));
         }
         elements = new_elements;
       }
       DCHECK(cursor + 4 <= elements->length());
  
  
       Handle<Code> code = frames[i].code();
       Handle<Smi> offset(Smi::FromInt(frames[i].offset()), this);
       // The stack trace API should not expose receivers and function
       // objects on frames deeper than the top-most one with a strict
       // mode function.  The number of sloppy frames is stored as
       // first element in the result array.
       if (!encountered_strict_function) {
         if (fun->shared()->strict_mode() == STRICT) {
           encountered_strict_function = true;
         } else {
           sloppy_frames++;
         }
       }
       elements->set(cursor++, *recv);
       elements->set(cursor++, *fun);
       elements->set(cursor++, *code);
       elements->set(cursor++, *offset);
       frames_seen++;
     }
   }
   elements->set(0, Smi::FromInt(sloppy_frames));
   Handle<JSArray> result = factory()->NewJSArrayWithElements(elements);
   result->set_length(Smi::FromInt(cursor));
   return result;
 }

References context(), DCHECK, factory(), v8::internal::FastD2IChecked(), v8::internal::Smi::FromInt(), v8::internal::JSObject::GetDataProperty(), v8::internal::Object::GetProperty(), v8::internal::Handle< T >::is_null(), v8::internal::IsVisibleInStackTrace(), js_builtins_object(), v8::internal::Max(), v8::internal::Min(), v8::internal::JSObject::NewElementsCapacity(), v8::internal::STRICT, and v8::internal::JavaScriptFrame::Summarize().

Referenced by CaptureAndSetSimpleStackTrace().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clear_pending_exception()

void v8::internal::Isolate::clear_pending_exception ( )

inline

Definition at line 572 of file isolate.h.

                                  {
     DCHECK(!thread_local_top_.pending_exception_->IsException());
     thread_local_top_.pending_exception_ = heap_.the_hole_value();
   }

References DCHECK, heap_, and thread_local_top_.

Referenced by ArchiveThread(), CancelTerminateExecution(), v8::internal::Debug::CompileDebuggerScript(), v8::internal::LiveEdit::GatherCompileInfo(), v8::internal::Compiler::GetDebugCode(), v8::internal::Compiler::GetOptimizedCode(), Init(), OptionalRescheduleException(), v8::internal::MessageHandler::ReportMessage(), and ScheduleThrow().

Here is the caller graph for this function:

◆ clear_pending_message()

void v8::internal::Isolate::clear_pending_message ( )

inline

Definition at line 588 of file isolate.h.

                                {
     thread_local_top_.has_pending_message_ = false;
     thread_local_top_.pending_message_obj_ = heap_.the_hole_value();
     thread_local_top_.pending_message_script_ = heap_.the_hole_value();
   }

References heap_, and thread_local_top_.

Referenced by ArchiveThread(), v8::internal::LiveEdit::GatherCompileInfo(), Init(), v8::internal::Invoke(), and ReportPendingMessages().

Here is the caller graph for this function:

◆ clear_scheduled_exception()

void v8::internal::Isolate::clear_scheduled_exception ( )

inline

Definition at line 631 of file isolate.h.

                                    {
     DCHECK(!thread_local_top_.scheduled_exception_->IsException());
     thread_local_top_.scheduled_exception_ = heap_.the_hole_value();
   }

References DCHECK, heap_, and thread_local_top_.

Referenced by ArchiveThread(), CancelScheduledExceptionFromTryCatch(), CancelTerminateExecution(), Init(), v8::internal::Debug::OnThrow(), PromoteScheduledException(), and v8::internal::MessageHandler::ReportMessage().

Here is the caller graph for this function:

◆ code_aging_helper()

CodeAgingHelper* v8::internal::Isolate::code_aging_helper ( )

inline

Definition at line 876 of file isolate.h.

876 { return code_aging_helper_; }

References code_aging_helper_.

◆ code_range()

CodeRange* v8::internal::Isolate::code_range ( )

inline

Definition at line 863 of file isolate.h.

863 { return code_range_; }

References code_range_.

Referenced by v8::internal::MemoryAllocator::AllocateChunk(), v8::internal::Heap::AllocateCode(), v8::internal::MemoryChunk::CommitArea(), v8::internal::Heap::CopyCode(), v8::internal::MemoryAllocator::FreeMemory(), v8::Isolate::GetCodeRange(), v8::internal::Assembler::runtime_entry_at(), v8::internal::Heap::SetUp(), and v8::internal::PagedSpace::SizeOfFirstPage().

Here is the caller graph for this function:

◆ compilation_cache()

CompilationCache* v8::internal::Isolate::compilation_cache ( )

inline

Definition at line 865 of file isolate.h.

865 { return compilation_cache_; }

References compilation_cache_.

Referenced by v8::internal::Heap::AdvanceIdleIncrementalMarking(), v8::internal::Heap::CollectAllAvailableGarbage(), v8::internal::RegExpImpl::Compile(), v8::internal::Compiler::CompileScript(), v8::internal::Heap::CreateInitialObjects(), v8::internal::Compiler::GetFunctionFromEval(), v8::internal::Heap::IterateStrongRoots(), v8::internal::Heap::MarkCompactPrologue(), v8::internal::MarkCompactCollector::PrepareForCodeFlushing(), v8::internal::LiveEdit::ReplaceFunctionCode(), v8::internal::IncrementalMarking::StartMarking(), and v8::internal::Debug::UpdateState().

Here is the caller graph for this function:

◆ ComputeLocation()

void v8::internal::Isolate::ComputeLocation ( MessageLocation * target )

Definition at line 932 of file isolate.cc.

                                                      {
   *target = MessageLocation(Handle<Script>(heap_.empty_script()), -1, -1);
   StackTraceFrameIterator it(this);
   if (!it.done()) {
     JavaScriptFrame* frame = it.frame();
     JSFunction* fun = frame->function();
     Object* script = fun->shared()->script();
     if (script->IsScript() &&
         !(Script::cast(script)->source()->IsUndefined())) {
       int pos = frame->LookupCode()->SourcePosition(frame->pc());
       // Compute the location from the function and the reloc info.
       Handle<Script> casted_script(Script::cast(script));
       *target = MessageLocation(casted_script, pos, pos + 1);
     }
   }
 }

References v8::internal::JavaScriptFrame::function(), and heap_.

Referenced by v8::internal::Debug::CompileDebuggerScript(), and DoThrow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ concurrent_osr_enabled()

bool v8::internal::Isolate::concurrent_osr_enabled ( ) const

inline

Definition at line 1052 of file isolate.h.

                                       {
     // Thread is only available with flag enabled.
     DCHECK(optimizing_compiler_thread_ == NULL ||
            FLAG_concurrent_recompilation);
     return optimizing_compiler_thread_ != NULL && FLAG_concurrent_osr;
   }

References DCHECK, NULL, and optimizing_compiler_thread_.

Referenced by v8::internal::RuntimeProfiler::Optimize().

Here is the caller graph for this function:

◆ concurrent_recompilation_enabled()

bool v8::internal::Isolate::concurrent_recompilation_enabled ( )

inline

Definition at line 1045 of file isolate.h.

                                           {
     // Thread is only available with flag enabled.
     DCHECK(optimizing_compiler_thread_ == NULL ||
            FLAG_concurrent_recompilation);
     return optimizing_compiler_thread_ != NULL;
   }

References DCHECK, NULL, and optimizing_compiler_thread_.

Referenced by Deinit(), v8::internal::RuntimeProfiler::Optimize(), and v8::internal::Debug::PrepareForBreakPoints().

Here is the caller graph for this function:

◆ context()

Context* v8::internal::Isolate::context ( )

inline

Definition at line 548 of file isolate.h.

548 { return thread_local_top_.context_; }

References thread_local_top_.

Referenced by v8::internal::Debug::AssertDebugContext(), CaptureCurrentStackTrace(), CaptureSimpleStackTrace(), v8::internal::CompileGlobalEval(), v8::internal::ComputeReceiverForNonGlobal(), v8::internal::Runtime::CreateArrayLiteralBoilerplate(), v8::Context::Enter(), v8::internal::FindCaller(), get_initial_js_array_map(), GetCallingNativeContext(), v8::Isolate::GetCurrentContext(), v8::internal::Object::GetRootMap(), v8::internal::GetTypedArrayFun(), global_context(), global_object(), global_proxy(), v8::Isolate::InContext(), v8::internal::IsJSArrayFastElementMovingAllowed(), v8::internal::MayAccessPreCheck(), MayIndexedAccess(), MayNamedAccess(), native_context(), v8::internal::NewSloppyArguments(), v8::internal::JSObject::ReferencesObject(), ReportFailedAccessCheck(), RestoreThread(), set_context(), v8::internal::JSFunction::SetPrototype(), v8::internal::Object::ToObject(), and v8::internal::Map::TransitionElementsTo().

Here is the caller graph for this function:

◆ context_address()

Context** v8::internal::Isolate::context_address ( )

inline

Definition at line 553 of file isolate.h.

553 { return &thread_local_top_.context_; }

References thread_local_top_.

◆ context_slot_cache()

ContextSlotCache* v8::internal::Isolate::context_slot_cache ( )

inline

Definition at line 891 of file isolate.h.

                                          {
     return context_slot_cache_;
   }

References context_slot_cache_.

Referenced by v8::internal::Heap::CreateInitialObjects(), and v8::internal::Heap::MarkCompactPrologue().

Here is the caller graph for this function:

◆ counters()

Counters* v8::internal::Isolate::counters ( )

inline

Definition at line 857 of file isolate.h.

                        {
     // Call InitializeLoggingAndCounters() if logging is needed before
     // the isolate is fully initialized.
     DCHECK(counters_ != NULL);
     return counters_;
   }

References counters_, DCHECK, and NULL.

Here is the caller graph for this function:

◆ CountUsage()

void v8::internal::Isolate::CountUsage ( v8::Isolate::UseCounterFeature feature )

Definition at line 2358 of file isolate.cc.

                                                            {
   if (use_counter_callback_) {
     use_counter_callback_(reinterpret_cast<v8::Isolate*>(this), feature);
   }
 }

References use_counter_callback_.

Referenced by v8::internal::Parser::Internalize().

Here is the caller graph for this function:

◆ cpu_profiler()

CpuProfiler* v8::internal::Isolate::cpu_profiler ( ) const

inline

Definition at line 971 of file isolate.h.

971 { return cpu_profiler_; }

References cpu_profiler_.

Referenced by v8::CpuProfile::Delete(), v8::internal::CompilationInfo::Initialize(), v8::internal::Heap::OnMoveEvent(), v8::internal::RecordFunctionCompilation(), v8::internal::Sampler::SampleStack(), and v8::internal::Heap::SelectScavengingVisitorsTable().

Here is the caller graph for this function:

◆ CurrentPerIsolateThreadData()

static PerIsolateThreadData* v8::internal::Isolate::CurrentPerIsolateThreadData ( )

inlinestatic

Definition at line 474 of file isolate.h.

                                                              {
     return reinterpret_cast<PerIsolateThreadData*>(
         base::Thread::GetThreadLocal(per_isolate_thread_data_key_));
   }

References v8::base::Thread::GetThreadLocal(), and per_isolate_thread_data_key_.

Referenced by Enter(), Exit(), and TearDown().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ date_cache()

DateCache* v8::internal::Isolate::date_cache ( )

inline

Definition at line 1020 of file isolate.h.

                           {
     return date_cache_;
   }

References date_cache_.

Referenced by v8::Date::DateTimeConfigurationChangeNotification(), v8::internal::JSDate::DoGetField(), and set_date_cache().

Here is the caller graph for this function:

◆ debug()

Debug* v8::internal::Isolate::debug ( )

inline

Definition at line 967 of file isolate.h.

967 { return debug_; }

References debug_.

Referenced by v8::internal::IC::address(), v8::Debug::Call(), v8::internal::LiveEdit::ChangeScriptSource(), v8::internal::CheckExecutionState(), v8::internal::Compiler::CompileScript(), v8::internal::CompileToplevel(), v8::internal::IC::constant_pool(), v8::Debug::DebugBreakForCommand(), v8::internal::DebugEvaluate(), Deinit(), DoThrow(), v8::internal::DropActivationsInActiveThreadImpl(), v8::internal::ThreadManager::EagerlyArchiveThread(), v8::internal::ThreadManager::FreeThreadResources(), v8::internal::GetDebugEventContext(), v8::Debug::GetMirror(), v8::internal::Object::GetPropertyWithDefinedGetter(), v8::internal::CompilationInfo::Initialize(), v8::internal::Invoke(), v8::internal::ThreadManager::RestoreThread(), v8::internal::Runtime_NewObjectHelper(), v8::internal::ScopeIterator::ScopeIterator(), v8::Debug::SendCommand(), v8::Debug::SetDebugEventListener(), v8::internal::V8HeapExplorer::SetGcSubrootReference(), v8::Debug::SetLiveEditEnabled(), v8::Debug::SetMessageHandler(), v8::internal::Object::SetPropertyWithDefinedSetter(), v8::internal::Parser::ThrowPendingError(), and v8::internal::RelocInfo::Visit().

Here is the caller graph for this function:

◆ DebuggerHasBreakPoints()

bool v8::internal::Isolate::DebuggerHasBreakPoints ( )

inline

Definition at line 28 of file isolate-inl.h.

                                      {
   return debug()->has_break_points();
 }

Referenced by v8::internal::RuntimeProfiler::AttemptOnStackReplacement(), v8::internal::Compiler::DebuggerWantsEagerCompilation(), v8::internal::Compiler::GetConcurrentlyOptimizedCode(), v8::internal::Compiler::GetLazyCode(), and v8::internal::RuntimeProfiler::OptimizeNow().

Here is the caller graph for this function:

◆ Deinit()

void v8::internal::Isolate::Deinit ( )

private

Definition at line 1591 of file isolate.cc.

                      {
   if (state_ == INITIALIZED) {
     TRACE_ISOLATE(deinit);
  
     debug()->Unload();
  
     FreeThreadResources();
  
     if (concurrent_recompilation_enabled()) {
       optimizing_compiler_thread_->Stop();
       delete optimizing_compiler_thread_;
       optimizing_compiler_thread_ = NULL;
     }
  
     for (int i = 0; i < num_sweeper_threads_; i++) {
       sweeper_thread_[i]->Stop();
       delete sweeper_thread_[i];
       sweeper_thread_[i] = NULL;
     }
     delete[] sweeper_thread_;
     sweeper_thread_ = NULL;
  
     if (FLAG_job_based_sweeping &&
         heap_.mark_compact_collector()->sweeping_in_progress()) {
       heap_.mark_compact_collector()->EnsureSweepingCompleted();
     }
  
     if (FLAG_turbo_stats) GetTStatistics()->Print("TurboFan");
     if (FLAG_hydrogen_stats) GetHStatistics()->Print("Hydrogen");
  
     if (FLAG_print_deopt_stress) {
       PrintF(stdout, "=== Stress deopt counter: %u\n", stress_deopt_count_);
     }
  
     // We must stop the logger before we tear down other components.
     Sampler* sampler = logger_->sampler();
     if (sampler && sampler->IsActive()) sampler->Stop();
  
     delete deoptimizer_data_;
     deoptimizer_data_ = NULL;
     builtins_.TearDown();
     bootstrapper_->TearDown();
  
     if (runtime_profiler_ != NULL) {
       delete runtime_profiler_;
       runtime_profiler_ = NULL;
     }
  
     delete basic_block_profiler_;
     basic_block_profiler_ = NULL;
  
     heap_.TearDown();
     logger_->TearDown();
  
     delete heap_profiler_;
     heap_profiler_ = NULL;
     delete cpu_profiler_;
     cpu_profiler_ = NULL;
  
     // The default isolate is re-initializable due to legacy API.
     state_ = UNINITIALIZED;
   }
 }

References basic_block_profiler_, bootstrapper_, builtins_, concurrent_recompilation_enabled(), cpu_profiler_, debug(), deoptimizer_data_, v8::internal::MarkCompactCollector::EnsureSweepingCompleted(), FreeThreadResources(), GetHStatistics(), GetTStatistics(), heap_, heap_profiler_, INITIALIZED, v8::internal::Sampler::IsActive(), logger_, v8::internal::Heap::mark_compact_collector(), NULL, num_sweeper_threads_, optimizing_compiler_thread_, v8::internal::PrintF(), runtime_profiler_, v8::internal::Logger::sampler(), state_, v8::internal::SweeperThread::Stop(), v8::internal::OptimizingCompilerThread::Stop(), v8::internal::Sampler::Stop(), stress_deopt_count_, sweeper_thread_, v8::internal::MarkCompactCollector::sweeping_in_progress(), v8::internal::Builtins::TearDown(), v8::internal::Heap::TearDown(), v8::internal::Logger::TearDown(), TRACE_ISOLATE, UNINITIALIZED, and v8::internal::Debug::Unload().

Referenced by TearDown().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ deoptimizer_data()

DeoptimizerData* v8::internal::Isolate::deoptimizer_data ( )

inline

Definition at line 877 of file isolate.h.

877 { return deoptimizer_data_; }

References deoptimizer_data_.

Referenced by v8::internal::Deoptimizer::DebuggerInspectableFrame(), v8::internal::Deoptimizer::DeleteDebuggerInspectableFrame(), v8::internal::Deoptimizer::EnsureCodeForDeoptimizationEntry(), v8::internal::Deoptimizer::GetDeoptimizationEntry(), v8::internal::Deoptimizer::GetDeoptimizationId(), v8::internal::Deoptimizer::Grab(), v8::internal::Heap::IterateStrongRoots(), and v8::internal::Deoptimizer::New().

Here is the caller graph for this function:

◆ descriptor_lookup_cache()

DescriptorLookupCache* v8::internal::Isolate::descriptor_lookup_cache ( )

inline

Definition at line 895 of file isolate.h.

                                                    {
     return descriptor_lookup_cache_;
   }

References descriptor_lookup_cache_.

Referenced by v8::internal::Heap::CreateInitialObjects(), v8::internal::Heap::MarkCompactPrologue(), and v8::internal::Heap::Scavenge().

Here is the caller graph for this function:

◆ DISALLOW_COPY_AND_ASSIGN()

v8::internal::Isolate::DISALLOW_COPY_AND_ASSIGN ( Isolate )

private

◆ DoThrow()

void v8::internal::Isolate::DoThrow	(	Object *	exception,
		MessageLocation *	location
	)

Definition at line 1003 of file isolate.cc.

                                                                   {
   DCHECK(!has_pending_exception());
  
   HandleScope scope(this);
   Handle<Object> exception_handle(exception, this);
  
   // Determine reporting and whether the exception is caught externally.
   bool catchable_by_javascript = is_catchable_by_javascript(exception);
   bool can_be_caught_externally = false;
   bool should_report_exception =
       ShouldReportException(&can_be_caught_externally, catchable_by_javascript);
   bool report_exception = catchable_by_javascript && should_report_exception;
   bool try_catch_needs_message =
       can_be_caught_externally && try_catch_handler()->capture_message_;
   bool bootstrapping = bootstrapper()->IsActive();
   bool rethrowing_message = thread_local_top()->rethrowing_message_;
  
   thread_local_top()->rethrowing_message_ = false;
  
   // Notify debugger of exception.
   if (catchable_by_javascript) {
     debug()->OnThrow(exception_handle, report_exception);
   }
  
   // Generate the message if required.
   if (!rethrowing_message && (report_exception || try_catch_needs_message)) {
     MessageLocation potential_computed_location;
     if (location == NULL) {
       // If no location was specified we use a computed one instead.
       ComputeLocation(&potential_computed_location);
       location = &potential_computed_location;
     }
     // It's not safe to try to make message objects or collect stack traces
     // while the bootstrapper is active since the infrastructure may not have
     // been properly initialized.
     if (!bootstrapping) {
       Handle<JSArray> stack_trace_object;
       if (capture_stack_trace_for_uncaught_exceptions_) {
         if (IsErrorObject(exception_handle)) {
           // We fetch the stack trace that corresponds to this error object.
           Handle<Name> key = factory()->detailed_stack_trace_symbol();
           // Look up as own property.  If the lookup fails, the exception is
           // probably not a valid Error object.  In that case, we fall through
           // and capture the stack trace at this throw site.
           LookupIterator lookup(exception_handle, key,
                                 LookupIterator::OWN_SKIP_INTERCEPTOR);
           Handle<Object> stack_trace_property;
           if (Object::GetProperty(&lookup).ToHandle(&stack_trace_property) &&
               stack_trace_property->IsJSArray()) {
             stack_trace_object = Handle<JSArray>::cast(stack_trace_property);
           }
         }
         if (stack_trace_object.is_null()) {
           // Not an error object, we capture at throw site.
           stack_trace_object = CaptureCurrentStackTrace(
               stack_trace_for_uncaught_exceptions_frame_limit_,
               stack_trace_for_uncaught_exceptions_options_);
         }
       }
  
       Handle<Object> exception_arg = exception_handle;
       // If the exception argument is a custom object, turn it into a string
       // before throwing as uncaught exception.  Note that the pending
       // exception object to be set later must not be turned into a string.
       if (exception_arg->IsJSObject() && !IsErrorObject(exception_arg)) {
         MaybeHandle<Object> maybe_exception =
             Execution::ToDetailString(this, exception_arg);
         if (!maybe_exception.ToHandle(&exception_arg)) {
           exception_arg = factory()->InternalizeOneByteString(
               STATIC_CHAR_VECTOR("exception"));
         }
       }
       Handle<Object> message_obj = MessageHandler::MakeMessageObject(
           this,
           "uncaught_exception",
           location,
           HandleVector<Object>(&exception_arg, 1),
           stack_trace_object);
       thread_local_top()->pending_message_obj_ = *message_obj;
       if (location != NULL) {
         thread_local_top()->pending_message_script_ = *location->script();
         thread_local_top()->pending_message_start_pos_ = location->start_pos();
         thread_local_top()->pending_message_end_pos_ = location->end_pos();
       }
  
       // If the abort-on-uncaught-exception flag is specified, abort on any
       // exception not caught by JavaScript, even when an external handler is
       // present.  This flag is intended for use by JavaScript developers, so
       // print a user-friendly stack trace (not an internal one).
       if (fatal_exception_depth == 0 &&
           FLAG_abort_on_uncaught_exception &&
           (report_exception || can_be_caught_externally)) {
         fatal_exception_depth++;
         PrintF(stderr,
                "%s\n\nFROM\n",
                MessageHandler::GetLocalizedMessage(this, message_obj).get());
         PrintCurrentStackTrace(stderr);
         base::OS::Abort();
       }
     } else if (location != NULL && !location->script().is_null()) {
       // We are bootstrapping and caught an error where the location is set
       // and we have a script for the location.
       // In this case we could have an extension (or an internal error
       // somewhere) and we print out the line number at which the error occured
       // to the console for easier debugging.
       int line_number =
           location->script()->GetLineNumber(location->start_pos()) + 1;
       if (exception->IsString() && location->script()->name()->IsString()) {
         base::OS::PrintError(
             "Extension or internal compilation error: %s in %s at line %d.\n",
             String::cast(exception)->ToCString().get(),
             String::cast(location->script()->name())->ToCString().get(),
             line_number);
       } else if (location->script()->name()->IsString()) {
         base::OS::PrintError(
             "Extension or internal compilation error in %s at line %d.\n",
             String::cast(location->script()->name())->ToCString().get(),
             line_number);
       } else {
         base::OS::PrintError("Extension or internal compilation error.\n");
       }
 #ifdef OBJECT_PRINT
       // Since comments and empty lines have been stripped from the source of
       // builtins, print the actual source here so that line numbers match.
       if (location->script()->source()->IsString()) {
         Handle<String> src(String::cast(location->script()->source()));
         PrintF("Failing script:\n");
         int len = src->length();
         int line_number = 1;
         PrintF("%5d: ", line_number);
         for (int i = 0; i < len; i++) {
           uint16_t character = src->Get(i);
           PrintF("%c", character);
           if (character == '\n' && i < len - 2) {
             PrintF("%5d: ", ++line_number);
           }
         }
       }
 #endif
     }
   }
  
   // Save the message for reporting if the the exception remains uncaught.
   thread_local_top()->has_pending_message_ = report_exception;
  
   // Do not forget to clean catcher_ if currently thrown exception cannot
   // be caught.  If necessary, ReThrow will update the catcher.
   thread_local_top()->catcher_ = can_be_caught_externally ?
       try_catch_handler() : NULL;
  
   set_pending_exception(*exception_handle);
 }

References v8::base::OS::Abort(), bootstrapper(), v8::TryCatch::capture_message_, capture_stack_trace_for_uncaught_exceptions_, CaptureCurrentStackTrace(), v8::internal::Handle< T >::cast(), ComputeLocation(), DCHECK, debug(), v8::internal::MessageLocation::end_pos(), factory(), v8::internal::fatal_exception_depth, v8::internal::MessageHandler::GetLocalizedMessage(), v8::internal::Object::GetProperty(), has_pending_exception(), is_catchable_by_javascript(), v8::internal::Handle< T >::is_null(), IsErrorObject(), v8::internal::MessageHandler::MakeMessageObject(), NULL, v8::internal::Debug::OnThrow(), PrintCurrentStackTrace(), v8::base::OS::PrintError(), v8::internal::PrintF(), v8::internal::MessageLocation::script(), set_pending_exception(), ShouldReportException(), stack_trace_for_uncaught_exceptions_frame_limit_, stack_trace_for_uncaught_exceptions_options_, v8::internal::MessageLocation::start_pos(), STATIC_CHAR_VECTOR, thread_local_top(), and try_catch_handler().

Referenced by StackOverflow(), TerminateExecution(), and Throw().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ enable_serializer()

void v8::internal::Isolate::enable_serializer ( )

inline

Definition at line 1001 of file isolate.h.

                            {
     // The serializer can only be enabled before the isolate init.
     DCHECK(state_ != INITIALIZED);
     serializer_enabled_ = true;
   }

References DCHECK, INITIALIZED, serializer_enabled_, and state_.

Referenced by v8::Isolate::New().

Here is the caller graph for this function:

◆ EnqueueMicrotask()

void v8::internal::Isolate::EnqueueMicrotask ( Handle< Object > microtask )

Definition at line 2281 of file isolate.cc.

                                                        {
   DCHECK(microtask->IsJSFunction() || microtask->IsCallHandlerInfo());
   Handle<FixedArray> queue(heap()->microtask_queue(), this);
   int num_tasks = pending_microtask_count();
   DCHECK(num_tasks <= queue->length());
   if (num_tasks == 0) {
     queue = factory()->NewFixedArray(8);
     heap()->set_microtask_queue(*queue);
   } else if (num_tasks == queue->length()) {
     queue = FixedArray::CopySize(queue, num_tasks * 2);
     heap()->set_microtask_queue(*queue);
   }
   DCHECK(queue->get(num_tasks)->IsUndefined());
   queue->set(num_tasks, *microtask);
   set_pending_microtask_count(num_tasks + 1);
 }

References v8::internal::FixedArray::CopySize(), DCHECK, factory(), and heap().

Referenced by v8::Isolate::EnqueueMicrotask().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Enter()

void v8::internal::Isolate::Enter ( )

private

Definition at line 2047 of file isolate.cc.

                     {
   Isolate* current_isolate = NULL;
   PerIsolateThreadData* current_data = CurrentPerIsolateThreadData();
   if (current_data != NULL) {
     current_isolate = current_data->isolate_;
     DCHECK(current_isolate != NULL);
     if (current_isolate == this) {
       DCHECK(Current() == this);
       DCHECK(entry_stack_ != NULL);
       DCHECK(entry_stack_->previous_thread_data == NULL ||
              entry_stack_->previous_thread_data->thread_id().Equals(
                  ThreadId::Current()));
       // Same thread re-enters the isolate, no need to re-init anything.
       entry_stack_->entry_count++;
       return;
     }
   }
  
   PerIsolateThreadData* data = FindOrAllocatePerThreadDataForThisThread();
   DCHECK(data != NULL);
   DCHECK(data->isolate_ == this);
  
   EntryStackItem* item = new EntryStackItem(current_data,
                                             current_isolate,
                                             entry_stack_);
   entry_stack_ = item;
  
   SetIsolateThreadLocals(this, data);
  
   // In case it's the first time some thread enters the isolate.
   set_thread_id(data->thread_id());
 }

References v8::internal::ThreadId::Current(), CurrentPerIsolateThreadData(), DCHECK, v8::internal::Isolate::EntryStackItem::entry_count, entry_stack_, FindOrAllocatePerThreadDataForThisThread(), v8::internal::Isolate::PerIsolateThreadData::isolate_, NULL, v8::internal::Isolate::EntryStackItem::previous_thread_data, SetIsolateThreadLocals(), and v8::internal::Isolate::PerIsolateThreadData::thread_id().

Referenced by v8::Isolate::Enter(), and v8::Locker::Initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ eternal_handles()

EternalHandles* v8::internal::Isolate::eternal_handles ( )

inline

Definition at line 919 of file isolate.h.

919 { return eternal_handles_; }

References eternal_handles_.

Referenced by v8::Date::DateTimeConfigurationChangeNotification(), v8::V8::Eternalize(), v8::internal::anonymous_namespace{i18n.cc}::GetEternal(), v8::V8::GetEternal(), v8::internal::Heap::IterateStrongRoots(), v8::internal::Heap::PerformGarbageCollection(), and v8::internal::StartupSerializer::SerializeStrongReferences().

Here is the caller graph for this function:

◆ Exit()

void v8::internal::Isolate::Exit ( )

private

Definition at line 2081 of file isolate.cc.

                    {
   DCHECK(entry_stack_ != NULL);
   DCHECK(entry_stack_->previous_thread_data == NULL ||
          entry_stack_->previous_thread_data->thread_id().Equals(
              ThreadId::Current()));
  
   if (--entry_stack_->entry_count > 0) return;
  
   DCHECK(CurrentPerIsolateThreadData() != NULL);
   DCHECK(CurrentPerIsolateThreadData()->isolate_ == this);
  
   // Pop the stack.
   EntryStackItem* item = entry_stack_;
   entry_stack_ = item->previous_item;
  
   PerIsolateThreadData* previous_thread_data = item->previous_thread_data;
   Isolate* previous_isolate = item->previous_isolate;
  
   delete item;
  
   // Reinit the current thread for the isolate it was running before this one.
   SetIsolateThreadLocals(previous_isolate, previous_thread_data);
 }

References v8::internal::ThreadId::Current(), CurrentPerIsolateThreadData(), DCHECK, v8::internal::Isolate::EntryStackItem::entry_count, entry_stack_, NULL, v8::internal::Isolate::EntryStackItem::previous_isolate, v8::internal::Isolate::EntryStackItem::previous_item, v8::internal::Isolate::EntryStackItem::previous_thread_data, SetIsolateThreadLocals(), and v8::internal::Isolate::PerIsolateThreadData::thread_id().

Referenced by v8::Isolate::Exit(), and v8::Locker::Initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ external_caught_exception_address()

bool* v8::internal::Isolate::external_caught_exception_address ( )

inline

Definition at line 599 of file isolate.h.

                                             {
     return &thread_local_top_.external_caught_exception_;
   }

References thread_local_top_.

◆ factory()

Factory* v8::internal::Isolate::factory ( )

inline

Definition at line 982 of file isolate.h.

982 { return reinterpret_cast<Factory*>(this); }

◆ FillCache()

void v8::internal::Isolate::FillCache ( )

private

◆ FindCodeObject()

Object * v8::internal::Isolate::FindCodeObject ( Address a )

Definition at line 2214 of file isolate.cc.

                                          {
   return inner_pointer_to_code_cache()->GcSafeFindCodeForInnerPointer(a);
 }

References v8::internal::InnerPointerToCodeCache::GcSafeFindCodeForInnerPointer(), and inner_pointer_to_code_cache().

Referenced by v8::internal::DeoptimizedFrameInfo::DeoptimizedFrameInfo(), v8::internal::Deoptimizer::FindOptimizedCode(), and v8::internal::StubFrame::unchecked_code().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FindOrAllocatePerThreadDataForThisThread()

Isolate::PerIsolateThreadData * v8::internal::Isolate::FindOrAllocatePerThreadDataForThisThread ( )

private

Definition at line 119 of file isolate.cc.

                                                       {
   ThreadId thread_id = ThreadId::Current();
   PerIsolateThreadData* per_thread = NULL;
   {
     base::LockGuard<base::Mutex> lock_guard(thread_data_table_mutex_.Pointer());
     per_thread = thread_data_table_->Lookup(this, thread_id);
     if (per_thread == NULL) {
       per_thread = new PerIsolateThreadData(this, thread_id);
       thread_data_table_->Insert(per_thread);
     }
     DCHECK(thread_data_table_->Lookup(this, thread_id) == per_thread);
   }
   return per_thread;
 }

References v8::internal::ThreadId::Current(), DCHECK, v8::internal::Isolate::ThreadDataTable::Insert(), v8::internal::Isolate::ThreadDataTable::Lookup(), NULL, v8::base::LazyInstanceImpl< T, AllocationTrait, CreateTrait, InitOnceTrait, DestroyTrait >::Pointer(), thread_data_table_, and thread_data_table_mutex_.

Referenced by v8::internal::ThreadManager::ArchiveThread(), and Enter().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FindPerThreadDataForThisThread()

Isolate::PerIsolateThreadData * v8::internal::Isolate::FindPerThreadDataForThisThread ( )

Definition at line 135 of file isolate.cc.

                                                                      {
   ThreadId thread_id = ThreadId::Current();
   return FindPerThreadDataForThread(thread_id);
 }

References v8::internal::ThreadId::Current(), and FindPerThreadDataForThread().

Referenced by v8::internal::ThreadManager::IsArchived(), and v8::internal::ThreadManager::RestoreThread().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FindPerThreadDataForThread()

Isolate::PerIsolateThreadData * v8::internal::Isolate::FindPerThreadDataForThread ( ThreadId thread_id )

Definition at line 141 of file isolate.cc.

                         {
   PerIsolateThreadData* per_thread = NULL;
   {
     base::LockGuard<base::Mutex> lock_guard(thread_data_table_mutex_.Pointer());
     per_thread = thread_data_table_->Lookup(this, thread_id);
   }
   return per_thread;
 }

References v8::internal::Isolate::ThreadDataTable::Lookup(), NULL, v8::base::LazyInstanceImpl< T, AllocationTrait, CreateTrait, InitOnceTrait, DestroyTrait >::Pointer(), thread_data_table_, and thread_data_table_mutex_.

Referenced by FindPerThreadDataForThisThread().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FireCallCompletedCallback()

void v8::internal::Isolate::FireCallCompletedCallback ( )

Definition at line 2265 of file isolate.cc.

                                         {
   bool has_call_completed_callbacks = !call_completed_callbacks_.is_empty();
   bool run_microtasks = autorun_microtasks() && pending_microtask_count();
   if (!has_call_completed_callbacks && !run_microtasks) return;
  
   if (!handle_scope_implementer()->CallDepthIsZero()) return;
   if (run_microtasks) RunMicrotasks();
   // Fire callbacks.  Increase call depth to prevent recursive callbacks.
   v8::Isolate::SuppressMicrotaskExecutionScope suppress(
       reinterpret_cast<v8::Isolate*>(this));
   for (int i = 0; i < call_completed_callbacks_.length(); i++) {
     call_completed_callbacks_.at(i)();
   }
 }

References v8::internal::List< T, AllocationPolicy >::at(), call_completed_callbacks_, handle_scope_implementer(), and RunMicrotasks().

Here is the call graph for this function:

◆ formal_count_address()

void* v8::internal::Isolate::formal_count_address ( )

inline

Definition at line 666 of file isolate.h.

666 { return &thread_local_top_.formal_count_; }

References thread_local_top_.

◆ FreeThreadResources()

void v8::internal::Isolate::FreeThreadResources ( )

inline

Definition at line 684 of file isolate.h.

684 { thread_local_top_.Free(); }

References thread_local_top_.

Referenced by Deinit(), and v8::internal::ThreadManager::FreeThreadResources().

Here is the caller graph for this function:

◆ function_entry_hook()

FunctionEntryHook v8::internal::Isolate::function_entry_hook ( )

inline

Definition at line 1078 of file isolate.h.

1078 { return function_entry_hook_; }

References function_entry_hook_.

Referenced by v8::internal::ProfileEntryHookStub::EntryHookTrampoline(), Init(), and set_function_entry_hook().

Here is the caller graph for this function:

◆ get_address_from_id()

Address v8::internal::Isolate::get_address_from_id ( Isolate::AddressId id )

Definition at line 162 of file isolate.cc.

                                                         {
   return isolate_addresses_[id];
 }

References id(), and isolate_addresses_.

Referenced by v8::internal::ExternalReferenceTable::PopulateTable().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_initial_js_array_map()

Map * v8::internal::Isolate::get_initial_js_array_map ( ElementsKind kind )

Definition at line 2160 of file isolate.cc.

                                                         {
   Context* native_context = context()->native_context();
   Object* maybe_map_array = native_context->js_array_maps();
   if (!maybe_map_array->IsUndefined()) {
     Object* maybe_transitioned_map =
         FixedArray::cast(maybe_map_array)->get(kind);
     if (!maybe_transitioned_map->IsUndefined()) {
       return Map::cast(maybe_transitioned_map);
     }
   }
   return NULL;
 }

References context(), v8::internal::Context::native_context(), native_context(), and NULL.

Referenced by IsFastArrayConstructorPrototypeChainIntact().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetCallingNativeContext()

Handle< Context > v8::internal::Isolate::GetCallingNativeContext ( )

Definition at line 1349 of file isolate.cc.

                                                  {
   JavaScriptFrameIterator it(this);
   if (debug_->in_debug_scope()) {
     while (!it.done()) {
       JavaScriptFrame* frame = it.frame();
       Context* context = Context::cast(frame->context());
       if (context->native_context() == *debug_->debug_context()) {
         it.Advance();
       } else {
         break;
       }
     }
   }
   if (it.done()) return Handle<Context>::null();
   JavaScriptFrame* frame = it.frame();
   Context* context = Context::cast(frame->context());
   return Handle<Context>(context->native_context());
 }

References v8::internal::Context::cast(), context(), v8::internal::StandardFrame::context(), debug_, v8::internal::Debug::debug_context(), v8::internal::Debug::in_debug_scope(), v8::internal::Context::native_context(), and v8::internal::Handle< T >::null().

Referenced by v8::Isolate::GetCallingContext().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetCodeTracer()

CodeTracer * v8::internal::Isolate::GetCodeTracer ( )

Definition at line 2154 of file isolate.cc.

                                    {
   if (code_tracer() == NULL) set_code_tracer(new CodeTracer(id()));
   return code_tracer();
 }

References NULL.

Referenced by v8::internal::RegExpCompiler::Assemble(), v8::internal::Deoptimizer::DeoptimizeAll(), v8::internal::Deoptimizer::DeoptimizeGlobalObject(), v8::internal::Deoptimizer::DeoptimizeMarkedCode(), v8::internal::Deoptimizer::DeoptimizeMarkedCodeForContext(), v8::internal::Deoptimizer::Deoptimizer(), v8::internal::CodeGenerator::PrintCode(), v8::internal::DependentCode::SetMarkedForDeoptimization(), and v8::internal::Builtins::SetUp().

Here is the caller graph for this function:

◆ GetData()

void* v8::internal::Isolate::GetData ( uint32_t slot )

inline

Definition at line 994 of file isolate.h.

                                {
     DCHECK(slot < Internals::kNumIsolateDataSlots);
     return embedder_data_[slot];
   }

References DCHECK, embedder_data_, and v8::internal::Internals::kNumIsolateDataSlots.

◆ GetHStatistics()

HStatistics * v8::internal::Isolate::GetHStatistics ( )

Definition at line 2136 of file isolate.cc.

                                      {
   if (hstatistics() == NULL) set_hstatistics(new HStatistics());
   return hstatistics();
 }

References NULL.

Referenced by v8::internal::OptimizedCompileJob::CreateGraph(), Deinit(), and v8::internal::OptimizedCompileJob::RecordOptimizationStats().

Here is the caller graph for this function:

◆ GetHTracer()

HTracer * v8::internal::Isolate::GetHTracer ( )

Definition at line 2148 of file isolate.cc.

                              {
   if (htracer() == NULL) set_htracer(new HTracer(id()));
   return htracer();
 }

References NULL.

Referenced by v8::internal::CodeStubGraphBuilderBase::BuildGraph(), and v8::internal::OptimizedCompileJob::CreateGraph().

Here is the caller graph for this function:

◆ GetMessageLocation()

MessageLocation v8::internal::Isolate::GetMessageLocation ( )

Definition at line 1226 of file isolate.cc.

                                             {
   DCHECK(has_pending_exception());
  
   if (thread_local_top_.pending_exception_ != heap()->termination_exception() &&
       thread_local_top_.has_pending_message_ &&
       !thread_local_top_.pending_message_obj_->IsTheHole() &&
       !thread_local_top_.pending_message_obj_->IsTheHole()) {
     Handle<Script> script(
         Script::cast(thread_local_top_.pending_message_script_));
     int start_pos = thread_local_top_.pending_message_start_pos_;
     int end_pos = thread_local_top_.pending_message_end_pos_;
     return MessageLocation(script, start_pos, end_pos);
   }
  
   return MessageLocation();
 }

References DCHECK, has_pending_exception(), heap(), and thread_local_top_.

Referenced by v8::internal::LiveEdit::GatherCompileInfo().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetOrCreateBasicBlockProfiler()

BasicBlockProfiler * v8::internal::Isolate::GetOrCreateBasicBlockProfiler ( )

Definition at line 2365 of file isolate.cc.

                                                            {
   if (basic_block_profiler_ == NULL) {
     basic_block_profiler_ = new BasicBlockProfiler();
   }
   return basic_block_profiler_;
 }

References basic_block_profiler_, and NULL.

Referenced by v8::internal::compiler::BasicBlockInstrumentor::Instrument().

Here is the caller graph for this function:

◆ GetPromiseOnStackOnThrow()

Handle< Object > v8::internal::Isolate::GetPromiseOnStackOnThrow ( )

Definition at line 1308 of file isolate.cc.

                                                  {
   Handle<Object> undefined = factory()->undefined_value();
   ThreadLocalTop* tltop = thread_local_top();
   if (tltop->promise_on_stack_ == NULL) return undefined;
   StackHandler* promise_try = tltop->promise_on_stack_->handler();
   // Find the top-most try-catch handler.
   StackHandler* handler = StackHandler::FromAddress(Isolate::handler(tltop));
   do {
     if (handler == promise_try) {
       // Mark the pushed try-catch handler to prevent a later duplicate event
       // triggered with the following reject.
       return tltop->promise_on_stack_->promise();
     }
     handler = handler->next();
     // Throwing inside a Promise can be intercepted by an inner try-catch, so
     // we stop at the first try-catch handler.
   } while (handler != NULL && !handler->is_catch());
   return undefined;
 }

References factory(), handler(), NULL, and thread_local_top().

Referenced by v8::internal::Debug::OnThrow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetSymbolRegistry()

Handle< JSObject > v8::internal::Isolate::GetSymbolRegistry ( )

Definition at line 2228 of file isolate.cc.

                                             {
   if (heap()->symbol_registry()->IsUndefined()) {
     Handle<Map> map = factory()->NewMap(JS_OBJECT_TYPE, JSObject::kHeaderSize);
     Handle<JSObject> registry = factory()->NewJSObjectFromMap(map);
     heap()->set_symbol_registry(*registry);
  
     static const char* nested[] = {
       "for", "for_api", "for_intern", "keyFor", "private_api", "private_intern"
     };
     for (unsigned i = 0; i < arraysize(nested); ++i) {
       Handle<String> name = factory()->InternalizeUtf8String(nested[i]);
       Handle<JSObject> obj = factory()->NewJSObjectFromMap(map);
       JSObject::NormalizeProperties(obj, KEEP_INOBJECT_PROPERTIES, 8);
       JSObject::SetProperty(registry, name, obj, STRICT).Assert();
     }
   }
   return Handle<JSObject>::cast(factory()->symbol_registry());
 }

References arraysize, v8::internal::Handle< T >::cast(), factory(), heap(), v8::internal::JS_OBJECT_TYPE, v8::internal::KEEP_INOBJECT_PROPERTIES, v8::internal::JSObject::kHeaderSize, map, name, v8::internal::JSObject::NormalizeProperties(), v8::internal::Object::SetProperty(), and v8::internal::STRICT.

Referenced by v8::Private::ForApi(), and v8::SymbolFor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetTStatistics()

HStatistics * v8::internal::Isolate::GetTStatistics ( )

Definition at line 2142 of file isolate.cc.

                                      {
   if (tstatistics() == NULL) set_tstatistics(new HStatistics());
   return tstatistics();
 }

References NULL.

Referenced by Deinit(), v8::internal::compiler::Pipeline::GenerateCode(), and v8::internal::compiler::PhaseStats::~PhaseStats().

Here is the caller graph for this function:

◆ global_context()

Handle< Context > v8::internal::Isolate::global_context ( )

Definition at line 1344 of file isolate.cc.

                                         {
   return handle(context()->global_object()->global_context());
 }

References context(), global_object(), and v8::internal::handle().

Referenced by v8::ScriptCompiler::Compile(), v8::ScriptCompiler::CompileUnbound(), and v8::ScriptCompiler::StartStreamingScript().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ global_handles()

GlobalHandles* v8::internal::Isolate::global_handles ( )

inline

Definition at line 917 of file isolate.h.

917 { return global_handles_; }

References global_handles_.

Referenced by v8::internal::ScriptCache::Add(), v8::internal::MarkCompactCollector::AfterMarking(), v8::internal::NativeObjectsExplorer::FillImplicitReferences(), v8::internal::NativeObjectsExplorer::FillRetainedObjects(), v8::internal::Heap::GarbageCollectionEpilogue(), v8::V8::GlobalizeReference(), v8::internal::Heap::IterateStrongRoots(), v8::internal::Debug::Load(), v8::internal::MarkCompactCollector::MarkImplicitRefGroups(), v8::internal::MarkCompactCollector::MarkLiveObjects(), v8::internal::Heap::PerformGarbageCollection(), PopPromise(), v8::internal::MarkCompactCollector::ProcessEphemeralMarking(), PushPromise(), v8::internal::Heap::RecordStats(), v8::internal::Heap::Scavenge(), v8::internal::StartupSerializer::SerializeStrongReferences(), v8::internal::ArrayConcatVisitor::set_storage(), v8::internal::Debug::SetEventListener(), v8::Isolate::SetObjectGroupId(), v8::Isolate::SetReference(), v8::Isolate::SetReferenceFromGroup(), v8::internal::HeapProfiler::SetRetainedObjectInfo(), v8::internal::V8HeapExplorer::TagGlobalObjects(), v8::internal::Heap::TearDown(), v8::internal::AllocationTracker::UnresolvedLocation::UnresolvedLocation(), v8::V8::VisitHandlesForPartialDependence(), and v8::V8::VisitHandlesWithClassIds().

Here is the caller graph for this function:

◆ global_object()

Handle<GlobalObject> v8::internal::Isolate::global_object ( )

inline

Definition at line 670 of file isolate.h.

                                        {
     return Handle<GlobalObject>(context()->global_object());
   }

References context().

Referenced by v8::internal::Debug::ClearMirrorCache(), global_context(), and v8::internal::Debug::MakeJSObject().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ global_proxy()

JSObject* v8::internal::Isolate::global_proxy ( )

inline

Definition at line 675 of file isolate.h.

                            {
     return context()->global_proxy();
   }

References context(), and v8::internal::Context::global_proxy().

Referenced by v8::internal::Debug::CallEventCallback(), v8::Script::Run(), and v8::internal::Runtime_NewObjectHelper().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GlobalTearDown()

void v8::internal::Isolate::GlobalTearDown ( )

static

Definition at line 1585 of file isolate.cc.

                              {
   delete thread_data_table_;
   thread_data_table_ = NULL;
 }

References NULL, and thread_data_table_.

Referenced by v8::internal::V8::TearDown().

Here is the caller graph for this function:

◆ handle_scope_data()

HandleScopeData* v8::internal::Isolate::handle_scope_data ( )

inline

Definition at line 899 of file isolate.h.

899 { return &handle_scope_data_; }

References handle_scope_data_.

Here is the caller graph for this function:

◆ handle_scope_implementer()

HandleScopeImplementer* v8::internal::Isolate::handle_scope_implementer ( )

inline

Definition at line 901 of file isolate.h.

                                                      {
     DCHECK(handle_scope_implementer_);
     return handle_scope_implementer_;
   }

References DCHECK, and handle_scope_implementer_.

Referenced by v8::internal::HandleScope::DeleteExtensions(), v8::internal::Deserializer::Deserialize(), v8::internal::ThreadManager::EagerlyArchiveThread(), v8::Context::Enter(), v8::Context::Exit(), v8::internal::HandleScope::Extend(), FireCallCompletedCallback(), v8::internal::ThreadManager::FreeThreadResources(), v8::Isolate::GetEnteredContext(), v8::internal::Heap::IterateStrongRoots(), v8::internal::HandleScope::NumberOfHandles(), v8::internal::MarkCompactCollector::PrepareForCodeFlushing(), v8::internal::ThreadManager::RestoreThread(), v8::internal::StartupSerializer::SerializeStrongReferences(), and v8::Isolate::SuppressMicrotaskExecutionScope::SuppressMicrotaskExecutionScope().

Here is the caller graph for this function:

◆ handler()

static Address v8::internal::Isolate::handler ( ThreadLocalTop * thread )

inlinestatic

Definition at line 650 of file isolate.h.

650 { return thread->handler_; }

Referenced by CancelScheduledExceptionFromTryCatch(), GetPromiseOnStackOnThrow(), v8::internal::TickSample::Init(), IsFinallyOnTop(), v8::internal::SafeStackFrameIterator::IsValidTop(), PropagatePendingExceptionToExternalTryCatch(), PushPromise(), v8::internal::StackFrameIterator::Reset(), RestorePendingMessageFromTryCatch(), and ShouldReportException().

Here is the caller graph for this function:

◆ handler_address()

Address* v8::internal::Isolate::handler_address ( )

inline

Definition at line 655 of file isolate.h.

655 { return &thread_local_top_.handler_; }

References thread_local_top_.

◆ has_installed_extensions()

bool v8::internal::Isolate::has_installed_extensions ( )

inline

Definition at line 953 of file isolate.h.

953 { return has_installed_extensions_; }

References has_installed_extensions_.

Referenced by v8::internal::StartupSerializer::SerializeStrongReferences().

Here is the caller graph for this function:

◆ has_pending_exception()

bool v8::internal::Isolate::has_pending_exception ( )

inline

Definition at line 581 of file isolate.h.

                                {
     DCHECK(!thread_local_top_.pending_exception_->IsException());
     return !thread_local_top_.pending_exception_->IsTheHole();
   }

References DCHECK, and thread_local_top_.

Referenced by CancelTerminateExecution(), v8::internal::Debug::CompileDebuggerScript(), v8::internal::CompileUnoptimizedCode(), DoThrow(), v8::internal::NativeRegExpMacroAssembler::Execute(), v8::internal::ThreadManager::FreeThreadResources(), v8::internal::LiveEdit::GatherCompileInfo(), v8::internal::Compiler::GetDebugCode(), GetMessageLocation(), v8::internal::Compiler::GetOptimizedCode(), v8::internal::GetOptimizedCodeNow(), v8::internal::GetOwnProperty(), HasExternalTryCatch(), v8::internal::Invoke(), v8::internal::RegExpImpl::IrregexpExec(), v8::internal::RegExpImpl::IrregexpExecRaw(), v8::internal::LoadLookupSlotHelper(), v8::internal::Context::Lookup(), v8::internal::FullCodeGenerator::MakeCode(), OptionalRescheduleException(), pending_exception(), PropagatePendingExceptionToExternalTryCatch(), v8::internal::MessageHandler::ReportMessage(), ReportPendingMessages(), v8::internal::ScopeIterator::RetrieveScopeChain(), ScheduleThrow(), v8::internal::HOptimizedGraphBuilder::TryInline(), and v8::internal::UnscopableLookup().

Here is the caller graph for this function:

◆ has_pending_message_address()

Address v8::internal::Isolate::has_pending_message_address ( )

inline

Definition at line 613 of file isolate.h.

                                         {
     return reinterpret_cast<Address>(&thread_local_top_.has_pending_message_);
   }

References thread_local_top_.

◆ has_scheduled_exception()

bool v8::internal::Isolate::has_scheduled_exception ( )

inline

Definition at line 627 of file isolate.h.

                                  {
     DCHECK(!thread_local_top_.scheduled_exception_->IsException());
     return thread_local_top_.scheduled_exception_ != heap_.the_hole_value();
   }

References DCHECK, heap_, and thread_local_top_.

Referenced by v8::internal::Debug::CallEventCallback(), CancelScheduledExceptionFromTryCatch(), CancelTerminateExecution(), v8::IsExecutionTerminatingCheck(), v8::internal::Debug::OnThrow(), v8::internal::MessageHandler::ReportMessage(), and scheduled_exception().

Here is the caller graph for this function:

◆ HasExternalTryCatch()

bool v8::internal::Isolate::HasExternalTryCatch ( )

Definition at line 1157 of file isolate.cc.

                                   {
   DCHECK(has_pending_exception());
  
   return (thread_local_top()->catcher_ != NULL) &&
       (try_catch_handler() == thread_local_top()->catcher_);
 }

References DCHECK, has_pending_exception(), NULL, thread_local_top(), and try_catch_handler().

Referenced by PropagatePendingExceptionToExternalTryCatch().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ heap()

Heap* v8::internal::Isolate::heap ( )

inline

Definition at line 873 of file isolate.h.

873 { return &heap_; }

References heap_.

◆ heap_profiler()

HeapProfiler* v8::internal::Isolate::heap_profiler ( ) const

inline

Definition at line 972 of file isolate.h.

972 { return heap_profiler_; }

References heap_profiler_.

Referenced by v8::HeapSnapshot::Delete(), v8::internal::Heap::OnAllocationEvent(), v8::internal::Heap::OnMoveEvent(), v8::internal::Heap::RightTrimFixedArray(), v8::internal::Heap::SelectScavengingVisitorsTable(), and v8::internal::NativeObjectsExplorer::VisitSubtreeWrapper().

Here is the caller graph for this function:

◆ id()

int v8::internal::Isolate::id ( ) const

inline

Definition at line 1071 of file isolate.h.

1071 { return static_cast<int>(id_); }

References id_.

Referenced by get_address_from_id(), and NextOptimizationId().

Here is the caller graph for this function:

◆ Init()

bool v8::internal::Isolate::Init ( Deserializer * des )

Definition at line 1828 of file isolate.cc.

                                     {
   DCHECK(state_ != INITIALIZED);
   TRACE_ISOLATE(init);
  
   stress_deopt_count_ = FLAG_deopt_every_n_times;
  
   has_fatal_error_ = false;
  
   if (function_entry_hook() != NULL) {
     // When function entry hooking is in effect, we have to create the code
     // stubs from scratch to get entry hooks, rather than loading the previously
     // generated stubs from disk.
     // If this assert fires, the initialization path has regressed.
     DCHECK(des == NULL);
   }
  
   // The initialization process does not handle memory exhaustion.
   DisallowAllocationFailure disallow_allocation_failure(this);
  
   memory_allocator_ = new MemoryAllocator(this);
   code_range_ = new CodeRange(this);
  
   // Safe after setting Heap::isolate_, and initializing StackGuard
   heap_.SetStackLimits();
  
 #define ASSIGN_ELEMENT(CamelName, hacker_name)                  \
   isolate_addresses_[Isolate::k##CamelName##Address] =          \
       reinterpret_cast<Address>(hacker_name##_address());
   FOR_EACH_ISOLATE_ADDRESS_NAME(ASSIGN_ELEMENT)
 #undef ASSIGN_ELEMENT
  
   string_tracker_ = new StringTracker();
   string_tracker_->isolate_ = this;
   compilation_cache_ = new CompilationCache(this);
   keyed_lookup_cache_ = new KeyedLookupCache();
   context_slot_cache_ = new ContextSlotCache();
   descriptor_lookup_cache_ = new DescriptorLookupCache();
   unicode_cache_ = new UnicodeCache();
   inner_pointer_to_code_cache_ = new InnerPointerToCodeCache(this);
   write_iterator_ = new ConsStringIteratorOp();
   global_handles_ = new GlobalHandles(this);
   eternal_handles_ = new EternalHandles();
   bootstrapper_ = new Bootstrapper(this);
   handle_scope_implementer_ = new HandleScopeImplementer(this);
   stub_cache_ = new StubCache(this);
   materialized_object_store_ = new MaterializedObjectStore(this);
   regexp_stack_ = new RegExpStack();
   regexp_stack_->isolate_ = this;
   date_cache_ = new DateCache();
   call_descriptor_data_ =
       new CallInterfaceDescriptorData[CallDescriptors::NUMBER_OF_DESCRIPTORS];
   cpu_profiler_ = new CpuProfiler(this);
   heap_profiler_ = new HeapProfiler(heap());
  
   // Enable logging before setting up the heap
   logger_->SetUp(this);
  
   // Initialize other runtime facilities
 #if defined(USE_SIMULATOR)
 #if V8_TARGET_ARCH_ARM || V8_TARGET_ARCH_ARM64 || \
     V8_TARGET_ARCH_MIPS || V8_TARGET_ARCH_MIPS64
   Simulator::Initialize(this);
 #endif
 #endif
  
   code_aging_helper_ = new CodeAgingHelper();
  
   { // NOLINT
     // Ensure that the thread has a valid stack guard.  The v8::Locker object
     // will ensure this too, but we don't have to use lockers if we are only
     // using one thread.
     ExecutionAccess lock(this);
     stack_guard_.InitThread(lock);
   }
  
   // SetUp the object heap.
   DCHECK(!heap_.HasBeenSetUp());
   if (!heap_.SetUp()) {
     V8::FatalProcessOutOfMemory("heap setup");
     return false;
   }
  
   deoptimizer_data_ = new DeoptimizerData(memory_allocator_);
  
   const bool create_heap_objects = (des == NULL);
   if (create_heap_objects && !heap_.CreateHeapObjects()) {
     V8::FatalProcessOutOfMemory("heap object creation");
     return false;
   }
  
   if (create_heap_objects) {
     // Terminate the cache array with the sentinel so we can iterate.
     PushToPartialSnapshotCache(heap_.undefined_value());
   }
  
   InitializeThreadLocal();
  
   bootstrapper_->Initialize(create_heap_objects);
   builtins_.SetUp(this, create_heap_objects);
  
   if (FLAG_log_internal_timer_events) {
     set_event_logger(Logger::DefaultTimerEventsLogger);
   } else {
     set_event_logger(Logger::EmptyTimerEventsLogger);
   }
  
   // Set default value if not yet set.
   // TODO(yangguo): move this to ResourceConstraints::ConfigureDefaults
   // once ResourceConstraints becomes an argument to the Isolate constructor.
   if (max_available_threads_ < 1) {
     // Choose the default between 1 and 4.
     max_available_threads_ =
         Max(Min(base::SysInfo::NumberOfProcessors(), 4), 1);
   }
  
   if (!FLAG_job_based_sweeping) {
     num_sweeper_threads_ =
         SweeperThread::NumberOfThreads(max_available_threads_);
   }
  
   if (FLAG_trace_hydrogen || FLAG_trace_hydrogen_stubs) {
     PrintF("Concurrent recompilation has been disabled for tracing.\n");
   } else if (OptimizingCompilerThread::Enabled(max_available_threads_)) {
     optimizing_compiler_thread_ = new OptimizingCompilerThread(this);
     optimizing_compiler_thread_->Start();
   }
  
   if (num_sweeper_threads_ > 0) {
     sweeper_thread_ = new SweeperThread*[num_sweeper_threads_];
     for (int i = 0; i < num_sweeper_threads_; i++) {
       sweeper_thread_[i] = new SweeperThread(this);
       sweeper_thread_[i]->Start();
     }
   }
  
   // If we are deserializing, read the state into the now-empty heap.
   if (!create_heap_objects) {
     des->Deserialize(this);
   }
   stub_cache_->Initialize();
  
   // Finish initialization of ThreadLocal after deserialization is done.
   clear_pending_exception();
   clear_pending_message();
   clear_scheduled_exception();
  
   // Deserializing may put strange things in the root array's copy of the
   // stack guard.
   heap_.SetStackLimits();
  
   // Quiet the heap NaN if needed on target platform.
   if (!create_heap_objects) Assembler::QuietNaN(heap_.nan_value());
  
   runtime_profiler_ = new RuntimeProfiler(this);
  
   // If we are deserializing, log non-function code objects and compiled
   // functions found in the snapshot.
   if (!create_heap_objects &&
       (FLAG_log_code ||
        FLAG_ll_prof ||
        FLAG_perf_jit_prof ||
        FLAG_perf_basic_prof ||
        logger_->is_logging_code_events())) {
     HandleScope scope(this);
     LOG(this, LogCodeObjects());
     LOG(this, LogCompiledFunctions());
   }
  
   CHECK_EQ(static_cast<int>(OFFSET_OF(Isolate, embedder_data_)),
            Internals::kIsolateEmbedderDataOffset);
   CHECK_EQ(static_cast<int>(OFFSET_OF(Isolate, heap_.roots_)),
            Internals::kIsolateRootsOffset);
   CHECK_EQ(static_cast<int>(
                OFFSET_OF(Isolate, heap_.amount_of_external_allocated_memory_)),
            Internals::kAmountOfExternalAllocatedMemoryOffset);
   CHECK_EQ(static_cast<int>(OFFSET_OF(
                Isolate,
                heap_.amount_of_external_allocated_memory_at_last_global_gc_)),
            Internals::kAmountOfExternalAllocatedMemoryAtLastGlobalGCOffset);
  
   state_ = INITIALIZED;
   time_millis_at_init_ = base::OS::TimeCurrentMillis();
  
   if (!create_heap_objects) {
     // Now that the heap is consistent, it's OK to generate the code for the
     // deopt entry table that might have been referred to by optimized code in
     // the snapshot.
     HandleScope scope(this);
     Deoptimizer::EnsureCodeForDeoptimizationEntry(
         this,
         Deoptimizer::LAZY,
         kDeoptTableSerializeEntryCount - 1);
   }
  
   if (!serializer_enabled()) {
     // Ensure that all stubs which need to be generated ahead of time, but
     // cannot be serialized into the snapshot have been generated.
     HandleScope scope(this);
     CodeStub::GenerateFPStubs(this);
     StoreBufferOverflowStub::GenerateFixedRegStubsAheadOfTime(this);
     StubFailureTrampolineStub::GenerateAheadOfTime(this);
   }
  
   initialized_from_snapshot_ = (des != NULL);
  
   return true;
 }

References v8::internal::Heap::amount_of_external_allocated_memory_, v8::internal::Heap::amount_of_external_allocated_memory_at_last_global_gc_, ASSIGN_ELEMENT, bootstrapper_, builtins_, call_descriptor_data_, CHECK_EQ, clear_pending_exception(), clear_pending_message(), clear_scheduled_exception(), code_aging_helper_, code_range_, compilation_cache_, context_slot_cache_, cpu_profiler_, v8::internal::Heap::CreateHeapObjects(), date_cache_, DCHECK, v8::internal::Logger::DefaultTimerEventsLogger(), deoptimizer_data_, descriptor_lookup_cache_, v8::internal::Deserializer::Deserialize(), embedder_data_, v8::internal::Logger::EmptyTimerEventsLogger(), v8::internal::OptimizingCompilerThread::Enabled(), v8::internal::Deoptimizer::EnsureCodeForDeoptimizationEntry(), eternal_handles_, ExecutionAccess, v8::internal::V8::FatalProcessOutOfMemory(), FOR_EACH_ISOLATE_ADDRESS_NAME, function_entry_hook(), v8::internal::StubFailureTrampolineStub::GenerateAheadOfTime(), v8::internal::StoreBufferOverflowStub::GenerateFixedRegStubsAheadOfTime(), global_handles_, handle_scope_implementer_, HandleScopeImplementer, has_fatal_error_, v8::internal::Heap::HasBeenSetUp(), heap(), heap_, heap_profiler_, v8::internal::StubCache::Initialize(), INITIALIZED, initialized_from_snapshot_, InitializeThreadLocal(), inner_pointer_to_code_cache_, v8::internal::Logger::is_logging_code_events(), v8::internal::StringTracker::isolate_, v8::internal::RegExpStack::isolate_, v8::internal::Internals::kAmountOfExternalAllocatedMemoryAtLastGlobalGCOffset, v8::internal::Internals::kAmountOfExternalAllocatedMemoryOffset, v8::internal::kDeoptTableSerializeEntryCount, keyed_lookup_cache_, v8::internal::Internals::kIsolateEmbedderDataOffset, v8::internal::Internals::kIsolateRootsOffset, v8::internal::Deoptimizer::LAZY, LOG, logger_, materialized_object_store_, v8::internal::Max(), memory_allocator_, v8::internal::Min(), NULL, num_sweeper_threads_, v8::internal::CallDescriptors::NUMBER_OF_DESCRIPTORS, v8::internal::SweeperThread::NumberOfThreads(), OFFSET_OF, optimizing_compiler_thread_, OptimizingCompilerThread, v8::internal::PrintF(), PushToPartialSnapshotCache(), v8::internal::Assembler::QuietNaN(), regexp_stack_, v8::internal::Heap::roots_, runtime_profiler_, serializer_enabled(), v8::internal::Heap::SetStackLimits(), v8::internal::Heap::SetUp(), v8::internal::Logger::SetUp(), v8::internal::Builtins::SetUp(), stack_guard_, v8::base::Thread::Start(), state_, stress_deopt_count_, string_tracker_, stub_cache_, sweeper_thread_, SweeperThread, time_millis_at_init_, v8::base::OS::TimeCurrentMillis(), TRACE_ISOLATE, unicode_cache_, and write_iterator_.

Referenced by v8::internal::Snapshot::Initialize(), and v8::Isolate::New().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ initialized_from_snapshot()

bool v8::internal::Isolate::initialized_from_snapshot ( )

inline

Definition at line 1014 of file isolate.h.

1014 { return initialized_from_snapshot_; }

References initialized_from_snapshot_.

◆ InitializeLoggingAndCounters()

void v8::internal::Isolate::InitializeLoggingAndCounters ( )

Definition at line 1818 of file isolate.cc.

                                            {
   if (logger_ == NULL) {
     logger_ = new Logger(this);
   }
   if (counters_ == NULL) {
     counters_ = new Counters(this);
   }
 }

References counters_, logger_, and NULL.

Referenced by v8::internal::Serializer::InitializeCodeAddressMap(), Isolate(), v8::Isolate::New(), PrintStack(), v8::Isolate::SetCounterFunction(), v8::Isolate::SetCreateHistogramFunction(), and v8::Isolate::SetJitCodeEventHandler().

Here is the caller graph for this function:

◆ InitializeOncePerProcess()

void v8::internal::Isolate::InitializeOncePerProcess ( )

static

Definition at line 152 of file isolate.cc.

                                        {
   base::LockGuard<base::Mutex> lock_guard(thread_data_table_mutex_.Pointer());
   CHECK(thread_data_table_ == NULL);
   isolate_key_ = base::Thread::CreateThreadLocalKey();
   thread_id_key_ = base::Thread::CreateThreadLocalKey();
   per_isolate_thread_data_key_ = base::Thread::CreateThreadLocalKey();
   thread_data_table_ = new Isolate::ThreadDataTable();
 }

References CHECK, v8::base::Thread::CreateThreadLocalKey(), isolate_key_, NULL, per_isolate_thread_data_key_, v8::base::LazyInstanceImpl< T, AllocationTrait, CreateTrait, InitOnceTrait, DestroyTrait >::Pointer(), thread_data_table_, thread_data_table_mutex_, and thread_id_key_.

Referenced by v8::internal::V8::InitializeOncePerProcessImpl().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ InitializeThreadLocal()

void v8::internal::Isolate::InitializeThreadLocal ( )

private

Definition at line 1771 of file isolate.cc.

                                     {
   thread_local_top_.isolate_ = this;
   thread_local_top_.Initialize();
 }

References thread_local_top_.

Referenced by ArchiveThread(), and Init().

Here is the caller graph for this function:

◆ INLINE() [1/3]

v8::internal::Isolate::INLINE ( static Isolate * Current() )

inline

Definition at line 480 of file isolate.h.

                                     {
     Isolate* isolate = reinterpret_cast<Isolate*>(
         base::Thread::GetExistingThreadLocal(isolate_key_));
     DCHECK(isolate != NULL);
     return isolate;
   }

References DCHECK, v8::base::Thread::GetExistingThreadLocal(), isolate_key_, and NULL.

Here is the call graph for this function:

◆ INLINE() [2/3]

v8::internal::Isolate::INLINE ( static Isolate * UncheckedCurrent() )

inline

Definition at line 487 of file isolate.h.

                                              {
     return reinterpret_cast<Isolate*>(
         base::Thread::GetThreadLocal(isolate_key_));
   }

References v8::base::Thread::GetThreadLocal(), and isolate_key_.

Here is the call graph for this function:

◆ INLINE() [3/3]

v8::internal::Isolate::INLINE ( static Isolate * UnsafeCurrent() )

inline

Definition at line 494 of file isolate.h.

                                           {
     return reinterpret_cast<Isolate*>(
         base::Thread::GetThreadLocal(isolate_key_));
   }

References v8::base::Thread::GetThreadLocal(), and isolate_key_.

Here is the call graph for this function:

◆ inner_pointer_to_code_cache()

InnerPointerToCodeCache* v8::internal::Isolate::inner_pointer_to_code_cache ( )

inline

Definition at line 911 of file isolate.h.

                                                          {
     return inner_pointer_to_code_cache_;
   }

References inner_pointer_to_code_cache_.

Referenced by v8::internal::MarkCompactCollector::EvacuateNewSpaceAndCandidates(), FindCodeObject(), v8::internal::OptimizedFrame::GetDeoptimizationData(), v8::internal::IC::OnTypeFeedbackChanged(), v8::internal::MarkCompactCollector::RecordCodeTargetPatch(), and v8::internal::IncrementalMarking::RecordCodeTargetPatch().

Here is the caller graph for this function:

◆ interp_canonicalize_mapping()

unibrow::Mapping<unibrow::Ecma262Canonicalize>* v8::internal::Isolate::interp_canonicalize_mapping ( )

inline

Definition at line 963 of file isolate.h.

                                     {
     return &interp_canonicalize_mapping_;
   }

References interp_canonicalize_mapping_.

Referenced by v8::internal::RawMatch().

Here is the caller graph for this function:

◆ InvokeApiInterruptCallback()

void v8::internal::Isolate::InvokeApiInterruptCallback ( )

Definition at line 812 of file isolate.cc.

                                          {
   // Note: callback below should be called outside of execution access lock.
   InterruptCallback callback = NULL;
   void* data = NULL;
   {
     ExecutionAccess access(this);
     callback = api_interrupt_callback_;
     data = api_interrupt_callback_data_;
     api_interrupt_callback_ = NULL;
     api_interrupt_callback_data_ = NULL;
   }
  
   if (callback != NULL) {
     VMState<EXTERNAL> state(this);
     HandleScope handle_scope(this);
     callback(reinterpret_cast<v8::Isolate*>(this), data);
   }
 }

References ExecutionAccess, and NULL.

◆ is_catchable_by_javascript()

bool v8::internal::Isolate::is_catchable_by_javascript ( Object * exception )

inline

Definition at line 639 of file isolate.h.

                                                      {
     return exception != heap()->termination_exception();
   }

References heap().

Referenced by DoThrow(), PropagatePendingExceptionToExternalTryCatch(), and ReThrow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsDead()

bool v8::internal::Isolate::IsDead ( )

inline

Definition at line 1009 of file isolate.h.

1009 { return has_fatal_error_; }

References has_fatal_error_.

Referenced by v8::V8::IsDead().

Here is the caller graph for this function:

◆ IsErrorObject()

bool v8::internal::Isolate::IsErrorObject ( Handle< Object > obj )

private

Definition at line 981 of file isolate.cc.

                                               {
   if (!obj->IsJSObject()) return false;
  
   Handle<String> error_key =
       factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("$Error"));
   Handle<Object> error_constructor = Object::GetProperty(
       js_builtins_object(), error_key).ToHandleChecked();
  
   DisallowHeapAllocation no_gc;
   for (PrototypeIterator iter(this, *obj, PrototypeIterator::START_AT_RECEIVER);
        !iter.IsAtEnd(); iter.Advance()) {
     if (iter.GetCurrent()->IsJSProxy()) return false;
     if (JSObject::cast(iter.GetCurrent())->map()->constructor() ==
         *error_constructor) {
       return true;
     }
   }
   return false;
 }

References factory(), v8::internal::Object::GetProperty(), v8::internal::PrototypeIterator::IsAtEnd(), js_builtins_object(), v8::internal::PrototypeIterator::START_AT_RECEIVER, and STATIC_CHAR_VECTOR.

Referenced by DoThrow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsFastArrayConstructorPrototypeChainIntact()

bool v8::internal::Isolate::IsFastArrayConstructorPrototypeChainIntact ( )

Definition at line 2181 of file isolate.cc.

                                                          {
   Map* root_array_map =
       get_initial_js_array_map(GetInitialFastElementsKind());
   DCHECK(root_array_map != NULL);
   JSObject* initial_array_proto = JSObject::cast(*initial_array_prototype());
  
   // Check that the array prototype hasn't been altered WRT empty elements.
   if (root_array_map->prototype() != initial_array_proto) return false;
   if (initial_array_proto->elements() != heap()->empty_fixed_array()) {
     return false;
   }
  
   // Check that the object prototype hasn't been altered WRT empty elements.
   JSObject* initial_object_proto = JSObject::cast(*initial_object_prototype());
   PrototypeIterator iter(this, initial_array_proto);
   if (iter.IsAtEnd() || iter.GetCurrent() != initial_object_proto) {
     return false;
   }
   if (initial_object_proto->elements() != heap()->empty_fixed_array()) {
     return false;
   }
  
   iter.Advance();
   return iter.IsAtEnd();
 }

References v8::internal::PrototypeIterator::Advance(), DCHECK, get_initial_js_array_map(), v8::internal::PrototypeIterator::GetCurrent(), v8::internal::GetInitialFastElementsKind(), heap(), v8::internal::PrototypeIterator::IsAtEnd(), and NULL.

Here is the call graph for this function:

◆ IsFinallyOnTop()

bool v8::internal::Isolate::IsFinallyOnTop ( )

Definition at line 1165 of file isolate.cc.

                              {
   // Get the address of the external handler so we can compare the address to
   // determine which one is closer to the top of the stack.
   Address external_handler_address =
       thread_local_top()->try_catch_handler_address();
   DCHECK(external_handler_address != NULL);
  
   // The exception has been externally caught if and only if there is
   // an external handler which is on top of the top-most try-finally
   // handler.
   // There should be no try-catch blocks as they would prohibit us from
   // finding external catcher in the first place (see catcher_ check above).
   //
   // Note, that finally clause would rethrow an exception unless it's
   // aborted by jumps in control flow like return, break, etc. and we'll
   // have another chances to set proper v8::TryCatch.
   StackHandler* handler =
       StackHandler::FromAddress(Isolate::handler(thread_local_top()));
   while (handler != NULL && handler->address() < external_handler_address) {
     DCHECK(!handler->is_catch());
     if (handler->is_finally()) return true;
  
     handler = handler->next();
   }
  
   return false;
 }

References DCHECK, handler(), NULL, and thread_local_top().

Referenced by PropagatePendingExceptionToExternalTryCatch().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsInitialized()

bool v8::internal::Isolate::IsInitialized ( )

inline

Definition at line 508 of file isolate.h.

508 { return state_ == INITIALIZED; }

References INITIALIZED, and state_.

Referenced by v8::Debug::Call(), v8::Date::DateTimeConfigurationChangeNotification(), v8::Isolate::GetHeapStatistics(), v8::Debug::GetMirror(), v8::internal::TickSample::Init(), v8::Locker::Initialize(), v8::IsExecutionTerminatingCheck(), v8::Number::New(), v8::Integer::New(), v8::Integer::NewFromUnsigned(), PrintStack(), v8::internal::SamplerThread::Run(), v8::internal::IncrementalMarking::Start(), and v8::internal::IncrementalMarking::WorthActivating().

Here is the caller graph for this function:

◆ IsInUse()

bool v8::internal::Isolate::IsInUse ( )

inline

Definition at line 511 of file isolate.h.

511 { return entry_stack_ != NULL; }

References entry_stack_, and NULL.

Referenced by v8::Isolate::Dispose().

Here is the caller graph for this function:

◆ isolate_key()

static base::Thread::LocalStorageKey v8::internal::Isolate::isolate_key ( )

inlinestatic

Definition at line 531 of file isolate.h.

                                                  {
     return isolate_key_;
   }

References isolate_key_.

◆ Iterate() [1/3]

void v8::internal::Isolate::Iterate ( ObjectVisitor * v )

Definition at line 206 of file isolate.cc.

                                       {
   ThreadLocalTop* current_t = thread_local_top();
   Iterate(v, current_t);
 }

References thread_local_top().

Referenced by v8::internal::ThreadManager::Iterate(), Iterate(), and v8::internal::Heap::IterateStrongRoots().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Iterate() [2/3]

char * v8::internal::Isolate::Iterate	(	ObjectVisitor *	v,
		char *	t
	)

Definition at line 167 of file isolate.cc.

                                                              {
   ThreadLocalTop* thread = reinterpret_cast<ThreadLocalTop*>(thread_storage);
   Iterate(v, thread);
   return thread_storage + sizeof(ThreadLocalTop);
 }

References Iterate().

Here is the call graph for this function:

◆ Iterate() [3/3]

void v8::internal::Isolate::Iterate	(	ObjectVisitor *	v,
		ThreadLocalTop *	t
	)

Definition at line 180 of file isolate.cc.

                                                               {
   // Visit the roots from the top for a given thread.
   v->VisitPointer(&thread->pending_exception_);
   v->VisitPointer(&(thread->pending_message_obj_));
   v->VisitPointer(bit_cast<Object**>(&(thread->pending_message_script_)));
   v->VisitPointer(bit_cast<Object**>(&(thread->context_)));
   v->VisitPointer(&thread->scheduled_exception_);
  
   for (v8::TryCatch* block = thread->try_catch_handler();
        block != NULL;
        block = block->next_) {
     v->VisitPointer(bit_cast<Object**>(&(block->exception_)));
     v->VisitPointer(bit_cast<Object**>(&(block->message_obj_)));
     v->VisitPointer(bit_cast<Object**>(&(block->message_script_)));
   }
  
   // Iterate over pointers on native execution stack.
   for (StackFrameIterator it(this, thread); !it.done(); it.Advance()) {
     it.frame()->Iterate(v);
   }
  
   // Iterate pointers in live lookup results.
   thread->top_lookup_result_->Iterate(v);
 }

References v8::internal::StackFrameIterator::Advance(), and NULL.

Here is the call graph for this function:

◆ IterateDeferredHandles()

void v8::internal::Isolate::IterateDeferredHandles ( ObjectVisitor * visitor )

Definition at line 212 of file isolate.cc.

                                                            {
   for (DeferredHandles* deferred = deferred_handles_head_;
        deferred != NULL;
        deferred = deferred->next_) {
     deferred->Iterate(visitor);
   }
 }

References deferred_handles_head_, and NULL.

Referenced by v8::internal::Heap::IterateStrongRoots().

Here is the caller graph for this function:

◆ IterateThread()

void v8::internal::Isolate::IterateThread	(	ThreadVisitor *	v,
		char *	t
	)

Definition at line 174 of file isolate.cc.

                                                      {
   ThreadLocalTop* thread = reinterpret_cast<ThreadLocalTop*>(t);
   v->VisitThread(this, thread);
 }

References v8::internal::ThreadVisitor::VisitThread().

Referenced by v8::internal::ThreadManager::IterateArchivedThreads().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ js_builtins_object()

Handle<JSBuiltinsObject> v8::internal::Isolate::js_builtins_object ( )

inline

Definition at line 679 of file isolate.h.

                                                 {
     return Handle<JSBuiltinsObject>(thread_local_top_.context_->builtins());
   }

References thread_local_top_.

Referenced by v8::CallV8HeapFunction(), CaptureSimpleStackTrace(), v8::internal::Debug::CheckBreakPoint(), v8::CheckConstructor(), v8::internal::MessageHandler::GetMessage(), IsErrorObject(), v8::internal::Debug::OnAfterCompile(), v8::internal::Debug::PromiseHasRejectHandler(), StackOverflow(), and v8::internal::BinaryOpIC::Transition().

Here is the caller graph for this function:

◆ js_entry_sp()

Address v8::internal::Isolate::js_entry_sp ( )

inline

Definition at line 658 of file isolate.h.

                         {
     return thread_local_top_.js_entry_sp_;
   }

References thread_local_top_.

Referenced by v8::internal::TickSample::Init(), and v8::CpuProfiler::SetIdle().

Here is the caller graph for this function:

◆ js_entry_sp_address()

Address* v8::internal::Isolate::js_entry_sp_address ( )

inline

Definition at line 661 of file isolate.h.

                                         {
     return &thread_local_top_.js_entry_sp_;
   }

References thread_local_top_.

◆ jsregexp_canonrange()

unibrow::Mapping<unibrow::CanonicalizationRange>* v8::internal::Isolate::jsregexp_canonrange ( )

inline

Definition at line 929 of file isolate.h.

                                                                       {
     return &jsregexp_canonrange_;
   }

References jsregexp_canonrange_.

Referenced by v8::internal::CharacterRange::AddCaseEquivalents().

Here is the caller graph for this function:

◆ jsregexp_uncanonicalize()

unibrow::Mapping<unibrow::Ecma262UnCanonicalize>* v8::internal::Isolate::jsregexp_uncanonicalize ( )

inline

Definition at line 925 of file isolate.h.

                                                                           {
     return &jsregexp_uncanonicalize_;
   }

References jsregexp_uncanonicalize_.

Referenced by v8::internal::CharacterRange::AddCaseEquivalents(), and v8::internal::GetCaseIndependentLetters().

Here is the caller graph for this function:

◆ keyed_lookup_cache()

KeyedLookupCache* v8::internal::Isolate::keyed_lookup_cache ( )

inline

Definition at line 887 of file isolate.h.

                                          {
     return keyed_lookup_cache_;
   }

References keyed_lookup_cache_.

Referenced by v8::internal::Heap::CreateInitialObjects(), and v8::internal::Heap::MarkCompactPrologue().

Here is the caller graph for this function:

◆ LinkDeferredHandles()

void v8::internal::Isolate::LinkDeferredHandles ( DeferredHandles * deferred_handles )

Definition at line 2106 of file isolate.cc.

                                                            {
   deferred->next_ = deferred_handles_head_;
   if (deferred_handles_head_ != NULL) {
     deferred_handles_head_->previous_ = deferred;
   }
   deferred_handles_head_ = deferred;
 }

References deferred_handles_head_, v8::internal::DeferredHandles::next_, NULL, and v8::internal::DeferredHandles::previous_.

Referenced by v8::internal::DeferredHandles::DeferredHandles().

Here is the caller graph for this function:

◆ logger()

Logger* v8::internal::Isolate::logger ( )

inline

Definition at line 866 of file isolate.h.

                    {
     // Call InitializeLoggingAndCounters() if logging is needed before
     // the isolate is fully initialized.
     DCHECK(logger_ != NULL);
     return logger_;
   }

References DCHECK, logger_, and NULL.

Referenced by v8::internal::CodeAddressMap::CodeAddressMap(), v8::internal::Profiler::Disengage(), v8::internal::Profiler::Engage(), v8::internal::Debug::EnqueueCommandMessage(), v8::Isolate::New(), v8::internal::Debug::NotifyMessageHandler(), v8::internal::Heap::OnMoveEvent(), v8::internal::RecordFunctionCompilation(), v8::internal::Heap::SelectScavengingVisitorsTable(), v8::Isolate::SetJitCodeEventHandler(), v8::internal::CpuProfiler::StartProcessorIfNotStarted(), v8::internal::CpuProfiler::StopProcessor(), and v8::internal::CodeAddressMap::~CodeAddressMap().

Here is the caller graph for this function:

◆ MarkCompactEpilogue()

void v8::internal::Isolate::MarkCompactEpilogue	(	bool	is_compacting,
		ThreadLocalTop *	archived_thread_data
	)

private

◆ MarkCompactPrologue()

void v8::internal::Isolate::MarkCompactPrologue	(	bool	is_compacting,
		ThreadLocalTop *	archived_thread_data
	)

private

◆ materialized_object_store()

MaterializedObjectStore* v8::internal::Isolate::materialized_object_store ( )

inline

Definition at line 879 of file isolate.h.

                                                        {
     return materialized_object_store_;
   }

References materialized_object_store_.

Referenced by v8::internal::Deoptimizer::MaterializeHeapObjects().

Here is the caller graph for this function:

◆ MayIndexedAccess()

bool v8::internal::Isolate::MayIndexedAccess	(	Handle< JSObject >	receiver,
		uint32_t	index,
		v8::AccessType	type
	)

Definition at line 736 of file isolate.cc.

                                                   {
   DCHECK(receiver->IsJSGlobalProxy() || receiver->IsAccessCheckNeeded());
   // Check for compatibility between the security tokens in the
   // current lexical context and the accessed object.
   DCHECK(context());
  
   MayAccessDecision decision = MayAccessPreCheck(this, receiver, type);
   if (decision != UNKNOWN) return decision == YES;
  
   HandleScope scope(this);
   Handle<Object> data;
   v8::IndexedSecurityCallback callback;
   { DisallowHeapAllocation no_gc;
     // Get named access check callback
     AccessCheckInfo* access_check_info = GetAccessCheckInfo(this, receiver);
     if (!access_check_info) return false;
     Object* fun_obj = access_check_info->indexed_callback();
     callback = v8::ToCData<v8::IndexedSecurityCallback>(fun_obj);
     if (!callback) return false;
     data = handle(access_check_info->data(), this);
   }
  
   LOG(this, ApiIndexedSecurityCheck(index));
  
   // Leaving JavaScript.
   VMState<EXTERNAL> state(this);
   return callback(
       v8::Utils::ToLocal(receiver), index, type, v8::Utils::ToLocal(data));
 }

References context(), DCHECK, v8::internal::GetAccessCheckInfo(), v8::internal::handle(), LOG, v8::internal::MayAccessPreCheck(), v8::Utils::ToLocal(), v8::internal::UNKNOWN, and v8::internal::YES.

Referenced by v8::internal::JSObject::DeleteElement(), v8::internal::JSObject::GetElementAttributeWithReceiver(), v8::internal::Object::GetElementWithReceiver(), v8::internal::JSObject::HasRealElementProperty(), and v8::internal::JSObject::SetElement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MayNamedAccess()

bool v8::internal::Isolate::MayNamedAccess	(	Handle< JSObject >	receiver,
		Handle< Object >	key,
		v8::AccessType	type
	)

Definition at line 697 of file isolate.cc.

                                                 {
   DCHECK(receiver->IsJSGlobalProxy() || receiver->IsAccessCheckNeeded());
  
   // Skip checks for hidden properties access.  Note, we do not
   // require existence of a context in this case.
   if (key.is_identical_to(factory()->hidden_string())) return true;
  
   // Check for compatibility between the security tokens in the
   // current lexical context and the accessed object.
   DCHECK(context());
  
   MayAccessDecision decision = MayAccessPreCheck(this, receiver, type);
   if (decision != UNKNOWN) return decision == YES;
  
   HandleScope scope(this);
   Handle<Object> data;
   v8::NamedSecurityCallback callback;
   { DisallowHeapAllocation no_gc;
     AccessCheckInfo* access_check_info = GetAccessCheckInfo(this, receiver);
     if (!access_check_info) return false;
     Object* fun_obj = access_check_info->named_callback();
     callback = v8::ToCData<v8::NamedSecurityCallback>(fun_obj);
     if (!callback) return false;
     data = handle(access_check_info->data(), this);
   }
  
   LOG(this, ApiNamedSecurityCheck(*key));
  
   // Leaving JavaScript.
   VMState<EXTERNAL> state(this);
   return callback(v8::Utils::ToLocal(receiver),
                   v8::Utils::ToLocal(key),
                   type,
                   v8::Utils::ToLocal(data));
 }

References context(), DCHECK, factory(), v8::internal::GetAccessCheckInfo(), v8::internal::handle(), LOG, v8::internal::MayAccessPreCheck(), v8::Utils::ToLocal(), v8::internal::UNKNOWN, and v8::internal::YES.

Referenced by v8::internal::JSObject::DefineAccessor(), v8::internal::JSObject::Freeze(), v8::internal::JSObject::GetAccessor(), v8::internal::JSReceiver::GetKeys(), v8::internal::JSObject::PreventExtensions(), v8::internal::JSObject::SetAccessor(), and v8::internal::StoreToSuper().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ memory_allocator()

MemoryAllocator* v8::internal::Isolate::memory_allocator ( )

inline

Definition at line 883 of file isolate.h.

                                       {
     return memory_allocator_;
   }

References memory_allocator_.

Here is the caller graph for this function:

◆ native_context()

Handle< Context > v8::internal::Isolate::native_context ( )

Definition at line 1339 of file isolate.cc.

                                         {
   return handle(context()->native_context());
 }

References context(), and v8::internal::handle().

Referenced by v8::internal::CallJsBuiltin(), v8::internal::Debug::CompileDebuggerScript(), v8::internal::CompileToplevel(), get_initial_js_array_map(), v8::internal::IC::GetHandlerCacheHolder(), v8::internal::IC::GetICCacheHolder(), v8::internal::AstValue::Internalize(), v8::internal::Map::Normalize(), v8::internal::TypedArrayMap(), and v8::internal::UnscopableLookup().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ NewForTesting()

static Isolate* v8::internal::Isolate::NewForTesting ( )

inlinestatic

Definition at line 1114 of file isolate.h.

1114 { return new Isolate(); }

References Isolate().

Here is the call graph for this function:

◆ NextOptimizationId()

int v8::internal::Isolate::NextOptimizationId ( )

inline

Definition at line 1090 of file isolate.h.

                            {
     int id = next_optimization_id_++;
     if (!Smi::IsValid(next_optimization_id_)) {
       next_optimization_id_ = 0;
     }
     return id;
   }

References id(), v8::internal::Smi::IsValid(), and next_optimization_id_.

Referenced by v8::internal::CompilationInfo::SetOptimizing().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ NO_INLINE()

v8::internal::Isolate::NO_INLINE ( void PushStackTraceAndDieunsigned int magic, Object *object, Map *map, unsigned int magic2 )

◆ NotifyExtensionInstalled()

void v8::internal::Isolate::NotifyExtensionInstalled ( )

inline

Definition at line 949 of file isolate.h.

                                   {
     has_installed_extensions_ = true;
   }

References has_installed_extensions_.

◆ num_sweeper_threads()

int v8::internal::Isolate::num_sweeper_threads ( ) const

inline

Definition at line 1063 of file isolate.h.

                                   {
     return num_sweeper_threads_;
   }

References num_sweeper_threads_.

Referenced by v8::internal::MarkCompactCollector::EnsureSweepingCompleted(), v8::internal::MarkCompactCollector::IsSweepingCompleted(), and v8::internal::MarkCompactCollector::StartSweeperThreads().

Here is the caller graph for this function:

◆ objects_string_compare_iterator_a()

ConsStringIteratorOp* v8::internal::Isolate::objects_string_compare_iterator_a ( )

inline

Definition at line 933 of file isolate.h.

                                                             {
     return &objects_string_compare_iterator_a_;
   }

References objects_string_compare_iterator_a_.

Referenced by v8::internal::String::SlowEquals().

Here is the caller graph for this function:

◆ objects_string_compare_iterator_b()

ConsStringIteratorOp* v8::internal::Isolate::objects_string_compare_iterator_b ( )

inline

Definition at line 937 of file isolate.h.

                                                             {
     return &objects_string_compare_iterator_b_;
   }

References objects_string_compare_iterator_b_.

Referenced by v8::internal::String::SlowEquals().

Here is the caller graph for this function:

◆ objects_string_iterator()

StaticResource<ConsStringIteratorOp>* v8::internal::Isolate::objects_string_iterator ( )

inline

Definition at line 941 of file isolate.h.

                                                                   {
     return &objects_string_iterator_;
   }

References objects_string_iterator_.

Referenced by v8::internal::String::ToCString(), and v8::internal::String::ToWideCString().

Here is the caller graph for this function:

◆ optimizing_compiler_thread()

OptimizingCompilerThread* v8::internal::Isolate::optimizing_compiler_thread ( )

inline

Definition at line 1059 of file isolate.h.

                                                          {
     return optimizing_compiler_thread_;
   }

References optimizing_compiler_thread_.

Referenced by v8::internal::Heap::CollectAllAvailableGarbage(), v8::internal::Heap::GarbageCollectionPrologue(), v8::internal::GetOptimizedCodeLater(), v8::internal::Heap::NotifyContextDisposed(), v8::internal::RuntimeProfiler::Optimize(), and v8::internal::Debug::PrepareForBreakPoints().

Here is the caller graph for this function:

◆ OptionalRescheduleException()

bool v8::internal::Isolate::OptionalRescheduleException ( bool is_bottom_call )

Definition at line 1244 of file isolate.cc.

                                                              {
   DCHECK(has_pending_exception());
   PropagatePendingExceptionToExternalTryCatch();
  
   bool is_termination_exception =
       pending_exception() == heap_.termination_exception();
  
   // Do not reschedule the exception if this is the bottom call.
   bool clear_exception = is_bottom_call;
  
   if (is_termination_exception) {
     if (is_bottom_call) {
       thread_local_top()->external_caught_exception_ = false;
       clear_pending_exception();
       return false;
     }
   } else if (thread_local_top()->external_caught_exception_) {
     // If the exception is externally caught, clear it if there are no
     // JavaScript frames on the way to the C++ frame that has the
     // external handler.
     DCHECK(thread_local_top()->try_catch_handler_address() != NULL);
     Address external_handler_address =
         thread_local_top()->try_catch_handler_address();
     JavaScriptFrameIterator it(this);
     if (it.done() || (it.frame()->sp() > external_handler_address)) {
       clear_exception = true;
     }
   }
  
   // Clear the exception if needed.
   if (clear_exception) {
     thread_local_top()->external_caught_exception_ = false;
     clear_pending_exception();
     return false;
   }
  
   // Reschedule the exception.
   thread_local_top()->scheduled_exception_ = pending_exception();
   clear_pending_exception();
   return true;
 }

References clear_pending_exception(), DCHECK, has_pending_exception(), heap_, NULL, pending_exception(), PropagatePendingExceptionToExternalTryCatch(), thread_local_top(), and try_catch_handler_address().

Referenced by v8::internal::ModuleGetExport(), and v8::internal::ModuleSetExport().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pending_exception()

Object* v8::internal::Isolate::pending_exception ( )

inline

Definition at line 561 of file isolate.h.

                               {
     DCHECK(has_pending_exception());
     DCHECK(!thread_local_top_.pending_exception_->IsException());
     return thread_local_top_.pending_exception_;
   }

References DCHECK, has_pending_exception(), and thread_local_top_.

Referenced by CancelTerminateExecution(), v8::internal::LiveEdit::GatherCompileInfo(), OptionalRescheduleException(), PropagatePendingExceptionToExternalTryCatch(), v8::internal::MessageHandler::ReportMessage(), and ScheduleThrow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pending_exception_address()

Object** v8::internal::Isolate::pending_exception_address ( )

inline

Definition at line 577 of file isolate.h.

                                        {
     return &thread_local_top_.pending_exception_;
   }

References thread_local_top_.

◆ pending_message_obj_address()

Address v8::internal::Isolate::pending_message_obj_address ( )

inline

Definition at line 609 of file isolate.h.

                                         {
     return reinterpret_cast<Address>(&thread_local_top_.pending_message_obj_);
   }

References thread_local_top_.

◆ pending_message_script_address()

Address v8::internal::Isolate::pending_message_script_address ( )

inline

Definition at line 617 of file isolate.h.

                                            {
     return reinterpret_cast<Address>(
         &thread_local_top_.pending_message_script_);
   }

References thread_local_top_.

◆ per_isolate_thread_data_key()

static base::Thread::LocalStorageKey v8::internal::Isolate::per_isolate_thread_data_key ( )

static

◆ PopPromise()

void v8::internal::Isolate::PopPromise ( )

Definition at line 1297 of file isolate.cc.

                          {
   ThreadLocalTop* tltop = thread_local_top();
   if (tltop->promise_on_stack_ == NULL) return;
   PromiseOnStack* prev = tltop->promise_on_stack_->prev();
   Handle<Object> global_handle = tltop->promise_on_stack_->promise();
   delete tltop->promise_on_stack_;
   tltop->promise_on_stack_ = prev;
   global_handles()->Destroy(global_handle.location());
 }

References v8::internal::GlobalHandles::Destroy(), global_handles(), NULL, v8::internal::PromiseOnStack::prev(), and thread_local_top().

Here is the call graph for this function:

◆ PrintCurrentStackTrace()

void v8::internal::Isolate::PrintCurrentStackTrace ( FILE * out )

Definition at line 904 of file isolate.cc.

                                               {
   StackTraceFrameIterator it(this);
   while (!it.done()) {
     HandleScope scope(this);
     // Find code position if recorded in relocation info.
     JavaScriptFrame* frame = it.frame();
     int pos = frame->LookupCode()->SourcePosition(frame->pc());
     Handle<Object> pos_obj(Smi::FromInt(pos), this);
     // Fetch function and receiver.
     Handle<JSFunction> fun(frame->function());
     Handle<Object> recv(frame->receiver(), this);
     // Advance to the next JavaScript frame and determine if the
     // current frame is the top-level frame.
     it.Advance();
     Handle<Object> is_top_level = it.done()
         ? factory()->true_value()
         : factory()->false_value();
     // Generate and print stack trace line.
     Handle<String> line =
         Execution::GetStackTraceLine(recv, fun, pos_obj, is_top_level);
     if (line->length() > 0) {
       line->PrintOn(out);
       PrintF(out, "\n");
     }
   }
 }

References v8::internal::StackTraceFrameIterator::Advance(), factory(), v8::internal::Smi::FromInt(), v8::internal::JavaScriptFrame::function(), v8::internal::PrintF(), and v8::internal::JavaScriptFrame::receiver().

Referenced by DoThrow(), and v8::Message::PrintCurrentStackTrace().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintStack() [1/2]

void v8::internal::Isolate::PrintStack ( FILE * out )

Definition at line 553 of file isolate.cc.

                                   {
   if (stack_trace_nesting_level_ == 0) {
     stack_trace_nesting_level_++;
     StringStream::ClearMentionedObjectCache(this);
     HeapStringAllocator allocator;
     StringStream accumulator(&allocator);
     incomplete_message_ = &accumulator;
     PrintStack(&accumulator);
     accumulator.OutputToFile(out);
     InitializeLoggingAndCounters();
     accumulator.Log(this);
     incomplete_message_ = NULL;
     stack_trace_nesting_level_ = 0;
   } else if (stack_trace_nesting_level_ == 1) {
     stack_trace_nesting_level_++;
     base::OS::PrintError(
       "\n\nAttempt to print stack while printing stack (double fault)\n");
     base::OS::PrintError(
       "If you are lucky you may find a partial stack dump on stdout.\n\n");
     incomplete_message_->OutputToFile(out);
   }
 }

References incomplete_message_, InitializeLoggingAndCounters(), NULL, v8::base::OS::PrintError(), PrintStack(), and stack_trace_nesting_level_.

Here is the call graph for this function:

◆ PrintStack() [2/2]

void v8::internal::Isolate::PrintStack ( StringStream * accumulator )

Definition at line 587 of file isolate.cc.

                                                   {
   if (!IsInitialized()) {
     accumulator->Add(
         "\n==== JS stack trace is not available =======================\n\n");
     accumulator->Add(
         "\n==== Isolate for the thread is not initialized =============\n\n");
     return;
   }
   // The MentionedObjectCache is not GC-proof at the moment.
   DisallowHeapAllocation no_gc;
   DCHECK(StringStream::IsMentionedObjectCacheClear(this));
  
   // Avoid printing anything if there are no frames.
   if (c_entry_fp(thread_local_top()) == 0) return;
  
   accumulator->Add(
       "\n==== JS stack trace =========================================\n\n");
   PrintFrames(this, accumulator, StackFrame::OVERVIEW);
  
   accumulator->Add(
       "\n==== Details ================================================\n\n");
   PrintFrames(this, accumulator, StackFrame::DETAILS);
  
   accumulator->PrintMentionedObjectCache(this);
   accumulator->Add("=====================\n\n");
 }

References c_entry_fp(), DCHECK, IsInitialized(), v8::internal::PrintFrames(), and thread_local_top().

Referenced by PrintStack(), StackTraceString(), and ThrowIllegalOperation().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PromoteScheduledException()

Object * v8::internal::Isolate::PromoteScheduledException ( )

Definition at line 896 of file isolate.cc.

                                            {
   Object* thrown = scheduled_exception();
   clear_scheduled_exception();
   // Re-throw the exception to avoid getting repeated error reporting.
   return ReThrow(thrown);
 }

References clear_scheduled_exception(), ReThrow(), and scheduled_exception().

Here is the call graph for this function:

◆ PropagatePendingExceptionToExternalTryCatch()

bool v8::internal::Isolate::PropagatePendingExceptionToExternalTryCatch ( )

private

Definition at line 1777 of file isolate.cc.

                                                           {
   DCHECK(has_pending_exception());
  
   bool has_external_try_catch = HasExternalTryCatch();
   if (!has_external_try_catch) {
     thread_local_top_.external_caught_exception_ = false;
     return true;
   }
  
   bool catchable_by_js = is_catchable_by_javascript(pending_exception());
   if (catchable_by_js && IsFinallyOnTop()) {
     thread_local_top_.external_caught_exception_ = false;
     return false;
   }
  
   thread_local_top_.external_caught_exception_ = true;
   if (thread_local_top_.pending_exception_ == heap()->termination_exception()) {
     try_catch_handler()->can_continue_ = false;
     try_catch_handler()->has_terminated_ = true;
     try_catch_handler()->exception_ = heap()->null_value();
   } else {
     v8::TryCatch* handler = try_catch_handler();
     DCHECK(thread_local_top_.pending_message_obj_->IsJSMessageObject() ||
            thread_local_top_.pending_message_obj_->IsTheHole());
     DCHECK(thread_local_top_.pending_message_script_->IsScript() ||
            thread_local_top_.pending_message_script_->IsTheHole());
     handler->can_continue_ = true;
     handler->has_terminated_ = false;
     handler->exception_ = pending_exception();
     // Propagate to the external try-catch only if we got an actual message.
     if (thread_local_top_.pending_message_obj_->IsTheHole()) return true;
  
     handler->message_obj_ = thread_local_top_.pending_message_obj_;
     handler->message_script_ = thread_local_top_.pending_message_script_;
     handler->message_start_pos_ = thread_local_top_.pending_message_start_pos_;
     handler->message_end_pos_ = thread_local_top_.pending_message_end_pos_;
   }
   return true;
 }

References v8::TryCatch::can_continue_, DCHECK, v8::TryCatch::exception_, handler(), has_pending_exception(), v8::TryCatch::has_terminated_, HasExternalTryCatch(), heap(), is_catchable_by_javascript(), IsFinallyOnTop(), pending_exception(), thread_local_top_, and try_catch_handler().

Referenced by OptionalRescheduleException(), ReportPendingMessages(), and ScheduleThrow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PushPromise()

void v8::internal::Isolate::PushPromise ( Handle< JSObject > promise )

Definition at line 1287 of file isolate.cc.

                                                   {
   ThreadLocalTop* tltop = thread_local_top();
   PromiseOnStack* prev = tltop->promise_on_stack_;
   StackHandler* handler = StackHandler::FromAddress(Isolate::handler(tltop));
   Handle<JSObject> global_handle =
       Handle<JSObject>::cast(global_handles()->Create(*promise));
   tltop->promise_on_stack_ = new PromiseOnStack(handler, global_handle, prev);
 }

References v8::internal::Handle< T >::cast(), global_handles(), handler(), and thread_local_top().

Here is the call graph for this function:

◆ PushToPartialSnapshotCache()

void v8::internal::Isolate::PushToPartialSnapshotCache ( Object * obj )

Definition at line 1656 of file isolate.cc.

                                                     {
   int length = serialize_partial_snapshot_cache_length();
   int capacity = serialize_partial_snapshot_cache_capacity();
  
   if (length >= capacity) {
     int new_capacity = static_cast<int>((capacity + 10) * 1.2);
     Object** new_array = new Object*[new_capacity];
     for (int i = 0; i < length; i++) {
       new_array[i] = serialize_partial_snapshot_cache()[i];
     }
     if (capacity != 0) delete[] serialize_partial_snapshot_cache();
     set_serialize_partial_snapshot_cache(new_array);
     set_serialize_partial_snapshot_cache_capacity(new_capacity);
   }
  
   serialize_partial_snapshot_cache()[length] = obj;
   set_serialize_partial_snapshot_cache_length(length + 1);
 }

Referenced by Init(), v8::internal::SerializerDeserializer::Iterate(), and v8::internal::PartialSerializer::PartialSnapshotCacheIndex().

Here is the caller graph for this function:

◆ random_number_generator()

base::RandomNumberGenerator * v8::internal::Isolate::random_number_generator ( )

inline

Definition at line 33 of file isolate-inl.h.

                                                             {
   if (random_number_generator_ == NULL) {
     if (FLAG_random_seed != 0) {
       random_number_generator_ =
           new base::RandomNumberGenerator(FLAG_random_seed);
     } else {
       random_number_generator_ = new base::RandomNumberGenerator();
     }
   }
   return random_number_generator_;
 }

References NULL.

Referenced by v8::internal::Heap::AllocateSymbol(), v8::internal::AssemblerBase::AssemblerBase(), v8::internal::GenerateIdentityHash(), and v8::internal::Heap::SetUp().

Here is the caller graph for this function:

◆ regexp_macro_assembler_canonicalize()

unibrow::Mapping<unibrow::Ecma262Canonicalize>* v8::internal::Isolate::regexp_macro_assembler_canonicalize ( )

inline

Definition at line 956 of file isolate.h.

                                             {
     return &regexp_macro_assembler_canonicalize_;
   }

References regexp_macro_assembler_canonicalize_.

Referenced by v8::internal::NativeRegExpMacroAssembler::CaseInsensitiveCompareUC16().

Here is the caller graph for this function:

◆ regexp_stack()

RegExpStack* v8::internal::Isolate::regexp_stack ( )

inline

Definition at line 960 of file isolate.h.

960 { return regexp_stack_; }

References regexp_stack_.

Referenced by v8::internal::ThreadManager::EagerlyArchiveThread(), v8::internal::ThreadManager::FreeThreadResources(), v8::internal::NativeRegExpMacroAssembler::GrowStack(), and v8::internal::ThreadManager::RestoreThread().

Here is the caller graph for this function:

◆ RegisterTryCatchHandler()

void v8::internal::Isolate::RegisterTryCatchHandler ( v8::TryCatch * that )

Definition at line 244 of file isolate.cc.

                                                       {
   thread_local_top()->set_try_catch_handler(that);
 }

References thread_local_top().

Referenced by v8::TryCatch::TryCatch().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RemoveCallCompletedCallback()

void v8::internal::Isolate::RemoveCallCompletedCallback ( CallCompletedCallback callback )

Definition at line 2256 of file isolate.cc.

                                                                         {
   for (int i = 0; i < call_completed_callbacks_.length(); i++) {
     if (callback == call_completed_callbacks_.at(i)) {
       call_completed_callbacks_.Remove(i);
     }
   }
 }

References v8::internal::List< T, AllocationPolicy >::at(), call_completed_callbacks_, and v8::internal::List< T, AllocationPolicy >::Remove().

Referenced by v8::Isolate::RemoveCallCompletedCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ReportFailedAccessCheck()

void v8::internal::Isolate::ReportFailedAccessCheck	(	Handle< JSObject >	receiver,
		v8::AccessType	type
	)

Definition at line 634 of file isolate.cc.

                                                          {
   if (!thread_local_top()->failed_access_check_callback_) {
     Handle<String> message = factory()->InternalizeUtf8String("no access");
     Handle<Object> error;
     ASSIGN_RETURN_ON_EXCEPTION_VALUE(
         this, error, factory()->NewTypeError(message), /* void */);
     ScheduleThrow(*error);
     return;
   }
  
   DCHECK(receiver->IsAccessCheckNeeded());
   DCHECK(context());
  
   // Get the data object from access check info.
   HandleScope scope(this);
   Handle<Object> data;
   { DisallowHeapAllocation no_gc;
     AccessCheckInfo* access_check_info = GetAccessCheckInfo(this, receiver);
     if (!access_check_info) return;
     data = handle(access_check_info->data(), this);
   }
  
   // Leaving JavaScript.
   VMState<EXTERNAL> state(this);
   thread_local_top()->failed_access_check_callback_(
       v8::Utils::ToLocal(receiver),
       type,
       v8::Utils::ToLocal(data));
 }

References ASSIGN_RETURN_ON_EXCEPTION_VALUE, context(), DCHECK, factory(), v8::internal::GetAccessCheckInfo(), v8::internal::handle(), ScheduleThrow(), thread_local_top(), and v8::Utils::ToLocal().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ReportPendingMessages()

void v8::internal::Isolate::ReportPendingMessages ( )

Definition at line 1194 of file isolate.cc.

                                     {
   DCHECK(has_pending_exception());
   bool can_clear_message = PropagatePendingExceptionToExternalTryCatch();
  
   HandleScope scope(this);
   if (thread_local_top_.pending_exception_ == heap()->termination_exception()) {
     // Do nothing: if needed, the exception has been already propagated to
     // v8::TryCatch.
   } else {
     if (thread_local_top_.has_pending_message_) {
       thread_local_top_.has_pending_message_ = false;
       if (!thread_local_top_.pending_message_obj_->IsTheHole()) {
         HandleScope scope(this);
         Handle<Object> message_obj(thread_local_top_.pending_message_obj_,
                                    this);
         if (!thread_local_top_.pending_message_script_->IsTheHole()) {
           Handle<Script> script(
               Script::cast(thread_local_top_.pending_message_script_));
           int start_pos = thread_local_top_.pending_message_start_pos_;
           int end_pos = thread_local_top_.pending_message_end_pos_;
           MessageLocation location(script, start_pos, end_pos);
           MessageHandler::ReportMessage(this, &location, message_obj);
         } else {
           MessageHandler::ReportMessage(this, NULL, message_obj);
         }
       }
     }
   }
   if (can_clear_message) clear_pending_message();
 }

References clear_pending_message(), DCHECK, has_pending_exception(), heap(), NULL, PropagatePendingExceptionToExternalTryCatch(), v8::internal::MessageHandler::ReportMessage(), and thread_local_top_.

Referenced by v8::ScriptCompiler::Compile(), v8::internal::Compiler::CompileScript(), and v8::internal::Invoke().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RestorePendingMessageFromTryCatch()

void v8::internal::Isolate::RestorePendingMessageFromTryCatch ( v8::TryCatch * handler )

Definition at line 871 of file isolate.cc.

                                                                    {
   DCHECK(handler == try_catch_handler());
   DCHECK(handler->HasCaught());
   DCHECK(handler->rethrow_);
   DCHECK(handler->capture_message_);
   Object* message = reinterpret_cast<Object*>(handler->message_obj_);
   Object* script = reinterpret_cast<Object*>(handler->message_script_);
   DCHECK(message->IsJSMessageObject() || message->IsTheHole());
   DCHECK(script->IsScript() || script->IsTheHole());
   thread_local_top()->pending_message_obj_ = message;
   thread_local_top()->pending_message_script_ = script;
   thread_local_top()->pending_message_start_pos_ = handler->message_start_pos_;
   thread_local_top()->pending_message_end_pos_ = handler->message_end_pos_;
 }

References DCHECK, handler(), thread_local_top(), and try_catch_handler().

Here is the call graph for this function:

◆ RestoreThread()

char * v8::internal::Isolate::RestoreThread ( char * from )

Definition at line 1380 of file isolate.cc.

                                        {
   MemCopy(reinterpret_cast<char*>(thread_local_top()), from,
           sizeof(ThreadLocalTop));
 // This might be just paranoia, but it seems to be needed in case a
 // thread_local_top_ is restored on a separate OS thread.
 #ifdef USE_SIMULATOR
   thread_local_top()->simulator_ = Simulator::current(this);
 #endif
   DCHECK(context() == NULL || context()->IsContext());
   return from + sizeof(ThreadLocalTop);
 }

References context(), DCHECK, v8::internal::MemCopy(), NULL, and thread_local_top().

Referenced by v8::internal::ThreadManager::RestoreThread().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ReThrow()

Object * v8::internal::Isolate::ReThrow ( Object * exception )

Definition at line 838 of file isolate.cc.

                                           {
   bool can_be_caught_externally = false;
   bool catchable_by_javascript = is_catchable_by_javascript(exception);
   ShouldReportException(&can_be_caught_externally, catchable_by_javascript);
  
   thread_local_top()->catcher_ = can_be_caught_externally ?
       try_catch_handler() : NULL;
  
   // Set the exception being re-thrown.
   set_pending_exception(exception);
   return heap()->exception();
 }

References heap(), is_catchable_by_javascript(), NULL, set_pending_exception(), ShouldReportException(), thread_local_top(), and try_catch_handler().

Referenced by PromoteScheduledException().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RunMicrotasks()

void v8::internal::Isolate::RunMicrotasks ( )

Definition at line 2299 of file isolate.cc.

                             {
   // %RunMicrotasks may be called in mjsunit tests, which violates
   // this assertion, hence the check for --allow-natives-syntax.
   // TODO(adamk): However, this also fails some layout tests.
   //
   // DCHECK(FLAG_allow_natives_syntax ||
   //        handle_scope_implementer()->CallDepthIsZero());
  
   // Increase call depth to prevent recursive callbacks.
   v8::Isolate::SuppressMicrotaskExecutionScope suppress(
       reinterpret_cast<v8::Isolate*>(this));
  
   while (pending_microtask_count() > 0) {
     HandleScope scope(this);
     int num_tasks = pending_microtask_count();
     Handle<FixedArray> queue(heap()->microtask_queue(), this);
     DCHECK(num_tasks <= queue->length());
     set_pending_microtask_count(0);
     heap()->set_microtask_queue(heap()->empty_fixed_array());
  
     for (int i = 0; i < num_tasks; i++) {
       HandleScope scope(this);
       Handle<Object> microtask(queue->get(i), this);
       if (microtask->IsJSFunction()) {
         Handle<JSFunction> microtask_function =
             Handle<JSFunction>::cast(microtask);
         SaveContext save(this);
         set_context(microtask_function->context()->native_context());
         MaybeHandle<Object> maybe_exception;
         MaybeHandle<Object> result =
             Execution::TryCall(microtask_function, factory()->undefined_value(),
                                0, NULL, &maybe_exception);
         // If execution is terminating, just bail out.
         Handle<Object> exception;
         if (result.is_null() && maybe_exception.is_null()) {
           // Clear out any remaining callbacks in the queue.
           heap()->set_microtask_queue(heap()->empty_fixed_array());
           set_pending_microtask_count(0);
           return;
         }
       } else {
         Handle<CallHandlerInfo> callback_info =
             Handle<CallHandlerInfo>::cast(microtask);
         v8::MicrotaskCallback callback =
             v8::ToCData<v8::MicrotaskCallback>(callback_info->callback());
         void* data = v8::ToCData<void*>(callback_info->data());
         callback(data);
       }
     }
   }
 }

References v8::internal::Handle< T >::cast(), DCHECK, factory(), heap(), v8::internal::MaybeHandle< T >::is_null(), NULL, and set_context().

Referenced by FireCallCompletedCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ runtime_profiler()

RuntimeProfiler* v8::internal::Isolate::runtime_profiler ( )

inline

Definition at line 864 of file isolate.h.

864 { return runtime_profiler_; }

References runtime_profiler_.

Referenced by v8::internal::IC::OnTypeFeedbackChanged().

Here is the caller graph for this function:

◆ runtime_state()

RuntimeState* v8::internal::Isolate::runtime_state ( )

inline

Definition at line 945 of file isolate.h.

945 { return &runtime_state_; }

v8::internal::Isolate::runtime_state_

RuntimeState runtime_state_

Definition: isolate.h:1259

References runtime_state_.

Referenced by v8::internal::ConvertCaseHelper().

Here is the caller graph for this function:

◆ runtime_zone()

Zone* v8::internal::Isolate::runtime_zone ( )

inline

Definition at line 905 of file isolate.h.

905 { return &runtime_zone_; }

References runtime_zone_.

Referenced by v8::internal::StringReplaceGlobalAtomRegExpWithString(), and v8::internal::StringReplaceGlobalRegExpWithString().

Here is the caller graph for this function:

◆ scheduled_exception()

Object* v8::internal::Isolate::scheduled_exception ( )

inline

Definition at line 622 of file isolate.h.

                                 {
     DCHECK(has_scheduled_exception());
     DCHECK(!thread_local_top_.scheduled_exception_->IsException());
     return thread_local_top_.scheduled_exception_;
   }

References DCHECK, has_scheduled_exception(), and thread_local_top_.

Referenced by CancelScheduledExceptionFromTryCatch(), CancelTerminateExecution(), v8::IsExecutionTerminatingCheck(), v8::internal::Debug::OnThrow(), and PromoteScheduledException().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ scheduled_exception_address()

Object** v8::internal::Isolate::scheduled_exception_address ( )

inline

Definition at line 605 of file isolate.h.

                                          {
     return &thread_local_top_.scheduled_exception_;
   }

References thread_local_top_.

◆ ScheduleThrow()

void v8::internal::Isolate::ScheduleThrow ( Object * exception )

Definition at line 858 of file isolate.cc.

                                              {
   // When scheduling a throw we first throw the exception to get the
   // error reporting if it is uncaught before rescheduling it.
   Throw(exception);
   PropagatePendingExceptionToExternalTryCatch();
   if (has_pending_exception()) {
     thread_local_top()->scheduled_exception_ = pending_exception();
     thread_local_top()->external_caught_exception_ = false;
     clear_pending_exception();
   }
 }

References clear_pending_exception(), has_pending_exception(), pending_exception(), PropagatePendingExceptionToExternalTryCatch(), thread_local_top(), and Throw().

Referenced by v8::internal::ModuleGetExport(), v8::internal::ModuleSetExport(), ReportFailedAccessCheck(), and v8::Isolate::ThrowException().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ serializer_enabled()

bool v8::internal::Isolate::serializer_enabled ( ) const

inline

Definition at line 1007 of file isolate.h.

1007 { return serializer_enabled_; }

References serializer_enabled_.

Referenced by Init(), v8::internal::SerializerDeserializer::Iterate(), v8::internal::NoTrackDoubleFieldsForSerializerScope::NoTrackDoubleFieldsForSerializerScope(), v8::internal::IncrementalMarking::Start(), v8::internal::JSFunction::StartInobjectSlackTracking(), and v8::internal::IncrementalMarking::WorthActivating().

Here is the caller graph for this function:

◆ set_context()

void v8::internal::Isolate::set_context ( Context * context )

inline

Definition at line 549 of file isolate.h.

                                      {
     DCHECK(context == NULL || context->IsContext());
     thread_local_top_.context_ = context;
   }

References context(), DCHECK, NULL, and thread_local_top_.

Referenced by v8::Context::Enter(), v8::Context::Exit(), v8::internal::Debug::Load(), and RunMicrotasks().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_date_cache()

void v8::internal::Isolate::set_date_cache ( DateCache * date_cache )

inline

Definition at line 1024 of file isolate.h.

                                              {
     if (date_cache != date_cache_) {
       delete date_cache_;
     }
     date_cache_ = date_cache;
   }

References date_cache(), and date_cache_.

Here is the call graph for this function:

◆ set_function_entry_hook()

void v8::internal::Isolate::set_function_entry_hook ( FunctionEntryHook function_entry_hook )

inline

Definition at line 1079 of file isolate.h.

                                                                       {
     function_entry_hook_ = function_entry_hook;
   }

References function_entry_hook(), and function_entry_hook_.

Referenced by v8::Isolate::New().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_pending_exception()

void v8::internal::Isolate::set_pending_exception ( Object * exception_obj )

inline

Definition at line 567 of file isolate.h.

                                                     {
     DCHECK(!exception_obj->IsException());
     thread_local_top_.pending_exception_ = exception_obj;
   }

References DCHECK, and thread_local_top_.

Referenced by v8::internal::Debug::CompileDebuggerScript(), DoThrow(), ReThrow(), and v8::internal::Isolate::ExceptionScope::~ExceptionScope().

Here is the caller graph for this function:

◆ SetCaptureStackTraceForUncaughtExceptions()

void v8::internal::Isolate::SetCaptureStackTraceForUncaughtExceptions	(	bool	capture,
		int	frame_limit,
		StackTrace::StackTraceOptions	options
	)

Definition at line 1329 of file isolate.cc.

                                            {
   capture_stack_trace_for_uncaught_exceptions_ = capture;
   stack_trace_for_uncaught_exceptions_frame_limit_ = frame_limit;
   stack_trace_for_uncaught_exceptions_options_ = options;
 }

References capture_stack_trace_for_uncaught_exceptions_, stack_trace_for_uncaught_exceptions_frame_limit_, and stack_trace_for_uncaught_exceptions_options_.

◆ SetData()

void v8::internal::Isolate::SetData	(	uint32_t	slot,
		void *	data
	)

inline

Definition at line 990 of file isolate.h.

                                           {
     DCHECK(slot < Internals::kNumIsolateDataSlots);
     embedder_data_[slot] = data;
   }

References DCHECK, embedder_data_, and v8::internal::Internals::kNumIsolateDataSlots.

◆ SetFailedAccessCheckCallback()

void v8::internal::Isolate::SetFailedAccessCheckCallback ( v8::FailedAccessCheckCallback callback )

Definition at line 615 of file isolate.cc.

                                           {
   thread_local_top()->failed_access_check_callback_ = callback;
 }

References thread_local_top().

Referenced by v8::V8::SetFailedAccessCheckCallbackFunction().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetIsolateThreadLocals()

void v8::internal::Isolate::SetIsolateThreadLocals	(	Isolate *	isolate,
		PerIsolateThreadData *	data
	)

staticprivate

Definition at line 1676 of file isolate.cc.

                                                                  {
   base::Thread::SetThreadLocal(isolate_key_, isolate);
   base::Thread::SetThreadLocal(per_isolate_thread_data_key_, data);
 }

References isolate_key_, per_isolate_thread_data_key_, and v8::base::Thread::SetThreadLocal().

Referenced by Enter(), Exit(), v8::internal::SweeperThread::Run(), v8::internal::OptimizingCompilerThread::Run(), and TearDown().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetUseCounterCallback()

void v8::internal::Isolate::SetUseCounterCallback ( v8::Isolate::UseCounterCallback callback )

Definition at line 2352 of file isolate.cc.

                                                                         {
   DCHECK(!use_counter_callback_);
   use_counter_callback_ = callback;
 }

References DCHECK, and use_counter_callback_.

◆ ShouldReportException()

bool v8::internal::Isolate::ShouldReportException	(	bool *	can_be_caught_externally,
		bool	catchable_by_javascript
	)

Definition at line 950 of file isolate.cc.

                                                                   {
   // Find the top-most try-catch handler.
   StackHandler* handler =
       StackHandler::FromAddress(Isolate::handler(thread_local_top()));
   while (handler != NULL && !handler->is_catch()) {
     handler = handler->next();
   }
  
   // Get the address of the external handler so we can compare the address to
   // determine which one is closer to the top of the stack.
   Address external_handler_address =
       thread_local_top()->try_catch_handler_address();
  
   // The exception has been externally caught if and only if there is
   // an external handler which is on top of the top-most try-catch
   // handler.
   *can_be_caught_externally = external_handler_address != NULL &&
       (handler == NULL || handler->address() > external_handler_address ||
        !catchable_by_javascript);
  
   if (*can_be_caught_externally) {
     // Only report the exception if the external handler is verbose.
     return try_catch_handler()->is_verbose_;
   } else {
     // Report the exception if it isn't caught by JavaScript code.
     return handler == NULL;
   }
 }

References handler(), v8::TryCatch::is_verbose_, NULL, thread_local_top(), and try_catch_handler().

Referenced by DoThrow(), and ReThrow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SignalFatalError()

void v8::internal::Isolate::SignalFatalError ( )

inline

Definition at line 1010 of file isolate.h.

1010 { has_fatal_error_ = true; }

References has_fatal_error_.

Referenced by v8::Utils::ReportApiFailure().

Here is the caller graph for this function:

◆ stack_guard()

StackGuard* v8::internal::Isolate::stack_guard ( )

inline

Definition at line 872 of file isolate.h.

872 { return &stack_guard_; }

References stack_guard_.

Referenced by v8::internal::IncrementalMarking::Abort(), v8::Debug::CancelDebugBreak(), v8::V8::CancelTerminateExecution(), v8::Debug::CheckDebugBreak(), v8::Isolate::ClearInterrupt(), v8::internal::OptimizingCompilerThread::CompileNext(), v8::internal::ThreadManager::EagerlyArchiveThread(), v8::internal::Debug::EnqueueCommandMessage(), v8::internal::Debug::EnqueueDebugCommand(), v8::internal::IncrementalMarking::Finalize(), v8::internal::ThreadManager::FreeThreadResources(), v8::internal::Debug::HandleDebugBreak(), v8::Locker::Initialize(), v8::internal::IncrementalMarking::MarkingComplete(), v8::internal::Debug::NotifyMessageHandler(), v8::internal::Parser::Parse(), v8::internal::Debug::ProcessDebugMessages(), v8::internal::Heap::ProcessPretenuringFeedback(), v8::Isolate::RequestInterrupt(), v8::internal::Heap::ResetAllAllocationSitesDependentCode(), v8::internal::ThreadManager::RestoreThread(), v8::SetResourceConstraints(), v8::Isolate::SetStackLimit(), v8::internal::Heap::SetStackLimits(), and v8::V8::TerminateExecution().

Here is the caller graph for this function:

◆ StackOverflow()

Object * v8::internal::Isolate::StackOverflow ( )

Definition at line 773 of file isolate.cc.

                                {
   HandleScope scope(this);
   // At this point we cannot create an Error object using its javascript
   // constructor.  Instead, we copy the pre-constructed boilerplate and
   // attach the stack trace as a hidden property.
   Handle<String> key = factory()->stack_overflow_string();
   Handle<JSObject> boilerplate = Handle<JSObject>::cast(
       Object::GetProperty(js_builtins_object(), key).ToHandleChecked());
   Handle<JSObject> exception = factory()->CopyJSObject(boilerplate);
   DoThrow(*exception, NULL);
  
   CaptureAndSetSimpleStackTrace(exception, factory()->undefined_value());
   return heap()->exception();
 }

References CaptureAndSetSimpleStackTrace(), v8::internal::Handle< T >::cast(), DoThrow(), factory(), v8::internal::Object::GetProperty(), heap(), js_builtins_object(), and NULL.

Referenced by v8::internal::CompileUnoptimizedCode(), v8::internal::NativeRegExpMacroAssembler::Execute(), v8::internal::Parser::Internalize(), v8::internal::RegExpImpl::IrregexpExecRaw(), and v8::internal::JSObjectWalkVisitor< ContextObject >::StructureWalk().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ StackTraceString()

Handle< String > v8::internal::Isolate::StackTraceString ( )

Definition at line 256 of file isolate.cc.

                                          {
   if (stack_trace_nesting_level_ == 0) {
     stack_trace_nesting_level_++;
     HeapStringAllocator allocator;
     StringStream::ClearMentionedObjectCache(this);
     StringStream accumulator(&allocator);
     incomplete_message_ = &accumulator;
     PrintStack(&accumulator);
     Handle<String> stack_trace = accumulator.ToString(this);
     incomplete_message_ = NULL;
     stack_trace_nesting_level_ = 0;
     return stack_trace;
   } else if (stack_trace_nesting_level_ == 1) {
     stack_trace_nesting_level_++;
     base::OS::PrintError(
       "\n\nAttempt to print stack while printing stack (double fault)\n");
     base::OS::PrintError(
       "If you are lucky you may find a partial stack dump on stdout.\n\n");
     incomplete_message_->OutputToStdOut();
     return factory()->empty_string();
   } else {
     base::OS::Abort();
     // Unreachable
     return factory()->empty_string();
   }
 }

References v8::base::OS::Abort(), factory(), incomplete_message_, NULL, v8::base::OS::PrintError(), PrintStack(), and stack_trace_nesting_level_.

Here is the call graph for this function:

◆ stats_table()

StatsTable * v8::internal::Isolate::stats_table ( )

Definition at line 2039 of file isolate.cc.

                                  {
   if (stats_table_ == NULL) {
     stats_table_ = new StatsTable;
   }
   return stats_table_;
 }

References NULL, and stats_table_.

Referenced by v8::internal::Histogram::AddSample(), v8::internal::Histogram::CreateHistogram(), v8::internal::StatsCounter::FindLocationInStatsTable(), v8::internal::CompilationCacheScript::Lookup(), v8::Isolate::SetCounterFunction(), and v8::Isolate::SetCreateHistogramFunction().

Here is the caller graph for this function:

◆ stress_deopt_count_address()

void* v8::internal::Isolate::stress_deopt_count_address ( )

inline

Definition at line 1083 of file isolate.h.

1083 { return &stress_deopt_count_; }

References stress_deopt_count_.

◆ string_tracker()

StringTracker* v8::internal::Isolate::string_tracker ( )

inline

Definition at line 923 of file isolate.h.

923 { return string_tracker_; }

References string_tracker_.

Referenced by v8::String::CanMakeExternal(), v8::String::MakeExternal(), and v8::WriteHelper().

Here is the caller graph for this function:

◆ stub_cache()

StubCache* v8::internal::Isolate::stub_cache ( )

inline

Definition at line 875 of file isolate.h.

875 { return stub_cache_; }

References stub_cache_.

Referenced by v8::internal::TypeFeedbackOracle::CollectReceiverTypes(), v8::internal::IC::ComputeHandler(), v8::internal::MarkCompactCollector::Finish(), v8::internal::ExternalReferenceTable::PopulateTable(), and v8::internal::IC::UpdateMegamorphicCache().

Here is the caller graph for this function:

◆ sweeper_threads()

SweeperThread** v8::internal::Isolate::sweeper_threads ( )

inline

Definition at line 1067 of file isolate.h.

                                     {
     return sweeper_thread_;
   }

References sweeper_thread_.

Referenced by v8::internal::MarkCompactCollector::AreSweeperThreadsActivated(), v8::internal::MarkCompactCollector::EnsureSweepingCompleted(), v8::internal::MarkCompactCollector::IsSweepingCompleted(), and v8::internal::MarkCompactCollector::StartSweeperThreads().

Here is the caller graph for this function:

◆ TearDown()

void v8::internal::Isolate::TearDown ( )

Definition at line 1555 of file isolate.cc.

                        {
   TRACE_ISOLATE(tear_down);
  
   // Temporarily set this isolate as current so that various parts of
   // the isolate can access it in their destructors without having a
   // direct pointer. We don't use Enter/Exit here to avoid
   // initializing the thread data.
   PerIsolateThreadData* saved_data = CurrentPerIsolateThreadData();
   Isolate* saved_isolate = UncheckedCurrent();
   SetIsolateThreadLocals(this, NULL);
  
   Deinit();
  
   {
     base::LockGuard<base::Mutex> lock_guard(thread_data_table_mutex_.Pointer());
     thread_data_table_->RemoveAllThreads(this);
   }
  
   if (serialize_partial_snapshot_cache_ != NULL) {
     delete[] serialize_partial_snapshot_cache_;
     serialize_partial_snapshot_cache_ = NULL;
   }
  
   delete this;
  
   // Restore the previous current isolate.
   SetIsolateThreadLocals(saved_isolate, saved_data);
 }

References CurrentPerIsolateThreadData(), Deinit(), NULL, v8::base::LazyInstanceImpl< T, AllocationTrait, CreateTrait, InitOnceTrait, DestroyTrait >::Pointer(), v8::internal::Isolate::ThreadDataTable::RemoveAllThreads(), SetIsolateThreadLocals(), thread_data_table_, thread_data_table_mutex_, and TRACE_ISOLATE.

Referenced by v8::Isolate::Dispose().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TerminateExecution()

Object * v8::internal::Isolate::TerminateExecution ( )

Definition at line 789 of file isolate.cc.

                                     {
   DoThrow(heap_.termination_exception(), NULL);
   return heap()->exception();
 }

References DoThrow(), heap(), heap_, and NULL.

Here is the call graph for this function:

◆ thread_id_key()

static base::Thread::LocalStorageKey v8::internal::Isolate::thread_id_key ( )

inlinestatic

Definition at line 536 of file isolate.h.

                                                    {
     return thread_id_key_;
   }

References thread_id_key_.

◆ thread_local_top()

ThreadLocalTop* v8::internal::Isolate::thread_local_top ( )

inline

Definition at line 878 of file isolate.h.

878 { return &thread_local_top_; }

References thread_local_top_.

Referenced by ArchiveThread(), CancelTerminateExecution(), v8::internal::Deoptimizer::DeoptimizeMarkedCodeForContext(), DoThrow(), GetPromiseOnStackOnThrow(), HasExternalTryCatch(), v8::internal::IC::IC(), v8::internal::TickSample::Init(), IsFinallyOnTop(), Iterate(), v8::internal::Debug::OnThrow(), OptionalRescheduleException(), PopPromise(), v8::internal::Debug::PrepareForBreakPoints(), PrintStack(), PushPromise(), RegisterTryCatchHandler(), ReportFailedAccessCheck(), RestorePendingMessageFromTryCatch(), RestoreThread(), ReThrow(), v8::internal::SafeStackFrameIterator::SafeStackFrameIterator(), ScheduleThrow(), SetFailedAccessCheckCallback(), ShouldReportException(), v8::internal::StackFrameIterator::StackFrameIterator(), and UnregisterTryCatchHandler().

Here is the caller graph for this function:

◆ thread_manager()

ThreadManager* v8::internal::Isolate::thread_manager ( )

inline

Definition at line 921 of file isolate.h.

921 { return thread_manager_; }

References thread_manager_.

Referenced by v8::internal::LiveEdit::CheckAndDropActivations(), v8::internal::Deserializer::Deserialize(), v8::HandleScope::Initialize(), v8::Unlocker::Initialize(), v8::Locker::Initialize(), v8::Locker::IsLocked(), v8::internal::Heap::IterateStrongRoots(), v8::internal::Debug::PrepareForBreakPoints(), v8::internal::MarkCompactCollector::PrepareForCodeFlushing(), v8::internal::StartupSerializer::SerializeStrongReferences(), v8::Locker::~Locker(), and v8::Unlocker::~Unlocker().

Here is the caller graph for this function:

◆ Throw() [1/2]

template<typename T >

MUST_USE_RESULT MaybeHandle<T> v8::internal::Isolate::Throw	(	Handle< Object >	exception,
		MessageLocation *	location = `NULL`
	)

inline

Definition at line 759 of file isolate.h.

                                                                          {
     Throw(*exception, location);
     return MaybeHandle<T>();
   }

References Throw().

Here is the call graph for this function:

◆ Throw() [2/2]

Object * v8::internal::Isolate::Throw	(	Object *	exception,
		MessageLocation *	location = `NULL`
	)

Definition at line 832 of file isolate.cc.

                                                                    {
   DoThrow(exception, location);
   return heap()->exception();
 }

References DoThrow(), and heap().

Referenced by v8::internal::CompileGlobalEval(), v8::internal::CreateRegExpErrorObjectAndThrow(), v8::internal::LiveEdit::GatherCompileInfo(), v8::internal::LoadLookupSlotHelper(), v8::internal::Scope::ResolveVariable(), ScheduleThrow(), Throw(), ThrowIllegalOperation(), and v8::internal::Parser::ThrowPendingError().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ThrowIllegalOperation()

Object * v8::internal::Isolate::ThrowIllegalOperation ( )

Definition at line 852 of file isolate.cc.

                                        {
   if (FLAG_stack_trace_on_illegal) PrintStack(stdout);
   return Throw(heap_.illegal_access_string());
 }

References heap_, PrintStack(), and Throw().

Referenced by v8::internal::Invoke(), v8::internal::LoadLookupSlotHelper(), and v8::internal::TransitionElements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ time_millis_since_init()

double v8::internal::Isolate::time_millis_since_init ( )

inline

Definition at line 1016 of file isolate.h.

                                   {
     return base::OS::TimeCurrentMillis() - time_millis_at_init_;
   }

References time_millis_at_init_, and v8::base::OS::TimeCurrentMillis().

Referenced by v8::internal::GCTracer::Print(), and v8::internal::GCTracer::PrintNVP().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ try_catch_handler()

v8::TryCatch* v8::internal::Isolate::try_catch_handler ( )

inline

Definition at line 593 of file isolate.h.

                                   {
     return thread_local_top_.try_catch_handler();
   }

References thread_local_top_.

Referenced by CancelTerminateExecution(), DoThrow(), v8::internal::ThreadManager::FreeThreadResources(), HasExternalTryCatch(), PropagatePendingExceptionToExternalTryCatch(), RestorePendingMessageFromTryCatch(), ReThrow(), ShouldReportException(), and UnregisterTryCatchHandler().

Here is the caller graph for this function:

◆ try_catch_handler_address()

Address v8::internal::Isolate::try_catch_handler_address ( )

inline

Definition at line 596 of file isolate.h.

                                       {
     return thread_local_top_.try_catch_handler_address();
   }

References thread_local_top_.

Referenced by OptionalRescheduleException().

Here is the caller graph for this function:

◆ unicode_cache()

UnicodeCache* v8::internal::Isolate::unicode_cache ( )

inline

Definition at line 907 of file isolate.h.

                                 {
     return unicode_cache_;
   }

References unicode_cache_.

Referenced by v8::internal::Parser::Parse().

Here is the caller graph for this function:

◆ UnlinkDeferredHandles()

void v8::internal::Isolate::UnlinkDeferredHandles ( DeferredHandles * deferred_handles )

Definition at line 2115 of file isolate.cc.

                                                              {
 #ifdef DEBUG
   // In debug mode assert that the linked list is well-formed.
   DeferredHandles* deferred_iterator = deferred;
   while (deferred_iterator->previous_ != NULL) {
     deferred_iterator = deferred_iterator->previous_;
   }
   DCHECK(deferred_handles_head_ == deferred_iterator);
 #endif
   if (deferred_handles_head_ == deferred) {
     deferred_handles_head_ = deferred_handles_head_->next_;
   }
   if (deferred->next_ != NULL) {
     deferred->next_->previous_ = deferred->previous_;
   }
   if (deferred->previous_ != NULL) {
     deferred->previous_->next_ = deferred->next_;
   }
 }

References DCHECK, deferred_handles_head_, v8::internal::DeferredHandles::next_, NULL, and v8::internal::DeferredHandles::previous_.

◆ UnregisterTryCatchHandler()

void v8::internal::Isolate::UnregisterTryCatchHandler ( v8::TryCatch * that )

Definition at line 249 of file isolate.cc.

                                                         {
   DCHECK(thread_local_top()->try_catch_handler() == that);
   thread_local_top()->set_try_catch_handler(that->next_);
   thread_local_top()->catcher_ = NULL;
 }

References DCHECK, v8::TryCatch::next_, NULL, thread_local_top(), and try_catch_handler().

Here is the call graph for this function:

◆ use_crankshaft()

bool v8::internal::Isolate::use_crankshaft ( ) const

Definition at line 2174 of file isolate.cc.

                                    {
   return FLAG_crankshaft &&
          !serializer_enabled_ &&
          CpuFeatures::SupportsCrankshaft();
 }

References serializer_enabled_, and v8::internal::CpuFeatures::SupportsCrankshaft().

Referenced by v8::internal::Compiler::GetLazyCode(), and v8::internal::IsSuitableForOnStackReplacement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ write_iterator()

ConsStringIteratorOp* v8::internal::Isolate::write_iterator ( )

inline

Definition at line 915 of file isolate.h.

915 { return write_iterator_; }

References write_iterator_.

Friends And Related Function Documentation

◆ ExecutionAccess

friend class ExecutionAccess

friend

Definition at line 1336 of file isolate.h.

Referenced by Init(), and InvokeApiInterruptCallback().

◆ GlobalState

friend struct GlobalState

friend

Definition at line 1119 of file isolate.h.

◆ HandleScopeImplementer

friend class HandleScopeImplementer

friend

Definition at line 1337 of file isolate.h.

Referenced by Init().

◆ InitializeGlobalState

friend struct InitializeGlobalState

friend

Definition at line 1120 of file isolate.h.

◆ IsolateInitializer

friend class IsolateInitializer

friend

Definition at line 1338 of file isolate.h.

◆ OptimizingCompilerThread

friend class OptimizingCompilerThread

friend

Definition at line 1339 of file isolate.h.

Referenced by Init().

◆ Simulator

friend class Simulator

friend

Definition at line 1342 of file isolate.h.

◆ StackGuard

friend class StackGuard

friend

Definition at line 1343 of file isolate.h.

◆ SweeperThread

friend class SweeperThread

friend

Definition at line 1340 of file isolate.h.

Referenced by Init().

◆ TestCodeRangeScope

friend class TestCodeRangeScope

friend

Definition at line 1346 of file isolate.h.

◆ TestMemoryAllocatorScope

friend class TestMemoryAllocatorScope

friend

Definition at line 1345 of file isolate.h.

◆ ThreadId

friend class ThreadId

friend

Definition at line 1344 of file isolate.h.

◆ ThreadManager

friend class ThreadManager

friend

Definition at line 1341 of file isolate.h.

Referenced by Isolate().

◆ v8::Isolate

friend class v8::Isolate

friend

Definition at line 1347 of file isolate.h.

◆ v8::Locker

friend class v8::Locker

friend

Definition at line 1348 of file isolate.h.

◆ v8::Unlocker

friend class v8::Unlocker

friend

Definition at line 1349 of file isolate.h.

Member Data Documentation

◆ basic_block_profiler_

BasicBlockProfiler* v8::internal::Isolate::basic_block_profiler_

private

Definition at line 1334 of file isolate.h.

Referenced by basic_block_profiler(), Deinit(), and GetOrCreateBasicBlockProfiler().

◆ bootstrapper_

Bootstrapper* v8::internal::Isolate::bootstrapper_

private

Definition at line 1228 of file isolate.h.

Referenced by bootstrapper(), Deinit(), Init(), and ~Isolate().

◆ break_access_

base::RecursiveMutex v8::internal::Isolate::break_access_

private

Definition at line 1233 of file isolate.h.

Referenced by break_access().

◆ builtins_

Builtins v8::internal::Isolate::builtins_

private

Definition at line 1260 of file isolate.h.

Referenced by builtins(), Deinit(), and Init().

◆ call_completed_callbacks_

List<CallCompletedCallback> v8::internal::Isolate::call_completed_callbacks_

private

Definition at line 1331 of file isolate.h.

Referenced by AddCallCompletedCallback(), FireCallCompletedCallback(), and RemoveCallCompletedCallback().

◆ call_descriptor_data_

CallInterfaceDescriptorData* v8::internal::Isolate::call_descriptor_data_

private

Definition at line 1273 of file isolate.h.

Referenced by call_descriptor_data(), Init(), and ~Isolate().

◆ capture_stack_trace_for_uncaught_exceptions_

bool v8::internal::Isolate::capture_stack_trace_for_uncaught_exceptions_

private

Definition at line 1243 of file isolate.h.

Referenced by CaptureAndSetDetailedStackTrace(), DoThrow(), and SetCaptureStackTraceForUncaughtExceptions().

◆ code_aging_helper_

CodeAgingHelper* v8::internal::Isolate::code_aging_helper_

private

Definition at line 1239 of file isolate.h.

Referenced by code_aging_helper(), Init(), and ~Isolate().

◆ code_range_

CodeRange* v8::internal::Isolate::code_range_

private

Definition at line 1232 of file isolate.h.

Referenced by code_range(), Init(), and ~Isolate().

◆ compilation_cache_

CompilationCache* v8::internal::Isolate::compilation_cache_

private

Definition at line 1230 of file isolate.h.

Referenced by compilation_cache(), Init(), and ~Isolate().

◆ context_slot_cache_

ContextSlotCache* v8::internal::Isolate::context_slot_cache_

private

Definition at line 1248 of file isolate.h.

Referenced by context_slot_cache(), Init(), and ~Isolate().

◆ counters_

Counters* v8::internal::Isolate::counters_

private

Definition at line 1231 of file isolate.h.

Referenced by counters(), InitializeLoggingAndCounters(), and ~Isolate().

◆ cpu_profiler_

CpuProfiler* v8::internal::Isolate::cpu_profiler_

private

Definition at line 1295 of file isolate.h.

Referenced by cpu_profiler(), Deinit(), and Init().

◆ date_cache_

DateCache* v8::internal::Isolate::date_cache_

private

Definition at line 1271 of file isolate.h.

Referenced by date_cache(), Init(), set_date_cache(), and ~Isolate().

◆ debug_

Debug* v8::internal::Isolate::debug_

private

Definition at line 1294 of file isolate.h.

Referenced by debug(), GetCallingNativeContext(), Isolate(), and ~Isolate().

◆ debugger_initialized_

base::Atomic32 v8::internal::Isolate::debugger_initialized_

private

Definition at line 1234 of file isolate.h.

◆ deferred_handles_head_

DeferredHandles* v8::internal::Isolate::deferred_handles_head_

private

Definition at line 1320 of file isolate.h.

Referenced by IterateDeferredHandles(), LinkDeferredHandles(), and UnlinkDeferredHandles().

◆ deoptimizer_data_

DeoptimizerData* v8::internal::Isolate::deoptimizer_data_

private

Definition at line 1240 of file isolate.h.

Referenced by Deinit(), deoptimizer_data(), and Init().

◆ descriptor_lookup_cache_

DescriptorLookupCache* v8::internal::Isolate::descriptor_lookup_cache_

private

Definition at line 1249 of file isolate.h.

Referenced by descriptor_lookup_cache(), Init(), and ~Isolate().

◆ embedder_data_

void* v8::internal::Isolate::embedder_data_[Internals::kNumIsolateDataSlots]

private

Definition at line 1130 of file isolate.h.

Referenced by GetData(), Init(), and SetData().

◆ entry_stack_

EntryStackItem* v8::internal::Isolate::entry_stack_

private

Definition at line 1224 of file isolate.h.

Referenced by Enter(), Exit(), IsInUse(), and ~Isolate().

◆ eternal_handles_

EternalHandles* v8::internal::Isolate::eternal_handles_

private

Definition at line 1257 of file isolate.h.

Referenced by eternal_handles(), Init(), and ~Isolate().

◆ function_entry_hook_

FunctionEntryHook v8::internal::Isolate::function_entry_hook_

private

Definition at line 1297 of file isolate.h.

Referenced by function_entry_hook(), and set_function_entry_hook().

◆ global_handles_

GlobalHandles* v8::internal::Isolate::global_handles_

private

Definition at line 1256 of file isolate.h.

Referenced by global_handles(), Init(), and ~Isolate().

◆ handle_scope_data_

HandleScopeData v8::internal::Isolate::handle_scope_data_

private

Definition at line 1250 of file isolate.h.

Referenced by handle_scope_data(), and Isolate().

◆ handle_scope_implementer_

HandleScopeImplementer* v8::internal::Isolate::handle_scope_implementer_

private

Definition at line 1251 of file isolate.h.

Referenced by handle_scope_implementer(), Init(), and ~Isolate().

◆ has_fatal_error_

bool v8::internal::Isolate::has_fatal_error_

private

Definition at line 1280 of file isolate.h.

Referenced by Init(), IsDead(), and SignalFatalError().

◆ has_installed_extensions_

bool v8::internal::Isolate::has_installed_extensions_

private

Definition at line 1261 of file isolate.h.

Referenced by has_installed_extensions(), and NotifyExtensionInstalled().

◆ heap_

Heap v8::internal::Isolate::heap_

private

Definition at line 1131 of file isolate.h.

Referenced by CancelTerminateExecution(), clear_pending_exception(), clear_pending_message(), clear_scheduled_exception(), ComputeLocation(), Deinit(), has_scheduled_exception(), heap(), Init(), Isolate(), OptionalRescheduleException(), TerminateExecution(), and ThrowIllegalOperation().

◆ heap_profiler_

HeapProfiler* v8::internal::Isolate::heap_profiler_

private

Definition at line 1296 of file isolate.h.

Referenced by Deinit(), heap_profiler(), and Init().

◆ id_

base::Atomic32 v8::internal::Isolate::id_

private

Definition at line 1223 of file isolate.h.

Referenced by id(), and Isolate().

◆ incomplete_message_

StringStream* v8::internal::Isolate::incomplete_message_

private

Definition at line 1226 of file isolate.h.

Referenced by PrintStack(), and StackTraceString().

◆ initialized_from_snapshot_

bool v8::internal::Isolate::initialized_from_snapshot_

private

Definition at line 1283 of file isolate.h.

Referenced by Init(), and initialized_from_snapshot().

◆ inner_pointer_to_code_cache_

InnerPointerToCodeCache* v8::internal::Isolate::inner_pointer_to_code_cache_

private

Definition at line 1254 of file isolate.h.

Referenced by Init(), inner_pointer_to_code_cache(), and ~Isolate().

◆ interp_canonicalize_mapping_

unibrow::Mapping<unibrow::Ecma262Canonicalize> v8::internal::Isolate::interp_canonicalize_mapping_

private

Definition at line 1272 of file isolate.h.

Referenced by interp_canonicalize_mapping().

◆ isolate_addresses_

Address v8::internal::Isolate::isolate_addresses_[kIsolateAddressCount+1]

private

Definition at line 1227 of file isolate.h.

Referenced by get_address_from_id(), and Isolate().

◆ isolate_counter_

base::Atomic32 v8::internal::Isolate::isolate_counter_ = 0

staticprivate

Definition at line 1183 of file isolate.h.

Referenced by Isolate().

◆ isolate_key_

base::Thread::LocalStorageKey v8::internal::Isolate::isolate_key_

staticprivate

Definition at line 1178 of file isolate.h.

Referenced by InitializeOncePerProcess(), INLINE(), isolate_key(), and SetIsolateThreadLocals().

◆ jsregexp_canonrange_

unibrow::Mapping<unibrow::CanonicalizationRange> v8::internal::Isolate::jsregexp_canonrange_

private

Definition at line 1264 of file isolate.h.

Referenced by jsregexp_canonrange().

◆ jsregexp_uncanonicalize_

unibrow::Mapping<unibrow::Ecma262UnCanonicalize> v8::internal::Isolate::jsregexp_uncanonicalize_

private

Definition at line 1263 of file isolate.h.

Referenced by jsregexp_uncanonicalize().

◆ kBMMaxShift

const int v8::internal::Isolate::kBMMaxShift = 250

static

Definition at line 823 of file isolate.h.

◆ keyed_lookup_cache_

KeyedLookupCache* v8::internal::Isolate::keyed_lookup_cache_

private

Definition at line 1247 of file isolate.h.

Referenced by Init(), keyed_lookup_cache(), and ~Isolate().

◆ kJSRegexpStaticOffsetsVectorSize

const int v8::internal::Isolate::kJSRegexpStaticOffsetsVectorSize = 128

static

Definition at line 984 of file isolate.h.

Referenced by v8::internal::RegExpImpl::AtomExec(), v8::internal::RegExpImpl::GlobalCache::GlobalCache(), and v8::internal::RegExpImpl::IrregexpExec().

◆ kStackOverflowMessage

const char *const v8::internal::Isolate::kStackOverflowMessage

static

Initial value:

=

"Uncaught RangeError: Maximum call stack size exceeded"

Definition at line 820 of file isolate.h.

◆ kUC16AlphabetSize

const int v8::internal::Isolate::kUC16AlphabetSize = 256

static

Definition at line 822 of file isolate.h.

◆ logger_

Logger* v8::internal::Isolate::logger_

private

Definition at line 1235 of file isolate.h.

Referenced by Deinit(), Init(), InitializeLoggingAndCounters(), logger(), and ~Isolate().

◆ materialized_object_store_

MaterializedObjectStore* v8::internal::Isolate::materialized_object_store_

private

Definition at line 1241 of file isolate.h.

Referenced by Init(), materialized_object_store(), and ~Isolate().

◆ memory_allocator_

MemoryAllocator* v8::internal::Isolate::memory_allocator_

private

Definition at line 1246 of file isolate.h.

Referenced by Init(), memory_allocator(), and ~Isolate().

◆ next_optimization_id_

int v8::internal::Isolate::next_optimization_id_

private

Definition at line 1328 of file isolate.h.

Referenced by NextOptimizationId().

◆ num_sweeper_threads_

int v8::internal::Isolate::num_sweeper_threads_

private

Definition at line 1323 of file isolate.h.

Referenced by Deinit(), Init(), and num_sweeper_threads().

◆ objects_string_compare_iterator_a_

ConsStringIteratorOp v8::internal::Isolate::objects_string_compare_iterator_a_

private

Definition at line 1265 of file isolate.h.

Referenced by objects_string_compare_iterator_a().

◆ objects_string_compare_iterator_b_

ConsStringIteratorOp v8::internal::Isolate::objects_string_compare_iterator_b_

private

Definition at line 1266 of file isolate.h.

Referenced by objects_string_compare_iterator_b().

◆ objects_string_iterator_

StaticResource<ConsStringIteratorOp> v8::internal::Isolate::objects_string_iterator_

private

Definition at line 1267 of file isolate.h.

Referenced by objects_string_iterator().

◆ optimizing_compiler_thread_

OptimizingCompilerThread* v8::internal::Isolate::optimizing_compiler_thread_

private

Definition at line 1321 of file isolate.h.

Referenced by concurrent_osr_enabled(), concurrent_recompilation_enabled(), Deinit(), Init(), and optimizing_compiler_thread().

◆ per_isolate_thread_data_key_

base::Thread::LocalStorageKey v8::internal::Isolate::per_isolate_thread_data_key_

staticprivate

Definition at line 1177 of file isolate.h.

Referenced by CurrentPerIsolateThreadData(), InitializeOncePerProcess(), and SetIsolateThreadLocals().

◆ random_number_generator_

base::RandomNumberGenerator* v8::internal::Isolate::random_number_generator_

private

Definition at line 1274 of file isolate.h.

Referenced by ~Isolate().

◆ regexp_macro_assembler_canonicalize_

unibrow::Mapping<unibrow::Ecma262Canonicalize> v8::internal::Isolate::regexp_macro_assembler_canonicalize_

private

Definition at line 1269 of file isolate.h.

Referenced by regexp_macro_assembler_canonicalize().

◆ regexp_stack_

RegExpStack* v8::internal::Isolate::regexp_stack_

private

Definition at line 1270 of file isolate.h.

Referenced by Init(), regexp_stack(), and ~Isolate().

◆ runtime_profiler_

RuntimeProfiler* v8::internal::Isolate::runtime_profiler_

private

Definition at line 1229 of file isolate.h.

Referenced by Deinit(), Init(), and runtime_profiler().

◆ runtime_state_

RuntimeState v8::internal::Isolate::runtime_state_

private

Definition at line 1259 of file isolate.h.

Referenced by runtime_state().

◆ runtime_zone_

Zone v8::internal::Isolate::runtime_zone_

private

Definition at line 1253 of file isolate.h.

Referenced by runtime_zone(), and ~Isolate().

◆ serializer_enabled_

bool v8::internal::Isolate::serializer_enabled_

private

Definition at line 1277 of file isolate.h.

Referenced by enable_serializer(), serializer_enabled(), and use_crankshaft().

◆ stack_guard_

StackGuard v8::internal::Isolate::stack_guard_

private

Definition at line 1236 of file isolate.h.

Referenced by Init(), Isolate(), and stack_guard().

◆ stack_trace_for_uncaught_exceptions_frame_limit_

int v8::internal::Isolate::stack_trace_for_uncaught_exceptions_frame_limit_

private

Definition at line 1244 of file isolate.h.

Referenced by CaptureAndSetDetailedStackTrace(), DoThrow(), and SetCaptureStackTraceForUncaughtExceptions().

◆ stack_trace_for_uncaught_exceptions_options_

StackTrace::StackTraceOptions v8::internal::Isolate::stack_trace_for_uncaught_exceptions_options_

private

Definition at line 1245 of file isolate.h.

Referenced by CaptureAndSetDetailedStackTrace(), DoThrow(), and SetCaptureStackTraceForUncaughtExceptions().

◆ stack_trace_nesting_level_

int v8::internal::Isolate::stack_trace_nesting_level_

private

Definition at line 1225 of file isolate.h.

Referenced by PrintStack(), and StackTraceString().

◆ state_

State v8::internal::Isolate::state_

private

Definition at line 1132 of file isolate.h.

Referenced by Deinit(), enable_serializer(), Init(), and IsInitialized().

◆ stats_table_

StatsTable* v8::internal::Isolate::stats_table_

private

Definition at line 1237 of file isolate.h.

Referenced by stats_table(), and ~Isolate().

◆ stress_deopt_count_

unsigned int v8::internal::Isolate::stress_deopt_count_

private

Definition at line 1326 of file isolate.h.

Referenced by Deinit(), Init(), and stress_deopt_count_address().

◆ string_tracker_

StringTracker* v8::internal::Isolate::string_tracker_

private

Definition at line 1262 of file isolate.h.

Referenced by Init(), string_tracker(), and ~Isolate().

◆ stub_cache_

StubCache* v8::internal::Isolate::stub_cache_

private

Definition at line 1238 of file isolate.h.

Referenced by Init(), stub_cache(), and ~Isolate().

◆ sweeper_thread_

SweeperThread** v8::internal::Isolate::sweeper_thread_

private

Definition at line 1322 of file isolate.h.

Referenced by Deinit(), Init(), and sweeper_threads().

◆ thread_data_table_

Isolate::ThreadDataTable * v8::internal::Isolate::thread_data_table_ = NULL

staticprivate

Definition at line 1180 of file isolate.h.

Referenced by FindOrAllocatePerThreadDataForThisThread(), FindPerThreadDataForThread(), GlobalTearDown(), InitializeOncePerProcess(), Isolate(), and TearDown().

◆ thread_data_table_mutex_

base::LazyMutex v8::internal::Isolate::thread_data_table_mutex_ = LAZY_MUTEX_INITIALIZER

staticprivate

Definition at line 1175 of file isolate.h.

Referenced by FindOrAllocatePerThreadDataForThisThread(), FindPerThreadDataForThread(), InitializeOncePerProcess(), Isolate(), and TearDown().

◆ thread_id_key_

base::Thread::LocalStorageKey v8::internal::Isolate::thread_id_key_

staticprivate

Definition at line 1179 of file isolate.h.

Referenced by v8::internal::ThreadId::GetCurrentThreadId(), InitializeOncePerProcess(), and thread_id_key().

◆ thread_local_top_

ThreadLocalTop v8::internal::Isolate::thread_local_top_

private

Definition at line 1242 of file isolate.h.

Referenced by c_entry_fp_address(), clear_pending_exception(), clear_pending_message(), clear_scheduled_exception(), context(), context_address(), external_caught_exception_address(), formal_count_address(), FreeThreadResources(), GetMessageLocation(), handler_address(), has_pending_exception(), has_pending_message_address(), has_scheduled_exception(), InitializeThreadLocal(), js_builtins_object(), js_entry_sp(), js_entry_sp_address(), pending_exception(), pending_exception_address(), pending_message_obj_address(), pending_message_script_address(), PropagatePendingExceptionToExternalTryCatch(), ReportPendingMessages(), scheduled_exception(), scheduled_exception_address(), set_context(), set_pending_exception(), thread_local_top(), try_catch_handler(), and try_catch_handler_address().

◆ thread_manager_

ThreadManager* v8::internal::Isolate::thread_manager_

private

Definition at line 1258 of file isolate.h.

Referenced by Isolate(), thread_manager(), and ~Isolate().

◆ time_millis_at_init_

double v8::internal::Isolate::time_millis_at_init_

private

Definition at line 1286 of file isolate.h.

Referenced by Init(), and time_millis_since_init().

◆ unicode_cache_

UnicodeCache* v8::internal::Isolate::unicode_cache_

private

Definition at line 1252 of file isolate.h.

Referenced by Init(), unicode_cache(), and ~Isolate().

◆ use_counter_callback_

v8::Isolate::UseCounterCallback v8::internal::Isolate::use_counter_callback_

private

Definition at line 1333 of file isolate.h.

Referenced by CountUsage(), and SetUseCounterCallback().

◆ write_iterator_

ConsStringIteratorOp* v8::internal::Isolate::write_iterator_

private

Definition at line 1255 of file isolate.h.

Referenced by Init(), write_iterator(), and ~Isolate().

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

/mnt/V8SourceCode/src/isolate.h
/mnt/V8SourceCode/src/isolate-inl.h
/mnt/V8SourceCode/src/isolate.cc

Classes

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Friends

Detailed Description

Member Enumeration Documentation

◆ AddressId

◆ State

Constructor & Destructor Documentation

◆ ~Isolate()

◆ Isolate()

Member Function Documentation

◆ AddCallCompletedCallback()

◆ ArchiveSpacePerThread()

◆ ArchiveThread()

◆ basic_block_profiler()

◆ bootstrapper()

◆ break_access()

◆ builtins()

◆ c_entry_fp()

◆ c_entry_fp_address()

◆ call_descriptor_data()

◆ CancelScheduledExceptionFromTryCatch()

◆ CancelTerminateExecution()

◆ CaptureAndSetDetailedStackTrace()

◆ CaptureAndSetSimpleStackTrace()

◆ CaptureCurrentStackTrace()

◆ CaptureSimpleStackTrace()

◆ clear_pending_exception()

◆ clear_pending_message()

◆ clear_scheduled_exception()

◆ code_aging_helper()

◆ code_range()

◆ compilation_cache()

◆ ComputeLocation()

◆ concurrent_osr_enabled()

◆ concurrent_recompilation_enabled()

◆ context()

◆ context_address()

◆ context_slot_cache()

◆ counters()

◆ CountUsage()

◆ cpu_profiler()

◆ CurrentPerIsolateThreadData()

◆ date_cache()

◆ debug()

◆ DebuggerHasBreakPoints()

◆ Deinit()

◆ deoptimizer_data()

◆ descriptor_lookup_cache()

◆ DISALLOW_COPY_AND_ASSIGN()

◆ DoThrow()

◆ enable_serializer()

◆ EnqueueMicrotask()

◆ Enter()

◆ eternal_handles()

◆ Exit()

◆ external_caught_exception_address()

◆ factory()

◆ FillCache()

◆ FindCodeObject()

◆ FindOrAllocatePerThreadDataForThisThread()

◆ FindPerThreadDataForThisThread()

◆ FindPerThreadDataForThread()

◆ FireCallCompletedCallback()

◆ formal_count_address()

◆ FreeThreadResources()

◆ function_entry_hook()

◆ get_address_from_id()

◆ get_initial_js_array_map()

◆ GetCallingNativeContext()

◆ GetCodeTracer()

◆ GetData()