LLVM 20.0.0git
DWARFYAML.h
Go to the documentation of this file.
1//===- DWARFYAML.h - DWARF YAMLIO implementation ----------------*- 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/// \file
10/// This file declares classes for handling the YAML representation
11/// of DWARF Debug Info.
12///
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_OBJECTYAML_DWARFYAML_H
16#define LLVM_OBJECTYAML_DWARFYAML_H
17
18#include "llvm/ADT/SetVector.h"
19#include "llvm/ADT/StringRef.h"
23#include <cstdint>
24#include <optional>
25#include <unordered_map>
26#include <vector>
27
28namespace llvm {
29namespace DWARFYAML {
30
34 llvm::yaml::Hex64 Value; // Some DWARF5 attributes have values
35};
36
37struct Abbrev {
38 std::optional<yaml::Hex64> Code;
41 std::vector<AttributeAbbrev> Attributes;
42};
43
45 std::optional<uint64_t> ID;
46 std::vector<Abbrev> Table;
47};
48
50 llvm::yaml::Hex64 Address;
51 yaml::Hex64 Length;
52};
53
54struct ARange {
56 std::optional<yaml::Hex64> Length;
58 yaml::Hex64 CuOffset;
59 std::optional<yaml::Hex8> AddrSize;
60 yaml::Hex8 SegSize;
61 std::vector<ARangeDescriptor> Descriptors;
62};
63
64/// Class that describes a range list entry, or a base address selection entry
65/// within a range list in the .debug_ranges section.
66struct RangeEntry {
67 llvm::yaml::Hex64 LowOffset;
68 llvm::yaml::Hex64 HighOffset;
69};
70
71/// Class that describes a single range list inside the .debug_ranges section.
72struct Ranges {
73 std::optional<llvm::yaml::Hex64> Offset;
74 std::optional<llvm::yaml::Hex8> AddrSize;
75 std::vector<RangeEntry> Entries;
76};
77
78struct PubEntry {
79 llvm::yaml::Hex32 DieOffset;
80 llvm::yaml::Hex8 Descriptor;
82};
83
84struct PubSection {
86 yaml::Hex64 Length;
90 std::vector<PubEntry> Entries;
91};
92
93struct FormValue {
94 llvm::yaml::Hex64 Value;
96 std::vector<llvm::yaml::Hex8> BlockData;
97};
98
99struct Entry {
100 llvm::yaml::Hex32 AbbrCode;
101 std::vector<FormValue> Values;
102};
103
104/// Class that contains helpful context information when mapping YAML into DWARF
105/// data structures.
107 bool IsGNUPubSec = false;
108};
109
110struct Unit {
112 std::optional<yaml::Hex64> Length;
114 std::optional<uint8_t> AddrSize;
115 llvm::dwarf::UnitType Type; // Added in DWARF 5
116 std::optional<uint64_t> AbbrevTableID;
117 std::optional<yaml::Hex64> AbbrOffset;
118 yaml::Hex64 TypeSignatureOrDwoID; // For type or split units
119 yaml::Hex64 TypeOffset; // For type units
120
121 std::vector<Entry> Entries;
122};
123
124struct IdxForm {
127};
128
130 yaml::Hex64 Code;
132 std::vector<IdxForm> Indices;
133};
134
136 yaml::Hex32 NameStrp;
137 yaml::Hex64 Code;
138 std::vector<yaml::Hex64> Values;
139};
140
142 std::vector<DebugNameAbbreviation> Abbrevs;
143 std::vector<DebugNameEntry> Entries;
144};
145
146struct File {
151};
152
155 std::optional<uint64_t> ExtLen;
158 int64_t SData;
160 std::vector<llvm::yaml::Hex8> UnknownOpcodeData;
161 std::vector<llvm::yaml::Hex64> StandardOpcodeData;
162};
163
164struct LineTable {
166 std::optional<uint64_t> Length;
168 std::optional<uint64_t> PrologueLength;
172 uint8_t LineBase;
173 uint8_t LineRange;
174 std::optional<uint8_t> OpcodeBase;
175 std::optional<std::vector<uint8_t>> StandardOpcodeLengths;
176 std::vector<StringRef> IncludeDirs;
177 std::vector<File> Files;
178 std::vector<LineTableOpcode> Opcodes;
179};
180
182 yaml::Hex64 Segment;
183 yaml::Hex64 Address;
184};
185
188 std::optional<yaml::Hex64> Length;
189 yaml::Hex16 Version;
190 std::optional<yaml::Hex8> AddrSize;
191 yaml::Hex8 SegSelectorSize;
192 std::vector<SegAddrPair> SegAddrPairs;
193};
194
197 std::optional<yaml::Hex64> Length;
198 yaml::Hex16 Version;
199 yaml::Hex16 Padding;
200 std::vector<yaml::Hex64> Offsets;
201};
202
205 std::vector<yaml::Hex64> Values;
206};
207
210 std::vector<yaml::Hex64> Values;
211};
212
215 std::vector<yaml::Hex64> Values;
216 std::optional<yaml::Hex64> DescriptionsLength;
217 std::vector<DWARFOperation> Descriptions;
218};
219
220template <typename EntryType> struct ListEntries {
221 std::optional<std::vector<EntryType>> Entries;
222 std::optional<yaml::BinaryRef> Content;
223};
224
225template <typename EntryType> struct ListTable {
227 std::optional<yaml::Hex64> Length;
228 yaml::Hex16 Version;
229 std::optional<yaml::Hex8> AddrSize;
230 yaml::Hex8 SegSelectorSize;
231 std::optional<uint32_t> OffsetEntryCount;
232 std::optional<std::vector<yaml::Hex64>> Offsets;
233 std::vector<ListEntries<EntryType>> Lists;
234};
235
236struct Data {
239 std::vector<AbbrevTable> DebugAbbrev;
240 std::optional<std::vector<StringRef>> DebugStrings;
241 std::optional<std::vector<StringOffsetsTable>> DebugStrOffsets;
242 std::optional<std::vector<ARange>> DebugAranges;
243 std::optional<std::vector<Ranges>> DebugRanges;
244 std::optional<std::vector<AddrTableEntry>> DebugAddr;
245 std::optional<PubSection> PubNames;
246 std::optional<PubSection> PubTypes;
247
248 std::optional<PubSection> GNUPubNames;
249 std::optional<PubSection> GNUPubTypes;
250
251 std::vector<Unit> Units;
252
253 std::vector<LineTable> DebugLines;
254 std::optional<std::vector<ListTable<RnglistEntry>>> DebugRnglists;
255 std::optional<std::vector<ListTable<LoclistEntry>>> DebugLoclists;
256 std::optional<DebugNamesSection> DebugNames;
257
258 bool isEmpty() const;
259
261
265 };
268
269private:
270 mutable std::unordered_map<uint64_t, AbbrevTableInfo> AbbrevTableInfoMap;
271 mutable std::unordered_map<uint64_t, std::string> AbbrevTableContents;
272};
273
274} // end namespace DWARFYAML
275} // end namespace llvm
276
308
309namespace llvm {
310namespace yaml {
311
312template <> struct MappingTraits<DWARFYAML::Data> {
313 static void mapping(IO &IO, DWARFYAML::Data &DWARF);
314};
315
316template <> struct MappingTraits<DWARFYAML::AbbrevTable> {
317 static void mapping(IO &IO, DWARFYAML::AbbrevTable &AbbrevTable);
318};
319
320template <> struct MappingTraits<DWARFYAML::Abbrev> {
321 static void mapping(IO &IO, DWARFYAML::Abbrev &Abbrev);
322};
323
324template <> struct MappingTraits<DWARFYAML::AttributeAbbrev> {
325 static void mapping(IO &IO, DWARFYAML::AttributeAbbrev &AttAbbrev);
326};
327
328template <> struct MappingTraits<DWARFYAML::ARangeDescriptor> {
329 static void mapping(IO &IO, DWARFYAML::ARangeDescriptor &Descriptor);
330};
331
332template <> struct MappingTraits<DWARFYAML::ARange> {
333 static void mapping(IO &IO, DWARFYAML::ARange &ARange);
334};
335
336template <> struct MappingTraits<DWARFYAML::RangeEntry> {
337 static void mapping(IO &IO, DWARFYAML::RangeEntry &Entry);
338};
339
340template <> struct MappingTraits<DWARFYAML::Ranges> {
341 static void mapping(IO &IO, DWARFYAML::Ranges &Ranges);
342};
343
344template <> struct MappingTraits<DWARFYAML::PubEntry> {
345 static void mapping(IO &IO, DWARFYAML::PubEntry &Entry);
346};
347
348template <> struct MappingTraits<DWARFYAML::PubSection> {
349 static void mapping(IO &IO, DWARFYAML::PubSection &Section);
350};
351
352template <> struct MappingTraits<DWARFYAML::Unit> {
353 static void mapping(IO &IO, DWARFYAML::Unit &Unit);
354};
355
356template <> struct MappingTraits<DWARFYAML::DebugNamesSection> {
357 static void mapping(IO &IO, DWARFYAML::DebugNamesSection &);
358};
359template <> struct MappingTraits<DWARFYAML::DebugNameEntry> {
360 static void mapping(IO &IO, DWARFYAML::DebugNameEntry &);
361};
362template <> struct MappingTraits<DWARFYAML::DebugNameAbbreviation> {
363 static void mapping(IO &IO, DWARFYAML::DebugNameAbbreviation &);
364};
365template <> struct MappingTraits<DWARFYAML::IdxForm> {
366 static void mapping(IO &IO, DWARFYAML::IdxForm &);
367};
368
369template <> struct MappingTraits<DWARFYAML::Entry> {
370 static void mapping(IO &IO, DWARFYAML::Entry &Entry);
371};
372
373template <> struct MappingTraits<DWARFYAML::FormValue> {
374 static void mapping(IO &IO, DWARFYAML::FormValue &FormValue);
375};
376
377template <> struct MappingTraits<DWARFYAML::File> {
378 static void mapping(IO &IO, DWARFYAML::File &File);
379};
380
381template <> struct MappingTraits<DWARFYAML::LineTableOpcode> {
382 static void mapping(IO &IO, DWARFYAML::LineTableOpcode &LineTableOpcode);
383};
384
385template <> struct MappingTraits<DWARFYAML::LineTable> {
386 static void mapping(IO &IO, DWARFYAML::LineTable &LineTable);
387};
388
389template <> struct MappingTraits<DWARFYAML::SegAddrPair> {
390 static void mapping(IO &IO, DWARFYAML::SegAddrPair &SegAddrPair);
391};
392
393template <> struct MappingTraits<DWARFYAML::DWARFOperation> {
394 static void mapping(IO &IO, DWARFYAML::DWARFOperation &DWARFOperation);
395};
396
397template <typename EntryType>
398struct MappingTraits<DWARFYAML::ListTable<EntryType>> {
399 static void mapping(IO &IO, DWARFYAML::ListTable<EntryType> &ListTable);
400};
401
402template <typename EntryType>
403struct MappingTraits<DWARFYAML::ListEntries<EntryType>> {
404 static void mapping(IO &IO, DWARFYAML::ListEntries<EntryType> &ListEntries);
405 static std::string validate(IO &IO,
406 DWARFYAML::ListEntries<EntryType> &ListEntries);
407};
408
409template <> struct MappingTraits<DWARFYAML::RnglistEntry> {
410 static void mapping(IO &IO, DWARFYAML::RnglistEntry &RnglistEntry);
411};
412
413template <> struct MappingTraits<DWARFYAML::LoclistEntry> {
414 static void mapping(IO &IO, DWARFYAML::LoclistEntry &LoclistEntry);
415};
416
417template <> struct MappingTraits<DWARFYAML::AddrTableEntry> {
418 static void mapping(IO &IO, DWARFYAML::AddrTableEntry &AddrTable);
419};
420
421template <> struct MappingTraits<DWARFYAML::StringOffsetsTable> {
422 static void mapping(IO &IO, DWARFYAML::StringOffsetsTable &StrOffsetsTable);
423};
424
425template <> struct ScalarEnumerationTraits<dwarf::DwarfFormat> {
426 static void enumeration(IO &IO, dwarf::DwarfFormat &Format) {
427 IO.enumCase(Format, "DWARF32", dwarf::DWARF32);
428 IO.enumCase(Format, "DWARF64", dwarf::DWARF64);
429 }
430};
431
432#define HANDLE_DW_TAG(unused, name, unused2, unused3, unused4) \
433 io.enumCase(value, "DW_TAG_" #name, dwarf::DW_TAG_##name);
434
435template <> struct ScalarEnumerationTraits<dwarf::Tag> {
436 static void enumeration(IO &io, dwarf::Tag &value) {
437#include "llvm/BinaryFormat/Dwarf.def"
438 io.enumFallback<Hex16>(value);
439 }
440};
441
442#define HANDLE_DW_LNS(unused, name) \
443 io.enumCase(value, "DW_LNS_" #name, dwarf::DW_LNS_##name);
444
445template <> struct ScalarEnumerationTraits<dwarf::LineNumberOps> {
446 static void enumeration(IO &io, dwarf::LineNumberOps &value) {
447#include "llvm/BinaryFormat/Dwarf.def"
448 io.enumFallback<Hex8>(value);
449 }
450};
451
452#define HANDLE_DW_LNE(unused, name) \
453 io.enumCase(value, "DW_LNE_" #name, dwarf::DW_LNE_##name);
454
455template <> struct ScalarEnumerationTraits<dwarf::LineNumberExtendedOps> {
456 static void enumeration(IO &io, dwarf::LineNumberExtendedOps &value) {
457#include "llvm/BinaryFormat/Dwarf.def"
458 io.enumFallback<Hex16>(value);
459 }
460};
461
462#define HANDLE_DW_AT(unused, name, unused2, unused3) \
463 io.enumCase(value, "DW_AT_" #name, dwarf::DW_AT_##name);
464
465template <> struct ScalarEnumerationTraits<dwarf::Attribute> {
466 static void enumeration(IO &io, dwarf::Attribute &value) {
467#include "llvm/BinaryFormat/Dwarf.def"
468 io.enumFallback<Hex16>(value);
469 }
470};
471
472#define HANDLE_DW_FORM(unused, name, unused2, unused3) \
473 io.enumCase(value, "DW_FORM_" #name, dwarf::DW_FORM_##name);
474
475template <> struct ScalarEnumerationTraits<dwarf::Form> {
476 static void enumeration(IO &io, dwarf::Form &value) {
477#include "llvm/BinaryFormat/Dwarf.def"
478 io.enumFallback<Hex16>(value);
479 }
480};
481
482#define HANDLE_DW_IDX(unused, name) \
483 io.enumCase(value, "DW_IDX_" #name, dwarf::DW_IDX_##name);
484
485template <> struct ScalarEnumerationTraits<dwarf::Index> {
486 static void enumeration(IO &io, dwarf::Index &value) {
487#include "llvm/BinaryFormat/Dwarf.def"
488 io.enumFallback<Hex16>(value);
489 }
490};
491
492#define HANDLE_DW_UT(unused, name) \
493 io.enumCase(value, "DW_UT_" #name, dwarf::DW_UT_##name);
494
495template <> struct ScalarEnumerationTraits<dwarf::UnitType> {
496 static void enumeration(IO &io, dwarf::UnitType &value) {
497#include "llvm/BinaryFormat/Dwarf.def"
498 io.enumFallback<Hex8>(value);
499 }
500};
501
502template <> struct ScalarEnumerationTraits<dwarf::Constants> {
503 static void enumeration(IO &io, dwarf::Constants &value) {
504 io.enumCase(value, "DW_CHILDREN_no", dwarf::DW_CHILDREN_no);
505 io.enumCase(value, "DW_CHILDREN_yes", dwarf::DW_CHILDREN_yes);
506 io.enumFallback<Hex16>(value);
507 }
508};
509
510#define HANDLE_DW_RLE(unused, name) \
511 io.enumCase(value, "DW_RLE_" #name, dwarf::DW_RLE_##name);
512
513template <> struct ScalarEnumerationTraits<dwarf::RnglistEntries> {
514 static void enumeration(IO &io, dwarf::RnglistEntries &value) {
515#include "llvm/BinaryFormat/Dwarf.def"
516 }
517};
518
519#define HANDLE_DW_LLE(unused, name) \
520 io.enumCase(value, "DW_LLE_" #name, dwarf::DW_LLE_##name);
521
522template <> struct ScalarEnumerationTraits<dwarf::LoclistEntries> {
523 static void enumeration(IO &io, dwarf::LoclistEntries &value) {
524#include "llvm/BinaryFormat/Dwarf.def"
525 }
526};
527
528#define HANDLE_DW_OP(id, name, operands, arity, version, vendor) \
529 io.enumCase(value, "DW_OP_" #name, dwarf::DW_OP_##name);
530
531template <> struct ScalarEnumerationTraits<dwarf::LocationAtom> {
532 static void enumeration(IO &io, dwarf::LocationAtom &value) {
533#include "llvm/BinaryFormat/Dwarf.def"
534 io.enumFallback<yaml::Hex8>(value);
535 }
536};
537
538} // end namespace yaml
539} // end namespace llvm
540
541#endif // LLVM_OBJECTYAML_DWARFYAML_H
Given that RA is a live value
This file contains constants used for implementing Dwarf debug support.
This file implements a set that has insertion order iteration characteristics.
#define LLVM_YAML_IS_SEQUENCE_VECTOR(type)
Tagged union holding either a T or a Error.
Definition: Error.h:481
A vector that has set insertion semantics.
Definition: SetVector.h:57
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
@ Entry
Definition: COFF.h:826
void validate(const Triple &TT, const FeatureBitset &FeatureBits)
Attribute
Attributes.
Definition: Dwarf.h:123
LineNumberOps
Line Number Standard Opcode Encodings.
Definition: Dwarf.h:767
LoclistEntries
DWARF v5 loc list entry encoding values.
Definition: Dwarf.h:819
UnitType
Constants for unit types in DWARF v5.
Definition: Dwarf.h:868
LocationAtom
Definition: Dwarf.h:136
DwarfFormat
Constants that define the DWARF format as 32 or 64 bit.
Definition: Dwarf.h:91
RnglistEntries
DWARF v5 range list entry encoding values.
Definition: Dwarf.h:813
LineNumberExtendedOps
Line Number Extended Opcode Encodings.
Definition: Dwarf.h:773
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
std::optional< yaml::Hex64 > Length
Definition: DWARFYAML.h:56
yaml::Hex64 CuOffset
Definition: DWARFYAML.h:58
dwarf::DwarfFormat Format
Definition: DWARFYAML.h:55
std::vector< ARangeDescriptor > Descriptors
Definition: DWARFYAML.h:61
std::optional< yaml::Hex8 > AddrSize
Definition: DWARFYAML.h:59
std::vector< Abbrev > Table
Definition: DWARFYAML.h:46
std::optional< uint64_t > ID
Definition: DWARFYAML.h:45
llvm::dwarf::Tag Tag
Definition: DWARFYAML.h:39
std::vector< AttributeAbbrev > Attributes
Definition: DWARFYAML.h:41
std::optional< yaml::Hex64 > Code
Definition: DWARFYAML.h:38
llvm::dwarf::Constants Children
Definition: DWARFYAML.h:40
std::optional< yaml::Hex64 > Length
Definition: DWARFYAML.h:188
std::optional< yaml::Hex8 > AddrSize
Definition: DWARFYAML.h:190
dwarf::DwarfFormat Format
Definition: DWARFYAML.h:187
std::vector< SegAddrPair > SegAddrPairs
Definition: DWARFYAML.h:192
llvm::dwarf::Attribute Attribute
Definition: DWARFYAML.h:32
Class that contains helpful context information when mapping YAML into DWARF data structures.
Definition: DWARFYAML.h:106
std::vector< yaml::Hex64 > Values
Definition: DWARFYAML.h:205
dwarf::LocationAtom Operator
Definition: DWARFYAML.h:204
std::vector< Unit > Units
Definition: DWARFYAML.h:251
std::vector< LineTable > DebugLines
Definition: DWARFYAML.h:253
std::optional< std::vector< AddrTableEntry > > DebugAddr
Definition: DWARFYAML.h:244
std::optional< std::vector< Ranges > > DebugRanges
Definition: DWARFYAML.h:243
std::optional< std::vector< ListTable< LoclistEntry > > > DebugLoclists
Definition: DWARFYAML.h:255
std::vector< AbbrevTable > DebugAbbrev
Definition: DWARFYAML.h:239
Expected< AbbrevTableInfo > getAbbrevTableInfoByID(uint64_t ID) const
Definition: DWARFYAML.cpp:61
std::optional< PubSection > GNUPubNames
Definition: DWARFYAML.h:248
std::optional< std::vector< ARange > > DebugAranges
Definition: DWARFYAML.h:242
StringRef getAbbrevTableContentByIndex(uint64_t Index) const
std::optional< PubSection > GNUPubTypes
Definition: DWARFYAML.h:249
SetVector< StringRef > getNonEmptySectionNames() const
Definition: DWARFYAML.cpp:25
std::optional< std::vector< StringOffsetsTable > > DebugStrOffsets
Definition: DWARFYAML.h:241
std::optional< std::vector< StringRef > > DebugStrings
Definition: DWARFYAML.h:240
std::optional< std::vector< ListTable< RnglistEntry > > > DebugRnglists
Definition: DWARFYAML.h:254
std::optional< PubSection > PubNames
Definition: DWARFYAML.h:245
std::optional< DebugNamesSection > DebugNames
Definition: DWARFYAML.h:256
std::optional< PubSection > PubTypes
Definition: DWARFYAML.h:246
bool isEmpty() const
Definition: DWARFYAML.cpp:21
std::vector< IdxForm > Indices
Definition: DWARFYAML.h:132
std::vector< yaml::Hex64 > Values
Definition: DWARFYAML.h:138
std::vector< DebugNameAbbreviation > Abbrevs
Definition: DWARFYAML.h:142
std::vector< DebugNameEntry > Entries
Definition: DWARFYAML.h:143
std::vector< FormValue > Values
Definition: DWARFYAML.h:101
llvm::yaml::Hex32 AbbrCode
Definition: DWARFYAML.h:100
std::vector< llvm::yaml::Hex8 > BlockData
Definition: DWARFYAML.h:96
llvm::yaml::Hex64 Value
Definition: DWARFYAML.h:94
dwarf::LineNumberOps Opcode
Definition: DWARFYAML.h:154
std::optional< uint64_t > ExtLen
Definition: DWARFYAML.h:155
std::vector< llvm::yaml::Hex64 > StandardOpcodeData
Definition: DWARFYAML.h:161
dwarf::LineNumberExtendedOps SubOpcode
Definition: DWARFYAML.h:156
std::vector< llvm::yaml::Hex8 > UnknownOpcodeData
Definition: DWARFYAML.h:160
std::optional< uint64_t > Length
Definition: DWARFYAML.h:166
std::optional< uint8_t > OpcodeBase
Definition: DWARFYAML.h:174
std::vector< LineTableOpcode > Opcodes
Definition: DWARFYAML.h:178
std::optional< uint64_t > PrologueLength
Definition: DWARFYAML.h:168
dwarf::DwarfFormat Format
Definition: DWARFYAML.h:165
std::vector< File > Files
Definition: DWARFYAML.h:177
std::vector< StringRef > IncludeDirs
Definition: DWARFYAML.h:176
std::optional< std::vector< uint8_t > > StandardOpcodeLengths
Definition: DWARFYAML.h:175
std::optional< std::vector< EntryType > > Entries
Definition: DWARFYAML.h:221
std::optional< yaml::BinaryRef > Content
Definition: DWARFYAML.h:222
std::optional< yaml::Hex8 > AddrSize
Definition: DWARFYAML.h:229
std::optional< std::vector< yaml::Hex64 > > Offsets
Definition: DWARFYAML.h:232
dwarf::DwarfFormat Format
Definition: DWARFYAML.h:226
std::vector< ListEntries< EntryType > > Lists
Definition: DWARFYAML.h:233
std::optional< uint32_t > OffsetEntryCount
Definition: DWARFYAML.h:231
std::optional< yaml::Hex64 > Length
Definition: DWARFYAML.h:227
std::vector< yaml::Hex64 > Values
Definition: DWARFYAML.h:215
std::optional< yaml::Hex64 > DescriptionsLength
Definition: DWARFYAML.h:216
dwarf::LoclistEntries Operator
Definition: DWARFYAML.h:214
std::vector< DWARFOperation > Descriptions
Definition: DWARFYAML.h:217
llvm::yaml::Hex8 Descriptor
Definition: DWARFYAML.h:80
llvm::yaml::Hex32 DieOffset
Definition: DWARFYAML.h:79
dwarf::DwarfFormat Format
Definition: DWARFYAML.h:85
std::vector< PubEntry > Entries
Definition: DWARFYAML.h:90
Class that describes a range list entry, or a base address selection entry within a range list in the...
Definition: DWARFYAML.h:66
llvm::yaml::Hex64 HighOffset
Definition: DWARFYAML.h:68
llvm::yaml::Hex64 LowOffset
Definition: DWARFYAML.h:67
Class that describes a single range list inside the .debug_ranges section.
Definition: DWARFYAML.h:72
std::vector< RangeEntry > Entries
Definition: DWARFYAML.h:75
std::optional< llvm::yaml::Hex64 > Offset
Definition: DWARFYAML.h:73
std::optional< llvm::yaml::Hex8 > AddrSize
Definition: DWARFYAML.h:74
std::vector< yaml::Hex64 > Values
Definition: DWARFYAML.h:210
dwarf::RnglistEntries Operator
Definition: DWARFYAML.h:209
std::optional< yaml::Hex64 > Length
Definition: DWARFYAML.h:197
std::vector< yaml::Hex64 > Offsets
Definition: DWARFYAML.h:200
std::optional< uint64_t > AbbrevTableID
Definition: DWARFYAML.h:116
yaml::Hex64 TypeOffset
Definition: DWARFYAML.h:119
dwarf::DwarfFormat Format
Definition: DWARFYAML.h:111
std::optional< yaml::Hex64 > Length
Definition: DWARFYAML.h:112
yaml::Hex64 TypeSignatureOrDwoID
Definition: DWARFYAML.h:118
std::optional< uint8_t > AddrSize
Definition: DWARFYAML.h:114
llvm::dwarf::UnitType Type
Definition: DWARFYAML.h:115
std::vector< Entry > Entries
Definition: DWARFYAML.h:121
std::optional< yaml::Hex64 > AbbrOffset
Definition: DWARFYAML.h:117