1 //===- WasmYAML.cpp - Wasm YAMLIO implementation --------------------------===//
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 defines classes for handling the YAML representation of wasm.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "llvm/ObjectYAML/WasmYAML.h"
14 #include "llvm/ADT/StringRef.h"
15 #include "llvm/Support/Casting.h"
16 #include "llvm/Support/ErrorHandling.h"
17 #include "llvm/Support/YAMLTraits.h"
18 
19 namespace llvm {
20 
21 namespace WasmYAML {
22 
23 // Declared here rather than in the header to comply with:
24 // http://llvm.org/docs/CodingStandards.html#provide-a-virtual-method-anchor-for-classes-in-headers
25 Section::~Section() = default;
26 
27 } // end namespace WasmYAML
28 
29 namespace yaml {
30 
31 void MappingTraits<WasmYAML::FileHeader>::mapping(
32     IO &IO, WasmYAML::FileHeader &FileHdr) {
33   IO.mapRequired("Version", FileHdr.Version);
34 }
35 
36 void MappingTraits<WasmYAML::Object>::mapping(IO &IO,
37                                               WasmYAML::Object &Object) {
38   IO.setContext(&Object);
39   IO.mapTag("!WASM", true);
40   IO.mapRequired("FileHeader", Object.Header);
41   IO.mapOptional("Sections", Object.Sections);
42   IO.setContext(nullptr);
43 }
44 
45 static void commonSectionMapping(IO &IO, WasmYAML::Section &Section) {
46   IO.mapRequired("Type", Section.Type);
47   IO.mapOptional("Relocations", Section.Relocations);
48 }
49 
50 static void sectionMapping(IO &IO, WasmYAML::DylinkSection &Section) {
51   commonSectionMapping(IO, Section);
52   IO.mapRequired("Name", Section.Name);
53   IO.mapRequired("MemorySize", Section.MemorySize);
54   IO.mapRequired("MemoryAlignment", Section.MemoryAlignment);
55   IO.mapRequired("TableSize", Section.TableSize);
56   IO.mapRequired("TableAlignment", Section.TableAlignment);
57   IO.mapRequired("Needed", Section.Needed);
58   IO.mapOptional("ImportInfo", Section.ImportInfo);
59   IO.mapOptional("ExportInfo", Section.ExportInfo);
60 }
61 
62 static void sectionMapping(IO &IO, WasmYAML::NameSection &Section) {
63   commonSectionMapping(IO, Section);
64   IO.mapRequired("Name", Section.Name);
65   IO.mapOptional("FunctionNames", Section.FunctionNames);
66   IO.mapOptional("GlobalNames", Section.GlobalNames);
67   IO.mapOptional("DataSegmentNames", Section.DataSegmentNames);
68 }
69 
70 static void sectionMapping(IO &IO, WasmYAML::LinkingSection &Section) {
71   commonSectionMapping(IO, Section);
72   IO.mapRequired("Name", Section.Name);
73   IO.mapRequired("Version", Section.Version);
74   IO.mapOptional("SymbolTable", Section.SymbolTable);
75   IO.mapOptional("SegmentInfo", Section.SegmentInfos);
76   IO.mapOptional("InitFunctions", Section.InitFunctions);
77   IO.mapOptional("Comdats", Section.Comdats);
78 }
79 
80 static void sectionMapping(IO &IO, WasmYAML::ProducersSection &Section) {
81   commonSectionMapping(IO, Section);
82   IO.mapRequired("Name", Section.Name);
83   IO.mapOptional("Languages", Section.Languages);
84   IO.mapOptional("Tools", Section.Tools);
85   IO.mapOptional("SDKs", Section.SDKs);
86 }
87 
88 static void sectionMapping(IO &IO, WasmYAML::TargetFeaturesSection &Section) {
89   commonSectionMapping(IO, Section);
90   IO.mapRequired("Name", Section.Name);
91   IO.mapRequired("Features", Section.Features);
92 }
93 
94 static void sectionMapping(IO &IO, WasmYAML::CustomSection &Section) {
95   commonSectionMapping(IO, Section);
96   IO.mapRequired("Name", Section.Name);
97   IO.mapRequired("Payload", Section.Payload);
98 }
99 
100 static void sectionMapping(IO &IO, WasmYAML::TypeSection &Section) {
101   commonSectionMapping(IO, Section);
102   IO.mapOptional("Signatures", Section.Signatures);
103 }
104 
105 static void sectionMapping(IO &IO, WasmYAML::ImportSection &Section) {
106   commonSectionMapping(IO, Section);
107   IO.mapOptional("Imports", Section.Imports);
108 }
109 
110 static void sectionMapping(IO &IO, WasmYAML::FunctionSection &Section) {
111   commonSectionMapping(IO, Section);
112   IO.mapOptional("FunctionTypes", Section.FunctionTypes);
113 }
114 
115 static void sectionMapping(IO &IO, WasmYAML::TableSection &Section) {
116   commonSectionMapping(IO, Section);
117   IO.mapOptional("Tables", Section.Tables);
118 }
119 
120 static void sectionMapping(IO &IO, WasmYAML::MemorySection &Section) {
121   commonSectionMapping(IO, Section);
122   IO.mapOptional("Memories", Section.Memories);
123 }
124 
125 static void sectionMapping(IO &IO, WasmYAML::TagSection &Section) {
126   commonSectionMapping(IO, Section);
127   IO.mapOptional("TagTypes", Section.TagTypes);
128 }
129 
130 static void sectionMapping(IO &IO, WasmYAML::GlobalSection &Section) {
131   commonSectionMapping(IO, Section);
132   IO.mapOptional("Globals", Section.Globals);
133 }
134 
135 static void sectionMapping(IO &IO, WasmYAML::ExportSection &Section) {
136   commonSectionMapping(IO, Section);
137   IO.mapOptional("Exports", Section.Exports);
138 }
139 
140 static void sectionMapping(IO &IO, WasmYAML::StartSection &Section) {
141   commonSectionMapping(IO, Section);
142   IO.mapOptional("StartFunction", Section.StartFunction);
143 }
144 
145 static void sectionMapping(IO &IO, WasmYAML::ElemSection &Section) {
146   commonSectionMapping(IO, Section);
147   IO.mapOptional("Segments", Section.Segments);
148 }
149 
150 static void sectionMapping(IO &IO, WasmYAML::CodeSection &Section) {
151   commonSectionMapping(IO, Section);
152   IO.mapRequired("Functions", Section.Functions);
153 }
154 
155 static void sectionMapping(IO &IO, WasmYAML::DataSection &Section) {
156   commonSectionMapping(IO, Section);
157   IO.mapRequired("Segments", Section.Segments);
158 }
159 
160 static void sectionMapping(IO &IO, WasmYAML::DataCountSection &Section) {
161   commonSectionMapping(IO, Section);
162   IO.mapRequired("Count", Section.Count);
163 }
164 
165 void MappingTraits<std::unique_ptr<WasmYAML::Section>>::mapping(
166     IO &IO, std::unique_ptr<WasmYAML::Section> &Section) {
167   WasmYAML::SectionType SectionType;
168   if (IO.outputting())
169     SectionType = Section->Type;
170   else
171     IO.mapRequired("Type", SectionType);
172 
173   switch (SectionType) {
174   case wasm::WASM_SEC_CUSTOM: {
175     StringRef SectionName;
176     if (IO.outputting()) {
177       auto CustomSection = cast<WasmYAML::CustomSection>(Section.get());
178       SectionName = CustomSection->Name;
179     } else {
180       IO.mapRequired("Name", SectionName);
181     }
182     if (SectionName == "dylink" || SectionName == "dylink.0") {
183       if (!IO.outputting())
184         Section.reset(new WasmYAML::DylinkSection());
185       sectionMapping(IO, *cast<WasmYAML::DylinkSection>(Section.get()));
186     } else if (SectionName == "linking") {
187       if (!IO.outputting())
188         Section.reset(new WasmYAML::LinkingSection());
189       sectionMapping(IO, *cast<WasmYAML::LinkingSection>(Section.get()));
190     } else if (SectionName == "name") {
191       if (!IO.outputting())
192         Section.reset(new WasmYAML::NameSection());
193       sectionMapping(IO, *cast<WasmYAML::NameSection>(Section.get()));
194     } else if (SectionName == "producers") {
195       if (!IO.outputting())
196         Section.reset(new WasmYAML::ProducersSection());
197       sectionMapping(IO, *cast<WasmYAML::ProducersSection>(Section.get()));
198     } else if (SectionName == "target_features") {
199       if (!IO.outputting())
200         Section.reset(new WasmYAML::TargetFeaturesSection());
201       sectionMapping(IO, *cast<WasmYAML::TargetFeaturesSection>(Section.get()));
202     } else {
203       if (!IO.outputting())
204         Section.reset(new WasmYAML::CustomSection(SectionName));
205       sectionMapping(IO, *cast<WasmYAML::CustomSection>(Section.get()));
206     }
207     break;
208   }
209   case wasm::WASM_SEC_TYPE:
210     if (!IO.outputting())
211       Section.reset(new WasmYAML::TypeSection());
212     sectionMapping(IO, *cast<WasmYAML::TypeSection>(Section.get()));
213     break;
214   case wasm::WASM_SEC_IMPORT:
215     if (!IO.outputting())
216       Section.reset(new WasmYAML::ImportSection());
217     sectionMapping(IO, *cast<WasmYAML::ImportSection>(Section.get()));
218     break;
219   case wasm::WASM_SEC_FUNCTION:
220     if (!IO.outputting())
221       Section.reset(new WasmYAML::FunctionSection());
222     sectionMapping(IO, *cast<WasmYAML::FunctionSection>(Section.get()));
223     break;
224   case wasm::WASM_SEC_TABLE:
225     if (!IO.outputting())
226       Section.reset(new WasmYAML::TableSection());
227     sectionMapping(IO, *cast<WasmYAML::TableSection>(Section.get()));
228     break;
229   case wasm::WASM_SEC_MEMORY:
230     if (!IO.outputting())
231       Section.reset(new WasmYAML::MemorySection());
232     sectionMapping(IO, *cast<WasmYAML::MemorySection>(Section.get()));
233     break;
234   case wasm::WASM_SEC_TAG:
235     if (!IO.outputting())
236       Section.reset(new WasmYAML::TagSection());
237     sectionMapping(IO, *cast<WasmYAML::TagSection>(Section.get()));
238     break;
239   case wasm::WASM_SEC_GLOBAL:
240     if (!IO.outputting())
241       Section.reset(new WasmYAML::GlobalSection());
242     sectionMapping(IO, *cast<WasmYAML::GlobalSection>(Section.get()));
243     break;
244   case wasm::WASM_SEC_EXPORT:
245     if (!IO.outputting())
246       Section.reset(new WasmYAML::ExportSection());
247     sectionMapping(IO, *cast<WasmYAML::ExportSection>(Section.get()));
248     break;
249   case wasm::WASM_SEC_START:
250     if (!IO.outputting())
251       Section.reset(new WasmYAML::StartSection());
252     sectionMapping(IO, *cast<WasmYAML::StartSection>(Section.get()));
253     break;
254   case wasm::WASM_SEC_ELEM:
255     if (!IO.outputting())
256       Section.reset(new WasmYAML::ElemSection());
257     sectionMapping(IO, *cast<WasmYAML::ElemSection>(Section.get()));
258     break;
259   case wasm::WASM_SEC_CODE:
260     if (!IO.outputting())
261       Section.reset(new WasmYAML::CodeSection());
262     sectionMapping(IO, *cast<WasmYAML::CodeSection>(Section.get()));
263     break;
264   case wasm::WASM_SEC_DATA:
265     if (!IO.outputting())
266       Section.reset(new WasmYAML::DataSection());
267     sectionMapping(IO, *cast<WasmYAML::DataSection>(Section.get()));
268     break;
269   case wasm::WASM_SEC_DATACOUNT:
270     if (!IO.outputting())
271       Section.reset(new WasmYAML::DataCountSection());
272     sectionMapping(IO, *cast<WasmYAML::DataCountSection>(Section.get()));
273     break;
274   default:
275     llvm_unreachable("Unknown section type");
276   }
277 }
278 
279 void ScalarEnumerationTraits<WasmYAML::SectionType>::enumeration(
280     IO &IO, WasmYAML::SectionType &Type) {
281 #define ECase(X) IO.enumCase(Type, #X, wasm::WASM_SEC_##X);
282   ECase(CUSTOM);
283   ECase(TYPE);
284   ECase(IMPORT);
285   ECase(FUNCTION);
286   ECase(TABLE);
287   ECase(MEMORY);
288   ECase(GLOBAL);
289   ECase(TAG);
290   ECase(EXPORT);
291   ECase(START);
292   ECase(ELEM);
293   ECase(CODE);
294   ECase(DATA);
295   ECase(DATACOUNT);
296 #undef ECase
297 }
298 
299 void MappingTraits<WasmYAML::Signature>::mapping(
300     IO &IO, WasmYAML::Signature &Signature) {
301   IO.mapRequired("Index", Signature.Index);
302   IO.mapRequired("ParamTypes", Signature.ParamTypes);
303   IO.mapRequired("ReturnTypes", Signature.ReturnTypes);
304 }
305 
306 void MappingTraits<WasmYAML::Table>::mapping(IO &IO, WasmYAML::Table &Table) {
307   IO.mapRequired("Index", Table.Index);
308   IO.mapRequired("ElemType", Table.ElemType);
309   IO.mapRequired("Limits", Table.TableLimits);
310 }
311 
312 void MappingTraits<WasmYAML::Function>::mapping(IO &IO,
313                                                 WasmYAML::Function &Function) {
314   IO.mapRequired("Index", Function.Index);
315   IO.mapRequired("Locals", Function.Locals);
316   IO.mapRequired("Body", Function.Body);
317 }
318 
319 void MappingTraits<WasmYAML::Relocation>::mapping(
320     IO &IO, WasmYAML::Relocation &Relocation) {
321   IO.mapRequired("Type", Relocation.Type);
322   IO.mapRequired("Index", Relocation.Index);
323   IO.mapRequired("Offset", Relocation.Offset);
324   IO.mapOptional("Addend", Relocation.Addend, 0);
325 }
326 
327 void MappingTraits<WasmYAML::NameEntry>::mapping(
328     IO &IO, WasmYAML::NameEntry &NameEntry) {
329   IO.mapRequired("Index", NameEntry.Index);
330   IO.mapRequired("Name", NameEntry.Name);
331 }
332 
333 void MappingTraits<WasmYAML::ProducerEntry>::mapping(
334     IO &IO, WasmYAML::ProducerEntry &ProducerEntry) {
335   IO.mapRequired("Name", ProducerEntry.Name);
336   IO.mapRequired("Version", ProducerEntry.Version);
337 }
338 
339 void ScalarEnumerationTraits<WasmYAML::FeaturePolicyPrefix>::enumeration(
340     IO &IO, WasmYAML::FeaturePolicyPrefix &Kind) {
341 #define ECase(X) IO.enumCase(Kind, #X, wasm::WASM_FEATURE_PREFIX_##X);
342   ECase(USED);
343   ECase(REQUIRED);
344   ECase(DISALLOWED);
345 #undef ECase
346 }
347 
348 void MappingTraits<WasmYAML::FeatureEntry>::mapping(
349     IO &IO, WasmYAML::FeatureEntry &FeatureEntry) {
350   IO.mapRequired("Prefix", FeatureEntry.Prefix);
351   IO.mapRequired("Name", FeatureEntry.Name);
352 }
353 
354 void MappingTraits<WasmYAML::SegmentInfo>::mapping(
355     IO &IO, WasmYAML::SegmentInfo &SegmentInfo) {
356   IO.mapRequired("Index", SegmentInfo.Index);
357   IO.mapRequired("Name", SegmentInfo.Name);
358   IO.mapRequired("Alignment", SegmentInfo.Alignment);
359   IO.mapRequired("Flags", SegmentInfo.Flags);
360 }
361 
362 void MappingTraits<WasmYAML::LocalDecl>::mapping(
363     IO &IO, WasmYAML::LocalDecl &LocalDecl) {
364   IO.mapRequired("Type", LocalDecl.Type);
365   IO.mapRequired("Count", LocalDecl.Count);
366 }
367 
368 void MappingTraits<WasmYAML::Limits>::mapping(IO &IO,
369                                               WasmYAML::Limits &Limits) {
370   IO.mapOptional("Flags", Limits.Flags, 0);
371   IO.mapRequired("Minimum", Limits.Minimum);
372   if (!IO.outputting() || Limits.Flags & wasm::WASM_LIMITS_FLAG_HAS_MAX)
373     IO.mapOptional("Maximum", Limits.Maximum);
374 }
375 
376 void MappingTraits<WasmYAML::ElemSegment>::mapping(
377     IO &IO, WasmYAML::ElemSegment &Segment) {
378   IO.mapOptional("Flags", Segment.Flags, 0);
379   if (!IO.outputting() ||
380       Segment.Flags & wasm::WASM_ELEM_SEGMENT_HAS_TABLE_NUMBER)
381     IO.mapOptional("TableNumber", Segment.TableNumber);
382   if (!IO.outputting() ||
383       Segment.Flags & wasm::WASM_ELEM_SEGMENT_MASK_HAS_ELEM_KIND)
384     IO.mapOptional("ElemKind", Segment.ElemKind);
385   IO.mapRequired("Offset", Segment.Offset);
386   IO.mapRequired("Functions", Segment.Functions);
387 }
388 
389 void MappingTraits<WasmYAML::Import>::mapping(IO &IO,
390                                               WasmYAML::Import &Import) {
391   IO.mapRequired("Module", Import.Module);
392   IO.mapRequired("Field", Import.Field);
393   IO.mapRequired("Kind", Import.Kind);
394   if (Import.Kind == wasm::WASM_EXTERNAL_FUNCTION ||
395       Import.Kind == wasm::WASM_EXTERNAL_TAG) {
396     IO.mapRequired("SigIndex", Import.SigIndex);
397   } else if (Import.Kind == wasm::WASM_EXTERNAL_GLOBAL) {
398     IO.mapRequired("GlobalType", Import.GlobalImport.Type);
399     IO.mapRequired("GlobalMutable", Import.GlobalImport.Mutable);
400   } else if (Import.Kind == wasm::WASM_EXTERNAL_TABLE) {
401     IO.mapRequired("Table", Import.TableImport);
402   } else if (Import.Kind == wasm::WASM_EXTERNAL_MEMORY) {
403     IO.mapRequired("Memory", Import.Memory);
404   } else {
405     llvm_unreachable("unhandled import type");
406   }
407 }
408 
409 void MappingTraits<WasmYAML::Export>::mapping(IO &IO,
410                                               WasmYAML::Export &Export) {
411   IO.mapRequired("Name", Export.Name);
412   IO.mapRequired("Kind", Export.Kind);
413   IO.mapRequired("Index", Export.Index);
414 }
415 
416 void MappingTraits<WasmYAML::Global>::mapping(IO &IO,
417                                               WasmYAML::Global &Global) {
418   IO.mapRequired("Index", Global.Index);
419   IO.mapRequired("Type", Global.Type);
420   IO.mapRequired("Mutable", Global.Mutable);
421   IO.mapRequired("InitExpr", Global.Init);
422 }
423 
424 void MappingTraits<WasmYAML::InitExpr>::mapping(IO &IO,
425                                                 WasmYAML::InitExpr &Expr) {
426   IO.mapOptional("Extended", Expr.Extended, false);
427   if (Expr.Extended) {
428     IO.mapRequired("Body", Expr.Body);
429   } else {
430     WasmYAML::Opcode Op = Expr.Inst.Opcode;
431     IO.mapRequired("Opcode", Op);
432     Expr.Inst.Opcode = Op;
433     switch (Expr.Inst.Opcode) {
434     case wasm::WASM_OPCODE_I32_CONST:
435       IO.mapRequired("Value", Expr.Inst.Value.Int32);
436       break;
437     case wasm::WASM_OPCODE_I64_CONST:
438       IO.mapRequired("Value", Expr.Inst.Value.Int64);
439       break;
440     case wasm::WASM_OPCODE_F32_CONST:
441       IO.mapRequired("Value", Expr.Inst.Value.Float32);
442       break;
443     case wasm::WASM_OPCODE_F64_CONST:
444       IO.mapRequired("Value", Expr.Inst.Value.Float64);
445       break;
446     case wasm::WASM_OPCODE_GLOBAL_GET:
447       IO.mapRequired("Index", Expr.Inst.Value.Global);
448       break;
449     case wasm::WASM_OPCODE_REF_NULL: {
450       WasmYAML::ValueType Ty = wasm::WASM_TYPE_EXTERNREF;
451       IO.mapRequired("Type", Ty);
452       break;
453     }
454     }
455   }
456 }
457 
458 void MappingTraits<WasmYAML::DataSegment>::mapping(
459     IO &IO, WasmYAML::DataSegment &Segment) {
460   IO.mapOptional("SectionOffset", Segment.SectionOffset);
461   IO.mapRequired("InitFlags", Segment.InitFlags);
462   if (Segment.InitFlags & wasm::WASM_DATA_SEGMENT_HAS_MEMINDEX) {
463     IO.mapRequired("MemoryIndex", Segment.MemoryIndex);
464   } else {
465     Segment.MemoryIndex = 0;
466   }
467   if ((Segment.InitFlags & wasm::WASM_DATA_SEGMENT_IS_PASSIVE) == 0) {
468     IO.mapRequired("Offset", Segment.Offset);
469   } else {
470     Segment.Offset.Inst.Opcode = wasm::WASM_OPCODE_I32_CONST;
471     Segment.Offset.Inst.Value.Int32 = 0;
472   }
473   IO.mapRequired("Content", Segment.Content);
474 }
475 
476 void MappingTraits<WasmYAML::InitFunction>::mapping(
477     IO &IO, WasmYAML::InitFunction &Init) {
478   IO.mapRequired("Priority", Init.Priority);
479   IO.mapRequired("Symbol", Init.Symbol);
480 }
481 
482 void ScalarEnumerationTraits<WasmYAML::ComdatKind>::enumeration(
483     IO &IO, WasmYAML::ComdatKind &Kind) {
484 #define ECase(X) IO.enumCase(Kind, #X, wasm::WASM_COMDAT_##X);
485   ECase(FUNCTION);
486   ECase(DATA);
487   ECase(SECTION);
488 #undef ECase
489 }
490 
491 void MappingTraits<WasmYAML::ComdatEntry>::mapping(
492     IO &IO, WasmYAML::ComdatEntry &ComdatEntry) {
493   IO.mapRequired("Kind", ComdatEntry.Kind);
494   IO.mapRequired("Index", ComdatEntry.Index);
495 }
496 
497 void MappingTraits<WasmYAML::Comdat>::mapping(IO &IO,
498                                               WasmYAML::Comdat &Comdat) {
499   IO.mapRequired("Name", Comdat.Name);
500   IO.mapRequired("Entries", Comdat.Entries);
501 }
502 
503 void MappingTraits<WasmYAML::SymbolInfo>::mapping(IO &IO,
504                                                   WasmYAML::SymbolInfo &Info) {
505   IO.mapRequired("Index", Info.Index);
506   IO.mapRequired("Kind", Info.Kind);
507   if (Info.Kind != wasm::WASM_SYMBOL_TYPE_SECTION)
508     IO.mapRequired("Name", Info.Name);
509   IO.mapRequired("Flags", Info.Flags);
510   if (Info.Kind == wasm::WASM_SYMBOL_TYPE_FUNCTION) {
511     IO.mapRequired("Function", Info.ElementIndex);
512   } else if (Info.Kind == wasm::WASM_SYMBOL_TYPE_GLOBAL) {
513     IO.mapRequired("Global", Info.ElementIndex);
514   } else if (Info.Kind == wasm::WASM_SYMBOL_TYPE_TABLE) {
515     IO.mapRequired("Table", Info.ElementIndex);
516   } else if (Info.Kind == wasm::WASM_SYMBOL_TYPE_TAG) {
517     IO.mapRequired("Tag", Info.ElementIndex);
518   } else if (Info.Kind == wasm::WASM_SYMBOL_TYPE_DATA) {
519     if ((Info.Flags & wasm::WASM_SYMBOL_UNDEFINED) == 0) {
520       IO.mapRequired("Segment", Info.DataRef.Segment);
521       IO.mapOptional("Offset", Info.DataRef.Offset, 0u);
522       IO.mapRequired("Size", Info.DataRef.Size);
523     }
524   } else if (Info.Kind == wasm::WASM_SYMBOL_TYPE_SECTION) {
525     IO.mapRequired("Section", Info.ElementIndex);
526   } else {
527     llvm_unreachable("unsupported symbol kind");
528   }
529 }
530 
531 void MappingTraits<WasmYAML::DylinkImportInfo>::mapping(
532     IO &IO, WasmYAML::DylinkImportInfo &Info) {
533   IO.mapRequired("Module", Info.Module);
534   IO.mapRequired("Field", Info.Field);
535   IO.mapRequired("Flags", Info.Flags);
536 }
537 
538 void MappingTraits<WasmYAML::DylinkExportInfo>::mapping(
539     IO &IO, WasmYAML::DylinkExportInfo &Info) {
540   IO.mapRequired("Name", Info.Name);
541   IO.mapRequired("Flags", Info.Flags);
542 }
543 
544 void ScalarBitSetTraits<WasmYAML::LimitFlags>::bitset(
545     IO &IO, WasmYAML::LimitFlags &Value) {
546 #define BCase(X) IO.bitSetCase(Value, #X, wasm::WASM_LIMITS_FLAG_##X)
547   BCase(HAS_MAX);
548   BCase(IS_SHARED);
549   BCase(IS_64);
550 #undef BCase
551 }
552 
553 void ScalarBitSetTraits<WasmYAML::SegmentFlags>::bitset(
554     IO &IO, WasmYAML::SegmentFlags &Value) {
555 #define BCase(X) IO.bitSetCase(Value, #X, wasm::WASM_SEG_FLAG_##X)
556   BCase(STRINGS);
557   BCase(TLS);
558 #undef BCase
559 }
560 
561 void ScalarBitSetTraits<WasmYAML::SymbolFlags>::bitset(
562     IO &IO, WasmYAML::SymbolFlags &Value) {
563 #define BCaseMask(M, X)                                                        \
564   IO.maskedBitSetCase(Value, #X, wasm::WASM_SYMBOL_##X, wasm::WASM_SYMBOL_##M)
565   // BCaseMask(BINDING_MASK, BINDING_GLOBAL);
566   BCaseMask(BINDING_MASK, BINDING_WEAK);
567   BCaseMask(BINDING_MASK, BINDING_LOCAL);
568   // BCaseMask(VISIBILITY_MASK, VISIBILITY_DEFAULT);
569   BCaseMask(VISIBILITY_MASK, VISIBILITY_HIDDEN);
570   BCaseMask(UNDEFINED, UNDEFINED);
571   BCaseMask(EXPORTED, EXPORTED);
572   BCaseMask(EXPLICIT_NAME, EXPLICIT_NAME);
573   BCaseMask(NO_STRIP, NO_STRIP);
574   BCaseMask(TLS, TLS);
575 #undef BCaseMask
576 }
577 
578 void ScalarEnumerationTraits<WasmYAML::SymbolKind>::enumeration(
579     IO &IO, WasmYAML::SymbolKind &Kind) {
580 #define ECase(X) IO.enumCase(Kind, #X, wasm::WASM_SYMBOL_TYPE_##X);
581   ECase(FUNCTION);
582   ECase(DATA);
583   ECase(GLOBAL);
584   ECase(TABLE);
585   ECase(SECTION);
586   ECase(TAG);
587 #undef ECase
588 }
589 
590 void ScalarEnumerationTraits<WasmYAML::ValueType>::enumeration(
591     IO &IO, WasmYAML::ValueType &Type) {
592 #define ECase(X) IO.enumCase(Type, #X, wasm::WASM_TYPE_##X);
593   ECase(I32);
594   ECase(I64);
595   ECase(F32);
596   ECase(F64);
597   ECase(V128);
598   ECase(FUNCREF);
599   ECase(EXTERNREF);
600   ECase(FUNC);
601 #undef ECase
602 }
603 
604 void ScalarEnumerationTraits<WasmYAML::ExportKind>::enumeration(
605     IO &IO, WasmYAML::ExportKind &Kind) {
606 #define ECase(X) IO.enumCase(Kind, #X, wasm::WASM_EXTERNAL_##X);
607   ECase(FUNCTION);
608   ECase(TABLE);
609   ECase(MEMORY);
610   ECase(GLOBAL);
611   ECase(TAG);
612 #undef ECase
613 }
614 
615 void ScalarEnumerationTraits<WasmYAML::Opcode>::enumeration(
616     IO &IO, WasmYAML::Opcode &Code) {
617 #define ECase(X) IO.enumCase(Code, #X, wasm::WASM_OPCODE_##X);
618   ECase(END);
619   ECase(I32_CONST);
620   ECase(I64_CONST);
621   ECase(F64_CONST);
622   ECase(F32_CONST);
623   ECase(GLOBAL_GET);
624   ECase(REF_NULL);
625 #undef ECase
626 }
627 
628 void ScalarEnumerationTraits<WasmYAML::TableType>::enumeration(
629     IO &IO, WasmYAML::TableType &Type) {
630 #define ECase(X) IO.enumCase(Type, #X, wasm::WASM_TYPE_##X);
631   ECase(FUNCREF);
632   ECase(EXTERNREF);
633 #undef ECase
634 }
635 
636 void ScalarEnumerationTraits<WasmYAML::RelocType>::enumeration(
637     IO &IO, WasmYAML::RelocType &Type) {
638 #define WASM_RELOC(name, value) IO.enumCase(Type, #name, wasm::name);
639 #include "llvm/BinaryFormat/WasmRelocs.def"
640 #undef WASM_RELOC
641   IO.enumFallback<Hex32>(Type);
642 }
643 
644 } // end namespace yaml
645 
646 } // end namespace llvm
647