1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
| //===-- SBThread.h ----------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef LLDB_SBThread_h_
#define LLDB_SBThread_h_
#include "lldb/API/SBDefines.h"
#include <stdio.h>
namespace lldb {
class SBFrame;
class LLDB_API SBThread {
public:
enum {
eBroadcastBitStackChanged = (1 << 0),
eBroadcastBitThreadSuspended = (1 << 1),
eBroadcastBitThreadResumed = (1 << 2),
eBroadcastBitSelectedFrameChanged = (1 << 3),
eBroadcastBitThreadSelected = (1 << 4)
};
static const char *GetBroadcasterClassName();
SBThread();
SBThread(const lldb::SBThread &thread);
SBThread(const lldb::ThreadSP &lldb_object_sp);
~SBThread();
lldb::SBQueue GetQueue() const;
explicit operator bool() const;
bool IsValid() const;
void Clear();
lldb::StopReason GetStopReason();
/// Get the number of words associated with the stop reason.
/// See also GetStopReasonDataAtIndex().
size_t GetStopReasonDataCount();
/// 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
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 StepOver(lldb::RunMode stop_other_threads, SBError &error);
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 StepOut(SBError &error);
void StepOutOfFrame(SBFrame &frame);
void StepOutOfFrame(SBFrame &frame, SBError &error);
void StepInstruction(bool step_over);
void StepInstruction(bool step_over, SBError &error);
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 StepUsingScriptedThreadPlan(const char *script_class_name,
lldb::SBStructuredData &args_data,
bool resume_immediately);
SBError JumpToLine(lldb::SBFileSpec &file_spec, uint32_t line);
void RunToAddress(lldb::addr_t addr);
void RunToAddress(lldb::addr_t addr, SBError &error);
SBError ReturnFromFrame(SBFrame &frame, SBValue &return_value);
SBError UnwindInnermostExpression();
/// 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.
bool Suspend();
bool Suspend(SBError &error);
bool Resume();
bool Resume(SBError &error);
bool IsSuspended();
bool IsStopped();
uint32_t GetNumFrames();
lldb::SBFrame GetFrameAtIndex(uint32_t idx);
lldb::SBFrame GetSelectedFrame();
lldb::SBFrame SetSelectedFrame(uint32_t frame_idx);
static bool EventIsThreadEvent(const SBEvent &event);
static SBFrame GetStackFrameFromEvent(const SBEvent &event);
static SBThread GetThreadFromEvent(const SBEvent &event);
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 GetDescription(lldb::SBStream &description, bool stop_format) const;
bool GetStatus(lldb::SBStream &status) const;
SBThread GetExtendedBacktraceThread(const char *type);
uint32_t GetExtendedBacktraceOriginatingIndexID();
SBValue GetCurrentException();
SBThread GetCurrentExceptionBacktrace();
bool SafeToCallFunctions();
private:
friend class SBBreakpoint;
friend class SBBreakpointLocation;
friend class SBBreakpointCallbackBaton;
friend class SBExecutionContext;
friend class SBFrame;
friend class SBProcess;
friend class SBDebugger;
friend class SBValue;
friend class lldb_private::QueueImpl;
friend class SBQueueItem;
friend class SBThreadPlan;
void SetThread(const lldb::ThreadSP &lldb_object_sp);
SBError ResumeNewPlan(lldb_private::ExecutionContext &exe_ctx,
lldb_private::ThreadPlan *new_plan);
lldb::ExecutionContextRefSP m_opaque_sp;
lldb_private::Thread *operator->();
lldb_private::Thread *get();
};
} // namespace lldb
#endif // LLDB_SBThread_h_
|