[wasm]implement simd lowering for F32x4 and I32x4 binops

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

+// Copyright 2017 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 "test/cctest/wasm/test-wasm-simd-common.h"
+
+void TestWasmSimdCommon::RunF32x4SplatTest() {
+  FLAG_wasm_simd_prototype = true;
+
+  WasmRunner<int32_t, float> r(kExecuteCompiled);
+  byte lane_val = 0;
+  byte simd = r.AllocateLocal(kWasmS128);
+  BUILD(r,
+        WASM_SET_LOCAL(simd, WASM_SIMD_F32x4_SPLAT(WASM_GET_LOCAL(lane_val))),
+        WASM_SIMD_CHECK_SPLAT4_F32(F32x4, simd, lane_val), WASM_ONE);
+
+  FOR_FLOAT32_INPUTS(i) { CHECK_EQ(1, r.Call(*i)); }
+}
+
+void TestWasmSimdCommon::RunF32x4ReplaceLaneTest() {
+  FLAG_wasm_simd_prototype = true;
+  WasmRunner<int32_t, float, float> r(kExecuteCompiled);
+  byte old_val = 0;
+  byte new_val = 1;
+  byte simd = r.AllocateLocal(kWasmS128);
+  BUILD(r, WASM_SET_LOCAL(simd, WASM_SIMD_F32x4_SPLAT(WASM_GET_LOCAL(old_val))),
+        WASM_SET_LOCAL(simd,
+                       WASM_SIMD_F32x4_REPLACE_LANE(0, WASM_GET_LOCAL(simd),
+                                                    WASM_GET_LOCAL(new_val))),
+        WASM_SIMD_CHECK4(F32x4, simd, F32, new_val, old_val, old_val, old_val),
+        WASM_SET_LOCAL(simd,
+                       WASM_SIMD_F32x4_REPLACE_LANE(1, WASM_GET_LOCAL(simd),
+                                                    WASM_GET_LOCAL(new_val))),
+        WASM_SIMD_CHECK4(F32x4, simd, F32, new_val, new_val, old_val, old_val),
+        WASM_SET_LOCAL(simd,
+                       WASM_SIMD_F32x4_REPLACE_LANE(2, WASM_GET_LOCAL(simd),
+                                                    WASM_GET_LOCAL(new_val))),
+        WASM_SIMD_CHECK4(F32x4, simd, F32, new_val, new_val, new_val, old_val),
+        WASM_SET_LOCAL(simd,
+                       WASM_SIMD_F32x4_REPLACE_LANE(3, WASM_GET_LOCAL(simd),
+                                                    WASM_GET_LOCAL(new_val))),
+        WASM_SIMD_CHECK_SPLAT4(F32x4, simd, F32, new_val), WASM_ONE);
+
+  CHECK_EQ(1, r.Call(3.14159f, -1.5f));
+}
+
+void TestWasmSimdCommon::RunF32x4BinOpTest(WasmOpcode simd_op,
+                                           FloatBinOp expected_op,
+                                           bool skip_zero_inputs) {
+  FLAG_wasm_simd_prototype = true;
+  WasmRunner<int32_t, float, float, float> 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_F32x4_SPLAT(WASM_GET_LOCAL(a))),
+        WASM_SET_LOCAL(simd1, WASM_SIMD_F32x4_SPLAT(WASM_GET_LOCAL(b))),
+        WASM_SET_LOCAL(simd1, WASM_SIMD_BINOP(simd_op, WASM_GET_LOCAL(simd0),
+                                              WASM_GET_LOCAL(simd1))),
+        WASM_SIMD_CHECK_SPLAT4_F32(F32x4, simd1, expected), WASM_ONE);
+
+  FOR_FLOAT32_INPUTS(i) {
+    if (std::isnan(*i)) continue;
+    FOR_FLOAT32_INPUTS(j) {
+      if (std::isnan(*j)) continue;
+      if (skip_zero_inputs && std::fpclassify(*i) == FP_ZERO &&
+          std::fpclassify(*j) == FP_ZERO)
+        continue;
+      float expected = expected_op(*i, *j);
+      // SIMD on some platforms may handle denormalized numbers differently.
+      // TODO(bbudge) On platforms that flush denorms to zero, test with
+      // expected == 0.
+      if (std::fpclassify(expected) == FP_SUBNORMAL) continue;
+      if (std::isnan(expected)) continue;
+      CHECK_EQ(1, r.Call(*i, *j, expected));
+    }
+  }
+}
+
+void TestWasmSimdCommon::RunI32x4SplatTest() {
+  FLAG_wasm_simd_prototype = true;
+
+  // Store SIMD value in a local variable, use extract lane to check lane values
+  // This test is not a test for ExtractLane as Splat does not create
+  // interesting SIMD values.
+  //
+  // SetLocal(1, I32x4Splat(Local(0)));
+  // For each lane index
+  // if(Local(0) != I32x4ExtractLane(Local(1), index)
+  //   return 0
+  //
+  // return 1
+  WasmRunner<int32_t, int32_t> r(kExecuteCompiled);
+  byte lane_val = 0;
+  byte simd = r.AllocateLocal(kWasmS128);
+  BUILD(r,
+        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)); }
+}
+
+void TestWasmSimdCommon::RunI32x4ReplaceLaneTest() {
+  FLAG_wasm_simd_prototype = true;
+  WasmRunner<int32_t, int32_t, int32_t> r(kExecuteCompiled);
+  byte old_val = 0;
+  byte new_val = 1;
+  byte simd = r.AllocateLocal(kWasmS128);
+  BUILD(r, WASM_SET_LOCAL(simd, WASM_SIMD_I32x4_SPLAT(WASM_GET_LOCAL(old_val))),
+        WASM_SET_LOCAL(simd,
+                       WASM_SIMD_I32x4_REPLACE_LANE(0, WASM_GET_LOCAL(simd),
+                                                    WASM_GET_LOCAL(new_val))),
+        WASM_SIMD_CHECK4(I32x4, simd, I32, new_val, old_val, old_val, old_val),
+        WASM_SET_LOCAL(simd,
+                       WASM_SIMD_I32x4_REPLACE_LANE(1, WASM_GET_LOCAL(simd),
+                                                    WASM_GET_LOCAL(new_val))),
+        WASM_SIMD_CHECK4(I32x4, simd, I32, new_val, new_val, old_val, old_val),
+        WASM_SET_LOCAL(simd,
+                       WASM_SIMD_I32x4_REPLACE_LANE(2, WASM_GET_LOCAL(simd),
+                                                    WASM_GET_LOCAL(new_val))),
+        WASM_SIMD_CHECK4(I32x4, simd, I32, new_val, new_val, new_val, old_val),
+        WASM_SET_LOCAL(simd,
+                       WASM_SIMD_I32x4_REPLACE_LANE(3, WASM_GET_LOCAL(simd),
+                                                    WASM_GET_LOCAL(new_val))),
+        WASM_SIMD_CHECK_SPLAT4(I32x4, simd, I32, new_val), WASM_ONE);
+
+  CHECK_EQ(1, r.Call(1, 2));
+}
+
+void TestWasmSimdCommon::RunI32x4BinOpTest(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_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))); }
+  }
+}