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