Polymorphic inlining for some recognized methods in the optimizing compiler.

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 147 matching lines @@
   void Collect(const FlowGraph& graph) {
     call_site_count_ = 0;
     instruction_count_ = 0;
     for (BlockIterator block_it = graph.postorder_iterator();
          !block_it.Done();
          block_it.Advance()) {
       for (ForwardInstructionIterator it(block_it.Current());
            !it.Done();
            it.Advance()) {
         ++instruction_count_;
-        if (it.Current()->IsStaticCall() ||
-            it.Current()->IsClosureCall() ||
-            it.Current()->IsPolymorphicInstanceCall()) {
+        Instruction* current = it.Current();
+        if (current->IsStaticCall() ||
+            current->IsClosureCall() ||
+            (current->IsPolymorphicInstanceCall() &&
+             !current->AsPolymorphicInstanceCall()->HasRecognizedTarget())) {
           ++call_site_count_;
         }
       }
     }
   }
 
   intptr_t call_site_count() const { return call_site_count_; }
   intptr_t instruction_count() const { return instruction_count_; }
 
  private:
   intptr_t call_site_count_;
   intptr_t instruction_count_;
 };
 
 
 // A collection of call sites to consider for inlining.
-class CallSites : public FlowGraphVisitor {
+class CallSites : public ValueObject {
  public:
   explicit CallSites(FlowGraph* flow_graph)
-      : FlowGraphVisitor(flow_graph->postorder()),  // We don't use this order.
-        static_calls_(),
+      : static_calls_(),
         closure_calls_(),
         instance_calls_() { }
 
   const GrowableArray<ClosureCallInstr*>& closure_calls() const {
     return closure_calls_;
   }
 
   struct InstanceCallInfo {
     PolymorphicInstanceCallInstr* call;
     double ratio;
@@ skipping 60 matching lines @@
           0.0 : static_cast<double>(instance_call_counts[i]) / max_count;
       instance_calls_[i + instance_call_start_ix].ratio = ratio;
     }
     for (intptr_t i = 0; i < num_static_calls; ++i) {
       const double ratio = (max_count == 0) ?
           0.0 : static_cast<double>(static_call_counts[i]) / max_count;
       static_calls_[i + static_call_start_ix].ratio = ratio;
     }
   }
 
-  void FindCallSites(FlowGraph* graph) {
+  void FindCallSites(FlowGraph* graph, intptr_t depth) {
     ASSERT(graph != NULL);
+    // If depth is less than the threshold recursively add call sites.
+    if (depth > FLAG_inlining_depth_threshold) return;
+
+    // Recognized methods are not treated as normal calls. They don't have
+    // calls in themselves, so we keep adding those even when at the threshold.
+    const bool only_recognized_methods =
+        (depth == FLAG_inlining_depth_threshold);
 
     const intptr_t instance_call_start_ix = instance_calls_.length();
     const intptr_t static_call_start_ix = static_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);
+        Instruction* current = it.Current();
+        if (only_recognized_methods) {
+          PolymorphicInstanceCallInstr* instance_call =
+              current->AsPolymorphicInstanceCall();
+          if ((instance_call != NULL) && instance_call->HasRecognizedTarget()) {
+            instance_calls_.Add(InstanceCallInfo(instance_call));
+          }
+          continue;
+        }
+        // Collect all call sites (!only_recognized_methods).
+        ClosureCallInstr* closure_call = current->AsClosureCall();
+        if (closure_call != NULL) {
+          closure_calls_.Add(closure_call);
+          continue;
+        }
+        StaticCallInstr* static_call = current->AsStaticCall();
+        if (static_call != NULL) {
+          if (static_call->function().IsInlineable()) {
+            static_calls_.Add(StaticCallInfo(static_call));
+          }
+          continue;
+        }
+        PolymorphicInstanceCallInstr* instance_call =
+            current->AsPolymorphicInstanceCall();
+        if (instance_call != NULL) {
+          instance_calls_.Add(InstanceCallInfo(instance_call));
+          continue;
+        }
       }
     }
     ComputeCallSiteRatio(static_call_start_ix, instance_call_start_ix);
   }
 
-  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;
-    static_calls_.Add(StaticCallInfo(call));
-  }
-
  private:
   GrowableArray<StaticCallInfo> static_calls_;
   GrowableArray<ClosureCallInstr*> closure_calls_;
   GrowableArray<InstanceCallInfo> instance_calls_;
 
   DISALLOW_COPY_AND_ASSIGN(CallSites);
 };
 
 
 struct InlinedCallData {
@@ skipping 75 matching lines @@
     if ((const_arg_count >= FLAG_inlining_constant_arguments_count) &&
         (instr_count <= FLAG_inlining_constant_arguments_size_threshold)) {
       return true;
     }
     if (MethodRecognizer::AlwaysInline(callee)) {
       return true;
     }
     return false;
   }
 
-  // TODO(srdjan): Handle large 'skip_static_call_deopt_ids'. Currently
-  // max. size observed is 11 (dart2js).
   void InlineCalls() {
     // If inlining depth is less then one abort.
     if (FLAG_inlining_depth_threshold < 1) return;
     if (caller_graph_->parsed_function().function().deoptimization_counter() >=
         FLAG_deoptimization_counter_inlining_threshold) {
       return;
     }
     // Create two call site collections to swap between.
     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_);
+    collected_call_sites_->FindCallSites(caller_graph_, inlining_depth_);
     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_;
       inlining_call_sites_ = call_sites_temp;
       collected_call_sites_->Clear();
       // Inline call sites at the current depth.
       InlineStaticCalls();
@@ skipping 59 matching lines @@
 
     // Abort if this is a recursive occurrence.
     Definition* call = call_data->call;
     if (!FLAG_inline_recursive && IsCallRecursive(function, call)) {
       function.set_is_inlinable(false);
       TRACE_INLINING(OS::Print("     Bailout: recursive function\n"));
       return false;
     }
 
     // Abort if the callee has an intrinsic translation.
-    if (Intrinsifier::CanIntrinsify(function)) {
+    if (Intrinsifier::CanIntrinsify(function) &&
+        !function.is_optimizable()) {
       function.set_is_inlinable(false);
       TRACE_INLINING(OS::Print("     Bailout: can intrinsify\n"));
       return false;
     }
 
     Isolate* isolate = Isolate::Current();
     // Save and clear deopt id.
     const intptr_t prev_deopt_id = isolate->deopt_id();
     isolate->set_deopt_id(0);
     // Install bailout jump.
@@ skipping 122 matching lines @@
         TRACE_INLINING(OS::Print("     Bailout: heuristics with "
                                  "code size:  %" Pd ", "
                                  "call sites: %" Pd ", "
                                  "const args: %" Pd "\n",
                                  size,
                                  call_site_count,
                                  constants_count));
         return false;
       }
 
-      // If depth is less or equal to threshold recursively add call sites.
-      if (inlining_depth_ < FLAG_inlining_depth_threshold) {
-        collected_call_sites_->FindCallSites(callee_graph);
-      }
+      collected_call_sites_->FindCallSites(callee_graph, inlining_depth_);
 
       // Add the function to the cache.
       if (!in_cache) function_cache_.Add(parsed_function);
 
       // Build succeeded so we restore the bailout jump.
       inlined_ = true;
       inlined_size_ += size;
       isolate->set_long_jump_base(base);
       isolate->set_deopt_id(prev_deopt_id);
 
@@ skipping 775 matching lines @@
         OS::Print("After Inlining of %s\n", flow_graph_->
                   parsed_function().function().ToFullyQualifiedCString());
         FlowGraphPrinter printer(*flow_graph_);
         printer.PrintBlocks();
       }
     }
   }
 }
 
 }  // namespace dart