1 //===-- DWARFUnit.cpp -----------------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "DWARFUnit.h" 10 11 #include "lldb/Core/Module.h" 12 #include "lldb/Host/StringConvert.h" 13 #include "lldb/Symbol/ObjectFile.h" 14 #include "lldb/Utility/LLDBAssert.h" 15 #include "lldb/Utility/StreamString.h" 16 #include "lldb/Utility/Timer.h" 17 #include "llvm/Object/Error.h" 18 19 #include "DWARFCompileUnit.h" 20 #include "DWARFDebugAranges.h" 21 #include "DWARFDebugInfo.h" 22 #include "DWARFTypeUnit.h" 23 #include "LogChannelDWARF.h" 24 #include "SymbolFileDWARFDwo.h" 25 26 using namespace lldb; 27 using namespace lldb_private; 28 using namespace std; 29 30 extern int g_verbose; 31 32 DWARFUnit::DWARFUnit(SymbolFileDWARF &dwarf, lldb::user_id_t uid, 33 const DWARFUnitHeader &header, 34 const DWARFAbbreviationDeclarationSet &abbrevs, 35 DIERef::Section section, bool is_dwo) 36 : UserID(uid), m_dwarf(dwarf), m_header(header), m_abbrevs(&abbrevs), 37 m_cancel_scopes(false), m_section(section), m_is_dwo(is_dwo) {} 38 39 DWARFUnit::~DWARFUnit() = default; 40 41 // Parses first DIE of a compile unit. 42 void DWARFUnit::ExtractUnitDIEIfNeeded() { 43 { 44 llvm::sys::ScopedReader lock(m_first_die_mutex); 45 if (m_first_die) 46 return; // Already parsed 47 } 48 llvm::sys::ScopedWriter lock(m_first_die_mutex); 49 if (m_first_die) 50 return; // Already parsed 51 52 static Timer::Category func_cat(LLVM_PRETTY_FUNCTION); 53 Timer scoped_timer(func_cat, "%8.8x: DWARFUnit::ExtractUnitDIEIfNeeded()", 54 GetOffset()); 55 56 // Set the offset to that of the first DIE and calculate the start of the 57 // next compilation unit header. 58 lldb::offset_t offset = GetFirstDIEOffset(); 59 60 // We are in our compile unit, parse starting at the offset we were told to 61 // parse 62 const DWARFDataExtractor &data = GetData(); 63 if (offset < GetNextUnitOffset() && 64 m_first_die.Extract(data, this, &offset)) { 65 AddUnitDIE(m_first_die); 66 return; 67 } 68 } 69 70 // Parses a compile unit and indexes its DIEs if it hasn't already been done. 71 // It will leave this compile unit extracted forever. 72 void DWARFUnit::ExtractDIEsIfNeeded() { 73 m_cancel_scopes = true; 74 75 { 76 llvm::sys::ScopedReader lock(m_die_array_mutex); 77 if (!m_die_array.empty()) 78 return; // Already parsed 79 } 80 llvm::sys::ScopedWriter lock(m_die_array_mutex); 81 if (!m_die_array.empty()) 82 return; // Already parsed 83 84 ExtractDIEsRWLocked(); 85 } 86 87 // Parses a compile unit and indexes its DIEs if it hasn't already been done. 88 // It will clear this compile unit after returned instance gets out of scope, 89 // no other ScopedExtractDIEs instance is running for this compile unit 90 // and no ExtractDIEsIfNeeded() has been executed during this ScopedExtractDIEs 91 // lifetime. 92 DWARFUnit::ScopedExtractDIEs DWARFUnit::ExtractDIEsScoped() { 93 ScopedExtractDIEs scoped(*this); 94 95 { 96 llvm::sys::ScopedReader lock(m_die_array_mutex); 97 if (!m_die_array.empty()) 98 return scoped; // Already parsed 99 } 100 llvm::sys::ScopedWriter lock(m_die_array_mutex); 101 if (!m_die_array.empty()) 102 return scoped; // Already parsed 103 104 // Otherwise m_die_array would be already populated. 105 lldbassert(!m_cancel_scopes); 106 107 ExtractDIEsRWLocked(); 108 scoped.m_clear_dies = true; 109 return scoped; 110 } 111 112 DWARFUnit::ScopedExtractDIEs::ScopedExtractDIEs(DWARFUnit &cu) : m_cu(&cu) { 113 m_cu->m_die_array_scoped_mutex.lock_shared(); 114 } 115 116 DWARFUnit::ScopedExtractDIEs::~ScopedExtractDIEs() { 117 if (!m_cu) 118 return; 119 m_cu->m_die_array_scoped_mutex.unlock_shared(); 120 if (!m_clear_dies || m_cu->m_cancel_scopes) 121 return; 122 // Be sure no other ScopedExtractDIEs is running anymore. 123 llvm::sys::ScopedWriter lock_scoped(m_cu->m_die_array_scoped_mutex); 124 llvm::sys::ScopedWriter lock(m_cu->m_die_array_mutex); 125 if (m_cu->m_cancel_scopes) 126 return; 127 m_cu->ClearDIEsRWLocked(); 128 } 129 130 DWARFUnit::ScopedExtractDIEs::ScopedExtractDIEs(ScopedExtractDIEs &&rhs) 131 : m_cu(rhs.m_cu), m_clear_dies(rhs.m_clear_dies) { 132 rhs.m_cu = nullptr; 133 } 134 135 DWARFUnit::ScopedExtractDIEs &DWARFUnit::ScopedExtractDIEs::operator=( 136 DWARFUnit::ScopedExtractDIEs &&rhs) { 137 m_cu = rhs.m_cu; 138 rhs.m_cu = nullptr; 139 m_clear_dies = rhs.m_clear_dies; 140 return *this; 141 } 142 143 // Parses a compile unit and indexes its DIEs, m_die_array_mutex must be 144 // held R/W and m_die_array must be empty. 145 void DWARFUnit::ExtractDIEsRWLocked() { 146 llvm::sys::ScopedWriter first_die_lock(m_first_die_mutex); 147 148 static Timer::Category func_cat(LLVM_PRETTY_FUNCTION); 149 Timer scoped_timer(func_cat, "%8.8x: DWARFUnit::ExtractDIEsIfNeeded()", 150 GetOffset()); 151 152 // Set the offset to that of the first DIE and calculate the start of the 153 // next compilation unit header. 154 lldb::offset_t offset = GetFirstDIEOffset(); 155 lldb::offset_t next_cu_offset = GetNextUnitOffset(); 156 157 DWARFDebugInfoEntry die; 158 159 uint32_t depth = 0; 160 // We are in our compile unit, parse starting at the offset we were told to 161 // parse 162 const DWARFDataExtractor &data = GetData(); 163 std::vector<uint32_t> die_index_stack; 164 die_index_stack.reserve(32); 165 die_index_stack.push_back(0); 166 bool prev_die_had_children = false; 167 while (offset < next_cu_offset && die.Extract(data, this, &offset)) { 168 const bool null_die = die.IsNULL(); 169 if (depth == 0) { 170 assert(m_die_array.empty() && "Compile unit DIE already added"); 171 172 // The average bytes per DIE entry has been seen to be around 14-20 so 173 // lets pre-reserve half of that since we are now stripping the NULL 174 // tags. 175 176 // Only reserve the memory if we are adding children of the main 177 // compile unit DIE. The compile unit DIE is always the first entry, so 178 // if our size is 1, then we are adding the first compile unit child 179 // DIE and should reserve the memory. 180 m_die_array.reserve(GetDebugInfoSize() / 24); 181 m_die_array.push_back(die); 182 183 if (!m_first_die) 184 AddUnitDIE(m_die_array.front()); 185 186 // With -fsplit-dwarf-inlining, clang will emit non-empty skeleton compile 187 // units. We are not able to access these DIE *and* the dwo file 188 // simultaneously. We also don't need to do that as the dwo file will 189 // contain a superset of information. So, we don't even attempt to parse 190 // any remaining DIEs. 191 if (m_dwo) { 192 m_die_array.front().SetHasChildren(false); 193 break; 194 } 195 196 } else { 197 if (null_die) { 198 if (prev_die_had_children) { 199 // This will only happen if a DIE says is has children but all it 200 // contains is a NULL tag. Since we are removing the NULL DIEs from 201 // the list (saves up to 25% in C++ code), we need a way to let the 202 // DIE know that it actually doesn't have children. 203 if (!m_die_array.empty()) 204 m_die_array.back().SetHasChildren(false); 205 } 206 } else { 207 die.SetParentIndex(m_die_array.size() - die_index_stack[depth - 1]); 208 209 if (die_index_stack.back()) 210 m_die_array[die_index_stack.back()].SetSiblingIndex( 211 m_die_array.size() - die_index_stack.back()); 212 213 // Only push the DIE if it isn't a NULL DIE 214 m_die_array.push_back(die); 215 } 216 } 217 218 if (null_die) { 219 // NULL DIE. 220 if (!die_index_stack.empty()) 221 die_index_stack.pop_back(); 222 223 if (depth > 0) 224 --depth; 225 prev_die_had_children = false; 226 } else { 227 die_index_stack.back() = m_die_array.size() - 1; 228 // Normal DIE 229 const bool die_has_children = die.HasChildren(); 230 if (die_has_children) { 231 die_index_stack.push_back(0); 232 ++depth; 233 } 234 prev_die_had_children = die_has_children; 235 } 236 237 if (depth == 0) 238 break; // We are done with this compile unit! 239 } 240 241 if (!m_die_array.empty()) { 242 if (m_first_die) { 243 // Only needed for the assertion. 244 m_first_die.SetHasChildren(m_die_array.front().HasChildren()); 245 lldbassert(m_first_die == m_die_array.front()); 246 } 247 m_first_die = m_die_array.front(); 248 } 249 250 m_die_array.shrink_to_fit(); 251 252 if (m_dwo) 253 m_dwo->ExtractDIEsIfNeeded(); 254 } 255 256 // This is used when a split dwarf is enabled. 257 // A skeleton compilation unit may contain the DW_AT_str_offsets_base attribute 258 // that points to the first string offset of the CU contribution to the 259 // .debug_str_offsets. At the same time, the corresponding split debug unit also 260 // may use DW_FORM_strx* forms pointing to its own .debug_str_offsets.dwo and 261 // for that case, we should find the offset (skip the section header). 262 void DWARFUnit::SetDwoStrOffsetsBase() { 263 lldb::offset_t baseOffset = 0; 264 265 if (const llvm::DWARFUnitIndex::Entry *entry = m_header.GetIndexEntry()) { 266 if (const auto *contribution = 267 entry->getContribution(llvm::DW_SECT_STR_OFFSETS)) 268 baseOffset = contribution->Offset; 269 else 270 return; 271 } 272 273 if (GetVersion() >= 5) { 274 const DWARFDataExtractor &strOffsets = 275 GetSymbolFileDWARF().GetDWARFContext().getOrLoadStrOffsetsData(); 276 uint64_t length = strOffsets.GetU32(&baseOffset); 277 if (length == 0xffffffff) 278 length = strOffsets.GetU64(&baseOffset); 279 280 // Check version. 281 if (strOffsets.GetU16(&baseOffset) < 5) 282 return; 283 284 // Skip padding. 285 baseOffset += 2; 286 } 287 288 SetStrOffsetsBase(baseOffset); 289 } 290 291 // m_die_array_mutex must be already held as read/write. 292 void DWARFUnit::AddUnitDIE(const DWARFDebugInfoEntry &cu_die) { 293 llvm::Optional<uint64_t> addr_base, gnu_addr_base, ranges_base, 294 gnu_ranges_base; 295 296 DWARFAttributes attributes; 297 size_t num_attributes = cu_die.GetAttributes(this, attributes); 298 299 // Extract DW_AT_addr_base first, as other attributes may need it. 300 for (size_t i = 0; i < num_attributes; ++i) { 301 if (attributes.AttributeAtIndex(i) != DW_AT_addr_base) 302 continue; 303 DWARFFormValue form_value; 304 if (attributes.ExtractFormValueAtIndex(i, form_value)) { 305 addr_base = form_value.Unsigned(); 306 SetAddrBase(*addr_base); 307 break; 308 } 309 } 310 311 for (size_t i = 0; i < num_attributes; ++i) { 312 dw_attr_t attr = attributes.AttributeAtIndex(i); 313 DWARFFormValue form_value; 314 if (!attributes.ExtractFormValueAtIndex(i, form_value)) 315 continue; 316 switch (attr) { 317 case DW_AT_loclists_base: 318 SetLoclistsBase(form_value.Unsigned()); 319 break; 320 case DW_AT_rnglists_base: 321 ranges_base = form_value.Unsigned(); 322 SetRangesBase(*ranges_base); 323 break; 324 case DW_AT_str_offsets_base: 325 SetStrOffsetsBase(form_value.Unsigned()); 326 break; 327 case DW_AT_low_pc: 328 SetBaseAddress(form_value.Address()); 329 break; 330 case DW_AT_entry_pc: 331 // If the value was already set by DW_AT_low_pc, don't update it. 332 if (m_base_addr == LLDB_INVALID_ADDRESS) 333 SetBaseAddress(form_value.Address()); 334 break; 335 case DW_AT_stmt_list: 336 m_line_table_offset = form_value.Unsigned(); 337 break; 338 case DW_AT_GNU_addr_base: 339 gnu_addr_base = form_value.Unsigned(); 340 break; 341 case DW_AT_GNU_ranges_base: 342 gnu_ranges_base = form_value.Unsigned(); 343 break; 344 } 345 } 346 347 if (m_is_dwo) { 348 SetDwoStrOffsetsBase(); 349 return; 350 } 351 352 std::shared_ptr<SymbolFileDWARFDwo> dwo_symbol_file = 353 m_dwarf.GetDwoSymbolFileForCompileUnit(*this, cu_die); 354 if (!dwo_symbol_file) 355 return; 356 357 uint64_t main_dwo_id = 358 cu_die.GetAttributeValueAsUnsigned(this, DW_AT_GNU_dwo_id, 0); 359 DWARFUnit *dwo_cu = dwo_symbol_file->GetDWOCompileUnitForHash(main_dwo_id); 360 if (!dwo_cu) 361 return; // Can't fetch the compile unit from the dwo file. 362 dwo_cu->SetUserData(this); 363 364 DWARFBaseDIE dwo_cu_die = dwo_cu->GetUnitDIEOnly(); 365 if (!dwo_cu_die.IsValid()) 366 return; // Can't fetch the compile unit DIE from the dwo file. 367 368 // Here for DWO CU we want to use the address base set in the skeleton unit 369 // (DW_AT_addr_base) if it is available and use the DW_AT_GNU_addr_base 370 // otherwise. We do that because pre-DWARF v5 could use the DW_AT_GNU_* 371 // attributes which were applicable to the DWO units. The corresponding 372 // DW_AT_* attributes standardized in DWARF v5 are also applicable to the main 373 // unit in contrast. 374 if (addr_base) 375 dwo_cu->SetAddrBase(*addr_base); 376 else if (gnu_addr_base) 377 dwo_cu->SetAddrBase(*gnu_addr_base); 378 379 if (GetVersion() <= 4 && gnu_ranges_base) 380 dwo_cu->SetRangesBase(*gnu_ranges_base); 381 else if (dwo_symbol_file->GetDWARFContext() 382 .getOrLoadRngListsData() 383 .GetByteSize() > 0) 384 dwo_cu->SetRangesBase(llvm::DWARFListTableHeader::getHeaderSize(DWARF32)); 385 386 if (GetVersion() >= 5 && 387 dwo_symbol_file->GetDWARFContext().getOrLoadLocListsData().GetByteSize() > 388 0) 389 dwo_cu->SetLoclistsBase(llvm::DWARFListTableHeader::getHeaderSize(DWARF32)); 390 dwo_cu->SetBaseAddress(GetBaseAddress()); 391 392 m_dwo = std::shared_ptr<DWARFUnit>(std::move(dwo_symbol_file), dwo_cu); 393 } 394 395 DWARFDIE DWARFUnit::LookupAddress(const dw_addr_t address) { 396 if (DIE()) { 397 const DWARFDebugAranges &func_aranges = GetFunctionAranges(); 398 399 // Re-check the aranges auto pointer contents in case it was created above 400 if (!func_aranges.IsEmpty()) 401 return GetDIE(func_aranges.FindAddress(address)); 402 } 403 return DWARFDIE(); 404 } 405 406 size_t DWARFUnit::GetDebugInfoSize() const { 407 return GetLengthByteSize() + GetLength() - GetHeaderByteSize(); 408 } 409 410 const DWARFAbbreviationDeclarationSet *DWARFUnit::GetAbbreviations() const { 411 return m_abbrevs; 412 } 413 414 dw_offset_t DWARFUnit::GetAbbrevOffset() const { 415 return m_abbrevs ? m_abbrevs->GetOffset() : DW_INVALID_OFFSET; 416 } 417 418 dw_offset_t DWARFUnit::GetLineTableOffset() { 419 ExtractUnitDIEIfNeeded(); 420 return m_line_table_offset; 421 } 422 423 void DWARFUnit::SetAddrBase(dw_addr_t addr_base) { m_addr_base = addr_base; } 424 425 // Parse the rangelist table header, including the optional array of offsets 426 // following it (DWARF v5 and later). 427 template <typename ListTableType> 428 static llvm::Expected<ListTableType> 429 ParseListTableHeader(const llvm::DWARFDataExtractor &data, uint64_t offset, 430 DwarfFormat format) { 431 // We are expected to be called with Offset 0 or pointing just past the table 432 // header. Correct Offset in the latter case so that it points to the start 433 // of the header. 434 if (offset > 0) { 435 uint64_t HeaderSize = llvm::DWARFListTableHeader::getHeaderSize(format); 436 if (offset < HeaderSize) 437 return llvm::createStringError(errc::invalid_argument, 438 "did not detect a valid" 439 " list table with base = 0x%" PRIx64 "\n", 440 offset); 441 offset -= HeaderSize; 442 } 443 ListTableType Table; 444 if (llvm::Error E = Table.extractHeaderAndOffsets(data, &offset)) 445 return std::move(E); 446 return Table; 447 } 448 449 void DWARFUnit::SetLoclistsBase(dw_addr_t loclists_base) { 450 m_loclists_base = loclists_base; 451 452 uint64_t header_size = llvm::DWARFListTableHeader::getHeaderSize(DWARF32); 453 if (loclists_base < header_size) 454 return; 455 456 m_loclist_table_header.emplace(".debug_loclists", "locations"); 457 uint64_t offset = loclists_base - header_size; 458 if (llvm::Error E = m_loclist_table_header->extract( 459 m_dwarf.GetDWARFContext().getOrLoadLocListsData().GetAsLLVM(), 460 &offset)) { 461 GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError( 462 "Failed to extract location list table at offset 0x%" PRIx64 ": %s", 463 loclists_base, toString(std::move(E)).c_str()); 464 } 465 } 466 467 std::unique_ptr<llvm::DWARFLocationTable> 468 DWARFUnit::GetLocationTable(const DataExtractor &data) const { 469 llvm::DWARFDataExtractor llvm_data( 470 data.GetData(), data.GetByteOrder() == lldb::eByteOrderLittle, 471 data.GetAddressByteSize()); 472 473 if (m_is_dwo || GetVersion() >= 5) 474 return std::make_unique<llvm::DWARFDebugLoclists>(llvm_data, GetVersion()); 475 return std::make_unique<llvm::DWARFDebugLoc>(llvm_data); 476 } 477 478 DWARFDataExtractor DWARFUnit::GetLocationData() const { 479 DWARFContext &Ctx = GetSymbolFileDWARF().GetDWARFContext(); 480 const DWARFDataExtractor &data = 481 GetVersion() >= 5 ? Ctx.getOrLoadLocListsData() : Ctx.getOrLoadLocData(); 482 if (const llvm::DWARFUnitIndex::Entry *entry = m_header.GetIndexEntry()) { 483 if (const auto *contribution = entry->getContribution(llvm::DW_SECT_EXT_LOC)) 484 return DWARFDataExtractor(data, contribution->Offset, 485 contribution->Length); 486 return DWARFDataExtractor(); 487 } 488 return data; 489 } 490 491 void DWARFUnit::SetRangesBase(dw_addr_t ranges_base) { 492 m_ranges_base = ranges_base; 493 494 if (GetVersion() < 5) 495 return; 496 497 if (auto table_or_error = ParseListTableHeader<llvm::DWARFDebugRnglistTable>( 498 m_dwarf.GetDWARFContext().getOrLoadRngListsData().GetAsLLVM(), 499 ranges_base, DWARF32)) 500 m_rnglist_table = std::move(table_or_error.get()); 501 else 502 GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError( 503 "Failed to extract range list table at offset 0x%" PRIx64 ": %s", 504 ranges_base, toString(table_or_error.takeError()).c_str()); 505 } 506 507 void DWARFUnit::SetStrOffsetsBase(dw_offset_t str_offsets_base) { 508 m_str_offsets_base = str_offsets_base; 509 } 510 511 // It may be called only with m_die_array_mutex held R/W. 512 void DWARFUnit::ClearDIEsRWLocked() { 513 m_die_array.clear(); 514 m_die_array.shrink_to_fit(); 515 516 if (m_dwo) 517 m_dwo->ClearDIEsRWLocked(); 518 } 519 520 lldb::ByteOrder DWARFUnit::GetByteOrder() const { 521 return m_dwarf.GetObjectFile()->GetByteOrder(); 522 } 523 524 void DWARFUnit::SetBaseAddress(dw_addr_t base_addr) { m_base_addr = base_addr; } 525 526 // Compare function DWARFDebugAranges::Range structures 527 static bool CompareDIEOffset(const DWARFDebugInfoEntry &die, 528 const dw_offset_t die_offset) { 529 return die.GetOffset() < die_offset; 530 } 531 532 // GetDIE() 533 // 534 // Get the DIE (Debug Information Entry) with the specified offset by first 535 // checking if the DIE is contained within this compile unit and grabbing the 536 // DIE from this compile unit. Otherwise we grab the DIE from the DWARF file. 537 DWARFDIE 538 DWARFUnit::GetDIE(dw_offset_t die_offset) { 539 if (die_offset != DW_INVALID_OFFSET) { 540 if (ContainsDIEOffset(die_offset)) { 541 ExtractDIEsIfNeeded(); 542 DWARFDebugInfoEntry::const_iterator end = m_die_array.cend(); 543 DWARFDebugInfoEntry::const_iterator pos = 544 lower_bound(m_die_array.cbegin(), end, die_offset, CompareDIEOffset); 545 if (pos != end) { 546 if (die_offset == (*pos).GetOffset()) 547 return DWARFDIE(this, &(*pos)); 548 } 549 } else 550 GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError( 551 "GetDIE for DIE 0x%" PRIx32 " is outside of its CU 0x%" PRIx32, 552 die_offset, GetOffset()); 553 } 554 return DWARFDIE(); // Not found 555 } 556 557 DWARFUnit &DWARFUnit::GetNonSkeletonUnit() { 558 ExtractUnitDIEIfNeeded(); 559 if (m_dwo) 560 return *m_dwo; 561 return *this; 562 } 563 564 uint8_t DWARFUnit::GetAddressByteSize(const DWARFUnit *cu) { 565 if (cu) 566 return cu->GetAddressByteSize(); 567 return DWARFUnit::GetDefaultAddressSize(); 568 } 569 570 uint8_t DWARFUnit::GetDefaultAddressSize() { return 4; } 571 572 void *DWARFUnit::GetUserData() const { return m_user_data; } 573 574 void DWARFUnit::SetUserData(void *d) { m_user_data = d; } 575 576 bool DWARFUnit::Supports_DW_AT_APPLE_objc_complete_type() { 577 return GetProducer() != eProducerLLVMGCC; 578 } 579 580 bool DWARFUnit::DW_AT_decl_file_attributes_are_invalid() { 581 // llvm-gcc makes completely invalid decl file attributes and won't ever be 582 // fixed, so we need to know to ignore these. 583 return GetProducer() == eProducerLLVMGCC; 584 } 585 586 bool DWARFUnit::Supports_unnamed_objc_bitfields() { 587 if (GetProducer() == eProducerClang) { 588 const uint32_t major_version = GetProducerVersionMajor(); 589 return major_version > 425 || 590 (major_version == 425 && GetProducerVersionUpdate() >= 13); 591 } 592 return true; // Assume all other compilers didn't have incorrect ObjC bitfield 593 // info 594 } 595 596 void DWARFUnit::ParseProducerInfo() { 597 m_producer_version_major = UINT32_MAX; 598 m_producer_version_minor = UINT32_MAX; 599 m_producer_version_update = UINT32_MAX; 600 601 const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly(); 602 if (die) { 603 604 const char *producer_cstr = 605 die->GetAttributeValueAsString(this, DW_AT_producer, nullptr); 606 if (producer_cstr) { 607 RegularExpression llvm_gcc_regex( 608 llvm::StringRef("^4\\.[012]\\.[01] \\(Based on Apple " 609 "Inc\\. build [0-9]+\\) \\(LLVM build " 610 "[\\.0-9]+\\)$")); 611 if (llvm_gcc_regex.Execute(llvm::StringRef(producer_cstr))) { 612 m_producer = eProducerLLVMGCC; 613 } else if (strstr(producer_cstr, "clang")) { 614 static RegularExpression g_clang_version_regex( 615 llvm::StringRef("clang-([0-9]+)\\.([0-9]+)\\.([0-9]+)")); 616 llvm::SmallVector<llvm::StringRef, 4> matches; 617 if (g_clang_version_regex.Execute(llvm::StringRef(producer_cstr), 618 &matches)) { 619 m_producer_version_major = 620 StringConvert::ToUInt32(matches[1].str().c_str(), UINT32_MAX, 10); 621 m_producer_version_minor = 622 StringConvert::ToUInt32(matches[2].str().c_str(), UINT32_MAX, 10); 623 m_producer_version_update = 624 StringConvert::ToUInt32(matches[3].str().c_str(), UINT32_MAX, 10); 625 } 626 m_producer = eProducerClang; 627 } else if (strstr(producer_cstr, "GNU")) 628 m_producer = eProducerGCC; 629 } 630 } 631 if (m_producer == eProducerInvalid) 632 m_producer = eProcucerOther; 633 } 634 635 DWARFProducer DWARFUnit::GetProducer() { 636 if (m_producer == eProducerInvalid) 637 ParseProducerInfo(); 638 return m_producer; 639 } 640 641 uint32_t DWARFUnit::GetProducerVersionMajor() { 642 if (m_producer_version_major == 0) 643 ParseProducerInfo(); 644 return m_producer_version_major; 645 } 646 647 uint32_t DWARFUnit::GetProducerVersionMinor() { 648 if (m_producer_version_minor == 0) 649 ParseProducerInfo(); 650 return m_producer_version_minor; 651 } 652 653 uint32_t DWARFUnit::GetProducerVersionUpdate() { 654 if (m_producer_version_update == 0) 655 ParseProducerInfo(); 656 return m_producer_version_update; 657 } 658 659 uint64_t DWARFUnit::GetDWARFLanguageType() { 660 if (m_language_type) 661 return *m_language_type; 662 663 const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly(); 664 if (!die) 665 m_language_type = 0; 666 else 667 m_language_type = die->GetAttributeValueAsUnsigned(this, DW_AT_language, 0); 668 return *m_language_type; 669 } 670 671 bool DWARFUnit::GetIsOptimized() { 672 if (m_is_optimized == eLazyBoolCalculate) { 673 const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly(); 674 if (die) { 675 m_is_optimized = eLazyBoolNo; 676 if (die->GetAttributeValueAsUnsigned(this, DW_AT_APPLE_optimized, 0) == 677 1) { 678 m_is_optimized = eLazyBoolYes; 679 } 680 } 681 } 682 return m_is_optimized == eLazyBoolYes; 683 } 684 685 FileSpec::Style DWARFUnit::GetPathStyle() { 686 if (!m_comp_dir) 687 ComputeCompDirAndGuessPathStyle(); 688 return m_comp_dir->GetPathStyle(); 689 } 690 691 const FileSpec &DWARFUnit::GetCompilationDirectory() { 692 if (!m_comp_dir) 693 ComputeCompDirAndGuessPathStyle(); 694 return *m_comp_dir; 695 } 696 697 const FileSpec &DWARFUnit::GetAbsolutePath() { 698 if (!m_file_spec) 699 ComputeAbsolutePath(); 700 return *m_file_spec; 701 } 702 703 FileSpec DWARFUnit::GetFile(size_t file_idx) { 704 return m_dwarf.GetFile(*this, file_idx); 705 } 706 707 // DWARF2/3 suggests the form hostname:pathname for compilation directory. 708 // Remove the host part if present. 709 static llvm::StringRef 710 removeHostnameFromPathname(llvm::StringRef path_from_dwarf) { 711 if (!path_from_dwarf.contains(':')) 712 return path_from_dwarf; 713 llvm::StringRef host, path; 714 std::tie(host, path) = path_from_dwarf.split(':'); 715 716 if (host.contains('/')) 717 return path_from_dwarf; 718 719 // check whether we have a windows path, and so the first character is a 720 // drive-letter not a hostname. 721 if (host.size() == 1 && llvm::isAlpha(host[0]) && path.startswith("\\")) 722 return path_from_dwarf; 723 724 return path; 725 } 726 727 void DWARFUnit::ComputeCompDirAndGuessPathStyle() { 728 m_comp_dir = FileSpec(); 729 const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly(); 730 if (!die) 731 return; 732 733 llvm::StringRef comp_dir = removeHostnameFromPathname( 734 die->GetAttributeValueAsString(this, DW_AT_comp_dir, nullptr)); 735 if (!comp_dir.empty()) { 736 FileSpec::Style comp_dir_style = 737 FileSpec::GuessPathStyle(comp_dir).getValueOr(FileSpec::Style::native); 738 m_comp_dir = FileSpec(comp_dir, comp_dir_style); 739 } else { 740 // Try to detect the style based on the DW_AT_name attribute, but just store 741 // the detected style in the m_comp_dir field. 742 const char *name = 743 die->GetAttributeValueAsString(this, DW_AT_name, nullptr); 744 m_comp_dir = FileSpec( 745 "", FileSpec::GuessPathStyle(name).getValueOr(FileSpec::Style::native)); 746 } 747 } 748 749 void DWARFUnit::ComputeAbsolutePath() { 750 m_file_spec = FileSpec(); 751 const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly(); 752 if (!die) 753 return; 754 755 m_file_spec = 756 FileSpec(die->GetAttributeValueAsString(this, DW_AT_name, nullptr), 757 GetPathStyle()); 758 759 if (m_file_spec->IsRelative()) 760 m_file_spec->MakeAbsolute(GetCompilationDirectory()); 761 } 762 763 SymbolFileDWARFDwo *DWARFUnit::GetDwoSymbolFile() { 764 ExtractUnitDIEIfNeeded(); 765 if (m_dwo) 766 return &llvm::cast<SymbolFileDWARFDwo>(m_dwo->GetSymbolFileDWARF()); 767 return nullptr; 768 } 769 770 const DWARFDebugAranges &DWARFUnit::GetFunctionAranges() { 771 if (m_func_aranges_up == nullptr) { 772 m_func_aranges_up = std::make_unique<DWARFDebugAranges>(); 773 const DWARFDebugInfoEntry *die = DIEPtr(); 774 if (die) 775 die->BuildFunctionAddressRangeTable(this, m_func_aranges_up.get()); 776 777 if (m_dwo) { 778 const DWARFDebugInfoEntry *dwo_die = m_dwo->DIEPtr(); 779 if (dwo_die) 780 dwo_die->BuildFunctionAddressRangeTable(m_dwo.get(), 781 m_func_aranges_up.get()); 782 } 783 784 const bool minimize = false; 785 m_func_aranges_up->Sort(minimize); 786 } 787 return *m_func_aranges_up; 788 } 789 790 llvm::Expected<DWARFUnitHeader> 791 DWARFUnitHeader::extract(const DWARFDataExtractor &data, 792 DIERef::Section section, lldb::offset_t *offset_ptr, 793 const llvm::DWARFUnitIndex *index) { 794 DWARFUnitHeader header; 795 header.m_offset = *offset_ptr; 796 if (index) 797 header.m_index_entry = index->getFromOffset(*offset_ptr); 798 header.m_length = data.GetDWARFInitialLength(offset_ptr); 799 header.m_version = data.GetU16(offset_ptr); 800 if (header.m_version == 5) { 801 header.m_unit_type = data.GetU8(offset_ptr); 802 header.m_addr_size = data.GetU8(offset_ptr); 803 header.m_abbr_offset = data.GetDWARFOffset(offset_ptr); 804 if (header.m_unit_type == llvm::dwarf::DW_UT_skeleton) 805 header.m_dwo_id = data.GetU64(offset_ptr); 806 } else { 807 header.m_abbr_offset = data.GetDWARFOffset(offset_ptr); 808 header.m_addr_size = data.GetU8(offset_ptr); 809 header.m_unit_type = 810 section == DIERef::Section::DebugTypes ? DW_UT_type : DW_UT_compile; 811 } 812 813 if (header.m_index_entry) { 814 if (header.m_abbr_offset) { 815 return llvm::createStringError( 816 llvm::inconvertibleErrorCode(), 817 "Package unit with a non-zero abbreviation offset"); 818 } 819 auto *unit_contrib = header.m_index_entry->getContribution(); 820 if (!unit_contrib || unit_contrib->Length != header.m_length + 4) { 821 return llvm::createStringError(llvm::inconvertibleErrorCode(), 822 "Inconsistent DWARF package unit index"); 823 } 824 auto *abbr_entry = 825 header.m_index_entry->getContribution(llvm::DW_SECT_ABBREV); 826 if (!abbr_entry) { 827 return llvm::createStringError( 828 llvm::inconvertibleErrorCode(), 829 "DWARF package index missing abbreviation column"); 830 } 831 header.m_abbr_offset = abbr_entry->Offset; 832 } 833 if (header.IsTypeUnit()) { 834 header.m_type_hash = data.GetU64(offset_ptr); 835 header.m_type_offset = data.GetDWARFOffset(offset_ptr); 836 } 837 838 bool length_OK = data.ValidOffset(header.GetNextUnitOffset() - 1); 839 bool version_OK = SymbolFileDWARF::SupportedVersion(header.m_version); 840 bool addr_size_OK = (header.m_addr_size == 4) || (header.m_addr_size == 8); 841 bool type_offset_OK = 842 !header.IsTypeUnit() || (header.m_type_offset <= header.GetLength()); 843 844 if (!length_OK) 845 return llvm::make_error<llvm::object::GenericBinaryError>( 846 "Invalid unit length"); 847 if (!version_OK) 848 return llvm::make_error<llvm::object::GenericBinaryError>( 849 "Unsupported unit version"); 850 if (!addr_size_OK) 851 return llvm::make_error<llvm::object::GenericBinaryError>( 852 "Invalid unit address size"); 853 if (!type_offset_OK) 854 return llvm::make_error<llvm::object::GenericBinaryError>( 855 "Type offset out of range"); 856 857 return header; 858 } 859 860 llvm::Expected<DWARFUnitSP> 861 DWARFUnit::extract(SymbolFileDWARF &dwarf, user_id_t uid, 862 const DWARFDataExtractor &debug_info, 863 DIERef::Section section, lldb::offset_t *offset_ptr, 864 const llvm::DWARFUnitIndex *index) { 865 assert(debug_info.ValidOffset(*offset_ptr)); 866 867 auto expected_header = 868 DWARFUnitHeader::extract(debug_info, section, offset_ptr, index); 869 if (!expected_header) 870 return expected_header.takeError(); 871 872 const DWARFDebugAbbrev *abbr = dwarf.DebugAbbrev(); 873 if (!abbr) 874 return llvm::make_error<llvm::object::GenericBinaryError>( 875 "No debug_abbrev data"); 876 877 bool abbr_offset_OK = 878 dwarf.GetDWARFContext().getOrLoadAbbrevData().ValidOffset( 879 expected_header->GetAbbrOffset()); 880 if (!abbr_offset_OK) 881 return llvm::make_error<llvm::object::GenericBinaryError>( 882 "Abbreviation offset for unit is not valid"); 883 884 const DWARFAbbreviationDeclarationSet *abbrevs = 885 abbr->GetAbbreviationDeclarationSet(expected_header->GetAbbrOffset()); 886 if (!abbrevs) 887 return llvm::make_error<llvm::object::GenericBinaryError>( 888 "No abbrev exists at the specified offset."); 889 890 bool is_dwo = dwarf.GetDWARFContext().isDwo(); 891 if (expected_header->IsTypeUnit()) 892 return DWARFUnitSP(new DWARFTypeUnit(dwarf, uid, *expected_header, *abbrevs, 893 section, is_dwo)); 894 return DWARFUnitSP(new DWARFCompileUnit(dwarf, uid, *expected_header, 895 *abbrevs, section, is_dwo)); 896 } 897 898 const lldb_private::DWARFDataExtractor &DWARFUnit::GetData() const { 899 return m_section == DIERef::Section::DebugTypes 900 ? m_dwarf.GetDWARFContext().getOrLoadDebugTypesData() 901 : m_dwarf.GetDWARFContext().getOrLoadDebugInfoData(); 902 } 903 904 uint32_t DWARFUnit::GetHeaderByteSize() const { 905 switch (m_header.GetUnitType()) { 906 case llvm::dwarf::DW_UT_compile: 907 case llvm::dwarf::DW_UT_partial: 908 return GetVersion() < 5 ? 11 : 12; 909 case llvm::dwarf::DW_UT_skeleton: 910 case llvm::dwarf::DW_UT_split_compile: 911 return 20; 912 case llvm::dwarf::DW_UT_type: 913 case llvm::dwarf::DW_UT_split_type: 914 return GetVersion() < 5 ? 23 : 24; 915 } 916 llvm_unreachable("invalid UnitType."); 917 } 918 919 llvm::Optional<uint64_t> 920 DWARFUnit::GetStringOffsetSectionItem(uint32_t index) const { 921 offset_t offset = GetStrOffsetsBase() + index * 4; 922 return m_dwarf.GetDWARFContext().getOrLoadStrOffsetsData().GetU32(&offset); 923 } 924 925 llvm::Expected<DWARFRangeList> 926 DWARFUnit::FindRnglistFromOffset(dw_offset_t offset) { 927 if (GetVersion() <= 4) { 928 const DWARFDebugRanges *debug_ranges = m_dwarf.GetDebugRanges(); 929 if (!debug_ranges) 930 return llvm::make_error<llvm::object::GenericBinaryError>( 931 "No debug_ranges section"); 932 DWARFRangeList ranges; 933 debug_ranges->FindRanges(this, offset, ranges); 934 return ranges; 935 } 936 937 if (!m_rnglist_table) 938 return llvm::createStringError(errc::invalid_argument, 939 "missing or invalid range list table"); 940 941 auto range_list_or_error = m_rnglist_table->findList( 942 m_dwarf.GetDWARFContext().getOrLoadRngListsData().GetAsLLVM(), offset); 943 if (!range_list_or_error) 944 return range_list_or_error.takeError(); 945 946 llvm::Expected<llvm::DWARFAddressRangesVector> llvm_ranges = 947 range_list_or_error->getAbsoluteRanges( 948 llvm::object::SectionedAddress{GetBaseAddress()}, 949 [&](uint32_t index) { 950 uint32_t index_size = GetAddressByteSize(); 951 dw_offset_t addr_base = GetAddrBase(); 952 lldb::offset_t offset = addr_base + index * index_size; 953 return llvm::object::SectionedAddress{ 954 m_dwarf.GetDWARFContext().getOrLoadAddrData().GetMaxU64( 955 &offset, index_size)}; 956 }); 957 if (!llvm_ranges) 958 return llvm_ranges.takeError(); 959 960 DWARFRangeList ranges; 961 for (const llvm::DWARFAddressRange &llvm_range : *llvm_ranges) { 962 ranges.Append(DWARFRangeList::Entry(llvm_range.LowPC, 963 llvm_range.HighPC - llvm_range.LowPC)); 964 } 965 return ranges; 966 } 967 968 llvm::Expected<DWARFRangeList> 969 DWARFUnit::FindRnglistFromIndex(uint32_t index) { 970 if (llvm::Optional<uint64_t> offset = GetRnglistOffset(index)) 971 return FindRnglistFromOffset(*offset); 972 if (m_rnglist_table) 973 return llvm::createStringError(errc::invalid_argument, 974 "invalid range list table index %d", index); 975 976 return llvm::createStringError(errc::invalid_argument, 977 "missing or invalid range list table"); 978 } 979