WebAssembly JS API: implement more sections
[WebKit-https.git] / JSTests / wasm / self-test / test_BuilderJSON.js
1 import * as assert from '../assert.js';
2 import Builder from '../Builder.js';
3
4 const assertOpThrows = (opFn, message) => {
5     let f = (new Builder()).Type().End().Code().Function();
6     assert.throws(opFn, Error, message, f);
7 };
8
9 (function EmptyModule() {
10     const b = new Builder();
11     const j = JSON.parse(b.json());
12     assert.isNotUndef(j.preamble);
13     assert.isNotUndef(j.preamble["magic number"]);
14     assert.isNotUndef(j.preamble.version);
15     assert.isNotUndef(j.section);
16     assert.eq(j.section.length, 0);
17 })();
18
19 (function CustomMagicNumber() {
20     const b = (new Builder()).setPreamble({ "magic number": 1337 });
21     const j = JSON.parse(b.json());
22     assert.eq(j.preamble["magic number"], 1337);
23     assert.isNotUndef(j.preamble.version);
24 })();
25
26 (function CustomVersion() {
27     const b = (new Builder()).setPreamble({ "version": 1337 });
28     const j = JSON.parse(b.json());
29     assert.eq(j.preamble["version"], 1337);
30     assert.isNotUndef(j.preamble.version);
31 })();
32
33 (function CustomSection() {
34     const b = new Builder();
35     b.Unknown("custom section")
36         .Byte(0x00)
37         .Byte(0x42)
38         .Byte(0xFF);
39     const j = JSON.parse(b.json());
40     assert.eq(j.section.length, 1);
41     assert.eq(j.section[0].name, "custom section");
42     assert.eq(j.section[0].data.length, 3);
43     assert.eq(j.section[0].data[0], 0x00);
44     assert.eq(j.section[0].data[1], 0x42);
45     assert.eq(j.section[0].data[2], 0xFF);
46 })();
47
48 (function CustomSectionAllBytes() {
49     const b = new Builder();
50     let u = b.Unknown("custom section");
51     for (let i = 0; i !== 0xFF + 1; ++i)
52         u.Byte(i);
53     const j = JSON.parse(b.json());
54     assert.eq(j.section[0].data.length, 256);
55     for (let i = 0; i !== 0xFF + 1; ++i)
56         assert.eq(j.section[0].data[i], i);
57 })();
58
59 (function CustomSectionInvalidByte() {
60     const u = (new Builder()).Unknown("custom section");
61     assert.throws(() => u.Byte(0xFF + 1), Error, `Not the same: "0" and "256": Unknown section expected byte, got: "256"`);
62 })();
63
64 (function TwoCustomSections() {
65     const b = new Builder();
66     b.Unknown("custom section")
67         .Byte(0x00)
68         .Byte(0x42)
69         .Byte(0xFF)
70     .End()
71     .Unknown("☃")
72         .Byte(0x11);
73     const j = JSON.parse(b.json());
74     assert.eq(j.section.length, 2);
75     assert.eq(j.section[0].name, "custom section");
76     assert.eq(j.section[0].data.length, 3);
77     assert.eq(j.section[1].name, "☃");
78     assert.eq(j.section[1].data.length, 1);
79     assert.eq(j.section[1].data[0], 0x11);
80 })();
81
82 (function SectionsWithSameCustomName() {
83     const b = (new Builder()).Unknown("foo").End();
84     assert.throws(() => b.Unknown("foo"), Error, `Expected falsy: Cannot have two sections with the same name "foo" and ID 0`);
85 })();
86
87 (function EmptyTypeSection() {
88     const b = (new Builder()).Type().End();
89     const j = JSON.parse(b.json());
90     assert.eq(j.section.length, 1);
91     assert.eq(j.section[0].name, "Type");
92     assert.eq(j.section[0].data.length, 0);
93 })();
94
95 (function TwoTypeSections() {
96     const b = (new Builder()).Type().End();
97     assert.throws(() => b.Type(), Error, `Expected falsy: Cannot have two sections with the same name "Type" and ID 1`);
98 })();
99
100 (function SimpleTypeSection() {
101     const b = (new Builder()).Type()
102             .Func([])
103             .Func([], "void")
104             .Func([], "i32")
105             .Func([], "i64")
106             .Func([], "f32")
107             .Func([], "f64")
108             .Func(["i32", "i64", "f32", "f64"])
109         .End();
110     const j = JSON.parse(b.json());
111     assert.eq(j.section[0].data.length, 7);
112     assert.eq(j.section[0].data[0].params, []);
113     assert.eq(j.section[0].data[0].ret, "void");
114     assert.eq(j.section[0].data[1].params, []);
115     assert.eq(j.section[0].data[1].ret, "void");
116     assert.eq(j.section[0].data[2].params, []);
117     assert.eq(j.section[0].data[2].ret, "i32");
118     assert.eq(j.section[0].data[3].params, []);
119     assert.eq(j.section[0].data[3].ret, "i64");
120     assert.eq(j.section[0].data[4].params, []);
121     assert.eq(j.section[0].data[4].ret, "f32");
122     assert.eq(j.section[0].data[5].params, []);
123     assert.eq(j.section[0].data[5].ret, "f64");
124     assert.eq(j.section[0].data[6].params, ["i32", "i64", "f32", "f64"]);
125     assert.eq(j.section[0].data[6].ret, "void");
126 })();
127
128 (function EmptyImportSection() {
129     const b = (new Builder()).Import().End();
130     const j = JSON.parse(b.json());
131     assert.eq(j.section.length, 1);
132     assert.eq(j.section[0].name, "Import");
133     assert.eq(j.section[0].data.length, 0);
134 })();
135
136 (function ImportBeforeTypeSections() {
137     const b = (new Builder()).Import().End();
138     assert.throws(() => b.Type(), Error, `Expected: "2" > "1": Bad section ordering: "Import" cannot precede "Type"`);
139 })();
140
141 (function ImportFunctionWithoutTypeSection() {
142     const i = (new Builder()).Import();
143     assert.throws(() => i.Function("foo", "bar", 0), Error, `Shouldn't be undefined: Can't use type 0 if a type section isn't present`);
144 })();
145
146 (function ImportFunctionWithInvalidType() {
147     const i = (new Builder()).Type().End().Import();
148     assert.throws(() => i.Function("foo", "bar", 0), Error, `Shouldn't be undefined: Type 0 doesn't exist in type section`);
149 })();
150
151 (function ImportFunction() {
152     const b = (new Builder())
153         .Type().Func([]).End()
154         .Import()
155             .Function("foo", "bar", 0)
156         .End();
157     const j = JSON.parse(b.json());
158     assert.eq(j.section[1].data.length, 1);
159     assert.eq(j.section[1].data[0].module, "foo");
160     assert.eq(j.section[1].data[0].field, "bar");
161     assert.eq(j.section[1].data[0].type, 0);
162     assert.eq(j.section[1].data[0].kind, "Function");
163 })();
164
165 (function ImportFunctionsWithExistingTypes() {
166     const b = (new Builder())
167         .Type()
168             .Func([])
169             .Func([], "i32")
170             .Func(["i64", "i32"])
171             .Func(["i64", "i64"])
172         .End()
173         .Import()
174             .Function("foo", "bar", { params: [] })
175             .Function("foo", "baz", { params: [], ret: "i32" })
176             .Function("foo", "boo", { params: ["i64", "i64"] })
177         .End();
178     const j = JSON.parse(b.json());
179     assert.eq(j.section[0].data.length, 4);
180     assert.eq(j.section[1].data.length, 3);
181     assert.eq(j.section[1].data[0].type, 0);
182     assert.eq(j.section[1].data[1].type, 1);
183     assert.eq(j.section[1].data[2].type, 3);
184 })();
185
186 (function ImportFunctionWithNewType() {
187     const b = (new Builder())
188         .Type().End()
189         .Import()
190             .Function("foo", "bar", { params: [] })
191             .Function("foo", "baz", { params: [], ret: "i32" })
192             .Function("foo", "boo", { params: ["i64", "i64"] })
193         .End();
194     const j = JSON.parse(b.json());
195     assert.eq(j.section[0].data.length, 3);
196     assert.eq(j.section[0].data[0].ret, "void");
197     assert.eq(j.section[0].data[0].params, []);
198     assert.eq(j.section[0].data[1].ret, "i32");
199     assert.eq(j.section[0].data[1].params, []);
200     assert.eq(j.section[0].data[2].ret, "void");
201     assert.eq(j.section[0].data[2].params, ["i64", "i64"]);
202 })();
203
204 (function EmptyExportSection() {
205     const b = (new Builder()).Export().End();
206     const j = JSON.parse(b.json());
207     assert.eq(j.section.length, 1);
208     assert.eq(j.section[0].name, "Export");
209     assert.eq(j.section[0].data.length, 0);
210 })();
211
212 (function ExportFunctionWithoutTypeSection() {
213     const e = (new Builder()).Export();
214     assert.throws(() => e.Function("foo", 0, 0), Error, `Shouldn't be undefined: Can't use type 0 if a type section isn't present`);
215 })();
216
217 (function ExportFunctionWithInvalidType() {
218     const e = (new Builder()).Type().End().Export();
219     assert.throws(() => e.Function("foo", 0, 0), Error, `Shouldn't be undefined: Type 0 doesn't exist in type section`);
220 })();
221
222 (function ExportAnImport() {
223     const b = (new Builder())
224         .Type().End()
225         .Import().Function("foo", "bar", { params: [] }).End()
226         .Export().Function("ExportAnImport", { module: "foo", field: "bar" }).End();
227     const j = JSON.parse(b.json());
228     assert.eq(j.section[2].name, "Export");
229     assert.eq(j.section[2].data.length, 1);
230     assert.eq(j.section[2].data[0].field, "ExportAnImport");
231     assert.eq(j.section[2].data[0].type, 0);
232     assert.eq(j.section[2].data[0].index, 0);
233     assert.eq(j.section[2].data[0].kind, "Function");
234 })();
235
236 (function ExportMismatchedImport() {
237     const e = (new Builder())
238         .Type().End()
239         .Import().Function("foo", "bar", { params: [] }).End()
240         .Export();
241     assert.throws(() => e.Function("foo", 0, { params: ["i32"] }), Error, `Not the same: "1" and "0": Re-exporting import "bar" as "foo" has mismatching type`);
242 })();
243
244 (function EmptyCodeSection() {
245     const b = new Builder();
246     b.Code();
247     const j = JSON.parse(b.json());
248     assert.eq(j.section.length, 1);
249     assert.eq(j.section[0].name, "Code");
250     assert.eq(j.section[0].data.length, 0);
251 })();
252
253 (function CodeSectionWithEmptyFunction() {
254     const b = new Builder();
255     b.Type().End()
256         .Code()
257             .Function();
258     const j = JSON.parse(b.json());
259     assert.eq(j.section.length, 2);
260     assert.eq(j.section[0].name, "Type");
261     assert.eq(j.section[0].data.length, 1);
262     assert.eq(j.section[0].data[0].params, []);
263     assert.eq(j.section[0].data[0].ret, "void");
264     assert.eq(j.section[1].name, "Code");
265     assert.eq(j.section[1].data.length, 1);
266     assert.eq(j.section[1].data[0].name, undefined);
267     assert.eq(j.section[1].data[0].type, 0);
268     assert.eq(j.section[1].data[0].parameterCount, 0);
269     assert.eq(j.section[1].data[0].locals.length, 0);
270     assert.eq(j.section[1].data[0].code.length, 0);
271 })();
272
273 (function CodeSectionWithEmptyFunctionWithParameters() {
274     const b = new Builder();
275     b.Type().End()
276         .Code()
277             .Function({ params: ["i32", "i64", "f32", "f64"] });
278     const j = JSON.parse(b.json());
279     assert.eq(j.section.length, 2);
280     assert.eq(j.section[0].data.length, 1);
281     assert.eq(j.section[0].data[0].params, ["i32", "i64", "f32", "f64"]);
282     assert.eq(j.section[0].data[0].ret, "void");
283     assert.eq(j.section[1].data.length, 1);
284     assert.eq(j.section[1].data[0].type, 0);
285     assert.eq(j.section[1].data[0].parameterCount, 4);
286     assert.eq(j.section[1].data[0].locals[0], "i32");
287     assert.eq(j.section[1].data[0].locals[1], "i64");
288     assert.eq(j.section[1].data[0].locals[2], "f32");
289     assert.eq(j.section[1].data[0].locals[3], "f64");
290     assert.eq(j.section[1].data[0].code.length, 0);
291 })();
292
293 (function InvalidFunctionParameters() {
294     for (let invalid of ["", "void", "bool", "any", "struct", 0, 3.14, undefined, [], {}]) {
295         const c = (new Builder()).Code();
296         assert.throws(() => c.Function({ params: [invalid] }), Error, `Expected truthy: Type parameter ${invalid} needs a valid value type`);
297     }
298 })();
299
300 (function SimpleFunction() {
301     const b = new Builder();
302     b.Type().End()
303         .Code()
304             .Function()
305                 .Nop()
306                 .Nop()
307             .End();
308     const j = JSON.parse(b.json());
309     assert.eq(j.section[1].data.length, 1);
310     assert.eq(j.section[1].data[0].locals.length, 0);
311     assert.eq(j.section[1].data[0].code.length, 3);
312     assert.eq(j.section[1].data[0].code[0].name, "nop");
313     assert.eq(j.section[1].data[0].code[1].name, "nop");
314     assert.eq(j.section[1].data[0].code[2].name, "end");
315 })();
316
317 (function TwoSimpleFunctions() {
318     const b = new Builder();
319     b.Type().End()
320         .Code()
321             .Function()
322                 .Nop()
323                 .Nop()
324             .End()
325             .Function()
326                 .Return()
327             .End();
328     const j = JSON.parse(b.json());
329     assert.eq(j.section[1].data.length, 2);
330     assert.eq(j.section[1].data[0].locals.length, 0);
331     assert.eq(j.section[1].data[0].code.length, 3);
332     assert.eq(j.section[1].data[0].code[0].name, "nop");
333     assert.eq(j.section[1].data[0].code[1].name, "nop");
334     assert.eq(j.section[1].data[0].code[2].name, "end");
335     assert.eq(j.section[1].data[1].locals.length, 0);
336     assert.eq(j.section[1].data[1].code.length, 2);
337     assert.eq(j.section[1].data[1].code[0].name, "return");
338     assert.eq(j.section[1].data[1].code[1].name, "end");
339 })();
340
341 (function NamedFunctions() {
342     const b = new Builder().Type().End().Code()
343         .Function("hello").End()
344         .Function("world", { params: ["i32"] }).End()
345     .End();
346     const j = JSON.parse(b.json());
347     assert.eq(j.section[1].data[0].name, "hello");
348     assert.eq(j.section[1].data[0].parameterCount, 0);
349     assert.eq(j.section[1].data[1].name, "world");
350     assert.eq(j.section[1].data[1].parameterCount, 1);
351 })();
352
353 (function ExportSimpleFunctions() {
354     const b = (new Builder())
355         .Type().End()
356         .Export()
357             .Function("foo", 0, { params: [] })
358             .Function("bar")
359             .Function("betterNameForBar", "bar")
360         .End()
361         .Code()
362             .Function({ params: [] }).Nop().End()
363             .Function("bar", { params: [] }).Nop().End()
364         .End();
365     const j = JSON.parse(b.json());
366     assert.eq(j.section[0].data.length, 1);
367     assert.eq(j.section[0].data[0].ret, "void");
368     assert.eq(j.section[0].data[0].params, []);
369     assert.eq(j.section[1].data.length, 3);
370     assert.eq(j.section[1].data[0].field, "foo");
371     assert.eq(j.section[1].data[0].type, 0);
372     assert.eq(j.section[1].data[0].index, 0);
373     assert.eq(j.section[1].data[0].kind, "Function");
374     assert.eq(j.section[1].data[1].field, "bar");
375     assert.eq(j.section[1].data[1].type, 0);
376     assert.eq(j.section[1].data[1].index, 1);
377     assert.eq(j.section[1].data[1].kind, "Function");
378     assert.eq(j.section[1].data[2].field, "betterNameForBar");
379     assert.eq(j.section[1].data[2].type, 0);
380     assert.eq(j.section[1].data[2].index, 1);
381     assert.eq(j.section[1].data[2].kind, "Function");
382 })();
383
384 (function ExportUndefinedFunction() {
385     const c = (new Builder()).Type().End().Export().Function("foo").End().Code();
386     assert.throws(() => c.End(), Error, `Should be number, got undefined: Export section contains undefined function "foo"`);
387 })();
388
389 (function TwoBuildersAtTheSameTime() {
390     const b = [new Builder(), new Builder()];
391     const f = b.map(builder => builder.Type().End().Code().Function());
392     f[0].Nop();
393     f[1].Return().End().End();
394     f[0].Nop().End().End();
395     const j = b.map(builder => JSON.parse(builder.json()));
396     assert.eq(j[0].section[1].data[0].code.length, 3);
397     assert.eq(j[0].section[1].data[0].code[0].name, "nop");
398     assert.eq(j[0].section[1].data[0].code[1].name, "nop");
399     assert.eq(j[0].section[1].data[0].code[2].name, "end");
400     assert.eq(j[1].section[1].data[0].code.length, 2);
401     assert.eq(j[1].section[1].data[0].code[0].name, "return");
402     assert.eq(j[1].section[1].data[0].code[1].name, "end");
403 })();
404
405 (function CheckedOpcodeArgumentsTooMany() {
406     assertOpThrows(f => f.Nop("uh-oh!"), `Not the same: "1" and "0": "nop" expects 0 immediates, got 1`);
407 })();
408
409 (function UncheckedOpcodeArgumentsTooMany() {
410     (new Builder()).setChecked(false).Type().End().Code().Function().Nop("This is fine.", "I'm OK with the events that are unfolding currently.");
411 })();
412
413 (function CheckedOpcodeArgumentsNotEnough() {
414     assertOpThrows(f => f.I32Const(), `Not the same: "0" and "1": "i32.const" expects 1 immediates, got 0`);
415 })();
416
417 (function UncheckedOpcodeArgumentsNotEnough() {
418     (new Builder()).setChecked(false).Type().End().Code().Function().I32Const();
419 })();
420
421 (function CallNoArguments() {
422     const b = (new Builder()).Type().End().Code().Function().Call(0).End().End();
423     const j = JSON.parse(b.json());
424     assert.eq(j.section[1].data[0].code.length, 2);
425     assert.eq(j.section[1].data[0].code[0].name, "call");
426     assert.eq(j.section[1].data[0].code[0].arguments.length, 0);
427     assert.eq(j.section[1].data[0].code[0].immediates.length, 1);
428     assert.eq(j.section[1].data[0].code[0].immediates[0], 0);
429     assert.eq(j.section[1].data[0].code[1].name, "end");
430 })();
431
432 (function CallInvalid() {
433     for (let c of [-1, 0x100000000, "0", {}, Infinity, -Infinity, NaN, -NaN, null])
434         assertOpThrows(f => f.Call(c), `Expected truthy: Invalid value on call: got "${c}", expected i32`);
435 })();
436
437 (function I32ConstValid() {
438     for (let c of [0, 1, 2, 42, 1337, 0xFF, 0xFFFF, 0x7FFFFFFF, 0xFFFFFFFE, 0xFFFFFFFF]) {
439         const b = (new Builder()).Type().End().Code().Function().I32Const(c).Return().End().End();
440         const j = JSON.parse(b.json());
441         assert.eq(j.section[1].data[0].code[0].name, "i32.const");
442         assert.eq(j.section[1].data[0].code[0].arguments.length, 0);
443         assert.eq(j.section[1].data[0].code[0].immediates.length, 1);
444         assert.eq(j.section[1].data[0].code[0].immediates[0], c);
445     }
446 })();
447
448 (function I32ConstInvalid() {
449     for (let c of [-1, 0x100000000, 0.1, -0.1, "0", {}, Infinity, null])
450         assertOpThrows(f => f.I32Const(c), `Expected truthy: Invalid value on i32.const: got "${c}", expected i32`);
451 })();
452
453 // FIXME: test i64. https://bugs.webkit.org/show_bug.cgi?id=163420
454
455 (function F32ConstValid() {
456     for (let c of [0, -0., 0.2, Math.PI, 0x100000000]) {
457         const b = (new Builder()).Type().End().Code().Function().F32Const(c).Return().End().End();
458         const j = JSON.parse(b.json());
459         assert.eq(j.section[1].data[0].code[0].name, "f32.const");
460         assert.eq(j.section[1].data[0].code[0].arguments.length, 0);
461         assert.eq(j.section[1].data[0].code[0].immediates.length, 1);
462         assert.eq(j.section[1].data[0].code[0].immediates[0], c);
463     }
464 })();
465
466 (function F32ConstInvalid() {
467     for (let c of ["0", {}, Infinity, -Infinity, NaN, -NaN, null])
468         assertOpThrows(f => f.F32Const(c), `Expected truthy: Invalid value on f32.const: got "${c}", expected f32`);
469 })();
470
471 (function F64ConstValid() {
472     for (let c of [0, -0., 0.2, Math.PI, 0x100000000]) {
473         const b = (new Builder()).Type().End().Code().Function().F64Const(c).Return().End().End();
474         const j = JSON.parse(b.json());
475         assert.eq(j.section[1].data[0].code[0].name, "f64.const");
476         assert.eq(j.section[1].data[0].code[0].arguments.length, 0);
477         assert.eq(j.section[1].data[0].code[0].immediates.length, 1);
478         assert.eq(j.section[1].data[0].code[0].immediates[0], c);
479     }
480 })();
481
482 (function F64ConstInvalid() {
483     for (let c of ["0", {}, Infinity, -Infinity, NaN, -NaN, null])
484         assertOpThrows(f => f.F64Const(c), `Expected truthy: Invalid value on f64.const: got "${c}", expected f64`);
485 })();
486
487 (function CallOneFromStack() {
488     const b = (new Builder()).Type().End().Code()
489         .Function({ params: ["i32"] })
490             .I32Const(42)
491             .Call(0)
492         .End()
493     .End();
494     const j = JSON.parse(b.json());
495     assert.eq(j.section[1].data[0].code.length, 3);
496     assert.eq(j.section[1].data[0].code[0].name, "i32.const");
497     assert.eq(j.section[1].data[0].code[0].immediates[0], 42);
498     assert.eq(j.section[1].data[0].code[1].name, "call");
499     // FIXME: assert.eq(j.section[1].data[0].code[1].arguments.length, 1); https://bugs.webkit.org/show_bug.cgi?id=163267
500     assert.eq(j.section[1].data[0].code[1].immediates.length, 1);
501     assert.eq(j.section[1].data[0].code[1].immediates[0], 0);
502     assert.eq(j.section[1].data[0].code[2].name, "end");
503 })();
504
505 // FIXME https://bugs.webkit.org/show_bug.cgi?id=163267 all of these:
506 //  test too many pops.
507 //  test not enough pops (function has non-empty stack at the end).
508 //  test mismatched pop types.
509 //  test mismatched function signature (calling with wrong arg types).
510 //  test invalid function index.
511 //  test function names (both setting and calling them).
512
513 (function CallManyFromStack() {
514     const b = (new Builder()).Type().End().Code()
515         .Function({ params: ["i32", "i32", "i32", "i32"] })
516               .I32Const(42).I32Const(1337).I32Const(0xBEEF).I32Const(0xFFFF)
517               .Call(0)
518         .End()
519     .End();
520     const j = JSON.parse(b.json());
521     assert.eq(j.section[1].data[0].code.length, 6);
522     assert.eq(j.section[1].data[0].code[4].name, "call");
523     // FIXME: assert.eq(j.section[1].data[0].code[4].arguments.length, 4); https://bugs.webkit.org/show_bug.cgi?id=163267
524     assert.eq(j.section[1].data[0].code[4].immediates.length, 1);
525     assert.eq(j.section[1].data[0].code[4].immediates[0], 0);
526 })();
527
528 (function OpcodeAdd() {
529     const b = (new Builder()).Type().End().Code()
530           .Function()
531               .I32Const(42).I32Const(1337)
532               .I32Add()
533               .Return()
534         .End()
535     .End();
536     const j = JSON.parse(b.json());
537     assert.eq(j.section[1].data[0].code.length, 5);
538     assert.eq(j.section[1].data[0].code[2].name, "i32.add");
539     // FIXME: assert.eq(j.section[1].data[0].code[2].arguments.length, 2); https://bugs.webkit.org/show_bug.cgi?id=163267
540     assert.eq(j.section[1].data[0].code[3].name, "return");
541     // FIXME check return. https://bugs.webkit.org/show_bug.cgi?id=163267
542 })();
543
544 (function OpcodeUnreachable() {
545     const b = (new Builder()).Type().End().Code().Function().Unreachable().End().End();
546     const j = JSON.parse(b.json());
547     assert.eq(j.section[1].data[0].code.length, 2);
548     assert.eq(j.section[1].data[0].code[0].name, "unreachable");
549 })();
550
551 (function OpcodeUnreachableCombinations() {
552     (new Builder()).Type().End().Code().Function().Nop().Unreachable().End().End().json();
553     (new Builder()).Type().End().Code().Function().Unreachable().Nop().End().End().json();
554     (new Builder()).Type().End().Code().Function().Return().Unreachable().End().End().json();
555     (new Builder()).Type().End().Code().Function().Unreachable().Return().End().End().json();
556     (new Builder()).Type().End().Code().Function().Call(0).Unreachable().End().End().json();
557     (new Builder()).Type().End().Code().Function().Unreachable().Call(0).End().End().json();
558 })();
559
560 (function OpcodeSelect() {
561     const b = (new Builder()).Type().End().Code().Function()
562         .I32Const(1).I32Const(2).I32Const(0)
563         .Select()
564         .Return()
565       .End()
566     .End();
567     const j = JSON.parse(b.json());
568     assert.eq(j.section[1].data[0].code.length, 6);
569     assert.eq(j.section[1].data[0].code[3].name, "select");
570 })();
571
572 // FIXME test type mismatch with select. https://bugs.webkit.org/show_bug.cgi?id=163267