Support inlining of calls where type arguments are passed to generic functions.

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 363 matching lines @@
   M(PushArgument)                                                              \
   M(Return)                                                                    \
   M(Throw)                                                                     \
   M(ReThrow)                                                                   \
   M(Stop)                                                                      \
   M(Goto)                                                                      \
   M(IndirectGoto)                                                              \
   M(Branch)                                                                    \
   M(AssertAssignable)                                                          \
   M(AssertBoolean)                                                             \
-  M(CurrentContext)                                                            \
+  M(SpecialParameter)                                                          \
   M(ClosureCall)                                                               \
   M(InstanceCall)                                                              \
   M(PolymorphicInstanceCall)                                                   \
   M(StaticCall)                                                                \
   M(LoadLocal)                                                                 \
   M(DropTemps)                                                                 \
   M(StoreLocal)                                                                \
   M(StrictCompare)                                                             \
   M(EqualityCompare)                                                           \
   M(RelationalOp)                                                              \
@@ skipping 2376 matching lines @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const TokenPosition token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(AssertBooleanInstr);
 };
 
 
-// Denotes the current context, normally held in a register.  This is
-// a computation, not a value, because it's mutable.
-class CurrentContextInstr : public TemplateDefinition<0, NoThrow> {
+// Denotes a special parameter, currently either the context of a closure
+// (normally held in a register) or the type arguments of a generic function.

[Vyacheslav Egorov (Google), 2017/07/03 16:15:43]

"normally held in a register" part of the comment is obsolete. 

Historically we used to have a dedicated register CTX for the context, but
Florian has long time ago refactored backend to use a normal variable for
closure context. (We still use CTX to pass context value between function
prologue and function body in optimized code, but otherwise it is a completely
free register used for other things). 

[regis, 2017/07/05 18:41:30]

Updated comment.

+// This is a computation, not a value, because it's mutable.

[Vyacheslav Egorov (Google), 2017/07/03 16:15:43]

"This is computation, not a value" is an obsolete comment from ancient times. We
used to have very sophisticated IR distinction between computations and values -
but that all got refactored away in very early days of this JIT. Now this
sentence makes no sense, definition can't be mutable. It is an SSA value which
does not change once it is computed.

[regis, 2017/07/05 18:41:29]

Removed comment.

+class SpecialParameterInstr : public TemplateDefinition<0, NoThrow> {
  public:
-  explicit CurrentContextInstr(intptr_t deopt_id)
-      : TemplateDefinition(deopt_id) {}
+  enum SpecialParameterKind { kContext, kTypeArgs };
+  SpecialParameterInstr(SpecialParameterKind kind, intptr_t deopt_id)
+      : TemplateDefinition(deopt_id), kind_(kind) {}
 
-  DECLARE_INSTRUCTION(CurrentContext)
+  DECLARE_INSTRUCTION(SpecialParameter)
   virtual CompileType ComputeType() const;
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }

[Vyacheslav Egorov (Google), 2017/07/03 16:15:43]

this needs to be: 

return kind() == other->AsSpecialParameter()->kind();

[regis, 2017/07/05 18:41:30]

Done.

+  SpecialParameterKind kind() const { return kind_; }
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(CurrentContextInstr);
+  const SpecialParameterKind kind_;
+  DISALLOW_COPY_AND_ASSIGN(SpecialParameterInstr);
 };
 
 
 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) {}
@@ skipping 5447 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_