SymbolFileDWARFDebugMap.cpp revision 344779
1//===-- SymbolFileDWARFDebugMap.cpp -----------------------------*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9 10#include "SymbolFileDWARFDebugMap.h" 11 12#include "DWARFDebugAranges.h" 13 14#include "lldb/Core/Module.h" 15#include "lldb/Core/ModuleList.h" 16#include "lldb/Core/PluginManager.h" 17#include "lldb/Core/RangeMap.h" 18#include "lldb/Core/Section.h" 19#include "lldb/Host/FileSystem.h" 20#include "lldb/Utility/RegularExpression.h" 21#include "lldb/Utility/Timer.h" 22 23//#define DEBUG_OSO_DMAP // DO NOT CHECKIN WITH THIS NOT COMMENTED OUT 24#if defined(DEBUG_OSO_DMAP) 25#include "lldb/Core/StreamFile.h" 26#endif 27 28#include "lldb/Symbol/CompileUnit.h" 29#include "lldb/Symbol/LineTable.h" 30#include "lldb/Symbol/ObjectFile.h" 31#include "lldb/Symbol/SymbolVendor.h" 32#include "lldb/Symbol/TypeMap.h" 33#include "lldb/Symbol/VariableList.h" 34#include "llvm/Support/ScopedPrinter.h" 35 36#include "LogChannelDWARF.h" 37#include "SymbolFileDWARF.h" 38 39using namespace lldb; 40using namespace lldb_private; 41 42// Subclass lldb_private::Module so we can intercept the 43// "Module::GetObjectFile()" (so we can fixup the object file sections) and 44// also for "Module::GetSymbolVendor()" (so we can fixup the symbol file id. 45 46const SymbolFileDWARFDebugMap::FileRangeMap & 47SymbolFileDWARFDebugMap::CompileUnitInfo::GetFileRangeMap( 48 SymbolFileDWARFDebugMap *exe_symfile) { 49 if (file_range_map_valid) 50 return file_range_map; 51 52 file_range_map_valid = true; 53 54 Module *oso_module = exe_symfile->GetModuleByCompUnitInfo(this); 55 if (!oso_module) 56 return file_range_map; 57 58 ObjectFile *oso_objfile = oso_module->GetObjectFile(); 59 if (!oso_objfile) 60 return file_range_map; 61 62 Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_MAP)); 63 if (log) { 64 ConstString object_name(oso_module->GetObjectName()); 65 log->Printf( 66 "%p: SymbolFileDWARFDebugMap::CompileUnitInfo::GetFileRangeMap ('%s')", 67 static_cast<void *>(this), 68 oso_module->GetSpecificationDescription().c_str()); 69 } 70 71 std::vector<SymbolFileDWARFDebugMap::CompileUnitInfo *> cu_infos; 72 if (exe_symfile->GetCompUnitInfosForModule(oso_module, cu_infos)) { 73 for (auto comp_unit_info : cu_infos) { 74 Symtab *exe_symtab = exe_symfile->GetObjectFile()->GetSymtab(); 75 ModuleSP oso_module_sp(oso_objfile->GetModule()); 76 Symtab *oso_symtab = oso_objfile->GetSymtab(); 77 78 /// const uint32_t fun_resolve_flags = SymbolContext::Module | 79 /// eSymbolContextCompUnit | eSymbolContextFunction; 80 // SectionList *oso_sections = oso_objfile->Sections(); 81 // Now we need to make sections that map from zero based object file 82 // addresses to where things ended up in the main executable. 83 84 assert(comp_unit_info->first_symbol_index != UINT32_MAX); 85 // End index is one past the last valid symbol index 86 const uint32_t oso_end_idx = comp_unit_info->last_symbol_index + 1; 87 for (uint32_t idx = comp_unit_info->first_symbol_index + 88 2; // Skip the N_SO and N_OSO 89 idx < oso_end_idx; ++idx) { 90 Symbol *exe_symbol = exe_symtab->SymbolAtIndex(idx); 91 if (exe_symbol) { 92 if (!exe_symbol->IsDebug()) 93 continue; 94 95 switch (exe_symbol->GetType()) { 96 default: 97 break; 98 99 case eSymbolTypeCode: { 100 // For each N_FUN, or function that we run into in the debug map we 101 // make a new section that we add to the sections found in the .o 102 // file. This new section has the file address set to what the 103 // addresses are in the .o file, and the load address is adjusted 104 // to match where it ended up in the final executable! We do this 105 // before we parse any dwarf info so that when it goes get parsed 106 // all section/offset addresses that get registered will resolve 107 // correctly to the new addresses in the main executable. 108 109 // First we find the original symbol in the .o file's symbol table 110 Symbol *oso_fun_symbol = oso_symtab->FindFirstSymbolWithNameAndType( 111 exe_symbol->GetMangled().GetName(lldb::eLanguageTypeUnknown, 112 Mangled::ePreferMangled), 113 eSymbolTypeCode, Symtab::eDebugNo, Symtab::eVisibilityAny); 114 if (oso_fun_symbol) { 115 // Add the inverse OSO file address to debug map entry mapping 116 exe_symfile->AddOSOFileRange( 117 this, exe_symbol->GetAddressRef().GetFileAddress(), 118 exe_symbol->GetByteSize(), 119 oso_fun_symbol->GetAddressRef().GetFileAddress(), 120 oso_fun_symbol->GetByteSize()); 121 } 122 } break; 123 124 case eSymbolTypeData: { 125 // For each N_GSYM we remap the address for the global by making a 126 // new section that we add to the sections found in the .o file. 127 // This new section has the file address set to what the addresses 128 // are in the .o file, and the load address is adjusted to match 129 // where it ended up in the final executable! We do this before we 130 // parse any dwarf info so that when it goes get parsed all 131 // section/offset addresses that get registered will resolve 132 // correctly to the new addresses in the main executable. We 133 // initially set the section size to be 1 byte, but will need to 134 // fix up these addresses further after all globals have been 135 // parsed to span the gaps, or we can find the global variable 136 // sizes from the DWARF info as we are parsing. 137 138 // Next we find the non-stab entry that corresponds to the N_GSYM 139 // in the .o file 140 Symbol *oso_gsym_symbol = 141 oso_symtab->FindFirstSymbolWithNameAndType( 142 exe_symbol->GetMangled().GetName(lldb::eLanguageTypeUnknown, 143 Mangled::ePreferMangled), 144 eSymbolTypeData, Symtab::eDebugNo, Symtab::eVisibilityAny); 145 if (exe_symbol && oso_gsym_symbol && exe_symbol->ValueIsAddress() && 146 oso_gsym_symbol->ValueIsAddress()) { 147 // Add the inverse OSO file address to debug map entry mapping 148 exe_symfile->AddOSOFileRange( 149 this, exe_symbol->GetAddressRef().GetFileAddress(), 150 exe_symbol->GetByteSize(), 151 oso_gsym_symbol->GetAddressRef().GetFileAddress(), 152 oso_gsym_symbol->GetByteSize()); 153 } 154 } break; 155 } 156 } 157 } 158 159 exe_symfile->FinalizeOSOFileRanges(this); 160 // We don't need the symbols anymore for the .o files 161 oso_objfile->ClearSymtab(); 162 } 163 } 164 return file_range_map; 165} 166 167class DebugMapModule : public Module { 168public: 169 DebugMapModule(const ModuleSP &exe_module_sp, uint32_t cu_idx, 170 const FileSpec &file_spec, const ArchSpec &arch, 171 const ConstString *object_name, off_t object_offset, 172 const llvm::sys::TimePoint<> object_mod_time) 173 : Module(file_spec, arch, object_name, object_offset, object_mod_time), 174 m_exe_module_wp(exe_module_sp), m_cu_idx(cu_idx) {} 175 176 ~DebugMapModule() override = default; 177 178 SymbolVendor * 179 GetSymbolVendor(bool can_create = true, 180 lldb_private::Stream *feedback_strm = NULL) override { 181 // Scope for locker 182 if (m_symfile_ap.get() || !can_create) 183 return m_symfile_ap.get(); 184 185 ModuleSP exe_module_sp(m_exe_module_wp.lock()); 186 if (exe_module_sp) { 187 // Now get the object file outside of a locking scope 188 ObjectFile *oso_objfile = GetObjectFile(); 189 if (oso_objfile) { 190 std::lock_guard<std::recursive_mutex> guard(m_mutex); 191 SymbolVendor *symbol_vendor = 192 Module::GetSymbolVendor(can_create, feedback_strm); 193 if (symbol_vendor) { 194 // Set a pointer to this class to set our OSO DWARF file know that 195 // the DWARF is being used along with a debug map and that it will 196 // have the remapped sections that we do below. 197 SymbolFileDWARF *oso_symfile = 198 SymbolFileDWARFDebugMap::GetSymbolFileAsSymbolFileDWARF( 199 symbol_vendor->GetSymbolFile()); 200 201 if (!oso_symfile) 202 return NULL; 203 204 ObjectFile *exe_objfile = exe_module_sp->GetObjectFile(); 205 SymbolVendor *exe_sym_vendor = exe_module_sp->GetSymbolVendor(); 206 207 if (exe_objfile && exe_sym_vendor) { 208 oso_symfile->SetDebugMapModule(exe_module_sp); 209 // Set the ID of the symbol file DWARF to the index of the OSO 210 // shifted left by 32 bits to provide a unique prefix for any 211 // UserID's that get created in the symbol file. 212 oso_symfile->SetID(((uint64_t)m_cu_idx + 1ull) << 32ull); 213 } 214 return symbol_vendor; 215 } 216 } 217 } 218 return NULL; 219 } 220 221protected: 222 ModuleWP m_exe_module_wp; 223 const uint32_t m_cu_idx; 224}; 225 226void SymbolFileDWARFDebugMap::Initialize() { 227 PluginManager::RegisterPlugin(GetPluginNameStatic(), 228 GetPluginDescriptionStatic(), CreateInstance); 229} 230 231void SymbolFileDWARFDebugMap::Terminate() { 232 PluginManager::UnregisterPlugin(CreateInstance); 233} 234 235lldb_private::ConstString SymbolFileDWARFDebugMap::GetPluginNameStatic() { 236 static ConstString g_name("dwarf-debugmap"); 237 return g_name; 238} 239 240const char *SymbolFileDWARFDebugMap::GetPluginDescriptionStatic() { 241 return "DWARF and DWARF3 debug symbol file reader (debug map)."; 242} 243 244SymbolFile *SymbolFileDWARFDebugMap::CreateInstance(ObjectFile *obj_file) { 245 return new SymbolFileDWARFDebugMap(obj_file); 246} 247 248SymbolFileDWARFDebugMap::SymbolFileDWARFDebugMap(ObjectFile *ofile) 249 : SymbolFile(ofile), m_flags(), m_compile_unit_infos(), m_func_indexes(), 250 m_glob_indexes(), 251 m_supports_DW_AT_APPLE_objc_complete_type(eLazyBoolCalculate) {} 252 253SymbolFileDWARFDebugMap::~SymbolFileDWARFDebugMap() {} 254 255void SymbolFileDWARFDebugMap::InitializeObject() {} 256 257void SymbolFileDWARFDebugMap::InitOSO() { 258 if (m_flags.test(kHaveInitializedOSOs)) 259 return; 260 261 m_flags.set(kHaveInitializedOSOs); 262 263 // If the object file has been stripped, there is no sense in looking further 264 // as all of the debug symbols for the debug map will not be available 265 if (m_obj_file->IsStripped()) 266 return; 267 268 // Also make sure the file type is some sort of executable. Core files, debug 269 // info files (dSYM), object files (.o files), and stub libraries all can 270 switch (m_obj_file->GetType()) { 271 case ObjectFile::eTypeInvalid: 272 case ObjectFile::eTypeCoreFile: 273 case ObjectFile::eTypeDebugInfo: 274 case ObjectFile::eTypeObjectFile: 275 case ObjectFile::eTypeStubLibrary: 276 case ObjectFile::eTypeUnknown: 277 case ObjectFile::eTypeJIT: 278 return; 279 280 case ObjectFile::eTypeExecutable: 281 case ObjectFile::eTypeDynamicLinker: 282 case ObjectFile::eTypeSharedLibrary: 283 break; 284 } 285 286 // In order to get the abilities of this plug-in, we look at the list of 287 // N_OSO entries (object files) from the symbol table and make sure that 288 // these files exist and also contain valid DWARF. If we get any of that then 289 // we return the abilities of the first N_OSO's DWARF. 290 291 Symtab *symtab = m_obj_file->GetSymtab(); 292 if (symtab) { 293 Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_MAP)); 294 295 std::vector<uint32_t> oso_indexes; 296 // When a mach-o symbol is encoded, the n_type field is encoded in bits 297 // 23:16, and the n_desc field is encoded in bits 15:0. 298 // 299 // To find all N_OSO entries that are part of the DWARF + debug map we find 300 // only object file symbols with the flags value as follows: bits 23:16 == 301 // 0x66 (N_OSO) bits 15: 0 == 0x0001 (specifies this is a debug map object 302 // file) 303 const uint32_t k_oso_symbol_flags_value = 0x660001u; 304 305 const uint32_t oso_index_count = 306 symtab->AppendSymbolIndexesWithTypeAndFlagsValue( 307 eSymbolTypeObjectFile, k_oso_symbol_flags_value, oso_indexes); 308 309 if (oso_index_count > 0) { 310 symtab->AppendSymbolIndexesWithType(eSymbolTypeCode, Symtab::eDebugYes, 311 Symtab::eVisibilityAny, 312 m_func_indexes); 313 symtab->AppendSymbolIndexesWithType(eSymbolTypeData, Symtab::eDebugYes, 314 Symtab::eVisibilityAny, 315 m_glob_indexes); 316 317 symtab->SortSymbolIndexesByValue(m_func_indexes, true); 318 symtab->SortSymbolIndexesByValue(m_glob_indexes, true); 319 320 for (uint32_t sym_idx : m_func_indexes) { 321 const Symbol *symbol = symtab->SymbolAtIndex(sym_idx); 322 lldb::addr_t file_addr = symbol->GetAddressRef().GetFileAddress(); 323 lldb::addr_t byte_size = symbol->GetByteSize(); 324 DebugMap::Entry debug_map_entry( 325 file_addr, byte_size, OSOEntry(sym_idx, LLDB_INVALID_ADDRESS)); 326 m_debug_map.Append(debug_map_entry); 327 } 328 for (uint32_t sym_idx : m_glob_indexes) { 329 const Symbol *symbol = symtab->SymbolAtIndex(sym_idx); 330 lldb::addr_t file_addr = symbol->GetAddressRef().GetFileAddress(); 331 lldb::addr_t byte_size = symbol->GetByteSize(); 332 DebugMap::Entry debug_map_entry( 333 file_addr, byte_size, OSOEntry(sym_idx, LLDB_INVALID_ADDRESS)); 334 m_debug_map.Append(debug_map_entry); 335 } 336 m_debug_map.Sort(); 337 338 m_compile_unit_infos.resize(oso_index_count); 339 340 for (uint32_t i = 0; i < oso_index_count; ++i) { 341 const uint32_t so_idx = oso_indexes[i] - 1; 342 const uint32_t oso_idx = oso_indexes[i]; 343 const Symbol *so_symbol = symtab->SymbolAtIndex(so_idx); 344 const Symbol *oso_symbol = symtab->SymbolAtIndex(oso_idx); 345 if (so_symbol && oso_symbol && 346 so_symbol->GetType() == eSymbolTypeSourceFile && 347 oso_symbol->GetType() == eSymbolTypeObjectFile) { 348 m_compile_unit_infos[i].so_file.SetFile( 349 so_symbol->GetName().AsCString(), FileSpec::Style::native); 350 m_compile_unit_infos[i].oso_path = oso_symbol->GetName(); 351 m_compile_unit_infos[i].oso_mod_time = 352 llvm::sys::toTimePoint(oso_symbol->GetIntegerValue(0)); 353 uint32_t sibling_idx = so_symbol->GetSiblingIndex(); 354 // The sibling index can't be less that or equal to the current index 355 // "i" 356 if (sibling_idx == UINT32_MAX) { 357 m_obj_file->GetModule()->ReportError( 358 "N_SO in symbol with UID %u has invalid sibling in debug map, " 359 "please file a bug and attach the binary listed in this error", 360 so_symbol->GetID()); 361 } else { 362 const Symbol *last_symbol = symtab->SymbolAtIndex(sibling_idx - 1); 363 m_compile_unit_infos[i].first_symbol_index = so_idx; 364 m_compile_unit_infos[i].last_symbol_index = sibling_idx - 1; 365 m_compile_unit_infos[i].first_symbol_id = so_symbol->GetID(); 366 m_compile_unit_infos[i].last_symbol_id = last_symbol->GetID(); 367 368 if (log) 369 log->Printf("Initialized OSO 0x%8.8x: file=%s", i, 370 oso_symbol->GetName().GetCString()); 371 } 372 } else { 373 if (oso_symbol == NULL) 374 m_obj_file->GetModule()->ReportError( 375 "N_OSO symbol[%u] can't be found, please file a bug and attach " 376 "the binary listed in this error", 377 oso_idx); 378 else if (so_symbol == NULL) 379 m_obj_file->GetModule()->ReportError( 380 "N_SO not found for N_OSO symbol[%u], please file a bug and " 381 "attach the binary listed in this error", 382 oso_idx); 383 else if (so_symbol->GetType() != eSymbolTypeSourceFile) 384 m_obj_file->GetModule()->ReportError( 385 "N_SO has incorrect symbol type (%u) for N_OSO symbol[%u], " 386 "please file a bug and attach the binary listed in this error", 387 so_symbol->GetType(), oso_idx); 388 else if (oso_symbol->GetType() != eSymbolTypeSourceFile) 389 m_obj_file->GetModule()->ReportError( 390 "N_OSO has incorrect symbol type (%u) for N_OSO symbol[%u], " 391 "please file a bug and attach the binary listed in this error", 392 oso_symbol->GetType(), oso_idx); 393 } 394 } 395 } 396 } 397} 398 399Module *SymbolFileDWARFDebugMap::GetModuleByOSOIndex(uint32_t oso_idx) { 400 const uint32_t cu_count = GetNumCompileUnits(); 401 if (oso_idx < cu_count) 402 return GetModuleByCompUnitInfo(&m_compile_unit_infos[oso_idx]); 403 return NULL; 404} 405 406Module *SymbolFileDWARFDebugMap::GetModuleByCompUnitInfo( 407 CompileUnitInfo *comp_unit_info) { 408 if (!comp_unit_info->oso_sp) { 409 auto pos = m_oso_map.find( 410 {comp_unit_info->oso_path, comp_unit_info->oso_mod_time}); 411 if (pos != m_oso_map.end()) { 412 comp_unit_info->oso_sp = pos->second; 413 } else { 414 ObjectFile *obj_file = GetObjectFile(); 415 comp_unit_info->oso_sp.reset(new OSOInfo()); 416 m_oso_map[{comp_unit_info->oso_path, comp_unit_info->oso_mod_time}] = 417 comp_unit_info->oso_sp; 418 const char *oso_path = comp_unit_info->oso_path.GetCString(); 419 FileSpec oso_file(oso_path); 420 ConstString oso_object; 421 if (FileSystem::Instance().Exists(oso_file)) { 422 // The modification time returned by the FS can have a higher precision 423 // than the one from the CU. 424 auto oso_mod_time = std::chrono::time_point_cast<std::chrono::seconds>( 425 FileSystem::Instance().GetModificationTime(oso_file)); 426 if (oso_mod_time != comp_unit_info->oso_mod_time) { 427 obj_file->GetModule()->ReportError( 428 "debug map object file '%s' has changed (actual time is " 429 "%s, debug map time is %s" 430 ") since this executable was linked, file will be ignored", 431 oso_file.GetPath().c_str(), llvm::to_string(oso_mod_time).c_str(), 432 llvm::to_string(comp_unit_info->oso_mod_time).c_str()); 433 return NULL; 434 } 435 436 } else { 437 const bool must_exist = true; 438 439 if (!ObjectFile::SplitArchivePathWithObject(oso_path, oso_file, 440 oso_object, must_exist)) { 441 return NULL; 442 } 443 } 444 // Always create a new module for .o files. Why? Because we use the debug 445 // map, to add new sections to each .o file and even though a .o file 446 // might not have changed, the sections that get added to the .o file can 447 // change. 448 ArchSpec oso_arch; 449 // Only adopt the architecture from the module (not the vendor or OS) 450 // since .o files for "i386-apple-ios" will historically show up as "i386 451 // -apple-macosx" due to the lack of a LC_VERSION_MIN_MACOSX or 452 // LC_VERSION_MIN_IPHONEOS load command... 453 oso_arch.SetTriple(m_obj_file->GetModule() 454 ->GetArchitecture() 455 .GetTriple() 456 .getArchName() 457 .str() 458 .c_str()); 459 comp_unit_info->oso_sp->module_sp.reset(new DebugMapModule( 460 obj_file->GetModule(), GetCompUnitInfoIndex(comp_unit_info), oso_file, 461 oso_arch, oso_object ? &oso_object : NULL, 0, 462 oso_object ? comp_unit_info->oso_mod_time 463 : llvm::sys::TimePoint<>())); 464 } 465 } 466 if (comp_unit_info->oso_sp) 467 return comp_unit_info->oso_sp->module_sp.get(); 468 return NULL; 469} 470 471bool SymbolFileDWARFDebugMap::GetFileSpecForSO(uint32_t oso_idx, 472 FileSpec &file_spec) { 473 if (oso_idx < m_compile_unit_infos.size()) { 474 if (m_compile_unit_infos[oso_idx].so_file) { 475 file_spec = m_compile_unit_infos[oso_idx].so_file; 476 return true; 477 } 478 } 479 return false; 480} 481 482ObjectFile *SymbolFileDWARFDebugMap::GetObjectFileByOSOIndex(uint32_t oso_idx) { 483 Module *oso_module = GetModuleByOSOIndex(oso_idx); 484 if (oso_module) 485 return oso_module->GetObjectFile(); 486 return NULL; 487} 488 489SymbolFileDWARF * 490SymbolFileDWARFDebugMap::GetSymbolFile(const SymbolContext &sc) { 491 return GetSymbolFile(*sc.comp_unit); 492} 493 494SymbolFileDWARF * 495SymbolFileDWARFDebugMap::GetSymbolFile(const CompileUnit &comp_unit) { 496 CompileUnitInfo *comp_unit_info = GetCompUnitInfo(comp_unit); 497 if (comp_unit_info) 498 return GetSymbolFileByCompUnitInfo(comp_unit_info); 499 return NULL; 500} 501 502ObjectFile *SymbolFileDWARFDebugMap::GetObjectFileByCompUnitInfo( 503 CompileUnitInfo *comp_unit_info) { 504 Module *oso_module = GetModuleByCompUnitInfo(comp_unit_info); 505 if (oso_module) 506 return oso_module->GetObjectFile(); 507 return NULL; 508} 509 510uint32_t SymbolFileDWARFDebugMap::GetCompUnitInfoIndex( 511 const CompileUnitInfo *comp_unit_info) { 512 if (!m_compile_unit_infos.empty()) { 513 const CompileUnitInfo *first_comp_unit_info = &m_compile_unit_infos.front(); 514 const CompileUnitInfo *last_comp_unit_info = &m_compile_unit_infos.back(); 515 if (first_comp_unit_info <= comp_unit_info && 516 comp_unit_info <= last_comp_unit_info) 517 return comp_unit_info - first_comp_unit_info; 518 } 519 return UINT32_MAX; 520} 521 522SymbolFileDWARF * 523SymbolFileDWARFDebugMap::GetSymbolFileByOSOIndex(uint32_t oso_idx) { 524 unsigned size = m_compile_unit_infos.size(); 525 if (oso_idx < size) 526 return GetSymbolFileByCompUnitInfo(&m_compile_unit_infos[oso_idx]); 527 return NULL; 528} 529 530SymbolFileDWARF * 531SymbolFileDWARFDebugMap::GetSymbolFileAsSymbolFileDWARF(SymbolFile *sym_file) { 532 if (sym_file && 533 sym_file->GetPluginName() == SymbolFileDWARF::GetPluginNameStatic()) 534 return (SymbolFileDWARF *)sym_file; 535 return NULL; 536} 537 538SymbolFileDWARF *SymbolFileDWARFDebugMap::GetSymbolFileByCompUnitInfo( 539 CompileUnitInfo *comp_unit_info) { 540 Module *oso_module = GetModuleByCompUnitInfo(comp_unit_info); 541 if (oso_module) { 542 SymbolVendor *sym_vendor = oso_module->GetSymbolVendor(); 543 if (sym_vendor) 544 return GetSymbolFileAsSymbolFileDWARF(sym_vendor->GetSymbolFile()); 545 } 546 return NULL; 547} 548 549uint32_t SymbolFileDWARFDebugMap::CalculateAbilities() { 550 // In order to get the abilities of this plug-in, we look at the list of 551 // N_OSO entries (object files) from the symbol table and make sure that 552 // these files exist and also contain valid DWARF. If we get any of that then 553 // we return the abilities of the first N_OSO's DWARF. 554 555 const uint32_t oso_index_count = GetNumCompileUnits(); 556 if (oso_index_count > 0) { 557 InitOSO(); 558 if (!m_compile_unit_infos.empty()) { 559 return SymbolFile::CompileUnits | SymbolFile::Functions | 560 SymbolFile::Blocks | SymbolFile::GlobalVariables | 561 SymbolFile::LocalVariables | SymbolFile::VariableTypes | 562 SymbolFile::LineTables; 563 } 564 } 565 return 0; 566} 567 568uint32_t SymbolFileDWARFDebugMap::GetNumCompileUnits() { 569 InitOSO(); 570 return m_compile_unit_infos.size(); 571} 572 573CompUnitSP SymbolFileDWARFDebugMap::ParseCompileUnitAtIndex(uint32_t cu_idx) { 574 CompUnitSP comp_unit_sp; 575 const uint32_t cu_count = GetNumCompileUnits(); 576 577 if (cu_idx < cu_count) { 578 Module *oso_module = GetModuleByCompUnitInfo(&m_compile_unit_infos[cu_idx]); 579 if (oso_module) { 580 FileSpec so_file_spec; 581 if (GetFileSpecForSO(cu_idx, so_file_spec)) { 582 // User zero as the ID to match the compile unit at offset zero in each 583 // .o file since each .o file can only have one compile unit for now. 584 lldb::user_id_t cu_id = 0; 585 m_compile_unit_infos[cu_idx].compile_unit_sp.reset( 586 new CompileUnit(m_obj_file->GetModule(), NULL, so_file_spec, cu_id, 587 eLanguageTypeUnknown, eLazyBoolCalculate)); 588 589 if (m_compile_unit_infos[cu_idx].compile_unit_sp) { 590 // Let our symbol vendor know about this compile unit 591 m_obj_file->GetModule()->GetSymbolVendor()->SetCompileUnitAtIndex( 592 cu_idx, m_compile_unit_infos[cu_idx].compile_unit_sp); 593 } 594 } 595 } 596 comp_unit_sp = m_compile_unit_infos[cu_idx].compile_unit_sp; 597 } 598 599 return comp_unit_sp; 600} 601 602SymbolFileDWARFDebugMap::CompileUnitInfo * 603SymbolFileDWARFDebugMap::GetCompUnitInfo(const SymbolContext &sc) { 604 return GetCompUnitInfo(*sc.comp_unit); 605} 606 607SymbolFileDWARFDebugMap::CompileUnitInfo * 608SymbolFileDWARFDebugMap::GetCompUnitInfo(const CompileUnit &comp_unit) { 609 const uint32_t cu_count = GetNumCompileUnits(); 610 for (uint32_t i = 0; i < cu_count; ++i) { 611 if (comp_unit == m_compile_unit_infos[i].compile_unit_sp.get()) 612 return &m_compile_unit_infos[i]; 613 } 614 return NULL; 615} 616 617size_t SymbolFileDWARFDebugMap::GetCompUnitInfosForModule( 618 const lldb_private::Module *module, 619 std::vector<CompileUnitInfo *> &cu_infos) { 620 const uint32_t cu_count = GetNumCompileUnits(); 621 for (uint32_t i = 0; i < cu_count; ++i) { 622 if (module == GetModuleByCompUnitInfo(&m_compile_unit_infos[i])) 623 cu_infos.push_back(&m_compile_unit_infos[i]); 624 } 625 return cu_infos.size(); 626} 627 628lldb::LanguageType 629SymbolFileDWARFDebugMap::ParseLanguage(CompileUnit &comp_unit) { 630 SymbolFileDWARF *oso_dwarf = GetSymbolFile(comp_unit); 631 if (oso_dwarf) 632 return oso_dwarf->ParseLanguage(comp_unit); 633 return eLanguageTypeUnknown; 634} 635 636size_t SymbolFileDWARFDebugMap::ParseFunctions(CompileUnit &comp_unit) { 637 SymbolFileDWARF *oso_dwarf = GetSymbolFile(comp_unit); 638 if (oso_dwarf) 639 return oso_dwarf->ParseFunctions(comp_unit); 640 return 0; 641} 642 643bool SymbolFileDWARFDebugMap::ParseLineTable(CompileUnit &comp_unit) { 644 SymbolFileDWARF *oso_dwarf = GetSymbolFile(comp_unit); 645 if (oso_dwarf) 646 return oso_dwarf->ParseLineTable(comp_unit); 647 return false; 648} 649 650bool SymbolFileDWARFDebugMap::ParseDebugMacros(CompileUnit &comp_unit) { 651 SymbolFileDWARF *oso_dwarf = GetSymbolFile(comp_unit); 652 if (oso_dwarf) 653 return oso_dwarf->ParseDebugMacros(comp_unit); 654 return false; 655} 656 657bool SymbolFileDWARFDebugMap::ParseSupportFiles(CompileUnit &comp_unit, 658 FileSpecList &support_files) { 659 SymbolFileDWARF *oso_dwarf = GetSymbolFile(comp_unit); 660 if (oso_dwarf) 661 return oso_dwarf->ParseSupportFiles(comp_unit, support_files); 662 return false; 663} 664 665bool SymbolFileDWARFDebugMap::ParseIsOptimized(CompileUnit &comp_unit) { 666 SymbolFileDWARF *oso_dwarf = GetSymbolFile(comp_unit); 667 if (oso_dwarf) 668 return oso_dwarf->ParseIsOptimized(comp_unit); 669 return false; 670} 671 672bool SymbolFileDWARFDebugMap::ParseImportedModules( 673 const SymbolContext &sc, std::vector<ConstString> &imported_modules) { 674 SymbolFileDWARF *oso_dwarf = GetSymbolFile(sc); 675 if (oso_dwarf) 676 return oso_dwarf->ParseImportedModules(sc, imported_modules); 677 return false; 678} 679 680size_t SymbolFileDWARFDebugMap::ParseBlocksRecursive(Function &func) { 681 CompileUnit *comp_unit = func.GetCompileUnit(); 682 if (!comp_unit) 683 return 0; 684 685 SymbolFileDWARF *oso_dwarf = GetSymbolFile(*comp_unit); 686 if (oso_dwarf) 687 return oso_dwarf->ParseBlocksRecursive(func); 688 return 0; 689} 690 691size_t SymbolFileDWARFDebugMap::ParseTypes(CompileUnit &comp_unit) { 692 SymbolFileDWARF *oso_dwarf = GetSymbolFile(comp_unit); 693 if (oso_dwarf) 694 return oso_dwarf->ParseTypes(comp_unit); 695 return 0; 696} 697 698size_t 699SymbolFileDWARFDebugMap::ParseVariablesForContext(const SymbolContext &sc) { 700 SymbolFileDWARF *oso_dwarf = GetSymbolFile(sc); 701 if (oso_dwarf) 702 return oso_dwarf->ParseVariablesForContext(sc); 703 return 0; 704} 705 706Type *SymbolFileDWARFDebugMap::ResolveTypeUID(lldb::user_id_t type_uid) { 707 const uint64_t oso_idx = GetOSOIndexFromUserID(type_uid); 708 SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex(oso_idx); 709 if (oso_dwarf) 710 return oso_dwarf->ResolveTypeUID(type_uid); 711 return NULL; 712} 713 714llvm::Optional<SymbolFile::ArrayInfo> 715SymbolFileDWARFDebugMap::GetDynamicArrayInfoForUID( 716 lldb::user_id_t type_uid, const lldb_private::ExecutionContext *exe_ctx) { 717 const uint64_t oso_idx = GetOSOIndexFromUserID(type_uid); 718 SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex(oso_idx); 719 if (oso_dwarf) 720 return oso_dwarf->GetDynamicArrayInfoForUID(type_uid, exe_ctx); 721 return llvm::None; 722} 723 724bool SymbolFileDWARFDebugMap::CompleteType(CompilerType &compiler_type) { 725 bool success = false; 726 if (compiler_type) { 727 ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool { 728 if (oso_dwarf->HasForwardDeclForClangType(compiler_type)) { 729 oso_dwarf->CompleteType(compiler_type); 730 success = true; 731 return true; 732 } 733 return false; 734 }); 735 } 736 return success; 737} 738 739uint32_t 740SymbolFileDWARFDebugMap::ResolveSymbolContext(const Address &exe_so_addr, 741 SymbolContextItem resolve_scope, 742 SymbolContext &sc) { 743 uint32_t resolved_flags = 0; 744 Symtab *symtab = m_obj_file->GetSymtab(); 745 if (symtab) { 746 const addr_t exe_file_addr = exe_so_addr.GetFileAddress(); 747 748 const DebugMap::Entry *debug_map_entry = 749 m_debug_map.FindEntryThatContains(exe_file_addr); 750 if (debug_map_entry) { 751 752 sc.symbol = 753 symtab->SymbolAtIndex(debug_map_entry->data.GetExeSymbolIndex()); 754 755 if (sc.symbol != NULL) { 756 resolved_flags |= eSymbolContextSymbol; 757 758 uint32_t oso_idx = 0; 759 CompileUnitInfo *comp_unit_info = 760 GetCompileUnitInfoForSymbolWithID(sc.symbol->GetID(), &oso_idx); 761 if (comp_unit_info) { 762 comp_unit_info->GetFileRangeMap(this); 763 Module *oso_module = GetModuleByCompUnitInfo(comp_unit_info); 764 if (oso_module) { 765 lldb::addr_t oso_file_addr = 766 exe_file_addr - debug_map_entry->GetRangeBase() + 767 debug_map_entry->data.GetOSOFileAddress(); 768 Address oso_so_addr; 769 if (oso_module->ResolveFileAddress(oso_file_addr, oso_so_addr)) { 770 resolved_flags |= 771 oso_module->GetSymbolVendor()->ResolveSymbolContext( 772 oso_so_addr, resolve_scope, sc); 773 } 774 } 775 } 776 } 777 } 778 } 779 return resolved_flags; 780} 781 782uint32_t SymbolFileDWARFDebugMap::ResolveSymbolContext( 783 const FileSpec &file_spec, uint32_t line, bool check_inlines, 784 SymbolContextItem resolve_scope, SymbolContextList &sc_list) { 785 const uint32_t initial = sc_list.GetSize(); 786 const uint32_t cu_count = GetNumCompileUnits(); 787 788 for (uint32_t i = 0; i < cu_count; ++i) { 789 // If we are checking for inlines, then we need to look through all compile 790 // units no matter if "file_spec" matches. 791 bool resolve = check_inlines; 792 793 if (!resolve) { 794 FileSpec so_file_spec; 795 if (GetFileSpecForSO(i, so_file_spec)) { 796 // Match the full path if the incoming file_spec has a directory (not 797 // just a basename) 798 const bool full_match = (bool)file_spec.GetDirectory(); 799 resolve = FileSpec::Equal(file_spec, so_file_spec, full_match); 800 } 801 } 802 if (resolve) { 803 SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex(i); 804 if (oso_dwarf) 805 oso_dwarf->ResolveSymbolContext(file_spec, line, check_inlines, 806 resolve_scope, sc_list); 807 } 808 } 809 return sc_list.GetSize() - initial; 810} 811 812uint32_t SymbolFileDWARFDebugMap::PrivateFindGlobalVariables( 813 const ConstString &name, const CompilerDeclContext *parent_decl_ctx, 814 const std::vector<uint32_t> 815 &indexes, // Indexes into the symbol table that match "name" 816 uint32_t max_matches, VariableList &variables) { 817 const uint32_t original_size = variables.GetSize(); 818 const size_t match_count = indexes.size(); 819 for (size_t i = 0; i < match_count; ++i) { 820 uint32_t oso_idx; 821 CompileUnitInfo *comp_unit_info = 822 GetCompileUnitInfoForSymbolWithIndex(indexes[i], &oso_idx); 823 if (comp_unit_info) { 824 SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex(oso_idx); 825 if (oso_dwarf) { 826 if (oso_dwarf->FindGlobalVariables(name, parent_decl_ctx, max_matches, 827 variables)) 828 if (variables.GetSize() > max_matches) 829 break; 830 } 831 } 832 } 833 return variables.GetSize() - original_size; 834} 835 836uint32_t SymbolFileDWARFDebugMap::FindGlobalVariables( 837 const ConstString &name, const CompilerDeclContext *parent_decl_ctx, 838 uint32_t max_matches, VariableList &variables) { 839 840 // Remember how many variables are in the list before we search. 841 const uint32_t original_size = variables.GetSize(); 842 843 uint32_t total_matches = 0; 844 845 ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool { 846 const uint32_t oso_matches = oso_dwarf->FindGlobalVariables( 847 name, parent_decl_ctx, max_matches, variables); 848 if (oso_matches > 0) { 849 total_matches += oso_matches; 850 851 // Are we getting all matches? 852 if (max_matches == UINT32_MAX) 853 return false; // Yep, continue getting everything 854 855 // If we have found enough matches, lets get out 856 if (max_matches >= total_matches) 857 return true; 858 859 // Update the max matches for any subsequent calls to find globals in any 860 // other object files with DWARF 861 max_matches -= oso_matches; 862 } 863 864 return false; 865 }); 866 867 // Return the number of variable that were appended to the list 868 return variables.GetSize() - original_size; 869} 870 871uint32_t 872SymbolFileDWARFDebugMap::FindGlobalVariables(const RegularExpression ®ex, 873 uint32_t max_matches, 874 VariableList &variables) { 875 // Remember how many variables are in the list before we search. 876 const uint32_t original_size = variables.GetSize(); 877 878 uint32_t total_matches = 0; 879 ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool { 880 const uint32_t oso_matches = 881 oso_dwarf->FindGlobalVariables(regex, max_matches, variables); 882 if (oso_matches > 0) { 883 total_matches += oso_matches; 884 885 // Are we getting all matches? 886 if (max_matches == UINT32_MAX) 887 return false; // Yep, continue getting everything 888 889 // If we have found enough matches, lets get out 890 if (max_matches >= total_matches) 891 return true; 892 893 // Update the max matches for any subsequent calls to find globals in any 894 // other object files with DWARF 895 max_matches -= oso_matches; 896 } 897 898 return false; 899 }); 900 901 // Return the number of variable that were appended to the list 902 return variables.GetSize() - original_size; 903} 904 905int SymbolFileDWARFDebugMap::SymbolContainsSymbolWithIndex( 906 uint32_t *symbol_idx_ptr, const CompileUnitInfo *comp_unit_info) { 907 const uint32_t symbol_idx = *symbol_idx_ptr; 908 909 if (symbol_idx < comp_unit_info->first_symbol_index) 910 return -1; 911 912 if (symbol_idx <= comp_unit_info->last_symbol_index) 913 return 0; 914 915 return 1; 916} 917 918int SymbolFileDWARFDebugMap::SymbolContainsSymbolWithID( 919 user_id_t *symbol_idx_ptr, const CompileUnitInfo *comp_unit_info) { 920 const user_id_t symbol_id = *symbol_idx_ptr; 921 922 if (symbol_id < comp_unit_info->first_symbol_id) 923 return -1; 924 925 if (symbol_id <= comp_unit_info->last_symbol_id) 926 return 0; 927 928 return 1; 929} 930 931SymbolFileDWARFDebugMap::CompileUnitInfo * 932SymbolFileDWARFDebugMap::GetCompileUnitInfoForSymbolWithIndex( 933 uint32_t symbol_idx, uint32_t *oso_idx_ptr) { 934 const uint32_t oso_index_count = m_compile_unit_infos.size(); 935 CompileUnitInfo *comp_unit_info = NULL; 936 if (oso_index_count) { 937 comp_unit_info = (CompileUnitInfo *)bsearch( 938 &symbol_idx, &m_compile_unit_infos[0], m_compile_unit_infos.size(), 939 sizeof(CompileUnitInfo), 940 (ComparisonFunction)SymbolContainsSymbolWithIndex); 941 } 942 943 if (oso_idx_ptr) { 944 if (comp_unit_info != NULL) 945 *oso_idx_ptr = comp_unit_info - &m_compile_unit_infos[0]; 946 else 947 *oso_idx_ptr = UINT32_MAX; 948 } 949 return comp_unit_info; 950} 951 952SymbolFileDWARFDebugMap::CompileUnitInfo * 953SymbolFileDWARFDebugMap::GetCompileUnitInfoForSymbolWithID( 954 user_id_t symbol_id, uint32_t *oso_idx_ptr) { 955 const uint32_t oso_index_count = m_compile_unit_infos.size(); 956 CompileUnitInfo *comp_unit_info = NULL; 957 if (oso_index_count) { 958 comp_unit_info = (CompileUnitInfo *)::bsearch( 959 &symbol_id, &m_compile_unit_infos[0], m_compile_unit_infos.size(), 960 sizeof(CompileUnitInfo), 961 (ComparisonFunction)SymbolContainsSymbolWithID); 962 } 963 964 if (oso_idx_ptr) { 965 if (comp_unit_info != NULL) 966 *oso_idx_ptr = comp_unit_info - &m_compile_unit_infos[0]; 967 else 968 *oso_idx_ptr = UINT32_MAX; 969 } 970 return comp_unit_info; 971} 972 973static void RemoveFunctionsWithModuleNotEqualTo(const ModuleSP &module_sp, 974 SymbolContextList &sc_list, 975 uint32_t start_idx) { 976 // We found functions in .o files. Not all functions in the .o files will 977 // have made it into the final output file. The ones that did make it into 978 // the final output file will have a section whose module matches the module 979 // from the ObjectFile for this SymbolFile. When the modules don't match, 980 // then we have something that was in a .o file, but doesn't map to anything 981 // in the final executable. 982 uint32_t i = start_idx; 983 while (i < sc_list.GetSize()) { 984 SymbolContext sc; 985 sc_list.GetContextAtIndex(i, sc); 986 if (sc.function) { 987 const SectionSP section_sp( 988 sc.function->GetAddressRange().GetBaseAddress().GetSection()); 989 if (section_sp->GetModule() != module_sp) { 990 sc_list.RemoveContextAtIndex(i); 991 continue; 992 } 993 } 994 ++i; 995 } 996} 997 998uint32_t SymbolFileDWARFDebugMap::FindFunctions( 999 const ConstString &name, const CompilerDeclContext *parent_decl_ctx, 1000 FunctionNameType name_type_mask, bool include_inlines, bool append, 1001 SymbolContextList &sc_list) { 1002 static Timer::Category func_cat(LLVM_PRETTY_FUNCTION); 1003 Timer scoped_timer(func_cat, 1004 "SymbolFileDWARFDebugMap::FindFunctions (name = %s)", 1005 name.GetCString()); 1006 1007 uint32_t initial_size = 0; 1008 if (append) 1009 initial_size = sc_list.GetSize(); 1010 else 1011 sc_list.Clear(); 1012 1013 ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool { 1014 uint32_t sc_idx = sc_list.GetSize(); 1015 if (oso_dwarf->FindFunctions(name, parent_decl_ctx, name_type_mask, 1016 include_inlines, true, sc_list)) { 1017 RemoveFunctionsWithModuleNotEqualTo(m_obj_file->GetModule(), sc_list, 1018 sc_idx); 1019 } 1020 return false; 1021 }); 1022 1023 return sc_list.GetSize() - initial_size; 1024} 1025 1026uint32_t SymbolFileDWARFDebugMap::FindFunctions(const RegularExpression ®ex, 1027 bool include_inlines, 1028 bool append, 1029 SymbolContextList &sc_list) { 1030 static Timer::Category func_cat(LLVM_PRETTY_FUNCTION); 1031 Timer scoped_timer(func_cat, 1032 "SymbolFileDWARFDebugMap::FindFunctions (regex = '%s')", 1033 regex.GetText().str().c_str()); 1034 1035 uint32_t initial_size = 0; 1036 if (append) 1037 initial_size = sc_list.GetSize(); 1038 else 1039 sc_list.Clear(); 1040 1041 ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool { 1042 uint32_t sc_idx = sc_list.GetSize(); 1043 1044 if (oso_dwarf->FindFunctions(regex, include_inlines, true, sc_list)) { 1045 RemoveFunctionsWithModuleNotEqualTo(m_obj_file->GetModule(), sc_list, 1046 sc_idx); 1047 } 1048 return false; 1049 }); 1050 1051 return sc_list.GetSize() - initial_size; 1052} 1053 1054size_t SymbolFileDWARFDebugMap::GetTypes(SymbolContextScope *sc_scope, 1055 lldb::TypeClass type_mask, 1056 TypeList &type_list) { 1057 static Timer::Category func_cat(LLVM_PRETTY_FUNCTION); 1058 Timer scoped_timer(func_cat, 1059 "SymbolFileDWARFDebugMap::GetTypes (type_mask = 0x%8.8x)", 1060 type_mask); 1061 1062 uint32_t initial_size = type_list.GetSize(); 1063 SymbolFileDWARF *oso_dwarf = NULL; 1064 if (sc_scope) { 1065 SymbolContext sc; 1066 sc_scope->CalculateSymbolContext(&sc); 1067 1068 CompileUnitInfo *cu_info = GetCompUnitInfo(sc); 1069 if (cu_info) { 1070 oso_dwarf = GetSymbolFileByCompUnitInfo(cu_info); 1071 if (oso_dwarf) 1072 oso_dwarf->GetTypes(sc_scope, type_mask, type_list); 1073 } 1074 } else { 1075 ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool { 1076 oso_dwarf->GetTypes(sc_scope, type_mask, type_list); 1077 return false; 1078 }); 1079 } 1080 return type_list.GetSize() - initial_size; 1081} 1082 1083std::vector<lldb_private::CallEdge> 1084SymbolFileDWARFDebugMap::ParseCallEdgesInFunction(UserID func_id) { 1085 uint32_t oso_idx = GetOSOIndexFromUserID(func_id.GetID()); 1086 SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex(oso_idx); 1087 if (oso_dwarf) 1088 return oso_dwarf->ParseCallEdgesInFunction(func_id); 1089 return {}; 1090} 1091 1092TypeSP SymbolFileDWARFDebugMap::FindDefinitionTypeForDWARFDeclContext( 1093 const DWARFDeclContext &die_decl_ctx) { 1094 TypeSP type_sp; 1095 ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool { 1096 type_sp = oso_dwarf->FindDefinitionTypeForDWARFDeclContext(die_decl_ctx); 1097 return ((bool)type_sp); 1098 }); 1099 return type_sp; 1100} 1101 1102bool SymbolFileDWARFDebugMap::Supports_DW_AT_APPLE_objc_complete_type( 1103 SymbolFileDWARF *skip_dwarf_oso) { 1104 if (m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolCalculate) { 1105 m_supports_DW_AT_APPLE_objc_complete_type = eLazyBoolNo; 1106 ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool { 1107 if (skip_dwarf_oso != oso_dwarf && 1108 oso_dwarf->Supports_DW_AT_APPLE_objc_complete_type(NULL)) { 1109 m_supports_DW_AT_APPLE_objc_complete_type = eLazyBoolYes; 1110 return true; 1111 } 1112 return false; 1113 }); 1114 } 1115 return m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolYes; 1116} 1117 1118TypeSP SymbolFileDWARFDebugMap::FindCompleteObjCDefinitionTypeForDIE( 1119 const DWARFDIE &die, const ConstString &type_name, 1120 bool must_be_implementation) { 1121 // If we have a debug map, we will have an Objective-C symbol whose name is 1122 // the type name and whose type is eSymbolTypeObjCClass. If we can find that 1123 // symbol and find its containing parent, we can locate the .o file that will 1124 // contain the implementation definition since it will be scoped inside the 1125 // N_SO and we can then locate the SymbolFileDWARF that corresponds to that 1126 // N_SO. 1127 SymbolFileDWARF *oso_dwarf = NULL; 1128 TypeSP type_sp; 1129 ObjectFile *module_objfile = m_obj_file->GetModule()->GetObjectFile(); 1130 if (module_objfile) { 1131 Symtab *symtab = module_objfile->GetSymtab(); 1132 if (symtab) { 1133 Symbol *objc_class_symbol = symtab->FindFirstSymbolWithNameAndType( 1134 type_name, eSymbolTypeObjCClass, Symtab::eDebugAny, 1135 Symtab::eVisibilityAny); 1136 if (objc_class_symbol) { 1137 // Get the N_SO symbol that contains the objective C class symbol as 1138 // this should be the .o file that contains the real definition... 1139 const Symbol *source_file_symbol = symtab->GetParent(objc_class_symbol); 1140 1141 if (source_file_symbol && 1142 source_file_symbol->GetType() == eSymbolTypeSourceFile) { 1143 const uint32_t source_file_symbol_idx = 1144 symtab->GetIndexForSymbol(source_file_symbol); 1145 if (source_file_symbol_idx != UINT32_MAX) { 1146 CompileUnitInfo *compile_unit_info = 1147 GetCompileUnitInfoForSymbolWithIndex(source_file_symbol_idx, 1148 NULL); 1149 if (compile_unit_info) { 1150 oso_dwarf = GetSymbolFileByCompUnitInfo(compile_unit_info); 1151 if (oso_dwarf) { 1152 TypeSP type_sp(oso_dwarf->FindCompleteObjCDefinitionTypeForDIE( 1153 die, type_name, must_be_implementation)); 1154 if (type_sp) { 1155 return type_sp; 1156 } 1157 } 1158 } 1159 } 1160 } 1161 } 1162 } 1163 } 1164 1165 // Only search all .o files for the definition if we don't need the 1166 // implementation because otherwise, with a valid debug map we should have 1167 // the ObjC class symbol and the code above should have found it. 1168 if (!must_be_implementation) { 1169 TypeSP type_sp; 1170 1171 ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool { 1172 type_sp = oso_dwarf->FindCompleteObjCDefinitionTypeForDIE( 1173 die, type_name, must_be_implementation); 1174 return (bool)type_sp; 1175 }); 1176 1177 return type_sp; 1178 } 1179 return TypeSP(); 1180} 1181 1182uint32_t SymbolFileDWARFDebugMap::FindTypes( 1183 const ConstString &name, const CompilerDeclContext *parent_decl_ctx, 1184 bool append, uint32_t max_matches, 1185 llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files, 1186 TypeMap &types) { 1187 if (!append) 1188 types.Clear(); 1189 1190 const uint32_t initial_types_size = types.GetSize(); 1191 1192 ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool { 1193 oso_dwarf->FindTypes(name, parent_decl_ctx, append, max_matches, 1194 searched_symbol_files, types); 1195 return types.GetSize() >= max_matches; 1196 }); 1197 1198 return types.GetSize() - initial_types_size; 1199} 1200 1201// 1202// uint32_t 1203// SymbolFileDWARFDebugMap::FindTypes (const SymbolContext& sc, const 1204// RegularExpression& regex, bool append, uint32_t max_matches, Type::Encoding 1205// encoding, lldb::user_id_t udt_uid, TypeList& types) 1206//{ 1207// SymbolFileDWARF *oso_dwarf = GetSymbolFile (sc); 1208// if (oso_dwarf) 1209// return oso_dwarf->FindTypes (sc, regex, append, max_matches, encoding, 1210// udt_uid, types); 1211// return 0; 1212//} 1213 1214CompilerDeclContext SymbolFileDWARFDebugMap::FindNamespace( 1215 const lldb_private::ConstString &name, 1216 const CompilerDeclContext *parent_decl_ctx) { 1217 CompilerDeclContext matching_namespace; 1218 1219 ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool { 1220 matching_namespace = oso_dwarf->FindNamespace(name, parent_decl_ctx); 1221 1222 return (bool)matching_namespace; 1223 }); 1224 1225 return matching_namespace; 1226} 1227 1228void SymbolFileDWARFDebugMap::DumpClangAST(Stream &s) { 1229 ForEachSymbolFile([&s](SymbolFileDWARF *oso_dwarf) -> bool { 1230 oso_dwarf->DumpClangAST(s); 1231 return true; 1232 }); 1233} 1234 1235//------------------------------------------------------------------ 1236// PluginInterface protocol 1237//------------------------------------------------------------------ 1238lldb_private::ConstString SymbolFileDWARFDebugMap::GetPluginName() { 1239 return GetPluginNameStatic(); 1240} 1241 1242uint32_t SymbolFileDWARFDebugMap::GetPluginVersion() { return 1; } 1243 1244lldb::CompUnitSP 1245SymbolFileDWARFDebugMap::GetCompileUnit(SymbolFileDWARF *oso_dwarf) { 1246 if (oso_dwarf) { 1247 const uint32_t cu_count = GetNumCompileUnits(); 1248 for (uint32_t cu_idx = 0; cu_idx < cu_count; ++cu_idx) { 1249 SymbolFileDWARF *oso_symfile = 1250 GetSymbolFileByCompUnitInfo(&m_compile_unit_infos[cu_idx]); 1251 if (oso_symfile == oso_dwarf) { 1252 if (!m_compile_unit_infos[cu_idx].compile_unit_sp) 1253 m_compile_unit_infos[cu_idx].compile_unit_sp = 1254 ParseCompileUnitAtIndex(cu_idx); 1255 1256 return m_compile_unit_infos[cu_idx].compile_unit_sp; 1257 } 1258 } 1259 } 1260 llvm_unreachable("this shouldn't happen"); 1261} 1262 1263SymbolFileDWARFDebugMap::CompileUnitInfo * 1264SymbolFileDWARFDebugMap::GetCompileUnitInfo(SymbolFileDWARF *oso_dwarf) { 1265 if (oso_dwarf) { 1266 const uint32_t cu_count = GetNumCompileUnits(); 1267 for (uint32_t cu_idx = 0; cu_idx < cu_count; ++cu_idx) { 1268 SymbolFileDWARF *oso_symfile = 1269 GetSymbolFileByCompUnitInfo(&m_compile_unit_infos[cu_idx]); 1270 if (oso_symfile == oso_dwarf) { 1271 return &m_compile_unit_infos[cu_idx]; 1272 } 1273 } 1274 } 1275 return NULL; 1276} 1277 1278void SymbolFileDWARFDebugMap::SetCompileUnit(SymbolFileDWARF *oso_dwarf, 1279 const CompUnitSP &cu_sp) { 1280 if (oso_dwarf) { 1281 const uint32_t cu_count = GetNumCompileUnits(); 1282 for (uint32_t cu_idx = 0; cu_idx < cu_count; ++cu_idx) { 1283 SymbolFileDWARF *oso_symfile = 1284 GetSymbolFileByCompUnitInfo(&m_compile_unit_infos[cu_idx]); 1285 if (oso_symfile == oso_dwarf) { 1286 if (m_compile_unit_infos[cu_idx].compile_unit_sp) { 1287 assert(m_compile_unit_infos[cu_idx].compile_unit_sp.get() == 1288 cu_sp.get()); 1289 } else { 1290 m_compile_unit_infos[cu_idx].compile_unit_sp = cu_sp; 1291 m_obj_file->GetModule()->GetSymbolVendor()->SetCompileUnitAtIndex( 1292 cu_idx, cu_sp); 1293 } 1294 } 1295 } 1296 } 1297} 1298 1299CompilerDeclContext 1300SymbolFileDWARFDebugMap::GetDeclContextForUID(lldb::user_id_t type_uid) { 1301 const uint64_t oso_idx = GetOSOIndexFromUserID(type_uid); 1302 SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex(oso_idx); 1303 if (oso_dwarf) 1304 return oso_dwarf->GetDeclContextForUID(type_uid); 1305 return CompilerDeclContext(); 1306} 1307 1308CompilerDeclContext 1309SymbolFileDWARFDebugMap::GetDeclContextContainingUID(lldb::user_id_t type_uid) { 1310 const uint64_t oso_idx = GetOSOIndexFromUserID(type_uid); 1311 SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex(oso_idx); 1312 if (oso_dwarf) 1313 return oso_dwarf->GetDeclContextContainingUID(type_uid); 1314 return CompilerDeclContext(); 1315} 1316 1317void SymbolFileDWARFDebugMap::ParseDeclsForContext( 1318 lldb_private::CompilerDeclContext decl_ctx) { 1319 ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool { 1320 oso_dwarf->ParseDeclsForContext(decl_ctx); 1321 return true; // Keep iterating 1322 }); 1323} 1324 1325bool SymbolFileDWARFDebugMap::AddOSOFileRange(CompileUnitInfo *cu_info, 1326 lldb::addr_t exe_file_addr, 1327 lldb::addr_t exe_byte_size, 1328 lldb::addr_t oso_file_addr, 1329 lldb::addr_t oso_byte_size) { 1330 const uint32_t debug_map_idx = 1331 m_debug_map.FindEntryIndexThatContains(exe_file_addr); 1332 if (debug_map_idx != UINT32_MAX) { 1333 DebugMap::Entry *debug_map_entry = 1334 m_debug_map.FindEntryThatContains(exe_file_addr); 1335 debug_map_entry->data.SetOSOFileAddress(oso_file_addr); 1336 addr_t range_size = std::min<addr_t>(exe_byte_size, oso_byte_size); 1337 if (range_size == 0) { 1338 range_size = std::max<addr_t>(exe_byte_size, oso_byte_size); 1339 if (range_size == 0) 1340 range_size = 1; 1341 } 1342 cu_info->file_range_map.Append( 1343 FileRangeMap::Entry(oso_file_addr, range_size, exe_file_addr)); 1344 return true; 1345 } 1346 return false; 1347} 1348 1349void SymbolFileDWARFDebugMap::FinalizeOSOFileRanges(CompileUnitInfo *cu_info) { 1350 cu_info->file_range_map.Sort(); 1351#if defined(DEBUG_OSO_DMAP) 1352 const FileRangeMap &oso_file_range_map = cu_info->GetFileRangeMap(this); 1353 const size_t n = oso_file_range_map.GetSize(); 1354 printf("SymbolFileDWARFDebugMap::FinalizeOSOFileRanges (cu_info = %p) %s\n", 1355 cu_info, cu_info->oso_sp->module_sp->GetFileSpec().GetPath().c_str()); 1356 for (size_t i = 0; i < n; ++i) { 1357 const FileRangeMap::Entry &entry = oso_file_range_map.GetEntryRef(i); 1358 printf("oso [0x%16.16" PRIx64 " - 0x%16.16" PRIx64 1359 ") ==> exe [0x%16.16" PRIx64 " - 0x%16.16" PRIx64 ")\n", 1360 entry.GetRangeBase(), entry.GetRangeEnd(), entry.data, 1361 entry.data + entry.GetByteSize()); 1362 } 1363#endif 1364} 1365 1366lldb::addr_t 1367SymbolFileDWARFDebugMap::LinkOSOFileAddress(SymbolFileDWARF *oso_symfile, 1368 lldb::addr_t oso_file_addr) { 1369 CompileUnitInfo *cu_info = GetCompileUnitInfo(oso_symfile); 1370 if (cu_info) { 1371 const FileRangeMap::Entry *oso_range_entry = 1372 cu_info->GetFileRangeMap(this).FindEntryThatContains(oso_file_addr); 1373 if (oso_range_entry) { 1374 const DebugMap::Entry *debug_map_entry = 1375 m_debug_map.FindEntryThatContains(oso_range_entry->data); 1376 if (debug_map_entry) { 1377 const lldb::addr_t offset = 1378 oso_file_addr - oso_range_entry->GetRangeBase(); 1379 const lldb::addr_t exe_file_addr = 1380 debug_map_entry->GetRangeBase() + offset; 1381 return exe_file_addr; 1382 } 1383 } 1384 } 1385 return LLDB_INVALID_ADDRESS; 1386} 1387 1388bool SymbolFileDWARFDebugMap::LinkOSOAddress(Address &addr) { 1389 // Make sure this address hasn't been fixed already 1390 Module *exe_module = GetObjectFile()->GetModule().get(); 1391 Module *addr_module = addr.GetModule().get(); 1392 if (addr_module == exe_module) 1393 return true; // Address is already in terms of the main executable module 1394 1395 CompileUnitInfo *cu_info = GetCompileUnitInfo(GetSymbolFileAsSymbolFileDWARF( 1396 addr_module->GetSymbolVendor()->GetSymbolFile())); 1397 if (cu_info) { 1398 const lldb::addr_t oso_file_addr = addr.GetFileAddress(); 1399 const FileRangeMap::Entry *oso_range_entry = 1400 cu_info->GetFileRangeMap(this).FindEntryThatContains(oso_file_addr); 1401 if (oso_range_entry) { 1402 const DebugMap::Entry *debug_map_entry = 1403 m_debug_map.FindEntryThatContains(oso_range_entry->data); 1404 if (debug_map_entry) { 1405 const lldb::addr_t offset = 1406 oso_file_addr - oso_range_entry->GetRangeBase(); 1407 const lldb::addr_t exe_file_addr = 1408 debug_map_entry->GetRangeBase() + offset; 1409 return exe_module->ResolveFileAddress(exe_file_addr, addr); 1410 } 1411 } 1412 } 1413 return true; 1414} 1415 1416LineTable *SymbolFileDWARFDebugMap::LinkOSOLineTable(SymbolFileDWARF *oso_dwarf, 1417 LineTable *line_table) { 1418 CompileUnitInfo *cu_info = GetCompileUnitInfo(oso_dwarf); 1419 if (cu_info) 1420 return line_table->LinkLineTable(cu_info->GetFileRangeMap(this)); 1421 return NULL; 1422} 1423 1424size_t 1425SymbolFileDWARFDebugMap::AddOSOARanges(SymbolFileDWARF *dwarf2Data, 1426 DWARFDebugAranges *debug_aranges) { 1427 size_t num_line_entries_added = 0; 1428 if (debug_aranges && dwarf2Data) { 1429 CompileUnitInfo *compile_unit_info = GetCompileUnitInfo(dwarf2Data); 1430 if (compile_unit_info) { 1431 const FileRangeMap &file_range_map = 1432 compile_unit_info->GetFileRangeMap(this); 1433 for (size_t idx = 0; idx < file_range_map.GetSize(); idx++) { 1434 const FileRangeMap::Entry *entry = file_range_map.GetEntryAtIndex(idx); 1435 if (entry) { 1436 debug_aranges->AppendRange(dwarf2Data->GetID(), entry->GetRangeBase(), 1437 entry->GetRangeEnd()); 1438 num_line_entries_added++; 1439 } 1440 } 1441 } 1442 } 1443 return num_line_entries_added; 1444} 1445