[wasm] Allow import function to be any kind of callables.

test/cctest/wasm/test-run-wasm-js.cc

 // Copyright 2015 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.
 
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "src/wasm/wasm-macro-gen.h"
@@ skipping 79 matching lines @@
 void EXPECT_CALL(double expected, Handle<JSFunction> jsfunc, double a,
                  double b) {
   Isolate* isolate = jsfunc->GetIsolate();
   Handle<Object> buffer[] = {isolate->factory()->NewNumber(a),
                              isolate->factory()->NewNumber(b)};
   EXPECT_CALL(expected, jsfunc, buffer, 2);
 }
 }  // namespace
 
 TEST(Run_Int32Sub_jswrapped) {
+  CcTest::InitializeVM();
   TestSignatures sigs;
   TestingModule module;
   WasmFunctionCompiler t(sigs.i_ii(), &module);
   BUILD(t, WASM_I32_SUB(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   Handle<JSFunction> jsfunc = module.WrapCode(t.CompileAndAdd());
 
   EXPECT_CALL(33, jsfunc, 44, 11);
   EXPECT_CALL(-8723487, jsfunc, -8000000, 723487);
 }
 
 TEST(Run_Float32Div_jswrapped) {
+  CcTest::InitializeVM();
   TestSignatures sigs;
   TestingModule module;
   WasmFunctionCompiler t(sigs.f_ff(), &module);
   BUILD(t, WASM_F32_DIV(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   Handle<JSFunction> jsfunc = module.WrapCode(t.CompileAndAdd());
 
   EXPECT_CALL(92, jsfunc, 46, 0.5);
   EXPECT_CALL(64, jsfunc, -16, -0.25);
 }
 
 TEST(Run_Float64Add_jswrapped) {
+  CcTest::InitializeVM();
   TestSignatures sigs;
   TestingModule module;
   WasmFunctionCompiler t(sigs.d_dd(), &module);
   BUILD(t, WASM_F64_ADD(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   Handle<JSFunction> jsfunc = module.WrapCode(t.CompileAndAdd());
 
   EXPECT_CALL(3, jsfunc, 2, 1);
   EXPECT_CALL(-5.5, jsfunc, -5.25, -0.25);
 }
 
 TEST(Run_I32Popcount_jswrapped) {
+  CcTest::InitializeVM();
   TestSignatures sigs;
   TestingModule module;
   WasmFunctionCompiler t(sigs.i_i(), &module);
   BUILD(t, WASM_I32_POPCNT(WASM_GET_LOCAL(0)));
   Handle<JSFunction> jsfunc = module.WrapCode(t.CompileAndAdd());
 
   EXPECT_CALL(2, jsfunc, 9, 0);
   EXPECT_CALL(3, jsfunc, 11, 0);
   EXPECT_CALL(6, jsfunc, 0x3F, 0);
 }
 
 TEST(Run_CallJS_Add_jswrapped) {
+  CcTest::InitializeVM();
   TestSignatures sigs;
   TestingModule module;
   WasmFunctionCompiler t(sigs.i_i(), &module);
   uint32_t js_index =
       module.AddJsFunction(sigs.i_i(), "(function(a) { return a + 99; })");
   BUILD(t, WASM_CALL_FUNCTION1(js_index, WASM_GET_LOCAL(0)));
 
   Handle<JSFunction> jsfunc = module.WrapCode(t.CompileAndAdd());
 
   EXPECT_CALL(101, jsfunc, 2, -8);
@@ skipping 29 matching lines @@
       code.push_back(0);
       t.Build(&code[0], &code[end]);
     }
 
     Handle<JSFunction> jsfunc = module.WrapCode(t.CompileAndAdd());
     double expected = inputs.arg_d(which);
     EXPECT_CALL(expected, jsfunc, 0.0, 0.0);
   }
 }
 
-TEST(Run_JSSelect_0) { RunJSSelectTest(0); }
+TEST(Run_JSSelect_0) {
+  CcTest::InitializeVM();
+  RunJSSelectTest(0);
+}
 
-TEST(Run_JSSelect_1) { RunJSSelectTest(1); }
+TEST(Run_JSSelect_1) {
+  CcTest::InitializeVM();
+  RunJSSelectTest(1);
+}
 
-TEST(Run_JSSelect_2) { RunJSSelectTest(2); }
+TEST(Run_JSSelect_2) {
+  CcTest::InitializeVM();
+  RunJSSelectTest(2);
+}
 
-TEST(Run_JSSelect_3) { RunJSSelectTest(3); }
+TEST(Run_JSSelect_3) {
+  CcTest::InitializeVM();
+  RunJSSelectTest(3);
+}
 
-TEST(Run_JSSelect_4) { RunJSSelectTest(4); }
+TEST(Run_JSSelect_4) {
+  CcTest::InitializeVM();
+  RunJSSelectTest(4);
+}
 
-TEST(Run_JSSelect_5) { RunJSSelectTest(5); }
+TEST(Run_JSSelect_5) {
+  CcTest::InitializeVM();
+  RunJSSelectTest(5);
+}
 
-TEST(Run_JSSelect_6) { RunJSSelectTest(6); }
+TEST(Run_JSSelect_6) {
+  CcTest::InitializeVM();
+  RunJSSelectTest(6);
+}
 
-TEST(Run_JSSelect_7) { RunJSSelectTest(7); }
+TEST(Run_JSSelect_7) {
+  CcTest::InitializeVM();
+  RunJSSelectTest(7);
+}
 
 void RunWASMSelectTest(int which) {
   PredictableInputValues inputs(0x200);
   Isolate* isolate = CcTest::InitIsolateOnce();
   const int kMaxParams = 8;
   for (int num_params = which + 1; num_params < kMaxParams; num_params++) {
     LocalType type = kAstF64;
     LocalType types[kMaxParams + 1] = {type, type, type, type, type,
                                        type, type, type, type};
     FunctionSig sig(1, num_params, types);
@@ skipping 12 matching lines @@
         isolate->factory()->NewNumber(inputs.arg_d(5)),
         isolate->factory()->NewNumber(inputs.arg_d(6)),
         isolate->factory()->NewNumber(inputs.arg_d(7)),
     };
 
     double expected = inputs.arg_d(which);
     EXPECT_CALL(expected, jsfunc, args, kMaxParams);
   }
 }
 
-TEST(Run_WASMSelect_0) { RunWASMSelectTest(0); }
+TEST(Run_WASMSelect_0) {
+  CcTest::InitializeVM();
+  RunWASMSelectTest(0);
+}
 
-TEST(Run_WASMSelect_1) { RunWASMSelectTest(1); }
+TEST(Run_WASMSelect_1) {
+  CcTest::InitializeVM();
+  RunWASMSelectTest(1);
+}
 
-TEST(Run_WASMSelect_2) { RunWASMSelectTest(2); }
+TEST(Run_WASMSelect_2) {
+  CcTest::InitializeVM();
+  RunWASMSelectTest(2);
+}
 
-TEST(Run_WASMSelect_3) { RunWASMSelectTest(3); }
+TEST(Run_WASMSelect_3) {
+  CcTest::InitializeVM();
+  RunWASMSelectTest(3);
+}
 
-TEST(Run_WASMSelect_4) { RunWASMSelectTest(4); }
+TEST(Run_WASMSelect_4) {
+  CcTest::InitializeVM();
+  RunWASMSelectTest(4);
+}
 
-TEST(Run_WASMSelect_5) { RunWASMSelectTest(5); }
+TEST(Run_WASMSelect_5) {
+  CcTest::InitializeVM();
+  RunWASMSelectTest(5);
+}
 
-TEST(Run_WASMSelect_6) { RunWASMSelectTest(6); }
+TEST(Run_WASMSelect_6) {
+  CcTest::InitializeVM();
+  RunWASMSelectTest(6);
+}
 
-TEST(Run_WASMSelect_7) { RunWASMSelectTest(7); }
+TEST(Run_WASMSelect_7) {
+  CcTest::InitializeVM();
+  RunWASMSelectTest(7);
+}
 
 void RunWASMSelectAlignTest(int num_args, int num_params) {
   PredictableInputValues inputs(0x300);
   Isolate* isolate = CcTest::InitIsolateOnce();
   const int kMaxParams = 10;
   DCHECK_LE(num_args, kMaxParams);
   LocalType type = kAstF64;
   LocalType types[kMaxParams + 1] = {type, type, type, type, type, type,
                                      type, type, type, type, type};
   FunctionSig sig(1, num_params, types);
@@ skipping 15 matching lines @@
                              isolate->factory()->NewNumber(inputs.arg_d(8)),
                              isolate->factory()->NewNumber(inputs.arg_d(9))};
 
     double nan = std::numeric_limits<double>::quiet_NaN();
     double expected = which < num_args ? inputs.arg_d(which) : nan;
     EXPECT_CALL(expected, jsfunc, args, num_args);
   }
 }
 
 TEST(Run_WASMSelectAlign_0) {
+  CcTest::InitializeVM();
   RunWASMSelectAlignTest(0, 1);
   RunWASMSelectAlignTest(0, 2);
 }
 
 TEST(Run_WASMSelectAlign_1) {
+  CcTest::InitializeVM();
   RunWASMSelectAlignTest(1, 2);
   RunWASMSelectAlignTest(1, 3);
 }
 
 TEST(Run_WASMSelectAlign_2) {
+  CcTest::InitializeVM();
   RunWASMSelectAlignTest(2, 3);
   RunWASMSelectAlignTest(2, 4);
 }
 
 TEST(Run_WASMSelectAlign_3) {
+  CcTest::InitializeVM();
   RunWASMSelectAlignTest(3, 3);
   RunWASMSelectAlignTest(3, 4);
 }
 
 TEST(Run_WASMSelectAlign_4) {
+  CcTest::InitializeVM();
   RunWASMSelectAlignTest(4, 3);
   RunWASMSelectAlignTest(4, 4);
 }
 
 TEST(Run_WASMSelectAlign_7) {
+  CcTest::InitializeVM();
   RunWASMSelectAlignTest(7, 5);
   RunWASMSelectAlignTest(7, 6);
   RunWASMSelectAlignTest(7, 7);
 }
 
 TEST(Run_WASMSelectAlign_8) {
+  CcTest::InitializeVM();
   RunWASMSelectAlignTest(8, 5);
   RunWASMSelectAlignTest(8, 6);
   RunWASMSelectAlignTest(8, 7);
   RunWASMSelectAlignTest(8, 8);
 }
 
 TEST(Run_WASMSelectAlign_9) {
+  CcTest::InitializeVM();
   RunWASMSelectAlignTest(9, 6);
   RunWASMSelectAlignTest(9, 7);
   RunWASMSelectAlignTest(9, 8);
   RunWASMSelectAlignTest(9, 9);
 }
 
 TEST(Run_WASMSelectAlign_10) {
+  CcTest::InitializeVM();
   RunWASMSelectAlignTest(10, 7);
   RunWASMSelectAlignTest(10, 8);
   RunWASMSelectAlignTest(10, 9);
   RunWASMSelectAlignTest(10, 10);
 }
 
 void RunJSSelectAlignTest(int num_args, int num_params) {
   PredictableInputValues inputs(0x400);
   Isolate* isolate = CcTest::InitIsolateOnce();
   Factory* factory = isolate->factory();
@@ skipping 41 matching lines @@
         factory->NewNumber(inputs.arg_d(9)),
     };
 
     double nan = std::numeric_limits<double>::quiet_NaN();
     double expected = which < num_args ? inputs.arg_d(which) : nan;
     EXPECT_CALL(expected, jsfunc, args, num_args);
   }
 }
 
 TEST(Run_JSSelectAlign_0) {
+  CcTest::InitializeVM();
   RunJSSelectAlignTest(0, 1);
   RunJSSelectAlignTest(0, 2);
 }
 
 TEST(Run_JSSelectAlign_1) {
+  CcTest::InitializeVM();
   RunJSSelectAlignTest(1, 2);
   RunJSSelectAlignTest(1, 3);
 }
 
 TEST(Run_JSSelectAlign_2) {
+  CcTest::InitializeVM();
   RunJSSelectAlignTest(2, 3);
   RunJSSelectAlignTest(2, 4);
 }
 
 TEST(Run_JSSelectAlign_3) {
+  CcTest::InitializeVM();
   RunJSSelectAlignTest(3, 3);
   RunJSSelectAlignTest(3, 4);
 }
 
 TEST(Run_JSSelectAlign_4) {
+  CcTest::InitializeVM();
   RunJSSelectAlignTest(4, 3);
   RunJSSelectAlignTest(4, 4);
 }
 
 TEST(Run_JSSelectAlign_7) {
+  CcTest::InitializeVM();
   RunJSSelectAlignTest(7, 3);
   RunJSSelectAlignTest(7, 4);
   RunJSSelectAlignTest(7, 4);
   RunJSSelectAlignTest(7, 4);
 }
 
 TEST(Run_JSSelectAlign_8) {
+  CcTest::InitializeVM();
   RunJSSelectAlignTest(8, 5);
   RunJSSelectAlignTest(8, 6);
   RunJSSelectAlignTest(8, 7);
   RunJSSelectAlignTest(8, 8);
 }
 
 TEST(Run_JSSelectAlign_9) {
+  CcTest::InitializeVM();
   RunJSSelectAlignTest(9, 6);
   RunJSSelectAlignTest(9, 7);
   RunJSSelectAlignTest(9, 8);
   RunJSSelectAlignTest(9, 9);
 }
 
 TEST(Run_JSSelectAlign_10) {
+  CcTest::InitializeVM();
   RunJSSelectAlignTest(10, 7);
   RunJSSelectAlignTest(10, 8);
   RunJSSelectAlignTest(10, 9);
   RunJSSelectAlignTest(10, 10);
 }