1 //===-- SearchFilter.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 // C Includes 11 // C++ Includes 12 // Other libraries and framework includes 13 // Project includes 14 15 #include "lldb/lldb-private.h" 16 #include "lldb/Core/SearchFilter.h" 17 #include "lldb/Core/Module.h" 18 #include "lldb/Symbol/CompileUnit.h" 19 #include "lldb/Target/Target.h" 20 21 using namespace lldb; 22 using namespace lldb_private; 23 24 //---------------------------------------------------------------------- 25 // SearchFilter constructor 26 //---------------------------------------------------------------------- 27 Searcher::Searcher () 28 { 29 30 } 31 32 Searcher::~Searcher () 33 { 34 35 } 36 37 void 38 Searcher::GetDescription (Stream *s) 39 { 40 } 41 42 //---------------------------------------------------------------------- 43 // SearchFilter constructor 44 //---------------------------------------------------------------------- 45 SearchFilter::SearchFilter(const TargetSP &target_sp) : 46 m_target_sp (target_sp) 47 { 48 } 49 50 //---------------------------------------------------------------------- 51 // SearchFilter copy constructor 52 //---------------------------------------------------------------------- 53 SearchFilter::SearchFilter(const SearchFilter& rhs) : 54 m_target_sp (rhs.m_target_sp) 55 { 56 } 57 58 //---------------------------------------------------------------------- 59 // SearchFilter assignment operator 60 //---------------------------------------------------------------------- 61 const SearchFilter& 62 SearchFilter::operator=(const SearchFilter& rhs) 63 { 64 m_target_sp = rhs.m_target_sp; 65 return *this; 66 } 67 68 //---------------------------------------------------------------------- 69 // Destructor 70 //---------------------------------------------------------------------- 71 SearchFilter::~SearchFilter() 72 { 73 } 74 75 bool 76 SearchFilter::ModulePasses (const FileSpec &spec) 77 { 78 return true; 79 } 80 81 bool 82 SearchFilter::ModulePasses (const ModuleSP &module_sp) 83 { 84 return true; 85 } 86 87 bool 88 SearchFilter::AddressPasses (Address &address) 89 { 90 return true; 91 } 92 93 bool 94 SearchFilter::CompUnitPasses (FileSpec &fileSpec) 95 { 96 return true; 97 } 98 99 bool 100 SearchFilter::CompUnitPasses (CompileUnit &compUnit) 101 { 102 return true; 103 } 104 105 uint32_t 106 SearchFilter::GetFilterRequiredItems() 107 { 108 return (lldb::SymbolContextItem) 0; 109 } 110 111 void 112 SearchFilter::GetDescription (Stream *s) 113 { 114 } 115 116 void 117 SearchFilter::Dump (Stream *s) const 118 { 119 120 } 121 122 //---------------------------------------------------------------------- 123 // UTILITY Functions to help iterate down through the elements of the 124 // SymbolContext. 125 //---------------------------------------------------------------------- 126 127 void 128 SearchFilter::Search (Searcher &searcher) 129 { 130 SymbolContext empty_sc; 131 132 if (!m_target_sp) 133 return; 134 empty_sc.target_sp = m_target_sp; 135 136 if (searcher.GetDepth() == Searcher::eDepthTarget) 137 searcher.SearchCallback (*this, empty_sc, NULL, false); 138 else 139 DoModuleIteration(empty_sc, searcher); 140 } 141 142 void 143 SearchFilter::SearchInModuleList (Searcher &searcher, ModuleList &modules) 144 { 145 SymbolContext empty_sc; 146 147 if (!m_target_sp) 148 return; 149 empty_sc.target_sp = m_target_sp; 150 151 if (searcher.GetDepth() == Searcher::eDepthTarget) 152 searcher.SearchCallback (*this, empty_sc, NULL, false); 153 else 154 { 155 Mutex::Locker modules_locker(modules.GetMutex()); 156 const size_t numModules = modules.GetSize(); 157 158 for (size_t i = 0; i < numModules; i++) 159 { 160 ModuleSP module_sp(modules.GetModuleAtIndexUnlocked(i)); 161 if (ModulePasses(module_sp)) 162 { 163 if (DoModuleIteration(module_sp, searcher) == Searcher::eCallbackReturnStop) 164 return; 165 } 166 } 167 } 168 } 169 170 171 Searcher::CallbackReturn 172 SearchFilter::DoModuleIteration (const lldb::ModuleSP& module_sp, Searcher &searcher) 173 { 174 SymbolContext matchingContext (m_target_sp, module_sp); 175 return DoModuleIteration(matchingContext, searcher); 176 } 177 178 Searcher::CallbackReturn 179 SearchFilter::DoModuleIteration (const SymbolContext &context, Searcher &searcher) 180 { 181 if (searcher.GetDepth () >= Searcher::eDepthModule) 182 { 183 if (context.module_sp) 184 { 185 if (searcher.GetDepth () == Searcher::eDepthModule) 186 { 187 SymbolContext matchingContext(context.module_sp.get()); 188 searcher.SearchCallback (*this, matchingContext, NULL, false); 189 } 190 else 191 { 192 return DoCUIteration(context.module_sp, context, searcher); 193 } 194 } 195 else 196 { 197 const ModuleList &target_images = m_target_sp->GetImages(); 198 Mutex::Locker modules_locker(target_images.GetMutex()); 199 200 size_t n_modules = target_images.GetSize(); 201 for (size_t i = 0; i < n_modules; i++) 202 { 203 // If this is the last level supplied, then call the callback directly, 204 // otherwise descend. 205 ModuleSP module_sp(target_images.GetModuleAtIndexUnlocked (i)); 206 if (!ModulePasses (module_sp)) 207 continue; 208 209 if (searcher.GetDepth () == Searcher::eDepthModule) 210 { 211 SymbolContext matchingContext(m_target_sp, module_sp); 212 213 Searcher::CallbackReturn shouldContinue = searcher.SearchCallback (*this, matchingContext, NULL, false); 214 if (shouldContinue == Searcher::eCallbackReturnStop 215 || shouldContinue == Searcher::eCallbackReturnPop) 216 return shouldContinue; 217 } 218 else 219 { 220 Searcher::CallbackReturn shouldContinue = DoCUIteration(module_sp, context, searcher); 221 if (shouldContinue == Searcher::eCallbackReturnStop) 222 return shouldContinue; 223 else if (shouldContinue == Searcher::eCallbackReturnPop) 224 continue; 225 } 226 } 227 } 228 } 229 return Searcher::eCallbackReturnContinue; 230 } 231 232 Searcher::CallbackReturn 233 SearchFilter::DoCUIteration (const ModuleSP &module_sp, const SymbolContext &context, Searcher &searcher) 234 { 235 Searcher::CallbackReturn shouldContinue; 236 if (context.comp_unit == NULL) 237 { 238 const size_t num_comp_units = module_sp->GetNumCompileUnits(); 239 for (size_t i = 0; i < num_comp_units; i++) 240 { 241 CompUnitSP cu_sp (module_sp->GetCompileUnitAtIndex (i)); 242 if (cu_sp) 243 { 244 if (!CompUnitPasses (*(cu_sp.get()))) 245 continue; 246 247 if (searcher.GetDepth () == Searcher::eDepthCompUnit) 248 { 249 SymbolContext matchingContext(m_target_sp, module_sp, cu_sp.get()); 250 251 shouldContinue = searcher.SearchCallback (*this, matchingContext, NULL, false); 252 253 if (shouldContinue == Searcher::eCallbackReturnPop) 254 return Searcher::eCallbackReturnContinue; 255 else if (shouldContinue == Searcher::eCallbackReturnStop) 256 return shouldContinue; 257 } 258 else 259 { 260 // FIXME Descend to block. 261 } 262 } 263 } 264 } 265 else 266 { 267 if (CompUnitPasses(*context.comp_unit)) 268 { 269 SymbolContext matchingContext (m_target_sp, module_sp, context.comp_unit); 270 return searcher.SearchCallback (*this, matchingContext, NULL, false); 271 } 272 } 273 return Searcher::eCallbackReturnContinue; 274 } 275 276 Searcher::CallbackReturn 277 SearchFilter::DoFunctionIteration (Function *function, const SymbolContext &context, Searcher &searcher) 278 { 279 // FIXME: Implement... 280 return Searcher::eCallbackReturnContinue; 281 } 282 283 //---------------------------------------------------------------------- 284 // SearchFilterForNonModuleSpecificSearches: 285 // Selects a shared library matching a given file spec, consulting the targets "black list". 286 //---------------------------------------------------------------------- 287 288 bool 289 SearchFilterForNonModuleSpecificSearches::ModulePasses (const FileSpec &module_spec) 290 { 291 if (m_target_sp->ModuleIsExcludedForNonModuleSpecificSearches (module_spec)) 292 return false; 293 else 294 return true; 295 } 296 297 bool 298 SearchFilterForNonModuleSpecificSearches::ModulePasses (const lldb::ModuleSP &module_sp) 299 { 300 if (!module_sp) 301 return true; 302 else if (m_target_sp->ModuleIsExcludedForNonModuleSpecificSearches (module_sp)) 303 return false; 304 else 305 return true; 306 } 307 308 //---------------------------------------------------------------------- 309 // SearchFilterByModule: 310 // Selects a shared library matching a given file spec 311 //---------------------------------------------------------------------- 312 313 //---------------------------------------------------------------------- 314 // SearchFilterByModule constructors 315 //---------------------------------------------------------------------- 316 317 SearchFilterByModule::SearchFilterByModule (const lldb::TargetSP &target_sp, const FileSpec &module) : 318 SearchFilter (target_sp), 319 m_module_spec (module) 320 { 321 } 322 323 324 //---------------------------------------------------------------------- 325 // SearchFilterByModule copy constructor 326 //---------------------------------------------------------------------- 327 SearchFilterByModule::SearchFilterByModule(const SearchFilterByModule& rhs) : 328 SearchFilter (rhs), 329 m_module_spec (rhs.m_module_spec) 330 { 331 } 332 333 //---------------------------------------------------------------------- 334 // SearchFilterByModule assignment operator 335 //---------------------------------------------------------------------- 336 const SearchFilterByModule& 337 SearchFilterByModule::operator=(const SearchFilterByModule& rhs) 338 { 339 m_target_sp = rhs.m_target_sp; 340 m_module_spec = rhs.m_module_spec; 341 return *this; 342 } 343 344 //---------------------------------------------------------------------- 345 // Destructor 346 //---------------------------------------------------------------------- 347 SearchFilterByModule::~SearchFilterByModule() 348 { 349 } 350 351 bool 352 SearchFilterByModule::ModulePasses (const ModuleSP &module_sp) 353 { 354 if (module_sp && FileSpec::Equal(module_sp->GetFileSpec(), m_module_spec, false)) 355 return true; 356 else 357 return false; 358 } 359 360 bool 361 SearchFilterByModule::ModulePasses (const FileSpec &spec) 362 { 363 // Do a full match only if "spec" has a directory 364 const bool full_match = spec.GetDirectory(); 365 return FileSpec::Equal(spec, m_module_spec, full_match); 366 } 367 368 bool 369 SearchFilterByModule::AddressPasses (Address &address) 370 { 371 // FIXME: Not yet implemented 372 return true; 373 } 374 375 376 bool 377 SearchFilterByModule::CompUnitPasses (FileSpec &fileSpec) 378 { 379 return true; 380 } 381 382 bool 383 SearchFilterByModule::CompUnitPasses (CompileUnit &compUnit) 384 { 385 return true; 386 } 387 388 void 389 SearchFilterByModule::Search (Searcher &searcher) 390 { 391 if (!m_target_sp) 392 return; 393 394 if (searcher.GetDepth() == Searcher::eDepthTarget) 395 { 396 SymbolContext empty_sc; 397 empty_sc.target_sp = m_target_sp; 398 searcher.SearchCallback (*this, empty_sc, NULL, false); 399 } 400 401 // If the module file spec is a full path, then we can just find the one 402 // filespec that passes. Otherwise, we need to go through all modules and 403 // find the ones that match the file name. 404 405 const ModuleList &target_modules = m_target_sp->GetImages(); 406 Mutex::Locker modules_locker (target_modules.GetMutex()); 407 408 const size_t num_modules = target_modules.GetSize (); 409 for (size_t i = 0; i < num_modules; i++) 410 { 411 Module* module = target_modules.GetModulePointerAtIndexUnlocked(i); 412 const bool full_match = m_module_spec.GetDirectory(); 413 if (FileSpec::Equal (m_module_spec, module->GetFileSpec(), full_match)) 414 { 415 SymbolContext matchingContext(m_target_sp, module->shared_from_this()); 416 Searcher::CallbackReturn shouldContinue; 417 418 shouldContinue = DoModuleIteration(matchingContext, searcher); 419 if (shouldContinue == Searcher::eCallbackReturnStop) 420 return; 421 } 422 } 423 } 424 425 void 426 SearchFilterByModule::GetDescription (Stream *s) 427 { 428 s->PutCString(", module = "); 429 if (s->GetVerbose()) 430 { 431 char buffer[2048]; 432 m_module_spec.GetPath(buffer, 2047); 433 s->PutCString(buffer); 434 } 435 else 436 { 437 s->PutCString(m_module_spec.GetFilename().AsCString("<unknown>")); 438 } 439 } 440 441 uint32_t 442 SearchFilterByModule::GetFilterRequiredItems() 443 { 444 return eSymbolContextModule; 445 } 446 447 void 448 SearchFilterByModule::Dump (Stream *s) const 449 { 450 451 } 452 //---------------------------------------------------------------------- 453 // SearchFilterByModuleList: 454 // Selects a shared library matching a given file spec 455 //---------------------------------------------------------------------- 456 457 //---------------------------------------------------------------------- 458 // SearchFilterByModuleList constructors 459 //---------------------------------------------------------------------- 460 461 SearchFilterByModuleList::SearchFilterByModuleList (const lldb::TargetSP &target_sp, const FileSpecList &module_list) : 462 SearchFilter (target_sp), 463 m_module_spec_list (module_list) 464 { 465 } 466 467 468 //---------------------------------------------------------------------- 469 // SearchFilterByModuleList copy constructor 470 //---------------------------------------------------------------------- 471 SearchFilterByModuleList::SearchFilterByModuleList(const SearchFilterByModuleList& rhs) : 472 SearchFilter (rhs), 473 m_module_spec_list (rhs.m_module_spec_list) 474 { 475 } 476 477 //---------------------------------------------------------------------- 478 // SearchFilterByModuleList assignment operator 479 //---------------------------------------------------------------------- 480 const SearchFilterByModuleList& 481 SearchFilterByModuleList::operator=(const SearchFilterByModuleList& rhs) 482 { 483 m_target_sp = rhs.m_target_sp; 484 m_module_spec_list = rhs.m_module_spec_list; 485 return *this; 486 } 487 488 //---------------------------------------------------------------------- 489 // Destructor 490 //---------------------------------------------------------------------- 491 SearchFilterByModuleList::~SearchFilterByModuleList() 492 { 493 } 494 495 bool 496 SearchFilterByModuleList::ModulePasses (const ModuleSP &module_sp) 497 { 498 if (m_module_spec_list.GetSize() == 0) 499 return true; 500 501 if (module_sp && m_module_spec_list.FindFileIndex(0, module_sp->GetFileSpec(), false) != UINT32_MAX) 502 return true; 503 else 504 return false; 505 } 506 507 bool 508 SearchFilterByModuleList::ModulePasses (const FileSpec &spec) 509 { 510 if (m_module_spec_list.GetSize() == 0) 511 return true; 512 513 if (m_module_spec_list.FindFileIndex(0, spec, true) != UINT32_MAX) 514 return true; 515 else 516 return false; 517 } 518 519 bool 520 SearchFilterByModuleList::AddressPasses (Address &address) 521 { 522 // FIXME: Not yet implemented 523 return true; 524 } 525 526 527 bool 528 SearchFilterByModuleList::CompUnitPasses (FileSpec &fileSpec) 529 { 530 return true; 531 } 532 533 bool 534 SearchFilterByModuleList::CompUnitPasses (CompileUnit &compUnit) 535 { 536 return true; 537 } 538 539 void 540 SearchFilterByModuleList::Search (Searcher &searcher) 541 { 542 if (!m_target_sp) 543 return; 544 545 if (searcher.GetDepth() == Searcher::eDepthTarget) 546 { 547 SymbolContext empty_sc; 548 empty_sc.target_sp = m_target_sp; 549 searcher.SearchCallback (*this, empty_sc, NULL, false); 550 } 551 552 // If the module file spec is a full path, then we can just find the one 553 // filespec that passes. Otherwise, we need to go through all modules and 554 // find the ones that match the file name. 555 556 const ModuleList &target_modules = m_target_sp->GetImages(); 557 Mutex::Locker modules_locker (target_modules.GetMutex()); 558 559 const size_t num_modules = target_modules.GetSize (); 560 for (size_t i = 0; i < num_modules; i++) 561 { 562 Module* module = target_modules.GetModulePointerAtIndexUnlocked(i); 563 if (m_module_spec_list.FindFileIndex(0, module->GetFileSpec(), false) != UINT32_MAX) 564 { 565 SymbolContext matchingContext(m_target_sp, module->shared_from_this()); 566 Searcher::CallbackReturn shouldContinue; 567 568 shouldContinue = DoModuleIteration(matchingContext, searcher); 569 if (shouldContinue == Searcher::eCallbackReturnStop) 570 return; 571 } 572 } 573 } 574 575 void 576 SearchFilterByModuleList::GetDescription (Stream *s) 577 { 578 size_t num_modules = m_module_spec_list.GetSize(); 579 if (num_modules == 1) 580 { 581 s->Printf (", module = "); 582 if (s->GetVerbose()) 583 { 584 char buffer[2048]; 585 m_module_spec_list.GetFileSpecAtIndex(0).GetPath(buffer, 2047); 586 s->PutCString(buffer); 587 } 588 else 589 { 590 s->PutCString(m_module_spec_list.GetFileSpecAtIndex(0).GetFilename().AsCString("<unknown>")); 591 } 592 } 593 else 594 { 595 s->Printf (", modules(%zu) = ", num_modules); 596 for (size_t i = 0; i < num_modules; i++) 597 { 598 if (s->GetVerbose()) 599 { 600 char buffer[2048]; 601 m_module_spec_list.GetFileSpecAtIndex(i).GetPath(buffer, 2047); 602 s->PutCString(buffer); 603 } 604 else 605 { 606 s->PutCString(m_module_spec_list.GetFileSpecAtIndex(i).GetFilename().AsCString("<unknown>")); 607 } 608 if (i != num_modules - 1) 609 s->PutCString (", "); 610 } 611 } 612 } 613 614 uint32_t 615 SearchFilterByModuleList::GetFilterRequiredItems() 616 { 617 return eSymbolContextModule; 618 } 619 620 void 621 SearchFilterByModuleList::Dump (Stream *s) const 622 { 623 624 } 625 626 //---------------------------------------------------------------------- 627 // SearchFilterByModuleListAndCU: 628 // Selects a shared library matching a given file spec 629 //---------------------------------------------------------------------- 630 631 //---------------------------------------------------------------------- 632 // SearchFilterByModuleListAndCU constructors 633 //---------------------------------------------------------------------- 634 635 SearchFilterByModuleListAndCU::SearchFilterByModuleListAndCU (const lldb::TargetSP &target_sp, 636 const FileSpecList &module_list, 637 const FileSpecList &cu_list) : 638 SearchFilterByModuleList (target_sp, module_list), 639 m_cu_spec_list (cu_list) 640 { 641 } 642 643 644 //---------------------------------------------------------------------- 645 // SearchFilterByModuleListAndCU copy constructor 646 //---------------------------------------------------------------------- 647 SearchFilterByModuleListAndCU::SearchFilterByModuleListAndCU(const SearchFilterByModuleListAndCU& rhs) : 648 SearchFilterByModuleList (rhs), 649 m_cu_spec_list (rhs.m_cu_spec_list) 650 { 651 } 652 653 //---------------------------------------------------------------------- 654 // SearchFilterByModuleListAndCU assignment operator 655 //---------------------------------------------------------------------- 656 const SearchFilterByModuleListAndCU& 657 SearchFilterByModuleListAndCU::operator=(const SearchFilterByModuleListAndCU& rhs) 658 { 659 if (&rhs != this) 660 { 661 m_target_sp = rhs.m_target_sp; 662 m_module_spec_list = rhs.m_module_spec_list; 663 m_cu_spec_list = rhs.m_cu_spec_list; 664 } 665 return *this; 666 } 667 668 //---------------------------------------------------------------------- 669 // Destructor 670 //---------------------------------------------------------------------- 671 SearchFilterByModuleListAndCU::~SearchFilterByModuleListAndCU() 672 { 673 } 674 675 bool 676 SearchFilterByModuleListAndCU::AddressPasses (Address &address) 677 { 678 return true; 679 } 680 681 682 bool 683 SearchFilterByModuleListAndCU::CompUnitPasses (FileSpec &fileSpec) 684 { 685 return m_cu_spec_list.FindFileIndex(0, fileSpec, false) != UINT32_MAX; 686 } 687 688 bool 689 SearchFilterByModuleListAndCU::CompUnitPasses (CompileUnit &compUnit) 690 { 691 bool in_cu_list = m_cu_spec_list.FindFileIndex(0, compUnit, false) != UINT32_MAX; 692 if (in_cu_list) 693 { 694 ModuleSP module_sp(compUnit.GetModule()); 695 if (module_sp) 696 { 697 bool module_passes = SearchFilterByModuleList::ModulePasses(module_sp); 698 return module_passes; 699 } 700 else 701 return true; 702 } 703 else 704 return false; 705 } 706 707 void 708 SearchFilterByModuleListAndCU::Search (Searcher &searcher) 709 { 710 if (!m_target_sp) 711 return; 712 713 if (searcher.GetDepth() == Searcher::eDepthTarget) 714 { 715 SymbolContext empty_sc; 716 empty_sc.target_sp = m_target_sp; 717 searcher.SearchCallback (*this, empty_sc, NULL, false); 718 } 719 720 // If the module file spec is a full path, then we can just find the one 721 // filespec that passes. Otherwise, we need to go through all modules and 722 // find the ones that match the file name. 723 724 ModuleList matching_modules; 725 const ModuleList &target_images = m_target_sp->GetImages(); 726 Mutex::Locker modules_locker(target_images.GetMutex()); 727 728 const size_t num_modules = target_images.GetSize (); 729 bool no_modules_in_filter = m_module_spec_list.GetSize() == 0; 730 for (size_t i = 0; i < num_modules; i++) 731 { 732 lldb::ModuleSP module_sp = target_images.GetModuleAtIndexUnlocked(i); 733 if (no_modules_in_filter || m_module_spec_list.FindFileIndex(0, module_sp->GetFileSpec(), false) != UINT32_MAX) 734 { 735 SymbolContext matchingContext(m_target_sp, module_sp); 736 Searcher::CallbackReturn shouldContinue; 737 738 if (searcher.GetDepth() == Searcher::eDepthModule) 739 { 740 shouldContinue = DoModuleIteration(matchingContext, searcher); 741 if (shouldContinue == Searcher::eCallbackReturnStop) 742 return; 743 } 744 else 745 { 746 const size_t num_cu = module_sp->GetNumCompileUnits(); 747 for (size_t cu_idx = 0; cu_idx < num_cu; cu_idx++) 748 { 749 CompUnitSP cu_sp = module_sp->GetCompileUnitAtIndex(cu_idx); 750 matchingContext.comp_unit = cu_sp.get(); 751 if (matchingContext.comp_unit) 752 { 753 if (m_cu_spec_list.FindFileIndex(0, *matchingContext.comp_unit, false) != UINT32_MAX) 754 { 755 shouldContinue = DoCUIteration(module_sp, matchingContext, searcher); 756 if (shouldContinue == Searcher::eCallbackReturnStop) 757 return; 758 } 759 } 760 } 761 } 762 } 763 } 764 } 765 766 void 767 SearchFilterByModuleListAndCU::GetDescription (Stream *s) 768 { 769 size_t num_modules = m_module_spec_list.GetSize(); 770 if (num_modules == 1) 771 { 772 s->Printf (", module = "); 773 if (s->GetVerbose()) 774 { 775 char buffer[2048]; 776 m_module_spec_list.GetFileSpecAtIndex(0).GetPath(buffer, 2047); 777 s->PutCString(buffer); 778 } 779 else 780 { 781 s->PutCString(m_module_spec_list.GetFileSpecAtIndex(0).GetFilename().AsCString("<unknown>")); 782 } 783 } 784 else if (num_modules > 0) 785 { 786 s->Printf (", modules(%zd) = ", num_modules); 787 for (size_t i = 0; i < num_modules; i++) 788 { 789 if (s->GetVerbose()) 790 { 791 char buffer[2048]; 792 m_module_spec_list.GetFileSpecAtIndex(i).GetPath(buffer, 2047); 793 s->PutCString(buffer); 794 } 795 else 796 { 797 s->PutCString(m_module_spec_list.GetFileSpecAtIndex(i).GetFilename().AsCString("<unknown>")); 798 } 799 if (i != num_modules - 1) 800 s->PutCString (", "); 801 } 802 } 803 } 804 805 uint32_t 806 SearchFilterByModuleListAndCU::GetFilterRequiredItems() 807 { 808 return eSymbolContextModule | eSymbolContextCompUnit; 809 } 810 811 void 812 SearchFilterByModuleListAndCU::Dump (Stream *s) const 813 { 814 815 } 816 817
