source/Commands/CommandObjectBreakpointCommand.cpp

   1 //===-- CommandObjectBreakpointCommand.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 // C Includes
  13 // C++ Includes
  14
  15
  16 #include "CommandObjectBreakpointCommand.h"
  17 #include "CommandObjectBreakpoint.h"
  18
  19 #include "lldb/Core/IOHandler.h"
  20 #include "lldb/Interpreter/CommandInterpreter.h"
  21 #include "lldb/Interpreter/CommandReturnObject.h"
  22 #include "lldb/Target/Target.h"
  23 #include "lldb/Target/Thread.h"
  24 #include "lldb/Breakpoint/BreakpointIDList.h"
  25 #include "lldb/Breakpoint/Breakpoint.h"
  26 #include "lldb/Breakpoint/BreakpointLocation.h"
  27 #include "lldb/Breakpoint/StoppointCallbackContext.h"
  28 #include "lldb/Core/State.h"
  29
  30 using namespace lldb;
  31 using namespace lldb_private;
  32
  33 //-------------------------------------------------------------------------
  34 // CommandObjectBreakpointCommandAdd
  35 //-------------------------------------------------------------------------
  36
  37
  38 class CommandObjectBreakpointCommandAdd :
  39     public CommandObjectParsed,
  40     public IOHandlerDelegateMultiline
  41 {
  42 public:
  43
  44     CommandObjectBreakpointCommandAdd (CommandInterpreter &interpreter) :
  45         CommandObjectParsed (interpreter,
  46                              "add",
  47                              "Add a set of commands to a breakpoint, to be executed whenever the breakpoint is hit."
  48                              "  If no breakpoint is specified, adds the commands to the last created breakpoint.",
  49                              NULL),
  50         IOHandlerDelegateMultiline ("DONE", IOHandlerDelegate::Completion::LLDBCommand),
  51         m_options (interpreter)
  52     {
  53         SetHelpLong (
  54 "\nGeneral information about entering breakpoint commands\n\
  55 ------------------------------------------------------\n\
  56 \n\
  57 This command will cause you to be prompted to enter the command or set of\n\
  58 commands you wish to be executed when the specified breakpoint is hit. You\n\
  59 will be told to enter your command(s), and will see a '> 'prompt. Because\n\
  60 you can enter one or many commands to be executed when a breakpoint is hit,\n\
  61 you will continue to be prompted after each new-line that you enter, until you\n\
  62 enter the word 'DONE', which will cause the commands you have entered to be\n\
  63 stored with the breakpoint and executed when the breakpoint is hit.\n\
  64 \n\
  65 Syntax checking is not necessarily done when breakpoint commands are entered.\n\
  66 An improperly written breakpoint command will attempt to get executed when the\n\
  67 breakpoint gets hit, and usually silently fail.  If your breakpoint command does\n\
  68 not appear to be getting executed, go back and check your syntax.\n\
  69 \n\
  70 Special information about PYTHON breakpoint commands\n\
  71 ----------------------------------------------------\n\
  72 \n\
  73 You may enter either one line of Python, multiple lines of Python (including\n\
  74 function definitions), or specify a Python function in a module that has already,\n\
  75 or will be imported.  If you enter a single line of Python, that will be passed\n\
  76 to the Python interpreter 'as is' when the breakpoint gets hit.  If you enter\n\
  77 function definitions, they will be passed to the Python interpreter as soon as\n\
  78 you finish entering the breakpoint command, and they can be called later (don't\n\
  79 forget to add calls to them, if you want them called when the breakpoint is\n\
  80 hit).  If you enter multiple lines of Python that are not function definitions,\n\
  81 they will be collected into a new, automatically generated Python function, and\n\
  82 a call to the newly generated function will be attached to the breakpoint.\n\
  83 \n\
  84 \n\
  85 This auto-generated function is passed in three arguments:\n\
  86 \n\
  87     frame:  a lldb.SBFrame object for the frame which hit breakpoint.\n\
  88     bp_loc: a lldb.SBBreakpointLocation object that represents the breakpoint\n\
  89             location that was hit.\n\
  90     dict:   the python session dictionary hit.\n\
  91 \n\
  92 When specifying a python function with the --python-function option, you need\n\
  93 to supply the function name prepended by the module name. So if you import a\n\
  94 module named 'myutils' that contains a 'breakpoint_callback' function, you would\n\
  95 specify the option as:\n\
  96 \n\
  97     --python-function myutils.breakpoint_callback\n\
  98 \n\
  99 The function itself must have the following prototype:\n\
 100 \n\
 101 def breakpoint_callback(frame, bp_loc, dict):\n\
 102   # Your code goes here\n\
 103 \n\
 104 The arguments are the same as the 3 auto generation function arguments listed\n\
 105 above. Note that the global variable 'lldb.frame' will NOT be setup when this\n\
 106 function is called, so be sure to use the 'frame' argument. The 'frame' argument\n\
 107 can get you to the thread (frame.GetThread()), the thread can get you to the\n\
 108 process (thread.GetProcess()), and the process can get you back to the target\n\
 109 (process.GetTarget()).\n\
 110 \n\
 111 Important Note: Because loose Python code gets collected into functions, if you\n\
 112 want to access global variables in the 'loose' code, you need to specify that\n\
 113 they are global, using the 'global' keyword.  Be sure to use correct Python\n\
 114 syntax, including indentation, when entering Python breakpoint commands.\n\
 115 \n\
 116 As a third option, you can pass the name of an already existing Python function\n\
 117 and that function will be attached to the breakpoint. It will get passed the\n\
 118 frame and bp_loc arguments mentioned above.\n\
 119 \n\
 120 Example Python one-line breakpoint command:\n\
 121 \n\
 122 (lldb) breakpoint command add -s python 1\n\
 123 Enter your Python command(s). Type 'DONE' to end.\n\
 124 > print \"Hit this breakpoint!\"\n\
 125 > DONE\n\
 126 \n\
 127 As a convenience, this also works for a short Python one-liner:\n\
 128 (lldb) breakpoint command add -s python 1 -o \"import time; print time.asctime()\"\n\
 129 (lldb) run\n\
 130 Launching '.../a.out'  (x86_64)\n\
 131 (lldb) Fri Sep 10 12:17:45 2010\n\
 132 Process 21778 Stopped\n\
 133 * thread #1: tid = 0x2e03, 0x0000000100000de8 a.out`c + 7 at main.c:39, stop reason = breakpoint 1.1, queue = com.apple.main-thread\n\
 134   36    \n\
 135   37    int c(int val)\n\
 136   38    {\n\
 137   39 ->     return val + 3;\n\
 138   40    }\n\
 139   41    \n\
 140   42    int main (int argc, char const *argv[])\n\
 141 (lldb)\n\
 142 \n\
 143 Example multiple line Python breakpoint command, using function definition:\n\
 144 \n\
 145 (lldb) breakpoint command add -s python 1\n\
 146 Enter your Python command(s). Type 'DONE' to end.\n\
 147 > def breakpoint_output (bp_no):\n\
 148 >     out_string = \"Hit breakpoint number \" + repr (bp_no)\n\
 149 >     print out_string\n\
 150 >     return True\n\
 151 > breakpoint_output (1)\n\
 152 > DONE\n\
 153 \n\
 154 \n\
 155 Example multiple line Python breakpoint command, using 'loose' Python:\n\
 156 \n\
 157 (lldb) breakpoint command add -s p 1\n\
 158 Enter your Python command(s). Type 'DONE' to end.\n\
 159 > global bp_count\n\
 160 > bp_count = bp_count + 1\n\
 161 > print \"Hit this breakpoint \" + repr(bp_count) + \" times!\"\n\
 162 > DONE\n\
 163 \n\
 164 In this case, since there is a reference to a global variable,\n\
 165 'bp_count', you will also need to make sure 'bp_count' exists and is\n\
 166 initialized:\n\
 167 \n\
 168 (lldb) script\n\
 169 >>> bp_count = 0\n\
 170 >>> quit()\n\
 171 \n\
 172 (lldb)\n\
 173 \n\
 174 \n\
 175 Your Python code, however organized, can optionally return a value.\n\
 176 If the returned value is False, that tells LLDB not to stop at the breakpoint\n\
 177 to which the code is associated. Returning anything other than False, or even\n\
 178 returning None, or even omitting a return statement entirely, will cause\n\
 179 LLDB to stop.\n\
 180 \n\
 181 Final Note:  If you get a warning that no breakpoint command was generated, but\n\
 182 you did not get any syntax errors, you probably forgot to add a call to your\n\
 183 functions.\n\
 184 \n\
 185 Special information about debugger command breakpoint commands\n\
 186 --------------------------------------------------------------\n\
 187 \n\
 188 You may enter any debugger command, exactly as you would at the debugger prompt.\n\
 189 You may enter as many debugger commands as you like, but do NOT enter more than\n\
 190 one command per line.\n" );
 191
 192         CommandArgumentEntry arg;
 193         CommandArgumentData bp_id_arg;
 194
 195         // Define the first (and only) variant of this arg.
 196         bp_id_arg.arg_type = eArgTypeBreakpointID;
 197         bp_id_arg.arg_repetition = eArgRepeatOptional;
 198
 199         // There is only one variant this argument could be; put it into the argument entry.
 200         arg.push_back (bp_id_arg);
 201
 202         // Push the data for the first argument into the m_arguments vector.
 203         m_arguments.push_back (arg);
 204     }
 205
 206     virtual
 207     ~CommandObjectBreakpointCommandAdd () {}
 208
 209     virtual Options *
 210     GetOptions ()
 211     {
 212         return &m_options;
 213     }
 214
 215     virtual void
 216     IOHandlerActivated (IOHandler &io_handler)
 217     {
 218         StreamFileSP output_sp(io_handler.GetOutputStreamFile());
 219         if (output_sp)
 220         {
 221             output_sp->PutCString(g_reader_instructions);
 222             output_sp->Flush();
 223         }
 224     }
 225
 226
 227     virtual void
 228     IOHandlerInputComplete (IOHandler &io_handler, std::string &line)
 229     {
 230         io_handler.SetIsDone(true);
 231
 232         std::vector<BreakpointOptions *> *bp_options_vec = (std::vector<BreakpointOptions *> *)io_handler.GetUserData();
 233         for (BreakpointOptions *bp_options : *bp_options_vec)
 234         {
 235             if (!bp_options)
 236                 continue;
 237
 238             std::unique_ptr<BreakpointOptions::CommandData> data_ap(new BreakpointOptions::CommandData());
 239             if (data_ap.get())
 240             {
 241                 data_ap->user_source.SplitIntoLines (line.c_str(), line.size());
 242                 BatonSP baton_sp (new BreakpointOptions::CommandBaton (data_ap.release()));
 243                 bp_options->SetCallback (BreakpointOptionsCallbackFunction, baton_sp);
 244             }
 245         }
 246     }
 247
 248     void
 249     CollectDataForBreakpointCommandCallback (std::vector<BreakpointOptions *> &bp_options_vec,
 250                                              CommandReturnObject &result)
 251     {
 252         m_interpreter.GetLLDBCommandsFromIOHandler ("> ",           // Prompt
 253                                                     *this,          // IOHandlerDelegate
 254                                                     true,           // Run IOHandler in async mode
 255                                                     &bp_options_vec);    // Baton for the "io_handler" that will be passed back into our IOHandlerDelegate functions
 256     }
 257
 258     /// Set a one-liner as the callback for the breakpoint.
 259     void
 260     SetBreakpointCommandCallback (std::vector<BreakpointOptions *> &bp_options_vec,
 261                                   const char *oneliner)
 262     {
 263         for (auto bp_options : bp_options_vec)
 264         {
 265             std::unique_ptr<BreakpointOptions::CommandData> data_ap(new BreakpointOptions::CommandData());
 266
 267             // It's necessary to set both user_source and script_source to the oneliner.
 268             // The former is used to generate callback description (as in breakpoint command list)
 269             // while the latter is used for Python to interpret during the actual callback.
 270             data_ap->user_source.AppendString (oneliner);
 271             data_ap->script_source.assign (oneliner);
 272             data_ap->stop_on_error = m_options.m_stop_on_error;
 273
 274             BatonSP baton_sp (new BreakpointOptions::CommandBaton (data_ap.release()));
 275             bp_options->SetCallback (BreakpointOptionsCallbackFunction, baton_sp);
 276         }
 277         return;
 278     }
 279
 280     static bool
 281     BreakpointOptionsCallbackFunction (void *baton,
 282                                        StoppointCallbackContext *context,
 283                                        lldb::user_id_t break_id,
 284                                        lldb::user_id_t break_loc_id)
 285     {
 286         bool ret_value = true;
 287         if (baton == NULL)
 288             return true;
 289
 290
 291         BreakpointOptions::CommandData *data = (BreakpointOptions::CommandData *) baton;
 292         StringList &commands = data->user_source;
 293
 294         if (commands.GetSize() > 0)
 295         {
 296             ExecutionContext exe_ctx (context->exe_ctx_ref);
 297             Target *target = exe_ctx.GetTargetPtr();
 298             if (target)
 299             {
 300                 CommandReturnObject result;
 301                 Debugger &debugger = target->GetDebugger();
 302                 // Rig up the results secondary output stream to the debugger's, so the output will come out synchronously
 303                 // if the debugger is set up that way.
 304
 305                 StreamSP output_stream (debugger.GetAsyncOutputStream());
 306                 StreamSP error_stream (debugger.GetAsyncErrorStream());
 307                 result.SetImmediateOutputStream (output_stream);
 308                 result.SetImmediateErrorStream (error_stream);
 309
 310                 bool stop_on_continue = true;
 311                 bool echo_commands    = false;
 312                 bool print_results    = true;
 313
 314                 debugger.GetCommandInterpreter().HandleCommands (commands,
 315                                                                  &exe_ctx,
 316                                                                  stop_on_continue,
 317                                                                  data->stop_on_error,
 318                                                                  echo_commands,
 319                                                                  print_results,
 320                                                                  eLazyBoolNo,
 321                                                                  result);
 322                 result.GetImmediateOutputStream()->Flush();
 323                 result.GetImmediateErrorStream()->Flush();
 324            }
 325         }
 326         return ret_value;
 327     }
 328
 329     class CommandOptions : public Options
 330     {
 331     public:
 332
 333         CommandOptions (CommandInterpreter &interpreter) :
 334             Options (interpreter),
 335             m_use_commands (false),
 336             m_use_script_language (false),
 337             m_script_language (eScriptLanguageNone),
 338             m_use_one_liner (false),
 339             m_one_liner(),
 340             m_function_name()
 341         {
 342         }
 343
 344         virtual
 345         ~CommandOptions () {}
 346
 347         virtual Error
 348         SetOptionValue (uint32_t option_idx, const char *option_arg)
 349         {
 350             Error error;
 351             const int short_option = m_getopt_table[option_idx].val;
 352
 353             switch (short_option)
 354             {
 355             case 'o':
 356                 m_use_one_liner = true;
 357                 m_one_liner = option_arg;
 358                 break;
 359
 360             case 's':
 361                 m_script_language = (lldb::ScriptLanguage) Args::StringToOptionEnum (option_arg,
 362                                                                                      g_option_table[option_idx].enum_values,
 363                                                                                      eScriptLanguageNone,
 364                                                                                      error);
 365
 366                 if (m_script_language == eScriptLanguagePython || m_script_language == eScriptLanguageDefault)
 367                 {
 368                     m_use_script_language = true;
 369                 }
 370                 else
 371                 {
 372                     m_use_script_language = false;
 373                 }
 374                 break;
 375
 376             case 'e':
 377                 {
 378                     bool success = false;
 379                     m_stop_on_error = Args::StringToBoolean(option_arg, false, &success);
 380                     if (!success)
 381                         error.SetErrorStringWithFormat("invalid value for stop-on-error: \"%s\"", option_arg);
 382                 }
 383                 break;
 384
 385             case 'F':
 386                 {
 387                     m_use_one_liner = false;
 388                     m_use_script_language = true;
 389                     m_function_name.assign(option_arg);
 390                 }
 391                 break;
 392
 393             default:
 394                 break;
 395             }
 396             return error;
 397         }
 398         void
 399         OptionParsingStarting ()
 400         {
 401             m_use_commands = true;
 402             m_use_script_language = false;
 403             m_script_language = eScriptLanguageNone;
 404
 405             m_use_one_liner = false;
 406             m_stop_on_error = true;
 407             m_one_liner.clear();
 408             m_function_name.clear();
 409         }
 410
 411         const OptionDefinition*
 412         GetDefinitions ()
 413         {
 414             return g_option_table;
 415         }
 416
 417         // Options table: Required for subclasses of Options.
 418
 419         static OptionDefinition g_option_table[];
 420
 421         // Instance variables to hold the values for command options.
 422
 423         bool m_use_commands;
 424         bool m_use_script_language;
 425         lldb::ScriptLanguage m_script_language;
 426
 427         // Instance variables to hold the values for one_liner options.
 428         bool m_use_one_liner;
 429         std::string m_one_liner;
 430         bool m_stop_on_error;
 431         std::string m_function_name;
 432     };
 433
 434 protected:
 435     virtual bool
 436     DoExecute (Args& command, CommandReturnObject &result)
 437     {
 438         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
 439
 440         if (target == NULL)
 441         {
 442             result.AppendError ("There is not a current executable; there are no breakpoints to which to add commands");
 443             result.SetStatus (eReturnStatusFailed);
 444             return false;
 445         }
 446
 447         const BreakpointList &breakpoints = target->GetBreakpointList();
 448         size_t num_breakpoints = breakpoints.GetSize();
 449
 450         if (num_breakpoints == 0)
 451         {
 452             result.AppendError ("No breakpoints exist to have commands added");
 453             result.SetStatus (eReturnStatusFailed);
 454             return false;
 455         }
 456
 457         if (m_options.m_use_script_language == false && m_options.m_function_name.size())
 458         {
 459             result.AppendError ("need to enable scripting to have a function run as a breakpoint command");
 460             result.SetStatus (eReturnStatusFailed);
 461             return false;
 462         }
 463
 464         BreakpointIDList valid_bp_ids;
 465         CommandObjectMultiwordBreakpoint::VerifyBreakpointIDs (command, target, result, &valid_bp_ids);
 466
 467         m_bp_options_vec.clear();
 468
 469         if (result.Succeeded())
 470         {
 471             const size_t count = valid_bp_ids.GetSize();
 472
 473             for (size_t i = 0; i < count; ++i)
 474             {
 475                 BreakpointID cur_bp_id = valid_bp_ids.GetBreakpointIDAtIndex (i);
 476                 if (cur_bp_id.GetBreakpointID() != LLDB_INVALID_BREAK_ID)
 477                 {
 478                     Breakpoint *bp = target->GetBreakpointByID (cur_bp_id.GetBreakpointID()).get();
 479                     BreakpointOptions *bp_options = NULL;
 480                     if (cur_bp_id.GetLocationID() == LLDB_INVALID_BREAK_ID)
 481                     {
 482                         // This breakpoint does not have an associated location.
 483                         bp_options = bp->GetOptions();
 484                     }
 485                     else
 486                     {
 487                         BreakpointLocationSP bp_loc_sp(bp->FindLocationByID (cur_bp_id.GetLocationID()));
 488                         // This breakpoint does have an associated location.
 489                         // Get its breakpoint options.
 490                         if (bp_loc_sp)
 491                             bp_options = bp_loc_sp->GetLocationOptions();
 492                     }
 493                     if (bp_options)
 494                         m_bp_options_vec.push_back (bp_options);
 495                 }
 496             }
 497
 498             // If we are using script language, get the script interpreter
 499             // in order to set or collect command callback.  Otherwise, call
 500             // the methods associated with this object.
 501             if (m_options.m_use_script_language)
 502             {
 503                 ScriptInterpreter *script_interp = m_interpreter.GetScriptInterpreter();
 504                 // Special handling for one-liner specified inline.
 505                 if (m_options.m_use_one_liner)
 506                 {
 507                     script_interp->SetBreakpointCommandCallback (m_bp_options_vec,
 508                                                                  m_options.m_one_liner.c_str());
 509                 }
 510                 else if (m_options.m_function_name.size())
 511                 {
 512                     script_interp->SetBreakpointCommandCallbackFunction (m_bp_options_vec,
 513                                                                          m_options.m_function_name.c_str());
 514                 }
 515                 else
 516                 {
 517                     script_interp->CollectDataForBreakpointCommandCallback (m_bp_options_vec,
 518                                                                             result);
 519                 }
 520             }
 521             else
 522             {
 523                 // Special handling for one-liner specified inline.
 524                 if (m_options.m_use_one_liner)
 525                     SetBreakpointCommandCallback (m_bp_options_vec,
 526                                                   m_options.m_one_liner.c_str());
 527                 else
 528                     CollectDataForBreakpointCommandCallback (m_bp_options_vec,
 529                                                              result);
 530             }
 531
 532         }
 533
 534         return result.Succeeded();
 535     }
 536
 537 private:
 538     CommandOptions m_options;
 539     std::vector<BreakpointOptions *> m_bp_options_vec;  // This stores the breakpoint options that we are currently
 540                                                         // collecting commands for.  In the CollectData... calls we need
 541                                                         // to hand this off to the IOHandler, which may run asynchronously.
 542                                                         // So we have to have some way to keep it alive, and not leak it.
 543                                                         // Making it an ivar of the command object, which never goes away
 544                                                         // achieves this.  Note that if we were able to run
 545                                                         // the same command concurrently in one interpreter we'd have to
 546                                                         // make this "per invocation".  But there are many more reasons
 547                                                         // why it is not in general safe to do that in lldb at present,
 548                                                         // so it isn't worthwhile to come up with a more complex mechanism
 549                                                         // to address this particular weakness right now.
 550     static const char *g_reader_instructions;
 551
 552 };
 553
 554 const char *
 555 CommandObjectBreakpointCommandAdd::g_reader_instructions = "Enter your debugger command(s).  Type 'DONE' to end.\n";
 556
 557 // FIXME: "script-type" needs to have its contents determined dynamically, so somebody can add a new scripting
 558 // language to lldb and have it pickable here without having to change this enumeration by hand and rebuild lldb proper.
 559
 560 static OptionEnumValueElement
 561 g_script_option_enumeration[4] =
 562 {
 563     { eScriptLanguageNone,    "command",         "Commands are in the lldb command interpreter language"},
 564     { eScriptLanguagePython,  "python",          "Commands are in the Python language."},
 565     { eSortOrderByName,       "default-script",  "Commands are in the default scripting language."},
 566     { 0,                      NULL,              NULL }
 567 };
 568
 569 OptionDefinition
 570 CommandObjectBreakpointCommandAdd::CommandOptions::g_option_table[] =
 571 {
 572     { LLDB_OPT_SET_1, false, "one-liner", 'o', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeOneLiner,
 573         "Specify a one-line breakpoint command inline. Be sure to surround it with quotes." },
 574
 575     { LLDB_OPT_SET_ALL, false, "stop-on-error", 'e', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeBoolean,
 576         "Specify whether breakpoint command execution should terminate on error." },
 577
 578     { LLDB_OPT_SET_ALL,   false, "script-type",     's', OptionParser::eRequiredArgument, NULL, g_script_option_enumeration, 0, eArgTypeNone,
 579         "Specify the language for the commands - if none is specified, the lldb command interpreter will be used."},
 580
 581     { LLDB_OPT_SET_2,   false, "python-function",     'F', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypePythonFunction,
 582         "Give the name of a Python function to run as command for this breakpoint. Be sure to give a module name if appropriate."},
 583
 584     { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL }
 585 };
 586
 587 //-------------------------------------------------------------------------
 588 // CommandObjectBreakpointCommandDelete
 589 //-------------------------------------------------------------------------
 590
 591 class CommandObjectBreakpointCommandDelete : public CommandObjectParsed
 592 {
 593 public:
 594     CommandObjectBreakpointCommandDelete (CommandInterpreter &interpreter) :
 595         CommandObjectParsed (interpreter,
 596                              "delete",
 597                              "Delete the set of commands from a breakpoint.",
 598                              NULL)
 599     {
 600         CommandArgumentEntry arg;
 601         CommandArgumentData bp_id_arg;
 602
 603         // Define the first (and only) variant of this arg.
 604         bp_id_arg.arg_type = eArgTypeBreakpointID;
 605         bp_id_arg.arg_repetition = eArgRepeatPlain;
 606
 607         // There is only one variant this argument could be; put it into the argument entry.
 608         arg.push_back (bp_id_arg);
 609
 610         // Push the data for the first argument into the m_arguments vector.
 611         m_arguments.push_back (arg);
 612     }
 613
 614
 615     virtual
 616     ~CommandObjectBreakpointCommandDelete () {}
 617
 618 protected:
 619     virtual bool
 620     DoExecute (Args& command, CommandReturnObject &result)
 621     {
 622         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
 623
 624         if (target == NULL)
 625         {
 626             result.AppendError ("There is not a current executable; there are no breakpoints from which to delete commands");
 627             result.SetStatus (eReturnStatusFailed);
 628             return false;
 629         }
 630
 631         const BreakpointList &breakpoints = target->GetBreakpointList();
 632         size_t num_breakpoints = breakpoints.GetSize();
 633
 634         if (num_breakpoints == 0)
 635         {
 636             result.AppendError ("No breakpoints exist to have commands deleted");
 637             result.SetStatus (eReturnStatusFailed);
 638             return false;
 639         }
 640
 641         if (command.GetArgumentCount() == 0)
 642         {
 643             result.AppendError ("No breakpoint specified from which to delete the commands");
 644             result.SetStatus (eReturnStatusFailed);
 645             return false;
 646         }
 647
 648         BreakpointIDList valid_bp_ids;
 649         CommandObjectMultiwordBreakpoint::VerifyBreakpointIDs (command, target, result, &valid_bp_ids);
 650
 651         if (result.Succeeded())
 652         {
 653             const size_t count = valid_bp_ids.GetSize();
 654             for (size_t i = 0; i < count; ++i)
 655             {
 656                 BreakpointID cur_bp_id = valid_bp_ids.GetBreakpointIDAtIndex (i);
 657                 if (cur_bp_id.GetBreakpointID() != LLDB_INVALID_BREAK_ID)
 658                 {
 659                     Breakpoint *bp = target->GetBreakpointByID (cur_bp_id.GetBreakpointID()).get();
 660                     if (cur_bp_id.GetLocationID() != LLDB_INVALID_BREAK_ID)
 661                     {
 662                         BreakpointLocationSP bp_loc_sp (bp->FindLocationByID (cur_bp_id.GetLocationID()));
 663                         if (bp_loc_sp)
 664                             bp_loc_sp->ClearCallback();
 665                         else
 666                         {
 667                             result.AppendErrorWithFormat("Invalid breakpoint ID: %u.%u.\n",
 668                                                          cur_bp_id.GetBreakpointID(),
 669                                                          cur_bp_id.GetLocationID());
 670                             result.SetStatus (eReturnStatusFailed);
 671                             return false;
 672                         }
 673                     }
 674                     else
 675                     {
 676                         bp->ClearCallback();
 677                     }
 678                 }
 679             }
 680         }
 681         return result.Succeeded();
 682     }
 683 };
 684
 685 //-------------------------------------------------------------------------
 686 // CommandObjectBreakpointCommandList
 687 //-------------------------------------------------------------------------
 688
 689 class CommandObjectBreakpointCommandList : public CommandObjectParsed
 690 {
 691 public:
 692     CommandObjectBreakpointCommandList (CommandInterpreter &interpreter) :
 693         CommandObjectParsed (interpreter,
 694                              "list",
 695                              "List the script or set of commands to be executed when the breakpoint is hit.",
 696                               NULL)
 697     {
 698         CommandArgumentEntry arg;
 699         CommandArgumentData bp_id_arg;
 700
 701         // Define the first (and only) variant of this arg.
 702         bp_id_arg.arg_type = eArgTypeBreakpointID;
 703         bp_id_arg.arg_repetition = eArgRepeatPlain;
 704
 705         // There is only one variant this argument could be; put it into the argument entry.
 706         arg.push_back (bp_id_arg);
 707
 708         // Push the data for the first argument into the m_arguments vector.
 709         m_arguments.push_back (arg);
 710     }
 711
 712     virtual
 713     ~CommandObjectBreakpointCommandList () {}
 714
 715 protected:
 716     virtual bool
 717     DoExecute (Args& command,
 718              CommandReturnObject &result)
 719     {
 720         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
 721
 722         if (target == NULL)
 723         {
 724             result.AppendError ("There is not a current executable; there are no breakpoints for which to list commands");
 725             result.SetStatus (eReturnStatusFailed);
 726             return false;
 727         }
 728
 729         const BreakpointList &breakpoints = target->GetBreakpointList();
 730         size_t num_breakpoints = breakpoints.GetSize();
 731
 732         if (num_breakpoints == 0)
 733         {
 734             result.AppendError ("No breakpoints exist for which to list commands");
 735             result.SetStatus (eReturnStatusFailed);
 736             return false;
 737         }
 738
 739         if (command.GetArgumentCount() == 0)
 740         {
 741             result.AppendError ("No breakpoint specified for which to list the commands");
 742             result.SetStatus (eReturnStatusFailed);
 743             return false;
 744         }
 745
 746         BreakpointIDList valid_bp_ids;
 747         CommandObjectMultiwordBreakpoint::VerifyBreakpointIDs (command, target, result, &valid_bp_ids);
 748
 749         if (result.Succeeded())
 750         {
 751             const size_t count = valid_bp_ids.GetSize();
 752             for (size_t i = 0; i < count; ++i)
 753             {
 754                 BreakpointID cur_bp_id = valid_bp_ids.GetBreakpointIDAtIndex (i);
 755                 if (cur_bp_id.GetBreakpointID() != LLDB_INVALID_BREAK_ID)
 756                 {
 757                     Breakpoint *bp = target->GetBreakpointByID (cur_bp_id.GetBreakpointID()).get();
 758
 759                     if (bp)
 760                     {
 761                         const BreakpointOptions *bp_options = NULL;
 762                         if (cur_bp_id.GetLocationID() != LLDB_INVALID_BREAK_ID)
 763                         {
 764                             BreakpointLocationSP bp_loc_sp(bp->FindLocationByID (cur_bp_id.GetLocationID()));
 765                             if (bp_loc_sp)
 766                                 bp_options = bp_loc_sp->GetOptionsNoCreate();
 767                             else
 768                             {
 769                                 result.AppendErrorWithFormat("Invalid breakpoint ID: %u.%u.\n",
 770                                                              cur_bp_id.GetBreakpointID(),
 771                                                              cur_bp_id.GetLocationID());
 772                                 result.SetStatus (eReturnStatusFailed);
 773                                 return false;
 774                             }
 775                         }
 776                         else
 777                         {
 778                             bp_options = bp->GetOptions();
 779                         }
 780
 781                         if (bp_options)
 782                         {
 783                             StreamString id_str;
 784                             BreakpointID::GetCanonicalReference (&id_str,
 785                                                                  cur_bp_id.GetBreakpointID(),
 786                                                                  cur_bp_id.GetLocationID());
 787                             const Baton *baton = bp_options->GetBaton();
 788                             if (baton)
 789                             {
 790                                 result.GetOutputStream().Printf ("Breakpoint %s:\n", id_str.GetData());
 791                                 result.GetOutputStream().IndentMore ();
 792                                 baton->GetDescription(&result.GetOutputStream(), eDescriptionLevelFull);
 793                                 result.GetOutputStream().IndentLess ();
 794                             }
 795                             else
 796                             {
 797                                 result.AppendMessageWithFormat ("Breakpoint %s does not have an associated command.\n",
 798                                                                 id_str.GetData());
 799                             }
 800                         }
 801                         result.SetStatus (eReturnStatusSuccessFinishResult);
 802                     }
 803                     else
 804                     {
 805                         result.AppendErrorWithFormat("Invalid breakpoint ID: %u.\n", cur_bp_id.GetBreakpointID());
 806                         result.SetStatus (eReturnStatusFailed);
 807                     }
 808
 809                 }
 810             }
 811         }
 812
 813         return result.Succeeded();
 814     }
 815 };
 816
 817 //-------------------------------------------------------------------------
 818 // CommandObjectBreakpointCommand
 819 //-------------------------------------------------------------------------
 820
 821 CommandObjectBreakpointCommand::CommandObjectBreakpointCommand (CommandInterpreter &interpreter) :
 822     CommandObjectMultiword (interpreter,
 823                             "command",
 824                             "A set of commands for adding, removing and examining bits of code to be executed when the breakpoint is hit (breakpoint 'commands').",
 825                             "command <sub-command> [<sub-command-options>] <breakpoint-id>")
 826 {
 827     CommandObjectSP add_command_object (new CommandObjectBreakpointCommandAdd (interpreter));
 828     CommandObjectSP delete_command_object (new CommandObjectBreakpointCommandDelete (interpreter));
 829     CommandObjectSP list_command_object (new CommandObjectBreakpointCommandList (interpreter));
 830
 831     add_command_object->SetCommandName ("breakpoint command add");
 832     delete_command_object->SetCommandName ("breakpoint command delete");
 833     list_command_object->SetCommandName ("breakpoint command list");
 834
 835     LoadSubCommand ("add",    add_command_object);
 836     LoadSubCommand ("delete", delete_command_object);
 837     LoadSubCommand ("list",   list_command_object);
 838 }
 839
 840 CommandObjectBreakpointCommand::~CommandObjectBreakpointCommand ()
 841 {
 842 }
 843
 844