lib/ObjectYAML/WasmYAML.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-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 }
  59
  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);
  64 }
  65
  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);
  74 }
  75
  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);
  82 }
  83
  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);
  88 }
  89
  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);
  94 }
  95
  96 static void sectionMapping(IO &IO, WasmYAML::TypeSection &Section) {
  97   commonSectionMapping(IO, Section);
  98   IO.mapOptional("Signatures", Section.Signatures);
  99 }
 100
 101 static void sectionMapping(IO &IO, WasmYAML::ImportSection &Section) {
 102   commonSectionMapping(IO, Section);
 103   IO.mapOptional("Imports", Section.Imports);
 104 }
 105
 106 static void sectionMapping(IO &IO, WasmYAML::FunctionSection &Section) {
 107   commonSectionMapping(IO, Section);
 108   IO.mapOptional("FunctionTypes", Section.FunctionTypes);
 109 }
 110
 111 static void sectionMapping(IO &IO, WasmYAML::TableSection &Section) {
 112   commonSectionMapping(IO, Section);
 113   IO.mapOptional("Tables", Section.Tables);
 114 }
 115
 116 static void sectionMapping(IO &IO, WasmYAML::MemorySection &Section) {
 117   commonSectionMapping(IO, Section);
 118   IO.mapOptional("Memories", Section.Memories);
 119 }
 120
 121 static void sectionMapping(IO &IO, WasmYAML::GlobalSection &Section) {
 122   commonSectionMapping(IO, Section);
 123   IO.mapOptional("Globals", Section.Globals);
 124 }
 125
 126 static void sectionMapping(IO &IO, WasmYAML::EventSection &Section) {
 127   commonSectionMapping(IO, Section);
 128   IO.mapOptional("Events", Section.Events);
 129 }
 130
 131 static void sectionMapping(IO &IO, WasmYAML::ExportSection &Section) {
 132   commonSectionMapping(IO, Section);
 133   IO.mapOptional("Exports", Section.Exports);
 134 }
 135
 136 static void sectionMapping(IO &IO, WasmYAML::StartSection &Section) {
 137   commonSectionMapping(IO, Section);
 138   IO.mapOptional("StartFunction", Section.StartFunction);
 139 }
 140
 141 static void sectionMapping(IO &IO, WasmYAML::ElemSection &Section) {
 142   commonSectionMapping(IO, Section);
 143   IO.mapOptional("Segments", Section.Segments);
 144 }
 145
 146 static void sectionMapping(IO &IO, WasmYAML::CodeSection &Section) {
 147   commonSectionMapping(IO, Section);
 148   IO.mapRequired("Functions", Section.Functions);
 149 }
 150
 151 static void sectionMapping(IO &IO, WasmYAML::DataSection &Section) {
 152   commonSectionMapping(IO, Section);
 153   IO.mapRequired("Segments", Section.Segments);
 154 }
 155
 156 static void sectionMapping(IO &IO, WasmYAML::DataCountSection &Section) {
 157   commonSectionMapping(IO, Section);
 158   IO.mapRequired("Count", Section.Count);
 159 }
 160
 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);
 168
 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);
 177     }
 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()));
 202     }
 203     break;
 204   }
 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");
 272   }
 273 }
 274
 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
 293 }
 294
 295 void MappingTraits<WasmYAML::Signature>::mapping(
 296     IO &IO, WasmYAML::Signature &Signature) {
 297   IO.mapRequired("Index", Signature.Index);
 298   IO.mapRequired("ReturnType", Signature.ReturnType);
 299   IO.mapRequired("ParamTypes", Signature.ParamTypes);
 300 }
 301
 302 void MappingTraits<WasmYAML::Table>::mapping(IO &IO, WasmYAML::Table &Table) {
 303   IO.mapRequired("ElemType", Table.ElemType);
 304   IO.mapRequired("Limits", Table.TableLimits);
 305 }
 306
 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);
 312 }
 313
 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);
 320 }
 321
 322 void MappingTraits<WasmYAML::NameEntry>::mapping(
 323     IO &IO, WasmYAML::NameEntry &NameEntry) {
 324   IO.mapRequired("Index", NameEntry.Index);
 325   IO.mapRequired("Name", NameEntry.Name);
 326 }
 327
 328 void MappingTraits<WasmYAML::ProducerEntry>::mapping(
 329     IO &IO, WasmYAML::ProducerEntry &ProducerEntry) {
 330   IO.mapRequired("Name", ProducerEntry.Name);
 331   IO.mapRequired("Version", ProducerEntry.Version);
 332 }
 333
 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
 341 }
 342
 343 void MappingTraits<WasmYAML::FeatureEntry>::mapping(
 344     IO &IO, WasmYAML::FeatureEntry &FeatureEntry) {
 345   IO.mapRequired("Prefix", FeatureEntry.Prefix);
 346   IO.mapRequired("Name", FeatureEntry.Name);
 347 }
 348
 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);
 355 }
 356
 357 void MappingTraits<WasmYAML::LocalDecl>::mapping(
 358     IO &IO, WasmYAML::LocalDecl &LocalDecl) {
 359   IO.mapRequired("Type", LocalDecl.Type);
 360   IO.mapRequired("Count", LocalDecl.Count);
 361 }
 362
 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);
 370 }
 371
 372 void MappingTraits<WasmYAML::ElemSegment>::mapping(
 373     IO &IO, WasmYAML::ElemSegment &Segment) {
 374   IO.mapRequired("Offset", Segment.Offset);
 375   IO.mapRequired("Functions", Segment.Functions);
 376 }
 377
 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");
 397   }
 398 }
 399
 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);
 405 }
 406
 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);
 413 }
 414
 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;
 436   }
 437 }
 438
 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;
 447   }
 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;
 453   }
 454   IO.mapRequired("Content", Segment.Content);
 455 }
 456
 457 void MappingTraits<WasmYAML::InitFunction>::mapping(
 458     IO &IO, WasmYAML::InitFunction &Init) {
 459   IO.mapRequired("Priority", Init.Priority);
 460   IO.mapRequired("Symbol", Init.Symbol);
 461 }
 462
 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
 469 }
 470
 471 void MappingTraits<WasmYAML::ComdatEntry>::mapping(
 472     IO &IO, WasmYAML::ComdatEntry &ComdatEntry) {
 473   IO.mapRequired("Kind", ComdatEntry.Kind);
 474   IO.mapRequired("Index", ComdatEntry.Index);
 475 }
 476
 477 void MappingTraits<WasmYAML::Comdat>::mapping(IO &IO,
 478                                               WasmYAML::Comdat &Comdat) {
 479   IO.mapRequired("Name", Comdat.Name);
 480   IO.mapRequired("Entries", Comdat.Entries);
 481 }
 482
 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);
 501     }
 502   } else if (Info.Kind == wasm::WASM_SYMBOL_TYPE_SECTION) {
 503     IO.mapRequired("Section", Info.ElementIndex);
 504   } else {
 505     llvm_unreachable("unsupported symbol kind");
 506   }
 507 }
 508
 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);
 513 }
 514
 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
 521 }
 522
 523 void ScalarBitSetTraits<WasmYAML::SegmentFlags>::bitset(
 524     IO &IO, WasmYAML::SegmentFlags &Value) {}
 525
 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 #undef BCaseMask
 539 }
 540
 541 void ScalarEnumerationTraits<WasmYAML::SymbolKind>::enumeration(
 542     IO &IO, WasmYAML::SymbolKind &Kind) {
 543 #define ECase(X) IO.enumCase(Kind, #X, wasm::WASM_SYMBOL_TYPE_##X);
 544   ECase(FUNCTION);
 545   ECase(DATA);
 546   ECase(GLOBAL);
 547   ECase(SECTION);
 548   ECase(EVENT);
 549 #undef ECase
 550 }
 551
 552 void ScalarEnumerationTraits<WasmYAML::ValueType>::enumeration(
 553     IO &IO, WasmYAML::ValueType &Type) {
 554 #define ECase(X) IO.enumCase(Type, #X, wasm::WASM_TYPE_##X);
 555   ECase(I32);
 556   ECase(I64);
 557   ECase(F32);
 558   ECase(F64);
 559   ECase(V128);
 560   ECase(FUNCREF);
 561   ECase(FUNC);
 562   ECase(NORESULT);
 563 #undef ECase
 564 }
 565
 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
 575 }
 576
 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
 587 }
 588
 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
 594 }
 595
 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
 601 }
 602
 603 } // end namespace yaml
 604
 605 } // end namespace llvm