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 | |
63 | using namespace llvm; |
64 | using namespace dwarf; |
65 | using namespace object; |
66 | |
67 | #define DEBUG_TYPE "dwarf" |
68 | |
69 | using DWARFLineTable = DWARFDebugLine::LineTable; |
70 | using FileLineInfoKind = DILineInfoSpecifier::FileLineInfoKind; |
71 | using FunctionNameKind = DILineInfoSpecifier::FunctionNameKind; |
72 | |
73 | |
74 | void 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(F: [&](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: Offset)) { |
91 | DWARFUnitHeader ; |
92 | if (Error = Header.extract( |
93 | Context&: C, debug_info: Data, offset_ptr: &Offset, SectionKind: DWARFSectionKind::DW_SECT_INFO)) { |
94 | C.getWarningHandler()( |
95 | createError(Err: "Failed to parse CU header in DWP file: " + |
96 | toString(E: std::move(ExtractionErr)))); |
97 | Map.clear(); |
98 | break; |
99 | } |
100 | |
101 | auto Iter = Map.insert(KV: {TruncOffset, |
102 | {Header.getOffset(), Header.getNextUnitOffset() - |
103 | Header.getOffset()}}); |
104 | if (!Iter.second) { |
105 | logAllUnhandledErrors( |
106 | E: createError(Err: "Collision occured between for truncated offset 0x" + |
107 | Twine::utohexstr(Val: TruncOffset)), |
108 | OS&: 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(Val: CUOff.getOffset()); |
126 | if (Iter == Map.end()) { |
127 | logAllUnhandledErrors(E: createError(Err: "Could not find CU offset 0x" + |
128 | Twine::utohexstr(Val: CUOff.getOffset()) + |
129 | " in the Map" ), |
130 | OS&: errs()); |
131 | break; |
132 | } |
133 | CUOff.setOffset(Iter->second.getOffset()); |
134 | if (CUOff.getOffset() != Iter->second.getOffset()) |
135 | logAllUnhandledErrors(E: createError(Err: "Length of CU in CU index doesn't " |
136 | "match calculated length at offset 0x" + |
137 | Twine::utohexstr(Val: CUOff.getOffset())), |
138 | OS&: errs()); |
139 | } |
140 | } |
141 | |
142 | void fixupIndexV5(DWARFContext &C, DWARFUnitIndex &Index) { |
143 | DenseMap<uint64_t, uint64_t> Map; |
144 | |
145 | const auto &DObj = C.getDWARFObj(); |
146 | DObj.forEachInfoDWOSections(F: [&](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: Offset)) { |
153 | DWARFUnitHeader ; |
154 | if (Error = Header.extract( |
155 | Context&: C, debug_info: Data, offset_ptr: &Offset, SectionKind: DWARFSectionKind::DW_SECT_INFO)) { |
156 | C.getWarningHandler()( |
157 | createError(Err: "Failed to parse CU header in DWP file: " + |
158 | toString(E: 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(Val: E.getSignature()); |
174 | if (Iter == Map.end()) { |
175 | logAllUnhandledErrors( |
176 | E: createError(Err: "Could not find unit with signature 0x" + |
177 | Twine::utohexstr(Val: E.getSignature()) + " in the Map" ), |
178 | OS&: errs()); |
179 | break; |
180 | } |
181 | CUOff.setOffset(Iter->second); |
182 | } |
183 | } |
184 | |
185 | void fixupIndex(DWARFContext &C, DWARFUnitIndex &Index) { |
186 | if (Index.getVersion() < 5) |
187 | fixupIndexV4(C, Index); |
188 | else |
189 | fixupIndexV5(C, Index); |
190 | } |
191 | |
192 | template <typename T> |
193 | static 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(Err: std::move(E)); |
203 | return *Cache; |
204 | } |
205 | |
206 | |
207 | std::unique_ptr<DWARFDebugMacro> |
208 | DWARFContext::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(Units: SectionType == MacroSection |
212 | ? D.compile_units() |
213 | : D.dwo_compile_units(), |
214 | StringExtractor: SectionType == MacroSection |
215 | ? D.getStringExtractor() |
216 | : D.getStringDWOExtractor(), |
217 | MacroData: Data) |
218 | : Macro->parseMacinfo(MacroData: 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 | |
250 | class 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 | |
284 | public: |
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(F: [&](const DWARFSection &S) { |
293 | NormalUnits.addUnitsForSection(C&: D, Section: S, SectionKind: DW_SECT_INFO); |
294 | }); |
295 | NormalUnits.finishedInfoUnits(); |
296 | DObj.forEachTypesSections(F: [&](const DWARFSection &S) { |
297 | NormalUnits.addUnitsForSection(C&: D, Section: S, SectionKind: 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(F: [&](const DWARFSection &S) { |
308 | DWOUnits.addUnitsForDWOSection(C&: D, DWOSection: S, SectionKind: DW_SECT_INFO, Lazy); |
309 | }); |
310 | DWOUnits.finishedInfoUnits(); |
311 | DObj.forEachTypesDWOSections(F: [&](const DWARFSection &S) { |
312 | DWOUnits.addUnitsForDWOSection(C&: D, DWOSection: S, SectionKind: 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>(args&: 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>(args: DW_SECT_INFO); |
334 | if (CUIndex->parse(IndexData: Data)) |
335 | fixupIndex(C&: D, Index&: *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>(args: DW_SECT_EXT_TYPES); |
345 | bool isParseSuccessful = TUIndex->parse(IndexData: 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(C&: D, Index&: *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>(args&: 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(index: 0)->getAddressByteSize()) |
383 | : DWARFDataExtractor("" , D.isLittleEndian(), 0); |
384 | Loc = std::make_unique<DWARFDebugLoc>(args: 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(CTX: &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(V: UnitDIE.find(Attr: 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(Offset: 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(DebugLineData&: Data, Offset: stmtOffset, Ctx: 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(V: UnitDIE.find(Attr: DW_AT_stmt_list)); |
436 | if (!Offset) |
437 | return; |
438 | |
439 | uint64_t stmtOffset = *Offset + U->getLineTableOffset(); |
440 | Line->clearLineTable(Offset: 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>(args: D.getArch(), /*IsEH=*/args: false, |
462 | args: DS.Address); |
463 | if (Error E = DF->parse(Data)) |
464 | return std::move(E); |
465 | |
466 | DebugFrame.swap(u&: 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>(args: D.getArch(), /*IsEH=*/args: true, |
480 | args: DS.Address); |
481 | if (Error E = DF->parse(Data)) |
482 | return std::move(E); |
483 | EHFrame.swap(u&: DF); |
484 | return EHFrame.get(); |
485 | } |
486 | |
487 | const DWARFDebugMacro *getDebugMacinfo() override { |
488 | if (!Macinfo) |
489 | Macinfo = parseMacroOrMacinfo(SectionType: MacinfoSection); |
490 | return Macinfo.get(); |
491 | } |
492 | const DWARFDebugMacro *getDebugMacinfoDWO() override { |
493 | if (!MacinfoDWO) |
494 | MacinfoDWO = parseMacroOrMacinfo(SectionType: MacinfoDwoSection); |
495 | return MacinfoDWO.get(); |
496 | } |
497 | const DWARFDebugMacro *getDebugMacro() override { |
498 | if (!Macro) |
499 | Macro = parseMacroOrMacinfo(SectionType: MacroSection); |
500 | return Macro.get(); |
501 | } |
502 | const DWARFDebugMacro *getDebugMacroDWO() override { |
503 | if (!MacroDWO) |
504 | MacroDWO = parseMacroOrMacinfo(SectionType: MacroDwoSection); |
505 | return MacroDWO.get(); |
506 | } |
507 | const DWARFDebugNames &getDebugNames() override { |
508 | const DWARFObject &DObj = D.getDWARFObj(); |
509 | return getAccelTable(Cache&: Names, Obj: DObj, Section: DObj.getNamesSection(), |
510 | StringSection: DObj.getStrSection(), IsLittleEndian: D.isLittleEndian()); |
511 | } |
512 | const AppleAcceleratorTable &getAppleNames() override { |
513 | const DWARFObject &DObj = D.getDWARFObj(); |
514 | return getAccelTable(Cache&: AppleNames, Obj: DObj, Section: DObj.getAppleNamesSection(), |
515 | StringSection: DObj.getStrSection(), IsLittleEndian: D.isLittleEndian()); |
516 | |
517 | } |
518 | const AppleAcceleratorTable &getAppleTypes() override { |
519 | const DWARFObject &DObj = D.getDWARFObj(); |
520 | return getAccelTable(Cache&: AppleTypes, Obj: DObj, Section: DObj.getAppleTypesSection(), |
521 | StringSection: DObj.getStrSection(), IsLittleEndian: D.isLittleEndian()); |
522 | |
523 | } |
524 | const AppleAcceleratorTable &getAppleNamespaces() override { |
525 | const DWARFObject &DObj = D.getDWARFObj(); |
526 | return getAccelTable(Cache&: AppleNamespaces, Obj: DObj, |
527 | Section: DObj.getAppleNamespacesSection(), |
528 | StringSection: DObj.getStrSection(), IsLittleEndian: D.isLittleEndian()); |
529 | |
530 | } |
531 | const AppleAcceleratorTable &getAppleObjC() override { |
532 | const DWARFObject &DObj = D.getDWARFObj(); |
533 | return getAccelTable(Cache&: AppleObjC, Obj: DObj, Section: DObj.getAppleObjCSection(), |
534 | StringSection: DObj.getStrSection(), IsLittleEndian: 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 | ObjectPath: this->DWPName.empty() |
558 | ? (DObj.getFileName() + ".dwp" ).toStringRef(Out&: 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(Err: Obj.takeError()); |
568 | } |
569 | } |
570 | |
571 | return object::ObjectFile::createObjectFile(ObjectPath: AbsolutePath); |
572 | }(); |
573 | |
574 | if (!Obj) { |
575 | // TODO: Actually report errors helpfully. |
576 | consumeError(Err: 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 | Obj: *S->File.getBinary(), RelocAction: DWARFContext::ProcessDebugRelocations::Ignore, |
587 | L: nullptr, DWPName: "" , RecoverableErrorHandler: WithColor::defaultErrorHandler, |
588 | WarningHandler: 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>(Val: 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>(Val: 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 | |
629 | class ThreadSafeState : public ThreadUnsafeDWARFContextState { |
630 | std::recursive_mutex Mutex; |
631 | |
632 | public: |
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(Lazy: 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 | |
746 | DWARFContext::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>(args&: *this, args&: DWPName); |
756 | else |
757 | State = std::make_unique<ThreadUnsafeDWARFContextState>(args&: *this, args&: DWPName); |
758 | } |
759 | |
760 | DWARFContext::~DWARFContext() = default; |
761 | |
762 | /// Dump the UUID load command. |
763 | static void dumpUUID(raw_ostream &OS, const ObjectFile &Obj) { |
764 | auto *MachO = dyn_cast<MachOObjectFile>(Val: &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(dest: &UUID, src: LC.Ptr+sizeof(LC.C), n: 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 | |
784 | using 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. |
789 | static ContributionCollection |
790 | collectContributionData(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(x: 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(C&: Contributions, |
799 | Comp: [](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 | first: std::unique(first: Contributions.begin(), last: Contributions.end(), |
811 | binary_pred: [](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 | last: 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). |
829 | static 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 = 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 | EC: errc::invalid_argument, |
864 | Fmt: "overlapping contributions to string offsets table in section .%s." , |
865 | Vals: SectionName.data())); |
866 | } |
867 | // Report a gap in the table. |
868 | if (Offset < ContributionHeader) { |
869 | OS << format(Fmt: "0x%8.8" PRIx64 ": Gap, length = " , Vals: Offset); |
870 | OS << (ContributionHeader - Offset) << "\n" ; |
871 | } |
872 | OS << format(Fmt: "0x%8.8" PRIx64 ": " , Vals: 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(Fmt: "0x%8.8" PRIx64 ": " , Vals: Offset); |
885 | uint64_t StringOffset = |
886 | StrOffsetExt.getRelocatedValue(Size: EntrySize, Off: &Offset); |
887 | OS << format(Fmt: "%0*" PRIx64 " " , Vals: OffsetDumpWidth, Vals: StringOffset); |
888 | const char *S = StrData.getCStr(OffsetPtr: &StringOffset); |
889 | if (S) |
890 | OS << format(Fmt: "\"%s\"" , Vals: S); |
891 | OS << "\n" ; |
892 | } |
893 | } |
894 | // Report a gap at the end of the table. |
895 | if (Offset < SectionSize) { |
896 | OS << format(Fmt: "0x%8.8" PRIx64 ": Gap, length = " , Vals: Offset); |
897 | OS << (SectionSize - Offset) << "\n" ; |
898 | } |
899 | } |
900 | |
901 | // Dump the .debug_addr section. |
902 | static void (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: Offset)) { |
907 | DWARFDebugAddrTable AddrTable; |
908 | uint64_t TableOffset = Offset; |
909 | if (Error Err = AddrTable.extract(Data: AddrData, OffsetPtr: &Offset, CUVersion: Version, CUAddrSize: AddrSize, |
910 | WarnCallback: 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). |
925 | static void ( |
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: Offset)) { |
932 | llvm::DWARFDebugRnglistTable Rnglists; |
933 | uint64_t TableOffset = Offset; |
934 | if (Error Err = Rnglists.extract(Data: rnglistData, OffsetPtr: &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(Data: rnglistData, OS, LookupPooledAddress, DumpOpts); |
944 | } |
945 | } |
946 | } |
947 | |
948 | |
949 | static void (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: Offset)) { |
955 | DWARFListTableHeader (".debug_loclists" , "locations" ); |
956 | if (Error E = Header.extract(Data, OffsetPtr: &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: &Offset, OS, /*BaseAddr=*/std::nullopt, Obj, |
970 | U: nullptr, DumpOpts, /*Indent=*/0); |
971 | OS << "\n" ; |
972 | return; |
973 | } |
974 | } else { |
975 | Loc.dumpRange(StartOffset: Offset, Size: EndOffset - Offset, OS, Obj, DumpOpts); |
976 | } |
977 | Offset = EndOffset; |
978 | } |
979 | } |
980 | |
981 | static void (raw_ostream &OS, DIDumpOptions DumpOpts, |
982 | DWARFDataExtractor Data, bool GnuStyle) { |
983 | DWARFDebugPubTable Table; |
984 | Table.extract(Data, GnuStyle, RecoverableErrorHandler: DumpOpts.RecoverableErrorHandler); |
985 | Table.dump(OS); |
986 | } |
987 | |
988 | void 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(path: 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, Obj: *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(Offset: *DumpOffset) |
1029 | .dump(OS, indent: 0, DumpOpts: DumpOpts.noImplicitRecursion()); |
1030 | DWARFDie CUDie = U->getUnitDIE(ExtractUnitDIEOnly: false); |
1031 | DWARFDie CUNonSkeletonDie = U->getNonSkeletonUnitDIE(ExtractUnitDIEOnly: false); |
1032 | if (CUNonSkeletonDie && CUDie != CUNonSkeletonDie) { |
1033 | CUNonSkeletonDie.getDwarfUnit() |
1034 | ->getDIEForOffset(Offset: *DumpOffset) |
1035 | .dump(OS, indent: 0, DumpOpts: 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(Offset: *DumpOffset) |
1054 | .dump(OS, indent: 0, DumpOpts: 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, Obj: *DObj, DumpOpts: LLDumpOpts, Offset: *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, DumpOpts: LLDumpOpts, Data, Obj: *DObj, DumpOffset: *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, DumpOpts: LLDumpOpts, Data, Obj: *DObj, DumpOffset: *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: &Offset, OS, |
1097 | /*BaseAddr=*/std::nullopt, Obj: *DObj, U: nullptr, |
1098 | DumpOpts: LLDumpOpts, |
1099 | /*Indent=*/0); |
1100 | OS << "\n" ; |
1101 | } else { |
1102 | Loc.dumpRange(StartOffset: 0, Size: Data.getData().size(), OS, Obj: *DObj, DumpOpts: 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, Offset: *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, Offset: *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(data: arangesData, offset_ptr: &offset, WarningHandler: 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(RecoverableErrorHandler: DumpOpts.WarningHandler, UnrecoverableErrorHandler: DumpOpts.WarningHandler); |
1170 | continue; |
1171 | } |
1172 | OS << "debug_line[" << format(Fmt: "0x%8.8" PRIx64, Vals: Parser.getOffset()) |
1173 | << "]\n" ; |
1174 | Parser.parseNext(RecoverableErrorHandler: DumpOpts.WarningHandler, UnrecoverableErrorHandler: DumpOpts.WarningHandler, OS: &OS, |
1175 | Verbose: 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: Offset)) { |
1184 | Error Err = Error::success(); |
1185 | const char *CStr = StrData.getCStr(OffsetPtr: &Offset, Err: &Err); |
1186 | if (Err) { |
1187 | DumpOpts.WarningHandler(std::move(Err)); |
1188 | return; |
1189 | } |
1190 | OS << format(Fmt: "0x%8.8" PRIx64 ": \"" , Vals: StrOffset); |
1191 | OS.write_escaped(Str: 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, Version: getMaxVersion(), AddrSize: 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(data: rangesData, offset_ptr: &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&: 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&: 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, Data: 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, Data: 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, Data: 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, Data: PubTableData, /*GnuStyle=*/true); |
1308 | } |
1309 | |
1310 | if (shouldDump(Explicit, ".debug_str_offsets" , DIDT_ID_DebugStrOffsets, |
1311 | DObj->getStrOffsetsSection().Data)) |
1312 | dumpStringOffsetsSection( |
1313 | OS, DumpOpts, SectionName: "debug_str_offsets" , Obj: *DObj, StringOffsetsSection: DObj->getStrOffsetsSection(), |
1314 | StringSection: DObj->getStrSection(), Units: normal_units(), LittleEndian: isLittleEndian()); |
1315 | if (shouldDump(ExplicitDWO, ".debug_str_offsets.dwo" , DIDT_ID_DebugStrOffsets, |
1316 | DObj->getStrOffsetsDWOSection().Data)) |
1317 | dumpStringOffsetsSection(OS, DumpOpts, SectionName: "debug_str_offsets.dwo" , Obj: *DObj, |
1318 | StringOffsetsSection: DObj->getStrOffsetsDWOSection(), |
1319 | StringSection: DObj->getStrDWOSection(), Units: dwo_units(), |
1320 | LittleEndian: 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 | |
1347 | DWARFTypeUnit *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(Offset: Hash)) |
1352 | return dyn_cast_or_null<DWARFTypeUnit>( |
1353 | Val: DWOUnits.getUnitForIndexEntry(E: *R)); |
1354 | return nullptr; |
1355 | } |
1356 | return State->getTypeUnitMap(IsDWO).lookup(Val: Hash); |
1357 | } |
1358 | |
1359 | DWARFCompileUnit *DWARFContext::getDWOCompileUnitForHash(uint64_t Hash) { |
1360 | DWARFUnitVector &DWOUnits = State->getDWOUnits(Lazy: LazyParse); |
1361 | |
1362 | if (const auto &CUI = getCUIndex()) { |
1363 | if (const auto *R = CUI.getFromHash(Offset: Hash)) |
1364 | return dyn_cast_or_null<DWARFCompileUnit>( |
1365 | Val: DWOUnits.getUnitForIndexEntry(E: *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(V: DWOCU->getUnitDIE().find(Attr: 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>(Val: DWOCU.get()); |
1385 | } |
1386 | return nullptr; |
1387 | } |
1388 | |
1389 | DWARFDie DWARFContext::getDIEForOffset(uint64_t Offset) { |
1390 | if (auto *CU = State->getNormalUnits().getUnitForOffset(Offset)) |
1391 | return CU->getDIEForOffset(Offset); |
1392 | return DWARFDie(); |
1393 | } |
1394 | |
1395 | bool 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 | verifier.summarize(); |
1412 | return Success; |
1413 | } |
1414 | |
1415 | const DWARFUnitIndex &DWARFContext::getCUIndex() { |
1416 | return State->getCUIndex(); |
1417 | } |
1418 | |
1419 | const DWARFUnitIndex &DWARFContext::getTUIndex() { |
1420 | return State->getTUIndex(); |
1421 | } |
1422 | |
1423 | DWARFGdbIndex &DWARFContext::getGdbIndex() { |
1424 | return State->getGdbIndex(); |
1425 | } |
1426 | |
1427 | const DWARFDebugAbbrev *DWARFContext::getDebugAbbrev() { |
1428 | return State->getDebugAbbrev(); |
1429 | } |
1430 | |
1431 | const DWARFDebugAbbrev *DWARFContext::getDebugAbbrevDWO() { |
1432 | return State->getDebugAbbrevDWO(); |
1433 | } |
1434 | |
1435 | const DWARFDebugLoc *DWARFContext::getDebugLoc() { |
1436 | return State->getDebugLoc(); |
1437 | } |
1438 | |
1439 | const DWARFDebugAranges *DWARFContext::getDebugAranges() { |
1440 | return State->getDebugAranges(); |
1441 | } |
1442 | |
1443 | Expected<const DWARFDebugFrame *> DWARFContext::getDebugFrame() { |
1444 | return State->getDebugFrame(); |
1445 | } |
1446 | |
1447 | Expected<const DWARFDebugFrame *> DWARFContext::getEHFrame() { |
1448 | return State->getEHFrame(); |
1449 | } |
1450 | |
1451 | const DWARFDebugMacro *DWARFContext::getDebugMacro() { |
1452 | return State->getDebugMacro(); |
1453 | } |
1454 | |
1455 | const DWARFDebugMacro *DWARFContext::getDebugMacroDWO() { |
1456 | return State->getDebugMacroDWO(); |
1457 | } |
1458 | |
1459 | const DWARFDebugMacro *DWARFContext::getDebugMacinfo() { |
1460 | return State->getDebugMacinfo(); |
1461 | } |
1462 | |
1463 | const DWARFDebugMacro *DWARFContext::getDebugMacinfoDWO() { |
1464 | return State->getDebugMacinfoDWO(); |
1465 | } |
1466 | |
1467 | |
1468 | const DWARFDebugNames &DWARFContext::getDebugNames() { |
1469 | return State->getDebugNames(); |
1470 | } |
1471 | |
1472 | const AppleAcceleratorTable &DWARFContext::getAppleNames() { |
1473 | return State->getAppleNames(); |
1474 | } |
1475 | |
1476 | const AppleAcceleratorTable &DWARFContext::getAppleTypes() { |
1477 | return State->getAppleTypes(); |
1478 | } |
1479 | |
1480 | const AppleAcceleratorTable &DWARFContext::getAppleNamespaces() { |
1481 | return State->getAppleNamespaces(); |
1482 | } |
1483 | |
1484 | const AppleAcceleratorTable &DWARFContext::getAppleObjC() { |
1485 | return State->getAppleObjC(); |
1486 | } |
1487 | |
1488 | const DWARFDebugLine::LineTable * |
1489 | DWARFContext::getLineTableForUnit(DWARFUnit *U) { |
1490 | Expected<const DWARFDebugLine::LineTable *> ExpectedLineTable = |
1491 | getLineTableForUnit(U, RecoverableErrorHandler: WarningHandler); |
1492 | if (!ExpectedLineTable) { |
1493 | WarningHandler(ExpectedLineTable.takeError()); |
1494 | return nullptr; |
1495 | } |
1496 | return *ExpectedLineTable; |
1497 | } |
1498 | |
1499 | Expected<const DWARFDebugLine::LineTable *> DWARFContext::getLineTableForUnit( |
1500 | DWARFUnit *U, function_ref<void(Error)> RecoverableErrorHandler) { |
1501 | return State->getLineTableForUnit(U, RecoverableErrHandler: RecoverableErrorHandler); |
1502 | } |
1503 | |
1504 | void DWARFContext::clearLineTableForUnit(DWARFUnit *U) { |
1505 | return State->clearLineTableForUnit(U); |
1506 | } |
1507 | |
1508 | DWARFUnitVector &DWARFContext::getDWOUnits(bool Lazy) { |
1509 | return State->getDWOUnits(Lazy); |
1510 | } |
1511 | |
1512 | DWARFCompileUnit *DWARFContext::getCompileUnitForOffset(uint64_t Offset) { |
1513 | return dyn_cast_or_null<DWARFCompileUnit>( |
1514 | Val: State->getNormalUnits().getUnitForOffset(Offset)); |
1515 | } |
1516 | |
1517 | DWARFCompileUnit *DWARFContext::getCompileUnitForCodeAddress(uint64_t Address) { |
1518 | uint64_t CUOffset = getDebugAranges()->findAddress(Address); |
1519 | return getCompileUnitForOffset(Offset: CUOffset); |
1520 | } |
1521 | |
1522 | DWARFCompileUnit *DWARFContext::getCompileUnitForDataAddress(uint64_t Address) { |
1523 | uint64_t CUOffset = getDebugAranges()->findAddress(Address); |
1524 | if (DWARFCompileUnit *OffsetCU = getCompileUnitForOffset(Offset: CUOffset)) |
1525 | return OffsetCU; |
1526 | |
1527 | // Global variables are often missed by the above search, for one of two |
1528 | // reasons: |
1529 | // 1. .debug_aranges may not include global variables. On clang, it seems we |
1530 | // put the globals in the aranges, but this isn't true for gcc. |
1531 | // 2. Even if the global variable is in a .debug_arange, global variables |
1532 | // may not be captured in the [start, end) addresses described by the |
1533 | // parent compile unit. |
1534 | // |
1535 | // So, we walk the CU's and their child DI's manually, looking for the |
1536 | // specific global variable. |
1537 | for (std::unique_ptr<DWARFUnit> &CU : compile_units()) { |
1538 | if (CU->getVariableForAddress(Address)) { |
1539 | return static_cast<DWARFCompileUnit *>(CU.get()); |
1540 | } |
1541 | } |
1542 | return nullptr; |
1543 | } |
1544 | |
1545 | DWARFContext::DIEsForAddress DWARFContext::getDIEsForAddress(uint64_t Address, |
1546 | bool CheckDWO) { |
1547 | DIEsForAddress Result; |
1548 | |
1549 | DWARFCompileUnit *CU = getCompileUnitForCodeAddress(Address); |
1550 | if (!CU) |
1551 | return Result; |
1552 | |
1553 | if (CheckDWO) { |
1554 | // We were asked to check the DWO file and this debug information is more |
1555 | // complete that any information in the skeleton compile unit, so search the |
1556 | // DWO first to see if we have a match. |
1557 | DWARFDie CUDie = CU->getUnitDIE(ExtractUnitDIEOnly: false); |
1558 | DWARFDie CUDwoDie = CU->getNonSkeletonUnitDIE(ExtractUnitDIEOnly: false); |
1559 | if (CheckDWO && CUDwoDie && CUDie != CUDwoDie) { |
1560 | // We have a DWO file, lets search it. |
1561 | DWARFCompileUnit *CUDwo = |
1562 | dyn_cast_or_null<DWARFCompileUnit>(Val: CUDwoDie.getDwarfUnit()); |
1563 | if (CUDwo) { |
1564 | Result.FunctionDIE = CUDwo->getSubroutineForAddress(Address); |
1565 | if (Result.FunctionDIE) |
1566 | Result.CompileUnit = CUDwo; |
1567 | } |
1568 | } |
1569 | } |
1570 | |
1571 | // Search the normal DWARF if we didn't find a match in the DWO file or if |
1572 | // we didn't check the DWO file above. |
1573 | if (!Result) { |
1574 | Result.CompileUnit = CU; |
1575 | Result.FunctionDIE = CU->getSubroutineForAddress(Address); |
1576 | } |
1577 | |
1578 | std::vector<DWARFDie> Worklist; |
1579 | Worklist.push_back(x: Result.FunctionDIE); |
1580 | while (!Worklist.empty()) { |
1581 | DWARFDie DIE = Worklist.back(); |
1582 | Worklist.pop_back(); |
1583 | |
1584 | if (!DIE.isValid()) |
1585 | continue; |
1586 | |
1587 | if (DIE.getTag() == DW_TAG_lexical_block && |
1588 | DIE.addressRangeContainsAddress(Address)) { |
1589 | Result.BlockDIE = DIE; |
1590 | break; |
1591 | } |
1592 | |
1593 | append_range(C&: Worklist, R&: DIE); |
1594 | } |
1595 | |
1596 | return Result; |
1597 | } |
1598 | |
1599 | /// TODO: change input parameter from "uint64_t Address" |
1600 | /// into "SectionedAddress Address" |
1601 | static bool getFunctionNameAndStartLineForAddress( |
1602 | DWARFCompileUnit *CU, uint64_t Address, FunctionNameKind Kind, |
1603 | DILineInfoSpecifier::FileLineInfoKind FileNameKind, |
1604 | std::string &FunctionName, std::string &StartFile, uint32_t &StartLine, |
1605 | std::optional<uint64_t> &StartAddress) { |
1606 | // The address may correspond to instruction in some inlined function, |
1607 | // so we have to build the chain of inlined functions and take the |
1608 | // name of the topmost function in it. |
1609 | SmallVector<DWARFDie, 4> InlinedChain; |
1610 | CU->getInlinedChainForAddress(Address, InlinedChain); |
1611 | if (InlinedChain.empty()) |
1612 | return false; |
1613 | |
1614 | const DWARFDie &DIE = InlinedChain[0]; |
1615 | bool FoundResult = false; |
1616 | const char *Name = nullptr; |
1617 | if (Kind != FunctionNameKind::None && (Name = DIE.getSubroutineName(Kind))) { |
1618 | FunctionName = Name; |
1619 | FoundResult = true; |
1620 | } |
1621 | std::string DeclFile = DIE.getDeclFile(Kind: FileNameKind); |
1622 | if (!DeclFile.empty()) { |
1623 | StartFile = DeclFile; |
1624 | FoundResult = true; |
1625 | } |
1626 | if (auto DeclLineResult = DIE.getDeclLine()) { |
1627 | StartLine = DeclLineResult; |
1628 | FoundResult = true; |
1629 | } |
1630 | if (auto LowPcAddr = toSectionedAddress(V: DIE.find(Attr: DW_AT_low_pc))) |
1631 | StartAddress = LowPcAddr->Address; |
1632 | return FoundResult; |
1633 | } |
1634 | |
1635 | static std::optional<int64_t> |
1636 | getExpressionFrameOffset(ArrayRef<uint8_t> Expr, |
1637 | std::optional<unsigned> FrameBaseReg) { |
1638 | if (!Expr.empty() && |
1639 | (Expr[0] == DW_OP_fbreg || |
1640 | (FrameBaseReg && Expr[0] == DW_OP_breg0 + *FrameBaseReg))) { |
1641 | unsigned Count; |
1642 | int64_t Offset = decodeSLEB128(p: Expr.data() + 1, n: &Count, end: Expr.end()); |
1643 | // A single DW_OP_fbreg or DW_OP_breg. |
1644 | if (Expr.size() == Count + 1) |
1645 | return Offset; |
1646 | // Same + DW_OP_deref (Fortran arrays look like this). |
1647 | if (Expr.size() == Count + 2 && Expr[Count + 1] == DW_OP_deref) |
1648 | return Offset; |
1649 | // Fallthrough. Do not accept ex. (DW_OP_breg W29, DW_OP_stack_value) |
1650 | } |
1651 | return std::nullopt; |
1652 | } |
1653 | |
1654 | void DWARFContext::addLocalsForDie(DWARFCompileUnit *CU, DWARFDie Subprogram, |
1655 | DWARFDie Die, std::vector<DILocal> &Result) { |
1656 | if (Die.getTag() == DW_TAG_variable || |
1657 | Die.getTag() == DW_TAG_formal_parameter) { |
1658 | DILocal Local; |
1659 | if (const char *Name = Subprogram.getSubroutineName(Kind: DINameKind::ShortName)) |
1660 | Local.FunctionName = Name; |
1661 | |
1662 | std::optional<unsigned> FrameBaseReg; |
1663 | if (auto FrameBase = Subprogram.find(Attr: DW_AT_frame_base)) |
1664 | if (std::optional<ArrayRef<uint8_t>> Expr = FrameBase->getAsBlock()) |
1665 | if (!Expr->empty() && (*Expr)[0] >= DW_OP_reg0 && |
1666 | (*Expr)[0] <= DW_OP_reg31) { |
1667 | FrameBaseReg = (*Expr)[0] - DW_OP_reg0; |
1668 | } |
1669 | |
1670 | if (Expected<std::vector<DWARFLocationExpression>> Loc = |
1671 | Die.getLocations(Attr: DW_AT_location)) { |
1672 | for (const auto &Entry : *Loc) { |
1673 | if (std::optional<int64_t> FrameOffset = |
1674 | getExpressionFrameOffset(Expr: Entry.Expr, FrameBaseReg)) { |
1675 | Local.FrameOffset = *FrameOffset; |
1676 | break; |
1677 | } |
1678 | } |
1679 | } else { |
1680 | // FIXME: missing DW_AT_location is OK here, but other errors should be |
1681 | // reported to the user. |
1682 | consumeError(Err: Loc.takeError()); |
1683 | } |
1684 | |
1685 | if (auto TagOffsetAttr = Die.find(Attr: DW_AT_LLVM_tag_offset)) |
1686 | Local.TagOffset = TagOffsetAttr->getAsUnsignedConstant(); |
1687 | |
1688 | if (auto Origin = |
1689 | Die.getAttributeValueAsReferencedDie(Attr: DW_AT_abstract_origin)) |
1690 | Die = Origin; |
1691 | if (auto NameAttr = Die.find(Attr: DW_AT_name)) |
1692 | if (std::optional<const char *> Name = dwarf::toString(V: *NameAttr)) |
1693 | Local.Name = *Name; |
1694 | if (auto Type = Die.getAttributeValueAsReferencedDie(Attr: DW_AT_type)) |
1695 | Local.Size = Type.getTypeSize(PointerSize: getCUAddrSize()); |
1696 | if (auto DeclFileAttr = Die.find(Attr: DW_AT_decl_file)) { |
1697 | if (const auto *LT = CU->getContext().getLineTableForUnit(U: CU)) |
1698 | LT->getFileNameByIndex( |
1699 | FileIndex: *DeclFileAttr->getAsUnsignedConstant(), CompDir: CU->getCompilationDir(), |
1700 | Kind: DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath, |
1701 | Result&: Local.DeclFile); |
1702 | } |
1703 | if (auto DeclLineAttr = Die.find(Attr: DW_AT_decl_line)) |
1704 | Local.DeclLine = *DeclLineAttr->getAsUnsignedConstant(); |
1705 | |
1706 | Result.push_back(x: Local); |
1707 | return; |
1708 | } |
1709 | |
1710 | if (Die.getTag() == DW_TAG_inlined_subroutine) |
1711 | if (auto Origin = |
1712 | Die.getAttributeValueAsReferencedDie(Attr: DW_AT_abstract_origin)) |
1713 | Subprogram = Origin; |
1714 | |
1715 | for (auto Child : Die) |
1716 | addLocalsForDie(CU, Subprogram, Die: Child, Result); |
1717 | } |
1718 | |
1719 | std::vector<DILocal> |
1720 | DWARFContext::getLocalsForAddress(object::SectionedAddress Address) { |
1721 | std::vector<DILocal> Result; |
1722 | DWARFCompileUnit *CU = getCompileUnitForCodeAddress(Address: Address.Address); |
1723 | if (!CU) |
1724 | return Result; |
1725 | |
1726 | DWARFDie Subprogram = CU->getSubroutineForAddress(Address: Address.Address); |
1727 | if (Subprogram.isValid()) |
1728 | addLocalsForDie(CU, Subprogram, Die: Subprogram, Result); |
1729 | return Result; |
1730 | } |
1731 | |
1732 | DILineInfo DWARFContext::getLineInfoForAddress(object::SectionedAddress Address, |
1733 | DILineInfoSpecifier Spec) { |
1734 | DILineInfo Result; |
1735 | DWARFCompileUnit *CU = getCompileUnitForCodeAddress(Address: Address.Address); |
1736 | if (!CU) |
1737 | return Result; |
1738 | |
1739 | getFunctionNameAndStartLineForAddress( |
1740 | CU, Address: Address.Address, Kind: Spec.FNKind, FileNameKind: Spec.FLIKind, FunctionName&: Result.FunctionName, |
1741 | StartFile&: Result.StartFileName, StartLine&: Result.StartLine, StartAddress&: Result.StartAddress); |
1742 | if (Spec.FLIKind != FileLineInfoKind::None) { |
1743 | if (const DWARFLineTable *LineTable = getLineTableForUnit(U: CU)) { |
1744 | LineTable->getFileLineInfoForAddress( |
1745 | Address: {.Address: Address.Address, .SectionIndex: Address.SectionIndex}, CompDir: CU->getCompilationDir(), |
1746 | Kind: Spec.FLIKind, Result); |
1747 | } |
1748 | } |
1749 | |
1750 | return Result; |
1751 | } |
1752 | |
1753 | DILineInfo |
1754 | DWARFContext::getLineInfoForDataAddress(object::SectionedAddress Address) { |
1755 | DILineInfo Result; |
1756 | DWARFCompileUnit *CU = getCompileUnitForDataAddress(Address: Address.Address); |
1757 | if (!CU) |
1758 | return Result; |
1759 | |
1760 | if (DWARFDie Die = CU->getVariableForAddress(Address: Address.Address)) { |
1761 | Result.FileName = Die.getDeclFile(Kind: FileLineInfoKind::AbsoluteFilePath); |
1762 | Result.Line = Die.getDeclLine(); |
1763 | } |
1764 | |
1765 | return Result; |
1766 | } |
1767 | |
1768 | DILineInfoTable DWARFContext::getLineInfoForAddressRange( |
1769 | object::SectionedAddress Address, uint64_t Size, DILineInfoSpecifier Spec) { |
1770 | DILineInfoTable Lines; |
1771 | DWARFCompileUnit *CU = getCompileUnitForCodeAddress(Address: Address.Address); |
1772 | if (!CU) |
1773 | return Lines; |
1774 | |
1775 | uint32_t StartLine = 0; |
1776 | std::string StartFileName; |
1777 | std::string FunctionName(DILineInfo::BadString); |
1778 | std::optional<uint64_t> StartAddress; |
1779 | getFunctionNameAndStartLineForAddress(CU, Address: Address.Address, Kind: Spec.FNKind, |
1780 | FileNameKind: Spec.FLIKind, FunctionName, |
1781 | StartFile&: StartFileName, StartLine, StartAddress); |
1782 | |
1783 | // If the Specifier says we don't need FileLineInfo, just |
1784 | // return the top-most function at the starting address. |
1785 | if (Spec.FLIKind == FileLineInfoKind::None) { |
1786 | DILineInfo Result; |
1787 | Result.FunctionName = FunctionName; |
1788 | Result.StartFileName = StartFileName; |
1789 | Result.StartLine = StartLine; |
1790 | Result.StartAddress = StartAddress; |
1791 | Lines.push_back(Elt: std::make_pair(x&: Address.Address, y&: Result)); |
1792 | return Lines; |
1793 | } |
1794 | |
1795 | const DWARFLineTable *LineTable = getLineTableForUnit(U: CU); |
1796 | |
1797 | // Get the index of row we're looking for in the line table. |
1798 | std::vector<uint32_t> RowVector; |
1799 | if (!LineTable->lookupAddressRange(Address: {.Address: Address.Address, .SectionIndex: Address.SectionIndex}, |
1800 | Size, Result&: RowVector)) { |
1801 | return Lines; |
1802 | } |
1803 | |
1804 | for (uint32_t RowIndex : RowVector) { |
1805 | // Take file number and line/column from the row. |
1806 | const DWARFDebugLine::Row &Row = LineTable->Rows[RowIndex]; |
1807 | DILineInfo Result; |
1808 | LineTable->getFileNameByIndex(FileIndex: Row.File, CompDir: CU->getCompilationDir(), |
1809 | Kind: Spec.FLIKind, Result&: Result.FileName); |
1810 | Result.FunctionName = FunctionName; |
1811 | Result.Line = Row.Line; |
1812 | Result.Column = Row.Column; |
1813 | Result.StartFileName = StartFileName; |
1814 | Result.StartLine = StartLine; |
1815 | Result.StartAddress = StartAddress; |
1816 | Lines.push_back(Elt: std::make_pair(x: Row.Address.Address, y&: Result)); |
1817 | } |
1818 | |
1819 | return Lines; |
1820 | } |
1821 | |
1822 | DIInliningInfo |
1823 | DWARFContext::getInliningInfoForAddress(object::SectionedAddress Address, |
1824 | DILineInfoSpecifier Spec) { |
1825 | DIInliningInfo InliningInfo; |
1826 | |
1827 | DWARFCompileUnit *CU = getCompileUnitForCodeAddress(Address: Address.Address); |
1828 | if (!CU) |
1829 | return InliningInfo; |
1830 | |
1831 | const DWARFLineTable *LineTable = nullptr; |
1832 | SmallVector<DWARFDie, 4> InlinedChain; |
1833 | CU->getInlinedChainForAddress(Address: Address.Address, InlinedChain); |
1834 | if (InlinedChain.size() == 0) { |
1835 | // If there is no DIE for address (e.g. it is in unavailable .dwo file), |
1836 | // try to at least get file/line info from symbol table. |
1837 | if (Spec.FLIKind != FileLineInfoKind::None) { |
1838 | DILineInfo Frame; |
1839 | LineTable = getLineTableForUnit(U: CU); |
1840 | if (LineTable && LineTable->getFileLineInfoForAddress( |
1841 | Address: {.Address: Address.Address, .SectionIndex: Address.SectionIndex}, |
1842 | CompDir: CU->getCompilationDir(), Kind: Spec.FLIKind, Result&: Frame)) |
1843 | InliningInfo.addFrame(Frame); |
1844 | } |
1845 | return InliningInfo; |
1846 | } |
1847 | |
1848 | uint32_t CallFile = 0, CallLine = 0, CallColumn = 0, CallDiscriminator = 0; |
1849 | for (uint32_t i = 0, n = InlinedChain.size(); i != n; i++) { |
1850 | DWARFDie &FunctionDIE = InlinedChain[i]; |
1851 | DILineInfo Frame; |
1852 | // Get function name if necessary. |
1853 | if (const char *Name = FunctionDIE.getSubroutineName(Kind: Spec.FNKind)) |
1854 | Frame.FunctionName = Name; |
1855 | if (auto DeclLineResult = FunctionDIE.getDeclLine()) |
1856 | Frame.StartLine = DeclLineResult; |
1857 | Frame.StartFileName = FunctionDIE.getDeclFile(Kind: Spec.FLIKind); |
1858 | if (auto LowPcAddr = toSectionedAddress(V: FunctionDIE.find(Attr: DW_AT_low_pc))) |
1859 | Frame.StartAddress = LowPcAddr->Address; |
1860 | if (Spec.FLIKind != FileLineInfoKind::None) { |
1861 | if (i == 0) { |
1862 | // For the topmost frame, initialize the line table of this |
1863 | // compile unit and fetch file/line info from it. |
1864 | LineTable = getLineTableForUnit(U: CU); |
1865 | // For the topmost routine, get file/line info from line table. |
1866 | if (LineTable) |
1867 | LineTable->getFileLineInfoForAddress( |
1868 | Address: {.Address: Address.Address, .SectionIndex: Address.SectionIndex}, CompDir: CU->getCompilationDir(), |
1869 | Kind: Spec.FLIKind, Result&: Frame); |
1870 | } else { |
1871 | // Otherwise, use call file, call line and call column from |
1872 | // previous DIE in inlined chain. |
1873 | if (LineTable) |
1874 | LineTable->getFileNameByIndex(FileIndex: CallFile, CompDir: CU->getCompilationDir(), |
1875 | Kind: Spec.FLIKind, Result&: Frame.FileName); |
1876 | Frame.Line = CallLine; |
1877 | Frame.Column = CallColumn; |
1878 | Frame.Discriminator = CallDiscriminator; |
1879 | } |
1880 | // Get call file/line/column of a current DIE. |
1881 | if (i + 1 < n) { |
1882 | FunctionDIE.getCallerFrame(CallFile, CallLine, CallColumn, |
1883 | CallDiscriminator); |
1884 | } |
1885 | } |
1886 | InliningInfo.addFrame(Frame); |
1887 | } |
1888 | return InliningInfo; |
1889 | } |
1890 | |
1891 | std::shared_ptr<DWARFContext> |
1892 | DWARFContext::getDWOContext(StringRef AbsolutePath) { |
1893 | return State->getDWOContext(AbsolutePath); |
1894 | } |
1895 | |
1896 | static Error createError(const Twine &Reason, llvm::Error E) { |
1897 | return make_error<StringError>(Args: Reason + toString(E: std::move(E)), |
1898 | Args: inconvertibleErrorCode()); |
1899 | } |
1900 | |
1901 | /// SymInfo contains information about symbol: it's address |
1902 | /// and section index which is -1LL for absolute symbols. |
1903 | struct SymInfo { |
1904 | uint64_t Address; |
1905 | uint64_t SectionIndex; |
1906 | }; |
1907 | |
1908 | /// Returns the address of symbol relocation used against and a section index. |
1909 | /// Used for futher relocations computation. Symbol's section load address is |
1910 | static Expected<SymInfo> getSymbolInfo(const object::ObjectFile &Obj, |
1911 | const RelocationRef &Reloc, |
1912 | const LoadedObjectInfo *L, |
1913 | std::map<SymbolRef, SymInfo> &Cache) { |
1914 | SymInfo Ret = {.Address: 0, .SectionIndex: (uint64_t)-1LL}; |
1915 | object::section_iterator RSec = Obj.section_end(); |
1916 | object::symbol_iterator Sym = Reloc.getSymbol(); |
1917 | |
1918 | std::map<SymbolRef, SymInfo>::iterator CacheIt = Cache.end(); |
1919 | // First calculate the address of the symbol or section as it appears |
1920 | // in the object file |
1921 | if (Sym != Obj.symbol_end()) { |
1922 | bool New; |
1923 | std::tie(args&: CacheIt, args&: New) = Cache.insert(x: {*Sym, {.Address: 0, .SectionIndex: 0}}); |
1924 | if (!New) |
1925 | return CacheIt->second; |
1926 | |
1927 | Expected<uint64_t> SymAddrOrErr = Sym->getAddress(); |
1928 | if (!SymAddrOrErr) |
1929 | return createError(Reason: "failed to compute symbol address: " , |
1930 | E: SymAddrOrErr.takeError()); |
1931 | |
1932 | // Also remember what section this symbol is in for later |
1933 | auto SectOrErr = Sym->getSection(); |
1934 | if (!SectOrErr) |
1935 | return createError(Reason: "failed to get symbol section: " , |
1936 | E: SectOrErr.takeError()); |
1937 | |
1938 | RSec = *SectOrErr; |
1939 | Ret.Address = *SymAddrOrErr; |
1940 | } else if (auto *MObj = dyn_cast<MachOObjectFile>(Val: &Obj)) { |
1941 | RSec = MObj->getRelocationSection(Rel: Reloc.getRawDataRefImpl()); |
1942 | Ret.Address = RSec->getAddress(); |
1943 | } |
1944 | |
1945 | if (RSec != Obj.section_end()) |
1946 | Ret.SectionIndex = RSec->getIndex(); |
1947 | |
1948 | // If we are given load addresses for the sections, we need to adjust: |
1949 | // SymAddr = (Address of Symbol Or Section in File) - |
1950 | // (Address of Section in File) + |
1951 | // (Load Address of Section) |
1952 | // RSec is now either the section being targeted or the section |
1953 | // containing the symbol being targeted. In either case, |
1954 | // we need to perform the same computation. |
1955 | if (L && RSec != Obj.section_end()) |
1956 | if (uint64_t SectionLoadAddress = L->getSectionLoadAddress(Sec: *RSec)) |
1957 | Ret.Address += SectionLoadAddress - RSec->getAddress(); |
1958 | |
1959 | if (CacheIt != Cache.end()) |
1960 | CacheIt->second = Ret; |
1961 | |
1962 | return Ret; |
1963 | } |
1964 | |
1965 | static bool isRelocScattered(const object::ObjectFile &Obj, |
1966 | const RelocationRef &Reloc) { |
1967 | const MachOObjectFile *MachObj = dyn_cast<MachOObjectFile>(Val: &Obj); |
1968 | if (!MachObj) |
1969 | return false; |
1970 | // MachO also has relocations that point to sections and |
1971 | // scattered relocations. |
1972 | auto RelocInfo = MachObj->getRelocation(Rel: Reloc.getRawDataRefImpl()); |
1973 | return MachObj->isRelocationScattered(RE: RelocInfo); |
1974 | } |
1975 | |
1976 | namespace { |
1977 | struct DWARFSectionMap final : public DWARFSection { |
1978 | RelocAddrMap Relocs; |
1979 | }; |
1980 | |
1981 | class DWARFObjInMemory final : public DWARFObject { |
1982 | bool IsLittleEndian; |
1983 | uint8_t AddressSize; |
1984 | StringRef FileName; |
1985 | const object::ObjectFile *Obj = nullptr; |
1986 | std::vector<SectionName> SectionNames; |
1987 | |
1988 | using InfoSectionMap = MapVector<object::SectionRef, DWARFSectionMap, |
1989 | std::map<object::SectionRef, unsigned>>; |
1990 | |
1991 | InfoSectionMap InfoSections; |
1992 | InfoSectionMap TypesSections; |
1993 | InfoSectionMap InfoDWOSections; |
1994 | InfoSectionMap TypesDWOSections; |
1995 | |
1996 | DWARFSectionMap LocSection; |
1997 | DWARFSectionMap LoclistsSection; |
1998 | DWARFSectionMap LoclistsDWOSection; |
1999 | DWARFSectionMap LineSection; |
2000 | DWARFSectionMap RangesSection; |
2001 | DWARFSectionMap RnglistsSection; |
2002 | DWARFSectionMap StrOffsetsSection; |
2003 | DWARFSectionMap LineDWOSection; |
2004 | DWARFSectionMap FrameSection; |
2005 | DWARFSectionMap EHFrameSection; |
2006 | DWARFSectionMap LocDWOSection; |
2007 | DWARFSectionMap StrOffsetsDWOSection; |
2008 | DWARFSectionMap RangesDWOSection; |
2009 | DWARFSectionMap RnglistsDWOSection; |
2010 | DWARFSectionMap AddrSection; |
2011 | DWARFSectionMap AppleNamesSection; |
2012 | DWARFSectionMap AppleTypesSection; |
2013 | DWARFSectionMap AppleNamespacesSection; |
2014 | DWARFSectionMap AppleObjCSection; |
2015 | DWARFSectionMap NamesSection; |
2016 | DWARFSectionMap PubnamesSection; |
2017 | DWARFSectionMap PubtypesSection; |
2018 | DWARFSectionMap GnuPubnamesSection; |
2019 | DWARFSectionMap GnuPubtypesSection; |
2020 | DWARFSectionMap MacroSection; |
2021 | |
2022 | DWARFSectionMap *mapNameToDWARFSection(StringRef Name) { |
2023 | return StringSwitch<DWARFSectionMap *>(Name) |
2024 | .Case(S: "debug_loc" , Value: &LocSection) |
2025 | .Case(S: "debug_loclists" , Value: &LoclistsSection) |
2026 | .Case(S: "debug_loclists.dwo" , Value: &LoclistsDWOSection) |
2027 | .Case(S: "debug_line" , Value: &LineSection) |
2028 | .Case(S: "debug_frame" , Value: &FrameSection) |
2029 | .Case(S: "eh_frame" , Value: &EHFrameSection) |
2030 | .Case(S: "debug_str_offsets" , Value: &StrOffsetsSection) |
2031 | .Case(S: "debug_ranges" , Value: &RangesSection) |
2032 | .Case(S: "debug_rnglists" , Value: &RnglistsSection) |
2033 | .Case(S: "debug_loc.dwo" , Value: &LocDWOSection) |
2034 | .Case(S: "debug_line.dwo" , Value: &LineDWOSection) |
2035 | .Case(S: "debug_names" , Value: &NamesSection) |
2036 | .Case(S: "debug_rnglists.dwo" , Value: &RnglistsDWOSection) |
2037 | .Case(S: "debug_str_offsets.dwo" , Value: &StrOffsetsDWOSection) |
2038 | .Case(S: "debug_addr" , Value: &AddrSection) |
2039 | .Case(S: "apple_names" , Value: &AppleNamesSection) |
2040 | .Case(S: "debug_pubnames" , Value: &PubnamesSection) |
2041 | .Case(S: "debug_pubtypes" , Value: &PubtypesSection) |
2042 | .Case(S: "debug_gnu_pubnames" , Value: &GnuPubnamesSection) |
2043 | .Case(S: "debug_gnu_pubtypes" , Value: &GnuPubtypesSection) |
2044 | .Case(S: "apple_types" , Value: &AppleTypesSection) |
2045 | .Case(S: "apple_namespaces" , Value: &AppleNamespacesSection) |
2046 | .Case(S: "apple_namespac" , Value: &AppleNamespacesSection) |
2047 | .Case(S: "apple_objc" , Value: &AppleObjCSection) |
2048 | .Case(S: "debug_macro" , Value: &MacroSection) |
2049 | .Default(Value: nullptr); |
2050 | } |
2051 | |
2052 | StringRef AbbrevSection; |
2053 | StringRef ArangesSection; |
2054 | StringRef StrSection; |
2055 | StringRef MacinfoSection; |
2056 | StringRef MacinfoDWOSection; |
2057 | StringRef MacroDWOSection; |
2058 | StringRef AbbrevDWOSection; |
2059 | StringRef StrDWOSection; |
2060 | StringRef CUIndexSection; |
2061 | StringRef GdbIndexSection; |
2062 | StringRef TUIndexSection; |
2063 | StringRef LineStrSection; |
2064 | |
2065 | // A deque holding section data whose iterators are not invalidated when |
2066 | // new decompressed sections are inserted at the end. |
2067 | std::deque<SmallString<0>> UncompressedSections; |
2068 | |
2069 | StringRef *mapSectionToMember(StringRef Name) { |
2070 | if (DWARFSection *Sec = mapNameToDWARFSection(Name)) |
2071 | return &Sec->Data; |
2072 | return StringSwitch<StringRef *>(Name) |
2073 | .Case(S: "debug_abbrev" , Value: &AbbrevSection) |
2074 | .Case(S: "debug_aranges" , Value: &ArangesSection) |
2075 | .Case(S: "debug_str" , Value: &StrSection) |
2076 | .Case(S: "debug_macinfo" , Value: &MacinfoSection) |
2077 | .Case(S: "debug_macinfo.dwo" , Value: &MacinfoDWOSection) |
2078 | .Case(S: "debug_macro.dwo" , Value: &MacroDWOSection) |
2079 | .Case(S: "debug_abbrev.dwo" , Value: &AbbrevDWOSection) |
2080 | .Case(S: "debug_str.dwo" , Value: &StrDWOSection) |
2081 | .Case(S: "debug_cu_index" , Value: &CUIndexSection) |
2082 | .Case(S: "debug_tu_index" , Value: &TUIndexSection) |
2083 | .Case(S: "gdb_index" , Value: &GdbIndexSection) |
2084 | .Case(S: "debug_line_str" , Value: &LineStrSection) |
2085 | // Any more debug info sections go here. |
2086 | .Default(Value: nullptr); |
2087 | } |
2088 | |
2089 | /// If Sec is compressed section, decompresses and updates its contents |
2090 | /// provided by Data. Otherwise leaves it unchanged. |
2091 | Error maybeDecompress(const object::SectionRef &Sec, StringRef Name, |
2092 | StringRef &Data) { |
2093 | if (!Sec.isCompressed()) |
2094 | return Error::success(); |
2095 | |
2096 | Expected<Decompressor> Decompressor = |
2097 | Decompressor::create(Name, Data, IsLE: IsLittleEndian, Is64Bit: AddressSize == 8); |
2098 | if (!Decompressor) |
2099 | return Decompressor.takeError(); |
2100 | |
2101 | SmallString<0> Out; |
2102 | if (auto Err = Decompressor->resizeAndDecompress(Out)) |
2103 | return Err; |
2104 | |
2105 | UncompressedSections.push_back(x: std::move(Out)); |
2106 | Data = UncompressedSections.back(); |
2107 | |
2108 | return Error::success(); |
2109 | } |
2110 | |
2111 | public: |
2112 | DWARFObjInMemory(const StringMap<std::unique_ptr<MemoryBuffer>> &Sections, |
2113 | uint8_t AddrSize, bool IsLittleEndian) |
2114 | : IsLittleEndian(IsLittleEndian) { |
2115 | for (const auto &SecIt : Sections) { |
2116 | if (StringRef *SectionData = mapSectionToMember(Name: SecIt.first())) |
2117 | *SectionData = SecIt.second->getBuffer(); |
2118 | else if (SecIt.first() == "debug_info" ) |
2119 | // Find debug_info and debug_types data by section rather than name as |
2120 | // there are multiple, comdat grouped, of these sections. |
2121 | InfoSections[SectionRef()].Data = SecIt.second->getBuffer(); |
2122 | else if (SecIt.first() == "debug_info.dwo" ) |
2123 | InfoDWOSections[SectionRef()].Data = SecIt.second->getBuffer(); |
2124 | else if (SecIt.first() == "debug_types" ) |
2125 | TypesSections[SectionRef()].Data = SecIt.second->getBuffer(); |
2126 | else if (SecIt.first() == "debug_types.dwo" ) |
2127 | TypesDWOSections[SectionRef()].Data = SecIt.second->getBuffer(); |
2128 | } |
2129 | } |
2130 | DWARFObjInMemory(const object::ObjectFile &Obj, const LoadedObjectInfo *L, |
2131 | function_ref<void(Error)> HandleError, |
2132 | function_ref<void(Error)> HandleWarning, |
2133 | DWARFContext::ProcessDebugRelocations RelocAction) |
2134 | : IsLittleEndian(Obj.isLittleEndian()), |
2135 | AddressSize(Obj.getBytesInAddress()), FileName(Obj.getFileName()), |
2136 | Obj(&Obj) { |
2137 | |
2138 | StringMap<unsigned> SectionAmountMap; |
2139 | for (const SectionRef &Section : Obj.sections()) { |
2140 | StringRef Name; |
2141 | if (auto NameOrErr = Section.getName()) |
2142 | Name = *NameOrErr; |
2143 | else |
2144 | consumeError(Err: NameOrErr.takeError()); |
2145 | |
2146 | ++SectionAmountMap[Name]; |
2147 | SectionNames.push_back(x: { .Name: Name, .IsNameUnique: true }); |
2148 | |
2149 | // Skip BSS and Virtual sections, they aren't interesting. |
2150 | if (Section.isBSS() || Section.isVirtual()) |
2151 | continue; |
2152 | |
2153 | // Skip sections stripped by dsymutil. |
2154 | if (Section.isStripped()) |
2155 | continue; |
2156 | |
2157 | StringRef Data; |
2158 | Expected<section_iterator> SecOrErr = Section.getRelocatedSection(); |
2159 | if (!SecOrErr) { |
2160 | HandleError(createError(Reason: "failed to get relocated section: " , |
2161 | E: SecOrErr.takeError())); |
2162 | continue; |
2163 | } |
2164 | |
2165 | // Try to obtain an already relocated version of this section. |
2166 | // Else use the unrelocated section from the object file. We'll have to |
2167 | // apply relocations ourselves later. |
2168 | section_iterator RelocatedSection = |
2169 | Obj.isRelocatableObject() ? *SecOrErr : Obj.section_end(); |
2170 | if (!L || !L->getLoadedSectionContents(Sec: *RelocatedSection, Data)) { |
2171 | Expected<StringRef> E = Section.getContents(); |
2172 | if (E) |
2173 | Data = *E; |
2174 | else |
2175 | // maybeDecompress below will error. |
2176 | consumeError(Err: E.takeError()); |
2177 | } |
2178 | |
2179 | if (auto Err = maybeDecompress(Sec: Section, Name, Data)) { |
2180 | HandleError(createError(Reason: "failed to decompress '" + Name + "', " , |
2181 | E: std::move(Err))); |
2182 | continue; |
2183 | } |
2184 | |
2185 | // Map platform specific debug section names to DWARF standard section |
2186 | // names. |
2187 | Name = Name.substr(Start: Name.find_first_not_of(Chars: "._" )); |
2188 | Name = Obj.mapDebugSectionName(Name); |
2189 | |
2190 | if (StringRef *SectionData = mapSectionToMember(Name)) { |
2191 | *SectionData = Data; |
2192 | if (Name == "debug_ranges" ) { |
2193 | // FIXME: Use the other dwo range section when we emit it. |
2194 | RangesDWOSection.Data = Data; |
2195 | } else if (Name == "debug_frame" || Name == "eh_frame" ) { |
2196 | if (DWARFSection *S = mapNameToDWARFSection(Name)) |
2197 | S->Address = Section.getAddress(); |
2198 | } |
2199 | } else if (InfoSectionMap *Sections = |
2200 | StringSwitch<InfoSectionMap *>(Name) |
2201 | .Case(S: "debug_info" , Value: &InfoSections) |
2202 | .Case(S: "debug_info.dwo" , Value: &InfoDWOSections) |
2203 | .Case(S: "debug_types" , Value: &TypesSections) |
2204 | .Case(S: "debug_types.dwo" , Value: &TypesDWOSections) |
2205 | .Default(Value: nullptr)) { |
2206 | // Find debug_info and debug_types data by section rather than name as |
2207 | // there are multiple, comdat grouped, of these sections. |
2208 | DWARFSectionMap &S = (*Sections)[Section]; |
2209 | S.Data = Data; |
2210 | } |
2211 | |
2212 | if (RelocatedSection == Obj.section_end() || |
2213 | (RelocAction == DWARFContext::ProcessDebugRelocations::Ignore)) |
2214 | continue; |
2215 | |
2216 | StringRef RelSecName; |
2217 | if (auto NameOrErr = RelocatedSection->getName()) |
2218 | RelSecName = *NameOrErr; |
2219 | else |
2220 | consumeError(Err: NameOrErr.takeError()); |
2221 | |
2222 | // If the section we're relocating was relocated already by the JIT, |
2223 | // then we used the relocated version above, so we do not need to process |
2224 | // relocations for it now. |
2225 | StringRef RelSecData; |
2226 | if (L && L->getLoadedSectionContents(Sec: *RelocatedSection, Data&: RelSecData)) |
2227 | continue; |
2228 | |
2229 | // In Mach-o files, the relocations do not need to be applied if |
2230 | // there is no load offset to apply. The value read at the |
2231 | // relocation point already factors in the section address |
2232 | // (actually applying the relocations will produce wrong results |
2233 | // as the section address will be added twice). |
2234 | if (!L && isa<MachOObjectFile>(Val: &Obj)) |
2235 | continue; |
2236 | |
2237 | if (!Section.relocations().empty() && Name.ends_with(Suffix: ".dwo" ) && |
2238 | RelSecName.starts_with(Prefix: ".debug" )) { |
2239 | HandleWarning(createError(Err: "unexpected relocations for dwo section '" + |
2240 | RelSecName + "'" )); |
2241 | } |
2242 | |
2243 | // TODO: Add support for relocations in other sections as needed. |
2244 | // Record relocations for the debug_info and debug_line sections. |
2245 | RelSecName = RelSecName.substr(Start: RelSecName.find_first_not_of(Chars: "._" )); |
2246 | DWARFSectionMap *Sec = mapNameToDWARFSection(Name: RelSecName); |
2247 | RelocAddrMap *Map = Sec ? &Sec->Relocs : nullptr; |
2248 | if (!Map) { |
2249 | // Find debug_info and debug_types relocs by section rather than name |
2250 | // as there are multiple, comdat grouped, of these sections. |
2251 | if (RelSecName == "debug_info" ) |
2252 | Map = &static_cast<DWARFSectionMap &>(InfoSections[*RelocatedSection]) |
2253 | .Relocs; |
2254 | else if (RelSecName == "debug_types" ) |
2255 | Map = |
2256 | &static_cast<DWARFSectionMap &>(TypesSections[*RelocatedSection]) |
2257 | .Relocs; |
2258 | else |
2259 | continue; |
2260 | } |
2261 | |
2262 | if (Section.relocation_begin() == Section.relocation_end()) |
2263 | continue; |
2264 | |
2265 | // Symbol to [address, section index] cache mapping. |
2266 | std::map<SymbolRef, SymInfo> AddrCache; |
2267 | SupportsRelocation Supports; |
2268 | RelocationResolver Resolver; |
2269 | std::tie(args&: Supports, args&: Resolver) = getRelocationResolver(Obj); |
2270 | for (const RelocationRef &Reloc : Section.relocations()) { |
2271 | // FIXME: it's not clear how to correctly handle scattered |
2272 | // relocations. |
2273 | if (isRelocScattered(Obj, Reloc)) |
2274 | continue; |
2275 | |
2276 | Expected<SymInfo> SymInfoOrErr = |
2277 | getSymbolInfo(Obj, Reloc, L, Cache&: AddrCache); |
2278 | if (!SymInfoOrErr) { |
2279 | HandleError(SymInfoOrErr.takeError()); |
2280 | continue; |
2281 | } |
2282 | |
2283 | // Check if Resolver can handle this relocation type early so as not to |
2284 | // handle invalid cases in DWARFDataExtractor. |
2285 | // |
2286 | // TODO Don't store Resolver in every RelocAddrEntry. |
2287 | if (Supports && Supports(Reloc.getType())) { |
2288 | auto I = Map->try_emplace( |
2289 | Key: Reloc.getOffset(), |
2290 | Args: RelocAddrEntry{ |
2291 | .SectionIndex: SymInfoOrErr->SectionIndex, .Reloc: Reloc, .SymbolValue: SymInfoOrErr->Address, |
2292 | .Reloc2: std::optional<object::RelocationRef>(), .SymbolValue2: 0, .Resolver: Resolver}); |
2293 | // If we didn't successfully insert that's because we already had a |
2294 | // relocation for that offset. Store it as a second relocation in the |
2295 | // same RelocAddrEntry instead. |
2296 | if (!I.second) { |
2297 | RelocAddrEntry &entry = I.first->getSecond(); |
2298 | if (entry.Reloc2) { |
2299 | HandleError(createError( |
2300 | Err: "At most two relocations per offset are supported" )); |
2301 | } |
2302 | entry.Reloc2 = Reloc; |
2303 | entry.SymbolValue2 = SymInfoOrErr->Address; |
2304 | } |
2305 | } else { |
2306 | SmallString<32> Type; |
2307 | Reloc.getTypeName(Result&: Type); |
2308 | // FIXME: Support more relocations & change this to an error |
2309 | HandleWarning( |
2310 | createError(Reason: "failed to compute relocation: " + Type + ", " , |
2311 | E: errorCodeToError(EC: object_error::parse_failed))); |
2312 | } |
2313 | } |
2314 | } |
2315 | |
2316 | for (SectionName &S : SectionNames) |
2317 | if (SectionAmountMap[S.Name] > 1) |
2318 | S.IsNameUnique = false; |
2319 | } |
2320 | |
2321 | std::optional<RelocAddrEntry> find(const DWARFSection &S, |
2322 | uint64_t Pos) const override { |
2323 | auto &Sec = static_cast<const DWARFSectionMap &>(S); |
2324 | RelocAddrMap::const_iterator AI = Sec.Relocs.find(Val: Pos); |
2325 | if (AI == Sec.Relocs.end()) |
2326 | return std::nullopt; |
2327 | return AI->second; |
2328 | } |
2329 | |
2330 | const object::ObjectFile *getFile() const override { return Obj; } |
2331 | |
2332 | ArrayRef<SectionName> getSectionNames() const override { |
2333 | return SectionNames; |
2334 | } |
2335 | |
2336 | bool isLittleEndian() const override { return IsLittleEndian; } |
2337 | StringRef getAbbrevDWOSection() const override { return AbbrevDWOSection; } |
2338 | const DWARFSection &getLineDWOSection() const override { |
2339 | return LineDWOSection; |
2340 | } |
2341 | const DWARFSection &getLocDWOSection() const override { |
2342 | return LocDWOSection; |
2343 | } |
2344 | StringRef getStrDWOSection() const override { return StrDWOSection; } |
2345 | const DWARFSection &getStrOffsetsDWOSection() const override { |
2346 | return StrOffsetsDWOSection; |
2347 | } |
2348 | const DWARFSection &getRangesDWOSection() const override { |
2349 | return RangesDWOSection; |
2350 | } |
2351 | const DWARFSection &getRnglistsDWOSection() const override { |
2352 | return RnglistsDWOSection; |
2353 | } |
2354 | const DWARFSection &getLoclistsDWOSection() const override { |
2355 | return LoclistsDWOSection; |
2356 | } |
2357 | const DWARFSection &getAddrSection() const override { return AddrSection; } |
2358 | StringRef getCUIndexSection() const override { return CUIndexSection; } |
2359 | StringRef getGdbIndexSection() const override { return GdbIndexSection; } |
2360 | StringRef getTUIndexSection() const override { return TUIndexSection; } |
2361 | |
2362 | // DWARF v5 |
2363 | const DWARFSection &getStrOffsetsSection() const override { |
2364 | return StrOffsetsSection; |
2365 | } |
2366 | StringRef getLineStrSection() const override { return LineStrSection; } |
2367 | |
2368 | // Sections for DWARF5 split dwarf proposal. |
2369 | void forEachInfoDWOSections( |
2370 | function_ref<void(const DWARFSection &)> F) const override { |
2371 | for (auto &P : InfoDWOSections) |
2372 | F(P.second); |
2373 | } |
2374 | void forEachTypesDWOSections( |
2375 | function_ref<void(const DWARFSection &)> F) const override { |
2376 | for (auto &P : TypesDWOSections) |
2377 | F(P.second); |
2378 | } |
2379 | |
2380 | StringRef getAbbrevSection() const override { return AbbrevSection; } |
2381 | const DWARFSection &getLocSection() const override { return LocSection; } |
2382 | const DWARFSection &getLoclistsSection() const override { return LoclistsSection; } |
2383 | StringRef getArangesSection() const override { return ArangesSection; } |
2384 | const DWARFSection &getFrameSection() const override { |
2385 | return FrameSection; |
2386 | } |
2387 | const DWARFSection &getEHFrameSection() const override { |
2388 | return EHFrameSection; |
2389 | } |
2390 | const DWARFSection &getLineSection() const override { return LineSection; } |
2391 | StringRef getStrSection() const override { return StrSection; } |
2392 | const DWARFSection &getRangesSection() const override { return RangesSection; } |
2393 | const DWARFSection &getRnglistsSection() const override { |
2394 | return RnglistsSection; |
2395 | } |
2396 | const DWARFSection &getMacroSection() const override { return MacroSection; } |
2397 | StringRef getMacroDWOSection() const override { return MacroDWOSection; } |
2398 | StringRef getMacinfoSection() const override { return MacinfoSection; } |
2399 | StringRef getMacinfoDWOSection() const override { return MacinfoDWOSection; } |
2400 | const DWARFSection &getPubnamesSection() const override { return PubnamesSection; } |
2401 | const DWARFSection &getPubtypesSection() const override { return PubtypesSection; } |
2402 | const DWARFSection &getGnuPubnamesSection() const override { |
2403 | return GnuPubnamesSection; |
2404 | } |
2405 | const DWARFSection &getGnuPubtypesSection() const override { |
2406 | return GnuPubtypesSection; |
2407 | } |
2408 | const DWARFSection &getAppleNamesSection() const override { |
2409 | return AppleNamesSection; |
2410 | } |
2411 | const DWARFSection &getAppleTypesSection() const override { |
2412 | return AppleTypesSection; |
2413 | } |
2414 | const DWARFSection &getAppleNamespacesSection() const override { |
2415 | return AppleNamespacesSection; |
2416 | } |
2417 | const DWARFSection &getAppleObjCSection() const override { |
2418 | return AppleObjCSection; |
2419 | } |
2420 | const DWARFSection &getNamesSection() const override { |
2421 | return NamesSection; |
2422 | } |
2423 | |
2424 | StringRef getFileName() const override { return FileName; } |
2425 | uint8_t getAddressSize() const override { return AddressSize; } |
2426 | void forEachInfoSections( |
2427 | function_ref<void(const DWARFSection &)> F) const override { |
2428 | for (auto &P : InfoSections) |
2429 | F(P.second); |
2430 | } |
2431 | void forEachTypesSections( |
2432 | function_ref<void(const DWARFSection &)> F) const override { |
2433 | for (auto &P : TypesSections) |
2434 | F(P.second); |
2435 | } |
2436 | }; |
2437 | } // namespace |
2438 | |
2439 | std::unique_ptr<DWARFContext> |
2440 | DWARFContext::create(const object::ObjectFile &Obj, |
2441 | ProcessDebugRelocations RelocAction, |
2442 | const LoadedObjectInfo *L, std::string DWPName, |
2443 | std::function<void(Error)> RecoverableErrorHandler, |
2444 | std::function<void(Error)> WarningHandler, |
2445 | bool ThreadSafe) { |
2446 | auto DObj = std::make_unique<DWARFObjInMemory>( |
2447 | args: Obj, args&: L, args&: RecoverableErrorHandler, args&: WarningHandler, args&: RelocAction); |
2448 | return std::make_unique<DWARFContext>(args: std::move(DObj), |
2449 | args: std::move(DWPName), |
2450 | args&: RecoverableErrorHandler, |
2451 | args&: WarningHandler, |
2452 | args&: ThreadSafe); |
2453 | } |
2454 | |
2455 | std::unique_ptr<DWARFContext> |
2456 | DWARFContext::create(const StringMap<std::unique_ptr<MemoryBuffer>> &Sections, |
2457 | uint8_t AddrSize, bool isLittleEndian, |
2458 | std::function<void(Error)> RecoverableErrorHandler, |
2459 | std::function<void(Error)> WarningHandler, |
2460 | bool ThreadSafe) { |
2461 | auto DObj = |
2462 | std::make_unique<DWARFObjInMemory>(args: Sections, args&: AddrSize, args&: isLittleEndian); |
2463 | return std::make_unique<DWARFContext>( |
2464 | args: std::move(DObj), args: "" , args&: RecoverableErrorHandler, args&: WarningHandler, args&: ThreadSafe); |
2465 | } |
2466 | |
2467 | uint8_t DWARFContext::getCUAddrSize() { |
2468 | // In theory, different compile units may have different address byte |
2469 | // sizes, but for simplicity we just use the address byte size of the |
2470 | // first compile unit. In practice the address size field is repeated across |
2471 | // various DWARF headers (at least in version 5) to make it easier to dump |
2472 | // them independently, not to enable varying the address size. |
2473 | auto CUs = compile_units(); |
2474 | return CUs.empty() ? 0 : (*CUs.begin())->getAddressByteSize(); |
2475 | } |
2476 | |