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 "llvm/DebugInfo/DWARF/DWARFUnit.h" 10 #include "llvm/ADT/SmallString.h" 11 #include "llvm/ADT/StringRef.h" 12 #include "llvm/BinaryFormat/Dwarf.h" 13 #include "llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h" 14 #include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h" 15 #include "llvm/DebugInfo/DWARF/DWARFContext.h" 16 #include "llvm/DebugInfo/DWARF/DWARFDebugAbbrev.h" 17 #include "llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h" 18 #include "llvm/DebugInfo/DWARF/DWARFDebugLoc.h" 19 #include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h" 20 #include "llvm/DebugInfo/DWARF/DWARFDebugRnglists.h" 21 #include "llvm/DebugInfo/DWARF/DWARFDie.h" 22 #include "llvm/DebugInfo/DWARF/DWARFExpression.h" 23 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h" 24 #include "llvm/DebugInfo/DWARF/DWARFListTable.h" 25 #include "llvm/DebugInfo/DWARF/DWARFObject.h" 26 #include "llvm/DebugInfo/DWARF/DWARFSection.h" 27 #include "llvm/DebugInfo/DWARF/DWARFTypeUnit.h" 28 #include "llvm/Object/ObjectFile.h" 29 #include "llvm/Support/DataExtractor.h" 30 #include "llvm/Support/Errc.h" 31 #include "llvm/Support/Path.h" 32 #include <algorithm> 33 #include <cassert> 34 #include <cstddef> 35 #include <cstdint> 36 #include <utility> 37 #include <vector> 38 39 using namespace llvm; 40 using namespace dwarf; 41 42 void DWARFUnitVector::addUnitsForSection(DWARFContext &C, 43 const DWARFSection &Section, 44 DWARFSectionKind SectionKind) { 45 const DWARFObject &D = C.getDWARFObj(); 46 addUnitsImpl(C, D, Section, C.getDebugAbbrev(), &D.getRangesSection(), 47 &D.getLocSection(), D.getStrSection(), 48 D.getStrOffsetsSection(), &D.getAddrSection(), 49 D.getLineSection(), D.isLittleEndian(), false, false, 50 SectionKind); 51 } 52 53 void DWARFUnitVector::addUnitsForDWOSection(DWARFContext &C, 54 const DWARFSection &DWOSection, 55 DWARFSectionKind SectionKind, 56 bool Lazy) { 57 const DWARFObject &D = C.getDWARFObj(); 58 addUnitsImpl(C, D, DWOSection, C.getDebugAbbrevDWO(), &D.getRangesDWOSection(), 59 &D.getLocDWOSection(), D.getStrDWOSection(), 60 D.getStrOffsetsDWOSection(), &D.getAddrSection(), 61 D.getLineDWOSection(), C.isLittleEndian(), true, Lazy, 62 SectionKind); 63 } 64 65 void DWARFUnitVector::addUnitsImpl( 66 DWARFContext &Context, const DWARFObject &Obj, const DWARFSection &Section, 67 const DWARFDebugAbbrev *DA, const DWARFSection *RS, 68 const DWARFSection *LocSection, StringRef SS, const DWARFSection &SOS, 69 const DWARFSection *AOS, const DWARFSection &LS, bool LE, bool IsDWO, 70 bool Lazy, DWARFSectionKind SectionKind) { 71 DWARFDataExtractor Data(Obj, Section, LE, 0); 72 // Lazy initialization of Parser, now that we have all section info. 73 if (!Parser) { 74 Parser = [=, &Context, &Obj, &Section, &SOS, 75 &LS](uint64_t Offset, DWARFSectionKind SectionKind, 76 const DWARFSection *CurSection, 77 const DWARFUnitIndex::Entry *IndexEntry) 78 -> std::unique_ptr<DWARFUnit> { 79 const DWARFSection &InfoSection = CurSection ? *CurSection : Section; 80 DWARFDataExtractor Data(Obj, InfoSection, LE, 0); 81 if (!Data.isValidOffset(Offset)) 82 return nullptr; 83 DWARFUnitHeader Header; 84 if (Error ExtractErr = 85 Header.extract(Context, Data, &Offset, SectionKind)) { 86 Context.getWarningHandler()(std::move(ExtractErr)); 87 return nullptr; 88 } 89 if (!IndexEntry && IsDWO) { 90 const DWARFUnitIndex &Index = getDWARFUnitIndex( 91 Context, Header.isTypeUnit() ? DW_SECT_EXT_TYPES : DW_SECT_INFO); 92 if (Index) { 93 if (Header.isTypeUnit()) 94 IndexEntry = Index.getFromHash(Header.getTypeHash()); 95 else if (auto DWOId = Header.getDWOId()) 96 IndexEntry = Index.getFromHash(*DWOId); 97 } 98 if (!IndexEntry) 99 IndexEntry = Index.getFromOffset(Header.getOffset()); 100 } 101 if (IndexEntry && !Header.applyIndexEntry(IndexEntry)) 102 return nullptr; 103 std::unique_ptr<DWARFUnit> U; 104 if (Header.isTypeUnit()) 105 U = std::make_unique<DWARFTypeUnit>(Context, InfoSection, Header, DA, 106 RS, LocSection, SS, SOS, AOS, LS, 107 LE, IsDWO, *this); 108 else 109 U = std::make_unique<DWARFCompileUnit>(Context, InfoSection, Header, 110 DA, RS, LocSection, SS, SOS, 111 AOS, LS, LE, IsDWO, *this); 112 return U; 113 }; 114 } 115 if (Lazy) 116 return; 117 // Find a reasonable insertion point within the vector. We skip over 118 // (a) units from a different section, (b) units from the same section 119 // but with lower offset-within-section. This keeps units in order 120 // within a section, although not necessarily within the object file, 121 // even if we do lazy parsing. 122 auto I = this->begin(); 123 uint64_t Offset = 0; 124 while (Data.isValidOffset(Offset)) { 125 if (I != this->end() && 126 (&(*I)->getInfoSection() != &Section || (*I)->getOffset() == Offset)) { 127 ++I; 128 continue; 129 } 130 auto U = Parser(Offset, SectionKind, &Section, nullptr); 131 // If parsing failed, we're done with this section. 132 if (!U) 133 break; 134 Offset = U->getNextUnitOffset(); 135 I = std::next(this->insert(I, std::move(U))); 136 } 137 } 138 139 DWARFUnit *DWARFUnitVector::addUnit(std::unique_ptr<DWARFUnit> Unit) { 140 auto I = llvm::upper_bound(*this, Unit, 141 [](const std::unique_ptr<DWARFUnit> &LHS, 142 const std::unique_ptr<DWARFUnit> &RHS) { 143 return LHS->getOffset() < RHS->getOffset(); 144 }); 145 return this->insert(I, std::move(Unit))->get(); 146 } 147 148 DWARFUnit *DWARFUnitVector::getUnitForOffset(uint64_t Offset) const { 149 auto end = begin() + getNumInfoUnits(); 150 auto *CU = 151 std::upper_bound(begin(), end, Offset, 152 [](uint64_t LHS, const std::unique_ptr<DWARFUnit> &RHS) { 153 return LHS < RHS->getNextUnitOffset(); 154 }); 155 if (CU != end && (*CU)->getOffset() <= Offset) 156 return CU->get(); 157 return nullptr; 158 } 159 160 DWARFUnit * 161 DWARFUnitVector::getUnitForIndexEntry(const DWARFUnitIndex::Entry &E) { 162 const auto *CUOff = E.getContribution(DW_SECT_INFO); 163 if (!CUOff) 164 return nullptr; 165 166 uint64_t Offset = CUOff->getOffset(); 167 auto end = begin() + getNumInfoUnits(); 168 169 auto *CU = 170 std::upper_bound(begin(), end, CUOff->getOffset(), 171 [](uint64_t LHS, const std::unique_ptr<DWARFUnit> &RHS) { 172 return LHS < RHS->getNextUnitOffset(); 173 }); 174 if (CU != end && (*CU)->getOffset() <= Offset) 175 return CU->get(); 176 177 if (!Parser) 178 return nullptr; 179 180 auto U = Parser(Offset, DW_SECT_INFO, nullptr, &E); 181 if (!U) 182 return nullptr; 183 184 auto *NewCU = U.get(); 185 this->insert(CU, std::move(U)); 186 ++NumInfoUnits; 187 return NewCU; 188 } 189 190 DWARFUnit::DWARFUnit(DWARFContext &DC, const DWARFSection &Section, 191 const DWARFUnitHeader &Header, const DWARFDebugAbbrev *DA, 192 const DWARFSection *RS, const DWARFSection *LocSection, 193 StringRef SS, const DWARFSection &SOS, 194 const DWARFSection *AOS, const DWARFSection &LS, bool LE, 195 bool IsDWO, const DWARFUnitVector &UnitVector) 196 : Context(DC), InfoSection(Section), Header(Header), Abbrev(DA), 197 RangeSection(RS), LineSection(LS), StringSection(SS), 198 StringOffsetSection(SOS), AddrOffsetSection(AOS), IsLittleEndian(LE), 199 IsDWO(IsDWO), UnitVector(UnitVector) { 200 clear(); 201 } 202 203 DWARFUnit::~DWARFUnit() = default; 204 205 DWARFDataExtractor DWARFUnit::getDebugInfoExtractor() const { 206 return DWARFDataExtractor(Context.getDWARFObj(), InfoSection, IsLittleEndian, 207 getAddressByteSize()); 208 } 209 210 std::optional<object::SectionedAddress> 211 DWARFUnit::getAddrOffsetSectionItem(uint32_t Index) const { 212 if (!AddrOffsetSectionBase) { 213 auto R = Context.info_section_units(); 214 // Surprising if a DWO file has more than one skeleton unit in it - this 215 // probably shouldn't be valid, but if a use case is found, here's where to 216 // support it (probably have to linearly search for the matching skeleton CU 217 // here) 218 if (IsDWO && hasSingleElement(R)) 219 return (*R.begin())->getAddrOffsetSectionItem(Index); 220 221 return std::nullopt; 222 } 223 224 uint64_t Offset = *AddrOffsetSectionBase + Index * getAddressByteSize(); 225 if (AddrOffsetSection->Data.size() < Offset + getAddressByteSize()) 226 return std::nullopt; 227 DWARFDataExtractor DA(Context.getDWARFObj(), *AddrOffsetSection, 228 IsLittleEndian, getAddressByteSize()); 229 uint64_t Section; 230 uint64_t Address = DA.getRelocatedAddress(&Offset, &Section); 231 return {{Address, Section}}; 232 } 233 234 Expected<uint64_t> DWARFUnit::getStringOffsetSectionItem(uint32_t Index) const { 235 if (!StringOffsetsTableContribution) 236 return make_error<StringError>( 237 "DW_FORM_strx used without a valid string offsets table", 238 inconvertibleErrorCode()); 239 unsigned ItemSize = getDwarfStringOffsetsByteSize(); 240 uint64_t Offset = getStringOffsetsBase() + Index * ItemSize; 241 if (StringOffsetSection.Data.size() < Offset + ItemSize) 242 return make_error<StringError>("DW_FORM_strx uses index " + Twine(Index) + 243 ", which is too large", 244 inconvertibleErrorCode()); 245 DWARFDataExtractor DA(Context.getDWARFObj(), StringOffsetSection, 246 IsLittleEndian, 0); 247 return DA.getRelocatedValue(ItemSize, &Offset); 248 } 249 250 Error DWARFUnitHeader::extract(DWARFContext &Context, 251 const DWARFDataExtractor &debug_info, 252 uint64_t *offset_ptr, 253 DWARFSectionKind SectionKind) { 254 Offset = *offset_ptr; 255 Error Err = Error::success(); 256 IndexEntry = nullptr; 257 std::tie(Length, FormParams.Format) = 258 debug_info.getInitialLength(offset_ptr, &Err); 259 FormParams.Version = debug_info.getU16(offset_ptr, &Err); 260 if (FormParams.Version >= 5) { 261 UnitType = debug_info.getU8(offset_ptr, &Err); 262 FormParams.AddrSize = debug_info.getU8(offset_ptr, &Err); 263 AbbrOffset = debug_info.getRelocatedValue( 264 FormParams.getDwarfOffsetByteSize(), offset_ptr, nullptr, &Err); 265 } else { 266 AbbrOffset = debug_info.getRelocatedValue( 267 FormParams.getDwarfOffsetByteSize(), offset_ptr, nullptr, &Err); 268 FormParams.AddrSize = debug_info.getU8(offset_ptr, &Err); 269 // Fake a unit type based on the section type. This isn't perfect, 270 // but distinguishing compile and type units is generally enough. 271 if (SectionKind == DW_SECT_EXT_TYPES) 272 UnitType = DW_UT_type; 273 else 274 UnitType = DW_UT_compile; 275 } 276 if (isTypeUnit()) { 277 TypeHash = debug_info.getU64(offset_ptr, &Err); 278 TypeOffset = debug_info.getUnsigned( 279 offset_ptr, FormParams.getDwarfOffsetByteSize(), &Err); 280 } else if (UnitType == DW_UT_split_compile || UnitType == DW_UT_skeleton) 281 DWOId = debug_info.getU64(offset_ptr, &Err); 282 283 if (Err) 284 return joinErrors( 285 createStringError( 286 errc::invalid_argument, 287 "DWARF unit at 0x%8.8" PRIx64 " cannot be parsed:", Offset), 288 std::move(Err)); 289 290 // Header fields all parsed, capture the size of this unit header. 291 assert(*offset_ptr - Offset <= 255 && "unexpected header size"); 292 Size = uint8_t(*offset_ptr - Offset); 293 uint64_t NextCUOffset = Offset + getUnitLengthFieldByteSize() + getLength(); 294 295 if (!debug_info.isValidOffset(getNextUnitOffset() - 1)) 296 return createStringError(errc::invalid_argument, 297 "DWARF unit from offset 0x%8.8" PRIx64 " incl. " 298 "to offset 0x%8.8" PRIx64 " excl. " 299 "extends past section size 0x%8.8zx", 300 Offset, NextCUOffset, debug_info.size()); 301 302 if (!DWARFContext::isSupportedVersion(getVersion())) 303 return createStringError( 304 errc::invalid_argument, 305 "DWARF unit at offset 0x%8.8" PRIx64 " " 306 "has unsupported version %" PRIu16 ", supported are 2-%u", 307 Offset, getVersion(), DWARFContext::getMaxSupportedVersion()); 308 309 // Type offset is unit-relative; should be after the header and before 310 // the end of the current unit. 311 if (isTypeUnit() && TypeOffset < Size) 312 return createStringError(errc::invalid_argument, 313 "DWARF type unit at offset " 314 "0x%8.8" PRIx64 " " 315 "has its relocated type_offset 0x%8.8" PRIx64 " " 316 "pointing inside the header", 317 Offset, Offset + TypeOffset); 318 319 if (isTypeUnit() && TypeOffset >= getUnitLengthFieldByteSize() + getLength()) 320 return createStringError( 321 errc::invalid_argument, 322 "DWARF type unit from offset 0x%8.8" PRIx64 " incl. " 323 "to offset 0x%8.8" PRIx64 " excl. has its " 324 "relocated type_offset 0x%8.8" PRIx64 " pointing past the unit end", 325 Offset, NextCUOffset, Offset + TypeOffset); 326 327 if (Error SizeErr = DWARFContext::checkAddressSizeSupported( 328 getAddressByteSize(), errc::invalid_argument, 329 "DWARF unit at offset 0x%8.8" PRIx64, Offset)) 330 return SizeErr; 331 332 // Keep track of the highest DWARF version we encounter across all units. 333 Context.setMaxVersionIfGreater(getVersion()); 334 return Error::success(); 335 } 336 337 bool DWARFUnitHeader::applyIndexEntry(const DWARFUnitIndex::Entry *Entry) { 338 assert(Entry); 339 assert(!IndexEntry); 340 IndexEntry = Entry; 341 if (AbbrOffset) 342 return false; 343 auto *UnitContrib = IndexEntry->getContribution(); 344 if (!UnitContrib || 345 UnitContrib->getLength() != (getLength() + getUnitLengthFieldByteSize())) 346 return false; 347 auto *AbbrEntry = IndexEntry->getContribution(DW_SECT_ABBREV); 348 if (!AbbrEntry) 349 return false; 350 AbbrOffset = AbbrEntry->getOffset(); 351 return true; 352 } 353 354 Error DWARFUnit::extractRangeList(uint64_t RangeListOffset, 355 DWARFDebugRangeList &RangeList) const { 356 // Require that compile unit is extracted. 357 assert(!DieArray.empty()); 358 DWARFDataExtractor RangesData(Context.getDWARFObj(), *RangeSection, 359 IsLittleEndian, getAddressByteSize()); 360 uint64_t ActualRangeListOffset = RangeSectionBase + RangeListOffset; 361 return RangeList.extract(RangesData, &ActualRangeListOffset); 362 } 363 364 void DWARFUnit::clear() { 365 Abbrevs = nullptr; 366 BaseAddr.reset(); 367 RangeSectionBase = 0; 368 LocSectionBase = 0; 369 AddrOffsetSectionBase = std::nullopt; 370 SU = nullptr; 371 clearDIEs(false); 372 AddrDieMap.clear(); 373 if (DWO) 374 DWO->clear(); 375 DWO.reset(); 376 } 377 378 const char *DWARFUnit::getCompilationDir() { 379 return dwarf::toString(getUnitDIE().find(DW_AT_comp_dir), nullptr); 380 } 381 382 void DWARFUnit::extractDIEsToVector( 383 bool AppendCUDie, bool AppendNonCUDies, 384 std::vector<DWARFDebugInfoEntry> &Dies) const { 385 if (!AppendCUDie && !AppendNonCUDies) 386 return; 387 388 // Set the offset to that of the first DIE and calculate the start of the 389 // next compilation unit header. 390 uint64_t DIEOffset = getOffset() + getHeaderSize(); 391 uint64_t NextCUOffset = getNextUnitOffset(); 392 DWARFDebugInfoEntry DIE; 393 DWARFDataExtractor DebugInfoData = getDebugInfoExtractor(); 394 // The end offset has been already checked by DWARFUnitHeader::extract. 395 assert(DebugInfoData.isValidOffset(NextCUOffset - 1)); 396 std::vector<uint32_t> Parents; 397 std::vector<uint32_t> PrevSiblings; 398 bool IsCUDie = true; 399 400 assert( 401 ((AppendCUDie && Dies.empty()) || (!AppendCUDie && Dies.size() == 1)) && 402 "Dies array is not empty"); 403 404 // Fill Parents and Siblings stacks with initial value. 405 Parents.push_back(UINT32_MAX); 406 if (!AppendCUDie) 407 Parents.push_back(0); 408 PrevSiblings.push_back(0); 409 410 // Start to extract dies. 411 do { 412 assert(Parents.size() > 0 && "Empty parents stack"); 413 assert((Parents.back() == UINT32_MAX || Parents.back() <= Dies.size()) && 414 "Wrong parent index"); 415 416 // Extract die. Stop if any error occurred. 417 if (!DIE.extractFast(*this, &DIEOffset, DebugInfoData, NextCUOffset, 418 Parents.back())) 419 break; 420 421 // If previous sibling is remembered then update it`s SiblingIdx field. 422 if (PrevSiblings.back() > 0) { 423 assert(PrevSiblings.back() < Dies.size() && 424 "Previous sibling index is out of Dies boundaries"); 425 Dies[PrevSiblings.back()].setSiblingIdx(Dies.size()); 426 } 427 428 // Store die into the Dies vector. 429 if (IsCUDie) { 430 if (AppendCUDie) 431 Dies.push_back(DIE); 432 if (!AppendNonCUDies) 433 break; 434 // The average bytes per DIE entry has been seen to be 435 // around 14-20 so let's pre-reserve the needed memory for 436 // our DIE entries accordingly. 437 Dies.reserve(Dies.size() + getDebugInfoSize() / 14); 438 } else { 439 // Remember last previous sibling. 440 PrevSiblings.back() = Dies.size(); 441 442 Dies.push_back(DIE); 443 } 444 445 // Check for new children scope. 446 if (const DWARFAbbreviationDeclaration *AbbrDecl = 447 DIE.getAbbreviationDeclarationPtr()) { 448 if (AbbrDecl->hasChildren()) { 449 if (AppendCUDie || !IsCUDie) { 450 assert(Dies.size() > 0 && "Dies does not contain any die"); 451 Parents.push_back(Dies.size() - 1); 452 PrevSiblings.push_back(0); 453 } 454 } else if (IsCUDie) 455 // Stop if we have single compile unit die w/o children. 456 break; 457 } else { 458 // NULL DIE: finishes current children scope. 459 Parents.pop_back(); 460 PrevSiblings.pop_back(); 461 } 462 463 if (IsCUDie) 464 IsCUDie = false; 465 466 // Stop when compile unit die is removed from the parents stack. 467 } while (Parents.size() > 1); 468 } 469 470 void DWARFUnit::extractDIEsIfNeeded(bool CUDieOnly) { 471 if (Error e = tryExtractDIEsIfNeeded(CUDieOnly)) 472 Context.getRecoverableErrorHandler()(std::move(e)); 473 } 474 475 Error DWARFUnit::tryExtractDIEsIfNeeded(bool CUDieOnly) { 476 if ((CUDieOnly && !DieArray.empty()) || 477 DieArray.size() > 1) 478 return Error::success(); // Already parsed. 479 480 bool HasCUDie = !DieArray.empty(); 481 extractDIEsToVector(!HasCUDie, !CUDieOnly, DieArray); 482 483 if (DieArray.empty()) 484 return Error::success(); 485 486 // If CU DIE was just parsed, copy several attribute values from it. 487 if (HasCUDie) 488 return Error::success(); 489 490 DWARFDie UnitDie(this, &DieArray[0]); 491 if (std::optional<uint64_t> DWOId = 492 toUnsigned(UnitDie.find(DW_AT_GNU_dwo_id))) 493 Header.setDWOId(*DWOId); 494 if (!IsDWO) { 495 assert(AddrOffsetSectionBase == std::nullopt); 496 assert(RangeSectionBase == 0); 497 assert(LocSectionBase == 0); 498 AddrOffsetSectionBase = toSectionOffset(UnitDie.find(DW_AT_addr_base)); 499 if (!AddrOffsetSectionBase) 500 AddrOffsetSectionBase = 501 toSectionOffset(UnitDie.find(DW_AT_GNU_addr_base)); 502 RangeSectionBase = toSectionOffset(UnitDie.find(DW_AT_rnglists_base), 0); 503 LocSectionBase = toSectionOffset(UnitDie.find(DW_AT_loclists_base), 0); 504 } 505 506 // In general, in DWARF v5 and beyond we derive the start of the unit's 507 // contribution to the string offsets table from the unit DIE's 508 // DW_AT_str_offsets_base attribute. Split DWARF units do not use this 509 // attribute, so we assume that there is a contribution to the string 510 // offsets table starting at offset 0 of the debug_str_offsets.dwo section. 511 // In both cases we need to determine the format of the contribution, 512 // which may differ from the unit's format. 513 DWARFDataExtractor DA(Context.getDWARFObj(), StringOffsetSection, 514 IsLittleEndian, 0); 515 if (IsDWO || getVersion() >= 5) { 516 auto StringOffsetOrError = 517 IsDWO ? determineStringOffsetsTableContributionDWO(DA) 518 : determineStringOffsetsTableContribution(DA); 519 if (!StringOffsetOrError) 520 return createStringError(errc::invalid_argument, 521 "invalid reference to or invalid content in " 522 ".debug_str_offsets[.dwo]: " + 523 toString(StringOffsetOrError.takeError())); 524 525 StringOffsetsTableContribution = *StringOffsetOrError; 526 } 527 528 // DWARF v5 uses the .debug_rnglists and .debug_rnglists.dwo sections to 529 // describe address ranges. 530 if (getVersion() >= 5) { 531 // In case of DWP, the base offset from the index has to be added. 532 if (IsDWO) { 533 uint64_t ContributionBaseOffset = 0; 534 if (auto *IndexEntry = Header.getIndexEntry()) 535 if (auto *Contrib = IndexEntry->getContribution(DW_SECT_RNGLISTS)) 536 ContributionBaseOffset = Contrib->getOffset(); 537 setRangesSection( 538 &Context.getDWARFObj().getRnglistsDWOSection(), 539 ContributionBaseOffset + 540 DWARFListTableHeader::getHeaderSize(Header.getFormat())); 541 } else 542 setRangesSection(&Context.getDWARFObj().getRnglistsSection(), 543 toSectionOffset(UnitDie.find(DW_AT_rnglists_base), 544 DWARFListTableHeader::getHeaderSize( 545 Header.getFormat()))); 546 } 547 548 if (IsDWO) { 549 // If we are reading a package file, we need to adjust the location list 550 // data based on the index entries. 551 StringRef Data = Header.getVersion() >= 5 552 ? Context.getDWARFObj().getLoclistsDWOSection().Data 553 : Context.getDWARFObj().getLocDWOSection().Data; 554 if (auto *IndexEntry = Header.getIndexEntry()) 555 if (const auto *C = IndexEntry->getContribution( 556 Header.getVersion() >= 5 ? DW_SECT_LOCLISTS : DW_SECT_EXT_LOC)) 557 Data = Data.substr(C->getOffset(), C->getLength()); 558 559 DWARFDataExtractor DWARFData(Data, IsLittleEndian, getAddressByteSize()); 560 LocTable = 561 std::make_unique<DWARFDebugLoclists>(DWARFData, Header.getVersion()); 562 LocSectionBase = DWARFListTableHeader::getHeaderSize(Header.getFormat()); 563 } else if (getVersion() >= 5) { 564 LocTable = std::make_unique<DWARFDebugLoclists>( 565 DWARFDataExtractor(Context.getDWARFObj(), 566 Context.getDWARFObj().getLoclistsSection(), 567 IsLittleEndian, getAddressByteSize()), 568 getVersion()); 569 } else { 570 LocTable = std::make_unique<DWARFDebugLoc>(DWARFDataExtractor( 571 Context.getDWARFObj(), Context.getDWARFObj().getLocSection(), 572 IsLittleEndian, getAddressByteSize())); 573 } 574 575 // Don't fall back to DW_AT_GNU_ranges_base: it should be ignored for 576 // skeleton CU DIE, so that DWARF users not aware of it are not broken. 577 return Error::success(); 578 } 579 580 bool DWARFUnit::parseDWO(StringRef DWOAlternativeLocation) { 581 if (IsDWO) 582 return false; 583 if (DWO) 584 return false; 585 DWARFDie UnitDie = getUnitDIE(); 586 if (!UnitDie) 587 return false; 588 auto DWOFileName = getVersion() >= 5 589 ? dwarf::toString(UnitDie.find(DW_AT_dwo_name)) 590 : dwarf::toString(UnitDie.find(DW_AT_GNU_dwo_name)); 591 if (!DWOFileName) 592 return false; 593 auto CompilationDir = dwarf::toString(UnitDie.find(DW_AT_comp_dir)); 594 SmallString<16> AbsolutePath; 595 if (sys::path::is_relative(*DWOFileName) && CompilationDir && 596 *CompilationDir) { 597 sys::path::append(AbsolutePath, *CompilationDir); 598 } 599 sys::path::append(AbsolutePath, *DWOFileName); 600 auto DWOId = getDWOId(); 601 if (!DWOId) 602 return false; 603 auto DWOContext = Context.getDWOContext(AbsolutePath); 604 if (!DWOContext) { 605 // Use the alternative location to get the DWARF context for the DWO object. 606 if (DWOAlternativeLocation.empty()) 607 return false; 608 // If the alternative context does not correspond to the original DWO object 609 // (different hashes), the below 'getDWOCompileUnitForHash' call will catch 610 // the issue, with a returned null context. 611 DWOContext = Context.getDWOContext(DWOAlternativeLocation); 612 if (!DWOContext) 613 return false; 614 } 615 616 DWARFCompileUnit *DWOCU = DWOContext->getDWOCompileUnitForHash(*DWOId); 617 if (!DWOCU) 618 return false; 619 DWO = std::shared_ptr<DWARFCompileUnit>(std::move(DWOContext), DWOCU); 620 DWO->setSkeletonUnit(this); 621 // Share .debug_addr and .debug_ranges section with compile unit in .dwo 622 if (AddrOffsetSectionBase) 623 DWO->setAddrOffsetSection(AddrOffsetSection, *AddrOffsetSectionBase); 624 if (getVersion() == 4) { 625 auto DWORangesBase = UnitDie.getRangesBaseAttribute(); 626 DWO->setRangesSection(RangeSection, DWORangesBase.value_or(0)); 627 } 628 629 return true; 630 } 631 632 void DWARFUnit::clearDIEs(bool KeepCUDie) { 633 // Do not use resize() + shrink_to_fit() to free memory occupied by dies. 634 // shrink_to_fit() is a *non-binding* request to reduce capacity() to size(). 635 // It depends on the implementation whether the request is fulfilled. 636 // Create a new vector with a small capacity and assign it to the DieArray to 637 // have previous contents freed. 638 DieArray = (KeepCUDie && !DieArray.empty()) 639 ? std::vector<DWARFDebugInfoEntry>({DieArray[0]}) 640 : std::vector<DWARFDebugInfoEntry>(); 641 } 642 643 Expected<DWARFAddressRangesVector> 644 DWARFUnit::findRnglistFromOffset(uint64_t Offset) { 645 if (getVersion() <= 4) { 646 DWARFDebugRangeList RangeList; 647 if (Error E = extractRangeList(Offset, RangeList)) 648 return std::move(E); 649 return RangeList.getAbsoluteRanges(getBaseAddress()); 650 } 651 DWARFDataExtractor RangesData(Context.getDWARFObj(), *RangeSection, 652 IsLittleEndian, Header.getAddressByteSize()); 653 DWARFDebugRnglistTable RnglistTable; 654 auto RangeListOrError = RnglistTable.findList(RangesData, Offset); 655 if (RangeListOrError) 656 return RangeListOrError.get().getAbsoluteRanges(getBaseAddress(), *this); 657 return RangeListOrError.takeError(); 658 } 659 660 Expected<DWARFAddressRangesVector> 661 DWARFUnit::findRnglistFromIndex(uint32_t Index) { 662 if (auto Offset = getRnglistOffset(Index)) 663 return findRnglistFromOffset(*Offset); 664 665 return createStringError(errc::invalid_argument, 666 "invalid range list table index %d (possibly " 667 "missing the entire range list table)", 668 Index); 669 } 670 671 Expected<DWARFAddressRangesVector> DWARFUnit::collectAddressRanges() { 672 DWARFDie UnitDie = getUnitDIE(); 673 if (!UnitDie) 674 return createStringError(errc::invalid_argument, "No unit DIE"); 675 676 // First, check if unit DIE describes address ranges for the whole unit. 677 auto CUDIERangesOrError = UnitDie.getAddressRanges(); 678 if (!CUDIERangesOrError) 679 return createStringError(errc::invalid_argument, 680 "decoding address ranges: %s", 681 toString(CUDIERangesOrError.takeError()).c_str()); 682 return *CUDIERangesOrError; 683 } 684 685 Expected<DWARFLocationExpressionsVector> 686 DWARFUnit::findLoclistFromOffset(uint64_t Offset) { 687 DWARFLocationExpressionsVector Result; 688 689 Error InterpretationError = Error::success(); 690 691 Error ParseError = getLocationTable().visitAbsoluteLocationList( 692 Offset, getBaseAddress(), 693 [this](uint32_t Index) { return getAddrOffsetSectionItem(Index); }, 694 [&](Expected<DWARFLocationExpression> L) { 695 if (L) 696 Result.push_back(std::move(*L)); 697 else 698 InterpretationError = 699 joinErrors(L.takeError(), std::move(InterpretationError)); 700 return !InterpretationError; 701 }); 702 703 if (ParseError || InterpretationError) 704 return joinErrors(std::move(ParseError), std::move(InterpretationError)); 705 706 return Result; 707 } 708 709 void DWARFUnit::updateAddressDieMap(DWARFDie Die) { 710 if (Die.isSubroutineDIE()) { 711 auto DIERangesOrError = Die.getAddressRanges(); 712 if (DIERangesOrError) { 713 for (const auto &R : DIERangesOrError.get()) { 714 // Ignore 0-sized ranges. 715 if (R.LowPC == R.HighPC) 716 continue; 717 auto B = AddrDieMap.upper_bound(R.LowPC); 718 if (B != AddrDieMap.begin() && R.LowPC < (--B)->second.first) { 719 // The range is a sub-range of existing ranges, we need to split the 720 // existing range. 721 if (R.HighPC < B->second.first) 722 AddrDieMap[R.HighPC] = B->second; 723 if (R.LowPC > B->first) 724 AddrDieMap[B->first].first = R.LowPC; 725 } 726 AddrDieMap[R.LowPC] = std::make_pair(R.HighPC, Die); 727 } 728 } else 729 llvm::consumeError(DIERangesOrError.takeError()); 730 } 731 // Parent DIEs are added to the AddrDieMap prior to the Children DIEs to 732 // simplify the logic to update AddrDieMap. The child's range will always 733 // be equal or smaller than the parent's range. With this assumption, when 734 // adding one range into the map, it will at most split a range into 3 735 // sub-ranges. 736 for (DWARFDie Child = Die.getFirstChild(); Child; Child = Child.getSibling()) 737 updateAddressDieMap(Child); 738 } 739 740 DWARFDie DWARFUnit::getSubroutineForAddress(uint64_t Address) { 741 extractDIEsIfNeeded(false); 742 if (AddrDieMap.empty()) 743 updateAddressDieMap(getUnitDIE()); 744 auto R = AddrDieMap.upper_bound(Address); 745 if (R == AddrDieMap.begin()) 746 return DWARFDie(); 747 // upper_bound's previous item contains Address. 748 --R; 749 if (Address >= R->second.first) 750 return DWARFDie(); 751 return R->second.second; 752 } 753 754 void DWARFUnit::updateVariableDieMap(DWARFDie Die) { 755 for (DWARFDie Child : Die) { 756 if (isType(Child.getTag())) 757 continue; 758 updateVariableDieMap(Child); 759 } 760 761 if (Die.getTag() != DW_TAG_variable) 762 return; 763 764 Expected<DWARFLocationExpressionsVector> Locations = 765 Die.getLocations(DW_AT_location); 766 if (!Locations) { 767 // Missing DW_AT_location is fine here. 768 consumeError(Locations.takeError()); 769 return; 770 } 771 772 uint64_t Address = UINT64_MAX; 773 774 for (const DWARFLocationExpression &Location : *Locations) { 775 uint8_t AddressSize = getAddressByteSize(); 776 DataExtractor Data(Location.Expr, isLittleEndian(), AddressSize); 777 DWARFExpression Expr(Data, AddressSize); 778 auto It = Expr.begin(); 779 if (It == Expr.end()) 780 continue; 781 782 // Match exactly the main sequence used to describe global variables: 783 // `DW_OP_addr[x] [+ DW_OP_plus_uconst]`. Currently, this is the sequence 784 // that LLVM produces for DILocalVariables and DIGlobalVariables. If, in 785 // future, the DWARF producer (`DwarfCompileUnit::addLocationAttribute()` is 786 // a good starting point) is extended to use further expressions, this code 787 // needs to be updated. 788 uint64_t LocationAddr; 789 if (It->getCode() == dwarf::DW_OP_addr) { 790 LocationAddr = It->getRawOperand(0); 791 } else if (It->getCode() == dwarf::DW_OP_addrx) { 792 uint64_t DebugAddrOffset = It->getRawOperand(0); 793 if (auto Pointer = getAddrOffsetSectionItem(DebugAddrOffset)) { 794 LocationAddr = Pointer->Address; 795 } 796 } else { 797 continue; 798 } 799 800 // Read the optional 2nd operand, a DW_OP_plus_uconst. 801 if (++It != Expr.end()) { 802 if (It->getCode() != dwarf::DW_OP_plus_uconst) 803 continue; 804 805 LocationAddr += It->getRawOperand(0); 806 807 // Probe for a 3rd operand, if it exists, bail. 808 if (++It != Expr.end()) 809 continue; 810 } 811 812 Address = LocationAddr; 813 break; 814 } 815 816 // Get the size of the global variable. If all else fails (i.e. the global has 817 // no type), then we use a size of one to still allow symbolization of the 818 // exact address. 819 uint64_t GVSize = 1; 820 if (Die.getAttributeValueAsReferencedDie(DW_AT_type)) 821 if (std::optional<uint64_t> Size = Die.getTypeSize(getAddressByteSize())) 822 GVSize = *Size; 823 824 if (Address != UINT64_MAX) 825 VariableDieMap[Address] = {Address + GVSize, Die}; 826 } 827 828 DWARFDie DWARFUnit::getVariableForAddress(uint64_t Address) { 829 extractDIEsIfNeeded(false); 830 831 auto RootDie = getUnitDIE(); 832 833 auto RootLookup = RootsParsedForVariables.insert(RootDie.getOffset()); 834 if (RootLookup.second) 835 updateVariableDieMap(RootDie); 836 837 auto R = VariableDieMap.upper_bound(Address); 838 if (R == VariableDieMap.begin()) 839 return DWARFDie(); 840 841 // upper_bound's previous item contains Address. 842 --R; 843 if (Address >= R->second.first) 844 return DWARFDie(); 845 return R->second.second; 846 } 847 848 void 849 DWARFUnit::getInlinedChainForAddress(uint64_t Address, 850 SmallVectorImpl<DWARFDie> &InlinedChain) { 851 assert(InlinedChain.empty()); 852 // Try to look for subprogram DIEs in the DWO file. 853 parseDWO(); 854 // First, find the subroutine that contains the given address (the leaf 855 // of inlined chain). 856 DWARFDie SubroutineDIE = 857 (DWO ? *DWO : *this).getSubroutineForAddress(Address); 858 859 while (SubroutineDIE) { 860 if (SubroutineDIE.isSubprogramDIE()) { 861 InlinedChain.push_back(SubroutineDIE); 862 return; 863 } 864 if (SubroutineDIE.getTag() == DW_TAG_inlined_subroutine) 865 InlinedChain.push_back(SubroutineDIE); 866 SubroutineDIE = SubroutineDIE.getParent(); 867 } 868 } 869 870 const DWARFUnitIndex &llvm::getDWARFUnitIndex(DWARFContext &Context, 871 DWARFSectionKind Kind) { 872 if (Kind == DW_SECT_INFO) 873 return Context.getCUIndex(); 874 assert(Kind == DW_SECT_EXT_TYPES); 875 return Context.getTUIndex(); 876 } 877 878 DWARFDie DWARFUnit::getParent(const DWARFDebugInfoEntry *Die) { 879 if (const DWARFDebugInfoEntry *Entry = getParentEntry(Die)) 880 return DWARFDie(this, Entry); 881 882 return DWARFDie(); 883 } 884 885 const DWARFDebugInfoEntry * 886 DWARFUnit::getParentEntry(const DWARFDebugInfoEntry *Die) const { 887 if (!Die) 888 return nullptr; 889 assert(Die >= DieArray.data() && Die < DieArray.data() + DieArray.size()); 890 891 if (std::optional<uint32_t> ParentIdx = Die->getParentIdx()) { 892 assert(*ParentIdx < DieArray.size() && 893 "ParentIdx is out of DieArray boundaries"); 894 return getDebugInfoEntry(*ParentIdx); 895 } 896 897 return nullptr; 898 } 899 900 DWARFDie DWARFUnit::getSibling(const DWARFDebugInfoEntry *Die) { 901 if (const DWARFDebugInfoEntry *Sibling = getSiblingEntry(Die)) 902 return DWARFDie(this, Sibling); 903 904 return DWARFDie(); 905 } 906 907 const DWARFDebugInfoEntry * 908 DWARFUnit::getSiblingEntry(const DWARFDebugInfoEntry *Die) const { 909 if (!Die) 910 return nullptr; 911 assert(Die >= DieArray.data() && Die < DieArray.data() + DieArray.size()); 912 913 if (std::optional<uint32_t> SiblingIdx = Die->getSiblingIdx()) { 914 assert(*SiblingIdx < DieArray.size() && 915 "SiblingIdx is out of DieArray boundaries"); 916 return &DieArray[*SiblingIdx]; 917 } 918 919 return nullptr; 920 } 921 922 DWARFDie DWARFUnit::getPreviousSibling(const DWARFDebugInfoEntry *Die) { 923 if (const DWARFDebugInfoEntry *Sibling = getPreviousSiblingEntry(Die)) 924 return DWARFDie(this, Sibling); 925 926 return DWARFDie(); 927 } 928 929 const DWARFDebugInfoEntry * 930 DWARFUnit::getPreviousSiblingEntry(const DWARFDebugInfoEntry *Die) const { 931 if (!Die) 932 return nullptr; 933 assert(Die >= DieArray.data() && Die < DieArray.data() + DieArray.size()); 934 935 std::optional<uint32_t> ParentIdx = Die->getParentIdx(); 936 if (!ParentIdx) 937 // Die is a root die, there is no previous sibling. 938 return nullptr; 939 940 assert(*ParentIdx < DieArray.size() && 941 "ParentIdx is out of DieArray boundaries"); 942 assert(getDIEIndex(Die) > 0 && "Die is a root die"); 943 944 uint32_t PrevDieIdx = getDIEIndex(Die) - 1; 945 if (PrevDieIdx == *ParentIdx) 946 // Immediately previous node is parent, there is no previous sibling. 947 return nullptr; 948 949 while (DieArray[PrevDieIdx].getParentIdx() != *ParentIdx) { 950 PrevDieIdx = *DieArray[PrevDieIdx].getParentIdx(); 951 952 assert(PrevDieIdx < DieArray.size() && 953 "PrevDieIdx is out of DieArray boundaries"); 954 assert(PrevDieIdx >= *ParentIdx && 955 "PrevDieIdx is not a child of parent of Die"); 956 } 957 958 return &DieArray[PrevDieIdx]; 959 } 960 961 DWARFDie DWARFUnit::getFirstChild(const DWARFDebugInfoEntry *Die) { 962 if (const DWARFDebugInfoEntry *Child = getFirstChildEntry(Die)) 963 return DWARFDie(this, Child); 964 965 return DWARFDie(); 966 } 967 968 const DWARFDebugInfoEntry * 969 DWARFUnit::getFirstChildEntry(const DWARFDebugInfoEntry *Die) const { 970 if (!Die) 971 return nullptr; 972 assert(Die >= DieArray.data() && Die < DieArray.data() + DieArray.size()); 973 974 if (!Die->hasChildren()) 975 return nullptr; 976 977 // TODO: Instead of checking here for invalid die we might reject 978 // invalid dies at parsing stage(DWARFUnit::extractDIEsToVector). 979 // We do not want access out of bounds when parsing corrupted debug data. 980 size_t I = getDIEIndex(Die) + 1; 981 if (I >= DieArray.size()) 982 return nullptr; 983 return &DieArray[I]; 984 } 985 986 DWARFDie DWARFUnit::getLastChild(const DWARFDebugInfoEntry *Die) { 987 if (const DWARFDebugInfoEntry *Child = getLastChildEntry(Die)) 988 return DWARFDie(this, Child); 989 990 return DWARFDie(); 991 } 992 993 const DWARFDebugInfoEntry * 994 DWARFUnit::getLastChildEntry(const DWARFDebugInfoEntry *Die) const { 995 if (!Die) 996 return nullptr; 997 assert(Die >= DieArray.data() && Die < DieArray.data() + DieArray.size()); 998 999 if (!Die->hasChildren()) 1000 return nullptr; 1001 1002 if (std::optional<uint32_t> SiblingIdx = Die->getSiblingIdx()) { 1003 assert(*SiblingIdx < DieArray.size() && 1004 "SiblingIdx is out of DieArray boundaries"); 1005 assert(DieArray[*SiblingIdx - 1].getTag() == dwarf::DW_TAG_null && 1006 "Bad end of children marker"); 1007 return &DieArray[*SiblingIdx - 1]; 1008 } 1009 1010 // If SiblingIdx is set for non-root dies we could be sure that DWARF is 1011 // correct and "end of children marker" must be found. For root die we do not 1012 // have such a guarantee(parsing root die might be stopped if "end of children 1013 // marker" is missing, SiblingIdx is always zero for root die). That is why we 1014 // do not use assertion for checking for "end of children marker" for root 1015 // die. 1016 1017 // TODO: Instead of checking here for invalid die we might reject 1018 // invalid dies at parsing stage(DWARFUnit::extractDIEsToVector). 1019 if (getDIEIndex(Die) == 0 && DieArray.size() > 1 && 1020 DieArray.back().getTag() == dwarf::DW_TAG_null) { 1021 // For the unit die we might take last item from DieArray. 1022 assert(getDIEIndex(Die) == 1023 getDIEIndex(const_cast<DWARFUnit *>(this)->getUnitDIE()) && 1024 "Bad unit die"); 1025 return &DieArray.back(); 1026 } 1027 1028 return nullptr; 1029 } 1030 1031 const DWARFAbbreviationDeclarationSet *DWARFUnit::getAbbreviations() const { 1032 if (!Abbrevs) { 1033 Expected<const DWARFAbbreviationDeclarationSet *> AbbrevsOrError = 1034 Abbrev->getAbbreviationDeclarationSet(getAbbreviationsOffset()); 1035 if (!AbbrevsOrError) { 1036 // FIXME: We should propagate this error upwards. 1037 consumeError(AbbrevsOrError.takeError()); 1038 return nullptr; 1039 } 1040 Abbrevs = *AbbrevsOrError; 1041 } 1042 return Abbrevs; 1043 } 1044 1045 std::optional<object::SectionedAddress> DWARFUnit::getBaseAddress() { 1046 if (BaseAddr) 1047 return BaseAddr; 1048 1049 DWARFDie UnitDie = (SU ? SU : this)->getUnitDIE(); 1050 std::optional<DWARFFormValue> PC = 1051 UnitDie.find({DW_AT_low_pc, DW_AT_entry_pc}); 1052 BaseAddr = toSectionedAddress(PC); 1053 return BaseAddr; 1054 } 1055 1056 Expected<StrOffsetsContributionDescriptor> 1057 StrOffsetsContributionDescriptor::validateContributionSize( 1058 DWARFDataExtractor &DA) { 1059 uint8_t EntrySize = getDwarfOffsetByteSize(); 1060 // In order to ensure that we don't read a partial record at the end of 1061 // the section we validate for a multiple of the entry size. 1062 uint64_t ValidationSize = alignTo(Size, EntrySize); 1063 // Guard against overflow. 1064 if (ValidationSize >= Size) 1065 if (DA.isValidOffsetForDataOfSize((uint32_t)Base, ValidationSize)) 1066 return *this; 1067 return createStringError(errc::invalid_argument, "length exceeds section size"); 1068 } 1069 1070 // Look for a DWARF64-formatted contribution to the string offsets table 1071 // starting at a given offset and record it in a descriptor. 1072 static Expected<StrOffsetsContributionDescriptor> 1073 parseDWARF64StringOffsetsTableHeader(DWARFDataExtractor &DA, uint64_t Offset) { 1074 if (!DA.isValidOffsetForDataOfSize(Offset, 16)) 1075 return createStringError(errc::invalid_argument, "section offset exceeds section size"); 1076 1077 if (DA.getU32(&Offset) != dwarf::DW_LENGTH_DWARF64) 1078 return createStringError(errc::invalid_argument, "32 bit contribution referenced from a 64 bit unit"); 1079 1080 uint64_t Size = DA.getU64(&Offset); 1081 uint8_t Version = DA.getU16(&Offset); 1082 (void)DA.getU16(&Offset); // padding 1083 // The encoded length includes the 2-byte version field and the 2-byte 1084 // padding, so we need to subtract them out when we populate the descriptor. 1085 return StrOffsetsContributionDescriptor(Offset, Size - 4, Version, DWARF64); 1086 } 1087 1088 // Look for a DWARF32-formatted contribution to the string offsets table 1089 // starting at a given offset and record it in a descriptor. 1090 static Expected<StrOffsetsContributionDescriptor> 1091 parseDWARF32StringOffsetsTableHeader(DWARFDataExtractor &DA, uint64_t Offset) { 1092 if (!DA.isValidOffsetForDataOfSize(Offset, 8)) 1093 return createStringError(errc::invalid_argument, "section offset exceeds section size"); 1094 1095 uint32_t ContributionSize = DA.getU32(&Offset); 1096 if (ContributionSize >= dwarf::DW_LENGTH_lo_reserved) 1097 return createStringError(errc::invalid_argument, "invalid length"); 1098 1099 uint8_t Version = DA.getU16(&Offset); 1100 (void)DA.getU16(&Offset); // padding 1101 // The encoded length includes the 2-byte version field and the 2-byte 1102 // padding, so we need to subtract them out when we populate the descriptor. 1103 return StrOffsetsContributionDescriptor(Offset, ContributionSize - 4, Version, 1104 DWARF32); 1105 } 1106 1107 static Expected<StrOffsetsContributionDescriptor> 1108 parseDWARFStringOffsetsTableHeader(DWARFDataExtractor &DA, 1109 llvm::dwarf::DwarfFormat Format, 1110 uint64_t Offset) { 1111 StrOffsetsContributionDescriptor Desc; 1112 switch (Format) { 1113 case dwarf::DwarfFormat::DWARF64: { 1114 if (Offset < 16) 1115 return createStringError(errc::invalid_argument, "insufficient space for 64 bit header prefix"); 1116 auto DescOrError = parseDWARF64StringOffsetsTableHeader(DA, Offset - 16); 1117 if (!DescOrError) 1118 return DescOrError.takeError(); 1119 Desc = *DescOrError; 1120 break; 1121 } 1122 case dwarf::DwarfFormat::DWARF32: { 1123 if (Offset < 8) 1124 return createStringError(errc::invalid_argument, "insufficient space for 32 bit header prefix"); 1125 auto DescOrError = parseDWARF32StringOffsetsTableHeader(DA, Offset - 8); 1126 if (!DescOrError) 1127 return DescOrError.takeError(); 1128 Desc = *DescOrError; 1129 break; 1130 } 1131 } 1132 return Desc.validateContributionSize(DA); 1133 } 1134 1135 Expected<std::optional<StrOffsetsContributionDescriptor>> 1136 DWARFUnit::determineStringOffsetsTableContribution(DWARFDataExtractor &DA) { 1137 assert(!IsDWO); 1138 auto OptOffset = toSectionOffset(getUnitDIE().find(DW_AT_str_offsets_base)); 1139 if (!OptOffset) 1140 return std::nullopt; 1141 auto DescOrError = 1142 parseDWARFStringOffsetsTableHeader(DA, Header.getFormat(), *OptOffset); 1143 if (!DescOrError) 1144 return DescOrError.takeError(); 1145 return *DescOrError; 1146 } 1147 1148 Expected<std::optional<StrOffsetsContributionDescriptor>> 1149 DWARFUnit::determineStringOffsetsTableContributionDWO(DWARFDataExtractor &DA) { 1150 assert(IsDWO); 1151 uint64_t Offset = 0; 1152 auto IndexEntry = Header.getIndexEntry(); 1153 const auto *C = 1154 IndexEntry ? IndexEntry->getContribution(DW_SECT_STR_OFFSETS) : nullptr; 1155 if (C) 1156 Offset = C->getOffset(); 1157 if (getVersion() >= 5) { 1158 if (DA.getData().data() == nullptr) 1159 return std::nullopt; 1160 Offset += Header.getFormat() == dwarf::DwarfFormat::DWARF32 ? 8 : 16; 1161 // Look for a valid contribution at the given offset. 1162 auto DescOrError = parseDWARFStringOffsetsTableHeader(DA, Header.getFormat(), Offset); 1163 if (!DescOrError) 1164 return DescOrError.takeError(); 1165 return *DescOrError; 1166 } 1167 // Prior to DWARF v5, we derive the contribution size from the 1168 // index table (in a package file). In a .dwo file it is simply 1169 // the length of the string offsets section. 1170 StrOffsetsContributionDescriptor Desc; 1171 if (C) 1172 Desc = StrOffsetsContributionDescriptor(C->getOffset(), C->getLength(), 4, 1173 Header.getFormat()); 1174 else if (!IndexEntry && !StringOffsetSection.Data.empty()) 1175 Desc = StrOffsetsContributionDescriptor(0, StringOffsetSection.Data.size(), 1176 4, Header.getFormat()); 1177 else 1178 return std::nullopt; 1179 auto DescOrError = Desc.validateContributionSize(DA); 1180 if (!DescOrError) 1181 return DescOrError.takeError(); 1182 return *DescOrError; 1183 } 1184 1185 std::optional<uint64_t> DWARFUnit::getRnglistOffset(uint32_t Index) { 1186 DataExtractor RangesData(RangeSection->Data, IsLittleEndian, 1187 getAddressByteSize()); 1188 DWARFDataExtractor RangesDA(Context.getDWARFObj(), *RangeSection, 1189 IsLittleEndian, 0); 1190 if (std::optional<uint64_t> Off = llvm::DWARFListTableHeader::getOffsetEntry( 1191 RangesData, RangeSectionBase, getFormat(), Index)) 1192 return *Off + RangeSectionBase; 1193 return std::nullopt; 1194 } 1195 1196 std::optional<uint64_t> DWARFUnit::getLoclistOffset(uint32_t Index) { 1197 if (std::optional<uint64_t> Off = llvm::DWARFListTableHeader::getOffsetEntry( 1198 LocTable->getData(), LocSectionBase, getFormat(), Index)) 1199 return *Off + LocSectionBase; 1200 return std::nullopt; 1201 } 1202