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