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