[turbofan] move register allocation phases to pipeline

test/unittests/compiler/register-allocator-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/base/utils/random-number-generator.h"
-#include "src/compiler/register-allocator.h"
-#include "src/compiler/register-allocator-verifier.h"
+#include "src/compiler/instruction.h"
+#include "src/compiler/pipeline.h"
 #include "test/unittests/test-utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 typedef BasicBlock::RpoNumber Rpo;
 
 static const char*
@@ skipping 142 matching lines @@
   }
 
   InstructionSequence* sequence() {
     if (sequence_ == nullptr) {
       sequence_ =
           new (zone()) InstructionSequence(zone(), &instruction_blocks_);
     }
     return sequence_;
   }
 
-  RegisterAllocator* allocator() {
-    if (allocator_.is_empty()) {
-      allocator_.Reset(
-          new RegisterAllocator(config(), zone(), frame(), sequence()));
-    }
-    return allocator_.get();
-  }
-
   void StartLoop(int loop_blocks) {
     CHECK(current_block_ == nullptr);
     if (!loop_blocks_.empty()) {
       CHECK(!loop_blocks_.back().loop_header_.IsValid());
     }
     LoopData loop_data = {Rpo::Invalid(), loop_blocks};
     loop_blocks_.push_back(loop_data);
   }
 
   void EndLoop() {
@@ skipping 32 matching lines @@
     completions_.push_back(completion);
     CHECK(current_block_ != nullptr);
     sequence()->EndBlock(current_block_->rpo_number());
     current_block_ = nullptr;
     return instruction_index;
   }
 
   void Allocate() {
     CHECK_EQ(nullptr, current_block_);
     WireBlocks();
-    RegisterAllocatorVerifier verifier(zone(), config(), sequence());
-    if (FLAG_trace_alloc || FLAG_trace_turbo) {
-      OFStream os(stdout);
-      PrintableInstructionSequence printable = {config(), sequence()};
-      os << "Before: " << std::endl << printable << std::endl;
-    }
-    allocator()->Allocate();
-    if (FLAG_trace_alloc || FLAG_trace_turbo) {
-      OFStream os(stdout);
-      PrintableInstructionSequence printable = {config(), sequence()};
-      os << "After: " << std::endl << printable << std::endl;
-    }
-    verifier.VerifyAssignment();
-    verifier.VerifyGapMoves();
+    Pipeline::AllocateRegisters(config(), sequence(), true);
   }
 
   TestOperand Imm(int32_t imm = 0) {
     int index = sequence()->AddImmediate(Constant(imm));
     return TestOperand(kImmediate, index);
   }
 
   VReg Parameter(TestOperand output_op = Reg()) {
     VReg vreg = NewReg();
     InstructionOperand* outputs[1]{ConvertOutputOp(vreg, output_op)};
@@ skipping 259 matching lines @@
     Rpo loop_header_;
     int expected_blocks_;
   };
 
   typedef std::vector<LoopData> LoopBlocks;
   typedef std::map<int, const Instruction*> Instructions;
   typedef std::vector<BlockCompletion> Completions;
 
   SmartPointer<RegisterConfiguration> config_;
   Frame* frame_;
-  SmartPointer<RegisterAllocator> allocator_;
   InstructionSequence* sequence_;
   int num_general_registers_;
   int num_double_registers_;
 
   // Block building state.
   InstructionBlocks instruction_blocks_;
   Instructions instructions_;
   int current_instruction_index_;
   Completions completions_;
   LoopBlocks loop_blocks_;
@@ skipping 212 matching lines @@
   StartBlock();
   Return(DefineConstant());
   EndBlock();
 
   Allocate();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8