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 #include "llvm/ADT/SmallVector.h"
  20
  21 namespace llvm {
  22 namespace wasm {
  23
  24 // Object file magic string.
  25 const char WasmMagic[] = {'\0', 'a', 's', 'm'};
  26 // Wasm binary format version
  27 const uint32_t WasmVersion = 0x1;
  28 // Wasm linking metadata version
  29 const uint32_t WasmMetadataVersion = 0x2;
  30 // Wasm uses a 64k page size
  31 const uint32_t WasmPageSize = 65536;
  32
  33 struct WasmObjectHeader {
  34   StringRef Magic;
  35   uint32_t Version;
  36 };
  37
  38 struct WasmDylinkInfo {
  39   uint32_t MemorySize; // Memory size in bytes
  40   uint32_t MemoryAlignment;  // P2 alignment of memory
  41   uint32_t TableSize;  // Table size in elements
  42   uint32_t TableAlignment;  // P2 alignment of table
  43   std::vector<StringRef> Needed; // Shared library depenedencies
  44 };
  45
  46 struct WasmExport {
  47   StringRef Name;
  48   uint8_t Kind;
  49   uint32_t Index;
  50 };
  51
  52 struct WasmLimits {
  53   uint8_t Flags;
  54   uint32_t Initial;
  55   uint32_t Maximum;
  56 };
  57
  58 struct WasmTable {
  59   uint8_t ElemType;
  60   WasmLimits Limits;
  61 };
  62
  63 struct WasmInitExpr {
  64   uint8_t Opcode;
  65   union {
  66     int32_t Int32;
  67     int64_t Int64;
  68     int32_t Float32;
  69     int64_t Float64;
  70     uint32_t Global;
  71   } Value;
  72 };
  73
  74 struct WasmGlobalType {
  75   uint8_t Type;
  76   bool Mutable;
  77 };
  78
  79 struct WasmGlobal {
  80   uint32_t Index;
  81   WasmGlobalType Type;
  82   WasmInitExpr InitExpr;
  83   StringRef SymbolName; // from the "linking" section
  84 };
  85
  86 struct WasmEventType {
  87   // Kind of event. Currently only WASM_EVENT_ATTRIBUTE_EXCEPTION is possible.
  88   uint32_t Attribute;
  89   uint32_t SigIndex;
  90 };
  91
  92 struct WasmEvent {
  93   uint32_t Index;
  94   WasmEventType Type;
  95   StringRef SymbolName; // from the "linking" section
  96 };
  97
  98 struct WasmImport {
  99   StringRef Module;
 100   StringRef Field;
 101   uint8_t Kind;
 102   union {
 103     uint32_t SigIndex;
 104     WasmGlobalType Global;
 105     WasmTable Table;
 106     WasmLimits Memory;
 107     WasmEventType Event;
 108   };
 109 };
 110
 111 struct WasmLocalDecl {
 112   uint8_t Type;
 113   uint32_t Count;
 114 };
 115
 116 struct WasmFunction {
 117   uint32_t Index;
 118   std::vector<WasmLocalDecl> Locals;
 119   ArrayRef<uint8_t> Body;
 120   uint32_t CodeSectionOffset;
 121   uint32_t Size;
 122   uint32_t CodeOffset;  // start of Locals and Body
 123   StringRef SymbolName; // from the "linking" section
 124   StringRef DebugName;  // from the "name" section
 125   uint32_t Comdat;      // from the "comdat info" section
 126 };
 127
 128 struct WasmDataSegment {
 129   uint32_t MemoryIndex;
 130   WasmInitExpr Offset;
 131   ArrayRef<uint8_t> Content;
 132   StringRef Name; // from the "segment info" section
 133   uint32_t Alignment;
 134   uint32_t Flags;
 135   uint32_t Comdat; // from the "comdat info" section
 136 };
 137
 138 struct WasmElemSegment {
 139   uint32_t TableIndex;
 140   WasmInitExpr Offset;
 141   std::vector<uint32_t> Functions;
 142 };
 143
 144 // Represents the location of a Wasm data symbol within a WasmDataSegment, as
 145 // the index of the segment, and the offset and size within the segment.
 146 struct WasmDataReference {
 147   uint32_t Segment;
 148   uint32_t Offset;
 149   uint32_t Size;
 150 };
 151
 152 struct WasmRelocation {
 153   uint8_t Type;    // The type of the relocation.
 154   uint32_t Index;  // Index into either symbol or type index space.
 155   uint64_t Offset; // Offset from the start of the section.
 156   int64_t Addend;  // A value to add to the symbol.
 157 };
 158
 159 struct WasmInitFunc {
 160   uint32_t Priority;
 161   uint32_t Symbol;
 162 };
 163
 164 struct WasmSymbolInfo {
 165   StringRef Name;
 166   uint8_t Kind;
 167   uint32_t Flags;
 168   StringRef ImportModule; // For undefined symbols the module of the import
 169   StringRef ImportName;   // For undefined symbols the name of the import
 170   union {
 171     // For function or global symbols, the index in function or global index
 172     // space.
 173     uint32_t ElementIndex;
 174     // For a data symbols, the address of the data relative to segment.
 175     WasmDataReference DataRef;
 176   };
 177 };
 178
 179 struct WasmFunctionName {
 180   uint32_t Index;
 181   StringRef Name;
 182 };
 183
 184 struct WasmLinkingData {
 185   uint32_t Version;
 186   std::vector<WasmInitFunc> InitFunctions;
 187   std::vector<StringRef> Comdats;
 188   std::vector<WasmSymbolInfo> SymbolTable;
 189 };
 190
 191 enum : unsigned {
 192   WASM_SEC_CUSTOM = 0,     // Custom / User-defined section
 193   WASM_SEC_TYPE = 1,       // Function signature declarations
 194   WASM_SEC_IMPORT = 2,     // Import declarations
 195   WASM_SEC_FUNCTION = 3,   // Function declarations
 196   WASM_SEC_TABLE = 4,      // Indirect function table and other tables
 197   WASM_SEC_MEMORY = 5,     // Memory attributes
 198   WASM_SEC_GLOBAL = 6,     // Global declarations
 199   WASM_SEC_EXPORT = 7,     // Exports
 200   WASM_SEC_START = 8,      // Start function declaration
 201   WASM_SEC_ELEM = 9,       // Elements section
 202   WASM_SEC_CODE = 10,      // Function bodies (code)
 203   WASM_SEC_DATA = 11,      // Data segments
 204   WASM_SEC_DATACOUNT = 12, // Data segment count
 205   WASM_SEC_EVENT = 13      // Event declarations
 206 };
 207
 208 // Type immediate encodings used in various contexts.
 209 enum : unsigned {
 210   WASM_TYPE_I32 = 0x7F,
 211   WASM_TYPE_I64 = 0x7E,
 212   WASM_TYPE_F32 = 0x7D,
 213   WASM_TYPE_F64 = 0x7C,
 214   WASM_TYPE_V128 = 0x7B,
 215   WASM_TYPE_FUNCREF = 0x70,
 216   WASM_TYPE_EXCEPT_REF = 0x68,
 217   WASM_TYPE_FUNC = 0x60,
 218   WASM_TYPE_NORESULT = 0x40, // for blocks with no result values
 219 };
 220
 221 // Kinds of externals (for imports and exports).
 222 enum : unsigned {
 223   WASM_EXTERNAL_FUNCTION = 0x0,
 224   WASM_EXTERNAL_TABLE = 0x1,
 225   WASM_EXTERNAL_MEMORY = 0x2,
 226   WASM_EXTERNAL_GLOBAL = 0x3,
 227   WASM_EXTERNAL_EVENT = 0x4,
 228 };
 229
 230 // Opcodes used in initializer expressions.
 231 enum : unsigned {
 232   WASM_OPCODE_END = 0x0b,
 233   WASM_OPCODE_GLOBAL_GET = 0x23,
 234   WASM_OPCODE_I32_CONST = 0x41,
 235   WASM_OPCODE_I64_CONST = 0x42,
 236   WASM_OPCODE_F32_CONST = 0x43,
 237   WASM_OPCODE_F64_CONST = 0x44,
 238 };
 239
 240 enum : unsigned {
 241   WASM_LIMITS_FLAG_HAS_MAX = 0x1,
 242   WASM_LIMITS_FLAG_IS_SHARED = 0x2,
 243 };
 244
 245 // Kind codes used in the custom "name" section
 246 enum : unsigned {
 247   WASM_NAMES_FUNCTION = 0x1,
 248   WASM_NAMES_LOCAL = 0x2,
 249 };
 250
 251 // Kind codes used in the custom "linking" section
 252 enum : unsigned {
 253   WASM_SEGMENT_INFO = 0x5,
 254   WASM_INIT_FUNCS = 0x6,
 255   WASM_COMDAT_INFO = 0x7,
 256   WASM_SYMBOL_TABLE = 0x8,
 257 };
 258
 259 // Kind codes used in the custom "linking" section in the WASM_COMDAT_INFO
 260 enum : unsigned {
 261   WASM_COMDAT_DATA = 0x0,
 262   WASM_COMDAT_FUNCTION = 0x1,
 263 };
 264
 265 // Kind codes used in the custom "linking" section in the WASM_SYMBOL_TABLE
 266 enum WasmSymbolType : unsigned {
 267   WASM_SYMBOL_TYPE_FUNCTION = 0x0,
 268   WASM_SYMBOL_TYPE_DATA = 0x1,
 269   WASM_SYMBOL_TYPE_GLOBAL = 0x2,
 270   WASM_SYMBOL_TYPE_SECTION = 0x3,
 271   WASM_SYMBOL_TYPE_EVENT = 0x4,
 272 };
 273
 274 // Kinds of event attributes.
 275 enum WasmEventAttribute : unsigned {
 276   WASM_EVENT_ATTRIBUTE_EXCEPTION = 0x0,
 277 };
 278
 279 const unsigned WASM_SYMBOL_BINDING_MASK = 0x3;
 280 const unsigned WASM_SYMBOL_VISIBILITY_MASK = 0xc;
 281
 282 const unsigned WASM_SYMBOL_BINDING_GLOBAL = 0x0;
 283 const unsigned WASM_SYMBOL_BINDING_WEAK = 0x1;
 284 const unsigned WASM_SYMBOL_BINDING_LOCAL = 0x2;
 285 const unsigned WASM_SYMBOL_VISIBILITY_DEFAULT = 0x0;
 286 const unsigned WASM_SYMBOL_VISIBILITY_HIDDEN = 0x4;
 287 const unsigned WASM_SYMBOL_UNDEFINED = 0x10;
 288 const unsigned WASM_SYMBOL_EXPLICIT_NAME = 0x40;
 289
 290 #define WASM_RELOC(name, value) name = value,
 291
 292 enum : unsigned {
 293 #include "WasmRelocs.def"
 294 };
 295
 296 #undef WASM_RELOC
 297
 298 // Subset of types that a value can have
 299 enum class ValType {
 300   I32 = WASM_TYPE_I32,
 301   I64 = WASM_TYPE_I64,
 302   F32 = WASM_TYPE_F32,
 303   F64 = WASM_TYPE_F64,
 304   V128 = WASM_TYPE_V128,
 305   EXCEPT_REF = WASM_TYPE_EXCEPT_REF,
 306 };
 307
 308 struct WasmSignature {
 309   SmallVector<wasm::ValType, 1> Returns;
 310   SmallVector<wasm::ValType, 4> Params;
 311   // Support empty and tombstone instances, needed by DenseMap.
 312   enum { Plain, Empty, Tombstone } State = Plain;
 313
 314   WasmSignature(SmallVector<wasm::ValType, 1> &&InReturns,
 315                 SmallVector<wasm::ValType, 4> &&InParams)
 316       : Returns(InReturns), Params(InParams) {}
 317   WasmSignature() = default;
 318 };
 319
 320 // Useful comparison operators
 321 inline bool operator==(const WasmSignature &LHS, const WasmSignature &RHS) {
 322   return LHS.State == RHS.State && LHS.Returns == RHS.Returns &&
 323          LHS.Params == RHS.Params;
 324 }
 325
 326 inline bool operator!=(const WasmSignature &LHS, const WasmSignature &RHS) {
 327   return !(LHS == RHS);
 328 }
 329
 330 inline bool operator==(const WasmGlobalType &LHS, const WasmGlobalType &RHS) {
 331   return LHS.Type == RHS.Type && LHS.Mutable == RHS.Mutable;
 332 }
 333
 334 inline bool operator!=(const WasmGlobalType &LHS, const WasmGlobalType &RHS) {
 335   return !(LHS == RHS);
 336 }
 337
 338 std::string toString(wasm::WasmSymbolType type);
 339 std::string relocTypetoString(uint32_t type);
 340
 341 } // end namespace wasm
 342 } // end namespace llvm
 343
 344 #endif