1//===- COFFYAML.h - COFF 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// This file declares classes for handling the YAML representation of COFF. 11// 12//===----------------------------------------------------------------------===// 13 14#ifndef LLVM_OBJECTYAML_COFFYAML_H 15#define LLVM_OBJECTYAML_COFFYAML_H 16 17#include "llvm/ADT/Optional.h" 18#include "llvm/ADT/StringRef.h" 19#include "llvm/BinaryFormat/COFF.h" 20#include "llvm/ObjectYAML/CodeViewYAMLDebugSections.h" 21#include "llvm/ObjectYAML/CodeViewYAMLTypes.h" 22#include "llvm/ObjectYAML/YAML.h" 23#include <cstdint> 24#include <vector> 25 26namespace llvm { 27 28namespace COFF { 29 30inline Characteristics operator|(Characteristics a, Characteristics b) { 31 uint32_t Ret = static_cast<uint32_t>(a) | static_cast<uint32_t>(b); 32 return static_cast<Characteristics>(Ret); 33} 34 35inline SectionCharacteristics operator|(SectionCharacteristics a, 36 SectionCharacteristics b) { 37 uint32_t Ret = static_cast<uint32_t>(a) | static_cast<uint32_t>(b); 38 return static_cast<SectionCharacteristics>(Ret); 39} 40 41inline DLLCharacteristics operator|(DLLCharacteristics a, 42 DLLCharacteristics b) { 43 uint16_t Ret = static_cast<uint16_t>(a) | static_cast<uint16_t>(b); 44 return static_cast<DLLCharacteristics>(Ret); 45} 46 47} // end namespace COFF 48 49// The structure of the yaml files is not an exact 1:1 match to COFF. In order 50// to use yaml::IO, we use these structures which are closer to the source. 51namespace COFFYAML { 52 53LLVM_YAML_STRONG_TYPEDEF(uint8_t, COMDATType) 54LLVM_YAML_STRONG_TYPEDEF(uint32_t, WeakExternalCharacteristics) 55LLVM_YAML_STRONG_TYPEDEF(uint8_t, AuxSymbolType) 56 57struct Relocation { 58 uint32_t VirtualAddress; 59 uint16_t Type; 60 StringRef SymbolName; 61}; 62 63struct Section { 64 COFF::section Header; 65 unsigned Alignment = 0; 66 yaml::BinaryRef SectionData; 67 std::vector<CodeViewYAML::YAMLDebugSubsection> DebugS; 68 std::vector<CodeViewYAML::LeafRecord> DebugT; 69 std::vector<Relocation> Relocations; 70 StringRef Name; 71 72 Section(); 73}; 74 75struct Symbol { 76 COFF::symbol Header; 77 COFF::SymbolBaseType SimpleType = COFF::IMAGE_SYM_TYPE_NULL; 78 COFF::SymbolComplexType ComplexType = COFF::IMAGE_SYM_DTYPE_NULL; 79 Optional<COFF::AuxiliaryFunctionDefinition> FunctionDefinition; 80 Optional<COFF::AuxiliarybfAndefSymbol> bfAndefSymbol; 81 Optional<COFF::AuxiliaryWeakExternal> WeakExternal; 82 StringRef File; 83 Optional<COFF::AuxiliarySectionDefinition> SectionDefinition; 84 Optional<COFF::AuxiliaryCLRToken> CLRToken; 85 StringRef Name; 86 87 Symbol(); 88}; 89 90struct PEHeader { 91 COFF::PE32Header Header; 92 Optional<COFF::DataDirectory> DataDirectories[COFF::NUM_DATA_DIRECTORIES]; 93}; 94 95struct Object { 96 Optional<PEHeader> OptionalHeader; 97 COFF::header Header; 98 std::vector<Section> Sections; 99 std::vector<Symbol> Symbols; 100 101 Object(); 102}; 103 104} // end namespace COFFYAML 105 106} // end namespace llvm 107 108LLVM_YAML_IS_SEQUENCE_VECTOR(COFFYAML::Section) 109LLVM_YAML_IS_SEQUENCE_VECTOR(COFFYAML::Symbol) 110LLVM_YAML_IS_SEQUENCE_VECTOR(COFFYAML::Relocation) 111 112namespace llvm { 113namespace yaml { 114 115template <> 116struct ScalarEnumerationTraits<COFFYAML::WeakExternalCharacteristics> { 117 static void enumeration(IO &IO, COFFYAML::WeakExternalCharacteristics &Value); 118}; 119 120template <> 121struct ScalarEnumerationTraits<COFFYAML::AuxSymbolType> { 122 static void enumeration(IO &IO, COFFYAML::AuxSymbolType &Value); 123}; 124 125template <> 126struct ScalarEnumerationTraits<COFFYAML::COMDATType> { 127 static void enumeration(IO &IO, COFFYAML::COMDATType &Value); 128}; 129 130template <> 131struct ScalarEnumerationTraits<COFF::MachineTypes> { 132 static void enumeration(IO &IO, COFF::MachineTypes &Value); 133}; 134 135template <> 136struct ScalarEnumerationTraits<COFF::SymbolBaseType> { 137 static void enumeration(IO &IO, COFF::SymbolBaseType &Value); 138}; 139 140template <> 141struct ScalarEnumerationTraits<COFF::SymbolStorageClass> { 142 static void enumeration(IO &IO, COFF::SymbolStorageClass &Value); 143}; 144 145template <> 146struct ScalarEnumerationTraits<COFF::SymbolComplexType> { 147 static void enumeration(IO &IO, COFF::SymbolComplexType &Value); 148}; 149 150template <> 151struct ScalarEnumerationTraits<COFF::RelocationTypeI386> { 152 static void enumeration(IO &IO, COFF::RelocationTypeI386 &Value); 153}; 154 155template <> 156struct ScalarEnumerationTraits<COFF::RelocationTypeAMD64> { 157 static void enumeration(IO &IO, COFF::RelocationTypeAMD64 &Value); 158}; 159 160template <> 161struct ScalarEnumerationTraits<COFF::WindowsSubsystem> { 162 static void enumeration(IO &IO, COFF::WindowsSubsystem &Value); 163}; 164 165template <> 166struct ScalarBitSetTraits<COFF::Characteristics> { 167 static void bitset(IO &IO, COFF::Characteristics &Value); 168}; 169 170template <> 171struct ScalarBitSetTraits<COFF::SectionCharacteristics> { 172 static void bitset(IO &IO, COFF::SectionCharacteristics &Value); 173}; 174 175template <> 176struct ScalarBitSetTraits<COFF::DLLCharacteristics> { 177 static void bitset(IO &IO, COFF::DLLCharacteristics &Value); 178}; 179 180template <> 181struct MappingTraits<COFFYAML::Relocation> { 182 static void mapping(IO &IO, COFFYAML::Relocation &Rel); 183}; 184 185template <> 186struct MappingTraits<COFFYAML::PEHeader> { 187 static void mapping(IO &IO, COFFYAML::PEHeader &PH); 188}; 189 190template <> 191struct MappingTraits<COFF::DataDirectory> { 192 static void mapping(IO &IO, COFF::DataDirectory &DD); 193}; 194 195template <> 196struct MappingTraits<COFF::header> { 197 static void mapping(IO &IO, COFF::header &H); 198}; 199 200template <> struct MappingTraits<COFF::AuxiliaryFunctionDefinition> { 201 static void mapping(IO &IO, COFF::AuxiliaryFunctionDefinition &AFD); 202}; 203 204template <> struct MappingTraits<COFF::AuxiliarybfAndefSymbol> { 205 static void mapping(IO &IO, COFF::AuxiliarybfAndefSymbol &AAS); 206}; 207 208template <> struct MappingTraits<COFF::AuxiliaryWeakExternal> { 209 static void mapping(IO &IO, COFF::AuxiliaryWeakExternal &AWE); 210}; 211 212template <> struct MappingTraits<COFF::AuxiliarySectionDefinition> { 213 static void mapping(IO &IO, COFF::AuxiliarySectionDefinition &ASD); 214}; 215 216template <> struct MappingTraits<COFF::AuxiliaryCLRToken> { 217 static void mapping(IO &IO, COFF::AuxiliaryCLRToken &ACT); 218}; 219 220template <> 221struct MappingTraits<COFFYAML::Symbol> { 222 static void mapping(IO &IO, COFFYAML::Symbol &S); 223}; 224 225template <> 226struct MappingTraits<COFFYAML::Section> { 227 static void mapping(IO &IO, COFFYAML::Section &Sec); 228}; 229 230template <> 231struct MappingTraits<COFFYAML::Object> { 232 static void mapping(IO &IO, COFFYAML::Object &Obj); 233}; 234 235} // end namespace yaml 236} // end namespace llvm 237 238#endif // LLVM_OBJECTYAML_COFFYAML_H 239