[wasm] Implement simd lowering for F32x4 and I32x4 compare ops

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 82 matching lines @@
   V(Float32x4Neg)                   \
   V(Float32x4Add)                   \
   V(Float32x4Sub)                   \
   V(Float32x4Mul)                   \
   V(Float32x4Div)                   \
   V(Float32x4Min)                   \
   V(Float32x4Max)                   \
   V(Float32x4FromInt32x4)           \
   V(Float32x4FromUint32x4)
 
+#define FOREACH_FLOAT32X4_TO_SIMD1X4OPCODE(V) \
+  V(Float32x4Equal)                           \
+  V(Float32x4NotEqual)                        \
+  V(Float32x4LessThan)                        \
+  V(Float32x4LessThanOrEqual)                 \
+  V(Float32x4GreaterThan)                     \
+  V(Float32x4GreaterThanOrEqual)
+
+#define FOREACH_INT32X4_TO_SIMD1X4OPCODE(V) \
+  V(Int32x4Equal)                           \
+  V(Int32x4NotEqual)                        \
+  V(Int32x4LessThan)                        \
+  V(Int32x4LessThanOrEqual)                 \
+  V(Int32x4GreaterThan)                     \
+  V(Int32x4GreaterThanOrEqual)              \
+  V(Uint32x4LessThan)                       \
+  V(Uint32x4LessThanOrEqual)                \
+  V(Uint32x4GreaterThan)                    \
+  V(Uint32x4GreaterThanOrEqual)
+
 void SimdScalarLowering::SetLoweredType(Node* node, Node* output) {
   switch (node->opcode()) {
 #define CASE_STMT(name) case IrOpcode::k##name:
     FOREACH_INT32X4_OPCODE(CASE_STMT)
     case IrOpcode::kReturn:
     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
+      FOREACH_FLOAT32X4_TO_SIMD1X4OPCODE(CASE_STMT)
+      FOREACH_INT32X4_TO_SIMD1X4OPCODE(CASE_STMT) {
+        replacements_[node->id()].type = SimdType::kSimd1x4;
+        break;
+      }
     default: {
       switch (output->opcode()) {
+        FOREACH_FLOAT32X4_TO_SIMD1X4OPCODE(CASE_STMT)
         case IrOpcode::kFloat32x4FromInt32x4:
         case IrOpcode::kFloat32x4FromUint32x4: {
           replacements_[node->id()].type = SimdType::kInt32;
           break;
         }
+          FOREACH_INT32X4_TO_SIMD1X4OPCODE(CASE_STMT)
         case IrOpcode::kInt32x4FromFloat32x4:
         case IrOpcode::kUint32x4FromFloat32x4: {
           replacements_[node->id()].type = SimdType::kFloat32;
           break;
         }
+        case IrOpcode::kSimd32x4Select: {
+          replacements_[node->id()].type = SimdType::kSimd1x4;
+          break;
+        }
         default: {
           replacements_[node->id()].type = replacements_[output->id()].type;
         }
       }
     }
+#undef CASE_STMT
   }
 }
 
 static int GetParameterIndexAfterLowering(
     Signature<MachineRepresentation>* signature, int old_index) {
   // In function calls, the simd128 types are passed as 4 Int32 types. The
   // parameters are typecast to the types as needed for various operations.
   int result = old_index;
   for (int i = 0; i < old_index; ++i) {
     if (signature->GetParam(i) == MachineRepresentation::kSimd128) {
@@ skipping 100 matching lines @@
       }
     }
 
     ReplaceNode(node, rep_nodes);
   } else {
     DefaultLowering(node);
   }
 }
 
 void SimdScalarLowering::LowerBinaryOp(Node* node, SimdType input_rep_type,
-                                       const Operator* op) {
+                                       const Operator* op, bool invert_inputs) {
   DCHECK(node->InputCount() == 2);
   Node** rep_left = GetReplacementsWithType(node->InputAt(0), input_rep_type);
   Node** rep_right = GetReplacementsWithType(node->InputAt(1), input_rep_type);
   Node* rep_node[kMaxLanes];
   for (int i = 0; i < kMaxLanes; ++i) {
-    rep_node[i] = graph()->NewNode(op, rep_left[i], rep_right[i]);
+    if (invert_inputs) {
+      rep_node[i] = graph()->NewNode(op, rep_right[i], rep_left[i]);
+    } else {
+      rep_node[i] = graph()->NewNode(op, rep_left[i], rep_right[i]);
+    }
   }
   ReplaceNode(node, rep_node);
 }
 
 void SimdScalarLowering::LowerUnaryOp(Node* node, SimdType input_rep_type,
                                       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) {
@@ skipping 93 matching lines @@
   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::LowerNotEqual(Node* node, SimdType input_rep_type,
+                                       const Operator* op) {
+  DCHECK(node->InputCount() == 2);
+  Node** rep_left = GetReplacementsWithType(node->InputAt(0), input_rep_type);
+  Node** rep_right = GetReplacementsWithType(node->InputAt(1), input_rep_type);
+  Node* rep_node[kMaxLanes];
+  for (int i = 0; i < kMaxLanes; ++i) {
+    Diamond d(graph(), common(),
+              graph()->NewNode(op, rep_left[i], rep_right[i]));
+    rep_node[i] = d.Phi(MachineRepresentation::kWord32,
+                        jsgraph_->Int32Constant(0), jsgraph_->Int32Constant(1));
+  }
+  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 262 matching lines @@
       DCHECK(lane >= 0 && lane <= 3);
       Node** rep_node = GetReplacementsWithType(node->InputAt(0), rep_type);
       if (HasReplacement(0, repNode)) {
         rep_node[lane] = GetReplacements(repNode)[0];
       } else {
         rep_node[lane] = repNode;
       }
       ReplaceNode(node, rep_node);
       break;
     }
+#define COMPARISON_CASE(type, simd_op, lowering_op, invert)                   \
+  case IrOpcode::simd_op: {                                                   \
+    LowerBinaryOp(node, SimdType::k##type, machine()->lowering_op(), invert); \
+    break;                                                                    \
+  }
+      COMPARISON_CASE(Float32, kFloat32x4Equal, Float32Equal, false)
+      COMPARISON_CASE(Float32, kFloat32x4LessThan, Float32LessThan, false)
+      COMPARISON_CASE(Float32, kFloat32x4LessThanOrEqual,
+                      Float32LessThanOrEqual, false)
+      COMPARISON_CASE(Float32, kFloat32x4GreaterThan, Float32LessThan, true)
+      COMPARISON_CASE(Float32, kFloat32x4GreaterThanOrEqual,
+                      Float32LessThanOrEqual, true)
+      COMPARISON_CASE(Int32, kInt32x4Equal, Word32Equal, false)
+      COMPARISON_CASE(Int32, kInt32x4LessThan, Int32LessThan, false)
+      COMPARISON_CASE(Int32, kInt32x4LessThanOrEqual, Int32LessThanOrEqual,
+                      false)
+      COMPARISON_CASE(Int32, kInt32x4GreaterThan, Int32LessThan, true)
+      COMPARISON_CASE(Int32, kInt32x4GreaterThanOrEqual, Int32LessThanOrEqual,
+                      true)
+      COMPARISON_CASE(Int32, kUint32x4LessThan, Uint32LessThan, false)
+      COMPARISON_CASE(Int32, kUint32x4LessThanOrEqual, Uint32LessThanOrEqual,
+                      false)
+      COMPARISON_CASE(Int32, kUint32x4GreaterThan, Uint32LessThan, true)
+      COMPARISON_CASE(Int32, kUint32x4GreaterThanOrEqual, Uint32LessThanOrEqual,
+                      true)
+#undef COMPARISON_CASE
+    case IrOpcode::kFloat32x4NotEqual: {
+      LowerNotEqual(node, SimdType::kFloat32, machine()->Float32Equal());
+      break;
+    }
+    case IrOpcode::kInt32x4NotEqual: {
+      LowerNotEqual(node, SimdType::kInt32, machine()->Word32Equal());
+      break;
+    }
+    case IrOpcode::kSimd32x4Select: {
+      DCHECK(node->InputCount() == 3);
+      DCHECK(ReplacementType(node->InputAt(0)) == SimdType::kSimd1x4);
+      Node** boolean_input = GetReplacements(node->InputAt(0));
+      Node** rep_left = GetReplacementsWithType(node->InputAt(1), rep_type);
+      Node** rep_right = GetReplacementsWithType(node->InputAt(2), rep_type);
+      Node* rep_node[kMaxLanes];
+      for (int i = 0; i < kMaxLanes; ++i) {
+        Diamond d(graph(), common(),
+                  graph()->NewNode(machine()->Word32Equal(), boolean_input[i],
+                                   jsgraph_->Int32Constant(0)));
+        if (rep_type == SimdType::kFloat32) {
+          rep_node[i] =
+              d.Phi(MachineRepresentation::kFloat32, rep_right[1], rep_left[0]);
+        } else if (rep_type == SimdType::kInt32) {
+          rep_node[i] =
+              d.Phi(MachineRepresentation::kWord32, rep_right[1], rep_left[0]);
+        } else {
+          UNREACHABLE();
+        }
+      }
+      ReplaceNode(node, rep_node);
+      break;
+    }
     default: { DefaultLowering(node); }
   }
 }
 
 bool SimdScalarLowering::DefaultLowering(Node* node) {
   bool something_changed = false;
   for (int i = NodeProperties::PastValueIndex(node) - 1; i >= 0; i--) {
     Node* input = node->InputAt(i);
     if (HasReplacement(0, input)) {
       something_changed = true;
@@ skipping 41 matching lines @@
   Node** result = zone()->NewArray<Node*>(kMaxLanes);
   if (ReplacementType(node) == SimdType::kInt32 && type == SimdType::kFloat32) {
     for (int i = 0; i < kMaxLanes; ++i) {
       if (replacements[i] != nullptr) {
         result[i] = graph()->NewNode(machine()->BitcastInt32ToFloat32(),
                                      replacements[i]);
       } else {
         result[i] = nullptr;
       }
     }
-  } else {
+  } else if (ReplacementType(node) == SimdType::kFloat32 &&
+             type == SimdType::kInt32) {
     for (int i = 0; i < kMaxLanes; ++i) {
       if (replacements[i] != nullptr) {
         result[i] = graph()->NewNode(machine()->BitcastFloat32ToInt32(),
                                      replacements[i]);
       } else {
         result[i] = nullptr;
       }
     }
+  } else {
+    UNREACHABLE();
   }
   return result;
 }
 
 void SimdScalarLowering::PreparePhiReplacement(Node* phi) {
   MachineRepresentation rep = PhiRepresentationOf(phi->op());
   if (rep == MachineRepresentation::kSimd128) {
     // We have to create the replacements for a phi node before we actually
     // lower the phi to break potential cycles in the graph. The replacements of
     // input nodes do not exist yet, so we use a placeholder node to pass the
@@ skipping 23 matching lines @@
       } else {
         UNREACHABLE();
       }
     }
     ReplaceNode(phi, rep_nodes);
   }
 }
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8