Remove push arguments and replace constants in FlowGraph::InlineCall.

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 762 matching lines @@
     // If the successor is a target, update its predecessor.
     TargetEntryInstr* target = last->SuccessorAt(sidx)->AsTargetEntry();
     if (target != NULL) {
       target->predecessor_ = new_block;
       continue;
     }
     // If the successor is a join, update each predecessor and the phis.
     JoinEntryInstr* join = last->SuccessorAt(sidx)->AsJoinEntry();
     ASSERT(join != NULL);
     // Find the old predecessor index.
-    intptr_t old_index = join->IndexOfPredecessor(old_block);
-    intptr_t pred_count = join->PredecessorCount();
+    const intptr_t old_index = join->IndexOfPredecessor(old_block);
+    const intptr_t pred_count = join->PredecessorCount();
     ASSERT(old_index >= 0);
     ASSERT(old_index < pred_count);
     // Find the new predecessor index while reordering the predecessors.
-    intptr_t new_id = new_block->block_id();
+    const intptr_t new_id = new_block->block_id();
     intptr_t new_index = old_index;
+    // The predecessors are sorted by block id in ascending order.  This is done
+    // in JoinEntryInstr::AddPredecessor and in InlineCall.
     if (old_block->block_id() < new_id) {
       // Search upwards, bubbling down intermediate predecessors.
       for (; new_index < pred_count - 1; ++new_index) {
+        ASSERT(join->predecessors_[new_index]->block_id() <
+                   join->predecessors_[new_index + 1]->block_id());
         if (join->predecessors_[new_index + 1]->block_id() > new_id) break;
         join->predecessors_[new_index] = join->predecessors_[new_index + 1];
       }
     } else {
       // Search downwards, bubbling up intermediate predecessors.
       for (; new_index > 0; --new_index) {
+        ASSERT(join->predecessors_[new_index - 1]->block_id() <
+                   join->predecessors_[new_index]->block_id());
         if (join->predecessors_[new_index - 1]->block_id() < new_id) break;
         join->predecessors_[new_index] = join->predecessors_[new_index - 1];
       }
     }
     join->predecessors_[new_index] = new_block;
     // If the new and old predecessor index match there is nothing to update.
     if ((join->phis() == NULL) || (old_index == new_index)) return;
     // Otherwise, reorder the predecessor uses in each phi.
     for (intptr_t i = 0; i < join->phis()->length(); ++i) {
       PhiInstr* phi = (*join->phis())[i];
@@ skipping 170 matching lines @@
     ReplacePredecessor(callee_entry, caller_entry);
     // Update the last instruction pointers on each exit (ie, to the new goto).
     for (intptr_t i = 0; i < exits.length(); ++i) {
       exits[i]->set_last_instruction(
           exits[i]->last_instruction()->previous()->next());
     }
     // Mark that the dominator tree is invalid.
     // TODO(zerny): Compute the dominator frontier locally.
     invalid_dominator_tree_ = true;
   }
+
+  // Remove push arguments of the call.
+  for (intptr_t i = 0; i < call->ArgumentCount(); ++i) {
+    PushArgumentInstr* push = call->ArgumentAt(i);
+    push->ReplaceUsesWith(push->value()->definition());
+    push->RemoveFromGraph();
+  }
+
+  // Replace remaining constants with uses by constants in the caller's
+  // initial definitions.
+  GrowableArray<Definition*>* defns =
+      callee_graph->graph_entry()->initial_definitions();
+  for (intptr_t i = 0; i < defns->length(); ++i) {
+    ConstantInstr* constant = (*defns)[i]->AsConstant();
+    if (constant != NULL &&
+        ((constant->input_use_list() != NULL) ||
+         (constant->env_use_list() != NULL))) {
+      constant->ReplaceUsesWith(
+          AddConstantToInitialDefinitions(constant->value()));
+    }
+  }
 }
 
 
 void FlowGraph::RepairGraphAfterInlining() {
   DiscoverBlocks();
   if (invalid_dominator_tree_) {
     GrowableArray<BitVector*> dominance_frontier;
     ComputeDominators(&dominance_frontier);
   }
 }
 
 
 intptr_t FlowGraph::InstructionCount() const {
   intptr_t size = 0;
   // Iterate each block, skipping the graph entry.
   for (intptr_t i = 1; i < preorder_.length(); ++i) {
     for (ForwardInstructionIterator it(preorder_[i]);
          !it.Done();
          it.Advance()) {
       ++size;
     }
   }
   return size;
 }
 
 
 }  // namespace dart