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

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 57 matching lines @@
         state_.Set(input, State::kOnStack);
       }
     }
   }
 }
 
 #define FOREACH_INT32X4_OPCODE(V) \
   V(Int32x4Splat)                 \
   V(Int32x4ExtractLane)           \
   V(Int32x4ReplaceLane)           \
+  V(Int32x4Neg)                   \
+  V(Simd128Not)                   \
   V(Int32x4Add)                   \
   V(Int32x4Sub)                   \
   V(Int32x4Mul)                   \
   V(Simd128And)                   \
   V(Simd128Or)                    \
   V(Simd128Xor)
 
 #define FOREACH_FLOAT32X4_OPCODE(V) \
   V(Float32x4Splat)                 \
   V(Float32x4ExtractLane)           \
   V(Float32x4ReplaceLane)           \
+  V(Float32x4Abs)                   \
+  V(Float32x4Neg)                   \
   V(Float32x4Add)                   \
   V(Float32x4Sub)                   \
   V(Float32x4Mul)                   \
   V(Float32x4Div)                   \
   V(Float32x4Min)                   \
-  V(Float32x4Max)
+  V(Float32x4Max)                   \
+  V(Float32x4FromInt32x4)           \
+  V(Float32x4FromUint32x4)
 
 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
-    default:
-      replacements_[node->id()].type = replacements_[output->id()].type;
+    default: {
+      if (output->opcode() == IrOpcode::kFloat32x4FromInt32x4 ||
+          output->opcode() == IrOpcode::kFloat32x4FromUint32x4) {
+        replacements_[node->id()].type = SimdType::kInt32;
+      } 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
   // 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 99 matching lines @@
             graph()->NewNode(store_op, base, indices[i], rep_inputs[i]);
       }
     }
 
     ReplaceNode(node, rep_nodes);
   } else {
     DefaultLowering(node);
   }
 }
 
-void SimdScalarLowering::LowerBinaryOp(Node* node, SimdType rep_type,
+void SimdScalarLowering::LowerBinaryOp(Node* node, SimdType input_rep_type,
                                        const Operator* op) {
   DCHECK(node->InputCount() == 2);
-  Node** rep_left = GetReplacementsWithType(node->InputAt(0), rep_type);
-  Node** rep_right = GetReplacementsWithType(node->InputAt(1), rep_type);
+  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]);
   }
   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) {
+    rep_node[i] = graph()->NewNode(op, rep[i]);
+  }
+  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::kInt32x4Neg: {
+      DCHECK(node->InputCount() == 1);
+      Node** rep = GetReplacementsWithType(node->InputAt(0), rep_type);
+      Node* rep_node[kMaxLanes];
+      Node* zero = graph()->NewNode(common()->Int32Constant(0));
+      for (int i = 0; i < kMaxLanes; ++i) {
+        rep_node[i] = graph()->NewNode(machine()->Int32Sub(), zero, 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];
+      Node* mask = graph()->NewNode(common()->Int32Constant(0xffffffff));
+      for (int i = 0; i < kMaxLanes; ++i) {
+        rep_node[i] = graph()->NewNode(machine()->Word32Xor(), rep[i], mask);
+      }
+      ReplaceNode(node, rep_node);
+      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)
       F32X4_BINOP_CASE(Max)
 #undef F32X4_BINOP_CASE
+#define F32X4_UNOP_CASE(name)                                 \
+  case IrOpcode::kFloat32x4##name: {                          \
+    LowerUnaryOp(node, rep_type, machine()->Float32##name()); \
+    break;                                                    \
+  }
+      F32X4_UNOP_CASE(Abs)
+      F32X4_UNOP_CASE(Neg)
+      F32X4_UNOP_CASE(Sqrt)
+#undef F32x4_UNOP_CASE
+    case IrOpcode::kFloat32x4FromInt32x4: {
+      LowerUnaryOp(node, SimdType::kInt32, machine()->RoundInt32ToFloat32());
+      break;
+    }
+    case IrOpcode::kFloat32x4FromUint32x4: {
+      LowerUnaryOp(node, SimdType::kInt32, machine()->RoundUint32ToFloat32());
+      break;
+    }
     case IrOpcode::kInt32x4Splat:
     case IrOpcode::kFloat32x4Splat: {
       Node* rep_node[kMaxLanes];
       for (int i = 0; i < kMaxLanes; ++i) {
         if (HasReplacement(0, node->InputAt(0))) {
           rep_node[i] = GetReplacements(node->InputAt(0))[0];
         } else {
           rep_node[i] = node->InputAt(0);
         }
       }
@@ skipping 130 matching lines @@
       } else {
         UNREACHABLE();
       }
     }
     ReplaceNode(phi, rep_nodes);
   }
 }
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8