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 <cassert> 63 #include <cinttypes> 64 #include <cstdarg> 65 #include <cstdint> 66 #include <cstring> 67 #include <map> 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() : m_file_has_changed(false), m_first_file_changed_log(false) { 261 std::lock_guard<std::recursive_mutex> guard( 262 GetAllocationModuleCollectionMutex()); 263 GetModuleCollection().push_back(this); 264 } 265 266 Module::~Module() { 267 // Lock our module down while we tear everything down to make sure we don't 268 // get any access to the module while it is being destroyed 269 std::lock_guard<std::recursive_mutex> guard(m_mutex); 270 // Scope for locker below... 271 { 272 std::lock_guard<std::recursive_mutex> guard( 273 GetAllocationModuleCollectionMutex()); 274 ModuleCollection &modules = GetModuleCollection(); 275 ModuleCollection::iterator end = modules.end(); 276 ModuleCollection::iterator pos = std::find(modules.begin(), end, this); 277 assert(pos != end); 278 modules.erase(pos); 279 } 280 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_OBJECT | 281 LIBLLDB_LOG_MODULES)); 282 if (log != nullptr) 283 LLDB_LOGF(log, "%p Module::~Module((%s) '%s%s%s%s')", 284 static_cast<void *>(this), m_arch.GetArchitectureName(), 285 m_file.GetPath().c_str(), m_object_name.IsEmpty() ? "" : "(", 286 m_object_name.IsEmpty() ? "" : m_object_name.AsCString(""), 287 m_object_name.IsEmpty() ? "" : ")"); 288 // Release any auto pointers before we start tearing down our member 289 // variables since the object file and symbol files might need to make 290 // function calls back into this module object. The ordering is important 291 // here because symbol files can require the module object file. So we tear 292 // down the symbol file first, then the object file. 293 m_sections_up.reset(); 294 m_symfile_up.reset(); 295 m_objfile_sp.reset(); 296 } 297 298 ObjectFile *Module::GetMemoryObjectFile(const lldb::ProcessSP &process_sp, 299 lldb::addr_t header_addr, Status &error, 300 size_t size_to_read) { 301 if (m_objfile_sp) { 302 error.SetErrorString("object file already exists"); 303 } else { 304 std::lock_guard<std::recursive_mutex> guard(m_mutex); 305 if (process_sp) { 306 m_did_load_objfile = true; 307 auto data_up = std::make_unique<DataBufferHeap>(size_to_read, 0); 308 Status readmem_error; 309 const size_t bytes_read = 310 process_sp->ReadMemory(header_addr, data_up->GetBytes(), 311 data_up->GetByteSize(), readmem_error); 312 if (bytes_read < size_to_read) 313 data_up->SetByteSize(bytes_read); 314 if (data_up->GetByteSize() > 0) { 315 DataBufferSP data_sp(data_up.release()); 316 m_objfile_sp = ObjectFile::FindPlugin(shared_from_this(), process_sp, 317 header_addr, data_sp); 318 if (m_objfile_sp) { 319 StreamString s; 320 s.Printf("0x%16.16" PRIx64, header_addr); 321 m_object_name.SetString(s.GetString()); 322 323 // Once we get the object file, update our module with the object 324 // file's architecture since it might differ in vendor/os if some 325 // parts were unknown. 326 m_arch = m_objfile_sp->GetArchitecture(); 327 328 // Augment the arch with the target's information in case 329 // we are unable to extract the os/environment from memory. 330 m_arch.MergeFrom(process_sp->GetTarget().GetArchitecture()); 331 } else { 332 error.SetErrorString("unable to find suitable object file plug-in"); 333 } 334 } else { 335 error.SetErrorStringWithFormat("unable to read header from memory: %s", 336 readmem_error.AsCString()); 337 } 338 } else { 339 error.SetErrorString("invalid process"); 340 } 341 } 342 return m_objfile_sp.get(); 343 } 344 345 const lldb_private::UUID &Module::GetUUID() { 346 if (!m_did_set_uuid.load()) { 347 std::lock_guard<std::recursive_mutex> guard(m_mutex); 348 if (!m_did_set_uuid.load()) { 349 ObjectFile *obj_file = GetObjectFile(); 350 351 if (obj_file != nullptr) { 352 m_uuid = obj_file->GetUUID(); 353 m_did_set_uuid = true; 354 } 355 } 356 } 357 return m_uuid; 358 } 359 360 void Module::SetUUID(const lldb_private::UUID &uuid) { 361 std::lock_guard<std::recursive_mutex> guard(m_mutex); 362 if (!m_did_set_uuid) { 363 m_uuid = uuid; 364 m_did_set_uuid = true; 365 } else { 366 lldbassert(0 && "Attempting to overwrite the existing module UUID"); 367 } 368 } 369 370 llvm::Expected<TypeSystem &> 371 Module::GetTypeSystemForLanguage(LanguageType language) { 372 return m_type_system_map.GetTypeSystemForLanguage(language, this, true); 373 } 374 375 void Module::ParseAllDebugSymbols() { 376 std::lock_guard<std::recursive_mutex> guard(m_mutex); 377 size_t num_comp_units = GetNumCompileUnits(); 378 if (num_comp_units == 0) 379 return; 380 381 SymbolFile *symbols = GetSymbolFile(); 382 383 for (size_t cu_idx = 0; cu_idx < num_comp_units; cu_idx++) { 384 SymbolContext sc; 385 sc.module_sp = shared_from_this(); 386 sc.comp_unit = symbols->GetCompileUnitAtIndex(cu_idx).get(); 387 if (!sc.comp_unit) 388 continue; 389 390 symbols->ParseVariablesForContext(sc); 391 392 symbols->ParseFunctions(*sc.comp_unit); 393 394 sc.comp_unit->ForeachFunction([&sc, &symbols](const FunctionSP &f) { 395 symbols->ParseBlocksRecursive(*f); 396 397 // Parse the variables for this function and all its blocks 398 sc.function = f.get(); 399 symbols->ParseVariablesForContext(sc); 400 return false; 401 }); 402 403 // Parse all types for this compile unit 404 symbols->ParseTypes(*sc.comp_unit); 405 } 406 } 407 408 void Module::CalculateSymbolContext(SymbolContext *sc) { 409 sc->module_sp = shared_from_this(); 410 } 411 412 ModuleSP Module::CalculateSymbolContextModule() { return shared_from_this(); } 413 414 void Module::DumpSymbolContext(Stream *s) { 415 s->Printf(", Module{%p}", static_cast<void *>(this)); 416 } 417 418 size_t Module::GetNumCompileUnits() { 419 std::lock_guard<std::recursive_mutex> guard(m_mutex); 420 LLDB_SCOPED_TIMERF("Module::GetNumCompileUnits (module = %p)", 421 static_cast<void *>(this)); 422 if (SymbolFile *symbols = GetSymbolFile()) 423 return symbols->GetNumCompileUnits(); 424 return 0; 425 } 426 427 CompUnitSP Module::GetCompileUnitAtIndex(size_t index) { 428 std::lock_guard<std::recursive_mutex> guard(m_mutex); 429 size_t num_comp_units = GetNumCompileUnits(); 430 CompUnitSP cu_sp; 431 432 if (index < num_comp_units) { 433 if (SymbolFile *symbols = GetSymbolFile()) 434 cu_sp = symbols->GetCompileUnitAtIndex(index); 435 } 436 return cu_sp; 437 } 438 439 bool Module::ResolveFileAddress(lldb::addr_t vm_addr, Address &so_addr) { 440 std::lock_guard<std::recursive_mutex> guard(m_mutex); 441 SectionList *section_list = GetSectionList(); 442 if (section_list) 443 return so_addr.ResolveAddressUsingFileSections(vm_addr, section_list); 444 return false; 445 } 446 447 uint32_t Module::ResolveSymbolContextForAddress( 448 const Address &so_addr, lldb::SymbolContextItem resolve_scope, 449 SymbolContext &sc, bool resolve_tail_call_address) { 450 std::lock_guard<std::recursive_mutex> guard(m_mutex); 451 uint32_t resolved_flags = 0; 452 453 // Clear the result symbol context in case we don't find anything, but don't 454 // clear the target 455 sc.Clear(false); 456 457 // Get the section from the section/offset address. 458 SectionSP section_sp(so_addr.GetSection()); 459 460 // Make sure the section matches this module before we try and match anything 461 if (section_sp && section_sp->GetModule().get() == this) { 462 // If the section offset based address resolved itself, then this is the 463 // right module. 464 sc.module_sp = shared_from_this(); 465 resolved_flags |= eSymbolContextModule; 466 467 SymbolFile *symfile = GetSymbolFile(); 468 if (!symfile) 469 return resolved_flags; 470 471 // Resolve the compile unit, function, block, line table or line entry if 472 // requested. 473 if (resolve_scope & eSymbolContextCompUnit || 474 resolve_scope & eSymbolContextFunction || 475 resolve_scope & eSymbolContextBlock || 476 resolve_scope & eSymbolContextLineEntry || 477 resolve_scope & eSymbolContextVariable) { 478 resolved_flags |= 479 symfile->ResolveSymbolContext(so_addr, resolve_scope, sc); 480 } 481 482 // Resolve the symbol if requested, but don't re-look it up if we've 483 // already found it. 484 if (resolve_scope & eSymbolContextSymbol && 485 !(resolved_flags & eSymbolContextSymbol)) { 486 Symtab *symtab = symfile->GetSymtab(); 487 if (symtab && so_addr.IsSectionOffset()) { 488 Symbol *matching_symbol = nullptr; 489 490 symtab->ForEachSymbolContainingFileAddress( 491 so_addr.GetFileAddress(), 492 [&matching_symbol](Symbol *symbol) -> bool { 493 if (symbol->GetType() != eSymbolTypeInvalid) { 494 matching_symbol = symbol; 495 return false; // Stop iterating 496 } 497 return true; // Keep iterating 498 }); 499 sc.symbol = matching_symbol; 500 if (!sc.symbol && resolve_scope & eSymbolContextFunction && 501 !(resolved_flags & eSymbolContextFunction)) { 502 bool verify_unique = false; // No need to check again since 503 // ResolveSymbolContext failed to find a 504 // symbol at this address. 505 if (ObjectFile *obj_file = sc.module_sp->GetObjectFile()) 506 sc.symbol = 507 obj_file->ResolveSymbolForAddress(so_addr, verify_unique); 508 } 509 510 if (sc.symbol) { 511 if (sc.symbol->IsSynthetic()) { 512 // We have a synthetic symbol so lets check if the object file from 513 // the symbol file in the symbol vendor is different than the 514 // object file for the module, and if so search its symbol table to 515 // see if we can come up with a better symbol. For example dSYM 516 // files on MacOSX have an unstripped symbol table inside of them. 517 ObjectFile *symtab_objfile = symtab->GetObjectFile(); 518 if (symtab_objfile && symtab_objfile->IsStripped()) { 519 ObjectFile *symfile_objfile = symfile->GetObjectFile(); 520 if (symfile_objfile != symtab_objfile) { 521 Symtab *symfile_symtab = symfile_objfile->GetSymtab(); 522 if (symfile_symtab) { 523 Symbol *symbol = 524 symfile_symtab->FindSymbolContainingFileAddress( 525 so_addr.GetFileAddress()); 526 if (symbol && !symbol->IsSynthetic()) { 527 sc.symbol = symbol; 528 } 529 } 530 } 531 } 532 } 533 resolved_flags |= eSymbolContextSymbol; 534 } 535 } 536 } 537 538 // For function symbols, so_addr may be off by one. This is a convention 539 // consistent with FDE row indices in eh_frame sections, but requires extra 540 // logic here to permit symbol lookup for disassembly and unwind. 541 if (resolve_scope & eSymbolContextSymbol && 542 !(resolved_flags & eSymbolContextSymbol) && resolve_tail_call_address && 543 so_addr.IsSectionOffset()) { 544 Address previous_addr = so_addr; 545 previous_addr.Slide(-1); 546 547 bool do_resolve_tail_call_address = false; // prevent recursion 548 const uint32_t flags = ResolveSymbolContextForAddress( 549 previous_addr, resolve_scope, sc, do_resolve_tail_call_address); 550 if (flags & eSymbolContextSymbol) { 551 AddressRange addr_range; 552 if (sc.GetAddressRange(eSymbolContextFunction | eSymbolContextSymbol, 0, 553 false, addr_range)) { 554 if (addr_range.GetBaseAddress().GetSection() == 555 so_addr.GetSection()) { 556 // If the requested address is one past the address range of a 557 // function (i.e. a tail call), or the decremented address is the 558 // start of a function (i.e. some forms of trampoline), indicate 559 // that the symbol has been resolved. 560 if (so_addr.GetOffset() == 561 addr_range.GetBaseAddress().GetOffset() || 562 so_addr.GetOffset() == 563 addr_range.GetBaseAddress().GetOffset() + 564 addr_range.GetByteSize()) { 565 resolved_flags |= flags; 566 } 567 } else { 568 sc.symbol = 569 nullptr; // Don't trust the symbol if the sections didn't match. 570 } 571 } 572 } 573 } 574 } 575 return resolved_flags; 576 } 577 578 uint32_t Module::ResolveSymbolContextForFilePath( 579 const char *file_path, uint32_t line, bool check_inlines, 580 lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list) { 581 FileSpec file_spec(file_path); 582 return ResolveSymbolContextsForFileSpec(file_spec, line, check_inlines, 583 resolve_scope, sc_list); 584 } 585 586 uint32_t Module::ResolveSymbolContextsForFileSpec( 587 const FileSpec &file_spec, uint32_t line, bool check_inlines, 588 lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list) { 589 std::lock_guard<std::recursive_mutex> guard(m_mutex); 590 LLDB_SCOPED_TIMERF("Module::ResolveSymbolContextForFilePath (%s:%u, " 591 "check_inlines = %s, resolve_scope = 0x%8.8x)", 592 file_spec.GetPath().c_str(), line, 593 check_inlines ? "yes" : "no", resolve_scope); 594 595 const uint32_t initial_count = sc_list.GetSize(); 596 597 if (SymbolFile *symbols = GetSymbolFile()) { 598 // TODO: Handle SourceLocationSpec column information 599 SourceLocationSpec location_spec(file_spec, line, /*column=*/llvm::None, 600 check_inlines, /*exact_match=*/false); 601 602 symbols->ResolveSymbolContext(location_spec, resolve_scope, sc_list); 603 } 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 921 // TODO: Handle SourceLocationSpec column information 922 SourceLocationSpec location_spec(file, line, /*column=*/llvm::None, 923 /*check_inlines=*/true, 924 /*exact_match=*/false); 925 AddressResolverFileLine resolver(location_spec); 926 resolver.ResolveAddress(filter); 927 928 for (size_t n = 0; n < resolver.GetNumberOfAddresses(); n++) { 929 Address addr = resolver.GetAddressRangeAtIndex(n).GetBaseAddress(); 930 Function *f = addr.CalculateSymbolContextFunction(); 931 if (f && f == function) 932 output_local.push_back(addr); 933 else 934 output_extern.push_back(addr); 935 } 936 } 937 938 void Module::FindTypes_Impl( 939 ConstString name, const CompilerDeclContext &parent_decl_ctx, 940 size_t max_matches, 941 llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files, 942 TypeMap &types) { 943 LLDB_SCOPED_TIMER(); 944 if (SymbolFile *symbols = GetSymbolFile()) 945 symbols->FindTypes(name, parent_decl_ctx, max_matches, 946 searched_symbol_files, types); 947 } 948 949 void Module::FindTypesInNamespace(ConstString type_name, 950 const CompilerDeclContext &parent_decl_ctx, 951 size_t max_matches, TypeList &type_list) { 952 TypeMap types_map; 953 llvm::DenseSet<lldb_private::SymbolFile *> searched_symbol_files; 954 FindTypes_Impl(type_name, parent_decl_ctx, max_matches, searched_symbol_files, 955 types_map); 956 if (types_map.GetSize()) { 957 SymbolContext sc; 958 sc.module_sp = shared_from_this(); 959 sc.SortTypeList(types_map, type_list); 960 } 961 } 962 963 lldb::TypeSP Module::FindFirstType(const SymbolContext &sc, 964 ConstString name, bool exact_match) { 965 TypeList type_list; 966 llvm::DenseSet<lldb_private::SymbolFile *> searched_symbol_files; 967 FindTypes(name, exact_match, 1, searched_symbol_files, type_list); 968 if (type_list.GetSize()) 969 return type_list.GetTypeAtIndex(0); 970 return TypeSP(); 971 } 972 973 void Module::FindTypes( 974 ConstString name, bool exact_match, size_t max_matches, 975 llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files, 976 TypeList &types) { 977 const char *type_name_cstr = name.GetCString(); 978 llvm::StringRef type_scope; 979 llvm::StringRef type_basename; 980 TypeClass type_class = eTypeClassAny; 981 TypeMap typesmap; 982 983 if (Type::GetTypeScopeAndBasename(type_name_cstr, type_scope, type_basename, 984 type_class)) { 985 // Check if "name" starts with "::" which means the qualified type starts 986 // from the root namespace and implies and exact match. The typenames we 987 // get back from clang do not start with "::" so we need to strip this off 988 // in order to get the qualified names to match 989 exact_match = type_scope.consume_front("::"); 990 991 ConstString type_basename_const_str(type_basename); 992 FindTypes_Impl(type_basename_const_str, CompilerDeclContext(), max_matches, 993 searched_symbol_files, typesmap); 994 if (typesmap.GetSize()) 995 typesmap.RemoveMismatchedTypes(std::string(type_scope), 996 std::string(type_basename), type_class, 997 exact_match); 998 } else { 999 // The type is not in a namespace/class scope, just search for it by 1000 // basename 1001 if (type_class != eTypeClassAny && !type_basename.empty()) { 1002 // The "type_name_cstr" will have been modified if we have a valid type 1003 // class prefix (like "struct", "class", "union", "typedef" etc). 1004 FindTypes_Impl(ConstString(type_basename), CompilerDeclContext(), 1005 UINT_MAX, searched_symbol_files, typesmap); 1006 typesmap.RemoveMismatchedTypes(std::string(type_scope), 1007 std::string(type_basename), type_class, 1008 exact_match); 1009 } else { 1010 FindTypes_Impl(name, CompilerDeclContext(), UINT_MAX, 1011 searched_symbol_files, typesmap); 1012 if (exact_match) { 1013 std::string name_str(name.AsCString("")); 1014 typesmap.RemoveMismatchedTypes(std::string(type_scope), name_str, 1015 type_class, exact_match); 1016 } 1017 } 1018 } 1019 if (typesmap.GetSize()) { 1020 SymbolContext sc; 1021 sc.module_sp = shared_from_this(); 1022 sc.SortTypeList(typesmap, types); 1023 } 1024 } 1025 1026 void Module::FindTypes( 1027 llvm::ArrayRef<CompilerContext> pattern, LanguageSet languages, 1028 llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files, 1029 TypeMap &types) { 1030 LLDB_SCOPED_TIMER(); 1031 if (SymbolFile *symbols = GetSymbolFile()) 1032 symbols->FindTypes(pattern, languages, searched_symbol_files, types); 1033 } 1034 1035 SymbolFile *Module::GetSymbolFile(bool can_create, Stream *feedback_strm) { 1036 if (!m_did_load_symfile.load()) { 1037 std::lock_guard<std::recursive_mutex> guard(m_mutex); 1038 if (!m_did_load_symfile.load() && can_create) { 1039 ObjectFile *obj_file = GetObjectFile(); 1040 if (obj_file != nullptr) { 1041 LLDB_SCOPED_TIMER(); 1042 m_symfile_up.reset( 1043 SymbolVendor::FindPlugin(shared_from_this(), feedback_strm)); 1044 m_did_load_symfile = true; 1045 } 1046 } 1047 } 1048 return m_symfile_up ? m_symfile_up->GetSymbolFile() : nullptr; 1049 } 1050 1051 Symtab *Module::GetSymtab() { 1052 if (SymbolFile *symbols = GetSymbolFile()) 1053 return symbols->GetSymtab(); 1054 return nullptr; 1055 } 1056 1057 void Module::SetFileSpecAndObjectName(const FileSpec &file, 1058 ConstString object_name) { 1059 // Container objects whose paths do not specify a file directly can call this 1060 // function to correct the file and object names. 1061 m_file = file; 1062 m_mod_time = FileSystem::Instance().GetModificationTime(file); 1063 m_object_name = object_name; 1064 } 1065 1066 const ArchSpec &Module::GetArchitecture() const { return m_arch; } 1067 1068 std::string Module::GetSpecificationDescription() const { 1069 std::string spec(GetFileSpec().GetPath()); 1070 if (m_object_name) { 1071 spec += '('; 1072 spec += m_object_name.GetCString(); 1073 spec += ')'; 1074 } 1075 return spec; 1076 } 1077 1078 void Module::GetDescription(llvm::raw_ostream &s, 1079 lldb::DescriptionLevel level) { 1080 if (level >= eDescriptionLevelFull) { 1081 if (m_arch.IsValid()) 1082 s << llvm::formatv("({0}) ", m_arch.GetArchitectureName()); 1083 } 1084 1085 if (level == eDescriptionLevelBrief) { 1086 const char *filename = m_file.GetFilename().GetCString(); 1087 if (filename) 1088 s << filename; 1089 } else { 1090 char path[PATH_MAX]; 1091 if (m_file.GetPath(path, sizeof(path))) 1092 s << path; 1093 } 1094 1095 const char *object_name = m_object_name.GetCString(); 1096 if (object_name) 1097 s << llvm::formatv("({0})", object_name); 1098 } 1099 1100 void Module::ReportError(const char *format, ...) { 1101 if (format && format[0]) { 1102 StreamString strm; 1103 strm.PutCString("error: "); 1104 GetDescription(strm.AsRawOstream(), lldb::eDescriptionLevelBrief); 1105 strm.PutChar(' '); 1106 va_list args; 1107 va_start(args, format); 1108 strm.PrintfVarArg(format, args); 1109 va_end(args); 1110 1111 const int format_len = strlen(format); 1112 if (format_len > 0) { 1113 const char last_char = format[format_len - 1]; 1114 if (last_char != '\n' && last_char != '\r') 1115 strm.EOL(); 1116 } 1117 Host::SystemLog(Host::eSystemLogError, "%s", strm.GetData()); 1118 } 1119 } 1120 1121 bool Module::FileHasChanged() const { 1122 // We have provided the DataBuffer for this module to avoid accessing the 1123 // filesystem. We never want to reload those files. 1124 if (m_data_sp) 1125 return false; 1126 if (!m_file_has_changed) 1127 m_file_has_changed = 1128 (FileSystem::Instance().GetModificationTime(m_file) != m_mod_time); 1129 return m_file_has_changed; 1130 } 1131 1132 void Module::ReportErrorIfModifyDetected(const char *format, ...) { 1133 if (!m_first_file_changed_log) { 1134 if (FileHasChanged()) { 1135 m_first_file_changed_log = true; 1136 if (format) { 1137 StreamString strm; 1138 strm.PutCString("error: the object file "); 1139 GetDescription(strm.AsRawOstream(), lldb::eDescriptionLevelFull); 1140 strm.PutCString(" has been modified\n"); 1141 1142 va_list args; 1143 va_start(args, format); 1144 strm.PrintfVarArg(format, args); 1145 va_end(args); 1146 1147 const int format_len = strlen(format); 1148 if (format_len > 0) { 1149 const char last_char = format[format_len - 1]; 1150 if (last_char != '\n' && last_char != '\r') 1151 strm.EOL(); 1152 } 1153 strm.PutCString("The debug session should be aborted as the original " 1154 "debug information has been overwritten.\n"); 1155 Host::SystemLog(Host::eSystemLogError, "%s", strm.GetData()); 1156 } 1157 } 1158 } 1159 } 1160 1161 void Module::ReportWarning(const char *format, ...) { 1162 if (format && format[0]) { 1163 StreamString strm; 1164 strm.PutCString("warning: "); 1165 GetDescription(strm.AsRawOstream(), lldb::eDescriptionLevelFull); 1166 strm.PutChar(' '); 1167 1168 va_list args; 1169 va_start(args, format); 1170 strm.PrintfVarArg(format, args); 1171 va_end(args); 1172 1173 const int format_len = strlen(format); 1174 if (format_len > 0) { 1175 const char last_char = format[format_len - 1]; 1176 if (last_char != '\n' && last_char != '\r') 1177 strm.EOL(); 1178 } 1179 Host::SystemLog(Host::eSystemLogWarning, "%s", strm.GetData()); 1180 } 1181 } 1182 1183 void Module::LogMessage(Log *log, const char *format, ...) { 1184 if (log != nullptr) { 1185 StreamString log_message; 1186 GetDescription(log_message.AsRawOstream(), lldb::eDescriptionLevelFull); 1187 log_message.PutCString(": "); 1188 va_list args; 1189 va_start(args, format); 1190 log_message.PrintfVarArg(format, args); 1191 va_end(args); 1192 log->PutCString(log_message.GetData()); 1193 } 1194 } 1195 1196 void Module::LogMessageVerboseBacktrace(Log *log, const char *format, ...) { 1197 if (log != nullptr) { 1198 StreamString log_message; 1199 GetDescription(log_message.AsRawOstream(), lldb::eDescriptionLevelFull); 1200 log_message.PutCString(": "); 1201 va_list args; 1202 va_start(args, format); 1203 log_message.PrintfVarArg(format, args); 1204 va_end(args); 1205 if (log->GetVerbose()) { 1206 std::string back_trace; 1207 llvm::raw_string_ostream stream(back_trace); 1208 llvm::sys::PrintStackTrace(stream); 1209 log_message.PutCString(back_trace); 1210 } 1211 log->PutCString(log_message.GetData()); 1212 } 1213 } 1214 1215 void Module::Dump(Stream *s) { 1216 std::lock_guard<std::recursive_mutex> guard(m_mutex); 1217 // s->Printf("%.*p: ", (int)sizeof(void*) * 2, this); 1218 s->Indent(); 1219 s->Printf("Module %s%s%s%s\n", m_file.GetPath().c_str(), 1220 m_object_name ? "(" : "", 1221 m_object_name ? m_object_name.GetCString() : "", 1222 m_object_name ? ")" : ""); 1223 1224 s->IndentMore(); 1225 1226 ObjectFile *objfile = GetObjectFile(); 1227 if (objfile) 1228 objfile->Dump(s); 1229 1230 if (SymbolFile *symbols = GetSymbolFile()) 1231 symbols->Dump(*s); 1232 1233 s->IndentLess(); 1234 } 1235 1236 ConstString Module::GetObjectName() const { return m_object_name; } 1237 1238 ObjectFile *Module::GetObjectFile() { 1239 if (!m_did_load_objfile.load()) { 1240 std::lock_guard<std::recursive_mutex> guard(m_mutex); 1241 if (!m_did_load_objfile.load()) { 1242 LLDB_SCOPED_TIMERF("Module::GetObjectFile () module = %s", 1243 GetFileSpec().GetFilename().AsCString("")); 1244 lldb::offset_t data_offset = 0; 1245 lldb::offset_t file_size = 0; 1246 1247 if (m_data_sp) 1248 file_size = m_data_sp->GetByteSize(); 1249 else if (m_file) 1250 file_size = FileSystem::Instance().GetByteSize(m_file); 1251 1252 if (file_size > m_object_offset) { 1253 m_did_load_objfile = true; 1254 // FindPlugin will modify its data_sp argument. Do not let it 1255 // modify our m_data_sp member. 1256 auto data_sp = m_data_sp; 1257 m_objfile_sp = ObjectFile::FindPlugin( 1258 shared_from_this(), &m_file, m_object_offset, 1259 file_size - m_object_offset, data_sp, data_offset); 1260 if (m_objfile_sp) { 1261 // Once we get the object file, update our module with the object 1262 // file's architecture since it might differ in vendor/os if some 1263 // parts were unknown. But since the matching arch might already be 1264 // more specific than the generic COFF architecture, only merge in 1265 // those values that overwrite unspecified unknown values. 1266 m_arch.MergeFrom(m_objfile_sp->GetArchitecture()); 1267 } else { 1268 ReportError("failed to load objfile for %s", 1269 GetFileSpec().GetPath().c_str()); 1270 } 1271 } 1272 } 1273 } 1274 return m_objfile_sp.get(); 1275 } 1276 1277 SectionList *Module::GetSectionList() { 1278 // Populate m_sections_up with sections from objfile. 1279 if (!m_sections_up) { 1280 ObjectFile *obj_file = GetObjectFile(); 1281 if (obj_file != nullptr) 1282 obj_file->CreateSections(*GetUnifiedSectionList()); 1283 } 1284 return m_sections_up.get(); 1285 } 1286 1287 void Module::SectionFileAddressesChanged() { 1288 ObjectFile *obj_file = GetObjectFile(); 1289 if (obj_file) 1290 obj_file->SectionFileAddressesChanged(); 1291 if (SymbolFile *symbols = GetSymbolFile()) 1292 symbols->SectionFileAddressesChanged(); 1293 } 1294 1295 UnwindTable &Module::GetUnwindTable() { 1296 if (!m_unwind_table) 1297 m_unwind_table.emplace(*this); 1298 return *m_unwind_table; 1299 } 1300 1301 SectionList *Module::GetUnifiedSectionList() { 1302 if (!m_sections_up) 1303 m_sections_up = std::make_unique<SectionList>(); 1304 return m_sections_up.get(); 1305 } 1306 1307 const Symbol *Module::FindFirstSymbolWithNameAndType(ConstString name, 1308 SymbolType symbol_type) { 1309 LLDB_SCOPED_TIMERF( 1310 "Module::FindFirstSymbolWithNameAndType (name = %s, type = %i)", 1311 name.AsCString(), symbol_type); 1312 if (Symtab *symtab = GetSymtab()) 1313 return symtab->FindFirstSymbolWithNameAndType( 1314 name, symbol_type, Symtab::eDebugAny, Symtab::eVisibilityAny); 1315 return nullptr; 1316 } 1317 void Module::SymbolIndicesToSymbolContextList( 1318 Symtab *symtab, std::vector<uint32_t> &symbol_indexes, 1319 SymbolContextList &sc_list) { 1320 // No need to protect this call using m_mutex all other method calls are 1321 // already thread safe. 1322 1323 size_t num_indices = symbol_indexes.size(); 1324 if (num_indices > 0) { 1325 SymbolContext sc; 1326 CalculateSymbolContext(&sc); 1327 for (size_t i = 0; i < num_indices; i++) { 1328 sc.symbol = symtab->SymbolAtIndex(symbol_indexes[i]); 1329 if (sc.symbol) 1330 sc_list.Append(sc); 1331 } 1332 } 1333 } 1334 1335 void Module::FindFunctionSymbols(ConstString name, 1336 uint32_t name_type_mask, 1337 SymbolContextList &sc_list) { 1338 LLDB_SCOPED_TIMERF("Module::FindSymbolsFunctions (name = %s, mask = 0x%8.8x)", 1339 name.AsCString(), name_type_mask); 1340 if (Symtab *symtab = GetSymtab()) 1341 symtab->FindFunctionSymbols(name, name_type_mask, sc_list); 1342 } 1343 1344 void Module::FindSymbolsWithNameAndType(ConstString name, 1345 SymbolType symbol_type, 1346 SymbolContextList &sc_list) { 1347 // No need to protect this call using m_mutex all other method calls are 1348 // already thread safe. 1349 LLDB_SCOPED_TIMERF( 1350 "Module::FindSymbolsWithNameAndType (name = %s, type = %i)", 1351 name.AsCString(), symbol_type); 1352 if (Symtab *symtab = GetSymtab()) { 1353 std::vector<uint32_t> symbol_indexes; 1354 symtab->FindAllSymbolsWithNameAndType(name, symbol_type, symbol_indexes); 1355 SymbolIndicesToSymbolContextList(symtab, symbol_indexes, sc_list); 1356 } 1357 } 1358 1359 void Module::FindSymbolsMatchingRegExAndType(const RegularExpression ®ex, 1360 SymbolType symbol_type, 1361 SymbolContextList &sc_list) { 1362 // No need to protect this call using m_mutex all other method calls are 1363 // already thread safe. 1364 LLDB_SCOPED_TIMERF( 1365 "Module::FindSymbolsMatchingRegExAndType (regex = %s, type = %i)", 1366 regex.GetText().str().c_str(), symbol_type); 1367 if (Symtab *symtab = GetSymtab()) { 1368 std::vector<uint32_t> symbol_indexes; 1369 symtab->FindAllSymbolsMatchingRexExAndType( 1370 regex, symbol_type, Symtab::eDebugAny, Symtab::eVisibilityAny, 1371 symbol_indexes); 1372 SymbolIndicesToSymbolContextList(symtab, symbol_indexes, sc_list); 1373 } 1374 } 1375 1376 void Module::PreloadSymbols() { 1377 std::lock_guard<std::recursive_mutex> guard(m_mutex); 1378 SymbolFile *sym_file = GetSymbolFile(); 1379 if (!sym_file) 1380 return; 1381 1382 // Prime the symbol file first, since it adds symbols to the symbol table. 1383 sym_file->PreloadSymbols(); 1384 1385 // Now we can prime the symbol table. 1386 if (Symtab *symtab = sym_file->GetSymtab()) 1387 symtab->PreloadSymbols(); 1388 } 1389 1390 void Module::SetSymbolFileFileSpec(const FileSpec &file) { 1391 if (!FileSystem::Instance().Exists(file)) 1392 return; 1393 if (m_symfile_up) { 1394 // Remove any sections in the unified section list that come from the 1395 // current symbol vendor. 1396 SectionList *section_list = GetSectionList(); 1397 SymbolFile *symbol_file = GetSymbolFile(); 1398 if (section_list && symbol_file) { 1399 ObjectFile *obj_file = symbol_file->GetObjectFile(); 1400 // Make sure we have an object file and that the symbol vendor's objfile 1401 // isn't the same as the module's objfile before we remove any sections 1402 // for it... 1403 if (obj_file) { 1404 // Check to make sure we aren't trying to specify the file we already 1405 // have 1406 if (obj_file->GetFileSpec() == file) { 1407 // We are being told to add the exact same file that we already have 1408 // we don't have to do anything. 1409 return; 1410 } 1411 1412 // Cleare the current symtab as we are going to replace it with a new 1413 // one 1414 obj_file->ClearSymtab(); 1415 1416 // Clear the unwind table too, as that may also be affected by the 1417 // symbol file information. 1418 m_unwind_table.reset(); 1419 1420 // The symbol file might be a directory bundle ("/tmp/a.out.dSYM") 1421 // instead of a full path to the symbol file within the bundle 1422 // ("/tmp/a.out.dSYM/Contents/Resources/DWARF/a.out"). So we need to 1423 // check this 1424 1425 if (FileSystem::Instance().IsDirectory(file)) { 1426 std::string new_path(file.GetPath()); 1427 std::string old_path(obj_file->GetFileSpec().GetPath()); 1428 if (llvm::StringRef(old_path).startswith(new_path)) { 1429 // We specified the same bundle as the symbol file that we already 1430 // have 1431 return; 1432 } 1433 } 1434 1435 if (obj_file != m_objfile_sp.get()) { 1436 size_t num_sections = section_list->GetNumSections(0); 1437 for (size_t idx = num_sections; idx > 0; --idx) { 1438 lldb::SectionSP section_sp( 1439 section_list->GetSectionAtIndex(idx - 1)); 1440 if (section_sp->GetObjectFile() == obj_file) { 1441 section_list->DeleteSection(idx - 1); 1442 } 1443 } 1444 } 1445 } 1446 } 1447 // Keep all old symbol files around in case there are any lingering type 1448 // references in any SBValue objects that might have been handed out. 1449 m_old_symfiles.push_back(std::move(m_symfile_up)); 1450 } 1451 m_symfile_spec = file; 1452 m_symfile_up.reset(); 1453 m_did_load_symfile = false; 1454 } 1455 1456 bool Module::IsExecutable() { 1457 if (GetObjectFile() == nullptr) 1458 return false; 1459 else 1460 return GetObjectFile()->IsExecutable(); 1461 } 1462 1463 bool Module::IsLoadedInTarget(Target *target) { 1464 ObjectFile *obj_file = GetObjectFile(); 1465 if (obj_file) { 1466 SectionList *sections = GetSectionList(); 1467 if (sections != nullptr) { 1468 size_t num_sections = sections->GetSize(); 1469 for (size_t sect_idx = 0; sect_idx < num_sections; sect_idx++) { 1470 SectionSP section_sp = sections->GetSectionAtIndex(sect_idx); 1471 if (section_sp->GetLoadBaseAddress(target) != LLDB_INVALID_ADDRESS) { 1472 return true; 1473 } 1474 } 1475 } 1476 } 1477 return false; 1478 } 1479 1480 bool Module::LoadScriptingResourceInTarget(Target *target, Status &error, 1481 Stream *feedback_stream) { 1482 if (!target) { 1483 error.SetErrorString("invalid destination Target"); 1484 return false; 1485 } 1486 1487 LoadScriptFromSymFile should_load = 1488 target->TargetProperties::GetLoadScriptFromSymbolFile(); 1489 1490 if (should_load == eLoadScriptFromSymFileFalse) 1491 return false; 1492 1493 Debugger &debugger = target->GetDebugger(); 1494 const ScriptLanguage script_language = debugger.GetScriptLanguage(); 1495 if (script_language != eScriptLanguageNone) { 1496 1497 PlatformSP platform_sp(target->GetPlatform()); 1498 1499 if (!platform_sp) { 1500 error.SetErrorString("invalid Platform"); 1501 return false; 1502 } 1503 1504 FileSpecList file_specs = platform_sp->LocateExecutableScriptingResources( 1505 target, *this, feedback_stream); 1506 1507 const uint32_t num_specs = file_specs.GetSize(); 1508 if (num_specs) { 1509 ScriptInterpreter *script_interpreter = debugger.GetScriptInterpreter(); 1510 if (script_interpreter) { 1511 for (uint32_t i = 0; i < num_specs; ++i) { 1512 FileSpec scripting_fspec(file_specs.GetFileSpecAtIndex(i)); 1513 if (scripting_fspec && 1514 FileSystem::Instance().Exists(scripting_fspec)) { 1515 if (should_load == eLoadScriptFromSymFileWarn) { 1516 if (feedback_stream) 1517 feedback_stream->Printf( 1518 "warning: '%s' contains a debug script. To run this script " 1519 "in " 1520 "this debug session:\n\n command script import " 1521 "\"%s\"\n\n" 1522 "To run all discovered debug scripts in this session:\n\n" 1523 " settings set target.load-script-from-symbol-file " 1524 "true\n", 1525 GetFileSpec().GetFileNameStrippingExtension().GetCString(), 1526 scripting_fspec.GetPath().c_str()); 1527 return false; 1528 } 1529 StreamString scripting_stream; 1530 scripting_fspec.Dump(scripting_stream.AsRawOstream()); 1531 LoadScriptOptions options; 1532 bool did_load = script_interpreter->LoadScriptingModule( 1533 scripting_stream.GetData(), options, error); 1534 if (!did_load) 1535 return false; 1536 } 1537 } 1538 } else { 1539 error.SetErrorString("invalid ScriptInterpreter"); 1540 return false; 1541 } 1542 } 1543 } 1544 return true; 1545 } 1546 1547 bool Module::SetArchitecture(const ArchSpec &new_arch) { 1548 if (!m_arch.IsValid()) { 1549 m_arch = new_arch; 1550 return true; 1551 } 1552 return m_arch.IsCompatibleMatch(new_arch); 1553 } 1554 1555 bool Module::SetLoadAddress(Target &target, lldb::addr_t value, 1556 bool value_is_offset, bool &changed) { 1557 ObjectFile *object_file = GetObjectFile(); 1558 if (object_file != nullptr) { 1559 changed = object_file->SetLoadAddress(target, value, value_is_offset); 1560 return true; 1561 } else { 1562 changed = false; 1563 } 1564 return false; 1565 } 1566 1567 bool Module::MatchesModuleSpec(const ModuleSpec &module_ref) { 1568 const UUID &uuid = module_ref.GetUUID(); 1569 1570 if (uuid.IsValid()) { 1571 // If the UUID matches, then nothing more needs to match... 1572 return (uuid == GetUUID()); 1573 } 1574 1575 const FileSpec &file_spec = module_ref.GetFileSpec(); 1576 if (!FileSpec::Match(file_spec, m_file) && 1577 !FileSpec::Match(file_spec, m_platform_file)) 1578 return false; 1579 1580 const FileSpec &platform_file_spec = module_ref.GetPlatformFileSpec(); 1581 if (!FileSpec::Match(platform_file_spec, GetPlatformFileSpec())) 1582 return false; 1583 1584 const ArchSpec &arch = module_ref.GetArchitecture(); 1585 if (arch.IsValid()) { 1586 if (!m_arch.IsCompatibleMatch(arch)) 1587 return false; 1588 } 1589 1590 ConstString object_name = module_ref.GetObjectName(); 1591 if (object_name) { 1592 if (object_name != GetObjectName()) 1593 return false; 1594 } 1595 return true; 1596 } 1597 1598 bool Module::FindSourceFile(const FileSpec &orig_spec, 1599 FileSpec &new_spec) const { 1600 std::lock_guard<std::recursive_mutex> guard(m_mutex); 1601 if (auto remapped = m_source_mappings.FindFile(orig_spec)) { 1602 new_spec = *remapped; 1603 return true; 1604 } 1605 return false; 1606 } 1607 1608 llvm::Optional<std::string> Module::RemapSourceFile(llvm::StringRef path) const { 1609 std::lock_guard<std::recursive_mutex> guard(m_mutex); 1610 if (auto remapped = m_source_mappings.RemapPath(path)) 1611 return remapped->GetPath(); 1612 return {}; 1613 } 1614 1615 void Module::RegisterXcodeSDK(llvm::StringRef sdk_name, llvm::StringRef sysroot) { 1616 XcodeSDK sdk(sdk_name.str()); 1617 ConstString sdk_path(HostInfo::GetXcodeSDKPath(sdk)); 1618 if (!sdk_path) 1619 return; 1620 // If the SDK changed for a previously registered source path, update it. 1621 // This could happend with -fdebug-prefix-map, otherwise it's unlikely. 1622 ConstString sysroot_cs(sysroot); 1623 if (!m_source_mappings.Replace(sysroot_cs, sdk_path, true)) 1624 // In the general case, however, append it to the list. 1625 m_source_mappings.Append(sysroot_cs, sdk_path, false); 1626 } 1627 1628 bool Module::MergeArchitecture(const ArchSpec &arch_spec) { 1629 if (!arch_spec.IsValid()) 1630 return false; 1631 LLDB_LOG(GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT | LIBLLDB_LOG_MODULES), 1632 "module has arch %s, merging/replacing with arch %s", 1633 m_arch.GetTriple().getTriple().c_str(), 1634 arch_spec.GetTriple().getTriple().c_str()); 1635 if (!m_arch.IsCompatibleMatch(arch_spec)) { 1636 // The new architecture is different, we just need to replace it. 1637 return SetArchitecture(arch_spec); 1638 } 1639 1640 // Merge bits from arch_spec into "merged_arch" and set our architecture. 1641 ArchSpec merged_arch(m_arch); 1642 merged_arch.MergeFrom(arch_spec); 1643 // SetArchitecture() is a no-op if m_arch is already valid. 1644 m_arch = ArchSpec(); 1645 return SetArchitecture(merged_arch); 1646 } 1647 1648 llvm::VersionTuple Module::GetVersion() { 1649 if (ObjectFile *obj_file = GetObjectFile()) 1650 return obj_file->GetVersion(); 1651 return llvm::VersionTuple(); 1652 } 1653 1654 bool Module::GetIsDynamicLinkEditor() { 1655 ObjectFile *obj_file = GetObjectFile(); 1656 1657 if (obj_file) 1658 return obj_file->GetIsDynamicLinkEditor(); 1659 1660 return false; 1661 } 1662