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

src/IceTypes.cpp

 //===- subzero/src/IceTypes.cpp - Primitive type properties ---------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 115 matching lines @@
         IceType_##CompareResult                                                \
   }                                                                            \
   ,
     ICETYPE_PROPS_TABLE
 #undef X
 };
 
 } // end anonymous namespace
 
 const char *targetArchString(const TargetArch Arch) {
-  size_t Index = static_cast<size_t>(Arch);
-  if (Index < TargetArch_NUM)
-    return TargetArchName[Index];
+  if (Arch < TargetArch_NUM)
+    return TargetArchName[Arch];
   llvm_unreachable("Invalid target arch for targetArchString");
   return "???";
 }
 
 size_t typeWidthInBytes(Type Ty) {
   int8_t Shift = typeWidthInBytesLog2(Ty);
   return (Shift < 0) ? 0 : 1 << Shift;
 }
 
 int8_t typeWidthInBytesLog2(Type Ty) {
-  size_t Index = static_cast<size_t>(Ty);
-  if (Index < IceType_NUM)
-    return TypeAttributes[Index].TypeWidthInBytesLog2;
+  if (Ty < IceType_NUM)
+    return TypeAttributes[Ty].TypeWidthInBytesLog2;
   llvm_unreachable("Invalid type for typeWidthInBytesLog2()");
   return 0;
 }
 
 size_t typeAlignInBytes(Type Ty) {
-  size_t Index = static_cast<size_t>(Ty);
-  if (Index < IceType_NUM)
-    return TypeAttributes[Index].TypeAlignInBytes;
+  if (Ty < IceType_NUM)
+    return TypeAttributes[Ty].TypeAlignInBytes;
   llvm_unreachable("Invalid type for typeAlignInBytes()");
   return 1;
 }
 
 size_t typeNumElements(Type Ty) {
-  size_t Index = static_cast<size_t>(Ty);
-  if (Index < IceType_NUM)
-    return TypeAttributes[Index].TypeNumElements;
+  if (Ty < IceType_NUM)
+    return TypeAttributes[Ty].TypeNumElements;
   llvm_unreachable("Invalid type for typeNumElements()");
   return 1;
 }
 
 Type typeElementType(Type Ty) {
-  size_t Index = static_cast<size_t>(Ty);
-  if (Index < IceType_NUM)
-    return TypeAttributes[Index].TypeElementType;
+  if (Ty < IceType_NUM)
+    return TypeAttributes[Ty].TypeElementType;
   llvm_unreachable("Invalid type for typeElementType()");
   return IceType_void;
 }
 
 bool isVectorType(Type Ty) {
-  size_t Index = static_cast<size_t>(Ty);
-  if (Index < IceType_NUM)
-    return TypePropertiesTable[Index].TypeIsVectorType;
+  if (Ty < IceType_NUM)
+    return TypePropertiesTable[Ty].TypeIsVectorType;
   llvm_unreachable("Invalid type for isVectorType()");
   return false;
 }
 
 bool isIntegerType(Type Ty) {
-  size_t Index = static_cast<size_t>(Ty);
-  if (Index < IceType_NUM)
-    return TypePropertiesTable[Index].TypeIsIntegerType;
+  if (Ty < IceType_NUM)
+    return TypePropertiesTable[Ty].TypeIsIntegerType;
   llvm_unreachable("Invalid type for isIntegerType()");
   return false;
 }
 
 bool isScalarIntegerType(Type Ty) {
-  size_t Index = static_cast<size_t>(Ty);
-  if (Index < IceType_NUM)
-    return TypePropertiesTable[Index].TypeIsScalarIntegerType;
+  if (Ty < IceType_NUM)
+    return TypePropertiesTable[Ty].TypeIsScalarIntegerType;
   llvm_unreachable("Invalid type for isScalIntegerType()");
   return false;
 }
 
 bool isVectorIntegerType(Type Ty) {
-  size_t Index = static_cast<size_t>(Ty);
-  if (Index < IceType_NUM)
-    return TypePropertiesTable[Index].TypeIsVectorIntegerType;
+  if (Ty < IceType_NUM)
+    return TypePropertiesTable[Ty].TypeIsVectorIntegerType;
   llvm_unreachable("Invalid type for isVectorIntegerType()");
   return false;
 }
 
 bool isIntegerArithmeticType(Type Ty) {
-  size_t Index = static_cast<size_t>(Ty);
-  if (Index < IceType_NUM)
-    return TypePropertiesTable[Index].TypeIsIntegerArithmeticType;
+  if (Ty < IceType_NUM)
+    return TypePropertiesTable[Ty].TypeIsIntegerArithmeticType;
   llvm_unreachable("Invalid type for isIntegerArithmeticType()");
   return false;
 }
 
 bool isFloatingType(Type Ty) {
-  size_t Index = static_cast<size_t>(Ty);
-  if (Index < IceType_NUM)
-    return TypePropertiesTable[Index].TypeIsFloatingType;
+  if (Ty < IceType_NUM)
+    return TypePropertiesTable[Ty].TypeIsFloatingType;
   llvm_unreachable("Invalid type for isFloatingType()");
   return false;
 }
 
 bool isScalarFloatingType(Type Ty) {
-  size_t Index = static_cast<size_t>(Ty);
-  if (Index < IceType_NUM)
-    return TypePropertiesTable[Index].TypeIsScalarFloatingType;
+  if (Ty < IceType_NUM)
+    return TypePropertiesTable[Ty].TypeIsScalarFloatingType;
   llvm_unreachable("Invalid type for isScalarFloatingType()");
   return false;
 }
 
 bool isVectorFloatingType(Type Ty) {
-  size_t Index = static_cast<size_t>(Ty);
-  if (Index < IceType_NUM)
-    return TypePropertiesTable[Index].TypeIsVectorFloatingType;
+  if (Ty < IceType_NUM)
+    return TypePropertiesTable[Ty].TypeIsVectorFloatingType;
   llvm_unreachable("Invalid type for isVectorFloatingType()");
   return false;
 }
 
 bool isLoadStoreType(Type Ty) {
-  size_t Index = static_cast<size_t>(Ty);
-  if (Index < IceType_NUM)
-    return TypePropertiesTable[Index].TypeIsLoadStoreType;
+  if (Ty < IceType_NUM)
+    return TypePropertiesTable[Ty].TypeIsLoadStoreType;
   llvm_unreachable("Invalid type for isLoadStoreType()");
   return false;
 }
 
 bool isCallParameterType(Type Ty) {
-  size_t Index = static_cast<size_t>(Ty);
-  if (Index < IceType_NUM)
-    return TypePropertiesTable[Index].TypeIsCallParameterType;
+  if (Ty < IceType_NUM)
+    return TypePropertiesTable[Ty].TypeIsCallParameterType;
   llvm_unreachable("Invalid type for isCallParameterType()");
   return false;
 }
 
 Type getCompareResultType(Type Ty) {
-  size_t Index = static_cast<size_t>(Ty);
-  if (Index < IceType_NUM)
-    return TypePropertiesTable[Index].CompareResultType;
+  if (Ty < IceType_NUM)
+    return TypePropertiesTable[Ty].CompareResultType;
   llvm_unreachable("Invalid type for getCompareResultType");
   return IceType_void;
 }
 
 SizeT getScalarIntBitWidth(Type Ty) {
   assert(isScalarIntegerType(Ty));
   if (Ty == IceType_i1)
     return 1;
   return typeWidthInBytes(Ty) * CHAR_BIT;
 }
 
 // ======================== Dump routines ======================== //
 
 const char *typeString(Type Ty) {
-  size_t Index = static_cast<size_t>(Ty);
-  if (Index < IceType_NUM)
-    return TypeAttributes[Index].DisplayString;
+  if (Ty < IceType_NUM)
+    return TypeAttributes[Ty].DisplayString;
   llvm_unreachable("Invalid type for typeString");
   return "???";
 }
 
 const char *regClassString(RegClass C) {
   if (static_cast<size_t>(C) < IceType_NUM)
     return TypeAttributes[C].RegClassString;
   llvm_unreachable("Invalid type for regClassString");
   return "???";
 }
 
 void FuncSigType::dump(Ostream &Stream) const {
   if (!BuildDefs::dump())
     return;
   Stream << ReturnType << " (";
   bool IsFirst = true;
   for (const Type ArgTy : ArgList) {
     if (IsFirst) {
       IsFirst = false;
     } else {
       Stream << ", ";
     }
     Stream << ArgTy;
   }
   Stream << ")";
 }
 
 } // end of namespace Ice