Line data Source code
1 : //===- WasmYAML.h - Wasm 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 : /// \file
11 : /// This file declares classes for handling the YAML representation
12 : /// of wasm binaries.
13 : ///
14 : //===----------------------------------------------------------------------===//
15 :
16 : #ifndef LLVM_OBJECTYAML_WASMYAML_H
17 : #define LLVM_OBJECTYAML_WASMYAML_H
18 :
19 : #include "llvm/ADT/StringRef.h"
20 : #include "llvm/BinaryFormat/Wasm.h"
21 : #include "llvm/ObjectYAML/YAML.h"
22 : #include "llvm/Support/Casting.h"
23 : #include <cstdint>
24 : #include <memory>
25 : #include <vector>
26 :
27 : namespace llvm {
28 : namespace WasmYAML {
29 :
30 150 : LLVM_YAML_STRONG_TYPEDEF(uint32_t, SectionType)
31 482 : LLVM_YAML_STRONG_TYPEDEF(uint32_t, ValueType)
32 3 : LLVM_YAML_STRONG_TYPEDEF(uint32_t, TableType)
33 178 : LLVM_YAML_STRONG_TYPEDEF(uint32_t, SignatureForm)
34 419 : LLVM_YAML_STRONG_TYPEDEF(uint32_t, ExportKind)
35 311 : LLVM_YAML_STRONG_TYPEDEF(uint32_t, Opcode)
36 250 : LLVM_YAML_STRONG_TYPEDEF(uint32_t, RelocType)
37 24 : LLVM_YAML_STRONG_TYPEDEF(uint32_t, SymbolFlags)
38 24 : LLVM_YAML_STRONG_TYPEDEF(uint32_t, SymbolKind)
39 0 : LLVM_YAML_STRONG_TYPEDEF(uint32_t, SegmentFlags)
40 0 : LLVM_YAML_STRONG_TYPEDEF(uint32_t, LimitFlags)
41 0 : LLVM_YAML_STRONG_TYPEDEF(uint32_t, ComdatKind)
42 :
43 : struct FileHeader {
44 : yaml::Hex32 Version;
45 : };
46 :
47 : struct Limits {
48 : LimitFlags Flags;
49 : yaml::Hex32 Initial;
50 : yaml::Hex32 Maximum;
51 : };
52 :
53 : struct Table {
54 : TableType ElemType;
55 : Limits TableLimits;
56 : };
57 :
58 : struct Export {
59 : StringRef Name;
60 : ExportKind Kind;
61 : uint32_t Index;
62 : };
63 :
64 44 : struct ElemSegment {
65 : uint32_t TableIndex;
66 : wasm::WasmInitExpr Offset;
67 : std::vector<uint32_t> Functions;
68 : };
69 :
70 : struct Global {
71 : uint32_t Index;
72 : ValueType Type;
73 : bool Mutable;
74 : wasm::WasmInitExpr InitExpr;
75 : };
76 :
77 : struct Import {
78 : StringRef Module;
79 : StringRef Field;
80 : ExportKind Kind;
81 : union {
82 : uint32_t SigIndex;
83 : Global GlobalImport;
84 : Table TableImport;
85 : Limits Memory;
86 : };
87 : };
88 :
89 : struct LocalDecl {
90 : ValueType Type;
91 : uint32_t Count;
92 : };
93 :
94 2728 : struct Function {
95 : uint32_t Index;
96 : std::vector<LocalDecl> Locals;
97 : yaml::BinaryRef Body;
98 : };
99 :
100 : struct Relocation {
101 : RelocType Type;
102 : uint32_t Index;
103 : yaml::Hex32 Offset;
104 : int32_t Addend;
105 : };
106 :
107 : struct DataSegment {
108 : uint32_t MemoryIndex;
109 : uint32_t SectionOffset;
110 : wasm::WasmInitExpr Offset;
111 : yaml::BinaryRef Content;
112 : };
113 :
114 : struct NameEntry {
115 : uint32_t Index;
116 : StringRef Name;
117 : };
118 :
119 : struct SegmentInfo {
120 : uint32_t Index;
121 : StringRef Name;
122 : uint32_t Alignment;
123 : SegmentFlags Flags;
124 : };
125 :
126 605 : struct Signature {
127 : uint32_t Index;
128 : SignatureForm Form = wasm::WASM_TYPE_FUNC;
129 : std::vector<ValueType> ParamTypes;
130 : ValueType ReturnType;
131 : };
132 :
133 : struct SymbolInfo {
134 : uint32_t Index;
135 : StringRef Name;
136 : SymbolKind Kind;
137 : SymbolFlags Flags;
138 : union {
139 : uint32_t ElementIndex;
140 : wasm::WasmDataReference DataRef;
141 : };
142 : };
143 :
144 : struct InitFunction {
145 : uint32_t Priority;
146 : uint32_t Symbol;
147 : };
148 :
149 : struct ComdatEntry {
150 : ComdatKind Kind;
151 : uint32_t Index;
152 : };
153 :
154 8 : struct Comdat {
155 : StringRef Name;
156 : std::vector<ComdatEntry> Entries;
157 : };
158 :
159 783 : struct Section {
160 783 : explicit Section(SectionType SecType) : Type(SecType) {}
161 : virtual ~Section();
162 :
163 : SectionType Type;
164 : std::vector<Relocation> Relocations;
165 : };
166 :
167 : struct CustomSection : Section {
168 : explicit CustomSection(StringRef Name)
169 215 : : Section(wasm::WASM_SEC_CUSTOM), Name(Name) {}
170 :
171 : static bool classof(const Section *S) {
172 75 : return S->Type == wasm::WASM_SEC_CUSTOM;
173 : }
174 :
175 : StringRef Name;
176 : yaml::BinaryRef Payload;
177 : };
178 :
179 : struct NameSection : CustomSection {
180 136 : NameSection() : CustomSection("name") {}
181 :
182 14 : static bool classof(const Section *S) {
183 : auto C = dyn_cast<CustomSection>(S);
184 14 : return C && C->Name == "name";
185 : }
186 :
187 : std::vector<NameEntry> FunctionNames;
188 : };
189 :
190 : struct LinkingSection : CustomSection {
191 84 : LinkingSection() : CustomSection("linking") {}
192 :
193 12 : static bool classof(const Section *S) {
194 : auto C = dyn_cast<CustomSection>(S);
195 12 : return C && C->Name == "linking";
196 : }
197 :
198 : uint32_t Version;
199 : std::vector<SymbolInfo> SymbolTable;
200 : std::vector<SegmentInfo> SegmentInfos;
201 : std::vector<InitFunction> InitFunctions;
202 : std::vector<Comdat> Comdats;
203 : };
204 :
205 : struct TypeSection : Section {
206 210 : TypeSection() : Section(wasm::WASM_SEC_TYPE) {}
207 :
208 : static bool classof(const Section *S) {
209 0 : return S->Type == wasm::WASM_SEC_TYPE;
210 : }
211 :
212 : std::vector<Signature> Signatures;
213 : };
214 :
215 : struct ImportSection : Section {
216 86 : ImportSection() : Section(wasm::WASM_SEC_IMPORT) {}
217 :
218 : static bool classof(const Section *S) {
219 0 : return S->Type == wasm::WASM_SEC_IMPORT;
220 : }
221 :
222 : std::vector<Import> Imports;
223 : };
224 :
225 : struct FunctionSection : Section {
226 188 : FunctionSection() : Section(wasm::WASM_SEC_FUNCTION) {}
227 :
228 : static bool classof(const Section *S) {
229 0 : return S->Type == wasm::WASM_SEC_FUNCTION;
230 : }
231 :
232 : std::vector<uint32_t> FunctionTypes;
233 : };
234 :
235 : struct TableSection : Section {
236 144 : TableSection() : Section(wasm::WASM_SEC_TABLE) {}
237 :
238 : static bool classof(const Section *S) {
239 0 : return S->Type == wasm::WASM_SEC_TABLE;
240 : }
241 :
242 : std::vector<Table> Tables;
243 : };
244 :
245 : struct MemorySection : Section {
246 142 : MemorySection() : Section(wasm::WASM_SEC_MEMORY) {}
247 :
248 : static bool classof(const Section *S) {
249 0 : return S->Type == wasm::WASM_SEC_MEMORY;
250 : }
251 :
252 : std::vector<Limits> Memories;
253 : };
254 :
255 : struct GlobalSection : Section {
256 136 : GlobalSection() : Section(wasm::WASM_SEC_GLOBAL) {}
257 :
258 : static bool classof(const Section *S) {
259 0 : return S->Type == wasm::WASM_SEC_GLOBAL;
260 : }
261 :
262 : std::vector<Global> Globals;
263 : };
264 :
265 : struct ExportSection : Section {
266 128 : ExportSection() : Section(wasm::WASM_SEC_EXPORT) {}
267 :
268 : static bool classof(const Section *S) {
269 0 : return S->Type == wasm::WASM_SEC_EXPORT;
270 : }
271 :
272 : std::vector<Export> Exports;
273 : };
274 :
275 : struct StartSection : Section {
276 6 : StartSection() : Section(wasm::WASM_SEC_START) {}
277 :
278 : static bool classof(const Section *S) {
279 0 : return S->Type == wasm::WASM_SEC_START;
280 : }
281 :
282 : uint32_t StartFunction;
283 : };
284 :
285 : struct ElemSection : Section {
286 38 : ElemSection() : Section(wasm::WASM_SEC_ELEM) {}
287 :
288 : static bool classof(const Section *S) {
289 0 : return S->Type == wasm::WASM_SEC_ELEM;
290 : }
291 :
292 : std::vector<ElemSegment> Segments;
293 : };
294 :
295 : struct CodeSection : Section {
296 188 : CodeSection() : Section(wasm::WASM_SEC_CODE) {}
297 :
298 : static bool classof(const Section *S) {
299 0 : return S->Type == wasm::WASM_SEC_CODE;
300 : }
301 :
302 : std::vector<Function> Functions;
303 : };
304 :
305 : struct DataSection : Section {
306 72 : DataSection() : Section(wasm::WASM_SEC_DATA) {}
307 :
308 : static bool classof(const Section *S) {
309 0 : return S->Type == wasm::WASM_SEC_DATA;
310 : }
311 :
312 : std::vector<DataSegment> Segments;
313 : };
314 :
315 131 : struct Object {
316 : FileHeader Header;
317 : std::vector<std::unique_ptr<Section>> Sections;
318 : };
319 :
320 : } // end namespace WasmYAML
321 : } // end namespace llvm
322 :
323 : LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<llvm::WasmYAML::Section>)
324 : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Signature)
325 : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::ValueType)
326 : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Table)
327 : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Import)
328 : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Export)
329 : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::ElemSegment)
330 : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Limits)
331 : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::DataSegment)
332 : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Global)
333 : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Function)
334 : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::LocalDecl)
335 : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Relocation)
336 : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::NameEntry)
337 : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::SegmentInfo)
338 : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::SymbolInfo)
339 : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::InitFunction)
340 : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::ComdatEntry)
341 : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Comdat)
342 :
343 : namespace llvm {
344 : namespace yaml {
345 :
346 : template <> struct MappingTraits<WasmYAML::FileHeader> {
347 : static void mapping(IO &IO, WasmYAML::FileHeader &FileHdr);
348 : };
349 :
350 : template <> struct MappingTraits<std::unique_ptr<WasmYAML::Section>> {
351 : static void mapping(IO &IO, std::unique_ptr<WasmYAML::Section> &Section);
352 : };
353 :
354 : template <> struct MappingTraits<WasmYAML::Object> {
355 : static void mapping(IO &IO, WasmYAML::Object &Object);
356 : };
357 :
358 : template <> struct MappingTraits<WasmYAML::Import> {
359 : static void mapping(IO &IO, WasmYAML::Import &Import);
360 : };
361 :
362 : template <> struct MappingTraits<WasmYAML::Export> {
363 : static void mapping(IO &IO, WasmYAML::Export &Export);
364 : };
365 :
366 : template <> struct MappingTraits<WasmYAML::Global> {
367 : static void mapping(IO &IO, WasmYAML::Global &Global);
368 : };
369 :
370 : template <> struct ScalarBitSetTraits<WasmYAML::LimitFlags> {
371 : static void bitset(IO &IO, WasmYAML::LimitFlags &Value);
372 : };
373 :
374 : template <> struct ScalarBitSetTraits<WasmYAML::SymbolFlags> {
375 : static void bitset(IO &IO, WasmYAML::SymbolFlags &Value);
376 : };
377 :
378 : template <> struct ScalarEnumerationTraits<WasmYAML::SymbolKind> {
379 : static void enumeration(IO &IO, WasmYAML::SymbolKind &Kind);
380 : };
381 :
382 : template <> struct ScalarBitSetTraits<WasmYAML::SegmentFlags> {
383 : static void bitset(IO &IO, WasmYAML::SegmentFlags &Value);
384 : };
385 :
386 : template <> struct ScalarEnumerationTraits<WasmYAML::SectionType> {
387 : static void enumeration(IO &IO, WasmYAML::SectionType &Type);
388 : };
389 :
390 : template <> struct MappingTraits<WasmYAML::Signature> {
391 : static void mapping(IO &IO, WasmYAML::Signature &Signature);
392 : };
393 :
394 : template <> struct MappingTraits<WasmYAML::Table> {
395 : static void mapping(IO &IO, WasmYAML::Table &Table);
396 : };
397 :
398 : template <> struct MappingTraits<WasmYAML::Limits> {
399 : static void mapping(IO &IO, WasmYAML::Limits &Limits);
400 : };
401 :
402 : template <> struct MappingTraits<WasmYAML::Function> {
403 : static void mapping(IO &IO, WasmYAML::Function &Function);
404 : };
405 :
406 : template <> struct MappingTraits<WasmYAML::Relocation> {
407 : static void mapping(IO &IO, WasmYAML::Relocation &Relocation);
408 : };
409 :
410 : template <> struct MappingTraits<WasmYAML::NameEntry> {
411 : static void mapping(IO &IO, WasmYAML::NameEntry &NameEntry);
412 : };
413 :
414 : template <> struct MappingTraits<WasmYAML::SegmentInfo> {
415 : static void mapping(IO &IO, WasmYAML::SegmentInfo &SegmentInfo);
416 : };
417 :
418 : template <> struct MappingTraits<WasmYAML::LocalDecl> {
419 : static void mapping(IO &IO, WasmYAML::LocalDecl &LocalDecl);
420 : };
421 :
422 : template <> struct MappingTraits<wasm::WasmInitExpr> {
423 : static void mapping(IO &IO, wasm::WasmInitExpr &Expr);
424 : };
425 :
426 : template <> struct MappingTraits<WasmYAML::DataSegment> {
427 : static void mapping(IO &IO, WasmYAML::DataSegment &Segment);
428 : };
429 :
430 : template <> struct MappingTraits<WasmYAML::ElemSegment> {
431 : static void mapping(IO &IO, WasmYAML::ElemSegment &Segment);
432 : };
433 :
434 : template <> struct MappingTraits<WasmYAML::SymbolInfo> {
435 : static void mapping(IO &IO, WasmYAML::SymbolInfo &Info);
436 : };
437 :
438 : template <> struct MappingTraits<WasmYAML::InitFunction> {
439 : static void mapping(IO &IO, WasmYAML::InitFunction &Init);
440 : };
441 :
442 : template <> struct ScalarEnumerationTraits<WasmYAML::ComdatKind> {
443 : static void enumeration(IO &IO, WasmYAML::ComdatKind &Kind);
444 : };
445 :
446 : template <> struct MappingTraits<WasmYAML::ComdatEntry> {
447 : static void mapping(IO &IO, WasmYAML::ComdatEntry &ComdatEntry);
448 : };
449 :
450 : template <> struct MappingTraits<WasmYAML::Comdat> {
451 : static void mapping(IO &IO, WasmYAML::Comdat &Comdat);
452 : };
453 :
454 : template <> struct ScalarEnumerationTraits<WasmYAML::ValueType> {
455 : static void enumeration(IO &IO, WasmYAML::ValueType &Type);
456 : };
457 :
458 : template <> struct ScalarEnumerationTraits<WasmYAML::ExportKind> {
459 : static void enumeration(IO &IO, WasmYAML::ExportKind &Kind);
460 : };
461 :
462 : template <> struct ScalarEnumerationTraits<WasmYAML::TableType> {
463 : static void enumeration(IO &IO, WasmYAML::TableType &Type);
464 : };
465 :
466 : template <> struct ScalarEnumerationTraits<WasmYAML::Opcode> {
467 : static void enumeration(IO &IO, WasmYAML::Opcode &Opcode);
468 : };
469 :
470 : template <> struct ScalarEnumerationTraits<WasmYAML::RelocType> {
471 : static void enumeration(IO &IO, WasmYAML::RelocType &Kind);
472 : };
473 :
474 : } // end namespace yaml
475 : } // end namespace llvm
476 :
477 : #endif // LLVM_OBJECTYAML_WASMYAML_H
|
