Revert of [wasm] Make WasmRunner the central test structure

test/cctest/wasm/test-run-wasm-64.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 <stdlib.h>
 #include <string.h>
 
 #include "src/base/bits.h"
 #include "src/wasm/wasm-macro-gen.h"
@@ skipping 102 matching lines @@
     const int64_t kExpectedValue = (static_cast<int64_t>(*i) << 32) | cntr;
     // return(kExpectedValue)
     BUILD(r, WASM_I64V(kExpectedValue));
     CHECK_EQ(kExpectedValue, r.Call());
     cntr++;
   }
 }
 
 WASM_EXEC_TEST(Return_I64) {
   REQUIRE(I64Return);
-  WasmRunner<int64_t, int64_t> r(execution_mode);
+  WasmRunner<int64_t> r(execution_mode, MachineType::Int64());
 
   BUILD(r, WASM_RETURN1(WASM_GET_LOCAL(0)));
 
   FOR_INT64_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); }
 }
 
 WASM_EXEC_TEST(I64Add) {
   REQUIRE(I64Add);
-  WasmRunner<int64_t, int64_t, int64_t> r(execution_mode);
+  WasmRunner<int64_t> r(execution_mode, MachineType::Int64(),
+                        MachineType::Int64());
   BUILD(r, WASM_I64_ADD(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_INT64_INPUTS(i) {
     FOR_INT64_INPUTS(j) { CHECK_EQ(*i + *j, r.Call(*i, *j)); }
   }
 }
 
 WASM_EXEC_TEST(I64Sub) {
   REQUIRE(I64Sub);
-  WasmRunner<int64_t, int64_t, int64_t> r(execution_mode);
+  WasmRunner<int64_t> r(execution_mode, MachineType::Int64(),
+                        MachineType::Int64());
   BUILD(r, WASM_I64_SUB(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_INT64_INPUTS(i) {
     FOR_INT64_INPUTS(j) { CHECK_EQ(*i - *j, r.Call(*i, *j)); }
   }
 }
 
 WASM_EXEC_TEST(I64AddUseOnlyLowWord) {
   REQUIRE(I64Add);
   REQUIRE(I32ConvertI64);
-  WasmRunner<int32_t, int64_t, int64_t> r(execution_mode);
+  WasmRunner<int32_t> r(execution_mode, MachineType::Int64(),
+                        MachineType::Int64());
   BUILD(r, WASM_I32_CONVERT_I64(
                WASM_I64_ADD(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))));
   FOR_INT64_INPUTS(i) {
     FOR_INT64_INPUTS(j) {
       CHECK_EQ(static_cast<int32_t>(*i + *j), r.Call(*i, *j));
     }
   }
 }
 
 WASM_EXEC_TEST(I64SubUseOnlyLowWord) {
   REQUIRE(I64Sub);
   REQUIRE(I32ConvertI64);
-  WasmRunner<int32_t, int64_t, int64_t> r(execution_mode);
+  WasmRunner<int32_t> r(execution_mode, MachineType::Int64(),
+                        MachineType::Int64());
   BUILD(r, WASM_I32_CONVERT_I64(
                WASM_I64_SUB(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))));
   FOR_INT64_INPUTS(i) {
     FOR_INT64_INPUTS(j) {
       CHECK_EQ(static_cast<int32_t>(*i - *j), r.Call(*i, *j));
     }
   }
 }
 
 WASM_EXEC_TEST(I64MulUseOnlyLowWord) {
   REQUIRE(I64Mul);
   REQUIRE(I32ConvertI64);
-  WasmRunner<int32_t, int64_t, int64_t> r(execution_mode);
+  WasmRunner<int32_t> r(execution_mode, MachineType::Int64(),
+                        MachineType::Int64());
   BUILD(r, WASM_I32_CONVERT_I64(
                WASM_I64_MUL(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))));
   FOR_INT64_INPUTS(i) {
     FOR_INT64_INPUTS(j) {
       CHECK_EQ(static_cast<int32_t>(*i * *j), r.Call(*i, *j));
     }
   }
 }
 
 WASM_EXEC_TEST(I64ShlUseOnlyLowWord) {
   REQUIRE(I64Shl);
   REQUIRE(I32ConvertI64);
-  WasmRunner<int32_t, int64_t, int64_t> r(execution_mode);
+  WasmRunner<int32_t> r(execution_mode, MachineType::Int64(),
+                        MachineType::Int64());
   BUILD(r, WASM_I32_CONVERT_I64(
                WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))));
   FOR_INT64_INPUTS(i) {
     FOR_INT64_INPUTS(j) {
       int32_t expected = static_cast<int32_t>((*i) << (*j & 0x3f));
       CHECK_EQ(expected, r.Call(*i, *j));
     }
   }
 }
 
 WASM_EXEC_TEST(I64ShrUseOnlyLowWord) {
   REQUIRE(I64ShrU);
   REQUIRE(I32ConvertI64);
-  WasmRunner<int32_t, int64_t, int64_t> r(execution_mode);
+  WasmRunner<int32_t> r(execution_mode, MachineType::Int64(),
+                        MachineType::Int64());
   BUILD(r, WASM_I32_CONVERT_I64(
                WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))));
   FOR_UINT64_INPUTS(i) {
     FOR_UINT64_INPUTS(j) {
       int32_t expected = static_cast<int32_t>((*i) >> (*j & 0x3f));
       CHECK_EQ(expected, r.Call(*i, *j));
     }
   }
 }
 
 WASM_EXEC_TEST(I64SarUseOnlyLowWord) {
   REQUIRE(I64ShrS);
   REQUIRE(I32ConvertI64);
-  WasmRunner<int32_t, int64_t, int64_t> r(execution_mode);
+  WasmRunner<int32_t> r(execution_mode, MachineType::Int64(),
+                        MachineType::Int64());
   BUILD(r, WASM_I32_CONVERT_I64(
                WASM_I64_SAR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))));
   FOR_INT64_INPUTS(i) {
     FOR_INT64_INPUTS(j) {
       int32_t expected = static_cast<int32_t>((*i) >> (*j & 0x3f));
       CHECK_EQ(expected, r.Call(*i, *j));
     }
   }
 }
 
 WASM_EXEC_TEST_WITH_TRAP(I64DivS) {
   REQUIRE(I64DivS);
-  WasmRunner<int64_t, int64_t, int64_t> r(execution_mode);
+  WasmRunner<int64_t> r(execution_mode, MachineType::Int64(),
+                        MachineType::Int64());
   BUILD(r, WASM_I64_DIVS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_INT64_INPUTS(i) {
     FOR_INT64_INPUTS(j) {
       if (*j == 0) {
         CHECK_TRAP64(r.Call(*i, *j));
       } else if (*j == -1 && *i == std::numeric_limits<int64_t>::min()) {
         CHECK_TRAP64(r.Call(*i, *j));
       } else {
         CHECK_EQ(*i / *j, r.Call(*i, *j));
       }
     }
   }
 }
 
 WASM_EXEC_TEST_WITH_TRAP(I64DivS_Trap) {
   REQUIRE(I64DivS);
-  WasmRunner<int64_t, int64_t, int64_t> r(execution_mode);
+  WasmRunner<int64_t> r(execution_mode, MachineType::Int64(),
+                        MachineType::Int64());
   BUILD(r, WASM_I64_DIVS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   CHECK_EQ(0, r.Call(asi64(0), asi64(100)));
   CHECK_TRAP64(r.Call(asi64(100), asi64(0)));
   CHECK_TRAP64(r.Call(asi64(-1001), asi64(0)));
   CHECK_TRAP64(r.Call(std::numeric_limits<int64_t>::min(), asi64(-1)));
   CHECK_TRAP64(r.Call(std::numeric_limits<int64_t>::min(), asi64(0)));
 }
 
 WASM_EXEC_TEST_WITH_TRAP(I64DivS_Byzero_Const) {
   REQUIRE(I64DivS);
   for (int8_t denom = -2; denom < 8; denom++) {
-    WasmRunner<int64_t, int64_t> r(execution_mode);
+    WasmRunner<int64_t> r(execution_mode, MachineType::Int64());
     BUILD(r, WASM_I64_DIVS(WASM_GET_LOCAL(0), WASM_I64V_1(denom)));
     for (int64_t val = -7; val < 8; val++) {
       if (denom == 0) {
         CHECK_TRAP64(r.Call(val));
       } else {
         CHECK_EQ(val / denom, r.Call(val));
       }
     }
   }
 }
 
 WASM_EXEC_TEST_WITH_TRAP(I64DivU) {
   REQUIRE(I64DivU);
-  WasmRunner<uint64_t, uint64_t, uint64_t> r(execution_mode);
+  WasmRunner<uint64_t> r(execution_mode, MachineType::Uint64(),
+                         MachineType::Uint64());
   BUILD(r, WASM_I64_DIVU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_UINT64_INPUTS(i) {
     FOR_UINT64_INPUTS(j) {
       if (*j == 0) {
         CHECK_TRAP64(r.Call(*i, *j));
       } else {
         CHECK_EQ(*i / *j, r.Call(*i, *j));
       }
     }
   }
 }
 
 WASM_EXEC_TEST_WITH_TRAP(I64DivU_Trap) {
   REQUIRE(I64DivU);
-  WasmRunner<uint64_t, uint64_t, uint64_t> r(execution_mode);
+  WasmRunner<uint64_t> r(execution_mode, MachineType::Uint64(),
+                         MachineType::Uint64());
   BUILD(r, WASM_I64_DIVU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
-  CHECK_EQ(0, r.Call(asu64(0), asu64(100)));
+  CHECK_EQ(0u, r.Call(asu64(0), asu64(100)));
   CHECK_TRAP64(r.Call(asu64(100), asu64(0)));
   CHECK_TRAP64(r.Call(asu64(1001), asu64(0)));
   CHECK_TRAP64(r.Call(std::numeric_limits<uint64_t>::max(), asu64(0)));
 }
 
 WASM_EXEC_TEST_WITH_TRAP(I64DivU_Byzero_Const) {
   REQUIRE(I64DivU);
   for (uint64_t denom = 0xfffffffffffffffe; denom < 8; denom++) {
-    WasmRunner<uint64_t, uint64_t> r(execution_mode);
+    WasmRunner<uint64_t> r(execution_mode, MachineType::Uint64());
     BUILD(r, WASM_I64_DIVU(WASM_GET_LOCAL(0), WASM_I64V_1(denom)));
 
     for (uint64_t val = 0xfffffffffffffff0; val < 8; val++) {
       if (denom == 0) {
         CHECK_TRAP64(r.Call(val));
       } else {
         CHECK_EQ(val / denom, r.Call(val));
       }
     }
   }
 }
 
 WASM_EXEC_TEST_WITH_TRAP(I64RemS) {
   REQUIRE(I64RemS);
-  WasmRunner<int64_t, int64_t, int64_t> r(execution_mode);
+  WasmRunner<int64_t> r(execution_mode, MachineType::Int64(),
+                        MachineType::Int64());
   BUILD(r, WASM_I64_REMS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_INT64_INPUTS(i) {
     FOR_INT64_INPUTS(j) {
       if (*j == 0) {
         CHECK_TRAP64(r.Call(*i, *j));
       } else {
         CHECK_EQ(*i % *j, r.Call(*i, *j));
       }
     }
   }
 }
 
 WASM_EXEC_TEST_WITH_TRAP(I64RemS_Trap) {
   REQUIRE(I64RemS);
-  WasmRunner<int64_t, int64_t, int64_t> r(execution_mode);
+  WasmRunner<int64_t> r(execution_mode, MachineType::Int64(),
+                        MachineType::Int64());
   BUILD(r, WASM_I64_REMS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   CHECK_EQ(33, r.Call(asi64(133), asi64(100)));
   CHECK_EQ(0, r.Call(std::numeric_limits<int64_t>::min(), asi64(-1)));
   CHECK_TRAP64(r.Call(asi64(100), asi64(0)));
   CHECK_TRAP64(r.Call(asi64(-1001), asi64(0)));
   CHECK_TRAP64(r.Call(std::numeric_limits<int64_t>::min(), asi64(0)));
 }
 
 WASM_EXEC_TEST_WITH_TRAP(I64RemU) {
   REQUIRE(I64RemU);
-  WasmRunner<uint64_t, uint64_t, uint64_t> r(execution_mode);
+  WasmRunner<uint64_t> r(execution_mode, MachineType::Uint64(),
+                         MachineType::Uint64());
   BUILD(r, WASM_I64_REMU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_UINT64_INPUTS(i) {
     FOR_UINT64_INPUTS(j) {
       if (*j == 0) {
         CHECK_TRAP64(r.Call(*i, *j));
       } else {
         CHECK_EQ(*i % *j, r.Call(*i, *j));
       }
     }
   }
 }
 
 WASM_EXEC_TEST_WITH_TRAP(I64RemU_Trap) {
   REQUIRE(I64RemU);
-  WasmRunner<uint64_t, uint64_t, uint64_t> r(execution_mode);
+  WasmRunner<uint64_t> r(execution_mode, MachineType::Uint64(),
+                         MachineType::Uint64());
   BUILD(r, WASM_I64_REMU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
-  CHECK_EQ(17, r.Call(asu64(217), asu64(100)));
+  CHECK_EQ(17u, r.Call(asu64(217), asu64(100)));
   CHECK_TRAP64(r.Call(asu64(100), asu64(0)));
   CHECK_TRAP64(r.Call(asu64(1001), asu64(0)));
   CHECK_TRAP64(r.Call(std::numeric_limits<uint64_t>::max(), asu64(0)));
 }
 
 WASM_EXEC_TEST(I64And) {
   REQUIRE(I64And);
-  WasmRunner<int64_t, int64_t, int64_t> r(execution_mode);
+  WasmRunner<int64_t> r(execution_mode, MachineType::Int64(),
+                        MachineType::Int64());
   BUILD(r, WASM_I64_AND(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_INT64_INPUTS(i) {
     FOR_INT64_INPUTS(j) { CHECK_EQ((*i) & (*j), r.Call(*i, *j)); }
   }
 }
 
 WASM_EXEC_TEST(I64Ior) {
   REQUIRE(I64Ior);
-  WasmRunner<int64_t, int64_t, int64_t> r(execution_mode);
+  WasmRunner<int64_t> r(execution_mode, MachineType::Int64(),
+                        MachineType::Int64());
   BUILD(r, WASM_I64_IOR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_INT64_INPUTS(i) {
     FOR_INT64_INPUTS(j) { CHECK_EQ((*i) | (*j), r.Call(*i, *j)); }
   }
 }
 
 WASM_EXEC_TEST(I64Xor) {
   REQUIRE(I64Xor);
-  WasmRunner<int64_t, int64_t, int64_t> r(execution_mode);
+  WasmRunner<int64_t> r(execution_mode, MachineType::Int64(),
+                        MachineType::Int64());
   BUILD(r, WASM_I64_XOR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_INT64_INPUTS(i) {
     FOR_INT64_INPUTS(j) { CHECK_EQ((*i) ^ (*j), r.Call(*i, *j)); }
   }
 }
 
 WASM_EXEC_TEST(I64Shl) {
   REQUIRE(I64Shl);
   {
-    WasmRunner<uint64_t, uint64_t, uint64_t> r(execution_mode);
+    WasmRunner<uint64_t> r(execution_mode, MachineType::Uint64(),
+                           MachineType::Uint64());
     BUILD(r, WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
 
     FOR_UINT64_INPUTS(i) {
       FOR_UINT64_INPUTS(j) {
         uint64_t expected = (*i) << (*j & 0x3f);
         CHECK_EQ(expected, r.Call(*i, *j));
       }
     }
   }
   {
-    WasmRunner<uint64_t, int64_t> r(execution_mode);
+    WasmRunner<uint64_t> r(execution_mode, MachineType::Int64());
     BUILD(r, WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_I64V_1(0)));
     FOR_UINT64_INPUTS(i) { CHECK_EQ(*i << 0, r.Call(*i)); }
   }
   {
-    WasmRunner<uint64_t, int64_t> r(execution_mode);
+    WasmRunner<uint64_t> r(execution_mode, MachineType::Int64());
     BUILD(r, WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_I64V_1(32)));
     FOR_UINT64_INPUTS(i) { CHECK_EQ(*i << 32, r.Call(*i)); }
   }
   {
-    WasmRunner<uint64_t, int64_t> r(execution_mode);
+    WasmRunner<uint64_t> r(execution_mode, MachineType::Int64());
     BUILD(r, WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_I64V_1(20)));
     FOR_UINT64_INPUTS(i) { CHECK_EQ(*i << 20, r.Call(*i)); }
   }
   {
-    WasmRunner<uint64_t, int64_t> r(execution_mode);
+    WasmRunner<uint64_t> r(execution_mode, MachineType::Int64());
     BUILD(r, WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_I64V_1(40)));
     FOR_UINT64_INPUTS(i) { CHECK_EQ(*i << 40, r.Call(*i)); }
   }
 }
 
 WASM_EXEC_TEST(I64ShrU) {
   REQUIRE(I64ShrU);
   {
-    WasmRunner<uint64_t, uint64_t, uint64_t> r(execution_mode);
+    WasmRunner<uint64_t> r(execution_mode, MachineType::Uint64(),
+                           MachineType::Uint64());
     BUILD(r, WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
 
     FOR_UINT64_INPUTS(i) {
       FOR_UINT64_INPUTS(j) {
         uint64_t expected = (*i) >> (*j & 0x3f);
         CHECK_EQ(expected, r.Call(*i, *j));
       }
     }
   }
   {
-    WasmRunner<uint64_t, int64_t> r(execution_mode);
+    WasmRunner<uint64_t> r(execution_mode, MachineType::Int64());
     BUILD(r, WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_I64V_1(0)));
     FOR_UINT64_INPUTS(i) { CHECK_EQ(*i >> 0, r.Call(*i)); }
   }
   {
-    WasmRunner<uint64_t, int64_t> r(execution_mode);
+    WasmRunner<uint64_t> r(execution_mode, MachineType::Int64());
     BUILD(r, WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_I64V_1(32)));
     FOR_UINT64_INPUTS(i) { CHECK_EQ(*i >> 32, r.Call(*i)); }
   }
   {
-    WasmRunner<uint64_t, int64_t> r(execution_mode);
+    WasmRunner<uint64_t> r(execution_mode, MachineType::Int64());
     BUILD(r, WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_I64V_1(20)));
     FOR_UINT64_INPUTS(i) { CHECK_EQ(*i >> 20, r.Call(*i)); }
   }
   {
-    WasmRunner<uint64_t, int64_t> r(execution_mode);
+    WasmRunner<uint64_t> r(execution_mode, MachineType::Int64());
     BUILD(r, WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_I64V_1(40)));
     FOR_UINT64_INPUTS(i) { CHECK_EQ(*i >> 40, r.Call(*i)); }
   }
 }
 
 WASM_EXEC_TEST(I64ShrS) {
   REQUIRE(I64ShrS);
   {
-    WasmRunner<int64_t, int64_t, int64_t> r(execution_mode);
+    WasmRunner<int64_t> r(execution_mode, MachineType::Int64(),
+                          MachineType::Int64());
     BUILD(r, WASM_I64_SAR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
 
     FOR_INT64_INPUTS(i) {
       FOR_INT64_INPUTS(j) {
         int64_t expected = (*i) >> (*j & 0x3f);
         CHECK_EQ(expected, r.Call(*i, *j));
       }
     }
   }
   {
-    WasmRunner<int64_t, int64_t> r(execution_mode);
+    WasmRunner<int64_t> r(execution_mode, MachineType::Int64());
     BUILD(r, WASM_I64_SAR(WASM_GET_LOCAL(0), WASM_I64V_1(0)));
     FOR_INT64_INPUTS(i) { CHECK_EQ(*i >> 0, r.Call(*i)); }
   }
   {
-    WasmRunner<int64_t, int64_t> r(execution_mode);
+    WasmRunner<int64_t> r(execution_mode, MachineType::Int64());
     BUILD(r, WASM_I64_SAR(WASM_GET_LOCAL(0), WASM_I64V_1(32)));
     FOR_INT64_INPUTS(i) { CHECK_EQ(*i >> 32, r.Call(*i)); }
   }
   {
-    WasmRunner<int64_t, int64_t> r(execution_mode);
+    WasmRunner<int64_t> r(execution_mode, MachineType::Int64());
     BUILD(r, WASM_I64_SAR(WASM_GET_LOCAL(0), WASM_I64V_1(20)));
     FOR_INT64_INPUTS(i) { CHECK_EQ(*i >> 20, r.Call(*i)); }
   }
   {
-    WasmRunner<int64_t, int64_t> r(execution_mode);
+    WasmRunner<int64_t> r(execution_mode, MachineType::Int64());
     BUILD(r, WASM_I64_SAR(WASM_GET_LOCAL(0), WASM_I64V_1(40)));
     FOR_INT64_INPUTS(i) { CHECK_EQ(*i >> 40, r.Call(*i)); }
   }
 }
 
 WASM_EXEC_TEST(I64Eq) {
   REQUIRE(I64Eq);
-  WasmRunner<int32_t, int64_t, int64_t> r(execution_mode);
+  WasmRunner<int32_t> r(execution_mode, MachineType::Int64(),
+                        MachineType::Int64());
   BUILD(r, WASM_I64_EQ(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_INT64_INPUTS(i) {
     FOR_INT64_INPUTS(j) { CHECK_EQ(*i == *j ? 1 : 0, r.Call(*i, *j)); }
   }
 }
 
 WASM_EXEC_TEST(I64Ne) {
   REQUIRE(I64Ne);
-  WasmRunner<int32_t, int64_t, int64_t> r(execution_mode);
+  WasmRunner<int32_t> r(execution_mode, MachineType::Int64(),
+                        MachineType::Int64());
   BUILD(r, WASM_I64_NE(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_INT64_INPUTS(i) {
     FOR_INT64_INPUTS(j) { CHECK_EQ(*i != *j ? 1 : 0, r.Call(*i, *j)); }
   }
 }
 
 WASM_EXEC_TEST(I64LtS) {
   REQUIRE(I64LtS);
-  WasmRunner<int32_t, int64_t, int64_t> r(execution_mode);
+  WasmRunner<int32_t> r(execution_mode, MachineType::Int64(),
+                        MachineType::Int64());
   BUILD(r, WASM_I64_LTS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_INT64_INPUTS(i) {
     FOR_INT64_INPUTS(j) { CHECK_EQ(*i < *j ? 1 : 0, r.Call(*i, *j)); }
   }
 }
 
 WASM_EXEC_TEST(I64LeS) {
   REQUIRE(I64LeS);
-  WasmRunner<int32_t, int64_t, int64_t> r(execution_mode);
+  WasmRunner<int32_t> r(execution_mode, MachineType::Int64(),
+                        MachineType::Int64());
   BUILD(r, WASM_I64_LES(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_INT64_INPUTS(i) {
     FOR_INT64_INPUTS(j) { CHECK_EQ(*i <= *j ? 1 : 0, r.Call(*i, *j)); }
   }
 }
 
 WASM_EXEC_TEST(I64LtU) {
   REQUIRE(I64LtU);
-  WasmRunner<int32_t, int64_t, int64_t> r(execution_mode);
+  WasmRunner<int32_t> r(execution_mode, MachineType::Int64(),
+                        MachineType::Int64());
   BUILD(r, WASM_I64_LTU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_UINT64_INPUTS(i) {
     FOR_UINT64_INPUTS(j) { CHECK_EQ(*i < *j ? 1 : 0, r.Call(*i, *j)); }
   }
 }
 
 WASM_EXEC_TEST(I64LeU) {
   REQUIRE(I64LeU);
-  WasmRunner<int32_t, int64_t, int64_t> r(execution_mode);
+  WasmRunner<int32_t> r(execution_mode, MachineType::Int64(),
+                        MachineType::Int64());
   BUILD(r, WASM_I64_LEU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_UINT64_INPUTS(i) {
     FOR_UINT64_INPUTS(j) { CHECK_EQ(*i <= *j ? 1 : 0, r.Call(*i, *j)); }
   }
 }
 
 WASM_EXEC_TEST(I64GtS) {
   REQUIRE(I64GtS);
-  WasmRunner<int32_t, int64_t, int64_t> r(execution_mode);
+  WasmRunner<int32_t> r(execution_mode, MachineType::Int64(),
+                        MachineType::Int64());
   BUILD(r, WASM_I64_GTS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_INT64_INPUTS(i) {
     FOR_INT64_INPUTS(j) { CHECK_EQ(*i > *j ? 1 : 0, r.Call(*i, *j)); }
   }
 }
 
 WASM_EXEC_TEST(I64GeS) {
   REQUIRE(I64GeS);
-  WasmRunner<int32_t, int64_t, int64_t> r(execution_mode);
+  WasmRunner<int32_t> r(execution_mode, MachineType::Int64(),
+                        MachineType::Int64());
   BUILD(r, WASM_I64_GES(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_INT64_INPUTS(i) {
     FOR_INT64_INPUTS(j) { CHECK_EQ(*i >= *j ? 1 : 0, r.Call(*i, *j)); }
   }
 }
 
 WASM_EXEC_TEST(I64GtU) {
   REQUIRE(I64GtU);
-  WasmRunner<int32_t, int64_t, int64_t> r(execution_mode);
+  WasmRunner<int32_t> r(execution_mode, MachineType::Int64(),
+                        MachineType::Int64());
   BUILD(r, WASM_I64_GTU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_UINT64_INPUTS(i) {
     FOR_UINT64_INPUTS(j) { CHECK_EQ(*i > *j ? 1 : 0, r.Call(*i, *j)); }
   }
 }
 
 WASM_EXEC_TEST(I64GeU) {
   REQUIRE(I64GeU);
-  WasmRunner<int32_t, int64_t, int64_t> r(execution_mode);
+  WasmRunner<int32_t> r(execution_mode, MachineType::Int64(),
+                        MachineType::Int64());
   BUILD(r, WASM_I64_GEU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_UINT64_INPUTS(i) {
     FOR_UINT64_INPUTS(j) { CHECK_EQ(*i >= *j ? 1 : 0, r.Call(*i, *j)); }
   }
 }
 
 WASM_EXEC_TEST(I32ConvertI64) {
   REQUIRE(I32ConvertI64);
   FOR_INT64_INPUTS(i) {
     WasmRunner<int32_t> r(execution_mode);
     BUILD(r, WASM_I32_CONVERT_I64(WASM_I64V(*i)));
     CHECK_EQ(static_cast<int32_t>(*i), r.Call());
   }
 }
 
 WASM_EXEC_TEST(I64SConvertI32) {
   REQUIRE(I64SConvertI32);
-  WasmRunner<int64_t, int32_t> r(execution_mode);
+  WasmRunner<int64_t> r(execution_mode, MachineType::Int32());
   BUILD(r, WASM_I64_SCONVERT_I32(WASM_GET_LOCAL(0)));
   FOR_INT32_INPUTS(i) { CHECK_EQ(static_cast<int64_t>(*i), r.Call(*i)); }
 }
 
 WASM_EXEC_TEST(I64UConvertI32) {
   REQUIRE(I64UConvertI32);
-  WasmRunner<int64_t, uint32_t> r(execution_mode);
+  WasmRunner<int64_t> r(execution_mode, MachineType::Uint32());
   BUILD(r, WASM_I64_UCONVERT_I32(WASM_GET_LOCAL(0)));
   FOR_UINT32_INPUTS(i) { CHECK_EQ(static_cast<int64_t>(*i), r.Call(*i)); }
 }
 
 WASM_EXEC_TEST(I64Popcnt) {
   struct {
     int64_t expected;
     uint64_t input;
   } values[] = {{64, 0xffffffffffffffff},
                 {0, 0x0000000000000000},
                 {2, 0x0000080000008000},
                 {26, 0x1123456782345678},
                 {38, 0xffedcba09edcba09}};
 
-  WasmRunner<int64_t, uint64_t> r(execution_mode);
+  WasmRunner<int64_t> r(execution_mode, MachineType::Uint64());
   BUILD(r, WASM_I64_POPCNT(WASM_GET_LOCAL(0)));
   for (size_t i = 0; i < arraysize(values); i++) {
     CHECK_EQ(values[i].expected, r.Call(values[i].input));
   }
 }
 
 WASM_EXEC_TEST(F32SConvertI64) {
   REQUIRE(F32SConvertI64);
-  WasmRunner<float, int64_t> r(execution_mode);
+  WasmRunner<float> r(execution_mode, MachineType::Int64());
   BUILD(r, WASM_F32_SCONVERT_I64(WASM_GET_LOCAL(0)));
   FOR_INT64_INPUTS(i) { CHECK_FLOAT_EQ(static_cast<float>(*i), r.Call(*i)); }
 }
 
 WASM_EXEC_TEST(F32UConvertI64) {
   REQUIRE(F32UConvertI64);
   struct {
     uint64_t input;
     uint32_t expected;
   } values[] = {{0x0, 0x0},
@@ skipping 65 matching lines @@
                 {0x3fffffffffff, 0x56800000},
                 {0x1fffffffffff, 0x56000000},
                 {0xfffffffffff, 0x55800000},
                 {0x7ffffffffff, 0x55000000},
                 {0x3ffffffffff, 0x54800000},
                 {0x1ffffffffff, 0x54000000},
                 {0x8000008000000000, 0x5f000000},
                 {0x8000008000000001, 0x5f000001},
                 {0x8000000000000400, 0x5f000000},
                 {0x8000000000000401, 0x5f000000}};
-  WasmRunner<float, uint64_t> r(execution_mode);
+  WasmRunner<float> r(execution_mode, MachineType::Uint64());
   BUILD(r, WASM_F32_UCONVERT_I64(WASM_GET_LOCAL(0)));
   for (size_t i = 0; i < arraysize(values); i++) {
     CHECK_EQ(bit_cast<float>(values[i].expected), r.Call(values[i].input));
   }
 }
 
 WASM_EXEC_TEST(F64SConvertI64) {
   REQUIRE(F64SConvertI64);
-  WasmRunner<double, int64_t> r(execution_mode);
+  WasmRunner<double> r(execution_mode, MachineType::Int64());
   BUILD(r, WASM_F64_SCONVERT_I64(WASM_GET_LOCAL(0)));
   FOR_INT64_INPUTS(i) { CHECK_DOUBLE_EQ(static_cast<double>(*i), r.Call(*i)); }
 }
 
 WASM_EXEC_TEST(F64UConvertI64) {
   REQUIRE(F64UConvertI64);
   struct {
     uint64_t input;
     uint64_t expected;
   } values[] = {{0x0, 0x0},
@@ skipping 64 matching lines @@
                 {0x3fffffffffff, 0x42cfffffffffff80},
                 {0x1fffffffffff, 0x42bfffffffffff00},
                 {0xfffffffffff, 0x42affffffffffe00},
                 {0x7ffffffffff, 0x429ffffffffffc00},
                 {0x3ffffffffff, 0x428ffffffffff800},
                 {0x1ffffffffff, 0x427ffffffffff000},
                 {0x8000008000000000, 0x43e0000010000000},
                 {0x8000008000000001, 0x43e0000010000000},
                 {0x8000000000000400, 0x43e0000000000000},
                 {0x8000000000000401, 0x43e0000000000001}};
-  WasmRunner<double, uint64_t> r(execution_mode);
+  WasmRunner<double> r(execution_mode, MachineType::Uint64());
   BUILD(r, WASM_F64_UCONVERT_I64(WASM_GET_LOCAL(0)));
   for (size_t i = 0; i < arraysize(values); i++) {
     CHECK_EQ(bit_cast<double>(values[i].expected), r.Call(values[i].input));
   }
 }
 
 WASM_EXEC_TEST_WITH_TRAP(I64SConvertF32a) {
-  WasmRunner<int64_t, float> r(execution_mode);
+  WasmRunner<int64_t> r(execution_mode, MachineType::Float32());
   BUILD(r, WASM_I64_SCONVERT_F32(WASM_GET_LOCAL(0)));
 
   FOR_FLOAT32_INPUTS(i) {
     if (*i < static_cast<float>(std::numeric_limits<int64_t>::max()) &&
         *i >= static_cast<float>(std::numeric_limits<int64_t>::min())) {
       CHECK_EQ(static_cast<int64_t>(*i), r.Call(*i));
     } else {
       CHECK_TRAP64(r.Call(*i));
     }
   }
 }
 
 WASM_EXEC_TEST_WITH_TRAP(I64SConvertF64a) {
-  WasmRunner<int64_t, double> r(execution_mode);
+  WasmRunner<int64_t> r(execution_mode, MachineType::Float64());
   BUILD(r, WASM_I64_SCONVERT_F64(WASM_GET_LOCAL(0)));
 
   FOR_FLOAT64_INPUTS(i) {
     if (*i < static_cast<double>(std::numeric_limits<int64_t>::max()) &&
         *i >= static_cast<double>(std::numeric_limits<int64_t>::min())) {
       CHECK_EQ(static_cast<int64_t>(*i), r.Call(*i));
     } else {
       CHECK_TRAP64(r.Call(*i));
     }
   }
 }
 
 WASM_EXEC_TEST_WITH_TRAP(I64UConvertF32a) {
-  WasmRunner<uint64_t, float> r(execution_mode);
+  WasmRunner<uint64_t> r(execution_mode, MachineType::Float32());
   BUILD(r, WASM_I64_UCONVERT_F32(WASM_GET_LOCAL(0)));
 
   FOR_FLOAT32_INPUTS(i) {
     if (*i < static_cast<float>(std::numeric_limits<uint64_t>::max()) &&
         *i > -1) {
       CHECK_EQ(static_cast<uint64_t>(*i), r.Call(*i));
     } else {
       CHECK_TRAP64(r.Call(*i));
     }
   }
 }
 
 WASM_EXEC_TEST_WITH_TRAP(I64UConvertF64a) {
-  WasmRunner<uint64_t, double> r(execution_mode);
+  WasmRunner<uint64_t> r(execution_mode, MachineType::Float64());
   BUILD(r, WASM_I64_UCONVERT_F64(WASM_GET_LOCAL(0)));
 
   FOR_FLOAT64_INPUTS(i) {
     if (*i < static_cast<float>(std::numeric_limits<uint64_t>::max()) &&
         *i > -1) {
       CHECK_EQ(static_cast<uint64_t>(*i), r.Call(*i));
     } else {
       CHECK_TRAP64(r.Call(*i));
     }
   }
 }
 
 WASM_EXEC_TEST(CallI64Parameter) {
+  // Build the target function.
   LocalType param_types[20];
   for (int i = 0; i < 20; i++) param_types[i] = kAstI64;
   param_types[3] = kAstI32;
   param_types[4] = kAstI32;
   FunctionSig sig(1, 19, param_types);
   for (int i = 0; i < 19; i++) {
-    if (i == 2 || i == 3) continue;
-    WasmRunner<int32_t> r(execution_mode);
-    // Build the target function.
-    WasmFunctionCompiler& t = r.NewFunction(&sig);
-    BUILD(t, WASM_GET_LOCAL(i));
+    TestingModule module(execution_mode);
+    WasmFunctionCompiler t(&sig, &module);
+    if (i == 2 || i == 3) {
+      continue;
+    } else {
+      BUILD(t, WASM_GET_LOCAL(i));
+    }
+    uint32_t index = t.CompileAndAdd();
 
     // Build the calling function.
+    WasmRunner<int32_t> r(&module);
     BUILD(
         r,
         WASM_I32_CONVERT_I64(WASM_CALL_FUNCTION(
-            t.function_index(), WASM_I64V_9(0xbcd12340000000b),
+            index, WASM_I64V_9(0xbcd12340000000b),
             WASM_I64V_9(0xbcd12340000000c), WASM_I32V_1(0xd),
             WASM_I32_CONVERT_I64(WASM_I64V_9(0xbcd12340000000e)),
             WASM_I64V_9(0xbcd12340000000f), WASM_I64V_10(0xbcd1234000000010),
             WASM_I64V_10(0xbcd1234000000011), WASM_I64V_10(0xbcd1234000000012),
             WASM_I64V_10(0xbcd1234000000013), WASM_I64V_10(0xbcd1234000000014),
             WASM_I64V_10(0xbcd1234000000015), WASM_I64V_10(0xbcd1234000000016),
             WASM_I64V_10(0xbcd1234000000017), WASM_I64V_10(0xbcd1234000000018),
             WASM_I64V_10(0xbcd1234000000019), WASM_I64V_10(0xbcd123400000001a),
             WASM_I64V_10(0xbcd123400000001b), WASM_I64V_10(0xbcd123400000001c),
             WASM_I64V_10(0xbcd123400000001d))));
 
     CHECK_EQ(i + 0xb, r.Call());
   }
 }
 
 void TestI64Binop(WasmExecutionMode execution_mode, WasmOpcode opcode,
                   int64_t expected, int64_t a, int64_t b) {
   {
     WasmRunner<int64_t> r(execution_mode);
     // return K op K
     BUILD(r, WASM_BINOP(opcode, WASM_I64V(a), WASM_I64V(b)));
     CHECK_EQ(expected, r.Call());
   }
   {
-    WasmRunner<int64_t, int64_t, int64_t> r(execution_mode);
+    WasmRunner<int64_t> r(execution_mode, MachineType::Int64(),
+                          MachineType::Int64());
     // return a op b
     BUILD(r, WASM_BINOP(opcode, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
     CHECK_EQ(expected, r.Call(a, b));
   }
 }
 
 void TestI64Cmp(WasmExecutionMode execution_mode, WasmOpcode opcode,
                 int64_t expected, int64_t a, int64_t b) {
   {
     WasmRunner<int32_t> r(execution_mode);
     // return K op K
     BUILD(r, WASM_BINOP(opcode, WASM_I64V(a), WASM_I64V(b)));
     CHECK_EQ(expected, r.Call());
   }
   {
-    WasmRunner<int32_t, int64_t, int64_t> r(execution_mode);
+    WasmRunner<int32_t> r(execution_mode, MachineType::Int64(),
+                          MachineType::Int64());
     // return a op b
     BUILD(r, WASM_BINOP(opcode, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
     CHECK_EQ(expected, r.Call(a, b));
   }
 }
 
 #define TEST_I64_BINOP(name, expected, a, b)                     \
   do {                                                           \
     if (WASM_64 || kSupported_##name)                            \
       TestI64Binop(execution_mode, kExpr##name, expected, a, b); \
@@ skipping 82 matching lines @@
                 {48, 0x0000000000008040}, {49, 0x0000000000004005},
                 {50, 0x0000000000002050}, {51, 0x0000000000001700},
                 {52, 0x0000000000000870}, {53, 0x0000000000000405},
                 {54, 0x0000000000000203}, {55, 0x0000000000000101},
                 {56, 0x0000000000000089}, {57, 0x0000000000000041},
                 {58, 0x0000000000000022}, {59, 0x0000000000000013},
                 {60, 0x0000000000000008}, {61, 0x0000000000000004},
                 {62, 0x0000000000000002}, {63, 0x0000000000000001},
                 {64, 0x0000000000000000}};
 
-  WasmRunner<int64_t, uint64_t> r(execution_mode);
+  WasmRunner<int64_t> r(execution_mode, MachineType::Uint64());
   BUILD(r, WASM_I64_CLZ(WASM_GET_LOCAL(0)));
   for (size_t i = 0; i < arraysize(values); i++) {
     CHECK_EQ(values[i].expected, r.Call(values[i].input));
   }
 }
 
 WASM_EXEC_TEST(I64Ctz) {
   REQUIRE(I64Ctz);
   struct {
     int64_t expected;
@@ skipping 25 matching lines @@
                 {16, 0x00000000b8f10000}, {15, 0x000000003b9f8000},
                 {14, 0x00000000db4c4000}, {13, 0x00000000e9a32000},
                 {12, 0x00000000fca61000}, {11, 0x000000006c8a7800},
                 {10, 0x000000008ce5a400}, {9, 0x00000000cb7d0200},
                 {8, 0x00000000cb4dc100},  {7, 0x00000000dfbec580},
                 {6, 0x0000000027a9db40},  {5, 0x00000000de3bcb20},
                 {4, 0x00000000d7e8a610},  {3, 0x000000009afdbc88},
                 {2, 0x000000009afdbc84},  {1, 0x000000009afdbc82},
                 {0, 0x000000009afdbc81}};
 
-  WasmRunner<int64_t, uint64_t> r(execution_mode);
+  WasmRunner<int64_t> r(execution_mode, MachineType::Uint64());
   BUILD(r, WASM_I64_CTZ(WASM_GET_LOCAL(0)));
   for (size_t i = 0; i < arraysize(values); i++) {
     CHECK_EQ(values[i].expected, r.Call(values[i].input));
   }
 }
 
 WASM_EXEC_TEST(I64Popcnt2) {
   REQUIRE(I64Popcnt);
   struct {
     int64_t expected;
     uint64_t input;
   } values[] = {{64, 0xffffffffffffffff},
                 {0, 0x0000000000000000},
                 {2, 0x0000080000008000},
                 {26, 0x1123456782345678},
                 {38, 0xffedcba09edcba09}};
 
-  WasmRunner<int64_t, uint64_t> r(execution_mode);
+  WasmRunner<int64_t> r(execution_mode, MachineType::Uint64());
   BUILD(r, WASM_I64_POPCNT(WASM_GET_LOCAL(0)));
   for (size_t i = 0; i < arraysize(values); i++) {
     CHECK_EQ(values[i].expected, r.Call(values[i].input));
   }
 }
 
 // Test the WasmRunner with an Int64 return value and different numbers of
 // Int64 parameters.
 WASM_EXEC_TEST(I64WasmRunner) {
   REQUIRE(I64Param);
   REQUIRE(I64Xor);
   {FOR_INT64_INPUTS(i){WasmRunner<int64_t> r(execution_mode);
   BUILD(r, WASM_I64V(*i));
   CHECK_EQ(*i, r.Call());
 }
 }
 {
-  WasmRunner<int64_t, int64_t> r(execution_mode);
+  WasmRunner<int64_t> r(execution_mode, MachineType::Int64());
   BUILD(r, WASM_GET_LOCAL(0));
   FOR_INT64_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); }
 }
 {
-  WasmRunner<int64_t, int64_t, int64_t> r(execution_mode);
+  WasmRunner<int64_t> r(execution_mode, MachineType::Int64(),
+                        MachineType::Int64());
   BUILD(r, WASM_I64_XOR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_INT64_INPUTS(i) {
     FOR_INT64_INPUTS(j) { CHECK_EQ(*i ^ *j, r.Call(*i, *j)); }
   }
 }
 {
-  WasmRunner<int64_t, int64_t, int64_t, int64_t> r(execution_mode);
+  WasmRunner<int64_t> r(execution_mode, MachineType::Int64(),
+                        MachineType::Int64(), MachineType::Int64());
   BUILD(r, WASM_I64_XOR(WASM_GET_LOCAL(0),
                         WASM_I64_XOR(WASM_GET_LOCAL(1), WASM_GET_LOCAL(2))));
   FOR_INT64_INPUTS(i) {
     FOR_INT64_INPUTS(j) {
       CHECK_EQ(*i ^ *j ^ *j, r.Call(*i, *j, *j));
       CHECK_EQ(*j ^ *i ^ *j, r.Call(*j, *i, *j));
       CHECK_EQ(*j ^ *j ^ *i, r.Call(*j, *j, *i));
     }
   }
 }
 {
-  WasmRunner<int64_t, int64_t, int64_t, int64_t, int64_t> r(execution_mode);
+  WasmRunner<int64_t> r(execution_mode, MachineType::Int64(),
+                        MachineType::Int64(), MachineType::Int64(),
+                        MachineType::Int64());
   BUILD(r, WASM_I64_XOR(WASM_GET_LOCAL(0),
                         WASM_I64_XOR(WASM_GET_LOCAL(1),
                                      WASM_I64_XOR(WASM_GET_LOCAL(2),
                                                   WASM_GET_LOCAL(3)))));
   FOR_INT64_INPUTS(i) {
     FOR_INT64_INPUTS(j) {
       CHECK_EQ(*i ^ *j ^ *j ^ *j, r.Call(*i, *j, *j, *j));
       CHECK_EQ(*j ^ *i ^ *j ^ *j, r.Call(*j, *i, *j, *j));
       CHECK_EQ(*j ^ *j ^ *i ^ *j, r.Call(*j, *j, *i, *j));
       CHECK_EQ(*j ^ *j ^ *j ^ *i, r.Call(*j, *j, *j, *i));
     }
   }
 }
 }
 
 WASM_EXEC_TEST(Call_Int64Sub) {
   REQUIRE(I64Sub);
-  WasmRunner<int64_t, int64_t, int64_t> r(execution_mode);
   // Build the target function.
   TestSignatures sigs;
-  WasmFunctionCompiler& t = r.NewFunction(sigs.l_ll());
+  TestingModule module(execution_mode);
+  WasmFunctionCompiler t(sigs.l_ll(), &module);
   BUILD(t, WASM_I64_SUB(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
+  uint32_t index = t.CompileAndAdd();
 
   // Build the caller function.
-  BUILD(r, WASM_CALL_FUNCTION(t.function_index(), WASM_GET_LOCAL(0),
-                              WASM_GET_LOCAL(1)));
+  WasmRunner<int64_t> r(&module, MachineType::Int64(), MachineType::Int64());
+  BUILD(r, WASM_CALL_FUNCTION(index, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
 
   FOR_INT32_INPUTS(i) {
     FOR_INT32_INPUTS(j) {
       int64_t a = static_cast<int64_t>(*i) << 32 |
                   (static_cast<int64_t>(*j) | 0xFFFFFFFF);
       int64_t b = static_cast<int64_t>(*j) << 32 |
                   (static_cast<int64_t>(*i) | 0xFFFFFFFF);
 
       int64_t expected = static_cast<int64_t>(static_cast<uint64_t>(a) -
                                               static_cast<uint64_t>(b));
       CHECK_EQ(expected, r.Call(a, b));
     }
   }
 }
 
 WASM_EXEC_TEST(LoadStoreI64_sx) {
   REQUIRE(I64LoadStore);
   REQUIRE(DepthFirst);
   byte loads[] = {kExprI64LoadMem8S, kExprI64LoadMem16S, kExprI64LoadMem32S,
                   kExprI64LoadMem};
 
   for (size_t m = 0; m < arraysize(loads); m++) {
-    WasmRunner<int64_t> r(execution_mode);
-    byte* memory = r.module().AddMemoryElems<byte>(16);
+    TestingModule module(execution_mode);
+    byte* memory = module.AddMemoryElems<byte>(16);
+    WasmRunner<int64_t> r(&module);
 
     byte code[] = {
         kExprI8Const,     8,  // --
         kExprI8Const,     0,  // --
         loads[m],             // --
         ZERO_ALIGNMENT,       // --
         ZERO_OFFSET,          // --
         kExprI64StoreMem,     // --
         ZERO_ALIGNMENT,       // --
         ZERO_OFFSET,          // --
         kExprI8Const,     0,  // --
         loads[m],             // --
         ZERO_ALIGNMENT,       // --
         ZERO_OFFSET,          // --
     };
 
     r.Build(code, code + arraysize(code));
 
     // Try a bunch of different negative values.
     for (int i = -1; i >= -128; i -= 11) {
       int size = 1 << m;
-      r.module().BlankMemory();
+      module.BlankMemory();
       memory[size - 1] = static_cast<byte>(i);  // set the high order byte.
 
       int64_t expected = static_cast<int64_t>(i) << ((size - 1) * 8);
 
       CHECK_EQ(expected, r.Call());
       CHECK_EQ(static_cast<byte>(i), memory[8 + size - 1]);
       for (int j = size; j < 8; j++) {
         CHECK_EQ(255, memory[8 + j]);
       }
     }
   }
 }
 
 WASM_EXEC_TEST_WITH_TRAP(I64SConvertF32b) {
   REQUIRE(I64SConvertF32);
-  WasmRunner<int64_t, float> r(execution_mode);
+  WasmRunner<int64_t> r(execution_mode, MachineType::Float32());
   BUILD(r, WASM_I64_SCONVERT_F32(WASM_GET_LOCAL(0)));
 
   FOR_FLOAT32_INPUTS(i) {
     if (*i < static_cast<float>(INT64_MAX) &&
         *i >= static_cast<float>(INT64_MIN)) {
       CHECK_EQ(static_cast<int64_t>(*i), r.Call(*i));
     } else {
       CHECK_TRAP64(r.Call(*i));
     }
   }
 }
 
 WASM_EXEC_TEST_WITH_TRAP(I64SConvertF64b) {
   REQUIRE(I64SConvertF64);
-  WasmRunner<int64_t, double> r(execution_mode);
+  WasmRunner<int64_t> r(execution_mode, MachineType::Float64());
   BUILD(r, WASM_I64_SCONVERT_F64(WASM_GET_LOCAL(0)));
 
   FOR_FLOAT64_INPUTS(i) {
     if (*i < static_cast<double>(INT64_MAX) &&
         *i >= static_cast<double>(INT64_MIN)) {
       CHECK_EQ(static_cast<int64_t>(*i), r.Call(*i));
     } else {
       CHECK_TRAP64(r.Call(*i));
     }
   }
 }
 
 WASM_EXEC_TEST_WITH_TRAP(I64UConvertF32b) {
   REQUIRE(I64UConvertF32);
-  WasmRunner<uint64_t, float> r(execution_mode);
+  WasmRunner<uint64_t> r(execution_mode, MachineType::Float32());
   BUILD(r, WASM_I64_UCONVERT_F32(WASM_GET_LOCAL(0)));
 
   FOR_FLOAT32_INPUTS(i) {
     if (*i < static_cast<float>(UINT64_MAX) && *i > -1) {
       CHECK_EQ(static_cast<uint64_t>(*i), r.Call(*i));
     } else {
       CHECK_TRAP64(r.Call(*i));
     }
   }
 }
 
 WASM_EXEC_TEST_WITH_TRAP(I64UConvertF64b) {
   REQUIRE(I64UConvertF64);
-  WasmRunner<uint64_t, double> r(execution_mode);
+  WasmRunner<uint64_t> r(execution_mode, MachineType::Float64());
   BUILD(r, WASM_I64_UCONVERT_F64(WASM_GET_LOCAL(0)));
 
   FOR_FLOAT64_INPUTS(i) {
     if (*i < static_cast<float>(UINT64_MAX) && *i > -1) {
       CHECK_EQ(static_cast<uint64_t>(*i), r.Call(*i));
     } else {
       CHECK_TRAP64(r.Call(*i));
     }
   }
 }
 
 WASM_EXEC_TEST(I64ReinterpretF64) {
   REQUIRE(I64ReinterpretF64);
-  WasmRunner<int64_t> r(execution_mode);
-  int64_t* memory = r.module().AddMemoryElems<int64_t>(8);
+  TestingModule module(execution_mode);
+  int64_t* memory = module.AddMemoryElems<int64_t>(8);
+  WasmRunner<int64_t> r(&module);
 
   BUILD(r, WASM_I64_REINTERPRET_F64(
                WASM_LOAD_MEM(MachineType::Float64(), WASM_ZERO)));
 
   FOR_INT32_INPUTS(i) {
     int64_t expected = static_cast<int64_t>(*i) * 0x300010001;
-    r.module().WriteMemory(&memory[0], expected);
+    module.WriteMemory(&memory[0], expected);
     CHECK_EQ(expected, r.Call());
   }
 }
 
 WASM_EXEC_TEST(F64ReinterpretI64) {
   REQUIRE(F64ReinterpretI64);
-  WasmRunner<int64_t, int64_t> r(execution_mode);
-  int64_t* memory = r.module().AddMemoryElems<int64_t>(8);
+  TestingModule module(execution_mode);
+  int64_t* memory = module.AddMemoryElems<int64_t>(8);
+  WasmRunner<int64_t> r(&module, MachineType::Int64());
 
   BUILD(r, WASM_STORE_MEM(MachineType::Float64(), WASM_ZERO,
                           WASM_F64_REINTERPRET_I64(WASM_GET_LOCAL(0))),
         WASM_GET_LOCAL(0));
 
   FOR_INT32_INPUTS(i) {
     int64_t expected = static_cast<int64_t>(*i) * 0x300010001;
     CHECK_EQ(expected, r.Call(expected));
-    CHECK_EQ(expected, r.module().ReadMemory<int64_t>(&memory[0]));
+    CHECK_EQ(expected, module.ReadMemory<int64_t>(&memory[0]));
   }
 }
 
 WASM_EXEC_TEST(LoadMemI64) {
   REQUIRE(I64LoadStore);
-  WasmRunner<int64_t> r(execution_mode);
-  int64_t* memory = r.module().AddMemoryElems<int64_t>(8);
-  r.module().RandomizeMemory(1111);
+  TestingModule module(execution_mode);
+  int64_t* memory = module.AddMemoryElems<int64_t>(8);
+  module.RandomizeMemory(1111);
+  WasmRunner<int64_t> r(&module);
 
   BUILD(r, WASM_LOAD_MEM(MachineType::Int64(), WASM_I8(0)));
 
-  r.module().WriteMemory<int64_t>(&memory[0], 0x1abbccdd00112233LL);
+  module.WriteMemory<int64_t>(&memory[0], 0x1abbccdd00112233LL);
   CHECK_EQ(0x1abbccdd00112233LL, r.Call());
 
-  r.module().WriteMemory<int64_t>(&memory[0], 0x33aabbccdd001122LL);
+  module.WriteMemory<int64_t>(&memory[0], 0x33aabbccdd001122LL);
   CHECK_EQ(0x33aabbccdd001122LL, r.Call());
 
-  r.module().WriteMemory<int64_t>(&memory[0], 77777777);
+  module.WriteMemory<int64_t>(&memory[0], 77777777);
   CHECK_EQ(77777777, r.Call());
 }
 
 WASM_EXEC_TEST(LoadMemI64_alignment) {
   REQUIRE(I64LoadStore);
+  TestingModule module(execution_mode);
+  int64_t* memory = module.AddMemoryElems<int64_t>(8);
   for (byte alignment = 0; alignment <= 3; alignment++) {
-    WasmRunner<int64_t> r(execution_mode);
-    int64_t* memory = r.module().AddMemoryElems<int64_t>(8);
-    r.module().RandomizeMemory(1111);
+    module.RandomizeMemory(1111);
+    WasmRunner<int64_t> r(&module);
 
     BUILD(r,
           WASM_LOAD_MEM_ALIGNMENT(MachineType::Int64(), WASM_I8(0), alignment));
 
-    r.module().WriteMemory<int64_t>(&memory[0], 0x1abbccdd00112233LL);
+    module.WriteMemory<int64_t>(&memory[0], 0x1abbccdd00112233LL);
     CHECK_EQ(0x1abbccdd00112233LL, r.Call());
 
-    r.module().WriteMemory<int64_t>(&memory[0], 0x33aabbccdd001122LL);
+    module.WriteMemory<int64_t>(&memory[0], 0x33aabbccdd001122LL);
     CHECK_EQ(0x33aabbccdd001122LL, r.Call());
 
-    r.module().WriteMemory<int64_t>(&memory[0], 77777777);
+    module.WriteMemory<int64_t>(&memory[0], 77777777);
     CHECK_EQ(77777777, r.Call());
   }
 }
 
 WASM_EXEC_TEST(MemI64_Sum) {
   REQUIRE(I64LoadStore);
   REQUIRE(I64Add);
   REQUIRE(I64Sub);
   REQUIRE(I64Phi);
   const int kNumElems = 20;
-  WasmRunner<uint64_t, int32_t> r(execution_mode);
-  uint64_t* memory = r.module().AddMemoryElems<uint64_t>(kNumElems);
+  TestingModule module(execution_mode);
+  uint64_t* memory = module.AddMemoryElems<uint64_t>(kNumElems);
+  WasmRunner<uint64_t> r(&module, MachineType::Int32());
   const byte kSum = r.AllocateLocal(kAstI64);
 
   BUILD(
       r,
       WASM_WHILE(
           WASM_GET_LOCAL(0),
           WASM_BLOCK(
               WASM_SET_LOCAL(kSum,
                              WASM_I64_ADD(WASM_GET_LOCAL(kSum),
                                           WASM_LOAD_MEM(MachineType::Int64(),
                                                         WASM_GET_LOCAL(0)))),
               WASM_SET_LOCAL(0, WASM_I32_SUB(WASM_GET_LOCAL(0), WASM_I8(8))))),
       WASM_GET_LOCAL(1));
 
   // Run 4 trials.
   for (int i = 0; i < 3; i++) {
-    r.module().RandomizeMemory(i * 33);
+    module.RandomizeMemory(i * 33);
     uint64_t expected = 0;
     for (size_t j = kNumElems - 1; j > 0; j--) {
-      expected += r.module().ReadMemory(&memory[j]);
+      expected += module.ReadMemory(&memory[j]);
     }
     uint64_t result = r.Call(8 * (kNumElems - 1));
     CHECK_EQ(expected, result);
   }
 }
 
 WASM_EXEC_TEST(StoreMemI64_alignment) {
+  TestingModule module(execution_mode);
+  int64_t* memory = module.AddMemoryElems<int64_t>(4);
   const int64_t kWritten = 0x12345678abcd0011ll;
 
   for (byte i = 0; i <= 3; i++) {
-    WasmRunner<int64_t, int64_t> r(execution_mode);
-    int64_t* memory = r.module().AddMemoryElems<int64_t>(4);
+    WasmRunner<int64_t> r(&module, MachineType::Int64());
     BUILD(r, WASM_STORE_MEM_ALIGNMENT(MachineType::Int64(), WASM_ZERO, i,
                                       WASM_GET_LOCAL(0)),
           WASM_GET_LOCAL(0));
-    r.module().RandomizeMemory(1111);
-    r.module().WriteMemory<int64_t>(&memory[0], 0);
+    module.RandomizeMemory(1111);
+    module.WriteMemory<int64_t>(&memory[0], 0);
 
     CHECK_EQ(kWritten, r.Call(kWritten));
-    CHECK_EQ(kWritten, r.module().ReadMemory(&memory[0]));
+    CHECK_EQ(kWritten, module.ReadMemory(&memory[0]));
   }
 }
 
 WASM_EXEC_TEST(I64Global) {
   REQUIRE(I64LoadStore);
   REQUIRE(I64SConvertI32);
   REQUIRE(I64And);
   REQUIRE(DepthFirst);
-  WasmRunner<int32_t, int32_t> r(execution_mode);
-  int64_t* global = r.module().AddGlobal<int64_t>();
+  TestingModule module(execution_mode);
+  int64_t* global = module.AddGlobal<int64_t>(kAstI64);
+  WasmRunner<int32_t> r(&module, MachineType::Int32());
   // global = global + p0
   BUILD(r, WASM_SET_GLOBAL(
                0, WASM_I64_AND(WASM_GET_GLOBAL(0),
                                WASM_I64_SCONVERT_I32(WASM_GET_LOCAL(0)))),
         WASM_ZERO);
 
-  r.module().WriteMemory<int64_t>(global, 0xFFFFFFFFFFFFFFFFLL);
+  module.WriteMemory<int64_t>(global, 0xFFFFFFFFFFFFFFFFLL);
   for (int i = 9; i < 444444; i += 111111) {
     int64_t expected = *global & i;
     r.Call(i);
     CHECK_EQ(expected, *global);
   }
 }
 
 WASM_EXEC_TEST(I64Eqz) {
   REQUIRE(I64Eq);
 
-  WasmRunner<int32_t, int64_t> r(execution_mode);
+  WasmRunner<int32_t> r(execution_mode, MachineType::Int64());
   BUILD(r, WASM_I64_EQZ(WASM_GET_LOCAL(0)));
 
   FOR_INT64_INPUTS(i) {
     int32_t result = *i == 0 ? 1 : 0;
     CHECK_EQ(result, r.Call(*i));
   }
 }
 
 WASM_EXEC_TEST(I64Ror) {
   REQUIRE(I64Ror);
-  WasmRunner<int64_t, int64_t, int64_t> r(execution_mode);
+  WasmRunner<int64_t> r(execution_mode, MachineType::Int64(),
+                        MachineType::Int64());
   BUILD(r, WASM_I64_ROR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
 
   FOR_UINT64_INPUTS(i) {
     FOR_UINT64_INPUTS(j) {
       int64_t expected = bits::RotateRight64(*i, *j & 0x3f);
       CHECK_EQ(expected, r.Call(*i, *j));
     }
   }
 }
 
 WASM_EXEC_TEST(I64Rol) {
   REQUIRE(I64Rol);
-  WasmRunner<int64_t, int64_t, int64_t> r(execution_mode);
+  WasmRunner<int64_t> r(execution_mode, MachineType::Int64(),
+                        MachineType::Int64());
   BUILD(r, WASM_I64_ROL(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
 
   FOR_UINT64_INPUTS(i) {
     FOR_UINT64_INPUTS(j) {
       int64_t expected = bits::RotateLeft64(*i, *j & 0x3f);
       CHECK_EQ(expected, r.Call(*i, *j));
     }
   }
 }
 
 WASM_EXEC_TEST_WITH_TRAP(StoreMem_offset_oob_i64) {
+  TestingModule module(execution_mode);
+  byte* memory = module.AddMemoryElems<byte>(32);
+
   static const MachineType machineTypes[] = {
       MachineType::Int8(),   MachineType::Uint8(),  MachineType::Int16(),
       MachineType::Uint16(), MachineType::Int32(),  MachineType::Uint32(),
       MachineType::Int64(),  MachineType::Uint64(), MachineType::Float32(),
       MachineType::Float64()};
 
   for (size_t m = 0; m < arraysize(machineTypes); m++) {
-    WasmRunner<int32_t, uint32_t> r(execution_mode);
-    byte* memory = r.module().AddMemoryElems<byte>(32);
-    r.module().RandomizeMemory(1119 + static_cast<int>(m));
+    module.RandomizeMemory(1119 + static_cast<int>(m));
+    WasmRunner<int32_t> r(&module, MachineType::Uint32());
 
     BUILD(r, WASM_STORE_MEM_OFFSET(machineTypes[m], 8, WASM_GET_LOCAL(0),
                                    WASM_LOAD_MEM(machineTypes[m], WASM_ZERO)),
           WASM_ZERO);
 
     byte memsize = WasmOpcodes::MemSize(machineTypes[m]);
     uint32_t boundary = 24 - memsize;
     CHECK_EQ(0, r.Call(boundary));  // in bounds.
     CHECK_EQ(0, memcmp(&memory[0], &memory[8 + boundary], memsize));
 
     for (uint32_t offset = boundary + 1; offset < boundary + 19; offset++) {
       CHECK_TRAP(r.Call(offset));  // out of bounds.
     }
   }
 }
 
 #define ADD_CODE(vec, ...)                                              \
   do {                                                                  \
     byte __buf[] = {__VA_ARGS__};                                       \
     for (size_t i = 0; i < sizeof(__buf); i++) vec.push_back(__buf[i]); \
   } while (false)
 
 static void CompileCallIndirectMany(LocalType param) {
   // Make sure we don't run out of registers when compiling indirect calls
   // with many many parameters.
   TestSignatures sigs;
   for (byte num_params = 0; num_params < 40; num_params++) {
-    WasmRunner<void> r(kExecuteCompiled);
-    FunctionSig* sig = sigs.many(r.zone(), kAstStmt, param, num_params);
+    v8::internal::AccountingAllocator allocator;
+    Zone zone(&allocator, ZONE_NAME);
+    HandleScope scope(CcTest::InitIsolateOnce());
+    TestingModule module(kExecuteCompiled);
+    FunctionSig* sig = sigs.many(&zone, kAstStmt, param, num_params);
 
-    r.module().AddSignature(sig);
-    r.module().AddSignature(sig);
-    r.module().AddIndirectFunctionTable(nullptr, 0);
+    module.AddSignature(sig);
+    module.AddSignature(sig);
+    module.AddIndirectFunctionTable(nullptr, 0);
 
-    WasmFunctionCompiler& t = r.NewFunction(sig);
+    WasmFunctionCompiler t(sig, &module);
 
     std::vector<byte> code;
     for (byte p = 0; p < num_params; p++) {
       ADD_CODE(code, kExprGetLocal, p);
     }
     ADD_CODE(code, kExprI8Const, 0);
     ADD_CODE(code, kExprCallIndirect, 1, TABLE_ZERO);
 
     t.Build(&code[0], &code[0] + code.size());
+    t.Compile();
   }
 }
 
 TEST(Compile_Wasm_CallIndirect_Many_i64) { CompileCallIndirectMany(kAstI64); }
 
 static void Run_WasmMixedCall_N(WasmExecutionMode execution_mode, int start) {
   const int kExpected = 6333;
   const int kElemSize = 8;
   TestSignatures sigs;
 
   static MachineType mixed[] = {
       MachineType::Int32(),   MachineType::Float32(), MachineType::Int64(),
       MachineType::Float64(), MachineType::Float32(), MachineType::Int64(),
       MachineType::Int32(),   MachineType::Float64(), MachineType::Float32(),
       MachineType::Float64(), MachineType::Int32(),   MachineType::Int64(),
       MachineType::Int32(),   MachineType::Int32()};
 
   int num_params = static_cast<int>(arraysize(mixed)) - start;
   for (int which = 0; which < num_params; which++) {
     v8::internal::AccountingAllocator allocator;
     Zone zone(&allocator, ZONE_NAME);
-    WasmRunner<int32_t> r(execution_mode);
-    r.module().AddMemory(1024);
+    TestingModule module(execution_mode);
+    module.AddMemory(1024);
     MachineType* memtypes = &mixed[start];
     MachineType result = memtypes[which];
 
     // =========================================================================
     // Build the selector function.
     // =========================================================================
+    uint32_t index;
     FunctionSig::Builder b(&zone, 1, num_params);
     b.AddReturn(WasmOpcodes::LocalTypeFor(result));
     for (int i = 0; i < num_params; i++) {
       b.AddParam(WasmOpcodes::LocalTypeFor(memtypes[i]));
     }
-    WasmFunctionCompiler& t = r.NewFunction(b.Build());
+    WasmFunctionCompiler t(b.Build(), &module);
     BUILD(t, WASM_GET_LOCAL(which));
+    index = t.CompileAndAdd();
 
     // =========================================================================
     // Build the calling function.
     // =========================================================================
+    WasmRunner<int32_t> r(&module);
     std::vector<byte> code;
 
     // Load the offset for the store.
     ADD_CODE(code, WASM_ZERO);
 
     // Load the arguments.
     for (int i = 0; i < num_params; i++) {
       int offset = (i + 1) * kElemSize;
       ADD_CODE(code, WASM_LOAD_MEM(memtypes[i], WASM_I8(offset)));
     }
 
     // Call the selector function.
-    ADD_CODE(code, WASM_CALL_FUNCTION0(t.function_index()));
+    ADD_CODE(code, kExprCallFunction, static_cast<byte>(index));
 
     // Store the result in memory.
     ADD_CODE(code,
              static_cast<byte>(WasmOpcodes::LoadStoreOpcodeOf(result, true)),
              ZERO_ALIGNMENT, ZERO_OFFSET);
 
     // Return the expected value.
     ADD_CODE(code, WASM_I32V_2(kExpected));
 
     r.Build(&code[0], &code[0] + code.size());
 
     // Run the code.
     for (int t = 0; t < 10; t++) {
-      r.module().RandomizeMemory();
+      module.RandomizeMemory();
       CHECK_EQ(kExpected, r.Call());
 
       int size = WasmOpcodes::MemSize(result);
       for (int i = 0; i < size; i++) {
         int base = (which + 1) * kElemSize;
-        byte expected = r.module().raw_mem_at<byte>(base + i);
-        byte result = r.module().raw_mem_at<byte>(i);
+        byte expected = module.raw_mem_at<byte>(base + i);
+        byte result = module.raw_mem_at<byte>(i);
         CHECK_EQ(expected, result);
       }
     }
   }
 }
 
 WASM_EXEC_TEST(MixedCall_i64_0) { Run_WasmMixedCall_N(execution_mode, 0); }
 WASM_EXEC_TEST(MixedCall_i64_1) { Run_WasmMixedCall_N(execution_mode, 1); }
 WASM_EXEC_TEST(MixedCall_i64_2) { Run_WasmMixedCall_N(execution_mode, 2); }
 WASM_EXEC_TEST(MixedCall_i64_3) { Run_WasmMixedCall_N(execution_mode, 3); }