1 | //===- DWARFUnit.h ----------------------------------------------*- C++ -*-===// |
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 | #ifndef LLVM_DEBUGINFO_DWARF_DWARFUNIT_H |
10 | #define LLVM_DEBUGINFO_DWARF_DWARFUNIT_H |
11 | |
12 | #include "llvm/ADT/DenseSet.h" |
13 | #include "llvm/ADT/STLExtras.h" |
14 | #include "llvm/ADT/SmallVector.h" |
15 | #include "llvm/ADT/StringRef.h" |
16 | #include "llvm/ADT/iterator_range.h" |
17 | #include "llvm/BinaryFormat/Dwarf.h" |
18 | #include "llvm/DebugInfo/DWARF/DWARFAddressRange.h" |
19 | #include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h" |
20 | #include "llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h" |
21 | #include "llvm/DebugInfo/DWARF/DWARFDie.h" |
22 | #include "llvm/DebugInfo/DWARF/DWARFLocationExpression.h" |
23 | #include "llvm/DebugInfo/DWARF/DWARFUnitIndex.h" |
24 | #include "llvm/Support/DataExtractor.h" |
25 | #include <cassert> |
26 | #include <cstddef> |
27 | #include <cstdint> |
28 | #include <map> |
29 | #include <memory> |
30 | #include <set> |
31 | #include <utility> |
32 | #include <vector> |
33 | |
34 | namespace llvm { |
35 | |
36 | class DWARFAbbreviationDeclarationSet; |
37 | class DWARFContext; |
38 | class DWARFDebugAbbrev; |
39 | class DWARFUnit; |
40 | class DWARFDebugRangeList; |
41 | class DWARFLocationTable; |
42 | class DWARFObject; |
43 | class raw_ostream; |
44 | struct DIDumpOptions; |
45 | struct DWARFSection; |
46 | namespace dwarf_linker { |
47 | namespace parallel { |
48 | class CompileUnit; |
49 | } |
50 | } // namespace dwarf_linker |
51 | |
52 | /// Base class describing the header of any kind of "unit." Some information |
53 | /// is specific to certain unit types. We separate this class out so we can |
54 | /// parse the header before deciding what specific kind of unit to construct. |
55 | class { |
56 | // Offset within section. |
57 | uint64_t = 0; |
58 | // Version, address size, and DWARF format. |
59 | dwarf::FormParams ; |
60 | uint64_t = 0; |
61 | uint64_t = 0; |
62 | |
63 | // For DWO units only. |
64 | const DWARFUnitIndex::Entry * = nullptr; |
65 | |
66 | // For type units only. |
67 | uint64_t = 0; |
68 | uint64_t = 0; |
69 | |
70 | // For v5 split or skeleton compile units only. |
71 | std::optional<uint64_t> ; |
72 | |
73 | // Unit type as parsed, or derived from the section kind. |
74 | uint8_t = 0; |
75 | |
76 | // Size as parsed. uint8_t for compactness. |
77 | uint8_t = 0; |
78 | |
79 | public: |
80 | /// Parse a unit header from \p debug_info starting at \p offset_ptr. |
81 | /// Note that \p SectionKind is used as a hint to guess the unit type |
82 | /// for DWARF formats prior to DWARFv5. In DWARFv5 the unit type is |
83 | /// explicitly defined in the header and the hint is ignored. |
84 | Error (DWARFContext &Context, const DWARFDataExtractor &debug_info, |
85 | uint64_t *offset_ptr, DWARFSectionKind SectionKind); |
86 | // For units in DWARF Package File, remember the index entry and update |
87 | // the abbreviation offset read by extract(). |
88 | bool (const DWARFUnitIndex::Entry *Entry); |
89 | uint64_t () const { return Offset; } |
90 | const dwarf::FormParams &() const { return FormParams; } |
91 | uint16_t () const { return FormParams.Version; } |
92 | dwarf::DwarfFormat () const { return FormParams.Format; } |
93 | uint8_t () const { return FormParams.AddrSize; } |
94 | uint8_t () const { return FormParams.getRefAddrByteSize(); } |
95 | uint8_t () const { |
96 | return FormParams.getDwarfOffsetByteSize(); |
97 | } |
98 | uint64_t () const { return Length; } |
99 | uint64_t () const { return AbbrOffset; } |
100 | std::optional<uint64_t> () const { return DWOId; } |
101 | void (uint64_t Id) { |
102 | assert((!DWOId || *DWOId == Id) && "setting DWOId to a different value" ); |
103 | DWOId = Id; |
104 | } |
105 | const DWARFUnitIndex::Entry *() const { return IndexEntry; } |
106 | uint64_t () const { return TypeHash; } |
107 | uint64_t () const { return TypeOffset; } |
108 | uint8_t () const { return UnitType; } |
109 | bool () const { |
110 | return UnitType == dwarf::DW_UT_type || UnitType == dwarf::DW_UT_split_type; |
111 | } |
112 | uint8_t () const { return Size; } |
113 | uint8_t () const { |
114 | return dwarf::getUnitLengthFieldByteSize(Format: FormParams.Format); |
115 | } |
116 | uint64_t () const { |
117 | return Offset + Length + getUnitLengthFieldByteSize(); |
118 | } |
119 | }; |
120 | |
121 | const DWARFUnitIndex &getDWARFUnitIndex(DWARFContext &Context, |
122 | DWARFSectionKind Kind); |
123 | |
124 | bool isCompileUnit(const std::unique_ptr<DWARFUnit> &U); |
125 | |
126 | /// Describe a collection of units. Intended to hold all units either from |
127 | /// .debug_info and .debug_types, or from .debug_info.dwo and .debug_types.dwo. |
128 | class DWARFUnitVector final : public SmallVector<std::unique_ptr<DWARFUnit>, 1> { |
129 | std::function<std::unique_ptr<DWARFUnit>(uint64_t, DWARFSectionKind, |
130 | const DWARFSection *, |
131 | const DWARFUnitIndex::Entry *)> |
132 | Parser; |
133 | int NumInfoUnits = -1; |
134 | |
135 | public: |
136 | using UnitVector = SmallVectorImpl<std::unique_ptr<DWARFUnit>>; |
137 | using iterator = typename UnitVector::iterator; |
138 | using iterator_range = llvm::iterator_range<typename UnitVector::iterator>; |
139 | |
140 | using compile_unit_range = |
141 | decltype(make_filter_range(Range: std::declval<iterator_range>(), Pred: isCompileUnit)); |
142 | |
143 | DWARFUnit *getUnitForOffset(uint64_t Offset) const; |
144 | DWARFUnit *getUnitForIndexEntry(const DWARFUnitIndex::Entry &E); |
145 | |
146 | /// Read units from a .debug_info or .debug_types section. Calls made |
147 | /// before finishedInfoUnits() are assumed to be for .debug_info sections, |
148 | /// calls after finishedInfoUnits() are for .debug_types sections. Caller |
149 | /// must not mix calls to addUnitsForSection and addUnitsForDWOSection. |
150 | void addUnitsForSection(DWARFContext &C, const DWARFSection &Section, |
151 | DWARFSectionKind SectionKind); |
152 | /// Read units from a .debug_info.dwo or .debug_types.dwo section. Calls |
153 | /// made before finishedInfoUnits() are assumed to be for .debug_info.dwo |
154 | /// sections, calls after finishedInfoUnits() are for .debug_types.dwo |
155 | /// sections. Caller must not mix calls to addUnitsForSection and |
156 | /// addUnitsForDWOSection. |
157 | void addUnitsForDWOSection(DWARFContext &C, const DWARFSection &DWOSection, |
158 | DWARFSectionKind SectionKind, bool Lazy = false); |
159 | |
160 | /// Add an existing DWARFUnit to this UnitVector. This is used by the DWARF |
161 | /// verifier to process unit separately. |
162 | DWARFUnit *addUnit(std::unique_ptr<DWARFUnit> Unit); |
163 | |
164 | /// Returns number of all units held by this instance. |
165 | unsigned getNumUnits() const { return size(); } |
166 | /// Returns number of units from all .debug_info[.dwo] sections. |
167 | unsigned getNumInfoUnits() const { |
168 | return NumInfoUnits == -1 ? size() : NumInfoUnits; |
169 | } |
170 | /// Returns number of units from all .debug_types[.dwo] sections. |
171 | unsigned getNumTypesUnits() const { return size() - NumInfoUnits; } |
172 | /// Indicate that parsing .debug_info[.dwo] is done, and remaining units |
173 | /// will be from .debug_types[.dwo]. |
174 | void finishedInfoUnits() { NumInfoUnits = size(); } |
175 | |
176 | private: |
177 | void addUnitsImpl(DWARFContext &Context, const DWARFObject &Obj, |
178 | const DWARFSection &Section, const DWARFDebugAbbrev *DA, |
179 | const DWARFSection *RS, const DWARFSection *LocSection, |
180 | StringRef SS, const DWARFSection &SOS, |
181 | const DWARFSection *AOS, const DWARFSection &LS, bool LE, |
182 | bool IsDWO, bool Lazy, DWARFSectionKind SectionKind); |
183 | }; |
184 | |
185 | /// Represents base address of the CU. |
186 | /// Represents a unit's contribution to the string offsets table. |
187 | struct StrOffsetsContributionDescriptor { |
188 | uint64_t Base = 0; |
189 | /// The contribution size not including the header. |
190 | uint64_t Size = 0; |
191 | /// Format and version. |
192 | dwarf::FormParams FormParams = {.Version: 0, .AddrSize: 0, .Format: dwarf::DwarfFormat::DWARF32}; |
193 | |
194 | StrOffsetsContributionDescriptor(uint64_t Base, uint64_t Size, |
195 | uint8_t Version, dwarf::DwarfFormat Format) |
196 | : Base(Base), Size(Size), FormParams({.Version: Version, .AddrSize: 0, .Format: Format}) {} |
197 | StrOffsetsContributionDescriptor() = default; |
198 | |
199 | uint8_t getVersion() const { return FormParams.Version; } |
200 | dwarf::DwarfFormat getFormat() const { return FormParams.Format; } |
201 | uint8_t getDwarfOffsetByteSize() const { |
202 | return FormParams.getDwarfOffsetByteSize(); |
203 | } |
204 | /// Determine whether a contribution to the string offsets table is |
205 | /// consistent with the relevant section size and that its length is |
206 | /// a multiple of the size of one of its entries. |
207 | Expected<StrOffsetsContributionDescriptor> |
208 | (DWARFDataExtractor &DA); |
209 | }; |
210 | |
211 | class DWARFUnit { |
212 | DWARFContext &Context; |
213 | /// Section containing this DWARFUnit. |
214 | const DWARFSection &InfoSection; |
215 | |
216 | DWARFUnitHeader ; |
217 | const DWARFDebugAbbrev *Abbrev; |
218 | const DWARFSection *RangeSection; |
219 | uint64_t RangeSectionBase; |
220 | uint64_t LocSectionBase; |
221 | |
222 | /// Location table of this unit. |
223 | std::unique_ptr<DWARFLocationTable> LocTable; |
224 | |
225 | const DWARFSection &LineSection; |
226 | StringRef StringSection; |
227 | const DWARFSection &StringOffsetSection; |
228 | const DWARFSection *AddrOffsetSection; |
229 | DWARFUnit *SU; |
230 | std::optional<uint64_t> AddrOffsetSectionBase; |
231 | bool IsLittleEndian; |
232 | bool IsDWO; |
233 | const DWARFUnitVector &UnitVector; |
234 | |
235 | /// Start, length, and DWARF format of the unit's contribution to the string |
236 | /// offsets table (DWARF v5). |
237 | std::optional<StrOffsetsContributionDescriptor> |
238 | StringOffsetsTableContribution; |
239 | |
240 | mutable const DWARFAbbreviationDeclarationSet *Abbrevs; |
241 | std::optional<object::SectionedAddress> BaseAddr; |
242 | /// The compile unit debug information entry items. |
243 | std::vector<DWARFDebugInfoEntry> DieArray; |
244 | |
245 | /// Map from range's start address to end address and corresponding DIE. |
246 | /// IntervalMap does not support range removal, as a result, we use the |
247 | /// std::map::upper_bound for address range lookup. |
248 | std::map<uint64_t, std::pair<uint64_t, DWARFDie>> AddrDieMap; |
249 | |
250 | /// Map from the location (interpreted DW_AT_location) of a DW_TAG_variable, |
251 | /// to the end address and the corresponding DIE. |
252 | std::map<uint64_t, std::pair<uint64_t, DWARFDie>> VariableDieMap; |
253 | DenseSet<uint64_t> RootsParsedForVariables; |
254 | |
255 | using die_iterator_range = |
256 | iterator_range<std::vector<DWARFDebugInfoEntry>::iterator>; |
257 | |
258 | std::shared_ptr<DWARFUnit> DWO; |
259 | |
260 | protected: |
261 | friend dwarf_linker::parallel::CompileUnit; |
262 | |
263 | /// Return the index of a \p Die entry inside the unit's DIE vector. |
264 | /// |
265 | /// It is illegal to call this method with a DIE that hasn't be |
266 | /// created by this unit. In other word, it's illegal to call this |
267 | /// method on a DIE that isn't accessible by following |
268 | /// children/sibling links starting from this unit's getUnitDIE(). |
269 | uint32_t getDIEIndex(const DWARFDebugInfoEntry *Die) const { |
270 | auto First = DieArray.data(); |
271 | assert(Die >= First && Die < First + DieArray.size()); |
272 | return Die - First; |
273 | } |
274 | |
275 | /// Return DWARFDebugInfoEntry for the specified index \p Index. |
276 | const DWARFDebugInfoEntry *getDebugInfoEntry(unsigned Index) const { |
277 | assert(Index < DieArray.size()); |
278 | return &DieArray[Index]; |
279 | } |
280 | |
281 | const DWARFDebugInfoEntry * |
282 | getParentEntry(const DWARFDebugInfoEntry *Die) const; |
283 | const DWARFDebugInfoEntry * |
284 | getSiblingEntry(const DWARFDebugInfoEntry *Die) const; |
285 | const DWARFDebugInfoEntry * |
286 | getPreviousSiblingEntry(const DWARFDebugInfoEntry *Die) const; |
287 | const DWARFDebugInfoEntry * |
288 | getFirstChildEntry(const DWARFDebugInfoEntry *Die) const; |
289 | const DWARFDebugInfoEntry * |
290 | getLastChildEntry(const DWARFDebugInfoEntry *Die) const; |
291 | |
292 | const DWARFUnitHeader &() const { return Header; } |
293 | |
294 | /// Find the unit's contribution to the string offsets table and determine its |
295 | /// length and form. The given offset is expected to be derived from the unit |
296 | /// DIE's DW_AT_str_offsets_base attribute. |
297 | Expected<std::optional<StrOffsetsContributionDescriptor>> |
298 | (DWARFDataExtractor &DA); |
299 | |
300 | /// Find the unit's contribution to the string offsets table and determine its |
301 | /// length and form. The given offset is expected to be 0 in a dwo file or, |
302 | /// in a dwp file, the start of the unit's contribution to the string offsets |
303 | /// table section (as determined by the index table). |
304 | Expected<std::optional<StrOffsetsContributionDescriptor>> |
305 | (DWARFDataExtractor &DA); |
306 | |
307 | public: |
308 | (DWARFContext &Context, const DWARFSection &Section, |
309 | const DWARFUnitHeader &, const DWARFDebugAbbrev *DA, |
310 | const DWARFSection *RS, const DWARFSection *LocSection, |
311 | StringRef SS, const DWARFSection &SOS, const DWARFSection *AOS, |
312 | const DWARFSection &LS, bool LE, bool IsDWO, |
313 | const DWARFUnitVector &UnitVector); |
314 | |
315 | virtual ~DWARFUnit(); |
316 | |
317 | bool isLittleEndian() const { return IsLittleEndian; } |
318 | bool isDWOUnit() const { return IsDWO; } |
319 | DWARFContext& getContext() const { return Context; } |
320 | const DWARFSection &getInfoSection() const { return InfoSection; } |
321 | uint64_t getOffset() const { return Header.getOffset(); } |
322 | const dwarf::FormParams &getFormParams() const { |
323 | return Header.getFormParams(); |
324 | } |
325 | uint16_t getVersion() const { return Header.getVersion(); } |
326 | uint8_t getAddressByteSize() const { return Header.getAddressByteSize(); } |
327 | uint8_t getRefAddrByteSize() const { return Header.getRefAddrByteSize(); } |
328 | uint8_t getDwarfOffsetByteSize() const { |
329 | return Header.getDwarfOffsetByteSize(); |
330 | } |
331 | /// Size in bytes of the parsed unit header. |
332 | uint32_t () const { return Header.getSize(); } |
333 | uint64_t getLength() const { return Header.getLength(); } |
334 | dwarf::DwarfFormat getFormat() const { return Header.getFormat(); } |
335 | uint8_t getUnitType() const { return Header.getUnitType(); } |
336 | bool isTypeUnit() const { return Header.isTypeUnit(); } |
337 | uint64_t getAbbrOffset() const { return Header.getAbbrOffset(); } |
338 | uint64_t getNextUnitOffset() const { return Header.getNextUnitOffset(); } |
339 | const DWARFSection &getLineSection() const { return LineSection; } |
340 | StringRef getStringSection() const { return StringSection; } |
341 | const DWARFSection &getStringOffsetSection() const { |
342 | return StringOffsetSection; |
343 | } |
344 | |
345 | void setSkeletonUnit(DWARFUnit *SU) { this->SU = SU; } |
346 | // Returns itself if not using Split DWARF, or if the unit is a skeleton unit |
347 | // - otherwise returns the split full unit's corresponding skeleton, if |
348 | // available. |
349 | DWARFUnit *getLinkedUnit() { return IsDWO ? SU : this; } |
350 | |
351 | void setAddrOffsetSection(const DWARFSection *AOS, uint64_t Base) { |
352 | AddrOffsetSection = AOS; |
353 | AddrOffsetSectionBase = Base; |
354 | } |
355 | |
356 | std::optional<uint64_t> getAddrOffsetSectionBase() const { |
357 | return AddrOffsetSectionBase; |
358 | } |
359 | |
360 | /// Returns offset to the indexed address value inside .debug_addr section. |
361 | std::optional<uint64_t> getIndexedAddressOffset(uint64_t Index) { |
362 | if (std::optional<uint64_t> AddrOffsetSectionBase = |
363 | getAddrOffsetSectionBase()) |
364 | return *AddrOffsetSectionBase + Index * getAddressByteSize(); |
365 | |
366 | return std::nullopt; |
367 | } |
368 | |
369 | /// Recursively update address to Die map. |
370 | void updateAddressDieMap(DWARFDie Die); |
371 | |
372 | /// Recursively update address to variable Die map. |
373 | void updateVariableDieMap(DWARFDie Die); |
374 | |
375 | void setRangesSection(const DWARFSection *RS, uint64_t Base) { |
376 | RangeSection = RS; |
377 | RangeSectionBase = Base; |
378 | } |
379 | |
380 | uint64_t getLocSectionBase() const { |
381 | return LocSectionBase; |
382 | } |
383 | |
384 | std::optional<object::SectionedAddress> |
385 | getAddrOffsetSectionItem(uint32_t Index) const; |
386 | Expected<uint64_t> getStringOffsetSectionItem(uint32_t Index) const; |
387 | |
388 | DWARFDataExtractor () const; |
389 | |
390 | DataExtractor () const { |
391 | return DataExtractor(StringSection, false, 0); |
392 | } |
393 | |
394 | const DWARFLocationTable &getLocationTable() { return *LocTable; } |
395 | |
396 | /// Extract the range list referenced by this compile unit from the |
397 | /// .debug_ranges section. If the extraction is unsuccessful, an error |
398 | /// is returned. Successful extraction requires that the compile unit |
399 | /// has already been extracted. |
400 | Error (uint64_t RangeListOffset, |
401 | DWARFDebugRangeList &RangeList) const; |
402 | void clear(); |
403 | |
404 | const std::optional<StrOffsetsContributionDescriptor> & |
405 | getStringOffsetsTableContribution() { |
406 | extractDIEsIfNeeded(CUDieOnly: true /*CUDIeOnly*/); |
407 | return StringOffsetsTableContribution; |
408 | } |
409 | |
410 | uint8_t getDwarfStringOffsetsByteSize() const { |
411 | assert(StringOffsetsTableContribution); |
412 | return StringOffsetsTableContribution->getDwarfOffsetByteSize(); |
413 | } |
414 | |
415 | uint64_t getStringOffsetsBase() const { |
416 | assert(StringOffsetsTableContribution); |
417 | return StringOffsetsTableContribution->Base; |
418 | } |
419 | |
420 | uint64_t getAbbreviationsOffset() const { return Header.getAbbrOffset(); } |
421 | |
422 | const DWARFAbbreviationDeclarationSet *getAbbreviations() const; |
423 | |
424 | static bool isMatchingUnitTypeAndTag(uint8_t UnitType, dwarf::Tag Tag) { |
425 | switch (UnitType) { |
426 | case dwarf::DW_UT_compile: |
427 | return Tag == dwarf::DW_TAG_compile_unit; |
428 | case dwarf::DW_UT_type: |
429 | return Tag == dwarf::DW_TAG_type_unit; |
430 | case dwarf::DW_UT_partial: |
431 | return Tag == dwarf::DW_TAG_partial_unit; |
432 | case dwarf::DW_UT_skeleton: |
433 | return Tag == dwarf::DW_TAG_skeleton_unit; |
434 | case dwarf::DW_UT_split_compile: |
435 | case dwarf::DW_UT_split_type: |
436 | return dwarf::isUnitType(T: Tag); |
437 | } |
438 | return false; |
439 | } |
440 | |
441 | std::optional<object::SectionedAddress> getBaseAddress(); |
442 | |
443 | DWARFDie getUnitDIE(bool = true) { |
444 | extractDIEsIfNeeded(CUDieOnly: ExtractUnitDIEOnly); |
445 | if (DieArray.empty()) |
446 | return DWARFDie(); |
447 | return DWARFDie(this, &DieArray[0]); |
448 | } |
449 | |
450 | DWARFDie getNonSkeletonUnitDIE(bool = true, |
451 | StringRef DWOAlternativeLocation = {}) { |
452 | parseDWO(AlternativeLocation: DWOAlternativeLocation); |
453 | return DWO ? DWO->getUnitDIE(ExtractUnitDIEOnly) |
454 | : getUnitDIE(ExtractUnitDIEOnly); |
455 | } |
456 | |
457 | const char *getCompilationDir(); |
458 | std::optional<uint64_t> getDWOId() { |
459 | extractDIEsIfNeeded(/*CUDieOnly*/ CUDieOnly: true); |
460 | return getHeader().getDWOId(); |
461 | } |
462 | void setDWOId(uint64_t NewID) { Header.setDWOId(NewID); } |
463 | |
464 | /// Return a vector of address ranges resulting from a (possibly encoded) |
465 | /// range list starting at a given offset in the appropriate ranges section. |
466 | Expected<DWARFAddressRangesVector> findRnglistFromOffset(uint64_t Offset); |
467 | |
468 | /// Return a vector of address ranges retrieved from an encoded range |
469 | /// list whose offset is found via a table lookup given an index (DWARF v5 |
470 | /// and later). |
471 | Expected<DWARFAddressRangesVector> findRnglistFromIndex(uint32_t Index); |
472 | |
473 | /// Return a rangelist's offset based on an index. The index designates |
474 | /// an entry in the rangelist table's offset array and is supplied by |
475 | /// DW_FORM_rnglistx. |
476 | std::optional<uint64_t> getRnglistOffset(uint32_t Index); |
477 | |
478 | std::optional<uint64_t> getLoclistOffset(uint32_t Index); |
479 | |
480 | Expected<DWARFAddressRangesVector> collectAddressRanges(); |
481 | |
482 | Expected<DWARFLocationExpressionsVector> |
483 | findLoclistFromOffset(uint64_t Offset); |
484 | |
485 | /// Returns subprogram DIE with address range encompassing the provided |
486 | /// address. The pointer is alive as long as parsed compile unit DIEs are not |
487 | /// cleared. |
488 | DWARFDie getSubroutineForAddress(uint64_t Address); |
489 | |
490 | /// Returns variable DIE for the address provided. The pointer is alive as |
491 | /// long as parsed compile unit DIEs are not cleared. |
492 | DWARFDie getVariableForAddress(uint64_t Address); |
493 | |
494 | /// getInlinedChainForAddress - fetches inlined chain for a given address. |
495 | /// Returns empty chain if there is no subprogram containing address. The |
496 | /// chain is valid as long as parsed compile unit DIEs are not cleared. |
497 | void getInlinedChainForAddress(uint64_t Address, |
498 | SmallVectorImpl<DWARFDie> &InlinedChain); |
499 | |
500 | /// Return the DWARFUnitVector containing this unit. |
501 | const DWARFUnitVector &getUnitVector() const { return UnitVector; } |
502 | |
503 | /// Returns the number of DIEs in the unit. Parses the unit |
504 | /// if necessary. |
505 | unsigned getNumDIEs() { |
506 | extractDIEsIfNeeded(CUDieOnly: false); |
507 | return DieArray.size(); |
508 | } |
509 | |
510 | /// Return the index of a DIE inside the unit's DIE vector. |
511 | /// |
512 | /// It is illegal to call this method with a DIE that hasn't be |
513 | /// created by this unit. In other word, it's illegal to call this |
514 | /// method on a DIE that isn't accessible by following |
515 | /// children/sibling links starting from this unit's getUnitDIE(). |
516 | uint32_t getDIEIndex(const DWARFDie &D) const { |
517 | return getDIEIndex(Die: D.getDebugInfoEntry()); |
518 | } |
519 | |
520 | /// Return the DIE object at the given index \p Index. |
521 | DWARFDie getDIEAtIndex(unsigned Index) { |
522 | return DWARFDie(this, getDebugInfoEntry(Index)); |
523 | } |
524 | |
525 | DWARFDie getParent(const DWARFDebugInfoEntry *Die); |
526 | DWARFDie getSibling(const DWARFDebugInfoEntry *Die); |
527 | DWARFDie getPreviousSibling(const DWARFDebugInfoEntry *Die); |
528 | DWARFDie getFirstChild(const DWARFDebugInfoEntry *Die); |
529 | DWARFDie getLastChild(const DWARFDebugInfoEntry *Die); |
530 | |
531 | /// Return the DIE object for a given offset \p Offset inside the |
532 | /// unit's DIE vector. |
533 | DWARFDie getDIEForOffset(uint64_t Offset) { |
534 | if (std::optional<uint32_t> DieIdx = getDIEIndexForOffset(Offset)) |
535 | return DWARFDie(this, &DieArray[*DieIdx]); |
536 | |
537 | return DWARFDie(); |
538 | } |
539 | |
540 | /// Return the DIE index for a given offset \p Offset inside the |
541 | /// unit's DIE vector. |
542 | std::optional<uint32_t> getDIEIndexForOffset(uint64_t Offset) { |
543 | extractDIEsIfNeeded(CUDieOnly: false); |
544 | auto It = |
545 | llvm::partition_point(Range&: DieArray, P: [=](const DWARFDebugInfoEntry &DIE) { |
546 | return DIE.getOffset() < Offset; |
547 | }); |
548 | if (It != DieArray.end() && It->getOffset() == Offset) |
549 | return It - DieArray.begin(); |
550 | return std::nullopt; |
551 | } |
552 | |
553 | uint32_t getLineTableOffset() const { |
554 | if (auto IndexEntry = Header.getIndexEntry()) |
555 | if (const auto *Contrib = IndexEntry->getContribution(Sec: DW_SECT_LINE)) |
556 | return Contrib->getOffset32(); |
557 | return 0; |
558 | } |
559 | |
560 | die_iterator_range dies() { |
561 | extractDIEsIfNeeded(CUDieOnly: false); |
562 | return die_iterator_range(DieArray.begin(), DieArray.end()); |
563 | } |
564 | |
565 | virtual void dump(raw_ostream &OS, DIDumpOptions DumpOpts) = 0; |
566 | |
567 | Error (bool CUDieOnly); |
568 | |
569 | private: |
570 | /// Size in bytes of the .debug_info data associated with this compile unit. |
571 | size_t getDebugInfoSize() const { |
572 | return Header.getLength() + Header.getUnitLengthFieldByteSize() - |
573 | getHeaderSize(); |
574 | } |
575 | |
576 | /// extractDIEsIfNeeded - Parses a compile unit and indexes its DIEs if it |
577 | /// hasn't already been done |
578 | void (bool CUDieOnly); |
579 | |
580 | /// extractDIEsToVector - Appends all parsed DIEs to a vector. |
581 | void (bool AppendCUDie, bool AppendNonCUDIEs, |
582 | std::vector<DWARFDebugInfoEntry> &DIEs) const; |
583 | |
584 | /// clearDIEs - Clear parsed DIEs to keep memory usage low. |
585 | void clearDIEs(bool KeepCUDie); |
586 | |
587 | /// parseDWO - Parses .dwo file for current compile unit. Returns true if |
588 | /// it was actually constructed. |
589 | /// The \p AlternativeLocation specifies an alternative location to get |
590 | /// the DWARF context for the DWO object; this is the case when it has |
591 | /// been moved from its original location. |
592 | bool parseDWO(StringRef AlternativeLocation = {}); |
593 | }; |
594 | |
595 | inline bool isCompileUnit(const std::unique_ptr<DWARFUnit> &U) { |
596 | return !U->isTypeUnit(); |
597 | } |
598 | |
599 | } // end namespace llvm |
600 | |
601 | #endif // LLVM_DEBUGINFO_DWARF_DWARFUNIT_H |
602 | |