1//===- DWARFContext.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/DWARFContext.h"
10#include "llvm/ADT/MapVector.h"
11#include "llvm/ADT/STLExtras.h"
12#include "llvm/ADT/SmallString.h"
13#include "llvm/ADT/SmallVector.h"
14#include "llvm/ADT/StringRef.h"
15#include "llvm/ADT/StringSwitch.h"
16#include "llvm/BinaryFormat/Dwarf.h"
17#include "llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h"
18#include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h"
19#include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
20#include "llvm/DebugInfo/DWARF/DWARFDebugAbbrev.h"
21#include "llvm/DebugInfo/DWARF/DWARFDebugAddr.h"
22#include "llvm/DebugInfo/DWARF/DWARFDebugArangeSet.h"
23#include "llvm/DebugInfo/DWARF/DWARFDebugAranges.h"
24#include "llvm/DebugInfo/DWARF/DWARFDebugFrame.h"
25#include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
26#include "llvm/DebugInfo/DWARF/DWARFDebugLoc.h"
27#include "llvm/DebugInfo/DWARF/DWARFDebugMacro.h"
28#include "llvm/DebugInfo/DWARF/DWARFDebugPubTable.h"
29#include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
30#include "llvm/DebugInfo/DWARF/DWARFDebugRnglists.h"
31#include "llvm/DebugInfo/DWARF/DWARFDie.h"
32#include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
33#include "llvm/DebugInfo/DWARF/DWARFGdbIndex.h"
34#include "llvm/DebugInfo/DWARF/DWARFListTable.h"
35#include "llvm/DebugInfo/DWARF/DWARFLocationExpression.h"
36#include "llvm/DebugInfo/DWARF/DWARFRelocMap.h"
37#include "llvm/DebugInfo/DWARF/DWARFSection.h"
38#include "llvm/DebugInfo/DWARF/DWARFTypeUnit.h"
39#include "llvm/DebugInfo/DWARF/DWARFUnitIndex.h"
40#include "llvm/DebugInfo/DWARF/DWARFVerifier.h"
41#include "llvm/MC/TargetRegistry.h"
42#include "llvm/Object/Decompressor.h"
43#include "llvm/Object/MachO.h"
44#include "llvm/Object/ObjectFile.h"
45#include "llvm/Object/RelocationResolver.h"
46#include "llvm/Support/Casting.h"
47#include "llvm/Support/DataExtractor.h"
48#include "llvm/Support/Error.h"
49#include "llvm/Support/Format.h"
50#include "llvm/Support/LEB128.h"
51#include "llvm/Support/FormatVariadic.h"
52#include "llvm/Support/MemoryBuffer.h"
53#include "llvm/Support/Path.h"
54#include "llvm/Support/raw_ostream.h"
55#include <algorithm>
56#include <cstdint>
57#include <deque>
58#include <map>
59#include <string>
60#include <utility>
61#include <vector>
62
63using namespace llvm;
64using namespace dwarf;
65using namespace object;
66
67#define DEBUG_TYPE "dwarf"
68
69using DWARFLineTable = DWARFDebugLine::LineTable;
70using FileLineInfoKind = DILineInfoSpecifier::FileLineInfoKind;
71using FunctionNameKind = DILineInfoSpecifier::FunctionNameKind;
72
73
74void fixupIndexV4(DWARFContext &C, DWARFUnitIndex &Index) {
75  using EntryType = DWARFUnitIndex::Entry::SectionContribution;
76  using EntryMap = DenseMap<uint32_t, EntryType>;
77  EntryMap Map;
78  const auto &DObj = C.getDWARFObj();
79  if (DObj.getCUIndexSection().empty())
80    return;
81
82  uint64_t Offset = 0;
83  uint32_t TruncOffset = 0;
84  DObj.forEachInfoDWOSections([&](const DWARFSection &S) {
85    if (!(C.getParseCUTUIndexManually() ||
86          S.Data.size() >= std::numeric_limits<uint32_t>::max()))
87      return;
88
89    DWARFDataExtractor Data(DObj, S, C.isLittleEndian(), 0);
90    while (Data.isValidOffset(Offset)) {
91      DWARFUnitHeader Header;
92      if (Error ExtractionErr = Header.extract(
93              C, Data, &Offset, DWARFSectionKind::DW_SECT_INFO)) {
94        C.getWarningHandler()(
95            createError("Failed to parse CU header in DWP file: " +
96                        toString(std::move(ExtractionErr))));
97        Map.clear();
98        break;
99      }
100
101      auto Iter = Map.insert({TruncOffset,
102                              {Header.getOffset(), Header.getNextUnitOffset() -
103                                                       Header.getOffset()}});
104      if (!Iter.second) {
105        logAllUnhandledErrors(
106            createError("Collision occured between for truncated offset 0x" +
107                        Twine::utohexstr(TruncOffset)),
108            errs());
109        Map.clear();
110        return;
111      }
112
113      Offset = Header.getNextUnitOffset();
114      TruncOffset = Offset;
115    }
116  });
117
118  if (Map.empty())
119    return;
120
121  for (DWARFUnitIndex::Entry &E : Index.getMutableRows()) {
122    if (!E.isValid())
123      continue;
124    DWARFUnitIndex::Entry::SectionContribution &CUOff = E.getContribution();
125    auto Iter = Map.find(CUOff.getOffset());
126    if (Iter == Map.end()) {
127      logAllUnhandledErrors(createError("Could not find CU offset 0x" +
128                                        Twine::utohexstr(CUOff.getOffset()) +
129                                        " in the Map"),
130                            errs());
131      break;
132    }
133    CUOff.setOffset(Iter->second.getOffset());
134    if (CUOff.getOffset() != Iter->second.getOffset())
135      logAllUnhandledErrors(createError("Length of CU in CU index doesn't "
136                                        "match calculated length at offset 0x" +
137                                        Twine::utohexstr(CUOff.getOffset())),
138                            errs());
139  }
140}
141
142void fixupIndexV5(DWARFContext &C, DWARFUnitIndex &Index) {
143  DenseMap<uint64_t, uint64_t> Map;
144
145  const auto &DObj = C.getDWARFObj();
146  DObj.forEachInfoDWOSections([&](const DWARFSection &S) {
147    if (!(C.getParseCUTUIndexManually() ||
148          S.Data.size() >= std::numeric_limits<uint32_t>::max()))
149      return;
150    DWARFDataExtractor Data(DObj, S, C.isLittleEndian(), 0);
151    uint64_t Offset = 0;
152    while (Data.isValidOffset(Offset)) {
153      DWARFUnitHeader Header;
154      if (Error ExtractionErr = Header.extract(
155              C, Data, &Offset, DWARFSectionKind::DW_SECT_INFO)) {
156        C.getWarningHandler()(
157            createError("Failed to parse CU header in DWP file: " +
158                        toString(std::move(ExtractionErr))));
159        break;
160      }
161      bool CU = Header.getUnitType() == DW_UT_split_compile;
162      uint64_t Sig = CU ? *Header.getDWOId() : Header.getTypeHash();
163      Map[Sig] = Header.getOffset();
164      Offset = Header.getNextUnitOffset();
165    }
166  });
167  if (Map.empty())
168    return;
169  for (DWARFUnitIndex::Entry &E : Index.getMutableRows()) {
170    if (!E.isValid())
171      continue;
172    DWARFUnitIndex::Entry::SectionContribution &CUOff = E.getContribution();
173    auto Iter = Map.find(E.getSignature());
174    if (Iter == Map.end()) {
175      logAllUnhandledErrors(
176          createError("Could not find unit with signature 0x" +
177                      Twine::utohexstr(E.getSignature()) + " in the Map"),
178          errs());
179      break;
180    }
181    CUOff.setOffset(Iter->second);
182  }
183}
184
185void fixupIndex(DWARFContext &C, DWARFUnitIndex &Index) {
186  if (Index.getVersion() < 5)
187    fixupIndexV4(C, Index);
188  else
189    fixupIndexV5(C, Index);
190}
191
192template <typename T>
193static T &getAccelTable(std::unique_ptr<T> &Cache, const DWARFObject &Obj,
194                        const DWARFSection &Section, StringRef StringSection,
195                        bool IsLittleEndian) {
196  if (Cache)
197    return *Cache;
198  DWARFDataExtractor AccelSection(Obj, Section, IsLittleEndian, 0);
199  DataExtractor StrData(StringSection, IsLittleEndian, 0);
200  Cache = std::make_unique<T>(AccelSection, StrData);
201  if (Error E = Cache->extract())
202    llvm::consumeError(std::move(E));
203  return *Cache;
204}
205
206
207std::unique_ptr<DWARFDebugMacro>
208DWARFContext::DWARFContextState::parseMacroOrMacinfo(MacroSecType SectionType) {
209  auto Macro = std::make_unique<DWARFDebugMacro>();
210  auto ParseAndDump = [&](DWARFDataExtractor &Data, bool IsMacro) {
211    if (Error Err = IsMacro ? Macro->parseMacro(SectionType == MacroSection
212                                                    ? D.compile_units()
213                                                    : D.dwo_compile_units(),
214                                                SectionType == MacroSection
215                                                    ? D.getStringExtractor()
216                                                    : D.getStringDWOExtractor(),
217                                                Data)
218                            : Macro->parseMacinfo(Data)) {
219      D.getRecoverableErrorHandler()(std::move(Err));
220      Macro = nullptr;
221    }
222  };
223  const DWARFObject &DObj = D.getDWARFObj();
224  switch (SectionType) {
225  case MacinfoSection: {
226    DWARFDataExtractor Data(DObj.getMacinfoSection(), D.isLittleEndian(), 0);
227    ParseAndDump(Data, /*IsMacro=*/false);
228    break;
229  }
230  case MacinfoDwoSection: {
231    DWARFDataExtractor Data(DObj.getMacinfoDWOSection(), D.isLittleEndian(), 0);
232    ParseAndDump(Data, /*IsMacro=*/false);
233    break;
234  }
235  case MacroSection: {
236    DWARFDataExtractor Data(DObj, DObj.getMacroSection(), D.isLittleEndian(),
237                            0);
238    ParseAndDump(Data, /*IsMacro=*/true);
239    break;
240  }
241  case MacroDwoSection: {
242    DWARFDataExtractor Data(DObj.getMacroDWOSection(), D.isLittleEndian(), 0);
243    ParseAndDump(Data, /*IsMacro=*/true);
244    break;
245  }
246  }
247  return Macro;
248}
249
250class ThreadUnsafeDWARFContextState : public DWARFContext::DWARFContextState {
251
252  DWARFUnitVector NormalUnits;
253  std::optional<DenseMap<uint64_t, DWARFTypeUnit *>> NormalTypeUnits;
254  std::unique_ptr<DWARFUnitIndex> CUIndex;
255  std::unique_ptr<DWARFGdbIndex> GdbIndex;
256  std::unique_ptr<DWARFUnitIndex> TUIndex;
257  std::unique_ptr<DWARFDebugAbbrev> Abbrev;
258  std::unique_ptr<DWARFDebugLoc> Loc;
259  std::unique_ptr<DWARFDebugAranges> Aranges;
260  std::unique_ptr<DWARFDebugLine> Line;
261  std::unique_ptr<DWARFDebugFrame> DebugFrame;
262  std::unique_ptr<DWARFDebugFrame> EHFrame;
263  std::unique_ptr<DWARFDebugMacro> Macro;
264  std::unique_ptr<DWARFDebugMacro> Macinfo;
265  std::unique_ptr<DWARFDebugNames> Names;
266  std::unique_ptr<AppleAcceleratorTable> AppleNames;
267  std::unique_ptr<AppleAcceleratorTable> AppleTypes;
268  std::unique_ptr<AppleAcceleratorTable> AppleNamespaces;
269  std::unique_ptr<AppleAcceleratorTable> AppleObjC;
270  DWARFUnitVector DWOUnits;
271  std::optional<DenseMap<uint64_t, DWARFTypeUnit *>> DWOTypeUnits;
272  std::unique_ptr<DWARFDebugAbbrev> AbbrevDWO;
273  std::unique_ptr<DWARFDebugMacro> MacinfoDWO;
274  std::unique_ptr<DWARFDebugMacro> MacroDWO;
275  struct DWOFile {
276    object::OwningBinary<object::ObjectFile> File;
277    std::unique_ptr<DWARFContext> Context;
278  };
279  StringMap<std::weak_ptr<DWOFile>> DWOFiles;
280  std::weak_ptr<DWOFile> DWP;
281  bool CheckedForDWP = false;
282  std::string DWPName;
283
284public:
285  ThreadUnsafeDWARFContextState(DWARFContext &DC, std::string &DWP) :
286      DWARFContext::DWARFContextState(DC),
287      DWPName(std::move(DWP)) {}
288
289  DWARFUnitVector &getNormalUnits() override {
290    if (NormalUnits.empty()) {
291      const DWARFObject &DObj = D.getDWARFObj();
292      DObj.forEachInfoSections([&](const DWARFSection &S) {
293        NormalUnits.addUnitsForSection(D, S, DW_SECT_INFO);
294      });
295      NormalUnits.finishedInfoUnits();
296      DObj.forEachTypesSections([&](const DWARFSection &S) {
297        NormalUnits.addUnitsForSection(D, S, DW_SECT_EXT_TYPES);
298      });
299    }
300    return NormalUnits;
301  }
302
303  DWARFUnitVector &getDWOUnits(bool Lazy) override {
304    if (DWOUnits.empty()) {
305      const DWARFObject &DObj = D.getDWARFObj();
306
307      DObj.forEachInfoDWOSections([&](const DWARFSection &S) {
308        DWOUnits.addUnitsForDWOSection(D, S, DW_SECT_INFO, Lazy);
309      });
310      DWOUnits.finishedInfoUnits();
311      DObj.forEachTypesDWOSections([&](const DWARFSection &S) {
312        DWOUnits.addUnitsForDWOSection(D, S, DW_SECT_EXT_TYPES, Lazy);
313      });
314    }
315    return DWOUnits;
316  }
317
318  const DWARFDebugAbbrev *getDebugAbbrevDWO() override {
319    if (AbbrevDWO)
320      return AbbrevDWO.get();
321    const DWARFObject &DObj = D.getDWARFObj();
322    DataExtractor abbrData(DObj.getAbbrevDWOSection(), D.isLittleEndian(), 0);
323    AbbrevDWO = std::make_unique<DWARFDebugAbbrev>(abbrData);
324    return AbbrevDWO.get();
325  }
326
327  const DWARFUnitIndex &getCUIndex() override {
328    if (CUIndex)
329      return *CUIndex;
330
331    DataExtractor Data(D.getDWARFObj().getCUIndexSection(),
332                       D.isLittleEndian(), 0);
333    CUIndex = std::make_unique<DWARFUnitIndex>(DW_SECT_INFO);
334    if (CUIndex->parse(Data))
335      fixupIndex(D, *CUIndex);
336    return *CUIndex;
337  }
338  const DWARFUnitIndex &getTUIndex() override {
339    if (TUIndex)
340      return *TUIndex;
341
342    DataExtractor Data(D.getDWARFObj().getTUIndexSection(),
343                       D.isLittleEndian(), 0);
344    TUIndex = std::make_unique<DWARFUnitIndex>(DW_SECT_EXT_TYPES);
345    bool isParseSuccessful = TUIndex->parse(Data);
346    // If we are parsing TU-index and for .debug_types section we don't need
347    // to do anything.
348    if (isParseSuccessful && TUIndex->getVersion() != 2)
349      fixupIndex(D, *TUIndex);
350    return *TUIndex;
351  }
352
353  DWARFGdbIndex &getGdbIndex() override {
354    if (GdbIndex)
355      return *GdbIndex;
356
357    DataExtractor Data(D.getDWARFObj().getGdbIndexSection(), true /*LE*/, 0);
358    GdbIndex = std::make_unique<DWARFGdbIndex>();
359    GdbIndex->parse(Data);
360    return *GdbIndex;
361  }
362
363  const DWARFDebugAbbrev *getDebugAbbrev() override {
364    if (Abbrev)
365      return Abbrev.get();
366
367    DataExtractor Data(D.getDWARFObj().getAbbrevSection(),
368                       D.isLittleEndian(), 0);
369    Abbrev = std::make_unique<DWARFDebugAbbrev>(Data);
370    return Abbrev.get();
371  }
372
373  const DWARFDebugLoc *getDebugLoc() override {
374    if (Loc)
375      return Loc.get();
376
377    const DWARFObject &DObj = D.getDWARFObj();
378    // Assume all units have the same address byte size.
379    auto Data =
380        D.getNumCompileUnits()
381            ? DWARFDataExtractor(DObj, DObj.getLocSection(), D.isLittleEndian(),
382                                 D.getUnitAtIndex(0)->getAddressByteSize())
383            : DWARFDataExtractor("", D.isLittleEndian(), 0);
384    Loc = std::make_unique<DWARFDebugLoc>(std::move(Data));
385    return Loc.get();
386  }
387
388  const DWARFDebugAranges *getDebugAranges() override {
389    if (Aranges)
390      return Aranges.get();
391
392    Aranges = std::make_unique<DWARFDebugAranges>();
393    Aranges->generate(&D);
394    return Aranges.get();
395  }
396
397  Expected<const DWARFDebugLine::LineTable *>
398  getLineTableForUnit(DWARFUnit *U, function_ref<void(Error)> RecoverableErrorHandler) override {
399    if (!Line)
400      Line = std::make_unique<DWARFDebugLine>();
401
402    auto UnitDIE = U->getUnitDIE();
403    if (!UnitDIE)
404      return nullptr;
405
406    auto Offset = toSectionOffset(UnitDIE.find(DW_AT_stmt_list));
407    if (!Offset)
408      return nullptr; // No line table for this compile unit.
409
410    uint64_t stmtOffset = *Offset + U->getLineTableOffset();
411    // See if the line table is cached.
412    if (const DWARFLineTable *lt = Line->getLineTable(stmtOffset))
413      return lt;
414
415    // Make sure the offset is good before we try to parse.
416    if (stmtOffset >= U->getLineSection().Data.size())
417      return nullptr;
418
419    // We have to parse it first.
420    DWARFDataExtractor Data(U->getContext().getDWARFObj(), U->getLineSection(),
421                            U->isLittleEndian(), U->getAddressByteSize());
422    return Line->getOrParseLineTable(Data, stmtOffset, U->getContext(), U,
423                                     RecoverableErrorHandler);
424
425  }
426
427  void clearLineTableForUnit(DWARFUnit *U) override {
428    if (!Line)
429      return;
430
431    auto UnitDIE = U->getUnitDIE();
432    if (!UnitDIE)
433      return;
434
435    auto Offset = toSectionOffset(UnitDIE.find(DW_AT_stmt_list));
436    if (!Offset)
437      return;
438
439    uint64_t stmtOffset = *Offset + U->getLineTableOffset();
440    Line->clearLineTable(stmtOffset);
441  }
442
443  Expected<const DWARFDebugFrame *> getDebugFrame() override {
444    if (DebugFrame)
445      return DebugFrame.get();
446    const DWARFObject &DObj = D.getDWARFObj();
447    const DWARFSection &DS = DObj.getFrameSection();
448
449    // There's a "bug" in the DWARFv3 standard with respect to the target address
450    // size within debug frame sections. While DWARF is supposed to be independent
451    // of its container, FDEs have fields with size being "target address size",
452    // which isn't specified in DWARF in general. It's only specified for CUs, but
453    // .eh_frame can appear without a .debug_info section. Follow the example of
454    // other tools (libdwarf) and extract this from the container (ObjectFile
455    // provides this information). This problem is fixed in DWARFv4
456    // See this dwarf-discuss discussion for more details:
457    // http://lists.dwarfstd.org/htdig.cgi/dwarf-discuss-dwarfstd.org/2011-December/001173.html
458    DWARFDataExtractor Data(DObj, DS, D.isLittleEndian(),
459                            DObj.getAddressSize());
460    auto DF =
461        std::make_unique<DWARFDebugFrame>(D.getArch(), /*IsEH=*/false,
462                                          DS.Address);
463    if (Error E = DF->parse(Data))
464      return std::move(E);
465
466    DebugFrame.swap(DF);
467    return DebugFrame.get();
468  }
469
470  Expected<const DWARFDebugFrame *> getEHFrame() override {
471    if (EHFrame)
472      return EHFrame.get();
473    const DWARFObject &DObj = D.getDWARFObj();
474
475    const DWARFSection &DS = DObj.getEHFrameSection();
476    DWARFDataExtractor Data(DObj, DS, D.isLittleEndian(),
477                            DObj.getAddressSize());
478    auto DF =
479        std::make_unique<DWARFDebugFrame>(D.getArch(), /*IsEH=*/true,
480                                          DS.Address);
481    if (Error E = DF->parse(Data))
482      return std::move(E);
483    EHFrame.swap(DF);
484    return EHFrame.get();
485  }
486
487  const DWARFDebugMacro *getDebugMacinfo() override {
488    if (!Macinfo)
489      Macinfo = parseMacroOrMacinfo(MacinfoSection);
490    return Macinfo.get();
491  }
492  const DWARFDebugMacro *getDebugMacinfoDWO() override {
493    if (!MacinfoDWO)
494      MacinfoDWO = parseMacroOrMacinfo(MacinfoDwoSection);
495    return MacinfoDWO.get();
496  }
497  const DWARFDebugMacro *getDebugMacro() override {
498    if (!Macro)
499      Macro = parseMacroOrMacinfo(MacroSection);
500    return Macro.get();
501  }
502  const DWARFDebugMacro *getDebugMacroDWO() override {
503    if (!MacroDWO)
504      MacroDWO = parseMacroOrMacinfo(MacroDwoSection);
505    return MacroDWO.get();
506  }
507  const DWARFDebugNames &getDebugNames() override {
508    const DWARFObject &DObj = D.getDWARFObj();
509    return getAccelTable(Names, DObj, DObj.getNamesSection(),
510                         DObj.getStrSection(), D.isLittleEndian());
511  }
512  const AppleAcceleratorTable &getAppleNames() override {
513    const DWARFObject &DObj = D.getDWARFObj();
514    return getAccelTable(AppleNames, DObj, DObj.getAppleNamesSection(),
515                         DObj.getStrSection(), D.isLittleEndian());
516
517  }
518  const AppleAcceleratorTable &getAppleTypes() override {
519    const DWARFObject &DObj = D.getDWARFObj();
520    return getAccelTable(AppleTypes, DObj, DObj.getAppleTypesSection(),
521                         DObj.getStrSection(), D.isLittleEndian());
522
523  }
524  const AppleAcceleratorTable &getAppleNamespaces() override {
525    const DWARFObject &DObj = D.getDWARFObj();
526    return getAccelTable(AppleNamespaces, DObj,
527                         DObj.getAppleNamespacesSection(),
528                         DObj.getStrSection(), D.isLittleEndian());
529
530  }
531  const AppleAcceleratorTable &getAppleObjC() override {
532    const DWARFObject &DObj = D.getDWARFObj();
533    return getAccelTable(AppleObjC, DObj, DObj.getAppleObjCSection(),
534                         DObj.getStrSection(), D.isLittleEndian());
535  }
536
537  std::shared_ptr<DWARFContext>
538  getDWOContext(StringRef AbsolutePath) override {
539    if (auto S = DWP.lock()) {
540      DWARFContext *Ctxt = S->Context.get();
541      return std::shared_ptr<DWARFContext>(std::move(S), Ctxt);
542    }
543
544    std::weak_ptr<DWOFile> *Entry = &DWOFiles[AbsolutePath];
545
546    if (auto S = Entry->lock()) {
547      DWARFContext *Ctxt = S->Context.get();
548      return std::shared_ptr<DWARFContext>(std::move(S), Ctxt);
549    }
550
551    const DWARFObject &DObj = D.getDWARFObj();
552
553    Expected<OwningBinary<ObjectFile>> Obj = [&] {
554      if (!CheckedForDWP) {
555        SmallString<128> DWPName;
556        auto Obj = object::ObjectFile::createObjectFile(
557            this->DWPName.empty()
558                ? (DObj.getFileName() + ".dwp").toStringRef(DWPName)
559                : StringRef(this->DWPName));
560        if (Obj) {
561          Entry = &DWP;
562          return Obj;
563        } else {
564          CheckedForDWP = true;
565          // TODO: Should this error be handled (maybe in a high verbosity mode)
566          // before falling back to .dwo files?
567          consumeError(Obj.takeError());
568        }
569      }
570
571      return object::ObjectFile::createObjectFile(AbsolutePath);
572    }();
573
574    if (!Obj) {
575      // TODO: Actually report errors helpfully.
576      consumeError(Obj.takeError());
577      return nullptr;
578    }
579
580    auto S = std::make_shared<DWOFile>();
581    S->File = std::move(Obj.get());
582    // Allow multi-threaded access if there is a .dwp file as the CU index and
583    // TU index might be accessed from multiple threads.
584    bool ThreadSafe = isThreadSafe();
585    S->Context = DWARFContext::create(
586        *S->File.getBinary(), DWARFContext::ProcessDebugRelocations::Ignore,
587        nullptr, "", WithColor::defaultErrorHandler,
588        WithColor::defaultWarningHandler, ThreadSafe);
589    *Entry = S;
590    auto *Ctxt = S->Context.get();
591    return std::shared_ptr<DWARFContext>(std::move(S), Ctxt);
592  }
593
594  bool isThreadSafe() const override { return false; }
595
596  const DenseMap<uint64_t, DWARFTypeUnit *> &getNormalTypeUnitMap() {
597    if (!NormalTypeUnits) {
598      NormalTypeUnits.emplace();
599      for (const auto &U :D.normal_units()) {
600        if (DWARFTypeUnit *TU = dyn_cast<DWARFTypeUnit>(U.get()))
601          (*NormalTypeUnits)[TU->getTypeHash()] = TU;
602      }
603    }
604    return *NormalTypeUnits;
605  }
606
607  const DenseMap<uint64_t, DWARFTypeUnit *> &getDWOTypeUnitMap() {
608    if (!DWOTypeUnits) {
609      DWOTypeUnits.emplace();
610      for (const auto &U :D.dwo_units()) {
611        if (DWARFTypeUnit *TU = dyn_cast<DWARFTypeUnit>(U.get()))
612          (*DWOTypeUnits)[TU->getTypeHash()] = TU;
613      }
614    }
615    return *DWOTypeUnits;
616  }
617
618  const DenseMap<uint64_t, DWARFTypeUnit *> &
619  getTypeUnitMap(bool IsDWO) override {
620    if (IsDWO)
621      return getDWOTypeUnitMap();
622    else
623      return getNormalTypeUnitMap();
624  }
625
626
627};
628
629class ThreadSafeState : public ThreadUnsafeDWARFContextState {
630  std::recursive_mutex Mutex;
631
632public:
633  ThreadSafeState(DWARFContext &DC, std::string &DWP) :
634      ThreadUnsafeDWARFContextState(DC, DWP) {}
635
636  DWARFUnitVector &getNormalUnits() override {
637    std::unique_lock<std::recursive_mutex> LockGuard(Mutex);
638    return ThreadUnsafeDWARFContextState::getNormalUnits();
639  }
640  DWARFUnitVector &getDWOUnits(bool Lazy) override {
641    std::unique_lock<std::recursive_mutex> LockGuard(Mutex);
642    // We need to not do lazy parsing when we need thread safety as
643    // DWARFUnitVector, in lazy mode, will slowly add things to itself and
644    // will cause problems in a multi-threaded environment.
645    return ThreadUnsafeDWARFContextState::getDWOUnits(false);
646  }
647  const DWARFUnitIndex &getCUIndex() override {
648    std::unique_lock<std::recursive_mutex> LockGuard(Mutex);
649    return ThreadUnsafeDWARFContextState::getCUIndex();
650  }
651  const DWARFDebugAbbrev *getDebugAbbrevDWO() override {
652    std::unique_lock<std::recursive_mutex> LockGuard(Mutex);
653    return ThreadUnsafeDWARFContextState::getDebugAbbrevDWO();
654  }
655
656  const DWARFUnitIndex &getTUIndex() override {
657    std::unique_lock<std::recursive_mutex> LockGuard(Mutex);
658    return ThreadUnsafeDWARFContextState::getTUIndex();
659  }
660  DWARFGdbIndex &getGdbIndex() override {
661    std::unique_lock<std::recursive_mutex> LockGuard(Mutex);
662    return ThreadUnsafeDWARFContextState::getGdbIndex();
663  }
664  const DWARFDebugAbbrev *getDebugAbbrev() override {
665    std::unique_lock<std::recursive_mutex> LockGuard(Mutex);
666    return ThreadUnsafeDWARFContextState::getDebugAbbrev();
667  }
668  const DWARFDebugLoc *getDebugLoc() override {
669    std::unique_lock<std::recursive_mutex> LockGuard(Mutex);
670    return ThreadUnsafeDWARFContextState::getDebugLoc();
671  }
672  const DWARFDebugAranges *getDebugAranges() override {
673    std::unique_lock<std::recursive_mutex> LockGuard(Mutex);
674    return ThreadUnsafeDWARFContextState::getDebugAranges();
675  }
676  Expected<const DWARFDebugLine::LineTable *>
677  getLineTableForUnit(DWARFUnit *U, function_ref<void(Error)> RecoverableErrorHandler) override {
678    std::unique_lock<std::recursive_mutex> LockGuard(Mutex);
679    return ThreadUnsafeDWARFContextState::getLineTableForUnit(U, RecoverableErrorHandler);
680  }
681  void clearLineTableForUnit(DWARFUnit *U) override {
682    std::unique_lock<std::recursive_mutex> LockGuard(Mutex);
683    return ThreadUnsafeDWARFContextState::clearLineTableForUnit(U);
684  }
685  Expected<const DWARFDebugFrame *> getDebugFrame() override {
686    std::unique_lock<std::recursive_mutex> LockGuard(Mutex);
687    return ThreadUnsafeDWARFContextState::getDebugFrame();
688  }
689  Expected<const DWARFDebugFrame *> getEHFrame() override {
690    std::unique_lock<std::recursive_mutex> LockGuard(Mutex);
691    return ThreadUnsafeDWARFContextState::getEHFrame();
692  }
693  const DWARFDebugMacro *getDebugMacinfo() override {
694    std::unique_lock<std::recursive_mutex> LockGuard(Mutex);
695    return ThreadUnsafeDWARFContextState::getDebugMacinfo();
696  }
697  const DWARFDebugMacro *getDebugMacinfoDWO() override {
698    std::unique_lock<std::recursive_mutex> LockGuard(Mutex);
699    return ThreadUnsafeDWARFContextState::getDebugMacinfoDWO();
700  }
701  const DWARFDebugMacro *getDebugMacro() override {
702    std::unique_lock<std::recursive_mutex> LockGuard(Mutex);
703    return ThreadUnsafeDWARFContextState::getDebugMacro();
704  }
705  const DWARFDebugMacro *getDebugMacroDWO() override {
706    std::unique_lock<std::recursive_mutex> LockGuard(Mutex);
707    return ThreadUnsafeDWARFContextState::getDebugMacroDWO();
708  }
709  const DWARFDebugNames &getDebugNames() override {
710    std::unique_lock<std::recursive_mutex> LockGuard(Mutex);
711    return ThreadUnsafeDWARFContextState::getDebugNames();
712  }
713  const AppleAcceleratorTable &getAppleNames() override {
714    std::unique_lock<std::recursive_mutex> LockGuard(Mutex);
715    return ThreadUnsafeDWARFContextState::getAppleNames();
716  }
717  const AppleAcceleratorTable &getAppleTypes() override {
718    std::unique_lock<std::recursive_mutex> LockGuard(Mutex);
719    return ThreadUnsafeDWARFContextState::getAppleTypes();
720  }
721  const AppleAcceleratorTable &getAppleNamespaces() override {
722    std::unique_lock<std::recursive_mutex> LockGuard(Mutex);
723    return ThreadUnsafeDWARFContextState::getAppleNamespaces();
724  }
725  const AppleAcceleratorTable &getAppleObjC() override {
726    std::unique_lock<std::recursive_mutex> LockGuard(Mutex);
727    return ThreadUnsafeDWARFContextState::getAppleObjC();
728  }
729  std::shared_ptr<DWARFContext>
730  getDWOContext(StringRef AbsolutePath) override {
731    std::unique_lock<std::recursive_mutex> LockGuard(Mutex);
732    return ThreadUnsafeDWARFContextState::getDWOContext(AbsolutePath);
733  }
734
735  bool isThreadSafe() const override { return true; }
736
737  const DenseMap<uint64_t, DWARFTypeUnit *> &
738  getTypeUnitMap(bool IsDWO) override {
739    std::unique_lock<std::recursive_mutex> LockGuard(Mutex);
740    return ThreadUnsafeDWARFContextState::getTypeUnitMap(IsDWO);
741  }
742};
743
744
745
746DWARFContext::DWARFContext(std::unique_ptr<const DWARFObject> DObj,
747                           std::string DWPName,
748                           std::function<void(Error)> RecoverableErrorHandler,
749                           std::function<void(Error)> WarningHandler,
750                           bool ThreadSafe)
751    : DIContext(CK_DWARF),
752      RecoverableErrorHandler(RecoverableErrorHandler),
753      WarningHandler(WarningHandler), DObj(std::move(DObj)) {
754        if (ThreadSafe)
755          State = std::make_unique<ThreadSafeState>(*this, DWPName);
756        else
757          State = std::make_unique<ThreadUnsafeDWARFContextState>(*this, DWPName);
758      }
759
760DWARFContext::~DWARFContext() = default;
761
762/// Dump the UUID load command.
763static void dumpUUID(raw_ostream &OS, const ObjectFile &Obj) {
764  auto *MachO = dyn_cast<MachOObjectFile>(&Obj);
765  if (!MachO)
766    return;
767  for (auto LC : MachO->load_commands()) {
768    raw_ostream::uuid_t UUID;
769    if (LC.C.cmd == MachO::LC_UUID) {
770      if (LC.C.cmdsize < sizeof(UUID) + sizeof(LC.C)) {
771        OS << "error: UUID load command is too short.\n";
772        return;
773      }
774      OS << "UUID: ";
775      memcpy(&UUID, LC.Ptr+sizeof(LC.C), sizeof(UUID));
776      OS.write_uuid(UUID);
777      Triple T = MachO->getArchTriple();
778      OS << " (" << T.getArchName() << ')';
779      OS << ' ' << MachO->getFileName() << '\n';
780    }
781  }
782}
783
784using ContributionCollection =
785    std::vector<std::optional<StrOffsetsContributionDescriptor>>;
786
787// Collect all the contributions to the string offsets table from all units,
788// sort them by their starting offsets and remove duplicates.
789static ContributionCollection
790collectContributionData(DWARFContext::unit_iterator_range Units) {
791  ContributionCollection Contributions;
792  for (const auto &U : Units)
793    if (const auto &C = U->getStringOffsetsTableContribution())
794      Contributions.push_back(C);
795  // Sort the contributions so that any invalid ones are placed at
796  // the start of the contributions vector. This way they are reported
797  // first.
798  llvm::sort(Contributions,
799             [](const std::optional<StrOffsetsContributionDescriptor> &L,
800                const std::optional<StrOffsetsContributionDescriptor> &R) {
801               if (L && R)
802                 return L->Base < R->Base;
803               return R.has_value();
804             });
805
806  // Uniquify contributions, as it is possible that units (specifically
807  // type units in dwo or dwp files) share contributions. We don't want
808  // to report them more than once.
809  Contributions.erase(
810      std::unique(Contributions.begin(), Contributions.end(),
811                  [](const std::optional<StrOffsetsContributionDescriptor> &L,
812                     const std::optional<StrOffsetsContributionDescriptor> &R) {
813                    if (L && R)
814                      return L->Base == R->Base && L->Size == R->Size;
815                    return false;
816                  }),
817      Contributions.end());
818  return Contributions;
819}
820
821// Dump a DWARF string offsets section. This may be a DWARF v5 formatted
822// string offsets section, where each compile or type unit contributes a
823// number of entries (string offsets), with each contribution preceded by
824// a header containing size and version number. Alternatively, it may be a
825// monolithic series of string offsets, as generated by the pre-DWARF v5
826// implementation of split DWARF; however, in that case we still need to
827// collect contributions of units because the size of the offsets (4 or 8
828// bytes) depends on the format of the referencing unit (DWARF32 or DWARF64).
829static void dumpStringOffsetsSection(raw_ostream &OS, DIDumpOptions DumpOpts,
830                                     StringRef SectionName,
831                                     const DWARFObject &Obj,
832                                     const DWARFSection &StringOffsetsSection,
833                                     StringRef StringSection,
834                                     DWARFContext::unit_iterator_range Units,
835                                     bool LittleEndian) {
836  auto Contributions = collectContributionData(Units);
837  DWARFDataExtractor StrOffsetExt(Obj, StringOffsetsSection, LittleEndian, 0);
838  DataExtractor StrData(StringSection, LittleEndian, 0);
839  uint64_t SectionSize = StringOffsetsSection.Data.size();
840  uint64_t Offset = 0;
841  for (auto &Contribution : Contributions) {
842    // Report an ill-formed contribution.
843    if (!Contribution) {
844      OS << "error: invalid contribution to string offsets table in section ."
845         << SectionName << ".\n";
846      return;
847    }
848
849    dwarf::DwarfFormat Format = Contribution->getFormat();
850    int OffsetDumpWidth = 2 * dwarf::getDwarfOffsetByteSize(Format);
851    uint16_t Version = Contribution->getVersion();
852    uint64_t ContributionHeader = Contribution->Base;
853    // In DWARF v5 there is a contribution header that immediately precedes
854    // the string offsets base (the location we have previously retrieved from
855    // the CU DIE's DW_AT_str_offsets attribute). The header is located either
856    // 8 or 16 bytes before the base, depending on the contribution's format.
857    if (Version >= 5)
858      ContributionHeader -= Format == DWARF32 ? 8 : 16;
859
860    // Detect overlapping contributions.
861    if (Offset > ContributionHeader) {
862      DumpOpts.RecoverableErrorHandler(createStringError(
863          errc::invalid_argument,
864          "overlapping contributions to string offsets table in section .%s.",
865          SectionName.data()));
866    }
867    // Report a gap in the table.
868    if (Offset < ContributionHeader) {
869      OS << format("0x%8.8" PRIx64 ": Gap, length = ", Offset);
870      OS << (ContributionHeader - Offset) << "\n";
871    }
872    OS << format("0x%8.8" PRIx64 ": ", ContributionHeader);
873    // In DWARF v5 the contribution size in the descriptor does not equal
874    // the originally encoded length (it does not contain the length of the
875    // version field and the padding, a total of 4 bytes). Add them back in
876    // for reporting.
877    OS << "Contribution size = " << (Contribution->Size + (Version < 5 ? 0 : 4))
878       << ", Format = " << dwarf::FormatString(Format)
879       << ", Version = " << Version << "\n";
880
881    Offset = Contribution->Base;
882    unsigned EntrySize = Contribution->getDwarfOffsetByteSize();
883    while (Offset - Contribution->Base < Contribution->Size) {
884      OS << format("0x%8.8" PRIx64 ": ", Offset);
885      uint64_t StringOffset =
886          StrOffsetExt.getRelocatedValue(EntrySize, &Offset);
887      OS << format("%0*" PRIx64 " ", OffsetDumpWidth, StringOffset);
888      const char *S = StrData.getCStr(&StringOffset);
889      if (S)
890        OS << format("\"%s\"", S);
891      OS << "\n";
892    }
893  }
894  // Report a gap at the end of the table.
895  if (Offset < SectionSize) {
896    OS << format("0x%8.8" PRIx64 ": Gap, length = ", Offset);
897    OS << (SectionSize - Offset) << "\n";
898  }
899}
900
901// Dump the .debug_addr section.
902static void dumpAddrSection(raw_ostream &OS, DWARFDataExtractor &AddrData,
903                            DIDumpOptions DumpOpts, uint16_t Version,
904                            uint8_t AddrSize) {
905  uint64_t Offset = 0;
906  while (AddrData.isValidOffset(Offset)) {
907    DWARFDebugAddrTable AddrTable;
908    uint64_t TableOffset = Offset;
909    if (Error Err = AddrTable.extract(AddrData, &Offset, Version, AddrSize,
910                                      DumpOpts.WarningHandler)) {
911      DumpOpts.RecoverableErrorHandler(std::move(Err));
912      // Keep going after an error, if we can, assuming that the length field
913      // could be read. If it couldn't, stop reading the section.
914      if (auto TableLength = AddrTable.getFullLength()) {
915        Offset = TableOffset + *TableLength;
916        continue;
917      }
918      break;
919    }
920    AddrTable.dump(OS, DumpOpts);
921  }
922}
923
924// Dump the .debug_rnglists or .debug_rnglists.dwo section (DWARF v5).
925static void dumpRnglistsSection(
926    raw_ostream &OS, DWARFDataExtractor &rnglistData,
927    llvm::function_ref<std::optional<object::SectionedAddress>(uint32_t)>
928        LookupPooledAddress,
929    DIDumpOptions DumpOpts) {
930  uint64_t Offset = 0;
931  while (rnglistData.isValidOffset(Offset)) {
932    llvm::DWARFDebugRnglistTable Rnglists;
933    uint64_t TableOffset = Offset;
934    if (Error Err = Rnglists.extract(rnglistData, &Offset)) {
935      DumpOpts.RecoverableErrorHandler(std::move(Err));
936      uint64_t Length = Rnglists.length();
937      // Keep going after an error, if we can, assuming that the length field
938      // could be read. If it couldn't, stop reading the section.
939      if (Length == 0)
940        break;
941      Offset = TableOffset + Length;
942    } else {
943      Rnglists.dump(rnglistData, OS, LookupPooledAddress, DumpOpts);
944    }
945  }
946}
947
948
949static void dumpLoclistsSection(raw_ostream &OS, DIDumpOptions DumpOpts,
950                                DWARFDataExtractor Data, const DWARFObject &Obj,
951                                std::optional<uint64_t> DumpOffset) {
952  uint64_t Offset = 0;
953
954  while (Data.isValidOffset(Offset)) {
955    DWARFListTableHeader Header(".debug_loclists", "locations");
956    if (Error E = Header.extract(Data, &Offset)) {
957      DumpOpts.RecoverableErrorHandler(std::move(E));
958      return;
959    }
960
961    Header.dump(Data, OS, DumpOpts);
962
963    uint64_t EndOffset = Header.length() + Header.getHeaderOffset();
964    Data.setAddressSize(Header.getAddrSize());
965    DWARFDebugLoclists Loc(Data, Header.getVersion());
966    if (DumpOffset) {
967      if (DumpOffset >= Offset && DumpOffset < EndOffset) {
968        Offset = *DumpOffset;
969        Loc.dumpLocationList(&Offset, OS, /*BaseAddr=*/std::nullopt, Obj,
970                             nullptr, DumpOpts, /*Indent=*/0);
971        OS << "\n";
972        return;
973      }
974    } else {
975      Loc.dumpRange(Offset, EndOffset - Offset, OS, Obj, DumpOpts);
976    }
977    Offset = EndOffset;
978  }
979}
980
981static void dumpPubTableSection(raw_ostream &OS, DIDumpOptions DumpOpts,
982                                DWARFDataExtractor Data, bool GnuStyle) {
983  DWARFDebugPubTable Table;
984  Table.extract(Data, GnuStyle, DumpOpts.RecoverableErrorHandler);
985  Table.dump(OS);
986}
987
988void DWARFContext::dump(
989    raw_ostream &OS, DIDumpOptions DumpOpts,
990    std::array<std::optional<uint64_t>, DIDT_ID_Count> DumpOffsets) {
991  uint64_t DumpType = DumpOpts.DumpType;
992
993  StringRef Extension = sys::path::extension(DObj->getFileName());
994  bool IsDWO = (Extension == ".dwo") || (Extension == ".dwp");
995
996  // Print UUID header.
997  const auto *ObjFile = DObj->getFile();
998  if (DumpType & DIDT_UUID)
999    dumpUUID(OS, *ObjFile);
1000
1001  // Print a header for each explicitly-requested section.
1002  // Otherwise just print one for non-empty sections.
1003  // Only print empty .dwo section headers when dumping a .dwo file.
1004  bool Explicit = DumpType != DIDT_All && !IsDWO;
1005  bool ExplicitDWO = Explicit && IsDWO;
1006  auto shouldDump = [&](bool Explicit, const char *Name, unsigned ID,
1007                        StringRef Section) -> std::optional<uint64_t> * {
1008    unsigned Mask = 1U << ID;
1009    bool Should = (DumpType & Mask) && (Explicit || !Section.empty());
1010    if (!Should)
1011      return nullptr;
1012    OS << "\n" << Name << " contents:\n";
1013    return &DumpOffsets[ID];
1014  };
1015
1016  // Dump individual sections.
1017  if (shouldDump(Explicit, ".debug_abbrev", DIDT_ID_DebugAbbrev,
1018                 DObj->getAbbrevSection()))
1019    getDebugAbbrev()->dump(OS);
1020  if (shouldDump(ExplicitDWO, ".debug_abbrev.dwo", DIDT_ID_DebugAbbrev,
1021                 DObj->getAbbrevDWOSection()))
1022    getDebugAbbrevDWO()->dump(OS);
1023
1024  auto dumpDebugInfo = [&](const char *Name, unit_iterator_range Units) {
1025    OS << '\n' << Name << " contents:\n";
1026    if (auto DumpOffset = DumpOffsets[DIDT_ID_DebugInfo])
1027      for (const auto &U : Units) {
1028        U->getDIEForOffset(*DumpOffset)
1029            .dump(OS, 0, DumpOpts.noImplicitRecursion());
1030        DWARFDie CUDie = U->getUnitDIE(false);
1031        DWARFDie CUNonSkeletonDie = U->getNonSkeletonUnitDIE(false);
1032        if (CUNonSkeletonDie && CUDie != CUNonSkeletonDie) {
1033          CUNonSkeletonDie.getDwarfUnit()
1034              ->getDIEForOffset(*DumpOffset)
1035              .dump(OS, 0, DumpOpts.noImplicitRecursion());
1036        }
1037      }
1038    else
1039      for (const auto &U : Units)
1040        U->dump(OS, DumpOpts);
1041  };
1042  if ((DumpType & DIDT_DebugInfo)) {
1043    if (Explicit || getNumCompileUnits())
1044      dumpDebugInfo(".debug_info", info_section_units());
1045    if (ExplicitDWO || getNumDWOCompileUnits())
1046      dumpDebugInfo(".debug_info.dwo", dwo_info_section_units());
1047  }
1048
1049  auto dumpDebugType = [&](const char *Name, unit_iterator_range Units) {
1050    OS << '\n' << Name << " contents:\n";
1051    for (const auto &U : Units)
1052      if (auto DumpOffset = DumpOffsets[DIDT_ID_DebugTypes])
1053        U->getDIEForOffset(*DumpOffset)
1054            .dump(OS, 0, DumpOpts.noImplicitRecursion());
1055      else
1056        U->dump(OS, DumpOpts);
1057  };
1058  if ((DumpType & DIDT_DebugTypes)) {
1059    if (Explicit || getNumTypeUnits())
1060      dumpDebugType(".debug_types", types_section_units());
1061    if (ExplicitDWO || getNumDWOTypeUnits())
1062      dumpDebugType(".debug_types.dwo", dwo_types_section_units());
1063  }
1064
1065  DIDumpOptions LLDumpOpts = DumpOpts;
1066  if (LLDumpOpts.Verbose)
1067    LLDumpOpts.DisplayRawContents = true;
1068
1069  if (const auto *Off = shouldDump(Explicit, ".debug_loc", DIDT_ID_DebugLoc,
1070                                   DObj->getLocSection().Data)) {
1071    getDebugLoc()->dump(OS, *DObj, LLDumpOpts, *Off);
1072  }
1073  if (const auto *Off =
1074          shouldDump(Explicit, ".debug_loclists", DIDT_ID_DebugLoclists,
1075                     DObj->getLoclistsSection().Data)) {
1076    DWARFDataExtractor Data(*DObj, DObj->getLoclistsSection(), isLittleEndian(),
1077                            0);
1078    dumpLoclistsSection(OS, LLDumpOpts, Data, *DObj, *Off);
1079  }
1080  if (const auto *Off =
1081          shouldDump(ExplicitDWO, ".debug_loclists.dwo", DIDT_ID_DebugLoclists,
1082                     DObj->getLoclistsDWOSection().Data)) {
1083    DWARFDataExtractor Data(*DObj, DObj->getLoclistsDWOSection(),
1084                            isLittleEndian(), 0);
1085    dumpLoclistsSection(OS, LLDumpOpts, Data, *DObj, *Off);
1086  }
1087
1088  if (const auto *Off =
1089          shouldDump(ExplicitDWO, ".debug_loc.dwo", DIDT_ID_DebugLoc,
1090                     DObj->getLocDWOSection().Data)) {
1091    DWARFDataExtractor Data(*DObj, DObj->getLocDWOSection(), isLittleEndian(),
1092                            4);
1093    DWARFDebugLoclists Loc(Data, /*Version=*/4);
1094    if (*Off) {
1095      uint64_t Offset = **Off;
1096      Loc.dumpLocationList(&Offset, OS,
1097                           /*BaseAddr=*/std::nullopt, *DObj, nullptr,
1098                           LLDumpOpts,
1099                           /*Indent=*/0);
1100      OS << "\n";
1101    } else {
1102      Loc.dumpRange(0, Data.getData().size(), OS, *DObj, LLDumpOpts);
1103    }
1104  }
1105
1106  if (const std::optional<uint64_t> *Off =
1107          shouldDump(Explicit, ".debug_frame", DIDT_ID_DebugFrame,
1108                     DObj->getFrameSection().Data)) {
1109    if (Expected<const DWARFDebugFrame *> DF = getDebugFrame())
1110      (*DF)->dump(OS, DumpOpts, *Off);
1111    else
1112      RecoverableErrorHandler(DF.takeError());
1113  }
1114
1115  if (const std::optional<uint64_t> *Off =
1116          shouldDump(Explicit, ".eh_frame", DIDT_ID_DebugFrame,
1117                     DObj->getEHFrameSection().Data)) {
1118    if (Expected<const DWARFDebugFrame *> DF = getEHFrame())
1119      (*DF)->dump(OS, DumpOpts, *Off);
1120    else
1121      RecoverableErrorHandler(DF.takeError());
1122  }
1123
1124  if (shouldDump(Explicit, ".debug_macro", DIDT_ID_DebugMacro,
1125                 DObj->getMacroSection().Data)) {
1126    if (auto Macro = getDebugMacro())
1127      Macro->dump(OS);
1128  }
1129
1130  if (shouldDump(Explicit, ".debug_macro.dwo", DIDT_ID_DebugMacro,
1131                 DObj->getMacroDWOSection())) {
1132    if (auto MacroDWO = getDebugMacroDWO())
1133      MacroDWO->dump(OS);
1134  }
1135
1136  if (shouldDump(Explicit, ".debug_macinfo", DIDT_ID_DebugMacro,
1137                 DObj->getMacinfoSection())) {
1138    if (auto Macinfo = getDebugMacinfo())
1139      Macinfo->dump(OS);
1140  }
1141
1142  if (shouldDump(Explicit, ".debug_macinfo.dwo", DIDT_ID_DebugMacro,
1143                 DObj->getMacinfoDWOSection())) {
1144    if (auto MacinfoDWO = getDebugMacinfoDWO())
1145      MacinfoDWO->dump(OS);
1146  }
1147
1148  if (shouldDump(Explicit, ".debug_aranges", DIDT_ID_DebugAranges,
1149                 DObj->getArangesSection())) {
1150    uint64_t offset = 0;
1151    DWARFDataExtractor arangesData(DObj->getArangesSection(), isLittleEndian(),
1152                                   0);
1153    DWARFDebugArangeSet set;
1154    while (arangesData.isValidOffset(offset)) {
1155      if (Error E =
1156              set.extract(arangesData, &offset, DumpOpts.WarningHandler)) {
1157        RecoverableErrorHandler(std::move(E));
1158        break;
1159      }
1160      set.dump(OS);
1161    }
1162  }
1163
1164  auto DumpLineSection = [&](DWARFDebugLine::SectionParser Parser,
1165                             DIDumpOptions DumpOpts,
1166                             std::optional<uint64_t> DumpOffset) {
1167    while (!Parser.done()) {
1168      if (DumpOffset && Parser.getOffset() != *DumpOffset) {
1169        Parser.skip(DumpOpts.WarningHandler, DumpOpts.WarningHandler);
1170        continue;
1171      }
1172      OS << "debug_line[" << format("0x%8.8" PRIx64, Parser.getOffset())
1173         << "]\n";
1174      Parser.parseNext(DumpOpts.WarningHandler, DumpOpts.WarningHandler, &OS,
1175                       DumpOpts.Verbose);
1176    }
1177  };
1178
1179  auto DumpStrSection = [&](StringRef Section) {
1180    DataExtractor StrData(Section, isLittleEndian(), 0);
1181    uint64_t Offset = 0;
1182    uint64_t StrOffset = 0;
1183    while (StrData.isValidOffset(Offset)) {
1184      Error Err = Error::success();
1185      const char *CStr = StrData.getCStr(&Offset, &Err);
1186      if (Err) {
1187        DumpOpts.WarningHandler(std::move(Err));
1188        return;
1189      }
1190      OS << format("0x%8.8" PRIx64 ": \"", StrOffset);
1191      OS.write_escaped(CStr);
1192      OS << "\"\n";
1193      StrOffset = Offset;
1194    }
1195  };
1196
1197  if (const auto *Off = shouldDump(Explicit, ".debug_line", DIDT_ID_DebugLine,
1198                                   DObj->getLineSection().Data)) {
1199    DWARFDataExtractor LineData(*DObj, DObj->getLineSection(), isLittleEndian(),
1200                                0);
1201    DWARFDebugLine::SectionParser Parser(LineData, *this, normal_units());
1202    DumpLineSection(Parser, DumpOpts, *Off);
1203  }
1204
1205  if (const auto *Off =
1206          shouldDump(ExplicitDWO, ".debug_line.dwo", DIDT_ID_DebugLine,
1207                     DObj->getLineDWOSection().Data)) {
1208    DWARFDataExtractor LineData(*DObj, DObj->getLineDWOSection(),
1209                                isLittleEndian(), 0);
1210    DWARFDebugLine::SectionParser Parser(LineData, *this, dwo_units());
1211    DumpLineSection(Parser, DumpOpts, *Off);
1212  }
1213
1214  if (shouldDump(Explicit, ".debug_cu_index", DIDT_ID_DebugCUIndex,
1215                 DObj->getCUIndexSection())) {
1216    getCUIndex().dump(OS);
1217  }
1218
1219  if (shouldDump(Explicit, ".debug_tu_index", DIDT_ID_DebugTUIndex,
1220                 DObj->getTUIndexSection())) {
1221    getTUIndex().dump(OS);
1222  }
1223
1224  if (shouldDump(Explicit, ".debug_str", DIDT_ID_DebugStr,
1225                 DObj->getStrSection()))
1226    DumpStrSection(DObj->getStrSection());
1227
1228  if (shouldDump(ExplicitDWO, ".debug_str.dwo", DIDT_ID_DebugStr,
1229                 DObj->getStrDWOSection()))
1230    DumpStrSection(DObj->getStrDWOSection());
1231
1232  if (shouldDump(Explicit, ".debug_line_str", DIDT_ID_DebugLineStr,
1233                 DObj->getLineStrSection()))
1234    DumpStrSection(DObj->getLineStrSection());
1235
1236  if (shouldDump(Explicit, ".debug_addr", DIDT_ID_DebugAddr,
1237                 DObj->getAddrSection().Data)) {
1238    DWARFDataExtractor AddrData(*DObj, DObj->getAddrSection(),
1239                                   isLittleEndian(), 0);
1240    dumpAddrSection(OS, AddrData, DumpOpts, getMaxVersion(), getCUAddrSize());
1241  }
1242
1243  if (shouldDump(Explicit, ".debug_ranges", DIDT_ID_DebugRanges,
1244                 DObj->getRangesSection().Data)) {
1245    uint8_t savedAddressByteSize = getCUAddrSize();
1246    DWARFDataExtractor rangesData(*DObj, DObj->getRangesSection(),
1247                                  isLittleEndian(), savedAddressByteSize);
1248    uint64_t offset = 0;
1249    DWARFDebugRangeList rangeList;
1250    while (rangesData.isValidOffset(offset)) {
1251      if (Error E = rangeList.extract(rangesData, &offset)) {
1252        DumpOpts.RecoverableErrorHandler(std::move(E));
1253        break;
1254      }
1255      rangeList.dump(OS);
1256    }
1257  }
1258
1259  auto LookupPooledAddress =
1260      [&](uint32_t Index) -> std::optional<SectionedAddress> {
1261    const auto &CUs = compile_units();
1262    auto I = CUs.begin();
1263    if (I == CUs.end())
1264      return std::nullopt;
1265    return (*I)->getAddrOffsetSectionItem(Index);
1266  };
1267
1268  if (shouldDump(Explicit, ".debug_rnglists", DIDT_ID_DebugRnglists,
1269                 DObj->getRnglistsSection().Data)) {
1270    DWARFDataExtractor RnglistData(*DObj, DObj->getRnglistsSection(),
1271                                   isLittleEndian(), 0);
1272    dumpRnglistsSection(OS, RnglistData, LookupPooledAddress, DumpOpts);
1273  }
1274
1275  if (shouldDump(ExplicitDWO, ".debug_rnglists.dwo", DIDT_ID_DebugRnglists,
1276                 DObj->getRnglistsDWOSection().Data)) {
1277    DWARFDataExtractor RnglistData(*DObj, DObj->getRnglistsDWOSection(),
1278                                   isLittleEndian(), 0);
1279    dumpRnglistsSection(OS, RnglistData, LookupPooledAddress, DumpOpts);
1280  }
1281
1282  if (shouldDump(Explicit, ".debug_pubnames", DIDT_ID_DebugPubnames,
1283                 DObj->getPubnamesSection().Data)) {
1284    DWARFDataExtractor PubTableData(*DObj, DObj->getPubnamesSection(),
1285                                    isLittleEndian(), 0);
1286    dumpPubTableSection(OS, DumpOpts, PubTableData, /*GnuStyle=*/false);
1287  }
1288
1289  if (shouldDump(Explicit, ".debug_pubtypes", DIDT_ID_DebugPubtypes,
1290                 DObj->getPubtypesSection().Data)) {
1291    DWARFDataExtractor PubTableData(*DObj, DObj->getPubtypesSection(),
1292                                    isLittleEndian(), 0);
1293    dumpPubTableSection(OS, DumpOpts, PubTableData, /*GnuStyle=*/false);
1294  }
1295
1296  if (shouldDump(Explicit, ".debug_gnu_pubnames", DIDT_ID_DebugGnuPubnames,
1297                 DObj->getGnuPubnamesSection().Data)) {
1298    DWARFDataExtractor PubTableData(*DObj, DObj->getGnuPubnamesSection(),
1299                                    isLittleEndian(), 0);
1300    dumpPubTableSection(OS, DumpOpts, PubTableData, /*GnuStyle=*/true);
1301  }
1302
1303  if (shouldDump(Explicit, ".debug_gnu_pubtypes", DIDT_ID_DebugGnuPubtypes,
1304                 DObj->getGnuPubtypesSection().Data)) {
1305    DWARFDataExtractor PubTableData(*DObj, DObj->getGnuPubtypesSection(),
1306                                    isLittleEndian(), 0);
1307    dumpPubTableSection(OS, DumpOpts, PubTableData, /*GnuStyle=*/true);
1308  }
1309
1310  if (shouldDump(Explicit, ".debug_str_offsets", DIDT_ID_DebugStrOffsets,
1311                 DObj->getStrOffsetsSection().Data))
1312    dumpStringOffsetsSection(
1313        OS, DumpOpts, "debug_str_offsets", *DObj, DObj->getStrOffsetsSection(),
1314        DObj->getStrSection(), normal_units(), isLittleEndian());
1315  if (shouldDump(ExplicitDWO, ".debug_str_offsets.dwo", DIDT_ID_DebugStrOffsets,
1316                 DObj->getStrOffsetsDWOSection().Data))
1317    dumpStringOffsetsSection(OS, DumpOpts, "debug_str_offsets.dwo", *DObj,
1318                             DObj->getStrOffsetsDWOSection(),
1319                             DObj->getStrDWOSection(), dwo_units(),
1320                             isLittleEndian());
1321
1322  if (shouldDump(Explicit, ".gdb_index", DIDT_ID_GdbIndex,
1323                 DObj->getGdbIndexSection())) {
1324    getGdbIndex().dump(OS);
1325  }
1326
1327  if (shouldDump(Explicit, ".apple_names", DIDT_ID_AppleNames,
1328                 DObj->getAppleNamesSection().Data))
1329    getAppleNames().dump(OS);
1330
1331  if (shouldDump(Explicit, ".apple_types", DIDT_ID_AppleTypes,
1332                 DObj->getAppleTypesSection().Data))
1333    getAppleTypes().dump(OS);
1334
1335  if (shouldDump(Explicit, ".apple_namespaces", DIDT_ID_AppleNamespaces,
1336                 DObj->getAppleNamespacesSection().Data))
1337    getAppleNamespaces().dump(OS);
1338
1339  if (shouldDump(Explicit, ".apple_objc", DIDT_ID_AppleObjC,
1340                 DObj->getAppleObjCSection().Data))
1341    getAppleObjC().dump(OS);
1342  if (shouldDump(Explicit, ".debug_names", DIDT_ID_DebugNames,
1343                 DObj->getNamesSection().Data))
1344    getDebugNames().dump(OS);
1345}
1346
1347DWARFTypeUnit *DWARFContext::getTypeUnitForHash(uint16_t Version, uint64_t Hash,
1348                                                bool IsDWO) {
1349  DWARFUnitVector &DWOUnits = State->getDWOUnits();
1350  if (const auto &TUI = getTUIndex()) {
1351    if (const auto *R = TUI.getFromHash(Hash))
1352      return dyn_cast_or_null<DWARFTypeUnit>(
1353          DWOUnits.getUnitForIndexEntry(*R));
1354    return nullptr;
1355  }
1356  return State->getTypeUnitMap(IsDWO).lookup(Hash);
1357}
1358
1359DWARFCompileUnit *DWARFContext::getDWOCompileUnitForHash(uint64_t Hash) {
1360  DWARFUnitVector &DWOUnits = State->getDWOUnits(LazyParse);
1361
1362  if (const auto &CUI = getCUIndex()) {
1363    if (const auto *R = CUI.getFromHash(Hash))
1364      return dyn_cast_or_null<DWARFCompileUnit>(
1365          DWOUnits.getUnitForIndexEntry(*R));
1366    return nullptr;
1367  }
1368
1369  // If there's no index, just search through the CUs in the DWO - there's
1370  // probably only one unless this is something like LTO - though an in-process
1371  // built/cached lookup table could be used in that case to improve repeated
1372  // lookups of different CUs in the DWO.
1373  for (const auto &DWOCU : dwo_compile_units()) {
1374    // Might not have parsed DWO ID yet.
1375    if (!DWOCU->getDWOId()) {
1376      if (std::optional<uint64_t> DWOId =
1377              toUnsigned(DWOCU->getUnitDIE().find(DW_AT_GNU_dwo_id)))
1378        DWOCU->setDWOId(*DWOId);
1379      else
1380        // No DWO ID?
1381        continue;
1382    }
1383    if (DWOCU->getDWOId() == Hash)
1384      return dyn_cast<DWARFCompileUnit>(DWOCU.get());
1385  }
1386  return nullptr;
1387}
1388
1389DWARFDie DWARFContext::getDIEForOffset(uint64_t Offset) {
1390  if (auto *CU = State->getNormalUnits().getUnitForOffset(Offset))
1391    return CU->getDIEForOffset(Offset);
1392  return DWARFDie();
1393}
1394
1395bool DWARFContext::verify(raw_ostream &OS, DIDumpOptions DumpOpts) {
1396  bool Success = true;
1397  DWARFVerifier verifier(OS, *this, DumpOpts);
1398
1399  Success &= verifier.handleDebugAbbrev();
1400  if (DumpOpts.DumpType & DIDT_DebugCUIndex)
1401    Success &= verifier.handleDebugCUIndex();
1402  if (DumpOpts.DumpType & DIDT_DebugTUIndex)
1403    Success &= verifier.handleDebugTUIndex();
1404  if (DumpOpts.DumpType & DIDT_DebugInfo)
1405    Success &= verifier.handleDebugInfo();
1406  if (DumpOpts.DumpType & DIDT_DebugLine)
1407    Success &= verifier.handleDebugLine();
1408  if (DumpOpts.DumpType & DIDT_DebugStrOffsets)
1409    Success &= verifier.handleDebugStrOffsets();
1410  Success &= verifier.handleAccelTables();
1411  return Success;
1412}
1413
1414const DWARFUnitIndex &DWARFContext::getCUIndex() {
1415  return State->getCUIndex();
1416}
1417
1418const DWARFUnitIndex &DWARFContext::getTUIndex() {
1419  return State->getTUIndex();
1420}
1421
1422DWARFGdbIndex &DWARFContext::getGdbIndex() {
1423  return State->getGdbIndex();
1424}
1425
1426const DWARFDebugAbbrev *DWARFContext::getDebugAbbrev() {
1427  return State->getDebugAbbrev();
1428}
1429
1430const DWARFDebugAbbrev *DWARFContext::getDebugAbbrevDWO() {
1431  return State->getDebugAbbrevDWO();
1432}
1433
1434const DWARFDebugLoc *DWARFContext::getDebugLoc() {
1435  return State->getDebugLoc();
1436}
1437
1438const DWARFDebugAranges *DWARFContext::getDebugAranges() {
1439  return State->getDebugAranges();
1440}
1441
1442Expected<const DWARFDebugFrame *> DWARFContext::getDebugFrame() {
1443  return State->getDebugFrame();
1444}
1445
1446Expected<const DWARFDebugFrame *> DWARFContext::getEHFrame() {
1447  return State->getEHFrame();
1448}
1449
1450const DWARFDebugMacro *DWARFContext::getDebugMacro() {
1451  return State->getDebugMacro();
1452}
1453
1454const DWARFDebugMacro *DWARFContext::getDebugMacroDWO() {
1455  return State->getDebugMacroDWO();
1456}
1457
1458const DWARFDebugMacro *DWARFContext::getDebugMacinfo() {
1459  return State->getDebugMacinfo();
1460}
1461
1462const DWARFDebugMacro *DWARFContext::getDebugMacinfoDWO() {
1463  return State->getDebugMacinfoDWO();
1464}
1465
1466
1467const DWARFDebugNames &DWARFContext::getDebugNames() {
1468  return State->getDebugNames();
1469}
1470
1471const AppleAcceleratorTable &DWARFContext::getAppleNames() {
1472  return State->getAppleNames();
1473}
1474
1475const AppleAcceleratorTable &DWARFContext::getAppleTypes() {
1476  return State->getAppleTypes();
1477}
1478
1479const AppleAcceleratorTable &DWARFContext::getAppleNamespaces() {
1480  return State->getAppleNamespaces();
1481}
1482
1483const AppleAcceleratorTable &DWARFContext::getAppleObjC() {
1484  return State->getAppleObjC();
1485}
1486
1487const DWARFDebugLine::LineTable *
1488DWARFContext::getLineTableForUnit(DWARFUnit *U) {
1489  Expected<const DWARFDebugLine::LineTable *> ExpectedLineTable =
1490      getLineTableForUnit(U, WarningHandler);
1491  if (!ExpectedLineTable) {
1492    WarningHandler(ExpectedLineTable.takeError());
1493    return nullptr;
1494  }
1495  return *ExpectedLineTable;
1496}
1497
1498Expected<const DWARFDebugLine::LineTable *> DWARFContext::getLineTableForUnit(
1499    DWARFUnit *U, function_ref<void(Error)> RecoverableErrorHandler) {
1500  return State->getLineTableForUnit(U, RecoverableErrorHandler);
1501}
1502
1503void DWARFContext::clearLineTableForUnit(DWARFUnit *U) {
1504  return State->clearLineTableForUnit(U);
1505}
1506
1507DWARFUnitVector &DWARFContext::getDWOUnits(bool Lazy) {
1508  return State->getDWOUnits(Lazy);
1509}
1510
1511DWARFCompileUnit *DWARFContext::getCompileUnitForOffset(uint64_t Offset) {
1512  return dyn_cast_or_null<DWARFCompileUnit>(
1513      State->getNormalUnits().getUnitForOffset(Offset));
1514}
1515
1516DWARFCompileUnit *DWARFContext::getCompileUnitForCodeAddress(uint64_t Address) {
1517  uint64_t CUOffset = getDebugAranges()->findAddress(Address);
1518  return getCompileUnitForOffset(CUOffset);
1519}
1520
1521DWARFCompileUnit *DWARFContext::getCompileUnitForDataAddress(uint64_t Address) {
1522  uint64_t CUOffset = getDebugAranges()->findAddress(Address);
1523  if (DWARFCompileUnit *OffsetCU = getCompileUnitForOffset(CUOffset))
1524    return OffsetCU;
1525
1526  // Global variables are often missed by the above search, for one of two
1527  // reasons:
1528  //   1. .debug_aranges may not include global variables. On clang, it seems we
1529  //      put the globals in the aranges, but this isn't true for gcc.
1530  //   2. Even if the global variable is in a .debug_arange, global variables
1531  //      may not be captured in the [start, end) addresses described by the
1532  //      parent compile unit.
1533  //
1534  // So, we walk the CU's and their child DI's manually, looking for the
1535  // specific global variable.
1536  for (std::unique_ptr<DWARFUnit> &CU : compile_units()) {
1537    if (CU->getVariableForAddress(Address)) {
1538      return static_cast<DWARFCompileUnit *>(CU.get());
1539    }
1540  }
1541  return nullptr;
1542}
1543
1544DWARFContext::DIEsForAddress DWARFContext::getDIEsForAddress(uint64_t Address,
1545                                                             bool CheckDWO) {
1546  DIEsForAddress Result;
1547
1548  DWARFCompileUnit *CU = getCompileUnitForCodeAddress(Address);
1549  if (!CU)
1550    return Result;
1551
1552  if (CheckDWO) {
1553    // We were asked to check the DWO file and this debug information is more
1554    // complete that any information in the skeleton compile unit, so search the
1555    // DWO first to see if we have a match.
1556    DWARFDie CUDie = CU->getUnitDIE(false);
1557    DWARFDie CUDwoDie = CU->getNonSkeletonUnitDIE(false);
1558    if (CheckDWO && CUDwoDie && CUDie != CUDwoDie) {
1559      // We have a DWO file, lets search it.
1560      DWARFCompileUnit *CUDwo =
1561          dyn_cast_or_null<DWARFCompileUnit>(CUDwoDie.getDwarfUnit());
1562      if (CUDwo) {
1563        Result.FunctionDIE = CUDwo->getSubroutineForAddress(Address);
1564        if (Result.FunctionDIE)
1565          Result.CompileUnit = CUDwo;
1566      }
1567    }
1568  }
1569
1570  // Search the normal DWARF if we didn't find a match in the DWO file or if
1571  // we didn't check the DWO file above.
1572  if (!Result) {
1573    Result.CompileUnit = CU;
1574    Result.FunctionDIE = CU->getSubroutineForAddress(Address);
1575  }
1576
1577  std::vector<DWARFDie> Worklist;
1578  Worklist.push_back(Result.FunctionDIE);
1579  while (!Worklist.empty()) {
1580    DWARFDie DIE = Worklist.back();
1581    Worklist.pop_back();
1582
1583    if (!DIE.isValid())
1584      continue;
1585
1586    if (DIE.getTag() == DW_TAG_lexical_block &&
1587        DIE.addressRangeContainsAddress(Address)) {
1588      Result.BlockDIE = DIE;
1589      break;
1590    }
1591
1592    append_range(Worklist, DIE);
1593  }
1594
1595  return Result;
1596}
1597
1598/// TODO: change input parameter from "uint64_t Address"
1599///       into "SectionedAddress Address"
1600static bool getFunctionNameAndStartLineForAddress(
1601    DWARFCompileUnit *CU, uint64_t Address, FunctionNameKind Kind,
1602    DILineInfoSpecifier::FileLineInfoKind FileNameKind,
1603    std::string &FunctionName, std::string &StartFile, uint32_t &StartLine,
1604    std::optional<uint64_t> &StartAddress) {
1605  // The address may correspond to instruction in some inlined function,
1606  // so we have to build the chain of inlined functions and take the
1607  // name of the topmost function in it.
1608  SmallVector<DWARFDie, 4> InlinedChain;
1609  CU->getInlinedChainForAddress(Address, InlinedChain);
1610  if (InlinedChain.empty())
1611    return false;
1612
1613  const DWARFDie &DIE = InlinedChain[0];
1614  bool FoundResult = false;
1615  const char *Name = nullptr;
1616  if (Kind != FunctionNameKind::None && (Name = DIE.getSubroutineName(Kind))) {
1617    FunctionName = Name;
1618    FoundResult = true;
1619  }
1620  std::string DeclFile = DIE.getDeclFile(FileNameKind);
1621  if (!DeclFile.empty()) {
1622    StartFile = DeclFile;
1623    FoundResult = true;
1624  }
1625  if (auto DeclLineResult = DIE.getDeclLine()) {
1626    StartLine = DeclLineResult;
1627    FoundResult = true;
1628  }
1629  if (auto LowPcAddr = toSectionedAddress(DIE.find(DW_AT_low_pc)))
1630    StartAddress = LowPcAddr->Address;
1631  return FoundResult;
1632}
1633
1634static std::optional<int64_t>
1635getExpressionFrameOffset(ArrayRef<uint8_t> Expr,
1636                         std::optional<unsigned> FrameBaseReg) {
1637  if (!Expr.empty() &&
1638      (Expr[0] == DW_OP_fbreg ||
1639       (FrameBaseReg && Expr[0] == DW_OP_breg0 + *FrameBaseReg))) {
1640    unsigned Count;
1641    int64_t Offset = decodeSLEB128(Expr.data() + 1, &Count, Expr.end());
1642    // A single DW_OP_fbreg or DW_OP_breg.
1643    if (Expr.size() == Count + 1)
1644      return Offset;
1645    // Same + DW_OP_deref (Fortran arrays look like this).
1646    if (Expr.size() == Count + 2 && Expr[Count + 1] == DW_OP_deref)
1647      return Offset;
1648    // Fallthrough. Do not accept ex. (DW_OP_breg W29, DW_OP_stack_value)
1649  }
1650  return std::nullopt;
1651}
1652
1653void DWARFContext::addLocalsForDie(DWARFCompileUnit *CU, DWARFDie Subprogram,
1654                                   DWARFDie Die, std::vector<DILocal> &Result) {
1655  if (Die.getTag() == DW_TAG_variable ||
1656      Die.getTag() == DW_TAG_formal_parameter) {
1657    DILocal Local;
1658    if (const char *Name = Subprogram.getSubroutineName(DINameKind::ShortName))
1659      Local.FunctionName = Name;
1660
1661    std::optional<unsigned> FrameBaseReg;
1662    if (auto FrameBase = Subprogram.find(DW_AT_frame_base))
1663      if (std::optional<ArrayRef<uint8_t>> Expr = FrameBase->getAsBlock())
1664        if (!Expr->empty() && (*Expr)[0] >= DW_OP_reg0 &&
1665            (*Expr)[0] <= DW_OP_reg31) {
1666          FrameBaseReg = (*Expr)[0] - DW_OP_reg0;
1667        }
1668
1669    if (Expected<std::vector<DWARFLocationExpression>> Loc =
1670            Die.getLocations(DW_AT_location)) {
1671      for (const auto &Entry : *Loc) {
1672        if (std::optional<int64_t> FrameOffset =
1673                getExpressionFrameOffset(Entry.Expr, FrameBaseReg)) {
1674          Local.FrameOffset = *FrameOffset;
1675          break;
1676        }
1677      }
1678    } else {
1679      // FIXME: missing DW_AT_location is OK here, but other errors should be
1680      // reported to the user.
1681      consumeError(Loc.takeError());
1682    }
1683
1684    if (auto TagOffsetAttr = Die.find(DW_AT_LLVM_tag_offset))
1685      Local.TagOffset = TagOffsetAttr->getAsUnsignedConstant();
1686
1687    if (auto Origin =
1688            Die.getAttributeValueAsReferencedDie(DW_AT_abstract_origin))
1689      Die = Origin;
1690    if (auto NameAttr = Die.find(DW_AT_name))
1691      if (std::optional<const char *> Name = dwarf::toString(*NameAttr))
1692        Local.Name = *Name;
1693    if (auto Type = Die.getAttributeValueAsReferencedDie(DW_AT_type))
1694      Local.Size = Type.getTypeSize(getCUAddrSize());
1695    if (auto DeclFileAttr = Die.find(DW_AT_decl_file)) {
1696      if (const auto *LT = CU->getContext().getLineTableForUnit(CU))
1697        LT->getFileNameByIndex(
1698            *DeclFileAttr->getAsUnsignedConstant(), CU->getCompilationDir(),
1699            DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath,
1700            Local.DeclFile);
1701    }
1702    if (auto DeclLineAttr = Die.find(DW_AT_decl_line))
1703      Local.DeclLine = *DeclLineAttr->getAsUnsignedConstant();
1704
1705    Result.push_back(Local);
1706    return;
1707  }
1708
1709  if (Die.getTag() == DW_TAG_inlined_subroutine)
1710    if (auto Origin =
1711            Die.getAttributeValueAsReferencedDie(DW_AT_abstract_origin))
1712      Subprogram = Origin;
1713
1714  for (auto Child : Die)
1715    addLocalsForDie(CU, Subprogram, Child, Result);
1716}
1717
1718std::vector<DILocal>
1719DWARFContext::getLocalsForAddress(object::SectionedAddress Address) {
1720  std::vector<DILocal> Result;
1721  DWARFCompileUnit *CU = getCompileUnitForCodeAddress(Address.Address);
1722  if (!CU)
1723    return Result;
1724
1725  DWARFDie Subprogram = CU->getSubroutineForAddress(Address.Address);
1726  if (Subprogram.isValid())
1727    addLocalsForDie(CU, Subprogram, Subprogram, Result);
1728  return Result;
1729}
1730
1731DILineInfo DWARFContext::getLineInfoForAddress(object::SectionedAddress Address,
1732                                               DILineInfoSpecifier Spec) {
1733  DILineInfo Result;
1734  DWARFCompileUnit *CU = getCompileUnitForCodeAddress(Address.Address);
1735  if (!CU)
1736    return Result;
1737
1738  getFunctionNameAndStartLineForAddress(
1739      CU, Address.Address, Spec.FNKind, Spec.FLIKind, Result.FunctionName,
1740      Result.StartFileName, Result.StartLine, Result.StartAddress);
1741  if (Spec.FLIKind != FileLineInfoKind::None) {
1742    if (const DWARFLineTable *LineTable = getLineTableForUnit(CU)) {
1743      LineTable->getFileLineInfoForAddress(
1744          {Address.Address, Address.SectionIndex}, CU->getCompilationDir(),
1745          Spec.FLIKind, Result);
1746    }
1747  }
1748
1749  return Result;
1750}
1751
1752DILineInfo
1753DWARFContext::getLineInfoForDataAddress(object::SectionedAddress Address) {
1754  DILineInfo Result;
1755  DWARFCompileUnit *CU = getCompileUnitForDataAddress(Address.Address);
1756  if (!CU)
1757    return Result;
1758
1759  if (DWARFDie Die = CU->getVariableForAddress(Address.Address)) {
1760    Result.FileName = Die.getDeclFile(FileLineInfoKind::AbsoluteFilePath);
1761    Result.Line = Die.getDeclLine();
1762  }
1763
1764  return Result;
1765}
1766
1767DILineInfoTable DWARFContext::getLineInfoForAddressRange(
1768    object::SectionedAddress Address, uint64_t Size, DILineInfoSpecifier Spec) {
1769  DILineInfoTable Lines;
1770  DWARFCompileUnit *CU = getCompileUnitForCodeAddress(Address.Address);
1771  if (!CU)
1772    return Lines;
1773
1774  uint32_t StartLine = 0;
1775  std::string StartFileName;
1776  std::string FunctionName(DILineInfo::BadString);
1777  std::optional<uint64_t> StartAddress;
1778  getFunctionNameAndStartLineForAddress(CU, Address.Address, Spec.FNKind,
1779                                        Spec.FLIKind, FunctionName,
1780                                        StartFileName, StartLine, StartAddress);
1781
1782  // If the Specifier says we don't need FileLineInfo, just
1783  // return the top-most function at the starting address.
1784  if (Spec.FLIKind == FileLineInfoKind::None) {
1785    DILineInfo Result;
1786    Result.FunctionName = FunctionName;
1787    Result.StartFileName = StartFileName;
1788    Result.StartLine = StartLine;
1789    Result.StartAddress = StartAddress;
1790    Lines.push_back(std::make_pair(Address.Address, Result));
1791    return Lines;
1792  }
1793
1794  const DWARFLineTable *LineTable = getLineTableForUnit(CU);
1795
1796  // Get the index of row we're looking for in the line table.
1797  std::vector<uint32_t> RowVector;
1798  if (!LineTable->lookupAddressRange({Address.Address, Address.SectionIndex},
1799                                     Size, RowVector)) {
1800    return Lines;
1801  }
1802
1803  for (uint32_t RowIndex : RowVector) {
1804    // Take file number and line/column from the row.
1805    const DWARFDebugLine::Row &Row = LineTable->Rows[RowIndex];
1806    DILineInfo Result;
1807    LineTable->getFileNameByIndex(Row.File, CU->getCompilationDir(),
1808                                  Spec.FLIKind, Result.FileName);
1809    Result.FunctionName = FunctionName;
1810    Result.Line = Row.Line;
1811    Result.Column = Row.Column;
1812    Result.StartFileName = StartFileName;
1813    Result.StartLine = StartLine;
1814    Result.StartAddress = StartAddress;
1815    Lines.push_back(std::make_pair(Row.Address.Address, Result));
1816  }
1817
1818  return Lines;
1819}
1820
1821DIInliningInfo
1822DWARFContext::getInliningInfoForAddress(object::SectionedAddress Address,
1823                                        DILineInfoSpecifier Spec) {
1824  DIInliningInfo InliningInfo;
1825
1826  DWARFCompileUnit *CU = getCompileUnitForCodeAddress(Address.Address);
1827  if (!CU)
1828    return InliningInfo;
1829
1830  const DWARFLineTable *LineTable = nullptr;
1831  SmallVector<DWARFDie, 4> InlinedChain;
1832  CU->getInlinedChainForAddress(Address.Address, InlinedChain);
1833  if (InlinedChain.size() == 0) {
1834    // If there is no DIE for address (e.g. it is in unavailable .dwo file),
1835    // try to at least get file/line info from symbol table.
1836    if (Spec.FLIKind != FileLineInfoKind::None) {
1837      DILineInfo Frame;
1838      LineTable = getLineTableForUnit(CU);
1839      if (LineTable && LineTable->getFileLineInfoForAddress(
1840                           {Address.Address, Address.SectionIndex},
1841                           CU->getCompilationDir(), Spec.FLIKind, Frame))
1842        InliningInfo.addFrame(Frame);
1843    }
1844    return InliningInfo;
1845  }
1846
1847  uint32_t CallFile = 0, CallLine = 0, CallColumn = 0, CallDiscriminator = 0;
1848  for (uint32_t i = 0, n = InlinedChain.size(); i != n; i++) {
1849    DWARFDie &FunctionDIE = InlinedChain[i];
1850    DILineInfo Frame;
1851    // Get function name if necessary.
1852    if (const char *Name = FunctionDIE.getSubroutineName(Spec.FNKind))
1853      Frame.FunctionName = Name;
1854    if (auto DeclLineResult = FunctionDIE.getDeclLine())
1855      Frame.StartLine = DeclLineResult;
1856    Frame.StartFileName = FunctionDIE.getDeclFile(Spec.FLIKind);
1857    if (auto LowPcAddr = toSectionedAddress(FunctionDIE.find(DW_AT_low_pc)))
1858      Frame.StartAddress = LowPcAddr->Address;
1859    if (Spec.FLIKind != FileLineInfoKind::None) {
1860      if (i == 0) {
1861        // For the topmost frame, initialize the line table of this
1862        // compile unit and fetch file/line info from it.
1863        LineTable = getLineTableForUnit(CU);
1864        // For the topmost routine, get file/line info from line table.
1865        if (LineTable)
1866          LineTable->getFileLineInfoForAddress(
1867              {Address.Address, Address.SectionIndex}, CU->getCompilationDir(),
1868              Spec.FLIKind, Frame);
1869      } else {
1870        // Otherwise, use call file, call line and call column from
1871        // previous DIE in inlined chain.
1872        if (LineTable)
1873          LineTable->getFileNameByIndex(CallFile, CU->getCompilationDir(),
1874                                        Spec.FLIKind, Frame.FileName);
1875        Frame.Line = CallLine;
1876        Frame.Column = CallColumn;
1877        Frame.Discriminator = CallDiscriminator;
1878      }
1879      // Get call file/line/column of a current DIE.
1880      if (i + 1 < n) {
1881        FunctionDIE.getCallerFrame(CallFile, CallLine, CallColumn,
1882                                   CallDiscriminator);
1883      }
1884    }
1885    InliningInfo.addFrame(Frame);
1886  }
1887  return InliningInfo;
1888}
1889
1890std::shared_ptr<DWARFContext>
1891DWARFContext::getDWOContext(StringRef AbsolutePath) {
1892  return State->getDWOContext(AbsolutePath);
1893}
1894
1895static Error createError(const Twine &Reason, llvm::Error E) {
1896  return make_error<StringError>(Reason + toString(std::move(E)),
1897                                 inconvertibleErrorCode());
1898}
1899
1900/// SymInfo contains information about symbol: it's address
1901/// and section index which is -1LL for absolute symbols.
1902struct SymInfo {
1903  uint64_t Address;
1904  uint64_t SectionIndex;
1905};
1906
1907/// Returns the address of symbol relocation used against and a section index.
1908/// Used for futher relocations computation. Symbol's section load address is
1909static Expected<SymInfo> getSymbolInfo(const object::ObjectFile &Obj,
1910                                       const RelocationRef &Reloc,
1911                                       const LoadedObjectInfo *L,
1912                                       std::map<SymbolRef, SymInfo> &Cache) {
1913  SymInfo Ret = {0, (uint64_t)-1LL};
1914  object::section_iterator RSec = Obj.section_end();
1915  object::symbol_iterator Sym = Reloc.getSymbol();
1916
1917  std::map<SymbolRef, SymInfo>::iterator CacheIt = Cache.end();
1918  // First calculate the address of the symbol or section as it appears
1919  // in the object file
1920  if (Sym != Obj.symbol_end()) {
1921    bool New;
1922    std::tie(CacheIt, New) = Cache.insert({*Sym, {0, 0}});
1923    if (!New)
1924      return CacheIt->second;
1925
1926    Expected<uint64_t> SymAddrOrErr = Sym->getAddress();
1927    if (!SymAddrOrErr)
1928      return createError("failed to compute symbol address: ",
1929                         SymAddrOrErr.takeError());
1930
1931    // Also remember what section this symbol is in for later
1932    auto SectOrErr = Sym->getSection();
1933    if (!SectOrErr)
1934      return createError("failed to get symbol section: ",
1935                         SectOrErr.takeError());
1936
1937    RSec = *SectOrErr;
1938    Ret.Address = *SymAddrOrErr;
1939  } else if (auto *MObj = dyn_cast<MachOObjectFile>(&Obj)) {
1940    RSec = MObj->getRelocationSection(Reloc.getRawDataRefImpl());
1941    Ret.Address = RSec->getAddress();
1942  }
1943
1944  if (RSec != Obj.section_end())
1945    Ret.SectionIndex = RSec->getIndex();
1946
1947  // If we are given load addresses for the sections, we need to adjust:
1948  // SymAddr = (Address of Symbol Or Section in File) -
1949  //           (Address of Section in File) +
1950  //           (Load Address of Section)
1951  // RSec is now either the section being targeted or the section
1952  // containing the symbol being targeted. In either case,
1953  // we need to perform the same computation.
1954  if (L && RSec != Obj.section_end())
1955    if (uint64_t SectionLoadAddress = L->getSectionLoadAddress(*RSec))
1956      Ret.Address += SectionLoadAddress - RSec->getAddress();
1957
1958  if (CacheIt != Cache.end())
1959    CacheIt->second = Ret;
1960
1961  return Ret;
1962}
1963
1964static bool isRelocScattered(const object::ObjectFile &Obj,
1965                             const RelocationRef &Reloc) {
1966  const MachOObjectFile *MachObj = dyn_cast<MachOObjectFile>(&Obj);
1967  if (!MachObj)
1968    return false;
1969  // MachO also has relocations that point to sections and
1970  // scattered relocations.
1971  auto RelocInfo = MachObj->getRelocation(Reloc.getRawDataRefImpl());
1972  return MachObj->isRelocationScattered(RelocInfo);
1973}
1974
1975namespace {
1976struct DWARFSectionMap final : public DWARFSection {
1977  RelocAddrMap Relocs;
1978};
1979
1980class DWARFObjInMemory final : public DWARFObject {
1981  bool IsLittleEndian;
1982  uint8_t AddressSize;
1983  StringRef FileName;
1984  const object::ObjectFile *Obj = nullptr;
1985  std::vector<SectionName> SectionNames;
1986
1987  using InfoSectionMap = MapVector<object::SectionRef, DWARFSectionMap,
1988                                   std::map<object::SectionRef, unsigned>>;
1989
1990  InfoSectionMap InfoSections;
1991  InfoSectionMap TypesSections;
1992  InfoSectionMap InfoDWOSections;
1993  InfoSectionMap TypesDWOSections;
1994
1995  DWARFSectionMap LocSection;
1996  DWARFSectionMap LoclistsSection;
1997  DWARFSectionMap LoclistsDWOSection;
1998  DWARFSectionMap LineSection;
1999  DWARFSectionMap RangesSection;
2000  DWARFSectionMap RnglistsSection;
2001  DWARFSectionMap StrOffsetsSection;
2002  DWARFSectionMap LineDWOSection;
2003  DWARFSectionMap FrameSection;
2004  DWARFSectionMap EHFrameSection;
2005  DWARFSectionMap LocDWOSection;
2006  DWARFSectionMap StrOffsetsDWOSection;
2007  DWARFSectionMap RangesDWOSection;
2008  DWARFSectionMap RnglistsDWOSection;
2009  DWARFSectionMap AddrSection;
2010  DWARFSectionMap AppleNamesSection;
2011  DWARFSectionMap AppleTypesSection;
2012  DWARFSectionMap AppleNamespacesSection;
2013  DWARFSectionMap AppleObjCSection;
2014  DWARFSectionMap NamesSection;
2015  DWARFSectionMap PubnamesSection;
2016  DWARFSectionMap PubtypesSection;
2017  DWARFSectionMap GnuPubnamesSection;
2018  DWARFSectionMap GnuPubtypesSection;
2019  DWARFSectionMap MacroSection;
2020
2021  DWARFSectionMap *mapNameToDWARFSection(StringRef Name) {
2022    return StringSwitch<DWARFSectionMap *>(Name)
2023        .Case("debug_loc", &LocSection)
2024        .Case("debug_loclists", &LoclistsSection)
2025        .Case("debug_loclists.dwo", &LoclistsDWOSection)
2026        .Case("debug_line", &LineSection)
2027        .Case("debug_frame", &FrameSection)
2028        .Case("eh_frame", &EHFrameSection)
2029        .Case("debug_str_offsets", &StrOffsetsSection)
2030        .Case("debug_ranges", &RangesSection)
2031        .Case("debug_rnglists", &RnglistsSection)
2032        .Case("debug_loc.dwo", &LocDWOSection)
2033        .Case("debug_line.dwo", &LineDWOSection)
2034        .Case("debug_names", &NamesSection)
2035        .Case("debug_rnglists.dwo", &RnglistsDWOSection)
2036        .Case("debug_str_offsets.dwo", &StrOffsetsDWOSection)
2037        .Case("debug_addr", &AddrSection)
2038        .Case("apple_names", &AppleNamesSection)
2039        .Case("debug_pubnames", &PubnamesSection)
2040        .Case("debug_pubtypes", &PubtypesSection)
2041        .Case("debug_gnu_pubnames", &GnuPubnamesSection)
2042        .Case("debug_gnu_pubtypes", &GnuPubtypesSection)
2043        .Case("apple_types", &AppleTypesSection)
2044        .Case("apple_namespaces", &AppleNamespacesSection)
2045        .Case("apple_namespac", &AppleNamespacesSection)
2046        .Case("apple_objc", &AppleObjCSection)
2047        .Case("debug_macro", &MacroSection)
2048        .Default(nullptr);
2049  }
2050
2051  StringRef AbbrevSection;
2052  StringRef ArangesSection;
2053  StringRef StrSection;
2054  StringRef MacinfoSection;
2055  StringRef MacinfoDWOSection;
2056  StringRef MacroDWOSection;
2057  StringRef AbbrevDWOSection;
2058  StringRef StrDWOSection;
2059  StringRef CUIndexSection;
2060  StringRef GdbIndexSection;
2061  StringRef TUIndexSection;
2062  StringRef LineStrSection;
2063
2064  // A deque holding section data whose iterators are not invalidated when
2065  // new decompressed sections are inserted at the end.
2066  std::deque<SmallString<0>> UncompressedSections;
2067
2068  StringRef *mapSectionToMember(StringRef Name) {
2069    if (DWARFSection *Sec = mapNameToDWARFSection(Name))
2070      return &Sec->Data;
2071    return StringSwitch<StringRef *>(Name)
2072        .Case("debug_abbrev", &AbbrevSection)
2073        .Case("debug_aranges", &ArangesSection)
2074        .Case("debug_str", &StrSection)
2075        .Case("debug_macinfo", &MacinfoSection)
2076        .Case("debug_macinfo.dwo", &MacinfoDWOSection)
2077        .Case("debug_macro.dwo", &MacroDWOSection)
2078        .Case("debug_abbrev.dwo", &AbbrevDWOSection)
2079        .Case("debug_str.dwo", &StrDWOSection)
2080        .Case("debug_cu_index", &CUIndexSection)
2081        .Case("debug_tu_index", &TUIndexSection)
2082        .Case("gdb_index", &GdbIndexSection)
2083        .Case("debug_line_str", &LineStrSection)
2084        // Any more debug info sections go here.
2085        .Default(nullptr);
2086  }
2087
2088  /// If Sec is compressed section, decompresses and updates its contents
2089  /// provided by Data. Otherwise leaves it unchanged.
2090  Error maybeDecompress(const object::SectionRef &Sec, StringRef Name,
2091                        StringRef &Data) {
2092    if (!Sec.isCompressed())
2093      return Error::success();
2094
2095    Expected<Decompressor> Decompressor =
2096        Decompressor::create(Name, Data, IsLittleEndian, AddressSize == 8);
2097    if (!Decompressor)
2098      return Decompressor.takeError();
2099
2100    SmallString<0> Out;
2101    if (auto Err = Decompressor->resizeAndDecompress(Out))
2102      return Err;
2103
2104    UncompressedSections.push_back(std::move(Out));
2105    Data = UncompressedSections.back();
2106
2107    return Error::success();
2108  }
2109
2110public:
2111  DWARFObjInMemory(const StringMap<std::unique_ptr<MemoryBuffer>> &Sections,
2112                   uint8_t AddrSize, bool IsLittleEndian)
2113      : IsLittleEndian(IsLittleEndian) {
2114    for (const auto &SecIt : Sections) {
2115      if (StringRef *SectionData = mapSectionToMember(SecIt.first()))
2116        *SectionData = SecIt.second->getBuffer();
2117      else if (SecIt.first() == "debug_info")
2118        // Find debug_info and debug_types data by section rather than name as
2119        // there are multiple, comdat grouped, of these sections.
2120        InfoSections[SectionRef()].Data = SecIt.second->getBuffer();
2121      else if (SecIt.first() == "debug_info.dwo")
2122        InfoDWOSections[SectionRef()].Data = SecIt.second->getBuffer();
2123      else if (SecIt.first() == "debug_types")
2124        TypesSections[SectionRef()].Data = SecIt.second->getBuffer();
2125      else if (SecIt.first() == "debug_types.dwo")
2126        TypesDWOSections[SectionRef()].Data = SecIt.second->getBuffer();
2127    }
2128  }
2129  DWARFObjInMemory(const object::ObjectFile &Obj, const LoadedObjectInfo *L,
2130                   function_ref<void(Error)> HandleError,
2131                   function_ref<void(Error)> HandleWarning,
2132                   DWARFContext::ProcessDebugRelocations RelocAction)
2133      : IsLittleEndian(Obj.isLittleEndian()),
2134        AddressSize(Obj.getBytesInAddress()), FileName(Obj.getFileName()),
2135        Obj(&Obj) {
2136
2137    StringMap<unsigned> SectionAmountMap;
2138    for (const SectionRef &Section : Obj.sections()) {
2139      StringRef Name;
2140      if (auto NameOrErr = Section.getName())
2141        Name = *NameOrErr;
2142      else
2143        consumeError(NameOrErr.takeError());
2144
2145      ++SectionAmountMap[Name];
2146      SectionNames.push_back({ Name, true });
2147
2148      // Skip BSS and Virtual sections, they aren't interesting.
2149      if (Section.isBSS() || Section.isVirtual())
2150        continue;
2151
2152      // Skip sections stripped by dsymutil.
2153      if (Section.isStripped())
2154        continue;
2155
2156      StringRef Data;
2157      Expected<section_iterator> SecOrErr = Section.getRelocatedSection();
2158      if (!SecOrErr) {
2159        HandleError(createError("failed to get relocated section: ",
2160                                SecOrErr.takeError()));
2161        continue;
2162      }
2163
2164      // Try to obtain an already relocated version of this section.
2165      // Else use the unrelocated section from the object file. We'll have to
2166      // apply relocations ourselves later.
2167      section_iterator RelocatedSection =
2168          Obj.isRelocatableObject() ? *SecOrErr : Obj.section_end();
2169      if (!L || !L->getLoadedSectionContents(*RelocatedSection, Data)) {
2170        Expected<StringRef> E = Section.getContents();
2171        if (E)
2172          Data = *E;
2173        else
2174          // maybeDecompress below will error.
2175          consumeError(E.takeError());
2176      }
2177
2178      if (auto Err = maybeDecompress(Section, Name, Data)) {
2179        HandleError(createError("failed to decompress '" + Name + "', ",
2180                                std::move(Err)));
2181        continue;
2182      }
2183
2184      // Map platform specific debug section names to DWARF standard section
2185      // names.
2186      Name = Name.substr(Name.find_first_not_of("._"));
2187      Name = Obj.mapDebugSectionName(Name);
2188
2189      if (StringRef *SectionData = mapSectionToMember(Name)) {
2190        *SectionData = Data;
2191        if (Name == "debug_ranges") {
2192          // FIXME: Use the other dwo range section when we emit it.
2193          RangesDWOSection.Data = Data;
2194        } else if (Name == "debug_frame" || Name == "eh_frame") {
2195          if (DWARFSection *S = mapNameToDWARFSection(Name))
2196            S->Address = Section.getAddress();
2197        }
2198      } else if (InfoSectionMap *Sections =
2199                     StringSwitch<InfoSectionMap *>(Name)
2200                         .Case("debug_info", &InfoSections)
2201                         .Case("debug_info.dwo", &InfoDWOSections)
2202                         .Case("debug_types", &TypesSections)
2203                         .Case("debug_types.dwo", &TypesDWOSections)
2204                         .Default(nullptr)) {
2205        // Find debug_info and debug_types data by section rather than name as
2206        // there are multiple, comdat grouped, of these sections.
2207        DWARFSectionMap &S = (*Sections)[Section];
2208        S.Data = Data;
2209      }
2210
2211      if (RelocatedSection == Obj.section_end() ||
2212          (RelocAction == DWARFContext::ProcessDebugRelocations::Ignore))
2213        continue;
2214
2215      StringRef RelSecName;
2216      if (auto NameOrErr = RelocatedSection->getName())
2217        RelSecName = *NameOrErr;
2218      else
2219        consumeError(NameOrErr.takeError());
2220
2221      // If the section we're relocating was relocated already by the JIT,
2222      // then we used the relocated version above, so we do not need to process
2223      // relocations for it now.
2224      StringRef RelSecData;
2225      if (L && L->getLoadedSectionContents(*RelocatedSection, RelSecData))
2226        continue;
2227
2228      // In Mach-o files, the relocations do not need to be applied if
2229      // there is no load offset to apply. The value read at the
2230      // relocation point already factors in the section address
2231      // (actually applying the relocations will produce wrong results
2232      // as the section address will be added twice).
2233      if (!L && isa<MachOObjectFile>(&Obj))
2234        continue;
2235
2236      if (!Section.relocations().empty() && Name.ends_with(".dwo") &&
2237          RelSecName.starts_with(".debug")) {
2238        HandleWarning(createError("unexpected relocations for dwo section '" +
2239                                  RelSecName + "'"));
2240      }
2241
2242      // TODO: Add support for relocations in other sections as needed.
2243      // Record relocations for the debug_info and debug_line sections.
2244      RelSecName = RelSecName.substr(RelSecName.find_first_not_of("._"));
2245      DWARFSectionMap *Sec = mapNameToDWARFSection(RelSecName);
2246      RelocAddrMap *Map = Sec ? &Sec->Relocs : nullptr;
2247      if (!Map) {
2248        // Find debug_info and debug_types relocs by section rather than name
2249        // as there are multiple, comdat grouped, of these sections.
2250        if (RelSecName == "debug_info")
2251          Map = &static_cast<DWARFSectionMap &>(InfoSections[*RelocatedSection])
2252                     .Relocs;
2253        else if (RelSecName == "debug_types")
2254          Map =
2255              &static_cast<DWARFSectionMap &>(TypesSections[*RelocatedSection])
2256                   .Relocs;
2257        else
2258          continue;
2259      }
2260
2261      if (Section.relocation_begin() == Section.relocation_end())
2262        continue;
2263
2264      // Symbol to [address, section index] cache mapping.
2265      std::map<SymbolRef, SymInfo> AddrCache;
2266      SupportsRelocation Supports;
2267      RelocationResolver Resolver;
2268      std::tie(Supports, Resolver) = getRelocationResolver(Obj);
2269      for (const RelocationRef &Reloc : Section.relocations()) {
2270        // FIXME: it's not clear how to correctly handle scattered
2271        // relocations.
2272        if (isRelocScattered(Obj, Reloc))
2273          continue;
2274
2275        Expected<SymInfo> SymInfoOrErr =
2276            getSymbolInfo(Obj, Reloc, L, AddrCache);
2277        if (!SymInfoOrErr) {
2278          HandleError(SymInfoOrErr.takeError());
2279          continue;
2280        }
2281
2282        // Check if Resolver can handle this relocation type early so as not to
2283        // handle invalid cases in DWARFDataExtractor.
2284        //
2285        // TODO Don't store Resolver in every RelocAddrEntry.
2286        if (Supports && Supports(Reloc.getType())) {
2287          auto I = Map->try_emplace(
2288              Reloc.getOffset(),
2289              RelocAddrEntry{
2290                  SymInfoOrErr->SectionIndex, Reloc, SymInfoOrErr->Address,
2291                  std::optional<object::RelocationRef>(), 0, Resolver});
2292          // If we didn't successfully insert that's because we already had a
2293          // relocation for that offset. Store it as a second relocation in the
2294          // same RelocAddrEntry instead.
2295          if (!I.second) {
2296            RelocAddrEntry &entry = I.first->getSecond();
2297            if (entry.Reloc2) {
2298              HandleError(createError(
2299                  "At most two relocations per offset are supported"));
2300            }
2301            entry.Reloc2 = Reloc;
2302            entry.SymbolValue2 = SymInfoOrErr->Address;
2303          }
2304        } else {
2305          SmallString<32> Type;
2306          Reloc.getTypeName(Type);
2307          // FIXME: Support more relocations & change this to an error
2308          HandleWarning(
2309              createError("failed to compute relocation: " + Type + ", ",
2310                          errorCodeToError(object_error::parse_failed)));
2311        }
2312      }
2313    }
2314
2315    for (SectionName &S : SectionNames)
2316      if (SectionAmountMap[S.Name] > 1)
2317        S.IsNameUnique = false;
2318  }
2319
2320  std::optional<RelocAddrEntry> find(const DWARFSection &S,
2321                                     uint64_t Pos) const override {
2322    auto &Sec = static_cast<const DWARFSectionMap &>(S);
2323    RelocAddrMap::const_iterator AI = Sec.Relocs.find(Pos);
2324    if (AI == Sec.Relocs.end())
2325      return std::nullopt;
2326    return AI->second;
2327  }
2328
2329  const object::ObjectFile *getFile() const override { return Obj; }
2330
2331  ArrayRef<SectionName> getSectionNames() const override {
2332    return SectionNames;
2333  }
2334
2335  bool isLittleEndian() const override { return IsLittleEndian; }
2336  StringRef getAbbrevDWOSection() const override { return AbbrevDWOSection; }
2337  const DWARFSection &getLineDWOSection() const override {
2338    return LineDWOSection;
2339  }
2340  const DWARFSection &getLocDWOSection() const override {
2341    return LocDWOSection;
2342  }
2343  StringRef getStrDWOSection() const override { return StrDWOSection; }
2344  const DWARFSection &getStrOffsetsDWOSection() const override {
2345    return StrOffsetsDWOSection;
2346  }
2347  const DWARFSection &getRangesDWOSection() const override {
2348    return RangesDWOSection;
2349  }
2350  const DWARFSection &getRnglistsDWOSection() const override {
2351    return RnglistsDWOSection;
2352  }
2353  const DWARFSection &getLoclistsDWOSection() const override {
2354    return LoclistsDWOSection;
2355  }
2356  const DWARFSection &getAddrSection() const override { return AddrSection; }
2357  StringRef getCUIndexSection() const override { return CUIndexSection; }
2358  StringRef getGdbIndexSection() const override { return GdbIndexSection; }
2359  StringRef getTUIndexSection() const override { return TUIndexSection; }
2360
2361  // DWARF v5
2362  const DWARFSection &getStrOffsetsSection() const override {
2363    return StrOffsetsSection;
2364  }
2365  StringRef getLineStrSection() const override { return LineStrSection; }
2366
2367  // Sections for DWARF5 split dwarf proposal.
2368  void forEachInfoDWOSections(
2369      function_ref<void(const DWARFSection &)> F) const override {
2370    for (auto &P : InfoDWOSections)
2371      F(P.second);
2372  }
2373  void forEachTypesDWOSections(
2374      function_ref<void(const DWARFSection &)> F) const override {
2375    for (auto &P : TypesDWOSections)
2376      F(P.second);
2377  }
2378
2379  StringRef getAbbrevSection() const override { return AbbrevSection; }
2380  const DWARFSection &getLocSection() const override { return LocSection; }
2381  const DWARFSection &getLoclistsSection() const override { return LoclistsSection; }
2382  StringRef getArangesSection() const override { return ArangesSection; }
2383  const DWARFSection &getFrameSection() const override {
2384    return FrameSection;
2385  }
2386  const DWARFSection &getEHFrameSection() const override {
2387    return EHFrameSection;
2388  }
2389  const DWARFSection &getLineSection() const override { return LineSection; }
2390  StringRef getStrSection() const override { return StrSection; }
2391  const DWARFSection &getRangesSection() const override { return RangesSection; }
2392  const DWARFSection &getRnglistsSection() const override {
2393    return RnglistsSection;
2394  }
2395  const DWARFSection &getMacroSection() const override { return MacroSection; }
2396  StringRef getMacroDWOSection() const override { return MacroDWOSection; }
2397  StringRef getMacinfoSection() const override { return MacinfoSection; }
2398  StringRef getMacinfoDWOSection() const override { return MacinfoDWOSection; }
2399  const DWARFSection &getPubnamesSection() const override { return PubnamesSection; }
2400  const DWARFSection &getPubtypesSection() const override { return PubtypesSection; }
2401  const DWARFSection &getGnuPubnamesSection() const override {
2402    return GnuPubnamesSection;
2403  }
2404  const DWARFSection &getGnuPubtypesSection() const override {
2405    return GnuPubtypesSection;
2406  }
2407  const DWARFSection &getAppleNamesSection() const override {
2408    return AppleNamesSection;
2409  }
2410  const DWARFSection &getAppleTypesSection() const override {
2411    return AppleTypesSection;
2412  }
2413  const DWARFSection &getAppleNamespacesSection() const override {
2414    return AppleNamespacesSection;
2415  }
2416  const DWARFSection &getAppleObjCSection() const override {
2417    return AppleObjCSection;
2418  }
2419  const DWARFSection &getNamesSection() const override {
2420    return NamesSection;
2421  }
2422
2423  StringRef getFileName() const override { return FileName; }
2424  uint8_t getAddressSize() const override { return AddressSize; }
2425  void forEachInfoSections(
2426      function_ref<void(const DWARFSection &)> F) const override {
2427    for (auto &P : InfoSections)
2428      F(P.second);
2429  }
2430  void forEachTypesSections(
2431      function_ref<void(const DWARFSection &)> F) const override {
2432    for (auto &P : TypesSections)
2433      F(P.second);
2434  }
2435};
2436} // namespace
2437
2438std::unique_ptr<DWARFContext>
2439DWARFContext::create(const object::ObjectFile &Obj,
2440                     ProcessDebugRelocations RelocAction,
2441                     const LoadedObjectInfo *L, std::string DWPName,
2442                     std::function<void(Error)> RecoverableErrorHandler,
2443                     std::function<void(Error)> WarningHandler,
2444                     bool ThreadSafe) {
2445  auto DObj = std::make_unique<DWARFObjInMemory>(
2446      Obj, L, RecoverableErrorHandler, WarningHandler, RelocAction);
2447  return std::make_unique<DWARFContext>(std::move(DObj),
2448                                        std::move(DWPName),
2449                                        RecoverableErrorHandler,
2450                                        WarningHandler,
2451                                        ThreadSafe);
2452}
2453
2454std::unique_ptr<DWARFContext>
2455DWARFContext::create(const StringMap<std::unique_ptr<MemoryBuffer>> &Sections,
2456                     uint8_t AddrSize, bool isLittleEndian,
2457                     std::function<void(Error)> RecoverableErrorHandler,
2458                     std::function<void(Error)> WarningHandler,
2459                     bool ThreadSafe) {
2460  auto DObj =
2461      std::make_unique<DWARFObjInMemory>(Sections, AddrSize, isLittleEndian);
2462  return std::make_unique<DWARFContext>(
2463      std::move(DObj), "", RecoverableErrorHandler, WarningHandler, ThreadSafe);
2464}
2465
2466uint8_t DWARFContext::getCUAddrSize() {
2467  // In theory, different compile units may have different address byte
2468  // sizes, but for simplicity we just use the address byte size of the
2469  // first compile unit. In practice the address size field is repeated across
2470  // various DWARF headers (at least in version 5) to make it easier to dump
2471  // them independently, not to enable varying the address size.
2472  auto CUs = compile_units();
2473  return CUs.empty() ? 0 : (*CUs.begin())->getAddressByteSize();
2474}
2475