Module.cpp revision 899025fb72c0430e3b02746ca11c9070e9ede951
1//===-- Module.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/Core/Module.h" 11#include "lldb/Core/Log.h" 12#include "lldb/Core/ModuleList.h" 13#include "lldb/Core/RegularExpression.h" 14#include "lldb/Core/Timer.h" 15#include "lldb/lldb-private-log.h" 16#include "lldb/Symbol/ObjectFile.h" 17#include "lldb/Symbol/SymbolContext.h" 18#include "lldb/Symbol/SymbolVendor.h" 19 20using namespace lldb; 21using namespace lldb_private; 22 23// Shared pointers to modules track module lifetimes in 24// targets and in the global module, but this collection 25// will track all module objects that are still alive 26typedef std::vector<Module *> ModuleCollection; 27 28static ModuleCollection & 29GetModuleCollection() 30{ 31 static ModuleCollection g_module_collection; 32 return g_module_collection; 33} 34 35Mutex & 36Module::GetAllocationModuleCollectionMutex() 37{ 38 static Mutex g_module_collection_mutex(Mutex::eMutexTypeRecursive); 39 return g_module_collection_mutex; 40} 41 42size_t 43Module::GetNumberAllocatedModules () 44{ 45 Mutex::Locker locker (GetAllocationModuleCollectionMutex()); 46 return GetModuleCollection().size(); 47} 48 49Module * 50Module::GetAllocatedModuleAtIndex (size_t idx) 51{ 52 Mutex::Locker locker (GetAllocationModuleCollectionMutex()); 53 ModuleCollection &modules = GetModuleCollection(); 54 if (idx < modules.size()) 55 return modules[idx]; 56 return NULL; 57} 58 59 60 61 62Module::Module(const FileSpec& file_spec, const ArchSpec& arch, const ConstString *object_name, off_t object_offset) : 63 m_mutex (Mutex::eMutexTypeRecursive), 64 m_mod_time (file_spec.GetModificationTime()), 65 m_arch (arch), 66 m_uuid (), 67 m_file (file_spec), 68 m_platform_file(), 69 m_object_name (), 70 m_object_offset (object_offset), 71 m_objfile_ap (), 72 m_symfile_ap (), 73 m_ast (), 74 m_did_load_objfile (false), 75 m_did_load_symbol_vendor (false), 76 m_did_parse_uuid (false), 77 m_did_init_ast (false), 78 m_is_dynamic_loader_module (false) 79{ 80 // Scope for locker below... 81 { 82 Mutex::Locker locker (GetAllocationModuleCollectionMutex()); 83 GetModuleCollection().push_back(this); 84 } 85 86 if (object_name) 87 m_object_name = *object_name; 88 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT)); 89 if (log) 90 log->Printf ("%p Module::Module((%s) '%s/%s%s%s%s')", 91 this, 92 m_arch.GetArchitectureName(), 93 m_file.GetDirectory().AsCString(""), 94 m_file.GetFilename().AsCString(""), 95 m_object_name.IsEmpty() ? "" : "(", 96 m_object_name.IsEmpty() ? "" : m_object_name.AsCString(""), 97 m_object_name.IsEmpty() ? "" : ")"); 98} 99 100Module::~Module() 101{ 102 // Scope for locker below... 103 { 104 Mutex::Locker locker (GetAllocationModuleCollectionMutex()); 105 ModuleCollection &modules = GetModuleCollection(); 106 ModuleCollection::iterator end = modules.end(); 107 ModuleCollection::iterator pos = std::find(modules.begin(), end, this); 108 if (pos != end) 109 modules.erase(pos); 110 } 111 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT)); 112 if (log) 113 log->Printf ("%p Module::~Module((%s) '%s/%s%s%s%s')", 114 this, 115 m_arch.GetArchitectureName(), 116 m_file.GetDirectory().AsCString(""), 117 m_file.GetFilename().AsCString(""), 118 m_object_name.IsEmpty() ? "" : "(", 119 m_object_name.IsEmpty() ? "" : m_object_name.AsCString(""), 120 m_object_name.IsEmpty() ? "" : ")"); 121 // Release any auto pointers before we start tearing down our member 122 // variables since the object file and symbol files might need to make 123 // function calls back into this module object. The ordering is important 124 // here because symbol files can require the module object file. So we tear 125 // down the symbol file first, then the object file. 126 m_symfile_ap.reset(); 127 m_objfile_ap.reset(); 128} 129 130 131ModuleSP 132Module::GetSP () const 133{ 134 return ModuleList::GetModuleSP (this); 135} 136 137const lldb_private::UUID& 138Module::GetUUID() 139{ 140 Mutex::Locker locker (m_mutex); 141 if (m_did_parse_uuid == false) 142 { 143 ObjectFile * obj_file = GetObjectFile (); 144 145 if (obj_file != NULL) 146 { 147 obj_file->GetUUID(&m_uuid); 148 m_did_parse_uuid = true; 149 } 150 } 151 return m_uuid; 152} 153 154ClangASTContext & 155Module::GetClangASTContext () 156{ 157 Mutex::Locker locker (m_mutex); 158 if (m_did_init_ast == false) 159 { 160 ObjectFile * objfile = GetObjectFile(); 161 ArchSpec object_arch; 162 if (objfile && objfile->GetArchitecture(object_arch)) 163 { 164 m_did_init_ast = true; 165 m_ast.SetArchitecture (object_arch); 166 } 167 } 168 return m_ast; 169} 170 171void 172Module::ParseAllDebugSymbols() 173{ 174 Mutex::Locker locker (m_mutex); 175 uint32_t num_comp_units = GetNumCompileUnits(); 176 if (num_comp_units == 0) 177 return; 178 179 TargetSP null_target; 180 SymbolContext sc(null_target, GetSP()); 181 uint32_t cu_idx; 182 SymbolVendor *symbols = GetSymbolVendor (); 183 184 for (cu_idx = 0; cu_idx < num_comp_units; cu_idx++) 185 { 186 sc.comp_unit = symbols->GetCompileUnitAtIndex(cu_idx).get(); 187 if (sc.comp_unit) 188 { 189 sc.function = NULL; 190 symbols->ParseVariablesForContext(sc); 191 192 symbols->ParseCompileUnitFunctions(sc); 193 194 uint32_t func_idx; 195 for (func_idx = 0; (sc.function = sc.comp_unit->GetFunctionAtIndex(func_idx).get()) != NULL; ++func_idx) 196 { 197 symbols->ParseFunctionBlocks(sc); 198 199 // Parse the variables for this function and all its blocks 200 symbols->ParseVariablesForContext(sc); 201 } 202 203 204 // Parse all types for this compile unit 205 sc.function = NULL; 206 symbols->ParseTypes(sc); 207 } 208 } 209} 210 211void 212Module::CalculateSymbolContext(SymbolContext* sc) 213{ 214 sc->module_sp = GetSP(); 215} 216 217void 218Module::DumpSymbolContext(Stream *s) 219{ 220 s->Printf(", Module{0x%8.8x}", this); 221} 222 223uint32_t 224Module::GetNumCompileUnits() 225{ 226 Mutex::Locker locker (m_mutex); 227 Timer scoped_timer(__PRETTY_FUNCTION__, "Module::GetNumCompileUnits (module = %p)", this); 228 SymbolVendor *symbols = GetSymbolVendor (); 229 if (symbols) 230 return symbols->GetNumCompileUnits(); 231 return 0; 232} 233 234CompUnitSP 235Module::GetCompileUnitAtIndex (uint32_t index) 236{ 237 Mutex::Locker locker (m_mutex); 238 uint32_t num_comp_units = GetNumCompileUnits (); 239 CompUnitSP cu_sp; 240 241 if (index < num_comp_units) 242 { 243 SymbolVendor *symbols = GetSymbolVendor (); 244 if (symbols) 245 cu_sp = symbols->GetCompileUnitAtIndex(index); 246 } 247 return cu_sp; 248} 249 250bool 251Module::ResolveFileAddress (lldb::addr_t vm_addr, Address& so_addr) 252{ 253 Mutex::Locker locker (m_mutex); 254 Timer scoped_timer(__PRETTY_FUNCTION__, "Module::ResolveFileAddress (vm_addr = 0x%llx)", vm_addr); 255 ObjectFile* ofile = GetObjectFile(); 256 if (ofile) 257 return so_addr.ResolveAddressUsingFileSections(vm_addr, ofile->GetSectionList()); 258 return false; 259} 260 261uint32_t 262Module::ResolveSymbolContextForAddress (const Address& so_addr, uint32_t resolve_scope, SymbolContext& sc) 263{ 264 Mutex::Locker locker (m_mutex); 265 uint32_t resolved_flags = 0; 266 267 // Clear the result symbol context in case we don't find anything 268 sc.Clear(); 269 270 // Get the section from the section/offset address. 271 const Section *section = so_addr.GetSection(); 272 273 // Make sure the section matches this module before we try and match anything 274 if (section && section->GetModule() == this) 275 { 276 // If the section offset based address resolved itself, then this 277 // is the right module. 278 sc.module_sp = GetSP(); 279 resolved_flags |= eSymbolContextModule; 280 281 // Resolve the compile unit, function, block, line table or line 282 // entry if requested. 283 if (resolve_scope & eSymbolContextCompUnit || 284 resolve_scope & eSymbolContextFunction || 285 resolve_scope & eSymbolContextBlock || 286 resolve_scope & eSymbolContextLineEntry ) 287 { 288 SymbolVendor *symbols = GetSymbolVendor (); 289 if (symbols) 290 resolved_flags |= symbols->ResolveSymbolContext (so_addr, resolve_scope, sc); 291 } 292 293 // Resolve the symbol if requested, but don't re-look it up if we've already found it. 294 if (resolve_scope & eSymbolContextSymbol && !(resolved_flags & eSymbolContextSymbol)) 295 { 296 ObjectFile* ofile = GetObjectFile(); 297 if (ofile) 298 { 299 Symtab *symtab = ofile->GetSymtab(); 300 if (symtab) 301 { 302 if (so_addr.IsSectionOffset()) 303 { 304 sc.symbol = symtab->FindSymbolContainingFileAddress(so_addr.GetFileAddress()); 305 if (sc.symbol) 306 resolved_flags |= eSymbolContextSymbol; 307 } 308 } 309 } 310 } 311 } 312 return resolved_flags; 313} 314 315uint32_t 316Module::ResolveSymbolContextForFilePath 317( 318 const char *file_path, 319 uint32_t line, 320 bool check_inlines, 321 uint32_t resolve_scope, 322 SymbolContextList& sc_list 323) 324{ 325 FileSpec file_spec(file_path, false); 326 return ResolveSymbolContextsForFileSpec (file_spec, line, check_inlines, resolve_scope, sc_list); 327} 328 329uint32_t 330Module::ResolveSymbolContextsForFileSpec (const FileSpec &file_spec, uint32_t line, bool check_inlines, uint32_t resolve_scope, SymbolContextList& sc_list) 331{ 332 Mutex::Locker locker (m_mutex); 333 Timer scoped_timer(__PRETTY_FUNCTION__, 334 "Module::ResolveSymbolContextForFilePath (%s%s%s:%u, check_inlines = %s, resolve_scope = 0x%8.8x)", 335 file_spec.GetDirectory().AsCString(""), 336 file_spec.GetDirectory() ? "/" : "", 337 file_spec.GetFilename().AsCString(""), 338 line, 339 check_inlines ? "yes" : "no", 340 resolve_scope); 341 342 const uint32_t initial_count = sc_list.GetSize(); 343 344 SymbolVendor *symbols = GetSymbolVendor (); 345 if (symbols) 346 symbols->ResolveSymbolContext (file_spec, line, check_inlines, resolve_scope, sc_list); 347 348 return sc_list.GetSize() - initial_count; 349} 350 351 352uint32_t 353Module::FindGlobalVariables(const ConstString &name, bool append, uint32_t max_matches, VariableList& variables) 354{ 355 SymbolVendor *symbols = GetSymbolVendor (); 356 if (symbols) 357 return symbols->FindGlobalVariables(name, append, max_matches, variables); 358 return 0; 359} 360uint32_t 361Module::FindGlobalVariables(const RegularExpression& regex, bool append, uint32_t max_matches, VariableList& variables) 362{ 363 SymbolVendor *symbols = GetSymbolVendor (); 364 if (symbols) 365 return symbols->FindGlobalVariables(regex, append, max_matches, variables); 366 return 0; 367} 368 369uint32_t 370Module::FindCompileUnits (const FileSpec &path, 371 bool append, 372 SymbolContextList &sc_list) 373{ 374 if (!append) 375 sc_list.Clear(); 376 377 const uint32_t start_size = sc_list.GetSize(); 378 const uint32_t num_compile_units = GetNumCompileUnits(); 379 SymbolContext sc; 380 sc.module_sp = GetSP(); 381 const bool compare_directory = path.GetDirectory(); 382 for (uint32_t i=0; i<num_compile_units; ++i) 383 { 384 sc.comp_unit = GetCompileUnitAtIndex(i).get(); 385 if (FileSpec::Equal (*sc.comp_unit, path, compare_directory)) 386 sc_list.Append(sc); 387 } 388 return sc_list.GetSize() - start_size; 389} 390 391uint32_t 392Module::FindFunctions (const ConstString &name, 393 uint32_t name_type_mask, 394 bool include_symbols, 395 bool append, 396 SymbolContextList& sc_list) 397{ 398 if (!append) 399 sc_list.Clear(); 400 401 const uint32_t start_size = sc_list.GetSize(); 402 403 // Find all the functions (not symbols, but debug information functions... 404 SymbolVendor *symbols = GetSymbolVendor (); 405 if (symbols) 406 symbols->FindFunctions(name, name_type_mask, append, sc_list); 407 408 // Now check our symbol table for symbols that are code symbols if requested 409 if (include_symbols) 410 { 411 ObjectFile *objfile = GetObjectFile(); 412 if (objfile) 413 { 414 Symtab *symtab = objfile->GetSymtab(); 415 if (symtab) 416 { 417 std::vector<uint32_t> symbol_indexes; 418 symtab->FindAllSymbolsWithNameAndType (name, eSymbolTypeCode, Symtab::eDebugAny, Symtab::eVisibilityAny, symbol_indexes); 419 const uint32_t num_matches = symbol_indexes.size(); 420 if (num_matches) 421 { 422 const bool merge_symbol_into_function = true; 423 SymbolContext sc(this); 424 for (uint32_t i=0; i<num_matches; i++) 425 { 426 sc.symbol = symtab->SymbolAtIndex(symbol_indexes[i]); 427 sc_list.AppendIfUnique (sc, merge_symbol_into_function); 428 } 429 } 430 } 431 } 432 } 433 return sc_list.GetSize() - start_size; 434} 435 436uint32_t 437Module::FindFunctions (const RegularExpression& regex, 438 bool include_symbols, 439 bool append, 440 SymbolContextList& sc_list) 441{ 442 if (!append) 443 sc_list.Clear(); 444 445 const uint32_t start_size = sc_list.GetSize(); 446 447 SymbolVendor *symbols = GetSymbolVendor (); 448 if (symbols) 449 symbols->FindFunctions(regex, append, sc_list); 450 // Now check our symbol table for symbols that are code symbols if requested 451 if (include_symbols) 452 { 453 ObjectFile *objfile = GetObjectFile(); 454 if (objfile) 455 { 456 Symtab *symtab = objfile->GetSymtab(); 457 if (symtab) 458 { 459 std::vector<uint32_t> symbol_indexes; 460 symtab->AppendSymbolIndexesMatchingRegExAndType (regex, eSymbolTypeCode, Symtab::eDebugAny, Symtab::eVisibilityAny, symbol_indexes); 461 const uint32_t num_matches = symbol_indexes.size(); 462 if (num_matches) 463 { 464 const bool merge_symbol_into_function = true; 465 SymbolContext sc(this); 466 for (uint32_t i=0; i<num_matches; i++) 467 { 468 sc.symbol = symtab->SymbolAtIndex(symbol_indexes[i]); 469 sc_list.AppendIfUnique (sc, merge_symbol_into_function); 470 } 471 } 472 } 473 } 474 } 475 return sc_list.GetSize() - start_size; 476} 477 478uint32_t 479Module::FindTypes_Impl (const SymbolContext& sc, const ConstString &name, bool append, uint32_t max_matches, TypeList& types) 480{ 481 Timer scoped_timer(__PRETTY_FUNCTION__, __PRETTY_FUNCTION__); 482 if (sc.module_sp.get() == NULL || sc.module_sp.get() == this) 483 { 484 SymbolVendor *symbols = GetSymbolVendor (); 485 if (symbols) 486 return symbols->FindTypes(sc, name, append, max_matches, types); 487 } 488 return 0; 489} 490 491// depending on implementation details, type lookup might fail because of 492// embedded spurious namespace:: prefixes. this call strips them, paying 493// attention to the fact that a type might have namespace'd type names as 494// arguments to templates, and those must not be stripped off 495static const char* 496StripTypeName(const char* name_cstr) 497{ 498 const char* skip_namespace = strstr(name_cstr, "::"); 499 const char* template_arg_char = strchr(name_cstr, '<'); 500 while (skip_namespace != NULL) 501 { 502 if (template_arg_char != NULL && 503 skip_namespace > template_arg_char) // but namespace'd template arguments are still good to go 504 break; 505 name_cstr = skip_namespace+2; 506 skip_namespace = strstr(name_cstr, "::"); 507 } 508 return name_cstr; 509} 510 511uint32_t 512Module::FindTypes (const SymbolContext& sc, const ConstString &name, bool append, uint32_t max_matches, TypeList& types) 513{ 514 uint32_t retval = FindTypes_Impl(sc, name, append, max_matches, types); 515 516 if (retval == 0) 517 { 518 const char *stripped = StripTypeName(name.GetCString()); 519 return FindTypes_Impl(sc, ConstString(stripped), append, max_matches, types); 520 } 521 else 522 return retval; 523 524} 525 526//uint32_t 527//Module::FindTypes(const SymbolContext& sc, const RegularExpression& regex, bool append, uint32_t max_matches, Type::Encoding encoding, const char *udt_name, TypeList& types) 528//{ 529// Timer scoped_timer(__PRETTY_FUNCTION__); 530// SymbolVendor *symbols = GetSymbolVendor (); 531// if (symbols) 532// return symbols->FindTypes(sc, regex, append, max_matches, encoding, udt_name, types); 533// return 0; 534// 535//} 536 537SymbolVendor* 538Module::GetSymbolVendor (bool can_create) 539{ 540 Mutex::Locker locker (m_mutex); 541 if (m_did_load_symbol_vendor == false && can_create) 542 { 543 ObjectFile *obj_file = GetObjectFile (); 544 if (obj_file != NULL) 545 { 546 Timer scoped_timer(__PRETTY_FUNCTION__, __PRETTY_FUNCTION__); 547 m_symfile_ap.reset(SymbolVendor::FindPlugin(this)); 548 m_did_load_symbol_vendor = true; 549 } 550 } 551 return m_symfile_ap.get(); 552} 553 554void 555Module::SetFileSpecAndObjectName (const FileSpec &file, const ConstString &object_name) 556{ 557 // Container objects whose paths do not specify a file directly can call 558 // this function to correct the file and object names. 559 m_file = file; 560 m_mod_time = file.GetModificationTime(); 561 m_object_name = object_name; 562} 563 564const ArchSpec& 565Module::GetArchitecture () const 566{ 567 return m_arch; 568} 569 570void 571Module::GetDescription (Stream *s) 572{ 573 Mutex::Locker locker (m_mutex); 574 575 if (m_arch.IsValid()) 576 s->Printf("(%s) ", m_arch.GetArchitectureName()); 577 578 char path[PATH_MAX]; 579 if (m_file.GetPath(path, sizeof(path))) 580 s->PutCString(path); 581 582 const char *object_name = m_object_name.GetCString(); 583 if (object_name) 584 s->Printf("(%s)", object_name); 585} 586 587void 588Module::Dump(Stream *s) 589{ 590 Mutex::Locker locker (m_mutex); 591 //s->Printf("%.*p: ", (int)sizeof(void*) * 2, this); 592 s->Indent(); 593 s->Printf("Module %s/%s%s%s%s\n", 594 m_file.GetDirectory().AsCString(), 595 m_file.GetFilename().AsCString(), 596 m_object_name ? "(" : "", 597 m_object_name ? m_object_name.GetCString() : "", 598 m_object_name ? ")" : ""); 599 600 s->IndentMore(); 601 ObjectFile *objfile = GetObjectFile (); 602 603 if (objfile) 604 objfile->Dump(s); 605 606 SymbolVendor *symbols = GetSymbolVendor (); 607 608 if (symbols) 609 symbols->Dump(s); 610 611 s->IndentLess(); 612} 613 614 615TypeList* 616Module::GetTypeList () 617{ 618 SymbolVendor *symbols = GetSymbolVendor (); 619 if (symbols) 620 return &symbols->GetTypeList(); 621 return NULL; 622} 623 624const ConstString & 625Module::GetObjectName() const 626{ 627 return m_object_name; 628} 629 630ObjectFile * 631Module::GetObjectFile() 632{ 633 Mutex::Locker locker (m_mutex); 634 if (m_did_load_objfile == false) 635 { 636 m_did_load_objfile = true; 637 Timer scoped_timer(__PRETTY_FUNCTION__, 638 "Module::GetObjectFile () module = %s", GetFileSpec().GetFilename().AsCString("")); 639 m_objfile_ap.reset(ObjectFile::FindPlugin(this, &m_file, m_object_offset, m_file.GetByteSize())); 640 } 641 return m_objfile_ap.get(); 642} 643 644 645const Symbol * 646Module::FindFirstSymbolWithNameAndType (const ConstString &name, SymbolType symbol_type) 647{ 648 Timer scoped_timer(__PRETTY_FUNCTION__, 649 "Module::FindFirstSymbolWithNameAndType (name = %s, type = %i)", 650 name.AsCString(), 651 symbol_type); 652 ObjectFile *objfile = GetObjectFile(); 653 if (objfile) 654 { 655 Symtab *symtab = objfile->GetSymtab(); 656 if (symtab) 657 return symtab->FindFirstSymbolWithNameAndType (name, symbol_type, Symtab::eDebugAny, Symtab::eVisibilityAny); 658 } 659 return NULL; 660} 661void 662Module::SymbolIndicesToSymbolContextList (Symtab *symtab, std::vector<uint32_t> &symbol_indexes, SymbolContextList &sc_list) 663{ 664 // No need to protect this call using m_mutex all other method calls are 665 // already thread safe. 666 667 size_t num_indices = symbol_indexes.size(); 668 if (num_indices > 0) 669 { 670 SymbolContext sc; 671 CalculateSymbolContext (&sc); 672 for (size_t i = 0; i < num_indices; i++) 673 { 674 sc.symbol = symtab->SymbolAtIndex (symbol_indexes[i]); 675 if (sc.symbol) 676 sc_list.Append (sc); 677 } 678 } 679} 680 681size_t 682Module::FindSymbolsWithNameAndType (const ConstString &name, SymbolType symbol_type, SymbolContextList &sc_list) 683{ 684 // No need to protect this call using m_mutex all other method calls are 685 // already thread safe. 686 687 688 Timer scoped_timer(__PRETTY_FUNCTION__, 689 "Module::FindSymbolsWithNameAndType (name = %s, type = %i)", 690 name.AsCString(), 691 symbol_type); 692 const size_t initial_size = sc_list.GetSize(); 693 ObjectFile *objfile = GetObjectFile (); 694 if (objfile) 695 { 696 Symtab *symtab = objfile->GetSymtab(); 697 if (symtab) 698 { 699 std::vector<uint32_t> symbol_indexes; 700 symtab->FindAllSymbolsWithNameAndType (name, symbol_type, symbol_indexes); 701 SymbolIndicesToSymbolContextList (symtab, symbol_indexes, sc_list); 702 } 703 } 704 return sc_list.GetSize() - initial_size; 705} 706 707size_t 708Module::FindSymbolsMatchingRegExAndType (const RegularExpression ®ex, SymbolType symbol_type, SymbolContextList &sc_list) 709{ 710 // No need to protect this call using m_mutex all other method calls are 711 // already thread safe. 712 713 Timer scoped_timer(__PRETTY_FUNCTION__, 714 "Module::FindSymbolsMatchingRegExAndType (regex = %s, type = %i)", 715 regex.GetText(), 716 symbol_type); 717 const size_t initial_size = sc_list.GetSize(); 718 ObjectFile *objfile = GetObjectFile (); 719 if (objfile) 720 { 721 Symtab *symtab = objfile->GetSymtab(); 722 if (symtab) 723 { 724 std::vector<uint32_t> symbol_indexes; 725 symtab->FindAllSymbolsMatchingRexExAndType (regex, symbol_type, Symtab::eDebugAny, Symtab::eVisibilityAny, symbol_indexes); 726 SymbolIndicesToSymbolContextList (symtab, symbol_indexes, sc_list); 727 } 728 } 729 return sc_list.GetSize() - initial_size; 730} 731 732const TimeValue & 733Module::GetModificationTime () const 734{ 735 return m_mod_time; 736} 737 738bool 739Module::IsExecutable () 740{ 741 if (GetObjectFile() == NULL) 742 return false; 743 else 744 return GetObjectFile()->IsExecutable(); 745} 746 747bool 748Module::IsLoadedInTarget (Target *target) 749{ 750 ObjectFile *obj_file = GetObjectFile(); 751 if (obj_file) 752 { 753 SectionList *sections = obj_file->GetSectionList(); 754 if (sections != NULL) 755 { 756 size_t num_sections = sections->GetSize(); 757 for (size_t sect_idx = 0; sect_idx < num_sections; sect_idx++) 758 { 759 SectionSP section_sp = sections->GetSectionAtIndex(sect_idx); 760 if (section_sp->GetLoadBaseAddress(target) != LLDB_INVALID_ADDRESS) 761 { 762 return true; 763 } 764 } 765 } 766 } 767 return false; 768} 769bool 770Module::SetArchitecture (const ArchSpec &new_arch) 771{ 772 if (!m_arch.IsValid()) 773 { 774 m_arch = new_arch; 775 return true; 776 } 777 return m_arch == new_arch; 778} 779 780