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 WasmSignatureWasmSignature314 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 345