Detect leaf optimized methods and skip stack check overflow test in those, unless it is in a loop (…

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 142 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();
   for (int i = 0; i < block_order_.length(); ++i) {
     block_info_.Add(new BlockInfo());
     if (is_optimizing()) {
       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.
         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
+          // can deoptimize.
+          LocationSummary* locs = current->locs();
+          if (locs != NULL && locs->can_call()) {
+            is_leaf = false;
+          }
+        }
       }
     }
   }
+  if (is_leaf) {
+    BlockEntryInstr* entry = block_order_[1];

[Kevin Millikin (Google), 2013/04/18 10:05:28]

I don't think we should rely on properties of the block order here (i.e., we
might want to reorder blocks).

The simplest way to avoid it is to have the FlowGraphCompiler hold onto the flow
graph so you can write

Instruction* entry = flow_graph_->normal_entry();

[srdjan, 2013/04/18 18:15:57]

Yes, using: flow_graph_.graph_entry()->normal_entry()->next()

+    ASSERT(entry != NULL);
+    CheckStackOverflowInstr* check = entry->next()->AsCheckStackOverflow();
+    ASSERT(check != NULL);
+    check->RemoveFromGraph();
+  }
 }
 
 
 bool FlowGraphCompiler::CanOptimize() {
   return !FLAG_report_usage_count &&
          (FLAG_optimization_counter_threshold >= 0);
 }
 
 
 bool FlowGraphCompiler::CanOptimizeFunction() const {
@@ skipping 923 matching lines @@
     if (i != largest_ix) {
       // Swap.
       CidTarget temp = (*sorted)[i];
       (*sorted)[i] = (*sorted)[largest_ix];
       (*sorted)[largest_ix] = temp;
     }
   }
 }
 
 }  // namespace dart