[turbofan] use ZonePool in most places in the compiler pipeline a temp zone is used.

src/compiler/register-allocator.h

 // 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.
 
 #ifndef V8_REGISTER_ALLOCATOR_H_
 #define V8_REGISTER_ALLOCATOR_H_
 
 #include "src/allocation.h"
 #include "src/compiler/instruction.h"
+#include "src/compiler/zone-pool.h"
 #include "src/macro-assembler.h"
 #include "src/zone.h"
 
 namespace v8 {
 namespace internal {
 
 // Forward declarations.
 class BitVector;
 class InstructionOperand;
 class UnallocatedOperand;
@@ skipping 291 matching lines @@
   InstructionOperand* spill_operand_;
   int spill_start_index_;
 
   friend class RegisterAllocator;  // Assigns to kind_.
 };
 
 
 class RegisterAllocator BASE_EMBEDDED {
  public:
   // TODO(dcarney): remove info
-  explicit RegisterAllocator(Frame* frame, CompilationInfo* info,
-                             InstructionSequence* code);
+  explicit RegisterAllocator(Zone* local_zone, Frame* frame,
+                             CompilationInfo* info, InstructionSequence* code);
 
   static void TraceAlloc(const char* msg, ...);
 
   // Checks whether the value of a given virtual register is a reference.
   // TODO(titzer): rename this to IsReference.
   bool HasTaggedValue(int virtual_register) const;
 
   // Returns the register kind required by the given virtual register.
   RegisterKind RequiredRegisterKind(int virtual_register) const;
 
-  bool Allocate();
+  // TODO(dcarney): fix compilation phase stats to not require this.
+  bool Allocate(ZonePool* zone_pool = NULL);
 
   const ZoneList<LiveRange*>* live_ranges() const { return &live_ranges_; }
   const Vector<LiveRange*>* fixed_live_ranges() const {
     return &fixed_live_ranges_;
   }
   const Vector<LiveRange*>* fixed_double_live_ranges() const {
     return &fixed_double_live_ranges_;
   }
 
   CompilationInfo* info() const { return info_; }
   inline InstructionSequence* code() const { return code_; }
+  ZonePool* zone_pool() const { return zone_pool_; }
 
   // This zone is for datastructures only needed during register allocation.
-  inline Zone* zone() { return &zone_; }
+  inline Zone* zone() const { return zone_; }
 
   // This zone is for InstructionOperands and moves that live beyond register
   // allocation.
-  inline Zone* code_zone() { return code()->zone(); }
+  inline Zone* code_zone() const { return code()->zone(); }
 
   int GetVirtualRegister() {
     int vreg = code()->NextVirtualRegister();
     if (vreg >= UnallocatedOperand::kMaxVirtualRegisters) {
       allocation_ok_ = false;
       // Maintain the invariant that we return something below the maximum.
       return 0;
     }
     return vreg;
   }
@@ skipping 128 matching lines @@
   GapInstruction* GetLastGap(const InstructionBlock* block);
 
   const char* RegisterName(int allocation_index);
 
   inline Instruction* InstructionAt(int index) {
     return code()->InstructionAt(index);
   }
 
   Frame* frame() const { return frame_; }
 
-  Zone zone_;
+  Zone* const zone_;
+  // TODO(dcarney): remove this.
+  ZonePool* zone_pool_;
   Frame* const frame_;
   CompilationInfo* const info_;
   InstructionSequence* const code_;
 
   // During liveness analysis keep a mapping from block id to live_in sets
   // for blocks already analyzed.
   ZoneList<BitVector*> live_in_sets_;
 
   // Liveness analysis results.
   ZoneList<LiveRange*> live_ranges_;
@@ skipping 17 matching lines @@
   // Indicates success or failure during register allocation.
   bool allocation_ok_;
 
 #ifdef DEBUG
   LifetimePosition allocation_finger_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(RegisterAllocator);
 };
 
-
-class RegisterAllocatorPhase : public CompilationPhase {
- public:
-  RegisterAllocatorPhase(const char* name, RegisterAllocator* allocator);
-  ~RegisterAllocatorPhase();
-
- private:
-  RegisterAllocator* allocator_;
-  unsigned allocator_zone_start_allocation_size_;
-
-  DISALLOW_COPY_AND_ASSIGN(RegisterAllocatorPhase);
-};
 }
 }
 }  // namespace v8::internal::compiler
 
 #endif  // V8_REGISTER_ALLOCATOR_H_