Coverage Report

Created: 2018-09-23 22:08

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/BinaryFormat/Wasm.h
Line
Count
Source (jump to first uncovered line)
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
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 = 0x1;
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 WasmSignature {
38
  std::vector<uint8_t> ParamTypes;
39
  uint8_t ReturnType;
40
};
41
42
struct WasmExport {
43
  StringRef Name;
44
  uint8_t Kind;
45
  uint32_t Index;
46
};
47
48
struct WasmLimits {
49
  uint8_t Flags;
50
  uint32_t Initial;
51
  uint32_t Maximum;
52
};
53
54
struct WasmTable {
55
  uint8_t ElemType;
56
  WasmLimits Limits;
57
};
58
59
struct WasmInitExpr {
60
  uint8_t Opcode;
61
  union {
62
    int32_t Int32;
63
    int64_t Int64;
64
    int32_t Float32;
65
    int64_t Float64;
66
    uint32_t Global;
67
  } Value;
68
};
69
70
0
struct WasmGlobalType {
71
  uint8_t Type;
72
  bool Mutable;
73
};
74
75
struct WasmGlobal {
76
  uint32_t Index;
77
  WasmGlobalType Type;
78
  WasmInitExpr InitExpr;
79
  StringRef SymbolName; // from the "linking" section
80
};
81
82
struct WasmImport {
83
  StringRef Module;
84
  StringRef Field;
85
  uint8_t Kind;
86
  union {
87
    uint32_t SigIndex;
88
    WasmGlobalType Global;
89
    WasmTable Table;
90
    WasmLimits Memory;
91
  };
92
};
93
94
struct WasmLocalDecl {
95
  uint8_t Type;
96
  uint32_t Count;
97
};
98
99
struct WasmFunction {
100
  uint32_t Index;
101
  std::vector<WasmLocalDecl> Locals;
102
  ArrayRef<uint8_t> Body;
103
  uint32_t CodeSectionOffset;
104
  uint32_t Size;
105
  uint32_t CodeOffset;  // start of Locals and Body
106
  StringRef SymbolName; // from the "linking" section
107
  StringRef DebugName;  // from the "name" section
108
  uint32_t Comdat;      // from the "comdat info" section
109
};
110
111
struct WasmDataSegment {
112
  uint32_t MemoryIndex;
113
  WasmInitExpr Offset;
114
  ArrayRef<uint8_t> Content;
115
  StringRef Name; // from the "segment info" section
116
  uint32_t Alignment;
117
  uint32_t Flags;
118
  uint32_t Comdat; // from the "comdat info" section
119
};
120
121
struct WasmElemSegment {
122
  uint32_t TableIndex;
123
  WasmInitExpr Offset;
124
  std::vector<uint32_t> Functions;
125
};
126
127
// Represents the location of a Wasm data symbol within a WasmDataSegment, as
128
// the index of the segment, and the offset and size within the segment.
129
struct WasmDataReference {
130
  uint32_t Segment;
131
  uint32_t Offset;
132
  uint32_t Size;
133
};
134
135
struct WasmRelocation {
136
  uint8_t Type;    // The type of the relocation.
137
  uint32_t Index;  // Index into either symbol or type index space.
138
  uint64_t Offset; // Offset from the start of the section.
139
  int64_t Addend;  // A value to add to the symbol.
140
};
141
142
struct WasmInitFunc {
143
  uint32_t Priority;
144
  uint32_t Symbol;
145
};
146
147
struct WasmSymbolInfo {
148
  StringRef Name;
149
  uint8_t Kind;
150
  uint32_t Flags;
151
  StringRef Module; // For undefined symbols the module name of the import
152
  union {
153
    // For function or global symbols, the index in function or global index
154
    // space.
155
    uint32_t ElementIndex;
156
    // For a data symbols, the address of the data relative to segment.
157
    WasmDataReference DataRef;
158
  };
159
};
160
161
struct WasmFunctionName {
162
  uint32_t Index;
163
  StringRef Name;
164
};
165
166
struct WasmLinkingData {
167
  uint32_t Version;
168
  std::vector<WasmInitFunc> InitFunctions;
169
  std::vector<StringRef> Comdats;
170
  std::vector<WasmSymbolInfo> SymbolTable;
171
};
172
173
enum : unsigned {
174
  WASM_SEC_CUSTOM = 0,   // Custom / User-defined section
175
  WASM_SEC_TYPE = 1,     // Function signature declarations
176
  WASM_SEC_IMPORT = 2,   // Import declarations
177
  WASM_SEC_FUNCTION = 3, // Function declarations
178
  WASM_SEC_TABLE = 4,    // Indirect function table and other tables
179
  WASM_SEC_MEMORY = 5,   // Memory attributes
180
  WASM_SEC_GLOBAL = 6,   // Global declarations
181
  WASM_SEC_EXPORT = 7,   // Exports
182
  WASM_SEC_START = 8,    // Start function declaration
183
  WASM_SEC_ELEM = 9,     // Elements section
184
  WASM_SEC_CODE = 10,    // Function bodies (code)
185
  WASM_SEC_DATA = 11     // Data segments
186
};
187
188
// Type immediate encodings used in various contexts.
189
enum : unsigned {
190
  WASM_TYPE_I32 = 0x7F,
191
  WASM_TYPE_I64 = 0x7E,
192
  WASM_TYPE_F32 = 0x7D,
193
  WASM_TYPE_F64 = 0x7C,
194
  WASM_TYPE_V128 = 0x7B,
195
  WASM_TYPE_ANYFUNC = 0x70,
196
  WASM_TYPE_EXCEPT_REF = 0x68,
197
  WASM_TYPE_FUNC = 0x60,
198
  WASM_TYPE_NORESULT = 0x40, // for blocks with no result values
199
};
200
201
// Kinds of externals (for imports and exports).
202
enum : unsigned {
203
  WASM_EXTERNAL_FUNCTION = 0x0,
204
  WASM_EXTERNAL_TABLE = 0x1,
205
  WASM_EXTERNAL_MEMORY = 0x2,
206
  WASM_EXTERNAL_GLOBAL = 0x3,
207
};
208
209
// Opcodes used in initializer expressions.
210
enum : unsigned {
211
  WASM_OPCODE_END = 0x0b,
212
  WASM_OPCODE_GET_GLOBAL = 0x23,
213
  WASM_OPCODE_I32_CONST = 0x41,
214
  WASM_OPCODE_I64_CONST = 0x42,
215
  WASM_OPCODE_F32_CONST = 0x43,
216
  WASM_OPCODE_F64_CONST = 0x44,
217
};
218
219
enum : unsigned {
220
  WASM_LIMITS_FLAG_HAS_MAX = 0x1,
221
};
222
223
// Subset of types that a value can have
224
enum class ValType {
225
  I32 = WASM_TYPE_I32,
226
  I64 = WASM_TYPE_I64,
227
  F32 = WASM_TYPE_F32,
228
  F64 = WASM_TYPE_F64,
229
  V128 = WASM_TYPE_V128,
230
  EXCEPT_REF = WASM_TYPE_EXCEPT_REF,
231
};
232
233
// Kind codes used in the custom "name" section
234
enum : unsigned {
235
  WASM_NAMES_FUNCTION = 0x1,
236
  WASM_NAMES_LOCAL = 0x2,
237
};
238
239
// Kind codes used in the custom "linking" section
240
enum : unsigned {
241
  WASM_SEGMENT_INFO = 0x5,
242
  WASM_INIT_FUNCS = 0x6,
243
  WASM_COMDAT_INFO = 0x7,
244
  WASM_SYMBOL_TABLE = 0x8,
245
};
246
247
// Kind codes used in the custom "linking" section in the WASM_COMDAT_INFO
248
enum : unsigned {
249
  WASM_COMDAT_DATA = 0x0,
250
  WASM_COMDAT_FUNCTION = 0x1,
251
};
252
253
// Kind codes used in the custom "linking" section in the WASM_SYMBOL_TABLE
254
enum WasmSymbolType : unsigned {
255
  WASM_SYMBOL_TYPE_FUNCTION = 0x0,
256
  WASM_SYMBOL_TYPE_DATA = 0x1,
257
  WASM_SYMBOL_TYPE_GLOBAL = 0x2,
258
  WASM_SYMBOL_TYPE_SECTION = 0x3,
259
};
260
261
const unsigned WASM_SYMBOL_BINDING_MASK = 0x3;
262
const unsigned WASM_SYMBOL_VISIBILITY_MASK = 0xc;
263
264
const unsigned WASM_SYMBOL_BINDING_GLOBAL = 0x0;
265
const unsigned WASM_SYMBOL_BINDING_WEAK = 0x1;
266
const unsigned WASM_SYMBOL_BINDING_LOCAL = 0x2;
267
const unsigned WASM_SYMBOL_VISIBILITY_DEFAULT = 0x0;
268
const unsigned WASM_SYMBOL_VISIBILITY_HIDDEN = 0x4;
269
const unsigned WASM_SYMBOL_UNDEFINED = 0x10;
270
271
#define WASM_RELOC(name, value) name = value,
272
273
enum : unsigned {
274
#include "WasmRelocs.def"
275
};
276
277
#undef WASM_RELOC
278
279
// Useful comparison operators
280
0
inline bool operator==(const WasmSignature &LHS, const WasmSignature &RHS) {
281
0
  return LHS.ReturnType == RHS.ReturnType && LHS.ParamTypes == RHS.ParamTypes;
282
0
}
283
284
0
inline bool operator!=(const WasmSignature &LHS, const WasmSignature &RHS) {
285
0
  return !(LHS == RHS);
286
0
}
287
288
0
inline bool operator==(const WasmGlobalType &LHS, const WasmGlobalType &RHS) {
289
0
  return LHS.Type == RHS.Type && LHS.Mutable == RHS.Mutable;
290
0
}
291
292
0
inline bool operator!=(const WasmGlobalType &LHS, const WasmGlobalType &RHS) {
293
0
  return !(LHS == RHS);
294
0
}
295
296
std::string toString(wasm::WasmSymbolType type);
297
std::string relocTypetoString(uint32_t type);
298
299
} // end namespace wasm
300
} // end namespace llvm
301
302
#endif