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

src/IceTargetLoweringX8632.cpp

 //===- subzero/src/IceTargetLoweringX8632.cpp - x86-32 lowering -----------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 102 matching lines @@
   //
   // * Stack arguments of vector type are aligned to start at the next
   // highest multiple of 16 bytes.  Other stack arguments are aligned to
   // 4 bytes.
   //
   // This intends to match the section "IA-32 Function Calling
   // Convention" of the document "OS X ABI Function Call Guide" by
   // Apple.
   NeedsStackAlignment = true;
 
-  typedef std::vector<Operand *> OperandList;
+  using OperandList = std::vector<Operand *>;
   OperandList XmmArgs;
   OperandList StackArgs, StackArgLocations;
   uint32_t ParameterAreaSizeBytes = 0;
 
   // Classify each argument operand according to the location where the
   // argument is passed.
   for (SizeT i = 0, NumArgs = Instr->getNumArgs(); i < NumArgs; ++i) {
     Operand *Arg = Instr->getArg(i);
     Type Ty = Arg->getType();
     // The PNaCl ABI requires the width of arguments to be at least 32 bits.
@@ skipping 512 matching lines @@
   Str << "\n";
 }
 
 TargetDataX8632::TargetDataX8632(GlobalContext *Ctx)
     : TargetDataLowering(Ctx) {}
 
 namespace {
 template <typename T> struct PoolTypeConverter {};
 
 template <> struct PoolTypeConverter<float> {
-  typedef uint32_t PrimitiveIntType;
-  typedef ConstantFloat IceType;
+  using PrimitiveIntType = uint32_t;
+  using IceType = ConstantFloat;
   static const Type Ty = IceType_f32;
   static const char *TypeName;
   static const char *AsmTag;
   static const char *PrintfString;
 };
 const char *PoolTypeConverter<float>::TypeName = "float";
 const char *PoolTypeConverter<float>::AsmTag = ".long";
 const char *PoolTypeConverter<float>::PrintfString = "0x%x";
 
 template <> struct PoolTypeConverter<double> {
-  typedef uint64_t PrimitiveIntType;
-  typedef ConstantDouble IceType;
+  using PrimitiveIntType = uint64_t;
+  using IceType = ConstantDouble;
   static const Type Ty = IceType_f64;
   static const char *TypeName;
   static const char *AsmTag;
   static const char *PrintfString;
 };
 const char *PoolTypeConverter<double>::TypeName = "double";
 const char *PoolTypeConverter<double>::AsmTag = ".quad";
 const char *PoolTypeConverter<double>::PrintfString = "0x%llx";
 
 // Add converter for int type constant pooling
 template <> struct PoolTypeConverter<uint32_t> {
-  typedef uint32_t PrimitiveIntType;
-  typedef ConstantInteger32 IceType;
+  using PrimitiveIntType = uint32_t;
+  using IceType = ConstantInteger32;
   static const Type Ty = IceType_i32;
   static const char *TypeName;
   static const char *AsmTag;
   static const char *PrintfString;
 };
 const char *PoolTypeConverter<uint32_t>::TypeName = "i32";
 const char *PoolTypeConverter<uint32_t>::AsmTag = ".long";
 const char *PoolTypeConverter<uint32_t>::PrintfString = "0x%x";
 
 // Add converter for int type constant pooling
 template <> struct PoolTypeConverter<uint16_t> {
-  typedef uint32_t PrimitiveIntType;
-  typedef ConstantInteger32 IceType;
+  using PrimitiveIntType = uint32_t;
+  using IceType = ConstantInteger32;
   static const Type Ty = IceType_i16;
   static const char *TypeName;
   static const char *AsmTag;
   static const char *PrintfString;
 };
 const char *PoolTypeConverter<uint16_t>::TypeName = "i16";
 const char *PoolTypeConverter<uint16_t>::AsmTag = ".short";
 const char *PoolTypeConverter<uint16_t>::PrintfString = "0x%x";
 
 // Add converter for int type constant pooling
 template <> struct PoolTypeConverter<uint8_t> {
-  typedef uint32_t PrimitiveIntType;
-  typedef ConstantInteger32 IceType;
+  using PrimitiveIntType = uint32_t;
+  using IceType = ConstantInteger32;
   static const Type Ty = IceType_i8;
   static const char *TypeName;
   static const char *AsmTag;
   static const char *PrintfString;
 };
 const char *PoolTypeConverter<uint8_t>::TypeName = "i8";
 const char *PoolTypeConverter<uint8_t>::AsmTag = ".byte";
 const char *PoolTypeConverter<uint8_t>::PrintfString = "0x%x";
 } // end of anonymous namespace
 
@@ skipping 229 matching lines @@
 // entries in case the high-level table has extra entries.
 #define X(tag, sizeLog2, align, elts, elty, str)                               \
   static_assert(_table1_##tag == _table2_##tag,                                \
                 "Inconsistency between ICETYPEX8632_TABLE and ICETYPE_TABLE");
 ICETYPE_TABLE
 #undef X
 } // end of namespace dummy3
 } // end of anonymous namespace
 
 } // end of namespace Ice