Allocation sinking for contexts.

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/block_scheduler.h"
 #include "vm/compiler.h"
 #include "vm/flags.h"
 #include "vm/flow_graph.h"
@@ skipping 33 matching lines @@
 DEFINE_FLAG(int, inlining_constant_arguments_size_threshold, 60,
     "Inline function calls with sufficient constant arguments "
     "and up to the increased threshold on instructions");
 DEFINE_FLAG(int, inlining_hotness, 10,
     "Inline only hotter calls, in percents (0 .. 100); "
     "default 10%: calls above-equal 10% of max-count are inlined.");
 DEFINE_FLAG(bool, inline_recursive, false, "Inline recursive calls.");
 DEFINE_FLAG(int, max_inlined_per_depth, 500,
     "Max. number of inlined calls per depth");
 DEFINE_FLAG(bool, print_inlining_tree, false, "Print inlining tree");
+DEFINE_FLAG(bool, enable_inlining_annotations, false,
+            "Enable inlining annotations");
 
 DECLARE_FLAG(bool, compiler_stats);
 DECLARE_FLAG(bool, enable_type_checks);
 DECLARE_FLAG(int, deoptimization_counter_threshold);
 DECLARE_FLAG(bool, print_flow_graph);
 DECLARE_FLAG(bool, print_flow_graph_optimized);
 DECLARE_FLAG(bool, verify_compiler);
 
 #define TRACE_INLINING(statement)                                              \
   do {                                                                         \
@@ skipping 377 matching lines @@
 
   GrowableArray<CidTarget> inlined_variants_;
   GrowableArray<CidTarget> non_inlined_variants_;
   GrowableArray<BlockEntryInstr*> inlined_entries_;
   InlineExitCollector* exit_collector_;
 
   const Function& caller_function_;
 };
 
 
+static bool HasAnnotation(const Function& function, const char* annotation) {
+  const Class& owner = Class::Handle(function.Owner());
+  const Library& library = Library::Handle(owner.library());
+  const Array& metadata =
+      Array::Cast(Object::Handle(library.GetMetadata(function)));
+
+  if (metadata.Length() > 0) {
+    Object& val = Object::Handle();
+    for (intptr_t i = 0; i < metadata.Length(); i++) {
+      val = metadata.At(i);
+      if (val.IsString() && String::Cast(val).Equals(annotation)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+
 class CallSiteInliner : public ValueObject {
  public:
   explicit CallSiteInliner(FlowGraph* flow_graph)
       : caller_graph_(flow_graph),
         inlined_(false),
         initial_size_(flow_graph->InstructionCount()),
         inlined_size_(0),
         inlining_depth_(1),
         collected_call_sites_(NULL),
         inlining_call_sites_(NULL),
@@ skipping 125 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"));
       PRINT_INLINING_TREE("Deoptimization threshold exceeded",
           &call_data->caller, &function, call_data->call);
       return false;
     }
 
+    if (FLAG_enable_inlining_annotations &&
+        HasAnnotation(function, "NeverInline")) {

[Vyacheslav Egorov (Google), 2014/11/13 13:01:42]

Maybe make a Symbol for this?

[Florian Schneider, 2014/11/13 13:38:53]

I'll make it a constant variable. Symbol is not needed since it is only a const
char* - and used only for comparison.

+      TRACE_INLINING(OS::Print("     Bailout: NeverInline annotation\n"));
+      return false;
+    }
+
     GrowableArray<Value*>* arguments = call_data->arguments;
     const intptr_t constant_arguments = CountConstants(*arguments);
     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));
       PRINT_INLINING_TREE("Early heuristic",
           &call_data->caller, &function, call_data->call);
       return false;
     }
 
     // Abort if this is a recursive occurrence.
     Definition* call = call_data->call;
     if (!FLAG_inline_recursive && IsCallRecursive(unoptimized_code, call)) {
-      function.set_is_inlinable(false);
       TRACE_INLINING(OS::Print("     Bailout: recursive function\n"));
       PRINT_INLINING_TREE("Recursive function",
           &call_data->caller, &function, call_data->call);
       return false;
     }
 
     // Save and clear deopt id.
     const intptr_t prev_deopt_id = isolate()->deopt_id();
     isolate()->set_deopt_id(0);
     // Install bailout jump.
@@ skipping 128 matching lines @@
                                  "code size:  %" Pd ", "
                                  "call sites: %" Pd ", "
                                  "const args: %" Pd "\n",
                                  size,
                                  call_site_count,
                                  constants_count));
         PRINT_INLINING_TREE("Heuristic fail",
             &call_data->caller, &function, call_data->call);
         return false;
       }
+
       if (function.IsInvokeFieldDispatcher() ||
           function.IsNoSuchMethodDispatcher()) {
         // Append call sites to the currently processed list so that dispatcher
         // methods get inlined regardless of the current depth.
         // Need a throttling mechanism for recursive inlining.
         ASSERT(!FLAG_inline_recursive);
         inlining_call_sites_->FindCallSites(callee_graph,
                                             0,
                                             &inlined_info_);
       } else {
@@ skipping 902 matching lines @@
     info.Collect(*flow_graph);
 
     function.set_optimized_instruction_count(
         ClampUint16(info.instruction_count()));
     function.set_optimized_call_site_count(ClampUint16(info.call_site_count()));
   }
 }
 
 
 bool FlowGraphInliner::AlwaysInline(const Function& function) {
+  if (FLAG_enable_inlining_annotations &&
+      HasAnnotation(function, "AlwaysInline")) {

[Vyacheslav Egorov (Google), 2014/11/13 13:01:42]

Maybe make a symbol for this?

[Florian Schneider, 2014/11/13 13:38:53]

Done. Same as above.

+    TRACE_INLINING(OS::Print("AlwaysInline annotation for %s\n",
+                             function.ToCString()));
+    return true;
+  }
+
   if (function.IsImplicitGetterFunction() || function.IsGetterFunction() ||
       function.IsImplicitSetterFunction() || function.IsSetterFunction()) {
     const intptr_t count = function.optimized_instruction_count();
     if ((count != 0) && (count < FLAG_inline_getters_setters_smaller_than)) {
       return true;
     }
   }
   return MethodRecognizer::AlwaysInline(function);
 }
 
@@ skipping 33 matching lines @@
         OS::Print("After Inlining of %s\n", flow_graph_->
                   parsed_function().function().ToFullyQualifiedCString());
         FlowGraphPrinter printer(*flow_graph_);
         printer.PrintBlocks();
       }
     }
   }
 }
 
 }  // namespace dart