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 CommandInterpreterRunOptions options; 311 options.SetStopOnContinue(true); 312 options.SetStopOnError (data->stop_on_error); 313 options.SetEchoCommands (true); 314 options.SetPrintResults (true); 315 options.SetAddToHistory (false); 316 317 debugger.GetCommandInterpreter().HandleCommands (commands, 318 &exe_ctx, 319 options, 320 result); 321 result.GetImmediateOutputStream()->Flush(); 322 result.GetImmediateErrorStream()->Flush(); 323 } 324 } 325 return ret_value; 326 } 327 328 class CommandOptions : public Options 329 { 330 public: 331 332 CommandOptions (CommandInterpreter &interpreter) : 333 Options (interpreter), 334 m_use_commands (false), 335 m_use_script_language (false), 336 m_script_language (eScriptLanguageNone), 337 m_use_one_liner (false), 338 m_one_liner(), 339 m_function_name() 340 { 341 } 342 343 virtual 344 ~CommandOptions () {} 345 346 virtual Error 347 SetOptionValue (uint32_t option_idx, const char *option_arg) 348 { 349 Error error; 350 const int short_option = m_getopt_table[option_idx].val; 351 352 switch (short_option) 353 { 354 case 'o': 355 m_use_one_liner = true; 356 m_one_liner = option_arg; 357 break; 358 359 case 's': 360 m_script_language = (lldb::ScriptLanguage) Args::StringToOptionEnum (option_arg, 361 g_option_table[option_idx].enum_values, 362 eScriptLanguageNone, 363 error); 364 365 if (m_script_language == eScriptLanguagePython || m_script_language == eScriptLanguageDefault) 366 { 367 m_use_script_language = true; 368 } 369 else 370 { 371 m_use_script_language = false; 372 } 373 break; 374 375 case 'e': 376 { 377 bool success = false; 378 m_stop_on_error = Args::StringToBoolean(option_arg, false, &success); 379 if (!success) 380 error.SetErrorStringWithFormat("invalid value for stop-on-error: \"%s\"", option_arg); 381 } 382 break; 383 384 case 'F': 385 { 386 m_use_one_liner = false; 387 m_use_script_language = true; 388 m_function_name.assign(option_arg); 389 } 390 break; 391 392 case 'D': 393 m_use_dummy = true; 394 break; 395 396 default: 397 break; 398 } 399 return error; 400 } 401 void 402 OptionParsingStarting () 403 { 404 m_use_commands = true; 405 m_use_script_language = false; 406 m_script_language = eScriptLanguageNone; 407 408 m_use_one_liner = false; 409 m_stop_on_error = true; 410 m_one_liner.clear(); 411 m_function_name.clear(); 412 m_use_dummy = false; 413 } 414 415 const OptionDefinition* 416 GetDefinitions () 417 { 418 return g_option_table; 419 } 420 421 // Options table: Required for subclasses of Options. 422 423 static OptionDefinition g_option_table[]; 424 425 // Instance variables to hold the values for command options. 426 427 bool m_use_commands; 428 bool m_use_script_language; 429 lldb::ScriptLanguage m_script_language; 430 431 // Instance variables to hold the values for one_liner options. 432 bool m_use_one_liner; 433 std::string m_one_liner; 434 bool m_stop_on_error; 435 std::string m_function_name; 436 bool m_use_dummy; 437 }; 438 439 protected: 440 virtual bool 441 DoExecute (Args& command, CommandReturnObject &result) 442 { 443 Target *target = GetSelectedOrDummyTarget(m_options.m_use_dummy); 444 445 if (target == NULL) 446 { 447 result.AppendError ("There is not a current executable; there are no breakpoints to which to add commands"); 448 result.SetStatus (eReturnStatusFailed); 449 return false; 450 } 451 452 const BreakpointList &breakpoints = target->GetBreakpointList(); 453 size_t num_breakpoints = breakpoints.GetSize(); 454 455 if (num_breakpoints == 0) 456 { 457 result.AppendError ("No breakpoints exist to have commands added"); 458 result.SetStatus (eReturnStatusFailed); 459 return false; 460 } 461 462 if (m_options.m_use_script_language == false && m_options.m_function_name.size()) 463 { 464 result.AppendError ("need to enable scripting to have a function run as a breakpoint command"); 465 result.SetStatus (eReturnStatusFailed); 466 return false; 467 } 468 469 BreakpointIDList valid_bp_ids; 470 CommandObjectMultiwordBreakpoint::VerifyBreakpointOrLocationIDs (command, target, result, &valid_bp_ids); 471 472 m_bp_options_vec.clear(); 473 474 if (result.Succeeded()) 475 { 476 const size_t count = valid_bp_ids.GetSize(); 477 478 for (size_t i = 0; i < count; ++i) 479 { 480 BreakpointID cur_bp_id = valid_bp_ids.GetBreakpointIDAtIndex (i); 481 if (cur_bp_id.GetBreakpointID() != LLDB_INVALID_BREAK_ID) 482 { 483 Breakpoint *bp = target->GetBreakpointByID (cur_bp_id.GetBreakpointID()).get(); 484 BreakpointOptions *bp_options = NULL; 485 if (cur_bp_id.GetLocationID() == LLDB_INVALID_BREAK_ID) 486 { 487 // This breakpoint does not have an associated location. 488 bp_options = bp->GetOptions(); 489 } 490 else 491 { 492 BreakpointLocationSP bp_loc_sp(bp->FindLocationByID (cur_bp_id.GetLocationID())); 493 // This breakpoint does have an associated location. 494 // Get its breakpoint options. 495 if (bp_loc_sp) 496 bp_options = bp_loc_sp->GetLocationOptions(); 497 } 498 if (bp_options) 499 m_bp_options_vec.push_back (bp_options); 500 } 501 } 502 503 // If we are using script language, get the script interpreter 504 // in order to set or collect command callback. Otherwise, call 505 // the methods associated with this object. 506 if (m_options.m_use_script_language) 507 { 508 ScriptInterpreter *script_interp = m_interpreter.GetScriptInterpreter(); 509 // Special handling for one-liner specified inline. 510 if (m_options.m_use_one_liner) 511 { 512 script_interp->SetBreakpointCommandCallback (m_bp_options_vec, 513 m_options.m_one_liner.c_str()); 514 } 515 else if (m_options.m_function_name.size()) 516 { 517 script_interp->SetBreakpointCommandCallbackFunction (m_bp_options_vec, 518 m_options.m_function_name.c_str()); 519 } 520 else 521 { 522 script_interp->CollectDataForBreakpointCommandCallback (m_bp_options_vec, 523 result); 524 } 525 } 526 else 527 { 528 // Special handling for one-liner specified inline. 529 if (m_options.m_use_one_liner) 530 SetBreakpointCommandCallback (m_bp_options_vec, 531 m_options.m_one_liner.c_str()); 532 else 533 CollectDataForBreakpointCommandCallback (m_bp_options_vec, 534 result); 535 } 536 537 } 538 539 return result.Succeeded(); 540 } 541 542 private: 543 CommandOptions m_options; 544 std::vector<BreakpointOptions *> m_bp_options_vec; // This stores the breakpoint options that we are currently 545 // collecting commands for. In the CollectData... calls we need 546 // to hand this off to the IOHandler, which may run asynchronously. 547 // So we have to have some way to keep it alive, and not leak it. 548 // Making it an ivar of the command object, which never goes away 549 // achieves this. Note that if we were able to run 550 // the same command concurrently in one interpreter we'd have to 551 // make this "per invocation". But there are many more reasons 552 // why it is not in general safe to do that in lldb at present, 553 // so it isn't worthwhile to come up with a more complex mechanism 554 // to address this particular weakness right now. 555 static const char *g_reader_instructions; 556 557 }; 558 559 const char * 560 CommandObjectBreakpointCommandAdd::g_reader_instructions = "Enter your debugger command(s). Type 'DONE' to end.\n"; 561 562 // FIXME: "script-type" needs to have its contents determined dynamically, so somebody can add a new scripting 563 // language to lldb and have it pickable here without having to change this enumeration by hand and rebuild lldb proper. 564 565 static OptionEnumValueElement 566 g_script_option_enumeration[4] = 567 { 568 { eScriptLanguageNone, "command", "Commands are in the lldb command interpreter language"}, 569 { eScriptLanguagePython, "python", "Commands are in the Python language."}, 570 { eSortOrderByName, "default-script", "Commands are in the default scripting language."}, 571 { 0, NULL, NULL } 572 }; 573 574 OptionDefinition 575 CommandObjectBreakpointCommandAdd::CommandOptions::g_option_table[] = 576 { 577 { LLDB_OPT_SET_1, false, "one-liner", 'o', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeOneLiner, 578 "Specify a one-line breakpoint command inline. Be sure to surround it with quotes." }, 579 580 { LLDB_OPT_SET_ALL, false, "stop-on-error", 'e', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeBoolean, 581 "Specify whether breakpoint command execution should terminate on error." }, 582 583 { LLDB_OPT_SET_ALL, false, "script-type", 's', OptionParser::eRequiredArgument, NULL, g_script_option_enumeration, 0, eArgTypeNone, 584 "Specify the language for the commands - if none is specified, the lldb command interpreter will be used."}, 585 586 { LLDB_OPT_SET_2, false, "python-function", 'F', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypePythonFunction, 587 "Give the name of a Python function to run as command for this breakpoint. Be sure to give a module name if appropriate."}, 588 589 { LLDB_OPT_SET_ALL, false, "dummy-breakpoints", 'D', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone, 590 "Sets Dummy breakpoints - i.e. breakpoints set before a file is provided, which prime new targets."}, 591 592 { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL } 593 }; 594 595 //------------------------------------------------------------------------- 596 // CommandObjectBreakpointCommandDelete 597 //------------------------------------------------------------------------- 598 599 class CommandObjectBreakpointCommandDelete : public CommandObjectParsed 600 { 601 public: 602 CommandObjectBreakpointCommandDelete (CommandInterpreter &interpreter) : 603 CommandObjectParsed (interpreter, 604 "delete", 605 "Delete the set of commands from a breakpoint.", 606 NULL), 607 m_options (interpreter) 608 { 609 CommandArgumentEntry arg; 610 CommandArgumentData bp_id_arg; 611 612 // Define the first (and only) variant of this arg. 613 bp_id_arg.arg_type = eArgTypeBreakpointID; 614 bp_id_arg.arg_repetition = eArgRepeatPlain; 615 616 // There is only one variant this argument could be; put it into the argument entry. 617 arg.push_back (bp_id_arg); 618 619 // Push the data for the first argument into the m_arguments vector. 620 m_arguments.push_back (arg); 621 } 622 623 624 virtual 625 ~CommandObjectBreakpointCommandDelete () {} 626 627 virtual Options * 628 GetOptions () 629 { 630 return &m_options; 631 } 632 633 class CommandOptions : public Options 634 { 635 public: 636 637 CommandOptions (CommandInterpreter &interpreter) : 638 Options (interpreter), 639 m_use_dummy (false) 640 { 641 } 642 643 virtual 644 ~CommandOptions () {} 645 646 virtual Error 647 SetOptionValue (uint32_t option_idx, const char *option_arg) 648 { 649 Error error; 650 const int short_option = m_getopt_table[option_idx].val; 651 652 switch (short_option) 653 { 654 case 'D': 655 m_use_dummy = true; 656 break; 657 658 default: 659 error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option); 660 break; 661 } 662 663 return error; 664 } 665 666 void 667 OptionParsingStarting () 668 { 669 m_use_dummy = false; 670 } 671 672 const OptionDefinition* 673 GetDefinitions () 674 { 675 return g_option_table; 676 } 677 678 // Options table: Required for subclasses of Options. 679 680 static OptionDefinition g_option_table[]; 681 682 // Instance variables to hold the values for command options. 683 bool m_use_dummy; 684 }; 685 686 protected: 687 virtual bool 688 DoExecute (Args& command, CommandReturnObject &result) 689 { 690 Target *target = GetSelectedOrDummyTarget(m_options.m_use_dummy); 691 692 if (target == NULL) 693 { 694 result.AppendError ("There is not a current executable; there are no breakpoints from which to delete commands"); 695 result.SetStatus (eReturnStatusFailed); 696 return false; 697 } 698 699 const BreakpointList &breakpoints = target->GetBreakpointList(); 700 size_t num_breakpoints = breakpoints.GetSize(); 701 702 if (num_breakpoints == 0) 703 { 704 result.AppendError ("No breakpoints exist to have commands deleted"); 705 result.SetStatus (eReturnStatusFailed); 706 return false; 707 } 708 709 if (command.GetArgumentCount() == 0) 710 { 711 result.AppendError ("No breakpoint specified from which to delete the commands"); 712 result.SetStatus (eReturnStatusFailed); 713 return false; 714 } 715 716 BreakpointIDList valid_bp_ids; 717 CommandObjectMultiwordBreakpoint::VerifyBreakpointOrLocationIDs (command, target, result, &valid_bp_ids); 718 719 if (result.Succeeded()) 720 { 721 const size_t count = valid_bp_ids.GetSize(); 722 for (size_t i = 0; i < count; ++i) 723 { 724 BreakpointID cur_bp_id = valid_bp_ids.GetBreakpointIDAtIndex (i); 725 if (cur_bp_id.GetBreakpointID() != LLDB_INVALID_BREAK_ID) 726 { 727 Breakpoint *bp = target->GetBreakpointByID (cur_bp_id.GetBreakpointID()).get(); 728 if (cur_bp_id.GetLocationID() != LLDB_INVALID_BREAK_ID) 729 { 730 BreakpointLocationSP bp_loc_sp (bp->FindLocationByID (cur_bp_id.GetLocationID())); 731 if (bp_loc_sp) 732 bp_loc_sp->ClearCallback(); 733 else 734 { 735 result.AppendErrorWithFormat("Invalid breakpoint ID: %u.%u.\n", 736 cur_bp_id.GetBreakpointID(), 737 cur_bp_id.GetLocationID()); 738 result.SetStatus (eReturnStatusFailed); 739 return false; 740 } 741 } 742 else 743 { 744 bp->ClearCallback(); 745 } 746 } 747 } 748 } 749 return result.Succeeded(); 750 } 751 private: 752 CommandOptions m_options; 753 }; 754 755 OptionDefinition 756 CommandObjectBreakpointCommandDelete::CommandOptions::g_option_table[] = 757 { 758 { LLDB_OPT_SET_1, false, "dummy-breakpoints", 'D', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone, 759 "Delete commands from Dummy breakpoints - i.e. breakpoints set before a file is provided, which prime new targets."}, 760 761 { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL } 762 }; 763 764 765 //------------------------------------------------------------------------- 766 // CommandObjectBreakpointCommandList 767 //------------------------------------------------------------------------- 768 769 class CommandObjectBreakpointCommandList : public CommandObjectParsed 770 { 771 public: 772 CommandObjectBreakpointCommandList (CommandInterpreter &interpreter) : 773 CommandObjectParsed (interpreter, 774 "list", 775 "List the script or set of commands to be executed when the breakpoint is hit.", 776 NULL) 777 { 778 CommandArgumentEntry arg; 779 CommandArgumentData bp_id_arg; 780 781 // Define the first (and only) variant of this arg. 782 bp_id_arg.arg_type = eArgTypeBreakpointID; 783 bp_id_arg.arg_repetition = eArgRepeatPlain; 784 785 // There is only one variant this argument could be; put it into the argument entry. 786 arg.push_back (bp_id_arg); 787 788 // Push the data for the first argument into the m_arguments vector. 789 m_arguments.push_back (arg); 790 } 791 792 virtual 793 ~CommandObjectBreakpointCommandList () {} 794 795 protected: 796 virtual bool 797 DoExecute (Args& command, 798 CommandReturnObject &result) 799 { 800 Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get(); 801 802 if (target == NULL) 803 { 804 result.AppendError ("There is not a current executable; there are no breakpoints for which to list commands"); 805 result.SetStatus (eReturnStatusFailed); 806 return false; 807 } 808 809 const BreakpointList &breakpoints = target->GetBreakpointList(); 810 size_t num_breakpoints = breakpoints.GetSize(); 811 812 if (num_breakpoints == 0) 813 { 814 result.AppendError ("No breakpoints exist for which to list commands"); 815 result.SetStatus (eReturnStatusFailed); 816 return false; 817 } 818 819 if (command.GetArgumentCount() == 0) 820 { 821 result.AppendError ("No breakpoint specified for which to list the commands"); 822 result.SetStatus (eReturnStatusFailed); 823 return false; 824 } 825 826 BreakpointIDList valid_bp_ids; 827 CommandObjectMultiwordBreakpoint::VerifyBreakpointOrLocationIDs (command, target, result, &valid_bp_ids); 828 829 if (result.Succeeded()) 830 { 831 const size_t count = valid_bp_ids.GetSize(); 832 for (size_t i = 0; i < count; ++i) 833 { 834 BreakpointID cur_bp_id = valid_bp_ids.GetBreakpointIDAtIndex (i); 835 if (cur_bp_id.GetBreakpointID() != LLDB_INVALID_BREAK_ID) 836 { 837 Breakpoint *bp = target->GetBreakpointByID (cur_bp_id.GetBreakpointID()).get(); 838 839 if (bp) 840 { 841 const BreakpointOptions *bp_options = NULL; 842 if (cur_bp_id.GetLocationID() != LLDB_INVALID_BREAK_ID) 843 { 844 BreakpointLocationSP bp_loc_sp(bp->FindLocationByID (cur_bp_id.GetLocationID())); 845 if (bp_loc_sp) 846 bp_options = bp_loc_sp->GetOptionsNoCreate(); 847 else 848 { 849 result.AppendErrorWithFormat("Invalid breakpoint ID: %u.%u.\n", 850 cur_bp_id.GetBreakpointID(), 851 cur_bp_id.GetLocationID()); 852 result.SetStatus (eReturnStatusFailed); 853 return false; 854 } 855 } 856 else 857 { 858 bp_options = bp->GetOptions(); 859 } 860 861 if (bp_options) 862 { 863 StreamString id_str; 864 BreakpointID::GetCanonicalReference (&id_str, 865 cur_bp_id.GetBreakpointID(), 866 cur_bp_id.GetLocationID()); 867 const Baton *baton = bp_options->GetBaton(); 868 if (baton) 869 { 870 result.GetOutputStream().Printf ("Breakpoint %s:\n", id_str.GetData()); 871 result.GetOutputStream().IndentMore (); 872 baton->GetDescription(&result.GetOutputStream(), eDescriptionLevelFull); 873 result.GetOutputStream().IndentLess (); 874 } 875 else 876 { 877 result.AppendMessageWithFormat ("Breakpoint %s does not have an associated command.\n", 878 id_str.GetData()); 879 } 880 } 881 result.SetStatus (eReturnStatusSuccessFinishResult); 882 } 883 else 884 { 885 result.AppendErrorWithFormat("Invalid breakpoint ID: %u.\n", cur_bp_id.GetBreakpointID()); 886 result.SetStatus (eReturnStatusFailed); 887 } 888 889 } 890 } 891 } 892 893 return result.Succeeded(); 894 } 895 }; 896 897 //------------------------------------------------------------------------- 898 // CommandObjectBreakpointCommand 899 //------------------------------------------------------------------------- 900 901 CommandObjectBreakpointCommand::CommandObjectBreakpointCommand (CommandInterpreter &interpreter) : 902 CommandObjectMultiword (interpreter, 903 "command", 904 "A set of commands for adding, removing and examining bits of code to be executed when the breakpoint is hit (breakpoint 'commands').", 905 "command <sub-command> [<sub-command-options>] <breakpoint-id>") 906 { 907 CommandObjectSP add_command_object (new CommandObjectBreakpointCommandAdd (interpreter)); 908 CommandObjectSP delete_command_object (new CommandObjectBreakpointCommandDelete (interpreter)); 909 CommandObjectSP list_command_object (new CommandObjectBreakpointCommandList (interpreter)); 910 911 add_command_object->SetCommandName ("breakpoint command add"); 912 delete_command_object->SetCommandName ("breakpoint command delete"); 913 list_command_object->SetCommandName ("breakpoint command list"); 914 915 LoadSubCommand ("add", add_command_object); 916 LoadSubCommand ("delete", delete_command_object); 917 LoadSubCommand ("list", list_command_object); 918 } 919 920 CommandObjectBreakpointCommand::~CommandObjectBreakpointCommand () 921 { 922 } 923 924 925