Start processing function blocks in Subzero.

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.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines a few attributes of Subzero primitive types.
 //
 //===----------------------------------------------------------------------===//
 
 #include "IceDefs.h"
 #include "IceTypes.h"
 
+#include "llvm/ADT/STLExtras.h"
+
 namespace Ice {
 
 namespace {
 
+// Dummy function to make sure the two type tables have the same
+// enumerated types.
+void xIceTypeMacroIntegrityCheck() {
+
+  // Show tags match between ICETYPE_TABLE and ICETYPE_PROPS_TABLE.
+
+  // Define a temporary set of enum values based on ICETYPE_TABLE
+  enum {
+#define X(tag, size, align, elts, elty, str) _table_tag_##tag,
+    ICETYPE_TABLE
+#undef X
+        _enum_table_tag_Names
+  };
+  // Define a temporary set of enum values based on ICETYPE_PROPS_TABLE
+  enum {
+#define X(tag, IsVec, IsInt, IsFloat) _props_table_tag_##tag,
+    ICETYPE_PROPS_TABLE
+#undef X
+        _enum_props_table_tag_Names
+  };
+// Assert that tags in ICETYPE_TABLE are also in ICETYPE_PROPS_TABLE.
+#define X(tag, size, align, elts, elty, str)                                   \
+  STATIC_ASSERT((unsigned)_table_tag_##tag == (unsigned)_props_table_tag_##tag);
+  ICETYPE_TABLE;
+#undef X
+// Assert that tags in ICETYPE_PROPS_TABLE is in ICETYPE_TABLE.
+#define X(tag, IsVec, IsInt, IsFloat)                                          \
+  STATIC_ASSERT((unsigned)_table_tag_##tag == (unsigned)_props_table_tag_##tag);
+  ICETYPE_PROPS_TABLE;
+#undef X
+
+  // Show vector definitions match in ICETYPE_TABLE and
+  // ICETYPE_PROPS_TABLE.
+
+  // Define constants for each element size in ICETYPE_TABLE.
+  enum {
+#define X(tag, size, align, elts, elty, str) _table_elts_##tag = elts,
+    ICETYPE_TABLE
+#undef X
+        _enum_table_elts_Elements = 0
+  };
+  // Define constants for boolean flag if vector in ICETYPE_PROPS_TABLE.
+  enum {
+#define X(tag, IsVec, IsInt, IsFloat) _props_table_IsVec_##tag = IsVec,
+    ICETYPE_PROPS_TABLE
+#undef X
+  };
+// Verify Number vector elements consistent with IsVec.

[jvoung (off chromium), 2014/07/25 22:42:08]

nit: "Verify Number vector" -> "Verify that the number of elements is
consistent..." ?

[Karl, 2014/07/30 20:16:15]

Done.

+#define X(tag, IsVec, IsInt, IsFloat)                                          \
+  STATIC_ASSERT((_table_elts_##tag > 1) == _props_table_IsVec_##tag);
+  ICETYPE_PROPS_TABLE;
+#undef X
+}
+
 const struct {
   size_t TypeWidthInBytes;
   size_t TypeAlignInBytes;
   size_t TypeNumElements;
   Type TypeElementType;
   const char *DisplayString;
 } TypeAttributes[] = {
 #define X(tag, size, align, elts, elty, str)                                   \
   { size, align, elts, elty, str }                                             \
   ,
     ICETYPE_TABLE
 #undef X
   };
 
 const size_t TypeAttributesSize =

[Karl, 2014/07/30 20:16:15]

Removed this and replaced with llvm::array_lengthof

     sizeof(TypeAttributes) / sizeof(*TypeAttributes);
 
 } // end anonymous namespace
 
 size_t typeWidthInBytes(Type Ty) {
   size_t Width = 0;
   size_t Index = static_cast<size_t>(Ty);
   if (Index < TypeAttributesSize) {
     Width = TypeAttributes[Index].TypeWidthInBytes;
   } else {
     llvm_unreachable("Invalid type for typeWidthInBytes()");
   }
   return Width;
 }
 
 size_t typeAlignInBytes(Type Ty) {
   size_t Align = 0;
   size_t Index = static_cast<size_t>(Ty);
   if (Index < TypeAttributesSize) {

[Karl, 2014/07/30 20:16:15]

Simplified this (and subsequent functions) to not use else clause.

     Align = TypeAttributes[Index].TypeAlignInBytes;
   } else {
     llvm_unreachable("Invalid type for typeAlignInBytes()");
   }
   return Align;
 }
 
 size_t typeNumElements(Type Ty) {
   size_t NumElements = 0;
   size_t Index = static_cast<size_t>(Ty);
   if (Index < TypeAttributesSize) {
     NumElements = TypeAttributes[Index].TypeNumElements;
   } else {
     llvm_unreachable("Invalid type for typeNumElements()");
   }
   return NumElements;
 }
 
 Type typeElementType(Type Ty) {
   Type ElementType = IceType_void;
   size_t Index = static_cast<size_t>(Ty);
   if (Index < TypeAttributesSize) {
     ElementType = TypeAttributes[Index].TypeElementType;
   } else {
     llvm_unreachable("Invalid type for typeElementType()");
   }
   return ElementType;
 }
 
+namespace {
+
+static const bool IsVectorTable[] = {
+#define X(tag, IsVec, IsInt, IsFloat) IsVec,
+    ICETYPE_PROPS_TABLE
+#undef X
+};
+
+} // end anonymous namespace
+
+bool isVectorType(Type Ty) {
+  size_t Index = static_cast<size_t>(Ty);
+  if (Index < llvm::array_lengthof(IsVectorTable))
+    return IsVectorTable[Index];
+  llvm_unreachable("Invalid type for isVectorType()");
+}
+
+namespace {
+
+static const bool IsScalarIntegerTable[] = {
+#define X(tag, IsVec, IsInt, IsFloat) IsInt && !IsVec,
+    ICETYPE_PROPS_TABLE
+#undef X
+};
+
+} // end anonymous namespace

[jvoung (off chromium), 2014/07/25 22:42:09]

I think it would be nicer to just have all the tables in a contiguous anonymous
namespace.

Or one table of structs, where you can initialize the fields of the structs
based on the table elements (haven't visualized if that would be too confusing
or not though)... and the getter would be like TypeProps[Index].IsScalarInteger,
TypeProps[Index].IsVectorInteger, etc. ?

[Karl, 2014/07/30 20:16:15]

Merged into a single table of structs.

+
+bool isScalarIntegerType(Type Ty) {
+  size_t Index = static_cast<size_t>(Ty);
+  if (Index < llvm::array_lengthof(IsScalarIntegerTable))
+    return IsScalarIntegerTable[Index];
+  llvm_unreachable("Invalid type for isScalIntegerType()");
+}
+
+namespace {
+
+static const bool IsVectorIntegerTable[] = {
+#define X(tag, IsVec, IsInt, IsFloat) IsInt &&IsVec,

[jvoung (off chromium), 2014/07/25 22:42:08]

space between && and IsVec

[Karl, 2014/07/30 20:16:15]

Done.

+    ICETYPE_PROPS_TABLE
+#undef X
+};
+
+} // end anonymous namespace
+
+bool isVectorIntegerType(Type Ty) {
+  size_t Index = static_cast<size_t>(Ty);
+  if (Index < llvm::array_lengthof(IsVectorIntegerTable))
+    return IsVectorIntegerTable[Index];
+  llvm_unreachable("Invalid type for IsVectorIntegerType()");
+}
+
+namespace {
+
+static const bool IsScalarFloatingTable[] = {
+#define X(tag, IsVec, IsInt, IsFloat) IsFloat && !IsVec,
+    ICETYPE_PROPS_TABLE
+#undef X
+};
+
+} // end anonymous namespace
+
+bool isScalarFloatingType(Type Ty) {
+  size_t Index = static_cast<size_t>(Ty);
+  if (Index < llvm::array_lengthof(IsScalarFloatingTable))
+    return IsScalarFloatingTable[Index];
+  llvm_unreachable("Invalid type for IsScalarFloatingType()");
+}
+
+namespace {
+
+static const bool IsVectorFloatingTable[] = {
+#define X(tag, IsVec, IsInt, IsFloat) IsFloat &&IsVec,

[jvoung (off chromium), 2014/07/25 22:42:09]

space between && and IsVec

[Karl, 2014/07/30 20:16:15]

Done.

+    ICETYPE_PROPS_TABLE
+#undef X
+};
+
+} // end anonymous namespace
+
+bool isVectorFloatingType(Type Ty) {
+  size_t Index = static_cast<size_t>(Ty);
+  if (Index < llvm::array_lengthof(IsVectorFloatingTable))
+    return IsVectorFloatingTable[Index];
+  llvm_unreachable("Invalid type for IsVectorFloatingType()");
+}
+
 // ======================== Dump routines ======================== //
 
-template <> Ostream &operator<<(Ostream &Str, const Type &Ty) {
+Ostream &operator<<(Ostream &Str, const Type &Ty) {
   size_t Index = static_cast<size_t>(Ty);
   if (Index < TypeAttributesSize) {
     Str << TypeAttributes[Index].DisplayString;
   } else {
     Str << "???";
     llvm_unreachable("Invalid type for printing");
   }
 
   return Str;
 }
 
 } // end of namespace Ice