1 //===-- DWARFCompileUnit.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 "DWARFCompileUnit.h" 11 12 #include "lldb/Core/Mangled.h" 13 #include "lldb/Core/Module.h" 14 #include "lldb/Core/Stream.h" 15 #include "lldb/Core/StreamString.h" 16 #include "lldb/Core/Timer.h" 17 #include "lldb/Host/StringConvert.h" 18 #include "lldb/Symbol/CompileUnit.h" 19 #include "lldb/Symbol/LineTable.h" 20 #include "lldb/Symbol/ObjectFile.h" 21 #include "Plugins/Language/ObjC/ObjCLanguage.h" 22 23 #include "DWARFDebugAbbrev.h" 24 #include "DWARFDebugAranges.h" 25 #include "DWARFDebugInfo.h" 26 #include "DWARFDIECollection.h" 27 #include "DWARFFormValue.h" 28 #include "LogChannelDWARF.h" 29 #include "NameToDIE.h" 30 #include "SymbolFileDWARF.h" 31 #include "SymbolFileDWARFDwo.h" 32 #include "SymbolFileDWARFDebugMap.h" 33 34 using namespace lldb; 35 using namespace lldb_private; 36 using namespace std; 37 38 39 extern int g_verbose; 40 41 DWARFCompileUnit::DWARFCompileUnit(SymbolFileDWARF* dwarf2Data) : 42 m_dwarf2Data (dwarf2Data), 43 m_abbrevs (NULL), 44 m_user_data (NULL), 45 m_die_array (), 46 m_func_aranges_ap (), 47 m_base_addr (0), 48 m_offset (DW_INVALID_OFFSET), 49 m_length (0), 50 m_version (0), 51 m_addr_size (DWARFCompileUnit::GetDefaultAddressSize()), 52 m_producer (eProducerInvalid), 53 m_producer_version_major (0), 54 m_producer_version_minor (0), 55 m_producer_version_update (0), 56 m_language_type (eLanguageTypeUnknown), 57 m_is_dwarf64 (false), 58 m_is_optimized (eLazyBoolCalculate), 59 m_addr_base (0), 60 m_base_obj_offset (DW_INVALID_OFFSET) 61 { 62 } 63 64 DWARFCompileUnit::~DWARFCompileUnit() 65 {} 66 67 void 68 DWARFCompileUnit::Clear() 69 { 70 m_offset = DW_INVALID_OFFSET; 71 m_length = 0; 72 m_version = 0; 73 m_abbrevs = NULL; 74 m_addr_size = DWARFCompileUnit::GetDefaultAddressSize(); 75 m_base_addr = 0; 76 m_die_array.clear(); 77 m_func_aranges_ap.reset(); 78 m_user_data = NULL; 79 m_producer = eProducerInvalid; 80 m_language_type = eLanguageTypeUnknown; 81 m_is_dwarf64 = false; 82 m_is_optimized = eLazyBoolCalculate; 83 m_addr_base = 0; 84 m_base_obj_offset = DW_INVALID_OFFSET; 85 } 86 87 bool 88 DWARFCompileUnit::Extract(const DWARFDataExtractor &debug_info, lldb::offset_t *offset_ptr) 89 { 90 Clear(); 91 92 m_offset = *offset_ptr; 93 94 if (debug_info.ValidOffset(*offset_ptr)) 95 { 96 dw_offset_t abbr_offset; 97 const DWARFDebugAbbrev *abbr = m_dwarf2Data->DebugAbbrev(); 98 m_length = debug_info.GetDWARFInitialLength(offset_ptr); 99 m_is_dwarf64 = debug_info.IsDWARF64(); 100 m_version = debug_info.GetU16(offset_ptr); 101 abbr_offset = debug_info.GetDWARFOffset(offset_ptr); 102 m_addr_size = debug_info.GetU8 (offset_ptr); 103 104 bool length_OK = debug_info.ValidOffset(GetNextCompileUnitOffset()-1); 105 bool version_OK = SymbolFileDWARF::SupportedVersion(m_version); 106 bool abbr_offset_OK = m_dwarf2Data->get_debug_abbrev_data().ValidOffset(abbr_offset); 107 bool addr_size_OK = ((m_addr_size == 4) || (m_addr_size == 8)); 108 109 if (length_OK && version_OK && addr_size_OK && abbr_offset_OK && abbr != NULL) 110 { 111 m_abbrevs = abbr->GetAbbreviationDeclarationSet(abbr_offset); 112 return true; 113 } 114 115 // reset the offset to where we tried to parse from if anything went wrong 116 *offset_ptr = m_offset; 117 } 118 119 return false; 120 } 121 122 123 void 124 DWARFCompileUnit::ClearDIEs(bool keep_compile_unit_die) 125 { 126 if (m_die_array.size() > 1) 127 { 128 // std::vectors never get any smaller when resized to a smaller size, 129 // or when clear() or erase() are called, the size will report that it 130 // is smaller, but the memory allocated remains intact (call capacity() 131 // to see this). So we need to create a temporary vector and swap the 132 // contents which will cause just the internal pointers to be swapped 133 // so that when "tmp_array" goes out of scope, it will destroy the 134 // contents. 135 136 // Save at least the compile unit DIE 137 DWARFDebugInfoEntry::collection tmp_array; 138 m_die_array.swap(tmp_array); 139 if (keep_compile_unit_die) 140 m_die_array.push_back(tmp_array.front()); 141 } 142 143 if (m_dwo_symbol_file) 144 m_dwo_symbol_file->GetCompileUnit()->ClearDIEs(keep_compile_unit_die); 145 } 146 147 //---------------------------------------------------------------------- 148 // ParseCompileUnitDIEsIfNeeded 149 // 150 // Parses a compile unit and indexes its DIEs if it hasn't already been 151 // done. 152 //---------------------------------------------------------------------- 153 size_t 154 DWARFCompileUnit::ExtractDIEsIfNeeded (bool cu_die_only) 155 { 156 const size_t initial_die_array_size = m_die_array.size(); 157 if ((cu_die_only && initial_die_array_size > 0) || initial_die_array_size > 1) 158 return 0; // Already parsed 159 160 Timer scoped_timer (__PRETTY_FUNCTION__, 161 "%8.8x: DWARFCompileUnit::ExtractDIEsIfNeeded( cu_die_only = %i )", 162 m_offset, 163 cu_die_only); 164 165 // Set the offset to that of the first DIE and calculate the start of the 166 // next compilation unit header. 167 lldb::offset_t offset = GetFirstDIEOffset(); 168 lldb::offset_t next_cu_offset = GetNextCompileUnitOffset(); 169 170 DWARFDebugInfoEntry die; 171 // Keep a flat array of the DIE for binary lookup by DIE offset 172 if (!cu_die_only) 173 { 174 Log *log (LogChannelDWARF::GetLogIfAny(DWARF_LOG_DEBUG_INFO | DWARF_LOG_LOOKUPS)); 175 if (log) 176 { 177 m_dwarf2Data->GetObjectFile()->GetModule()->LogMessageVerboseBacktrace (log, 178 "DWARFCompileUnit::ExtractDIEsIfNeeded () for compile unit at .debug_info[0x%8.8x]", 179 GetOffset()); 180 } 181 } 182 183 uint32_t depth = 0; 184 // We are in our compile unit, parse starting at the offset 185 // we were told to parse 186 const DWARFDataExtractor& debug_info_data = m_dwarf2Data->get_debug_info_data(); 187 std::vector<uint32_t> die_index_stack; 188 die_index_stack.reserve(32); 189 die_index_stack.push_back(0); 190 bool prev_die_had_children = false; 191 DWARFFormValue::FixedFormSizes fixed_form_sizes = 192 DWARFFormValue::GetFixedFormSizesForAddressSize (GetAddressByteSize(), m_is_dwarf64); 193 while (offset < next_cu_offset && 194 die.FastExtract (debug_info_data, this, fixed_form_sizes, &offset)) 195 { 196 // if (log) 197 // log->Printf("0x%8.8x: %*.*s%s%s", 198 // die.GetOffset(), 199 // depth * 2, depth * 2, "", 200 // DW_TAG_value_to_name (die.Tag()), 201 // die.HasChildren() ? " *" : ""); 202 203 const bool null_die = die.IsNULL(); 204 if (depth == 0) 205 { 206 if (initial_die_array_size == 0) 207 AddCompileUnitDIE(die); 208 uint64_t base_addr = die.GetAttributeValueAsAddress(m_dwarf2Data, this, DW_AT_low_pc, LLDB_INVALID_ADDRESS); 209 if (base_addr == LLDB_INVALID_ADDRESS) 210 base_addr = die.GetAttributeValueAsAddress(m_dwarf2Data, this, DW_AT_entry_pc, 0); 211 SetBaseAddress (base_addr); 212 if (cu_die_only) 213 return 1; 214 } 215 else 216 { 217 if (null_die) 218 { 219 if (prev_die_had_children) 220 { 221 // This will only happen if a DIE says is has children 222 // but all it contains is a NULL tag. Since we are removing 223 // the NULL DIEs from the list (saves up to 25% in C++ code), 224 // we need a way to let the DIE know that it actually doesn't 225 // have children. 226 if (!m_die_array.empty()) 227 m_die_array.back().SetEmptyChildren(true); 228 } 229 } 230 else 231 { 232 die.SetParentIndex(m_die_array.size() - die_index_stack[depth-1]); 233 234 if (die_index_stack.back()) 235 m_die_array[die_index_stack.back()].SetSiblingIndex(m_die_array.size()-die_index_stack.back()); 236 237 // Only push the DIE if it isn't a NULL DIE 238 m_die_array.push_back(die); 239 } 240 } 241 242 if (null_die) 243 { 244 // NULL DIE. 245 if (!die_index_stack.empty()) 246 die_index_stack.pop_back(); 247 248 if (depth > 0) 249 --depth; 250 if (depth == 0) 251 break; // We are done with this compile unit! 252 253 prev_die_had_children = false; 254 } 255 else 256 { 257 die_index_stack.back() = m_die_array.size() - 1; 258 // Normal DIE 259 const bool die_has_children = die.HasChildren(); 260 if (die_has_children) 261 { 262 die_index_stack.push_back(0); 263 ++depth; 264 } 265 prev_die_had_children = die_has_children; 266 } 267 } 268 269 // Give a little bit of info if we encounter corrupt DWARF (our offset 270 // should always terminate at or before the start of the next compilation 271 // unit header). 272 if (offset > next_cu_offset) 273 { 274 m_dwarf2Data->GetObjectFile()->GetModule()->ReportWarning ("DWARF compile unit extends beyond its bounds cu 0x%8.8x at 0x%8.8" PRIx64 "\n", 275 GetOffset(), 276 offset); 277 } 278 279 // Since std::vector objects will double their size, we really need to 280 // make a new array with the perfect size so we don't end up wasting 281 // space. So here we copy and swap to make sure we don't have any extra 282 // memory taken up. 283 284 if (m_die_array.size () < m_die_array.capacity()) 285 { 286 DWARFDebugInfoEntry::collection exact_size_die_array (m_die_array.begin(), m_die_array.end()); 287 exact_size_die_array.swap (m_die_array); 288 } 289 Log *verbose_log (LogChannelDWARF::GetLogIfAll (DWARF_LOG_DEBUG_INFO | DWARF_LOG_VERBOSE)); 290 if (verbose_log) 291 { 292 StreamString strm; 293 Dump(&strm); 294 if (m_die_array.empty()) 295 strm.Printf("error: no DIE for compile unit"); 296 else 297 m_die_array[0].Dump(m_dwarf2Data, this, strm, UINT32_MAX); 298 verbose_log->PutCString (strm.GetString().c_str()); 299 } 300 301 if (!m_dwo_symbol_file) 302 return m_die_array.size(); 303 304 DWARFCompileUnit* dwo_cu = m_dwo_symbol_file->GetCompileUnit(); 305 size_t dwo_die_count = dwo_cu->ExtractDIEsIfNeeded(cu_die_only); 306 return m_die_array.size() + dwo_die_count - 1; // We have 2 CU die, but we waht to count it only as one 307 } 308 309 void 310 DWARFCompileUnit::AddCompileUnitDIE(DWARFDebugInfoEntry& die) 311 { 312 assert (m_die_array.empty() && "Compile unit DIE already added"); 313 AddDIE(die); 314 315 const DWARFDebugInfoEntry &cu_die = m_die_array.front(); 316 std::unique_ptr<SymbolFileDWARFDwo> dwo_symbol_file = m_dwarf2Data->GetDwoSymbolFileForCompileUnit(*this, cu_die); 317 if (!dwo_symbol_file) 318 return; 319 320 DWARFCompileUnit* dwo_cu = dwo_symbol_file->GetCompileUnit(); 321 if (!dwo_cu) 322 return; // Can't fetch the compile unit from the dwo file. 323 324 DWARFDIE dwo_cu_die = dwo_cu->GetCompileUnitDIEOnly(); 325 if (!dwo_cu_die.IsValid()) 326 return; // Can't fetch the compile unit DIE from the dwo file. 327 328 uint64_t main_dwo_id = cu_die.GetAttributeValueAsUnsigned(m_dwarf2Data, 329 this, 330 DW_AT_GNU_dwo_id, 331 0); 332 uint64_t sub_dwo_id = dwo_cu_die.GetAttributeValueAsUnsigned(DW_AT_GNU_dwo_id, 0); 333 if (main_dwo_id != sub_dwo_id) 334 return; // The 2 dwo ID isn't match. Don't use the dwo file as it belongs to a differectn compilation. 335 336 m_dwo_symbol_file = std::move(dwo_symbol_file); 337 338 dw_addr_t addr_base = cu_die.GetAttributeValueAsUnsigned(m_dwarf2Data, 339 this, 340 DW_AT_GNU_addr_base, 341 0); 342 dwo_cu->SetAddrBase(addr_base, m_offset); 343 } 344 345 dw_offset_t 346 DWARFCompileUnit::GetAbbrevOffset() const 347 { 348 return m_abbrevs ? m_abbrevs->GetOffset() : DW_INVALID_OFFSET; 349 } 350 351 352 353 bool 354 DWARFCompileUnit::Verify(Stream *s) const 355 { 356 const DWARFDataExtractor& debug_info = m_dwarf2Data->get_debug_info_data(); 357 bool valid_offset = debug_info.ValidOffset(m_offset); 358 bool length_OK = debug_info.ValidOffset(GetNextCompileUnitOffset()-1); 359 bool version_OK = SymbolFileDWARF::SupportedVersion(m_version); 360 bool abbr_offset_OK = m_dwarf2Data->get_debug_abbrev_data().ValidOffset(GetAbbrevOffset()); 361 bool addr_size_OK = ((m_addr_size == 4) || (m_addr_size == 8)); 362 bool verbose = s->GetVerbose(); 363 if (valid_offset && length_OK && version_OK && addr_size_OK && abbr_offset_OK) 364 { 365 if (verbose) 366 s->Printf(" 0x%8.8x: OK\n", m_offset); 367 return true; 368 } 369 else 370 { 371 s->Printf(" 0x%8.8x: ", m_offset); 372 373 m_dwarf2Data->get_debug_info_data().Dump (s, m_offset, lldb::eFormatHex, 1, Size(), 32, LLDB_INVALID_ADDRESS, 0, 0); 374 s->EOL(); 375 if (valid_offset) 376 { 377 if (!length_OK) 378 s->Printf(" The length (0x%8.8x) for this compile unit is too large for the .debug_info provided.\n", m_length); 379 if (!version_OK) 380 s->Printf(" The 16 bit compile unit header version is not supported.\n"); 381 if (!abbr_offset_OK) 382 s->Printf(" The offset into the .debug_abbrev section (0x%8.8x) is not valid.\n", GetAbbrevOffset()); 383 if (!addr_size_OK) 384 s->Printf(" The address size is unsupported: 0x%2.2x\n", m_addr_size); 385 } 386 else 387 s->Printf(" The start offset of the compile unit header in the .debug_info is invalid.\n"); 388 } 389 return false; 390 } 391 392 393 void 394 DWARFCompileUnit::Dump(Stream *s) const 395 { 396 s->Printf("0x%8.8x: Compile Unit: length = 0x%8.8x, version = 0x%4.4x, abbr_offset = 0x%8.8x, addr_size = 0x%2.2x (next CU at {0x%8.8x})\n", 397 m_offset, m_length, m_version, GetAbbrevOffset(), m_addr_size, GetNextCompileUnitOffset()); 398 } 399 400 401 static uint8_t g_default_addr_size = 4; 402 403 uint8_t 404 DWARFCompileUnit::GetAddressByteSize(const DWARFCompileUnit* cu) 405 { 406 if (cu) 407 return cu->GetAddressByteSize(); 408 return DWARFCompileUnit::GetDefaultAddressSize(); 409 } 410 411 bool 412 DWARFCompileUnit::IsDWARF64(const DWARFCompileUnit* cu) 413 { 414 if (cu) 415 return cu->IsDWARF64(); 416 return false; 417 } 418 419 uint8_t 420 DWARFCompileUnit::GetDefaultAddressSize() 421 { 422 return g_default_addr_size; 423 } 424 425 void 426 DWARFCompileUnit::SetDefaultAddressSize(uint8_t addr_size) 427 { 428 g_default_addr_size = addr_size; 429 } 430 431 lldb::user_id_t 432 DWARFCompileUnit::GetID () const 433 { 434 dw_offset_t local_id = m_base_obj_offset != DW_INVALID_OFFSET ? m_base_obj_offset : m_offset; 435 if (m_dwarf2Data) 436 return DIERef(local_id, local_id).GetUID(m_dwarf2Data); 437 else 438 return local_id; 439 } 440 441 void 442 DWARFCompileUnit::BuildAddressRangeTable (SymbolFileDWARF* dwarf2Data, 443 DWARFDebugAranges* debug_aranges) 444 { 445 // This function is usually called if there in no .debug_aranges section 446 // in order to produce a compile unit level set of address ranges that 447 // is accurate. 448 449 size_t num_debug_aranges = debug_aranges->GetNumRanges(); 450 451 // First get the compile unit DIE only and check if it has a DW_AT_ranges 452 const DWARFDebugInfoEntry* die = GetCompileUnitDIEPtrOnly(); 453 454 const dw_offset_t cu_offset = GetOffset(); 455 if (die) 456 { 457 DWARFRangeList ranges; 458 const size_t num_ranges = die->GetAttributeAddressRanges(dwarf2Data, this, ranges, false); 459 if (num_ranges > 0) 460 { 461 // This compile unit has DW_AT_ranges, assume this is correct if it 462 // is present since clang no longer makes .debug_aranges by default 463 // and it emits DW_AT_ranges for DW_TAG_compile_units. GCC also does 464 // this with recent GCC builds. 465 for (size_t i=0; i<num_ranges; ++i) 466 { 467 const DWARFRangeList::Entry &range = ranges.GetEntryRef(i); 468 debug_aranges->AppendRange(cu_offset, range.GetRangeBase(), range.GetRangeEnd()); 469 } 470 471 return; // We got all of our ranges from the DW_AT_ranges attribute 472 } 473 } 474 // We don't have a DW_AT_ranges attribute, so we need to parse the DWARF 475 476 // If the DIEs weren't parsed, then we don't want all dies for all compile units 477 // to stay loaded when they weren't needed. So we can end up parsing the DWARF 478 // and then throwing them all away to keep memory usage down. 479 const bool clear_dies = ExtractDIEsIfNeeded (false) > 1; 480 481 die = DIEPtr(); 482 if (die) 483 die->BuildAddressRangeTable(dwarf2Data, this, debug_aranges); 484 485 if (debug_aranges->GetNumRanges() == num_debug_aranges) 486 { 487 // We got nothing from the functions, maybe we have a line tables only 488 // situation. Check the line tables and build the arange table from this. 489 SymbolContext sc; 490 sc.comp_unit = dwarf2Data->GetCompUnitForDWARFCompUnit(this); 491 if (sc.comp_unit) 492 { 493 SymbolFileDWARFDebugMap *debug_map_sym_file = m_dwarf2Data->GetDebugMapSymfile(); 494 if (debug_map_sym_file == NULL) 495 { 496 LineTable *line_table = sc.comp_unit->GetLineTable(); 497 498 if (line_table) 499 { 500 LineTable::FileAddressRanges file_ranges; 501 const bool append = true; 502 const size_t num_ranges = line_table->GetContiguousFileAddressRanges (file_ranges, append); 503 for (uint32_t idx=0; idx<num_ranges; ++idx) 504 { 505 const LineTable::FileAddressRanges::Entry &range = file_ranges.GetEntryRef(idx); 506 debug_aranges->AppendRange(cu_offset, range.GetRangeBase(), range.GetRangeEnd()); 507 } 508 } 509 } 510 else 511 debug_map_sym_file->AddOSOARanges(dwarf2Data,debug_aranges); 512 } 513 } 514 515 if (debug_aranges->GetNumRanges() == num_debug_aranges) 516 { 517 // We got nothing from the functions, maybe we have a line tables only 518 // situation. Check the line tables and build the arange table from this. 519 SymbolContext sc; 520 sc.comp_unit = dwarf2Data->GetCompUnitForDWARFCompUnit(this); 521 if (sc.comp_unit) 522 { 523 LineTable *line_table = sc.comp_unit->GetLineTable(); 524 525 if (line_table) 526 { 527 LineTable::FileAddressRanges file_ranges; 528 const bool append = true; 529 const size_t num_ranges = line_table->GetContiguousFileAddressRanges (file_ranges, append); 530 for (uint32_t idx=0; idx<num_ranges; ++idx) 531 { 532 const LineTable::FileAddressRanges::Entry &range = file_ranges.GetEntryRef(idx); 533 debug_aranges->AppendRange(GetOffset(), range.GetRangeBase(), range.GetRangeEnd()); 534 } 535 } 536 } 537 } 538 539 // Keep memory down by clearing DIEs if this generate function 540 // caused them to be parsed 541 if (clear_dies) 542 ClearDIEs (true); 543 544 } 545 546 547 const DWARFDebugAranges & 548 DWARFCompileUnit::GetFunctionAranges () 549 { 550 if (m_func_aranges_ap.get() == NULL) 551 { 552 m_func_aranges_ap.reset (new DWARFDebugAranges()); 553 Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_ARANGES)); 554 555 if (log) 556 { 557 m_dwarf2Data->GetObjectFile()->GetModule()->LogMessage (log, 558 "DWARFCompileUnit::GetFunctionAranges() for compile unit at .debug_info[0x%8.8x]", 559 GetOffset()); 560 } 561 const DWARFDebugInfoEntry* die = DIEPtr(); 562 if (die) 563 die->BuildFunctionAddressRangeTable (m_dwarf2Data, this, m_func_aranges_ap.get()); 564 565 if (m_dwo_symbol_file) 566 { 567 DWARFCompileUnit* dwo_cu = m_dwo_symbol_file->GetCompileUnit(); 568 const DWARFDebugInfoEntry* dwo_die = dwo_cu->DIEPtr(); 569 if (dwo_die) 570 dwo_die->BuildFunctionAddressRangeTable (m_dwo_symbol_file.get(), 571 dwo_cu, 572 m_func_aranges_ap.get()); 573 } 574 575 const bool minimize = false; 576 m_func_aranges_ap->Sort(minimize); 577 } 578 return *m_func_aranges_ap.get(); 579 } 580 581 DWARFDIE 582 DWARFCompileUnit::LookupAddress (const dw_addr_t address) 583 { 584 if (DIE()) 585 { 586 const DWARFDebugAranges &func_aranges = GetFunctionAranges (); 587 588 // Re-check the aranges auto pointer contents in case it was created above 589 if (!func_aranges.IsEmpty()) 590 return GetDIE(func_aranges.FindAddress(address)); 591 } 592 return DWARFDIE(); 593 } 594 595 //---------------------------------------------------------------------- 596 // Compare function DWARFDebugAranges::Range structures 597 //---------------------------------------------------------------------- 598 static bool CompareDIEOffset (const DWARFDebugInfoEntry& die, const dw_offset_t die_offset) 599 { 600 return die.GetOffset() < die_offset; 601 } 602 603 //---------------------------------------------------------------------- 604 // GetDIE() 605 // 606 // Get the DIE (Debug Information Entry) with the specified offset by 607 // first checking if the DIE is contained within this compile unit and 608 // grabbing the DIE from this compile unit. Otherwise we grab the DIE 609 // from the DWARF file. 610 //---------------------------------------------------------------------- 611 DWARFDIE 612 DWARFCompileUnit::GetDIE (dw_offset_t die_offset) 613 { 614 if (die_offset != DW_INVALID_OFFSET) 615 { 616 if (m_dwo_symbol_file) 617 return m_dwo_symbol_file->GetCompileUnit()->GetDIE(die_offset); 618 619 if (ContainsDIEOffset(die_offset)) 620 { 621 ExtractDIEsIfNeeded (false); 622 DWARFDebugInfoEntry::iterator end = m_die_array.end(); 623 DWARFDebugInfoEntry::iterator pos = lower_bound(m_die_array.begin(), end, die_offset, CompareDIEOffset); 624 if (pos != end) 625 { 626 if (die_offset == (*pos).GetOffset()) 627 return DWARFDIE(this, &(*pos)); 628 } 629 } 630 else 631 { 632 // Don't specify the compile unit offset as we don't know it because the DIE belongs to 633 // a different compile unit in the same symbol file. 634 return m_dwarf2Data->DebugInfo()->GetDIEForDIEOffset(die_offset); 635 } 636 } 637 return DWARFDIE(); // Not found 638 } 639 640 size_t 641 DWARFCompileUnit::AppendDIEsWithTag (const dw_tag_t tag, DWARFDIECollection& dies, uint32_t depth) const 642 { 643 size_t old_size = dies.Size(); 644 DWARFDebugInfoEntry::const_iterator pos; 645 DWARFDebugInfoEntry::const_iterator end = m_die_array.end(); 646 for (pos = m_die_array.begin(); pos != end; ++pos) 647 { 648 if (pos->Tag() == tag) 649 dies.Append (DWARFDIE(this, &(*pos))); 650 } 651 652 // Return the number of DIEs added to the collection 653 return dies.Size() - old_size; 654 } 655 656 //void 657 //DWARFCompileUnit::AddGlobalDIEByIndex (uint32_t die_idx) 658 //{ 659 // m_global_die_indexes.push_back (die_idx); 660 //} 661 // 662 // 663 //void 664 //DWARFCompileUnit::AddGlobal (const DWARFDebugInfoEntry* die) 665 //{ 666 // // Indexes to all file level global and static variables 667 // m_global_die_indexes; 668 // 669 // if (m_die_array.empty()) 670 // return; 671 // 672 // const DWARFDebugInfoEntry* first_die = &m_die_array[0]; 673 // const DWARFDebugInfoEntry* end = first_die + m_die_array.size(); 674 // if (first_die <= die && die < end) 675 // m_global_die_indexes.push_back (die - first_die); 676 //} 677 678 679 void 680 DWARFCompileUnit::Index (NameToDIE& func_basenames, 681 NameToDIE& func_fullnames, 682 NameToDIE& func_methods, 683 NameToDIE& func_selectors, 684 NameToDIE& objc_class_selectors, 685 NameToDIE& globals, 686 NameToDIE& types, 687 NameToDIE& namespaces) 688 { 689 Log *log (LogChannelDWARF::GetLogIfAll (DWARF_LOG_LOOKUPS)); 690 691 if (log) 692 { 693 m_dwarf2Data->GetObjectFile()->GetModule()->LogMessage (log, 694 "DWARFCompileUnit::Index() for compile unit at .debug_info[0x%8.8x]", 695 GetOffset()); 696 } 697 698 const LanguageType cu_language = GetLanguageType(); 699 DWARFFormValue::FixedFormSizes fixed_form_sizes = 700 DWARFFormValue::GetFixedFormSizesForAddressSize (GetAddressByteSize(), m_is_dwarf64); 701 702 IndexPrivate(this, 703 cu_language, 704 fixed_form_sizes, 705 GetOffset(), 706 func_basenames, 707 func_fullnames, 708 func_methods, 709 func_selectors, 710 objc_class_selectors, 711 globals, 712 types, 713 namespaces); 714 715 SymbolFileDWARFDwo* dwo_symbol_file = GetDwoSymbolFile(); 716 if (dwo_symbol_file) 717 { 718 IndexPrivate(dwo_symbol_file->GetCompileUnit(), 719 cu_language, 720 fixed_form_sizes, 721 GetOffset(), 722 func_basenames, 723 func_fullnames, 724 func_methods, 725 func_selectors, 726 objc_class_selectors, 727 globals, 728 types, 729 namespaces); 730 } 731 } 732 733 void 734 DWARFCompileUnit::IndexPrivate (DWARFCompileUnit* dwarf_cu, 735 const LanguageType cu_language, 736 const DWARFFormValue::FixedFormSizes& fixed_form_sizes, 737 const dw_offset_t cu_offset, 738 NameToDIE& func_basenames, 739 NameToDIE& func_fullnames, 740 NameToDIE& func_methods, 741 NameToDIE& func_selectors, 742 NameToDIE& objc_class_selectors, 743 NameToDIE& globals, 744 NameToDIE& types, 745 NameToDIE& namespaces) 746 { 747 DWARFDebugInfoEntry::const_iterator pos; 748 DWARFDebugInfoEntry::const_iterator begin = dwarf_cu->m_die_array.begin(); 749 DWARFDebugInfoEntry::const_iterator end = dwarf_cu->m_die_array.end(); 750 for (pos = begin; pos != end; ++pos) 751 { 752 const DWARFDebugInfoEntry &die = *pos; 753 754 const dw_tag_t tag = die.Tag(); 755 756 switch (tag) 757 { 758 case DW_TAG_array_type: 759 case DW_TAG_base_type: 760 case DW_TAG_class_type: 761 case DW_TAG_constant: 762 case DW_TAG_enumeration_type: 763 case DW_TAG_inlined_subroutine: 764 case DW_TAG_namespace: 765 case DW_TAG_string_type: 766 case DW_TAG_structure_type: 767 case DW_TAG_subprogram: 768 case DW_TAG_subroutine_type: 769 case DW_TAG_typedef: 770 case DW_TAG_union_type: 771 case DW_TAG_unspecified_type: 772 case DW_TAG_variable: 773 break; 774 775 default: 776 continue; 777 } 778 779 DWARFAttributes attributes; 780 const char *name = NULL; 781 const char *mangled_cstr = NULL; 782 bool is_declaration = false; 783 //bool is_artificial = false; 784 bool has_address = false; 785 bool has_location_or_const_value = false; 786 bool is_global_or_static_variable = false; 787 788 DWARFFormValue specification_die_form; 789 const size_t num_attributes = die.GetAttributes(dwarf_cu, fixed_form_sizes, attributes); 790 if (num_attributes > 0) 791 { 792 for (uint32_t i=0; i<num_attributes; ++i) 793 { 794 dw_attr_t attr = attributes.AttributeAtIndex(i); 795 DWARFFormValue form_value; 796 switch (attr) 797 { 798 case DW_AT_name: 799 if (attributes.ExtractFormValueAtIndex(i, form_value)) 800 name = form_value.AsCString(); 801 break; 802 803 case DW_AT_declaration: 804 if (attributes.ExtractFormValueAtIndex(i, form_value)) 805 is_declaration = form_value.Unsigned() != 0; 806 break; 807 808 // case DW_AT_artificial: 809 // if (attributes.ExtractFormValueAtIndex(i, form_value)) 810 // is_artificial = form_value.Unsigned() != 0; 811 // break; 812 813 case DW_AT_MIPS_linkage_name: 814 case DW_AT_linkage_name: 815 if (attributes.ExtractFormValueAtIndex(i, form_value)) 816 mangled_cstr = form_value.AsCString(); 817 break; 818 819 case DW_AT_low_pc: 820 case DW_AT_high_pc: 821 case DW_AT_ranges: 822 has_address = true; 823 break; 824 825 case DW_AT_entry_pc: 826 has_address = true; 827 break; 828 829 case DW_AT_location: 830 case DW_AT_const_value: 831 has_location_or_const_value = true; 832 if (tag == DW_TAG_variable) 833 { 834 const DWARFDebugInfoEntry* parent_die = die.GetParent(); 835 while ( parent_die != NULL ) 836 { 837 switch (parent_die->Tag()) 838 { 839 case DW_TAG_subprogram: 840 case DW_TAG_lexical_block: 841 case DW_TAG_inlined_subroutine: 842 // Even if this is a function level static, we don't add it. We could theoretically 843 // add these if we wanted to by introspecting into the DW_AT_location and seeing 844 // if the location describes a hard coded address, but we dont want the performance 845 // penalty of that right now. 846 is_global_or_static_variable = false; 847 // if (attributes.ExtractFormValueAtIndex(dwarf2Data, i, form_value)) 848 // { 849 // // If we have valid block data, then we have location expression bytes 850 // // that are fixed (not a location list). 851 // const uint8_t *block_data = form_value.BlockData(); 852 // if (block_data) 853 // { 854 // uint32_t block_length = form_value.Unsigned(); 855 // if (block_length == 1 + attributes.CompileUnitAtIndex(i)->GetAddressByteSize()) 856 // { 857 // if (block_data[0] == DW_OP_addr) 858 // add_die = true; 859 // } 860 // } 861 // } 862 parent_die = NULL; // Terminate the while loop. 863 break; 864 865 case DW_TAG_compile_unit: 866 is_global_or_static_variable = true; 867 parent_die = NULL; // Terminate the while loop. 868 break; 869 870 default: 871 parent_die = parent_die->GetParent(); // Keep going in the while loop. 872 break; 873 } 874 } 875 } 876 break; 877 878 case DW_AT_specification: 879 if (attributes.ExtractFormValueAtIndex(i, form_value)) 880 specification_die_form = form_value; 881 break; 882 } 883 } 884 } 885 886 switch (tag) 887 { 888 case DW_TAG_subprogram: 889 if (has_address) 890 { 891 if (name) 892 { 893 ObjCLanguage::MethodName objc_method(name, true); 894 if (objc_method.IsValid(true)) 895 { 896 ConstString objc_class_name_with_category (objc_method.GetClassNameWithCategory()); 897 ConstString objc_selector_name (objc_method.GetSelector()); 898 ConstString objc_fullname_no_category_name (objc_method.GetFullNameWithoutCategory(true)); 899 ConstString objc_class_name_no_category (objc_method.GetClassName()); 900 func_fullnames.Insert (ConstString(name), DIERef(cu_offset, die.GetOffset())); 901 if (objc_class_name_with_category) 902 objc_class_selectors.Insert(objc_class_name_with_category, DIERef(cu_offset, die.GetOffset())); 903 if (objc_class_name_no_category && objc_class_name_no_category != objc_class_name_with_category) 904 objc_class_selectors.Insert(objc_class_name_no_category, DIERef(cu_offset, die.GetOffset())); 905 if (objc_selector_name) 906 func_selectors.Insert (objc_selector_name, DIERef(cu_offset, die.GetOffset())); 907 if (objc_fullname_no_category_name) 908 func_fullnames.Insert (objc_fullname_no_category_name, DIERef(cu_offset, die.GetOffset())); 909 } 910 // If we have a mangled name, then the DW_AT_name attribute 911 // is usually the method name without the class or any parameters 912 const DWARFDebugInfoEntry *parent = die.GetParent(); 913 bool is_method = false; 914 if (parent) 915 { 916 dw_tag_t parent_tag = parent->Tag(); 917 if (parent_tag == DW_TAG_class_type || parent_tag == DW_TAG_structure_type) 918 { 919 is_method = true; 920 } 921 else 922 { 923 if (specification_die_form.IsValid()) 924 { 925 DWARFDIE specification_die = dwarf_cu->GetSymbolFileDWARF()->DebugInfo()->GetDIE (DIERef(specification_die_form)); 926 if (specification_die.GetParent().IsStructOrClass()) 927 is_method = true; 928 } 929 } 930 } 931 932 933 if (is_method) 934 func_methods.Insert (ConstString(name), DIERef(cu_offset, die.GetOffset())); 935 else 936 func_basenames.Insert (ConstString(name), DIERef(cu_offset, die.GetOffset())); 937 938 if (!is_method && !mangled_cstr && !objc_method.IsValid(true)) 939 func_fullnames.Insert (ConstString(name), DIERef(cu_offset, die.GetOffset())); 940 } 941 if (mangled_cstr) 942 { 943 // Make sure our mangled name isn't the same string table entry 944 // as our name. If it starts with '_', then it is ok, else compare 945 // the string to make sure it isn't the same and we don't end up 946 // with duplicate entries 947 if (name && name != mangled_cstr && ((mangled_cstr[0] == '_') || (::strcmp(name, mangled_cstr) != 0))) 948 { 949 Mangled mangled (ConstString(mangled_cstr), true); 950 func_fullnames.Insert (mangled.GetMangledName(), DIERef(cu_offset, die.GetOffset())); 951 ConstString demangled = mangled.GetDemangledName(cu_language); 952 if (demangled) 953 func_fullnames.Insert (demangled, DIERef(cu_offset, die.GetOffset())); 954 } 955 } 956 } 957 break; 958 959 case DW_TAG_inlined_subroutine: 960 if (has_address) 961 { 962 if (name) 963 func_basenames.Insert (ConstString(name), DIERef(cu_offset, die.GetOffset())); 964 if (mangled_cstr) 965 { 966 // Make sure our mangled name isn't the same string table entry 967 // as our name. If it starts with '_', then it is ok, else compare 968 // the string to make sure it isn't the same and we don't end up 969 // with duplicate entries 970 if (name && name != mangled_cstr && ((mangled_cstr[0] == '_') || (::strcmp(name, mangled_cstr) != 0))) 971 { 972 Mangled mangled (ConstString(mangled_cstr), true); 973 func_fullnames.Insert (mangled.GetMangledName(), DIERef(cu_offset, die.GetOffset())); 974 ConstString demangled = mangled.GetDemangledName(cu_language); 975 if (demangled) 976 func_fullnames.Insert (demangled, DIERef(cu_offset, die.GetOffset())); 977 } 978 } 979 else 980 func_fullnames.Insert (ConstString(name), DIERef(cu_offset, die.GetOffset())); 981 } 982 break; 983 984 case DW_TAG_array_type: 985 case DW_TAG_base_type: 986 case DW_TAG_class_type: 987 case DW_TAG_constant: 988 case DW_TAG_enumeration_type: 989 case DW_TAG_string_type: 990 case DW_TAG_structure_type: 991 case DW_TAG_subroutine_type: 992 case DW_TAG_typedef: 993 case DW_TAG_union_type: 994 case DW_TAG_unspecified_type: 995 if (name && !is_declaration) 996 types.Insert (ConstString(name), DIERef(cu_offset, die.GetOffset())); 997 if (mangled_cstr && !is_declaration) 998 types.Insert (ConstString(mangled_cstr), DIERef(cu_offset, die.GetOffset())); 999 break; 1000 1001 case DW_TAG_namespace: 1002 if (name) 1003 namespaces.Insert (ConstString(name), DIERef(cu_offset, die.GetOffset())); 1004 break; 1005 1006 case DW_TAG_variable: 1007 if (name && has_location_or_const_value && is_global_or_static_variable) 1008 { 1009 globals.Insert (ConstString(name), DIERef(cu_offset, die.GetOffset())); 1010 // Be sure to include variables by their mangled and demangled 1011 // names if they have any since a variable can have a basename 1012 // "i", a mangled named "_ZN12_GLOBAL__N_11iE" and a demangled 1013 // mangled name "(anonymous namespace)::i"... 1014 1015 // Make sure our mangled name isn't the same string table entry 1016 // as our name. If it starts with '_', then it is ok, else compare 1017 // the string to make sure it isn't the same and we don't end up 1018 // with duplicate entries 1019 if (mangled_cstr && name != mangled_cstr && ((mangled_cstr[0] == '_') || (::strcmp(name, mangled_cstr) != 0))) 1020 { 1021 Mangled mangled (ConstString(mangled_cstr), true); 1022 globals.Insert (mangled.GetMangledName(), DIERef(cu_offset, die.GetOffset())); 1023 ConstString demangled = mangled.GetDemangledName(cu_language); 1024 if (demangled) 1025 globals.Insert (demangled, DIERef(cu_offset, die.GetOffset())); 1026 } 1027 } 1028 break; 1029 1030 default: 1031 continue; 1032 } 1033 } 1034 } 1035 1036 bool 1037 DWARFCompileUnit::Supports_unnamed_objc_bitfields () 1038 { 1039 if (GetProducer() == eProducerClang) 1040 { 1041 const uint32_t major_version = GetProducerVersionMajor(); 1042 if (major_version > 425 || (major_version == 425 && GetProducerVersionUpdate() >= 13)) 1043 return true; 1044 else 1045 return false; 1046 } 1047 return true; // Assume all other compilers didn't have incorrect ObjC bitfield info 1048 } 1049 1050 bool 1051 DWARFCompileUnit::Supports_DW_AT_APPLE_objc_complete_type () 1052 { 1053 if (GetProducer() == eProducerLLVMGCC) 1054 return false; 1055 return true; 1056 } 1057 1058 bool 1059 DWARFCompileUnit::DW_AT_decl_file_attributes_are_invalid() 1060 { 1061 // llvm-gcc makes completely invalid decl file attributes and won't ever 1062 // be fixed, so we need to know to ignore these. 1063 return GetProducer() == eProducerLLVMGCC; 1064 } 1065 1066 void 1067 DWARFCompileUnit::ParseProducerInfo () 1068 { 1069 m_producer_version_major = UINT32_MAX; 1070 m_producer_version_minor = UINT32_MAX; 1071 m_producer_version_update = UINT32_MAX; 1072 1073 const DWARFDebugInfoEntry *die = GetCompileUnitDIEPtrOnly(); 1074 if (die) 1075 { 1076 1077 const char *producer_cstr = die->GetAttributeValueAsString(m_dwarf2Data, this, DW_AT_producer, NULL); 1078 if (producer_cstr) 1079 { 1080 RegularExpression llvm_gcc_regex("^4\\.[012]\\.[01] \\(Based on Apple Inc\\. build [0-9]+\\) \\(LLVM build [\\.0-9]+\\)$"); 1081 if (llvm_gcc_regex.Execute (producer_cstr)) 1082 { 1083 m_producer = eProducerLLVMGCC; 1084 } 1085 else if (strstr(producer_cstr, "clang")) 1086 { 1087 static RegularExpression g_clang_version_regex("clang-([0-9]+)\\.([0-9]+)\\.([0-9]+)"); 1088 RegularExpression::Match regex_match(3); 1089 if (g_clang_version_regex.Execute (producer_cstr, ®ex_match)) 1090 { 1091 std::string str; 1092 if (regex_match.GetMatchAtIndex (producer_cstr, 1, str)) 1093 m_producer_version_major = StringConvert::ToUInt32(str.c_str(), UINT32_MAX, 10); 1094 if (regex_match.GetMatchAtIndex (producer_cstr, 2, str)) 1095 m_producer_version_minor = StringConvert::ToUInt32(str.c_str(), UINT32_MAX, 10); 1096 if (regex_match.GetMatchAtIndex (producer_cstr, 3, str)) 1097 m_producer_version_update = StringConvert::ToUInt32(str.c_str(), UINT32_MAX, 10); 1098 } 1099 m_producer = eProducerClang; 1100 } 1101 else if (strstr(producer_cstr, "GNU")) 1102 m_producer = eProducerGCC; 1103 } 1104 } 1105 if (m_producer == eProducerInvalid) 1106 m_producer = eProcucerOther; 1107 } 1108 1109 DWARFCompileUnit::Producer 1110 DWARFCompileUnit::GetProducer () 1111 { 1112 if (m_producer == eProducerInvalid) 1113 ParseProducerInfo (); 1114 return m_producer; 1115 } 1116 1117 1118 uint32_t 1119 DWARFCompileUnit::GetProducerVersionMajor() 1120 { 1121 if (m_producer_version_major == 0) 1122 ParseProducerInfo (); 1123 return m_producer_version_major; 1124 } 1125 1126 uint32_t 1127 DWARFCompileUnit::GetProducerVersionMinor() 1128 { 1129 if (m_producer_version_minor == 0) 1130 ParseProducerInfo (); 1131 return m_producer_version_minor; 1132 } 1133 1134 uint32_t 1135 DWARFCompileUnit::GetProducerVersionUpdate() 1136 { 1137 if (m_producer_version_update == 0) 1138 ParseProducerInfo (); 1139 return m_producer_version_update; 1140 } 1141 1142 LanguageType 1143 DWARFCompileUnit::LanguageTypeFromDWARF(uint64_t val) 1144 { 1145 // Note: user languages between lo_user and hi_user 1146 // must be handled explicitly here. 1147 switch (val) 1148 { 1149 case DW_LANG_Mips_Assembler: 1150 return eLanguageTypeMipsAssembler; 1151 case DW_LANG_GOOGLE_RenderScript: 1152 return eLanguageTypeExtRenderScript; 1153 default: 1154 return static_cast<LanguageType>(val); 1155 } 1156 } 1157 1158 LanguageType 1159 DWARFCompileUnit::GetLanguageType() 1160 { 1161 if (m_language_type != eLanguageTypeUnknown) 1162 return m_language_type; 1163 1164 const DWARFDebugInfoEntry *die = GetCompileUnitDIEPtrOnly(); 1165 if (die) 1166 m_language_type = LanguageTypeFromDWARF(die->GetAttributeValueAsUnsigned(m_dwarf2Data, this, DW_AT_language, 0)); 1167 return m_language_type; 1168 } 1169 1170 bool 1171 DWARFCompileUnit::IsDWARF64() const 1172 { 1173 return m_is_dwarf64; 1174 } 1175 1176 bool 1177 DWARFCompileUnit::GetIsOptimized () 1178 { 1179 if (m_is_optimized == eLazyBoolCalculate) 1180 { 1181 const DWARFDebugInfoEntry *die = GetCompileUnitDIEPtrOnly(); 1182 if (die) 1183 { 1184 m_is_optimized = eLazyBoolNo; 1185 if (die->GetAttributeValueAsUnsigned (m_dwarf2Data, this, DW_AT_APPLE_optimized, 0) == 1) 1186 { 1187 m_is_optimized = eLazyBoolYes; 1188 } 1189 } 1190 } 1191 if (m_is_optimized == eLazyBoolYes) 1192 { 1193 return true; 1194 } 1195 else 1196 { 1197 return false; 1198 } 1199 } 1200 1201 DWARFFormValue::FixedFormSizes 1202 DWARFCompileUnit::GetFixedFormSizes () 1203 { 1204 return DWARFFormValue::GetFixedFormSizesForAddressSize (GetAddressByteSize(), IsDWARF64()); 1205 } 1206 1207 TypeSystem * 1208 DWARFCompileUnit::GetTypeSystem () 1209 { 1210 if (m_dwarf2Data) 1211 return m_dwarf2Data->GetTypeSystemForLanguage(GetLanguageType()); 1212 else 1213 return nullptr; 1214 } 1215 1216 void 1217 DWARFCompileUnit::SetUserData(void *d) 1218 { 1219 m_user_data = d; 1220 if (m_dwo_symbol_file) 1221 m_dwo_symbol_file->GetCompileUnit()->SetUserData(d); 1222 } 1223 1224 void 1225 DWARFCompileUnit::SetAddrBase(dw_addr_t addr_base, dw_offset_t base_obj_offset) 1226 { 1227 m_addr_base = addr_base; 1228 m_base_obj_offset = base_obj_offset; 1229 } 1230 1231 lldb::ByteOrder 1232 DWARFCompileUnit::GetByteOrder() const 1233 { 1234 return m_dwarf2Data->GetObjectFile()->GetByteOrder(); 1235 } 1236