Introduce subclass wrappers for STL containers that make them a lot easier

src/compiler/schedule.h

 // Copyright 2013 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_COMPILER_SCHEDULE_H_
 #define V8_COMPILER_SCHEDULE_H_
 
 #include <vector>
 
 #include "src/v8.h"
@@ skipping 45 matching lines @@
   explicit BasicBlockData(Zone* zone)
       : rpo_number_(-1),
         loop_header_(NULL),
         loop_depth_(0),
         loop_end_(-1),
         code_start_(-1),
         code_end_(-1),
         deferred_(false),
         control_(kNone),
         control_input_(NULL),
-        nodes_(NodeVector::allocator_type(zone)) {}
+        nodes_(zone) {}
 
   inline bool IsLoopHeader() const { return loop_end_ >= 0; }
   inline bool LoopContains(BasicBlockData* block) const {
     // RPO numbers must be initialized.
     DCHECK(rpo_number_ >= 0);
     DCHECK(block->rpo_number_ >= 0);
     if (loop_end_ < 0) return false;  // This is not a loop.
     return block->rpo_number_ >= rpo_number_ && block->rpo_number_ < loop_end_;
   }
   int first_instruction_index() {
@@ skipping 61 matching lines @@
   reverse_iterator rbegin() { return nodes_.rbegin(); }
   reverse_iterator rend() { return nodes_.rend(); }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BasicBlock);
 };
 
 typedef GenericGraphVisit::NullNodeVisitor<BasicBlockData, BasicBlock>
     NullBasicBlockVisitor;
 
-typedef zone_allocator<BasicBlock*> BasicBlockPtrZoneAllocator;
-typedef std::vector<BasicBlock*, BasicBlockPtrZoneAllocator> BasicBlockVector;
+typedef ZoneVector<BasicBlock*> BasicBlockVector;
 typedef BasicBlockVector::iterator BasicBlockVectorIter;
 typedef BasicBlockVector::reverse_iterator BasicBlockVectorRIter;
 
 // A schedule represents the result of assigning nodes to basic blocks
 // and ordering them within basic blocks. Prior to computing a schedule,
 // a graph has no notion of control flow ordering other than that induced
 // by the graph's dependencies. A schedule is required to generate code.
 class Schedule : public GenericGraph<BasicBlock> {
  public:
   explicit Schedule(Zone* zone)
       : GenericGraph<BasicBlock>(zone),
         zone_(zone),
-        all_blocks_(BasicBlockVector::allocator_type(zone)),
-        nodeid_to_block_(BasicBlockVector::allocator_type(zone)),
-        rpo_order_(BasicBlockVector::allocator_type(zone)),
-        immediate_dominator_(BasicBlockVector::allocator_type(zone)) {
+        all_blocks_(zone),
+        nodeid_to_block_(zone),
+        rpo_order_(zone),
+        immediate_dominator_(zone) {
     SetStart(NewBasicBlock());  // entry.
     SetEnd(NewBasicBlock());    // exit.
   }
 
   // Return the block which contains {node}, if any.
   BasicBlock* block(Node* node) const {
     if (node->id() < static_cast<NodeId>(nodeid_to_block_.size())) {
       return nodeid_to_block_[node->id()];
     }
     return NULL;
@@ skipping 144 matching lines @@
                                           // dominator, indexed by block
                                           // id.
 };
 
 OStream& operator<<(OStream& os, const Schedule& s);
 }
 }
 }  // namespace v8::internal::compiler
 
 #endif  // V8_COMPILER_SCHEDULE_H_