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 "clang/AST/ASTConsumer.h" 14 #include "clang/AST/ASTContext.h" 15 #include "clang/AST/Decl.h" 16 #include "clang/AST/DeclGroup.h" 17 #include "clang/AST/DeclObjC.h" 18 #include "clang/AST/DeclTemplate.h" 19 #include "clang/Basic/Builtins.h" 20 #include "clang/Basic/IdentifierTable.h" 21 #include "clang/Basic/LangOptions.h" 22 #include "clang/Basic/SourceManager.h" 23 #include "clang/Basic/TargetInfo.h" 24 #include "clang/Basic/Specifiers.h" 25 #include "clang/Sema/DeclSpec.h" 26 27 #include "llvm/Support/Casting.h" 28 29 #include "lldb/Core/ArchSpec.h" 30 #include "lldb/Core/Module.h" 31 #include "lldb/Core/ModuleList.h" 32 #include "lldb/Core/ModuleSpec.h" 33 #include "lldb/Core/PluginManager.h" 34 #include "lldb/Core/RegularExpression.h" 35 #include "lldb/Core/Scalar.h" 36 #include "lldb/Core/Section.h" 37 #include "lldb/Core/StreamFile.h" 38 #include "lldb/Core/StreamString.h" 39 #include "lldb/Core/Timer.h" 40 #include "lldb/Core/Value.h" 41 42 #include "lldb/Expression/ClangModulesDeclVendor.h" 43 44 #include "lldb/Host/Host.h" 45 46 #include "lldb/Symbol/Block.h" 47 #include "lldb/Symbol/ClangExternalASTSourceCallbacks.h" 48 #include "lldb/Symbol/CompileUnit.h" 49 #include "lldb/Symbol/LineTable.h" 50 #include "lldb/Symbol/ObjectFile.h" 51 #include "lldb/Symbol/SymbolVendor.h" 52 #include "lldb/Symbol/VariableList.h" 53 54 #include "lldb/Target/ObjCLanguageRuntime.h" 55 #include "lldb/Target/CPPLanguageRuntime.h" 56 57 #include "DWARFCompileUnit.h" 58 #include "DWARFDebugAbbrev.h" 59 #include "DWARFDebugAranges.h" 60 #include "DWARFDebugInfo.h" 61 #include "DWARFDebugInfoEntry.h" 62 #include "DWARFDebugLine.h" 63 #include "DWARFDebugPubnames.h" 64 #include "DWARFDebugRanges.h" 65 #include "DWARFDeclContext.h" 66 #include "DWARFDIECollection.h" 67 #include "DWARFFormValue.h" 68 #include "DWARFLocationList.h" 69 #include "LogChannelDWARF.h" 70 #include "SymbolFileDWARFDebugMap.h" 71 72 #include <map> 73 74 #include <ctype.h> 75 #include <string.h> 76 77 //#define ENABLE_DEBUG_PRINTF // COMMENT OUT THIS LINE PRIOR TO CHECKIN 78 79 #ifdef ENABLE_DEBUG_PRINTF 80 #include <stdio.h> 81 #define DEBUG_PRINTF(fmt, ...) printf(fmt, __VA_ARGS__) 82 #else 83 #define DEBUG_PRINTF(fmt, ...) 84 #endif 85 86 #define DIE_IS_BEING_PARSED ((lldb_private::Type*)1) 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 static AccessType 109 DW_ACCESS_to_AccessType (uint32_t dwarf_accessibility) 110 { 111 switch (dwarf_accessibility) 112 { 113 case DW_ACCESS_public: return eAccessPublic; 114 case DW_ACCESS_private: return eAccessPrivate; 115 case DW_ACCESS_protected: return eAccessProtected; 116 default: break; 117 } 118 return eAccessNone; 119 } 120 121 static const char* 122 removeHostnameFromPathname(const char* path_from_dwarf) 123 { 124 if (!path_from_dwarf || !path_from_dwarf[0]) 125 { 126 return path_from_dwarf; 127 } 128 129 const char *colon_pos = strchr(path_from_dwarf, ':'); 130 if (!colon_pos) 131 { 132 return path_from_dwarf; 133 } 134 135 // check whether we have a windows path, and so the first character 136 // is a drive-letter not a hostname. 137 if ( 138 colon_pos == path_from_dwarf + 1 && 139 isalpha(*path_from_dwarf) && 140 strlen(path_from_dwarf) > 2 && 141 '\\' == path_from_dwarf[2]) 142 { 143 return path_from_dwarf; 144 } 145 146 return colon_pos + 1; 147 } 148 149 #if defined(LLDB_CONFIGURATION_DEBUG) || defined(LLDB_CONFIGURATION_RELEASE) 150 151 class DIEStack 152 { 153 public: 154 155 void Push (DWARFCompileUnit *cu, const DWARFDebugInfoEntry *die) 156 { 157 m_dies.push_back (DIEInfo(cu, die)); 158 } 159 160 161 void LogDIEs (Log *log, SymbolFileDWARF *dwarf) 162 { 163 StreamString log_strm; 164 const size_t n = m_dies.size(); 165 log_strm.Printf("DIEStack[%" PRIu64 "]:\n", (uint64_t)n); 166 for (size_t i=0; i<n; i++) 167 { 168 DWARFCompileUnit *cu = m_dies[i].cu; 169 const DWARFDebugInfoEntry *die = m_dies[i].die; 170 std::string qualified_name; 171 die->GetQualifiedName(dwarf, cu, qualified_name); 172 log_strm.Printf ("[%" PRIu64 "] 0x%8.8x: %s name='%s'\n", 173 (uint64_t)i, 174 die->GetOffset(), 175 DW_TAG_value_to_name(die->Tag()), 176 qualified_name.c_str()); 177 } 178 log->PutCString(log_strm.GetData()); 179 } 180 void Pop () 181 { 182 m_dies.pop_back(); 183 } 184 185 class ScopedPopper 186 { 187 public: 188 ScopedPopper (DIEStack &die_stack) : 189 m_die_stack (die_stack), 190 m_valid (false) 191 { 192 } 193 194 void 195 Push (DWARFCompileUnit *cu, const DWARFDebugInfoEntry *die) 196 { 197 m_valid = true; 198 m_die_stack.Push (cu, die); 199 } 200 201 ~ScopedPopper () 202 { 203 if (m_valid) 204 m_die_stack.Pop(); 205 } 206 207 208 209 protected: 210 DIEStack &m_die_stack; 211 bool m_valid; 212 }; 213 214 protected: 215 struct DIEInfo { 216 DIEInfo (DWARFCompileUnit *c, const DWARFDebugInfoEntry *d) : 217 cu(c), 218 die(d) 219 { 220 } 221 DWARFCompileUnit *cu; 222 const DWARFDebugInfoEntry *die; 223 }; 224 typedef std::vector<DIEInfo> Stack; 225 Stack m_dies; 226 }; 227 #endif 228 229 void 230 SymbolFileDWARF::Initialize() 231 { 232 LogChannelDWARF::Initialize(); 233 PluginManager::RegisterPlugin (GetPluginNameStatic(), 234 GetPluginDescriptionStatic(), 235 CreateInstance); 236 } 237 238 void 239 SymbolFileDWARF::Terminate() 240 { 241 PluginManager::UnregisterPlugin (CreateInstance); 242 LogChannelDWARF::Initialize(); 243 } 244 245 246 lldb_private::ConstString 247 SymbolFileDWARF::GetPluginNameStatic() 248 { 249 static ConstString g_name("dwarf"); 250 return g_name; 251 } 252 253 const char * 254 SymbolFileDWARF::GetPluginDescriptionStatic() 255 { 256 return "DWARF and DWARF3 debug symbol file reader."; 257 } 258 259 260 SymbolFile* 261 SymbolFileDWARF::CreateInstance (ObjectFile* obj_file) 262 { 263 return new SymbolFileDWARF(obj_file); 264 } 265 266 TypeList * 267 SymbolFileDWARF::GetTypeList () 268 { 269 if (GetDebugMapSymfile ()) 270 return m_debug_map_symfile->GetTypeList(); 271 return m_obj_file->GetModule()->GetTypeList(); 272 273 } 274 void 275 SymbolFileDWARF::GetTypes (DWARFCompileUnit* cu, 276 const DWARFDebugInfoEntry *die, 277 dw_offset_t min_die_offset, 278 dw_offset_t max_die_offset, 279 uint32_t type_mask, 280 TypeSet &type_set) 281 { 282 if (cu) 283 { 284 if (die) 285 { 286 const dw_offset_t die_offset = die->GetOffset(); 287 288 if (die_offset >= max_die_offset) 289 return; 290 291 if (die_offset >= min_die_offset) 292 { 293 const dw_tag_t tag = die->Tag(); 294 295 bool add_type = false; 296 297 switch (tag) 298 { 299 case DW_TAG_array_type: add_type = (type_mask & eTypeClassArray ) != 0; break; 300 case DW_TAG_unspecified_type: 301 case DW_TAG_base_type: add_type = (type_mask & eTypeClassBuiltin ) != 0; break; 302 case DW_TAG_class_type: add_type = (type_mask & eTypeClassClass ) != 0; break; 303 case DW_TAG_structure_type: add_type = (type_mask & eTypeClassStruct ) != 0; break; 304 case DW_TAG_union_type: add_type = (type_mask & eTypeClassUnion ) != 0; break; 305 case DW_TAG_enumeration_type: add_type = (type_mask & eTypeClassEnumeration ) != 0; break; 306 case DW_TAG_subroutine_type: 307 case DW_TAG_subprogram: 308 case DW_TAG_inlined_subroutine: add_type = (type_mask & eTypeClassFunction ) != 0; break; 309 case DW_TAG_pointer_type: add_type = (type_mask & eTypeClassPointer ) != 0; break; 310 case DW_TAG_rvalue_reference_type: 311 case DW_TAG_reference_type: add_type = (type_mask & eTypeClassReference ) != 0; break; 312 case DW_TAG_typedef: add_type = (type_mask & eTypeClassTypedef ) != 0; break; 313 case DW_TAG_ptr_to_member_type: add_type = (type_mask & eTypeClassMemberPointer ) != 0; break; 314 } 315 316 if (add_type) 317 { 318 const bool assert_not_being_parsed = true; 319 Type *type = ResolveTypeUID (cu, die, assert_not_being_parsed); 320 if (type) 321 { 322 if (type_set.find(type) == type_set.end()) 323 type_set.insert(type); 324 } 325 } 326 } 327 328 for (const DWARFDebugInfoEntry *child_die = die->GetFirstChild(); 329 child_die != NULL; 330 child_die = child_die->GetSibling()) 331 { 332 GetTypes (cu, child_die, min_die_offset, max_die_offset, type_mask, type_set); 333 } 334 } 335 } 336 } 337 338 size_t 339 SymbolFileDWARF::GetTypes (SymbolContextScope *sc_scope, 340 uint32_t type_mask, 341 TypeList &type_list) 342 343 { 344 TypeSet type_set; 345 346 CompileUnit *comp_unit = NULL; 347 DWARFCompileUnit* dwarf_cu = NULL; 348 if (sc_scope) 349 comp_unit = sc_scope->CalculateSymbolContextCompileUnit(); 350 351 if (comp_unit) 352 { 353 dwarf_cu = GetDWARFCompileUnit(comp_unit); 354 if (dwarf_cu == 0) 355 return 0; 356 GetTypes (dwarf_cu, 357 dwarf_cu->DIE(), 358 dwarf_cu->GetOffset(), 359 dwarf_cu->GetNextCompileUnitOffset(), 360 type_mask, 361 type_set); 362 } 363 else 364 { 365 DWARFDebugInfo* info = DebugInfo(); 366 if (info) 367 { 368 const size_t num_cus = info->GetNumCompileUnits(); 369 for (size_t cu_idx=0; cu_idx<num_cus; ++cu_idx) 370 { 371 dwarf_cu = info->GetCompileUnitAtIndex(cu_idx); 372 if (dwarf_cu) 373 { 374 GetTypes (dwarf_cu, 375 dwarf_cu->DIE(), 376 0, 377 UINT32_MAX, 378 type_mask, 379 type_set); 380 } 381 } 382 } 383 } 384 // if (m_using_apple_tables) 385 // { 386 // DWARFMappedHash::MemoryTable *apple_types = m_apple_types_ap.get(); 387 // if (apple_types) 388 // { 389 // apple_types->ForEach([this, &type_set, apple_types, type_mask](const DWARFMappedHash::DIEInfoArray &die_info_array) -> bool { 390 // 391 // for (auto die_info: die_info_array) 392 // { 393 // bool add_type = TagMatchesTypeMask (type_mask, 0); 394 // if (!add_type) 395 // { 396 // dw_tag_t tag = die_info.tag; 397 // if (tag == 0) 398 // { 399 // const DWARFDebugInfoEntry *die = DebugInfo()->GetDIEPtr(die_info.offset, NULL); 400 // tag = die->Tag(); 401 // } 402 // add_type = TagMatchesTypeMask (type_mask, tag); 403 // } 404 // if (add_type) 405 // { 406 // Type *type = ResolveTypeUID(die_info.offset); 407 // 408 // if (type_set.find(type) == type_set.end()) 409 // type_set.insert(type); 410 // } 411 // } 412 // return true; // Keep iterating 413 // }); 414 // } 415 // } 416 // else 417 // { 418 // if (!m_indexed) 419 // Index (); 420 // 421 // m_type_index.ForEach([this, &type_set, type_mask](const char *name, uint32_t die_offset) -> bool { 422 // 423 // bool add_type = TagMatchesTypeMask (type_mask, 0); 424 // 425 // if (!add_type) 426 // { 427 // const DWARFDebugInfoEntry *die = DebugInfo()->GetDIEPtr(die_offset, NULL); 428 // if (die) 429 // { 430 // const dw_tag_t tag = die->Tag(); 431 // add_type = TagMatchesTypeMask (type_mask, tag); 432 // } 433 // } 434 // 435 // if (add_type) 436 // { 437 // Type *type = ResolveTypeUID(die_offset); 438 // 439 // if (type_set.find(type) == type_set.end()) 440 // type_set.insert(type); 441 // } 442 // return true; // Keep iterating 443 // }); 444 // } 445 446 std::set<ClangASTType> clang_type_set; 447 size_t num_types_added = 0; 448 for (Type *type : type_set) 449 { 450 ClangASTType clang_type = type->GetClangForwardType(); 451 if (clang_type_set.find(clang_type) == clang_type_set.end()) 452 { 453 clang_type_set.insert(clang_type); 454 type_list.Insert (type->shared_from_this()); 455 ++num_types_added; 456 } 457 } 458 return num_types_added; 459 } 460 461 462 //---------------------------------------------------------------------- 463 // Gets the first parent that is a lexical block, function or inlined 464 // subroutine, or compile unit. 465 //---------------------------------------------------------------------- 466 static const DWARFDebugInfoEntry * 467 GetParentSymbolContextDIE(const DWARFDebugInfoEntry *child_die) 468 { 469 const DWARFDebugInfoEntry *die; 470 for (die = child_die->GetParent(); die != NULL; die = die->GetParent()) 471 { 472 dw_tag_t tag = die->Tag(); 473 474 switch (tag) 475 { 476 case DW_TAG_compile_unit: 477 case DW_TAG_subprogram: 478 case DW_TAG_inlined_subroutine: 479 case DW_TAG_lexical_block: 480 return die; 481 } 482 } 483 return NULL; 484 } 485 486 487 SymbolFileDWARF::SymbolFileDWARF(ObjectFile* objfile) : 488 SymbolFile (objfile), 489 UserID (0), // Used by SymbolFileDWARFDebugMap to when this class parses .o files to contain the .o file index/ID 490 m_debug_map_module_wp (), 491 m_debug_map_symfile (NULL), 492 m_clang_tu_decl (NULL), 493 m_flags(), 494 m_data_debug_abbrev (), 495 m_data_debug_aranges (), 496 m_data_debug_frame (), 497 m_data_debug_info (), 498 m_data_debug_line (), 499 m_data_debug_loc (), 500 m_data_debug_ranges (), 501 m_data_debug_str (), 502 m_data_apple_names (), 503 m_data_apple_types (), 504 m_data_apple_namespaces (), 505 m_abbr(), 506 m_info(), 507 m_line(), 508 m_apple_names_ap (), 509 m_apple_types_ap (), 510 m_apple_namespaces_ap (), 511 m_apple_objc_ap (), 512 m_function_basename_index(), 513 m_function_fullname_index(), 514 m_function_method_index(), 515 m_function_selector_index(), 516 m_objc_class_selectors_index(), 517 m_global_index(), 518 m_type_index(), 519 m_namespace_index(), 520 m_indexed (false), 521 m_is_external_ast_source (false), 522 m_using_apple_tables (false), 523 m_fetched_external_modules (false), 524 m_supports_DW_AT_APPLE_objc_complete_type (eLazyBoolCalculate), 525 m_ranges(), 526 m_unique_ast_type_map () 527 { 528 } 529 530 SymbolFileDWARF::~SymbolFileDWARF() 531 { 532 if (m_is_external_ast_source) 533 { 534 ModuleSP module_sp (m_obj_file->GetModule()); 535 if (module_sp) 536 module_sp->GetClangASTContext().RemoveExternalSource (); 537 } 538 } 539 540 static const ConstString & 541 GetDWARFMachOSegmentName () 542 { 543 static ConstString g_dwarf_section_name ("__DWARF"); 544 return g_dwarf_section_name; 545 } 546 547 UniqueDWARFASTTypeMap & 548 SymbolFileDWARF::GetUniqueDWARFASTTypeMap () 549 { 550 if (GetDebugMapSymfile ()) 551 return m_debug_map_symfile->GetUniqueDWARFASTTypeMap (); 552 return m_unique_ast_type_map; 553 } 554 555 ClangASTContext & 556 SymbolFileDWARF::GetClangASTContext () 557 { 558 if (GetDebugMapSymfile ()) 559 return m_debug_map_symfile->GetClangASTContext (); 560 561 ClangASTContext &ast = m_obj_file->GetModule()->GetClangASTContext(); 562 if (!m_is_external_ast_source) 563 { 564 m_is_external_ast_source = true; 565 llvm::IntrusiveRefCntPtr<clang::ExternalASTSource> ast_source_ap ( 566 new ClangExternalASTSourceCallbacks (SymbolFileDWARF::CompleteTagDecl, 567 SymbolFileDWARF::CompleteObjCInterfaceDecl, 568 SymbolFileDWARF::FindExternalVisibleDeclsByName, 569 SymbolFileDWARF::LayoutRecordType, 570 this)); 571 ast.SetExternalSource (ast_source_ap); 572 } 573 return ast; 574 } 575 576 void 577 SymbolFileDWARF::InitializeObject() 578 { 579 // Install our external AST source callbacks so we can complete Clang types. 580 ModuleSP module_sp (m_obj_file->GetModule()); 581 if (module_sp) 582 { 583 const SectionList *section_list = module_sp->GetSectionList(); 584 585 const Section* section = section_list->FindSectionByName(GetDWARFMachOSegmentName ()).get(); 586 587 // Memory map the DWARF mach-o segment so we have everything mmap'ed 588 // to keep our heap memory usage down. 589 if (section) 590 m_obj_file->MemoryMapSectionData(section, m_dwarf_data); 591 } 592 get_apple_names_data(); 593 if (m_data_apple_names.GetByteSize() > 0) 594 { 595 m_apple_names_ap.reset (new DWARFMappedHash::MemoryTable (m_data_apple_names, get_debug_str_data(), ".apple_names")); 596 if (m_apple_names_ap->IsValid()) 597 m_using_apple_tables = true; 598 else 599 m_apple_names_ap.reset(); 600 } 601 get_apple_types_data(); 602 if (m_data_apple_types.GetByteSize() > 0) 603 { 604 m_apple_types_ap.reset (new DWARFMappedHash::MemoryTable (m_data_apple_types, get_debug_str_data(), ".apple_types")); 605 if (m_apple_types_ap->IsValid()) 606 m_using_apple_tables = true; 607 else 608 m_apple_types_ap.reset(); 609 } 610 611 get_apple_namespaces_data(); 612 if (m_data_apple_namespaces.GetByteSize() > 0) 613 { 614 m_apple_namespaces_ap.reset (new DWARFMappedHash::MemoryTable (m_data_apple_namespaces, get_debug_str_data(), ".apple_namespaces")); 615 if (m_apple_namespaces_ap->IsValid()) 616 m_using_apple_tables = true; 617 else 618 m_apple_namespaces_ap.reset(); 619 } 620 621 get_apple_objc_data(); 622 if (m_data_apple_objc.GetByteSize() > 0) 623 { 624 m_apple_objc_ap.reset (new DWARFMappedHash::MemoryTable (m_data_apple_objc, get_debug_str_data(), ".apple_objc")); 625 if (m_apple_objc_ap->IsValid()) 626 m_using_apple_tables = true; 627 else 628 m_apple_objc_ap.reset(); 629 } 630 } 631 632 bool 633 SymbolFileDWARF::SupportedVersion(uint16_t version) 634 { 635 return version == 2 || version == 3 || version == 4; 636 } 637 638 uint32_t 639 SymbolFileDWARF::CalculateAbilities () 640 { 641 uint32_t abilities = 0; 642 if (m_obj_file != NULL) 643 { 644 const Section* section = NULL; 645 const SectionList *section_list = m_obj_file->GetSectionList(); 646 if (section_list == NULL) 647 return 0; 648 649 uint64_t debug_abbrev_file_size = 0; 650 uint64_t debug_info_file_size = 0; 651 uint64_t debug_line_file_size = 0; 652 653 section = section_list->FindSectionByName(GetDWARFMachOSegmentName ()).get(); 654 655 if (section) 656 section_list = §ion->GetChildren (); 657 658 section = section_list->FindSectionByType (eSectionTypeDWARFDebugInfo, true).get(); 659 if (section != NULL) 660 { 661 debug_info_file_size = section->GetFileSize(); 662 663 section = section_list->FindSectionByType (eSectionTypeDWARFDebugAbbrev, true).get(); 664 if (section) 665 debug_abbrev_file_size = section->GetFileSize(); 666 else 667 m_flags.Set (flagsGotDebugAbbrevData); 668 669 section = section_list->FindSectionByType (eSectionTypeDWARFDebugAranges, true).get(); 670 if (!section) 671 m_flags.Set (flagsGotDebugArangesData); 672 673 section = section_list->FindSectionByType (eSectionTypeDWARFDebugFrame, true).get(); 674 if (!section) 675 m_flags.Set (flagsGotDebugFrameData); 676 677 section = section_list->FindSectionByType (eSectionTypeDWARFDebugLine, true).get(); 678 if (section) 679 debug_line_file_size = section->GetFileSize(); 680 else 681 m_flags.Set (flagsGotDebugLineData); 682 683 section = section_list->FindSectionByType (eSectionTypeDWARFDebugLoc, true).get(); 684 if (!section) 685 m_flags.Set (flagsGotDebugLocData); 686 687 section = section_list->FindSectionByType (eSectionTypeDWARFDebugMacInfo, true).get(); 688 if (!section) 689 m_flags.Set (flagsGotDebugMacInfoData); 690 691 section = section_list->FindSectionByType (eSectionTypeDWARFDebugPubNames, true).get(); 692 if (!section) 693 m_flags.Set (flagsGotDebugPubNamesData); 694 695 section = section_list->FindSectionByType (eSectionTypeDWARFDebugPubTypes, true).get(); 696 if (!section) 697 m_flags.Set (flagsGotDebugPubTypesData); 698 699 section = section_list->FindSectionByType (eSectionTypeDWARFDebugRanges, true).get(); 700 if (!section) 701 m_flags.Set (flagsGotDebugRangesData); 702 703 section = section_list->FindSectionByType (eSectionTypeDWARFDebugStr, true).get(); 704 if (!section) 705 m_flags.Set (flagsGotDebugStrData); 706 } 707 else 708 { 709 const char *symfile_dir_cstr = m_obj_file->GetFileSpec().GetDirectory().GetCString(); 710 if (symfile_dir_cstr) 711 { 712 if (strcasestr(symfile_dir_cstr, ".dsym")) 713 { 714 if (m_obj_file->GetType() == ObjectFile::eTypeDebugInfo) 715 { 716 // We have a dSYM file that didn't have a any debug info. 717 // If the string table has a size of 1, then it was made from 718 // an executable with no debug info, or from an executable that 719 // was stripped. 720 section = section_list->FindSectionByType (eSectionTypeDWARFDebugStr, true).get(); 721 if (section && section->GetFileSize() == 1) 722 { 723 m_obj_file->GetModule()->ReportWarning ("empty dSYM file detected, dSYM was created with an executable with no debug info."); 724 } 725 } 726 } 727 } 728 } 729 730 if (debug_abbrev_file_size > 0 && debug_info_file_size > 0) 731 abilities |= CompileUnits | Functions | Blocks | GlobalVariables | LocalVariables | VariableTypes; 732 733 if (debug_line_file_size > 0) 734 abilities |= LineTables; 735 } 736 return abilities; 737 } 738 739 const DWARFDataExtractor& 740 SymbolFileDWARF::GetCachedSectionData (uint32_t got_flag, SectionType sect_type, DWARFDataExtractor &data) 741 { 742 if (m_flags.IsClear (got_flag)) 743 { 744 ModuleSP module_sp (m_obj_file->GetModule()); 745 m_flags.Set (got_flag); 746 const SectionList *section_list = module_sp->GetSectionList(); 747 if (section_list) 748 { 749 SectionSP section_sp (section_list->FindSectionByType(sect_type, true)); 750 if (section_sp) 751 { 752 // See if we memory mapped the DWARF segment? 753 if (m_dwarf_data.GetByteSize()) 754 { 755 data.SetData(m_dwarf_data, section_sp->GetOffset (), section_sp->GetFileSize()); 756 } 757 else 758 { 759 if (m_obj_file->ReadSectionData (section_sp.get(), data) == 0) 760 data.Clear(); 761 } 762 } 763 } 764 } 765 return data; 766 } 767 768 const DWARFDataExtractor& 769 SymbolFileDWARF::get_debug_abbrev_data() 770 { 771 return GetCachedSectionData (flagsGotDebugAbbrevData, eSectionTypeDWARFDebugAbbrev, m_data_debug_abbrev); 772 } 773 774 const DWARFDataExtractor& 775 SymbolFileDWARF::get_debug_aranges_data() 776 { 777 return GetCachedSectionData (flagsGotDebugArangesData, eSectionTypeDWARFDebugAranges, m_data_debug_aranges); 778 } 779 780 const DWARFDataExtractor& 781 SymbolFileDWARF::get_debug_frame_data() 782 { 783 return GetCachedSectionData (flagsGotDebugFrameData, eSectionTypeDWARFDebugFrame, m_data_debug_frame); 784 } 785 786 const DWARFDataExtractor& 787 SymbolFileDWARF::get_debug_info_data() 788 { 789 return GetCachedSectionData (flagsGotDebugInfoData, eSectionTypeDWARFDebugInfo, m_data_debug_info); 790 } 791 792 const DWARFDataExtractor& 793 SymbolFileDWARF::get_debug_line_data() 794 { 795 return GetCachedSectionData (flagsGotDebugLineData, eSectionTypeDWARFDebugLine, m_data_debug_line); 796 } 797 798 const DWARFDataExtractor& 799 SymbolFileDWARF::get_debug_loc_data() 800 { 801 return GetCachedSectionData (flagsGotDebugLocData, eSectionTypeDWARFDebugLoc, m_data_debug_loc); 802 } 803 804 const DWARFDataExtractor& 805 SymbolFileDWARF::get_debug_ranges_data() 806 { 807 return GetCachedSectionData (flagsGotDebugRangesData, eSectionTypeDWARFDebugRanges, m_data_debug_ranges); 808 } 809 810 const DWARFDataExtractor& 811 SymbolFileDWARF::get_debug_str_data() 812 { 813 return GetCachedSectionData (flagsGotDebugStrData, eSectionTypeDWARFDebugStr, m_data_debug_str); 814 } 815 816 const DWARFDataExtractor& 817 SymbolFileDWARF::get_apple_names_data() 818 { 819 return GetCachedSectionData (flagsGotAppleNamesData, eSectionTypeDWARFAppleNames, m_data_apple_names); 820 } 821 822 const DWARFDataExtractor& 823 SymbolFileDWARF::get_apple_types_data() 824 { 825 return GetCachedSectionData (flagsGotAppleTypesData, eSectionTypeDWARFAppleTypes, m_data_apple_types); 826 } 827 828 const DWARFDataExtractor& 829 SymbolFileDWARF::get_apple_namespaces_data() 830 { 831 return GetCachedSectionData (flagsGotAppleNamespacesData, eSectionTypeDWARFAppleNamespaces, m_data_apple_namespaces); 832 } 833 834 const DWARFDataExtractor& 835 SymbolFileDWARF::get_apple_objc_data() 836 { 837 return GetCachedSectionData (flagsGotAppleObjCData, eSectionTypeDWARFAppleObjC, m_data_apple_objc); 838 } 839 840 841 DWARFDebugAbbrev* 842 SymbolFileDWARF::DebugAbbrev() 843 { 844 if (m_abbr.get() == NULL) 845 { 846 const DWARFDataExtractor &debug_abbrev_data = get_debug_abbrev_data(); 847 if (debug_abbrev_data.GetByteSize() > 0) 848 { 849 m_abbr.reset(new DWARFDebugAbbrev()); 850 if (m_abbr.get()) 851 m_abbr->Parse(debug_abbrev_data); 852 } 853 } 854 return m_abbr.get(); 855 } 856 857 const DWARFDebugAbbrev* 858 SymbolFileDWARF::DebugAbbrev() const 859 { 860 return m_abbr.get(); 861 } 862 863 864 DWARFDebugInfo* 865 SymbolFileDWARF::DebugInfo() 866 { 867 if (m_info.get() == NULL) 868 { 869 Timer scoped_timer(__PRETTY_FUNCTION__, "%s this = %p", 870 __PRETTY_FUNCTION__, static_cast<void*>(this)); 871 if (get_debug_info_data().GetByteSize() > 0) 872 { 873 m_info.reset(new DWARFDebugInfo()); 874 if (m_info.get()) 875 { 876 m_info->SetDwarfData(this); 877 } 878 } 879 } 880 return m_info.get(); 881 } 882 883 const DWARFDebugInfo* 884 SymbolFileDWARF::DebugInfo() const 885 { 886 return m_info.get(); 887 } 888 889 DWARFCompileUnit* 890 SymbolFileDWARF::GetDWARFCompileUnit(lldb_private::CompileUnit *comp_unit) 891 { 892 DWARFDebugInfo* info = DebugInfo(); 893 if (info) 894 { 895 if (GetDebugMapSymfile ()) 896 { 897 // The debug map symbol file made the compile units for this DWARF 898 // file which is .o file with DWARF in it, and we should have 899 // only 1 compile unit which is at offset zero in the DWARF. 900 // TODO: modify to support LTO .o files where each .o file might 901 // have multiple DW_TAG_compile_unit tags. 902 903 DWARFCompileUnit *dwarf_cu = info->GetCompileUnit(0).get(); 904 if (dwarf_cu && dwarf_cu->GetUserData() == NULL) 905 dwarf_cu->SetUserData(comp_unit); 906 return dwarf_cu; 907 } 908 else 909 { 910 // Just a normal DWARF file whose user ID for the compile unit is 911 // the DWARF offset itself 912 913 DWARFCompileUnit *dwarf_cu = info->GetCompileUnit((dw_offset_t)comp_unit->GetID()).get(); 914 if (dwarf_cu && dwarf_cu->GetUserData() == NULL) 915 dwarf_cu->SetUserData(comp_unit); 916 return dwarf_cu; 917 918 } 919 } 920 return NULL; 921 } 922 923 924 DWARFDebugRanges* 925 SymbolFileDWARF::DebugRanges() 926 { 927 if (m_ranges.get() == NULL) 928 { 929 Timer scoped_timer(__PRETTY_FUNCTION__, "%s this = %p", 930 __PRETTY_FUNCTION__, static_cast<void*>(this)); 931 if (get_debug_ranges_data().GetByteSize() > 0) 932 { 933 m_ranges.reset(new DWARFDebugRanges()); 934 if (m_ranges.get()) 935 m_ranges->Extract(this); 936 } 937 } 938 return m_ranges.get(); 939 } 940 941 const DWARFDebugRanges* 942 SymbolFileDWARF::DebugRanges() const 943 { 944 return m_ranges.get(); 945 } 946 947 lldb::CompUnitSP 948 SymbolFileDWARF::ParseCompileUnit (DWARFCompileUnit* dwarf_cu, uint32_t cu_idx) 949 { 950 CompUnitSP cu_sp; 951 if (dwarf_cu) 952 { 953 CompileUnit *comp_unit = (CompileUnit*)dwarf_cu->GetUserData(); 954 if (comp_unit) 955 { 956 // We already parsed this compile unit, had out a shared pointer to it 957 cu_sp = comp_unit->shared_from_this(); 958 } 959 else 960 { 961 if (GetDebugMapSymfile ()) 962 { 963 // Let the debug map create the compile unit 964 cu_sp = m_debug_map_symfile->GetCompileUnit(this); 965 dwarf_cu->SetUserData(cu_sp.get()); 966 } 967 else 968 { 969 ModuleSP module_sp (m_obj_file->GetModule()); 970 if (module_sp) 971 { 972 const DWARFDebugInfoEntry * cu_die = dwarf_cu->GetCompileUnitDIEOnly (); 973 if (cu_die) 974 { 975 FileSpec cu_file_spec{cu_die->GetName(this, dwarf_cu), false}; 976 if (cu_file_spec) 977 { 978 // If we have a full path to the compile unit, we don't need to resolve 979 // the file. This can be expensive e.g. when the source files are NFS mounted. 980 if (cu_file_spec.IsRelative()) 981 { 982 // DWARF2/3 suggests the form hostname:pathname for compilation directory. 983 // Remove the host part if present. 984 const char *cu_comp_dir{cu_die->GetAttributeValueAsString(this, dwarf_cu, DW_AT_comp_dir, nullptr)}; 985 cu_file_spec.PrependPathComponent(removeHostnameFromPathname(cu_comp_dir)); 986 } 987 988 std::string remapped_file; 989 if (module_sp->RemapSourceFile(cu_file_spec.GetCString(), remapped_file)) 990 cu_file_spec.SetFile(remapped_file, false); 991 992 LanguageType cu_language = DWARFCompileUnit::LanguageTypeFromDWARF(cu_die->GetAttributeValueAsUnsigned(this, dwarf_cu, DW_AT_language, 0)); 993 994 cu_sp.reset(new CompileUnit (module_sp, 995 dwarf_cu, 996 cu_file_spec, 997 MakeUserID(dwarf_cu->GetOffset()), 998 cu_language)); 999 if (cu_sp) 1000 { 1001 dwarf_cu->SetUserData(cu_sp.get()); 1002 1003 // Figure out the compile unit index if we weren't given one 1004 if (cu_idx == UINT32_MAX) 1005 DebugInfo()->GetCompileUnit(dwarf_cu->GetOffset(), &cu_idx); 1006 1007 m_obj_file->GetModule()->GetSymbolVendor()->SetCompileUnitAtIndex(cu_idx, cu_sp); 1008 } 1009 } 1010 } 1011 } 1012 } 1013 } 1014 } 1015 return cu_sp; 1016 } 1017 1018 uint32_t 1019 SymbolFileDWARF::GetNumCompileUnits() 1020 { 1021 DWARFDebugInfo* info = DebugInfo(); 1022 if (info) 1023 return info->GetNumCompileUnits(); 1024 return 0; 1025 } 1026 1027 CompUnitSP 1028 SymbolFileDWARF::ParseCompileUnitAtIndex(uint32_t cu_idx) 1029 { 1030 CompUnitSP cu_sp; 1031 DWARFDebugInfo* info = DebugInfo(); 1032 if (info) 1033 { 1034 DWARFCompileUnit* dwarf_cu = info->GetCompileUnitAtIndex(cu_idx); 1035 if (dwarf_cu) 1036 cu_sp = ParseCompileUnit(dwarf_cu, cu_idx); 1037 } 1038 return cu_sp; 1039 } 1040 1041 Function * 1042 SymbolFileDWARF::ParseCompileUnitFunction (const SymbolContext& sc, DWARFCompileUnit* dwarf_cu, const DWARFDebugInfoEntry *die) 1043 { 1044 DWARFDebugRanges::RangeList func_ranges; 1045 const char *name = NULL; 1046 const char *mangled = NULL; 1047 int decl_file = 0; 1048 int decl_line = 0; 1049 int decl_column = 0; 1050 int call_file = 0; 1051 int call_line = 0; 1052 int call_column = 0; 1053 DWARFExpression frame_base; 1054 1055 assert (die->Tag() == DW_TAG_subprogram); 1056 1057 if (die->Tag() != DW_TAG_subprogram) 1058 return NULL; 1059 1060 if (die->GetDIENamesAndRanges (this, 1061 dwarf_cu, 1062 name, 1063 mangled, 1064 func_ranges, 1065 decl_file, 1066 decl_line, 1067 decl_column, 1068 call_file, 1069 call_line, 1070 call_column, 1071 &frame_base)) 1072 { 1073 // Union of all ranges in the function DIE (if the function is discontiguous) 1074 AddressRange func_range; 1075 lldb::addr_t lowest_func_addr = func_ranges.GetMinRangeBase (0); 1076 lldb::addr_t highest_func_addr = func_ranges.GetMaxRangeEnd (0); 1077 if (lowest_func_addr != LLDB_INVALID_ADDRESS && lowest_func_addr <= highest_func_addr) 1078 { 1079 ModuleSP module_sp (m_obj_file->GetModule()); 1080 func_range.GetBaseAddress().ResolveAddressUsingFileSections (lowest_func_addr, module_sp->GetSectionList()); 1081 if (func_range.GetBaseAddress().IsValid()) 1082 func_range.SetByteSize(highest_func_addr - lowest_func_addr); 1083 } 1084 1085 if (func_range.GetBaseAddress().IsValid()) 1086 { 1087 Mangled func_name; 1088 if (mangled) 1089 func_name.SetValue(ConstString(mangled), true); 1090 else if (die->GetParent()->Tag() == DW_TAG_compile_unit && 1091 LanguageRuntime::LanguageIsCPlusPlus(dwarf_cu->GetLanguageType()) && 1092 name && strcmp(name, "main") != 0) 1093 { 1094 // If the mangled name is not present in the DWARF, generate the demangled name 1095 // using the decl context. We skip if the function is "main" as its name is 1096 // never mangled. 1097 bool is_static = false; 1098 bool is_variadic = false; 1099 unsigned type_quals = 0; 1100 std::vector<ClangASTType> param_types; 1101 std::vector<clang::ParmVarDecl*> param_decls; 1102 const DWARFDebugInfoEntry *decl_ctx_die = NULL; 1103 DWARFDeclContext decl_ctx; 1104 StreamString sstr; 1105 1106 die->GetDWARFDeclContext(this, dwarf_cu, decl_ctx); 1107 sstr << decl_ctx.GetQualifiedName(); 1108 1109 clang::DeclContext *containing_decl_ctx = GetClangDeclContextContainingDIE(dwarf_cu, 1110 die, 1111 &decl_ctx_die); 1112 ParseChildParameters(sc, 1113 containing_decl_ctx, 1114 dwarf_cu, 1115 die, 1116 true, 1117 is_static, 1118 is_variadic, 1119 param_types, 1120 param_decls, 1121 type_quals); 1122 sstr << "("; 1123 for (size_t i = 0; i < param_types.size(); i++) 1124 { 1125 if (i > 0) 1126 sstr << ", "; 1127 sstr << param_types[i].GetTypeName(); 1128 } 1129 if (is_variadic) 1130 sstr << ", ..."; 1131 sstr << ")"; 1132 if (type_quals & clang::Qualifiers::Const) 1133 sstr << " const"; 1134 1135 func_name.SetValue(ConstString(sstr.GetData()), false); 1136 } 1137 else 1138 func_name.SetValue(ConstString(name), false); 1139 1140 FunctionSP func_sp; 1141 std::unique_ptr<Declaration> decl_ap; 1142 if (decl_file != 0 || decl_line != 0 || decl_column != 0) 1143 decl_ap.reset(new Declaration (sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(decl_file), 1144 decl_line, 1145 decl_column)); 1146 1147 // Supply the type _only_ if it has already been parsed 1148 Type *func_type = m_die_to_type.lookup (die); 1149 1150 assert(func_type == NULL || func_type != DIE_IS_BEING_PARSED); 1151 1152 if (FixupAddress (func_range.GetBaseAddress())) 1153 { 1154 const user_id_t func_user_id = MakeUserID(die->GetOffset()); 1155 func_sp.reset(new Function (sc.comp_unit, 1156 MakeUserID(func_user_id), // UserID is the DIE offset 1157 MakeUserID(func_user_id), 1158 func_name, 1159 func_type, 1160 func_range)); // first address range 1161 1162 if (func_sp.get() != NULL) 1163 { 1164 if (frame_base.IsValid()) 1165 func_sp->GetFrameBaseExpression() = frame_base; 1166 sc.comp_unit->AddFunction(func_sp); 1167 return func_sp.get(); 1168 } 1169 } 1170 } 1171 } 1172 return NULL; 1173 } 1174 1175 bool 1176 SymbolFileDWARF::FixupAddress (Address &addr) 1177 { 1178 SymbolFileDWARFDebugMap * debug_map_symfile = GetDebugMapSymfile (); 1179 if (debug_map_symfile) 1180 { 1181 return debug_map_symfile->LinkOSOAddress(addr); 1182 } 1183 // This is a normal DWARF file, no address fixups need to happen 1184 return true; 1185 } 1186 lldb::LanguageType 1187 SymbolFileDWARF::ParseCompileUnitLanguage (const SymbolContext& sc) 1188 { 1189 assert (sc.comp_unit); 1190 DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit); 1191 if (dwarf_cu) 1192 { 1193 const DWARFDebugInfoEntry *die = dwarf_cu->GetCompileUnitDIEOnly(); 1194 if (die) 1195 return DWARFCompileUnit::LanguageTypeFromDWARF(die->GetAttributeValueAsUnsigned(this, dwarf_cu, DW_AT_language, 0)); 1196 } 1197 return eLanguageTypeUnknown; 1198 } 1199 1200 size_t 1201 SymbolFileDWARF::ParseCompileUnitFunctions(const SymbolContext &sc) 1202 { 1203 assert (sc.comp_unit); 1204 size_t functions_added = 0; 1205 DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit); 1206 if (dwarf_cu) 1207 { 1208 DWARFDIECollection function_dies; 1209 const size_t num_functions = dwarf_cu->AppendDIEsWithTag (DW_TAG_subprogram, function_dies); 1210 size_t func_idx; 1211 for (func_idx = 0; func_idx < num_functions; ++func_idx) 1212 { 1213 const DWARFDebugInfoEntry *die = function_dies.GetDIEPtrAtIndex(func_idx); 1214 if (sc.comp_unit->FindFunctionByUID (MakeUserID(die->GetOffset())).get() == NULL) 1215 { 1216 if (ParseCompileUnitFunction(sc, dwarf_cu, die)) 1217 ++functions_added; 1218 } 1219 } 1220 //FixupTypes(); 1221 } 1222 return functions_added; 1223 } 1224 1225 bool 1226 SymbolFileDWARF::ParseCompileUnitSupportFiles (const SymbolContext& sc, FileSpecList& support_files) 1227 { 1228 assert (sc.comp_unit); 1229 DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit); 1230 if (dwarf_cu) 1231 { 1232 const DWARFDebugInfoEntry * cu_die = dwarf_cu->GetCompileUnitDIEOnly(); 1233 1234 if (cu_die) 1235 { 1236 const char * cu_comp_dir = cu_die->GetAttributeValueAsString(this, dwarf_cu, DW_AT_comp_dir, NULL); 1237 1238 // DWARF2/3 suggests the form hostname:pathname for compilation directory. 1239 // Remove the host part if present. 1240 cu_comp_dir = removeHostnameFromPathname(cu_comp_dir); 1241 1242 dw_offset_t stmt_list = cu_die->GetAttributeValueAsUnsigned(this, dwarf_cu, DW_AT_stmt_list, DW_INVALID_OFFSET); 1243 1244 // All file indexes in DWARF are one based and a file of index zero is 1245 // supposed to be the compile unit itself. 1246 support_files.Append (*sc.comp_unit); 1247 1248 return DWARFDebugLine::ParseSupportFiles(sc.comp_unit->GetModule(), get_debug_line_data(), cu_comp_dir, stmt_list, support_files); 1249 } 1250 } 1251 return false; 1252 } 1253 1254 bool 1255 SymbolFileDWARF::ParseImportedModules (const lldb_private::SymbolContext &sc, std::vector<lldb_private::ConstString> &imported_modules) 1256 { 1257 assert (sc.comp_unit); 1258 DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit); 1259 if (dwarf_cu) 1260 { 1261 if (ClangModulesDeclVendor::LanguageSupportsClangModules(sc.comp_unit->GetLanguage())) 1262 { 1263 UpdateExternalModuleListIfNeeded(); 1264 for (const std::pair<uint64_t, const ClangModuleInfo> &external_type_module : m_external_type_modules) 1265 { 1266 imported_modules.push_back(external_type_module.second.m_name); 1267 } 1268 } 1269 } 1270 return false; 1271 } 1272 1273 struct ParseDWARFLineTableCallbackInfo 1274 { 1275 LineTable* line_table; 1276 std::unique_ptr<LineSequence> sequence_ap; 1277 }; 1278 1279 //---------------------------------------------------------------------- 1280 // ParseStatementTableCallback 1281 //---------------------------------------------------------------------- 1282 static void 1283 ParseDWARFLineTableCallback(dw_offset_t offset, const DWARFDebugLine::State& state, void* userData) 1284 { 1285 if (state.row == DWARFDebugLine::State::StartParsingLineTable) 1286 { 1287 // Just started parsing the line table 1288 } 1289 else if (state.row == DWARFDebugLine::State::DoneParsingLineTable) 1290 { 1291 // Done parsing line table, nothing to do for the cleanup 1292 } 1293 else 1294 { 1295 ParseDWARFLineTableCallbackInfo* info = (ParseDWARFLineTableCallbackInfo*)userData; 1296 LineTable* line_table = info->line_table; 1297 1298 // If this is our first time here, we need to create a 1299 // sequence container. 1300 if (!info->sequence_ap.get()) 1301 { 1302 info->sequence_ap.reset(line_table->CreateLineSequenceContainer()); 1303 assert(info->sequence_ap.get()); 1304 } 1305 line_table->AppendLineEntryToSequence (info->sequence_ap.get(), 1306 state.address, 1307 state.line, 1308 state.column, 1309 state.file, 1310 state.is_stmt, 1311 state.basic_block, 1312 state.prologue_end, 1313 state.epilogue_begin, 1314 state.end_sequence); 1315 if (state.end_sequence) 1316 { 1317 // First, put the current sequence into the line table. 1318 line_table->InsertSequence(info->sequence_ap.get()); 1319 // Then, empty it to prepare for the next sequence. 1320 info->sequence_ap->Clear(); 1321 } 1322 } 1323 } 1324 1325 bool 1326 SymbolFileDWARF::ParseCompileUnitLineTable (const SymbolContext &sc) 1327 { 1328 assert (sc.comp_unit); 1329 if (sc.comp_unit->GetLineTable() != NULL) 1330 return true; 1331 1332 DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit); 1333 if (dwarf_cu) 1334 { 1335 const DWARFDebugInfoEntry *dwarf_cu_die = dwarf_cu->GetCompileUnitDIEOnly(); 1336 if (dwarf_cu_die) 1337 { 1338 const dw_offset_t cu_line_offset = dwarf_cu_die->GetAttributeValueAsUnsigned(this, dwarf_cu, DW_AT_stmt_list, DW_INVALID_OFFSET); 1339 if (cu_line_offset != DW_INVALID_OFFSET) 1340 { 1341 std::unique_ptr<LineTable> line_table_ap(new LineTable(sc.comp_unit)); 1342 if (line_table_ap.get()) 1343 { 1344 ParseDWARFLineTableCallbackInfo info; 1345 info.line_table = line_table_ap.get(); 1346 lldb::offset_t offset = cu_line_offset; 1347 DWARFDebugLine::ParseStatementTable(get_debug_line_data(), &offset, ParseDWARFLineTableCallback, &info); 1348 if (m_debug_map_symfile) 1349 { 1350 // We have an object file that has a line table with addresses 1351 // that are not linked. We need to link the line table and convert 1352 // the addresses that are relative to the .o file into addresses 1353 // for the main executable. 1354 sc.comp_unit->SetLineTable (m_debug_map_symfile->LinkOSOLineTable (this, line_table_ap.get())); 1355 } 1356 else 1357 { 1358 sc.comp_unit->SetLineTable(line_table_ap.release()); 1359 return true; 1360 } 1361 } 1362 } 1363 } 1364 } 1365 return false; 1366 } 1367 1368 size_t 1369 SymbolFileDWARF::ParseFunctionBlocks 1370 ( 1371 const SymbolContext& sc, 1372 Block *parent_block, 1373 DWARFCompileUnit* dwarf_cu, 1374 const DWARFDebugInfoEntry *die, 1375 addr_t subprogram_low_pc, 1376 uint32_t depth 1377 ) 1378 { 1379 size_t blocks_added = 0; 1380 while (die != NULL) 1381 { 1382 dw_tag_t tag = die->Tag(); 1383 1384 switch (tag) 1385 { 1386 case DW_TAG_inlined_subroutine: 1387 case DW_TAG_subprogram: 1388 case DW_TAG_lexical_block: 1389 { 1390 Block *block = NULL; 1391 if (tag == DW_TAG_subprogram) 1392 { 1393 // Skip any DW_TAG_subprogram DIEs that are inside 1394 // of a normal or inlined functions. These will be 1395 // parsed on their own as separate entities. 1396 1397 if (depth > 0) 1398 break; 1399 1400 block = parent_block; 1401 } 1402 else 1403 { 1404 BlockSP block_sp(new Block (MakeUserID(die->GetOffset()))); 1405 parent_block->AddChild(block_sp); 1406 block = block_sp.get(); 1407 } 1408 DWARFDebugRanges::RangeList ranges; 1409 const char *name = NULL; 1410 const char *mangled_name = NULL; 1411 1412 int decl_file = 0; 1413 int decl_line = 0; 1414 int decl_column = 0; 1415 int call_file = 0; 1416 int call_line = 0; 1417 int call_column = 0; 1418 if (die->GetDIENamesAndRanges (this, 1419 dwarf_cu, 1420 name, 1421 mangled_name, 1422 ranges, 1423 decl_file, decl_line, decl_column, 1424 call_file, call_line, call_column)) 1425 { 1426 if (tag == DW_TAG_subprogram) 1427 { 1428 assert (subprogram_low_pc == LLDB_INVALID_ADDRESS); 1429 subprogram_low_pc = ranges.GetMinRangeBase(0); 1430 } 1431 else if (tag == DW_TAG_inlined_subroutine) 1432 { 1433 // We get called here for inlined subroutines in two ways. 1434 // The first time is when we are making the Function object 1435 // for this inlined concrete instance. Since we're creating a top level block at 1436 // here, the subprogram_low_pc will be LLDB_INVALID_ADDRESS. So we need to 1437 // adjust the containing address. 1438 // The second time is when we are parsing the blocks inside the function that contains 1439 // the inlined concrete instance. Since these will be blocks inside the containing "real" 1440 // function the offset will be for that function. 1441 if (subprogram_low_pc == LLDB_INVALID_ADDRESS) 1442 { 1443 subprogram_low_pc = ranges.GetMinRangeBase(0); 1444 } 1445 } 1446 1447 const size_t num_ranges = ranges.GetSize(); 1448 for (size_t i = 0; i<num_ranges; ++i) 1449 { 1450 const DWARFDebugRanges::Range &range = ranges.GetEntryRef (i); 1451 const addr_t range_base = range.GetRangeBase(); 1452 if (range_base >= subprogram_low_pc) 1453 block->AddRange(Block::Range (range_base - subprogram_low_pc, range.GetByteSize())); 1454 else 1455 { 1456 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", 1457 block->GetID(), 1458 range_base, 1459 range.GetRangeEnd(), 1460 subprogram_low_pc); 1461 } 1462 } 1463 block->FinalizeRanges (); 1464 1465 if (tag != DW_TAG_subprogram && (name != NULL || mangled_name != NULL)) 1466 { 1467 std::unique_ptr<Declaration> decl_ap; 1468 if (decl_file != 0 || decl_line != 0 || decl_column != 0) 1469 decl_ap.reset(new Declaration(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(decl_file), 1470 decl_line, decl_column)); 1471 1472 std::unique_ptr<Declaration> call_ap; 1473 if (call_file != 0 || call_line != 0 || call_column != 0) 1474 call_ap.reset(new Declaration(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(call_file), 1475 call_line, call_column)); 1476 1477 block->SetInlinedFunctionInfo (name, mangled_name, decl_ap.get(), call_ap.get()); 1478 } 1479 1480 ++blocks_added; 1481 1482 if (die->HasChildren()) 1483 { 1484 blocks_added += ParseFunctionBlocks (sc, 1485 block, 1486 dwarf_cu, 1487 die->GetFirstChild(), 1488 subprogram_low_pc, 1489 depth + 1); 1490 } 1491 } 1492 } 1493 break; 1494 default: 1495 break; 1496 } 1497 1498 // Only parse siblings of the block if we are not at depth zero. A depth 1499 // of zero indicates we are currently parsing the top level 1500 // DW_TAG_subprogram DIE 1501 1502 if (depth == 0) 1503 die = NULL; 1504 else 1505 die = die->GetSibling(); 1506 } 1507 return blocks_added; 1508 } 1509 1510 bool 1511 SymbolFileDWARF::ParseTemplateDIE (DWARFCompileUnit* dwarf_cu, 1512 const DWARFDebugInfoEntry *die, 1513 ClangASTContext::TemplateParameterInfos &template_param_infos) 1514 { 1515 const dw_tag_t tag = die->Tag(); 1516 1517 switch (tag) 1518 { 1519 case DW_TAG_template_type_parameter: 1520 case DW_TAG_template_value_parameter: 1521 { 1522 const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (dwarf_cu->GetAddressByteSize(), dwarf_cu->IsDWARF64()); 1523 1524 DWARFDebugInfoEntry::Attributes attributes; 1525 const size_t num_attributes = die->GetAttributes (this, 1526 dwarf_cu, 1527 fixed_form_sizes, 1528 attributes); 1529 const char *name = NULL; 1530 Type *lldb_type = NULL; 1531 ClangASTType clang_type; 1532 uint64_t uval64 = 0; 1533 bool uval64_valid = false; 1534 if (num_attributes > 0) 1535 { 1536 DWARFFormValue form_value; 1537 for (size_t i=0; i<num_attributes; ++i) 1538 { 1539 const dw_attr_t attr = attributes.AttributeAtIndex(i); 1540 1541 switch (attr) 1542 { 1543 case DW_AT_name: 1544 if (attributes.ExtractFormValueAtIndex(this, i, form_value)) 1545 name = form_value.AsCString(&get_debug_str_data()); 1546 break; 1547 1548 case DW_AT_type: 1549 if (attributes.ExtractFormValueAtIndex(this, i, form_value)) 1550 { 1551 const dw_offset_t type_die_offset = form_value.Reference(); 1552 lldb_type = ResolveTypeUID(type_die_offset); 1553 if (lldb_type) 1554 clang_type = lldb_type->GetClangForwardType(); 1555 } 1556 break; 1557 1558 case DW_AT_const_value: 1559 if (attributes.ExtractFormValueAtIndex(this, i, form_value)) 1560 { 1561 uval64_valid = true; 1562 uval64 = form_value.Unsigned(); 1563 } 1564 break; 1565 default: 1566 break; 1567 } 1568 } 1569 1570 clang::ASTContext *ast = GetClangASTContext().getASTContext(); 1571 if (!clang_type) 1572 clang_type = GetClangASTContext().GetBasicType(eBasicTypeVoid); 1573 1574 if (clang_type) 1575 { 1576 bool is_signed = false; 1577 if (name && name[0]) 1578 template_param_infos.names.push_back(name); 1579 else 1580 template_param_infos.names.push_back(NULL); 1581 1582 if (tag == DW_TAG_template_value_parameter && 1583 lldb_type != NULL && 1584 clang_type.IsIntegerType (is_signed) && 1585 uval64_valid) 1586 { 1587 llvm::APInt apint (lldb_type->GetByteSize() * 8, uval64, is_signed); 1588 template_param_infos.args.push_back (clang::TemplateArgument (*ast, 1589 llvm::APSInt(apint), 1590 clang_type.GetQualType())); 1591 } 1592 else 1593 { 1594 template_param_infos.args.push_back (clang::TemplateArgument (clang_type.GetQualType())); 1595 } 1596 } 1597 else 1598 { 1599 return false; 1600 } 1601 1602 } 1603 } 1604 return true; 1605 1606 default: 1607 break; 1608 } 1609 return false; 1610 } 1611 1612 bool 1613 SymbolFileDWARF::ParseTemplateParameterInfos (DWARFCompileUnit* dwarf_cu, 1614 const DWARFDebugInfoEntry *parent_die, 1615 ClangASTContext::TemplateParameterInfos &template_param_infos) 1616 { 1617 1618 if (parent_die == NULL) 1619 return false; 1620 1621 Args template_parameter_names; 1622 for (const DWARFDebugInfoEntry *die = parent_die->GetFirstChild(); 1623 die != NULL; 1624 die = die->GetSibling()) 1625 { 1626 const dw_tag_t tag = die->Tag(); 1627 1628 switch (tag) 1629 { 1630 case DW_TAG_template_type_parameter: 1631 case DW_TAG_template_value_parameter: 1632 ParseTemplateDIE (dwarf_cu, die, template_param_infos); 1633 break; 1634 1635 default: 1636 break; 1637 } 1638 } 1639 if (template_param_infos.args.empty()) 1640 return false; 1641 return template_param_infos.args.size() == template_param_infos.names.size(); 1642 } 1643 1644 clang::ClassTemplateDecl * 1645 SymbolFileDWARF::ParseClassTemplateDecl (clang::DeclContext *decl_ctx, 1646 lldb::AccessType access_type, 1647 const char *parent_name, 1648 int tag_decl_kind, 1649 const ClangASTContext::TemplateParameterInfos &template_param_infos) 1650 { 1651 if (template_param_infos.IsValid()) 1652 { 1653 std::string template_basename(parent_name); 1654 template_basename.erase (template_basename.find('<')); 1655 ClangASTContext &ast = GetClangASTContext(); 1656 1657 return ast.CreateClassTemplateDecl (decl_ctx, 1658 access_type, 1659 template_basename.c_str(), 1660 tag_decl_kind, 1661 template_param_infos); 1662 } 1663 return NULL; 1664 } 1665 1666 class SymbolFileDWARF::DelayedAddObjCClassProperty 1667 { 1668 public: 1669 DelayedAddObjCClassProperty 1670 ( 1671 const ClangASTType &class_opaque_type, 1672 const char *property_name, 1673 const ClangASTType &property_opaque_type, // The property type is only required if you don't have an ivar decl 1674 clang::ObjCIvarDecl *ivar_decl, 1675 const char *property_setter_name, 1676 const char *property_getter_name, 1677 uint32_t property_attributes, 1678 const ClangASTMetadata *metadata 1679 ) : 1680 m_class_opaque_type (class_opaque_type), 1681 m_property_name (property_name), 1682 m_property_opaque_type (property_opaque_type), 1683 m_ivar_decl (ivar_decl), 1684 m_property_setter_name (property_setter_name), 1685 m_property_getter_name (property_getter_name), 1686 m_property_attributes (property_attributes) 1687 { 1688 if (metadata != NULL) 1689 { 1690 m_metadata_ap.reset(new ClangASTMetadata()); 1691 *m_metadata_ap = *metadata; 1692 } 1693 } 1694 1695 DelayedAddObjCClassProperty (const DelayedAddObjCClassProperty &rhs) 1696 { 1697 *this = rhs; 1698 } 1699 1700 DelayedAddObjCClassProperty& operator= (const DelayedAddObjCClassProperty &rhs) 1701 { 1702 m_class_opaque_type = rhs.m_class_opaque_type; 1703 m_property_name = rhs.m_property_name; 1704 m_property_opaque_type = rhs.m_property_opaque_type; 1705 m_ivar_decl = rhs.m_ivar_decl; 1706 m_property_setter_name = rhs.m_property_setter_name; 1707 m_property_getter_name = rhs.m_property_getter_name; 1708 m_property_attributes = rhs.m_property_attributes; 1709 1710 if (rhs.m_metadata_ap.get()) 1711 { 1712 m_metadata_ap.reset (new ClangASTMetadata()); 1713 *m_metadata_ap = *rhs.m_metadata_ap; 1714 } 1715 return *this; 1716 } 1717 1718 bool 1719 Finalize() 1720 { 1721 return m_class_opaque_type.AddObjCClassProperty (m_property_name, 1722 m_property_opaque_type, 1723 m_ivar_decl, 1724 m_property_setter_name, 1725 m_property_getter_name, 1726 m_property_attributes, 1727 m_metadata_ap.get()); 1728 } 1729 private: 1730 ClangASTType m_class_opaque_type; 1731 const char *m_property_name; 1732 ClangASTType m_property_opaque_type; 1733 clang::ObjCIvarDecl *m_ivar_decl; 1734 const char *m_property_setter_name; 1735 const char *m_property_getter_name; 1736 uint32_t m_property_attributes; 1737 std::unique_ptr<ClangASTMetadata> m_metadata_ap; 1738 }; 1739 1740 struct BitfieldInfo 1741 { 1742 uint64_t bit_size; 1743 uint64_t bit_offset; 1744 1745 BitfieldInfo () : 1746 bit_size (LLDB_INVALID_ADDRESS), 1747 bit_offset (LLDB_INVALID_ADDRESS) 1748 { 1749 } 1750 1751 void 1752 Clear() 1753 { 1754 bit_size = LLDB_INVALID_ADDRESS; 1755 bit_offset = LLDB_INVALID_ADDRESS; 1756 } 1757 1758 bool IsValid () 1759 { 1760 return (bit_size != LLDB_INVALID_ADDRESS) && 1761 (bit_offset != LLDB_INVALID_ADDRESS); 1762 } 1763 }; 1764 1765 1766 bool 1767 SymbolFileDWARF::ClassOrStructIsVirtual (DWARFCompileUnit* dwarf_cu, 1768 const DWARFDebugInfoEntry *parent_die) 1769 { 1770 if (parent_die) 1771 { 1772 for (const DWARFDebugInfoEntry *die = parent_die->GetFirstChild(); die != NULL; die = die->GetSibling()) 1773 { 1774 dw_tag_t tag = die->Tag(); 1775 bool check_virtuality = false; 1776 switch (tag) 1777 { 1778 case DW_TAG_inheritance: 1779 case DW_TAG_subprogram: 1780 check_virtuality = true; 1781 break; 1782 default: 1783 break; 1784 } 1785 if (check_virtuality) 1786 { 1787 if (die->GetAttributeValueAsUnsigned(this, dwarf_cu, DW_AT_virtuality, 0) != 0) 1788 return true; 1789 } 1790 } 1791 } 1792 return false; 1793 } 1794 1795 size_t 1796 SymbolFileDWARF::ParseChildMembers 1797 ( 1798 const SymbolContext& sc, 1799 DWARFCompileUnit* dwarf_cu, 1800 const DWARFDebugInfoEntry *parent_die, 1801 ClangASTType &class_clang_type, 1802 const LanguageType class_language, 1803 std::vector<clang::CXXBaseSpecifier *>& base_classes, 1804 std::vector<int>& member_accessibilities, 1805 DWARFDIECollection& member_function_dies, 1806 DelayedPropertyList& delayed_properties, 1807 AccessType& default_accessibility, 1808 bool &is_a_class, 1809 LayoutInfo &layout_info 1810 ) 1811 { 1812 if (parent_die == NULL) 1813 return 0; 1814 1815 size_t count = 0; 1816 const DWARFDebugInfoEntry *die; 1817 const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (dwarf_cu->GetAddressByteSize(), dwarf_cu->IsDWARF64()); 1818 uint32_t member_idx = 0; 1819 BitfieldInfo last_field_info; 1820 ModuleSP module = GetObjectFile()->GetModule(); 1821 1822 for (die = parent_die->GetFirstChild(); die != NULL; die = die->GetSibling()) 1823 { 1824 dw_tag_t tag = die->Tag(); 1825 1826 switch (tag) 1827 { 1828 case DW_TAG_member: 1829 case DW_TAG_APPLE_property: 1830 { 1831 DWARFDebugInfoEntry::Attributes attributes; 1832 const size_t num_attributes = die->GetAttributes (this, 1833 dwarf_cu, 1834 fixed_form_sizes, 1835 attributes); 1836 if (num_attributes > 0) 1837 { 1838 Declaration decl; 1839 //DWARFExpression location; 1840 const char *name = NULL; 1841 const char *prop_name = NULL; 1842 const char *prop_getter_name = NULL; 1843 const char *prop_setter_name = NULL; 1844 uint32_t prop_attributes = 0; 1845 1846 1847 bool is_artificial = false; 1848 lldb::user_id_t encoding_uid = LLDB_INVALID_UID; 1849 AccessType accessibility = eAccessNone; 1850 uint32_t member_byte_offset = UINT32_MAX; 1851 size_t byte_size = 0; 1852 size_t bit_offset = 0; 1853 size_t bit_size = 0; 1854 bool is_external = false; // On DW_TAG_members, this means the member is static 1855 uint32_t i; 1856 for (i=0; i<num_attributes && !is_artificial; ++i) 1857 { 1858 const dw_attr_t attr = attributes.AttributeAtIndex(i); 1859 DWARFFormValue form_value; 1860 if (attributes.ExtractFormValueAtIndex(this, i, form_value)) 1861 { 1862 switch (attr) 1863 { 1864 case DW_AT_decl_file: decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned())); break; 1865 case DW_AT_decl_line: decl.SetLine(form_value.Unsigned()); break; 1866 case DW_AT_decl_column: decl.SetColumn(form_value.Unsigned()); break; 1867 case DW_AT_name: name = form_value.AsCString(&get_debug_str_data()); break; 1868 case DW_AT_type: encoding_uid = form_value.Reference(); break; 1869 case DW_AT_bit_offset: bit_offset = form_value.Unsigned(); break; 1870 case DW_AT_bit_size: bit_size = form_value.Unsigned(); break; 1871 case DW_AT_byte_size: byte_size = form_value.Unsigned(); break; 1872 case DW_AT_data_member_location: 1873 if (form_value.BlockData()) 1874 { 1875 Value initialValue(0); 1876 Value memberOffset(0); 1877 const DWARFDataExtractor& debug_info_data = get_debug_info_data(); 1878 uint32_t block_length = form_value.Unsigned(); 1879 uint32_t block_offset = form_value.BlockData() - debug_info_data.GetDataStart(); 1880 if (DWARFExpression::Evaluate(NULL, // ExecutionContext * 1881 NULL, // ClangExpressionVariableList * 1882 NULL, // ClangExpressionDeclMap * 1883 NULL, // RegisterContext * 1884 module, 1885 debug_info_data, 1886 block_offset, 1887 block_length, 1888 eRegisterKindDWARF, 1889 &initialValue, 1890 memberOffset, 1891 NULL)) 1892 { 1893 member_byte_offset = memberOffset.ResolveValue(NULL).UInt(); 1894 } 1895 } 1896 else 1897 { 1898 // With DWARF 3 and later, if the value is an integer constant, 1899 // this form value is the offset in bytes from the beginning 1900 // of the containing entity. 1901 member_byte_offset = form_value.Unsigned(); 1902 } 1903 break; 1904 1905 case DW_AT_accessibility: accessibility = DW_ACCESS_to_AccessType (form_value.Unsigned()); break; 1906 case DW_AT_artificial: is_artificial = form_value.Boolean(); break; 1907 case DW_AT_APPLE_property_name: prop_name = form_value.AsCString(&get_debug_str_data()); break; 1908 case DW_AT_APPLE_property_getter: prop_getter_name = form_value.AsCString(&get_debug_str_data()); break; 1909 case DW_AT_APPLE_property_setter: prop_setter_name = form_value.AsCString(&get_debug_str_data()); break; 1910 case DW_AT_APPLE_property_attribute: prop_attributes = form_value.Unsigned(); break; 1911 case DW_AT_external: is_external = form_value.Boolean(); break; 1912 1913 default: 1914 case DW_AT_declaration: 1915 case DW_AT_description: 1916 case DW_AT_mutable: 1917 case DW_AT_visibility: 1918 case DW_AT_sibling: 1919 break; 1920 } 1921 } 1922 } 1923 1924 if (prop_name) 1925 { 1926 ConstString fixed_getter; 1927 ConstString fixed_setter; 1928 1929 // Check if the property getter/setter were provided as full 1930 // names. We want basenames, so we extract them. 1931 1932 if (prop_getter_name && prop_getter_name[0] == '-') 1933 { 1934 ObjCLanguageRuntime::MethodName prop_getter_method(prop_getter_name, true); 1935 prop_getter_name = prop_getter_method.GetSelector().GetCString(); 1936 } 1937 1938 if (prop_setter_name && prop_setter_name[0] == '-') 1939 { 1940 ObjCLanguageRuntime::MethodName prop_setter_method(prop_setter_name, true); 1941 prop_setter_name = prop_setter_method.GetSelector().GetCString(); 1942 } 1943 1944 // If the names haven't been provided, they need to be 1945 // filled in. 1946 1947 if (!prop_getter_name) 1948 { 1949 prop_getter_name = prop_name; 1950 } 1951 if (!prop_setter_name && prop_name[0] && !(prop_attributes & DW_APPLE_PROPERTY_readonly)) 1952 { 1953 StreamString ss; 1954 1955 ss.Printf("set%c%s:", 1956 toupper(prop_name[0]), 1957 &prop_name[1]); 1958 1959 fixed_setter.SetCString(ss.GetData()); 1960 prop_setter_name = fixed_setter.GetCString(); 1961 } 1962 } 1963 1964 // Clang has a DWARF generation bug where sometimes it 1965 // represents fields that are references with bad byte size 1966 // and bit size/offset information such as: 1967 // 1968 // DW_AT_byte_size( 0x00 ) 1969 // DW_AT_bit_size( 0x40 ) 1970 // DW_AT_bit_offset( 0xffffffffffffffc0 ) 1971 // 1972 // So check the bit offset to make sure it is sane, and if 1973 // the values are not sane, remove them. If we don't do this 1974 // then we will end up with a crash if we try to use this 1975 // type in an expression when clang becomes unhappy with its 1976 // recycled debug info. 1977 1978 if (bit_offset > 128) 1979 { 1980 bit_size = 0; 1981 bit_offset = 0; 1982 } 1983 1984 // FIXME: Make Clang ignore Objective-C accessibility for expressions 1985 if (class_language == eLanguageTypeObjC || 1986 class_language == eLanguageTypeObjC_plus_plus) 1987 accessibility = eAccessNone; 1988 1989 if (member_idx == 0 && !is_artificial && name && (strstr (name, "_vptr$") == name)) 1990 { 1991 // Not all compilers will mark the vtable pointer 1992 // member as artificial (llvm-gcc). We can't have 1993 // the virtual members in our classes otherwise it 1994 // throws off all child offsets since we end up 1995 // having and extra pointer sized member in our 1996 // class layouts. 1997 is_artificial = true; 1998 } 1999 2000 // Handle static members 2001 if (is_external && member_byte_offset == UINT32_MAX) 2002 { 2003 Type *var_type = ResolveTypeUID(encoding_uid); 2004 2005 if (var_type) 2006 { 2007 if (accessibility == eAccessNone) 2008 accessibility = eAccessPublic; 2009 class_clang_type.AddVariableToRecordType (name, 2010 var_type->GetClangLayoutType(), 2011 accessibility); 2012 } 2013 break; 2014 } 2015 2016 if (is_artificial == false) 2017 { 2018 Type *member_type = ResolveTypeUID(encoding_uid); 2019 2020 clang::FieldDecl *field_decl = NULL; 2021 if (tag == DW_TAG_member) 2022 { 2023 if (member_type) 2024 { 2025 if (accessibility == eAccessNone) 2026 accessibility = default_accessibility; 2027 member_accessibilities.push_back(accessibility); 2028 2029 uint64_t field_bit_offset = (member_byte_offset == UINT32_MAX ? 0 : (member_byte_offset * 8)); 2030 if (bit_size > 0) 2031 { 2032 2033 BitfieldInfo this_field_info; 2034 this_field_info.bit_offset = field_bit_offset; 2035 this_field_info.bit_size = bit_size; 2036 2037 ///////////////////////////////////////////////////////////// 2038 // How to locate a field given the DWARF debug information 2039 // 2040 // AT_byte_size indicates the size of the word in which the 2041 // bit offset must be interpreted. 2042 // 2043 // AT_data_member_location indicates the byte offset of the 2044 // word from the base address of the structure. 2045 // 2046 // AT_bit_offset indicates how many bits into the word 2047 // (according to the host endianness) the low-order bit of 2048 // the field starts. AT_bit_offset can be negative. 2049 // 2050 // AT_bit_size indicates the size of the field in bits. 2051 ///////////////////////////////////////////////////////////// 2052 2053 if (byte_size == 0) 2054 byte_size = member_type->GetByteSize(); 2055 2056 if (GetObjectFile()->GetByteOrder() == eByteOrderLittle) 2057 { 2058 this_field_info.bit_offset += byte_size * 8; 2059 this_field_info.bit_offset -= (bit_offset + bit_size); 2060 } 2061 else 2062 { 2063 this_field_info.bit_offset += bit_offset; 2064 } 2065 2066 // Update the field bit offset we will report for layout 2067 field_bit_offset = this_field_info.bit_offset; 2068 2069 // If the member to be emitted did not start on a character boundary and there is 2070 // empty space between the last field and this one, then we need to emit an 2071 // anonymous member filling up the space up to its start. There are three cases 2072 // here: 2073 // 2074 // 1 If the previous member ended on a character boundary, then we can emit an 2075 // anonymous member starting at the most recent character boundary. 2076 // 2077 // 2 If the previous member did not end on a character boundary and the distance 2078 // from the end of the previous member to the current member is less than a 2079 // word width, then we can emit an anonymous member starting right after the 2080 // previous member and right before this member. 2081 // 2082 // 3 If the previous member did not end on a character boundary and the distance 2083 // from the end of the previous member to the current member is greater than 2084 // or equal a word width, then we act as in Case 1. 2085 2086 const uint64_t character_width = 8; 2087 const uint64_t word_width = 32; 2088 2089 // Objective-C has invalid DW_AT_bit_offset values in older versions 2090 // of clang, so we have to be careful and only insert unnamed bitfields 2091 // if we have a new enough clang. 2092 bool detect_unnamed_bitfields = true; 2093 2094 if (class_language == eLanguageTypeObjC || class_language == eLanguageTypeObjC_plus_plus) 2095 detect_unnamed_bitfields = dwarf_cu->Supports_unnamed_objc_bitfields (); 2096 2097 if (detect_unnamed_bitfields) 2098 { 2099 BitfieldInfo anon_field_info; 2100 2101 if ((this_field_info.bit_offset % character_width) != 0) // not char aligned 2102 { 2103 uint64_t last_field_end = 0; 2104 2105 if (last_field_info.IsValid()) 2106 last_field_end = last_field_info.bit_offset + last_field_info.bit_size; 2107 2108 if (this_field_info.bit_offset != last_field_end) 2109 { 2110 if (((last_field_end % character_width) == 0) || // case 1 2111 (this_field_info.bit_offset - last_field_end >= word_width)) // case 3 2112 { 2113 anon_field_info.bit_size = this_field_info.bit_offset % character_width; 2114 anon_field_info.bit_offset = this_field_info.bit_offset - anon_field_info.bit_size; 2115 } 2116 else // case 2 2117 { 2118 anon_field_info.bit_size = this_field_info.bit_offset - last_field_end; 2119 anon_field_info.bit_offset = last_field_end; 2120 } 2121 } 2122 } 2123 2124 if (anon_field_info.IsValid()) 2125 { 2126 clang::FieldDecl *unnamed_bitfield_decl = class_clang_type.AddFieldToRecordType (NULL, 2127 GetClangASTContext().GetBuiltinTypeForEncodingAndBitSize(eEncodingSint, word_width), 2128 accessibility, 2129 anon_field_info.bit_size); 2130 2131 layout_info.field_offsets.insert( 2132 std::make_pair(unnamed_bitfield_decl, anon_field_info.bit_offset)); 2133 } 2134 } 2135 last_field_info = this_field_info; 2136 } 2137 else 2138 { 2139 last_field_info.Clear(); 2140 } 2141 2142 ClangASTType member_clang_type = member_type->GetClangLayoutType(); 2143 2144 { 2145 // Older versions of clang emit array[0] and array[1] in the same way (<rdar://problem/12566646>). 2146 // If the current field is at the end of the structure, then there is definitely no room for extra 2147 // elements and we override the type to array[0]. 2148 2149 ClangASTType member_array_element_type; 2150 uint64_t member_array_size; 2151 bool member_array_is_incomplete; 2152 2153 if (member_clang_type.IsArrayType(&member_array_element_type, 2154 &member_array_size, 2155 &member_array_is_incomplete) && 2156 !member_array_is_incomplete) 2157 { 2158 uint64_t parent_byte_size = parent_die->GetAttributeValueAsUnsigned(this, dwarf_cu, DW_AT_byte_size, UINT64_MAX); 2159 2160 if (member_byte_offset >= parent_byte_size) 2161 { 2162 if (member_array_size != 1) 2163 { 2164 GetObjectFile()->GetModule()->ReportError ("0x%8.8" PRIx64 ": DW_TAG_member '%s' refers to type 0x%8.8" PRIx64 " which extends beyond the bounds of 0x%8.8" PRIx64, 2165 MakeUserID(die->GetOffset()), 2166 name, 2167 encoding_uid, 2168 MakeUserID(parent_die->GetOffset())); 2169 } 2170 2171 member_clang_type = GetClangASTContext().CreateArrayType(member_array_element_type, 0, false); 2172 } 2173 } 2174 } 2175 2176 field_decl = class_clang_type.AddFieldToRecordType (name, 2177 member_clang_type, 2178 accessibility, 2179 bit_size); 2180 2181 GetClangASTContext().SetMetadataAsUserID (field_decl, MakeUserID(die->GetOffset())); 2182 2183 layout_info.field_offsets.insert(std::make_pair(field_decl, field_bit_offset)); 2184 } 2185 else 2186 { 2187 if (name) 2188 GetObjectFile()->GetModule()->ReportError ("0x%8.8" PRIx64 ": DW_TAG_member '%s' refers to type 0x%8.8" PRIx64 " which was unable to be parsed", 2189 MakeUserID(die->GetOffset()), 2190 name, 2191 encoding_uid); 2192 else 2193 GetObjectFile()->GetModule()->ReportError ("0x%8.8" PRIx64 ": DW_TAG_member refers to type 0x%8.8" PRIx64 " which was unable to be parsed", 2194 MakeUserID(die->GetOffset()), 2195 encoding_uid); 2196 } 2197 } 2198 2199 if (prop_name != NULL) 2200 { 2201 clang::ObjCIvarDecl *ivar_decl = NULL; 2202 2203 if (field_decl) 2204 { 2205 ivar_decl = clang::dyn_cast<clang::ObjCIvarDecl>(field_decl); 2206 assert (ivar_decl != NULL); 2207 } 2208 2209 ClangASTMetadata metadata; 2210 metadata.SetUserID (MakeUserID(die->GetOffset())); 2211 delayed_properties.push_back(DelayedAddObjCClassProperty(class_clang_type, 2212 prop_name, 2213 member_type->GetClangLayoutType(), 2214 ivar_decl, 2215 prop_setter_name, 2216 prop_getter_name, 2217 prop_attributes, 2218 &metadata)); 2219 2220 if (ivar_decl) 2221 GetClangASTContext().SetMetadataAsUserID (ivar_decl, MakeUserID(die->GetOffset())); 2222 } 2223 } 2224 } 2225 ++member_idx; 2226 } 2227 break; 2228 2229 case DW_TAG_subprogram: 2230 // Let the type parsing code handle this one for us. 2231 member_function_dies.Append (die); 2232 break; 2233 2234 case DW_TAG_inheritance: 2235 { 2236 is_a_class = true; 2237 if (default_accessibility == eAccessNone) 2238 default_accessibility = eAccessPrivate; 2239 // TODO: implement DW_TAG_inheritance type parsing 2240 DWARFDebugInfoEntry::Attributes attributes; 2241 const size_t num_attributes = die->GetAttributes (this, 2242 dwarf_cu, 2243 fixed_form_sizes, 2244 attributes); 2245 if (num_attributes > 0) 2246 { 2247 Declaration decl; 2248 DWARFExpression location; 2249 lldb::user_id_t encoding_uid = LLDB_INVALID_UID; 2250 AccessType accessibility = default_accessibility; 2251 bool is_virtual = false; 2252 bool is_base_of_class = true; 2253 off_t member_byte_offset = 0; 2254 uint32_t i; 2255 for (i=0; i<num_attributes; ++i) 2256 { 2257 const dw_attr_t attr = attributes.AttributeAtIndex(i); 2258 DWARFFormValue form_value; 2259 if (attributes.ExtractFormValueAtIndex(this, i, form_value)) 2260 { 2261 switch (attr) 2262 { 2263 case DW_AT_decl_file: decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned())); break; 2264 case DW_AT_decl_line: decl.SetLine(form_value.Unsigned()); break; 2265 case DW_AT_decl_column: decl.SetColumn(form_value.Unsigned()); break; 2266 case DW_AT_type: encoding_uid = form_value.Reference(); break; 2267 case DW_AT_data_member_location: 2268 if (form_value.BlockData()) 2269 { 2270 Value initialValue(0); 2271 Value memberOffset(0); 2272 const DWARFDataExtractor& debug_info_data = get_debug_info_data(); 2273 uint32_t block_length = form_value.Unsigned(); 2274 uint32_t block_offset = form_value.BlockData() - debug_info_data.GetDataStart(); 2275 if (DWARFExpression::Evaluate (NULL, 2276 NULL, 2277 NULL, 2278 NULL, 2279 module, 2280 debug_info_data, 2281 block_offset, 2282 block_length, 2283 eRegisterKindDWARF, 2284 &initialValue, 2285 memberOffset, 2286 NULL)) 2287 { 2288 member_byte_offset = memberOffset.ResolveValue(NULL).UInt(); 2289 } 2290 } 2291 else 2292 { 2293 // With DWARF 3 and later, if the value is an integer constant, 2294 // this form value is the offset in bytes from the beginning 2295 // of the containing entity. 2296 member_byte_offset = form_value.Unsigned(); 2297 } 2298 break; 2299 2300 case DW_AT_accessibility: 2301 accessibility = DW_ACCESS_to_AccessType(form_value.Unsigned()); 2302 break; 2303 2304 case DW_AT_virtuality: 2305 is_virtual = form_value.Boolean(); 2306 break; 2307 2308 case DW_AT_sibling: 2309 break; 2310 2311 default: 2312 break; 2313 } 2314 } 2315 } 2316 2317 Type *base_class_type = ResolveTypeUID(encoding_uid); 2318 if (base_class_type == NULL) 2319 { 2320 GetObjectFile()->GetModule()->ReportError("0x%8.8x: DW_TAG_inheritance failed to resolve the base class at 0x%8.8" PRIx64 " from enclosing type 0x%8.8x. \nPlease file a bug and attach the file at the start of this error message", 2321 die->GetOffset(), 2322 encoding_uid, 2323 parent_die->GetOffset()); 2324 break; 2325 } 2326 2327 ClangASTType base_class_clang_type = base_class_type->GetClangFullType(); 2328 assert (base_class_clang_type); 2329 if (class_language == eLanguageTypeObjC) 2330 { 2331 class_clang_type.SetObjCSuperClass(base_class_clang_type); 2332 } 2333 else 2334 { 2335 base_classes.push_back (base_class_clang_type.CreateBaseClassSpecifier (accessibility, 2336 is_virtual, 2337 is_base_of_class)); 2338 2339 if (is_virtual) 2340 { 2341 // Do not specify any offset for virtual inheritance. The DWARF produced by clang doesn't 2342 // give us a constant offset, but gives us a DWARF expressions that requires an actual object 2343 // in memory. the DW_AT_data_member_location for a virtual base class looks like: 2344 // DW_AT_data_member_location( DW_OP_dup, DW_OP_deref, DW_OP_constu(0x00000018), DW_OP_minus, DW_OP_deref, DW_OP_plus ) 2345 // Given this, there is really no valid response we can give to clang for virtual base 2346 // class offsets, and this should eventually be removed from LayoutRecordType() in the external 2347 // AST source in clang. 2348 } 2349 else 2350 { 2351 layout_info.base_offsets.insert( 2352 std::make_pair(base_class_clang_type.GetAsCXXRecordDecl(), 2353 clang::CharUnits::fromQuantity(member_byte_offset))); 2354 } 2355 } 2356 } 2357 } 2358 break; 2359 2360 default: 2361 break; 2362 } 2363 } 2364 2365 return count; 2366 } 2367 2368 2369 clang::DeclContext* 2370 SymbolFileDWARF::GetClangDeclContextContainingTypeUID (lldb::user_id_t type_uid) 2371 { 2372 DWARFDebugInfo* debug_info = DebugInfo(); 2373 if (debug_info && UserIDMatches(type_uid)) 2374 { 2375 DWARFCompileUnitSP cu_sp; 2376 const DWARFDebugInfoEntry* die = debug_info->GetDIEPtr(type_uid, &cu_sp); 2377 if (die) 2378 return GetClangDeclContextContainingDIE (cu_sp.get(), die, NULL); 2379 } 2380 return NULL; 2381 } 2382 2383 clang::DeclContext* 2384 SymbolFileDWARF::GetClangDeclContextForTypeUID (const lldb_private::SymbolContext &sc, lldb::user_id_t type_uid) 2385 { 2386 if (UserIDMatches(type_uid)) 2387 return GetClangDeclContextForDIEOffset (sc, type_uid); 2388 return NULL; 2389 } 2390 2391 Type* 2392 SymbolFileDWARF::ResolveTypeUID (lldb::user_id_t type_uid) 2393 { 2394 if (UserIDMatches(type_uid)) 2395 { 2396 DWARFDebugInfo* debug_info = DebugInfo(); 2397 if (debug_info) 2398 { 2399 DWARFCompileUnitSP cu_sp; 2400 const DWARFDebugInfoEntry* type_die = debug_info->GetDIEPtr(type_uid, &cu_sp); 2401 const bool assert_not_being_parsed = true; 2402 return ResolveTypeUID (cu_sp.get(), type_die, assert_not_being_parsed); 2403 } 2404 } 2405 return NULL; 2406 } 2407 2408 Type* 2409 SymbolFileDWARF::ResolveTypeUID (DWARFCompileUnit* cu, const DWARFDebugInfoEntry* die, bool assert_not_being_parsed) 2410 { 2411 if (die != NULL) 2412 { 2413 Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO)); 2414 if (log) 2415 GetObjectFile()->GetModule()->LogMessage (log, 2416 "SymbolFileDWARF::ResolveTypeUID (die = 0x%8.8x) %s '%s'", 2417 die->GetOffset(), 2418 DW_TAG_value_to_name(die->Tag()), 2419 die->GetName(this, cu)); 2420 2421 // We might be coming in in the middle of a type tree (a class 2422 // withing a class, an enum within a class), so parse any needed 2423 // parent DIEs before we get to this one... 2424 const DWARFDebugInfoEntry *decl_ctx_die = GetDeclContextDIEContainingDIE (cu, die); 2425 switch (decl_ctx_die->Tag()) 2426 { 2427 case DW_TAG_structure_type: 2428 case DW_TAG_union_type: 2429 case DW_TAG_class_type: 2430 { 2431 // Get the type, which could be a forward declaration 2432 if (log) 2433 GetObjectFile()->GetModule()->LogMessage (log, 2434 "SymbolFileDWARF::ResolveTypeUID (die = 0x%8.8x) %s '%s' resolve parent forward type for 0x%8.8x", 2435 die->GetOffset(), 2436 DW_TAG_value_to_name(die->Tag()), 2437 die->GetName(this, cu), 2438 decl_ctx_die->GetOffset()); 2439 // 2440 // Type *parent_type = ResolveTypeUID (cu, decl_ctx_die, assert_not_being_parsed); 2441 // if (child_requires_parent_class_union_or_struct_to_be_completed(die->Tag())) 2442 // { 2443 // if (log) 2444 // GetObjectFile()->GetModule()->LogMessage (log, 2445 // "SymbolFileDWARF::ResolveTypeUID (die = 0x%8.8x) %s '%s' resolve parent full type for 0x%8.8x since die is a function", 2446 // die->GetOffset(), 2447 // DW_TAG_value_to_name(die->Tag()), 2448 // die->GetName(this, cu), 2449 // decl_ctx_die->GetOffset()); 2450 // // Ask the type to complete itself if it already hasn't since if we 2451 // // want a function (method or static) from a class, the class must 2452 // // create itself and add it's own methods and class functions. 2453 // if (parent_type) 2454 // parent_type->GetClangFullType(); 2455 // } 2456 } 2457 break; 2458 2459 default: 2460 break; 2461 } 2462 return ResolveType (cu, die); 2463 } 2464 return NULL; 2465 } 2466 2467 // This function is used when SymbolFileDWARFDebugMap owns a bunch of 2468 // SymbolFileDWARF objects to detect if this DWARF file is the one that 2469 // can resolve a clang_type. 2470 bool 2471 SymbolFileDWARF::HasForwardDeclForClangType (const ClangASTType &clang_type) 2472 { 2473 ClangASTType clang_type_no_qualifiers = clang_type.RemoveFastQualifiers(); 2474 const DWARFDebugInfoEntry* die = m_forward_decl_clang_type_to_die.lookup (clang_type_no_qualifiers.GetOpaqueQualType()); 2475 return die != NULL; 2476 } 2477 2478 2479 bool 2480 SymbolFileDWARF::ResolveClangOpaqueTypeDefinition (ClangASTType &clang_type) 2481 { 2482 // We have a struct/union/class/enum that needs to be fully resolved. 2483 ClangASTType clang_type_no_qualifiers = clang_type.RemoveFastQualifiers(); 2484 const DWARFDebugInfoEntry* die = m_forward_decl_clang_type_to_die.lookup (clang_type_no_qualifiers.GetOpaqueQualType()); 2485 if (die == NULL) 2486 { 2487 // We have already resolved this type... 2488 return true; 2489 } 2490 // Once we start resolving this type, remove it from the forward declaration 2491 // map in case anyone child members or other types require this type to get resolved. 2492 // The type will get resolved when all of the calls to SymbolFileDWARF::ResolveClangOpaqueTypeDefinition 2493 // are done. 2494 m_forward_decl_clang_type_to_die.erase (clang_type_no_qualifiers.GetOpaqueQualType()); 2495 2496 // Disable external storage for this type so we don't get anymore 2497 // clang::ExternalASTSource queries for this type. 2498 clang_type.SetHasExternalStorage (false); 2499 2500 DWARFDebugInfo* debug_info = DebugInfo(); 2501 2502 DWARFCompileUnit *dwarf_cu = debug_info->GetCompileUnitContainingDIE (die->GetOffset()).get(); 2503 Type *type = m_die_to_type.lookup (die); 2504 2505 const dw_tag_t tag = die->Tag(); 2506 2507 Log *log (LogChannelDWARF::GetLogIfAny(DWARF_LOG_DEBUG_INFO|DWARF_LOG_TYPE_COMPLETION)); 2508 if (log) 2509 GetObjectFile()->GetModule()->LogMessageVerboseBacktrace (log, 2510 "0x%8.8" PRIx64 ": %s '%s' resolving forward declaration...", 2511 MakeUserID(die->GetOffset()), 2512 DW_TAG_value_to_name(tag), 2513 type->GetName().AsCString()); 2514 assert (clang_type); 2515 DWARFDebugInfoEntry::Attributes attributes; 2516 2517 switch (tag) 2518 { 2519 case DW_TAG_structure_type: 2520 case DW_TAG_union_type: 2521 case DW_TAG_class_type: 2522 { 2523 LayoutInfo layout_info; 2524 2525 { 2526 if (die->HasChildren()) 2527 { 2528 LanguageType class_language = eLanguageTypeUnknown; 2529 if (clang_type.IsObjCObjectOrInterfaceType()) 2530 { 2531 class_language = eLanguageTypeObjC; 2532 // For objective C we don't start the definition when 2533 // the class is created. 2534 clang_type.StartTagDeclarationDefinition (); 2535 } 2536 2537 int tag_decl_kind = -1; 2538 AccessType default_accessibility = eAccessNone; 2539 if (tag == DW_TAG_structure_type) 2540 { 2541 tag_decl_kind = clang::TTK_Struct; 2542 default_accessibility = eAccessPublic; 2543 } 2544 else if (tag == DW_TAG_union_type) 2545 { 2546 tag_decl_kind = clang::TTK_Union; 2547 default_accessibility = eAccessPublic; 2548 } 2549 else if (tag == DW_TAG_class_type) 2550 { 2551 tag_decl_kind = clang::TTK_Class; 2552 default_accessibility = eAccessPrivate; 2553 } 2554 2555 SymbolContext sc(GetCompUnitForDWARFCompUnit(dwarf_cu)); 2556 std::vector<clang::CXXBaseSpecifier *> base_classes; 2557 std::vector<int> member_accessibilities; 2558 bool is_a_class = false; 2559 // Parse members and base classes first 2560 DWARFDIECollection member_function_dies; 2561 2562 DelayedPropertyList delayed_properties; 2563 ParseChildMembers (sc, 2564 dwarf_cu, 2565 die, 2566 clang_type, 2567 class_language, 2568 base_classes, 2569 member_accessibilities, 2570 member_function_dies, 2571 delayed_properties, 2572 default_accessibility, 2573 is_a_class, 2574 layout_info); 2575 2576 // Now parse any methods if there were any... 2577 size_t num_functions = member_function_dies.Size(); 2578 if (num_functions > 0) 2579 { 2580 for (size_t i=0; i<num_functions; ++i) 2581 { 2582 ResolveType(dwarf_cu, member_function_dies.GetDIEPtrAtIndex(i)); 2583 } 2584 } 2585 2586 if (class_language == eLanguageTypeObjC) 2587 { 2588 ConstString class_name (clang_type.GetTypeName()); 2589 if (class_name) 2590 { 2591 DIEArray method_die_offsets; 2592 if (m_using_apple_tables) 2593 { 2594 if (m_apple_objc_ap.get()) 2595 m_apple_objc_ap->FindByName(class_name.GetCString(), method_die_offsets); 2596 } 2597 else 2598 { 2599 if (!m_indexed) 2600 Index (); 2601 2602 m_objc_class_selectors_index.Find (class_name, method_die_offsets); 2603 } 2604 2605 if (!method_die_offsets.empty()) 2606 { 2607 DWARFDebugInfo* debug_info = DebugInfo(); 2608 2609 DWARFCompileUnit* method_cu = NULL; 2610 const size_t num_matches = method_die_offsets.size(); 2611 for (size_t i=0; i<num_matches; ++i) 2612 { 2613 const dw_offset_t die_offset = method_die_offsets[i]; 2614 DWARFDebugInfoEntry *method_die = debug_info->GetDIEPtrWithCompileUnitHint (die_offset, &method_cu); 2615 2616 if (method_die) 2617 ResolveType (method_cu, method_die); 2618 else 2619 { 2620 if (m_using_apple_tables) 2621 { 2622 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_objc accelerator table had bad die 0x%8.8x for '%s')\n", 2623 die_offset, class_name.GetCString()); 2624 } 2625 } 2626 } 2627 } 2628 2629 for (DelayedPropertyList::iterator pi = delayed_properties.begin(), pe = delayed_properties.end(); 2630 pi != pe; 2631 ++pi) 2632 pi->Finalize(); 2633 } 2634 } 2635 2636 // If we have a DW_TAG_structure_type instead of a DW_TAG_class_type we 2637 // need to tell the clang type it is actually a class. 2638 if (class_language != eLanguageTypeObjC) 2639 { 2640 if (is_a_class && tag_decl_kind != clang::TTK_Class) 2641 clang_type.SetTagTypeKind (clang::TTK_Class); 2642 } 2643 2644 // Since DW_TAG_structure_type gets used for both classes 2645 // and structures, we may need to set any DW_TAG_member 2646 // fields to have a "private" access if none was specified. 2647 // When we parsed the child members we tracked that actual 2648 // accessibility value for each DW_TAG_member in the 2649 // "member_accessibilities" array. If the value for the 2650 // member is zero, then it was set to the "default_accessibility" 2651 // which for structs was "public". Below we correct this 2652 // by setting any fields to "private" that weren't correctly 2653 // set. 2654 if (is_a_class && !member_accessibilities.empty()) 2655 { 2656 // This is a class and all members that didn't have 2657 // their access specified are private. 2658 clang_type.SetDefaultAccessForRecordFields (eAccessPrivate, 2659 &member_accessibilities.front(), 2660 member_accessibilities.size()); 2661 } 2662 2663 if (!base_classes.empty()) 2664 { 2665 // Make sure all base classes refer to complete types and not 2666 // forward declarations. If we don't do this, clang will crash 2667 // with an assertion in the call to clang_type.SetBaseClassesForClassType() 2668 bool base_class_error = false; 2669 for (auto &base_class : base_classes) 2670 { 2671 clang::TypeSourceInfo *type_source_info = base_class->getTypeSourceInfo(); 2672 if (type_source_info) 2673 { 2674 ClangASTType base_class_type (GetClangASTContext().getASTContext(), type_source_info->getType()); 2675 if (base_class_type.GetCompleteType() == false) 2676 { 2677 if (!base_class_error) 2678 { 2679 GetObjectFile()->GetModule()->ReportError ("DWARF DIE at 0x%8.8x for class '%s' has a base class '%s' that is a forward declaration, not a complete definition.\nPlease file a bug against the compiler and include the preprocessed output for %s", 2680 die->GetOffset(), 2681 die->GetName(this, dwarf_cu), 2682 base_class_type.GetTypeName().GetCString(), 2683 sc.comp_unit ? sc.comp_unit->GetPath().c_str() : "the source file"); 2684 } 2685 // We have no choice other than to pretend that the base class 2686 // is complete. If we don't do this, clang will crash when we 2687 // call setBases() inside of "clang_type.SetBaseClassesForClassType()" 2688 // below. Since we provide layout assistance, all ivars in this 2689 // class and other classes will be fine, this is the best we can do 2690 // short of crashing. 2691 base_class_type.StartTagDeclarationDefinition (); 2692 base_class_type.CompleteTagDeclarationDefinition (); 2693 } 2694 } 2695 } 2696 clang_type.SetBaseClassesForClassType (&base_classes.front(), 2697 base_classes.size()); 2698 2699 // Clang will copy each CXXBaseSpecifier in "base_classes" 2700 // so we have to free them all. 2701 ClangASTType::DeleteBaseClassSpecifiers (&base_classes.front(), 2702 base_classes.size()); 2703 } 2704 } 2705 } 2706 2707 clang_type.BuildIndirectFields (); 2708 clang_type.CompleteTagDeclarationDefinition (); 2709 2710 if (!layout_info.field_offsets.empty() || 2711 !layout_info.base_offsets.empty() || 2712 !layout_info.vbase_offsets.empty() ) 2713 { 2714 if (type) 2715 layout_info.bit_size = type->GetByteSize() * 8; 2716 if (layout_info.bit_size == 0) 2717 layout_info.bit_size = die->GetAttributeValueAsUnsigned(this, dwarf_cu, DW_AT_byte_size, 0) * 8; 2718 2719 clang::CXXRecordDecl *record_decl = clang_type.GetAsCXXRecordDecl(); 2720 if (record_decl) 2721 { 2722 if (log) 2723 { 2724 GetObjectFile()->GetModule()->LogMessage (log, 2725 "SymbolFileDWARF::ResolveClangOpaqueTypeDefinition (clang_type = %p) caching layout info for record_decl = %p, bit_size = %" PRIu64 ", alignment = %" PRIu64 ", field_offsets[%u], base_offsets[%u], vbase_offsets[%u])", 2726 static_cast<void*>(clang_type.GetOpaqueQualType()), 2727 static_cast<void*>(record_decl), 2728 layout_info.bit_size, 2729 layout_info.alignment, 2730 static_cast<uint32_t>(layout_info.field_offsets.size()), 2731 static_cast<uint32_t>(layout_info.base_offsets.size()), 2732 static_cast<uint32_t>(layout_info.vbase_offsets.size())); 2733 2734 uint32_t idx; 2735 { 2736 llvm::DenseMap<const clang::FieldDecl *, uint64_t>::const_iterator pos, 2737 end = layout_info.field_offsets.end(); 2738 for (idx = 0, pos = layout_info.field_offsets.begin(); pos != end; ++pos, ++idx) 2739 { 2740 GetObjectFile()->GetModule()->LogMessage( 2741 log, "SymbolFileDWARF::ResolveClangOpaqueTypeDefinition (clang_type = %p) field[%u] = " 2742 "{ bit_offset=%u, name='%s' }", 2743 static_cast<void *>(clang_type.GetOpaqueQualType()), idx, 2744 static_cast<uint32_t>(pos->second), pos->first->getNameAsString().c_str()); 2745 } 2746 } 2747 2748 { 2749 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>::const_iterator base_pos, 2750 base_end = layout_info.base_offsets.end(); 2751 for (idx = 0, base_pos = layout_info.base_offsets.begin(); base_pos != base_end; 2752 ++base_pos, ++idx) 2753 { 2754 GetObjectFile()->GetModule()->LogMessage( 2755 log, "SymbolFileDWARF::ResolveClangOpaqueTypeDefinition (clang_type = %p) base[%u] " 2756 "= { byte_offset=%u, name='%s' }", 2757 clang_type.GetOpaqueQualType(), idx, (uint32_t)base_pos->second.getQuantity(), 2758 base_pos->first->getNameAsString().c_str()); 2759 } 2760 } 2761 { 2762 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>::const_iterator vbase_pos, 2763 vbase_end = layout_info.vbase_offsets.end(); 2764 for (idx = 0, vbase_pos = layout_info.vbase_offsets.begin(); vbase_pos != vbase_end; 2765 ++vbase_pos, ++idx) 2766 { 2767 GetObjectFile()->GetModule()->LogMessage( 2768 log, "SymbolFileDWARF::ResolveClangOpaqueTypeDefinition (clang_type = %p) " 2769 "vbase[%u] = { byte_offset=%u, name='%s' }", 2770 static_cast<void *>(clang_type.GetOpaqueQualType()), idx, 2771 static_cast<uint32_t>(vbase_pos->second.getQuantity()), 2772 vbase_pos->first->getNameAsString().c_str()); 2773 } 2774 } 2775 } 2776 m_record_decl_to_layout_map.insert(std::make_pair(record_decl, layout_info)); 2777 } 2778 } 2779 } 2780 2781 return (bool)clang_type; 2782 2783 case DW_TAG_enumeration_type: 2784 clang_type.StartTagDeclarationDefinition (); 2785 if (die->HasChildren()) 2786 { 2787 SymbolContext sc(GetCompUnitForDWARFCompUnit(dwarf_cu)); 2788 bool is_signed = false; 2789 clang_type.IsIntegerType(is_signed); 2790 ParseChildEnumerators(sc, clang_type, is_signed, type->GetByteSize(), dwarf_cu, die); 2791 } 2792 clang_type.CompleteTagDeclarationDefinition (); 2793 return (bool)clang_type; 2794 2795 default: 2796 assert(false && "not a forward clang type decl!"); 2797 break; 2798 } 2799 return false; 2800 } 2801 2802 Type* 2803 SymbolFileDWARF::ResolveType (DWARFCompileUnit* dwarf_cu, const DWARFDebugInfoEntry* type_die, bool assert_not_being_parsed) 2804 { 2805 if (type_die != NULL) 2806 { 2807 Type *type = m_die_to_type.lookup (type_die); 2808 2809 if (type == NULL) 2810 type = GetTypeForDIE (dwarf_cu, type_die).get(); 2811 2812 if (assert_not_being_parsed) 2813 { 2814 if (type != DIE_IS_BEING_PARSED) 2815 return type; 2816 2817 GetObjectFile()->GetModule()->ReportError ("Parsing a die that is being parsed die: 0x%8.8x: %s %s", 2818 type_die->GetOffset(), 2819 DW_TAG_value_to_name(type_die->Tag()), 2820 type_die->GetName(this, dwarf_cu)); 2821 2822 } 2823 else 2824 return type; 2825 } 2826 return NULL; 2827 } 2828 2829 CompileUnit* 2830 SymbolFileDWARF::GetCompUnitForDWARFCompUnit (DWARFCompileUnit* dwarf_cu, uint32_t cu_idx) 2831 { 2832 // Check if the symbol vendor already knows about this compile unit? 2833 if (dwarf_cu->GetUserData() == NULL) 2834 { 2835 // The symbol vendor doesn't know about this compile unit, we 2836 // need to parse and add it to the symbol vendor object. 2837 return ParseCompileUnit(dwarf_cu, cu_idx).get(); 2838 } 2839 return (CompileUnit*)dwarf_cu->GetUserData(); 2840 } 2841 2842 bool 2843 SymbolFileDWARF::GetFunction (DWARFCompileUnit* dwarf_cu, const DWARFDebugInfoEntry* func_die, SymbolContext& sc) 2844 { 2845 sc.Clear(false); 2846 // Check if the symbol vendor already knows about this compile unit? 2847 sc.comp_unit = GetCompUnitForDWARFCompUnit(dwarf_cu, UINT32_MAX); 2848 2849 sc.function = sc.comp_unit->FindFunctionByUID (MakeUserID(func_die->GetOffset())).get(); 2850 if (sc.function == NULL) 2851 sc.function = ParseCompileUnitFunction(sc, dwarf_cu, func_die); 2852 2853 if (sc.function) 2854 { 2855 sc.module_sp = sc.function->CalculateSymbolContextModule(); 2856 return true; 2857 } 2858 2859 return false; 2860 } 2861 2862 void 2863 SymbolFileDWARF::UpdateExternalModuleListIfNeeded() 2864 { 2865 if (m_fetched_external_modules) 2866 return; 2867 m_fetched_external_modules = true; 2868 2869 DWARFDebugInfo * debug_info = DebugInfo(); 2870 debug_info->GetNumCompileUnits(); 2871 2872 const uint32_t num_compile_units = GetNumCompileUnits(); 2873 for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) 2874 { 2875 DWARFCompileUnit* dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx); 2876 2877 const DWARFDebugInfoEntry *die = dwarf_cu->GetCompileUnitDIEOnly(); 2878 if (die && die->HasChildren() == false) 2879 { 2880 const uint64_t name_strp = die->GetAttributeValueAsUnsigned(this, dwarf_cu, DW_AT_name, UINT64_MAX); 2881 const uint64_t dwo_path_strp = die->GetAttributeValueAsUnsigned(this, dwarf_cu, DW_AT_GNU_dwo_name, UINT64_MAX); 2882 2883 if (name_strp != UINT64_MAX) 2884 { 2885 if (m_external_type_modules.find(dwo_path_strp) == m_external_type_modules.end()) 2886 { 2887 const char *name = get_debug_str_data().PeekCStr(name_strp); 2888 const char *dwo_path = get_debug_str_data().PeekCStr(dwo_path_strp); 2889 if (name || dwo_path) 2890 { 2891 ModuleSP module_sp; 2892 if (dwo_path) 2893 { 2894 ModuleSpec dwo_module_spec; 2895 dwo_module_spec.GetFileSpec().SetFile(dwo_path, false); 2896 dwo_module_spec.GetArchitecture() = m_obj_file->GetModule()->GetArchitecture(); 2897 //printf ("Loading dwo = '%s'\n", dwo_path); 2898 Error error = ModuleList::GetSharedModule (dwo_module_spec, module_sp, NULL, NULL, NULL); 2899 } 2900 2901 if (dwo_path_strp != LLDB_INVALID_UID) 2902 { 2903 m_external_type_modules[dwo_path_strp] = ClangModuleInfo { ConstString(name), module_sp }; 2904 } 2905 else 2906 { 2907 // This hack should be removed promptly once clang emits both. 2908 m_external_type_modules[name_strp] = ClangModuleInfo { ConstString(name), module_sp }; 2909 } 2910 } 2911 } 2912 } 2913 } 2914 } 2915 } 2916 2917 SymbolFileDWARF::GlobalVariableMap & 2918 SymbolFileDWARF::GetGlobalAranges() 2919 { 2920 if (!m_global_aranges_ap) 2921 { 2922 m_global_aranges_ap.reset (new GlobalVariableMap()); 2923 2924 ModuleSP module_sp = GetObjectFile()->GetModule(); 2925 if (module_sp) 2926 { 2927 const size_t num_cus = module_sp->GetNumCompileUnits(); 2928 for (size_t i = 0; i < num_cus; ++i) 2929 { 2930 CompUnitSP cu_sp = module_sp->GetCompileUnitAtIndex(i); 2931 if (cu_sp) 2932 { 2933 VariableListSP globals_sp = cu_sp->GetVariableList(true); 2934 if (globals_sp) 2935 { 2936 const size_t num_globals = globals_sp->GetSize(); 2937 for (size_t g = 0; g < num_globals; ++g) 2938 { 2939 VariableSP var_sp = globals_sp->GetVariableAtIndex(g); 2940 if (var_sp && !var_sp->GetLocationIsConstantValueData()) 2941 { 2942 const DWARFExpression &location = var_sp->LocationExpression(); 2943 Value location_result; 2944 Error error; 2945 if (location.Evaluate(NULL, NULL, NULL, LLDB_INVALID_ADDRESS, NULL, location_result, &error)) 2946 { 2947 if (location_result.GetValueType() == Value::eValueTypeFileAddress) 2948 { 2949 lldb::addr_t file_addr = location_result.GetScalar().ULongLong(); 2950 lldb::addr_t byte_size = 1; 2951 if (var_sp->GetType()) 2952 byte_size = var_sp->GetType()->GetByteSize(); 2953 m_global_aranges_ap->Append(GlobalVariableMap::Entry(file_addr, byte_size, var_sp.get())); 2954 } 2955 } 2956 } 2957 } 2958 } 2959 } 2960 } 2961 } 2962 m_global_aranges_ap->Sort(); 2963 } 2964 return *m_global_aranges_ap; 2965 } 2966 2967 2968 uint32_t 2969 SymbolFileDWARF::ResolveSymbolContext (const Address& so_addr, uint32_t resolve_scope, SymbolContext& sc) 2970 { 2971 Timer scoped_timer(__PRETTY_FUNCTION__, 2972 "SymbolFileDWARF::ResolveSymbolContext (so_addr = { section = %p, offset = 0x%" PRIx64 " }, resolve_scope = 0x%8.8x)", 2973 static_cast<void*>(so_addr.GetSection().get()), 2974 so_addr.GetOffset(), resolve_scope); 2975 uint32_t resolved = 0; 2976 if (resolve_scope & ( eSymbolContextCompUnit | 2977 eSymbolContextFunction | 2978 eSymbolContextBlock | 2979 eSymbolContextLineEntry | 2980 eSymbolContextVariable )) 2981 { 2982 lldb::addr_t file_vm_addr = so_addr.GetFileAddress(); 2983 2984 DWARFDebugInfo* debug_info = DebugInfo(); 2985 if (debug_info) 2986 { 2987 const dw_offset_t cu_offset = debug_info->GetCompileUnitAranges().FindAddress(file_vm_addr); 2988 if (cu_offset == DW_INVALID_OFFSET) 2989 { 2990 // Global variables are not in the compile unit address ranges. The only way to 2991 // currently find global variables is to iterate over the .debug_pubnames or the 2992 // __apple_names table and find all items in there that point to DW_TAG_variable 2993 // DIEs and then find the address that matches. 2994 if (resolve_scope & eSymbolContextVariable) 2995 { 2996 GlobalVariableMap &map = GetGlobalAranges(); 2997 const GlobalVariableMap::Entry *entry = map.FindEntryThatContains(file_vm_addr); 2998 if (entry && entry->data) 2999 { 3000 Variable *variable = entry->data; 3001 SymbolContextScope *scc = variable->GetSymbolContextScope(); 3002 if (scc) 3003 { 3004 scc->CalculateSymbolContext(&sc); 3005 sc.variable = variable; 3006 } 3007 return sc.GetResolvedMask(); 3008 } 3009 } 3010 } 3011 else 3012 { 3013 uint32_t cu_idx = DW_INVALID_INDEX; 3014 DWARFCompileUnit* dwarf_cu = debug_info->GetCompileUnit(cu_offset, &cu_idx).get(); 3015 if (dwarf_cu) 3016 { 3017 sc.comp_unit = GetCompUnitForDWARFCompUnit(dwarf_cu, cu_idx); 3018 if (sc.comp_unit) 3019 { 3020 resolved |= eSymbolContextCompUnit; 3021 3022 bool force_check_line_table = false; 3023 if (resolve_scope & (eSymbolContextFunction | eSymbolContextBlock)) 3024 { 3025 DWARFDebugInfoEntry *function_die = NULL; 3026 DWARFDebugInfoEntry *block_die = NULL; 3027 if (resolve_scope & eSymbolContextBlock) 3028 { 3029 dwarf_cu->LookupAddress(file_vm_addr, &function_die, &block_die); 3030 } 3031 else 3032 { 3033 dwarf_cu->LookupAddress(file_vm_addr, &function_die, NULL); 3034 } 3035 3036 if (function_die != NULL) 3037 { 3038 sc.function = sc.comp_unit->FindFunctionByUID (MakeUserID(function_die->GetOffset())).get(); 3039 if (sc.function == NULL) 3040 sc.function = ParseCompileUnitFunction(sc, dwarf_cu, function_die); 3041 } 3042 else 3043 { 3044 // We might have had a compile unit that had discontiguous 3045 // address ranges where the gaps are symbols that don't have 3046 // any debug info. Discontiguous compile unit address ranges 3047 // should only happen when there aren't other functions from 3048 // other compile units in these gaps. This helps keep the size 3049 // of the aranges down. 3050 force_check_line_table = true; 3051 } 3052 3053 if (sc.function != NULL) 3054 { 3055 resolved |= eSymbolContextFunction; 3056 3057 if (resolve_scope & eSymbolContextBlock) 3058 { 3059 Block& block = sc.function->GetBlock (true); 3060 3061 if (block_die != NULL) 3062 sc.block = block.FindBlockByID (MakeUserID(block_die->GetOffset())); 3063 else 3064 sc.block = block.FindBlockByID (MakeUserID(function_die->GetOffset())); 3065 if (sc.block) 3066 resolved |= eSymbolContextBlock; 3067 } 3068 } 3069 } 3070 3071 if ((resolve_scope & eSymbolContextLineEntry) || force_check_line_table) 3072 { 3073 LineTable *line_table = sc.comp_unit->GetLineTable(); 3074 if (line_table != NULL) 3075 { 3076 // And address that makes it into this function should be in terms 3077 // of this debug file if there is no debug map, or it will be an 3078 // address in the .o file which needs to be fixed up to be in terms 3079 // of the debug map executable. Either way, calling FixupAddress() 3080 // will work for us. 3081 Address exe_so_addr (so_addr); 3082 if (FixupAddress(exe_so_addr)) 3083 { 3084 if (line_table->FindLineEntryByAddress (exe_so_addr, sc.line_entry)) 3085 { 3086 resolved |= eSymbolContextLineEntry; 3087 } 3088 } 3089 } 3090 } 3091 3092 if (force_check_line_table && !(resolved & eSymbolContextLineEntry)) 3093 { 3094 // We might have had a compile unit that had discontiguous 3095 // address ranges where the gaps are symbols that don't have 3096 // any debug info. Discontiguous compile unit address ranges 3097 // should only happen when there aren't other functions from 3098 // other compile units in these gaps. This helps keep the size 3099 // of the aranges down. 3100 sc.comp_unit = NULL; 3101 resolved &= ~eSymbolContextCompUnit; 3102 } 3103 } 3104 else 3105 { 3106 GetObjectFile()->GetModule()->ReportWarning ("0x%8.8x: compile unit %u failed to create a valid lldb_private::CompileUnit class.", 3107 cu_offset, 3108 cu_idx); 3109 } 3110 } 3111 } 3112 } 3113 } 3114 return resolved; 3115 } 3116 3117 3118 3119 uint32_t 3120 SymbolFileDWARF::ResolveSymbolContext(const FileSpec& file_spec, uint32_t line, bool check_inlines, uint32_t resolve_scope, SymbolContextList& sc_list) 3121 { 3122 const uint32_t prev_size = sc_list.GetSize(); 3123 if (resolve_scope & eSymbolContextCompUnit) 3124 { 3125 DWARFDebugInfo* debug_info = DebugInfo(); 3126 if (debug_info) 3127 { 3128 uint32_t cu_idx; 3129 DWARFCompileUnit* dwarf_cu = NULL; 3130 3131 for (cu_idx = 0; (dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx)) != NULL; ++cu_idx) 3132 { 3133 CompileUnit *dc_cu = GetCompUnitForDWARFCompUnit(dwarf_cu, cu_idx); 3134 const bool full_match = (bool)file_spec.GetDirectory(); 3135 bool file_spec_matches_cu_file_spec = dc_cu != NULL && FileSpec::Equal(file_spec, *dc_cu, full_match); 3136 if (check_inlines || file_spec_matches_cu_file_spec) 3137 { 3138 SymbolContext sc (m_obj_file->GetModule()); 3139 sc.comp_unit = GetCompUnitForDWARFCompUnit(dwarf_cu, cu_idx); 3140 if (sc.comp_unit) 3141 { 3142 uint32_t file_idx = UINT32_MAX; 3143 3144 // If we are looking for inline functions only and we don't 3145 // find it in the support files, we are done. 3146 if (check_inlines) 3147 { 3148 file_idx = sc.comp_unit->GetSupportFiles().FindFileIndex (1, file_spec, true); 3149 if (file_idx == UINT32_MAX) 3150 continue; 3151 } 3152 3153 if (line != 0) 3154 { 3155 LineTable *line_table = sc.comp_unit->GetLineTable(); 3156 3157 if (line_table != NULL && line != 0) 3158 { 3159 // We will have already looked up the file index if 3160 // we are searching for inline entries. 3161 if (!check_inlines) 3162 file_idx = sc.comp_unit->GetSupportFiles().FindFileIndex (1, file_spec, true); 3163 3164 if (file_idx != UINT32_MAX) 3165 { 3166 uint32_t found_line; 3167 uint32_t line_idx = line_table->FindLineEntryIndexByFileIndex (0, file_idx, line, false, &sc.line_entry); 3168 found_line = sc.line_entry.line; 3169 3170 while (line_idx != UINT32_MAX) 3171 { 3172 sc.function = NULL; 3173 sc.block = NULL; 3174 if (resolve_scope & (eSymbolContextFunction | eSymbolContextBlock)) 3175 { 3176 const lldb::addr_t file_vm_addr = sc.line_entry.range.GetBaseAddress().GetFileAddress(); 3177 if (file_vm_addr != LLDB_INVALID_ADDRESS) 3178 { 3179 DWARFDebugInfoEntry *function_die = NULL; 3180 DWARFDebugInfoEntry *block_die = NULL; 3181 dwarf_cu->LookupAddress(file_vm_addr, &function_die, resolve_scope & eSymbolContextBlock ? &block_die : NULL); 3182 3183 if (function_die != NULL) 3184 { 3185 sc.function = sc.comp_unit->FindFunctionByUID (MakeUserID(function_die->GetOffset())).get(); 3186 if (sc.function == NULL) 3187 sc.function = ParseCompileUnitFunction(sc, dwarf_cu, function_die); 3188 } 3189 3190 if (sc.function != NULL) 3191 { 3192 Block& block = sc.function->GetBlock (true); 3193 3194 if (block_die != NULL) 3195 sc.block = block.FindBlockByID (MakeUserID(block_die->GetOffset())); 3196 else if (function_die != NULL) 3197 sc.block = block.FindBlockByID (MakeUserID(function_die->GetOffset())); 3198 } 3199 } 3200 } 3201 3202 sc_list.Append(sc); 3203 line_idx = line_table->FindLineEntryIndexByFileIndex (line_idx + 1, file_idx, found_line, true, &sc.line_entry); 3204 } 3205 } 3206 } 3207 else if (file_spec_matches_cu_file_spec && !check_inlines) 3208 { 3209 // only append the context if we aren't looking for inline call sites 3210 // by file and line and if the file spec matches that of the compile unit 3211 sc_list.Append(sc); 3212 } 3213 } 3214 else if (file_spec_matches_cu_file_spec && !check_inlines) 3215 { 3216 // only append the context if we aren't looking for inline call sites 3217 // by file and line and if the file spec matches that of the compile unit 3218 sc_list.Append(sc); 3219 } 3220 3221 if (!check_inlines) 3222 break; 3223 } 3224 } 3225 } 3226 } 3227 } 3228 return sc_list.GetSize() - prev_size; 3229 } 3230 3231 void 3232 SymbolFileDWARF::Index () 3233 { 3234 if (m_indexed) 3235 return; 3236 m_indexed = true; 3237 Timer scoped_timer (__PRETTY_FUNCTION__, 3238 "SymbolFileDWARF::Index (%s)", 3239 GetObjectFile()->GetFileSpec().GetFilename().AsCString("<Unknown>")); 3240 3241 DWARFDebugInfo* debug_info = DebugInfo(); 3242 if (debug_info) 3243 { 3244 uint32_t cu_idx = 0; 3245 const uint32_t num_compile_units = GetNumCompileUnits(); 3246 for (cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) 3247 { 3248 DWARFCompileUnit* dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx); 3249 3250 bool clear_dies = dwarf_cu->ExtractDIEsIfNeeded (false) > 1; 3251 3252 dwarf_cu->Index (cu_idx, 3253 m_function_basename_index, 3254 m_function_fullname_index, 3255 m_function_method_index, 3256 m_function_selector_index, 3257 m_objc_class_selectors_index, 3258 m_global_index, 3259 m_type_index, 3260 m_namespace_index); 3261 3262 // Keep memory down by clearing DIEs if this generate function 3263 // caused them to be parsed 3264 if (clear_dies) 3265 dwarf_cu->ClearDIEs (true); 3266 } 3267 3268 m_function_basename_index.Finalize(); 3269 m_function_fullname_index.Finalize(); 3270 m_function_method_index.Finalize(); 3271 m_function_selector_index.Finalize(); 3272 m_objc_class_selectors_index.Finalize(); 3273 m_global_index.Finalize(); 3274 m_type_index.Finalize(); 3275 m_namespace_index.Finalize(); 3276 3277 #if defined (ENABLE_DEBUG_PRINTF) 3278 StreamFile s(stdout, false); 3279 s.Printf ("DWARF index for '%s':", 3280 GetObjectFile()->GetFileSpec().GetPath().c_str()); 3281 s.Printf("\nFunction basenames:\n"); m_function_basename_index.Dump (&s); 3282 s.Printf("\nFunction fullnames:\n"); m_function_fullname_index.Dump (&s); 3283 s.Printf("\nFunction methods:\n"); m_function_method_index.Dump (&s); 3284 s.Printf("\nFunction selectors:\n"); m_function_selector_index.Dump (&s); 3285 s.Printf("\nObjective C class selectors:\n"); m_objc_class_selectors_index.Dump (&s); 3286 s.Printf("\nGlobals and statics:\n"); m_global_index.Dump (&s); 3287 s.Printf("\nTypes:\n"); m_type_index.Dump (&s); 3288 s.Printf("\nNamepaces:\n"); m_namespace_index.Dump (&s); 3289 #endif 3290 } 3291 } 3292 3293 bool 3294 SymbolFileDWARF::NamespaceDeclMatchesThisSymbolFile (const ClangNamespaceDecl *namespace_decl) 3295 { 3296 if (namespace_decl == NULL) 3297 { 3298 // Invalid namespace decl which means we aren't matching only things 3299 // in this symbol file, so return true to indicate it matches this 3300 // symbol file. 3301 return true; 3302 } 3303 3304 clang::ASTContext *namespace_ast = namespace_decl->GetASTContext(); 3305 3306 if (namespace_ast == NULL) 3307 return true; // No AST in the "namespace_decl", return true since it 3308 // could then match any symbol file, including this one 3309 3310 if (namespace_ast == GetClangASTContext().getASTContext()) 3311 return true; // The ASTs match, return true 3312 3313 // The namespace AST was valid, and it does not match... 3314 Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS)); 3315 3316 if (log) 3317 GetObjectFile()->GetModule()->LogMessage(log, "Valid namespace does not match symbol file"); 3318 3319 return false; 3320 } 3321 3322 bool 3323 SymbolFileDWARF::DIEIsInNamespace (const ClangNamespaceDecl *namespace_decl, 3324 DWARFCompileUnit* cu, 3325 const DWARFDebugInfoEntry* die) 3326 { 3327 // No namespace specified, so the answer is 3328 if (namespace_decl == NULL) 3329 return true; 3330 3331 Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS)); 3332 3333 const DWARFDebugInfoEntry *decl_ctx_die = NULL; 3334 clang::DeclContext *die_clang_decl_ctx = GetClangDeclContextContainingDIE (cu, die, &decl_ctx_die); 3335 if (decl_ctx_die) 3336 { 3337 clang::NamespaceDecl *clang_namespace_decl = namespace_decl->GetNamespaceDecl(); 3338 3339 if (clang_namespace_decl) 3340 { 3341 if (decl_ctx_die->Tag() != DW_TAG_namespace) 3342 { 3343 if (log) 3344 GetObjectFile()->GetModule()->LogMessage(log, "Found a match, but its parent is not a namespace"); 3345 return false; 3346 } 3347 3348 if (clang_namespace_decl == die_clang_decl_ctx) 3349 return true; 3350 else 3351 return false; 3352 } 3353 else 3354 { 3355 // We have a namespace_decl that was not NULL but it contained 3356 // a NULL "clang::NamespaceDecl", so this means the global namespace 3357 // So as long the contained decl context DIE isn't a namespace 3358 // we should be ok. 3359 if (decl_ctx_die->Tag() != DW_TAG_namespace) 3360 return true; 3361 } 3362 } 3363 3364 if (log) 3365 GetObjectFile()->GetModule()->LogMessage(log, "Found a match, but its parent doesn't exist"); 3366 3367 return false; 3368 } 3369 uint32_t 3370 SymbolFileDWARF::FindGlobalVariables (const ConstString &name, const lldb_private::ClangNamespaceDecl *namespace_decl, bool append, uint32_t max_matches, VariableList& variables) 3371 { 3372 Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS)); 3373 3374 if (log) 3375 GetObjectFile()->GetModule()->LogMessage (log, 3376 "SymbolFileDWARF::FindGlobalVariables (name=\"%s\", namespace_decl=%p, append=%u, max_matches=%u, variables)", 3377 name.GetCString(), 3378 static_cast<const void*>(namespace_decl), 3379 append, max_matches); 3380 3381 if (!NamespaceDeclMatchesThisSymbolFile(namespace_decl)) 3382 return 0; 3383 3384 DWARFDebugInfo* info = DebugInfo(); 3385 if (info == NULL) 3386 return 0; 3387 3388 // If we aren't appending the results to this list, then clear the list 3389 if (!append) 3390 variables.Clear(); 3391 3392 // Remember how many variables are in the list before we search in case 3393 // we are appending the results to a variable list. 3394 const uint32_t original_size = variables.GetSize(); 3395 3396 DIEArray die_offsets; 3397 3398 if (m_using_apple_tables) 3399 { 3400 if (m_apple_names_ap.get()) 3401 { 3402 const char *name_cstr = name.GetCString(); 3403 llvm::StringRef basename; 3404 llvm::StringRef context; 3405 3406 if (!CPPLanguageRuntime::ExtractContextAndIdentifier(name_cstr, context, basename)) 3407 basename = name_cstr; 3408 3409 m_apple_names_ap->FindByName (basename.data(), die_offsets); 3410 } 3411 } 3412 else 3413 { 3414 // Index the DWARF if we haven't already 3415 if (!m_indexed) 3416 Index (); 3417 3418 m_global_index.Find (name, die_offsets); 3419 } 3420 3421 const size_t num_die_matches = die_offsets.size(); 3422 if (num_die_matches) 3423 { 3424 SymbolContext sc; 3425 sc.module_sp = m_obj_file->GetModule(); 3426 assert (sc.module_sp); 3427 3428 DWARFDebugInfo* debug_info = DebugInfo(); 3429 DWARFCompileUnit* dwarf_cu = NULL; 3430 const DWARFDebugInfoEntry* die = NULL; 3431 bool done = false; 3432 for (size_t i=0; i<num_die_matches && !done; ++i) 3433 { 3434 const dw_offset_t die_offset = die_offsets[i]; 3435 die = debug_info->GetDIEPtrWithCompileUnitHint (die_offset, &dwarf_cu); 3436 3437 if (die) 3438 { 3439 switch (die->Tag()) 3440 { 3441 default: 3442 case DW_TAG_subprogram: 3443 case DW_TAG_inlined_subroutine: 3444 case DW_TAG_try_block: 3445 case DW_TAG_catch_block: 3446 break; 3447 3448 case DW_TAG_variable: 3449 { 3450 sc.comp_unit = GetCompUnitForDWARFCompUnit(dwarf_cu, UINT32_MAX); 3451 3452 if (namespace_decl && !DIEIsInNamespace (namespace_decl, dwarf_cu, die)) 3453 continue; 3454 3455 ParseVariables(sc, dwarf_cu, LLDB_INVALID_ADDRESS, die, false, false, &variables); 3456 3457 if (variables.GetSize() - original_size >= max_matches) 3458 done = true; 3459 } 3460 break; 3461 } 3462 } 3463 else 3464 { 3465 if (m_using_apple_tables) 3466 { 3467 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_names accelerator table had bad die 0x%8.8x for '%s')\n", 3468 die_offset, name.GetCString()); 3469 } 3470 } 3471 } 3472 } 3473 3474 // Return the number of variable that were appended to the list 3475 const uint32_t num_matches = variables.GetSize() - original_size; 3476 if (log && num_matches > 0) 3477 { 3478 GetObjectFile()->GetModule()->LogMessage (log, 3479 "SymbolFileDWARF::FindGlobalVariables (name=\"%s\", namespace_decl=%p, append=%u, max_matches=%u, variables) => %u", 3480 name.GetCString(), 3481 static_cast<const void*>(namespace_decl), 3482 append, max_matches, 3483 num_matches); 3484 } 3485 return num_matches; 3486 } 3487 3488 uint32_t 3489 SymbolFileDWARF::FindGlobalVariables(const RegularExpression& regex, bool append, uint32_t max_matches, VariableList& variables) 3490 { 3491 Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS)); 3492 3493 if (log) 3494 { 3495 GetObjectFile()->GetModule()->LogMessage (log, 3496 "SymbolFileDWARF::FindGlobalVariables (regex=\"%s\", append=%u, max_matches=%u, variables)", 3497 regex.GetText(), append, 3498 max_matches); 3499 } 3500 3501 DWARFDebugInfo* info = DebugInfo(); 3502 if (info == NULL) 3503 return 0; 3504 3505 // If we aren't appending the results to this list, then clear the list 3506 if (!append) 3507 variables.Clear(); 3508 3509 // Remember how many variables are in the list before we search in case 3510 // we are appending the results to a variable list. 3511 const uint32_t original_size = variables.GetSize(); 3512 3513 DIEArray die_offsets; 3514 3515 if (m_using_apple_tables) 3516 { 3517 if (m_apple_names_ap.get()) 3518 { 3519 DWARFMappedHash::DIEInfoArray hash_data_array; 3520 if (m_apple_names_ap->AppendAllDIEsThatMatchingRegex (regex, hash_data_array)) 3521 DWARFMappedHash::ExtractDIEArray (hash_data_array, die_offsets); 3522 } 3523 } 3524 else 3525 { 3526 // Index the DWARF if we haven't already 3527 if (!m_indexed) 3528 Index (); 3529 3530 m_global_index.Find (regex, die_offsets); 3531 } 3532 3533 SymbolContext sc; 3534 sc.module_sp = m_obj_file->GetModule(); 3535 assert (sc.module_sp); 3536 3537 DWARFCompileUnit* dwarf_cu = NULL; 3538 const DWARFDebugInfoEntry* die = NULL; 3539 const size_t num_matches = die_offsets.size(); 3540 if (num_matches) 3541 { 3542 DWARFDebugInfo* debug_info = DebugInfo(); 3543 for (size_t i=0; i<num_matches; ++i) 3544 { 3545 const dw_offset_t die_offset = die_offsets[i]; 3546 die = debug_info->GetDIEPtrWithCompileUnitHint (die_offset, &dwarf_cu); 3547 3548 if (die) 3549 { 3550 sc.comp_unit = GetCompUnitForDWARFCompUnit(dwarf_cu, UINT32_MAX); 3551 3552 ParseVariables(sc, dwarf_cu, LLDB_INVALID_ADDRESS, die, false, false, &variables); 3553 3554 if (variables.GetSize() - original_size >= max_matches) 3555 break; 3556 } 3557 else 3558 { 3559 if (m_using_apple_tables) 3560 { 3561 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_names accelerator table had bad die 0x%8.8x for regex '%s')\n", 3562 die_offset, regex.GetText()); 3563 } 3564 } 3565 } 3566 } 3567 3568 // Return the number of variable that were appended to the list 3569 return variables.GetSize() - original_size; 3570 } 3571 3572 3573 bool 3574 SymbolFileDWARF::ResolveFunction (dw_offset_t die_offset, 3575 DWARFCompileUnit *&dwarf_cu, 3576 bool include_inlines, 3577 SymbolContextList& sc_list) 3578 { 3579 const DWARFDebugInfoEntry *die = DebugInfo()->GetDIEPtrWithCompileUnitHint (die_offset, &dwarf_cu); 3580 return ResolveFunction (dwarf_cu, die, include_inlines, sc_list); 3581 } 3582 3583 3584 bool 3585 SymbolFileDWARF::ResolveFunction (DWARFCompileUnit *cu, 3586 const DWARFDebugInfoEntry *die, 3587 bool include_inlines, 3588 SymbolContextList& sc_list) 3589 { 3590 SymbolContext sc; 3591 3592 if (die == NULL) 3593 return false; 3594 3595 // If we were passed a die that is not a function, just return false... 3596 if (! (die->Tag() == DW_TAG_subprogram || (include_inlines && die->Tag() == DW_TAG_inlined_subroutine))) 3597 return false; 3598 3599 const DWARFDebugInfoEntry* inlined_die = NULL; 3600 if (die->Tag() == DW_TAG_inlined_subroutine) 3601 { 3602 inlined_die = die; 3603 3604 while ((die = die->GetParent()) != NULL) 3605 { 3606 if (die->Tag() == DW_TAG_subprogram) 3607 break; 3608 } 3609 } 3610 assert (die && die->Tag() == DW_TAG_subprogram); 3611 if (GetFunction (cu, die, sc)) 3612 { 3613 Address addr; 3614 // Parse all blocks if needed 3615 if (inlined_die) 3616 { 3617 Block &function_block = sc.function->GetBlock (true); 3618 sc.block = function_block.FindBlockByID (MakeUserID(inlined_die->GetOffset())); 3619 if (sc.block == NULL) 3620 sc.block = function_block.FindBlockByID (inlined_die->GetOffset()); 3621 if (sc.block == NULL || sc.block->GetStartAddress (addr) == false) 3622 addr.Clear(); 3623 } 3624 else 3625 { 3626 sc.block = NULL; 3627 addr = sc.function->GetAddressRange().GetBaseAddress(); 3628 } 3629 3630 if (addr.IsValid()) 3631 { 3632 sc_list.Append(sc); 3633 return true; 3634 } 3635 } 3636 3637 return false; 3638 } 3639 3640 void 3641 SymbolFileDWARF::FindFunctions (const ConstString &name, 3642 const NameToDIE &name_to_die, 3643 bool include_inlines, 3644 SymbolContextList& sc_list) 3645 { 3646 DIEArray die_offsets; 3647 if (name_to_die.Find (name, die_offsets)) 3648 { 3649 ParseFunctions (die_offsets, include_inlines, sc_list); 3650 } 3651 } 3652 3653 3654 void 3655 SymbolFileDWARF::FindFunctions (const RegularExpression ®ex, 3656 const NameToDIE &name_to_die, 3657 bool include_inlines, 3658 SymbolContextList& sc_list) 3659 { 3660 DIEArray die_offsets; 3661 if (name_to_die.Find (regex, die_offsets)) 3662 { 3663 ParseFunctions (die_offsets, include_inlines, sc_list); 3664 } 3665 } 3666 3667 3668 void 3669 SymbolFileDWARF::FindFunctions (const RegularExpression ®ex, 3670 const DWARFMappedHash::MemoryTable &memory_table, 3671 bool include_inlines, 3672 SymbolContextList& sc_list) 3673 { 3674 DIEArray die_offsets; 3675 DWARFMappedHash::DIEInfoArray hash_data_array; 3676 if (memory_table.AppendAllDIEsThatMatchingRegex (regex, hash_data_array)) 3677 { 3678 DWARFMappedHash::ExtractDIEArray (hash_data_array, die_offsets); 3679 ParseFunctions (die_offsets, include_inlines, sc_list); 3680 } 3681 } 3682 3683 void 3684 SymbolFileDWARF::ParseFunctions (const DIEArray &die_offsets, 3685 bool include_inlines, 3686 SymbolContextList& sc_list) 3687 { 3688 const size_t num_matches = die_offsets.size(); 3689 if (num_matches) 3690 { 3691 DWARFCompileUnit* dwarf_cu = NULL; 3692 for (size_t i=0; i<num_matches; ++i) 3693 { 3694 const dw_offset_t die_offset = die_offsets[i]; 3695 ResolveFunction (die_offset, dwarf_cu, include_inlines, sc_list); 3696 } 3697 } 3698 } 3699 3700 bool 3701 SymbolFileDWARF::FunctionDieMatchesPartialName (const DWARFDebugInfoEntry* die, 3702 const DWARFCompileUnit *dwarf_cu, 3703 uint32_t name_type_mask, 3704 const char *partial_name, 3705 const char *base_name_start, 3706 const char *base_name_end) 3707 { 3708 // If we are looking only for methods, throw away all the ones that are or aren't in C++ classes: 3709 if (name_type_mask == eFunctionNameTypeMethod || name_type_mask == eFunctionNameTypeBase) 3710 { 3711 clang::DeclContext *containing_decl_ctx = GetClangDeclContextContainingDIEOffset(die->GetOffset()); 3712 if (!containing_decl_ctx) 3713 return false; 3714 3715 bool is_cxx_method = DeclKindIsCXXClass(containing_decl_ctx->getDeclKind()); 3716 3717 if (name_type_mask == eFunctionNameTypeMethod) 3718 { 3719 if (is_cxx_method == false) 3720 return false; 3721 } 3722 3723 if (name_type_mask == eFunctionNameTypeBase) 3724 { 3725 if (is_cxx_method == true) 3726 return false; 3727 } 3728 } 3729 3730 // Now we need to check whether the name we got back for this type matches the extra specifications 3731 // that were in the name we're looking up: 3732 if (base_name_start != partial_name || *base_name_end != '\0') 3733 { 3734 // First see if the stuff to the left matches the full name. To do that let's see if 3735 // we can pull out the mips linkage name attribute: 3736 3737 Mangled best_name; 3738 DWARFDebugInfoEntry::Attributes attributes; 3739 DWARFFormValue form_value; 3740 die->GetAttributes(this, dwarf_cu, NULL, attributes); 3741 uint32_t idx = attributes.FindAttributeIndex(DW_AT_MIPS_linkage_name); 3742 if (idx == UINT32_MAX) 3743 idx = attributes.FindAttributeIndex(DW_AT_linkage_name); 3744 if (idx != UINT32_MAX) 3745 { 3746 if (attributes.ExtractFormValueAtIndex(this, idx, form_value)) 3747 { 3748 const char *mangled_name = form_value.AsCString(&get_debug_str_data()); 3749 if (mangled_name) 3750 best_name.SetValue (ConstString(mangled_name), true); 3751 } 3752 } 3753 3754 if (!best_name) 3755 { 3756 idx = attributes.FindAttributeIndex(DW_AT_name); 3757 if (idx != UINT32_MAX && attributes.ExtractFormValueAtIndex(this, idx, form_value)) 3758 { 3759 const char *name = form_value.AsCString(&get_debug_str_data()); 3760 best_name.SetValue (ConstString(name), false); 3761 } 3762 } 3763 3764 if (best_name.GetDemangledName()) 3765 { 3766 const char *demangled = best_name.GetDemangledName().GetCString(); 3767 if (demangled) 3768 { 3769 std::string name_no_parens(partial_name, base_name_end - partial_name); 3770 const char *partial_in_demangled = strstr (demangled, name_no_parens.c_str()); 3771 if (partial_in_demangled == NULL) 3772 return false; 3773 else 3774 { 3775 // Sort out the case where our name is something like "Process::Destroy" and the match is 3776 // "SBProcess::Destroy" - that shouldn't be a match. We should really always match on 3777 // namespace boundaries... 3778 3779 if (partial_name[0] == ':' && partial_name[1] == ':') 3780 { 3781 // The partial name was already on a namespace boundary so all matches are good. 3782 return true; 3783 } 3784 else if (partial_in_demangled == demangled) 3785 { 3786 // They both start the same, so this is an good match. 3787 return true; 3788 } 3789 else 3790 { 3791 if (partial_in_demangled - demangled == 1) 3792 { 3793 // Only one character difference, can't be a namespace boundary... 3794 return false; 3795 } 3796 else if (*(partial_in_demangled - 1) == ':' && *(partial_in_demangled - 2) == ':') 3797 { 3798 // We are on a namespace boundary, so this is also good. 3799 return true; 3800 } 3801 else 3802 return false; 3803 } 3804 } 3805 } 3806 } 3807 } 3808 3809 return true; 3810 } 3811 3812 uint32_t 3813 SymbolFileDWARF::FindFunctions (const ConstString &name, 3814 const lldb_private::ClangNamespaceDecl *namespace_decl, 3815 uint32_t name_type_mask, 3816 bool include_inlines, 3817 bool append, 3818 SymbolContextList& sc_list) 3819 { 3820 Timer scoped_timer (__PRETTY_FUNCTION__, 3821 "SymbolFileDWARF::FindFunctions (name = '%s')", 3822 name.AsCString()); 3823 3824 // eFunctionNameTypeAuto should be pre-resolved by a call to Module::PrepareForFunctionNameLookup() 3825 assert ((name_type_mask & eFunctionNameTypeAuto) == 0); 3826 3827 Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS)); 3828 3829 if (log) 3830 { 3831 GetObjectFile()->GetModule()->LogMessage (log, 3832 "SymbolFileDWARF::FindFunctions (name=\"%s\", name_type_mask=0x%x, append=%u, sc_list)", 3833 name.GetCString(), 3834 name_type_mask, 3835 append); 3836 } 3837 3838 // If we aren't appending the results to this list, then clear the list 3839 if (!append) 3840 sc_list.Clear(); 3841 3842 if (!NamespaceDeclMatchesThisSymbolFile(namespace_decl)) 3843 return 0; 3844 3845 // If name is empty then we won't find anything. 3846 if (name.IsEmpty()) 3847 return 0; 3848 3849 // Remember how many sc_list are in the list before we search in case 3850 // we are appending the results to a variable list. 3851 3852 const char *name_cstr = name.GetCString(); 3853 3854 const uint32_t original_size = sc_list.GetSize(); 3855 3856 DWARFDebugInfo* info = DebugInfo(); 3857 if (info == NULL) 3858 return 0; 3859 3860 DWARFCompileUnit *dwarf_cu = NULL; 3861 std::set<const DWARFDebugInfoEntry *> resolved_dies; 3862 if (m_using_apple_tables) 3863 { 3864 if (m_apple_names_ap.get()) 3865 { 3866 3867 DIEArray die_offsets; 3868 3869 uint32_t num_matches = 0; 3870 3871 if (name_type_mask & eFunctionNameTypeFull) 3872 { 3873 // If they asked for the full name, match what they typed. At some point we may 3874 // want to canonicalize this (strip double spaces, etc. For now, we just add all the 3875 // dies that we find by exact match. 3876 num_matches = m_apple_names_ap->FindByName (name_cstr, die_offsets); 3877 for (uint32_t i = 0; i < num_matches; i++) 3878 { 3879 const dw_offset_t die_offset = die_offsets[i]; 3880 const DWARFDebugInfoEntry *die = info->GetDIEPtrWithCompileUnitHint (die_offset, &dwarf_cu); 3881 if (die) 3882 { 3883 if (namespace_decl && !DIEIsInNamespace (namespace_decl, dwarf_cu, die)) 3884 continue; 3885 3886 if (resolved_dies.find(die) == resolved_dies.end()) 3887 { 3888 if (ResolveFunction (dwarf_cu, die, include_inlines, sc_list)) 3889 resolved_dies.insert(die); 3890 } 3891 } 3892 else 3893 { 3894 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_names accelerator table had bad die 0x%8.8x for '%s')", 3895 die_offset, name_cstr); 3896 } 3897 } 3898 } 3899 3900 if (name_type_mask & eFunctionNameTypeSelector) 3901 { 3902 if (namespace_decl && *namespace_decl) 3903 return 0; // no selectors in namespaces 3904 3905 num_matches = m_apple_names_ap->FindByName (name_cstr, die_offsets); 3906 // Now make sure these are actually ObjC methods. In this case we can simply look up the name, 3907 // and if it is an ObjC method name, we're good. 3908 3909 for (uint32_t i = 0; i < num_matches; i++) 3910 { 3911 const dw_offset_t die_offset = die_offsets[i]; 3912 const DWARFDebugInfoEntry* die = info->GetDIEPtrWithCompileUnitHint (die_offset, &dwarf_cu); 3913 if (die) 3914 { 3915 const char *die_name = die->GetName(this, dwarf_cu); 3916 if (ObjCLanguageRuntime::IsPossibleObjCMethodName(die_name)) 3917 { 3918 if (resolved_dies.find(die) == resolved_dies.end()) 3919 { 3920 if (ResolveFunction (dwarf_cu, die, include_inlines, sc_list)) 3921 resolved_dies.insert(die); 3922 } 3923 } 3924 } 3925 else 3926 { 3927 GetObjectFile()->GetModule()->ReportError ("the DWARF debug information has been modified (.apple_names accelerator table had bad die 0x%8.8x for '%s')", 3928 die_offset, name_cstr); 3929 } 3930 } 3931 die_offsets.clear(); 3932 } 3933 3934 if (((name_type_mask & eFunctionNameTypeMethod) && !namespace_decl) || name_type_mask & eFunctionNameTypeBase) 3935 { 3936 // The apple_names table stores just the "base name" of C++ methods in the table. So we have to 3937 // extract the base name, look that up, and if there is any other information in the name we were 3938 // passed in we have to post-filter based on that. 3939 3940 // FIXME: Arrange the logic above so that we don't calculate the base name twice: 3941 num_matches = m_apple_names_ap->FindByName (name_cstr, die_offsets); 3942 3943 for (uint32_t i = 0; i < num_matches; i++) 3944 { 3945 const dw_offset_t die_offset = die_offsets[i]; 3946 const DWARFDebugInfoEntry* die = info->GetDIEPtrWithCompileUnitHint (die_offset, &dwarf_cu); 3947 if (die) 3948 { 3949 if (namespace_decl && !DIEIsInNamespace (namespace_decl, dwarf_cu, die)) 3950 continue; 3951 3952 // If we get to here, the die is good, and we should add it: 3953 if (resolved_dies.find(die) == resolved_dies.end()) 3954 if (ResolveFunction (dwarf_cu, die, include_inlines, sc_list)) 3955 { 3956 bool keep_die = true; 3957 if ((name_type_mask & (eFunctionNameTypeBase|eFunctionNameTypeMethod)) != (eFunctionNameTypeBase|eFunctionNameTypeMethod)) 3958 { 3959 // We are looking for either basenames or methods, so we need to 3960 // trim out the ones we won't want by looking at the type 3961 SymbolContext sc; 3962 if (sc_list.GetLastContext(sc)) 3963 { 3964 if (sc.block) 3965 { 3966 // We have an inlined function 3967 } 3968 else if (sc.function) 3969 { 3970 Type *type = sc.function->GetType(); 3971 3972 if (type) 3973 { 3974 clang::DeclContext* decl_ctx = GetClangDeclContextContainingTypeUID (type->GetID()); 3975 if (decl_ctx->isRecord()) 3976 { 3977 if (name_type_mask & eFunctionNameTypeBase) 3978 { 3979 sc_list.RemoveContextAtIndex(sc_list.GetSize()-1); 3980 keep_die = false; 3981 } 3982 } 3983 else 3984 { 3985 if (name_type_mask & eFunctionNameTypeMethod) 3986 { 3987 sc_list.RemoveContextAtIndex(sc_list.GetSize()-1); 3988 keep_die = false; 3989 } 3990 } 3991 } 3992 else 3993 { 3994 GetObjectFile()->GetModule()->ReportWarning ("function at die offset 0x%8.8x had no function type", 3995 die_offset); 3996 } 3997 } 3998 } 3999 } 4000 if (keep_die) 4001 resolved_dies.insert(die); 4002 } 4003 } 4004 else 4005 { 4006 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_names accelerator table had bad die 0x%8.8x for '%s')", 4007 die_offset, name_cstr); 4008 } 4009 } 4010 die_offsets.clear(); 4011 } 4012 } 4013 } 4014 else 4015 { 4016 4017 // Index the DWARF if we haven't already 4018 if (!m_indexed) 4019 Index (); 4020 4021 if (name_type_mask & eFunctionNameTypeFull) 4022 { 4023 FindFunctions (name, m_function_fullname_index, include_inlines, sc_list); 4024 4025 // FIXME Temporary workaround for global/anonymous namespace 4026 // functions debugging FreeBSD and Linux binaries. 4027 // If we didn't find any functions in the global namespace try 4028 // looking in the basename index but ignore any returned 4029 // functions that have a namespace but keep functions which 4030 // have an anonymous namespace 4031 // TODO: The arch in the object file isn't correct for MSVC 4032 // binaries on windows, we should find a way to make it 4033 // correct and handle those symbols as well. 4034 if (sc_list.GetSize() == 0) 4035 { 4036 ArchSpec arch; 4037 if (!namespace_decl && 4038 GetObjectFile()->GetArchitecture(arch) && 4039 (arch.GetTriple().isOSFreeBSD() || arch.GetTriple().isOSLinux() || 4040 arch.GetMachine() == llvm::Triple::hexagon)) 4041 { 4042 SymbolContextList temp_sc_list; 4043 FindFunctions (name, m_function_basename_index, include_inlines, temp_sc_list); 4044 SymbolContext sc; 4045 for (uint32_t i = 0; i < temp_sc_list.GetSize(); i++) 4046 { 4047 if (temp_sc_list.GetContextAtIndex(i, sc)) 4048 { 4049 ConstString mangled_name = sc.GetFunctionName(Mangled::ePreferMangled); 4050 ConstString demangled_name = sc.GetFunctionName(Mangled::ePreferDemangled); 4051 // Mangled names on Linux and FreeBSD are of the form: 4052 // _ZN18function_namespace13function_nameEv. 4053 if (strncmp(mangled_name.GetCString(), "_ZN", 3) || 4054 !strncmp(demangled_name.GetCString(), "(anonymous namespace)", 21)) 4055 { 4056 sc_list.Append(sc); 4057 } 4058 } 4059 } 4060 } 4061 } 4062 } 4063 DIEArray die_offsets; 4064 DWARFCompileUnit *dwarf_cu = NULL; 4065 4066 if (name_type_mask & eFunctionNameTypeBase) 4067 { 4068 uint32_t num_base = m_function_basename_index.Find(name, die_offsets); 4069 for (uint32_t i = 0; i < num_base; i++) 4070 { 4071 const DWARFDebugInfoEntry* die = info->GetDIEPtrWithCompileUnitHint (die_offsets[i], &dwarf_cu); 4072 if (die) 4073 { 4074 if (namespace_decl && !DIEIsInNamespace (namespace_decl, dwarf_cu, die)) 4075 continue; 4076 4077 // If we get to here, the die is good, and we should add it: 4078 if (resolved_dies.find(die) == resolved_dies.end()) 4079 { 4080 if (ResolveFunction (dwarf_cu, die, include_inlines, sc_list)) 4081 resolved_dies.insert(die); 4082 } 4083 } 4084 } 4085 die_offsets.clear(); 4086 } 4087 4088 if (name_type_mask & eFunctionNameTypeMethod) 4089 { 4090 if (namespace_decl && *namespace_decl) 4091 return 0; // no methods in namespaces 4092 4093 uint32_t num_base = m_function_method_index.Find(name, die_offsets); 4094 { 4095 for (uint32_t i = 0; i < num_base; i++) 4096 { 4097 const DWARFDebugInfoEntry* die = info->GetDIEPtrWithCompileUnitHint (die_offsets[i], &dwarf_cu); 4098 if (die) 4099 { 4100 // If we get to here, the die is good, and we should add it: 4101 if (resolved_dies.find(die) == resolved_dies.end()) 4102 { 4103 if (ResolveFunction (dwarf_cu, die, include_inlines, sc_list)) 4104 resolved_dies.insert(die); 4105 } 4106 } 4107 } 4108 } 4109 die_offsets.clear(); 4110 } 4111 4112 if ((name_type_mask & eFunctionNameTypeSelector) && (!namespace_decl || !*namespace_decl)) 4113 { 4114 FindFunctions (name, m_function_selector_index, include_inlines, sc_list); 4115 } 4116 4117 } 4118 4119 // Return the number of variable that were appended to the list 4120 const uint32_t num_matches = sc_list.GetSize() - original_size; 4121 4122 if (log && num_matches > 0) 4123 { 4124 GetObjectFile()->GetModule()->LogMessage (log, 4125 "SymbolFileDWARF::FindFunctions (name=\"%s\", name_type_mask=0x%x, include_inlines=%d, append=%u, sc_list) => %u", 4126 name.GetCString(), 4127 name_type_mask, 4128 include_inlines, 4129 append, 4130 num_matches); 4131 } 4132 return num_matches; 4133 } 4134 4135 uint32_t 4136 SymbolFileDWARF::FindFunctions(const RegularExpression& regex, bool include_inlines, bool append, SymbolContextList& sc_list) 4137 { 4138 Timer scoped_timer (__PRETTY_FUNCTION__, 4139 "SymbolFileDWARF::FindFunctions (regex = '%s')", 4140 regex.GetText()); 4141 4142 Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS)); 4143 4144 if (log) 4145 { 4146 GetObjectFile()->GetModule()->LogMessage (log, 4147 "SymbolFileDWARF::FindFunctions (regex=\"%s\", append=%u, sc_list)", 4148 regex.GetText(), 4149 append); 4150 } 4151 4152 4153 // If we aren't appending the results to this list, then clear the list 4154 if (!append) 4155 sc_list.Clear(); 4156 4157 // Remember how many sc_list are in the list before we search in case 4158 // we are appending the results to a variable list. 4159 uint32_t original_size = sc_list.GetSize(); 4160 4161 if (m_using_apple_tables) 4162 { 4163 if (m_apple_names_ap.get()) 4164 FindFunctions (regex, *m_apple_names_ap, include_inlines, sc_list); 4165 } 4166 else 4167 { 4168 // Index the DWARF if we haven't already 4169 if (!m_indexed) 4170 Index (); 4171 4172 FindFunctions (regex, m_function_basename_index, include_inlines, sc_list); 4173 4174 FindFunctions (regex, m_function_fullname_index, include_inlines, sc_list); 4175 } 4176 4177 // Return the number of variable that were appended to the list 4178 return sc_list.GetSize() - original_size; 4179 } 4180 4181 uint32_t 4182 SymbolFileDWARF::FindTypes (const SymbolContext& sc, 4183 const ConstString &name, 4184 const lldb_private::ClangNamespaceDecl *namespace_decl, 4185 bool append, 4186 uint32_t max_matches, 4187 TypeList& types) 4188 { 4189 DWARFDebugInfo* info = DebugInfo(); 4190 if (info == NULL) 4191 return 0; 4192 4193 Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS)); 4194 4195 if (log) 4196 { 4197 if (namespace_decl) 4198 GetObjectFile()->GetModule()->LogMessage (log, 4199 "SymbolFileDWARF::FindTypes (sc, name=\"%s\", clang::NamespaceDecl(%p) \"%s\", append=%u, max_matches=%u, type_list)", 4200 name.GetCString(), 4201 static_cast<void*>(namespace_decl->GetNamespaceDecl()), 4202 namespace_decl->GetQualifiedName().c_str(), 4203 append, max_matches); 4204 else 4205 GetObjectFile()->GetModule()->LogMessage (log, 4206 "SymbolFileDWARF::FindTypes (sc, name=\"%s\", clang::NamespaceDecl(NULL), append=%u, max_matches=%u, type_list)", 4207 name.GetCString(), append, 4208 max_matches); 4209 } 4210 4211 // If we aren't appending the results to this list, then clear the list 4212 if (!append) 4213 types.Clear(); 4214 4215 if (!NamespaceDeclMatchesThisSymbolFile(namespace_decl)) 4216 return 0; 4217 4218 DIEArray die_offsets; 4219 4220 if (m_using_apple_tables) 4221 { 4222 if (m_apple_types_ap.get()) 4223 { 4224 const char *name_cstr = name.GetCString(); 4225 m_apple_types_ap->FindByName (name_cstr, die_offsets); 4226 } 4227 } 4228 else 4229 { 4230 if (!m_indexed) 4231 Index (); 4232 4233 m_type_index.Find (name, die_offsets); 4234 } 4235 4236 const size_t num_die_matches = die_offsets.size(); 4237 4238 if (num_die_matches) 4239 { 4240 const uint32_t initial_types_size = types.GetSize(); 4241 DWARFCompileUnit* dwarf_cu = NULL; 4242 const DWARFDebugInfoEntry* die = NULL; 4243 DWARFDebugInfo* debug_info = DebugInfo(); 4244 for (size_t i=0; i<num_die_matches; ++i) 4245 { 4246 const dw_offset_t die_offset = die_offsets[i]; 4247 die = debug_info->GetDIEPtrWithCompileUnitHint (die_offset, &dwarf_cu); 4248 4249 if (die) 4250 { 4251 if (namespace_decl && !DIEIsInNamespace (namespace_decl, dwarf_cu, die)) 4252 continue; 4253 4254 Type *matching_type = ResolveType (dwarf_cu, die); 4255 if (matching_type) 4256 { 4257 // We found a type pointer, now find the shared pointer form our type list 4258 types.InsertUnique (matching_type->shared_from_this()); 4259 if (types.GetSize() >= max_matches) 4260 break; 4261 } 4262 } 4263 else 4264 { 4265 if (m_using_apple_tables) 4266 { 4267 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_types accelerator table had bad die 0x%8.8x for '%s')\n", 4268 die_offset, name.GetCString()); 4269 } 4270 } 4271 4272 } 4273 const uint32_t num_matches = types.GetSize() - initial_types_size; 4274 if (log && num_matches) 4275 { 4276 if (namespace_decl) 4277 { 4278 GetObjectFile()->GetModule()->LogMessage (log, 4279 "SymbolFileDWARF::FindTypes (sc, name=\"%s\", clang::NamespaceDecl(%p) \"%s\", append=%u, max_matches=%u, type_list) => %u", 4280 name.GetCString(), 4281 static_cast<void*>(namespace_decl->GetNamespaceDecl()), 4282 namespace_decl->GetQualifiedName().c_str(), 4283 append, max_matches, 4284 num_matches); 4285 } 4286 else 4287 { 4288 GetObjectFile()->GetModule()->LogMessage (log, 4289 "SymbolFileDWARF::FindTypes (sc, name=\"%s\", clang::NamespaceDecl(NULL), append=%u, max_matches=%u, type_list) => %u", 4290 name.GetCString(), 4291 append, max_matches, 4292 num_matches); 4293 } 4294 } 4295 return num_matches; 4296 } 4297 return 0; 4298 } 4299 4300 4301 ClangNamespaceDecl 4302 SymbolFileDWARF::FindNamespace (const SymbolContext& sc, 4303 const ConstString &name, 4304 const lldb_private::ClangNamespaceDecl *parent_namespace_decl) 4305 { 4306 Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS)); 4307 4308 if (log) 4309 { 4310 GetObjectFile()->GetModule()->LogMessage (log, 4311 "SymbolFileDWARF::FindNamespace (sc, name=\"%s\")", 4312 name.GetCString()); 4313 } 4314 4315 if (!NamespaceDeclMatchesThisSymbolFile(parent_namespace_decl)) 4316 return ClangNamespaceDecl(); 4317 4318 ClangNamespaceDecl namespace_decl; 4319 DWARFDebugInfo* info = DebugInfo(); 4320 if (info) 4321 { 4322 DIEArray die_offsets; 4323 4324 // Index if we already haven't to make sure the compile units 4325 // get indexed and make their global DIE index list 4326 if (m_using_apple_tables) 4327 { 4328 if (m_apple_namespaces_ap.get()) 4329 { 4330 const char *name_cstr = name.GetCString(); 4331 m_apple_namespaces_ap->FindByName (name_cstr, die_offsets); 4332 } 4333 } 4334 else 4335 { 4336 if (!m_indexed) 4337 Index (); 4338 4339 m_namespace_index.Find (name, die_offsets); 4340 } 4341 4342 DWARFCompileUnit* dwarf_cu = NULL; 4343 const DWARFDebugInfoEntry* die = NULL; 4344 const size_t num_matches = die_offsets.size(); 4345 if (num_matches) 4346 { 4347 DWARFDebugInfo* debug_info = DebugInfo(); 4348 for (size_t i=0; i<num_matches; ++i) 4349 { 4350 const dw_offset_t die_offset = die_offsets[i]; 4351 die = debug_info->GetDIEPtrWithCompileUnitHint (die_offset, &dwarf_cu); 4352 4353 if (die) 4354 { 4355 if (parent_namespace_decl && !DIEIsInNamespace (parent_namespace_decl, dwarf_cu, die)) 4356 continue; 4357 4358 clang::NamespaceDecl *clang_namespace_decl = ResolveNamespaceDIE (dwarf_cu, die); 4359 if (clang_namespace_decl) 4360 { 4361 namespace_decl.SetASTContext (GetClangASTContext().getASTContext()); 4362 namespace_decl.SetNamespaceDecl (clang_namespace_decl); 4363 break; 4364 } 4365 } 4366 else 4367 { 4368 if (m_using_apple_tables) 4369 { 4370 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_namespaces accelerator table had bad die 0x%8.8x for '%s')\n", 4371 die_offset, name.GetCString()); 4372 } 4373 } 4374 4375 } 4376 } 4377 } 4378 if (log && namespace_decl.GetNamespaceDecl()) 4379 { 4380 GetObjectFile()->GetModule()->LogMessage (log, 4381 "SymbolFileDWARF::FindNamespace (sc, name=\"%s\") => clang::NamespaceDecl(%p) \"%s\"", 4382 name.GetCString(), 4383 static_cast<const void*>(namespace_decl.GetNamespaceDecl()), 4384 namespace_decl.GetQualifiedName().c_str()); 4385 } 4386 4387 return namespace_decl; 4388 } 4389 4390 uint32_t 4391 SymbolFileDWARF::FindTypes(std::vector<dw_offset_t> die_offsets, uint32_t max_matches, TypeList& types) 4392 { 4393 // Remember how many sc_list are in the list before we search in case 4394 // we are appending the results to a variable list. 4395 uint32_t original_size = types.GetSize(); 4396 4397 const uint32_t num_die_offsets = die_offsets.size(); 4398 // Parse all of the types we found from the pubtypes matches 4399 uint32_t i; 4400 uint32_t num_matches = 0; 4401 for (i = 0; i < num_die_offsets; ++i) 4402 { 4403 Type *matching_type = ResolveTypeUID (die_offsets[i]); 4404 if (matching_type) 4405 { 4406 // We found a type pointer, now find the shared pointer form our type list 4407 types.InsertUnique (matching_type->shared_from_this()); 4408 ++num_matches; 4409 if (num_matches >= max_matches) 4410 break; 4411 } 4412 } 4413 4414 // Return the number of variable that were appended to the list 4415 return types.GetSize() - original_size; 4416 } 4417 4418 4419 size_t 4420 SymbolFileDWARF::ParseChildParameters (const SymbolContext& sc, 4421 clang::DeclContext *containing_decl_ctx, 4422 DWARFCompileUnit* dwarf_cu, 4423 const DWARFDebugInfoEntry *parent_die, 4424 bool skip_artificial, 4425 bool &is_static, 4426 bool &is_variadic, 4427 std::vector<ClangASTType>& function_param_types, 4428 std::vector<clang::ParmVarDecl*>& function_param_decls, 4429 unsigned &type_quals) // , 4430 // ClangASTContext::TemplateParameterInfos &template_param_infos)) 4431 { 4432 if (parent_die == NULL) 4433 return 0; 4434 4435 const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (dwarf_cu->GetAddressByteSize(), dwarf_cu->IsDWARF64()); 4436 4437 size_t arg_idx = 0; 4438 const DWARFDebugInfoEntry *die; 4439 for (die = parent_die->GetFirstChild(); die != NULL; die = die->GetSibling()) 4440 { 4441 dw_tag_t tag = die->Tag(); 4442 switch (tag) 4443 { 4444 case DW_TAG_formal_parameter: 4445 { 4446 DWARFDebugInfoEntry::Attributes attributes; 4447 const size_t num_attributes = die->GetAttributes(this, dwarf_cu, fixed_form_sizes, attributes); 4448 if (num_attributes > 0) 4449 { 4450 const char *name = NULL; 4451 Declaration decl; 4452 dw_offset_t param_type_die_offset = DW_INVALID_OFFSET; 4453 bool is_artificial = false; 4454 // one of None, Auto, Register, Extern, Static, PrivateExtern 4455 4456 clang::StorageClass storage = clang::SC_None; 4457 uint32_t i; 4458 for (i=0; i<num_attributes; ++i) 4459 { 4460 const dw_attr_t attr = attributes.AttributeAtIndex(i); 4461 DWARFFormValue form_value; 4462 if (attributes.ExtractFormValueAtIndex(this, i, form_value)) 4463 { 4464 switch (attr) 4465 { 4466 case DW_AT_decl_file: decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned())); break; 4467 case DW_AT_decl_line: decl.SetLine(form_value.Unsigned()); break; 4468 case DW_AT_decl_column: decl.SetColumn(form_value.Unsigned()); break; 4469 case DW_AT_name: name = form_value.AsCString(&get_debug_str_data()); break; 4470 case DW_AT_type: param_type_die_offset = form_value.Reference(); break; 4471 case DW_AT_artificial: is_artificial = form_value.Boolean(); break; 4472 case DW_AT_location: 4473 // if (form_value.BlockData()) 4474 // { 4475 // const DWARFDataExtractor& debug_info_data = debug_info(); 4476 // uint32_t block_length = form_value.Unsigned(); 4477 // DWARFDataExtractor location(debug_info_data, form_value.BlockData() - debug_info_data.GetDataStart(), block_length); 4478 // } 4479 // else 4480 // { 4481 // } 4482 // break; 4483 case DW_AT_const_value: 4484 case DW_AT_default_value: 4485 case DW_AT_description: 4486 case DW_AT_endianity: 4487 case DW_AT_is_optional: 4488 case DW_AT_segment: 4489 case DW_AT_variable_parameter: 4490 default: 4491 case DW_AT_abstract_origin: 4492 case DW_AT_sibling: 4493 break; 4494 } 4495 } 4496 } 4497 4498 bool skip = false; 4499 if (skip_artificial) 4500 { 4501 if (is_artificial) 4502 { 4503 // In order to determine if a C++ member function is 4504 // "const" we have to look at the const-ness of "this"... 4505 // Ugly, but that 4506 if (arg_idx == 0) 4507 { 4508 if (DeclKindIsCXXClass(containing_decl_ctx->getDeclKind())) 4509 { 4510 // Often times compilers omit the "this" name for the 4511 // specification DIEs, so we can't rely upon the name 4512 // being in the formal parameter DIE... 4513 if (name == NULL || ::strcmp(name, "this")==0) 4514 { 4515 Type *this_type = ResolveTypeUID (param_type_die_offset); 4516 if (this_type) 4517 { 4518 uint32_t encoding_mask = this_type->GetEncodingMask(); 4519 if (encoding_mask & Type::eEncodingIsPointerUID) 4520 { 4521 is_static = false; 4522 4523 if (encoding_mask & (1u << Type::eEncodingIsConstUID)) 4524 type_quals |= clang::Qualifiers::Const; 4525 if (encoding_mask & (1u << Type::eEncodingIsVolatileUID)) 4526 type_quals |= clang::Qualifiers::Volatile; 4527 } 4528 } 4529 } 4530 } 4531 } 4532 skip = true; 4533 } 4534 else 4535 { 4536 4537 // HACK: Objective C formal parameters "self" and "_cmd" 4538 // are not marked as artificial in the DWARF... 4539 CompileUnit *comp_unit = GetCompUnitForDWARFCompUnit(dwarf_cu, UINT32_MAX); 4540 if (comp_unit) 4541 { 4542 switch (comp_unit->GetLanguage()) 4543 { 4544 case eLanguageTypeObjC: 4545 case eLanguageTypeObjC_plus_plus: 4546 if (name && name[0] && (strcmp (name, "self") == 0 || strcmp (name, "_cmd") == 0)) 4547 skip = true; 4548 break; 4549 default: 4550 break; 4551 } 4552 } 4553 } 4554 } 4555 4556 if (!skip) 4557 { 4558 Type *type = ResolveTypeUID(param_type_die_offset); 4559 if (type) 4560 { 4561 function_param_types.push_back (type->GetClangForwardType()); 4562 4563 clang::ParmVarDecl *param_var_decl = GetClangASTContext().CreateParameterDeclaration (name, 4564 type->GetClangForwardType(), 4565 storage); 4566 assert(param_var_decl); 4567 function_param_decls.push_back(param_var_decl); 4568 4569 GetClangASTContext().SetMetadataAsUserID (param_var_decl, MakeUserID(die->GetOffset())); 4570 } 4571 } 4572 } 4573 arg_idx++; 4574 } 4575 break; 4576 4577 case DW_TAG_unspecified_parameters: 4578 is_variadic = true; 4579 break; 4580 4581 case DW_TAG_template_type_parameter: 4582 case DW_TAG_template_value_parameter: 4583 // The one caller of this was never using the template_param_infos, 4584 // and the local variable was taking up a large amount of stack space 4585 // in SymbolFileDWARF::ParseType() so this was removed. If we ever need 4586 // the template params back, we can add them back. 4587 // ParseTemplateDIE (dwarf_cu, die, template_param_infos); 4588 break; 4589 4590 default: 4591 break; 4592 } 4593 } 4594 return arg_idx; 4595 } 4596 4597 size_t 4598 SymbolFileDWARF::ParseChildEnumerators 4599 ( 4600 const SymbolContext& sc, 4601 lldb_private::ClangASTType &clang_type, 4602 bool is_signed, 4603 uint32_t enumerator_byte_size, 4604 DWARFCompileUnit* dwarf_cu, 4605 const DWARFDebugInfoEntry *parent_die 4606 ) 4607 { 4608 if (parent_die == NULL) 4609 return 0; 4610 4611 size_t enumerators_added = 0; 4612 const DWARFDebugInfoEntry *die; 4613 const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (dwarf_cu->GetAddressByteSize(), dwarf_cu->IsDWARF64()); 4614 4615 for (die = parent_die->GetFirstChild(); die != NULL; die = die->GetSibling()) 4616 { 4617 const dw_tag_t tag = die->Tag(); 4618 if (tag == DW_TAG_enumerator) 4619 { 4620 DWARFDebugInfoEntry::Attributes attributes; 4621 const size_t num_child_attributes = die->GetAttributes(this, dwarf_cu, fixed_form_sizes, attributes); 4622 if (num_child_attributes > 0) 4623 { 4624 const char *name = NULL; 4625 bool got_value = false; 4626 int64_t enum_value = 0; 4627 Declaration decl; 4628 4629 uint32_t i; 4630 for (i=0; i<num_child_attributes; ++i) 4631 { 4632 const dw_attr_t attr = attributes.AttributeAtIndex(i); 4633 DWARFFormValue form_value; 4634 if (attributes.ExtractFormValueAtIndex(this, i, form_value)) 4635 { 4636 switch (attr) 4637 { 4638 case DW_AT_const_value: 4639 got_value = true; 4640 if (is_signed) 4641 enum_value = form_value.Signed(); 4642 else 4643 enum_value = form_value.Unsigned(); 4644 break; 4645 4646 case DW_AT_name: 4647 name = form_value.AsCString(&get_debug_str_data()); 4648 break; 4649 4650 case DW_AT_description: 4651 default: 4652 case DW_AT_decl_file: decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned())); break; 4653 case DW_AT_decl_line: decl.SetLine(form_value.Unsigned()); break; 4654 case DW_AT_decl_column: decl.SetColumn(form_value.Unsigned()); break; 4655 case DW_AT_sibling: 4656 break; 4657 } 4658 } 4659 } 4660 4661 if (name && name[0] && got_value) 4662 { 4663 clang_type.AddEnumerationValueToEnumerationType (clang_type.GetEnumerationIntegerType(), 4664 decl, 4665 name, 4666 enum_value, 4667 enumerator_byte_size * 8); 4668 ++enumerators_added; 4669 } 4670 } 4671 } 4672 } 4673 return enumerators_added; 4674 } 4675 4676 void 4677 SymbolFileDWARF::ParseChildArrayInfo 4678 ( 4679 const SymbolContext& sc, 4680 DWARFCompileUnit* dwarf_cu, 4681 const DWARFDebugInfoEntry *parent_die, 4682 int64_t& first_index, 4683 std::vector<uint64_t>& element_orders, 4684 uint32_t& byte_stride, 4685 uint32_t& bit_stride 4686 ) 4687 { 4688 if (parent_die == NULL) 4689 return; 4690 4691 const DWARFDebugInfoEntry *die; 4692 const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (dwarf_cu->GetAddressByteSize(), dwarf_cu->IsDWARF64()); 4693 for (die = parent_die->GetFirstChild(); die != NULL; die = die->GetSibling()) 4694 { 4695 const dw_tag_t tag = die->Tag(); 4696 switch (tag) 4697 { 4698 case DW_TAG_subrange_type: 4699 { 4700 DWARFDebugInfoEntry::Attributes attributes; 4701 const size_t num_child_attributes = die->GetAttributes(this, dwarf_cu, fixed_form_sizes, attributes); 4702 if (num_child_attributes > 0) 4703 { 4704 uint64_t num_elements = 0; 4705 uint64_t lower_bound = 0; 4706 uint64_t upper_bound = 0; 4707 bool upper_bound_valid = false; 4708 uint32_t i; 4709 for (i=0; i<num_child_attributes; ++i) 4710 { 4711 const dw_attr_t attr = attributes.AttributeAtIndex(i); 4712 DWARFFormValue form_value; 4713 if (attributes.ExtractFormValueAtIndex(this, i, form_value)) 4714 { 4715 switch (attr) 4716 { 4717 case DW_AT_name: 4718 break; 4719 4720 case DW_AT_count: 4721 num_elements = form_value.Unsigned(); 4722 break; 4723 4724 case DW_AT_bit_stride: 4725 bit_stride = form_value.Unsigned(); 4726 break; 4727 4728 case DW_AT_byte_stride: 4729 byte_stride = form_value.Unsigned(); 4730 break; 4731 4732 case DW_AT_lower_bound: 4733 lower_bound = form_value.Unsigned(); 4734 break; 4735 4736 case DW_AT_upper_bound: 4737 upper_bound_valid = true; 4738 upper_bound = form_value.Unsigned(); 4739 break; 4740 4741 default: 4742 case DW_AT_abstract_origin: 4743 case DW_AT_accessibility: 4744 case DW_AT_allocated: 4745 case DW_AT_associated: 4746 case DW_AT_data_location: 4747 case DW_AT_declaration: 4748 case DW_AT_description: 4749 case DW_AT_sibling: 4750 case DW_AT_threads_scaled: 4751 case DW_AT_type: 4752 case DW_AT_visibility: 4753 break; 4754 } 4755 } 4756 } 4757 4758 if (num_elements == 0) 4759 { 4760 if (upper_bound_valid && upper_bound >= lower_bound) 4761 num_elements = upper_bound - lower_bound + 1; 4762 } 4763 4764 element_orders.push_back (num_elements); 4765 } 4766 } 4767 break; 4768 } 4769 } 4770 } 4771 4772 TypeSP 4773 SymbolFileDWARF::GetTypeForDIE (DWARFCompileUnit *dwarf_cu, const DWARFDebugInfoEntry* die) 4774 { 4775 TypeSP type_sp; 4776 if (die != NULL) 4777 { 4778 assert(dwarf_cu != NULL); 4779 Type *type_ptr = m_die_to_type.lookup (die); 4780 if (type_ptr == NULL) 4781 { 4782 CompileUnit* lldb_cu = GetCompUnitForDWARFCompUnit(dwarf_cu); 4783 assert (lldb_cu); 4784 SymbolContext sc(lldb_cu); 4785 type_sp = ParseType(sc, dwarf_cu, die, NULL); 4786 } 4787 else if (type_ptr != DIE_IS_BEING_PARSED) 4788 { 4789 // Grab the existing type from the master types lists 4790 type_sp = type_ptr->shared_from_this(); 4791 } 4792 4793 } 4794 return type_sp; 4795 } 4796 4797 clang::DeclContext * 4798 SymbolFileDWARF::GetClangDeclContextContainingDIEOffset (dw_offset_t die_offset) 4799 { 4800 if (die_offset != DW_INVALID_OFFSET) 4801 { 4802 DWARFCompileUnitSP cu_sp; 4803 const DWARFDebugInfoEntry* die = DebugInfo()->GetDIEPtr(die_offset, &cu_sp); 4804 return GetClangDeclContextContainingDIE (cu_sp.get(), die, NULL); 4805 } 4806 return NULL; 4807 } 4808 4809 clang::DeclContext * 4810 SymbolFileDWARF::GetClangDeclContextForDIEOffset (const SymbolContext &sc, dw_offset_t die_offset) 4811 { 4812 if (die_offset != DW_INVALID_OFFSET) 4813 { 4814 DWARFDebugInfo* debug_info = DebugInfo(); 4815 if (debug_info) 4816 { 4817 DWARFCompileUnitSP cu_sp; 4818 const DWARFDebugInfoEntry* die = debug_info->GetDIEPtr(die_offset, &cu_sp); 4819 if (die) 4820 return GetClangDeclContextForDIE (sc, cu_sp.get(), die); 4821 } 4822 } 4823 return NULL; 4824 } 4825 4826 clang::NamespaceDecl * 4827 SymbolFileDWARF::ResolveNamespaceDIE (DWARFCompileUnit *dwarf_cu, const DWARFDebugInfoEntry *die) 4828 { 4829 if (die && die->Tag() == DW_TAG_namespace) 4830 { 4831 // See if we already parsed this namespace DIE and associated it with a 4832 // uniqued namespace declaration 4833 clang::NamespaceDecl *namespace_decl = static_cast<clang::NamespaceDecl *>(m_die_to_decl_ctx[die]); 4834 if (namespace_decl) 4835 return namespace_decl; 4836 else 4837 { 4838 const char *namespace_name = die->GetAttributeValueAsString(this, dwarf_cu, DW_AT_name, NULL); 4839 clang::DeclContext *containing_decl_ctx = GetClangDeclContextContainingDIE (dwarf_cu, die, NULL); 4840 namespace_decl = GetClangASTContext().GetUniqueNamespaceDeclaration (namespace_name, containing_decl_ctx); 4841 Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO)); 4842 if (log) 4843 { 4844 if (namespace_name) 4845 { 4846 GetObjectFile()->GetModule()->LogMessage (log, 4847 "ASTContext => %p: 0x%8.8" PRIx64 ": DW_TAG_namespace with DW_AT_name(\"%s\") => clang::NamespaceDecl *%p (original = %p)", 4848 static_cast<void*>(GetClangASTContext().getASTContext()), 4849 MakeUserID(die->GetOffset()), 4850 namespace_name, 4851 static_cast<void*>(namespace_decl), 4852 static_cast<void*>(namespace_decl->getOriginalNamespace())); 4853 } 4854 else 4855 { 4856 GetObjectFile()->GetModule()->LogMessage (log, 4857 "ASTContext => %p: 0x%8.8" PRIx64 ": DW_TAG_namespace (anonymous) => clang::NamespaceDecl *%p (original = %p)", 4858 static_cast<void*>(GetClangASTContext().getASTContext()), 4859 MakeUserID(die->GetOffset()), 4860 static_cast<void*>(namespace_decl), 4861 static_cast<void*>(namespace_decl->getOriginalNamespace())); 4862 } 4863 } 4864 4865 if (namespace_decl) 4866 LinkDeclContextToDIE((clang::DeclContext*)namespace_decl, die); 4867 return namespace_decl; 4868 } 4869 } 4870 return NULL; 4871 } 4872 4873 clang::DeclContext * 4874 SymbolFileDWARF::GetClangDeclContextForDIE (const SymbolContext &sc, DWARFCompileUnit *cu, const DWARFDebugInfoEntry *die) 4875 { 4876 clang::DeclContext *clang_decl_ctx = GetCachedClangDeclContextForDIE (die); 4877 if (clang_decl_ctx) 4878 return clang_decl_ctx; 4879 // If this DIE has a specification, or an abstract origin, then trace to those. 4880 4881 dw_offset_t die_offset = die->GetAttributeValueAsReference(this, cu, DW_AT_specification, DW_INVALID_OFFSET); 4882 if (die_offset != DW_INVALID_OFFSET) 4883 return GetClangDeclContextForDIEOffset (sc, die_offset); 4884 4885 die_offset = die->GetAttributeValueAsReference(this, cu, DW_AT_abstract_origin, DW_INVALID_OFFSET); 4886 if (die_offset != DW_INVALID_OFFSET) 4887 return GetClangDeclContextForDIEOffset (sc, die_offset); 4888 4889 Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO)); 4890 if (log) 4891 GetObjectFile()->GetModule()->LogMessage(log, "SymbolFileDWARF::GetClangDeclContextForDIE (die = 0x%8.8x) %s '%s'", die->GetOffset(), DW_TAG_value_to_name(die->Tag()), die->GetName(this, cu)); 4892 // This is the DIE we want. Parse it, then query our map. 4893 bool assert_not_being_parsed = true; 4894 ResolveTypeUID (cu, die, assert_not_being_parsed); 4895 4896 clang_decl_ctx = GetCachedClangDeclContextForDIE (die); 4897 4898 return clang_decl_ctx; 4899 } 4900 4901 clang::DeclContext * 4902 SymbolFileDWARF::GetClangDeclContextContainingDIE (DWARFCompileUnit *cu, const DWARFDebugInfoEntry *die, const DWARFDebugInfoEntry **decl_ctx_die_copy) 4903 { 4904 if (m_clang_tu_decl == NULL) 4905 m_clang_tu_decl = GetClangASTContext().getASTContext()->getTranslationUnitDecl(); 4906 4907 const DWARFDebugInfoEntry *decl_ctx_die = GetDeclContextDIEContainingDIE (cu, die); 4908 4909 if (decl_ctx_die_copy) 4910 *decl_ctx_die_copy = decl_ctx_die; 4911 4912 if (decl_ctx_die) 4913 { 4914 4915 DIEToDeclContextMap::iterator pos = m_die_to_decl_ctx.find (decl_ctx_die); 4916 if (pos != m_die_to_decl_ctx.end()) 4917 return pos->second; 4918 4919 switch (decl_ctx_die->Tag()) 4920 { 4921 case DW_TAG_compile_unit: 4922 return m_clang_tu_decl; 4923 4924 case DW_TAG_namespace: 4925 return ResolveNamespaceDIE (cu, decl_ctx_die); 4926 break; 4927 4928 case DW_TAG_structure_type: 4929 case DW_TAG_union_type: 4930 case DW_TAG_class_type: 4931 { 4932 Type* type = ResolveType (cu, decl_ctx_die); 4933 if (type) 4934 { 4935 clang::DeclContext *decl_ctx = type->GetClangForwardType().GetDeclContextForType (); 4936 if (decl_ctx) 4937 { 4938 LinkDeclContextToDIE (decl_ctx, decl_ctx_die); 4939 if (decl_ctx) 4940 return decl_ctx; 4941 } 4942 } 4943 } 4944 break; 4945 4946 default: 4947 break; 4948 } 4949 } 4950 return m_clang_tu_decl; 4951 } 4952 4953 4954 const DWARFDebugInfoEntry * 4955 SymbolFileDWARF::GetDeclContextDIEContainingDIE (DWARFCompileUnit *cu, const DWARFDebugInfoEntry *die) 4956 { 4957 if (cu && die) 4958 { 4959 const DWARFDebugInfoEntry * const decl_die = die; 4960 4961 while (die != NULL) 4962 { 4963 // If this is the original DIE that we are searching for a declaration 4964 // for, then don't look in the cache as we don't want our own decl 4965 // context to be our decl context... 4966 if (decl_die != die) 4967 { 4968 switch (die->Tag()) 4969 { 4970 case DW_TAG_compile_unit: 4971 case DW_TAG_namespace: 4972 case DW_TAG_structure_type: 4973 case DW_TAG_union_type: 4974 case DW_TAG_class_type: 4975 return die; 4976 4977 default: 4978 break; 4979 } 4980 } 4981 4982 dw_offset_t die_offset = die->GetAttributeValueAsReference(this, cu, DW_AT_specification, DW_INVALID_OFFSET); 4983 if (die_offset != DW_INVALID_OFFSET) 4984 { 4985 DWARFCompileUnit *spec_cu = cu; 4986 const DWARFDebugInfoEntry *spec_die = DebugInfo()->GetDIEPtrWithCompileUnitHint (die_offset, &spec_cu); 4987 const DWARFDebugInfoEntry *spec_die_decl_ctx_die = GetDeclContextDIEContainingDIE (spec_cu, spec_die); 4988 if (spec_die_decl_ctx_die) 4989 return spec_die_decl_ctx_die; 4990 } 4991 4992 die_offset = die->GetAttributeValueAsReference(this, cu, DW_AT_abstract_origin, DW_INVALID_OFFSET); 4993 if (die_offset != DW_INVALID_OFFSET) 4994 { 4995 DWARFCompileUnit *abs_cu = cu; 4996 const DWARFDebugInfoEntry *abs_die = DebugInfo()->GetDIEPtrWithCompileUnitHint (die_offset, &abs_cu); 4997 const DWARFDebugInfoEntry *abs_die_decl_ctx_die = GetDeclContextDIEContainingDIE (abs_cu, abs_die); 4998 if (abs_die_decl_ctx_die) 4999 return abs_die_decl_ctx_die; 5000 } 5001 5002 die = die->GetParent(); 5003 } 5004 } 5005 return NULL; 5006 } 5007 5008 5009 Symbol * 5010 SymbolFileDWARF::GetObjCClassSymbol (const ConstString &objc_class_name) 5011 { 5012 Symbol *objc_class_symbol = NULL; 5013 if (m_obj_file) 5014 { 5015 Symtab *symtab = m_obj_file->GetSymtab (); 5016 if (symtab) 5017 { 5018 objc_class_symbol = symtab->FindFirstSymbolWithNameAndType (objc_class_name, 5019 eSymbolTypeObjCClass, 5020 Symtab::eDebugNo, 5021 Symtab::eVisibilityAny); 5022 } 5023 } 5024 return objc_class_symbol; 5025 } 5026 5027 // Some compilers don't emit the DW_AT_APPLE_objc_complete_type attribute. If they don't 5028 // then we can end up looking through all class types for a complete type and never find 5029 // the full definition. We need to know if this attribute is supported, so we determine 5030 // this here and cache th result. We also need to worry about the debug map DWARF file 5031 // if we are doing darwin DWARF in .o file debugging. 5032 bool 5033 SymbolFileDWARF::Supports_DW_AT_APPLE_objc_complete_type (DWARFCompileUnit *cu) 5034 { 5035 if (m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolCalculate) 5036 { 5037 m_supports_DW_AT_APPLE_objc_complete_type = eLazyBoolNo; 5038 if (cu && cu->Supports_DW_AT_APPLE_objc_complete_type()) 5039 m_supports_DW_AT_APPLE_objc_complete_type = eLazyBoolYes; 5040 else 5041 { 5042 DWARFDebugInfo* debug_info = DebugInfo(); 5043 const uint32_t num_compile_units = GetNumCompileUnits(); 5044 for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) 5045 { 5046 DWARFCompileUnit* dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx); 5047 if (dwarf_cu != cu && dwarf_cu->Supports_DW_AT_APPLE_objc_complete_type()) 5048 { 5049 m_supports_DW_AT_APPLE_objc_complete_type = eLazyBoolYes; 5050 break; 5051 } 5052 } 5053 } 5054 if (m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolNo && GetDebugMapSymfile ()) 5055 return m_debug_map_symfile->Supports_DW_AT_APPLE_objc_complete_type (this); 5056 } 5057 return m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolYes; 5058 } 5059 5060 // This function can be used when a DIE is found that is a forward declaration 5061 // DIE and we want to try and find a type that has the complete definition. 5062 TypeSP 5063 SymbolFileDWARF::FindCompleteObjCDefinitionTypeForDIE (const DWARFDebugInfoEntry *die, 5064 const ConstString &type_name, 5065 bool must_be_implementation) 5066 { 5067 5068 TypeSP type_sp; 5069 5070 if (!type_name || (must_be_implementation && !GetObjCClassSymbol (type_name))) 5071 return type_sp; 5072 5073 DIEArray die_offsets; 5074 5075 if (m_using_apple_tables) 5076 { 5077 if (m_apple_types_ap.get()) 5078 { 5079 const char *name_cstr = type_name.GetCString(); 5080 m_apple_types_ap->FindCompleteObjCClassByName (name_cstr, die_offsets, must_be_implementation); 5081 } 5082 } 5083 else 5084 { 5085 if (!m_indexed) 5086 Index (); 5087 5088 m_type_index.Find (type_name, die_offsets); 5089 } 5090 5091 const size_t num_matches = die_offsets.size(); 5092 5093 DWARFCompileUnit* type_cu = NULL; 5094 const DWARFDebugInfoEntry* type_die = NULL; 5095 if (num_matches) 5096 { 5097 DWARFDebugInfo* debug_info = DebugInfo(); 5098 for (size_t i=0; i<num_matches; ++i) 5099 { 5100 const dw_offset_t die_offset = die_offsets[i]; 5101 type_die = debug_info->GetDIEPtrWithCompileUnitHint (die_offset, &type_cu); 5102 5103 if (type_die) 5104 { 5105 bool try_resolving_type = false; 5106 5107 // Don't try and resolve the DIE we are looking for with the DIE itself! 5108 if (type_die != die) 5109 { 5110 switch (type_die->Tag()) 5111 { 5112 case DW_TAG_class_type: 5113 case DW_TAG_structure_type: 5114 try_resolving_type = true; 5115 break; 5116 default: 5117 break; 5118 } 5119 } 5120 5121 if (try_resolving_type) 5122 { 5123 if (must_be_implementation && type_cu->Supports_DW_AT_APPLE_objc_complete_type()) 5124 try_resolving_type = type_die->GetAttributeValueAsUnsigned (this, type_cu, DW_AT_APPLE_objc_complete_type, 0); 5125 5126 if (try_resolving_type) 5127 { 5128 Type *resolved_type = ResolveType (type_cu, type_die, false); 5129 if (resolved_type && resolved_type != DIE_IS_BEING_PARSED) 5130 { 5131 DEBUG_PRINTF ("resolved 0x%8.8" PRIx64 " from %s to 0x%8.8" PRIx64 " (cu 0x%8.8" PRIx64 ")\n", 5132 MakeUserID(die->GetOffset()), 5133 m_obj_file->GetFileSpec().GetFilename().AsCString("<Unknown>"), 5134 MakeUserID(type_die->GetOffset()), 5135 MakeUserID(type_cu->GetOffset())); 5136 5137 if (die) 5138 m_die_to_type[die] = resolved_type; 5139 type_sp = resolved_type->shared_from_this(); 5140 break; 5141 } 5142 } 5143 } 5144 } 5145 else 5146 { 5147 if (m_using_apple_tables) 5148 { 5149 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_types accelerator table had bad die 0x%8.8x for '%s')\n", 5150 die_offset, type_name.GetCString()); 5151 } 5152 } 5153 5154 } 5155 } 5156 return type_sp; 5157 } 5158 5159 5160 //---------------------------------------------------------------------- 5161 // This function helps to ensure that the declaration contexts match for 5162 // two different DIEs. Often times debug information will refer to a 5163 // forward declaration of a type (the equivalent of "struct my_struct;". 5164 // There will often be a declaration of that type elsewhere that has the 5165 // full definition. When we go looking for the full type "my_struct", we 5166 // will find one or more matches in the accelerator tables and we will 5167 // then need to make sure the type was in the same declaration context 5168 // as the original DIE. This function can efficiently compare two DIEs 5169 // and will return true when the declaration context matches, and false 5170 // when they don't. 5171 //---------------------------------------------------------------------- 5172 bool 5173 SymbolFileDWARF::DIEDeclContextsMatch (DWARFCompileUnit* cu1, const DWARFDebugInfoEntry *die1, 5174 DWARFCompileUnit* cu2, const DWARFDebugInfoEntry *die2) 5175 { 5176 if (die1 == die2) 5177 return true; 5178 5179 #if defined (LLDB_CONFIGURATION_DEBUG) 5180 // You can't and shouldn't call this function with a compile unit from 5181 // two different SymbolFileDWARF instances. 5182 assert (DebugInfo()->ContainsCompileUnit (cu1)); 5183 assert (DebugInfo()->ContainsCompileUnit (cu2)); 5184 #endif 5185 5186 DWARFDIECollection decl_ctx_1; 5187 DWARFDIECollection decl_ctx_2; 5188 //The declaration DIE stack is a stack of the declaration context 5189 // DIEs all the way back to the compile unit. If a type "T" is 5190 // declared inside a class "B", and class "B" is declared inside 5191 // a class "A" and class "A" is in a namespace "lldb", and the 5192 // namespace is in a compile unit, there will be a stack of DIEs: 5193 // 5194 // [0] DW_TAG_class_type for "B" 5195 // [1] DW_TAG_class_type for "A" 5196 // [2] DW_TAG_namespace for "lldb" 5197 // [3] DW_TAG_compile_unit for the source file. 5198 // 5199 // We grab both contexts and make sure that everything matches 5200 // all the way back to the compiler unit. 5201 5202 // First lets grab the decl contexts for both DIEs 5203 die1->GetDeclContextDIEs (this, cu1, decl_ctx_1); 5204 die2->GetDeclContextDIEs (this, cu2, decl_ctx_2); 5205 // Make sure the context arrays have the same size, otherwise 5206 // we are done 5207 const size_t count1 = decl_ctx_1.Size(); 5208 const size_t count2 = decl_ctx_2.Size(); 5209 if (count1 != count2) 5210 return false; 5211 5212 // Make sure the DW_TAG values match all the way back up the 5213 // compile unit. If they don't, then we are done. 5214 const DWARFDebugInfoEntry *decl_ctx_die1; 5215 const DWARFDebugInfoEntry *decl_ctx_die2; 5216 size_t i; 5217 for (i=0; i<count1; i++) 5218 { 5219 decl_ctx_die1 = decl_ctx_1.GetDIEPtrAtIndex (i); 5220 decl_ctx_die2 = decl_ctx_2.GetDIEPtrAtIndex (i); 5221 if (decl_ctx_die1->Tag() != decl_ctx_die2->Tag()) 5222 return false; 5223 } 5224 #if defined LLDB_CONFIGURATION_DEBUG 5225 5226 // Make sure the top item in the decl context die array is always 5227 // DW_TAG_compile_unit. If it isn't then something went wrong in 5228 // the DWARFDebugInfoEntry::GetDeclContextDIEs() function... 5229 assert (decl_ctx_1.GetDIEPtrAtIndex (count1 - 1)->Tag() == DW_TAG_compile_unit); 5230 5231 #endif 5232 // Always skip the compile unit when comparing by only iterating up to 5233 // "count - 1". Here we compare the names as we go. 5234 for (i=0; i<count1 - 1; i++) 5235 { 5236 decl_ctx_die1 = decl_ctx_1.GetDIEPtrAtIndex (i); 5237 decl_ctx_die2 = decl_ctx_2.GetDIEPtrAtIndex (i); 5238 const char *name1 = decl_ctx_die1->GetName(this, cu1); 5239 const char *name2 = decl_ctx_die2->GetName(this, cu2); 5240 // If the string was from a DW_FORM_strp, then the pointer will often 5241 // be the same! 5242 if (name1 == name2) 5243 continue; 5244 5245 // Name pointers are not equal, so only compare the strings 5246 // if both are not NULL. 5247 if (name1 && name2) 5248 { 5249 // If the strings don't compare, we are done... 5250 if (strcmp(name1, name2) != 0) 5251 return false; 5252 } 5253 else 5254 { 5255 // One name was NULL while the other wasn't 5256 return false; 5257 } 5258 } 5259 // We made it through all of the checks and the declaration contexts 5260 // are equal. 5261 return true; 5262 } 5263 5264 5265 TypeSP 5266 SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext (const DWARFDeclContext &dwarf_decl_ctx) 5267 { 5268 TypeSP type_sp; 5269 5270 const uint32_t dwarf_decl_ctx_count = dwarf_decl_ctx.GetSize(); 5271 if (dwarf_decl_ctx_count > 0) 5272 { 5273 const ConstString type_name(dwarf_decl_ctx[0].name); 5274 const dw_tag_t tag = dwarf_decl_ctx[0].tag; 5275 5276 if (type_name) 5277 { 5278 Log *log (LogChannelDWARF::GetLogIfAny(DWARF_LOG_TYPE_COMPLETION|DWARF_LOG_LOOKUPS)); 5279 if (log) 5280 { 5281 GetObjectFile()->GetModule()->LogMessage (log, 5282 "SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext(tag=%s, qualified-name='%s')", 5283 DW_TAG_value_to_name(dwarf_decl_ctx[0].tag), 5284 dwarf_decl_ctx.GetQualifiedName()); 5285 } 5286 5287 DIEArray die_offsets; 5288 5289 if (m_using_apple_tables) 5290 { 5291 if (m_apple_types_ap.get()) 5292 { 5293 const bool has_tag = m_apple_types_ap->GetHeader().header_data.ContainsAtom (DWARFMappedHash::eAtomTypeTag); 5294 const bool has_qualified_name_hash = m_apple_types_ap->GetHeader().header_data.ContainsAtom (DWARFMappedHash::eAtomTypeQualNameHash); 5295 if (has_tag && has_qualified_name_hash) 5296 { 5297 const char *qualified_name = dwarf_decl_ctx.GetQualifiedName(); 5298 const uint32_t qualified_name_hash = MappedHash::HashStringUsingDJB (qualified_name); 5299 if (log) 5300 GetObjectFile()->GetModule()->LogMessage (log,"FindByNameAndTagAndQualifiedNameHash()"); 5301 m_apple_types_ap->FindByNameAndTagAndQualifiedNameHash (type_name.GetCString(), tag, qualified_name_hash, die_offsets); 5302 } 5303 else if (has_tag) 5304 { 5305 if (log) 5306 GetObjectFile()->GetModule()->LogMessage (log,"FindByNameAndTag()"); 5307 m_apple_types_ap->FindByNameAndTag (type_name.GetCString(), tag, die_offsets); 5308 } 5309 else 5310 { 5311 m_apple_types_ap->FindByName (type_name.GetCString(), die_offsets); 5312 } 5313 } 5314 } 5315 else 5316 { 5317 if (!m_indexed) 5318 Index (); 5319 5320 m_type_index.Find (type_name, die_offsets); 5321 } 5322 5323 const size_t num_matches = die_offsets.size(); 5324 5325 5326 DWARFCompileUnit* type_cu = NULL; 5327 const DWARFDebugInfoEntry* type_die = NULL; 5328 if (num_matches) 5329 { 5330 DWARFDebugInfo* debug_info = DebugInfo(); 5331 for (size_t i=0; i<num_matches; ++i) 5332 { 5333 const dw_offset_t die_offset = die_offsets[i]; 5334 type_die = debug_info->GetDIEPtrWithCompileUnitHint (die_offset, &type_cu); 5335 5336 if (type_die) 5337 { 5338 bool try_resolving_type = false; 5339 5340 // Don't try and resolve the DIE we are looking for with the DIE itself! 5341 const dw_tag_t type_tag = type_die->Tag(); 5342 // Make sure the tags match 5343 if (type_tag == tag) 5344 { 5345 // The tags match, lets try resolving this type 5346 try_resolving_type = true; 5347 } 5348 else 5349 { 5350 // The tags don't match, but we need to watch our for a 5351 // forward declaration for a struct and ("struct foo") 5352 // ends up being a class ("class foo { ... };") or 5353 // vice versa. 5354 switch (type_tag) 5355 { 5356 case DW_TAG_class_type: 5357 // We had a "class foo", see if we ended up with a "struct foo { ... };" 5358 try_resolving_type = (tag == DW_TAG_structure_type); 5359 break; 5360 case DW_TAG_structure_type: 5361 // We had a "struct foo", see if we ended up with a "class foo { ... };" 5362 try_resolving_type = (tag == DW_TAG_class_type); 5363 break; 5364 default: 5365 // Tags don't match, don't event try to resolve 5366 // using this type whose name matches.... 5367 break; 5368 } 5369 } 5370 5371 if (try_resolving_type) 5372 { 5373 DWARFDeclContext type_dwarf_decl_ctx; 5374 type_die->GetDWARFDeclContext (this, type_cu, type_dwarf_decl_ctx); 5375 5376 if (log) 5377 { 5378 GetObjectFile()->GetModule()->LogMessage (log, 5379 "SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext(tag=%s, qualified-name='%s') trying die=0x%8.8x (%s)", 5380 DW_TAG_value_to_name(dwarf_decl_ctx[0].tag), 5381 dwarf_decl_ctx.GetQualifiedName(), 5382 type_die->GetOffset(), 5383 type_dwarf_decl_ctx.GetQualifiedName()); 5384 } 5385 5386 // Make sure the decl contexts match all the way up 5387 if (dwarf_decl_ctx == type_dwarf_decl_ctx) 5388 { 5389 Type *resolved_type = ResolveType (type_cu, type_die, false); 5390 if (resolved_type && resolved_type != DIE_IS_BEING_PARSED) 5391 { 5392 type_sp = resolved_type->shared_from_this(); 5393 break; 5394 } 5395 } 5396 } 5397 else 5398 { 5399 if (log) 5400 { 5401 std::string qualified_name; 5402 type_die->GetQualifiedName(this, type_cu, qualified_name); 5403 GetObjectFile()->GetModule()->LogMessage (log, 5404 "SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext(tag=%s, qualified-name='%s') ignoring die=0x%8.8x (%s)", 5405 DW_TAG_value_to_name(dwarf_decl_ctx[0].tag), 5406 dwarf_decl_ctx.GetQualifiedName(), 5407 type_die->GetOffset(), 5408 qualified_name.c_str()); 5409 } 5410 } 5411 } 5412 else 5413 { 5414 if (m_using_apple_tables) 5415 { 5416 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_types accelerator table had bad die 0x%8.8x for '%s')\n", 5417 die_offset, type_name.GetCString()); 5418 } 5419 } 5420 5421 } 5422 } 5423 } 5424 } 5425 return type_sp; 5426 } 5427 5428 bool 5429 SymbolFileDWARF::CopyUniqueClassMethodTypes (SymbolFileDWARF *src_symfile, 5430 Type *class_type, 5431 DWARFCompileUnit* src_cu, 5432 const DWARFDebugInfoEntry *src_class_die, 5433 DWARFCompileUnit* dst_cu, 5434 const DWARFDebugInfoEntry *dst_class_die, 5435 DWARFDIECollection &failures) 5436 { 5437 if (!class_type || !src_cu || !src_class_die || !dst_cu || !dst_class_die) 5438 return false; 5439 if (src_class_die->Tag() != dst_class_die->Tag()) 5440 return false; 5441 5442 // We need to complete the class type so we can get all of the method types 5443 // parsed so we can then unique those types to their equivalent counterparts 5444 // in "dst_cu" and "dst_class_die" 5445 class_type->GetClangFullType(); 5446 5447 const DWARFDebugInfoEntry *src_die; 5448 const DWARFDebugInfoEntry *dst_die; 5449 UniqueCStringMap<const DWARFDebugInfoEntry *> src_name_to_die; 5450 UniqueCStringMap<const DWARFDebugInfoEntry *> dst_name_to_die; 5451 UniqueCStringMap<const DWARFDebugInfoEntry *> src_name_to_die_artificial; 5452 UniqueCStringMap<const DWARFDebugInfoEntry *> dst_name_to_die_artificial; 5453 for (src_die = src_class_die->GetFirstChild(); src_die != NULL; src_die = src_die->GetSibling()) 5454 { 5455 if (src_die->Tag() == DW_TAG_subprogram) 5456 { 5457 // Make sure this is a declaration and not a concrete instance by looking 5458 // for DW_AT_declaration set to 1. Sometimes concrete function instances 5459 // are placed inside the class definitions and shouldn't be included in 5460 // the list of things are are tracking here. 5461 if (src_die->GetAttributeValueAsUnsigned(src_symfile, src_cu, DW_AT_declaration, 0) == 1) 5462 { 5463 const char *src_name = src_die->GetMangledName (src_symfile, src_cu); 5464 if (src_name) 5465 { 5466 ConstString src_const_name(src_name); 5467 if (src_die->GetAttributeValueAsUnsigned(src_symfile, src_cu, DW_AT_artificial, 0)) 5468 src_name_to_die_artificial.Append(src_const_name.GetCString(), src_die); 5469 else 5470 src_name_to_die.Append(src_const_name.GetCString(), src_die); 5471 } 5472 } 5473 } 5474 } 5475 for (dst_die = dst_class_die->GetFirstChild(); dst_die != NULL; dst_die = dst_die->GetSibling()) 5476 { 5477 if (dst_die->Tag() == DW_TAG_subprogram) 5478 { 5479 // Make sure this is a declaration and not a concrete instance by looking 5480 // for DW_AT_declaration set to 1. Sometimes concrete function instances 5481 // are placed inside the class definitions and shouldn't be included in 5482 // the list of things are are tracking here. 5483 if (dst_die->GetAttributeValueAsUnsigned(this, dst_cu, DW_AT_declaration, 0) == 1) 5484 { 5485 const char *dst_name = dst_die->GetMangledName (this, dst_cu); 5486 if (dst_name) 5487 { 5488 ConstString dst_const_name(dst_name); 5489 if (dst_die->GetAttributeValueAsUnsigned(this, dst_cu, DW_AT_artificial, 0)) 5490 dst_name_to_die_artificial.Append(dst_const_name.GetCString(), dst_die); 5491 else 5492 dst_name_to_die.Append(dst_const_name.GetCString(), dst_die); 5493 } 5494 } 5495 } 5496 } 5497 const uint32_t src_size = src_name_to_die.GetSize (); 5498 const uint32_t dst_size = dst_name_to_die.GetSize (); 5499 Log *log (LogChannelDWARF::GetLogIfAny(DWARF_LOG_DEBUG_INFO | DWARF_LOG_TYPE_COMPLETION)); 5500 5501 // Is everything kosher so we can go through the members at top speed? 5502 bool fast_path = true; 5503 5504 if (src_size != dst_size) 5505 { 5506 if (src_size != 0 && dst_size != 0) 5507 { 5508 if (log) 5509 log->Printf("warning: trying to unique class DIE 0x%8.8x to 0x%8.8x, but they didn't have the same size (src=%d, dst=%d)", 5510 src_class_die->GetOffset(), 5511 dst_class_die->GetOffset(), 5512 src_size, 5513 dst_size); 5514 } 5515 5516 fast_path = false; 5517 } 5518 5519 uint32_t idx; 5520 5521 if (fast_path) 5522 { 5523 for (idx = 0; idx < src_size; ++idx) 5524 { 5525 src_die = src_name_to_die.GetValueAtIndexUnchecked (idx); 5526 dst_die = dst_name_to_die.GetValueAtIndexUnchecked (idx); 5527 5528 if (src_die->Tag() != dst_die->Tag()) 5529 { 5530 if (log) 5531 log->Printf("warning: tried to unique class DIE 0x%8.8x to 0x%8.8x, but 0x%8.8x (%s) tags didn't match 0x%8.8x (%s)", 5532 src_class_die->GetOffset(), 5533 dst_class_die->GetOffset(), 5534 src_die->GetOffset(), 5535 DW_TAG_value_to_name(src_die->Tag()), 5536 dst_die->GetOffset(), 5537 DW_TAG_value_to_name(src_die->Tag())); 5538 fast_path = false; 5539 } 5540 5541 const char *src_name = src_die->GetMangledName (src_symfile, src_cu); 5542 const char *dst_name = dst_die->GetMangledName (this, dst_cu); 5543 5544 // Make sure the names match 5545 if (src_name == dst_name || (strcmp (src_name, dst_name) == 0)) 5546 continue; 5547 5548 if (log) 5549 log->Printf("warning: tried to unique class DIE 0x%8.8x to 0x%8.8x, but 0x%8.8x (%s) names didn't match 0x%8.8x (%s)", 5550 src_class_die->GetOffset(), 5551 dst_class_die->GetOffset(), 5552 src_die->GetOffset(), 5553 src_name, 5554 dst_die->GetOffset(), 5555 dst_name); 5556 5557 fast_path = false; 5558 } 5559 } 5560 5561 // Now do the work of linking the DeclContexts and Types. 5562 if (fast_path) 5563 { 5564 // We can do this quickly. Just run across the tables index-for-index since 5565 // we know each node has matching names and tags. 5566 for (idx = 0; idx < src_size; ++idx) 5567 { 5568 src_die = src_name_to_die.GetValueAtIndexUnchecked (idx); 5569 dst_die = dst_name_to_die.GetValueAtIndexUnchecked (idx); 5570 5571 clang::DeclContext *src_decl_ctx = src_symfile->m_die_to_decl_ctx[src_die]; 5572 if (src_decl_ctx) 5573 { 5574 if (log) 5575 log->Printf ("uniquing decl context %p from 0x%8.8x for 0x%8.8x", 5576 static_cast<void*>(src_decl_ctx), 5577 src_die->GetOffset(), dst_die->GetOffset()); 5578 LinkDeclContextToDIE (src_decl_ctx, dst_die); 5579 } 5580 else 5581 { 5582 if (log) 5583 log->Printf ("warning: tried to unique decl context from 0x%8.8x for 0x%8.8x, but none was found", 5584 src_die->GetOffset(), dst_die->GetOffset()); 5585 } 5586 5587 Type *src_child_type = m_die_to_type[src_die]; 5588 if (src_child_type) 5589 { 5590 if (log) 5591 log->Printf ("uniquing type %p (uid=0x%" PRIx64 ") from 0x%8.8x for 0x%8.8x", 5592 static_cast<void*>(src_child_type), 5593 src_child_type->GetID(), 5594 src_die->GetOffset(), dst_die->GetOffset()); 5595 m_die_to_type[dst_die] = src_child_type; 5596 } 5597 else 5598 { 5599 if (log) 5600 log->Printf ("warning: tried to unique lldb_private::Type from 0x%8.8x for 0x%8.8x, but none was found", src_die->GetOffset(), dst_die->GetOffset()); 5601 } 5602 } 5603 } 5604 else 5605 { 5606 // We must do this slowly. For each member of the destination, look 5607 // up a member in the source with the same name, check its tag, and 5608 // unique them if everything matches up. Report failures. 5609 5610 if (!src_name_to_die.IsEmpty() && !dst_name_to_die.IsEmpty()) 5611 { 5612 src_name_to_die.Sort(); 5613 5614 for (idx = 0; idx < dst_size; ++idx) 5615 { 5616 const char *dst_name = dst_name_to_die.GetCStringAtIndex(idx); 5617 dst_die = dst_name_to_die.GetValueAtIndexUnchecked(idx); 5618 src_die = src_name_to_die.Find(dst_name, NULL); 5619 5620 if (src_die && (src_die->Tag() == dst_die->Tag())) 5621 { 5622 clang::DeclContext *src_decl_ctx = src_symfile->m_die_to_decl_ctx[src_die]; 5623 if (src_decl_ctx) 5624 { 5625 if (log) 5626 log->Printf ("uniquing decl context %p from 0x%8.8x for 0x%8.8x", 5627 static_cast<void*>(src_decl_ctx), 5628 src_die->GetOffset(), 5629 dst_die->GetOffset()); 5630 LinkDeclContextToDIE (src_decl_ctx, dst_die); 5631 } 5632 else 5633 { 5634 if (log) 5635 log->Printf ("warning: tried to unique decl context from 0x%8.8x for 0x%8.8x, but none was found", src_die->GetOffset(), dst_die->GetOffset()); 5636 } 5637 5638 Type *src_child_type = m_die_to_type[src_die]; 5639 if (src_child_type) 5640 { 5641 if (log) 5642 log->Printf ("uniquing type %p (uid=0x%" PRIx64 ") from 0x%8.8x for 0x%8.8x", 5643 static_cast<void*>(src_child_type), 5644 src_child_type->GetID(), 5645 src_die->GetOffset(), 5646 dst_die->GetOffset()); 5647 m_die_to_type[dst_die] = src_child_type; 5648 } 5649 else 5650 { 5651 if (log) 5652 log->Printf ("warning: tried to unique lldb_private::Type from 0x%8.8x for 0x%8.8x, but none was found", src_die->GetOffset(), dst_die->GetOffset()); 5653 } 5654 } 5655 else 5656 { 5657 if (log) 5658 log->Printf ("warning: couldn't find a match for 0x%8.8x", dst_die->GetOffset()); 5659 5660 failures.Append(dst_die); 5661 } 5662 } 5663 } 5664 } 5665 5666 const uint32_t src_size_artificial = src_name_to_die_artificial.GetSize (); 5667 const uint32_t dst_size_artificial = dst_name_to_die_artificial.GetSize (); 5668 5669 UniqueCStringMap<const DWARFDebugInfoEntry *> name_to_die_artificial_not_in_src; 5670 5671 if (src_size_artificial && dst_size_artificial) 5672 { 5673 dst_name_to_die_artificial.Sort(); 5674 5675 for (idx = 0; idx < src_size_artificial; ++idx) 5676 { 5677 const char *src_name_artificial = src_name_to_die_artificial.GetCStringAtIndex(idx); 5678 src_die = src_name_to_die_artificial.GetValueAtIndexUnchecked (idx); 5679 dst_die = dst_name_to_die_artificial.Find(src_name_artificial, NULL); 5680 5681 if (dst_die) 5682 { 5683 // Both classes have the artificial types, link them 5684 clang::DeclContext *src_decl_ctx = m_die_to_decl_ctx[src_die]; 5685 if (src_decl_ctx) 5686 { 5687 if (log) 5688 log->Printf ("uniquing decl context %p from 0x%8.8x for 0x%8.8x", 5689 static_cast<void*>(src_decl_ctx), 5690 src_die->GetOffset(), dst_die->GetOffset()); 5691 LinkDeclContextToDIE (src_decl_ctx, dst_die); 5692 } 5693 else 5694 { 5695 if (log) 5696 log->Printf ("warning: tried to unique decl context from 0x%8.8x for 0x%8.8x, but none was found", src_die->GetOffset(), dst_die->GetOffset()); 5697 } 5698 5699 Type *src_child_type = m_die_to_type[src_die]; 5700 if (src_child_type) 5701 { 5702 if (log) 5703 log->Printf ("uniquing type %p (uid=0x%" PRIx64 ") from 0x%8.8x for 0x%8.8x", 5704 static_cast<void*>(src_child_type), 5705 src_child_type->GetID(), 5706 src_die->GetOffset(), dst_die->GetOffset()); 5707 m_die_to_type[dst_die] = src_child_type; 5708 } 5709 else 5710 { 5711 if (log) 5712 log->Printf ("warning: tried to unique lldb_private::Type from 0x%8.8x for 0x%8.8x, but none was found", src_die->GetOffset(), dst_die->GetOffset()); 5713 } 5714 } 5715 } 5716 } 5717 5718 if (dst_size_artificial) 5719 { 5720 for (idx = 0; idx < dst_size_artificial; ++idx) 5721 { 5722 const char *dst_name_artificial = dst_name_to_die_artificial.GetCStringAtIndex(idx); 5723 dst_die = dst_name_to_die_artificial.GetValueAtIndexUnchecked (idx); 5724 if (log) 5725 log->Printf ("warning: need to create artificial method for 0x%8.8x for method '%s'", dst_die->GetOffset(), dst_name_artificial); 5726 5727 failures.Append(dst_die); 5728 } 5729 } 5730 5731 return (failures.Size() != 0); 5732 } 5733 5734 TypeSP 5735 SymbolFileDWARF::ParseType (const SymbolContext& sc, DWARFCompileUnit* dwarf_cu, const DWARFDebugInfoEntry *die, bool *type_is_new_ptr) 5736 { 5737 TypeSP type_sp; 5738 5739 if (type_is_new_ptr) 5740 *type_is_new_ptr = false; 5741 5742 #if defined(LLDB_CONFIGURATION_DEBUG) || defined(LLDB_CONFIGURATION_RELEASE) 5743 static DIEStack g_die_stack; 5744 DIEStack::ScopedPopper scoped_die_logger(g_die_stack); 5745 #endif 5746 5747 AccessType accessibility = eAccessNone; 5748 if (die != NULL) 5749 { 5750 Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO)); 5751 if (log) 5752 { 5753 const DWARFDebugInfoEntry *context_die; 5754 clang::DeclContext *context = GetClangDeclContextContainingDIE (dwarf_cu, die, &context_die); 5755 5756 GetObjectFile()->GetModule()->LogMessage (log, "SymbolFileDWARF::ParseType (die = 0x%8.8x, decl_ctx = %p (die 0x%8.8x)) %s name = '%s')", 5757 die->GetOffset(), 5758 static_cast<void*>(context), 5759 context_die->GetOffset(), 5760 DW_TAG_value_to_name(die->Tag()), 5761 die->GetName(this, dwarf_cu)); 5762 5763 #if defined(LLDB_CONFIGURATION_DEBUG) || defined(LLDB_CONFIGURATION_RELEASE) 5764 scoped_die_logger.Push (dwarf_cu, die); 5765 g_die_stack.LogDIEs(log, this); 5766 #endif 5767 } 5768 // 5769 // Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO)); 5770 // if (log && dwarf_cu) 5771 // { 5772 // StreamString s; 5773 // die->DumpLocation (this, dwarf_cu, s); 5774 // GetObjectFile()->GetModule()->LogMessage (log, "SymbolFileDwarf::%s %s", __FUNCTION__, s.GetData()); 5775 // 5776 // } 5777 5778 Type *type_ptr = m_die_to_type.lookup (die); 5779 TypeList* type_list = GetTypeList(); 5780 if (type_ptr == NULL) 5781 { 5782 ClangASTContext &ast = GetClangASTContext(); 5783 if (type_is_new_ptr) 5784 *type_is_new_ptr = true; 5785 5786 const dw_tag_t tag = die->Tag(); 5787 5788 bool is_forward_declaration = false; 5789 DWARFDebugInfoEntry::Attributes attributes; 5790 const char *type_name_cstr = NULL; 5791 ConstString type_name_const_str; 5792 Type::ResolveState resolve_state = Type::eResolveStateUnresolved; 5793 uint64_t byte_size = 0; 5794 Declaration decl; 5795 5796 Type::EncodingDataType encoding_data_type = Type::eEncodingIsUID; 5797 ClangASTType clang_type; 5798 DWARFFormValue form_value; 5799 5800 dw_attr_t attr; 5801 5802 switch (tag) 5803 { 5804 case DW_TAG_base_type: 5805 case DW_TAG_pointer_type: 5806 case DW_TAG_reference_type: 5807 case DW_TAG_rvalue_reference_type: 5808 case DW_TAG_typedef: 5809 case DW_TAG_const_type: 5810 case DW_TAG_restrict_type: 5811 case DW_TAG_volatile_type: 5812 case DW_TAG_unspecified_type: 5813 { 5814 // Set a bit that lets us know that we are currently parsing this 5815 m_die_to_type[die] = DIE_IS_BEING_PARSED; 5816 5817 const size_t num_attributes = die->GetAttributes(this, dwarf_cu, NULL, attributes); 5818 uint32_t encoding = 0; 5819 lldb::user_id_t encoding_uid = LLDB_INVALID_UID; 5820 5821 if (num_attributes > 0) 5822 { 5823 uint32_t i; 5824 for (i=0; i<num_attributes; ++i) 5825 { 5826 attr = attributes.AttributeAtIndex(i); 5827 if (attributes.ExtractFormValueAtIndex(this, i, form_value)) 5828 { 5829 switch (attr) 5830 { 5831 case DW_AT_decl_file: decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned())); break; 5832 case DW_AT_decl_line: decl.SetLine(form_value.Unsigned()); break; 5833 case DW_AT_decl_column: decl.SetColumn(form_value.Unsigned()); break; 5834 case DW_AT_name: 5835 5836 type_name_cstr = form_value.AsCString(&get_debug_str_data()); 5837 // Work around a bug in llvm-gcc where they give a name to a reference type which doesn't 5838 // include the "&"... 5839 if (tag == DW_TAG_reference_type) 5840 { 5841 if (strchr (type_name_cstr, '&') == NULL) 5842 type_name_cstr = NULL; 5843 } 5844 if (type_name_cstr) 5845 type_name_const_str.SetCString(type_name_cstr); 5846 break; 5847 case DW_AT_byte_size: byte_size = form_value.Unsigned(); break; 5848 case DW_AT_encoding: encoding = form_value.Unsigned(); break; 5849 case DW_AT_type: encoding_uid = form_value.Reference(); break; 5850 default: 5851 case DW_AT_sibling: 5852 break; 5853 } 5854 } 5855 } 5856 } 5857 5858 DEBUG_PRINTF ("0x%8.8" PRIx64 ": %s (\"%s\") type => 0x%8.8lx\n", MakeUserID(die->GetOffset()), DW_TAG_value_to_name(tag), type_name_cstr, encoding_uid); 5859 5860 switch (tag) 5861 { 5862 default: 5863 break; 5864 5865 case DW_TAG_unspecified_type: 5866 if (strcmp(type_name_cstr, "nullptr_t") == 0 || 5867 strcmp(type_name_cstr, "decltype(nullptr)") == 0 ) 5868 { 5869 resolve_state = Type::eResolveStateFull; 5870 clang_type = ast.GetBasicType(eBasicTypeNullPtr); 5871 break; 5872 } 5873 // Fall through to base type below in case we can handle the type there... 5874 5875 case DW_TAG_base_type: 5876 resolve_state = Type::eResolveStateFull; 5877 clang_type = ast.GetBuiltinTypeForDWARFEncodingAndBitSize (type_name_cstr, 5878 encoding, 5879 byte_size * 8); 5880 break; 5881 5882 case DW_TAG_pointer_type: encoding_data_type = Type::eEncodingIsPointerUID; break; 5883 case DW_TAG_reference_type: encoding_data_type = Type::eEncodingIsLValueReferenceUID; break; 5884 case DW_TAG_rvalue_reference_type: encoding_data_type = Type::eEncodingIsRValueReferenceUID; break; 5885 case DW_TAG_typedef: encoding_data_type = Type::eEncodingIsTypedefUID; break; 5886 case DW_TAG_const_type: encoding_data_type = Type::eEncodingIsConstUID; break; 5887 case DW_TAG_restrict_type: encoding_data_type = Type::eEncodingIsRestrictUID; break; 5888 case DW_TAG_volatile_type: encoding_data_type = Type::eEncodingIsVolatileUID; break; 5889 } 5890 5891 if (!clang_type && (encoding_data_type == Type::eEncodingIsPointerUID || encoding_data_type == Type::eEncodingIsTypedefUID) && sc.comp_unit != NULL) 5892 { 5893 bool translation_unit_is_objc = (sc.comp_unit->GetLanguage() == eLanguageTypeObjC || sc.comp_unit->GetLanguage() == eLanguageTypeObjC_plus_plus); 5894 5895 if (translation_unit_is_objc) 5896 { 5897 if (type_name_cstr != NULL) 5898 { 5899 static ConstString g_objc_type_name_id("id"); 5900 static ConstString g_objc_type_name_Class("Class"); 5901 static ConstString g_objc_type_name_selector("SEL"); 5902 5903 if (type_name_const_str == g_objc_type_name_id) 5904 { 5905 if (log) 5906 GetObjectFile()->GetModule()->LogMessage (log, "SymbolFileDWARF::ParseType (die = 0x%8.8x) %s '%s' is Objective C 'id' built-in type.", 5907 die->GetOffset(), 5908 DW_TAG_value_to_name(die->Tag()), 5909 die->GetName(this, dwarf_cu)); 5910 clang_type = ast.GetBasicType(eBasicTypeObjCID); 5911 encoding_data_type = Type::eEncodingIsUID; 5912 encoding_uid = LLDB_INVALID_UID; 5913 resolve_state = Type::eResolveStateFull; 5914 5915 } 5916 else if (type_name_const_str == g_objc_type_name_Class) 5917 { 5918 if (log) 5919 GetObjectFile()->GetModule()->LogMessage (log, "SymbolFileDWARF::ParseType (die = 0x%8.8x) %s '%s' is Objective C 'Class' built-in type.", 5920 die->GetOffset(), 5921 DW_TAG_value_to_name(die->Tag()), 5922 die->GetName(this, dwarf_cu)); 5923 clang_type = ast.GetBasicType(eBasicTypeObjCClass); 5924 encoding_data_type = Type::eEncodingIsUID; 5925 encoding_uid = LLDB_INVALID_UID; 5926 resolve_state = Type::eResolveStateFull; 5927 } 5928 else if (type_name_const_str == g_objc_type_name_selector) 5929 { 5930 if (log) 5931 GetObjectFile()->GetModule()->LogMessage (log, "SymbolFileDWARF::ParseType (die = 0x%8.8x) %s '%s' is Objective C 'selector' built-in type.", 5932 die->GetOffset(), 5933 DW_TAG_value_to_name(die->Tag()), 5934 die->GetName(this, dwarf_cu)); 5935 clang_type = ast.GetBasicType(eBasicTypeObjCSel); 5936 encoding_data_type = Type::eEncodingIsUID; 5937 encoding_uid = LLDB_INVALID_UID; 5938 resolve_state = Type::eResolveStateFull; 5939 } 5940 } 5941 else if (encoding_data_type == Type::eEncodingIsPointerUID && encoding_uid != LLDB_INVALID_UID) 5942 { 5943 // Clang sometimes erroneously emits id as objc_object*. In that case we fix up the type to "id". 5944 5945 DWARFDebugInfoEntry* encoding_die = dwarf_cu->GetDIEPtr(encoding_uid); 5946 5947 if (encoding_die && encoding_die->Tag() == DW_TAG_structure_type) 5948 { 5949 if (const char *struct_name = encoding_die->GetAttributeValueAsString(this, dwarf_cu, DW_AT_name, NULL)) 5950 { 5951 if (!strcmp(struct_name, "objc_object")) 5952 { 5953 if (log) 5954 GetObjectFile()->GetModule()->LogMessage (log, "SymbolFileDWARF::ParseType (die = 0x%8.8x) %s '%s' is 'objc_object*', which we overrode to 'id'.", 5955 die->GetOffset(), 5956 DW_TAG_value_to_name(die->Tag()), 5957 die->GetName(this, dwarf_cu)); 5958 clang_type = ast.GetBasicType(eBasicTypeObjCID); 5959 encoding_data_type = Type::eEncodingIsUID; 5960 encoding_uid = LLDB_INVALID_UID; 5961 resolve_state = Type::eResolveStateFull; 5962 } 5963 } 5964 } 5965 } 5966 } 5967 } 5968 5969 type_sp.reset( new Type (MakeUserID(die->GetOffset()), 5970 this, 5971 type_name_const_str, 5972 byte_size, 5973 NULL, 5974 encoding_uid, 5975 encoding_data_type, 5976 &decl, 5977 clang_type, 5978 resolve_state)); 5979 5980 m_die_to_type[die] = type_sp.get(); 5981 5982 // Type* encoding_type = GetUniquedTypeForDIEOffset(encoding_uid, type_sp, NULL, 0, 0, false); 5983 // if (encoding_type != NULL) 5984 // { 5985 // if (encoding_type != DIE_IS_BEING_PARSED) 5986 // type_sp->SetEncodingType(encoding_type); 5987 // else 5988 // m_indirect_fixups.push_back(type_sp.get()); 5989 // } 5990 } 5991 break; 5992 5993 case DW_TAG_structure_type: 5994 case DW_TAG_union_type: 5995 case DW_TAG_class_type: 5996 { 5997 // Set a bit that lets us know that we are currently parsing this 5998 m_die_to_type[die] = DIE_IS_BEING_PARSED; 5999 bool byte_size_valid = false; 6000 6001 LanguageType class_language = eLanguageTypeUnknown; 6002 bool is_complete_objc_class = false; 6003 //bool struct_is_class = false; 6004 const size_t num_attributes = die->GetAttributes(this, dwarf_cu, NULL, attributes); 6005 if (num_attributes > 0) 6006 { 6007 uint32_t i; 6008 for (i=0; i<num_attributes; ++i) 6009 { 6010 attr = attributes.AttributeAtIndex(i); 6011 if (attributes.ExtractFormValueAtIndex(this, i, form_value)) 6012 { 6013 switch (attr) 6014 { 6015 case DW_AT_decl_file: 6016 if (dwarf_cu->DW_AT_decl_file_attributes_are_invalid()) 6017 { 6018 // llvm-gcc outputs invalid DW_AT_decl_file attributes that always 6019 // point to the compile unit file, so we clear this invalid value 6020 // so that we can still unique types efficiently. 6021 decl.SetFile(FileSpec ("<invalid>", false)); 6022 } 6023 else 6024 decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned())); 6025 break; 6026 6027 case DW_AT_decl_line: 6028 decl.SetLine(form_value.Unsigned()); 6029 break; 6030 6031 case DW_AT_decl_column: 6032 decl.SetColumn(form_value.Unsigned()); 6033 break; 6034 6035 case DW_AT_name: 6036 type_name_cstr = form_value.AsCString(&get_debug_str_data()); 6037 type_name_const_str.SetCString(type_name_cstr); 6038 break; 6039 6040 case DW_AT_byte_size: 6041 byte_size = form_value.Unsigned(); 6042 byte_size_valid = true; 6043 break; 6044 6045 case DW_AT_accessibility: 6046 accessibility = DW_ACCESS_to_AccessType(form_value.Unsigned()); 6047 break; 6048 6049 case DW_AT_declaration: 6050 is_forward_declaration = form_value.Boolean(); 6051 break; 6052 6053 case DW_AT_APPLE_runtime_class: 6054 class_language = (LanguageType)form_value.Signed(); 6055 break; 6056 6057 case DW_AT_APPLE_objc_complete_type: 6058 is_complete_objc_class = form_value.Signed(); 6059 break; 6060 6061 case DW_AT_allocated: 6062 case DW_AT_associated: 6063 case DW_AT_data_location: 6064 case DW_AT_description: 6065 case DW_AT_start_scope: 6066 case DW_AT_visibility: 6067 default: 6068 case DW_AT_sibling: 6069 break; 6070 } 6071 } 6072 } 6073 } 6074 6075 // UniqueDWARFASTType is large, so don't create a local variables on the 6076 // stack, put it on the heap. This function is often called recursively 6077 // and clang isn't good and sharing the stack space for variables in different blocks. 6078 std::unique_ptr<UniqueDWARFASTType> unique_ast_entry_ap(new UniqueDWARFASTType()); 6079 6080 // Only try and unique the type if it has a name. 6081 if (type_name_const_str && 6082 GetUniqueDWARFASTTypeMap().Find (type_name_const_str, 6083 this, 6084 dwarf_cu, 6085 die, 6086 decl, 6087 byte_size_valid ? byte_size : -1, 6088 *unique_ast_entry_ap)) 6089 { 6090 // We have already parsed this type or from another 6091 // compile unit. GCC loves to use the "one definition 6092 // rule" which can result in multiple definitions 6093 // of the same class over and over in each compile 6094 // unit. 6095 type_sp = unique_ast_entry_ap->m_type_sp; 6096 if (type_sp) 6097 { 6098 m_die_to_type[die] = type_sp.get(); 6099 return type_sp; 6100 } 6101 } 6102 6103 DEBUG_PRINTF ("0x%8.8" PRIx64 ": %s (\"%s\")\n", MakeUserID(die->GetOffset()), DW_TAG_value_to_name(tag), type_name_cstr); 6104 6105 int tag_decl_kind = -1; 6106 AccessType default_accessibility = eAccessNone; 6107 if (tag == DW_TAG_structure_type) 6108 { 6109 tag_decl_kind = clang::TTK_Struct; 6110 default_accessibility = eAccessPublic; 6111 } 6112 else if (tag == DW_TAG_union_type) 6113 { 6114 tag_decl_kind = clang::TTK_Union; 6115 default_accessibility = eAccessPublic; 6116 } 6117 else if (tag == DW_TAG_class_type) 6118 { 6119 tag_decl_kind = clang::TTK_Class; 6120 default_accessibility = eAccessPrivate; 6121 } 6122 6123 if (byte_size_valid && byte_size == 0 && type_name_cstr && 6124 die->HasChildren() == false && 6125 sc.comp_unit->GetLanguage() == eLanguageTypeObjC) 6126 { 6127 // Work around an issue with clang at the moment where 6128 // forward declarations for objective C classes are emitted 6129 // as: 6130 // DW_TAG_structure_type [2] 6131 // DW_AT_name( "ForwardObjcClass" ) 6132 // DW_AT_byte_size( 0x00 ) 6133 // DW_AT_decl_file( "..." ) 6134 // DW_AT_decl_line( 1 ) 6135 // 6136 // Note that there is no DW_AT_declaration and there are 6137 // no children, and the byte size is zero. 6138 is_forward_declaration = true; 6139 } 6140 6141 if (class_language == eLanguageTypeObjC || 6142 class_language == eLanguageTypeObjC_plus_plus) 6143 { 6144 if (!is_complete_objc_class && Supports_DW_AT_APPLE_objc_complete_type(dwarf_cu)) 6145 { 6146 // We have a valid eSymbolTypeObjCClass class symbol whose 6147 // name matches the current objective C class that we 6148 // are trying to find and this DIE isn't the complete 6149 // definition (we checked is_complete_objc_class above and 6150 // know it is false), so the real definition is in here somewhere 6151 type_sp = FindCompleteObjCDefinitionTypeForDIE (die, type_name_const_str, true); 6152 6153 if (!type_sp && GetDebugMapSymfile ()) 6154 { 6155 // We weren't able to find a full declaration in 6156 // this DWARF, see if we have a declaration anywhere 6157 // else... 6158 type_sp = m_debug_map_symfile->FindCompleteObjCDefinitionTypeForDIE (die, type_name_const_str, true); 6159 } 6160 6161 if (type_sp) 6162 { 6163 if (log) 6164 { 6165 GetObjectFile()->GetModule()->LogMessage (log, 6166 "SymbolFileDWARF(%p) - 0x%8.8x: %s type \"%s\" is an incomplete objc type, complete type is 0x%8.8" PRIx64, 6167 static_cast<void*>(this), 6168 die->GetOffset(), 6169 DW_TAG_value_to_name(tag), 6170 type_name_cstr, 6171 type_sp->GetID()); 6172 } 6173 6174 // We found a real definition for this type elsewhere 6175 // so lets use it and cache the fact that we found 6176 // a complete type for this die 6177 m_die_to_type[die] = type_sp.get(); 6178 return type_sp; 6179 } 6180 } 6181 } 6182 6183 6184 if (is_forward_declaration) 6185 { 6186 // We have a forward declaration to a type and we need 6187 // to try and find a full declaration. We look in the 6188 // current type index just in case we have a forward 6189 // declaration followed by an actual declarations in the 6190 // DWARF. If this fails, we need to look elsewhere... 6191 if (log) 6192 { 6193 GetObjectFile()->GetModule()->LogMessage (log, 6194 "SymbolFileDWARF(%p) - 0x%8.8x: %s type \"%s\" is a forward declaration, trying to find complete type", 6195 static_cast<void*>(this), 6196 die->GetOffset(), 6197 DW_TAG_value_to_name(tag), 6198 type_name_cstr); 6199 } 6200 6201 DWARFDeclContext die_decl_ctx; 6202 die->GetDWARFDeclContext(this, dwarf_cu, die_decl_ctx); 6203 6204 //type_sp = FindDefinitionTypeForDIE (dwarf_cu, die, type_name_const_str); 6205 type_sp = FindDefinitionTypeForDWARFDeclContext (die_decl_ctx); 6206 6207 if (!type_sp && GetDebugMapSymfile ()) 6208 { 6209 // We weren't able to find a full declaration in 6210 // this DWARF, see if we have a declaration anywhere 6211 // else... 6212 type_sp = m_debug_map_symfile->FindDefinitionTypeForDWARFDeclContext (die_decl_ctx); 6213 } 6214 6215 if (type_sp) 6216 { 6217 if (log) 6218 { 6219 GetObjectFile()->GetModule()->LogMessage (log, 6220 "SymbolFileDWARF(%p) - 0x%8.8x: %s type \"%s\" is a forward declaration, complete type is 0x%8.8" PRIx64, 6221 static_cast<void*>(this), 6222 die->GetOffset(), 6223 DW_TAG_value_to_name(tag), 6224 type_name_cstr, 6225 type_sp->GetID()); 6226 } 6227 6228 // We found a real definition for this type elsewhere 6229 // so lets use it and cache the fact that we found 6230 // a complete type for this die 6231 m_die_to_type[die] = type_sp.get(); 6232 return type_sp; 6233 } 6234 } 6235 assert (tag_decl_kind != -1); 6236 bool clang_type_was_created = false; 6237 clang_type.SetClangType(ast.getASTContext(), m_forward_decl_die_to_clang_type.lookup (die)); 6238 if (!clang_type) 6239 { 6240 const DWARFDebugInfoEntry *decl_ctx_die; 6241 6242 clang::DeclContext *decl_ctx = GetClangDeclContextContainingDIE (dwarf_cu, die, &decl_ctx_die); 6243 if (accessibility == eAccessNone && decl_ctx) 6244 { 6245 // Check the decl context that contains this class/struct/union. 6246 // If it is a class we must give it an accessibility. 6247 const clang::Decl::Kind containing_decl_kind = decl_ctx->getDeclKind(); 6248 if (DeclKindIsCXXClass (containing_decl_kind)) 6249 accessibility = default_accessibility; 6250 } 6251 6252 ClangASTMetadata metadata; 6253 metadata.SetUserID(MakeUserID(die->GetOffset())); 6254 metadata.SetIsDynamicCXXType(ClassOrStructIsVirtual (dwarf_cu, die)); 6255 6256 if (type_name_cstr && strchr (type_name_cstr, '<')) 6257 { 6258 ClangASTContext::TemplateParameterInfos template_param_infos; 6259 if (ParseTemplateParameterInfos (dwarf_cu, die, template_param_infos)) 6260 { 6261 clang::ClassTemplateDecl *class_template_decl = ParseClassTemplateDecl (decl_ctx, 6262 accessibility, 6263 type_name_cstr, 6264 tag_decl_kind, 6265 template_param_infos); 6266 6267 clang::ClassTemplateSpecializationDecl *class_specialization_decl = ast.CreateClassTemplateSpecializationDecl (decl_ctx, 6268 class_template_decl, 6269 tag_decl_kind, 6270 template_param_infos); 6271 clang_type = ast.CreateClassTemplateSpecializationType (class_specialization_decl); 6272 clang_type_was_created = true; 6273 6274 GetClangASTContext().SetMetadata (class_template_decl, metadata); 6275 GetClangASTContext().SetMetadata (class_specialization_decl, metadata); 6276 } 6277 } 6278 6279 if (!clang_type_was_created) 6280 { 6281 clang_type_was_created = true; 6282 clang_type = ast.CreateRecordType (decl_ctx, 6283 accessibility, 6284 type_name_cstr, 6285 tag_decl_kind, 6286 class_language, 6287 &metadata); 6288 } 6289 } 6290 6291 // Store a forward declaration to this class type in case any 6292 // parameters in any class methods need it for the clang 6293 // types for function prototypes. 6294 LinkDeclContextToDIE(clang_type.GetDeclContextForType(), die); 6295 type_sp.reset (new Type (MakeUserID(die->GetOffset()), 6296 this, 6297 type_name_const_str, 6298 byte_size, 6299 NULL, 6300 LLDB_INVALID_UID, 6301 Type::eEncodingIsUID, 6302 &decl, 6303 clang_type, 6304 Type::eResolveStateForward)); 6305 6306 type_sp->SetIsCompleteObjCClass(is_complete_objc_class); 6307 6308 6309 // Add our type to the unique type map so we don't 6310 // end up creating many copies of the same type over 6311 // and over in the ASTContext for our module 6312 unique_ast_entry_ap->m_type_sp = type_sp; 6313 unique_ast_entry_ap->m_symfile = this; 6314 unique_ast_entry_ap->m_cu = dwarf_cu; 6315 unique_ast_entry_ap->m_die = die; 6316 unique_ast_entry_ap->m_declaration = decl; 6317 unique_ast_entry_ap->m_byte_size = byte_size; 6318 GetUniqueDWARFASTTypeMap().Insert (type_name_const_str, 6319 *unique_ast_entry_ap); 6320 6321 if (is_forward_declaration && die->HasChildren()) 6322 { 6323 // Check to see if the DIE actually has a definition, some version of GCC will 6324 // emit DIEs with DW_AT_declaration set to true, but yet still have subprogram, 6325 // members, or inheritance, so we can't trust it 6326 const DWARFDebugInfoEntry *child_die = die->GetFirstChild(); 6327 while (child_die) 6328 { 6329 switch (child_die->Tag()) 6330 { 6331 case DW_TAG_inheritance: 6332 case DW_TAG_subprogram: 6333 case DW_TAG_member: 6334 case DW_TAG_APPLE_property: 6335 case DW_TAG_class_type: 6336 case DW_TAG_structure_type: 6337 case DW_TAG_enumeration_type: 6338 case DW_TAG_typedef: 6339 case DW_TAG_union_type: 6340 child_die = NULL; 6341 is_forward_declaration = false; 6342 break; 6343 default: 6344 child_die = child_die->GetSibling(); 6345 break; 6346 } 6347 } 6348 } 6349 6350 if (!is_forward_declaration) 6351 { 6352 // Always start the definition for a class type so that 6353 // if the class has child classes or types that require 6354 // the class to be created for use as their decl contexts 6355 // the class will be ready to accept these child definitions. 6356 if (die->HasChildren() == false) 6357 { 6358 // No children for this struct/union/class, lets finish it 6359 clang_type.StartTagDeclarationDefinition (); 6360 clang_type.CompleteTagDeclarationDefinition (); 6361 6362 if (tag == DW_TAG_structure_type) // this only applies in C 6363 { 6364 clang::RecordDecl *record_decl = clang_type.GetAsRecordDecl(); 6365 6366 if (record_decl) 6367 m_record_decl_to_layout_map.insert(std::make_pair(record_decl, LayoutInfo())); 6368 } 6369 } 6370 else if (clang_type_was_created) 6371 { 6372 // Start the definition if the class is not objective C since 6373 // the underlying decls respond to isCompleteDefinition(). Objective 6374 // C decls don't respond to isCompleteDefinition() so we can't 6375 // start the declaration definition right away. For C++ class/union/structs 6376 // we want to start the definition in case the class is needed as the 6377 // declaration context for a contained class or type without the need 6378 // to complete that type.. 6379 6380 if (class_language != eLanguageTypeObjC && 6381 class_language != eLanguageTypeObjC_plus_plus) 6382 clang_type.StartTagDeclarationDefinition (); 6383 6384 // Leave this as a forward declaration until we need 6385 // to know the details of the type. lldb_private::Type 6386 // will automatically call the SymbolFile virtual function 6387 // "SymbolFileDWARF::ResolveClangOpaqueTypeDefinition(Type *)" 6388 // When the definition needs to be defined. 6389 m_forward_decl_die_to_clang_type[die] = clang_type.GetOpaqueQualType(); 6390 m_forward_decl_clang_type_to_die[clang_type.RemoveFastQualifiers().GetOpaqueQualType()] = die; 6391 clang_type.SetHasExternalStorage (true); 6392 } 6393 } 6394 6395 } 6396 break; 6397 6398 case DW_TAG_enumeration_type: 6399 { 6400 // Set a bit that lets us know that we are currently parsing this 6401 m_die_to_type[die] = DIE_IS_BEING_PARSED; 6402 6403 lldb::user_id_t encoding_uid = DW_INVALID_OFFSET; 6404 6405 const size_t num_attributes = die->GetAttributes(this, dwarf_cu, NULL, attributes); 6406 if (num_attributes > 0) 6407 { 6408 uint32_t i; 6409 6410 for (i=0; i<num_attributes; ++i) 6411 { 6412 attr = attributes.AttributeAtIndex(i); 6413 if (attributes.ExtractFormValueAtIndex(this, i, form_value)) 6414 { 6415 switch (attr) 6416 { 6417 case DW_AT_decl_file: decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned())); break; 6418 case DW_AT_decl_line: decl.SetLine(form_value.Unsigned()); break; 6419 case DW_AT_decl_column: decl.SetColumn(form_value.Unsigned()); break; 6420 case DW_AT_name: 6421 type_name_cstr = form_value.AsCString(&get_debug_str_data()); 6422 type_name_const_str.SetCString(type_name_cstr); 6423 break; 6424 case DW_AT_type: encoding_uid = form_value.Reference(); break; 6425 case DW_AT_byte_size: byte_size = form_value.Unsigned(); break; 6426 case DW_AT_accessibility: break; //accessibility = DW_ACCESS_to_AccessType(form_value.Unsigned()); break; 6427 case DW_AT_declaration: break; //is_forward_declaration = form_value.Boolean(); break; 6428 case DW_AT_allocated: 6429 case DW_AT_associated: 6430 case DW_AT_bit_stride: 6431 case DW_AT_byte_stride: 6432 case DW_AT_data_location: 6433 case DW_AT_description: 6434 case DW_AT_start_scope: 6435 case DW_AT_visibility: 6436 case DW_AT_specification: 6437 case DW_AT_abstract_origin: 6438 case DW_AT_sibling: 6439 break; 6440 } 6441 } 6442 } 6443 6444 DEBUG_PRINTF ("0x%8.8" PRIx64 ": %s (\"%s\")\n", MakeUserID(die->GetOffset()), DW_TAG_value_to_name(tag), type_name_cstr); 6445 6446 ClangASTType enumerator_clang_type; 6447 clang_type.SetClangType (ast.getASTContext(), m_forward_decl_die_to_clang_type.lookup (die)); 6448 if (!clang_type) 6449 { 6450 if (encoding_uid != DW_INVALID_OFFSET) 6451 { 6452 Type *enumerator_type = ResolveTypeUID(encoding_uid); 6453 if (enumerator_type) 6454 enumerator_clang_type = enumerator_type->GetClangFullType(); 6455 } 6456 6457 if (!enumerator_clang_type) 6458 enumerator_clang_type = ast.GetBuiltinTypeForDWARFEncodingAndBitSize (NULL, 6459 DW_ATE_signed, 6460 byte_size * 8); 6461 6462 clang_type = ast.CreateEnumerationType (type_name_cstr, 6463 GetClangDeclContextContainingDIE (dwarf_cu, die, NULL), 6464 decl, 6465 enumerator_clang_type); 6466 } 6467 else 6468 { 6469 enumerator_clang_type = clang_type.GetEnumerationIntegerType (); 6470 } 6471 6472 LinkDeclContextToDIE(clang_type.GetDeclContextForType(), die); 6473 6474 type_sp.reset( new Type (MakeUserID(die->GetOffset()), 6475 this, 6476 type_name_const_str, 6477 byte_size, 6478 NULL, 6479 encoding_uid, 6480 Type::eEncodingIsUID, 6481 &decl, 6482 clang_type, 6483 Type::eResolveStateForward)); 6484 6485 clang_type.StartTagDeclarationDefinition (); 6486 if (die->HasChildren()) 6487 { 6488 SymbolContext cu_sc(GetCompUnitForDWARFCompUnit(dwarf_cu)); 6489 bool is_signed = false; 6490 enumerator_clang_type.IsIntegerType(is_signed); 6491 ParseChildEnumerators(cu_sc, clang_type, is_signed, type_sp->GetByteSize(), dwarf_cu, die); 6492 } 6493 clang_type.CompleteTagDeclarationDefinition (); 6494 } 6495 } 6496 break; 6497 6498 case DW_TAG_inlined_subroutine: 6499 case DW_TAG_subprogram: 6500 case DW_TAG_subroutine_type: 6501 { 6502 // Set a bit that lets us know that we are currently parsing this 6503 m_die_to_type[die] = DIE_IS_BEING_PARSED; 6504 6505 //const char *mangled = NULL; 6506 dw_offset_t type_die_offset = DW_INVALID_OFFSET; 6507 bool is_variadic = false; 6508 bool is_inline = false; 6509 bool is_static = false; 6510 bool is_virtual = false; 6511 bool is_explicit = false; 6512 bool is_artificial = false; 6513 dw_offset_t specification_die_offset = DW_INVALID_OFFSET; 6514 dw_offset_t abstract_origin_die_offset = DW_INVALID_OFFSET; 6515 dw_offset_t object_pointer_die_offset = DW_INVALID_OFFSET; 6516 6517 unsigned type_quals = 0; 6518 clang::StorageClass storage = clang::SC_None;//, Extern, Static, PrivateExtern 6519 6520 6521 const size_t num_attributes = die->GetAttributes(this, dwarf_cu, NULL, attributes); 6522 if (num_attributes > 0) 6523 { 6524 uint32_t i; 6525 for (i=0; i<num_attributes; ++i) 6526 { 6527 attr = attributes.AttributeAtIndex(i); 6528 if (attributes.ExtractFormValueAtIndex(this, i, form_value)) 6529 { 6530 switch (attr) 6531 { 6532 case DW_AT_decl_file: decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned())); break; 6533 case DW_AT_decl_line: decl.SetLine(form_value.Unsigned()); break; 6534 case DW_AT_decl_column: decl.SetColumn(form_value.Unsigned()); break; 6535 case DW_AT_name: 6536 type_name_cstr = form_value.AsCString(&get_debug_str_data()); 6537 type_name_const_str.SetCString(type_name_cstr); 6538 break; 6539 6540 case DW_AT_linkage_name: 6541 case DW_AT_MIPS_linkage_name: break; // mangled = form_value.AsCString(&get_debug_str_data()); break; 6542 case DW_AT_type: type_die_offset = form_value.Reference(); break; 6543 case DW_AT_accessibility: accessibility = DW_ACCESS_to_AccessType(form_value.Unsigned()); break; 6544 case DW_AT_declaration: break; // is_forward_declaration = form_value.Boolean(); break; 6545 case DW_AT_inline: is_inline = form_value.Boolean(); break; 6546 case DW_AT_virtuality: is_virtual = form_value.Boolean(); break; 6547 case DW_AT_explicit: is_explicit = form_value.Boolean(); break; 6548 case DW_AT_artificial: is_artificial = form_value.Boolean(); break; 6549 6550 6551 case DW_AT_external: 6552 if (form_value.Unsigned()) 6553 { 6554 if (storage == clang::SC_None) 6555 storage = clang::SC_Extern; 6556 else 6557 storage = clang::SC_PrivateExtern; 6558 } 6559 break; 6560 6561 case DW_AT_specification: 6562 specification_die_offset = form_value.Reference(); 6563 break; 6564 6565 case DW_AT_abstract_origin: 6566 abstract_origin_die_offset = form_value.Reference(); 6567 break; 6568 6569 case DW_AT_object_pointer: 6570 object_pointer_die_offset = form_value.Reference(); 6571 break; 6572 6573 case DW_AT_allocated: 6574 case DW_AT_associated: 6575 case DW_AT_address_class: 6576 case DW_AT_calling_convention: 6577 case DW_AT_data_location: 6578 case DW_AT_elemental: 6579 case DW_AT_entry_pc: 6580 case DW_AT_frame_base: 6581 case DW_AT_high_pc: 6582 case DW_AT_low_pc: 6583 case DW_AT_prototyped: 6584 case DW_AT_pure: 6585 case DW_AT_ranges: 6586 case DW_AT_recursive: 6587 case DW_AT_return_addr: 6588 case DW_AT_segment: 6589 case DW_AT_start_scope: 6590 case DW_AT_static_link: 6591 case DW_AT_trampoline: 6592 case DW_AT_visibility: 6593 case DW_AT_vtable_elem_location: 6594 case DW_AT_description: 6595 case DW_AT_sibling: 6596 break; 6597 } 6598 } 6599 } 6600 } 6601 6602 std::string object_pointer_name; 6603 if (object_pointer_die_offset != DW_INVALID_OFFSET) 6604 { 6605 // Get the name from the object pointer die 6606 StreamString s; 6607 if (DWARFDebugInfoEntry::GetName (this, dwarf_cu, object_pointer_die_offset, s)) 6608 { 6609 object_pointer_name.assign(s.GetData()); 6610 } 6611 } 6612 6613 DEBUG_PRINTF ("0x%8.8" PRIx64 ": %s (\"%s\")\n", MakeUserID(die->GetOffset()), DW_TAG_value_to_name(tag), type_name_cstr); 6614 6615 ClangASTType return_clang_type; 6616 Type *func_type = NULL; 6617 6618 if (type_die_offset != DW_INVALID_OFFSET) 6619 func_type = ResolveTypeUID(type_die_offset); 6620 6621 if (func_type) 6622 return_clang_type = func_type->GetClangForwardType(); 6623 else 6624 return_clang_type = ast.GetBasicType(eBasicTypeVoid); 6625 6626 6627 std::vector<ClangASTType> function_param_types; 6628 std::vector<clang::ParmVarDecl*> function_param_decls; 6629 6630 // Parse the function children for the parameters 6631 6632 const DWARFDebugInfoEntry *decl_ctx_die = NULL; 6633 clang::DeclContext *containing_decl_ctx = GetClangDeclContextContainingDIE (dwarf_cu, die, &decl_ctx_die); 6634 const clang::Decl::Kind containing_decl_kind = containing_decl_ctx->getDeclKind(); 6635 6636 const bool is_cxx_method = DeclKindIsCXXClass (containing_decl_kind); 6637 // Start off static. This will be set to false in ParseChildParameters(...) 6638 // if we find a "this" parameters as the first parameter 6639 if (is_cxx_method) 6640 is_static = true; 6641 6642 if (die->HasChildren()) 6643 { 6644 bool skip_artificial = true; 6645 ParseChildParameters (sc, 6646 containing_decl_ctx, 6647 dwarf_cu, 6648 die, 6649 skip_artificial, 6650 is_static, 6651 is_variadic, 6652 function_param_types, 6653 function_param_decls, 6654 type_quals); 6655 } 6656 6657 // clang_type will get the function prototype clang type after this call 6658 clang_type = ast.CreateFunctionType (return_clang_type, 6659 function_param_types.data(), 6660 function_param_types.size(), 6661 is_variadic, 6662 type_quals); 6663 6664 bool ignore_containing_context = false; 6665 6666 if (type_name_cstr) 6667 { 6668 bool type_handled = false; 6669 if (tag == DW_TAG_subprogram) 6670 { 6671 ObjCLanguageRuntime::MethodName objc_method (type_name_cstr, true); 6672 if (objc_method.IsValid(true)) 6673 { 6674 ClangASTType class_opaque_type; 6675 ConstString class_name(objc_method.GetClassName()); 6676 if (class_name) 6677 { 6678 TypeSP complete_objc_class_type_sp (FindCompleteObjCDefinitionTypeForDIE (NULL, class_name, false)); 6679 6680 if (complete_objc_class_type_sp) 6681 { 6682 ClangASTType type_clang_forward_type = complete_objc_class_type_sp->GetClangForwardType(); 6683 if (type_clang_forward_type.IsObjCObjectOrInterfaceType ()) 6684 class_opaque_type = type_clang_forward_type; 6685 } 6686 } 6687 6688 if (class_opaque_type) 6689 { 6690 // If accessibility isn't set to anything valid, assume public for 6691 // now... 6692 if (accessibility == eAccessNone) 6693 accessibility = eAccessPublic; 6694 6695 clang::ObjCMethodDecl *objc_method_decl = class_opaque_type.AddMethodToObjCObjectType (type_name_cstr, 6696 clang_type, 6697 accessibility, 6698 is_artificial); 6699 type_handled = objc_method_decl != NULL; 6700 if (type_handled) 6701 { 6702 LinkDeclContextToDIE(ClangASTContext::GetAsDeclContext(objc_method_decl), die); 6703 GetClangASTContext().SetMetadataAsUserID (objc_method_decl, MakeUserID(die->GetOffset())); 6704 } 6705 else 6706 { 6707 GetObjectFile()->GetModule()->ReportError ("{0x%8.8x}: invalid Objective-C method 0x%4.4x (%s), please file a bug and attach the file at the start of this error message", 6708 die->GetOffset(), 6709 tag, 6710 DW_TAG_value_to_name(tag)); 6711 } 6712 } 6713 } 6714 else if (is_cxx_method) 6715 { 6716 // Look at the parent of this DIE and see if is is 6717 // a class or struct and see if this is actually a 6718 // C++ method 6719 Type *class_type = ResolveType (dwarf_cu, decl_ctx_die); 6720 if (class_type) 6721 { 6722 if (class_type->GetID() != MakeUserID(decl_ctx_die->GetOffset())) 6723 { 6724 // We uniqued the parent class of this function to another class 6725 // so we now need to associate all dies under "decl_ctx_die" to 6726 // DIEs in the DIE for "class_type"... 6727 SymbolFileDWARF *class_symfile = NULL; 6728 DWARFCompileUnitSP class_type_cu_sp; 6729 const DWARFDebugInfoEntry *class_type_die = NULL; 6730 6731 SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile(); 6732 if (debug_map_symfile) 6733 { 6734 class_symfile = debug_map_symfile->GetSymbolFileByOSOIndex(SymbolFileDWARFDebugMap::GetOSOIndexFromUserID(class_type->GetID())); 6735 class_type_die = class_symfile->DebugInfo()->GetDIEPtr(class_type->GetID(), &class_type_cu_sp); 6736 } 6737 else 6738 { 6739 class_symfile = this; 6740 class_type_die = DebugInfo()->GetDIEPtr(class_type->GetID(), &class_type_cu_sp); 6741 } 6742 if (class_type_die) 6743 { 6744 DWARFDIECollection failures; 6745 6746 CopyUniqueClassMethodTypes (class_symfile, 6747 class_type, 6748 class_type_cu_sp.get(), 6749 class_type_die, 6750 dwarf_cu, 6751 decl_ctx_die, 6752 failures); 6753 6754 // FIXME do something with these failures that's smarter than 6755 // just dropping them on the ground. Unfortunately classes don't 6756 // like having stuff added to them after their definitions are 6757 // complete... 6758 6759 type_ptr = m_die_to_type[die]; 6760 if (type_ptr && type_ptr != DIE_IS_BEING_PARSED) 6761 { 6762 type_sp = type_ptr->shared_from_this(); 6763 break; 6764 } 6765 } 6766 } 6767 6768 if (specification_die_offset != DW_INVALID_OFFSET) 6769 { 6770 // We have a specification which we are going to base our function 6771 // prototype off of, so we need this type to be completed so that the 6772 // m_die_to_decl_ctx for the method in the specification has a valid 6773 // clang decl context. 6774 class_type->GetClangForwardType(); 6775 // If we have a specification, then the function type should have been 6776 // made with the specification and not with this die. 6777 DWARFCompileUnitSP spec_cu_sp; 6778 const DWARFDebugInfoEntry* spec_die = DebugInfo()->GetDIEPtr(specification_die_offset, &spec_cu_sp); 6779 clang::DeclContext *spec_clang_decl_ctx = GetClangDeclContextForDIE (sc, dwarf_cu, spec_die); 6780 if (spec_clang_decl_ctx) 6781 { 6782 LinkDeclContextToDIE(spec_clang_decl_ctx, die); 6783 } 6784 else 6785 { 6786 GetObjectFile()->GetModule()->ReportWarning ("0x%8.8" PRIx64 ": DW_AT_specification(0x%8.8x) has no decl\n", 6787 MakeUserID(die->GetOffset()), 6788 specification_die_offset); 6789 } 6790 type_handled = true; 6791 } 6792 else if (abstract_origin_die_offset != DW_INVALID_OFFSET) 6793 { 6794 // We have a specification which we are going to base our function 6795 // prototype off of, so we need this type to be completed so that the 6796 // m_die_to_decl_ctx for the method in the abstract origin has a valid 6797 // clang decl context. 6798 class_type->GetClangForwardType(); 6799 6800 DWARFCompileUnitSP abs_cu_sp; 6801 const DWARFDebugInfoEntry* abs_die = DebugInfo()->GetDIEPtr(abstract_origin_die_offset, &abs_cu_sp); 6802 clang::DeclContext *abs_clang_decl_ctx = GetClangDeclContextForDIE (sc, dwarf_cu, abs_die); 6803 if (abs_clang_decl_ctx) 6804 { 6805 LinkDeclContextToDIE (abs_clang_decl_ctx, die); 6806 } 6807 else 6808 { 6809 GetObjectFile()->GetModule()->ReportWarning ("0x%8.8" PRIx64 ": DW_AT_abstract_origin(0x%8.8x) has no decl\n", 6810 MakeUserID(die->GetOffset()), 6811 abstract_origin_die_offset); 6812 } 6813 type_handled = true; 6814 } 6815 else 6816 { 6817 ClangASTType class_opaque_type = class_type->GetClangForwardType(); 6818 if (class_opaque_type.IsCXXClassType ()) 6819 { 6820 if (class_opaque_type.IsBeingDefined ()) 6821 { 6822 // Neither GCC 4.2 nor clang++ currently set a valid accessibility 6823 // in the DWARF for C++ methods... Default to public for now... 6824 if (accessibility == eAccessNone) 6825 accessibility = eAccessPublic; 6826 6827 if (!is_static && !die->HasChildren()) 6828 { 6829 // We have a C++ member function with no children (this pointer!) 6830 // and clang will get mad if we try and make a function that isn't 6831 // well formed in the DWARF, so we will just skip it... 6832 type_handled = true; 6833 } 6834 else 6835 { 6836 clang::CXXMethodDecl *cxx_method_decl; 6837 // REMOVE THE CRASH DESCRIPTION BELOW 6838 Host::SetCrashDescriptionWithFormat ("SymbolFileDWARF::ParseType() is adding a method %s to class %s in DIE 0x%8.8" PRIx64 " from %s", 6839 type_name_cstr, 6840 class_type->GetName().GetCString(), 6841 MakeUserID(die->GetOffset()), 6842 m_obj_file->GetFileSpec().GetPath().c_str()); 6843 6844 const bool is_attr_used = false; 6845 6846 cxx_method_decl = class_opaque_type.AddMethodToCXXRecordType (type_name_cstr, 6847 clang_type, 6848 accessibility, 6849 is_virtual, 6850 is_static, 6851 is_inline, 6852 is_explicit, 6853 is_attr_used, 6854 is_artificial); 6855 6856 type_handled = cxx_method_decl != NULL; 6857 6858 if (type_handled) 6859 { 6860 LinkDeclContextToDIE(ClangASTContext::GetAsDeclContext(cxx_method_decl), die); 6861 6862 Host::SetCrashDescription (NULL); 6863 6864 6865 ClangASTMetadata metadata; 6866 metadata.SetUserID(MakeUserID(die->GetOffset())); 6867 6868 if (!object_pointer_name.empty()) 6869 { 6870 metadata.SetObjectPtrName(object_pointer_name.c_str()); 6871 if (log) 6872 log->Printf ("Setting object pointer name: %s on method object %p.\n", 6873 object_pointer_name.c_str(), 6874 static_cast<void*>(cxx_method_decl)); 6875 } 6876 GetClangASTContext().SetMetadata (cxx_method_decl, metadata); 6877 } 6878 else 6879 { 6880 ignore_containing_context = true; 6881 } 6882 } 6883 } 6884 else 6885 { 6886 // We were asked to parse the type for a method in a class, yet the 6887 // class hasn't been asked to complete itself through the 6888 // clang::ExternalASTSource protocol, so we need to just have the 6889 // class complete itself and do things the right way, then our 6890 // DIE should then have an entry in the m_die_to_type map. First 6891 // we need to modify the m_die_to_type so it doesn't think we are 6892 // trying to parse this DIE anymore... 6893 m_die_to_type[die] = NULL; 6894 6895 // Now we get the full type to force our class type to complete itself 6896 // using the clang::ExternalASTSource protocol which will parse all 6897 // base classes and all methods (including the method for this DIE). 6898 class_type->GetClangFullType(); 6899 6900 // The type for this DIE should have been filled in the function call above 6901 type_ptr = m_die_to_type[die]; 6902 if (type_ptr && type_ptr != DIE_IS_BEING_PARSED) 6903 { 6904 type_sp = type_ptr->shared_from_this(); 6905 break; 6906 } 6907 6908 // FIXME This is fixing some even uglier behavior but we really need to 6909 // uniq the methods of each class as well as the class itself. 6910 // <rdar://problem/11240464> 6911 type_handled = true; 6912 } 6913 } 6914 } 6915 } 6916 } 6917 } 6918 6919 if (!type_handled) 6920 { 6921 // We just have a function that isn't part of a class 6922 clang::FunctionDecl *function_decl = ast.CreateFunctionDeclaration (ignore_containing_context ? GetClangASTContext().GetTranslationUnitDecl() : containing_decl_ctx, 6923 type_name_cstr, 6924 clang_type, 6925 storage, 6926 is_inline); 6927 6928 // if (template_param_infos.GetSize() > 0) 6929 // { 6930 // clang::FunctionTemplateDecl *func_template_decl = ast.CreateFunctionTemplateDecl (containing_decl_ctx, 6931 // function_decl, 6932 // type_name_cstr, 6933 // template_param_infos); 6934 // 6935 // ast.CreateFunctionTemplateSpecializationInfo (function_decl, 6936 // func_template_decl, 6937 // template_param_infos); 6938 // } 6939 // Add the decl to our DIE to decl context map 6940 assert (function_decl); 6941 LinkDeclContextToDIE(function_decl, die); 6942 if (!function_param_decls.empty()) 6943 ast.SetFunctionParameters (function_decl, 6944 &function_param_decls.front(), 6945 function_param_decls.size()); 6946 6947 ClangASTMetadata metadata; 6948 metadata.SetUserID(MakeUserID(die->GetOffset())); 6949 6950 if (!object_pointer_name.empty()) 6951 { 6952 metadata.SetObjectPtrName(object_pointer_name.c_str()); 6953 if (log) 6954 log->Printf ("Setting object pointer name: %s on function object %p.", 6955 object_pointer_name.c_str(), 6956 static_cast<void*>(function_decl)); 6957 } 6958 GetClangASTContext().SetMetadata (function_decl, metadata); 6959 } 6960 } 6961 type_sp.reset( new Type (MakeUserID(die->GetOffset()), 6962 this, 6963 type_name_const_str, 6964 0, 6965 NULL, 6966 LLDB_INVALID_UID, 6967 Type::eEncodingIsUID, 6968 &decl, 6969 clang_type, 6970 Type::eResolveStateFull)); 6971 assert(type_sp.get()); 6972 } 6973 break; 6974 6975 case DW_TAG_array_type: 6976 { 6977 // Set a bit that lets us know that we are currently parsing this 6978 m_die_to_type[die] = DIE_IS_BEING_PARSED; 6979 6980 lldb::user_id_t type_die_offset = DW_INVALID_OFFSET; 6981 int64_t first_index = 0; 6982 uint32_t byte_stride = 0; 6983 uint32_t bit_stride = 0; 6984 bool is_vector = false; 6985 const size_t num_attributes = die->GetAttributes(this, dwarf_cu, NULL, attributes); 6986 6987 if (num_attributes > 0) 6988 { 6989 uint32_t i; 6990 for (i=0; i<num_attributes; ++i) 6991 { 6992 attr = attributes.AttributeAtIndex(i); 6993 if (attributes.ExtractFormValueAtIndex(this, i, form_value)) 6994 { 6995 switch (attr) 6996 { 6997 case DW_AT_decl_file: decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned())); break; 6998 case DW_AT_decl_line: decl.SetLine(form_value.Unsigned()); break; 6999 case DW_AT_decl_column: decl.SetColumn(form_value.Unsigned()); break; 7000 case DW_AT_name: 7001 type_name_cstr = form_value.AsCString(&get_debug_str_data()); 7002 type_name_const_str.SetCString(type_name_cstr); 7003 break; 7004 7005 case DW_AT_type: type_die_offset = form_value.Reference(); break; 7006 case DW_AT_byte_size: break; // byte_size = form_value.Unsigned(); break; 7007 case DW_AT_byte_stride: byte_stride = form_value.Unsigned(); break; 7008 case DW_AT_bit_stride: bit_stride = form_value.Unsigned(); break; 7009 case DW_AT_GNU_vector: is_vector = form_value.Boolean(); break; 7010 case DW_AT_accessibility: break; // accessibility = DW_ACCESS_to_AccessType(form_value.Unsigned()); break; 7011 case DW_AT_declaration: break; // is_forward_declaration = form_value.Boolean(); break; 7012 case DW_AT_allocated: 7013 case DW_AT_associated: 7014 case DW_AT_data_location: 7015 case DW_AT_description: 7016 case DW_AT_ordering: 7017 case DW_AT_start_scope: 7018 case DW_AT_visibility: 7019 case DW_AT_specification: 7020 case DW_AT_abstract_origin: 7021 case DW_AT_sibling: 7022 break; 7023 } 7024 } 7025 } 7026 7027 DEBUG_PRINTF ("0x%8.8" PRIx64 ": %s (\"%s\")\n", MakeUserID(die->GetOffset()), DW_TAG_value_to_name(tag), type_name_cstr); 7028 7029 Type *element_type = ResolveTypeUID(type_die_offset); 7030 7031 if (element_type) 7032 { 7033 std::vector<uint64_t> element_orders; 7034 ParseChildArrayInfo(sc, dwarf_cu, die, first_index, element_orders, byte_stride, bit_stride); 7035 if (byte_stride == 0 && bit_stride == 0) 7036 byte_stride = element_type->GetByteSize(); 7037 ClangASTType array_element_type = element_type->GetClangForwardType(); 7038 uint64_t array_element_bit_stride = byte_stride * 8 + bit_stride; 7039 if (element_orders.size() > 0) 7040 { 7041 uint64_t num_elements = 0; 7042 std::vector<uint64_t>::const_reverse_iterator pos; 7043 std::vector<uint64_t>::const_reverse_iterator end = element_orders.rend(); 7044 for (pos = element_orders.rbegin(); pos != end; ++pos) 7045 { 7046 num_elements = *pos; 7047 clang_type = ast.CreateArrayType (array_element_type, 7048 num_elements, 7049 is_vector); 7050 array_element_type = clang_type; 7051 array_element_bit_stride = num_elements ? 7052 array_element_bit_stride * num_elements : 7053 array_element_bit_stride; 7054 } 7055 } 7056 else 7057 { 7058 clang_type = ast.CreateArrayType (array_element_type, 0, is_vector); 7059 } 7060 ConstString empty_name; 7061 type_sp.reset( new Type (MakeUserID(die->GetOffset()), 7062 this, 7063 empty_name, 7064 array_element_bit_stride / 8, 7065 NULL, 7066 type_die_offset, 7067 Type::eEncodingIsUID, 7068 &decl, 7069 clang_type, 7070 Type::eResolveStateFull)); 7071 type_sp->SetEncodingType (element_type); 7072 } 7073 } 7074 } 7075 break; 7076 7077 case DW_TAG_ptr_to_member_type: 7078 { 7079 dw_offset_t type_die_offset = DW_INVALID_OFFSET; 7080 dw_offset_t containing_type_die_offset = DW_INVALID_OFFSET; 7081 7082 const size_t num_attributes = die->GetAttributes(this, dwarf_cu, NULL, attributes); 7083 7084 if (num_attributes > 0) { 7085 uint32_t i; 7086 for (i=0; i<num_attributes; ++i) 7087 { 7088 attr = attributes.AttributeAtIndex(i); 7089 if (attributes.ExtractFormValueAtIndex(this, i, form_value)) 7090 { 7091 switch (attr) 7092 { 7093 case DW_AT_type: 7094 type_die_offset = form_value.Reference(); break; 7095 case DW_AT_containing_type: 7096 containing_type_die_offset = form_value.Reference(); break; 7097 } 7098 } 7099 } 7100 7101 Type *pointee_type = ResolveTypeUID(type_die_offset); 7102 Type *class_type = ResolveTypeUID(containing_type_die_offset); 7103 7104 ClangASTType pointee_clang_type = pointee_type->GetClangForwardType(); 7105 ClangASTType class_clang_type = class_type->GetClangLayoutType(); 7106 7107 clang_type = pointee_clang_type.CreateMemberPointerType(class_clang_type); 7108 7109 byte_size = clang_type.GetByteSize(nullptr); 7110 7111 type_sp.reset( new Type (MakeUserID(die->GetOffset()), 7112 this, 7113 type_name_const_str, 7114 byte_size, 7115 NULL, 7116 LLDB_INVALID_UID, 7117 Type::eEncodingIsUID, 7118 NULL, 7119 clang_type, 7120 Type::eResolveStateForward)); 7121 } 7122 7123 break; 7124 } 7125 default: 7126 GetObjectFile()->GetModule()->ReportError ("{0x%8.8x}: unhandled type tag 0x%4.4x (%s), please file a bug and attach the file at the start of this error message", 7127 die->GetOffset(), 7128 tag, 7129 DW_TAG_value_to_name(tag)); 7130 break; 7131 } 7132 7133 if (type_sp.get()) 7134 { 7135 const DWARFDebugInfoEntry *sc_parent_die = GetParentSymbolContextDIE(die); 7136 dw_tag_t sc_parent_tag = sc_parent_die ? sc_parent_die->Tag() : 0; 7137 7138 SymbolContextScope * symbol_context_scope = NULL; 7139 if (sc_parent_tag == DW_TAG_compile_unit) 7140 { 7141 symbol_context_scope = sc.comp_unit; 7142 } 7143 else if (sc.function != NULL && sc_parent_die) 7144 { 7145 symbol_context_scope = sc.function->GetBlock(true).FindBlockByID(MakeUserID(sc_parent_die->GetOffset())); 7146 if (symbol_context_scope == NULL) 7147 symbol_context_scope = sc.function; 7148 } 7149 7150 if (symbol_context_scope != NULL) 7151 { 7152 type_sp->SetSymbolContextScope(symbol_context_scope); 7153 } 7154 7155 // We are ready to put this type into the uniqued list up at the module level 7156 type_list->Insert (type_sp); 7157 7158 m_die_to_type[die] = type_sp.get(); 7159 } 7160 } 7161 else if (type_ptr != DIE_IS_BEING_PARSED) 7162 { 7163 type_sp = type_ptr->shared_from_this(); 7164 } 7165 } 7166 return type_sp; 7167 } 7168 7169 size_t 7170 SymbolFileDWARF::ParseTypes 7171 ( 7172 const SymbolContext& sc, 7173 DWARFCompileUnit* dwarf_cu, 7174 const DWARFDebugInfoEntry *die, 7175 bool parse_siblings, 7176 bool parse_children 7177 ) 7178 { 7179 size_t types_added = 0; 7180 while (die != NULL) 7181 { 7182 bool type_is_new = false; 7183 if (ParseType(sc, dwarf_cu, die, &type_is_new).get()) 7184 { 7185 if (type_is_new) 7186 ++types_added; 7187 } 7188 7189 if (parse_children && die->HasChildren()) 7190 { 7191 if (die->Tag() == DW_TAG_subprogram) 7192 { 7193 SymbolContext child_sc(sc); 7194 child_sc.function = sc.comp_unit->FindFunctionByUID(MakeUserID(die->GetOffset())).get(); 7195 types_added += ParseTypes(child_sc, dwarf_cu, die->GetFirstChild(), true, true); 7196 } 7197 else 7198 types_added += ParseTypes(sc, dwarf_cu, die->GetFirstChild(), true, true); 7199 } 7200 7201 if (parse_siblings) 7202 die = die->GetSibling(); 7203 else 7204 die = NULL; 7205 } 7206 return types_added; 7207 } 7208 7209 7210 size_t 7211 SymbolFileDWARF::ParseFunctionBlocks (const SymbolContext &sc) 7212 { 7213 assert(sc.comp_unit && sc.function); 7214 size_t functions_added = 0; 7215 DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit); 7216 if (dwarf_cu) 7217 { 7218 dw_offset_t function_die_offset = sc.function->GetID(); 7219 const DWARFDebugInfoEntry *function_die = dwarf_cu->GetDIEPtr(function_die_offset); 7220 if (function_die) 7221 { 7222 ParseFunctionBlocks(sc, &sc.function->GetBlock (false), dwarf_cu, function_die, LLDB_INVALID_ADDRESS, 0); 7223 } 7224 } 7225 7226 return functions_added; 7227 } 7228 7229 7230 size_t 7231 SymbolFileDWARF::ParseTypes (const SymbolContext &sc) 7232 { 7233 // At least a compile unit must be valid 7234 assert(sc.comp_unit); 7235 size_t types_added = 0; 7236 DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit); 7237 if (dwarf_cu) 7238 { 7239 if (sc.function) 7240 { 7241 dw_offset_t function_die_offset = sc.function->GetID(); 7242 const DWARFDebugInfoEntry *func_die = dwarf_cu->GetDIEPtr(function_die_offset); 7243 if (func_die && func_die->HasChildren()) 7244 { 7245 types_added = ParseTypes(sc, dwarf_cu, func_die->GetFirstChild(), true, true); 7246 } 7247 } 7248 else 7249 { 7250 const DWARFDebugInfoEntry *dwarf_cu_die = dwarf_cu->DIE(); 7251 if (dwarf_cu_die && dwarf_cu_die->HasChildren()) 7252 { 7253 types_added = ParseTypes(sc, dwarf_cu, dwarf_cu_die->GetFirstChild(), true, true); 7254 } 7255 } 7256 } 7257 7258 return types_added; 7259 } 7260 7261 size_t 7262 SymbolFileDWARF::ParseVariablesForContext (const SymbolContext& sc) 7263 { 7264 if (sc.comp_unit != NULL) 7265 { 7266 DWARFDebugInfo* info = DebugInfo(); 7267 if (info == NULL) 7268 return 0; 7269 7270 if (sc.function) 7271 { 7272 DWARFCompileUnit* dwarf_cu = info->GetCompileUnitContainingDIE(sc.function->GetID()).get(); 7273 7274 if (dwarf_cu == NULL) 7275 return 0; 7276 7277 const DWARFDebugInfoEntry *function_die = dwarf_cu->GetDIEPtr(sc.function->GetID()); 7278 7279 dw_addr_t func_lo_pc = function_die->GetAttributeValueAsUnsigned (this, dwarf_cu, DW_AT_low_pc, LLDB_INVALID_ADDRESS); 7280 if (func_lo_pc != LLDB_INVALID_ADDRESS) 7281 { 7282 const size_t num_variables = ParseVariables(sc, dwarf_cu, func_lo_pc, function_die->GetFirstChild(), true, true); 7283 7284 // Let all blocks know they have parse all their variables 7285 sc.function->GetBlock (false).SetDidParseVariables (true, true); 7286 return num_variables; 7287 } 7288 } 7289 else if (sc.comp_unit) 7290 { 7291 DWARFCompileUnit* dwarf_cu = info->GetCompileUnit(sc.comp_unit->GetID()).get(); 7292 7293 if (dwarf_cu == NULL) 7294 return 0; 7295 7296 uint32_t vars_added = 0; 7297 VariableListSP variables (sc.comp_unit->GetVariableList(false)); 7298 7299 if (variables.get() == NULL) 7300 { 7301 variables.reset(new VariableList()); 7302 sc.comp_unit->SetVariableList(variables); 7303 7304 DWARFCompileUnit* match_dwarf_cu = NULL; 7305 const DWARFDebugInfoEntry* die = NULL; 7306 DIEArray die_offsets; 7307 if (m_using_apple_tables) 7308 { 7309 if (m_apple_names_ap.get()) 7310 { 7311 DWARFMappedHash::DIEInfoArray hash_data_array; 7312 if (m_apple_names_ap->AppendAllDIEsInRange (dwarf_cu->GetOffset(), 7313 dwarf_cu->GetNextCompileUnitOffset(), 7314 hash_data_array)) 7315 { 7316 DWARFMappedHash::ExtractDIEArray (hash_data_array, die_offsets); 7317 } 7318 } 7319 } 7320 else 7321 { 7322 // Index if we already haven't to make sure the compile units 7323 // get indexed and make their global DIE index list 7324 if (!m_indexed) 7325 Index (); 7326 7327 m_global_index.FindAllEntriesForCompileUnit (dwarf_cu->GetOffset(), 7328 dwarf_cu->GetNextCompileUnitOffset(), 7329 die_offsets); 7330 } 7331 7332 const size_t num_matches = die_offsets.size(); 7333 if (num_matches) 7334 { 7335 DWARFDebugInfo* debug_info = DebugInfo(); 7336 for (size_t i=0; i<num_matches; ++i) 7337 { 7338 const dw_offset_t die_offset = die_offsets[i]; 7339 die = debug_info->GetDIEPtrWithCompileUnitHint (die_offset, &match_dwarf_cu); 7340 if (die) 7341 { 7342 VariableSP var_sp (ParseVariableDIE(sc, dwarf_cu, die, LLDB_INVALID_ADDRESS)); 7343 if (var_sp) 7344 { 7345 variables->AddVariableIfUnique (var_sp); 7346 ++vars_added; 7347 } 7348 } 7349 else 7350 { 7351 if (m_using_apple_tables) 7352 { 7353 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_names accelerator table had bad die 0x%8.8x)\n", die_offset); 7354 } 7355 } 7356 7357 } 7358 } 7359 } 7360 return vars_added; 7361 } 7362 } 7363 return 0; 7364 } 7365 7366 7367 VariableSP 7368 SymbolFileDWARF::ParseVariableDIE 7369 ( 7370 const SymbolContext& sc, 7371 DWARFCompileUnit* dwarf_cu, 7372 const DWARFDebugInfoEntry *die, 7373 const lldb::addr_t func_low_pc 7374 ) 7375 { 7376 VariableSP var_sp (m_die_to_variable_sp[die]); 7377 if (var_sp) 7378 return var_sp; // Already been parsed! 7379 7380 const dw_tag_t tag = die->Tag(); 7381 ModuleSP module = GetObjectFile()->GetModule(); 7382 7383 if ((tag == DW_TAG_variable) || 7384 (tag == DW_TAG_constant) || 7385 (tag == DW_TAG_formal_parameter && sc.function)) 7386 { 7387 DWARFDebugInfoEntry::Attributes attributes; 7388 const size_t num_attributes = die->GetAttributes(this, dwarf_cu, NULL, attributes); 7389 if (num_attributes > 0) 7390 { 7391 const char *name = NULL; 7392 const char *mangled = NULL; 7393 Declaration decl; 7394 uint32_t i; 7395 lldb::user_id_t type_uid = LLDB_INVALID_UID; 7396 DWARFExpression location; 7397 bool is_external = false; 7398 bool is_artificial = false; 7399 bool location_is_const_value_data = false; 7400 bool has_explicit_location = false; 7401 DWARFFormValue const_value; 7402 //AccessType accessibility = eAccessNone; 7403 7404 for (i=0; i<num_attributes; ++i) 7405 { 7406 dw_attr_t attr = attributes.AttributeAtIndex(i); 7407 DWARFFormValue form_value; 7408 7409 if (attributes.ExtractFormValueAtIndex(this, i, form_value)) 7410 { 7411 switch (attr) 7412 { 7413 case DW_AT_decl_file: decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned())); break; 7414 case DW_AT_decl_line: decl.SetLine(form_value.Unsigned()); break; 7415 case DW_AT_decl_column: decl.SetColumn(form_value.Unsigned()); break; 7416 case DW_AT_name: name = form_value.AsCString(&get_debug_str_data()); break; 7417 case DW_AT_linkage_name: 7418 case DW_AT_MIPS_linkage_name: mangled = form_value.AsCString(&get_debug_str_data()); break; 7419 case DW_AT_type: type_uid = form_value.Reference(); break; 7420 case DW_AT_external: is_external = form_value.Boolean(); break; 7421 case DW_AT_const_value: 7422 // If we have already found a DW_AT_location attribute, ignore this attribute. 7423 if (!has_explicit_location) 7424 { 7425 location_is_const_value_data = true; 7426 // The constant value will be either a block, a data value or a string. 7427 const DWARFDataExtractor& debug_info_data = get_debug_info_data(); 7428 if (DWARFFormValue::IsBlockForm(form_value.Form())) 7429 { 7430 // Retrieve the value as a block expression. 7431 uint32_t block_offset = form_value.BlockData() - debug_info_data.GetDataStart(); 7432 uint32_t block_length = form_value.Unsigned(); 7433 location.CopyOpcodeData(module, debug_info_data, block_offset, block_length); 7434 } 7435 else if (DWARFFormValue::IsDataForm(form_value.Form())) 7436 { 7437 // Retrieve the value as a data expression. 7438 const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (attributes.CompileUnitAtIndex(i)->GetAddressByteSize(), attributes.CompileUnitAtIndex(i)->IsDWARF64()); 7439 uint32_t data_offset = attributes.DIEOffsetAtIndex(i); 7440 uint32_t data_length = fixed_form_sizes[form_value.Form()]; 7441 if (data_length == 0) 7442 { 7443 const uint8_t *data_pointer = form_value.BlockData(); 7444 if (data_pointer) 7445 { 7446 form_value.Unsigned(); 7447 } 7448 else if (DWARFFormValue::IsDataForm(form_value.Form())) 7449 { 7450 // we need to get the byte size of the type later after we create the variable 7451 const_value = form_value; 7452 } 7453 } 7454 else 7455 location.CopyOpcodeData(module, debug_info_data, data_offset, data_length); 7456 } 7457 else 7458 { 7459 // Retrieve the value as a string expression. 7460 if (form_value.Form() == DW_FORM_strp) 7461 { 7462 const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (attributes.CompileUnitAtIndex(i)->GetAddressByteSize(), attributes.CompileUnitAtIndex(i)->IsDWARF64()); 7463 uint32_t data_offset = attributes.DIEOffsetAtIndex(i); 7464 uint32_t data_length = fixed_form_sizes[form_value.Form()]; 7465 location.CopyOpcodeData(module, debug_info_data, data_offset, data_length); 7466 } 7467 else 7468 { 7469 const char *str = form_value.AsCString(&debug_info_data); 7470 uint32_t string_offset = str - (const char *)debug_info_data.GetDataStart(); 7471 uint32_t string_length = strlen(str) + 1; 7472 location.CopyOpcodeData(module, debug_info_data, string_offset, string_length); 7473 } 7474 } 7475 } 7476 break; 7477 case DW_AT_location: 7478 { 7479 location_is_const_value_data = false; 7480 has_explicit_location = true; 7481 if (form_value.BlockData()) 7482 { 7483 const DWARFDataExtractor& debug_info_data = get_debug_info_data(); 7484 7485 uint32_t block_offset = form_value.BlockData() - debug_info_data.GetDataStart(); 7486 uint32_t block_length = form_value.Unsigned(); 7487 location.CopyOpcodeData(module, get_debug_info_data(), block_offset, block_length); 7488 } 7489 else 7490 { 7491 const DWARFDataExtractor& debug_loc_data = get_debug_loc_data(); 7492 const dw_offset_t debug_loc_offset = form_value.Unsigned(); 7493 7494 size_t loc_list_length = DWARFLocationList::Size(debug_loc_data, debug_loc_offset); 7495 if (loc_list_length > 0) 7496 { 7497 location.CopyOpcodeData(module, debug_loc_data, debug_loc_offset, loc_list_length); 7498 assert (func_low_pc != LLDB_INVALID_ADDRESS); 7499 location.SetLocationListSlide (func_low_pc - attributes.CompileUnitAtIndex(i)->GetBaseAddress()); 7500 } 7501 } 7502 } 7503 break; 7504 7505 case DW_AT_artificial: is_artificial = form_value.Boolean(); break; 7506 case DW_AT_accessibility: break; //accessibility = DW_ACCESS_to_AccessType(form_value.Unsigned()); break; 7507 case DW_AT_declaration: 7508 case DW_AT_description: 7509 case DW_AT_endianity: 7510 case DW_AT_segment: 7511 case DW_AT_start_scope: 7512 case DW_AT_visibility: 7513 default: 7514 case DW_AT_abstract_origin: 7515 case DW_AT_sibling: 7516 case DW_AT_specification: 7517 break; 7518 } 7519 } 7520 } 7521 7522 ValueType scope = eValueTypeInvalid; 7523 7524 const DWARFDebugInfoEntry *sc_parent_die = GetParentSymbolContextDIE(die); 7525 dw_tag_t parent_tag = sc_parent_die ? sc_parent_die->Tag() : 0; 7526 SymbolContextScope * symbol_context_scope = NULL; 7527 7528 if (!mangled) 7529 { 7530 // LLDB relies on the mangled name (DW_TAG_linkage_name or DW_AT_MIPS_linkage_name) to 7531 // generate fully qualified names of global variables with commands like "frame var j". 7532 // For example, if j were an int variable holding a value 4 and declared in a namespace 7533 // B which in turn is contained in a namespace A, the command "frame var j" returns 7534 // "(int) A::B::j = 4". If the compiler does not emit a linkage name, we should be able 7535 // to generate a fully qualified name from the declaration context. 7536 if (die->GetParent()->Tag() == DW_TAG_compile_unit && 7537 LanguageRuntime::LanguageIsCPlusPlus(dwarf_cu->GetLanguageType())) 7538 { 7539 DWARFDeclContext decl_ctx; 7540 7541 die->GetDWARFDeclContext(this, dwarf_cu, decl_ctx); 7542 mangled = decl_ctx.GetQualifiedNameAsConstString().GetCString(); 7543 } 7544 } 7545 7546 // DWARF doesn't specify if a DW_TAG_variable is a local, global 7547 // or static variable, so we have to do a little digging by 7548 // looking at the location of a variable to see if it contains 7549 // a DW_OP_addr opcode _somewhere_ in the definition. I say 7550 // somewhere because clang likes to combine small global variables 7551 // into the same symbol and have locations like: 7552 // DW_OP_addr(0x1000), DW_OP_constu(2), DW_OP_plus 7553 // So if we don't have a DW_TAG_formal_parameter, we can look at 7554 // the location to see if it contains a DW_OP_addr opcode, and 7555 // then we can correctly classify our variables. 7556 if (tag == DW_TAG_formal_parameter) 7557 scope = eValueTypeVariableArgument; 7558 else 7559 { 7560 bool op_error = false; 7561 // Check if the location has a DW_OP_addr with any address value... 7562 lldb::addr_t location_DW_OP_addr = LLDB_INVALID_ADDRESS; 7563 if (!location_is_const_value_data) 7564 { 7565 location_DW_OP_addr = location.GetLocation_DW_OP_addr (0, op_error); 7566 if (op_error) 7567 { 7568 StreamString strm; 7569 location.DumpLocationForAddress (&strm, eDescriptionLevelFull, 0, 0, NULL); 7570 GetObjectFile()->GetModule()->ReportError ("0x%8.8x: %s has an invalid location: %s", die->GetOffset(), DW_TAG_value_to_name(die->Tag()), strm.GetString().c_str()); 7571 } 7572 } 7573 7574 if (location_DW_OP_addr != LLDB_INVALID_ADDRESS) 7575 { 7576 if (is_external) 7577 scope = eValueTypeVariableGlobal; 7578 else 7579 scope = eValueTypeVariableStatic; 7580 7581 7582 SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile (); 7583 7584 if (debug_map_symfile) 7585 { 7586 // When leaving the DWARF in the .o files on darwin, 7587 // when we have a global variable that wasn't initialized, 7588 // the .o file might not have allocated a virtual 7589 // address for the global variable. In this case it will 7590 // have created a symbol for the global variable 7591 // that is undefined/data and external and the value will 7592 // be the byte size of the variable. When we do the 7593 // address map in SymbolFileDWARFDebugMap we rely on 7594 // having an address, we need to do some magic here 7595 // so we can get the correct address for our global 7596 // variable. The address for all of these entries 7597 // will be zero, and there will be an undefined symbol 7598 // in this object file, and the executable will have 7599 // a matching symbol with a good address. So here we 7600 // dig up the correct address and replace it in the 7601 // location for the variable, and set the variable's 7602 // symbol context scope to be that of the main executable 7603 // so the file address will resolve correctly. 7604 bool linked_oso_file_addr = false; 7605 if (is_external && location_DW_OP_addr == 0) 7606 { 7607 // we have a possible uninitialized extern global 7608 ConstString const_name(mangled ? mangled : name); 7609 ObjectFile *debug_map_objfile = debug_map_symfile->GetObjectFile(); 7610 if (debug_map_objfile) 7611 { 7612 Symtab *debug_map_symtab = debug_map_objfile->GetSymtab(); 7613 if (debug_map_symtab) 7614 { 7615 Symbol *exe_symbol = debug_map_symtab->FindFirstSymbolWithNameAndType (const_name, 7616 eSymbolTypeData, 7617 Symtab::eDebugYes, 7618 Symtab::eVisibilityExtern); 7619 if (exe_symbol) 7620 { 7621 if (exe_symbol->ValueIsAddress()) 7622 { 7623 const addr_t exe_file_addr = exe_symbol->GetAddressRef().GetFileAddress(); 7624 if (exe_file_addr != LLDB_INVALID_ADDRESS) 7625 { 7626 if (location.Update_DW_OP_addr (exe_file_addr)) 7627 { 7628 linked_oso_file_addr = true; 7629 symbol_context_scope = exe_symbol; 7630 } 7631 } 7632 } 7633 } 7634 } 7635 } 7636 } 7637 7638 if (!linked_oso_file_addr) 7639 { 7640 // The DW_OP_addr is not zero, but it contains a .o file address which 7641 // needs to be linked up correctly. 7642 const lldb::addr_t exe_file_addr = debug_map_symfile->LinkOSOFileAddress(this, location_DW_OP_addr); 7643 if (exe_file_addr != LLDB_INVALID_ADDRESS) 7644 { 7645 // Update the file address for this variable 7646 location.Update_DW_OP_addr (exe_file_addr); 7647 } 7648 else 7649 { 7650 // Variable didn't make it into the final executable 7651 return var_sp; 7652 } 7653 } 7654 } 7655 } 7656 else 7657 { 7658 scope = eValueTypeVariableLocal; 7659 } 7660 } 7661 7662 if (symbol_context_scope == NULL) 7663 { 7664 switch (parent_tag) 7665 { 7666 case DW_TAG_subprogram: 7667 case DW_TAG_inlined_subroutine: 7668 case DW_TAG_lexical_block: 7669 if (sc.function) 7670 { 7671 symbol_context_scope = sc.function->GetBlock(true).FindBlockByID(MakeUserID(sc_parent_die->GetOffset())); 7672 if (symbol_context_scope == NULL) 7673 symbol_context_scope = sc.function; 7674 } 7675 break; 7676 7677 default: 7678 symbol_context_scope = sc.comp_unit; 7679 break; 7680 } 7681 } 7682 7683 if (symbol_context_scope) 7684 { 7685 SymbolFileTypeSP type_sp(new SymbolFileType(*this, type_uid)); 7686 7687 if (const_value.Form() && type_sp && type_sp->GetType()) 7688 location.CopyOpcodeData(const_value.Unsigned(), type_sp->GetType()->GetByteSize(), dwarf_cu->GetAddressByteSize()); 7689 7690 var_sp.reset (new Variable (MakeUserID(die->GetOffset()), 7691 name, 7692 mangled, 7693 type_sp, 7694 scope, 7695 symbol_context_scope, 7696 &decl, 7697 location, 7698 is_external, 7699 is_artificial)); 7700 7701 var_sp->SetLocationIsConstantValueData (location_is_const_value_data); 7702 } 7703 else 7704 { 7705 // Not ready to parse this variable yet. It might be a global 7706 // or static variable that is in a function scope and the function 7707 // in the symbol context wasn't filled in yet 7708 return var_sp; 7709 } 7710 } 7711 // Cache var_sp even if NULL (the variable was just a specification or 7712 // was missing vital information to be able to be displayed in the debugger 7713 // (missing location due to optimization, etc)) so we don't re-parse 7714 // this DIE over and over later... 7715 m_die_to_variable_sp[die] = var_sp; 7716 } 7717 return var_sp; 7718 } 7719 7720 7721 const DWARFDebugInfoEntry * 7722 SymbolFileDWARF::FindBlockContainingSpecification (dw_offset_t func_die_offset, 7723 dw_offset_t spec_block_die_offset, 7724 DWARFCompileUnit **result_die_cu_handle) 7725 { 7726 // Give the concrete function die specified by "func_die_offset", find the 7727 // concrete block whose DW_AT_specification or DW_AT_abstract_origin points 7728 // to "spec_block_die_offset" 7729 DWARFDebugInfo* info = DebugInfo(); 7730 7731 const DWARFDebugInfoEntry *die = info->GetDIEPtrWithCompileUnitHint(func_die_offset, result_die_cu_handle); 7732 if (die) 7733 { 7734 assert (*result_die_cu_handle); 7735 return FindBlockContainingSpecification (*result_die_cu_handle, die, spec_block_die_offset, result_die_cu_handle); 7736 } 7737 return NULL; 7738 } 7739 7740 7741 const DWARFDebugInfoEntry * 7742 SymbolFileDWARF::FindBlockContainingSpecification(DWARFCompileUnit* dwarf_cu, 7743 const DWARFDebugInfoEntry *die, 7744 dw_offset_t spec_block_die_offset, 7745 DWARFCompileUnit **result_die_cu_handle) 7746 { 7747 if (die) 7748 { 7749 switch (die->Tag()) 7750 { 7751 case DW_TAG_subprogram: 7752 case DW_TAG_inlined_subroutine: 7753 case DW_TAG_lexical_block: 7754 { 7755 if (die->GetAttributeValueAsReference (this, dwarf_cu, DW_AT_specification, DW_INVALID_OFFSET) == spec_block_die_offset) 7756 { 7757 *result_die_cu_handle = dwarf_cu; 7758 return die; 7759 } 7760 7761 if (die->GetAttributeValueAsReference (this, dwarf_cu, DW_AT_abstract_origin, DW_INVALID_OFFSET) == spec_block_die_offset) 7762 { 7763 *result_die_cu_handle = dwarf_cu; 7764 return die; 7765 } 7766 } 7767 break; 7768 } 7769 7770 // Give the concrete function die specified by "func_die_offset", find the 7771 // concrete block whose DW_AT_specification or DW_AT_abstract_origin points 7772 // to "spec_block_die_offset" 7773 for (const DWARFDebugInfoEntry *child_die = die->GetFirstChild(); child_die != NULL; child_die = child_die->GetSibling()) 7774 { 7775 const DWARFDebugInfoEntry *result_die = FindBlockContainingSpecification (dwarf_cu, 7776 child_die, 7777 spec_block_die_offset, 7778 result_die_cu_handle); 7779 if (result_die) 7780 return result_die; 7781 } 7782 } 7783 7784 *result_die_cu_handle = NULL; 7785 return NULL; 7786 } 7787 7788 size_t 7789 SymbolFileDWARF::ParseVariables 7790 ( 7791 const SymbolContext& sc, 7792 DWARFCompileUnit* dwarf_cu, 7793 const lldb::addr_t func_low_pc, 7794 const DWARFDebugInfoEntry *orig_die, 7795 bool parse_siblings, 7796 bool parse_children, 7797 VariableList* cc_variable_list 7798 ) 7799 { 7800 if (orig_die == NULL) 7801 return 0; 7802 7803 VariableListSP variable_list_sp; 7804 7805 size_t vars_added = 0; 7806 const DWARFDebugInfoEntry *die = orig_die; 7807 while (die != NULL) 7808 { 7809 dw_tag_t tag = die->Tag(); 7810 7811 // Check to see if we have already parsed this variable or constant? 7812 if (m_die_to_variable_sp[die]) 7813 { 7814 if (cc_variable_list) 7815 cc_variable_list->AddVariableIfUnique (m_die_to_variable_sp[die]); 7816 } 7817 else 7818 { 7819 // We haven't already parsed it, lets do that now. 7820 if ((tag == DW_TAG_variable) || 7821 (tag == DW_TAG_constant) || 7822 (tag == DW_TAG_formal_parameter && sc.function)) 7823 { 7824 if (variable_list_sp.get() == NULL) 7825 { 7826 const DWARFDebugInfoEntry *sc_parent_die = GetParentSymbolContextDIE(orig_die); 7827 dw_tag_t parent_tag = sc_parent_die ? sc_parent_die->Tag() : 0; 7828 switch (parent_tag) 7829 { 7830 case DW_TAG_compile_unit: 7831 if (sc.comp_unit != NULL) 7832 { 7833 variable_list_sp = sc.comp_unit->GetVariableList(false); 7834 if (variable_list_sp.get() == NULL) 7835 { 7836 variable_list_sp.reset(new VariableList()); 7837 sc.comp_unit->SetVariableList(variable_list_sp); 7838 } 7839 } 7840 else 7841 { 7842 GetObjectFile()->GetModule()->ReportError ("parent 0x%8.8" PRIx64 " %s with no valid compile unit in symbol context for 0x%8.8" PRIx64 " %s.\n", 7843 MakeUserID(sc_parent_die->GetOffset()), 7844 DW_TAG_value_to_name (parent_tag), 7845 MakeUserID(orig_die->GetOffset()), 7846 DW_TAG_value_to_name (orig_die->Tag())); 7847 } 7848 break; 7849 7850 case DW_TAG_subprogram: 7851 case DW_TAG_inlined_subroutine: 7852 case DW_TAG_lexical_block: 7853 if (sc.function != NULL) 7854 { 7855 // Check to see if we already have parsed the variables for the given scope 7856 7857 Block *block = sc.function->GetBlock(true).FindBlockByID(MakeUserID(sc_parent_die->GetOffset())); 7858 if (block == NULL) 7859 { 7860 // This must be a specification or abstract origin with 7861 // a concrete block counterpart in the current function. We need 7862 // to find the concrete block so we can correctly add the 7863 // variable to it 7864 DWARFCompileUnit *concrete_block_die_cu = dwarf_cu; 7865 const DWARFDebugInfoEntry *concrete_block_die = FindBlockContainingSpecification (sc.function->GetID(), 7866 sc_parent_die->GetOffset(), 7867 &concrete_block_die_cu); 7868 if (concrete_block_die) 7869 block = sc.function->GetBlock(true).FindBlockByID(MakeUserID(concrete_block_die->GetOffset())); 7870 } 7871 7872 if (block != NULL) 7873 { 7874 const bool can_create = false; 7875 variable_list_sp = block->GetBlockVariableList (can_create); 7876 if (variable_list_sp.get() == NULL) 7877 { 7878 variable_list_sp.reset(new VariableList()); 7879 block->SetVariableList(variable_list_sp); 7880 } 7881 } 7882 } 7883 break; 7884 7885 default: 7886 GetObjectFile()->GetModule()->ReportError ("didn't find appropriate parent DIE for variable list for 0x%8.8" PRIx64 " %s.\n", 7887 MakeUserID(orig_die->GetOffset()), 7888 DW_TAG_value_to_name (orig_die->Tag())); 7889 break; 7890 } 7891 } 7892 7893 if (variable_list_sp) 7894 { 7895 VariableSP var_sp (ParseVariableDIE(sc, dwarf_cu, die, func_low_pc)); 7896 if (var_sp) 7897 { 7898 variable_list_sp->AddVariableIfUnique (var_sp); 7899 if (cc_variable_list) 7900 cc_variable_list->AddVariableIfUnique (var_sp); 7901 ++vars_added; 7902 } 7903 } 7904 } 7905 } 7906 7907 bool skip_children = (sc.function == NULL && tag == DW_TAG_subprogram); 7908 7909 if (!skip_children && parse_children && die->HasChildren()) 7910 { 7911 vars_added += ParseVariables(sc, dwarf_cu, func_low_pc, die->GetFirstChild(), true, true, cc_variable_list); 7912 } 7913 7914 if (parse_siblings) 7915 die = die->GetSibling(); 7916 else 7917 die = NULL; 7918 } 7919 return vars_added; 7920 } 7921 7922 //------------------------------------------------------------------ 7923 // PluginInterface protocol 7924 //------------------------------------------------------------------ 7925 ConstString 7926 SymbolFileDWARF::GetPluginName() 7927 { 7928 return GetPluginNameStatic(); 7929 } 7930 7931 uint32_t 7932 SymbolFileDWARF::GetPluginVersion() 7933 { 7934 return 1; 7935 } 7936 7937 void 7938 SymbolFileDWARF::CompleteTagDecl (void *baton, clang::TagDecl *decl) 7939 { 7940 SymbolFileDWARF *symbol_file_dwarf = (SymbolFileDWARF *)baton; 7941 ClangASTType clang_type = symbol_file_dwarf->GetClangASTContext().GetTypeForDecl (decl); 7942 if (clang_type) 7943 symbol_file_dwarf->ResolveClangOpaqueTypeDefinition (clang_type); 7944 } 7945 7946 void 7947 SymbolFileDWARF::CompleteObjCInterfaceDecl (void *baton, clang::ObjCInterfaceDecl *decl) 7948 { 7949 SymbolFileDWARF *symbol_file_dwarf = (SymbolFileDWARF *)baton; 7950 ClangASTType clang_type = symbol_file_dwarf->GetClangASTContext().GetTypeForDecl (decl); 7951 if (clang_type) 7952 symbol_file_dwarf->ResolveClangOpaqueTypeDefinition (clang_type); 7953 } 7954 7955 void 7956 SymbolFileDWARF::DumpIndexes () 7957 { 7958 StreamFile s(stdout, false); 7959 7960 s.Printf ("DWARF index for (%s) '%s':", 7961 GetObjectFile()->GetModule()->GetArchitecture().GetArchitectureName(), 7962 GetObjectFile()->GetFileSpec().GetPath().c_str()); 7963 s.Printf("\nFunction basenames:\n"); m_function_basename_index.Dump (&s); 7964 s.Printf("\nFunction fullnames:\n"); m_function_fullname_index.Dump (&s); 7965 s.Printf("\nFunction methods:\n"); m_function_method_index.Dump (&s); 7966 s.Printf("\nFunction selectors:\n"); m_function_selector_index.Dump (&s); 7967 s.Printf("\nObjective C class selectors:\n"); m_objc_class_selectors_index.Dump (&s); 7968 s.Printf("\nGlobals and statics:\n"); m_global_index.Dump (&s); 7969 s.Printf("\nTypes:\n"); m_type_index.Dump (&s); 7970 s.Printf("\nNamepaces:\n"); m_namespace_index.Dump (&s); 7971 } 7972 7973 void 7974 SymbolFileDWARF::SearchDeclContext (const clang::DeclContext *decl_context, 7975 const char *name, 7976 llvm::SmallVectorImpl <clang::NamedDecl *> *results) 7977 { 7978 DeclContextToDIEMap::iterator iter = m_decl_ctx_to_die.find(decl_context); 7979 7980 if (iter == m_decl_ctx_to_die.end()) 7981 return; 7982 7983 for (DIEPointerSet::iterator pos = iter->second.begin(), end = iter->second.end(); pos != end; ++pos) 7984 { 7985 const DWARFDebugInfoEntry *context_die = *pos; 7986 7987 if (!results) 7988 return; 7989 7990 DWARFDebugInfo* info = DebugInfo(); 7991 7992 DIEArray die_offsets; 7993 7994 DWARFCompileUnit* dwarf_cu = NULL; 7995 const DWARFDebugInfoEntry* die = NULL; 7996 7997 if (m_using_apple_tables) 7998 { 7999 if (m_apple_types_ap.get()) 8000 m_apple_types_ap->FindByName (name, die_offsets); 8001 } 8002 else 8003 { 8004 if (!m_indexed) 8005 Index (); 8006 8007 m_type_index.Find (ConstString(name), die_offsets); 8008 } 8009 8010 const size_t num_matches = die_offsets.size(); 8011 8012 if (num_matches) 8013 { 8014 for (size_t i = 0; i < num_matches; ++i) 8015 { 8016 const dw_offset_t die_offset = die_offsets[i]; 8017 die = info->GetDIEPtrWithCompileUnitHint (die_offset, &dwarf_cu); 8018 8019 if (die->GetParent() != context_die) 8020 continue; 8021 8022 Type *matching_type = ResolveType (dwarf_cu, die); 8023 8024 clang::QualType qual_type = matching_type->GetClangForwardType().GetQualType(); 8025 8026 if (const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(qual_type.getTypePtr())) 8027 { 8028 clang::TagDecl *tag_decl = tag_type->getDecl(); 8029 results->push_back(tag_decl); 8030 } 8031 else if (const clang::TypedefType *typedef_type = llvm::dyn_cast<clang::TypedefType>(qual_type.getTypePtr())) 8032 { 8033 clang::TypedefNameDecl *typedef_decl = typedef_type->getDecl(); 8034 results->push_back(typedef_decl); 8035 } 8036 } 8037 } 8038 } 8039 } 8040 8041 void 8042 SymbolFileDWARF::FindExternalVisibleDeclsByName (void *baton, 8043 const clang::DeclContext *decl_context, 8044 clang::DeclarationName decl_name, 8045 llvm::SmallVectorImpl <clang::NamedDecl *> *results) 8046 { 8047 8048 switch (decl_context->getDeclKind()) 8049 { 8050 case clang::Decl::Namespace: 8051 case clang::Decl::TranslationUnit: 8052 { 8053 SymbolFileDWARF *symbol_file_dwarf = (SymbolFileDWARF *)baton; 8054 symbol_file_dwarf->SearchDeclContext (decl_context, decl_name.getAsString().c_str(), results); 8055 } 8056 break; 8057 default: 8058 break; 8059 } 8060 } 8061 8062 bool 8063 SymbolFileDWARF::LayoutRecordType(void *baton, const clang::RecordDecl *record_decl, uint64_t &size, 8064 uint64_t &alignment, 8065 llvm::DenseMap<const clang::FieldDecl *, uint64_t> &field_offsets, 8066 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> &base_offsets, 8067 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> &vbase_offsets) 8068 { 8069 SymbolFileDWARF *symbol_file_dwarf = (SymbolFileDWARF *)baton; 8070 return symbol_file_dwarf->LayoutRecordType (record_decl, size, alignment, field_offsets, base_offsets, vbase_offsets); 8071 } 8072 8073 bool 8074 SymbolFileDWARF::LayoutRecordType(const clang::RecordDecl *record_decl, uint64_t &bit_size, uint64_t &alignment, 8075 llvm::DenseMap<const clang::FieldDecl *, uint64_t> &field_offsets, 8076 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> &base_offsets, 8077 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> &vbase_offsets) 8078 { 8079 Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO)); 8080 RecordDeclToLayoutMap::iterator pos = m_record_decl_to_layout_map.find (record_decl); 8081 bool success = false; 8082 base_offsets.clear(); 8083 vbase_offsets.clear(); 8084 if (pos != m_record_decl_to_layout_map.end()) 8085 { 8086 bit_size = pos->second.bit_size; 8087 alignment = pos->second.alignment; 8088 field_offsets.swap(pos->second.field_offsets); 8089 base_offsets.swap (pos->second.base_offsets); 8090 vbase_offsets.swap (pos->second.vbase_offsets); 8091 m_record_decl_to_layout_map.erase(pos); 8092 success = true; 8093 } 8094 else 8095 { 8096 bit_size = 0; 8097 alignment = 0; 8098 field_offsets.clear(); 8099 } 8100 8101 if (log) 8102 GetObjectFile()->GetModule()->LogMessage (log, 8103 "SymbolFileDWARF::LayoutRecordType (record_decl = %p, bit_size = %" PRIu64 ", alignment = %" PRIu64 ", field_offsets[%u],base_offsets[%u], vbase_offsets[%u]) success = %i", 8104 static_cast<const void*>(record_decl), 8105 bit_size, alignment, 8106 static_cast<uint32_t>(field_offsets.size()), 8107 static_cast<uint32_t>(base_offsets.size()), 8108 static_cast<uint32_t>(vbase_offsets.size()), 8109 success); 8110 return success; 8111 } 8112 8113 8114 SymbolFileDWARFDebugMap * 8115 SymbolFileDWARF::GetDebugMapSymfile () 8116 { 8117 if (m_debug_map_symfile == NULL && !m_debug_map_module_wp.expired()) 8118 { 8119 lldb::ModuleSP module_sp (m_debug_map_module_wp.lock()); 8120 if (module_sp) 8121 { 8122 SymbolVendor *sym_vendor = module_sp->GetSymbolVendor(); 8123 if (sym_vendor) 8124 m_debug_map_symfile = (SymbolFileDWARFDebugMap *)sym_vendor->GetSymbolFile(); 8125 } 8126 } 8127 return m_debug_map_symfile; 8128 } 8129 8130 8131