1 //===-- CommandObjectBreakpoint.cpp -----------------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "CommandObjectBreakpoint.h" 10 #include "CommandObjectBreakpointCommand.h" 11 #include "lldb/Breakpoint/Breakpoint.h" 12 #include "lldb/Breakpoint/BreakpointIDList.h" 13 #include "lldb/Breakpoint/BreakpointLocation.h" 14 #include "lldb/Host/OptionParser.h" 15 #include "lldb/Interpreter/CommandInterpreter.h" 16 #include "lldb/Interpreter/CommandReturnObject.h" 17 #include "lldb/Interpreter/OptionArgParser.h" 18 #include "lldb/Interpreter/OptionGroupPythonClassWithDict.h" 19 #include "lldb/Interpreter/OptionValueBoolean.h" 20 #include "lldb/Interpreter/OptionValueString.h" 21 #include "lldb/Interpreter/OptionValueUInt64.h" 22 #include "lldb/Interpreter/Options.h" 23 #include "lldb/Target/Language.h" 24 #include "lldb/Target/StackFrame.h" 25 #include "lldb/Target/Target.h" 26 #include "lldb/Target/ThreadSpec.h" 27 #include "lldb/Utility/RegularExpression.h" 28 #include "lldb/Utility/StreamString.h" 29 30 #include <memory> 31 #include <vector> 32 33 using namespace lldb; 34 using namespace lldb_private; 35 36 static void AddBreakpointDescription(Stream *s, Breakpoint *bp, 37 lldb::DescriptionLevel level) { 38 s->IndentMore(); 39 bp->GetDescription(s, level, true); 40 s->IndentLess(); 41 s->EOL(); 42 } 43 44 // Modifiable Breakpoint Options 45 #pragma mark Modify::CommandOptions 46 #define LLDB_OPTIONS_breakpoint_modify 47 #include "CommandOptions.inc" 48 49 class lldb_private::BreakpointOptionGroup : public OptionGroup { 50 public: 51 BreakpointOptionGroup() : OptionGroup(), m_bp_opts(false) {} 52 53 ~BreakpointOptionGroup() override = default; 54 55 llvm::ArrayRef<OptionDefinition> GetDefinitions() override { 56 return llvm::makeArrayRef(g_breakpoint_modify_options); 57 } 58 59 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, 60 ExecutionContext *execution_context) override { 61 Status error; 62 const int short_option = 63 g_breakpoint_modify_options[option_idx].short_option; 64 65 switch (short_option) { 66 case 'c': 67 // Normally an empty breakpoint condition marks is as unset. But we need 68 // to say it was passed in. 69 m_bp_opts.SetCondition(option_arg.str().c_str()); 70 m_bp_opts.m_set_flags.Set(BreakpointOptions::eCondition); 71 break; 72 case 'C': 73 m_commands.push_back(option_arg); 74 break; 75 case 'd': 76 m_bp_opts.SetEnabled(false); 77 break; 78 case 'e': 79 m_bp_opts.SetEnabled(true); 80 break; 81 case 'G': { 82 bool value, success; 83 value = OptionArgParser::ToBoolean(option_arg, false, &success); 84 if (success) { 85 m_bp_opts.SetAutoContinue(value); 86 } else 87 error.SetErrorStringWithFormat( 88 "invalid boolean value '%s' passed for -G option", 89 option_arg.str().c_str()); 90 } break; 91 case 'i': { 92 uint32_t ignore_count; 93 if (option_arg.getAsInteger(0, ignore_count)) 94 error.SetErrorStringWithFormat("invalid ignore count '%s'", 95 option_arg.str().c_str()); 96 else 97 m_bp_opts.SetIgnoreCount(ignore_count); 98 } break; 99 case 'o': { 100 bool value, success; 101 value = OptionArgParser::ToBoolean(option_arg, false, &success); 102 if (success) { 103 m_bp_opts.SetOneShot(value); 104 } else 105 error.SetErrorStringWithFormat( 106 "invalid boolean value '%s' passed for -o option", 107 option_arg.str().c_str()); 108 } break; 109 case 't': { 110 lldb::tid_t thread_id = LLDB_INVALID_THREAD_ID; 111 if (option_arg[0] != '\0') { 112 if (option_arg.getAsInteger(0, thread_id)) 113 error.SetErrorStringWithFormat("invalid thread id string '%s'", 114 option_arg.str().c_str()); 115 } 116 m_bp_opts.SetThreadID(thread_id); 117 } break; 118 case 'T': 119 m_bp_opts.GetThreadSpec()->SetName(option_arg.str().c_str()); 120 break; 121 case 'q': 122 m_bp_opts.GetThreadSpec()->SetQueueName(option_arg.str().c_str()); 123 break; 124 case 'x': { 125 uint32_t thread_index = UINT32_MAX; 126 if (option_arg[0] != '\n') { 127 if (option_arg.getAsInteger(0, thread_index)) 128 error.SetErrorStringWithFormat("invalid thread index string '%s'", 129 option_arg.str().c_str()); 130 } 131 m_bp_opts.GetThreadSpec()->SetIndex(thread_index); 132 } break; 133 default: 134 llvm_unreachable("Unimplemented option"); 135 } 136 137 return error; 138 } 139 140 void OptionParsingStarting(ExecutionContext *execution_context) override { 141 m_bp_opts.Clear(); 142 m_commands.clear(); 143 } 144 145 Status OptionParsingFinished(ExecutionContext *execution_context) override { 146 if (!m_commands.empty()) { 147 auto cmd_data = std::make_unique<BreakpointOptions::CommandData>(); 148 149 for (std::string &str : m_commands) 150 cmd_data->user_source.AppendString(str); 151 152 cmd_data->stop_on_error = true; 153 m_bp_opts.SetCommandDataCallback(cmd_data); 154 } 155 return Status(); 156 } 157 158 const BreakpointOptions &GetBreakpointOptions() { return m_bp_opts; } 159 160 std::vector<std::string> m_commands; 161 BreakpointOptions m_bp_opts; 162 }; 163 164 #define LLDB_OPTIONS_breakpoint_dummy 165 #include "CommandOptions.inc" 166 167 class BreakpointDummyOptionGroup : public OptionGroup { 168 public: 169 BreakpointDummyOptionGroup() : OptionGroup() {} 170 171 ~BreakpointDummyOptionGroup() override = default; 172 173 llvm::ArrayRef<OptionDefinition> GetDefinitions() override { 174 return llvm::makeArrayRef(g_breakpoint_dummy_options); 175 } 176 177 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, 178 ExecutionContext *execution_context) override { 179 Status error; 180 const int short_option = 181 g_breakpoint_dummy_options[option_idx].short_option; 182 183 switch (short_option) { 184 case 'D': 185 m_use_dummy = true; 186 break; 187 default: 188 llvm_unreachable("Unimplemented option"); 189 } 190 191 return error; 192 } 193 194 void OptionParsingStarting(ExecutionContext *execution_context) override { 195 m_use_dummy = false; 196 } 197 198 bool m_use_dummy; 199 }; 200 201 #define LLDB_OPTIONS_breakpoint_set 202 #include "CommandOptions.inc" 203 204 // CommandObjectBreakpointSet 205 206 class CommandObjectBreakpointSet : public CommandObjectParsed { 207 public: 208 enum BreakpointSetType { 209 eSetTypeInvalid, 210 eSetTypeFileAndLine, 211 eSetTypeAddress, 212 eSetTypeFunctionName, 213 eSetTypeFunctionRegexp, 214 eSetTypeSourceRegexp, 215 eSetTypeException, 216 eSetTypeScripted, 217 }; 218 219 CommandObjectBreakpointSet(CommandInterpreter &interpreter) 220 : CommandObjectParsed( 221 interpreter, "breakpoint set", 222 "Sets a breakpoint or set of breakpoints in the executable.", 223 "breakpoint set <cmd-options>"), 224 m_bp_opts(), m_python_class_options("scripted breakpoint", true, 'P'), 225 m_options() { 226 // We're picking up all the normal options, commands and disable. 227 m_all_options.Append(&m_python_class_options, 228 LLDB_OPT_SET_1 | LLDB_OPT_SET_2, LLDB_OPT_SET_11); 229 m_all_options.Append(&m_bp_opts, 230 LLDB_OPT_SET_1 | LLDB_OPT_SET_3 | LLDB_OPT_SET_4, 231 LLDB_OPT_SET_ALL); 232 m_all_options.Append(&m_dummy_options, LLDB_OPT_SET_1, LLDB_OPT_SET_ALL); 233 m_all_options.Append(&m_options); 234 m_all_options.Finalize(); 235 } 236 237 ~CommandObjectBreakpointSet() override = default; 238 239 Options *GetOptions() override { return &m_all_options; } 240 241 class CommandOptions : public OptionGroup { 242 public: 243 CommandOptions() 244 : OptionGroup(), m_condition(), m_filenames(), m_line_num(0), 245 m_column(0), m_func_names(), 246 m_func_name_type_mask(eFunctionNameTypeNone), m_func_regexp(), 247 m_source_text_regexp(), m_modules(), m_load_addr(), m_catch_bp(false), 248 m_throw_bp(true), m_hardware(false), 249 m_exception_language(eLanguageTypeUnknown), 250 m_language(lldb::eLanguageTypeUnknown), 251 m_skip_prologue(eLazyBoolCalculate), m_all_files(false), 252 m_move_to_nearest_code(eLazyBoolCalculate) {} 253 254 ~CommandOptions() override = default; 255 256 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, 257 ExecutionContext *execution_context) override { 258 Status error; 259 const int short_option = 260 g_breakpoint_set_options[option_idx].short_option; 261 262 switch (short_option) { 263 case 'a': { 264 m_load_addr = OptionArgParser::ToAddress(execution_context, option_arg, 265 LLDB_INVALID_ADDRESS, &error); 266 } break; 267 268 case 'A': 269 m_all_files = true; 270 break; 271 272 case 'b': 273 m_func_names.push_back(option_arg); 274 m_func_name_type_mask |= eFunctionNameTypeBase; 275 break; 276 277 case 'C': 278 if (option_arg.getAsInteger(0, m_column)) 279 error.SetErrorStringWithFormat("invalid column number: %s", 280 option_arg.str().c_str()); 281 break; 282 283 case 'E': { 284 LanguageType language = Language::GetLanguageTypeFromString(option_arg); 285 286 switch (language) { 287 case eLanguageTypeC89: 288 case eLanguageTypeC: 289 case eLanguageTypeC99: 290 case eLanguageTypeC11: 291 m_exception_language = eLanguageTypeC; 292 break; 293 case eLanguageTypeC_plus_plus: 294 case eLanguageTypeC_plus_plus_03: 295 case eLanguageTypeC_plus_plus_11: 296 case eLanguageTypeC_plus_plus_14: 297 m_exception_language = eLanguageTypeC_plus_plus; 298 break; 299 case eLanguageTypeObjC: 300 m_exception_language = eLanguageTypeObjC; 301 break; 302 case eLanguageTypeObjC_plus_plus: 303 error.SetErrorStringWithFormat( 304 "Set exception breakpoints separately for c++ and objective-c"); 305 break; 306 case eLanguageTypeUnknown: 307 error.SetErrorStringWithFormat( 308 "Unknown language type: '%s' for exception breakpoint", 309 option_arg.str().c_str()); 310 break; 311 default: 312 error.SetErrorStringWithFormat( 313 "Unsupported language type: '%s' for exception breakpoint", 314 option_arg.str().c_str()); 315 } 316 } break; 317 318 case 'f': 319 m_filenames.AppendIfUnique(FileSpec(option_arg)); 320 break; 321 322 case 'F': 323 m_func_names.push_back(option_arg); 324 m_func_name_type_mask |= eFunctionNameTypeFull; 325 break; 326 327 case 'h': { 328 bool success; 329 m_catch_bp = OptionArgParser::ToBoolean(option_arg, true, &success); 330 if (!success) 331 error.SetErrorStringWithFormat( 332 "Invalid boolean value for on-catch option: '%s'", 333 option_arg.str().c_str()); 334 } break; 335 336 case 'H': 337 m_hardware = true; 338 break; 339 340 case 'K': { 341 bool success; 342 bool value; 343 value = OptionArgParser::ToBoolean(option_arg, true, &success); 344 if (value) 345 m_skip_prologue = eLazyBoolYes; 346 else 347 m_skip_prologue = eLazyBoolNo; 348 349 if (!success) 350 error.SetErrorStringWithFormat( 351 "Invalid boolean value for skip prologue option: '%s'", 352 option_arg.str().c_str()); 353 } break; 354 355 case 'l': 356 if (option_arg.getAsInteger(0, m_line_num)) 357 error.SetErrorStringWithFormat("invalid line number: %s.", 358 option_arg.str().c_str()); 359 break; 360 361 case 'L': 362 m_language = Language::GetLanguageTypeFromString(option_arg); 363 if (m_language == eLanguageTypeUnknown) 364 error.SetErrorStringWithFormat( 365 "Unknown language type: '%s' for breakpoint", 366 option_arg.str().c_str()); 367 break; 368 369 case 'm': { 370 bool success; 371 bool value; 372 value = OptionArgParser::ToBoolean(option_arg, true, &success); 373 if (value) 374 m_move_to_nearest_code = eLazyBoolYes; 375 else 376 m_move_to_nearest_code = eLazyBoolNo; 377 378 if (!success) 379 error.SetErrorStringWithFormat( 380 "Invalid boolean value for move-to-nearest-code option: '%s'", 381 option_arg.str().c_str()); 382 break; 383 } 384 385 case 'M': 386 m_func_names.push_back(option_arg); 387 m_func_name_type_mask |= eFunctionNameTypeMethod; 388 break; 389 390 case 'n': 391 m_func_names.push_back(option_arg); 392 m_func_name_type_mask |= eFunctionNameTypeAuto; 393 break; 394 395 case 'N': { 396 if (BreakpointID::StringIsBreakpointName(option_arg, error)) 397 m_breakpoint_names.push_back(option_arg); 398 else 399 error.SetErrorStringWithFormat("Invalid breakpoint name: %s", 400 option_arg.str().c_str()); 401 break; 402 } 403 404 case 'R': { 405 lldb::addr_t tmp_offset_addr; 406 tmp_offset_addr = OptionArgParser::ToAddress(execution_context, 407 option_arg, 0, &error); 408 if (error.Success()) 409 m_offset_addr = tmp_offset_addr; 410 } break; 411 412 case 'O': 413 m_exception_extra_args.AppendArgument("-O"); 414 m_exception_extra_args.AppendArgument(option_arg); 415 break; 416 417 case 'p': 418 m_source_text_regexp.assign(option_arg); 419 break; 420 421 case 'r': 422 m_func_regexp.assign(option_arg); 423 break; 424 425 case 's': 426 m_modules.AppendIfUnique(FileSpec(option_arg)); 427 break; 428 429 case 'S': 430 m_func_names.push_back(option_arg); 431 m_func_name_type_mask |= eFunctionNameTypeSelector; 432 break; 433 434 case 'w': { 435 bool success; 436 m_throw_bp = OptionArgParser::ToBoolean(option_arg, true, &success); 437 if (!success) 438 error.SetErrorStringWithFormat( 439 "Invalid boolean value for on-throw option: '%s'", 440 option_arg.str().c_str()); 441 } break; 442 443 case 'X': 444 m_source_regex_func_names.insert(option_arg); 445 break; 446 447 default: 448 llvm_unreachable("Unimplemented option"); 449 } 450 451 return error; 452 } 453 454 void OptionParsingStarting(ExecutionContext *execution_context) override { 455 m_filenames.Clear(); 456 m_line_num = 0; 457 m_column = 0; 458 m_func_names.clear(); 459 m_func_name_type_mask = eFunctionNameTypeNone; 460 m_func_regexp.clear(); 461 m_source_text_regexp.clear(); 462 m_modules.Clear(); 463 m_load_addr = LLDB_INVALID_ADDRESS; 464 m_offset_addr = 0; 465 m_catch_bp = false; 466 m_throw_bp = true; 467 m_hardware = false; 468 m_exception_language = eLanguageTypeUnknown; 469 m_language = lldb::eLanguageTypeUnknown; 470 m_skip_prologue = eLazyBoolCalculate; 471 m_breakpoint_names.clear(); 472 m_all_files = false; 473 m_exception_extra_args.Clear(); 474 m_move_to_nearest_code = eLazyBoolCalculate; 475 m_source_regex_func_names.clear(); 476 m_current_key.clear(); 477 } 478 479 llvm::ArrayRef<OptionDefinition> GetDefinitions() override { 480 return llvm::makeArrayRef(g_breakpoint_set_options); 481 } 482 483 // Instance variables to hold the values for command options. 484 485 std::string m_condition; 486 FileSpecList m_filenames; 487 uint32_t m_line_num; 488 uint32_t m_column; 489 std::vector<std::string> m_func_names; 490 std::vector<std::string> m_breakpoint_names; 491 lldb::FunctionNameType m_func_name_type_mask; 492 std::string m_func_regexp; 493 std::string m_source_text_regexp; 494 FileSpecList m_modules; 495 lldb::addr_t m_load_addr; 496 lldb::addr_t m_offset_addr; 497 bool m_catch_bp; 498 bool m_throw_bp; 499 bool m_hardware; // Request to use hardware breakpoints 500 lldb::LanguageType m_exception_language; 501 lldb::LanguageType m_language; 502 LazyBool m_skip_prologue; 503 bool m_all_files; 504 Args m_exception_extra_args; 505 LazyBool m_move_to_nearest_code; 506 std::unordered_set<std::string> m_source_regex_func_names; 507 std::string m_current_key; 508 }; 509 510 protected: 511 bool DoExecute(Args &command, CommandReturnObject &result) override { 512 Target &target = GetSelectedOrDummyTarget(m_dummy_options.m_use_dummy); 513 514 // The following are the various types of breakpoints that could be set: 515 // 1). -f -l -p [-s -g] (setting breakpoint by source location) 516 // 2). -a [-s -g] (setting breakpoint by address) 517 // 3). -n [-s -g] (setting breakpoint by function name) 518 // 4). -r [-s -g] (setting breakpoint by function name regular 519 // expression) 520 // 5). -p -f (setting a breakpoint by comparing a reg-exp 521 // to source text) 522 // 6). -E [-w -h] (setting a breakpoint for exceptions for a 523 // given language.) 524 525 BreakpointSetType break_type = eSetTypeInvalid; 526 527 if (!m_python_class_options.GetName().empty()) 528 break_type = eSetTypeScripted; 529 else if (m_options.m_line_num != 0) 530 break_type = eSetTypeFileAndLine; 531 else if (m_options.m_load_addr != LLDB_INVALID_ADDRESS) 532 break_type = eSetTypeAddress; 533 else if (!m_options.m_func_names.empty()) 534 break_type = eSetTypeFunctionName; 535 else if (!m_options.m_func_regexp.empty()) 536 break_type = eSetTypeFunctionRegexp; 537 else if (!m_options.m_source_text_regexp.empty()) 538 break_type = eSetTypeSourceRegexp; 539 else if (m_options.m_exception_language != eLanguageTypeUnknown) 540 break_type = eSetTypeException; 541 542 BreakpointSP bp_sp = nullptr; 543 FileSpec module_spec; 544 const bool internal = false; 545 546 // If the user didn't specify skip-prologue, having an offset should turn 547 // that off. 548 if (m_options.m_offset_addr != 0 && 549 m_options.m_skip_prologue == eLazyBoolCalculate) 550 m_options.m_skip_prologue = eLazyBoolNo; 551 552 switch (break_type) { 553 case eSetTypeFileAndLine: // Breakpoint by source position 554 { 555 FileSpec file; 556 const size_t num_files = m_options.m_filenames.GetSize(); 557 if (num_files == 0) { 558 if (!GetDefaultFile(target, file, result)) { 559 result.AppendError("No file supplied and no default file available."); 560 result.SetStatus(eReturnStatusFailed); 561 return false; 562 } 563 } else if (num_files > 1) { 564 result.AppendError("Only one file at a time is allowed for file and " 565 "line breakpoints."); 566 result.SetStatus(eReturnStatusFailed); 567 return false; 568 } else 569 file = m_options.m_filenames.GetFileSpecAtIndex(0); 570 571 // Only check for inline functions if 572 LazyBool check_inlines = eLazyBoolCalculate; 573 574 bp_sp = target.CreateBreakpoint( 575 &(m_options.m_modules), file, m_options.m_line_num, 576 m_options.m_column, m_options.m_offset_addr, check_inlines, 577 m_options.m_skip_prologue, internal, m_options.m_hardware, 578 m_options.m_move_to_nearest_code); 579 } break; 580 581 case eSetTypeAddress: // Breakpoint by address 582 { 583 // If a shared library has been specified, make an lldb_private::Address 584 // with the library, and use that. That way the address breakpoint 585 // will track the load location of the library. 586 size_t num_modules_specified = m_options.m_modules.GetSize(); 587 if (num_modules_specified == 1) { 588 const FileSpec *file_spec = 589 m_options.m_modules.GetFileSpecPointerAtIndex(0); 590 bp_sp = target.CreateAddressInModuleBreakpoint( 591 m_options.m_load_addr, internal, file_spec, m_options.m_hardware); 592 } else if (num_modules_specified == 0) { 593 bp_sp = target.CreateBreakpoint(m_options.m_load_addr, internal, 594 m_options.m_hardware); 595 } else { 596 result.AppendError("Only one shared library can be specified for " 597 "address breakpoints."); 598 result.SetStatus(eReturnStatusFailed); 599 return false; 600 } 601 break; 602 } 603 case eSetTypeFunctionName: // Breakpoint by function name 604 { 605 FunctionNameType name_type_mask = m_options.m_func_name_type_mask; 606 607 if (name_type_mask == 0) 608 name_type_mask = eFunctionNameTypeAuto; 609 610 bp_sp = target.CreateBreakpoint( 611 &(m_options.m_modules), &(m_options.m_filenames), 612 m_options.m_func_names, name_type_mask, m_options.m_language, 613 m_options.m_offset_addr, m_options.m_skip_prologue, internal, 614 m_options.m_hardware); 615 } break; 616 617 case eSetTypeFunctionRegexp: // Breakpoint by regular expression function 618 // name 619 { 620 RegularExpression regexp(m_options.m_func_regexp); 621 if (llvm::Error err = regexp.GetError()) { 622 result.AppendErrorWithFormat( 623 "Function name regular expression could not be compiled: \"%s\"", 624 llvm::toString(std::move(err)).c_str()); 625 result.SetStatus(eReturnStatusFailed); 626 return false; 627 } 628 629 bp_sp = target.CreateFuncRegexBreakpoint( 630 &(m_options.m_modules), &(m_options.m_filenames), std::move(regexp), 631 m_options.m_language, m_options.m_skip_prologue, internal, 632 m_options.m_hardware); 633 } break; 634 case eSetTypeSourceRegexp: // Breakpoint by regexp on source text. 635 { 636 const size_t num_files = m_options.m_filenames.GetSize(); 637 638 if (num_files == 0 && !m_options.m_all_files) { 639 FileSpec file; 640 if (!GetDefaultFile(target, file, result)) { 641 result.AppendError( 642 "No files provided and could not find default file."); 643 result.SetStatus(eReturnStatusFailed); 644 return false; 645 } else { 646 m_options.m_filenames.Append(file); 647 } 648 } 649 650 RegularExpression regexp(m_options.m_source_text_regexp); 651 if (llvm::Error err = regexp.GetError()) { 652 result.AppendErrorWithFormat( 653 "Source text regular expression could not be compiled: \"%s\"", 654 llvm::toString(std::move(err)).c_str()); 655 result.SetStatus(eReturnStatusFailed); 656 return false; 657 } 658 bp_sp = target.CreateSourceRegexBreakpoint( 659 &(m_options.m_modules), &(m_options.m_filenames), 660 m_options.m_source_regex_func_names, std::move(regexp), internal, 661 m_options.m_hardware, m_options.m_move_to_nearest_code); 662 } break; 663 case eSetTypeException: { 664 Status precond_error; 665 bp_sp = target.CreateExceptionBreakpoint( 666 m_options.m_exception_language, m_options.m_catch_bp, 667 m_options.m_throw_bp, internal, &m_options.m_exception_extra_args, 668 &precond_error); 669 if (precond_error.Fail()) { 670 result.AppendErrorWithFormat( 671 "Error setting extra exception arguments: %s", 672 precond_error.AsCString()); 673 target.RemoveBreakpointByID(bp_sp->GetID()); 674 result.SetStatus(eReturnStatusFailed); 675 return false; 676 } 677 } break; 678 case eSetTypeScripted: { 679 680 Status error; 681 bp_sp = target.CreateScriptedBreakpoint( 682 m_python_class_options.GetName().c_str(), &(m_options.m_modules), 683 &(m_options.m_filenames), false, m_options.m_hardware, 684 m_python_class_options.GetStructuredData(), &error); 685 if (error.Fail()) { 686 result.AppendErrorWithFormat( 687 "Error setting extra exception arguments: %s", error.AsCString()); 688 target.RemoveBreakpointByID(bp_sp->GetID()); 689 result.SetStatus(eReturnStatusFailed); 690 return false; 691 } 692 } break; 693 default: 694 break; 695 } 696 697 // Now set the various options that were passed in: 698 if (bp_sp) { 699 bp_sp->GetOptions()->CopyOverSetOptions(m_bp_opts.GetBreakpointOptions()); 700 701 if (!m_options.m_breakpoint_names.empty()) { 702 Status name_error; 703 for (auto name : m_options.m_breakpoint_names) { 704 target.AddNameToBreakpoint(bp_sp, name.c_str(), name_error); 705 if (name_error.Fail()) { 706 result.AppendErrorWithFormat("Invalid breakpoint name: %s", 707 name.c_str()); 708 target.RemoveBreakpointByID(bp_sp->GetID()); 709 result.SetStatus(eReturnStatusFailed); 710 return false; 711 } 712 } 713 } 714 } 715 716 if (bp_sp) { 717 Stream &output_stream = result.GetOutputStream(); 718 const bool show_locations = false; 719 bp_sp->GetDescription(&output_stream, lldb::eDescriptionLevelInitial, 720 show_locations); 721 if (&target == &GetDummyTarget()) 722 output_stream.Printf("Breakpoint set in dummy target, will get copied " 723 "into future targets.\n"); 724 else { 725 // Don't print out this warning for exception breakpoints. They can 726 // get set before the target is set, but we won't know how to actually 727 // set the breakpoint till we run. 728 if (bp_sp->GetNumLocations() == 0 && break_type != eSetTypeException) { 729 output_stream.Printf("WARNING: Unable to resolve breakpoint to any " 730 "actual locations.\n"); 731 } 732 } 733 result.SetStatus(eReturnStatusSuccessFinishResult); 734 } else if (!bp_sp) { 735 result.AppendError("Breakpoint creation failed: No breakpoint created."); 736 result.SetStatus(eReturnStatusFailed); 737 } 738 739 return result.Succeeded(); 740 } 741 742 private: 743 bool GetDefaultFile(Target &target, FileSpec &file, 744 CommandReturnObject &result) { 745 uint32_t default_line; 746 // First use the Source Manager's default file. Then use the current stack 747 // frame's file. 748 if (!target.GetSourceManager().GetDefaultFileAndLine(file, default_line)) { 749 StackFrame *cur_frame = m_exe_ctx.GetFramePtr(); 750 if (cur_frame == nullptr) { 751 result.AppendError( 752 "No selected frame to use to find the default file."); 753 result.SetStatus(eReturnStatusFailed); 754 return false; 755 } else if (!cur_frame->HasDebugInformation()) { 756 result.AppendError("Cannot use the selected frame to find the default " 757 "file, it has no debug info."); 758 result.SetStatus(eReturnStatusFailed); 759 return false; 760 } else { 761 const SymbolContext &sc = 762 cur_frame->GetSymbolContext(eSymbolContextLineEntry); 763 if (sc.line_entry.file) { 764 file = sc.line_entry.file; 765 } else { 766 result.AppendError("Can't find the file for the selected frame to " 767 "use as the default file."); 768 result.SetStatus(eReturnStatusFailed); 769 return false; 770 } 771 } 772 } 773 return true; 774 } 775 776 BreakpointOptionGroup m_bp_opts; 777 BreakpointDummyOptionGroup m_dummy_options; 778 OptionGroupPythonClassWithDict m_python_class_options; 779 CommandOptions m_options; 780 OptionGroupOptions m_all_options; 781 }; 782 783 // CommandObjectBreakpointModify 784 #pragma mark Modify 785 786 class CommandObjectBreakpointModify : public CommandObjectParsed { 787 public: 788 CommandObjectBreakpointModify(CommandInterpreter &interpreter) 789 : CommandObjectParsed(interpreter, "breakpoint modify", 790 "Modify the options on a breakpoint or set of " 791 "breakpoints in the executable. " 792 "If no breakpoint is specified, acts on the last " 793 "created breakpoint. " 794 "With the exception of -e, -d and -i, passing an " 795 "empty argument clears the modification.", 796 nullptr), 797 m_options() { 798 CommandArgumentEntry arg; 799 CommandObject::AddIDsArgumentData(arg, eArgTypeBreakpointID, 800 eArgTypeBreakpointIDRange); 801 // Add the entry for the first argument for this command to the object's 802 // arguments vector. 803 m_arguments.push_back(arg); 804 805 m_options.Append(&m_bp_opts, 806 LLDB_OPT_SET_1 | LLDB_OPT_SET_2 | LLDB_OPT_SET_3, 807 LLDB_OPT_SET_ALL); 808 m_options.Append(&m_dummy_opts, LLDB_OPT_SET_1, LLDB_OPT_SET_ALL); 809 m_options.Finalize(); 810 } 811 812 ~CommandObjectBreakpointModify() override = default; 813 814 Options *GetOptions() override { return &m_options; } 815 816 protected: 817 bool DoExecute(Args &command, CommandReturnObject &result) override { 818 Target &target = GetSelectedOrDummyTarget(m_dummy_opts.m_use_dummy); 819 820 std::unique_lock<std::recursive_mutex> lock; 821 target.GetBreakpointList().GetListMutex(lock); 822 823 BreakpointIDList valid_bp_ids; 824 825 CommandObjectMultiwordBreakpoint::VerifyBreakpointOrLocationIDs( 826 command, &target, result, &valid_bp_ids, 827 BreakpointName::Permissions::PermissionKinds::disablePerm); 828 829 if (result.Succeeded()) { 830 const size_t count = valid_bp_ids.GetSize(); 831 for (size_t i = 0; i < count; ++i) { 832 BreakpointID cur_bp_id = valid_bp_ids.GetBreakpointIDAtIndex(i); 833 834 if (cur_bp_id.GetBreakpointID() != LLDB_INVALID_BREAK_ID) { 835 Breakpoint *bp = 836 target.GetBreakpointByID(cur_bp_id.GetBreakpointID()).get(); 837 if (cur_bp_id.GetLocationID() != LLDB_INVALID_BREAK_ID) { 838 BreakpointLocation *location = 839 bp->FindLocationByID(cur_bp_id.GetLocationID()).get(); 840 if (location) 841 location->GetLocationOptions()->CopyOverSetOptions( 842 m_bp_opts.GetBreakpointOptions()); 843 } else { 844 bp->GetOptions()->CopyOverSetOptions( 845 m_bp_opts.GetBreakpointOptions()); 846 } 847 } 848 } 849 } 850 851 return result.Succeeded(); 852 } 853 854 private: 855 BreakpointOptionGroup m_bp_opts; 856 BreakpointDummyOptionGroup m_dummy_opts; 857 OptionGroupOptions m_options; 858 }; 859 860 // CommandObjectBreakpointEnable 861 #pragma mark Enable 862 863 class CommandObjectBreakpointEnable : public CommandObjectParsed { 864 public: 865 CommandObjectBreakpointEnable(CommandInterpreter &interpreter) 866 : CommandObjectParsed(interpreter, "enable", 867 "Enable the specified disabled breakpoint(s). If " 868 "no breakpoints are specified, enable all of them.", 869 nullptr) { 870 CommandArgumentEntry arg; 871 CommandObject::AddIDsArgumentData(arg, eArgTypeBreakpointID, 872 eArgTypeBreakpointIDRange); 873 // Add the entry for the first argument for this command to the object's 874 // arguments vector. 875 m_arguments.push_back(arg); 876 } 877 878 ~CommandObjectBreakpointEnable() override = default; 879 880 protected: 881 bool DoExecute(Args &command, CommandReturnObject &result) override { 882 Target &target = GetSelectedOrDummyTarget(); 883 884 std::unique_lock<std::recursive_mutex> lock; 885 target.GetBreakpointList().GetListMutex(lock); 886 887 const BreakpointList &breakpoints = target.GetBreakpointList(); 888 889 size_t num_breakpoints = breakpoints.GetSize(); 890 891 if (num_breakpoints == 0) { 892 result.AppendError("No breakpoints exist to be enabled."); 893 result.SetStatus(eReturnStatusFailed); 894 return false; 895 } 896 897 if (command.empty()) { 898 // No breakpoint selected; enable all currently set breakpoints. 899 target.EnableAllowedBreakpoints(); 900 result.AppendMessageWithFormat("All breakpoints enabled. (%" PRIu64 901 " breakpoints)\n", 902 (uint64_t)num_breakpoints); 903 result.SetStatus(eReturnStatusSuccessFinishNoResult); 904 } else { 905 // Particular breakpoint selected; enable that breakpoint. 906 BreakpointIDList valid_bp_ids; 907 CommandObjectMultiwordBreakpoint::VerifyBreakpointOrLocationIDs( 908 command, &target, result, &valid_bp_ids, 909 BreakpointName::Permissions::PermissionKinds::disablePerm); 910 911 if (result.Succeeded()) { 912 int enable_count = 0; 913 int loc_count = 0; 914 const size_t count = valid_bp_ids.GetSize(); 915 for (size_t i = 0; i < count; ++i) { 916 BreakpointID cur_bp_id = valid_bp_ids.GetBreakpointIDAtIndex(i); 917 918 if (cur_bp_id.GetBreakpointID() != LLDB_INVALID_BREAK_ID) { 919 Breakpoint *breakpoint = 920 target.GetBreakpointByID(cur_bp_id.GetBreakpointID()).get(); 921 if (cur_bp_id.GetLocationID() != LLDB_INVALID_BREAK_ID) { 922 BreakpointLocation *location = 923 breakpoint->FindLocationByID(cur_bp_id.GetLocationID()).get(); 924 if (location) { 925 location->SetEnabled(true); 926 ++loc_count; 927 } 928 } else { 929 breakpoint->SetEnabled(true); 930 ++enable_count; 931 } 932 } 933 } 934 result.AppendMessageWithFormat("%d breakpoints enabled.\n", 935 enable_count + loc_count); 936 result.SetStatus(eReturnStatusSuccessFinishNoResult); 937 } 938 } 939 940 return result.Succeeded(); 941 } 942 }; 943 944 // CommandObjectBreakpointDisable 945 #pragma mark Disable 946 947 class CommandObjectBreakpointDisable : public CommandObjectParsed { 948 public: 949 CommandObjectBreakpointDisable(CommandInterpreter &interpreter) 950 : CommandObjectParsed( 951 interpreter, "breakpoint disable", 952 "Disable the specified breakpoint(s) without deleting " 953 "them. If none are specified, disable all " 954 "breakpoints.", 955 nullptr) { 956 SetHelpLong( 957 "Disable the specified breakpoint(s) without deleting them. \ 958 If none are specified, disable all breakpoints." 959 R"( 960 961 )" 962 "Note: disabling a breakpoint will cause none of its locations to be hit \ 963 regardless of whether individual locations are enabled or disabled. After the sequence:" 964 R"( 965 966 (lldb) break disable 1 967 (lldb) break enable 1.1 968 969 execution will NOT stop at location 1.1. To achieve that, type: 970 971 (lldb) break disable 1.* 972 (lldb) break enable 1.1 973 974 )" 975 "The first command disables all locations for breakpoint 1, \ 976 the second re-enables the first location."); 977 978 CommandArgumentEntry arg; 979 CommandObject::AddIDsArgumentData(arg, eArgTypeBreakpointID, 980 eArgTypeBreakpointIDRange); 981 // Add the entry for the first argument for this command to the object's 982 // arguments vector. 983 m_arguments.push_back(arg); 984 } 985 986 ~CommandObjectBreakpointDisable() override = default; 987 988 protected: 989 bool DoExecute(Args &command, CommandReturnObject &result) override { 990 Target &target = GetSelectedOrDummyTarget(); 991 std::unique_lock<std::recursive_mutex> lock; 992 target.GetBreakpointList().GetListMutex(lock); 993 994 const BreakpointList &breakpoints = target.GetBreakpointList(); 995 size_t num_breakpoints = breakpoints.GetSize(); 996 997 if (num_breakpoints == 0) { 998 result.AppendError("No breakpoints exist to be disabled."); 999 result.SetStatus(eReturnStatusFailed); 1000 return false; 1001 } 1002 1003 if (command.empty()) { 1004 // No breakpoint selected; disable all currently set breakpoints. 1005 target.DisableAllowedBreakpoints(); 1006 result.AppendMessageWithFormat("All breakpoints disabled. (%" PRIu64 1007 " breakpoints)\n", 1008 (uint64_t)num_breakpoints); 1009 result.SetStatus(eReturnStatusSuccessFinishNoResult); 1010 } else { 1011 // Particular breakpoint selected; disable that breakpoint. 1012 BreakpointIDList valid_bp_ids; 1013 1014 CommandObjectMultiwordBreakpoint::VerifyBreakpointOrLocationIDs( 1015 command, &target, result, &valid_bp_ids, 1016 BreakpointName::Permissions::PermissionKinds::disablePerm); 1017 1018 if (result.Succeeded()) { 1019 int disable_count = 0; 1020 int loc_count = 0; 1021 const size_t count = valid_bp_ids.GetSize(); 1022 for (size_t i = 0; i < count; ++i) { 1023 BreakpointID cur_bp_id = valid_bp_ids.GetBreakpointIDAtIndex(i); 1024 1025 if (cur_bp_id.GetBreakpointID() != LLDB_INVALID_BREAK_ID) { 1026 Breakpoint *breakpoint = 1027 target.GetBreakpointByID(cur_bp_id.GetBreakpointID()).get(); 1028 if (cur_bp_id.GetLocationID() != LLDB_INVALID_BREAK_ID) { 1029 BreakpointLocation *location = 1030 breakpoint->FindLocationByID(cur_bp_id.GetLocationID()).get(); 1031 if (location) { 1032 location->SetEnabled(false); 1033 ++loc_count; 1034 } 1035 } else { 1036 breakpoint->SetEnabled(false); 1037 ++disable_count; 1038 } 1039 } 1040 } 1041 result.AppendMessageWithFormat("%d breakpoints disabled.\n", 1042 disable_count + loc_count); 1043 result.SetStatus(eReturnStatusSuccessFinishNoResult); 1044 } 1045 } 1046 1047 return result.Succeeded(); 1048 } 1049 }; 1050 1051 // CommandObjectBreakpointList 1052 1053 #pragma mark List::CommandOptions 1054 #define LLDB_OPTIONS_breakpoint_list 1055 #include "CommandOptions.inc" 1056 1057 #pragma mark List 1058 1059 class CommandObjectBreakpointList : public CommandObjectParsed { 1060 public: 1061 CommandObjectBreakpointList(CommandInterpreter &interpreter) 1062 : CommandObjectParsed( 1063 interpreter, "breakpoint list", 1064 "List some or all breakpoints at configurable levels of detail.", 1065 nullptr), 1066 m_options() { 1067 CommandArgumentEntry arg; 1068 CommandArgumentData bp_id_arg; 1069 1070 // Define the first (and only) variant of this arg. 1071 bp_id_arg.arg_type = eArgTypeBreakpointID; 1072 bp_id_arg.arg_repetition = eArgRepeatOptional; 1073 1074 // There is only one variant this argument could be; put it into the 1075 // argument entry. 1076 arg.push_back(bp_id_arg); 1077 1078 // Push the data for the first argument into the m_arguments vector. 1079 m_arguments.push_back(arg); 1080 } 1081 1082 ~CommandObjectBreakpointList() override = default; 1083 1084 Options *GetOptions() override { return &m_options; } 1085 1086 class CommandOptions : public Options { 1087 public: 1088 CommandOptions() 1089 : Options(), m_level(lldb::eDescriptionLevelBrief), m_use_dummy(false) { 1090 } 1091 1092 ~CommandOptions() override = default; 1093 1094 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, 1095 ExecutionContext *execution_context) override { 1096 Status error; 1097 const int short_option = m_getopt_table[option_idx].val; 1098 1099 switch (short_option) { 1100 case 'b': 1101 m_level = lldb::eDescriptionLevelBrief; 1102 break; 1103 case 'D': 1104 m_use_dummy = true; 1105 break; 1106 case 'f': 1107 m_level = lldb::eDescriptionLevelFull; 1108 break; 1109 case 'v': 1110 m_level = lldb::eDescriptionLevelVerbose; 1111 break; 1112 case 'i': 1113 m_internal = true; 1114 break; 1115 default: 1116 llvm_unreachable("Unimplemented option"); 1117 } 1118 1119 return error; 1120 } 1121 1122 void OptionParsingStarting(ExecutionContext *execution_context) override { 1123 m_level = lldb::eDescriptionLevelFull; 1124 m_internal = false; 1125 m_use_dummy = false; 1126 } 1127 1128 llvm::ArrayRef<OptionDefinition> GetDefinitions() override { 1129 return llvm::makeArrayRef(g_breakpoint_list_options); 1130 } 1131 1132 // Instance variables to hold the values for command options. 1133 1134 lldb::DescriptionLevel m_level; 1135 1136 bool m_internal; 1137 bool m_use_dummy; 1138 }; 1139 1140 protected: 1141 bool DoExecute(Args &command, CommandReturnObject &result) override { 1142 Target &target = GetSelectedOrDummyTarget(m_options.m_use_dummy); 1143 1144 const BreakpointList &breakpoints = 1145 target.GetBreakpointList(m_options.m_internal); 1146 std::unique_lock<std::recursive_mutex> lock; 1147 target.GetBreakpointList(m_options.m_internal).GetListMutex(lock); 1148 1149 size_t num_breakpoints = breakpoints.GetSize(); 1150 1151 if (num_breakpoints == 0) { 1152 result.AppendMessage("No breakpoints currently set."); 1153 result.SetStatus(eReturnStatusSuccessFinishNoResult); 1154 return true; 1155 } 1156 1157 Stream &output_stream = result.GetOutputStream(); 1158 1159 if (command.empty()) { 1160 // No breakpoint selected; show info about all currently set breakpoints. 1161 result.AppendMessage("Current breakpoints:"); 1162 for (size_t i = 0; i < num_breakpoints; ++i) { 1163 Breakpoint *breakpoint = breakpoints.GetBreakpointAtIndex(i).get(); 1164 if (breakpoint->AllowList()) 1165 AddBreakpointDescription(&output_stream, breakpoint, 1166 m_options.m_level); 1167 } 1168 result.SetStatus(eReturnStatusSuccessFinishNoResult); 1169 } else { 1170 // Particular breakpoints selected; show info about that breakpoint. 1171 BreakpointIDList valid_bp_ids; 1172 CommandObjectMultiwordBreakpoint::VerifyBreakpointOrLocationIDs( 1173 command, &target, result, &valid_bp_ids, 1174 BreakpointName::Permissions::PermissionKinds::listPerm); 1175 1176 if (result.Succeeded()) { 1177 for (size_t i = 0; i < valid_bp_ids.GetSize(); ++i) { 1178 BreakpointID cur_bp_id = valid_bp_ids.GetBreakpointIDAtIndex(i); 1179 Breakpoint *breakpoint = 1180 target.GetBreakpointByID(cur_bp_id.GetBreakpointID()).get(); 1181 AddBreakpointDescription(&output_stream, breakpoint, 1182 m_options.m_level); 1183 } 1184 result.SetStatus(eReturnStatusSuccessFinishNoResult); 1185 } else { 1186 result.AppendError("Invalid breakpoint ID."); 1187 result.SetStatus(eReturnStatusFailed); 1188 } 1189 } 1190 1191 return result.Succeeded(); 1192 } 1193 1194 private: 1195 CommandOptions m_options; 1196 }; 1197 1198 // CommandObjectBreakpointClear 1199 #pragma mark Clear::CommandOptions 1200 1201 #define LLDB_OPTIONS_breakpoint_clear 1202 #include "CommandOptions.inc" 1203 1204 #pragma mark Clear 1205 1206 class CommandObjectBreakpointClear : public CommandObjectParsed { 1207 public: 1208 enum BreakpointClearType { eClearTypeInvalid, eClearTypeFileAndLine }; 1209 1210 CommandObjectBreakpointClear(CommandInterpreter &interpreter) 1211 : CommandObjectParsed(interpreter, "breakpoint clear", 1212 "Delete or disable breakpoints matching the " 1213 "specified source file and line.", 1214 "breakpoint clear <cmd-options>"), 1215 m_options() {} 1216 1217 ~CommandObjectBreakpointClear() override = default; 1218 1219 Options *GetOptions() override { return &m_options; } 1220 1221 class CommandOptions : public Options { 1222 public: 1223 CommandOptions() : Options(), m_filename(), m_line_num(0) {} 1224 1225 ~CommandOptions() override = default; 1226 1227 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, 1228 ExecutionContext *execution_context) override { 1229 Status error; 1230 const int short_option = m_getopt_table[option_idx].val; 1231 1232 switch (short_option) { 1233 case 'f': 1234 m_filename.assign(option_arg); 1235 break; 1236 1237 case 'l': 1238 option_arg.getAsInteger(0, m_line_num); 1239 break; 1240 1241 default: 1242 llvm_unreachable("Unimplemented option"); 1243 } 1244 1245 return error; 1246 } 1247 1248 void OptionParsingStarting(ExecutionContext *execution_context) override { 1249 m_filename.clear(); 1250 m_line_num = 0; 1251 } 1252 1253 llvm::ArrayRef<OptionDefinition> GetDefinitions() override { 1254 return llvm::makeArrayRef(g_breakpoint_clear_options); 1255 } 1256 1257 // Instance variables to hold the values for command options. 1258 1259 std::string m_filename; 1260 uint32_t m_line_num; 1261 }; 1262 1263 protected: 1264 bool DoExecute(Args &command, CommandReturnObject &result) override { 1265 Target &target = GetSelectedOrDummyTarget(); 1266 1267 // The following are the various types of breakpoints that could be 1268 // cleared: 1269 // 1). -f -l (clearing breakpoint by source location) 1270 1271 BreakpointClearType break_type = eClearTypeInvalid; 1272 1273 if (m_options.m_line_num != 0) 1274 break_type = eClearTypeFileAndLine; 1275 1276 std::unique_lock<std::recursive_mutex> lock; 1277 target.GetBreakpointList().GetListMutex(lock); 1278 1279 BreakpointList &breakpoints = target.GetBreakpointList(); 1280 size_t num_breakpoints = breakpoints.GetSize(); 1281 1282 // Early return if there's no breakpoint at all. 1283 if (num_breakpoints == 0) { 1284 result.AppendError("Breakpoint clear: No breakpoint cleared."); 1285 result.SetStatus(eReturnStatusFailed); 1286 return result.Succeeded(); 1287 } 1288 1289 // Find matching breakpoints and delete them. 1290 1291 // First create a copy of all the IDs. 1292 std::vector<break_id_t> BreakIDs; 1293 for (size_t i = 0; i < num_breakpoints; ++i) 1294 BreakIDs.push_back(breakpoints.GetBreakpointAtIndex(i)->GetID()); 1295 1296 int num_cleared = 0; 1297 StreamString ss; 1298 switch (break_type) { 1299 case eClearTypeFileAndLine: // Breakpoint by source position 1300 { 1301 const ConstString filename(m_options.m_filename.c_str()); 1302 BreakpointLocationCollection loc_coll; 1303 1304 for (size_t i = 0; i < num_breakpoints; ++i) { 1305 Breakpoint *bp = breakpoints.FindBreakpointByID(BreakIDs[i]).get(); 1306 1307 if (bp->GetMatchingFileLine(filename, m_options.m_line_num, loc_coll)) { 1308 // If the collection size is 0, it's a full match and we can just 1309 // remove the breakpoint. 1310 if (loc_coll.GetSize() == 0) { 1311 bp->GetDescription(&ss, lldb::eDescriptionLevelBrief); 1312 ss.EOL(); 1313 target.RemoveBreakpointByID(bp->GetID()); 1314 ++num_cleared; 1315 } 1316 } 1317 } 1318 } break; 1319 1320 default: 1321 break; 1322 } 1323 1324 if (num_cleared > 0) { 1325 Stream &output_stream = result.GetOutputStream(); 1326 output_stream.Printf("%d breakpoints cleared:\n", num_cleared); 1327 output_stream << ss.GetString(); 1328 output_stream.EOL(); 1329 result.SetStatus(eReturnStatusSuccessFinishNoResult); 1330 } else { 1331 result.AppendError("Breakpoint clear: No breakpoint cleared."); 1332 result.SetStatus(eReturnStatusFailed); 1333 } 1334 1335 return result.Succeeded(); 1336 } 1337 1338 private: 1339 CommandOptions m_options; 1340 }; 1341 1342 // CommandObjectBreakpointDelete 1343 #define LLDB_OPTIONS_breakpoint_delete 1344 #include "CommandOptions.inc" 1345 1346 #pragma mark Delete 1347 1348 class CommandObjectBreakpointDelete : public CommandObjectParsed { 1349 public: 1350 CommandObjectBreakpointDelete(CommandInterpreter &interpreter) 1351 : CommandObjectParsed(interpreter, "breakpoint delete", 1352 "Delete the specified breakpoint(s). If no " 1353 "breakpoints are specified, delete them all.", 1354 nullptr), 1355 m_options() { 1356 CommandArgumentEntry arg; 1357 CommandObject::AddIDsArgumentData(arg, eArgTypeBreakpointID, 1358 eArgTypeBreakpointIDRange); 1359 // Add the entry for the first argument for this command to the object's 1360 // arguments vector. 1361 m_arguments.push_back(arg); 1362 } 1363 1364 ~CommandObjectBreakpointDelete() override = default; 1365 1366 Options *GetOptions() override { return &m_options; } 1367 1368 class CommandOptions : public Options { 1369 public: 1370 CommandOptions() : Options(), m_use_dummy(false), m_force(false) {} 1371 1372 ~CommandOptions() override = default; 1373 1374 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, 1375 ExecutionContext *execution_context) override { 1376 Status error; 1377 const int short_option = m_getopt_table[option_idx].val; 1378 1379 switch (short_option) { 1380 case 'f': 1381 m_force = true; 1382 break; 1383 1384 case 'D': 1385 m_use_dummy = true; 1386 break; 1387 1388 default: 1389 llvm_unreachable("Unimplemented option"); 1390 } 1391 1392 return error; 1393 } 1394 1395 void OptionParsingStarting(ExecutionContext *execution_context) override { 1396 m_use_dummy = false; 1397 m_force = false; 1398 } 1399 1400 llvm::ArrayRef<OptionDefinition> GetDefinitions() override { 1401 return llvm::makeArrayRef(g_breakpoint_delete_options); 1402 } 1403 1404 // Instance variables to hold the values for command options. 1405 bool m_use_dummy; 1406 bool m_force; 1407 }; 1408 1409 protected: 1410 bool DoExecute(Args &command, CommandReturnObject &result) override { 1411 Target &target = GetSelectedOrDummyTarget(m_options.m_use_dummy); 1412 1413 std::unique_lock<std::recursive_mutex> lock; 1414 target.GetBreakpointList().GetListMutex(lock); 1415 1416 const BreakpointList &breakpoints = target.GetBreakpointList(); 1417 1418 size_t num_breakpoints = breakpoints.GetSize(); 1419 1420 if (num_breakpoints == 0) { 1421 result.AppendError("No breakpoints exist to be deleted."); 1422 result.SetStatus(eReturnStatusFailed); 1423 return false; 1424 } 1425 1426 if (command.empty()) { 1427 if (!m_options.m_force && 1428 !m_interpreter.Confirm( 1429 "About to delete all breakpoints, do you want to do that?", 1430 true)) { 1431 result.AppendMessage("Operation cancelled..."); 1432 } else { 1433 target.RemoveAllowedBreakpoints(); 1434 result.AppendMessageWithFormat( 1435 "All breakpoints removed. (%" PRIu64 " breakpoint%s)\n", 1436 (uint64_t)num_breakpoints, num_breakpoints > 1 ? "s" : ""); 1437 } 1438 result.SetStatus(eReturnStatusSuccessFinishNoResult); 1439 } else { 1440 // Particular breakpoint selected; disable that breakpoint. 1441 BreakpointIDList valid_bp_ids; 1442 CommandObjectMultiwordBreakpoint::VerifyBreakpointOrLocationIDs( 1443 command, &target, result, &valid_bp_ids, 1444 BreakpointName::Permissions::PermissionKinds::deletePerm); 1445 1446 if (result.Succeeded()) { 1447 int delete_count = 0; 1448 int disable_count = 0; 1449 const size_t count = valid_bp_ids.GetSize(); 1450 for (size_t i = 0; i < count; ++i) { 1451 BreakpointID cur_bp_id = valid_bp_ids.GetBreakpointIDAtIndex(i); 1452 1453 if (cur_bp_id.GetBreakpointID() != LLDB_INVALID_BREAK_ID) { 1454 if (cur_bp_id.GetLocationID() != LLDB_INVALID_BREAK_ID) { 1455 Breakpoint *breakpoint = 1456 target.GetBreakpointByID(cur_bp_id.GetBreakpointID()).get(); 1457 BreakpointLocation *location = 1458 breakpoint->FindLocationByID(cur_bp_id.GetLocationID()).get(); 1459 // It makes no sense to try to delete individual locations, so we 1460 // disable them instead. 1461 if (location) { 1462 location->SetEnabled(false); 1463 ++disable_count; 1464 } 1465 } else { 1466 target.RemoveBreakpointByID(cur_bp_id.GetBreakpointID()); 1467 ++delete_count; 1468 } 1469 } 1470 } 1471 result.AppendMessageWithFormat( 1472 "%d breakpoints deleted; %d breakpoint locations disabled.\n", 1473 delete_count, disable_count); 1474 result.SetStatus(eReturnStatusSuccessFinishNoResult); 1475 } 1476 } 1477 return result.Succeeded(); 1478 } 1479 1480 private: 1481 CommandOptions m_options; 1482 }; 1483 1484 // CommandObjectBreakpointName 1485 #define LLDB_OPTIONS_breakpoint_name 1486 #include "CommandOptions.inc" 1487 1488 class BreakpointNameOptionGroup : public OptionGroup { 1489 public: 1490 BreakpointNameOptionGroup() 1491 : OptionGroup(), m_breakpoint(LLDB_INVALID_BREAK_ID), m_use_dummy(false) { 1492 } 1493 1494 ~BreakpointNameOptionGroup() override = default; 1495 1496 llvm::ArrayRef<OptionDefinition> GetDefinitions() override { 1497 return llvm::makeArrayRef(g_breakpoint_name_options); 1498 } 1499 1500 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, 1501 ExecutionContext *execution_context) override { 1502 Status error; 1503 const int short_option = g_breakpoint_name_options[option_idx].short_option; 1504 1505 switch (short_option) { 1506 case 'N': 1507 if (BreakpointID::StringIsBreakpointName(option_arg, error) && 1508 error.Success()) 1509 m_name.SetValueFromString(option_arg); 1510 break; 1511 case 'B': 1512 if (m_breakpoint.SetValueFromString(option_arg).Fail()) 1513 error.SetErrorStringWithFormat( 1514 "unrecognized value \"%s\" for breakpoint", 1515 option_arg.str().c_str()); 1516 break; 1517 case 'D': 1518 if (m_use_dummy.SetValueFromString(option_arg).Fail()) 1519 error.SetErrorStringWithFormat( 1520 "unrecognized value \"%s\" for use-dummy", 1521 option_arg.str().c_str()); 1522 break; 1523 case 'H': 1524 m_help_string.SetValueFromString(option_arg); 1525 break; 1526 1527 default: 1528 llvm_unreachable("Unimplemented option"); 1529 } 1530 return error; 1531 } 1532 1533 void OptionParsingStarting(ExecutionContext *execution_context) override { 1534 m_name.Clear(); 1535 m_breakpoint.Clear(); 1536 m_use_dummy.Clear(); 1537 m_use_dummy.SetDefaultValue(false); 1538 m_help_string.Clear(); 1539 } 1540 1541 OptionValueString m_name; 1542 OptionValueUInt64 m_breakpoint; 1543 OptionValueBoolean m_use_dummy; 1544 OptionValueString m_help_string; 1545 }; 1546 1547 #define LLDB_OPTIONS_breakpoint_access 1548 #include "CommandOptions.inc" 1549 1550 class BreakpointAccessOptionGroup : public OptionGroup { 1551 public: 1552 BreakpointAccessOptionGroup() : OptionGroup() {} 1553 1554 ~BreakpointAccessOptionGroup() override = default; 1555 1556 llvm::ArrayRef<OptionDefinition> GetDefinitions() override { 1557 return llvm::makeArrayRef(g_breakpoint_access_options); 1558 } 1559 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, 1560 ExecutionContext *execution_context) override { 1561 Status error; 1562 const int short_option = 1563 g_breakpoint_access_options[option_idx].short_option; 1564 1565 switch (short_option) { 1566 case 'L': { 1567 bool value, success; 1568 value = OptionArgParser::ToBoolean(option_arg, false, &success); 1569 if (success) { 1570 m_permissions.SetAllowList(value); 1571 } else 1572 error.SetErrorStringWithFormat( 1573 "invalid boolean value '%s' passed for -L option", 1574 option_arg.str().c_str()); 1575 } break; 1576 case 'A': { 1577 bool value, success; 1578 value = OptionArgParser::ToBoolean(option_arg, false, &success); 1579 if (success) { 1580 m_permissions.SetAllowDisable(value); 1581 } else 1582 error.SetErrorStringWithFormat( 1583 "invalid boolean value '%s' passed for -L option", 1584 option_arg.str().c_str()); 1585 } break; 1586 case 'D': { 1587 bool value, success; 1588 value = OptionArgParser::ToBoolean(option_arg, false, &success); 1589 if (success) { 1590 m_permissions.SetAllowDelete(value); 1591 } else 1592 error.SetErrorStringWithFormat( 1593 "invalid boolean value '%s' passed for -L option", 1594 option_arg.str().c_str()); 1595 } break; 1596 default: 1597 llvm_unreachable("Unimplemented option"); 1598 } 1599 1600 return error; 1601 } 1602 1603 void OptionParsingStarting(ExecutionContext *execution_context) override {} 1604 1605 const BreakpointName::Permissions &GetPermissions() const { 1606 return m_permissions; 1607 } 1608 BreakpointName::Permissions m_permissions; 1609 }; 1610 1611 class CommandObjectBreakpointNameConfigure : public CommandObjectParsed { 1612 public: 1613 CommandObjectBreakpointNameConfigure(CommandInterpreter &interpreter) 1614 : CommandObjectParsed( 1615 interpreter, "configure", 1616 "Configure the options for the breakpoint" 1617 " name provided. " 1618 "If you provide a breakpoint id, the options will be copied from " 1619 "the breakpoint, otherwise only the options specified will be set " 1620 "on the name.", 1621 "breakpoint name configure <command-options> " 1622 "<breakpoint-name-list>"), 1623 m_bp_opts(), m_option_group() { 1624 // Create the first variant for the first (and only) argument for this 1625 // command. 1626 CommandArgumentEntry arg1; 1627 CommandArgumentData id_arg; 1628 id_arg.arg_type = eArgTypeBreakpointName; 1629 id_arg.arg_repetition = eArgRepeatOptional; 1630 arg1.push_back(id_arg); 1631 m_arguments.push_back(arg1); 1632 1633 m_option_group.Append(&m_bp_opts, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1); 1634 m_option_group.Append(&m_access_options, LLDB_OPT_SET_ALL, 1635 LLDB_OPT_SET_ALL); 1636 m_option_group.Append(&m_bp_id, LLDB_OPT_SET_2 | LLDB_OPT_SET_4, 1637 LLDB_OPT_SET_ALL); 1638 m_option_group.Finalize(); 1639 } 1640 1641 ~CommandObjectBreakpointNameConfigure() override = default; 1642 1643 Options *GetOptions() override { return &m_option_group; } 1644 1645 protected: 1646 bool DoExecute(Args &command, CommandReturnObject &result) override { 1647 1648 const size_t argc = command.GetArgumentCount(); 1649 if (argc == 0) { 1650 result.AppendError("No names provided."); 1651 result.SetStatus(eReturnStatusFailed); 1652 return false; 1653 } 1654 1655 Target &target = GetSelectedOrDummyTarget(false); 1656 1657 std::unique_lock<std::recursive_mutex> lock; 1658 target.GetBreakpointList().GetListMutex(lock); 1659 1660 // Make a pass through first to see that all the names are legal. 1661 for (auto &entry : command.entries()) { 1662 Status error; 1663 if (!BreakpointID::StringIsBreakpointName(entry.ref(), error)) { 1664 result.AppendErrorWithFormat("Invalid breakpoint name: %s - %s", 1665 entry.c_str(), error.AsCString()); 1666 result.SetStatus(eReturnStatusFailed); 1667 return false; 1668 } 1669 } 1670 // Now configure them, we already pre-checked the names so we don't need to 1671 // check the error: 1672 BreakpointSP bp_sp; 1673 if (m_bp_id.m_breakpoint.OptionWasSet()) { 1674 lldb::break_id_t bp_id = m_bp_id.m_breakpoint.GetUInt64Value(); 1675 bp_sp = target.GetBreakpointByID(bp_id); 1676 if (!bp_sp) { 1677 result.AppendErrorWithFormatv("Could not find specified breakpoint {0}", 1678 bp_id); 1679 result.SetStatus(eReturnStatusFailed); 1680 return false; 1681 } 1682 } 1683 1684 Status error; 1685 for (auto &entry : command.entries()) { 1686 ConstString name(entry.c_str()); 1687 BreakpointName *bp_name = target.FindBreakpointName(name, true, error); 1688 if (!bp_name) 1689 continue; 1690 if (m_bp_id.m_help_string.OptionWasSet()) 1691 bp_name->SetHelp(m_bp_id.m_help_string.GetStringValue().str().c_str()); 1692 1693 if (bp_sp) 1694 target.ConfigureBreakpointName(*bp_name, *bp_sp->GetOptions(), 1695 m_access_options.GetPermissions()); 1696 else 1697 target.ConfigureBreakpointName(*bp_name, 1698 m_bp_opts.GetBreakpointOptions(), 1699 m_access_options.GetPermissions()); 1700 } 1701 return true; 1702 } 1703 1704 private: 1705 BreakpointNameOptionGroup m_bp_id; // Only using the id part of this. 1706 BreakpointOptionGroup m_bp_opts; 1707 BreakpointAccessOptionGroup m_access_options; 1708 OptionGroupOptions m_option_group; 1709 }; 1710 1711 class CommandObjectBreakpointNameAdd : public CommandObjectParsed { 1712 public: 1713 CommandObjectBreakpointNameAdd(CommandInterpreter &interpreter) 1714 : CommandObjectParsed( 1715 interpreter, "add", "Add a name to the breakpoints provided.", 1716 "breakpoint name add <command-options> <breakpoint-id-list>"), 1717 m_name_options(), m_option_group() { 1718 // Create the first variant for the first (and only) argument for this 1719 // command. 1720 CommandArgumentEntry arg1; 1721 CommandArgumentData id_arg; 1722 id_arg.arg_type = eArgTypeBreakpointID; 1723 id_arg.arg_repetition = eArgRepeatOptional; 1724 arg1.push_back(id_arg); 1725 m_arguments.push_back(arg1); 1726 1727 m_option_group.Append(&m_name_options, LLDB_OPT_SET_1, LLDB_OPT_SET_ALL); 1728 m_option_group.Finalize(); 1729 } 1730 1731 ~CommandObjectBreakpointNameAdd() override = default; 1732 1733 Options *GetOptions() override { return &m_option_group; } 1734 1735 protected: 1736 bool DoExecute(Args &command, CommandReturnObject &result) override { 1737 if (!m_name_options.m_name.OptionWasSet()) { 1738 result.SetError("No name option provided."); 1739 return false; 1740 } 1741 1742 Target &target = 1743 GetSelectedOrDummyTarget(m_name_options.m_use_dummy.GetCurrentValue()); 1744 1745 std::unique_lock<std::recursive_mutex> lock; 1746 target.GetBreakpointList().GetListMutex(lock); 1747 1748 const BreakpointList &breakpoints = target.GetBreakpointList(); 1749 1750 size_t num_breakpoints = breakpoints.GetSize(); 1751 if (num_breakpoints == 0) { 1752 result.SetError("No breakpoints, cannot add names."); 1753 result.SetStatus(eReturnStatusFailed); 1754 return false; 1755 } 1756 1757 // Particular breakpoint selected; disable that breakpoint. 1758 BreakpointIDList valid_bp_ids; 1759 CommandObjectMultiwordBreakpoint::VerifyBreakpointIDs( 1760 command, &target, result, &valid_bp_ids, 1761 BreakpointName::Permissions::PermissionKinds::listPerm); 1762 1763 if (result.Succeeded()) { 1764 if (valid_bp_ids.GetSize() == 0) { 1765 result.SetError("No breakpoints specified, cannot add names."); 1766 result.SetStatus(eReturnStatusFailed); 1767 return false; 1768 } 1769 size_t num_valid_ids = valid_bp_ids.GetSize(); 1770 const char *bp_name = m_name_options.m_name.GetCurrentValue(); 1771 Status error; // This error reports illegal names, but we've already 1772 // checked that, so we don't need to check it again here. 1773 for (size_t index = 0; index < num_valid_ids; index++) { 1774 lldb::break_id_t bp_id = 1775 valid_bp_ids.GetBreakpointIDAtIndex(index).GetBreakpointID(); 1776 BreakpointSP bp_sp = breakpoints.FindBreakpointByID(bp_id); 1777 target.AddNameToBreakpoint(bp_sp, bp_name, error); 1778 } 1779 } 1780 1781 return true; 1782 } 1783 1784 private: 1785 BreakpointNameOptionGroup m_name_options; 1786 OptionGroupOptions m_option_group; 1787 }; 1788 1789 class CommandObjectBreakpointNameDelete : public CommandObjectParsed { 1790 public: 1791 CommandObjectBreakpointNameDelete(CommandInterpreter &interpreter) 1792 : CommandObjectParsed( 1793 interpreter, "delete", 1794 "Delete a name from the breakpoints provided.", 1795 "breakpoint name delete <command-options> <breakpoint-id-list>"), 1796 m_name_options(), m_option_group() { 1797 // Create the first variant for the first (and only) argument for this 1798 // command. 1799 CommandArgumentEntry arg1; 1800 CommandArgumentData id_arg; 1801 id_arg.arg_type = eArgTypeBreakpointID; 1802 id_arg.arg_repetition = eArgRepeatOptional; 1803 arg1.push_back(id_arg); 1804 m_arguments.push_back(arg1); 1805 1806 m_option_group.Append(&m_name_options, LLDB_OPT_SET_1, LLDB_OPT_SET_ALL); 1807 m_option_group.Finalize(); 1808 } 1809 1810 ~CommandObjectBreakpointNameDelete() override = default; 1811 1812 Options *GetOptions() override { return &m_option_group; } 1813 1814 protected: 1815 bool DoExecute(Args &command, CommandReturnObject &result) override { 1816 if (!m_name_options.m_name.OptionWasSet()) { 1817 result.SetError("No name option provided."); 1818 return false; 1819 } 1820 1821 Target &target = 1822 GetSelectedOrDummyTarget(m_name_options.m_use_dummy.GetCurrentValue()); 1823 1824 std::unique_lock<std::recursive_mutex> lock; 1825 target.GetBreakpointList().GetListMutex(lock); 1826 1827 const BreakpointList &breakpoints = target.GetBreakpointList(); 1828 1829 size_t num_breakpoints = breakpoints.GetSize(); 1830 if (num_breakpoints == 0) { 1831 result.SetError("No breakpoints, cannot delete names."); 1832 result.SetStatus(eReturnStatusFailed); 1833 return false; 1834 } 1835 1836 // Particular breakpoint selected; disable that breakpoint. 1837 BreakpointIDList valid_bp_ids; 1838 CommandObjectMultiwordBreakpoint::VerifyBreakpointIDs( 1839 command, &target, result, &valid_bp_ids, 1840 BreakpointName::Permissions::PermissionKinds::deletePerm); 1841 1842 if (result.Succeeded()) { 1843 if (valid_bp_ids.GetSize() == 0) { 1844 result.SetError("No breakpoints specified, cannot delete names."); 1845 result.SetStatus(eReturnStatusFailed); 1846 return false; 1847 } 1848 ConstString bp_name(m_name_options.m_name.GetCurrentValue()); 1849 size_t num_valid_ids = valid_bp_ids.GetSize(); 1850 for (size_t index = 0; index < num_valid_ids; index++) { 1851 lldb::break_id_t bp_id = 1852 valid_bp_ids.GetBreakpointIDAtIndex(index).GetBreakpointID(); 1853 BreakpointSP bp_sp = breakpoints.FindBreakpointByID(bp_id); 1854 target.RemoveNameFromBreakpoint(bp_sp, bp_name); 1855 } 1856 } 1857 1858 return true; 1859 } 1860 1861 private: 1862 BreakpointNameOptionGroup m_name_options; 1863 OptionGroupOptions m_option_group; 1864 }; 1865 1866 class CommandObjectBreakpointNameList : public CommandObjectParsed { 1867 public: 1868 CommandObjectBreakpointNameList(CommandInterpreter &interpreter) 1869 : CommandObjectParsed(interpreter, "list", 1870 "List either the names for a breakpoint or info " 1871 "about a given name. With no arguments, lists all " 1872 "names", 1873 "breakpoint name list <command-options>"), 1874 m_name_options(), m_option_group() { 1875 m_option_group.Append(&m_name_options, LLDB_OPT_SET_3, LLDB_OPT_SET_ALL); 1876 m_option_group.Finalize(); 1877 } 1878 1879 ~CommandObjectBreakpointNameList() override = default; 1880 1881 Options *GetOptions() override { return &m_option_group; } 1882 1883 protected: 1884 bool DoExecute(Args &command, CommandReturnObject &result) override { 1885 Target &target = 1886 GetSelectedOrDummyTarget(m_name_options.m_use_dummy.GetCurrentValue()); 1887 1888 std::vector<std::string> name_list; 1889 if (command.empty()) { 1890 target.GetBreakpointNames(name_list); 1891 } else { 1892 for (const Args::ArgEntry &arg : command) { 1893 name_list.push_back(arg.c_str()); 1894 } 1895 } 1896 1897 if (name_list.empty()) { 1898 result.AppendMessage("No breakpoint names found."); 1899 } else { 1900 for (const std::string &name_str : name_list) { 1901 const char *name = name_str.c_str(); 1902 // First print out the options for the name: 1903 Status error; 1904 BreakpointName *bp_name = 1905 target.FindBreakpointName(ConstString(name), false, error); 1906 if (bp_name) { 1907 StreamString s; 1908 result.AppendMessageWithFormat("Name: %s\n", name); 1909 if (bp_name->GetDescription(&s, eDescriptionLevelFull)) { 1910 result.AppendMessage(s.GetString()); 1911 } 1912 1913 std::unique_lock<std::recursive_mutex> lock; 1914 target.GetBreakpointList().GetListMutex(lock); 1915 1916 BreakpointList &breakpoints = target.GetBreakpointList(); 1917 bool any_set = false; 1918 for (BreakpointSP bp_sp : breakpoints.Breakpoints()) { 1919 if (bp_sp->MatchesName(name)) { 1920 StreamString s; 1921 any_set = true; 1922 bp_sp->GetDescription(&s, eDescriptionLevelBrief); 1923 s.EOL(); 1924 result.AppendMessage(s.GetString()); 1925 } 1926 } 1927 if (!any_set) 1928 result.AppendMessage("No breakpoints using this name."); 1929 } else { 1930 result.AppendMessageWithFormat("Name: %s not found.\n", name); 1931 } 1932 } 1933 } 1934 return true; 1935 } 1936 1937 private: 1938 BreakpointNameOptionGroup m_name_options; 1939 OptionGroupOptions m_option_group; 1940 }; 1941 1942 // CommandObjectBreakpointName 1943 class CommandObjectBreakpointName : public CommandObjectMultiword { 1944 public: 1945 CommandObjectBreakpointName(CommandInterpreter &interpreter) 1946 : CommandObjectMultiword( 1947 interpreter, "name", "Commands to manage name tags for breakpoints", 1948 "breakpoint name <subcommand> [<command-options>]") { 1949 CommandObjectSP add_command_object( 1950 new CommandObjectBreakpointNameAdd(interpreter)); 1951 CommandObjectSP delete_command_object( 1952 new CommandObjectBreakpointNameDelete(interpreter)); 1953 CommandObjectSP list_command_object( 1954 new CommandObjectBreakpointNameList(interpreter)); 1955 CommandObjectSP configure_command_object( 1956 new CommandObjectBreakpointNameConfigure(interpreter)); 1957 1958 LoadSubCommand("add", add_command_object); 1959 LoadSubCommand("delete", delete_command_object); 1960 LoadSubCommand("list", list_command_object); 1961 LoadSubCommand("configure", configure_command_object); 1962 } 1963 1964 ~CommandObjectBreakpointName() override = default; 1965 }; 1966 1967 // CommandObjectBreakpointRead 1968 #pragma mark Read::CommandOptions 1969 #define LLDB_OPTIONS_breakpoint_read 1970 #include "CommandOptions.inc" 1971 1972 #pragma mark Read 1973 1974 class CommandObjectBreakpointRead : public CommandObjectParsed { 1975 public: 1976 CommandObjectBreakpointRead(CommandInterpreter &interpreter) 1977 : CommandObjectParsed(interpreter, "breakpoint read", 1978 "Read and set the breakpoints previously saved to " 1979 "a file with \"breakpoint write\". ", 1980 nullptr), 1981 m_options() { 1982 CommandArgumentEntry arg; 1983 CommandObject::AddIDsArgumentData(arg, eArgTypeBreakpointID, 1984 eArgTypeBreakpointIDRange); 1985 // Add the entry for the first argument for this command to the object's 1986 // arguments vector. 1987 m_arguments.push_back(arg); 1988 } 1989 1990 ~CommandObjectBreakpointRead() override = default; 1991 1992 Options *GetOptions() override { return &m_options; } 1993 1994 class CommandOptions : public Options { 1995 public: 1996 CommandOptions() : Options() {} 1997 1998 ~CommandOptions() override = default; 1999 2000 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, 2001 ExecutionContext *execution_context) override { 2002 Status error; 2003 const int short_option = m_getopt_table[option_idx].val; 2004 2005 switch (short_option) { 2006 case 'f': 2007 m_filename.assign(option_arg); 2008 break; 2009 case 'N': { 2010 Status name_error; 2011 if (!BreakpointID::StringIsBreakpointName(llvm::StringRef(option_arg), 2012 name_error)) { 2013 error.SetErrorStringWithFormat("Invalid breakpoint name: %s", 2014 name_error.AsCString()); 2015 } 2016 m_names.push_back(option_arg); 2017 break; 2018 } 2019 default: 2020 llvm_unreachable("Unimplemented option"); 2021 } 2022 2023 return error; 2024 } 2025 2026 void OptionParsingStarting(ExecutionContext *execution_context) override { 2027 m_filename.clear(); 2028 m_names.clear(); 2029 } 2030 2031 llvm::ArrayRef<OptionDefinition> GetDefinitions() override { 2032 return llvm::makeArrayRef(g_breakpoint_read_options); 2033 } 2034 2035 // Instance variables to hold the values for command options. 2036 2037 std::string m_filename; 2038 std::vector<std::string> m_names; 2039 }; 2040 2041 protected: 2042 bool DoExecute(Args &command, CommandReturnObject &result) override { 2043 Target &target = GetSelectedOrDummyTarget(); 2044 2045 std::unique_lock<std::recursive_mutex> lock; 2046 target.GetBreakpointList().GetListMutex(lock); 2047 2048 FileSpec input_spec(m_options.m_filename); 2049 FileSystem::Instance().Resolve(input_spec); 2050 BreakpointIDList new_bps; 2051 Status error = target.CreateBreakpointsFromFile(input_spec, 2052 m_options.m_names, new_bps); 2053 2054 if (!error.Success()) { 2055 result.AppendError(error.AsCString()); 2056 result.SetStatus(eReturnStatusFailed); 2057 return false; 2058 } 2059 2060 Stream &output_stream = result.GetOutputStream(); 2061 2062 size_t num_breakpoints = new_bps.GetSize(); 2063 if (num_breakpoints == 0) { 2064 result.AppendMessage("No breakpoints added."); 2065 } else { 2066 // No breakpoint selected; show info about all currently set breakpoints. 2067 result.AppendMessage("New breakpoints:"); 2068 for (size_t i = 0; i < num_breakpoints; ++i) { 2069 BreakpointID bp_id = new_bps.GetBreakpointIDAtIndex(i); 2070 Breakpoint *bp = target.GetBreakpointList() 2071 .FindBreakpointByID(bp_id.GetBreakpointID()) 2072 .get(); 2073 if (bp) 2074 bp->GetDescription(&output_stream, lldb::eDescriptionLevelInitial, 2075 false); 2076 } 2077 } 2078 return result.Succeeded(); 2079 } 2080 2081 private: 2082 CommandOptions m_options; 2083 }; 2084 2085 // CommandObjectBreakpointWrite 2086 #pragma mark Write::CommandOptions 2087 #define LLDB_OPTIONS_breakpoint_write 2088 #include "CommandOptions.inc" 2089 2090 #pragma mark Write 2091 class CommandObjectBreakpointWrite : public CommandObjectParsed { 2092 public: 2093 CommandObjectBreakpointWrite(CommandInterpreter &interpreter) 2094 : CommandObjectParsed(interpreter, "breakpoint write", 2095 "Write the breakpoints listed to a file that can " 2096 "be read in with \"breakpoint read\". " 2097 "If given no arguments, writes all breakpoints.", 2098 nullptr), 2099 m_options() { 2100 CommandArgumentEntry arg; 2101 CommandObject::AddIDsArgumentData(arg, eArgTypeBreakpointID, 2102 eArgTypeBreakpointIDRange); 2103 // Add the entry for the first argument for this command to the object's 2104 // arguments vector. 2105 m_arguments.push_back(arg); 2106 } 2107 2108 ~CommandObjectBreakpointWrite() override = default; 2109 2110 Options *GetOptions() override { return &m_options; } 2111 2112 class CommandOptions : public Options { 2113 public: 2114 CommandOptions() : Options() {} 2115 2116 ~CommandOptions() override = default; 2117 2118 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, 2119 ExecutionContext *execution_context) override { 2120 Status error; 2121 const int short_option = m_getopt_table[option_idx].val; 2122 2123 switch (short_option) { 2124 case 'f': 2125 m_filename.assign(option_arg); 2126 break; 2127 case 'a': 2128 m_append = true; 2129 break; 2130 default: 2131 llvm_unreachable("Unimplemented option"); 2132 } 2133 2134 return error; 2135 } 2136 2137 void OptionParsingStarting(ExecutionContext *execution_context) override { 2138 m_filename.clear(); 2139 m_append = false; 2140 } 2141 2142 llvm::ArrayRef<OptionDefinition> GetDefinitions() override { 2143 return llvm::makeArrayRef(g_breakpoint_write_options); 2144 } 2145 2146 // Instance variables to hold the values for command options. 2147 2148 std::string m_filename; 2149 bool m_append = false; 2150 }; 2151 2152 protected: 2153 bool DoExecute(Args &command, CommandReturnObject &result) override { 2154 Target &target = GetSelectedOrDummyTarget(); 2155 2156 std::unique_lock<std::recursive_mutex> lock; 2157 target.GetBreakpointList().GetListMutex(lock); 2158 2159 BreakpointIDList valid_bp_ids; 2160 if (!command.empty()) { 2161 CommandObjectMultiwordBreakpoint::VerifyBreakpointIDs( 2162 command, &target, result, &valid_bp_ids, 2163 BreakpointName::Permissions::PermissionKinds::listPerm); 2164 2165 if (!result.Succeeded()) { 2166 result.SetStatus(eReturnStatusFailed); 2167 return false; 2168 } 2169 } 2170 FileSpec file_spec(m_options.m_filename); 2171 FileSystem::Instance().Resolve(file_spec); 2172 Status error = target.SerializeBreakpointsToFile(file_spec, valid_bp_ids, 2173 m_options.m_append); 2174 if (!error.Success()) { 2175 result.AppendErrorWithFormat("error serializing breakpoints: %s.", 2176 error.AsCString()); 2177 result.SetStatus(eReturnStatusFailed); 2178 } 2179 return result.Succeeded(); 2180 } 2181 2182 private: 2183 CommandOptions m_options; 2184 }; 2185 2186 // CommandObjectMultiwordBreakpoint 2187 #pragma mark MultiwordBreakpoint 2188 2189 CommandObjectMultiwordBreakpoint::CommandObjectMultiwordBreakpoint( 2190 CommandInterpreter &interpreter) 2191 : CommandObjectMultiword( 2192 interpreter, "breakpoint", 2193 "Commands for operating on breakpoints (see 'help b' for shorthand.)", 2194 "breakpoint <subcommand> [<command-options>]") { 2195 CommandObjectSP list_command_object( 2196 new CommandObjectBreakpointList(interpreter)); 2197 CommandObjectSP enable_command_object( 2198 new CommandObjectBreakpointEnable(interpreter)); 2199 CommandObjectSP disable_command_object( 2200 new CommandObjectBreakpointDisable(interpreter)); 2201 CommandObjectSP clear_command_object( 2202 new CommandObjectBreakpointClear(interpreter)); 2203 CommandObjectSP delete_command_object( 2204 new CommandObjectBreakpointDelete(interpreter)); 2205 CommandObjectSP set_command_object( 2206 new CommandObjectBreakpointSet(interpreter)); 2207 CommandObjectSP command_command_object( 2208 new CommandObjectBreakpointCommand(interpreter)); 2209 CommandObjectSP modify_command_object( 2210 new CommandObjectBreakpointModify(interpreter)); 2211 CommandObjectSP name_command_object( 2212 new CommandObjectBreakpointName(interpreter)); 2213 CommandObjectSP write_command_object( 2214 new CommandObjectBreakpointWrite(interpreter)); 2215 CommandObjectSP read_command_object( 2216 new CommandObjectBreakpointRead(interpreter)); 2217 2218 list_command_object->SetCommandName("breakpoint list"); 2219 enable_command_object->SetCommandName("breakpoint enable"); 2220 disable_command_object->SetCommandName("breakpoint disable"); 2221 clear_command_object->SetCommandName("breakpoint clear"); 2222 delete_command_object->SetCommandName("breakpoint delete"); 2223 set_command_object->SetCommandName("breakpoint set"); 2224 command_command_object->SetCommandName("breakpoint command"); 2225 modify_command_object->SetCommandName("breakpoint modify"); 2226 name_command_object->SetCommandName("breakpoint name"); 2227 write_command_object->SetCommandName("breakpoint write"); 2228 read_command_object->SetCommandName("breakpoint read"); 2229 2230 LoadSubCommand("list", list_command_object); 2231 LoadSubCommand("enable", enable_command_object); 2232 LoadSubCommand("disable", disable_command_object); 2233 LoadSubCommand("clear", clear_command_object); 2234 LoadSubCommand("delete", delete_command_object); 2235 LoadSubCommand("set", set_command_object); 2236 LoadSubCommand("command", command_command_object); 2237 LoadSubCommand("modify", modify_command_object); 2238 LoadSubCommand("name", name_command_object); 2239 LoadSubCommand("write", write_command_object); 2240 LoadSubCommand("read", read_command_object); 2241 } 2242 2243 CommandObjectMultiwordBreakpoint::~CommandObjectMultiwordBreakpoint() = default; 2244 2245 void CommandObjectMultiwordBreakpoint::VerifyIDs( 2246 Args &args, Target *target, bool allow_locations, 2247 CommandReturnObject &result, BreakpointIDList *valid_ids, 2248 BreakpointName::Permissions ::PermissionKinds purpose) { 2249 // args can be strings representing 1). integers (for breakpoint ids) 2250 // 2). the full breakpoint & location 2251 // canonical representation 2252 // 3). the word "to" or a hyphen, 2253 // representing a range (in which case there 2254 // had *better* be an entry both before & 2255 // after of one of the first two types. 2256 // 4). A breakpoint name 2257 // If args is empty, we will use the last created breakpoint (if there is 2258 // one.) 2259 2260 Args temp_args; 2261 2262 if (args.empty()) { 2263 if (target->GetLastCreatedBreakpoint()) { 2264 valid_ids->AddBreakpointID(BreakpointID( 2265 target->GetLastCreatedBreakpoint()->GetID(), LLDB_INVALID_BREAK_ID)); 2266 result.SetStatus(eReturnStatusSuccessFinishNoResult); 2267 } else { 2268 result.AppendError( 2269 "No breakpoint specified and no last created breakpoint."); 2270 result.SetStatus(eReturnStatusFailed); 2271 } 2272 return; 2273 } 2274 2275 // Create a new Args variable to use; copy any non-breakpoint-id-ranges stuff 2276 // directly from the old ARGS to the new TEMP_ARGS. Do not copy breakpoint 2277 // id range strings over; instead generate a list of strings for all the 2278 // breakpoint ids in the range, and shove all of those breakpoint id strings 2279 // into TEMP_ARGS. 2280 2281 BreakpointIDList::FindAndReplaceIDRanges(args, target, allow_locations, 2282 purpose, result, temp_args); 2283 2284 // NOW, convert the list of breakpoint id strings in TEMP_ARGS into an actual 2285 // BreakpointIDList: 2286 2287 valid_ids->InsertStringArray(temp_args.GetArgumentArrayRef(), result); 2288 2289 // At this point, all of the breakpoint ids that the user passed in have 2290 // been converted to breakpoint IDs and put into valid_ids. 2291 2292 if (result.Succeeded()) { 2293 // Now that we've converted everything from args into a list of breakpoint 2294 // ids, go through our tentative list of breakpoint id's and verify that 2295 // they correspond to valid/currently set breakpoints. 2296 2297 const size_t count = valid_ids->GetSize(); 2298 for (size_t i = 0; i < count; ++i) { 2299 BreakpointID cur_bp_id = valid_ids->GetBreakpointIDAtIndex(i); 2300 Breakpoint *breakpoint = 2301 target->GetBreakpointByID(cur_bp_id.GetBreakpointID()).get(); 2302 if (breakpoint != nullptr) { 2303 const size_t num_locations = breakpoint->GetNumLocations(); 2304 if (static_cast<size_t>(cur_bp_id.GetLocationID()) > num_locations) { 2305 StreamString id_str; 2306 BreakpointID::GetCanonicalReference( 2307 &id_str, cur_bp_id.GetBreakpointID(), cur_bp_id.GetLocationID()); 2308 i = valid_ids->GetSize() + 1; 2309 result.AppendErrorWithFormat( 2310 "'%s' is not a currently valid breakpoint/location id.\n", 2311 id_str.GetData()); 2312 result.SetStatus(eReturnStatusFailed); 2313 } 2314 } else { 2315 i = valid_ids->GetSize() + 1; 2316 result.AppendErrorWithFormat( 2317 "'%d' is not a currently valid breakpoint ID.\n", 2318 cur_bp_id.GetBreakpointID()); 2319 result.SetStatus(eReturnStatusFailed); 2320 } 2321 } 2322 } 2323 } 2324