[wasm]implement simd lowering for f32x4->i32x4, i32x4 min/max and shift instructions

src/compiler/simd-scalar-lowering.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/compiler/simd-scalar-lowering.h"
 #include "src/compiler/diamond.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/node-properties.h"
 
@@ skipping 62 matching lines @@
 
 #define FOREACH_INT32X4_OPCODE(V) \
   V(Int32x4Splat)                 \
   V(Int32x4ExtractLane)           \
   V(Int32x4ReplaceLane)           \
   V(Int32x4Neg)                   \
   V(Simd128Not)                   \
   V(Int32x4Add)                   \
   V(Int32x4Sub)                   \
   V(Int32x4Mul)                   \
+  V(Int32x4Min)                   \
+  V(Int32x4Max)                   \
+  V(Uint32x4Min)                  \
+  V(Uint32x4Max)                  \
   V(Simd128And)                   \
   V(Simd128Or)                    \
-  V(Simd128Xor)
+  V(Simd128Xor)                   \
+  V(Int32x4FromFloat32x4)         \
+  V(Uint32x4FromFloat32x4)
 
 #define FOREACH_FLOAT32X4_OPCODE(V) \
   V(Float32x4Splat)                 \
   V(Float32x4ExtractLane)           \
   V(Float32x4ReplaceLane)           \
   V(Float32x4Abs)                   \
   V(Float32x4Neg)                   \
   V(Float32x4Add)                   \
   V(Float32x4Sub)                   \
   V(Float32x4Mul)                   \
@@ skipping 11 matching lines @@
     case IrOpcode::kParameter:
     case IrOpcode::kCall: {
       replacements_[node->id()].type = SimdType::kInt32;
       break;
     }
       FOREACH_FLOAT32X4_OPCODE(CASE_STMT) {
         replacements_[node->id()].type = SimdType::kFloat32;
         break;
       }
 #undef CASE_STMT
     default: {

[titzer, 2017/03/01 09:40:28]

Probably time for an innner switch now?

[aseemgarg, 2017/03/01 10:55:16]

Done.

       if (output->opcode() == IrOpcode::kFloat32x4FromInt32x4 ||
           output->opcode() == IrOpcode::kFloat32x4FromUint32x4) {
         replacements_[node->id()].type = SimdType::kInt32;
+      } else if (output->opcode() == IrOpcode::kInt32x4FromFloat32x4 ||
+                 output->opcode() == IrOpcode::kUint32x4FromFloat32x4) {
+        replacements_[node->id()].type = SimdType::kFloat32;
       } else {
         replacements_[node->id()].type = replacements_[output->id()].type;
       }
     }
   }
 }
 
 static int GetParameterIndexAfterLowering(
     Signature<MachineRepresentation>* signature, int old_index) {
   // In function calls, the simd128 types are passed as 4 Int32 types. The
@@ skipping 126 matching lines @@
                                       const Operator* op) {
   DCHECK(node->InputCount() == 1);
   Node** rep = GetReplacementsWithType(node->InputAt(0), input_rep_type);
   Node* rep_node[kMaxLanes];
   for (int i = 0; i < kMaxLanes; ++i) {
     rep_node[i] = graph()->NewNode(op, rep[i]);
   }
   ReplaceNode(node, rep_node);
 }
 
+void SimdScalarLowering::LowerIntMinMax(Node* node, const Operator* op,
+                                        bool is_max) {
+  DCHECK(node->InputCount() == 2);
+  Node** rep_left = GetReplacementsWithType(node->InputAt(0), SimdType::kInt32);
+  Node** rep_right =
+      GetReplacementsWithType(node->InputAt(1), SimdType::kInt32);
+  Node* rep_node[kMaxLanes];
+  for (int i = 0; i < kMaxLanes; ++i) {
+    Diamond d(graph(), common(),
+              graph()->NewNode(op, rep_left[i], rep_right[i]));
+    if (is_max) {
+      rep_node[i] =
+          d.Phi(MachineRepresentation::kWord32, rep_right[i], rep_left[i]);
+    } else {
+      rep_node[i] =
+          d.Phi(MachineRepresentation::kWord32, rep_left[i], rep_right[i]);
+    }
+  }
+  ReplaceNode(node, rep_node);
+}
+
+void SimdScalarLowering::LowerConvertFromFloat(Node* node, bool is_signed) {
+  DCHECK(node->InputCount() == 1);
+  Node** rep = GetReplacementsWithType(node->InputAt(0), SimdType::kFloat32);
+  Node* rep_node[kMaxLanes];
+  Node* double_zero = graph()->NewNode(common()->Float64Constant(0.0));
+  Node* min = graph()->NewNode(
+      common()->Float64Constant(static_cast<double>(is_signed ? kMinInt : 0)));
+  Node* max = graph()->NewNode(common()->Float64Constant(
+      static_cast<double>(is_signed ? kMaxInt : 0xffffffffu)));
+  for (int i = 0; i < kMaxLanes; ++i) {
+    Node* double_rep =
+        graph()->NewNode(machine()->ChangeFloat32ToFloat64(), rep[i]);
+    Diamond nan_d(graph(), common(), graph()->NewNode(machine()->Float64Equal(),
+                                                      double_rep, double_rep));
+    Node* temp =
+        nan_d.Phi(MachineRepresentation::kFloat64, double_rep, double_zero);
+    Diamond min_d(graph(), common(),
+                  graph()->NewNode(machine()->Float64LessThan(), temp, min));
+    temp = min_d.Phi(MachineRepresentation::kFloat64, min, temp);
+    Diamond max_d(graph(), common(),
+                  graph()->NewNode(machine()->Float64LessThan(), max, temp));
+    //    if (!machine()->Float32RoundTruncate().IsSupported()) {

[titzer, 2017/03/01 09:40:28]

Is this code ncessary? if not, then please remove it.

[aseemgarg, 2017/03/01 10:55:16]

Removed. All bots are passing with this commented out. 

+    //      trunc = BuildF32Trunc(input);
+    //    } else {
+    //      trunc =
+    //    }
+    temp = max_d.Phi(MachineRepresentation::kFloat64, max, temp);
+    Node* trunc =
+        graph()->NewNode(machine()->Float64RoundTruncate().op(), temp);
+    if (is_signed) {
+      rep_node[i] = graph()->NewNode(machine()->ChangeFloat64ToInt32(), trunc);
+    } else {
+      rep_node[i] =
+          graph()->NewNode(machine()->TruncateFloat64ToUint32(), trunc);
+    }
+  }
+  ReplaceNode(node, rep_node);
+}
+
+void SimdScalarLowering::LowerShiftOp(Node* node, const Operator* op) {
+  static int32_t shift_mask = 0x1f;
+  DCHECK_EQ(1, node->InputCount());
+  int32_t shift_amount = OpParameter<int32_t>(node);
+  Node* shift_node =
+      graph()->NewNode(common()->Int32Constant(shift_amount & shift_mask));
+  Node** rep = GetReplacementsWithType(node->InputAt(0), SimdType::kInt32);
+  Node* rep_node[kMaxLanes];
+  for (int i = 0; i < kMaxLanes; ++i) {
+    rep_node[i] = graph()->NewNode(op, rep[i], shift_node);
+  }
+  ReplaceNode(node, rep_node);
+}
+
 void SimdScalarLowering::LowerNode(Node* node) {
   SimdType rep_type = ReplacementType(node);
   switch (node->opcode()) {
     case IrOpcode::kStart: {
       int parameter_count = GetParameterCountAfterLowering();
       // Only exchange the node if the parameter count actually changed.
       if (parameter_count != static_cast<int>(signature()->parameter_count())) {
         int delta =
             parameter_count - static_cast<int>(signature()->parameter_count());
         int new_output_count = node->op()->ValueOutputCount() + delta;
@@ skipping 138 matching lines @@
     LowerBinaryOp(node, rep_type, machine()->instruction()); \
     break;                                                   \
   }
       I32X4_BINOP_CASE(kInt32x4Add, Int32Add)
       I32X4_BINOP_CASE(kInt32x4Sub, Int32Sub)
       I32X4_BINOP_CASE(kInt32x4Mul, Int32Mul)
       I32X4_BINOP_CASE(kSimd128And, Word32And)
       I32X4_BINOP_CASE(kSimd128Or, Word32Or)
       I32X4_BINOP_CASE(kSimd128Xor, Word32Xor)
 #undef I32X4_BINOP_CASE
+    case IrOpcode::kInt32x4Max: {
+      LowerIntMinMax(node, machine()->Int32LessThan(), true);
+      break;
+    }
+    case IrOpcode::kInt32x4Min: {
+      LowerIntMinMax(node, machine()->Int32LessThan(), false);
+      break;
+    }
+    case IrOpcode::kUint32x4Max: {
+      LowerIntMinMax(node, machine()->Uint32LessThan(), true);
+      break;
+    }
+    case IrOpcode::kUint32x4Min: {
+      LowerIntMinMax(node, machine()->Uint32LessThan(), false);
+      break;
+    }
     case IrOpcode::kInt32x4Neg: {
       DCHECK(node->InputCount() == 1);
       Node** rep = GetReplacementsWithType(node->InputAt(0), rep_type);
       Node* rep_node[kMaxLanes];
       for (int i = 0; i < kMaxLanes; ++i) {
         rep_node[i] = graph()->NewNode(
             machine()->Int32Sub(), graph()->NewNode(common()->Int32Constant(0)),
             rep[i]);
       }
       ReplaceNode(node, rep_node);
       break;
     }
     case IrOpcode::kSimd128Not: {
       DCHECK(node->InputCount() == 1);
       Node** rep = GetReplacementsWithType(node->InputAt(0), rep_type);
       Node* rep_node[kMaxLanes];
       for (int i = 0; i < kMaxLanes; ++i) {
         rep_node[i] = graph()->NewNode(
             machine()->Word32Xor(), rep[i],
             graph()->NewNode(common()->Int32Constant(0xffffffff)));
       }
       ReplaceNode(node, rep_node);
       break;
     }
+    case IrOpcode::kInt32x4FromFloat32x4: {
+      LowerConvertFromFloat(node, true);
+      break;
+    }
+    case IrOpcode::kUint32x4FromFloat32x4: {
+      LowerConvertFromFloat(node, false);
+      break;
+    }
+    case IrOpcode::kInt32x4ShiftLeftByScalar: {
+      LowerShiftOp(node, machine()->Word32Shl());
+      break;
+    }
+    case IrOpcode::kInt32x4ShiftRightByScalar: {
+      LowerShiftOp(node, machine()->Word32Sar());
+      break;
+    }
+    case IrOpcode::kUint32x4ShiftRightByScalar: {
+      LowerShiftOp(node, machine()->Word32Shr());
+      break;
+    }
 #define F32X4_BINOP_CASE(name)                                 \
   case IrOpcode::kFloat32x4##name: {                           \
     LowerBinaryOp(node, rep_type, machine()->Float32##name()); \
     break;                                                     \
   }
       F32X4_BINOP_CASE(Add)
       F32X4_BINOP_CASE(Sub)
       F32X4_BINOP_CASE(Mul)
       F32X4_BINOP_CASE(Div)
       F32X4_BINOP_CASE(Min)
@@ skipping 159 matching lines @@
       } else {
         UNREACHABLE();
       }
     }
     ReplaceNode(phi, rep_nodes);
   }
 }
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8