[AST] Allow VectorTypes of 1-256 elements, and powers of two up to 2**31.

[sammccall]

Summary

This used to be 1-2043 elements, and recently regressed to a limit of 1023.
The new behavior is an almost-superset of GCC, which accepts powers of two up
to 2**62.

This change frees one further bit in VectorType in case Type grows again.

[efriedma]

I think I would rather just pay the extra 8 bytes per VectorType, and expand this to support all vector types supported by LLVM. It's not like we allocate enough VectorTypes for it to matter, anyway.

[sammccall]

In D77313#1957690, @efriedma wrote:

I think I would rather just pay the extra 8 bytes per VectorType, and expand this to support all vector types supported by LLVM. It's not like we allocate enough VectorTypes for it to matter, anyway.

llvm::VectorType seems to accept arbitrary unsigned size, so IIUC you'd suggest putting just putting unsigned NumElements in VectorType, which would cost 4 bytes and another 4 in padding.
Sounds reasonable to me, I'll try that.

[sammccall]

In D77313#1957970, @sammccall wrote:

In D77313#1957690, @efriedma wrote:

I think I would rather just pay the extra 8 bytes per VectorType, and expand this to support all vector types supported by LLVM. It's not like we allocate enough VectorTypes for it to matter, anyway.

Sounds reasonable to me, I'll try that.

This alternative is in D77335, which is much simpler.

clang/include/clang/AST/Type.h

 //===- Type.h - C Language Family Type Representation -----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //

 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/MathExtras.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
 #include "llvm/Support/TrailingObjects.h"
 #include "llvm/Support/type_traits.h"
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
 #include <string>
class VectorTypeBitfields {
     friend class DependentVectorType;
 
     unsigned : NumTypeBits;
 
     /// The kind of vector, either a generic vector type or some
     /// target-specific vector type such as for AltiVec or Neon.
     unsigned VecKind : 3;
 
-    /// The number of elements in the vector.
-    unsigned NumElements : 29 - NumTypeBits;
+    unsigned ManyElements : 1;
+    /// Encoded number of elements in the vector.
+    /// If ManyElements is set, the count is 2 ** EncodedNumElements.
+    unsigned EncodedNumElements : 8;
 
-    enum { MaxNumElements = (1 << (29 - NumTypeBits)) - 1 };
+    enum { ManyElementsThreshold = 1 << 8 };
   };
 
   class AttributedTypeBitfields {
     friend class AttributedType;
 
     unsigned : NumTypeBits;
 
     /// An AttributedType::Kind
protected:
   VectorType(QualType vecType, unsigned nElements, QualType canonType,
              VectorKind vecKind);
 
   VectorType(TypeClass tc, QualType vecType, unsigned nElements,
              QualType canonType, VectorKind vecKind);
 
 public:
   QualType getElementType() const { return ElementType; }
-  unsigned getNumElements() const { return VectorTypeBits.NumElements; }
+  unsigned getNumElements() const {
+    return VectorTypeBits.ManyElements
+               ? (1 << VectorTypeBits.EncodedNumElements)
+               : VectorTypeBits.EncodedNumElements;
+  }
 
-  static bool isVectorSizeTooLarge(unsigned NumElements) {
-    return NumElements > VectorTypeBitfields::MaxNumElements;
+  static bool isVectorSizeValid(unsigned NumElements) {
+    return NumElements < VectorTypeBitfields::ManyElementsThreshold ||
+           llvm::isPowerOf2_32(NumElements);
   }
 
   bool isSugared() const { return false; }
   QualType desugar() const { return QualType(this, 0); }
 
   VectorKind getVectorKind() const {
     return VectorKind(VectorTypeBits.VecKind);
   }

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def err_callback_callee_no_function_type : Error<
   "'callback' attribute callee does not have function type">;
 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<
+def err_attribute_noninteger_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_invalid_size : Error<
+   "vector size exceeds 256 and is not a power of two">;
 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/AST/Type.cpp

 //===- Type.cpp - Type representation and manipulation --------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //

 VectorType::VectorType(QualType vecType, unsigned nElements, QualType canonType,
                        VectorKind vecKind)
     : VectorType(Vector, vecType, nElements, canonType, vecKind) {}
 
 VectorType::VectorType(TypeClass tc, QualType vecType, unsigned nElements,
                        QualType canonType, VectorKind vecKind)
     : Type(tc, canonType, vecType->getDependence()), ElementType(vecType) {
   VectorTypeBits.VecKind = vecKind;
-  VectorTypeBits.NumElements = nElements;
+  if (nElements < VectorTypeBitfields::ManyElementsThreshold) {
+    VectorTypeBits.ManyElements = false;
+    VectorTypeBits.EncodedNumElements = nElements;
+  } else {
+    assert(llvm::isPowerOf2_32(nElements));
+    VectorTypeBits.ManyElements = true;
+    VectorTypeBits.EncodedNumElements = llvm::Log2_32(nElements);
+  }
+  assert(getNumElements() == nElements);
 }
 
 /// getArrayElementTypeNoTypeQual - If this is an array type, return the
 /// element type of the array, potentially with type qualifiers missing.
 /// This method should never be used when type qualifiers are meaningful.
 const Type *Type::getArrayElementTypeNoTypeQual() const {
   // If this is directly an array type, return it.
   if (const auto *ATy = dyn_cast<ArrayType>(this))

clang/lib/Sema/SemaType.cpp

 //===--- SemaType.cpp - Semantic Analysis for Types -----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file implements type-related semantic analysis.
 //
 //===----------------------------------------------------------------------===//
 
 #include "TypeLocBuilder.h"
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTMutationListener.h"
 #include "clang/AST/ASTStructuralEquivalence.h"
 #include "clang/AST/CXXInheritance.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/AST/TypeLocVisitor.h"
+#include "clang/Basic/DiagnosticSema.h"
 #include "clang/Basic/PartialDiagnostic.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/DelayedDiagnostic.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/ScopeInfo.h"
Diag(AttrLoc, diag::err_attribute_argument_type)
         << SizeExpr->getSourceRange();
     return QualType();
   }
 
   if (CurType->isDependentType())
     return Context.getDependentVectorType(CurType, SizeExpr, AttrLoc,
                                                VectorType::GenericVector);
 
-  unsigned VectorSize = static_cast<unsigned>(VecSize.getZExtValue() * 8);
+  if (!VecSize.isIntN(32)) {
+    Diag(AttrLoc, diag::err_attribute_size_too_large)
+        << SizeExpr->getSourceRange();
+    return QualType();
+  }
+  unsigned VectorSize = VecSize.getZExtValue() * 8;
   unsigned TypeSize = static_cast<unsigned>(Context.getTypeSize(CurType));
 
   if (VectorSize == 0) {
     Diag(AttrLoc, diag::err_attribute_zero_size) << SizeExpr->getSourceRange();
     return QualType();
   }
 
   // vecSize is specified in bytes - convert to bits.
   if (VectorSize % TypeSize) {
-    Diag(AttrLoc, diag::err_attribute_invalid_size)
+    Diag(AttrLoc, diag::err_attribute_noninteger_size)
         << SizeExpr->getSourceRange();
     return QualType();
   }
 
-  if (VectorType::isVectorSizeTooLarge(VectorSize / TypeSize)) {
-    Diag(AttrLoc, diag::err_attribute_size_too_large)
+  if (!VectorType::isVectorSizeValid(VectorSize / TypeSize)) {
+    Diag(AttrLoc, diag::err_attribute_invalid_size)
         << SizeExpr->getSourceRange();
     return QualType();
   }
 
   return Context.getVectorType(CurType, VectorSize / TypeSize,
                                VectorType::GenericVector);
 }
 
if (!ArraySize->isIntegerConstantExpr(vecSize, Context)) {
       Diag(AttrLoc, diag::err_attribute_argument_type)
         << "ext_vector_type" << AANT_ArgumentIntegerConstant
         << ArraySize->getSourceRange();
       return QualType();
     }
 
     // Unlike gcc's vector_size attribute, the size is specified as the
     // number of elements, not the number of bytes.
+    if (!vecSize.isIntN(32)) {
+      Diag(AttrLoc, diag::err_attribute_size_too_large)
+          << ArraySize->getSourceRange();
+      return QualType();
+    }
     unsigned vectorSize = static_cast<unsigned>(vecSize.getZExtValue());
 
     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)
+    if (!VectorType::isVectorSizeValid(vectorSize)) {
+      Diag(AttrLoc, diag::err_attribute_invalid_size)
         << ArraySize->getSourceRange();
       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}}
+char __attribute__ ((vector_size(255))) v1;
+char __attribute__ ((vector_size(256))) v2;
+char __attribute__ ((vector_size(257))) v3; // expected-error {{vector size exceeds 256 and is not a power of two}}
+char __attribute__ ((vector_size(512))) v4;
+char __attribute__ ((vector_size(0x10000000))) v5;
+char __attribute__ ((vector_size(0x100000000))) v6; // expected-error {{vector size too large}}
+typedef int __attribute__ ((ext_vector_type(255))) e1;
+typedef int __attribute__ ((ext_vector_type(256))) e2;
+typedef int __attribute__ ((ext_vector_type(257))) e3; // expected-error {{vector size exceeds 256 and is not a power of two}}
+typedef int __attribute__ ((ext_vector_type(512))) e4;
+typedef int __attribute__ ((ext_vector_type(0x10000000))) e5;
+typedef int __attribute__ ((ext_vector_type(0x100000000))) e6; // expected-error {{vector size too large}}
 
 // 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

 // RUN: %clang_cc1 -flax-vector-conversions=all -triple x86_64-apple-darwin10 -fsyntax-only -verify %s
 // RUN: %clang_cc1 -flax-vector-conversions=all -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=c++98 %s
 // RUN: %clang_cc1 -flax-vector-conversions=all -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=c++11 %s
 // RUN: %clang_cc1 -flax-vector-conversions=integer -triple x86_64-apple-darwin10 -fsyntax-only -verify %s -DNO_LAX_FLOAT
 // RUN: %clang_cc1 -flax-vector-conversions=none -triple x86_64-apple-darwin10 -fsyntax-only -verify %s -DNO_LAX_FLOAT -DNO_LAX_INT
 
 typedef char char16 __attribute__ ((__vector_size__ (16)));
 typedef long long longlong16 __attribute__ ((__vector_size__ (16)));

 template <typename Elt, unsigned Size>
 struct TemplateVectorType {
   typedef Elt __attribute__((__vector_size__(Size))) type; // #1
 };
 
 template <int N, typename T>
 struct PR15730 {
   typedef T __attribute__((vector_size(N * sizeof(T)))) type;
-  typedef T __attribute__((vector_size(8192))) type2; // #2
+  typedef T __attribute__((vector_size(10000))) type2; // #2
   typedef T __attribute__((vector_size(3))) type3; // #3
 };
 
 void Init() {
   const TemplateVectorType<float, 32>::type Works = {};
   const TemplateVectorType<int, 32>::type Works2 = {};
   // expected-error@#1 {{invalid vector element type 'bool'}}
   // expected-note@+1 {{in instantiation of template class 'Templates::TemplateVectorType<bool, 32>' requested here}}
-  const TemplateVectorType<bool, 32>::type NoBool;
+  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;
+  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-note@+1 {{in instantiation of template class 'Templates::TemplateVectorType<int, 8192>' requested here}}
-  const TemplateVectorType<int, 8192>::type TooLarge;
+  const TemplateVectorType<int, 33>::type BadSize = {};
+  const TemplateVectorType<int, 320>::type SmallNonPower = {};
+  const TemplateVectorType<int, 8192>::type LargePower = {};
+  // expected-error@#1 {{vector size exceeds 256 and is not a power of two}}
+  // expected-note@+1 {{in instantiation of template class 'Templates::TemplateVectorType<int, 10000>' requested here}}
+  const TemplateVectorType<int, 10000>::type LargeNonPower = {};
   // 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;
+  const TemplateVectorType<int, 0>::type Zero = {};
 
-  // expected-error@#2 {{vector size too large}}
+  // expected-error@#2 {{not a power of two}}
   // 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 {{not a power of two}}
   // 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)));