Move register allocation unittests and constrain owners

test/unittests/compiler/regalloc/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 {
@@ skipping 80 matching lines @@
         return ExplicitOperand(LocationOperand::REGISTER, rep, op.value_);
       }
       default:
         break;
     }
     CHECK(false);
     return InstructionOperand();
   }
 };
 
-
 TEST_F(MoveOptimizerTest, RemovesRedundant) {
   StartBlock();
   auto first_instr = EmitNop();
   auto last_instr = EmitNop();
 
   AddMove(first_instr, Reg(0), Reg(1));
   AddMove(last_instr, Reg(1), Reg(0));
 
   AddMove(first_instr, FPReg(kS128_1, kSimd128), FPReg(kS128_2, kSimd128));
   AddMove(last_instr, FPReg(kS128_2, kSimd128), FPReg(kS128_1, kSimd128));
   AddMove(first_instr, FPReg(kF64_1, kFloat64), FPReg(kF64_2, kFloat64));
   AddMove(last_instr, FPReg(kF64_2, kFloat64), FPReg(kF64_1, kFloat64));
   AddMove(first_instr, FPReg(kF32_1, kFloat32), FPReg(kF32_2, kFloat32));
   AddMove(last_instr, FPReg(kF32_2, kFloat32), FPReg(kF32_1, kFloat32));
 
   EndBlock(Last());
 
   Optimize();
 
   CHECK_EQ(0, NonRedundantSize(first_instr->parallel_moves()[0]));
   auto move = last_instr->parallel_moves()[0];
   CHECK_EQ(4, NonRedundantSize(move));
   CHECK(Contains(move, Reg(0), Reg(1)));
   CHECK(Contains(move, FPReg(kS128_1, kSimd128), FPReg(kS128_2, kSimd128)));
   CHECK(Contains(move, FPReg(kF64_1, kFloat64), FPReg(kF64_2, kFloat64)));
   CHECK(Contains(move, FPReg(kF32_1, kFloat32), FPReg(kF32_2, kFloat32)));
 }
 
-
 TEST_F(MoveOptimizerTest, RemovesRedundantExplicit) {
   int index1 = GetAllocatableCode(0);
   int index2 = GetAllocatableCode(1);
   int s128_1 = GetAllocatableCode(kS128_1, kSimd128);
   int s128_2 = GetAllocatableCode(kS128_2, kSimd128);
   int f64_1 = GetAllocatableCode(kF64_1, kFloat64);
   int f64_2 = GetAllocatableCode(kF64_2, kFloat64);
   int f32_1 = GetAllocatableCode(kF32_1, kFloat32);
   int f32_2 = GetAllocatableCode(kF32_2, kFloat32);
 
@@ skipping 19 matching lines @@
   CHECK_EQ(0, NonRedundantSize(first_instr->parallel_moves()[0]));
   auto move = last_instr->parallel_moves()[0];
   CHECK_EQ(4, NonRedundantSize(move));
   CHECK(Contains(move, Reg(index1), ExplicitReg(index2)));
   CHECK(
       Contains(move, FPReg(s128_1, kSimd128), ExplicitFPReg(s128_2, kSimd128)));
   CHECK(Contains(move, FPReg(f64_1, kFloat64), ExplicitFPReg(f64_2, kFloat64)));
   CHECK(Contains(move, FPReg(f32_1, kFloat32), ExplicitFPReg(f32_2, kFloat32)));
 }
 
-
 TEST_F(MoveOptimizerTest, SplitsConstants) {
   StartBlock();
   EndBlock(Last());
 
   auto gap = LastInstruction();
   AddMove(gap, Const(1), Slot(0));
   AddMove(gap, Const(1), Slot(1));
   AddMove(gap, Const(1), Reg(0));
   AddMove(gap, Const(1), Slot(2));
 
   Optimize();
 
   auto move = gap->parallel_moves()[0];
   CHECK_EQ(1, NonRedundantSize(move));
   CHECK(Contains(move, Const(1), Reg(0)));
 
   move = gap->parallel_moves()[1];
   CHECK_EQ(3, NonRedundantSize(move));
   CHECK(Contains(move, Reg(0), Slot(0)));
   CHECK(Contains(move, Reg(0), Slot(1)));
   CHECK(Contains(move, Reg(0), Slot(2)));
 }
 
-
 TEST_F(MoveOptimizerTest, SimpleMerge) {
   StartBlock();
   EndBlock(Branch(Imm(), 1, 2));
 
   StartBlock();
   EndBlock(Jump(2));
   AddMove(LastInstruction(), Reg(0), Reg(1));
   AddMove(LastInstruction(), FPReg(kS128_1, kSimd128),
           FPReg(kS128_2, kSimd128));
   AddMove(LastInstruction(), FPReg(kF64_1, kFloat64), FPReg(kF64_2, kFloat64));
@@ skipping 15 matching lines @@
   Optimize();
 
   auto move = last->parallel_moves()[0];
   CHECK_EQ(4, NonRedundantSize(move));
   CHECK(Contains(move, Reg(0), Reg(1)));
   CHECK(Contains(move, FPReg(kS128_1, kSimd128), FPReg(kS128_2, kSimd128)));
   CHECK(Contains(move, FPReg(kF64_1, kFloat64), FPReg(kF64_2, kFloat64)));
   CHECK(Contains(move, FPReg(kF32_1, kFloat32), FPReg(kF32_2, kFloat32)));
 }
 
-
 TEST_F(MoveOptimizerTest, SimpleMergeCycle) {
   StartBlock();
   EndBlock(Branch(Imm(), 1, 2));
 
   StartBlock();
   EndBlock(Jump(2));
   auto gap_0 = LastInstruction();
   AddMove(gap_0, Reg(0), Reg(1));
   AddMove(LastInstruction(), Reg(1), Reg(0));
 
@@ skipping 31 matching lines @@
   CHECK(Contains(move, Reg(0), Reg(1)));
   CHECK(Contains(move, Reg(1), Reg(0)));
   CHECK(Contains(move, FPReg(kS128_1, kSimd128), FPReg(kS128_2, kSimd128)));
   CHECK(Contains(move, FPReg(kS128_2, kSimd128), FPReg(kS128_1, kSimd128)));
   CHECK(Contains(move, FPReg(kF64_1, kFloat64), FPReg(kF64_2, kFloat64)));
   CHECK(Contains(move, FPReg(kF64_2, kFloat64), FPReg(kF64_1, kFloat64)));
   CHECK(Contains(move, FPReg(kF32_1, kFloat32), FPReg(kF32_2, kFloat32)));
   CHECK(Contains(move, FPReg(kF32_2, kFloat32), FPReg(kF32_1, kFloat32)));
 }
 
-
 TEST_F(MoveOptimizerTest, GapsCanMoveOverInstruction) {
   StartBlock();
   int const_index = 1;
   DefineConstant(const_index);
   Instruction* ctant_def = LastInstruction();
   AddMove(ctant_def, Reg(1), Reg(0));
 
   Instruction* last = EmitNop();
   AddMove(last, Const(const_index), Reg(0));
   AddMove(last, Reg(0), Reg(1));
@@ skipping 17 matching lines @@
     } else {
       ++assignment;
       CHECK(move->destination().IsRegister());
       CHECK(move->source().IsConstant());
     }
   }
   CHECK_EQ(1, redundants);
   CHECK_EQ(1, assignment);
 }
 
-
 TEST_F(MoveOptimizerTest, SubsetMovesMerge) {
   StartBlock();
   EndBlock(Branch(Imm(), 1, 2));
 
   StartBlock();
   EndBlock(Jump(2));
   Instruction* last_move_b1 = LastInstruction();
   AddMove(last_move_b1, Reg(0), Reg(1));
   AddMove(last_move_b1, Reg(2), Reg(3));
 
@@ skipping 16 matching lines @@
 
   ParallelMove* b1_move = last_move_b1->parallel_moves()[0];
   CHECK_EQ(1, NonRedundantSize(b1_move));
   CHECK(Contains(b1_move, Reg(2), Reg(3)));
 
   ParallelMove* b2_move = last_move_b2->parallel_moves()[0];
   CHECK_EQ(1, NonRedundantSize(b2_move));
   CHECK(Contains(b2_move, Reg(4), Reg(5)));
 }
 
-
 TEST_F(MoveOptimizerTest, GapConflictSubsetMovesDoNotMerge) {
   StartBlock();
   EndBlock(Branch(Imm(), 1, 2));
 
   StartBlock();
   EndBlock(Jump(2));
   Instruction* last_move_b1 = LastInstruction();
   AddMove(last_move_b1, Reg(0), Reg(1));
   AddMove(last_move_b1, Reg(2), Reg(0));
   AddMove(last_move_b1, Reg(4), Reg(5));
@@ skipping 62 matching lines @@
   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