LLVM: lldb::SBThread Class Reference
Description: C++ source code API documentation for LLDB.
Keywords: LLDB,C++,doxygen,API,documentation

LLDB API Documentation

- Main Page
- Namespaces
- Classes
- Files

- Class List
- Class Index
- Class Hierarchy
- Class Members

Public Types | Public Member Functions | Static Public Member Functions | Protected Member Functions | Friends | List of all members
lldb::SBThread Class Reference

`#include <SBThread.h>`

## Public Types
enum | { eBroadcastBitStackChanged = (1 << 0), eBroadcastBitThreadSuspended = (1 << 1), eBroadcastBitThreadResumed = (1 << 2), eBroadcastBitSelectedFrameChanged = (1 << 3), eBroadcastBitThreadSelected = (1 << 4) }

## Public Member Functions
| SBThread ()
| SBThread (const lldb::SBThread &thread)
| SBThread (const lldb::ThreadSP &lldb_object_sp)
| ~SBThread ()
lldb::SBQueue | GetQueue () const
bool | IsValid () const
void | Clear ()
lldb::StopReason | GetStopReason ()
size_t | GetStopReasonDataCount ()
uint64_t | GetStopReasonDataAtIndex (uint32_t idx)
bool | GetStopReasonExtendedInfoAsJSON (lldb::SBStream &stream)
SBThreadCollection | GetStopReasonExtendedBacktraces (InstrumentationRuntimeType type)
size_t | GetStopDescription (char *dst, size_t dst_len)
SBValue | GetStopReturnValue ()
lldb::tid_t | GetThreadID () const
uint32_t | GetIndexID () const
const char * | GetName () const
const char * | GetQueueName () const
lldb::queue_id_t | GetQueueID () const
bool | GetInfoItemByPathAsString (const char *path, SBStream &strm)
void | StepOver (lldb::RunMode stop_other_threads=lldb::eOnlyDuringStepping)
void | StepInto (lldb::RunMode stop_other_threads=lldb::eOnlyDuringStepping)
void | StepInto (const char *target_name, lldb::RunMode stop_other_threads=lldb::eOnlyDuringStepping)
void | StepInto (const char *target_name, uint32_t end_line, SBError &error, lldb::RunMode stop_other_threads=lldb::eOnlyDuringStepping)
void | StepOut ()
void | StepOutOfFrame (lldb::SBFrame &frame)
void | StepInstruction (bool step_over)
SBError | StepOverUntil (lldb::SBFrame &frame, lldb::SBFileSpec &file_spec, uint32_t line)
SBError | StepUsingScriptedThreadPlan (const char *script_class_name)
SBError | StepUsingScriptedThreadPlan (const char *script_class_name, bool resume_immediately)
SBError | JumpToLine (lldb::SBFileSpec &file_spec, uint32_t line)
void | RunToAddress (lldb::addr_t addr)
SBError | ReturnFromFrame (SBFrame &frame, SBValue &return_value)
SBError | UnwindInnermostExpression ()
bool | Suspend ()
bool | Resume ()
bool | IsSuspended ()
bool | IsStopped ()
uint32_t | GetNumFrames ()
lldb::SBFrame | GetFrameAtIndex (uint32_t idx)
lldb::SBFrame | GetSelectedFrame ()
lldb::SBFrame | SetSelectedFrame (uint32_t frame_idx)
lldb::SBProcess | GetProcess ()
const lldb::SBThread & | operator= (const lldb::SBThread &rhs)
bool | operator== (const lldb::SBThread &rhs) const
bool | operator!= (const lldb::SBThread &rhs) const
bool | GetDescription (lldb::SBStream &description) const
bool | GetStatus (lldb::SBStream &status) const
SBThread | GetExtendedBacktraceThread (const char *type)
uint32_t | GetExtendedBacktraceOriginatingIndexID ()
bool | SafeToCallFunctions ()
lldb_private::Thread * | operator-> ()
lldb_private::Thread * | get ()

## Static Public Member Functions
static const char * | GetBroadcasterClassName ()
static bool | EventIsThreadEvent (const SBEvent &event)
static SBFrame | GetStackFrameFromEvent (const SBEvent &event)
static SBThread | GetThreadFromEvent (const SBEvent &event)

## Protected Member Functions
void | SetThread (const lldb::ThreadSP &lldb_object_sp)
SBError | ResumeNewPlan (lldb_private::ExecutionContext &exe_ctx, lldb_private::ThreadPlan *new_plan)

## Friends
class | SBBreakpoint
class | SBBreakpointLocation
class | SBExecutionContext
class | SBFrame
class | SBProcess
class | SBDebugger
class | SBValue
class | lldb_private::QueueImpl
class | SBQueueItem

## Detailed Description

Definition at line 21 of file SBThread.h.

## Member Enumeration Documentation

anonymous enum

Enumerator
eBroadcastBitStackChanged |
eBroadcastBitThreadSuspended |
eBroadcastBitThreadResumed |
eBroadcastBitSelectedFrameChanged |
eBroadcastBitThreadSelected |

Definition at line 23 of file SBThread.h.

## Constructor & Destructor Documentation

lldb::SBThread::SBThread | ( |  | ) |

lldb::SBThread::SBThread | ( | const lldb::SBThread & | thread | ) |

lldb::SBThread::SBThread | ( | const lldb::ThreadSP & | lldb_object_sp | ) |

lldb::SBThread::~SBThread | ( |  | ) |

## Member Function Documentation

void lldb::SBThread::Clear | ( |  | ) |

static bool lldb::SBThread::EventIsThreadEvent | ( | const SBEvent & | event | ) |
| static

lldb_private::Thread* lldb::SBThread::get | ( |  | ) |

static const char* lldb::SBThread::GetBroadcasterClassName | ( |  | ) |
| static

bool lldb::SBThread::GetDescription | ( | lldb::SBStream & | description | ) | const

uint32_t lldb::SBThread::GetExtendedBacktraceOriginatingIndexID | ( |  | ) |

SBThread lldb::SBThread::GetExtendedBacktraceThread | ( | const char * | type | ) |

lldb::SBFrame lldb::SBThread::GetFrameAtIndex | ( | uint32_t | idx | ) |

uint32_t lldb::SBThread::GetIndexID | ( |  | ) | const

bool lldb::SBThread::GetInfoItemByPathAsString | ( | const char * | path,
|  | SBStream & | strm
| ) |  |

const char* lldb::SBThread::GetName | ( |  | ) | const

uint32_t lldb::SBThread::GetNumFrames | ( |  | ) |

lldb::SBProcess lldb::SBThread::GetProcess | ( |  | ) |

lldb::SBQueue lldb::SBThread::GetQueue | ( |  | ) | const

lldb::queue_id_t lldb::SBThread::GetQueueID | ( |  | ) | const

const char* lldb::SBThread::GetQueueName | ( |  | ) | const

lldb::SBFrame lldb::SBThread::GetSelectedFrame | ( |  | ) |

static SBFrame lldb::SBThread::GetStackFrameFromEvent | ( | const SBEvent & | event | ) |
| static

bool lldb::SBThread::GetStatus | ( | lldb::SBStream & | status | ) | const

size_t lldb::SBThread::GetStopDescription | ( | char * | dst,
|  | size_t | dst_len
| ) |  |

lldb::StopReason lldb::SBThread::GetStopReason | ( |  | ) |

uint64_t lldb::SBThread::GetStopReasonDataAtIndex | ( | uint32_t | idx | ) |

Get information associated with a stop reason.

Breakpoint stop reasons will have data that consists of pairs of breakpoint IDs followed by the breakpoint location IDs (they always come in pairs).

Stop Reason Count Data Type ======================== ===== ========================================= eStopReasonNone 0 eStopReasonTrace 0 eStopReasonBreakpoint N duple: {breakpoint id, location id} eStopReasonWatchpoint 1 watchpoint id eStopReasonSignal 1 unix signal number eStopReasonException N exception data eStopReasonExec 0 eStopReasonPlanComplete 0

size_t lldb::SBThread::GetStopReasonDataCount | ( |  | ) |

Get the number of words associated with the stop reason. See also GetStopReasonDataAtIndex().

SBThreadCollection lldb::SBThread::GetStopReasonExtendedBacktraces | ( | InstrumentationRuntimeType | type | ) |

bool lldb::SBThread::GetStopReasonExtendedInfoAsJSON | ( | lldb::SBStream & | stream | ) |

SBValue lldb::SBThread::GetStopReturnValue | ( |  | ) |

static SBThread lldb::SBThread::GetThreadFromEvent | ( | const SBEvent & | event | ) |
| static

lldb::tid_t lldb::SBThread::GetThreadID | ( |  | ) | const

bool lldb::SBThread::IsStopped | ( |  | ) |

bool lldb::SBThread::IsSuspended | ( |  | ) |

bool lldb::SBThread::IsValid | ( |  | ) | const

SBError lldb::SBThread::JumpToLine | ( | lldb::SBFileSpec & | file_spec,
|  | uint32_t | line
| ) |  |

bool lldb::SBThread::operator!= | ( | const lldb::SBThread & | rhs | ) | const

lldb_private::Thread* lldb::SBThread::operator-> | ( |  | ) |

const lldb::SBThread& lldb::SBThread::operator= | ( | const lldb::SBThread & | rhs | ) |

bool lldb::SBThread::operator== | ( | const lldb::SBThread & | rhs | ) | const

bool lldb::SBThread::Resume | ( |  | ) |

SBError lldb::SBThread::ResumeNewPlan | ( | lldb_private::ExecutionContext & | exe_ctx,
|  | lldb_private::ThreadPlan * | new_plan
| ) |  |
| protected

SBError lldb::SBThread::ReturnFromFrame | ( | SBFrame & | frame,
|  | SBValue & | return_value
| ) |  |

void lldb::SBThread::RunToAddress | ( | lldb::addr_t | addr | ) |

bool lldb::SBThread::SafeToCallFunctions | ( |  | ) |

lldb::SBFrame lldb::SBThread::SetSelectedFrame | ( | uint32_t | frame_idx | ) |

void lldb::SBThread::SetThread | ( | const lldb::ThreadSP & | lldb_object_sp | ) |
| protected

void lldb::SBThread::StepInstruction | ( | bool | step_over | ) |

void lldb::SBThread::StepInto | ( | lldb::RunMode | stop_other_threads = `lldb::eOnlyDuringStepping` | ) |

void lldb::SBThread::StepInto | ( | const char * | target_name,
|  | lldb::RunMode | stop_other_threads = `lldb::eOnlyDuringStepping`
| ) |  |

void lldb::SBThread::StepInto | ( | const char * | target_name,
|  | uint32_t | end_line,
|  | SBError & | error,
|  | lldb::RunMode | stop_other_threads = `lldb::eOnlyDuringStepping`
| ) |  |

void lldb::SBThread::StepOut | ( |  | ) |

void lldb::SBThread::StepOutOfFrame | ( | lldb::SBFrame & | frame | ) |

void lldb::SBThread::StepOver | ( | lldb::RunMode | stop_other_threads = `lldb::eOnlyDuringStepping` | ) |

SBError lldb::SBThread::StepOverUntil | ( | lldb::SBFrame & | frame,
|  | lldb::SBFileSpec & | file_spec,
|  | uint32_t | line
| ) |  |

SBError lldb::SBThread::StepUsingScriptedThreadPlan | ( | const char * | script_class_name | ) |

SBError lldb::SBThread::StepUsingScriptedThreadPlan | ( | const char * | script_class_name,
|  | bool | resume_immediately
| ) |  |

bool lldb::SBThread::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 (StepOver, StepInto, StepOut, StepInstruction, RunToAddress), the thread will not be allowed to run and these functions will simply return.

Eventually we plan to add support for thread centric debugging where each thread is controlled individually and each thread would broadcast its state, but we haven't implemented this yet.

Likewise the SBThread::Resume() call will again allow the thread to run when the process is continued.

Suspend() and Resume() functions are not currently reference counted, if anyone has the need for them to be reference counted, please let us know.

SBError lldb::SBThread::UnwindInnermostExpression | ( |  | ) |

## Friends And Related Function Documentation

friend class lldb_private::QueueImpl
| friend

Definition at line 202 of file SBThread.h.

friend class SBBreakpoint
| friend

Definition at line 195 of file SBThread.h.

friend class SBBreakpointLocation
| friend

Definition at line 196 of file SBThread.h.

friend class SBDebugger
| friend

Definition at line 200 of file SBThread.h.

friend class SBExecutionContext
| friend

Definition at line 197 of file SBThread.h.

friend class SBFrame
| friend

Definition at line 198 of file SBThread.h.

friend class SBProcess
| friend

Definition at line 199 of file SBThread.h.

friend class SBQueueItem
| friend

Definition at line 203 of file SBThread.h.

friend class SBValue
| friend

Definition at line 201 of file SBThread.h.

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

- SBThread.h