1 //===-- CommandObjectWatchpoint.cpp -----------------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "lldb/lldb-python.h" 11 12 #include "CommandObjectWatchpoint.h" 13 #include "CommandObjectWatchpointCommand.h" 14 15 // C Includes 16 // C++ Includes 17 // Other libraries and framework includes 18 // Project includes 19 #include "lldb/Breakpoint/Watchpoint.h" 20 #include "lldb/Breakpoint/WatchpointList.h" 21 #include "lldb/Core/StreamString.h" 22 #include "lldb/Core/ValueObject.h" 23 #include "lldb/Core/ValueObjectVariable.h" 24 #include "lldb/Interpreter/CommandInterpreter.h" 25 #include "lldb/Interpreter/CommandReturnObject.h" 26 #include "lldb/Interpreter/CommandCompletions.h" 27 #include "lldb/Symbol/Variable.h" 28 #include "lldb/Symbol/VariableList.h" 29 #include "lldb/Target/Target.h" 30 31 #include <vector> 32 33 using namespace lldb; 34 using namespace lldb_private; 35 36 static void 37 AddWatchpointDescription(Stream *s, Watchpoint *wp, lldb::DescriptionLevel level) 38 { 39 s->IndentMore(); 40 wp->GetDescription(s, level); 41 s->IndentLess(); 42 s->EOL(); 43 } 44 45 static bool 46 CheckTargetForWatchpointOperations(Target *target, CommandReturnObject &result) 47 { 48 if (target == NULL) 49 { 50 result.AppendError ("Invalid target. No existing target or watchpoints."); 51 result.SetStatus (eReturnStatusFailed); 52 return false; 53 } 54 bool process_is_valid = target->GetProcessSP() && target->GetProcessSP()->IsAlive(); 55 if (!process_is_valid) 56 { 57 result.AppendError ("Thre's no process or it is not alive."); 58 result.SetStatus (eReturnStatusFailed); 59 return false; 60 } 61 // Target passes our checks, return true. 62 return true; 63 } 64 65 // FIXME: This doesn't seem to be the right place for this functionality. 66 #include "llvm/ADT/StringRef.h" 67 static inline void StripLeadingSpaces(llvm::StringRef &Str) 68 { 69 while (!Str.empty() && isspace(Str[0])) 70 Str = Str.substr(1); 71 } 72 73 // Equivalent class: {"-", "to", "To", "TO"} of range specifier array. 74 static const char* RSA[4] = { "-", "to", "To", "TO" }; 75 76 // Return the index to RSA if found; otherwise -1 is returned. 77 static int32_t 78 WithRSAIndex(llvm::StringRef &Arg) 79 { 80 81 uint32_t i; 82 for (i = 0; i < 4; ++i) 83 if (Arg.find(RSA[i]) != llvm::StringRef::npos) 84 return i; 85 return -1; 86 } 87 88 // Return true if wp_ids is successfully populated with the watch ids. 89 // False otherwise. 90 bool 91 CommandObjectMultiwordWatchpoint::VerifyWatchpointIDs(Target *target, Args &args, std::vector<uint32_t> &wp_ids) 92 { 93 // Pre-condition: args.GetArgumentCount() > 0. 94 if (args.GetArgumentCount() == 0) 95 { 96 if (target == NULL) 97 return false; 98 WatchpointSP watch_sp = target->GetLastCreatedWatchpoint(); 99 if (watch_sp) 100 { 101 wp_ids.push_back(watch_sp->GetID()); 102 return true; 103 } 104 else 105 return false; 106 } 107 108 llvm::StringRef Minus("-"); 109 std::vector<llvm::StringRef> StrRefArgs; 110 std::pair<llvm::StringRef, llvm::StringRef> Pair; 111 size_t i; 112 int32_t idx; 113 // Go through the argments and make a canonical form of arg list containing 114 // only numbers with possible "-" in between. 115 for (i = 0; i < args.GetArgumentCount(); ++i) { 116 llvm::StringRef Arg(args.GetArgumentAtIndex(i)); 117 if ((idx = WithRSAIndex(Arg)) == -1) { 118 StrRefArgs.push_back(Arg); 119 continue; 120 } 121 // The Arg contains the range specifier, split it, then. 122 Pair = Arg.split(RSA[idx]); 123 if (!Pair.first.empty()) 124 StrRefArgs.push_back(Pair.first); 125 StrRefArgs.push_back(Minus); 126 if (!Pair.second.empty()) 127 StrRefArgs.push_back(Pair.second); 128 } 129 // Now process the canonical list and fill in the vector of uint32_t's. 130 // If there is any error, return false and the client should ignore wp_ids. 131 uint32_t beg, end, id; 132 size_t size = StrRefArgs.size(); 133 bool in_range = false; 134 for (i = 0; i < size; ++i) { 135 llvm::StringRef Arg = StrRefArgs[i]; 136 if (in_range) { 137 // Look for the 'end' of the range. Note StringRef::getAsInteger() 138 // returns true to signify error while parsing. 139 if (Arg.getAsInteger(0, end)) 140 return false; 141 // Found a range! Now append the elements. 142 for (id = beg; id <= end; ++id) 143 wp_ids.push_back(id); 144 in_range = false; 145 continue; 146 } 147 if (i < (size - 1) && StrRefArgs[i+1] == Minus) { 148 if (Arg.getAsInteger(0, beg)) 149 return false; 150 // Turn on the in_range flag, we are looking for end of range next. 151 ++i; in_range = true; 152 continue; 153 } 154 // Otherwise, we have a simple ID. Just append it. 155 if (Arg.getAsInteger(0, beg)) 156 return false; 157 wp_ids.push_back(beg); 158 } 159 // It is an error if after the loop, we're still in_range. 160 if (in_range) 161 return false; 162 163 return true; // Success! 164 } 165 166 //------------------------------------------------------------------------- 167 // CommandObjectWatchpointList 168 //------------------------------------------------------------------------- 169 #pragma mark List 170 171 class CommandObjectWatchpointList : public CommandObjectParsed 172 { 173 public: 174 CommandObjectWatchpointList (CommandInterpreter &interpreter) : 175 CommandObjectParsed (interpreter, 176 "watchpoint list", 177 "List all watchpoints at configurable levels of detail.", 178 NULL), 179 m_options(interpreter) 180 { 181 CommandArgumentEntry arg; 182 CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID, eArgTypeWatchpointIDRange); 183 // Add the entry for the first argument for this command to the object's arguments vector. 184 m_arguments.push_back(arg); 185 } 186 187 virtual 188 ~CommandObjectWatchpointList () {} 189 190 virtual Options * 191 GetOptions () 192 { 193 return &m_options; 194 } 195 196 class CommandOptions : public Options 197 { 198 public: 199 200 CommandOptions (CommandInterpreter &interpreter) : 201 Options(interpreter), 202 m_level(lldb::eDescriptionLevelBrief) // Watchpoint List defaults to brief descriptions 203 { 204 } 205 206 virtual 207 ~CommandOptions () {} 208 209 virtual Error 210 SetOptionValue (uint32_t option_idx, const char *option_arg) 211 { 212 Error error; 213 const int short_option = m_getopt_table[option_idx].val; 214 215 switch (short_option) 216 { 217 case 'b': 218 m_level = lldb::eDescriptionLevelBrief; 219 break; 220 case 'f': 221 m_level = lldb::eDescriptionLevelFull; 222 break; 223 case 'v': 224 m_level = lldb::eDescriptionLevelVerbose; 225 break; 226 default: 227 error.SetErrorStringWithFormat("unrecognized option '%c'", short_option); 228 break; 229 } 230 231 return error; 232 } 233 234 void 235 OptionParsingStarting () 236 { 237 m_level = lldb::eDescriptionLevelFull; 238 } 239 240 const OptionDefinition * 241 GetDefinitions () 242 { 243 return g_option_table; 244 } 245 246 247 // Options table: Required for subclasses of Options. 248 249 static OptionDefinition g_option_table[]; 250 251 // Instance variables to hold the values for command options. 252 253 lldb::DescriptionLevel m_level; 254 }; 255 256 protected: 257 virtual bool 258 DoExecute (Args& command, CommandReturnObject &result) 259 { 260 Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get(); 261 if (target == NULL) 262 { 263 result.AppendError ("Invalid target. No current target or watchpoints."); 264 result.SetStatus (eReturnStatusSuccessFinishNoResult); 265 return true; 266 } 267 268 if (target->GetProcessSP() && target->GetProcessSP()->IsAlive()) 269 { 270 uint32_t num_supported_hardware_watchpoints; 271 Error error = target->GetProcessSP()->GetWatchpointSupportInfo(num_supported_hardware_watchpoints); 272 if (error.Success()) 273 result.AppendMessageWithFormat("Number of supported hardware watchpoints: %u\n", 274 num_supported_hardware_watchpoints); 275 } 276 277 const WatchpointList &watchpoints = target->GetWatchpointList(); 278 Mutex::Locker locker; 279 target->GetWatchpointList().GetListMutex(locker); 280 281 size_t num_watchpoints = watchpoints.GetSize(); 282 283 if (num_watchpoints == 0) 284 { 285 result.AppendMessage("No watchpoints currently set."); 286 result.SetStatus(eReturnStatusSuccessFinishNoResult); 287 return true; 288 } 289 290 Stream &output_stream = result.GetOutputStream(); 291 292 if (command.GetArgumentCount() == 0) 293 { 294 // No watchpoint selected; show info about all currently set watchpoints. 295 result.AppendMessage ("Current watchpoints:"); 296 for (size_t i = 0; i < num_watchpoints; ++i) 297 { 298 Watchpoint *wp = watchpoints.GetByIndex(i).get(); 299 AddWatchpointDescription(&output_stream, wp, m_options.m_level); 300 } 301 result.SetStatus(eReturnStatusSuccessFinishNoResult); 302 } 303 else 304 { 305 // Particular watchpoints selected; enable them. 306 std::vector<uint32_t> wp_ids; 307 if (!CommandObjectMultiwordWatchpoint::VerifyWatchpointIDs(target, command, wp_ids)) 308 { 309 result.AppendError("Invalid watchpoints specification."); 310 result.SetStatus(eReturnStatusFailed); 311 return false; 312 } 313 314 const size_t size = wp_ids.size(); 315 for (size_t i = 0; i < size; ++i) 316 { 317 Watchpoint *wp = watchpoints.FindByID(wp_ids[i]).get(); 318 if (wp) 319 AddWatchpointDescription(&output_stream, wp, m_options.m_level); 320 result.SetStatus(eReturnStatusSuccessFinishNoResult); 321 } 322 } 323 324 return result.Succeeded(); 325 } 326 327 private: 328 CommandOptions m_options; 329 }; 330 331 //------------------------------------------------------------------------- 332 // CommandObjectWatchpointList::Options 333 //------------------------------------------------------------------------- 334 #pragma mark List::CommandOptions 335 OptionDefinition 336 CommandObjectWatchpointList::CommandOptions::g_option_table[] = 337 { 338 { LLDB_OPT_SET_1, false, "brief", 'b', no_argument, NULL, 0, eArgTypeNone, 339 "Give a brief description of the watchpoint (no location info)."}, 340 341 { LLDB_OPT_SET_2, false, "full", 'f', no_argument, NULL, 0, eArgTypeNone, 342 "Give a full description of the watchpoint and its locations."}, 343 344 { LLDB_OPT_SET_3, false, "verbose", 'v', no_argument, NULL, 0, eArgTypeNone, 345 "Explain everything we know about the watchpoint (for debugging debugger bugs)." }, 346 347 { 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL } 348 }; 349 350 //------------------------------------------------------------------------- 351 // CommandObjectWatchpointEnable 352 //------------------------------------------------------------------------- 353 #pragma mark Enable 354 355 class CommandObjectWatchpointEnable : public CommandObjectParsed 356 { 357 public: 358 CommandObjectWatchpointEnable (CommandInterpreter &interpreter) : 359 CommandObjectParsed (interpreter, 360 "enable", 361 "Enable the specified disabled watchpoint(s). If no watchpoints are specified, enable all of them.", 362 NULL) 363 { 364 CommandArgumentEntry arg; 365 CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID, eArgTypeWatchpointIDRange); 366 // Add the entry for the first argument for this command to the object's arguments vector. 367 m_arguments.push_back(arg); 368 } 369 370 virtual 371 ~CommandObjectWatchpointEnable () {} 372 373 protected: 374 virtual bool 375 DoExecute (Args& command, 376 CommandReturnObject &result) 377 { 378 Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get(); 379 if (!CheckTargetForWatchpointOperations(target, result)) 380 return false; 381 382 Mutex::Locker locker; 383 target->GetWatchpointList().GetListMutex(locker); 384 385 const WatchpointList &watchpoints = target->GetWatchpointList(); 386 387 size_t num_watchpoints = watchpoints.GetSize(); 388 389 if (num_watchpoints == 0) 390 { 391 result.AppendError("No watchpoints exist to be enabled."); 392 result.SetStatus(eReturnStatusFailed); 393 return false; 394 } 395 396 if (command.GetArgumentCount() == 0) 397 { 398 // No watchpoint selected; enable all currently set watchpoints. 399 target->EnableAllWatchpoints(); 400 result.AppendMessageWithFormat("All watchpoints enabled. (%lu watchpoints)\n", num_watchpoints); 401 result.SetStatus(eReturnStatusSuccessFinishNoResult); 402 } 403 else 404 { 405 // Particular watchpoints selected; enable them. 406 std::vector<uint32_t> wp_ids; 407 if (!CommandObjectMultiwordWatchpoint::VerifyWatchpointIDs(target, command, wp_ids)) 408 { 409 result.AppendError("Invalid watchpoints specification."); 410 result.SetStatus(eReturnStatusFailed); 411 return false; 412 } 413 414 int count = 0; 415 const size_t size = wp_ids.size(); 416 for (size_t i = 0; i < size; ++i) 417 if (target->EnableWatchpointByID(wp_ids[i])) 418 ++count; 419 result.AppendMessageWithFormat("%d watchpoints enabled.\n", count); 420 result.SetStatus(eReturnStatusSuccessFinishNoResult); 421 } 422 423 return result.Succeeded(); 424 } 425 426 private: 427 }; 428 429 //------------------------------------------------------------------------- 430 // CommandObjectWatchpointDisable 431 //------------------------------------------------------------------------- 432 #pragma mark Disable 433 434 class CommandObjectWatchpointDisable : public CommandObjectParsed 435 { 436 public: 437 CommandObjectWatchpointDisable (CommandInterpreter &interpreter) : 438 CommandObjectParsed (interpreter, 439 "watchpoint disable", 440 "Disable the specified watchpoint(s) without removing it/them. If no watchpoints are specified, disable them all.", 441 NULL) 442 { 443 CommandArgumentEntry arg; 444 CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID, eArgTypeWatchpointIDRange); 445 // Add the entry for the first argument for this command to the object's arguments vector. 446 m_arguments.push_back(arg); 447 } 448 449 450 virtual 451 ~CommandObjectWatchpointDisable () {} 452 453 protected: 454 virtual bool 455 DoExecute (Args& command, CommandReturnObject &result) 456 { 457 Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get(); 458 if (!CheckTargetForWatchpointOperations(target, result)) 459 return false; 460 461 Mutex::Locker locker; 462 target->GetWatchpointList().GetListMutex(locker); 463 464 const WatchpointList &watchpoints = target->GetWatchpointList(); 465 size_t num_watchpoints = watchpoints.GetSize(); 466 467 if (num_watchpoints == 0) 468 { 469 result.AppendError("No watchpoints exist to be disabled."); 470 result.SetStatus(eReturnStatusFailed); 471 return false; 472 } 473 474 if (command.GetArgumentCount() == 0) 475 { 476 // No watchpoint selected; disable all currently set watchpoints. 477 if (target->DisableAllWatchpoints()) 478 { 479 result.AppendMessageWithFormat("All watchpoints disabled. (%lu watchpoints)\n", num_watchpoints); 480 result.SetStatus(eReturnStatusSuccessFinishNoResult); 481 } 482 else 483 { 484 result.AppendError("Disable all watchpoints failed\n"); 485 result.SetStatus(eReturnStatusFailed); 486 } 487 } 488 else 489 { 490 // Particular watchpoints selected; disable them. 491 std::vector<uint32_t> wp_ids; 492 if (!CommandObjectMultiwordWatchpoint::VerifyWatchpointIDs(target, command, wp_ids)) 493 { 494 result.AppendError("Invalid watchpoints specification."); 495 result.SetStatus(eReturnStatusFailed); 496 return false; 497 } 498 499 int count = 0; 500 const size_t size = wp_ids.size(); 501 for (size_t i = 0; i < size; ++i) 502 if (target->DisableWatchpointByID(wp_ids[i])) 503 ++count; 504 result.AppendMessageWithFormat("%d watchpoints disabled.\n", count); 505 result.SetStatus(eReturnStatusSuccessFinishNoResult); 506 } 507 508 return result.Succeeded(); 509 } 510 511 }; 512 513 //------------------------------------------------------------------------- 514 // CommandObjectWatchpointDelete 515 //------------------------------------------------------------------------- 516 #pragma mark Delete 517 518 class CommandObjectWatchpointDelete : public CommandObjectParsed 519 { 520 public: 521 CommandObjectWatchpointDelete (CommandInterpreter &interpreter) : 522 CommandObjectParsed(interpreter, 523 "watchpoint delete", 524 "Delete the specified watchpoint(s). If no watchpoints are specified, delete them all.", 525 NULL) 526 { 527 CommandArgumentEntry arg; 528 CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID, eArgTypeWatchpointIDRange); 529 // Add the entry for the first argument for this command to the object's arguments vector. 530 m_arguments.push_back(arg); 531 } 532 533 virtual 534 ~CommandObjectWatchpointDelete () {} 535 536 protected: 537 virtual bool 538 DoExecute (Args& command, CommandReturnObject &result) 539 { 540 Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get(); 541 if (!CheckTargetForWatchpointOperations(target, result)) 542 return false; 543 544 Mutex::Locker locker; 545 target->GetWatchpointList().GetListMutex(locker); 546 547 const WatchpointList &watchpoints = target->GetWatchpointList(); 548 549 size_t num_watchpoints = watchpoints.GetSize(); 550 551 if (num_watchpoints == 0) 552 { 553 result.AppendError("No watchpoints exist to be deleted."); 554 result.SetStatus(eReturnStatusFailed); 555 return false; 556 } 557 558 if (command.GetArgumentCount() == 0) 559 { 560 if (!m_interpreter.Confirm("About to delete all watchpoints, do you want to do that?", true)) 561 { 562 result.AppendMessage("Operation cancelled..."); 563 } 564 else 565 { 566 target->RemoveAllWatchpoints(); 567 result.AppendMessageWithFormat("All watchpoints removed. (%lu watchpoints)\n", num_watchpoints); 568 } 569 result.SetStatus (eReturnStatusSuccessFinishNoResult); 570 } 571 else 572 { 573 // Particular watchpoints selected; delete them. 574 std::vector<uint32_t> wp_ids; 575 if (!CommandObjectMultiwordWatchpoint::VerifyWatchpointIDs(target, command, wp_ids)) 576 { 577 result.AppendError("Invalid watchpoints specification."); 578 result.SetStatus(eReturnStatusFailed); 579 return false; 580 } 581 582 int count = 0; 583 const size_t size = wp_ids.size(); 584 for (size_t i = 0; i < size; ++i) 585 if (target->RemoveWatchpointByID(wp_ids[i])) 586 ++count; 587 result.AppendMessageWithFormat("%d watchpoints deleted.\n",count); 588 result.SetStatus (eReturnStatusSuccessFinishNoResult); 589 } 590 591 return result.Succeeded(); 592 } 593 594 }; 595 596 //------------------------------------------------------------------------- 597 // CommandObjectWatchpointIgnore 598 //------------------------------------------------------------------------- 599 600 class CommandObjectWatchpointIgnore : public CommandObjectParsed 601 { 602 public: 603 CommandObjectWatchpointIgnore (CommandInterpreter &interpreter) : 604 CommandObjectParsed (interpreter, 605 "watchpoint ignore", 606 "Set ignore count on the specified watchpoint(s). If no watchpoints are specified, set them all.", 607 NULL), 608 m_options (interpreter) 609 { 610 CommandArgumentEntry arg; 611 CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID, eArgTypeWatchpointIDRange); 612 // Add the entry for the first argument for this command to the object's arguments vector. 613 m_arguments.push_back(arg); 614 } 615 616 virtual 617 ~CommandObjectWatchpointIgnore () {} 618 619 virtual Options * 620 GetOptions () 621 { 622 return &m_options; 623 } 624 625 class CommandOptions : public Options 626 { 627 public: 628 629 CommandOptions (CommandInterpreter &interpreter) : 630 Options (interpreter), 631 m_ignore_count (0) 632 { 633 } 634 635 virtual 636 ~CommandOptions () {} 637 638 virtual Error 639 SetOptionValue (uint32_t option_idx, const char *option_arg) 640 { 641 Error error; 642 const int short_option = m_getopt_table[option_idx].val; 643 644 switch (short_option) 645 { 646 case 'i': 647 { 648 m_ignore_count = Args::StringToUInt32(option_arg, UINT32_MAX, 0); 649 if (m_ignore_count == UINT32_MAX) 650 error.SetErrorStringWithFormat ("invalid ignore count '%s'", option_arg); 651 } 652 break; 653 default: 654 error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option); 655 break; 656 } 657 658 return error; 659 } 660 661 void 662 OptionParsingStarting () 663 { 664 m_ignore_count = 0; 665 } 666 667 const OptionDefinition * 668 GetDefinitions () 669 { 670 return g_option_table; 671 } 672 673 674 // Options table: Required for subclasses of Options. 675 676 static OptionDefinition g_option_table[]; 677 678 // Instance variables to hold the values for command options. 679 680 uint32_t m_ignore_count; 681 }; 682 683 protected: 684 virtual bool 685 DoExecute (Args& command, 686 CommandReturnObject &result) 687 { 688 Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get(); 689 if (!CheckTargetForWatchpointOperations(target, result)) 690 return false; 691 692 Mutex::Locker locker; 693 target->GetWatchpointList().GetListMutex(locker); 694 695 const WatchpointList &watchpoints = target->GetWatchpointList(); 696 697 size_t num_watchpoints = watchpoints.GetSize(); 698 699 if (num_watchpoints == 0) 700 { 701 result.AppendError("No watchpoints exist to be ignored."); 702 result.SetStatus(eReturnStatusFailed); 703 return false; 704 } 705 706 if (command.GetArgumentCount() == 0) 707 { 708 target->IgnoreAllWatchpoints(m_options.m_ignore_count); 709 result.AppendMessageWithFormat("All watchpoints ignored. (%lu watchpoints)\n", num_watchpoints); 710 result.SetStatus (eReturnStatusSuccessFinishNoResult); 711 } 712 else 713 { 714 // Particular watchpoints selected; ignore them. 715 std::vector<uint32_t> wp_ids; 716 if (!CommandObjectMultiwordWatchpoint::VerifyWatchpointIDs(target, command, wp_ids)) 717 { 718 result.AppendError("Invalid watchpoints specification."); 719 result.SetStatus(eReturnStatusFailed); 720 return false; 721 } 722 723 int count = 0; 724 const size_t size = wp_ids.size(); 725 for (size_t i = 0; i < size; ++i) 726 if (target->IgnoreWatchpointByID(wp_ids[i], m_options.m_ignore_count)) 727 ++count; 728 result.AppendMessageWithFormat("%d watchpoints ignored.\n",count); 729 result.SetStatus (eReturnStatusSuccessFinishNoResult); 730 } 731 732 return result.Succeeded(); 733 } 734 735 private: 736 CommandOptions m_options; 737 }; 738 739 #pragma mark Ignore::CommandOptions 740 OptionDefinition 741 CommandObjectWatchpointIgnore::CommandOptions::g_option_table[] = 742 { 743 { LLDB_OPT_SET_ALL, true, "ignore-count", 'i', required_argument, NULL, 0, eArgTypeCount, "Set the number of times this watchpoint is skipped before stopping." }, 744 { 0, false, NULL, 0 , 0, NULL, 0, eArgTypeNone, NULL } 745 }; 746 747 748 //------------------------------------------------------------------------- 749 // CommandObjectWatchpointModify 750 //------------------------------------------------------------------------- 751 #pragma mark Modify 752 753 class CommandObjectWatchpointModify : public CommandObjectParsed 754 { 755 public: 756 757 CommandObjectWatchpointModify (CommandInterpreter &interpreter) : 758 CommandObjectParsed (interpreter, 759 "watchpoint modify", 760 "Modify the options on a watchpoint or set of watchpoints in the executable. " 761 "If no watchpoint is specified, act on the last created watchpoint. " 762 "Passing an empty argument clears the modification.", 763 NULL), 764 m_options (interpreter) 765 { 766 CommandArgumentEntry arg; 767 CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID, eArgTypeWatchpointIDRange); 768 // Add the entry for the first argument for this command to the object's arguments vector. 769 m_arguments.push_back (arg); 770 } 771 772 virtual 773 ~CommandObjectWatchpointModify () {} 774 775 virtual Options * 776 GetOptions () 777 { 778 return &m_options; 779 } 780 781 class CommandOptions : public Options 782 { 783 public: 784 785 CommandOptions (CommandInterpreter &interpreter) : 786 Options (interpreter), 787 m_condition (), 788 m_condition_passed (false) 789 { 790 } 791 792 virtual 793 ~CommandOptions () {} 794 795 virtual Error 796 SetOptionValue (uint32_t option_idx, const char *option_arg) 797 { 798 Error error; 799 const int short_option = m_getopt_table[option_idx].val; 800 801 switch (short_option) 802 { 803 case 'c': 804 if (option_arg != NULL) 805 m_condition.assign (option_arg); 806 else 807 m_condition.clear(); 808 m_condition_passed = true; 809 break; 810 default: 811 error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option); 812 break; 813 } 814 815 return error; 816 } 817 818 void 819 OptionParsingStarting () 820 { 821 m_condition.clear(); 822 m_condition_passed = false; 823 } 824 825 const OptionDefinition* 826 GetDefinitions () 827 { 828 return g_option_table; 829 } 830 831 // Options table: Required for subclasses of Options. 832 833 static OptionDefinition g_option_table[]; 834 835 // Instance variables to hold the values for command options. 836 837 std::string m_condition; 838 bool m_condition_passed; 839 }; 840 841 protected: 842 virtual bool 843 DoExecute (Args& command, CommandReturnObject &result) 844 { 845 Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get(); 846 if (!CheckTargetForWatchpointOperations(target, result)) 847 return false; 848 849 Mutex::Locker locker; 850 target->GetWatchpointList().GetListMutex(locker); 851 852 const WatchpointList &watchpoints = target->GetWatchpointList(); 853 854 size_t num_watchpoints = watchpoints.GetSize(); 855 856 if (num_watchpoints == 0) 857 { 858 result.AppendError("No watchpoints exist to be modified."); 859 result.SetStatus(eReturnStatusFailed); 860 return false; 861 } 862 863 if (command.GetArgumentCount() == 0) 864 { 865 WatchpointSP wp_sp = target->GetLastCreatedWatchpoint(); 866 wp_sp->SetCondition(m_options.m_condition.c_str()); 867 result.SetStatus (eReturnStatusSuccessFinishNoResult); 868 } 869 else 870 { 871 // Particular watchpoints selected; set condition on them. 872 std::vector<uint32_t> wp_ids; 873 if (!CommandObjectMultiwordWatchpoint::VerifyWatchpointIDs(target, command, wp_ids)) 874 { 875 result.AppendError("Invalid watchpoints specification."); 876 result.SetStatus(eReturnStatusFailed); 877 return false; 878 } 879 880 int count = 0; 881 const size_t size = wp_ids.size(); 882 for (size_t i = 0; i < size; ++i) 883 { 884 WatchpointSP wp_sp = watchpoints.FindByID(wp_ids[i]); 885 if (wp_sp) 886 { 887 wp_sp->SetCondition(m_options.m_condition.c_str()); 888 ++count; 889 } 890 } 891 result.AppendMessageWithFormat("%d watchpoints modified.\n",count); 892 result.SetStatus (eReturnStatusSuccessFinishNoResult); 893 } 894 895 return result.Succeeded(); 896 } 897 898 private: 899 CommandOptions m_options; 900 }; 901 902 #pragma mark Modify::CommandOptions 903 OptionDefinition 904 CommandObjectWatchpointModify::CommandOptions::g_option_table[] = 905 { 906 { LLDB_OPT_SET_ALL, false, "condition", 'c', required_argument, NULL, 0, eArgTypeExpression, "The watchpoint stops only if this condition expression evaluates to true."}, 907 { 0, false, NULL, 0 , 0, NULL, 0, eArgTypeNone, NULL } 908 }; 909 910 //------------------------------------------------------------------------- 911 // CommandObjectWatchpointSetVariable 912 //------------------------------------------------------------------------- 913 #pragma mark SetVariable 914 915 class CommandObjectWatchpointSetVariable : public CommandObjectParsed 916 { 917 public: 918 919 CommandObjectWatchpointSetVariable (CommandInterpreter &interpreter) : 920 CommandObjectParsed (interpreter, 921 "watchpoint set variable", 922 "Set a watchpoint on a variable. " 923 "Use the '-w' option to specify the type of watchpoint and " 924 "the '-x' option to specify the byte size to watch for. " 925 "If no '-w' option is specified, it defaults to write. " 926 "If no '-x' option is specified, it defaults to the variable's " 927 "byte size. " 928 "Note that there are limited hardware resources for watchpoints. " 929 "If watchpoint setting fails, consider disable/delete existing ones " 930 "to free up resources.", 931 NULL, 932 eFlagRequiresFrame | 933 eFlagTryTargetAPILock | 934 eFlagProcessMustBeLaunched | 935 eFlagProcessMustBePaused ), 936 m_option_group (interpreter), 937 m_option_watchpoint () 938 { 939 SetHelpLong( 940 "Examples: \n\ 941 \n\ 942 watchpoint set variable -w read_wriate my_global_var \n\ 943 # Watch my_global_var for read/write access, with the region to watch corresponding to the byte size of the data type.\n"); 944 945 CommandArgumentEntry arg; 946 CommandArgumentData var_name_arg; 947 948 // Define the only variant of this arg. 949 var_name_arg.arg_type = eArgTypeVarName; 950 var_name_arg.arg_repetition = eArgRepeatPlain; 951 952 // Push the variant into the argument entry. 953 arg.push_back (var_name_arg); 954 955 // Push the data for the only argument into the m_arguments vector. 956 m_arguments.push_back (arg); 957 958 // Absorb the '-w' and '-x' options into our option group. 959 m_option_group.Append (&m_option_watchpoint, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1); 960 m_option_group.Finalize(); 961 } 962 963 virtual 964 ~CommandObjectWatchpointSetVariable () {} 965 966 virtual Options * 967 GetOptions () 968 { 969 return &m_option_group; 970 } 971 972 protected: 973 static size_t GetVariableCallback (void *baton, 974 const char *name, 975 VariableList &variable_list) 976 { 977 Target *target = static_cast<Target *>(baton); 978 if (target) 979 { 980 return target->GetImages().FindGlobalVariables (ConstString(name), 981 true, 982 UINT32_MAX, 983 variable_list); 984 } 985 return 0; 986 } 987 988 virtual bool 989 DoExecute (Args& command, CommandReturnObject &result) 990 { 991 Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get(); 992 StackFrame *frame = m_exe_ctx.GetFramePtr(); 993 994 // If no argument is present, issue an error message. There's no way to set a watchpoint. 995 if (command.GetArgumentCount() <= 0) 996 { 997 result.GetErrorStream().Printf("error: required argument missing; specify your program variable to watch for\n"); 998 result.SetStatus(eReturnStatusFailed); 999 return false; 1000 } 1001 1002 // If no '-w' is specified, default to '-w write'. 1003 if (!m_option_watchpoint.watch_type_specified) 1004 { 1005 m_option_watchpoint.watch_type = OptionGroupWatchpoint::eWatchWrite; 1006 } 1007 1008 // We passed the sanity check for the command. 1009 // Proceed to set the watchpoint now. 1010 lldb::addr_t addr = 0; 1011 size_t size = 0; 1012 1013 VariableSP var_sp; 1014 ValueObjectSP valobj_sp; 1015 Stream &output_stream = result.GetOutputStream(); 1016 1017 // A simple watch variable gesture allows only one argument. 1018 if (command.GetArgumentCount() != 1) 1019 { 1020 result.GetErrorStream().Printf("error: specify exactly one variable to watch for\n"); 1021 result.SetStatus(eReturnStatusFailed); 1022 return false; 1023 } 1024 1025 // Things have checked out ok... 1026 Error error; 1027 uint32_t expr_path_options = StackFrame::eExpressionPathOptionCheckPtrVsMember | 1028 StackFrame::eExpressionPathOptionsAllowDirectIVarAccess; 1029 valobj_sp = frame->GetValueForVariableExpressionPath (command.GetArgumentAtIndex(0), 1030 eNoDynamicValues, 1031 expr_path_options, 1032 var_sp, 1033 error); 1034 1035 if (!valobj_sp) 1036 { 1037 // Not in the frame; let's check the globals. 1038 1039 VariableList variable_list; 1040 ValueObjectList valobj_list; 1041 1042 Error error (Variable::GetValuesForVariableExpressionPath (command.GetArgumentAtIndex(0), 1043 m_exe_ctx.GetBestExecutionContextScope(), 1044 GetVariableCallback, 1045 target, 1046 variable_list, 1047 valobj_list)); 1048 1049 if (valobj_list.GetSize()) 1050 valobj_sp = valobj_list.GetValueObjectAtIndex(0); 1051 } 1052 1053 ClangASTType clang_type; 1054 1055 if (valobj_sp) 1056 { 1057 AddressType addr_type; 1058 addr = valobj_sp->GetAddressOf(false, &addr_type); 1059 if (addr_type == eAddressTypeLoad) 1060 { 1061 // We're in business. 1062 // Find out the size of this variable. 1063 size = m_option_watchpoint.watch_size == 0 ? valobj_sp->GetByteSize() 1064 : m_option_watchpoint.watch_size; 1065 } 1066 clang_type = valobj_sp->GetClangType(); 1067 } 1068 else 1069 { 1070 const char *error_cstr = error.AsCString(NULL); 1071 if (error_cstr) 1072 result.GetErrorStream().Printf("error: %s\n", error_cstr); 1073 else 1074 result.GetErrorStream().Printf ("error: unable to find any variable expression path that matches '%s'\n", 1075 command.GetArgumentAtIndex(0)); 1076 return false; 1077 } 1078 1079 // Now it's time to create the watchpoint. 1080 uint32_t watch_type = m_option_watchpoint.watch_type; 1081 1082 error.Clear(); 1083 Watchpoint *wp = target->CreateWatchpoint(addr, size, &clang_type, watch_type, error).get(); 1084 if (wp) 1085 { 1086 wp->SetWatchSpec(command.GetArgumentAtIndex(0)); 1087 wp->SetWatchVariable(true); 1088 if (var_sp && var_sp->GetDeclaration().GetFile()) 1089 { 1090 StreamString ss; 1091 // True to show fullpath for declaration file. 1092 var_sp->GetDeclaration().DumpStopContext(&ss, true); 1093 wp->SetDeclInfo(ss.GetString()); 1094 } 1095 output_stream.Printf("Watchpoint created: "); 1096 wp->GetDescription(&output_stream, lldb::eDescriptionLevelFull); 1097 output_stream.EOL(); 1098 result.SetStatus(eReturnStatusSuccessFinishResult); 1099 } 1100 else 1101 { 1102 result.AppendErrorWithFormat("Watchpoint creation failed (addr=0x%" PRIx64 ", size=%lu, variable expression='%s').\n", 1103 addr, size, command.GetArgumentAtIndex(0)); 1104 if (error.AsCString(NULL)) 1105 result.AppendError(error.AsCString()); 1106 result.SetStatus(eReturnStatusFailed); 1107 } 1108 1109 return result.Succeeded(); 1110 } 1111 1112 private: 1113 OptionGroupOptions m_option_group; 1114 OptionGroupWatchpoint m_option_watchpoint; 1115 }; 1116 1117 //------------------------------------------------------------------------- 1118 // CommandObjectWatchpointSetExpression 1119 //------------------------------------------------------------------------- 1120 #pragma mark Set 1121 1122 class CommandObjectWatchpointSetExpression : public CommandObjectRaw 1123 { 1124 public: 1125 1126 CommandObjectWatchpointSetExpression (CommandInterpreter &interpreter) : 1127 CommandObjectRaw (interpreter, 1128 "watchpoint set expression", 1129 "Set a watchpoint on an address by supplying an expression. " 1130 "Use the '-w' option to specify the type of watchpoint and " 1131 "the '-x' option to specify the byte size to watch for. " 1132 "If no '-w' option is specified, it defaults to write. " 1133 "If no '-x' option is specified, it defaults to the target's " 1134 "pointer byte size. " 1135 "Note that there are limited hardware resources for watchpoints. " 1136 "If watchpoint setting fails, consider disable/delete existing ones " 1137 "to free up resources.", 1138 NULL, 1139 eFlagRequiresFrame | 1140 eFlagTryTargetAPILock | 1141 eFlagProcessMustBeLaunched | 1142 eFlagProcessMustBePaused ), 1143 m_option_group (interpreter), 1144 m_option_watchpoint () 1145 { 1146 SetHelpLong( 1147 "Examples: \n\ 1148 \n\ 1149 watchpoint set expression -w write -x 1 -- foo + 32\n\ 1150 # Watch write access for the 1-byte region pointed to by the address 'foo + 32'.\n"); 1151 1152 CommandArgumentEntry arg; 1153 CommandArgumentData expression_arg; 1154 1155 // Define the only variant of this arg. 1156 expression_arg.arg_type = eArgTypeExpression; 1157 expression_arg.arg_repetition = eArgRepeatPlain; 1158 1159 // Push the only variant into the argument entry. 1160 arg.push_back (expression_arg); 1161 1162 // Push the data for the only argument into the m_arguments vector. 1163 m_arguments.push_back (arg); 1164 1165 // Absorb the '-w' and '-x' options into our option group. 1166 m_option_group.Append (&m_option_watchpoint, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1); 1167 m_option_group.Finalize(); 1168 } 1169 1170 1171 virtual 1172 ~CommandObjectWatchpointSetExpression () {} 1173 1174 // Overrides base class's behavior where WantsCompletion = !WantsRawCommandString. 1175 virtual bool 1176 WantsCompletion() { return true; } 1177 1178 virtual Options * 1179 GetOptions () 1180 { 1181 return &m_option_group; 1182 } 1183 1184 protected: 1185 virtual bool 1186 DoExecute (const char *raw_command, CommandReturnObject &result) 1187 { 1188 m_option_group.NotifyOptionParsingStarting(); // This is a raw command, so notify the option group 1189 1190 Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get(); 1191 StackFrame *frame = m_exe_ctx.GetFramePtr(); 1192 1193 Args command(raw_command); 1194 const char *expr = NULL; 1195 if (raw_command[0] == '-') 1196 { 1197 // We have some options and these options MUST end with --. 1198 const char *end_options = NULL; 1199 const char *s = raw_command; 1200 while (s && s[0]) 1201 { 1202 end_options = ::strstr (s, "--"); 1203 if (end_options) 1204 { 1205 end_options += 2; // Get past the "--" 1206 if (::isspace (end_options[0])) 1207 { 1208 expr = end_options; 1209 while (::isspace (*expr)) 1210 ++expr; 1211 break; 1212 } 1213 } 1214 s = end_options; 1215 } 1216 1217 if (end_options) 1218 { 1219 Args args (raw_command, end_options - raw_command); 1220 if (!ParseOptions (args, result)) 1221 return false; 1222 1223 Error error (m_option_group.NotifyOptionParsingFinished()); 1224 if (error.Fail()) 1225 { 1226 result.AppendError (error.AsCString()); 1227 result.SetStatus (eReturnStatusFailed); 1228 return false; 1229 } 1230 } 1231 } 1232 1233 if (expr == NULL) 1234 expr = raw_command; 1235 1236 // If no argument is present, issue an error message. There's no way to set a watchpoint. 1237 if (command.GetArgumentCount() == 0) 1238 { 1239 result.GetErrorStream().Printf("error: required argument missing; specify an expression to evaulate into the address to watch for\n"); 1240 result.SetStatus(eReturnStatusFailed); 1241 return false; 1242 } 1243 1244 // If no '-w' is specified, default to '-w write'. 1245 if (!m_option_watchpoint.watch_type_specified) 1246 { 1247 m_option_watchpoint.watch_type = OptionGroupWatchpoint::eWatchWrite; 1248 } 1249 1250 // We passed the sanity check for the command. 1251 // Proceed to set the watchpoint now. 1252 lldb::addr_t addr = 0; 1253 size_t size = 0; 1254 1255 ValueObjectSP valobj_sp; 1256 1257 // Use expression evaluation to arrive at the address to watch. 1258 EvaluateExpressionOptions options; 1259 options.SetCoerceToId(false) 1260 .SetUnwindOnError(true) 1261 .SetKeepInMemory(false) 1262 .SetRunOthers(true) 1263 .SetTimeoutUsec(0); 1264 1265 ExecutionResults expr_result = target->EvaluateExpression (expr, 1266 frame, 1267 valobj_sp, 1268 options); 1269 if (expr_result != eExecutionCompleted) 1270 { 1271 result.GetErrorStream().Printf("error: expression evaluation of address to watch failed\n"); 1272 result.GetErrorStream().Printf("expression evaluated: %s\n", expr); 1273 result.SetStatus(eReturnStatusFailed); 1274 return false; 1275 } 1276 1277 // Get the address to watch. 1278 bool success = false; 1279 addr = valobj_sp->GetValueAsUnsigned(0, &success); 1280 if (!success) 1281 { 1282 result.GetErrorStream().Printf("error: expression did not evaluate to an address\n"); 1283 result.SetStatus(eReturnStatusFailed); 1284 return false; 1285 } 1286 1287 if (m_option_watchpoint.watch_size != 0) 1288 size = m_option_watchpoint.watch_size; 1289 else 1290 size = target->GetArchitecture().GetAddressByteSize(); 1291 1292 // Now it's time to create the watchpoint. 1293 uint32_t watch_type = m_option_watchpoint.watch_type; 1294 1295 // Fetch the type from the value object, the type of the watched object is the pointee type 1296 /// of the expression, so convert to that if we found a valid type. 1297 ClangASTType clang_type(valobj_sp->GetClangType()); 1298 1299 Error error; 1300 Watchpoint *wp = target->CreateWatchpoint(addr, size, &clang_type, watch_type, error).get(); 1301 if (wp) 1302 { 1303 Stream &output_stream = result.GetOutputStream(); 1304 output_stream.Printf("Watchpoint created: "); 1305 wp->GetDescription(&output_stream, lldb::eDescriptionLevelFull); 1306 output_stream.EOL(); 1307 result.SetStatus(eReturnStatusSuccessFinishResult); 1308 } 1309 else 1310 { 1311 result.AppendErrorWithFormat("Watchpoint creation failed (addr=0x%" PRIx64 ", size=%lu).\n", 1312 addr, size); 1313 if (error.AsCString(NULL)) 1314 result.AppendError(error.AsCString()); 1315 result.SetStatus(eReturnStatusFailed); 1316 } 1317 1318 return result.Succeeded(); 1319 } 1320 1321 private: 1322 OptionGroupOptions m_option_group; 1323 OptionGroupWatchpoint m_option_watchpoint; 1324 }; 1325 1326 //------------------------------------------------------------------------- 1327 // CommandObjectWatchpointSet 1328 //------------------------------------------------------------------------- 1329 #pragma mark Set 1330 1331 class CommandObjectWatchpointSet : public CommandObjectMultiword 1332 { 1333 public: 1334 1335 CommandObjectWatchpointSet (CommandInterpreter &interpreter) : 1336 CommandObjectMultiword (interpreter, 1337 "watchpoint set", 1338 "A set of commands for setting a watchpoint.", 1339 "watchpoint set <subcommand> [<subcommand-options>]") 1340 { 1341 1342 LoadSubCommand ("variable", CommandObjectSP (new CommandObjectWatchpointSetVariable (interpreter))); 1343 LoadSubCommand ("expression", CommandObjectSP (new CommandObjectWatchpointSetExpression (interpreter))); 1344 } 1345 1346 1347 virtual 1348 ~CommandObjectWatchpointSet () {} 1349 1350 }; 1351 1352 //------------------------------------------------------------------------- 1353 // CommandObjectMultiwordWatchpoint 1354 //------------------------------------------------------------------------- 1355 #pragma mark MultiwordWatchpoint 1356 1357 CommandObjectMultiwordWatchpoint::CommandObjectMultiwordWatchpoint(CommandInterpreter &interpreter) : 1358 CommandObjectMultiword (interpreter, 1359 "watchpoint", 1360 "A set of commands for operating on watchpoints.", 1361 "watchpoint <command> [<command-options>]") 1362 { 1363 CommandObjectSP list_command_object (new CommandObjectWatchpointList (interpreter)); 1364 CommandObjectSP enable_command_object (new CommandObjectWatchpointEnable (interpreter)); 1365 CommandObjectSP disable_command_object (new CommandObjectWatchpointDisable (interpreter)); 1366 CommandObjectSP delete_command_object (new CommandObjectWatchpointDelete (interpreter)); 1367 CommandObjectSP ignore_command_object (new CommandObjectWatchpointIgnore (interpreter)); 1368 CommandObjectSP command_command_object (new CommandObjectWatchpointCommand (interpreter)); 1369 CommandObjectSP modify_command_object (new CommandObjectWatchpointModify (interpreter)); 1370 CommandObjectSP set_command_object (new CommandObjectWatchpointSet (interpreter)); 1371 1372 list_command_object->SetCommandName ("watchpoint list"); 1373 enable_command_object->SetCommandName("watchpoint enable"); 1374 disable_command_object->SetCommandName("watchpoint disable"); 1375 delete_command_object->SetCommandName("watchpoint delete"); 1376 ignore_command_object->SetCommandName("watchpoint ignore"); 1377 command_command_object->SetCommandName ("watchpoint command"); 1378 modify_command_object->SetCommandName("watchpoint modify"); 1379 set_command_object->SetCommandName("watchpoint set"); 1380 1381 LoadSubCommand ("list", list_command_object); 1382 LoadSubCommand ("enable", enable_command_object); 1383 LoadSubCommand ("disable", disable_command_object); 1384 LoadSubCommand ("delete", delete_command_object); 1385 LoadSubCommand ("ignore", ignore_command_object); 1386 LoadSubCommand ("command", command_command_object); 1387 LoadSubCommand ("modify", modify_command_object); 1388 LoadSubCommand ("set", set_command_object); 1389 } 1390 1391 CommandObjectMultiwordWatchpoint::~CommandObjectMultiwordWatchpoint() 1392 { 1393 } 1394 1395
