contrib/llvm/lib/ObjectYAML/WasmYAML.cpp

   1 //===- WasmYAML.cpp - Wasm YAMLIO implementation --------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file defines classes for handling the YAML representation of wasm.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/ObjectYAML/WasmYAML.h"
  15 #include "llvm/ADT/StringRef.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 }
  50
  51 static void sectionMapping(IO &IO, WasmYAML::NameSection &Section) {
  52   commonSectionMapping(IO, Section);
  53   IO.mapRequired("Name", Section.Name);
  54   IO.mapOptional("FunctionNames", Section.FunctionNames);
  55 }
  56
  57 static void sectionMapping(IO &IO, WasmYAML::LinkingSection &Section) {
  58   commonSectionMapping(IO, Section);
  59   IO.mapRequired("Name", Section.Name);
  60   IO.mapRequired("DataSize", Section.DataSize);
  61   IO.mapOptional("SymbolInfo", Section.SymbolInfos);
  62   IO.mapOptional("SegmentInfo", Section.SegmentInfos);
  63   IO.mapOptional("InitFunctions", Section.InitFunctions);
  64 }
  65
  66 static void sectionMapping(IO &IO, WasmYAML::CustomSection &Section) {
  67   commonSectionMapping(IO, Section);
  68   IO.mapRequired("Name", Section.Name);
  69   IO.mapRequired("Payload", Section.Payload);
  70 }
  71
  72 static void sectionMapping(IO &IO, WasmYAML::TypeSection &Section) {
  73   commonSectionMapping(IO, Section);
  74   IO.mapOptional("Signatures", Section.Signatures);
  75 }
  76
  77 static void sectionMapping(IO &IO, WasmYAML::ImportSection &Section) {
  78   commonSectionMapping(IO, Section);
  79   IO.mapOptional("Imports", Section.Imports);
  80 }
  81
  82 static void sectionMapping(IO &IO, WasmYAML::FunctionSection &Section) {
  83   commonSectionMapping(IO, Section);
  84   IO.mapOptional("FunctionTypes", Section.FunctionTypes);
  85 }
  86
  87 static void sectionMapping(IO &IO, WasmYAML::TableSection &Section) {
  88   commonSectionMapping(IO, Section);
  89   IO.mapOptional("Tables", Section.Tables);
  90 }
  91
  92 static void sectionMapping(IO &IO, WasmYAML::MemorySection &Section) {
  93   commonSectionMapping(IO, Section);
  94   IO.mapOptional("Memories", Section.Memories);
  95 }
  96
  97 static void sectionMapping(IO &IO, WasmYAML::GlobalSection &Section) {
  98   commonSectionMapping(IO, Section);
  99   IO.mapOptional("Globals", Section.Globals);
 100 }
 101
 102 static void sectionMapping(IO &IO, WasmYAML::ExportSection &Section) {
 103   commonSectionMapping(IO, Section);
 104   IO.mapOptional("Exports", Section.Exports);
 105 }
 106
 107 static void sectionMapping(IO &IO, WasmYAML::StartSection &Section) {
 108   commonSectionMapping(IO, Section);
 109   IO.mapOptional("StartFunction", Section.StartFunction);
 110 }
 111
 112 static void sectionMapping(IO &IO, WasmYAML::ElemSection &Section) {
 113   commonSectionMapping(IO, Section);
 114   IO.mapOptional("Segments", Section.Segments);
 115 }
 116
 117 static void sectionMapping(IO &IO, WasmYAML::CodeSection &Section) {
 118   commonSectionMapping(IO, Section);
 119   IO.mapRequired("Functions", Section.Functions);
 120 }
 121
 122 static void sectionMapping(IO &IO, WasmYAML::DataSection &Section) {
 123   commonSectionMapping(IO, Section);
 124   IO.mapRequired("Segments", Section.Segments);
 125 }
 126
 127 void MappingTraits<std::unique_ptr<WasmYAML::Section>>::mapping(
 128     IO &IO, std::unique_ptr<WasmYAML::Section> &Section) {
 129   WasmYAML::SectionType SectionType;
 130   if (IO.outputting())
 131     SectionType = Section->Type;
 132   else
 133     IO.mapRequired("Type", SectionType);
 134
 135   switch (SectionType) {
 136   case wasm::WASM_SEC_CUSTOM: {
 137     StringRef SectionName;
 138     if (IO.outputting()) {
 139       auto CustomSection = cast<WasmYAML::CustomSection>(Section.get());
 140       SectionName = CustomSection->Name;
 141     } else {
 142       IO.mapRequired("Name", SectionName);
 143     }
 144     if (SectionName == "linking") {
 145       if (!IO.outputting())
 146         Section.reset(new WasmYAML::LinkingSection());
 147       sectionMapping(IO, *cast<WasmYAML::LinkingSection>(Section.get()));
 148     } else if (SectionName == "name") {
 149       if (!IO.outputting())
 150         Section.reset(new WasmYAML::NameSection());
 151       sectionMapping(IO, *cast<WasmYAML::NameSection>(Section.get()));
 152     } else {
 153       if (!IO.outputting())
 154         Section.reset(new WasmYAML::CustomSection(SectionName));
 155       sectionMapping(IO, *cast<WasmYAML::CustomSection>(Section.get()));
 156     }
 157     break;
 158   }
 159   case wasm::WASM_SEC_TYPE:
 160     if (!IO.outputting())
 161       Section.reset(new WasmYAML::TypeSection());
 162     sectionMapping(IO, *cast<WasmYAML::TypeSection>(Section.get()));
 163     break;
 164   case wasm::WASM_SEC_IMPORT:
 165     if (!IO.outputting())
 166       Section.reset(new WasmYAML::ImportSection());
 167     sectionMapping(IO, *cast<WasmYAML::ImportSection>(Section.get()));
 168     break;
 169   case wasm::WASM_SEC_FUNCTION:
 170     if (!IO.outputting())
 171       Section.reset(new WasmYAML::FunctionSection());
 172     sectionMapping(IO, *cast<WasmYAML::FunctionSection>(Section.get()));
 173     break;
 174   case wasm::WASM_SEC_TABLE:
 175     if (!IO.outputting())
 176       Section.reset(new WasmYAML::TableSection());
 177     sectionMapping(IO, *cast<WasmYAML::TableSection>(Section.get()));
 178     break;
 179   case wasm::WASM_SEC_MEMORY:
 180     if (!IO.outputting())
 181       Section.reset(new WasmYAML::MemorySection());
 182     sectionMapping(IO, *cast<WasmYAML::MemorySection>(Section.get()));
 183     break;
 184   case wasm::WASM_SEC_GLOBAL:
 185     if (!IO.outputting())
 186       Section.reset(new WasmYAML::GlobalSection());
 187     sectionMapping(IO, *cast<WasmYAML::GlobalSection>(Section.get()));
 188     break;
 189   case wasm::WASM_SEC_EXPORT:
 190     if (!IO.outputting())
 191       Section.reset(new WasmYAML::ExportSection());
 192     sectionMapping(IO, *cast<WasmYAML::ExportSection>(Section.get()));
 193     break;
 194   case wasm::WASM_SEC_START:
 195     if (!IO.outputting())
 196       Section.reset(new WasmYAML::StartSection());
 197     sectionMapping(IO, *cast<WasmYAML::StartSection>(Section.get()));
 198     break;
 199   case wasm::WASM_SEC_ELEM:
 200     if (!IO.outputting())
 201       Section.reset(new WasmYAML::ElemSection());
 202     sectionMapping(IO, *cast<WasmYAML::ElemSection>(Section.get()));
 203     break;
 204   case wasm::WASM_SEC_CODE:
 205     if (!IO.outputting())
 206       Section.reset(new WasmYAML::CodeSection());
 207     sectionMapping(IO, *cast<WasmYAML::CodeSection>(Section.get()));
 208     break;
 209   case wasm::WASM_SEC_DATA:
 210     if (!IO.outputting())
 211       Section.reset(new WasmYAML::DataSection());
 212     sectionMapping(IO, *cast<WasmYAML::DataSection>(Section.get()));
 213     break;
 214   default:
 215     llvm_unreachable("Unknown section type");
 216   }
 217 }
 218
 219 void ScalarEnumerationTraits<WasmYAML::SectionType>::enumeration(
 220     IO &IO, WasmYAML::SectionType &Type) {
 221 #define ECase(X) IO.enumCase(Type, #X, wasm::WASM_SEC_##X);
 222   ECase(CUSTOM);
 223   ECase(TYPE);
 224   ECase(IMPORT);
 225   ECase(FUNCTION);
 226   ECase(TABLE);
 227   ECase(MEMORY);
 228   ECase(GLOBAL);
 229   ECase(EXPORT);
 230   ECase(START);
 231   ECase(ELEM);
 232   ECase(CODE);
 233   ECase(DATA);
 234 #undef ECase
 235 }
 236
 237 void MappingTraits<WasmYAML::Signature>::mapping(
 238     IO &IO, WasmYAML::Signature &Signature) {
 239   IO.mapOptional("Index", Signature.Index);
 240   IO.mapRequired("ReturnType", Signature.ReturnType);
 241   IO.mapRequired("ParamTypes", Signature.ParamTypes);
 242 }
 243
 244 void MappingTraits<WasmYAML::Table>::mapping(IO &IO, WasmYAML::Table &Table) {
 245   IO.mapRequired("ElemType", Table.ElemType);
 246   IO.mapRequired("Limits", Table.TableLimits);
 247 }
 248
 249 void MappingTraits<WasmYAML::Function>::mapping(IO &IO,
 250                                                 WasmYAML::Function &Function) {
 251   IO.mapRequired("Locals", Function.Locals);
 252   IO.mapRequired("Body", Function.Body);
 253 }
 254
 255 void MappingTraits<WasmYAML::Relocation>::mapping(
 256     IO &IO, WasmYAML::Relocation &Relocation) {
 257   IO.mapRequired("Type", Relocation.Type);
 258   IO.mapRequired("Index", Relocation.Index);
 259   IO.mapRequired("Offset", Relocation.Offset);
 260   IO.mapOptional("Addend", Relocation.Addend, 0);
 261 }
 262
 263 void MappingTraits<WasmYAML::NameEntry>::mapping(
 264     IO &IO, WasmYAML::NameEntry &NameEntry) {
 265   IO.mapRequired("Index", NameEntry.Index);
 266   IO.mapRequired("Name", NameEntry.Name);
 267 }
 268
 269 void MappingTraits<WasmYAML::SegmentInfo>::mapping(
 270     IO &IO, WasmYAML::SegmentInfo &SegmentInfo) {
 271   IO.mapRequired("Index", SegmentInfo.Index);
 272   IO.mapRequired("Name", SegmentInfo.Name);
 273   IO.mapRequired("Alignment", SegmentInfo.Alignment);
 274   IO.mapRequired("Flags", SegmentInfo.Flags);
 275 }
 276
 277 void MappingTraits<WasmYAML::LocalDecl>::mapping(
 278     IO &IO, WasmYAML::LocalDecl &LocalDecl) {
 279   IO.mapRequired("Type", LocalDecl.Type);
 280   IO.mapRequired("Count", LocalDecl.Count);
 281 }
 282
 283 void MappingTraits<WasmYAML::Limits>::mapping(IO &IO,
 284                                               WasmYAML::Limits &Limits) {
 285   if (!IO.outputting() || Limits.Flags)
 286     IO.mapOptional("Flags", Limits.Flags);
 287   IO.mapRequired("Initial", Limits.Initial);
 288   if (!IO.outputting() || Limits.Flags & wasm::WASM_LIMITS_FLAG_HAS_MAX)
 289     IO.mapOptional("Maximum", Limits.Maximum);
 290 }
 291
 292 void MappingTraits<WasmYAML::ElemSegment>::mapping(
 293     IO &IO, WasmYAML::ElemSegment &Segment) {
 294   IO.mapRequired("Offset", Segment.Offset);
 295   IO.mapRequired("Functions", Segment.Functions);
 296 }
 297
 298 void MappingTraits<WasmYAML::Import>::mapping(IO &IO,
 299                                               WasmYAML::Import &Import) {
 300   IO.mapRequired("Module", Import.Module);
 301   IO.mapRequired("Field", Import.Field);
 302   IO.mapRequired("Kind", Import.Kind);
 303   if (Import.Kind == wasm::WASM_EXTERNAL_FUNCTION) {
 304     IO.mapRequired("SigIndex", Import.SigIndex);
 305   } else if (Import.Kind == wasm::WASM_EXTERNAL_GLOBAL) {
 306     IO.mapRequired("GlobalType", Import.GlobalImport.Type);
 307     IO.mapRequired("GlobalMutable", Import.GlobalImport.Mutable);
 308   } else if (Import.Kind == wasm::WASM_EXTERNAL_TABLE) {
 309     IO.mapRequired("Table", Import.TableImport);
 310   } else if (Import.Kind == wasm::WASM_EXTERNAL_MEMORY ) {
 311     IO.mapRequired("Memory", Import.Memory);
 312   } else {
 313     llvm_unreachable("unhandled import type");
 314   }
 315 }
 316
 317 void MappingTraits<WasmYAML::Export>::mapping(IO &IO,
 318                                               WasmYAML::Export &Export) {
 319   IO.mapRequired("Name", Export.Name);
 320   IO.mapRequired("Kind", Export.Kind);
 321   IO.mapRequired("Index", Export.Index);
 322 }
 323
 324 void MappingTraits<WasmYAML::Global>::mapping(IO &IO,
 325                                               WasmYAML::Global &Global) {
 326   IO.mapRequired("Type", Global.Type);
 327   IO.mapRequired("Mutable", Global.Mutable);
 328   IO.mapRequired("InitExpr", Global.InitExpr);
 329 }
 330
 331 void MappingTraits<wasm::WasmInitExpr>::mapping(IO &IO,
 332                                                 wasm::WasmInitExpr &Expr) {
 333   WasmYAML::Opcode Op = Expr.Opcode;
 334   IO.mapRequired("Opcode", Op);
 335   Expr.Opcode = Op;
 336   switch (Expr.Opcode) {
 337   case wasm::WASM_OPCODE_I32_CONST:
 338     IO.mapRequired("Value", Expr.Value.Int32);
 339     break;
 340   case wasm::WASM_OPCODE_I64_CONST:
 341     IO.mapRequired("Value", Expr.Value.Int64);
 342     break;
 343   case wasm::WASM_OPCODE_F32_CONST:
 344     IO.mapRequired("Value", Expr.Value.Float32);
 345     break;
 346   case wasm::WASM_OPCODE_F64_CONST:
 347     IO.mapRequired("Value", Expr.Value.Float64);
 348     break;
 349   case wasm::WASM_OPCODE_GET_GLOBAL:
 350     IO.mapRequired("Index", Expr.Value.Global);
 351     break;
 352   }
 353 }
 354
 355 void MappingTraits<WasmYAML::DataSegment>::mapping(
 356     IO &IO, WasmYAML::DataSegment &Segment) {
 357   IO.mapOptional("SectionOffset", Segment.SectionOffset);
 358   IO.mapRequired("MemoryIndex", Segment.MemoryIndex);
 359   IO.mapRequired("Offset", Segment.Offset);
 360   IO.mapRequired("Content", Segment.Content);
 361 }
 362
 363 void MappingTraits<WasmYAML::InitFunction>::mapping(
 364     IO &IO, WasmYAML::InitFunction &Init) {
 365   IO.mapRequired("Priority", Init.Priority);
 366   IO.mapRequired("FunctionIndex", Init.FunctionIndex);
 367 }
 368
 369 void MappingTraits<WasmYAML::SymbolInfo>::mapping(IO &IO,
 370                                                   WasmYAML::SymbolInfo &Info) {
 371   IO.mapRequired("Name", Info.Name);
 372   IO.mapRequired("Flags", Info.Flags);
 373 }
 374
 375 void ScalarBitSetTraits<WasmYAML::LimitFlags>::bitset(
 376     IO &IO, WasmYAML::LimitFlags &Value) {
 377 #define BCase(X) IO.bitSetCase(Value, #X, wasm::WASM_LIMITS_FLAG_##X)
 378   BCase(HAS_MAX);
 379 #undef BCase
 380 }
 381
 382 void ScalarBitSetTraits<WasmYAML::SegmentFlags>::bitset(
 383     IO &IO, WasmYAML::SegmentFlags &Value) {
 384 }
 385
 386 void ScalarBitSetTraits<WasmYAML::SymbolFlags>::bitset(
 387     IO &IO, WasmYAML::SymbolFlags &Value) {
 388 #define BCaseMask(M, X) IO.maskedBitSetCase(Value, #X, wasm::WASM_SYMBOL_##X, wasm::WASM_SYMBOL_##M)
 389   //BCaseMask(BINDING_MASK, BINDING_GLOBAL);
 390   BCaseMask(BINDING_MASK, BINDING_WEAK);
 391   BCaseMask(BINDING_MASK, BINDING_LOCAL);
 392   //BCaseMask(VISIBILITY_MASK, VISIBILITY_DEFAULT);
 393   BCaseMask(VISIBILITY_MASK, VISIBILITY_HIDDEN);
 394 #undef BCaseMask
 395 }
 396
 397 void ScalarEnumerationTraits<WasmYAML::ValueType>::enumeration(
 398     IO &IO, WasmYAML::ValueType &Type) {
 399 #define ECase(X) IO.enumCase(Type, #X, wasm::WASM_TYPE_##X);
 400   ECase(I32);
 401   ECase(I64);
 402   ECase(F32);
 403   ECase(F64);
 404   ECase(ANYFUNC);
 405   ECase(FUNC);
 406   ECase(NORESULT);
 407 #undef ECase
 408 }
 409
 410 void ScalarEnumerationTraits<WasmYAML::ExportKind>::enumeration(
 411     IO &IO, WasmYAML::ExportKind &Kind) {
 412 #define ECase(X) IO.enumCase(Kind, #X, wasm::WASM_EXTERNAL_##X);
 413   ECase(FUNCTION);
 414   ECase(TABLE);
 415   ECase(MEMORY);
 416   ECase(GLOBAL);
 417 #undef ECase
 418 }
 419
 420 void ScalarEnumerationTraits<WasmYAML::Opcode>::enumeration(
 421     IO &IO, WasmYAML::Opcode &Code) {
 422 #define ECase(X) IO.enumCase(Code, #X, wasm::WASM_OPCODE_##X);
 423   ECase(END);
 424   ECase(I32_CONST);
 425   ECase(I64_CONST);
 426   ECase(F64_CONST);
 427   ECase(F32_CONST);
 428   ECase(GET_GLOBAL);
 429 #undef ECase
 430 }
 431
 432 void ScalarEnumerationTraits<WasmYAML::TableType>::enumeration(
 433     IO &IO, WasmYAML::TableType &Type) {
 434 #define ECase(X) IO.enumCase(Type, #X, wasm::WASM_TYPE_##X);
 435   ECase(ANYFUNC);
 436 #undef ECase
 437 }
 438
 439 void ScalarEnumerationTraits<WasmYAML::RelocType>::enumeration(
 440     IO &IO, WasmYAML::RelocType &Type) {
 441 #define WASM_RELOC(name, value) IO.enumCase(Type, #name, wasm::name);
 442 #include "llvm/BinaryFormat/WasmRelocs.def"
 443 #undef WASM_RELOC
 444 }
 445
 446 } // end namespace yaml
 447
 448 } // end namespace llvm