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

runtime/vm/aot_optimizer.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/aot_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/branch_optimizer.h"
 #include "vm/cha.h"
 #include "vm/compiler.h"
@@ skipping 95 matching lines @@
     return false;
   }
 
   if (call->function_name().raw() != Symbols::GetRuntimeType().raw()) {
     return false;
   }
 
   // There is only a single function Object.get:runtimeType that can be invoked
   // by this call. Convert dynamic invocation to a static one.
   const Class& cls = Class::Handle(Z, I->object_store()->object_class());
-  const Array& args_desc_array = Array::Handle(
-      Z,
-      ArgumentsDescriptor::New(call->ArgumentCount(), call->argument_names()));
+  const Array& args_desc_array =

[Vyacheslav Egorov (Google), 2017/05/13 22:20:13]

This pattern is repeated - maybe call instruction can have a method:

RawFunction* ...CallInstr::ResolveForRecieverClass(const Class& cls)

[regis, 2017/05/18 21:02:12]

Done.

+      Array::Handle(Z, call->GetArgumentsDescriptor());
   ArgumentsDescriptor args_desc(args_desc_array);
   const Function& function =
       Function::Handle(Z, Resolver::ResolveDynamicForReceiverClass(
                               cls, call->function_name(), args_desc));
   ASSERT(!function.IsNull());
-
+  const intptr_t kTypeArgsLen = 0;
+  ASSERT(call->type_args_len() == kTypeArgsLen);
   ZoneGrowableArray<PushArgumentInstr*>* args =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>(call->ArgumentCount());
   for (intptr_t i = 0; i < call->ArgumentCount(); i++) {
     args->Add(call->PushArgumentAt(i));
   }
   StaticCallInstr* static_call = new (Z) StaticCallInstr(
-      call->token_pos(), Function::ZoneHandle(Z, function.raw()),
+      call->token_pos(), Function::ZoneHandle(Z, function.raw()), kTypeArgsLen,
       call->argument_names(), args, call->deopt_id());
   static_call->set_result_cid(kTypeCid);
   call->ReplaceWith(static_call, current_iterator());
   return true;
 }
 
 
 // Optimize instance calls using cid.  This is called after optimizer
 // converted instance calls to instructions. Any remaining
 // instance calls are either megamorphic calls, cannot be optimized or
@@ skipping 29 matching lines @@
 
 
 bool AotOptimizer::TryCreateICData(InstanceCallInstr* call) {
   ASSERT(call->HasICData());
   if (call->ic_data()->NumberOfUsedChecks() > 0) {
     // This occurs when an instance call has too many checks, will be converted
     // to megamorphic call.
     return false;
   }
   GrowableArray<intptr_t> class_ids(call->ic_data()->NumArgsTested());
-  ASSERT(call->ic_data()->NumArgsTested() <= call->ArgumentCount());
+  const intptr_t receiver_idx = call->FirstParamIndex();
+  ASSERT(call->ic_data()->NumArgsTested() <=
+         call->ArgumentCountWithoutTypeArgs());
   for (intptr_t i = 0; i < call->ic_data()->NumArgsTested(); i++) {
-    class_ids.Add(call->PushArgumentAt(i)->value()->Type()->ToCid());
+    class_ids.Add(
+        call->PushArgumentAt(receiver_idx + i)->value()->Type()->ToCid());
   }
 
   const Token::Kind op_kind = call->token_kind();
   if (FLAG_guess_icdata_cid) {
     if (Token::IsBinaryBitwiseOperator(op_kind)) {
       class_ids[0] = kSmiCid;
       class_ids[1] = kSmiCid;
     }
     if (Token::IsRelationalOperator(op_kind) ||
         Token::IsEqualityOperator(op_kind) ||
@@ skipping 22 matching lines @@
   if (all_cids_known) {
     const Class& receiver_class =
         Class::Handle(Z, isolate()->class_table()->At(class_ids[0]));
     if (!receiver_class.is_finalized()) {
       // Do not eagerly finalize classes. ResolveDynamicForReceiverClass can
       // cause class finalization, since callee's receiver class may not be
       // finalized yet.
       return false;
     }
     const Array& args_desc_array =
-        Array::Handle(Z, ArgumentsDescriptor::New(call->ArgumentCount(),
-                                                  call->argument_names()));
+        Array::Handle(Z, call->GetArgumentsDescriptor());
     ArgumentsDescriptor args_desc(args_desc_array);
     const Function& function = Function::Handle(
         Z, Resolver::ResolveDynamicForReceiverClass(
                receiver_class, call->function_name(), args_desc));
     if (function.IsNull()) {
       return false;
     }
 
     // Create new ICData, do not modify the one attached to the instruction
     // since it is attached to the assembly instruction itself.
     // TODO(srdjan): Prevent modification of ICData object that is
     // referenced in assembly code.
     const ICData& ic_data = ICData::ZoneHandle(
         Z, ICData::NewFrom(*call->ic_data(), class_ids.length()));
     if (class_ids.length() > 1) {
       ic_data.AddCheck(class_ids, function);
     } else {
       ASSERT(class_ids.length() == 1);
       ic_data.AddReceiverCheck(class_ids[0], function);
     }
     call->set_ic_data(&ic_data);
     return true;
   }
 
   if (isolate()->object_store()->unique_dynamic_targets() != Array::null()) {
     // Check if the target is unique.
     Function& target_function = Function::Handle(Z);
     GetUniqueDynamicTarget(isolate(), call->function_name(), &target_function);
-    // Calls with named arguments must be resolved/checked at runtime.
+    // Calls passing named arguments and calls to a function taking named
+    // arguments must be resolved/checked at runtime.
+    // Calls passing a type argument vector and calls to a generic function must
+    // be resolved/checked at runtime.
     if (!target_function.IsNull() &&
         !target_function.HasOptionalNamedParameters() &&
-        target_function.AreValidArgumentCounts(call->ArgumentCount(), 0,
-                                               /* error_message = */ NULL)) {
+        !target_function.IsGeneric() &&
+        target_function.AreValidArgumentCounts(
+            call->type_args_len(), call->ArgumentCountWithoutTypeArgs(),
+            call->argument_names().IsNull() ? 0
+                                            : call->argument_names().Length(),
+            /* error_message = */ NULL)) {
       const Class& cls = Class::Handle(Z, target_function.Owner());
       if (!CHA::IsImplemented(cls) && !CHA::HasSubclasses(cls)) {
         const ICData& ic_data =
             ICData::ZoneHandle(Z, ICData::NewFrom(*call->ic_data(), 1));
         ic_data.AddReceiverCheck(cls.id(), target_function);
         call->set_ic_data(&ic_data);
         if (has_unique_no_such_method_) {
           call->set_has_unique_selector(true);
           // Add redefinition of the receiver to prevent code motion across
           // this call.
@@ skipping 335 matching lines @@
 }
 
 
 // Recognize a.runtimeType == b.runtimeType and fold it into
 // Object._haveSameRuntimeType(a, b).
 // Note: this optimization is not speculative.
 bool AotOptimizer::TryReplaceWithHaveSameRuntimeType(InstanceCallInstr* call) {
   const ICData& ic_data = *call->ic_data();
   ASSERT(ic_data.NumArgsTested() == 2);
 
+  ASSERT(call->type_args_len() == 0);
   ASSERT(call->ArgumentCount() == 2);
   Definition* left = call->ArgumentAt(0);
   Definition* right = call->ArgumentAt(1);
 
   if (IsGetRuntimeType(left) && left->input_use_list()->IsSingleUse() &&
       IsGetRuntimeType(right) && right->input_use_list()->IsSingleUse()) {
     const Class& cls = Class::Handle(Z, I->object_store()->object_class());
     const Function& have_same_runtime_type = Function::ZoneHandle(
         Z,
         cls.LookupStaticFunctionAllowPrivate(Symbols::HaveSameRuntimeType()));
     ASSERT(!have_same_runtime_type.IsNull());
 
     ZoneGrowableArray<PushArgumentInstr*>* args =
         new (Z) ZoneGrowableArray<PushArgumentInstr*>(2);
     PushArgumentInstr* arg =
         new (Z) PushArgumentInstr(new (Z) Value(left->ArgumentAt(0)));
     InsertBefore(call, arg, NULL, FlowGraph::kEffect);
     args->Add(arg);
     arg = new (Z) PushArgumentInstr(new (Z) Value(right->ArgumentAt(0)));
     InsertBefore(call, arg, NULL, FlowGraph::kEffect);
     args->Add(arg);
-    StaticCallInstr* static_call =
-        new (Z) StaticCallInstr(call->token_pos(), have_same_runtime_type,
-                                Object::null_array(),  // argument_names
-                                args, call->deopt_id());
+    const intptr_t kTypeArgsLen = 0;
+    ASSERT(call->type_args_len() == kTypeArgsLen);
+    StaticCallInstr* static_call = new (Z)
+        StaticCallInstr(call->token_pos(), have_same_runtime_type, kTypeArgsLen,
+                        Object::null_array(),  // argument_names
+                        args, call->deopt_id());
     static_call->set_result_cid(kBoolCid);
     ReplaceCall(call, static_call);
     return true;
   }
 
   return false;
 }
 
 
 bool AotOptimizer::TryReplaceWithEqualityOp(InstanceCallInstr* call,
                                             Token::Kind op_kind) {
   const ICData& ic_data = *call->ic_data();
   ASSERT(ic_data.NumArgsTested() == 2);
 
+  ASSERT(call->type_args_len() == 0);
   ASSERT(call->ArgumentCount() == 2);
   Definition* const left = call->ArgumentAt(0);
   Definition* const right = call->ArgumentAt(1);
 
   intptr_t cid = kIllegalCid;
   if (HasOnlyTwoOf(ic_data, kOneByteStringCid)) {
     return TryStringLengthOneEquality(call, op_kind);
   } else if (HasOnlyTwoOf(ic_data, kSmiCid)) {
     InsertBefore(call,
                  new (Z) CheckSmiInstr(new (Z) Value(left), call->deopt_id(),
@@ skipping 62 matching lines @@
   ReplaceCall(call, comp);
   return true;
 }
 
 
 bool AotOptimizer::TryReplaceWithRelationalOp(InstanceCallInstr* call,
                                               Token::Kind op_kind) {
   const ICData& ic_data = *call->ic_data();
   ASSERT(ic_data.NumArgsTested() == 2);
 
+  ASSERT(call->type_args_len() == 0);
   ASSERT(call->ArgumentCount() == 2);
   Definition* left = call->ArgumentAt(0);
   Definition* right = call->ArgumentAt(1);
 
   intptr_t cid = kIllegalCid;
   if (HasOnlyTwoOf(ic_data, kSmiCid)) {
     InsertBefore(call,
                  new (Z) CheckSmiInstr(new (Z) Value(left), call->deopt_id(),
                                        call->token_pos()),
                  call->env(), FlowGraph::kEffect);
@@ skipping 129 matching lines @@
         }
         operands_type = kSmiCid;
       } else {
         return false;
       }
       break;
     default:
       UNREACHABLE();
   }
 
+  ASSERT(call->type_args_len() == 0);
   ASSERT(call->ArgumentCount() == 2);
   Definition* left = call->ArgumentAt(0);
   Definition* right = call->ArgumentAt(1);
   if (operands_type == kDoubleCid) {
     if (!CanUnboxDouble()) {
       return false;
     }
     // Check that either left or right are not a smi.  Result of a
     // binary operation with two smis is a smi not a double, except '/' which
     // returns a double for two smis.
@@ skipping 68 matching lines @@
     BinarySmiOpInstr* bin_op = new (Z) BinarySmiOpInstr(
         op_kind, new (Z) Value(left), new (Z) Value(right), call->deopt_id());
     ReplaceCall(call, bin_op);
   }
   return true;
 }
 
 
 bool AotOptimizer::TryReplaceWithUnaryOp(InstanceCallInstr* call,
                                          Token::Kind op_kind) {
+  ASSERT(call->type_args_len() == 0);
   ASSERT(call->ArgumentCount() == 1);
   Definition* input = call->ArgumentAt(0);
   Definition* unary_op = NULL;
   if (HasOnlyOneSmi(*call->ic_data())) {
     InsertBefore(call,
                  new (Z) CheckSmiInstr(new (Z) Value(input), call->deopt_id(),
                                        call->token_pos()),
                  call->env(), FlowGraph::kEffect);
     unary_op = new (Z)
         UnarySmiOpInstr(op_kind, new (Z) Value(input), call->deopt_id());
@@ skipping 66 matching lines @@
   }
   return true;
 }
 
 
 bool AotOptimizer::InlineFloat32x4BinaryOp(InstanceCallInstr* call,
                                            Token::Kind op_kind) {
   if (!ShouldInlineSimd()) {
     return false;
   }
+  ASSERT(call->type_args_len() == 0);
   ASSERT(call->ArgumentCount() == 2);
   Definition* const left = call->ArgumentAt(0);
   Definition* const right = call->ArgumentAt(1);
   // Type check left and right.
   AddChecksForArgNr(call, left, /* arg_number = */ 0);
   AddChecksForArgNr(call, right, /* arg_number = */ 1);
   // Replace call.
   BinaryFloat32x4OpInstr* float32x4_bin_op = new (Z) BinaryFloat32x4OpInstr(
       op_kind, new (Z) Value(left), new (Z) Value(right), call->deopt_id());
   ReplaceCall(call, float32x4_bin_op);
 
   return true;
 }
 
 
 bool AotOptimizer::InlineInt32x4BinaryOp(InstanceCallInstr* call,
                                          Token::Kind op_kind) {
   if (!ShouldInlineSimd()) {
     return false;
   }
+  ASSERT(call->type_args_len() == 0);
   ASSERT(call->ArgumentCount() == 2);
   Definition* const left = call->ArgumentAt(0);
   Definition* const right = call->ArgumentAt(1);
   // Type check left and right.
   AddChecksForArgNr(call, left, /* arg_number = */ 0);
   AddChecksForArgNr(call, right, /* arg_number = */ 1);
   // Replace call.
   BinaryInt32x4OpInstr* int32x4_bin_op = new (Z) BinaryInt32x4OpInstr(
       op_kind, new (Z) Value(left), new (Z) Value(right), call->deopt_id());
   ReplaceCall(call, int32x4_bin_op);
   return true;
 }
 
 
 bool AotOptimizer::InlineFloat64x2BinaryOp(InstanceCallInstr* call,
                                            Token::Kind op_kind) {
   if (!ShouldInlineSimd()) {
     return false;
   }
+  ASSERT(call->type_args_len() == 0);
   ASSERT(call->ArgumentCount() == 2);
   Definition* const left = call->ArgumentAt(0);
   Definition* const right = call->ArgumentAt(1);
   // Type check left and right.
   AddChecksForArgNr(call, left, /* arg_number = */ 0);
   AddChecksForArgNr(call, right, /* arg_number = */ 1);
   // Replace call.
   BinaryFloat64x2OpInstr* float64x2_bin_op = new (Z) BinaryFloat64x2OpInstr(
       op_kind, new (Z) Value(left), new (Z) Value(right), call->deopt_id());
   ReplaceCall(call, float64x2_bin_op);
@@ skipping 22 matching lines @@
     // inlining in FlowGraphInliner.
     return false;
   }
   return InlineImplicitInstanceGetter(call);
 }
 
 
 void AotOptimizer::ReplaceWithMathCFunction(
     InstanceCallInstr* call,
     MethodRecognizer::Kind recognized_kind) {
+  ASSERT(call->type_args_len() == 0);
   AddReceiverCheck(call);
   ZoneGrowableArray<Value*>* args =
       new (Z) ZoneGrowableArray<Value*>(call->ArgumentCount());
   for (intptr_t i = 0; i < call->ArgumentCount(); i++) {
     args->Add(new (Z) Value(call->ArgumentAt(i)));
   }
   InvokeMathCFunctionInstr* invoke = new (Z) InvokeMathCFunctionInstr(
       args, call->deopt_id(), recognized_kind, call->token_pos());
   ReplaceCall(call, invoke);
 }
@@ skipping 260 matching lines @@
 }
 
 
 // TODO(srdjan): Use ICData to check if always true or false.
 void AotOptimizer::ReplaceWithInstanceOf(InstanceCallInstr* call) {
   ASSERT(Token::IsTypeTestOperator(call->token_kind()));
   Definition* left = call->ArgumentAt(0);
   Definition* instantiator_type_args = NULL;
   Definition* function_type_args = NULL;
   AbstractType& type = AbstractType::ZoneHandle(Z);
+  ASSERT(call->type_args_len() == 0);
   if (call->ArgumentCount() == 2) {
     instantiator_type_args = flow_graph()->constant_null();
     function_type_args = flow_graph()->constant_null();
     ASSERT(call->MatchesCoreName(Symbols::_simpleInstanceOf()));
     type = AbstractType::Cast(call->ArgumentAt(1)->AsConstant()->value()).raw();
   } else {
     instantiator_type_args = call->ArgumentAt(1);
     function_type_args = call->ArgumentAt(2);
     type = AbstractType::Cast(call->ArgumentAt(3)->AsConstant()->value()).raw();
   }
@@ skipping 43 matching lines @@
       args->Add(arg);
 
       const Library& dart_internal =
           Library::Handle(Z, Library::InternalLibrary());
       const String& target_name = Symbols::_classRangeCheck();
       const Function& target = Function::ZoneHandle(
           Z, dart_internal.LookupFunctionAllowPrivate(target_name));
       ASSERT(!target.IsNull());
       ASSERT(target.IsRecognized() && target.always_inline());
 
+      const intptr_t kTypeArgsLen = 0;
       StaticCallInstr* new_call =
-          new (Z) StaticCallInstr(call->token_pos(), target,
+          new (Z) StaticCallInstr(call->token_pos(), target, kTypeArgsLen,
                                   Object::null_array(),  // argument_names
                                   args, call->deopt_id());
       Environment* copy = call->env()->DeepCopy(
           Z, call->env()->Length() - call->ArgumentCount());
       for (intptr_t i = 0; i < args->length(); ++i) {
         copy->PushValue(new (Z) Value((*args)[i]->value()->definition()));
       }
       call->RemoveEnvironment();
       ReplaceCall(call, new_call);
       copy->DeepCopyTo(Z, new_call);
@@ skipping 27 matching lines @@
       call->token_pos(), new (Z) Value(left),
       new (Z) Value(instantiator_type_args), new (Z) Value(function_type_args),
       type, call->deopt_id());
   ReplaceCall(call, instance_of);
 }
 
 
 // TODO(srdjan): Apply optimizations as in ReplaceWithInstanceOf (TestCids).
 void AotOptimizer::ReplaceWithTypeCast(InstanceCallInstr* call) {
   ASSERT(Token::IsTypeCastOperator(call->token_kind()));
+  ASSERT(call->type_args_len() == 0);
   Definition* left = call->ArgumentAt(0);
   Definition* instantiator_type_args = call->ArgumentAt(1);
   Definition* function_type_args = call->ArgumentAt(2);
   const AbstractType& type =
       AbstractType::Cast(call->ArgumentAt(3)->AsConstant()->value());
   ASSERT(!type.IsMalformedOrMalbounded());
 
   if (TypeCheckAsClassEquality(type)) {
     LoadClassIdInstr* left_cid = new (Z) LoadClassIdInstr(new (Z) Value(left));
     InsertBefore(call, left_cid, NULL, FlowGraph::kValue);
@@ skipping 23 matching lines @@
     args->Add(arg);
 
     const Library& dart_internal = Library::Handle(Z, Library::CoreLibrary());
     const String& target_name = Symbols::_classIdEqualsAssert();
     const Function& target = Function::ZoneHandle(
         Z, dart_internal.LookupFunctionAllowPrivate(target_name));
     ASSERT(!target.IsNull());
     ASSERT(target.IsRecognized());
     ASSERT(target.always_inline());
 
+    const intptr_t kTypeArgsLen = 0;
     StaticCallInstr* new_call =
-        new (Z) StaticCallInstr(call->token_pos(), target,
+        new (Z) StaticCallInstr(call->token_pos(), target, kTypeArgsLen,
                                 Object::null_array(),  // argument_names
                                 args, call->deopt_id());
     Environment* copy =
         call->env()->DeepCopy(Z, call->env()->Length() - call->ArgumentCount());
     for (intptr_t i = 0; i < args->length(); ++i) {
       copy->PushValue(new (Z) Value((*args)[i]->value()->definition()));
     }
     call->RemoveEnvironment();
     ReplaceCall(call, new_call);
     copy->DeepCopyTo(Z, new_call);
@@ skipping 41 matching lines @@
       args->Add(arg);
 
       const Library& dart_internal = Library::Handle(Z, Library::CoreLibrary());
       const String& target_name = Symbols::_classRangeAssert();
       const Function& target = Function::ZoneHandle(
           Z, dart_internal.LookupFunctionAllowPrivate(target_name));
       ASSERT(!target.IsNull());
       ASSERT(target.IsRecognized());
       ASSERT(target.always_inline());
 
+      const intptr_t kTypeArgsLen = 0;
       StaticCallInstr* new_call =
-          new (Z) StaticCallInstr(call->token_pos(), target,
+          new (Z) StaticCallInstr(call->token_pos(), target, kTypeArgsLen,
                                   Object::null_array(),  // argument_names
                                   args, call->deopt_id());
       Environment* copy = call->env()->DeepCopy(
           Z, call->env()->Length() - call->ArgumentCount());
       for (intptr_t i = 0; i < args->length(); ++i) {
         copy->PushValue(new (Z) Value((*args)[i]->value()->definition()));
       }
       call->RemoveEnvironment();
       ReplaceCall(call, new_call);
       copy->DeepCopyTo(Z, new_call);
@@ skipping 39 matching lines @@
 bool AotOptimizer::IsAllowedForInlining(intptr_t call_deopt_id) {
   if (!use_speculative_inlining_) return false;
   for (intptr_t i = 0; i < inlining_black_list_->length(); ++i) {
     if ((*inlining_black_list_)[i] == call_deopt_id) return false;
   }
   return true;
 }
 
 
 static bool HasLikelySmiOperand(InstanceCallInstr* instr) {
+  if (instr->type_args_len() > 0) {

[Vyacheslav Egorov (Google), 2017/05/13 22:20:13]

Should not be possible. These are operators, no way to pass type arguments
there.

[regis, 2017/05/18 21:02:12]

What I thought. Replaced by assert.

+    return false;  // TODO(regis): Is it even possible? Replace with assert.
+  }
   // Phis with at least one known smi are // guessed to be likely smi as well.
   for (intptr_t i = 0; i < instr->ArgumentCount(); ++i) {
     PhiInstr* phi = instr->ArgumentAt(i)->AsPhi();
     if (phi != NULL) {
       for (intptr_t j = 0; j < phi->InputCount(); ++j) {
         if (phi->InputAt(j)->Type()->ToCid() == kSmiCid) return true;
       }
     }
   }
   // If all of the inputs are known smis or the result of CheckedSmiOp,
@@ skipping 152 matching lines @@
       break;
   }
 
   // No IC data checks. Try resolve target using the propagated cid.
   const intptr_t receiver_cid =
       instr->PushArgumentAt(0)->value()->Type()->ToCid();
   if (receiver_cid != kDynamicCid) {
     const Class& receiver_class =
         Class::Handle(Z, isolate()->class_table()->At(receiver_cid));
 
-    const Array& args_desc_array =
-        Array::Handle(Z, ArgumentsDescriptor::New(instr->ArgumentCount(),
-                                                  instr->argument_names()));
-    ArgumentsDescriptor args_desc(args_desc_array);
+    ArgumentsDescriptor args_desc(
+        Array::Handle(Z, instr->GetArgumentsDescriptor()));
     Function& function = Function::Handle(
         Z, Resolver::ResolveDynamicForReceiverClass(
                receiver_class, instr->function_name(), args_desc));
     if (!function.IsNull()) {
       CallTargets* targets = new (Z) CallTargets(Z);
       Function& target = Function::ZoneHandle(Z, function.raw());
       targets->Add(new (Z) TargetInfo(receiver_class.id(), receiver_class.id(),
                                       &target, /*count = */ 1));
       PolymorphicInstanceCallInstr* call =
           new (Z) PolymorphicInstanceCallInstr(instr, *targets,
@@ skipping 26 matching lines @@
   if (!receiver_class.IsNull()) {
     GrowableArray<intptr_t> class_ids(6);
     if (thread()->cha()->ConcreteSubclasses(receiver_class, &class_ids)) {
       // First check if all subclasses end up calling the same method.
       // If this is the case we will replace instance call with a direct
       // static call.
       // Otherwise we will try to create ICData that contains all possible
       // targets with appropriate checks.
       Function& single_target = Function::Handle(Z);
       ICData& ic_data = ICData::Handle(Z);
-
       const Array& args_desc_array =
-          Array::Handle(Z, ArgumentsDescriptor::New(instr->ArgumentCount(),
-                                                    instr->argument_names()));
+          Array::Handle(Z, instr->GetArgumentsDescriptor());
       ArgumentsDescriptor args_desc(args_desc_array);
-
       Function& target = Function::Handle(Z);
       Class& cls = Class::Handle(Z);
       for (intptr_t i = 0; i < class_ids.length(); i++) {
         const intptr_t cid = class_ids[i];
         cls = isolate()->class_table()->At(cid);
         target = Resolver::ResolveDynamicForReceiverClass(
             cls, instr->function_name(), args_desc);
 
         if (target.IsNull()) {
           // Can't resolve the target. It might be a noSuchMethod,
@@ skipping 55 matching lines @@
 
         // We have computed that there is only a single target for this call
         // within the whole hierarchy. Replace InstanceCall with StaticCall.
         ZoneGrowableArray<PushArgumentInstr*>* args = new (Z)
             ZoneGrowableArray<PushArgumentInstr*>(instr->ArgumentCount());
         for (intptr_t i = 0; i < instr->ArgumentCount(); i++) {
           args->Add(instr->PushArgumentAt(i));
         }
         StaticCallInstr* call = new (Z) StaticCallInstr(
             instr->token_pos(), Function::ZoneHandle(Z, single_target.raw()),
-            instr->argument_names(), args, instr->deopt_id());
+            instr->type_args_len(), instr->argument_names(), args,
+            instr->deopt_id());
         instr->ReplaceWith(call, current_iterator());
         return;
       } else if ((ic_data.raw() != ICData::null()) &&
                  !ic_data.NumberOfChecksIs(0)) {
         CallTargets* targets = CallTargets::Create(Z, ic_data);
         PolymorphicInstanceCallInstr* call =
             new (Z) PolymorphicInstanceCallInstr(instr, *targets,
                                                  /* with_checks = */ true,
                                                  /* complete = */ true);
         instr->ReplaceWith(call, current_iterator());
@@ skipping 20 matching lines @@
 
 
 void AotOptimizer::VisitPolymorphicInstanceCall(
     PolymorphicInstanceCallInstr* call) {
   if (call->with_checks()) {
     const intptr_t receiver_cid =
         call->PushArgumentAt(0)->value()->Type()->ToCid();
     if (receiver_cid != kDynamicCid) {
       const Class& receiver_class =
           Class::Handle(Z, isolate()->class_table()->At(receiver_cid));
-
-      const Array& args_desc_array = Array::Handle(
-          Z, ArgumentsDescriptor::New(call->ArgumentCount(),
-                                      call->instance_call()->argument_names()));
-      ArgumentsDescriptor args_desc(args_desc_array);
+      ArgumentsDescriptor args_desc(
+          Array::Handle(Z, call->instance_call()->GetArgumentsDescriptor()));
       const Function& function = Function::Handle(
           Z, Resolver::ResolveDynamicForReceiverClass(
                  receiver_class, call->instance_call()->function_name(),
                  args_desc));
       if (!function.IsNull()) {
         call->set_with_checks(false);
       }
     }
   }
 }
@@ skipping 163 matching lines @@
                                   FlowGraph::kEffect);
         current_iterator()->RemoveCurrentFromGraph();
       }
     }
   }
 }
 
 #endif  // DART_PRECOMPILER
 
 }  // namespace dart