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 2690 matching lines @@
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CurrentContextInstr);
 };
 
 
-class ClosureCallInstr : public TemplateDefinition<1, Throws> {
+struct ArgumentsInfo {
+  ArgumentsInfo(intptr_t type_args_len,
+                intptr_t pushed_argc,
+                const Array& argument_names)
+      : type_args_len(type_args_len),
+        pushed_argc(pushed_argc),
+        argument_names(argument_names) {}
+
+  const Array& ToArgumentsDescriptor(Zone* zone) const {

[zra, 2017/05/11 04:14:21]

Why does this not follow the convention of returning a raw pointer?

[regis, 2017/05/11 09:55:11]

No particular reason :-)
Changed.

+    return Array::ZoneHandle(
+        zone, ArgumentsDescriptor::New(
+                  type_args_len, pushed_argc - (type_args_len > 0 ? 1 : 0),
+                  argument_names));
+  }
+
+  intptr_t type_args_len;
+  intptr_t pushed_argc;
+  const Array& argument_names;
+};
+
+
+template <intptr_t kInputCount>
+class TemplateDartCall : public TemplateDefinition<kInputCount, Throws> {
+ public:
+  TemplateDartCall(intptr_t deopt_id,
+                   intptr_t type_args_len,
+                   const Array& argument_names,
+                   ZoneGrowableArray<PushArgumentInstr*>* arguments,
+                   TokenPosition token_pos)
+      : TemplateDefinition<kInputCount, Throws>(deopt_id),
+        type_args_len_(type_args_len),
+        argument_names_(argument_names),
+        arguments_(arguments),
+        token_pos_(token_pos) {
+    ASSERT(argument_names.IsZoneHandle() || argument_names.InVMHeap());
+  }
+
+  virtual intptr_t FirstParamIndex() const {
+    return type_args_len() > 0 ? 1 : 0;
+  }
+  virtual intptr_t ArgumentCountWithoutTypeArgs() const {
+    return arguments_->length() - FirstParamIndex();
+  }
+  // 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 type_args_len() const { return type_args_len_; }
+  virtual const Array& argument_names() const { return argument_names_; }

[zra, 2017/05/11 04:14:21]

ditto

[regis, 2017/05/11 09:55:11]

There is no need to unwrap and rewrap the input here. Note that there are many
locations in the parser and ast where we return handles.

+  virtual TokenPosition token_pos() const { return token_pos_; }
+  virtual const Array& GetArgumentsDescriptor(Zone* zone) const {

[zra, 2017/05/11 04:14:21]

ditto

[regis, 2017/05/11 09:55:11]

Done.

+    return Array::ZoneHandle(
+        zone,
+        ArgumentsDescriptor::New(
+            type_args_len(), ArgumentCountWithoutTypeArgs(), argument_names()));
+  }
+
+ private:
+  intptr_t type_args_len_;
+  const Array& argument_names_;
+  ZoneGrowableArray<PushArgumentInstr*>* arguments_;
+  TokenPosition token_pos_;
+
+  DISALLOW_COPY_AND_ASSIGN(TemplateDartCall);
+};
+
+
+class ClosureCallInstr : public TemplateDartCall<1> {
  public:
   ClosureCallInstr(Value* function,
                    ClosureCallNode* node,
                    ZoneGrowableArray<PushArgumentInstr*>* arguments)
-      : TemplateDefinition(Thread::Current()->GetNextDeoptId()),
-        argument_names_(node->arguments()->names()),
-        token_pos_(node->token_pos()),
-        arguments_(arguments) {
+      : TemplateDartCall(Thread::Current()->GetNextDeoptId(),
+                         node->arguments()->type_args_len(),
+                         node->arguments()->names(),
+                         arguments,
+                         node->token_pos()) {
+    ASSERT(!arguments->is_empty());
     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()),
-        argument_names_(argument_names),
-        token_pos_(token_pos),
-        arguments_(arguments) {
+      : TemplateDartCall(Thread::Current()->GetNextDeoptId(),
+                         type_args_len,
+                         argument_names,
+                         arguments,
+                         token_pos) {
+    ASSERT(!arguments->is_empty());
     SetInputAt(0, function);
   }
 
   DECLARE_INSTRUCTION(ClosureCall)
 
-  const Array& argument_names() const { return argument_names_; }
-  virtual TokenPosition token_pos() const { return token_pos_; }
-
-  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:
-  const Array& argument_names_;
-  TokenPosition token_pos_;
-  ZoneGrowableArray<PushArgumentInstr*>* arguments_;
-
   DISALLOW_COPY_AND_ASSIGN(ClosureCallInstr);
 };
 
 
-class InstanceCallInstr : public TemplateDefinition<0, Throws> {
+class InstanceCallInstr : public TemplateDartCall<0> {
  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()),
+      : TemplateDartCall(Thread::Current()->GetNextDeoptId(),
+                         type_args_len,
+                         argument_names,
+                         arguments,
+                         token_pos),
         ic_data_(NULL),
-        token_pos_(token_pos),
         function_name_(function_name),
         token_kind_(token_kind),
-        arguments_(arguments),
-        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_; }
-  virtual intptr_t ArgumentCount() const { return arguments_->length(); }
-  virtual PushArgumentInstr* PushArgumentAt(intptr_t index) const {
-    return (*arguments_)[index];
-  }
-  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);
 
   virtual bool CanBecomeDeoptimizationTarget() const {
     // Instance calls that are specialized by the optimizer need a
     // deoptimization descriptor before the call.
     return true;
   }
 
   virtual EffectSet Effects() const { return EffectSet::All(); }
 
   PRINT_OPERANDS_TO_SUPPORT
 
   bool MatchesCoreName(const String& name);
 
  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_;
-  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:
   PolymorphicInstanceCallInstr(InstanceCallInstr* instance_call,
@@ skipping 30 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 306 matching lines @@
   }
 
   ComparisonInstr* comparison_;
   const intptr_t if_true_;
   const intptr_t if_false_;
 
   DISALLOW_COPY_AND_ASSIGN(IfThenElseInstr);
 };
 
 
-class StaticCallInstr : public TemplateDefinition<0, Throws> {
+class StaticCallInstr : public TemplateDartCall<0> {
  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()),
+      : TemplateDartCall(Thread::Current()->GetNextDeoptId(),
+                         type_args_len,
+                         argument_names,
+                         arguments,
+                         token_pos),
         ic_data_(NULL),
-        token_pos_(token_pos),
         function_(function),
-        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),
+      : TemplateDartCall(deopt_id,
+                         type_args_len,
+                         argument_names,
+                         arguments,
+                         token_pos),
         ic_data_(NULL),
-        token_pos_(token_pos),
         function_(function),
-        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_; }
-  const Array& argument_names() const { return argument_names_; }
-  virtual TokenPosition token_pos() const { return token_pos_; }
-
-  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; }
 
   virtual bool CanBecomeDeoptimizationTarget() const {
     // Static calls that are specialized by the optimizer (e.g. sqrt) need a
     // deoptimization descriptor before the call.
@@ skipping 11 matching lines @@
 
   bool IsRecognizedFactory() const { return is_known_list_constructor(); }
 
   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_;
-  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 3402 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_