path: root/contrib/libs/llvm12/include/llvm/ObjectYAML/DWARFYAML.h

#pragma once

#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#endif

//===- 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

#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif