[wasm] Make WasmRunner the central test structure

The WasmRunner now always holds a TestingModule, and allows to add
several functions to it. The prepares a change to always run wasm code
with a full module behind it, removing the special handling for "no wasm
instance" at runtime (http://crrev.com/2551053002).
This CL here also templatizes the WasmRunner such that the Call method must
be called with the same signature specified for the WasmRunner. This
already catched several mismatches there.

R=titzer@chromium.org, ahaas@chromium.org
BUG=v8:5620

Review-Url: https://codereview.chromium.org/2551043002
Cr-Original-Commit-Position: refs/heads/master@{#41728}
Committed: https://chromium.googlesource.com/v8/v8/+/2ff59062314e9b86bcc28dfaa53cedf2d98e3a13
Review-Url: https://codereview.chromium.org/2551043002
Cr-Commit-Position: refs/heads/master@{#41747}

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

@@ -35,14 +35,14 @@ TEST(Run_WasmInt8Const_i) {
 }
 
 TEST(Run_WasmIfElse) {
-  WasmRunner<int32_t> r(kExecuteInterpreted, MachineType::Int32());
+  WasmRunner<int32_t, int32_t> r(kExecuteInterpreted);
   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> r(kExecuteInterpreted, MachineType::Int32());
+  WasmRunner<int32_t, int32_t> r(kExecuteInterpreted);
   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));
@@ -131,8 +131,7 @@ TEST(Run_WasmBlockBreakN) {
 }
 
 TEST(Run_Wasm_nested_ifs_i) {
-  WasmRunner<int32_t> r(kExecuteInterpreted, MachineType::Int32(),
-                        MachineType::Int32());
+  WasmRunner<int32_t, int32_t, int32_t> r(kExecuteInterpreted);
 
   BUILD(r, WASM_IF_ELSE_I(
                WASM_GET_LOCAL(0),
@@ -180,8 +179,7 @@ TEST(Breakpoint_I32Add) {
       Find(code, sizeof(code), kNumBreakpoints, kExprGetLocal, kExprGetLocal,
            kExprI32Add);
 
-  WasmRunner<int32_t> r(kExecuteInterpreted, MachineType::Uint32(),
-                        MachineType::Uint32());
+  WasmRunner<int32_t, uint32_t, uint32_t> r(kExecuteInterpreted);
 
   r.Build(code, code + arraysize(code));
 
@@ -220,8 +218,7 @@ TEST(Step_I32Mul) {
   static const int kTraceLength = 4;
   byte code[] = {WASM_I32_MUL(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))};
 
-  WasmRunner<int32_t> r(kExecuteInterpreted, MachineType::Uint32(),
-                        MachineType::Uint32());
+  WasmRunner<int32_t, uint32_t, uint32_t> r(kExecuteInterpreted);
 
   r.Build(code, code + arraysize(code));
 
@@ -259,8 +256,7 @@ TEST(Breakpoint_I32And_disable) {
   std::unique_ptr<int[]> offsets =
       Find(code, sizeof(code), kNumBreakpoints, kExprI32And);
 
-  WasmRunner<int32_t> r(kExecuteInterpreted, MachineType::Uint32(),
-                        MachineType::Uint32());
+  WasmRunner<int32_t, uint32_t, uint32_t> r(kExecuteInterpreted);
 
   r.Build(code, code + arraysize(code));
 
@@ -297,9 +293,8 @@ TEST(Breakpoint_I32And_disable) {
 }
 
 TEST(GrowMemory) {
-  TestingModule module(kExecuteInterpreted);
-  WasmRunner<int32_t> r(&module, MachineType::Uint32());
-  module.AddMemory(WasmModule::kPageSize);
+  WasmRunner<int32_t, uint32_t> r(kExecuteInterpreted);
+  r.module().AddMemory(WasmModule::kPageSize);
   BUILD(r, WASM_GROW_MEMORY(WASM_GET_LOCAL(0)));
   CHECK_EQ(1, r.Call(1));
 }
@@ -307,9 +302,8 @@ TEST(GrowMemory) {
 TEST(GrowMemoryPreservesData) {
   int32_t index = 16;
   int32_t value = 2335;
-  TestingModule module(kExecuteInterpreted);
-  WasmRunner<int32_t> r(&module, MachineType::Uint32());
-  module.AddMemory(WasmModule::kPageSize);
+  WasmRunner<int32_t, uint32_t> r(kExecuteInterpreted);
+  r.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,
@@ -320,16 +314,14 @@ TEST(GrowMemoryPreservesData) {
 TEST(GrowMemoryInvalidSize) {
   {
     // Grow memory by an invalid amount without initial memory.
-    TestingModule module(kExecuteInterpreted);
-    WasmRunner<int32_t> r(&module, MachineType::Uint32());
+    WasmRunner<int32_t, uint32_t> r(kExecuteInterpreted);
     BUILD(r, WASM_GROW_MEMORY(WASM_GET_LOCAL(0)));
     CHECK_EQ(-1, r.Call(1048575));
   }
   {
     // Grow memory by an invalid amount without initial memory.
-    TestingModule module(kExecuteInterpreted);
-    WasmRunner<int32_t> r(&module, MachineType::Uint32());
-    module.AddMemory(WasmModule::kPageSize);
+    WasmRunner<int32_t, uint32_t> r(kExecuteInterpreted);
+    r.module().AddMemory(WasmModule::kPageSize);
     BUILD(r, WASM_GROW_MEMORY(WASM_GET_LOCAL(0)));
     CHECK_EQ(-1, r.Call(1048575));
   }
@@ -338,9 +330,7 @@ TEST(GrowMemoryInvalidSize) {
 TEST(TestPossibleNondeterminism) {
   {
     // F32Div may produced NaN
-    TestingModule module(kExecuteInterpreted);
-    WasmRunner<float> r(&module, MachineType::Float32(),
-                        MachineType::Float32());
+    WasmRunner<float, float, float> r(kExecuteInterpreted);
     BUILD(r, WASM_F32_DIV(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
     r.Call(1048575.5f, 2.5f);
     CHECK(!r.possible_nondeterminism());
@@ -349,8 +339,7 @@ TEST(TestPossibleNondeterminism) {
   }
   {
     // F32Sqrt may produced NaN
-    TestingModule module(kExecuteInterpreted);
-    WasmRunner<float> r(&module, MachineType::Float32());
+    WasmRunner<float, float> r(kExecuteInterpreted);
     BUILD(r, WASM_F32_SQRT(WASM_GET_LOCAL(0)));
     r.Call(16.0f);
     CHECK(!r.possible_nondeterminism());
@@ -359,9 +348,7 @@ TEST(TestPossibleNondeterminism) {
   }
   {
     // F32Mul may produced NaN
-    TestingModule module(kExecuteInterpreted);
-    WasmRunner<float> r(&module, MachineType::Float32(),
-                        MachineType::Float32());
+    WasmRunner<float, float, float> r(kExecuteInterpreted);
     BUILD(r, WASM_F32_MUL(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
     r.Call(1048575.5f, 2.5f);
     CHECK(!r.possible_nondeterminism());
@@ -370,9 +357,7 @@ TEST(TestPossibleNondeterminism) {
   }
   {
     // F64Div may produced NaN
-    TestingModule module(kExecuteInterpreted);
-    WasmRunner<double> r(&module, MachineType::Float64(),
-                         MachineType::Float64());
+    WasmRunner<double, double, double> r(kExecuteInterpreted);
     BUILD(r, WASM_F64_DIV(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
     r.Call(1048575.5, 2.5);
     CHECK(!r.possible_nondeterminism());
@@ -381,8 +366,7 @@ TEST(TestPossibleNondeterminism) {
   }
   {
     // F64Sqrt may produced NaN
-    TestingModule module(kExecuteInterpreted);
-    WasmRunner<double> r(&module, MachineType::Float64());
+    WasmRunner<double, double> r(kExecuteInterpreted);
     BUILD(r, WASM_F64_SQRT(WASM_GET_LOCAL(0)));
     r.Call(1048575.5);
     CHECK(!r.possible_nondeterminism());
@@ -391,9 +375,7 @@ TEST(TestPossibleNondeterminism) {
   }
   {
     // F64Mul may produced NaN
-    TestingModule module(kExecuteInterpreted);
-    WasmRunner<double> r(&module, MachineType::Float64(),
-                         MachineType::Float64());
+    WasmRunner<double, double, double> r(kExecuteInterpreted);
     BUILD(r, WASM_F64_MUL(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
     r.Call(1048575.5, 2.5);
     CHECK(!r.possible_nondeterminism());

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

@@ -97,48 +97,36 @@ void EXPECT_CALL(double expected, Handle<JSFunction> jsfunc, double a,
 }  // 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());
+  WasmRunner<int, int, int> r(kExecuteCompiled);
+  BUILD(r, WASM_I32_SUB(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
+  Handle<JSFunction> jsfunc = r.module().WrapCode(r.function()->func_index);
 
   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());
+  WasmRunner<float, float, float> r(kExecuteCompiled);
+  BUILD(r, WASM_F32_DIV(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
+  Handle<JSFunction> jsfunc = r.module().WrapCode(r.function()->func_index);
 
   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());
+  WasmRunner<double, double, double> r(kExecuteCompiled);
+  BUILD(r, WASM_F64_ADD(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
+  Handle<JSFunction> jsfunc = r.module().WrapCode(r.function()->func_index);
 
   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());
+  WasmRunner<int, int> r(kExecuteCompiled);
+  BUILD(r, WASM_I32_POPCNT(WASM_GET_LOCAL(0)));
+  Handle<JSFunction> jsfunc = r.module().WrapCode(r.function()->func_index);
 
   EXPECT_CALL(2, jsfunc, 9, 0);
   EXPECT_CALL(3, jsfunc, 11, 0);
@@ -146,15 +134,13 @@ TEST(Run_I32Popcount_jswrapped) {
 }
 
 TEST(Run_CallJS_Add_jswrapped) {
-  CcTest::InitializeVM();
+  WasmRunner<int, int> r(kExecuteCompiled);
   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_FUNCTION(js_index, WASM_GET_LOCAL(0)));
+      r.module().AddJsFunction(sigs.i_i(), "(function(a) { return a + 99; })");
+  BUILD(r, WASM_CALL_FUNCTION(js_index, WASM_GET_LOCAL(0)));
 
-  Handle<JSFunction> jsfunc = module.WrapCode(t.CompileAndAdd());
+  Handle<JSFunction> jsfunc = r.module().WrapCode(r.function()->func_index);
 
   EXPECT_CALL(101, jsfunc, 2, -8);
   EXPECT_CALL(199, jsfunc, 100, -1);
@@ -171,9 +157,9 @@ void RunJSSelectTest(int which) {
     HandleScope scope(CcTest::InitIsolateOnce());
     FunctionSig sig(1, num_params, types);
 
-    TestingModule module;
-    uint32_t js_index = AddJSSelector(&module, &sig, which);
-    WasmFunctionCompiler t(&sig, &module);
+    WasmRunner<void> r(kExecuteCompiled);
+    uint32_t js_index = AddJSSelector(&r.module(), &sig, which);
+    WasmFunctionCompiler& t = r.NewFunction(&sig);
 
     {
       std::vector<byte> code;
@@ -189,7 +175,7 @@ void RunJSSelectTest(int which) {
       t.Build(&code[0], &code[end]);
     }
 
-    Handle<JSFunction> jsfunc = module.WrapCode(t.CompileAndAdd());
+    Handle<JSFunction> jsfunc = r.module().WrapCode(t.function_index());
     double expected = inputs.arg_d(which);
     EXPECT_CALL(expected, jsfunc, 0.0, 0.0);
   }
@@ -245,10 +231,10 @@ void RunWASMSelectTest(int which) {
                                        type, type, type, type};
     FunctionSig sig(1, num_params, types);
 
-    TestingModule module;
-    WasmFunctionCompiler t(&sig, &module);
+    WasmRunner<void> r(kExecuteCompiled);
+    WasmFunctionCompiler& t = r.NewFunction(&sig);
     BUILD(t, WASM_GET_LOCAL(which));
-    Handle<JSFunction> jsfunc = module.WrapCode(t.CompileAndAdd());
+    Handle<JSFunction> jsfunc = r.module().WrapCode(t.function_index());
 
     Handle<Object> args[] = {
         isolate->factory()->NewNumber(inputs.arg_d(0)),
@@ -317,10 +303,10 @@ void RunWASMSelectAlignTest(int num_args, int num_params) {
   FunctionSig sig(1, num_params, types);
 
   for (int which = 0; which < num_params; which++) {
-    TestingModule module;
-    WasmFunctionCompiler t(&sig, &module);
+    WasmRunner<void> r(kExecuteCompiled);
+    WasmFunctionCompiler& t = r.NewFunction(&sig);
     BUILD(t, WASM_GET_LOCAL(which));
-    Handle<JSFunction> jsfunc = module.WrapCode(t.CompileAndAdd());
+    Handle<JSFunction> jsfunc = r.module().WrapCode(t.function_index());
 
     Handle<Object> args[] = {isolate->factory()->NewNumber(inputs.arg_d(0)),
                              isolate->factory()->NewNumber(inputs.arg_d(1)),
@@ -411,6 +397,8 @@ void RunJSSelectAlignTest(int num_args, int num_params) {
   LocalType types[kMaxParams + 1] = {type, type, type, type, type, type,
                                      type, type, type, type, type};
   FunctionSig sig(1, num_params, types);
+  i::AccountingAllocator allocator;
+  Zone zone(&allocator, ZONE_NAME);
 
   // Build the calling code.
   std::vector<byte> code;
@@ -419,21 +407,21 @@ void RunJSSelectAlignTest(int num_args, int num_params) {
     ADD_CODE(code, WASM_GET_LOCAL(i));
   }
 
-  ADD_CODE(code, kExprCallFunction, 0);
+  uint8_t predicted_js_index = 1;
+  ADD_CODE(code, kExprCallFunction, predicted_js_index);
 
   size_t end = code.size();
   code.push_back(0);
 
   // Call different select JS functions.
   for (int which = 0; which < num_params; which++) {
-    HandleScope scope(isolate);
-    TestingModule module;
-    uint32_t js_index = AddJSSelector(&module, &sig, which);
-    CHECK_EQ(0u, js_index);
-    WasmFunctionCompiler t(&sig, &module);
+    WasmRunner<void> r(kExecuteCompiled);
+    uint32_t js_index = AddJSSelector(&r.module(), &sig, which);
+    CHECK_EQ(predicted_js_index, js_index);
+    WasmFunctionCompiler& t = r.NewFunction(&sig);
     t.Build(&code[0], &code[end]);
 
-    Handle<JSFunction> jsfunc = module.WrapCode(t.CompileAndAdd());
+    Handle<JSFunction> jsfunc = r.module().WrapCode(t.function_index());
 
     Handle<Object> args[] = {
         factory->NewNumber(inputs.arg_d(0)),

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

@@ -13,31 +13,29 @@
 using namespace v8::internal;
 using namespace v8::internal::compiler;
 
-#define FOREACH_TYPE(TEST_BODY)         \
-  TEST_BODY(int32_t, I32, WASM_I32_ADD) \
-  TEST_BODY(int64_t, I64, WASM_I64_ADD) \
-  TEST_BODY(float, F32, WASM_F32_ADD)   \
-  TEST_BODY(double, F64, WASM_F64_ADD)
+#define FOREACH_TYPE(TEST_BODY)    \
+  TEST_BODY(int32_t, WASM_I32_ADD) \
+  TEST_BODY(int64_t, WASM_I64_ADD) \
+  TEST_BODY(float, WASM_F32_ADD)   \
+  TEST_BODY(double, WASM_F64_ADD)
 
-#define LOAD_SET_GLOBAL_TEST_BODY(C_TYPE, MACHINE_TYPE, ADD)                 \
-  TEST(WasmRelocateGlobal##MACHINE_TYPE) {                                   \
-    TestingModule module(kExecuteCompiled);                                  \
-    module.AddGlobal<C_TYPE>(kAst##MACHINE_TYPE);                            \
-    module.AddGlobal<C_TYPE>(kAst##MACHINE_TYPE);                            \
+#define LOAD_SET_GLOBAL_TEST_BODY(C_TYPE, ADD)                               \
+  TEST(WasmRelocateGlobal_##C_TYPE) {                                        \
+    WasmRunner<C_TYPE, C_TYPE> r(kExecuteCompiled);                          \
                                                                              \
-    WasmRunner<C_TYPE> r(&module,                                            \
-                         WasmOpcodes::MachineTypeFor(kAst##MACHINE_TYPE));   \
+    r.module().AddGlobal<C_TYPE>();                                          \
+    r.module().AddGlobal<C_TYPE>();                                          \
                                                                              \
     /* global = global + p0 */                                               \
     BUILD(r, WASM_SET_GLOBAL(1, ADD(WASM_GET_GLOBAL(0), WASM_GET_LOCAL(0))), \
           WASM_GET_GLOBAL(0));                                               \
-    CHECK_EQ(1u, module.instance->function_code.size());                     \
+    CHECK_EQ(1, r.module().instance->function_code.size());                  \
                                                                              \
     int filter = 1 << RelocInfo::WASM_GLOBAL_REFERENCE;                      \
                                                                              \
-    Handle<Code> code = module.instance->function_code[0];                   \
+    Handle<Code> code = r.module().instance->function_code[0];               \
                                                                              \
-    Address old_start = module.instance->globals_start;                      \
+    Address old_start = r.module().instance->globals_start;                  \
     Address new_start = old_start + 1;                                       \
                                                                              \
     Address old_addresses[4];                                                \

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

@@ -45,7 +45,7 @@ WASM_EXEC_TEST(I32x4Splat) {
   //   return 0
   //
   // return 1
-  WasmRunner<int32_t> r(kExecuteCompiled, MachineType::Int32());
+  WasmRunner<int32_t, int32_t> r(kExecuteCompiled);
   byte lane_val = 0;
   byte simd = r.AllocateLocal(kAstS128);
   BUILD(r, WASM_BLOCK(WASM_SET_LOCAL(simd, WASM_SIMD_I32x4_SPLAT(
@@ -58,8 +58,7 @@ WASM_EXEC_TEST(I32x4Splat) {
 
 WASM_EXEC_TEST(I32x4ReplaceLane) {
   FLAG_wasm_simd_prototype = true;
-  WasmRunner<int32_t> r(kExecuteCompiled, MachineType::Int32(),
-                        MachineType::Int32());
+  WasmRunner<int32_t, int32_t, int32_t> r(kExecuteCompiled);
   byte old_val = 0;
   byte new_val = 1;
   byte simd = r.AllocateLocal(kAstS128);
@@ -92,8 +91,7 @@ WASM_EXEC_TEST(I32x4ReplaceLane) {
 
 WASM_EXEC_TEST(I32x4Add) {
   FLAG_wasm_simd_prototype = true;
-  WasmRunner<int32_t> r(kExecuteCompiled, MachineType::Int32(),
-                        MachineType::Int32(), MachineType::Int32());
+  WasmRunner<int32_t, int32_t, int32_t, int32_t> r(kExecuteCompiled);
   byte a = 0;
   byte b = 1;
   byte expected = 2;
@@ -115,8 +113,7 @@ WASM_EXEC_TEST(I32x4Add) {
 
 WASM_EXEC_TEST(I32x4Sub) {
   FLAG_wasm_simd_prototype = true;
-  WasmRunner<int32_t> r(kExecuteCompiled, MachineType::Int32(),
-                        MachineType::Int32(), MachineType::Int32());
+  WasmRunner<int32_t, int32_t, int32_t, int32_t> r(kExecuteCompiled);
   byte a = 0;
   byte b = 1;
   byte expected = 2;

test/cctest/wasm/test-wasm-stack.cc

@@ -76,25 +76,22 @@ void CheckExceptionInfos(Handle<Object> exc,
 
 // Call from JS to WASM to JS and throw an Error from JS.
 TEST(CollectDetailedWasmStack_ExplicitThrowFromJs) {
+  WasmRunner<void> r(kExecuteCompiled);
   TestSignatures sigs;
-  TestingModule module;
 
-  // Initialize WasmFunctionCompiler first, since it sets up the HandleScope.
-  WasmFunctionCompiler comp1(sigs.v_v(), &module);
-
-  uint32_t js_throwing_index = module.AddJsFunction(
+  uint32_t js_throwing_index = r.module().AddJsFunction(
       sigs.v_v(),
       "(function js() {\n function a() {\n throw new Error(); };\n a(); })");
 
   // Add a nop such that we don't always get position 1.
-  BUILD(comp1, WASM_NOP, WASM_CALL_FUNCTION0(js_throwing_index));
-  uint32_t wasm_index = comp1.CompileAndAdd();
+  BUILD(r, WASM_NOP, WASM_CALL_FUNCTION0(js_throwing_index));
+  uint32_t wasm_index_1 = r.function()->func_index;
 
-  WasmFunctionCompiler comp2(sigs.v_v(), &module);
-  BUILD(comp2, WASM_CALL_FUNCTION0(wasm_index));
-  uint32_t wasm_index_2 = comp2.CompileAndAdd();
+  WasmFunctionCompiler& f2 = r.NewFunction<void>();
+  BUILD(f2, WASM_CALL_FUNCTION0(wasm_index_1));
+  uint32_t wasm_index_2 = f2.function_index();
 
-  Handle<JSFunction> js_wasm_wrapper = module.WrapCode(wasm_index_2);
+  Handle<JSFunction> js_wasm_wrapper = r.module().WrapCode(wasm_index_2);
 
   Handle<JSFunction> js_trampoline = Handle<JSFunction>::cast(
       v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
@@ -114,7 +111,7 @@ TEST(CollectDetailedWasmStack_ExplicitThrowFromJs) {
   ExceptionInfo expected_exceptions[] = {
       {"a", 3, 8},                                                // -
       {"js", 4, 2},                                               // -
-      {"<WASM UNNAMED>", static_cast<int>(wasm_index) + 1, 3},    // -
+      {"<WASM UNNAMED>", static_cast<int>(wasm_index_1) + 1, 3},  // -
       {"<WASM UNNAMED>", static_cast<int>(wasm_index_2) + 1, 2},  // -
       {"callFn", 1, 24}                                           // -
   };
@@ -124,21 +121,18 @@ TEST(CollectDetailedWasmStack_ExplicitThrowFromJs) {
 // Trigger a trap in WASM, stack should be JS -> WASM -> WASM.
 TEST(CollectDetailedWasmStack_WasmError) {
   TestSignatures sigs;
-  TestingModule module;
-
-  WasmFunctionCompiler comp1(sigs.i_v(), &module,
-                             ArrayVector("exec_unreachable"));
+  WasmRunner<int> r(kExecuteCompiled);
   // Set the execution context, such that a runtime error can be thrown.
-  comp1.SetModuleContext();
-  BUILD(comp1, WASM_UNREACHABLE);
-  uint32_t wasm_index = comp1.CompileAndAdd();
+  r.SetModuleContext();
+
+  BUILD(r, WASM_UNREACHABLE);
+  uint32_t wasm_index_1 = r.function()->func_index;
 
-  WasmFunctionCompiler comp2(sigs.i_v(), &module,
-                             ArrayVector("call_exec_unreachable"));
-  BUILD(comp2, WASM_CALL_FUNCTION0(wasm_index));
-  uint32_t wasm_index_2 = comp2.CompileAndAdd();
+  WasmFunctionCompiler& f2 = r.NewFunction<int>();
+  BUILD(f2, WASM_CALL_FUNCTION0(0));
+  uint32_t wasm_index_2 = f2.function_index();
 
-  Handle<JSFunction> js_wasm_wrapper = module.WrapCode(wasm_index_2);
+  Handle<JSFunction> js_wasm_wrapper = r.module().WrapCode(wasm_index_2);
 
   Handle<JSFunction> js_trampoline = Handle<JSFunction>::cast(
       v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
@@ -156,7 +150,7 @@ TEST(CollectDetailedWasmStack_WasmError) {
 
   // Line and column are 1-based, so add 1 for the expected wasm output.
   ExceptionInfo expected_exceptions[] = {
-      {"<WASM UNNAMED>", static_cast<int>(wasm_index) + 1, 2},    // -
+      {"<WASM UNNAMED>", static_cast<int>(wasm_index_1) + 1, 2},  // -
       {"<WASM UNNAMED>", static_cast<int>(wasm_index_2) + 1, 2},  // -
       {"callFn", 1, 24}                                           //-
   };

test/cctest/wasm/test-wasm-trap-position.cc

@@ -62,17 +62,15 @@ void CheckExceptionInfos(Handle<Object> exc,
 
 // Trigger a trap for executing unreachable.
 TEST(Unreachable) {
+  WasmRunner<void> r(kExecuteCompiled);
   TestSignatures sigs;
-  TestingModule module;
-
-  WasmFunctionCompiler comp1(sigs.v_v(), &module,
-                             ArrayVector("exec_unreachable"));
   // Set the execution context, such that a runtime error can be thrown.
-  comp1.SetModuleContext();
-  BUILD(comp1, WASM_UNREACHABLE);
-  uint32_t wasm_index = comp1.CompileAndAdd();
+  r.SetModuleContext();
+
+  BUILD(r, WASM_UNREACHABLE);
+  uint32_t wasm_index = r.function()->func_index;
 
-  Handle<JSFunction> js_wasm_wrapper = module.WrapCode(wasm_index);
+  Handle<JSFunction> js_wasm_wrapper = r.module().WrapCode(wasm_index);
 
   Handle<JSFunction> js_trampoline = Handle<JSFunction>::cast(
       v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
@@ -98,23 +96,22 @@ TEST(Unreachable) {
 
 // Trigger a trap for loading from out-of-bounds.
 TEST(IllegalLoad) {
+  WasmRunner<void> r(kExecuteCompiled);
   TestSignatures sigs;
-  TestingModule module;
-
-  WasmFunctionCompiler comp1(sigs.v_v(), &module, ArrayVector("mem_oob"));
   // Set the execution context, such that a runtime error can be thrown.
-  comp1.SetModuleContext();
-  BUILD(comp1, WASM_IF(WASM_ONE, WASM_SEQ(WASM_LOAD_MEM(MachineType::Int32(),
-                                                        WASM_I32V_1(-3)),
-                                          WASM_DROP)));
-  uint32_t wasm_index = comp1.CompileAndAdd();
+  r.SetModuleContext();
+
+  BUILD(r, WASM_IF(WASM_ONE, WASM_SEQ(WASM_LOAD_MEM(MachineType::Int32(),
+                                                    WASM_I32V_1(-3)),
+                                      WASM_DROP)));
+  uint32_t wasm_index_1 = r.function()->func_index;
 
-  WasmFunctionCompiler comp2(sigs.v_v(), &module, ArrayVector("call_mem_oob"));
+  WasmFunctionCompiler& f2 = r.NewFunction<void>();
   // Insert a NOP such that the position of the call is not one.
-  BUILD(comp2, WASM_NOP, WASM_CALL_FUNCTION0(wasm_index));
-  uint32_t wasm_index_2 = comp2.CompileAndAdd();
+  BUILD(f2, WASM_NOP, WASM_CALL_FUNCTION0(wasm_index_1));
+  uint32_t wasm_index_2 = f2.function_index();
 
-  Handle<JSFunction> js_wasm_wrapper = module.WrapCode(wasm_index_2);
+  Handle<JSFunction> js_wasm_wrapper = r.module().WrapCode(wasm_index_2);
 
   Handle<JSFunction> js_trampoline = Handle<JSFunction>::cast(
       v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
@@ -132,7 +129,7 @@ TEST(IllegalLoad) {
 
   // Line and column are 1-based, so add 1 for the expected wasm output.
   ExceptionInfo expected_exceptions[] = {
-      {"<WASM UNNAMED>", static_cast<int>(wasm_index) + 1, 8},    // --
+      {"<WASM UNNAMED>", static_cast<int>(wasm_index_1) + 1, 8},  // --
       {"<WASM UNNAMED>", static_cast<int>(wasm_index_2) + 1, 3},  // --
       {"callFn", 1, 24}                                           // --
   };