LLVM  8.0.0svn
Wasm.h
Go to the documentation of this file.
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
30 // Wasm uses a 64k page size
31 const uint32_t WasmPageSize = 65536;
32 
36 };
37 
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 };
44 
45 struct WasmExport {
47  uint8_t Kind;
49 };
50 
51 struct WasmLimits {
52  uint8_t Flags;
55 };
56 
57 struct WasmTable {
58  uint8_t ElemType;
60 };
61 
62 struct WasmInitExpr {
63  uint8_t Opcode;
64  union {
65  int32_t Int32;
66  int64_t Int64;
67  int32_t Float32;
68  int64_t Float64;
70  } Value;
71 };
72 
74  uint8_t Type;
75  bool Mutable;
76 };
77 
78 struct WasmGlobal {
82  StringRef SymbolName; // from the "linking" section
83 };
84 
85 struct WasmEventType {
86  // Kind of event. Currently only WASM_EVENT_ATTRIBUTE_EXCEPTION is possible.
89 };
90 
91 struct WasmEvent {
94  StringRef SymbolName; // from the "linking" section
95 };
96 
97 struct WasmImport {
100  uint8_t Kind;
101  union {
107  };
108 };
109 
111  uint8_t Type;
113 };
114 
115 struct WasmFunction {
117  std::vector<WasmLocalDecl> Locals;
121  uint32_t CodeOffset; // start of Locals and Body
122  StringRef SymbolName; // from the "linking" section
123  StringRef DebugName; // from the "name" section
124  uint32_t Comdat; // from the "comdat info" section
125 };
126 
131  StringRef Name; // from the "segment info" section
134  uint32_t Comdat; // from the "comdat info" section
135 };
136 
140  std::vector<uint32_t> Functions;
141 };
142 
143 // Represents the location of a Wasm data symbol within a WasmDataSegment, as
144 // the index of the segment, and the offset and size within the segment.
149 };
150 
152  uint8_t Type; // The type of the relocation.
153  uint32_t Index; // Index into either symbol or type index space.
154  uint64_t Offset; // Offset from the start of the section.
155  int64_t Addend; // A value to add to the symbol.
156 };
157 
158 struct WasmInitFunc {
161 };
162 
165  uint8_t Kind;
167  StringRef Module; // For undefined symbols the module name of the import
168  union {
169  // For function or global symbols, the index in function or global index
170  // space.
172  // For a data symbols, the address of the data relative to segment.
174  };
175 };
176 
180 };
181 
184  std::vector<WasmInitFunc> InitFunctions;
185  std::vector<StringRef> Comdats;
186  std::vector<WasmSymbolInfo> SymbolTable;
187 };
188 
189 enum : unsigned {
190  WASM_SEC_CUSTOM = 0, // Custom / User-defined section
191  WASM_SEC_TYPE = 1, // Function signature declarations
192  WASM_SEC_IMPORT = 2, // Import declarations
193  WASM_SEC_FUNCTION = 3, // Function declarations
194  WASM_SEC_TABLE = 4, // Indirect function table and other tables
195  WASM_SEC_MEMORY = 5, // Memory attributes
196  WASM_SEC_GLOBAL = 6, // Global declarations
197  WASM_SEC_EXPORT = 7, // Exports
198  WASM_SEC_START = 8, // Start function declaration
199  WASM_SEC_ELEM = 9, // Elements section
200  WASM_SEC_CODE = 10, // Function bodies (code)
201  WASM_SEC_DATA = 11, // Data segments
202  WASM_SEC_EVENT = 12 // Event declarations
203 };
204 
205 // Type immediate encodings used in various contexts.
206 enum : unsigned {
215  WASM_TYPE_NORESULT = 0x40, // for blocks with no result values
216 };
217 
218 // Kinds of externals (for imports and exports).
219 enum : unsigned {
225 };
226 
227 // Opcodes used in initializer expressions.
228 enum : unsigned {
235 };
236 
237 enum : unsigned {
240 };
241 
242 // Kind codes used in the custom "name" section
243 enum : unsigned {
246 };
247 
248 // Kind codes used in the custom "linking" section
249 enum : unsigned {
254 };
255 
256 // Kind codes used in the custom "linking" section in the WASM_COMDAT_INFO
257 enum : unsigned {
260 };
261 
262 // Kind codes used in the custom "linking" section in the WASM_SYMBOL_TABLE
263 enum WasmSymbolType : unsigned {
269 };
270 
271 // Kinds of event attributes.
272 enum WasmEventAttribute : unsigned {
274 };
275 
276 const unsigned WASM_SYMBOL_BINDING_MASK = 0x3;
277 const unsigned WASM_SYMBOL_VISIBILITY_MASK = 0xc;
278 
279 const unsigned WASM_SYMBOL_BINDING_GLOBAL = 0x0;
280 const unsigned WASM_SYMBOL_BINDING_WEAK = 0x1;
281 const unsigned WASM_SYMBOL_BINDING_LOCAL = 0x2;
282 const unsigned WASM_SYMBOL_VISIBILITY_DEFAULT = 0x0;
283 const unsigned WASM_SYMBOL_VISIBILITY_HIDDEN = 0x4;
284 const unsigned WASM_SYMBOL_UNDEFINED = 0x10;
285 
286 #define WASM_RELOC(name, value) name = value,
287 
288 enum : unsigned {
289 #include "WasmRelocs.def"
290 };
291 
292 #undef WASM_RELOC
293 
294 // Subset of types that a value can have
295 enum class ValType {
296  I32 = WASM_TYPE_I32,
297  I64 = WASM_TYPE_I64,
298  F32 = WASM_TYPE_F32,
299  F64 = WASM_TYPE_F64,
302 };
303 
307  // Support empty and tombstone instances, needed by DenseMap.
308  enum { Plain, Empty, Tombstone } State = Plain;
309 
312  : Returns(InReturns), Params(InParams) {}
313  WasmSignature() = default;
314 };
315 
316 // Useful comparison operators
317 inline bool operator==(const WasmSignature &LHS, const WasmSignature &RHS) {
318  return LHS.State == RHS.State && LHS.Returns == RHS.Returns &&
319  LHS.Params == RHS.Params;
320 }
321 
322 inline bool operator!=(const WasmSignature &LHS, const WasmSignature &RHS) {
323  return !(LHS == RHS);
324 }
325 
326 inline bool operator==(const WasmGlobalType &LHS, const WasmGlobalType &RHS) {
327  return LHS.Type == RHS.Type && LHS.Mutable == RHS.Mutable;
328 }
329 
330 inline bool operator!=(const WasmGlobalType &LHS, const WasmGlobalType &RHS) {
331  return !(LHS == RHS);
332 }
333 
334 std::string toString(wasm::WasmSymbolType type);
335 std::string relocTypetoString(uint32_t type);
336 
337 } // end namespace wasm
338 } // end namespace llvm
339 
340 #endif
uint32_t TableAlignment
Definition: Wasm.h:42
std::vector< WasmInitFunc > InitFunctions
Definition: Wasm.h:184
WasmSymbolType
Definition: Wasm.h:263
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
const unsigned WASM_SYMBOL_BINDING_LOCAL
Definition: Wasm.h:281
StringRef SymbolName
Definition: Wasm.h:94
WasmGlobalType Type
Definition: Wasm.h:80
const uint32_t WasmMetadataVersion
Definition: Wasm.h:29
SmallVector< wasm::ValType, 1 > Returns
Definition: Wasm.h:305
std::vector< StringRef > Comdats
Definition: Wasm.h:185
WasmEventType Type
Definition: Wasm.h:93
StringRef SymbolName
Definition: Wasm.h:122
const unsigned WASM_SYMBOL_UNDEFINED
Definition: Wasm.h:284
bool operator==(const WasmSignature &LHS, const WasmSignature &RHS)
Definition: Wasm.h:317
WasmTable Table
Definition: Wasm.h:104
StringRef Module
Definition: Wasm.h:98
bool operator!=(const WasmSignature &LHS, const WasmSignature &RHS)
Definition: Wasm.h:322
uint32_t CodeOffset
Definition: Wasm.h:121
const uint32_t WasmVersion
Definition: Wasm.h:27
ArrayRef< uint8_t > Content
Definition: Wasm.h:130
ArrayRef< uint8_t > Body
Definition: Wasm.h:118
uint32_t Index
Definition: Wasm.h:92
uint32_t Attribute
Definition: Wasm.h:87
std::string relocTypetoString(uint32_t type)
Definition: Wasm.cpp:28
uint32_t Initial
Definition: Wasm.h:53
const unsigned WASM_SYMBOL_VISIBILITY_DEFAULT
Definition: Wasm.h:282
uint32_t SigIndex
Definition: Wasm.h:102
WasmLimits Memory
Definition: Wasm.h:105
std::vector< uint32_t > Functions
Definition: Wasm.h:140
const unsigned WASM_SYMBOL_VISIBILITY_HIDDEN
Definition: Wasm.h:283
uint8_t ElemType
Definition: Wasm.h:58
uint32_t MemoryAlignment
Definition: Wasm.h:40
const unsigned WASM_SYMBOL_BINDING_WEAK
Definition: Wasm.h:280
uint32_t CodeSectionOffset
Definition: Wasm.h:119
WasmInitExpr Offset
Definition: Wasm.h:129
WasmEventType Event
Definition: Wasm.h:106
const unsigned WASM_SYMBOL_VISIBILITY_MASK
Definition: Wasm.h:277
StringRef DebugName
Definition: Wasm.h:123
const char WasmMagic[]
Definition: Wasm.h:25
WasmInitExpr InitExpr
Definition: Wasm.h:81
const unsigned WASM_SYMBOL_BINDING_GLOBAL
Definition: Wasm.h:279
enum llvm::wasm::WasmSignature::@147 State
WasmEventAttribute
Definition: Wasm.h:272
WasmLimits Limits
Definition: Wasm.h:59
WasmGlobalType Global
Definition: Wasm.h:103
const unsigned WASM_SYMBOL_BINDING_MASK
Definition: Wasm.h:276
WasmSignature(SmallVector< wasm::ValType, 1 > &&InReturns, SmallVector< wasm::ValType, 4 > &&InParams)
Definition: Wasm.h:310
uint32_t Index
Definition: Wasm.h:48
WasmDataReference DataRef
Definition: Wasm.h:173
LLVM Value Representation.
Definition: Value.h:73
uint32_t Index
Definition: Wasm.h:79
StringRef Name
Definition: Wasm.h:46
const uint32_t WasmPageSize
Definition: Wasm.h:31
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
StringRef SymbolName
Definition: Wasm.h:82
std::string toString(wasm::WasmSymbolType type)
Definition: Wasm.cpp:12
std::vector< WasmSymbolInfo > SymbolTable
Definition: Wasm.h:186
std::vector< WasmLocalDecl > Locals
Definition: Wasm.h:117
SmallVector< wasm::ValType, 4 > Params
Definition: Wasm.h:306
WasmInitExpr Offset
Definition: Wasm.h:139
uint32_t Maximum
Definition: Wasm.h:54
StringRef Field
Definition: Wasm.h:99