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_OBJECT_COFFYAML_H 15 #define LLVM_OBJECT_COFFYAML_H 16 17 #include "llvm/Object/YAML.h" 18 #include "llvm/Support/COFF.h" 19 20 namespace llvm { 21 22 namespace COFF { 23 inline Characteristics operator|(Characteristics a, Characteristics b) { 24 uint32_t Ret = static_cast<uint32_t>(a) | static_cast<uint32_t>(b); 25 return static_cast<Characteristics>(Ret); 26 } 27 28 inline SectionCharacteristics operator|(SectionCharacteristics a, 29 SectionCharacteristics b) { 30 uint32_t Ret = static_cast<uint32_t>(a) | static_cast<uint32_t>(b); 31 return static_cast<SectionCharacteristics>(Ret); 32 } 33 } 34 35 // The structure of the yaml files is not an exact 1:1 match to COFF. In order 36 // to use yaml::IO, we use these structures which are closer to the source. 37 namespace COFFYAML { 38 struct Relocation { 39 uint32_t VirtualAddress; 40 uint16_t Type; 41 StringRef SymbolName; 42 }; 43 44 struct Section { 45 COFF::section Header; 46 unsigned Alignment; 47 object::yaml::BinaryRef SectionData; 48 std::vector<Relocation> Relocations; 49 StringRef Name; 50 Section(); 51 }; 52 53 struct Symbol { 54 COFF::symbol Header; 55 COFF::SymbolBaseType SimpleType; 56 COFF::SymbolComplexType ComplexType; 57 object::yaml::BinaryRef AuxiliaryData; 58 StringRef Name; 59 Symbol(); 60 }; 61 62 struct Object { 63 COFF::header Header; 64 std::vector<Section> Sections; 65 std::vector<Symbol> Symbols; 66 Object(); 67 }; 68 } 69 } 70 71 LLVM_YAML_IS_SEQUENCE_VECTOR(COFFYAML::Section) 72 LLVM_YAML_IS_SEQUENCE_VECTOR(COFFYAML::Symbol) 73 LLVM_YAML_IS_SEQUENCE_VECTOR(COFFYAML::Relocation) 74 75 namespace llvm { 76 namespace yaml { 77 78 template <> 79 struct ScalarEnumerationTraits<COFF::MachineTypes> { 80 static void enumeration(IO &IO, COFF::MachineTypes &Value); 81 }; 82 83 template <> 84 struct ScalarEnumerationTraits<COFF::SymbolBaseType> { 85 static void enumeration(IO &IO, COFF::SymbolBaseType &Value); 86 }; 87 88 template <> 89 struct ScalarEnumerationTraits<COFF::SymbolStorageClass> { 90 static void enumeration(IO &IO, COFF::SymbolStorageClass &Value); 91 }; 92 93 template <> 94 struct ScalarEnumerationTraits<COFF::SymbolComplexType> { 95 static void enumeration(IO &IO, COFF::SymbolComplexType &Value); 96 }; 97 98 template <> 99 struct ScalarEnumerationTraits<COFF::RelocationTypeX86> { 100 static void enumeration(IO &IO, COFF::RelocationTypeX86 &Value); 101 }; 102 103 template <> 104 struct ScalarBitSetTraits<COFF::Characteristics> { 105 static void bitset(IO &IO, COFF::Characteristics &Value); 106 }; 107 108 template <> 109 struct ScalarBitSetTraits<COFF::SectionCharacteristics> { 110 static void bitset(IO &IO, COFF::SectionCharacteristics &Value); 111 }; 112 113 template <> 114 struct MappingTraits<COFFYAML::Relocation> { 115 static void mapping(IO &IO, COFFYAML::Relocation &Rel); 116 }; 117 118 template <> 119 struct MappingTraits<COFF::header> { 120 static void mapping(IO &IO, COFF::header &H); 121 }; 122 123 template <> 124 struct MappingTraits<COFFYAML::Symbol> { 125 static void mapping(IO &IO, COFFYAML::Symbol &S); 126 }; 127 128 template <> 129 struct MappingTraits<COFFYAML::Section> { 130 static void mapping(IO &IO, COFFYAML::Section &Sec); 131 }; 132 133 template <> 134 struct MappingTraits<COFFYAML::Object> { 135 static void mapping(IO &IO, COFFYAML::Object &Obj); 136 }; 137 138 } // end namespace yaml 139 } // end namespace llvm 140 141 #endif 142
