Revert of [wasm] Make WasmRunner the central test structure

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

 // 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.
 
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include <memory>
 
@@ skipping 17 matching lines @@
 
 TEST(Run_WasmInt8Const_i) {
   WasmRunner<int32_t> r(kExecuteInterpreted);
   const byte kExpectedValue = 109;
   // return(kExpectedValue)
   BUILD(r, WASM_I8(kExpectedValue));
   CHECK_EQ(kExpectedValue, r.Call());
 }
 
 TEST(Run_WasmIfElse) {
-  WasmRunner<int32_t, int32_t> r(kExecuteInterpreted);
+  WasmRunner<int32_t> r(kExecuteInterpreted, MachineType::Int32());
   BUILD(r, WASM_IF_ELSE_I(WASM_GET_LOCAL(0), WASM_I8(9), WASM_I8(10)));
   CHECK_EQ(10, r.Call(0));
   CHECK_EQ(9, r.Call(1));
 }
 
 TEST(Run_WasmIfReturn) {
-  WasmRunner<int32_t, int32_t> r(kExecuteInterpreted);
+  WasmRunner<int32_t> r(kExecuteInterpreted, MachineType::Int32());
   BUILD(r, WASM_IF(WASM_GET_LOCAL(0), WASM_RETURN1(WASM_I8(77))), WASM_I8(65));
   CHECK_EQ(65, r.Call(0));
   CHECK_EQ(77, r.Call(1));
 }
 
 TEST(Run_WasmNopsN) {
   const int kMaxNops = 10;
   byte code[kMaxNops + 2];
   for (int nops = 0; nops < kMaxNops; nops++) {
     byte expected = static_cast<byte>(20 + nops);
@@ skipping 68 matching lines @@
       code[2 + index + 3] = 0;
 
       WasmRunner<int32_t> r(kExecuteInterpreted);
       r.Build(code, code + kMaxNops + kExtra);
       CHECK_EQ(expected, r.Call());
     }
   }
 }
 
 TEST(Run_Wasm_nested_ifs_i) {
-  WasmRunner<int32_t, int32_t, int32_t> r(kExecuteInterpreted);
+  WasmRunner<int32_t> r(kExecuteInterpreted, MachineType::Int32(),
+                        MachineType::Int32());
 
   BUILD(r, WASM_IF_ELSE_I(
                WASM_GET_LOCAL(0),
                WASM_IF_ELSE_I(WASM_GET_LOCAL(1), WASM_I8(11), WASM_I8(12)),
                WASM_IF_ELSE_I(WASM_GET_LOCAL(1), WASM_I8(13), WASM_I8(14))));
 
   CHECK_EQ(11, r.Call(1, 1));
   CHECK_EQ(12, r.Call(1, 0));
   CHECK_EQ(13, r.Call(0, 1));
   CHECK_EQ(14, r.Call(0, 0));
@@ skipping 27 matching lines @@
 }
 
 TEST(Breakpoint_I32Add) {
   static const int kLocalsDeclSize = 1;
   static const int kNumBreakpoints = 3;
   byte code[] = {WASM_I32_ADD(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))};
   std::unique_ptr<int[]> offsets =
       Find(code, sizeof(code), kNumBreakpoints, kExprGetLocal, kExprGetLocal,
            kExprI32Add);
 
-  WasmRunner<int32_t, uint32_t, uint32_t> r(kExecuteInterpreted);
+  WasmRunner<int32_t> r(kExecuteInterpreted, MachineType::Uint32(),
+                        MachineType::Uint32());
 
   r.Build(code, code + arraysize(code));
 
   WasmInterpreter* interpreter = r.interpreter();
   WasmInterpreter::Thread* thread = interpreter->GetThread(0);
   for (int i = 0; i < kNumBreakpoints; i++) {
     interpreter->SetBreakpoint(r.function(), kLocalsDeclSize + offsets[i],
                                true);
   }
 
@@ skipping 18 matching lines @@
       uint32_t expected = (*a) + (b);
       CHECK_EQ(expected, thread->GetReturnValue().to<uint32_t>());
     }
   }
 }
 
 TEST(Step_I32Mul) {
   static const int kTraceLength = 4;
   byte code[] = {WASM_I32_MUL(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))};
 
-  WasmRunner<int32_t, uint32_t, uint32_t> r(kExecuteInterpreted);
+  WasmRunner<int32_t> r(kExecuteInterpreted, MachineType::Uint32(),
+                        MachineType::Uint32());
 
   r.Build(code, code + arraysize(code));
 
   WasmInterpreter* interpreter = r.interpreter();
   WasmInterpreter::Thread* thread = interpreter->GetThread(0);
 
   FOR_UINT32_INPUTS(a) {
     for (uint32_t b = 33; b < 3000000000u; b += 1000000000u) {
       thread->Reset();
       WasmVal args[] = {WasmVal(*a), WasmVal(b)};
@@ skipping 17 matching lines @@
   }
 }
 
 TEST(Breakpoint_I32And_disable) {
   static const int kLocalsDeclSize = 1;
   static const int kNumBreakpoints = 1;
   byte code[] = {WASM_I32_AND(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))};
   std::unique_ptr<int[]> offsets =
       Find(code, sizeof(code), kNumBreakpoints, kExprI32And);
 
-  WasmRunner<int32_t, uint32_t, uint32_t> r(kExecuteInterpreted);
+  WasmRunner<int32_t> r(kExecuteInterpreted, MachineType::Uint32(),
+                        MachineType::Uint32());
 
   r.Build(code, code + arraysize(code));
 
   WasmInterpreter* interpreter = r.interpreter();
   WasmInterpreter::Thread* thread = interpreter->GetThread(0);
 
   FOR_UINT32_INPUTS(a) {
     for (uint32_t b = 11; b < 3000000000u; b += 1000000000u) {
       // Run with and without breakpoints.
       for (int do_break = 0; do_break < 2; do_break++) {
@@ skipping 16 matching lines @@
         // Check the thread finished with the right value.
         CHECK_EQ(WasmInterpreter::FINISHED, thread->state());
         uint32_t expected = (*a) & (b);
         CHECK_EQ(expected, thread->GetReturnValue().to<uint32_t>());
       }
     }
   }
 }
 
 TEST(GrowMemory) {
-  WasmRunner<int32_t, uint32_t> r(kExecuteInterpreted);
-  r.module().AddMemory(WasmModule::kPageSize);
+  TestingModule module(kExecuteInterpreted);
+  WasmRunner<int32_t> r(&module, MachineType::Uint32());
+  module.AddMemory(WasmModule::kPageSize);
   BUILD(r, WASM_GROW_MEMORY(WASM_GET_LOCAL(0)));
   CHECK_EQ(1, r.Call(1));
 }
 
 TEST(GrowMemoryPreservesData) {
   int32_t index = 16;
   int32_t value = 2335;
-  WasmRunner<int32_t, uint32_t> r(kExecuteInterpreted);
-  r.module().AddMemory(WasmModule::kPageSize);
+  TestingModule module(kExecuteInterpreted);
+  WasmRunner<int32_t> r(&module, MachineType::Uint32());
+  module.AddMemory(WasmModule::kPageSize);
   BUILD(r, WASM_STORE_MEM(MachineType::Int32(), WASM_I32V(index),
                           WASM_I32V(value)),
         WASM_GROW_MEMORY(WASM_GET_LOCAL(0)), WASM_DROP,
         WASM_LOAD_MEM(MachineType::Int32(), WASM_I32V(index)));
   CHECK_EQ(value, r.Call(1));
 }
 
 TEST(GrowMemoryInvalidSize) {
   {
     // Grow memory by an invalid amount without initial memory.
-    WasmRunner<int32_t, uint32_t> r(kExecuteInterpreted);
+    TestingModule module(kExecuteInterpreted);
+    WasmRunner<int32_t> r(&module, MachineType::Uint32());
     BUILD(r, WASM_GROW_MEMORY(WASM_GET_LOCAL(0)));
     CHECK_EQ(-1, r.Call(1048575));
   }
   {
     // Grow memory by an invalid amount without initial memory.
-    WasmRunner<int32_t, uint32_t> r(kExecuteInterpreted);
-    r.module().AddMemory(WasmModule::kPageSize);
+    TestingModule module(kExecuteInterpreted);
+    WasmRunner<int32_t> r(&module, MachineType::Uint32());
+    module.AddMemory(WasmModule::kPageSize);
     BUILD(r, WASM_GROW_MEMORY(WASM_GET_LOCAL(0)));
     CHECK_EQ(-1, r.Call(1048575));
   }
 }
 
 TEST(TestPossibleNondeterminism) {
   {
     // F32Div may produced NaN
-    WasmRunner<float, float, float> r(kExecuteInterpreted);
+    TestingModule module(kExecuteInterpreted);
+    WasmRunner<float> r(&module, MachineType::Float32(),
+                        MachineType::Float32());
     BUILD(r, WASM_F32_DIV(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
     r.Call(1048575.5f, 2.5f);
     CHECK(!r.possible_nondeterminism());
     r.Call(0.0f, 0.0f);
     CHECK(r.possible_nondeterminism());
   }
   {
     // F32Sqrt may produced NaN
-    WasmRunner<float, float> r(kExecuteInterpreted);
+    TestingModule module(kExecuteInterpreted);
+    WasmRunner<float> r(&module, MachineType::Float32());
     BUILD(r, WASM_F32_SQRT(WASM_GET_LOCAL(0)));
     r.Call(16.0f);
     CHECK(!r.possible_nondeterminism());
     r.Call(-1048575.5f);
     CHECK(r.possible_nondeterminism());
   }
   {
     // F32Mul may produced NaN
-    WasmRunner<float, float, float> r(kExecuteInterpreted);
+    TestingModule module(kExecuteInterpreted);
+    WasmRunner<float> r(&module, MachineType::Float32(),
+                        MachineType::Float32());
     BUILD(r, WASM_F32_MUL(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
     r.Call(1048575.5f, 2.5f);
     CHECK(!r.possible_nondeterminism());
     r.Call(std::numeric_limits<float>::infinity(), 0.0f);
     CHECK(r.possible_nondeterminism());
   }
   {
     // F64Div may produced NaN
-    WasmRunner<double, double, double> r(kExecuteInterpreted);
+    TestingModule module(kExecuteInterpreted);
+    WasmRunner<double> r(&module, MachineType::Float64(),
+                         MachineType::Float64());
     BUILD(r, WASM_F64_DIV(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
     r.Call(1048575.5, 2.5);
     CHECK(!r.possible_nondeterminism());
     r.Call(0.0, 0.0);
     CHECK(r.possible_nondeterminism());
   }
   {
     // F64Sqrt may produced NaN
-    WasmRunner<double, double> r(kExecuteInterpreted);
+    TestingModule module(kExecuteInterpreted);
+    WasmRunner<double> r(&module, MachineType::Float64());
     BUILD(r, WASM_F64_SQRT(WASM_GET_LOCAL(0)));
     r.Call(1048575.5);
     CHECK(!r.possible_nondeterminism());
     r.Call(-1048575.5);
     CHECK(r.possible_nondeterminism());
   }
   {
     // F64Mul may produced NaN
-    WasmRunner<double, double, double> r(kExecuteInterpreted);
+    TestingModule module(kExecuteInterpreted);
+    WasmRunner<double> r(&module, MachineType::Float64(),
+                         MachineType::Float64());
     BUILD(r, WASM_F64_MUL(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
     r.Call(1048575.5, 2.5);
     CHECK(!r.possible_nondeterminism());
     r.Call(std::numeric_limits<double>::infinity(), 0.0);
     CHECK(r.possible_nondeterminism());
   }
 }
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8