[turbofan] split compilation stats off from HStatistics and track high water marks

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;
 class ParallelMove;
 class PointerMap;
 
 namespace compiler {
 
+class PipelineStatistics;
+
 enum RegisterKind {
   UNALLOCATED_REGISTERS,
   GENERAL_REGISTERS,
   DOUBLE_REGISTERS
 };
 
 
 // This class represents a single point of a InstructionOperand's lifetime. For
 // each instruction there are exactly two lifetime positions: the beginning and
 // the end of the instruction. Lifetime positions for different instructions are
@@ skipping 288 matching lines @@
 
   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;
 
-  // TODO(dcarney): fix compilation phase stats to not require this.
-  bool Allocate(ZonePool* zone_pool = NULL);
+  bool Allocate(PipelineStatistics* stats = 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() const { return zone_; }
 
   // This zone is for InstructionOperands and moves that live beyond register
   // allocation.
   inline Zone* code_zone() const { return code()->zone(); }
 
   int GetVirtualRegister() {
     int vreg = code()->NextVirtualRegister();
@@ skipping 136 matching lines @@
 
   const char* RegisterName(int allocation_index);
 
   inline Instruction* InstructionAt(int index) {
     return code()->InstructionAt(index);
   }
 
   Frame* frame() const { return frame_; }
 
   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 22 matching lines @@
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(RegisterAllocator);
 };
 
 }
 }
 }  // namespace v8::internal::compiler
 
 #endif  // V8_REGISTER_ALLOCATOR_H_