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

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 141 matching lines @@
 };
 
 /// ConstantPrimitive<> wraps a primitive type.
 template <typename T, Operand::OperandKind K>
 class ConstantPrimitive : public Constant {
   ConstantPrimitive() = delete;
   ConstantPrimitive(const ConstantPrimitive &) = delete;
   ConstantPrimitive &operator=(const ConstantPrimitive &) = delete;
 
 public:
-  typedef T PrimType;
+  using PrimType = T;
 
   static ConstantPrimitive *create(GlobalContext *Ctx, Type Ty, PrimType Value,
                                    uint32_t PoolEntryID) {
     assert(!Ctx->isIRGenerationDisabled() &&
            "Attempt to build primitive constant when IR generation disabled");
     return new (Ctx->allocate<ConstantPrimitive>())
         ConstantPrimitive(Ty, Value, PoolEntryID);
   }
   PrimType getValue() const { return Value; }
   using Constant::emit;
@@ skipping 12 matching lines @@
     (void)Ctx;
     return false;
   }
 
 private:
   ConstantPrimitive(Type Ty, PrimType Value, uint32_t PoolEntryID)
       : Constant(K, Ty, PoolEntryID), Value(Value) {}
   const PrimType Value;
 };
 
-typedef ConstantPrimitive<int32_t, Operand::kConstInteger32> ConstantInteger32;
-typedef ConstantPrimitive<int64_t, Operand::kConstInteger64> ConstantInteger64;
-typedef ConstantPrimitive<float, Operand::kConstFloat> ConstantFloat;
-typedef ConstantPrimitive<double, Operand::kConstDouble> ConstantDouble;
+using ConstantInteger32 = ConstantPrimitive<int32_t, Operand::kConstInteger32>;
+using ConstantInteger64 = ConstantPrimitive<int64_t, Operand::kConstInteger64>;
+using ConstantFloat = ConstantPrimitive<float, Operand::kConstFloat>;
+using ConstantDouble = ConstantPrimitive<double, Operand::kConstDouble>;
 
 template <>
 inline void ConstantInteger32::dump(const Cfg *, Ostream &Str) const {
   if (!BuildDefs::dump())
     return;
   if (getType() == IceType_i1)
     Str << (getValue() ? "true" : "false");
   else
     Str << static_cast<int32_t>(getValue());
 }
@@ skipping 171 matching lines @@
   InstNumberT getEnd() const {
     return Range.empty() ? -1 : Range.rbegin()->second;
   }
 
   void untrim() { TrimmedBegin = Range.begin(); }
   void trim(InstNumberT Lower);
 
   void dump(Ostream &Str) const;
 
 private:
-  typedef std::pair<InstNumberT, InstNumberT> RangeElementType;
+  using RangeElementType = std::pair<InstNumberT, InstNumberT>;
   /// RangeType is arena-allocated from the Cfg's allocator.
-  typedef std::vector<RangeElementType, CfgLocalAllocator<RangeElementType>>
-      RangeType;
+  using RangeType =
+      std::vector<RangeElementType, CfgLocalAllocator<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 149 matching lines @@
   /// 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
 };
-typedef std::vector<const Inst *, CfgLocalAllocator<const Inst *>> InstDefList;
+using InstDefList = std::vector<const Inst *, CfgLocalAllocator<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 85 matching lines @@
 private:
   const Cfg *Func;
   MetadataKind Kind;
   std::vector<VariableTracking> Metadata;
   const static InstDefList NoDefinitions;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H