Refactor the code for making inlining decisions.

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 341 matching lines @@
   }
 
   bool inlined() const { return inlined_; }
 
   double GrowthFactor() const {
     return static_cast<double>(inlined_size_) /
         static_cast<double>(initial_size_);
   }
 
  private:
+  struct InlinedCallData {
+   public:
+    InlinedCallData(Definition* call, GrowableArray<Value*>* arguments)
+        : call(call),
+          arguments(arguments),
+          callee_graph(NULL),
+          parameter_stubs(NULL),
+          exit_collector(NULL) { }
+
+    Definition* call;
+    GrowableArray<Value*>* arguments;
+    FlowGraph* callee_graph;
+    ZoneGrowableArray<Definition*>* parameter_stubs;
+    InlineExitCollector* exit_collector;
+  };
+
   bool TryInlining(const Function& function,
                    const Array& argument_names,
-                   GrowableArray<Value*>* arguments,
-                   Definition* call) {
+                   InlinedCallData* call_data) {
     TRACE_INLINING(OS::Print("  => %s (deopt count %d)\n",
                              function.ToCString(),
                              function.deoptimization_counter()));
 
     // Abort if the inlinable bit on the function is low.
     if (!function.IsInlineable()) {
       TRACE_INLINING(OS::Print("     Bailout: not inlinable\n"));
       return false;
     }
 
     // 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(),
                         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;
     }
 
     // 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)) {
       function.set_is_inlinable(false);
       TRACE_INLINING(OS::Print("     Bailout: can intrinsify\n"));
@@ skipping 23 matching lines @@
       }
 
       // Load IC data for the callee.
       if (function.HasCode()) {
         const Code& unoptimized_code =
             Code::Handle(function.unoptimized_code());
         isolate->set_ic_data_array(unoptimized_code.ExtractTypeFeedbackArray());
       }
 
       // Build the callee graph.
-      InliningContext inlining_context(caller_graph_, call);
-      FlowGraphBuilder builder(*parsed_function, &inlining_context);
+      InlineExitCollector* exit_collector =
+          new InlineExitCollector(caller_graph_, call);
+      FlowGraphBuilder builder(*parsed_function, exit_collector);
       builder.SetInitialBlockId(caller_graph_->max_block_id());
       FlowGraph* callee_graph;
       {
         TimerScope timer(FLAG_compiler_stats,
                          &CompilerStats::graphinliner_build_timer,
                          isolate);
         callee_graph = builder.BuildGraph();
       }
 
       // The parameter stubs are a copy of the actual arguments providing
       // concrete information about the values, for example constant values,
       // without linking between the caller and callee graphs.
       // TODO(zerny): Put more information in the stubs, eg, type information.
-      GrowableArray<Definition*> param_stubs(function.NumParameters());
+      ZoneGrowableArray<Definition*>* param_stubs =
+          new ZoneGrowableArray<Definition*>(function.NumParameters());
 
       // Create a parameter stub for each fixed positional parameter.
       for (intptr_t i = 0; i < function.num_fixed_parameters(); ++i) {
-        param_stubs.Add(CreateParameterStub(i, (*arguments)[i], callee_graph));
+        param_stubs->Add(CreateParameterStub(i, (*arguments)[i], callee_graph));
       }
 
       // If the callee has optional parameters, rebuild the argument and stub
       // arrays so that actual arguments are in one-to-one with the formal
       // parameters.
       if (function.HasOptionalParameters()) {
         TRACE_INLINING(OS::Print("     adjusting for optional parameters\n"));
         AdjustForOptionalParameters(*parsed_function,
                                     argument_names,
                                     arguments,
-                                    &param_stubs,
+                                    param_stubs,
                                     callee_graph);
         // Add a bogus parameter at the end for the (unused) arguments
         // descriptor slot. The parser allocates an extra slot between
         // locals and parameters to hold the arguments descriptor in case it
         // escapes.  We currently bailout if there are argument test
         // expressions or escaping variables so this parameter and the stack
         // slot are not used.
         if (parsed_function->GetSavedArgumentsDescriptorVar() != NULL) {
-          param_stubs.Add(new ParameterInstr(
+          param_stubs->Add(new ParameterInstr(
               function.NumParameters(), callee_graph->graph_entry()));
         }
       }
 
       // After treating optional parameters the actual/formal count must match.
       ASSERT(arguments->length() == function.NumParameters());
-      ASSERT(param_stubs.length() == callee_graph->parameter_count());
+      ASSERT(param_stubs->length() == callee_graph->parameter_count());
 
       {
         TimerScope timer(FLAG_compiler_stats,
                          &CompilerStats::graphinliner_ssa_timer,
                          isolate);
         // Compute SSA on the callee graph, catching bailouts.
         callee_graph->ComputeSSA(caller_graph_->max_virtual_register_number(),
-                                 &param_stubs);
+                                 param_stubs);
         DEBUG_ASSERT(callee_graph->VerifyUseLists());
       }
 
       {
         TimerScope timer(FLAG_compiler_stats,
                          &CompilerStats::graphinliner_opt_timer,
                          isolate);
         // TODO(zerny): Do more optimization passes on the callee graph.
         FlowGraphOptimizer optimizer(callee_graph, guarded_fields_);
         optimizer.ApplyICData();
         DEBUG_ASSERT(callee_graph->VerifyUseLists());
       }
 
       if (FLAG_trace_inlining &&
           (FLAG_print_flow_graph || FLAG_print_flow_graph_optimized)) {
         OS::Print("Callee graph for inlining %s\n",
                   function.ToFullyQualifiedCString());
         FlowGraphPrinter printer(*callee_graph);
         printer.PrintBlocks();
       }
 
       // Collect information about the call site and caller graph.
       // TODO(zerny): Do this after CP and dead code elimination.
       intptr_t constants_count = 0;
-      for (intptr_t i = 0; i < param_stubs.length(); ++i) {
-        if (param_stubs[i]->IsConstant()) ++constants_count;
+      for (intptr_t i = 0; i < param_stubs->length(); ++i) {
+        if ((*param_stubs)[i]->IsConstant()) ++constants_count;
       }
       GraphInfoCollector info;
       info.Collect(*callee_graph);
       const intptr_t size = info.instruction_count();
 
       function.set_optimized_instruction_count(size);
       function.set_optimized_call_site_count(info.call_site_count());
 
       // Use heuristics do decide if this call should be inlined.
       if (!ShouldWeInline(size,
@@ skipping 16 matching lines @@
                                  info.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);
       }
 
-      {
-        TimerScope timer(FLAG_compiler_stats,
-                         &CompilerStats::graphinliner_subst_timer,
-                         isolate);
-
-        // Plug result in the caller graph.
-        inlining_context.ReplaceCall(callee_graph);
-
-        // Replace each stub with the actual argument or the caller's constant.
-        // Nulls denote optional parameters for which no actual was given.
-        for (intptr_t i = 0; i < arguments->length(); ++i) {
-          Definition* stub = param_stubs[i];
-          Value* actual = (*arguments)[i];
-          if (actual != NULL) stub->ReplaceUsesWith(actual->definition());
-        }
-
-        // Remove push arguments of the call.
-        for (intptr_t i = 0; i < call->ArgumentCount(); ++i) {
-          PushArgumentInstr* push = call->PushArgumentAt(i);
-          push->ReplaceUsesWith(push->value()->definition());
-          push->RemoveFromGraph();
-        }
-
-        // Replace remaining constants with uses by constants in the caller's
-        // initial definitions.
-        GrowableArray<Definition*>* defns =
-            callee_graph->graph_entry()->initial_definitions();
-        for (intptr_t i = 0; i < defns->length(); ++i) {
-          ConstantInstr* constant = (*defns)[i]->AsConstant();
-          if ((constant != NULL) && constant->HasUses()) {
-            constant->ReplaceUsesWith(
-                caller_graph_->AddConstantToInitialDefinitions(
-                    constant->value()));
-          }
-        }
-      }
-
-      TRACE_INLINING(OS::Print("     Success\n"));
-
       // Add the function to the cache.
       if (!in_cache) function_cache_.Add(parsed_function);
 
-      // Check that inlining maintains use lists.
-      DEBUG_ASSERT(!FLAG_verify_compiler || caller_graph_->VerifyUseLists());
-
       // 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);
       isolate->set_ic_data_array(prev_ic_data.raw());
+
+      call_data->callee_graph = callee_graph;
+      call_data->parameter_stubs = param_stubs;
+      call_data->exit_collector = exit_collector;
+      TRACE_INLINING(OS::Print("     Success\n"));
       return true;
     } else {
       Error& error = Error::Handle();
       error = isolate->object_store()->sticky_error();
       isolate->object_store()->clear_sticky_error();
       isolate->set_long_jump_base(base);
       isolate->set_deopt_id(prev_deopt_id);
       isolate->set_ic_data_array(prev_ic_data.raw());
       TRACE_INLINING(OS::Print("     Bailout: %s\n", error.ToErrorCString()));
       return false;
     }
   }
 
+  void InlineCall(InlinedCallData* call_data) {

[srdjan, 2013/04/16 16:51:17]

call_data is read only in this function, you could make it const ref, then the
callers become simpler.

[tfarina, 2013/04/23 02:05:27]

I have addressed this here: https://codereview.chromium.org/14341013/

+    TimerScope timer(FLAG_compiler_stats,
+                     &CompilerStats::graphinliner_subst_timer,
+                     Isolate::Current());
+
+    // Plug result in the caller graph.
+    FlowGraph* callee_graph = call_data->callee_graph;
+    InlineExitCollector* exit_collector = call_data->exit_collector;
+    exit_collector->PrepareGraphs(callee_graph);
+    exit_collector->ReplaceCall(callee_graph->graph_entry()->normal_entry());
+
+    // Replace each stub with the actual argument or the caller's constant.
+    // Nulls denote optional parameters for which no actual was given.
+    GrowableArray<Value*>* arguments = call_data->arguments;
+    for (intptr_t i = 0; i < arguments->length(); ++i) {
+      Definition* stub = (*call_data->parameter_stubs)[i];
+      Value* actual = (*arguments)[i];
+      if (actual != NULL) stub->ReplaceUsesWith(actual->definition());
+    }
+
+    // Remove push arguments of the call.
+    Definition* call = call_data->call;
+    for (intptr_t i = 0; i < call->ArgumentCount(); ++i) {
+      PushArgumentInstr* push = call->PushArgumentAt(i);
+      push->ReplaceUsesWith(push->value()->definition());
+      push->RemoveFromGraph();
+    }
+
+    // Replace remaining constants with uses by constants in the caller's
+    // initial definitions.
+    GrowableArray<Definition*>* defns =
+        callee_graph->graph_entry()->initial_definitions();
+    for (intptr_t i = 0; i < defns->length(); ++i) {
+      ConstantInstr* constant = (*defns)[i]->AsConstant();
+      if ((constant != NULL) && constant->HasUses()) {
+        constant->ReplaceUsesWith(
+            caller_graph_->AddConstantToInitialDefinitions(
+                constant->value()));
+      }
+    }
+
+    // Check that inlining maintains use lists.
+    DEBUG_ASSERT(!FLAG_verify_compiler || caller_graph_->VerifyUseLists());
+  }
+
   static intptr_t CountConstants(const GrowableArray<Value*>& arguments) {
     intptr_t count = 0;
     for (intptr_t i = 0; i < arguments.length(); i++) {
       if (arguments[i]->BindsToConstant()) count++;
     }
     return count;
   }
 
   // Parse a function reusing the cache if possible.
   ParsedFunction* GetParsedFunction(const Function& function, bool* in_cache) {
@@ skipping 32 matching lines @@
         if ((call->ArgumentCount() == 2) &&
             (!call->PushArgumentAt(1)->value()->BindsToConstant())) {
           // Do not inline since a non-constant argument was passed.
           continue;
         }
       }
       GrowableArray<Value*> arguments(call->ArgumentCount());
       for (int i = 0; i < call->ArgumentCount(); ++i) {
         arguments.Add(call->PushArgumentAt(i)->value());
       }
-      TryInlining(call->function(), call->argument_names(), &arguments, call);
+      InlinedCallData call_data(call, &arguments);
+      if (TryInlining(call->function(), call->argument_names(), &call_data)) {
+        InlineCall(&call_data);
+      }
     }
   }
 
   void InlineClosureCalls() {
     const GrowableArray<ClosureCallInstr*>& calls =
         inlining_call_sites_->closure_calls();
     TRACE_INLINING(OS::Print("  Closure Calls (%d)\n", calls.length()));
     for (intptr_t i = 0; i < calls.length(); ++i) {
       ClosureCallInstr* call = calls[i];
       // Find the closure of the callee.
       ASSERT(call->ArgumentCount() > 0);
       const CreateClosureInstr* closure =
           call->ArgumentAt(0)->AsCreateClosure();
       if (closure == NULL) {
         TRACE_INLINING(OS::Print("     Bailout: non-closure operator\n"));
         continue;
       }
       GrowableArray<Value*> arguments(call->ArgumentCount());
       for (int i = 0; i < call->ArgumentCount(); ++i) {
         arguments.Add(call->PushArgumentAt(i)->value());
       }
-      TryInlining(closure->function(),
-                  call->argument_names(),
-                  &arguments,
-                  call);
+      InlinedCallData call_data(call, &arguments);
+      if (TryInlining(closure->function(),
+                      call->argument_names(),
+                      &call_data)) {
+        InlineCall(&call_data);
+      }
     }
   }
 
   void InlineInstanceCalls() {
     const GrowableArray<CallSites::InstanceCallInfo>& call_info =
         inlining_call_sites_->instance_calls();
     TRACE_INLINING(OS::Print("  Polymorphic Instance Calls (%d)\n",
                              call_info.length()));
     for (intptr_t i = 0; i < call_info.length(); ++i) {
-      PolymorphicInstanceCallInstr* instr = call_info[i].call;
-      const ICData& ic_data = instr->ic_data();
+      PolymorphicInstanceCallInstr* call = call_info[i].call;
+      const ICData& ic_data = call->ic_data();
       const Function& target = Function::ZoneHandle(ic_data.GetTargetAt(0));
-      if (instr->with_checks()) {
+      if (call->with_checks()) {
         TRACE_INLINING(OS::Print(
             "  => %s (deopt count %d)\n     Bailout: %"Pd" checks\n",
             target.ToCString(),
             target.deoptimization_counter(),
             ic_data.NumberOfChecks()));
         continue;
       }
       if ((call_info[i].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[i].ratio));
         continue;
       }
-      GrowableArray<Value*> arguments(instr->ArgumentCount());
-      for (int arg_i = 0; arg_i < instr->ArgumentCount(); ++arg_i) {
-        arguments.Add(instr->PushArgumentAt(arg_i)->value());
+      GrowableArray<Value*> arguments(call->ArgumentCount());
+      for (int arg_i = 0; arg_i < call->ArgumentCount(); ++arg_i) {
+        arguments.Add(call->PushArgumentAt(arg_i)->value());
       }
-      TryInlining(target,
-                  instr->instance_call()->argument_names(),
-                  &arguments,
-                  instr);
+      InlinedCallData call_data(call, &arguments);
+      if (TryInlining(target,
+                      call->instance_call()->argument_names(),
+                      &call_data)) {
+        InlineCall(&call_data);
+      }
     }
   }
 
   void AdjustForOptionalParameters(const ParsedFunction& parsed_function,
                                    const Array& argument_names,
                                    GrowableArray<Value*>* arguments,
-                                   GrowableArray<Definition*>* param_stubs,
+                                   ZoneGrowableArray<Definition*>* param_stubs,
                                    FlowGraph* callee_graph) {
     const Function& function = parsed_function.function();
     // The language and this code does not support both optional positional
     // and optional named parameters for the same function.
     ASSERT(!function.HasOptionalPositionalParameters() ||
            !function.HasOptionalNamedParameters());
 
     intptr_t arg_count = arguments->length();
     intptr_t param_count = function.NumParameters();
     intptr_t fixed_param_count = function.num_fixed_parameters();
@@ skipping 133 matching lines @@
         OS::Print("After Inlining of %s\n", flow_graph_->
                   parsed_function().function().ToFullyQualifiedCString());
         FlowGraphPrinter printer(*flow_graph_);
         printer.PrintBlocks();
       }
     }
   }
 }
 
 }  // namespace dart