[turbofan] Improve interplay of ControlReducer and CommonOperatorReducer.

src/compiler/control-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.h"
+#include "src/compiler/common-operator-reducer.h"
 #include "src/compiler/control-reducer.h"
 #include "src/compiler/graph.h"
 #include "src/compiler/graph-reducer.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/node-marker.h"
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/node-properties.h"
 #include "src/zone-containers.h"
 
 namespace v8 {
@@ skipping 46 matching lines @@
       case IrOpcode::kIfTrue:
         result = ReduceIfProjection(node, kTrue);
         break;
       case IrOpcode::kIfFalse:
         result = ReduceIfProjection(node, kFalse);
         break;
       case IrOpcode::kLoop:  // fallthrough
       case IrOpcode::kMerge:
         result = ReduceMerge(node);
         break;
-      case IrOpcode::kSelect:
-        result = ReduceSelect(node);
-        break;
-      case IrOpcode::kPhi:
-      case IrOpcode::kEffectPhi:
-        result = ReducePhi(node);
-        break;
       case IrOpcode::kEnd:
         result = ReduceEnd(node);
         break;
       default:
         break;
     }
 
     return result == node ? NoChange() : Replace(result);
   }
 
   // Try to statically fold a condition.
   Decision DecideCondition(Node* cond) {
     switch (cond->opcode()) {
       case IrOpcode::kInt32Constant:
         return Int32Matcher(cond).Is(0) ? kFalse : kTrue;
       case IrOpcode::kInt64Constant:
         return Int64Matcher(cond).Is(0) ? kFalse : kTrue;
       case IrOpcode::kHeapConstant: {
         Handle<Object> object =
             HeapObjectMatcher<Object>(cond).Value().handle();
         return object->BooleanValue() ? kTrue : kFalse;
       }
       default:
         break;
     }
     return kUnknown;
   }
 
-  // Reduce redundant selects.
-  Node* ReduceSelect(Node* const node) {
-    Node* const tvalue = node->InputAt(1);
-    Node* const fvalue = node->InputAt(2);
-    if (tvalue == fvalue) return tvalue;
-    Decision result = DecideCondition(node->InputAt(0));
-    if (result == kTrue) return tvalue;
-    if (result == kFalse) return fvalue;
-    return node;
-  }
-
-  // Reduce redundant phis.
-  Node* ReducePhi(Node* node) {
-    int n = node->InputCount();
-    if (n <= 1) return dead();            // No non-control inputs.
-    if (n == 2) return node->InputAt(0);  // Only one non-control input.
-
-    Node* replacement = NULL;
-    auto const inputs = node->inputs();
-    for (auto it = inputs.begin(); n > 1; --n, ++it) {
-      Node* input = *it;
-      // Ignore dead inputs.
-      if (input->opcode() == IrOpcode::kDeadControl) continue;
-      // Non-redundant input.
-      if (input != node && input != replacement) {
-        if (replacement != NULL) return node;
-        replacement = input;
-      }
-    }
-    return replacement == NULL ? dead() : replacement;
-  }
-
   // Reduce branches.
   Node* ReduceBranch(Node* branch) {
     if (DecideCondition(branch->InputAt(0)) != kUnknown) {
       for (Node* use : branch->uses()) Revisit(use);
     }
     return branch;
   }
 
   // Reduce end by trimming away dead inputs.
   Node* ReduceEnd(Node* node) {
@@ skipping 156 matching lines @@
     DCHECK_NE(total, node->InputCount());
     node->TrimInputCount(total);
     node->set_op(common()->ResizeMergeOrPhi(node->op(), live));
   }
 };
 
 
 void ControlReducer::ReduceGraph(Zone* zone, JSGraph* jsgraph,
                                  int max_phis_for_select) {
   GraphReducer graph_reducer(zone, jsgraph->graph());
+  CommonOperatorReducer common(&graph_reducer, jsgraph->graph(),
+                               jsgraph->common(), jsgraph->machine());
   ControlReducerImpl impl(&graph_reducer, zone, jsgraph);
   impl.max_phis_for_select_ = max_phis_for_select;
   graph_reducer.AddReducer(&impl);
+  graph_reducer.AddReducer(&common);
   graph_reducer.ReduceGraph();
 }
 
 
 namespace {
 
 class DummyEditor final : public AdvancedReducer::Editor {
  public:
   void Replace(Node* node, Node* replacement) final {
     node->ReplaceUses(replacement);
   }
   void Revisit(Node* node) final {}
   void ReplaceWithValue(Node* node, Node* value, Node* effect,
                         Node* control) final {}
 };
 
 }  // namespace
 
 
 Node* ControlReducer::ReduceMerge(JSGraph* jsgraph, Node* node,
                                   int max_phis_for_select) {
   Zone zone;
   DummyEditor editor;
   ControlReducerImpl impl(&editor, &zone, jsgraph);
   impl.max_phis_for_select_ = max_phis_for_select;
   return impl.ReduceMerge(node);
 }
 
 
-Node* ControlReducer::ReducePhiForTesting(JSGraph* jsgraph, Node* node) {
-  Zone zone;
-  DummyEditor editor;
-  ControlReducerImpl impl(&editor, &zone, jsgraph);
-  return impl.ReducePhi(node);
-}
-
-
 Node* ControlReducer::ReduceIfNodeForTesting(JSGraph* jsgraph, Node* node) {
   Zone zone;
   DummyEditor editor;
   ControlReducerImpl impl(&editor, &zone, jsgraph);
   switch (node->opcode()) {
     case IrOpcode::kIfTrue:
       return impl.ReduceIfProjection(node, kTrue);
     case IrOpcode::kIfFalse:
       return impl.ReduceIfProjection(node, kFalse);
     default:
       return node;
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8