[Clang] Include size and maximum in vector size error message.

[fhahn]

Summary

The error message for invalid vector sizes can be a bit more helpful by
including the actual maximum. This should match the recently added
suggestions for error messages in the coding standard.

[fhahn]

Fix wrong formatting of check lines..

[fhahn]

With the recent size increase for vector dimensions I am not sure this is too useful.

clang/include/clang/AST/Type.h

 public:
   QualType getElementType() const { return ElementType; }
   unsigned getNumElements() const { return VectorTypeBits.NumElements; }
 
   static bool isVectorSizeTooLarge(unsigned NumElements) {
     return NumElements > VectorTypeBitfields::MaxNumElements;
   }
 
+  static unsigned getMaxNumElements() {
+    return VectorTypeBitfields::MaxNumElements;
+  }
+
   bool isSugared() const { return false; }
   QualType desugar() const { return QualType(this, 0); }
 
   VectorKind getVectorKind() const {
     return VectorKind(VectorTypeBits.VecKind);
   }
 
   void Profile(llvm::FoldingSetNodeID &ID) {

clang/include/clang/Basic/DiagnosticSemaKinds.td

def err_callback_callee_is_variadic : Error<
   "'callback' attribute callee may not be variadic">;
 def err_callback_implicit_this_not_available : Error<
   "'callback' argument at position %0 references unavailable implicit 'this'">;
 def err_init_method_bad_return_type : Error<
   "init methods must return an object pointer type, not %0">;
 def err_attribute_invalid_size : Error<
   "vector size not an integral multiple of component size">;
 def err_attribute_zero_size : Error<"zero vector size">;
-def err_attribute_size_too_large : Error<"vector size too large">;
+def err_attribute_size_too_large : Error<"vector size too large. Size is %0 when the maximum allowed is %1">;
 def err_typecheck_vector_not_convertable_implict_truncation : Error<
    "cannot convert between %select{scalar|vector}0 type %1 and vector type"
    " %2 as implicit conversion would cause truncation">;
 def err_typecheck_vector_not_convertable : Error<
   "cannot convert between vector values of different size (%0 and %1)">;
 def err_typecheck_vector_not_convertable_non_scalar : Error<
   "cannot convert between vector and non-scalar values (%0 and %1)">;
 def err_typecheck_vector_lengths_not_equal : Error<

clang/lib/Sema/SemaType.cpp

QualType Sema::BuildVectorType(QualType CurType, Expr *SizeExpr,
   if (VectorSize % TypeSize) {
     Diag(AttrLoc, diag::err_attribute_invalid_size)
         << SizeExpr->getSourceRange();
     return QualType();
   }
 
   if (VectorType::isVectorSizeTooLarge(VectorSize / TypeSize)) {
     Diag(AttrLoc, diag::err_attribute_size_too_large)
-        << SizeExpr->getSourceRange();
+        // Display sizes in error messages in bytes.
+        << SizeExpr->getSourceRange()
+        << static_cast<unsigned>(VecSize.getZExtValue())
+        << (VectorType::getMaxNumElements() * (TypeSize / 8));
     return QualType();
   }
 
   return Context.getVectorType(CurType, VectorSize / TypeSize,
                                VectorType::GenericVector);
 }
 
 /// Build an ext-vector type.
if (!ArraySize->isTypeDependent() && !ArraySize->isValueDependent()) {
     if (vectorSize == 0) {
       Diag(AttrLoc, diag::err_attribute_zero_size)
       << ArraySize->getSourceRange();
       return QualType();
     }
 
     if (VectorType::isVectorSizeTooLarge(vectorSize)) {
       Diag(AttrLoc, diag::err_attribute_size_too_large)
-        << ArraySize->getSourceRange();
+          << ArraySize->getSourceRange() << vectorSize
+          << VectorType::getMaxNumElements();
       return QualType();
     }
 
     return Context.getExtVectorType(T, vectorSize);
   }
 
   return Context.getDependentSizedExtVectorType(T, ArraySize, AttrLoc);
 }

clang/test/Sema/types.c

 // FIXME: This may or may not be the correct approach (no warning or error),
 // but large amounts of Linux and FreeBSD code need this attribute to not be
 // a hard error in order to work correctly.
 void test2(int i) {
   char c = (char __attribute__((may_alias))) i;
 }
 
 // vector size too large
-int __attribute__ ((vector_size(8192))) x1; // expected-error {{vector size too large}}
-typedef int __attribute__ ((ext_vector_type(8192))) x2; // expected-error {{vector size too large}}
+int __attribute__((vector_size(8192))) x1;             // expected-error {{vector size too large. Size is 8192 when the maximum allowed is 4092}}
+typedef int __attribute__((ext_vector_type(8192))) x2; // expected-error {{vector size too large. Size is 8192 when the maximum allowed is 1023}}
 
 // no support for vector enum type
 enum { e_2 } x3 __attribute__((vector_size(64))); // expected-error {{invalid vector element type}}
 
 int x4 __attribute__((ext_vector_type(64)));  // expected-error {{'ext_vector_type' attribute only applies to typedefs}}
 
 // rdar://16492792
 typedef __attribute__ ((ext_vector_type(32),__aligned__(32))) unsigned char uchar32;

clang/test/SemaCXX/vector.cpp

void Init() {
   // expected-note@+1 {{in instantiation of template class 'Templates::TemplateVectorType<bool, 32>' requested here}}
   const TemplateVectorType<bool, 32>::type NoBool;
   // expected-error@#1 {{invalid vector element type 'int __attribute__((ext_vector_type(4)))' (vector of 4 'int' values)}}
   // expected-note@+1 {{in instantiation of template class 'Templates::TemplateVectorType<int __attribute__((ext_vector_type(4))), 32>' requested here}}
   const TemplateVectorType<vi4, 32>::type NoComplex;
   // expected-error@#1 {{vector size not an integral multiple of component size}}
   // expected-note@+1 {{in instantiation of template class 'Templates::TemplateVectorType<int, 33>' requested here}}
   const TemplateVectorType<int, 33>::type BadSize;
-  // expected-error@#1 {{vector size too large}}
+  // expected-error@#1 {{vector size too large. Size is 8192 when the maximum allowed is 4092}}
   // expected-note@+1 {{in instantiation of template class 'Templates::TemplateVectorType<int, 8192>' requested here}}
   const TemplateVectorType<int, 8192>::type TooLarge;
   // expected-error@#1 {{zero vector size}}
   // expected-note@+1 {{in instantiation of template class 'Templates::TemplateVectorType<int, 0>' requested here}}
   const TemplateVectorType<int, 0>::type Zero;
 
-  // expected-error@#2 {{vector size too large}}
+  // expected-error@#2 {{vector size too large. Size is 8192 when the maximum allowed is 4092}}
   // expected-error@#3 {{vector size not an integral multiple of component size}}
   // expected-note@+1 {{in instantiation of template class 'Templates::PR15730<8, int>' requested here}}
   const PR15730<8, int>::type PR15730_1 = {};
-  // expected-error@#2 {{vector size too large}}
+  // expected-error@#2 {{vector size too large. Size is 8192 when the maximum allowed is 1023}}
   // expected-note@+1 {{in instantiation of template class 'Templates::PR15730<8, char>' requested here}}
   const PR15730<8, char>::type2 PR15730_2 = {};
 }
 
 } // namespace Templates
 
 typedef int inte2 __attribute__((__ext_vector_type__(2)));