[turbofan] only use two gaps

src/compiler/instruction.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_INSTRUCTION_H_
 #define V8_COMPILER_INSTRUCTION_H_
 
 #include <deque>
 #include <iosfwd>
 #include <map>
@@ skipping 382 matching lines @@
     move_operands_.Add(MoveOperands(from, to), zone);
   }
 
   bool IsRedundant() const;
 
   ZoneList<MoveOperands>* move_operands() { return &move_operands_; }
   const ZoneList<MoveOperands>* move_operands() const {
     return &move_operands_;
   }
 
+  // Prepare this ParallelMove to insert move as if it happened in a subsequent
+  // ParallelMove.  move->source() may be changed.  The MoveOperand returned
+  // must be Eliminated and, as it points directly into move_operands_, it must
+  // be Eliminated before any further mutation.
+  MoveOperands* PrepareInsertAfter(MoveOperands* move) const;
+
  private:
   ZoneList<MoveOperands> move_operands_;
 };
 
 
 struct PrintableParallelMove {
   const RegisterConfiguration* register_configuration_;
   const ParallelMove* parallel_move_;
 };
 
@@ skipping 176 matching lines @@
 };
 std::ostream& operator<<(std::ostream& os, const PrintableInstruction& instr);
 
 
 // Represents moves inserted before an instruction due to register allocation.
 // TODO(titzer): squash GapInstruction back into Instruction, since essentially
 // every instruction can possibly have moves inserted before it.
 class GapInstruction : public Instruction {
  public:
   enum InnerPosition {
-    BEFORE,
     START,
     END,
-    AFTER,
-    FIRST_INNER_POSITION = BEFORE,
-    LAST_INNER_POSITION = AFTER
+    FIRST_INNER_POSITION = START,
+    LAST_INNER_POSITION = END
   };
 
   ParallelMove* GetOrCreateParallelMove(InnerPosition pos, Zone* zone) {
     if (parallel_moves_[pos] == NULL) {
       parallel_moves_[pos] = new (zone) ParallelMove(zone);
     }
     return parallel_moves_[pos];
   }
 
   ParallelMove* GetParallelMove(InnerPosition pos) {
@@ skipping 18 matching lines @@
     return static_cast<GapInstruction*>(instr);
   }
 
   static const GapInstruction* cast(const Instruction* instr) {
     DCHECK(instr->IsGapMoves());
     return static_cast<const GapInstruction*>(instr);
   }
 
  protected:
   explicit GapInstruction(InstructionCode opcode) : Instruction(opcode) {
-    parallel_moves_[BEFORE] = NULL;
     parallel_moves_[START] = NULL;
     parallel_moves_[END] = NULL;
-    parallel_moves_[AFTER] = NULL;
   }
 
  private:
   friend std::ostream& operator<<(std::ostream& os,
                                   const PrintableInstruction& instr);
   ParallelMove* parallel_moves_[LAST_INNER_POSITION + 1];
 };
 
 
 class SourcePositionInstruction FINAL : public Instruction {
@@ skipping 403 matching lines @@
 
 
 std::ostream& operator<<(std::ostream& os,
                          const PrintableInstructionSequence& code);
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_INSTRUCTION_H_