add maps and sets to zone containers

src/compiler/register-allocator-verifier.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/bit-vector.h"
 #include "src/compiler/instruction.h"
 #include "src/compiler/register-allocator-verifier.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 222 matching lines @@
     operands.insert(operands.begin(), phi->operands().begin(),
                     phi->operands().end());
   }
   const Rpo definition_rpo;
   const int virtual_register;
   const int first_pred_vreg;
   const PhiData* first_pred_phi;
   IntVector operands;
 };
 
-typedef std::map<int, PhiData*, std::less<int>,
-                 zone_allocator<std::pair<int, PhiData*>>> PhiMapBase;
-
-class PhiMap : public PhiMapBase, public ZoneObject {
+class PhiMap : public ZoneMap<int, PhiData*>, public ZoneObject {
  public:
-  explicit PhiMap(Zone* zone)
-      : PhiMapBase(key_compare(), allocator_type(zone)) {}
+  explicit PhiMap(Zone* zone) : ZoneMap<int, PhiData*>(zone) {}
 };
 
 struct OperandLess {
   bool operator()(const InstructionOperand* a,
                   const InstructionOperand* b) const {
     if (a->kind() == b->kind()) return a->index() < b->index();
     return a->kind() < b->kind();
   }
 };
 
 class OperandMap : public ZoneObject {
  public:
   struct MapValue : public ZoneObject {
     MapValue()
         : incoming(nullptr),
           define_vreg(kInvalidVreg),
           use_vreg(kInvalidVreg),
           succ_vreg(kInvalidVreg) {}
     MapValue* incoming;  // value from first predecessor block.
     int define_vreg;     // valid if this value was defined in this block.
     int use_vreg;        // valid if this value was used in this block.
     int succ_vreg;       // valid if propagated back from successor block.
   };
 
-  typedef std::map<
-      const InstructionOperand*, MapValue*, OperandLess,
-      zone_allocator<std::pair<const InstructionOperand*, MapValue*>>> MapBase;
-
-  class Map : public MapBase {
+  class Map
+      : public ZoneMap<const InstructionOperand*, MapValue*, OperandLess> {
    public:
-    explicit Map(Zone* zone) : MapBase(key_compare(), allocator_type(zone)) {}
+    explicit Map(Zone* zone)
+        : ZoneMap<const InstructionOperand*, MapValue*, OperandLess>(zone) {}
 
     // Remove all entries with keys not in other.
     void Intersect(const Map& other) {
       if (this->empty()) return;
       auto it = this->begin();
       OperandLess less;
       for (const auto& o : other) {
         while (less(it->first, o.first)) {
           this->erase(it++);
           if (it == this->end()) return;
@@ skipping 379 matching lines @@
         int virtual_register = op_constraints[count].virtual_register_;
         current->Define(zone(), instr->OutputAt(i), virtual_register);
       }
     }
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8