| //===- DWARFYAML.h - DWARF YAMLIO implementation ----------------*- C++ -*-===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| /// |
| /// \file |
| /// This file declares classes for handling the YAML representation |
| /// of DWARF Debug Info. |
| /// |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef LLVM_OBJECTYAML_DWARFYAML_H |
| #define LLVM_OBJECTYAML_DWARFYAML_H |
| |
| #include "llvm/ADT/SetVector.h" |
| #include "llvm/ADT/StringRef.h" |
| #include "llvm/BinaryFormat/Dwarf.h" |
| #include "llvm/ObjectYAML/YAML.h" |
| #include "llvm/Support/YAMLTraits.h" |
| #include <cstdint> |
| #include <unordered_map> |
| #include <vector> |
| |
| namespace llvm { |
| namespace DWARFYAML { |
| |
| struct AttributeAbbrev { |
| llvm::dwarf::Attribute Attribute; |
| llvm::dwarf::Form Form; |
| llvm::yaml::Hex64 Value; // Some DWARF5 attributes have values |
| }; |
| |
| struct Abbrev { |
| Optional<yaml::Hex64> Code; |
| llvm::dwarf::Tag Tag; |
| llvm::dwarf::Constants Children; |
| std::vector<AttributeAbbrev> Attributes; |
| }; |
| |
| struct AbbrevTable { |
| Optional<uint64_t> ID; |
| std::vector<Abbrev> Table; |
| }; |
| |
| struct ARangeDescriptor { |
| llvm::yaml::Hex64 Address; |
| yaml::Hex64 Length; |
| }; |
| |
| struct ARange { |
| dwarf::DwarfFormat Format; |
| Optional<yaml::Hex64> Length; |
| uint16_t Version; |
| yaml::Hex64 CuOffset; |
| Optional<yaml::Hex8> AddrSize; |
| yaml::Hex8 SegSize; |
| std::vector<ARangeDescriptor> Descriptors; |
| }; |
| |
| /// Class that describes a range list entry, or a base address selection entry |
| /// within a range list in the .debug_ranges section. |
| struct RangeEntry { |
| llvm::yaml::Hex64 LowOffset; |
| llvm::yaml::Hex64 HighOffset; |
| }; |
| |
| /// Class that describes a single range list inside the .debug_ranges section. |
| struct Ranges { |
| Optional<llvm::yaml::Hex64> Offset; |
| Optional<llvm::yaml::Hex8> AddrSize; |
| std::vector<RangeEntry> Entries; |
| }; |
| |
| struct PubEntry { |
| llvm::yaml::Hex32 DieOffset; |
| llvm::yaml::Hex8 Descriptor; |
| StringRef Name; |
| }; |
| |
| struct PubSection { |
| dwarf::DwarfFormat Format; |
| yaml::Hex64 Length; |
| uint16_t Version; |
| uint32_t UnitOffset; |
| uint32_t UnitSize; |
| std::vector<PubEntry> Entries; |
| }; |
| |
| struct FormValue { |
| llvm::yaml::Hex64 Value; |
| StringRef CStr; |
| std::vector<llvm::yaml::Hex8> BlockData; |
| }; |
| |
| struct Entry { |
| llvm::yaml::Hex32 AbbrCode; |
| std::vector<FormValue> Values; |
| }; |
| |
| /// Class that contains helpful context information when mapping YAML into DWARF |
| /// data structures. |
| struct DWARFContext { |
| bool IsGNUPubSec = false; |
| }; |
| |
| struct Unit { |
| dwarf::DwarfFormat Format; |
| Optional<yaml::Hex64> Length; |
| uint16_t Version; |
| Optional<uint8_t> AddrSize; |
| llvm::dwarf::UnitType Type; // Added in DWARF 5 |
| Optional<uint64_t> AbbrevTableID; |
| Optional<yaml::Hex64> AbbrOffset; |
| std::vector<Entry> Entries; |
| }; |
| |
| struct File { |
| StringRef Name; |
| uint64_t DirIdx; |
| uint64_t ModTime; |
| uint64_t Length; |
| }; |
| |
| struct LineTableOpcode { |
| dwarf::LineNumberOps Opcode; |
| Optional<uint64_t> ExtLen; |
| dwarf::LineNumberExtendedOps SubOpcode; |
| uint64_t Data; |
| int64_t SData; |
| File FileEntry; |
| std::vector<llvm::yaml::Hex8> UnknownOpcodeData; |
| std::vector<llvm::yaml::Hex64> StandardOpcodeData; |
| }; |
| |
| struct LineTable { |
| dwarf::DwarfFormat Format; |
| Optional<uint64_t> Length; |
| uint16_t Version; |
| Optional<uint64_t> PrologueLength; |
| uint8_t MinInstLength; |
| uint8_t MaxOpsPerInst; |
| uint8_t DefaultIsStmt; |
| uint8_t LineBase; |
| uint8_t LineRange; |
| Optional<uint8_t> OpcodeBase; |
| Optional<std::vector<uint8_t>> StandardOpcodeLengths; |
| std::vector<StringRef> IncludeDirs; |
| std::vector<File> Files; |
| std::vector<LineTableOpcode> Opcodes; |
| }; |
| |
| struct SegAddrPair { |
| yaml::Hex64 Segment; |
| yaml::Hex64 Address; |
| }; |
| |
| struct AddrTableEntry { |
| dwarf::DwarfFormat Format; |
| Optional<yaml::Hex64> Length; |
| yaml::Hex16 Version; |
| Optional<yaml::Hex8> AddrSize; |
| yaml::Hex8 SegSelectorSize; |
| std::vector<SegAddrPair> SegAddrPairs; |
| }; |
| |
| struct StringOffsetsTable { |
| dwarf::DwarfFormat Format; |
| Optional<yaml::Hex64> Length; |
| yaml::Hex16 Version; |
| yaml::Hex16 Padding; |
| std::vector<yaml::Hex64> Offsets; |
| }; |
| |
| struct DWARFOperation { |
| dwarf::LocationAtom Operator; |
| std::vector<yaml::Hex64> Values; |
| }; |
| |
| struct RnglistEntry { |
| dwarf::RnglistEntries Operator; |
| std::vector<yaml::Hex64> Values; |
| }; |
| |
| struct LoclistEntry { |
| dwarf::LoclistEntries Operator; |
| std::vector<yaml::Hex64> Values; |
| Optional<yaml::Hex64> DescriptionsLength; |
| std::vector<DWARFOperation> Descriptions; |
| }; |
| |
| template <typename EntryType> struct ListEntries { |
| Optional<std::vector<EntryType>> Entries; |
| Optional<yaml::BinaryRef> Content; |
| }; |
| |
| template <typename EntryType> struct ListTable { |
| dwarf::DwarfFormat Format; |
| Optional<yaml::Hex64> Length; |
| yaml::Hex16 Version; |
| Optional<yaml::Hex8> AddrSize; |
| yaml::Hex8 SegSelectorSize; |
| Optional<uint32_t> OffsetEntryCount; |
| Optional<std::vector<yaml::Hex64>> Offsets; |
| std::vector<ListEntries<EntryType>> Lists; |
| }; |
| |
| struct Data { |
| bool IsLittleEndian; |
| bool Is64BitAddrSize; |
| std::vector<AbbrevTable> DebugAbbrev; |
| Optional<std::vector<StringRef>> DebugStrings; |
| Optional<std::vector<StringOffsetsTable>> DebugStrOffsets; |
| Optional<std::vector<ARange>> DebugAranges; |
| Optional<std::vector<Ranges>> DebugRanges; |
| Optional<std::vector<AddrTableEntry>> DebugAddr; |
| Optional<PubSection> PubNames; |
| Optional<PubSection> PubTypes; |
| |
| Optional<PubSection> GNUPubNames; |
| Optional<PubSection> GNUPubTypes; |
| |
| std::vector<Unit> CompileUnits; |
| |
| std::vector<LineTable> DebugLines; |
| Optional<std::vector<ListTable<RnglistEntry>>> DebugRnglists; |
| Optional<std::vector<ListTable<LoclistEntry>>> DebugLoclists; |
| |
| bool isEmpty() const; |
| |
| SetVector<StringRef> getNonEmptySectionNames() const; |
| |
| struct AbbrevTableInfo { |
| uint64_t Index; |
| uint64_t Offset; |
| }; |
| Expected<AbbrevTableInfo> getAbbrevTableInfoByID(uint64_t ID) const; |
| StringRef getAbbrevTableContentByIndex(uint64_t Index) const; |
| |
| private: |
| mutable std::unordered_map<uint64_t, AbbrevTableInfo> AbbrevTableInfoMap; |
| mutable std::unordered_map<uint64_t, std::string> AbbrevTableContents; |
| }; |
| |
| } // end namespace DWARFYAML |
| } // end namespace llvm |
| |
| LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::AttributeAbbrev) |
| LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Abbrev) |
| LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::AbbrevTable) |
| LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::ARangeDescriptor) |
| LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::ARange) |
| LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::RangeEntry) |
| LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Ranges) |
| LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::PubEntry) |
| LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Unit) |
| LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::FormValue) |
| LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Entry) |
| LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::File) |
| LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::LineTable) |
| LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::LineTableOpcode) |
| LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::SegAddrPair) |
| LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::AddrTableEntry) |
| LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::StringOffsetsTable) |
| LLVM_YAML_IS_SEQUENCE_VECTOR( |
| llvm::DWARFYAML::ListTable<DWARFYAML::RnglistEntry>) |
| LLVM_YAML_IS_SEQUENCE_VECTOR( |
| llvm::DWARFYAML::ListEntries<DWARFYAML::RnglistEntry>) |
| LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::RnglistEntry) |
| LLVM_YAML_IS_SEQUENCE_VECTOR( |
| llvm::DWARFYAML::ListTable<DWARFYAML::LoclistEntry>) |
| LLVM_YAML_IS_SEQUENCE_VECTOR( |
| llvm::DWARFYAML::ListEntries<DWARFYAML::LoclistEntry>) |
| LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::LoclistEntry) |
| LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::DWARFOperation) |
| |
| namespace llvm { |
| namespace yaml { |
| |
| template <> struct MappingTraits<DWARFYAML::Data> { |
| static void mapping(IO &IO, DWARFYAML::Data &DWARF); |
| }; |
| |
| template <> struct MappingTraits<DWARFYAML::AbbrevTable> { |
| static void mapping(IO &IO, DWARFYAML::AbbrevTable &AbbrevTable); |
| }; |
| |
| template <> struct MappingTraits<DWARFYAML::Abbrev> { |
| static void mapping(IO &IO, DWARFYAML::Abbrev &Abbrev); |
| }; |
| |
| template <> struct MappingTraits<DWARFYAML::AttributeAbbrev> { |
| static void mapping(IO &IO, DWARFYAML::AttributeAbbrev &AttAbbrev); |
| }; |
| |
| template <> struct MappingTraits<DWARFYAML::ARangeDescriptor> { |
| static void mapping(IO &IO, DWARFYAML::ARangeDescriptor &Descriptor); |
| }; |
| |
| template <> struct MappingTraits<DWARFYAML::ARange> { |
| static void mapping(IO &IO, DWARFYAML::ARange &ARange); |
| }; |
| |
| template <> struct MappingTraits<DWARFYAML::RangeEntry> { |
| static void mapping(IO &IO, DWARFYAML::RangeEntry &Entry); |
| }; |
| |
| template <> struct MappingTraits<DWARFYAML::Ranges> { |
| static void mapping(IO &IO, DWARFYAML::Ranges &Ranges); |
| }; |
| |
| template <> struct MappingTraits<DWARFYAML::PubEntry> { |
| static void mapping(IO &IO, DWARFYAML::PubEntry &Entry); |
| }; |
| |
| template <> struct MappingTraits<DWARFYAML::PubSection> { |
| static void mapping(IO &IO, DWARFYAML::PubSection &Section); |
| }; |
| |
| template <> struct MappingTraits<DWARFYAML::Unit> { |
| static void mapping(IO &IO, DWARFYAML::Unit &Unit); |
| }; |
| |
| template <> struct MappingTraits<DWARFYAML::Entry> { |
| static void mapping(IO &IO, DWARFYAML::Entry &Entry); |
| }; |
| |
| template <> struct MappingTraits<DWARFYAML::FormValue> { |
| static void mapping(IO &IO, DWARFYAML::FormValue &FormValue); |
| }; |
| |
| template <> struct MappingTraits<DWARFYAML::File> { |
| static void mapping(IO &IO, DWARFYAML::File &File); |
| }; |
| |
| template <> struct MappingTraits<DWARFYAML::LineTableOpcode> { |
| static void mapping(IO &IO, DWARFYAML::LineTableOpcode &LineTableOpcode); |
| }; |
| |
| template <> struct MappingTraits<DWARFYAML::LineTable> { |
| static void mapping(IO &IO, DWARFYAML::LineTable &LineTable); |
| }; |
| |
| template <> struct MappingTraits<DWARFYAML::SegAddrPair> { |
| static void mapping(IO &IO, DWARFYAML::SegAddrPair &SegAddrPair); |
| }; |
| |
| template <> struct MappingTraits<DWARFYAML::DWARFOperation> { |
| static void mapping(IO &IO, DWARFYAML::DWARFOperation &DWARFOperation); |
| }; |
| |
| template <typename EntryType> |
| struct MappingTraits<DWARFYAML::ListTable<EntryType>> { |
| static void mapping(IO &IO, DWARFYAML::ListTable<EntryType> &ListTable); |
| }; |
| |
| template <typename EntryType> |
| struct MappingTraits<DWARFYAML::ListEntries<EntryType>> { |
| static void mapping(IO &IO, DWARFYAML::ListEntries<EntryType> &ListEntries); |
| static std::string validate(IO &IO, |
| DWARFYAML::ListEntries<EntryType> &ListEntries); |
| }; |
| |
| template <> struct MappingTraits<DWARFYAML::RnglistEntry> { |
| static void mapping(IO &IO, DWARFYAML::RnglistEntry &RnglistEntry); |
| }; |
| |
| template <> struct MappingTraits<DWARFYAML::LoclistEntry> { |
| static void mapping(IO &IO, DWARFYAML::LoclistEntry &LoclistEntry); |
| }; |
| |
| template <> struct MappingTraits<DWARFYAML::AddrTableEntry> { |
| static void mapping(IO &IO, DWARFYAML::AddrTableEntry &AddrTable); |
| }; |
| |
| template <> struct MappingTraits<DWARFYAML::StringOffsetsTable> { |
| static void mapping(IO &IO, DWARFYAML::StringOffsetsTable &StrOffsetsTable); |
| }; |
| |
| template <> struct ScalarEnumerationTraits<dwarf::DwarfFormat> { |
| static void enumeration(IO &IO, dwarf::DwarfFormat &Format) { |
| IO.enumCase(Format, "DWARF32", dwarf::DWARF32); |
| IO.enumCase(Format, "DWARF64", dwarf::DWARF64); |
| } |
| }; |
| |
| #define HANDLE_DW_TAG(unused, name, unused2, unused3, unused4) \ |
| io.enumCase(value, "DW_TAG_" #name, dwarf::DW_TAG_##name); |
| |
| template <> struct ScalarEnumerationTraits<dwarf::Tag> { |
| static void enumeration(IO &io, dwarf::Tag &value) { |
| #include "llvm/BinaryFormat/Dwarf.def" |
| io.enumFallback<Hex16>(value); |
| } |
| }; |
| |
| #define HANDLE_DW_LNS(unused, name) \ |
| io.enumCase(value, "DW_LNS_" #name, dwarf::DW_LNS_##name); |
| |
| template <> struct ScalarEnumerationTraits<dwarf::LineNumberOps> { |
| static void enumeration(IO &io, dwarf::LineNumberOps &value) { |
| #include "llvm/BinaryFormat/Dwarf.def" |
| io.enumFallback<Hex8>(value); |
| } |
| }; |
| |
| #define HANDLE_DW_LNE(unused, name) \ |
| io.enumCase(value, "DW_LNE_" #name, dwarf::DW_LNE_##name); |
| |
| template <> struct ScalarEnumerationTraits<dwarf::LineNumberExtendedOps> { |
| static void enumeration(IO &io, dwarf::LineNumberExtendedOps &value) { |
| #include "llvm/BinaryFormat/Dwarf.def" |
| io.enumFallback<Hex16>(value); |
| } |
| }; |
| |
| #define HANDLE_DW_AT(unused, name, unused2, unused3) \ |
| io.enumCase(value, "DW_AT_" #name, dwarf::DW_AT_##name); |
| |
| template <> struct ScalarEnumerationTraits<dwarf::Attribute> { |
| static void enumeration(IO &io, dwarf::Attribute &value) { |
| #include "llvm/BinaryFormat/Dwarf.def" |
| io.enumFallback<Hex16>(value); |
| } |
| }; |
| |
| #define HANDLE_DW_FORM(unused, name, unused2, unused3) \ |
| io.enumCase(value, "DW_FORM_" #name, dwarf::DW_FORM_##name); |
| |
| template <> struct ScalarEnumerationTraits<dwarf::Form> { |
| static void enumeration(IO &io, dwarf::Form &value) { |
| #include "llvm/BinaryFormat/Dwarf.def" |
| io.enumFallback<Hex16>(value); |
| } |
| }; |
| |
| #define HANDLE_DW_UT(unused, name) \ |
| io.enumCase(value, "DW_UT_" #name, dwarf::DW_UT_##name); |
| |
| template <> struct ScalarEnumerationTraits<dwarf::UnitType> { |
| static void enumeration(IO &io, dwarf::UnitType &value) { |
| #include "llvm/BinaryFormat/Dwarf.def" |
| io.enumFallback<Hex8>(value); |
| } |
| }; |
| |
| template <> struct ScalarEnumerationTraits<dwarf::Constants> { |
| static void enumeration(IO &io, dwarf::Constants &value) { |
| io.enumCase(value, "DW_CHILDREN_no", dwarf::DW_CHILDREN_no); |
| io.enumCase(value, "DW_CHILDREN_yes", dwarf::DW_CHILDREN_yes); |
| io.enumFallback<Hex16>(value); |
| } |
| }; |
| |
| #define HANDLE_DW_RLE(unused, name) \ |
| io.enumCase(value, "DW_RLE_" #name, dwarf::DW_RLE_##name); |
| |
| template <> struct ScalarEnumerationTraits<dwarf::RnglistEntries> { |
| static void enumeration(IO &io, dwarf::RnglistEntries &value) { |
| #include "llvm/BinaryFormat/Dwarf.def" |
| } |
| }; |
| |
| #define HANDLE_DW_LLE(unused, name) \ |
| io.enumCase(value, "DW_LLE_" #name, dwarf::DW_LLE_##name); |
| |
| template <> struct ScalarEnumerationTraits<dwarf::LoclistEntries> { |
| static void enumeration(IO &io, dwarf::LoclistEntries &value) { |
| #include "llvm/BinaryFormat/Dwarf.def" |
| } |
| }; |
| |
| #define HANDLE_DW_OP(id, name, version, vendor) \ |
| io.enumCase(value, "DW_OP_" #name, dwarf::DW_OP_##name); |
| |
| template <> struct ScalarEnumerationTraits<dwarf::LocationAtom> { |
| static void enumeration(IO &io, dwarf::LocationAtom &value) { |
| #include "llvm/BinaryFormat/Dwarf.def" |
| io.enumFallback<yaml::Hex8>(value); |
| } |
| }; |
| |
| } // end namespace yaml |
| } // end namespace llvm |
| |
| #endif // LLVM_OBJECTYAML_DWARFYAML_H |