Initial implementation of on-stack replacement (OSR).

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 633 matching lines @@
         }
       }
     }
   }
 }
 
 
 void FlowGraph::Rename(GrowableArray<PhiInstr*>* live_phis,
                        VariableLivenessAnalysis* variable_liveness,
                        ZoneGrowableArray<Definition*>* inlining_parameters) {
-  if (!FLAG_optimize_try_catch && (graph_entry_->SuccessorCount() > 1)) {
+  GraphEntryInstr* entry = graph_entry();
+  if (!FLAG_optimize_try_catch && (entry->SuccessorCount() > 1)) {
     Bailout("Catch-entry support in SSA.");
   }
 
   // Initial renaming environment.
   GrowableArray<Definition*> env(variable_count());
 
   // Add global constants to the initial definitions.
   constant_null_ = GetConstant(Object::ZoneHandle());
 
   // 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.
       AddToInitialDefinitions(defn);
       env.Add(defn);
     }
   } else {
-    // Create new parameters.
-    for (intptr_t i = 0; i < parameter_count(); ++i) {
-      ParameterInstr* param = new ParameterInstr(i, graph_entry_);
+    // Create new parameters.  For functions compiled for OSR, the locals
+    // are unknown and so treated like parameters.
+    intptr_t count = IsCompiledForOsr() ? variable_count() : parameter_count();
+    for (intptr_t i = 0; i < count; ++i) {
+      ParameterInstr* param = new ParameterInstr(i, entry);
       param->set_ssa_temp_index(alloc_ssa_temp_index());  // New SSA temp.
       AddToInitialDefinitions(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());
+  // Initialize all locals with #null in the renaming environment.  For OSR,
+  // the locals have already been handled as parameters.
+  if (!IsCompiledForOsr()) {
+    for (intptr_t i = parameter_count(); i < variable_count(); ++i) {
+      env.Add(constant_null());
+    }
   }
 
-  if (graph_entry_->SuccessorCount() > 1) {
+  if (entry->SuccessorCount() > 1) {
     // Functions with try-catch have a fixed area of stack slots reserved
     // so that all local variables are stored at a known location when
     // on entry to the catch.
-    graph_entry_->set_fixed_slot_count(
-        num_stack_locals() + num_copied_params());
+    entry->set_fixed_slot_count(num_stack_locals() + num_copied_params());
   }
-  RenameRecursive(graph_entry_, &env, live_phis, variable_liveness);
+  RenameRecursive(entry, &env, live_phis, variable_liveness);
 }
 
 
 void FlowGraph::AttachEnvironment(Instruction* instr,
                                   GrowableArray<Definition*>* env) {
   Environment* deopt_env =
       Environment::From(*env,
                         num_non_copied_params_,
                         parsed_function_.function());
   instr->SetEnvironment(deopt_env);
@@ skipping 428 matching lines @@
 }
 
 
 bool BlockEffects::IsSideEffectFreePath(BlockEntryInstr* from,
                                         BlockEntryInstr* to) const {
   return available_at_[to->postorder_number()]->Contains(
       from->postorder_number());
 }
 
 }  // namespace dart