#include <ThreadMemory.h>

Inheritance diagram for ThreadMemory:

[legend]

Public Member Functions
	ThreadMemory (lldb_private::Process &process, lldb::tid_t tid, const lldb::ValueObjectSP &thread_info_valobj_sp)

	ThreadMemory (lldb_private::Process &process, lldb::tid_t tid, llvm::StringRef name, llvm::StringRef queue, lldb::addr_t register_data_addr)

	~ThreadMemory () override

lldb::RegisterContextSP	GetRegisterContext () override

lldb::RegisterContextSP	CreateRegisterContextForFrame (lldb_private::StackFrame *frame) override

bool	CalculateStopInfo () override
	Ask the thread subclass to set its stop info.

const char *	GetInfo () override

const char *	GetName () override

const char *	GetQueueName () override
	Retrieve the Queue name for the queue currently using this Thread.

void	WillResume (lldb::StateType resume_state) override

void	DidResume () override

lldb::user_id_t	GetProtocolID () const override

void	RefreshStateAfterStop () override

lldb::ValueObjectSP &	GetValueObject ()

void	ClearStackFrames () override

void	ClearBackingThread () override

bool	SetBackingThread (const lldb::ThreadSP &thread_sp) override

lldb::ThreadSP	GetBackingThread () const override

Public Member Functions inherited from lldb_private::Thread
llvm::StringRef	GetBroadcasterClass () const override
	This needs to be filled in if you are going to register the broadcaster with the broadcaster manager and do broadcaster class matching.

	Thread (Process &process, lldb::tid_t tid, bool use_invalid_index_id=false)
	Constructor.

	~Thread () override

lldb::ProcessSP	GetProcess () const

int	GetResumeSignal () const

void	SetResumeSignal (int signal)

lldb::StateType	GetState () const

void	SetState (lldb::StateType state)

void	SetResumeState (lldb::StateType state, bool override_suspend=false)
	Sets the USER resume state for this thread.

lldb::StateType	GetResumeState () const
	Gets the USER resume state for this thread.

void	SetupForResume ()

bool	ShouldResume (lldb::StateType resume_state)

virtual void	WillResume (lldb::StateType resume_state)

virtual void	DidResume ()

virtual void	DidStop ()

virtual void	RefreshStateAfterStop ()=0

std::string	GetStopDescription ()

std::string	GetStopDescriptionRaw ()

void	WillStop ()

bool	ShouldStop (Event *event_ptr)

Vote	ShouldReportStop (Event *event_ptr)

Vote	ShouldReportRun (Event *event_ptr)

void	Flush ()

virtual bool	MatchesSpec (const ThreadSpec *spec)

lldb::StopInfoSP	GetStopInfo ()

lldb::StopReason	GetStopReason ()

bool	StopInfoIsUpToDate () const

void	SetStopInfoToNothing ()

bool	ThreadStoppedForAReason ()

virtual const char *	GetInfo ()

StructuredData::ObjectSP	GetExtendedInfo ()
	Retrieve a dictionary of information about this thread.

virtual const char *	GetName ()

virtual void	SetName (const char *name)

virtual lldb_private::LazyBool	GetAssociatedWithLibdispatchQueue ()
	Whether this thread can be associated with a libdispatch queue.

virtual void	SetAssociatedWithLibdispatchQueue (lldb_private::LazyBool associated_with_libdispatch_queue)

virtual lldb::queue_id_t	GetQueueID ()
	Retrieve the Queue ID for the queue currently using this Thread.

virtual void	SetQueueID (lldb::queue_id_t new_val)

virtual const char *	GetQueueName ()
	Retrieve the Queue name for the queue currently using this Thread.

virtual void	SetQueueName (const char *name)

virtual lldb::QueueKind	GetQueueKind ()
	Retrieve the Queue kind for the queue currently using this Thread.

virtual void	SetQueueKind (lldb::QueueKind kind)

virtual lldb::QueueSP	GetQueue ()
	Retrieve the Queue for this thread, if any.

virtual lldb::addr_t	GetQueueLibdispatchQueueAddress ()
	Retrieve the address of the libdispatch_queue_t struct for queue currently using this Thread.

virtual void	SetQueueLibdispatchQueueAddress (lldb::addr_t dispatch_queue_t)

virtual bool	ThreadHasQueueInformation () const
	Whether this Thread already has all the Queue information cached or not.

virtual uint32_t	GetStackFrameCount ()
	GetStackFrameCount can be expensive.

virtual lldb::StackFrameSP	GetStackFrameAtIndex (uint32_t idx)

virtual lldb::StackFrameSP	GetFrameWithConcreteFrameIndex (uint32_t unwind_idx)

bool	DecrementCurrentInlinedDepth ()

uint32_t	GetCurrentInlinedDepth ()

Status	ReturnFromFrameWithIndex (uint32_t frame_idx, lldb::ValueObjectSP return_value_sp, bool broadcast=false)

Status	ReturnFromFrame (lldb::StackFrameSP frame_sp, lldb::ValueObjectSP return_value_sp, bool broadcast=false)

Status	JumpToLine (const FileSpec &file, uint32_t line, bool can_leave_function, std::string *warnings=nullptr)

virtual lldb::StackFrameSP	GetFrameWithStackID (const StackID &stack_id)

uint32_t	GetSelectedFrameIndex (SelectMostRelevant select_most_relevant)

lldb::StackFrameSP	GetSelectedFrame (SelectMostRelevant select_most_relevant)

uint32_t	SetSelectedFrame (lldb_private::StackFrame *frame, bool broadcast=false)

bool	SetSelectedFrameByIndex (uint32_t frame_idx, bool broadcast=false)

bool	SetSelectedFrameByIndexNoisily (uint32_t frame_idx, Stream &output_stream)

void	SetDefaultFileAndLineToSelectedFrame ()

virtual lldb::RegisterContextSP	GetRegisterContext ()=0

virtual lldb::RegisterContextSP	CreateRegisterContextForFrame (StackFrame *frame)=0

virtual void	ClearStackFrames ()

virtual bool	SetBackingThread (const lldb::ThreadSP &thread_sp)

virtual lldb::ThreadSP	GetBackingThread () const

virtual void	ClearBackingThread ()

void	DumpTraceInstructions (Stream &s, size_t count, size_t start_position=0) const
	Dump count instructions of the thread's Trace starting at the start_position position in reverse order.

bool	DumpUsingFormat (Stream &strm, uint32_t frame_idx, const FormatEntity::Entry *format)
	Print a description of this thread using the provided thread format.

void	DumpUsingSettingsFormat (Stream &strm, uint32_t frame_idx, bool stop_format)

bool	GetDescription (Stream &s, lldb::DescriptionLevel level, bool print_json_thread, bool print_json_stopinfo)

virtual Status	StepIn (bool source_step, LazyBool step_in_avoids_code_without_debug_info=eLazyBoolCalculate, LazyBool step_out_avoids_code_without_debug_info=eLazyBoolCalculate)
	Default implementation for stepping into.

virtual Status	StepOver (bool source_step, LazyBool step_out_avoids_code_without_debug_info=eLazyBoolCalculate)
	Default implementation for stepping over.

virtual Status	StepOut (uint32_t frame_idx=0)
	Default implementation for stepping out.

virtual lldb::addr_t	GetThreadPointer ()
	Retrieves the per-thread data area.

virtual lldb::addr_t	GetThreadLocalData (const lldb::ModuleSP module, lldb::addr_t tls_file_addr)
	Retrieves the per-module TLS block for a thread.

virtual bool	SafeToCallFunctions ()
	Check whether this thread is safe to run functions.

lldb::ThreadPlanSP	QueueBasePlan (bool abort_other_plans)
	Queues the base plan for a thread.

virtual lldb::ThreadPlanSP	QueueThreadPlanForStepSingleInstruction (bool step_over, bool abort_other_plans, bool stop_other_threads, Status &status)
	Queues the plan used to step one instruction from the current PC of thread.

virtual lldb::ThreadPlanSP	QueueThreadPlanForStepOverRange (bool abort_other_plans, const AddressRange &range, const SymbolContext &addr_context, lldb::RunMode stop_other_threads, Status &status, LazyBool step_out_avoids_code_without_debug_info=eLazyBoolCalculate)
	Queues the plan used to step through an address range, stepping over function calls.

virtual lldb::ThreadPlanSP	QueueThreadPlanForStepOverRange (bool abort_other_plans, const LineEntry &line_entry, const SymbolContext &addr_context, lldb::RunMode stop_other_threads, Status &status, LazyBool step_out_avoids_code_without_debug_info=eLazyBoolCalculate)

virtual lldb::ThreadPlanSP	QueueThreadPlanForStepInRange (bool abort_other_plans, const AddressRange &range, const SymbolContext &addr_context, const char *step_in_target, lldb::RunMode stop_other_threads, Status &status, LazyBool step_in_avoids_code_without_debug_info=eLazyBoolCalculate, LazyBool step_out_avoids_code_without_debug_info=eLazyBoolCalculate)
	Queues the plan used to step through an address range, stepping into functions.

virtual lldb::ThreadPlanSP	QueueThreadPlanForStepInRange (bool abort_other_plans, const LineEntry &line_entry, const SymbolContext &addr_context, const char *step_in_target, lldb::RunMode stop_other_threads, Status &status, LazyBool step_in_avoids_code_without_debug_info=eLazyBoolCalculate, LazyBool step_out_avoids_code_without_debug_info=eLazyBoolCalculate)

virtual lldb::ThreadPlanSP	QueueThreadPlanForStepOut (bool abort_other_plans, SymbolContext *addr_context, bool first_insn, bool stop_other_threads, Vote report_stop_vote, Vote report_run_vote, uint32_t frame_idx, Status &status, LazyBool step_out_avoids_code_without_debug_info=eLazyBoolCalculate)
	Queue the plan used to step out of the function at the current PC of thread.

virtual lldb::ThreadPlanSP	QueueThreadPlanForStepOutNoShouldStop (bool abort_other_plans, SymbolContext *addr_context, bool first_insn, bool stop_other_threads, Vote report_stop_vote, Vote report_run_vote, uint32_t frame_idx, Status &status, bool continue_to_next_branch=false)
	Queue the plan used to step out of the function at the current PC of a thread.

virtual lldb::ThreadPlanSP	QueueThreadPlanForStepThrough (StackID &return_stack_id, bool abort_other_plans, bool stop_other_threads, Status &status)
	Gets the plan used to step through the code that steps from a function call site at the current PC into the actual function call.

virtual lldb::ThreadPlanSP	QueueThreadPlanForRunToAddress (bool abort_other_plans, Address &target_addr, bool stop_other_threads, Status &status)
	Gets the plan used to continue from the current PC.

virtual lldb::ThreadPlanSP	QueueThreadPlanForStepUntil (bool abort_other_plans, lldb::addr_t *address_list, size_t num_addresses, bool stop_others, uint32_t frame_idx, Status &status)

virtual lldb::ThreadPlanSP	QueueThreadPlanForStepScripted (bool abort_other_plans, const char *class_name, StructuredData::ObjectSP extra_args_sp, bool stop_other_threads, Status &status)

void	AutoCompleteThreadPlans (CompletionRequest &request) const
	Format the thread plan information for auto completion.

ThreadPlan *	GetCurrentPlan () const
	Gets the plan which will execute next on the plan stack.

Status	UnwindInnermostExpression ()
	Unwinds the thread stack for the innermost expression plan currently on the thread plan stack.

lldb::ThreadPlanSP	GetCompletedPlan () const
	Gets the outer-most plan that was popped off the plan stack in the most recent stop.

lldb::ValueObjectSP	GetReturnValueObject () const
	Gets the outer-most return value from the completed plans.

lldb::ExpressionVariableSP	GetExpressionVariable () const
	Gets the outer-most expression variable from the completed plans.

bool	IsThreadPlanDone (ThreadPlan *plan) const
	Checks whether the given plan is in the completed plans for this stop.

bool	WasThreadPlanDiscarded (ThreadPlan *plan) const
	Checks whether the given plan is in the discarded plans for this stop.

bool	CompletedPlanOverridesBreakpoint () const
	Check if we have completed plan to override breakpoint stop reason.

Status	QueueThreadPlan (lldb::ThreadPlanSP &plan_sp, bool abort_other_plans)
	Queues a generic thread plan.

void	DiscardThreadPlans (bool force)
	Discards the plans queued on the plan stack of the current thread.

void	DiscardThreadPlansUpToPlan (lldb::ThreadPlanSP &up_to_plan_sp)
	Discards the plans queued on the plan stack of the current thread up to and including up_to_plan_sp.

void	DiscardThreadPlansUpToPlan (ThreadPlan *up_to_plan_ptr)

bool	DiscardUserThreadPlansUpToIndex (uint32_t thread_index)
	Discards the plans queued on the plan stack of the current thread up to and including the plan in that matches thread_index counting only the non-Private plans.

virtual bool	CheckpointThreadState (ThreadStateCheckpoint &saved_state)

virtual bool	RestoreRegisterStateFromCheckpoint (ThreadStateCheckpoint &saved_state)

void	RestoreThreadStateFromCheckpoint (ThreadStateCheckpoint &saved_state)

uint32_t	GetIndexID () const

virtual uint32_t	GetExtendedBacktraceOriginatingIndexID ()

virtual lldb::user_id_t	GetProtocolID () const

lldb::TargetSP	CalculateTarget () override

lldb::ProcessSP	CalculateProcess () override

lldb::ThreadSP	CalculateThread () override

lldb::StackFrameSP	CalculateStackFrame () override

void	CalculateExecutionContext (ExecutionContext &exe_ctx) override
	Reconstruct the object's execution context into sc.

lldb::StackFrameSP	GetStackFrameSPForStackFramePtr (StackFrame *stack_frame_ptr)

size_t	GetStatus (Stream &strm, uint32_t start_frame, uint32_t num_frames, uint32_t num_frames_with_source, bool stop_format, bool show_hidden, bool only_stacks=false)

size_t	GetStackFrameStatus (Stream &strm, uint32_t first_frame, uint32_t num_frames, bool show_frame_info, uint32_t num_frames_with_source, bool show_hidden)

bool	IsValid () const

virtual lldb::StopInfoSP	GetPrivateStopInfo (bool calculate=true)

void	CalculatePublicStopInfo ()

virtual bool	CalculateStopInfo ()=0
	Ask the thread subclass to set its stop info.

lldb::StateType	GetTemporaryResumeState () const

void	SetStopInfo (const lldb::StopInfoSP &stop_info_sp)

void	ResetStopInfo ()

void	SetShouldReportStop (Vote vote)

void	SetShouldRunBeforePublicStop (bool newval)

bool	ShouldRunBeforePublicStop ()

virtual void	SetExtendedBacktraceToken (uint64_t token)
	Sets the extended backtrace token for this thread.

virtual uint64_t	GetExtendedBacktraceToken ()
	Gets the extended backtrace token for this thread.

lldb::ValueObjectSP	GetCurrentException ()

lldb::ThreadSP	GetCurrentExceptionBacktrace ()

lldb::ValueObjectSP	GetSiginfoValue ()

std::optional< lldb::addr_t >	GetPreviousFrameZeroPC ()
	Request the pc value the thread had when previously stopped.

Public Member Functions inherited from lldb_private::ThreadProperties
	ThreadProperties (bool is_global)

	~ThreadProperties () override

const RegularExpression *	GetSymbolsToAvoidRegexp ()
	The regular expression returned determines symbols that this thread won't stop in during "step-in" operations.

FileSpecList	GetLibrariesToAvoid () const

bool	GetTraceEnabledState () const

bool	GetStepInAvoidsNoDebug () const

bool	GetStepOutAvoidsNoDebug () const

uint64_t	GetMaxBacktraceDepth () const

uint64_t	GetSingleThreadPlanTimeout () const

Public Member Functions inherited from lldb_private::Properties
	Properties ()

	Properties (const lldb::OptionValuePropertiesSP &collection_sp)

virtual	~Properties ()

virtual lldb::OptionValuePropertiesSP	GetValueProperties () const

virtual lldb::OptionValueSP	GetPropertyValue (const ExecutionContext *exe_ctx, llvm::StringRef property_path, Status &error) const

virtual Status	SetPropertyValue (const ExecutionContext *exe_ctx, VarSetOperationType op, llvm::StringRef property_path, llvm::StringRef value)

virtual Status	DumpPropertyValue (const ExecutionContext *exe_ctx, Stream &strm, llvm::StringRef property_path, uint32_t dump_mask, bool is_json=false)

virtual void	DumpAllPropertyValues (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask, bool is_json=false)

virtual void	DumpAllDescriptions (CommandInterpreter &interpreter, Stream &strm) const

size_t	Apropos (llvm::StringRef keyword, std::vector< const Property * > &matching_properties) const

template<typename T >
T	GetPropertyAtIndexAs (uint32_t idx, T default_value, const ExecutionContext *exe_ctx=nullptr) const

template<typename T , typename U = typename std::remove_pointer<T>::type, std::enable_if_t< std::is_pointer_v< T >, bool > = true>
const U *	GetPropertyAtIndexAs (uint32_t idx, const ExecutionContext *exe_ctx=nullptr) const

template<typename T >
bool	SetPropertyAtIndex (uint32_t idx, T t, const ExecutionContext *exe_ctx=nullptr) const

Public Member Functions inherited from lldb_private::UserID
	UserID (lldb::user_id_t uid=LLDB_INVALID_UID)
	Construct with optional user ID.

	~UserID ()=default
	Destructor.

void	Clear ()
	Clears the object state.

lldb::user_id_t	GetID () const
	Get accessor for the user ID.

void	SetID (lldb::user_id_t uid)
	Set accessor for the user ID.

Public Member Functions inherited from lldb_private::ExecutionContextScope
virtual	~ExecutionContextScope ()=default

virtual lldb::TargetSP	CalculateTarget ()=0

virtual lldb::ProcessSP	CalculateProcess ()=0

virtual lldb::ThreadSP	CalculateThread ()=0

virtual lldb::StackFrameSP	CalculateStackFrame ()=0

virtual void	CalculateExecutionContext (ExecutionContext &exe_ctx)=0
	Reconstruct the object's execution context into sc.

Public Member Functions inherited from lldb_private::Broadcaster
	Broadcaster (lldb::BroadcasterManagerSP manager_sp, std::string name)
	Construct with a broadcaster with a name.

virtual	~Broadcaster ()
	Destructor.

void	CheckInWithManager ()

void	BroadcastEvent (lldb::EventSP &event_sp)
	Broadcast an event which has no associated data.

void	BroadcastEventIfUnique (lldb::EventSP &event_sp)

void	BroadcastEvent (uint32_t event_type, const lldb::EventDataSP &event_data_sp)

void	BroadcastEvent (uint32_t event_type)

void	BroadcastEventIfUnique (uint32_t event_type)

void	Clear ()

virtual void	AddInitialEventsToListener (const lldb::ListenerSP &listener_sp, uint32_t requested_events)

uint32_t	AddListener (const lldb::ListenerSP &listener_sp, uint32_t event_mask)
	Listen for any events specified by event_mask.

const std::string &	GetBroadcasterName ()
	Get this broadcaster's name.

bool	GetEventNames (Stream &s, const uint32_t event_mask, bool prefix_with_broadcaster_name) const
	Get the event name(s) for one or more event bits.

void	SetEventName (uint32_t event_mask, const char *name)
	Set the name for an event bit.

const char *	GetEventName (uint32_t event_mask) const

bool	EventTypeHasListeners (uint32_t event_type)

bool	RemoveListener (const lldb::ListenerSP &listener_sp, uint32_t event_mask=UINT32_MAX)
	Removes a Listener from this broadcasters list and frees the event bits specified by event_mask that were previously acquired by listener (assuming listener was listening to this object) for other listener objects to use.

bool	HijackBroadcaster (const lldb::ListenerSP &listener_sp, uint32_t event_mask=UINT32_MAX)
	Provides a simple mechanism to temporarily redirect events from broadcaster.

bool	IsHijackedForEvent (uint32_t event_mask)

void	RestoreBroadcaster ()
	Restore the state of the Broadcaster from a previous hijack attempt.

virtual llvm::StringRef	GetBroadcasterClass () const
	This needs to be filled in if you are going to register the broadcaster with the broadcaster manager and do broadcaster class matching.

lldb::BroadcasterManagerSP	GetManager ()

void	SetPrimaryListener (lldb::ListenerSP listener_sp)

lldb::ListenerSP	GetPrimaryListener ()

Protected Member Functions
bool	IsOperatingSystemPluginThread () const override

Protected Member Functions inherited from lldb_private::Thread
virtual void	DestroyThread ()

ThreadPlanStack &	GetPlans () const

void	PushPlan (lldb::ThreadPlanSP plan_sp)

void	PopPlan ()

void	DiscardPlan ()

ThreadPlan *	GetPreviousPlan (ThreadPlan *plan) const

virtual Unwind &	GetUnwinder ()

virtual bool	IsStillAtLastBreakpointHit ()

virtual bool	IsOperatingSystemPluginThread () const

virtual lldb_private::StructuredData::ObjectSP	FetchThreadExtendedInfo ()

lldb::StackFrameListSP	GetStackFrameList ()

void	SetTemporaryResumeState (lldb::StateType new_state)

void	FrameSelectedCallback (lldb_private::StackFrame *frame)

virtual llvm::Expected< std::unique_ptr< llvm::MemoryBuffer > >	GetSiginfo (size_t max_size) const

Protected Member Functions inherited from lldb_private::Broadcaster
BroadcasterImplSP	GetBroadcasterImpl ()

const char *	GetHijackingListenerName ()

Protected Attributes
lldb::ThreadSP	m_backing_thread_sp

lldb::ValueObjectSP	m_thread_info_valobj_sp

std::string	m_name

std::string	m_queue

lldb::addr_t	m_register_data_addr

Protected Attributes inherited from lldb_private::Thread
lldb::ProcessWP	m_process_wp
	The process that owns this thread.

lldb::StopInfoSP	m_stop_info_sp
	The private stop reason for this thread.

uint32_t	m_stop_info_stop_id

uint32_t	m_stop_info_override_stop_id

bool	m_should_run_before_public_stop

const uint32_t	m_index_id
	A unique 1 based index assigned to each thread for easy UI/command line access.

lldb::RegisterContextSP	m_reg_context_sp
	The register context for this thread's current register state.

lldb::StateType	m_state
	The state of our process.

std::recursive_mutex	m_state_mutex
	Multithreaded protection for m_state.

std::recursive_mutex	m_frame_mutex
	Multithreaded protection for m_state.

lldb::StackFrameListSP	m_curr_frames_sp
	The stack frames that get lazily populated after a thread stops.

lldb::StackFrameListSP	m_prev_frames_sp
	The previous stack frames from the last time this thread stopped.

std::optional< lldb::addr_t >	m_prev_framezero_pc
	Frame 0's PC the last time this thread was stopped.

int	m_resume_signal
	The signal that should be used when continuing this thread.

lldb::StateType	m_resume_state
	This state is used to force a thread to be suspended from outside the ThreadPlan logic.

lldb::StateType	m_temporary_resume_state
	This state records what the thread was told to do by the thread plan logic for the current resume.

std::unique_ptr< lldb_private::Unwind >	m_unwinder_up
	It gets set in Thread::ShouldResume.

bool	m_destroy_called

LazyBool	m_override_should_notify

std::unique_ptr< ThreadPlanStack >	m_null_plan_stack_up

Protected Attributes inherited from lldb_private::Properties
lldb::OptionValuePropertiesSP	m_collection_sp

Protected Attributes inherited from lldb_private::UserID
lldb::user_id_t	m_uid
	The user ID that uniquely identifies an object.

Private Member Functions
	ThreadMemory (const ThreadMemory &)=delete

const ThreadMemory &	operator= (const ThreadMemory &)=delete

Additional Inherited Members
Public Types inherited from lldb_private::Thread
enum	{ eBroadcastBitStackChanged = (1 << 0) , eBroadcastBitThreadSuspended = (1 << 1) , eBroadcastBitThreadResumed = (1 << 2) , eBroadcastBitSelectedFrameChanged = (1 << 3) , eBroadcastBitThreadSelected = (1 << 4) }
	Broadcaster event bits definitions. More...

Static Public Member Functions inherited from lldb_private::Thread
static llvm::StringRef	GetStaticBroadcasterClass ()

static void	SettingsInitialize ()

static void	SettingsTerminate ()

static ThreadProperties &	GetGlobalProperties ()

static std::string	RunModeAsString (lldb::RunMode mode)

static std::string	StopReasonAsString (lldb::StopReason reason)

Static Public Member Functions inherited from lldb_private::Properties
static llvm::StringRef	GetExperimentalSettingsName ()

static bool	IsSettingExperimental (llvm::StringRef setting)

Protected Types inherited from lldb_private::Broadcaster
typedef std::shared_ptr< BroadcasterImpl >	BroadcasterImplSP

typedef std::weak_ptr< BroadcasterImpl >	BroadcasterImplWP

Detailed Description

Definition at line 16 of file ThreadMemory.h.

Constructor & Destructor Documentation

◆ ThreadMemory() [1/3]

ThreadMemory::ThreadMemory	(	lldb_private::Process &	process,
		lldb::tid_t	tid,
		const lldb::ValueObjectSP &	thread_info_valobj_sp
	)

Definition at line 23 of file ThreadMemory.cpp.

◆ ThreadMemory() [2/3]

ThreadMemory::ThreadMemory	(	lldb_private::Process &	process,
		lldb::tid_t	tid,
		llvm::StringRef	name,
		llvm::StringRef	queue,
		lldb::addr_t	register_data_addr
	)

Definition at line 29 of file ThreadMemory.cpp.

◆ ~ThreadMemory()

ThreadMemory::~ThreadMemory ( )

override

Definition at line 36 of file ThreadMemory.cpp.

References lldb_private::Thread::DestroyThread().

◆ ThreadMemory() [3/3]

ThreadMemory::ThreadMemory ( const ThreadMemory & )

privatedelete

Member Function Documentation

◆ CalculateStopInfo()

bool ThreadMemory::CalculateStopInfo ( )

overridevirtual

Ask the thread subclass to set its stop info.

Thread subclasses should call Thread::SetStopInfo(...) with the reason the thread stopped.

A thread that is sitting at a breakpoint site, but has not yet executed the breakpoint instruction, should have a breakpoint-hit StopInfo set. When execution is resumed, any thread sitting at a breakpoint site will instruction-step over the breakpoint instruction silently, and we will never record this breakpoint as being hit, updating the hit count, possibly executing breakpoint commands or conditions.