VM: Inlining of small constructors/factories, optimizations on inlined function bodies

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"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/flow_graph_optimizer.h"
+#include "vm/flow_graph_type_propagator.h"
 #include "vm/il_printer.h"
 #include "vm/intrinsifier.h"
 #include "vm/longjump.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/timer.h"
 
 namespace dart {
 
 DEFINE_FLAG(int, deoptimization_counter_inlining_threshold, 12,
@@ skipping 745 matching lines @@
       {
         CSTAT_TIMER_SCOPE(thread(), graphinliner_ssa_timer);
         // Compute SSA on the callee graph, catching bailouts.
         callee_graph->ComputeSSA(caller_graph_->max_virtual_register_number(),
                                  param_stubs);
         DEBUG_ASSERT(callee_graph->VerifyUseLists());
       }
 
       {
         CSTAT_TIMER_SCOPE(thread(), graphinliner_opt_timer);
-        // TODO(zerny): Do more optimization passes on the callee graph.
-        FlowGraphOptimizer optimizer(callee_graph);
+        // TODO(fschneider): Improve suppression of speculative inlining.
+        // Deopt-ids overlap between caller and callee.
+        FlowGraphOptimizer optimizer(callee_graph,
+                                     inliner_->use_speculative_inlining_,
+                                     inliner_->inlining_black_list_);
         if (Compiler::always_optimize()) {
           optimizer.PopulateWithICData();
+
+          optimizer.ApplyClassIds();
+          DEBUG_ASSERT(callee_graph->VerifyUseLists());
+
+          FlowGraphTypePropagator::Propagate(callee_graph);
+          DEBUG_ASSERT(callee_graph->VerifyUseLists());
         }
         optimizer.ApplyICData();
         DEBUG_ASSERT(callee_graph->VerifyUseLists());
 
         // Optimize (a << b) & c patterns, merge instructions. Must occur before
         // 'SelectRepresentations' which inserts conversion nodes.
         optimizer.TryOptimizePatterns();
         DEBUG_ASSERT(callee_graph->VerifyUseLists());
       }
 
@@ skipping 669 matching lines @@
     Value* input = second->InputAt(i);
     input->definition()->AddInputUse(input);
   }
   first->LinkTo(second);
   return second;
 }
 
 
 bool PolymorphicInliner::TryInlineRecognizedMethod(intptr_t receiver_cid,
                                                    const Function& target) {
-  FlowGraphOptimizer optimizer(owner_->caller_graph());
+  FlowGraphOptimizer optimizer(owner_->caller_graph(),
+                               false,  // Speculative inlining not applicable.
+                               NULL);
   TargetEntryInstr* entry;
   Definition* last;
   // Replace the receiver argument with a redefinition to prevent code from
   // the inlined body from being hoisted above the inlined entry.
   GrowableArray<Definition*> arguments(call_->ArgumentCount());
   Definition* receiver = call_->ArgumentAt(0);
     RedefinitionInstr* redefinition =
         new(Z) RedefinitionInstr(new(Z) Value(receiver));
     redefinition->set_ssa_temp_index(
         owner_->caller_graph()->alloc_ssa_temp_index());
@@ skipping 285 matching lines @@
 
 static bool ShouldTraceInlining(FlowGraph* flow_graph) {
   const Function& top = flow_graph->parsed_function().function();
   return FLAG_trace_inlining && FlowGraphPrinter::ShouldPrint(top);
 }
 
 
 FlowGraphInliner::FlowGraphInliner(
     FlowGraph* flow_graph,
     GrowableArray<const Function*>* inline_id_to_function,
-    GrowableArray<intptr_t>* caller_inline_id)
+    GrowableArray<intptr_t>* caller_inline_id,
+    bool use_speculative_inlining,
+    GrowableArray<intptr_t>* inlining_black_list)
     : flow_graph_(flow_graph),
       inline_id_to_function_(inline_id_to_function),
       caller_inline_id_(caller_inline_id),
-      trace_inlining_(ShouldTraceInlining(flow_graph)) {
+      trace_inlining_(ShouldTraceInlining(flow_graph)),
+      use_speculative_inlining_(use_speculative_inlining),
+      inlining_black_list_(inlining_black_list) {
+  ASSERT(!use_speculative_inlining || (inlining_black_list != NULL));
 }
 
 
 void FlowGraphInliner::CollectGraphInfo(FlowGraph* flow_graph, bool force) {
   const Function& function = flow_graph->function();
   if (force || (function.optimized_instruction_count() == 0)) {
     GraphInfoCollector info;
     info.Collect(*flow_graph);
 
     function.set_optimized_instruction_count(
@@ skipping 39 matching lines @@
   const char* kAlwaysInlineAnnotation = "AlwaysInline";
   if (FLAG_enable_inlining_annotations &&
       HasAnnotation(function, kAlwaysInlineAnnotation)) {
     TRACE_INLINING(THR_Print("AlwaysInline annotation for %s\n",
                              function.ToCString()));
     return true;
   }
 
   if (function.IsImplicitGetterFunction() || function.IsGetterFunction() ||
       function.IsImplicitSetterFunction() || function.IsSetterFunction() ||
-      IsInlineableOperator(function)) {
+      IsInlineableOperator(function) ||
+      (function.kind() == RawFunction::kConstructor)) {
     const intptr_t count = function.optimized_instruction_count();
     if ((count != 0) && (count < FLAG_inline_getters_setters_smaller_than)) {
       return true;
     }
   }
   return MethodRecognizer::AlwaysInline(function);
 }
 
 
 void FlowGraphInliner::Inline() {
@@ skipping 41 matching lines @@
 intptr_t FlowGraphInliner::NextInlineId(const Function& function,
                                         intptr_t parent_id) {
   const intptr_t id = inline_id_to_function_->length();
   inline_id_to_function_->Add(&function);
   caller_inline_id_->Add(parent_id);
   return id;
 }
 
 
 }  // namespace dart