Change some explicit type checks into using helper functions.

src/IceTypes.h

 //===- subzero/src/IceTypes.h - Primitive ICE types -------------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares a few properties of the primitive types allowed
@@ skipping 51 matching lines @@
 bool isLoadStoreType(Type Ty);
 
 /// Returns type generated by applying the compare instructions (icmp and fcmp)
 /// to arguments of the given type. Returns IceType_void if compare is not
 /// allowed.
 Type getCompareResultType(Type Ty);
 
 /// Returns the number of bits in a scalar integer type.
 SizeT getScalarIntBitWidth(Type Ty);
 
+// Check if a type is byte sized (slight optimization over typeWidthInBytes).
+inline bool isByteSizedType(Type Ty) {
+  bool result = Ty == IceType_i8 || Ty == IceType_i1;
+  assert(result == (1 == typeWidthInBytes(Ty)));
+  return result;
+}
+
+// Check if Ty is byte sized and specifically i8. Assert that it's not
+// byte sized due to being an i1.
+inline bool isByteSizedArithType(Type Ty) {
+  assert(Ty != IceType_i1);
+  return Ty == IceType_i8;
+}
+
+// Assuming Ty is either i32 or i64, return true if Ty is i32.
+inline bool isInt32Assuming32Or64(Type Ty) {

[jvoung (off chromium), 2014/09/27 00:23:39]

Hmm different name suggestions welcome

[Jim Stichnoth, 2014/09/27 00:38:22]

I guess my suggestion would be
  isI32AssumingI32OrI64()
  isF32AssumingF32OrF64()

Another thought is to use Asserting instead of Assuming?  That might help convey
the possibly unexpected side effect of the isFoo() function, i.e. possibly
throwing an assertion failure.

[jvoung (off chromium), 2014/09/29 16:10:51]

Going with "Asserting" instead of "Assuming"

+  bool result = Ty == IceType_i32;
+  assert(result || Ty == IceType_i64);
+  return result;
+}
+
+// Assuming Ty is either f32 or f64, return true if Ty is f32.
+inline bool isFloat32Assuming32Or64(Type Ty) {
+  bool result = Ty == IceType_f32;
+  assert(result || Ty == IceType_f64);
+  return result;
+}
+
 template <typename StreamType>
 inline StreamType &operator<<(StreamType &Str, const Type &Ty) {
   Str << typeString(Ty);
   return Str;
 }
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICETYPES_H