|
1
|
var illegalop = "illegal";
|
|
2
|
var magicModuleHeader = [0x00, 0x61, 0x73, 0x6d];
|
|
3
|
var moduleVersion = [0x01, 0x00, 0x00, 0x00];
|
|
4
|
|
|
5
|
function invertMap(obj) {
|
|
6
|
var keyModifierFn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (k) {
|
|
7
|
return k;
|
|
8
|
};
|
|
9
|
var result = {};
|
|
10
|
var keys = Object.keys(obj);
|
|
11
|
|
|
12
|
for (var i = 0, length = keys.length; i < length; i++) {
|
|
13
|
result[keyModifierFn(obj[keys[i]])] = keys[i];
|
|
14
|
}
|
|
15
|
|
|
16
|
return result;
|
|
17
|
}
|
|
18
|
|
|
19
|
function createSymbolObject(name
|
|
20
|
/*: string */
|
|
21
|
, object
|
|
22
|
/*: string */
|
|
23
|
)
|
|
24
|
/*: Symbol*/
|
|
25
|
{
|
|
26
|
var numberOfArgs
|
|
27
|
/*: number*/
|
|
28
|
= arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
|
|
29
|
return {
|
|
30
|
name: name,
|
|
31
|
object: object,
|
|
32
|
numberOfArgs: numberOfArgs
|
|
33
|
};
|
|
34
|
}
|
|
35
|
|
|
36
|
function createSymbol(name
|
|
37
|
/*: string */
|
|
38
|
)
|
|
39
|
/*: Symbol*/
|
|
40
|
{
|
|
41
|
var numberOfArgs
|
|
42
|
/*: number*/
|
|
43
|
= arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
|
|
44
|
return {
|
|
45
|
name: name,
|
|
46
|
numberOfArgs: numberOfArgs
|
|
47
|
};
|
|
48
|
}
|
|
49
|
|
|
50
|
var types = {
|
|
51
|
func: 0x60,
|
|
52
|
result: 0x40
|
|
53
|
};
|
|
54
|
var exportTypes = {
|
|
55
|
0x00: "Func",
|
|
56
|
0x01: "Table",
|
|
57
|
0x02: "Mem",
|
|
58
|
0x03: "Global"
|
|
59
|
};
|
|
60
|
var exportTypesByName = invertMap(exportTypes);
|
|
61
|
var valtypes = {
|
|
62
|
0x7f: "i32",
|
|
63
|
0x7e: "i64",
|
|
64
|
0x7d: "f32",
|
|
65
|
0x7c: "f64",
|
|
66
|
0x7b: "v128"
|
|
67
|
};
|
|
68
|
var valtypesByString = invertMap(valtypes);
|
|
69
|
var tableTypes = {
|
|
70
|
0x70: "anyfunc"
|
|
71
|
};
|
|
72
|
var blockTypes = Object.assign({}, valtypes, {
|
|
73
|
// https://webassembly.github.io/spec/core/binary/types.html#binary-blocktype
|
|
74
|
0x40: null,
|
|
75
|
// https://webassembly.github.io/spec/core/binary/types.html#binary-valtype
|
|
76
|
0x7f: "i32",
|
|
77
|
0x7e: "i64",
|
|
78
|
0x7d: "f32",
|
|
79
|
0x7c: "f64"
|
|
80
|
});
|
|
81
|
var globalTypes = {
|
|
82
|
0x00: "const",
|
|
83
|
0x01: "var"
|
|
84
|
};
|
|
85
|
var globalTypesByString = invertMap(globalTypes);
|
|
86
|
var importTypes = {
|
|
87
|
0x00: "func",
|
|
88
|
0x01: "table",
|
|
89
|
0x02: "mem",
|
|
90
|
0x03: "global"
|
|
91
|
};
|
|
92
|
var sections = {
|
|
93
|
custom: 0,
|
|
94
|
type: 1,
|
|
95
|
import: 2,
|
|
96
|
func: 3,
|
|
97
|
table: 4,
|
|
98
|
memory: 5,
|
|
99
|
global: 6,
|
|
100
|
export: 7,
|
|
101
|
start: 8,
|
|
102
|
element: 9,
|
|
103
|
code: 10,
|
|
104
|
data: 11
|
|
105
|
};
|
|
106
|
var symbolsByByte = {
|
|
107
|
0x00: createSymbol("unreachable"),
|
|
108
|
0x01: createSymbol("nop"),
|
|
109
|
0x02: createSymbol("block"),
|
|
110
|
0x03: createSymbol("loop"),
|
|
111
|
0x04: createSymbol("if"),
|
|
112
|
0x05: createSymbol("else"),
|
|
113
|
0x06: illegalop,
|
|
114
|
0x07: illegalop,
|
|
115
|
0x08: illegalop,
|
|
116
|
0x09: illegalop,
|
|
117
|
0x0a: illegalop,
|
|
118
|
0x0b: createSymbol("end"),
|
|
119
|
0x0c: createSymbol("br", 1),
|
|
120
|
0x0d: createSymbol("br_if", 1),
|
|
121
|
0x0e: createSymbol("br_table"),
|
|
122
|
0x0f: createSymbol("return"),
|
|
123
|
0x10: createSymbol("call", 1),
|
|
124
|
0x11: createSymbol("call_indirect", 2),
|
|
125
|
0x12: illegalop,
|
|
126
|
0x13: illegalop,
|
|
127
|
0x14: illegalop,
|
|
128
|
0x15: illegalop,
|
|
129
|
0x16: illegalop,
|
|
130
|
0x17: illegalop,
|
|
131
|
0x18: illegalop,
|
|
132
|
0x19: illegalop,
|
|
133
|
0x1a: createSymbol("drop"),
|
|
134
|
0x1b: createSymbol("select"),
|
|
135
|
0x1c: illegalop,
|
|
136
|
0x1d: illegalop,
|
|
137
|
0x1e: illegalop,
|
|
138
|
0x1f: illegalop,
|
|
139
|
0x20: createSymbol("get_local", 1),
|
|
140
|
0x21: createSymbol("set_local", 1),
|
|
141
|
0x22: createSymbol("tee_local", 1),
|
|
142
|
0x23: createSymbol("get_global", 1),
|
|
143
|
0x24: createSymbol("set_global", 1),
|
|
144
|
0x25: illegalop,
|
|
145
|
0x26: illegalop,
|
|
146
|
0x27: illegalop,
|
|
147
|
0x28: createSymbolObject("load", "u32", 1),
|
|
148
|
0x29: createSymbolObject("load", "u64", 1),
|
|
149
|
0x2a: createSymbolObject("load", "f32", 1),
|
|
150
|
0x2b: createSymbolObject("load", "f64", 1),
|
|
151
|
0x2c: createSymbolObject("load8_s", "u32", 1),
|
|
152
|
0x2d: createSymbolObject("load8_u", "u32", 1),
|
|
153
|
0x2e: createSymbolObject("load16_s", "u32", 1),
|
|
154
|
0x2f: createSymbolObject("load16_u", "u32", 1),
|
|
155
|
0x30: createSymbolObject("load8_s", "u64", 1),
|
|
156
|
0x31: createSymbolObject("load8_u", "u64", 1),
|
|
157
|
0x32: createSymbolObject("load16_s", "u64", 1),
|
|
158
|
0x33: createSymbolObject("load16_u", "u64", 1),
|
|
159
|
0x34: createSymbolObject("load32_s", "u64", 1),
|
|
160
|
0x35: createSymbolObject("load32_u", "u64", 1),
|
|
161
|
0x36: createSymbolObject("store", "u32", 1),
|
|
162
|
0x37: createSymbolObject("store", "u64", 1),
|
|
163
|
0x38: createSymbolObject("store", "f32", 1),
|
|
164
|
0x39: createSymbolObject("store", "f64", 1),
|
|
165
|
0x3a: createSymbolObject("store8", "u32", 1),
|
|
166
|
0x3b: createSymbolObject("store16", "u32", 1),
|
|
167
|
0x3c: createSymbolObject("store8", "u64", 1),
|
|
168
|
0x3d: createSymbolObject("store16", "u64", 1),
|
|
169
|
0x3e: createSymbolObject("store32", "u64", 1),
|
|
170
|
0x3f: createSymbolObject("current_memory"),
|
|
171
|
0x40: createSymbolObject("grow_memory"),
|
|
172
|
0x41: createSymbolObject("const", "i32", 1),
|
|
173
|
0x42: createSymbolObject("const", "i64", 1),
|
|
174
|
0x43: createSymbolObject("const", "f32", 1),
|
|
175
|
0x44: createSymbolObject("const", "f64", 1),
|
|
176
|
0x45: createSymbolObject("eqz", "i32"),
|
|
177
|
0x46: createSymbolObject("eq", "i32"),
|
|
178
|
0x47: createSymbolObject("ne", "i32"),
|
|
179
|
0x48: createSymbolObject("lt_s", "i32"),
|
|
180
|
0x49: createSymbolObject("lt_u", "i32"),
|
|
181
|
0x4a: createSymbolObject("gt_s", "i32"),
|
|
182
|
0x4b: createSymbolObject("gt_u", "i32"),
|
|
183
|
0x4c: createSymbolObject("le_s", "i32"),
|
|
184
|
0x4d: createSymbolObject("le_u", "i32"),
|
|
185
|
0x4e: createSymbolObject("ge_s", "i32"),
|
|
186
|
0x4f: createSymbolObject("ge_u", "i32"),
|
|
187
|
0x50: createSymbolObject("eqz", "i64"),
|
|
188
|
0x51: createSymbolObject("eq", "i64"),
|
|
189
|
0x52: createSymbolObject("ne", "i64"),
|
|
190
|
0x53: createSymbolObject("lt_s", "i64"),
|
|
191
|
0x54: createSymbolObject("lt_u", "i64"),
|
|
192
|
0x55: createSymbolObject("gt_s", "i64"),
|
|
193
|
0x56: createSymbolObject("gt_u", "i64"),
|
|
194
|
0x57: createSymbolObject("le_s", "i64"),
|
|
195
|
0x58: createSymbolObject("le_u", "i64"),
|
|
196
|
0x59: createSymbolObject("ge_s", "i64"),
|
|
197
|
0x5a: createSymbolObject("ge_u", "i64"),
|
|
198
|
0x5b: createSymbolObject("eq", "f32"),
|
|
199
|
0x5c: createSymbolObject("ne", "f32"),
|
|
200
|
0x5d: createSymbolObject("lt", "f32"),
|
|
201
|
0x5e: createSymbolObject("gt", "f32"),
|
|
202
|
0x5f: createSymbolObject("le", "f32"),
|
|
203
|
0x60: createSymbolObject("ge", "f32"),
|
|
204
|
0x61: createSymbolObject("eq", "f64"),
|
|
205
|
0x62: createSymbolObject("ne", "f64"),
|
|
206
|
0x63: createSymbolObject("lt", "f64"),
|
|
207
|
0x64: createSymbolObject("gt", "f64"),
|
|
208
|
0x65: createSymbolObject("le", "f64"),
|
|
209
|
0x66: createSymbolObject("ge", "f64"),
|
|
210
|
0x67: createSymbolObject("clz", "i32"),
|
|
211
|
0x68: createSymbolObject("ctz", "i32"),
|
|
212
|
0x69: createSymbolObject("popcnt", "i32"),
|
|
213
|
0x6a: createSymbolObject("add", "i32"),
|
|
214
|
0x6b: createSymbolObject("sub", "i32"),
|
|
215
|
0x6c: createSymbolObject("mul", "i32"),
|
|
216
|
0x6d: createSymbolObject("div_s", "i32"),
|
|
217
|
0x6e: createSymbolObject("div_u", "i32"),
|
|
218
|
0x6f: createSymbolObject("rem_s", "i32"),
|
|
219
|
0x70: createSymbolObject("rem_u", "i32"),
|
|
220
|
0x71: createSymbolObject("and", "i32"),
|
|
221
|
0x72: createSymbolObject("or", "i32"),
|
|
222
|
0x73: createSymbolObject("xor", "i32"),
|
|
223
|
0x74: createSymbolObject("shl", "i32"),
|
|
224
|
0x75: createSymbolObject("shr_s", "i32"),
|
|
225
|
0x76: createSymbolObject("shr_u", "i32"),
|
|
226
|
0x77: createSymbolObject("rotl", "i32"),
|
|
227
|
0x78: createSymbolObject("rotr", "i32"),
|
|
228
|
0x79: createSymbolObject("clz", "i64"),
|
|
229
|
0x7a: createSymbolObject("ctz", "i64"),
|
|
230
|
0x7b: createSymbolObject("popcnt", "i64"),
|
|
231
|
0x7c: createSymbolObject("add", "i64"),
|
|
232
|
0x7d: createSymbolObject("sub", "i64"),
|
|
233
|
0x7e: createSymbolObject("mul", "i64"),
|
|
234
|
0x7f: createSymbolObject("div_s", "i64"),
|
|
235
|
0x80: createSymbolObject("div_u", "i64"),
|
|
236
|
0x81: createSymbolObject("rem_s", "i64"),
|
|
237
|
0x82: createSymbolObject("rem_u", "i64"),
|
|
238
|
0x83: createSymbolObject("and", "i64"),
|
|
239
|
0x84: createSymbolObject("or", "i64"),
|
|
240
|
0x85: createSymbolObject("xor", "i64"),
|
|
241
|
0x86: createSymbolObject("shl", "i64"),
|
|
242
|
0x87: createSymbolObject("shr_s", "i64"),
|
|
243
|
0x88: createSymbolObject("shr_u", "i64"),
|
|
244
|
0x89: createSymbolObject("rotl", "i64"),
|
|
245
|
0x8a: createSymbolObject("rotr", "i64"),
|
|
246
|
0x8b: createSymbolObject("abs", "f32"),
|
|
247
|
0x8c: createSymbolObject("neg", "f32"),
|
|
248
|
0x8d: createSymbolObject("ceil", "f32"),
|
|
249
|
0x8e: createSymbolObject("floor", "f32"),
|
|
250
|
0x8f: createSymbolObject("trunc", "f32"),
|
|
251
|
0x90: createSymbolObject("nearest", "f32"),
|
|
252
|
0x91: createSymbolObject("sqrt", "f32"),
|
|
253
|
0x92: createSymbolObject("add", "f32"),
|
|
254
|
0x93: createSymbolObject("sub", "f32"),
|
|
255
|
0x94: createSymbolObject("mul", "f32"),
|
|
256
|
0x95: createSymbolObject("div", "f32"),
|
|
257
|
0x96: createSymbolObject("min", "f32"),
|
|
258
|
0x97: createSymbolObject("max", "f32"),
|
|
259
|
0x98: createSymbolObject("copysign", "f32"),
|
|
260
|
0x99: createSymbolObject("abs", "f64"),
|
|
261
|
0x9a: createSymbolObject("neg", "f64"),
|
|
262
|
0x9b: createSymbolObject("ceil", "f64"),
|
|
263
|
0x9c: createSymbolObject("floor", "f64"),
|
|
264
|
0x9d: createSymbolObject("trunc", "f64"),
|
|
265
|
0x9e: createSymbolObject("nearest", "f64"),
|
|
266
|
0x9f: createSymbolObject("sqrt", "f64"),
|
|
267
|
0xa0: createSymbolObject("add", "f64"),
|
|
268
|
0xa1: createSymbolObject("sub", "f64"),
|
|
269
|
0xa2: createSymbolObject("mul", "f64"),
|
|
270
|
0xa3: createSymbolObject("div", "f64"),
|
|
271
|
0xa4: createSymbolObject("min", "f64"),
|
|
272
|
0xa5: createSymbolObject("max", "f64"),
|
|
273
|
0xa6: createSymbolObject("copysign", "f64"),
|
|
274
|
0xa7: createSymbolObject("wrap/i64", "i32"),
|
|
275
|
0xa8: createSymbolObject("trunc_s/f32", "i32"),
|
|
276
|
0xa9: createSymbolObject("trunc_u/f32", "i32"),
|
|
277
|
0xaa: createSymbolObject("trunc_s/f64", "i32"),
|
|
278
|
0xab: createSymbolObject("trunc_u/f64", "i32"),
|
|
279
|
0xac: createSymbolObject("extend_s/i32", "i64"),
|
|
280
|
0xad: createSymbolObject("extend_u/i32", "i64"),
|
|
281
|
0xae: createSymbolObject("trunc_s/f32", "i64"),
|
|
282
|
0xaf: createSymbolObject("trunc_u/f32", "i64"),
|
|
283
|
0xb0: createSymbolObject("trunc_s/f64", "i64"),
|
|
284
|
0xb1: createSymbolObject("trunc_u/f64", "i64"),
|
|
285
|
0xb2: createSymbolObject("convert_s/i32", "f32"),
|
|
286
|
0xb3: createSymbolObject("convert_u/i32", "f32"),
|
|
287
|
0xb4: createSymbolObject("convert_s/i64", "f32"),
|
|
288
|
0xb5: createSymbolObject("convert_u/i64", "f32"),
|
|
289
|
0xb6: createSymbolObject("demote/f64", "f32"),
|
|
290
|
0xb7: createSymbolObject("convert_s/i32", "f64"),
|
|
291
|
0xb8: createSymbolObject("convert_u/i32", "f64"),
|
|
292
|
0xb9: createSymbolObject("convert_s/i64", "f64"),
|
|
293
|
0xba: createSymbolObject("convert_u/i64", "f64"),
|
|
294
|
0xbb: createSymbolObject("promote/f32", "f64"),
|
|
295
|
0xbc: createSymbolObject("reinterpret/f32", "i32"),
|
|
296
|
0xbd: createSymbolObject("reinterpret/f64", "i64"),
|
|
297
|
0xbe: createSymbolObject("reinterpret/i32", "f32"),
|
|
298
|
0xbf: createSymbolObject("reinterpret/i64", "f64")
|
|
299
|
};
|
|
300
|
var symbolsByName = invertMap(symbolsByByte, function (obj) {
|
|
301
|
if (typeof obj.object === "string") {
|
|
302
|
return "".concat(obj.object, ".").concat(obj.name);
|
|
303
|
}
|
|
304
|
|
|
305
|
return obj.name;
|
|
306
|
});
|
|
307
|
export default {
|
|
308
|
symbolsByByte: symbolsByByte,
|
|
309
|
sections: sections,
|
|
310
|
magicModuleHeader: magicModuleHeader,
|
|
311
|
moduleVersion: moduleVersion,
|
|
312
|
types: types,
|
|
313
|
valtypes: valtypes,
|
|
314
|
exportTypes: exportTypes,
|
|
315
|
blockTypes: blockTypes,
|
|
316
|
tableTypes: tableTypes,
|
|
317
|
globalTypes: globalTypes,
|
|
318
|
importTypes: importTypes,
|
|
319
|
valtypesByString: valtypesByString,
|
|
320
|
globalTypesByString: globalTypesByString,
|
|
321
|
exportTypesByName: exportTypesByName,
|
|
322
|
symbolsByName: symbolsByName
|
|
323
|
};
|
|
324
|
export { getSectionForNode } from "./section";
|