Initial implementation of on-stack replacement (OSR).

runtime/vm/flow_graph_compiler.cc

 // Copyright (c) 2013, 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/globals.h"  // Needed here to get TARGET_ARCH_XXX.
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/cha.h"
 #include "vm/dart_entry.h"
@@ skipping 83 matching lines @@
 
 bool FlowGraphCompiler::HasFinally() const {
   return parsed_function().function().has_finally();
 }
 
 
 void FlowGraphCompiler::InitCompiler() {
   pc_descriptors_list_ = new DescriptorList(64);
   exception_handlers_list_ = new ExceptionHandlerList();
   block_info_.Clear();
-  bool is_leaf = !parsed_function().function().IsClosureFunction() &&
-                 is_optimizing();
+  // Conservative detection of leaf routines used to remove the stack check
+  // on function entry.
+  bool is_leaf = !parsed_function().function().IsClosureFunction()
+      && is_optimizing()
+      && !flow_graph().IsCompiledForOsr();
+  // Initialize block info and search optimized (non-OSR) code for calls
+  // indicating a non-leaf routine and calls without IC data indicating
+  // possible reoptimization.
   for (int i = 0; i < block_order_.length(); ++i) {
     block_info_.Add(new BlockInfo());
-    if (is_optimizing()) {
+    if (is_optimizing() && !flow_graph().IsCompiledForOsr()) {
       BlockEntryInstr* entry = block_order_[i];
       for (ForwardInstructionIterator it(entry); !it.Done(); it.Advance()) {
         Instruction* current = it.Current();
-        const ICData* ic_data = NULL;
         if (current->IsBranch()) {
           current = current->AsBranch()->comparison();
         }
         // In optimized code, ICData is always set in the instructions.
+        const ICData* ic_data = NULL;
         if (current->IsInstanceCall()) {
           ic_data = current->AsInstanceCall()->ic_data();
           ASSERT(ic_data != NULL);
         } else if (current->IsRelationalOp()) {
           ic_data = current->AsRelationalOp()->ic_data();
           ASSERT(ic_data != NULL);
         } else if (current->IsEqualityCompare()) {
           ic_data = current->AsEqualityCompare()->ic_data();
           ASSERT(ic_data != NULL);
         }
         if ((ic_data != NULL) && (ic_data->NumberOfChecks() == 0)) {
           may_reoptimize_ = true;
-          break;
         }
         if (is_leaf && !current->IsCheckStackOverflow()) {
-          // Note that we do no care if the code contains instructions that
+          // Note that we do not care if the code contains instructions that
           // can deoptimize.
           LocationSummary* locs = current->locs();
           if ((locs != NULL) && locs->can_call()) {
             is_leaf = false;
           }
         }
       }
     }
   }
   if (is_leaf) {
-    // Remove check stack overflow at entry.
-    CheckStackOverflowInstr* check = flow_graph_.graph_entry()->normal_entry()
-        ->next()->AsCheckStackOverflow();
-    ASSERT(check != NULL);
-    check->RemoveFromGraph();
+    // Remove the stack overflow check at function entry.
+    Instruction* first = flow_graph_.graph_entry()->normal_entry()->next();
+    ASSERT(first->IsCheckStackOverflow());
+    if (first->IsCheckStackOverflow()) first->RemoveFromGraph();
   }
 }
 
 
 bool FlowGraphCompiler::CanOptimize() {
   return !FLAG_report_usage_count &&
          (FLAG_optimization_counter_threshold >= 0);
 }
 
 
@@ skipping 389 matching lines @@
       label_address = StubCode::ClosureCallInlineCacheEntryPoint();
       ExternalLabel target_label("InlineCache", label_address);
       EmitInstanceCall(&target_label,
                        ICData::ZoneHandle(ic_data.AsUnaryClassChecks()),
                        arguments_descriptor, argument_count,
                        deopt_id, token_pos, locs);
       return;
     }
     // Emit IC call that will count and thus may need reoptimization at
     // function entry.
-    ASSERT(!is_optimizing() || may_reoptimize());
+    ASSERT(!is_optimizing()
+           || may_reoptimize()
+           || flow_graph().IsCompiledForOsr());
     switch (ic_data.num_args_tested()) {
       case 1:
         label_address = StubCode::OneArgOptimizedCheckInlineCacheEntryPoint();
         break;
       case 2:
         label_address = StubCode::TwoArgsOptimizedCheckInlineCacheEntryPoint();
         break;
       case 3:
         label_address =
             StubCode::ThreeArgsOptimizedCheckInlineCacheEntryPoint();
@@ skipping 513 matching lines @@
 
   for (int i = 0; i < len; i++) {
     sorted->Add(CidTarget(ic_data.GetReceiverClassIdAt(i),
                           &Function::ZoneHandle(ic_data.GetTargetAt(i)),
                           ic_data.GetCountAt(i)));
   }
   sorted->Sort(HighestCountFirst);
 }
 
 }  // namespace dart