Refactor all instances of `typedef y x` to the C++11 `using x = y` syntax.

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 120 matching lines @@
 } // end of namespace Internal
 
 template <class T, class... Args>
 static std::unique_ptr<T> makeUnique(Args &&... TheArgs) {
   return ::Ice::Internal::MakeUniqueEnabler::create<T>(
       std::forward<Args>(TheArgs)...);
 }
 
 #define ENABLE_MAKE_UNIQUE friend struct ::Ice::Internal::MakeUniqueEnabler
 
-typedef std::string IceString;
-typedef llvm::ilist<Inst> InstList;
+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.
-typedef InstList PhiList;
-typedef InstList AssignList;
+using PhiList = InstList;
+using AssignList = InstList;
 
 // Containers that are arena-allocated from the Cfg's allocator.
-typedef std::vector<Operand *, CfgLocalAllocator<Operand *>> OperandList;
-typedef std::vector<Variable *, CfgLocalAllocator<Variable *>> VarList;
-typedef std::vector<CfgNode *, CfgLocalAllocator<CfgNode *>> NodeList;
+using OperandList = std::vector<Operand *, CfgLocalAllocator<Operand *>>;
+using VarList = std::vector<Variable *, CfgLocalAllocator<Variable *>>;
+using NodeList = std::vector<CfgNode *, CfgLocalAllocator<CfgNode *>>;
 
 // Contains that use the default (global) allocator.
-typedef std::vector<Constant *> ConstantList;
-typedef std::vector<FunctionDeclaration *> FunctionDeclarationList;
-typedef std::vector<VariableDeclaration *> VariableDeclarationList;
+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.
-typedef uint32_t SizeT;
+using SizeT = uint32_t;
 
 /// InstNumberT is for holding an instruction number.  Instruction
 /// numbers are used for representing Variable live ranges.
-typedef int32_t InstNumberT;
+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.
-typedef std::pair<SizeT, InstNumberT> LiveBeginEndMapEntry;
-typedef std::vector<LiveBeginEndMapEntry,
-                    CfgLocalAllocator<LiveBeginEndMapEntry>> LiveBeginEndMap;
-typedef llvm::BitVector LivenessBV;
+using LiveBeginEndMapEntry = std::pair<SizeT, InstNumberT>;
+using LiveBeginEndMap =
+    std::vector<LiveBeginEndMapEntry, CfgLocalAllocator<LiveBeginEndMapEntry>>;
+using LivenessBV = llvm::BitVector;
 
-typedef uint32_t TimerStackIdT;
-typedef uint32_t TimerIdT;
+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.
 // Note: zero is added to work around the following GCC 4.8 bug (fixed in 4.9):
 //       https://gcc.gnu.org/bugzilla/show_bug.cgi?id=55382
 #define ICE_CACHELINE_BOUNDARY                                                 \
   __attribute__((aligned(MaxCacheLineSize + 0))) int : 0
 
 /// PNaCl is ILP32, so theoretically we should only need 32-bit offsets.
-typedef int32_t RelocOffsetT;
+using RelocOffsetT = int32_t;
 enum { RelocAddrSize = 4 };
 
 enum LivenessMode {
   /// Basic version of live-range-end calculation.  Marks the last uses
   /// of variables based on dataflow analysis.  Records the set of
   /// live-in and live-out variables for each block.  Identifies and
   /// deletes dead instructions (primarily stores).
   Liveness_Basic,
 
   /// In addition to Liveness_Basic, also calculate the complete
@@ skipping 21 matching lines @@
   IceV_LinearScan = 1 << 7,
   IceV_Frame = 1 << 8,
   IceV_AddrOpt = 1 << 9,
   IceV_Random = 1 << 10,
   IceV_Folding = 1 << 11,
   IceV_RMW = 1 << 12,
   IceV_Loop = 1 << 13,
   IceV_All = ~IceV_None,
   IceV_Most = IceV_All & ~IceV_LinearScan
 };
-typedef uint32_t VerboseMask;
+using VerboseMask = uint32_t;
 
 enum FileType {
   FT_Elf, /// ELF .o file
   FT_Asm, /// Assembly .s file
   FT_Iasm /// "Integrated assembler" .byte-style .s file
 };
 
-typedef llvm::raw_ostream Ostream;
-typedef llvm::raw_fd_ostream Fdstream;
+using Ostream = llvm::raw_ostream;
+using Fdstream = llvm::raw_fd_ostream;
 
-typedef std::mutex GlobalLockType;
+using GlobalLockType = std::mutex;
 
 enum ErrorCodes { EC_None = 0, EC_Args, EC_Bitcode, EC_Translation };
 
 /// Wrapper around std::error_code for allowing multiple errors to be
 /// folded into one.  The current implementation keeps track of the
 /// first error, which is likely to be the most useful one, and this
 /// could be extended to e.g. collect a vector of errors.
 class ErrorCode : public std::error_code {
   ErrorCode(const ErrorCode &) = delete;
   ErrorCode &operator=(const ErrorCode &) = delete;
@@ skipping 34 matching lines @@
   RPE_GlobalVariableReordering,
   RPE_NopInsertion,
   RPE_PooledConstantReordering,
   RPE_RegAllocRandomization,
   RPE_num
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEDEFS_H