[wasm] Fix interpreter entry for i64 return type

test/cctest/wasm/test-wasm-interpreter-entry.cc

 // Copyright 2017 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 <cstdint>
 
 #include "src/assembler-inl.h"
 #include "src/objects-inl.h"
 #include "src/wasm/wasm-macro-gen.h"
 #include "src/wasm/wasm-objects.h"
@@ skipping 69 matching lines @@
     WasmRunnerBase& runner, WasmFunctionCompiler& inner_compiler,
     std::initializer_list<uint8_t> bytes_inner_function,
     std::initializer_list<uint8_t> bytes_outer_function,
     const T& expected_lambda) {
   return ArgPassingHelper<T>(runner, inner_compiler, bytes_inner_function,
                              bytes_outer_function, expected_lambda);
 }
 
 }  // namespace
 
+// Pass int32_t, return int32_t.
 TEST(TestArgumentPassing_int32) {
   WasmRunner<int32_t, int32_t> runner(kExecuteCompiled);
   WasmFunctionCompiler& f2 = runner.NewFunction<int32_t, int32_t>();
 
   auto helper = GetHelper(
       runner, f2,
       {// Return 2*<0> + 1.
        WASM_I32_ADD(WASM_I32_MUL(WASM_I32V_1(2), WASM_GET_LOCAL(0)), WASM_ONE)},
       {// Call f2 with param <0>.
        WASM_GET_LOCAL(0), WASM_CALL_FUNCTION0(f2.function_index())},
       [](int32_t a) { return 2 * a + 1; });
 
   std::vector<int32_t> test_values = compiler::ValueHelper::int32_vector();
   for (int32_t v : test_values) helper.CheckCall(v);
 }
 
-TEST(TestArgumentPassing_int64) {
+// Pass int64_t, return double.
+TEST(TestArgumentPassing_double_int64) {
   WasmRunner<double, int32_t, int32_t> runner(kExecuteCompiled);
   WasmFunctionCompiler& f2 = runner.NewFunction<double, int64_t>();
 
   auto helper = GetHelper(
       runner, f2,
       {// Return (double)<0>.
        WASM_F64_SCONVERT_I64(WASM_GET_LOCAL(0))},
       {// Call f2 with param (<0> | (<1> << 32)).
        WASM_I64_IOR(WASM_I64_UCONVERT_I32(WASM_GET_LOCAL(0)),
                     WASM_I64_SHL(WASM_I64_UCONVERT_I32(WASM_GET_LOCAL(1)),
@@ skipping 14 matching lines @@
 
   std::vector<int64_t> test_values_i64 = compiler::ValueHelper::int64_vector();
   for (int64_t v : test_values_i64) {
     int32_t v1 = static_cast<int32_t>(v);
     int32_t v2 = static_cast<int32_t>(v >> 32);
     helper.CheckCall(v1, v2);
     helper.CheckCall(v2, v1);
   }
 }
 
+// Pass double, return int64_t.
+TEST(TestArgumentPassing_int64_double) {
+  // Outer function still returns double.
+  WasmRunner<double, double> runner(kExecuteCompiled);
+  WasmFunctionCompiler& f2 = runner.NewFunction<int64_t, double>();
+
+  auto helper = GetHelper(
+      runner, f2,
+      {// Return (int64_t)<0>.
+       WASM_I64_SCONVERT_F64(WASM_GET_LOCAL(0))},
+      {// Call f2 with param <0>, convert returned value back to double.
+       WASM_F64_SCONVERT_I64(WASM_SEQ(
+           WASM_GET_LOCAL(0), WASM_CALL_FUNCTION0(f2.function_index())))},
+      [](double d) { return d; });
+
+  for (int64_t i : compiler::ValueHelper::int64_vector()) {
+    helper.CheckCall(i);
+  }
+}
+
+// Pass float, return double.
 TEST(TestArgumentPassing_float_double) {
   WasmRunner<double, float> runner(kExecuteCompiled);
   WasmFunctionCompiler& f2 = runner.NewFunction<double, float>();
 
   auto helper = GetHelper(
       runner, f2,
       {// Return 2*(double)<0> + 1.
        WASM_F64_ADD(
            WASM_F64_MUL(WASM_F64(2), WASM_F64_CONVERT_F32(WASM_GET_LOCAL(0))),
            WASM_F64(1))},
       {// Call f2 with param <0>.
        WASM_GET_LOCAL(0), WASM_CALL_FUNCTION0(f2.function_index())},
       [](float f) { return 2. * static_cast<double>(f) + 1.; });
 
   std::vector<float> test_values = compiler::ValueHelper::float32_vector();
   for (float f : test_values) helper.CheckCall(f);
 }
 
+// Pass two doubles, return double.
 TEST(TestArgumentPassing_double_double) {
   WasmRunner<double, double, double> runner(kExecuteCompiled);
   WasmFunctionCompiler& f2 = runner.NewFunction<double, double, double>();
 
   auto helper = GetHelper(runner, f2,
                           {// Return <0> + <1>.
                            WASM_F64_ADD(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))},
                           {// Call f2 with params <0>, <1>.
                            WASM_GET_LOCAL(0), WASM_GET_LOCAL(1),
                            WASM_CALL_FUNCTION0(f2.function_index())},
                           [](double a, double b) { return a + b; });
 
   std::vector<double> test_values = compiler::ValueHelper::float64_vector();
   for (double d1 : test_values) {
     for (double d2 : test_values) {
       helper.CheckCall(d1, d2);
     }
   }
 }
 
+// Pass int32_t, int64_t, float and double, return double.
 TEST(TestArgumentPassing_AllTypes) {
   // The second and third argument will be combined to an i64.
-  WasmRunner<double, int, int, int, float, double> runner(kExecuteCompiled);
+  WasmRunner<double, int32_t, int32_t, int32_t, float, double> runner(
+      kExecuteCompiled);
   WasmFunctionCompiler& f2 =
-      runner.NewFunction<double, int, int64_t, float, double>();
+      runner.NewFunction<double, int32_t, int64_t, float, double>();
 
   auto helper = GetHelper(
       runner, f2,
       {
           // Convert all arguments to double, add them and return the sum.
           WASM_F64_ADD(          // <0+1+2> + <3>
               WASM_F64_ADD(      // <0+1> + <2>
                   WASM_F64_ADD(  // <0> + <1>
                       WASM_F64_SCONVERT_I32(
                           WASM_GET_LOCAL(0)),  // <0> to double
@@ skipping 29 matching lines @@
       std::max(std::max(test_values_i32.size(), test_values_i64.size()),
                std::max(test_values_f32.size(), test_values_f64.size()));
   for (size_t i = 0; i < max_len; ++i) {
     int32_t i32 = test_values_i32[i % test_values_i32.size()];
     int64_t i64 = test_values_i64[i % test_values_i64.size()];
     float f32 = test_values_f32[i % test_values_f32.size()];
     double f64 = test_values_f64[i % test_values_f64.size()];
     CheckCall(i32, i64, f32, f64);
   }
 }