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
19namespace llvm {
20
21namespace 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
25Section::~Section() = default;
26
27} // end namespace WasmYAML
28
29namespace yaml {
30
31void MappingTraits<WasmYAML::FileHeader>::mapping(
32    IO &IO, WasmYAML::FileHeader &FileHdr) {
33  IO.mapRequired("Version", FileHdr.Version);
34}
35
36void 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
45static void commonSectionMapping(IO &IO, WasmYAML::Section &Section) {
46  IO.mapRequired("Type", Section.Type);
47  IO.mapOptional("Relocations", Section.Relocations);
48}
49
50static 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
62static 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
70static 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
80static 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
88static 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
94static 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
100static void sectionMapping(IO &IO, WasmYAML::TypeSection &Section) {
101  commonSectionMapping(IO, Section);
102  IO.mapOptional("Signatures", Section.Signatures);
103}
104
105static void sectionMapping(IO &IO, WasmYAML::ImportSection &Section) {
106  commonSectionMapping(IO, Section);
107  IO.mapOptional("Imports", Section.Imports);
108}
109
110static void sectionMapping(IO &IO, WasmYAML::FunctionSection &Section) {
111  commonSectionMapping(IO, Section);
112  IO.mapOptional("FunctionTypes", Section.FunctionTypes);
113}
114
115static void sectionMapping(IO &IO, WasmYAML::TableSection &Section) {
116  commonSectionMapping(IO, Section);
117  IO.mapOptional("Tables", Section.Tables);
118}
119
120static void sectionMapping(IO &IO, WasmYAML::MemorySection &Section) {
121  commonSectionMapping(IO, Section);
122  IO.mapOptional("Memories", Section.Memories);
123}
124
125static void sectionMapping(IO &IO, WasmYAML::TagSection &Section) {
126  commonSectionMapping(IO, Section);
127  IO.mapOptional("TagTypes", Section.TagTypes);
128}
129
130static void sectionMapping(IO &IO, WasmYAML::GlobalSection &Section) {
131  commonSectionMapping(IO, Section);
132  IO.mapOptional("Globals", Section.Globals);
133}
134
135static void sectionMapping(IO &IO, WasmYAML::ExportSection &Section) {
136  commonSectionMapping(IO, Section);
137  IO.mapOptional("Exports", Section.Exports);
138}
139
140static void sectionMapping(IO &IO, WasmYAML::StartSection &Section) {
141  commonSectionMapping(IO, Section);
142  IO.mapOptional("StartFunction", Section.StartFunction);
143}
144
145static void sectionMapping(IO &IO, WasmYAML::ElemSection &Section) {
146  commonSectionMapping(IO, Section);
147  IO.mapOptional("Segments", Section.Segments);
148}
149
150static void sectionMapping(IO &IO, WasmYAML::CodeSection &Section) {
151  commonSectionMapping(IO, Section);
152  IO.mapRequired("Functions", Section.Functions);
153}
154
155static void sectionMapping(IO &IO, WasmYAML::DataSection &Section) {
156  commonSectionMapping(IO, Section);
157  IO.mapRequired("Segments", Section.Segments);
158}
159
160static void sectionMapping(IO &IO, WasmYAML::DataCountSection &Section) {
161  commonSectionMapping(IO, Section);
162  IO.mapRequired("Count", Section.Count);
163}
164
165void 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
279void 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
299void 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
306void 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
312void 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
319void 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
327void MappingTraits<WasmYAML::NameEntry>::mapping(
328    IO &IO, WasmYAML::NameEntry &NameEntry) {
329  IO.mapRequired("Index", NameEntry.Index);
330  IO.mapRequired("Name", NameEntry.Name);
331}
332
333void MappingTraits<WasmYAML::ProducerEntry>::mapping(
334    IO &IO, WasmYAML::ProducerEntry &ProducerEntry) {
335  IO.mapRequired("Name", ProducerEntry.Name);
336  IO.mapRequired("Version", ProducerEntry.Version);
337}
338
339void 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
348void MappingTraits<WasmYAML::FeatureEntry>::mapping(
349    IO &IO, WasmYAML::FeatureEntry &FeatureEntry) {
350  IO.mapRequired("Prefix", FeatureEntry.Prefix);
351  IO.mapRequired("Name", FeatureEntry.Name);
352}
353
354void 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
362void MappingTraits<WasmYAML::LocalDecl>::mapping(
363    IO &IO, WasmYAML::LocalDecl &LocalDecl) {
364  IO.mapRequired("Type", LocalDecl.Type);
365  IO.mapRequired("Count", LocalDecl.Count);
366}
367
368void 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
376void 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
389void 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
409void 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
416void 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
424void 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
458void 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
476void MappingTraits<WasmYAML::InitFunction>::mapping(
477    IO &IO, WasmYAML::InitFunction &Init) {
478  IO.mapRequired("Priority", Init.Priority);
479  IO.mapRequired("Symbol", Init.Symbol);
480}
481
482void 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
491void MappingTraits<WasmYAML::ComdatEntry>::mapping(
492    IO &IO, WasmYAML::ComdatEntry &ComdatEntry) {
493  IO.mapRequired("Kind", ComdatEntry.Kind);
494  IO.mapRequired("Index", ComdatEntry.Index);
495}
496
497void MappingTraits<WasmYAML::Comdat>::mapping(IO &IO,
498                                              WasmYAML::Comdat &Comdat) {
499  IO.mapRequired("Name", Comdat.Name);
500  IO.mapRequired("Entries", Comdat.Entries);
501}
502
503void 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
531void 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
538void MappingTraits<WasmYAML::DylinkExportInfo>::mapping(
539    IO &IO, WasmYAML::DylinkExportInfo &Info) {
540  IO.mapRequired("Name", Info.Name);
541  IO.mapRequired("Flags", Info.Flags);
542}
543
544void 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
553void 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
561void 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
578void 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
590void 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
604void 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
615void 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
628void 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
636void 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