Improve use of CfgLocalAllocator and introduce containers that use it.

src/IceDefs.h

 //===- subzero/src/IceDefs.h - Common Subzero declarations ------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 127 matching lines @@
 
 #define ENABLE_MAKE_UNIQUE friend struct ::Ice::Internal::MakeUniqueEnabler
 
 using IceString = std::string;
 using InstList = llvm::ilist<Inst>;
 // Ideally PhiList would be llvm::ilist<InstPhi>, and similar for AssignList,
 // but this runs into issues with SFINAE.
 using PhiList = InstList;
 using AssignList = InstList;
 
+// Standard library containers with CfgLocalAllocator.
+template <typename T> using CfgVector = std::vector<T, CfgLocalAllocator<T>>;
+template <typename T> using CfgList = std::list<T, CfgLocalAllocator<T>>;
+
 // Containers that are arena-allocated from the Cfg's allocator.
-using OperandList = std::vector<Operand *, CfgLocalAllocator<Operand *>>;
-using VarList = std::vector<Variable *, CfgLocalAllocator<Variable *>>;
-using NodeList = std::vector<CfgNode *, CfgLocalAllocator<CfgNode *>>;
+using OperandList = CfgVector<Operand *>;
+using VarList = CfgVector<Variable *>;
+using NodeList = CfgVector<CfgNode *>;
 
 // Contains that use the default (global) allocator.
 using ConstantList = std::vector<Constant *>;
 using FunctionDeclarationList = std::vector<FunctionDeclaration *>;
 using VariableDeclarationList = std::vector<VariableDeclaration *>;
 
 /// SizeT is for holding small-ish limits like number of source operands in an
 /// instruction. It is used instead of size_t (which may be 64-bits wide) when
 /// we want to save space.
 using SizeT = uint32_t;
 
 /// InstNumberT is for holding an instruction number. Instruction numbers are
 /// used for representing Variable live ranges.
 using InstNumberT = int32_t;
 
 /// A LiveBeginEndMapEntry maps a Variable::Number value to an Inst::Number
 /// value, giving the instruction number that begins or ends a variable's live
 /// range.
 using LiveBeginEndMapEntry = std::pair<SizeT, InstNumberT>;
-using LiveBeginEndMap =
-    std::vector<LiveBeginEndMapEntry, CfgLocalAllocator<LiveBeginEndMapEntry>>;
+using LiveBeginEndMap = CfgVector<LiveBeginEndMapEntry>;
 using LivenessBV = llvm::BitVector;
 
 using TimerStackIdT = uint32_t;
 using TimerIdT = uint32_t;
 
 /// Use alignas(MaxCacheLineSize) to isolate variables/fields that might be
 /// contended while multithreading. Assumes the maximum cache line size is 64.
 enum { MaxCacheLineSize = 64 };
 // Use ICE_CACHELINE_BOUNDARY to force the next field in a declaration
 // list to be aligned to the next cache line.
@@ skipping 104 matching lines @@
   RPE_GlobalVariableReordering,
   RPE_NopInsertion,
   RPE_PooledConstantReordering,
   RPE_RegAllocRandomization,
   RPE_num
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEDEFS_H