Skeleton of a linear scan register allocator.

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 509 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));
   }
 }
 
 
+#if 0
+// TODO(vegorov): land a separate CL to fix the fusion. Now it should remove
+// instruction from the graph to avoid confusing register allocator.
 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();
       return;
@@ skipping 11 matching lines @@
           comp->MarkFusedWithBranch(branch);
           branch->MarkFusedWithComparison();
           branch->set_is_negated(true);
           instr->set_next(next_next_instr);
           return;
         }
       }
     }
   }
 }
+#endif
 
 
 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.
+#if 0

[srdjan, 2012/07/11 17:22:32]

Enable once synced with branch fusion fix

   TryFuseComparisonWithBranch(instr, comp);
+#endif
 }
 
 
 void FlowGraphOptimizer::VisitStrictCompare(StrictCompareComp* comp,
                                             BindInstr* instr) {
+#if 0
   TryFuseComparisonWithBranch(instr, comp);
+#endif
 }
 
 
 void FlowGraphOptimizer::VisitEqualityCompare(EqualityCompareComp* comp,
                                               BindInstr* instr) {
   if (comp->HasICData()) {
     // Replace binary checks with unary ones since EmitNative expects it.
     ICData& unary_checks =
         ICData::Handle(ToUnaryClassChecks(*comp->ic_data()));
     comp->set_ic_data(&unary_checks);
   }
 
+#if 0
   TryFuseComparisonWithBranch(instr, comp);
+#endif
 }
 
 
 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