contrib/llvm/tools/lldb/source/Commands/CommandObjectThread.cpp

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