[turbofan] Reduce duplication between ControlReducer::ReduceIf(True,False).

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/control-reducer.h"
 #include "src/compiler/graph.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/node-marker.h"
 #include "src/compiler/node-matchers.h"
@@ skipping 398 matching lines @@
         TRACE("ControlDead: #%d:%s\n", node->id(), node->op()->mnemonic());
         return control;
       }
     }
 
     // Reduce branches, phis, and merges.
     switch (node->opcode()) {
       case IrOpcode::kBranch:
         return ReduceBranch(node);
       case IrOpcode::kIfTrue:
-        return ReduceIfTrue(node);
+        return ReduceIfProjection(node, kTrue);
       case IrOpcode::kIfFalse:
-        return ReduceIfFalse(node);
+        return ReduceIfProjection(node, kFalse);
       case IrOpcode::kLoop:
       case IrOpcode::kMerge:
         return ReduceMerge(node);
       case IrOpcode::kSelect:
         return ReduceSelect(node);
       case IrOpcode::kPhi:
       case IrOpcode::kEffectPhi:
         return ReducePhi(node);
       default:
         return node;
@@ skipping 137 matching lines @@
                 node0->op()->mnemonic(), node1->id(), node1->op()->mnemonic(),
                 branch0->id(), branch0->op()->mnemonic());
           return NodeProperties::GetControlInput(branch0);
         }
       }
     }
 
     return node;
   }
 
-  // Reduce branches if they have constant inputs.
-  Node* ReduceIfTrue(Node* node) {
+  // Reduce if projections if the branch has a constant input.
+  Node* ReduceIfProjection(Node* node, Decision decision) {
     Node* branch = node->InputAt(0);
     DCHECK_EQ(IrOpcode::kBranch, branch->opcode());
     Decision result = DecideCondition(branch->InputAt(0));
-    if (result == kTrue) {
-      // fold a true branch by replacing IfTrue with the branch control.
+    if (result == decision) {
+      // Fold a branch by replacing IfTrue/IfFalse with the branch control.
       TRACE("  BranchReduce: #%d:%s => #%d:%s\n", branch->id(),
             branch->op()->mnemonic(), node->id(), node->op()->mnemonic());
       return branch->InputAt(1);
-    }
-    return result == kUnknown ? node : dead();
-  }
-
-  // Reduce branches if they have constant inputs.
-  Node* ReduceIfFalse(Node* node) {
-    Node* branch = node->InputAt(0);
-    DCHECK_EQ(IrOpcode::kBranch, branch->opcode());
-    Decision result = DecideCondition(branch->InputAt(0));
-    if (result == kFalse) {
-      // fold a false branch by replacing IfFalse with the branch control.
-      TRACE("  BranchReduce: #%d:%s => #%d:%s\n", branch->id(),
-            branch->op()->mnemonic(), node->id(), node->op()->mnemonic());
-      return branch->InputAt(1);
     }
     return result == kUnknown ? node : dead();
   }
 
   // Remove inputs to {node} corresponding to the dead inputs to {merge}
   // and compact the remaining inputs, updating the operator.
   void RemoveDeadInputs(Node* merge, Node* node) {
     int live = 0;
     for (int i = 0; i < merge->InputCount(); i++) {
       // skip dead inputs.
@@ skipping 61 matching lines @@
 }
 
 
 Node* ControlReducer::ReduceIfNodeForTesting(JSGraph* jsgraph,
                                              CommonOperatorBuilder* common,
                                              Node* node) {
   Zone zone;
   ControlReducerImpl impl(&zone, jsgraph, common);
   switch (node->opcode()) {
     case IrOpcode::kIfTrue:
-      return impl.ReduceIfTrue(node);
+      return impl.ReduceIfProjection(node, kTrue);
     case IrOpcode::kIfFalse:
-      return impl.ReduceIfFalse(node);
+      return impl.ReduceIfProjection(node, kFalse);
     default:
       return node;
   }
 }
 }
 }
 }  // namespace v8::internal::compiler