Changed statement ZoneList to a ZoneChunkList

src/crankshaft/lithium-allocator.h

 // Copyright 2012 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_CRANKSHAFT_LITHIUM_ALLOCATOR_H_
 #define V8_CRANKSHAFT_LITHIUM_ALLOCATOR_H_
 
 #include "src/allocation.h"
 #include "src/base/compiler-specific.h"
 #include "src/crankshaft/compilation-phase.h"
@@ skipping 100 matching lines @@
   // Code relies on kStep being a power of two.
   STATIC_ASSERT(IS_POWER_OF_TWO(kStep));
 
   explicit LifetimePosition(int value) : value_(value) { }
 
   int value_;
 };
 
 
 // Representation of the non-empty interval [start,end[.
-class UseInterval: public ZoneObject {
+class UseInterval : public ZoneObject {
  public:
   UseInterval(LifetimePosition start, LifetimePosition end)
       : start_(start), end_(end), next_(NULL) {
     DCHECK(start.Value() < end.Value());
   }
 
   LifetimePosition start() const { return start_; }
   LifetimePosition end() const { return end_; }
   UseInterval* next() const { return next_; }
 
@@ skipping 18 matching lines @@
   void set_next(UseInterval* next) { next_ = next; }
 
   LifetimePosition start_;
   LifetimePosition end_;
   UseInterval* next_;
 
   friend class LiveRange;  // Assigns to start_.
 };
 
 // Representation of a use position.
-class UsePosition: public ZoneObject {
+class UsePosition : public ZoneObject {
  public:
   UsePosition(LifetimePosition pos, LOperand* operand, LOperand* hint);
 
   LOperand* operand() const { return operand_; }
   bool HasOperand() const { return operand_ != NULL; }
 
   LOperand* hint() const { return hint_; }
   bool HasHint() const;
   bool RequiresRegister() const;
   bool RegisterIsBeneficial() const;
 
   LifetimePosition pos() const { return pos_; }
   UsePosition* next() const { return next_; }
 
  private:
   void set_next(UsePosition* next) { next_ = next; }
 
   LOperand* const operand_;
   LOperand* const hint_;
   LifetimePosition const pos_;
   UsePosition* next_;
   bool requires_reg_;
   bool register_beneficial_;
 
   friend class LiveRange;
 };
 
 // Representation of SSA values' live ranges as a collection of (continuous)
 // intervals over the instruction ordering.
-class LiveRange: public ZoneObject {
+class LiveRange : public ZoneObject {
  public:
   static const int kInvalidAssignment = 0x7fffffff;
 
   LiveRange(int id, Zone* zone);
 
   UseInterval* first_interval() const { return first_interval_; }
   UsePosition* first_pos() const { return first_pos_; }
   LiveRange* parent() const { return parent_; }
   LiveRange* TopLevel() { return (parent_ == NULL) ? this : parent_; }
   LiveRange* next() const { return next_; }
@@ skipping 366 matching lines @@
   size_t allocator_zone_start_allocation_size_;
 
   DISALLOW_COPY_AND_ASSIGN(LAllocatorPhase);
 };
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_CRANKSHAFT_LITHIUM_ALLOCATOR_H_