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