llvm/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/BinaryFormat/Wasm.h"
  16 #include "llvm/Support/Casting.h"
  17 #include "llvm/Support/ErrorHandling.h"
  18 #include "llvm/Support/YAMLTraits.h"
  19
  20 namespace llvm {
  21
  22 namespace 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
  26 Section::~Section() = default;
  27
  28 } // end namespace WasmYAML
  29
  30 namespace yaml {
  31
  32 void MappingTraits<WasmYAML::FileHeader>::mapping(
  33     IO &IO, WasmYAML::FileHeader &FileHdr) {
  34   IO.mapRequired("Version", FileHdr.Version);
  35 }
  36
  37 void 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
  46 static 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
  52 static 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
  64 static 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
  72 static 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
  82 static 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
  90 static 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
  96 static 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
 102 static void sectionMapping(IO &IO, WasmYAML::TypeSection &Section) {
 103   commonSectionMapping(IO, Section);
 104   IO.mapOptional("Signatures", Section.Signatures);
 105 }
 106
 107 static void sectionMapping(IO &IO, WasmYAML::ImportSection &Section) {
 108   commonSectionMapping(IO, Section);
 109   IO.mapOptional("Imports", Section.Imports);
 110 }
 111
 112 static void sectionMapping(IO &IO, WasmYAML::FunctionSection &Section) {
 113   commonSectionMapping(IO, Section);
 114   IO.mapOptional("FunctionTypes", Section.FunctionTypes);
 115 }
 116
 117 static void sectionMapping(IO &IO, WasmYAML::TableSection &Section) {
 118   commonSectionMapping(IO, Section);
 119   IO.mapOptional("Tables", Section.Tables);
 120 }
 121
 122 static void sectionMapping(IO &IO, WasmYAML::MemorySection &Section) {
 123   commonSectionMapping(IO, Section);
 124   IO.mapOptional("Memories", Section.Memories);
 125 }
 126
 127 static void sectionMapping(IO &IO, WasmYAML::TagSection &Section) {
 128   commonSectionMapping(IO, Section);
 129   IO.mapOptional("TagTypes", Section.TagTypes);
 130 }
 131
 132 static void sectionMapping(IO &IO, WasmYAML::GlobalSection &Section) {
 133   commonSectionMapping(IO, Section);
 134   IO.mapOptional("Globals", Section.Globals);
 135 }
 136
 137 static void sectionMapping(IO &IO, WasmYAML::ExportSection &Section) {
 138   commonSectionMapping(IO, Section);
 139   IO.mapOptional("Exports", Section.Exports);
 140 }
 141
 142 static void sectionMapping(IO &IO, WasmYAML::StartSection &Section) {
 143   commonSectionMapping(IO, Section);
 144   IO.mapOptional("StartFunction", Section.StartFunction);
 145 }
 146
 147 static void sectionMapping(IO &IO, WasmYAML::ElemSection &Section) {
 148   commonSectionMapping(IO, Section);
 149   IO.mapOptional("Segments", Section.Segments);
 150 }
 151
 152 static void sectionMapping(IO &IO, WasmYAML::CodeSection &Section) {
 153   commonSectionMapping(IO, Section);
 154   IO.mapRequired("Functions", Section.Functions);
 155 }
 156
 157 static void sectionMapping(IO &IO, WasmYAML::DataSection &Section) {
 158   commonSectionMapping(IO, Section);
 159   IO.mapRequired("Segments", Section.Segments);
 160 }
 161
 162 static void sectionMapping(IO &IO, WasmYAML::DataCountSection &Section) {
 163   commonSectionMapping(IO, Section);
 164   IO.mapRequired("Count", Section.Count);
 165 }
 166
 167 void MappingTraits<std::unique_ptr<WasmYAML::Section>>::mapping(
 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) {
 176   case wasm::WASM_SEC_CUSTOM: {
 177     StringRef SectionName;
 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   }
 211   case wasm::WASM_SEC_TYPE:
 212     if (!IO.outputting())
 213       Section.reset(new WasmYAML::TypeSection());
 214     sectionMapping(IO, *cast<WasmYAML::TypeSection>(Section.get()));
 215     break;
 216   case wasm::WASM_SEC_IMPORT:
 217     if (!IO.outputting())
 218       Section.reset(new WasmYAML::ImportSection());
 219     sectionMapping(IO, *cast<WasmYAML::ImportSection>(Section.get()));
 220     break;
 221   case wasm::WASM_SEC_FUNCTION:
 222     if (!IO.outputting())
 223       Section.reset(new WasmYAML::FunctionSection());
 224     sectionMapping(IO, *cast<WasmYAML::FunctionSection>(Section.get()));
 225     break;
 226   case wasm::WASM_SEC_TABLE:
 227     if (!IO.outputting())
 228       Section.reset(new WasmYAML::TableSection());
 229     sectionMapping(IO, *cast<WasmYAML::TableSection>(Section.get()));
 230     break;
 231   case wasm::WASM_SEC_MEMORY:
 232     if (!IO.outputting())
 233       Section.reset(new WasmYAML::MemorySection());
 234     sectionMapping(IO, *cast<WasmYAML::MemorySection>(Section.get()));
 235     break;
 236   case wasm::WASM_SEC_TAG:
 237     if (!IO.outputting())
 238       Section.reset(new WasmYAML::TagSection());
 239     sectionMapping(IO, *cast<WasmYAML::TagSection>(Section.get()));
 240     break;
 241   case wasm::WASM_SEC_GLOBAL:
 242     if (!IO.outputting())
 243       Section.reset(new WasmYAML::GlobalSection());
 244     sectionMapping(IO, *cast<WasmYAML::GlobalSection>(Section.get()));
 245     break;
 246   case wasm::WASM_SEC_EXPORT:
 247     if (!IO.outputting())
 248       Section.reset(new WasmYAML::ExportSection());
 249     sectionMapping(IO, *cast<WasmYAML::ExportSection>(Section.get()));
 250     break;
 251   case wasm::WASM_SEC_START:
 252     if (!IO.outputting())
 253       Section.reset(new WasmYAML::StartSection());
 254     sectionMapping(IO, *cast<WasmYAML::StartSection>(Section.get()));
 255     break;
 256   case wasm::WASM_SEC_ELEM:
 257     if (!IO.outputting())
 258       Section.reset(new WasmYAML::ElemSection());
 259     sectionMapping(IO, *cast<WasmYAML::ElemSection>(Section.get()));
 260     break;
 261   case wasm::WASM_SEC_CODE:
 262     if (!IO.outputting())
 263       Section.reset(new WasmYAML::CodeSection());
 264     sectionMapping(IO, *cast<WasmYAML::CodeSection>(Section.get()));
 265     break;
 266   case wasm::WASM_SEC_DATA:
 267     if (!IO.outputting())
 268       Section.reset(new WasmYAML::DataSection());
 269     sectionMapping(IO, *cast<WasmYAML::DataSection>(Section.get()));
 270     break;
 271   case wasm::WASM_SEC_DATACOUNT:
 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
 281 void 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);
 287   ECase(FUNCTION);
 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
 301 void MappingTraits<WasmYAML::Signature>::mapping(
 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
 308 void MappingTraits<WasmYAML::Table>::mapping(IO &IO, WasmYAML::Table &Table) {
 309   IO.mapRequired("Index", Table.Index);
 310   IO.mapRequired("ElemType", Table.ElemType);
 311   IO.mapRequired("Limits", Table.TableLimits);
 312 }
 313
 314 void MappingTraits<WasmYAML::Function>::mapping(IO &IO,
 315                                                 WasmYAML::Function &Function) {
 316   IO.mapRequired("Index", Function.Index);
 317   IO.mapRequired("Locals", Function.Locals);
 318   IO.mapRequired("Body", Function.Body);
 319 }
 320
 321 void MappingTraits<WasmYAML::Relocation>::mapping(
 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
 329 void MappingTraits<WasmYAML::NameEntry>::mapping(
 330     IO &IO, WasmYAML::NameEntry &NameEntry) {
 331   IO.mapRequired("Index", NameEntry.Index);
 332   IO.mapRequired("Name", NameEntry.Name);
 333 }
 334
 335 void MappingTraits<WasmYAML::ProducerEntry>::mapping(
 336     IO &IO, WasmYAML::ProducerEntry &ProducerEntry) {
 337   IO.mapRequired("Name", ProducerEntry.Name);
 338   IO.mapRequired("Version", ProducerEntry.Version);
 339 }
 340
 341 void 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);
 345   ECase(REQUIRED);
 346   ECase(DISALLOWED);
 347 #undef ECase
 348 }
 349
 350 void MappingTraits<WasmYAML::FeatureEntry>::mapping(
 351     IO &IO, WasmYAML::FeatureEntry &FeatureEntry) {
 352   IO.mapRequired("Prefix", FeatureEntry.Prefix);
 353   IO.mapRequired("Name", FeatureEntry.Name);
 354 }
 355
 356 void 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
 364 void MappingTraits<WasmYAML::LocalDecl>::mapping(
 365     IO &IO, WasmYAML::LocalDecl &LocalDecl) {
 366   IO.mapRequired("Type", LocalDecl.Type);
 367   IO.mapRequired("Count", LocalDecl.Count);
 368 }
 369
 370 void 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 }
 377
 378 void MappingTraits<WasmYAML::ElemSegment>::mapping(
 379     IO &IO, WasmYAML::ElemSegment &Segment) {
 380   IO.mapOptional("Flags", Segment.Flags, 0);
 381   if (!IO.outputting() ||
 382       Segment.Flags & wasm::WASM_ELEM_SEGMENT_HAS_TABLE_NUMBER)
 383     IO.mapOptional("TableNumber", Segment.TableNumber);
 384   if (!IO.outputting() ||
 385       Segment.Flags & wasm::WASM_ELEM_SEGMENT_MASK_HAS_ELEM_KIND)
 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
 393 void MappingTraits<WasmYAML::Import>::mapping(IO &IO,
 394                                               WasmYAML::Import &Import) {
 395   IO.mapRequired("Module", Import.Module);
 396   IO.mapRequired("Field", Import.Field);
 397   IO.mapRequired("Kind", Import.Kind);
 398   if (Import.Kind == wasm::WASM_EXTERNAL_FUNCTION ||
 399       Import.Kind == wasm::WASM_EXTERNAL_TAG) {
 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
 413 void MappingTraits<WasmYAML::Export>::mapping(IO &IO,
 414                                               WasmYAML::Export &Export) {
 415   IO.mapRequired("Name", Export.Name);
 416   IO.mapRequired("Kind", Export.Kind);
 417   IO.mapRequired("Index", Export.Index);
 418 }
 419
 420 void MappingTraits<WasmYAML::Global>::mapping(IO &IO,
 421                                               WasmYAML::Global &Global) {
 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
 428 void MappingTraits<WasmYAML::InitExpr>::mapping(IO &IO,
 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) {
 438     case wasm::WASM_OPCODE_I32_CONST:
 439       IO.mapRequired("Value", Expr.Inst.Value.Int32);
 440       break;
 441     case wasm::WASM_OPCODE_I64_CONST:
 442       IO.mapRequired("Value", Expr.Inst.Value.Int64);
 443       break;
 444     case wasm::WASM_OPCODE_F32_CONST:
 445       IO.mapRequired("Value", Expr.Inst.Value.Float32);
 446       break;
 447     case wasm::WASM_OPCODE_F64_CONST:
 448       IO.mapRequired("Value", Expr.Inst.Value.Float64);
 449       break;
 450     case wasm::WASM_OPCODE_GLOBAL_GET:
 451       IO.mapRequired("Index", Expr.Inst.Value.Global);
 452       break;
 453     case wasm::WASM_OPCODE_REF_NULL: {
 454       WasmYAML::ValueType Ty = wasm::WASM_TYPE_EXTERNREF;
 455       IO.mapRequired("Type", Ty);
 456       break;
 457     }
 458     }
 459   }
 460 }
 461
 462 void MappingTraits<WasmYAML::DataSegment>::mapping(
 463     IO &IO, WasmYAML::DataSegment &Segment) {
 464   IO.mapOptional("SectionOffset", Segment.SectionOffset);
 465   IO.mapRequired("InitFlags", Segment.InitFlags);
 466   if (Segment.InitFlags & wasm::WASM_DATA_SEGMENT_HAS_MEMINDEX) {
 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 {
 474     Segment.Offset.Inst.Opcode = wasm::WASM_OPCODE_I32_CONST;
 475     Segment.Offset.Inst.Value.Int32 = 0;
 476   }
 477   IO.mapRequired("Content", Segment.Content);
 478 }
 479
 480 void MappingTraits<WasmYAML::InitFunction>::mapping(
 481     IO &IO, WasmYAML::InitFunction &Init) {
 482   IO.mapRequired("Priority", Init.Priority);
 483   IO.mapRequired("Symbol", Init.Symbol);
 484 }
 485
 486 void ScalarEnumerationTraits<WasmYAML::ComdatKind>::enumeration(
 487     IO &IO, WasmYAML::ComdatKind &Kind) {
 488 #define ECase(X) IO.enumCase(Kind, #X, wasm::WASM_COMDAT_##X);
 489   ECase(FUNCTION);
 490   ECase(DATA);
 491   ECase(SECTION);
 492 #undef ECase
 493 }
 494
 495 void MappingTraits<WasmYAML::ComdatEntry>::mapping(
 496     IO &IO, WasmYAML::ComdatEntry &ComdatEntry) {
 497   IO.mapRequired("Kind", ComdatEntry.Kind);
 498   IO.mapRequired("Index", ComdatEntry.Index);
 499 }
 500
 501 void MappingTraits<WasmYAML::Comdat>::mapping(IO &IO,
 502                                               WasmYAML::Comdat &Comdat) {
 503   IO.mapRequired("Name", Comdat.Name);
 504   IO.mapRequired("Entries", Comdat.Entries);
 505 }
 506
 507 void MappingTraits<WasmYAML::SymbolInfo>::mapping(IO &IO,
 508                                                   WasmYAML::SymbolInfo &Info) {
 509   IO.mapRequired("Index", Info.Index);
 510   IO.mapRequired("Kind", Info.Kind);
 511   if (Info.Kind != wasm::WASM_SYMBOL_TYPE_SECTION)
 512     IO.mapRequired("Name", Info.Name);
 513   IO.mapRequired("Flags", Info.Flags);
 514   if (Info.Kind == wasm::WASM_SYMBOL_TYPE_FUNCTION) {
 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
 537 void MappingTraits<WasmYAML::DylinkImportInfo>::mapping(
 538     IO &IO, WasmYAML::DylinkImportInfo &Info) {
 539   IO.mapRequired("Module", Info.Module);
 540   IO.mapRequired("Field", Info.Field);
 541   IO.mapRequired("Flags", Info.Flags);
 542 }
 543
 544 void MappingTraits<WasmYAML::DylinkExportInfo>::mapping(
 545     IO &IO, WasmYAML::DylinkExportInfo &Info) {
 546   IO.mapRequired("Name", Info.Name);
 547   IO.mapRequired("Flags", Info.Flags);
 548 }
 549
 550 void 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
 559 void 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
 568 void 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);
 577   BCaseMask(UNDEFINED, UNDEFINED);
 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
 586 void ScalarEnumerationTraits<WasmYAML::SymbolKind>::enumeration(
 587     IO &IO, WasmYAML::SymbolKind &Kind) {
 588 #define ECase(X) IO.enumCase(Kind, #X, wasm::WASM_SYMBOL_TYPE_##X);
 589   ECase(FUNCTION);
 590   ECase(DATA);
 591   ECase(GLOBAL);
 592   ECase(TABLE);
 593   ECase(SECTION);
 594   ECase(TAG);
 595 #undef ECase
 596 }
 597
 598 void 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(OTHERREF);
 610 #undef ECase
 611 }
 612
 613 void ScalarEnumerationTraits<WasmYAML::ExportKind>::enumeration(
 614     IO &IO, WasmYAML::ExportKind &Kind) {
 615 #define ECase(X) IO.enumCase(Kind, #X, wasm::WASM_EXTERNAL_##X);
 616   ECase(FUNCTION);
 617   ECase(TABLE);
 618   ECase(MEMORY);
 619   ECase(GLOBAL);
 620   ECase(TAG);
 621 #undef ECase
 622 }
 623
 624 void ScalarEnumerationTraits<WasmYAML::Opcode>::enumeration(
 625     IO &IO, WasmYAML::Opcode &Code) {
 626 #define ECase(X) IO.enumCase(Code, #X, wasm::WASM_OPCODE_##X);
 627   ECase(END);
 628   ECase(I32_CONST);
 629   ECase(I64_CONST);
 630   ECase(F64_CONST);
 631   ECase(F32_CONST);
 632   ECase(GLOBAL_GET);
 633   ECase(REF_NULL);
 634 #undef ECase
 635 }
 636
 637 void ScalarEnumerationTraits<WasmYAML::TableType>::enumeration(
 638     IO &IO, WasmYAML::TableType &Type) {
 639 #define CONCAT(X) (uint32_t) wasm::ValType::X
 640 #define ECase(X) IO.enumCase(Type, #X, CONCAT(X));
 641   ECase(FUNCREF);
 642   ECase(EXTERNREF);
 643   ECase(OTHERREF);
 644 #undef ECase
 645 }
 646
 647 void ScalarEnumerationTraits<WasmYAML::RelocType>::enumeration(
 648     IO &IO, WasmYAML::RelocType &Type) {
 649 #define WASM_RELOC(name, value) IO.enumCase(Type, #name, wasm::name);
 650 #include "llvm/BinaryFormat/WasmRelocs.def"
 651 #undef WASM_RELOC
 652   IO.enumFallback<Hex32>(Type);
 653 }
 654
 655 } // end namespace yaml
 656
 657 } // end namespace llvm