LCOV - code coverage report
Current view: top level - include/llvm/ObjectYAML - WasmYAML.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 47 49 95.9 %
Date: 2018-02-17 17:14:17 Functions: 26 32 81.2 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- WasmYAML.h - Wasm YAMLIO implementation ------------------*- C++ -*-===//
       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             : /// \file
      11             : /// \brief This file declares classes for handling the YAML representation
      12             : /// of wasm binaries.
      13             : ///
      14             : //===----------------------------------------------------------------------===//
      15             : 
      16             : #ifndef LLVM_OBJECTYAML_WASMYAML_H
      17             : #define LLVM_OBJECTYAML_WASMYAML_H
      18             : 
      19             : #include "llvm/ADT/StringRef.h"
      20             : #include "llvm/BinaryFormat/Wasm.h"
      21             : #include "llvm/ObjectYAML/YAML.h"
      22             : #include "llvm/Support/Casting.h"
      23             : #include <cstdint>
      24             : #include <memory>
      25             : #include <vector>
      26             : 
      27             : namespace llvm {
      28             : namespace WasmYAML {
      29             : 
      30         722 : LLVM_YAML_STRONG_TYPEDEF(uint32_t, SectionType)
      31         338 : LLVM_YAML_STRONG_TYPEDEF(int32_t, ValueType)
      32           7 : LLVM_YAML_STRONG_TYPEDEF(int32_t, TableType)
      33          25 : LLVM_YAML_STRONG_TYPEDEF(int32_t, SignatureForm)
      34         141 : LLVM_YAML_STRONG_TYPEDEF(uint32_t, ExportKind)
      35         114 : LLVM_YAML_STRONG_TYPEDEF(uint32_t, Opcode)
      36          67 : LLVM_YAML_STRONG_TYPEDEF(uint32_t, RelocType)
      37          10 : LLVM_YAML_STRONG_TYPEDEF(uint32_t, SymbolFlags)
      38           2 : LLVM_YAML_STRONG_TYPEDEF(uint32_t, SegmentFlags)
      39             : LLVM_YAML_STRONG_TYPEDEF(uint32_t, LimitFlags)
      40           0 : LLVM_YAML_STRONG_TYPEDEF(uint32_t, ComdatKind)
      41             : 
      42             : struct FileHeader {
      43             :   yaml::Hex32 Version;
      44             : };
      45             : 
      46             : struct Limits {
      47             :   LimitFlags Flags;
      48             :   yaml::Hex32 Initial;
      49             :   yaml::Hex32 Maximum;
      50             : };
      51             : 
      52             : struct Table {
      53             :   TableType ElemType;
      54             :   Limits TableLimits;
      55             : };
      56             : 
      57             : struct Export {
      58             :   StringRef Name;
      59             :   ExportKind Kind;
      60             :   uint32_t Index;
      61             : };
      62             : 
      63          10 : struct ElemSegment {
      64             :   uint32_t TableIndex;
      65             :   wasm::WasmInitExpr Offset;
      66             :   std::vector<uint32_t> Functions;
      67             : };
      68             : 
      69             : struct Global {
      70             :   uint32_t Index;
      71             :   ValueType Type;
      72             :   bool Mutable;
      73             :   wasm::WasmInitExpr InitExpr;
      74             : };
      75             : 
      76             : struct Import {
      77             :   StringRef Module;
      78             :   StringRef Field;
      79             :   ExportKind Kind;
      80             :   union {
      81             :     uint32_t SigIndex;
      82             :     Global GlobalImport;
      83             :     Table TableImport;
      84             :     Limits Memory;
      85             :   };
      86             : };
      87             : 
      88             : struct LocalDecl {
      89             :   ValueType Type;
      90             :   uint32_t Count;
      91             : };
      92             : 
      93          65 : struct Function {
      94             :   uint32_t Index;
      95             :   std::vector<LocalDecl> Locals;
      96             :   yaml::BinaryRef Body;
      97             : };
      98             : 
      99             : struct Relocation {
     100             :   RelocType Type;
     101             :   uint32_t Index;
     102             :   yaml::Hex32 Offset;
     103             :   int32_t Addend;
     104             : };
     105             : 
     106             : struct DataSegment {
     107             :   uint32_t MemoryIndex;
     108             :   uint32_t SectionOffset;
     109             :   wasm::WasmInitExpr Offset;
     110             :   yaml::BinaryRef Content;
     111             : };
     112             : 
     113             : struct NameEntry {
     114             :   uint32_t Index;
     115             :   StringRef Name;
     116             : };
     117             : 
     118             : struct SegmentInfo {
     119             :   uint32_t Index;
     120             :   StringRef Name;
     121             :   uint32_t Alignment;
     122             :   SegmentFlags Flags;
     123             : };
     124             : 
     125          58 : struct Signature {
     126             :   uint32_t Index;
     127             :   SignatureForm Form = wasm::WASM_TYPE_FUNC;
     128             :   std::vector<ValueType> ParamTypes;
     129             :   ValueType ReturnType;
     130             : };
     131             : 
     132             : struct SymbolInfo {
     133             :   StringRef Name;
     134             :   SymbolFlags Flags;
     135             : };
     136             : 
     137             : struct InitFunction {
     138             :   uint32_t Priority;
     139             :   uint32_t FunctionIndex;
     140             : };
     141             : 
     142             : struct ComdatEntry {
     143             :   ComdatKind Kind;
     144             :   uint32_t Index;
     145             : };
     146             : 
     147           0 : struct Comdat {
     148             :   StringRef Name;
     149             :   std::vector<ComdatEntry> Entries;
     150             : };
     151             : 
     152         202 : struct Section {
     153         101 :   explicit Section(SectionType SecType) : Type(SecType) {}
     154             :   virtual ~Section();
     155             : 
     156             :   SectionType Type;
     157             :   std::vector<Relocation> Relocations;
     158             : };
     159             : 
     160          14 : struct CustomSection : Section {
     161             :   explicit CustomSection(StringRef Name)
     162          28 :       : Section(wasm::WASM_SEC_CUSTOM), Name(Name) {}
     163             : 
     164             :   static bool classof(const Section *S) {
     165             :     return S->Type == wasm::WASM_SEC_CUSTOM;
     166             :   }
     167             : 
     168             :   StringRef Name;
     169             :   yaml::BinaryRef Payload;
     170             : };
     171             : 
     172          12 : struct NameSection : CustomSection {
     173           8 :   NameSection() : CustomSection("name") {}
     174             : 
     175           8 :   static bool classof(const Section *S) {
     176             :     auto C = dyn_cast<CustomSection>(S);
     177           8 :     return C && C->Name == "name";
     178             :   }
     179             : 
     180             :   std::vector<NameEntry> FunctionNames;
     181             : };
     182             : 
     183          24 : struct LinkingSection : CustomSection {
     184          16 :   LinkingSection() : CustomSection("linking") {}
     185             : 
     186           6 :   static bool classof(const Section *S) {
     187             :     auto C = dyn_cast<CustomSection>(S);
     188           6 :     return C && C->Name == "linking";
     189             :   }
     190             : 
     191             :   uint32_t DataSize;
     192             :   std::vector<SymbolInfo> SymbolInfos;
     193             :   std::vector<SegmentInfo> SegmentInfos;
     194             :   std::vector<InitFunction> InitFunctions;
     195             :   std::vector<Comdat> Comdats;
     196             : };
     197             : 
     198          19 : struct TypeSection : Section {
     199          38 :   TypeSection() : Section(wasm::WASM_SEC_TYPE) {}
     200             : 
     201             :   static bool classof(const Section *S) {
     202             :     return S->Type == wasm::WASM_SEC_TYPE;
     203             :   }
     204             : 
     205             :   std::vector<Signature> Signatures;
     206             : };
     207             : 
     208          33 : struct ImportSection : Section {
     209          22 :   ImportSection() : Section(wasm::WASM_SEC_IMPORT) {}
     210             : 
     211             :   static bool classof(const Section *S) {
     212             :     return S->Type == wasm::WASM_SEC_IMPORT;
     213             :   }
     214             : 
     215             :   std::vector<Import> Imports;
     216             : };
     217             : 
     218          39 : struct FunctionSection : Section {
     219          26 :   FunctionSection() : Section(wasm::WASM_SEC_FUNCTION) {}
     220             : 
     221             :   static bool classof(const Section *S) {
     222             :     return S->Type == wasm::WASM_SEC_FUNCTION;
     223             :   }
     224             : 
     225             :   std::vector<uint32_t> FunctionTypes;
     226             : };
     227             : 
     228          15 : struct TableSection : Section {
     229          10 :   TableSection() : Section(wasm::WASM_SEC_TABLE) {}
     230             : 
     231             :   static bool classof(const Section *S) {
     232             :     return S->Type == wasm::WASM_SEC_TABLE;
     233             :   }
     234             : 
     235             :   std::vector<Table> Tables;
     236             : };
     237             : 
     238          15 : struct MemorySection : Section {
     239          10 :   MemorySection() : Section(wasm::WASM_SEC_MEMORY) {}
     240             : 
     241             :   static bool classof(const Section *S) {
     242             :     return S->Type == wasm::WASM_SEC_MEMORY;
     243             :   }
     244             : 
     245             :   std::vector<Limits> Memories;
     246             : };
     247             : 
     248          27 : struct GlobalSection : Section {
     249          18 :   GlobalSection() : Section(wasm::WASM_SEC_GLOBAL) {}
     250             : 
     251             :   static bool classof(const Section *S) {
     252             :     return S->Type == wasm::WASM_SEC_GLOBAL;
     253             :   }
     254             : 
     255             :   std::vector<Global> Globals;
     256             : };
     257             : 
     258          24 : struct ExportSection : Section {
     259          16 :   ExportSection() : Section(wasm::WASM_SEC_EXPORT) {}
     260             : 
     261             :   static bool classof(const Section *S) {
     262             :     return S->Type == wasm::WASM_SEC_EXPORT;
     263             :   }
     264             : 
     265             :   std::vector<Export> Exports;
     266             : };
     267             : 
     268           3 : struct StartSection : Section {
     269           6 :   StartSection() : Section(wasm::WASM_SEC_START) {}
     270             : 
     271             :   static bool classof(const Section *S) {
     272             :     return S->Type == wasm::WASM_SEC_START;
     273             :   }
     274             : 
     275             :   uint32_t StartFunction;
     276             : };
     277             : 
     278           2 : struct ElemSection : Section {
     279           4 :   ElemSection() : Section(wasm::WASM_SEC_ELEM) {}
     280             : 
     281             :   static bool classof(const Section *S) {
     282             :     return S->Type == wasm::WASM_SEC_ELEM;
     283             :   }
     284             : 
     285             :   std::vector<ElemSegment> Segments;
     286             : };
     287             : 
     288           7 : struct CodeSection : Section {
     289          14 :   CodeSection() : Section(wasm::WASM_SEC_CODE) {}
     290             : 
     291             :   static bool classof(const Section *S) {
     292             :     return S->Type == wasm::WASM_SEC_CODE;
     293             :   }
     294             : 
     295             :   std::vector<Function> Functions;
     296             : };
     297             : 
     298          15 : struct DataSection : Section {
     299          10 :   DataSection() : Section(wasm::WASM_SEC_DATA) {}
     300             : 
     301             :   static bool classof(const Section *S) {
     302             :     return S->Type == wasm::WASM_SEC_DATA;
     303             :   }
     304             : 
     305             :   std::vector<DataSegment> Segments;
     306             : };
     307             : 
     308          41 : struct Object {
     309             :   FileHeader Header;
     310             :   std::vector<std::unique_ptr<Section>> Sections;
     311             : };
     312             : 
     313             : } // end namespace WasmYAML
     314             : } // end namespace llvm
     315             : 
     316             : LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<llvm::WasmYAML::Section>)
     317             : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Signature)
     318             : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::ValueType)
     319             : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Table)
     320             : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Import)
     321             : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Export)
     322             : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::ElemSegment)
     323             : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Limits)
     324             : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::DataSegment)
     325             : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Global)
     326             : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Function)
     327             : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::LocalDecl)
     328             : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Relocation)
     329             : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::NameEntry)
     330             : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::SegmentInfo)
     331             : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::SymbolInfo)
     332             : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::InitFunction)
     333             : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::ComdatEntry)
     334             : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Comdat)
     335             : 
     336             : namespace llvm {
     337             : namespace yaml {
     338             : 
     339             : template <> struct MappingTraits<WasmYAML::FileHeader> {
     340             :   static void mapping(IO &IO, WasmYAML::FileHeader &FileHdr);
     341             : };
     342             : 
     343             : template <> struct MappingTraits<std::unique_ptr<WasmYAML::Section>> {
     344             :   static void mapping(IO &IO, std::unique_ptr<WasmYAML::Section> &Section);
     345             : };
     346             : 
     347             : template <> struct MappingTraits<WasmYAML::Object> {
     348             :   static void mapping(IO &IO, WasmYAML::Object &Object);
     349             : };
     350             : 
     351             : template <> struct MappingTraits<WasmYAML::Import> {
     352             :   static void mapping(IO &IO, WasmYAML::Import &Import);
     353             : };
     354             : 
     355             : template <> struct MappingTraits<WasmYAML::Export> {
     356             :   static void mapping(IO &IO, WasmYAML::Export &Export);
     357             : };
     358             : 
     359             : template <> struct MappingTraits<WasmYAML::Global> {
     360             :   static void mapping(IO &IO, WasmYAML::Global &Global);
     361             : };
     362             : 
     363             : template <> struct ScalarBitSetTraits<WasmYAML::LimitFlags> {
     364             :   static void bitset(IO &IO, WasmYAML::LimitFlags &Value);
     365             : };
     366             : 
     367             : template <> struct ScalarBitSetTraits<WasmYAML::SymbolFlags> {
     368             :   static void bitset(IO &IO, WasmYAML::SymbolFlags &Value);
     369             : };
     370             : 
     371             : template <> struct ScalarBitSetTraits<WasmYAML::SegmentFlags> {
     372             :   static void bitset(IO &IO, WasmYAML::SegmentFlags &Value);
     373             : };
     374             : 
     375             : template <> struct ScalarEnumerationTraits<WasmYAML::SectionType> {
     376             :   static void enumeration(IO &IO, WasmYAML::SectionType &Type);
     377             : };
     378             : 
     379             : template <> struct MappingTraits<WasmYAML::Signature> {
     380             :   static void mapping(IO &IO, WasmYAML::Signature &Signature);
     381             : };
     382             : 
     383             : template <> struct MappingTraits<WasmYAML::Table> {
     384             :   static void mapping(IO &IO, WasmYAML::Table &Table);
     385             : };
     386             : 
     387             : template <> struct MappingTraits<WasmYAML::Limits> {
     388             :   static void mapping(IO &IO, WasmYAML::Limits &Limits);
     389             : };
     390             : 
     391             : template <> struct MappingTraits<WasmYAML::Function> {
     392             :   static void mapping(IO &IO, WasmYAML::Function &Function);
     393             : };
     394             : 
     395             : template <> struct MappingTraits<WasmYAML::Relocation> {
     396             :   static void mapping(IO &IO, WasmYAML::Relocation &Relocation);
     397             : };
     398             : 
     399             : template <> struct MappingTraits<WasmYAML::NameEntry> {
     400             :   static void mapping(IO &IO, WasmYAML::NameEntry &NameEntry);
     401             : };
     402             : 
     403             : template <> struct MappingTraits<WasmYAML::SegmentInfo> {
     404             :   static void mapping(IO &IO, WasmYAML::SegmentInfo &SegmentInfo);
     405             : };
     406             : 
     407             : template <> struct MappingTraits<WasmYAML::LocalDecl> {
     408             :   static void mapping(IO &IO, WasmYAML::LocalDecl &LocalDecl);
     409             : };
     410             : 
     411             : template <> struct MappingTraits<wasm::WasmInitExpr> {
     412             :   static void mapping(IO &IO, wasm::WasmInitExpr &Expr);
     413             : };
     414             : 
     415             : template <> struct MappingTraits<WasmYAML::DataSegment> {
     416             :   static void mapping(IO &IO, WasmYAML::DataSegment &Segment);
     417             : };
     418             : 
     419             : template <> struct MappingTraits<WasmYAML::ElemSegment> {
     420             :   static void mapping(IO &IO, WasmYAML::ElemSegment &Segment);
     421             : };
     422             : 
     423             : template <> struct MappingTraits<WasmYAML::SymbolInfo> {
     424             :   static void mapping(IO &IO, WasmYAML::SymbolInfo &Info);
     425             : };
     426             : 
     427             : template <> struct MappingTraits<WasmYAML::InitFunction> {
     428             :   static void mapping(IO &IO, WasmYAML::InitFunction &Init);
     429             : };
     430             : 
     431             : template <> struct ScalarEnumerationTraits<WasmYAML::ComdatKind> {
     432             :   static void enumeration(IO &IO, WasmYAML::ComdatKind &Kind);
     433             : };
     434             : 
     435             : template <> struct MappingTraits<WasmYAML::ComdatEntry> {
     436             :   static void mapping(IO &IO, WasmYAML::ComdatEntry &ComdatEntry);
     437             : };
     438             : 
     439             : template <> struct MappingTraits<WasmYAML::Comdat> {
     440             :   static void mapping(IO &IO, WasmYAML::Comdat &Comdat);
     441             : };
     442             : 
     443             : template <> struct ScalarEnumerationTraits<WasmYAML::ValueType> {
     444             :   static void enumeration(IO &IO, WasmYAML::ValueType &Type);
     445             : };
     446             : 
     447             : template <> struct ScalarEnumerationTraits<WasmYAML::ExportKind> {
     448             :   static void enumeration(IO &IO, WasmYAML::ExportKind &Kind);
     449             : };
     450             : 
     451             : template <> struct ScalarEnumerationTraits<WasmYAML::TableType> {
     452             :   static void enumeration(IO &IO, WasmYAML::TableType &Type);
     453             : };
     454             : 
     455             : template <> struct ScalarEnumerationTraits<WasmYAML::Opcode> {
     456             :   static void enumeration(IO &IO, WasmYAML::Opcode &Opcode);
     457             : };
     458             : 
     459             : template <> struct ScalarEnumerationTraits<WasmYAML::RelocType> {
     460             :   static void enumeration(IO &IO, WasmYAML::RelocType &Kind);
     461             : };
     462             : 
     463             : } // end namespace yaml
     464             : } // end namespace llvm
     465             : 
     466             : #endif // LLVM_OBJECTYAML_WASMYAML_H

Generated by: LCOV version 1.13