[turbofan] move optimizer - CompressBlock cleanup

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 {
 
@@ skipping 100 matching lines @@
     }
     OptimizeMerge(block);
   }
   for (Instruction* gap : to_finalize_) {
     FinalizeMoves(gap);
   }
 }
 
 
 void MoveOptimizer::CompressMoves(ParallelMove* left, ParallelMove* right) {
+  if (right == nullptr) return;
+
   MoveOpVector& eliminated = local_vector();
   DCHECK(eliminated.empty());
 
   if (!left->empty()) {
     // Modify the right moves in place and collect moves that will be killed by
     // merging the two gaps.
     for (MoveOperands* move : *right) {
       if (move->IsRedundant()) continue;
       MoveOperands* to_eliminate = left->PrepareInsertAfter(move);
       if (to_eliminate != nullptr) eliminated.push_back(to_eliminate);
@@ skipping 15 matching lines @@
 }
 
 
 // Smash all consecutive moves into the left most move slot and accumulate them
 // as much as possible across instructions.
 void MoveOptimizer::CompressBlock(InstructionBlock* block) {
   Instruction* prev_instr = nullptr;
   for (int index = block->code_start(); index < block->code_end(); ++index) {
     Instruction* instr = code()->instructions()[index];
     int i = FindFirstNonEmptySlot(instr);
-    if (i <= Instruction::LAST_GAP_POSITION) {
-      // Move the first non-empty gap to position 0.
-      std::swap(instr->parallel_moves()[0], instr->parallel_moves()[i]);
-      ParallelMove* left = instr->parallel_moves()[0];
-      // Compress everything into position 0.
-      for (++i; i <= Instruction::LAST_GAP_POSITION; ++i) {
-        ParallelMove* move = instr->parallel_moves()[i];
-        if (move == nullptr) continue;
-        CompressMoves(left, move);
+    bool has_moves = i <= Instruction::LAST_GAP_POSITION;
+
+    if (i == Instruction::LAST_GAP_POSITION) {
+      std::swap(instr->parallel_moves()[Instruction::FIRST_GAP_POSITION],
+                instr->parallel_moves()[Instruction::LAST_GAP_POSITION]);
+    } else if (i == Instruction::FIRST_GAP_POSITION) {
+      CompressMoves(instr->parallel_moves()[Instruction::FIRST_GAP_POSITION],
+                    instr->parallel_moves()[Instruction::LAST_GAP_POSITION]);
+    }
+    // We either have no moves, or, after swapping or compressing, we have
+    // all the moves in the first gap position, and none in the second/end gap
+    // position.
+    ParallelMove* first =
+        instr->parallel_moves()[Instruction::FIRST_GAP_POSITION];
+    ParallelMove* last =
+        instr->parallel_moves()[Instruction::LAST_GAP_POSITION];
+    USE(last);
+
+    DCHECK(!has_moves ||
+           (first != nullptr && (last == nullptr || last->empty())));
+
+    if (prev_instr != nullptr) {
+      if (has_moves) {
+        // Smash first into prev_instr, killing left.
+        ParallelMove* pred_moves = prev_instr->parallel_moves()[0];
+        CompressMoves(pred_moves, first);
       }
-      if (prev_instr != nullptr) {
-        // Smash left into prev_instr, killing left.
-        ParallelMove* pred_moves = prev_instr->parallel_moves()[0];
-        CompressMoves(pred_moves, left);
-      }
-    }
-    if (prev_instr != nullptr) {
       // Slide prev_instr down so we always know where to look for it.
       std::swap(prev_instr->parallel_moves()[0], instr->parallel_moves()[0]);
     }
+
     prev_instr = instr->parallel_moves()[0] == nullptr ? nullptr : instr;
     if (GapsCanMoveOver(instr, local_zone())) continue;
     if (prev_instr != nullptr) {
       to_finalize_.push_back(prev_instr);
       prev_instr = nullptr;
     }
   }
   if (prev_instr != nullptr) {
     to_finalize_.push_back(prev_instr);
   }
@@ skipping 143 matching lines @@
         static_cast<Instruction::GapPosition>(1), code_zone());
     slot_1->AddMove(group_begin->destination(), load->destination());
     load->Eliminate();
   }
   loads.clear();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8