Always try to inline certain core library functions.

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 352 matching lines @@
         inlined_size_(0),
         inlining_depth_(1),
         collected_call_sites_(NULL),
         inlining_call_sites_(NULL),
         function_cache_(),
         guarded_fields_(guarded_fields) { }
 
   FlowGraph* caller_graph() const { return caller_graph_; }
 
   // Inlining heuristics based on Cooper et al. 2008.
-  bool ShouldWeInline(intptr_t instr_count,
+  bool ShouldWeInline(const Function& callee,
+                      intptr_t instr_count,
                       intptr_t call_site_count,
                       intptr_t const_arg_count) {
     if (inlined_size_ > FLAG_inlining_caller_size_threshold) {
       // Prevent methods becoming humongous and thus slow to compile.
       return false;
     }
     if (instr_count <= FLAG_inlining_size_threshold) {
       return true;
     }
     if (call_site_count <= FLAG_inlining_callee_call_sites_threshold) {
       return true;
     }
     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) {
@@ skipping 55 matching lines @@
     // Abort if this function has deoptimized too much.
     if (function.deoptimization_counter() >=
         FLAG_deoptimization_counter_threshold) {
       function.set_is_inlinable(false);
       TRACE_INLINING(OS::Print("     Bailout: deoptimization threshold\n"));
       return false;
     }
 
     GrowableArray<Value*>* arguments = call_data->arguments;
     const intptr_t constant_arguments = CountConstants(*arguments);
-    if (!ShouldWeInline(function.optimized_instruction_count(),
+    if (!ShouldWeInline(function,
+                        function.optimized_instruction_count(),
                         function.optimized_call_site_count(),
                         constant_arguments)) {
       TRACE_INLINING(OS::Print("     Bailout: early heuristics with "
                                "code size:  %"Pd", "
                                "call sites: %"Pd", "
                                "const args: %"Pd"\n",
                                function.optimized_instruction_count(),
                                function.optimized_call_site_count(),
                                constant_arguments));
       return false;
@@ skipping 125 matching lines @@
       }
       GraphInfoCollector info;
       info.Collect(*callee_graph);
       const intptr_t size = info.instruction_count();
       const intptr_t call_site_count = info.call_site_count();
 
       function.set_optimized_instruction_count(size);
       function.set_optimized_call_site_count(call_site_count);
 
       // Use heuristics do decide if this call should be inlined.
-      if (!ShouldWeInline(size, call_site_count, constants_count)) {
+      if (!ShouldWeInline(function, size, call_site_count, constants_count)) {
         // If size is larger than all thresholds, don't consider it again.
         if ((size > FLAG_inlining_size_threshold) &&
             (call_site_count > FLAG_inlining_callee_call_sites_threshold) &&
             (size > FLAG_inlining_constant_arguments_size_threshold)) {
           function.set_is_inlinable(false);
         }
         isolate->set_long_jump_base(base);
         isolate->set_deopt_id(prev_deopt_id);
         TRACE_INLINING(OS::Print("     Bailout: heuristics with "
                                  "code size:  %"Pd", "
@@ skipping 121 matching lines @@
         ASSERT(call->function().NumImplicitParameters() == 1);
         ASSERT(call->ArgumentCount() <= 2);
         // Arg 0: Instantiator type arguments.
         // Arg 1: Length (optional).
         if ((call->ArgumentCount() == 2) &&
             (!call->PushArgumentAt(1)->value()->BindsToConstant())) {
           // Do not inline since a non-constant argument was passed.
           continue;
         }
       }
-      if ((call_info[call_idx].ratio * 100) < FLAG_inlining_hotness) {
-        const Function& target = call->function();
+      const Function& target = call->function();
+      if (!MethodRecognizer::AlwaysInline(target) &&
+          (call_info[call_idx].ratio * 100) < FLAG_inlining_hotness) {
         TRACE_INLINING(OS::Print(
             "  => %s (deopt count %d)\n     Bailout: cold %f\n",
             target.ToCString(),
             target.deoptimization_counter(),
             call_info[call_idx].ratio));
         continue;
       }
       GrowableArray<Value*> arguments(call->ArgumentCount());
       for (int i = 0; i < call->ArgumentCount(); ++i) {
         arguments.Add(call->PushArgumentAt(i)->value());
@@ skipping 40 matching lines @@
     for (intptr_t call_idx = 0; call_idx < call_info.length(); ++call_idx) {
       PolymorphicInstanceCallInstr* call = call_info[call_idx].call;
       if (call->with_checks()) {
         PolymorphicInliner inliner(this, call);
         inliner.Inline();
         continue;
       }
 
       const ICData& ic_data = call->ic_data();
       const Function& target = Function::ZoneHandle(ic_data.GetTargetAt(0));
-      if ((call_info[call_idx].ratio * 100) < FLAG_inlining_hotness) {
+      if (!MethodRecognizer::AlwaysInline(target) &&
+          (call_info[call_idx].ratio * 100) < FLAG_inlining_hotness) {
         TRACE_INLINING(OS::Print(
             "  => %s (deopt count %d)\n     Bailout: cold %f\n",
             target.ToCString(),
             target.deoptimization_counter(),
             call_info[call_idx].ratio));
         continue;
       }
       GrowableArray<Value*> arguments(call->ArgumentCount());
       for (int arg_i = 0; arg_i < call->ArgumentCount(); ++arg_i) {
         arguments.Add(call->PushArgumentAt(arg_i)->value());
@@ skipping 549 matching lines @@
         OS::Print("After Inlining of %s\n", flow_graph_->
                   parsed_function().function().ToFullyQualifiedCString());
         FlowGraphPrinter printer(*flow_graph_);
         printer.PrintBlocks();
       }
     }
   }
 }
 
 }  // namespace dart