1 //===-- Module.cpp --------------------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "lldb/Core/Module.h" 10 11 #include "lldb/Core/AddressRange.h" 12 #include "lldb/Core/AddressResolverFileLine.h" 13 #include "lldb/Core/Debugger.h" 14 #include "lldb/Core/FileSpecList.h" 15 #include "lldb/Core/Mangled.h" 16 #include "lldb/Core/ModuleSpec.h" 17 #include "lldb/Core/SearchFilter.h" 18 #include "lldb/Core/Section.h" 19 #include "lldb/Host/FileSystem.h" 20 #include "lldb/Host/Host.h" 21 #include "lldb/Host/HostInfo.h" 22 #include "lldb/Interpreter/CommandInterpreter.h" 23 #include "lldb/Interpreter/ScriptInterpreter.h" 24 #include "lldb/Symbol/CompileUnit.h" 25 #include "lldb/Symbol/Function.h" 26 #include "lldb/Symbol/ObjectFile.h" 27 #include "lldb/Symbol/Symbol.h" 28 #include "lldb/Symbol/SymbolContext.h" 29 #include "lldb/Symbol/SymbolFile.h" 30 #include "lldb/Symbol/SymbolVendor.h" 31 #include "lldb/Symbol/Symtab.h" 32 #include "lldb/Symbol/Type.h" 33 #include "lldb/Symbol/TypeList.h" 34 #include "lldb/Symbol/TypeMap.h" 35 #include "lldb/Symbol/TypeSystem.h" 36 #include "lldb/Target/Language.h" 37 #include "lldb/Target/Process.h" 38 #include "lldb/Target/Target.h" 39 #include "lldb/Utility/DataBufferHeap.h" 40 #include "lldb/Utility/LLDBAssert.h" 41 #include "lldb/Utility/Log.h" 42 #include "lldb/Utility/Logging.h" 43 #include "lldb/Utility/RegularExpression.h" 44 #include "lldb/Utility/Status.h" 45 #include "lldb/Utility/Stream.h" 46 #include "lldb/Utility/StreamString.h" 47 #include "lldb/Utility/Timer.h" 48 49 #if defined(_WIN32) 50 #include "lldb/Host/windows/PosixApi.h" 51 #endif 52 53 #include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h" 54 #include "Plugins/Language/ObjC/ObjCLanguage.h" 55 56 #include "llvm/ADT/STLExtras.h" 57 #include "llvm/Support/Compiler.h" 58 #include "llvm/Support/FileSystem.h" 59 #include "llvm/Support/Signals.h" 60 #include "llvm/Support/raw_ostream.h" 61 62 #include <assert.h> 63 #include <cstdint> 64 #include <inttypes.h> 65 #include <map> 66 #include <stdarg.h> 67 #include <string.h> 68 #include <type_traits> 69 #include <utility> 70 71 namespace lldb_private { 72 class CompilerDeclContext; 73 } 74 namespace lldb_private { 75 class VariableList; 76 } 77 78 using namespace lldb; 79 using namespace lldb_private; 80 81 // Shared pointers to modules track module lifetimes in targets and in the 82 // global module, but this collection will track all module objects that are 83 // still alive 84 typedef std::vector<Module *> ModuleCollection; 85 86 static ModuleCollection &GetModuleCollection() { 87 // This module collection needs to live past any module, so we could either 88 // make it a shared pointer in each module or just leak is. Since it is only 89 // an empty vector by the time all the modules have gone away, we just leak 90 // it for now. If we decide this is a big problem we can introduce a 91 // Finalize method that will tear everything down in a predictable order. 92 93 static ModuleCollection *g_module_collection = nullptr; 94 if (g_module_collection == nullptr) 95 g_module_collection = new ModuleCollection(); 96 97 return *g_module_collection; 98 } 99 100 std::recursive_mutex &Module::GetAllocationModuleCollectionMutex() { 101 // NOTE: The mutex below must be leaked since the global module list in 102 // the ModuleList class will get torn at some point, and we can't know if it 103 // will tear itself down before the "g_module_collection_mutex" below will. 104 // So we leak a Mutex object below to safeguard against that 105 106 static std::recursive_mutex *g_module_collection_mutex = nullptr; 107 if (g_module_collection_mutex == nullptr) 108 g_module_collection_mutex = new std::recursive_mutex; // NOTE: known leak 109 return *g_module_collection_mutex; 110 } 111 112 size_t Module::GetNumberAllocatedModules() { 113 std::lock_guard<std::recursive_mutex> guard( 114 GetAllocationModuleCollectionMutex()); 115 return GetModuleCollection().size(); 116 } 117 118 Module *Module::GetAllocatedModuleAtIndex(size_t idx) { 119 std::lock_guard<std::recursive_mutex> guard( 120 GetAllocationModuleCollectionMutex()); 121 ModuleCollection &modules = GetModuleCollection(); 122 if (idx < modules.size()) 123 return modules[idx]; 124 return nullptr; 125 } 126 127 Module::Module(const ModuleSpec &module_spec) 128 : m_object_offset(0), m_file_has_changed(false), 129 m_first_file_changed_log(false) { 130 // Scope for locker below... 131 { 132 std::lock_guard<std::recursive_mutex> guard( 133 GetAllocationModuleCollectionMutex()); 134 GetModuleCollection().push_back(this); 135 } 136 137 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_OBJECT | 138 LIBLLDB_LOG_MODULES)); 139 if (log != nullptr) 140 LLDB_LOGF(log, "%p Module::Module((%s) '%s%s%s%s')", 141 static_cast<void *>(this), 142 module_spec.GetArchitecture().GetArchitectureName(), 143 module_spec.GetFileSpec().GetPath().c_str(), 144 module_spec.GetObjectName().IsEmpty() ? "" : "(", 145 module_spec.GetObjectName().IsEmpty() 146 ? "" 147 : module_spec.GetObjectName().AsCString(""), 148 module_spec.GetObjectName().IsEmpty() ? "" : ")"); 149 150 auto data_sp = module_spec.GetData(); 151 lldb::offset_t file_size = 0; 152 if (data_sp) 153 file_size = data_sp->GetByteSize(); 154 155 // First extract all module specifications from the file using the local file 156 // path. If there are no specifications, then don't fill anything in 157 ModuleSpecList modules_specs; 158 if (ObjectFile::GetModuleSpecifications( 159 module_spec.GetFileSpec(), 0, file_size, modules_specs, data_sp) == 0) 160 return; 161 162 // Now make sure that one of the module specifications matches what we just 163 // extract. We might have a module specification that specifies a file 164 // "/usr/lib/dyld" with UUID XXX, but we might have a local version of 165 // "/usr/lib/dyld" that has 166 // UUID YYY and we don't want those to match. If they don't match, just don't 167 // fill any ivars in so we don't accidentally grab the wrong file later since 168 // they don't match... 169 ModuleSpec matching_module_spec; 170 if (!modules_specs.FindMatchingModuleSpec(module_spec, 171 matching_module_spec)) { 172 if (log) { 173 LLDB_LOGF(log, "Found local object file but the specs didn't match"); 174 } 175 return; 176 } 177 178 // Set m_data_sp if it was initially provided in the ModuleSpec. Note that 179 // we cannot use the data_sp variable here, because it will have been 180 // modified by GetModuleSpecifications(). 181 if (auto module_spec_data_sp = module_spec.GetData()) { 182 m_data_sp = module_spec_data_sp; 183 m_mod_time = {}; 184 } else { 185 if (module_spec.GetFileSpec()) 186 m_mod_time = 187 FileSystem::Instance().GetModificationTime(module_spec.GetFileSpec()); 188 else if (matching_module_spec.GetFileSpec()) 189 m_mod_time = FileSystem::Instance().GetModificationTime( 190 matching_module_spec.GetFileSpec()); 191 } 192 193 // Copy the architecture from the actual spec if we got one back, else use 194 // the one that was specified 195 if (matching_module_spec.GetArchitecture().IsValid()) 196 m_arch = matching_module_spec.GetArchitecture(); 197 else if (module_spec.GetArchitecture().IsValid()) 198 m_arch = module_spec.GetArchitecture(); 199 200 // Copy the file spec over and use the specified one (if there was one) so we 201 // don't use a path that might have gotten resolved a path in 202 // 'matching_module_spec' 203 if (module_spec.GetFileSpec()) 204 m_file = module_spec.GetFileSpec(); 205 else if (matching_module_spec.GetFileSpec()) 206 m_file = matching_module_spec.GetFileSpec(); 207 208 // Copy the platform file spec over 209 if (module_spec.GetPlatformFileSpec()) 210 m_platform_file = module_spec.GetPlatformFileSpec(); 211 else if (matching_module_spec.GetPlatformFileSpec()) 212 m_platform_file = matching_module_spec.GetPlatformFileSpec(); 213 214 // Copy the symbol file spec over 215 if (module_spec.GetSymbolFileSpec()) 216 m_symfile_spec = module_spec.GetSymbolFileSpec(); 217 else if (matching_module_spec.GetSymbolFileSpec()) 218 m_symfile_spec = matching_module_spec.GetSymbolFileSpec(); 219 220 // Copy the object name over 221 if (matching_module_spec.GetObjectName()) 222 m_object_name = matching_module_spec.GetObjectName(); 223 else 224 m_object_name = module_spec.GetObjectName(); 225 226 // Always trust the object offset (file offset) and object modification time 227 // (for mod time in a BSD static archive) of from the matching module 228 // specification 229 m_object_offset = matching_module_spec.GetObjectOffset(); 230 m_object_mod_time = matching_module_spec.GetObjectModificationTime(); 231 } 232 233 Module::Module(const FileSpec &file_spec, const ArchSpec &arch, 234 const ConstString *object_name, lldb::offset_t object_offset, 235 const llvm::sys::TimePoint<> &object_mod_time) 236 : m_mod_time(FileSystem::Instance().GetModificationTime(file_spec)), m_arch(arch), 237 m_file(file_spec), m_object_offset(object_offset), 238 m_object_mod_time(object_mod_time), m_file_has_changed(false), 239 m_first_file_changed_log(false) { 240 // Scope for locker below... 241 { 242 std::lock_guard<std::recursive_mutex> guard( 243 GetAllocationModuleCollectionMutex()); 244 GetModuleCollection().push_back(this); 245 } 246 247 if (object_name) 248 m_object_name = *object_name; 249 250 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_OBJECT | 251 LIBLLDB_LOG_MODULES)); 252 if (log != nullptr) 253 LLDB_LOGF(log, "%p Module::Module((%s) '%s%s%s%s')", 254 static_cast<void *>(this), m_arch.GetArchitectureName(), 255 m_file.GetPath().c_str(), m_object_name.IsEmpty() ? "" : "(", 256 m_object_name.IsEmpty() ? "" : m_object_name.AsCString(""), 257 m_object_name.IsEmpty() ? "" : ")"); 258 } 259 260 Module::Module() 261 : m_object_offset(0), m_file_has_changed(false), 262 m_first_file_changed_log(false) { 263 std::lock_guard<std::recursive_mutex> guard( 264 GetAllocationModuleCollectionMutex()); 265 GetModuleCollection().push_back(this); 266 } 267 268 Module::~Module() { 269 // Lock our module down while we tear everything down to make sure we don't 270 // get any access to the module while it is being destroyed 271 std::lock_guard<std::recursive_mutex> guard(m_mutex); 272 // Scope for locker below... 273 { 274 std::lock_guard<std::recursive_mutex> guard( 275 GetAllocationModuleCollectionMutex()); 276 ModuleCollection &modules = GetModuleCollection(); 277 ModuleCollection::iterator end = modules.end(); 278 ModuleCollection::iterator pos = std::find(modules.begin(), end, this); 279 assert(pos != end); 280 modules.erase(pos); 281 } 282 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_OBJECT | 283 LIBLLDB_LOG_MODULES)); 284 if (log != nullptr) 285 LLDB_LOGF(log, "%p Module::~Module((%s) '%s%s%s%s')", 286 static_cast<void *>(this), m_arch.GetArchitectureName(), 287 m_file.GetPath().c_str(), m_object_name.IsEmpty() ? "" : "(", 288 m_object_name.IsEmpty() ? "" : m_object_name.AsCString(""), 289 m_object_name.IsEmpty() ? "" : ")"); 290 // Release any auto pointers before we start tearing down our member 291 // variables since the object file and symbol files might need to make 292 // function calls back into this module object. The ordering is important 293 // here because symbol files can require the module object file. So we tear 294 // down the symbol file first, then the object file. 295 m_sections_up.reset(); 296 m_symfile_up.reset(); 297 m_objfile_sp.reset(); 298 } 299 300 ObjectFile *Module::GetMemoryObjectFile(const lldb::ProcessSP &process_sp, 301 lldb::addr_t header_addr, Status &error, 302 size_t size_to_read) { 303 if (m_objfile_sp) { 304 error.SetErrorString("object file already exists"); 305 } else { 306 std::lock_guard<std::recursive_mutex> guard(m_mutex); 307 if (process_sp) { 308 m_did_load_objfile = true; 309 auto data_up = std::make_unique<DataBufferHeap>(size_to_read, 0); 310 Status readmem_error; 311 const size_t bytes_read = 312 process_sp->ReadMemory(header_addr, data_up->GetBytes(), 313 data_up->GetByteSize(), readmem_error); 314 if (bytes_read < size_to_read) 315 data_up->SetByteSize(bytes_read); 316 if (data_up->GetByteSize() > 0) { 317 DataBufferSP data_sp(data_up.release()); 318 m_objfile_sp = ObjectFile::FindPlugin(shared_from_this(), process_sp, 319 header_addr, data_sp); 320 if (m_objfile_sp) { 321 StreamString s; 322 s.Printf("0x%16.16" PRIx64, header_addr); 323 m_object_name.SetString(s.GetString()); 324 325 // Once we get the object file, update our module with the object 326 // file's architecture since it might differ in vendor/os if some 327 // parts were unknown. 328 m_arch = m_objfile_sp->GetArchitecture(); 329 330 // Augment the arch with the target's information in case 331 // we are unable to extract the os/environment from memory. 332 m_arch.MergeFrom(process_sp->GetTarget().GetArchitecture()); 333 } else { 334 error.SetErrorString("unable to find suitable object file plug-in"); 335 } 336 } else { 337 error.SetErrorStringWithFormat("unable to read header from memory: %s", 338 readmem_error.AsCString()); 339 } 340 } else { 341 error.SetErrorString("invalid process"); 342 } 343 } 344 return m_objfile_sp.get(); 345 } 346 347 const lldb_private::UUID &Module::GetUUID() { 348 if (!m_did_set_uuid.load()) { 349 std::lock_guard<std::recursive_mutex> guard(m_mutex); 350 if (!m_did_set_uuid.load()) { 351 ObjectFile *obj_file = GetObjectFile(); 352 353 if (obj_file != nullptr) { 354 m_uuid = obj_file->GetUUID(); 355 m_did_set_uuid = true; 356 } 357 } 358 } 359 return m_uuid; 360 } 361 362 void Module::SetUUID(const lldb_private::UUID &uuid) { 363 std::lock_guard<std::recursive_mutex> guard(m_mutex); 364 if (!m_did_set_uuid) { 365 m_uuid = uuid; 366 m_did_set_uuid = true; 367 } else { 368 lldbassert(0 && "Attempting to overwrite the existing module UUID"); 369 } 370 } 371 372 llvm::Expected<TypeSystem &> 373 Module::GetTypeSystemForLanguage(LanguageType language) { 374 return m_type_system_map.GetTypeSystemForLanguage(language, this, true); 375 } 376 377 void Module::ParseAllDebugSymbols() { 378 std::lock_guard<std::recursive_mutex> guard(m_mutex); 379 size_t num_comp_units = GetNumCompileUnits(); 380 if (num_comp_units == 0) 381 return; 382 383 SymbolFile *symbols = GetSymbolFile(); 384 385 for (size_t cu_idx = 0; cu_idx < num_comp_units; cu_idx++) { 386 SymbolContext sc; 387 sc.module_sp = shared_from_this(); 388 sc.comp_unit = symbols->GetCompileUnitAtIndex(cu_idx).get(); 389 if (!sc.comp_unit) 390 continue; 391 392 symbols->ParseVariablesForContext(sc); 393 394 symbols->ParseFunctions(*sc.comp_unit); 395 396 sc.comp_unit->ForeachFunction([&sc, &symbols](const FunctionSP &f) { 397 symbols->ParseBlocksRecursive(*f); 398 399 // Parse the variables for this function and all its blocks 400 sc.function = f.get(); 401 symbols->ParseVariablesForContext(sc); 402 return false; 403 }); 404 405 // Parse all types for this compile unit 406 symbols->ParseTypes(*sc.comp_unit); 407 } 408 } 409 410 void Module::CalculateSymbolContext(SymbolContext *sc) { 411 sc->module_sp = shared_from_this(); 412 } 413 414 ModuleSP Module::CalculateSymbolContextModule() { return shared_from_this(); } 415 416 void Module::DumpSymbolContext(Stream *s) { 417 s->Printf(", Module{%p}", static_cast<void *>(this)); 418 } 419 420 size_t Module::GetNumCompileUnits() { 421 std::lock_guard<std::recursive_mutex> guard(m_mutex); 422 LLDB_SCOPED_TIMERF("Module::GetNumCompileUnits (module = %p)", 423 static_cast<void *>(this)); 424 if (SymbolFile *symbols = GetSymbolFile()) 425 return symbols->GetNumCompileUnits(); 426 return 0; 427 } 428 429 CompUnitSP Module::GetCompileUnitAtIndex(size_t index) { 430 std::lock_guard<std::recursive_mutex> guard(m_mutex); 431 size_t num_comp_units = GetNumCompileUnits(); 432 CompUnitSP cu_sp; 433 434 if (index < num_comp_units) { 435 if (SymbolFile *symbols = GetSymbolFile()) 436 cu_sp = symbols->GetCompileUnitAtIndex(index); 437 } 438 return cu_sp; 439 } 440 441 bool Module::ResolveFileAddress(lldb::addr_t vm_addr, Address &so_addr) { 442 std::lock_guard<std::recursive_mutex> guard(m_mutex); 443 LLDB_SCOPED_TIMERF("Module::ResolveFileAddress (vm_addr = 0x%" PRIx64 ")", 444 vm_addr); 445 SectionList *section_list = GetSectionList(); 446 if (section_list) 447 return so_addr.ResolveAddressUsingFileSections(vm_addr, section_list); 448 return false; 449 } 450 451 uint32_t Module::ResolveSymbolContextForAddress( 452 const Address &so_addr, lldb::SymbolContextItem resolve_scope, 453 SymbolContext &sc, bool resolve_tail_call_address) { 454 std::lock_guard<std::recursive_mutex> guard(m_mutex); 455 uint32_t resolved_flags = 0; 456 457 // Clear the result symbol context in case we don't find anything, but don't 458 // clear the target 459 sc.Clear(false); 460 461 // Get the section from the section/offset address. 462 SectionSP section_sp(so_addr.GetSection()); 463 464 // Make sure the section matches this module before we try and match anything 465 if (section_sp && section_sp->GetModule().get() == this) { 466 // If the section offset based address resolved itself, then this is the 467 // right module. 468 sc.module_sp = shared_from_this(); 469 resolved_flags |= eSymbolContextModule; 470 471 SymbolFile *symfile = GetSymbolFile(); 472 if (!symfile) 473 return resolved_flags; 474 475 // Resolve the compile unit, function, block, line table or line entry if 476 // requested. 477 if (resolve_scope & eSymbolContextCompUnit || 478 resolve_scope & eSymbolContextFunction || 479 resolve_scope & eSymbolContextBlock || 480 resolve_scope & eSymbolContextLineEntry || 481 resolve_scope & eSymbolContextVariable) { 482 resolved_flags |= 483 symfile->ResolveSymbolContext(so_addr, resolve_scope, sc); 484 } 485 486 // Resolve the symbol if requested, but don't re-look it up if we've 487 // already found it. 488 if (resolve_scope & eSymbolContextSymbol && 489 !(resolved_flags & eSymbolContextSymbol)) { 490 Symtab *symtab = symfile->GetSymtab(); 491 if (symtab && so_addr.IsSectionOffset()) { 492 Symbol *matching_symbol = nullptr; 493 494 symtab->ForEachSymbolContainingFileAddress( 495 so_addr.GetFileAddress(), 496 [&matching_symbol](Symbol *symbol) -> bool { 497 if (symbol->GetType() != eSymbolTypeInvalid) { 498 matching_symbol = symbol; 499 return false; // Stop iterating 500 } 501 return true; // Keep iterating 502 }); 503 sc.symbol = matching_symbol; 504 if (!sc.symbol && resolve_scope & eSymbolContextFunction && 505 !(resolved_flags & eSymbolContextFunction)) { 506 bool verify_unique = false; // No need to check again since 507 // ResolveSymbolContext failed to find a 508 // symbol at this address. 509 if (ObjectFile *obj_file = sc.module_sp->GetObjectFile()) 510 sc.symbol = 511 obj_file->ResolveSymbolForAddress(so_addr, verify_unique); 512 } 513 514 if (sc.symbol) { 515 if (sc.symbol->IsSynthetic()) { 516 // We have a synthetic symbol so lets check if the object file from 517 // the symbol file in the symbol vendor is different than the 518 // object file for the module, and if so search its symbol table to 519 // see if we can come up with a better symbol. For example dSYM 520 // files on MacOSX have an unstripped symbol table inside of them. 521 ObjectFile *symtab_objfile = symtab->GetObjectFile(); 522 if (symtab_objfile && symtab_objfile->IsStripped()) { 523 ObjectFile *symfile_objfile = symfile->GetObjectFile(); 524 if (symfile_objfile != symtab_objfile) { 525 Symtab *symfile_symtab = symfile_objfile->GetSymtab(); 526 if (symfile_symtab) { 527 Symbol *symbol = 528 symfile_symtab->FindSymbolContainingFileAddress( 529 so_addr.GetFileAddress()); 530 if (symbol && !symbol->IsSynthetic()) { 531 sc.symbol = symbol; 532 } 533 } 534 } 535 } 536 } 537 resolved_flags |= eSymbolContextSymbol; 538 } 539 } 540 } 541 542 // For function symbols, so_addr may be off by one. This is a convention 543 // consistent with FDE row indices in eh_frame sections, but requires extra 544 // logic here to permit symbol lookup for disassembly and unwind. 545 if (resolve_scope & eSymbolContextSymbol && 546 !(resolved_flags & eSymbolContextSymbol) && resolve_tail_call_address && 547 so_addr.IsSectionOffset()) { 548 Address previous_addr = so_addr; 549 previous_addr.Slide(-1); 550 551 bool do_resolve_tail_call_address = false; // prevent recursion 552 const uint32_t flags = ResolveSymbolContextForAddress( 553 previous_addr, resolve_scope, sc, do_resolve_tail_call_address); 554 if (flags & eSymbolContextSymbol) { 555 AddressRange addr_range; 556 if (sc.GetAddressRange(eSymbolContextFunction | eSymbolContextSymbol, 0, 557 false, addr_range)) { 558 if (addr_range.GetBaseAddress().GetSection() == 559 so_addr.GetSection()) { 560 // If the requested address is one past the address range of a 561 // function (i.e. a tail call), or the decremented address is the 562 // start of a function (i.e. some forms of trampoline), indicate 563 // that the symbol has been resolved. 564 if (so_addr.GetOffset() == 565 addr_range.GetBaseAddress().GetOffset() || 566 so_addr.GetOffset() == 567 addr_range.GetBaseAddress().GetOffset() + 568 addr_range.GetByteSize()) { 569 resolved_flags |= flags; 570 } 571 } else { 572 sc.symbol = 573 nullptr; // Don't trust the symbol if the sections didn't match. 574 } 575 } 576 } 577 } 578 } 579 return resolved_flags; 580 } 581 582 uint32_t Module::ResolveSymbolContextForFilePath( 583 const char *file_path, uint32_t line, bool check_inlines, 584 lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list) { 585 FileSpec file_spec(file_path); 586 return ResolveSymbolContextsForFileSpec(file_spec, line, check_inlines, 587 resolve_scope, sc_list); 588 } 589 590 uint32_t Module::ResolveSymbolContextsForFileSpec( 591 const FileSpec &file_spec, uint32_t line, bool check_inlines, 592 lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list) { 593 std::lock_guard<std::recursive_mutex> guard(m_mutex); 594 LLDB_SCOPED_TIMERF("Module::ResolveSymbolContextForFilePath (%s:%u, " 595 "check_inlines = %s, resolve_scope = 0x%8.8x)", 596 file_spec.GetPath().c_str(), line, 597 check_inlines ? "yes" : "no", resolve_scope); 598 599 const uint32_t initial_count = sc_list.GetSize(); 600 601 if (SymbolFile *symbols = GetSymbolFile()) 602 symbols->ResolveSymbolContext(file_spec, line, check_inlines, resolve_scope, 603 sc_list); 604 605 return sc_list.GetSize() - initial_count; 606 } 607 608 void Module::FindGlobalVariables(ConstString name, 609 const CompilerDeclContext &parent_decl_ctx, 610 size_t max_matches, VariableList &variables) { 611 if (SymbolFile *symbols = GetSymbolFile()) 612 symbols->FindGlobalVariables(name, parent_decl_ctx, max_matches, variables); 613 } 614 615 void Module::FindGlobalVariables(const RegularExpression ®ex, 616 size_t max_matches, VariableList &variables) { 617 SymbolFile *symbols = GetSymbolFile(); 618 if (symbols) 619 symbols->FindGlobalVariables(regex, max_matches, variables); 620 } 621 622 void Module::FindCompileUnits(const FileSpec &path, 623 SymbolContextList &sc_list) { 624 const size_t num_compile_units = GetNumCompileUnits(); 625 SymbolContext sc; 626 sc.module_sp = shared_from_this(); 627 for (size_t i = 0; i < num_compile_units; ++i) { 628 sc.comp_unit = GetCompileUnitAtIndex(i).get(); 629 if (sc.comp_unit) { 630 if (FileSpec::Match(path, sc.comp_unit->GetPrimaryFile())) 631 sc_list.Append(sc); 632 } 633 } 634 } 635 636 Module::LookupInfo::LookupInfo(ConstString name, 637 FunctionNameType name_type_mask, 638 LanguageType language) 639 : m_name(name), m_lookup_name(), m_language(language), 640 m_name_type_mask(eFunctionNameTypeNone), 641 m_match_name_after_lookup(false) { 642 const char *name_cstr = name.GetCString(); 643 llvm::StringRef basename; 644 llvm::StringRef context; 645 646 if (name_type_mask & eFunctionNameTypeAuto) { 647 if (CPlusPlusLanguage::IsCPPMangledName(name_cstr)) 648 m_name_type_mask = eFunctionNameTypeFull; 649 else if ((language == eLanguageTypeUnknown || 650 Language::LanguageIsObjC(language)) && 651 ObjCLanguage::IsPossibleObjCMethodName(name_cstr)) 652 m_name_type_mask = eFunctionNameTypeFull; 653 else if (Language::LanguageIsC(language)) { 654 m_name_type_mask = eFunctionNameTypeFull; 655 } else { 656 if ((language == eLanguageTypeUnknown || 657 Language::LanguageIsObjC(language)) && 658 ObjCLanguage::IsPossibleObjCSelector(name_cstr)) 659 m_name_type_mask |= eFunctionNameTypeSelector; 660 661 CPlusPlusLanguage::MethodName cpp_method(name); 662 basename = cpp_method.GetBasename(); 663 if (basename.empty()) { 664 if (CPlusPlusLanguage::ExtractContextAndIdentifier(name_cstr, context, 665 basename)) 666 m_name_type_mask |= (eFunctionNameTypeMethod | eFunctionNameTypeBase); 667 else 668 m_name_type_mask |= eFunctionNameTypeFull; 669 } else { 670 m_name_type_mask |= (eFunctionNameTypeMethod | eFunctionNameTypeBase); 671 } 672 } 673 } else { 674 m_name_type_mask = name_type_mask; 675 if (name_type_mask & eFunctionNameTypeMethod || 676 name_type_mask & eFunctionNameTypeBase) { 677 // If they've asked for a CPP method or function name and it can't be 678 // that, we don't even need to search for CPP methods or names. 679 CPlusPlusLanguage::MethodName cpp_method(name); 680 if (cpp_method.IsValid()) { 681 basename = cpp_method.GetBasename(); 682 683 if (!cpp_method.GetQualifiers().empty()) { 684 // There is a "const" or other qualifier following the end of the 685 // function parens, this can't be a eFunctionNameTypeBase 686 m_name_type_mask &= ~(eFunctionNameTypeBase); 687 if (m_name_type_mask == eFunctionNameTypeNone) 688 return; 689 } 690 } else { 691 // If the CPP method parser didn't manage to chop this up, try to fill 692 // in the base name if we can. If a::b::c is passed in, we need to just 693 // look up "c", and then we'll filter the result later. 694 CPlusPlusLanguage::ExtractContextAndIdentifier(name_cstr, context, 695 basename); 696 } 697 } 698 699 if (name_type_mask & eFunctionNameTypeSelector) { 700 if (!ObjCLanguage::IsPossibleObjCSelector(name_cstr)) { 701 m_name_type_mask &= ~(eFunctionNameTypeSelector); 702 if (m_name_type_mask == eFunctionNameTypeNone) 703 return; 704 } 705 } 706 707 // Still try and get a basename in case someone specifies a name type mask 708 // of eFunctionNameTypeFull and a name like "A::func" 709 if (basename.empty()) { 710 if (name_type_mask & eFunctionNameTypeFull && 711 !CPlusPlusLanguage::IsCPPMangledName(name_cstr)) { 712 CPlusPlusLanguage::MethodName cpp_method(name); 713 basename = cpp_method.GetBasename(); 714 if (basename.empty()) 715 CPlusPlusLanguage::ExtractContextAndIdentifier(name_cstr, context, 716 basename); 717 } 718 } 719 } 720 721 if (!basename.empty()) { 722 // The name supplied was a partial C++ path like "a::count". In this case 723 // we want to do a lookup on the basename "count" and then make sure any 724 // matching results contain "a::count" so that it would match "b::a::count" 725 // and "a::count". This is why we set "match_name_after_lookup" to true 726 m_lookup_name.SetString(basename); 727 m_match_name_after_lookup = true; 728 } else { 729 // The name is already correct, just use the exact name as supplied, and we 730 // won't need to check if any matches contain "name" 731 m_lookup_name = name; 732 m_match_name_after_lookup = false; 733 } 734 } 735 736 void Module::LookupInfo::Prune(SymbolContextList &sc_list, 737 size_t start_idx) const { 738 if (m_match_name_after_lookup && m_name) { 739 SymbolContext sc; 740 size_t i = start_idx; 741 while (i < sc_list.GetSize()) { 742 if (!sc_list.GetContextAtIndex(i, sc)) 743 break; 744 ConstString full_name(sc.GetFunctionName()); 745 if (full_name && 746 ::strstr(full_name.GetCString(), m_name.GetCString()) == nullptr) { 747 sc_list.RemoveContextAtIndex(i); 748 } else { 749 ++i; 750 } 751 } 752 } 753 754 // If we have only full name matches we might have tried to set breakpoint on 755 // "func" and specified eFunctionNameTypeFull, but we might have found 756 // "a::func()", "a::b::func()", "c::func()", "func()" and "func". Only 757 // "func()" and "func" should end up matching. 758 if (m_name_type_mask == eFunctionNameTypeFull) { 759 SymbolContext sc; 760 size_t i = start_idx; 761 while (i < sc_list.GetSize()) { 762 if (!sc_list.GetContextAtIndex(i, sc)) 763 break; 764 // Make sure the mangled and demangled names don't match before we try to 765 // pull anything out 766 ConstString mangled_name(sc.GetFunctionName(Mangled::ePreferMangled)); 767 ConstString full_name(sc.GetFunctionName()); 768 if (mangled_name != m_name && full_name != m_name) 769 { 770 CPlusPlusLanguage::MethodName cpp_method(full_name); 771 if (cpp_method.IsValid()) { 772 if (cpp_method.GetContext().empty()) { 773 if (cpp_method.GetBasename().compare(m_name.GetStringRef()) != 0) { 774 sc_list.RemoveContextAtIndex(i); 775 continue; 776 } 777 } else { 778 std::string qualified_name; 779 llvm::StringRef anon_prefix("(anonymous namespace)"); 780 if (cpp_method.GetContext() == anon_prefix) 781 qualified_name = cpp_method.GetBasename().str(); 782 else 783 qualified_name = cpp_method.GetScopeQualifiedName(); 784 if (qualified_name != m_name.GetCString()) { 785 sc_list.RemoveContextAtIndex(i); 786 continue; 787 } 788 } 789 } 790 } 791 ++i; 792 } 793 } 794 } 795 796 void Module::FindFunctions(ConstString name, 797 const CompilerDeclContext &parent_decl_ctx, 798 FunctionNameType name_type_mask, 799 bool include_symbols, bool include_inlines, 800 SymbolContextList &sc_list) { 801 const size_t old_size = sc_list.GetSize(); 802 803 // Find all the functions (not symbols, but debug information functions... 804 SymbolFile *symbols = GetSymbolFile(); 805 806 if (name_type_mask & eFunctionNameTypeAuto) { 807 LookupInfo lookup_info(name, name_type_mask, eLanguageTypeUnknown); 808 809 if (symbols) { 810 symbols->FindFunctions(lookup_info.GetLookupName(), parent_decl_ctx, 811 lookup_info.GetNameTypeMask(), include_inlines, 812 sc_list); 813 814 // Now check our symbol table for symbols that are code symbols if 815 // requested 816 if (include_symbols) { 817 Symtab *symtab = symbols->GetSymtab(); 818 if (symtab) 819 symtab->FindFunctionSymbols(lookup_info.GetLookupName(), 820 lookup_info.GetNameTypeMask(), sc_list); 821 } 822 } 823 824 const size_t new_size = sc_list.GetSize(); 825 826 if (old_size < new_size) 827 lookup_info.Prune(sc_list, old_size); 828 } else { 829 if (symbols) { 830 symbols->FindFunctions(name, parent_decl_ctx, name_type_mask, 831 include_inlines, sc_list); 832 833 // Now check our symbol table for symbols that are code symbols if 834 // requested 835 if (include_symbols) { 836 Symtab *symtab = symbols->GetSymtab(); 837 if (symtab) 838 symtab->FindFunctionSymbols(name, name_type_mask, sc_list); 839 } 840 } 841 } 842 } 843 844 void Module::FindFunctions(const RegularExpression ®ex, bool include_symbols, 845 bool include_inlines, 846 SymbolContextList &sc_list) { 847 const size_t start_size = sc_list.GetSize(); 848 849 if (SymbolFile *symbols = GetSymbolFile()) { 850 symbols->FindFunctions(regex, include_inlines, sc_list); 851 852 // Now check our symbol table for symbols that are code symbols if 853 // requested 854 if (include_symbols) { 855 Symtab *symtab = symbols->GetSymtab(); 856 if (symtab) { 857 std::vector<uint32_t> symbol_indexes; 858 symtab->AppendSymbolIndexesMatchingRegExAndType( 859 regex, eSymbolTypeAny, Symtab::eDebugAny, Symtab::eVisibilityAny, 860 symbol_indexes); 861 const size_t num_matches = symbol_indexes.size(); 862 if (num_matches) { 863 SymbolContext sc(this); 864 const size_t end_functions_added_index = sc_list.GetSize(); 865 size_t num_functions_added_to_sc_list = 866 end_functions_added_index - start_size; 867 if (num_functions_added_to_sc_list == 0) { 868 // No functions were added, just symbols, so we can just append 869 // them 870 for (size_t i = 0; i < num_matches; ++i) { 871 sc.symbol = symtab->SymbolAtIndex(symbol_indexes[i]); 872 SymbolType sym_type = sc.symbol->GetType(); 873 if (sc.symbol && (sym_type == eSymbolTypeCode || 874 sym_type == eSymbolTypeResolver)) 875 sc_list.Append(sc); 876 } 877 } else { 878 typedef std::map<lldb::addr_t, uint32_t> FileAddrToIndexMap; 879 FileAddrToIndexMap file_addr_to_index; 880 for (size_t i = start_size; i < end_functions_added_index; ++i) { 881 const SymbolContext &sc = sc_list[i]; 882 if (sc.block) 883 continue; 884 file_addr_to_index[sc.function->GetAddressRange() 885 .GetBaseAddress() 886 .GetFileAddress()] = i; 887 } 888 889 FileAddrToIndexMap::const_iterator end = file_addr_to_index.end(); 890 // Functions were added so we need to merge symbols into any 891 // existing function symbol contexts 892 for (size_t i = start_size; i < num_matches; ++i) { 893 sc.symbol = symtab->SymbolAtIndex(symbol_indexes[i]); 894 SymbolType sym_type = sc.symbol->GetType(); 895 if (sc.symbol && sc.symbol->ValueIsAddress() && 896 (sym_type == eSymbolTypeCode || 897 sym_type == eSymbolTypeResolver)) { 898 FileAddrToIndexMap::const_iterator pos = 899 file_addr_to_index.find( 900 sc.symbol->GetAddressRef().GetFileAddress()); 901 if (pos == end) 902 sc_list.Append(sc); 903 else 904 sc_list[pos->second].symbol = sc.symbol; 905 } 906 } 907 } 908 } 909 } 910 } 911 } 912 } 913 914 void Module::FindAddressesForLine(const lldb::TargetSP target_sp, 915 const FileSpec &file, uint32_t line, 916 Function *function, 917 std::vector<Address> &output_local, 918 std::vector<Address> &output_extern) { 919 SearchFilterByModule filter(target_sp, m_file); 920 AddressResolverFileLine resolver(file, line, true); 921 resolver.ResolveAddress(filter); 922 923 for (size_t n = 0; n < resolver.GetNumberOfAddresses(); n++) { 924 Address addr = resolver.GetAddressRangeAtIndex(n).GetBaseAddress(); 925 Function *f = addr.CalculateSymbolContextFunction(); 926 if (f && f == function) 927 output_local.push_back(addr); 928 else 929 output_extern.push_back(addr); 930 } 931 } 932 933 void Module::FindTypes_Impl( 934 ConstString name, const CompilerDeclContext &parent_decl_ctx, 935 size_t max_matches, 936 llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files, 937 TypeMap &types) { 938 LLDB_SCOPED_TIMER(); 939 if (SymbolFile *symbols = GetSymbolFile()) 940 symbols->FindTypes(name, parent_decl_ctx, max_matches, 941 searched_symbol_files, types); 942 } 943 944 void Module::FindTypesInNamespace(ConstString type_name, 945 const CompilerDeclContext &parent_decl_ctx, 946 size_t max_matches, TypeList &type_list) { 947 TypeMap types_map; 948 llvm::DenseSet<lldb_private::SymbolFile *> searched_symbol_files; 949 FindTypes_Impl(type_name, parent_decl_ctx, max_matches, searched_symbol_files, 950 types_map); 951 if (types_map.GetSize()) { 952 SymbolContext sc; 953 sc.module_sp = shared_from_this(); 954 sc.SortTypeList(types_map, type_list); 955 } 956 } 957 958 lldb::TypeSP Module::FindFirstType(const SymbolContext &sc, 959 ConstString name, bool exact_match) { 960 TypeList type_list; 961 llvm::DenseSet<lldb_private::SymbolFile *> searched_symbol_files; 962 FindTypes(name, exact_match, 1, searched_symbol_files, type_list); 963 if (type_list.GetSize()) 964 return type_list.GetTypeAtIndex(0); 965 return TypeSP(); 966 } 967 968 void Module::FindTypes( 969 ConstString name, bool exact_match, size_t max_matches, 970 llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files, 971 TypeList &types) { 972 const char *type_name_cstr = name.GetCString(); 973 llvm::StringRef type_scope; 974 llvm::StringRef type_basename; 975 TypeClass type_class = eTypeClassAny; 976 TypeMap typesmap; 977 978 if (Type::GetTypeScopeAndBasename(type_name_cstr, type_scope, type_basename, 979 type_class)) { 980 // Check if "name" starts with "::" which means the qualified type starts 981 // from the root namespace and implies and exact match. The typenames we 982 // get back from clang do not start with "::" so we need to strip this off 983 // in order to get the qualified names to match 984 exact_match = type_scope.consume_front("::"); 985 986 ConstString type_basename_const_str(type_basename); 987 FindTypes_Impl(type_basename_const_str, CompilerDeclContext(), max_matches, 988 searched_symbol_files, typesmap); 989 if (typesmap.GetSize()) 990 typesmap.RemoveMismatchedTypes(std::string(type_scope), 991 std::string(type_basename), type_class, 992 exact_match); 993 } else { 994 // The type is not in a namespace/class scope, just search for it by 995 // basename 996 if (type_class != eTypeClassAny && !type_basename.empty()) { 997 // The "type_name_cstr" will have been modified if we have a valid type 998 // class prefix (like "struct", "class", "union", "typedef" etc). 999 FindTypes_Impl(ConstString(type_basename), CompilerDeclContext(), 1000 UINT_MAX, searched_symbol_files, typesmap); 1001 typesmap.RemoveMismatchedTypes(std::string(type_scope), 1002 std::string(type_basename), type_class, 1003 exact_match); 1004 } else { 1005 FindTypes_Impl(name, CompilerDeclContext(), UINT_MAX, 1006 searched_symbol_files, typesmap); 1007 if (exact_match) { 1008 std::string name_str(name.AsCString("")); 1009 typesmap.RemoveMismatchedTypes(std::string(type_scope), name_str, 1010 type_class, exact_match); 1011 } 1012 } 1013 } 1014 if (typesmap.GetSize()) { 1015 SymbolContext sc; 1016 sc.module_sp = shared_from_this(); 1017 sc.SortTypeList(typesmap, types); 1018 } 1019 } 1020 1021 void Module::FindTypes( 1022 llvm::ArrayRef<CompilerContext> pattern, LanguageSet languages, 1023 llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files, 1024 TypeMap &types) { 1025 LLDB_SCOPED_TIMER(); 1026 if (SymbolFile *symbols = GetSymbolFile()) 1027 symbols->FindTypes(pattern, languages, searched_symbol_files, types); 1028 } 1029 1030 SymbolFile *Module::GetSymbolFile(bool can_create, Stream *feedback_strm) { 1031 if (!m_did_load_symfile.load()) { 1032 std::lock_guard<std::recursive_mutex> guard(m_mutex); 1033 if (!m_did_load_symfile.load() && can_create) { 1034 ObjectFile *obj_file = GetObjectFile(); 1035 if (obj_file != nullptr) { 1036 LLDB_SCOPED_TIMER(); 1037 m_symfile_up.reset( 1038 SymbolVendor::FindPlugin(shared_from_this(), feedback_strm)); 1039 m_did_load_symfile = true; 1040 } 1041 } 1042 } 1043 return m_symfile_up ? m_symfile_up->GetSymbolFile() : nullptr; 1044 } 1045 1046 Symtab *Module::GetSymtab() { 1047 if (SymbolFile *symbols = GetSymbolFile()) 1048 return symbols->GetSymtab(); 1049 return nullptr; 1050 } 1051 1052 void Module::SetFileSpecAndObjectName(const FileSpec &file, 1053 ConstString object_name) { 1054 // Container objects whose paths do not specify a file directly can call this 1055 // function to correct the file and object names. 1056 m_file = file; 1057 m_mod_time = FileSystem::Instance().GetModificationTime(file); 1058 m_object_name = object_name; 1059 } 1060 1061 const ArchSpec &Module::GetArchitecture() const { return m_arch; } 1062 1063 std::string Module::GetSpecificationDescription() const { 1064 std::string spec(GetFileSpec().GetPath()); 1065 if (m_object_name) { 1066 spec += '('; 1067 spec += m_object_name.GetCString(); 1068 spec += ')'; 1069 } 1070 return spec; 1071 } 1072 1073 void Module::GetDescription(llvm::raw_ostream &s, 1074 lldb::DescriptionLevel level) { 1075 std::lock_guard<std::recursive_mutex> guard(m_mutex); 1076 1077 if (level >= eDescriptionLevelFull) { 1078 if (m_arch.IsValid()) 1079 s << llvm::formatv("({0}) ", m_arch.GetArchitectureName()); 1080 } 1081 1082 if (level == eDescriptionLevelBrief) { 1083 const char *filename = m_file.GetFilename().GetCString(); 1084 if (filename) 1085 s << filename; 1086 } else { 1087 char path[PATH_MAX]; 1088 if (m_file.GetPath(path, sizeof(path))) 1089 s << path; 1090 } 1091 1092 const char *object_name = m_object_name.GetCString(); 1093 if (object_name) 1094 s << llvm::formatv("({0})", object_name); 1095 } 1096 1097 void Module::ReportError(const char *format, ...) { 1098 if (format && format[0]) { 1099 StreamString strm; 1100 strm.PutCString("error: "); 1101 GetDescription(strm.AsRawOstream(), lldb::eDescriptionLevelBrief); 1102 strm.PutChar(' '); 1103 va_list args; 1104 va_start(args, format); 1105 strm.PrintfVarArg(format, args); 1106 va_end(args); 1107 1108 const int format_len = strlen(format); 1109 if (format_len > 0) { 1110 const char last_char = format[format_len - 1]; 1111 if (last_char != '\n' && last_char != '\r') 1112 strm.EOL(); 1113 } 1114 Host::SystemLog(Host::eSystemLogError, "%s", strm.GetData()); 1115 } 1116 } 1117 1118 bool Module::FileHasChanged() const { 1119 // We have provided the DataBuffer for this module to avoid accessing the 1120 // filesystem. We never want to reload those files. 1121 if (m_data_sp) 1122 return false; 1123 if (!m_file_has_changed) 1124 m_file_has_changed = 1125 (FileSystem::Instance().GetModificationTime(m_file) != m_mod_time); 1126 return m_file_has_changed; 1127 } 1128 1129 void Module::ReportErrorIfModifyDetected(const char *format, ...) { 1130 if (!m_first_file_changed_log) { 1131 if (FileHasChanged()) { 1132 m_first_file_changed_log = true; 1133 if (format) { 1134 StreamString strm; 1135 strm.PutCString("error: the object file "); 1136 GetDescription(strm.AsRawOstream(), lldb::eDescriptionLevelFull); 1137 strm.PutCString(" has been modified\n"); 1138 1139 va_list args; 1140 va_start(args, format); 1141 strm.PrintfVarArg(format, args); 1142 va_end(args); 1143 1144 const int format_len = strlen(format); 1145 if (format_len > 0) { 1146 const char last_char = format[format_len - 1]; 1147 if (last_char != '\n' && last_char != '\r') 1148 strm.EOL(); 1149 } 1150 strm.PutCString("The debug session should be aborted as the original " 1151 "debug information has been overwritten.\n"); 1152 Host::SystemLog(Host::eSystemLogError, "%s", strm.GetData()); 1153 } 1154 } 1155 } 1156 } 1157 1158 void Module::ReportWarning(const char *format, ...) { 1159 if (format && format[0]) { 1160 StreamString strm; 1161 strm.PutCString("warning: "); 1162 GetDescription(strm.AsRawOstream(), lldb::eDescriptionLevelFull); 1163 strm.PutChar(' '); 1164 1165 va_list args; 1166 va_start(args, format); 1167 strm.PrintfVarArg(format, args); 1168 va_end(args); 1169 1170 const int format_len = strlen(format); 1171 if (format_len > 0) { 1172 const char last_char = format[format_len - 1]; 1173 if (last_char != '\n' && last_char != '\r') 1174 strm.EOL(); 1175 } 1176 Host::SystemLog(Host::eSystemLogWarning, "%s", strm.GetData()); 1177 } 1178 } 1179 1180 void Module::LogMessage(Log *log, const char *format, ...) { 1181 if (log != nullptr) { 1182 StreamString log_message; 1183 GetDescription(log_message.AsRawOstream(), lldb::eDescriptionLevelFull); 1184 log_message.PutCString(": "); 1185 va_list args; 1186 va_start(args, format); 1187 log_message.PrintfVarArg(format, args); 1188 va_end(args); 1189 log->PutCString(log_message.GetData()); 1190 } 1191 } 1192 1193 void Module::LogMessageVerboseBacktrace(Log *log, const char *format, ...) { 1194 if (log != nullptr) { 1195 StreamString log_message; 1196 GetDescription(log_message.AsRawOstream(), lldb::eDescriptionLevelFull); 1197 log_message.PutCString(": "); 1198 va_list args; 1199 va_start(args, format); 1200 log_message.PrintfVarArg(format, args); 1201 va_end(args); 1202 if (log->GetVerbose()) { 1203 std::string back_trace; 1204 llvm::raw_string_ostream stream(back_trace); 1205 llvm::sys::PrintStackTrace(stream); 1206 log_message.PutCString(back_trace); 1207 } 1208 log->PutCString(log_message.GetData()); 1209 } 1210 } 1211 1212 void Module::Dump(Stream *s) { 1213 std::lock_guard<std::recursive_mutex> guard(m_mutex); 1214 // s->Printf("%.*p: ", (int)sizeof(void*) * 2, this); 1215 s->Indent(); 1216 s->Printf("Module %s%s%s%s\n", m_file.GetPath().c_str(), 1217 m_object_name ? "(" : "", 1218 m_object_name ? m_object_name.GetCString() : "", 1219 m_object_name ? ")" : ""); 1220 1221 s->IndentMore(); 1222 1223 ObjectFile *objfile = GetObjectFile(); 1224 if (objfile) 1225 objfile->Dump(s); 1226 1227 if (SymbolFile *symbols = GetSymbolFile()) 1228 symbols->Dump(*s); 1229 1230 s->IndentLess(); 1231 } 1232 1233 ConstString Module::GetObjectName() const { return m_object_name; } 1234 1235 ObjectFile *Module::GetObjectFile() { 1236 if (!m_did_load_objfile.load()) { 1237 std::lock_guard<std::recursive_mutex> guard(m_mutex); 1238 if (!m_did_load_objfile.load()) { 1239 LLDB_SCOPED_TIMERF("Module::GetObjectFile () module = %s", 1240 GetFileSpec().GetFilename().AsCString("")); 1241 lldb::offset_t data_offset = 0; 1242 lldb::offset_t file_size = 0; 1243 1244 if (m_data_sp) 1245 file_size = m_data_sp->GetByteSize(); 1246 else if (m_file) 1247 file_size = FileSystem::Instance().GetByteSize(m_file); 1248 1249 if (file_size > m_object_offset) { 1250 m_did_load_objfile = true; 1251 // FindPlugin will modify its data_sp argument. Do not let it 1252 // modify our m_data_sp member. 1253 auto data_sp = m_data_sp; 1254 m_objfile_sp = ObjectFile::FindPlugin( 1255 shared_from_this(), &m_file, m_object_offset, 1256 file_size - m_object_offset, data_sp, data_offset); 1257 if (m_objfile_sp) { 1258 // Once we get the object file, update our module with the object 1259 // file's architecture since it might differ in vendor/os if some 1260 // parts were unknown. But since the matching arch might already be 1261 // more specific than the generic COFF architecture, only merge in 1262 // those values that overwrite unspecified unknown values. 1263 m_arch.MergeFrom(m_objfile_sp->GetArchitecture()); 1264 } else { 1265 ReportError("failed to load objfile for %s", 1266 GetFileSpec().GetPath().c_str()); 1267 } 1268 } 1269 } 1270 } 1271 return m_objfile_sp.get(); 1272 } 1273 1274 SectionList *Module::GetSectionList() { 1275 // Populate m_sections_up with sections from objfile. 1276 if (!m_sections_up) { 1277 ObjectFile *obj_file = GetObjectFile(); 1278 if (obj_file != nullptr) 1279 obj_file->CreateSections(*GetUnifiedSectionList()); 1280 } 1281 return m_sections_up.get(); 1282 } 1283 1284 void Module::SectionFileAddressesChanged() { 1285 ObjectFile *obj_file = GetObjectFile(); 1286 if (obj_file) 1287 obj_file->SectionFileAddressesChanged(); 1288 if (SymbolFile *symbols = GetSymbolFile()) 1289 symbols->SectionFileAddressesChanged(); 1290 } 1291 1292 UnwindTable &Module::GetUnwindTable() { 1293 if (!m_unwind_table) 1294 m_unwind_table.emplace(*this); 1295 return *m_unwind_table; 1296 } 1297 1298 SectionList *Module::GetUnifiedSectionList() { 1299 if (!m_sections_up) 1300 m_sections_up = std::make_unique<SectionList>(); 1301 return m_sections_up.get(); 1302 } 1303 1304 const Symbol *Module::FindFirstSymbolWithNameAndType(ConstString name, 1305 SymbolType symbol_type) { 1306 LLDB_SCOPED_TIMERF( 1307 "Module::FindFirstSymbolWithNameAndType (name = %s, type = %i)", 1308 name.AsCString(), symbol_type); 1309 if (Symtab *symtab = GetSymtab()) 1310 return symtab->FindFirstSymbolWithNameAndType( 1311 name, symbol_type, Symtab::eDebugAny, Symtab::eVisibilityAny); 1312 return nullptr; 1313 } 1314 void Module::SymbolIndicesToSymbolContextList( 1315 Symtab *symtab, std::vector<uint32_t> &symbol_indexes, 1316 SymbolContextList &sc_list) { 1317 // No need to protect this call using m_mutex all other method calls are 1318 // already thread safe. 1319 1320 size_t num_indices = symbol_indexes.size(); 1321 if (num_indices > 0) { 1322 SymbolContext sc; 1323 CalculateSymbolContext(&sc); 1324 for (size_t i = 0; i < num_indices; i++) { 1325 sc.symbol = symtab->SymbolAtIndex(symbol_indexes[i]); 1326 if (sc.symbol) 1327 sc_list.Append(sc); 1328 } 1329 } 1330 } 1331 1332 void Module::FindFunctionSymbols(ConstString name, 1333 uint32_t name_type_mask, 1334 SymbolContextList &sc_list) { 1335 LLDB_SCOPED_TIMERF("Module::FindSymbolsFunctions (name = %s, mask = 0x%8.8x)", 1336 name.AsCString(), name_type_mask); 1337 if (Symtab *symtab = GetSymtab()) 1338 symtab->FindFunctionSymbols(name, name_type_mask, sc_list); 1339 } 1340 1341 void Module::FindSymbolsWithNameAndType(ConstString name, 1342 SymbolType symbol_type, 1343 SymbolContextList &sc_list) { 1344 // No need to protect this call using m_mutex all other method calls are 1345 // already thread safe. 1346 LLDB_SCOPED_TIMERF( 1347 "Module::FindSymbolsWithNameAndType (name = %s, type = %i)", 1348 name.AsCString(), symbol_type); 1349 if (Symtab *symtab = GetSymtab()) { 1350 std::vector<uint32_t> symbol_indexes; 1351 symtab->FindAllSymbolsWithNameAndType(name, symbol_type, symbol_indexes); 1352 SymbolIndicesToSymbolContextList(symtab, symbol_indexes, sc_list); 1353 } 1354 } 1355 1356 void Module::FindSymbolsMatchingRegExAndType(const RegularExpression ®ex, 1357 SymbolType symbol_type, 1358 SymbolContextList &sc_list) { 1359 // No need to protect this call using m_mutex all other method calls are 1360 // already thread safe. 1361 LLDB_SCOPED_TIMERF( 1362 "Module::FindSymbolsMatchingRegExAndType (regex = %s, type = %i)", 1363 regex.GetText().str().c_str(), symbol_type); 1364 if (Symtab *symtab = GetSymtab()) { 1365 std::vector<uint32_t> symbol_indexes; 1366 symtab->FindAllSymbolsMatchingRexExAndType( 1367 regex, symbol_type, Symtab::eDebugAny, Symtab::eVisibilityAny, 1368 symbol_indexes); 1369 SymbolIndicesToSymbolContextList(symtab, symbol_indexes, sc_list); 1370 } 1371 } 1372 1373 void Module::PreloadSymbols() { 1374 std::lock_guard<std::recursive_mutex> guard(m_mutex); 1375 SymbolFile *sym_file = GetSymbolFile(); 1376 if (!sym_file) 1377 return; 1378 1379 // Prime the symbol file first, since it adds symbols to the symbol table. 1380 sym_file->PreloadSymbols(); 1381 1382 // Now we can prime the symbol table. 1383 if (Symtab *symtab = sym_file->GetSymtab()) 1384 symtab->PreloadSymbols(); 1385 } 1386 1387 void Module::SetSymbolFileFileSpec(const FileSpec &file) { 1388 if (!FileSystem::Instance().Exists(file)) 1389 return; 1390 if (m_symfile_up) { 1391 // Remove any sections in the unified section list that come from the 1392 // current symbol vendor. 1393 SectionList *section_list = GetSectionList(); 1394 SymbolFile *symbol_file = GetSymbolFile(); 1395 if (section_list && symbol_file) { 1396 ObjectFile *obj_file = symbol_file->GetObjectFile(); 1397 // Make sure we have an object file and that the symbol vendor's objfile 1398 // isn't the same as the module's objfile before we remove any sections 1399 // for it... 1400 if (obj_file) { 1401 // Check to make sure we aren't trying to specify the file we already 1402 // have 1403 if (obj_file->GetFileSpec() == file) { 1404 // We are being told to add the exact same file that we already have 1405 // we don't have to do anything. 1406 return; 1407 } 1408 1409 // Cleare the current symtab as we are going to replace it with a new 1410 // one 1411 obj_file->ClearSymtab(); 1412 1413 // Clear the unwind table too, as that may also be affected by the 1414 // symbol file information. 1415 m_unwind_table.reset(); 1416 1417 // The symbol file might be a directory bundle ("/tmp/a.out.dSYM") 1418 // instead of a full path to the symbol file within the bundle 1419 // ("/tmp/a.out.dSYM/Contents/Resources/DWARF/a.out"). So we need to 1420 // check this 1421 1422 if (FileSystem::Instance().IsDirectory(file)) { 1423 std::string new_path(file.GetPath()); 1424 std::string old_path(obj_file->GetFileSpec().GetPath()); 1425 if (llvm::StringRef(old_path).startswith(new_path)) { 1426 // We specified the same bundle as the symbol file that we already 1427 // have 1428 return; 1429 } 1430 } 1431 1432 if (obj_file != m_objfile_sp.get()) { 1433 size_t num_sections = section_list->GetNumSections(0); 1434 for (size_t idx = num_sections; idx > 0; --idx) { 1435 lldb::SectionSP section_sp( 1436 section_list->GetSectionAtIndex(idx - 1)); 1437 if (section_sp->GetObjectFile() == obj_file) { 1438 section_list->DeleteSection(idx - 1); 1439 } 1440 } 1441 } 1442 } 1443 } 1444 // Keep all old symbol files around in case there are any lingering type 1445 // references in any SBValue objects that might have been handed out. 1446 m_old_symfiles.push_back(std::move(m_symfile_up)); 1447 } 1448 m_symfile_spec = file; 1449 m_symfile_up.reset(); 1450 m_did_load_symfile = false; 1451 } 1452 1453 bool Module::IsExecutable() { 1454 if (GetObjectFile() == nullptr) 1455 return false; 1456 else 1457 return GetObjectFile()->IsExecutable(); 1458 } 1459 1460 bool Module::IsLoadedInTarget(Target *target) { 1461 ObjectFile *obj_file = GetObjectFile(); 1462 if (obj_file) { 1463 SectionList *sections = GetSectionList(); 1464 if (sections != nullptr) { 1465 size_t num_sections = sections->GetSize(); 1466 for (size_t sect_idx = 0; sect_idx < num_sections; sect_idx++) { 1467 SectionSP section_sp = sections->GetSectionAtIndex(sect_idx); 1468 if (section_sp->GetLoadBaseAddress(target) != LLDB_INVALID_ADDRESS) { 1469 return true; 1470 } 1471 } 1472 } 1473 } 1474 return false; 1475 } 1476 1477 bool Module::LoadScriptingResourceInTarget(Target *target, Status &error, 1478 Stream *feedback_stream) { 1479 if (!target) { 1480 error.SetErrorString("invalid destination Target"); 1481 return false; 1482 } 1483 1484 LoadScriptFromSymFile should_load = 1485 target->TargetProperties::GetLoadScriptFromSymbolFile(); 1486 1487 if (should_load == eLoadScriptFromSymFileFalse) 1488 return false; 1489 1490 Debugger &debugger = target->GetDebugger(); 1491 const ScriptLanguage script_language = debugger.GetScriptLanguage(); 1492 if (script_language != eScriptLanguageNone) { 1493 1494 PlatformSP platform_sp(target->GetPlatform()); 1495 1496 if (!platform_sp) { 1497 error.SetErrorString("invalid Platform"); 1498 return false; 1499 } 1500 1501 FileSpecList file_specs = platform_sp->LocateExecutableScriptingResources( 1502 target, *this, feedback_stream); 1503 1504 const uint32_t num_specs = file_specs.GetSize(); 1505 if (num_specs) { 1506 ScriptInterpreter *script_interpreter = debugger.GetScriptInterpreter(); 1507 if (script_interpreter) { 1508 for (uint32_t i = 0; i < num_specs; ++i) { 1509 FileSpec scripting_fspec(file_specs.GetFileSpecAtIndex(i)); 1510 if (scripting_fspec && 1511 FileSystem::Instance().Exists(scripting_fspec)) { 1512 if (should_load == eLoadScriptFromSymFileWarn) { 1513 if (feedback_stream) 1514 feedback_stream->Printf( 1515 "warning: '%s' contains a debug script. To run this script " 1516 "in " 1517 "this debug session:\n\n command script import " 1518 "\"%s\"\n\n" 1519 "To run all discovered debug scripts in this session:\n\n" 1520 " settings set target.load-script-from-symbol-file " 1521 "true\n", 1522 GetFileSpec().GetFileNameStrippingExtension().GetCString(), 1523 scripting_fspec.GetPath().c_str()); 1524 return false; 1525 } 1526 StreamString scripting_stream; 1527 scripting_fspec.Dump(scripting_stream.AsRawOstream()); 1528 const bool init_lldb_globals = false; 1529 bool did_load = script_interpreter->LoadScriptingModule( 1530 scripting_stream.GetData(), init_lldb_globals, error); 1531 if (!did_load) 1532 return false; 1533 } 1534 } 1535 } else { 1536 error.SetErrorString("invalid ScriptInterpreter"); 1537 return false; 1538 } 1539 } 1540 } 1541 return true; 1542 } 1543 1544 bool Module::SetArchitecture(const ArchSpec &new_arch) { 1545 if (!m_arch.IsValid()) { 1546 m_arch = new_arch; 1547 return true; 1548 } 1549 return m_arch.IsCompatibleMatch(new_arch); 1550 } 1551 1552 bool Module::SetLoadAddress(Target &target, lldb::addr_t value, 1553 bool value_is_offset, bool &changed) { 1554 ObjectFile *object_file = GetObjectFile(); 1555 if (object_file != nullptr) { 1556 changed = object_file->SetLoadAddress(target, value, value_is_offset); 1557 return true; 1558 } else { 1559 changed = false; 1560 } 1561 return false; 1562 } 1563 1564 bool Module::MatchesModuleSpec(const ModuleSpec &module_ref) { 1565 const UUID &uuid = module_ref.GetUUID(); 1566 1567 if (uuid.IsValid()) { 1568 // If the UUID matches, then nothing more needs to match... 1569 return (uuid == GetUUID()); 1570 } 1571 1572 const FileSpec &file_spec = module_ref.GetFileSpec(); 1573 if (!FileSpec::Match(file_spec, m_file) && 1574 !FileSpec::Match(file_spec, m_platform_file)) 1575 return false; 1576 1577 const FileSpec &platform_file_spec = module_ref.GetPlatformFileSpec(); 1578 if (!FileSpec::Match(platform_file_spec, GetPlatformFileSpec())) 1579 return false; 1580 1581 const ArchSpec &arch = module_ref.GetArchitecture(); 1582 if (arch.IsValid()) { 1583 if (!m_arch.IsCompatibleMatch(arch)) 1584 return false; 1585 } 1586 1587 ConstString object_name = module_ref.GetObjectName(); 1588 if (object_name) { 1589 if (object_name != GetObjectName()) 1590 return false; 1591 } 1592 return true; 1593 } 1594 1595 bool Module::FindSourceFile(const FileSpec &orig_spec, 1596 FileSpec &new_spec) const { 1597 std::lock_guard<std::recursive_mutex> guard(m_mutex); 1598 return m_source_mappings.FindFile(orig_spec, new_spec); 1599 } 1600 1601 bool Module::RemapSourceFile(llvm::StringRef path, 1602 std::string &new_path) const { 1603 std::lock_guard<std::recursive_mutex> guard(m_mutex); 1604 return m_source_mappings.RemapPath(path, new_path); 1605 } 1606 1607 void Module::RegisterXcodeSDK(llvm::StringRef sdk_name, llvm::StringRef sysroot) { 1608 XcodeSDK sdk(sdk_name.str()); 1609 ConstString sdk_path(HostInfo::GetXcodeSDKPath(sdk)); 1610 if (!sdk_path) 1611 return; 1612 // If the SDK changed for a previously registered source path, update it. 1613 // This could happend with -fdebug-prefix-map, otherwise it's unlikely. 1614 ConstString sysroot_cs(sysroot); 1615 if (!m_source_mappings.Replace(sysroot_cs, sdk_path, true)) 1616 // In the general case, however, append it to the list. 1617 m_source_mappings.Append(sysroot_cs, sdk_path, false); 1618 } 1619 1620 bool Module::MergeArchitecture(const ArchSpec &arch_spec) { 1621 if (!arch_spec.IsValid()) 1622 return false; 1623 LLDB_LOG(GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT | LIBLLDB_LOG_MODULES), 1624 "module has arch %s, merging/replacing with arch %s", 1625 m_arch.GetTriple().getTriple().c_str(), 1626 arch_spec.GetTriple().getTriple().c_str()); 1627 if (!m_arch.IsCompatibleMatch(arch_spec)) { 1628 // The new architecture is different, we just need to replace it. 1629 return SetArchitecture(arch_spec); 1630 } 1631 1632 // Merge bits from arch_spec into "merged_arch" and set our architecture. 1633 ArchSpec merged_arch(m_arch); 1634 merged_arch.MergeFrom(arch_spec); 1635 // SetArchitecture() is a no-op if m_arch is already valid. 1636 m_arch = ArchSpec(); 1637 return SetArchitecture(merged_arch); 1638 } 1639 1640 llvm::VersionTuple Module::GetVersion() { 1641 if (ObjectFile *obj_file = GetObjectFile()) 1642 return obj_file->GetVersion(); 1643 return llvm::VersionTuple(); 1644 } 1645 1646 bool Module::GetIsDynamicLinkEditor() { 1647 ObjectFile *obj_file = GetObjectFile(); 1648 1649 if (obj_file) 1650 return obj_file->GetIsDynamicLinkEditor(); 1651 1652 return false; 1653 } 1654