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
39using namespace llvm;
40using namespace dwarf;
41
42void 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
53void 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
65void 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
139DWARFUnit *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
148DWARFUnit *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
160DWARFUnit *
161DWARFUnitVector::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
190DWARFUnit::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
203DWARFUnit::~DWARFUnit() = default;
204
205DWARFDataExtractor DWARFUnit::getDebugInfoExtractor() const {
206  return DWARFDataExtractor(Context.getDWARFObj(), InfoSection, IsLittleEndian,
207                            getAddressByteSize());
208}
209
210std::optional<object::SectionedAddress>
211DWARFUnit::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
234Expected<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
250Error 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
337bool 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
354Error 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
364void 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
378const char *DWARFUnit::getCompilationDir() {
379  return dwarf::toString(getUnitDIE().find(DW_AT_comp_dir), nullptr);
380}
381
382void 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
470void DWARFUnit::extractDIEsIfNeeded(bool CUDieOnly) {
471  if (Error e = tryExtractDIEsIfNeeded(CUDieOnly))
472    Context.getRecoverableErrorHandler()(std::move(e));
473}
474
475Error 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
580bool 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
632void 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
643Expected<DWARFAddressRangesVector>
644DWARFUnit::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
660Expected<DWARFAddressRangesVector>
661DWARFUnit::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
671Expected<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
685Expected<DWARFLocationExpressionsVector>
686DWARFUnit::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
709void 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
740DWARFDie 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
754void 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
828DWARFDie 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
848void
849DWARFUnit::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
870const 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
878DWARFDie DWARFUnit::getParent(const DWARFDebugInfoEntry *Die) {
879  if (const DWARFDebugInfoEntry *Entry = getParentEntry(Die))
880    return DWARFDie(this, Entry);
881
882  return DWARFDie();
883}
884
885const DWARFDebugInfoEntry *
886DWARFUnit::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
900DWARFDie DWARFUnit::getSibling(const DWARFDebugInfoEntry *Die) {
901  if (const DWARFDebugInfoEntry *Sibling = getSiblingEntry(Die))
902    return DWARFDie(this, Sibling);
903
904  return DWARFDie();
905}
906
907const DWARFDebugInfoEntry *
908DWARFUnit::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
922DWARFDie DWARFUnit::getPreviousSibling(const DWARFDebugInfoEntry *Die) {
923  if (const DWARFDebugInfoEntry *Sibling = getPreviousSiblingEntry(Die))
924    return DWARFDie(this, Sibling);
925
926  return DWARFDie();
927}
928
929const DWARFDebugInfoEntry *
930DWARFUnit::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
961DWARFDie DWARFUnit::getFirstChild(const DWARFDebugInfoEntry *Die) {
962  if (const DWARFDebugInfoEntry *Child = getFirstChildEntry(Die))
963    return DWARFDie(this, Child);
964
965  return DWARFDie();
966}
967
968const DWARFDebugInfoEntry *
969DWARFUnit::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
986DWARFDie DWARFUnit::getLastChild(const DWARFDebugInfoEntry *Die) {
987  if (const DWARFDebugInfoEntry *Child = getLastChildEntry(Die))
988    return DWARFDie(this, Child);
989
990  return DWARFDie();
991}
992
993const DWARFDebugInfoEntry *
994DWARFUnit::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
1031const 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
1045std::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
1056Expected<StrOffsetsContributionDescriptor>
1057StrOffsetsContributionDescriptor::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.
1072static Expected<StrOffsetsContributionDescriptor>
1073parseDWARF64StringOffsetsTableHeader(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.
1090static Expected<StrOffsetsContributionDescriptor>
1091parseDWARF32StringOffsetsTableHeader(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
1107static Expected<StrOffsetsContributionDescriptor>
1108parseDWARFStringOffsetsTableHeader(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
1135Expected<std::optional<StrOffsetsContributionDescriptor>>
1136DWARFUnit::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
1148Expected<std::optional<StrOffsetsContributionDescriptor>>
1149DWARFUnit::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
1185std::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
1196std::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