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