Support inlining of calls where type arguments are passed to generic functions.

runtime/vm/flow_graph.cc

 // Copyright (c) 2012, 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.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 972 matching lines @@
   GraphEntryInstr* entry = graph_entry();
 
   // Initial renaming environment.
   GrowableArray<Definition*> env(variable_count());
 
   // Add global constants to the initial definitions.
   constant_null_ = GetConstant(Object::ZoneHandle());
   constant_dead_ = GetConstant(Symbols::OptimizedOut());
   constant_empty_context_ = GetConstant(Object::empty_context());
 
+  // Check if inlining_parameters include a type argument vector parameter.
+  const intptr_t inlined_type_args_param =
+      (FLAG_reify_generic_functions && (inlining_parameters != NULL) &&
+       function().IsGeneric())
+          ? 1
+          : 0;
+
   // Add parameters to the initial definitions and renaming environment.
   if (inlining_parameters != NULL) {
     // Use known parameters.
-    ASSERT(parameter_count() == inlining_parameters->length());
+    ASSERT(inlined_type_args_param + parameter_count() ==
+           inlining_parameters->length());
     for (intptr_t i = 0; i < parameter_count(); ++i) {
-      Definition* defn = (*inlining_parameters)[i];
+      // If inlined_type_args_param == 1, then (*inlining_parameters)[0]
+      // is the passed-in type args. We do not add it to env[0] but to
+      // env[parameter_count()] below.
+      Definition* defn = (*inlining_parameters)[inlined_type_args_param + i];
       AllocateSSAIndexes(defn);
       AddToInitialDefinitions(defn);
       env.Add(defn);
     }
   } else {
     // Create new parameters.  For functions compiled for OSR, the locals
     // are unknown and so treated like parameters.
     intptr_t count = IsCompiledForOsr() ? variable_count() : parameter_count();
     for (intptr_t i = 0; i < count; ++i) {
       ParameterInstr* param = new (zone()) ParameterInstr(i, entry);
       param->set_ssa_temp_index(alloc_ssa_temp_index());  // New SSA temp.
       AddToInitialDefinitions(param);
       env.Add(param);
     }
   }
 
   // Initialize all locals in the renaming environment  For OSR, the locals have
   // already been handled as parameters.
   if (!IsCompiledForOsr()) {
-    for (intptr_t i = parameter_count(); i < variable_count(); ++i) {
+    intptr_t i = parameter_count();
+    if (FLAG_reify_generic_functions && function().IsGeneric()) {
+      // The first local is the slot holding the copied passed-in type args.
+      // TODO(regis): Do we need the SpecialParameterInstr if the type_args_var
+      // is not needed? Add an assert for now:
+      ASSERT(parsed_function().function_type_arguments() != NULL);
+      Definition* defn;
+      if (inlining_parameters == NULL) {
+        defn = new SpecialParameterInstr(SpecialParameterInstr::kTypeArgs,
+                                         Thread::kNoDeoptId);
+      } else {
+        defn = (*inlining_parameters)[0];
+      }
+      AllocateSSAIndexes(defn);
+      AddToInitialDefinitions(defn);
+      env.Add(defn);
+      ++i;
+    }
+    for (; i < variable_count(); ++i) {
       if (i == CurrentContextEnvIndex()) {
         if (function().IsClosureFunction()) {
-          CurrentContextInstr* context =
-              new CurrentContextInstr(Thread::kNoDeoptId);
+          SpecialParameterInstr* context = new SpecialParameterInstr(
+              SpecialParameterInstr::kContext, Thread::kNoDeoptId);
           context->set_ssa_temp_index(alloc_ssa_temp_index());  // New SSA temp.
           AddToInitialDefinitions(context);
           env.Add(context);
         } else {
           env.Add(constant_empty_context());
         }
       } else {
         env.Add(constant_null());
       }
     }
@@ skipping 1278 matching lines @@
                                                 Representation rep,
                                                 intptr_t cid) {
   ExtractNthOutputInstr* extract =
       new (Z) ExtractNthOutputInstr(new (Z) Value(instr), index, rep, cid);
   instr->ReplaceUsesWith(extract);
   InsertAfter(instr, extract, NULL, FlowGraph::kValue);
 }
 
 
 }  // namespace dart