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