Details | Last modification | View Log | RSS feed
| Rev | Author | Line No. | Line |
|---|---|---|---|
| 14 | pmbaty | 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" |
||
| 20 | #include "llvm/BinaryFormat/Dwarf.h" |
||
| 21 | #include "llvm/ObjectYAML/YAML.h" |
||
| 22 | #include "llvm/Support/YAMLTraits.h" |
||
| 23 | #include <cstdint> |
||
| 24 | #include <optional> |
||
| 25 | #include <unordered_map> |
||
| 26 | #include <vector> |
||
| 27 | |||
| 28 | namespace llvm { |
||
| 29 | namespace DWARFYAML { |
||
| 30 | |||
| 31 | struct AttributeAbbrev { |
||
| 32 | llvm::dwarf::Attribute Attribute; |
||
| 33 | llvm::dwarf::Form Form; |
||
| 34 | llvm::yaml::Hex64 Value; // Some DWARF5 attributes have values |
||
| 35 | }; |
||
| 36 | |||
| 37 | struct Abbrev { |
||
| 38 | std::optional<yaml::Hex64> Code; |
||
| 39 | llvm::dwarf::Tag Tag; |
||
| 40 | llvm::dwarf::Constants Children; |
||
| 41 | std::vector<AttributeAbbrev> Attributes; |
||
| 42 | }; |
||
| 43 | |||
| 44 | struct AbbrevTable { |
||
| 45 | std::optional<uint64_t> ID; |
||
| 46 | std::vector<Abbrev> Table; |
||
| 47 | }; |
||
| 48 | |||
| 49 | struct ARangeDescriptor { |
||
| 50 | llvm::yaml::Hex64 Address; |
||
| 51 | yaml::Hex64 Length; |
||
| 52 | }; |
||
| 53 | |||
| 54 | struct ARange { |
||
| 55 | dwarf::DwarfFormat Format; |
||
| 56 | std::optional<yaml::Hex64> Length; |
||
| 57 | uint16_t Version; |
||
| 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. |
||
| 66 | struct 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. |
||
| 72 | struct Ranges { |
||
| 73 | std::optional<llvm::yaml::Hex64> Offset; |
||
| 74 | std::optional<llvm::yaml::Hex8> AddrSize; |
||
| 75 | std::vector<RangeEntry> Entries; |
||
| 76 | }; |
||
| 77 | |||
| 78 | struct PubEntry { |
||
| 79 | llvm::yaml::Hex32 DieOffset; |
||
| 80 | llvm::yaml::Hex8 Descriptor; |
||
| 81 | StringRef Name; |
||
| 82 | }; |
||
| 83 | |||
| 84 | struct PubSection { |
||
| 85 | dwarf::DwarfFormat Format; |
||
| 86 | yaml::Hex64 Length; |
||
| 87 | uint16_t Version; |
||
| 88 | uint32_t UnitOffset; |
||
| 89 | uint32_t UnitSize; |
||
| 90 | std::vector<PubEntry> Entries; |
||
| 91 | }; |
||
| 92 | |||
| 93 | struct FormValue { |
||
| 94 | llvm::yaml::Hex64 Value; |
||
| 95 | StringRef CStr; |
||
| 96 | std::vector<llvm::yaml::Hex8> BlockData; |
||
| 97 | }; |
||
| 98 | |||
| 99 | struct 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. |
||
| 106 | struct DWARFContext { |
||
| 107 | bool IsGNUPubSec = false; |
||
| 108 | }; |
||
| 109 | |||
| 110 | struct Unit { |
||
| 111 | dwarf::DwarfFormat Format; |
||
| 112 | std::optional<yaml::Hex64> Length; |
||
| 113 | uint16_t Version; |
||
| 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 | std::vector<Entry> Entries; |
||
| 119 | }; |
||
| 120 | |||
| 121 | struct File { |
||
| 122 | StringRef Name; |
||
| 123 | uint64_t DirIdx; |
||
| 124 | uint64_t ModTime; |
||
| 125 | uint64_t Length; |
||
| 126 | }; |
||
| 127 | |||
| 128 | struct LineTableOpcode { |
||
| 129 | dwarf::LineNumberOps Opcode; |
||
| 130 | std::optional<uint64_t> ExtLen; |
||
| 131 | dwarf::LineNumberExtendedOps SubOpcode; |
||
| 132 | uint64_t Data; |
||
| 133 | int64_t SData; |
||
| 134 | File FileEntry; |
||
| 135 | std::vector<llvm::yaml::Hex8> UnknownOpcodeData; |
||
| 136 | std::vector<llvm::yaml::Hex64> StandardOpcodeData; |
||
| 137 | }; |
||
| 138 | |||
| 139 | struct LineTable { |
||
| 140 | dwarf::DwarfFormat Format; |
||
| 141 | std::optional<uint64_t> Length; |
||
| 142 | uint16_t Version; |
||
| 143 | std::optional<uint64_t> PrologueLength; |
||
| 144 | uint8_t MinInstLength; |
||
| 145 | uint8_t MaxOpsPerInst; |
||
| 146 | uint8_t DefaultIsStmt; |
||
| 147 | uint8_t LineBase; |
||
| 148 | uint8_t LineRange; |
||
| 149 | std::optional<uint8_t> OpcodeBase; |
||
| 150 | std::optional<std::vector<uint8_t>> StandardOpcodeLengths; |
||
| 151 | std::vector<StringRef> IncludeDirs; |
||
| 152 | std::vector<File> Files; |
||
| 153 | std::vector<LineTableOpcode> Opcodes; |
||
| 154 | }; |
||
| 155 | |||
| 156 | struct SegAddrPair { |
||
| 157 | yaml::Hex64 Segment; |
||
| 158 | yaml::Hex64 Address; |
||
| 159 | }; |
||
| 160 | |||
| 161 | struct AddrTableEntry { |
||
| 162 | dwarf::DwarfFormat Format; |
||
| 163 | std::optional<yaml::Hex64> Length; |
||
| 164 | yaml::Hex16 Version; |
||
| 165 | std::optional<yaml::Hex8> AddrSize; |
||
| 166 | yaml::Hex8 SegSelectorSize; |
||
| 167 | std::vector<SegAddrPair> SegAddrPairs; |
||
| 168 | }; |
||
| 169 | |||
| 170 | struct StringOffsetsTable { |
||
| 171 | dwarf::DwarfFormat Format; |
||
| 172 | std::optional<yaml::Hex64> Length; |
||
| 173 | yaml::Hex16 Version; |
||
| 174 | yaml::Hex16 Padding; |
||
| 175 | std::vector<yaml::Hex64> Offsets; |
||
| 176 | }; |
||
| 177 | |||
| 178 | struct DWARFOperation { |
||
| 179 | dwarf::LocationAtom Operator; |
||
| 180 | std::vector<yaml::Hex64> Values; |
||
| 181 | }; |
||
| 182 | |||
| 183 | struct RnglistEntry { |
||
| 184 | dwarf::RnglistEntries Operator; |
||
| 185 | std::vector<yaml::Hex64> Values; |
||
| 186 | }; |
||
| 187 | |||
| 188 | struct LoclistEntry { |
||
| 189 | dwarf::LoclistEntries Operator; |
||
| 190 | std::vector<yaml::Hex64> Values; |
||
| 191 | std::optional<yaml::Hex64> DescriptionsLength; |
||
| 192 | std::vector<DWARFOperation> Descriptions; |
||
| 193 | }; |
||
| 194 | |||
| 195 | template <typename EntryType> struct ListEntries { |
||
| 196 | std::optional<std::vector<EntryType>> Entries; |
||
| 197 | std::optional<yaml::BinaryRef> Content; |
||
| 198 | }; |
||
| 199 | |||
| 200 | template <typename EntryType> struct ListTable { |
||
| 201 | dwarf::DwarfFormat Format; |
||
| 202 | std::optional<yaml::Hex64> Length; |
||
| 203 | yaml::Hex16 Version; |
||
| 204 | std::optional<yaml::Hex8> AddrSize; |
||
| 205 | yaml::Hex8 SegSelectorSize; |
||
| 206 | std::optional<uint32_t> OffsetEntryCount; |
||
| 207 | std::optional<std::vector<yaml::Hex64>> Offsets; |
||
| 208 | std::vector<ListEntries<EntryType>> Lists; |
||
| 209 | }; |
||
| 210 | |||
| 211 | struct Data { |
||
| 212 | bool IsLittleEndian; |
||
| 213 | bool Is64BitAddrSize; |
||
| 214 | std::vector<AbbrevTable> DebugAbbrev; |
||
| 215 | std::optional<std::vector<StringRef>> DebugStrings; |
||
| 216 | std::optional<std::vector<StringOffsetsTable>> DebugStrOffsets; |
||
| 217 | std::optional<std::vector<ARange>> DebugAranges; |
||
| 218 | std::optional<std::vector<Ranges>> DebugRanges; |
||
| 219 | std::optional<std::vector<AddrTableEntry>> DebugAddr; |
||
| 220 | std::optional<PubSection> PubNames; |
||
| 221 | std::optional<PubSection> PubTypes; |
||
| 222 | |||
| 223 | std::optional<PubSection> GNUPubNames; |
||
| 224 | std::optional<PubSection> GNUPubTypes; |
||
| 225 | |||
| 226 | std::vector<Unit> CompileUnits; |
||
| 227 | |||
| 228 | std::vector<LineTable> DebugLines; |
||
| 229 | std::optional<std::vector<ListTable<RnglistEntry>>> DebugRnglists; |
||
| 230 | std::optional<std::vector<ListTable<LoclistEntry>>> DebugLoclists; |
||
| 231 | |||
| 232 | bool isEmpty() const; |
||
| 233 | |||
| 234 | SetVector<StringRef> getNonEmptySectionNames() const; |
||
| 235 | |||
| 236 | struct AbbrevTableInfo { |
||
| 237 | uint64_t Index; |
||
| 238 | uint64_t Offset; |
||
| 239 | }; |
||
| 240 | Expected<AbbrevTableInfo> getAbbrevTableInfoByID(uint64_t ID) const; |
||
| 241 | StringRef getAbbrevTableContentByIndex(uint64_t Index) const; |
||
| 242 | |||
| 243 | private: |
||
| 244 | mutable std::unordered_map<uint64_t, AbbrevTableInfo> AbbrevTableInfoMap; |
||
| 245 | mutable std::unordered_map<uint64_t, std::string> AbbrevTableContents; |
||
| 246 | }; |
||
| 247 | |||
| 248 | } // end namespace DWARFYAML |
||
| 249 | } // end namespace llvm |
||
| 250 | |||
| 251 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::AttributeAbbrev) |
||
| 252 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Abbrev) |
||
| 253 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::AbbrevTable) |
||
| 254 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::ARangeDescriptor) |
||
| 255 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::ARange) |
||
| 256 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::RangeEntry) |
||
| 257 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Ranges) |
||
| 258 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::PubEntry) |
||
| 259 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Unit) |
||
| 260 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::FormValue) |
||
| 261 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Entry) |
||
| 262 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::File) |
||
| 263 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::LineTable) |
||
| 264 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::LineTableOpcode) |
||
| 265 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::SegAddrPair) |
||
| 266 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::AddrTableEntry) |
||
| 267 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::StringOffsetsTable) |
||
| 268 | LLVM_YAML_IS_SEQUENCE_VECTOR( |
||
| 269 | llvm::DWARFYAML::ListTable<DWARFYAML::RnglistEntry>) |
||
| 270 | LLVM_YAML_IS_SEQUENCE_VECTOR( |
||
| 271 | llvm::DWARFYAML::ListEntries<DWARFYAML::RnglistEntry>) |
||
| 272 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::RnglistEntry) |
||
| 273 | LLVM_YAML_IS_SEQUENCE_VECTOR( |
||
| 274 | llvm::DWARFYAML::ListTable<DWARFYAML::LoclistEntry>) |
||
| 275 | LLVM_YAML_IS_SEQUENCE_VECTOR( |
||
| 276 | llvm::DWARFYAML::ListEntries<DWARFYAML::LoclistEntry>) |
||
| 277 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::LoclistEntry) |
||
| 278 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::DWARFOperation) |
||
| 279 | |||
| 280 | namespace llvm { |
||
| 281 | namespace yaml { |
||
| 282 | |||
| 283 | template <> struct MappingTraits<DWARFYAML::Data> { |
||
| 284 | static void mapping(IO &IO, DWARFYAML::Data &DWARF); |
||
| 285 | }; |
||
| 286 | |||
| 287 | template <> struct MappingTraits<DWARFYAML::AbbrevTable> { |
||
| 288 | static void mapping(IO &IO, DWARFYAML::AbbrevTable &AbbrevTable); |
||
| 289 | }; |
||
| 290 | |||
| 291 | template <> struct MappingTraits<DWARFYAML::Abbrev> { |
||
| 292 | static void mapping(IO &IO, DWARFYAML::Abbrev &Abbrev); |
||
| 293 | }; |
||
| 294 | |||
| 295 | template <> struct MappingTraits<DWARFYAML::AttributeAbbrev> { |
||
| 296 | static void mapping(IO &IO, DWARFYAML::AttributeAbbrev &AttAbbrev); |
||
| 297 | }; |
||
| 298 | |||
| 299 | template <> struct MappingTraits<DWARFYAML::ARangeDescriptor> { |
||
| 300 | static void mapping(IO &IO, DWARFYAML::ARangeDescriptor &Descriptor); |
||
| 301 | }; |
||
| 302 | |||
| 303 | template <> struct MappingTraits<DWARFYAML::ARange> { |
||
| 304 | static void mapping(IO &IO, DWARFYAML::ARange &ARange); |
||
| 305 | }; |
||
| 306 | |||
| 307 | template <> struct MappingTraits<DWARFYAML::RangeEntry> { |
||
| 308 | static void mapping(IO &IO, DWARFYAML::RangeEntry &Entry); |
||
| 309 | }; |
||
| 310 | |||
| 311 | template <> struct MappingTraits<DWARFYAML::Ranges> { |
||
| 312 | static void mapping(IO &IO, DWARFYAML::Ranges &Ranges); |
||
| 313 | }; |
||
| 314 | |||
| 315 | template <> struct MappingTraits<DWARFYAML::PubEntry> { |
||
| 316 | static void mapping(IO &IO, DWARFYAML::PubEntry &Entry); |
||
| 317 | }; |
||
| 318 | |||
| 319 | template <> struct MappingTraits<DWARFYAML::PubSection> { |
||
| 320 | static void mapping(IO &IO, DWARFYAML::PubSection &Section); |
||
| 321 | }; |
||
| 322 | |||
| 323 | template <> struct MappingTraits<DWARFYAML::Unit> { |
||
| 324 | static void mapping(IO &IO, DWARFYAML::Unit &Unit); |
||
| 325 | }; |
||
| 326 | |||
| 327 | template <> struct MappingTraits<DWARFYAML::Entry> { |
||
| 328 | static void mapping(IO &IO, DWARFYAML::Entry &Entry); |
||
| 329 | }; |
||
| 330 | |||
| 331 | template <> struct MappingTraits<DWARFYAML::FormValue> { |
||
| 332 | static void mapping(IO &IO, DWARFYAML::FormValue &FormValue); |
||
| 333 | }; |
||
| 334 | |||
| 335 | template <> struct MappingTraits<DWARFYAML::File> { |
||
| 336 | static void mapping(IO &IO, DWARFYAML::File &File); |
||
| 337 | }; |
||
| 338 | |||
| 339 | template <> struct MappingTraits<DWARFYAML::LineTableOpcode> { |
||
| 340 | static void mapping(IO &IO, DWARFYAML::LineTableOpcode &LineTableOpcode); |
||
| 341 | }; |
||
| 342 | |||
| 343 | template <> struct MappingTraits<DWARFYAML::LineTable> { |
||
| 344 | static void mapping(IO &IO, DWARFYAML::LineTable &LineTable); |
||
| 345 | }; |
||
| 346 | |||
| 347 | template <> struct MappingTraits<DWARFYAML::SegAddrPair> { |
||
| 348 | static void mapping(IO &IO, DWARFYAML::SegAddrPair &SegAddrPair); |
||
| 349 | }; |
||
| 350 | |||
| 351 | template <> struct MappingTraits<DWARFYAML::DWARFOperation> { |
||
| 352 | static void mapping(IO &IO, DWARFYAML::DWARFOperation &DWARFOperation); |
||
| 353 | }; |
||
| 354 | |||
| 355 | template <typename EntryType> |
||
| 356 | struct MappingTraits<DWARFYAML::ListTable<EntryType>> { |
||
| 357 | static void mapping(IO &IO, DWARFYAML::ListTable<EntryType> &ListTable); |
||
| 358 | }; |
||
| 359 | |||
| 360 | template <typename EntryType> |
||
| 361 | struct MappingTraits<DWARFYAML::ListEntries<EntryType>> { |
||
| 362 | static void mapping(IO &IO, DWARFYAML::ListEntries<EntryType> &ListEntries); |
||
| 363 | static std::string validate(IO &IO, |
||
| 364 | DWARFYAML::ListEntries<EntryType> &ListEntries); |
||
| 365 | }; |
||
| 366 | |||
| 367 | template <> struct MappingTraits<DWARFYAML::RnglistEntry> { |
||
| 368 | static void mapping(IO &IO, DWARFYAML::RnglistEntry &RnglistEntry); |
||
| 369 | }; |
||
| 370 | |||
| 371 | template <> struct MappingTraits<DWARFYAML::LoclistEntry> { |
||
| 372 | static void mapping(IO &IO, DWARFYAML::LoclistEntry &LoclistEntry); |
||
| 373 | }; |
||
| 374 | |||
| 375 | template <> struct MappingTraits<DWARFYAML::AddrTableEntry> { |
||
| 376 | static void mapping(IO &IO, DWARFYAML::AddrTableEntry &AddrTable); |
||
| 377 | }; |
||
| 378 | |||
| 379 | template <> struct MappingTraits<DWARFYAML::StringOffsetsTable> { |
||
| 380 | static void mapping(IO &IO, DWARFYAML::StringOffsetsTable &StrOffsetsTable); |
||
| 381 | }; |
||
| 382 | |||
| 383 | template <> struct ScalarEnumerationTraits<dwarf::DwarfFormat> { |
||
| 384 | static void enumeration(IO &IO, dwarf::DwarfFormat &Format) { |
||
| 385 | IO.enumCase(Format, "DWARF32", dwarf::DWARF32); |
||
| 386 | IO.enumCase(Format, "DWARF64", dwarf::DWARF64); |
||
| 387 | } |
||
| 388 | }; |
||
| 389 | |||
| 390 | #define HANDLE_DW_TAG(unused, name, unused2, unused3, unused4) \ |
||
| 391 | io.enumCase(value, "DW_TAG_" #name, dwarf::DW_TAG_##name); |
||
| 392 | |||
| 393 | template <> struct ScalarEnumerationTraits<dwarf::Tag> { |
||
| 394 | static void enumeration(IO &io, dwarf::Tag &value) { |
||
| 395 | #include "llvm/BinaryFormat/Dwarf.def" |
||
| 396 | io.enumFallback<Hex16>(value); |
||
| 397 | } |
||
| 398 | }; |
||
| 399 | |||
| 400 | #define HANDLE_DW_LNS(unused, name) \ |
||
| 401 | io.enumCase(value, "DW_LNS_" #name, dwarf::DW_LNS_##name); |
||
| 402 | |||
| 403 | template <> struct ScalarEnumerationTraits<dwarf::LineNumberOps> { |
||
| 404 | static void enumeration(IO &io, dwarf::LineNumberOps &value) { |
||
| 405 | #include "llvm/BinaryFormat/Dwarf.def" |
||
| 406 | io.enumFallback<Hex8>(value); |
||
| 407 | } |
||
| 408 | }; |
||
| 409 | |||
| 410 | #define HANDLE_DW_LNE(unused, name) \ |
||
| 411 | io.enumCase(value, "DW_LNE_" #name, dwarf::DW_LNE_##name); |
||
| 412 | |||
| 413 | template <> struct ScalarEnumerationTraits<dwarf::LineNumberExtendedOps> { |
||
| 414 | static void enumeration(IO &io, dwarf::LineNumberExtendedOps &value) { |
||
| 415 | #include "llvm/BinaryFormat/Dwarf.def" |
||
| 416 | io.enumFallback<Hex16>(value); |
||
| 417 | } |
||
| 418 | }; |
||
| 419 | |||
| 420 | #define HANDLE_DW_AT(unused, name, unused2, unused3) \ |
||
| 421 | io.enumCase(value, "DW_AT_" #name, dwarf::DW_AT_##name); |
||
| 422 | |||
| 423 | template <> struct ScalarEnumerationTraits<dwarf::Attribute> { |
||
| 424 | static void enumeration(IO &io, dwarf::Attribute &value) { |
||
| 425 | #include "llvm/BinaryFormat/Dwarf.def" |
||
| 426 | io.enumFallback<Hex16>(value); |
||
| 427 | } |
||
| 428 | }; |
||
| 429 | |||
| 430 | #define HANDLE_DW_FORM(unused, name, unused2, unused3) \ |
||
| 431 | io.enumCase(value, "DW_FORM_" #name, dwarf::DW_FORM_##name); |
||
| 432 | |||
| 433 | template <> struct ScalarEnumerationTraits<dwarf::Form> { |
||
| 434 | static void enumeration(IO &io, dwarf::Form &value) { |
||
| 435 | #include "llvm/BinaryFormat/Dwarf.def" |
||
| 436 | io.enumFallback<Hex16>(value); |
||
| 437 | } |
||
| 438 | }; |
||
| 439 | |||
| 440 | #define HANDLE_DW_UT(unused, name) \ |
||
| 441 | io.enumCase(value, "DW_UT_" #name, dwarf::DW_UT_##name); |
||
| 442 | |||
| 443 | template <> struct ScalarEnumerationTraits<dwarf::UnitType> { |
||
| 444 | static void enumeration(IO &io, dwarf::UnitType &value) { |
||
| 445 | #include "llvm/BinaryFormat/Dwarf.def" |
||
| 446 | io.enumFallback<Hex8>(value); |
||
| 447 | } |
||
| 448 | }; |
||
| 449 | |||
| 450 | template <> struct ScalarEnumerationTraits<dwarf::Constants> { |
||
| 451 | static void enumeration(IO &io, dwarf::Constants &value) { |
||
| 452 | io.enumCase(value, "DW_CHILDREN_no", dwarf::DW_CHILDREN_no); |
||
| 453 | io.enumCase(value, "DW_CHILDREN_yes", dwarf::DW_CHILDREN_yes); |
||
| 454 | io.enumFallback<Hex16>(value); |
||
| 455 | } |
||
| 456 | }; |
||
| 457 | |||
| 458 | #define HANDLE_DW_RLE(unused, name) \ |
||
| 459 | io.enumCase(value, "DW_RLE_" #name, dwarf::DW_RLE_##name); |
||
| 460 | |||
| 461 | template <> struct ScalarEnumerationTraits<dwarf::RnglistEntries> { |
||
| 462 | static void enumeration(IO &io, dwarf::RnglistEntries &value) { |
||
| 463 | #include "llvm/BinaryFormat/Dwarf.def" |
||
| 464 | } |
||
| 465 | }; |
||
| 466 | |||
| 467 | #define HANDLE_DW_LLE(unused, name) \ |
||
| 468 | io.enumCase(value, "DW_LLE_" #name, dwarf::DW_LLE_##name); |
||
| 469 | |||
| 470 | template <> struct ScalarEnumerationTraits<dwarf::LoclistEntries> { |
||
| 471 | static void enumeration(IO &io, dwarf::LoclistEntries &value) { |
||
| 472 | #include "llvm/BinaryFormat/Dwarf.def" |
||
| 473 | } |
||
| 474 | }; |
||
| 475 | |||
| 476 | #define HANDLE_DW_OP(id, name, version, vendor) \ |
||
| 477 | io.enumCase(value, "DW_OP_" #name, dwarf::DW_OP_##name); |
||
| 478 | |||
| 479 | template <> struct ScalarEnumerationTraits<dwarf::LocationAtom> { |
||
| 480 | static void enumeration(IO &io, dwarf::LocationAtom &value) { |
||
| 481 | #include "llvm/BinaryFormat/Dwarf.def" |
||
| 482 | io.enumFallback<yaml::Hex8>(value); |
||
| 483 | } |
||
| 484 | }; |
||
| 485 | |||
| 486 | } // end namespace yaml |
||
| 487 | } // end namespace llvm |
||
| 488 | |||
| 489 | #endif // LLVM_OBJECTYAML_DWARFYAML_H |