Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/BinaryFormat/Wasm.h
Line
Count
Source
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
20
namespace llvm {
21
namespace wasm {
22
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;
31
32
struct WasmObjectHeader {
33
  StringRef Magic;
34
  uint32_t Version;
35
};
36
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
43
};
44
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;
49
};
50
51
struct WasmFeatureEntry {
52
  uint8_t Prefix;
53
  std::string Name;
54
};
55
56
struct WasmExport {
57
  StringRef Name;
58
  uint8_t Kind;
59
  uint32_t Index;
60
};
61
62
struct WasmLimits {
63
  uint8_t Flags;
64
  uint32_t Initial;
65
  uint32_t Maximum;
66
};
67
68
struct WasmTable {
69
  uint8_t ElemType;
70
  WasmLimits Limits;
71
};
72
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;
82
};
83
84
struct WasmGlobalType {
85
  uint8_t Type;
86
  bool Mutable;
87
};
88
89
struct WasmGlobal {
90
  uint32_t Index;
91
  WasmGlobalType Type;
92
  WasmInitExpr InitExpr;
93
  StringRef SymbolName; // from the "linking" section
94
};
95
96
struct WasmEventType {
97
  // Kind of event. Currently only WASM_EVENT_ATTRIBUTE_EXCEPTION is possible.
98
  uint32_t Attribute;
99
  uint32_t SigIndex;
100
};
101
102
struct WasmEvent {
103
  uint32_t Index;
104
  WasmEventType Type;
105
  StringRef SymbolName; // from the "linking" section
106
};
107
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;
118
  };
119
};
120
121
struct WasmLocalDecl {
122
  uint8_t Type;
123
  uint32_t Count;
124
};
125
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
136
};
137
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
147
};
148
149
struct WasmElemSegment {
150
  uint32_t TableIndex;
151
  WasmInitExpr Offset;
152
  std::vector<uint32_t> Functions;
153
};
154
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;
161
};
162
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.
168
};
169
170
struct WasmInitFunc {
171
  uint32_t Priority;
172
  uint32_t Symbol;
173
};
174
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;
187
  };
188
};
189
190
struct WasmFunctionName {
191
  uint32_t Index;
192
  StringRef Name;
193
};
194
195
struct WasmLinkingData {
196
  uint32_t Version;
197
  std::vector<WasmInitFunc> InitFunctions;
198
  std::vector<StringRef> Comdats;
199
  std::vector<WasmSymbolInfo> SymbolTable;
200
};
201
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
217
};
218
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
230
};
231
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,
239
};
240
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,
254
  WASM_OPCODE_MISC_PREFIX = 0xfc,
255
  WASM_OPCODE_MEMORY_INIT = 0x08,
256
  WASM_OPCODE_DATA_DROP = 0x09,
257
};
258
259
enum : unsigned {
260
  WASM_LIMITS_FLAG_HAS_MAX = 0x1,
261
  WASM_LIMITS_FLAG_IS_SHARED = 0x2,
262
};
263
264
enum : unsigned {
265
  WASM_SEGMENT_IS_PASSIVE = 0x01,
266
  WASM_SEGMENT_HAS_MEMINDEX = 0x02,
267
};
268
269
// Feature policy prefixes used in the custom "target_features" section
270
enum : uint8_t {
271
  WASM_FEATURE_PREFIX_USED = '+',
272
  WASM_FEATURE_PREFIX_REQUIRED = '=',
273
  WASM_FEATURE_PREFIX_DISALLOWED = '-',
274
};
275
276
// Kind codes used in the custom "name" section
277
enum : unsigned {
278
  WASM_NAMES_FUNCTION = 0x1,
279
  WASM_NAMES_LOCAL = 0x2,
280
};
281
282
// Kind codes used in the custom "linking" section
283
enum : unsigned {
284
  WASM_SEGMENT_INFO = 0x5,
285
  WASM_INIT_FUNCS = 0x6,
286
  WASM_COMDAT_INFO = 0x7,
287
  WASM_SYMBOL_TABLE = 0x8,
288
};
289
290
// Kind codes used in the custom "linking" section in the WASM_COMDAT_INFO
291
enum : unsigned {
292
  WASM_COMDAT_DATA = 0x0,
293
  WASM_COMDAT_FUNCTION = 0x1,
294
};
295
296
// Kind codes used in the custom "linking" section in the WASM_SYMBOL_TABLE
297
enum WasmSymbolType : unsigned {
298
  WASM_SYMBOL_TYPE_FUNCTION = 0x0,
299
  WASM_SYMBOL_TYPE_DATA = 0x1,
300
  WASM_SYMBOL_TYPE_GLOBAL = 0x2,
301
  WASM_SYMBOL_TYPE_SECTION = 0x3,
302
  WASM_SYMBOL_TYPE_EVENT = 0x4,
303
};
304
305
// Kinds of event attributes.
306
enum WasmEventAttribute : unsigned {
307
  WASM_EVENT_ATTRIBUTE_EXCEPTION = 0x0,
308
};
309
310
const unsigned WASM_SYMBOL_BINDING_MASK = 0x3;
311
const unsigned WASM_SYMBOL_VISIBILITY_MASK = 0xc;
312
313
const unsigned WASM_SYMBOL_BINDING_GLOBAL = 0x0;
314
const unsigned WASM_SYMBOL_BINDING_WEAK = 0x1;
315
const unsigned WASM_SYMBOL_BINDING_LOCAL = 0x2;
316
const unsigned WASM_SYMBOL_VISIBILITY_DEFAULT = 0x0;
317
const unsigned WASM_SYMBOL_VISIBILITY_HIDDEN = 0x4;
318
const unsigned WASM_SYMBOL_UNDEFINED = 0x10;
319
const unsigned WASM_SYMBOL_EXPORTED = 0x20;
320
const unsigned WASM_SYMBOL_EXPLICIT_NAME = 0x40;
321
322
#define WASM_RELOC(name, value) name = value,
323
324
enum : unsigned {
325
#include "WasmRelocs.def"
326
};
327
328
#undef WASM_RELOC
329
330
// Subset of types that a value can have
331
enum class ValType {
332
  I32 = WASM_TYPE_I32,
333
  I64 = WASM_TYPE_I64,
334
  F32 = WASM_TYPE_F32,
335
  F64 = WASM_TYPE_F64,
336
  V128 = WASM_TYPE_V128,
337
  EXNREF = WASM_TYPE_EXNREF,
338
};
339
340
struct WasmSignature {
341
  SmallVector<ValType, 1> Returns;
342
  SmallVector<ValType, 4> Params;
343
  // Support empty and tombstone instances, needed by DenseMap.
344
  enum { Plain, Empty, Tombstone } State = Plain;
345
346
  WasmSignature(SmallVector<ValType, 1> &&InReturns,
347
                SmallVector<ValType, 4> &&InParams)
348
764
      : Returns(InReturns), Params(InParams) {}
349
9.26k
  WasmSignature() = default;
350
};
351
352
// Useful comparison operators
353
inline bool operator==(const WasmSignature &LHS, const WasmSignature &RHS) {
354
  return LHS.State == RHS.State && LHS.Returns == RHS.Returns &&
355
         LHS.Params == RHS.Params;
356
}
357
358
inline bool operator!=(const WasmSignature &LHS, const WasmSignature &RHS) {
359
  return !(LHS == RHS);
360
}
361
362
inline bool operator==(const WasmGlobalType &LHS, const WasmGlobalType &RHS) {
363
  return LHS.Type == RHS.Type && LHS.Mutable == RHS.Mutable;
364
}
365
366
inline bool operator!=(const WasmGlobalType &LHS, const WasmGlobalType &RHS) {
367
  return !(LHS == RHS);
368
}
369
370
std::string toString(WasmSymbolType type);
371
std::string relocTypetoString(uint32_t type);
372
bool relocTypeHasAddend(uint32_t type);
373
374
} // end namespace wasm
375
} // end namespace llvm
376
377
#endif