LLDB  mainline
CommandObjectThread.cpp
Go to the documentation of this file.
1 //===-- CommandObjectThread.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 "CommandObjectThread.h"
10 
12 #include "lldb/Core/ValueObject.h"
13 #include "lldb/Host/Host.h"
14 #include "lldb/Host/OptionParser.h"
21 #include "lldb/Symbol/Function.h"
22 #include "lldb/Symbol/LineEntry.h"
23 #include "lldb/Symbol/LineTable.h"
24 #include "lldb/Target/Process.h"
27 #include "lldb/Target/Target.h"
28 #include "lldb/Target/Thread.h"
29 #include "lldb/Target/ThreadPlan.h"
34 #include "lldb/Utility/State.h"
35 #include "lldb/lldb-private.h"
36 
37 using namespace lldb;
38 using namespace lldb_private;
39 
40 // CommandObjectIterateOverThreads
41 
43 
44  class UniqueStack {
45 
46  public:
47  UniqueStack(std::stack<lldb::addr_t> stack_frames, uint32_t thread_index_id)
48  : m_stack_frames(stack_frames) {
49  m_thread_index_ids.push_back(thread_index_id);
50  }
51 
52  void AddThread(uint32_t thread_index_id) const {
53  m_thread_index_ids.push_back(thread_index_id);
54  }
55 
56  const std::vector<uint32_t> &GetUniqueThreadIndexIDs() const {
57  return m_thread_index_ids;
58  }
59 
60  lldb::tid_t GetRepresentativeThread() const {
61  return m_thread_index_ids.front();
62  }
63 
64  friend bool inline operator<(const UniqueStack &lhs,
65  const UniqueStack &rhs) {
66  return lhs.m_stack_frames < rhs.m_stack_frames;
67  }
68 
69  protected:
70  // Mark the thread index as mutable, as we don't care about it from a const
71  // perspective, we only care about m_stack_frames so we keep our std::set
72  // sorted.
73  mutable std::vector<uint32_t> m_thread_index_ids;
74  std::stack<lldb::addr_t> m_stack_frames;
75  };
76 
77 public:
79  const char *name, const char *help,
80  const char *syntax, uint32_t flags)
81  : CommandObjectParsed(interpreter, name, help, syntax, flags) {}
82 
83  ~CommandObjectIterateOverThreads() override = default;
84 
85  bool DoExecute(Args &command, CommandReturnObject &result) override {
86  result.SetStatus(m_success_return);
87 
88  bool all_threads = false;
89  if (command.GetArgumentCount() == 0) {
90  Thread *thread = m_exe_ctx.GetThreadPtr();
91  if (!thread || !HandleOneThread(thread->GetID(), result))
92  return false;
93  return result.Succeeded();
94  } else if (command.GetArgumentCount() == 1) {
95  all_threads = ::strcmp(command.GetArgumentAtIndex(0), "all") == 0;
96  m_unique_stacks = ::strcmp(command.GetArgumentAtIndex(0), "unique") == 0;
97  }
98 
99  // Use tids instead of ThreadSPs to prevent deadlocking problems which
100  // result from JIT-ing code while iterating over the (locked) ThreadSP
101  // list.
102  std::vector<lldb::tid_t> tids;
103 
104  if (all_threads || m_unique_stacks) {
105  Process *process = m_exe_ctx.GetProcessPtr();
106 
107  for (ThreadSP thread_sp : process->Threads())
108  tids.push_back(thread_sp->GetID());
109  } else {
110  const size_t num_args = command.GetArgumentCount();
111  Process *process = m_exe_ctx.GetProcessPtr();
112 
113  std::lock_guard<std::recursive_mutex> guard(
114  process->GetThreadList().GetMutex());
115 
116  for (size_t i = 0; i < num_args; i++) {
117  bool success;
118 
119  uint32_t thread_idx = StringConvert::ToUInt32(
120  command.GetArgumentAtIndex(i), 0, 0, &success);
121  if (!success) {
122  result.AppendErrorWithFormat("invalid thread specification: \"%s\"\n",
123  command.GetArgumentAtIndex(i));
125  return false;
126  }
127 
128  ThreadSP thread =
129  process->GetThreadList().FindThreadByIndexID(thread_idx);
130 
131  if (!thread) {
132  result.AppendErrorWithFormat("no thread with index: \"%s\"\n",
133  command.GetArgumentAtIndex(i));
135  return false;
136  }
137 
138  tids.push_back(thread->GetID());
139  }
140  }
141 
142  if (m_unique_stacks) {
143  // Iterate over threads, finding unique stack buckets.
144  std::set<UniqueStack> unique_stacks;
145  for (const lldb::tid_t &tid : tids) {
146  if (!BucketThread(tid, unique_stacks, result)) {
147  return false;
148  }
149  }
150 
151  // Write the thread id's and unique call stacks to the output stream
152  Stream &strm = result.GetOutputStream();
153  Process *process = m_exe_ctx.GetProcessPtr();
154  for (const UniqueStack &stack : unique_stacks) {
155  // List the common thread ID's
156  const std::vector<uint32_t> &thread_index_ids =
157  stack.GetUniqueThreadIndexIDs();
158  strm.Format("{0} thread(s) ", thread_index_ids.size());
159  for (const uint32_t &thread_index_id : thread_index_ids) {
160  strm.Format("#{0} ", thread_index_id);
161  }
162  strm.EOL();
163 
164  // List the shared call stack for this set of threads
165  uint32_t representative_thread_id = stack.GetRepresentativeThread();
166  ThreadSP thread = process->GetThreadList().FindThreadByIndexID(
167  representative_thread_id);
168  if (!HandleOneThread(thread->GetID(), result)) {
169  return false;
170  }
171  }
172  } else {
173  uint32_t idx = 0;
174  for (const lldb::tid_t &tid : tids) {
175  if (idx != 0 && m_add_return)
176  result.AppendMessage("");
177 
178  if (!HandleOneThread(tid, result))
179  return false;
180 
181  ++idx;
182  }
183  }
184  return result.Succeeded();
185  }
186 
187 protected:
188  // Override this to do whatever you need to do for one thread.
189  //
190  // If you return false, the iteration will stop, otherwise it will proceed.
191  // The result is set to m_success_return (defaults to
192  // eReturnStatusSuccessFinishResult) before the iteration, so you only need
193  // to set the return status in HandleOneThread if you want to indicate an
194  // error. If m_add_return is true, a blank line will be inserted between each
195  // of the listings (except the last one.)
196 
197  virtual bool HandleOneThread(lldb::tid_t, CommandReturnObject &result) = 0;
198 
199  bool BucketThread(lldb::tid_t tid, std::set<UniqueStack> &unique_stacks,
200  CommandReturnObject &result) {
201  // Grab the corresponding thread for the given thread id.
202  Process *process = m_exe_ctx.GetProcessPtr();
203  Thread *thread = process->GetThreadList().FindThreadByID(tid).get();
204  if (thread == nullptr) {
205  result.AppendErrorWithFormatv("Failed to process thread #{0}.\n", tid);
207  return false;
208  }
209 
210  // Collect the each frame's address for this call-stack
211  std::stack<lldb::addr_t> stack_frames;
212  const uint32_t frame_count = thread->GetStackFrameCount();
213  for (uint32_t frame_index = 0; frame_index < frame_count; frame_index++) {
214  const lldb::StackFrameSP frame_sp =
215  thread->GetStackFrameAtIndex(frame_index);
216  const lldb::addr_t pc = frame_sp->GetStackID().GetPC();
217  stack_frames.push(pc);
218  }
219 
220  uint32_t thread_index_id = thread->GetIndexID();
221  UniqueStack new_unique_stack(stack_frames, thread_index_id);
222 
223  // Try to match the threads stack to and existing entry.
224  std::set<UniqueStack>::iterator matching_stack =
225  unique_stacks.find(new_unique_stack);
226  if (matching_stack != unique_stacks.end()) {
227  matching_stack->AddThread(thread_index_id);
228  } else {
229  unique_stacks.insert(new_unique_stack);
230  }
231  return true;
232  }
233 
235  bool m_unique_stacks = false;
236  bool m_add_return = true;
237 };
238 
239 // CommandObjectThreadBacktrace
240 
241 static constexpr OptionDefinition g_thread_backtrace_options[] = {
242  // clang-format off
243  { LLDB_OPT_SET_1, false, "count", 'c', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeCount, "How many frames to display (-1 for all)" },
244  { LLDB_OPT_SET_1, false, "start", 's', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeFrameIndex, "Frame in which to start the backtrace" },
245  { LLDB_OPT_SET_1, false, "extended", 'e', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeBoolean, "Show the extended backtrace, if available" }
246  // clang-format on
247 };
248 
250 public:
251  class CommandOptions : public Options {
252  public:
254  // Keep default values of all options in one place: OptionParsingStarting
255  // ()
256  OptionParsingStarting(nullptr);
257  }
258 
259  ~CommandOptions() override = default;
260 
261  Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
262  ExecutionContext *execution_context) override {
263  Status error;
264  const int short_option = m_getopt_table[option_idx].val;
265 
266  switch (short_option) {
267  case 'c': {
268  int32_t input_count = 0;
269  if (option_arg.getAsInteger(0, m_count)) {
270  m_count = UINT32_MAX;
272  "invalid integer value for option '%c'", short_option);
273  } else if (input_count < 0)
274  m_count = UINT32_MAX;
275  } break;
276  case 's':
277  if (option_arg.getAsInteger(0, m_start))
279  "invalid integer value for option '%c'", short_option);
280  break;
281  case 'e': {
282  bool success;
283  m_extended_backtrace =
284  OptionArgParser::ToBoolean(option_arg, false, &success);
285  if (!success)
287  "invalid boolean value for option '%c'", short_option);
288  } break;
289  default:
290  error.SetErrorStringWithFormat("invalid short option character '%c'",
291  short_option);
292  break;
293  }
294  return error;
295  }
296 
297  void OptionParsingStarting(ExecutionContext *execution_context) override {
298  m_count = UINT32_MAX;
299  m_start = 0;
300  m_extended_backtrace = false;
301  }
302 
303  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
304  return llvm::makeArrayRef(g_thread_backtrace_options);
305  }
306 
307  // Instance variables to hold the values for command options.
311  };
312 
315  interpreter, "thread backtrace",
316  "Show thread call stacks. Defaults to the current thread, thread "
317  "indexes can be specified as arguments.\n"
318  "Use the thread-index \"all\" to see all threads.\n"
319  "Use the thread-index \"unique\" to see threads grouped by unique "
320  "call stacks.\n"
321  "Use 'settings set frame-format' to customize the printing of "
322  "frames in the backtrace and 'settings set thread-format' to "
323  "customize the thread header.",
324  nullptr,
325  eCommandRequiresProcess | eCommandRequiresThread |
326  eCommandTryTargetAPILock | eCommandProcessMustBeLaunched |
327  eCommandProcessMustBePaused),
328  m_options() {}
329 
330  ~CommandObjectThreadBacktrace() override = default;
331 
332  Options *GetOptions() override { return &m_options; }
333 
334 protected:
336  SystemRuntime *runtime = thread->GetProcess()->GetSystemRuntime();
337  if (runtime) {
338  Stream &strm = result.GetOutputStream();
339  const std::vector<ConstString> &types =
340  runtime->GetExtendedBacktraceTypes();
341  for (auto type : types) {
342  ThreadSP ext_thread_sp = runtime->GetExtendedBacktraceThread(
343  thread->shared_from_this(), type);
344  if (ext_thread_sp && ext_thread_sp->IsValid()) {
345  const uint32_t num_frames_with_source = 0;
346  const bool stop_format = false;
347  if (ext_thread_sp->GetStatus(strm, m_options.m_start,
348  m_options.m_count,
349  num_frames_with_source,
350  stop_format)) {
351  DoExtendedBacktrace(ext_thread_sp.get(), result);
352  }
353  }
354  }
355  }
356  }
357 
358  bool HandleOneThread(lldb::tid_t tid, CommandReturnObject &result) override {
359  ThreadSP thread_sp =
360  m_exe_ctx.GetProcessPtr()->GetThreadList().FindThreadByID(tid);
361  if (!thread_sp) {
362  result.AppendErrorWithFormat(
363  "thread disappeared while computing backtraces: 0x%" PRIx64 "\n",
364  tid);
366  return false;
367  }
368 
369  Thread *thread = thread_sp.get();
370 
371  Stream &strm = result.GetOutputStream();
372 
373  // Only dump stack info if we processing unique stacks.
374  const bool only_stacks = m_unique_stacks;
375 
376  // Don't show source context when doing backtraces.
377  const uint32_t num_frames_with_source = 0;
378  const bool stop_format = true;
379  if (!thread->GetStatus(strm, m_options.m_start, m_options.m_count,
380  num_frames_with_source, stop_format, only_stacks)) {
381  result.AppendErrorWithFormat(
382  "error displaying backtrace for thread: \"0x%4.4x\"\n",
383  thread->GetIndexID());
385  return false;
386  }
387  if (m_options.m_extended_backtrace) {
388  DoExtendedBacktrace(thread, result);
389  }
390 
391  return true;
392  }
393 
395 };
396 
398 
399 static constexpr OptionEnumValueElement g_tri_running_mode[] = {
400  {eOnlyThisThread, "this-thread", "Run only this thread"},
401  {eAllThreads, "all-threads", "Run all threads"},
402  {eOnlyDuringStepping, "while-stepping",
403  "Run only this thread while stepping"} };
404 
405 static constexpr OptionEnumValues TriRunningModes() {
406  return OptionEnumValues(g_tri_running_mode);
407 }
408 
409 static constexpr OptionDefinition g_thread_step_scope_options[] = {
410  // clang-format off
411  { LLDB_OPT_SET_1, false, "step-in-avoids-no-debug", 'a', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeBoolean, "A boolean value that sets whether stepping into functions will step over functions with no debug information." },
412  { LLDB_OPT_SET_1, false, "step-out-avoids-no-debug", 'A', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeBoolean, "A boolean value, if true stepping out of functions will continue to step out till it hits a function with debug information." },
413  { LLDB_OPT_SET_1, false, "count", 'c', OptionParser::eRequiredArgument, nullptr, {}, 1, eArgTypeCount, "How many times to perform the stepping operation - currently only supported for step-inst and next-inst." },
414  { LLDB_OPT_SET_1, false, "end-linenumber", 'e', OptionParser::eRequiredArgument, nullptr, {}, 1, eArgTypeLineNum, "The line at which to stop stepping - defaults to the next line and only supported for step-in and step-over. You can also pass the string 'block' to step to the end of the current block. This is particularly useful in conjunction with --step-target to step through a complex calling sequence." },
415  { LLDB_OPT_SET_1, false, "run-mode", 'm', OptionParser::eRequiredArgument, nullptr, TriRunningModes(), 0, eArgTypeRunMode, "Determine how to run other threads while stepping the current thread." },
416  { LLDB_OPT_SET_1, false, "step-over-regexp", 'r', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeRegularExpression, "A regular expression that defines function names to not to stop at when stepping in." },
417  { LLDB_OPT_SET_1, false, "step-in-target", 't', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeFunctionName, "The name of the directly called function step in should stop at when stepping into." },
418  { LLDB_OPT_SET_2, false, "python-class", 'C', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypePythonClass, "The name of the class that will manage this step - only supported for Scripted Step." }
419  // clang-format on
420 };
421 
423 public:
424  class CommandOptions : public Options {
425  public:
427  // Keep default values of all options in one place: OptionParsingStarting
428  // ()
429  OptionParsingStarting(nullptr);
430  }
431 
432  ~CommandOptions() override = default;
433 
434  Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
435  ExecutionContext *execution_context) override {
436  Status error;
437  const int short_option = m_getopt_table[option_idx].val;
438 
439  switch (short_option) {
440  case 'a': {
441  bool success;
442  bool avoid_no_debug =
443  OptionArgParser::ToBoolean(option_arg, true, &success);
444  if (!success)
446  "invalid boolean value for option '%c'", short_option);
447  else {
448  m_step_in_avoid_no_debug =
449  avoid_no_debug ? eLazyBoolYes : eLazyBoolNo;
450  }
451  } break;
452 
453  case 'A': {
454  bool success;
455  bool avoid_no_debug =
456  OptionArgParser::ToBoolean(option_arg, true, &success);
457  if (!success)
459  "invalid boolean value for option '%c'", short_option);
460  else {
461  m_step_out_avoid_no_debug =
462  avoid_no_debug ? eLazyBoolYes : eLazyBoolNo;
463  }
464  } break;
465 
466  case 'c':
467  if (option_arg.getAsInteger(0, m_step_count))
468  error.SetErrorStringWithFormat("invalid step count '%s'",
469  option_arg.str().c_str());
470  break;
471 
472  case 'C':
473  m_class_name.clear();
474  m_class_name.assign(option_arg);
475  break;
476 
477  case 'm': {
478  auto enum_values = GetDefinitions()[option_idx].enum_values;
479  m_run_mode = (lldb::RunMode)OptionArgParser::ToOptionEnum(
480  option_arg, enum_values, eOnlyDuringStepping, error);
481  } break;
482 
483  case 'e':
484  if (option_arg == "block") {
485  m_end_line_is_block_end = 1;
486  break;
487  }
488  if (option_arg.getAsInteger(0, m_end_line))
489  error.SetErrorStringWithFormat("invalid end line number '%s'",
490  option_arg.str().c_str());
491  break;
492 
493  case 'r':
494  m_avoid_regexp.clear();
495  m_avoid_regexp.assign(option_arg);
496  break;
497 
498  case 't':
499  m_step_in_target.clear();
500  m_step_in_target.assign(option_arg);
501  break;
502 
503  default:
504  error.SetErrorStringWithFormat("invalid short option character '%c'",
505  short_option);
506  break;
507  }
508  return error;
509  }
510 
511  void OptionParsingStarting(ExecutionContext *execution_context) override {
512  m_step_in_avoid_no_debug = eLazyBoolCalculate;
513  m_step_out_avoid_no_debug = eLazyBoolCalculate;
514  m_run_mode = eOnlyDuringStepping;
515 
516  // Check if we are in Non-Stop mode
517  TargetSP target_sp =
518  execution_context ? execution_context->GetTargetSP() : TargetSP();
519  if (target_sp && target_sp->GetNonStopModeEnabled())
520  m_run_mode = eOnlyThisThread;
521 
522  m_avoid_regexp.clear();
523  m_step_in_target.clear();
524  m_class_name.clear();
525  m_step_count = 1;
526  m_end_line = LLDB_INVALID_LINE_NUMBER;
527  m_end_line_is_block_end = false;
528  }
529 
530  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
531  return llvm::makeArrayRef(g_thread_step_scope_options);
532  }
533 
534  // Instance variables to hold the values for command options.
538  std::string m_avoid_regexp;
539  std::string m_step_in_target;
540  std::string m_class_name;
544  };
545 
547  const char *name, const char *help,
548  const char *syntax,
549  StepType step_type,
550  StepScope step_scope)
551  : CommandObjectParsed(interpreter, name, help, syntax,
552  eCommandRequiresProcess | eCommandRequiresThread |
553  eCommandTryTargetAPILock |
554  eCommandProcessMustBeLaunched |
555  eCommandProcessMustBePaused),
556  m_step_type(step_type), m_step_scope(step_scope), m_options() {
558  CommandArgumentData thread_id_arg;
559 
560  // Define the first (and only) variant of this arg.
561  thread_id_arg.arg_type = eArgTypeThreadID;
562  thread_id_arg.arg_repetition = eArgRepeatOptional;
563 
564  // There is only one variant this argument could be; put it into the
565  // argument entry.
566  arg.push_back(thread_id_arg);
567 
568  // Push the data for the first argument into the m_arguments vector.
569  m_arguments.push_back(arg);
570  }
571 
572  ~CommandObjectThreadStepWithTypeAndScope() override = default;
573 
574  Options *GetOptions() override { return &m_options; }
575 
576 protected:
577  bool DoExecute(Args &command, CommandReturnObject &result) override {
578  Process *process = m_exe_ctx.GetProcessPtr();
579  bool synchronous_execution = m_interpreter.GetSynchronous();
580 
581  const uint32_t num_threads = process->GetThreadList().GetSize();
582  Thread *thread = nullptr;
583 
584  if (command.GetArgumentCount() == 0) {
585  thread = GetDefaultThread();
586 
587  if (thread == nullptr) {
588  result.AppendError("no selected thread in process");
590  return false;
591  }
592  } else {
593  const char *thread_idx_cstr = command.GetArgumentAtIndex(0);
594  uint32_t step_thread_idx =
596  if (step_thread_idx == LLDB_INVALID_INDEX32) {
597  result.AppendErrorWithFormat("invalid thread index '%s'.\n",
598  thread_idx_cstr);
600  return false;
601  }
602  thread =
603  process->GetThreadList().FindThreadByIndexID(step_thread_idx).get();
604  if (thread == nullptr) {
605  result.AppendErrorWithFormat(
606  "Thread index %u is out of range (valid values are 0 - %u).\n",
607  step_thread_idx, num_threads);
609  return false;
610  }
611  }
612 
613  if (m_step_type == eStepTypeScripted) {
614  if (m_options.m_class_name.empty()) {
615  result.AppendErrorWithFormat("empty class name for scripted step.");
617  return false;
618  } else if (!GetDebugger().GetScriptInterpreter()->CheckObjectExists(
619  m_options.m_class_name.c_str())) {
620  result.AppendErrorWithFormat(
621  "class for scripted step: \"%s\" does not exist.",
622  m_options.m_class_name.c_str());
624  return false;
625  }
626  }
627 
628  if (m_options.m_end_line != LLDB_INVALID_LINE_NUMBER &&
629  m_step_type != eStepTypeInto) {
630  result.AppendErrorWithFormat(
631  "end line option is only valid for step into");
633  return false;
634  }
635 
636  const bool abort_other_plans = false;
637  const lldb::RunMode stop_other_threads = m_options.m_run_mode;
638 
639  // This is a bit unfortunate, but not all the commands in this command
640  // object support only while stepping, so I use the bool for them.
641  bool bool_stop_other_threads;
642  if (m_options.m_run_mode == eAllThreads)
643  bool_stop_other_threads = false;
644  else if (m_options.m_run_mode == eOnlyDuringStepping)
645  bool_stop_other_threads =
646  (m_step_type != eStepTypeOut && m_step_type != eStepTypeScripted);
647  else
648  bool_stop_other_threads = true;
649 
650  ThreadPlanSP new_plan_sp;
651  Status new_plan_status;
652 
653  if (m_step_type == eStepTypeInto) {
654  StackFrame *frame = thread->GetStackFrameAtIndex(0).get();
655  assert(frame != nullptr);
656 
657  if (frame->HasDebugInformation()) {
658  AddressRange range;
659  SymbolContext sc = frame->GetSymbolContext(eSymbolContextEverything);
660  if (m_options.m_end_line != LLDB_INVALID_LINE_NUMBER) {
661  Status error;
662  if (!sc.GetAddressRangeFromHereToEndLine(m_options.m_end_line, range,
663  error)) {
664  result.AppendErrorWithFormat("invalid end-line option: %s.",
665  error.AsCString());
667  return false;
668  }
669  } else if (m_options.m_end_line_is_block_end) {
670  Status error;
671  Block *block = frame->GetSymbolContext(eSymbolContextBlock).block;
672  if (!block) {
673  result.AppendErrorWithFormat("Could not find the current block.");
675  return false;
676  }
677 
678  AddressRange block_range;
679  Address pc_address = frame->GetFrameCodeAddress();
680  block->GetRangeContainingAddress(pc_address, block_range);
681  if (!block_range.GetBaseAddress().IsValid()) {
682  result.AppendErrorWithFormat(
683  "Could not find the current block address.");
685  return false;
686  }
687  lldb::addr_t pc_offset_in_block =
688  pc_address.GetFileAddress() -
689  block_range.GetBaseAddress().GetFileAddress();
690  lldb::addr_t range_length =
691  block_range.GetByteSize() - pc_offset_in_block;
692  range = AddressRange(pc_address, range_length);
693  } else {
694  range = sc.line_entry.range;
695  }
696 
697  new_plan_sp = thread->QueueThreadPlanForStepInRange(
698  abort_other_plans, range,
699  frame->GetSymbolContext(eSymbolContextEverything),
700  m_options.m_step_in_target.c_str(), stop_other_threads,
701  new_plan_status, m_options.m_step_in_avoid_no_debug,
702  m_options.m_step_out_avoid_no_debug);
703 
704  if (new_plan_sp && !m_options.m_avoid_regexp.empty()) {
705  ThreadPlanStepInRange *step_in_range_plan =
706  static_cast<ThreadPlanStepInRange *>(new_plan_sp.get());
707  step_in_range_plan->SetAvoidRegexp(m_options.m_avoid_regexp.c_str());
708  }
709  } else
710  new_plan_sp = thread->QueueThreadPlanForStepSingleInstruction(
711  false, abort_other_plans, bool_stop_other_threads, new_plan_status);
712  } else if (m_step_type == eStepTypeOver) {
713  StackFrame *frame = thread->GetStackFrameAtIndex(0).get();
714 
715  if (frame->HasDebugInformation())
716  new_plan_sp = thread->QueueThreadPlanForStepOverRange(
717  abort_other_plans,
718  frame->GetSymbolContext(eSymbolContextEverything).line_entry,
719  frame->GetSymbolContext(eSymbolContextEverything),
720  stop_other_threads, new_plan_status,
721  m_options.m_step_out_avoid_no_debug);
722  else
723  new_plan_sp = thread->QueueThreadPlanForStepSingleInstruction(
724  true, abort_other_plans, bool_stop_other_threads, new_plan_status);
725  } else if (m_step_type == eStepTypeTrace) {
726  new_plan_sp = thread->QueueThreadPlanForStepSingleInstruction(
727  false, abort_other_plans, bool_stop_other_threads, new_plan_status);
728  } else if (m_step_type == eStepTypeTraceOver) {
729  new_plan_sp = thread->QueueThreadPlanForStepSingleInstruction(
730  true, abort_other_plans, bool_stop_other_threads, new_plan_status);
731  } else if (m_step_type == eStepTypeOut) {
732  new_plan_sp = thread->QueueThreadPlanForStepOut(
733  abort_other_plans, nullptr, false, bool_stop_other_threads, eVoteYes,
734  eVoteNoOpinion, thread->GetSelectedFrameIndex(), new_plan_status,
735  m_options.m_step_out_avoid_no_debug);
736  } else if (m_step_type == eStepTypeScripted) {
737  new_plan_sp = thread->QueueThreadPlanForStepScripted(
738  abort_other_plans, m_options.m_class_name.c_str(),
739  bool_stop_other_threads, new_plan_status);
740  } else {
741  result.AppendError("step type is not supported");
743  return false;
744  }
745 
746  // If we got a new plan, then set it to be a master plan (User level Plans
747  // should be master plans so that they can be interruptible). Then resume
748  // the process.
749 
750  if (new_plan_sp) {
751  new_plan_sp->SetIsMasterPlan(true);
752  new_plan_sp->SetOkayToDiscard(false);
753 
754  if (m_options.m_step_count > 1) {
755  if (!new_plan_sp->SetIterationCount(m_options.m_step_count)) {
756  result.AppendWarning(
757  "step operation does not support iteration count.");
758  }
759  }
760 
761  process->GetThreadList().SetSelectedThreadByID(thread->GetID());
762 
763  const uint32_t iohandler_id = process->GetIOHandlerID();
764 
765  StreamString stream;
766  Status error;
767  if (synchronous_execution)
768  error = process->ResumeSynchronous(&stream);
769  else
770  error = process->Resume();
771 
772  if (!error.Success()) {
773  result.AppendMessage(error.AsCString());
775  return false;
776  }
777 
778  // There is a race condition where this thread will return up the call
779  // stack to the main command handler and show an (lldb) prompt before
780  // HandlePrivateEvent (from PrivateStateThread) has a chance to call
781  // PushProcessIOHandler().
782  process->SyncIOHandler(iohandler_id, std::chrono::seconds(2));
783 
784  if (synchronous_execution) {
785  // If any state changed events had anything to say, add that to the
786  // result
787  if (stream.GetSize() > 0)
788  result.AppendMessage(stream.GetString());
789 
790  process->GetThreadList().SetSelectedThreadByID(thread->GetID());
791  result.SetDidChangeProcessState(true);
793  } else {
795  }
796  } else {
797  result.SetError(new_plan_status);
799  }
800  return result.Succeeded();
801  }
802 
803 protected:
807 };
808 
809 // CommandObjectThreadContinue
810 
812 public:
815  interpreter, "thread continue",
816  "Continue execution of the current target process. One "
817  "or more threads may be specified, by default all "
818  "threads continue.",
819  nullptr,
820  eCommandRequiresThread | eCommandTryTargetAPILock |
821  eCommandProcessMustBeLaunched | eCommandProcessMustBePaused) {
823  CommandArgumentData thread_idx_arg;
824 
825  // Define the first (and only) variant of this arg.
826  thread_idx_arg.arg_type = eArgTypeThreadIndex;
827  thread_idx_arg.arg_repetition = eArgRepeatPlus;
828 
829  // There is only one variant this argument could be; put it into the
830  // argument entry.
831  arg.push_back(thread_idx_arg);
832 
833  // Push the data for the first argument into the m_arguments vector.
834  m_arguments.push_back(arg);
835  }
836 
837  ~CommandObjectThreadContinue() override = default;
838 
839  bool DoExecute(Args &command, CommandReturnObject &result) override {
840  bool synchronous_execution = m_interpreter.GetSynchronous();
841 
842  if (!GetDebugger().GetSelectedTarget()) {
843  result.AppendError("invalid target, create a debug target using the "
844  "'target create' command");
846  return false;
847  }
848 
849  Process *process = m_exe_ctx.GetProcessPtr();
850  if (process == nullptr) {
851  result.AppendError("no process exists. Cannot continue");
853  return false;
854  }
855 
856  StateType state = process->GetState();
857  if ((state == eStateCrashed) || (state == eStateStopped) ||
858  (state == eStateSuspended)) {
859  const size_t argc = command.GetArgumentCount();
860  if (argc > 0) {
861  // These two lines appear at the beginning of both blocks in this
862  // if..else, but that is because we need to release the lock before
863  // calling process->Resume below.
864  std::lock_guard<std::recursive_mutex> guard(
865  process->GetThreadList().GetMutex());
866  const uint32_t num_threads = process->GetThreadList().GetSize();
867  std::vector<Thread *> resume_threads;
868  for (auto &entry : command.entries()) {
869  uint32_t thread_idx;
870  if (entry.ref.getAsInteger(0, thread_idx)) {
871  result.AppendErrorWithFormat(
872  "invalid thread index argument: \"%s\".\n", entry.c_str());
874  return false;
875  }
876  Thread *thread =
877  process->GetThreadList().FindThreadByIndexID(thread_idx).get();
878 
879  if (thread) {
880  resume_threads.push_back(thread);
881  } else {
882  result.AppendErrorWithFormat("invalid thread index %u.\n",
883  thread_idx);
885  return false;
886  }
887  }
888 
889  if (resume_threads.empty()) {
890  result.AppendError("no valid thread indexes were specified");
892  return false;
893  } else {
894  if (resume_threads.size() == 1)
895  result.AppendMessageWithFormat("Resuming thread: ");
896  else
897  result.AppendMessageWithFormat("Resuming threads: ");
898 
899  for (uint32_t idx = 0; idx < num_threads; ++idx) {
900  Thread *thread =
901  process->GetThreadList().GetThreadAtIndex(idx).get();
902  std::vector<Thread *>::iterator this_thread_pos =
903  find(resume_threads.begin(), resume_threads.end(), thread);
904 
905  if (this_thread_pos != resume_threads.end()) {
906  resume_threads.erase(this_thread_pos);
907  if (!resume_threads.empty())
908  result.AppendMessageWithFormat("%u, ", thread->GetIndexID());
909  else
910  result.AppendMessageWithFormat("%u ", thread->GetIndexID());
911 
912  const bool override_suspend = true;
913  thread->SetResumeState(eStateRunning, override_suspend);
914  } else {
916  }
917  }
918  result.AppendMessageWithFormat("in process %" PRIu64 "\n",
919  process->GetID());
920  }
921  } else {
922  // These two lines appear at the beginning of both blocks in this
923  // if..else, but that is because we need to release the lock before
924  // calling process->Resume below.
925  std::lock_guard<std::recursive_mutex> guard(
926  process->GetThreadList().GetMutex());
927  const uint32_t num_threads = process->GetThreadList().GetSize();
928  Thread *current_thread = GetDefaultThread();
929  if (current_thread == nullptr) {
930  result.AppendError("the process doesn't have a current thread");
932  return false;
933  }
934  // Set the actions that the threads should each take when resuming
935  for (uint32_t idx = 0; idx < num_threads; ++idx) {
936  Thread *thread = process->GetThreadList().GetThreadAtIndex(idx).get();
937  if (thread == current_thread) {
938  result.AppendMessageWithFormat("Resuming thread 0x%4.4" PRIx64
939  " in process %" PRIu64 "\n",
940  thread->GetID(), process->GetID());
941  const bool override_suspend = true;
942  thread->SetResumeState(eStateRunning, override_suspend);
943  } else {
945  }
946  }
947  }
948 
949  StreamString stream;
950  Status error;
951  if (synchronous_execution)
952  error = process->ResumeSynchronous(&stream);
953  else
954  error = process->Resume();
955 
956  // We should not be holding the thread list lock when we do this.
957  if (error.Success()) {
958  result.AppendMessageWithFormat("Process %" PRIu64 " resuming\n",
959  process->GetID());
960  if (synchronous_execution) {
961  // If any state changed events had anything to say, add that to the
962  // result
963  if (stream.GetSize() > 0)
964  result.AppendMessage(stream.GetString());
965 
966  result.SetDidChangeProcessState(true);
968  } else {
970  }
971  } else {
972  result.AppendErrorWithFormat("Failed to resume process: %s\n",
973  error.AsCString());
975  }
976  } else {
977  result.AppendErrorWithFormat(
978  "Process cannot be continued from its current state (%s).\n",
979  StateAsCString(state));
981  }
982 
983  return result.Succeeded();
984  }
985 };
986 
987 // CommandObjectThreadUntil
988 
989 static constexpr OptionEnumValueElement g_duo_running_mode[] = {
990  {eOnlyThisThread, "this-thread", "Run only this thread"},
991  {eAllThreads, "all-threads", "Run all threads"} };
992 
993 static constexpr OptionEnumValues DuoRunningModes() {
994  return OptionEnumValues(g_duo_running_mode);
995 }
996 
997 static constexpr OptionDefinition g_thread_until_options[] = {
998  // clang-format off
999  { LLDB_OPT_SET_1, false, "frame", 'f', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeFrameIndex, "Frame index for until operation - defaults to 0" },
1000  { LLDB_OPT_SET_1, false, "thread", 't', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeThreadIndex, "Thread index for the thread for until operation" },
1001  { LLDB_OPT_SET_1, false, "run-mode",'m', OptionParser::eRequiredArgument, nullptr, DuoRunningModes(), 0, eArgTypeRunMode, "Determine how to run other threads while stepping this one" },
1002  { LLDB_OPT_SET_1, false, "address", 'a', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeAddressOrExpression, "Run until we reach the specified address, or leave the function - can be specified multiple times." }
1003  // clang-format on
1004 };
1005 
1007 public:
1008  class CommandOptions : public Options {
1009  public:
1012 
1014  : Options(), m_thread_idx(LLDB_INVALID_THREAD_ID),
1015  m_frame_idx(LLDB_INVALID_FRAME_ID) {
1016  // Keep default values of all options in one place: OptionParsingStarting
1017  // ()
1018  OptionParsingStarting(nullptr);
1019  }
1020 
1021  ~CommandOptions() override = default;
1022 
1023  Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
1024  ExecutionContext *execution_context) override {
1025  Status error;
1026  const int short_option = m_getopt_table[option_idx].val;
1027 
1028  switch (short_option) {
1029  case 'a': {
1030  lldb::addr_t tmp_addr = OptionArgParser::ToAddress(
1031  execution_context, option_arg, LLDB_INVALID_ADDRESS, &error);
1032  if (error.Success())
1033  m_until_addrs.push_back(tmp_addr);
1034  } break;
1035  case 't':
1036  if (option_arg.getAsInteger(0, m_thread_idx)) {
1037  m_thread_idx = LLDB_INVALID_INDEX32;
1038  error.SetErrorStringWithFormat("invalid thread index '%s'",
1039  option_arg.str().c_str());
1040  }
1041  break;
1042  case 'f':
1043  if (option_arg.getAsInteger(0, m_frame_idx)) {
1044  m_frame_idx = LLDB_INVALID_FRAME_ID;
1045  error.SetErrorStringWithFormat("invalid frame index '%s'",
1046  option_arg.str().c_str());
1047  }
1048  break;
1049  case 'm': {
1050  auto enum_values = GetDefinitions()[option_idx].enum_values;
1051  lldb::RunMode run_mode = (lldb::RunMode)OptionArgParser::ToOptionEnum(
1052  option_arg, enum_values, eOnlyDuringStepping, error);
1053 
1054  if (error.Success()) {
1055  if (run_mode == eAllThreads)
1056  m_stop_others = false;
1057  else
1058  m_stop_others = true;
1059  }
1060  } break;
1061  default:
1062  error.SetErrorStringWithFormat("invalid short option character '%c'",
1063  short_option);
1064  break;
1065  }
1066  return error;
1067  }
1068 
1069  void OptionParsingStarting(ExecutionContext *execution_context) override {
1070  m_thread_idx = LLDB_INVALID_THREAD_ID;
1071  m_frame_idx = 0;
1072  m_stop_others = false;
1073  m_until_addrs.clear();
1074  }
1075 
1076  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
1077  return llvm::makeArrayRef(g_thread_until_options);
1078  }
1079 
1082  std::vector<lldb::addr_t> m_until_addrs;
1083 
1084  // Instance variables to hold the values for command options.
1085  };
1086 
1089  interpreter, "thread until",
1090  "Continue until a line number or address is reached by the "
1091  "current or specified thread. Stops when returning from "
1092  "the current function as a safety measure. "
1093  "The target line number(s) are given as arguments, and if more than one"
1094  " is provided, stepping will stop when the first one is hit.",
1095  nullptr,
1096  eCommandRequiresThread | eCommandTryTargetAPILock |
1097  eCommandProcessMustBeLaunched | eCommandProcessMustBePaused),
1098  m_options() {
1100  CommandArgumentData line_num_arg;
1101 
1102  // Define the first (and only) variant of this arg.
1103  line_num_arg.arg_type = eArgTypeLineNum;
1104  line_num_arg.arg_repetition = eArgRepeatPlain;
1105 
1106  // There is only one variant this argument could be; put it into the
1107  // argument entry.
1108  arg.push_back(line_num_arg);
1109 
1110  // Push the data for the first argument into the m_arguments vector.
1111  m_arguments.push_back(arg);
1112  }
1113 
1114  ~CommandObjectThreadUntil() override = default;
1115 
1116  Options *GetOptions() override { return &m_options; }
1117 
1118 protected:
1119  bool DoExecute(Args &command, CommandReturnObject &result) override {
1120  bool synchronous_execution = m_interpreter.GetSynchronous();
1121 
1122  Target *target = GetDebugger().GetSelectedTarget().get();
1123  if (target == nullptr) {
1124  result.AppendError("invalid target, create a debug target using the "
1125  "'target create' command");
1127  return false;
1128  }
1129 
1130  Process *process = m_exe_ctx.GetProcessPtr();
1131  if (process == nullptr) {
1132  result.AppendError("need a valid process to step");
1134  } else {
1135  Thread *thread = nullptr;
1136  std::vector<uint32_t> line_numbers;
1137 
1138  if (command.GetArgumentCount() >= 1) {
1139  size_t num_args = command.GetArgumentCount();
1140  for (size_t i = 0; i < num_args; i++) {
1141  uint32_t line_number;
1142  line_number = StringConvert::ToUInt32(command.GetArgumentAtIndex(i),
1143  UINT32_MAX);
1144  if (line_number == UINT32_MAX) {
1145  result.AppendErrorWithFormat("invalid line number: '%s'.\n",
1146  command.GetArgumentAtIndex(i));
1148  return false;
1149  } else
1150  line_numbers.push_back(line_number);
1151  }
1152  } else if (m_options.m_until_addrs.empty()) {
1153  result.AppendErrorWithFormat("No line number or address provided:\n%s",
1154  GetSyntax().str().c_str());
1156  return false;
1157  }
1158 
1159  if (m_options.m_thread_idx == LLDB_INVALID_THREAD_ID) {
1160  thread = GetDefaultThread();
1161  } else {
1162  thread = process->GetThreadList()
1163  .FindThreadByIndexID(m_options.m_thread_idx)
1164  .get();
1165  }
1166 
1167  if (thread == nullptr) {
1168  const uint32_t num_threads = process->GetThreadList().GetSize();
1169  result.AppendErrorWithFormat(
1170  "Thread index %u is out of range (valid values are 0 - %u).\n",
1171  m_options.m_thread_idx, num_threads);
1173  return false;
1174  }
1175 
1176  const bool abort_other_plans = false;
1177 
1178  StackFrame *frame =
1179  thread->GetStackFrameAtIndex(m_options.m_frame_idx).get();
1180  if (frame == nullptr) {
1181  result.AppendErrorWithFormat(
1182  "Frame index %u is out of range for thread %u.\n",
1183  m_options.m_frame_idx, m_options.m_thread_idx);
1185  return false;
1186  }
1187 
1188  ThreadPlanSP new_plan_sp;
1189  Status new_plan_status;
1190 
1191  if (frame->HasDebugInformation()) {
1192  // Finally we got here... Translate the given line number to a bunch
1193  // of addresses:
1194  SymbolContext sc(frame->GetSymbolContext(eSymbolContextCompUnit));
1195  LineTable *line_table = nullptr;
1196  if (sc.comp_unit)
1197  line_table = sc.comp_unit->GetLineTable();
1198 
1199  if (line_table == nullptr) {
1200  result.AppendErrorWithFormat("Failed to resolve the line table for "
1201  "frame %u of thread index %u.\n",
1202  m_options.m_frame_idx,
1203  m_options.m_thread_idx);
1205  return false;
1206  }
1207 
1208  LineEntry function_start;
1209  uint32_t index_ptr = 0, end_ptr;
1210  std::vector<addr_t> address_list;
1211 
1212  // Find the beginning & end index of the
1213  AddressRange fun_addr_range = sc.function->GetAddressRange();
1214  Address fun_start_addr = fun_addr_range.GetBaseAddress();
1215  line_table->FindLineEntryByAddress(fun_start_addr, function_start,
1216  &index_ptr);
1217 
1218  Address fun_end_addr(fun_start_addr.GetSection(),
1219  fun_start_addr.GetOffset() +
1220  fun_addr_range.GetByteSize());
1221 
1222  bool all_in_function = true;
1223 
1224  line_table->FindLineEntryByAddress(fun_end_addr, function_start,
1225  &end_ptr);
1226 
1227  for (uint32_t line_number : line_numbers) {
1228  uint32_t start_idx_ptr = index_ptr;
1229  while (start_idx_ptr <= end_ptr) {
1230  LineEntry line_entry;
1231  const bool exact = false;
1232  start_idx_ptr = sc.comp_unit->FindLineEntry(
1233  start_idx_ptr, line_number, sc.comp_unit, exact, &line_entry);
1234  if (start_idx_ptr == UINT32_MAX)
1235  break;
1236 
1237  addr_t address =
1238  line_entry.range.GetBaseAddress().GetLoadAddress(target);
1239  if (address != LLDB_INVALID_ADDRESS) {
1240  if (fun_addr_range.ContainsLoadAddress(address, target))
1241  address_list.push_back(address);
1242  else
1243  all_in_function = false;
1244  }
1245  start_idx_ptr++;
1246  }
1247  }
1248 
1249  for (lldb::addr_t address : m_options.m_until_addrs) {
1250  if (fun_addr_range.ContainsLoadAddress(address, target))
1251  address_list.push_back(address);
1252  else
1253  all_in_function = false;
1254  }
1255 
1256  if (address_list.empty()) {
1257  if (all_in_function)
1258  result.AppendErrorWithFormat(
1259  "No line entries matching until target.\n");
1260  else
1261  result.AppendErrorWithFormat(
1262  "Until target outside of the current function.\n");
1263 
1265  return false;
1266  }
1267 
1268  new_plan_sp = thread->QueueThreadPlanForStepUntil(
1269  abort_other_plans, &address_list.front(), address_list.size(),
1270  m_options.m_stop_others, m_options.m_frame_idx, new_plan_status);
1271  if (new_plan_sp) {
1272  // User level plans should be master plans so they can be interrupted
1273  // (e.g. by hitting a breakpoint) and other plans executed by the
1274  // user (stepping around the breakpoint) and then a "continue" will
1275  // resume the original plan.
1276  new_plan_sp->SetIsMasterPlan(true);
1277  new_plan_sp->SetOkayToDiscard(false);
1278  } else {
1279  result.SetError(new_plan_status);
1281  return false;
1282  }
1283  } else {
1284  result.AppendErrorWithFormat(
1285  "Frame index %u of thread %u has no debug information.\n",
1286  m_options.m_frame_idx, m_options.m_thread_idx);
1288  return false;
1289  }
1290 
1291  process->GetThreadList().SetSelectedThreadByID(m_options.m_thread_idx);
1292 
1293  StreamString stream;
1294  Status error;
1295  if (synchronous_execution)
1296  error = process->ResumeSynchronous(&stream);
1297  else
1298  error = process->Resume();
1299 
1300  if (error.Success()) {
1301  result.AppendMessageWithFormat("Process %" PRIu64 " resuming\n",
1302  process->GetID());
1303  if (synchronous_execution) {
1304  // If any state changed events had anything to say, add that to the
1305  // result
1306  if (stream.GetSize() > 0)
1307  result.AppendMessage(stream.GetString());
1308 
1309  result.SetDidChangeProcessState(true);
1311  } else {
1313  }
1314  } else {
1315  result.AppendErrorWithFormat("Failed to resume process: %s.\n",
1316  error.AsCString());
1318  }
1319  }
1320  return result.Succeeded();
1321  }
1322 
1324 };
1325 
1326 // CommandObjectThreadSelect
1327 
1329 public:
1331  : CommandObjectParsed(interpreter, "thread select",
1332  "Change the currently selected thread.", nullptr,
1333  eCommandRequiresProcess | eCommandTryTargetAPILock |
1334  eCommandProcessMustBeLaunched |
1335  eCommandProcessMustBePaused) {
1337  CommandArgumentData thread_idx_arg;
1338 
1339  // Define the first (and only) variant of this arg.
1340  thread_idx_arg.arg_type = eArgTypeThreadIndex;
1341  thread_idx_arg.arg_repetition = eArgRepeatPlain;
1342 
1343  // There is only one variant this argument could be; put it into the
1344  // argument entry.
1345  arg.push_back(thread_idx_arg);
1346 
1347  // Push the data for the first argument into the m_arguments vector.
1348  m_arguments.push_back(arg);
1349  }
1350 
1351  ~CommandObjectThreadSelect() override = default;
1352 
1353 protected:
1354  bool DoExecute(Args &command, CommandReturnObject &result) override {
1355  Process *process = m_exe_ctx.GetProcessPtr();
1356  if (process == nullptr) {
1357  result.AppendError("no process");
1359  return false;
1360  } else if (command.GetArgumentCount() != 1) {
1361  result.AppendErrorWithFormat(
1362  "'%s' takes exactly one thread index argument:\nUsage: %s\n",
1363  m_cmd_name.c_str(), m_cmd_syntax.c_str());
1365  return false;
1366  }
1367 
1368  uint32_t index_id =
1369  StringConvert::ToUInt32(command.GetArgumentAtIndex(0), 0, 0);
1370 
1371  Thread *new_thread =
1372  process->GetThreadList().FindThreadByIndexID(index_id).get();
1373  if (new_thread == nullptr) {
1374  result.AppendErrorWithFormat("invalid thread #%s.\n",
1375  command.GetArgumentAtIndex(0));
1377  return false;
1378  }
1379 
1380  process->GetThreadList().SetSelectedThreadByID(new_thread->GetID(), true);
1382 
1383  return result.Succeeded();
1384  }
1385 };
1386 
1387 // CommandObjectThreadList
1388 
1390 public:
1393  interpreter, "thread list",
1394  "Show a summary of each thread in the current target process. "
1395  "Use 'settings set thread-format' to customize the individual "
1396  "thread listings.",
1397  "thread list",
1398  eCommandRequiresProcess | eCommandTryTargetAPILock |
1399  eCommandProcessMustBeLaunched | eCommandProcessMustBePaused) {}
1400 
1401  ~CommandObjectThreadList() override = default;
1402 
1403 protected:
1404  bool DoExecute(Args &command, CommandReturnObject &result) override {
1405  Stream &strm = result.GetOutputStream();
1407  Process *process = m_exe_ctx.GetProcessPtr();
1408  const bool only_threads_with_stop_reason = false;
1409  const uint32_t start_frame = 0;
1410  const uint32_t num_frames = 0;
1411  const uint32_t num_frames_with_source = 0;
1412  process->GetStatus(strm);
1413  process->GetThreadStatus(strm, only_threads_with_stop_reason, start_frame,
1414  num_frames, num_frames_with_source, false);
1415  return result.Succeeded();
1416  }
1417 };
1418 
1419 // CommandObjectThreadInfo
1420 
1421 static constexpr OptionDefinition g_thread_info_options[] = {
1422  // clang-format off
1423  { LLDB_OPT_SET_ALL, false, "json", 'j', OptionParser::eNoArgument, nullptr, {}, 0, eArgTypeNone, "Display the thread info in JSON format." },
1424  { LLDB_OPT_SET_ALL, false, "stop-info", 's', OptionParser::eNoArgument, nullptr, {}, 0, eArgTypeNone, "Display the extended stop info in JSON format." }
1425  // clang-format on
1426 };
1427 
1429 public:
1430  class CommandOptions : public Options {
1431  public:
1432  CommandOptions() : Options() { OptionParsingStarting(nullptr); }
1433 
1434  ~CommandOptions() override = default;
1435 
1436  void OptionParsingStarting(ExecutionContext *execution_context) override {
1437  m_json_thread = false;
1438  m_json_stopinfo = false;
1439  }
1440 
1441  Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
1442  ExecutionContext *execution_context) override {
1443  const int short_option = m_getopt_table[option_idx].val;
1444  Status error;
1445 
1446  switch (short_option) {
1447  case 'j':
1448  m_json_thread = true;
1449  break;
1450 
1451  case 's':
1452  m_json_stopinfo = true;
1453  break;
1454 
1455  default:
1456  return Status("invalid short option character '%c'", short_option);
1457  }
1458  return error;
1459  }
1460 
1461  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
1462  return llvm::makeArrayRef(g_thread_info_options);
1463  }
1464 
1467  };
1468 
1471  interpreter, "thread info", "Show an extended summary of one or "
1472  "more threads. Defaults to the "
1473  "current thread.",
1474  "thread info",
1475  eCommandRequiresProcess | eCommandTryTargetAPILock |
1476  eCommandProcessMustBeLaunched | eCommandProcessMustBePaused),
1477  m_options() {
1478  m_add_return = false;
1479  }
1480 
1481  ~CommandObjectThreadInfo() override = default;
1482 
1483  Options *GetOptions() override { return &m_options; }
1484 
1485  bool HandleOneThread(lldb::tid_t tid, CommandReturnObject &result) override {
1486  ThreadSP thread_sp =
1487  m_exe_ctx.GetProcessPtr()->GetThreadList().FindThreadByID(tid);
1488  if (!thread_sp) {
1489  result.AppendErrorWithFormat("thread no longer exists: 0x%" PRIx64 "\n",
1490  tid);
1492  return false;
1493  }
1494 
1495  Thread *thread = thread_sp.get();
1496 
1497  Stream &strm = result.GetOutputStream();
1498  if (!thread->GetDescription(strm, eDescriptionLevelFull,
1499  m_options.m_json_thread,
1500  m_options.m_json_stopinfo)) {
1501  result.AppendErrorWithFormat("error displaying info for thread: \"%d\"\n",
1502  thread->GetIndexID());
1504  return false;
1505  }
1506  return true;
1507  }
1508 
1510 };
1511 
1512 // CommandObjectThreadException
1513 
1515  public:
1518  interpreter, "thread exception",
1519  "Display the current exception object for a thread. Defaults to "
1520  "the current thread.",
1521  "thread exception",
1522  eCommandRequiresProcess | eCommandTryTargetAPILock |
1523  eCommandProcessMustBeLaunched | eCommandProcessMustBePaused) {}
1524 
1525  ~CommandObjectThreadException() override = default;
1526 
1527  bool HandleOneThread(lldb::tid_t tid, CommandReturnObject &result) override {
1528  ThreadSP thread_sp =
1529  m_exe_ctx.GetProcessPtr()->GetThreadList().FindThreadByID(tid);
1530  if (!thread_sp) {
1531  result.AppendErrorWithFormat("thread no longer exists: 0x%" PRIx64 "\n",
1532  tid);
1534  return false;
1535  }
1536 
1537  Stream &strm = result.GetOutputStream();
1538  ValueObjectSP exception_object_sp = thread_sp->GetCurrentException();
1539  if (exception_object_sp) {
1540  exception_object_sp->Dump(strm);
1541  }
1542 
1543  ThreadSP exception_thread_sp = thread_sp->GetCurrentExceptionBacktrace();
1544  if (exception_thread_sp && exception_thread_sp->IsValid()) {
1545  const uint32_t num_frames_with_source = 0;
1546  const bool stop_format = false;
1547  exception_thread_sp->GetStatus(strm, 0, UINT32_MAX,
1548  num_frames_with_source, stop_format);
1549  }
1550 
1551  return true;
1552  }
1553 };
1554 
1555 // CommandObjectThreadReturn
1556 
1557 static constexpr OptionDefinition g_thread_return_options[] = {
1558  // clang-format off
1559  { LLDB_OPT_SET_ALL, false, "from-expression", 'x', OptionParser::eNoArgument, nullptr, {}, 0, eArgTypeNone, "Return from the innermost expression evaluation." }
1560  // clang-format on
1561 };
1562 
1564 public:
1565  class CommandOptions : public Options {
1566  public:
1567  CommandOptions() : Options(), m_from_expression(false) {
1568  // Keep default values of all options in one place: OptionParsingStarting
1569  // ()
1570  OptionParsingStarting(nullptr);
1571  }
1572 
1573  ~CommandOptions() override = default;
1574 
1575  Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
1576  ExecutionContext *execution_context) override {
1577  Status error;
1578  const int short_option = m_getopt_table[option_idx].val;
1579 
1580  switch (short_option) {
1581  case 'x': {
1582  bool success;
1583  bool tmp_value =
1584  OptionArgParser::ToBoolean(option_arg, false, &success);
1585  if (success)
1586  m_from_expression = tmp_value;
1587  else {
1589  "invalid boolean value '%s' for 'x' option",
1590  option_arg.str().c_str());
1591  }
1592  } break;
1593  default:
1594  error.SetErrorStringWithFormat("invalid short option character '%c'",
1595  short_option);
1596  break;
1597  }
1598  return error;
1599  }
1600 
1601  void OptionParsingStarting(ExecutionContext *execution_context) override {
1602  m_from_expression = false;
1603  }
1604 
1605  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
1606  return llvm::makeArrayRef(g_thread_return_options);
1607  }
1608 
1610 
1611  // Instance variables to hold the values for command options.
1612  };
1613 
1615  : CommandObjectRaw(interpreter, "thread return",
1616  "Prematurely return from a stack frame, "
1617  "short-circuiting execution of newer frames "
1618  "and optionally yielding a specified value. Defaults "
1619  "to the exiting the current stack "
1620  "frame.",
1621  "thread return",
1622  eCommandRequiresFrame | eCommandTryTargetAPILock |
1623  eCommandProcessMustBeLaunched |
1624  eCommandProcessMustBePaused),
1625  m_options() {
1627  CommandArgumentData expression_arg;
1628 
1629  // Define the first (and only) variant of this arg.
1630  expression_arg.arg_type = eArgTypeExpression;
1631  expression_arg.arg_repetition = eArgRepeatOptional;
1632 
1633  // There is only one variant this argument could be; put it into the
1634  // argument entry.
1635  arg.push_back(expression_arg);
1636 
1637  // Push the data for the first argument into the m_arguments vector.
1638  m_arguments.push_back(arg);
1639  }
1640 
1641  ~CommandObjectThreadReturn() override = default;
1642 
1643  Options *GetOptions() override { return &m_options; }
1644 
1645 protected:
1646  bool DoExecute(llvm::StringRef command,
1647  CommandReturnObject &result) override {
1648  // I am going to handle this by hand, because I don't want you to have to
1649  // say:
1650  // "thread return -- -5".
1651  if (command.startswith("-x")) {
1652  if (command.size() != 2U)
1653  result.AppendWarning("Return values ignored when returning from user "
1654  "called expressions");
1655 
1656  Thread *thread = m_exe_ctx.GetThreadPtr();
1657  Status error;
1658  error = thread->UnwindInnermostExpression();
1659  if (!error.Success()) {
1660  result.AppendErrorWithFormat("Unwinding expression failed - %s.",
1661  error.AsCString());
1663  } else {
1664  bool success =
1665  thread->SetSelectedFrameByIndexNoisily(0, result.GetOutputStream());
1666  if (success) {
1667  m_exe_ctx.SetFrameSP(thread->GetSelectedFrame());
1669  } else {
1670  result.AppendErrorWithFormat(
1671  "Could not select 0th frame after unwinding expression.");
1673  }
1674  }
1675  return result.Succeeded();
1676  }
1677 
1678  ValueObjectSP return_valobj_sp;
1679 
1680  StackFrameSP frame_sp = m_exe_ctx.GetFrameSP();
1681  uint32_t frame_idx = frame_sp->GetFrameIndex();
1682 
1683  if (frame_sp->IsInlined()) {
1684  result.AppendError("Don't know how to return from inlined frames.");
1686  return false;
1687  }
1688 
1689  if (!command.empty()) {
1690  Target *target = m_exe_ctx.GetTargetPtr();
1691  EvaluateExpressionOptions options;
1692 
1693  options.SetUnwindOnError(true);
1695 
1697  exe_results = target->EvaluateExpression(command, frame_sp.get(),
1698  return_valobj_sp, options);
1699  if (exe_results != eExpressionCompleted) {
1700  if (return_valobj_sp)
1701  result.AppendErrorWithFormat(
1702  "Error evaluating result expression: %s",
1703  return_valobj_sp->GetError().AsCString());
1704  else
1705  result.AppendErrorWithFormat(
1706  "Unknown error evaluating result expression.");
1708  return false;
1709  }
1710  }
1711 
1712  Status error;
1713  ThreadSP thread_sp = m_exe_ctx.GetThreadSP();
1714  const bool broadcast = true;
1715  error = thread_sp->ReturnFromFrame(frame_sp, return_valobj_sp, broadcast);
1716  if (!error.Success()) {
1717  result.AppendErrorWithFormat(
1718  "Error returning from frame %d of thread %d: %s.", frame_idx,
1719  thread_sp->GetIndexID(), error.AsCString());
1721  return false;
1722  }
1723 
1725  return true;
1726  }
1727 
1729 };
1730 
1731 // CommandObjectThreadJump
1732 
1733 static constexpr OptionDefinition g_thread_jump_options[] = {
1734  // clang-format off
1735  { LLDB_OPT_SET_1, false, "file", 'f', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eSourceFileCompletion, eArgTypeFilename, "Specifies the source file to jump to." },
1736  { LLDB_OPT_SET_1, true, "line", 'l', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeLineNum, "Specifies the line number to jump to." },
1737  { LLDB_OPT_SET_2, true, "by", 'b', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeOffset, "Jumps by a relative line offset from the current line." },
1738  { LLDB_OPT_SET_3, true, "address", 'a', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeAddressOrExpression, "Jumps to a specific address." },
1739  { LLDB_OPT_SET_1 | LLDB_OPT_SET_2 | LLDB_OPT_SET_3, false, "force", 'r', OptionParser::eNoArgument, nullptr, {}, 0, eArgTypeNone, "Allows the PC to leave the current function." }
1740  // clang-format on
1741 };
1742 
1744 public:
1745  class CommandOptions : public Options {
1746  public:
1747  CommandOptions() : Options() { OptionParsingStarting(nullptr); }
1748 
1749  ~CommandOptions() override = default;
1750 
1751  void OptionParsingStarting(ExecutionContext *execution_context) override {
1752  m_filenames.Clear();
1753  m_line_num = 0;
1754  m_line_offset = 0;
1755  m_load_addr = LLDB_INVALID_ADDRESS;
1756  m_force = false;
1757  }
1758 
1759  Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
1760  ExecutionContext *execution_context) override {
1761  const int short_option = m_getopt_table[option_idx].val;
1762  Status error;
1763 
1764  switch (short_option) {
1765  case 'f':
1766  m_filenames.AppendIfUnique(FileSpec(option_arg));
1767  if (m_filenames.GetSize() > 1)
1768  return Status("only one source file expected.");
1769  break;
1770  case 'l':
1771  if (option_arg.getAsInteger(0, m_line_num))
1772  return Status("invalid line number: '%s'.", option_arg.str().c_str());
1773  break;
1774  case 'b':
1775  if (option_arg.getAsInteger(0, m_line_offset))
1776  return Status("invalid line offset: '%s'.", option_arg.str().c_str());
1777  break;
1778  case 'a':
1779  m_load_addr = OptionArgParser::ToAddress(execution_context, option_arg,
1780  LLDB_INVALID_ADDRESS, &error);
1781  break;
1782  case 'r':
1783  m_force = true;
1784  break;
1785  default:
1786  return Status("invalid short option character '%c'", short_option);
1787  }
1788  return error;
1789  }
1790 
1791  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
1792  return llvm::makeArrayRef(g_thread_jump_options);
1793  }
1794 
1795  FileSpecList m_filenames;
1797  int32_t m_line_offset;
1799  bool m_force;
1800  };
1801 
1804  interpreter, "thread jump",
1805  "Sets the program counter to a new address.", "thread jump",
1806  eCommandRequiresFrame | eCommandTryTargetAPILock |
1807  eCommandProcessMustBeLaunched | eCommandProcessMustBePaused),
1808  m_options() {}
1809 
1810  ~CommandObjectThreadJump() override = default;
1811 
1812  Options *GetOptions() override { return &m_options; }
1813 
1814 protected:
1815  bool DoExecute(Args &args, CommandReturnObject &result) override {
1816  RegisterContext *reg_ctx = m_exe_ctx.GetRegisterContext();
1817  StackFrame *frame = m_exe_ctx.GetFramePtr();
1818  Thread *thread = m_exe_ctx.GetThreadPtr();
1819  Target *target = m_exe_ctx.GetTargetPtr();
1820  const SymbolContext &sym_ctx =
1821  frame->GetSymbolContext(eSymbolContextLineEntry);
1822 
1823  if (m_options.m_load_addr != LLDB_INVALID_ADDRESS) {
1824  // Use this address directly.
1825  Address dest = Address(m_options.m_load_addr);
1826 
1827  lldb::addr_t callAddr = dest.GetCallableLoadAddress(target);
1828  if (callAddr == LLDB_INVALID_ADDRESS) {
1829  result.AppendErrorWithFormat("Invalid destination address.");
1831  return false;
1832  }
1833 
1834  if (!reg_ctx->SetPC(callAddr)) {
1835  result.AppendErrorWithFormat("Error changing PC value for thread %d.",
1836  thread->GetIndexID());
1838  return false;
1839  }
1840  } else {
1841  // Pick either the absolute line, or work out a relative one.
1842  int32_t line = (int32_t)m_options.m_line_num;
1843  if (line == 0)
1844  line = sym_ctx.line_entry.line + m_options.m_line_offset;
1845 
1846  // Try the current file, but override if asked.
1847  FileSpec file = sym_ctx.line_entry.file;
1848  if (m_options.m_filenames.GetSize() == 1)
1849  file = m_options.m_filenames.GetFileSpecAtIndex(0);
1850 
1851  if (!file) {
1852  result.AppendErrorWithFormat(
1853  "No source file available for the current location.");
1855  return false;
1856  }
1857 
1858  std::string warnings;
1859  Status err = thread->JumpToLine(file, line, m_options.m_force, &warnings);
1860 
1861  if (err.Fail()) {
1862  result.SetError(err);
1863  return false;
1864  }
1865 
1866  if (!warnings.empty())
1867  result.AppendWarning(warnings.c_str());
1868  }
1869 
1871  return true;
1872  }
1873 
1875 };
1876 
1877 // Next are the subcommands of CommandObjectMultiwordThreadPlan
1878 
1879 // CommandObjectThreadPlanList
1880 
1881 static constexpr OptionDefinition g_thread_plan_list_options[] = {
1882  // clang-format off
1883  { LLDB_OPT_SET_1, false, "verbose", 'v', OptionParser::eNoArgument, nullptr, {}, 0, eArgTypeNone, "Display more information about the thread plans" },
1884  { LLDB_OPT_SET_1, false, "internal", 'i', OptionParser::eNoArgument, nullptr, {}, 0, eArgTypeNone, "Display internal as well as user thread plans" }
1885  // clang-format on
1886 };
1887 
1889 public:
1890  class CommandOptions : public Options {
1891  public:
1893  // Keep default values of all options in one place: OptionParsingStarting
1894  // ()
1895  OptionParsingStarting(nullptr);
1896  }
1897 
1898  ~CommandOptions() override = default;
1899 
1900  Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
1901  ExecutionContext *execution_context) override {
1902  Status error;
1903  const int short_option = m_getopt_table[option_idx].val;
1904 
1905  switch (short_option) {
1906  case 'i':
1907  m_internal = true;
1908  break;
1909  case 'v':
1910  m_verbose = true;
1911  break;
1912  default:
1913  error.SetErrorStringWithFormat("invalid short option character '%c'",
1914  short_option);
1915  break;
1916  }
1917  return error;
1918  }
1919 
1920  void OptionParsingStarting(ExecutionContext *execution_context) override {
1921  m_verbose = false;
1922  m_internal = false;
1923  }
1924 
1925  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
1926  return llvm::makeArrayRef(g_thread_plan_list_options);
1927  }
1928 
1929  // Instance variables to hold the values for command options.
1932  };
1933 
1936  interpreter, "thread plan list",
1937  "Show thread plans for one or more threads. If no threads are "
1938  "specified, show the "
1939  "current thread. Use the thread-index \"all\" to see all threads.",
1940  nullptr,
1941  eCommandRequiresProcess | eCommandRequiresThread |
1942  eCommandTryTargetAPILock | eCommandProcessMustBeLaunched |
1943  eCommandProcessMustBePaused),
1944  m_options() {}
1945 
1946  ~CommandObjectThreadPlanList() override = default;
1947 
1948  Options *GetOptions() override { return &m_options; }
1949 
1950 protected:
1951  bool HandleOneThread(lldb::tid_t tid, CommandReturnObject &result) override {
1952  ThreadSP thread_sp =
1953  m_exe_ctx.GetProcessPtr()->GetThreadList().FindThreadByID(tid);
1954  if (!thread_sp) {
1955  result.AppendErrorWithFormat("thread no longer exists: 0x%" PRIx64 "\n",
1956  tid);
1958  return false;
1959  }
1960 
1961  Thread *thread = thread_sp.get();
1962 
1963  Stream &strm = result.GetOutputStream();
1965  if (m_options.m_verbose)
1966  desc_level = eDescriptionLevelVerbose;
1967 
1968  thread->DumpThreadPlans(&strm, desc_level, m_options.m_internal, true);
1969  return true;
1970  }
1971 
1973 };
1974 
1976 public:
1978  : CommandObjectParsed(interpreter, "thread plan discard",
1979  "Discards thread plans up to and including the "
1980  "specified index (see 'thread plan list'.) "
1981  "Only user visible plans can be discarded.",
1982  nullptr,
1983  eCommandRequiresProcess | eCommandRequiresThread |
1984  eCommandTryTargetAPILock |
1985  eCommandProcessMustBeLaunched |
1986  eCommandProcessMustBePaused) {
1988  CommandArgumentData plan_index_arg;
1989 
1990  // Define the first (and only) variant of this arg.
1991  plan_index_arg.arg_type = eArgTypeUnsignedInteger;
1992  plan_index_arg.arg_repetition = eArgRepeatPlain;
1993 
1994  // There is only one variant this argument could be; put it into the
1995  // argument entry.
1996  arg.push_back(plan_index_arg);
1997 
1998  // Push the data for the first argument into the m_arguments vector.
1999  m_arguments.push_back(arg);
2000  }
2001 
2002  ~CommandObjectThreadPlanDiscard() override = default;
2003 
2004  bool DoExecute(Args &args, CommandReturnObject &result) override {
2005  Thread *thread = m_exe_ctx.GetThreadPtr();
2006  if (args.GetArgumentCount() != 1) {
2007  result.AppendErrorWithFormat("Too many arguments, expected one - the "
2008  "thread plan index - but got %zu.",
2009  args.GetArgumentCount());
2011  return false;
2012  }
2013 
2014  bool success;
2015  uint32_t thread_plan_idx =
2016  StringConvert::ToUInt32(args.GetArgumentAtIndex(0), 0, 0, &success);
2017  if (!success) {
2018  result.AppendErrorWithFormat(
2019  "Invalid thread index: \"%s\" - should be unsigned int.",
2020  args.GetArgumentAtIndex(0));
2022  return false;
2023  }
2024 
2025  if (thread_plan_idx == 0) {
2026  result.AppendErrorWithFormat(
2027  "You wouldn't really want me to discard the base thread plan.");
2029  return false;
2030  }
2031 
2032  if (thread->DiscardUserThreadPlansUpToIndex(thread_plan_idx)) {
2034  return true;
2035  } else {
2036  result.AppendErrorWithFormat(
2037  "Could not find User thread plan with index %s.",
2038  args.GetArgumentAtIndex(0));
2040  return false;
2041  }
2042  }
2043 };
2044 
2045 // CommandObjectMultiwordThreadPlan
2046 
2048 public:
2051  interpreter, "plan",
2052  "Commands for managing thread plans that control execution.",
2053  "thread plan <subcommand> [<subcommand objects]") {
2054  LoadSubCommand(
2055  "list", CommandObjectSP(new CommandObjectThreadPlanList(interpreter)));
2056  LoadSubCommand(
2057  "discard",
2058  CommandObjectSP(new CommandObjectThreadPlanDiscard(interpreter)));
2059  }
2060 
2061  ~CommandObjectMultiwordThreadPlan() override = default;
2062 };
2063 
2064 // CommandObjectMultiwordThread
2065 
2066 CommandObjectMultiwordThread::CommandObjectMultiwordThread(
2067  CommandInterpreter &interpreter)
2068  : CommandObjectMultiword(interpreter, "thread", "Commands for operating on "
2069  "one or more threads in "
2070  "the current process.",
2071  "thread <subcommand> [<subcommand-options>]") {
2072  LoadSubCommand("backtrace", CommandObjectSP(new CommandObjectThreadBacktrace(
2073  interpreter)));
2074  LoadSubCommand("continue",
2075  CommandObjectSP(new CommandObjectThreadContinue(interpreter)));
2076  LoadSubCommand("list",
2077  CommandObjectSP(new CommandObjectThreadList(interpreter)));
2078  LoadSubCommand("return",
2079  CommandObjectSP(new CommandObjectThreadReturn(interpreter)));
2080  LoadSubCommand("jump",
2081  CommandObjectSP(new CommandObjectThreadJump(interpreter)));
2082  LoadSubCommand("select",
2083  CommandObjectSP(new CommandObjectThreadSelect(interpreter)));
2084  LoadSubCommand("until",
2085  CommandObjectSP(new CommandObjectThreadUntil(interpreter)));
2086  LoadSubCommand("info",
2087  CommandObjectSP(new CommandObjectThreadInfo(interpreter)));
2089  "exception",
2090  CommandObjectSP(new CommandObjectThreadException(interpreter)));
2091  LoadSubCommand("step-in",
2092  CommandObjectSP(new CommandObjectThreadStepWithTypeAndScope(
2093  interpreter, "thread step-in",
2094  "Source level single step, stepping into calls. Defaults "
2095  "to current thread unless specified.",
2096  nullptr, eStepTypeInto, eStepScopeSource)));
2097 
2098  LoadSubCommand("step-out",
2099  CommandObjectSP(new CommandObjectThreadStepWithTypeAndScope(
2100  interpreter, "thread step-out",
2101  "Finish executing the current stack frame and stop after "
2102  "returning. Defaults to current thread unless specified.",
2103  nullptr, eStepTypeOut, eStepScopeSource)));
2104 
2105  LoadSubCommand("step-over",
2106  CommandObjectSP(new CommandObjectThreadStepWithTypeAndScope(
2107  interpreter, "thread step-over",
2108  "Source level single step, stepping over calls. Defaults "
2109  "to current thread unless specified.",
2110  nullptr, eStepTypeOver, eStepScopeSource)));
2111 
2112  LoadSubCommand("step-inst",
2113  CommandObjectSP(new CommandObjectThreadStepWithTypeAndScope(
2114  interpreter, "thread step-inst",
2115  "Instruction level single step, stepping into calls. "
2116  "Defaults to current thread unless specified.",
2118 
2119  LoadSubCommand("step-inst-over",
2120  CommandObjectSP(new CommandObjectThreadStepWithTypeAndScope(
2121  interpreter, "thread step-inst-over",
2122  "Instruction level single step, stepping over calls. "
2123  "Defaults to current thread unless specified.",
2125 
2127  "step-scripted",
2128  CommandObjectSP(new CommandObjectThreadStepWithTypeAndScope(
2129  interpreter, "thread step-scripted",
2130  "Step as instructed by the script class passed in the -C option.",
2131  nullptr, eStepTypeScripted, eStepScopeSource)));
2132 
2133  LoadSubCommand("plan", CommandObjectSP(new CommandObjectMultiwordThreadPlan(
2134  interpreter)));
2135 }
2136 
lldb::ThreadSP FindThreadByIndexID(uint32_t index_id, bool can_update=true)
Definition: ThreadList.cpp:208
lldb::addr_t GetCallableLoadAddress(Target *target, bool is_indirect=false) const
Get the load address as a callable code load address.
Definition: Address.cpp:317
A line table entry class.
Definition: LineEntry.h:20
CommandObjectThreadUntil(CommandInterpreter &interpreter)
std::vector< CommandArgumentData > CommandArgumentEntry
A command line argument class.
Definition: Args.h:32
CommandObjectMultiwordThreadPlan(CommandInterpreter &interpreter)
lldb::StackFrameSP GetSelectedFrame()
Definition: Thread.cpp:317
static constexpr OptionEnumValueElement g_tri_running_mode[]
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
Set the value of an option.
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
const char * StateAsCString(lldb::StateType state)
Converts a StateType to a C string.
Definition: State.cpp:14
Enumerations for broadcasting.
Definition: SBLaunchInfo.h:14
lldb::addr_t GetByteSize() const
Get accessor for the byte size of this range.
Definition: AddressRange.h:232
Options * GetOptions() override
Single step over a specified context.
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
llvm::ArrayRef< ArgEntry > entries() const
Definition: Args.h:123
Status UnwindInnermostExpression()
Unwinds the thread stack for the innermost expression plan currently on the thread plan stack...
Definition: Thread.cpp:1347
Single step one instruction.
Defines a symbol context baton that can be handed other debug core functions.
Definition: SymbolContext.h:33
bool LoadSubCommand(llvm::StringRef cmd_name, const lldb::CommandObjectSP &command_obj) override
const lldb::TargetSP & GetTargetSP() const
Get accessor to get the target shared pointer.
lldb::addr_t GetLoadAddress(Target *target) const
Get the load address.
Definition: Address.cpp:292
void OptionParsingStarting(ExecutionContext *execution_context) override
void AppendErrorWithFormat(const char *format,...) __attribute__((format(printf
uint32_t GetIOHandlerID() const
Definition: Process.h:2097
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
void SetUseDynamic(lldb::DynamicValueType dynamic=lldb::eDynamicCanRunTarget)
Definition: Target.h:300
size_t GetArgumentCount() const
Gets the number of arguments left in this command object.
Definition: Args.cpp:254
void SetResumeState(lldb::StateType state, bool override_suspend=false)
Sets the USER resume state for this thread.
Definition: Thread.h:186
uint32_t GetSelectedFrameIndex()
Definition: Thread.h:427
CommandObjectThreadBacktrace(CommandInterpreter &interpreter)
void OptionParsingStarting(ExecutionContext *execution_context) override
bool DiscardUserThreadPlansUpToIndex(uint32_t thread_index)
Discards the plans queued on the plan stack of the current thread up to and including the plan in tha...
Definition: Thread.cpp:1225
void SetUnwindOnError(bool unwind=false)
Definition: Target.h:285
lldb::user_id_t GetID() const
Get accessor for the user ID.
Definition: UserID.h:49
bool DoExecute(Args &command, CommandReturnObject &result) override
A file utility class.
Definition: FileSpec.h:55
Single step one instruction, stepping over.
ThreadList & GetThreadList()
Definition: Process.h:2045
CommandObjectThreadException(CommandInterpreter &interpreter)
lldb::StateType GetState()
Get accessor for the current process state.
Definition: Process.cpp:1347
virtual lldb::ThreadPlanSP QueueThreadPlanForStepInRange(bool abort_other_plans, const AddressRange &range, const SymbolContext &addr_context, const char *step_in_target, lldb::RunMode stop_other_threads, Status &status, LazyBool step_in_avoids_code_without_debug_info=eLazyBoolCalculate, LazyBool step_out_avoids_code_without_debug_info=eLazyBoolCalculate)
Queues the plan used to step through an address range, stepping into functions.
Definition: Thread.cpp:1406
bool DoExecute(Args &args, CommandReturnObject &result) override
bool HandleOneThread(lldb::tid_t tid, CommandReturnObject &result) override
Status ResumeSynchronous(Stream *stream)
Definition: Process.cpp:1406
lldb::ExpressionResults EvaluateExpression(llvm::StringRef expression, ExecutionContextScope *exe_scope, lldb::ValueObjectSP &result_valobj_sp, const EvaluateExpressionOptions &options=EvaluateExpressionOptions(), std::string *fixed_expression=nullptr, ValueObject *ctx_obj=nullptr)
Definition: Target.cpp:2375
lldb::addr_t GetFileAddress() const
Get the file address.
Definition: Address.cpp:272
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
CommandObjectIterateOverThreads(CommandInterpreter &interpreter, const char *name, const char *help, const char *syntax, uint32_t flags)
bool DoExecute(Args &command, CommandReturnObject &result) override
size_t GetThreadStatus(Stream &ostrm, bool only_threads_with_stop_reason, uint32_t start_frame, uint32_t num_frames, uint32_t num_frames_with_source, bool stop_format)
Definition: Process.cpp:5491
bool DoExecute(Args &command, CommandReturnObject &result) override
bool DoExecute(Args &command, CommandReturnObject &result) override
Options * GetOptions() override
bool GetAddressRangeFromHereToEndLine(uint32_t end_line, AddressRange &range, Status &error)
Process or thread is stopped and can be examined.
bool DoExecute(Args &args, CommandReturnObject &result) override
void OptionParsingStarting(ExecutionContext *execution_context) override
A class that describes a single lexical block.
Definition: Block.h:41
void GetStatus(Stream &ostrm)
Definition: Process.cpp:5471
bool GetRangeContainingAddress(const Address &addr, AddressRange &range)
Definition: Block.cpp:240
virtual lldb::ThreadPlanSP QueueThreadPlanForStepSingleInstruction(bool step_over, bool abort_other_plans, bool stop_other_threads, Status &status)
Queues the plan used to step one instruction from the current PC of thread.
Definition: Thread.cpp:1370
Process or thread has crashed and can be examined.
bool DoExecute(llvm::StringRef command, CommandReturnObject &result) override
bool HandleOneThread(lldb::tid_t tid, CommandReturnObject &result) override
const char * GetArgumentAtIndex(size_t idx) const
Gets the NULL terminated C string argument pointer for the argument at index idx. ...
Definition: Args.cpp:256
bool GetDescription(Stream &s, lldb::DescriptionLevel level, bool print_json_thread, bool print_json_stopinfo)
Definition: Thread.cpp:1961
CommandObjectThreadPlanList(CommandInterpreter &interpreter)
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
const SymbolContext & GetSymbolContext(lldb::SymbolContextItem resolve_scope)
Provide a SymbolContext for this StackFrame&#39;s current pc value.
Definition: StackFrame.cpp:267
#define LLDB_OPT_SET_3
Definition: lldb-defines.h:113
bool DoExecute(Args &command, CommandReturnObject &result) override
static constexpr OptionDefinition g_thread_backtrace_options[]
lldb::addr_t GetOffset() const
Get the section relative offset value.
Definition: Address.h:317
void OptionParsingStarting(ExecutionContext *execution_context) override
bool ContainsLoadAddress(const Address &so_addr, Target *target) const
Check if a section offset so_addr when represented as a load address is contained within this object&#39;...
#define UINT32_MAX
Definition: lldb-defines.h:31
lldb::ThreadSP GetThreadAtIndex(uint32_t idx, bool can_update=true)
Definition: ThreadList.cpp:90
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
Set the value of an option.
void Format(const char *format, Args &&... args)
Definition: Stream.h:422
CommandObjectThreadInfo(CommandInterpreter &interpreter)
CommandObjectThreadReturn(CommandInterpreter &interpreter)
#define LLDB_INVALID_ADDRESS
Invalid value definitions.
Definition: lldb-defines.h:85
lldb::ThreadSP FindThreadByID(lldb::tid_t tid, bool can_update=true)
Definition: ThreadList.cpp:102
void AppendWarning(llvm::StringRef in_string)
#define LLDB_INVALID_INDEX32
Definition: lldb-defines.h:86
static constexpr OptionEnumValueElement g_duo_running_mode[]
size_t GetStatus(Stream &strm, uint32_t start_frame, uint32_t num_frames, uint32_t num_frames_with_source, bool stop_format, bool only_stacks=false)
Definition: Thread.cpp:1908
bool HandleOneThread(lldb::tid_t tid, CommandReturnObject &result) override
Status JumpToLine(const FileSpec &file, uint32_t line, bool can_leave_function, std::string *warnings=nullptr)
Definition: Thread.cpp:1740
size_t EOL()
Output and End of Line character to the stream.
Definition: Stream.cpp:127
CommandObjectThreadStepWithTypeAndScope(CommandInterpreter &interpreter, const char *name, const char *help, const char *syntax, StepType step_type, StepScope step_scope)
bool SetSelectedFrameByIndexNoisily(uint32_t frame_idx, Stream &output_stream)
Definition: Thread.cpp:346
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
Set the value of an option.
static constexpr OptionEnumValues DuoRunningModes()
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
void AppendMessageWithFormat(const char *format,...) __attribute__((format(printf
#define LLDB_INVALID_FRAME_ID
Definition: lldb-defines.h:94
CommandObjectThreadSelect(CommandInterpreter &interpreter)
A line table class.
Definition: LineTable.h:37
uint64_t tid_t
Definition: lldb-types.h:86
void AppendMessage(llvm::StringRef in_string)
llvm::StringRef GetString() const
virtual lldb::ThreadSP GetExtendedBacktraceThread(lldb::ThreadSP thread, ConstString type)
Return a Thread which shows the origin of this thread&#39;s creation.
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
Set the value of an option.
void SetError(const Status &error, const char *fallback_error_cstr=nullptr)
FileSpec file
The source file, possibly mapped by the target.source-map setting.
Definition: LineEntry.h:151
uint32_t line
The source line number, or zero if there is no line number information.
Definition: LineEntry.h:154
A plug-in interface definition class for debugging a process.
Definition: Process.h:353
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
Status Resume()
Resumes all of a process&#39;s threads as configured using the Thread run control functions.
Definition: Process.cpp:1385
void SyncIOHandler(uint32_t iohandler_id, const Timeout< std::micro > &timeout)
Waits for the process state to be running within a given msec timeout.
Definition: Process.cpp:741
bool Success() const
Test for success condition.
Definition: Status.cpp:287
void AppendErrorWithFormatv(const char *format, Args &&... args)
bool IsValid() const
Check if the object state is valid.
Definition: Address.h:343
A section + offset based address class.
Definition: Address.h:80
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
CommandObjectThreadList(CommandInterpreter &interpreter)
lldb::ProcessSP GetProcess() const
Definition: Thread.h:154
bool DoExecute(Args &command, CommandReturnObject &result) override
static constexpr OptionDefinition g_thread_info_options[]
static constexpr OptionDefinition g_thread_step_scope_options[]
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
#define LLDB_OPT_SET_2
Definition: lldb-defines.h:112
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
Set the value of an option.
Process or thread is in a suspended state as far as the debugger is concerned while other processes o...
CommandObjectThreadJump(CommandInterpreter &interpreter)
A command line option parsing protocol class.
Definition: Options.h:62
virtual lldb::ThreadPlanSP QueueThreadPlanForStepScripted(bool abort_other_plans, const char *class_name, bool stop_other_threads, Status &status)
Definition: Thread.cpp:1506
void void AppendError(llvm::StringRef in_string)
Single step into a specified context.
#define LLDB_INVALID_THREAD_ID
Definition: lldb-defines.h:93
uint64_t addr_t
Definition: lldb-types.h:83
CommandObjectThreadContinue(CommandInterpreter &interpreter)
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
Set the value of an option.
void DumpThreadPlans(Stream *s, lldb::DescriptionLevel desc_level=lldb::eDescriptionLevelVerbose, bool include_internal=true, bool ignore_boring=false) const
Prints the current plan stack.
Definition: Thread.cpp:1540
A step type implemented by the script interpreter.
void DoExtendedBacktrace(Thread *thread, CommandReturnObject &result)
virtual lldb::ThreadPlanSP QueueThreadPlanForStepOverRange(bool abort_other_plans, const AddressRange &range, const SymbolContext &addr_context, lldb::RunMode stop_other_threads, Status &status, LazyBool step_out_avoids_code_without_debug_info=eLazyBoolCalculate)
Queues the plan used to step through an address range, stepping over function calls.
Definition: Thread.cpp:1379
virtual const std::vector< ConstString > & GetExtendedBacktraceTypes()
Return a list of thread origin extended backtraces that may be available.
bool Fail() const
Test for error condition.
Definition: Status.cpp:181
static constexpr OptionDefinition g_thread_return_options[]
static constexpr OptionEnumValues TriRunningModes()
virtual lldb::ThreadPlanSP QueueThreadPlanForStepUntil(bool abort_other_plans, lldb::addr_t *address_list, size_t num_addresses, bool stop_others, uint32_t frame_idx, Status &status)
Definition: Thread.cpp:1496
LineEntry line_entry
The LineEntry for a given query.
bool HandleOneThread(lldb::tid_t tid, CommandReturnObject &result) override
Definition: SBAddress.h:15
uint32_t ToUInt32(const char *s, uint32_t fail_value=0, int base=0, bool *success_ptr=nullptr)
static constexpr OptionDefinition g_thread_jump_options[]
#define LLDB_OPT_SET_ALL
Definition: lldb-defines.h:110
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
Set the value of an option.
Address & GetBaseAddress()
Get accessor for the base address of the range.
Definition: AddressRange.h:220
uint32_t GetSize(bool can_update=true)
Definition: ThreadList.cpp:82
int SetErrorStringWithFormat(const char *format,...) __attribute__((format(printf
Set the current error string to a formatted error string.
Definition: Status.cpp:255
bool BucketThread(lldb::tid_t tid, std::set< UniqueStack > &unique_stacks, CommandReturnObject &result)
bool HasDebugInformation()
Determine whether this StackFrame has debug information available or not.
#define LLDB_INVALID_LINE_NUMBER
Definition: lldb-defines.h:97
uint32_t GetIndexID() const
Definition: Thread.cpp:1515
#define LLDB_OPT_SET_1
Definition: lldb-defines.h:111
const char * AsCString(const char *default_error_str="unknown error") const
Get the error string associated with the current error.
Definition: Status.cpp:130
Single step out a specified context.
static constexpr OptionDefinition g_thread_until_options[]
virtual lldb::StackFrameSP GetStackFrameAtIndex(uint32_t idx)
Definition: Thread.h:395
lldb::SectionSP GetSection() const
Get const accessor for the section.
Definition: Address.h:410
void OptionParsingStarting(ExecutionContext *execution_context) override
virtual uint32_t GetStackFrameCount()
Definition: Thread.h:391
bool operator<(const Address &lhs, const Address &rhs)
Definition: Address.cpp:942
void OptionParsingStarting(ExecutionContext *execution_context) override
Options * GetOptions() override
Block * block
The Block for a given query.
CommandObjectThreadPlanDiscard(CommandInterpreter &interpreter)
static constexpr OptionDefinition g_thread_plan_list_options[]
A section + offset based address range class.
Definition: AddressRange.h:32
void SetStatus(lldb::ReturnStatus status)
This base class provides an interface to stack frames.
Definition: StackFrame.h:40
virtual lldb::ThreadPlanSP QueueThreadPlanForStepOut(bool abort_other_plans, SymbolContext *addr_context, bool first_insn, bool stop_other_threads, Vote stop_vote, Vote run_vote, uint32_t frame_idx, Status &status, LazyBool step_out_avoids_code_without_debug_info=eLazyBoolCalculate)
Queue the plan used to step out of the function at the current PC of thread.
Definition: Thread.cpp:1442
AddressRange range
The section offset address range for this line entry.
Definition: LineEntry.h:150
ThreadList::ThreadIterable Threads()
Definition: Process.h:2053
const Address & GetFrameCodeAddress()
Get an Address for the current pc value in this StackFrame.
Definition: StackFrame.cpp:181
void OptionParsingStarting(ExecutionContext *execution_context) override
std::recursive_mutex & GetMutex() const override
Definition: ThreadList.cpp:743
bool SetSelectedThreadByID(lldb::tid_t tid, bool notify=false)
Definition: ThreadList.cpp:661
An error handling class.
Definition: Status.h:44
A plug-in interface definition class for system runtimes.
Definition: SystemRuntime.h:42
Process or thread is running and can&#39;t be examined.