Initial support for polymorphic inlining.

runtime/vm/flow_graph.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.h"
 
 #include "vm/bit_vector.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/intermediate_language.h"
 #include "vm/longjump.h"
@@ skipping 504 matching lines @@
   }
 
   // 2. Compute the immediate dominators as the nearest common ancestor of
   // spanning tree parent and semidominator, for all blocks except the entry.
   for (intptr_t block_index = 1; block_index < size; ++block_index) {
     intptr_t dom_index = idom[block_index];
     while (dom_index > semi[block_index]) {
       dom_index = idom[dom_index];
     }
     idom[block_index] = dom_index;
-    preorder_[block_index]->set_dominator(preorder_[dom_index]);
     preorder_[dom_index]->AddDominatedBlock(preorder_[block_index]);
   }
 
   // 3. Now compute the dominance frontier for all blocks.  This is
   // algorithm in "A Simple, Fast Dominance Algorithm" (Figure 5), which is
   // attributed to a paper by Ferrante et al.  There is no bookkeeping
   // required to avoid adding a block twice to the same block's dominance
   // frontier because we use a set to represent the dominance frontier.
   for (intptr_t block_index = 0; block_index < size; ++block_index) {
     BlockEntryInstr* block = preorder_[block_index];
@@ skipping 304 matching lines @@
     }
   }
 
   for (BlockIterator it(postorder_iterator()); !it.Done(); it.Advance()) {
     JoinEntryInstr* join = it.Current()->AsJoinEntry();
     if (join != NULL) join->RemoveDeadPhis(constant_null());
   }
 }
 
 
+void FlowGraph::RemoveRedefinitions() {
+  // Remove redefinition instructions inserted to inhibit hoisting.
+  for (BlockIterator block_it = reverse_postorder_iterator();
+       !block_it.Done();
+       block_it.Advance()) {
+    for (ForwardInstructionIterator instr_it(block_it.Current());
+         !instr_it.Done();
+         instr_it.Advance()) {
+      RedefinitionInstr* redefinition = instr_it.Current()->AsRedefinition();
+      if (redefinition != NULL) {
+        Definition* original;
+        do {
+          original = redefinition->value()->definition();
+        } while (original->IsRedefinition());
+        redefinition->ReplaceUsesWith(original);
+        instr_it.RemoveCurrentFromGraph();
+      }
+    }
+  }
+}
+
+
 // Find the natural loop for the back edge m->n and attach loop information
 // to block n (loop header). The algorithm is described in "Advanced Compiler
 // Design & Implementation" (Muchnick) p192.
 static void FindLoop(BlockEntryInstr* m,
                      BlockEntryInstr* n,
                      intptr_t num_blocks) {
   GrowableArray<BlockEntryInstr*> stack;
   BitVector* loop = new BitVector(num_blocks);
 
   loop->Add(n->preorder_number());
@@ skipping 171 matching lines @@
 }
 
 
 bool BlockEffects::IsSideEffectFreePath(BlockEntryInstr* from,
                                         BlockEntryInstr* to) const {
   return available_at_[to->postorder_number()]->Contains(
       from->postorder_number());
 }
 
 }  // namespace dart