Improve use of CfgLocalAllocator and introduce containers that use it.

src/IceOperand.h

 //===- subzero/src/IceOperand.h - High-level operands -----------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 67 matching lines @@
       return;
     assert(Func);
     dump(Func, Func->getContext()->getStrDump());
   }
   void dump(Ostream &Str) const {
     if (BuildDefs::dump())
       dump(nullptr, Str);
   }
   /// @}
 
+  ~Operand() = default;
+
 protected:
   Operand(OperandKind Kind, Type Ty) : Ty(Ty), Kind(Kind) {
     // It is undefined behavior to have a larger value in the enum
     assert(Kind <= kTarget_Max);
   }
-  virtual ~Operand() = default;
 
   const Type Ty;
   const OperandKind Kind;
   /// Vars and NumVars are initialized by the derived class.
   SizeT NumVars = 0;
   Variable **Vars = nullptr;
 };
 
 template <class StreamType>
 inline StreamType &operator<<(StreamType &Str, const Operand &Op) {
@@ skipping 243 matching lines @@
 
 /// LiveRange is a set of instruction number intervals representing a variable's
 /// live range. Generally there is one interval per basic block where the
 /// variable is live, but adjacent intervals get coalesced into a single
 /// interval.
 class LiveRange {
 public:
   LiveRange() = default;
   /// Special constructor for building a kill set. The advantage is that we can
   /// reserve the right amount of space in advance.
-  explicit LiveRange(const std::vector<InstNumberT> &Kills) {
+  explicit LiveRange(const CfgVector<InstNumberT> &Kills) {
     Range.reserve(Kills.size());
     for (InstNumberT I : Kills)
       addSegment(I, I);
   }
   LiveRange(const LiveRange &) = default;
   LiveRange &operator=(const LiveRange &) = default;
 
   void reset() {
     Range.clear();
     untrim();
@@ skipping 13 matching lines @@
   }
 
   void untrim() { TrimmedBegin = Range.begin(); }
   void trim(InstNumberT Lower);
 
   void dump(Ostream &Str) const;
 
 private:
   using RangeElementType = std::pair<InstNumberT, InstNumberT>;
   /// RangeType is arena-allocated from the Cfg's allocator.
-  using RangeType =
-      std::vector<RangeElementType, CfgLocalAllocator<RangeElementType>>;
+  using RangeType = CfgVector<RangeElementType>;
   RangeType Range;
   /// TrimmedBegin is an optimization for the overlaps() computation. Since the
   /// linear-scan algorithm always calls it as overlaps(Cur) and Cur advances
   /// monotonically according to live range start, we can optimize overlaps() by
   /// ignoring all segments that end before the start of Cur's range. The
   /// linear-scan code enables this by calling trim() on the ranges of interest
   /// as Cur advances. Note that linear-scan also has to initialize TrimmedBegin
   /// at the beginning by calling untrim().
   RangeType::const_iterator TrimmedBegin;
 };
@@ skipping 146 matching lines @@
   Variable *HiVar = nullptr;
   /// VarsReal (and Operand::Vars) are set up such that Vars[0] == this.
   Variable *VarsReal[1];
 };
 
 enum MetadataKind {
   VMK_Uses,       /// Track only uses, not defs
   VMK_SingleDefs, /// Track uses+defs, but only record single def
   VMK_All         /// Track uses+defs, including full def list
 };
-using InstDefList = std::vector<const Inst *, CfgLocalAllocator<const Inst *>>;
+using InstDefList = CfgVector<const Inst *>;
 
 /// VariableTracking tracks the metadata for a single variable.  It is
 /// only meant to be used internally by VariablesMetadata.
 class VariableTracking {
   VariableTracking &operator=(const VariableTracking &) = delete;
 
 public:
   enum MultiDefState {
     // TODO(stichnot): Consider using just a simple counter.
     MDS_Unknown,
@@ skipping 75 matching lines @@
   /// isMultiBlock() returns false. Otherwise, nullptr is returned.
   CfgNode *getLocalUseNode(const Variable *Var) const;
 
   /// Returns the total use weight computed as the sum of uses multiplied by a
   /// loop nest depth factor for each use.
   RegWeight getUseWeight(const Variable *Var) const;
 
 private:
   const Cfg *Func;
   MetadataKind Kind;
-  std::vector<VariableTracking> Metadata;
+  CfgVector<VariableTracking> Metadata;
   const static InstDefList NoDefinitions;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H