Struct lldb::SBThread

pub struct SBThread {
    pub raw: SBThreadRef,
}

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 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 selected_frame and set via set_selected_frame.

Events

...

Fields

raw: SBThreadRef

The underlying raw SBThreadRef.

Methods

impl SBThread

fn wrap(raw: SBThreadRef) -> SBThread

Construct a new SBThread.

fn maybe_wrap(raw: SBThreadRef) -> Option<SBThread>

Construct a new Some(SBThread) or None.

fn is_valid(&self) -> bool

Check whether or not this is a valid SBThread value.

fn broadcaster_class_name() -> &'static str

fn stop_reason(&self) -> StopReason

Get the stop reason for this thread.

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

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 Mac OS X 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.

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.

fn name(&self) -> &str

The name associated with the thread, if any.

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.

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.

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.

fn suspend(&self) -> u8

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() 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.

fn resume(&self) -> u8

Set the user resume state for this to allow it to run again.

See the discussion on suspend for further details.

fn is_suspended(&self) -> bool

Is this thread set to the suspended user resume state?

See the discussion on suspend for further details.

fn is_stopped(&self) -> bool

Is this thread stopped?

fn frames(&self) -> SBThreadFrameIter

Get an iterator over the frames known to this thread instance.

fn selected_frame(&self) -> SBFrame

Get the currently selected frame for this thread.

fn set_selected_frame(&self, frame_index: u32) -> Option<SBFrame>

Set the currently selected frame for this thread. This takes a frame index.

fn process(&self) -> SBProcess

Get the process in which this thread is running.

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.

Trait Implementations

impl Debug for SBThread

fn fmt(&self, fmt: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Drop for SBThread

fn drop(&mut self)

Executes the destructor for this type.