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

runtime/vm/flow_graph_compiler.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/globals.h"  // Needed here to get TARGET_ARCH_XXX.
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
@@ skipping 1179 matching lines @@
       break;
     default:
       UNIMPLEMENTED();
   }
 }
 
 
 void FlowGraphCompiler::GenerateStaticCall(intptr_t deopt_id,
                                            TokenPosition token_pos,
                                            const Function& function,
-                                           intptr_t argument_count,
-                                           const Array& argument_names,
+                                           ArgumentsInfo args_info,
                                            LocationSummary* locs,
                                            const ICData& ic_data_in) {
   const ICData& ic_data = ICData::ZoneHandle(ic_data_in.Original());
   const Array& arguments_descriptor =
-      Array::ZoneHandle(ic_data.IsNull() ? ArgumentsDescriptor::New(
-                                               argument_count, argument_names)
-                                         : ic_data.arguments_descriptor());
+      ic_data.IsNull()
+          ? args_info.ToArgumentsDescriptor(zone())
+          : Array::ZoneHandle(zone(), ic_data.arguments_descriptor());
   if (is_optimizing()) {
-    EmitOptimizedStaticCall(function, arguments_descriptor, argument_count,
-                            deopt_id, token_pos, locs);
+    EmitOptimizedStaticCall(function, arguments_descriptor,
+                            args_info.pushed_argc(), deopt_id, token_pos, locs);
   } else {
-    ICData& call_ic_data = ICData::ZoneHandle(ic_data.raw());
+    ICData& call_ic_data = ICData::ZoneHandle(zone(), ic_data.raw());
     if (call_ic_data.IsNull()) {
       const intptr_t kNumArgsChecked = 0;
       call_ic_data =
           GetOrAddStaticCallICData(deopt_id, function, arguments_descriptor,
                                    kNumArgsChecked)
               ->raw();
     }
     AddCurrentDescriptor(RawPcDescriptors::kRewind, deopt_id, token_pos);
-    EmitUnoptimizedStaticCall(argument_count, deopt_id, token_pos, locs,
-                              call_ic_data);
+    EmitUnoptimizedStaticCall(args_info.pushed_argc(), deopt_id, token_pos,
+                              locs, call_ic_data);
   }
 }
 
 
 void FlowGraphCompiler::GenerateNumberTypeCheck(Register kClassIdReg,
                                                 const AbstractType& type,
                                                 Label* is_instance_lbl,
                                                 Label* is_not_instance_lbl) {
   assembler()->Comment("NumberTypeCheck");
   GrowableArray<intptr_t> args;
@@ skipping 602 matching lines @@
   return true;
 }
 
 
 #if !defined(TARGET_ARCH_DBC)
 // DBC emits calls very differently from other architectures due to its
 // interpreted nature.
 void FlowGraphCompiler::EmitPolymorphicInstanceCall(
     const CallTargets& targets,
     const InstanceCallInstr& original_call,
-    intptr_t argument_count,
-    const Array& argument_names,
+    ArgumentsInfo args_info,
     intptr_t deopt_id,
     TokenPosition token_pos,
     LocationSummary* locs,
     bool complete,
     intptr_t total_ic_calls) {
   if (FLAG_polymorphic_with_deopt) {
     Label* deopt =
         AddDeoptStub(deopt_id, ICData::kDeoptPolymorphicInstanceCallTestFail);
     Label ok;
-    EmitTestAndCall(targets, original_call.function_name(), argument_count,
-                    argument_names,
+    EmitTestAndCall(targets, original_call.function_name(), args_info,
                     deopt,  // No cid match.
                     &ok,    // Found cid.
                     deopt_id, token_pos, locs, complete, total_ic_calls);
     assembler()->Bind(&ok);
   } else {
     if (complete) {
       Label ok;
-      EmitTestAndCall(targets, original_call.function_name(), argument_count,
-                      argument_names,
+      EmitTestAndCall(targets, original_call.function_name(), args_info,
                       NULL,  // No cid match.
                       &ok,   // Found cid.
                       deopt_id, token_pos, locs, true, total_ic_calls);
       assembler()->Bind(&ok);
     } else {
       const ICData& unary_checks = ICData::ZoneHandle(
           zone(), original_call.ic_data()->AsUnaryClassChecks());
-      EmitSwitchableInstanceCall(unary_checks, argument_count, deopt_id,
-                                 token_pos, locs);
+      EmitSwitchableInstanceCall(unary_checks, args_info.pushed_argc(),
+                                 deopt_id, token_pos, locs);
     }
   }
 }
 
 
 #define __ assembler()->
 void FlowGraphCompiler::EmitTestAndCall(const CallTargets& targets,
                                         const String& function_name,
-                                        intptr_t argument_count,
-                                        const Array& argument_names,
+                                        ArgumentsInfo args_info,
                                         Label* failed,
                                         Label* match_found,
                                         intptr_t deopt_id,
                                         TokenPosition token_index,
                                         LocationSummary* locs,
                                         bool complete,
                                         intptr_t total_ic_calls) {
   ASSERT(is_optimizing());
 
-  const Array& arguments_descriptor = Array::ZoneHandle(
-      zone(), ArgumentsDescriptor::New(argument_count, argument_names));
-
-  EmitTestAndCallLoadReceiver(argument_count, arguments_descriptor);
+  const Array& arguments_descriptor = args_info.ToArgumentsDescriptor(zone());
+  EmitTestAndCallLoadReceiver(args_info.pushed_argc(), arguments_descriptor);
 
   static const int kNoCase = -1;
   int smi_case = kNoCase;
   int which_case_to_skip = kNoCase;
 
   const int length = targets.length();
   ASSERT(length > 0);
   int non_smi_length = length;
 
   // Find out if one of the classes in one of the cases is the Smi class. We
@@ skipping 18 matching lines @@
     Label after_smi_test;
     EmitTestAndCallSmiBranch(non_smi_length == 0 ? failed : &after_smi_test,
                              /* jump_if_smi= */ false);
 
     // Do not use the code from the function, but let the code be patched so
     // that we can record the outgoing edges to other code.
     const Function& function = *targets[smi_case].target;
     GenerateStaticDartCall(deopt_id, token_index,
                            *StubCode::CallStaticFunction_entry(),
                            RawPcDescriptors::kOther, locs, function);
-    __ Drop(argument_count);
+    __ Drop(args_info.pushed_argc());
     if (match_found != NULL) {
       __ Jump(match_found);
     }
     __ Bind(&after_smi_test);
   } else {
     if (!complete) {
       // Smi is not a valid class.
       EmitTestAndCallSmiBranch(failed, /* jump_if_smi = */ true);
     }
   }
@@ skipping 28 matching lines @@
     if (!complete || !is_last_check) {
       bias = EmitTestAndCallCheckCid(is_last_check ? failed : &next_test,
                                      targets[i], bias);
     }
     // Do not use the code from the function, but let the code be patched so
     // that we can record the outgoing edges to other code.
     const Function& function = *targets[i].target;
     GenerateStaticDartCall(deopt_id, token_index,
                            *StubCode::CallStaticFunction_entry(),
                            RawPcDescriptors::kOther, locs, function);
-    __ Drop(argument_count);
+    __ Drop(args_info.pushed_argc());
     if (!is_last_check || add_megamorphic_call) {
       __ Jump(match_found);
     }
     __ Bind(&next_test);
   }
   if (add_megamorphic_call) {
     int try_index = CatchClauseNode::kInvalidTryIndex;
     EmitMegamorphicInstanceCall(function_name, arguments_descriptor,
-                                argument_count, deopt_id, token_index, locs,
-                                try_index);
+                                args_info.pushed_argc(), deopt_id, token_index,
+                                locs, try_index);
   }
 }
 #undef __
 #endif
 
 #if defined(DEBUG) && !defined(TARGET_ARCH_DBC)
 // TODO(vegorov) re-enable frame state tracking on DBC. It is
 // currently disabled because it relies on LocationSummaries and
 // we don't use them during unoptimized compilation on DBC.
 void FlowGraphCompiler::FrameStateUpdateWith(Instruction* instr) {
@@ skipping 61 matching lines @@
 
 
 void FlowGraphCompiler::FrameStateClear() {
   ASSERT(!is_optimizing());
   frame_state_.TruncateTo(0);
 }
 #endif  // defined(DEBUG) && !defined(TARGET_ARCH_DBC)
 
 
 }  // namespace dart