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