Pass InlinedCallData by const-reference in InlineCall() function.

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 584 matching lines @@
       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) {
+  void InlineCall(const InlinedCallData& call_data) {
     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;
+    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;
+    GrowableArray<Value*>* arguments = call_data.arguments;
     for (intptr_t i = 0; i < arguments->length(); ++i) {
-      Definition* stub = (*call_data->parameter_stubs)[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;
+    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();
@@ skipping 57 matching lines @@
           // 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());
       }
       InlinedCallData call_data(call, &arguments);
       if (TryInlining(call->function(), call->argument_names(), &call_data)) {
-        InlineCall(&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());
       }
       InlinedCallData call_data(call, &arguments);
       if (TryInlining(closure->function(),
                       call->argument_names(),
                       &call_data)) {
-        InlineCall(&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) {
@@ skipping 17 matching lines @@
         continue;
       }
       GrowableArray<Value*> arguments(call->ArgumentCount());
       for (int arg_i = 0; arg_i < call->ArgumentCount(); ++arg_i) {
         arguments.Add(call->PushArgumentAt(arg_i)->value());
       }
       InlinedCallData call_data(call, &arguments);
       if (TryInlining(target,
                       call->instance_call()->argument_names(),
                       &call_data)) {
-        InlineCall(&call_data);
+        InlineCall(call_data);
       }
     }
   }
 
   void AdjustForOptionalParameters(const ParsedFunction& parsed_function,
                                    const Array& argument_names,
                                    GrowableArray<Value*>* arguments,
                                    ZoneGrowableArray<Definition*>* param_stubs,
                                    FlowGraph* callee_graph) {
     const Function& function = parsed_function.function();
@@ skipping 141 matching lines @@
         OS::Print("After Inlining of %s\n", flow_graph_->
                   parsed_function().function().ToFullyQualifiedCString());
         FlowGraphPrinter printer(*flow_graph_);
         printer.PrintBlocks();
       }
     }
   }
 }
 
 }  // namespace dart