LLVM  4.0.0
DWARFYAML.h
Go to the documentation of this file.
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 
17 #ifndef LLVM_OBJECTYAML_DWARFYAML_H
18 #define LLVM_OBJECTYAML_DWARFYAML_H
19 
20 #include "llvm/ObjectYAML/YAML.h"
21 #include "llvm/Support/Dwarf.h"
22 
23 namespace llvm {
24 namespace DWARFYAML {
25 
29 };
30 
31 struct Abbrev {
32  llvm::yaml::Hex32 Code;
35  std::vector<AttributeAbbrev> Attributes;
36 };
37 
39  llvm::yaml::Hex64 Address;
40  uint64_t Length;
41 };
42 
43 struct ARange {
45  uint16_t Version;
47  uint8_t AddrSize;
48  uint8_t SegSize;
49  std::vector<ARangeDescriptor> Descriptors;
50 };
51 
52 struct PubEntry {
53  llvm::yaml::Hex32 DieOffset;
54  llvm::yaml::Hex8 Descriptor;
56 };
57 
58 struct PubSection {
60 
62  uint16_t Version;
65  bool IsGNUStyle;
66  std::vector<PubEntry> Entries;
67 };
68 
69 struct FormValue {
70  llvm::yaml::Hex64 Value;
72  std::vector<llvm::yaml::Hex8> BlockData;
73 };
74 
75 struct Entry {
76  llvm::yaml::Hex32 AbbrCode;
77  std::vector<FormValue> Values;
78 };
79 
80 struct Unit {
82  uint16_t Version;
84  uint8_t AddrSize;
85  std::vector<Entry> Entries;
86 };
87 
88 struct File {
90  uint64_t DirIdx;
91  uint64_t ModTime;
92  uint64_t Length;
93 };
94 
97  uint64_t ExtLen;
99  uint64_t Data;
100  int64_t SData;
102  std::vector<llvm::yaml::Hex8> UnknownOpcodeData;
103  std::vector<llvm::yaml::Hex64> StandardOpcodeData;
104 };
105 
106 struct LineTable {
108  uint64_t TotalLength64;
109  uint16_t Version;
110  uint64_t PrologueLength;
111  uint8_t MinInstLength;
112  uint8_t MaxOpsPerInst;
113  uint8_t DefaultIsStmt;
114  uint8_t LineBase;
115  uint8_t LineRange;
116  uint8_t OpcodeBase;
117  std::vector<uint8_t> StandardOpcodeLengths;
118  std::vector<StringRef> IncludeDirs;
119  std::vector<File> Files;
120  std::vector<LineTableOpcode> Opcodes;
121 };
122 
123 struct Data {
125  std::vector<Abbrev> AbbrevDecls;
126  std::vector<StringRef> DebugStrings;
127  std::vector<ARange> ARanges;
130 
133 
134  std::vector<Unit> CompileUnits;
135 
136  std::vector<LineTable> DebugLines;
137 
138  bool isEmpty() const;
139 };
140 
141 } // namespace llvm::DWARFYAML
142 } // namespace llvm
143 
145 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::yaml::Hex64)
146 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::StringRef)
147 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::yaml::Hex8)
148 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::AttributeAbbrev)
149 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Abbrev)
150 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::ARangeDescriptor)
151 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::ARange)
152 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::PubEntry)
153 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Unit)
154 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::FormValue)
155 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Entry)
156 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::File)
157 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::LineTable)
158 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::LineTableOpcode)
159 
160 namespace llvm {
161 namespace yaml {
162 
163 template <> struct MappingTraits<DWARFYAML::Data> {
164  static void mapping(IO &IO, DWARFYAML::Data &DWARF);
165 };
166 
167 template <> struct MappingTraits<DWARFYAML::Abbrev> {
168  static void mapping(IO &IO, DWARFYAML::Abbrev &Abbrev);
169 };
170 
171 template <> struct MappingTraits<DWARFYAML::AttributeAbbrev> {
172  static void mapping(IO &IO, DWARFYAML::AttributeAbbrev &AttAbbrev);
173 };
174 
175 template <> struct MappingTraits<DWARFYAML::ARangeDescriptor> {
176  static void mapping(IO &IO, DWARFYAML::ARangeDescriptor &Descriptor);
177 };
178 
179 template <> struct MappingTraits<DWARFYAML::ARange> {
180  static void mapping(IO &IO, DWARFYAML::ARange &Range);
181 };
182 
183 template <> struct MappingTraits<DWARFYAML::PubEntry> {
184  static void mapping(IO &IO, DWARFYAML::PubEntry &Entry);
185 };
186 
187 template <> struct MappingTraits<DWARFYAML::PubSection> {
188  static void mapping(IO &IO, DWARFYAML::PubSection &Section);
189 };
190 
191 template <> struct MappingTraits<DWARFYAML::Unit> {
192  static void mapping(IO &IO, DWARFYAML::Unit &Unit);
193 };
194 
195 template <> struct MappingTraits<DWARFYAML::Entry> {
196  static void mapping(IO &IO, DWARFYAML::Entry &Entry);
197 };
198 
199 template <> struct MappingTraits<DWARFYAML::FormValue> {
200  static void mapping(IO &IO, DWARFYAML::FormValue &FormValue);
201 };
202 
203 template <> struct MappingTraits<DWARFYAML::File> {
204  static void mapping(IO &IO, DWARFYAML::File &File);
205 };
206 
207 template <> struct MappingTraits<DWARFYAML::LineTableOpcode> {
208  static void mapping(IO &IO, DWARFYAML::LineTableOpcode &LineTableOpcode);
209 };
210 
211 template <> struct MappingTraits<DWARFYAML::LineTable> {
212  static void mapping(IO &IO, DWARFYAML::LineTable &LineTable);
213 };
214 
215 #define HANDLE_DW_TAG(unused, name) \
216  io.enumCase(value, "DW_TAG_" #name, dwarf::DW_TAG_##name);
217 
218 template <> struct ScalarEnumerationTraits<dwarf::Tag> {
219  static void enumeration(IO &io, dwarf::Tag &value) {
220 #include "llvm/Support/Dwarf.def"
221  io.enumFallback<Hex16>(value);
222  }
223 };
224 
225 #define HANDLE_DW_LNS(unused, name) \
226  io.enumCase(value, "DW_LNS_" #name, dwarf::DW_LNS_##name);
227 
228 template <> struct ScalarEnumerationTraits<dwarf::LineNumberOps> {
229  static void enumeration(IO &io, dwarf::LineNumberOps &value) {
230 #include "llvm/Support/Dwarf.def"
231  io.enumFallback<Hex8>(value);
232  }
233 };
234 
235 #define HANDLE_DW_LNE(unused, name) \
236  io.enumCase(value, "DW_LNE_" #name, dwarf::DW_LNE_##name);
237 
238 template <> struct ScalarEnumerationTraits<dwarf::LineNumberExtendedOps> {
239  static void enumeration(IO &io, dwarf::LineNumberExtendedOps &value) {
240 #include "llvm/Support/Dwarf.def"
241  io.enumFallback<Hex16>(value);
242  }
243 };
244 
245 #define HANDLE_DW_AT(unused, name) \
246  io.enumCase(value, "DW_AT_" #name, dwarf::DW_AT_##name);
247 
248 template <> struct ScalarEnumerationTraits<dwarf::Attribute> {
249  static void enumeration(IO &io, dwarf::Attribute &value) {
250 #include "llvm/Support/Dwarf.def"
251  io.enumFallback<Hex16>(value);
252  }
253 };
254 
255 #define HANDLE_DW_FORM(unused, name) \
256  io.enumCase(value, "DW_FORM_" #name, dwarf::DW_FORM_##name);
257 
258 template <> struct ScalarEnumerationTraits<dwarf::Form> {
259  static void enumeration(IO &io, dwarf::Form &value) {
260 #include "llvm/Support/Dwarf.def"
261  io.enumFallback<Hex16>(value);
262  }
263 };
264 
265 template <> struct ScalarEnumerationTraits<dwarf::Constants> {
266  static void enumeration(IO &io, dwarf::Constants &value) {
267  io.enumCase(value, "DW_CHILDREN_no", dwarf::DW_CHILDREN_no);
268  io.enumCase(value, "DW_CHILDREN_yes", dwarf::DW_CHILDREN_yes);
269  io.enumFallback<Hex16>(value);
270  }
271 };
272 
273 } // namespace llvm::yaml
274 } // namespace llvm
275 
276 #endif
llvm::dwarf::Constants Children
Definition: DWARFYAML.h:34
PubSection PubNames
Definition: DWARFYAML.h:128
std::vector< AttributeAbbrev > Attributes
Definition: DWARFYAML.h:35
LineNumberOps
Line Number Standard Opcode Encodings.
Definition: Dwarf.h:210
dwarf::LineNumberExtendedOps SubOpcode
Definition: DWARFYAML.h:98
dwarf::LineNumberOps Opcode
Definition: DWARFYAML.h:96
Attribute
Attributes.
Definition: Dwarf.h:94
static void enumeration(IO &io, dwarf::LineNumberOps &value)
Definition: DWARFYAML.h:229
std::vector< Abbrev > AbbrevDecls
Definition: DWARFYAML.h:125
static void enumeration(IO &io, dwarf::LineNumberExtendedOps &value)
Definition: DWARFYAML.h:239
#define LLVM_YAML_IS_SEQUENCE_VECTOR(_type)
Utility for declaring that a std::vector of a particular type should be considered a YAML sequence...
Definition: YAMLTraits.h:1565
std::vector< uint8_t > StandardOpcodeLengths
Definition: DWARFYAML.h:117
std::vector< PubEntry > Entries
Definition: DWARFYAML.h:66
std::vector< ARangeDescriptor > Descriptors
Definition: DWARFYAML.h:49
static void enumeration(IO &io, dwarf::Form &value)
Definition: DWARFYAML.h:259
void enumFallback(T &Val)
Definition: YAMLTraits.h:596
PubSection GNUPubNames
Definition: DWARFYAML.h:131
std::vector< ARange > ARanges
Definition: DWARFYAML.h:127
This class should be specialized by any type that needs to be converted to/from a YAML mapping...
Function Alias Analysis false
std::vector< Unit > CompileUnits
Definition: DWARFYAML.h:134
std::vector< llvm::yaml::Hex8 > BlockData
Definition: DWARFYAML.h:72
llvm::yaml::Hex32 Code
Definition: DWARFYAML.h:32
void enumCase(T &Val, const char *Str, const T ConstVal)
Definition: YAMLTraits.h:581
std::vector< File > Files
Definition: DWARFYAML.h:119
llvm::yaml::Hex32 DieOffset
Definition: DWARFYAML.h:53
std::vector< LineTable > DebugLines
Definition: DWARFYAML.h:136
static void enumeration(IO &io, dwarf::Tag &value)
Definition: DWARFYAML.h:219
std::vector< StringRef > IncludeDirs
Definition: DWARFYAML.h:118
std::vector< Entry > Entries
Definition: DWARFYAML.h:85
llvm::yaml::Hex64 Value
Definition: DWARFYAML.h:70
std::vector< FormValue > Values
Definition: DWARFYAML.h:77
llvm::yaml::Hex8 Descriptor
Definition: DWARFYAML.h:54
LineNumberExtendedOps
Line Number Extended Opcode Encodings.
Definition: Dwarf.h:216
llvm::dwarf::Attribute Attribute
Definition: DWARFYAML.h:27
This class should be specialized by any integral type that converts to/from a YAML scalar where there...
Definition: YAMLTraits.h:97
PubSection PubTypes
Definition: DWARFYAML.h:129
std::vector< StringRef > DebugStrings
Definition: DWARFYAML.h:126
llvm::yaml::Hex32 AbbrCode
Definition: DWARFYAML.h:76
PubSection GNUPubTypes
Definition: DWARFYAML.h:132
std::vector< llvm::yaml::Hex8 > UnknownOpcodeData
Definition: DWARFYAML.h:102
bool isEmpty() const
Definition: DWARFYAML.cpp:19
static void enumeration(IO &io, dwarf::Attribute &value)
Definition: DWARFYAML.h:249
std::vector< llvm::yaml::Hex64 > StandardOpcodeData
Definition: DWARFYAML.h:103
std::vector< LineTableOpcode > Opcodes
Definition: DWARFYAML.h:120
std::vector< uint8_t > Unit
Definition: FuzzerDefs.h:71
llvm::dwarf::Tag Tag
Definition: DWARFYAML.h:33
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:47
static void enumeration(IO &io, dwarf::Constants &value)
Definition: DWARFYAML.h:266