1 //===-- SymbolFileDWARF.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 "SymbolFileDWARF.h" 11 12 // Other libraries and framework includes 13 #include "llvm/Support/Casting.h" 14 15 #include "lldb/Core/ArchSpec.h" 16 #include "lldb/Core/Module.h" 17 #include "lldb/Core/ModuleList.h" 18 #include "lldb/Core/ModuleSpec.h" 19 #include "lldb/Core/PluginManager.h" 20 #include "lldb/Core/RegularExpression.h" 21 #include "lldb/Core/Scalar.h" 22 #include "lldb/Core/Section.h" 23 #include "lldb/Core/StreamFile.h" 24 #include "lldb/Core/StreamString.h" 25 #include "lldb/Core/Timer.h" 26 #include "lldb/Core/Value.h" 27 28 #include "Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.h" 29 30 #include "lldb/Host/FileSystem.h" 31 #include "lldb/Host/Host.h" 32 33 #include "lldb/Interpreter/OptionValueFileSpecList.h" 34 #include "lldb/Interpreter/OptionValueProperties.h" 35 36 #include "lldb/Symbol/Block.h" 37 #include "lldb/Symbol/ClangASTContext.h" 38 #include "lldb/Symbol/ClangUtil.h" 39 #include "lldb/Symbol/CompileUnit.h" 40 #include "lldb/Symbol/CompilerDecl.h" 41 #include "lldb/Symbol/CompilerDeclContext.h" 42 #include "lldb/Symbol/DebugMacros.h" 43 #include "lldb/Symbol/LineTable.h" 44 #include "lldb/Symbol/ObjectFile.h" 45 #include "lldb/Symbol/SymbolVendor.h" 46 #include "lldb/Symbol/TypeMap.h" 47 #include "lldb/Symbol/TypeSystem.h" 48 #include "lldb/Symbol/VariableList.h" 49 50 #include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h" 51 #include "Plugins/Language/ObjC/ObjCLanguage.h" 52 53 #include "lldb/Target/Language.h" 54 55 #include "lldb/Utility/TaskPool.h" 56 57 #include "DWARFASTParser.h" 58 #include "DWARFASTParserClang.h" 59 #include "DWARFCompileUnit.h" 60 #include "DWARFDIECollection.h" 61 #include "DWARFDebugAbbrev.h" 62 #include "DWARFDebugAranges.h" 63 #include "DWARFDebugInfo.h" 64 #include "DWARFDebugLine.h" 65 #include "DWARFDebugMacro.h" 66 #include "DWARFDebugPubnames.h" 67 #include "DWARFDebugRanges.h" 68 #include "DWARFDeclContext.h" 69 #include "DWARFFormValue.h" 70 #include "LogChannelDWARF.h" 71 #include "SymbolFileDWARFDebugMap.h" 72 #include "SymbolFileDWARFDwo.h" 73 74 #include <map> 75 76 #include <ctype.h> 77 #include <string.h> 78 79 //#define ENABLE_DEBUG_PRINTF // COMMENT OUT THIS LINE PRIOR TO CHECKIN 80 81 #ifdef ENABLE_DEBUG_PRINTF 82 #include <stdio.h> 83 #define DEBUG_PRINTF(fmt, ...) printf(fmt, __VA_ARGS__) 84 #else 85 #define DEBUG_PRINTF(fmt, ...) 86 #endif 87 88 using namespace lldb; 89 using namespace lldb_private; 90 91 //static inline bool 92 //child_requires_parent_class_union_or_struct_to_be_completed (dw_tag_t tag) 93 //{ 94 // switch (tag) 95 // { 96 // default: 97 // break; 98 // case DW_TAG_subprogram: 99 // case DW_TAG_inlined_subroutine: 100 // case DW_TAG_class_type: 101 // case DW_TAG_structure_type: 102 // case DW_TAG_union_type: 103 // return true; 104 // } 105 // return false; 106 //} 107 // 108 109 namespace { 110 111 PropertyDefinition 112 g_properties[] = 113 { 114 { "comp-dir-symlink-paths" , OptionValue::eTypeFileSpecList, true, 0 , nullptr, nullptr, "If the DW_AT_comp_dir matches any of these paths the symbolic links will be resolved at DWARF parse time." }, 115 { nullptr , OptionValue::eTypeInvalid , false, 0, nullptr, nullptr, nullptr } 116 }; 117 118 enum 119 { 120 ePropertySymLinkPaths 121 }; 122 123 124 class PluginProperties : public Properties 125 { 126 public: 127 static ConstString 128 GetSettingName() 129 { 130 return SymbolFileDWARF::GetPluginNameStatic(); 131 } 132 133 PluginProperties() 134 { 135 m_collection_sp.reset (new OptionValueProperties(GetSettingName())); 136 m_collection_sp->Initialize(g_properties); 137 } 138 139 FileSpecList& 140 GetSymLinkPaths() 141 { 142 OptionValueFileSpecList *option_value = m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList(nullptr, true, ePropertySymLinkPaths); 143 assert(option_value); 144 return option_value->GetCurrentValue(); 145 } 146 147 }; 148 149 typedef std::shared_ptr<PluginProperties> SymbolFileDWARFPropertiesSP; 150 151 static const SymbolFileDWARFPropertiesSP& 152 GetGlobalPluginProperties() 153 { 154 static const auto g_settings_sp(std::make_shared<PluginProperties>()); 155 return g_settings_sp; 156 } 157 158 } // anonymous namespace end 159 160 161 static const char* 162 removeHostnameFromPathname(const char* path_from_dwarf) 163 { 164 if (!path_from_dwarf || !path_from_dwarf[0]) 165 { 166 return path_from_dwarf; 167 } 168 169 const char *colon_pos = strchr(path_from_dwarf, ':'); 170 if (nullptr == colon_pos) 171 { 172 return path_from_dwarf; 173 } 174 175 const char *slash_pos = strchr(path_from_dwarf, '/'); 176 if (slash_pos && (slash_pos < colon_pos)) 177 { 178 return path_from_dwarf; 179 } 180 181 // check whether we have a windows path, and so the first character 182 // is a drive-letter not a hostname. 183 if ( 184 colon_pos == path_from_dwarf + 1 && 185 isalpha(*path_from_dwarf) && 186 strlen(path_from_dwarf) > 2 && 187 '\\' == path_from_dwarf[2]) 188 { 189 return path_from_dwarf; 190 } 191 192 return colon_pos + 1; 193 } 194 195 static const char* 196 resolveCompDir(const char* path_from_dwarf) 197 { 198 if (!path_from_dwarf) 199 return nullptr; 200 201 // DWARF2/3 suggests the form hostname:pathname for compilation directory. 202 // Remove the host part if present. 203 const char* local_path = removeHostnameFromPathname(path_from_dwarf); 204 if (!local_path) 205 return nullptr; 206 207 bool is_symlink = false; 208 FileSpec local_path_spec(local_path, false); 209 const auto& file_specs = GetGlobalPluginProperties()->GetSymLinkPaths(); 210 for (size_t i = 0; i < file_specs.GetSize() && !is_symlink; ++i) 211 is_symlink = FileSpec::Equal(file_specs.GetFileSpecAtIndex(i), local_path_spec, true); 212 213 if (!is_symlink) 214 return local_path; 215 216 if (!local_path_spec.IsSymbolicLink()) 217 return local_path; 218 219 FileSpec resolved_local_path_spec; 220 const auto error = FileSystem::Readlink(local_path_spec, resolved_local_path_spec); 221 if (error.Success()) 222 return resolved_local_path_spec.GetCString(); 223 224 return nullptr; 225 } 226 227 228 void 229 SymbolFileDWARF::Initialize() 230 { 231 LogChannelDWARF::Initialize(); 232 PluginManager::RegisterPlugin (GetPluginNameStatic(), 233 GetPluginDescriptionStatic(), 234 CreateInstance, 235 DebuggerInitialize); 236 } 237 238 void 239 SymbolFileDWARF::DebuggerInitialize(Debugger &debugger) 240 { 241 if (!PluginManager::GetSettingForSymbolFilePlugin(debugger, PluginProperties::GetSettingName())) 242 { 243 const bool is_global_setting = true; 244 PluginManager::CreateSettingForSymbolFilePlugin(debugger, 245 GetGlobalPluginProperties()->GetValueProperties(), 246 ConstString ("Properties for the dwarf symbol-file plug-in."), 247 is_global_setting); 248 } 249 } 250 251 void 252 SymbolFileDWARF::Terminate() 253 { 254 PluginManager::UnregisterPlugin (CreateInstance); 255 LogChannelDWARF::Initialize(); 256 } 257 258 259 lldb_private::ConstString 260 SymbolFileDWARF::GetPluginNameStatic() 261 { 262 static ConstString g_name("dwarf"); 263 return g_name; 264 } 265 266 const char * 267 SymbolFileDWARF::GetPluginDescriptionStatic() 268 { 269 return "DWARF and DWARF3 debug symbol file reader."; 270 } 271 272 273 SymbolFile* 274 SymbolFileDWARF::CreateInstance (ObjectFile* obj_file) 275 { 276 return new SymbolFileDWARF(obj_file); 277 } 278 279 TypeList * 280 SymbolFileDWARF::GetTypeList () 281 { 282 SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile(); 283 if (debug_map_symfile) 284 return debug_map_symfile->GetTypeList(); 285 else 286 return m_obj_file->GetModule()->GetTypeList(); 287 288 } 289 void 290 SymbolFileDWARF::GetTypes (const DWARFDIE &die, 291 dw_offset_t min_die_offset, 292 dw_offset_t max_die_offset, 293 uint32_t type_mask, 294 TypeSet &type_set) 295 { 296 if (die) 297 { 298 const dw_offset_t die_offset = die.GetOffset(); 299 300 if (die_offset >= max_die_offset) 301 return; 302 303 if (die_offset >= min_die_offset) 304 { 305 const dw_tag_t tag = die.Tag(); 306 307 bool add_type = false; 308 309 switch (tag) 310 { 311 case DW_TAG_array_type: add_type = (type_mask & eTypeClassArray ) != 0; break; 312 case DW_TAG_unspecified_type: 313 case DW_TAG_base_type: add_type = (type_mask & eTypeClassBuiltin ) != 0; break; 314 case DW_TAG_class_type: add_type = (type_mask & eTypeClassClass ) != 0; break; 315 case DW_TAG_structure_type: add_type = (type_mask & eTypeClassStruct ) != 0; break; 316 case DW_TAG_union_type: add_type = (type_mask & eTypeClassUnion ) != 0; break; 317 case DW_TAG_enumeration_type: add_type = (type_mask & eTypeClassEnumeration ) != 0; break; 318 case DW_TAG_subroutine_type: 319 case DW_TAG_subprogram: 320 case DW_TAG_inlined_subroutine: add_type = (type_mask & eTypeClassFunction ) != 0; break; 321 case DW_TAG_pointer_type: add_type = (type_mask & eTypeClassPointer ) != 0; break; 322 case DW_TAG_rvalue_reference_type: 323 case DW_TAG_reference_type: add_type = (type_mask & eTypeClassReference ) != 0; break; 324 case DW_TAG_typedef: add_type = (type_mask & eTypeClassTypedef ) != 0; break; 325 case DW_TAG_ptr_to_member_type: add_type = (type_mask & eTypeClassMemberPointer ) != 0; break; 326 } 327 328 if (add_type) 329 { 330 const bool assert_not_being_parsed = true; 331 Type *type = ResolveTypeUID (die, assert_not_being_parsed); 332 if (type) 333 { 334 if (type_set.find(type) == type_set.end()) 335 type_set.insert(type); 336 } 337 } 338 } 339 340 for (DWARFDIE child_die = die.GetFirstChild(); 341 child_die.IsValid(); 342 child_die = child_die.GetSibling()) 343 { 344 GetTypes (child_die, min_die_offset, max_die_offset, type_mask, type_set); 345 } 346 } 347 } 348 349 size_t 350 SymbolFileDWARF::GetTypes (SymbolContextScope *sc_scope, 351 uint32_t type_mask, 352 TypeList &type_list) 353 354 { 355 TypeSet type_set; 356 357 CompileUnit *comp_unit = NULL; 358 DWARFCompileUnit* dwarf_cu = NULL; 359 if (sc_scope) 360 comp_unit = sc_scope->CalculateSymbolContextCompileUnit(); 361 362 if (comp_unit) 363 { 364 dwarf_cu = GetDWARFCompileUnit(comp_unit); 365 if (dwarf_cu == 0) 366 return 0; 367 GetTypes (dwarf_cu->DIE(), 368 dwarf_cu->GetOffset(), 369 dwarf_cu->GetNextCompileUnitOffset(), 370 type_mask, 371 type_set); 372 } 373 else 374 { 375 DWARFDebugInfo* info = DebugInfo(); 376 if (info) 377 { 378 const size_t num_cus = info->GetNumCompileUnits(); 379 for (size_t cu_idx=0; cu_idx<num_cus; ++cu_idx) 380 { 381 dwarf_cu = info->GetCompileUnitAtIndex(cu_idx); 382 if (dwarf_cu) 383 { 384 GetTypes (dwarf_cu->DIE(), 385 0, 386 UINT32_MAX, 387 type_mask, 388 type_set); 389 } 390 } 391 } 392 } 393 394 std::set<CompilerType> compiler_type_set; 395 size_t num_types_added = 0; 396 for (Type *type : type_set) 397 { 398 CompilerType compiler_type = type->GetForwardCompilerType (); 399 if (compiler_type_set.find(compiler_type) == compiler_type_set.end()) 400 { 401 compiler_type_set.insert(compiler_type); 402 type_list.Insert (type->shared_from_this()); 403 ++num_types_added; 404 } 405 } 406 return num_types_added; 407 } 408 409 410 //---------------------------------------------------------------------- 411 // Gets the first parent that is a lexical block, function or inlined 412 // subroutine, or compile unit. 413 //---------------------------------------------------------------------- 414 DWARFDIE 415 SymbolFileDWARF::GetParentSymbolContextDIE(const DWARFDIE &child_die) 416 { 417 DWARFDIE die; 418 for (die = child_die.GetParent(); die; die = die.GetParent()) 419 { 420 dw_tag_t tag = die.Tag(); 421 422 switch (tag) 423 { 424 case DW_TAG_compile_unit: 425 case DW_TAG_subprogram: 426 case DW_TAG_inlined_subroutine: 427 case DW_TAG_lexical_block: 428 return die; 429 } 430 } 431 return DWARFDIE(); 432 } 433 434 435 SymbolFileDWARF::SymbolFileDWARF(ObjectFile* objfile) : 436 SymbolFile (objfile), 437 UserID (0), // Used by SymbolFileDWARFDebugMap to when this class parses .o files to contain the .o file index/ID 438 m_debug_map_module_wp (), 439 m_debug_map_symfile (NULL), 440 m_data_debug_abbrev (), 441 m_data_debug_aranges (), 442 m_data_debug_frame (), 443 m_data_debug_info (), 444 m_data_debug_line (), 445 m_data_debug_macro (), 446 m_data_debug_loc (), 447 m_data_debug_ranges (), 448 m_data_debug_str (), 449 m_data_apple_names (), 450 m_data_apple_types (), 451 m_data_apple_namespaces (), 452 m_abbr(), 453 m_info(), 454 m_line(), 455 m_apple_names_ap (), 456 m_apple_types_ap (), 457 m_apple_namespaces_ap (), 458 m_apple_objc_ap (), 459 m_function_basename_index(), 460 m_function_fullname_index(), 461 m_function_method_index(), 462 m_function_selector_index(), 463 m_objc_class_selectors_index(), 464 m_global_index(), 465 m_type_index(), 466 m_namespace_index(), 467 m_indexed (false), 468 m_using_apple_tables (false), 469 m_fetched_external_modules (false), 470 m_supports_DW_AT_APPLE_objc_complete_type (eLazyBoolCalculate), 471 m_ranges(), 472 m_unique_ast_type_map () 473 { 474 } 475 476 SymbolFileDWARF::~SymbolFileDWARF() 477 { 478 } 479 480 static const ConstString & 481 GetDWARFMachOSegmentName () 482 { 483 static ConstString g_dwarf_section_name ("__DWARF"); 484 return g_dwarf_section_name; 485 } 486 487 UniqueDWARFASTTypeMap & 488 SymbolFileDWARF::GetUniqueDWARFASTTypeMap () 489 { 490 SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile(); 491 if (debug_map_symfile) 492 return debug_map_symfile->GetUniqueDWARFASTTypeMap (); 493 else 494 return m_unique_ast_type_map; 495 } 496 497 TypeSystem * 498 SymbolFileDWARF::GetTypeSystemForLanguage (LanguageType language) 499 { 500 SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile(); 501 TypeSystem *type_system; 502 if (debug_map_symfile) 503 { 504 type_system = debug_map_symfile->GetTypeSystemForLanguage(language); 505 } 506 else 507 { 508 type_system = m_obj_file->GetModule()->GetTypeSystemForLanguage(language); 509 if (type_system) 510 type_system->SetSymbolFile(this); 511 } 512 return type_system; 513 } 514 515 void 516 SymbolFileDWARF::InitializeObject() 517 { 518 ModuleSP module_sp (m_obj_file->GetModule()); 519 if (module_sp) 520 { 521 const SectionList *section_list = module_sp->GetSectionList(); 522 const Section* section = section_list->FindSectionByName(GetDWARFMachOSegmentName ()).get(); 523 524 // Memory map the DWARF mach-o segment so we have everything mmap'ed 525 // to keep our heap memory usage down. 526 if (section) 527 m_obj_file->MemoryMapSectionData(section, m_dwarf_data); 528 } 529 530 get_apple_names_data(); 531 if (m_data_apple_names.m_data.GetByteSize() > 0) 532 { 533 m_apple_names_ap.reset (new DWARFMappedHash::MemoryTable (m_data_apple_names.m_data, 534 get_debug_str_data(), 535 ".apple_names")); 536 if (m_apple_names_ap->IsValid()) 537 m_using_apple_tables = true; 538 else 539 m_apple_names_ap.reset(); 540 } 541 get_apple_types_data(); 542 if (m_data_apple_types.m_data.GetByteSize() > 0) 543 { 544 m_apple_types_ap.reset (new DWARFMappedHash::MemoryTable (m_data_apple_types.m_data, 545 get_debug_str_data(), 546 ".apple_types")); 547 if (m_apple_types_ap->IsValid()) 548 m_using_apple_tables = true; 549 else 550 m_apple_types_ap.reset(); 551 } 552 553 get_apple_namespaces_data(); 554 if (m_data_apple_namespaces.m_data.GetByteSize() > 0) 555 { 556 m_apple_namespaces_ap.reset (new DWARFMappedHash::MemoryTable (m_data_apple_namespaces.m_data, 557 get_debug_str_data(), 558 ".apple_namespaces")); 559 if (m_apple_namespaces_ap->IsValid()) 560 m_using_apple_tables = true; 561 else 562 m_apple_namespaces_ap.reset(); 563 } 564 565 get_apple_objc_data(); 566 if (m_data_apple_objc.m_data.GetByteSize() > 0) 567 { 568 m_apple_objc_ap.reset (new DWARFMappedHash::MemoryTable (m_data_apple_objc.m_data, 569 get_debug_str_data(), 570 ".apple_objc")); 571 if (m_apple_objc_ap->IsValid()) 572 m_using_apple_tables = true; 573 else 574 m_apple_objc_ap.reset(); 575 } 576 } 577 578 bool 579 SymbolFileDWARF::SupportedVersion(uint16_t version) 580 { 581 return version == 2 || version == 3 || version == 4; 582 } 583 584 uint32_t 585 SymbolFileDWARF::CalculateAbilities () 586 { 587 uint32_t abilities = 0; 588 if (m_obj_file != NULL) 589 { 590 const Section* section = NULL; 591 const SectionList *section_list = m_obj_file->GetSectionList(); 592 if (section_list == NULL) 593 return 0; 594 595 uint64_t debug_abbrev_file_size = 0; 596 uint64_t debug_info_file_size = 0; 597 uint64_t debug_line_file_size = 0; 598 599 section = section_list->FindSectionByName(GetDWARFMachOSegmentName ()).get(); 600 601 if (section) 602 section_list = §ion->GetChildren (); 603 604 section = section_list->FindSectionByType (eSectionTypeDWARFDebugInfo, true).get(); 605 if (section != NULL) 606 { 607 debug_info_file_size = section->GetFileSize(); 608 609 section = section_list->FindSectionByType (eSectionTypeDWARFDebugAbbrev, true).get(); 610 if (section) 611 debug_abbrev_file_size = section->GetFileSize(); 612 613 section = section_list->FindSectionByType (eSectionTypeDWARFDebugLine, true).get(); 614 if (section) 615 debug_line_file_size = section->GetFileSize(); 616 } 617 else 618 { 619 const char *symfile_dir_cstr = m_obj_file->GetFileSpec().GetDirectory().GetCString(); 620 if (symfile_dir_cstr) 621 { 622 if (strcasestr(symfile_dir_cstr, ".dsym")) 623 { 624 if (m_obj_file->GetType() == ObjectFile::eTypeDebugInfo) 625 { 626 // We have a dSYM file that didn't have a any debug info. 627 // If the string table has a size of 1, then it was made from 628 // an executable with no debug info, or from an executable that 629 // was stripped. 630 section = section_list->FindSectionByType (eSectionTypeDWARFDebugStr, true).get(); 631 if (section && section->GetFileSize() == 1) 632 { 633 m_obj_file->GetModule()->ReportWarning ("empty dSYM file detected, dSYM was created with an executable with no debug info."); 634 } 635 } 636 } 637 } 638 } 639 640 if (debug_abbrev_file_size > 0 && debug_info_file_size > 0) 641 abilities |= CompileUnits | Functions | Blocks | GlobalVariables | LocalVariables | VariableTypes; 642 643 if (debug_line_file_size > 0) 644 abilities |= LineTables; 645 } 646 return abilities; 647 } 648 649 const DWARFDataExtractor& 650 SymbolFileDWARF::GetCachedSectionData (lldb::SectionType sect_type, DWARFDataSegment& data_segment) 651 { 652 std::call_once(data_segment.m_flag, 653 &SymbolFileDWARF::LoadSectionData, 654 this, 655 sect_type, 656 std::ref(data_segment.m_data)); 657 return data_segment.m_data; 658 } 659 660 void 661 SymbolFileDWARF::LoadSectionData (lldb::SectionType sect_type, DWARFDataExtractor& data) 662 { 663 ModuleSP module_sp (m_obj_file->GetModule()); 664 const SectionList *section_list = module_sp->GetSectionList(); 665 if (section_list) 666 { 667 SectionSP section_sp (section_list->FindSectionByType(sect_type, true)); 668 if (section_sp) 669 { 670 // See if we memory mapped the DWARF segment? 671 if (m_dwarf_data.GetByteSize()) 672 { 673 data.SetData(m_dwarf_data, section_sp->GetOffset(), section_sp->GetFileSize()); 674 } 675 else 676 { 677 if (m_obj_file->ReadSectionData(section_sp.get(), data) == 0) 678 data.Clear(); 679 } 680 } 681 } 682 } 683 684 const DWARFDataExtractor& 685 SymbolFileDWARF::get_debug_abbrev_data() 686 { 687 return GetCachedSectionData (eSectionTypeDWARFDebugAbbrev, m_data_debug_abbrev); 688 } 689 690 const DWARFDataExtractor& 691 SymbolFileDWARF::get_debug_addr_data() 692 { 693 return GetCachedSectionData (eSectionTypeDWARFDebugAddr, m_data_debug_addr); 694 } 695 696 const DWARFDataExtractor& 697 SymbolFileDWARF::get_debug_aranges_data() 698 { 699 return GetCachedSectionData (eSectionTypeDWARFDebugAranges, m_data_debug_aranges); 700 } 701 702 const DWARFDataExtractor& 703 SymbolFileDWARF::get_debug_frame_data() 704 { 705 return GetCachedSectionData (eSectionTypeDWARFDebugFrame, m_data_debug_frame); 706 } 707 708 const DWARFDataExtractor& 709 SymbolFileDWARF::get_debug_info_data() 710 { 711 return GetCachedSectionData (eSectionTypeDWARFDebugInfo, m_data_debug_info); 712 } 713 714 const DWARFDataExtractor& 715 SymbolFileDWARF::get_debug_line_data() 716 { 717 return GetCachedSectionData (eSectionTypeDWARFDebugLine, m_data_debug_line); 718 } 719 720 const DWARFDataExtractor& 721 SymbolFileDWARF::get_debug_macro_data() 722 { 723 return GetCachedSectionData (eSectionTypeDWARFDebugMacro, m_data_debug_macro); 724 } 725 726 const DWARFDataExtractor& 727 SymbolFileDWARF::get_debug_loc_data() 728 { 729 return GetCachedSectionData (eSectionTypeDWARFDebugLoc, m_data_debug_loc); 730 } 731 732 const DWARFDataExtractor& 733 SymbolFileDWARF::get_debug_ranges_data() 734 { 735 return GetCachedSectionData (eSectionTypeDWARFDebugRanges, m_data_debug_ranges); 736 } 737 738 const DWARFDataExtractor& 739 SymbolFileDWARF::get_debug_str_data() 740 { 741 return GetCachedSectionData (eSectionTypeDWARFDebugStr, m_data_debug_str); 742 } 743 744 const DWARFDataExtractor& 745 SymbolFileDWARF::get_debug_str_offsets_data() 746 { 747 return GetCachedSectionData (eSectionTypeDWARFDebugStrOffsets, m_data_debug_str_offsets); 748 } 749 750 const DWARFDataExtractor& 751 SymbolFileDWARF::get_apple_names_data() 752 { 753 return GetCachedSectionData (eSectionTypeDWARFAppleNames, m_data_apple_names); 754 } 755 756 const DWARFDataExtractor& 757 SymbolFileDWARF::get_apple_types_data() 758 { 759 return GetCachedSectionData (eSectionTypeDWARFAppleTypes, m_data_apple_types); 760 } 761 762 const DWARFDataExtractor& 763 SymbolFileDWARF::get_apple_namespaces_data() 764 { 765 return GetCachedSectionData (eSectionTypeDWARFAppleNamespaces, m_data_apple_namespaces); 766 } 767 768 const DWARFDataExtractor& 769 SymbolFileDWARF::get_apple_objc_data() 770 { 771 return GetCachedSectionData (eSectionTypeDWARFAppleObjC, m_data_apple_objc); 772 } 773 774 775 DWARFDebugAbbrev* 776 SymbolFileDWARF::DebugAbbrev() 777 { 778 if (m_abbr.get() == NULL) 779 { 780 const DWARFDataExtractor &debug_abbrev_data = get_debug_abbrev_data(); 781 if (debug_abbrev_data.GetByteSize() > 0) 782 { 783 m_abbr.reset(new DWARFDebugAbbrev()); 784 if (m_abbr.get()) 785 m_abbr->Parse(debug_abbrev_data); 786 } 787 } 788 return m_abbr.get(); 789 } 790 791 const DWARFDebugAbbrev* 792 SymbolFileDWARF::DebugAbbrev() const 793 { 794 return m_abbr.get(); 795 } 796 797 798 DWARFDebugInfo* 799 SymbolFileDWARF::DebugInfo() 800 { 801 if (m_info.get() == NULL) 802 { 803 Timer scoped_timer(__PRETTY_FUNCTION__, "%s this = %p", 804 __PRETTY_FUNCTION__, static_cast<void*>(this)); 805 if (get_debug_info_data().GetByteSize() > 0) 806 { 807 m_info.reset(new DWARFDebugInfo()); 808 if (m_info.get()) 809 { 810 m_info->SetDwarfData(this); 811 } 812 } 813 } 814 return m_info.get(); 815 } 816 817 const DWARFDebugInfo* 818 SymbolFileDWARF::DebugInfo() const 819 { 820 return m_info.get(); 821 } 822 823 DWARFCompileUnit* 824 SymbolFileDWARF::GetDWARFCompileUnit(lldb_private::CompileUnit *comp_unit) 825 { 826 if (!comp_unit) 827 return nullptr; 828 829 DWARFDebugInfo* info = DebugInfo(); 830 if (info) 831 { 832 // Just a normal DWARF file whose user ID for the compile unit is 833 // the DWARF offset itself 834 835 DWARFCompileUnit *dwarf_cu = info->GetCompileUnit((dw_offset_t)comp_unit->GetID()); 836 if (dwarf_cu && dwarf_cu->GetUserData() == NULL) 837 dwarf_cu->SetUserData(comp_unit); 838 return dwarf_cu; 839 } 840 return NULL; 841 } 842 843 844 DWARFDebugRanges* 845 SymbolFileDWARF::DebugRanges() 846 { 847 if (m_ranges.get() == NULL) 848 { 849 Timer scoped_timer(__PRETTY_FUNCTION__, "%s this = %p", 850 __PRETTY_FUNCTION__, static_cast<void*>(this)); 851 if (get_debug_ranges_data().GetByteSize() > 0) 852 { 853 m_ranges.reset(new DWARFDebugRanges()); 854 if (m_ranges.get()) 855 m_ranges->Extract(this); 856 } 857 } 858 return m_ranges.get(); 859 } 860 861 const DWARFDebugRanges* 862 SymbolFileDWARF::DebugRanges() const 863 { 864 return m_ranges.get(); 865 } 866 867 lldb::CompUnitSP 868 SymbolFileDWARF::ParseCompileUnit (DWARFCompileUnit* dwarf_cu, uint32_t cu_idx) 869 { 870 CompUnitSP cu_sp; 871 if (dwarf_cu) 872 { 873 CompileUnit *comp_unit = (CompileUnit*)dwarf_cu->GetUserData(); 874 if (comp_unit) 875 { 876 // We already parsed this compile unit, had out a shared pointer to it 877 cu_sp = comp_unit->shared_from_this(); 878 } 879 else 880 { 881 if (dwarf_cu->GetSymbolFileDWARF() != this) 882 { 883 return dwarf_cu->GetSymbolFileDWARF()->ParseCompileUnit(dwarf_cu, cu_idx); 884 } 885 else if (dwarf_cu->GetOffset() == 0 && GetDebugMapSymfile ()) 886 { 887 // Let the debug map create the compile unit 888 cu_sp = m_debug_map_symfile->GetCompileUnit(this); 889 dwarf_cu->SetUserData(cu_sp.get()); 890 } 891 else 892 { 893 ModuleSP module_sp (m_obj_file->GetModule()); 894 if (module_sp) 895 { 896 const DWARFDIE cu_die = dwarf_cu->GetCompileUnitDIEOnly (); 897 if (cu_die) 898 { 899 FileSpec cu_file_spec{cu_die.GetName(), false}; 900 if (cu_file_spec) 901 { 902 // If we have a full path to the compile unit, we don't need to resolve 903 // the file. This can be expensive e.g. when the source files are NFS mounted. 904 if (cu_file_spec.IsRelative()) 905 { 906 const char *cu_comp_dir{cu_die.GetAttributeValueAsString(DW_AT_comp_dir, nullptr)}; 907 cu_file_spec.PrependPathComponent(resolveCompDir(cu_comp_dir)); 908 } 909 910 std::string remapped_file; 911 if (module_sp->RemapSourceFile(cu_file_spec.GetCString(), remapped_file)) 912 cu_file_spec.SetFile(remapped_file, false); 913 } 914 915 LanguageType cu_language = DWARFCompileUnit::LanguageTypeFromDWARF(cu_die.GetAttributeValueAsUnsigned(DW_AT_language, 0)); 916 917 bool is_optimized = dwarf_cu->GetIsOptimized (); 918 cu_sp.reset(new CompileUnit (module_sp, 919 dwarf_cu, 920 cu_file_spec, 921 dwarf_cu->GetID(), 922 cu_language, 923 is_optimized)); 924 if (cu_sp) 925 { 926 // If we just created a compile unit with an invalid file spec, try and get the 927 // first entry in the supports files from the line table as that should be the 928 // compile unit. 929 if (!cu_file_spec) 930 { 931 cu_file_spec = cu_sp->GetSupportFiles().GetFileSpecAtIndex(1); 932 if (cu_file_spec) 933 { 934 (FileSpec &)(*cu_sp) = cu_file_spec; 935 // Also fix the invalid file spec which was copied from the compile unit. 936 cu_sp->GetSupportFiles().Replace(0, cu_file_spec); 937 } 938 } 939 940 dwarf_cu->SetUserData(cu_sp.get()); 941 942 // Figure out the compile unit index if we weren't given one 943 if (cu_idx == UINT32_MAX) 944 DebugInfo()->GetCompileUnit(dwarf_cu->GetOffset(), &cu_idx); 945 946 m_obj_file->GetModule()->GetSymbolVendor()->SetCompileUnitAtIndex(cu_idx, cu_sp); 947 } 948 } 949 } 950 } 951 } 952 } 953 return cu_sp; 954 } 955 956 uint32_t 957 SymbolFileDWARF::GetNumCompileUnits() 958 { 959 DWARFDebugInfo* info = DebugInfo(); 960 if (info) 961 return info->GetNumCompileUnits(); 962 return 0; 963 } 964 965 CompUnitSP 966 SymbolFileDWARF::ParseCompileUnitAtIndex(uint32_t cu_idx) 967 { 968 CompUnitSP cu_sp; 969 DWARFDebugInfo* info = DebugInfo(); 970 if (info) 971 { 972 DWARFCompileUnit* dwarf_cu = info->GetCompileUnitAtIndex(cu_idx); 973 if (dwarf_cu) 974 cu_sp = ParseCompileUnit(dwarf_cu, cu_idx); 975 } 976 return cu_sp; 977 } 978 979 Function * 980 SymbolFileDWARF::ParseCompileUnitFunction (const SymbolContext& sc, const DWARFDIE &die) 981 { 982 if (die.IsValid()) 983 { 984 TypeSystem *type_system = GetTypeSystemForLanguage(die.GetCU()->GetLanguageType()); 985 986 if (type_system) 987 { 988 DWARFASTParser *dwarf_ast = type_system->GetDWARFParser(); 989 if (dwarf_ast) 990 return dwarf_ast->ParseFunctionFromDWARF(sc, die); 991 } 992 } 993 return nullptr; 994 } 995 996 bool 997 SymbolFileDWARF::FixupAddress (Address &addr) 998 { 999 SymbolFileDWARFDebugMap * debug_map_symfile = GetDebugMapSymfile(); 1000 if (debug_map_symfile) 1001 { 1002 return debug_map_symfile->LinkOSOAddress(addr); 1003 } 1004 // This is a normal DWARF file, no address fixups need to happen 1005 return true; 1006 } 1007 lldb::LanguageType 1008 SymbolFileDWARF::ParseCompileUnitLanguage (const SymbolContext& sc) 1009 { 1010 assert (sc.comp_unit); 1011 DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit); 1012 if (dwarf_cu) 1013 return dwarf_cu->GetLanguageType(); 1014 else 1015 return eLanguageTypeUnknown; 1016 } 1017 1018 size_t 1019 SymbolFileDWARF::ParseCompileUnitFunctions(const SymbolContext &sc) 1020 { 1021 assert (sc.comp_unit); 1022 size_t functions_added = 0; 1023 DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit); 1024 if (dwarf_cu) 1025 { 1026 DWARFDIECollection function_dies; 1027 const size_t num_functions = dwarf_cu->AppendDIEsWithTag (DW_TAG_subprogram, function_dies); 1028 size_t func_idx; 1029 for (func_idx = 0; func_idx < num_functions; ++func_idx) 1030 { 1031 DWARFDIE die = function_dies.GetDIEAtIndex(func_idx); 1032 if (sc.comp_unit->FindFunctionByUID (die.GetID()).get() == NULL) 1033 { 1034 if (ParseCompileUnitFunction(sc, die)) 1035 ++functions_added; 1036 } 1037 } 1038 //FixupTypes(); 1039 } 1040 return functions_added; 1041 } 1042 1043 bool 1044 SymbolFileDWARF::ParseCompileUnitSupportFiles (const SymbolContext& sc, FileSpecList& support_files) 1045 { 1046 assert (sc.comp_unit); 1047 DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit); 1048 if (dwarf_cu) 1049 { 1050 const DWARFDIE cu_die = dwarf_cu->GetCompileUnitDIEOnly(); 1051 1052 if (cu_die) 1053 { 1054 const char * cu_comp_dir = resolveCompDir(cu_die.GetAttributeValueAsString(DW_AT_comp_dir, nullptr)); 1055 const dw_offset_t stmt_list = cu_die.GetAttributeValueAsUnsigned(DW_AT_stmt_list, DW_INVALID_OFFSET); 1056 if (stmt_list != DW_INVALID_OFFSET) 1057 { 1058 // All file indexes in DWARF are one based and a file of index zero is 1059 // supposed to be the compile unit itself. 1060 support_files.Append (*sc.comp_unit); 1061 return DWARFDebugLine::ParseSupportFiles(sc.comp_unit->GetModule(), 1062 get_debug_line_data(), 1063 cu_comp_dir, 1064 stmt_list, 1065 support_files); 1066 } 1067 } 1068 } 1069 return false; 1070 } 1071 1072 bool 1073 SymbolFileDWARF::ParseImportedModules (const lldb_private::SymbolContext &sc, std::vector<lldb_private::ConstString> &imported_modules) 1074 { 1075 assert (sc.comp_unit); 1076 DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit); 1077 if (dwarf_cu) 1078 { 1079 if (ClangModulesDeclVendor::LanguageSupportsClangModules(sc.comp_unit->GetLanguage())) 1080 { 1081 UpdateExternalModuleListIfNeeded(); 1082 1083 if (sc.comp_unit) 1084 { 1085 const DWARFDIE die = dwarf_cu->GetCompileUnitDIEOnly(); 1086 1087 if (die) 1088 { 1089 for (DWARFDIE child_die = die.GetFirstChild(); 1090 child_die; 1091 child_die = child_die.GetSibling()) 1092 { 1093 if (child_die.Tag() == DW_TAG_imported_declaration) 1094 { 1095 if (DWARFDIE module_die = child_die.GetReferencedDIE(DW_AT_import)) 1096 { 1097 if (module_die.Tag() == DW_TAG_module) 1098 { 1099 if (const char *name = module_die.GetAttributeValueAsString(DW_AT_name, nullptr)) 1100 { 1101 ConstString const_name(name); 1102 imported_modules.push_back(const_name); 1103 } 1104 } 1105 } 1106 } 1107 } 1108 } 1109 } 1110 else 1111 { 1112 for (const auto &pair : m_external_type_modules) 1113 { 1114 imported_modules.push_back(pair.first); 1115 } 1116 } 1117 } 1118 } 1119 return false; 1120 } 1121 1122 struct ParseDWARFLineTableCallbackInfo 1123 { 1124 LineTable* line_table; 1125 std::unique_ptr<LineSequence> sequence_ap; 1126 lldb::addr_t addr_mask; 1127 }; 1128 1129 //---------------------------------------------------------------------- 1130 // ParseStatementTableCallback 1131 //---------------------------------------------------------------------- 1132 static void 1133 ParseDWARFLineTableCallback(dw_offset_t offset, const DWARFDebugLine::State& state, void* userData) 1134 { 1135 if (state.row == DWARFDebugLine::State::StartParsingLineTable) 1136 { 1137 // Just started parsing the line table 1138 } 1139 else if (state.row == DWARFDebugLine::State::DoneParsingLineTable) 1140 { 1141 // Done parsing line table, nothing to do for the cleanup 1142 } 1143 else 1144 { 1145 ParseDWARFLineTableCallbackInfo* info = (ParseDWARFLineTableCallbackInfo*)userData; 1146 LineTable* line_table = info->line_table; 1147 1148 // If this is our first time here, we need to create a 1149 // sequence container. 1150 if (!info->sequence_ap.get()) 1151 { 1152 info->sequence_ap.reset(line_table->CreateLineSequenceContainer()); 1153 assert(info->sequence_ap.get()); 1154 } 1155 line_table->AppendLineEntryToSequence (info->sequence_ap.get(), 1156 state.address & info->addr_mask, 1157 state.line, 1158 state.column, 1159 state.file, 1160 state.is_stmt, 1161 state.basic_block, 1162 state.prologue_end, 1163 state.epilogue_begin, 1164 state.end_sequence); 1165 if (state.end_sequence) 1166 { 1167 // First, put the current sequence into the line table. 1168 line_table->InsertSequence(info->sequence_ap.get()); 1169 // Then, empty it to prepare for the next sequence. 1170 info->sequence_ap->Clear(); 1171 } 1172 } 1173 } 1174 1175 bool 1176 SymbolFileDWARF::ParseCompileUnitLineTable (const SymbolContext &sc) 1177 { 1178 assert (sc.comp_unit); 1179 if (sc.comp_unit->GetLineTable() != NULL) 1180 return true; 1181 1182 DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit); 1183 if (dwarf_cu) 1184 { 1185 const DWARFDIE dwarf_cu_die = dwarf_cu->GetCompileUnitDIEOnly(); 1186 if (dwarf_cu_die) 1187 { 1188 const dw_offset_t cu_line_offset = dwarf_cu_die.GetAttributeValueAsUnsigned(DW_AT_stmt_list, DW_INVALID_OFFSET); 1189 if (cu_line_offset != DW_INVALID_OFFSET) 1190 { 1191 std::unique_ptr<LineTable> line_table_ap(new LineTable(sc.comp_unit)); 1192 if (line_table_ap.get()) 1193 { 1194 ParseDWARFLineTableCallbackInfo info; 1195 info.line_table = line_table_ap.get(); 1196 1197 /* 1198 * MIPS: 1199 * The SymbolContext may not have a valid target, thus we may not be able 1200 * to call Address::GetOpcodeLoadAddress() which would clear the bit #0 1201 * for MIPS. Use ArchSpec to clear the bit #0. 1202 */ 1203 ArchSpec arch; 1204 GetObjectFile()->GetArchitecture(arch); 1205 switch (arch.GetMachine()) 1206 { 1207 case llvm::Triple::mips: 1208 case llvm::Triple::mipsel: 1209 case llvm::Triple::mips64: 1210 case llvm::Triple::mips64el: 1211 info.addr_mask = ~((lldb::addr_t)1); 1212 break; 1213 default: 1214 info.addr_mask = ~((lldb::addr_t)0); 1215 break; 1216 } 1217 1218 lldb::offset_t offset = cu_line_offset; 1219 DWARFDebugLine::ParseStatementTable(get_debug_line_data(), &offset, ParseDWARFLineTableCallback, &info); 1220 SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile(); 1221 if (debug_map_symfile) 1222 { 1223 // We have an object file that has a line table with addresses 1224 // that are not linked. We need to link the line table and convert 1225 // the addresses that are relative to the .o file into addresses 1226 // for the main executable. 1227 sc.comp_unit->SetLineTable (debug_map_symfile->LinkOSOLineTable (this, line_table_ap.get())); 1228 } 1229 else 1230 { 1231 sc.comp_unit->SetLineTable(line_table_ap.release()); 1232 return true; 1233 } 1234 } 1235 } 1236 } 1237 } 1238 return false; 1239 } 1240 1241 lldb_private::DebugMacrosSP 1242 SymbolFileDWARF::ParseDebugMacros(lldb::offset_t *offset) 1243 { 1244 auto iter = m_debug_macros_map.find(*offset); 1245 if (iter != m_debug_macros_map.end()) 1246 return iter->second; 1247 1248 const DWARFDataExtractor &debug_macro_data = get_debug_macro_data(); 1249 if (debug_macro_data.GetByteSize() == 0) 1250 return DebugMacrosSP(); 1251 1252 lldb_private::DebugMacrosSP debug_macros_sp(new lldb_private::DebugMacros()); 1253 m_debug_macros_map[*offset] = debug_macros_sp; 1254 1255 const DWARFDebugMacroHeader &header = DWARFDebugMacroHeader::ParseHeader(debug_macro_data, offset); 1256 DWARFDebugMacroEntry::ReadMacroEntries( 1257 debug_macro_data, get_debug_str_data(), header.OffsetIs64Bit(), offset, this, debug_macros_sp); 1258 1259 return debug_macros_sp; 1260 } 1261 1262 bool 1263 SymbolFileDWARF::ParseCompileUnitDebugMacros(const SymbolContext& sc) 1264 { 1265 assert (sc.comp_unit); 1266 1267 DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit); 1268 if (dwarf_cu == nullptr) 1269 return false; 1270 1271 const DWARFDIE dwarf_cu_die = dwarf_cu->GetCompileUnitDIEOnly(); 1272 if (!dwarf_cu_die) 1273 return false; 1274 1275 lldb::offset_t sect_offset = dwarf_cu_die.GetAttributeValueAsUnsigned(DW_AT_macros, DW_INVALID_OFFSET); 1276 if (sect_offset == DW_INVALID_OFFSET) 1277 sect_offset = dwarf_cu_die.GetAttributeValueAsUnsigned(DW_AT_GNU_macros, DW_INVALID_OFFSET); 1278 if (sect_offset == DW_INVALID_OFFSET) 1279 return false; 1280 1281 sc.comp_unit->SetDebugMacros(ParseDebugMacros(§_offset)); 1282 1283 return true; 1284 } 1285 1286 size_t 1287 SymbolFileDWARF::ParseFunctionBlocks (const SymbolContext& sc, 1288 Block *parent_block, 1289 const DWARFDIE &orig_die, 1290 addr_t subprogram_low_pc, 1291 uint32_t depth) 1292 { 1293 size_t blocks_added = 0; 1294 DWARFDIE die = orig_die; 1295 while (die) 1296 { 1297 dw_tag_t tag = die.Tag(); 1298 1299 switch (tag) 1300 { 1301 case DW_TAG_inlined_subroutine: 1302 case DW_TAG_subprogram: 1303 case DW_TAG_lexical_block: 1304 { 1305 Block *block = NULL; 1306 if (tag == DW_TAG_subprogram) 1307 { 1308 // Skip any DW_TAG_subprogram DIEs that are inside 1309 // of a normal or inlined functions. These will be 1310 // parsed on their own as separate entities. 1311 1312 if (depth > 0) 1313 break; 1314 1315 block = parent_block; 1316 } 1317 else 1318 { 1319 BlockSP block_sp(new Block (die.GetID())); 1320 parent_block->AddChild(block_sp); 1321 block = block_sp.get(); 1322 } 1323 DWARFRangeList ranges; 1324 const char *name = NULL; 1325 const char *mangled_name = NULL; 1326 1327 int decl_file = 0; 1328 int decl_line = 0; 1329 int decl_column = 0; 1330 int call_file = 0; 1331 int call_line = 0; 1332 int call_column = 0; 1333 if (die.GetDIENamesAndRanges (name, 1334 mangled_name, 1335 ranges, 1336 decl_file, decl_line, decl_column, 1337 call_file, call_line, call_column, nullptr)) 1338 { 1339 if (tag == DW_TAG_subprogram) 1340 { 1341 assert (subprogram_low_pc == LLDB_INVALID_ADDRESS); 1342 subprogram_low_pc = ranges.GetMinRangeBase(0); 1343 } 1344 else if (tag == DW_TAG_inlined_subroutine) 1345 { 1346 // We get called here for inlined subroutines in two ways. 1347 // The first time is when we are making the Function object 1348 // for this inlined concrete instance. Since we're creating a top level block at 1349 // here, the subprogram_low_pc will be LLDB_INVALID_ADDRESS. So we need to 1350 // adjust the containing address. 1351 // The second time is when we are parsing the blocks inside the function that contains 1352 // the inlined concrete instance. Since these will be blocks inside the containing "real" 1353 // function the offset will be for that function. 1354 if (subprogram_low_pc == LLDB_INVALID_ADDRESS) 1355 { 1356 subprogram_low_pc = ranges.GetMinRangeBase(0); 1357 } 1358 } 1359 1360 const size_t num_ranges = ranges.GetSize(); 1361 for (size_t i = 0; i<num_ranges; ++i) 1362 { 1363 const DWARFRangeList::Entry &range = ranges.GetEntryRef (i); 1364 const addr_t range_base = range.GetRangeBase(); 1365 if (range_base >= subprogram_low_pc) 1366 block->AddRange(Block::Range (range_base - subprogram_low_pc, range.GetByteSize())); 1367 else 1368 { 1369 GetObjectFile()->GetModule()->ReportError ("0x%8.8" PRIx64 ": adding range [0x%" PRIx64 "-0x%" PRIx64 ") which has a base that is less than the function's low PC 0x%" PRIx64 ". Please file a bug and attach the file at the start of this error message", 1370 block->GetID(), 1371 range_base, 1372 range.GetRangeEnd(), 1373 subprogram_low_pc); 1374 } 1375 } 1376 block->FinalizeRanges (); 1377 1378 if (tag != DW_TAG_subprogram && (name != NULL || mangled_name != NULL)) 1379 { 1380 std::unique_ptr<Declaration> decl_ap; 1381 if (decl_file != 0 || decl_line != 0 || decl_column != 0) 1382 decl_ap.reset(new Declaration(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(decl_file), 1383 decl_line, decl_column)); 1384 1385 std::unique_ptr<Declaration> call_ap; 1386 if (call_file != 0 || call_line != 0 || call_column != 0) 1387 call_ap.reset(new Declaration(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(call_file), 1388 call_line, call_column)); 1389 1390 block->SetInlinedFunctionInfo (name, mangled_name, decl_ap.get(), call_ap.get()); 1391 } 1392 1393 ++blocks_added; 1394 1395 if (die.HasChildren()) 1396 { 1397 blocks_added += ParseFunctionBlocks (sc, 1398 block, 1399 die.GetFirstChild(), 1400 subprogram_low_pc, 1401 depth + 1); 1402 } 1403 } 1404 } 1405 break; 1406 default: 1407 break; 1408 } 1409 1410 // Only parse siblings of the block if we are not at depth zero. A depth 1411 // of zero indicates we are currently parsing the top level 1412 // DW_TAG_subprogram DIE 1413 1414 if (depth == 0) 1415 die.Clear(); 1416 else 1417 die = die.GetSibling(); 1418 } 1419 return blocks_added; 1420 } 1421 1422 bool 1423 SymbolFileDWARF::ClassOrStructIsVirtual (const DWARFDIE &parent_die) 1424 { 1425 if (parent_die) 1426 { 1427 for (DWARFDIE die = parent_die.GetFirstChild(); die; die = die.GetSibling()) 1428 { 1429 dw_tag_t tag = die.Tag(); 1430 bool check_virtuality = false; 1431 switch (tag) 1432 { 1433 case DW_TAG_inheritance: 1434 case DW_TAG_subprogram: 1435 check_virtuality = true; 1436 break; 1437 default: 1438 break; 1439 } 1440 if (check_virtuality) 1441 { 1442 if (die.GetAttributeValueAsUnsigned(DW_AT_virtuality, 0) != 0) 1443 return true; 1444 } 1445 } 1446 } 1447 return false; 1448 } 1449 1450 void 1451 SymbolFileDWARF::ParseDeclsForContext (CompilerDeclContext decl_ctx) 1452 { 1453 TypeSystem *type_system = decl_ctx.GetTypeSystem(); 1454 DWARFASTParser *ast_parser = type_system->GetDWARFParser(); 1455 std::vector<DWARFDIE> decl_ctx_die_list = ast_parser->GetDIEForDeclContext(decl_ctx); 1456 1457 for (DWARFDIE decl_ctx_die : decl_ctx_die_list) 1458 for (DWARFDIE decl = decl_ctx_die.GetFirstChild(); decl; decl = decl.GetSibling()) 1459 ast_parser->GetDeclForUIDFromDWARF(decl); 1460 } 1461 1462 SymbolFileDWARF * 1463 SymbolFileDWARF::GetDWARFForUID (lldb::user_id_t uid) 1464 { 1465 // Anytime we get a "lldb::user_id_t" from an lldb_private::SymbolFile API 1466 // we must make sure we use the correct DWARF file when resolving things. 1467 // On MacOSX, when using SymbolFileDWARFDebugMap, we will use multiple 1468 // SymbolFileDWARF classes, one for each .o file. We can often end up 1469 // with references to other DWARF objects and we must be ready to receive 1470 // a "lldb::user_id_t" that specifies a DIE from another SymbolFileDWARF 1471 // instance. 1472 SymbolFileDWARFDebugMap *debug_map = GetDebugMapSymfile(); 1473 if (debug_map) 1474 return debug_map->GetSymbolFileByOSOIndex(debug_map->GetOSOIndexFromUserID(uid)); 1475 return this; 1476 } 1477 1478 DWARFDIE 1479 SymbolFileDWARF::GetDIEFromUID (lldb::user_id_t uid) 1480 { 1481 // Anytime we get a "lldb::user_id_t" from an lldb_private::SymbolFile API 1482 // we must make sure we use the correct DWARF file when resolving things. 1483 // On MacOSX, when using SymbolFileDWARFDebugMap, we will use multiple 1484 // SymbolFileDWARF classes, one for each .o file. We can often end up 1485 // with references to other DWARF objects and we must be ready to receive 1486 // a "lldb::user_id_t" that specifies a DIE from another SymbolFileDWARF 1487 // instance. 1488 SymbolFileDWARF *dwarf = GetDWARFForUID(uid); 1489 if (dwarf) 1490 return dwarf->GetDIE(DIERef(uid, dwarf)); 1491 return DWARFDIE(); 1492 } 1493 1494 CompilerDecl 1495 SymbolFileDWARF::GetDeclForUID (lldb::user_id_t type_uid) 1496 { 1497 // Anytime we have a lldb::user_id_t, we must get the DIE by 1498 // calling SymbolFileDWARF::GetDIEFromUID(). See comments inside 1499 // the SymbolFileDWARF::GetDIEFromUID() for details. 1500 DWARFDIE die = GetDIEFromUID(type_uid); 1501 if (die) 1502 return die.GetDecl(); 1503 return CompilerDecl(); 1504 } 1505 1506 CompilerDeclContext 1507 SymbolFileDWARF::GetDeclContextForUID (lldb::user_id_t type_uid) 1508 { 1509 // Anytime we have a lldb::user_id_t, we must get the DIE by 1510 // calling SymbolFileDWARF::GetDIEFromUID(). See comments inside 1511 // the SymbolFileDWARF::GetDIEFromUID() for details. 1512 DWARFDIE die = GetDIEFromUID(type_uid); 1513 if (die) 1514 return die.GetDeclContext(); 1515 return CompilerDeclContext(); 1516 } 1517 1518 CompilerDeclContext 1519 SymbolFileDWARF::GetDeclContextContainingUID (lldb::user_id_t type_uid) 1520 { 1521 // Anytime we have a lldb::user_id_t, we must get the DIE by 1522 // calling SymbolFileDWARF::GetDIEFromUID(). See comments inside 1523 // the SymbolFileDWARF::GetDIEFromUID() for details. 1524 DWARFDIE die = GetDIEFromUID(type_uid); 1525 if (die) 1526 return die.GetContainingDeclContext(); 1527 return CompilerDeclContext(); 1528 } 1529 1530 1531 Type* 1532 SymbolFileDWARF::ResolveTypeUID (lldb::user_id_t type_uid) 1533 { 1534 // Anytime we have a lldb::user_id_t, we must get the DIE by 1535 // calling SymbolFileDWARF::GetDIEFromUID(). See comments inside 1536 // the SymbolFileDWARF::GetDIEFromUID() for details. 1537 DWARFDIE type_die = GetDIEFromUID(type_uid); 1538 if (type_die) 1539 return type_die.ResolveType(); 1540 else 1541 return nullptr; 1542 } 1543 1544 Type* 1545 SymbolFileDWARF::ResolveTypeUID (const DIERef &die_ref) 1546 { 1547 return ResolveType (GetDIE(die_ref), true); 1548 } 1549 1550 Type* 1551 SymbolFileDWARF::ResolveTypeUID (const DWARFDIE &die, bool assert_not_being_parsed) 1552 { 1553 if (die) 1554 { 1555 Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO)); 1556 if (log) 1557 GetObjectFile()->GetModule()->LogMessage (log, 1558 "SymbolFileDWARF::ResolveTypeUID (die = 0x%8.8x) %s '%s'", 1559 die.GetOffset(), 1560 die.GetTagAsCString(), 1561 die.GetName()); 1562 1563 // We might be coming in in the middle of a type tree (a class 1564 // withing a class, an enum within a class), so parse any needed 1565 // parent DIEs before we get to this one... 1566 DWARFDIE decl_ctx_die = GetDeclContextDIEContainingDIE (die); 1567 if (decl_ctx_die) 1568 { 1569 if (log) 1570 { 1571 switch (decl_ctx_die.Tag()) 1572 { 1573 case DW_TAG_structure_type: 1574 case DW_TAG_union_type: 1575 case DW_TAG_class_type: 1576 { 1577 // Get the type, which could be a forward declaration 1578 if (log) 1579 GetObjectFile()->GetModule()->LogMessage (log, 1580 "SymbolFileDWARF::ResolveTypeUID (die = 0x%8.8x) %s '%s' resolve parent forward type for 0x%8.8x", 1581 die.GetOffset(), 1582 die.GetTagAsCString(), 1583 die.GetName(), 1584 decl_ctx_die.GetOffset()); 1585 } 1586 break; 1587 1588 default: 1589 break; 1590 } 1591 } 1592 } 1593 return ResolveType (die); 1594 } 1595 return NULL; 1596 } 1597 1598 // This function is used when SymbolFileDWARFDebugMap owns a bunch of 1599 // SymbolFileDWARF objects to detect if this DWARF file is the one that 1600 // can resolve a compiler_type. 1601 bool 1602 SymbolFileDWARF::HasForwardDeclForClangType (const CompilerType &compiler_type) 1603 { 1604 CompilerType compiler_type_no_qualifiers = ClangUtil::RemoveFastQualifiers(compiler_type); 1605 if (GetForwardDeclClangTypeToDie().count (compiler_type_no_qualifiers.GetOpaqueQualType())) 1606 { 1607 return true; 1608 } 1609 TypeSystem *type_system = compiler_type.GetTypeSystem(); 1610 1611 ClangASTContext *clang_type_system = llvm::dyn_cast_or_null<ClangASTContext>(type_system); 1612 if (!clang_type_system) 1613 return false; 1614 DWARFASTParserClang *ast_parser = static_cast<DWARFASTParserClang *>(clang_type_system->GetDWARFParser()); 1615 return ast_parser->GetClangASTImporter().CanImport(compiler_type); 1616 } 1617 1618 1619 bool 1620 SymbolFileDWARF::CompleteType (CompilerType &compiler_type) 1621 { 1622 lldb_private::Mutex::Locker locker(GetObjectFile()->GetModule()->GetMutex()); 1623 1624 ClangASTContext *clang_type_system = llvm::dyn_cast_or_null<ClangASTContext>(compiler_type.GetTypeSystem()); 1625 if (clang_type_system) 1626 { 1627 DWARFASTParserClang *ast_parser = static_cast<DWARFASTParserClang *>(clang_type_system->GetDWARFParser()); 1628 if (ast_parser && ast_parser->GetClangASTImporter().CanImport(compiler_type)) 1629 return ast_parser->GetClangASTImporter().CompleteType(compiler_type); 1630 } 1631 1632 // We have a struct/union/class/enum that needs to be fully resolved. 1633 CompilerType compiler_type_no_qualifiers = ClangUtil::RemoveFastQualifiers(compiler_type); 1634 auto die_it = GetForwardDeclClangTypeToDie().find (compiler_type_no_qualifiers.GetOpaqueQualType()); 1635 if (die_it == GetForwardDeclClangTypeToDie().end()) 1636 { 1637 // We have already resolved this type... 1638 return true; 1639 } 1640 1641 DWARFDIE dwarf_die = GetDIE(die_it->getSecond()); 1642 if (dwarf_die) 1643 { 1644 // Once we start resolving this type, remove it from the forward declaration 1645 // map in case anyone child members or other types require this type to get resolved. 1646 // The type will get resolved when all of the calls to SymbolFileDWARF::ResolveClangOpaqueTypeDefinition 1647 // are done. 1648 GetForwardDeclClangTypeToDie().erase (die_it); 1649 1650 Type *type = GetDIEToType().lookup (dwarf_die.GetDIE()); 1651 1652 Log *log (LogChannelDWARF::GetLogIfAny(DWARF_LOG_DEBUG_INFO|DWARF_LOG_TYPE_COMPLETION)); 1653 if (log) 1654 GetObjectFile()->GetModule()->LogMessageVerboseBacktrace (log, 1655 "0x%8.8" PRIx64 ": %s '%s' resolving forward declaration...", 1656 dwarf_die.GetID(), 1657 dwarf_die.GetTagAsCString(), 1658 type->GetName().AsCString()); 1659 assert (compiler_type); 1660 DWARFASTParser *dwarf_ast = dwarf_die.GetDWARFParser(); 1661 if (dwarf_ast) 1662 return dwarf_ast->CompleteTypeFromDWARF (dwarf_die, type, compiler_type); 1663 } 1664 return false; 1665 } 1666 1667 Type* 1668 SymbolFileDWARF::ResolveType (const DWARFDIE &die, bool assert_not_being_parsed, bool resolve_function_context) 1669 { 1670 if (die) 1671 { 1672 Type *type = GetTypeForDIE (die, resolve_function_context).get(); 1673 1674 if (assert_not_being_parsed) 1675 { 1676 if (type != DIE_IS_BEING_PARSED) 1677 return type; 1678 1679 GetObjectFile()->GetModule()->ReportError ("Parsing a die that is being parsed die: 0x%8.8x: %s %s", 1680 die.GetOffset(), 1681 die.GetTagAsCString(), 1682 die.GetName()); 1683 1684 } 1685 else 1686 return type; 1687 } 1688 return nullptr; 1689 } 1690 1691 CompileUnit* 1692 SymbolFileDWARF::GetCompUnitForDWARFCompUnit (DWARFCompileUnit* dwarf_cu, uint32_t cu_idx) 1693 { 1694 // Check if the symbol vendor already knows about this compile unit? 1695 if (dwarf_cu->GetUserData() == NULL) 1696 { 1697 // The symbol vendor doesn't know about this compile unit, we 1698 // need to parse and add it to the symbol vendor object. 1699 return ParseCompileUnit(dwarf_cu, cu_idx).get(); 1700 } 1701 return (CompileUnit*)dwarf_cu->GetUserData(); 1702 } 1703 1704 size_t 1705 SymbolFileDWARF::GetObjCMethodDIEOffsets (ConstString class_name, DIEArray &method_die_offsets) 1706 { 1707 method_die_offsets.clear(); 1708 if (m_using_apple_tables) 1709 { 1710 if (m_apple_objc_ap.get()) 1711 m_apple_objc_ap->FindByName(class_name.GetCString(), method_die_offsets); 1712 } 1713 else 1714 { 1715 if (!m_indexed) 1716 Index (); 1717 1718 m_objc_class_selectors_index.Find (class_name, method_die_offsets); 1719 } 1720 return method_die_offsets.size(); 1721 } 1722 1723 bool 1724 SymbolFileDWARF::GetFunction (const DWARFDIE &die, SymbolContext& sc) 1725 { 1726 sc.Clear(false); 1727 1728 if (die) 1729 { 1730 // Check if the symbol vendor already knows about this compile unit? 1731 sc.comp_unit = GetCompUnitForDWARFCompUnit(die.GetCU(), UINT32_MAX); 1732 1733 sc.function = sc.comp_unit->FindFunctionByUID (die.GetID()).get(); 1734 if (sc.function == NULL) 1735 sc.function = ParseCompileUnitFunction(sc, die); 1736 1737 if (sc.function) 1738 { 1739 sc.module_sp = sc.function->CalculateSymbolContextModule(); 1740 return true; 1741 } 1742 } 1743 1744 return false; 1745 } 1746 1747 lldb::ModuleSP 1748 SymbolFileDWARF::GetDWOModule (ConstString name) 1749 { 1750 UpdateExternalModuleListIfNeeded(); 1751 const auto &pos = m_external_type_modules.find(name); 1752 if (pos != m_external_type_modules.end()) 1753 return pos->second; 1754 else 1755 return lldb::ModuleSP(); 1756 } 1757 1758 DWARFDIE 1759 SymbolFileDWARF::GetDIE (const DIERef &die_ref) 1760 { 1761 DWARFDebugInfo * debug_info = DebugInfo(); 1762 if (debug_info) 1763 return debug_info->GetDIE(die_ref); 1764 else 1765 return DWARFDIE(); 1766 } 1767 1768 1769 std::unique_ptr<SymbolFileDWARFDwo> 1770 SymbolFileDWARF::GetDwoSymbolFileForCompileUnit(DWARFCompileUnit &dwarf_cu, const DWARFDebugInfoEntry &cu_die) 1771 { 1772 const char *dwo_name = cu_die.GetAttributeValueAsString(this, &dwarf_cu, DW_AT_GNU_dwo_name, nullptr); 1773 if (!dwo_name) 1774 return nullptr; 1775 1776 FileSpec dwo_file(dwo_name, true); 1777 if (dwo_file.IsRelative()) 1778 { 1779 const char *comp_dir = cu_die.GetAttributeValueAsString(this, &dwarf_cu, DW_AT_comp_dir, nullptr); 1780 if (!comp_dir) 1781 return nullptr; 1782 1783 dwo_file.SetFile(comp_dir, true); 1784 dwo_file.AppendPathComponent(dwo_name); 1785 } 1786 1787 if (!dwo_file.Exists()) 1788 return nullptr; 1789 1790 const lldb::offset_t file_offset = 0; 1791 DataBufferSP dwo_file_data_sp; 1792 lldb::offset_t dwo_file_data_offset = 0; 1793 ObjectFileSP dwo_obj_file = ObjectFile::FindPlugin(GetObjectFile()->GetModule(), &dwo_file, file_offset, 1794 dwo_file.GetByteSize(), dwo_file_data_sp, dwo_file_data_offset); 1795 if (dwo_obj_file == nullptr) 1796 return nullptr; 1797 1798 return llvm::make_unique<SymbolFileDWARFDwo>(dwo_obj_file, &dwarf_cu); 1799 } 1800 1801 void 1802 SymbolFileDWARF::UpdateExternalModuleListIfNeeded() 1803 { 1804 if (m_fetched_external_modules) 1805 return; 1806 m_fetched_external_modules = true; 1807 1808 DWARFDebugInfo * debug_info = DebugInfo(); 1809 1810 const uint32_t num_compile_units = GetNumCompileUnits(); 1811 for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) 1812 { 1813 DWARFCompileUnit* dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx); 1814 1815 const DWARFDIE die = dwarf_cu->GetCompileUnitDIEOnly(); 1816 if (die && die.HasChildren() == false) 1817 { 1818 const char *name = die.GetAttributeValueAsString(DW_AT_name, nullptr); 1819 1820 if (name) 1821 { 1822 ConstString const_name(name); 1823 if (m_external_type_modules.find(const_name) == m_external_type_modules.end()) 1824 { 1825 ModuleSP module_sp; 1826 const char *dwo_path = die.GetAttributeValueAsString(DW_AT_GNU_dwo_name, nullptr); 1827 if (dwo_path) 1828 { 1829 ModuleSpec dwo_module_spec; 1830 dwo_module_spec.GetFileSpec().SetFile(dwo_path, false); 1831 dwo_module_spec.GetArchitecture() = m_obj_file->GetModule()->GetArchitecture(); 1832 //printf ("Loading dwo = '%s'\n", dwo_path); 1833 Error error = ModuleList::GetSharedModule (dwo_module_spec, module_sp, NULL, NULL, NULL); 1834 } 1835 m_external_type_modules[const_name] = module_sp; 1836 } 1837 } 1838 } 1839 } 1840 } 1841 1842 SymbolFileDWARF::GlobalVariableMap & 1843 SymbolFileDWARF::GetGlobalAranges() 1844 { 1845 if (!m_global_aranges_ap) 1846 { 1847 m_global_aranges_ap.reset (new GlobalVariableMap()); 1848 1849 ModuleSP module_sp = GetObjectFile()->GetModule(); 1850 if (module_sp) 1851 { 1852 const size_t num_cus = module_sp->GetNumCompileUnits(); 1853 for (size_t i = 0; i < num_cus; ++i) 1854 { 1855 CompUnitSP cu_sp = module_sp->GetCompileUnitAtIndex(i); 1856 if (cu_sp) 1857 { 1858 VariableListSP globals_sp = cu_sp->GetVariableList(true); 1859 if (globals_sp) 1860 { 1861 const size_t num_globals = globals_sp->GetSize(); 1862 for (size_t g = 0; g < num_globals; ++g) 1863 { 1864 VariableSP var_sp = globals_sp->GetVariableAtIndex(g); 1865 if (var_sp && !var_sp->GetLocationIsConstantValueData()) 1866 { 1867 const DWARFExpression &location = var_sp->LocationExpression(); 1868 Value location_result; 1869 Error error; 1870 if (location.Evaluate(nullptr, nullptr, nullptr, LLDB_INVALID_ADDRESS, nullptr, nullptr, location_result, &error)) 1871 { 1872 if (location_result.GetValueType() == Value::eValueTypeFileAddress) 1873 { 1874 lldb::addr_t file_addr = location_result.GetScalar().ULongLong(); 1875 lldb::addr_t byte_size = 1; 1876 if (var_sp->GetType()) 1877 byte_size = var_sp->GetType()->GetByteSize(); 1878 m_global_aranges_ap->Append(GlobalVariableMap::Entry(file_addr, byte_size, var_sp.get())); 1879 } 1880 } 1881 } 1882 } 1883 } 1884 } 1885 } 1886 } 1887 m_global_aranges_ap->Sort(); 1888 } 1889 return *m_global_aranges_ap; 1890 } 1891 1892 1893 uint32_t 1894 SymbolFileDWARF::ResolveSymbolContext (const Address& so_addr, uint32_t resolve_scope, SymbolContext& sc) 1895 { 1896 Timer scoped_timer(__PRETTY_FUNCTION__, 1897 "SymbolFileDWARF::ResolveSymbolContext (so_addr = { section = %p, offset = 0x%" PRIx64 " }, resolve_scope = 0x%8.8x)", 1898 static_cast<void*>(so_addr.GetSection().get()), 1899 so_addr.GetOffset(), resolve_scope); 1900 uint32_t resolved = 0; 1901 if (resolve_scope & ( eSymbolContextCompUnit | 1902 eSymbolContextFunction | 1903 eSymbolContextBlock | 1904 eSymbolContextLineEntry | 1905 eSymbolContextVariable )) 1906 { 1907 lldb::addr_t file_vm_addr = so_addr.GetFileAddress(); 1908 1909 DWARFDebugInfo* debug_info = DebugInfo(); 1910 if (debug_info) 1911 { 1912 const dw_offset_t cu_offset = debug_info->GetCompileUnitAranges().FindAddress(file_vm_addr); 1913 if (cu_offset == DW_INVALID_OFFSET) 1914 { 1915 // Global variables are not in the compile unit address ranges. The only way to 1916 // currently find global variables is to iterate over the .debug_pubnames or the 1917 // __apple_names table and find all items in there that point to DW_TAG_variable 1918 // DIEs and then find the address that matches. 1919 if (resolve_scope & eSymbolContextVariable) 1920 { 1921 GlobalVariableMap &map = GetGlobalAranges(); 1922 const GlobalVariableMap::Entry *entry = map.FindEntryThatContains(file_vm_addr); 1923 if (entry && entry->data) 1924 { 1925 Variable *variable = entry->data; 1926 SymbolContextScope *scc = variable->GetSymbolContextScope(); 1927 if (scc) 1928 { 1929 scc->CalculateSymbolContext(&sc); 1930 sc.variable = variable; 1931 } 1932 return sc.GetResolvedMask(); 1933 } 1934 } 1935 } 1936 else 1937 { 1938 uint32_t cu_idx = DW_INVALID_INDEX; 1939 DWARFCompileUnit* dwarf_cu = debug_info->GetCompileUnit(cu_offset, &cu_idx); 1940 if (dwarf_cu) 1941 { 1942 sc.comp_unit = GetCompUnitForDWARFCompUnit(dwarf_cu, cu_idx); 1943 if (sc.comp_unit) 1944 { 1945 resolved |= eSymbolContextCompUnit; 1946 1947 bool force_check_line_table = false; 1948 if (resolve_scope & (eSymbolContextFunction | eSymbolContextBlock)) 1949 { 1950 DWARFDIE function_die = dwarf_cu->LookupAddress(file_vm_addr); 1951 DWARFDIE block_die; 1952 if (function_die) 1953 { 1954 sc.function = sc.comp_unit->FindFunctionByUID (function_die.GetID()).get(); 1955 if (sc.function == NULL) 1956 sc.function = ParseCompileUnitFunction(sc, function_die); 1957 1958 if (sc.function && (resolve_scope & eSymbolContextBlock)) 1959 block_die = function_die.LookupDeepestBlock(file_vm_addr); 1960 } 1961 else 1962 { 1963 // We might have had a compile unit that had discontiguous 1964 // address ranges where the gaps are symbols that don't have 1965 // any debug info. Discontiguous compile unit address ranges 1966 // should only happen when there aren't other functions from 1967 // other compile units in these gaps. This helps keep the size 1968 // of the aranges down. 1969 force_check_line_table = true; 1970 } 1971 1972 if (sc.function != NULL) 1973 { 1974 resolved |= eSymbolContextFunction; 1975 1976 if (resolve_scope & eSymbolContextBlock) 1977 { 1978 Block& block = sc.function->GetBlock (true); 1979 1980 if (block_die) 1981 sc.block = block.FindBlockByID (block_die.GetID()); 1982 else 1983 sc.block = block.FindBlockByID (function_die.GetID()); 1984 if (sc.block) 1985 resolved |= eSymbolContextBlock; 1986 } 1987 } 1988 } 1989 1990 if ((resolve_scope & eSymbolContextLineEntry) || force_check_line_table) 1991 { 1992 LineTable *line_table = sc.comp_unit->GetLineTable(); 1993 if (line_table != NULL) 1994 { 1995 // And address that makes it into this function should be in terms 1996 // of this debug file if there is no debug map, or it will be an 1997 // address in the .o file which needs to be fixed up to be in terms 1998 // of the debug map executable. Either way, calling FixupAddress() 1999 // will work for us. 2000 Address exe_so_addr (so_addr); 2001 if (FixupAddress(exe_so_addr)) 2002 { 2003 if (line_table->FindLineEntryByAddress (exe_so_addr, sc.line_entry)) 2004 { 2005 resolved |= eSymbolContextLineEntry; 2006 } 2007 } 2008 } 2009 } 2010 2011 if (force_check_line_table && !(resolved & eSymbolContextLineEntry)) 2012 { 2013 // We might have had a compile unit that had discontiguous 2014 // address ranges where the gaps are symbols that don't have 2015 // any debug info. Discontiguous compile unit address ranges 2016 // should only happen when there aren't other functions from 2017 // other compile units in these gaps. This helps keep the size 2018 // of the aranges down. 2019 sc.comp_unit = NULL; 2020 resolved &= ~eSymbolContextCompUnit; 2021 } 2022 } 2023 else 2024 { 2025 GetObjectFile()->GetModule()->ReportWarning ("0x%8.8x: compile unit %u failed to create a valid lldb_private::CompileUnit class.", 2026 cu_offset, 2027 cu_idx); 2028 } 2029 } 2030 } 2031 } 2032 } 2033 return resolved; 2034 } 2035 2036 2037 2038 uint32_t 2039 SymbolFileDWARF::ResolveSymbolContext(const FileSpec& file_spec, uint32_t line, bool check_inlines, uint32_t resolve_scope, SymbolContextList& sc_list) 2040 { 2041 const uint32_t prev_size = sc_list.GetSize(); 2042 if (resolve_scope & eSymbolContextCompUnit) 2043 { 2044 DWARFDebugInfo* debug_info = DebugInfo(); 2045 if (debug_info) 2046 { 2047 uint32_t cu_idx; 2048 DWARFCompileUnit* dwarf_cu = NULL; 2049 2050 for (cu_idx = 0; (dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx)) != NULL; ++cu_idx) 2051 { 2052 CompileUnit *dc_cu = GetCompUnitForDWARFCompUnit(dwarf_cu, cu_idx); 2053 const bool full_match = (bool)file_spec.GetDirectory(); 2054 bool file_spec_matches_cu_file_spec = dc_cu != NULL && FileSpec::Equal(file_spec, *dc_cu, full_match); 2055 if (check_inlines || file_spec_matches_cu_file_spec) 2056 { 2057 SymbolContext sc (m_obj_file->GetModule()); 2058 sc.comp_unit = GetCompUnitForDWARFCompUnit(dwarf_cu, cu_idx); 2059 if (sc.comp_unit) 2060 { 2061 uint32_t file_idx = UINT32_MAX; 2062 2063 // If we are looking for inline functions only and we don't 2064 // find it in the support files, we are done. 2065 if (check_inlines) 2066 { 2067 file_idx = sc.comp_unit->GetSupportFiles().FindFileIndex (1, file_spec, true); 2068 if (file_idx == UINT32_MAX) 2069 continue; 2070 } 2071 2072 if (line != 0) 2073 { 2074 LineTable *line_table = sc.comp_unit->GetLineTable(); 2075 2076 if (line_table != NULL && line != 0) 2077 { 2078 // We will have already looked up the file index if 2079 // we are searching for inline entries. 2080 if (!check_inlines) 2081 file_idx = sc.comp_unit->GetSupportFiles().FindFileIndex (1, file_spec, true); 2082 2083 if (file_idx != UINT32_MAX) 2084 { 2085 uint32_t found_line; 2086 uint32_t line_idx = line_table->FindLineEntryIndexByFileIndex (0, file_idx, line, false, &sc.line_entry); 2087 found_line = sc.line_entry.line; 2088 2089 while (line_idx != UINT32_MAX) 2090 { 2091 sc.function = NULL; 2092 sc.block = NULL; 2093 if (resolve_scope & (eSymbolContextFunction | eSymbolContextBlock)) 2094 { 2095 const lldb::addr_t file_vm_addr = sc.line_entry.range.GetBaseAddress().GetFileAddress(); 2096 if (file_vm_addr != LLDB_INVALID_ADDRESS) 2097 { 2098 DWARFDIE function_die = dwarf_cu->LookupAddress(file_vm_addr); 2099 DWARFDIE block_die; 2100 if (function_die) 2101 { 2102 sc.function = sc.comp_unit->FindFunctionByUID (function_die.GetID()).get(); 2103 if (sc.function == NULL) 2104 sc.function = ParseCompileUnitFunction(sc, function_die); 2105 2106 if (sc.function && (resolve_scope & eSymbolContextBlock)) 2107 block_die = function_die.LookupDeepestBlock(file_vm_addr); 2108 } 2109 2110 if (sc.function != NULL) 2111 { 2112 Block& block = sc.function->GetBlock (true); 2113 2114 if (block_die) 2115 sc.block = block.FindBlockByID (block_die.GetID()); 2116 else if (function_die) 2117 sc.block = block.FindBlockByID (function_die.GetID()); 2118 } 2119 } 2120 } 2121 2122 sc_list.Append(sc); 2123 line_idx = line_table->FindLineEntryIndexByFileIndex (line_idx + 1, file_idx, found_line, true, &sc.line_entry); 2124 } 2125 } 2126 } 2127 else if (file_spec_matches_cu_file_spec && !check_inlines) 2128 { 2129 // only append the context if we aren't looking for inline call sites 2130 // by file and line and if the file spec matches that of the compile unit 2131 sc_list.Append(sc); 2132 } 2133 } 2134 else if (file_spec_matches_cu_file_spec && !check_inlines) 2135 { 2136 // only append the context if we aren't looking for inline call sites 2137 // by file and line and if the file spec matches that of the compile unit 2138 sc_list.Append(sc); 2139 } 2140 2141 if (!check_inlines) 2142 break; 2143 } 2144 } 2145 } 2146 } 2147 } 2148 return sc_list.GetSize() - prev_size; 2149 } 2150 2151 void 2152 SymbolFileDWARF::Index () 2153 { 2154 if (m_indexed) 2155 return; 2156 m_indexed = true; 2157 Timer scoped_timer (__PRETTY_FUNCTION__, 2158 "SymbolFileDWARF::Index (%s)", 2159 GetObjectFile()->GetFileSpec().GetFilename().AsCString("<Unknown>")); 2160 2161 DWARFDebugInfo* debug_info = DebugInfo(); 2162 if (debug_info) 2163 { 2164 const uint32_t num_compile_units = GetNumCompileUnits(); 2165 std::vector<NameToDIE> function_basename_index(num_compile_units); 2166 std::vector<NameToDIE> function_fullname_index(num_compile_units); 2167 std::vector<NameToDIE> function_method_index(num_compile_units); 2168 std::vector<NameToDIE> function_selector_index(num_compile_units); 2169 std::vector<NameToDIE> objc_class_selectors_index(num_compile_units); 2170 std::vector<NameToDIE> global_index(num_compile_units); 2171 std::vector<NameToDIE> type_index(num_compile_units); 2172 std::vector<NameToDIE> namespace_index(num_compile_units); 2173 2174 auto parser_fn = [this, 2175 debug_info, 2176 &function_basename_index, 2177 &function_fullname_index, 2178 &function_method_index, 2179 &function_selector_index, 2180 &objc_class_selectors_index, 2181 &global_index, 2182 &type_index, 2183 &namespace_index](uint32_t cu_idx) 2184 { 2185 DWARFCompileUnit* dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx); 2186 bool clear_dies = dwarf_cu->ExtractDIEsIfNeeded(false) > 1; 2187 2188 dwarf_cu->Index(function_basename_index[cu_idx], 2189 function_fullname_index[cu_idx], 2190 function_method_index[cu_idx], 2191 function_selector_index[cu_idx], 2192 objc_class_selectors_index[cu_idx], 2193 global_index[cu_idx], 2194 type_index[cu_idx], 2195 namespace_index[cu_idx]); 2196 2197 // Keep memory down by clearing DIEs if this generate function 2198 // caused them to be parsed 2199 if (clear_dies) 2200 dwarf_cu->ClearDIEs(true); 2201 2202 return cu_idx; 2203 }; 2204 2205 TaskRunner<uint32_t> task_runner; 2206 for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) 2207 task_runner.AddTask(parser_fn, cu_idx); 2208 2209 while (true) 2210 { 2211 std::future<uint32_t> f = task_runner.WaitForNextCompletedTask(); 2212 if (!f.valid()) 2213 break; 2214 uint32_t cu_idx = f.get(); 2215 2216 m_function_basename_index.Append(function_basename_index[cu_idx]); 2217 m_function_fullname_index.Append(function_fullname_index[cu_idx]); 2218 m_function_method_index.Append(function_method_index[cu_idx]); 2219 m_function_selector_index.Append(function_selector_index[cu_idx]); 2220 m_objc_class_selectors_index.Append(objc_class_selectors_index[cu_idx]); 2221 m_global_index.Append(global_index[cu_idx]); 2222 m_type_index.Append(type_index[cu_idx]); 2223 m_namespace_index.Append(namespace_index[cu_idx]); 2224 } 2225 2226 TaskPool::RunTasks( 2227 [&]() { m_function_basename_index.Finalize(); }, 2228 [&]() { m_function_fullname_index.Finalize(); }, 2229 [&]() { m_function_method_index.Finalize(); }, 2230 [&]() { m_function_selector_index.Finalize(); }, 2231 [&]() { m_objc_class_selectors_index.Finalize(); }, 2232 [&]() { m_global_index.Finalize(); }, 2233 [&]() { m_type_index.Finalize(); }, 2234 [&]() { m_namespace_index.Finalize(); }); 2235 2236 #if defined (ENABLE_DEBUG_PRINTF) 2237 StreamFile s(stdout, false); 2238 s.Printf ("DWARF index for '%s':", 2239 GetObjectFile()->GetFileSpec().GetPath().c_str()); 2240 s.Printf("\nFunction basenames:\n"); m_function_basename_index.Dump (&s); 2241 s.Printf("\nFunction fullnames:\n"); m_function_fullname_index.Dump (&s); 2242 s.Printf("\nFunction methods:\n"); m_function_method_index.Dump (&s); 2243 s.Printf("\nFunction selectors:\n"); m_function_selector_index.Dump (&s); 2244 s.Printf("\nObjective C class selectors:\n"); m_objc_class_selectors_index.Dump (&s); 2245 s.Printf("\nGlobals and statics:\n"); m_global_index.Dump (&s); 2246 s.Printf("\nTypes:\n"); m_type_index.Dump (&s); 2247 s.Printf("\nNamespaces:\n") m_namespace_index.Dump (&s); 2248 #endif 2249 } 2250 } 2251 2252 bool 2253 SymbolFileDWARF::DeclContextMatchesThisSymbolFile (const lldb_private::CompilerDeclContext *decl_ctx) 2254 { 2255 if (decl_ctx == nullptr || !decl_ctx->IsValid()) 2256 { 2257 // Invalid namespace decl which means we aren't matching only things 2258 // in this symbol file, so return true to indicate it matches this 2259 // symbol file. 2260 return true; 2261 } 2262 2263 TypeSystem *decl_ctx_type_system = decl_ctx->GetTypeSystem(); 2264 TypeSystem *type_system = GetTypeSystemForLanguage(decl_ctx_type_system->GetMinimumLanguage(nullptr)); 2265 if (decl_ctx_type_system == type_system) 2266 return true; // The type systems match, return true 2267 2268 // The namespace AST was valid, and it does not match... 2269 Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS)); 2270 2271 if (log) 2272 GetObjectFile()->GetModule()->LogMessage(log, "Valid namespace does not match symbol file"); 2273 2274 return false; 2275 } 2276 2277 uint32_t 2278 SymbolFileDWARF::FindGlobalVariables (const ConstString &name, const CompilerDeclContext *parent_decl_ctx, bool append, uint32_t max_matches, VariableList& variables) 2279 { 2280 Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS)); 2281 2282 if (log) 2283 GetObjectFile()->GetModule()->LogMessage (log, 2284 "SymbolFileDWARF::FindGlobalVariables (name=\"%s\", parent_decl_ctx=%p, append=%u, max_matches=%u, variables)", 2285 name.GetCString(), 2286 static_cast<const void*>(parent_decl_ctx), 2287 append, max_matches); 2288 2289 if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx)) 2290 return 0; 2291 2292 DWARFDebugInfo* info = DebugInfo(); 2293 if (info == NULL) 2294 return 0; 2295 2296 // If we aren't appending the results to this list, then clear the list 2297 if (!append) 2298 variables.Clear(); 2299 2300 // Remember how many variables are in the list before we search in case 2301 // we are appending the results to a variable list. 2302 const uint32_t original_size = variables.GetSize(); 2303 2304 DIEArray die_offsets; 2305 2306 if (m_using_apple_tables) 2307 { 2308 if (m_apple_names_ap.get()) 2309 { 2310 const char *name_cstr = name.GetCString(); 2311 llvm::StringRef basename; 2312 llvm::StringRef context; 2313 2314 if (!CPlusPlusLanguage::ExtractContextAndIdentifier(name_cstr, context, basename)) 2315 basename = name_cstr; 2316 2317 m_apple_names_ap->FindByName (basename.data(), die_offsets); 2318 } 2319 } 2320 else 2321 { 2322 // Index the DWARF if we haven't already 2323 if (!m_indexed) 2324 Index (); 2325 2326 m_global_index.Find (name, die_offsets); 2327 } 2328 2329 const size_t num_die_matches = die_offsets.size(); 2330 if (num_die_matches) 2331 { 2332 SymbolContext sc; 2333 sc.module_sp = m_obj_file->GetModule(); 2334 assert (sc.module_sp); 2335 2336 bool done = false; 2337 for (size_t i=0; i<num_die_matches && !done; ++i) 2338 { 2339 const DIERef& die_ref = die_offsets[i]; 2340 DWARFDIE die = GetDIE (die_ref); 2341 2342 if (die) 2343 { 2344 switch (die.Tag()) 2345 { 2346 default: 2347 case DW_TAG_subprogram: 2348 case DW_TAG_inlined_subroutine: 2349 case DW_TAG_try_block: 2350 case DW_TAG_catch_block: 2351 break; 2352 2353 case DW_TAG_variable: 2354 { 2355 sc.comp_unit = GetCompUnitForDWARFCompUnit(die.GetCU(), UINT32_MAX); 2356 2357 if (parent_decl_ctx) 2358 { 2359 DWARFASTParser *dwarf_ast = die.GetDWARFParser(); 2360 if (dwarf_ast) 2361 { 2362 CompilerDeclContext actual_parent_decl_ctx = dwarf_ast->GetDeclContextContainingUIDFromDWARF (die); 2363 if (!actual_parent_decl_ctx || actual_parent_decl_ctx != *parent_decl_ctx) 2364 continue; 2365 } 2366 } 2367 2368 ParseVariables(sc, die, LLDB_INVALID_ADDRESS, false, false, &variables); 2369 2370 if (variables.GetSize() - original_size >= max_matches) 2371 done = true; 2372 } 2373 break; 2374 } 2375 } 2376 else 2377 { 2378 if (m_using_apple_tables) 2379 { 2380 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_names accelerator table had bad die 0x%8.8x for '%s')\n", 2381 die_ref.die_offset, name.GetCString()); 2382 } 2383 } 2384 } 2385 } 2386 2387 // Return the number of variable that were appended to the list 2388 const uint32_t num_matches = variables.GetSize() - original_size; 2389 if (log && num_matches > 0) 2390 { 2391 GetObjectFile()->GetModule()->LogMessage (log, 2392 "SymbolFileDWARF::FindGlobalVariables (name=\"%s\", parent_decl_ctx=%p, append=%u, max_matches=%u, variables) => %u", 2393 name.GetCString(), 2394 static_cast<const void*>(parent_decl_ctx), 2395 append, max_matches, 2396 num_matches); 2397 } 2398 return num_matches; 2399 } 2400 2401 uint32_t 2402 SymbolFileDWARF::FindGlobalVariables(const RegularExpression& regex, bool append, uint32_t max_matches, VariableList& variables) 2403 { 2404 Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS)); 2405 2406 if (log) 2407 { 2408 GetObjectFile()->GetModule()->LogMessage (log, 2409 "SymbolFileDWARF::FindGlobalVariables (regex=\"%s\", append=%u, max_matches=%u, variables)", 2410 regex.GetText(), append, 2411 max_matches); 2412 } 2413 2414 DWARFDebugInfo* info = DebugInfo(); 2415 if (info == NULL) 2416 return 0; 2417 2418 // If we aren't appending the results to this list, then clear the list 2419 if (!append) 2420 variables.Clear(); 2421 2422 // Remember how many variables are in the list before we search in case 2423 // we are appending the results to a variable list. 2424 const uint32_t original_size = variables.GetSize(); 2425 2426 DIEArray die_offsets; 2427 2428 if (m_using_apple_tables) 2429 { 2430 if (m_apple_names_ap.get()) 2431 { 2432 DWARFMappedHash::DIEInfoArray hash_data_array; 2433 if (m_apple_names_ap->AppendAllDIEsThatMatchingRegex (regex, hash_data_array)) 2434 DWARFMappedHash::ExtractDIEArray (hash_data_array, die_offsets); 2435 } 2436 } 2437 else 2438 { 2439 // Index the DWARF if we haven't already 2440 if (!m_indexed) 2441 Index (); 2442 2443 m_global_index.Find (regex, die_offsets); 2444 } 2445 2446 SymbolContext sc; 2447 sc.module_sp = m_obj_file->GetModule(); 2448 assert (sc.module_sp); 2449 2450 const size_t num_matches = die_offsets.size(); 2451 if (num_matches) 2452 { 2453 for (size_t i=0; i<num_matches; ++i) 2454 { 2455 const DIERef& die_ref = die_offsets[i]; 2456 DWARFDIE die = GetDIE (die_ref); 2457 2458 if (die) 2459 { 2460 sc.comp_unit = GetCompUnitForDWARFCompUnit(die.GetCU(), UINT32_MAX); 2461 2462 ParseVariables(sc, die, LLDB_INVALID_ADDRESS, false, false, &variables); 2463 2464 if (variables.GetSize() - original_size >= max_matches) 2465 break; 2466 } 2467 else 2468 { 2469 if (m_using_apple_tables) 2470 { 2471 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_names accelerator table had bad die 0x%8.8x for regex '%s')\n", 2472 die_ref.die_offset, regex.GetText()); 2473 } 2474 } 2475 } 2476 } 2477 2478 // Return the number of variable that were appended to the list 2479 return variables.GetSize() - original_size; 2480 } 2481 2482 2483 bool 2484 SymbolFileDWARF::ResolveFunction (const DIERef& die_ref, 2485 bool include_inlines, 2486 SymbolContextList& sc_list) 2487 { 2488 DWARFDIE die = DebugInfo()->GetDIE (die_ref); 2489 return ResolveFunction (die, include_inlines, sc_list); 2490 } 2491 2492 2493 bool 2494 SymbolFileDWARF::ResolveFunction (const DWARFDIE &orig_die, 2495 bool include_inlines, 2496 SymbolContextList& sc_list) 2497 { 2498 SymbolContext sc; 2499 2500 if (!orig_die) 2501 return false; 2502 2503 // If we were passed a die that is not a function, just return false... 2504 if (!(orig_die.Tag() == DW_TAG_subprogram || (include_inlines && orig_die.Tag() == DW_TAG_inlined_subroutine))) 2505 return false; 2506 2507 DWARFDIE die = orig_die; 2508 DWARFDIE inlined_die; 2509 if (die.Tag() == DW_TAG_inlined_subroutine) 2510 { 2511 inlined_die = die; 2512 2513 while (1) 2514 { 2515 die = die.GetParent(); 2516 2517 if (die) 2518 { 2519 if (die.Tag() == DW_TAG_subprogram) 2520 break; 2521 } 2522 else 2523 break; 2524 } 2525 } 2526 assert (die && die.Tag() == DW_TAG_subprogram); 2527 if (GetFunction (die, sc)) 2528 { 2529 Address addr; 2530 // Parse all blocks if needed 2531 if (inlined_die) 2532 { 2533 Block &function_block = sc.function->GetBlock (true); 2534 sc.block = function_block.FindBlockByID (inlined_die.GetID()); 2535 if (sc.block == NULL) 2536 sc.block = function_block.FindBlockByID (inlined_die.GetOffset()); 2537 if (sc.block == NULL || sc.block->GetStartAddress (addr) == false) 2538 addr.Clear(); 2539 } 2540 else 2541 { 2542 sc.block = NULL; 2543 addr = sc.function->GetAddressRange().GetBaseAddress(); 2544 } 2545 2546 if (addr.IsValid()) 2547 { 2548 sc_list.Append(sc); 2549 return true; 2550 } 2551 } 2552 2553 return false; 2554 } 2555 2556 void 2557 SymbolFileDWARF::FindFunctions (const ConstString &name, 2558 const NameToDIE &name_to_die, 2559 bool include_inlines, 2560 SymbolContextList& sc_list) 2561 { 2562 DIEArray die_offsets; 2563 if (name_to_die.Find (name, die_offsets)) 2564 { 2565 ParseFunctions (die_offsets, include_inlines, sc_list); 2566 } 2567 } 2568 2569 2570 void 2571 SymbolFileDWARF::FindFunctions (const RegularExpression ®ex, 2572 const NameToDIE &name_to_die, 2573 bool include_inlines, 2574 SymbolContextList& sc_list) 2575 { 2576 DIEArray die_offsets; 2577 if (name_to_die.Find (regex, die_offsets)) 2578 { 2579 ParseFunctions (die_offsets, include_inlines, sc_list); 2580 } 2581 } 2582 2583 2584 void 2585 SymbolFileDWARF::FindFunctions (const RegularExpression ®ex, 2586 const DWARFMappedHash::MemoryTable &memory_table, 2587 bool include_inlines, 2588 SymbolContextList& sc_list) 2589 { 2590 DIEArray die_offsets; 2591 DWARFMappedHash::DIEInfoArray hash_data_array; 2592 if (memory_table.AppendAllDIEsThatMatchingRegex (regex, hash_data_array)) 2593 { 2594 DWARFMappedHash::ExtractDIEArray (hash_data_array, die_offsets); 2595 ParseFunctions (die_offsets, include_inlines, sc_list); 2596 } 2597 } 2598 2599 void 2600 SymbolFileDWARF::ParseFunctions (const DIEArray &die_offsets, 2601 bool include_inlines, 2602 SymbolContextList& sc_list) 2603 { 2604 const size_t num_matches = die_offsets.size(); 2605 if (num_matches) 2606 { 2607 for (size_t i=0; i<num_matches; ++i) 2608 ResolveFunction (die_offsets[i], include_inlines, sc_list); 2609 } 2610 } 2611 2612 bool 2613 SymbolFileDWARF::DIEInDeclContext (const CompilerDeclContext *decl_ctx, 2614 const DWARFDIE &die) 2615 { 2616 // If we have no parent decl context to match this DIE matches, and if the parent 2617 // decl context isn't valid, we aren't trying to look for any particular decl 2618 // context so any die matches. 2619 if (decl_ctx == nullptr || !decl_ctx->IsValid()) 2620 return true; 2621 2622 if (die) 2623 { 2624 DWARFASTParser *dwarf_ast = die.GetDWARFParser(); 2625 if (dwarf_ast) 2626 { 2627 CompilerDeclContext actual_decl_ctx = dwarf_ast->GetDeclContextContainingUIDFromDWARF (die); 2628 if (actual_decl_ctx) 2629 return actual_decl_ctx == *decl_ctx; 2630 } 2631 } 2632 return false; 2633 } 2634 2635 uint32_t 2636 SymbolFileDWARF::FindFunctions (const ConstString &name, 2637 const CompilerDeclContext *parent_decl_ctx, 2638 uint32_t name_type_mask, 2639 bool include_inlines, 2640 bool append, 2641 SymbolContextList& sc_list) 2642 { 2643 Timer scoped_timer (__PRETTY_FUNCTION__, 2644 "SymbolFileDWARF::FindFunctions (name = '%s')", 2645 name.AsCString()); 2646 2647 // eFunctionNameTypeAuto should be pre-resolved by a call to Module::PrepareForFunctionNameLookup() 2648 assert ((name_type_mask & eFunctionNameTypeAuto) == 0); 2649 2650 Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS)); 2651 2652 if (log) 2653 { 2654 GetObjectFile()->GetModule()->LogMessage (log, 2655 "SymbolFileDWARF::FindFunctions (name=\"%s\", name_type_mask=0x%x, append=%u, sc_list)", 2656 name.GetCString(), 2657 name_type_mask, 2658 append); 2659 } 2660 2661 // If we aren't appending the results to this list, then clear the list 2662 if (!append) 2663 sc_list.Clear(); 2664 2665 if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx)) 2666 return 0; 2667 2668 // If name is empty then we won't find anything. 2669 if (name.IsEmpty()) 2670 return 0; 2671 2672 // Remember how many sc_list are in the list before we search in case 2673 // we are appending the results to a variable list. 2674 2675 const char *name_cstr = name.GetCString(); 2676 2677 const uint32_t original_size = sc_list.GetSize(); 2678 2679 DWARFDebugInfo* info = DebugInfo(); 2680 if (info == NULL) 2681 return 0; 2682 2683 std::set<const DWARFDebugInfoEntry *> resolved_dies; 2684 if (m_using_apple_tables) 2685 { 2686 if (m_apple_names_ap.get()) 2687 { 2688 2689 DIEArray die_offsets; 2690 2691 uint32_t num_matches = 0; 2692 2693 if (name_type_mask & eFunctionNameTypeFull) 2694 { 2695 // If they asked for the full name, match what they typed. At some point we may 2696 // want to canonicalize this (strip double spaces, etc. For now, we just add all the 2697 // dies that we find by exact match. 2698 num_matches = m_apple_names_ap->FindByName (name_cstr, die_offsets); 2699 for (uint32_t i = 0; i < num_matches; i++) 2700 { 2701 const DIERef& die_ref = die_offsets[i]; 2702 DWARFDIE die = info->GetDIE (die_ref); 2703 if (die) 2704 { 2705 if (!DIEInDeclContext(parent_decl_ctx, die)) 2706 continue; // The containing decl contexts don't match 2707 2708 if (resolved_dies.find(die.GetDIE()) == resolved_dies.end()) 2709 { 2710 if (ResolveFunction (die, include_inlines, sc_list)) 2711 resolved_dies.insert(die.GetDIE()); 2712 } 2713 } 2714 else 2715 { 2716 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_names accelerator table had bad die 0x%8.8x for '%s')", 2717 die_ref.die_offset, name_cstr); 2718 } 2719 } 2720 } 2721 2722 if (name_type_mask & eFunctionNameTypeSelector) 2723 { 2724 if (parent_decl_ctx && parent_decl_ctx->IsValid()) 2725 return 0; // no selectors in namespaces 2726 2727 num_matches = m_apple_names_ap->FindByName (name_cstr, die_offsets); 2728 // Now make sure these are actually ObjC methods. In this case we can simply look up the name, 2729 // and if it is an ObjC method name, we're good. 2730 2731 for (uint32_t i = 0; i < num_matches; i++) 2732 { 2733 const DIERef& die_ref = die_offsets[i]; 2734 DWARFDIE die = info->GetDIE (die_ref); 2735 if (die) 2736 { 2737 const char *die_name = die.GetName(); 2738 if (ObjCLanguage::IsPossibleObjCMethodName(die_name)) 2739 { 2740 if (resolved_dies.find(die.GetDIE()) == resolved_dies.end()) 2741 { 2742 if (ResolveFunction (die, include_inlines, sc_list)) 2743 resolved_dies.insert(die.GetDIE()); 2744 } 2745 } 2746 } 2747 else 2748 { 2749 GetObjectFile()->GetModule()->ReportError ("the DWARF debug information has been modified (.apple_names accelerator table had bad die 0x%8.8x for '%s')", 2750 die_ref.die_offset, name_cstr); 2751 } 2752 } 2753 die_offsets.clear(); 2754 } 2755 2756 if (((name_type_mask & eFunctionNameTypeMethod) && !parent_decl_ctx) || name_type_mask & eFunctionNameTypeBase) 2757 { 2758 // The apple_names table stores just the "base name" of C++ methods in the table. So we have to 2759 // extract the base name, look that up, and if there is any other information in the name we were 2760 // passed in we have to post-filter based on that. 2761 2762 // FIXME: Arrange the logic above so that we don't calculate the base name twice: 2763 num_matches = m_apple_names_ap->FindByName (name_cstr, die_offsets); 2764 2765 for (uint32_t i = 0; i < num_matches; i++) 2766 { 2767 const DIERef& die_ref = die_offsets[i]; 2768 DWARFDIE die = info->GetDIE (die_ref); 2769 if (die) 2770 { 2771 if (!DIEInDeclContext(parent_decl_ctx, die)) 2772 continue; // The containing decl contexts don't match 2773 2774 2775 // If we get to here, the die is good, and we should add it: 2776 if (resolved_dies.find(die.GetDIE()) == resolved_dies.end() && ResolveFunction (die, include_inlines, sc_list)) 2777 { 2778 bool keep_die = true; 2779 if ((name_type_mask & (eFunctionNameTypeBase|eFunctionNameTypeMethod)) != (eFunctionNameTypeBase|eFunctionNameTypeMethod)) 2780 { 2781 // We are looking for either basenames or methods, so we need to 2782 // trim out the ones we won't want by looking at the type 2783 SymbolContext sc; 2784 if (sc_list.GetLastContext(sc)) 2785 { 2786 if (sc.block) 2787 { 2788 // We have an inlined function 2789 } 2790 else if (sc.function) 2791 { 2792 Type *type = sc.function->GetType(); 2793 2794 if (type) 2795 { 2796 CompilerDeclContext decl_ctx = GetDeclContextContainingUID (type->GetID()); 2797 if (decl_ctx.IsStructUnionOrClass()) 2798 { 2799 if (name_type_mask & eFunctionNameTypeBase) 2800 { 2801 sc_list.RemoveContextAtIndex(sc_list.GetSize()-1); 2802 keep_die = false; 2803 } 2804 } 2805 else 2806 { 2807 if (name_type_mask & eFunctionNameTypeMethod) 2808 { 2809 sc_list.RemoveContextAtIndex(sc_list.GetSize()-1); 2810 keep_die = false; 2811 } 2812 } 2813 } 2814 else 2815 { 2816 GetObjectFile()->GetModule()->ReportWarning ("function at die offset 0x%8.8x had no function type", 2817 die_ref.die_offset); 2818 } 2819 } 2820 } 2821 } 2822 if (keep_die) 2823 resolved_dies.insert(die.GetDIE()); 2824 } 2825 } 2826 else 2827 { 2828 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_names accelerator table had bad die 0x%8.8x for '%s')", 2829 die_ref.die_offset, name_cstr); 2830 } 2831 } 2832 die_offsets.clear(); 2833 } 2834 } 2835 } 2836 else 2837 { 2838 2839 // Index the DWARF if we haven't already 2840 if (!m_indexed) 2841 Index (); 2842 2843 if (name_type_mask & eFunctionNameTypeFull) 2844 { 2845 FindFunctions (name, m_function_fullname_index, include_inlines, sc_list); 2846 2847 // FIXME Temporary workaround for global/anonymous namespace 2848 // functions debugging FreeBSD and Linux binaries. 2849 // If we didn't find any functions in the global namespace try 2850 // looking in the basename index but ignore any returned 2851 // functions that have a namespace but keep functions which 2852 // have an anonymous namespace 2853 // TODO: The arch in the object file isn't correct for MSVC 2854 // binaries on windows, we should find a way to make it 2855 // correct and handle those symbols as well. 2856 if (sc_list.GetSize() == original_size) 2857 { 2858 ArchSpec arch; 2859 if (!parent_decl_ctx && 2860 GetObjectFile()->GetArchitecture(arch) && 2861 (arch.GetTriple().isOSFreeBSD() || arch.GetTriple().isOSLinux() || 2862 arch.GetMachine() == llvm::Triple::hexagon)) 2863 { 2864 SymbolContextList temp_sc_list; 2865 FindFunctions (name, m_function_basename_index, include_inlines, temp_sc_list); 2866 SymbolContext sc; 2867 for (uint32_t i = 0; i < temp_sc_list.GetSize(); i++) 2868 { 2869 if (temp_sc_list.GetContextAtIndex(i, sc)) 2870 { 2871 ConstString mangled_name = sc.GetFunctionName(Mangled::ePreferMangled); 2872 ConstString demangled_name = sc.GetFunctionName(Mangled::ePreferDemangled); 2873 // Mangled names on Linux and FreeBSD are of the form: 2874 // _ZN18function_namespace13function_nameEv. 2875 if (strncmp(mangled_name.GetCString(), "_ZN", 3) || 2876 !strncmp(demangled_name.GetCString(), "(anonymous namespace)", 21)) 2877 { 2878 sc_list.Append(sc); 2879 } 2880 } 2881 } 2882 } 2883 } 2884 } 2885 DIEArray die_offsets; 2886 if (name_type_mask & eFunctionNameTypeBase) 2887 { 2888 uint32_t num_base = m_function_basename_index.Find(name, die_offsets); 2889 for (uint32_t i = 0; i < num_base; i++) 2890 { 2891 DWARFDIE die = info->GetDIE (die_offsets[i]); 2892 if (die) 2893 { 2894 if (!DIEInDeclContext(parent_decl_ctx, die)) 2895 continue; // The containing decl contexts don't match 2896 2897 // If we get to here, the die is good, and we should add it: 2898 if (resolved_dies.find(die.GetDIE()) == resolved_dies.end()) 2899 { 2900 if (ResolveFunction (die, include_inlines, sc_list)) 2901 resolved_dies.insert(die.GetDIE()); 2902 } 2903 } 2904 } 2905 die_offsets.clear(); 2906 } 2907 2908 if (name_type_mask & eFunctionNameTypeMethod) 2909 { 2910 if (parent_decl_ctx && parent_decl_ctx->IsValid()) 2911 return 0; // no methods in namespaces 2912 2913 uint32_t num_base = m_function_method_index.Find(name, die_offsets); 2914 { 2915 for (uint32_t i = 0; i < num_base; i++) 2916 { 2917 DWARFDIE die = info->GetDIE (die_offsets[i]); 2918 if (die) 2919 { 2920 // If we get to here, the die is good, and we should add it: 2921 if (resolved_dies.find(die.GetDIE()) == resolved_dies.end()) 2922 { 2923 if (ResolveFunction (die, include_inlines, sc_list)) 2924 resolved_dies.insert(die.GetDIE()); 2925 } 2926 } 2927 } 2928 } 2929 die_offsets.clear(); 2930 } 2931 2932 if ((name_type_mask & eFunctionNameTypeSelector) && (!parent_decl_ctx || !parent_decl_ctx->IsValid())) 2933 { 2934 FindFunctions (name, m_function_selector_index, include_inlines, sc_list); 2935 } 2936 2937 } 2938 2939 // Return the number of variable that were appended to the list 2940 const uint32_t num_matches = sc_list.GetSize() - original_size; 2941 2942 if (log && num_matches > 0) 2943 { 2944 GetObjectFile()->GetModule()->LogMessage (log, 2945 "SymbolFileDWARF::FindFunctions (name=\"%s\", name_type_mask=0x%x, include_inlines=%d, append=%u, sc_list) => %u", 2946 name.GetCString(), 2947 name_type_mask, 2948 include_inlines, 2949 append, 2950 num_matches); 2951 } 2952 return num_matches; 2953 } 2954 2955 uint32_t 2956 SymbolFileDWARF::FindFunctions(const RegularExpression& regex, bool include_inlines, bool append, SymbolContextList& sc_list) 2957 { 2958 Timer scoped_timer (__PRETTY_FUNCTION__, 2959 "SymbolFileDWARF::FindFunctions (regex = '%s')", 2960 regex.GetText()); 2961 2962 Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS)); 2963 2964 if (log) 2965 { 2966 GetObjectFile()->GetModule()->LogMessage (log, 2967 "SymbolFileDWARF::FindFunctions (regex=\"%s\", append=%u, sc_list)", 2968 regex.GetText(), 2969 append); 2970 } 2971 2972 2973 // If we aren't appending the results to this list, then clear the list 2974 if (!append) 2975 sc_list.Clear(); 2976 2977 // Remember how many sc_list are in the list before we search in case 2978 // we are appending the results to a variable list. 2979 uint32_t original_size = sc_list.GetSize(); 2980 2981 if (m_using_apple_tables) 2982 { 2983 if (m_apple_names_ap.get()) 2984 FindFunctions (regex, *m_apple_names_ap, include_inlines, sc_list); 2985 } 2986 else 2987 { 2988 // Index the DWARF if we haven't already 2989 if (!m_indexed) 2990 Index (); 2991 2992 FindFunctions (regex, m_function_basename_index, include_inlines, sc_list); 2993 2994 FindFunctions (regex, m_function_fullname_index, include_inlines, sc_list); 2995 } 2996 2997 // Return the number of variable that were appended to the list 2998 return sc_list.GetSize() - original_size; 2999 } 3000 3001 void 3002 SymbolFileDWARF::GetMangledNamesForFunction (const std::string &scope_qualified_name, 3003 std::vector<ConstString> &mangled_names) 3004 { 3005 DWARFDebugInfo* info = DebugInfo(); 3006 uint32_t num_comp_units = 0; 3007 if (info) 3008 num_comp_units = info->GetNumCompileUnits(); 3009 3010 for (uint32_t i = 0; i < num_comp_units; i++) 3011 { 3012 DWARFCompileUnit *cu = info->GetCompileUnitAtIndex(i); 3013 if (cu == nullptr) 3014 continue; 3015 3016 SymbolFileDWARFDwo *dwo = cu->GetDwoSymbolFile(); 3017 if (dwo) 3018 dwo->GetMangledNamesForFunction(scope_qualified_name, mangled_names); 3019 } 3020 3021 NameToOffsetMap::iterator iter = m_function_scope_qualified_name_map.find(scope_qualified_name); 3022 if (iter == m_function_scope_qualified_name_map.end()) 3023 return; 3024 3025 DIERefSetSP set_sp = (*iter).second; 3026 std::set<DIERef>::iterator set_iter; 3027 for (set_iter = set_sp->begin(); set_iter != set_sp->end(); set_iter++) 3028 { 3029 DWARFDIE die = DebugInfo()->GetDIE (*set_iter); 3030 mangled_names.push_back(ConstString(die.GetMangledName())); 3031 } 3032 } 3033 3034 3035 uint32_t 3036 SymbolFileDWARF::FindTypes (const SymbolContext& sc, 3037 const ConstString &name, 3038 const CompilerDeclContext *parent_decl_ctx, 3039 bool append, 3040 uint32_t max_matches, 3041 llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files, 3042 TypeMap& types) 3043 { 3044 // If we aren't appending the results to this list, then clear the list 3045 if (!append) 3046 types.Clear(); 3047 3048 // Make sure we haven't already searched this SymbolFile before... 3049 if (searched_symbol_files.count(this)) 3050 return 0; 3051 else 3052 searched_symbol_files.insert(this); 3053 3054 DWARFDebugInfo* info = DebugInfo(); 3055 if (info == NULL) 3056 return 0; 3057 3058 Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS)); 3059 3060 if (log) 3061 { 3062 if (parent_decl_ctx) 3063 GetObjectFile()->GetModule()->LogMessage (log, 3064 "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx = %p (\"%s\"), append=%u, max_matches=%u, type_list)", 3065 name.GetCString(), 3066 static_cast<const void*>(parent_decl_ctx), 3067 parent_decl_ctx->GetName().AsCString("<NULL>"), 3068 append, max_matches); 3069 else 3070 GetObjectFile()->GetModule()->LogMessage (log, 3071 "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx = NULL, append=%u, max_matches=%u, type_list)", 3072 name.GetCString(), append, 3073 max_matches); 3074 } 3075 3076 if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx)) 3077 return 0; 3078 3079 DIEArray die_offsets; 3080 3081 if (m_using_apple_tables) 3082 { 3083 if (m_apple_types_ap.get()) 3084 { 3085 const char *name_cstr = name.GetCString(); 3086 m_apple_types_ap->FindByName (name_cstr, die_offsets); 3087 } 3088 } 3089 else 3090 { 3091 if (!m_indexed) 3092 Index (); 3093 3094 m_type_index.Find (name, die_offsets); 3095 } 3096 3097 const size_t num_die_matches = die_offsets.size(); 3098 3099 if (num_die_matches) 3100 { 3101 const uint32_t initial_types_size = types.GetSize(); 3102 for (size_t i=0; i<num_die_matches; ++i) 3103 { 3104 const DIERef& die_ref = die_offsets[i]; 3105 DWARFDIE die = GetDIE (die_ref); 3106 3107 if (die) 3108 { 3109 if (!DIEInDeclContext(parent_decl_ctx, die)) 3110 continue; // The containing decl contexts don't match 3111 3112 Type *matching_type = ResolveType (die, true, true); 3113 if (matching_type) 3114 { 3115 // We found a type pointer, now find the shared pointer form our type list 3116 types.InsertUnique (matching_type->shared_from_this()); 3117 if (types.GetSize() >= max_matches) 3118 break; 3119 } 3120 } 3121 else 3122 { 3123 if (m_using_apple_tables) 3124 { 3125 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_types accelerator table had bad die 0x%8.8x for '%s')\n", 3126 die_ref.die_offset, name.GetCString()); 3127 } 3128 } 3129 3130 } 3131 const uint32_t num_matches = types.GetSize() - initial_types_size; 3132 if (log && num_matches) 3133 { 3134 if (parent_decl_ctx) 3135 { 3136 GetObjectFile()->GetModule()->LogMessage (log, 3137 "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx = %p (\"%s\"), append=%u, max_matches=%u, type_list) => %u", 3138 name.GetCString(), 3139 static_cast<const void*>(parent_decl_ctx), 3140 parent_decl_ctx->GetName().AsCString("<NULL>"), 3141 append, max_matches, 3142 num_matches); 3143 } 3144 else 3145 { 3146 GetObjectFile()->GetModule()->LogMessage (log, 3147 "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx = NULL, append=%u, max_matches=%u, type_list) => %u", 3148 name.GetCString(), 3149 append, max_matches, 3150 num_matches); 3151 } 3152 } 3153 return num_matches; 3154 } 3155 else 3156 { 3157 UpdateExternalModuleListIfNeeded(); 3158 3159 for (const auto &pair : m_external_type_modules) 3160 { 3161 ModuleSP external_module_sp = pair.second; 3162 if (external_module_sp) 3163 { 3164 SymbolVendor *sym_vendor = external_module_sp->GetSymbolVendor(); 3165 if (sym_vendor) 3166 { 3167 const uint32_t num_external_matches = sym_vendor->FindTypes (sc, 3168 name, 3169 parent_decl_ctx, 3170 append, 3171 max_matches, 3172 searched_symbol_files, 3173 types); 3174 if (num_external_matches) 3175 return num_external_matches; 3176 } 3177 } 3178 } 3179 } 3180 3181 return 0; 3182 } 3183 3184 3185 size_t 3186 SymbolFileDWARF::FindTypes (const std::vector<CompilerContext> &context, 3187 bool append, 3188 TypeMap& types) 3189 { 3190 if (!append) 3191 types.Clear(); 3192 3193 if (context.empty()) 3194 return 0; 3195 3196 DIEArray die_offsets; 3197 3198 ConstString name = context.back().name; 3199 3200 if (!name) 3201 return 0; 3202 3203 if (m_using_apple_tables) 3204 { 3205 if (m_apple_types_ap.get()) 3206 { 3207 const char *name_cstr = name.GetCString(); 3208 m_apple_types_ap->FindByName (name_cstr, die_offsets); 3209 } 3210 } 3211 else 3212 { 3213 if (!m_indexed) 3214 Index (); 3215 3216 m_type_index.Find (name, die_offsets); 3217 } 3218 3219 const size_t num_die_matches = die_offsets.size(); 3220 3221 if (num_die_matches) 3222 { 3223 size_t num_matches = 0; 3224 for (size_t i=0; i<num_die_matches; ++i) 3225 { 3226 const DIERef& die_ref = die_offsets[i]; 3227 DWARFDIE die = GetDIE (die_ref); 3228 3229 if (die) 3230 { 3231 std::vector<CompilerContext> die_context; 3232 die.GetDWOContext(die_context); 3233 if (die_context != context) 3234 continue; 3235 3236 Type *matching_type = ResolveType (die, true, true); 3237 if (matching_type) 3238 { 3239 // We found a type pointer, now find the shared pointer form our type list 3240 types.InsertUnique (matching_type->shared_from_this()); 3241 ++num_matches; 3242 } 3243 } 3244 else 3245 { 3246 if (m_using_apple_tables) 3247 { 3248 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_types accelerator table had bad die 0x%8.8x for '%s')\n", 3249 die_ref.die_offset, name.GetCString()); 3250 } 3251 } 3252 3253 } 3254 return num_matches; 3255 } 3256 return 0; 3257 } 3258 3259 3260 CompilerDeclContext 3261 SymbolFileDWARF::FindNamespace (const SymbolContext& sc, 3262 const ConstString &name, 3263 const CompilerDeclContext *parent_decl_ctx) 3264 { 3265 Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS)); 3266 3267 if (log) 3268 { 3269 GetObjectFile()->GetModule()->LogMessage (log, 3270 "SymbolFileDWARF::FindNamespace (sc, name=\"%s\")", 3271 name.GetCString()); 3272 } 3273 3274 CompilerDeclContext namespace_decl_ctx; 3275 3276 if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx)) 3277 return namespace_decl_ctx; 3278 3279 3280 DWARFDebugInfo* info = DebugInfo(); 3281 if (info) 3282 { 3283 DIEArray die_offsets; 3284 3285 // Index if we already haven't to make sure the compile units 3286 // get indexed and make their global DIE index list 3287 if (m_using_apple_tables) 3288 { 3289 if (m_apple_namespaces_ap.get()) 3290 { 3291 const char *name_cstr = name.GetCString(); 3292 m_apple_namespaces_ap->FindByName (name_cstr, die_offsets); 3293 } 3294 } 3295 else 3296 { 3297 if (!m_indexed) 3298 Index (); 3299 3300 m_namespace_index.Find (name, die_offsets); 3301 } 3302 3303 const size_t num_matches = die_offsets.size(); 3304 if (num_matches) 3305 { 3306 for (size_t i=0; i<num_matches; ++i) 3307 { 3308 const DIERef& die_ref = die_offsets[i]; 3309 DWARFDIE die = GetDIE (die_ref); 3310 3311 if (die) 3312 { 3313 if (!DIEInDeclContext (parent_decl_ctx, die)) 3314 continue; // The containing decl contexts don't match 3315 3316 DWARFASTParser *dwarf_ast = die.GetDWARFParser(); 3317 if (dwarf_ast) 3318 { 3319 namespace_decl_ctx = dwarf_ast->GetDeclContextForUIDFromDWARF (die); 3320 if (namespace_decl_ctx) 3321 break; 3322 } 3323 } 3324 else 3325 { 3326 if (m_using_apple_tables) 3327 { 3328 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_namespaces accelerator table had bad die 0x%8.8x for '%s')\n", 3329 die_ref.die_offset, name.GetCString()); 3330 } 3331 } 3332 3333 } 3334 } 3335 } 3336 if (log && namespace_decl_ctx) 3337 { 3338 GetObjectFile()->GetModule()->LogMessage (log, 3339 "SymbolFileDWARF::FindNamespace (sc, name=\"%s\") => CompilerDeclContext(%p/%p) \"%s\"", 3340 name.GetCString(), 3341 static_cast<const void*>(namespace_decl_ctx.GetTypeSystem()), 3342 static_cast<const void*>(namespace_decl_ctx.GetOpaqueDeclContext()), 3343 namespace_decl_ctx.GetName().AsCString("<NULL>")); 3344 } 3345 3346 return namespace_decl_ctx; 3347 } 3348 3349 TypeSP 3350 SymbolFileDWARF::GetTypeForDIE (const DWARFDIE &die, bool resolve_function_context) 3351 { 3352 TypeSP type_sp; 3353 if (die) 3354 { 3355 Type *type_ptr = GetDIEToType().lookup (die.GetDIE()); 3356 if (type_ptr == NULL) 3357 { 3358 CompileUnit* lldb_cu = GetCompUnitForDWARFCompUnit(die.GetCU()); 3359 assert (lldb_cu); 3360 SymbolContext sc(lldb_cu); 3361 const DWARFDebugInfoEntry* parent_die = die.GetParent().GetDIE(); 3362 while (parent_die != nullptr) 3363 { 3364 if (parent_die->Tag() == DW_TAG_subprogram) 3365 break; 3366 parent_die = parent_die->GetParent(); 3367 } 3368 SymbolContext sc_backup = sc; 3369 if (resolve_function_context && parent_die != nullptr && !GetFunction(DWARFDIE(die.GetCU(),parent_die), sc)) 3370 sc = sc_backup; 3371 3372 type_sp = ParseType(sc, die, NULL); 3373 } 3374 else if (type_ptr != DIE_IS_BEING_PARSED) 3375 { 3376 // Grab the existing type from the master types lists 3377 type_sp = type_ptr->shared_from_this(); 3378 } 3379 3380 } 3381 return type_sp; 3382 } 3383 3384 3385 DWARFDIE 3386 SymbolFileDWARF::GetDeclContextDIEContainingDIE (const DWARFDIE &orig_die) 3387 { 3388 if (orig_die) 3389 { 3390 DWARFDIE die = orig_die; 3391 3392 while (die) 3393 { 3394 // If this is the original DIE that we are searching for a declaration 3395 // for, then don't look in the cache as we don't want our own decl 3396 // context to be our decl context... 3397 if (orig_die != die) 3398 { 3399 switch (die.Tag()) 3400 { 3401 case DW_TAG_compile_unit: 3402 case DW_TAG_namespace: 3403 case DW_TAG_structure_type: 3404 case DW_TAG_union_type: 3405 case DW_TAG_class_type: 3406 case DW_TAG_lexical_block: 3407 case DW_TAG_subprogram: 3408 return die; 3409 3410 default: 3411 break; 3412 } 3413 } 3414 3415 DWARFDIE spec_die = die.GetReferencedDIE(DW_AT_specification); 3416 if (spec_die) 3417 { 3418 DWARFDIE decl_ctx_die = GetDeclContextDIEContainingDIE(spec_die); 3419 if (decl_ctx_die) 3420 return decl_ctx_die; 3421 } 3422 3423 DWARFDIE abs_die = die.GetReferencedDIE(DW_AT_abstract_origin); 3424 if (abs_die) 3425 { 3426 DWARFDIE decl_ctx_die = GetDeclContextDIEContainingDIE(abs_die); 3427 if (decl_ctx_die) 3428 return decl_ctx_die; 3429 } 3430 3431 die = die.GetParent(); 3432 } 3433 } 3434 return DWARFDIE(); 3435 } 3436 3437 3438 Symbol * 3439 SymbolFileDWARF::GetObjCClassSymbol (const ConstString &objc_class_name) 3440 { 3441 Symbol *objc_class_symbol = NULL; 3442 if (m_obj_file) 3443 { 3444 Symtab *symtab = m_obj_file->GetSymtab (); 3445 if (symtab) 3446 { 3447 objc_class_symbol = symtab->FindFirstSymbolWithNameAndType (objc_class_name, 3448 eSymbolTypeObjCClass, 3449 Symtab::eDebugNo, 3450 Symtab::eVisibilityAny); 3451 } 3452 } 3453 return objc_class_symbol; 3454 } 3455 3456 // Some compilers don't emit the DW_AT_APPLE_objc_complete_type attribute. If they don't 3457 // then we can end up looking through all class types for a complete type and never find 3458 // the full definition. We need to know if this attribute is supported, so we determine 3459 // this here and cache th result. We also need to worry about the debug map DWARF file 3460 // if we are doing darwin DWARF in .o file debugging. 3461 bool 3462 SymbolFileDWARF::Supports_DW_AT_APPLE_objc_complete_type (DWARFCompileUnit *cu) 3463 { 3464 if (m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolCalculate) 3465 { 3466 m_supports_DW_AT_APPLE_objc_complete_type = eLazyBoolNo; 3467 if (cu && cu->Supports_DW_AT_APPLE_objc_complete_type()) 3468 m_supports_DW_AT_APPLE_objc_complete_type = eLazyBoolYes; 3469 else 3470 { 3471 DWARFDebugInfo* debug_info = DebugInfo(); 3472 const uint32_t num_compile_units = GetNumCompileUnits(); 3473 for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) 3474 { 3475 DWARFCompileUnit* dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx); 3476 if (dwarf_cu != cu && dwarf_cu->Supports_DW_AT_APPLE_objc_complete_type()) 3477 { 3478 m_supports_DW_AT_APPLE_objc_complete_type = eLazyBoolYes; 3479 break; 3480 } 3481 } 3482 } 3483 if (m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolNo && GetDebugMapSymfile ()) 3484 return m_debug_map_symfile->Supports_DW_AT_APPLE_objc_complete_type (this); 3485 } 3486 return m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolYes; 3487 } 3488 3489 // This function can be used when a DIE is found that is a forward declaration 3490 // DIE and we want to try and find a type that has the complete definition. 3491 TypeSP 3492 SymbolFileDWARF::FindCompleteObjCDefinitionTypeForDIE (const DWARFDIE &die, 3493 const ConstString &type_name, 3494 bool must_be_implementation) 3495 { 3496 3497 TypeSP type_sp; 3498 3499 if (!type_name || (must_be_implementation && !GetObjCClassSymbol (type_name))) 3500 return type_sp; 3501 3502 DIEArray die_offsets; 3503 3504 if (m_using_apple_tables) 3505 { 3506 if (m_apple_types_ap.get()) 3507 { 3508 const char *name_cstr = type_name.GetCString(); 3509 m_apple_types_ap->FindCompleteObjCClassByName (name_cstr, die_offsets, must_be_implementation); 3510 } 3511 } 3512 else 3513 { 3514 if (!m_indexed) 3515 Index (); 3516 3517 m_type_index.Find (type_name, die_offsets); 3518 } 3519 3520 const size_t num_matches = die_offsets.size(); 3521 3522 if (num_matches) 3523 { 3524 for (size_t i=0; i<num_matches; ++i) 3525 { 3526 const DIERef& die_ref = die_offsets[i]; 3527 DWARFDIE type_die = GetDIE (die_ref); 3528 3529 if (type_die) 3530 { 3531 bool try_resolving_type = false; 3532 3533 // Don't try and resolve the DIE we are looking for with the DIE itself! 3534 if (type_die != die) 3535 { 3536 switch (type_die.Tag()) 3537 { 3538 case DW_TAG_class_type: 3539 case DW_TAG_structure_type: 3540 try_resolving_type = true; 3541 break; 3542 default: 3543 break; 3544 } 3545 } 3546 3547 if (try_resolving_type) 3548 { 3549 if (must_be_implementation && type_die.Supports_DW_AT_APPLE_objc_complete_type()) 3550 try_resolving_type = type_die.GetAttributeValueAsUnsigned (DW_AT_APPLE_objc_complete_type, 0); 3551 3552 if (try_resolving_type) 3553 { 3554 Type *resolved_type = ResolveType (type_die, false, true); 3555 if (resolved_type && resolved_type != DIE_IS_BEING_PARSED) 3556 { 3557 DEBUG_PRINTF ("resolved 0x%8.8" PRIx64 " from %s to 0x%8.8" PRIx64 " (cu 0x%8.8" PRIx64 ")\n", 3558 die.GetID(), 3559 m_obj_file->GetFileSpec().GetFilename().AsCString("<Unknown>"), 3560 type_die.GetID(), 3561 type_cu->GetID()); 3562 3563 if (die) 3564 GetDIEToType()[die.GetDIE()] = resolved_type; 3565 type_sp = resolved_type->shared_from_this(); 3566 break; 3567 } 3568 } 3569 } 3570 } 3571 else 3572 { 3573 if (m_using_apple_tables) 3574 { 3575 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_types accelerator table had bad die 0x%8.8x for '%s')\n", 3576 die_ref.die_offset, type_name.GetCString()); 3577 } 3578 } 3579 3580 } 3581 } 3582 return type_sp; 3583 } 3584 3585 3586 //---------------------------------------------------------------------- 3587 // This function helps to ensure that the declaration contexts match for 3588 // two different DIEs. Often times debug information will refer to a 3589 // forward declaration of a type (the equivalent of "struct my_struct;". 3590 // There will often be a declaration of that type elsewhere that has the 3591 // full definition. When we go looking for the full type "my_struct", we 3592 // will find one or more matches in the accelerator tables and we will 3593 // then need to make sure the type was in the same declaration context 3594 // as the original DIE. This function can efficiently compare two DIEs 3595 // and will return true when the declaration context matches, and false 3596 // when they don't. 3597 //---------------------------------------------------------------------- 3598 bool 3599 SymbolFileDWARF::DIEDeclContextsMatch (const DWARFDIE &die1, 3600 const DWARFDIE &die2) 3601 { 3602 if (die1 == die2) 3603 return true; 3604 3605 DWARFDIECollection decl_ctx_1; 3606 DWARFDIECollection decl_ctx_2; 3607 //The declaration DIE stack is a stack of the declaration context 3608 // DIEs all the way back to the compile unit. If a type "T" is 3609 // declared inside a class "B", and class "B" is declared inside 3610 // a class "A" and class "A" is in a namespace "lldb", and the 3611 // namespace is in a compile unit, there will be a stack of DIEs: 3612 // 3613 // [0] DW_TAG_class_type for "B" 3614 // [1] DW_TAG_class_type for "A" 3615 // [2] DW_TAG_namespace for "lldb" 3616 // [3] DW_TAG_compile_unit for the source file. 3617 // 3618 // We grab both contexts and make sure that everything matches 3619 // all the way back to the compiler unit. 3620 3621 // First lets grab the decl contexts for both DIEs 3622 die1.GetDeclContextDIEs (decl_ctx_1); 3623 die2.GetDeclContextDIEs (decl_ctx_2); 3624 // Make sure the context arrays have the same size, otherwise 3625 // we are done 3626 const size_t count1 = decl_ctx_1.Size(); 3627 const size_t count2 = decl_ctx_2.Size(); 3628 if (count1 != count2) 3629 return false; 3630 3631 // Make sure the DW_TAG values match all the way back up the 3632 // compile unit. If they don't, then we are done. 3633 DWARFDIE decl_ctx_die1; 3634 DWARFDIE decl_ctx_die2; 3635 size_t i; 3636 for (i=0; i<count1; i++) 3637 { 3638 decl_ctx_die1 = decl_ctx_1.GetDIEAtIndex (i); 3639 decl_ctx_die2 = decl_ctx_2.GetDIEAtIndex (i); 3640 if (decl_ctx_die1.Tag() != decl_ctx_die2.Tag()) 3641 return false; 3642 } 3643 #if defined LLDB_CONFIGURATION_DEBUG 3644 3645 // Make sure the top item in the decl context die array is always 3646 // DW_TAG_compile_unit. If it isn't then something went wrong in 3647 // the DWARFDIE::GetDeclContextDIEs() function... 3648 assert (decl_ctx_1.GetDIEAtIndex (count1 - 1).Tag() == DW_TAG_compile_unit); 3649 3650 #endif 3651 // Always skip the compile unit when comparing by only iterating up to 3652 // "count - 1". Here we compare the names as we go. 3653 for (i=0; i<count1 - 1; i++) 3654 { 3655 decl_ctx_die1 = decl_ctx_1.GetDIEAtIndex (i); 3656 decl_ctx_die2 = decl_ctx_2.GetDIEAtIndex (i); 3657 const char *name1 = decl_ctx_die1.GetName(); 3658 const char *name2 = decl_ctx_die2.GetName(); 3659 // If the string was from a DW_FORM_strp, then the pointer will often 3660 // be the same! 3661 if (name1 == name2) 3662 continue; 3663 3664 // Name pointers are not equal, so only compare the strings 3665 // if both are not NULL. 3666 if (name1 && name2) 3667 { 3668 // If the strings don't compare, we are done... 3669 if (strcmp(name1, name2) != 0) 3670 return false; 3671 } 3672 else 3673 { 3674 // One name was NULL while the other wasn't 3675 return false; 3676 } 3677 } 3678 // We made it through all of the checks and the declaration contexts 3679 // are equal. 3680 return true; 3681 } 3682 3683 3684 TypeSP 3685 SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext (const DWARFDeclContext &dwarf_decl_ctx) 3686 { 3687 TypeSP type_sp; 3688 3689 const uint32_t dwarf_decl_ctx_count = dwarf_decl_ctx.GetSize(); 3690 if (dwarf_decl_ctx_count > 0) 3691 { 3692 const ConstString type_name(dwarf_decl_ctx[0].name); 3693 const dw_tag_t tag = dwarf_decl_ctx[0].tag; 3694 3695 if (type_name) 3696 { 3697 Log *log (LogChannelDWARF::GetLogIfAny(DWARF_LOG_TYPE_COMPLETION|DWARF_LOG_LOOKUPS)); 3698 if (log) 3699 { 3700 GetObjectFile()->GetModule()->LogMessage (log, 3701 "SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext(tag=%s, qualified-name='%s')", 3702 DW_TAG_value_to_name(dwarf_decl_ctx[0].tag), 3703 dwarf_decl_ctx.GetQualifiedName()); 3704 } 3705 3706 DIEArray die_offsets; 3707 3708 if (m_using_apple_tables) 3709 { 3710 if (m_apple_types_ap.get()) 3711 { 3712 const bool has_tag = m_apple_types_ap->GetHeader().header_data.ContainsAtom (DWARFMappedHash::eAtomTypeTag); 3713 const bool has_qualified_name_hash = m_apple_types_ap->GetHeader().header_data.ContainsAtom (DWARFMappedHash::eAtomTypeQualNameHash); 3714 if (has_tag && has_qualified_name_hash) 3715 { 3716 const char *qualified_name = dwarf_decl_ctx.GetQualifiedName(); 3717 const uint32_t qualified_name_hash = MappedHash::HashStringUsingDJB (qualified_name); 3718 if (log) 3719 GetObjectFile()->GetModule()->LogMessage (log,"FindByNameAndTagAndQualifiedNameHash()"); 3720 m_apple_types_ap->FindByNameAndTagAndQualifiedNameHash (type_name.GetCString(), tag, qualified_name_hash, die_offsets); 3721 } 3722 else if (has_tag) 3723 { 3724 if (log) 3725 GetObjectFile()->GetModule()->LogMessage (log,"FindByNameAndTag()"); 3726 m_apple_types_ap->FindByNameAndTag (type_name.GetCString(), tag, die_offsets); 3727 } 3728 else 3729 { 3730 m_apple_types_ap->FindByName (type_name.GetCString(), die_offsets); 3731 } 3732 } 3733 } 3734 else 3735 { 3736 if (!m_indexed) 3737 Index (); 3738 3739 m_type_index.Find (type_name, die_offsets); 3740 } 3741 3742 const size_t num_matches = die_offsets.size(); 3743 3744 // Get the type system that we are looking to find a type for. We will use this 3745 // to ensure any matches we find are in a language that this type system supports 3746 const LanguageType language = dwarf_decl_ctx.GetLanguage(); 3747 TypeSystem *type_system = (language == eLanguageTypeUnknown) ? nullptr : GetTypeSystemForLanguage(language); 3748 3749 if (num_matches) 3750 { 3751 for (size_t i=0; i<num_matches; ++i) 3752 { 3753 const DIERef& die_ref = die_offsets[i]; 3754 DWARFDIE type_die = GetDIE (die_ref); 3755 3756 if (type_die) 3757 { 3758 // Make sure type_die's langauge matches the type system we are looking for. 3759 // We don't want to find a "Foo" type from Java if we are looking for a "Foo" 3760 // type for C, C++, ObjC, or ObjC++. 3761 if (type_system && !type_system->SupportsLanguage(type_die.GetLanguage())) 3762 continue; 3763 bool try_resolving_type = false; 3764 3765 // Don't try and resolve the DIE we are looking for with the DIE itself! 3766 const dw_tag_t type_tag = type_die.Tag(); 3767 // Make sure the tags match 3768 if (type_tag == tag) 3769 { 3770 // The tags match, lets try resolving this type 3771 try_resolving_type = true; 3772 } 3773 else 3774 { 3775 // The tags don't match, but we need to watch our for a 3776 // forward declaration for a struct and ("struct foo") 3777 // ends up being a class ("class foo { ... };") or 3778 // vice versa. 3779 switch (type_tag) 3780 { 3781 case DW_TAG_class_type: 3782 // We had a "class foo", see if we ended up with a "struct foo { ... };" 3783 try_resolving_type = (tag == DW_TAG_structure_type); 3784 break; 3785 case DW_TAG_structure_type: 3786 // We had a "struct foo", see if we ended up with a "class foo { ... };" 3787 try_resolving_type = (tag == DW_TAG_class_type); 3788 break; 3789 default: 3790 // Tags don't match, don't event try to resolve 3791 // using this type whose name matches.... 3792 break; 3793 } 3794 } 3795 3796 if (try_resolving_type) 3797 { 3798 DWARFDeclContext type_dwarf_decl_ctx; 3799 type_die.GetDWARFDeclContext (type_dwarf_decl_ctx); 3800 3801 if (log) 3802 { 3803 GetObjectFile()->GetModule()->LogMessage (log, 3804 "SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext(tag=%s, qualified-name='%s') trying die=0x%8.8x (%s)", 3805 DW_TAG_value_to_name(dwarf_decl_ctx[0].tag), 3806 dwarf_decl_ctx.GetQualifiedName(), 3807 type_die.GetOffset(), 3808 type_dwarf_decl_ctx.GetQualifiedName()); 3809 } 3810 3811 // Make sure the decl contexts match all the way up 3812 if (dwarf_decl_ctx == type_dwarf_decl_ctx) 3813 { 3814 Type *resolved_type = ResolveType (type_die, false); 3815 if (resolved_type && resolved_type != DIE_IS_BEING_PARSED) 3816 { 3817 type_sp = resolved_type->shared_from_this(); 3818 break; 3819 } 3820 } 3821 } 3822 else 3823 { 3824 if (log) 3825 { 3826 std::string qualified_name; 3827 type_die.GetQualifiedName(qualified_name); 3828 GetObjectFile()->GetModule()->LogMessage (log, 3829 "SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext(tag=%s, qualified-name='%s') ignoring die=0x%8.8x (%s)", 3830 DW_TAG_value_to_name(dwarf_decl_ctx[0].tag), 3831 dwarf_decl_ctx.GetQualifiedName(), 3832 type_die.GetOffset(), 3833 qualified_name.c_str()); 3834 } 3835 } 3836 } 3837 else 3838 { 3839 if (m_using_apple_tables) 3840 { 3841 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_types accelerator table had bad die 0x%8.8x for '%s')\n", 3842 die_ref.die_offset, type_name.GetCString()); 3843 } 3844 } 3845 3846 } 3847 } 3848 } 3849 } 3850 return type_sp; 3851 } 3852 3853 TypeSP 3854 SymbolFileDWARF::ParseType (const SymbolContext& sc, const DWARFDIE &die, bool *type_is_new_ptr) 3855 { 3856 TypeSP type_sp; 3857 3858 if (die) 3859 { 3860 TypeSystem *type_system = GetTypeSystemForLanguage(die.GetCU()->GetLanguageType()); 3861 3862 if (type_system) 3863 { 3864 DWARFASTParser *dwarf_ast = type_system->GetDWARFParser(); 3865 if (dwarf_ast) 3866 { 3867 Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO); 3868 type_sp = dwarf_ast->ParseTypeFromDWARF (sc, die, log, type_is_new_ptr); 3869 if (type_sp) 3870 { 3871 TypeList* type_list = GetTypeList(); 3872 if (type_list) 3873 type_list->Insert(type_sp); 3874 3875 if (die.Tag() == DW_TAG_subprogram) 3876 { 3877 DIERef die_ref = die.GetDIERef(); 3878 std::string scope_qualified_name(GetDeclContextForUID(die.GetID()).GetScopeQualifiedName().AsCString("")); 3879 if (scope_qualified_name.size()) 3880 { 3881 NameToOffsetMap::iterator iter = m_function_scope_qualified_name_map.find(scope_qualified_name); 3882 if (iter != m_function_scope_qualified_name_map.end()) 3883 (*iter).second->insert(die_ref); 3884 else 3885 { 3886 DIERefSetSP new_set(new std::set<DIERef>); 3887 new_set->insert(die_ref); 3888 m_function_scope_qualified_name_map.emplace(std::make_pair(scope_qualified_name, new_set)); 3889 } 3890 } 3891 } 3892 } 3893 } 3894 } 3895 } 3896 3897 return type_sp; 3898 } 3899 3900 size_t 3901 SymbolFileDWARF::ParseTypes 3902 ( 3903 const SymbolContext& sc, 3904 const DWARFDIE &orig_die, 3905 bool parse_siblings, 3906 bool parse_children 3907 ) 3908 { 3909 size_t types_added = 0; 3910 DWARFDIE die = orig_die; 3911 while (die) 3912 { 3913 bool type_is_new = false; 3914 if (ParseType(sc, die, &type_is_new).get()) 3915 { 3916 if (type_is_new) 3917 ++types_added; 3918 } 3919 3920 if (parse_children && die.HasChildren()) 3921 { 3922 if (die.Tag() == DW_TAG_subprogram) 3923 { 3924 SymbolContext child_sc(sc); 3925 child_sc.function = sc.comp_unit->FindFunctionByUID(die.GetID()).get(); 3926 types_added += ParseTypes(child_sc, die.GetFirstChild(), true, true); 3927 } 3928 else 3929 types_added += ParseTypes(sc, die.GetFirstChild(), true, true); 3930 } 3931 3932 if (parse_siblings) 3933 die = die.GetSibling(); 3934 else 3935 die.Clear(); 3936 } 3937 return types_added; 3938 } 3939 3940 3941 size_t 3942 SymbolFileDWARF::ParseFunctionBlocks (const SymbolContext &sc) 3943 { 3944 assert(sc.comp_unit && sc.function); 3945 size_t functions_added = 0; 3946 DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit); 3947 if (dwarf_cu) 3948 { 3949 const dw_offset_t function_die_offset = sc.function->GetID(); 3950 DWARFDIE function_die = dwarf_cu->GetDIE (function_die_offset); 3951 if (function_die) 3952 { 3953 ParseFunctionBlocks(sc, &sc.function->GetBlock (false), function_die, LLDB_INVALID_ADDRESS, 0); 3954 } 3955 } 3956 3957 return functions_added; 3958 } 3959 3960 3961 size_t 3962 SymbolFileDWARF::ParseTypes (const SymbolContext &sc) 3963 { 3964 // At least a compile unit must be valid 3965 assert(sc.comp_unit); 3966 size_t types_added = 0; 3967 DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit); 3968 if (dwarf_cu) 3969 { 3970 if (sc.function) 3971 { 3972 dw_offset_t function_die_offset = sc.function->GetID(); 3973 DWARFDIE func_die = dwarf_cu->GetDIE(function_die_offset); 3974 if (func_die && func_die.HasChildren()) 3975 { 3976 types_added = ParseTypes(sc, func_die.GetFirstChild(), true, true); 3977 } 3978 } 3979 else 3980 { 3981 DWARFDIE dwarf_cu_die = dwarf_cu->DIE(); 3982 if (dwarf_cu_die && dwarf_cu_die.HasChildren()) 3983 { 3984 types_added = ParseTypes(sc, dwarf_cu_die.GetFirstChild(), true, true); 3985 } 3986 } 3987 } 3988 3989 return types_added; 3990 } 3991 3992 size_t 3993 SymbolFileDWARF::ParseVariablesForContext (const SymbolContext& sc) 3994 { 3995 if (sc.comp_unit != NULL) 3996 { 3997 DWARFDebugInfo* info = DebugInfo(); 3998 if (info == NULL) 3999 return 0; 4000 4001 if (sc.function) 4002 { 4003 DWARFDIE function_die = info->GetDIE(DIERef(sc.function->GetID(), this)); 4004 4005 const dw_addr_t func_lo_pc = function_die.GetAttributeValueAsAddress (DW_AT_low_pc, LLDB_INVALID_ADDRESS); 4006 if (func_lo_pc != LLDB_INVALID_ADDRESS) 4007 { 4008 const size_t num_variables = ParseVariables(sc, function_die.GetFirstChild(), func_lo_pc, true, true); 4009 4010 // Let all blocks know they have parse all their variables 4011 sc.function->GetBlock (false).SetDidParseVariables (true, true); 4012 return num_variables; 4013 } 4014 } 4015 else if (sc.comp_unit) 4016 { 4017 DWARFCompileUnit* dwarf_cu = info->GetCompileUnit(sc.comp_unit->GetID()); 4018 4019 if (dwarf_cu == NULL) 4020 return 0; 4021 4022 uint32_t vars_added = 0; 4023 VariableListSP variables (sc.comp_unit->GetVariableList(false)); 4024 4025 if (variables.get() == NULL) 4026 { 4027 variables.reset(new VariableList()); 4028 sc.comp_unit->SetVariableList(variables); 4029 4030 DIEArray die_offsets; 4031 if (m_using_apple_tables) 4032 { 4033 if (m_apple_names_ap.get()) 4034 { 4035 DWARFMappedHash::DIEInfoArray hash_data_array; 4036 if (m_apple_names_ap->AppendAllDIEsInRange (dwarf_cu->GetOffset(), 4037 dwarf_cu->GetNextCompileUnitOffset(), 4038 hash_data_array)) 4039 { 4040 DWARFMappedHash::ExtractDIEArray (hash_data_array, die_offsets); 4041 } 4042 } 4043 } 4044 else 4045 { 4046 // Index if we already haven't to make sure the compile units 4047 // get indexed and make their global DIE index list 4048 if (!m_indexed) 4049 Index (); 4050 4051 m_global_index.FindAllEntriesForCompileUnit (dwarf_cu->GetOffset(), 4052 die_offsets); 4053 } 4054 4055 const size_t num_matches = die_offsets.size(); 4056 if (num_matches) 4057 { 4058 for (size_t i=0; i<num_matches; ++i) 4059 { 4060 const DIERef& die_ref = die_offsets[i]; 4061 DWARFDIE die = GetDIE (die_ref); 4062 if (die) 4063 { 4064 VariableSP var_sp (ParseVariableDIE(sc, die, LLDB_INVALID_ADDRESS)); 4065 if (var_sp) 4066 { 4067 variables->AddVariableIfUnique (var_sp); 4068 ++vars_added; 4069 } 4070 } 4071 else 4072 { 4073 if (m_using_apple_tables) 4074 { 4075 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_names accelerator table had bad die 0x%8.8x)\n", die_ref.die_offset); 4076 } 4077 } 4078 4079 } 4080 } 4081 } 4082 return vars_added; 4083 } 4084 } 4085 return 0; 4086 } 4087 4088 VariableSP 4089 SymbolFileDWARF::ParseVariableDIE 4090 ( 4091 const SymbolContext& sc, 4092 const DWARFDIE &die, 4093 const lldb::addr_t func_low_pc 4094 ) 4095 { 4096 if (die.GetDWARF() != this) 4097 return die.GetDWARF()->ParseVariableDIE(sc, die, func_low_pc); 4098 4099 VariableSP var_sp; 4100 if (!die) 4101 return var_sp; 4102 4103 var_sp = GetDIEToVariable()[die.GetDIE()]; 4104 if (var_sp) 4105 return var_sp; // Already been parsed! 4106 4107 const dw_tag_t tag = die.Tag(); 4108 ModuleSP module = GetObjectFile()->GetModule(); 4109 4110 if ((tag == DW_TAG_variable) || 4111 (tag == DW_TAG_constant) || 4112 (tag == DW_TAG_formal_parameter && sc.function)) 4113 { 4114 DWARFAttributes attributes; 4115 const size_t num_attributes = die.GetAttributes(attributes); 4116 DWARFDIE spec_die; 4117 if (num_attributes > 0) 4118 { 4119 const char *name = NULL; 4120 const char *mangled = NULL; 4121 Declaration decl; 4122 uint32_t i; 4123 DWARFFormValue type_die_form; 4124 DWARFExpression location(die.GetCU()); 4125 bool is_external = false; 4126 bool is_artificial = false; 4127 bool location_is_const_value_data = false; 4128 bool has_explicit_location = false; 4129 DWARFFormValue const_value; 4130 Variable::RangeList scope_ranges; 4131 //AccessType accessibility = eAccessNone; 4132 4133 for (i=0; i<num_attributes; ++i) 4134 { 4135 dw_attr_t attr = attributes.AttributeAtIndex(i); 4136 DWARFFormValue form_value; 4137 4138 if (attributes.ExtractFormValueAtIndex(i, form_value)) 4139 { 4140 switch (attr) 4141 { 4142 case DW_AT_decl_file: decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned())); break; 4143 case DW_AT_decl_line: decl.SetLine(form_value.Unsigned()); break; 4144 case DW_AT_decl_column: decl.SetColumn(form_value.Unsigned()); break; 4145 case DW_AT_name: name = form_value.AsCString(); break; 4146 case DW_AT_linkage_name: 4147 case DW_AT_MIPS_linkage_name: mangled = form_value.AsCString(); break; 4148 case DW_AT_type: type_die_form = form_value; break; 4149 case DW_AT_external: is_external = form_value.Boolean(); break; 4150 case DW_AT_const_value: 4151 // If we have already found a DW_AT_location attribute, ignore this attribute. 4152 if (!has_explicit_location) 4153 { 4154 location_is_const_value_data = true; 4155 // The constant value will be either a block, a data value or a string. 4156 const DWARFDataExtractor& debug_info_data = get_debug_info_data(); 4157 if (DWARFFormValue::IsBlockForm(form_value.Form())) 4158 { 4159 // Retrieve the value as a block expression. 4160 uint32_t block_offset = form_value.BlockData() - debug_info_data.GetDataStart(); 4161 uint32_t block_length = form_value.Unsigned(); 4162 location.CopyOpcodeData(module, debug_info_data, block_offset, block_length); 4163 } 4164 else if (DWARFFormValue::IsDataForm(form_value.Form())) 4165 { 4166 // Retrieve the value as a data expression. 4167 DWARFFormValue::FixedFormSizes fixed_form_sizes = 4168 DWARFFormValue::GetFixedFormSizesForAddressSize ( 4169 attributes.CompileUnitAtIndex(i)->GetAddressByteSize(), 4170 attributes.CompileUnitAtIndex(i)->IsDWARF64()); 4171 uint32_t data_offset = attributes.DIEOffsetAtIndex(i); 4172 uint32_t data_length = fixed_form_sizes.GetSize(form_value.Form()); 4173 if (data_length == 0) 4174 { 4175 const uint8_t *data_pointer = form_value.BlockData(); 4176 if (data_pointer) 4177 { 4178 form_value.Unsigned(); 4179 } 4180 else if (DWARFFormValue::IsDataForm(form_value.Form())) 4181 { 4182 // we need to get the byte size of the type later after we create the variable 4183 const_value = form_value; 4184 } 4185 } 4186 else 4187 location.CopyOpcodeData(module, debug_info_data, data_offset, data_length); 4188 } 4189 else 4190 { 4191 // Retrieve the value as a string expression. 4192 if (form_value.Form() == DW_FORM_strp) 4193 { 4194 DWARFFormValue::FixedFormSizes fixed_form_sizes = 4195 DWARFFormValue::GetFixedFormSizesForAddressSize ( 4196 attributes.CompileUnitAtIndex(i)->GetAddressByteSize(), 4197 attributes.CompileUnitAtIndex(i)->IsDWARF64()); 4198 uint32_t data_offset = attributes.DIEOffsetAtIndex(i); 4199 uint32_t data_length = fixed_form_sizes.GetSize(form_value.Form()); 4200 location.CopyOpcodeData(module, debug_info_data, data_offset, data_length); 4201 } 4202 else 4203 { 4204 const char *str = form_value.AsCString(); 4205 uint32_t string_offset = str - (const char *)debug_info_data.GetDataStart(); 4206 uint32_t string_length = strlen(str) + 1; 4207 location.CopyOpcodeData(module, debug_info_data, string_offset, string_length); 4208 } 4209 } 4210 } 4211 break; 4212 case DW_AT_location: 4213 { 4214 location_is_const_value_data = false; 4215 has_explicit_location = true; 4216 if (form_value.BlockData()) 4217 { 4218 const DWARFDataExtractor& debug_info_data = get_debug_info_data(); 4219 4220 uint32_t block_offset = form_value.BlockData() - debug_info_data.GetDataStart(); 4221 uint32_t block_length = form_value.Unsigned(); 4222 location.CopyOpcodeData(module, get_debug_info_data(), block_offset, block_length); 4223 } 4224 else 4225 { 4226 const DWARFDataExtractor& debug_loc_data = get_debug_loc_data(); 4227 const dw_offset_t debug_loc_offset = form_value.Unsigned(); 4228 4229 size_t loc_list_length = DWARFExpression::LocationListSize(die.GetCU(), debug_loc_data, debug_loc_offset); 4230 if (loc_list_length > 0) 4231 { 4232 location.CopyOpcodeData(module, debug_loc_data, debug_loc_offset, loc_list_length); 4233 assert (func_low_pc != LLDB_INVALID_ADDRESS); 4234 location.SetLocationListSlide (func_low_pc - attributes.CompileUnitAtIndex(i)->GetBaseAddress()); 4235 } 4236 } 4237 } 4238 break; 4239 case DW_AT_specification: 4240 spec_die = GetDIE(DIERef(form_value)); 4241 break; 4242 case DW_AT_start_scope: 4243 { 4244 if (form_value.Form() == DW_FORM_sec_offset) 4245 { 4246 DWARFRangeList dwarf_scope_ranges; 4247 const DWARFDebugRanges* debug_ranges = DebugRanges(); 4248 debug_ranges->FindRanges(form_value.Unsigned(), dwarf_scope_ranges); 4249 4250 // All DW_AT_start_scope are relative to the base address of the 4251 // compile unit. We add the compile unit base address to make 4252 // sure all the addresses are properly fixed up. 4253 for (size_t i = 0, count = dwarf_scope_ranges.GetSize(); i < count; ++i) 4254 { 4255 const DWARFRangeList::Entry& range = dwarf_scope_ranges.GetEntryRef(i); 4256 scope_ranges.Append(range.GetRangeBase() + die.GetCU()->GetBaseAddress(), 4257 range.GetByteSize()); 4258 } 4259 } 4260 else 4261 { 4262 // TODO: Handle the case when DW_AT_start_scope have form constant. The 4263 // dwarf spec is a bit ambiguous about what is the expected behavior in 4264 // case the enclosing block have a non coninious address range and the 4265 // DW_AT_start_scope entry have a form constant. 4266 GetObjectFile()->GetModule()->ReportWarning ("0x%8.8" PRIx64 ": DW_AT_start_scope has unsupported form type (0x%x)\n", 4267 die.GetID(), 4268 form_value.Form()); 4269 } 4270 4271 scope_ranges.Sort(); 4272 scope_ranges.CombineConsecutiveRanges(); 4273 } 4274 break; 4275 case DW_AT_artificial: is_artificial = form_value.Boolean(); break; 4276 case DW_AT_accessibility: break; //accessibility = DW_ACCESS_to_AccessType(form_value.Unsigned()); break; 4277 case DW_AT_declaration: 4278 case DW_AT_description: 4279 case DW_AT_endianity: 4280 case DW_AT_segment: 4281 case DW_AT_visibility: 4282 default: 4283 case DW_AT_abstract_origin: 4284 case DW_AT_sibling: 4285 break; 4286 } 4287 } 4288 } 4289 4290 const DWARFDIE parent_context_die = GetDeclContextDIEContainingDIE(die); 4291 const dw_tag_t parent_tag = die.GetParent().Tag(); 4292 bool is_static_member = parent_tag == DW_TAG_compile_unit && (parent_context_die.Tag() == DW_TAG_class_type || parent_context_die.Tag() == DW_TAG_structure_type); 4293 4294 ValueType scope = eValueTypeInvalid; 4295 4296 const DWARFDIE sc_parent_die = GetParentSymbolContextDIE(die); 4297 SymbolContextScope * symbol_context_scope = NULL; 4298 4299 if (!mangled) 4300 { 4301 // LLDB relies on the mangled name (DW_TAG_linkage_name or DW_AT_MIPS_linkage_name) to 4302 // generate fully qualified names of global variables with commands like "frame var j". 4303 // For example, if j were an int variable holding a value 4 and declared in a namespace 4304 // B which in turn is contained in a namespace A, the command "frame var j" returns 4305 // "(int) A::B::j = 4". If the compiler does not emit a linkage name, we should be able 4306 // to generate a fully qualified name from the declaration context. 4307 if (parent_tag == DW_TAG_compile_unit && 4308 Language::LanguageIsCPlusPlus(die.GetLanguage())) 4309 { 4310 DWARFDeclContext decl_ctx; 4311 4312 die.GetDWARFDeclContext(decl_ctx); 4313 mangled = decl_ctx.GetQualifiedNameAsConstString().GetCString(); 4314 } 4315 } 4316 4317 // DWARF doesn't specify if a DW_TAG_variable is a local, global 4318 // or static variable, so we have to do a little digging by 4319 // looking at the location of a variable to see if it contains 4320 // a DW_OP_addr opcode _somewhere_ in the definition. I say 4321 // somewhere because clang likes to combine small global variables 4322 // into the same symbol and have locations like: 4323 // DW_OP_addr(0x1000), DW_OP_constu(2), DW_OP_plus 4324 // So if we don't have a DW_TAG_formal_parameter, we can look at 4325 // the location to see if it contains a DW_OP_addr opcode, and 4326 // then we can correctly classify our variables. 4327 if (tag == DW_TAG_formal_parameter) 4328 scope = eValueTypeVariableArgument; 4329 else 4330 { 4331 bool op_error = false; 4332 // Check if the location has a DW_OP_addr with any address value... 4333 lldb::addr_t location_DW_OP_addr = LLDB_INVALID_ADDRESS; 4334 if (!location_is_const_value_data) 4335 { 4336 location_DW_OP_addr = location.GetLocation_DW_OP_addr (0, op_error); 4337 if (op_error) 4338 { 4339 StreamString strm; 4340 location.DumpLocationForAddress (&strm, eDescriptionLevelFull, 0, 0, NULL); 4341 GetObjectFile()->GetModule()->ReportError ("0x%8.8x: %s has an invalid location: %s", die.GetOffset(), die.GetTagAsCString(), strm.GetString().c_str()); 4342 } 4343 } 4344 4345 if (location_DW_OP_addr != LLDB_INVALID_ADDRESS) 4346 { 4347 if (is_external) 4348 scope = eValueTypeVariableGlobal; 4349 else 4350 scope = eValueTypeVariableStatic; 4351 4352 4353 SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile(); 4354 4355 if (debug_map_symfile) 4356 { 4357 // When leaving the DWARF in the .o files on darwin, 4358 // when we have a global variable that wasn't initialized, 4359 // the .o file might not have allocated a virtual 4360 // address for the global variable. In this case it will 4361 // have created a symbol for the global variable 4362 // that is undefined/data and external and the value will 4363 // be the byte size of the variable. When we do the 4364 // address map in SymbolFileDWARFDebugMap we rely on 4365 // having an address, we need to do some magic here 4366 // so we can get the correct address for our global 4367 // variable. The address for all of these entries 4368 // will be zero, and there will be an undefined symbol 4369 // in this object file, and the executable will have 4370 // a matching symbol with a good address. So here we 4371 // dig up the correct address and replace it in the 4372 // location for the variable, and set the variable's 4373 // symbol context scope to be that of the main executable 4374 // so the file address will resolve correctly. 4375 bool linked_oso_file_addr = false; 4376 if (is_external && location_DW_OP_addr == 0) 4377 { 4378 // we have a possible uninitialized extern global 4379 ConstString const_name(mangled ? mangled : name); 4380 ObjectFile *debug_map_objfile = debug_map_symfile->GetObjectFile(); 4381 if (debug_map_objfile) 4382 { 4383 Symtab *debug_map_symtab = debug_map_objfile->GetSymtab(); 4384 if (debug_map_symtab) 4385 { 4386 Symbol *exe_symbol = debug_map_symtab->FindFirstSymbolWithNameAndType (const_name, 4387 eSymbolTypeData, 4388 Symtab::eDebugYes, 4389 Symtab::eVisibilityExtern); 4390 if (exe_symbol) 4391 { 4392 if (exe_symbol->ValueIsAddress()) 4393 { 4394 const addr_t exe_file_addr = exe_symbol->GetAddressRef().GetFileAddress(); 4395 if (exe_file_addr != LLDB_INVALID_ADDRESS) 4396 { 4397 if (location.Update_DW_OP_addr (exe_file_addr)) 4398 { 4399 linked_oso_file_addr = true; 4400 symbol_context_scope = exe_symbol; 4401 } 4402 } 4403 } 4404 } 4405 } 4406 } 4407 } 4408 4409 if (!linked_oso_file_addr) 4410 { 4411 // The DW_OP_addr is not zero, but it contains a .o file address which 4412 // needs to be linked up correctly. 4413 const lldb::addr_t exe_file_addr = debug_map_symfile->LinkOSOFileAddress(this, location_DW_OP_addr); 4414 if (exe_file_addr != LLDB_INVALID_ADDRESS) 4415 { 4416 // Update the file address for this variable 4417 location.Update_DW_OP_addr (exe_file_addr); 4418 } 4419 else 4420 { 4421 // Variable didn't make it into the final executable 4422 return var_sp; 4423 } 4424 } 4425 } 4426 } 4427 else 4428 { 4429 if (location_is_const_value_data) 4430 scope = eValueTypeVariableStatic; 4431 else 4432 scope = eValueTypeVariableLocal; 4433 } 4434 } 4435 4436 if (symbol_context_scope == NULL) 4437 { 4438 switch (parent_tag) 4439 { 4440 case DW_TAG_subprogram: 4441 case DW_TAG_inlined_subroutine: 4442 case DW_TAG_lexical_block: 4443 if (sc.function) 4444 { 4445 symbol_context_scope = sc.function->GetBlock(true).FindBlockByID(sc_parent_die.GetID()); 4446 if (symbol_context_scope == NULL) 4447 symbol_context_scope = sc.function; 4448 } 4449 break; 4450 4451 default: 4452 symbol_context_scope = sc.comp_unit; 4453 break; 4454 } 4455 } 4456 4457 if (symbol_context_scope) 4458 { 4459 SymbolFileTypeSP type_sp(new SymbolFileType(*this, DIERef(type_die_form).GetUID(this))); 4460 4461 if (const_value.Form() && type_sp && type_sp->GetType()) 4462 location.CopyOpcodeData(const_value.Unsigned(), type_sp->GetType()->GetByteSize(), die.GetCU()->GetAddressByteSize()); 4463 4464 var_sp.reset (new Variable (die.GetID(), 4465 name, 4466 mangled, 4467 type_sp, 4468 scope, 4469 symbol_context_scope, 4470 scope_ranges, 4471 &decl, 4472 location, 4473 is_external, 4474 is_artificial, 4475 is_static_member)); 4476 4477 var_sp->SetLocationIsConstantValueData (location_is_const_value_data); 4478 } 4479 else 4480 { 4481 // Not ready to parse this variable yet. It might be a global 4482 // or static variable that is in a function scope and the function 4483 // in the symbol context wasn't filled in yet 4484 return var_sp; 4485 } 4486 } 4487 // Cache var_sp even if NULL (the variable was just a specification or 4488 // was missing vital information to be able to be displayed in the debugger 4489 // (missing location due to optimization, etc)) so we don't re-parse 4490 // this DIE over and over later... 4491 GetDIEToVariable()[die.GetDIE()] = var_sp; 4492 if (spec_die) 4493 GetDIEToVariable()[spec_die.GetDIE()] = var_sp; 4494 } 4495 return var_sp; 4496 } 4497 4498 4499 DWARFDIE 4500 SymbolFileDWARF::FindBlockContainingSpecification (const DIERef& func_die_ref, 4501 dw_offset_t spec_block_die_offset) 4502 { 4503 // Give the concrete function die specified by "func_die_offset", find the 4504 // concrete block whose DW_AT_specification or DW_AT_abstract_origin points 4505 // to "spec_block_die_offset" 4506 return FindBlockContainingSpecification (DebugInfo()->GetDIE (func_die_ref), spec_block_die_offset); 4507 } 4508 4509 4510 DWARFDIE 4511 SymbolFileDWARF::FindBlockContainingSpecification(const DWARFDIE &die, 4512 dw_offset_t spec_block_die_offset) 4513 { 4514 if (die) 4515 { 4516 switch (die.Tag()) 4517 { 4518 case DW_TAG_subprogram: 4519 case DW_TAG_inlined_subroutine: 4520 case DW_TAG_lexical_block: 4521 { 4522 if (die.GetAttributeValueAsReference (DW_AT_specification, DW_INVALID_OFFSET) == spec_block_die_offset) 4523 return die; 4524 4525 if (die.GetAttributeValueAsReference (DW_AT_abstract_origin, DW_INVALID_OFFSET) == spec_block_die_offset) 4526 return die; 4527 } 4528 break; 4529 } 4530 4531 // Give the concrete function die specified by "func_die_offset", find the 4532 // concrete block whose DW_AT_specification or DW_AT_abstract_origin points 4533 // to "spec_block_die_offset" 4534 for (DWARFDIE child_die = die.GetFirstChild(); child_die; child_die = child_die.GetSibling()) 4535 { 4536 DWARFDIE result_die = FindBlockContainingSpecification (child_die, spec_block_die_offset); 4537 if (result_die) 4538 return result_die; 4539 } 4540 } 4541 4542 return DWARFDIE(); 4543 } 4544 4545 size_t 4546 SymbolFileDWARF::ParseVariables (const SymbolContext& sc, 4547 const DWARFDIE &orig_die, 4548 const lldb::addr_t func_low_pc, 4549 bool parse_siblings, 4550 bool parse_children, 4551 VariableList* cc_variable_list) 4552 { 4553 if (!orig_die) 4554 return 0; 4555 4556 VariableListSP variable_list_sp; 4557 4558 size_t vars_added = 0; 4559 DWARFDIE die = orig_die; 4560 while (die) 4561 { 4562 dw_tag_t tag = die.Tag(); 4563 4564 // Check to see if we have already parsed this variable or constant? 4565 VariableSP var_sp = GetDIEToVariable()[die.GetDIE()]; 4566 if (var_sp) 4567 { 4568 if (cc_variable_list) 4569 cc_variable_list->AddVariableIfUnique (var_sp); 4570 } 4571 else 4572 { 4573 // We haven't already parsed it, lets do that now. 4574 if ((tag == DW_TAG_variable) || 4575 (tag == DW_TAG_constant) || 4576 (tag == DW_TAG_formal_parameter && sc.function)) 4577 { 4578 if (variable_list_sp.get() == NULL) 4579 { 4580 DWARFDIE sc_parent_die = GetParentSymbolContextDIE(orig_die); 4581 dw_tag_t parent_tag = sc_parent_die.Tag(); 4582 switch (parent_tag) 4583 { 4584 case DW_TAG_compile_unit: 4585 if (sc.comp_unit != NULL) 4586 { 4587 variable_list_sp = sc.comp_unit->GetVariableList(false); 4588 if (variable_list_sp.get() == NULL) 4589 { 4590 variable_list_sp.reset(new VariableList()); 4591 sc.comp_unit->SetVariableList(variable_list_sp); 4592 } 4593 } 4594 else 4595 { 4596 GetObjectFile()->GetModule()->ReportError ("parent 0x%8.8" PRIx64 " %s with no valid compile unit in symbol context for 0x%8.8" PRIx64 " %s.\n", 4597 sc_parent_die.GetID(), 4598 sc_parent_die.GetTagAsCString(), 4599 orig_die.GetID(), 4600 orig_die.GetTagAsCString()); 4601 } 4602 break; 4603 4604 case DW_TAG_subprogram: 4605 case DW_TAG_inlined_subroutine: 4606 case DW_TAG_lexical_block: 4607 if (sc.function != NULL) 4608 { 4609 // Check to see if we already have parsed the variables for the given scope 4610 4611 Block *block = sc.function->GetBlock(true).FindBlockByID(sc_parent_die.GetID()); 4612 if (block == NULL) 4613 { 4614 // This must be a specification or abstract origin with 4615 // a concrete block counterpart in the current function. We need 4616 // to find the concrete block so we can correctly add the 4617 // variable to it 4618 const DWARFDIE concrete_block_die = FindBlockContainingSpecification (DIERef(sc.function->GetID(), this), 4619 sc_parent_die.GetOffset()); 4620 if (concrete_block_die) 4621 block = sc.function->GetBlock(true).FindBlockByID(concrete_block_die.GetID()); 4622 } 4623 4624 if (block != NULL) 4625 { 4626 const bool can_create = false; 4627 variable_list_sp = block->GetBlockVariableList (can_create); 4628 if (variable_list_sp.get() == NULL) 4629 { 4630 variable_list_sp.reset(new VariableList()); 4631 block->SetVariableList(variable_list_sp); 4632 } 4633 } 4634 } 4635 break; 4636 4637 default: 4638 GetObjectFile()->GetModule()->ReportError ("didn't find appropriate parent DIE for variable list for 0x%8.8" PRIx64 " %s.\n", 4639 orig_die.GetID(), 4640 orig_die.GetTagAsCString()); 4641 break; 4642 } 4643 } 4644 4645 if (variable_list_sp) 4646 { 4647 VariableSP var_sp (ParseVariableDIE(sc, die, func_low_pc)); 4648 if (var_sp) 4649 { 4650 variable_list_sp->AddVariableIfUnique (var_sp); 4651 if (cc_variable_list) 4652 cc_variable_list->AddVariableIfUnique (var_sp); 4653 ++vars_added; 4654 } 4655 } 4656 } 4657 } 4658 4659 bool skip_children = (sc.function == NULL && tag == DW_TAG_subprogram); 4660 4661 if (!skip_children && parse_children && die.HasChildren()) 4662 { 4663 vars_added += ParseVariables(sc, die.GetFirstChild(), func_low_pc, true, true, cc_variable_list); 4664 } 4665 4666 if (parse_siblings) 4667 die = die.GetSibling(); 4668 else 4669 die.Clear(); 4670 } 4671 return vars_added; 4672 } 4673 4674 //------------------------------------------------------------------ 4675 // PluginInterface protocol 4676 //------------------------------------------------------------------ 4677 ConstString 4678 SymbolFileDWARF::GetPluginName() 4679 { 4680 return GetPluginNameStatic(); 4681 } 4682 4683 uint32_t 4684 SymbolFileDWARF::GetPluginVersion() 4685 { 4686 return 1; 4687 } 4688 4689 void 4690 SymbolFileDWARF::DumpIndexes () 4691 { 4692 StreamFile s(stdout, false); 4693 4694 s.Printf ("DWARF index for (%s) '%s':", 4695 GetObjectFile()->GetModule()->GetArchitecture().GetArchitectureName(), 4696 GetObjectFile()->GetFileSpec().GetPath().c_str()); 4697 s.Printf("\nFunction basenames:\n"); m_function_basename_index.Dump (&s); 4698 s.Printf("\nFunction fullnames:\n"); m_function_fullname_index.Dump (&s); 4699 s.Printf("\nFunction methods:\n"); m_function_method_index.Dump (&s); 4700 s.Printf("\nFunction selectors:\n"); m_function_selector_index.Dump (&s); 4701 s.Printf("\nObjective C class selectors:\n"); m_objc_class_selectors_index.Dump (&s); 4702 s.Printf("\nGlobals and statics:\n"); m_global_index.Dump (&s); 4703 s.Printf("\nTypes:\n"); m_type_index.Dump (&s); 4704 s.Printf("\nNamespaces:\n"); m_namespace_index.Dump (&s); 4705 } 4706 4707 4708 SymbolFileDWARFDebugMap * 4709 SymbolFileDWARF::GetDebugMapSymfile() 4710 { 4711 if (m_debug_map_symfile == NULL && !m_debug_map_module_wp.expired()) 4712 { 4713 lldb::ModuleSP module_sp (m_debug_map_module_wp.lock()); 4714 if (module_sp) 4715 { 4716 SymbolVendor *sym_vendor = module_sp->GetSymbolVendor(); 4717 if (sym_vendor) 4718 m_debug_map_symfile = (SymbolFileDWARFDebugMap *)sym_vendor->GetSymbolFile(); 4719 } 4720 } 4721 return m_debug_map_symfile; 4722 } 4723 4724 DWARFExpression::LocationListFormat 4725 SymbolFileDWARF::GetLocationListFormat() const 4726 { 4727 return DWARFExpression::RegularLocationList; 4728 } 4729