#include <thread.h>

Inheritance diagram for dart::Thread:

Public Types
enum	TaskKind { kUnknownTask = 0 , kMutatorTask , kCompilerTask , kMarkerTask , kSweeperTask , kCompactorTask , kScavengerTask , kSampleBlockTask , kIncrementalCompactorTask }

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)

void	StoreBufferReleaseGC ()

void	StoreBufferAcquireGC ()

bool	is_marking () const

void	MarkingStackAddObject (ObjectPtr obj)

void	OldMarkingStackAddObject (ObjectPtr obj)

void	NewMarkingStackAddObject (ObjectPtr obj)

void	DeferredMarkingStackAddObject (ObjectPtr obj)

void	OldMarkingStackBlockProcess ()

void	NewMarkingStackBlockProcess ()

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

virtual bool	MayAllocateHandles ()=0

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	shared_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	old_marking_stack_block_offset ()

static intptr_t	new_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 424 of file thread.h.

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

◆ anonymous enum

anonymous enum

Enumerator
kDidNotExit
kExitThroughFfi
kExitThroughRuntimeCall

Definition at line 464 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 487 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 1033 of file thread.h.

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

◆ TaskKind

enum dart::Thread::TaskKind

Enumerator
kUnknownTask
kMutatorTask
kCompilerTask
kMarkerTask
kSweeperTask
kCompactorTask
kScavengerTask
kSampleBlockTask
kIncrementalCompactorTask

Definition at line 345 of file thread.h.

                {
    kUnknownTask = 0,
    kMutatorTask,
    kCompilerTask,
    kMarkerTask,
    kSweeperTask,
    kCompactorTask,
    kScavengerTask,
    kSampleBlockTask,
    kIncrementalCompactorTask,
  };

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(old_marking_stack_block_ == nullptr);
  ASSERT(new_marking_stack_block_ == nullptr);
  ASSERT(deferred_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 861 of file thread.h.

861{ return active_exception_; }

◆ active_exception_offset()

static intptr_t dart::Thread::active_exception_offset ( )

inlinestatic

Definition at line 863 of file thread.h.

                                            {
    return OFFSET_OF(Thread, active_exception_);
  }

◆ active_stacktrace()

ObjectPtr dart::Thread::active_stacktrace ( ) const

inline

Definition at line 867 of file thread.h.

867{ return active_stacktrace_; }

◆ active_stacktrace_offset()

static intptr_t dart::Thread::active_stacktrace_offset ( )

inlinestatic

Definition at line 869 of file thread.h.

                                             {
    return OFFSET_OF(Thread, active_stacktrace_);
  }

◆ AllocateReusableHandle()

template<class C >

C * dart::Thread::AllocateReusableHandle ( )

Definition at line 956 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 505 of file thread.h.

505{ return api_reusable_scope_; }

◆ api_top_scope()

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

inline

Definition at line 513 of file thread.h.

513{ return api_top_scope_; }

◆ api_top_scope_offset()

static intptr_t dart::Thread::api_top_scope_offset ( )

inlinestatic

Definition at line 515 of file thread.h.

                                         {
    return OFFSET_OF(Thread, api_top_scope_);
  }

◆ AssertEmptyStackInvariants()

void dart::Thread::AssertEmptyStackInvariants ( )

Definition at line 287 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 318 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(old_marking_stack_block_ == nullptr);
  ASSERT(new_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(shared_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 279 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 270 of file thread.cc.

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

◆ BlockForSafepoint()

void dart::Thread::BlockForSafepoint ( )

Definition at line 1348 of file thread.cc.

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

◆ BypassSafepoints()

bool dart::Thread::BypassSafepoints ( ) const

inline

Definition at line 1007 of file thread.h.

                                {
    return BypassSafepointsField::decode(safepoint_state_);
  }

◆ CanAcquireSafepointLocks()

bool dart::Thread::CanAcquireSafepointLocks ( ) const

Definition at line 1372 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 1154 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 1104 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 962 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 701 of file thread.cc.

                             {
  SetStackLimit(OSThread::kInvalidStackLimit);
}

◆ ClearStickyError()

void dart::Thread::ClearStickyError ( )

Definition at line 241 of file thread.cc.

                              {
  sticky_error_ = Error::null();
}

◆ compiler_state()

CompilerState & dart::Thread::compiler_state ( )

inline

Definition at line 588 of file thread.h.

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

◆ compiler_timings()

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

inline

Definition at line 617 of file thread.h.

617{ return compiler_timings_; }

◆ CountLocalHandles()

intptr_t dart::Thread::CountLocalHandles ( ) const

Definition at line 1281 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 362 of file thread.h.

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

◆ current_safepoint_level()

SafepointLevel dart::Thread::current_safepoint_level ( ) const

inline

Definition at line 1146 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 571 of file thread.h.

                                       {
    return OFFSET_OF(Thread, dart_stream_);
  }

◆ DecrementForceGrowthScopeDepth()

void dart::Thread::DecrementForceGrowthScopeDepth ( )

inline

Definition at line 638 of file thread.h.

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

◆ DecrementNoCallbackScopeDepth()

void dart::Thread::DecrementNoCallbackScopeDepth ( )

inline

Definition at line 628 of file thread.h.

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

◆ DecrementNoSafepointScopeDepth()

void dart::Thread::DecrementNoSafepointScopeDepth ( )

inline

Definition at line 733 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 871 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 842 of file thread.cc.

                                              {
  DeferredMarkingStackRelease();
  DeferredMarkingStackAcquire();
}

◆ DeferredMarkLiveTemporaries()

void dart::Thread::DeferredMarkLiveTemporaries ( )

Definition at line 1144 of file thread.cc.

                                         {
  RestoreWriteBarrierInvariant(
      RestoreWriteBarrierInvariantOp::kAddToDeferredMarkingStack);
}

◆ dispatch_table_array()

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

inline

Definition at line 797 of file thread.h.

797{ return dispatch_table_array_; }

◆ dispatch_table_array_offset()

static intptr_t dart::Thread::dispatch_table_array_offset ( )

inlinestatic

Definition at line 857 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 522 of file thread.h.

                                                           {
    return OFFSET_OF(Thread, double_truncate_round_supported_);
  }

◆ end()

uword dart::Thread::end ( ) const

inline

Definition at line 710 of file thread.h.

710{ return end_; }

◆ end_offset()

static intptr_t dart::Thread::end_offset ( )

inlinestatic

Definition at line 716 of file thread.h.

716{ return OFFSET_OF(Thread, end_); }

◆ EnterApiScope()

void dart::Thread::EnterApiScope ( )

Definition at line 1301 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 371 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 481 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 511 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 1076 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 1040 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 1045 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 1051 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 475 of file thread.h.

                                            {
    return OFFSET_OF(Thread, exit_through_ffi_);
  }

◆ ExitApiScope()

void dart::Thread::ExitApiScope ( )

Definition at line 1314 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 428 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 499 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 526 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 1094 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 543 of file thread.h.

                                              {
    return OFFSET_OF(Thread, field_table_values_);
  }

◆ force_growth()

bool dart::Thread::force_growth ( ) const

inline

Definition at line 633 of file thread.h.

633{ return force_growth_scope_depth_ != 0; }

◆ full_safepoint_state_acquired()

static uword dart::Thread::full_safepoint_state_acquired ( )

inlinestatic

Definition at line 1064 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 1060 of file thread.h.

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

◆ GetAndClearInterrupts()

uword dart::Thread::GetAndClearInterrupts ( )

Definition at line 724 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 785 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 1129 of file thread.h.

1129{ return next_task_id_++; }

◆ global_object_pool()

ObjectPoolPtr dart::Thread::global_object_pool ( ) const

inline

Definition at line 792 of file thread.h.

792{ return global_object_pool_; }

◆ global_object_pool_offset()

static intptr_t dart::Thread::global_object_pool_offset ( )

inlinestatic

Definition at line 853 of file thread.h.

                                              {
    return OFFSET_OF(Thread, global_object_pool_);
  }

◆ HandleInterrupts()

ErrorPtr dart::Thread::HandleInterrupts ( )

Definition at line 739 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 354 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 586 of file thread.h.

586{ return compiler_state_ != nullptr; }

◆ HasExitedDartCode()

bool dart::Thread::HasExitedDartCode ( ) const

Definition at line 951 of file thread.cc.

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

◆ HasScheduledInterrupts()

bool dart::Thread::HasScheduledInterrupts ( ) const

inline

Definition at line 497 of file thread.h.

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

◆ heap()

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

Definition at line 943 of file thread.cc.

                         {
  return isolate_group_->heap();
}

◆ heap_base()

uword dart::Thread::heap_base ( ) const

inline

Definition at line 429 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 1141 of file thread.h.

1141{ return heap_sampler_; }

◆ hierarchy_info()

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

inline

Definition at line 593 of file thread.h.

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

◆ IncrementAndGetRuntimeCallCount()

uint32_t dart::Thread::IncrementAndGetRuntimeCallCount ( )

inline

Definition at line 451 of file thread.h.

451{ return ++runtime_call_count_; }

◆ IncrementAndGetStackOverflowCount()

int32_t dart::Thread::IncrementAndGetStackOverflowCount ( )

inline

Definition at line 447 of file thread.h.

                                              {
    return ++stack_overflow_count_;
  }

◆ IncrementForceGrowthScopeDepth()

void dart::Thread::IncrementForceGrowthScopeDepth ( )

inline

Definition at line 634 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 624 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 726 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 183 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 676 of file thread.h.

676{ return old_marking_stack_block_ != nullptr; }

◆ is_unwind_in_progress()

bool dart::Thread::is_unwind_in_progress ( ) const

inline

Definition at line 643 of file thread.h.

643{ return is_unwind_in_progress_; }

◆ IsAtSafepoint() [1/3]

bool dart::Thread::IsAtSafepoint ( ) const

inline

Definition at line 917 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 921 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 911 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 999 of file thread.h.

                                     {
    return BlockedForSafepointField::decode(safepoint_state_);
  }

◆ IsBlockedForSafepoint() [2/2]

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

inlinestatic

Definition at line 996 of file thread.h.

                                                 {
    return BlockedForSafepointField::decode(state);
  }

◆ IsDartMutatorThread()

bool dart::Thread::IsDartMutatorThread ( ) const

inline

Definition at line 551 of file thread.h.

                                   {
    return scheduled_dart_mutator_isolate_ != nullptr;
  }

◆ IsExecutingDartCode()

bool dart::Thread::IsExecutingDartCode ( ) const

Definition at line 947 of file thread.cc.

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

◆ IsInNoReloadScope()

bool dart::Thread::IsInNoReloadScope ( ) const

inline

Definition at line 740 of file thread.h.

740{ return no_reload_scope_depth_ > 0; }

◆ IsInStoppedMutatorsScope()

bool dart::Thread::IsInStoppedMutatorsScope ( ) const

inline

Definition at line 742 of file thread.h.

                                        {
    return stopped_mutators_scope_depth_ > 0;
  }

◆ isolate()

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

inline

Definition at line 534 of file thread.h.

534{ return isolate_; }

◆ isolate_group()

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

inline

Definition at line 541 of file thread.h.

541{ return isolate_group_; }

◆ isolate_group_offset()

static intptr_t dart::Thread::isolate_group_offset ( )

inlinestatic

Definition at line 536 of file thread.h.

                                         {
    return OFFSET_OF(Thread, isolate_group_);
  }

◆ isolate_offset()

static intptr_t dart::Thread::isolate_offset ( )

inlinestatic

Definition at line 535 of file thread.h.

535{ return OFFSET_OF(Thread, isolate_); }

◆ IsSafepointLevelRequested()

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

inlinestatic

Definition at line 955 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 948 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 937 of file thread.h.

                                    {
    return IsSafepointRequested(current_safepoint_level());
  }

◆ IsSafepointRequested() [2/2]

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

inline

Definition at line 940 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 933 of file thread.h.

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

◆ IsValidHandle()

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

Definition at line 1265 of file thread.cc.

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

◆ IsValidLocalHandle()

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

Definition at line 1270 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;
}

◆ MarkingStackAddObject()

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

Definition at line 847 of file thread.cc.

                                                {
  if (obj->IsNewObject()) {
    NewMarkingStackAddObject(obj);
  } else {
    OldMarkingStackAddObject(obj);
  }
}

◆ MayAllocateHandles()

virtual bool dart::Thread::MayAllocateHandles ( )

inlinevirtual

Implements dart::ThreadState.

Definition at line 1055 of file thread.h.

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

◆ new_marking_stack_block_offset()

static intptr_t dart::Thread::new_marking_stack_block_offset ( )

inlinestatic

Definition at line 687 of file thread.h.

                                                   {
    return OFFSET_OF(Thread, new_marking_stack_block_);
  }

◆ NewMarkingStackAddObject()

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

Definition at line 863 of file thread.cc.

                                                   {
  ASSERT(obj->IsNewObject());
  new_marking_stack_block_->Push(obj);
  if (new_marking_stack_block_->IsFull()) {
    NewMarkingStackBlockProcess();
  }
}

◆ NewMarkingStackBlockProcess()

void dart::Thread::NewMarkingStackBlockProcess ( )

Definition at line 837 of file thread.cc.

                                         {
  NewMarkingStackRelease();
  NewMarkingStackAcquire();
}

◆ next()

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

inline

Definition at line 1113 of file thread.h.

1113{ return next_; }

◆ next_task_id_offset()

static intptr_t dart::Thread::next_task_id_offset ( )

inlinestatic

Definition at line 1130 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 623 of file thread.h.

623{ return no_callback_scope_depth_; }

◆ no_safepoint_scope_depth()

int32_t dart::Thread::no_safepoint_scope_depth ( ) const

inline

Definition at line 718 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 1205 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 1178 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 1222 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;
}

◆ old_marking_stack_block_offset()

static intptr_t dart::Thread::old_marking_stack_block_offset ( )

inlinestatic

Definition at line 684 of file thread.h.

                                                   {
    return OFFSET_OF(Thread, old_marking_stack_block_);
  }

◆ OldMarkingStackAddObject()

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

Definition at line 855 of file thread.cc.

                                                   {
  ASSERT(obj->IsOldObject());
  old_marking_stack_block_->Push(obj);
  if (old_marking_stack_block_->IsFull()) {
    OldMarkingStackBlockProcess();
  }
}

◆ OldMarkingStackBlockProcess()

void dart::Thread::OldMarkingStackBlockProcess ( )

Definition at line 832 of file thread.cc.

                                         {
  OldMarkingStackRelease();
  OldMarkingStackAcquire();
}

◆ OwnsDeoptSafepoint()

bool dart::Thread::OwnsDeoptSafepoint ( ) const

Definition at line 1357 of file thread.cc.

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

◆ OwnsGCSafepoint()

bool dart::Thread::OwnsGCSafepoint ( ) const

Definition at line 1352 of file thread.cc.

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

◆ OwnsReloadSafepoint()

bool dart::Thread::OwnsReloadSafepoint ( ) const

Definition at line 1362 of file thread.cc.

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

◆ OwnsSafepoint()

bool dart::Thread::OwnsSafepoint ( ) const

Definition at line 1367 of file thread.cc.

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

◆ pending_deopts()

PendingDeopts & dart::Thread::pending_deopts ( )

inline

Definition at line 1144 of file thread.h.

1144{ return pending_deopts_; }

◆ PrintJSON()

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

◆ random()

Random * dart::Thread::random ( )

inline

Definition at line 1133 of file thread.h.

1133{ return &thread_random_; }

◆ random_offset()

static intptr_t dart::Thread::random_offset ( )

inlinestatic

Definition at line 1134 of file thread.h.

1134{ return OFFSET_OF(Thread, thread_random_); }

◆ ReleaseMarkingStack()

void dart::Thread::ReleaseMarkingStack ( )

◆ ReleaseStoreBuffer()

void dart::Thread::ReleaseStoreBuffer ( )

Definition at line 677 of file thread.cc.

                                {
  ASSERT(IsAtSafepoint() || OwnsSafepoint() || task_kind_ == kMarkerTask);
  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 1149 of file thread.cc.

                                     {
  RestoreWriteBarrierInvariant(
      RestoreWriteBarrierInvariantOp::kAddToRememberedSet);
}

◆ resume_pc()

uword dart::Thread::resume_pc ( ) const

inline

Definition at line 873 of file thread.h.

873{ return resume_pc_; }

◆ resume_pc_offset()

static uword dart::Thread::resume_pc_offset ( )

inlinestatic

Definition at line 875 of file thread.h.

875{ return OFFSET_OF(Thread, resume_pc_); }

◆ safepoint_state()

uword dart::Thread::safepoint_state ( )

inline

Definition at line 1031 of file thread.h.

1031{ return safepoint_state_; }

◆ safepoint_state_offset()

static intptr_t dart::Thread::safepoint_state_offset ( )

inlinestatic

Definition at line 459 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 418 of file thread.h.

418{ return saved_shadow_call_stack_; }

◆ saved_shadow_call_stack_offset()

static uword dart::Thread::saved_shadow_call_stack_offset ( )

inlinestatic

Definition at line 419 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 410 of file thread.h.

410{ return saved_stack_limit_; }

◆ saved_stack_limit_offset()

static intptr_t dart::Thread::saved_stack_limit_offset ( )

inlinestatic

Definition at line 407 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 562 of file thread.h.

                                                  {
    return scheduled_dart_mutator_isolate_;
  }

◆ ScheduleInterrupts()

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

Definition at line 710 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 576 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 224 of file thread.cc.

                                                     {
  active_exception_ = value.ptr();
}

◆ set_active_stacktrace()

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

Definition at line 228 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 506 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 514 of file thread.h.

514{ api_top_scope_ = value; }

◆ set_compiler_timings()

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

inline

Definition at line 619 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 798 of file thread.h.

                                                    {
    dispatch_table_array_ = array;
  }

◆ set_end()

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

inline

Definition at line 713 of file thread.h.

713{ end_ = end; }

dart::Thread::end

uword end() const

Definition: thread.h:710

◆ set_execution_state()

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

inline

Definition at line 1048 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 793 of file thread.h.

                                                       {
    global_object_pool_ = raw_value;
  }

◆ set_hierarchy_info()

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

inline

Definition at line 598 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 874 of file thread.h.

874{ resume_pc_ = value; }

◆ set_sticky_error()

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

Definition at line 236 of file thread.cc.

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

◆ set_top()

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

inline

Definition at line 712 of file thread.h.

712{ top_ = top; }

dart::Thread::top

uword top() const

Definition: thread.h:709

◆ set_top_exit_frame_info()

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

inline

Definition at line 692 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 714 of file thread.h.

714{ true_end_ = true_end; }

dart::Thread::true_end

uword true_end() const

Definition: thread.h:711

◆ set_type_usage_info()

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

inline

Definition at line 610 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 840 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 828 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 834 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 846 of file thread.h.

                                                              {
    unboxed_runtime_arg_ = value;
  }

◆ set_vm_tag()

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

inline

Definition at line 822 of file thread.h.

822{ vm_tag_ = tag; }

◆ SetAtSafepoint()

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

inline

Definition at line 924 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 1002 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 1010 of file thread.h.

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

◆ SetSafepointRequested()

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

inline

Definition at line 970 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 690 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 1016 of file thread.h.

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

◆ shared_field_table_values_offset()

static intptr_t dart::Thread::shared_field_table_values_offset ( )

inlinestatic

Definition at line 547 of file thread.h.

                                                     {
    return OFFSET_OF(Thread, shared_field_table_values_);
  }

◆ stack_limit_address()

uword dart::Thread::stack_limit_address ( ) const

inline

Definition at line 399 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 402 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 443 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 453 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 645 of file thread.h.

                          {
    is_unwind_in_progress_ = true;
    SetUnwindErrorInProgress(true);
  }

◆ StealStickyError()

ErrorPtr dart::Thread::StealStickyError ( )

Definition at line 245 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 232 of file thread.cc.

                                    {
  return sticky_error_;
}

◆ store_buffer_block_offset()

static intptr_t dart::Thread::store_buffer_block_offset ( )

inlinestatic

Definition at line 672 of file thread.h.

                                              {
    return OFFSET_OF(Thread, store_buffer_block_);
  }

◆ StoreBufferAcquireGC()

void dart::Thread::StoreBufferAcquireGC ( )

Definition at line 828 of file thread.cc.

                                  {
  store_buffer_block_ = isolate_group()->store_buffer()->PopNonFullBlock();
}

◆ StoreBufferAddObject()

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

Definition at line 796 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 804 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 791 of file thread.cc.

                                                                      {
  StoreBufferRelease(policy);
  StoreBufferAcquire();
}

◆ StoreBufferReleaseGC()

void dart::Thread::StoreBufferReleaseGC ( )

Definition at line 821 of file thread.cc.

                                  {
  StoreBufferBlock* block = store_buffer_block_;
  store_buffer_block_ = nullptr;
  isolate_group()->store_buffer()->PushBlock(block,
                                             StoreBuffer::kIgnoreThreshold);
}

◆ task_kind()

TaskKind dart::Thread::task_kind ( ) const

inline

Definition at line 479 of file thread.h.

479{ return task_kind_; }

◆ TaskKindToCString()

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

static

Definition at line 252 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 502 of file thread.h.

502{ return &thread_lock_; }

◆ top()

uword dart::Thread::top ( ) const

inline

Definition at line 709 of file thread.h.

709{ return top_; }

◆ top_exit_frame_info()

uword dart::Thread::top_exit_frame_info ( ) const

inline

Definition at line 691 of file thread.h.

691{ return top_exit_frame_info_; }

◆ top_exit_frame_info_offset()

static intptr_t dart::Thread::top_exit_frame_info_offset ( )

inlinestatic

Definition at line 695 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 715 of file thread.h.

715{ return OFFSET_OF(Thread, top_); }

◆ true_end()

uword dart::Thread::true_end ( ) const

inline

Definition at line 711 of file thread.h.

711{ return true_end_; }

◆ TryEnterSafepoint()

bool dart::Thread::TryEnterSafepoint ( )

inline

Definition at line 1069 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 1087 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 526 of file thread.h.

526{ return OFFSET_OF(Thread, tsan_utils_); }

◆ type_usage_info()

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

inline

Definition at line 605 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 837 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 825 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 831 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 849 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 843 of file thread.h.

                                                      {
    return unboxed_runtime_arg_;
  }

◆ UnwindErrorInProgress()

bool dart::Thread::UnwindErrorInProgress ( ) const

inline

Definition at line 1013 of file thread.h.

                                     {
    return UnwindErrorInProgressField::decode(safepoint_state_);
  }

◆ UnwindScopes()

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

Definition at line 1328 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 968 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 821 of file thread.h.

821{ return vm_tag_; }

◆ vm_tag_offset()

static intptr_t dart::Thread::vm_tag_offset ( )

inlinestatic

Definition at line 823 of file thread.h.

823{ return OFFSET_OF(Thread, vm_tag_); }

◆ write_barrier_mask()

uword dart::Thread::write_barrier_mask ( ) const

inline

Definition at line 428 of file thread.h.

428{ return write_barrier_mask_; }

◆ write_barrier_mask_offset()

static intptr_t dart::Thread::write_barrier_mask_offset ( )

inlinestatic

Definition at line 437 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 753 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 765 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 1291 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 Function Documentation

◆ ActiveIsolateScope

friend class ActiveIsolateScope

friend

Definition at line 1474 of file thread.h.

◆ ApiZone

friend class ApiZone

friend

Definition at line 1473 of file thread.h.

◆ compiler::target::Thread

friend class compiler::target::Thread

friend

Definition at line 1486 of file thread.h.

◆ CompilerState

friend class CompilerState

friend

Definition at line 1485 of file thread.h.

◆ CreateWithinExistingIsolateGroup

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

friend

Definition at line 1301 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 1489 of file thread.h.

◆ FieldTable

friend class FieldTable

friend

Definition at line 1487 of file thread.h.

◆ InterruptChecker

friend class InterruptChecker

friend

Definition at line 1475 of file thread.h.

◆ Isolate

friend class Isolate

friend

Definition at line 1476 of file thread.h.

◆ IsolateGroup

friend class IsolateGroup

friend

Definition at line 1477 of file thread.h.

◆ MonitorLocker

friend class MonitorLocker

friend

Definition at line 1494 of file thread.h.

◆ NoActiveIsolateScope

friend class NoActiveIsolateScope

friend

Definition at line 1478 of file thread.h.

◆ NoReloadScope

friend class NoReloadScope

friend

Definition at line 1479 of file thread.h.

◆ RawReloadParticipationScope

friend class RawReloadParticipationScope

friend

Definition at line 1480 of file thread.h.

◆ RestoreWriteBarrierInvariantVisitor

friend class RestoreWriteBarrierInvariantVisitor

friend

Definition at line 1165 of file thread.h.

◆ RuntimeCallDeoptScope

friend class RuntimeCallDeoptScope

friend

Definition at line 1488 of file thread.h.

◆ Simulator

friend class Simulator

friend

Definition at line 1481 of file thread.h.

◆ StackZone

friend class StackZone

friend

Definition at line 1482 of file thread.h.

◆ StoppedMutatorsScope

friend class StoppedMutatorsScope

friend

Definition at line 1483 of file thread.h.

◆ ThreadRegistry

friend class ThreadRegistry

friend

Definition at line 1484 of file thread.h.

◆ TransitionGeneratedToVM

friend class TransitionGeneratedToVM

friend

Definition at line 1491 of file thread.h.

◆ TransitionVMToGenerated

friend class TransitionVMToGenerated

friend

Definition at line 1493 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()