Fixed disabling inlining of static calls that were not executed.

runtime/vm/flow_graph_inliner.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_inliner.h"
 
 #include "vm/compiler.h"
 #include "vm/flags.h"
 #include "vm/flow_graph.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 160 matching lines @@
 
  private:
   intptr_t call_site_count_;
   intptr_t instruction_count_;
 };
 
 
 // A collection of call sites to consider for inlining.
 class CallSites : public FlowGraphVisitor {
  public:
-  CallSites(FlowGraph* flow_graph,
-            const GrowableArray<intptr_t>& skip_static_call_deopt_ids)
+  explicit CallSites(FlowGraph* flow_graph)
       : FlowGraphVisitor(flow_graph->postorder()),  // We don't use this order.
         static_calls_(),
         closure_calls_(),
         instance_calls_(),
-        skip_static_call_deopt_ids_(skip_static_call_deopt_ids) { }
+        skip_static_call_deopt_ids_() { }
 
   GrowableArray<StaticCallInstr*>* static_calls() {
     return &static_calls_;
   }
 
   GrowableArray<ClosureCallInstr*>* closure_calls() {
     return &closure_calls_;
   }
 
   GrowableArray<PolymorphicInstanceCallInstr*>* instance_calls() {
     return &instance_calls_;
   }
 
   bool HasCalls() const {
     return !(static_calls_.is_empty() &&
              closure_calls_.is_empty() &&
              instance_calls_.is_empty());
   }
 
   void Clear() {
     static_calls_.Clear();
     closure_calls_.Clear();
     instance_calls_.Clear();
+    skip_static_call_deopt_ids_.Clear();
   }
 
   void FindCallSites(FlowGraph* graph) {
+    ASSERT(graph != NULL);
+    const Function& function = graph->parsed_function().function();
+    ASSERT(function.HasCode());
+    const Code& code = Code::Handle(function.CurrentCode());
+    skip_static_call_deopt_ids_.Clear();
+    code.ExtractUncalledStaticCallDeoptIds(&skip_static_call_deopt_ids_);
     for (BlockIterator block_it = graph->postorder_iterator();
          !block_it.Done();
          block_it.Advance()) {
       for (ForwardInstructionIterator it(block_it.Current());
            !it.Done();
            it.Advance()) {
         it.Current()->Accept(this);
       }
     }
   }
@@ skipping 15 matching lines @@
         return;
       }
     }
     static_calls_.Add(call);
   }
 
  private:
   GrowableArray<StaticCallInstr*> static_calls_;
   GrowableArray<ClosureCallInstr*> closure_calls_;
   GrowableArray<PolymorphicInstanceCallInstr*> instance_calls_;
-  const GrowableArray<intptr_t>& skip_static_call_deopt_ids_;
+  GrowableArray<intptr_t> skip_static_call_deopt_ids_;
 
   DISALLOW_COPY_AND_ASSIGN(CallSites);
 };
 
 
 class CallSiteInliner : public ValueObject {
  public:
   explicit CallSiteInliner(FlowGraph* flow_graph)
       : caller_graph_(flow_graph),
         next_ssa_temp_index_(flow_graph->max_virtual_register_number()),
@@ skipping 22 matching lines @@
     }
     if ((const_arg_count >= FLAG_inlining_constant_arguments_count) &&
         (instr_count <= FLAG_inlining_constant_arguments_size_threshold)) {
       return true;
     }
     return false;
   }
 
   // TODO(srdjan): Handle large 'skip_static_call_deopt_ids'. Currently
   // max. size observed is 11 (dart2js).
-  void InlineCalls(const GrowableArray<intptr_t>& skip_static_call_deopt_ids) {
+  void InlineCalls() {
     // If inlining depth is less then one abort.
     if (FLAG_inlining_depth_threshold < 1) return;
     // Create two call site collections to swap between.
-    CallSites sites1(caller_graph_, skip_static_call_deopt_ids);
-    CallSites sites2(caller_graph_, skip_static_call_deopt_ids);
+    CallSites sites1(caller_graph_);
+    CallSites sites2(caller_graph_);
     CallSites* call_sites_temp = NULL;
     collected_call_sites_ = &sites1;
     inlining_call_sites_ = &sites2;
     // Collect initial call sites.
     collected_call_sites_->FindCallSites(caller_graph_);
     while (collected_call_sites_->HasCalls()) {
       TRACE_INLINING(OS::Print("  Depth %"Pd" ----------\n", inlining_depth_));
       // Swap collected and inlining arrays and clear the new collecting array.
       call_sites_temp = collected_call_sites_;
       collected_call_sites_ = inlining_call_sites_;
@@ skipping 469 matching lines @@
       flow_graph_->parsed_function().function().ToCString()));
 
   if (FLAG_trace_inlining && FLAG_print_flow_graph) {
     OS::Print("Before Inlining of %s\n", flow_graph_->
               parsed_function().function().ToFullyQualifiedCString());
     FlowGraphPrinter printer(*flow_graph_);
     printer.PrintBlocks();
   }
 
   CallSiteInliner inliner(flow_graph_);
-  inliner.InlineCalls(uncalled_static_static_call_deopt_ids_);
+  inliner.InlineCalls();
 
   if (inliner.inlined()) {
     flow_graph_->RepairGraphAfterInlining();
     if (FLAG_trace_inlining) {
       OS::Print("Inlining growth factor: %f\n", inliner.GrowthFactor());
       if (FLAG_print_flow_graph) {
         OS::Print("After Inlining of %s\n", flow_graph_->
                   parsed_function().function().ToFullyQualifiedCString());
         FlowGraphPrinter printer(*flow_graph_);
         printer.PrintBlocks();
       }
     }
   }
 }
 
 }  // namespace dart