Add Int32x4 Wasm Simd Binops, compare ops, select

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

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/assembler-inl.h"
 #include "src/wasm/wasm-macro-gen.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/compiler/value-helper.h"
 #include "test/cctest/wasm/wasm-run-utils.h"
 
@@ skipping 832 matching lines @@
 
   FOR_INT32_INPUTS(i) {
     FOR_INT32_INPUTS(j) { CHECK_EQ(1, r.Call(*i, *j, expected_op(*i, *j))); }
   }
 }
 
 WASM_EXEC_COMPILED_TEST(I32x4Add) { RunI32x4BinOpTest(kExprI32x4Add, Add); }
 
 WASM_EXEC_COMPILED_TEST(I32x4Sub) { RunI32x4BinOpTest(kExprI32x4Sub, Sub); }
 
-#if V8_TARGET_ARCH_ARM || SIMD_LOWERING_TARGET
 WASM_EXEC_COMPILED_TEST(I32x4Mul) { RunI32x4BinOpTest(kExprI32x4Mul, Mul); }
 
+#if V8_TARGET_ARCH_ARM || SIMD_LOWERING_TARGET
 WASM_EXEC_COMPILED_TEST(S128And) { RunI32x4BinOpTest(kExprS128And, And); }
 
 WASM_EXEC_COMPILED_TEST(S128Or) { RunI32x4BinOpTest(kExprS128Or, Or); }
 
 WASM_EXEC_COMPILED_TEST(S128Xor) { RunI32x4BinOpTest(kExprS128Xor, Xor); }
 #endif  // V8_TARGET_ARCH_ARM || SIMD_LOWERING_TARGET
 
-#if V8_TARGET_ARCH_ARM
+#if V8_TARGET_ARCH_ARM || V8_TARGET_ARCH_X64
 WASM_EXEC_COMPILED_TEST(I32x4Min) {
   RunI32x4BinOpTest(kExprI32x4MinS, Minimum);
 }
 
 WASM_EXEC_COMPILED_TEST(I32x4Max) {
   RunI32x4BinOpTest(kExprI32x4MaxS, Maximum);
 }
 
 WASM_EXEC_COMPILED_TEST(Ui32x4Min) {
   RunI32x4BinOpTest(kExprI32x4MinU, UnsignedMinimum);
 }
 
 WASM_EXEC_COMPILED_TEST(Ui32x4Max) {
   RunI32x4BinOpTest(kExprI32x4MaxU, UnsignedMaximum);
 }
 
-
-
 void RunI32x4CompareOpTest(WasmOpcode simd_op, Int32BinOp expected_op) {
   FLAG_wasm_simd_prototype = true;
   WasmRunner<int32_t, int32_t, int32_t, int32_t> r(kExecuteCompiled);
   byte a = 0;
   byte b = 1;
   byte expected = 2;
   byte simd0 = r.AllocateLocal(kWasmS128);
   byte simd1 = r.AllocateLocal(kWasmS128);
   BUILD(r, WASM_SET_LOCAL(simd0, WASM_SIMD_I32x4_SPLAT(WASM_GET_LOCAL(a))),
         WASM_SET_LOCAL(simd1, WASM_SIMD_I32x4_SPLAT(WASM_GET_LOCAL(b))),
         WASM_SET_LOCAL(simd1,
                        WASM_SIMD_MATERIALIZE_BOOLS(
                            32x4, WASM_SIMD_BINOP(simd_op, WASM_GET_LOCAL(simd0),
                                                  WASM_GET_LOCAL(simd1)))),
         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))); }
   }
 }
 
 WASM_EXEC_COMPILED_TEST(I32x4Equal) {
   RunI32x4CompareOpTest(kExprI32x4Eq, Equal);
 }
 
 WASM_EXEC_COMPILED_TEST(I32x4NotEqual) {
   RunI32x4CompareOpTest(kExprI32x4Ne, NotEqual);
 }
 
+// Test Select by making a mask where the first two lanes are true and the rest
+// false, and comparing for non-equality with zero to materialize a bool vector.
+#define WASM_SIMD_SELECT_TEST(format)                                         \
+  WASM_EXEC_COMPILED_TEST(S##format##Select) {                                \
+    FLAG_wasm_simd_prototype = true;                                          \
+    WasmRunner<int32_t, int32_t, int32_t> r(kExecuteCompiled);                \
+    byte val1 = 0;                                                            \
+    byte val2 = 1;                                                            \
+    byte src1 = r.AllocateLocal(kWasmS128);                                   \
+    byte src2 = r.AllocateLocal(kWasmS128);                                   \
+    byte zero = r.AllocateLocal(kWasmS128);                                   \
+    byte mask = r.AllocateLocal(kWasmS128);                                   \
+    BUILD(r, WASM_SET_LOCAL(                                                  \
+                 src1, WASM_SIMD_I##format##_SPLAT(WASM_GET_LOCAL(val1))),    \
+          WASM_SET_LOCAL(src2,                                                \
+                         WASM_SIMD_I##format##_SPLAT(WASM_GET_LOCAL(val2))),  \
+          WASM_SET_LOCAL(zero, WASM_SIMD_I##format##_SPLAT(WASM_ZERO)),       \
+          WASM_SET_LOCAL(mask, WASM_SIMD_I##format##_REPLACE_LANE(            \
+                                   1, WASM_GET_LOCAL(zero), WASM_I32V(-1))),  \
+          WASM_SET_LOCAL(mask, WASM_SIMD_I##format##_REPLACE_LANE(            \
+                                   2, WASM_GET_LOCAL(mask), WASM_I32V(-1))),  \
+          WASM_SET_LOCAL(                                                     \
+              mask,                                                           \
+              WASM_SIMD_SELECT(format, WASM_SIMD_BINOP(kExprI##format##Ne,    \
+                                                       WASM_GET_LOCAL(mask),  \
+                                                       WASM_GET_LOCAL(zero)), \
+                               WASM_GET_LOCAL(src1), WASM_GET_LOCAL(src2))),  \
+          WASM_SIMD_CHECK_LANE(I##format, mask, I32, val2, 0),                \
+          WASM_SIMD_CHECK_LANE(I##format, mask, I32, val1, 1),                \
+          WASM_SIMD_CHECK_LANE(I##format, mask, I32, val1, 2),                \
+          WASM_SIMD_CHECK_LANE(I##format, mask, I32, val2, 3), WASM_ONE);     \
+                                                                              \
+    CHECK_EQ(1, r.Call(0x12, 0x34));                                          \
+  }
+
+WASM_SIMD_SELECT_TEST(32x4)
+#endif  // V8_TARGET_ARCH_ARM || V8_TARGET_ARCH_X64
+
+#if V8_TARGET_ARCH_ARM
 WASM_EXEC_COMPILED_TEST(I32x4Greater) {
   RunI32x4CompareOpTest(kExprI32x4GtS, Greater);
 }
 
 WASM_EXEC_COMPILED_TEST(I32x4GreaterEqual) {
   RunI32x4CompareOpTest(kExprI32x4GeS, GreaterEqual);
 }
 
 WASM_EXEC_COMPILED_TEST(I32x4Less) {
   RunI32x4CompareOpTest(kExprI32x4LtS, Less);
@@ skipping 359 matching lines @@
 }
 
 WASM_EXEC_COMPILED_TEST(I8x16ShrS) {
   RunI8x16ShiftOpTest(kExprI8x16ShrS, ArithmeticShiftRight, 1);
 }
 
 WASM_EXEC_COMPILED_TEST(I8x16ShrU) {
   RunI8x16ShiftOpTest(kExprI8x16ShrU, LogicalShiftRight, 1);
 }
 
-// Test Select by making a mask where the first two lanes are true and the rest
-// false, and comparing for non-equality with zero to materialize a bool vector.
-#define WASM_SIMD_SELECT_TEST(format)                                         \
-  WASM_EXEC_COMPILED_TEST(S##format##Select) {                                \
-    FLAG_wasm_simd_prototype = true;                                          \
-    WasmRunner<int32_t, int32_t, int32_t> r(kExecuteCompiled);                \
-    byte val1 = 0;                                                            \
-    byte val2 = 1;                                                            \
-    byte src1 = r.AllocateLocal(kWasmS128);                                   \
-    byte src2 = r.AllocateLocal(kWasmS128);                                   \
-    byte zero = r.AllocateLocal(kWasmS128);                                   \
-    byte mask = r.AllocateLocal(kWasmS128);                                   \
-    BUILD(r, WASM_SET_LOCAL(                                                  \
-                 src1, WASM_SIMD_I##format##_SPLAT(WASM_GET_LOCAL(val1))),    \
-          WASM_SET_LOCAL(src2,                                                \
-                         WASM_SIMD_I##format##_SPLAT(WASM_GET_LOCAL(val2))),  \
-          WASM_SET_LOCAL(zero, WASM_SIMD_I##format##_SPLAT(WASM_ZERO)),       \
-          WASM_SET_LOCAL(mask, WASM_SIMD_I##format##_REPLACE_LANE(            \
-                                   1, WASM_GET_LOCAL(zero), WASM_I32V(-1))),  \
-          WASM_SET_LOCAL(mask, WASM_SIMD_I##format##_REPLACE_LANE(            \
-                                   2, WASM_GET_LOCAL(mask), WASM_I32V(-1))),  \
-          WASM_SET_LOCAL(                                                     \
-              mask,                                                           \
-              WASM_SIMD_SELECT(format, WASM_SIMD_BINOP(kExprI##format##Ne,    \
-                                                       WASM_GET_LOCAL(mask),  \
-                                                       WASM_GET_LOCAL(zero)), \
-                               WASM_GET_LOCAL(src1), WASM_GET_LOCAL(src2))),  \
-          WASM_SIMD_CHECK_LANE(I##format, mask, I32, val2, 0),                \
-          WASM_SIMD_CHECK_LANE(I##format, mask, I32, val1, 1),                \
-          WASM_SIMD_CHECK_LANE(I##format, mask, I32, val1, 2),                \
-          WASM_SIMD_CHECK_LANE(I##format, mask, I32, val2, 3), WASM_ONE);     \
-                                                                              \
-    CHECK_EQ(1, r.Call(0x12, 0x34));                                          \
-  }
-
-WASM_SIMD_SELECT_TEST(32x4)
 WASM_SIMD_SELECT_TEST(16x8)
 WASM_SIMD_SELECT_TEST(8x16)
 #endif  // V8_TARGET_ARCH_ARM
 
 #if V8_TARGET_ARCH_ARM || SIMD_LOWERING_TARGET
 WASM_EXEC_COMPILED_TEST(SimdI32x4ExtractWithF32x4) {
   FLAG_wasm_simd_prototype = true;
   WasmRunner<int32_t> r(kExecuteCompiled);
   BUILD(r, WASM_IF_ELSE_I(
                WASM_I32_EQ(WASM_SIMD_I32x4_EXTRACT_LANE(
@@ skipping 215 matching lines @@
         WASM_SET_GLOBAL(0, WASM_SIMD_F32x4_REPLACE_LANE(3, WASM_GET_GLOBAL(0),
                                                         WASM_F32(65.0))),
         WASM_I32V(1));
   FOR_INT32_INPUTS(i) { CHECK_EQ(1, r.Call(0)); }
   CHECK_EQ(*global, 13.5);
   CHECK_EQ(*(global + 1), 45.5);
   CHECK_EQ(*(global + 2), 32.25);
   CHECK_EQ(*(global + 3), 65.0);
 }
 #endif  // SIMD_LOWERING_TARGET