[wasm] Add simd binops to wasm interpreter

R=gdeepti@chromium.org,bbudge@chromium.org,clemensh@chromium.org,titzer@chromium.org
BUG=v8:6020

Change-Id: I671d74b49206a3612764c7b9cb63591e7e81e857
Reviewed-on: https://chromium-review.googlesource.com/1069933
Commit-Queue: Aseem Garg <aseemgarg@chromium.org>
Reviewed-by: Ben Titzer <titzer@chromium.org>
Cr-Commit-Position: refs/heads/master@{#53316}

src/wasm/wasm-interpreter.cc

@@ -1653,6 +1653,63 @@ class ThreadImpl {
       EXTRACT_LANE_CASE(I16x8, i16x8)
       EXTRACT_LANE_CASE(I8x16, i8x16)
 #undef EXTRACT_LANE_CASE
+#define BINOP_CASE(op, name, stype, count, expr) \
+  case kExpr##op: {                              \
+    WasmValue v2 = Pop();                        \
+    WasmValue v1 = Pop();                        \
+    stype s1 = v1.to_s128().to_##name();         \
+    stype s2 = v2.to_s128().to_##name();         \
+    stype res;                                   \
+    for (size_t i = 0; i < count; ++i) {         \
+      auto a = s1.val[i];                        \
+      auto b = s2.val[i];                        \
+      res.val[i] = expr;                         \
+    }                                            \
+    Push(WasmValue(Simd128(res)));               \
+    return true;                                 \
+  }
+      BINOP_CASE(F32x4Add, f32x4, float4, 4, a + b)
+      BINOP_CASE(I32x4Add, i32x4, int4, 4, a + b)
+      BINOP_CASE(I16x8Add, i16x8, int8, 8, a + b)
+      BINOP_CASE(I8x16Add, i8x16, int16, 16, a + b)
+      BINOP_CASE(F32x4Sub, f32x4, float4, 4, a - b)
+      BINOP_CASE(I32x4Sub, i32x4, int4, 4, a - b)
+      BINOP_CASE(I16x8Sub, i16x8, int8, 8, a - b)
+      BINOP_CASE(I8x16Sub, i8x16, int16, 16, a - b)
+      BINOP_CASE(F32x4Mul, f32x4, float4, 4, a * b)
+      BINOP_CASE(I32x4Mul, i32x4, int4, 4, a * b)
+      BINOP_CASE(I16x8Mul, i16x8, int8, 8, a * b)
+      BINOP_CASE(I8x16Mul, i8x16, int16, 16, a * b)
+      BINOP_CASE(F32x4Min, f32x4, float4, 4, a < b ? a : b)
+      BINOP_CASE(I32x4MinS, i32x4, int4, 4, a < b ? a : b)
+      BINOP_CASE(I32x4MinU, ui32x4, uint4, 4, a < b ? a : b)
+      BINOP_CASE(I16x8MinS, i16x8, int8, 8, a < b ? a : b)
+      BINOP_CASE(I16x8MinU, ui16x8, uint8, 8, a < b ? a : b)
+      BINOP_CASE(I8x16MinS, i8x16, int16, 16, a < b ? a : b)
+      BINOP_CASE(I8x16MinU, ui8x16, uint16, 16, a < b ? a : b)
+      BINOP_CASE(F32x4Max, f32x4, float4, 4, a > b ? a : b)
+      BINOP_CASE(I32x4MaxS, i32x4, int4, 4, a > b ? a : b)
+      BINOP_CASE(I32x4MaxU, ui32x4, uint4, 4, a > b ? a : b)
+      BINOP_CASE(I16x8MaxS, i16x8, int8, 8, a > b ? a : b)
+      BINOP_CASE(I16x8MaxU, ui16x8, uint8, 8, a > b ? a : b)
+      BINOP_CASE(I8x16MaxS, i8x16, int16, 16, a > b ? a : b)
+      BINOP_CASE(I8x16MaxU, ui8x16, uint16, 16, a > b ? a : b)
+      BINOP_CASE(S128And, i32x4, int4, 4, a & b)
+      BINOP_CASE(S128Or, i32x4, int4, 4, a | b)
+      BINOP_CASE(S128Xor, i32x4, int4, 4, a ^ b)
+      BINOP_CASE(I16x8AddSaturateS, i16x8, int8, 8, SaturateAdd<int16_t>(a, b))
+      BINOP_CASE(I16x8AddSaturateU, ui16x8, uint8, 8,
+                 SaturateAdd<uint16_t>(a, b))
+      BINOP_CASE(I16x8SubSaturateS, i16x8, int8, 8, SaturateSub<int16_t>(a, b))
+      BINOP_CASE(I16x8SubSaturateU, ui16x8, uint8, 8,
+                 SaturateSub<uint16_t>(a, b))
+      BINOP_CASE(I8x16AddSaturateS, i8x16, int16, 16, SaturateAdd<int8_t>(a, b))
+      BINOP_CASE(I8x16AddSaturateU, ui8x16, uint16, 16,
+                 SaturateAdd<uint8_t>(a, b))
+      BINOP_CASE(I8x16SubSaturateS, i8x16, int16, 16, SaturateSub<int8_t>(a, b))
+      BINOP_CASE(I8x16SubSaturateU, ui8x16, uint16, 16,
+                 SaturateSub<uint8_t>(a, b))
+#undef BINOP_CASE
       default:
         return false;
     }

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

@@ -94,11 +94,6 @@ T Mul(T a, T b) {
   return a * b;
 }
 
-template <typename T>
-T Div(T a, T b) {
-  return a / b;
-}
-
 template <typename T>
 T Minimum(T a, T b) {
   return a <= b ? a : b;
@@ -561,19 +556,19 @@ void RunF32x4BinOpTest(WasmExecutionMode execution_mode, LowerSimd lower_simd,
   }
 }
 
-WASM_SIMD_COMPILED_AND_LOWERED_TEST(F32x4Add) {
+WASM_SIMD_TEST(F32x4Add) {
   RunF32x4BinOpTest(execution_mode, lower_simd, kExprF32x4Add, Add);
 }
-WASM_SIMD_COMPILED_AND_LOWERED_TEST(F32x4Sub) {
+WASM_SIMD_TEST(F32x4Sub) {
   RunF32x4BinOpTest(execution_mode, lower_simd, kExprF32x4Sub, Sub);
 }
-WASM_SIMD_COMPILED_AND_LOWERED_TEST(F32x4Mul) {
+WASM_SIMD_TEST(F32x4Mul) {
   RunF32x4BinOpTest(execution_mode, lower_simd, kExprF32x4Mul, Mul);
 }
-WASM_SIMD_COMPILED_AND_LOWERED_TEST(F32x4_Min) {
+WASM_SIMD_TEST(F32x4_Min) {
   RunF32x4BinOpTest(execution_mode, lower_simd, kExprF32x4Min, JSMin);
 }
-WASM_SIMD_COMPILED_AND_LOWERED_TEST(F32x4_Max) {
+WASM_SIMD_TEST(F32x4_Max) {
   RunF32x4BinOpTest(execution_mode, lower_simd, kExprF32x4Max, JSMax);
 }
 
@@ -957,45 +952,45 @@ void RunI32x4BinOpTest(WasmExecutionMode execution_mode, LowerSimd lower_simd,
   }
 }
 
-WASM_SIMD_COMPILED_AND_LOWERED_TEST(I32x4Add) {
+WASM_SIMD_TEST(I32x4Add) {
   RunI32x4BinOpTest(execution_mode, lower_simd, kExprI32x4Add, Add);
 }
 
-WASM_SIMD_COMPILED_AND_LOWERED_TEST(I32x4Sub) {
+WASM_SIMD_TEST(I32x4Sub) {
   RunI32x4BinOpTest(execution_mode, lower_simd, kExprI32x4Sub, Sub);
 }
 
-WASM_SIMD_COMPILED_AND_LOWERED_TEST(I32x4Mul) {
+WASM_SIMD_TEST(I32x4Mul) {
   RunI32x4BinOpTest(execution_mode, lower_simd, kExprI32x4Mul, Mul);
 }
 
-WASM_SIMD_COMPILED_AND_LOWERED_TEST(I32x4MinS) {
+WASM_SIMD_TEST(I32x4MinS) {
   RunI32x4BinOpTest(execution_mode, lower_simd, kExprI32x4MinS, Minimum);
 }
 
-WASM_SIMD_COMPILED_AND_LOWERED_TEST(I32x4MaxS) {
+WASM_SIMD_TEST(I32x4MaxS) {
   RunI32x4BinOpTest(execution_mode, lower_simd, kExprI32x4MaxS, Maximum);
 }
 
-WASM_SIMD_COMPILED_AND_LOWERED_TEST(I32x4MinU) {
+WASM_SIMD_TEST(I32x4MinU) {
   RunI32x4BinOpTest(execution_mode, lower_simd, kExprI32x4MinU,
                     UnsignedMinimum);
 }
-
-WASM_SIMD_COMPILED_AND_LOWERED_TEST(I32x4MaxU) {
+WASM_SIMD_TEST(I32x4MaxU) {
   RunI32x4BinOpTest(execution_mode, lower_simd, kExprI32x4MaxU,
+
                     UnsignedMaximum);
 }
 
-WASM_SIMD_COMPILED_AND_LOWERED_TEST(S128And) {
+WASM_SIMD_TEST(S128And) {
   RunI32x4BinOpTest(execution_mode, lower_simd, kExprS128And, And);
 }
 
-WASM_SIMD_COMPILED_AND_LOWERED_TEST(S128Or) {
+WASM_SIMD_TEST(S128Or) {
   RunI32x4BinOpTest(execution_mode, lower_simd, kExprS128Or, Or);
 }
 
-WASM_SIMD_COMPILED_AND_LOWERED_TEST(S128Xor) {
+WASM_SIMD_TEST(S128Xor) {
   RunI32x4BinOpTest(execution_mode, lower_simd, kExprS128Xor, Xor);
 }
 
@@ -1190,52 +1185,52 @@ void RunI16x8BinOpTest(WasmExecutionMode execution_mode, LowerSimd lower_simd,
   }
 }
 
-WASM_SIMD_COMPILED_AND_LOWERED_TEST(I16x8Add) {
+WASM_SIMD_TEST(I16x8Add) {
   RunI16x8BinOpTest(execution_mode, lower_simd, kExprI16x8Add, Add);
 }
 
-WASM_SIMD_COMPILED_AND_LOWERED_TEST(I16x8AddSaturateS) {
+WASM_SIMD_TEST(I16x8AddSaturateS) {
   RunI16x8BinOpTest(execution_mode, lower_simd, kExprI16x8AddSaturateS,
                     AddSaturate);
 }
 
-WASM_SIMD_COMPILED_AND_LOWERED_TEST(I16x8Sub) {
+WASM_SIMD_TEST(I16x8Sub) {
   RunI16x8BinOpTest(execution_mode, lower_simd, kExprI16x8Sub, Sub);
 }
 
-WASM_SIMD_COMPILED_AND_LOWERED_TEST(I16x8SubSaturateS) {
+WASM_SIMD_TEST(I16x8SubSaturateS) {
   RunI16x8BinOpTest(execution_mode, lower_simd, kExprI16x8SubSaturateS,
                     SubSaturate);
 }
 
-WASM_SIMD_COMPILED_AND_LOWERED_TEST(I16x8Mul) {
+WASM_SIMD_TEST(I16x8Mul) {
   RunI16x8BinOpTest(execution_mode, lower_simd, kExprI16x8Mul, Mul);
 }
 
-WASM_SIMD_COMPILED_AND_LOWERED_TEST(I16x8MinS) {
+WASM_SIMD_TEST(I16x8MinS) {
   RunI16x8BinOpTest(execution_mode, lower_simd, kExprI16x8MinS, Minimum);
 }
 
-WASM_SIMD_COMPILED_AND_LOWERED_TEST(I16x8MaxS) {
+WASM_SIMD_TEST(I16x8MaxS) {
   RunI16x8BinOpTest(execution_mode, lower_simd, kExprI16x8MaxS, Maximum);
 }
 
-WASM_SIMD_COMPILED_AND_LOWERED_TEST(I16x8AddSaturateU) {
+WASM_SIMD_TEST(I16x8AddSaturateU) {
   RunI16x8BinOpTest(execution_mode, lower_simd, kExprI16x8AddSaturateU,
                     UnsignedAddSaturate);
 }
 
-WASM_SIMD_COMPILED_AND_LOWERED_TEST(I16x8SubSaturateU) {
+WASM_SIMD_TEST(I16x8SubSaturateU) {
   RunI16x8BinOpTest(execution_mode, lower_simd, kExprI16x8SubSaturateU,
                     UnsignedSubSaturate);
 }
 
-WASM_SIMD_COMPILED_AND_LOWERED_TEST(I16x8MinU) {
+WASM_SIMD_TEST(I16x8MinU) {
   RunI16x8BinOpTest(execution_mode, lower_simd, kExprI16x8MinU,
                     UnsignedMinimum);
 }
 
-WASM_SIMD_COMPILED_AND_LOWERED_TEST(I16x8MaxU) {
+WASM_SIMD_TEST(I16x8MaxU) {
   RunI16x8BinOpTest(execution_mode, lower_simd, kExprI16x8MaxU,
                     UnsignedMaximum);
 }
@@ -1403,48 +1398,48 @@ void RunI8x16BinOpTest(WasmExecutionMode execution_mode, LowerSimd lower_simd,
   }
 }
 
-WASM_SIMD_COMPILED_AND_LOWERED_TEST(I8x16Add) {
+WASM_SIMD_TEST(I8x16Add) {
   RunI8x16BinOpTest(execution_mode, lower_simd, kExprI8x16Add, Add);
 }
 
-WASM_SIMD_COMPILED_AND_LOWERED_TEST(I8x16AddSaturateS) {
+WASM_SIMD_TEST(I8x16AddSaturateS) {
   RunI8x16BinOpTest(execution_mode, lower_simd, kExprI8x16AddSaturateS,
                     AddSaturate);
 }
 
-WASM_SIMD_COMPILED_AND_LOWERED_TEST(I8x16Sub) {
+WASM_SIMD_TEST(I8x16Sub) {
   RunI8x16BinOpTest(execution_mode, lower_simd, kExprI8x16Sub, Sub);
 }
 
-WASM_SIMD_COMPILED_AND_LOWERED_TEST(I8x16SubSaturateS) {
+WASM_SIMD_TEST(I8x16SubSaturateS) {
   RunI8x16BinOpTest(execution_mode, lower_simd, kExprI8x16SubSaturateS,
                     SubSaturate);
 }
 
-WASM_SIMD_COMPILED_AND_LOWERED_TEST(I8x16MinS) {
+WASM_SIMD_TEST(I8x16MinS) {
   RunI8x16BinOpTest(execution_mode, lower_simd, kExprI8x16MinS, Minimum);
 }
 
-WASM_SIMD_COMPILED_AND_LOWERED_TEST(I8x16MaxS) {
+WASM_SIMD_TEST(I8x16MaxS) {
   RunI8x16BinOpTest(execution_mode, lower_simd, kExprI8x16MaxS, Maximum);
 }
 
-WASM_SIMD_COMPILED_AND_LOWERED_TEST(I8x16AddSaturateU) {
+WASM_SIMD_TEST(I8x16AddSaturateU) {
   RunI8x16BinOpTest(execution_mode, lower_simd, kExprI8x16AddSaturateU,
                     UnsignedAddSaturate);
 }
 
-WASM_SIMD_COMPILED_AND_LOWERED_TEST(I8x16SubSaturateU) {
+WASM_SIMD_TEST(I8x16SubSaturateU) {
   RunI8x16BinOpTest(execution_mode, lower_simd, kExprI8x16SubSaturateU,
                     UnsignedSubSaturate);
 }
 
-WASM_SIMD_COMPILED_AND_LOWERED_TEST(I8x16MinU) {
+WASM_SIMD_TEST(I8x16MinU) {
   RunI8x16BinOpTest(execution_mode, lower_simd, kExprI8x16MinU,
                     UnsignedMinimum);
 }
 
-WASM_SIMD_COMPILED_AND_LOWERED_TEST(I8x16MaxU) {
+WASM_SIMD_TEST(I8x16MaxU) {
   RunI8x16BinOpTest(execution_mode, lower_simd, kExprI8x16MaxU,
                     UnsignedMaximum);
 }
@@ -2060,7 +2055,7 @@ WASM_SIMD_COMPILED_AND_LOWERED_TEST(SimdF32x4ExtractWithI32x4) {
   CHECK_EQ(1, r.Call());
 }
 
-WASM_SIMD_COMPILED_AND_LOWERED_TEST(SimdF32x4AddWithI32x4) {
+WASM_SIMD_TEST(SimdF32x4AddWithI32x4) {
   // Choose two floating point values whose sum is normal and exactly
   // representable as a float.
   const int kOne = 0x3F800000;
@@ -2079,7 +2074,7 @@ WASM_SIMD_COMPILED_AND_LOWERED_TEST(SimdF32x4AddWithI32x4) {
   CHECK_EQ(1, r.Call());
 }
 
-WASM_SIMD_COMPILED_AND_LOWERED_TEST(SimdI32x4AddWithF32x4) {
+WASM_SIMD_TEST(SimdI32x4AddWithF32x4) {
   WasmRunner<int32_t> r(execution_mode, lower_simd);
   BUILD(r,
         WASM_IF_ELSE_I(