1 //===-- CommandObjectSource.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 "CommandObjectSource.h" 13 14 // C Includes 15 // C++ Includes 16 // Other libraries and framework includes 17 // Project includes 18 #include "lldb/Interpreter/Args.h" 19 #include "lldb/Core/Debugger.h" 20 #include "lldb/Core/FileLineResolver.h" 21 #include "lldb/Core/Module.h" 22 #include "lldb/Core/ModuleSpec.h" 23 #include "lldb/Core/SourceManager.h" 24 #include "lldb/Interpreter/CommandInterpreter.h" 25 #include "lldb/Interpreter/CommandReturnObject.h" 26 #include "lldb/Host/FileSpec.h" 27 #include "lldb/Symbol/CompileUnit.h" 28 #include "lldb/Symbol/Function.h" 29 #include "lldb/Symbol/Symbol.h" 30 #include "lldb/Target/Process.h" 31 #include "lldb/Target/TargetList.h" 32 #include "lldb/Interpreter/CommandCompletions.h" 33 #include "lldb/Interpreter/Options.h" 34 35 using namespace lldb; 36 using namespace lldb_private; 37 38 //------------------------------------------------------------------------- 39 // CommandObjectSourceInfo 40 //------------------------------------------------------------------------- 41 42 class CommandObjectSourceInfo : public CommandObjectParsed 43 { 44 45 class CommandOptions : public Options 46 { 47 public: 48 CommandOptions (CommandInterpreter &interpreter) : 49 Options(interpreter) 50 { 51 } 52 53 ~CommandOptions () 54 { 55 } 56 57 Error 58 SetOptionValue (uint32_t option_idx, const char *option_arg) 59 { 60 Error error; 61 const int short_option = g_option_table[option_idx].short_option; 62 switch (short_option) 63 { 64 case 'l': 65 start_line = Args::StringToUInt32 (option_arg, 0); 66 if (start_line == 0) 67 error.SetErrorStringWithFormat("invalid line number: '%s'", option_arg); 68 break; 69 70 case 'f': 71 file_name = option_arg; 72 break; 73 74 default: 75 error.SetErrorStringWithFormat("unrecognized short option '%c'", short_option); 76 break; 77 } 78 79 return error; 80 } 81 82 void 83 OptionParsingStarting () 84 { 85 file_spec.Clear(); 86 file_name.clear(); 87 start_line = 0; 88 } 89 90 const OptionDefinition* 91 GetDefinitions () 92 { 93 return g_option_table; 94 } 95 static OptionDefinition g_option_table[]; 96 97 // Instance variables to hold the values for command options. 98 FileSpec file_spec; 99 std::string file_name; 100 uint32_t start_line; 101 102 }; 103 104 public: 105 CommandObjectSourceInfo(CommandInterpreter &interpreter) : 106 CommandObjectParsed (interpreter, 107 "source info", 108 "Display information about the source lines from the current executable's debug info.", 109 "source info [<cmd-options>]"), 110 m_options (interpreter) 111 { 112 } 113 114 ~CommandObjectSourceInfo () 115 { 116 } 117 118 119 Options * 120 GetOptions () 121 { 122 return &m_options; 123 } 124 125 protected: 126 bool 127 DoExecute (Args& command, CommandReturnObject &result) 128 { 129 result.AppendError ("Not yet implemented"); 130 result.SetStatus (eReturnStatusFailed); 131 return false; 132 } 133 134 CommandOptions m_options; 135 }; 136 137 OptionDefinition 138 CommandObjectSourceInfo::CommandOptions::g_option_table[] = 139 { 140 { LLDB_OPT_SET_1, false, "line", 'l', required_argument, NULL, 0, eArgTypeLineNum, "The line number at which to start the display source."}, 141 { LLDB_OPT_SET_1, false, "file", 'f', required_argument, NULL, CommandCompletions::eSourceFileCompletion, eArgTypeFilename, "The file from which to display source."}, 142 { 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL } 143 }; 144 145 #pragma mark CommandObjectSourceList 146 //------------------------------------------------------------------------- 147 // CommandObjectSourceList 148 //------------------------------------------------------------------------- 149 150 class CommandObjectSourceList : public CommandObjectParsed 151 { 152 153 class CommandOptions : public Options 154 { 155 public: 156 CommandOptions (CommandInterpreter &interpreter) : 157 Options(interpreter) 158 { 159 } 160 161 ~CommandOptions () 162 { 163 } 164 165 Error 166 SetOptionValue (uint32_t option_idx, const char *option_arg) 167 { 168 Error error; 169 const int short_option = g_option_table[option_idx].short_option; 170 switch (short_option) 171 { 172 case 'l': 173 start_line = Args::StringToUInt32 (option_arg, 0); 174 if (start_line == 0) 175 error.SetErrorStringWithFormat("invalid line number: '%s'", option_arg); 176 break; 177 178 case 'c': 179 num_lines = Args::StringToUInt32 (option_arg, 0); 180 if (num_lines == 0) 181 error.SetErrorStringWithFormat("invalid line count: '%s'", option_arg); 182 break; 183 184 case 'f': 185 file_name = option_arg; 186 break; 187 188 case 'n': 189 symbol_name = option_arg; 190 break; 191 192 case 'a': 193 { 194 ExecutionContext exe_ctx (m_interpreter.GetExecutionContext()); 195 address = Args::StringToAddress(&exe_ctx, option_arg, LLDB_INVALID_ADDRESS, &error); 196 } 197 break; 198 case 's': 199 modules.push_back (std::string (option_arg)); 200 break; 201 202 case 'b': 203 show_bp_locs = true; 204 break; 205 case 'r': 206 reverse = true; 207 break; 208 default: 209 error.SetErrorStringWithFormat("unrecognized short option '%c'", short_option); 210 break; 211 } 212 213 return error; 214 } 215 216 void 217 OptionParsingStarting () 218 { 219 file_spec.Clear(); 220 file_name.clear(); 221 symbol_name.clear(); 222 address = LLDB_INVALID_ADDRESS; 223 start_line = 0; 224 num_lines = 0; 225 show_bp_locs = false; 226 reverse = false; 227 modules.clear(); 228 } 229 230 const OptionDefinition* 231 GetDefinitions () 232 { 233 return g_option_table; 234 } 235 static OptionDefinition g_option_table[]; 236 237 // Instance variables to hold the values for command options. 238 FileSpec file_spec; 239 std::string file_name; 240 std::string symbol_name; 241 lldb::addr_t address; 242 uint32_t start_line; 243 uint32_t num_lines; 244 STLStringArray modules; 245 bool show_bp_locs; 246 bool reverse; 247 }; 248 249 public: 250 CommandObjectSourceList(CommandInterpreter &interpreter) : 251 CommandObjectParsed (interpreter, 252 "source list", 253 "Display source code (as specified) based on the current executable's debug info.", 254 NULL, 255 eFlagRequiresTarget), 256 m_options (interpreter) 257 { 258 } 259 260 ~CommandObjectSourceList () 261 { 262 } 263 264 265 Options * 266 GetOptions () 267 { 268 return &m_options; 269 } 270 271 virtual const char * 272 GetRepeatCommand (Args ¤t_command_args, uint32_t index) 273 { 274 // This is kind of gross, but the command hasn't been parsed yet so we can't look at the option 275 // values for this invocation... I have to scan the arguments directly. 276 size_t num_args = current_command_args.GetArgumentCount(); 277 bool is_reverse = false; 278 for (size_t i = 0 ; i < num_args; i++) 279 { 280 const char *arg = current_command_args.GetArgumentAtIndex(i); 281 if (arg && (strcmp(arg, "-r") == 0 || strcmp(arg, "--reverse") == 0)) 282 { 283 is_reverse = true; 284 } 285 } 286 if (is_reverse) 287 { 288 if (m_reverse_name.empty()) 289 { 290 m_reverse_name = m_cmd_name; 291 m_reverse_name.append (" -r"); 292 } 293 return m_reverse_name.c_str(); 294 } 295 else 296 return m_cmd_name.c_str(); 297 } 298 299 protected: 300 301 struct SourceInfo 302 { 303 ConstString function; 304 LineEntry line_entry; 305 306 SourceInfo (const ConstString &name, const LineEntry &line_entry) : 307 function(name), 308 line_entry(line_entry) 309 { 310 } 311 312 SourceInfo () : 313 function(), 314 line_entry() 315 { 316 } 317 318 bool 319 IsValid () const 320 { 321 return (bool)function && line_entry.IsValid(); 322 } 323 324 bool 325 operator == (const SourceInfo &rhs) const 326 { 327 return function == rhs.function && 328 line_entry.file == rhs.line_entry.file && 329 line_entry.line == rhs.line_entry.line; 330 } 331 332 bool 333 operator != (const SourceInfo &rhs) const 334 { 335 return function != rhs.function || 336 line_entry.file != rhs.line_entry.file || 337 line_entry.line != rhs.line_entry.line; 338 } 339 340 bool 341 operator < (const SourceInfo &rhs) const 342 { 343 if (function.GetCString() < rhs.function.GetCString()) 344 return true; 345 if (line_entry.file.GetDirectory().GetCString() < rhs.line_entry.file.GetDirectory().GetCString()) 346 return true; 347 if (line_entry.file.GetFilename().GetCString() < rhs.line_entry.file.GetFilename().GetCString()) 348 return true; 349 if (line_entry.line < rhs.line_entry.line) 350 return true; 351 return false; 352 } 353 }; 354 355 size_t 356 DisplayFunctionSource (const SymbolContext &sc, 357 SourceInfo &source_info, 358 CommandReturnObject &result) 359 { 360 if (!source_info.IsValid()) 361 { 362 source_info.function = sc.GetFunctionName(); 363 source_info.line_entry = sc.GetFunctionStartLineEntry(); 364 } 365 366 if (sc.function) 367 { 368 Target *target = m_exe_ctx.GetTargetPtr(); 369 370 FileSpec start_file; 371 uint32_t start_line; 372 uint32_t end_line; 373 FileSpec end_file; 374 375 if (sc.block == NULL) 376 { 377 // Not an inlined function 378 sc.function->GetStartLineSourceInfo (start_file, start_line); 379 if (start_line == 0) 380 { 381 result.AppendErrorWithFormat("Could not find line information for start of function: \"%s\".\n", source_info.function.GetCString()); 382 result.SetStatus (eReturnStatusFailed); 383 return 0; 384 } 385 sc.function->GetEndLineSourceInfo (end_file, end_line); 386 } 387 else 388 { 389 // We have an inlined function 390 start_file = source_info.line_entry.file; 391 start_line = source_info.line_entry.line; 392 end_line = start_line + m_options.num_lines; 393 } 394 395 // This is a little hacky, but the first line table entry for a function points to the "{" that 396 // starts the function block. It would be nice to actually get the function 397 // declaration in there too. So back up a bit, but not further than what you're going to display. 398 uint32_t extra_lines; 399 if (m_options.num_lines >= 10) 400 extra_lines = 5; 401 else 402 extra_lines = m_options.num_lines/2; 403 uint32_t line_no; 404 if (start_line <= extra_lines) 405 line_no = 1; 406 else 407 line_no = start_line - extra_lines; 408 409 // For fun, if the function is shorter than the number of lines we're supposed to display, 410 // only display the function... 411 if (end_line != 0) 412 { 413 if (m_options.num_lines > end_line - line_no) 414 m_options.num_lines = end_line - line_no + extra_lines; 415 } 416 417 m_breakpoint_locations.Clear(); 418 419 if (m_options.show_bp_locs) 420 { 421 const bool show_inlines = true; 422 m_breakpoint_locations.Reset (start_file, 0, show_inlines); 423 SearchFilter target_search_filter (m_exe_ctx.GetTargetSP()); 424 target_search_filter.Search (m_breakpoint_locations); 425 } 426 427 result.AppendMessageWithFormat("File: %s\n", start_file.GetPath().c_str()); 428 return target->GetSourceManager().DisplaySourceLinesWithLineNumbers (start_file, 429 line_no, 430 0, 431 m_options.num_lines, 432 "", 433 &result.GetOutputStream(), 434 GetBreakpointLocations ()); 435 } 436 else 437 { 438 result.AppendErrorWithFormat("Could not find function info for: \"%s\".\n", m_options.symbol_name.c_str()); 439 } 440 return 0; 441 } 442 443 // From Jim: The FindMatchingFunctions / FindMatchingFunctionSymbols functions 444 // "take a possibly empty vector of strings which are names of modules, and 445 // run the two search functions on the subset of the full module list that 446 // matches the strings in the input vector". If we wanted to put these somewhere, 447 // there should probably be a module-filter-list that can be passed to the 448 // various ModuleList::Find* calls, which would either be a vector of string 449 // names or a ModuleSpecList. 450 size_t FindMatchingFunctions (Target *target, const ConstString &name, SymbolContextList& sc_list) 451 { 452 // Displaying the source for a symbol: 453 bool include_inlines = true; 454 bool append = true; 455 bool include_symbols = false; 456 size_t num_matches = 0; 457 458 if (m_options.num_lines == 0) 459 m_options.num_lines = 10; 460 461 const size_t num_modules = m_options.modules.size(); 462 if (num_modules > 0) 463 { 464 ModuleList matching_modules; 465 for (size_t i = 0; i < num_modules; ++i) 466 { 467 FileSpec module_file_spec(m_options.modules[i].c_str(), false); 468 if (module_file_spec) 469 { 470 ModuleSpec module_spec (module_file_spec); 471 matching_modules.Clear(); 472 target->GetImages().FindModules (module_spec, matching_modules); 473 num_matches += matching_modules.FindFunctions (name, eFunctionNameTypeAuto, include_symbols, include_inlines, append, sc_list); 474 } 475 } 476 } 477 else 478 { 479 num_matches = target->GetImages().FindFunctions (name, eFunctionNameTypeAuto, include_symbols, include_inlines, append, sc_list); 480 } 481 return num_matches; 482 } 483 484 size_t FindMatchingFunctionSymbols (Target *target, const ConstString &name, SymbolContextList& sc_list) 485 { 486 size_t num_matches = 0; 487 const size_t num_modules = m_options.modules.size(); 488 if (num_modules > 0) 489 { 490 ModuleList matching_modules; 491 for (size_t i = 0; i < num_modules; ++i) 492 { 493 FileSpec module_file_spec(m_options.modules[i].c_str(), false); 494 if (module_file_spec) 495 { 496 ModuleSpec module_spec (module_file_spec); 497 matching_modules.Clear(); 498 target->GetImages().FindModules (module_spec, matching_modules); 499 num_matches += matching_modules.FindFunctionSymbols (name, eFunctionNameTypeAuto, sc_list); 500 } 501 } 502 } 503 else 504 { 505 num_matches = target->GetImages().FindFunctionSymbols (name, eFunctionNameTypeAuto, sc_list); 506 } 507 return num_matches; 508 } 509 510 bool 511 DoExecute (Args& command, CommandReturnObject &result) 512 { 513 const size_t argc = command.GetArgumentCount(); 514 515 if (argc != 0) 516 { 517 result.AppendErrorWithFormat("'%s' takes no arguments, only flags.\n", GetCommandName()); 518 result.SetStatus (eReturnStatusFailed); 519 return false; 520 } 521 522 Target *target = m_exe_ctx.GetTargetPtr(); 523 524 if (!m_options.symbol_name.empty()) 525 { 526 SymbolContextList sc_list; 527 ConstString name(m_options.symbol_name.c_str()); 528 529 // Displaying the source for a symbol. Search for function named name. 530 size_t num_matches = FindMatchingFunctions (target, name, sc_list); 531 if (!num_matches) 532 { 533 // If we didn't find any functions with that name, try searching for symbols 534 // that line up exactly with function addresses. 535 SymbolContextList sc_list_symbols; 536 size_t num_symbol_matches = FindMatchingFunctionSymbols (target, name, sc_list_symbols); 537 for (size_t i = 0; i < num_symbol_matches; i++) 538 { 539 SymbolContext sc; 540 sc_list_symbols.GetContextAtIndex (i, sc); 541 if (sc.symbol) 542 { 543 const Address &base_address = sc.symbol->GetAddress(); 544 Function *function = base_address.CalculateSymbolContextFunction(); 545 if (function) 546 { 547 sc_list.Append (SymbolContext(function)); 548 num_matches++; 549 break; 550 } 551 } 552 } 553 } 554 555 if (num_matches == 0) 556 { 557 result.AppendErrorWithFormat("Could not find function named: \"%s\".\n", m_options.symbol_name.c_str()); 558 result.SetStatus (eReturnStatusFailed); 559 return false; 560 } 561 562 if (num_matches > 1) 563 { 564 std::set<SourceInfo> source_match_set; 565 566 bool displayed_something = false; 567 for (size_t i = 0; i < num_matches; i++) 568 { 569 SymbolContext sc; 570 sc_list.GetContextAtIndex (i, sc); 571 SourceInfo source_info (sc.GetFunctionName(), 572 sc.GetFunctionStartLineEntry()); 573 574 if (source_info.IsValid()) 575 { 576 if (source_match_set.find(source_info) == source_match_set.end()) 577 { 578 source_match_set.insert(source_info); 579 if (DisplayFunctionSource (sc, source_info, result)) 580 displayed_something = true; 581 } 582 } 583 } 584 585 if (displayed_something) 586 result.SetStatus (eReturnStatusSuccessFinishResult); 587 else 588 result.SetStatus (eReturnStatusFailed); 589 } 590 else 591 { 592 SymbolContext sc; 593 sc_list.GetContextAtIndex (0, sc); 594 SourceInfo source_info; 595 596 if (DisplayFunctionSource (sc, source_info, result)) 597 { 598 result.SetStatus (eReturnStatusSuccessFinishResult); 599 } 600 else 601 { 602 result.SetStatus (eReturnStatusFailed); 603 } 604 } 605 return result.Succeeded(); 606 } 607 else if (m_options.address != LLDB_INVALID_ADDRESS) 608 { 609 Address so_addr; 610 StreamString error_strm; 611 SymbolContextList sc_list; 612 613 if (target->GetSectionLoadList().IsEmpty()) 614 { 615 // The target isn't loaded yet, we need to lookup the file address 616 // in all modules 617 const ModuleList &module_list = target->GetImages(); 618 const size_t num_modules = module_list.GetSize(); 619 for (size_t i=0; i<num_modules; ++i) 620 { 621 ModuleSP module_sp (module_list.GetModuleAtIndex(i)); 622 if (module_sp && module_sp->ResolveFileAddress(m_options.address, so_addr)) 623 { 624 SymbolContext sc; 625 sc.Clear(true); 626 if (module_sp->ResolveSymbolContextForAddress (so_addr, eSymbolContextEverything, sc) & eSymbolContextLineEntry) 627 sc_list.Append(sc); 628 } 629 } 630 631 if (sc_list.GetSize() == 0) 632 { 633 result.AppendErrorWithFormat("no modules have source information for file address 0x%" PRIx64 ".\n", 634 m_options.address); 635 result.SetStatus (eReturnStatusFailed); 636 return false; 637 } 638 } 639 else 640 { 641 // The target has some things loaded, resolve this address to a 642 // compile unit + file + line and display 643 if (target->GetSectionLoadList().ResolveLoadAddress (m_options.address, so_addr)) 644 { 645 ModuleSP module_sp (so_addr.GetModule()); 646 if (module_sp) 647 { 648 SymbolContext sc; 649 sc.Clear(true); 650 if (module_sp->ResolveSymbolContextForAddress (so_addr, eSymbolContextEverything, sc) & eSymbolContextLineEntry) 651 { 652 sc_list.Append(sc); 653 } 654 else 655 { 656 so_addr.Dump(&error_strm, NULL, Address::DumpStyleModuleWithFileAddress); 657 result.AppendErrorWithFormat("address resolves to %s, but there is no line table information available for this address.\n", 658 error_strm.GetData()); 659 result.SetStatus (eReturnStatusFailed); 660 return false; 661 } 662 } 663 } 664 665 if (sc_list.GetSize() == 0) 666 { 667 result.AppendErrorWithFormat("no modules contain load address 0x%" PRIx64 ".\n", m_options.address); 668 result.SetStatus (eReturnStatusFailed); 669 return false; 670 } 671 } 672 uint32_t num_matches = sc_list.GetSize(); 673 for (uint32_t i=0; i<num_matches; ++i) 674 { 675 SymbolContext sc; 676 sc_list.GetContextAtIndex(i, sc); 677 if (sc.comp_unit) 678 { 679 if (m_options.show_bp_locs) 680 { 681 m_breakpoint_locations.Clear(); 682 const bool show_inlines = true; 683 m_breakpoint_locations.Reset (*sc.comp_unit, 0, show_inlines); 684 SearchFilter target_search_filter (target->shared_from_this()); 685 target_search_filter.Search (m_breakpoint_locations); 686 } 687 688 bool show_fullpaths = true; 689 bool show_module = true; 690 bool show_inlined_frames = true; 691 sc.DumpStopContext(&result.GetOutputStream(), 692 m_exe_ctx.GetBestExecutionContextScope(), 693 sc.line_entry.range.GetBaseAddress(), 694 show_fullpaths, 695 show_module, 696 show_inlined_frames); 697 result.GetOutputStream().EOL(); 698 699 if (m_options.num_lines == 0) 700 m_options.num_lines = 10; 701 702 size_t lines_to_back_up = m_options.num_lines >= 10 ? 5 : m_options.num_lines/2; 703 704 target->GetSourceManager().DisplaySourceLinesWithLineNumbers (sc.comp_unit, 705 sc.line_entry.line, 706 lines_to_back_up, 707 m_options.num_lines - lines_to_back_up, 708 "->", 709 &result.GetOutputStream(), 710 GetBreakpointLocations ()); 711 result.SetStatus (eReturnStatusSuccessFinishResult); 712 } 713 } 714 } 715 else if (m_options.file_name.empty()) 716 { 717 // Last valid source manager context, or the current frame if no 718 // valid last context in source manager. 719 // One little trick here, if you type the exact same list command twice in a row, it is 720 // more likely because you typed it once, then typed it again 721 if (m_options.start_line == 0) 722 { 723 if (target->GetSourceManager().DisplayMoreWithLineNumbers (&result.GetOutputStream(), 724 m_options.num_lines, 725 m_options.reverse, 726 GetBreakpointLocations ())) 727 { 728 result.SetStatus (eReturnStatusSuccessFinishResult); 729 } 730 } 731 else 732 { 733 if (m_options.num_lines == 0) 734 m_options.num_lines = 10; 735 736 if (m_options.show_bp_locs) 737 { 738 SourceManager::FileSP last_file_sp (target->GetSourceManager().GetLastFile ()); 739 if (last_file_sp) 740 { 741 const bool show_inlines = true; 742 m_breakpoint_locations.Reset (last_file_sp->GetFileSpec(), 0, show_inlines); 743 SearchFilter target_search_filter (target->shared_from_this()); 744 target_search_filter.Search (m_breakpoint_locations); 745 } 746 } 747 else 748 m_breakpoint_locations.Clear(); 749 750 if (target->GetSourceManager().DisplaySourceLinesWithLineNumbersUsingLastFile( 751 m_options.start_line, // Line to display 752 m_options.num_lines, // Lines after line to 753 UINT32_MAX, // Don't mark "line" 754 "", // Don't mark "line" 755 &result.GetOutputStream(), 756 GetBreakpointLocations ())) 757 { 758 result.SetStatus (eReturnStatusSuccessFinishResult); 759 } 760 761 } 762 } 763 else 764 { 765 const char *filename = m_options.file_name.c_str(); 766 767 bool check_inlines = false; 768 SymbolContextList sc_list; 769 size_t num_matches = 0; 770 771 if (m_options.modules.size() > 0) 772 { 773 ModuleList matching_modules; 774 for (size_t i = 0, e = m_options.modules.size(); i < e; ++i) 775 { 776 FileSpec module_file_spec(m_options.modules[i].c_str(), false); 777 if (module_file_spec) 778 { 779 ModuleSpec module_spec (module_file_spec); 780 matching_modules.Clear(); 781 target->GetImages().FindModules (module_spec, matching_modules); 782 num_matches += matching_modules.ResolveSymbolContextForFilePath (filename, 783 0, 784 check_inlines, 785 eSymbolContextModule | eSymbolContextCompUnit, 786 sc_list); 787 } 788 } 789 } 790 else 791 { 792 num_matches = target->GetImages().ResolveSymbolContextForFilePath (filename, 793 0, 794 check_inlines, 795 eSymbolContextModule | eSymbolContextCompUnit, 796 sc_list); 797 } 798 799 if (num_matches == 0) 800 { 801 result.AppendErrorWithFormat("Could not find source file \"%s\".\n", 802 m_options.file_name.c_str()); 803 result.SetStatus (eReturnStatusFailed); 804 return false; 805 } 806 807 if (num_matches > 1) 808 { 809 bool got_multiple = false; 810 FileSpec *test_cu_spec = NULL; 811 812 for (unsigned i = 0; i < num_matches; i++) 813 { 814 SymbolContext sc; 815 sc_list.GetContextAtIndex(i, sc); 816 if (sc.comp_unit) 817 { 818 if (test_cu_spec) 819 { 820 if (test_cu_spec != static_cast<FileSpec *> (sc.comp_unit)) 821 got_multiple = true; 822 break; 823 } 824 else 825 test_cu_spec = sc.comp_unit; 826 } 827 } 828 if (got_multiple) 829 { 830 result.AppendErrorWithFormat("Multiple source files found matching: \"%s.\"\n", 831 m_options.file_name.c_str()); 832 result.SetStatus (eReturnStatusFailed); 833 return false; 834 } 835 } 836 837 SymbolContext sc; 838 if (sc_list.GetContextAtIndex(0, sc)) 839 { 840 if (sc.comp_unit) 841 { 842 if (m_options.show_bp_locs) 843 { 844 const bool show_inlines = true; 845 m_breakpoint_locations.Reset (*sc.comp_unit, 0, show_inlines); 846 SearchFilter target_search_filter (target->shared_from_this()); 847 target_search_filter.Search (m_breakpoint_locations); 848 } 849 else 850 m_breakpoint_locations.Clear(); 851 852 if (m_options.num_lines == 0) 853 m_options.num_lines = 10; 854 855 target->GetSourceManager().DisplaySourceLinesWithLineNumbers (sc.comp_unit, 856 m_options.start_line, 857 0, 858 m_options.num_lines, 859 "", 860 &result.GetOutputStream(), 861 GetBreakpointLocations ()); 862 863 result.SetStatus (eReturnStatusSuccessFinishResult); 864 } 865 else 866 { 867 result.AppendErrorWithFormat("No comp unit found for: \"%s.\"\n", 868 m_options.file_name.c_str()); 869 result.SetStatus (eReturnStatusFailed); 870 return false; 871 } 872 } 873 } 874 return result.Succeeded(); 875 } 876 877 const SymbolContextList * 878 GetBreakpointLocations () 879 { 880 if (m_breakpoint_locations.GetFileLineMatches().GetSize() > 0) 881 return &m_breakpoint_locations.GetFileLineMatches(); 882 return NULL; 883 } 884 CommandOptions m_options; 885 FileLineResolver m_breakpoint_locations; 886 std::string m_reverse_name; 887 888 }; 889 890 OptionDefinition 891 CommandObjectSourceList::CommandOptions::g_option_table[] = 892 { 893 { LLDB_OPT_SET_ALL, false, "count", 'c', required_argument, NULL, 0, eArgTypeCount, "The number of source lines to display."}, 894 { LLDB_OPT_SET_1 | 895 LLDB_OPT_SET_2 , false, "shlib", 's', required_argument, NULL, CommandCompletions::eModuleCompletion, eArgTypeShlibName, "Look up the source file in the given shared library."}, 896 { LLDB_OPT_SET_ALL, false, "show-breakpoints", 'b', no_argument, NULL, 0, eArgTypeNone, "Show the line table locations from the debug information that indicate valid places to set source level breakpoints."}, 897 { LLDB_OPT_SET_1 , false, "file", 'f', required_argument, NULL, CommandCompletions::eSourceFileCompletion, eArgTypeFilename, "The file from which to display source."}, 898 { LLDB_OPT_SET_1 , false, "line", 'l', required_argument, NULL, 0, eArgTypeLineNum, "The line number at which to start the display source."}, 899 { LLDB_OPT_SET_2 , false, "name", 'n', required_argument, NULL, CommandCompletions::eSymbolCompletion, eArgTypeSymbol, "The name of a function whose source to display."}, 900 { LLDB_OPT_SET_3 , false, "address",'a', required_argument, NULL, 0, eArgTypeAddressOrExpression, "Lookup the address and display the source information for the corresponding file and line."}, 901 { LLDB_OPT_SET_4, false, "reverse", 'r', no_argument, NULL, 0, eArgTypeNone, "Reverse the listing to look backwards from the last displayed block of source."}, 902 { 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL } 903 }; 904 905 #pragma mark CommandObjectMultiwordSource 906 907 //------------------------------------------------------------------------- 908 // CommandObjectMultiwordSource 909 //------------------------------------------------------------------------- 910 911 CommandObjectMultiwordSource::CommandObjectMultiwordSource (CommandInterpreter &interpreter) : 912 CommandObjectMultiword (interpreter, 913 "source", 914 "A set of commands for accessing source file information", 915 "source <subcommand> [<subcommand-options>]") 916 { 917 // "source info" isn't implemented yet... 918 //LoadSubCommand ("info", CommandObjectSP (new CommandObjectSourceInfo (interpreter))); 919 LoadSubCommand ("list", CommandObjectSP (new CommandObjectSourceList (interpreter))); 920 } 921 922 CommandObjectMultiwordSource::~CommandObjectMultiwordSource () 923 { 924 } 925 926
