LCOV - code coverage report
Current view: top level - include/llvm/BinaryFormat - Wasm.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 7 7 100.0 %
Date: 2017-09-14 15:23:50 Functions: 0 0 -
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- Wasm.h - Wasm object file format -------------------------*- 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             : // This file defines manifest constants for the wasm object file format.
      11             : // See: https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md
      12             : //
      13             : //===----------------------------------------------------------------------===//
      14             : 
      15             : #ifndef LLVM_BINARYFORMAT_WASM_H
      16             : #define LLVM_BINARYFORMAT_WASM_H
      17             : 
      18             : #include "llvm/ADT/ArrayRef.h"
      19             : 
      20             : namespace llvm {
      21             : namespace wasm {
      22             : 
      23             : // Object file magic string.
      24             : const char WasmMagic[] = {'\0', 'a', 's', 'm'};
      25             : // Wasm binary format version
      26             : const uint32_t WasmVersion = 0x1;
      27             : // Wasm uses a 64k page size
      28             : const uint32_t WasmPageSize = 65536;
      29             : 
      30          66 : struct WasmObjectHeader {
      31             :   StringRef Magic;
      32             :   uint32_t Version;
      33             : };
      34             : 
      35         287 : struct WasmSignature {
      36             :   std::vector<int32_t> ParamTypes;
      37             :   int32_t ReturnType;
      38             : };
      39             : 
      40          54 : struct WasmExport {
      41             :   StringRef Name;
      42             :   uint32_t Kind;
      43             :   uint32_t Index;
      44             : };
      45             : 
      46             : struct WasmLimits {
      47             :   uint32_t Flags;
      48             :   uint32_t Initial;
      49             :   uint32_t Maximum;
      50             : };
      51             : 
      52             : struct WasmTable {
      53             :   int32_t ElemType;
      54             :   WasmLimits Limits;
      55             : };
      56             : 
      57             : struct WasmInitExpr {
      58             :   uint8_t Opcode;
      59             :   union {
      60             :     int32_t Int32;
      61             :     int64_t Int64;
      62             :     int32_t Float32;
      63             :     int64_t Float64;
      64             :     uint32_t Global;
      65             :   } Value;
      66             : };
      67             : 
      68             : struct WasmGlobal {
      69             :   int32_t Type;
      70             :   bool Mutable;
      71             :   WasmInitExpr InitExpr;
      72             : };
      73             : 
      74          99 : struct WasmImport {
      75             :   StringRef Module;
      76             :   StringRef Field;
      77             :   uint32_t Kind;
      78             :   union {
      79             :     uint32_t SigIndex;
      80             :     WasmGlobal Global;
      81             :     WasmTable Table;
      82             :     WasmLimits Memory;
      83             :   };
      84             : };
      85             : 
      86             : struct WasmLocalDecl {
      87             :   int32_t Type;
      88             :   uint32_t Count;
      89             : };
      90             : 
      91         100 : struct WasmFunction {
      92             :   std::vector<WasmLocalDecl> Locals;
      93             :   ArrayRef<uint8_t> Body;
      94             : };
      95             : 
      96          22 : struct WasmDataSegment {
      97             :   uint32_t MemoryIndex;
      98             :   WasmInitExpr Offset;
      99             :   ArrayRef<uint8_t> Content;
     100             : };
     101             : 
     102          14 : struct WasmElemSegment {
     103             :   uint32_t TableIndex;
     104             :   WasmInitExpr Offset;
     105             :   std::vector<uint32_t> Functions;
     106             : };
     107             : 
     108             : struct WasmRelocation {
     109             :   uint32_t Type;   // The type of the relocation.
     110             :   uint32_t Index;  // Index into function to global index space.
     111             :   uint64_t Offset; // Offset from the start of the section.
     112             :   int64_t Addend;  // A value to add to the symbol.
     113             : };
     114             : 
     115             : struct WasmLinkingData {
     116             :   uint32_t DataSize;
     117             :   uint32_t DataAlignment;
     118             : };
     119             : 
     120             : enum : unsigned {
     121             :   WASM_SEC_CUSTOM = 0,   // Custom / User-defined section
     122             :   WASM_SEC_TYPE = 1,     // Function signature declarations
     123             :   WASM_SEC_IMPORT = 2,   // Import declarations
     124             :   WASM_SEC_FUNCTION = 3, // Function declarations
     125             :   WASM_SEC_TABLE = 4,    // Indirect function table and other tables
     126             :   WASM_SEC_MEMORY = 5,   // Memory attributes
     127             :   WASM_SEC_GLOBAL = 6,   // Global declarations
     128             :   WASM_SEC_EXPORT = 7,   // Exports
     129             :   WASM_SEC_START = 8,    // Start function declaration
     130             :   WASM_SEC_ELEM = 9,     // Elements section
     131             :   WASM_SEC_CODE = 10,    // Function bodies (code)
     132             :   WASM_SEC_DATA = 11     // Data segments
     133             : };
     134             : 
     135             : // Type immediate encodings used in various contexts.
     136             : enum {
     137             :   WASM_TYPE_I32 = -0x01,
     138             :   WASM_TYPE_I64 = -0x02,
     139             :   WASM_TYPE_F32 = -0x03,
     140             :   WASM_TYPE_F64 = -0x04,
     141             :   WASM_TYPE_ANYFUNC = -0x10,
     142             :   WASM_TYPE_FUNC = -0x20,
     143             :   WASM_TYPE_NORESULT = -0x40, // for blocks with no result values
     144             : };
     145             : 
     146             : // Kinds of externals (for imports and exports).
     147             : enum : unsigned {
     148             :   WASM_EXTERNAL_FUNCTION = 0x0,
     149             :   WASM_EXTERNAL_TABLE = 0x1,
     150             :   WASM_EXTERNAL_MEMORY = 0x2,
     151             :   WASM_EXTERNAL_GLOBAL = 0x3,
     152             : };
     153             : 
     154             : // Opcodes used in initializer expressions.
     155             : enum : unsigned {
     156             :   WASM_OPCODE_END = 0x0b,
     157             :   WASM_OPCODE_GET_GLOBAL = 0x23,
     158             :   WASM_OPCODE_I32_CONST = 0x41,
     159             :   WASM_OPCODE_I64_CONST = 0x42,
     160             :   WASM_OPCODE_F32_CONST = 0x43,
     161             :   WASM_OPCODE_F64_CONST = 0x44,
     162             : };
     163             : 
     164             : enum : unsigned {
     165             :   WASM_NAMES_FUNCTION = 0x1,
     166             :   WASM_NAMES_LOCAL = 0x2,
     167             : };
     168             : 
     169             : enum : unsigned {
     170             :   WASM_LIMITS_FLAG_HAS_MAX = 0x1,
     171             : };
     172             : 
     173             : // Subset of types that a value can have
     174             : enum class ValType {
     175             :   I32 = WASM_TYPE_I32,
     176             :   I64 = WASM_TYPE_I64,
     177             :   F32 = WASM_TYPE_F32,
     178             :   F64 = WASM_TYPE_F64,
     179             : };
     180             : 
     181             : // Linking metadata kinds.
     182             : enum : unsigned {
     183             :   WASM_STACK_POINTER  = 0x1,
     184             :   WASM_SYMBOL_INFO    = 0x2,
     185             :   WASM_DATA_SIZE      = 0x3,
     186             :   WASM_DATA_ALIGNMENT = 0x4,
     187             : };
     188             : 
     189             : enum : unsigned {
     190             :   WASM_SYMBOL_FLAG_WEAK = 0x1,
     191             : };
     192             : 
     193             : #define WASM_RELOC(name, value) name = value,
     194             : 
     195             : enum : unsigned {
     196             : #include "WasmRelocs/WebAssembly.def"
     197             : };
     198             : 
     199             : #undef WASM_RELOC
     200             : 
     201             : struct Global {
     202             :   ValType Type;
     203             :   bool Mutable;
     204             : 
     205             :   // The initial value for this global is either the value of an imported
     206             :   // global, in which case InitialModule and InitialName specify the global
     207             :   // import, or a value, in which case InitialModule is empty and InitialValue
     208             :   // holds the value.
     209             :   StringRef InitialModule;
     210             :   StringRef InitialName;
     211             :   uint64_t InitialValue;
     212             : };
     213             : 
     214             : } // end namespace wasm
     215             : } // end namespace llvm
     216             : 
     217             : #endif

Generated by: LCOV version 1.13