Initial support for polymorphic inlining.

runtime/vm/flow_graph_optimizer.cc

 // Copyright (c) 2013, 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/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 3220 matching lines @@
     if (pre_header == NULL) continue;
 
     for (BitVector::Iterator loop_it(header->loop_info());
          !loop_it.Done();
          loop_it.Advance()) {
       BlockEntryInstr* block = flow_graph()->preorder()[loop_it.Current()];
       for (ForwardInstructionIterator it(block);
            !it.Done();
            it.Advance()) {
         Instruction* current = it.Current();
-        if (!current->IsPushArgument() &&
-            current->AllowsCSE() &&
+        if (current->AllowsCSE() &&
             flow_graph()->block_effects()->CanBeMovedTo(current, pre_header)) {
           bool inputs_loop_invariant = true;
           for (int i = 0; i < current->InputCount(); ++i) {
             Definition* input_def = current->InputAt(i)->definition();
             if (!input_def->GetBlock()->Dominates(pre_header)) {
               inputs_loop_invariant = false;
               break;
             }
           }
           if (inputs_loop_invariant &&
@@ skipping 1270 matching lines @@
     if (reachable_->Contains(
             block->PredecessorAt(pred_idx)->preorder_number())) {
       Join(&value,
            instr->InputAt(pred_idx)->definition()->constant_value());
     }
   }
   SetValue(instr, value);
 }
 
 
+void ConstantPropagator::VisitRedefinition(RedefinitionInstr* instr) {
+  SetValue(instr, instr->value()->definition()->constant_value());
+}
+
+
 void ConstantPropagator::VisitParameter(ParameterInstr* instr) {
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitPushArgument(PushArgumentInstr* instr) {
   SetValue(instr, instr->value()->definition()->constant_value());
 }
 
 
@@ skipping 254 matching lines @@
     AllocateObjectWithBoundsCheckInstr* instr) {
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitLoadUntagged(LoadUntaggedInstr* instr) {
   SetValue(instr, non_constant_);
 }
 
 
+void ConstantPropagator::VisitLoadClassId(LoadClassIdInstr* instr) {
+  SetValue(instr, non_constant_);
+}
+
+
 void ConstantPropagator::VisitLoadField(LoadFieldInstr* instr) {
   if ((instr->recognized_kind() == MethodRecognizer::kObjectArrayLength) &&
       (instr->instance()->definition()->IsCreateArray())) {
     const intptr_t length =
         instr->instance()->definition()->AsCreateArray()->num_elements();
     const Object& result = Smi::ZoneHandle(Smi::New(length));
     SetValue(instr, result);
     return;
   }
 
@@ skipping 754 matching lines @@
 
         // Insert a copy of the constant in all the predecessors.
         ConstantInstr* new_constant = CloneConstant(flow_graph, constant);
         new_constant->InsertBefore(old_goto);
 
         // Replace the goto in each predecessor with a rewritten branch,
         // rewritten to use the corresponding phi input instead of the phi.
         Value* new_left = phi->InputAt(i)->Copy();
         Value* new_right = new Value(new_constant);
         BranchInstr* new_branch = CloneBranch(branch, new_left, new_right);
-        new_branch->InheritDeoptTarget(old_goto);
+        if (branch->env() == NULL) {
+          new_branch->InheritDeoptTarget(old_goto);
+        } else {
+          // Take the environment from the branch if it has one.
+          new_branch->InheritDeoptTarget(branch);
+          // InheritDeoptTarget gave the new branch's comparison the same
+          // deopt id that it gave the new branch.  The id should be the
+          // deopt id of the original comparison.
+          new_branch->comparison()->SetDeoptId(comparison->GetDeoptId());
+          // The phi and constant can be used in the branch's environment.
+          // Rename such uses.
+          for (Environment::DeepIterator it(new_branch->env());
+               !it.Done();
+               it.Advance()) {
+            Value* use = it.CurrentValue();
+            Definition* replacement = NULL;
+            if (use->definition() == phi) {
+              replacement = phi->InputAt(i)->definition();
+            } else if (use->definition() == constant) {
+              replacement = new_constant;
+            }
+            if (replacement != NULL) {
+              use->RemoveFromUseList();
+              use->set_definition(replacement);
+              replacement->AddEnvUse(use);
+            }
+          }
+        }
+
         new_branch->InsertBefore(old_goto);
         new_branch->set_next(NULL);  // Detaching the goto from the graph.
         old_goto->UnuseAllInputs();
 
         // Update the predecessor block.  We may have created another
         // instance of the pattern so add it to the worklist if necessary.
         BlockEntryInstr* branch_block = new_branch->GetBlock();
         branch_block->set_last_instruction(new_branch);
         if (branch_block->IsJoinEntry()) worklist.Add(branch_block);
 
@@ skipping 17 matching lines @@
         GotoInstr* goto_false = new GotoInstr(join_false);
         goto_false->InheritDeoptTarget(join_false);
         false_target->LinkTo(goto_false);
         false_target->set_last_instruction(goto_false);
       }
       // When all predecessors have been rewritten, the original block is
       // unreachable from the graph.
       phi->UnuseAllInputs();
       branch->UnuseAllInputs();
       block->UnuseAllInputs();
+      ASSERT(!phi->HasUses());
+      ASSERT(!constant->HasUses());
     }
   }
 
   if (changed) {
     // We may have changed the block order and the dominator tree.
     flow_graph->DiscoverBlocks();
     GrowableArray<BitVector*> dominance_frontier;
     flow_graph->ComputeDominators(&dominance_frontier);
   }
 }
@@ skipping 122 matching lines @@
   if (changed) {
     // We may have changed the block order and the dominator tree.
     flow_graph->DiscoverBlocks();
     GrowableArray<BitVector*> dominance_frontier;
     flow_graph->ComputeDominators(&dominance_frontier);
   }
 }
 
 
 }  // namespace dart