1 //===-- SBThread.cpp --------------------------------------------*- 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 #include "lldb/API/SBThread.h"
11
12 #include "lldb/API/SBSymbolContext.h"
13 #include "lldb/API/SBFileSpec.h"
14 #include "lldb/API/SBStream.h"
15 #include "lldb/Breakpoint/BreakpointLocation.h"
16 #include "lldb/Core/Debugger.h"
17 #include "lldb/Core/State.h"
18 #include "lldb/Core/Stream.h"
19 #include "lldb/Core/StreamFile.h"
20 #include "lldb/Core/StructuredData.h"
21 #include "lldb/Interpreter/CommandInterpreter.h"
22 #include "lldb/Target/SystemRuntime.h"
23 #include "lldb/Target/Thread.h"
24 #include "lldb/Target/ThreadPlan.h"
25 #include "lldb/Target/Process.h"
26 #include "lldb/Target/Queue.h"
27 #include "lldb/Symbol/SymbolContext.h"
28 #include "lldb/Symbol/CompileUnit.h"
29 #include "lldb/Target/StopInfo.h"
30 #include "lldb/Target/Target.h"
31 #include "lldb/Target/ThreadPlan.h"
32 #include "lldb/Target/ThreadPlanPython.h"
33 #include "lldb/Target/ThreadPlanStepInstruction.h"
34 #include "lldb/Target/ThreadPlanStepOut.h"
35 #include "lldb/Target/ThreadPlanStepRange.h"
36 #include "lldb/Target/ThreadPlanStepInRange.h"
37
38
39 #include "lldb/API/SBAddress.h"
40 #include "lldb/API/SBDebugger.h"
41 #include "lldb/API/SBEvent.h"
42 #include "lldb/API/SBFrame.h"
43 #include "lldb/API/SBProcess.h"
44 #include "lldb/API/SBThreadPlan.h"
45 #include "lldb/API/SBValue.h"
46
47 using namespace lldb;
48 using namespace lldb_private;
49
50 //----------------------------------------------------------------------
51 // Constructors
52 //----------------------------------------------------------------------
SBThreadPlan()53 SBThreadPlan::SBThreadPlan ()
54 {
55 }
56
SBThreadPlan(const ThreadPlanSP & lldb_object_sp)57 SBThreadPlan::SBThreadPlan (const ThreadPlanSP& lldb_object_sp) :
58 m_opaque_sp (lldb_object_sp)
59 {
60 }
61
SBThreadPlan(const SBThreadPlan & rhs)62 SBThreadPlan::SBThreadPlan (const SBThreadPlan &rhs) :
63 m_opaque_sp (rhs.m_opaque_sp)
64 {
65
66 }
67
SBThreadPlan(lldb::SBThread & sb_thread,const char * class_name)68 SBThreadPlan::SBThreadPlan (lldb::SBThread &sb_thread, const char *class_name)
69 {
70 Thread *thread = sb_thread.get();
71 if (thread)
72 m_opaque_sp.reset(new ThreadPlanPython(*thread, class_name));
73 }
74
75 //----------------------------------------------------------------------
76 // Assignment operator
77 //----------------------------------------------------------------------
78
79 const lldb::SBThreadPlan &
operator =(const SBThreadPlan & rhs)80 SBThreadPlan::operator = (const SBThreadPlan &rhs)
81 {
82 if (this != &rhs)
83 m_opaque_sp = rhs.m_opaque_sp;
84 return *this;
85 }
86 //----------------------------------------------------------------------
87 // Destructor
88 //----------------------------------------------------------------------
~SBThreadPlan()89 SBThreadPlan::~SBThreadPlan()
90 {
91 }
92
93 lldb_private::ThreadPlan *
get()94 SBThreadPlan::get()
95 {
96 return m_opaque_sp.get();
97 }
98
99 bool
IsValid() const100 SBThreadPlan::IsValid() const
101 {
102 return m_opaque_sp.get() != NULL;
103 }
104
105 void
Clear()106 SBThreadPlan::Clear ()
107 {
108 m_opaque_sp.reset();
109 }
110
111 lldb::StopReason
GetStopReason()112 SBThreadPlan::GetStopReason()
113 {
114 return eStopReasonNone;
115 }
116
117 size_t
GetStopReasonDataCount()118 SBThreadPlan::GetStopReasonDataCount()
119 {
120 return 0;
121 }
122
123 uint64_t
GetStopReasonDataAtIndex(uint32_t idx)124 SBThreadPlan::GetStopReasonDataAtIndex(uint32_t idx)
125 {
126 return 0;
127 }
128
129 SBThread
GetThread() const130 SBThreadPlan::GetThread () const
131 {
132 if (m_opaque_sp)
133 {
134 return SBThread(m_opaque_sp->GetThread().shared_from_this());
135 }
136 else
137 return SBThread();
138 }
139
140 bool
GetDescription(lldb::SBStream & description) const141 SBThreadPlan::GetDescription (lldb::SBStream &description) const
142 {
143 if (m_opaque_sp)
144 {
145 m_opaque_sp->GetDescription(description.get(), eDescriptionLevelFull);
146 }
147 else
148 {
149 description.Printf("Empty SBThreadPlan");
150 }
151 return true;
152 }
153
154 void
SetThreadPlan(const ThreadPlanSP & lldb_object_sp)155 SBThreadPlan::SetThreadPlan (const ThreadPlanSP& lldb_object_sp)
156 {
157 m_opaque_sp = lldb_object_sp;
158 }
159
160 void
SetPlanComplete(bool success)161 SBThreadPlan::SetPlanComplete (bool success)
162 {
163 if (m_opaque_sp)
164 m_opaque_sp->SetPlanComplete (success);
165 }
166
167 bool
IsPlanComplete()168 SBThreadPlan::IsPlanComplete()
169 {
170 if (m_opaque_sp)
171 return m_opaque_sp->IsPlanComplete();
172 else
173 return true;
174 }
175
176 bool
IsValid()177 SBThreadPlan::IsValid()
178 {
179 if (m_opaque_sp)
180 return m_opaque_sp->ValidatePlan(nullptr);
181 else
182 return false;
183 }
184
185 // This section allows an SBThreadPlan to push another of the common types of plans...
186 //
187 // FIXME, you should only be able to queue thread plans from inside the methods of a
188 // Scripted Thread Plan. Need a way to enforce that.
189
190 SBThreadPlan
QueueThreadPlanForStepOverRange(SBAddress & sb_start_address,lldb::addr_t size)191 SBThreadPlan::QueueThreadPlanForStepOverRange (SBAddress &sb_start_address,
192 lldb::addr_t size)
193 {
194 if (m_opaque_sp)
195 {
196 Address *start_address = sb_start_address.get();
197 if (!start_address)
198 {
199 return SBThreadPlan();
200 }
201
202 AddressRange range (*start_address, size);
203 SymbolContext sc;
204 start_address->CalculateSymbolContext(&sc);
205 return SBThreadPlan (m_opaque_sp->GetThread().QueueThreadPlanForStepOverRange (false,
206 range,
207 sc,
208 eAllThreads));
209 }
210 else
211 {
212 return SBThreadPlan();
213 }
214 }
215
216 SBThreadPlan
QueueThreadPlanForStepInRange(SBAddress & sb_start_address,lldb::addr_t size)217 SBThreadPlan::QueueThreadPlanForStepInRange (SBAddress &sb_start_address,
218 lldb::addr_t size)
219 {
220 if (m_opaque_sp)
221 {
222 Address *start_address = sb_start_address.get();
223 if (!start_address)
224 {
225 return SBThreadPlan();
226 }
227
228 AddressRange range (*start_address, size);
229 SymbolContext sc;
230 start_address->CalculateSymbolContext(&sc);
231 return SBThreadPlan (m_opaque_sp->GetThread().QueueThreadPlanForStepInRange (false,
232 range,
233 sc,
234 NULL,
235 eAllThreads));
236 }
237 else
238 {
239 return SBThreadPlan();
240 }
241 }
242
243 SBThreadPlan
QueueThreadPlanForStepOut(uint32_t frame_idx_to_step_to,bool first_insn)244 SBThreadPlan::QueueThreadPlanForStepOut (uint32_t frame_idx_to_step_to, bool first_insn)
245 {
246 if (m_opaque_sp)
247 {
248 SymbolContext sc;
249 sc = m_opaque_sp->GetThread().GetStackFrameAtIndex(0)->GetSymbolContext(lldb::eSymbolContextEverything);
250 return SBThreadPlan (m_opaque_sp->GetThread().QueueThreadPlanForStepOut (false,
251 &sc,
252 first_insn,
253 false,
254 eVoteYes,
255 eVoteNoOpinion,
256 frame_idx_to_step_to));
257 }
258 else
259 {
260 return SBThreadPlan();
261 }
262 }
263
264 SBThreadPlan
QueueThreadPlanForRunToAddress(SBAddress sb_address)265 SBThreadPlan::QueueThreadPlanForRunToAddress (SBAddress sb_address)
266 {
267 if (m_opaque_sp)
268 {
269 Address *address = sb_address.get();
270 if (!address)
271 return SBThreadPlan();
272
273 return SBThreadPlan (m_opaque_sp->GetThread().QueueThreadPlanForRunToAddress (false,
274 *address,
275 false));
276 }
277 else
278 {
279 return SBThreadPlan();
280 }
281 }
282
283
284