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/// \brief 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
25namespace llvm {
26namespace DWARFYAML {
27
28struct InitialLength {
29  uint32_t TotalLength;
30  uint64_t TotalLength64;
31
32  bool isDWARF64() const { return TotalLength == UINT32_MAX; }
33
34  uint64_t getLength() const {
35    return isDWARF64() ? TotalLength64 : TotalLength;
36  }
37
38  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
48struct AttributeAbbrev {
49  llvm::dwarf::Attribute Attribute;
50  llvm::dwarf::Form Form;
51  llvm::yaml::Hex64 Value; // Some DWARF5 attributes have values
52};
53
54struct Abbrev {
55  llvm::yaml::Hex32 Code;
56  llvm::dwarf::Tag Tag;
57  llvm::dwarf::Constants Children;
58  std::vector<AttributeAbbrev> Attributes;
59};
60
61struct ARangeDescriptor {
62  llvm::yaml::Hex64 Address;
63  uint64_t Length;
64};
65
66struct 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
75struct PubEntry {
76  llvm::yaml::Hex32 DieOffset;
77  llvm::yaml::Hex8 Descriptor;
78  StringRef Name;
79};
80
81struct 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
90struct FormValue {
91  llvm::yaml::Hex64 Value;
92  StringRef CStr;
93  std::vector<llvm::yaml::Hex8> BlockData;
94};
95
96struct Entry {
97  llvm::yaml::Hex32 AbbrCode;
98  std::vector<FormValue> Values;
99};
100
101struct 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
110struct File {
111  StringRef Name;
112  uint64_t DirIdx;
113  uint64_t ModTime;
114  uint64_t Length;
115};
116
117struct 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
128struct 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
144struct 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
165LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::yaml::Hex64)
166LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::yaml::Hex8)
167LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::AttributeAbbrev)
168LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Abbrev)
169LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::ARangeDescriptor)
170LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::ARange)
171LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::PubEntry)
172LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Unit)
173LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::FormValue)
174LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Entry)
175LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::File)
176LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::LineTable)
177LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::LineTableOpcode)
178
179namespace llvm {
180namespace yaml {
181
182template <> struct MappingTraits<DWARFYAML::Data> {
183  static void mapping(IO &IO, DWARFYAML::Data &DWARF);
184};
185
186template <> struct MappingTraits<DWARFYAML::Abbrev> {
187  static void mapping(IO &IO, DWARFYAML::Abbrev &Abbrev);
188};
189
190template <> struct MappingTraits<DWARFYAML::AttributeAbbrev> {
191  static void mapping(IO &IO, DWARFYAML::AttributeAbbrev &AttAbbrev);
192};
193
194template <> struct MappingTraits<DWARFYAML::ARangeDescriptor> {
195  static void mapping(IO &IO, DWARFYAML::ARangeDescriptor &Descriptor);
196};
197
198template <> struct MappingTraits<DWARFYAML::ARange> {
199  static void mapping(IO &IO, DWARFYAML::ARange &Range);
200};
201
202template <> struct MappingTraits<DWARFYAML::PubEntry> {
203  static void mapping(IO &IO, DWARFYAML::PubEntry &Entry);
204};
205
206template <> struct MappingTraits<DWARFYAML::PubSection> {
207  static void mapping(IO &IO, DWARFYAML::PubSection &Section);
208};
209
210template <> struct MappingTraits<DWARFYAML::Unit> {
211  static void mapping(IO &IO, DWARFYAML::Unit &Unit);
212};
213
214template <> struct MappingTraits<DWARFYAML::Entry> {
215  static void mapping(IO &IO, DWARFYAML::Entry &Entry);
216};
217
218template <> struct MappingTraits<DWARFYAML::FormValue> {
219  static void mapping(IO &IO, DWARFYAML::FormValue &FormValue);
220};
221
222template <> struct MappingTraits<DWARFYAML::File> {
223  static void mapping(IO &IO, DWARFYAML::File &File);
224};
225
226template <> struct MappingTraits<DWARFYAML::LineTableOpcode> {
227  static void mapping(IO &IO, DWARFYAML::LineTableOpcode &LineTableOpcode);
228};
229
230template <> struct MappingTraits<DWARFYAML::LineTable> {
231  static void mapping(IO &IO, DWARFYAML::LineTable &LineTable);
232};
233
234template <> 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
241template <> 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
251template <> 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
261template <> 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
271template <> 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
281template <> 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
291template <> 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
298template <> 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