contrib/llvm/include/llvm/BinaryFormat/Wasm.h

   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 struct WasmObjectHeader {
  31   StringRef Magic;
  32   uint32_t Version;
  33 };
  34
  35 struct WasmSignature {
  36   std::vector<int32_t> ParamTypes;
  37   int32_t ReturnType;
  38 };
  39
  40 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 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 struct WasmFunction {
  92   std::vector<WasmLocalDecl> Locals;
  93   ArrayRef<uint8_t> Body;
  94 };
  95
  96 struct WasmDataSegment {
  97   uint32_t Index;
  98   WasmInitExpr Offset;
  99   ArrayRef<uint8_t> Content;
 100 };
 101
 102 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   int32_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 enum : unsigned {
 116   WASM_SEC_CUSTOM = 0,   // Custom / User-defined section
 117   WASM_SEC_TYPE = 1,     // Function signature declarations
 118   WASM_SEC_IMPORT = 2,   // Import declarations
 119   WASM_SEC_FUNCTION = 3, // Function declarations
 120   WASM_SEC_TABLE = 4,    // Indirect function table and other tables
 121   WASM_SEC_MEMORY = 5,   // Memory attributes
 122   WASM_SEC_GLOBAL = 6,   // Global declarations
 123   WASM_SEC_EXPORT = 7,   // Exports
 124   WASM_SEC_START = 8,    // Start function declaration
 125   WASM_SEC_ELEM = 9,     // Elements section
 126   WASM_SEC_CODE = 10,    // Function bodies (code)
 127   WASM_SEC_DATA = 11     // Data segments
 128 };
 129
 130 // Type immediate encodings used in various contexts.
 131 enum {
 132   WASM_TYPE_I32 = -0x01,
 133   WASM_TYPE_I64 = -0x02,
 134   WASM_TYPE_F32 = -0x03,
 135   WASM_TYPE_F64 = -0x04,
 136   WASM_TYPE_ANYFUNC = -0x10,
 137   WASM_TYPE_FUNC = -0x20,
 138   WASM_TYPE_NORESULT = -0x40, // for blocks with no result values
 139 };
 140
 141 // Kinds of externals (for imports and exports).
 142 enum : unsigned {
 143   WASM_EXTERNAL_FUNCTION = 0x0,
 144   WASM_EXTERNAL_TABLE = 0x1,
 145   WASM_EXTERNAL_MEMORY = 0x2,
 146   WASM_EXTERNAL_GLOBAL = 0x3,
 147 };
 148
 149 // Opcodes used in initializer expressions.
 150 enum : unsigned {
 151   WASM_OPCODE_END = 0x0b,
 152   WASM_OPCODE_GET_GLOBAL = 0x23,
 153   WASM_OPCODE_I32_CONST = 0x41,
 154   WASM_OPCODE_I64_CONST = 0x42,
 155   WASM_OPCODE_F32_CONST = 0x43,
 156   WASM_OPCODE_F64_CONST = 0x44,
 157 };
 158
 159 enum : unsigned {
 160   WASM_NAMES_FUNCTION = 0x1,
 161   WASM_NAMES_LOCAL = 0x2,
 162 };
 163
 164 enum : unsigned {
 165   WASM_LIMITS_FLAG_HAS_MAX = 0x1,
 166 };
 167
 168 // Subset of types that a value can have
 169 enum class ValType {
 170   I32 = WASM_TYPE_I32,
 171   I64 = WASM_TYPE_I64,
 172   F32 = WASM_TYPE_F32,
 173   F64 = WASM_TYPE_F64,
 174 };
 175
 176 // Linking metadata kinds.
 177 enum : unsigned {
 178   WASM_STACK_POINTER = 0x1,
 179 };
 180
 181 #define WASM_RELOC(name, value) name = value,
 182
 183 enum : unsigned {
 184 #include "WasmRelocs/WebAssembly.def"
 185 };
 186
 187 #undef WASM_RELOC
 188
 189 struct Global {
 190   ValType Type;
 191   bool Mutable;
 192
 193   // The initial value for this global is either the value of an imported
 194   // global, in which case InitialModule and InitialName specify the global
 195   // import, or a value, in which case InitialModule is empty and InitialValue
 196   // holds the value.
 197   StringRef InitialModule;
 198   StringRef InitialName;
 199   uint64_t InitialValue;
 200 };
 201
 202 } // end namespace wasm
 203 } // end namespace llvm
 204
 205 #endif