[turbofan] fine grained in-block move optimization

test/unittests/compiler/move-optimizer-unittest.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"
+#include "src/compiler/pipeline.h"
 #include "test/unittests/compiler/instruction-sequence-unittest.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 class MoveOptimizerTest : public InstructionSequenceTest {
  public:
   Instruction* LastInstruction() { return sequence()->instructions().back(); }
 
@@ skipping 204 matching lines @@
   AddMove(last, Reg(0), Reg(1));
   EndBlock(Last());
   Optimize();
 
   ParallelMove* inst1_start =
       ctant_def->GetParallelMove(Instruction::GapPosition::START);
   ParallelMove* inst1_end =
       ctant_def->GetParallelMove(Instruction::GapPosition::END);
   ParallelMove* last_start =
       last->GetParallelMove(Instruction::GapPosition::START);
-  CHECK(inst1_start == nullptr || inst1_start->size() == 0);
-  CHECK(inst1_end == nullptr || inst1_end->size() == 0);
+  CHECK(inst1_start == nullptr || NonRedundantSize(inst1_start) == 0);
+  CHECK(inst1_end == nullptr || NonRedundantSize(inst1_end) == 0);
   CHECK(last_start->size() == 2);
   int redundants = 0;
   int assignment = 0;
   for (MoveOperands* move : *last_start) {
     if (move->IsRedundant()) {
       ++redundants;
     } else {
       ++assignment;
       CHECK(move->destination().IsRegister());
       CHECK(move->source().IsConstant());
@@ skipping 72 matching lines @@
   ParallelMove* b1_move = last_move_b1->parallel_moves()[0];
   CHECK_EQ(2, NonRedundantSize(b1_move));
   CHECK(Contains(b1_move, Reg(0), Reg(1)));
   CHECK(Contains(b1_move, Reg(2), Reg(0)));
 
   ParallelMove* b2_move = last_move_b2->parallel_moves()[0];
   CHECK_EQ(1, NonRedundantSize(b2_move));
   CHECK(Contains(b1_move, Reg(0), Reg(1)));
 }
 
+TEST_F(MoveOptimizerTest, ClobberedDestinationsAreEliminated) {
+  StartBlock();
+  EmitNop();
+  Instruction* first_instr = LastInstruction();
+  AddMove(first_instr, Reg(0), Reg(1));
+  EmitOI(Reg(1), 0, nullptr);
+  Instruction* last_instr = LastInstruction();
+  EndBlock();
+  Optimize();
+
+  ParallelMove* first_move = first_instr->parallel_moves()[0];
+  CHECK_EQ(0, NonRedundantSize(first_move));
+
+  ParallelMove* last_move = last_instr->parallel_moves()[0];
+  CHECK_EQ(0, NonRedundantSize(last_move));
+}
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8