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

Generated by: LCOV version 1.13