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 CompilerDecl 1463 SymbolFileDWARF::GetDeclForUID (lldb::user_id_t type_uid) 1464 { 1465 DWARFDIE die = GetDIE(DIERef(type_uid, this)); 1466 if (die) 1467 return die.GetDecl(); 1468 return CompilerDecl(); 1469 } 1470 1471 CompilerDeclContext 1472 SymbolFileDWARF::GetDeclContextForUID (lldb::user_id_t type_uid) 1473 { 1474 DWARFDIE die = GetDIE(DIERef(type_uid, this)); 1475 if (die) 1476 return die.GetDeclContext(); 1477 return CompilerDeclContext(); 1478 } 1479 1480 CompilerDeclContext 1481 SymbolFileDWARF::GetDeclContextContainingUID (lldb::user_id_t type_uid) 1482 { 1483 DWARFDIE die = GetDIE (DIERef(type_uid, this)); 1484 if (die) 1485 return die.GetContainingDeclContext(); 1486 return CompilerDeclContext(); 1487 } 1488 1489 1490 Type* 1491 SymbolFileDWARF::ResolveTypeUID (lldb::user_id_t type_uid) 1492 { 1493 DWARFDIE type_die = GetDIE (DIERef(type_uid, this)); 1494 if (type_die) 1495 { 1496 const bool assert_not_being_parsed = true; 1497 return ResolveTypeUID (type_die, assert_not_being_parsed); 1498 } 1499 return NULL; 1500 } 1501 1502 Type* 1503 SymbolFileDWARF::ResolveTypeUID (const DIERef &die_ref) 1504 { 1505 return ResolveType (GetDIE(die_ref), true); 1506 } 1507 1508 Type* 1509 SymbolFileDWARF::ResolveTypeUID (const DWARFDIE &die, bool assert_not_being_parsed) 1510 { 1511 if (die) 1512 { 1513 Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO)); 1514 if (log) 1515 GetObjectFile()->GetModule()->LogMessage (log, 1516 "SymbolFileDWARF::ResolveTypeUID (die = 0x%8.8x) %s '%s'", 1517 die.GetOffset(), 1518 die.GetTagAsCString(), 1519 die.GetName()); 1520 1521 // We might be coming in in the middle of a type tree (a class 1522 // withing a class, an enum within a class), so parse any needed 1523 // parent DIEs before we get to this one... 1524 DWARFDIE decl_ctx_die = GetDeclContextDIEContainingDIE (die); 1525 if (decl_ctx_die) 1526 { 1527 if (log) 1528 { 1529 switch (decl_ctx_die.Tag()) 1530 { 1531 case DW_TAG_structure_type: 1532 case DW_TAG_union_type: 1533 case DW_TAG_class_type: 1534 { 1535 // Get the type, which could be a forward declaration 1536 if (log) 1537 GetObjectFile()->GetModule()->LogMessage (log, 1538 "SymbolFileDWARF::ResolveTypeUID (die = 0x%8.8x) %s '%s' resolve parent forward type for 0x%8.8x", 1539 die.GetOffset(), 1540 die.GetTagAsCString(), 1541 die.GetName(), 1542 decl_ctx_die.GetOffset()); 1543 } 1544 break; 1545 1546 default: 1547 break; 1548 } 1549 } 1550 } 1551 return ResolveType (die); 1552 } 1553 return NULL; 1554 } 1555 1556 // This function is used when SymbolFileDWARFDebugMap owns a bunch of 1557 // SymbolFileDWARF objects to detect if this DWARF file is the one that 1558 // can resolve a compiler_type. 1559 bool 1560 SymbolFileDWARF::HasForwardDeclForClangType (const CompilerType &compiler_type) 1561 { 1562 CompilerType compiler_type_no_qualifiers = ClangUtil::RemoveFastQualifiers(compiler_type); 1563 if (GetForwardDeclClangTypeToDie().count (compiler_type_no_qualifiers.GetOpaqueQualType())) 1564 { 1565 return true; 1566 } 1567 TypeSystem *type_system = compiler_type.GetTypeSystem(); 1568 1569 ClangASTContext *clang_type_system = llvm::dyn_cast_or_null<ClangASTContext>(type_system); 1570 if (!clang_type_system) 1571 return false; 1572 DWARFASTParserClang *ast_parser = static_cast<DWARFASTParserClang *>(clang_type_system->GetDWARFParser()); 1573 return ast_parser->GetClangASTImporter().CanImport(compiler_type); 1574 } 1575 1576 1577 bool 1578 SymbolFileDWARF::CompleteType (CompilerType &compiler_type) 1579 { 1580 lldb_private::Mutex::Locker locker(GetObjectFile()->GetModule()->GetMutex()); 1581 1582 ClangASTContext *clang_type_system = llvm::dyn_cast_or_null<ClangASTContext>(compiler_type.GetTypeSystem()); 1583 if (clang_type_system) 1584 { 1585 DWARFASTParserClang *ast_parser = static_cast<DWARFASTParserClang *>(clang_type_system->GetDWARFParser()); 1586 if (ast_parser && ast_parser->GetClangASTImporter().CanImport(compiler_type)) 1587 return ast_parser->GetClangASTImporter().CompleteType(compiler_type); 1588 } 1589 1590 // We have a struct/union/class/enum that needs to be fully resolved. 1591 CompilerType compiler_type_no_qualifiers = ClangUtil::RemoveFastQualifiers(compiler_type); 1592 auto die_it = GetForwardDeclClangTypeToDie().find (compiler_type_no_qualifiers.GetOpaqueQualType()); 1593 if (die_it == GetForwardDeclClangTypeToDie().end()) 1594 { 1595 // We have already resolved this type... 1596 return true; 1597 } 1598 1599 DWARFDIE dwarf_die = GetDIE(die_it->getSecond()); 1600 if (dwarf_die) 1601 { 1602 // Once we start resolving this type, remove it from the forward declaration 1603 // map in case anyone child members or other types require this type to get resolved. 1604 // The type will get resolved when all of the calls to SymbolFileDWARF::ResolveClangOpaqueTypeDefinition 1605 // are done. 1606 GetForwardDeclClangTypeToDie().erase (die_it); 1607 1608 Type *type = GetDIEToType().lookup (dwarf_die.GetDIE()); 1609 1610 Log *log (LogChannelDWARF::GetLogIfAny(DWARF_LOG_DEBUG_INFO|DWARF_LOG_TYPE_COMPLETION)); 1611 if (log) 1612 GetObjectFile()->GetModule()->LogMessageVerboseBacktrace (log, 1613 "0x%8.8" PRIx64 ": %s '%s' resolving forward declaration...", 1614 dwarf_die.GetID(), 1615 dwarf_die.GetTagAsCString(), 1616 type->GetName().AsCString()); 1617 assert (compiler_type); 1618 DWARFASTParser *dwarf_ast = dwarf_die.GetDWARFParser(); 1619 if (dwarf_ast) 1620 return dwarf_ast->CompleteTypeFromDWARF (dwarf_die, type, compiler_type); 1621 } 1622 return false; 1623 } 1624 1625 Type* 1626 SymbolFileDWARF::ResolveType (const DWARFDIE &die, bool assert_not_being_parsed, bool resolve_function_context) 1627 { 1628 if (die) 1629 { 1630 Type *type = GetTypeForDIE (die, resolve_function_context).get(); 1631 1632 if (assert_not_being_parsed) 1633 { 1634 if (type != DIE_IS_BEING_PARSED) 1635 return type; 1636 1637 GetObjectFile()->GetModule()->ReportError ("Parsing a die that is being parsed die: 0x%8.8x: %s %s", 1638 die.GetOffset(), 1639 die.GetTagAsCString(), 1640 die.GetName()); 1641 1642 } 1643 else 1644 return type; 1645 } 1646 return nullptr; 1647 } 1648 1649 CompileUnit* 1650 SymbolFileDWARF::GetCompUnitForDWARFCompUnit (DWARFCompileUnit* dwarf_cu, uint32_t cu_idx) 1651 { 1652 // Check if the symbol vendor already knows about this compile unit? 1653 if (dwarf_cu->GetUserData() == NULL) 1654 { 1655 // The symbol vendor doesn't know about this compile unit, we 1656 // need to parse and add it to the symbol vendor object. 1657 return ParseCompileUnit(dwarf_cu, cu_idx).get(); 1658 } 1659 return (CompileUnit*)dwarf_cu->GetUserData(); 1660 } 1661 1662 size_t 1663 SymbolFileDWARF::GetObjCMethodDIEOffsets (ConstString class_name, DIEArray &method_die_offsets) 1664 { 1665 method_die_offsets.clear(); 1666 if (m_using_apple_tables) 1667 { 1668 if (m_apple_objc_ap.get()) 1669 m_apple_objc_ap->FindByName(class_name.GetCString(), method_die_offsets); 1670 } 1671 else 1672 { 1673 if (!m_indexed) 1674 Index (); 1675 1676 m_objc_class_selectors_index.Find (class_name, method_die_offsets); 1677 } 1678 return method_die_offsets.size(); 1679 } 1680 1681 bool 1682 SymbolFileDWARF::GetFunction (const DWARFDIE &die, SymbolContext& sc) 1683 { 1684 sc.Clear(false); 1685 1686 if (die) 1687 { 1688 // Check if the symbol vendor already knows about this compile unit? 1689 sc.comp_unit = GetCompUnitForDWARFCompUnit(die.GetCU(), UINT32_MAX); 1690 1691 sc.function = sc.comp_unit->FindFunctionByUID (die.GetID()).get(); 1692 if (sc.function == NULL) 1693 sc.function = ParseCompileUnitFunction(sc, die); 1694 1695 if (sc.function) 1696 { 1697 sc.module_sp = sc.function->CalculateSymbolContextModule(); 1698 return true; 1699 } 1700 } 1701 1702 return false; 1703 } 1704 1705 lldb::ModuleSP 1706 SymbolFileDWARF::GetDWOModule (ConstString name) 1707 { 1708 UpdateExternalModuleListIfNeeded(); 1709 const auto &pos = m_external_type_modules.find(name); 1710 if (pos != m_external_type_modules.end()) 1711 return pos->second; 1712 else 1713 return lldb::ModuleSP(); 1714 } 1715 1716 DWARFDIE 1717 SymbolFileDWARF::GetDIE (const DIERef &die_ref) 1718 { 1719 DWARFDebugInfo * debug_info = DebugInfo(); 1720 if (debug_info) 1721 return debug_info->GetDIE(die_ref); 1722 else 1723 return DWARFDIE(); 1724 } 1725 1726 1727 std::unique_ptr<SymbolFileDWARFDwo> 1728 SymbolFileDWARF::GetDwoSymbolFileForCompileUnit(DWARFCompileUnit &dwarf_cu, const DWARFDebugInfoEntry &cu_die) 1729 { 1730 const char *dwo_name = cu_die.GetAttributeValueAsString(this, &dwarf_cu, DW_AT_GNU_dwo_name, nullptr); 1731 if (!dwo_name) 1732 return nullptr; 1733 1734 FileSpec dwo_file(dwo_name, true); 1735 if (dwo_file.IsRelative()) 1736 { 1737 const char *comp_dir = cu_die.GetAttributeValueAsString(this, &dwarf_cu, DW_AT_comp_dir, nullptr); 1738 if (!comp_dir) 1739 return nullptr; 1740 1741 dwo_file.SetFile(comp_dir, true); 1742 dwo_file.AppendPathComponent(dwo_name); 1743 } 1744 1745 if (!dwo_file.Exists()) 1746 return nullptr; 1747 1748 const lldb::offset_t file_offset = 0; 1749 DataBufferSP dwo_file_data_sp; 1750 lldb::offset_t dwo_file_data_offset = 0; 1751 ObjectFileSP dwo_obj_file = ObjectFile::FindPlugin(GetObjectFile()->GetModule(), &dwo_file, file_offset, 1752 dwo_file.GetByteSize(), dwo_file_data_sp, dwo_file_data_offset); 1753 if (dwo_obj_file == nullptr) 1754 return nullptr; 1755 1756 return llvm::make_unique<SymbolFileDWARFDwo>(dwo_obj_file, &dwarf_cu); 1757 } 1758 1759 void 1760 SymbolFileDWARF::UpdateExternalModuleListIfNeeded() 1761 { 1762 if (m_fetched_external_modules) 1763 return; 1764 m_fetched_external_modules = true; 1765 1766 DWARFDebugInfo * debug_info = DebugInfo(); 1767 1768 const uint32_t num_compile_units = GetNumCompileUnits(); 1769 for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) 1770 { 1771 DWARFCompileUnit* dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx); 1772 1773 const DWARFDIE die = dwarf_cu->GetCompileUnitDIEOnly(); 1774 if (die && die.HasChildren() == false) 1775 { 1776 const char *name = die.GetAttributeValueAsString(DW_AT_name, nullptr); 1777 1778 if (name) 1779 { 1780 ConstString const_name(name); 1781 if (m_external_type_modules.find(const_name) == m_external_type_modules.end()) 1782 { 1783 ModuleSP module_sp; 1784 const char *dwo_path = die.GetAttributeValueAsString(DW_AT_GNU_dwo_name, nullptr); 1785 if (dwo_path) 1786 { 1787 ModuleSpec dwo_module_spec; 1788 dwo_module_spec.GetFileSpec().SetFile(dwo_path, false); 1789 dwo_module_spec.GetArchitecture() = m_obj_file->GetModule()->GetArchitecture(); 1790 //printf ("Loading dwo = '%s'\n", dwo_path); 1791 Error error = ModuleList::GetSharedModule (dwo_module_spec, module_sp, NULL, NULL, NULL); 1792 } 1793 m_external_type_modules[const_name] = module_sp; 1794 } 1795 } 1796 } 1797 } 1798 } 1799 1800 SymbolFileDWARF::GlobalVariableMap & 1801 SymbolFileDWARF::GetGlobalAranges() 1802 { 1803 if (!m_global_aranges_ap) 1804 { 1805 m_global_aranges_ap.reset (new GlobalVariableMap()); 1806 1807 ModuleSP module_sp = GetObjectFile()->GetModule(); 1808 if (module_sp) 1809 { 1810 const size_t num_cus = module_sp->GetNumCompileUnits(); 1811 for (size_t i = 0; i < num_cus; ++i) 1812 { 1813 CompUnitSP cu_sp = module_sp->GetCompileUnitAtIndex(i); 1814 if (cu_sp) 1815 { 1816 VariableListSP globals_sp = cu_sp->GetVariableList(true); 1817 if (globals_sp) 1818 { 1819 const size_t num_globals = globals_sp->GetSize(); 1820 for (size_t g = 0; g < num_globals; ++g) 1821 { 1822 VariableSP var_sp = globals_sp->GetVariableAtIndex(g); 1823 if (var_sp && !var_sp->GetLocationIsConstantValueData()) 1824 { 1825 const DWARFExpression &location = var_sp->LocationExpression(); 1826 Value location_result; 1827 Error error; 1828 if (location.Evaluate(nullptr, nullptr, nullptr, LLDB_INVALID_ADDRESS, nullptr, nullptr, location_result, &error)) 1829 { 1830 if (location_result.GetValueType() == Value::eValueTypeFileAddress) 1831 { 1832 lldb::addr_t file_addr = location_result.GetScalar().ULongLong(); 1833 lldb::addr_t byte_size = 1; 1834 if (var_sp->GetType()) 1835 byte_size = var_sp->GetType()->GetByteSize(); 1836 m_global_aranges_ap->Append(GlobalVariableMap::Entry(file_addr, byte_size, var_sp.get())); 1837 } 1838 } 1839 } 1840 } 1841 } 1842 } 1843 } 1844 } 1845 m_global_aranges_ap->Sort(); 1846 } 1847 return *m_global_aranges_ap; 1848 } 1849 1850 1851 uint32_t 1852 SymbolFileDWARF::ResolveSymbolContext (const Address& so_addr, uint32_t resolve_scope, SymbolContext& sc) 1853 { 1854 Timer scoped_timer(__PRETTY_FUNCTION__, 1855 "SymbolFileDWARF::ResolveSymbolContext (so_addr = { section = %p, offset = 0x%" PRIx64 " }, resolve_scope = 0x%8.8x)", 1856 static_cast<void*>(so_addr.GetSection().get()), 1857 so_addr.GetOffset(), resolve_scope); 1858 uint32_t resolved = 0; 1859 if (resolve_scope & ( eSymbolContextCompUnit | 1860 eSymbolContextFunction | 1861 eSymbolContextBlock | 1862 eSymbolContextLineEntry | 1863 eSymbolContextVariable )) 1864 { 1865 lldb::addr_t file_vm_addr = so_addr.GetFileAddress(); 1866 1867 DWARFDebugInfo* debug_info = DebugInfo(); 1868 if (debug_info) 1869 { 1870 const dw_offset_t cu_offset = debug_info->GetCompileUnitAranges().FindAddress(file_vm_addr); 1871 if (cu_offset == DW_INVALID_OFFSET) 1872 { 1873 // Global variables are not in the compile unit address ranges. The only way to 1874 // currently find global variables is to iterate over the .debug_pubnames or the 1875 // __apple_names table and find all items in there that point to DW_TAG_variable 1876 // DIEs and then find the address that matches. 1877 if (resolve_scope & eSymbolContextVariable) 1878 { 1879 GlobalVariableMap &map = GetGlobalAranges(); 1880 const GlobalVariableMap::Entry *entry = map.FindEntryThatContains(file_vm_addr); 1881 if (entry && entry->data) 1882 { 1883 Variable *variable = entry->data; 1884 SymbolContextScope *scc = variable->GetSymbolContextScope(); 1885 if (scc) 1886 { 1887 scc->CalculateSymbolContext(&sc); 1888 sc.variable = variable; 1889 } 1890 return sc.GetResolvedMask(); 1891 } 1892 } 1893 } 1894 else 1895 { 1896 uint32_t cu_idx = DW_INVALID_INDEX; 1897 DWARFCompileUnit* dwarf_cu = debug_info->GetCompileUnit(cu_offset, &cu_idx); 1898 if (dwarf_cu) 1899 { 1900 sc.comp_unit = GetCompUnitForDWARFCompUnit(dwarf_cu, cu_idx); 1901 if (sc.comp_unit) 1902 { 1903 resolved |= eSymbolContextCompUnit; 1904 1905 bool force_check_line_table = false; 1906 if (resolve_scope & (eSymbolContextFunction | eSymbolContextBlock)) 1907 { 1908 DWARFDIE function_die = dwarf_cu->LookupAddress(file_vm_addr); 1909 DWARFDIE block_die; 1910 if (function_die) 1911 { 1912 sc.function = sc.comp_unit->FindFunctionByUID (function_die.GetID()).get(); 1913 if (sc.function == NULL) 1914 sc.function = ParseCompileUnitFunction(sc, function_die); 1915 1916 if (sc.function && (resolve_scope & eSymbolContextBlock)) 1917 block_die = function_die.LookupDeepestBlock(file_vm_addr); 1918 } 1919 else 1920 { 1921 // We might have had a compile unit that had discontiguous 1922 // address ranges where the gaps are symbols that don't have 1923 // any debug info. Discontiguous compile unit address ranges 1924 // should only happen when there aren't other functions from 1925 // other compile units in these gaps. This helps keep the size 1926 // of the aranges down. 1927 force_check_line_table = true; 1928 } 1929 1930 if (sc.function != NULL) 1931 { 1932 resolved |= eSymbolContextFunction; 1933 1934 if (resolve_scope & eSymbolContextBlock) 1935 { 1936 Block& block = sc.function->GetBlock (true); 1937 1938 if (block_die) 1939 sc.block = block.FindBlockByID (block_die.GetID()); 1940 else 1941 sc.block = block.FindBlockByID (function_die.GetID()); 1942 if (sc.block) 1943 resolved |= eSymbolContextBlock; 1944 } 1945 } 1946 } 1947 1948 if ((resolve_scope & eSymbolContextLineEntry) || force_check_line_table) 1949 { 1950 LineTable *line_table = sc.comp_unit->GetLineTable(); 1951 if (line_table != NULL) 1952 { 1953 // And address that makes it into this function should be in terms 1954 // of this debug file if there is no debug map, or it will be an 1955 // address in the .o file which needs to be fixed up to be in terms 1956 // of the debug map executable. Either way, calling FixupAddress() 1957 // will work for us. 1958 Address exe_so_addr (so_addr); 1959 if (FixupAddress(exe_so_addr)) 1960 { 1961 if (line_table->FindLineEntryByAddress (exe_so_addr, sc.line_entry)) 1962 { 1963 resolved |= eSymbolContextLineEntry; 1964 } 1965 } 1966 } 1967 } 1968 1969 if (force_check_line_table && !(resolved & eSymbolContextLineEntry)) 1970 { 1971 // We might have had a compile unit that had discontiguous 1972 // address ranges where the gaps are symbols that don't have 1973 // any debug info. Discontiguous compile unit address ranges 1974 // should only happen when there aren't other functions from 1975 // other compile units in these gaps. This helps keep the size 1976 // of the aranges down. 1977 sc.comp_unit = NULL; 1978 resolved &= ~eSymbolContextCompUnit; 1979 } 1980 } 1981 else 1982 { 1983 GetObjectFile()->GetModule()->ReportWarning ("0x%8.8x: compile unit %u failed to create a valid lldb_private::CompileUnit class.", 1984 cu_offset, 1985 cu_idx); 1986 } 1987 } 1988 } 1989 } 1990 } 1991 return resolved; 1992 } 1993 1994 1995 1996 uint32_t 1997 SymbolFileDWARF::ResolveSymbolContext(const FileSpec& file_spec, uint32_t line, bool check_inlines, uint32_t resolve_scope, SymbolContextList& sc_list) 1998 { 1999 const uint32_t prev_size = sc_list.GetSize(); 2000 if (resolve_scope & eSymbolContextCompUnit) 2001 { 2002 DWARFDebugInfo* debug_info = DebugInfo(); 2003 if (debug_info) 2004 { 2005 uint32_t cu_idx; 2006 DWARFCompileUnit* dwarf_cu = NULL; 2007 2008 for (cu_idx = 0; (dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx)) != NULL; ++cu_idx) 2009 { 2010 CompileUnit *dc_cu = GetCompUnitForDWARFCompUnit(dwarf_cu, cu_idx); 2011 const bool full_match = (bool)file_spec.GetDirectory(); 2012 bool file_spec_matches_cu_file_spec = dc_cu != NULL && FileSpec::Equal(file_spec, *dc_cu, full_match); 2013 if (check_inlines || file_spec_matches_cu_file_spec) 2014 { 2015 SymbolContext sc (m_obj_file->GetModule()); 2016 sc.comp_unit = GetCompUnitForDWARFCompUnit(dwarf_cu, cu_idx); 2017 if (sc.comp_unit) 2018 { 2019 uint32_t file_idx = UINT32_MAX; 2020 2021 // If we are looking for inline functions only and we don't 2022 // find it in the support files, we are done. 2023 if (check_inlines) 2024 { 2025 file_idx = sc.comp_unit->GetSupportFiles().FindFileIndex (1, file_spec, true); 2026 if (file_idx == UINT32_MAX) 2027 continue; 2028 } 2029 2030 if (line != 0) 2031 { 2032 LineTable *line_table = sc.comp_unit->GetLineTable(); 2033 2034 if (line_table != NULL && line != 0) 2035 { 2036 // We will have already looked up the file index if 2037 // we are searching for inline entries. 2038 if (!check_inlines) 2039 file_idx = sc.comp_unit->GetSupportFiles().FindFileIndex (1, file_spec, true); 2040 2041 if (file_idx != UINT32_MAX) 2042 { 2043 uint32_t found_line; 2044 uint32_t line_idx = line_table->FindLineEntryIndexByFileIndex (0, file_idx, line, false, &sc.line_entry); 2045 found_line = sc.line_entry.line; 2046 2047 while (line_idx != UINT32_MAX) 2048 { 2049 sc.function = NULL; 2050 sc.block = NULL; 2051 if (resolve_scope & (eSymbolContextFunction | eSymbolContextBlock)) 2052 { 2053 const lldb::addr_t file_vm_addr = sc.line_entry.range.GetBaseAddress().GetFileAddress(); 2054 if (file_vm_addr != LLDB_INVALID_ADDRESS) 2055 { 2056 DWARFDIE function_die = dwarf_cu->LookupAddress(file_vm_addr); 2057 DWARFDIE block_die; 2058 if (function_die) 2059 { 2060 sc.function = sc.comp_unit->FindFunctionByUID (function_die.GetID()).get(); 2061 if (sc.function == NULL) 2062 sc.function = ParseCompileUnitFunction(sc, function_die); 2063 2064 if (sc.function && (resolve_scope & eSymbolContextBlock)) 2065 block_die = function_die.LookupDeepestBlock(file_vm_addr); 2066 } 2067 2068 if (sc.function != NULL) 2069 { 2070 Block& block = sc.function->GetBlock (true); 2071 2072 if (block_die) 2073 sc.block = block.FindBlockByID (block_die.GetID()); 2074 else if (function_die) 2075 sc.block = block.FindBlockByID (function_die.GetID()); 2076 } 2077 } 2078 } 2079 2080 sc_list.Append(sc); 2081 line_idx = line_table->FindLineEntryIndexByFileIndex (line_idx + 1, file_idx, found_line, true, &sc.line_entry); 2082 } 2083 } 2084 } 2085 else if (file_spec_matches_cu_file_spec && !check_inlines) 2086 { 2087 // only append the context if we aren't looking for inline call sites 2088 // by file and line and if the file spec matches that of the compile unit 2089 sc_list.Append(sc); 2090 } 2091 } 2092 else if (file_spec_matches_cu_file_spec && !check_inlines) 2093 { 2094 // only append the context if we aren't looking for inline call sites 2095 // by file and line and if the file spec matches that of the compile unit 2096 sc_list.Append(sc); 2097 } 2098 2099 if (!check_inlines) 2100 break; 2101 } 2102 } 2103 } 2104 } 2105 } 2106 return sc_list.GetSize() - prev_size; 2107 } 2108 2109 void 2110 SymbolFileDWARF::Index () 2111 { 2112 if (m_indexed) 2113 return; 2114 m_indexed = true; 2115 Timer scoped_timer (__PRETTY_FUNCTION__, 2116 "SymbolFileDWARF::Index (%s)", 2117 GetObjectFile()->GetFileSpec().GetFilename().AsCString("<Unknown>")); 2118 2119 DWARFDebugInfo* debug_info = DebugInfo(); 2120 if (debug_info) 2121 { 2122 const uint32_t num_compile_units = GetNumCompileUnits(); 2123 std::vector<NameToDIE> function_basename_index(num_compile_units); 2124 std::vector<NameToDIE> function_fullname_index(num_compile_units); 2125 std::vector<NameToDIE> function_method_index(num_compile_units); 2126 std::vector<NameToDIE> function_selector_index(num_compile_units); 2127 std::vector<NameToDIE> objc_class_selectors_index(num_compile_units); 2128 std::vector<NameToDIE> global_index(num_compile_units); 2129 std::vector<NameToDIE> type_index(num_compile_units); 2130 std::vector<NameToDIE> namespace_index(num_compile_units); 2131 2132 auto parser_fn = [this, 2133 debug_info, 2134 &function_basename_index, 2135 &function_fullname_index, 2136 &function_method_index, 2137 &function_selector_index, 2138 &objc_class_selectors_index, 2139 &global_index, 2140 &type_index, 2141 &namespace_index](uint32_t cu_idx) 2142 { 2143 DWARFCompileUnit* dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx); 2144 bool clear_dies = dwarf_cu->ExtractDIEsIfNeeded(false) > 1; 2145 2146 dwarf_cu->Index(function_basename_index[cu_idx], 2147 function_fullname_index[cu_idx], 2148 function_method_index[cu_idx], 2149 function_selector_index[cu_idx], 2150 objc_class_selectors_index[cu_idx], 2151 global_index[cu_idx], 2152 type_index[cu_idx], 2153 namespace_index[cu_idx]); 2154 2155 // Keep memory down by clearing DIEs if this generate function 2156 // caused them to be parsed 2157 if (clear_dies) 2158 dwarf_cu->ClearDIEs(true); 2159 2160 return cu_idx; 2161 }; 2162 2163 TaskRunner<uint32_t> task_runner; 2164 for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) 2165 task_runner.AddTask(parser_fn, cu_idx); 2166 2167 while (true) 2168 { 2169 std::future<uint32_t> f = task_runner.WaitForNextCompletedTask(); 2170 if (!f.valid()) 2171 break; 2172 uint32_t cu_idx = f.get(); 2173 2174 m_function_basename_index.Append(function_basename_index[cu_idx]); 2175 m_function_fullname_index.Append(function_fullname_index[cu_idx]); 2176 m_function_method_index.Append(function_method_index[cu_idx]); 2177 m_function_selector_index.Append(function_selector_index[cu_idx]); 2178 m_objc_class_selectors_index.Append(objc_class_selectors_index[cu_idx]); 2179 m_global_index.Append(global_index[cu_idx]); 2180 m_type_index.Append(type_index[cu_idx]); 2181 m_namespace_index.Append(namespace_index[cu_idx]); 2182 } 2183 2184 TaskPool::RunTasks( 2185 [&]() { m_function_basename_index.Finalize(); }, 2186 [&]() { m_function_fullname_index.Finalize(); }, 2187 [&]() { m_function_method_index.Finalize(); }, 2188 [&]() { m_function_selector_index.Finalize(); }, 2189 [&]() { m_objc_class_selectors_index.Finalize(); }, 2190 [&]() { m_global_index.Finalize(); }, 2191 [&]() { m_type_index.Finalize(); }, 2192 [&]() { m_namespace_index.Finalize(); }); 2193 2194 #if defined (ENABLE_DEBUG_PRINTF) 2195 StreamFile s(stdout, false); 2196 s.Printf ("DWARF index for '%s':", 2197 GetObjectFile()->GetFileSpec().GetPath().c_str()); 2198 s.Printf("\nFunction basenames:\n"); m_function_basename_index.Dump (&s); 2199 s.Printf("\nFunction fullnames:\n"); m_function_fullname_index.Dump (&s); 2200 s.Printf("\nFunction methods:\n"); m_function_method_index.Dump (&s); 2201 s.Printf("\nFunction selectors:\n"); m_function_selector_index.Dump (&s); 2202 s.Printf("\nObjective C class selectors:\n"); m_objc_class_selectors_index.Dump (&s); 2203 s.Printf("\nGlobals and statics:\n"); m_global_index.Dump (&s); 2204 s.Printf("\nTypes:\n"); m_type_index.Dump (&s); 2205 s.Printf("\nNamespaces:\n") m_namespace_index.Dump (&s); 2206 #endif 2207 } 2208 } 2209 2210 bool 2211 SymbolFileDWARF::DeclContextMatchesThisSymbolFile (const lldb_private::CompilerDeclContext *decl_ctx) 2212 { 2213 if (decl_ctx == nullptr || !decl_ctx->IsValid()) 2214 { 2215 // Invalid namespace decl which means we aren't matching only things 2216 // in this symbol file, so return true to indicate it matches this 2217 // symbol file. 2218 return true; 2219 } 2220 2221 TypeSystem *decl_ctx_type_system = decl_ctx->GetTypeSystem(); 2222 TypeSystem *type_system = GetTypeSystemForLanguage(decl_ctx_type_system->GetMinimumLanguage(nullptr)); 2223 if (decl_ctx_type_system == type_system) 2224 return true; // The type systems match, return true 2225 2226 // The namespace AST was valid, and it does not match... 2227 Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS)); 2228 2229 if (log) 2230 GetObjectFile()->GetModule()->LogMessage(log, "Valid namespace does not match symbol file"); 2231 2232 return false; 2233 } 2234 2235 uint32_t 2236 SymbolFileDWARF::FindGlobalVariables (const ConstString &name, const CompilerDeclContext *parent_decl_ctx, bool append, uint32_t max_matches, VariableList& variables) 2237 { 2238 Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS)); 2239 2240 if (log) 2241 GetObjectFile()->GetModule()->LogMessage (log, 2242 "SymbolFileDWARF::FindGlobalVariables (name=\"%s\", parent_decl_ctx=%p, append=%u, max_matches=%u, variables)", 2243 name.GetCString(), 2244 static_cast<const void*>(parent_decl_ctx), 2245 append, max_matches); 2246 2247 if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx)) 2248 return 0; 2249 2250 DWARFDebugInfo* info = DebugInfo(); 2251 if (info == NULL) 2252 return 0; 2253 2254 // If we aren't appending the results to this list, then clear the list 2255 if (!append) 2256 variables.Clear(); 2257 2258 // Remember how many variables are in the list before we search in case 2259 // we are appending the results to a variable list. 2260 const uint32_t original_size = variables.GetSize(); 2261 2262 DIEArray die_offsets; 2263 2264 if (m_using_apple_tables) 2265 { 2266 if (m_apple_names_ap.get()) 2267 { 2268 const char *name_cstr = name.GetCString(); 2269 llvm::StringRef basename; 2270 llvm::StringRef context; 2271 2272 if (!CPlusPlusLanguage::ExtractContextAndIdentifier(name_cstr, context, basename)) 2273 basename = name_cstr; 2274 2275 m_apple_names_ap->FindByName (basename.data(), die_offsets); 2276 } 2277 } 2278 else 2279 { 2280 // Index the DWARF if we haven't already 2281 if (!m_indexed) 2282 Index (); 2283 2284 m_global_index.Find (name, die_offsets); 2285 } 2286 2287 const size_t num_die_matches = die_offsets.size(); 2288 if (num_die_matches) 2289 { 2290 SymbolContext sc; 2291 sc.module_sp = m_obj_file->GetModule(); 2292 assert (sc.module_sp); 2293 2294 bool done = false; 2295 for (size_t i=0; i<num_die_matches && !done; ++i) 2296 { 2297 const DIERef& die_ref = die_offsets[i]; 2298 DWARFDIE die = GetDIE (die_ref); 2299 2300 if (die) 2301 { 2302 switch (die.Tag()) 2303 { 2304 default: 2305 case DW_TAG_subprogram: 2306 case DW_TAG_inlined_subroutine: 2307 case DW_TAG_try_block: 2308 case DW_TAG_catch_block: 2309 break; 2310 2311 case DW_TAG_variable: 2312 { 2313 sc.comp_unit = GetCompUnitForDWARFCompUnit(die.GetCU(), UINT32_MAX); 2314 2315 if (parent_decl_ctx) 2316 { 2317 DWARFASTParser *dwarf_ast = die.GetDWARFParser(); 2318 if (dwarf_ast) 2319 { 2320 CompilerDeclContext actual_parent_decl_ctx = dwarf_ast->GetDeclContextContainingUIDFromDWARF (die); 2321 if (!actual_parent_decl_ctx || actual_parent_decl_ctx != *parent_decl_ctx) 2322 continue; 2323 } 2324 } 2325 2326 ParseVariables(sc, die, LLDB_INVALID_ADDRESS, false, false, &variables); 2327 2328 if (variables.GetSize() - original_size >= max_matches) 2329 done = true; 2330 } 2331 break; 2332 } 2333 } 2334 else 2335 { 2336 if (m_using_apple_tables) 2337 { 2338 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_names accelerator table had bad die 0x%8.8x for '%s')\n", 2339 die_ref.die_offset, name.GetCString()); 2340 } 2341 } 2342 } 2343 } 2344 2345 // Return the number of variable that were appended to the list 2346 const uint32_t num_matches = variables.GetSize() - original_size; 2347 if (log && num_matches > 0) 2348 { 2349 GetObjectFile()->GetModule()->LogMessage (log, 2350 "SymbolFileDWARF::FindGlobalVariables (name=\"%s\", parent_decl_ctx=%p, append=%u, max_matches=%u, variables) => %u", 2351 name.GetCString(), 2352 static_cast<const void*>(parent_decl_ctx), 2353 append, max_matches, 2354 num_matches); 2355 } 2356 return num_matches; 2357 } 2358 2359 uint32_t 2360 SymbolFileDWARF::FindGlobalVariables(const RegularExpression& regex, bool append, uint32_t max_matches, VariableList& variables) 2361 { 2362 Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS)); 2363 2364 if (log) 2365 { 2366 GetObjectFile()->GetModule()->LogMessage (log, 2367 "SymbolFileDWARF::FindGlobalVariables (regex=\"%s\", append=%u, max_matches=%u, variables)", 2368 regex.GetText(), append, 2369 max_matches); 2370 } 2371 2372 DWARFDebugInfo* info = DebugInfo(); 2373 if (info == NULL) 2374 return 0; 2375 2376 // If we aren't appending the results to this list, then clear the list 2377 if (!append) 2378 variables.Clear(); 2379 2380 // Remember how many variables are in the list before we search in case 2381 // we are appending the results to a variable list. 2382 const uint32_t original_size = variables.GetSize(); 2383 2384 DIEArray die_offsets; 2385 2386 if (m_using_apple_tables) 2387 { 2388 if (m_apple_names_ap.get()) 2389 { 2390 DWARFMappedHash::DIEInfoArray hash_data_array; 2391 if (m_apple_names_ap->AppendAllDIEsThatMatchingRegex (regex, hash_data_array)) 2392 DWARFMappedHash::ExtractDIEArray (hash_data_array, die_offsets); 2393 } 2394 } 2395 else 2396 { 2397 // Index the DWARF if we haven't already 2398 if (!m_indexed) 2399 Index (); 2400 2401 m_global_index.Find (regex, die_offsets); 2402 } 2403 2404 SymbolContext sc; 2405 sc.module_sp = m_obj_file->GetModule(); 2406 assert (sc.module_sp); 2407 2408 const size_t num_matches = die_offsets.size(); 2409 if (num_matches) 2410 { 2411 for (size_t i=0; i<num_matches; ++i) 2412 { 2413 const DIERef& die_ref = die_offsets[i]; 2414 DWARFDIE die = GetDIE (die_ref); 2415 2416 if (die) 2417 { 2418 sc.comp_unit = GetCompUnitForDWARFCompUnit(die.GetCU(), UINT32_MAX); 2419 2420 ParseVariables(sc, die, LLDB_INVALID_ADDRESS, false, false, &variables); 2421 2422 if (variables.GetSize() - original_size >= max_matches) 2423 break; 2424 } 2425 else 2426 { 2427 if (m_using_apple_tables) 2428 { 2429 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_names accelerator table had bad die 0x%8.8x for regex '%s')\n", 2430 die_ref.die_offset, regex.GetText()); 2431 } 2432 } 2433 } 2434 } 2435 2436 // Return the number of variable that were appended to the list 2437 return variables.GetSize() - original_size; 2438 } 2439 2440 2441 bool 2442 SymbolFileDWARF::ResolveFunction (const DIERef& die_ref, 2443 bool include_inlines, 2444 SymbolContextList& sc_list) 2445 { 2446 DWARFDIE die = DebugInfo()->GetDIE (die_ref); 2447 return ResolveFunction (die, include_inlines, sc_list); 2448 } 2449 2450 2451 bool 2452 SymbolFileDWARF::ResolveFunction (const DWARFDIE &orig_die, 2453 bool include_inlines, 2454 SymbolContextList& sc_list) 2455 { 2456 SymbolContext sc; 2457 2458 if (!orig_die) 2459 return false; 2460 2461 // If we were passed a die that is not a function, just return false... 2462 if (!(orig_die.Tag() == DW_TAG_subprogram || (include_inlines && orig_die.Tag() == DW_TAG_inlined_subroutine))) 2463 return false; 2464 2465 DWARFDIE die = orig_die; 2466 DWARFDIE inlined_die; 2467 if (die.Tag() == DW_TAG_inlined_subroutine) 2468 { 2469 inlined_die = die; 2470 2471 while (1) 2472 { 2473 die = die.GetParent(); 2474 2475 if (die) 2476 { 2477 if (die.Tag() == DW_TAG_subprogram) 2478 break; 2479 } 2480 else 2481 break; 2482 } 2483 } 2484 assert (die && die.Tag() == DW_TAG_subprogram); 2485 if (GetFunction (die, sc)) 2486 { 2487 Address addr; 2488 // Parse all blocks if needed 2489 if (inlined_die) 2490 { 2491 Block &function_block = sc.function->GetBlock (true); 2492 sc.block = function_block.FindBlockByID (inlined_die.GetID()); 2493 if (sc.block == NULL) 2494 sc.block = function_block.FindBlockByID (inlined_die.GetOffset()); 2495 if (sc.block == NULL || sc.block->GetStartAddress (addr) == false) 2496 addr.Clear(); 2497 } 2498 else 2499 { 2500 sc.block = NULL; 2501 addr = sc.function->GetAddressRange().GetBaseAddress(); 2502 } 2503 2504 if (addr.IsValid()) 2505 { 2506 sc_list.Append(sc); 2507 return true; 2508 } 2509 } 2510 2511 return false; 2512 } 2513 2514 void 2515 SymbolFileDWARF::FindFunctions (const ConstString &name, 2516 const NameToDIE &name_to_die, 2517 bool include_inlines, 2518 SymbolContextList& sc_list) 2519 { 2520 DIEArray die_offsets; 2521 if (name_to_die.Find (name, die_offsets)) 2522 { 2523 ParseFunctions (die_offsets, include_inlines, sc_list); 2524 } 2525 } 2526 2527 2528 void 2529 SymbolFileDWARF::FindFunctions (const RegularExpression ®ex, 2530 const NameToDIE &name_to_die, 2531 bool include_inlines, 2532 SymbolContextList& sc_list) 2533 { 2534 DIEArray die_offsets; 2535 if (name_to_die.Find (regex, die_offsets)) 2536 { 2537 ParseFunctions (die_offsets, include_inlines, sc_list); 2538 } 2539 } 2540 2541 2542 void 2543 SymbolFileDWARF::FindFunctions (const RegularExpression ®ex, 2544 const DWARFMappedHash::MemoryTable &memory_table, 2545 bool include_inlines, 2546 SymbolContextList& sc_list) 2547 { 2548 DIEArray die_offsets; 2549 DWARFMappedHash::DIEInfoArray hash_data_array; 2550 if (memory_table.AppendAllDIEsThatMatchingRegex (regex, hash_data_array)) 2551 { 2552 DWARFMappedHash::ExtractDIEArray (hash_data_array, die_offsets); 2553 ParseFunctions (die_offsets, include_inlines, sc_list); 2554 } 2555 } 2556 2557 void 2558 SymbolFileDWARF::ParseFunctions (const DIEArray &die_offsets, 2559 bool include_inlines, 2560 SymbolContextList& sc_list) 2561 { 2562 const size_t num_matches = die_offsets.size(); 2563 if (num_matches) 2564 { 2565 for (size_t i=0; i<num_matches; ++i) 2566 ResolveFunction (die_offsets[i], include_inlines, sc_list); 2567 } 2568 } 2569 2570 bool 2571 SymbolFileDWARF::DIEInDeclContext (const CompilerDeclContext *decl_ctx, 2572 const DWARFDIE &die) 2573 { 2574 // If we have no parent decl context to match this DIE matches, and if the parent 2575 // decl context isn't valid, we aren't trying to look for any particular decl 2576 // context so any die matches. 2577 if (decl_ctx == nullptr || !decl_ctx->IsValid()) 2578 return true; 2579 2580 if (die) 2581 { 2582 DWARFASTParser *dwarf_ast = die.GetDWARFParser(); 2583 if (dwarf_ast) 2584 { 2585 CompilerDeclContext actual_decl_ctx = dwarf_ast->GetDeclContextContainingUIDFromDWARF (die); 2586 if (actual_decl_ctx) 2587 return actual_decl_ctx == *decl_ctx; 2588 } 2589 } 2590 return false; 2591 } 2592 2593 uint32_t 2594 SymbolFileDWARF::FindFunctions (const ConstString &name, 2595 const CompilerDeclContext *parent_decl_ctx, 2596 uint32_t name_type_mask, 2597 bool include_inlines, 2598 bool append, 2599 SymbolContextList& sc_list) 2600 { 2601 Timer scoped_timer (__PRETTY_FUNCTION__, 2602 "SymbolFileDWARF::FindFunctions (name = '%s')", 2603 name.AsCString()); 2604 2605 // eFunctionNameTypeAuto should be pre-resolved by a call to Module::PrepareForFunctionNameLookup() 2606 assert ((name_type_mask & eFunctionNameTypeAuto) == 0); 2607 2608 Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS)); 2609 2610 if (log) 2611 { 2612 GetObjectFile()->GetModule()->LogMessage (log, 2613 "SymbolFileDWARF::FindFunctions (name=\"%s\", name_type_mask=0x%x, append=%u, sc_list)", 2614 name.GetCString(), 2615 name_type_mask, 2616 append); 2617 } 2618 2619 // If we aren't appending the results to this list, then clear the list 2620 if (!append) 2621 sc_list.Clear(); 2622 2623 if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx)) 2624 return 0; 2625 2626 // If name is empty then we won't find anything. 2627 if (name.IsEmpty()) 2628 return 0; 2629 2630 // Remember how many sc_list are in the list before we search in case 2631 // we are appending the results to a variable list. 2632 2633 const char *name_cstr = name.GetCString(); 2634 2635 const uint32_t original_size = sc_list.GetSize(); 2636 2637 DWARFDebugInfo* info = DebugInfo(); 2638 if (info == NULL) 2639 return 0; 2640 2641 std::set<const DWARFDebugInfoEntry *> resolved_dies; 2642 if (m_using_apple_tables) 2643 { 2644 if (m_apple_names_ap.get()) 2645 { 2646 2647 DIEArray die_offsets; 2648 2649 uint32_t num_matches = 0; 2650 2651 if (name_type_mask & eFunctionNameTypeFull) 2652 { 2653 // If they asked for the full name, match what they typed. At some point we may 2654 // want to canonicalize this (strip double spaces, etc. For now, we just add all the 2655 // dies that we find by exact match. 2656 num_matches = m_apple_names_ap->FindByName (name_cstr, die_offsets); 2657 for (uint32_t i = 0; i < num_matches; i++) 2658 { 2659 const DIERef& die_ref = die_offsets[i]; 2660 DWARFDIE die = info->GetDIE (die_ref); 2661 if (die) 2662 { 2663 if (!DIEInDeclContext(parent_decl_ctx, die)) 2664 continue; // The containing decl contexts don't match 2665 2666 if (resolved_dies.find(die.GetDIE()) == resolved_dies.end()) 2667 { 2668 if (ResolveFunction (die, include_inlines, sc_list)) 2669 resolved_dies.insert(die.GetDIE()); 2670 } 2671 } 2672 else 2673 { 2674 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_names accelerator table had bad die 0x%8.8x for '%s')", 2675 die_ref.die_offset, name_cstr); 2676 } 2677 } 2678 } 2679 2680 if (name_type_mask & eFunctionNameTypeSelector) 2681 { 2682 if (parent_decl_ctx && parent_decl_ctx->IsValid()) 2683 return 0; // no selectors in namespaces 2684 2685 num_matches = m_apple_names_ap->FindByName (name_cstr, die_offsets); 2686 // Now make sure these are actually ObjC methods. In this case we can simply look up the name, 2687 // and if it is an ObjC method name, we're good. 2688 2689 for (uint32_t i = 0; i < num_matches; i++) 2690 { 2691 const DIERef& die_ref = die_offsets[i]; 2692 DWARFDIE die = info->GetDIE (die_ref); 2693 if (die) 2694 { 2695 const char *die_name = die.GetName(); 2696 if (ObjCLanguage::IsPossibleObjCMethodName(die_name)) 2697 { 2698 if (resolved_dies.find(die.GetDIE()) == resolved_dies.end()) 2699 { 2700 if (ResolveFunction (die, include_inlines, sc_list)) 2701 resolved_dies.insert(die.GetDIE()); 2702 } 2703 } 2704 } 2705 else 2706 { 2707 GetObjectFile()->GetModule()->ReportError ("the DWARF debug information has been modified (.apple_names accelerator table had bad die 0x%8.8x for '%s')", 2708 die_ref.die_offset, name_cstr); 2709 } 2710 } 2711 die_offsets.clear(); 2712 } 2713 2714 if (((name_type_mask & eFunctionNameTypeMethod) && !parent_decl_ctx) || name_type_mask & eFunctionNameTypeBase) 2715 { 2716 // The apple_names table stores just the "base name" of C++ methods in the table. So we have to 2717 // extract the base name, look that up, and if there is any other information in the name we were 2718 // passed in we have to post-filter based on that. 2719 2720 // FIXME: Arrange the logic above so that we don't calculate the base name twice: 2721 num_matches = m_apple_names_ap->FindByName (name_cstr, die_offsets); 2722 2723 for (uint32_t i = 0; i < num_matches; i++) 2724 { 2725 const DIERef& die_ref = die_offsets[i]; 2726 DWARFDIE die = info->GetDIE (die_ref); 2727 if (die) 2728 { 2729 if (!DIEInDeclContext(parent_decl_ctx, die)) 2730 continue; // The containing decl contexts don't match 2731 2732 2733 // If we get to here, the die is good, and we should add it: 2734 if (resolved_dies.find(die.GetDIE()) == resolved_dies.end() && ResolveFunction (die, include_inlines, sc_list)) 2735 { 2736 bool keep_die = true; 2737 if ((name_type_mask & (eFunctionNameTypeBase|eFunctionNameTypeMethod)) != (eFunctionNameTypeBase|eFunctionNameTypeMethod)) 2738 { 2739 // We are looking for either basenames or methods, so we need to 2740 // trim out the ones we won't want by looking at the type 2741 SymbolContext sc; 2742 if (sc_list.GetLastContext(sc)) 2743 { 2744 if (sc.block) 2745 { 2746 // We have an inlined function 2747 } 2748 else if (sc.function) 2749 { 2750 Type *type = sc.function->GetType(); 2751 2752 if (type) 2753 { 2754 CompilerDeclContext decl_ctx = GetDeclContextContainingUID (type->GetID()); 2755 if (decl_ctx.IsStructUnionOrClass()) 2756 { 2757 if (name_type_mask & eFunctionNameTypeBase) 2758 { 2759 sc_list.RemoveContextAtIndex(sc_list.GetSize()-1); 2760 keep_die = false; 2761 } 2762 } 2763 else 2764 { 2765 if (name_type_mask & eFunctionNameTypeMethod) 2766 { 2767 sc_list.RemoveContextAtIndex(sc_list.GetSize()-1); 2768 keep_die = false; 2769 } 2770 } 2771 } 2772 else 2773 { 2774 GetObjectFile()->GetModule()->ReportWarning ("function at die offset 0x%8.8x had no function type", 2775 die_ref.die_offset); 2776 } 2777 } 2778 } 2779 } 2780 if (keep_die) 2781 resolved_dies.insert(die.GetDIE()); 2782 } 2783 } 2784 else 2785 { 2786 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_names accelerator table had bad die 0x%8.8x for '%s')", 2787 die_ref.die_offset, name_cstr); 2788 } 2789 } 2790 die_offsets.clear(); 2791 } 2792 } 2793 } 2794 else 2795 { 2796 2797 // Index the DWARF if we haven't already 2798 if (!m_indexed) 2799 Index (); 2800 2801 if (name_type_mask & eFunctionNameTypeFull) 2802 { 2803 FindFunctions (name, m_function_fullname_index, include_inlines, sc_list); 2804 2805 // FIXME Temporary workaround for global/anonymous namespace 2806 // functions debugging FreeBSD and Linux binaries. 2807 // If we didn't find any functions in the global namespace try 2808 // looking in the basename index but ignore any returned 2809 // functions that have a namespace but keep functions which 2810 // have an anonymous namespace 2811 // TODO: The arch in the object file isn't correct for MSVC 2812 // binaries on windows, we should find a way to make it 2813 // correct and handle those symbols as well. 2814 if (sc_list.GetSize() == original_size) 2815 { 2816 ArchSpec arch; 2817 if (!parent_decl_ctx && 2818 GetObjectFile()->GetArchitecture(arch) && 2819 (arch.GetTriple().isOSFreeBSD() || arch.GetTriple().isOSLinux() || 2820 arch.GetMachine() == llvm::Triple::hexagon)) 2821 { 2822 SymbolContextList temp_sc_list; 2823 FindFunctions (name, m_function_basename_index, include_inlines, temp_sc_list); 2824 SymbolContext sc; 2825 for (uint32_t i = 0; i < temp_sc_list.GetSize(); i++) 2826 { 2827 if (temp_sc_list.GetContextAtIndex(i, sc)) 2828 { 2829 ConstString mangled_name = sc.GetFunctionName(Mangled::ePreferMangled); 2830 ConstString demangled_name = sc.GetFunctionName(Mangled::ePreferDemangled); 2831 // Mangled names on Linux and FreeBSD are of the form: 2832 // _ZN18function_namespace13function_nameEv. 2833 if (strncmp(mangled_name.GetCString(), "_ZN", 3) || 2834 !strncmp(demangled_name.GetCString(), "(anonymous namespace)", 21)) 2835 { 2836 sc_list.Append(sc); 2837 } 2838 } 2839 } 2840 } 2841 } 2842 } 2843 DIEArray die_offsets; 2844 if (name_type_mask & eFunctionNameTypeBase) 2845 { 2846 uint32_t num_base = m_function_basename_index.Find(name, die_offsets); 2847 for (uint32_t i = 0; i < num_base; i++) 2848 { 2849 DWARFDIE die = info->GetDIE (die_offsets[i]); 2850 if (die) 2851 { 2852 if (!DIEInDeclContext(parent_decl_ctx, die)) 2853 continue; // The containing decl contexts don't match 2854 2855 // If we get to here, the die is good, and we should add it: 2856 if (resolved_dies.find(die.GetDIE()) == resolved_dies.end()) 2857 { 2858 if (ResolveFunction (die, include_inlines, sc_list)) 2859 resolved_dies.insert(die.GetDIE()); 2860 } 2861 } 2862 } 2863 die_offsets.clear(); 2864 } 2865 2866 if (name_type_mask & eFunctionNameTypeMethod) 2867 { 2868 if (parent_decl_ctx && parent_decl_ctx->IsValid()) 2869 return 0; // no methods in namespaces 2870 2871 uint32_t num_base = m_function_method_index.Find(name, die_offsets); 2872 { 2873 for (uint32_t i = 0; i < num_base; i++) 2874 { 2875 DWARFDIE die = info->GetDIE (die_offsets[i]); 2876 if (die) 2877 { 2878 // If we get to here, the die is good, and we should add it: 2879 if (resolved_dies.find(die.GetDIE()) == resolved_dies.end()) 2880 { 2881 if (ResolveFunction (die, include_inlines, sc_list)) 2882 resolved_dies.insert(die.GetDIE()); 2883 } 2884 } 2885 } 2886 } 2887 die_offsets.clear(); 2888 } 2889 2890 if ((name_type_mask & eFunctionNameTypeSelector) && (!parent_decl_ctx || !parent_decl_ctx->IsValid())) 2891 { 2892 FindFunctions (name, m_function_selector_index, include_inlines, sc_list); 2893 } 2894 2895 } 2896 2897 // Return the number of variable that were appended to the list 2898 const uint32_t num_matches = sc_list.GetSize() - original_size; 2899 2900 if (log && num_matches > 0) 2901 { 2902 GetObjectFile()->GetModule()->LogMessage (log, 2903 "SymbolFileDWARF::FindFunctions (name=\"%s\", name_type_mask=0x%x, include_inlines=%d, append=%u, sc_list) => %u", 2904 name.GetCString(), 2905 name_type_mask, 2906 include_inlines, 2907 append, 2908 num_matches); 2909 } 2910 return num_matches; 2911 } 2912 2913 uint32_t 2914 SymbolFileDWARF::FindFunctions(const RegularExpression& regex, bool include_inlines, bool append, SymbolContextList& sc_list) 2915 { 2916 Timer scoped_timer (__PRETTY_FUNCTION__, 2917 "SymbolFileDWARF::FindFunctions (regex = '%s')", 2918 regex.GetText()); 2919 2920 Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS)); 2921 2922 if (log) 2923 { 2924 GetObjectFile()->GetModule()->LogMessage (log, 2925 "SymbolFileDWARF::FindFunctions (regex=\"%s\", append=%u, sc_list)", 2926 regex.GetText(), 2927 append); 2928 } 2929 2930 2931 // If we aren't appending the results to this list, then clear the list 2932 if (!append) 2933 sc_list.Clear(); 2934 2935 // Remember how many sc_list are in the list before we search in case 2936 // we are appending the results to a variable list. 2937 uint32_t original_size = sc_list.GetSize(); 2938 2939 if (m_using_apple_tables) 2940 { 2941 if (m_apple_names_ap.get()) 2942 FindFunctions (regex, *m_apple_names_ap, include_inlines, sc_list); 2943 } 2944 else 2945 { 2946 // Index the DWARF if we haven't already 2947 if (!m_indexed) 2948 Index (); 2949 2950 FindFunctions (regex, m_function_basename_index, include_inlines, sc_list); 2951 2952 FindFunctions (regex, m_function_fullname_index, include_inlines, sc_list); 2953 } 2954 2955 // Return the number of variable that were appended to the list 2956 return sc_list.GetSize() - original_size; 2957 } 2958 2959 void 2960 SymbolFileDWARF::GetMangledNamesForFunction (const std::string &scope_qualified_name, 2961 std::vector<ConstString> &mangled_names) 2962 { 2963 DWARFDebugInfo* info = DebugInfo(); 2964 uint32_t num_comp_units = 0; 2965 if (info) 2966 num_comp_units = info->GetNumCompileUnits(); 2967 2968 for (uint32_t i = 0; i < num_comp_units; i++) 2969 { 2970 DWARFCompileUnit *cu = info->GetCompileUnitAtIndex(i); 2971 if (cu == nullptr) 2972 continue; 2973 2974 SymbolFileDWARFDwo *dwo = cu->GetDwoSymbolFile(); 2975 if (dwo) 2976 dwo->GetMangledNamesForFunction(scope_qualified_name, mangled_names); 2977 } 2978 2979 NameToOffsetMap::iterator iter = m_function_scope_qualified_name_map.find(scope_qualified_name); 2980 if (iter == m_function_scope_qualified_name_map.end()) 2981 return; 2982 2983 DIERefSetSP set_sp = (*iter).second; 2984 std::set<DIERef>::iterator set_iter; 2985 for (set_iter = set_sp->begin(); set_iter != set_sp->end(); set_iter++) 2986 { 2987 DWARFDIE die = DebugInfo()->GetDIE (*set_iter); 2988 mangled_names.push_back(ConstString(die.GetMangledName())); 2989 } 2990 } 2991 2992 2993 uint32_t 2994 SymbolFileDWARF::FindTypes (const SymbolContext& sc, 2995 const ConstString &name, 2996 const CompilerDeclContext *parent_decl_ctx, 2997 bool append, 2998 uint32_t max_matches, 2999 llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files, 3000 TypeMap& types) 3001 { 3002 // If we aren't appending the results to this list, then clear the list 3003 if (!append) 3004 types.Clear(); 3005 3006 // Make sure we haven't already searched this SymbolFile before... 3007 if (searched_symbol_files.count(this)) 3008 return 0; 3009 else 3010 searched_symbol_files.insert(this); 3011 3012 DWARFDebugInfo* info = DebugInfo(); 3013 if (info == NULL) 3014 return 0; 3015 3016 Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS)); 3017 3018 if (log) 3019 { 3020 if (parent_decl_ctx) 3021 GetObjectFile()->GetModule()->LogMessage (log, 3022 "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx = %p (\"%s\"), append=%u, max_matches=%u, type_list)", 3023 name.GetCString(), 3024 static_cast<const void*>(parent_decl_ctx), 3025 parent_decl_ctx->GetName().AsCString("<NULL>"), 3026 append, max_matches); 3027 else 3028 GetObjectFile()->GetModule()->LogMessage (log, 3029 "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx = NULL, append=%u, max_matches=%u, type_list)", 3030 name.GetCString(), append, 3031 max_matches); 3032 } 3033 3034 if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx)) 3035 return 0; 3036 3037 DIEArray die_offsets; 3038 3039 if (m_using_apple_tables) 3040 { 3041 if (m_apple_types_ap.get()) 3042 { 3043 const char *name_cstr = name.GetCString(); 3044 m_apple_types_ap->FindByName (name_cstr, die_offsets); 3045 } 3046 } 3047 else 3048 { 3049 if (!m_indexed) 3050 Index (); 3051 3052 m_type_index.Find (name, die_offsets); 3053 } 3054 3055 const size_t num_die_matches = die_offsets.size(); 3056 3057 if (num_die_matches) 3058 { 3059 const uint32_t initial_types_size = types.GetSize(); 3060 for (size_t i=0; i<num_die_matches; ++i) 3061 { 3062 const DIERef& die_ref = die_offsets[i]; 3063 DWARFDIE die = GetDIE (die_ref); 3064 3065 if (die) 3066 { 3067 if (!DIEInDeclContext(parent_decl_ctx, die)) 3068 continue; // The containing decl contexts don't match 3069 3070 Type *matching_type = ResolveType (die, true, true); 3071 if (matching_type) 3072 { 3073 // We found a type pointer, now find the shared pointer form our type list 3074 types.InsertUnique (matching_type->shared_from_this()); 3075 if (types.GetSize() >= max_matches) 3076 break; 3077 } 3078 } 3079 else 3080 { 3081 if (m_using_apple_tables) 3082 { 3083 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_types accelerator table had bad die 0x%8.8x for '%s')\n", 3084 die_ref.die_offset, name.GetCString()); 3085 } 3086 } 3087 3088 } 3089 const uint32_t num_matches = types.GetSize() - initial_types_size; 3090 if (log && num_matches) 3091 { 3092 if (parent_decl_ctx) 3093 { 3094 GetObjectFile()->GetModule()->LogMessage (log, 3095 "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx = %p (\"%s\"), append=%u, max_matches=%u, type_list) => %u", 3096 name.GetCString(), 3097 static_cast<const void*>(parent_decl_ctx), 3098 parent_decl_ctx->GetName().AsCString("<NULL>"), 3099 append, max_matches, 3100 num_matches); 3101 } 3102 else 3103 { 3104 GetObjectFile()->GetModule()->LogMessage (log, 3105 "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx = NULL, append=%u, max_matches=%u, type_list) => %u", 3106 name.GetCString(), 3107 append, max_matches, 3108 num_matches); 3109 } 3110 } 3111 return num_matches; 3112 } 3113 else 3114 { 3115 UpdateExternalModuleListIfNeeded(); 3116 3117 for (const auto &pair : m_external_type_modules) 3118 { 3119 ModuleSP external_module_sp = pair.second; 3120 if (external_module_sp) 3121 { 3122 SymbolVendor *sym_vendor = external_module_sp->GetSymbolVendor(); 3123 if (sym_vendor) 3124 { 3125 const uint32_t num_external_matches = sym_vendor->FindTypes (sc, 3126 name, 3127 parent_decl_ctx, 3128 append, 3129 max_matches, 3130 searched_symbol_files, 3131 types); 3132 if (num_external_matches) 3133 return num_external_matches; 3134 } 3135 } 3136 } 3137 } 3138 3139 return 0; 3140 } 3141 3142 3143 size_t 3144 SymbolFileDWARF::FindTypes (const std::vector<CompilerContext> &context, 3145 bool append, 3146 TypeMap& types) 3147 { 3148 if (!append) 3149 types.Clear(); 3150 3151 if (context.empty()) 3152 return 0; 3153 3154 DIEArray die_offsets; 3155 3156 ConstString name = context.back().name; 3157 3158 if (!name) 3159 return 0; 3160 3161 if (m_using_apple_tables) 3162 { 3163 if (m_apple_types_ap.get()) 3164 { 3165 const char *name_cstr = name.GetCString(); 3166 m_apple_types_ap->FindByName (name_cstr, die_offsets); 3167 } 3168 } 3169 else 3170 { 3171 if (!m_indexed) 3172 Index (); 3173 3174 m_type_index.Find (name, die_offsets); 3175 } 3176 3177 const size_t num_die_matches = die_offsets.size(); 3178 3179 if (num_die_matches) 3180 { 3181 size_t num_matches = 0; 3182 for (size_t i=0; i<num_die_matches; ++i) 3183 { 3184 const DIERef& die_ref = die_offsets[i]; 3185 DWARFDIE die = GetDIE (die_ref); 3186 3187 if (die) 3188 { 3189 std::vector<CompilerContext> die_context; 3190 die.GetDWOContext(die_context); 3191 if (die_context != context) 3192 continue; 3193 3194 Type *matching_type = ResolveType (die, true, true); 3195 if (matching_type) 3196 { 3197 // We found a type pointer, now find the shared pointer form our type list 3198 types.InsertUnique (matching_type->shared_from_this()); 3199 ++num_matches; 3200 } 3201 } 3202 else 3203 { 3204 if (m_using_apple_tables) 3205 { 3206 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_types accelerator table had bad die 0x%8.8x for '%s')\n", 3207 die_ref.die_offset, name.GetCString()); 3208 } 3209 } 3210 3211 } 3212 return num_matches; 3213 } 3214 return 0; 3215 } 3216 3217 3218 CompilerDeclContext 3219 SymbolFileDWARF::FindNamespace (const SymbolContext& sc, 3220 const ConstString &name, 3221 const CompilerDeclContext *parent_decl_ctx) 3222 { 3223 Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS)); 3224 3225 if (log) 3226 { 3227 GetObjectFile()->GetModule()->LogMessage (log, 3228 "SymbolFileDWARF::FindNamespace (sc, name=\"%s\")", 3229 name.GetCString()); 3230 } 3231 3232 CompilerDeclContext namespace_decl_ctx; 3233 3234 if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx)) 3235 return namespace_decl_ctx; 3236 3237 3238 DWARFDebugInfo* info = DebugInfo(); 3239 if (info) 3240 { 3241 DIEArray die_offsets; 3242 3243 // Index if we already haven't to make sure the compile units 3244 // get indexed and make their global DIE index list 3245 if (m_using_apple_tables) 3246 { 3247 if (m_apple_namespaces_ap.get()) 3248 { 3249 const char *name_cstr = name.GetCString(); 3250 m_apple_namespaces_ap->FindByName (name_cstr, die_offsets); 3251 } 3252 } 3253 else 3254 { 3255 if (!m_indexed) 3256 Index (); 3257 3258 m_namespace_index.Find (name, die_offsets); 3259 } 3260 3261 const size_t num_matches = die_offsets.size(); 3262 if (num_matches) 3263 { 3264 for (size_t i=0; i<num_matches; ++i) 3265 { 3266 const DIERef& die_ref = die_offsets[i]; 3267 DWARFDIE die = GetDIE (die_ref); 3268 3269 if (die) 3270 { 3271 if (!DIEInDeclContext (parent_decl_ctx, die)) 3272 continue; // The containing decl contexts don't match 3273 3274 DWARFASTParser *dwarf_ast = die.GetDWARFParser(); 3275 if (dwarf_ast) 3276 { 3277 namespace_decl_ctx = dwarf_ast->GetDeclContextForUIDFromDWARF (die); 3278 if (namespace_decl_ctx) 3279 break; 3280 } 3281 } 3282 else 3283 { 3284 if (m_using_apple_tables) 3285 { 3286 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_namespaces accelerator table had bad die 0x%8.8x for '%s')\n", 3287 die_ref.die_offset, name.GetCString()); 3288 } 3289 } 3290 3291 } 3292 } 3293 } 3294 if (log && namespace_decl_ctx) 3295 { 3296 GetObjectFile()->GetModule()->LogMessage (log, 3297 "SymbolFileDWARF::FindNamespace (sc, name=\"%s\") => CompilerDeclContext(%p/%p) \"%s\"", 3298 name.GetCString(), 3299 static_cast<const void*>(namespace_decl_ctx.GetTypeSystem()), 3300 static_cast<const void*>(namespace_decl_ctx.GetOpaqueDeclContext()), 3301 namespace_decl_ctx.GetName().AsCString("<NULL>")); 3302 } 3303 3304 return namespace_decl_ctx; 3305 } 3306 3307 TypeSP 3308 SymbolFileDWARF::GetTypeForDIE (const DWARFDIE &die, bool resolve_function_context) 3309 { 3310 TypeSP type_sp; 3311 if (die) 3312 { 3313 Type *type_ptr = GetDIEToType().lookup (die.GetDIE()); 3314 if (type_ptr == NULL) 3315 { 3316 CompileUnit* lldb_cu = GetCompUnitForDWARFCompUnit(die.GetCU()); 3317 assert (lldb_cu); 3318 SymbolContext sc(lldb_cu); 3319 const DWARFDebugInfoEntry* parent_die = die.GetParent().GetDIE(); 3320 while (parent_die != nullptr) 3321 { 3322 if (parent_die->Tag() == DW_TAG_subprogram) 3323 break; 3324 parent_die = parent_die->GetParent(); 3325 } 3326 SymbolContext sc_backup = sc; 3327 if (resolve_function_context && parent_die != nullptr && !GetFunction(DWARFDIE(die.GetCU(),parent_die), sc)) 3328 sc = sc_backup; 3329 3330 type_sp = ParseType(sc, die, NULL); 3331 } 3332 else if (type_ptr != DIE_IS_BEING_PARSED) 3333 { 3334 // Grab the existing type from the master types lists 3335 type_sp = type_ptr->shared_from_this(); 3336 } 3337 3338 } 3339 return type_sp; 3340 } 3341 3342 3343 DWARFDIE 3344 SymbolFileDWARF::GetDeclContextDIEContainingDIE (const DWARFDIE &orig_die) 3345 { 3346 if (orig_die) 3347 { 3348 DWARFDIE die = orig_die; 3349 3350 while (die) 3351 { 3352 // If this is the original DIE that we are searching for a declaration 3353 // for, then don't look in the cache as we don't want our own decl 3354 // context to be our decl context... 3355 if (orig_die != die) 3356 { 3357 switch (die.Tag()) 3358 { 3359 case DW_TAG_compile_unit: 3360 case DW_TAG_namespace: 3361 case DW_TAG_structure_type: 3362 case DW_TAG_union_type: 3363 case DW_TAG_class_type: 3364 case DW_TAG_lexical_block: 3365 case DW_TAG_subprogram: 3366 return die; 3367 3368 default: 3369 break; 3370 } 3371 } 3372 3373 DWARFDIE spec_die = die.GetReferencedDIE(DW_AT_specification); 3374 if (spec_die) 3375 { 3376 DWARFDIE decl_ctx_die = GetDeclContextDIEContainingDIE(spec_die); 3377 if (decl_ctx_die) 3378 return decl_ctx_die; 3379 } 3380 3381 DWARFDIE abs_die = die.GetReferencedDIE(DW_AT_abstract_origin); 3382 if (abs_die) 3383 { 3384 DWARFDIE decl_ctx_die = GetDeclContextDIEContainingDIE(abs_die); 3385 if (decl_ctx_die) 3386 return decl_ctx_die; 3387 } 3388 3389 die = die.GetParent(); 3390 } 3391 } 3392 return DWARFDIE(); 3393 } 3394 3395 3396 Symbol * 3397 SymbolFileDWARF::GetObjCClassSymbol (const ConstString &objc_class_name) 3398 { 3399 Symbol *objc_class_symbol = NULL; 3400 if (m_obj_file) 3401 { 3402 Symtab *symtab = m_obj_file->GetSymtab (); 3403 if (symtab) 3404 { 3405 objc_class_symbol = symtab->FindFirstSymbolWithNameAndType (objc_class_name, 3406 eSymbolTypeObjCClass, 3407 Symtab::eDebugNo, 3408 Symtab::eVisibilityAny); 3409 } 3410 } 3411 return objc_class_symbol; 3412 } 3413 3414 // Some compilers don't emit the DW_AT_APPLE_objc_complete_type attribute. If they don't 3415 // then we can end up looking through all class types for a complete type and never find 3416 // the full definition. We need to know if this attribute is supported, so we determine 3417 // this here and cache th result. We also need to worry about the debug map DWARF file 3418 // if we are doing darwin DWARF in .o file debugging. 3419 bool 3420 SymbolFileDWARF::Supports_DW_AT_APPLE_objc_complete_type (DWARFCompileUnit *cu) 3421 { 3422 if (m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolCalculate) 3423 { 3424 m_supports_DW_AT_APPLE_objc_complete_type = eLazyBoolNo; 3425 if (cu && cu->Supports_DW_AT_APPLE_objc_complete_type()) 3426 m_supports_DW_AT_APPLE_objc_complete_type = eLazyBoolYes; 3427 else 3428 { 3429 DWARFDebugInfo* debug_info = DebugInfo(); 3430 const uint32_t num_compile_units = GetNumCompileUnits(); 3431 for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) 3432 { 3433 DWARFCompileUnit* dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx); 3434 if (dwarf_cu != cu && dwarf_cu->Supports_DW_AT_APPLE_objc_complete_type()) 3435 { 3436 m_supports_DW_AT_APPLE_objc_complete_type = eLazyBoolYes; 3437 break; 3438 } 3439 } 3440 } 3441 if (m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolNo && GetDebugMapSymfile ()) 3442 return m_debug_map_symfile->Supports_DW_AT_APPLE_objc_complete_type (this); 3443 } 3444 return m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolYes; 3445 } 3446 3447 // This function can be used when a DIE is found that is a forward declaration 3448 // DIE and we want to try and find a type that has the complete definition. 3449 TypeSP 3450 SymbolFileDWARF::FindCompleteObjCDefinitionTypeForDIE (const DWARFDIE &die, 3451 const ConstString &type_name, 3452 bool must_be_implementation) 3453 { 3454 3455 TypeSP type_sp; 3456 3457 if (!type_name || (must_be_implementation && !GetObjCClassSymbol (type_name))) 3458 return type_sp; 3459 3460 DIEArray die_offsets; 3461 3462 if (m_using_apple_tables) 3463 { 3464 if (m_apple_types_ap.get()) 3465 { 3466 const char *name_cstr = type_name.GetCString(); 3467 m_apple_types_ap->FindCompleteObjCClassByName (name_cstr, die_offsets, must_be_implementation); 3468 } 3469 } 3470 else 3471 { 3472 if (!m_indexed) 3473 Index (); 3474 3475 m_type_index.Find (type_name, die_offsets); 3476 } 3477 3478 const size_t num_matches = die_offsets.size(); 3479 3480 if (num_matches) 3481 { 3482 for (size_t i=0; i<num_matches; ++i) 3483 { 3484 const DIERef& die_ref = die_offsets[i]; 3485 DWARFDIE type_die = GetDIE (die_ref); 3486 3487 if (type_die) 3488 { 3489 bool try_resolving_type = false; 3490 3491 // Don't try and resolve the DIE we are looking for with the DIE itself! 3492 if (type_die != die) 3493 { 3494 switch (type_die.Tag()) 3495 { 3496 case DW_TAG_class_type: 3497 case DW_TAG_structure_type: 3498 try_resolving_type = true; 3499 break; 3500 default: 3501 break; 3502 } 3503 } 3504 3505 if (try_resolving_type) 3506 { 3507 if (must_be_implementation && type_die.Supports_DW_AT_APPLE_objc_complete_type()) 3508 try_resolving_type = type_die.GetAttributeValueAsUnsigned (DW_AT_APPLE_objc_complete_type, 0); 3509 3510 if (try_resolving_type) 3511 { 3512 Type *resolved_type = ResolveType (type_die, false, true); 3513 if (resolved_type && resolved_type != DIE_IS_BEING_PARSED) 3514 { 3515 DEBUG_PRINTF ("resolved 0x%8.8" PRIx64 " from %s to 0x%8.8" PRIx64 " (cu 0x%8.8" PRIx64 ")\n", 3516 die.GetID(), 3517 m_obj_file->GetFileSpec().GetFilename().AsCString("<Unknown>"), 3518 type_die.GetID(), 3519 type_cu->GetID()); 3520 3521 if (die) 3522 GetDIEToType()[die.GetDIE()] = resolved_type; 3523 type_sp = resolved_type->shared_from_this(); 3524 break; 3525 } 3526 } 3527 } 3528 } 3529 else 3530 { 3531 if (m_using_apple_tables) 3532 { 3533 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_types accelerator table had bad die 0x%8.8x for '%s')\n", 3534 die_ref.die_offset, type_name.GetCString()); 3535 } 3536 } 3537 3538 } 3539 } 3540 return type_sp; 3541 } 3542 3543 3544 //---------------------------------------------------------------------- 3545 // This function helps to ensure that the declaration contexts match for 3546 // two different DIEs. Often times debug information will refer to a 3547 // forward declaration of a type (the equivalent of "struct my_struct;". 3548 // There will often be a declaration of that type elsewhere that has the 3549 // full definition. When we go looking for the full type "my_struct", we 3550 // will find one or more matches in the accelerator tables and we will 3551 // then need to make sure the type was in the same declaration context 3552 // as the original DIE. This function can efficiently compare two DIEs 3553 // and will return true when the declaration context matches, and false 3554 // when they don't. 3555 //---------------------------------------------------------------------- 3556 bool 3557 SymbolFileDWARF::DIEDeclContextsMatch (const DWARFDIE &die1, 3558 const DWARFDIE &die2) 3559 { 3560 if (die1 == die2) 3561 return true; 3562 3563 DWARFDIECollection decl_ctx_1; 3564 DWARFDIECollection decl_ctx_2; 3565 //The declaration DIE stack is a stack of the declaration context 3566 // DIEs all the way back to the compile unit. If a type "T" is 3567 // declared inside a class "B", and class "B" is declared inside 3568 // a class "A" and class "A" is in a namespace "lldb", and the 3569 // namespace is in a compile unit, there will be a stack of DIEs: 3570 // 3571 // [0] DW_TAG_class_type for "B" 3572 // [1] DW_TAG_class_type for "A" 3573 // [2] DW_TAG_namespace for "lldb" 3574 // [3] DW_TAG_compile_unit for the source file. 3575 // 3576 // We grab both contexts and make sure that everything matches 3577 // all the way back to the compiler unit. 3578 3579 // First lets grab the decl contexts for both DIEs 3580 die1.GetDeclContextDIEs (decl_ctx_1); 3581 die2.GetDeclContextDIEs (decl_ctx_2); 3582 // Make sure the context arrays have the same size, otherwise 3583 // we are done 3584 const size_t count1 = decl_ctx_1.Size(); 3585 const size_t count2 = decl_ctx_2.Size(); 3586 if (count1 != count2) 3587 return false; 3588 3589 // Make sure the DW_TAG values match all the way back up the 3590 // compile unit. If they don't, then we are done. 3591 DWARFDIE decl_ctx_die1; 3592 DWARFDIE decl_ctx_die2; 3593 size_t i; 3594 for (i=0; i<count1; i++) 3595 { 3596 decl_ctx_die1 = decl_ctx_1.GetDIEAtIndex (i); 3597 decl_ctx_die2 = decl_ctx_2.GetDIEAtIndex (i); 3598 if (decl_ctx_die1.Tag() != decl_ctx_die2.Tag()) 3599 return false; 3600 } 3601 #if defined LLDB_CONFIGURATION_DEBUG 3602 3603 // Make sure the top item in the decl context die array is always 3604 // DW_TAG_compile_unit. If it isn't then something went wrong in 3605 // the DWARFDIE::GetDeclContextDIEs() function... 3606 assert (decl_ctx_1.GetDIEAtIndex (count1 - 1).Tag() == DW_TAG_compile_unit); 3607 3608 #endif 3609 // Always skip the compile unit when comparing by only iterating up to 3610 // "count - 1". Here we compare the names as we go. 3611 for (i=0; i<count1 - 1; i++) 3612 { 3613 decl_ctx_die1 = decl_ctx_1.GetDIEAtIndex (i); 3614 decl_ctx_die2 = decl_ctx_2.GetDIEAtIndex (i); 3615 const char *name1 = decl_ctx_die1.GetName(); 3616 const char *name2 = decl_ctx_die2.GetName(); 3617 // If the string was from a DW_FORM_strp, then the pointer will often 3618 // be the same! 3619 if (name1 == name2) 3620 continue; 3621 3622 // Name pointers are not equal, so only compare the strings 3623 // if both are not NULL. 3624 if (name1 && name2) 3625 { 3626 // If the strings don't compare, we are done... 3627 if (strcmp(name1, name2) != 0) 3628 return false; 3629 } 3630 else 3631 { 3632 // One name was NULL while the other wasn't 3633 return false; 3634 } 3635 } 3636 // We made it through all of the checks and the declaration contexts 3637 // are equal. 3638 return true; 3639 } 3640 3641 3642 TypeSP 3643 SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext (const DWARFDeclContext &dwarf_decl_ctx) 3644 { 3645 TypeSP type_sp; 3646 3647 const uint32_t dwarf_decl_ctx_count = dwarf_decl_ctx.GetSize(); 3648 if (dwarf_decl_ctx_count > 0) 3649 { 3650 const ConstString type_name(dwarf_decl_ctx[0].name); 3651 const dw_tag_t tag = dwarf_decl_ctx[0].tag; 3652 3653 if (type_name) 3654 { 3655 Log *log (LogChannelDWARF::GetLogIfAny(DWARF_LOG_TYPE_COMPLETION|DWARF_LOG_LOOKUPS)); 3656 if (log) 3657 { 3658 GetObjectFile()->GetModule()->LogMessage (log, 3659 "SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext(tag=%s, qualified-name='%s')", 3660 DW_TAG_value_to_name(dwarf_decl_ctx[0].tag), 3661 dwarf_decl_ctx.GetQualifiedName()); 3662 } 3663 3664 DIEArray die_offsets; 3665 3666 if (m_using_apple_tables) 3667 { 3668 if (m_apple_types_ap.get()) 3669 { 3670 const bool has_tag = m_apple_types_ap->GetHeader().header_data.ContainsAtom (DWARFMappedHash::eAtomTypeTag); 3671 const bool has_qualified_name_hash = m_apple_types_ap->GetHeader().header_data.ContainsAtom (DWARFMappedHash::eAtomTypeQualNameHash); 3672 if (has_tag && has_qualified_name_hash) 3673 { 3674 const char *qualified_name = dwarf_decl_ctx.GetQualifiedName(); 3675 const uint32_t qualified_name_hash = MappedHash::HashStringUsingDJB (qualified_name); 3676 if (log) 3677 GetObjectFile()->GetModule()->LogMessage (log,"FindByNameAndTagAndQualifiedNameHash()"); 3678 m_apple_types_ap->FindByNameAndTagAndQualifiedNameHash (type_name.GetCString(), tag, qualified_name_hash, die_offsets); 3679 } 3680 else if (has_tag) 3681 { 3682 if (log) 3683 GetObjectFile()->GetModule()->LogMessage (log,"FindByNameAndTag()"); 3684 m_apple_types_ap->FindByNameAndTag (type_name.GetCString(), tag, die_offsets); 3685 } 3686 else 3687 { 3688 m_apple_types_ap->FindByName (type_name.GetCString(), die_offsets); 3689 } 3690 } 3691 } 3692 else 3693 { 3694 if (!m_indexed) 3695 Index (); 3696 3697 m_type_index.Find (type_name, die_offsets); 3698 } 3699 3700 const size_t num_matches = die_offsets.size(); 3701 3702 // Get the type system that we are looking to find a type for. We will use this 3703 // to ensure any matches we find are in a language that this type system supports 3704 const LanguageType language = dwarf_decl_ctx.GetLanguage(); 3705 TypeSystem *type_system = (language == eLanguageTypeUnknown) ? nullptr : GetTypeSystemForLanguage(language); 3706 3707 if (num_matches) 3708 { 3709 for (size_t i=0; i<num_matches; ++i) 3710 { 3711 const DIERef& die_ref = die_offsets[i]; 3712 DWARFDIE type_die = GetDIE (die_ref); 3713 3714 if (type_die) 3715 { 3716 // Make sure type_die's langauge matches the type system we are looking for. 3717 // We don't want to find a "Foo" type from Java if we are looking for a "Foo" 3718 // type for C, C++, ObjC, or ObjC++. 3719 if (type_system && !type_system->SupportsLanguage(type_die.GetLanguage())) 3720 continue; 3721 bool try_resolving_type = false; 3722 3723 // Don't try and resolve the DIE we are looking for with the DIE itself! 3724 const dw_tag_t type_tag = type_die.Tag(); 3725 // Make sure the tags match 3726 if (type_tag == tag) 3727 { 3728 // The tags match, lets try resolving this type 3729 try_resolving_type = true; 3730 } 3731 else 3732 { 3733 // The tags don't match, but we need to watch our for a 3734 // forward declaration for a struct and ("struct foo") 3735 // ends up being a class ("class foo { ... };") or 3736 // vice versa. 3737 switch (type_tag) 3738 { 3739 case DW_TAG_class_type: 3740 // We had a "class foo", see if we ended up with a "struct foo { ... };" 3741 try_resolving_type = (tag == DW_TAG_structure_type); 3742 break; 3743 case DW_TAG_structure_type: 3744 // We had a "struct foo", see if we ended up with a "class foo { ... };" 3745 try_resolving_type = (tag == DW_TAG_class_type); 3746 break; 3747 default: 3748 // Tags don't match, don't event try to resolve 3749 // using this type whose name matches.... 3750 break; 3751 } 3752 } 3753 3754 if (try_resolving_type) 3755 { 3756 DWARFDeclContext type_dwarf_decl_ctx; 3757 type_die.GetDWARFDeclContext (type_dwarf_decl_ctx); 3758 3759 if (log) 3760 { 3761 GetObjectFile()->GetModule()->LogMessage (log, 3762 "SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext(tag=%s, qualified-name='%s') trying die=0x%8.8x (%s)", 3763 DW_TAG_value_to_name(dwarf_decl_ctx[0].tag), 3764 dwarf_decl_ctx.GetQualifiedName(), 3765 type_die.GetOffset(), 3766 type_dwarf_decl_ctx.GetQualifiedName()); 3767 } 3768 3769 // Make sure the decl contexts match all the way up 3770 if (dwarf_decl_ctx == type_dwarf_decl_ctx) 3771 { 3772 Type *resolved_type = ResolveType (type_die, false); 3773 if (resolved_type && resolved_type != DIE_IS_BEING_PARSED) 3774 { 3775 type_sp = resolved_type->shared_from_this(); 3776 break; 3777 } 3778 } 3779 } 3780 else 3781 { 3782 if (log) 3783 { 3784 std::string qualified_name; 3785 type_die.GetQualifiedName(qualified_name); 3786 GetObjectFile()->GetModule()->LogMessage (log, 3787 "SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext(tag=%s, qualified-name='%s') ignoring die=0x%8.8x (%s)", 3788 DW_TAG_value_to_name(dwarf_decl_ctx[0].tag), 3789 dwarf_decl_ctx.GetQualifiedName(), 3790 type_die.GetOffset(), 3791 qualified_name.c_str()); 3792 } 3793 } 3794 } 3795 else 3796 { 3797 if (m_using_apple_tables) 3798 { 3799 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_types accelerator table had bad die 0x%8.8x for '%s')\n", 3800 die_ref.die_offset, type_name.GetCString()); 3801 } 3802 } 3803 3804 } 3805 } 3806 } 3807 } 3808 return type_sp; 3809 } 3810 3811 TypeSP 3812 SymbolFileDWARF::ParseType (const SymbolContext& sc, const DWARFDIE &die, bool *type_is_new_ptr) 3813 { 3814 TypeSP type_sp; 3815 3816 if (die) 3817 { 3818 TypeSystem *type_system = GetTypeSystemForLanguage(die.GetCU()->GetLanguageType()); 3819 3820 if (type_system) 3821 { 3822 DWARFASTParser *dwarf_ast = type_system->GetDWARFParser(); 3823 if (dwarf_ast) 3824 { 3825 Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO); 3826 type_sp = dwarf_ast->ParseTypeFromDWARF (sc, die, log, type_is_new_ptr); 3827 if (type_sp) 3828 { 3829 TypeList* type_list = GetTypeList(); 3830 if (type_list) 3831 type_list->Insert(type_sp); 3832 3833 if (die.Tag() == DW_TAG_subprogram) 3834 { 3835 DIERef die_ref = die.GetDIERef(); 3836 std::string scope_qualified_name(GetDeclContextForUID(die.GetID()).GetScopeQualifiedName().AsCString("")); 3837 if (scope_qualified_name.size()) 3838 { 3839 NameToOffsetMap::iterator iter = m_function_scope_qualified_name_map.find(scope_qualified_name); 3840 if (iter != m_function_scope_qualified_name_map.end()) 3841 (*iter).second->insert(die_ref); 3842 else 3843 { 3844 DIERefSetSP new_set(new std::set<DIERef>); 3845 new_set->insert(die_ref); 3846 m_function_scope_qualified_name_map.emplace(std::make_pair(scope_qualified_name, new_set)); 3847 } 3848 } 3849 } 3850 } 3851 } 3852 } 3853 } 3854 3855 return type_sp; 3856 } 3857 3858 size_t 3859 SymbolFileDWARF::ParseTypes 3860 ( 3861 const SymbolContext& sc, 3862 const DWARFDIE &orig_die, 3863 bool parse_siblings, 3864 bool parse_children 3865 ) 3866 { 3867 size_t types_added = 0; 3868 DWARFDIE die = orig_die; 3869 while (die) 3870 { 3871 bool type_is_new = false; 3872 if (ParseType(sc, die, &type_is_new).get()) 3873 { 3874 if (type_is_new) 3875 ++types_added; 3876 } 3877 3878 if (parse_children && die.HasChildren()) 3879 { 3880 if (die.Tag() == DW_TAG_subprogram) 3881 { 3882 SymbolContext child_sc(sc); 3883 child_sc.function = sc.comp_unit->FindFunctionByUID(die.GetID()).get(); 3884 types_added += ParseTypes(child_sc, die.GetFirstChild(), true, true); 3885 } 3886 else 3887 types_added += ParseTypes(sc, die.GetFirstChild(), true, true); 3888 } 3889 3890 if (parse_siblings) 3891 die = die.GetSibling(); 3892 else 3893 die.Clear(); 3894 } 3895 return types_added; 3896 } 3897 3898 3899 size_t 3900 SymbolFileDWARF::ParseFunctionBlocks (const SymbolContext &sc) 3901 { 3902 assert(sc.comp_unit && sc.function); 3903 size_t functions_added = 0; 3904 DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit); 3905 if (dwarf_cu) 3906 { 3907 const dw_offset_t function_die_offset = sc.function->GetID(); 3908 DWARFDIE function_die = dwarf_cu->GetDIE (function_die_offset); 3909 if (function_die) 3910 { 3911 ParseFunctionBlocks(sc, &sc.function->GetBlock (false), function_die, LLDB_INVALID_ADDRESS, 0); 3912 } 3913 } 3914 3915 return functions_added; 3916 } 3917 3918 3919 size_t 3920 SymbolFileDWARF::ParseTypes (const SymbolContext &sc) 3921 { 3922 // At least a compile unit must be valid 3923 assert(sc.comp_unit); 3924 size_t types_added = 0; 3925 DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit); 3926 if (dwarf_cu) 3927 { 3928 if (sc.function) 3929 { 3930 dw_offset_t function_die_offset = sc.function->GetID(); 3931 DWARFDIE func_die = dwarf_cu->GetDIE(function_die_offset); 3932 if (func_die && func_die.HasChildren()) 3933 { 3934 types_added = ParseTypes(sc, func_die.GetFirstChild(), true, true); 3935 } 3936 } 3937 else 3938 { 3939 DWARFDIE dwarf_cu_die = dwarf_cu->DIE(); 3940 if (dwarf_cu_die && dwarf_cu_die.HasChildren()) 3941 { 3942 types_added = ParseTypes(sc, dwarf_cu_die.GetFirstChild(), true, true); 3943 } 3944 } 3945 } 3946 3947 return types_added; 3948 } 3949 3950 size_t 3951 SymbolFileDWARF::ParseVariablesForContext (const SymbolContext& sc) 3952 { 3953 if (sc.comp_unit != NULL) 3954 { 3955 DWARFDebugInfo* info = DebugInfo(); 3956 if (info == NULL) 3957 return 0; 3958 3959 if (sc.function) 3960 { 3961 DWARFDIE function_die = info->GetDIE(DIERef(sc.function->GetID(), this)); 3962 3963 const dw_addr_t func_lo_pc = function_die.GetAttributeValueAsAddress (DW_AT_low_pc, LLDB_INVALID_ADDRESS); 3964 if (func_lo_pc != LLDB_INVALID_ADDRESS) 3965 { 3966 const size_t num_variables = ParseVariables(sc, function_die.GetFirstChild(), func_lo_pc, true, true); 3967 3968 // Let all blocks know they have parse all their variables 3969 sc.function->GetBlock (false).SetDidParseVariables (true, true); 3970 return num_variables; 3971 } 3972 } 3973 else if (sc.comp_unit) 3974 { 3975 DWARFCompileUnit* dwarf_cu = info->GetCompileUnit(sc.comp_unit->GetID()); 3976 3977 if (dwarf_cu == NULL) 3978 return 0; 3979 3980 uint32_t vars_added = 0; 3981 VariableListSP variables (sc.comp_unit->GetVariableList(false)); 3982 3983 if (variables.get() == NULL) 3984 { 3985 variables.reset(new VariableList()); 3986 sc.comp_unit->SetVariableList(variables); 3987 3988 DIEArray die_offsets; 3989 if (m_using_apple_tables) 3990 { 3991 if (m_apple_names_ap.get()) 3992 { 3993 DWARFMappedHash::DIEInfoArray hash_data_array; 3994 if (m_apple_names_ap->AppendAllDIEsInRange (dwarf_cu->GetOffset(), 3995 dwarf_cu->GetNextCompileUnitOffset(), 3996 hash_data_array)) 3997 { 3998 DWARFMappedHash::ExtractDIEArray (hash_data_array, die_offsets); 3999 } 4000 } 4001 } 4002 else 4003 { 4004 // Index if we already haven't to make sure the compile units 4005 // get indexed and make their global DIE index list 4006 if (!m_indexed) 4007 Index (); 4008 4009 m_global_index.FindAllEntriesForCompileUnit (dwarf_cu->GetOffset(), 4010 die_offsets); 4011 } 4012 4013 const size_t num_matches = die_offsets.size(); 4014 if (num_matches) 4015 { 4016 for (size_t i=0; i<num_matches; ++i) 4017 { 4018 const DIERef& die_ref = die_offsets[i]; 4019 DWARFDIE die = GetDIE (die_ref); 4020 if (die) 4021 { 4022 VariableSP var_sp (ParseVariableDIE(sc, die, LLDB_INVALID_ADDRESS)); 4023 if (var_sp) 4024 { 4025 variables->AddVariableIfUnique (var_sp); 4026 ++vars_added; 4027 } 4028 } 4029 else 4030 { 4031 if (m_using_apple_tables) 4032 { 4033 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); 4034 } 4035 } 4036 4037 } 4038 } 4039 } 4040 return vars_added; 4041 } 4042 } 4043 return 0; 4044 } 4045 4046 VariableSP 4047 SymbolFileDWARF::ParseVariableDIE 4048 ( 4049 const SymbolContext& sc, 4050 const DWARFDIE &die, 4051 const lldb::addr_t func_low_pc 4052 ) 4053 { 4054 if (die.GetDWARF() != this) 4055 return die.GetDWARF()->ParseVariableDIE(sc, die, func_low_pc); 4056 4057 VariableSP var_sp; 4058 if (!die) 4059 return var_sp; 4060 4061 var_sp = GetDIEToVariable()[die.GetDIE()]; 4062 if (var_sp) 4063 return var_sp; // Already been parsed! 4064 4065 const dw_tag_t tag = die.Tag(); 4066 ModuleSP module = GetObjectFile()->GetModule(); 4067 4068 if ((tag == DW_TAG_variable) || 4069 (tag == DW_TAG_constant) || 4070 (tag == DW_TAG_formal_parameter && sc.function)) 4071 { 4072 DWARFAttributes attributes; 4073 const size_t num_attributes = die.GetAttributes(attributes); 4074 DWARFDIE spec_die; 4075 if (num_attributes > 0) 4076 { 4077 const char *name = NULL; 4078 const char *mangled = NULL; 4079 Declaration decl; 4080 uint32_t i; 4081 DWARFFormValue type_die_form; 4082 DWARFExpression location(die.GetCU()); 4083 bool is_external = false; 4084 bool is_artificial = false; 4085 bool location_is_const_value_data = false; 4086 bool has_explicit_location = false; 4087 DWARFFormValue const_value; 4088 Variable::RangeList scope_ranges; 4089 //AccessType accessibility = eAccessNone; 4090 4091 for (i=0; i<num_attributes; ++i) 4092 { 4093 dw_attr_t attr = attributes.AttributeAtIndex(i); 4094 DWARFFormValue form_value; 4095 4096 if (attributes.ExtractFormValueAtIndex(i, form_value)) 4097 { 4098 switch (attr) 4099 { 4100 case DW_AT_decl_file: decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned())); break; 4101 case DW_AT_decl_line: decl.SetLine(form_value.Unsigned()); break; 4102 case DW_AT_decl_column: decl.SetColumn(form_value.Unsigned()); break; 4103 case DW_AT_name: name = form_value.AsCString(); break; 4104 case DW_AT_linkage_name: 4105 case DW_AT_MIPS_linkage_name: mangled = form_value.AsCString(); break; 4106 case DW_AT_type: type_die_form = form_value; break; 4107 case DW_AT_external: is_external = form_value.Boolean(); break; 4108 case DW_AT_const_value: 4109 // If we have already found a DW_AT_location attribute, ignore this attribute. 4110 if (!has_explicit_location) 4111 { 4112 location_is_const_value_data = true; 4113 // The constant value will be either a block, a data value or a string. 4114 const DWARFDataExtractor& debug_info_data = get_debug_info_data(); 4115 if (DWARFFormValue::IsBlockForm(form_value.Form())) 4116 { 4117 // Retrieve the value as a block expression. 4118 uint32_t block_offset = form_value.BlockData() - debug_info_data.GetDataStart(); 4119 uint32_t block_length = form_value.Unsigned(); 4120 location.CopyOpcodeData(module, debug_info_data, block_offset, block_length); 4121 } 4122 else if (DWARFFormValue::IsDataForm(form_value.Form())) 4123 { 4124 // Retrieve the value as a data expression. 4125 DWARFFormValue::FixedFormSizes fixed_form_sizes = 4126 DWARFFormValue::GetFixedFormSizesForAddressSize ( 4127 attributes.CompileUnitAtIndex(i)->GetAddressByteSize(), 4128 attributes.CompileUnitAtIndex(i)->IsDWARF64()); 4129 uint32_t data_offset = attributes.DIEOffsetAtIndex(i); 4130 uint32_t data_length = fixed_form_sizes.GetSize(form_value.Form()); 4131 if (data_length == 0) 4132 { 4133 const uint8_t *data_pointer = form_value.BlockData(); 4134 if (data_pointer) 4135 { 4136 form_value.Unsigned(); 4137 } 4138 else if (DWARFFormValue::IsDataForm(form_value.Form())) 4139 { 4140 // we need to get the byte size of the type later after we create the variable 4141 const_value = form_value; 4142 } 4143 } 4144 else 4145 location.CopyOpcodeData(module, debug_info_data, data_offset, data_length); 4146 } 4147 else 4148 { 4149 // Retrieve the value as a string expression. 4150 if (form_value.Form() == DW_FORM_strp) 4151 { 4152 DWARFFormValue::FixedFormSizes fixed_form_sizes = 4153 DWARFFormValue::GetFixedFormSizesForAddressSize ( 4154 attributes.CompileUnitAtIndex(i)->GetAddressByteSize(), 4155 attributes.CompileUnitAtIndex(i)->IsDWARF64()); 4156 uint32_t data_offset = attributes.DIEOffsetAtIndex(i); 4157 uint32_t data_length = fixed_form_sizes.GetSize(form_value.Form()); 4158 location.CopyOpcodeData(module, debug_info_data, data_offset, data_length); 4159 } 4160 else 4161 { 4162 const char *str = form_value.AsCString(); 4163 uint32_t string_offset = str - (const char *)debug_info_data.GetDataStart(); 4164 uint32_t string_length = strlen(str) + 1; 4165 location.CopyOpcodeData(module, debug_info_data, string_offset, string_length); 4166 } 4167 } 4168 } 4169 break; 4170 case DW_AT_location: 4171 { 4172 location_is_const_value_data = false; 4173 has_explicit_location = true; 4174 if (form_value.BlockData()) 4175 { 4176 const DWARFDataExtractor& debug_info_data = get_debug_info_data(); 4177 4178 uint32_t block_offset = form_value.BlockData() - debug_info_data.GetDataStart(); 4179 uint32_t block_length = form_value.Unsigned(); 4180 location.CopyOpcodeData(module, get_debug_info_data(), block_offset, block_length); 4181 } 4182 else 4183 { 4184 const DWARFDataExtractor& debug_loc_data = get_debug_loc_data(); 4185 const dw_offset_t debug_loc_offset = form_value.Unsigned(); 4186 4187 size_t loc_list_length = DWARFExpression::LocationListSize(die.GetCU(), debug_loc_data, debug_loc_offset); 4188 if (loc_list_length > 0) 4189 { 4190 location.CopyOpcodeData(module, debug_loc_data, debug_loc_offset, loc_list_length); 4191 assert (func_low_pc != LLDB_INVALID_ADDRESS); 4192 location.SetLocationListSlide (func_low_pc - attributes.CompileUnitAtIndex(i)->GetBaseAddress()); 4193 } 4194 } 4195 } 4196 break; 4197 case DW_AT_specification: 4198 spec_die = GetDIE(DIERef(form_value)); 4199 break; 4200 case DW_AT_start_scope: 4201 { 4202 if (form_value.Form() == DW_FORM_sec_offset) 4203 { 4204 DWARFRangeList dwarf_scope_ranges; 4205 const DWARFDebugRanges* debug_ranges = DebugRanges(); 4206 debug_ranges->FindRanges(form_value.Unsigned(), dwarf_scope_ranges); 4207 4208 // All DW_AT_start_scope are relative to the base address of the 4209 // compile unit. We add the compile unit base address to make 4210 // sure all the addresses are properly fixed up. 4211 for (size_t i = 0, count = dwarf_scope_ranges.GetSize(); i < count; ++i) 4212 { 4213 const DWARFRangeList::Entry& range = dwarf_scope_ranges.GetEntryRef(i); 4214 scope_ranges.Append(range.GetRangeBase() + die.GetCU()->GetBaseAddress(), 4215 range.GetByteSize()); 4216 } 4217 } 4218 else 4219 { 4220 // TODO: Handle the case when DW_AT_start_scope have form constant. The 4221 // dwarf spec is a bit ambiguous about what is the expected behavior in 4222 // case the enclosing block have a non coninious address range and the 4223 // DW_AT_start_scope entry have a form constant. 4224 GetObjectFile()->GetModule()->ReportWarning ("0x%8.8" PRIx64 ": DW_AT_start_scope has unsupported form type (0x%x)\n", 4225 die.GetID(), 4226 form_value.Form()); 4227 } 4228 4229 scope_ranges.Sort(); 4230 scope_ranges.CombineConsecutiveRanges(); 4231 } 4232 break; 4233 case DW_AT_artificial: is_artificial = form_value.Boolean(); break; 4234 case DW_AT_accessibility: break; //accessibility = DW_ACCESS_to_AccessType(form_value.Unsigned()); break; 4235 case DW_AT_declaration: 4236 case DW_AT_description: 4237 case DW_AT_endianity: 4238 case DW_AT_segment: 4239 case DW_AT_visibility: 4240 default: 4241 case DW_AT_abstract_origin: 4242 case DW_AT_sibling: 4243 break; 4244 } 4245 } 4246 } 4247 4248 const DWARFDIE parent_context_die = GetDeclContextDIEContainingDIE(die); 4249 const dw_tag_t parent_tag = die.GetParent().Tag(); 4250 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); 4251 4252 ValueType scope = eValueTypeInvalid; 4253 4254 const DWARFDIE sc_parent_die = GetParentSymbolContextDIE(die); 4255 SymbolContextScope * symbol_context_scope = NULL; 4256 4257 if (!mangled) 4258 { 4259 // LLDB relies on the mangled name (DW_TAG_linkage_name or DW_AT_MIPS_linkage_name) to 4260 // generate fully qualified names of global variables with commands like "frame var j". 4261 // For example, if j were an int variable holding a value 4 and declared in a namespace 4262 // B which in turn is contained in a namespace A, the command "frame var j" returns 4263 // "(int) A::B::j = 4". If the compiler does not emit a linkage name, we should be able 4264 // to generate a fully qualified name from the declaration context. 4265 if (parent_tag == DW_TAG_compile_unit && 4266 Language::LanguageIsCPlusPlus(die.GetLanguage())) 4267 { 4268 DWARFDeclContext decl_ctx; 4269 4270 die.GetDWARFDeclContext(decl_ctx); 4271 mangled = decl_ctx.GetQualifiedNameAsConstString().GetCString(); 4272 } 4273 } 4274 4275 // DWARF doesn't specify if a DW_TAG_variable is a local, global 4276 // or static variable, so we have to do a little digging by 4277 // looking at the location of a variable to see if it contains 4278 // a DW_OP_addr opcode _somewhere_ in the definition. I say 4279 // somewhere because clang likes to combine small global variables 4280 // into the same symbol and have locations like: 4281 // DW_OP_addr(0x1000), DW_OP_constu(2), DW_OP_plus 4282 // So if we don't have a DW_TAG_formal_parameter, we can look at 4283 // the location to see if it contains a DW_OP_addr opcode, and 4284 // then we can correctly classify our variables. 4285 if (tag == DW_TAG_formal_parameter) 4286 scope = eValueTypeVariableArgument; 4287 else 4288 { 4289 bool op_error = false; 4290 // Check if the location has a DW_OP_addr with any address value... 4291 lldb::addr_t location_DW_OP_addr = LLDB_INVALID_ADDRESS; 4292 if (!location_is_const_value_data) 4293 { 4294 location_DW_OP_addr = location.GetLocation_DW_OP_addr (0, op_error); 4295 if (op_error) 4296 { 4297 StreamString strm; 4298 location.DumpLocationForAddress (&strm, eDescriptionLevelFull, 0, 0, NULL); 4299 GetObjectFile()->GetModule()->ReportError ("0x%8.8x: %s has an invalid location: %s", die.GetOffset(), die.GetTagAsCString(), strm.GetString().c_str()); 4300 } 4301 } 4302 4303 if (location_DW_OP_addr != LLDB_INVALID_ADDRESS) 4304 { 4305 if (is_external) 4306 scope = eValueTypeVariableGlobal; 4307 else 4308 scope = eValueTypeVariableStatic; 4309 4310 4311 SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile(); 4312 4313 if (debug_map_symfile) 4314 { 4315 // When leaving the DWARF in the .o files on darwin, 4316 // when we have a global variable that wasn't initialized, 4317 // the .o file might not have allocated a virtual 4318 // address for the global variable. In this case it will 4319 // have created a symbol for the global variable 4320 // that is undefined/data and external and the value will 4321 // be the byte size of the variable. When we do the 4322 // address map in SymbolFileDWARFDebugMap we rely on 4323 // having an address, we need to do some magic here 4324 // so we can get the correct address for our global 4325 // variable. The address for all of these entries 4326 // will be zero, and there will be an undefined symbol 4327 // in this object file, and the executable will have 4328 // a matching symbol with a good address. So here we 4329 // dig up the correct address and replace it in the 4330 // location for the variable, and set the variable's 4331 // symbol context scope to be that of the main executable 4332 // so the file address will resolve correctly. 4333 bool linked_oso_file_addr = false; 4334 if (is_external && location_DW_OP_addr == 0) 4335 { 4336 // we have a possible uninitialized extern global 4337 ConstString const_name(mangled ? mangled : name); 4338 ObjectFile *debug_map_objfile = debug_map_symfile->GetObjectFile(); 4339 if (debug_map_objfile) 4340 { 4341 Symtab *debug_map_symtab = debug_map_objfile->GetSymtab(); 4342 if (debug_map_symtab) 4343 { 4344 Symbol *exe_symbol = debug_map_symtab->FindFirstSymbolWithNameAndType (const_name, 4345 eSymbolTypeData, 4346 Symtab::eDebugYes, 4347 Symtab::eVisibilityExtern); 4348 if (exe_symbol) 4349 { 4350 if (exe_symbol->ValueIsAddress()) 4351 { 4352 const addr_t exe_file_addr = exe_symbol->GetAddressRef().GetFileAddress(); 4353 if (exe_file_addr != LLDB_INVALID_ADDRESS) 4354 { 4355 if (location.Update_DW_OP_addr (exe_file_addr)) 4356 { 4357 linked_oso_file_addr = true; 4358 symbol_context_scope = exe_symbol; 4359 } 4360 } 4361 } 4362 } 4363 } 4364 } 4365 } 4366 4367 if (!linked_oso_file_addr) 4368 { 4369 // The DW_OP_addr is not zero, but it contains a .o file address which 4370 // needs to be linked up correctly. 4371 const lldb::addr_t exe_file_addr = debug_map_symfile->LinkOSOFileAddress(this, location_DW_OP_addr); 4372 if (exe_file_addr != LLDB_INVALID_ADDRESS) 4373 { 4374 // Update the file address for this variable 4375 location.Update_DW_OP_addr (exe_file_addr); 4376 } 4377 else 4378 { 4379 // Variable didn't make it into the final executable 4380 return var_sp; 4381 } 4382 } 4383 } 4384 } 4385 else 4386 { 4387 if (location_is_const_value_data) 4388 scope = eValueTypeVariableStatic; 4389 else 4390 scope = eValueTypeVariableLocal; 4391 } 4392 } 4393 4394 if (symbol_context_scope == NULL) 4395 { 4396 switch (parent_tag) 4397 { 4398 case DW_TAG_subprogram: 4399 case DW_TAG_inlined_subroutine: 4400 case DW_TAG_lexical_block: 4401 if (sc.function) 4402 { 4403 symbol_context_scope = sc.function->GetBlock(true).FindBlockByID(sc_parent_die.GetID()); 4404 if (symbol_context_scope == NULL) 4405 symbol_context_scope = sc.function; 4406 } 4407 break; 4408 4409 default: 4410 symbol_context_scope = sc.comp_unit; 4411 break; 4412 } 4413 } 4414 4415 if (symbol_context_scope) 4416 { 4417 SymbolFileTypeSP type_sp(new SymbolFileType(*this, DIERef(type_die_form).GetUID(this))); 4418 4419 if (const_value.Form() && type_sp && type_sp->GetType()) 4420 location.CopyOpcodeData(const_value.Unsigned(), type_sp->GetType()->GetByteSize(), die.GetCU()->GetAddressByteSize()); 4421 4422 var_sp.reset (new Variable (die.GetID(), 4423 name, 4424 mangled, 4425 type_sp, 4426 scope, 4427 symbol_context_scope, 4428 scope_ranges, 4429 &decl, 4430 location, 4431 is_external, 4432 is_artificial, 4433 is_static_member)); 4434 4435 var_sp->SetLocationIsConstantValueData (location_is_const_value_data); 4436 } 4437 else 4438 { 4439 // Not ready to parse this variable yet. It might be a global 4440 // or static variable that is in a function scope and the function 4441 // in the symbol context wasn't filled in yet 4442 return var_sp; 4443 } 4444 } 4445 // Cache var_sp even if NULL (the variable was just a specification or 4446 // was missing vital information to be able to be displayed in the debugger 4447 // (missing location due to optimization, etc)) so we don't re-parse 4448 // this DIE over and over later... 4449 GetDIEToVariable()[die.GetDIE()] = var_sp; 4450 if (spec_die) 4451 GetDIEToVariable()[spec_die.GetDIE()] = var_sp; 4452 } 4453 return var_sp; 4454 } 4455 4456 4457 DWARFDIE 4458 SymbolFileDWARF::FindBlockContainingSpecification (const DIERef& func_die_ref, 4459 dw_offset_t spec_block_die_offset) 4460 { 4461 // Give the concrete function die specified by "func_die_offset", find the 4462 // concrete block whose DW_AT_specification or DW_AT_abstract_origin points 4463 // to "spec_block_die_offset" 4464 return FindBlockContainingSpecification (DebugInfo()->GetDIE (func_die_ref), spec_block_die_offset); 4465 } 4466 4467 4468 DWARFDIE 4469 SymbolFileDWARF::FindBlockContainingSpecification(const DWARFDIE &die, 4470 dw_offset_t spec_block_die_offset) 4471 { 4472 if (die) 4473 { 4474 switch (die.Tag()) 4475 { 4476 case DW_TAG_subprogram: 4477 case DW_TAG_inlined_subroutine: 4478 case DW_TAG_lexical_block: 4479 { 4480 if (die.GetAttributeValueAsReference (DW_AT_specification, DW_INVALID_OFFSET) == spec_block_die_offset) 4481 return die; 4482 4483 if (die.GetAttributeValueAsReference (DW_AT_abstract_origin, DW_INVALID_OFFSET) == spec_block_die_offset) 4484 return die; 4485 } 4486 break; 4487 } 4488 4489 // Give the concrete function die specified by "func_die_offset", find the 4490 // concrete block whose DW_AT_specification or DW_AT_abstract_origin points 4491 // to "spec_block_die_offset" 4492 for (DWARFDIE child_die = die.GetFirstChild(); child_die; child_die = child_die.GetSibling()) 4493 { 4494 DWARFDIE result_die = FindBlockContainingSpecification (child_die, spec_block_die_offset); 4495 if (result_die) 4496 return result_die; 4497 } 4498 } 4499 4500 return DWARFDIE(); 4501 } 4502 4503 size_t 4504 SymbolFileDWARF::ParseVariables (const SymbolContext& sc, 4505 const DWARFDIE &orig_die, 4506 const lldb::addr_t func_low_pc, 4507 bool parse_siblings, 4508 bool parse_children, 4509 VariableList* cc_variable_list) 4510 { 4511 if (!orig_die) 4512 return 0; 4513 4514 VariableListSP variable_list_sp; 4515 4516 size_t vars_added = 0; 4517 DWARFDIE die = orig_die; 4518 while (die) 4519 { 4520 dw_tag_t tag = die.Tag(); 4521 4522 // Check to see if we have already parsed this variable or constant? 4523 VariableSP var_sp = GetDIEToVariable()[die.GetDIE()]; 4524 if (var_sp) 4525 { 4526 if (cc_variable_list) 4527 cc_variable_list->AddVariableIfUnique (var_sp); 4528 } 4529 else 4530 { 4531 // We haven't already parsed it, lets do that now. 4532 if ((tag == DW_TAG_variable) || 4533 (tag == DW_TAG_constant) || 4534 (tag == DW_TAG_formal_parameter && sc.function)) 4535 { 4536 if (variable_list_sp.get() == NULL) 4537 { 4538 DWARFDIE sc_parent_die = GetParentSymbolContextDIE(orig_die); 4539 dw_tag_t parent_tag = sc_parent_die.Tag(); 4540 switch (parent_tag) 4541 { 4542 case DW_TAG_compile_unit: 4543 if (sc.comp_unit != NULL) 4544 { 4545 variable_list_sp = sc.comp_unit->GetVariableList(false); 4546 if (variable_list_sp.get() == NULL) 4547 { 4548 variable_list_sp.reset(new VariableList()); 4549 sc.comp_unit->SetVariableList(variable_list_sp); 4550 } 4551 } 4552 else 4553 { 4554 GetObjectFile()->GetModule()->ReportError ("parent 0x%8.8" PRIx64 " %s with no valid compile unit in symbol context for 0x%8.8" PRIx64 " %s.\n", 4555 sc_parent_die.GetID(), 4556 sc_parent_die.GetTagAsCString(), 4557 orig_die.GetID(), 4558 orig_die.GetTagAsCString()); 4559 } 4560 break; 4561 4562 case DW_TAG_subprogram: 4563 case DW_TAG_inlined_subroutine: 4564 case DW_TAG_lexical_block: 4565 if (sc.function != NULL) 4566 { 4567 // Check to see if we already have parsed the variables for the given scope 4568 4569 Block *block = sc.function->GetBlock(true).FindBlockByID(sc_parent_die.GetID()); 4570 if (block == NULL) 4571 { 4572 // This must be a specification or abstract origin with 4573 // a concrete block counterpart in the current function. We need 4574 // to find the concrete block so we can correctly add the 4575 // variable to it 4576 const DWARFDIE concrete_block_die = FindBlockContainingSpecification (DIERef(sc.function->GetID(), this), 4577 sc_parent_die.GetOffset()); 4578 if (concrete_block_die) 4579 block = sc.function->GetBlock(true).FindBlockByID(concrete_block_die.GetID()); 4580 } 4581 4582 if (block != NULL) 4583 { 4584 const bool can_create = false; 4585 variable_list_sp = block->GetBlockVariableList (can_create); 4586 if (variable_list_sp.get() == NULL) 4587 { 4588 variable_list_sp.reset(new VariableList()); 4589 block->SetVariableList(variable_list_sp); 4590 } 4591 } 4592 } 4593 break; 4594 4595 default: 4596 GetObjectFile()->GetModule()->ReportError ("didn't find appropriate parent DIE for variable list for 0x%8.8" PRIx64 " %s.\n", 4597 orig_die.GetID(), 4598 orig_die.GetTagAsCString()); 4599 break; 4600 } 4601 } 4602 4603 if (variable_list_sp) 4604 { 4605 VariableSP var_sp (ParseVariableDIE(sc, die, func_low_pc)); 4606 if (var_sp) 4607 { 4608 variable_list_sp->AddVariableIfUnique (var_sp); 4609 if (cc_variable_list) 4610 cc_variable_list->AddVariableIfUnique (var_sp); 4611 ++vars_added; 4612 } 4613 } 4614 } 4615 } 4616 4617 bool skip_children = (sc.function == NULL && tag == DW_TAG_subprogram); 4618 4619 if (!skip_children && parse_children && die.HasChildren()) 4620 { 4621 vars_added += ParseVariables(sc, die.GetFirstChild(), func_low_pc, true, true, cc_variable_list); 4622 } 4623 4624 if (parse_siblings) 4625 die = die.GetSibling(); 4626 else 4627 die.Clear(); 4628 } 4629 return vars_added; 4630 } 4631 4632 //------------------------------------------------------------------ 4633 // PluginInterface protocol 4634 //------------------------------------------------------------------ 4635 ConstString 4636 SymbolFileDWARF::GetPluginName() 4637 { 4638 return GetPluginNameStatic(); 4639 } 4640 4641 uint32_t 4642 SymbolFileDWARF::GetPluginVersion() 4643 { 4644 return 1; 4645 } 4646 4647 void 4648 SymbolFileDWARF::DumpIndexes () 4649 { 4650 StreamFile s(stdout, false); 4651 4652 s.Printf ("DWARF index for (%s) '%s':", 4653 GetObjectFile()->GetModule()->GetArchitecture().GetArchitectureName(), 4654 GetObjectFile()->GetFileSpec().GetPath().c_str()); 4655 s.Printf("\nFunction basenames:\n"); m_function_basename_index.Dump (&s); 4656 s.Printf("\nFunction fullnames:\n"); m_function_fullname_index.Dump (&s); 4657 s.Printf("\nFunction methods:\n"); m_function_method_index.Dump (&s); 4658 s.Printf("\nFunction selectors:\n"); m_function_selector_index.Dump (&s); 4659 s.Printf("\nObjective C class selectors:\n"); m_objc_class_selectors_index.Dump (&s); 4660 s.Printf("\nGlobals and statics:\n"); m_global_index.Dump (&s); 4661 s.Printf("\nTypes:\n"); m_type_index.Dump (&s); 4662 s.Printf("\nNamespaces:\n"); m_namespace_index.Dump (&s); 4663 } 4664 4665 4666 SymbolFileDWARFDebugMap * 4667 SymbolFileDWARF::GetDebugMapSymfile() 4668 { 4669 if (m_debug_map_symfile == NULL && !m_debug_map_module_wp.expired()) 4670 { 4671 lldb::ModuleSP module_sp (m_debug_map_module_wp.lock()); 4672 if (module_sp) 4673 { 4674 SymbolVendor *sym_vendor = module_sp->GetSymbolVendor(); 4675 if (sym_vendor) 4676 m_debug_map_symfile = (SymbolFileDWARFDebugMap *)sym_vendor->GetSymbolFile(); 4677 } 4678 } 4679 return m_debug_map_symfile; 4680 } 4681 4682 DWARFExpression::LocationListFormat 4683 SymbolFileDWARF::GetLocationListFormat() const 4684 { 4685 return DWARFExpression::RegularLocationList; 4686 } 4687