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