diff options
Diffstat (limited to 'deps/v8/test/cctest/wasm')
17 files changed, 990 insertions, 569 deletions
diff --git a/deps/v8/test/cctest/wasm/test-c-wasm-entry.cc b/deps/v8/test/cctest/wasm/test-c-wasm-entry.cc index 6c246bc48c..fc711aa7a7 100644 --- a/deps/v8/test/cctest/wasm/test-c-wasm-entry.cc +++ b/deps/v8/test/cctest/wasm/test-c-wasm-entry.cc @@ -109,7 +109,7 @@ TEST(TestCWasmEntryArgPassing_int32) { return base::AddWithWraparound(base::MulWithWraparound(2, a), 1); }); - FOR_INT32_INPUTS(v) { tester.CheckCall(*v); } + FOR_INT32_INPUTS(v) { tester.CheckCall(v); } } // Pass int64_t, return double. @@ -119,7 +119,7 @@ TEST(TestCWasmEntryArgPassing_double_int64) { WASM_F64_SCONVERT_I64(WASM_GET_LOCAL(0))}, [](int64_t a) { return static_cast<double>(a); }); - FOR_INT64_INPUTS(v) { tester.CheckCall(*v); } + FOR_INT64_INPUTS(v) { tester.CheckCall(v); } } // Pass double, return int64_t. @@ -129,7 +129,7 @@ TEST(TestCWasmEntryArgPassing_int64_double) { WASM_I64_SCONVERT_F64(WASM_GET_LOCAL(0))}, [](double d) { return static_cast<int64_t>(d); }); - FOR_INT64_INPUTS(i) { tester.CheckCall(*i); } + FOR_INT64_INPUTS(i) { tester.CheckCall(i); } } // Pass float, return double. @@ -141,7 +141,7 @@ TEST(TestCWasmEntryArgPassing_float_double) { WASM_F64(1))}, [](float f) { return 2. * static_cast<double>(f) + 1.; }); - FOR_FLOAT32_INPUTS(f) { tester.CheckCall(*f); } + FOR_FLOAT32_INPUTS(f) { tester.CheckCall(f); } } // Pass two doubles, return double. @@ -152,7 +152,7 @@ TEST(TestCWasmEntryArgPassing_double_double) { [](double a, double b) { return a + b; }); FOR_FLOAT64_INPUTS(d1) { - FOR_FLOAT64_INPUTS(d2) { tester.CheckCall(*d1, *d2); } + FOR_FLOAT64_INPUTS(d2) { tester.CheckCall(d1, d2); } } } diff --git a/deps/v8/test/cctest/wasm/test-jump-table-assembler.cc b/deps/v8/test/cctest/wasm/test-jump-table-assembler.cc index d8d9e0412e..1472196504 100644 --- a/deps/v8/test/cctest/wasm/test-jump-table-assembler.cc +++ b/deps/v8/test/cctest/wasm/test-jump-table-assembler.cc @@ -24,10 +24,6 @@ namespace wasm { #define __ masm. -// TODO(v8:7424,v8:8018): Extend this test to all architectures. -#if V8_TARGET_ARCH_X64 || V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_ARM || \ - V8_TARGET_ARCH_ARM64 - namespace { static volatile int global_stop_bit = 0; @@ -109,6 +105,30 @@ Address GenerateJumpTableThunk( __ Tbnz(scratch, 0, &exit); __ Mov(scratch, Immediate(jump_target, RelocInfo::NONE)); __ Br(scratch); +#elif V8_TARGET_ARCH_PPC64 + __ mov(scratch, Operand(stop_bit_address, RelocInfo::NONE)); + __ LoadP(scratch, MemOperand(scratch)); + __ cmpi(scratch, Operand::Zero()); + __ bne(&exit); + __ mov(scratch, Operand(jump_target, RelocInfo::NONE)); + __ Jump(scratch); +#elif V8_TARGET_ARCH_S390X + __ mov(scratch, Operand(stop_bit_address, RelocInfo::NONE)); + __ LoadP(scratch, MemOperand(scratch)); + __ CmpP(scratch, Operand(0)); + __ bne(&exit); + __ mov(scratch, Operand(jump_target, RelocInfo::NONE)); + __ Jump(scratch); +#elif V8_TARGET_ARCH_MIPS64 + __ li(scratch, Operand(stop_bit_address, RelocInfo::NONE)); + __ Lw(scratch, MemOperand(scratch, 0)); + __ Branch(&exit, ne, scratch, Operand(zero_reg)); + __ Jump(jump_target, RelocInfo::NONE); +#elif V8_TARGET_ARCH_MIPS + __ li(scratch, Operand(stop_bit_address, RelocInfo::NONE)); + __ lw(scratch, MemOperand(scratch, 0)); + __ Branch(&exit, ne, scratch, Operand(zero_reg)); + __ Jump(jump_target, RelocInfo::NONE); #else #error Unsupported architecture #endif @@ -236,9 +256,6 @@ TEST(JumpTablePatchingStress) { } } -#endif // V8_TARGET_ARCH_X64 || V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_ARM || - // V8_TARGET_ARCH_ARM64 - #undef __ #undef TRACE diff --git a/deps/v8/test/cctest/wasm/test-run-wasm-64.cc b/deps/v8/test/cctest/wasm/test-run-wasm-64.cc index cca0c1b061..dfce94b20c 100644 --- a/deps/v8/test/cctest/wasm/test-run-wasm-64.cc +++ b/deps/v8/test/cctest/wasm/test-run-wasm-64.cc @@ -32,9 +32,9 @@ WASM_EXEC_TEST(I64Const) { WASM_EXEC_TEST(I64Const_many) { int cntr = 0; - FOR_INT32_INPUTS(i) { + FOR_UINT32_INPUTS(i) { WasmRunner<int64_t> r(execution_tier); - const int64_t kExpectedValue = (static_cast<int64_t>(*i) << 32) | cntr; + const int64_t kExpectedValue = (static_cast<uint64_t>(i) << 32) | cntr; // return(kExpectedValue) BUILD(r, WASM_I64V(kExpectedValue)); CHECK_EQ(kExpectedValue, r.Call()); @@ -47,7 +47,7 @@ WASM_EXEC_TEST(Return_I64) { BUILD(r, WASM_RETURN1(WASM_GET_LOCAL(0))); - FOR_INT64_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); } + FOR_INT64_INPUTS(i) { CHECK_EQ(i, r.Call(i)); } } WASM_EXEC_TEST(I64Add) { @@ -55,7 +55,7 @@ WASM_EXEC_TEST(I64Add) { BUILD(r, WASM_I64_ADD(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); FOR_INT64_INPUTS(i) { FOR_INT64_INPUTS(j) { - CHECK_EQ(base::AddWithWraparound(*i, *j), r.Call(*i, *j)); + CHECK_EQ(base::AddWithWraparound(i, j), r.Call(i, j)); } } } @@ -79,7 +79,7 @@ WASM_EXEC_TEST(I64Sub) { BUILD(r, WASM_I64_SUB(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); FOR_INT64_INPUTS(i) { FOR_INT64_INPUTS(j) { - CHECK_EQ(base::SubWithWraparound(*i, *j), r.Call(*i, *j)); + CHECK_EQ(base::SubWithWraparound(i, j), r.Call(i, j)); } } } @@ -99,8 +99,8 @@ WASM_EXEC_TEST(I64AddUseOnlyLowWord) { 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>(base::AddWithWraparound(*i, *j)), - r.Call(*i, *j)); + CHECK_EQ(static_cast<int32_t>(base::AddWithWraparound(i, j)), + r.Call(i, j)); } } } @@ -111,8 +111,8 @@ WASM_EXEC_TEST(I64SubUseOnlyLowWord) { 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>(base::SubWithWraparound(*i, *j)), - r.Call(*i, *j)); + CHECK_EQ(static_cast<int32_t>(base::SubWithWraparound(i, j)), + r.Call(i, j)); } } } @@ -123,8 +123,8 @@ WASM_EXEC_TEST(I64MulUseOnlyLowWord) { 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>(base::MulWithWraparound(*i, *j)), - r.Call(*i, *j)); + CHECK_EQ(static_cast<int32_t>(base::MulWithWraparound(i, j)), + r.Call(i, j)); } } } @@ -135,8 +135,8 @@ WASM_EXEC_TEST(I64ShlUseOnlyLowWord) { 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>(base::ShlWithWraparound(*i, *j)); - CHECK_EQ(expected, r.Call(*i, *j)); + int32_t expected = static_cast<int32_t>(base::ShlWithWraparound(i, j)); + CHECK_EQ(expected, r.Call(i, j)); } } } @@ -147,8 +147,8 @@ WASM_EXEC_TEST(I64ShrUseOnlyLowWord) { 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)); + int32_t expected = static_cast<int32_t>((i) >> (j & 0x3F)); + CHECK_EQ(expected, r.Call(i, j)); } } } @@ -159,8 +159,8 @@ WASM_EXEC_TEST(I64SarUseOnlyLowWord) { 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)); + int32_t expected = static_cast<int32_t>((i) >> (j & 0x3F)); + CHECK_EQ(expected, r.Call(i, j)); } } } @@ -170,12 +170,12 @@ WASM_EXEC_TEST(I64DivS) { 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)); + 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)); + CHECK_EQ(i / j, r.Call(i, j)); } } } @@ -210,10 +210,10 @@ WASM_EXEC_TEST(I64DivU) { 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)); + if (j == 0) { + CHECK_TRAP64(r.Call(i, j)); } else { - CHECK_EQ(*i / *j, r.Call(*i, *j)); + CHECK_EQ(i / j, r.Call(i, j)); } } } @@ -248,10 +248,10 @@ WASM_EXEC_TEST(I64RemS) { 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)); + if (j == 0) { + CHECK_TRAP64(r.Call(i, j)); } else { - CHECK_EQ(*i % *j, r.Call(*i, *j)); + CHECK_EQ(i % j, r.Call(i, j)); } } } @@ -272,10 +272,10 @@ WASM_EXEC_TEST(I64RemU) { 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)); + if (j == 0) { + CHECK_TRAP64(r.Call(i, j)); } else { - CHECK_EQ(*i % *j, r.Call(*i, *j)); + CHECK_EQ(i % j, r.Call(i, j)); } } } @@ -294,7 +294,7 @@ WASM_EXEC_TEST(I64And) { WasmRunner<int64_t, int64_t, int64_t> r(execution_tier); 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)); } + FOR_INT64_INPUTS(j) { CHECK_EQ((i) & (j), r.Call(i, j)); } } } @@ -302,7 +302,7 @@ WASM_EXEC_TEST(I64Ior) { WasmRunner<int64_t, int64_t, int64_t> r(execution_tier); 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)); } + FOR_INT64_INPUTS(j) { CHECK_EQ((i) | (j), r.Call(i, j)); } } } @@ -310,7 +310,7 @@ WASM_EXEC_TEST(I64Xor) { WasmRunner<int64_t, int64_t, int64_t> r(execution_tier); 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)); } + FOR_INT64_INPUTS(j) { CHECK_EQ((i) ^ (j), r.Call(i, j)); } } } @@ -321,30 +321,30 @@ WASM_EXEC_TEST(I64Shl) { FOR_UINT64_INPUTS(i) { FOR_UINT64_INPUTS(j) { - uint64_t expected = (*i) << (*j & 0x3F); - CHECK_EQ(expected, r.Call(*i, *j)); + uint64_t expected = (i) << (j & 0x3F); + CHECK_EQ(expected, r.Call(i, j)); } } } { WasmRunner<uint64_t, int64_t> r(execution_tier); BUILD(r, WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_I64V_1(0))); - FOR_UINT64_INPUTS(i) { CHECK_EQ(*i << 0, r.Call(*i)); } + FOR_UINT64_INPUTS(i) { CHECK_EQ(i << 0, r.Call(i)); } } { WasmRunner<uint64_t, int64_t> r(execution_tier); BUILD(r, WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_I64V_1(32))); - FOR_UINT64_INPUTS(i) { CHECK_EQ(*i << 32, r.Call(*i)); } + FOR_UINT64_INPUTS(i) { CHECK_EQ(i << 32, r.Call(i)); } } { WasmRunner<uint64_t, int64_t> r(execution_tier); BUILD(r, WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_I64V_1(20))); - FOR_UINT64_INPUTS(i) { CHECK_EQ(*i << 20, r.Call(*i)); } + FOR_UINT64_INPUTS(i) { CHECK_EQ(i << 20, r.Call(i)); } } { WasmRunner<uint64_t, int64_t> r(execution_tier); BUILD(r, WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_I64V_1(40))); - FOR_UINT64_INPUTS(i) { CHECK_EQ(*i << 40, r.Call(*i)); } + FOR_UINT64_INPUTS(i) { CHECK_EQ(i << 40, r.Call(i)); } } } @@ -355,30 +355,30 @@ WASM_EXEC_TEST(I64ShrU) { FOR_UINT64_INPUTS(i) { FOR_UINT64_INPUTS(j) { - uint64_t expected = (*i) >> (*j & 0x3F); - CHECK_EQ(expected, r.Call(*i, *j)); + uint64_t expected = (i) >> (j & 0x3F); + CHECK_EQ(expected, r.Call(i, j)); } } } { WasmRunner<uint64_t, int64_t> r(execution_tier); BUILD(r, WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_I64V_1(0))); - FOR_UINT64_INPUTS(i) { CHECK_EQ(*i >> 0, r.Call(*i)); } + FOR_UINT64_INPUTS(i) { CHECK_EQ(i >> 0, r.Call(i)); } } { WasmRunner<uint64_t, int64_t> r(execution_tier); BUILD(r, WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_I64V_1(32))); - FOR_UINT64_INPUTS(i) { CHECK_EQ(*i >> 32, r.Call(*i)); } + FOR_UINT64_INPUTS(i) { CHECK_EQ(i >> 32, r.Call(i)); } } { WasmRunner<uint64_t, int64_t> r(execution_tier); BUILD(r, WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_I64V_1(20))); - FOR_UINT64_INPUTS(i) { CHECK_EQ(*i >> 20, r.Call(*i)); } + FOR_UINT64_INPUTS(i) { CHECK_EQ(i >> 20, r.Call(i)); } } { WasmRunner<uint64_t, int64_t> r(execution_tier); BUILD(r, WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_I64V_1(40))); - FOR_UINT64_INPUTS(i) { CHECK_EQ(*i >> 40, r.Call(*i)); } + FOR_UINT64_INPUTS(i) { CHECK_EQ(i >> 40, r.Call(i)); } } } @@ -389,30 +389,30 @@ WASM_EXEC_TEST(I64ShrS) { FOR_INT64_INPUTS(i) { FOR_INT64_INPUTS(j) { - int64_t expected = (*i) >> (*j & 0x3F); - CHECK_EQ(expected, r.Call(*i, *j)); + int64_t expected = (i) >> (j & 0x3F); + CHECK_EQ(expected, r.Call(i, j)); } } } { WasmRunner<int64_t, int64_t> r(execution_tier); BUILD(r, WASM_I64_SAR(WASM_GET_LOCAL(0), WASM_I64V_1(0))); - FOR_INT64_INPUTS(i) { CHECK_EQ(*i >> 0, r.Call(*i)); } + FOR_INT64_INPUTS(i) { CHECK_EQ(i >> 0, r.Call(i)); } } { WasmRunner<int64_t, int64_t> r(execution_tier); BUILD(r, WASM_I64_SAR(WASM_GET_LOCAL(0), WASM_I64V_1(32))); - FOR_INT64_INPUTS(i) { CHECK_EQ(*i >> 32, r.Call(*i)); } + FOR_INT64_INPUTS(i) { CHECK_EQ(i >> 32, r.Call(i)); } } { WasmRunner<int64_t, int64_t> r(execution_tier); BUILD(r, WASM_I64_SAR(WASM_GET_LOCAL(0), WASM_I64V_1(20))); - FOR_INT64_INPUTS(i) { CHECK_EQ(*i >> 20, r.Call(*i)); } + FOR_INT64_INPUTS(i) { CHECK_EQ(i >> 20, r.Call(i)); } } { WasmRunner<int64_t, int64_t> r(execution_tier); BUILD(r, WASM_I64_SAR(WASM_GET_LOCAL(0), WASM_I64V_1(40))); - FOR_INT64_INPUTS(i) { CHECK_EQ(*i >> 40, r.Call(*i)); } + FOR_INT64_INPUTS(i) { CHECK_EQ(i >> 40, r.Call(i)); } } } @@ -420,7 +420,7 @@ WASM_EXEC_TEST(I64Eq) { WasmRunner<int32_t, int64_t, int64_t> r(execution_tier); 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)); } + FOR_INT64_INPUTS(j) { CHECK_EQ(i == j ? 1 : 0, r.Call(i, j)); } } } @@ -428,7 +428,7 @@ WASM_EXEC_TEST(I64Ne) { WasmRunner<int32_t, int64_t, int64_t> r(execution_tier); 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)); } + FOR_INT64_INPUTS(j) { CHECK_EQ(i != j ? 1 : 0, r.Call(i, j)); } } } @@ -436,7 +436,7 @@ WASM_EXEC_TEST(I64LtS) { WasmRunner<int32_t, int64_t, int64_t> r(execution_tier); 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)); } + FOR_INT64_INPUTS(j) { CHECK_EQ(i < j ? 1 : 0, r.Call(i, j)); } } } @@ -444,7 +444,7 @@ WASM_EXEC_TEST(I64LeS) { WasmRunner<int32_t, int64_t, int64_t> r(execution_tier); 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)); } + FOR_INT64_INPUTS(j) { CHECK_EQ(i <= j ? 1 : 0, r.Call(i, j)); } } } @@ -452,7 +452,7 @@ WASM_EXEC_TEST(I64LtU) { WasmRunner<int32_t, int64_t, int64_t> r(execution_tier); 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)); } + FOR_UINT64_INPUTS(j) { CHECK_EQ(i < j ? 1 : 0, r.Call(i, j)); } } } @@ -460,7 +460,7 @@ WASM_EXEC_TEST(I64LeU) { WasmRunner<int32_t, int64_t, int64_t> r(execution_tier); 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)); } + FOR_UINT64_INPUTS(j) { CHECK_EQ(i <= j ? 1 : 0, r.Call(i, j)); } } } @@ -468,7 +468,7 @@ WASM_EXEC_TEST(I64GtS) { WasmRunner<int32_t, int64_t, int64_t> r(execution_tier); 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)); } + FOR_INT64_INPUTS(j) { CHECK_EQ(i > j ? 1 : 0, r.Call(i, j)); } } } @@ -476,7 +476,7 @@ WASM_EXEC_TEST(I64GeS) { WasmRunner<int32_t, int64_t, int64_t> r(execution_tier); 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)); } + FOR_INT64_INPUTS(j) { CHECK_EQ(i >= j ? 1 : 0, r.Call(i, j)); } } } @@ -484,7 +484,7 @@ WASM_EXEC_TEST(I64GtU) { WasmRunner<int32_t, int64_t, int64_t> r(execution_tier); 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)); } + FOR_UINT64_INPUTS(j) { CHECK_EQ(i > j ? 1 : 0, r.Call(i, j)); } } } @@ -492,28 +492,28 @@ WASM_EXEC_TEST(I64GeU) { WasmRunner<int32_t, int64_t, int64_t> r(execution_tier); 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)); } + FOR_UINT64_INPUTS(j) { CHECK_EQ(i >= j ? 1 : 0, r.Call(i, j)); } } } WASM_EXEC_TEST(I32ConvertI64) { FOR_INT64_INPUTS(i) { WasmRunner<int32_t> r(execution_tier); - BUILD(r, WASM_I32_CONVERT_I64(WASM_I64V(*i))); - CHECK_EQ(static_cast<int32_t>(*i), r.Call()); + BUILD(r, WASM_I32_CONVERT_I64(WASM_I64V(i))); + CHECK_EQ(static_cast<int32_t>(i), r.Call()); } } WASM_EXEC_TEST(I64SConvertI32) { WasmRunner<int64_t, int32_t> r(execution_tier); BUILD(r, WASM_I64_SCONVERT_I32(WASM_GET_LOCAL(0))); - FOR_INT32_INPUTS(i) { CHECK_EQ(static_cast<int64_t>(*i), r.Call(*i)); } + FOR_INT32_INPUTS(i) { CHECK_EQ(static_cast<int64_t>(i), r.Call(i)); } } WASM_EXEC_TEST(I64UConvertI32) { WasmRunner<int64_t, uint32_t> r(execution_tier); BUILD(r, WASM_I64_UCONVERT_I32(WASM_GET_LOCAL(0))); - FOR_UINT32_INPUTS(i) { CHECK_EQ(static_cast<int64_t>(*i), r.Call(*i)); } + FOR_UINT32_INPUTS(i) { CHECK_EQ(static_cast<int64_t>(i), r.Call(i)); } } WASM_EXEC_TEST(I64Popcnt) { @@ -536,7 +536,7 @@ WASM_EXEC_TEST(I64Popcnt) { WASM_EXEC_TEST(F32SConvertI64) { WasmRunner<float, int64_t> r(execution_tier); BUILD(r, WASM_F32_SCONVERT_I64(WASM_GET_LOCAL(0))); - FOR_INT64_INPUTS(i) { CHECK_FLOAT_EQ(static_cast<float>(*i), r.Call(*i)); } + FOR_INT64_INPUTS(i) { CHECK_FLOAT_EQ(static_cast<float>(i), r.Call(i)); } } WASM_EXEC_TEST(F32UConvertI64) { @@ -629,7 +629,7 @@ WASM_EXEC_TEST(F32UConvertI64) { WASM_EXEC_TEST(F64SConvertI64) { WasmRunner<double, int64_t> r(execution_tier); BUILD(r, WASM_F64_SCONVERT_I64(WASM_GET_LOCAL(0))); - FOR_INT64_INPUTS(i) { CHECK_DOUBLE_EQ(static_cast<double>(*i), r.Call(*i)); } + FOR_INT64_INPUTS(i) { CHECK_DOUBLE_EQ(static_cast<double>(i), r.Call(i)); } } WASM_EXEC_TEST(F64UConvertI64) { @@ -723,11 +723,11 @@ WASM_EXEC_TEST(I64SConvertF32) { 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)); + 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)); + CHECK_TRAP64(r.Call(i)); } } } @@ -738,17 +738,17 @@ WASM_EXEC_TEST(I64SConvertSatF32) { BUILD(r, WASM_I64_SCONVERT_SAT_F32(WASM_GET_LOCAL(0))); FOR_FLOAT32_INPUTS(i) { int64_t expected; - if (*i < static_cast<float>(std::numeric_limits<int64_t>::max()) && - *i >= static_cast<float>(std::numeric_limits<int64_t>::min())) { - expected = static_cast<int64_t>(*i); - } else if (std::isnan(*i)) { + if (i < static_cast<float>(std::numeric_limits<int64_t>::max()) && + i >= static_cast<float>(std::numeric_limits<int64_t>::min())) { + expected = static_cast<int64_t>(i); + } else if (std::isnan(i)) { expected = static_cast<int64_t>(0); - } else if (*i < 0.0) { + } else if (i < 0.0) { expected = std::numeric_limits<int64_t>::min(); } else { expected = std::numeric_limits<int64_t>::max(); } - int64_t found = r.Call(*i); + int64_t found = r.Call(i); CHECK_EQ(expected, found); } } @@ -758,11 +758,11 @@ WASM_EXEC_TEST(I64SConvertF64) { 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)); + 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)); + CHECK_TRAP64(r.Call(i)); } } } @@ -773,17 +773,17 @@ WASM_EXEC_TEST(I64SConvertSatF64) { BUILD(r, WASM_I64_SCONVERT_SAT_F64(WASM_GET_LOCAL(0))); FOR_FLOAT64_INPUTS(i) { int64_t expected; - if (*i < static_cast<double>(std::numeric_limits<int64_t>::max()) && - *i >= static_cast<double>(std::numeric_limits<int64_t>::min())) { - expected = static_cast<int64_t>(*i); - } else if (std::isnan(*i)) { + if (i < static_cast<double>(std::numeric_limits<int64_t>::max()) && + i >= static_cast<double>(std::numeric_limits<int64_t>::min())) { + expected = static_cast<int64_t>(i); + } else if (std::isnan(i)) { expected = static_cast<int64_t>(0); - } else if (*i < 0.0) { + } else if (i < 0.0) { expected = std::numeric_limits<int64_t>::min(); } else { expected = std::numeric_limits<int64_t>::max(); } - int64_t found = r.Call(*i); + int64_t found = r.Call(i); CHECK_EQ(expected, found); } } @@ -793,11 +793,11 @@ WASM_EXEC_TEST(I64UConvertF32) { 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)); + 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)); + CHECK_TRAP64(r.Call(i)); } } } @@ -808,17 +808,17 @@ WASM_EXEC_TEST(I64UConvertSatF32) { BUILD(r, WASM_I64_UCONVERT_SAT_F32(WASM_GET_LOCAL(0))); FOR_FLOAT32_INPUTS(i) { uint64_t expected; - if (*i < static_cast<float>(std::numeric_limits<uint64_t>::max()) && - *i > -1) { - expected = static_cast<uint64_t>(*i); - } else if (std::isnan(*i)) { + if (i < static_cast<float>(std::numeric_limits<uint64_t>::max()) && + i > -1) { + expected = static_cast<uint64_t>(i); + } else if (std::isnan(i)) { expected = static_cast<uint64_t>(0); - } else if (*i < 0.0) { + } else if (i < 0.0) { expected = std::numeric_limits<uint64_t>::min(); } else { expected = std::numeric_limits<uint64_t>::max(); } - uint64_t found = r.Call(*i); + uint64_t found = r.Call(i); CHECK_EQ(expected, found); } } @@ -828,11 +828,11 @@ WASM_EXEC_TEST(I64UConvertF64) { 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)); + 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)); + CHECK_TRAP64(r.Call(i)); } } } @@ -843,17 +843,17 @@ WASM_EXEC_TEST(I64UConvertSatF64) { BUILD(r, WASM_I64_UCONVERT_SAT_F64(WASM_GET_LOCAL(0))); FOR_FLOAT64_INPUTS(i) { int64_t expected; - if (*i < static_cast<float>(std::numeric_limits<uint64_t>::max()) && - *i > -1) { - expected = static_cast<uint64_t>(*i); - } else if (std::isnan(*i)) { + if (i < static_cast<float>(std::numeric_limits<uint64_t>::max()) && + i > -1) { + expected = static_cast<uint64_t>(i); + } else if (std::isnan(i)) { expected = static_cast<uint64_t>(0); - } else if (*i < 0.0) { + } else if (i < 0.0) { expected = std::numeric_limits<uint64_t>::min(); } else { expected = std::numeric_limits<uint64_t>::max(); } - int64_t found = r.Call(*i); + int64_t found = r.Call(i); CHECK_EQ(expected, found); } } @@ -1115,50 +1115,50 @@ WASM_EXEC_TEST(I64Popcnt2) { // Test the WasmRunner with an Int64 return value and different numbers of // Int64 parameters. WASM_EXEC_TEST(I64WasmRunner) { - {FOR_INT64_INPUTS(i){WasmRunner<int64_t> r(execution_tier); - BUILD(r, WASM_I64V(*i)); - CHECK_EQ(*i, r.Call()); -} -} -{ - WasmRunner<int64_t, int64_t> r(execution_tier); - 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_tier); - 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> r(execution_tier); + BUILD(r, WASM_I64V(i)); + CHECK_EQ(i, r.Call()); } -} -{ - WasmRunner<int64_t, int64_t, int64_t, int64_t> r(execution_tier); - 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> r(execution_tier); + 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_tier); + 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, int64_t> r(execution_tier); - 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)); + { + WasmRunner<int64_t, int64_t, int64_t, int64_t> r(execution_tier); + 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_tier); + 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) { @@ -1172,16 +1172,9 @@ WASM_EXEC_TEST(Call_Int64Sub) { BUILD(r, WASM_CALL_FUNCTION(t.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)); + FOR_INT64_INPUTS(i) { + FOR_INT64_INPUTS(j) { + CHECK_EQ(base::SubWithWraparound(i, j), r.Call(i, j)); } } } @@ -1217,7 +1210,8 @@ WASM_EXEC_TEST(LoadStoreI64_sx) { r.builder().BlankMemory(); memory[size - 1] = static_cast<byte>(i); // set the high order byte. - int64_t expected = static_cast<int64_t>(i) << ((size - 1) * 8); + int64_t expected = static_cast<uint64_t>(static_cast<int64_t>(i)) + << ((size - 1) * 8); CHECK_EQ(expected, r.Call()); CHECK_EQ(static_cast<byte>(i), memory[8 + size - 1]); @@ -1238,8 +1232,8 @@ WASM_EXEC_TEST(I64ReinterpretF64) { WASM_LOAD_MEM(MachineType::Float64(), WASM_ZERO))); FOR_INT32_INPUTS(i) { - int64_t expected = base::MulWithWraparound(static_cast<int64_t>(*i), - int64_t{0x300010001L}); + int64_t expected = + base::MulWithWraparound(static_cast<int64_t>(i), int64_t{0x300010001L}); r.builder().WriteMemory(&memory[0], expected); CHECK_EQ(expected, r.Call()); } @@ -1264,8 +1258,8 @@ WASM_EXEC_TEST(F64ReinterpretI64) { WASM_GET_LOCAL(0)); FOR_INT32_INPUTS(i) { - int64_t expected = base::MulWithWraparound(static_cast<int64_t>(*i), - int64_t{0x300010001L}); + int64_t expected = + base::MulWithWraparound(static_cast<int64_t>(i), int64_t{0x300010001L}); CHECK_EQ(expected, r.Call(expected)); CHECK_EQ(expected, r.builder().ReadMemory<int64_t>(&memory[0])); } @@ -1380,8 +1374,8 @@ WASM_EXEC_TEST(I64Eqz) { 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)); + int32_t result = i == 0 ? 1 : 0; + CHECK_EQ(result, r.Call(i)); } } @@ -1391,8 +1385,8 @@ WASM_EXEC_TEST(I64Ror) { FOR_UINT64_INPUTS(i) { FOR_UINT64_INPUTS(j) { - int64_t expected = base::bits::RotateRight64(*i, *j & 0x3F); - CHECK_EQ(expected, r.Call(*i, *j)); + int64_t expected = base::bits::RotateRight64(i, j & 0x3F); + CHECK_EQ(expected, r.Call(i, j)); } } } @@ -1403,8 +1397,8 @@ WASM_EXEC_TEST(I64Rol) { FOR_UINT64_INPUTS(i) { FOR_UINT64_INPUTS(j) { - int64_t expected = base::bits::RotateLeft64(*i, *j & 0x3F); - CHECK_EQ(expected, r.Call(*i, *j)); + int64_t expected = base::bits::RotateLeft64(i, j & 0x3F); + CHECK_EQ(expected, r.Call(i, j)); } } } diff --git a/deps/v8/test/cctest/wasm/test-run-wasm-asmjs.cc b/deps/v8/test/cctest/wasm/test-run-wasm-asmjs.cc index fc9e395d44..ea45762a7c 100644 --- a/deps/v8/test/cctest/wasm/test-run-wasm-asmjs.cc +++ b/deps/v8/test/cctest/wasm/test-run-wasm-asmjs.cc @@ -73,8 +73,8 @@ WASM_EXEC_TEST(I32AsmjsSConvertF32) { BUILD(r, WASM_UNOP(kExprI32AsmjsSConvertF32, WASM_GET_LOCAL(0))); FOR_FLOAT32_INPUTS(i) { - int32_t expected = DoubleToInt32(*i); - CHECK_EQ(expected, r.Call(*i)); + int32_t expected = DoubleToInt32(i); + CHECK_EQ(expected, r.Call(i)); } } @@ -84,8 +84,8 @@ WASM_EXEC_TEST(I32AsmjsSConvertF64) { BUILD(r, WASM_UNOP(kExprI32AsmjsSConvertF64, WASM_GET_LOCAL(0))); FOR_FLOAT64_INPUTS(i) { - int32_t expected = DoubleToInt32(*i); - CHECK_EQ(expected, r.Call(*i)); + int32_t expected = DoubleToInt32(i); + CHECK_EQ(expected, r.Call(i)); } } @@ -95,8 +95,8 @@ WASM_EXEC_TEST(I32AsmjsUConvertF32) { BUILD(r, WASM_UNOP(kExprI32AsmjsUConvertF32, WASM_GET_LOCAL(0))); FOR_FLOAT32_INPUTS(i) { - uint32_t expected = DoubleToUint32(*i); - CHECK_EQ(expected, r.Call(*i)); + uint32_t expected = DoubleToUint32(i); + CHECK_EQ(expected, r.Call(i)); } } @@ -106,8 +106,8 @@ WASM_EXEC_TEST(I32AsmjsUConvertF64) { BUILD(r, WASM_UNOP(kExprI32AsmjsUConvertF64, WASM_GET_LOCAL(0))); FOR_FLOAT64_INPUTS(i) { - uint32_t expected = DoubleToUint32(*i); - CHECK_EQ(expected, r.Call(*i)); + uint32_t expected = DoubleToUint32(i); + CHECK_EQ(expected, r.Call(i)); } } diff --git a/deps/v8/test/cctest/wasm/test-run-wasm-atomics.cc b/deps/v8/test/cctest/wasm/test-run-wasm-atomics.cc index 8eddaa0224..7895b192f8 100644 --- a/deps/v8/test/cctest/wasm/test-run-wasm-atomics.cc +++ b/deps/v8/test/cctest/wasm/test-run-wasm-atomics.cc @@ -22,11 +22,11 @@ void RunU32BinOp(ExecutionTier execution_tier, WasmOpcode wasm_op, MachineRepresentation::kWord32)); FOR_UINT32_INPUTS(i) { - uint32_t initial = *i; + uint32_t initial = i; FOR_UINT32_INPUTS(j) { r.builder().WriteMemory(&memory[0], initial); - CHECK_EQ(initial, r.Call(*j)); - uint32_t expected = expected_op(*i, *j); + CHECK_EQ(initial, r.Call(j)); + uint32_t expected = expected_op(i, j); CHECK_EQ(expected, r.builder().ReadMemory(&memory[0])); } } @@ -51,11 +51,11 @@ void RunU16BinOp(ExecutionTier tier, WasmOpcode wasm_op, MachineRepresentation::kWord16)); FOR_UINT16_INPUTS(i) { - uint16_t initial = *i; + uint16_t initial = i; FOR_UINT16_INPUTS(j) { r.builder().WriteMemory(&memory[0], initial); - CHECK_EQ(initial, r.Call(*j)); - uint16_t expected = expected_op(*i, *j); + CHECK_EQ(initial, r.Call(j)); + uint16_t expected = expected_op(i, j); CHECK_EQ(expected, r.builder().ReadMemory(&memory[0])); } } @@ -79,11 +79,11 @@ void RunU8BinOp(ExecutionTier execution_tier, WasmOpcode wasm_op, MachineRepresentation::kWord8)); FOR_UINT8_INPUTS(i) { - uint8_t initial = *i; + uint8_t initial = i; FOR_UINT8_INPUTS(j) { r.builder().WriteMemory(&memory[0], initial); - CHECK_EQ(initial, r.Call(*j)); - uint8_t expected = expected_op(*i, *j); + CHECK_EQ(initial, r.Call(j)); + uint8_t expected = expected_op(i, j); CHECK_EQ(expected, r.builder().ReadMemory(&memory[0])); } } @@ -107,11 +107,11 @@ WASM_EXEC_TEST(I32AtomicCompareExchange) { WASM_GET_LOCAL(1), MachineRepresentation::kWord32)); FOR_UINT32_INPUTS(i) { - uint32_t initial = *i; + uint32_t initial = i; FOR_UINT32_INPUTS(j) { r.builder().WriteMemory(&memory[0], initial); - CHECK_EQ(initial, r.Call(*i, *j)); - uint32_t expected = CompareExchange(initial, *i, *j); + CHECK_EQ(initial, r.Call(i, j)); + uint32_t expected = CompareExchange(initial, i, j); CHECK_EQ(expected, r.builder().ReadMemory(&memory[0])); } } @@ -129,11 +129,11 @@ WASM_EXEC_TEST(I32AtomicCompareExchange16U) { MachineRepresentation::kWord16)); FOR_UINT16_INPUTS(i) { - uint16_t initial = *i; + uint16_t initial = i; FOR_UINT16_INPUTS(j) { r.builder().WriteMemory(&memory[0], initial); - CHECK_EQ(initial, r.Call(*i, *j)); - uint16_t expected = CompareExchange(initial, *i, *j); + CHECK_EQ(initial, r.Call(i, j)); + uint16_t expected = CompareExchange(initial, i, j); CHECK_EQ(expected, r.builder().ReadMemory(&memory[0])); } } @@ -150,16 +150,38 @@ WASM_EXEC_TEST(I32AtomicCompareExchange8U) { MachineRepresentation::kWord8)); FOR_UINT8_INPUTS(i) { - uint8_t initial = *i; + uint8_t initial = i; FOR_UINT8_INPUTS(j) { r.builder().WriteMemory(&memory[0], initial); - CHECK_EQ(initial, r.Call(*i, *j)); - uint8_t expected = CompareExchange(initial, *i, *j); + CHECK_EQ(initial, r.Call(i, j)); + uint8_t expected = CompareExchange(initial, i, j); CHECK_EQ(expected, r.builder().ReadMemory(&memory[0])); } } } +WASM_EXEC_TEST(I32AtomicCompareExchange_fail) { + EXPERIMENTAL_FLAG_SCOPE(threads); + WasmRunner<uint32_t, uint32_t, uint32_t> r(execution_tier); + r.builder().SetHasSharedMemory(); + uint32_t* memory = + r.builder().AddMemoryElems<uint32_t>(kWasmPageSize / sizeof(uint32_t)); + BUILD(r, WASM_ATOMICS_TERNARY_OP( + kExprI32AtomicCompareExchange, WASM_I32V_1(0), WASM_GET_LOCAL(0), + WASM_GET_LOCAL(1), MachineRepresentation::kWord32)); + + // The original value at the memory location. + uint32_t old_val = 4; + // The value we use as the expected value for the compare-exchange so that it + // fails. + uint32_t expected = 6; + // The new value for the compare-exchange. + uint32_t new_val = 5; + + r.builder().WriteMemory(&memory[0], old_val); + CHECK_EQ(old_val, r.Call(expected, new_val)); +} + WASM_EXEC_TEST(I32AtomicLoad) { EXPERIMENTAL_FLAG_SCOPE(threads); WasmRunner<uint32_t> r(execution_tier); @@ -170,7 +192,7 @@ WASM_EXEC_TEST(I32AtomicLoad) { MachineRepresentation::kWord32)); FOR_UINT32_INPUTS(i) { - uint32_t expected = *i; + uint32_t expected = i; r.builder().WriteMemory(&memory[0], expected); CHECK_EQ(expected, r.Call()); } @@ -186,7 +208,7 @@ WASM_EXEC_TEST(I32AtomicLoad16U) { MachineRepresentation::kWord16)); FOR_UINT16_INPUTS(i) { - uint16_t expected = *i; + uint16_t expected = i; r.builder().WriteMemory(&memory[0], expected); CHECK_EQ(expected, r.Call()); } @@ -201,7 +223,7 @@ WASM_EXEC_TEST(I32AtomicLoad8U) { MachineRepresentation::kWord8)); FOR_UINT8_INPUTS(i) { - uint8_t expected = *i; + uint8_t expected = i; r.builder().WriteMemory(&memory[0], expected); CHECK_EQ(expected, r.Call()); } @@ -221,8 +243,8 @@ WASM_EXEC_TEST(I32AtomicStoreLoad) { MachineRepresentation::kWord32)); FOR_UINT32_INPUTS(i) { - uint32_t expected = *i; - CHECK_EQ(expected, r.Call(*i)); + uint32_t expected = i; + CHECK_EQ(expected, r.Call(i)); CHECK_EQ(expected, r.builder().ReadMemory(&memory[0])); } } @@ -242,8 +264,8 @@ WASM_EXEC_TEST(I32AtomicStoreLoad16U) { MachineRepresentation::kWord16)); FOR_UINT16_INPUTS(i) { - uint16_t expected = *i; - CHECK_EQ(expected, r.Call(*i)); + uint16_t expected = i; + CHECK_EQ(expected, r.Call(i)); CHECK_EQ(expected, r.builder().ReadMemory(&memory[0])); } } @@ -261,9 +283,9 @@ WASM_EXEC_TEST(I32AtomicStoreLoad8U) { MachineRepresentation::kWord8)); FOR_UINT8_INPUTS(i) { - uint8_t expected = *i; - CHECK_EQ(expected, r.Call(*i)); - CHECK_EQ(*i, r.builder().ReadMemory(&memory[0])); + uint8_t expected = i; + CHECK_EQ(expected, r.Call(i)); + CHECK_EQ(i, r.builder().ReadMemory(&memory[0])); } } diff --git a/deps/v8/test/cctest/wasm/test-run-wasm-atomics64.cc b/deps/v8/test/cctest/wasm/test-run-wasm-atomics64.cc index 624982a117..bbeafc9151 100644 --- a/deps/v8/test/cctest/wasm/test-run-wasm-atomics64.cc +++ b/deps/v8/test/cctest/wasm/test-run-wasm-atomics64.cc @@ -22,11 +22,11 @@ void RunU64BinOp(ExecutionTier execution_tier, WasmOpcode wasm_op, MachineRepresentation::kWord64)); FOR_UINT64_INPUTS(i) { - uint64_t initial = *i; + uint64_t initial = i; FOR_UINT64_INPUTS(j) { r.builder().WriteMemory(&memory[0], initial); - CHECK_EQ(initial, r.Call(*j)); - uint64_t expected = expected_op(*i, *j); + CHECK_EQ(initial, r.Call(j)); + uint64_t expected = expected_op(i, j); CHECK_EQ(expected, r.builder().ReadMemory(&memory[0])); } } @@ -51,11 +51,11 @@ void RunU32BinOp(ExecutionTier execution_tier, WasmOpcode wasm_op, MachineRepresentation::kWord32)); FOR_UINT32_INPUTS(i) { - uint32_t initial = *i; + uint32_t initial = i; FOR_UINT32_INPUTS(j) { r.builder().WriteMemory(&memory[0], initial); - CHECK_EQ(initial, r.Call(*j)); - uint32_t expected = expected_op(*i, *j); + CHECK_EQ(initial, r.Call(j)); + uint32_t expected = expected_op(i, j); CHECK_EQ(expected, r.builder().ReadMemory(&memory[0])); } } @@ -80,11 +80,11 @@ void RunU16BinOp(ExecutionTier tier, WasmOpcode wasm_op, MachineRepresentation::kWord16)); FOR_UINT16_INPUTS(i) { - uint16_t initial = *i; + uint16_t initial = i; FOR_UINT16_INPUTS(j) { r.builder().WriteMemory(&memory[0], initial); - CHECK_EQ(initial, r.Call(*j)); - uint16_t expected = expected_op(*i, *j); + CHECK_EQ(initial, r.Call(j)); + uint16_t expected = expected_op(i, j); CHECK_EQ(expected, r.builder().ReadMemory(&memory[0])); } } @@ -108,11 +108,11 @@ void RunU8BinOp(ExecutionTier execution_tier, WasmOpcode wasm_op, MachineRepresentation::kWord8)); FOR_UINT8_INPUTS(i) { - uint8_t initial = *i; + uint8_t initial = i; FOR_UINT8_INPUTS(j) { r.builder().WriteMemory(&memory[0], initial); - CHECK_EQ(initial, r.Call(*j)); - uint8_t expected = expected_op(*i, *j); + CHECK_EQ(initial, r.Call(j)); + uint8_t expected = expected_op(i, j); CHECK_EQ(expected, r.builder().ReadMemory(&memory[0])); } } @@ -136,11 +136,11 @@ WASM_EXEC_TEST(I64AtomicCompareExchange) { WASM_GET_LOCAL(1), MachineRepresentation::kWord64)); FOR_UINT64_INPUTS(i) { - uint64_t initial = *i; + uint64_t initial = i; FOR_UINT64_INPUTS(j) { r.builder().WriteMemory(&memory[0], initial); - CHECK_EQ(initial, r.Call(*i, *j)); - uint64_t expected = CompareExchange(initial, *i, *j); + CHECK_EQ(initial, r.Call(i, j)); + uint64_t expected = CompareExchange(initial, i, j); CHECK_EQ(expected, r.builder().ReadMemory(&memory[0])); } } @@ -158,11 +158,11 @@ WASM_EXEC_TEST(I64AtomicCompareExchange32U) { MachineRepresentation::kWord32)); FOR_UINT32_INPUTS(i) { - uint32_t initial = *i; + uint32_t initial = i; FOR_UINT32_INPUTS(j) { r.builder().WriteMemory(&memory[0], initial); - CHECK_EQ(initial, r.Call(*i, *j)); - uint32_t expected = CompareExchange(initial, *i, *j); + CHECK_EQ(initial, r.Call(i, j)); + uint32_t expected = CompareExchange(initial, i, j); CHECK_EQ(expected, r.builder().ReadMemory(&memory[0])); } } @@ -180,11 +180,11 @@ WASM_EXEC_TEST(I64AtomicCompareExchange16U) { MachineRepresentation::kWord16)); FOR_UINT16_INPUTS(i) { - uint16_t initial = *i; + uint16_t initial = i; FOR_UINT16_INPUTS(j) { r.builder().WriteMemory(&memory[0], initial); - CHECK_EQ(initial, r.Call(*i, *j)); - uint16_t expected = CompareExchange(initial, *i, *j); + CHECK_EQ(initial, r.Call(i, j)); + uint16_t expected = CompareExchange(initial, i, j); CHECK_EQ(expected, r.builder().ReadMemory(&memory[0])); } } @@ -200,11 +200,11 @@ WASM_EXEC_TEST(I32AtomicCompareExchange8U) { WASM_GET_LOCAL(0), WASM_GET_LOCAL(1), MachineRepresentation::kWord8)); FOR_UINT8_INPUTS(i) { - uint8_t initial = *i; + uint8_t initial = i; FOR_UINT8_INPUTS(j) { r.builder().WriteMemory(&memory[0], initial); - CHECK_EQ(initial, r.Call(*i, *j)); - uint8_t expected = CompareExchange(initial, *i, *j); + CHECK_EQ(initial, r.Call(i, j)); + uint8_t expected = CompareExchange(initial, i, j); CHECK_EQ(expected, r.builder().ReadMemory(&memory[0])); } } @@ -220,7 +220,7 @@ WASM_EXEC_TEST(I64AtomicLoad) { MachineRepresentation::kWord64)); FOR_UINT64_INPUTS(i) { - uint64_t expected = *i; + uint64_t expected = i; r.builder().WriteMemory(&memory[0], expected); CHECK_EQ(expected, r.Call()); } @@ -236,7 +236,7 @@ WASM_EXEC_TEST(I64AtomicLoad32U) { MachineRepresentation::kWord32)); FOR_UINT32_INPUTS(i) { - uint32_t expected = *i; + uint32_t expected = i; r.builder().WriteMemory(&memory[0], expected); CHECK_EQ(expected, r.Call()); } @@ -252,7 +252,7 @@ WASM_EXEC_TEST(I64AtomicLoad16U) { MachineRepresentation::kWord16)); FOR_UINT16_INPUTS(i) { - uint16_t expected = *i; + uint16_t expected = i; r.builder().WriteMemory(&memory[0], expected); CHECK_EQ(expected, r.Call()); } @@ -267,7 +267,7 @@ WASM_EXEC_TEST(I64AtomicLoad8U) { MachineRepresentation::kWord8)); FOR_UINT8_INPUTS(i) { - uint8_t expected = *i; + uint8_t expected = i; r.builder().WriteMemory(&memory[0], expected); CHECK_EQ(expected, r.Call()); } @@ -287,8 +287,8 @@ WASM_EXEC_TEST(I64AtomicStoreLoad) { MachineRepresentation::kWord64)); FOR_UINT64_INPUTS(i) { - uint64_t expected = *i; - CHECK_EQ(expected, r.Call(*i)); + uint64_t expected = i; + CHECK_EQ(expected, r.Call(i)); CHECK_EQ(expected, r.builder().ReadMemory(&memory[0])); } } @@ -308,8 +308,8 @@ WASM_EXEC_TEST(I64AtomicStoreLoad32U) { MachineRepresentation::kWord32)); FOR_UINT32_INPUTS(i) { - uint32_t expected = *i; - CHECK_EQ(expected, r.Call(*i)); + uint32_t expected = i; + CHECK_EQ(expected, r.Call(i)); CHECK_EQ(expected, r.builder().ReadMemory(&memory[0])); } } @@ -329,8 +329,8 @@ WASM_EXEC_TEST(I64AtomicStoreLoad16U) { MachineRepresentation::kWord16)); FOR_UINT16_INPUTS(i) { - uint16_t expected = *i; - CHECK_EQ(expected, r.Call(*i)); + uint16_t expected = i; + CHECK_EQ(expected, r.Call(i)); CHECK_EQ(expected, r.builder().ReadMemory(&memory[0])); } } @@ -348,9 +348,9 @@ WASM_EXEC_TEST(I64AtomicStoreLoad8U) { MachineRepresentation::kWord8)); FOR_UINT8_INPUTS(i) { - uint8_t expected = *i; - CHECK_EQ(expected, r.Call(*i)); - CHECK_EQ(*i, r.builder().ReadMemory(&memory[0])); + uint8_t expected = i; + CHECK_EQ(expected, r.Call(i)); + CHECK_EQ(i, r.builder().ReadMemory(&memory[0])); } } diff --git a/deps/v8/test/cctest/wasm/test-run-wasm-exceptions.cc b/deps/v8/test/cctest/wasm/test-run-wasm-exceptions.cc new file mode 100644 index 0000000000..eefaa678d1 --- /dev/null +++ b/deps/v8/test/cctest/wasm/test-run-wasm-exceptions.cc @@ -0,0 +1,220 @@ +// Copyright 2019 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 "src/api-inl.h" +#include "test/cctest/wasm/wasm-atomics-utils.h" +#include "test/common/wasm/test-signatures.h" +#include "test/common/wasm/wasm-macro-gen.h" + +namespace v8 { +namespace internal { +namespace wasm { +namespace test_run_wasm_exceptions { + +WASM_EXEC_TEST(TryCatchThrow) { + TestSignatures sigs; + EXPERIMENTAL_FLAG_SCOPE(eh); + WasmRunner<uint32_t, uint32_t> r(execution_tier); + uint32_t except = r.builder().AddException(sigs.v_v()); + constexpr uint32_t kResult0 = 23; + constexpr uint32_t kResult1 = 42; + + // Build the main test function. + BUILD(r, WASM_TRY_CATCH_T(kWasmI32, + WASM_STMTS(WASM_I32V(kResult1), + WASM_IF(WASM_I32_EQZ(WASM_GET_LOCAL(0)), + WASM_THROW(except))), + WASM_STMTS(WASM_DROP, WASM_I32V(kResult0)))); + + // Need to call through JS to allow for creation of stack traces. + r.CheckCallViaJS(kResult0, 0); + r.CheckCallViaJS(kResult1, 1); +} + +WASM_EXEC_TEST(TryCatchCallDirect) { + TestSignatures sigs; + EXPERIMENTAL_FLAG_SCOPE(eh); + WasmRunner<uint32_t, uint32_t> r(execution_tier); + uint32_t except = r.builder().AddException(sigs.v_v()); + constexpr uint32_t kResult0 = 23; + constexpr uint32_t kResult1 = 42; + + // Build a throwing helper function. + WasmFunctionCompiler& throw_func = r.NewFunction(sigs.i_ii()); + BUILD(throw_func, WASM_THROW(except)); + + // Build the main test function. + BUILD(r, WASM_TRY_CATCH_T( + kWasmI32, + WASM_STMTS(WASM_I32V(kResult1), + WASM_IF(WASM_I32_EQZ(WASM_GET_LOCAL(0)), + WASM_STMTS(WASM_CALL_FUNCTION( + throw_func.function_index(), + WASM_I32V(7), WASM_I32V(9)), + WASM_DROP))), + WASM_STMTS(WASM_DROP, WASM_I32V(kResult0)))); + + // Need to call through JS to allow for creation of stack traces. + r.CheckCallViaJS(kResult0, 0); + r.CheckCallViaJS(kResult1, 1); +} + +WASM_EXEC_TEST(TryCatchCallIndirect) { + TestSignatures sigs; + EXPERIMENTAL_FLAG_SCOPE(eh); + WasmRunner<uint32_t, uint32_t> r(execution_tier); + uint32_t except = r.builder().AddException(sigs.v_v()); + constexpr uint32_t kResult0 = 23; + constexpr uint32_t kResult1 = 42; + + // Build a throwing helper function. + WasmFunctionCompiler& throw_func = r.NewFunction(sigs.i_ii()); + BUILD(throw_func, WASM_THROW(except)); + r.builder().AddSignature(sigs.i_ii()); + throw_func.SetSigIndex(0); + + // Add an indirect function table. + uint16_t indirect_function_table[] = { + static_cast<uint16_t>(throw_func.function_index())}; + r.builder().AddIndirectFunctionTable(indirect_function_table, + arraysize(indirect_function_table)); + r.builder().PopulateIndirectFunctionTable(); + + // Build the main test function. + BUILD(r, WASM_TRY_CATCH_T( + kWasmI32, + WASM_STMTS(WASM_I32V(kResult1), + WASM_IF(WASM_I32_EQZ(WASM_GET_LOCAL(0)), + WASM_STMTS(WASM_CALL_INDIRECT2( + 0, WASM_GET_LOCAL(0), + WASM_I32V(7), WASM_I32V(9)), + WASM_DROP))), + WASM_STMTS(WASM_DROP, WASM_I32V(kResult0)))); + + // Need to call through JS to allow for creation of stack traces. + r.CheckCallViaJS(kResult0, 0); + r.CheckCallViaJS(kResult1, 1); +} + +WASM_EXEC_TEST(TryCatchCallExternal) { + TestSignatures sigs; + EXPERIMENTAL_FLAG_SCOPE(eh); + HandleScope scope(CcTest::InitIsolateOnce()); + const char* source = "(function() { throw 'ball'; })"; + Handle<JSFunction> js_function = + Handle<JSFunction>::cast(v8::Utils::OpenHandle( + *v8::Local<v8::Function>::Cast(CompileRun(source)))); + ManuallyImportedJSFunction import = {sigs.i_ii(), js_function}; + WasmRunner<uint32_t, uint32_t> r(execution_tier, &import); + constexpr uint32_t kResult0 = 23; + constexpr uint32_t kResult1 = 42; + constexpr uint32_t kJSFunc = 0; + + // Build the main test function. + BUILD(r, WASM_TRY_CATCH_T( + kWasmI32, + WASM_STMTS( + WASM_I32V(kResult1), + WASM_IF(WASM_I32_EQZ(WASM_GET_LOCAL(0)), + WASM_STMTS(WASM_CALL_FUNCTION(kJSFunc, WASM_I32V(7), + WASM_I32V(9)), + WASM_DROP))), + WASM_STMTS(WASM_DROP, WASM_I32V(kResult0)))); + + // Need to call through JS to allow for creation of stack traces. + r.CheckCallViaJS(kResult0, 0); + r.CheckCallViaJS(kResult1, 1); +} + +WASM_EXEC_TEST(TryCatchTrapTypeError) { + TestSignatures sigs; + EXPERIMENTAL_FLAG_SCOPE(eh); + HandleScope scope(CcTest::InitIsolateOnce()); + const char* source = "(function() { return 0; })"; + Handle<JSFunction> js_function = + Handle<JSFunction>::cast(v8::Utils::OpenHandle( + *v8::Local<v8::Function>::Cast(CompileRun(source)))); + // Make sure to use a signature incompatible with JS below. + ManuallyImportedJSFunction import = {sigs.i_ll(), js_function}; + WasmRunner<uint32_t, uint32_t> r(execution_tier, &import); + constexpr uint32_t kResult0 = 23; + constexpr uint32_t kResult1 = 42; + constexpr uint32_t kJSFunc = 0; + + // Build the main test function. + BUILD(r, WASM_TRY_CATCH_T( + kWasmI32, + WASM_STMTS( + WASM_I32V(kResult1), + WASM_IF(WASM_I32_EQZ(WASM_GET_LOCAL(0)), + WASM_STMTS(WASM_CALL_FUNCTION(kJSFunc, WASM_I64V(7), + WASM_I64V(9)), + WASM_DROP))), + WASM_STMTS(WASM_DROP, WASM_I32V(kResult0)))); + + // Need to call through JS to allow for creation of stack traces. + r.CheckCallViaJS(kResult0, 0); + r.CheckCallViaJS(kResult1, 1); +} + +namespace { + +// TODO(8729): The semantics of this are not yet specified and might change, +// this test aims at keeping semantics of various execution tiers consistent. +void TestTryCatchTrap(byte* code, size_t code_size, + ExecutionTier execution_tier) { + TestSignatures sigs; + EXPERIMENTAL_FLAG_SCOPE(eh); + WasmRunner<uint32_t, uint32_t> r(execution_tier, nullptr, "main", + kRuntimeExceptionSupport); + r.builder().AddMemory(kWasmPageSize); + constexpr uint32_t kResult0 = 23; + constexpr uint32_t kResult1 = 42; + + // Build a trapping helper function. + WasmFunctionCompiler& trap_func = r.NewFunction(sigs.i_ii()); + trap_func.Build(code, code + code_size); + + // Build the main test function. + BUILD(r, WASM_TRY_CATCH_T( + kWasmI32, + WASM_STMTS(WASM_I32V(kResult1), + WASM_IF(WASM_I32_EQZ(WASM_GET_LOCAL(0)), + WASM_STMTS(WASM_CALL_FUNCTION( + trap_func.function_index(), + WASM_I32V(7), WASM_I32V(9)), + WASM_DROP))), + WASM_STMTS(WASM_DROP, WASM_I32V(kResult0)))); + + // Need to call through JS to allow for creation of stack traces. + r.CheckCallViaJS(kResult0, 0); + r.CheckCallViaJS(kResult1, 1); +} + +} // namespace + +WASM_EXEC_TEST(TryCatchTrapUnreachable) { + byte code[] = {WASM_UNREACHABLE}; + TestTryCatchTrap(code, arraysize(code), execution_tier); +} + +WASM_EXEC_TEST(TryCatchTrapMemOutOfBounds) { + byte code[] = {WASM_LOAD_MEM(MachineType::Int32(), WASM_I32V_1(-1))}; + TestTryCatchTrap(code, arraysize(code), execution_tier); +} + +WASM_EXEC_TEST(TryCatchTrapDivByZero) { + byte code[] = {WASM_I32_DIVS(WASM_GET_LOCAL(0), WASM_I32V_1(0))}; + TestTryCatchTrap(code, arraysize(code), execution_tier); +} + +WASM_EXEC_TEST(TryCatchTrapRemByZero) { + byte code[] = {WASM_I32_REMS(WASM_GET_LOCAL(0), WASM_I32V_1(0))}; + TestTryCatchTrap(code, arraysize(code), execution_tier); +} + +} // namespace test_run_wasm_exceptions +} // namespace wasm +} // namespace internal +} // namespace v8 diff --git a/deps/v8/test/cctest/wasm/test-run-wasm-interpreter.cc b/deps/v8/test/cctest/wasm/test-run-wasm-interpreter.cc index c5d0d84e63..1a8c15be31 100644 --- a/deps/v8/test/cctest/wasm/test-run-wasm-interpreter.cc +++ b/deps/v8/test/cctest/wasm/test-run-wasm-interpreter.cc @@ -143,6 +143,109 @@ TEST(Run_Wasm_nested_ifs_i) { CHECK_EQ(14, r.Call(0, 0)); } +// Repeated from test-run-wasm.cc to avoid poluting header files. +template <typename T> +static T factorial(T v) { + T expected = 1; + for (T i = v; i > 1; i--) { + expected *= i; + } + return expected; +} + +// Basic test of return call in interpreter. Good old factorial. +TEST(Run_Wasm_returnCallFactorial) { + EXPERIMENTAL_FLAG_SCOPE(return_call); + // Run in bounded amount of stack - 8kb. + FlagScope<int32_t> stack_size(&v8::internal::FLAG_stack_size, 8); + + WasmRunner<uint32_t, int32_t> r(ExecutionTier::kInterpreter); + + WasmFunctionCompiler& fact_aux_fn = + r.NewFunction<int32_t, int32_t, int32_t>("fact_aux"); + + BUILD(r, WASM_RETURN_CALL_FUNCTION(fact_aux_fn.function_index(), + WASM_GET_LOCAL(0), WASM_I32V(1))); + + BUILD(fact_aux_fn, + WASM_IF_ELSE_I( + WASM_I32_EQ(WASM_I32V(1), WASM_GET_LOCAL(0)), WASM_GET_LOCAL(1), + WASM_RETURN_CALL_FUNCTION( + fact_aux_fn.function_index(), + WASM_I32_SUB(WASM_GET_LOCAL(0), WASM_I32V(1)), + WASM_I32_MUL(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))))); + + // Runs out of stack space without using return call. + uint32_t test_values[] = {1, 2, 5, 10, 20, 20000}; + + for (uint32_t v : test_values) { + uint32_t found = r.Call(v); + CHECK_EQ(factorial(v), found); + } +} + +TEST(Run_Wasm_returnCallFactorial64) { + EXPERIMENTAL_FLAG_SCOPE(return_call); + + int32_t test_values[] = {1, 2, 5, 10, 20}; + WasmRunner<int64_t, int32_t> r(ExecutionTier::kInterpreter); + + WasmFunctionCompiler& fact_aux_fn = + r.NewFunction<int64_t, int32_t, int64_t>("fact_aux"); + + BUILD(r, WASM_RETURN_CALL_FUNCTION(fact_aux_fn.function_index(), + WASM_GET_LOCAL(0), WASM_I64V(1))); + + BUILD(fact_aux_fn, + WASM_IF_ELSE_L( + WASM_I32_EQ(WASM_I32V(1), WASM_GET_LOCAL(0)), WASM_GET_LOCAL(1), + WASM_RETURN_CALL_FUNCTION( + fact_aux_fn.function_index(), + WASM_I32_SUB(WASM_GET_LOCAL(0), WASM_I32V(1)), + WASM_I64_MUL(WASM_I64_SCONVERT_I32(WASM_GET_LOCAL(0)), + WASM_GET_LOCAL(1))))); + + for (int32_t v : test_values) { + CHECK_EQ(factorial<int64_t>(v), r.Call(v)); + } +} + +TEST(Run_Wasm_returnCallIndirectFactorial) { + EXPERIMENTAL_FLAG_SCOPE(return_call); + + TestSignatures sigs; + + WasmRunner<uint32_t, uint32_t> r(ExecutionTier::kInterpreter); + + WasmFunctionCompiler& fact_aux_fn = r.NewFunction(sigs.i_ii(), "fact_aux"); + fact_aux_fn.SetSigIndex(0); + + r.builder().AddSignature(sigs.i_ii()); + + // Function table. + uint16_t indirect_function_table[] = { + static_cast<uint16_t>(fact_aux_fn.function_index())}; + + r.builder().AddIndirectFunctionTable(indirect_function_table, + arraysize(indirect_function_table)); + r.builder().PopulateIndirectFunctionTable(); + + BUILD(r, WASM_RETURN_CALL_INDIRECT(0, WASM_I32V(0), WASM_GET_LOCAL(0), + WASM_I32V(1))); + + BUILD(fact_aux_fn, + WASM_IF_ELSE_I( + WASM_I32_EQ(WASM_I32V(1), WASM_GET_LOCAL(0)), WASM_GET_LOCAL(1), + WASM_RETURN_CALL_INDIRECT( + 0, WASM_I32V(0), WASM_I32_SUB(WASM_GET_LOCAL(0), WASM_I32V(1)), + WASM_I32_MUL(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))))); + + uint32_t test_values[] = {1, 2, 5, 10, 20}; + + for (uint32_t v : test_values) { + CHECK_EQ(factorial(v), r.Call(v)); + } +} // Make tests more robust by not hard-coding offsets of various operations. // The {Find} method finds the offsets for the given bytecodes, returning // the offsets in an array. @@ -192,7 +295,7 @@ TEST(Breakpoint_I32Add) { FOR_UINT32_INPUTS(a) { for (uint32_t b = 11; b < 3000000000u; b += 1000000000u) { thread->Reset(); - WasmValue args[] = {WasmValue(*a), WasmValue(b)}; + WasmValue args[] = {WasmValue(a), WasmValue(b)}; thread->InitFrame(r.function(), args); for (int i = 0; i < kNumBreakpoints; i++) { @@ -207,7 +310,7 @@ TEST(Breakpoint_I32Add) { // Check the thread finished with the right value. CHECK_EQ(WasmInterpreter::FINISHED, thread->state()); - uint32_t expected = (*a) + (b); + uint32_t expected = (a) + (b); CHECK_EQ(expected, thread->GetReturnValue().to<uint32_t>()); } } @@ -227,7 +330,7 @@ TEST(Step_I32Mul) { FOR_UINT32_INPUTS(a) { for (uint32_t b = 33; b < 3000000000u; b += 1000000000u) { thread->Reset(); - WasmValue args[] = {WasmValue(*a), WasmValue(b)}; + WasmValue args[] = {WasmValue(a), WasmValue(b)}; thread->InitFrame(r.function(), args); // Run instructions one by one. @@ -242,7 +345,7 @@ TEST(Step_I32Mul) { // Check the thread finished with the right value. CHECK_EQ(WasmInterpreter::FINISHED, thread->state()); - uint32_t expected = (*a) * (b); + uint32_t expected = (a) * (b); CHECK_EQ(expected, thread->GetReturnValue().to<uint32_t>()); } } @@ -269,7 +372,7 @@ TEST(Breakpoint_I32And_disable) { interpreter->SetBreakpoint(r.function(), kLocalsDeclSize + offsets[0], do_break); thread->Reset(); - WasmValue args[] = {WasmValue(*a), WasmValue(b)}; + WasmValue args[] = {WasmValue(a), WasmValue(b)}; thread->InitFrame(r.function(), args); if (do_break) { @@ -284,7 +387,7 @@ TEST(Breakpoint_I32And_disable) { // Check the thread finished with the right value. CHECK_EQ(WasmInterpreter::FINISHED, thread->state()); - uint32_t expected = (*a) & (b); + uint32_t expected = (a) & (b); CHECK_EQ(expected, thread->GetReturnValue().to<uint32_t>()); } } @@ -438,7 +541,7 @@ TEST(TestPossibleNondeterminism) { TEST(WasmInterpreterActivations) { WasmRunner<void> r(ExecutionTier::kInterpreter); Isolate* isolate = r.main_isolate(); - BUILD(r, WASM_NOP); + BUILD(r, WASM_UNREACHABLE); WasmInterpreter* interpreter = r.interpreter(); WasmInterpreter::Thread* thread = interpreter->GetThread(0); @@ -451,17 +554,20 @@ TEST(WasmInterpreterActivations) { thread->InitFrame(r.function(), nullptr); CHECK_EQ(2, thread->NumActivations()); CHECK_EQ(2, thread->GetFrameCount()); - isolate->set_pending_exception(Smi::kZero); - thread->HandleException(isolate); + CHECK_EQ(WasmInterpreter::TRAPPED, thread->Run()); + thread->RaiseException(isolate, handle(Smi::kZero, isolate)); CHECK_EQ(1, thread->GetFrameCount()); CHECK_EQ(2, thread->NumActivations()); thread->FinishActivation(act1); + isolate->clear_pending_exception(); CHECK_EQ(1, thread->GetFrameCount()); CHECK_EQ(1, thread->NumActivations()); - thread->HandleException(isolate); + CHECK_EQ(WasmInterpreter::TRAPPED, thread->Run()); + thread->RaiseException(isolate, handle(Smi::kZero, isolate)); CHECK_EQ(0, thread->GetFrameCount()); CHECK_EQ(1, thread->NumActivations()); thread->FinishActivation(act0); + isolate->clear_pending_exception(); CHECK_EQ(0, thread->NumActivations()); } diff --git a/deps/v8/test/cctest/wasm/test-run-wasm-js.cc b/deps/v8/test/cctest/wasm/test-run-wasm-js.cc index 499942464e..47ed644673 100644 --- a/deps/v8/test/cctest/wasm/test-run-wasm-js.cc +++ b/deps/v8/test/cctest/wasm/test-run-wasm-js.cc @@ -69,68 +69,39 @@ ManuallyImportedJSFunction CreateJSSelector(FunctionSig* sig, int which) { return import; } - -void EXPECT_CALL(double expected, Handle<JSFunction> jsfunc, - Handle<Object>* buffer, int count) { - Isolate* isolate = jsfunc->GetIsolate(); - Handle<Object> global(isolate->context()->global_object(), isolate); - MaybeHandle<Object> retval = - Execution::Call(isolate, jsfunc, global, count, buffer); - - CHECK(!retval.is_null()); - Handle<Object> result = retval.ToHandleChecked(); - if (result->IsSmi()) { - CHECK_EQ(expected, Smi::ToInt(*result)); - } else { - CHECK(result->IsHeapNumber()); - CHECK_FLOAT_EQ(expected, HeapNumber::cast(*result)->value()); - } -} - -void EXPECT_CALL(double expected, Handle<JSFunction> jsfunc, double a, - double b) { - Isolate* isolate = jsfunc->GetIsolate(); - Handle<Object> buffer[] = {isolate->factory()->NewNumber(a), - isolate->factory()->NewNumber(b)}; - EXPECT_CALL(expected, jsfunc, buffer, 2); -} } // namespace WASM_EXEC_TEST(Run_Int32Sub_jswrapped) { WasmRunner<int, int, int> r(execution_tier); BUILD(r, WASM_I32_SUB(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); - Handle<JSFunction> jsfunc = r.builder().WrapCode(r.function()->func_index); - EXPECT_CALL(33, jsfunc, 44, 11); - EXPECT_CALL(-8723487, jsfunc, -8000000, 723487); + r.CheckCallViaJS(33, 44, 11); + r.CheckCallViaJS(-8723487, -8000000, 723487); } WASM_EXEC_TEST(Run_Float32Div_jswrapped) { WasmRunner<float, float, float> r(execution_tier); BUILD(r, WASM_F32_DIV(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); - Handle<JSFunction> jsfunc = r.builder().WrapCode(r.function()->func_index); - EXPECT_CALL(92, jsfunc, 46, 0.5); - EXPECT_CALL(64, jsfunc, -16, -0.25); + r.CheckCallViaJS(92, 46, 0.5); + r.CheckCallViaJS(64, -16, -0.25); } WASM_EXEC_TEST(Run_Float64Add_jswrapped) { WasmRunner<double, double, double> r(execution_tier); BUILD(r, WASM_F64_ADD(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); - Handle<JSFunction> jsfunc = r.builder().WrapCode(r.function()->func_index); - EXPECT_CALL(3, jsfunc, 2, 1); - EXPECT_CALL(-5.5, jsfunc, -5.25, -0.25); + r.CheckCallViaJS(3, 2, 1); + r.CheckCallViaJS(-5.5, -5.25, -0.25); } WASM_EXEC_TEST(Run_I32Popcount_jswrapped) { WasmRunner<int, int> r(execution_tier); BUILD(r, WASM_I32_POPCNT(WASM_GET_LOCAL(0))); - Handle<JSFunction> jsfunc = r.builder().WrapCode(r.function()->func_index); - EXPECT_CALL(2, jsfunc, 9, 0); - EXPECT_CALL(3, jsfunc, 11, 0); - EXPECT_CALL(6, jsfunc, 0x3F, 0); + r.CheckCallViaJS(2, 9); + r.CheckCallViaJS(3, 11); + r.CheckCallViaJS(6, 0x3F); } WASM_EXEC_TEST(Run_CallJS_Add_jswrapped) { @@ -143,15 +114,48 @@ WASM_EXEC_TEST(Run_CallJS_Add_jswrapped) { ManuallyImportedJSFunction import = {sigs.i_i(), js_function}; WasmRunner<int, int> r(execution_tier, &import); uint32_t js_index = 0; + BUILD(r, WASM_CALL_FUNCTION(js_index, WASM_GET_LOCAL(0))); - WasmFunctionCompiler& t = r.NewFunction(sigs.i_i()); - BUILD(t, WASM_CALL_FUNCTION(js_index, WASM_GET_LOCAL(0))); + r.CheckCallViaJS(101, 2); + r.CheckCallViaJS(199, 100); + r.CheckCallViaJS(-666666801, -666666900); +} - Handle<JSFunction> jsfunc = r.builder().WrapCode(t.function_index()); +WASM_EXEC_TEST(Run_IndirectCallJSFunction) { + Isolate* isolate = CcTest::InitIsolateOnce(); + HandleScope scope(isolate); + TestSignatures sigs; - EXPECT_CALL(101, jsfunc, 2, -8); - EXPECT_CALL(199, jsfunc, 100, -1); - EXPECT_CALL(-666666801, jsfunc, -666666900, -1); + const char* source = "(function(a, b, c) { if(c) return a; return b; })"; + Handle<JSFunction> js_function = + Handle<JSFunction>::cast(v8::Utils::OpenHandle( + *v8::Local<v8::Function>::Cast(CompileRun(source)))); + + ManuallyImportedJSFunction import = {sigs.i_iii(), js_function}; + + WasmRunner<int32_t, int32_t> r(execution_tier, &import); + + const uint32_t js_index = 0; + const int32_t left = -2; + const int32_t right = 3; + + WasmFunctionCompiler& rc_fn = r.NewFunction(sigs.i_i(), "rc"); + + r.builder().AddSignature(sigs.i_iii()); + uint16_t indirect_function_table[] = {static_cast<uint16_t>(js_index)}; + + r.builder().AddIndirectFunctionTable(indirect_function_table, + arraysize(indirect_function_table)); + r.builder().PopulateIndirectFunctionTable(); + + BUILD(rc_fn, WASM_CALL_INDIRECT3(0, WASM_I32V(js_index), WASM_I32V(left), + WASM_I32V(right), WASM_GET_LOCAL(0))); + + Handle<Object> args_left[] = {isolate->factory()->NewNumber(1)}; + r.CheckCallViaJS(left, rc_fn.function_index(), args_left, 1); + + Handle<Object> args_right[] = {isolate->factory()->NewNumber(0)}; + r.CheckCallViaJS(right, rc_fn.function_index(), args_right, 1); } void RunJSSelectTest(ExecutionTier tier, int which) { @@ -184,9 +188,8 @@ void RunJSSelectTest(ExecutionTier tier, int which) { t.Build(&code[0], &code[end]); } - Handle<JSFunction> jsfunc = r.builder().WrapCode(t.function_index()); double expected = inputs.arg_d(which); - EXPECT_CALL(expected, jsfunc, 0.0, 0.0); + r.CheckCallViaJS(expected, t.function_index(), nullptr, 0); } } @@ -243,7 +246,6 @@ void RunWASMSelectTest(ExecutionTier tier, int which) { WasmRunner<void> r(tier); WasmFunctionCompiler& t = r.NewFunction(&sig); BUILD(t, WASM_GET_LOCAL(which)); - Handle<JSFunction> jsfunc = r.builder().WrapCode(t.function_index()); Handle<Object> args[] = { isolate->factory()->NewNumber(inputs.arg_d(0)), @@ -257,7 +259,7 @@ void RunWASMSelectTest(ExecutionTier tier, int which) { }; double expected = inputs.arg_d(which); - EXPECT_CALL(expected, jsfunc, args, kMaxParams); + r.CheckCallViaJS(expected, t.function_index(), args, kMaxParams); } } @@ -315,7 +317,6 @@ void RunWASMSelectAlignTest(ExecutionTier tier, int num_args, int num_params) { WasmRunner<void> r(tier); WasmFunctionCompiler& t = r.NewFunction(&sig); BUILD(t, WASM_GET_LOCAL(which)); - Handle<JSFunction> jsfunc = r.builder().WrapCode(t.function_index()); Handle<Object> args[] = {isolate->factory()->NewNumber(inputs.arg_d(0)), isolate->factory()->NewNumber(inputs.arg_d(1)), @@ -330,7 +331,7 @@ void RunWASMSelectAlignTest(ExecutionTier tier, int num_args, int num_params) { double nan = std::numeric_limits<double>::quiet_NaN(); double expected = which < num_args ? inputs.arg_d(which) : nan; - EXPECT_CALL(expected, jsfunc, args, num_args); + r.CheckCallViaJS(expected, t.function_index(), args, num_args); } } @@ -430,8 +431,6 @@ void RunJSSelectAlignTest(ExecutionTier tier, int num_args, int num_params) { WasmFunctionCompiler& t = r.NewFunction(&sig); t.Build(&code[0], &code[end]); - Handle<JSFunction> jsfunc = r.builder().WrapCode(t.function_index()); - Handle<Object> args[] = { factory->NewNumber(inputs.arg_d(0)), factory->NewNumber(inputs.arg_d(1)), @@ -447,7 +446,7 @@ void RunJSSelectAlignTest(ExecutionTier tier, int num_args, int num_params) { double nan = std::numeric_limits<double>::quiet_NaN(); double expected = which < num_args ? inputs.arg_d(which) : nan; - EXPECT_CALL(expected, jsfunc, args, num_args); + r.CheckCallViaJS(expected, t.function_index(), args, num_args); } } diff --git a/deps/v8/test/cctest/wasm/test-run-wasm-module.cc b/deps/v8/test/cctest/wasm/test-run-wasm-module.cc index 2503ec57fd..d23bdc133f 100644 --- a/deps/v8/test/cctest/wasm/test-run-wasm-module.cc +++ b/deps/v8/test/cctest/wasm/test-run-wasm-module.cc @@ -854,8 +854,7 @@ TEST(Run_WasmModule_Reclaim_Memory) { Handle<JSArrayBuffer> buffer; for (int i = 0; i < 256; ++i) { HandleScope scope(isolate); - CHECK(NewArrayBuffer(isolate, kWasmPageSize, SharedFlag::kNotShared) - .ToHandle(&buffer)); + CHECK(NewArrayBuffer(isolate, kWasmPageSize).ToHandle(&buffer)); } } #endif diff --git a/deps/v8/test/cctest/wasm/test-run-wasm-simd.cc b/deps/v8/test/cctest/wasm/test-run-wasm-simd.cc index ed8bdf7281..fa27e983af 100644 --- a/deps/v8/test/cctest/wasm/test-run-wasm-simd.cc +++ b/deps/v8/test/cctest/wasm/test-run-wasm-simd.cc @@ -158,7 +158,8 @@ int UnsignedGreaterEqual(T a, T b) { template <typename T> T LogicalShiftLeft(T a, int shift) { - return a << shift; + using UnsignedT = typename std::make_unsigned<T>::type; + return static_cast<UnsignedT>(a) << shift; } template <typename T> @@ -407,8 +408,8 @@ WASM_SIMD_TEST(F32x4Splat) { WASM_SIMD_CHECK_SPLAT_F32x4(simd, lane_val), WASM_RETURN1(WASM_ONE)); FOR_FLOAT32_INPUTS(i) { - if (SkipFPExpectedValue(*i)) continue; - CHECK_EQ(1, r.Call(*i)); + if (SkipFPExpectedValue(i)) continue; + CHECK_EQ(1, r.Call(i)); } } @@ -485,8 +486,8 @@ WASM_SIMD_COMPILED_TEST(F32x4ConvertI32x4) { WASM_RETURN1(WASM_ONE)); FOR_INT32_INPUTS(i) { - CHECK_EQ(1, r.Call(*i, static_cast<float>(*i), - static_cast<float>(static_cast<uint32_t>(*i)))); + CHECK_EQ(1, r.Call(i, static_cast<float>(i), + static_cast<float>(static_cast<uint32_t>(i)))); } } @@ -504,11 +505,11 @@ void RunF32x4UnOpTest(ExecutionTier execution_tier, LowerSimd lower_simd, WASM_RETURN1(WASM_ONE)); FOR_FLOAT32_INPUTS(i) { - if (SkipFPValue(*i)) continue; - float expected = expected_op(*i); + if (SkipFPValue(i)) continue; + float expected = expected_op(i); if (SkipFPExpectedValue(expected)) continue; float abs_error = std::abs(expected) * error; - CHECK_EQ(1, r.Call(*i, expected - abs_error, expected + abs_error)); + CHECK_EQ(1, r.Call(i, expected - abs_error, expected + abs_error)); } } @@ -546,12 +547,12 @@ void RunF32x4BinOpTest(ExecutionTier execution_tier, LowerSimd lower_simd, WASM_SIMD_CHECK_SPLAT_F32x4(simd1, expected), WASM_RETURN1(WASM_ONE)); FOR_FLOAT32_INPUTS(i) { - if (SkipFPValue(*i)) continue; + if (SkipFPValue(i)) continue; FOR_FLOAT32_INPUTS(j) { - if (SkipFPValue(*j)) continue; - float expected = expected_op(*i, *j); + if (SkipFPValue(j)) continue; + float expected = expected_op(i, j); if (SkipFPExpectedValue(expected)) continue; - CHECK_EQ(1, r.Call(*i, *j, expected)); + CHECK_EQ(1, r.Call(i, j, expected)); } } } @@ -587,12 +588,12 @@ void RunF32x4CompareOpTest(ExecutionTier execution_tier, LowerSimd lower_simd, WASM_SIMD_CHECK_SPLAT4(I32x4, simd1, I32, expected), WASM_ONE); FOR_FLOAT32_INPUTS(i) { - if (SkipFPValue(*i)) continue; + if (SkipFPValue(i)) continue; FOR_FLOAT32_INPUTS(j) { - if (SkipFPValue(*j)) continue; - float diff = *i - *j; + if (SkipFPValue(j)) continue; + float diff = i - j; if (SkipFPExpectedValue(diff)) continue; - CHECK_EQ(1, r.Call(*i, *j, expected_op(*i, *j))); + CHECK_EQ(1, r.Call(i, j, expected_op(i, j))); } } } @@ -639,7 +640,7 @@ WASM_SIMD_TEST(I32x4Splat) { WASM_SET_LOCAL(simd, WASM_SIMD_I32x4_SPLAT(WASM_GET_LOCAL(lane_val))), WASM_SIMD_CHECK_SPLAT4(I32x4, simd, I32, lane_val), WASM_ONE); - FOR_INT32_INPUTS(i) { CHECK_EQ(1, r.Call(*i)); } + FOR_INT32_INPUTS(i) { CHECK_EQ(1, r.Call(i)); } } WASM_SIMD_TEST(I32x4ReplaceLane) { @@ -676,7 +677,7 @@ WASM_SIMD_TEST(I16x8Splat) { WASM_SET_LOCAL(simd, WASM_SIMD_I16x8_SPLAT(WASM_GET_LOCAL(lane_val))), WASM_SIMD_CHECK_SPLAT8(I16x8, simd, I32, lane_val), WASM_ONE); - FOR_INT16_INPUTS(i) { CHECK_EQ(1, r.Call(*i)); } + FOR_INT16_INPUTS(i) { CHECK_EQ(1, r.Call(i)); } } WASM_SIMD_TEST(I16x8ReplaceLane) { @@ -736,7 +737,7 @@ WASM_SIMD_TEST(I8x16Splat) { WASM_SET_LOCAL(simd, WASM_SIMD_I8x16_SPLAT(WASM_GET_LOCAL(lane_val))), WASM_SIMD_CHECK_SPLAT8(I8x16, simd, I32, lane_val), WASM_ONE); - FOR_INT8_INPUTS(i) { CHECK_EQ(1, r.Call(*i)); } + FOR_INT8_INPUTS(i) { CHECK_EQ(1, r.Call(i)); } } WASM_SIMD_TEST(I8x16ReplaceLane) { @@ -874,10 +875,10 @@ WASM_SIMD_TEST(I32x4ConvertF32x4) { WASM_SIMD_CHECK_SPLAT4(I32x4, simd2, I32, expected_unsigned), WASM_ONE); FOR_FLOAT32_INPUTS(i) { - if (SkipFPValue(*i)) continue; - int32_t signed_value = ConvertToInt(*i, false); - int32_t unsigned_value = ConvertToInt(*i, true); - CHECK_EQ(1, r.Call(*i, signed_value, unsigned_value)); + if (SkipFPValue(i)) continue; + int32_t signed_value = ConvertToInt(i, false); + int32_t unsigned_value = ConvertToInt(i, true); + CHECK_EQ(1, r.Call(i, signed_value, unsigned_value)); } } @@ -915,10 +916,9 @@ WASM_SIMD_TEST(I32x4ConvertI16x8) { WASM_ONE); FOR_INT16_INPUTS(i) { - int32_t unpacked_signed = static_cast<int32_t>(Widen<int16_t>(*i)); - int32_t unpacked_unsigned = - static_cast<int32_t>(UnsignedWiden<int16_t>(*i)); - CHECK_EQ(1, r.Call(*i, unpacked_signed, unpacked_unsigned, 0)); + int32_t unpacked_signed = static_cast<int32_t>(Widen<int16_t>(i)); + int32_t unpacked_unsigned = static_cast<int32_t>(UnsignedWiden<int16_t>(i)); + CHECK_EQ(1, r.Call(i, unpacked_signed, unpacked_unsigned, 0)); } } @@ -932,7 +932,7 @@ void RunI32x4UnOpTest(ExecutionTier execution_tier, LowerSimd lower_simd, WASM_SET_LOCAL(simd, WASM_SIMD_UNOP(simd_op, WASM_GET_LOCAL(simd))), WASM_SIMD_CHECK_SPLAT4(I32x4, simd, I32, expected), WASM_ONE); - FOR_INT32_INPUTS(i) { CHECK_EQ(1, r.Call(*i, expected_op(*i))); } + FOR_INT32_INPUTS(i) { CHECK_EQ(1, r.Call(i, expected_op(i))); } } WASM_SIMD_TEST(I32x4Neg) { @@ -959,7 +959,7 @@ void RunI32x4BinOpTest(ExecutionTier execution_tier, LowerSimd lower_simd, WASM_SIMD_CHECK_SPLAT4(I32x4, simd1, I32, expected), WASM_ONE); FOR_INT32_INPUTS(i) { - FOR_INT32_INPUTS(j) { CHECK_EQ(1, r.Call(*i, *j, expected_op(*i, *j))); } + FOR_INT32_INPUTS(j) { CHECK_EQ(1, r.Call(i, j, expected_op(i, j))); } } } @@ -1023,7 +1023,7 @@ void RunI32x4CompareOpTest(ExecutionTier execution_tier, LowerSimd lower_simd, WASM_SIMD_CHECK_SPLAT4(I32x4, simd1, I32, expected), WASM_ONE); FOR_INT32_INPUTS(i) { - FOR_INT32_INPUTS(j) { CHECK_EQ(1, r.Call(*i, *j, expected_op(*i, *j))); } + FOR_INT32_INPUTS(j) { CHECK_EQ(1, r.Call(i, j, expected_op(i, j))); } } } @@ -1084,7 +1084,7 @@ void RunI32x4ShiftOpTest(ExecutionTier execution_tier, LowerSimd lower_simd, simd, WASM_SIMD_SHIFT_OP(simd_op, shift, WASM_GET_LOCAL(simd))), WASM_SIMD_CHECK_SPLAT4(I32x4, simd, I32, expected), WASM_ONE); - FOR_INT32_INPUTS(i) { CHECK_EQ(1, r.Call(*i, expected_op(*i, shift))); } + FOR_INT32_INPUTS(i) { CHECK_EQ(1, r.Call(i, expected_op(i, shift))); } } } @@ -1140,9 +1140,9 @@ WASM_SIMD_TEST(I16x8ConvertI8x16) { WASM_ONE); FOR_INT8_INPUTS(i) { - int32_t unpacked_signed = static_cast<int32_t>(Widen<int8_t>(*i)); - int32_t unpacked_unsigned = static_cast<int32_t>(UnsignedWiden<int8_t>(*i)); - CHECK_EQ(1, r.Call(*i, unpacked_signed, unpacked_unsigned, 0)); + int32_t unpacked_signed = static_cast<int32_t>(Widen<int8_t>(i)); + int32_t unpacked_unsigned = static_cast<int32_t>(UnsignedWiden<int8_t>(i)); + CHECK_EQ(1, r.Call(i, unpacked_signed, unpacked_unsigned, 0)); } } @@ -1156,7 +1156,7 @@ void RunI16x8UnOpTest(ExecutionTier execution_tier, LowerSimd lower_simd, WASM_SET_LOCAL(simd, WASM_SIMD_UNOP(simd_op, WASM_GET_LOCAL(simd))), WASM_SIMD_CHECK_SPLAT8(I16x8, simd, I32, expected), WASM_ONE); - FOR_INT16_INPUTS(i) { CHECK_EQ(1, r.Call(*i, expected_op(*i))); } + FOR_INT16_INPUTS(i) { CHECK_EQ(1, r.Call(i, expected_op(i))); } } WASM_SIMD_TEST(I16x8Neg) { @@ -1196,15 +1196,15 @@ WASM_SIMD_TEST(I16x8ConvertI32x4) { FOR_INT32_INPUTS(i) { FOR_INT32_INPUTS(j) { // packed signed values - int32_t ps_a = Narrow<int16_t>(*i); - int32_t ps_b = Narrow<int16_t>(*j); + int32_t ps_a = Narrow<int16_t>(i); + int32_t ps_b = Narrow<int16_t>(j); // packed unsigned values - int32_t pu_a = UnsignedNarrow<int16_t>(*i); - int32_t pu_b = UnsignedNarrow<int16_t>(*j); + int32_t pu_a = UnsignedNarrow<int16_t>(i); + int32_t pu_b = UnsignedNarrow<int16_t>(j); // Sign-extend here, since ExtractLane sign extends. if (pu_a & 0x8000) pu_a |= 0xFFFF0000; if (pu_b & 0x8000) pu_b |= 0xFFFF0000; - CHECK_EQ(1, r.Call(*i, *j, ps_a, ps_b, pu_a, pu_b)); + CHECK_EQ(1, r.Call(i, j, ps_a, ps_b, pu_a, pu_b)); } } } @@ -1224,7 +1224,7 @@ void RunI16x8BinOpTest(ExecutionTier execution_tier, LowerSimd lower_simd, WASM_SIMD_CHECK_SPLAT8(I16x8, simd1, I32, expected), WASM_ONE); FOR_INT16_INPUTS(i) { - FOR_INT16_INPUTS(j) { CHECK_EQ(1, r.Call(*i, *j, expected_op(*i, *j))); } + FOR_INT16_INPUTS(j) { CHECK_EQ(1, r.Call(i, j, expected_op(i, j))); } } } @@ -1296,7 +1296,7 @@ void RunI16x8CompareOpTest(ExecutionTier execution_tier, LowerSimd lower_simd, WASM_SIMD_CHECK_SPLAT8(I16x8, simd1, I32, expected), WASM_ONE); FOR_INT16_INPUTS(i) { - FOR_INT16_INPUTS(j) { CHECK_EQ(1, r.Call(*i, *j, expected_op(*i, *j))); } + FOR_INT16_INPUTS(j) { CHECK_EQ(1, r.Call(i, j, expected_op(i, j))); } } } @@ -1357,7 +1357,7 @@ void RunI16x8ShiftOpTest(ExecutionTier execution_tier, LowerSimd lower_simd, simd, WASM_SIMD_SHIFT_OP(simd_op, shift, WASM_GET_LOCAL(simd))), WASM_SIMD_CHECK_SPLAT8(I16x8, simd, I32, expected), WASM_ONE); - FOR_INT16_INPUTS(i) { CHECK_EQ(1, r.Call(*i, expected_op(*i, shift))); } + FOR_INT16_INPUTS(i) { CHECK_EQ(1, r.Call(i, expected_op(i, shift))); } } } @@ -1386,7 +1386,7 @@ void RunI8x16UnOpTest(ExecutionTier execution_tier, LowerSimd lower_simd, WASM_SET_LOCAL(simd, WASM_SIMD_UNOP(simd_op, WASM_GET_LOCAL(simd))), WASM_SIMD_CHECK_SPLAT16(I8x16, simd, I32, expected), WASM_ONE); - FOR_INT8_INPUTS(i) { CHECK_EQ(1, r.Call(*i, expected_op(*i))); } + FOR_INT8_INPUTS(i) { CHECK_EQ(1, r.Call(i, expected_op(i))); } } WASM_SIMD_TEST(I8x16Neg) { @@ -1428,15 +1428,15 @@ WASM_SIMD_TEST(I8x16ConvertI16x8) { FOR_INT16_INPUTS(i) { FOR_INT16_INPUTS(j) { // packed signed values - int32_t ps_a = Narrow<int8_t>(*i); - int32_t ps_b = Narrow<int8_t>(*j); + int32_t ps_a = Narrow<int8_t>(i); + int32_t ps_b = Narrow<int8_t>(j); // packed unsigned values - int32_t pu_a = UnsignedNarrow<int8_t>(*i); - int32_t pu_b = UnsignedNarrow<int8_t>(*j); + int32_t pu_a = UnsignedNarrow<int8_t>(i); + int32_t pu_b = UnsignedNarrow<int8_t>(j); // Sign-extend here, since ExtractLane sign extends. if (pu_a & 0x80) pu_a |= 0xFFFFFF00; if (pu_b & 0x80) pu_b |= 0xFFFFFF00; - CHECK_EQ(1, r.Call(*i, *j, ps_a, ps_b, pu_a, pu_b)); + CHECK_EQ(1, r.Call(i, j, ps_a, ps_b, pu_a, pu_b)); } } } @@ -1456,7 +1456,7 @@ void RunI8x16BinOpTest(ExecutionTier execution_tier, LowerSimd lower_simd, WASM_SIMD_CHECK_SPLAT16(I8x16, simd1, I32, expected), WASM_ONE); FOR_INT8_INPUTS(i) { - FOR_INT8_INPUTS(j) { CHECK_EQ(1, r.Call(*i, *j, expected_op(*i, *j))); } + FOR_INT8_INPUTS(j) { CHECK_EQ(1, r.Call(i, j, expected_op(i, j))); } } } @@ -1523,7 +1523,7 @@ void RunI8x16CompareOpTest(ExecutionTier execution_tier, LowerSimd lower_simd, WASM_SIMD_CHECK_SPLAT16(I8x16, simd1, I32, expected), WASM_ONE); FOR_INT8_INPUTS(i) { - FOR_INT8_INPUTS(j) { CHECK_EQ(1, r.Call(*i, *j, expected_op(*i, *j))); } + FOR_INT8_INPUTS(j) { CHECK_EQ(1, r.Call(i, j, expected_op(i, j))); } } } @@ -1589,7 +1589,7 @@ void RunI8x16ShiftOpTest(ExecutionTier execution_tier, LowerSimd lower_simd, simd, WASM_SIMD_SHIFT_OP(simd_op, shift, WASM_GET_LOCAL(simd))), WASM_SIMD_CHECK_SPLAT16(I8x16, simd, I32, expected), WASM_ONE); - FOR_INT8_INPUTS(i) { CHECK_EQ(1, r.Call(*i, expected_op(*i, shift))); } + FOR_INT8_INPUTS(i) { CHECK_EQ(1, r.Call(i, expected_op(i, shift))); } } } @@ -2334,7 +2334,7 @@ WASM_SIMD_COMPILED_TEST(SimdLoadStoreLoad) { WASM_SIMD_I32x4_EXTRACT_LANE(0, WASM_SIMD_LOAD_MEM(WASM_I32V(4)))); FOR_INT32_INPUTS(i) { - int32_t expected = *i; + int32_t expected = i; r.builder().WriteMemory(&memory[1], expected); CHECK_EQ(expected, r.Call()); } @@ -2356,9 +2356,9 @@ WASM_SIMD_COMPILED_TEST(SimdLoadStoreLoad) { DCHECK_EQ(1, r.Call(5)); \ DCHECK_EQ(0, r.Call(0)); \ } -WASM_SIMD_ANYTRUE_TEST(32x4, 4, 0xffffffff); -WASM_SIMD_ANYTRUE_TEST(16x8, 8, 0xffff); -WASM_SIMD_ANYTRUE_TEST(8x16, 16, 0xff); +WASM_SIMD_ANYTRUE_TEST(32x4, 4, 0xffffffff) +WASM_SIMD_ANYTRUE_TEST(16x8, 8, 0xffff) +WASM_SIMD_ANYTRUE_TEST(8x16, 16, 0xff) #define WASM_SIMD_ALLTRUE_TEST(format, lanes, max) \ WASM_SIMD_TEST_TURBOFAN(S##format##AllTrue) { \ @@ -2372,9 +2372,9 @@ WASM_SIMD_ANYTRUE_TEST(8x16, 16, 0xff); DCHECK_EQ(0, r.Call(21)); \ DCHECK_EQ(0, r.Call(0)); \ } -WASM_SIMD_ALLTRUE_TEST(32x4, 4, 0xffffffff); -WASM_SIMD_ALLTRUE_TEST(16x8, 8, 0xffff); -WASM_SIMD_ALLTRUE_TEST(8x16, 16, 0xff); +WASM_SIMD_ALLTRUE_TEST(32x4, 4, 0xffffffff) +WASM_SIMD_ALLTRUE_TEST(16x8, 8, 0xffff) +WASM_SIMD_ALLTRUE_TEST(8x16, 16, 0xff) #endif // V8_TARGET_ARCH_X64 || V8_TARGET_ARCH_IA32 WASM_SIMD_TEST_TURBOFAN(BitSelect) { diff --git a/deps/v8/test/cctest/wasm/test-run-wasm.cc b/deps/v8/test/cctest/wasm/test-run-wasm.cc index 7e6ba47448..ef481bc929 100644 --- a/deps/v8/test/cctest/wasm/test-run-wasm.cc +++ b/deps/v8/test/cctest/wasm/test-run-wasm.cc @@ -38,7 +38,7 @@ WASM_EXEC_TEST(Int32Const) { WASM_EXEC_TEST(Int32Const_many) { FOR_INT32_INPUTS(i) { WasmRunner<int32_t> r(execution_tier); - const int32_t kExpectedValue = *i; + const int32_t kExpectedValue = i; // return(kExpectedValue) BUILD(r, WASM_I32V(kExpectedValue)); CHECK_EQ(kExpectedValue, r.Call()); @@ -57,21 +57,21 @@ WASM_EXEC_TEST(Int32Param0) { WasmRunner<int32_t, int32_t> r(execution_tier); // return(local[0]) BUILD(r, WASM_GET_LOCAL(0)); - FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); } + FOR_INT32_INPUTS(i) { CHECK_EQ(i, r.Call(i)); } } WASM_EXEC_TEST(Int32Param0_fallthru) { WasmRunner<int32_t, int32_t> r(execution_tier); // local[0] BUILD(r, WASM_GET_LOCAL(0)); - FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); } + FOR_INT32_INPUTS(i) { CHECK_EQ(i, r.Call(i)); } } WASM_EXEC_TEST(Int32Param1) { WasmRunner<int32_t, int32_t, int32_t> r(execution_tier); // local[1] BUILD(r, WASM_GET_LOCAL(1)); - FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(-111, *i)); } + FOR_INT32_INPUTS(i) { CHECK_EQ(i, r.Call(-111, i)); } } WASM_EXEC_TEST(Int32Add) { @@ -85,14 +85,14 @@ WASM_EXEC_TEST(Int32Add_P) { WasmRunner<int32_t, int32_t> r(execution_tier); // p0 + 13 BUILD(r, WASM_I32_ADD(WASM_I32V_1(13), WASM_GET_LOCAL(0))); - FOR_INT32_INPUTS(i) { CHECK_EQ(base::AddWithWraparound(*i, 13), r.Call(*i)); } + FOR_INT32_INPUTS(i) { CHECK_EQ(base::AddWithWraparound(i, 13), r.Call(i)); } } WASM_EXEC_TEST(Int32Add_P_fallthru) { WasmRunner<int32_t, int32_t> r(execution_tier); // p0 + 13 BUILD(r, WASM_I32_ADD(WASM_I32V_1(13), WASM_GET_LOCAL(0))); - FOR_INT32_INPUTS(i) { CHECK_EQ(base::AddWithWraparound(*i, 13), r.Call(*i)); } + FOR_INT32_INPUTS(i) { CHECK_EQ(base::AddWithWraparound(i, 13), r.Call(i)); } } static void RunInt32AddTest(ExecutionTier execution_tier, const byte* code, @@ -104,9 +104,9 @@ static void RunInt32AddTest(ExecutionTier execution_tier, const byte* code, r.Build(code, code + size); FOR_INT32_INPUTS(i) { FOR_INT32_INPUTS(j) { - int32_t expected = static_cast<int32_t>(static_cast<uint32_t>(*i) + - static_cast<uint32_t>(*j)); - CHECK_EQ(expected, r.Call(*i, *j)); + int32_t expected = static_cast<int32_t>(static_cast<uint32_t>(i) + + static_cast<uint32_t>(j)); + CHECK_EQ(expected, r.Call(i, j)); } } } @@ -168,8 +168,8 @@ static void TestInt32Binop(ExecutionTier execution_tier, WasmOpcode opcode, FOR_INT32_INPUTS(j) { WasmRunner<ctype> r(execution_tier); // Apply {opcode} on two constants. - BUILD(r, WASM_BINOP(opcode, WASM_I32V(*i), WASM_I32V(*j))); - CHECK_EQ(expected(*i, *j), r.Call()); + BUILD(r, WASM_BINOP(opcode, WASM_I32V(i), WASM_I32V(j))); + CHECK_EQ(expected(i, j), r.Call()); } } { @@ -178,7 +178,7 @@ static void TestInt32Binop(ExecutionTier execution_tier, WasmOpcode opcode, BUILD(r, WASM_BINOP(opcode, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); FOR_INT32_INPUTS(i) { FOR_INT32_INPUTS(j) { - CHECK_EQ(expected(*i, *j), r.Call(*i, *j)); + CHECK_EQ(expected(i, j), r.Call(i, j)); } } } @@ -204,7 +204,7 @@ WASM_I32_BINOP_TEST(RemU, uint32_t, b == 0 ? 0xDEADBEEF : a % b) WASM_I32_BINOP_TEST(And, int32_t, a& b) WASM_I32_BINOP_TEST(Ior, int32_t, a | b) WASM_I32_BINOP_TEST(Xor, int32_t, a ^ b) -WASM_I32_BINOP_TEST(Shl, int32_t, a << (b & 0x1F)) +WASM_I32_BINOP_TEST(Shl, int32_t, base::ShlWithWraparound(a, b)) WASM_I32_BINOP_TEST(ShrU, uint32_t, a >> (b & 0x1F)) WASM_I32_BINOP_TEST(ShrS, int32_t, a >> (b & 0x1F)) WASM_I32_BINOP_TEST(Ror, uint32_t, (a >> (b & 0x1F)) | (a << ((32 - b) & 0x1F))) @@ -392,11 +392,11 @@ WASM_EXEC_TEST(Int32AsmjsDivS_byzero_const) { BUILD(r, WASM_I32_ASMJS_DIVS(WASM_GET_LOCAL(0), WASM_I32V_1(denom))); FOR_INT32_INPUTS(i) { if (denom == 0) { - CHECK_EQ(0, r.Call(*i)); - } else if (denom == -1 && *i == std::numeric_limits<int32_t>::min()) { - CHECK_EQ(std::numeric_limits<int32_t>::min(), r.Call(*i)); + CHECK_EQ(0, r.Call(i)); + } else if (denom == -1 && i == std::numeric_limits<int32_t>::min()) { + CHECK_EQ(std::numeric_limits<int32_t>::min(), r.Call(i)); } else { - CHECK_EQ(*i / denom, r.Call(*i)); + CHECK_EQ(i / denom, r.Call(i)); } } } @@ -409,11 +409,11 @@ WASM_EXEC_TEST(Int32AsmjsRemS_byzero_const) { BUILD(r, WASM_I32_ASMJS_REMS(WASM_GET_LOCAL(0), WASM_I32V_1(denom))); FOR_INT32_INPUTS(i) { if (denom == 0) { - CHECK_EQ(0, r.Call(*i)); - } else if (denom == -1 && *i == std::numeric_limits<int32_t>::min()) { - CHECK_EQ(0, r.Call(*i)); + CHECK_EQ(0, r.Call(i)); + } else if (denom == -1 && i == std::numeric_limits<int32_t>::min()) { + CHECK_EQ(0, r.Call(i)); } else { - CHECK_EQ(*i % denom, r.Call(*i)); + CHECK_EQ(i % denom, r.Call(i)); } } } @@ -605,8 +605,7 @@ WASM_EXEC_TEST(Float32Neg) { BUILD(r, WASM_F32_NEG(WASM_GET_LOCAL(0))); FOR_FLOAT32_INPUTS(i) { - CHECK_EQ(0x80000000, - bit_cast<uint32_t>(*i) ^ bit_cast<uint32_t>(r.Call(*i))); + CHECK_EQ(0x80000000, bit_cast<uint32_t>(i) ^ bit_cast<uint32_t>(r.Call(i))); } } @@ -616,7 +615,7 @@ WASM_EXEC_TEST(Float64Neg) { FOR_FLOAT64_INPUTS(i) { CHECK_EQ(0x8000000000000000, - bit_cast<uint64_t>(*i) ^ bit_cast<uint64_t>(r.Call(*i))); + bit_cast<uint64_t>(i) ^ bit_cast<uint64_t>(r.Call(i))); } } @@ -627,36 +626,36 @@ WASM_EXEC_TEST(IfElse_P) { WASM_I32V_1(11), // -- WASM_I32V_1(22))); // -- FOR_INT32_INPUTS(i) { - int32_t expected = *i ? 11 : 22; - CHECK_EQ(expected, r.Call(*i)); + int32_t expected = i ? 11 : 22; + CHECK_EQ(expected, r.Call(i)); } } WASM_EXEC_TEST(If_empty1) { WasmRunner<uint32_t, uint32_t, uint32_t> r(execution_tier); BUILD(r, WASM_GET_LOCAL(0), kExprIf, kLocalVoid, kExprEnd, WASM_GET_LOCAL(1)); - FOR_UINT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i - 9, *i)); } + FOR_UINT32_INPUTS(i) { CHECK_EQ(i, r.Call(i - 9, i)); } } WASM_EXEC_TEST(IfElse_empty1) { WasmRunner<uint32_t, uint32_t, uint32_t> r(execution_tier); BUILD(r, WASM_GET_LOCAL(0), kExprIf, kLocalVoid, kExprElse, kExprEnd, WASM_GET_LOCAL(1)); - FOR_UINT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i - 8, *i)); } + FOR_UINT32_INPUTS(i) { CHECK_EQ(i, r.Call(i - 8, i)); } } WASM_EXEC_TEST(IfElse_empty2) { WasmRunner<uint32_t, uint32_t, uint32_t> r(execution_tier); BUILD(r, WASM_GET_LOCAL(0), kExprIf, kLocalVoid, WASM_NOP, kExprElse, kExprEnd, WASM_GET_LOCAL(1)); - FOR_UINT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i - 7, *i)); } + FOR_UINT32_INPUTS(i) { CHECK_EQ(i, r.Call(i - 7, i)); } } WASM_EXEC_TEST(IfElse_empty3) { WasmRunner<uint32_t, uint32_t, uint32_t> r(execution_tier); BUILD(r, WASM_GET_LOCAL(0), kExprIf, kLocalVoid, kExprElse, WASM_NOP, kExprEnd, WASM_GET_LOCAL(1)); - FOR_UINT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i - 6, *i)); } + FOR_UINT32_INPUTS(i) { CHECK_EQ(i, r.Call(i - 6, i)); } } WASM_EXEC_TEST(If_chain1) { @@ -664,7 +663,7 @@ WASM_EXEC_TEST(If_chain1) { // if (p0) 13; if (p0) 14; 15 BUILD(r, WASM_IF(WASM_GET_LOCAL(0), WASM_NOP), WASM_IF(WASM_GET_LOCAL(0), WASM_NOP), WASM_I32V_1(15)); - FOR_INT32_INPUTS(i) { CHECK_EQ(15, r.Call(*i)); } + FOR_INT32_INPUTS(i) { CHECK_EQ(15, r.Call(i)); } } WASM_EXEC_TEST(If_chain_set) { @@ -674,8 +673,8 @@ WASM_EXEC_TEST(If_chain_set) { WASM_IF(WASM_GET_LOCAL(0), WASM_SET_LOCAL(1, WASM_I32V_2(74))), WASM_GET_LOCAL(1)); FOR_INT32_INPUTS(i) { - int32_t expected = *i ? 74 : *i; - CHECK_EQ(expected, r.Call(*i, *i)); + int32_t expected = i ? 74 : i; + CHECK_EQ(expected, r.Call(i, i)); } } @@ -716,7 +715,7 @@ WASM_EXEC_TEST(Return_I32) { BUILD(r, RET(WASM_GET_LOCAL(0))); - FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); } + FOR_INT32_INPUTS(i) { CHECK_EQ(i, r.Call(i)); } } WASM_EXEC_TEST(Return_F32) { @@ -725,7 +724,7 @@ WASM_EXEC_TEST(Return_F32) { BUILD(r, RET(WASM_GET_LOCAL(0))); FOR_FLOAT32_INPUTS(i) { - float expect = *i; + float expect = i; float result = r.Call(expect); if (std::isnan(expect)) { CHECK(std::isnan(result)); @@ -741,7 +740,7 @@ WASM_EXEC_TEST(Return_F64) { BUILD(r, RET(WASM_GET_LOCAL(0))); FOR_FLOAT64_INPUTS(i) { - double expect = *i; + double expect = i; double result = r.Call(expect); if (std::isnan(expect)) { CHECK(std::isnan(result)); @@ -764,8 +763,8 @@ WASM_EXEC_TEST(Select) { // return select(11, 22, a); BUILD(r, WASM_SELECT(WASM_I32V_1(11), WASM_I32V_1(22), WASM_GET_LOCAL(0))); FOR_INT32_INPUTS(i) { - int32_t expected = *i ? 11 : 22; - CHECK_EQ(expected, r.Call(*i)); + int32_t expected = i ? 11 : 22; + CHECK_EQ(expected, r.Call(i)); } } @@ -776,7 +775,7 @@ WASM_EXEC_TEST(Select_strict1) { WASM_TEE_LOCAL(0, WASM_I32V_1(1)), WASM_TEE_LOCAL(0, WASM_I32V_1(2))), WASM_DROP, WASM_GET_LOCAL(0)); - FOR_INT32_INPUTS(i) { CHECK_EQ(2, r.Call(*i)); } + FOR_INT32_INPUTS(i) { CHECK_EQ(2, r.Call(i)); } } WASM_EXEC_TEST(Select_strict2) { @@ -787,8 +786,8 @@ WASM_EXEC_TEST(Select_strict2) { BUILD(r, WASM_SELECT(WASM_TEE_LOCAL(1, WASM_I32V_1(5)), WASM_TEE_LOCAL(2, WASM_I32V_1(6)), WASM_GET_LOCAL(0))); FOR_INT32_INPUTS(i) { - int32_t expected = *i ? 5 : 6; - CHECK_EQ(expected, r.Call(*i)); + int32_t expected = i ? 5 : 6; + CHECK_EQ(expected, r.Call(i)); } } @@ -802,7 +801,7 @@ WASM_EXEC_TEST(Select_strict3) { WASM_TEE_LOCAL(0, WASM_GET_LOCAL(1)))); FOR_INT32_INPUTS(i) { int32_t expected = 5; - CHECK_EQ(expected, r.Call(*i)); + CHECK_EQ(expected, r.Call(i)); } } @@ -811,7 +810,7 @@ WASM_EXEC_TEST(BrIf_strict) { BUILD(r, WASM_BLOCK_I(WASM_BRV_IF(0, WASM_GET_LOCAL(0), WASM_TEE_LOCAL(0, WASM_I32V_2(99))))); - FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); } + FOR_INT32_INPUTS(i) { CHECK_EQ(i, r.Call(i)); } } WASM_EXEC_TEST(Br_height) { @@ -839,7 +838,7 @@ WASM_EXEC_TEST(BrTable0a) { WasmRunner<int32_t, int32_t> r(execution_tier); BUILD(r, B1(B1(WASM_BR_TABLE(WASM_GET_LOCAL(0), 0, BR_TARGET(0)))), WASM_I32V_2(91)); - FOR_INT32_INPUTS(i) { CHECK_EQ(91, r.Call(*i)); } + FOR_INT32_INPUTS(i) { CHECK_EQ(91, r.Call(i)); } } WASM_EXEC_TEST(BrTable0b) { @@ -847,7 +846,7 @@ WASM_EXEC_TEST(BrTable0b) { BUILD(r, B1(B1(WASM_BR_TABLE(WASM_GET_LOCAL(0), 1, BR_TARGET(0), BR_TARGET(0)))), WASM_I32V_2(92)); - FOR_INT32_INPUTS(i) { CHECK_EQ(92, r.Call(*i)); } + FOR_INT32_INPUTS(i) { CHECK_EQ(92, r.Call(i)); } } WASM_EXEC_TEST(BrTable0c) { @@ -858,15 +857,15 @@ WASM_EXEC_TEST(BrTable0c) { RET_I8(76))), WASM_I32V_2(77)); FOR_INT32_INPUTS(i) { - int32_t expected = *i == 0 ? 76 : 77; - CHECK_EQ(expected, r.Call(*i)); + int32_t expected = i == 0 ? 76 : 77; + CHECK_EQ(expected, r.Call(i)); } } WASM_EXEC_TEST(BrTable1) { WasmRunner<int32_t, int32_t> r(execution_tier); BUILD(r, B1(WASM_BR_TABLE(WASM_GET_LOCAL(0), 0, BR_TARGET(0))), RET_I8(93)); - FOR_INT32_INPUTS(i) { CHECK_EQ(93, r.Call(*i)); } + FOR_INT32_INPUTS(i) { CHECK_EQ(93, r.Call(i)); } } WASM_EXEC_TEST(BrTable_loop) { @@ -1021,7 +1020,7 @@ WASM_EXEC_TEST(F32ReinterpretI32) { WASM_LOAD_MEM(MachineType::Float32(), WASM_ZERO))); FOR_INT32_INPUTS(i) { - int32_t expected = *i; + int32_t expected = i; r.builder().WriteMemory(&memory[0], expected); CHECK_EQ(expected, r.Call()); } @@ -1037,7 +1036,7 @@ WASM_EXEC_TEST(I32ReinterpretF32) { WASM_I32V_2(107)); FOR_INT32_INPUTS(i) { - int32_t expected = *i; + int32_t expected = i; CHECK_EQ(107, r.Call(expected)); CHECK_EQ(expected, r.builder().ReadMemory(&memory[0])); } @@ -1079,7 +1078,7 @@ WASM_EXEC_TEST(LoadStoreLoad) { WASM_LOAD_MEM(MachineType::Int32(), WASM_ZERO)); FOR_INT32_INPUTS(i) { - int32_t expected = *i; + int32_t expected = i; r.builder().WriteMemory(&memory[0], expected); CHECK_EQ(expected, r.Call()); } @@ -1170,61 +1169,61 @@ WASM_EXEC_TEST(VoidReturn2) { WASM_EXEC_TEST(BrEmpty) { WasmRunner<int32_t, int32_t> r(execution_tier); BUILD(r, WASM_BRV(0, WASM_GET_LOCAL(0))); - FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); } + FOR_INT32_INPUTS(i) { CHECK_EQ(i, r.Call(i)); } } WASM_EXEC_TEST(BrIfEmpty) { WasmRunner<int32_t, int32_t> r(execution_tier); BUILD(r, WASM_BRV_IF(0, WASM_GET_LOCAL(0), WASM_GET_LOCAL(0))); - FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); } + FOR_INT32_INPUTS(i) { CHECK_EQ(i, r.Call(i)); } } WASM_EXEC_TEST(Block_empty) { WasmRunner<int32_t, int32_t> r(execution_tier); BUILD(r, kExprBlock, kLocalVoid, kExprEnd, WASM_GET_LOCAL(0)); - FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); } + FOR_INT32_INPUTS(i) { CHECK_EQ(i, r.Call(i)); } } WASM_EXEC_TEST(Block_empty_br1) { WasmRunner<int32_t, int32_t> r(execution_tier); BUILD(r, B1(WASM_BR(0)), WASM_GET_LOCAL(0)); - FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); } + FOR_INT32_INPUTS(i) { CHECK_EQ(i, r.Call(i)); } } WASM_EXEC_TEST(Block_empty_brif1) { WasmRunner<int32_t, int32_t> r(execution_tier); BUILD(r, WASM_BLOCK(WASM_BR_IF(0, WASM_ZERO)), WASM_GET_LOCAL(0)); - FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); } + FOR_INT32_INPUTS(i) { CHECK_EQ(i, r.Call(i)); } } WASM_EXEC_TEST(Block_empty_brif2) { WasmRunner<uint32_t, uint32_t, uint32_t> r(execution_tier); BUILD(r, WASM_BLOCK(WASM_BR_IF(0, WASM_GET_LOCAL(1))), WASM_GET_LOCAL(0)); - FOR_UINT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i, *i + 1)); } + FOR_UINT32_INPUTS(i) { CHECK_EQ(i, r.Call(i, i + 1)); } } WASM_EXEC_TEST(Block_i) { WasmRunner<int32_t, int32_t> r(execution_tier); BUILD(r, WASM_BLOCK_I(WASM_GET_LOCAL(0))); - FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); } + FOR_INT32_INPUTS(i) { CHECK_EQ(i, r.Call(i)); } } WASM_EXEC_TEST(Block_f) { WasmRunner<float, float> r(execution_tier); BUILD(r, WASM_BLOCK_F(WASM_GET_LOCAL(0))); - FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(*i, r.Call(*i)); } + FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(i, r.Call(i)); } } WASM_EXEC_TEST(Block_d) { WasmRunner<double, double> r(execution_tier); BUILD(r, WASM_BLOCK_D(WASM_GET_LOCAL(0))); - FOR_FLOAT64_INPUTS(i) { CHECK_FLOAT_EQ(*i, r.Call(*i)); } + FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(i, r.Call(i)); } } WASM_EXEC_TEST(Block_br2) { WasmRunner<int32_t, int32_t> r(execution_tier); BUILD(r, WASM_BLOCK_I(WASM_BRV(0, WASM_GET_LOCAL(0)))); - FOR_UINT32_INPUTS(i) { CHECK_EQ(*i, static_cast<uint32_t>(r.Call(*i))); } + FOR_UINT32_INPUTS(i) { CHECK_EQ(i, static_cast<uint32_t>(r.Call(i))); } } WASM_EXEC_TEST(Block_If_P) { @@ -1235,51 +1234,51 @@ WASM_EXEC_TEST(Block_If_P) { WASM_BRV(1, WASM_I32V_1(51))), // -- WASM_I32V_1(52))); // -- FOR_INT32_INPUTS(i) { - int32_t expected = *i ? 51 : 52; - CHECK_EQ(expected, r.Call(*i)); + int32_t expected = i ? 51 : 52; + CHECK_EQ(expected, r.Call(i)); } } WASM_EXEC_TEST(Loop_empty) { WasmRunner<int32_t, int32_t> r(execution_tier); BUILD(r, kExprLoop, kLocalVoid, kExprEnd, WASM_GET_LOCAL(0)); - FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); } + FOR_INT32_INPUTS(i) { CHECK_EQ(i, r.Call(i)); } } WASM_EXEC_TEST(Loop_i) { WasmRunner<int32_t, int32_t> r(execution_tier); BUILD(r, WASM_LOOP_I(WASM_GET_LOCAL(0))); - FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); } + FOR_INT32_INPUTS(i) { CHECK_EQ(i, r.Call(i)); } } WASM_EXEC_TEST(Loop_f) { WasmRunner<float, float> r(execution_tier); BUILD(r, WASM_LOOP_F(WASM_GET_LOCAL(0))); - FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(*i, r.Call(*i)); } + FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(i, r.Call(i)); } } WASM_EXEC_TEST(Loop_d) { WasmRunner<double, double> r(execution_tier); BUILD(r, WASM_LOOP_D(WASM_GET_LOCAL(0))); - FOR_FLOAT64_INPUTS(i) { CHECK_FLOAT_EQ(*i, r.Call(*i)); } + FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(i, r.Call(i)); } } WASM_EXEC_TEST(Loop_empty_br1) { WasmRunner<int32_t, int32_t> r(execution_tier); BUILD(r, B1(WASM_LOOP(WASM_BR(1))), WASM_GET_LOCAL(0)); - FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); } + FOR_INT32_INPUTS(i) { CHECK_EQ(i, r.Call(i)); } } WASM_EXEC_TEST(Loop_empty_brif1) { WasmRunner<int32_t, int32_t> r(execution_tier); BUILD(r, B1(WASM_LOOP(WASM_BR_IF(1, WASM_ZERO))), WASM_GET_LOCAL(0)); - FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); } + FOR_INT32_INPUTS(i) { CHECK_EQ(i, r.Call(i)); } } WASM_EXEC_TEST(Loop_empty_brif2) { WasmRunner<uint32_t, uint32_t, uint32_t> r(execution_tier); BUILD(r, WASM_LOOP_I(WASM_BRV_IF(1, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)))); - FOR_UINT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i, *i + 1)); } + FOR_UINT32_INPUTS(i) { CHECK_EQ(i, r.Call(i, i + 1)); } } WASM_EXEC_TEST(Loop_empty_brif3) { @@ -1288,8 +1287,8 @@ WASM_EXEC_TEST(Loop_empty_brif3) { WASM_GET_LOCAL(1)); FOR_UINT32_INPUTS(i) { FOR_UINT32_INPUTS(j) { - CHECK_EQ(*i, r.Call(0, *i, *j)); - CHECK_EQ(*j, r.Call(1, *i, *j)); + CHECK_EQ(i, r.Call(0, i, j)); + CHECK_EQ(j, r.Call(1, i, j)); } } } @@ -1299,8 +1298,8 @@ WASM_EXEC_TEST(Block_BrIf_P) { BUILD(r, WASM_BLOCK_I(WASM_BRV_IFD(0, WASM_I32V_1(51), WASM_GET_LOCAL(0)), WASM_I32V_1(52))); FOR_INT32_INPUTS(i) { - int32_t expected = *i ? 51 : 52; - CHECK_EQ(expected, r.Call(*i)); + int32_t expected = i ? 51 : 52; + CHECK_EQ(expected, r.Call(i)); } } @@ -1313,8 +1312,8 @@ WASM_EXEC_TEST(Block_IfElse_P_assign) { WASM_SET_LOCAL(0, WASM_I32V_2(72))), // -- WASM_GET_LOCAL(0)); FOR_INT32_INPUTS(i) { - int32_t expected = *i ? 71 : 72; - CHECK_EQ(expected, r.Call(*i)); + int32_t expected = i ? 71 : 72; + CHECK_EQ(expected, r.Call(i)); } } @@ -1327,8 +1326,8 @@ WASM_EXEC_TEST(Block_IfElse_P_return) { RET_I8(82)), // -- WASM_ZERO); // -- FOR_INT32_INPUTS(i) { - int32_t expected = *i ? 81 : 82; - CHECK_EQ(expected, r.Call(*i)); + int32_t expected = i ? 81 : 82; + CHECK_EQ(expected, r.Call(i)); } } @@ -1338,8 +1337,8 @@ WASM_EXEC_TEST(Block_If_P_assign) { BUILD(r, WASM_IF(WASM_GET_LOCAL(0), WASM_SET_LOCAL(0, WASM_I32V_1(61))), WASM_GET_LOCAL(0)); FOR_INT32_INPUTS(i) { - int32_t expected = *i ? 61 : *i; - CHECK_EQ(expected, r.Call(*i)); + int32_t expected = i ? 61 : i; + CHECK_EQ(expected, r.Call(i)); } } @@ -1357,8 +1356,8 @@ WASM_EXEC_TEST(ExprIf_P) { WASM_I32V_1(11), // -- WASM_I32V_1(22))); // -- FOR_INT32_INPUTS(i) { - int32_t expected = *i ? 11 : 22; - CHECK_EQ(expected, r.Call(*i)); + int32_t expected = i ? 11 : 22; + CHECK_EQ(expected, r.Call(i)); } } @@ -2039,7 +2038,7 @@ WASM_EXEC_TEST(Int32LoadInt16_signext) { BUILD(r, WASM_LOAD_MEM(MachineType::Int16(), WASM_GET_LOCAL(0))); for (int i = 0; i < kNumBytes; i += 2) { - int32_t expected = memory[i] | (static_cast<int8_t>(memory[i + 1]) << 8); + int32_t expected = static_cast<int16_t>(memory[i] | (memory[i + 1] << 8)); CHECK_EQ(expected, r.Call(i)); } } @@ -2275,9 +2274,9 @@ WASM_EXEC_TEST(Call_Int32Add) { FOR_INT32_INPUTS(i) { FOR_INT32_INPUTS(j) { - int32_t expected = static_cast<int32_t>(static_cast<uint32_t>(*i) + - static_cast<uint32_t>(*j)); - CHECK_EQ(expected, r.Call(*i, *j)); + int32_t expected = static_cast<int32_t>(static_cast<uint32_t>(i) + + static_cast<uint32_t>(j)); + CHECK_EQ(expected, r.Call(i, j)); } } } @@ -2294,7 +2293,7 @@ WASM_EXEC_TEST(Call_Float32Sub) { WASM_GET_LOCAL(1))); FOR_FLOAT32_INPUTS(i) { - FOR_FLOAT32_INPUTS(j) { CHECK_FLOAT_EQ(*i - *j, r.Call(*i, *j)); } + FOR_FLOAT32_INPUTS(j) { CHECK_FLOAT_EQ(i - j, r.Call(i, j)); } } } @@ -2312,9 +2311,9 @@ WASM_EXEC_TEST(Call_Float64Sub) { FOR_FLOAT64_INPUTS(i) { FOR_FLOAT64_INPUTS(j) { - r.builder().WriteMemory(&memory[0], *i); - r.builder().WriteMemory(&memory[1], *j); - double expected = *i - *j; + r.builder().WriteMemory(&memory[0], i); + r.builder().WriteMemory(&memory[1], j); + double expected = i - j; CHECK_EQ(107, r.Call()); if (expected != expected) { @@ -2445,9 +2444,9 @@ WASM_EXEC_TEST(MultiReturnSub) { FOR_INT32_INPUTS(i) { FOR_INT32_INPUTS(j) { - int32_t expected = static_cast<int32_t>(static_cast<uint32_t>(*j) - - static_cast<uint32_t>(*i)); - CHECK_EQ(expected, r.Call(*i, *j)); + int32_t expected = static_cast<int32_t>(static_cast<uint32_t>(j) - + static_cast<uint32_t>(i)); + CHECK_EQ(expected, r.Call(i, j)); } } } @@ -2779,56 +2778,56 @@ WASM_EXEC_TEST(F32Floor) { WasmRunner<float, float> r(execution_tier); BUILD(r, WASM_F32_FLOOR(WASM_GET_LOCAL(0))); - FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(floorf(*i), r.Call(*i)); } + FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(floorf(i), r.Call(i)); } } WASM_EXEC_TEST(F32Ceil) { WasmRunner<float, float> r(execution_tier); BUILD(r, WASM_F32_CEIL(WASM_GET_LOCAL(0))); - FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(ceilf(*i), r.Call(*i)); } + FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(ceilf(i), r.Call(i)); } } WASM_EXEC_TEST(F32Trunc) { WasmRunner<float, float> r(execution_tier); BUILD(r, WASM_F32_TRUNC(WASM_GET_LOCAL(0))); - FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(truncf(*i), r.Call(*i)); } + FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(truncf(i), r.Call(i)); } } WASM_EXEC_TEST(F32NearestInt) { WasmRunner<float, float> r(execution_tier); BUILD(r, WASM_F32_NEARESTINT(WASM_GET_LOCAL(0))); - FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(nearbyintf(*i), r.Call(*i)); } + FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(nearbyintf(i), r.Call(i)); } } WASM_EXEC_TEST(F64Floor) { WasmRunner<double, double> r(execution_tier); BUILD(r, WASM_F64_FLOOR(WASM_GET_LOCAL(0))); - FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(floor(*i), r.Call(*i)); } + FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(floor(i), r.Call(i)); } } WASM_EXEC_TEST(F64Ceil) { WasmRunner<double, double> r(execution_tier); BUILD(r, WASM_F64_CEIL(WASM_GET_LOCAL(0))); - FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ceil(*i), r.Call(*i)); } + FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ceil(i), r.Call(i)); } } WASM_EXEC_TEST(F64Trunc) { WasmRunner<double, double> r(execution_tier); BUILD(r, WASM_F64_TRUNC(WASM_GET_LOCAL(0))); - FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(trunc(*i), r.Call(*i)); } + FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(trunc(i), r.Call(i)); } } WASM_EXEC_TEST(F64NearestInt) { WasmRunner<double, double> r(execution_tier); BUILD(r, WASM_F64_NEARESTINT(WASM_GET_LOCAL(0))); - FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(nearbyint(*i), r.Call(*i)); } + FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(nearbyint(i), r.Call(i)); } } WASM_EXEC_TEST(F32Min) { @@ -2836,7 +2835,7 @@ WASM_EXEC_TEST(F32Min) { BUILD(r, WASM_F32_MIN(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); FOR_FLOAT32_INPUTS(i) { - FOR_FLOAT32_INPUTS(j) { CHECK_DOUBLE_EQ(JSMin(*i, *j), r.Call(*i, *j)); } + FOR_FLOAT32_INPUTS(j) { CHECK_DOUBLE_EQ(JSMin(i, j), r.Call(i, j)); } } } @@ -2852,7 +2851,7 @@ WASM_EXEC_TEST(F64Min) { BUILD(r, WASM_F64_MIN(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); FOR_FLOAT64_INPUTS(i) { - FOR_FLOAT64_INPUTS(j) { CHECK_DOUBLE_EQ(JSMin(*i, *j), r.Call(*i, *j)); } + FOR_FLOAT64_INPUTS(j) { CHECK_DOUBLE_EQ(JSMin(i, j), r.Call(i, j)); } } } @@ -2868,7 +2867,7 @@ WASM_EXEC_TEST(F32Max) { BUILD(r, WASM_F32_MAX(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); FOR_FLOAT32_INPUTS(i) { - FOR_FLOAT32_INPUTS(j) { CHECK_FLOAT_EQ(JSMax(*i, *j), r.Call(*i, *j)); } + FOR_FLOAT32_INPUTS(j) { CHECK_FLOAT_EQ(JSMax(i, j), r.Call(i, j)); } } } @@ -2885,8 +2884,8 @@ WASM_EXEC_TEST(F64Max) { FOR_FLOAT64_INPUTS(i) { FOR_FLOAT64_INPUTS(j) { - double result = r.Call(*i, *j); - CHECK_DOUBLE_EQ(JSMax(*i, *j), result); + double result = r.Call(i, j); + CHECK_DOUBLE_EQ(JSMax(i, j), result); } } } @@ -2903,10 +2902,10 @@ WASM_EXEC_TEST(I32SConvertF32) { BUILD(r, WASM_I32_SCONVERT_F32(WASM_GET_LOCAL(0))); FOR_FLOAT32_INPUTS(i) { - if (is_inbounds<int32_t>(*i)) { - CHECK_EQ(static_cast<int32_t>(*i), r.Call(*i)); + if (is_inbounds<int32_t>(i)) { + CHECK_EQ(static_cast<int32_t>(i), r.Call(i)); } else { - CHECK_TRAP32(r.Call(*i)); + CHECK_TRAP32(r.Call(i)); } } } @@ -2918,12 +2917,12 @@ WASM_EXEC_TEST(I32SConvertSatF32) { FOR_FLOAT32_INPUTS(i) { int32_t expected = - is_inbounds<int32_t>(*i) - ? static_cast<int32_t>(*i) - : std::isnan(*i) ? 0 - : *i < 0.0 ? std::numeric_limits<int32_t>::min() - : std::numeric_limits<int32_t>::max(); - int32_t found = r.Call(*i); + is_inbounds<int32_t>(i) + ? static_cast<int32_t>(i) + : std::isnan(i) ? 0 + : i < 0.0 ? std::numeric_limits<int32_t>::min() + : std::numeric_limits<int32_t>::max(); + int32_t found = r.Call(i); CHECK_EQ(expected, found); } } @@ -2933,10 +2932,10 @@ WASM_EXEC_TEST(I32SConvertF64) { BUILD(r, WASM_I32_SCONVERT_F64(WASM_GET_LOCAL(0))); FOR_FLOAT64_INPUTS(i) { - if (is_inbounds<int32_t>(*i)) { - CHECK_EQ(static_cast<int32_t>(*i), r.Call(*i)); + if (is_inbounds<int32_t>(i)) { + CHECK_EQ(static_cast<int32_t>(i), r.Call(i)); } else { - CHECK_TRAP32(r.Call(*i)); + CHECK_TRAP32(r.Call(i)); } } } @@ -2947,12 +2946,12 @@ WASM_EXEC_TEST(I32SConvertSatF64) { BUILD(r, WASM_I32_SCONVERT_SAT_F64(WASM_GET_LOCAL(0))); FOR_FLOAT64_INPUTS(i) { int32_t expected = - is_inbounds<int32_t>(*i) - ? static_cast<int32_t>(*i) - : std::isnan(*i) ? 0 - : *i < 0.0 ? std::numeric_limits<int32_t>::min() - : std::numeric_limits<int32_t>::max(); - int32_t found = r.Call(*i); + is_inbounds<int32_t>(i) + ? static_cast<int32_t>(i) + : std::isnan(i) ? 0 + : i < 0.0 ? std::numeric_limits<int32_t>::min() + : std::numeric_limits<int32_t>::max(); + int32_t found = r.Call(i); CHECK_EQ(expected, found); } } @@ -2961,10 +2960,10 @@ WASM_EXEC_TEST(I32UConvertF32) { WasmRunner<uint32_t, float> r(execution_tier); BUILD(r, WASM_I32_UCONVERT_F32(WASM_GET_LOCAL(0))); FOR_FLOAT32_INPUTS(i) { - if (is_inbounds<uint32_t>(*i)) { - CHECK_EQ(static_cast<uint32_t>(*i), r.Call(*i)); + if (is_inbounds<uint32_t>(i)) { + CHECK_EQ(static_cast<uint32_t>(i), r.Call(i)); } else { - CHECK_TRAP32(r.Call(*i)); + CHECK_TRAP32(r.Call(i)); } } } @@ -2975,12 +2974,12 @@ WASM_EXEC_TEST(I32UConvertSatF32) { BUILD(r, WASM_I32_UCONVERT_SAT_F32(WASM_GET_LOCAL(0))); FOR_FLOAT32_INPUTS(i) { int32_t expected = - is_inbounds<uint32_t>(*i) - ? static_cast<uint32_t>(*i) - : std::isnan(*i) ? 0 - : *i < 0.0 ? std::numeric_limits<uint32_t>::min() - : std::numeric_limits<uint32_t>::max(); - int32_t found = r.Call(*i); + is_inbounds<uint32_t>(i) + ? static_cast<uint32_t>(i) + : std::isnan(i) ? 0 + : i < 0.0 ? std::numeric_limits<uint32_t>::min() + : std::numeric_limits<uint32_t>::max(); + int32_t found = r.Call(i); CHECK_EQ(expected, found); } } @@ -2989,10 +2988,10 @@ WASM_EXEC_TEST(I32UConvertF64) { WasmRunner<uint32_t, double> r(execution_tier); BUILD(r, WASM_I32_UCONVERT_F64(WASM_GET_LOCAL(0))); FOR_FLOAT64_INPUTS(i) { - if (is_inbounds<uint32_t>(*i)) { - CHECK_EQ(static_cast<uint32_t>(*i), r.Call(*i)); + if (is_inbounds<uint32_t>(i)) { + CHECK_EQ(static_cast<uint32_t>(i), r.Call(i)); } else { - CHECK_TRAP32(r.Call(*i)); + CHECK_TRAP32(r.Call(i)); } } } @@ -3003,12 +3002,12 @@ WASM_EXEC_TEST(I32UConvertSatF64) { BUILD(r, WASM_I32_UCONVERT_SAT_F64(WASM_GET_LOCAL(0))); FOR_FLOAT64_INPUTS(i) { int32_t expected = - is_inbounds<uint32_t>(*i) - ? static_cast<uint32_t>(*i) - : std::isnan(*i) ? 0 - : *i < 0.0 ? std::numeric_limits<uint32_t>::min() - : std::numeric_limits<uint32_t>::max(); - int32_t found = r.Call(*i); + is_inbounds<uint32_t>(i) + ? static_cast<uint32_t>(i) + : std::isnan(i) ? 0 + : i < 0.0 ? std::numeric_limits<uint32_t>::min() + : std::numeric_limits<uint32_t>::max(); + int32_t found = r.Call(i); CHECK_EQ(expected, found); } } @@ -3018,7 +3017,7 @@ WASM_EXEC_TEST(F64CopySign) { BUILD(r, WASM_F64_COPYSIGN(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); FOR_FLOAT64_INPUTS(i) { - FOR_FLOAT64_INPUTS(j) { CHECK_DOUBLE_EQ(copysign(*i, *j), r.Call(*i, *j)); } + FOR_FLOAT64_INPUTS(j) { CHECK_DOUBLE_EQ(copysign(i, j), r.Call(i, j)); } } } @@ -3027,7 +3026,7 @@ WASM_EXEC_TEST(F32CopySign) { BUILD(r, WASM_F32_COPYSIGN(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); FOR_FLOAT32_INPUTS(i) { - FOR_FLOAT32_INPUTS(j) { CHECK_FLOAT_EQ(copysignf(*i, *j), r.Call(*i, *j)); } + FOR_FLOAT32_INPUTS(j) { CHECK_FLOAT_EQ(copysignf(i, j), r.Call(i, j)); } } } @@ -3307,9 +3306,11 @@ WASM_EXEC_TEST(I32MulOnDifferentRegisters) { } WASM_EXEC_TEST(I32ShlOnDifferentRegisters) { - BinOpOnDifferentRegisters<int32_t>( - execution_tier, kWasmI32, ArrayVector(kSome32BitInputs), kExprI32Shl, - [](int32_t lhs, int32_t rhs, bool* trap) { return lhs << (rhs & 31); }); + BinOpOnDifferentRegisters<int32_t>(execution_tier, kWasmI32, + ArrayVector(kSome32BitInputs), kExprI32Shl, + [](int32_t lhs, int32_t rhs, bool* trap) { + return base::ShlWithWraparound(lhs, rhs); + }); } WASM_EXEC_TEST(I32ShrSOnDifferentRegisters) { @@ -3383,9 +3384,11 @@ WASM_EXEC_TEST(I64MulOnDifferentRegisters) { } WASM_EXEC_TEST(I64ShlOnDifferentRegisters) { - BinOpOnDifferentRegisters<int64_t>( - execution_tier, kWasmI64, ArrayVector(kSome64BitInputs), kExprI64Shl, - [](int64_t lhs, int64_t rhs, bool* trap) { return lhs << (rhs & 63); }); + BinOpOnDifferentRegisters<int64_t>(execution_tier, kWasmI64, + ArrayVector(kSome64BitInputs), kExprI64Shl, + [](int64_t lhs, int64_t rhs, bool* trap) { + return base::ShlWithWraparound(lhs, rhs); + }); } WASM_EXEC_TEST(I64ShrSOnDifferentRegisters) { @@ -3470,10 +3473,9 @@ TEST(Liftoff_tier_up) { memcpy(buffer.get(), sub_code->instructions().start(), sub_size); desc.buffer = buffer.get(); desc.instr_size = static_cast<int>(sub_size); - WasmCode* code = native_module->AddCode( - add.function_index(), desc, 0, 0, 0, {}, OwnedVector<byte>(), - WasmCode::kFunction, WasmCode::kOther); - native_module->PublishCode(code); + native_module->AddCode(add.function_index(), desc, 0, 0, {}, + OwnedVector<byte>(), WasmCode::kFunction, + WasmCode::kOther); // Second run should now execute {sub}. CHECK_EQ(4, r.Call(11, 7)); diff --git a/deps/v8/test/cctest/wasm/test-streaming-compilation.cc b/deps/v8/test/cctest/wasm/test-streaming-compilation.cc index 43ba7dfea1..3ef62d869f 100644 --- a/deps/v8/test/cctest/wasm/test-streaming-compilation.cc +++ b/deps/v8/test/cctest/wasm/test-streaming-compilation.cc @@ -59,14 +59,14 @@ class MockPlatform final : public TestPlatform { void PostDelayedTask(std::unique_ptr<Task> task, double delay_in_seconds) override { - UNREACHABLE(); - }; + tasks_.push(std::move(task)); + } void PostIdleTask(std::unique_ptr<IdleTask> task) override { UNREACHABLE(); } - bool IdleTasksEnabled() override { return false; }; + bool IdleTasksEnabled() override { return false; } void ExecuteTasks() { while (!tasks_.empty()) { diff --git a/deps/v8/test/cctest/wasm/test-wasm-import-wrapper-cache.cc b/deps/v8/test/cctest/wasm/test-wasm-import-wrapper-cache.cc index ba189a57ca..68366dc2df 100644 --- a/deps/v8/test/cctest/wasm/test-wasm-import-wrapper-cache.cc +++ b/deps/v8/test/cctest/wasm/test-wasm-import-wrapper-cache.cc @@ -18,11 +18,10 @@ namespace wasm { namespace test_wasm_import_wrapper_cache { std::unique_ptr<NativeModule> NewModule(Isolate* isolate) { - WasmCodeManager* manager = isolate->wasm_engine()->code_manager(); std::shared_ptr<WasmModule> module(new WasmModule); bool can_request_more = false; size_t size = 16384; - auto native_module = manager->NewNativeModule( + auto native_module = isolate->wasm_engine()->NewNativeModule( isolate, kAllWasmFeatures, size, can_request_more, std::move(module)); native_module->SetRuntimeStubs(isolate); return native_module; diff --git a/deps/v8/test/cctest/wasm/test-wasm-interpreter-entry.cc b/deps/v8/test/cctest/wasm/test-wasm-interpreter-entry.cc index 1349ce2d17..211a79978e 100644 --- a/deps/v8/test/cctest/wasm/test-wasm-interpreter-entry.cc +++ b/deps/v8/test/cctest/wasm/test-wasm-interpreter-entry.cc @@ -48,7 +48,7 @@ class ArgPassingHelper { runner.Build(outer_code.data(), outer_code.data() + outer_code.size()); int funcs_to_redict[] = {static_cast<int>(inner_compiler.function_index())}; - runner.builder().Link(); + runner.builder().SetExecutable(); WasmDebugInfo::RedirectToInterpreter(debug_info_, ArrayVector(funcs_to_redict)); main_fun_wrapper_ = runner.builder().WrapCode(runner.function_index()); @@ -105,7 +105,7 @@ TEST(TestArgumentPassing_int32) { return base::AddWithWraparound(base::MulWithWraparound(2, a), 1); }); - FOR_INT32_INPUTS(v) { helper.CheckCall(*v); } + FOR_INT32_INPUTS(v) { helper.CheckCall(v); } } // Pass int64_t, return double. @@ -124,17 +124,17 @@ TEST(TestArgumentPassing_double_int64) { WASM_CALL_FUNCTION0(f2.function_index())}, [](int32_t a, int32_t b) { int64_t a64 = static_cast<int64_t>(a) & 0xFFFFFFFF; - int64_t b64 = static_cast<int64_t>(b) << 32; + int64_t b64 = static_cast<uint64_t>(static_cast<int64_t>(b)) << 32; return static_cast<double>(a64 | b64); }); FOR_INT32_INPUTS(v1) { - FOR_INT32_INPUTS(v2) { helper.CheckCall(*v1, *v2); } + FOR_INT32_INPUTS(v2) { helper.CheckCall(v1, v2); } } FOR_INT64_INPUTS(v) { - int32_t v1 = static_cast<int32_t>(*v); - int32_t v2 = static_cast<int32_t>(*v >> 32); + 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); } @@ -175,7 +175,7 @@ TEST(TestArgumentPassing_float_double) { WASM_GET_LOCAL(0), WASM_CALL_FUNCTION0(f2.function_index())}, [](float f) { return 2. * static_cast<double>(f) + 1.; }); - FOR_FLOAT32_INPUTS(f) { helper.CheckCall(*f); } + FOR_FLOAT32_INPUTS(f) { helper.CheckCall(f); } } // Pass two doubles, return double. @@ -192,7 +192,7 @@ TEST(TestArgumentPassing_double_double) { [](double a, double b) { return a + b; }); FOR_FLOAT64_INPUTS(d1) { - FOR_FLOAT64_INPUTS(d2) { helper.CheckCall(*d1, *d2); } + FOR_FLOAT64_INPUTS(d2) { helper.CheckCall(d1, d2); } } } diff --git a/deps/v8/test/cctest/wasm/wasm-run-utils.cc b/deps/v8/test/cctest/wasm/wasm-run-utils.cc index f95760569f..ad57b458c6 100644 --- a/deps/v8/test/cctest/wasm/wasm-run-utils.cc +++ b/deps/v8/test/cctest/wasm/wasm-run-utils.cc @@ -6,6 +6,7 @@ #include "src/assembler-inl.h" #include "src/code-tracer.h" +#include "src/heap/heap-inl.h" #include "src/wasm/graph-builder-interface.h" #include "src/wasm/wasm-import-wrapper-cache-inl.h" #include "src/wasm/wasm-memory.h" @@ -57,7 +58,7 @@ TestingModuleBuilder::TestingModuleBuilder( } } -byte* TestingModuleBuilder::AddMemory(uint32_t size) { +byte* TestingModuleBuilder::AddMemory(uint32_t size, SharedFlag shared) { CHECK(!test_module_->has_memory); CHECK_NULL(mem_start_); CHECK_EQ(0, mem_size_); @@ -65,9 +66,16 @@ byte* TestingModuleBuilder::AddMemory(uint32_t size) { DCHECK_IMPLIES(test_module_->origin == kWasmOrigin, size % kWasmPageSize == 0); test_module_->has_memory = true; + uint32_t max_size = + (test_module_->maximum_pages != 0) ? test_module_->maximum_pages : size; uint32_t alloc_size = RoundUp(size, kWasmPageSize); Handle<JSArrayBuffer> new_buffer; - CHECK(NewArrayBuffer(isolate_, alloc_size).ToHandle(&new_buffer)); + if (shared == SharedFlag::kShared) { + CHECK(NewSharedArrayBuffer(isolate_, alloc_size, max_size) + .ToHandle(&new_buffer)); + } else { + CHECK(NewArrayBuffer(isolate_, alloc_size).ToHandle(&new_buffer)); + } CHECK(!new_buffer.is_null()); mem_start_ = reinterpret_cast<byte*>(new_buffer->backing_store()); mem_size_ = size; @@ -75,9 +83,8 @@ byte* TestingModuleBuilder::AddMemory(uint32_t size) { memset(mem_start_, 0, size); // Create the WasmMemoryObject. - Handle<WasmMemoryObject> memory_object = WasmMemoryObject::New( - isolate_, new_buffer, - (test_module_->maximum_pages != 0) ? test_module_->maximum_pages : -1); + Handle<WasmMemoryObject> memory_object = + WasmMemoryObject::New(isolate_, new_buffer, max_size); instance_object_->set_memory_object(*memory_object); WasmMemoryObject::AddInstance(isolate_, memory_object, instance_object_); // TODO(wasm): Delete the following two lines when test-run-wasm will use a @@ -119,8 +126,7 @@ uint32_t TestingModuleBuilder::AddFunction(FunctionSig* sig, const char* name, } Handle<JSFunction> TestingModuleBuilder::WrapCode(uint32_t index) { - // Wrap the code so it can be called as a JS function. - Link(); + SetExecutable(); FunctionSig* sig = test_module_->functions[index].sig; MaybeHandle<Code> maybe_ret_code = compiler::CompileJSToWasmWrapper(isolate_, sig, false); @@ -140,6 +146,14 @@ Handle<JSFunction> TestingModuleBuilder::WrapCode(uint32_t index) { new_arr->set(old_arr->length(), *ret_code); module_object->set_export_wrappers(*new_arr); + if (interpreter_) { + // Patch the jump table to call the interpreter for this function. This is + // only needed for functions with a wrapper. Other functions never get + // called through the jump table. + wasm::WasmCode* wasm_new_code = compiler::CompileWasmInterpreterEntry( + isolate_->wasm_engine(), native_module_, index, sig); + native_module_->PublishInterpreterEntry(wasm_new_code, index); + } return ret; } @@ -181,12 +195,26 @@ uint32_t TestingModuleBuilder::AddBytes(Vector<const byte> bytes) { uint32_t bytes_offset = old_size ? old_size : 1; size_t new_size = bytes_offset + bytes.size(); OwnedVector<uint8_t> new_bytes = OwnedVector<uint8_t>::New(new_size); - memcpy(new_bytes.start(), old_bytes.start(), old_size); + if (old_size > 0) { + memcpy(new_bytes.start(), old_bytes.start(), old_size); + } memcpy(new_bytes.start() + bytes_offset, bytes.start(), bytes.length()); native_module_->SetWireBytes(std::move(new_bytes)); return bytes_offset; } +uint32_t TestingModuleBuilder::AddException(FunctionSig* sig) { + DCHECK_EQ(0, sig->return_count()); + uint32_t index = static_cast<uint32_t>(test_module_->exceptions.size()); + test_module_->exceptions.push_back(WasmException{sig}); + Handle<WasmExceptionTag> tag = WasmExceptionTag::New(isolate_, index); + Handle<FixedArray> table(instance_object_->exceptions_table(), isolate_); + table = isolate_->factory()->CopyFixedArrayAndGrow(table, 1); + instance_object_->set_exceptions_table(*table); + table->set(index, *tag); + return index; +} + CompilationEnv TestingModuleBuilder::CreateCompilationEnv() { return { test_module_ptr_, @@ -219,6 +247,7 @@ Handle<WasmInstanceObject> TestingModuleBuilder::InitInstanceObject() { native_module_->ReserveCodeTableForTesting(kMaxFunctions); auto instance = WasmInstanceObject::New(isolate_, module_object); + instance->set_exceptions_table(*isolate_->factory()->empty_fixed_array()); instance->set_globals_start(globals_data_); return instance; } @@ -393,15 +422,9 @@ void WasmFunctionCompiler::Build(const byte* start, const byte* end) { static_cast<uint32_t>(len)}; if (interpreter_) { - // Add the code to the interpreter. + // Add the code to the interpreter; do not generate compiled code. interpreter_->SetFunctionCodeForTesting(function_, start, end); - } - - // TODO(wasm): tests that go through JS depend on having a compiled version - // of each function, even if the execution tier is the interpreter. Fix. - auto tier = builder_->execution_tier(); - if (tier == ExecutionTier::kInterpreter) { - tier = ExecutionTier::kOptimized; + return; } Vector<const uint8_t> wire_bytes = builder_->instance_object() @@ -419,7 +442,7 @@ void WasmFunctionCompiler::Build(const byte* start, const byte* end) { NativeModule* native_module = builder_->instance_object()->module_object()->native_module(); WasmCompilationUnit unit(isolate()->wasm_engine(), function_->func_index, - tier); + builder_->execution_tier()); WasmFeatures unused_detected_features; WasmCompilationResult result = unit.ExecuteCompilation( &env, native_module->compilation_state()->GetWireBytesStorage(), diff --git a/deps/v8/test/cctest/wasm/wasm-run-utils.h b/deps/v8/test/cctest/wasm/wasm-run-utils.h index af575fff77..d52d7bac76 100644 --- a/deps/v8/test/cctest/wasm/wasm-run-utils.h +++ b/deps/v8/test/cctest/wasm/wasm-run-utils.h @@ -39,6 +39,7 @@ #include "test/cctest/cctest.h" #include "test/cctest/compiler/call-tester.h" #include "test/cctest/compiler/graph-builder-tester.h" +#include "test/cctest/compiler/value-helper.h" #include "test/common/wasm/flag-utils.h" namespace v8 { @@ -87,7 +88,7 @@ class TestingModuleBuilder { void ChangeOriginToAsmjs() { test_module_->origin = kAsmJsOrigin; } - byte* AddMemory(uint32_t size); + byte* AddMemory(uint32_t size, SharedFlag shared = SharedFlag::kNotShared); size_t CodeTableLength() const { return native_module_->num_functions(); } @@ -175,6 +176,7 @@ class TestingModuleBuilder { enum FunctionType { kImport, kWasm }; uint32_t AddFunction(FunctionSig* sig, const char* name, FunctionType type); + // Wrap the code so it can be called as a JS function. Handle<JSFunction> WrapCode(uint32_t index); void AddIndirectFunctionTable(const uint16_t* function_indexes, @@ -184,6 +186,8 @@ class TestingModuleBuilder { uint32_t AddBytes(Vector<const byte> bytes); + uint32_t AddException(FunctionSig* sig); + WasmFunction* GetFunctionAt(int index) { return &test_module_->functions[index]; } @@ -201,11 +205,8 @@ class TestingModuleBuilder { Address globals_start() const { return reinterpret_cast<Address>(globals_data_); } - void Link() { - if (linked_) return; - linked_ = true; - native_module_->SetExecutable(true); - } + + void SetExecutable() { native_module_->SetExecutable(true); } CompilationEnv CreateCompilationEnv(); @@ -228,7 +229,6 @@ class TestingModuleBuilder { ExecutionTier execution_tier_; Handle<WasmInstanceObject> instance_object_; NativeModule* native_module_ = nullptr; - bool linked_ = false; RuntimeExceptionSupport runtime_exception_support_; LowerSimd lower_simd_; @@ -450,7 +450,7 @@ class WasmRunner : public WasmRunnerBase { wrapper_.SetInnerCode(builder_.GetFunctionCode(0)); wrapper_.SetInstance(builder_.instance_object()); - builder_.Link(); + builder_.SetExecutable(); Handle<Code> wrapper_code = wrapper_.GetWrapperCode(); compiler::CodeRunner<int32_t> runner(CcTest::InitIsolateOnce(), wrapper_code, wrapper_.signature()); @@ -474,7 +474,9 @@ class WasmRunner : public WasmRunnerBase { thread->Reset(); std::array<WasmValue, sizeof...(p)> args{{WasmValue(p)...}}; thread->InitFrame(function(), args.data()); - if (thread->Run() == WasmInterpreter::FINISHED) { + thread->Run(); + CHECK_GT(thread->NumInterpretedCalls(), 0); + if (thread->state() == WasmInterpreter::FINISHED) { WasmValue val = thread->GetReturnValue(); possible_nondeterminism_ |= thread->PossibleNondeterminism(); return val.to<ReturnType>(); @@ -488,7 +490,45 @@ class WasmRunner : public WasmRunnerBase { } } + void CheckCallViaJS(double expected, uint32_t function_index, + Handle<Object>* buffer, int count) { + Isolate* isolate = builder_.isolate(); + if (jsfuncs_.size() <= function_index) { + jsfuncs_.resize(function_index + 1); + } + if (jsfuncs_[function_index].is_null()) { + jsfuncs_[function_index] = builder_.WrapCode(function_index); + } + Handle<JSFunction> jsfunc = jsfuncs_[function_index]; + Handle<Object> global(isolate->context()->global_object(), isolate); + MaybeHandle<Object> retval = + Execution::Call(isolate, jsfunc, global, count, buffer); + + CHECK(!retval.is_null()); + Handle<Object> result = retval.ToHandleChecked(); + if (result->IsSmi()) { + CHECK_EQ(expected, Smi::ToInt(*result)); + } else { + CHECK(result->IsHeapNumber()); + CHECK_DOUBLE_EQ(expected, HeapNumber::cast(*result)->value()); + } + + if (builder_.interpret()) { + CHECK_GT(builder_.interpreter()->GetThread(0)->NumInterpretedCalls(), 0); + } + } + + void CheckCallViaJS(double expected, ParamTypes... p) { + Isolate* isolate = builder_.isolate(); + uint32_t function_index = function()->func_index; + Handle<Object> buffer[] = {isolate->factory()->NewNumber(p)...}; + CheckCallViaJS(expected, function_index, buffer, sizeof...(p)); + } + Handle<Code> GetWrapperCode() { return wrapper_.GetWrapperCode(); } + + private: + std::vector<Handle<JSFunction>> jsfuncs_; }; // A macro to define tests that run in different engine configurations. |