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