Line data Source code
1 : //===- WasmYAML.cpp - Wasm YAMLIO implementation --------------------------===//
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 defines classes for handling the YAML representation of wasm.
11 : //
12 : //===----------------------------------------------------------------------===//
13 :
14 : #include "llvm/ObjectYAML/WasmYAML.h"
15 : #include "llvm/ADT/StringRef.h"
16 : #include "llvm/Support/Casting.h"
17 : #include "llvm/Support/ErrorHandling.h"
18 : #include "llvm/Support/YAMLTraits.h"
19 :
20 : namespace llvm {
21 :
22 : namespace WasmYAML {
23 :
24 : // Declared here rather than in the header to comply with:
25 : // http://llvm.org/docs/CodingStandards.html#provide-a-virtual-method-anchor-for-classes-in-headers
26 : Section::~Section() = default;
27 :
28 : } // end namespace WasmYAML
29 :
30 : namespace yaml {
31 :
32 131 : void MappingTraits<WasmYAML::FileHeader>::mapping(
33 : IO &IO, WasmYAML::FileHeader &FileHdr) {
34 131 : IO.mapRequired("Version", FileHdr.Version);
35 131 : }
36 :
37 131 : void MappingTraits<WasmYAML::Object>::mapping(IO &IO,
38 : WasmYAML::Object &Object) {
39 131 : IO.setContext(&Object);
40 262 : IO.mapTag("!WASM", true);
41 131 : IO.mapRequired("FileHeader", Object.Header);
42 131 : IO.mapOptional("Sections", Object.Sections);
43 131 : IO.setContext(nullptr);
44 131 : }
45 :
46 783 : static void commonSectionMapping(IO &IO, WasmYAML::Section &Section) {
47 783 : IO.mapRequired("Type", Section.Type);
48 783 : IO.mapOptional("Relocations", Section.Relocations);
49 783 : }
50 :
51 68 : static void sectionMapping(IO &IO, WasmYAML::NameSection &Section) {
52 68 : commonSectionMapping(IO, Section);
53 68 : IO.mapRequired("Name", Section.Name);
54 68 : IO.mapOptional("FunctionNames", Section.FunctionNames);
55 68 : }
56 :
57 42 : static void sectionMapping(IO &IO, WasmYAML::LinkingSection &Section) {
58 42 : commonSectionMapping(IO, Section);
59 42 : IO.mapRequired("Name", Section.Name);
60 42 : IO.mapRequired("Version", Section.Version);
61 42 : IO.mapOptional("SymbolTable", Section.SymbolTable);
62 42 : IO.mapOptional("SegmentInfo", Section.SegmentInfos);
63 42 : IO.mapOptional("InitFunctions", Section.InitFunctions);
64 42 : IO.mapOptional("Comdats", Section.Comdats);
65 42 : }
66 :
67 4 : static void sectionMapping(IO &IO, WasmYAML::CustomSection &Section) {
68 4 : commonSectionMapping(IO, Section);
69 4 : IO.mapRequired("Name", Section.Name);
70 4 : IO.mapRequired("Payload", Section.Payload);
71 4 : }
72 :
73 105 : static void sectionMapping(IO &IO, WasmYAML::TypeSection &Section) {
74 105 : commonSectionMapping(IO, Section);
75 105 : IO.mapOptional("Signatures", Section.Signatures);
76 105 : }
77 :
78 43 : static void sectionMapping(IO &IO, WasmYAML::ImportSection &Section) {
79 43 : commonSectionMapping(IO, Section);
80 43 : IO.mapOptional("Imports", Section.Imports);
81 43 : }
82 :
83 94 : static void sectionMapping(IO &IO, WasmYAML::FunctionSection &Section) {
84 94 : commonSectionMapping(IO, Section);
85 94 : IO.mapOptional("FunctionTypes", Section.FunctionTypes);
86 94 : }
87 :
88 72 : static void sectionMapping(IO &IO, WasmYAML::TableSection &Section) {
89 72 : commonSectionMapping(IO, Section);
90 72 : IO.mapOptional("Tables", Section.Tables);
91 72 : }
92 :
93 71 : static void sectionMapping(IO &IO, WasmYAML::MemorySection &Section) {
94 71 : commonSectionMapping(IO, Section);
95 71 : IO.mapOptional("Memories", Section.Memories);
96 71 : }
97 :
98 68 : static void sectionMapping(IO &IO, WasmYAML::GlobalSection &Section) {
99 68 : commonSectionMapping(IO, Section);
100 68 : IO.mapOptional("Globals", Section.Globals);
101 68 : }
102 :
103 64 : static void sectionMapping(IO &IO, WasmYAML::ExportSection &Section) {
104 64 : commonSectionMapping(IO, Section);
105 64 : IO.mapOptional("Exports", Section.Exports);
106 64 : }
107 :
108 3 : static void sectionMapping(IO &IO, WasmYAML::StartSection &Section) {
109 3 : commonSectionMapping(IO, Section);
110 3 : IO.mapOptional("StartFunction", Section.StartFunction);
111 3 : }
112 :
113 19 : static void sectionMapping(IO &IO, WasmYAML::ElemSection &Section) {
114 19 : commonSectionMapping(IO, Section);
115 19 : IO.mapOptional("Segments", Section.Segments);
116 19 : }
117 :
118 94 : static void sectionMapping(IO &IO, WasmYAML::CodeSection &Section) {
119 94 : commonSectionMapping(IO, Section);
120 94 : IO.mapRequired("Functions", Section.Functions);
121 94 : }
122 :
123 36 : static void sectionMapping(IO &IO, WasmYAML::DataSection &Section) {
124 36 : commonSectionMapping(IO, Section);
125 36 : IO.mapRequired("Segments", Section.Segments);
126 36 : }
127 :
128 783 : void MappingTraits<std::unique_ptr<WasmYAML::Section>>::mapping(
129 : IO &IO, std::unique_ptr<WasmYAML::Section> &Section) {
130 : WasmYAML::SectionType SectionType;
131 783 : if (IO.outputting())
132 708 : SectionType = Section->Type;
133 : else
134 : IO.mapRequired("Type", SectionType);
135 :
136 783 : switch (SectionType) {
137 114 : case wasm::WASM_SEC_CUSTOM: {
138 114 : StringRef SectionName;
139 114 : if (IO.outputting()) {
140 : auto CustomSection = cast<WasmYAML::CustomSection>(Section.get());
141 100 : SectionName = CustomSection->Name;
142 : } else {
143 : IO.mapRequired("Name", SectionName);
144 : }
145 : if (SectionName == "linking") {
146 42 : if (!IO.outputting())
147 11 : Section.reset(new WasmYAML::LinkingSection());
148 42 : sectionMapping(IO, *cast<WasmYAML::LinkingSection>(Section.get()));
149 : } else if (SectionName == "name") {
150 68 : if (!IO.outputting())
151 2 : Section.reset(new WasmYAML::NameSection());
152 68 : sectionMapping(IO, *cast<WasmYAML::NameSection>(Section.get()));
153 : } else {
154 4 : if (!IO.outputting())
155 1 : Section.reset(new WasmYAML::CustomSection(SectionName));
156 4 : sectionMapping(IO, *cast<WasmYAML::CustomSection>(Section.get()));
157 : }
158 : break;
159 : }
160 105 : case wasm::WASM_SEC_TYPE:
161 105 : if (!IO.outputting())
162 15 : Section.reset(new WasmYAML::TypeSection());
163 105 : sectionMapping(IO, *cast<WasmYAML::TypeSection>(Section.get()));
164 105 : break;
165 43 : case wasm::WASM_SEC_IMPORT:
166 43 : if (!IO.outputting())
167 8 : Section.reset(new WasmYAML::ImportSection());
168 43 : sectionMapping(IO, *cast<WasmYAML::ImportSection>(Section.get()));
169 43 : break;
170 94 : case wasm::WASM_SEC_FUNCTION:
171 94 : if (!IO.outputting())
172 9 : Section.reset(new WasmYAML::FunctionSection());
173 94 : sectionMapping(IO, *cast<WasmYAML::FunctionSection>(Section.get()));
174 94 : break;
175 72 : case wasm::WASM_SEC_TABLE:
176 72 : if (!IO.outputting())
177 2 : Section.reset(new WasmYAML::TableSection());
178 72 : sectionMapping(IO, *cast<WasmYAML::TableSection>(Section.get()));
179 72 : break;
180 71 : case wasm::WASM_SEC_MEMORY:
181 71 : if (!IO.outputting())
182 2 : Section.reset(new WasmYAML::MemorySection());
183 71 : sectionMapping(IO, *cast<WasmYAML::MemorySection>(Section.get()));
184 71 : break;
185 68 : case wasm::WASM_SEC_GLOBAL:
186 68 : if (!IO.outputting())
187 6 : Section.reset(new WasmYAML::GlobalSection());
188 68 : sectionMapping(IO, *cast<WasmYAML::GlobalSection>(Section.get()));
189 68 : break;
190 64 : case wasm::WASM_SEC_EXPORT:
191 64 : if (!IO.outputting())
192 3 : Section.reset(new WasmYAML::ExportSection());
193 64 : sectionMapping(IO, *cast<WasmYAML::ExportSection>(Section.get()));
194 64 : break;
195 3 : case wasm::WASM_SEC_START:
196 3 : if (!IO.outputting())
197 2 : Section.reset(new WasmYAML::StartSection());
198 3 : sectionMapping(IO, *cast<WasmYAML::StartSection>(Section.get()));
199 3 : break;
200 19 : case wasm::WASM_SEC_ELEM:
201 19 : if (!IO.outputting())
202 1 : Section.reset(new WasmYAML::ElemSection());
203 19 : sectionMapping(IO, *cast<WasmYAML::ElemSection>(Section.get()));
204 19 : break;
205 94 : case wasm::WASM_SEC_CODE:
206 94 : if (!IO.outputting())
207 9 : Section.reset(new WasmYAML::CodeSection());
208 94 : sectionMapping(IO, *cast<WasmYAML::CodeSection>(Section.get()));
209 94 : break;
210 36 : case wasm::WASM_SEC_DATA:
211 36 : if (!IO.outputting())
212 4 : Section.reset(new WasmYAML::DataSection());
213 36 : sectionMapping(IO, *cast<WasmYAML::DataSection>(Section.get()));
214 36 : break;
215 0 : default:
216 0 : llvm_unreachable("Unknown section type");
217 : }
218 783 : }
219 :
220 858 : void ScalarEnumerationTraits<WasmYAML::SectionType>::enumeration(
221 : IO &IO, WasmYAML::SectionType &Type) {
222 : #define ECase(X) IO.enumCase(Type, #X, wasm::WASM_SEC_##X);
223 858 : ECase(CUSTOM);
224 858 : ECase(TYPE);
225 858 : ECase(IMPORT);
226 858 : ECase(FUNCTION);
227 858 : ECase(TABLE);
228 858 : ECase(MEMORY);
229 858 : ECase(GLOBAL);
230 858 : ECase(EXPORT);
231 858 : ECase(START);
232 858 : ECase(ELEM);
233 858 : ECase(CODE);
234 858 : ECase(DATA);
235 : #undef ECase
236 858 : }
237 :
238 178 : void MappingTraits<WasmYAML::Signature>::mapping(
239 : IO &IO, WasmYAML::Signature &Signature) {
240 178 : IO.mapRequired("Index", Signature.Index);
241 178 : IO.mapRequired("ReturnType", Signature.ReturnType);
242 178 : IO.mapRequired("ParamTypes", Signature.ParamTypes);
243 178 : }
244 :
245 92 : void MappingTraits<WasmYAML::Table>::mapping(IO &IO, WasmYAML::Table &Table) {
246 92 : IO.mapRequired("ElemType", Table.ElemType);
247 92 : IO.mapRequired("Limits", Table.TableLimits);
248 92 : }
249 :
250 464 : void MappingTraits<WasmYAML::Function>::mapping(IO &IO,
251 : WasmYAML::Function &Function) {
252 464 : IO.mapRequired("Index", Function.Index);
253 464 : IO.mapRequired("Locals", Function.Locals);
254 464 : IO.mapRequired("Body", Function.Body);
255 464 : }
256 :
257 250 : void MappingTraits<WasmYAML::Relocation>::mapping(
258 : IO &IO, WasmYAML::Relocation &Relocation) {
259 250 : IO.mapRequired("Type", Relocation.Type);
260 250 : IO.mapRequired("Index", Relocation.Index);
261 250 : IO.mapRequired("Offset", Relocation.Offset);
262 250 : IO.mapOptional("Addend", Relocation.Addend, 0);
263 250 : }
264 :
265 422 : void MappingTraits<WasmYAML::NameEntry>::mapping(
266 : IO &IO, WasmYAML::NameEntry &NameEntry) {
267 422 : IO.mapRequired("Index", NameEntry.Index);
268 422 : IO.mapRequired("Name", NameEntry.Name);
269 422 : }
270 :
271 48 : void MappingTraits<WasmYAML::SegmentInfo>::mapping(
272 : IO &IO, WasmYAML::SegmentInfo &SegmentInfo) {
273 48 : IO.mapRequired("Index", SegmentInfo.Index);
274 48 : IO.mapRequired("Name", SegmentInfo.Name);
275 48 : IO.mapRequired("Alignment", SegmentInfo.Alignment);
276 48 : IO.mapRequired("Flags", SegmentInfo.Flags);
277 48 : }
278 :
279 15 : void MappingTraits<WasmYAML::LocalDecl>::mapping(
280 : IO &IO, WasmYAML::LocalDecl &LocalDecl) {
281 15 : IO.mapRequired("Type", LocalDecl.Type);
282 15 : IO.mapRequired("Count", LocalDecl.Count);
283 15 : }
284 :
285 186 : void MappingTraits<WasmYAML::Limits>::mapping(IO &IO,
286 : WasmYAML::Limits &Limits) {
287 186 : if (!IO.outputting() || Limits.Flags)
288 83 : IO.mapOptional("Flags", Limits.Flags);
289 186 : IO.mapRequired("Initial", Limits.Initial);
290 186 : if (!IO.outputting() || Limits.Flags & wasm::WASM_LIMITS_FLAG_HAS_MAX)
291 83 : IO.mapOptional("Maximum", Limits.Maximum);
292 186 : }
293 :
294 21 : void MappingTraits<WasmYAML::ElemSegment>::mapping(
295 : IO &IO, WasmYAML::ElemSegment &Segment) {
296 21 : IO.mapRequired("Offset", Segment.Offset);
297 21 : IO.mapRequired("Functions", Segment.Functions);
298 21 : }
299 :
300 106 : void MappingTraits<WasmYAML::Import>::mapping(IO &IO,
301 : WasmYAML::Import &Import) {
302 106 : IO.mapRequired("Module", Import.Module);
303 106 : IO.mapRequired("Field", Import.Field);
304 106 : IO.mapRequired("Kind", Import.Kind);
305 106 : if (Import.Kind == wasm::WASM_EXTERNAL_FUNCTION) {
306 50 : IO.mapRequired("SigIndex", Import.SigIndex);
307 56 : } else if (Import.Kind == wasm::WASM_EXTERNAL_GLOBAL) {
308 15 : IO.mapRequired("GlobalType", Import.GlobalImport.Type);
309 15 : IO.mapRequired("GlobalMutable", Import.GlobalImport.Mutable);
310 41 : } else if (Import.Kind == wasm::WASM_EXTERNAL_TABLE) {
311 20 : IO.mapRequired("Table", Import.TableImport);
312 21 : } else if (Import.Kind == wasm::WASM_EXTERNAL_MEMORY) {
313 21 : IO.mapRequired("Memory", Import.Memory);
314 : } else {
315 0 : llvm_unreachable("unhandled import type");
316 : }
317 106 : }
318 :
319 313 : void MappingTraits<WasmYAML::Export>::mapping(IO &IO,
320 : WasmYAML::Export &Export) {
321 313 : IO.mapRequired("Name", Export.Name);
322 313 : IO.mapRequired("Kind", Export.Kind);
323 313 : IO.mapRequired("Index", Export.Index);
324 313 : }
325 :
326 200 : void MappingTraits<WasmYAML::Global>::mapping(IO &IO,
327 : WasmYAML::Global &Global) {
328 200 : IO.mapRequired("Index", Global.Index);
329 200 : IO.mapRequired("Type", Global.Type);
330 200 : IO.mapRequired("Mutable", Global.Mutable);
331 200 : IO.mapRequired("InitExpr", Global.InitExpr);
332 200 : }
333 :
334 296 : void MappingTraits<wasm::WasmInitExpr>::mapping(IO &IO,
335 : wasm::WasmInitExpr &Expr) {
336 296 : WasmYAML::Opcode Op = Expr.Opcode;
337 : IO.mapRequired("Opcode", Op);
338 296 : Expr.Opcode = Op;
339 296 : switch (Expr.Opcode) {
340 281 : case wasm::WASM_OPCODE_I32_CONST:
341 281 : IO.mapRequired("Value", Expr.Value.Int32);
342 : break;
343 13 : case wasm::WASM_OPCODE_I64_CONST:
344 13 : IO.mapRequired("Value", Expr.Value.Int64);
345 : break;
346 0 : case wasm::WASM_OPCODE_F32_CONST:
347 0 : IO.mapRequired("Value", Expr.Value.Float32);
348 : break;
349 0 : case wasm::WASM_OPCODE_F64_CONST:
350 0 : IO.mapRequired("Value", Expr.Value.Float64);
351 : break;
352 2 : case wasm::WASM_OPCODE_GET_GLOBAL:
353 2 : IO.mapRequired("Index", Expr.Value.Global);
354 : break;
355 : }
356 296 : }
357 :
358 75 : void MappingTraits<WasmYAML::DataSegment>::mapping(
359 : IO &IO, WasmYAML::DataSegment &Segment) {
360 75 : IO.mapOptional("SectionOffset", Segment.SectionOffset);
361 75 : IO.mapRequired("MemoryIndex", Segment.MemoryIndex);
362 75 : IO.mapRequired("Offset", Segment.Offset);
363 75 : IO.mapRequired("Content", Segment.Content);
364 75 : }
365 :
366 19 : void MappingTraits<WasmYAML::InitFunction>::mapping(
367 : IO &IO, WasmYAML::InitFunction &Init) {
368 19 : IO.mapRequired("Priority", Init.Priority);
369 19 : IO.mapRequired("Symbol", Init.Symbol);
370 19 : }
371 :
372 5 : void ScalarEnumerationTraits<WasmYAML::ComdatKind>::enumeration(
373 : IO &IO, WasmYAML::ComdatKind &Kind) {
374 : #define ECase(X) IO.enumCase(Kind, #X, wasm::WASM_COMDAT_##X);
375 5 : ECase(FUNCTION);
376 5 : ECase(DATA);
377 : #undef ECase
378 5 : }
379 :
380 5 : void MappingTraits<WasmYAML::ComdatEntry>::mapping(
381 : IO &IO, WasmYAML::ComdatEntry &ComdatEntry) {
382 5 : IO.mapRequired("Kind", ComdatEntry.Kind);
383 5 : IO.mapRequired("Index", ComdatEntry.Index);
384 5 : }
385 :
386 3 : void MappingTraits<WasmYAML::Comdat>::mapping(IO &IO,
387 : WasmYAML::Comdat &Comdat) {
388 3 : IO.mapRequired("Name", Comdat.Name);
389 3 : IO.mapRequired("Entries", Comdat.Entries);
390 3 : }
391 :
392 326 : void MappingTraits<WasmYAML::SymbolInfo>::mapping(IO &IO,
393 : WasmYAML::SymbolInfo &Info) {
394 326 : IO.mapRequired("Index", Info.Index);
395 326 : IO.mapRequired("Kind", Info.Kind);
396 326 : IO.mapRequired("Name", Info.Name);
397 326 : IO.mapRequired("Flags", Info.Flags);
398 326 : if (Info.Kind == wasm::WASM_SYMBOL_TYPE_FUNCTION) {
399 252 : IO.mapRequired("Function", Info.ElementIndex);
400 74 : } else if (Info.Kind == wasm::WASM_SYMBOL_TYPE_GLOBAL) {
401 16 : IO.mapRequired("Global", Info.ElementIndex);
402 58 : } else if (Info.Kind == wasm::WASM_SYMBOL_TYPE_DATA) {
403 58 : if ((Info.Flags & wasm::WASM_SYMBOL_UNDEFINED) == 0) {
404 51 : IO.mapRequired("Segment", Info.DataRef.Segment);
405 51 : IO.mapOptional("Offset", Info.DataRef.Offset, 0u);
406 51 : IO.mapRequired("Size", Info.DataRef.Size);
407 : }
408 0 : } else if (Info.Kind == wasm::WASM_SYMBOL_TYPE_SECTION) {
409 0 : IO.mapRequired("Section", Info.ElementIndex);
410 : } else {
411 0 : llvm_unreachable("unsupported symbol kind");
412 : }
413 326 : }
414 :
415 81 : void ScalarBitSetTraits<WasmYAML::LimitFlags>::bitset(
416 : IO &IO, WasmYAML::LimitFlags &Value) {
417 : #define BCase(X) IO.bitSetCase(Value, #X, wasm::WASM_LIMITS_FLAG_##X)
418 81 : BCase(HAS_MAX);
419 : #undef BCase
420 81 : }
421 :
422 48 : void ScalarBitSetTraits<WasmYAML::SegmentFlags>::bitset(
423 48 : IO &IO, WasmYAML::SegmentFlags &Value) {}
424 :
425 326 : void ScalarBitSetTraits<WasmYAML::SymbolFlags>::bitset(
426 : IO &IO, WasmYAML::SymbolFlags &Value) {
427 : #define BCaseMask(M, X) \
428 : IO.maskedBitSetCase(Value, #X, wasm::WASM_SYMBOL_##X, wasm::WASM_SYMBOL_##M)
429 : // BCaseMask(BINDING_MASK, BINDING_GLOBAL);
430 326 : BCaseMask(BINDING_MASK, BINDING_WEAK);
431 326 : BCaseMask(BINDING_MASK, BINDING_LOCAL);
432 : // BCaseMask(VISIBILITY_MASK, VISIBILITY_DEFAULT);
433 326 : BCaseMask(VISIBILITY_MASK, VISIBILITY_HIDDEN);
434 326 : BCaseMask(UNDEFINED, UNDEFINED);
435 : #undef BCaseMask
436 326 : }
437 :
438 326 : void ScalarEnumerationTraits<WasmYAML::SymbolKind>::enumeration(
439 : IO &IO, WasmYAML::SymbolKind &Kind) {
440 : #define ECase(X) IO.enumCase(Kind, #X, wasm::WASM_SYMBOL_TYPE_##X);
441 326 : ECase(FUNCTION);
442 326 : ECase(DATA);
443 326 : ECase(GLOBAL);
444 326 : ECase(SECTION);
445 : #undef ECase
446 326 : }
447 :
448 482 : void ScalarEnumerationTraits<WasmYAML::ValueType>::enumeration(
449 : IO &IO, WasmYAML::ValueType &Type) {
450 : #define ECase(X) IO.enumCase(Type, #X, wasm::WASM_TYPE_##X);
451 482 : ECase(I32);
452 482 : ECase(I64);
453 482 : ECase(F32);
454 482 : ECase(F64);
455 482 : ECase(V128);
456 482 : ECase(ANYFUNC);
457 482 : ECase(FUNC);
458 482 : ECase(NORESULT);
459 : #undef ECase
460 482 : }
461 :
462 419 : void ScalarEnumerationTraits<WasmYAML::ExportKind>::enumeration(
463 : IO &IO, WasmYAML::ExportKind &Kind) {
464 : #define ECase(X) IO.enumCase(Kind, #X, wasm::WASM_EXTERNAL_##X);
465 419 : ECase(FUNCTION);
466 419 : ECase(TABLE);
467 419 : ECase(MEMORY);
468 419 : ECase(GLOBAL);
469 : #undef ECase
470 419 : }
471 :
472 296 : void ScalarEnumerationTraits<WasmYAML::Opcode>::enumeration(
473 : IO &IO, WasmYAML::Opcode &Code) {
474 : #define ECase(X) IO.enumCase(Code, #X, wasm::WASM_OPCODE_##X);
475 296 : ECase(END);
476 296 : ECase(I32_CONST);
477 296 : ECase(I64_CONST);
478 296 : ECase(F64_CONST);
479 296 : ECase(F32_CONST);
480 296 : ECase(GET_GLOBAL);
481 : #undef ECase
482 296 : }
483 :
484 92 : void ScalarEnumerationTraits<WasmYAML::TableType>::enumeration(
485 : IO &IO, WasmYAML::TableType &Type) {
486 : #define ECase(X) IO.enumCase(Type, #X, wasm::WASM_TYPE_##X);
487 92 : ECase(ANYFUNC);
488 : #undef ECase
489 92 : }
490 :
491 250 : void ScalarEnumerationTraits<WasmYAML::RelocType>::enumeration(
492 : IO &IO, WasmYAML::RelocType &Type) {
493 : #define WASM_RELOC(name, value) IO.enumCase(Type, #name, wasm::name);
494 : #include "llvm/BinaryFormat/WasmRelocs.def"
495 : #undef WASM_RELOC
496 250 : }
497 :
498 : } // end namespace yaml
499 :
500 : } // end namespace llvm
|
