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

src/compiler/instruction.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_COMPILER_INSTRUCTION_H_
 #define V8_COMPILER_INSTRUCTION_H_
 
 #include <deque>
 #include <map>
 #include <set>
@@ skipping 71 matching lines @@
   // Calls SetUpCache()/TearDownCache() for each subclass.
   static void SetUpCaches();
   static void TearDownCaches();
 
  protected:
   typedef BitField<Kind, 0, 3> KindField;
 
   unsigned value_;
 };
 
-typedef std::vector<InstructionOperand*, zone_allocator<InstructionOperand*> >
-    InstructionOperandVector;
+typedef ZoneVector<InstructionOperand*> InstructionOperandVector;
 
 OStream& operator<<(OStream& os, const InstructionOperand& op);
 
 class UnallocatedOperand : public InstructionOperand {
  public:
   enum BasicPolicy { FIXED_SLOT, EXTENDED_POLICY };
 
   enum ExtendedPolicy {
     NONE,
     ANY,
@@ skipping 614 matching lines @@
 
  private:
   BailoutId bailout_id_;
   int parameters_count_;
   int locals_count_;
   int stack_count_;
 };
 
 OStream& operator<<(OStream& os, const Constant& constant);
 
-typedef std::deque<Constant, zone_allocator<Constant> > ConstantDeque;
+typedef ZoneDeque<Constant> ConstantDeque;
 typedef std::map<int, Constant, std::less<int>,
                  zone_allocator<std::pair<int, Constant> > > ConstantMap;
 
-
-typedef std::deque<Instruction*, zone_allocator<Instruction*> >
-    InstructionDeque;
-typedef std::deque<PointerMap*, zone_allocator<PointerMap*> > PointerMapDeque;
-typedef std::vector<FrameStateDescriptor*,
-                    zone_allocator<FrameStateDescriptor*> >
-    DeoptimizationVector;
-
+typedef ZoneDeque<Instruction*> InstructionDeque;
+typedef ZoneDeque<PointerMap*> PointerMapDeque;
+typedef ZoneVector<FrameStateDescriptor*> DeoptimizationVector;
 
 // Represents architecture-specific generated code before, during, and after
 // register allocation.
 // TODO(titzer): s/IsDouble/IsFloat64/
 class InstructionSequence V8_FINAL {
  public:
   InstructionSequence(Linkage* linkage, Graph* graph, Schedule* schedule)
       : graph_(graph),
         linkage_(linkage),
         schedule_(schedule),
         constants_(ConstantMap::key_compare(),
                    ConstantMap::allocator_type(zone())),
-        immediates_(ConstantDeque::allocator_type(zone())),
-        instructions_(InstructionDeque::allocator_type(zone())),
+        immediates_(zone()),
+        instructions_(zone()),
         next_virtual_register_(graph->NodeCount()),
-        pointer_maps_(PointerMapDeque::allocator_type(zone())),
+        pointer_maps_(zone()),
         doubles_(std::less<int>(), VirtualRegisterSet::allocator_type(zone())),
         references_(std::less<int>(),
                     VirtualRegisterSet::allocator_type(zone())),
-        deoptimization_entries_(DeoptimizationVector::allocator_type(zone())) {}
+        deoptimization_entries_(zone()) {}
 
   int NextVirtualRegister() { return next_virtual_register_++; }
   int VirtualRegisterCount() const { return next_virtual_register_; }
 
   int ValueCount() const { return graph_->NodeCount(); }
 
   int BasicBlockCount() const {
     return static_cast<int>(schedule_->rpo_order()->size());
   }
 
@@ skipping 97 matching lines @@
   DeoptimizationVector deoptimization_entries_;
 };
 
 OStream& operator<<(OStream& os, const InstructionSequence& code);
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_INSTRUCTION_H_