[turbofan] only use two gaps

src/compiler/move-optimizer.cc

 // 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.
 
 #include "src/compiler/move-optimizer.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 namespace {
 
-MoveOperands* PrepareInsertAfter(ParallelMove* left, MoveOperands* move,
-                                 Zone* zone) {
-  auto move_ops = left->move_operands();
-  MoveOperands* replacement = nullptr;
-  MoveOperands* to_eliminate = nullptr;
-  for (auto curr = move_ops->begin(); curr != move_ops->end(); ++curr) {
-    if (curr->IsEliminated()) continue;
-    if (curr->destination()->Equals(move->source())) {
-      DCHECK(!replacement);
-      replacement = curr;
-      if (to_eliminate != nullptr) break;
-    } else if (curr->destination()->Equals(move->destination())) {
-      DCHECK(!to_eliminate);
-      to_eliminate = curr;
-      if (replacement != nullptr) break;
-    }
-  }
-  DCHECK(!(replacement == to_eliminate && replacement != nullptr));
-  if (replacement != nullptr) {
-    auto new_source = InstructionOperand::New(
-        zone, replacement->source()->kind(), replacement->source()->index());
-    move->set_source(new_source);
-  }
-  return to_eliminate;
-}
-
-
 bool GapsCanMoveOver(Instruction* instr) {
   DCHECK(!instr->IsGapMoves());
   return instr->IsSourcePosition() || instr->IsNop();
 }
 
 
 int FindFirstNonEmptySlot(GapInstruction* gap) {
   int i = GapInstruction::FIRST_INNER_POSITION;
   for (; i <= GapInstruction::LAST_INNER_POSITION; i++) {
     auto move = gap->parallel_moves()[i];
@@ skipping 33 matching lines @@
 
 void MoveOptimizer::CompressMoves(MoveOpVector* eliminated, ParallelMove* left,
                                   ParallelMove* right) {
   DCHECK(eliminated->empty());
   auto move_ops = right->move_operands();
   if (!left->move_operands()->is_empty()) {
     // Modify the right moves in place and collect moves that will be killed by
     // merging the two gaps.
     for (auto op = move_ops->begin(); op != move_ops->end(); ++op) {
       if (op->IsRedundant()) continue;
-      MoveOperands* to_eliminate = PrepareInsertAfter(left, op, code_zone());
+      auto to_eliminate = left->PrepareInsertAfter(op);
       if (to_eliminate != nullptr) eliminated->push_back(to_eliminate);
     }
     // Eliminate dead moves.  Must happen before insertion of new moves as the
     // contents of eliminated are pointers into a list.
     for (auto to_eliminate : *eliminated) {
       to_eliminate->Eliminate();
     }
     eliminated->clear();
   }
   // Add all possibly modified moves from right side.
@@ skipping 118 matching lines @@
     std::swap(*new_move, *it);
     ++it;
   }
   DCHECK_EQ(it, slot_1->move_operands()->end());
   new_moves.clear();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8