LLDB API Documentation

- Main Page
- Namespaces
- Classes
- Files

- File List

SBThread.h
Go to the documentation of this file.
1 //===-- SBThread.h ----------------------------------------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #ifndef LLDB_SBThread_h_
11 #define LLDB_SBThread_h_
12
13 #include "lldb/API/SBDefines.h"
14
15 #include <stdio.h>
16
17 namespace lldb {
18
19 class SBFrame;
20
21 class SBThread
22 {
23 public:
24 enum
25 {
26 eBroadcastBitStackChanged = (1 << 0),
27 eBroadcastBitThreadSuspended = (1 << 1),
28 eBroadcastBitThreadResumed = (1 << 2),
29 eBroadcastBitSelectedFrameChanged = (1 << 3),
30 eBroadcastBitThreadSelected = (1 << 4)
31 };
32
33 static const char *
34 GetBroadcasterClassName ();
35
36 SBThread ();
37
38 SBThread (const lldb::SBThread &thread);
39
40 SBThread (const lldb::ThreadSP& lldb_object_sp);
41
42 ~SBThread();
43
44 bool
45 IsValid() const;
46
47 void
48 Clear ();
49
50 lldb::StopReason
51 GetStopReason();
52
53 /// Get the number of words associated with the stop reason.
54 /// See also GetStopReasonDataAtIndex().
55 size_t
56 GetStopReasonDataCount();
57
58 //--------------------------------------------------------------------------
59 /// Get information associated with a stop reason.
60 ///
61 /// Breakpoint stop reasons will have data that consists of pairs of
62 /// breakpoint IDs followed by the breakpoint location IDs (they always come
63 /// in pairs).
64 ///
65 /// Stop Reason Count Data Type
66 /// ======================== ===== =========================================
67 /// eStopReasonNone 0
68 /// eStopReasonTrace 0
69 /// eStopReasonBreakpoint N duple: {breakpoint id, location id}
70 /// eStopReasonWatchpoint 1 watchpoint id
71 /// eStopReasonSignal 1 unix signal number
72 /// eStopReasonException N exception data
73 /// eStopReasonExec 0
74 /// eStopReasonPlanComplete 0
75 //--------------------------------------------------------------------------
76 uint64_t
77 GetStopReasonDataAtIndex(uint32_t idx);
78
79 size_t
80 GetStopDescription (char *dst, size_t dst_len);
81
82 SBValue
83 GetStopReturnValue ();
84
85 lldb::tid_t
86 GetThreadID () const;
87
88 uint32_t
89 GetIndexID () const;
90
91 const char *
92 GetName () const;
93
94 const char *
95 GetQueueName() const;
96
97 void
98 StepOver (lldb::RunMode stop_other_threads = lldb::eOnlyDuringStepping);
99
100 void
101 StepInto (lldb::RunMode stop_other_threads = lldb::eOnlyDuringStepping);
102
103 void
104 StepInto (const char *target_name, lldb::RunMode stop_other_threads = lldb::eOnlyDuringStepping);
105
106 void
107 StepOut ();
108
109 void
110 StepOutOfFrame (lldb::SBFrame &frame);
111
112 void
113 StepInstruction(bool step_over);
114
115 SBError
116 StepOverUntil (lldb::SBFrame &frame,
117 lldb::SBFileSpec &file_spec,
118 uint32_t line);
119
120 void
121 RunToAddress (lldb::addr_t addr);
122
123 SBError
124 ReturnFromFrame (SBFrame &frame, SBValue &return_value);
125
126 //--------------------------------------------------------------------------
127 /// LLDB currently supports process centric debugging which means when any
128 /// thread in a process stops, all other threads are stopped. The Suspend()
129 /// call here tells our process to suspend a thread and not let it run when
130 /// the other threads in a process are allowed to run. So when
131 /// SBProcess::Continue() is called, any threads that aren't suspended will
132 /// be allowed to run. If any of the SBThread functions for stepping are
133 /// called (StepOver, StepInto, StepOut, StepInstruction, RunToAddres), the
134 /// thread will not be allowed to run and these funtions will simply return.
135 ///
136 /// Eventually we plan to add support for thread centric debugging where
137 /// each thread is controlled individually and each thread would broadcast
138 /// its state, but we haven't implemented this yet.
139 ///
140 /// Likewise the SBThread::Resume() call will again allow the thread to run
141 /// when the process is continued.
142 ///
143 /// Suspend() and Resume() functions are not currently reference counted, if
144 /// anyone has the need for them to be reference counted, please let us
145 /// know.
146 //--------------------------------------------------------------------------
147 bool
148 Suspend();
149
150 bool
151 Resume ();
152
153 bool
154 IsSuspended();
155
156 bool
157 IsStopped();
158
159 uint32_t
160 GetNumFrames ();
161
162 lldb::SBFrame
163 GetFrameAtIndex (uint32_t idx);
164
165 lldb::SBFrame
166 GetSelectedFrame ();
167
168 lldb::SBFrame
169 SetSelectedFrame (uint32_t frame_idx);
170
171 static bool
172 EventIsThreadEvent (const SBEvent &event);
173
174 static SBFrame
175 GetStackFrameFromEvent (const SBEvent &event);
176
177 static SBThread
178 GetThreadFromEvent (const SBEvent &event);
179
180 lldb::SBProcess
181 GetProcess ();
182
183 const lldb::SBThread &
184 operator = (const lldb::SBThread &rhs);
185
186 bool
187 operator == (const lldb::SBThread &rhs) const;
188
189 bool
190 operator != (const lldb::SBThread &rhs) const;
191
192 bool
193 GetDescription (lldb::SBStream &description) const;
194
195 bool
196 GetStatus (lldb::SBStream &status) const;
197
198 protected:
199 friend class SBBreakpoint;
200 friend class SBBreakpointLocation;
201 friend class SBFrame;
202 friend class SBProcess;
203 friend class SBDebugger;
204 friend class SBValue;
205
206 void
207 SetThread (const lldb::ThreadSP& lldb_object_sp);
208
209 #ifndef SWIG
210 SBError
211 ResumeNewPlan (lldb_private::ExecutionContext &exe_ctx, lldb_private::ThreadPlan *new_plan);
212 #endif
213
214 private:
215 lldb::ExecutionContextRefSP m_opaque_sp;
216 };
217
218 } // namespace lldb
219
220 #endif // LLDB_SBThread_h_