[turbofan] Add new Float32Abs and Float64Abs operators.

src/compiler/common-operator-reducer.cc

 // Copyright 2014 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/common-operator-reducer.h"
 
 #include <algorithm>
 
 #include "src/compiler/common-operator.h"
 #include "src/compiler/js-graph.h"
@@ skipping 37 matching lines @@
   DCHECK_EQ(IrOpcode::kPhi, node->opcode());
   int const input_count = node->InputCount();
   if (input_count == 3) {
     Node* vtrue = NodeProperties::GetValueInput(node, 0);
     Node* vfalse = NodeProperties::GetValueInput(node, 1);
     Node* merge = NodeProperties::GetControlInput(node);
     DiamondMatcher matcher(merge);
     if (matcher.Matched()) {
       if (matcher.IfTrue() == merge->InputAt(1)) std::swap(vtrue, vfalse);
       Node* cond = matcher.Branch()->InputAt(0);
-      if (cond->opcode() == IrOpcode::kFloat64LessThan) {
-        if (cond->InputAt(0) == vtrue && cond->InputAt(1) == vfalse &&
+      if (cond->opcode() == IrOpcode::kFloat32LessThan) {
+        Float32BinopMatcher mcond(cond);
+        if (mcond.left().Is(0.0) && mcond.right().Equals(vtrue) &&
+            vfalse->opcode() == IrOpcode::kFloat32Sub &&
+            machine()->HasFloat32Abs()) {
+          Float32BinopMatcher mvfalse(vfalse);
+          if (mvfalse.left().IsZero() && mvfalse.right().Equals(vtrue)) {
+            return Change(node, machine()->Float32Abs(), vtrue);
+          }
+        }
+        if (mcond.left().Equals(vtrue) && mcond.right().Equals(vfalse) &&
+            machine()->HasFloat32Min()) {
+          return Change(node, machine()->Float32Min(), vtrue, vfalse);
+        } else if (mcond.left().Equals(vfalse) && mcond.right().Equals(vtrue) &&
+                   machine()->HasFloat32Max()) {
+          return Change(node, machine()->Float32Max(), vtrue, vfalse);
+        }
+      } else if (cond->opcode() == IrOpcode::kFloat64LessThan) {
+        Float64BinopMatcher mcond(cond);
+        if (mcond.left().Is(0.0) && mcond.right().Equals(vtrue) &&
+            vfalse->opcode() == IrOpcode::kFloat64Sub &&
+            machine()->HasFloat64Abs()) {
+          Float64BinopMatcher mvfalse(vfalse);
+          if (mvfalse.left().IsZero() && mvfalse.right().Equals(vtrue)) {
+            return Change(node, machine()->Float64Abs(), vtrue);
+          }
+        }
+        if (mcond.left().Equals(vtrue) && mcond.right().Equals(vfalse) &&
             machine()->HasFloat64Min()) {
-          node->set_op(machine()->Float64Min());
-          node->ReplaceInput(0, vtrue);
-          node->ReplaceInput(1, vfalse);
-          node->TrimInputCount(2);
-          return Changed(node);
-        } else if (cond->InputAt(0) == vfalse && cond->InputAt(1) == vtrue &&
+          return Change(node, machine()->Float64Min(), vtrue, vfalse);
+        } else if (mcond.left().Equals(vfalse) && mcond.right().Equals(vtrue) &&
                    machine()->HasFloat64Max()) {
-          node->set_op(machine()->Float64Max());
-          node->ReplaceInput(0, vtrue);
-          node->ReplaceInput(1, vfalse);
-          node->TrimInputCount(2);
-          return Changed(node);
+          return Change(node, machine()->Float64Max(), vtrue, vfalse);
         }
       }
     }
   }
   if (input_count > 1) {
     Node* const replacement = node->InputAt(0);
     for (int i = 1; i < input_count - 1; ++i) {
       if (node->InputAt(i) != replacement) return NoChange();
     }
     return Replace(replacement);
   }
   return NoChange();
 }
 
 
 Reduction CommonOperatorReducer::ReduceSelect(Node* node) {
   DCHECK_EQ(IrOpcode::kSelect, node->opcode());
   Node* cond = NodeProperties::GetValueInput(node, 0);
   Node* vtrue = NodeProperties::GetValueInput(node, 1);
   Node* vfalse = NodeProperties::GetValueInput(node, 2);
   if (vtrue == vfalse) return Replace(vtrue);
-  if (cond->opcode() == IrOpcode::kFloat64LessThan) {
-    if (cond->InputAt(0) == vtrue && cond->InputAt(1) == vfalse &&
+  if (cond->opcode() == IrOpcode::kFloat32LessThan) {
+    Float32BinopMatcher mcond(cond);
+    if (mcond.left().Is(0.0) && mcond.right().Equals(vtrue) &&
+        vfalse->opcode() == IrOpcode::kFloat32Sub &&
+        machine()->HasFloat32Abs()) {
+      Float32BinopMatcher mvfalse(vfalse);
+      if (mvfalse.left().IsZero() && mvfalse.right().Equals(vtrue)) {
+        return Change(node, machine()->Float32Abs(), vtrue);
+      }
+    }
+    if (mcond.left().Equals(vtrue) && mcond.right().Equals(vfalse) &&
+        machine()->HasFloat32Min()) {
+      return Change(node, machine()->Float32Min(), vtrue, vfalse);
+    } else if (mcond.left().Equals(vfalse) && mcond.right().Equals(vtrue) &&
+               machine()->HasFloat32Max()) {
+      return Change(node, machine()->Float32Max(), vtrue, vfalse);
+    }
+  } else if (cond->opcode() == IrOpcode::kFloat64LessThan) {
+    Float64BinopMatcher mcond(cond);
+    if (mcond.left().Is(0.0) && mcond.right().Equals(vtrue) &&
+        vfalse->opcode() == IrOpcode::kFloat64Sub &&
+        machine()->HasFloat64Abs()) {
+      Float64BinopMatcher mvfalse(vfalse);
+      if (mvfalse.left().IsZero() && mvfalse.right().Equals(vtrue)) {
+        return Change(node, machine()->Float64Abs(), vtrue);
+      }
+    }
+    if (mcond.left().Equals(vtrue) && mcond.right().Equals(vfalse) &&
         machine()->HasFloat64Min()) {
-      node->set_op(machine()->Float64Min());
-      node->ReplaceInput(0, vtrue);
-      node->ReplaceInput(1, vfalse);
-      node->TrimInputCount(2);
-      return Changed(node);
-    } else if (cond->InputAt(0) == vfalse && cond->InputAt(1) == vtrue &&
+      return Change(node, machine()->Float64Min(), vtrue, vfalse);
+    } else if (mcond.left().Equals(vfalse) && mcond.right().Equals(vtrue) &&
                machine()->HasFloat64Max()) {
-      node->set_op(machine()->Float64Max());
-      node->ReplaceInput(0, vtrue);
-      node->ReplaceInput(1, vfalse);
-      node->TrimInputCount(2);
-      return Changed(node);
+      return Change(node, machine()->Float64Max(), vtrue, vfalse);
     }
   }
   return NoChange();
 }
 
 
+Reduction CommonOperatorReducer::Change(Node* node, Operator const* op,
+                                        Node* a) {
+  node->set_op(op);
+  node->ReplaceInput(0, a);
+  node->TrimInputCount(1);
+  return Changed(node);
+}
+
+
+Reduction CommonOperatorReducer::Change(Node* node, Operator const* op, Node* a,
+                                        Node* b) {
+  node->set_op(op);
+  node->ReplaceInput(0, a);
+  node->ReplaceInput(1, b);
+  node->TrimInputCount(2);
+  return Changed(node);
+}
+
+
 CommonOperatorBuilder* CommonOperatorReducer::common() const {
   return jsgraph()->common();
 }
 
 
 Graph* CommonOperatorReducer::graph() const { return jsgraph()->graph(); }
 
 
 MachineOperatorBuilder* CommonOperatorReducer::machine() const {
   return jsgraph()->machine();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8