Inlining of calls with optional parameters.

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 18 matching lines @@
     graph_entry_(graph_entry),
     preorder_(),
     postorder_(),
     reverse_postorder_(),
     exits_(NULL),
     invalid_dominator_tree_(true) {
   DiscoverBlocks();
 }
 
 
+ConstantInstr* FlowGraph::AddConstantToInitialDefinitions(
+    const Object& object) {
+  // Check if the constant is already in the pool.
+  for (intptr_t i = 0; i < graph_entry_->initial_definitions()->length(); ++i) {
+    ConstantInstr* constant =
+        (*graph_entry_->initial_definitions())[i]->AsConstant();
+    if ((constant != NULL) && (constant->value().raw() == object.raw())) {
+      return constant;
+    }
+  }
+  // Otherwise, allocate and add it to the pool.
+  ConstantInstr* constant = new ConstantInstr(object);
+  constant->set_ssa_temp_index(alloc_ssa_temp_index());
+  graph_entry_->initial_definitions()->Add(constant);
+  return constant;
+}
+
+
 void FlowGraph::DiscoverBlocks() {
   // Initialize state.
   preorder_.Clear();
   postorder_.Clear();
   reverse_postorder_.Clear();
   parent_.Clear();
   assigned_vars_.Clear();
   // Perform a depth-first traversal of the graph to build preorder and
   // postorder block orders.
   graph_entry_->DiscoverBlocks(NULL,  // Entry block predecessor.
@@ skipping 226 matching lines @@
   DEBUG_ASSERT(ResetUseLists());
   // Clear initial definitions.
   for (intptr_t i = 0; i < graph_entry_->initial_definitions()->length(); ++i) {
     ClearUseLists((*graph_entry_->initial_definitions())[i]);
   }
   ComputeUseListsRecursive(graph_entry_);
   DEBUG_ASSERT(!FLAG_verify_compiler || ValidateUseLists());
 }
 
 
-void FlowGraph::ComputeSSA(intptr_t next_virtual_register_number) {
+void FlowGraph::ComputeSSA(intptr_t next_virtual_register_number,
+                           GrowableArray<Definition*>* inlining_parameters) {
+  ASSERT((next_virtual_register_number == 0) || (inlining_parameters != NULL));
   current_ssa_temp_index_ = next_virtual_register_number;
   GrowableArray<BitVector*> dominance_frontier;
   ComputeDominators(&dominance_frontier);
   InsertPhis(preorder_, assigned_vars_, dominance_frontier);
   GrowableArray<PhiInstr*> live_phis;
   // Rename uses to reference inserted phis where appropriate.
   // Collect phis that reach a non-environment use.
-  Rename(&live_phis);
+  Rename(&live_phis, inlining_parameters);
   // Propagate alive mark transitively from alive phis.
   MarkLivePhis(&live_phis);
 }
 
 
 // Compute immediate dominators and the dominance frontier for each basic
 // block.  As a side effect of the algorithm, sets the immediate dominator
 // of each basic block.
 //
 // dominance_frontier: an output parameter encoding the dominance frontier.
@@ skipping 160 matching lines @@
             work[index] = var_index;
             worklist.Add(block);
           }
         }
       }
     }
   }
 }
 
 
-void FlowGraph::Rename(GrowableArray<PhiInstr*>* live_phis) {
+void FlowGraph::Rename(GrowableArray<PhiInstr*>* live_phis,
+                       GrowableArray<Definition*>* inlining_parameters) {
   // TODO(fschneider): Support catch-entry.
   if (graph_entry_->SuccessorCount() > 1) {
     Bailout("Catch-entry support in SSA.");
   }
 
   // Initial renaming environment.
   GrowableArray<Definition*> env(variable_count());
 
   // Add global constants to the initial definitions.
   ConstantInstr* constant_null = new ConstantInstr(Object::ZoneHandle());
   constant_null->set_ssa_temp_index(alloc_ssa_temp_index());
   graph_entry_->initial_definitions()->Add(constant_null);
 
-  // Add incoming parameters to the initial definitions and the renaming
-  // environment.
-  for (intptr_t i = 0; i < parameter_count(); ++i) {
-    ParameterInstr* param = new ParameterInstr(i, graph_entry_);
-    param->set_ssa_temp_index(alloc_ssa_temp_index());  // New SSA temp.
-    graph_entry_->initial_definitions()->Add(param);
-    env.Add(param);
+  // Add parameters to the initial definitions and renaming environment.
+  if (inlining_parameters != NULL) {
+    // Use known parameters.
+    ASSERT(parameter_count() == inlining_parameters->length());
+    for (intptr_t i = 0; i < parameter_count(); ++i) {
+      Definition* defn = (*inlining_parameters)[i];
+      defn->set_ssa_temp_index(alloc_ssa_temp_index());  // New SSA temp.
+      graph_entry_->initial_definitions()->Add(defn);
+      env.Add(defn);
+    }
+  } else {
+    // Create new parameters.
+    for (intptr_t i = 0; i < parameter_count(); ++i) {
+      ParameterInstr* param = new ParameterInstr(i, graph_entry_);
+      param->set_ssa_temp_index(alloc_ssa_temp_index());  // New SSA temp.
+      graph_entry_->initial_definitions()->Add(param);
+      env.Add(param);
+    }
   }
 
   // Initialize all locals with #null in the renaming environment.
   for (intptr_t i = parameter_count(); i < variable_count(); ++i) {
     env.Add(constant_null);
   }
 
   BlockEntryInstr* normal_entry = graph_entry_->SuccessorAt(0);
   ASSERT(normal_entry != NULL);  // Must have entry.
   RenameRecursive(normal_entry, &env, live_phis);
@@ skipping 465 matching lines @@
          !it.Done();
          it.Advance()) {
       ++size;
     }
   }
   return size;
 }
 
 
 }  // namespace dart