[wasm]implement simd lowering for simple F32x4 and I32x4 unops

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 <cmath>

[gdeepti, 2017/02/28 09:50:49]

Header not needed here, already included in cctest.h (utils). 

[aseemgarg, 2017/02/28 12:54:07]

Done.

 #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"
 
 using namespace v8::base;
 using namespace v8::internal;
 using namespace v8::internal::compiler;
 using namespace v8::internal::wasm;
@@ skipping 190 matching lines @@
 template <typename T>
 T Xor(T a, T b) {
   return a ^ b;
 }
 
 template <typename T>
 T Not(T a) {
   return ~a;
 }
 
+template <typename T>
+T Sqrt(T a) {
+  return std::sqrt(a);
+}
+
 }  // namespace
 
 #if !V8_TARGET_ARCH_ARM && !V8_TARGET_ARCH_X64
 #define SIMD_LOWERING_TARGET 1
 #else
 #define SIMD_LOWERING_TARGET 0
 #endif  // !V8_TARGET_ARCH_ARM && !V8_TARGET_ARCH_X64
 
 // TODO(gdeepti): These are tests using sample values to verify functional
 // correctness of opcodes, add more tests for a range of values and macroize
@@ skipping 147 matching lines @@
                        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));
 }
-#endif  // V8_TARGET_ARCH_ARM || SIMD_LOWERING_TARGET
 
-#if V8_TARGET_ARCH_ARM
 // Tests both signed and unsigned conversion.
 WASM_EXEC_COMPILED_TEST(F32x4FromInt32x4) {
   FLAG_wasm_simd_prototype = true;
   WasmRunner<int32_t, int32_t, float, float> r(kExecuteCompiled);
   byte a = 0;
   byte expected_signed = 1;
   byte expected_unsigned = 2;
   byte simd0 = r.AllocateLocal(kWasmS128);
   byte simd1 = r.AllocateLocal(kWasmS128);
   byte simd2 = r.AllocateLocal(kWasmS128);
@@ skipping 21 matching lines @@
         WASM_SIMD_CHECK_SPLAT4_F32(F32x4, simd, expected), WASM_ONE);
 
   FOR_FLOAT32_INPUTS(i) {
     if (std::isnan(*i)) continue;
     CHECK_EQ(1, r.Call(*i, expected_op(*i)));
   }
 }
 
 WASM_EXEC_COMPILED_TEST(F32x4Abs) { RunF32x4UnOpTest(kExprF32x4Abs, std::abs); }
 WASM_EXEC_COMPILED_TEST(F32x4Neg) { RunF32x4UnOpTest(kExprF32x4Neg, Negate); }
-#endif  // V8_TARGET_ARCH_ARM
+#endif  // V8_TARGET_ARCH_ARM || SIMD_LOWERING_TARGET
+
+#if SIMD_LOWERING_TARGET
+WASM_EXEC_COMPILED_TEST(F32x4Sqrt) { RunF32x4UnOpTest(kExprF32x4Sqrt, Sqrt); }
+#endif  // SIMD_LOWERING_TARGET
 
 #if V8_TARGET_ARCH_ARM || SIMD_LOWERING_TARGET
 void RunF32x4BinOpTest(WasmOpcode simd_op, FloatBinOp expected_op,
                        bool skip_zero_inputs = false) {
   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);
@@ skipping 364 matching lines @@
       WASM_SIMD_CHECK_SPLAT4(I32x4, simd1, I32, expected_signed),
       WASM_SET_LOCAL(simd2, WASM_SIMD_U32x4_FROM_F32x4(WASM_GET_LOCAL(simd0))),
       WASM_SIMD_CHECK_SPLAT4(I32x4, simd2, I32, expected_unsigned), WASM_ONE);
 
   FOR_FLOAT32_INPUTS(i) {
     int32_t signed_value = ConvertToInt(*i, false);
     int32_t unsigned_value = ConvertToInt(*i, true);
     CHECK_EQ(1, r.Call(*i, signed_value, unsigned_value));
   }
 }
+#endif  // V8_TARGET_ARCH_ARM
 
+#if V8_TARGET_ARCH_ARM || SIMD_LOWERING_TARGET
 void RunI32x4UnOpTest(WasmOpcode simd_op, Int32UnOp expected_op) {
   FLAG_wasm_simd_prototype = true;
   WasmRunner<int32_t, int32_t, int32_t> r(kExecuteCompiled);
   byte a = 0;
   byte expected = 1;
   byte simd = r.AllocateLocal(kWasmS128);
   BUILD(r, WASM_SET_LOCAL(simd, WASM_SIMD_I32x4_SPLAT(WASM_GET_LOCAL(a))),
         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))); }
 }
 
 WASM_EXEC_COMPILED_TEST(I32x4Neg) { RunI32x4UnOpTest(kExprI32x4Neg, Negate); }
 
 WASM_EXEC_COMPILED_TEST(S128Not) { RunI32x4UnOpTest(kExprS128Not, Not); }
-#endif  // V8_TARGET_ARCH_ARM
+#endif  // V8_TARGET_ARCH_ARM || SIMD_LOWERING_TARGET
 
 void 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))),
@@ skipping 712 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