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

src/IceAssemblerX86Base.h

 //===- subzero/src/IceAssemblerX86Base.h - base x86 assembler -*- C++ -*---===//
 //
 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 //
 // Modified by the Subzero authors.
 //
 //===----------------------------------------------------------------------===//
 //
@@ skipping 145 matching lines @@
   Label *getOrCreateLocalLabel(SizeT Number);
   void bindLocalLabel(SizeT Number);
 
   bool fixupIsPCRel(FixupKind Kind) const override {
     // Currently assuming this is the only PC-rel relocation type used.
     // TODO(jpp): Traits.PcRelTypes.count(Kind) != 0
     return Kind == Traits::PcRelFixup;
   }
 
   // Operations to emit GPR instructions (and dispatch on operand type).
-  typedef void (AssemblerX86Base::*TypedEmitGPR)(Type,
-                                                 typename Traits::GPRRegister);
-  typedef void (AssemblerX86Base::*TypedEmitAddr)(
-      Type, const typename Traits::Address &);
+  using TypedEmitGPR = void (AssemblerX86Base::*)(Type,
+                                                  typename Traits::GPRRegister);
+  using TypedEmitAddr =
+      void (AssemblerX86Base::*)(Type, const typename Traits::Address &);
   struct GPREmitterOneOp {
     TypedEmitGPR Reg;
     TypedEmitAddr Addr;
   };
 
-  typedef void (AssemblerX86Base::*TypedEmitGPRGPR)(
+  using TypedEmitGPRGPR = void (AssemblerX86Base::*)(
       Type, typename Traits::GPRRegister, typename Traits::GPRRegister);
-  typedef void (AssemblerX86Base::*TypedEmitGPRAddr)(
+  using TypedEmitGPRAddr = void (AssemblerX86Base::*)(
       Type, typename Traits::GPRRegister, const typename Traits::Address &);
-  typedef void (AssemblerX86Base::*TypedEmitGPRImm)(
+  using TypedEmitGPRImm = void (AssemblerX86Base::*)(
       Type, typename Traits::GPRRegister, const Immediate &);
   struct GPREmitterRegOp {
     TypedEmitGPRGPR GPRGPR;
     TypedEmitGPRAddr GPRAddr;
     TypedEmitGPRImm GPRImm;
   };
 
   struct GPREmitterShiftOp {
     // Technically, Addr/GPR and Addr/Imm are also allowed, but */Addr are not.
     // In practice, we always normalize the Dest to a Register first.
     TypedEmitGPRGPR GPRGPR;
     TypedEmitGPRImm GPRImm;
   };
 
-  typedef void (AssemblerX86Base::*TypedEmitGPRGPRImm)(
+  using TypedEmitGPRGPRImm = void (AssemblerX86Base::*)(
       Type, typename Traits::GPRRegister, typename Traits::GPRRegister,
       const Immediate &);
   struct GPREmitterShiftD {
     // Technically AddrGPR and AddrGPRImm are also allowed, but in practice
     // we always normalize Dest to a Register first.
     TypedEmitGPRGPR GPRGPR;
     TypedEmitGPRGPRImm GPRGPRImm;
   };
 
-  typedef void (AssemblerX86Base::*TypedEmitAddrGPR)(
+  using TypedEmitAddrGPR = void (AssemblerX86Base::*)(
       Type, const typename Traits::Address &, typename Traits::GPRRegister);
-  typedef void (AssemblerX86Base::*TypedEmitAddrImm)(
+  using TypedEmitAddrImm = void (AssemblerX86Base::*)(
       Type, const typename Traits::Address &, const Immediate &);
   struct GPREmitterAddrOp {
     TypedEmitAddrGPR AddrGPR;
     TypedEmitAddrImm AddrImm;
   };
 
   // Operations to emit XMM instructions (and dispatch on operand type).
-  typedef void (AssemblerX86Base::*TypedEmitXmmXmm)(
+  using TypedEmitXmmXmm = void (AssemblerX86Base::*)(
       Type, typename Traits::XmmRegister, typename Traits::XmmRegister);
-  typedef void (AssemblerX86Base::*TypedEmitXmmAddr)(
+  using TypedEmitXmmAddr = void (AssemblerX86Base::*)(
       Type, typename Traits::XmmRegister, const typename Traits::Address &);
   struct XmmEmitterRegOp {
     TypedEmitXmmXmm XmmXmm;
     TypedEmitXmmAddr XmmAddr;
   };
 
-  typedef void (AssemblerX86Base::*EmitXmmXmm)(typename Traits::XmmRegister,
-                                               typename Traits::XmmRegister);
-  typedef void (AssemblerX86Base::*EmitXmmAddr)(
+  using EmitXmmXmm = void (AssemblerX86Base::*)(typename Traits::XmmRegister,
+                                                typename Traits::XmmRegister);
+  using EmitXmmAddr = void (AssemblerX86Base::*)(
       typename Traits::XmmRegister, const typename Traits::Address &);
-  typedef void (AssemblerX86Base::*EmitAddrXmm)(
+  using EmitAddrXmm = void (AssemblerX86Base::*)(
       const typename Traits::Address &, typename Traits::XmmRegister);
   struct XmmEmitterMovOps {
     EmitXmmXmm XmmXmm;
     EmitXmmAddr XmmAddr;
     EmitAddrXmm AddrXmm;
   };
 
-  typedef void (AssemblerX86Base::*TypedEmitXmmImm)(
+  using TypedEmitXmmImm = void (AssemblerX86Base::*)(
       Type, typename Traits::XmmRegister, const Immediate &);
 
   struct XmmEmitterShiftOp {
     TypedEmitXmmXmm XmmXmm;
     TypedEmitXmmAddr XmmAddr;
     TypedEmitXmmImm XmmImm;
   };
 
   // Cross Xmm/GPR cast instructions.
   template <typename DReg_t, typename SReg_t> struct CastEmitterRegOp {
-    typedef void (AssemblerX86Base::*TypedEmitRegs)(Type, DReg_t, Type, SReg_t);
-    typedef void (AssemblerX86Base::*TypedEmitAddr)(
+    using TypedEmitRegs = void (AssemblerX86Base::*)(Type, DReg_t, Type,
+                                                     SReg_t);
+    using TypedEmitAddr = void (AssemblerX86Base::*)(
         Type, DReg_t, Type, const typename Traits::Address &);
 
     TypedEmitRegs RegReg;
     TypedEmitAddr RegAddr;
   };
 
   // Three operand (potentially) cross Xmm/GPR instructions.
   // The last operand must be an immediate.
   template <typename DReg_t, typename SReg_t> struct ThreeOpImmEmitter {
-    typedef void (AssemblerX86Base::*TypedEmitRegRegImm)(Type, DReg_t, SReg_t,
-                                                         const Immediate &);
-    typedef void (AssemblerX86Base::*TypedEmitRegAddrImm)(
+    using TypedEmitRegRegImm = void (AssemblerX86Base::*)(Type, DReg_t, SReg_t,
+                                                          const Immediate &);
+    using TypedEmitRegAddrImm = void (AssemblerX86Base::*)(
         Type, DReg_t, const typename Traits::Address &, const Immediate &);
 
     TypedEmitRegRegImm RegRegImm;
     TypedEmitRegAddrImm RegAddrImm;
   };
 
   /*
    * Emit Machine Instructions.
    */
   void call(typename Traits::GPRRegister reg);
@@ skipping 620 matching lines @@
   void emitLabel(Label *label, intptr_t instruction_size);
   void emitLabelLink(Label *label);
   void emitNearLabelLink(Label *label);
 
   void emitGenericShift(int rm, Type Ty, typename Traits::GPRRegister reg,
                         const Immediate &imm);
   void emitGenericShift(int rm, Type Ty,
                         const typename Traits::Operand &operand,
                         typename Traits::GPRRegister shifter);
 
-  typedef std::vector<Label *> LabelVector;
+  using LabelVector = std::vector<Label *>;
   // A vector of pool-allocated x86 labels for CFG nodes.
   LabelVector CfgNodeLabels;
   // A vector of pool-allocated x86 labels for Local labels.
   LabelVector LocalLabels;
 
   Label *getOrCreateLabel(SizeT Number, LabelVector &Labels);
 
   // The arith_int() methods factor out the commonality between the encodings of
   // add(), Or(), adc(), sbb(), And(), sub(), Xor(), and cmp().  The Tag
   // parameter is statically asserted to be less than 8.
@@ skipping 154 matching lines @@
   emitUint8(0x66);
 }
 
 } // end of namespace X86Internal
 
 } // end of namespace Ice
 
 #include "IceAssemblerX86BaseImpl.h"
 
 #endif // SUBZERO_SRC_ICEASSEMBLERX86BASE_H