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

runtime/vm/intermediate_language.h

 // 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.
 
 #ifndef RUNTIME_VM_INTERMEDIATE_LANGUAGE_H_
 #define RUNTIME_VM_INTERMEDIATE_LANGUAGE_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/growable_array.h"
@@ skipping 2696 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(CurrentContextInstr);
 };
 
 
 class ClosureCallInstr : public TemplateDefinition<1, Throws> {
  public:
   ClosureCallInstr(Value* function,
                    ClosureCallNode* node,
                    ZoneGrowableArray<PushArgumentInstr*>* arguments)
       : TemplateDefinition(Thread::Current()->GetNextDeoptId()),
+        type_args_len_(node->arguments()->type_args_len()),
         argument_names_(node->arguments()->names()),
         token_pos_(node->token_pos()),
         arguments_(arguments) {
     SetInputAt(0, function);
   }
 
   ClosureCallInstr(Value* function,
                    ZoneGrowableArray<PushArgumentInstr*>* arguments,
+                   intptr_t type_args_len,
                    const Array& argument_names,
                    TokenPosition token_pos)
       : TemplateDefinition(Thread::Current()->GetNextDeoptId()),
+        type_args_len_(type_args_len),
         argument_names_(argument_names),
         token_pos_(token_pos),
         arguments_(arguments) {
     SetInputAt(0, function);
   }
 
   DECLARE_INSTRUCTION(ClosureCall)
 
+  intptr_t type_args_len() const { return type_args_len_; }
   const Array& argument_names() const { return argument_names_; }
   virtual TokenPosition token_pos() const { return token_pos_; }
 
+  // ArgumentCount() includes the type argument vector if any.
   virtual intptr_t ArgumentCount() const { return arguments_->length(); }
   virtual PushArgumentInstr* PushArgumentAt(intptr_t index) const {
     return (*arguments_)[index];
   }
 
   // TODO(kmillikin): implement exact call counts for closure calls.
   virtual intptr_t CallCount() const { return 1; }
 
   virtual bool ComputeCanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::All(); }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
+  intptr_t type_args_len_;

[Vyacheslav Egorov (Google), 2017/05/04 12:12:23]

I suggest the following refactoring of call instructions:

Introduce a common super class and move everything related to arguments to this
super class:

template<intptr_t kInputCount>
class TemplateDartCall : public TemplateDefinition<kInputCount, Throws> {
 public:
  virtual intptr_t ArgumentCount() const { return arguments_->length(); }
  virtual PushArgumentInstr* PushArgumentAt(intptr_t index) const {
    return (*arguments_)[index];
  }

  intptr_t type_args_len() const { return type_args_len_; }
  const Array& argument_names() const { return argument_names_; }

 private:
   intptr_t type_args_len;
   ZoneGrowableArray<PushArgumentInstr*>* arguments_;
   const Array& argument_names; 
};

Additionally this common super class can have a helper method for repetitive
code patterns, e.g. just like Zach suggested it certainly needs a method like
this:

  const Array& GetArgumentDescriptor() const;

[regis, 2017/05/09 18:31:23]

Done.

   const Array& argument_names_;
   TokenPosition token_pos_;
   ZoneGrowableArray<PushArgumentInstr*>* arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(ClosureCallInstr);
 };
 
 
 class InstanceCallInstr : public TemplateDefinition<0, Throws> {
  public:
   InstanceCallInstr(TokenPosition token_pos,
                     const String& function_name,
                     Token::Kind token_kind,
                     ZoneGrowableArray<PushArgumentInstr*>* arguments,
+                    intptr_t type_args_len,
                     const Array& argument_names,
                     intptr_t checked_argument_count,
                     const ZoneGrowableArray<const ICData*>& ic_data_array)
       : TemplateDefinition(Thread::Current()->GetNextDeoptId()),
         ic_data_(NULL),
         token_pos_(token_pos),
         function_name_(function_name),
         token_kind_(token_kind),
         arguments_(arguments),
+        type_args_len_(type_args_len),
         argument_names_(argument_names),
         checked_argument_count_(checked_argument_count),
         has_unique_selector_(false) {
     ic_data_ = GetICData(ic_data_array);
     ASSERT(function_name.IsNotTemporaryScopedHandle());
     ASSERT(!arguments->is_empty());
     ASSERT(argument_names.IsZoneHandle() || argument_names.InVMHeap());
     ASSERT(Token::IsBinaryOperator(token_kind) ||
            Token::IsEqualityOperator(token_kind) ||
            Token::IsRelationalOperator(token_kind) ||
            Token::IsUnaryOperator(token_kind) ||
            Token::IsIndexOperator(token_kind) ||
            Token::IsTypeTestOperator(token_kind) ||
            Token::IsTypeCastOperator(token_kind) || token_kind == Token::kGET ||
            token_kind == Token::kSET || token_kind == Token::kILLEGAL);
   }
 
   DECLARE_INSTRUCTION(InstanceCall)
 
   const ICData* ic_data() const { return ic_data_; }
   bool HasICData() const { return (ic_data() != NULL) && !ic_data()->IsNull(); }
 
   // ICData can be replaced by optimizer.
   void set_ic_data(const ICData* value) { ic_data_ = value; }
 
   virtual TokenPosition token_pos() const { return token_pos_; }
   const String& function_name() const { return function_name_; }
   Token::Kind token_kind() const { return token_kind_; }
+  // ArgumentCount() includes the type argument vector if any.
   virtual intptr_t ArgumentCount() const { return arguments_->length(); }
   virtual PushArgumentInstr* PushArgumentAt(intptr_t index) const {
     return (*arguments_)[index];
   }
+  intptr_t type_args_len() const { return type_args_len_; }
   const Array& argument_names() const { return argument_names_; }
   intptr_t checked_argument_count() const { return checked_argument_count_; }
 
   bool has_unique_selector() const { return has_unique_selector_; }
   void set_has_unique_selector(bool b) { has_unique_selector_ = b; }
 
   virtual bool ComputeCanDeoptimize() const { return true; }
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
@@ skipping 12 matching lines @@
  protected:
   friend class JitOptimizer;
   void set_ic_data(ICData* value) { ic_data_ = value; }
 
  private:
   const ICData* ic_data_;
   const TokenPosition token_pos_;
   const String& function_name_;
   const Token::Kind token_kind_;  // Binary op, unary op, kGET or kILLEGAL.
   ZoneGrowableArray<PushArgumentInstr*>* const arguments_;
+  intptr_t type_args_len_;
   const Array& argument_names_;
   const intptr_t checked_argument_count_;
   bool has_unique_selector_;
 
   DISALLOW_COPY_AND_ASSIGN(InstanceCallInstr);
 };
 
 
 class PolymorphicInstanceCallInstr : public TemplateDefinition<0, Throws> {
  public:
@@ skipping 31 matching lines @@
   bool HasOnlyDispatcherOrImplicitAccessorTargets() const;
 
   const CallTargets& targets() const { return targets_; }
   intptr_t NumberOfChecks() const { return targets_.length(); }
 
   bool IsSureToCallSingleRecognizedTarget() const;
 
   virtual intptr_t CallCount() const;
 
   // If this polymophic call site was created to cover the remaining cids after
-  // inlinng then we need to keep track of the total number of calls including
-  // the ones that wer inlined. This is different from the CallCount above:  Eg
-  // if there  were 100 calls originally, distributed across three class-ids in
+  // inlining then we need to keep track of the total number of calls including
+  // the ones that we inlined. This is different from the CallCount above:  Eg
+  // if there were 100 calls originally, distributed across three class-ids in
   // the ratio 50, 40, 7, 3.  The first two were inlined, so now we have only
   // 10 calls in the CallCount above, but the heuristics need to know that the
   // last two cids cover 7% and 3% of the calls, not 70% and 30%.
   intptr_t total_call_count() { return total_call_count_; }
 
   void set_total_call_count(intptr_t count) { total_call_count_ = count; }
 
   DECLARE_INSTRUCTION(PolymorphicInstanceCall)
 
   virtual bool ComputeCanDeoptimize() const { return true; }
@@ skipping 310 matching lines @@
   const intptr_t if_false_;
 
   DISALLOW_COPY_AND_ASSIGN(IfThenElseInstr);
 };
 
 
 class StaticCallInstr : public TemplateDefinition<0, Throws> {
  public:
   StaticCallInstr(TokenPosition token_pos,
                   const Function& function,
+                  intptr_t type_args_len,
                   const Array& argument_names,
                   ZoneGrowableArray<PushArgumentInstr*>* arguments,
                   const ZoneGrowableArray<const ICData*>& ic_data_array)
       : TemplateDefinition(Thread::Current()->GetNextDeoptId()),
         ic_data_(NULL),
         token_pos_(token_pos),
         function_(function),
+        type_args_len_(type_args_len),
         argument_names_(argument_names),
         arguments_(arguments),
         result_cid_(kDynamicCid),
         is_known_list_constructor_(false),
         identity_(AliasIdentity::Unknown()) {
     ic_data_ = GetICData(ic_data_array);
     ASSERT(function.IsZoneHandle());
     ASSERT(!function.IsNull());
     ASSERT(argument_names.IsZoneHandle() || argument_names.InVMHeap());
   }
 
   StaticCallInstr(TokenPosition token_pos,
                   const Function& function,
+                  intptr_t type_args_len,
                   const Array& argument_names,
                   ZoneGrowableArray<PushArgumentInstr*>* arguments,
                   intptr_t deopt_id)
       : TemplateDefinition(deopt_id),
         ic_data_(NULL),
         token_pos_(token_pos),
         function_(function),
+        type_args_len_(type_args_len),
         argument_names_(argument_names),
         arguments_(arguments),
         result_cid_(kDynamicCid),
         is_known_list_constructor_(false),
         identity_(AliasIdentity::Unknown()) {
     ASSERT(function.IsZoneHandle());
     ASSERT(!function.IsNull());
     ASSERT(argument_names.IsZoneHandle() || argument_names.InVMHeap());
   }
 
   // ICData for static calls carries call count.
   const ICData* ic_data() const { return ic_data_; }
   bool HasICData() const { return (ic_data() != NULL) && !ic_data()->IsNull(); }
 
   void set_ic_data(const ICData* value) { ic_data_ = value; }
 
   DECLARE_INSTRUCTION(StaticCall)
   virtual CompileType ComputeType() const;
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   // Accessors forwarded to the AST node.
   const Function& function() const { return function_; }
+  intptr_t type_args_len() const { return type_args_len_; }
   const Array& argument_names() const { return argument_names_; }
   virtual TokenPosition token_pos() const { return token_pos_; }
 
+  // ArgumentCount() includes the type argument vector if any.
   virtual intptr_t ArgumentCount() const { return arguments_->length(); }
   virtual PushArgumentInstr* PushArgumentAt(intptr_t index) const {
     return (*arguments_)[index];
   }
 
   virtual intptr_t CallCount() const {
     return ic_data() == NULL ? 0 : ic_data()->AggregateCount();
   }
 
   virtual bool ComputeCanDeoptimize() const { return true; }
@@ skipping 17 matching lines @@
 
   virtual AliasIdentity Identity() const { return identity_; }
   virtual void SetIdentity(AliasIdentity identity) { identity_ = identity; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const ICData* ic_data_;
   const TokenPosition token_pos_;
   const Function& function_;
+  intptr_t type_args_len_;
   const Array& argument_names_;
   ZoneGrowableArray<PushArgumentInstr*>* arguments_;
   intptr_t result_cid_;  // For some library functions we know the result.
 
   // 'True' for recognized list constructors.
   bool is_known_list_constructor_;
 
   AliasIdentity identity_;
 
   DISALLOW_COPY_AND_ASSIGN(StaticCallInstr);
@@ skipping 3404 matching lines @@
 };
 
 
 class CheckedSmiOpInstr : public TemplateDefinition<2, Throws> {
  public:
   CheckedSmiOpInstr(Token::Kind op_kind,
                     Value* left,
                     Value* right,
                     InstanceCallInstr* call)
       : TemplateDefinition(call->deopt_id()), call_(call), op_kind_(op_kind) {
+    ASSERT(call->type_args_len() == 0);
     SetInputAt(0, left);
     SetInputAt(1, right);
   }
 
   InstanceCallInstr* call() const { return call_; }
   Token::Kind op_kind() const { return op_kind_; }
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
@@ skipping 15 matching lines @@
 
 class CheckedSmiComparisonInstr : public TemplateComparison<2, Throws> {
  public:
   CheckedSmiComparisonInstr(Token::Kind op_kind,
                             Value* left,
                             Value* right,
                             InstanceCallInstr* call)
       : TemplateComparison(call->token_pos(), op_kind, call->deopt_id()),
         call_(call),
         is_negated_(false) {
+    ASSERT(call->type_args_len() == 0);
     SetInputAt(0, left);
     SetInputAt(1, right);
   }
 
   InstanceCallInstr* call() const { return call_; }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
@@ skipping 1331 matching lines @@
   LocationSummary* Name::MakeLocationSummary(Zone* zone, bool opt) const {     \
     UNIMPLEMENTED();                                                           \
     return NULL;                                                               \
   }                                                                            \
   void Name::EmitNativeCode(FlowGraphCompiler* compiler) { UNIMPLEMENTED(); }
 
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_INTERMEDIATE_LANGUAGE_H_