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