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