1 //===- DWARFYAML.h - DWARF YAMLIO implementation ----------------*- C++ -*-===//
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 /// \file
11 /// This file declares classes for handling the YAML representation
12 /// of DWARF Debug Info.
13 ///
14 //===----------------------------------------------------------------------===//
15 
16 #ifndef LLVM_OBJECTYAML_DWARFYAML_H
17 #define LLVM_OBJECTYAML_DWARFYAML_H
18 
19 #include "llvm/ADT/StringRef.h"
20 #include "llvm/BinaryFormat/Dwarf.h"
21 #include "llvm/Support/YAMLTraits.h"
22 #include <cstdint>
23 #include <vector>
24 
25 namespace llvm {
26 namespace DWARFYAML {
27 
28 struct InitialLength {
29   uint32_t TotalLength;
30   uint64_t TotalLength64;
31 
isDWARF64InitialLength32   bool isDWARF64() const { return TotalLength == UINT32_MAX; }
33 
getLengthInitialLength34   uint64_t getLength() const {
35     return isDWARF64() ? TotalLength64 : TotalLength;
36   }
37 
setLengthInitialLength38   void setLength(uint64_t Len) {
39     if (Len >= (uint64_t)UINT32_MAX) {
40       TotalLength64 = Len;
41       TotalLength = UINT32_MAX;
42     } else {
43       TotalLength = Len;
44     }
45   }
46 };
47 
48 struct AttributeAbbrev {
49   llvm::dwarf::Attribute Attribute;
50   llvm::dwarf::Form Form;
51   llvm::yaml::Hex64 Value; // Some DWARF5 attributes have values
52 };
53 
54 struct Abbrev {
55   llvm::yaml::Hex32 Code;
56   llvm::dwarf::Tag Tag;
57   llvm::dwarf::Constants Children;
58   std::vector<AttributeAbbrev> Attributes;
59 };
60 
61 struct ARangeDescriptor {
62   llvm::yaml::Hex64 Address;
63   uint64_t Length;
64 };
65 
66 struct ARange {
67   InitialLength Length;
68   uint16_t Version;
69   uint32_t CuOffset;
70   uint8_t AddrSize;
71   uint8_t SegSize;
72   std::vector<ARangeDescriptor> Descriptors;
73 };
74 
75 struct PubEntry {
76   llvm::yaml::Hex32 DieOffset;
77   llvm::yaml::Hex8 Descriptor;
78   StringRef Name;
79 };
80 
81 struct PubSection {
82   InitialLength Length;
83   uint16_t Version;
84   uint32_t UnitOffset;
85   uint32_t UnitSize;
86   bool IsGNUStyle = false;
87   std::vector<PubEntry> Entries;
88 };
89 
90 struct FormValue {
91   llvm::yaml::Hex64 Value;
92   StringRef CStr;
93   std::vector<llvm::yaml::Hex8> BlockData;
94 };
95 
96 struct Entry {
97   llvm::yaml::Hex32 AbbrCode;
98   std::vector<FormValue> Values;
99 };
100 
101 struct Unit {
102   InitialLength Length;
103   uint16_t Version;
104   llvm::dwarf::UnitType Type; // Added in DWARF 5
105   uint32_t AbbrOffset;
106   uint8_t AddrSize;
107   std::vector<Entry> Entries;
108 };
109 
110 struct File {
111   StringRef Name;
112   uint64_t DirIdx;
113   uint64_t ModTime;
114   uint64_t Length;
115 };
116 
117 struct LineTableOpcode {
118   dwarf::LineNumberOps Opcode;
119   uint64_t ExtLen;
120   dwarf::LineNumberExtendedOps SubOpcode;
121   uint64_t Data;
122   int64_t SData;
123   File FileEntry;
124   std::vector<llvm::yaml::Hex8> UnknownOpcodeData;
125   std::vector<llvm::yaml::Hex64> StandardOpcodeData;
126 };
127 
128 struct LineTable {
129   InitialLength Length;
130   uint16_t Version;
131   uint64_t PrologueLength;
132   uint8_t MinInstLength;
133   uint8_t MaxOpsPerInst;
134   uint8_t DefaultIsStmt;
135   uint8_t LineBase;
136   uint8_t LineRange;
137   uint8_t OpcodeBase;
138   std::vector<uint8_t> StandardOpcodeLengths;
139   std::vector<StringRef> IncludeDirs;
140   std::vector<File> Files;
141   std::vector<LineTableOpcode> Opcodes;
142 };
143 
144 struct Data {
145   bool IsLittleEndian;
146   std::vector<Abbrev> AbbrevDecls;
147   std::vector<StringRef> DebugStrings;
148   std::vector<ARange> ARanges;
149   PubSection PubNames;
150   PubSection PubTypes;
151 
152   PubSection GNUPubNames;
153   PubSection GNUPubTypes;
154 
155   std::vector<Unit> CompileUnits;
156 
157   std::vector<LineTable> DebugLines;
158 
159   bool isEmpty() const;
160 };
161 
162 } // end namespace DWARFYAML
163 } // end namespace llvm
164 
165 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::yaml::Hex64)
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::yaml::Hex8)166 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::yaml::Hex8)
167 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::AttributeAbbrev)
168 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Abbrev)
169 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::ARangeDescriptor)
170 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::ARange)
171 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::PubEntry)
172 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Unit)
173 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::FormValue)
174 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Entry)
175 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::File)
176 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::LineTable)
177 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::LineTableOpcode)
178 
179 namespace llvm {
180 namespace yaml {
181 
182 template <> struct MappingTraits<DWARFYAML::Data> {
183   static void mapping(IO &IO, DWARFYAML::Data &DWARF);
184 };
185 
186 template <> struct MappingTraits<DWARFYAML::Abbrev> {
187   static void mapping(IO &IO, DWARFYAML::Abbrev &Abbrev);
188 };
189 
190 template <> struct MappingTraits<DWARFYAML::AttributeAbbrev> {
191   static void mapping(IO &IO, DWARFYAML::AttributeAbbrev &AttAbbrev);
192 };
193 
194 template <> struct MappingTraits<DWARFYAML::ARangeDescriptor> {
195   static void mapping(IO &IO, DWARFYAML::ARangeDescriptor &Descriptor);
196 };
197 
198 template <> struct MappingTraits<DWARFYAML::ARange> {
199   static void mapping(IO &IO, DWARFYAML::ARange &Range);
200 };
201 
202 template <> struct MappingTraits<DWARFYAML::PubEntry> {
203   static void mapping(IO &IO, DWARFYAML::PubEntry &Entry);
204 };
205 
206 template <> struct MappingTraits<DWARFYAML::PubSection> {
207   static void mapping(IO &IO, DWARFYAML::PubSection &Section);
208 };
209 
210 template <> struct MappingTraits<DWARFYAML::Unit> {
211   static void mapping(IO &IO, DWARFYAML::Unit &Unit);
212 };
213 
214 template <> struct MappingTraits<DWARFYAML::Entry> {
215   static void mapping(IO &IO, DWARFYAML::Entry &Entry);
216 };
217 
218 template <> struct MappingTraits<DWARFYAML::FormValue> {
219   static void mapping(IO &IO, DWARFYAML::FormValue &FormValue);
220 };
221 
222 template <> struct MappingTraits<DWARFYAML::File> {
223   static void mapping(IO &IO, DWARFYAML::File &File);
224 };
225 
226 template <> struct MappingTraits<DWARFYAML::LineTableOpcode> {
227   static void mapping(IO &IO, DWARFYAML::LineTableOpcode &LineTableOpcode);
228 };
229 
230 template <> struct MappingTraits<DWARFYAML::LineTable> {
231   static void mapping(IO &IO, DWARFYAML::LineTable &LineTable);
232 };
233 
234 template <> struct MappingTraits<DWARFYAML::InitialLength> {
235   static void mapping(IO &IO, DWARFYAML::InitialLength &DWARF);
236 };
237 
238 #define HANDLE_DW_TAG(unused, name, unused2, unused3)                          \
239   io.enumCase(value, "DW_TAG_" #name, dwarf::DW_TAG_##name);
240 
241 template <> struct ScalarEnumerationTraits<dwarf::Tag> {
242   static void enumeration(IO &io, dwarf::Tag &value) {
243 #include "llvm/BinaryFormat/Dwarf.def"
244     io.enumFallback<Hex16>(value);
245   }
246 };
247 
248 #define HANDLE_DW_LNS(unused, name)                                            \
249   io.enumCase(value, "DW_LNS_" #name, dwarf::DW_LNS_##name);
250 
251 template <> struct ScalarEnumerationTraits<dwarf::LineNumberOps> {
252   static void enumeration(IO &io, dwarf::LineNumberOps &value) {
253 #include "llvm/BinaryFormat/Dwarf.def"
254     io.enumFallback<Hex8>(value);
255   }
256 };
257 
258 #define HANDLE_DW_LNE(unused, name)                                            \
259   io.enumCase(value, "DW_LNE_" #name, dwarf::DW_LNE_##name);
260 
261 template <> struct ScalarEnumerationTraits<dwarf::LineNumberExtendedOps> {
262   static void enumeration(IO &io, dwarf::LineNumberExtendedOps &value) {
263 #include "llvm/BinaryFormat/Dwarf.def"
264     io.enumFallback<Hex16>(value);
265   }
266 };
267 
268 #define HANDLE_DW_AT(unused, name, unused2, unused3)                           \
269   io.enumCase(value, "DW_AT_" #name, dwarf::DW_AT_##name);
270 
271 template <> struct ScalarEnumerationTraits<dwarf::Attribute> {
272   static void enumeration(IO &io, dwarf::Attribute &value) {
273 #include "llvm/BinaryFormat/Dwarf.def"
274     io.enumFallback<Hex16>(value);
275   }
276 };
277 
278 #define HANDLE_DW_FORM(unused, name, unused2, unused3)                         \
279   io.enumCase(value, "DW_FORM_" #name, dwarf::DW_FORM_##name);
280 
281 template <> struct ScalarEnumerationTraits<dwarf::Form> {
282   static void enumeration(IO &io, dwarf::Form &value) {
283 #include "llvm/BinaryFormat/Dwarf.def"
284     io.enumFallback<Hex16>(value);
285   }
286 };
287 
288 #define HANDLE_DW_UT(unused, name)                                             \
289   io.enumCase(value, "DW_UT_" #name, dwarf::DW_UT_##name);
290 
291 template <> struct ScalarEnumerationTraits<dwarf::UnitType> {
292   static void enumeration(IO &io, dwarf::UnitType &value) {
293 #include "llvm/BinaryFormat/Dwarf.def"
294     io.enumFallback<Hex8>(value);
295   }
296 };
297 
298 template <> struct ScalarEnumerationTraits<dwarf::Constants> {
299   static void enumeration(IO &io, dwarf::Constants &value) {
300     io.enumCase(value, "DW_CHILDREN_no", dwarf::DW_CHILDREN_no);
301     io.enumCase(value, "DW_CHILDREN_yes", dwarf::DW_CHILDREN_yes);
302     io.enumFallback<Hex16>(value);
303   }
304 };
305 
306 } // end namespace yaml
307 } // end namespace llvm
308 
309 #endif // LLVM_OBJECTYAML_DWARFYAML_H
310