#include <thread.h>

Inheritance diagram for dart::Thread:

Public Types
enum	TaskKind { kUnknownTask = 0x0 , kMutatorTask = 0x1 , kCompilerTask = 0x2 , kMarkerTask = 0x4 , kSweeperTask = 0x8 , kCompactorTask = 0x10 , kScavengerTask = 0x20 , kSampleBlockTask = 0x40 }

enum	{ kOsrRequest = 0x1 }

enum	{ kDidNotExit = 0 , kExitThroughFfi = 1 , kExitThroughRuntimeCall = 2 }

enum	{ kVMInterrupt = 0x1 , kMessageInterrupt = 0x2 , kInterruptsMask = (kVMInterrupt \| kMessageInterrupt) }

enum	ExecutionState { kThreadInVM = 0 , kThreadInGenerated , kThreadInNative , kThreadInBlockedState }

Public Member Functions
	~Thread ()

bool	HasActiveState ()

void	AssertNonMutatorInvariants ()

void	AssertNonDartMutatorInvariants ()

void	AssertEmptyStackInvariants ()

void	AssertEmptyThreadInvariants ()

void	ReleaseStoreBuffer ()

void	AcquireMarkingStack ()

void	ReleaseMarkingStack ()

void	SetStackLimit (uword value)

void	ClearStackLimit ()

uword	stack_limit_address () const

uword	saved_stack_limit () const

uword	saved_shadow_call_stack () const

uword	write_barrier_mask () const

uword	heap_base () const

int32_t	IncrementAndGetStackOverflowCount ()

uint32_t	IncrementAndGetRuntimeCallCount ()

TaskKind	task_kind () const

uword	GetAndClearStackOverflowFlags ()

void	ScheduleInterrupts (uword interrupt_bits)

ErrorPtr	HandleInterrupts ()

uword	GetAndClearInterrupts ()

bool	HasScheduledInterrupts () const

Monitor *	thread_lock () const

ApiLocalScope *	api_reusable_scope () const

void	set_api_reusable_scope (ApiLocalScope *value)

ApiLocalScope *	api_top_scope () const

void	set_api_top_scope (ApiLocalScope *value)

void	EnterApiScope ()

void	ExitApiScope ()

Isolate *	isolate () const

IsolateGroup *	isolate_group () const

bool	IsDartMutatorThread () const

Isolate *	scheduled_dart_mutator_isolate () const

bool	IsExecutingDartCode () const

bool	HasExitedDartCode () const

bool	HasCompilerState () const

CompilerState &	compiler_state ()

HierarchyInfo *	hierarchy_info () const

void	set_hierarchy_info (HierarchyInfo *value)

TypeUsageInfo *	type_usage_info () const

void	set_type_usage_info (TypeUsageInfo *value)

CompilerTimings *	compiler_timings () const

void	set_compiler_timings (CompilerTimings *stats)

int32_t	no_callback_scope_depth () const

void	IncrementNoCallbackScopeDepth ()

void	DecrementNoCallbackScopeDepth ()

bool	force_growth () const

void	IncrementForceGrowthScopeDepth ()

void	DecrementForceGrowthScopeDepth ()

bool	is_unwind_in_progress () const

void	StartUnwindError ()

void	StoreBufferAddObject (ObjectPtr obj)

void	StoreBufferAddObjectGC (ObjectPtr obj)

void	StoreBufferBlockProcess (StoreBuffer::ThresholdPolicy policy)

bool	is_marking () const

void	MarkingStackAddObject (ObjectPtr obj)

void	DeferredMarkingStackAddObject (ObjectPtr obj)

void	MarkingStackBlockProcess ()

void	DeferredMarkingStackBlockProcess ()

uword	top_exit_frame_info () const

void	set_top_exit_frame_info (uword top_exit_frame_info)

Heap *	heap () const

uword	top () const

uword	end () const

uword	true_end () const

void	set_top (uword top)

void	set_end (uword end)

void	set_true_end (uword true_end)

int32_t	no_safepoint_scope_depth () const

void	IncrementNoSafepointScopeDepth ()

void	DecrementNoSafepointScopeDepth ()

bool	IsInNoReloadScope () const

bool	IsInStoppedMutatorsScope () const

ObjectPoolPtr	global_object_pool () const

void	set_global_object_pool (ObjectPoolPtr raw_value)

const uword *	dispatch_table_array () const

void	set_dispatch_table_array (const uword *array)

uword	vm_tag () const

void	set_vm_tag (uword tag)

int64_t	unboxed_int64_runtime_arg () const

void	set_unboxed_int64_runtime_arg (int64_t value)

int64_t	unboxed_int64_runtime_second_arg () const

void	set_unboxed_int64_runtime_second_arg (int64_t value)

double	unboxed_double_runtime_arg () const

void	set_unboxed_double_runtime_arg (double value)

simd128_value_t	unboxed_simd128_runtime_arg () const

void	set_unboxed_simd128_runtime_arg (simd128_value_t value)

ObjectPtr	active_exception () const

void	set_active_exception (const Object &value)

ObjectPtr	active_stacktrace () const

void	set_active_stacktrace (const Object &value)

uword	resume_pc () const

void	set_resume_pc (uword value)

ErrorPtr	sticky_error () const

void	set_sticky_error (const Error &value)

void	ClearStickyError ()

DART_WARN_UNUSED_RESULT ErrorPtr	StealStickyError ()

void	ClearReusableHandles ()

bool	IsAtSafepoint () const

bool	IsAtSafepoint (SafepointLevel level) const

void	SetAtSafepoint (bool value, SafepointLevel level)

bool	IsSafepointRequestedLocked (SafepointLevel level) const

bool	IsSafepointRequested () const

bool	IsSafepointRequested (SafepointLevel level) const

bool	IsSafepointLevelRequestedLocked (SafepointLevel level) const

void	BlockForSafepoint ()

uword	SetSafepointRequested (SafepointLevel level, bool value)

bool	IsBlockedForSafepoint () const

void	SetBlockedForSafepoint (bool value)

bool	BypassSafepoints () const

bool	UnwindErrorInProgress () const

void	SetUnwindErrorInProgress (bool value)

bool	OwnsGCSafepoint () const

bool	OwnsReloadSafepoint () const

bool	OwnsDeoptSafepoint () const

bool	OwnsSafepoint () const

bool	CanAcquireSafepointLocks () const

uword	safepoint_state ()

ExecutionState	execution_state () const

NO_SANITIZE_THREAD ExecutionState	execution_state_cross_thread_for_testing () const

void	set_execution_state (ExecutionState state)

virtual bool	MayAllocateHandles ()

bool	TryEnterSafepoint ()

void	EnterSafepoint ()

bool	TryExitSafepoint ()

void	ExitSafepoint ()

void	CheckForSafepoint ()

Thread *	next () const

void	VisitObjectPointers (ObjectPointerVisitor *visitor, ValidationPolicy validate_frames)

void	RememberLiveTemporaries ()

void	DeferredMarkLiveTemporaries ()

bool	IsValidHandle (Dart_Handle object) const

bool	IsValidLocalHandle (Dart_Handle object) const

intptr_t	CountLocalHandles () const

int	ZoneSizeInBytes () const

void	UnwindScopes (uword stack_marker)

void	InitVMConstants ()

int64_t	GetNextTaskId ()

Random *	random ()

void	PrintJSON (JSONStream *stream) const

HeapProfileSampler &	heap_sampler ()

PendingDeopts &	pending_deopts ()

SafepointLevel	current_safepoint_level () const

template<class C >
C *	AllocateReusableHandle ()

Public Member Functions inherited from dart::ThreadState
	ThreadState (bool is_os_thread)

virtual	~ThreadState ()

OSThread *	os_thread () const

void	set_os_thread (OSThread *os_thread)

Zone *	zone () const

bool	ZoneIsOwnedByThread (Zone *zone) const

StackResource *	top_resource () const

void	set_top_resource (StackResource *value)

LongJumpScope *	long_jump_base () const

void	set_long_jump_base (LongJumpScope *value)

bool	IsValidZoneHandle (Dart_Handle object) const

intptr_t	CountZoneHandles () const

bool	IsValidScopedHandle (Dart_Handle object) const

intptr_t	CountScopedHandles () const

HandleScope *	top_handle_scope () const

void	set_top_handle_scope (HandleScope *handle_scope)

Public Member Functions inherited from dart::BaseThread
bool	is_os_thread () const

Static Public Member Functions
static const char *	TaskKindToCString (TaskKind kind)

static Thread *	Current ()

static void	EnterIsolate (Isolate *isolate)

static void	ExitIsolate (bool isolate_shutdown=false)

static bool	EnterIsolateGroupAsHelper (IsolateGroup *isolate_group, TaskKind kind, bool bypass_safepoint)

static void	ExitIsolateGroupAsHelper (bool bypass_safepoint)

static bool	EnterIsolateGroupAsNonMutator (IsolateGroup *isolate_group, TaskKind kind)

static void	ExitIsolateGroupAsNonMutator ()

static intptr_t	stack_limit_offset ()

static intptr_t	saved_stack_limit_offset ()

static uword	saved_shadow_call_stack_offset ()

static intptr_t	write_barrier_mask_offset ()

static intptr_t	stack_overflow_flags_offset ()

static uword	stack_overflow_shared_stub_entry_point_offset (bool fpu_regs)

static intptr_t	safepoint_state_offset ()

static intptr_t	exit_through_ffi_offset ()

static intptr_t	api_top_scope_offset ()

static intptr_t	double_truncate_round_supported_offset ()

static intptr_t	tsan_utils_offset ()

static intptr_t	isolate_offset ()

static intptr_t	isolate_group_offset ()

static intptr_t	field_table_values_offset ()

static intptr_t	dart_stream_offset ()

static intptr_t	service_extension_stream_offset ()

static intptr_t	store_buffer_block_offset ()

static intptr_t	marking_stack_block_offset ()

static intptr_t	top_exit_frame_info_offset ()

static intptr_t	top_offset ()

static intptr_t	end_offset ()

static intptr_t	write_barrier_wrappers_thread_offset (Register reg)

static intptr_t	WriteBarrierWrappersOffsetForRegister (Register reg)

static bool	CanLoadFromThread (const Object &object)

static intptr_t	OffsetFromThread (const Object &object)

static bool	ObjectAtOffset (intptr_t offset, Object *object)

static intptr_t	OffsetFromThread (const RuntimeEntry *runtime_entry)

static intptr_t	vm_tag_offset ()

static intptr_t	unboxed_runtime_arg_offset ()

static intptr_t	global_object_pool_offset ()

static intptr_t	dispatch_table_array_offset ()

static intptr_t	active_exception_offset ()

static intptr_t	active_stacktrace_offset ()

static uword	resume_pc_offset ()

static bool	IsAtSafepoint (SafepointLevel level, uword state)

static bool	IsSafepointLevelRequested (uword state, SafepointLevel level)

static bool	IsBlockedForSafepoint (uword state)

static uword	SetBypassSafepoints (bool value, uword state)

static intptr_t	execution_state_offset ()

static uword	full_safepoint_state_unacquired ()

static uword	full_safepoint_state_acquired ()

static intptr_t	next_task_id_offset ()

static intptr_t	random_offset ()

Static Public Member Functions inherited from dart::ThreadState
static ThreadState *	Current ()

static intptr_t	top_resource_offset ()

Friends
class	RestoreWriteBarrierInvariantVisitor

class	ApiZone

class	ActiveIsolateScope

class	InterruptChecker

class	Isolate

class	IsolateGroup

class	NoActiveIsolateScope

class	NoReloadScope

class	RawReloadParticipationScope

class	Simulator

class	StackZone

class	StoppedMutatorsScope

class	ThreadRegistry

class	CompilerState

class	compiler::target::Thread

class	FieldTable

class	RuntimeCallDeoptScope

class	Dart

class	TransitionGeneratedToVM

class	TransitionVMToGenerated

class	MonitorLocker

Isolate *	CreateWithinExistingIsolateGroup (IsolateGroup , const char , char **)

Detailed Description

Definition at line 342 of file thread.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

Enumerator
kOsrRequest

Definition at line 423 of file thread.h.

       {
    kOsrRequest = 0x1,  // Current stack overflow caused by OSR request.
  };

◆ anonymous enum

anonymous enum

Enumerator
kDidNotExit
kExitThroughFfi
kExitThroughRuntimeCall

Definition at line 463 of file thread.h.

       {
    // Always true in generated state.
    kDidNotExit = 0,
    // The VM exited the generated state through FFI.
    // This can be true in both native and VM state.
    kExitThroughFfi = 1,
    // The VM exited the generated state through a runtime call.
    // This can be true in both native and VM state.
    kExitThroughRuntimeCall = 2,
  };

◆ anonymous enum

anonymous enum

Enumerator
kVMInterrupt
kMessageInterrupt
kInterruptsMask

Definition at line 486 of file thread.h.

       {
    kVMInterrupt = 0x1,  // Internal VM checks: safepoints, store buffers, etc.
    kMessageInterrupt = 0x2,  // An interrupt to process an out of band message.
 
    kInterruptsMask = (kVMInterrupt | kMessageInterrupt),
  };

◆ ExecutionState

enum dart::Thread::ExecutionState

Enumerator
kThreadInVM
kThreadInGenerated
kThreadInNative
kThreadInBlockedState

Definition at line 1020 of file thread.h.

                      {
    kThreadInVM = 0,
    kThreadInGenerated,
    kThreadInNative,
    kThreadInBlockedState
  };

◆ TaskKind

enum dart::Thread::TaskKind

Enumerator
kUnknownTask
kMutatorTask
kCompilerTask
kMarkerTask
kSweeperTask
kCompactorTask
kScavengerTask
kSampleBlockTask

Definition at line 345 of file thread.h.

                {
    kUnknownTask = 0x0,
    kMutatorTask = 0x1,
    kCompilerTask = 0x2,
    kMarkerTask = 0x4,
    kSweeperTask = 0x8,
    kCompactorTask = 0x10,
    kScavengerTask = 0x20,
    kSampleBlockTask = 0x40,
  };

Constructor & Destructor Documentation

◆ ~Thread()

dart::Thread::~Thread ( )

Definition at line 37 of file thread.cc.

                {
  // We should cleanly exit any isolate before destruction.
  ASSERT(isolate_ == nullptr);
  ASSERT(store_buffer_block_ == nullptr);
  ASSERT(marking_stack_block_ == nullptr);
  // There should be no top api scopes at this point.
  ASSERT(api_top_scope() == nullptr);
  // Delete the reusable api scope if there is one.
  if (api_reusable_scope_ != nullptr) {
    delete api_reusable_scope_;
    api_reusable_scope_ = nullptr;
  }
 
  DO_IF_TSAN(delete tsan_utils_);
}

Member Function Documentation

◆ AcquireMarkingStack()

void dart::Thread::AcquireMarkingStack ( )

◆ active_exception()

ObjectPtr dart::Thread::active_exception ( ) const

inline

Definition at line 848 of file thread.h.

848{ return active_exception_; }

◆ active_exception_offset()

static intptr_t dart::Thread::active_exception_offset ( )

inlinestatic

Definition at line 850 of file thread.h.

                                            {
    return OFFSET_OF(Thread, active_exception_);
  }

◆ active_stacktrace()

ObjectPtr dart::Thread::active_stacktrace ( ) const

inline

Definition at line 854 of file thread.h.

854{ return active_stacktrace_; }

◆ active_stacktrace_offset()

static intptr_t dart::Thread::active_stacktrace_offset ( )

inlinestatic

Definition at line 856 of file thread.h.

                                             {
    return OFFSET_OF(Thread, active_stacktrace_);
  }

◆ AllocateReusableHandle()

template<class C >

C * dart::Thread::AllocateReusableHandle ( )

Definition at line 889 of file thread.cc.

                                  {
  C* handle = reinterpret_cast<C*>(reusable_handles_.AllocateScopedHandle());
  C::initializeHandle(handle, C::null());
  return handle;
}

◆ api_reusable_scope()

ApiLocalScope * dart::Thread::api_reusable_scope ( ) const

inline

Definition at line 504 of file thread.h.

504{ return api_reusable_scope_; }

◆ api_top_scope()

ApiLocalScope * dart::Thread::api_top_scope ( ) const

inline

Definition at line 512 of file thread.h.

512{ return api_top_scope_; }

◆ api_top_scope_offset()

static intptr_t dart::Thread::api_top_scope_offset ( )

inlinestatic

Definition at line 514 of file thread.h.

                                         {
    return OFFSET_OF(Thread, api_top_scope_);
  }

◆ AssertEmptyStackInvariants()

void dart::Thread::AssertEmptyStackInvariants ( )

Definition at line 284 of file thread.cc.

                                        {
  ASSERT(zone() == nullptr);
  ASSERT(top_handle_scope() == nullptr);
  ASSERT(long_jump_base() == nullptr);
  ASSERT(top_resource() == nullptr);
  ASSERT(top_exit_frame_info_ == 0);
  ASSERT(api_top_scope_ == nullptr);
  ASSERT(!pending_deopts_.HasPendingDeopts());
  ASSERT(compiler_state_ == nullptr);
  ASSERT(hierarchy_info_ == nullptr);
  ASSERT(type_usage_info_ == nullptr);
  ASSERT(no_active_isolate_scope_ == nullptr);
  ASSERT(compiler_timings_ == nullptr);
  ASSERT(!exit_through_ffi_);
  ASSERT(runtime_call_deopt_ability_ == RuntimeCallDeoptAbility::kCanLazyDeopt);
  ASSERT(no_callback_scope_depth_ == 0);
  ASSERT(force_growth_scope_depth_ == 0);
  ASSERT(no_reload_scope_depth_ == 0);
  ASSERT(stopped_mutators_scope_depth_ == 0);
  ASSERT(stack_overflow_flags_ == 0);
  DEBUG_ASSERT(!inside_compiler_);
  DEBUG_ASSERT(no_safepoint_scope_depth_ == 0);
 
  // Avoid running these asserts for `vm-isolate`.
  if (active_stacktrace_.untag() != 0) {
    ASSERT(sticky_error() == Error::null());
    ASSERT(active_exception_ == Object::null());
    ASSERT(active_stacktrace_ == Object::null());
  }
}

◆ AssertEmptyThreadInvariants()

void dart::Thread::AssertEmptyThreadInvariants ( )

Definition at line 315 of file thread.cc.

                                         {
  AssertEmptyStackInvariants();
 
  ASSERT(top_ == 0);
  ASSERT(end_ == 0);
  ASSERT(true_end_ == 0);
  ASSERT(isolate_ == nullptr);
  ASSERT(isolate_group_ == nullptr);
  ASSERT(os_thread() == nullptr);
  ASSERT(vm_tag_ == VMTag::kInvalidTagId);
  ASSERT(task_kind_ == kUnknownTask);
  ASSERT(execution_state_ == Thread::kThreadInNative);
  ASSERT(scheduled_dart_mutator_isolate_ == nullptr);
 
  ASSERT(write_barrier_mask_ == UntaggedObject::kGenerationalBarrierMask);
  ASSERT(store_buffer_block_ == nullptr);
  ASSERT(marking_stack_block_ == nullptr);
  ASSERT(deferred_marking_stack_block_ == nullptr);
  ASSERT(!is_unwind_in_progress_);
 
  ASSERT(saved_stack_limit_ == OSThread::kInvalidStackLimit);
  ASSERT(stack_limit_.load() == 0);
  ASSERT(safepoint_state_ == 0);
 
  // Avoid running these asserts for `vm-isolate`.
  if (active_stacktrace_.untag() != 0) {
    ASSERT(field_table_values_ == nullptr);
    ASSERT(global_object_pool_ == Object::null());
#define CHECK_REUSABLE_HANDLE(object) ASSERT(object##_handle_->IsNull());
    REUSABLE_HANDLE_LIST(CHECK_REUSABLE_HANDLE)
#undef CHECK_REUSABLE_HANDLE
  }
}

◆ AssertNonDartMutatorInvariants()

void dart::Thread::AssertNonDartMutatorInvariants ( )

Definition at line 276 of file thread.cc.

                                            {
  ASSERT(!IsDartMutatorThread());
  ASSERT(isolate() == nullptr);
  ASSERT(isolate_group() != nullptr);
  ASSERT(task_kind_ != kMutatorTask);
  DEBUG_ASSERT(!IsAnyReusableHandleScopeActive());
}

◆ AssertNonMutatorInvariants()

void dart::Thread::AssertNonMutatorInvariants ( )

Definition at line 268 of file thread.cc.

                                        {
  ASSERT(BypassSafepoints());
  ASSERT(store_buffer_block_ == nullptr);
  ASSERT(marking_stack_block_ == nullptr);
  ASSERT(deferred_marking_stack_block_ == nullptr);
  AssertNonDartMutatorInvariants();
}

◆ BlockForSafepoint()

void dart::Thread::BlockForSafepoint ( )

Definition at line 1282 of file thread.cc.

                               {
  isolate_group()->safepoint_handler()->BlockForSafepoint(this);
}

◆ BypassSafepoints()

bool dart::Thread::BypassSafepoints ( ) const

inline

Definition at line 994 of file thread.h.

                                {
    return BypassSafepointsField::decode(safepoint_state_);
  }

◆ CanAcquireSafepointLocks()

bool dart::Thread::CanAcquireSafepointLocks ( ) const

Definition at line 1306 of file thread.cc.

                                            {
  // A thread may acquire locks and then enter a safepoint operation (e.g.
  // holding program lock, allocating objects which triggers GC).
  //
  // So if this code is called inside safepoint operation, we generally have to
  // assume other threads may hold locks and are blocked on the safepoint,
  // meaning we cannot hold safepoint and acquire locks (deadlock!).
  //
  // Though if we own a reload safepoint operation it means all other mutators
  // are blocked in very specific places, where we know no locks are held. As
  // such we allow the current thread to acquire locks.
  //
  // Example: We own reload safepoint operation, load kernel, which allocates
  // symbols, where the symbol implementation acquires the symbol lock (we know
  // other mutators at reload safepoint do not hold symbol lock).
  return isolate_group()->safepoint_handler()->InnermostSafepointOperation(
             this) >= SafepointLevel::kGCAndDeoptAndReload;
}

◆ CanLoadFromThread()

bool dart::Thread::CanLoadFromThread ( const Object & object )

static

Definition at line 1088 of file thread.cc.

                                                   {
  // In order to allow us to use assembler helper routines with non-[Code]
  // objects *before* stubs are initialized, we only loop ver the stubs if the
  // [object] is in fact a [Code] object.
  if (object.IsCode()) {
#define CHECK_OBJECT(type_name, member_name, expr, default_init_value)         \
  if (object.ptr() == expr) {                                                  \
    return true;                                                               \
  }
    CACHED_VM_STUBS_LIST(CHECK_OBJECT)
#undef CHECK_OBJECT
  }
 
  // For non [Code] objects we check if the object equals to any of the cached
  // non-stub entries.
#define CHECK_OBJECT(type_name, member_name, expr, default_init_value)         \
  if (object.ptr() == expr) {                                                  \
    return true;                                                               \
  }
  CACHED_NON_VM_STUB_LIST(CHECK_OBJECT)
#undef CHECK_OBJECT
  return false;
}

◆ CheckForSafepoint()

void dart::Thread::CheckForSafepoint ( )

inline

Definition at line 1091 of file thread.h.

                           {
    // If we are in a runtime call that doesn't support lazy deopt, we will only
    // respond to gc safepointing requests.
    ASSERT(no_safepoint_scope_depth() == 0);
    if (IsSafepointRequested()) {
      BlockForSafepoint();
    }
  }

◆ ClearReusableHandles()

void dart::Thread::ClearReusableHandles ( )

Definition at line 895 of file thread.cc.

                                  {
#define CLEAR_REUSABLE_HANDLE(object) *object##_handle_ = object::null();
  REUSABLE_HANDLE_LIST(CLEAR_REUSABLE_HANDLE)
#undef CLEAR_REUSABLE_HANDLE
}

◆ ClearStackLimit()

void dart::Thread::ClearStackLimit ( )

Definition at line 696 of file thread.cc.

                             {
  SetStackLimit(OSThread::kInvalidStackLimit);
}

◆ ClearStickyError()

void dart::Thread::ClearStickyError ( )

Definition at line 239 of file thread.cc.

                              {
  sticky_error_ = Error::null();
}

◆ compiler_state()

CompilerState & dart::Thread::compiler_state ( )

inline

Definition at line 583 of file thread.h.

                                  {
    ASSERT(HasCompilerState());
    return *compiler_state_;
  }

◆ compiler_timings()

CompilerTimings * dart::Thread::compiler_timings ( ) const

inline

Definition at line 612 of file thread.h.

612{ return compiler_timings_; }

◆ CountLocalHandles()

intptr_t dart::Thread::CountLocalHandles ( ) const

Definition at line 1215 of file thread.cc.

                                         {
  intptr_t total = 0;
  ApiLocalScope* scope = api_top_scope_;
  while (scope != nullptr) {
    total += scope->local_handles()->CountHandles();
    scope = scope->previous();
  }
  return total;
}

◆ Current()

static Thread * dart::Thread::Current ( )

inlinestatic

Definition at line 361 of file thread.h.

                           {
    return static_cast<Thread*>(OSThread::CurrentVMThread());
  }

◆ current_safepoint_level()

SafepointLevel dart::Thread::current_safepoint_level ( ) const

inline

Definition at line 1133 of file thread.h.

                                                 {
    if (runtime_call_deopt_ability_ ==
        RuntimeCallDeoptAbility::kCannotLazyDeopt) {
      return SafepointLevel::kGC;
    }
    if (no_reload_scope_depth_ > 0 || allow_reload_scope_depth_ <= 0) {
      return SafepointLevel::kGCAndDeopt;
    }
    return SafepointLevel::kGCAndDeoptAndReload;
  }

◆ dart_stream_offset()

static intptr_t dart::Thread::dart_stream_offset ( )

inlinestatic

Definition at line 566 of file thread.h.

                                       {
    return OFFSET_OF(Thread, dart_stream_);
  }

◆ DecrementForceGrowthScopeDepth()

void dart::Thread::DecrementForceGrowthScopeDepth ( )

inline

Definition at line 633 of file thread.h.

                                        {
    ASSERT(force_growth_scope_depth_ > 0);
    force_growth_scope_depth_ -= 1;
  }

◆ DecrementNoCallbackScopeDepth()

void dart::Thread::DecrementNoCallbackScopeDepth ( )

inline

Definition at line 623 of file thread.h.

                                       {
    ASSERT(no_callback_scope_depth_ > 0);
    no_callback_scope_depth_ -= 1;
  }

◆ DecrementNoSafepointScopeDepth()

void dart::Thread::DecrementNoSafepointScopeDepth ( )

inline

Definition at line 720 of file thread.h.

                                        {
#if defined(DEBUG)
    ASSERT(no_safepoint_scope_depth_ > 0);
    no_safepoint_scope_depth_ -= 1;
#endif
  }

◆ DeferredMarkingStackAddObject()

void dart::Thread::DeferredMarkingStackAddObject ( ObjectPtr obj )

Definition at line 833 of file thread.cc.

                                                        {
  deferred_marking_stack_block_->Push(obj);
  if (deferred_marking_stack_block_->IsFull()) {
    DeferredMarkingStackBlockProcess();
  }
}

◆ DeferredMarkingStackBlockProcess()

void dart::Thread::DeferredMarkingStackBlockProcess ( )

Definition at line 821 of file thread.cc.

                                              {
  DeferredMarkingStackRelease();
  DeferredMarkingStackAcquire();
}

◆ DeferredMarkLiveTemporaries()

void dart::Thread::DeferredMarkLiveTemporaries ( )

Definition at line 1078 of file thread.cc.

                                         {
  RestoreWriteBarrierInvariant(
      RestoreWriteBarrierInvariantOp::kAddToDeferredMarkingStack);
}

◆ dispatch_table_array()

const uword * dart::Thread::dispatch_table_array ( ) const

inline

Definition at line 784 of file thread.h.

784{ return dispatch_table_array_; }

◆ dispatch_table_array_offset()

static intptr_t dart::Thread::dispatch_table_array_offset ( )

inlinestatic

Definition at line 844 of file thread.h.

                                                {
    return OFFSET_OF(Thread, dispatch_table_array_);
  }

◆ double_truncate_round_supported_offset()

static intptr_t dart::Thread::double_truncate_round_supported_offset ( )

inlinestatic

Definition at line 521 of file thread.h.

                                                           {
    return OFFSET_OF(Thread, double_truncate_round_supported_);
  }

◆ end()

uword dart::Thread::end ( ) const

inline

Definition at line 697 of file thread.h.

697{ return end_; }

◆ end_offset()

static intptr_t dart::Thread::end_offset ( )

inlinestatic

Definition at line 703 of file thread.h.

703{ return OFFSET_OF(Thread, end_); }

◆ EnterApiScope()

void dart::Thread::EnterApiScope ( )

Definition at line 1235 of file thread.cc.

                           {
  ASSERT(MayAllocateHandles());
  ApiLocalScope* new_scope = api_reusable_scope();
  if (new_scope == nullptr) {
    new_scope = new ApiLocalScope(api_top_scope(), top_exit_frame_info());
    ASSERT(new_scope != nullptr);
  } else {
    new_scope->Reinit(this, api_top_scope(), top_exit_frame_info());
    set_api_reusable_scope(nullptr);
  }
  set_api_top_scope(new_scope);  // New scope is now the top scope.
}

◆ EnterIsolate()

void dart::Thread::EnterIsolate ( Isolate * isolate )

static

Definition at line 366 of file thread.cc.

                                          {
  const bool is_resumable = isolate->mutator_thread() != nullptr;
 
  // To let VM's thread pool (if we run on it) know that this thread is
  // occupying a mutator again (decreases its max size).
  const bool is_nested_reenter =
      (is_resumable && isolate->mutator_thread()->top_exit_frame_info() != 0);
 
  auto group = isolate->group();
  if (!(is_nested_reenter && isolate->mutator_thread()->OwnsSafepoint())) {
    group->IncreaseMutatorCount(isolate, is_nested_reenter);
  }
 
  // Two threads cannot enter isolate at same time.
  ASSERT(isolate->scheduled_mutator_thread_ == nullptr);
 
  // We lazily create a [Thread] structure for the mutator thread, but we'll
  // reuse it until the death of the isolate.
  Thread* thread = nullptr;
  if (is_resumable) {
    thread = isolate->mutator_thread();
    ASSERT(thread->scheduled_dart_mutator_isolate_ == isolate);
    ASSERT(thread->isolate() == isolate);
    ASSERT(thread->isolate_group() == isolate->group());
    {
      // Descheduled isolates are reloadable (if nothing else prevents it).
      RawReloadParticipationScope enable_reload(thread);
      thread->ExitSafepoint();
    }
  } else {
    thread = AddActiveThread(group, isolate, /*is_dart_mutator*/ true,
                             /*bypass_safepoint=*/false);
    thread->SetupState(kMutatorTask);
    thread->SetupMutatorState(kMutatorTask);
    thread->SetupDartMutatorState(isolate);
  }
 
  isolate->scheduled_mutator_thread_ = thread;
  ResumeDartMutatorThreadInternal(thread);
}

◆ EnterIsolateGroupAsHelper()

bool dart::Thread::EnterIsolateGroupAsHelper	(	IsolateGroup *	isolate_group,
		TaskKind	kind,
		bool	bypass_safepoint
	)

static

Definition at line 476 of file thread.cc.

                                                              {
  Thread* thread = AddActiveThread(isolate_group, nullptr,
                                   /*is_dart_mutator=*/false, bypass_safepoint);
  if (thread != nullptr) {
    thread->SetupState(kind);
    // Even if [bypass_safepoint] is true, a thread may need mutator state (e.g.
    // parallel scavenger threads write to the [Thread]s storebuffer)
    thread->SetupMutatorState(kind);
    ResumeThreadInternal(thread);
 
    thread->AssertNonDartMutatorInvariants();
    return true;
  }
  return false;
}

◆ EnterIsolateGroupAsNonMutator()

bool dart::Thread::EnterIsolateGroupAsNonMutator	(	IsolateGroup *	isolate_group,
		TaskKind	kind
	)

static

Definition at line 506 of file thread.cc.

                                                          {
  Thread* thread =
      AddActiveThread(isolate_group, nullptr,
                      /*is_dart_mutator=*/false, /*bypass_safepoint=*/true);
  if (thread != nullptr) {
    thread->SetupState(kind);
    ResumeThreadInternal(thread);
 
    thread->AssertNonMutatorInvariants();
    return true;
  }
  return false;
}

◆ EnterSafepoint()

void dart::Thread::EnterSafepoint ( )

inline

Definition at line 1063 of file thread.h.

                        {
    ASSERT(no_safepoint_scope_depth() == 0);
    // First try a fast update of the thread state to indicate it is at a
    // safepoint.
    if (!TryEnterSafepoint()) {
      // Fast update failed which means we could potentially be in the middle
      // of a safepoint operation.
      EnterSafepointUsingLock();
    }
  }

◆ execution_state()

ExecutionState dart::Thread::execution_state ( ) const

inline

Definition at line 1027 of file thread.h.

                                         {
    return static_cast<ExecutionState>(execution_state_);
  }

◆ execution_state_cross_thread_for_testing()

NO_SANITIZE_THREAD ExecutionState dart::Thread::execution_state_cross_thread_for_testing ( ) const

inline

Definition at line 1032 of file thread.h.

                                                                  {
    return static_cast<ExecutionState>(execution_state_);
  }

◆ execution_state_offset()

static intptr_t dart::Thread::execution_state_offset ( )

inlinestatic

Definition at line 1038 of file thread.h.

                                           {
    return OFFSET_OF(Thread, execution_state_);
  }

◆ exit_through_ffi_offset()

static intptr_t dart::Thread::exit_through_ffi_offset ( )

inlinestatic

Definition at line 474 of file thread.h.

                                            {
    return OFFSET_OF(Thread, exit_through_ffi_);
  }

◆ ExitApiScope()

void dart::Thread::ExitApiScope ( )

Definition at line 1248 of file thread.cc.

                          {
  ASSERT(MayAllocateHandles());
  ApiLocalScope* scope = api_top_scope();
  ApiLocalScope* reusable_scope = api_reusable_scope();
  set_api_top_scope(scope->previous());  // Reset top scope to previous.
  if (reusable_scope == nullptr) {
    scope->Reset(this);  // Reset the old scope which we just exited.
    set_api_reusable_scope(scope);
  } else {
    ASSERT(reusable_scope != scope);
    delete scope;
  }
}

◆ ExitIsolate()

void dart::Thread::ExitIsolate ( bool isolate_shutdown = false )

static

Definition at line 423 of file thread.cc.

                                              {
  Thread* thread = Thread::Current();
  ASSERT(thread != nullptr);
  ASSERT(thread->IsDartMutatorThread());
  ASSERT(thread->isolate() != nullptr);
  ASSERT(thread->isolate_group() != nullptr);
  ASSERT(thread->isolate()->mutator_thread_ == thread);
  ASSERT(thread->isolate()->scheduled_mutator_thread_ == thread);
  DEBUG_ASSERT(!thread->IsAnyReusableHandleScopeActive());
 
  auto isolate = thread->isolate();
  auto group = thread->isolate_group();
 
  thread->set_vm_tag(isolate->is_runnable() ? VMTag::kIdleTagId
                                            : VMTag::kLoadWaitTagId);
  if (thread->sticky_error() != Error::null()) {
    ASSERT(isolate->sticky_error_ == Error::null());
    isolate->sticky_error_ = thread->StealStickyError();
  }
 
  isolate->scheduled_mutator_thread_ = nullptr;
 
  // Right now we keep the [Thread] object across the isolate's lifetime. This
  // makes entering/exiting quite fast as it mainly boils down to safepoint
  // transitions. Though any operation that walks over all active threads will
  // see this thread as well (e.g. safepoint operations).
  const bool is_nested_exit = thread->top_exit_frame_info() != 0;
  if (ShouldSuspend(isolate_shutdown, thread)) {
    const auto tag =
        isolate->is_runnable() ? VMTag::kIdleTagId : VMTag::kLoadWaitTagId;
    SuspendDartMutatorThreadInternal(thread, tag);
    {
      // Descheduled isolates are reloadable (if nothing else prevents it).
      RawReloadParticipationScope enable_reload(thread);
      thread->EnterSafepoint();
    }
    thread->set_execution_state(Thread::kThreadInNative);
  } else {
    thread->ResetDartMutatorState(isolate);
    thread->ResetMutatorState();
    thread->ResetState();
    SuspendDartMutatorThreadInternal(thread, VMTag::kInvalidTagId);
    FreeActiveThread(thread, /*bypass_safepoint=*/false);
  }
 
  // To let VM's thread pool (if we run on it) know that this thread is
  // occupying a mutator again (decreases its max size).
  ASSERT(!(isolate_shutdown && is_nested_exit));
  if (!(is_nested_exit && thread->OwnsSafepoint())) {
    group->DecreaseMutatorCount(isolate, is_nested_exit);
  }
}

◆ ExitIsolateGroupAsHelper()

void dart::Thread::ExitIsolateGroupAsHelper ( bool bypass_safepoint )

static

Definition at line 494 of file thread.cc.

                                                           {
  Thread* thread = Thread::Current();
  thread->AssertNonDartMutatorInvariants();
 
  // Even if [bypass_safepoint] is true, a thread may need mutator state (e.g.
  // parallel scavenger threads write to the [Thread]s storebuffer)
  thread->ResetMutatorState();
  thread->ResetState();
  SuspendThreadInternal(thread, VMTag::kInvalidTagId);
  FreeActiveThread(thread, bypass_safepoint);
}

◆ ExitIsolateGroupAsNonMutator()

void dart::Thread::ExitIsolateGroupAsNonMutator ( )

static

Definition at line 521 of file thread.cc.

                                          {
  Thread* thread = Thread::Current();
  ASSERT(thread != nullptr);
  thread->AssertNonMutatorInvariants();
 
  thread->ResetState();
  SuspendThreadInternal(thread, VMTag::kInvalidTagId);
  FreeActiveThread(thread, /*bypass_safepoint=*/true);
}

◆ ExitSafepoint()

void dart::Thread::ExitSafepoint ( )

inline

Definition at line 1081 of file thread.h.

                       {
    // First try a fast update of the thread state to indicate it is not at a
    // safepoint anymore.
    if (!TryExitSafepoint()) {
      // Fast update failed which means we could potentially be in the middle
      // of a safepoint operation.
      ExitSafepointUsingLock();
    }
  }

◆ field_table_values_offset()

static intptr_t dart::Thread::field_table_values_offset ( )

inlinestatic

Definition at line 542 of file thread.h.

                                              {
    return OFFSET_OF(Thread, field_table_values_);
  }

◆ force_growth()

bool dart::Thread::force_growth ( ) const

inline

Definition at line 628 of file thread.h.

628{ return force_growth_scope_depth_ != 0; }

◆ full_safepoint_state_acquired()

static uword dart::Thread::full_safepoint_state_acquired ( )

inlinestatic

Definition at line 1051 of file thread.h.

                                               {
    return (1 << AtSafepointField::shift()) |
           (1 << AtDeoptSafepointField::shift());
  }

◆ full_safepoint_state_unacquired()

static uword dart::Thread::full_safepoint_state_unacquired ( )

inlinestatic

Definition at line 1047 of file thread.h.

                                                 {
    return (0 << AtSafepointField::shift()) |
           (0 << AtDeoptSafepointField::shift());
  }

◆ GetAndClearInterrupts()

uword dart::Thread::GetAndClearInterrupts ( )

Definition at line 719 of file thread.cc.

                                    {
  uword interrupt_bits = 0;
  uword old_limit = stack_limit_.load();
  uword new_limit = saved_stack_limit_;
  do {
    if (IsInterruptLimit(old_limit)) {
      interrupt_bits = interrupt_bits | (old_limit & kInterruptsMask);
    } else {
      return interrupt_bits;
    }
  } while (!stack_limit_.compare_exchange_weak(old_limit, new_limit));
 
  return interrupt_bits;
}

◆ GetAndClearStackOverflowFlags()

uword dart::Thread::GetAndClearStackOverflowFlags ( )

Definition at line 780 of file thread.cc.

                                            {
  uword stack_overflow_flags = stack_overflow_flags_;
  stack_overflow_flags_ = 0;
  return stack_overflow_flags;
}

◆ GetNextTaskId()

int64_t dart::Thread::GetNextTaskId ( )

inline

Definition at line 1116 of file thread.h.

1116{ return next_task_id_++; }

◆ global_object_pool()

ObjectPoolPtr dart::Thread::global_object_pool ( ) const

inline

Definition at line 779 of file thread.h.

779{ return global_object_pool_; }

◆ global_object_pool_offset()

static intptr_t dart::Thread::global_object_pool_offset ( )

inlinestatic

Definition at line 840 of file thread.h.

                                              {
    return OFFSET_OF(Thread, global_object_pool_);
  }

◆ HandleInterrupts()

ErrorPtr dart::Thread::HandleInterrupts ( )

Definition at line 734 of file thread.cc.

                                  {
  uword interrupt_bits = GetAndClearInterrupts();
  if ((interrupt_bits & kVMInterrupt) != 0) {
    CheckForSafepoint();
    if (isolate_group()->store_buffer()->Overflowed()) {
      // Evacuate: If the popular store buffer targets are copied instead of
      // promoted, the store buffer won't shrink and a second scavenge will
      // occur that does promote them.
      heap()->CollectGarbage(this, GCType::kEvacuate, GCReason::kStoreBuffer);
    }
    heap()->CheckFinalizeMarking(this);
 
#if !defined(PRODUCT)
    if (isolate()->TakeHasCompletedBlocks()) {
      Profiler::ProcessCompletedBlocks(isolate());
    }
#endif  // !defined(PRODUCT)
 
#if !defined(PRODUCT) || defined(FORCE_INCLUDE_SAMPLING_HEAP_PROFILER)
    HeapProfileSampler& sampler = heap_sampler();
    if (sampler.ShouldSetThreadSamplingInterval()) {
      sampler.SetThreadSamplingInterval();
    }
    if (sampler.ShouldUpdateThreadEnable()) {
      sampler.UpdateThreadEnable();
    }
#endif  // !defined(PRODUCT) || defined(FORCE_INCLUDE_SAMPLING_HEAP_PROFILER)
  }
  if ((interrupt_bits & kMessageInterrupt) != 0) {
    MessageHandler::MessageStatus status =
        isolate()->message_handler()->HandleOOBMessages();
    if (status != MessageHandler::kOK) {
      // False result from HandleOOBMessages signals that the isolate should
      // be terminating.
      if (FLAG_trace_isolates) {
        OS::PrintErr(
            "[!] Terminating isolate due to OOB message:\n"
            "\tisolate:    %s\n",
            isolate()->name());
      }
      return StealStickyError();
    }
  }
  return Error::null();
}

◆ HasActiveState()

bool dart::Thread::HasActiveState ( )

Definition at line 349 of file thread.cc.

                            {
  // Do we have active dart frames?
  if (top_exit_frame_info() != 0) {
    return true;
  }
  // Do we have active embedder scopes?
  if (api_top_scope() != nullptr) {
    return true;
  }
  // Do we have active vm zone?
  if (zone() != nullptr) {
    return true;
  }
  AssertEmptyStackInvariants();
  return false;
}

◆ HasCompilerState()

bool dart::Thread::HasCompilerState ( ) const

inline

Definition at line 581 of file thread.h.

581{ return compiler_state_ != nullptr; }

◆ HasExitedDartCode()

bool dart::Thread::HasExitedDartCode ( ) const

Definition at line 884 of file thread.cc.

                                     {
  return (top_exit_frame_info() != 0) && !VMTag::IsDartTag(vm_tag());
}

◆ HasScheduledInterrupts()

bool dart::Thread::HasScheduledInterrupts ( ) const

inline

Definition at line 496 of file thread.h.

                                      {
    return (stack_limit_.load() & kInterruptsMask) != 0;
  }

◆ heap()

Heap * dart::Thread::heap ( ) const

Definition at line 876 of file thread.cc.

                         {
  return isolate_group_->heap();
}

◆ heap_base()

uword dart::Thread::heap_base ( ) const

inline

Definition at line 428 of file thread.h.

                          {
#if defined(DART_COMPRESSED_POINTERS)
    return heap_base_;
#else
    return 0;
#endif
  }

◆ heap_sampler()

HeapProfileSampler & dart::Thread::heap_sampler ( )

inline

Definition at line 1128 of file thread.h.

1128{ return heap_sampler_; }

◆ hierarchy_info()

HierarchyInfo * dart::Thread::hierarchy_info ( ) const

inline

Definition at line 588 of file thread.h.

                                        {
    ASSERT(isolate_group_ != nullptr);
    return hierarchy_info_;
  }

◆ IncrementAndGetRuntimeCallCount()

uint32_t dart::Thread::IncrementAndGetRuntimeCallCount ( )

inline

Definition at line 450 of file thread.h.

450{ return ++runtime_call_count_; }

◆ IncrementAndGetStackOverflowCount()

int32_t dart::Thread::IncrementAndGetStackOverflowCount ( )

inline

Definition at line 446 of file thread.h.

                                              {
    return ++stack_overflow_count_;
  }

◆ IncrementForceGrowthScopeDepth()

void dart::Thread::IncrementForceGrowthScopeDepth ( )

inline

Definition at line 629 of file thread.h.

                                        {
    ASSERT(force_growth_scope_depth_ < INT_MAX);
    force_growth_scope_depth_ += 1;
  }

◆ IncrementNoCallbackScopeDepth()

void dart::Thread::IncrementNoCallbackScopeDepth ( )

inline

Definition at line 619 of file thread.h.

                                       {
    ASSERT(no_callback_scope_depth_ < INT_MAX);
    no_callback_scope_depth_ += 1;
  }

◆ IncrementNoSafepointScopeDepth()

void dart::Thread::IncrementNoSafepointScopeDepth ( )

inline

Definition at line 713 of file thread.h.

                                        {
#if defined(DEBUG)
    ASSERT(no_safepoint_scope_depth_ < INT_MAX);
    no_safepoint_scope_depth_ += 1;
#endif
  }

◆ InitVMConstants()

void dart::Thread::InitVMConstants ( )

Definition at line 181 of file thread.cc.

                             {
#if defined(DART_COMPRESSED_POINTERS)
  heap_base_ = Object::null()->heap_base();
#endif
 
#define ASSERT_VM_HEAP(type_name, member_name, init_expr, default_init_value)  \
  ASSERT((init_expr)->IsOldObject());
  CACHED_VM_OBJECTS_LIST(ASSERT_VM_HEAP)
#undef ASSERT_VM_HEAP
 
#define INIT_VALUE(type_name, member_name, init_expr, default_init_value)      \
  ASSERT(member_name == default_init_value);                                   \
  member_name = (init_expr);
  CACHED_CONSTANTS_LIST(INIT_VALUE)
#undef INIT_VALUE
 
  for (intptr_t i = 0; i < kNumberOfDartAvailableCpuRegs; ++i) {
    write_barrier_wrappers_entry_points_[i] =
        StubCode::WriteBarrierWrappers().EntryPoint() +
        i * kStoreBufferWrapperSize;
  }
 
#define INIT_VALUE(name)                                                       \
  ASSERT(name##_entry_point_ == 0);                                            \
  name##_entry_point_ = k##name##RuntimeEntry.GetEntryPoint();
  RUNTIME_ENTRY_LIST(INIT_VALUE)
#undef INIT_VALUE
 
#define INIT_VALUE(returntype, name, ...)                                      \
  ASSERT(name##_entry_point_ == 0);                                            \
  name##_entry_point_ = k##name##RuntimeEntry.GetEntryPoint();
  LEAF_RUNTIME_ENTRY_LIST(INIT_VALUE)
#undef INIT_VALUE
 
// Setup the thread specific reusable handles.
#define REUSABLE_HANDLE_ALLOCATION(object)                                     \
  this->object##_handle_ = this->AllocateReusableHandle<object>();
  REUSABLE_HANDLE_LIST(REUSABLE_HANDLE_ALLOCATION)
#undef REUSABLE_HANDLE_ALLOCATION
}

◆ is_marking()

bool dart::Thread::is_marking ( ) const

inline

Definition at line 669 of file thread.h.

669{ return marking_stack_block_ != nullptr; }

◆ is_unwind_in_progress()

bool dart::Thread::is_unwind_in_progress ( ) const

inline

Definition at line 638 of file thread.h.

638{ return is_unwind_in_progress_; }

◆ IsAtSafepoint() [1/3]

bool dart::Thread::IsAtSafepoint ( ) const

inline

Definition at line 904 of file thread.h.

                             {
    // Owning a higher level safepoint implies owning the lower levels as well.
    return IsAtSafepoint(SafepointLevel::kGC);
  }

◆ IsAtSafepoint() [2/3]

bool dart::Thread::IsAtSafepoint ( SafepointLevel level ) const

inline

Definition at line 908 of file thread.h.

                                                 {
    return IsAtSafepoint(level, safepoint_state_.load());
  }

◆ IsAtSafepoint() [3/3]

static bool dart::Thread::IsAtSafepoint	(	SafepointLevel	level,
		uword	state
	)

inlinestatic

Definition at line 898 of file thread.h.

                                                               {
    const uword mask = AtSafepointBits(level);
    return (state & mask) == mask;
  }

◆ IsBlockedForSafepoint() [1/2]

bool dart::Thread::IsBlockedForSafepoint ( ) const

inline

Definition at line 986 of file thread.h.

                                     {
    return BlockedForSafepointField::decode(safepoint_state_);
  }

◆ IsBlockedForSafepoint() [2/2]

static bool dart::Thread::IsBlockedForSafepoint ( uword state )

inlinestatic

Definition at line 983 of file thread.h.

                                                 {
    return BlockedForSafepointField::decode(state);
  }

◆ IsDartMutatorThread()

bool dart::Thread::IsDartMutatorThread ( ) const

inline

Definition at line 546 of file thread.h.

                                   {
    return scheduled_dart_mutator_isolate_ != nullptr;
  }

◆ IsExecutingDartCode()

bool dart::Thread::IsExecutingDartCode ( ) const

Definition at line 880 of file thread.cc.

                                       {
  return (top_exit_frame_info() == 0) && VMTag::IsDartTag(vm_tag());
}

◆ IsInNoReloadScope()

bool dart::Thread::IsInNoReloadScope ( ) const

inline

Definition at line 727 of file thread.h.

727{ return no_reload_scope_depth_ > 0; }

◆ IsInStoppedMutatorsScope()

bool dart::Thread::IsInStoppedMutatorsScope ( ) const

inline

Definition at line 729 of file thread.h.

                                        {
    return stopped_mutators_scope_depth_ > 0;
  }

◆ isolate()

Isolate * dart::Thread::isolate ( ) const

inline

Definition at line 533 of file thread.h.

533{ return isolate_; }

◆ isolate_group()

IsolateGroup * dart::Thread::isolate_group ( ) const

inline

Definition at line 540 of file thread.h.

540{ return isolate_group_; }

◆ isolate_group_offset()

static intptr_t dart::Thread::isolate_group_offset ( )

inlinestatic

Definition at line 535 of file thread.h.

                                         {
    return OFFSET_OF(Thread, isolate_group_);
  }

◆ isolate_offset()

static intptr_t dart::Thread::isolate_offset ( )

inlinestatic

Definition at line 534 of file thread.h.

534{ return OFFSET_OF(Thread, isolate_); }

◆ IsSafepointLevelRequested()

static bool dart::Thread::IsSafepointLevelRequested	(	uword	state,
		SafepointLevel	level
	)

inlinestatic

Definition at line 942 of file thread.h.

                                                                           {
    switch (level) {
      case SafepointLevel::kGC:
        return (state & SafepointRequestedField::mask_in_place()) != 0;
      case SafepointLevel::kGCAndDeopt:
        return (state & DeoptSafepointRequestedField::mask_in_place()) != 0;
      case SafepointLevel::kGCAndDeoptAndReload:
        return (state & ReloadSafepointRequestedField::mask_in_place()) != 0;
      default:
        UNREACHABLE();
    }
  }

◆ IsSafepointLevelRequestedLocked()

bool dart::Thread::IsSafepointLevelRequestedLocked ( SafepointLevel level ) const

inline

Definition at line 935 of file thread.h.

                                                                   {
    ASSERT(thread_lock()->IsOwnedByCurrentThread());
    if (level > current_safepoint_level()) return false;
    const uword state = safepoint_state_.load();
    return IsSafepointLevelRequested(state, level);
  }

◆ IsSafepointRequested() [1/2]

bool dart::Thread::IsSafepointRequested ( ) const

inline

Definition at line 924 of file thread.h.

                                    {
    return IsSafepointRequested(current_safepoint_level());
  }

◆ IsSafepointRequested() [2/2]

bool dart::Thread::IsSafepointRequested ( SafepointLevel level ) const

inline

Definition at line 927 of file thread.h.

                                                        {
    const uword state = safepoint_state_.load();
    for (intptr_t i = level; i >= 0; --i) {
      if (IsSafepointLevelRequested(state, static_cast<SafepointLevel>(i)))
        return true;
    }
    return false;
  }

◆ IsSafepointRequestedLocked()

bool dart::Thread::IsSafepointRequestedLocked ( SafepointLevel level ) const

inline

Definition at line 920 of file thread.h.

                                                              {
    ASSERT(thread_lock()->IsOwnedByCurrentThread());
    return IsSafepointRequested(level);
  }

◆ IsValidHandle()

bool dart::Thread::IsValidHandle ( Dart_Handle object ) const

Definition at line 1199 of file thread.cc.

                                                   {
  return IsValidLocalHandle(object) || IsValidZoneHandle(object) ||
         IsValidScopedHandle(object);
}

◆ IsValidLocalHandle()

bool dart::Thread::IsValidLocalHandle ( Dart_Handle object ) const

Definition at line 1204 of file thread.cc.

                                                        {
  ApiLocalScope* scope = api_top_scope_;
  while (scope != nullptr) {
    if (scope->local_handles()->IsValidHandle(object)) {
      return true;
    }
    scope = scope->previous();
  }
  return false;
}

◆ marking_stack_block_offset()

static intptr_t dart::Thread::marking_stack_block_offset ( )

inlinestatic

Definition at line 674 of file thread.h.

                                               {
    return OFFSET_OF(Thread, marking_stack_block_);
  }

◆ MarkingStackAddObject()

void dart::Thread::MarkingStackAddObject ( ObjectPtr obj )

Definition at line 826 of file thread.cc.

                                                {
  marking_stack_block_->Push(obj);
  if (marking_stack_block_->IsFull()) {
    MarkingStackBlockProcess();
  }
}

◆ MarkingStackBlockProcess()

void dart::Thread::MarkingStackBlockProcess ( )

Definition at line 816 of file thread.cc.

                                      {
  MarkingStackRelease();
  MarkingStackAcquire();
}

◆ MayAllocateHandles()

virtual bool dart::Thread::MayAllocateHandles ( )

inlinevirtual

Implements dart::ThreadState.

Definition at line 1042 of file thread.h.

                                    {
    return (execution_state() == kThreadInVM) ||
           (execution_state() == kThreadInGenerated);
  }

◆ next()

Thread * dart::Thread::next ( ) const

inline

Definition at line 1100 of file thread.h.

1100{ return next_; }

◆ next_task_id_offset()

static intptr_t dart::Thread::next_task_id_offset ( )

inlinestatic

Definition at line 1117 of file thread.h.

                                        {
    return OFFSET_OF(Thread, next_task_id_);
  }

◆ no_callback_scope_depth()

int32_t dart::Thread::no_callback_scope_depth ( ) const

inline

Definition at line 618 of file thread.h.

618{ return no_callback_scope_depth_; }

◆ no_safepoint_scope_depth()

int32_t dart::Thread::no_safepoint_scope_depth ( ) const

inline

Definition at line 705 of file thread.h.

                                           {
#if defined(DEBUG)
    return no_safepoint_scope_depth_;
#else
    return 0;
#endif
  }

◆ ObjectAtOffset()

bool dart::Thread::ObjectAtOffset	(	intptr_t	offset,
		Object *	object
	)

static

Definition at line 1139 of file thread.cc.

                                                           {
  if (Isolate::Current() == Dart::vm_isolate()) {
    // --disassemble-stubs runs before all the references through
    // thread have targets
    return false;
  }
 
#define COMPUTE_OFFSET(type_name, member_name, expr, default_init_value)       \
  if (Thread::member_name##offset() == offset) {                               \
    *object = expr;                                                            \
    return true;                                                               \
  }
  CACHED_VM_OBJECTS_LIST(COMPUTE_OFFSET)
#undef COMPUTE_OFFSET
  return false;
}

◆ OffsetFromThread() [1/2]

intptr_t dart::Thread::OffsetFromThread ( const Object & object )

static

Definition at line 1112 of file thread.cc.

                                                      {
  // In order to allow us to use assembler helper routines with non-[Code]
  // objects *before* stubs are initialized, we only loop ver the stubs if the
  // [object] is in fact a [Code] object.
  if (object.IsCode()) {
#define COMPUTE_OFFSET(type_name, member_name, expr, default_init_value)       \
  ASSERT((expr)->untag()->InVMIsolateHeap());                                  \
  if (object.ptr() == expr) {                                                  \
    return Thread::member_name##offset();                                      \
  }
    CACHED_VM_STUBS_LIST(COMPUTE_OFFSET)
#undef COMPUTE_OFFSET
  }
 
  // For non [Code] objects we check if the object equals to any of the cached
  // non-stub entries.
#define COMPUTE_OFFSET(type_name, member_name, expr, default_init_value)       \
  if (object.ptr() == expr) {                                                  \
    return Thread::member_name##offset();                                      \
  }
  CACHED_NON_VM_STUB_LIST(COMPUTE_OFFSET)
#undef COMPUTE_OFFSET
 
  UNREACHABLE();
  return -1;
}

◆ OffsetFromThread() [2/2]

intptr_t dart::Thread::OffsetFromThread ( const RuntimeEntry * runtime_entry )

static

Definition at line 1156 of file thread.cc.

                                                                   {
#define COMPUTE_OFFSET(name)                                                   \
  if (runtime_entry == &k##name##RuntimeEntry) {                               \
    return Thread::name##_entry_point_offset();                                \
  }
  RUNTIME_ENTRY_LIST(COMPUTE_OFFSET)
#undef COMPUTE_OFFSET
 
#define COMPUTE_OFFSET(returntype, name, ...)                                  \
  if (runtime_entry == &k##name##RuntimeEntry) {                               \
    return Thread::name##_entry_point_offset();                                \
  }
  LEAF_RUNTIME_ENTRY_LIST(COMPUTE_OFFSET)
#undef COMPUTE_OFFSET
 
  UNREACHABLE();
  return -1;
}

◆ OwnsDeoptSafepoint()

bool dart::Thread::OwnsDeoptSafepoint ( ) const

Definition at line 1291 of file thread.cc.

                                      {
  return isolate_group()->safepoint_handler()->InnermostSafepointOperation(
             this) == SafepointLevel::kGCAndDeopt;
}

◆ OwnsGCSafepoint()

bool dart::Thread::OwnsGCSafepoint ( ) const

Definition at line 1286 of file thread.cc.

                                   {
  return isolate_group()->safepoint_handler()->InnermostSafepointOperation(
             this) <= SafepointLevel::kGCAndDeopt;
}

◆ OwnsReloadSafepoint()

bool dart::Thread::OwnsReloadSafepoint ( ) const

Definition at line 1296 of file thread.cc.

                                       {
  return isolate_group()->safepoint_handler()->InnermostSafepointOperation(
             this) <= SafepointLevel::kGCAndDeoptAndReload;
}

◆ OwnsSafepoint()

bool dart::Thread::OwnsSafepoint ( ) const

Definition at line 1301 of file thread.cc.

                                 {
  return isolate_group()->safepoint_handler()->InnermostSafepointOperation(
             this) != SafepointLevel::kNoSafepoint;
}

◆ pending_deopts()

PendingDeopts & dart::Thread::pending_deopts ( )

inline

Definition at line 1131 of file thread.h.

1131{ return pending_deopts_; }

◆ PrintJSON()

void dart::Thread::PrintJSON ( JSONStream * stream ) const

◆ random()

Random * dart::Thread::random ( )

inline

Definition at line 1120 of file thread.h.

1120{ return &thread_random_; }

◆ random_offset()

static intptr_t dart::Thread::random_offset ( )

inlinestatic

Definition at line 1121 of file thread.h.

1121{ return OFFSET_OF(Thread, thread_random_); }

◆ ReleaseMarkingStack()

void dart::Thread::ReleaseMarkingStack ( )

◆ ReleaseStoreBuffer()

void dart::Thread::ReleaseStoreBuffer ( )

Definition at line 672 of file thread.cc.

                                {
  ASSERT(IsAtSafepoint() || OwnsSafepoint());
  if (store_buffer_block_ == nullptr || store_buffer_block_->IsEmpty()) {
    return;  // Nothing to release.
  }
  // Prevent scheduling another GC by ignoring the threshold.
  StoreBufferRelease(StoreBuffer::kIgnoreThreshold);
  // Make sure to get an *empty* block; the isolate needs all entries
  // at GC time.
  // TODO(koda): Replace with an epilogue (PrepareAfterGC) that acquires.
  store_buffer_block_ = isolate_group()->store_buffer()->PopEmptyBlock();
}

◆ RememberLiveTemporaries()

void dart::Thread::RememberLiveTemporaries ( )

Definition at line 1083 of file thread.cc.

                                     {
  RestoreWriteBarrierInvariant(
      RestoreWriteBarrierInvariantOp::kAddToRememberedSet);
}

◆ resume_pc()

uword dart::Thread::resume_pc ( ) const

inline

Definition at line 860 of file thread.h.

860{ return resume_pc_; }

◆ resume_pc_offset()

static uword dart::Thread::resume_pc_offset ( )

inlinestatic

Definition at line 862 of file thread.h.

862{ return OFFSET_OF(Thread, resume_pc_); }

◆ safepoint_state()

uword dart::Thread::safepoint_state ( )

inline

Definition at line 1018 of file thread.h.

1018{ return safepoint_state_; }

◆ safepoint_state_offset()

static intptr_t dart::Thread::safepoint_state_offset ( )

inlinestatic

Definition at line 458 of file thread.h.

                                           {
    return OFFSET_OF(Thread, safepoint_state_);
  }

◆ saved_shadow_call_stack()

uword dart::Thread::saved_shadow_call_stack ( ) const

inline

Definition at line 417 of file thread.h.

417{ return saved_shadow_call_stack_; }

◆ saved_shadow_call_stack_offset()

static uword dart::Thread::saved_shadow_call_stack_offset ( )

inlinestatic

Definition at line 418 of file thread.h.

                                                {
    return OFFSET_OF(Thread, saved_shadow_call_stack_);
  }

◆ saved_stack_limit()

uword dart::Thread::saved_stack_limit ( ) const

inline

Definition at line 409 of file thread.h.

409{ return saved_stack_limit_; }

◆ saved_stack_limit_offset()

static intptr_t dart::Thread::saved_stack_limit_offset ( )

inlinestatic

Definition at line 406 of file thread.h.

                                             {
    return OFFSET_OF(Thread, saved_stack_limit_);
  }

◆ scheduled_dart_mutator_isolate()

Isolate * dart::Thread::scheduled_dart_mutator_isolate ( ) const

inline

Definition at line 557 of file thread.h.

                                                  {
    return scheduled_dart_mutator_isolate_;
  }

◆ ScheduleInterrupts()

void dart::Thread::ScheduleInterrupts ( uword interrupt_bits )

Definition at line 705 of file thread.cc.

                                                    {
  ASSERT((interrupt_bits & ~kInterruptsMask) == 0);  // Must fit in mask.
 
  uword old_limit = stack_limit_.load();
  uword new_limit;
  do {
    if (IsInterruptLimit(old_limit)) {
      new_limit = old_limit | interrupt_bits;
    } else {
      new_limit = (kInterruptStackLimit & ~kInterruptsMask) | interrupt_bits;
    }
  } while (!stack_limit_.compare_exchange_weak(old_limit, new_limit));
}

◆ service_extension_stream_offset()

static intptr_t dart::Thread::service_extension_stream_offset ( )

inlinestatic

Definition at line 571 of file thread.h.

                                                    {
    return OFFSET_OF(Thread, service_extension_stream_);
  }

◆ set_active_exception()

void dart::Thread::set_active_exception ( const Object & value )

Definition at line 222 of file thread.cc.

                                                     {
  active_exception_ = value.ptr();
}

◆ set_active_stacktrace()

void dart::Thread::set_active_stacktrace ( const Object & value )

Definition at line 226 of file thread.cc.

                                                      {
  active_stacktrace_ = value.ptr();
}

◆ set_api_reusable_scope()

void dart::Thread::set_api_reusable_scope ( ApiLocalScope * value )

inline

Definition at line 505 of file thread.h.

                                                    {
    ASSERT(value == nullptr || api_reusable_scope_ == nullptr);
    api_reusable_scope_ = value;
  }

◆ set_api_top_scope()

void dart::Thread::set_api_top_scope ( ApiLocalScope * value )

inline

Definition at line 513 of file thread.h.

513{ api_top_scope_ = value; }

◆ set_compiler_timings()

void dart::Thread::set_compiler_timings ( CompilerTimings * stats )

inline

Definition at line 614 of file thread.h.

                                                    {
    compiler_timings_ = stats;
  }

◆ set_dispatch_table_array()

void dart::Thread::set_dispatch_table_array ( const uword * array )

inline

Definition at line 785 of file thread.h.

                                                    {
    dispatch_table_array_ = array;
  }

◆ set_end()

void dart::Thread::set_end ( uword end )

inline

Definition at line 700 of file thread.h.

700{ end_ = end; }

dart::Thread::end

uword end() const

Definition thread.h:697

◆ set_execution_state()

void dart::Thread::set_execution_state ( ExecutionState state )

inline

Definition at line 1035 of file thread.h.

                                                 {
    execution_state_ = static_cast<uword>(state);
  }

◆ set_global_object_pool()

void dart::Thread::set_global_object_pool ( ObjectPoolPtr raw_value )

inline

Definition at line 780 of file thread.h.

                                                       {
    global_object_pool_ = raw_value;
  }

◆ set_hierarchy_info()

void dart::Thread::set_hierarchy_info ( HierarchyInfo * value )

inline

Definition at line 593 of file thread.h.

                                                {
    ASSERT(isolate_group_ != nullptr);
    ASSERT((hierarchy_info_ == nullptr && value != nullptr) ||
           (hierarchy_info_ != nullptr && value == nullptr));
    hierarchy_info_ = value;
  }

◆ set_resume_pc()

void dart::Thread::set_resume_pc ( uword value )

inline

Definition at line 861 of file thread.h.

861{ resume_pc_ = value; }

◆ set_sticky_error()

void dart::Thread::set_sticky_error ( const Error & value )

Definition at line 234 of file thread.cc.

                                                {
  ASSERT(!value.IsNull());
  sticky_error_ = value.ptr();
}

◆ set_top()

void dart::Thread::set_top ( uword top )

inline

Definition at line 699 of file thread.h.

699{ top_ = top; }

dart::Thread::top

uword top() const

Definition thread.h:696

◆ set_top_exit_frame_info()

void dart::Thread::set_top_exit_frame_info ( uword top_exit_frame_info )

inline

Definition at line 679 of file thread.h.

                                                          {
    top_exit_frame_info_ = top_exit_frame_info;
  }

◆ set_true_end()

void dart::Thread::set_true_end ( uword true_end )

inline

Definition at line 701 of file thread.h.

701{ true_end_ = true_end; }

dart::Thread::true_end

uword true_end() const

Definition thread.h:698

◆ set_type_usage_info()

void dart::Thread::set_type_usage_info ( TypeUsageInfo * value )

inline

Definition at line 605 of file thread.h.

                                                 {
    ASSERT(isolate_group_ != nullptr);
    ASSERT((type_usage_info_ == nullptr && value != nullptr) ||
           (type_usage_info_ != nullptr && value == nullptr));
    type_usage_info_ = value;
  }

◆ set_unboxed_double_runtime_arg()

void dart::Thread::set_unboxed_double_runtime_arg ( double value )

inline

Definition at line 827 of file thread.h.

                                                    {
    unboxed_runtime_arg_.double_storage[0] = value;
  }

◆ set_unboxed_int64_runtime_arg()

void dart::Thread::set_unboxed_int64_runtime_arg ( int64_t value )

inline

Definition at line 815 of file thread.h.

                                                    {
    unboxed_runtime_arg_.int64_storage[0] = value;
  }

◆ set_unboxed_int64_runtime_second_arg()

void dart::Thread::set_unboxed_int64_runtime_second_arg ( int64_t value )

inline

Definition at line 821 of file thread.h.

                                                           {
    unboxed_runtime_arg_.int64_storage[1] = value;
  }

◆ set_unboxed_simd128_runtime_arg()

void dart::Thread::set_unboxed_simd128_runtime_arg ( simd128_value_t value )

inline

Definition at line 833 of file thread.h.

                                                              {
    unboxed_runtime_arg_ = value;
  }

◆ set_vm_tag()

void dart::Thread::set_vm_tag ( uword tag )

inline

Definition at line 809 of file thread.h.

809{ vm_tag_ = tag; }

◆ SetAtSafepoint()

void dart::Thread::SetAtSafepoint	(	bool	value,
		SafepointLevel	level
	)

inline

Definition at line 911 of file thread.h.

                                                        {
    ASSERT(thread_lock()->IsOwnedByCurrentThread());
    ASSERT(level <= current_safepoint_level());
    if (value) {
      safepoint_state_ |= AtSafepointBits(level);
    } else {
      safepoint_state_ &= ~AtSafepointBits(level);
    }
  }

◆ SetBlockedForSafepoint()

void dart::Thread::SetBlockedForSafepoint ( bool value )

inline

Definition at line 989 of file thread.h.

                                          {
    ASSERT(thread_lock()->IsOwnedByCurrentThread());
    safepoint_state_ =
        BlockedForSafepointField::update(value, safepoint_state_);
  }

◆ SetBypassSafepoints()

static uword dart::Thread::SetBypassSafepoints	(	bool	value,
		uword	state
	)

inlinestatic

Definition at line 997 of file thread.h.

                                                            {
    return BypassSafepointsField::update(value, state);
  }

◆ SetSafepointRequested()

uword dart::Thread::SetSafepointRequested	(	SafepointLevel	level,
		bool	value
	)

inline

Definition at line 957 of file thread.h.

                                                                {
    ASSERT(thread_lock()->IsOwnedByCurrentThread());
 
    uword mask = 0;
    switch (level) {
      case SafepointLevel::kGC:
        mask = SafepointRequestedField::mask_in_place();
        break;
      case SafepointLevel::kGCAndDeopt:
        mask = DeoptSafepointRequestedField::mask_in_place();
        break;
      case SafepointLevel::kGCAndDeoptAndReload:
        mask = ReloadSafepointRequestedField::mask_in_place();
        break;
      default:
        UNREACHABLE();
    }
 
    if (value) {
      // acquire pulls from the release in TryEnterSafepoint.
      return safepoint_state_.fetch_or(mask, std::memory_order_acquire);
    } else {
      // release pushes to the acquire in TryExitSafepoint.
      return safepoint_state_.fetch_and(~mask, std::memory_order_release);
    }
  }

◆ SetStackLimit()

void dart::Thread::SetStackLimit ( uword value )

Definition at line 685 of file thread.cc.

                                      {
  // The thread setting the stack limit is not necessarily the thread which
  // the stack limit is being set on.
  MonitorLocker ml(&thread_lock_);
  if (!HasScheduledInterrupts()) {
    // No interrupt pending, set stack_limit_ too.
    stack_limit_.store(limit);
  }
  saved_stack_limit_ = limit;
}

◆ SetUnwindErrorInProgress()

void dart::Thread::SetUnwindErrorInProgress ( bool value )

inline

Definition at line 1003 of file thread.h.

                                            {
    const uword mask = UnwindErrorInProgressField::mask_in_place();
    if (value) {
      safepoint_state_.fetch_or(mask);
    } else {
      safepoint_state_.fetch_and(~mask);
    }
  }

◆ stack_limit_address()

uword dart::Thread::stack_limit_address ( ) const

inline

Definition at line 398 of file thread.h.

                                    {
    return reinterpret_cast<uword>(&stack_limit_);
  }

◆ stack_limit_offset()

static intptr_t dart::Thread::stack_limit_offset ( )

inlinestatic

Definition at line 401 of file thread.h.

                                       {
    return OFFSET_OF(Thread, stack_limit_);
  }

◆ stack_overflow_flags_offset()

static intptr_t dart::Thread::stack_overflow_flags_offset ( )

inlinestatic

Definition at line 442 of file thread.h.

                                                {
    return OFFSET_OF(Thread, stack_overflow_flags_);
  }

◆ stack_overflow_shared_stub_entry_point_offset()

static uword dart::Thread::stack_overflow_shared_stub_entry_point_offset ( bool fpu_regs )

inlinestatic

Definition at line 452 of file thread.h.

                                                                            {
    return fpu_regs
               ? stack_overflow_shared_with_fpu_regs_entry_point_offset()
               : stack_overflow_shared_without_fpu_regs_entry_point_offset();
  }

◆ StartUnwindError()

void dart::Thread::StartUnwindError ( )

inline

Definition at line 640 of file thread.h.

                          {
    is_unwind_in_progress_ = true;
    SetUnwindErrorInProgress(true);
  }

◆ StealStickyError()

ErrorPtr dart::Thread::StealStickyError ( )

Definition at line 243 of file thread.cc.

                                  {
  NoSafepointScope no_safepoint;
  ErrorPtr return_value = sticky_error_;
  sticky_error_ = Error::null();
  return return_value;
}

◆ sticky_error()

ErrorPtr dart::Thread::sticky_error ( ) const

Definition at line 230 of file thread.cc.

                                    {
  return sticky_error_;
}

◆ store_buffer_block_offset()

static intptr_t dart::Thread::store_buffer_block_offset ( )

inlinestatic

Definition at line 665 of file thread.h.

                                              {
    return OFFSET_OF(Thread, store_buffer_block_);
  }

◆ StoreBufferAddObject()

void dart::Thread::StoreBufferAddObject ( ObjectPtr obj )

Definition at line 791 of file thread.cc.

                                               {
  ASSERT(this == Thread::Current());
  store_buffer_block_->Push(obj);
  if (store_buffer_block_->IsFull()) {
    StoreBufferBlockProcess(StoreBuffer::kCheckThreshold);
  }
}

◆ StoreBufferAddObjectGC()

void dart::Thread::StoreBufferAddObjectGC ( ObjectPtr obj )

Definition at line 799 of file thread.cc.

                                                 {
  store_buffer_block_->Push(obj);
  if (store_buffer_block_->IsFull()) {
    StoreBufferBlockProcess(StoreBuffer::kIgnoreThreshold);
  }
}

◆ StoreBufferBlockProcess()

void dart::Thread::StoreBufferBlockProcess ( StoreBuffer::ThresholdPolicy policy )

Definition at line 786 of file thread.cc.

                                                                      {
  StoreBufferRelease(policy);
  StoreBufferAcquire();
}

◆ task_kind()

TaskKind dart::Thread::task_kind ( ) const

inline

Definition at line 478 of file thread.h.

478{ return task_kind_; }

◆ TaskKindToCString()

const char * dart::Thread::TaskKindToCString ( TaskKind kind )

static

Definition at line 250 of file thread.cc.

                                                   {
  switch (kind) {
    case kUnknownTask:
      return "kUnknownTask";
    case kMutatorTask:
      return "kMutatorTask";
    case kCompilerTask:
      return "kCompilerTask";
    case kSweeperTask:
      return "kSweeperTask";
    case kMarkerTask:
      return "kMarkerTask";
    default:
      UNREACHABLE();
      return "";
  }
}

◆ thread_lock()

Monitor * dart::Thread::thread_lock ( ) const

inline

Definition at line 501 of file thread.h.

501{ return &thread_lock_; }

◆ top()

uword dart::Thread::top ( ) const

inline

Definition at line 696 of file thread.h.

696{ return top_; }

◆ top_exit_frame_info()

uword dart::Thread::top_exit_frame_info ( ) const

inline

Definition at line 678 of file thread.h.

678{ return top_exit_frame_info_; }

◆ top_exit_frame_info_offset()

static intptr_t dart::Thread::top_exit_frame_info_offset ( )

inlinestatic

Definition at line 682 of file thread.h.

                                               {
    return OFFSET_OF(Thread, top_exit_frame_info_);
  }

◆ top_offset()

static intptr_t dart::Thread::top_offset ( )

inlinestatic

Definition at line 702 of file thread.h.

702{ return OFFSET_OF(Thread, top_); }

◆ true_end()

uword dart::Thread::true_end ( ) const

inline

Definition at line 698 of file thread.h.

698{ return true_end_; }

◆ TryEnterSafepoint()

bool dart::Thread::TryEnterSafepoint ( )

inline

Definition at line 1056 of file thread.h.

                           {
    uword old_state = 0;
    uword new_state = AtSafepointBits(current_safepoint_level());
    return safepoint_state_.compare_exchange_strong(old_state, new_state,
                                                    std::memory_order_release);
  }

◆ TryExitSafepoint()

bool dart::Thread::TryExitSafepoint ( )

inline

Definition at line 1074 of file thread.h.

                          {
    uword old_state = AtSafepointBits(current_safepoint_level());
    uword new_state = 0;
    return safepoint_state_.compare_exchange_strong(old_state, new_state,
                                                    std::memory_order_acquire);
  }

◆ tsan_utils_offset()

static intptr_t dart::Thread::tsan_utils_offset ( )

inlinestatic

Definition at line 525 of file thread.h.

525{ return OFFSET_OF(Thread, tsan_utils_); }

◆ type_usage_info()

TypeUsageInfo * dart::Thread::type_usage_info ( ) const

inline

Definition at line 600 of file thread.h.

                                         {
    ASSERT(isolate_group_ != nullptr);
    return type_usage_info_;
  }

◆ unboxed_double_runtime_arg()

double dart::Thread::unboxed_double_runtime_arg ( ) const

inline

Definition at line 824 of file thread.h.

                                            {
    return unboxed_runtime_arg_.double_storage[0];
  }

◆ unboxed_int64_runtime_arg()

int64_t dart::Thread::unboxed_int64_runtime_arg ( ) const

inline

Definition at line 812 of file thread.h.

                                            {
    return unboxed_runtime_arg_.int64_storage[0];
  }

◆ unboxed_int64_runtime_second_arg()

int64_t dart::Thread::unboxed_int64_runtime_second_arg ( ) const

inline

Definition at line 818 of file thread.h.

                                                   {
    return unboxed_runtime_arg_.int64_storage[1];
  }

◆ unboxed_runtime_arg_offset()

static intptr_t dart::Thread::unboxed_runtime_arg_offset ( )

inlinestatic

Definition at line 836 of file thread.h.

                                               {
    return OFFSET_OF(Thread, unboxed_runtime_arg_);
  }

◆ unboxed_simd128_runtime_arg()

simd128_value_t dart::Thread::unboxed_simd128_runtime_arg ( ) const

inline

Definition at line 830 of file thread.h.

                                                      {
    return unboxed_runtime_arg_;
  }

◆ UnwindErrorInProgress()

bool dart::Thread::UnwindErrorInProgress ( ) const

inline

Definition at line 1000 of file thread.h.

                                     {
    return UnwindErrorInProgressField::decode(safepoint_state_);
  }

◆ UnwindScopes()

void dart::Thread::UnwindScopes ( uword stack_marker )

Definition at line 1262 of file thread.cc.

                                            {
  // Unwind all scopes using the same stack_marker, i.e. all scopes allocated
  // under the same top_exit_frame_info.
  ApiLocalScope* scope = api_top_scope_;
  while (scope != nullptr && scope->stack_marker() != 0 &&
         scope->stack_marker() == stack_marker) {
    api_top_scope_ = scope->previous();
    delete scope;
    scope = api_top_scope_;
  }
}

◆ VisitObjectPointers()

void dart::Thread::VisitObjectPointers	(	ObjectPointerVisitor *	visitor,
		ValidationPolicy	validate_frames
	)

Definition at line 901 of file thread.cc.

                                                                     {
  ASSERT(visitor != nullptr);
 
  if (zone() != nullptr) {
    zone()->VisitObjectPointers(visitor);
  }
 
  // Visit objects in thread specific handles area.
  reusable_handles_.VisitObjectPointers(visitor);
 
  visitor->VisitPointer(reinterpret_cast<ObjectPtr*>(&global_object_pool_));
  visitor->VisitPointer(reinterpret_cast<ObjectPtr*>(&active_exception_));
  visitor->VisitPointer(reinterpret_cast<ObjectPtr*>(&active_stacktrace_));
  visitor->VisitPointer(reinterpret_cast<ObjectPtr*>(&sticky_error_));
 
  // Visit the api local scope as it has all the api local handles.
  ApiLocalScope* scope = api_top_scope_;
  while (scope != nullptr) {
    scope->local_handles()->VisitObjectPointers(visitor);
    scope = scope->previous();
  }
 
  // Only the mutator thread can run Dart code.
  if (IsDartMutatorThread()) {
    // The MarkTask, which calls this method, can run on a different thread.  We
    // therefore assume the mutator is at a safepoint and we can iterate its
    // stack.
    // TODO(vm-team): It would be beneficial to be able to ask the mutator
    // thread whether it is in fact blocked at the moment (at a "safepoint") so
    // we can safely iterate its stack.
    //
    // Unfortunately we cannot use `this->IsAtSafepoint()` here because that
    // will return `false` even though the mutator thread is waiting for mark
    // tasks (which iterate its stack) to finish.
    const StackFrameIterator::CrossThreadPolicy cross_thread_policy =
        StackFrameIterator::kAllowCrossThreadIteration;
 
    // Iterate over all the stack frames and visit objects on the stack.
    StackFrameIterator frames_iterator(top_exit_frame_info(), validation_policy,
                                       this, cross_thread_policy);
    StackFrame* frame = frames_iterator.NextFrame();
    visitor->set_gc_root_type("frame");
    while (frame != nullptr) {
      frame->VisitObjectPointers(visitor);
      frame = frames_iterator.NextFrame();
    }
    visitor->clear_gc_root_type();
  } else {
    // We are not on the mutator thread.
    RELEASE_ASSERT(top_exit_frame_info() == 0);
  }
}

◆ vm_tag()

uword dart::Thread::vm_tag ( ) const

inline

Definition at line 808 of file thread.h.

808{ return vm_tag_; }

◆ vm_tag_offset()

static intptr_t dart::Thread::vm_tag_offset ( )

inlinestatic

Definition at line 810 of file thread.h.

810{ return OFFSET_OF(Thread, vm_tag_); }

◆ write_barrier_mask()

uword dart::Thread::write_barrier_mask ( ) const

inline

Definition at line 427 of file thread.h.

427{ return write_barrier_mask_; }

◆ write_barrier_mask_offset()

static intptr_t dart::Thread::write_barrier_mask_offset ( )

inlinestatic

Definition at line 436 of file thread.h.

                                              {
    return OFFSET_OF(Thread, write_barrier_mask_);
  }

◆ write_barrier_wrappers_thread_offset()

static intptr_t dart::Thread::write_barrier_wrappers_thread_offset ( Register reg )

inlinestatic

Definition at line 740 of file thread.h.

                                                                     {
    ASSERT((kDartAvailableCpuRegs & (1 << reg)) != 0);
    intptr_t index = 0;
    for (intptr_t i = 0; i < kNumberOfCpuRegisters; ++i) {
      if ((kDartAvailableCpuRegs & (1 << i)) == 0) continue;
      if (i == reg) break;
      ++index;
    }
    return OFFSET_OF(Thread, write_barrier_wrappers_entry_points_) +
           index * sizeof(uword);
  }

◆ WriteBarrierWrappersOffsetForRegister()

static intptr_t dart::Thread::WriteBarrierWrappersOffsetForRegister ( Register reg )

inlinestatic

Definition at line 752 of file thread.h.

                                                                      {
    intptr_t index = 0;
    for (intptr_t i = 0; i < kNumberOfCpuRegisters; ++i) {
      if ((kDartAvailableCpuRegs & (1 << i)) == 0) continue;
      if (i == reg) {
        return index * kStoreBufferWrapperSize;
      }
      ++index;
    }
    UNREACHABLE();
    return 0;
  }

◆ ZoneSizeInBytes()

int dart::Thread::ZoneSizeInBytes ( ) const

Definition at line 1225 of file thread.cc.

                                  {
  int total = 0;
  ApiLocalScope* scope = api_top_scope_;
  while (scope != nullptr) {
    total += scope->zone()->SizeInBytes();
    scope = scope->previous();
  }
  return total;
}

Friends And Related Symbol Documentation

◆ ActiveIsolateScope

friend class ActiveIsolateScope

friend

Definition at line 1452 of file thread.h.

◆ ApiZone

friend class ApiZone

friend

Definition at line 1451 of file thread.h.

◆ compiler::target::Thread

friend class compiler::target::Thread

friend

Definition at line 1464 of file thread.h.

◆ CompilerState

friend class CompilerState

friend

Definition at line 1463 of file thread.h.

◆ CreateWithinExistingIsolateGroup

Isolate * CreateWithinExistingIsolateGroup	(	IsolateGroup *	,
		const char *	,
		char **
	)

friend

Definition at line 1302 of file dart_api_impl.cc.

                                                        {
  API_TIMELINE_DURATION(Thread::Current());
  CHECK_NO_ISOLATE(Isolate::Current());
 
  auto spawning_group = group;
 
  Isolate* isolate = reinterpret_cast<Isolate*>(
      CreateIsolate(spawning_group, /*is_new_group=*/false, name,
                    /*isolate_data=*/nullptr, error));
  if (isolate == nullptr) return nullptr;
 
  auto source = spawning_group->source();
  ASSERT(isolate->source() == source);
 
  return isolate;
}

◆ Dart

friend class Dart

friend

Definition at line 1467 of file thread.h.

◆ FieldTable

friend class FieldTable

friend

Definition at line 1465 of file thread.h.

◆ InterruptChecker

friend class InterruptChecker

friend

Definition at line 1453 of file thread.h.

◆ Isolate

friend class Isolate

friend

Definition at line 1454 of file thread.h.

◆ IsolateGroup

friend class IsolateGroup

friend

Definition at line 1455 of file thread.h.

◆ MonitorLocker

friend class MonitorLocker

friend

Definition at line 1472 of file thread.h.

◆ NoActiveIsolateScope

friend class NoActiveIsolateScope

friend

Definition at line 1456 of file thread.h.

◆ NoReloadScope

friend class NoReloadScope

friend

Definition at line 1457 of file thread.h.

◆ RawReloadParticipationScope

friend class RawReloadParticipationScope

friend

Definition at line 1458 of file thread.h.

◆ RestoreWriteBarrierInvariantVisitor

friend class RestoreWriteBarrierInvariantVisitor

friend

Definition at line 1152 of file thread.h.

◆ RuntimeCallDeoptScope

friend class RuntimeCallDeoptScope

friend

Definition at line 1466 of file thread.h.

◆ Simulator

friend class Simulator

friend

Definition at line 1459 of file thread.h.

◆ StackZone

friend class StackZone

friend

Definition at line 1460 of file thread.h.

◆ StoppedMutatorsScope

friend class StoppedMutatorsScope

friend

Definition at line 1461 of file thread.h.

◆ ThreadRegistry

friend class ThreadRegistry

friend

Definition at line 1462 of file thread.h.

◆ TransitionGeneratedToVM

friend class TransitionGeneratedToVM

friend

Definition at line 1469 of file thread.h.

◆ TransitionVMToGenerated

friend class TransitionVMToGenerated

friend

Definition at line 1471 of file thread.h.

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

third_party/dart-lang/sdk/runtime/vm/thread.h
third_party/dart-lang/sdk/runtime/vm/thread.cc

Public Types

Public Member Functions

Static Public Member Functions

Friends

Detailed Description

Member Enumeration Documentation

◆ anonymous enum

◆ anonymous enum

◆ anonymous enum

◆ ExecutionState

◆ TaskKind

Constructor & Destructor Documentation

◆ ~Thread()

Member Function Documentation

◆ AcquireMarkingStack()

◆ active_exception()

◆ active_exception_offset()

◆ active_stacktrace()

◆ active_stacktrace_offset()

◆ AllocateReusableHandle()

◆ api_reusable_scope()

◆ api_top_scope()

◆ api_top_scope_offset()

◆ AssertEmptyStackInvariants()

◆ AssertEmptyThreadInvariants()

◆ AssertNonDartMutatorInvariants()

◆ AssertNonMutatorInvariants()

◆ BlockForSafepoint()

◆ BypassSafepoints()

◆ CanAcquireSafepointLocks()

◆ CanLoadFromThread()

◆ CheckForSafepoint()

◆ ClearReusableHandles()

◆ ClearStackLimit()

◆ ClearStickyError()

◆ compiler_state()

◆ compiler_timings()

◆ CountLocalHandles()

◆ Current()

◆ current_safepoint_level()

◆ dart_stream_offset()

◆ DecrementForceGrowthScopeDepth()

◆ DecrementNoCallbackScopeDepth()

◆ DecrementNoSafepointScopeDepth()

◆ DeferredMarkingStackAddObject()

◆ DeferredMarkingStackBlockProcess()

◆ DeferredMarkLiveTemporaries()

◆ dispatch_table_array()

◆ dispatch_table_array_offset()

◆ double_truncate_round_supported_offset()

◆ end()

◆ end_offset()

◆ EnterApiScope()

◆ EnterIsolate()

◆ EnterIsolateGroupAsHelper()

◆ EnterIsolateGroupAsNonMutator()

◆ EnterSafepoint()

◆ execution_state()

◆ execution_state_cross_thread_for_testing()

◆ execution_state_offset()

◆ exit_through_ffi_offset()

◆ ExitApiScope()

◆ ExitIsolate()

◆ ExitIsolateGroupAsHelper()

◆ ExitIsolateGroupAsNonMutator()

◆ ExitSafepoint()

◆ field_table_values_offset()

◆ force_growth()

◆ full_safepoint_state_acquired()

◆ full_safepoint_state_unacquired()

◆ GetAndClearInterrupts()

◆ GetAndClearStackOverflowFlags()

◆ GetNextTaskId()

◆ global_object_pool()

◆ global_object_pool_offset()

◆ HandleInterrupts()

◆ HasActiveState()

◆ HasCompilerState()

◆ HasExitedDartCode()

◆ HasScheduledInterrupts()