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