1 //===- DWARFUnit.cpp ------------------------------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #include "llvm/DebugInfo/DWARF/DWARFUnit.h"
11 #include "llvm/ADT/SmallString.h"
12 #include "llvm/ADT/StringRef.h"
13 #include "llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h"
14 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
15 #include "llvm/DebugInfo/DWARF/DWARFDebugAbbrev.h"
16 #include "llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h"
17 #include "llvm/DebugInfo/DWARF/DWARFDebugRnglists.h"
18 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
19 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
20 #include "llvm/Support/DataExtractor.h"
21 #include "llvm/Support/Path.h"
22 #include "llvm/Support/WithColor.h"
23 #include <algorithm>
24 #include <cassert>
25 #include <cstddef>
26 #include <cstdint>
27 #include <cstdio>
28 #include <utility>
29 #include <vector>
30
31 using namespace llvm;
32 using namespace dwarf;
33
parse(DWARFContext & C,const DWARFSection & Section)34 void DWARFUnitSectionBase::parse(DWARFContext &C, const DWARFSection &Section) {
35 const DWARFObject &D = C.getDWARFObj();
36 parseImpl(C, D, Section, C.getDebugAbbrev(), &D.getRangeSection(),
37 D.getStringSection(), D.getStringOffsetSection(),
38 &D.getAddrSection(), D.getLineSection(), D.isLittleEndian(), false,
39 false);
40 }
41
parseDWO(DWARFContext & C,const DWARFSection & DWOSection,bool Lazy)42 void DWARFUnitSectionBase::parseDWO(DWARFContext &C,
43 const DWARFSection &DWOSection, bool Lazy) {
44 const DWARFObject &D = C.getDWARFObj();
45 parseImpl(C, D, DWOSection, C.getDebugAbbrevDWO(), &D.getRangeDWOSection(),
46 D.getStringDWOSection(), D.getStringOffsetDWOSection(),
47 &D.getAddrSection(), D.getLineDWOSection(), C.isLittleEndian(),
48 true, Lazy);
49 }
50
DWARFUnit(DWARFContext & DC,const DWARFSection & Section,const DWARFUnitHeader & Header,const DWARFDebugAbbrev * DA,const DWARFSection * RS,StringRef SS,const DWARFSection & SOS,const DWARFSection * AOS,const DWARFSection & LS,bool LE,bool IsDWO,const DWARFUnitSectionBase & UnitSection)51 DWARFUnit::DWARFUnit(DWARFContext &DC, const DWARFSection &Section,
52 const DWARFUnitHeader &Header,
53 const DWARFDebugAbbrev *DA, const DWARFSection *RS,
54 StringRef SS, const DWARFSection &SOS,
55 const DWARFSection *AOS, const DWARFSection &LS, bool LE,
56 bool IsDWO, const DWARFUnitSectionBase &UnitSection)
57 : Context(DC), InfoSection(Section), Header(Header), Abbrev(DA),
58 RangeSection(RS), LineSection(LS), StringSection(SS),
59 StringOffsetSection(SOS), AddrOffsetSection(AOS), isLittleEndian(LE),
60 isDWO(IsDWO), UnitSection(UnitSection) {
61 clear();
62 }
63
64 DWARFUnit::~DWARFUnit() = default;
65
getDebugInfoExtractor() const66 DWARFDataExtractor DWARFUnit::getDebugInfoExtractor() const {
67 return DWARFDataExtractor(Context.getDWARFObj(), InfoSection, isLittleEndian,
68 getAddressByteSize());
69 }
70
getAddrOffsetSectionItem(uint32_t Index,uint64_t & Result) const71 bool DWARFUnit::getAddrOffsetSectionItem(uint32_t Index,
72 uint64_t &Result) const {
73 uint32_t Offset = AddrOffsetSectionBase + Index * getAddressByteSize();
74 if (AddrOffsetSection->Data.size() < Offset + getAddressByteSize())
75 return false;
76 DWARFDataExtractor DA(Context.getDWARFObj(), *AddrOffsetSection,
77 isLittleEndian, getAddressByteSize());
78 Result = DA.getRelocatedAddress(&Offset);
79 return true;
80 }
81
getStringOffsetSectionItem(uint32_t Index,uint64_t & Result) const82 bool DWARFUnit::getStringOffsetSectionItem(uint32_t Index,
83 uint64_t &Result) const {
84 if (!StringOffsetsTableContribution)
85 return false;
86 unsigned ItemSize = getDwarfStringOffsetsByteSize();
87 uint32_t Offset = getStringOffsetsBase() + Index * ItemSize;
88 if (StringOffsetSection.Data.size() < Offset + ItemSize)
89 return false;
90 DWARFDataExtractor DA(Context.getDWARFObj(), StringOffsetSection,
91 isLittleEndian, 0);
92 Result = DA.getRelocatedValue(ItemSize, &Offset);
93 return true;
94 }
95
extract(DWARFContext & Context,const DWARFDataExtractor & debug_info,uint32_t * offset_ptr,DWARFSectionKind SectionKind,const DWARFUnitIndex * Index)96 bool DWARFUnitHeader::extract(DWARFContext &Context,
97 const DWARFDataExtractor &debug_info,
98 uint32_t *offset_ptr,
99 DWARFSectionKind SectionKind,
100 const DWARFUnitIndex *Index) {
101 Offset = *offset_ptr;
102 IndexEntry = Index ? Index->getFromOffset(*offset_ptr) : nullptr;
103 Length = debug_info.getU32(offset_ptr);
104 // FIXME: Support DWARF64.
105 unsigned SizeOfLength = 4;
106 FormParams.Format = DWARF32;
107 FormParams.Version = debug_info.getU16(offset_ptr);
108 if (FormParams.Version >= 5) {
109 UnitType = debug_info.getU8(offset_ptr);
110 FormParams.AddrSize = debug_info.getU8(offset_ptr);
111 AbbrOffset = debug_info.getU32(offset_ptr);
112 } else {
113 AbbrOffset = debug_info.getRelocatedValue(4, offset_ptr);
114 FormParams.AddrSize = debug_info.getU8(offset_ptr);
115 // Fake a unit type based on the section type. This isn't perfect,
116 // but distinguishing compile and type units is generally enough.
117 if (SectionKind == DW_SECT_TYPES)
118 UnitType = DW_UT_type;
119 else
120 UnitType = DW_UT_compile;
121 }
122 if (IndexEntry) {
123 if (AbbrOffset)
124 return false;
125 auto *UnitContrib = IndexEntry->getOffset();
126 if (!UnitContrib || UnitContrib->Length != (Length + 4))
127 return false;
128 auto *AbbrEntry = IndexEntry->getOffset(DW_SECT_ABBREV);
129 if (!AbbrEntry)
130 return false;
131 AbbrOffset = AbbrEntry->Offset;
132 }
133 if (isTypeUnit()) {
134 TypeHash = debug_info.getU64(offset_ptr);
135 TypeOffset = debug_info.getU32(offset_ptr);
136 } else if (UnitType == DW_UT_split_compile || UnitType == DW_UT_skeleton)
137 DWOId = debug_info.getU64(offset_ptr);
138
139 // Header fields all parsed, capture the size of this unit header.
140 assert(*offset_ptr - Offset <= 255 && "unexpected header size");
141 Size = uint8_t(*offset_ptr - Offset);
142
143 // Type offset is unit-relative; should be after the header and before
144 // the end of the current unit.
145 bool TypeOffsetOK =
146 !isTypeUnit()
147 ? true
148 : TypeOffset >= Size && TypeOffset < getLength() + SizeOfLength;
149 bool LengthOK = debug_info.isValidOffset(getNextUnitOffset() - 1);
150 bool VersionOK = DWARFContext::isSupportedVersion(getVersion());
151 bool AddrSizeOK = getAddressByteSize() == 4 || getAddressByteSize() == 8;
152
153 if (!LengthOK || !VersionOK || !AddrSizeOK || !TypeOffsetOK)
154 return false;
155
156 // Keep track of the highest DWARF version we encounter across all units.
157 Context.setMaxVersionIfGreater(getVersion());
158 return true;
159 }
160
161 // Parse the rangelist table header, including the optional array of offsets
162 // following it (DWARF v5 and later).
163 static Expected<DWARFDebugRnglistTable>
parseRngListTableHeader(DWARFDataExtractor & DA,uint32_t Offset)164 parseRngListTableHeader(DWARFDataExtractor &DA, uint32_t Offset) {
165 // TODO: Support DWARF64
166 // We are expected to be called with Offset 0 or pointing just past the table
167 // header, which is 12 bytes long for DWARF32.
168 if (Offset > 0) {
169 if (Offset < 12U) {
170 std::string Buffer;
171 raw_string_ostream Stream(Buffer);
172 Stream << format(
173 "Did not detect a valid range list table with base = 0x%x", Offset);
174 return make_error<StringError>(Stream.str(), inconvertibleErrorCode());
175 }
176 Offset -= 12U;
177 }
178 llvm::DWARFDebugRnglistTable Table;
179 if (Error E = Table.extractHeaderAndOffsets(DA, &Offset))
180 return std::move(E);
181 return Table;
182 }
183
extractRangeList(uint32_t RangeListOffset,DWARFDebugRangeList & RangeList) const184 Error DWARFUnit::extractRangeList(uint32_t RangeListOffset,
185 DWARFDebugRangeList &RangeList) const {
186 // Require that compile unit is extracted.
187 assert(!DieArray.empty());
188 DWARFDataExtractor RangesData(Context.getDWARFObj(), *RangeSection,
189 isLittleEndian, getAddressByteSize());
190 uint32_t ActualRangeListOffset = RangeSectionBase + RangeListOffset;
191 return RangeList.extract(RangesData, &ActualRangeListOffset);
192 }
193
clear()194 void DWARFUnit::clear() {
195 Abbrevs = nullptr;
196 BaseAddr.reset();
197 RangeSectionBase = 0;
198 AddrOffsetSectionBase = 0;
199 clearDIEs(false);
200 DWO.reset();
201 }
202
getCompilationDir()203 const char *DWARFUnit::getCompilationDir() {
204 return dwarf::toString(getUnitDIE().find(DW_AT_comp_dir), nullptr);
205 }
206
extractDIEsToVector(bool AppendCUDie,bool AppendNonCUDies,std::vector<DWARFDebugInfoEntry> & Dies) const207 void DWARFUnit::extractDIEsToVector(
208 bool AppendCUDie, bool AppendNonCUDies,
209 std::vector<DWARFDebugInfoEntry> &Dies) const {
210 if (!AppendCUDie && !AppendNonCUDies)
211 return;
212
213 // Set the offset to that of the first DIE and calculate the start of the
214 // next compilation unit header.
215 uint32_t DIEOffset = getOffset() + getHeaderSize();
216 uint32_t NextCUOffset = getNextUnitOffset();
217 DWARFDebugInfoEntry DIE;
218 DWARFDataExtractor DebugInfoData = getDebugInfoExtractor();
219 uint32_t Depth = 0;
220 bool IsCUDie = true;
221
222 while (DIE.extractFast(*this, &DIEOffset, DebugInfoData, NextCUOffset,
223 Depth)) {
224 if (IsCUDie) {
225 if (AppendCUDie)
226 Dies.push_back(DIE);
227 if (!AppendNonCUDies)
228 break;
229 // The average bytes per DIE entry has been seen to be
230 // around 14-20 so let's pre-reserve the needed memory for
231 // our DIE entries accordingly.
232 Dies.reserve(Dies.size() + getDebugInfoSize() / 14);
233 IsCUDie = false;
234 } else {
235 Dies.push_back(DIE);
236 }
237
238 if (const DWARFAbbreviationDeclaration *AbbrDecl =
239 DIE.getAbbreviationDeclarationPtr()) {
240 // Normal DIE
241 if (AbbrDecl->hasChildren())
242 ++Depth;
243 } else {
244 // NULL DIE.
245 if (Depth > 0)
246 --Depth;
247 if (Depth == 0)
248 break; // We are done with this compile unit!
249 }
250 }
251
252 // Give a little bit of info if we encounter corrupt DWARF (our offset
253 // should always terminate at or before the start of the next compilation
254 // unit header).
255 if (DIEOffset > NextCUOffset)
256 WithColor::warning() << format("DWARF compile unit extends beyond its "
257 "bounds cu 0x%8.8x at 0x%8.8x\n",
258 getOffset(), DIEOffset);
259 }
260
extractDIEsIfNeeded(bool CUDieOnly)261 size_t DWARFUnit::extractDIEsIfNeeded(bool CUDieOnly) {
262 if ((CUDieOnly && !DieArray.empty()) ||
263 DieArray.size() > 1)
264 return 0; // Already parsed.
265
266 bool HasCUDie = !DieArray.empty();
267 extractDIEsToVector(!HasCUDie, !CUDieOnly, DieArray);
268
269 if (DieArray.empty())
270 return 0;
271
272 // If CU DIE was just parsed, copy several attribute values from it.
273 if (!HasCUDie) {
274 DWARFDie UnitDie = getUnitDIE();
275 if (Optional<uint64_t> DWOId = toUnsigned(UnitDie.find(DW_AT_GNU_dwo_id)))
276 Header.setDWOId(*DWOId);
277 if (!isDWO) {
278 assert(AddrOffsetSectionBase == 0);
279 assert(RangeSectionBase == 0);
280 AddrOffsetSectionBase =
281 toSectionOffset(UnitDie.find(DW_AT_GNU_addr_base), 0);
282 RangeSectionBase = toSectionOffset(UnitDie.find(DW_AT_rnglists_base), 0);
283 }
284
285 // In general, in DWARF v5 and beyond we derive the start of the unit's
286 // contribution to the string offsets table from the unit DIE's
287 // DW_AT_str_offsets_base attribute. Split DWARF units do not use this
288 // attribute, so we assume that there is a contribution to the string
289 // offsets table starting at offset 0 of the debug_str_offsets.dwo section.
290 // In both cases we need to determine the format of the contribution,
291 // which may differ from the unit's format.
292 uint64_t StringOffsetsContributionBase =
293 isDWO ? 0 : toSectionOffset(UnitDie.find(DW_AT_str_offsets_base), 0);
294 auto IndexEntry = Header.getIndexEntry();
295 if (IndexEntry)
296 if (const auto *C = IndexEntry->getOffset(DW_SECT_STR_OFFSETS))
297 StringOffsetsContributionBase += C->Offset;
298
299 DWARFDataExtractor DA(Context.getDWARFObj(), StringOffsetSection,
300 isLittleEndian, 0);
301 if (isDWO)
302 StringOffsetsTableContribution =
303 determineStringOffsetsTableContributionDWO(
304 DA, StringOffsetsContributionBase);
305 else if (getVersion() >= 5)
306 StringOffsetsTableContribution = determineStringOffsetsTableContribution(
307 DA, StringOffsetsContributionBase);
308
309 // DWARF v5 uses the .debug_rnglists and .debug_rnglists.dwo sections to
310 // describe address ranges.
311 if (getVersion() >= 5) {
312 if (isDWO)
313 setRangesSection(&Context.getDWARFObj().getRnglistsDWOSection(), 0);
314 else
315 setRangesSection(&Context.getDWARFObj().getRnglistsSection(),
316 toSectionOffset(UnitDie.find(DW_AT_rnglists_base), 0));
317 if (RangeSection->Data.size()) {
318 // Parse the range list table header. Individual range lists are
319 // extracted lazily.
320 DWARFDataExtractor RangesDA(Context.getDWARFObj(), *RangeSection,
321 isLittleEndian, 0);
322 if (auto TableOrError =
323 parseRngListTableHeader(RangesDA, RangeSectionBase))
324 RngListTable = TableOrError.get();
325 else
326 WithColor::error() << "parsing a range list table: "
327 << toString(TableOrError.takeError())
328 << '\n';
329
330 // In a split dwarf unit, there is no DW_AT_rnglists_base attribute.
331 // Adjust RangeSectionBase to point past the table header.
332 if (isDWO && RngListTable)
333 RangeSectionBase = RngListTable->getHeaderSize();
334 }
335 }
336
337 // Don't fall back to DW_AT_GNU_ranges_base: it should be ignored for
338 // skeleton CU DIE, so that DWARF users not aware of it are not broken.
339 }
340
341 return DieArray.size();
342 }
343
parseDWO()344 bool DWARFUnit::parseDWO() {
345 if (isDWO)
346 return false;
347 if (DWO.get())
348 return false;
349 DWARFDie UnitDie = getUnitDIE();
350 if (!UnitDie)
351 return false;
352 auto DWOFileName = dwarf::toString(UnitDie.find(DW_AT_GNU_dwo_name));
353 if (!DWOFileName)
354 return false;
355 auto CompilationDir = dwarf::toString(UnitDie.find(DW_AT_comp_dir));
356 SmallString<16> AbsolutePath;
357 if (sys::path::is_relative(*DWOFileName) && CompilationDir &&
358 *CompilationDir) {
359 sys::path::append(AbsolutePath, *CompilationDir);
360 }
361 sys::path::append(AbsolutePath, *DWOFileName);
362 auto DWOId = getDWOId();
363 if (!DWOId)
364 return false;
365 auto DWOContext = Context.getDWOContext(AbsolutePath);
366 if (!DWOContext)
367 return false;
368
369 DWARFCompileUnit *DWOCU = DWOContext->getDWOCompileUnitForHash(*DWOId);
370 if (!DWOCU)
371 return false;
372 DWO = std::shared_ptr<DWARFCompileUnit>(std::move(DWOContext), DWOCU);
373 // Share .debug_addr and .debug_ranges section with compile unit in .dwo
374 DWO->setAddrOffsetSection(AddrOffsetSection, AddrOffsetSectionBase);
375 if (getVersion() >= 5) {
376 DWO->setRangesSection(&Context.getDWARFObj().getRnglistsDWOSection(), 0);
377 DWARFDataExtractor RangesDA(Context.getDWARFObj(), *RangeSection,
378 isLittleEndian, 0);
379 if (auto TableOrError = parseRngListTableHeader(RangesDA, RangeSectionBase))
380 DWO->RngListTable = TableOrError.get();
381 else
382 WithColor::error() << "parsing a range list table: "
383 << toString(TableOrError.takeError())
384 << '\n';
385 if (DWO->RngListTable)
386 DWO->RangeSectionBase = DWO->RngListTable->getHeaderSize();
387 } else {
388 auto DWORangesBase = UnitDie.getRangesBaseAttribute();
389 DWO->setRangesSection(RangeSection, DWORangesBase ? *DWORangesBase : 0);
390 }
391
392 return true;
393 }
394
clearDIEs(bool KeepCUDie)395 void DWARFUnit::clearDIEs(bool KeepCUDie) {
396 if (DieArray.size() > (unsigned)KeepCUDie) {
397 DieArray.resize((unsigned)KeepCUDie);
398 DieArray.shrink_to_fit();
399 }
400 }
401
402 Expected<DWARFAddressRangesVector>
findRnglistFromOffset(uint32_t Offset)403 DWARFUnit::findRnglistFromOffset(uint32_t Offset) {
404 if (getVersion() <= 4) {
405 DWARFDebugRangeList RangeList;
406 if (Error E = extractRangeList(Offset, RangeList))
407 return std::move(E);
408 return RangeList.getAbsoluteRanges(getBaseAddress());
409 }
410 if (RngListTable) {
411 DWARFDataExtractor RangesData(Context.getDWARFObj(), *RangeSection,
412 isLittleEndian, RngListTable->getAddrSize());
413 auto RangeListOrError = RngListTable->findList(RangesData, Offset);
414 if (RangeListOrError)
415 return RangeListOrError.get().getAbsoluteRanges(getBaseAddress());
416 return RangeListOrError.takeError();
417 }
418
419 return make_error<StringError>("missing or invalid range list table",
420 inconvertibleErrorCode());
421 }
422
423 Expected<DWARFAddressRangesVector>
findRnglistFromIndex(uint32_t Index)424 DWARFUnit::findRnglistFromIndex(uint32_t Index) {
425 if (auto Offset = getRnglistOffset(Index))
426 return findRnglistFromOffset(*Offset + RangeSectionBase);
427
428 std::string Buffer;
429 raw_string_ostream Stream(Buffer);
430 if (RngListTable)
431 Stream << format("invalid range list table index %d", Index);
432 else
433 Stream << "missing or invalid range list table";
434 return make_error<StringError>(Stream.str(), inconvertibleErrorCode());
435 }
436
collectAddressRanges(DWARFAddressRangesVector & CURanges)437 void DWARFUnit::collectAddressRanges(DWARFAddressRangesVector &CURanges) {
438 DWARFDie UnitDie = getUnitDIE();
439 if (!UnitDie)
440 return;
441 // First, check if unit DIE describes address ranges for the whole unit.
442 auto CUDIERangesOrError = UnitDie.getAddressRanges();
443 if (CUDIERangesOrError) {
444 if (!CUDIERangesOrError.get().empty()) {
445 CURanges.insert(CURanges.end(), CUDIERangesOrError.get().begin(),
446 CUDIERangesOrError.get().end());
447 return;
448 }
449 } else
450 WithColor::error() << "decoding address ranges: "
451 << toString(CUDIERangesOrError.takeError()) << '\n';
452
453 // This function is usually called if there in no .debug_aranges section
454 // in order to produce a compile unit level set of address ranges that
455 // is accurate. If the DIEs weren't parsed, then we don't want all dies for
456 // all compile units to stay loaded when they weren't needed. So we can end
457 // up parsing the DWARF and then throwing them all away to keep memory usage
458 // down.
459 const bool ClearDIEs = extractDIEsIfNeeded(false) > 1;
460 getUnitDIE().collectChildrenAddressRanges(CURanges);
461
462 // Collect address ranges from DIEs in .dwo if necessary.
463 bool DWOCreated = parseDWO();
464 if (DWO)
465 DWO->collectAddressRanges(CURanges);
466 if (DWOCreated)
467 DWO.reset();
468
469 // Keep memory down by clearing DIEs if this generate function
470 // caused them to be parsed.
471 if (ClearDIEs)
472 clearDIEs(true);
473 }
474
updateAddressDieMap(DWARFDie Die)475 void DWARFUnit::updateAddressDieMap(DWARFDie Die) {
476 if (Die.isSubroutineDIE()) {
477 auto DIERangesOrError = Die.getAddressRanges();
478 if (DIERangesOrError) {
479 for (const auto &R : DIERangesOrError.get()) {
480 // Ignore 0-sized ranges.
481 if (R.LowPC == R.HighPC)
482 continue;
483 auto B = AddrDieMap.upper_bound(R.LowPC);
484 if (B != AddrDieMap.begin() && R.LowPC < (--B)->second.first) {
485 // The range is a sub-range of existing ranges, we need to split the
486 // existing range.
487 if (R.HighPC < B->second.first)
488 AddrDieMap[R.HighPC] = B->second;
489 if (R.LowPC > B->first)
490 AddrDieMap[B->first].first = R.LowPC;
491 }
492 AddrDieMap[R.LowPC] = std::make_pair(R.HighPC, Die);
493 }
494 } else
495 llvm::consumeError(DIERangesOrError.takeError());
496 }
497 // Parent DIEs are added to the AddrDieMap prior to the Children DIEs to
498 // simplify the logic to update AddrDieMap. The child's range will always
499 // be equal or smaller than the parent's range. With this assumption, when
500 // adding one range into the map, it will at most split a range into 3
501 // sub-ranges.
502 for (DWARFDie Child = Die.getFirstChild(); Child; Child = Child.getSibling())
503 updateAddressDieMap(Child);
504 }
505
getSubroutineForAddress(uint64_t Address)506 DWARFDie DWARFUnit::getSubroutineForAddress(uint64_t Address) {
507 extractDIEsIfNeeded(false);
508 if (AddrDieMap.empty())
509 updateAddressDieMap(getUnitDIE());
510 auto R = AddrDieMap.upper_bound(Address);
511 if (R == AddrDieMap.begin())
512 return DWARFDie();
513 // upper_bound's previous item contains Address.
514 --R;
515 if (Address >= R->second.first)
516 return DWARFDie();
517 return R->second.second;
518 }
519
520 void
getInlinedChainForAddress(uint64_t Address,SmallVectorImpl<DWARFDie> & InlinedChain)521 DWARFUnit::getInlinedChainForAddress(uint64_t Address,
522 SmallVectorImpl<DWARFDie> &InlinedChain) {
523 assert(InlinedChain.empty());
524 // Try to look for subprogram DIEs in the DWO file.
525 parseDWO();
526 // First, find the subroutine that contains the given address (the leaf
527 // of inlined chain).
528 DWARFDie SubroutineDIE =
529 (DWO ? DWO.get() : this)->getSubroutineForAddress(Address);
530
531 if (!SubroutineDIE)
532 return;
533
534 while (!SubroutineDIE.isSubprogramDIE()) {
535 if (SubroutineDIE.getTag() == DW_TAG_inlined_subroutine)
536 InlinedChain.push_back(SubroutineDIE);
537 SubroutineDIE = SubroutineDIE.getParent();
538 }
539 InlinedChain.push_back(SubroutineDIE);
540 }
541
getDWARFUnitIndex(DWARFContext & Context,DWARFSectionKind Kind)542 const DWARFUnitIndex &llvm::getDWARFUnitIndex(DWARFContext &Context,
543 DWARFSectionKind Kind) {
544 if (Kind == DW_SECT_INFO)
545 return Context.getCUIndex();
546 assert(Kind == DW_SECT_TYPES);
547 return Context.getTUIndex();
548 }
549
getParent(const DWARFDebugInfoEntry * Die)550 DWARFDie DWARFUnit::getParent(const DWARFDebugInfoEntry *Die) {
551 if (!Die)
552 return DWARFDie();
553 const uint32_t Depth = Die->getDepth();
554 // Unit DIEs always have a depth of zero and never have parents.
555 if (Depth == 0)
556 return DWARFDie();
557 // Depth of 1 always means parent is the compile/type unit.
558 if (Depth == 1)
559 return getUnitDIE();
560 // Look for previous DIE with a depth that is one less than the Die's depth.
561 const uint32_t ParentDepth = Depth - 1;
562 for (uint32_t I = getDIEIndex(Die) - 1; I > 0; --I) {
563 if (DieArray[I].getDepth() == ParentDepth)
564 return DWARFDie(this, &DieArray[I]);
565 }
566 return DWARFDie();
567 }
568
getSibling(const DWARFDebugInfoEntry * Die)569 DWARFDie DWARFUnit::getSibling(const DWARFDebugInfoEntry *Die) {
570 if (!Die)
571 return DWARFDie();
572 uint32_t Depth = Die->getDepth();
573 // Unit DIEs always have a depth of zero and never have siblings.
574 if (Depth == 0)
575 return DWARFDie();
576 // NULL DIEs don't have siblings.
577 if (Die->getAbbreviationDeclarationPtr() == nullptr)
578 return DWARFDie();
579
580 // Find the next DIE whose depth is the same as the Die's depth.
581 for (size_t I = getDIEIndex(Die) + 1, EndIdx = DieArray.size(); I < EndIdx;
582 ++I) {
583 if (DieArray[I].getDepth() == Depth)
584 return DWARFDie(this, &DieArray[I]);
585 }
586 return DWARFDie();
587 }
588
getPreviousSibling(const DWARFDebugInfoEntry * Die)589 DWARFDie DWARFUnit::getPreviousSibling(const DWARFDebugInfoEntry *Die) {
590 if (!Die)
591 return DWARFDie();
592 uint32_t Depth = Die->getDepth();
593 // Unit DIEs always have a depth of zero and never have siblings.
594 if (Depth == 0)
595 return DWARFDie();
596
597 // Find the previous DIE whose depth is the same as the Die's depth.
598 for (size_t I = getDIEIndex(Die); I > 0;) {
599 --I;
600 if (DieArray[I].getDepth() == Depth - 1)
601 return DWARFDie();
602 if (DieArray[I].getDepth() == Depth)
603 return DWARFDie(this, &DieArray[I]);
604 }
605 return DWARFDie();
606 }
607
getFirstChild(const DWARFDebugInfoEntry * Die)608 DWARFDie DWARFUnit::getFirstChild(const DWARFDebugInfoEntry *Die) {
609 if (!Die->hasChildren())
610 return DWARFDie();
611
612 // We do not want access out of bounds when parsing corrupted debug data.
613 size_t I = getDIEIndex(Die) + 1;
614 if (I >= DieArray.size())
615 return DWARFDie();
616 return DWARFDie(this, &DieArray[I]);
617 }
618
getLastChild(const DWARFDebugInfoEntry * Die)619 DWARFDie DWARFUnit::getLastChild(const DWARFDebugInfoEntry *Die) {
620 if (!Die->hasChildren())
621 return DWARFDie();
622
623 uint32_t Depth = Die->getDepth();
624 for (size_t I = getDIEIndex(Die) + 1, EndIdx = DieArray.size(); I < EndIdx;
625 ++I) {
626 if (DieArray[I].getDepth() == Depth + 1 &&
627 DieArray[I].getTag() == dwarf::DW_TAG_null)
628 return DWARFDie(this, &DieArray[I]);
629 assert(DieArray[I].getDepth() > Depth && "Not processing children?");
630 }
631 return DWARFDie();
632 }
633
getAbbreviations() const634 const DWARFAbbreviationDeclarationSet *DWARFUnit::getAbbreviations() const {
635 if (!Abbrevs)
636 Abbrevs = Abbrev->getAbbreviationDeclarationSet(Header.getAbbrOffset());
637 return Abbrevs;
638 }
639
getBaseAddress()640 llvm::Optional<BaseAddress> DWARFUnit::getBaseAddress() {
641 if (BaseAddr)
642 return BaseAddr;
643
644 DWARFDie UnitDie = getUnitDIE();
645 Optional<DWARFFormValue> PC = UnitDie.find({DW_AT_low_pc, DW_AT_entry_pc});
646 if (Optional<uint64_t> Addr = toAddress(PC))
647 BaseAddr = {*Addr, PC->getSectionIndex()};
648
649 return BaseAddr;
650 }
651
652 Optional<StrOffsetsContributionDescriptor>
validateContributionSize(DWARFDataExtractor & DA)653 StrOffsetsContributionDescriptor::validateContributionSize(
654 DWARFDataExtractor &DA) {
655 uint8_t EntrySize = getDwarfOffsetByteSize();
656 // In order to ensure that we don't read a partial record at the end of
657 // the section we validate for a multiple of the entry size.
658 uint64_t ValidationSize = alignTo(Size, EntrySize);
659 // Guard against overflow.
660 if (ValidationSize >= Size)
661 if (DA.isValidOffsetForDataOfSize((uint32_t)Base, ValidationSize))
662 return *this;
663 return Optional<StrOffsetsContributionDescriptor>();
664 }
665
666 // Look for a DWARF64-formatted contribution to the string offsets table
667 // starting at a given offset and record it in a descriptor.
668 static Optional<StrOffsetsContributionDescriptor>
parseDWARF64StringOffsetsTableHeader(DWARFDataExtractor & DA,uint32_t Offset)669 parseDWARF64StringOffsetsTableHeader(DWARFDataExtractor &DA, uint32_t Offset) {
670 if (!DA.isValidOffsetForDataOfSize(Offset, 16))
671 return Optional<StrOffsetsContributionDescriptor>();
672
673 if (DA.getU32(&Offset) != 0xffffffff)
674 return Optional<StrOffsetsContributionDescriptor>();
675
676 uint64_t Size = DA.getU64(&Offset);
677 uint8_t Version = DA.getU16(&Offset);
678 (void)DA.getU16(&Offset); // padding
679 // The encoded length includes the 2-byte version field and the 2-byte
680 // padding, so we need to subtract them out when we populate the descriptor.
681 return StrOffsetsContributionDescriptor(Offset, Size - 4, Version, DWARF64);
682 //return Optional<StrOffsetsContributionDescriptor>(Descriptor);
683 }
684
685 // Look for a DWARF32-formatted contribution to the string offsets table
686 // starting at a given offset and record it in a descriptor.
687 static Optional<StrOffsetsContributionDescriptor>
parseDWARF32StringOffsetsTableHeader(DWARFDataExtractor & DA,uint32_t Offset)688 parseDWARF32StringOffsetsTableHeader(DWARFDataExtractor &DA, uint32_t Offset) {
689 if (!DA.isValidOffsetForDataOfSize(Offset, 8))
690 return Optional<StrOffsetsContributionDescriptor>();
691 uint32_t ContributionSize = DA.getU32(&Offset);
692 if (ContributionSize >= 0xfffffff0)
693 return Optional<StrOffsetsContributionDescriptor>();
694 uint8_t Version = DA.getU16(&Offset);
695 (void)DA.getU16(&Offset); // padding
696 // The encoded length includes the 2-byte version field and the 2-byte
697 // padding, so we need to subtract them out when we populate the descriptor.
698 return StrOffsetsContributionDescriptor(Offset, ContributionSize - 4, Version,
699 DWARF32);
700 //return Optional<StrOffsetsContributionDescriptor>(Descriptor);
701 }
702
703 Optional<StrOffsetsContributionDescriptor>
determineStringOffsetsTableContribution(DWARFDataExtractor & DA,uint64_t Offset)704 DWARFUnit::determineStringOffsetsTableContribution(DWARFDataExtractor &DA,
705 uint64_t Offset) {
706 Optional<StrOffsetsContributionDescriptor> Descriptor;
707 // Attempt to find a DWARF64 contribution 16 bytes before the base.
708 if (Offset >= 16)
709 Descriptor =
710 parseDWARF64StringOffsetsTableHeader(DA, (uint32_t)Offset - 16);
711 // Try to find a DWARF32 contribution 8 bytes before the base.
712 if (!Descriptor && Offset >= 8)
713 Descriptor = parseDWARF32StringOffsetsTableHeader(DA, (uint32_t)Offset - 8);
714 return Descriptor ? Descriptor->validateContributionSize(DA) : Descriptor;
715 }
716
717 Optional<StrOffsetsContributionDescriptor>
determineStringOffsetsTableContributionDWO(DWARFDataExtractor & DA,uint64_t Offset)718 DWARFUnit::determineStringOffsetsTableContributionDWO(DWARFDataExtractor &DA,
719 uint64_t Offset) {
720 if (getVersion() >= 5) {
721 // Look for a valid contribution at the given offset.
722 auto Descriptor =
723 parseDWARF64StringOffsetsTableHeader(DA, (uint32_t)Offset);
724 if (!Descriptor)
725 Descriptor = parseDWARF32StringOffsetsTableHeader(DA, (uint32_t)Offset);
726 return Descriptor ? Descriptor->validateContributionSize(DA) : Descriptor;
727 }
728 // Prior to DWARF v5, we derive the contribution size from the
729 // index table (in a package file). In a .dwo file it is simply
730 // the length of the string offsets section.
731 uint64_t Size = 0;
732 auto IndexEntry = Header.getIndexEntry();
733 if (!IndexEntry)
734 Size = StringOffsetSection.Data.size();
735 else if (const auto *C = IndexEntry->getOffset(DW_SECT_STR_OFFSETS))
736 Size = C->Length;
737 // Return a descriptor with the given offset as base, version 4 and
738 // DWARF32 format.
739 //return Optional<StrOffsetsContributionDescriptor>(
740 //StrOffsetsContributionDescriptor(Offset, Size, 4, DWARF32));
741 return StrOffsetsContributionDescriptor(Offset, Size, 4, DWARF32);
742 }
743