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