[wasm] JS-API: enable WebAssembly.instantiate tests; fix LinkError

test/mjsunit/wasm/errors.js

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Flags: --expose-wasm
 
 'use strict';
 
 load("test/mjsunit/wasm/wasm-constants.js");
 load("test/mjsunit/wasm/wasm-module-builder.js");
 
 function module(bytes) {
   let buffer = bytes;
   if (typeof buffer === 'string') {
     buffer = new ArrayBuffer(bytes.length);
     let view = new Uint8Array(buffer);
     for (let i = 0; i < bytes.length; ++i) {
       view[i] = bytes.charCodeAt(i);
     }
   }
   return new WebAssembly.Module(buffer);
 }
 
 function instance(bytes, imports = {}) {
   return new WebAssembly.Instance(module(bytes), imports);
 }
 
+// instantiate should succeed but run should fail.
+function instantiateAndFailAtRuntime(bytes, imports = {}) {
+  var instance = undefined;
+  try {
+    instance = new WebAssembly.Instance(module(bytes), imports);
+  } catch(e) {
+    // If we fail at startup.
+    if (e instanceof WebAssembly.RuntimeError) {
+      throw e;
+    }
+    // Swallow other instantiation errors because we expect instantiation
+    // to succeed but runtime to fail.
+    return;
+  }
+  instance.exports.run();
+}
+
 function builder() {
   return new WasmModuleBuilder;
 }
 
 function assertCompileError(bytes) {
   assertThrows(() => module(bytes), WebAssembly.CompileError);
 }
 
+// default imports to {} so we get LinkError by default, thus allowing us to
+// distinguish the TypeError we want to catch
 function assertTypeError(bytes, imports = {}) {
   assertThrows(() => instance(bytes, imports), TypeError);
 }
 
-function assertLinkError(bytes, imports = {}) {
+function assertLinkError(bytes, imports) {
   assertThrows(() => instance(bytes, imports), WebAssembly.LinkError);
 }
 
-function assertRuntimeError(bytes, imports = {}) {
-  assertThrows(() => instance(bytes, imports).exports.run(),
+function assertRuntimeError(bytes, imports) {
+  assertThrows(() => instantiateAndFailAtRuntime(bytes, imports),
     WebAssembly.RuntimeError);
 }
 
-function assertConversionError(bytes, imports = {}) {
-  assertThrows(() => instance(bytes, imports).exports.run(), TypeError);
+function assertConversionError(bytes, imports) {
+  assertThrows(() => instantiateAndFailAtRuntime(bytes, imports), TypeError);
 }
 
 (function TestDecodingError() {
   assertCompileError("");
   assertCompileError("X");
   assertCompileError("\0x00asm");
 })();
 
 (function TestValidationError() {
   assertCompileError(builder().addFunction("f", kSig_i_v).end().toBuffer());
   assertCompileError(builder().addFunction("f", kSig_i_v).addBody([
     kExprReturn
   ]).end().toBuffer());
   assertCompileError(builder().addFunction("f", kSig_v_v).addBody([
     kExprGetLocal, 0
   ]).end().toBuffer());
   assertCompileError(builder().addStart(0).toBuffer());
 })();
 
 (function TestLinkingError() {
   let b;
 
   b = builder();
   b.addImport("foo", "bar", kSig_v_v);
-  assertTypeError(b.toBuffer(), {});
+  assertLinkError(b.toBuffer(), {});
   b = builder();
   b.addImport("foo", "bar", kSig_v_v);
   assertLinkError(b.toBuffer(), {foo: {}});
   b = builder();
   b.addImport("foo", "bar", kSig_v_v);
   assertLinkError(b.toBuffer(), {foo: {bar: 9}});
 
   b = builder();
   b.addImportedGlobal("foo", "bar", kWasmI32);
-  assertTypeError(b.toBuffer(), {});
+  assertLinkError(b.toBuffer(), {});
   b = builder();
   b.addImportedGlobal("foo", "bar", kWasmI32);
   assertLinkError(b.toBuffer(), {foo: {}});
   b = builder();
   b.addImportedGlobal("foo", "bar", kWasmI32);
   assertLinkError(b.toBuffer(), {foo: {bar: ""}});
   b = builder();
   b.addImportedGlobal("foo", "bar", kWasmI32);
   assertLinkError(b.toBuffer(), {foo: {bar: () => 9}});
 
   b = builder();
   b.addImportedMemory("foo", "bar");
-  assertTypeError(b.toBuffer(), {});
+  assertLinkError(b.toBuffer(), {});
   b = builder();
   b.addImportedMemory("foo", "bar");
   assertLinkError(b.toBuffer(), {foo: {}});
   b = builder();
   b.addImportedMemory("foo", "bar", 1);
   assertLinkError(b.toBuffer(),
       {foo: {bar: () => new WebAssembly.Memory({initial: 0})}});
 
   b = builder();
-  b.addFunction("f", kSig_v_v).addBody([
+  b.addFunction("startup", kSig_v_v).addBody([
     kExprUnreachable,
   ]).end().addStart(0);
   assertRuntimeError(b.toBuffer());
 })();
 
 (function TestTrapError() {
   assertRuntimeError(builder().addFunction("run", kSig_v_v).addBody([
     kExprUnreachable
   ]).exportFunc().end().toBuffer());
 
   assertRuntimeError(builder().addFunction("run", kSig_v_v).addBody([
     kExprI32Const, 1,
     kExprI32Const, 0,
     kExprI32DivS,
     kExprDrop
   ]).exportFunc().end().toBuffer());
 
   assertRuntimeError(builder().addFunction("run", kSig_v_v).addBody([
   ]).exportFunc().end().
   addFunction("start", kSig_v_v).addBody([
     kExprUnreachable
   ]).end().addStart(1).toBuffer());
 })();
 
 (function TestConversionError() {
   let b = builder();
   b.addImport("foo", "bar", kSig_v_l);
   assertConversionError(b.addFunction("run", kSig_v_v).addBody([
     kExprI64Const, 0, kExprCallFunction, 0
-  ]).exportFunc().end().toBuffer());
+  ]).exportFunc().end().toBuffer(), {foo:{bar: (l)=>{}}});
 
+  b = builder()
   assertConversionError(builder().addFunction("run", kSig_l_v).addBody([
     kExprI64Const, 0
   ]).exportFunc().end().toBuffer());
 })();