[llvm] [cmake] Add possibility to use ChooseMSVCCRT.cmake when include LLVM library
[llvm-core.git] / include / llvm / BinaryFormat / Wasm.h
blobe2c94a12ad67905d6a37f5ee4d8a9fb49ee4b27b
1 //===- Wasm.h - Wasm object file format -------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file defines manifest constants for the wasm object file format.
10 // See: https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md
12 //===----------------------------------------------------------------------===//
14 #ifndef LLVM_BINARYFORMAT_WASM_H
15 #define LLVM_BINARYFORMAT_WASM_H
17 #include "llvm/ADT/ArrayRef.h"
18 #include "llvm/ADT/SmallVector.h"
20 namespace llvm {
21 namespace wasm {
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 linking metadata version
28 const uint32_t WasmMetadataVersion = 0x2;
29 // Wasm uses a 64k page size
30 const uint32_t WasmPageSize = 65536;
32 struct WasmObjectHeader {
33 StringRef Magic;
34 uint32_t Version;
37 struct WasmDylinkInfo {
38 uint32_t MemorySize; // Memory size in bytes
39 uint32_t MemoryAlignment; // P2 alignment of memory
40 uint32_t TableSize; // Table size in elements
41 uint32_t TableAlignment; // P2 alignment of table
42 std::vector<StringRef> Needed; // Shared library depenedencies
45 struct WasmProducerInfo {
46 std::vector<std::pair<std::string, std::string>> Languages;
47 std::vector<std::pair<std::string, std::string>> Tools;
48 std::vector<std::pair<std::string, std::string>> SDKs;
51 struct WasmFeatureEntry {
52 uint8_t Prefix;
53 std::string Name;
56 struct WasmExport {
57 StringRef Name;
58 uint8_t Kind;
59 uint32_t Index;
62 struct WasmLimits {
63 uint8_t Flags;
64 uint32_t Initial;
65 uint32_t Maximum;
68 struct WasmTable {
69 uint8_t ElemType;
70 WasmLimits Limits;
73 struct WasmInitExpr {
74 uint8_t Opcode;
75 union {
76 int32_t Int32;
77 int64_t Int64;
78 int32_t Float32;
79 int64_t Float64;
80 uint32_t Global;
81 } Value;
84 struct WasmGlobalType {
85 uint8_t Type;
86 bool Mutable;
89 struct WasmGlobal {
90 uint32_t Index;
91 WasmGlobalType Type;
92 WasmInitExpr InitExpr;
93 StringRef SymbolName; // from the "linking" section
96 struct WasmEventType {
97 // Kind of event. Currently only WASM_EVENT_ATTRIBUTE_EXCEPTION is possible.
98 uint32_t Attribute;
99 uint32_t SigIndex;
102 struct WasmEvent {
103 uint32_t Index;
104 WasmEventType Type;
105 StringRef SymbolName; // from the "linking" section
108 struct WasmImport {
109 StringRef Module;
110 StringRef Field;
111 uint8_t Kind;
112 union {
113 uint32_t SigIndex;
114 WasmGlobalType Global;
115 WasmTable Table;
116 WasmLimits Memory;
117 WasmEventType Event;
121 struct WasmLocalDecl {
122 uint8_t Type;
123 uint32_t Count;
126 struct WasmFunction {
127 uint32_t Index;
128 std::vector<WasmLocalDecl> Locals;
129 ArrayRef<uint8_t> Body;
130 uint32_t CodeSectionOffset;
131 uint32_t Size;
132 uint32_t CodeOffset; // start of Locals and Body
133 StringRef SymbolName; // from the "linking" section
134 StringRef DebugName; // from the "name" section
135 uint32_t Comdat; // from the "comdat info" section
138 struct WasmDataSegment {
139 uint32_t InitFlags;
140 uint32_t MemoryIndex; // present if InitFlags & WASM_SEGMENT_HAS_MEMINDEX
141 WasmInitExpr Offset; // present if InitFlags & WASM_SEGMENT_IS_PASSIVE == 0
142 ArrayRef<uint8_t> Content;
143 StringRef Name; // from the "segment info" section
144 uint32_t Alignment;
145 uint32_t LinkerFlags;
146 uint32_t Comdat; // from the "comdat info" section
149 struct WasmElemSegment {
150 uint32_t TableIndex;
151 WasmInitExpr Offset;
152 std::vector<uint32_t> Functions;
155 // Represents the location of a Wasm data symbol within a WasmDataSegment, as
156 // the index of the segment, and the offset and size within the segment.
157 struct WasmDataReference {
158 uint32_t Segment;
159 uint32_t Offset;
160 uint32_t Size;
163 struct WasmRelocation {
164 uint8_t Type; // The type of the relocation.
165 uint32_t Index; // Index into either symbol or type index space.
166 uint64_t Offset; // Offset from the start of the section.
167 int64_t Addend; // A value to add to the symbol.
170 struct WasmInitFunc {
171 uint32_t Priority;
172 uint32_t Symbol;
175 struct WasmSymbolInfo {
176 StringRef Name;
177 uint8_t Kind;
178 uint32_t Flags;
179 StringRef ImportModule; // For undefined symbols the module of the import
180 StringRef ImportName; // For undefined symbols the name of the import
181 union {
182 // For function or global symbols, the index in function or global index
183 // space.
184 uint32_t ElementIndex;
185 // For a data symbols, the address of the data relative to segment.
186 WasmDataReference DataRef;
190 struct WasmFunctionName {
191 uint32_t Index;
192 StringRef Name;
195 struct WasmLinkingData {
196 uint32_t Version;
197 std::vector<WasmInitFunc> InitFunctions;
198 std::vector<StringRef> Comdats;
199 std::vector<WasmSymbolInfo> SymbolTable;
202 enum : unsigned {
203 WASM_SEC_CUSTOM = 0, // Custom / User-defined section
204 WASM_SEC_TYPE = 1, // Function signature declarations
205 WASM_SEC_IMPORT = 2, // Import declarations
206 WASM_SEC_FUNCTION = 3, // Function declarations
207 WASM_SEC_TABLE = 4, // Indirect function table and other tables
208 WASM_SEC_MEMORY = 5, // Memory attributes
209 WASM_SEC_GLOBAL = 6, // Global declarations
210 WASM_SEC_EXPORT = 7, // Exports
211 WASM_SEC_START = 8, // Start function declaration
212 WASM_SEC_ELEM = 9, // Elements section
213 WASM_SEC_CODE = 10, // Function bodies (code)
214 WASM_SEC_DATA = 11, // Data segments
215 WASM_SEC_DATACOUNT = 12, // Data segment count
216 WASM_SEC_EVENT = 13 // Event declarations
219 // Type immediate encodings used in various contexts.
220 enum : unsigned {
221 WASM_TYPE_I32 = 0x7F,
222 WASM_TYPE_I64 = 0x7E,
223 WASM_TYPE_F32 = 0x7D,
224 WASM_TYPE_F64 = 0x7C,
225 WASM_TYPE_V128 = 0x7B,
226 WASM_TYPE_FUNCREF = 0x70,
227 WASM_TYPE_EXNREF = 0x68,
228 WASM_TYPE_FUNC = 0x60,
229 WASM_TYPE_NORESULT = 0x40, // for blocks with no result values
232 // Kinds of externals (for imports and exports).
233 enum : unsigned {
234 WASM_EXTERNAL_FUNCTION = 0x0,
235 WASM_EXTERNAL_TABLE = 0x1,
236 WASM_EXTERNAL_MEMORY = 0x2,
237 WASM_EXTERNAL_GLOBAL = 0x3,
238 WASM_EXTERNAL_EVENT = 0x4,
241 // Opcodes used in initializer expressions.
242 enum : unsigned {
243 WASM_OPCODE_END = 0x0b,
244 WASM_OPCODE_CALL = 0x10,
245 WASM_OPCODE_LOCAL_GET = 0x20,
246 WASM_OPCODE_GLOBAL_GET = 0x23,
247 WASM_OPCODE_GLOBAL_SET = 0x24,
248 WASM_OPCODE_I32_STORE = 0x36,
249 WASM_OPCODE_I32_CONST = 0x41,
250 WASM_OPCODE_I64_CONST = 0x42,
251 WASM_OPCODE_F32_CONST = 0x43,
252 WASM_OPCODE_F64_CONST = 0x44,
253 WASM_OPCODE_I32_ADD = 0x6a,
256 // Opcodes used in synthetic functions.
257 enum : unsigned {
258 WASM_OPCODE_IF = 0x04,
259 WASM_OPCODE_ELSE = 0x05,
260 WASM_OPCODE_DROP = 0x1a,
261 WASM_OPCODE_MISC_PREFIX = 0xfc,
262 WASM_OPCODE_MEMORY_INIT = 0x08,
263 WASM_OPCODE_DATA_DROP = 0x09,
264 WASM_OPCODE_ATOMICS_PREFIX = 0xfe,
265 WASM_OPCODE_ATOMIC_NOTIFY = 0x00,
266 WASM_OPCODE_I32_ATOMIC_WAIT = 0x01,
267 WASM_OPCODE_I32_ATOMIC_STORE = 0x17,
268 WASM_OPCODE_I32_RMW_CMPXCHG = 0x48,
271 enum : unsigned {
272 WASM_LIMITS_FLAG_HAS_MAX = 0x1,
273 WASM_LIMITS_FLAG_IS_SHARED = 0x2,
276 enum : unsigned {
277 WASM_SEGMENT_IS_PASSIVE = 0x01,
278 WASM_SEGMENT_HAS_MEMINDEX = 0x02,
281 // Feature policy prefixes used in the custom "target_features" section
282 enum : uint8_t {
283 WASM_FEATURE_PREFIX_USED = '+',
284 WASM_FEATURE_PREFIX_REQUIRED = '=',
285 WASM_FEATURE_PREFIX_DISALLOWED = '-',
288 // Kind codes used in the custom "name" section
289 enum : unsigned {
290 WASM_NAMES_FUNCTION = 0x1,
291 WASM_NAMES_LOCAL = 0x2,
294 // Kind codes used in the custom "linking" section
295 enum : unsigned {
296 WASM_SEGMENT_INFO = 0x5,
297 WASM_INIT_FUNCS = 0x6,
298 WASM_COMDAT_INFO = 0x7,
299 WASM_SYMBOL_TABLE = 0x8,
302 // Kind codes used in the custom "linking" section in the WASM_COMDAT_INFO
303 enum : unsigned {
304 WASM_COMDAT_DATA = 0x0,
305 WASM_COMDAT_FUNCTION = 0x1,
308 // Kind codes used in the custom "linking" section in the WASM_SYMBOL_TABLE
309 enum WasmSymbolType : unsigned {
310 WASM_SYMBOL_TYPE_FUNCTION = 0x0,
311 WASM_SYMBOL_TYPE_DATA = 0x1,
312 WASM_SYMBOL_TYPE_GLOBAL = 0x2,
313 WASM_SYMBOL_TYPE_SECTION = 0x3,
314 WASM_SYMBOL_TYPE_EVENT = 0x4,
317 // Kinds of event attributes.
318 enum WasmEventAttribute : unsigned {
319 WASM_EVENT_ATTRIBUTE_EXCEPTION = 0x0,
322 const unsigned WASM_SYMBOL_BINDING_MASK = 0x3;
323 const unsigned WASM_SYMBOL_VISIBILITY_MASK = 0xc;
325 const unsigned WASM_SYMBOL_BINDING_GLOBAL = 0x0;
326 const unsigned WASM_SYMBOL_BINDING_WEAK = 0x1;
327 const unsigned WASM_SYMBOL_BINDING_LOCAL = 0x2;
328 const unsigned WASM_SYMBOL_VISIBILITY_DEFAULT = 0x0;
329 const unsigned WASM_SYMBOL_VISIBILITY_HIDDEN = 0x4;
330 const unsigned WASM_SYMBOL_UNDEFINED = 0x10;
331 const unsigned WASM_SYMBOL_EXPORTED = 0x20;
332 const unsigned WASM_SYMBOL_EXPLICIT_NAME = 0x40;
333 const unsigned WASM_SYMBOL_NO_STRIP = 0x80;
335 #define WASM_RELOC(name, value) name = value,
337 enum : unsigned {
338 #include "WasmRelocs.def"
341 #undef WASM_RELOC
343 // Subset of types that a value can have
344 enum class ValType {
345 I32 = WASM_TYPE_I32,
346 I64 = WASM_TYPE_I64,
347 F32 = WASM_TYPE_F32,
348 F64 = WASM_TYPE_F64,
349 V128 = WASM_TYPE_V128,
350 EXNREF = WASM_TYPE_EXNREF,
353 struct WasmSignature {
354 SmallVector<ValType, 1> Returns;
355 SmallVector<ValType, 4> Params;
356 // Support empty and tombstone instances, needed by DenseMap.
357 enum { Plain, Empty, Tombstone } State = Plain;
359 WasmSignature(SmallVector<ValType, 1> &&InReturns,
360 SmallVector<ValType, 4> &&InParams)
361 : Returns(InReturns), Params(InParams) {}
362 WasmSignature() = default;
365 // Useful comparison operators
366 inline bool operator==(const WasmSignature &LHS, const WasmSignature &RHS) {
367 return LHS.State == RHS.State && LHS.Returns == RHS.Returns &&
368 LHS.Params == RHS.Params;
371 inline bool operator!=(const WasmSignature &LHS, const WasmSignature &RHS) {
372 return !(LHS == RHS);
375 inline bool operator==(const WasmGlobalType &LHS, const WasmGlobalType &RHS) {
376 return LHS.Type == RHS.Type && LHS.Mutable == RHS.Mutable;
379 inline bool operator!=(const WasmGlobalType &LHS, const WasmGlobalType &RHS) {
380 return !(LHS == RHS);
383 std::string toString(WasmSymbolType type);
384 std::string relocTypetoString(uint32_t type);
385 bool relocTypeHasAddend(uint32_t type);
387 } // end namespace wasm
388 } // end namespace llvm
390 #endif