Use constants from the frame at OSR entry.

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/growable_array.h"
 #include "vm/intermediate_language.h"
 #include "vm/longjump.h"
-#include "vm/growable_array.h"
+#include "vm/stack_frame.h"
 
 namespace dart {
 
 DECLARE_FLAG(bool, reorder_basic_blocks);
 DECLARE_FLAG(bool, trace_optimization);
 DECLARE_FLAG(bool, verify_compiler);
 DEFINE_FLAG(bool, optimize_try_catch, true, "Optimization of try-catch");
 
 
 FlowGraph::FlowGraph(const FlowGraphBuilder& builder,
@@ skipping 48 matching lines @@
 
 GrowableArray<BlockEntryInstr*>* FlowGraph::CodegenBlockOrder(
     bool is_optimized) {
   return ShouldReorderBlocks(parsed_function().function(), is_optimized)
       ? &optimized_block_order_
       : &reverse_postorder_;
 }
 
 
 ConstantInstr* FlowGraph::GetConstant(const Object& object) {
+  // Not all objects can be embedded in code.
+  ASSERT(object.IsSmi() || object.InVMHeap() || object.IsOld());
   // Check if the constant is already in the pool.
   GrowableArray<Definition*>* pool = graph_entry_->initial_definitions();
   for (intptr_t i = 0; i < pool->length(); ++i) {
     ConstantInstr* constant = (*pool)[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);
@@ skipping 598 matching lines @@
             work[index] = var_index;
             worklist.Add(block);
           }
         }
       }
     }
   }
 }
 
 
+void FlowGraph::InitializeOsrLocalRange(GrowableArray<Definition*>* env,
+                                        RawObject** base,
+                                        intptr_t count) {
+  for (intptr_t i = 0; i < count; ++i) {
+    // Variables go from high to low addresses as they go from left to
+    // right.
+    Object& value = Object::ZoneHandle(base[-i]);

[srdjan, 2014/01/07 18:51:20]

const Object&

[Florian Schneider, 2014/01/08 10:48:03]

Done.

+    Definition* definition = NULL;
+    if (value.IsSmi() || value.InVMHeap() || value.IsOld()) {
+      definition = GetConstant(value);
+    } else {
+      definition = new ParameterInstr(env->length(), graph_entry());

[Kevin Millikin (Google), 2014/01/07 14:09:19]

I know you've already thought of this, but here you could record the original
value (e.g., to query its class) but just not emit it in code.

[Florian Schneider, 2014/01/08 10:48:03]

Good point. I'll do this in a separate CL since adding the type information
triggers another bug in our specialization of ICData.

+      definition->set_ssa_temp_index(alloc_ssa_temp_index());
+      AddToInitialDefinitions(definition);
+    }
+    env->Add(definition);
+  }
+}
+
+
+void FlowGraph::InitializeOsrLocals(GrowableArray<Definition*>* env) {
+  DartFrameIterator iterator;
+  StackFrame* frame = iterator.NextFrame();
+  const Code& code = Code::Handle(frame->LookupDartCode());
+  ASSERT(!code.is_optimized());
+  ASSERT(frame->LookupDartFunction() == parsed_function().function().raw());
+
+  intptr_t count = num_non_copied_params();

[Kevin Millikin (Google), 2014/01/07 14:09:19]

I guess there should be a comment here that it's important to initialize them
from 'left to right' (parameters first, then other stack locals, in environment
order) because the counter is used to assign indexes.

[Florian Schneider, 2014/01/08 10:48:03]

Done.

+  RawObject** base = reinterpret_cast<RawObject**>(frame->fp())
+      + kParamEndSlotFromFp  // One past the last parameter.
+      + count;
+  InitializeOsrLocalRange(env, base, count);
+
+  count = num_copied_params() + num_stack_locals();
+  base = reinterpret_cast<RawObject**>(frame->fp()) + kFirstLocalSlotFromFp;
+  InitializeOsrLocalRange(env, base, count);
+}
+
+
 void FlowGraph::Rename(GrowableArray<PhiInstr*>* live_phis,
                        VariableLivenessAnalysis* variable_liveness,
                        ZoneGrowableArray<Definition*>* inlining_parameters) {
   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());
   constant_dead_ = GetConstant(Symbols::OptimizedOut());
 
   // Add parameters to the initial definitions and renaming environment.
   if (inlining_parameters != NULL) {
-    // Use known parameters.
+    // When inlining, use the known parameter definitions.
     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 if (IsCompiledForOsr()) {
+    // For functions compiled for OSR, use the constants found in the
+    // unoptimized frame.
+    InitializeOsrLocals(&env);
   } else {
-    // 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) {
+    // Create fresh (unknown) parameters.
+    for (intptr_t i = 0; i < parameter_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 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 (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.
-    entry->set_fixed_slot_count(num_stack_locals() + num_copied_params());
-  }
   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_,
                         Code::Handle(parsed_function_.code()));
@@ skipping 439 matching lines @@
 }
 
 
 bool BlockEffects::IsSideEffectFreePath(BlockEntryInstr* from,
                                         BlockEntryInstr* to) const {
   return available_at_[to->postorder_number()]->Contains(
       from->postorder_number());
 }
 
 }  // namespace dart