[wasm] Support validation of asm.js modules with != 3 args.

test/mjsunit/asm/asm-validation.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.

[Michael Starzinger, 2016/08/11 11:44:10]

Can we add tests for the following?

- Instantiating module via constructor call (i.e. var m = new Module()).
- Having multiple closures for one module, failing in sequence:
    function MkModule() {
      function Module(stdlib) { 'use asm'; return {} }
      return Module;
    }
    var Module1 = MkModule();
    var Module2 = MkModule();
    var m1 = Module(1,2,3);
    var m2 = Module(4,5,6);
- Simiar to the above where the second instantiation would actually succeed:
    var m1 = Module(1,2,3);
    var m2 = Module({},{},heap);
- Creating bound function from module
    var ModuleBound = Module.bind(this, stdlib, {}, heap);
    var m = ModuleBound();

[bradn, 2016/08/12 01:17:09]

Done, but Questions:

* The new case seems to be able to use the wasm path. Is this what you expected?
* Failure then, success does not go down the wasm path, as the stays in the
non-wasm path once there is a failure. This is probably ok for now as this is a
fallback. But, am I correct in assuming that I would need to create a separate
SharedFunctionInfo for each failed function to separate them, or is there some
why I can separate them and have a different code object on each?

[Michael Starzinger, 2016/08/12 09:21:55]

Yes, that is what my intuition of the asm.js spec was.
We cannot create a separate SharedFunctionInfo, that is out of the question. The
current approach will destroy the module the moment is instantiated with bogus
parameters and from that point on the module is broken and can no longer go down
the WASM path. IIRC we discussed this a couple of months back and the conclusion
was that this would be fine. If we want to "revive" a broken module or have the
possibility to have a module be both, compiled by WASM and FullCodegen at the
same time, then we need to rethink the entire design. With the current approach
this is not possible.

+
+// Flags: --validate-asm --allow-natives-syntax
+
+(function TestModuleArgs() {
+  function Module1(stdlib) {
+    "use asm";
+    function foo() { }
+    return { foo: foo };
+  }
+  function Module2(stdlib, ffi) {
+    "use asm";
+    function foo() { }
+    return { foo: foo };
+  }
+  function Module3(stdlib, ffi, heap) {
+    "use asm";
+    function foo() { }
+    return { foo: foo };
+  }
+  var modules = [Module1, Module2, Module3];
+  var heap = new ArrayBuffer(1024 * 1024);
+  for (var i = 0; i < modules.length; ++i) {
+    print('Module' + (i + 1));
+    var module = modules[i];
+    // TODO(bradnelson): Support modules without the stdlib.
+    var m = module({});
+    assertTrue(%IsAsmWasmCode(module));
+    var m = module({}, {});
+    assertTrue(%IsAsmWasmCode(module));
+    var m = module({}, {}, heap);
+    assertTrue(%IsAsmWasmCode(module));
+    var m = module({}, {}, heap, {});
+    assertTrue(%IsAsmWasmCode(module));
+  }
+})();
+
+(function TestBadModule() {
+  function Module(stdlib, ffi, heap) {
+    "use asm";
+    function foo() { var y = 3; var x = 1 + y; return 123; }
+    return { foo: foo };
+  }
+  var m = Module({});
+  assertFalse(%IsAsmWasmCode(Module));
+  assertEquals(123, m.foo());
+})();
+
+(function TestBadArgTypes() {
+  function Module(a, b, c) {
+    "use asm";
+    return {};
+  }
+  var m = Module(1, 2, 3);
+  assertFalse(%IsAsmWasmCode(Module));
+  assertEquals({}, m);
+})();
+
+(function TestBadArgTypesMismatch() {
+  function Module(a, b, c) {
+    "use asm";
+    return {};
+  }
+  var m = Module(1, 2);
+  assertFalse(%IsAsmWasmCode(Module));
+  assertEquals({}, m);
+})();
+
+(function TestModuleNoStdlib() {
+  // TODO(bradnelson):
+  // Support modules like this if they don't use the whole stdlib.
+  function Module() {
+    "use asm";
+    function foo() { return 123; }
+    return { foo: foo };
+  }
+  var m = Module({});
+  assertFalse(%IsAsmWasmCode(Module));
+  assertEquals(123, m.foo());
+})();
+
+(function TestModuleNoStdlibCall() {
+  function Module(stdlib, ffi, heap) {
+    "use asm";
+    function foo() { return 123; }
+    return { foo: foo };
+  }
+  // TODO(bradnelson): Support instantiation like this if stdlib is unused.
+  var m = Module();
+  assertFalse(%IsAsmWasmCode(Module));
+  assertEquals(123, m.foo());
+})();