Fix call instructions to check parameter types for consistency.

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 19 matching lines @@
 
 // Define a temporary set of enum values based on ICETYPE_TABLE
 enum {
 #define X(tag, sizeLog2, 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, IsIntArith, IsLoadStore, CompareResult)  \
+#define X(tag, IsVec, IsInt, IsFloat, IsIntArith, IsLoadStore, IsParam,        \
+          CompareResult)                                                       \
   _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, sizeLog2, align, elts, elty, str)                               \
   static_assert(                                                               \
       (unsigned)_table_tag_##tag == (unsigned)_props_table_tag_##tag,          \
       "Inconsistency between ICETYPE_PROPS_TABLE and ICETYPE_TABLE");
 ICETYPE_TABLE
 #undef X
 // Assert that tags in ICETYPE_PROPS_TABLE is in ICETYPE_TABLE.
-#define X(tag, IsVec, IsInt, IsFloat, IsIntArith, IsLoadStore, CompareResult)  \
+#define X(tag, IsVec, IsInt, IsFloat, IsIntArith, IsLoadStore, IsParam,        \
+          CompareResult)                                                       \
   static_assert(                                                               \
       (unsigned)_table_tag_##tag == (unsigned)_props_table_tag_##tag,          \
       "Inconsistency between ICETYPE_PROPS_TABLE and ICETYPE_TABLE");
 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, sizeLog2, 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, IsIntArith, IsLoadStore, CompareResult)  \
+#define X(tag, IsVec, IsInt, IsFloat, IsIntArith, IsLoadStore, IsParam,        \
+          CompareResult)                                                       \
   _props_table_IsVec_##tag = IsVec,
   ICETYPE_PROPS_TABLE
 #undef X
 };
 // Verify that the number of vector elements is consistent with IsVec.
-#define X(tag, IsVec, IsInt, IsFloat, IsIntArith, IsLoadStore, CompareResult)  \
+#define X(tag, IsVec, IsInt, IsFloat, IsIntArith, IsLoadStore, IsParam,        \
+          CompareResult)                                                       \
   static_assert((_table_elts_##tag > 1) == _props_table_IsVec_##tag,           \
                 "Inconsistent vector specification in ICETYPE_PROPS_TABLE");
 ICETYPE_PROPS_TABLE
 #undef X
 
 struct TypeAttributeFields {
   int8_t TypeWidthInBytesLog2;
   size_t TypeAlignInBytes;
   size_t TypeNumElements;
   Type TypeElementType;
@@ skipping 11 matching lines @@
 struct TypePropertyFields {
   bool TypeIsVectorType;
   bool TypeIsIntegerType;
   bool TypeIsScalarIntegerType;
   bool TypeIsVectorIntegerType;
   bool TypeIsIntegerArithmeticType;
   bool TypeIsFloatingType;
   bool TypeIsScalarFloatingType;
   bool TypeIsVectorFloatingType;
   bool TypeIsLoadStoreType;
+  bool TypeIsCallParameterType;
   Type CompareResultType;
 };
 
 const TypePropertyFields TypePropertiesTable[] = {
-#define X(tag, IsVec, IsInt, IsFloat, IsIntArith, IsLoadStore, CompareResult)  \
+#define X(tag, IsVec, IsInt, IsFloat, IsIntArith, IsLoadStore, IsParam,        \
+          CompareResult)                                                       \
   {                                                                            \
     IsVec, IsInt, IsInt & !IsVec, IsInt & IsVec, IsIntArith, IsFloat,          \
-        IsFloat & !IsVec, IsFloat & IsVec, IsLoadStore, CompareResult          \
+        IsFloat & !IsVec, IsFloat & IsVec, IsLoadStore, IsParam, CompareResult \
   }                                                                            \
   ,
     ICETYPE_PROPS_TABLE
 #undef X
 };
 
 } // end anonymous namespace
 
 const char *targetArchString(const TargetArch Arch) {
   size_t Index = static_cast<size_t>(Arch);
@@ skipping 105 matching lines @@
 }
 
 bool isLoadStoreType(Type Ty) {
   size_t Index = static_cast<size_t>(Ty);
   if (Index < IceType_NUM)
     return TypePropertiesTable[Index].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;
+  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;
   llvm_unreachable("Invalid type for getCompareResultType");
   return IceType_void;
 }
 
 SizeT getScalarIntBitWidth(Type Ty) {
   assert(isScalarIntegerType(Ty));
@@ skipping 22 matching lines @@
       IsFirst = false;
     } else {
       Stream << ", ";
     }
     Stream << ArgTy;
   }
   Stream << ")";
 }
 
 } // end of namespace Ice