[turbofan] refactor pipeline to use hydrogen like Run calls

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 "test/unittests/test-utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
@@ skipping 106 matching lines @@
     BlockCompletion completion = {kBranch, op, left_offset, right_offset};
     return completion;
   }
 
   static BlockCompletion Last() {
     BlockCompletion completion = {kBlockEnd, TestOperand(), kNoValue, kNoValue};
     return completion;
   }
 
   RegisterAllocatorTest()
-      : num_general_registers_(kDefaultNRegs),
+      : frame_(nullptr),
+        sequence_(nullptr),
+        num_general_registers_(kDefaultNRegs),
         num_double_registers_(kDefaultNRegs),
         instruction_blocks_(zone()),
         current_instruction_index_(-1),
         current_block_(nullptr),
         block_returns_(false) {
     InitializeRegisterNames();
   }
 
   void SetNumRegs(int num_general_registers, int num_double_registers) {
     CHECK(config_.is_empty());
     CHECK(instructions_.empty());
     CHECK(instruction_blocks_.empty());
     num_general_registers_ = num_general_registers;
     num_double_registers_ = num_double_registers;
   }
 
   RegisterConfiguration* config() {
     if (config_.is_empty()) {
       config_.Reset(new RegisterConfiguration(
           num_general_registers_, num_double_registers_, num_double_registers_,
           general_register_names_, double_register_names_));
     }
     return config_.get();
   }
 
   Frame* frame() {
-    if (frame_.is_empty()) {
-      frame_.Reset(new Frame());
+    if (frame_ == nullptr) {
+      frame_ = new (zone()) Frame();
     }
-    return frame_.get();
+    return frame_;
   }
 
   InstructionSequence* sequence() {
-    if (sequence_.is_empty()) {
-      sequence_.Reset(new InstructionSequence(zone(), &instruction_blocks_));
+    if (sequence_ == nullptr) {
+      sequence_ =
+          new (zone()) InstructionSequence(zone(), &instruction_blocks_);
     }
-    return sequence_.get();
+    return sequence_;
   }
 
   RegisterAllocator* allocator() {
     if (allocator_.is_empty()) {
       allocator_.Reset(
           new RegisterAllocator(config(), zone(), frame(), sequence()));
     }
     return allocator_.get();
   }
 
@@ skipping 334 matching lines @@
   struct LoopData {
     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_;
-  SmartPointer<Frame> frame_;
+  Frame* frame_;
   SmartPointer<RegisterAllocator> allocator_;
-  SmartPointer<InstructionSequence> sequence_;
+  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_;
   InstructionBlock* current_block_;
@@ skipping 211 matching lines @@
   StartBlock();
   Return(DefineConstant());
   EndBlock();
 
   Allocate();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8