[MIPS GlobalISel] Select MSA vector generic and builtin add
[llvm-complete.git] / lib / ObjectYAML / WasmYAML.cpp
blob232d5122004a7c6fcc00c3e30042a294e9b62d2b
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.
11 //===----------------------------------------------------------------------===//
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"
19 namespace llvm {
21 namespace WasmYAML {
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;
27 } // end namespace WasmYAML
29 namespace yaml {
31 void MappingTraits<WasmYAML::FileHeader>::mapping(
32 IO &IO, WasmYAML::FileHeader &FileHdr) {
33 IO.mapRequired("Version", FileHdr.Version);
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);
45 static void commonSectionMapping(IO &IO, WasmYAML::Section &Section) {
46 IO.mapRequired("Type", Section.Type);
47 IO.mapOptional("Relocations", Section.Relocations);
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);
60 static void sectionMapping(IO &IO, WasmYAML::NameSection &Section) {
61 commonSectionMapping(IO, Section);
62 IO.mapRequired("Name", Section.Name);
63 IO.mapOptional("FunctionNames", Section.FunctionNames);
66 static void sectionMapping(IO &IO, WasmYAML::LinkingSection &Section) {
67 commonSectionMapping(IO, Section);
68 IO.mapRequired("Name", Section.Name);
69 IO.mapRequired("Version", Section.Version);
70 IO.mapOptional("SymbolTable", Section.SymbolTable);
71 IO.mapOptional("SegmentInfo", Section.SegmentInfos);
72 IO.mapOptional("InitFunctions", Section.InitFunctions);
73 IO.mapOptional("Comdats", Section.Comdats);
76 static void sectionMapping(IO &IO, WasmYAML::ProducersSection &Section) {
77 commonSectionMapping(IO, Section);
78 IO.mapRequired("Name", Section.Name);
79 IO.mapOptional("Languages", Section.Languages);
80 IO.mapOptional("Tools", Section.Tools);
81 IO.mapOptional("SDKs", Section.SDKs);
84 static void sectionMapping(IO &IO, WasmYAML::TargetFeaturesSection &Section) {
85 commonSectionMapping(IO, Section);
86 IO.mapRequired("Name", Section.Name);
87 IO.mapRequired("Features", Section.Features);
90 static void sectionMapping(IO &IO, WasmYAML::CustomSection &Section) {
91 commonSectionMapping(IO, Section);
92 IO.mapRequired("Name", Section.Name);
93 IO.mapRequired("Payload", Section.Payload);
96 static void sectionMapping(IO &IO, WasmYAML::TypeSection &Section) {
97 commonSectionMapping(IO, Section);
98 IO.mapOptional("Signatures", Section.Signatures);
101 static void sectionMapping(IO &IO, WasmYAML::ImportSection &Section) {
102 commonSectionMapping(IO, Section);
103 IO.mapOptional("Imports", Section.Imports);
106 static void sectionMapping(IO &IO, WasmYAML::FunctionSection &Section) {
107 commonSectionMapping(IO, Section);
108 IO.mapOptional("FunctionTypes", Section.FunctionTypes);
111 static void sectionMapping(IO &IO, WasmYAML::TableSection &Section) {
112 commonSectionMapping(IO, Section);
113 IO.mapOptional("Tables", Section.Tables);
116 static void sectionMapping(IO &IO, WasmYAML::MemorySection &Section) {
117 commonSectionMapping(IO, Section);
118 IO.mapOptional("Memories", Section.Memories);
121 static void sectionMapping(IO &IO, WasmYAML::GlobalSection &Section) {
122 commonSectionMapping(IO, Section);
123 IO.mapOptional("Globals", Section.Globals);
126 static void sectionMapping(IO &IO, WasmYAML::EventSection &Section) {
127 commonSectionMapping(IO, Section);
128 IO.mapOptional("Events", Section.Events);
131 static void sectionMapping(IO &IO, WasmYAML::ExportSection &Section) {
132 commonSectionMapping(IO, Section);
133 IO.mapOptional("Exports", Section.Exports);
136 static void sectionMapping(IO &IO, WasmYAML::StartSection &Section) {
137 commonSectionMapping(IO, Section);
138 IO.mapOptional("StartFunction", Section.StartFunction);
141 static void sectionMapping(IO &IO, WasmYAML::ElemSection &Section) {
142 commonSectionMapping(IO, Section);
143 IO.mapOptional("Segments", Section.Segments);
146 static void sectionMapping(IO &IO, WasmYAML::CodeSection &Section) {
147 commonSectionMapping(IO, Section);
148 IO.mapRequired("Functions", Section.Functions);
151 static void sectionMapping(IO &IO, WasmYAML::DataSection &Section) {
152 commonSectionMapping(IO, Section);
153 IO.mapRequired("Segments", Section.Segments);
156 static void sectionMapping(IO &IO, WasmYAML::DataCountSection &Section) {
157 commonSectionMapping(IO, Section);
158 IO.mapRequired("Count", Section.Count);
161 void MappingTraits<std::unique_ptr<WasmYAML::Section>>::mapping(
162 IO &IO, std::unique_ptr<WasmYAML::Section> &Section) {
163 WasmYAML::SectionType SectionType;
164 if (IO.outputting())
165 SectionType = Section->Type;
166 else
167 IO.mapRequired("Type", SectionType);
169 switch (SectionType) {
170 case wasm::WASM_SEC_CUSTOM: {
171 StringRef SectionName;
172 if (IO.outputting()) {
173 auto CustomSection = cast<WasmYAML::CustomSection>(Section.get());
174 SectionName = CustomSection->Name;
175 } else {
176 IO.mapRequired("Name", SectionName);
178 if (SectionName == "dylink") {
179 if (!IO.outputting())
180 Section.reset(new WasmYAML::DylinkSection());
181 sectionMapping(IO, *cast<WasmYAML::DylinkSection>(Section.get()));
182 } else if (SectionName == "linking") {
183 if (!IO.outputting())
184 Section.reset(new WasmYAML::LinkingSection());
185 sectionMapping(IO, *cast<WasmYAML::LinkingSection>(Section.get()));
186 } else if (SectionName == "name") {
187 if (!IO.outputting())
188 Section.reset(new WasmYAML::NameSection());
189 sectionMapping(IO, *cast<WasmYAML::NameSection>(Section.get()));
190 } else if (SectionName == "producers") {
191 if (!IO.outputting())
192 Section.reset(new WasmYAML::ProducersSection());
193 sectionMapping(IO, *cast<WasmYAML::ProducersSection>(Section.get()));
194 } else if (SectionName == "target_features") {
195 if (!IO.outputting())
196 Section.reset(new WasmYAML::TargetFeaturesSection());
197 sectionMapping(IO, *cast<WasmYAML::TargetFeaturesSection>(Section.get()));
198 } else {
199 if (!IO.outputting())
200 Section.reset(new WasmYAML::CustomSection(SectionName));
201 sectionMapping(IO, *cast<WasmYAML::CustomSection>(Section.get()));
203 break;
205 case wasm::WASM_SEC_TYPE:
206 if (!IO.outputting())
207 Section.reset(new WasmYAML::TypeSection());
208 sectionMapping(IO, *cast<WasmYAML::TypeSection>(Section.get()));
209 break;
210 case wasm::WASM_SEC_IMPORT:
211 if (!IO.outputting())
212 Section.reset(new WasmYAML::ImportSection());
213 sectionMapping(IO, *cast<WasmYAML::ImportSection>(Section.get()));
214 break;
215 case wasm::WASM_SEC_FUNCTION:
216 if (!IO.outputting())
217 Section.reset(new WasmYAML::FunctionSection());
218 sectionMapping(IO, *cast<WasmYAML::FunctionSection>(Section.get()));
219 break;
220 case wasm::WASM_SEC_TABLE:
221 if (!IO.outputting())
222 Section.reset(new WasmYAML::TableSection());
223 sectionMapping(IO, *cast<WasmYAML::TableSection>(Section.get()));
224 break;
225 case wasm::WASM_SEC_MEMORY:
226 if (!IO.outputting())
227 Section.reset(new WasmYAML::MemorySection());
228 sectionMapping(IO, *cast<WasmYAML::MemorySection>(Section.get()));
229 break;
230 case wasm::WASM_SEC_GLOBAL:
231 if (!IO.outputting())
232 Section.reset(new WasmYAML::GlobalSection());
233 sectionMapping(IO, *cast<WasmYAML::GlobalSection>(Section.get()));
234 break;
235 case wasm::WASM_SEC_EVENT:
236 if (!IO.outputting())
237 Section.reset(new WasmYAML::EventSection());
238 sectionMapping(IO, *cast<WasmYAML::EventSection>(Section.get()));
239 break;
240 case wasm::WASM_SEC_EXPORT:
241 if (!IO.outputting())
242 Section.reset(new WasmYAML::ExportSection());
243 sectionMapping(IO, *cast<WasmYAML::ExportSection>(Section.get()));
244 break;
245 case wasm::WASM_SEC_START:
246 if (!IO.outputting())
247 Section.reset(new WasmYAML::StartSection());
248 sectionMapping(IO, *cast<WasmYAML::StartSection>(Section.get()));
249 break;
250 case wasm::WASM_SEC_ELEM:
251 if (!IO.outputting())
252 Section.reset(new WasmYAML::ElemSection());
253 sectionMapping(IO, *cast<WasmYAML::ElemSection>(Section.get()));
254 break;
255 case wasm::WASM_SEC_CODE:
256 if (!IO.outputting())
257 Section.reset(new WasmYAML::CodeSection());
258 sectionMapping(IO, *cast<WasmYAML::CodeSection>(Section.get()));
259 break;
260 case wasm::WASM_SEC_DATA:
261 if (!IO.outputting())
262 Section.reset(new WasmYAML::DataSection());
263 sectionMapping(IO, *cast<WasmYAML::DataSection>(Section.get()));
264 break;
265 case wasm::WASM_SEC_DATACOUNT:
266 if (!IO.outputting())
267 Section.reset(new WasmYAML::DataCountSection());
268 sectionMapping(IO, *cast<WasmYAML::DataCountSection>(Section.get()));
269 break;
270 default:
271 llvm_unreachable("Unknown section type");
275 void ScalarEnumerationTraits<WasmYAML::SectionType>::enumeration(
276 IO &IO, WasmYAML::SectionType &Type) {
277 #define ECase(X) IO.enumCase(Type, #X, wasm::WASM_SEC_##X);
278 ECase(CUSTOM);
279 ECase(TYPE);
280 ECase(IMPORT);
281 ECase(FUNCTION);
282 ECase(TABLE);
283 ECase(MEMORY);
284 ECase(GLOBAL);
285 ECase(EVENT);
286 ECase(EXPORT);
287 ECase(START);
288 ECase(ELEM);
289 ECase(CODE);
290 ECase(DATA);
291 ECase(DATACOUNT);
292 #undef ECase
295 void MappingTraits<WasmYAML::Signature>::mapping(
296 IO &IO, WasmYAML::Signature &Signature) {
297 IO.mapRequired("Index", Signature.Index);
298 IO.mapRequired("ParamTypes", Signature.ParamTypes);
299 IO.mapRequired("ReturnTypes", Signature.ReturnTypes);
302 void MappingTraits<WasmYAML::Table>::mapping(IO &IO, WasmYAML::Table &Table) {
303 IO.mapRequired("ElemType", Table.ElemType);
304 IO.mapRequired("Limits", Table.TableLimits);
307 void MappingTraits<WasmYAML::Function>::mapping(IO &IO,
308 WasmYAML::Function &Function) {
309 IO.mapRequired("Index", Function.Index);
310 IO.mapRequired("Locals", Function.Locals);
311 IO.mapRequired("Body", Function.Body);
314 void MappingTraits<WasmYAML::Relocation>::mapping(
315 IO &IO, WasmYAML::Relocation &Relocation) {
316 IO.mapRequired("Type", Relocation.Type);
317 IO.mapRequired("Index", Relocation.Index);
318 IO.mapRequired("Offset", Relocation.Offset);
319 IO.mapOptional("Addend", Relocation.Addend, 0);
322 void MappingTraits<WasmYAML::NameEntry>::mapping(
323 IO &IO, WasmYAML::NameEntry &NameEntry) {
324 IO.mapRequired("Index", NameEntry.Index);
325 IO.mapRequired("Name", NameEntry.Name);
328 void MappingTraits<WasmYAML::ProducerEntry>::mapping(
329 IO &IO, WasmYAML::ProducerEntry &ProducerEntry) {
330 IO.mapRequired("Name", ProducerEntry.Name);
331 IO.mapRequired("Version", ProducerEntry.Version);
334 void ScalarEnumerationTraits<WasmYAML::FeaturePolicyPrefix>::enumeration(
335 IO &IO, WasmYAML::FeaturePolicyPrefix &Kind) {
336 #define ECase(X) IO.enumCase(Kind, #X, wasm::WASM_FEATURE_PREFIX_##X);
337 ECase(USED);
338 ECase(REQUIRED);
339 ECase(DISALLOWED);
340 #undef ECase
343 void MappingTraits<WasmYAML::FeatureEntry>::mapping(
344 IO &IO, WasmYAML::FeatureEntry &FeatureEntry) {
345 IO.mapRequired("Prefix", FeatureEntry.Prefix);
346 IO.mapRequired("Name", FeatureEntry.Name);
349 void MappingTraits<WasmYAML::SegmentInfo>::mapping(
350 IO &IO, WasmYAML::SegmentInfo &SegmentInfo) {
351 IO.mapRequired("Index", SegmentInfo.Index);
352 IO.mapRequired("Name", SegmentInfo.Name);
353 IO.mapRequired("Alignment", SegmentInfo.Alignment);
354 IO.mapRequired("Flags", SegmentInfo.Flags);
357 void MappingTraits<WasmYAML::LocalDecl>::mapping(
358 IO &IO, WasmYAML::LocalDecl &LocalDecl) {
359 IO.mapRequired("Type", LocalDecl.Type);
360 IO.mapRequired("Count", LocalDecl.Count);
363 void MappingTraits<WasmYAML::Limits>::mapping(IO &IO,
364 WasmYAML::Limits &Limits) {
365 if (!IO.outputting() || Limits.Flags)
366 IO.mapOptional("Flags", Limits.Flags);
367 IO.mapRequired("Initial", Limits.Initial);
368 if (!IO.outputting() || Limits.Flags & wasm::WASM_LIMITS_FLAG_HAS_MAX)
369 IO.mapOptional("Maximum", Limits.Maximum);
372 void MappingTraits<WasmYAML::ElemSegment>::mapping(
373 IO &IO, WasmYAML::ElemSegment &Segment) {
374 IO.mapRequired("Offset", Segment.Offset);
375 IO.mapRequired("Functions", Segment.Functions);
378 void MappingTraits<WasmYAML::Import>::mapping(IO &IO,
379 WasmYAML::Import &Import) {
380 IO.mapRequired("Module", Import.Module);
381 IO.mapRequired("Field", Import.Field);
382 IO.mapRequired("Kind", Import.Kind);
383 if (Import.Kind == wasm::WASM_EXTERNAL_FUNCTION) {
384 IO.mapRequired("SigIndex", Import.SigIndex);
385 } else if (Import.Kind == wasm::WASM_EXTERNAL_GLOBAL) {
386 IO.mapRequired("GlobalType", Import.GlobalImport.Type);
387 IO.mapRequired("GlobalMutable", Import.GlobalImport.Mutable);
388 } else if (Import.Kind == wasm::WASM_EXTERNAL_EVENT) {
389 IO.mapRequired("EventAttribute", Import.EventImport.Attribute);
390 IO.mapRequired("EventSigIndex", Import.EventImport.SigIndex);
391 } else if (Import.Kind == wasm::WASM_EXTERNAL_TABLE) {
392 IO.mapRequired("Table", Import.TableImport);
393 } else if (Import.Kind == wasm::WASM_EXTERNAL_MEMORY) {
394 IO.mapRequired("Memory", Import.Memory);
395 } else {
396 llvm_unreachable("unhandled import type");
400 void MappingTraits<WasmYAML::Export>::mapping(IO &IO,
401 WasmYAML::Export &Export) {
402 IO.mapRequired("Name", Export.Name);
403 IO.mapRequired("Kind", Export.Kind);
404 IO.mapRequired("Index", Export.Index);
407 void MappingTraits<WasmYAML::Global>::mapping(IO &IO,
408 WasmYAML::Global &Global) {
409 IO.mapRequired("Index", Global.Index);
410 IO.mapRequired("Type", Global.Type);
411 IO.mapRequired("Mutable", Global.Mutable);
412 IO.mapRequired("InitExpr", Global.InitExpr);
415 void MappingTraits<wasm::WasmInitExpr>::mapping(IO &IO,
416 wasm::WasmInitExpr &Expr) {
417 WasmYAML::Opcode Op = Expr.Opcode;
418 IO.mapRequired("Opcode", Op);
419 Expr.Opcode = Op;
420 switch (Expr.Opcode) {
421 case wasm::WASM_OPCODE_I32_CONST:
422 IO.mapRequired("Value", Expr.Value.Int32);
423 break;
424 case wasm::WASM_OPCODE_I64_CONST:
425 IO.mapRequired("Value", Expr.Value.Int64);
426 break;
427 case wasm::WASM_OPCODE_F32_CONST:
428 IO.mapRequired("Value", Expr.Value.Float32);
429 break;
430 case wasm::WASM_OPCODE_F64_CONST:
431 IO.mapRequired("Value", Expr.Value.Float64);
432 break;
433 case wasm::WASM_OPCODE_GLOBAL_GET:
434 IO.mapRequired("Index", Expr.Value.Global);
435 break;
439 void MappingTraits<WasmYAML::DataSegment>::mapping(
440 IO &IO, WasmYAML::DataSegment &Segment) {
441 IO.mapOptional("SectionOffset", Segment.SectionOffset);
442 IO.mapRequired("InitFlags", Segment.InitFlags);
443 if (Segment.InitFlags & wasm::WASM_SEGMENT_HAS_MEMINDEX) {
444 IO.mapRequired("MemoryIndex", Segment.MemoryIndex);
445 } else {
446 Segment.MemoryIndex = 0;
448 if ((Segment.InitFlags & wasm::WASM_SEGMENT_IS_PASSIVE) == 0) {
449 IO.mapRequired("Offset", Segment.Offset);
450 } else {
451 Segment.Offset.Opcode = wasm::WASM_OPCODE_I32_CONST;
452 Segment.Offset.Value.Int32 = 0;
454 IO.mapRequired("Content", Segment.Content);
457 void MappingTraits<WasmYAML::InitFunction>::mapping(
458 IO &IO, WasmYAML::InitFunction &Init) {
459 IO.mapRequired("Priority", Init.Priority);
460 IO.mapRequired("Symbol", Init.Symbol);
463 void ScalarEnumerationTraits<WasmYAML::ComdatKind>::enumeration(
464 IO &IO, WasmYAML::ComdatKind &Kind) {
465 #define ECase(X) IO.enumCase(Kind, #X, wasm::WASM_COMDAT_##X);
466 ECase(FUNCTION);
467 ECase(DATA);
468 #undef ECase
471 void MappingTraits<WasmYAML::ComdatEntry>::mapping(
472 IO &IO, WasmYAML::ComdatEntry &ComdatEntry) {
473 IO.mapRequired("Kind", ComdatEntry.Kind);
474 IO.mapRequired("Index", ComdatEntry.Index);
477 void MappingTraits<WasmYAML::Comdat>::mapping(IO &IO,
478 WasmYAML::Comdat &Comdat) {
479 IO.mapRequired("Name", Comdat.Name);
480 IO.mapRequired("Entries", Comdat.Entries);
483 void MappingTraits<WasmYAML::SymbolInfo>::mapping(IO &IO,
484 WasmYAML::SymbolInfo &Info) {
485 IO.mapRequired("Index", Info.Index);
486 IO.mapRequired("Kind", Info.Kind);
487 if (Info.Kind != wasm::WASM_SYMBOL_TYPE_SECTION)
488 IO.mapRequired("Name", Info.Name);
489 IO.mapRequired("Flags", Info.Flags);
490 if (Info.Kind == wasm::WASM_SYMBOL_TYPE_FUNCTION) {
491 IO.mapRequired("Function", Info.ElementIndex);
492 } else if (Info.Kind == wasm::WASM_SYMBOL_TYPE_GLOBAL) {
493 IO.mapRequired("Global", Info.ElementIndex);
494 } else if (Info.Kind == wasm::WASM_SYMBOL_TYPE_EVENT) {
495 IO.mapRequired("Event", Info.ElementIndex);
496 } else if (Info.Kind == wasm::WASM_SYMBOL_TYPE_DATA) {
497 if ((Info.Flags & wasm::WASM_SYMBOL_UNDEFINED) == 0) {
498 IO.mapRequired("Segment", Info.DataRef.Segment);
499 IO.mapOptional("Offset", Info.DataRef.Offset, 0u);
500 IO.mapRequired("Size", Info.DataRef.Size);
502 } else if (Info.Kind == wasm::WASM_SYMBOL_TYPE_SECTION) {
503 IO.mapRequired("Section", Info.ElementIndex);
504 } else {
505 llvm_unreachable("unsupported symbol kind");
509 void MappingTraits<WasmYAML::Event>::mapping(IO &IO, WasmYAML::Event &Event) {
510 IO.mapRequired("Index", Event.Index);
511 IO.mapRequired("Attribute", Event.Attribute);
512 IO.mapRequired("SigIndex", Event.SigIndex);
515 void ScalarBitSetTraits<WasmYAML::LimitFlags>::bitset(
516 IO &IO, WasmYAML::LimitFlags &Value) {
517 #define BCase(X) IO.bitSetCase(Value, #X, wasm::WASM_LIMITS_FLAG_##X)
518 BCase(HAS_MAX);
519 BCase(IS_SHARED);
520 #undef BCase
523 void ScalarBitSetTraits<WasmYAML::SegmentFlags>::bitset(
524 IO &IO, WasmYAML::SegmentFlags &Value) {}
526 void ScalarBitSetTraits<WasmYAML::SymbolFlags>::bitset(
527 IO &IO, WasmYAML::SymbolFlags &Value) {
528 #define BCaseMask(M, X) \
529 IO.maskedBitSetCase(Value, #X, wasm::WASM_SYMBOL_##X, wasm::WASM_SYMBOL_##M)
530 // BCaseMask(BINDING_MASK, BINDING_GLOBAL);
531 BCaseMask(BINDING_MASK, BINDING_WEAK);
532 BCaseMask(BINDING_MASK, BINDING_LOCAL);
533 // BCaseMask(VISIBILITY_MASK, VISIBILITY_DEFAULT);
534 BCaseMask(VISIBILITY_MASK, VISIBILITY_HIDDEN);
535 BCaseMask(UNDEFINED, UNDEFINED);
536 BCaseMask(EXPORTED, EXPORTED);
537 BCaseMask(EXPLICIT_NAME, EXPLICIT_NAME);
538 BCaseMask(NO_STRIP, NO_STRIP);
539 #undef BCaseMask
542 void ScalarEnumerationTraits<WasmYAML::SymbolKind>::enumeration(
543 IO &IO, WasmYAML::SymbolKind &Kind) {
544 #define ECase(X) IO.enumCase(Kind, #X, wasm::WASM_SYMBOL_TYPE_##X);
545 ECase(FUNCTION);
546 ECase(DATA);
547 ECase(GLOBAL);
548 ECase(SECTION);
549 ECase(EVENT);
550 #undef ECase
553 void ScalarEnumerationTraits<WasmYAML::ValueType>::enumeration(
554 IO &IO, WasmYAML::ValueType &Type) {
555 #define ECase(X) IO.enumCase(Type, #X, wasm::WASM_TYPE_##X);
556 ECase(I32);
557 ECase(I64);
558 ECase(F32);
559 ECase(F64);
560 ECase(V128);
561 ECase(FUNCREF);
562 ECase(FUNC);
563 #undef ECase
566 void ScalarEnumerationTraits<WasmYAML::ExportKind>::enumeration(
567 IO &IO, WasmYAML::ExportKind &Kind) {
568 #define ECase(X) IO.enumCase(Kind, #X, wasm::WASM_EXTERNAL_##X);
569 ECase(FUNCTION);
570 ECase(TABLE);
571 ECase(MEMORY);
572 ECase(GLOBAL);
573 ECase(EVENT);
574 #undef ECase
577 void ScalarEnumerationTraits<WasmYAML::Opcode>::enumeration(
578 IO &IO, WasmYAML::Opcode &Code) {
579 #define ECase(X) IO.enumCase(Code, #X, wasm::WASM_OPCODE_##X);
580 ECase(END);
581 ECase(I32_CONST);
582 ECase(I64_CONST);
583 ECase(F64_CONST);
584 ECase(F32_CONST);
585 ECase(GLOBAL_GET);
586 #undef ECase
589 void ScalarEnumerationTraits<WasmYAML::TableType>::enumeration(
590 IO &IO, WasmYAML::TableType &Type) {
591 #define ECase(X) IO.enumCase(Type, #X, wasm::WASM_TYPE_##X);
592 ECase(FUNCREF);
593 #undef ECase
596 void ScalarEnumerationTraits<WasmYAML::RelocType>::enumeration(
597 IO &IO, WasmYAML::RelocType &Type) {
598 #define WASM_RELOC(name, value) IO.enumCase(Type, #name, wasm::name);
599 #include "llvm/BinaryFormat/WasmRelocs.def"
600 #undef WASM_RELOC
603 } // end namespace yaml
605 } // end namespace llvm