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

src/compiler/instruction-selector.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/instruction-selector.h"
 
 #include "src/compiler/instruction-selector-impl.h"
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/node-properties-inl.h"
 #include "src/compiler/pipeline.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 InstructionSelector::InstructionSelector(InstructionSequence* sequence,
                                          SourcePositionTable* source_positions,
                                          Features features)
     : zone_(sequence->isolate()),
       sequence_(sequence),
       source_positions_(source_positions),
       features_(features),
       current_block_(NULL),
-      instructions_(InstructionDeque::allocator_type(zone())),
-      defined_(graph()->NodeCount(), false, BoolVector::allocator_type(zone())),
-      used_(graph()->NodeCount(), false, BoolVector::allocator_type(zone())) {}
+      instructions_(zone()),
+      defined_(graph()->NodeCount(), false, zone()),
+      used_(graph()->NodeCount(), false, zone()) {}
 
 
 void InstructionSelector::SelectInstructions() {
   // Mark the inputs of all phis in loop headers as used.
   BasicBlockVector* blocks = schedule()->rpo_order();
   for (BasicBlockVectorIter i = blocks->begin(); i != blocks->end(); ++i) {
     BasicBlock* block = *i;
     if (!block->IsLoopHeader()) continue;
     DCHECK_NE(0, block->PredecessorCount());
     DCHECK_NE(1, block->PredecessorCount());
@@ skipping 211 matching lines @@
   if (RepresentationOf(rep) == kRepTagged) MarkAsReference(node);
 }
 
 
 // TODO(bmeurer): Get rid of the CallBuffer business and make
 // InstructionSelector::VisitCall platform independent instead.
 CallBuffer::CallBuffer(Zone* zone, CallDescriptor* d,
                        FrameStateDescriptor* frame_desc)
     : descriptor(d),
       frame_state_descriptor(frame_desc),
-      output_nodes(NodeVector::allocator_type(zone)),
-      outputs(InstructionOperandVector::allocator_type(zone)),
-      instruction_args(InstructionOperandVector::allocator_type(zone)),
-      pushed_nodes(NodeVector::allocator_type(zone)) {
+      output_nodes(zone),
+      outputs(zone),
+      instruction_args(zone),
+      pushed_nodes(zone) {
   output_nodes.reserve(d->ReturnCount());
   outputs.reserve(d->ReturnCount());
   pushed_nodes.reserve(input_count());
   instruction_args.reserve(input_count() + control_count() +
                            frame_state_value_count());
 }
 
 
 // TODO(bmeurer): Get rid of the CallBuffer business and make
 // InstructionSelector::VisitCall platform independent instead.
@@ skipping 795 matching lines @@
     inputs->push_back(UseOrImmediate(&g, stack->InputAt(i)));
   }
 }
 
 
 void InstructionSelector::VisitDeoptimize(Node* deopt) {
   DCHECK(deopt->op()->opcode() == IrOpcode::kDeoptimize);
   Node* state = deopt->InputAt(0);
   FrameStateDescriptor* descriptor = GetFrameStateDescriptor(state);
 
-  InstructionOperandVector inputs(
-      (InstructionOperandVector::allocator_type(zone())));
+  InstructionOperandVector inputs(zone());
   inputs.reserve(descriptor->size());
 
   AddFrameStateInputs(state, &inputs, descriptor);
 
   DCHECK_EQ(descriptor->size(), inputs.size());
 
   int deoptimization_id = sequence()->AddDeoptimizationEntry(descriptor);
   Emit(kArchDeoptimize | MiscField::encode(deoptimization_id), 0, NULL,
        inputs.size(), &inputs.front(), 0, NULL);
 }
@@ skipping 37 matching lines @@
 
 
 void InstructionSelector::VisitCall(Node* call, BasicBlock* continuation,
                                     BasicBlock* deoptimization) {}
 
 #endif  // !V8_TURBOFAN_BACKEND
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8