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

src/compiler/register-allocator.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/register-allocator.h"
 
 #include "src/compiler/linkage.h"
 #include "src/hydrogen.h"
 #include "src/string-stream.h"
 
@@ skipping 481 matching lines @@
       if (a == NULL || a->start().Value() > other->End().Value()) break;
       AdvanceLastProcessedMarker(a, advance_last_processed_up_to);
     } else {
       b = b->next();
     }
   }
   return LifetimePosition::Invalid();
 }
 
 
-RegisterAllocator::RegisterAllocator(Frame* frame, CompilationInfo* info,
+RegisterAllocator::RegisterAllocator(Zone* local_zone, Frame* frame,
+                                     CompilationInfo* info,
                                      InstructionSequence* code)
-    : zone_(code->isolate()),
+    : zone_(local_zone),
+      zone_pool_(NULL),
       frame_(frame),
       info_(info),
       code_(code),
       live_in_sets_(code->InstructionBlockCount(), zone()),
       live_ranges_(code->VirtualRegisterCount() * 2, zone()),
       fixed_live_ranges_(NULL),
       fixed_double_live_ranges_(NULL),
       unhandled_live_ranges_(code->VirtualRegisterCount() * 2, zone()),
       active_live_ranges_(8, zone()),
       inactive_live_ranges_(8, zone()),
@@ skipping 572 matching lines @@
 
     // We use the phi-ness of some nodes in some later heuristics.
     live_range->set_is_phi(true);
     if (!block->IsLoopHeader()) {
       live_range->set_is_non_loop_phi(true);
     }
   }
 }
 
 
-bool RegisterAllocator::Allocate() {
+bool RegisterAllocator::Allocate(ZonePool* zone_pool) {
+  DCHECK_EQ(NULL, zone_pool_);
+  zone_pool_ = zone_pool;
   assigned_registers_ = new (code_zone())
       BitVector(Register::NumAllocatableRegisters(), code_zone());
   assigned_double_registers_ = new (code_zone())
       BitVector(DoubleRegister::NumAllocatableAliasedRegisters(), code_zone());
   MeetRegisterConstraints();
   if (!AllocationOk()) return false;
   ResolvePhis();
   BuildLiveRanges();
   AllocateGeneralRegisters();
   if (!AllocationOk()) return false;
   AllocateDoubleRegisters();
   if (!AllocationOk()) return false;
   PopulatePointerMaps();
   ConnectRanges();
   ResolveControlFlow();
   frame()->SetAllocatedRegisters(assigned_registers_);
   frame()->SetAllocatedDoubleRegisters(assigned_double_registers_);
   return true;
 }
 
 
+class RegisterAllocatorPhase : public CompilationPhase {
+ public:
+  RegisterAllocatorPhase(const char* name, RegisterAllocator* allocator)
+      : CompilationPhase(name, allocator->info()),
+        allocator_(allocator),
+        allocator_zone_start_allocation_size_(0),
+        stats_(NULL) {
+    if (FLAG_turbo_stats) {
+      allocator_zone_start_allocation_size_ =
+          allocator->info()->zone()->allocation_size();
+      if (allocator->zone_pool() != NULL) {
+        stats_ = new ZonePool::StatsScope(allocator->zone_pool());
+      }
+    }
+  }
+
+  ~RegisterAllocatorPhase() {
+    if (FLAG_turbo_stats) {
+      unsigned size = allocator_->info()->zone()->allocation_size() -
+                      allocator_zone_start_allocation_size_;
+      if (stats_ != NULL) {
+        size += static_cast<unsigned>(stats_->GetMaxAllocatedBytes());
+      }
+      isolate()->GetTStatistics()->SaveTiming(name(), base::TimeDelta(), size);
+    }
+    delete stats_;
+#ifdef DEBUG
+    if (allocator_ != NULL) allocator_->Verify();
+#endif
+  }
+
+ private:
+  RegisterAllocator* allocator_;
+  unsigned allocator_zone_start_allocation_size_;
+  ZonePool::StatsScope* stats_;
+
+  DISALLOW_COPY_AND_ASSIGN(RegisterAllocatorPhase);
+};
+
+
 void RegisterAllocator::MeetRegisterConstraints() {
   RegisterAllocatorPhase phase("L_Register constraints", this);
   for (int i = 0; i < code()->InstructionBlockCount(); ++i) {
     MeetRegisterConstraints(
         code()->InstructionBlockAt(BasicBlock::RpoNumber::FromInt(i)));
     if (!AllocationOk()) return;
   }
 }
 
 
@@ skipping 1071 matching lines @@
                                                      int reg) {
   if (range->Kind() == DOUBLE_REGISTERS) {
     assigned_double_registers_->Add(reg);
   } else {
     DCHECK(range->Kind() == GENERAL_REGISTERS);
     assigned_registers_->Add(reg);
   }
   range->set_assigned_register(reg, code_zone());
 }
 
-
-RegisterAllocatorPhase::RegisterAllocatorPhase(const char* name,
-                                               RegisterAllocator* allocator)
-    : CompilationPhase(name, allocator->info()), allocator_(allocator) {
-  if (FLAG_turbo_stats) {
-    allocator_zone_start_allocation_size_ =
-        allocator->zone()->allocation_size();
-  }
-}
-
-
-RegisterAllocatorPhase::~RegisterAllocatorPhase() {
-  if (FLAG_turbo_stats) {
-    unsigned size = allocator_->zone()->allocation_size() -
-                    allocator_zone_start_allocation_size_;
-    isolate()->GetTStatistics()->SaveTiming(name(), base::TimeDelta(), size);
-  }
-#ifdef DEBUG
-  if (allocator_ != NULL) allocator_->Verify();
-#endif
-}
 }
 }
 }  // namespace v8::internal::compiler