[turbofan]: Support using push instructions for setting up tail call parameters

src/compiler/gap-resolver.h

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_COMPILER_GAP_RESOLVER_H_
 #define V8_COMPILER_GAP_RESOLVER_H_
 
 #include "src/compiler/instruction.h"
 
 namespace v8 {
@@ skipping 13 matching lines @@
     // Assemble swap.
     virtual void AssembleSwap(InstructionOperand* source,
                               InstructionOperand* destination) = 0;
   };
 
   explicit GapResolver(Assembler* assembler) : assembler_(assembler) {}
 
   // Resolve a set of parallel moves, emitting assembler instructions.
   void Resolve(ParallelMove* parallel_move) const;
 
+  enum PushTypeFlag {
+    kImmediatePush = 0x1,
+    kScalarPush = 0x2,
+    kFloat32Push = 0x4,
+    kFloat64Push = 0x8,
+    kFloatPush = kFloat32Push | kFloat64Push
+  };
+
+  typedef base::Flags<PushTypeFlag> PushTypeFlags;
+
+  // Generate a list moves from an instruction that are candidates to be turned
+  // into push instructions on platforms that support them.
+  static void GetPushCompatibleMoves(Zone* zone, Instruction* instr,

[Mircea Trofin, 2016/06/30 15:32:34]

Is this just for tail calls cases, or in general?

Could you add a comment as to what specifically makes a move instruction a
candidate to be turned into a 
push?

[danno, 2016/07/01 07:31:57]

Eventually, I'd like to convert the "normal" call mechanism to use this too, but
there is more prep work to do this. Given how bad the code was for tail calls in
its current from, going this path sets the bar low, allowing some of the
infrastructure in place before switching everything over. I'll explain this in
the overall comment for the CL.

+                                     PushTypeFlags push_type,
+                                     ZoneVector<MoveOperands*>* pushes);
+
  private:
   // Perform the given move, possibly requiring other moves to satisfy
   // dependencies.
   void PerformMove(ParallelMove* moves, MoveOperands* move) const;
 
   // Assembler used to emit moves and save registers.
   Assembler* const assembler_;
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_GAP_RESOLVER_H_