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

runtime/vm/intermediate_language.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/intermediate_language.h"
 
 #include "vm/bit_vector.h"
 #include "vm/bootstrap.h"
 #include "vm/compiler.h"
 #include "vm/constant_propagator.h"
@@ skipping 3248 matching lines @@
   }
 }
 #endif
 
 
 void InstanceCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Zone* zone = compiler->zone();
   const ICData* call_ic_data = NULL;
   if (!FLAG_propagate_ic_data || !compiler->is_optimizing() ||
       (ic_data() == NULL)) {
-    const Array& arguments_descriptor = Array::Handle(
-        zone, ArgumentsDescriptor::New(ArgumentCount(), argument_names()));
+    const Array& arguments_descriptor =
+        Array::Handle(zone, GetArgumentsDescriptor());
     call_ic_data = compiler->GetOrAddInstanceCallICData(
         deopt_id(), function_name(), arguments_descriptor,
         checked_argument_count());
   } else {
     call_ic_data = &ICData::ZoneHandle(zone, ic_data()->raw());
   }
 
 #if !defined(TARGET_ARCH_DBC)
   if (compiler->is_optimizing() && HasICData()) {
     ASSERT(HasICData());
@@ skipping 69 matching lines @@
   }
 #endif  // !defined(TARGET_ARCH_DBC)
 }
 
 
 bool InstanceCallInstr::MatchesCoreName(const String& name) {
   return function_name().raw() == Library::PrivateCoreLibName(name).raw();
 }
 
 
+RawFunction* InstanceCallInstr::ResolveForReceiverClass(const Class& cls) {
+  const Array& args_desc_array = Array::Handle(GetArgumentsDescriptor());
+  ArgumentsDescriptor args_desc(args_desc_array);
+  return Resolver::ResolveDynamicForReceiverClass(cls, function_name(),
+                                                  args_desc);
+}
+
+
 bool CallTargets::HasSingleRecognizedTarget() const {
   if (!HasSingleTarget()) return false;
   return MethodRecognizer::RecognizeKind(FirstTarget()) !=
          MethodRecognizer::kUnknown;
 }
 
 
 bool CallTargets::HasSingleTarget() const {
   ASSERT(length() != 0);
   for (int i = 0; i < length(); i++) {
@@ skipping 45 matching lines @@
 
 intptr_t PolymorphicInstanceCallInstr::CallCount() const {
   return targets().AggregateCallCount();
 }
 
 
 // DBC does not support optimizing compiler and thus doesn't emit
 // PolymorphicInstanceCallInstr.
 #if !defined(TARGET_ARCH_DBC)
 void PolymorphicInstanceCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  ArgumentsInfo args_info(instance_call()->type_args_len(),
+                          instance_call()->ArgumentCount(),
+                          instance_call()->argument_names());
   if (!with_checks()) {
     ASSERT(targets().HasSingleTarget());
     const Function& target = targets().FirstTarget();
     compiler->GenerateStaticCall(deopt_id(), instance_call()->token_pos(),
-                                 target, instance_call()->ArgumentCount(),
-                                 instance_call()->argument_names(), locs(),
-                                 ICData::Handle());
+                                 target, args_info, locs(), ICData::Handle());
     return;
   }
 
   compiler->EmitPolymorphicInstanceCall(
-      targets_, *instance_call(), instance_call()->ArgumentCount(),
-      instance_call()->argument_names(), deopt_id(),
+      targets_, *instance_call(), args_info, deopt_id(),
       instance_call()->token_pos(), locs(), complete(), total_call_count());
 }
 #endif
 
 
 RawType* PolymorphicInstanceCallInstr::ComputeRuntimeType(
     const CallTargets& targets) {
   bool is_string = true;
   bool is_integer = true;
   bool is_double = true;
@@ skipping 95 matching lines @@
 }
 
 
 LocationSummary* StaticCallInstr::MakeLocationSummary(Zone* zone,
                                                       bool optimizing) const {
   return MakeCallSummary(zone);
 }
 
 
 void StaticCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  Zone* zone = compiler->zone();
   const ICData* call_ic_data = NULL;
   if (!FLAG_propagate_ic_data || !compiler->is_optimizing() ||
       (ic_data() == NULL)) {
-    const Array& arguments_descriptor = Array::Handle(
-        ArgumentsDescriptor::New(ArgumentCount(), argument_names()));
+    const Array& arguments_descriptor =
+        Array::Handle(zone, GetArgumentsDescriptor());
     MethodRecognizer::Kind recognized_kind =
         MethodRecognizer::RecognizeKind(function());
     int num_args_checked = 0;
     switch (recognized_kind) {
       case MethodRecognizer::kDoubleFromInteger:
       case MethodRecognizer::kMathMin:
       case MethodRecognizer::kMathMax:
         num_args_checked = 2;
         break;
       default:
         break;
     }
     call_ic_data = compiler->GetOrAddStaticCallICData(
         deopt_id(), function(), arguments_descriptor, num_args_checked);
   } else {
     call_ic_data = &ICData::ZoneHandle(ic_data()->raw());
   }
 
 #if !defined(TARGET_ARCH_DBC)
-  compiler->GenerateStaticCall(deopt_id(), token_pos(), function(),
-                               ArgumentCount(), argument_names(), locs(),
-                               *call_ic_data);
+  ArgumentsInfo args_info(type_args_len(), ArgumentCount(), argument_names());
+  compiler->GenerateStaticCall(deopt_id(), token_pos(), function(), args_info,
+                               locs(), *call_ic_data);
 #else
-  const Array& arguments_descriptor =
-      (ic_data() == NULL) ? Array::Handle(ArgumentsDescriptor::New(
-                                ArgumentCount(), argument_names()))
-                          : Array::Handle(ic_data()->arguments_descriptor());
+  const Array& arguments_descriptor = Array::Handle(
+      zone, (ic_data() == NULL) ? GetArgumentsDescriptor()
+                                : ic_data()->arguments_descriptor());
   const intptr_t argdesc_kidx = __ AddConstant(arguments_descriptor);
 
   compiler->AddCurrentDescriptor(RawPcDescriptors::kRewind, deopt_id(),
                                  token_pos());
   if (compiler->is_optimizing()) {
     __ PushConstant(function());
     __ StaticCall(ArgumentCount(), argdesc_kidx);
     compiler->AddCurrentDescriptor(RawPcDescriptors::kOther, deopt_id(),
                                    token_pos());
     compiler->RecordAfterCall(this, FlowGraphCompiler::kHasResult);
@@ skipping 306 matching lines @@
       return Array::length_offset();
     default:
       UNREACHABLE();
       return -1;
   }
 }
 
 
 const Function& StringInterpolateInstr::CallFunction() const {
   if (function_.IsNull()) {
+    const int kTypeArgsLen = 0;
     const int kNumberOfArguments = 1;
     const Array& kNoArgumentNames = Object::null_array();
     const Class& cls =
         Class::Handle(Library::LookupCoreClass(Symbols::StringBase()));
     ASSERT(!cls.IsNull());
     function_ = Resolver::ResolveStatic(
-        cls, Library::PrivateCoreLibName(Symbols::Interpolate()),
+        cls, Library::PrivateCoreLibName(Symbols::Interpolate()), kTypeArgsLen,
         kNumberOfArguments, kNoArgumentNames);
   }
   ASSERT(!function_.IsNull());
   return function_;
 }
 
 
 // Replace StringInterpolateInstr with a constant string if all inputs are
 // constant of [string, number, boolean, null].
 // Leave the CreateArrayInstr and StoreIndexedInstr in the stream in case
@@ skipping 380 matching lines @@
                      "native function '%s' (%" Pd " arguments) cannot be found",
                      native_name().ToCString(), function().NumParameters());
   }
   set_is_auto_scope(auto_setup_scope);
   set_native_c_function(native_function);
 }
 
 #undef __
 
 }  // namespace dart