pub struct SBThread {
pub raw: SBThreadRef,
}Expand description
A thread of execution.
SBThreads can be referred to by their ID, which maps to the system
specific thread identifier, or by IndexID. The ID may or may not
be unique depending on whether the system reuses its thread identifiers.
The IndexID is a monotonically increasing identifier that will always
uniquely reference a particular thread, and when that thread goes
away it will not be reused.
Thread State
…
Execution Control
…
Frames
The thread contains stack frames. These can be iterated
over with SBThread::frames():
// Iterate over the frames...
for frame in thread.frames() {
println!("Hello {:?}!", frame);
}
// Or collect them into a vector!
let frames = thread.frames().collect::<Vec<SBFrame>>();Some functions operate on the ‘currently selected frame’. This can
retrieved via SBThread::selected_frame() and set via
SBThread::set_selected_frame().
Events
…
Fields
raw: SBThreadRefThe underlying raw SBThreadRef.
Implementations
sourceimpl SBThread
impl SBThread
pub fn broadcaster_class_name() -> &'static str
sourcepub fn stop_reason(&self) -> StopReason
pub fn stop_reason(&self) -> StopReason
Get the stop reason for this thread.
sourcepub fn stop_return_value(&self) -> Option<SBValue>
pub fn stop_return_value(&self) -> Option<SBValue>
The return value from the last stop if we just stopped due to stepping out of a function
sourcepub fn thread_id(&self) -> lldb_tid_t
pub fn thread_id(&self) -> lldb_tid_t
Returns a unique thread identifier for the current SBThread
that will remain constant throughout the thread’s lifetime in
this process and will not be reused by another thread during this
process lifetime. On macOS systems, this is a system-wide
unique thread identifier; this identifier is also used by
other tools like sample which helps to associate data from
those tools with lldb. See related SBThread::index_id.
sourcepub fn index_id(&self) -> u32
pub fn index_id(&self) -> u32
Return the index number for this SBThread. The index
number is the same thing that a user gives as an argument
to thread select in the command line lldb.
These numbers start at 1 (for the first thread lldb sees
in a debug session) and increments up throughout the process
lifetime. An index number will not be reused for a different
thread later in a process - thread 1 will always be associated
with the same thread. See related SBThread::thread_id.
sourcepub fn queue(&self) -> Option<SBQueue>
pub fn queue(&self) -> Option<SBQueue>
Return the queue associated with this thread, if any.
If this SBThread is actually a history thread, then there may be
a queue ID and name available, but not a full SBQueue as the
individual attributes may have been saved, but without enough
information to reconstitute the entire SBQueue at that time.
sourcepub fn queue_name(&self) -> &str
pub fn queue_name(&self) -> &str
Return the queue name associated with this thread, if any.
For example, this would report a libdispatch (Grand Central Dispatch)
queue name.
sourcepub fn queue_id(&self) -> u64
pub fn queue_id(&self) -> u64
Return the dispatch_queue_id for this thread, if any.
For example, this would report a libdispatch (Grand Central Dispatch)
queue ID.
sourcepub fn suspend(&self) -> Result<(), SBError>
pub fn suspend(&self) -> Result<(), SBError>
Set the user resume state for this thread to suspend.
LLDB currently supports process centric debugging which means when any
thread in a process stops, all other threads are stopped. The suspend
call here tells our process to suspend a thread and not let it run when
the other threads in a process are allowed to run. So when
SBProcess::continue_execution() is called, any threads that
aren’t suspended will be allowed to run. If any of the SBThread
functions for stepping are called (step_over, step_into,
step_out, step_instruction, run_to_address), the thread will
not be allowed to run and these functions will simply return.
sourcepub fn resume(&self) -> Result<(), SBError>
pub fn resume(&self) -> Result<(), SBError>
Set the user resume state for this to allow it to run again.
See the discussion on SBThread::suspend() for further details.
sourcepub fn is_suspended(&self) -> bool
pub fn is_suspended(&self) -> bool
Is this thread set to the suspended user resume state?
See the discussion on SBThread::suspend() for further details.
sourcepub fn is_stopped(&self) -> bool
pub fn is_stopped(&self) -> bool
Is this thread stopped?
sourcepub fn frames(&self) -> SBThreadFrameIter<'_>ⓘNotable traits for SBThreadFrameIter<'d>impl<'d> Iterator for SBThreadFrameIter<'d> type Item = SBFrame;
pub fn frames(&self) -> SBThreadFrameIter<'_>ⓘNotable traits for SBThreadFrameIter<'d>impl<'d> Iterator for SBThreadFrameIter<'d> type Item = SBFrame;
Get an iterator over the frames known to this thread instance.
sourcepub fn selected_frame(&self) -> SBFrame
pub fn selected_frame(&self) -> SBFrame
Get the currently selected frame for this thread.
sourcepub fn set_selected_frame(&self, frame_index: u32) -> Option<SBFrame>
pub fn set_selected_frame(&self, frame_index: u32) -> Option<SBFrame>
Set the currently selected frame for this thread. This takes a frame index.
sourcepub fn event_as_thread_event(event: &SBEvent) -> Option<SBThreadEvent<'_>>
pub fn event_as_thread_event(event: &SBEvent) -> Option<SBThreadEvent<'_>>
If the given event is a thread event, return it as an
SBThreadEvent. Otherwise, return None.