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

runtime/vm/flow_graph_allocator.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_allocator.h"
 
 #include "vm/bit_vector.h"
 #include "vm/intermediate_language.h"
 #include "vm/il_printer.h"
 #include "vm/flow_graph.h"
@@ skipping 678 matching lines @@
         CompleteRange(tail, Location::kRegister);
       }
       ConvertAllUses(range);
     }
     return;
   }
 #endif
 
   // Save the range end because it may change below.
   intptr_t range_end = range->End();
+  bool is_type_args_param = false;
   if (defn->IsParameter()) {
     ParameterInstr* param = defn->AsParameter();
     // Assert that copied and non-copied parameters are mutually exclusive.
     // This might change in the future and, if so, the index will be wrong.
     ASSERT((flow_graph_.num_copied_params() == 0) ||
            (flow_graph_.num_non_copied_params() == 0));
     intptr_t slot_index = param->index();
+    ASSERT(slot_index >= 0);  // TODO(regis): Can we encounter a type args here?
     ASSERT((param->base_reg() == FPREG) || (param->base_reg() == SPREG));
     if (param->base_reg() == FPREG) {
       // Slot index for the leftmost copied parameter is 0.
       // Slot index for the rightmost fixed parameter is -1.
       slot_index -= flow_graph_.num_non_copied_params();
     }
 
 #if defined(TARGET_ARCH_DBC)
     ASSERT(param->base_reg() == FPREG);
     if (slot_index >= 0) {
       AssignSafepoints(defn, range);
       range->finger()->Initialize(range);
       range->set_assigned_location(Location::RegisterLocation(slot_index));
       SplitInitialDefinitionAt(range, kNormalEntryPos);
       ConvertAllUses(range);
       return;
     }
 #endif  // defined(TARGET_ARCH_DBC)
     range->set_assigned_location(
         Location::StackSlot(slot_index, param->base_reg()));
     range->set_spill_slot(Location::StackSlot(slot_index, param->base_reg()));
 
-  } else if (defn->IsCurrentContext()) {
+  } else if (defn->IsSpecialParameter()) {
+    SpecialParameterInstr* param = defn->AsSpecialParameter();
+    if (param->kind() == SpecialParameterInstr::kContext) {
 #if !defined(TARGET_ARCH_DBC)
-    const Register context_reg = CTX;
+      const Register context_reg = CTX;
 #else
-    const intptr_t context_reg = flow_graph_.num_copied_params();
+      const intptr_t context_reg = flow_graph_.num_copied_params();
 #endif
 
-    AssignSafepoints(defn, range);
-    range->finger()->Initialize(range);
-    range->set_assigned_location(Location::RegisterLocation(context_reg));
-    if (range->End() > kNormalEntryPos) {
-      LiveRange* tail = range->SplitAt(kNormalEntryPos);
-      CompleteRange(tail, Location::kRegister);
+      AssignSafepoints(defn, range);
+      range->finger()->Initialize(range);
+      range->set_assigned_location(Location::RegisterLocation(context_reg));
+      if (range->End() > kNormalEntryPos) {
+        LiveRange* tail = range->SplitAt(kNormalEntryPos);
+        CompleteRange(tail, Location::kRegister);
+      }
+      ConvertAllUses(range);
+      return;
     }
-    ConvertAllUses(range);
-    return;
+    ASSERT(param->kind() == SpecialParameterInstr::kTypeArgs);
+    is_type_args_param = true;
+#if defined(TARGET_ARCH_DBC)
+    UNIMPLEMENTED();
+#endif
+    const intptr_t slot_index = flow_graph_.num_copied_params();
+    range->set_assigned_location(Location::StackSlot(slot_index, FPREG));
+    range->set_spill_slot(Location::StackSlot(slot_index, FPREG));
   } else {
     ConstantInstr* constant = defn->AsConstant();
     ASSERT(constant != NULL);
     range->set_assigned_location(Location::Constant(constant));
     range->set_spill_slot(Location::Constant(constant));
   }
   AssignSafepoints(defn, range);
   range->finger()->Initialize(range);
   UsePosition* use =
       range->finger()->FirstRegisterBeneficialUse(block->start_pos());
   if (use != NULL) {
     LiveRange* tail = SplitBetween(range, block->start_pos(), use->pos());
     // Parameters and constants are tagged, so allocated to CPU registers.
     CompleteRange(tail, Location::kRegister);
   }
   ConvertAllUses(range);
-  if (defn->IsParameter() && (range->spill_slot().stack_index() >= 0)) {
+  if ((defn->IsParameter() || is_type_args_param) &&
+      (range->spill_slot().stack_index() >= 0)) {
     // Parameters above the frame pointer consume spill slots and are marked
     // in stack maps.
     spill_slots_.Add(range_end);
     quad_spill_slots_.Add(false);
     untagged_spill_slots_.Add(false);
     // Note, all incoming parameters are assumed to be tagged.
     MarkAsObjectAtSafepoints(range);
   } else if (defn->IsConstant() && block->IsCatchBlockEntry()) {
     // Constants at catch block entries consume spill slots.
     spill_slots_.Add(range_end);
@@ skipping 2318 matching lines @@
       FlowGraphPrinter printer(flow_graph_, true);
       printer.PrintBlocks();
 #endif
     }
     THR_Print("----------------------------------------------\n");
   }
 }
 
 
 }  // namespace dart