Pass type argument vector to generic functions (if --reify-generic-functions is

runtime/vm/runtime_entry.cc

 // Copyright (c) 2011, 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/runtime_entry.h"
 
 #include "vm/assembler.h"
 #include "vm/ast.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
@@ skipping 840 matching lines @@
 // there is a getter with the same name.  If so, invoke it.  If the value is
 // a closure, invoke it with the given arguments.  If the value is a
 // non-closure, attempt to invoke "call" on it.
 static bool ResolveCallThroughGetter(const Instance& receiver,
                                      const Class& receiver_class,
                                      const String& target_name,
                                      const Array& arguments_descriptor,
                                      Function* result) {
   // 1. Check if there is a getter with the same name.
   const String& getter_name = String::Handle(Field::GetterName(target_name));
+  const int kTypeArgsLen = 0;
   const int kNumArguments = 1;
   ArgumentsDescriptor args_desc(
-      Array::Handle(ArgumentsDescriptor::New(kNumArguments)));
+      Array::Handle(ArgumentsDescriptor::New(kTypeArgsLen, kNumArguments)));
   const Function& getter =
       Function::Handle(Resolver::ResolveDynamicForReceiverClass(
           receiver_class, getter_name, args_desc));
   if (getter.IsNull() || getter.IsMethodExtractor()) {
     return false;
   }
   const Function& target_function =
       Function::Handle(receiver_class.GetInvocationDispatcher(
           target_name, arguments_descriptor,
           RawFunction::kInvokeFieldDispatcher, FLAG_lazy_dispatchers));
@@ skipping 49 matching lines @@
   ObjectStore* store = Isolate::Current()->object_store();
   const Function& target =
       Function::Handle(result ? store->simple_instance_of_true_function()
                               : store->simple_instance_of_false_function());
   ASSERT(!target.IsNull());
   return target.raw();
 }
 
 
 static RawFunction* InlineCacheMissHandler(
-    const GrowableArray<const Instance*>& args,
+    const GrowableArray<const Instance*>& args,  // Checked arguments only.
     const ICData& ic_data) {
   const Instance& receiver = *args[0];
   ArgumentsDescriptor arguments_descriptor(
       Array::Handle(ic_data.arguments_descriptor()));
   String& function_name = String::Handle(ic_data.target_name());
   ASSERT(function_name.IsSymbol());
 
   Function& target_function = Function::Handle(
       Resolver::ResolveDynamic(receiver, function_name, arguments_descriptor));
 
@@ skipping 193 matching lines @@
   SingleTargetCache& cache = SingleTargetCache::Handle(zone);
   cache ^=
       CodePatcher::GetSwitchableCallDataAt(caller_frame->pc(), caller_code);
   Code& old_target_code = Code::Handle(zone, cache.target());
   Function& old_target = Function::Handle(zone);
   old_target ^= old_target_code.owner();
 
   // We lost the original ICData when we patched to the monomorphic case.
   const String& name = String::Handle(zone, old_target.name());
   ASSERT(!old_target.HasOptionalParameters());
-  const Array& descriptor = Array::Handle(
-      zone, ArgumentsDescriptor::New(old_target.num_fixed_parameters()));
+  ASSERT(!old_target.IsGeneric());
+  const int kTypeArgsLen = 0;
+  const Array& descriptor =
+      Array::Handle(zone, ArgumentsDescriptor::New(
+                              kTypeArgsLen, old_target.num_fixed_parameters()));
   const ICData& ic_data =
       ICData::Handle(zone, ICData::New(caller_function, name, descriptor,
                                        Thread::kNoDeoptId, 1, /* args_tested */
                                        false /* static_call */));
 
   // Maybe add the new target.
   Class& cls = Class::Handle(zone, receiver.clazz());
   ArgumentsDescriptor args_desc(descriptor);
   Function& target_function = Function::Handle(
       zone, Resolver::ResolveDynamicForReceiverClass(cls, name, args_desc));
@@ skipping 75 matching lines @@
       zone, Resolver::ResolveDynamicForReceiverClass(cls, name, args_desc));
   if (target_function.IsNull()) {
     target_function = InlineCacheMissHelper(receiver, descriptor, name);
   }
   if (target_function.IsNull()) {
     ASSERT(!FLAG_lazy_dispatchers);
   } else {
     ic_data.AddReceiverCheck(receiver.GetClassId(), target_function);
   }
 
-  if (!target_function.IsNull() && !target_function.HasOptionalParameters()) {
+  if (!target_function.IsNull() && !target_function.HasOptionalParameters() &&
+      !target_function.IsGeneric()) {
     // Patch to monomorphic call.
     ASSERT(target_function.HasCode());
     const Code& target_code = Code::Handle(zone, target_function.CurrentCode());
     const Smi& expected_cid =
         Smi::Handle(zone, Smi::New(receiver.GetClassId()));
     CodePatcher::PatchSwitchableCallAt(caller_frame->pc(), caller_code,
                                        expected_cid, target_code);
 
     // Return the ICData. The miss stub will jump to continue in the IC call
     // stub.
@@ skipping 37 matching lines @@
   old_expected_cid ^=
       CodePatcher::GetSwitchableCallDataAt(caller_frame->pc(), caller_code);
   const Code& old_target_code = Code::Handle(
       CodePatcher::GetSwitchableCallTargetAt(caller_frame->pc(), caller_code));
   Function& old_target = Function::Handle(zone);
   old_target ^= old_target_code.owner();
 
   // We lost the original ICData when we patched to the monomorphic case.
   const String& name = String::Handle(zone, old_target.name());
   ASSERT(!old_target.HasOptionalParameters());
-  const Array& descriptor = Array::Handle(
-      zone, ArgumentsDescriptor::New(old_target.num_fixed_parameters()));
+  ASSERT(!old_target.IsGeneric());
+  const int kTypeArgsLen = 0;
+  const Array& descriptor =
+      Array::Handle(zone, ArgumentsDescriptor::New(
+                              kTypeArgsLen, old_target.num_fixed_parameters()));
   const ICData& ic_data =
       ICData::Handle(zone, ICData::New(caller_function, name, descriptor,
                                        Thread::kNoDeoptId, 1, /* args_tested */
                                        false /* static_call */));
 
   // Add the first target.
   ic_data.AddReceiverCheck(old_expected_cid.Value(), old_target);
 
   // Maybe add the new target.
   Class& cls = Class::Handle(zone, receiver.clazz());
@@ skipping 88 matching lines @@
   if (target_function.IsNull()) {
     ASSERT(!FLAG_lazy_dispatchers);
     arguments.SetReturn(target_function);
     return;
   }
 
   if (ic_data_or_cache.IsICData()) {
     const ICData& ic_data = ICData::Cast(ic_data_or_cache);
     const intptr_t number_of_checks = ic_data.NumberOfChecks();
 
-    if (number_of_checks == 0 && !target_function.HasOptionalParameters() &&
+    if ((number_of_checks == 0) && !target_function.HasOptionalParameters() &&
+        !target_function.IsGeneric() &&
         !Isolate::Current()->compilation_allowed()) {
       // This call site is unlinked: transition to a monomorphic direct call.
       // Note we cannot do this if the target has optional parameters because
       // the monomorphic direct call does not load the arguments descriptor.
       // We cannot do this if we are still in the middle of precompiling because
       // the monomorphic case hides an live instance selector from the
       // treeshaker.
 
       const Code& target_code =
           Code::Handle(zone, target_function.EnsureHasCode());
@@ skipping 922 matching lines @@
   const intptr_t new_size = 2 * old_size;
   const intptr_t elm_size = old_data.ElementSizeInBytes();
   const TypedData& new_data =
       TypedData::Handle(TypedData::New(cid, new_size, Heap::kOld));
   TypedData::Copy(new_data, 0, old_data, 0, old_size * elm_size);
   typed_data_cell.SetAt(0, new_data);
   arguments.SetReturn(new_data);
 }
 
 }  // namespace dart