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