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/ADT/Optional.h"
18#include "llvm/MC/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;
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;
67    COFF::SymbolComplexType ComplexType;
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