Fuse compare with branch at graph building time.

runtime/vm/flow_graph_optimizer.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/flow_graph_optimizer.h"
 
 #include "vm/flow_graph_builder.h"
 #include "vm/il_printer.h"
 #include "vm/object_store.h"
 
@@ skipping 473 matching lines @@
 
   const intptr_t class_id = ReceiverClassId(comp);
   switch (class_id) {
     case kArray:
     case kGrowableObjectArray:
       comp->set_receiver_type(static_cast<ObjectKind>(class_id));
   }
 }
 
 
-static void TryFuseComparisonWithBranch(BindInstr* instr,
-                                        ComparisonComp* comp) {
-  Instruction* next_instr = instr->next();
-  if ((next_instr != NULL) && next_instr->IsBranch()) {
-    BranchInstr* branch = next_instr->AsBranch();
-    UseVal* use = branch->value()->AsUse();
-    if (instr == use->definition()) {
-      comp->MarkFusedWithBranch(branch);
-      branch->MarkFusedWithComparison(comp);
-
-      // Remove comparison from the graph.
-      branch->set_previous(instr->previous());
-      instr->previous()->set_next(branch);
-      return;
-    }
-  }
-  if ((next_instr != NULL) && next_instr->IsBind()) {
-    Computation* next_comp = next_instr->AsBind()->computation();
-    if (next_comp->IsBooleanNegate()) {
-      Instruction* next_next_instr = next_instr->next();
-      if ((next_next_instr != NULL) && next_next_instr->IsBranch()) {
-        BooleanNegateComp* negate = next_comp->AsBooleanNegate();
-        BranchInstr* branch = next_next_instr->AsBranch();
-        if ((branch->value()->AsUse()->definition() == next_instr) &&
-            (negate->value()->AsUse()->definition() == instr)) {
-          comp->MarkFusedWithBranch(branch);
-          branch->MarkFusedWithComparison(comp);
-          branch->set_is_negated(true);
-
-          // Remove comparison and boolean negation from the graph.
-          branch->set_previous(instr->previous());
-          instr->previous()->set_next(branch);
-          return;
-        }
-      }
-    }
-  }
-}
-
-
 void FlowGraphOptimizer::VisitRelationalOp(RelationalOpComp* comp,
                                            BindInstr* instr) {
   if (!comp->HasICData()) return;
 
   const ICData& ic_data = *comp->ic_data();
   if (ic_data.NumberOfChecks() == 0) return;
   // TODO(srdjan): Add multiple receiver type support.
   if (ic_data.NumberOfChecks() != 1) return;
   ASSERT(HasOneTarget(ic_data));
 
   if (HasOnlyTwoSmi(ic_data)) {
     comp->set_operands_class_id(kSmi);
   } else if (HasOnlyTwoDouble(ic_data)) {
     comp->set_operands_class_id(kDouble);
   } else {
     return;
   }
-
-  // For smi and double comparisons if the next instruction is a conditional
-  // branch that uses the value of this comparison mark them as fused together
-  // to avoid materializing a boolean value.
-  TryFuseComparisonWithBranch(instr, comp);
-}
-
-
-void FlowGraphOptimizer::VisitStrictCompare(StrictCompareComp* comp,
-                                            BindInstr* instr) {
-  TryFuseComparisonWithBranch(instr, comp);
 }
 
 
 void FlowGraphOptimizer::VisitEqualityCompare(EqualityCompareComp* comp,
                                               BindInstr* instr) {
   if (comp->HasICData() && (comp->ic_data()->NumberOfChecks() == 1)) {
     ASSERT(comp->ic_data()->num_args_tested() == 2);
     GrowableArray<intptr_t> class_ids;
     Function& target = Function::Handle();
     comp->ic_data()->GetCheckAt(0, &class_ids, &target);
     // TODO(srdjan): allow for mixed mode comparison.
     if ((class_ids[0] == kSmi) && (class_ids[1] == kSmi)) {
       comp->set_receiver_class_id(kSmi);
     } else if ((class_ids[0] == kDouble) && (class_ids[1] == kDouble)) {
       comp->set_receiver_class_id(kDouble);
     }
   }
-  TryFuseComparisonWithBranch(instr, comp);
 }
 
 
 void FlowGraphOptimizer::VisitBind(BindInstr* instr) {
   instr->computation()->Accept(this, instr);
 }
 
 
 
 void FlowGraphAnalyzer::Analyze() {
   is_leaf_ = true;
   for (intptr_t i = 0; i < blocks_.length(); ++i) {
     BlockEntryInstr* entry = blocks_[i];
     for (ForwardInstructionIterator it(entry); !it.Done(); it.Advance()) {
       LocationSummary* locs = it.Current()->locs();
       if ((locs != NULL) && locs->is_call()) {
         is_leaf_ = false;
         return;
       }
     }
   }
 }
 
 }  // namespace dart