1//===-- SBThreadPlan.cpp ----------------------------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "SBReproducerPrivate.h"
10#include "lldb/API/SBThread.h"
11
12#include "lldb/API/SBFileSpec.h"
13#include "lldb/API/SBStream.h"
14#include "lldb/API/SBStructuredData.h"
15#include "lldb/API/SBSymbolContext.h"
16#include "lldb/Breakpoint/BreakpointLocation.h"
17#include "lldb/Core/Debugger.h"
18#include "lldb/Core/StreamFile.h"
19#include "lldb/Core/StructuredDataImpl.h"
20#include "lldb/Interpreter/CommandInterpreter.h"
21#include "lldb/Symbol/CompileUnit.h"
22#include "lldb/Symbol/SymbolContext.h"
23#include "lldb/Target/Process.h"
24#include "lldb/Target/Queue.h"
25#include "lldb/Target/StopInfo.h"
26#include "lldb/Target/SystemRuntime.h"
27#include "lldb/Target/Target.h"
28#include "lldb/Target/Thread.h"
29#include "lldb/Target/ThreadPlan.h"
30#include "lldb/Target/ThreadPlanPython.h"
31#include "lldb/Target/ThreadPlanStepInRange.h"
32#include "lldb/Target/ThreadPlanStepInstruction.h"
33#include "lldb/Target/ThreadPlanStepOut.h"
34#include "lldb/Target/ThreadPlanStepRange.h"
35#include "lldb/Utility/State.h"
36#include "lldb/Utility/Stream.h"
37#include "lldb/Utility/StructuredData.h"
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#include <memory>
48
49using namespace lldb;
50using namespace lldb_private;
51
52// Constructors
53SBThreadPlan::SBThreadPlan() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBThreadPlan); }
54
55SBThreadPlan::SBThreadPlan(const ThreadPlanSP &lldb_object_sp)
56    : m_opaque_sp(lldb_object_sp) {
57  LLDB_RECORD_CONSTRUCTOR(SBThreadPlan, (const lldb::ThreadPlanSP &),
58                          lldb_object_sp);
59}
60
61SBThreadPlan::SBThreadPlan(const SBThreadPlan &rhs)
62    : m_opaque_sp(rhs.m_opaque_sp) {
63  LLDB_RECORD_CONSTRUCTOR(SBThreadPlan, (const lldb::SBThreadPlan &), rhs);
64}
65
66SBThreadPlan::SBThreadPlan(lldb::SBThread &sb_thread, const char *class_name) {
67  LLDB_RECORD_CONSTRUCTOR(SBThreadPlan, (lldb::SBThread &, const char *),
68                          sb_thread, class_name);
69
70  Thread *thread = sb_thread.get();
71  if (thread)
72    m_opaque_sp = std::make_shared<ThreadPlanPython>(*thread, class_name,
73                                                     nullptr);
74}
75
76SBThreadPlan::SBThreadPlan(lldb::SBThread &sb_thread, const char *class_name,
77                           lldb::SBStructuredData &args_data) {
78  LLDB_RECORD_CONSTRUCTOR(SBThreadPlan, (lldb::SBThread &, const char *,
79                                         SBStructuredData &),
80                          sb_thread, class_name, args_data);
81
82  Thread *thread = sb_thread.get();
83  if (thread)
84    m_opaque_sp = std::make_shared<ThreadPlanPython>(*thread, class_name,
85                                                     args_data.m_impl_up.get());
86}
87
88// Assignment operator
89
90const lldb::SBThreadPlan &SBThreadPlan::operator=(const SBThreadPlan &rhs) {
91  LLDB_RECORD_METHOD(const lldb::SBThreadPlan &,
92                     SBThreadPlan, operator=,(const lldb::SBThreadPlan &), rhs);
93
94  if (this != &rhs)
95    m_opaque_sp = rhs.m_opaque_sp;
96  return LLDB_RECORD_RESULT(*this);
97}
98// Destructor
99SBThreadPlan::~SBThreadPlan() {}
100
101lldb_private::ThreadPlan *SBThreadPlan::get() { return m_opaque_sp.get(); }
102
103bool SBThreadPlan::IsValid() const {
104  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadPlan, IsValid);
105  return this->operator bool();
106}
107SBThreadPlan::operator bool() const {
108  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadPlan, operator bool);
109
110  return m_opaque_sp.get() != nullptr;
111}
112
113void SBThreadPlan::Clear() {
114  LLDB_RECORD_METHOD_NO_ARGS(void, SBThreadPlan, Clear);
115
116  m_opaque_sp.reset();
117}
118
119lldb::StopReason SBThreadPlan::GetStopReason() {
120  LLDB_RECORD_METHOD_NO_ARGS(lldb::StopReason, SBThreadPlan, GetStopReason);
121
122  return eStopReasonNone;
123}
124
125size_t SBThreadPlan::GetStopReasonDataCount() {
126  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBThreadPlan, GetStopReasonDataCount);
127
128  return 0;
129}
130
131uint64_t SBThreadPlan::GetStopReasonDataAtIndex(uint32_t idx) {
132  LLDB_RECORD_METHOD(uint64_t, SBThreadPlan, GetStopReasonDataAtIndex,
133                     (uint32_t), idx);
134
135  return 0;
136}
137
138SBThread SBThreadPlan::GetThread() const {
139  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBThreadPlan, GetThread);
140
141  if (m_opaque_sp) {
142    return LLDB_RECORD_RESULT(
143        SBThread(m_opaque_sp->GetThread().shared_from_this()));
144  } else
145    return LLDB_RECORD_RESULT(SBThread());
146}
147
148bool SBThreadPlan::GetDescription(lldb::SBStream &description) const {
149  LLDB_RECORD_METHOD_CONST(bool, SBThreadPlan, GetDescription,
150                           (lldb::SBStream &), description);
151
152  if (m_opaque_sp) {
153    m_opaque_sp->GetDescription(description.get(), eDescriptionLevelFull);
154  } else {
155    description.Printf("Empty SBThreadPlan");
156  }
157  return true;
158}
159
160void SBThreadPlan::SetThreadPlan(const ThreadPlanSP &lldb_object_sp) {
161  m_opaque_sp = lldb_object_sp;
162}
163
164void SBThreadPlan::SetPlanComplete(bool success) {
165  LLDB_RECORD_METHOD(void, SBThreadPlan, SetPlanComplete, (bool), success);
166
167  if (m_opaque_sp)
168    m_opaque_sp->SetPlanComplete(success);
169}
170
171bool SBThreadPlan::IsPlanComplete() {
172  LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, IsPlanComplete);
173
174  if (m_opaque_sp)
175    return m_opaque_sp->IsPlanComplete();
176  else
177    return true;
178}
179
180bool SBThreadPlan::IsPlanStale() {
181  LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, IsPlanStale);
182
183  if (m_opaque_sp)
184    return m_opaque_sp->IsPlanStale();
185  else
186    return true;
187}
188
189bool SBThreadPlan::IsValid() {
190  LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, IsValid);
191
192  if (m_opaque_sp)
193    return m_opaque_sp->ValidatePlan(nullptr);
194  else
195    return false;
196}
197
198// This section allows an SBThreadPlan to push another of the common types of
199// plans...
200//
201// FIXME, you should only be able to queue thread plans from inside the methods
202// of a Scripted Thread Plan.  Need a way to enforce that.
203
204SBThreadPlan
205SBThreadPlan::QueueThreadPlanForStepOverRange(SBAddress &sb_start_address,
206                                              lldb::addr_t size) {
207  LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
208                     QueueThreadPlanForStepOverRange,
209                     (lldb::SBAddress &, lldb::addr_t), sb_start_address, size);
210
211  SBError error;
212  return LLDB_RECORD_RESULT(
213      QueueThreadPlanForStepOverRange(sb_start_address, size, error));
214}
215
216SBThreadPlan SBThreadPlan::QueueThreadPlanForStepOverRange(
217    SBAddress &sb_start_address, lldb::addr_t size, SBError &error) {
218  LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
219                     QueueThreadPlanForStepOverRange,
220                     (lldb::SBAddress &, lldb::addr_t, lldb::SBError &),
221                     sb_start_address, size, error);
222
223  if (m_opaque_sp) {
224    Address *start_address = sb_start_address.get();
225    if (!start_address) {
226      return LLDB_RECORD_RESULT(SBThreadPlan());
227    }
228
229    AddressRange range(*start_address, size);
230    SymbolContext sc;
231    start_address->CalculateSymbolContext(&sc);
232    Status plan_status;
233
234    SBThreadPlan plan =
235        SBThreadPlan(m_opaque_sp->GetThread().QueueThreadPlanForStepOverRange(
236            false, range, sc, eAllThreads, plan_status));
237
238    if (plan_status.Fail())
239      error.SetErrorString(plan_status.AsCString());
240
241    return LLDB_RECORD_RESULT(plan);
242  } else {
243    return LLDB_RECORD_RESULT(SBThreadPlan());
244  }
245}
246
247SBThreadPlan
248SBThreadPlan::QueueThreadPlanForStepInRange(SBAddress &sb_start_address,
249                                            lldb::addr_t size) {
250  LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
251                     QueueThreadPlanForStepInRange,
252                     (lldb::SBAddress &, lldb::addr_t), sb_start_address, size);
253
254  SBError error;
255  return LLDB_RECORD_RESULT(
256      QueueThreadPlanForStepInRange(sb_start_address, size, error));
257}
258
259SBThreadPlan
260SBThreadPlan::QueueThreadPlanForStepInRange(SBAddress &sb_start_address,
261                                            lldb::addr_t size, SBError &error) {
262  LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
263                     QueueThreadPlanForStepInRange,
264                     (lldb::SBAddress &, lldb::addr_t, lldb::SBError &),
265                     sb_start_address, size, error);
266
267  if (m_opaque_sp) {
268    Address *start_address = sb_start_address.get();
269    if (!start_address) {
270      return LLDB_RECORD_RESULT(SBThreadPlan());
271    }
272
273    AddressRange range(*start_address, size);
274    SymbolContext sc;
275    start_address->CalculateSymbolContext(&sc);
276
277    Status plan_status;
278    SBThreadPlan plan =
279        SBThreadPlan(m_opaque_sp->GetThread().QueueThreadPlanForStepInRange(
280            false, range, sc, nullptr, eAllThreads, plan_status));
281
282    if (plan_status.Fail())
283      error.SetErrorString(plan_status.AsCString());
284
285    return LLDB_RECORD_RESULT(plan);
286  } else {
287    return LLDB_RECORD_RESULT(SBThreadPlan());
288  }
289}
290
291SBThreadPlan
292SBThreadPlan::QueueThreadPlanForStepOut(uint32_t frame_idx_to_step_to,
293                                        bool first_insn) {
294  LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
295                     QueueThreadPlanForStepOut, (uint32_t, bool),
296                     frame_idx_to_step_to, first_insn);
297
298  SBError error;
299  return LLDB_RECORD_RESULT(
300      QueueThreadPlanForStepOut(frame_idx_to_step_to, first_insn, error));
301}
302
303SBThreadPlan
304SBThreadPlan::QueueThreadPlanForStepOut(uint32_t frame_idx_to_step_to,
305                                        bool first_insn, SBError &error) {
306  LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
307                     QueueThreadPlanForStepOut,
308                     (uint32_t, bool, lldb::SBError &), frame_idx_to_step_to,
309                     first_insn, error);
310
311  if (m_opaque_sp) {
312    SymbolContext sc;
313    sc = m_opaque_sp->GetThread().GetStackFrameAtIndex(0)->GetSymbolContext(
314        lldb::eSymbolContextEverything);
315
316    Status plan_status;
317    SBThreadPlan plan =
318        SBThreadPlan(m_opaque_sp->GetThread().QueueThreadPlanForStepOut(
319            false, &sc, first_insn, false, eVoteYes, eVoteNoOpinion,
320            frame_idx_to_step_to, plan_status));
321
322    if (plan_status.Fail())
323      error.SetErrorString(plan_status.AsCString());
324
325    return LLDB_RECORD_RESULT(plan);
326  } else {
327    return LLDB_RECORD_RESULT(SBThreadPlan());
328  }
329}
330
331SBThreadPlan
332SBThreadPlan::QueueThreadPlanForRunToAddress(SBAddress sb_address) {
333  LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
334                     QueueThreadPlanForRunToAddress, (lldb::SBAddress),
335                     sb_address);
336
337  SBError error;
338  return LLDB_RECORD_RESULT(QueueThreadPlanForRunToAddress(sb_address, error));
339}
340
341SBThreadPlan SBThreadPlan::QueueThreadPlanForRunToAddress(SBAddress sb_address,
342                                                          SBError &error) {
343  LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
344                     QueueThreadPlanForRunToAddress,
345                     (lldb::SBAddress, lldb::SBError &), sb_address, error);
346
347  if (m_opaque_sp) {
348    Address *address = sb_address.get();
349    if (!address)
350      return LLDB_RECORD_RESULT(SBThreadPlan());
351
352    Status plan_status;
353    SBThreadPlan plan =
354        SBThreadPlan(m_opaque_sp->GetThread().QueueThreadPlanForRunToAddress(
355            false, *address, false, plan_status));
356
357    if (plan_status.Fail())
358      error.SetErrorString(plan_status.AsCString());
359
360    return LLDB_RECORD_RESULT(plan);
361  } else {
362    return LLDB_RECORD_RESULT(SBThreadPlan());
363  }
364}
365
366SBThreadPlan
367SBThreadPlan::QueueThreadPlanForStepScripted(const char *script_class_name) {
368  LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
369                     QueueThreadPlanForStepScripted, (const char *),
370                     script_class_name);
371
372  SBError error;
373  return LLDB_RECORD_RESULT(
374      QueueThreadPlanForStepScripted(script_class_name, error));
375}
376
377SBThreadPlan
378SBThreadPlan::QueueThreadPlanForStepScripted(const char *script_class_name,
379                                             SBError &error) {
380  LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
381                     QueueThreadPlanForStepScripted,
382                     (const char *, lldb::SBError &), script_class_name, error);
383
384  if (m_opaque_sp) {
385    Status plan_status;
386    StructuredData::ObjectSP empty_args;
387    SBThreadPlan plan =
388        SBThreadPlan(m_opaque_sp->GetThread().QueueThreadPlanForStepScripted(
389            false, script_class_name, empty_args, false, plan_status));
390
391    if (plan_status.Fail())
392      error.SetErrorString(plan_status.AsCString());
393
394    return LLDB_RECORD_RESULT(plan);
395  } else {
396    return LLDB_RECORD_RESULT(SBThreadPlan());
397  }
398}
399
400SBThreadPlan
401SBThreadPlan::QueueThreadPlanForStepScripted(const char *script_class_name,
402                                             lldb::SBStructuredData &args_data,
403                                             SBError &error) {
404  LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
405                     QueueThreadPlanForStepScripted,
406                     (const char *, lldb::SBStructuredData &, lldb::SBError &),
407                     script_class_name, args_data, error);
408
409  if (m_opaque_sp) {
410    Status plan_status;
411    StructuredData::ObjectSP args_obj = args_data.m_impl_up->GetObjectSP();
412    SBThreadPlan plan =
413        SBThreadPlan(m_opaque_sp->GetThread().QueueThreadPlanForStepScripted(
414            false, script_class_name, args_obj, false, plan_status));
415
416    if (plan_status.Fail())
417      error.SetErrorString(plan_status.AsCString());
418
419    return LLDB_RECORD_RESULT(plan);
420  } else {
421    return LLDB_RECORD_RESULT(SBThreadPlan());
422  }
423}
424
425namespace lldb_private {
426namespace repro {
427
428template <>
429void RegisterMethods<SBThreadPlan>(Registry &R) {
430  LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, ());
431  LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (const lldb::ThreadPlanSP &));
432  LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (const lldb::SBThreadPlan &));
433  LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (lldb::SBThread &, const char *));
434  LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (lldb::SBThread &, const char *,
435                       lldb::SBStructuredData &));
436  LLDB_REGISTER_METHOD(const lldb::SBThreadPlan &,
437                       SBThreadPlan, operator=,(const lldb::SBThreadPlan &));
438  LLDB_REGISTER_METHOD_CONST(bool, SBThreadPlan, IsValid, ());
439  LLDB_REGISTER_METHOD_CONST(bool, SBThreadPlan, operator bool, ());
440  LLDB_REGISTER_METHOD(void, SBThreadPlan, Clear, ());
441  LLDB_REGISTER_METHOD(lldb::StopReason, SBThreadPlan, GetStopReason, ());
442  LLDB_REGISTER_METHOD(size_t, SBThreadPlan, GetStopReasonDataCount, ());
443  LLDB_REGISTER_METHOD(uint64_t, SBThreadPlan, GetStopReasonDataAtIndex,
444                       (uint32_t));
445  LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBThreadPlan, GetThread, ());
446  LLDB_REGISTER_METHOD_CONST(bool, SBThreadPlan, GetDescription,
447                             (lldb::SBStream &));
448  LLDB_REGISTER_METHOD(void, SBThreadPlan, SetPlanComplete, (bool));
449  LLDB_REGISTER_METHOD(bool, SBThreadPlan, IsPlanComplete, ());
450  LLDB_REGISTER_METHOD(bool, SBThreadPlan, IsPlanStale, ());
451  LLDB_REGISTER_METHOD(bool, SBThreadPlan, IsValid, ());
452  LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
453                       QueueThreadPlanForStepOverRange,
454                       (lldb::SBAddress &, lldb::addr_t));
455  LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
456                       QueueThreadPlanForStepOverRange,
457                       (lldb::SBAddress &, lldb::addr_t, lldb::SBError &));
458  LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
459                       QueueThreadPlanForStepInRange,
460                       (lldb::SBAddress &, lldb::addr_t));
461  LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
462                       QueueThreadPlanForStepInRange,
463                       (lldb::SBAddress &, lldb::addr_t, lldb::SBError &));
464  LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
465                       QueueThreadPlanForStepOut, (uint32_t, bool));
466  LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
467                       QueueThreadPlanForStepOut,
468                       (uint32_t, bool, lldb::SBError &));
469  LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
470                       QueueThreadPlanForRunToAddress, (lldb::SBAddress));
471  LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
472                       QueueThreadPlanForRunToAddress,
473                       (lldb::SBAddress, lldb::SBError &));
474  LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
475                       QueueThreadPlanForStepScripted, (const char *));
476  LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
477                       QueueThreadPlanForStepScripted,
478                       (const char *, lldb::SBError &));
479  LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
480                       QueueThreadPlanForStepScripted,
481                       (const char *, lldb::SBStructuredData &,
482                       lldb::SBError &));
483}
484
485}
486}
487