[wasm] Fix duplicated tests for float to I64 tests

Fixes float to I64 tests to not have duplicated tests.

Also changes the use of macro REQUIRE to only be needed when an opcode
(i.e. operation) is not supported on some architecture.

Bug: v8:7226
Change-Id: I6c18602bd836469077808c0b3c93732af7c8f0d8
Reviewed-on: https://chromium-review.googlesource.com/895408
Commit-Queue: Karl Schimpf <kschimpf@chromium.org>
Reviewed-by: Clemens Hammacher <clemensh@chromium.org>
Cr-Commit-Position: refs/heads/master@{#51097}

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

@@ -35,67 +35,30 @@ namespace test_run_wasm_64 {
 #define MIPS false
 #endif
 
-#define FOREACH_I64_OPERATOR(V) \
-  V(DepthFirst, true)           \
-  V(I64Phi, true)               \
-  V(I64Const, true)             \
-  V(I64Return, true)            \
-  V(I64Param, true)             \
-  V(I64LoadStore, true)         \
-  V(I64Add, true)               \
-  V(I64Sub, true)               \
-  V(I64Mul, !MIPS)              \
-  V(I64DivS, true)              \
-  V(I64DivU, true)              \
-  V(I64RemS, true)              \
-  V(I64RemU, true)              \
-  V(I64And, true)               \
-  V(I64Ior, true)               \
-  V(I64Xor, true)               \
-  V(I64Shl, true)               \
-  V(I64ShrU, true)              \
-  V(I64ShrS, true)              \
-  V(I64Eq, true)                \
-  V(I64Ne, true)                \
-  V(I64LtS, true)               \
-  V(I64LeS, true)               \
-  V(I64LtU, true)               \
-  V(I64LeU, true)               \
-  V(I64GtS, true)               \
-  V(I64GeS, true)               \
-  V(I64GtU, true)               \
-  V(I64GeU, true)               \
-  V(I64Ctz, true)               \
-  V(I64Clz, true)               \
-  V(I64Popcnt, true)            \
-  V(I32ConvertI64, true)        \
-  V(I64SConvertF32, true)       \
-  V(I64SConvertF64, true)       \
-  V(I64UConvertF32, true)       \
-  V(I64UConvertF64, true)       \
-  V(I64SConvertSatF32, true)    \
-  V(I64SConvertI32, true)       \
-  V(I64UConvertI32, true)       \
-  V(F32SConvertI64, true)       \
-  V(F32UConvertI64, true)       \
-  V(F64SConvertI64, true)       \
-  V(F64UConvertI64, true)       \
-  V(F64ReinterpretI64, true)    \
-  V(I64ReinterpretF64, true)    \
-  V(I64Ror, true)               \
-  V(I64Rol, true)
-
-#define DECLARE_CONST(name, cond) static const bool kSupported_##name = cond;
-FOREACH_I64_OPERATOR(DECLARE_CONST)
-#undef DECLARE_CONST
-
-#undef FOREACH_I64_OPERATOR
+namespace {
+
+#define FOREACH_UNSUPPORTED_OPCODE(V) V(I64Mul, !WASM_64 && MIPS)
+
+bool SupportsOpcode(WasmOpcode opcode) {
+  switch (opcode) {
+#define CASE_TEST(name, unsupported_test) \
+  case kExpr##name:                       \
+    return !(unsupported_test);
+    FOREACH_UNSUPPORTED_OPCODE(CASE_TEST)
+#undef CASE_TEST
+    default:
+      return true;
+  }
+}
+
+#undef FOREACH_UNSUPPORTED_OPCODE
+
+}  // namespace
 
 #define REQUIRE(name) \
-  if (!WASM_64 && !kSupported_##name) return
+  if (!SupportsOpcode(kExpr##name)) return
 
 WASM_EXEC_TEST(I64Const) {
-  REQUIRE(I64Const);
   WasmRunner<int64_t> r(execution_mode);
   const int64_t kExpectedValue = 0x1122334455667788LL;
   // return(kExpectedValue)
@@ -104,7 +67,6 @@ WASM_EXEC_TEST(I64Const) {
 }
 
 WASM_EXEC_TEST(I64Const_many) {
-  REQUIRE(I64Const);
   int cntr = 0;
   FOR_INT32_INPUTS(i) {
     WasmRunner<int64_t> r(execution_mode);
@@ -117,7 +79,6 @@ WASM_EXEC_TEST(I64Const_many) {
 }
 
 WASM_EXEC_TEST(Return_I64) {
-  REQUIRE(I64Return);
   WasmRunner<int64_t, int64_t> r(execution_mode);
 
   BUILD(r, WASM_RETURN1(WASM_GET_LOCAL(0)));
@@ -126,7 +87,6 @@ WASM_EXEC_TEST(Return_I64) {
 }
 
 WASM_EXEC_TEST(I64Add) {
-  REQUIRE(I64Add);
   WasmRunner<int64_t, int64_t, int64_t> r(execution_mode);
   BUILD(r, WASM_I64_ADD(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_INT64_INPUTS(i) {
@@ -140,7 +100,6 @@ WASM_EXEC_TEST(I64Add) {
 const int64_t kHasBit33On = 0x100000000;
 
 WASM_EXEC_TEST(Regress5800_Add) {
-  REQUIRE(I64Add);
   WasmRunner<int32_t> r(execution_mode);
   BUILD(r, WASM_BLOCK(WASM_BR_IF(0, WASM_I64_EQZ(WASM_I64_ADD(
                                         WASM_I64V(0), WASM_I64V(kHasBit33On)))),
@@ -150,7 +109,6 @@ WASM_EXEC_TEST(Regress5800_Add) {
 }
 
 WASM_EXEC_TEST(I64Sub) {
-  REQUIRE(I64Sub);
   WasmRunner<int64_t, int64_t, int64_t> r(execution_mode);
   BUILD(r, WASM_I64_SUB(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_INT64_INPUTS(i) {
@@ -159,7 +117,6 @@ WASM_EXEC_TEST(I64Sub) {
 }
 
 WASM_EXEC_TEST(Regress5800_Sub) {
-  REQUIRE(I64Sub);
   WasmRunner<int32_t> r(execution_mode);
   BUILD(r, WASM_BLOCK(WASM_BR_IF(0, WASM_I64_EQZ(WASM_I64_SUB(
                                         WASM_I64V(0), WASM_I64V(kHasBit33On)))),
@@ -169,8 +126,6 @@ WASM_EXEC_TEST(Regress5800_Sub) {
 }
 
 WASM_EXEC_TEST(I64AddUseOnlyLowWord) {
-  REQUIRE(I64Add);
-  REQUIRE(I32ConvertI64);
   WasmRunner<int32_t, int64_t, int64_t> r(execution_mode);
   BUILD(r, WASM_I32_CONVERT_I64(
                WASM_I64_ADD(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))));
@@ -182,8 +137,6 @@ WASM_EXEC_TEST(I64AddUseOnlyLowWord) {
 }
 
 WASM_EXEC_TEST(I64SubUseOnlyLowWord) {
-  REQUIRE(I64Sub);
-  REQUIRE(I32ConvertI64);
   WasmRunner<int32_t, int64_t, int64_t> r(execution_mode);
   BUILD(r, WASM_I32_CONVERT_I64(
                WASM_I64_SUB(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))));
@@ -196,7 +149,6 @@ WASM_EXEC_TEST(I64SubUseOnlyLowWord) {
 
 WASM_EXEC_TEST(I64MulUseOnlyLowWord) {
   REQUIRE(I64Mul);
-  REQUIRE(I32ConvertI64);
   WasmRunner<int32_t, int64_t, int64_t> r(execution_mode);
   BUILD(r, WASM_I32_CONVERT_I64(
                WASM_I64_MUL(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))));
@@ -208,8 +160,6 @@ WASM_EXEC_TEST(I64MulUseOnlyLowWord) {
 }
 
 WASM_EXEC_TEST(I64ShlUseOnlyLowWord) {
-  REQUIRE(I64Shl);
-  REQUIRE(I32ConvertI64);
   WasmRunner<int32_t, int64_t, int64_t> r(execution_mode);
   BUILD(r, WASM_I32_CONVERT_I64(
                WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))));
@@ -222,8 +172,6 @@ WASM_EXEC_TEST(I64ShlUseOnlyLowWord) {
 }
 
 WASM_EXEC_TEST(I64ShrUseOnlyLowWord) {
-  REQUIRE(I64ShrU);
-  REQUIRE(I32ConvertI64);
   WasmRunner<int32_t, int64_t, int64_t> r(execution_mode);
   BUILD(r, WASM_I32_CONVERT_I64(
                WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))));
@@ -236,8 +184,6 @@ WASM_EXEC_TEST(I64ShrUseOnlyLowWord) {
 }
 
 WASM_EXEC_TEST(I64SarUseOnlyLowWord) {
-  REQUIRE(I64ShrS);
-  REQUIRE(I32ConvertI64);
   WasmRunner<int32_t, int64_t, int64_t> r(execution_mode);
   BUILD(r, WASM_I32_CONVERT_I64(
                WASM_I64_SAR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))));
@@ -250,7 +196,6 @@ WASM_EXEC_TEST(I64SarUseOnlyLowWord) {
 }
 
 WASM_EXEC_TEST(I64DivS) {
-  REQUIRE(I64DivS);
   WasmRunner<int64_t, int64_t, int64_t> r(execution_mode);
   BUILD(r, WASM_I64_DIVS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_INT64_INPUTS(i) {
@@ -267,7 +212,6 @@ WASM_EXEC_TEST(I64DivS) {
 }
 
 WASM_EXEC_TEST(I64DivS_Trap) {
-  REQUIRE(I64DivS);
   WasmRunner<int64_t, int64_t, int64_t> r(execution_mode);
   BUILD(r, WASM_I64_DIVS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   CHECK_EQ(0, r.Call(int64_t{0}, int64_t{100}));
@@ -278,7 +222,6 @@ WASM_EXEC_TEST(I64DivS_Trap) {
 }
 
 WASM_EXEC_TEST(I64DivS_Byzero_Const) {
-  REQUIRE(I64DivS);
   for (int8_t denom = -2; denom < 8; denom++) {
     WasmRunner<int64_t, int64_t> r(execution_mode);
     BUILD(r, WASM_I64_DIVS(WASM_GET_LOCAL(0), WASM_I64V_1(denom)));
@@ -293,7 +236,6 @@ WASM_EXEC_TEST(I64DivS_Byzero_Const) {
 }
 
 WASM_EXEC_TEST(I64DivU) {
-  REQUIRE(I64DivU);
   WasmRunner<uint64_t, uint64_t, uint64_t> r(execution_mode);
   BUILD(r, WASM_I64_DIVU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_UINT64_INPUTS(i) {
@@ -308,7 +250,6 @@ WASM_EXEC_TEST(I64DivU) {
 }
 
 WASM_EXEC_TEST(I64DivU_Trap) {
-  REQUIRE(I64DivU);
   WasmRunner<uint64_t, uint64_t, uint64_t> r(execution_mode);
   BUILD(r, WASM_I64_DIVU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   CHECK_EQ(0, r.Call(uint64_t{0}, uint64_t{100}));
@@ -318,7 +259,6 @@ WASM_EXEC_TEST(I64DivU_Trap) {
 }
 
 WASM_EXEC_TEST(I64DivU_Byzero_Const) {
-  REQUIRE(I64DivU);
   for (uint64_t denom = 0xFFFFFFFFFFFFFFFE; denom < 8; denom++) {
     WasmRunner<uint64_t, uint64_t> r(execution_mode);
     BUILD(r, WASM_I64_DIVU(WASM_GET_LOCAL(0), WASM_I64V_1(denom)));
@@ -334,7 +274,6 @@ WASM_EXEC_TEST(I64DivU_Byzero_Const) {
 }
 
 WASM_EXEC_TEST(I64RemS) {
-  REQUIRE(I64RemS);
   WasmRunner<int64_t, int64_t, int64_t> r(execution_mode);
   BUILD(r, WASM_I64_REMS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_INT64_INPUTS(i) {
@@ -349,7 +288,6 @@ WASM_EXEC_TEST(I64RemS) {
 }
 
 WASM_EXEC_TEST(I64RemS_Trap) {
-  REQUIRE(I64RemS);
   WasmRunner<int64_t, int64_t, int64_t> r(execution_mode);
   BUILD(r, WASM_I64_REMS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   CHECK_EQ(33, r.Call(int64_t{133}, int64_t{100}));
@@ -360,7 +298,6 @@ WASM_EXEC_TEST(I64RemS_Trap) {
 }
 
 WASM_EXEC_TEST(I64RemU) {
-  REQUIRE(I64RemU);
   WasmRunner<uint64_t, uint64_t, uint64_t> r(execution_mode);
   BUILD(r, WASM_I64_REMU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_UINT64_INPUTS(i) {
@@ -375,7 +312,6 @@ WASM_EXEC_TEST(I64RemU) {
 }
 
 WASM_EXEC_TEST(I64RemU_Trap) {
-  REQUIRE(I64RemU);
   WasmRunner<uint64_t, uint64_t, uint64_t> r(execution_mode);
   BUILD(r, WASM_I64_REMU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   CHECK_EQ(17, r.Call(uint64_t{217}, uint64_t{100}));
@@ -385,7 +321,6 @@ WASM_EXEC_TEST(I64RemU_Trap) {
 }
 
 WASM_EXEC_TEST(I64And) {
-  REQUIRE(I64And);
   WasmRunner<int64_t, int64_t, int64_t> r(execution_mode);
   BUILD(r, WASM_I64_AND(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_INT64_INPUTS(i) {
@@ -394,7 +329,6 @@ WASM_EXEC_TEST(I64And) {
 }
 
 WASM_EXEC_TEST(I64Ior) {
-  REQUIRE(I64Ior);
   WasmRunner<int64_t, int64_t, int64_t> r(execution_mode);
   BUILD(r, WASM_I64_IOR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_INT64_INPUTS(i) {
@@ -403,7 +337,6 @@ WASM_EXEC_TEST(I64Ior) {
 }
 
 WASM_EXEC_TEST(I64Xor) {
-  REQUIRE(I64Xor);
   WasmRunner<int64_t, int64_t, int64_t> r(execution_mode);
   BUILD(r, WASM_I64_XOR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_INT64_INPUTS(i) {
@@ -412,7 +345,6 @@ WASM_EXEC_TEST(I64Xor) {
 }
 
 WASM_EXEC_TEST(I64Shl) {
-  REQUIRE(I64Shl);
   {
     WasmRunner<uint64_t, uint64_t, uint64_t> r(execution_mode);
     BUILD(r, WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -447,7 +379,6 @@ WASM_EXEC_TEST(I64Shl) {
 }
 
 WASM_EXEC_TEST(I64ShrU) {
-  REQUIRE(I64ShrU);
   {
     WasmRunner<uint64_t, uint64_t, uint64_t> r(execution_mode);
     BUILD(r, WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -482,7 +413,6 @@ WASM_EXEC_TEST(I64ShrU) {
 }
 
 WASM_EXEC_TEST(I64ShrS) {
-  REQUIRE(I64ShrS);
   {
     WasmRunner<int64_t, int64_t, int64_t> r(execution_mode);
     BUILD(r, WASM_I64_SAR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -517,7 +447,6 @@ WASM_EXEC_TEST(I64ShrS) {
 }
 
 WASM_EXEC_TEST(I64Eq) {
-  REQUIRE(I64Eq);
   WasmRunner<int32_t, int64_t, int64_t> r(execution_mode);
   BUILD(r, WASM_I64_EQ(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_INT64_INPUTS(i) {
@@ -526,7 +455,6 @@ WASM_EXEC_TEST(I64Eq) {
 }
 
 WASM_EXEC_TEST(I64Ne) {
-  REQUIRE(I64Ne);
   WasmRunner<int32_t, int64_t, int64_t> r(execution_mode);
   BUILD(r, WASM_I64_NE(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_INT64_INPUTS(i) {
@@ -535,7 +463,6 @@ WASM_EXEC_TEST(I64Ne) {
 }
 
 WASM_EXEC_TEST(I64LtS) {
-  REQUIRE(I64LtS);
   WasmRunner<int32_t, int64_t, int64_t> r(execution_mode);
   BUILD(r, WASM_I64_LTS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_INT64_INPUTS(i) {
@@ -544,7 +471,6 @@ WASM_EXEC_TEST(I64LtS) {
 }
 
 WASM_EXEC_TEST(I64LeS) {
-  REQUIRE(I64LeS);
   WasmRunner<int32_t, int64_t, int64_t> r(execution_mode);
   BUILD(r, WASM_I64_LES(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_INT64_INPUTS(i) {
@@ -553,7 +479,6 @@ WASM_EXEC_TEST(I64LeS) {
 }
 
 WASM_EXEC_TEST(I64LtU) {
-  REQUIRE(I64LtU);
   WasmRunner<int32_t, int64_t, int64_t> r(execution_mode);
   BUILD(r, WASM_I64_LTU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_UINT64_INPUTS(i) {
@@ -562,7 +487,6 @@ WASM_EXEC_TEST(I64LtU) {
 }
 
 WASM_EXEC_TEST(I64LeU) {
-  REQUIRE(I64LeU);
   WasmRunner<int32_t, int64_t, int64_t> r(execution_mode);
   BUILD(r, WASM_I64_LEU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_UINT64_INPUTS(i) {
@@ -571,7 +495,6 @@ WASM_EXEC_TEST(I64LeU) {
 }
 
 WASM_EXEC_TEST(I64GtS) {
-  REQUIRE(I64GtS);
   WasmRunner<int32_t, int64_t, int64_t> r(execution_mode);
   BUILD(r, WASM_I64_GTS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_INT64_INPUTS(i) {
@@ -580,7 +503,6 @@ WASM_EXEC_TEST(I64GtS) {
 }
 
 WASM_EXEC_TEST(I64GeS) {
-  REQUIRE(I64GeS);
   WasmRunner<int32_t, int64_t, int64_t> r(execution_mode);
   BUILD(r, WASM_I64_GES(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_INT64_INPUTS(i) {
@@ -589,7 +511,6 @@ WASM_EXEC_TEST(I64GeS) {
 }
 
 WASM_EXEC_TEST(I64GtU) {
-  REQUIRE(I64GtU);
   WasmRunner<int32_t, int64_t, int64_t> r(execution_mode);
   BUILD(r, WASM_I64_GTU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_UINT64_INPUTS(i) {
@@ -598,7 +519,6 @@ WASM_EXEC_TEST(I64GtU) {
 }
 
 WASM_EXEC_TEST(I64GeU) {
-  REQUIRE(I64GeU);
   WasmRunner<int32_t, int64_t, int64_t> r(execution_mode);
   BUILD(r, WASM_I64_GEU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_UINT64_INPUTS(i) {
@@ -607,7 +527,6 @@ WASM_EXEC_TEST(I64GeU) {
 }
 
 WASM_EXEC_TEST(I32ConvertI64) {
-  REQUIRE(I32ConvertI64);
   FOR_INT64_INPUTS(i) {
     WasmRunner<int32_t> r(execution_mode);
     BUILD(r, WASM_I32_CONVERT_I64(WASM_I64V(*i)));
@@ -616,14 +535,12 @@ WASM_EXEC_TEST(I32ConvertI64) {
 }
 
 WASM_EXEC_TEST(I64SConvertI32) {
-  REQUIRE(I64SConvertI32);
   WasmRunner<int64_t, int32_t> r(execution_mode);
   BUILD(r, WASM_I64_SCONVERT_I32(WASM_GET_LOCAL(0)));
   FOR_INT32_INPUTS(i) { CHECK_EQ(static_cast<int64_t>(*i), r.Call(*i)); }
 }
 
 WASM_EXEC_TEST(I64UConvertI32) {
-  REQUIRE(I64UConvertI32);
   WasmRunner<int64_t, uint32_t> r(execution_mode);
   BUILD(r, WASM_I64_UCONVERT_I32(WASM_GET_LOCAL(0)));
   FOR_UINT32_INPUTS(i) { CHECK_EQ(static_cast<int64_t>(*i), r.Call(*i)); }
@@ -647,14 +564,12 @@ WASM_EXEC_TEST(I64Popcnt) {
 }
 
 WASM_EXEC_TEST(F32SConvertI64) {
-  REQUIRE(F32SConvertI64);
   WasmRunner<float, int64_t> r(execution_mode);
   BUILD(r, WASM_F32_SCONVERT_I64(WASM_GET_LOCAL(0)));
   FOR_INT64_INPUTS(i) { CHECK_FLOAT_EQ(static_cast<float>(*i), r.Call(*i)); }
 }
 
 WASM_EXEC_TEST(F32UConvertI64) {
-  REQUIRE(F32UConvertI64);
   struct {
     uint64_t input;
     uint32_t expected;
@@ -742,14 +657,12 @@ WASM_EXEC_TEST(F32UConvertI64) {
 }
 
 WASM_EXEC_TEST(F64SConvertI64) {
-  REQUIRE(F64SConvertI64);
   WasmRunner<double, int64_t> r(execution_mode);
   BUILD(r, WASM_F64_SCONVERT_I64(WASM_GET_LOCAL(0)));
   FOR_INT64_INPUTS(i) { CHECK_DOUBLE_EQ(static_cast<double>(*i), r.Call(*i)); }
 }
 
 WASM_EXEC_TEST(F64UConvertI64) {
-  REQUIRE(F64UConvertI64);
   struct {
     uint64_t input;
     uint64_t expected;
@@ -835,7 +748,7 @@ WASM_EXEC_TEST(F64UConvertI64) {
   }
 }
 
-WASM_EXEC_TEST(I64SConvertF32a) {
+WASM_EXEC_TEST(I64SConvertF32) {
   WasmRunner<int64_t, float> r(execution_mode);
   BUILD(r, WASM_I64_SCONVERT_F32(WASM_GET_LOCAL(0)));
 
@@ -849,7 +762,7 @@ WASM_EXEC_TEST(I64SConvertF32a) {
   }
 }
 
-WASM_EXEC_TEST(I64SConvertSatF32a) {
+WASM_EXEC_TEST(I64SConvertSatF32) {
   EXPERIMENTAL_FLAG_SCOPE(sat_f2i_conversions);
   WasmRunner<int64_t, float> r(execution_mode);
   BUILD(r, WASM_I64_SCONVERT_SAT_F32(WASM_GET_LOCAL(0)));
@@ -870,7 +783,7 @@ WASM_EXEC_TEST(I64SConvertSatF32a) {
   }
 }
 
-WASM_EXEC_TEST(I64SConvertF64a) {
+WASM_EXEC_TEST(I64SConvertF64) {
   WasmRunner<int64_t, double> r(execution_mode);
   BUILD(r, WASM_I64_SCONVERT_F64(WASM_GET_LOCAL(0)));
 
@@ -884,7 +797,7 @@ WASM_EXEC_TEST(I64SConvertF64a) {
   }
 }
 
-WASM_EXEC_TEST(I64UConvertF32a) {
+WASM_EXEC_TEST(I64UConvertF32) {
   WasmRunner<uint64_t, float> r(execution_mode);
   BUILD(r, WASM_I64_UCONVERT_F32(WASM_GET_LOCAL(0)));
 
@@ -898,7 +811,7 @@ WASM_EXEC_TEST(I64UConvertF32a) {
   }
 }
 
-WASM_EXEC_TEST(I64UConvertF64a) {
+WASM_EXEC_TEST(I64UConvertF64) {
   WasmRunner<uint64_t, double> r(execution_mode);
   BUILD(r, WASM_I64_UCONVERT_F64(WASM_GET_LOCAL(0)));
 
@@ -997,7 +910,7 @@ void TestI64Cmp(WasmExecutionMode execution_mode, WasmOpcode opcode,
 
 #define TEST_I64_BINOP(name, expected, a, b)                     \
   do {                                                           \
-    if (WASM_64 || kSupported_##name)                            \
+    if (SupportsOpcode(kExpr##name))                             \
       TestI64Binop(execution_mode, kExpr##name, expected, a, b); \
   } while (false)
 
@@ -1037,7 +950,7 @@ WASM_EXEC_TEST(I64Binops) {
 
 #define TEST_I64_CMP(name, expected, a, b)                     \
   do {                                                         \
-    if (WASM_64 || kSupported_##name)                          \
+    if (SupportsOpcode(kExpr##name))                           \
       TestI64Cmp(execution_mode, kExpr##name, expected, a, b); \
   } while (false)
 
@@ -1057,7 +970,6 @@ WASM_EXEC_TEST(I64Compare) {
 #undef TEST_I64_CMP
 
 WASM_EXEC_TEST(I64Clz) {
-  REQUIRE(I64Clz);
   struct {
     int64_t expected;
     uint64_t input;
@@ -1103,7 +1015,6 @@ WASM_EXEC_TEST(I64Clz) {
 }
 
 WASM_EXEC_TEST(I64Ctz) {
-  REQUIRE(I64Ctz);
   struct {
     int64_t expected;
     uint64_t input;
@@ -1149,7 +1060,6 @@ WASM_EXEC_TEST(I64Ctz) {
 }
 
 WASM_EXEC_TEST(I64Popcnt2) {
-  REQUIRE(I64Popcnt);
   struct {
     int64_t expected;
     uint64_t input;
@@ -1169,8 +1079,6 @@ WASM_EXEC_TEST(I64Popcnt2) {
 // Test the WasmRunner with an Int64 return value and different numbers of
 // Int64 parameters.
 WASM_EXEC_TEST(I64WasmRunner) {
-  REQUIRE(I64Param);
-  REQUIRE(I64Xor);
   {FOR_INT64_INPUTS(i){WasmRunner<int64_t> r(execution_mode);
   BUILD(r, WASM_I64V(*i));
   CHECK_EQ(*i, r.Call());
@@ -1218,7 +1126,6 @@ WASM_EXEC_TEST(I64WasmRunner) {
 }
 
 WASM_EXEC_TEST(Call_Int64Sub) {
-  REQUIRE(I64Sub);
   WasmRunner<int64_t, int64_t, int64_t> r(execution_mode);
   // Build the target function.
   TestSignatures sigs;
@@ -1244,8 +1151,6 @@ WASM_EXEC_TEST(Call_Int64Sub) {
 }
 
 WASM_EXEC_TEST(LoadStoreI64_sx) {
-  REQUIRE(I64LoadStore);
-  REQUIRE(DepthFirst);
   byte loads[] = {kExprI64LoadMem8S, kExprI64LoadMem16S, kExprI64LoadMem32S,
                   kExprI64LoadMem};
 
@@ -1287,89 +1192,8 @@ WASM_EXEC_TEST(LoadStoreI64_sx) {
   }
 }
 
-WASM_EXEC_TEST(I64SConvertF32b) {
-  REQUIRE(I64SConvertF32);
-  WasmRunner<int64_t, float> r(execution_mode);
-  BUILD(r, WASM_I64_SCONVERT_F32(WASM_GET_LOCAL(0)));
-
-  FOR_FLOAT32_INPUTS(i) {
-    if (*i < static_cast<float>(INT64_MAX) &&
-        *i >= static_cast<float>(INT64_MIN)) {
-      CHECK_EQ(static_cast<int64_t>(*i), r.Call(*i));
-    } else {
-      CHECK_TRAP64(r.Call(*i));
-    }
-  }
-}
-
-WASM_EXEC_TEST(I64SConvertSatF32b) {
-  EXPERIMENTAL_FLAG_SCOPE(sat_f2i_conversions);
-  REQUIRE(I64SConvertSatF32);
-  WasmRunner<int64_t, float> r(execution_mode);
-  BUILD(r, WASM_I64_SCONVERT_SAT_F32(WASM_GET_LOCAL(0)));
-
-  FOR_FLOAT32_INPUTS(i) {
-    int64_t expected;
-    if (*i < static_cast<float>(INT64_MAX) &&
-        *i >= static_cast<float>(INT64_MIN)) {
-      expected = static_cast<int64_t>(*i);
-    } else if (std::isnan(*i)) {
-      expected = static_cast<int64_t>(0);
-    } else if (*i < 0.0) {
-      expected = INT64_MIN;
-    } else {
-      expected = INT64_MAX;
-    }
-    int64_t found = r.Call(*i);
-    CHECK_EQ(expected, found);
-  }
-}
-
-WASM_EXEC_TEST(I64SConvertF64b) {
-  REQUIRE(I64SConvertF64);
-  WasmRunner<int64_t, double> r(execution_mode);
-  BUILD(r, WASM_I64_SCONVERT_F64(WASM_GET_LOCAL(0)));
-
-  FOR_FLOAT64_INPUTS(i) {
-    if (*i < static_cast<double>(INT64_MAX) &&
-        *i >= static_cast<double>(INT64_MIN)) {
-      CHECK_EQ(static_cast<int64_t>(*i), r.Call(*i));
-    } else {
-      CHECK_TRAP64(r.Call(*i));
-    }
-  }
-}
-
-WASM_EXEC_TEST(I64UConvertF32b) {
-  REQUIRE(I64UConvertF32);
-  WasmRunner<uint64_t, float> r(execution_mode);
-  BUILD(r, WASM_I64_UCONVERT_F32(WASM_GET_LOCAL(0)));
-
-  FOR_FLOAT32_INPUTS(i) {
-    if (*i < static_cast<float>(UINT64_MAX) && *i > -1) {
-      CHECK_EQ(static_cast<uint64_t>(*i), r.Call(*i));
-    } else {
-      CHECK_TRAP64(r.Call(*i));
-    }
-  }
-}
-
-WASM_EXEC_TEST(I64UConvertF64b) {
-  REQUIRE(I64UConvertF64);
-  WasmRunner<uint64_t, double> r(execution_mode);
-  BUILD(r, WASM_I64_UCONVERT_F64(WASM_GET_LOCAL(0)));
-
-  FOR_FLOAT64_INPUTS(i) {
-    if (*i < static_cast<float>(UINT64_MAX) && *i > -1) {
-      CHECK_EQ(static_cast<uint64_t>(*i), r.Call(*i));
-    } else {
-      CHECK_TRAP64(r.Call(*i));
-    }
-  }
-}
 
 WASM_EXEC_TEST(I64ReinterpretF64) {
-  REQUIRE(I64ReinterpretF64);
   WasmRunner<int64_t> r(execution_mode);
   int64_t* memory = r.builder().AddMemoryElems<int64_t>(8);
 
@@ -1384,7 +1208,6 @@ WASM_EXEC_TEST(I64ReinterpretF64) {
 }
 
 WASM_EXEC_TEST(SignallingNanSurvivesI64ReinterpretF64) {
-  REQUIRE(I64ReinterpretF64);
   WasmRunner<int64_t> r(execution_mode);
   BUILD(r, WASM_I64_REINTERPRET_F64(WASM_SEQ(kExprF64Const, 0x00, 0x00, 0x00,
                                              0x00, 0x00, 0x00, 0xF4, 0x7F)));
@@ -1394,7 +1217,6 @@ WASM_EXEC_TEST(SignallingNanSurvivesI64ReinterpretF64) {
 }
 
 WASM_EXEC_TEST(F64ReinterpretI64) {
-  REQUIRE(F64ReinterpretI64);
   WasmRunner<int64_t, int64_t> r(execution_mode);
   int64_t* memory = r.builder().AddMemoryElems<int64_t>(8);
 
@@ -1410,7 +1232,6 @@ WASM_EXEC_TEST(F64ReinterpretI64) {
 }
 
 WASM_EXEC_TEST(LoadMemI64) {
-  REQUIRE(I64LoadStore);
   WasmRunner<int64_t> r(execution_mode);
   int64_t* memory = r.builder().AddMemoryElems<int64_t>(8);
   r.builder().RandomizeMemory(1111);
@@ -1428,7 +1249,6 @@ WASM_EXEC_TEST(LoadMemI64) {
 }
 
 WASM_EXEC_TEST(LoadMemI64_alignment) {
-  REQUIRE(I64LoadStore);
   for (byte alignment = 0; alignment <= 3; alignment++) {
     WasmRunner<int64_t> r(execution_mode);
     int64_t* memory = r.builder().AddMemoryElems<int64_t>(8);
@@ -1449,10 +1269,6 @@ WASM_EXEC_TEST(LoadMemI64_alignment) {
 }
 
 WASM_EXEC_TEST(MemI64_Sum) {
-  REQUIRE(I64LoadStore);
-  REQUIRE(I64Add);
-  REQUIRE(I64Sub);
-  REQUIRE(I64Phi);
   const int kNumElems = 20;
   WasmRunner<uint64_t, int32_t> r(execution_mode);
   uint64_t* memory = r.builder().AddMemoryElems<uint64_t>(kNumElems);
@@ -1499,10 +1315,6 @@ WASM_EXEC_TEST(StoreMemI64_alignment) {
 }
 
 WASM_EXEC_TEST(I64Global) {
-  REQUIRE(I64LoadStore);
-  REQUIRE(I64SConvertI32);
-  REQUIRE(I64And);
-  REQUIRE(DepthFirst);
   WasmRunner<int32_t, int32_t> r(execution_mode);
   int64_t* global = r.builder().AddGlobal<int64_t>();
   // global = global + p0
@@ -1520,8 +1332,6 @@ WASM_EXEC_TEST(I64Global) {
 }
 
 WASM_EXEC_TEST(I64Eqz) {
-  REQUIRE(I64Eq);
-
   WasmRunner<int32_t, int64_t> r(execution_mode);
   BUILD(r, WASM_I64_EQZ(WASM_GET_LOCAL(0)));
 
@@ -1532,7 +1342,6 @@ WASM_EXEC_TEST(I64Eqz) {
 }
 
 WASM_EXEC_TEST(I64Ror) {
-  REQUIRE(I64Ror);
   WasmRunner<int64_t, int64_t, int64_t> r(execution_mode);
   BUILD(r, WASM_I64_ROR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
 
@@ -1545,7 +1354,6 @@ WASM_EXEC_TEST(I64Ror) {
 }
 
 WASM_EXEC_TEST(I64Rol) {
-  REQUIRE(I64Rol);
   WasmRunner<int64_t, int64_t, int64_t> r(execution_mode);
   BUILD(r, WASM_I64_ROL(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
 
@@ -1748,9 +1556,6 @@ WASM_EXEC_TEST(MixedCall_i64_2) { Run_WasmMixedCall_N(execution_mode, 2); }
 WASM_EXEC_TEST(MixedCall_i64_3) { Run_WasmMixedCall_N(execution_mode, 3); }
 
 WASM_EXEC_TEST(Regress5874) {
-  REQUIRE(I32ConvertI64);
-  REQUIRE(I64LoadStore);
-  REQUIRE(I64Const);
   WasmRunner<int32_t> r(execution_mode);
   r.builder().AddMemoryElems<int64_t>(8);
 
@@ -1764,7 +1569,6 @@ WASM_EXEC_TEST(Regress5874) {
 }
 
 WASM_EXEC_TEST(Regression_6858) {
-  REQUIRE(I64DivS);
   // WasmRunner with 5 params and returns, which is the maximum.
   WasmRunner<int64_t, int64_t, int64_t, int64_t, int64_t> r(execution_mode);
   BUILD(r, WASM_I64_DIVS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));