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