1 //===- COFFYAML.h - COFF YAMLIO implementation ------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file declares classes for handling the YAML representation of COFF.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #ifndef LLVM_OBJECTYAML_COFFYAML_H
14 #define LLVM_OBJECTYAML_COFFYAML_H
15
16 #include "llvm/ADT/StringRef.h"
17 #include "llvm/BinaryFormat/COFF.h"
18 #include "llvm/ObjectYAML/CodeViewYAMLDebugSections.h"
19 #include "llvm/ObjectYAML/CodeViewYAMLTypeHashing.h"
20 #include "llvm/ObjectYAML/CodeViewYAMLTypes.h"
21 #include "llvm/ObjectYAML/YAML.h"
22 #include <cstdint>
23 #include <optional>
24 #include <vector>
25
26 namespace llvm {
27
28 namespace COFF {
29
30 inline 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
35 inline 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
41 inline 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.
51 namespace COFFYAML {
52
53 LLVM_YAML_STRONG_TYPEDEF(uint8_t, COMDATType)
54 LLVM_YAML_STRONG_TYPEDEF(uint32_t, WeakExternalCharacteristics)
55 LLVM_YAML_STRONG_TYPEDEF(uint8_t, AuxSymbolType)
56
57 struct Relocation {
58 uint32_t VirtualAddress;
59 uint16_t Type;
60
61 // Normally a Relocation can refer to the symbol via its name.
62 // It can also use a direct symbol table index instead (with no name
63 // specified), allowing disambiguating between multiple symbols with the
64 // same name or crafting intentionally broken files for testing.
65 StringRef SymbolName;
66 std::optional<uint32_t> SymbolTableIndex;
67 };
68
69 struct Section {
70 COFF::section Header;
71 unsigned Alignment = 0;
72 yaml::BinaryRef SectionData;
73 std::vector<CodeViewYAML::YAMLDebugSubsection> DebugS;
74 std::vector<CodeViewYAML::LeafRecord> DebugT;
75 std::vector<CodeViewYAML::LeafRecord> DebugP;
76 std::optional<CodeViewYAML::DebugHSection> DebugH;
77 std::vector<Relocation> Relocations;
78 StringRef Name;
79
80 Section();
81 };
82
83 struct Symbol {
84 COFF::symbol Header;
85 COFF::SymbolBaseType SimpleType = COFF::IMAGE_SYM_TYPE_NULL;
86 COFF::SymbolComplexType ComplexType = COFF::IMAGE_SYM_DTYPE_NULL;
87 std::optional<COFF::AuxiliaryFunctionDefinition> FunctionDefinition;
88 std::optional<COFF::AuxiliarybfAndefSymbol> bfAndefSymbol;
89 std::optional<COFF::AuxiliaryWeakExternal> WeakExternal;
90 StringRef File;
91 std::optional<COFF::AuxiliarySectionDefinition> SectionDefinition;
92 std::optional<COFF::AuxiliaryCLRToken> CLRToken;
93 StringRef Name;
94
95 Symbol();
96 };
97
98 struct PEHeader {
99 COFF::PE32Header Header;
100 std::optional<COFF::DataDirectory>
101 DataDirectories[COFF::NUM_DATA_DIRECTORIES];
102 };
103
104 struct Object {
105 std::optional<PEHeader> OptionalHeader;
106 COFF::header Header;
107 std::vector<Section> Sections;
108 std::vector<Symbol> Symbols;
109
110 Object();
111 };
112
113 } // end namespace COFFYAML
114
115 } // end namespace llvm
116
117 LLVM_YAML_IS_SEQUENCE_VECTOR(COFFYAML::Section)
LLVM_YAML_IS_SEQUENCE_VECTOR(COFFYAML::Symbol)118 LLVM_YAML_IS_SEQUENCE_VECTOR(COFFYAML::Symbol)
119 LLVM_YAML_IS_SEQUENCE_VECTOR(COFFYAML::Relocation)
120
121 namespace llvm {
122 namespace yaml {
123
124 template <>
125 struct ScalarEnumerationTraits<COFFYAML::WeakExternalCharacteristics> {
126 static void enumeration(IO &IO, COFFYAML::WeakExternalCharacteristics &Value);
127 };
128
129 template <>
130 struct ScalarEnumerationTraits<COFFYAML::AuxSymbolType> {
131 static void enumeration(IO &IO, COFFYAML::AuxSymbolType &Value);
132 };
133
134 template <>
135 struct ScalarEnumerationTraits<COFFYAML::COMDATType> {
136 static void enumeration(IO &IO, COFFYAML::COMDATType &Value);
137 };
138
139 template <>
140 struct ScalarEnumerationTraits<COFF::MachineTypes> {
141 static void enumeration(IO &IO, COFF::MachineTypes &Value);
142 };
143
144 template <>
145 struct ScalarEnumerationTraits<COFF::SymbolBaseType> {
146 static void enumeration(IO &IO, COFF::SymbolBaseType &Value);
147 };
148
149 template <>
150 struct ScalarEnumerationTraits<COFF::SymbolStorageClass> {
151 static void enumeration(IO &IO, COFF::SymbolStorageClass &Value);
152 };
153
154 template <>
155 struct ScalarEnumerationTraits<COFF::SymbolComplexType> {
156 static void enumeration(IO &IO, COFF::SymbolComplexType &Value);
157 };
158
159 template <>
160 struct ScalarEnumerationTraits<COFF::RelocationTypeI386> {
161 static void enumeration(IO &IO, COFF::RelocationTypeI386 &Value);
162 };
163
164 template <>
165 struct ScalarEnumerationTraits<COFF::RelocationTypeAMD64> {
166 static void enumeration(IO &IO, COFF::RelocationTypeAMD64 &Value);
167 };
168
169 template <>
170 struct ScalarEnumerationTraits<COFF::RelocationTypesARM> {
171 static void enumeration(IO &IO, COFF::RelocationTypesARM &Value);
172 };
173
174 template <>
175 struct ScalarEnumerationTraits<COFF::RelocationTypesARM64> {
176 static void enumeration(IO &IO, COFF::RelocationTypesARM64 &Value);
177 };
178
179 template <>
180 struct ScalarEnumerationTraits<COFF::WindowsSubsystem> {
181 static void enumeration(IO &IO, COFF::WindowsSubsystem &Value);
182 };
183
184 template <>
185 struct ScalarBitSetTraits<COFF::Characteristics> {
186 static void bitset(IO &IO, COFF::Characteristics &Value);
187 };
188
189 template <>
190 struct ScalarBitSetTraits<COFF::SectionCharacteristics> {
191 static void bitset(IO &IO, COFF::SectionCharacteristics &Value);
192 };
193
194 template <>
195 struct ScalarBitSetTraits<COFF::DLLCharacteristics> {
196 static void bitset(IO &IO, COFF::DLLCharacteristics &Value);
197 };
198
199 template <>
200 struct MappingTraits<COFFYAML::Relocation> {
201 static void mapping(IO &IO, COFFYAML::Relocation &Rel);
202 };
203
204 template <>
205 struct MappingTraits<COFFYAML::PEHeader> {
206 static void mapping(IO &IO, COFFYAML::PEHeader &PH);
207 };
208
209 template <>
210 struct MappingTraits<COFF::DataDirectory> {
211 static void mapping(IO &IO, COFF::DataDirectory &DD);
212 };
213
214 template <>
215 struct MappingTraits<COFF::header> {
216 static void mapping(IO &IO, COFF::header &H);
217 };
218
219 template <> struct MappingTraits<COFF::AuxiliaryFunctionDefinition> {
220 static void mapping(IO &IO, COFF::AuxiliaryFunctionDefinition &AFD);
221 };
222
223 template <> struct MappingTraits<COFF::AuxiliarybfAndefSymbol> {
224 static void mapping(IO &IO, COFF::AuxiliarybfAndefSymbol &AAS);
225 };
226
227 template <> struct MappingTraits<COFF::AuxiliaryWeakExternal> {
228 static void mapping(IO &IO, COFF::AuxiliaryWeakExternal &AWE);
229 };
230
231 template <> struct MappingTraits<COFF::AuxiliarySectionDefinition> {
232 static void mapping(IO &IO, COFF::AuxiliarySectionDefinition &ASD);
233 };
234
235 template <> struct MappingTraits<COFF::AuxiliaryCLRToken> {
236 static void mapping(IO &IO, COFF::AuxiliaryCLRToken &ACT);
237 };
238
239 template <>
240 struct MappingTraits<COFFYAML::Symbol> {
241 static void mapping(IO &IO, COFFYAML::Symbol &S);
242 };
243
244 template <>
245 struct MappingTraits<COFFYAML::Section> {
246 static void mapping(IO &IO, COFFYAML::Section &Sec);
247 };
248
249 template <>
250 struct MappingTraits<COFFYAML::Object> {
251 static void mapping(IO &IO, COFFYAML::Object &Obj);
252 };
253
254 } // end namespace yaml
255 } // end namespace llvm
256
257 #endif // LLVM_OBJECTYAML_COFFYAML_H
258