Subzero: Clean up some uses of *_cast<>.

src/IceTargetLoweringX8664Traits.h

 //===- subzero/src/IceTargetLoweringX8664Traits.h - x86-64 traits -*- C++ -*-=//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 766 matching lines @@
   /// Value is in bytes. Return Value adjusted to the next highest multiple of
   /// the stack alignment.
   static uint32_t applyStackAlignment(uint32_t Value) {
     return Utils::applyAlignment(Value, X86_STACK_ALIGNMENT_BYTES);
   }
 
   /// Return the type which the elements of the vector have in the X86
   /// representation of the vector.
   static Type getInVectorElementType(Type Ty) {
     assert(isVectorType(Ty));
-    size_t Index = static_cast<size_t>(Ty);
-    (void)Index;
-    assert(Index < TableTypeX8664AttributesSize);
+    assert(Ty < TableTypeX8664AttributesSize);
     return TableTypeX8664Attributes[Ty].InVectorElementType;
   }
 
   // Note: The following data structures are defined in
   // IceTargetLoweringX8664.cpp.
 
   /// The following table summarizes the logic for lowering the fcmp
   /// instruction. There is one table entry for each of the 16 conditions.
   ///
   /// The first four columns describe the case when the operands are floating
@@ skipping 34 matching lines @@
   /// conditional branches are needed. For the other conditions, three separate
   /// conditional branches are needed.
   /// {@
   static const struct TableIcmp64Type {
     Cond::BrCond C1, C2, C3;
   } TableIcmp64[];
   static const size_t TableIcmp64Size;
   /// @}
 
   static Cond::BrCond getIcmp32Mapping(InstIcmp::ICond Cond) {
-    size_t Index = static_cast<size_t>(Cond);
-    assert(Index < TableIcmp32Size);
-    return TableIcmp32[Index].Mapping;
+    assert(Cond < TableIcmp32Size);
+    return TableIcmp32[Cond].Mapping;
   }
 
   static const struct TableTypeX8664AttributesType {
     Type InVectorElementType;
   } TableTypeX8664Attributes[];
   static const size_t TableTypeX8664AttributesSize;
 
   //----------------------------------------------------------------------------
   //      __  __   __  ______  ______
   //    /\ \/\ "-.\ \/\  ___\/\__  _\
@@ skipping 140 matching lines @@
   /// slot.
   class SpillVariable : public Variable {
     SpillVariable() = delete;
     SpillVariable(const SpillVariable &) = delete;
     SpillVariable &operator=(const SpillVariable &) = delete;
 
   public:
     static SpillVariable *create(Cfg *Func, Type Ty, SizeT Index) {
       return new (Func->allocate<SpillVariable>()) SpillVariable(Ty, Index);
     }
-    const static OperandKind SpillVariableKind =
+    const static auto SpillVariableKind =

[John, 2016/02/07 16:18:33]

While at this, constexpr?

[Jim Stichnoth, 2016/02/07 16:42:42]

Done.

         static_cast<OperandKind>(kVariable_Target);
     static bool classof(const Operand *Operand) {
       return Operand->getKind() == SpillVariableKind;
     }
     void setLinkedTo(Variable *Var) { LinkedTo = Var; }
     Variable *getLinkedTo() const { return LinkedTo; }
     // Inherit dump() and emit() from Variable.
 
   private:
     SpillVariable(Type Ty, SizeT Index)
@@ skipping 23 matching lines @@
     const char *FldString;   // s, l, or <blank>
   } TypeAttributes[];
 };
 
 using Traits = ::Ice::X8664::TargetX8664Traits;
 } // end of namespace X8664
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICETARGETLOWERINGX8664TRAITS_H