LCOV - code coverage report
Current view: top level - lib/ObjectYAML - WasmYAML.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 328 338 97.0 %
Date: 2018-10-20 13:21:21 Functions: 47 47 100.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.13