Remove skip_static_calls_ as it uses an obsolete way to check for uncalled static calls. Will be re…

runtime/vm/flow_graph_inliner.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/flow_graph_inliner.h"
 
 #include "vm/compiler.h"
 #include "vm/flags.h"
 #include "vm/flow_graph.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 168 matching lines @@
 };
 
 
 // A collection of call sites to consider for inlining.
 class CallSites : public FlowGraphVisitor {
  public:
   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_() { }
+        instance_calls_() { }
 
   const GrowableArray<StaticCallInstr*>& static_calls() const {
     return static_calls_;
   }
 
   const GrowableArray<ClosureCallInstr*>& closure_calls() const {
     return closure_calls_;
   }
 
   struct InstanceCallInfo {
@@ skipping 10 matching lines @@
   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.unoptimized_code());
-
-    skip_static_call_deopt_ids_.Clear();
-    code.ExtractUncalledStaticCallDeoptIds(&skip_static_call_deopt_ids_);
 
     const intptr_t instance_call_start_ix = instance_calls_.length();
     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);
       }
     }
     // Compute instance call site ratio.
     const intptr_t num_instance_calls =
         instance_calls_.length() - instance_call_start_ix;
     intptr_t max_count = 0;
     GrowableArray<intptr_t> call_counts(num_instance_calls);
     for (intptr_t i = 0; i < num_instance_calls; ++i) {
       const intptr_t aggregate_count =
           instance_calls_[i + instance_call_start_ix].
               call->ic_data().AggregateCount();
       call_counts.Add(aggregate_count);
       if (aggregate_count > max_count) max_count = aggregate_count;
     }
 
-
     for (intptr_t i = 0; i < num_instance_calls; ++i) {
       const double ratio = static_cast<double>(call_counts[i]) / max_count;
       instance_calls_[i + instance_call_start_ix].ratio = ratio;
     }
   }
 
   void VisitClosureCall(ClosureCallInstr* call) {
     closure_calls_.Add(call);
   }
 
   void VisitPolymorphicInstanceCall(PolymorphicInstanceCallInstr* call) {
     instance_calls_.Add(InstanceCallInfo(call));
   }
 
   void VisitStaticCall(StaticCallInstr* call) {
     if (!call->function().IsInlineable()) return;
-    const intptr_t call_deopt_id = call->deopt_id();
-    for (intptr_t i = 0; i < skip_static_call_deopt_ids_.length(); i++) {
-      if (call_deopt_id == skip_static_call_deopt_ids_[i]) {
-        // Do not inline this call.
-        return;
-      }
-    }
     static_calls_.Add(call);
   }
 
  private:
   GrowableArray<StaticCallInstr*> static_calls_;
   GrowableArray<ClosureCallInstr*> closure_calls_;
   GrowableArray<InstanceCallInfo> instance_calls_;
-  GrowableArray<intptr_t> skip_static_call_deopt_ids_;
 
   DISALLOW_COPY_AND_ASSIGN(CallSites);
 };
 
 
 struct InlinedCallData {
   InlinedCallData(Definition* call, GrowableArray<Value*>* arguments)
       : call(call),
         arguments(arguments),
         callee_graph(NULL),
@@ skipping 1045 matching lines @@
         OS::Print("After Inlining of %s\n", flow_graph_->
                   parsed_function().function().ToFullyQualifiedCString());
         FlowGraphPrinter printer(*flow_graph_);
         printer.PrintBlocks();
       }
     }
   }
 }
 
 }  // namespace dart