[turbofan] Introduce BranchMatcher and DiamondMatcher helpers.

src/compiler/control-flow-optimizer.cc

 // Copyright 2015 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/control-flow-optimizer.h"
 
 #include "src/compiler/js-graph.h"
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/node-properties.h"
 
@@ skipping 105 matching lines @@
 
   Node* branch = node;
   Node* cond = NodeProperties::GetValueInput(branch, 0);
   if (!cond->OwnedBy(branch) || cond->opcode() != IrOpcode::kPhi) return false;
   Node* merge = NodeProperties::GetControlInput(branch);
   if (merge->opcode() != IrOpcode::kMerge ||
       NodeProperties::GetControlInput(cond) != merge) {
     return false;
   }
   // Grab the IfTrue/IfFalse projections of the Branch.
-  Node* control_projections[2];
-  NodeProperties::CollectControlProjections(branch, control_projections,
-                                            arraysize(control_projections));
-  Node* if_true = control_projections[0];
-  Node* if_false = control_projections[1];
-  DCHECK_EQ(IrOpcode::kIfTrue, if_true->opcode());
-  DCHECK_EQ(IrOpcode::kIfFalse, if_false->opcode());
+  BranchMatcher matcher(branch);
   // Check/collect other Phi/EffectPhi nodes hanging off the Merge.
   NodeVector phis(zone());
   for (Node* const use : merge->uses()) {
     if (use == branch || use == cond) continue;
     // We cannot currently deal with non-Phi/EffectPhi nodes hanging off the
     // Merge. Ideally, we would just clone the nodes (and everything that
     // depends on it to some distant join point), but that requires knowledge
     // about dominance/post-dominance.
     if (!NodeProperties::IsPhi(use)) return false;
     for (Edge edge : use->use_edges()) {
       // Right now we can only handle Phi/EffectPhi nodes whose uses are
       // directly control-dependend on either the IfTrue or the IfFalse
       // successor, because we know exactly how to update those uses.
       // TODO(turbofan): Generalize this to all Phi/EffectPhi nodes using
       // dominance/post-dominance on the sea of nodes.
       if (edge.from()->op()->ControlInputCount() != 1) return false;
       Node* control = NodeProperties::GetControlInput(edge.from());
       if (NodeProperties::IsPhi(edge.from())) {
         control = NodeProperties::GetControlInput(control, edge.index());
       }
-      if (control != if_true && control != if_false) return false;
+      if (control != matcher.IfTrue() && control != matcher.IfFalse())
+        return false;
     }
     phis.push_back(use);
   }
   BranchHint const hint = BranchHintOf(branch->op());
   int const input_count = merge->op()->ControlInputCount();
   DCHECK_LE(1, input_count);
   Node** const inputs = zone()->NewArray<Node*>(2 * input_count);
   Node** const merge_true_inputs = &inputs[0];
   Node** const merge_false_inputs = &inputs[input_count];
   for (int index = 0; index < input_count; ++index) {
@@ skipping 14 matching lines @@
     }
     inputs[input_count] = merge_true;
     Node* phi_true = graph()->NewNode(phi->op(), input_count + 1, inputs);
     inputs[input_count] = merge_false;
     Node* phi_false = graph()->NewNode(phi->op(), input_count + 1, inputs);
     for (Edge edge : phi->use_edges()) {
       Node* control = NodeProperties::GetControlInput(edge.from());
       if (NodeProperties::IsPhi(edge.from())) {
         control = NodeProperties::GetControlInput(control, edge.index());
       }
-      DCHECK(control == if_true || control == if_false);
-      edge.UpdateTo((control == if_true) ? phi_true : phi_false);
+      DCHECK(control == matcher.IfTrue() || control == matcher.IfFalse());
+      edge.UpdateTo((control == matcher.IfTrue()) ? phi_true : phi_false);
     }
     phi->Kill();
   }
   // Fix up IfTrue and IfFalse and kill all dead nodes.
-  if_false->ReplaceUses(merge_false);
-  if_true->ReplaceUses(merge_true);
-  if_false->Kill();
-  if_true->Kill();
+  matcher.IfFalse()->ReplaceUses(merge_false);
+  matcher.IfTrue()->ReplaceUses(merge_true);
+  matcher.IfFalse()->Kill();
+  matcher.IfTrue()->Kill();
   branch->Kill();
   cond->Kill();
   merge->Kill();
   return true;
 }
 
 
 bool ControlFlowOptimizer::TryBuildSwitch(Node* node) {
   DCHECK_EQ(IrOpcode::kBranch, node->opcode());
 
   Node* branch = node;
   if (BranchHintOf(branch->op()) != BranchHint::kNone) return false;
   Node* cond = NodeProperties::GetValueInput(branch, 0);
   if (cond->opcode() != IrOpcode::kWord32Equal) return false;
   Int32BinopMatcher m(cond);
   Node* index = m.left().node();
   if (!m.right().HasValue()) return false;
   int32_t value = m.right().Value();
   ZoneSet<int32_t> values(zone());
   values.insert(value);
 
   Node* if_false;
   Node* if_true;
   while (true) {
-    Node* control_projections[2];
-    NodeProperties::CollectControlProjections(branch, control_projections, 2);
-    if_true = control_projections[0];
-    if_false = control_projections[1];
-    DCHECK_EQ(IrOpcode::kIfTrue, if_true->opcode());
-    DCHECK_EQ(IrOpcode::kIfFalse, if_false->opcode());
+    BranchMatcher matcher(branch);
+    DCHECK(matcher.Matched());
+
+    if_true = matcher.IfTrue();
+    if_false = matcher.IfFalse();
 
     auto it = if_false->uses().begin();
     if (it == if_false->uses().end()) break;
     Node* branch1 = *it++;
     if (branch1->opcode() != IrOpcode::kBranch) break;
     if (BranchHintOf(branch1->op()) != BranchHint::kNone) break;
     if (it != if_false->uses().end()) break;
     Node* cond1 = branch1->InputAt(0);
     if (cond1->opcode() != IrOpcode::kWord32Equal) break;
     Int32BinopMatcher m1(cond1);
@@ skipping 11 matching lines @@
     if_false->NullAllInputs();
     Enqueue(if_true);
 
     branch = branch1;
     value = value1;
     values.insert(value);
   }
 
   DCHECK_EQ(IrOpcode::kBranch, node->opcode());
   DCHECK_EQ(IrOpcode::kBranch, branch->opcode());
-  DCHECK_EQ(IrOpcode::kIfTrue, if_true->opcode());
-  DCHECK_EQ(IrOpcode::kIfFalse, if_false->opcode());
   if (branch == node) {
     DCHECK_EQ(1u, values.size());
     return false;
   }
   DCHECK_LT(1u, values.size());
   node->set_op(common()->Switch(values.size() + 1));
   node->ReplaceInput(0, index);
   if_true->set_op(common()->IfValue(value));
   if_true->ReplaceInput(0, node);
   Enqueue(if_true);
@@ skipping 13 matching lines @@
 Graph* ControlFlowOptimizer::graph() const { return jsgraph()->graph(); }
 
 
 MachineOperatorBuilder* ControlFlowOptimizer::machine() const {
   return jsgraph()->machine();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8