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