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