[AST] Pack the bits of TemplateSpecializationType into Type

[riccibruno]

Summary

Type has enough space for two members of
TemplateSpecializationType. Mechanical patch.

[erichkeane]

I think that this causes UB. The Type baseclass will use the TypeBitfields active member, but this uses the TemplateSpecializationTypeBits, right? I know we take advantage of this elsewhere, but I'm tentative about this one...

[riccibruno]

All of these bitfields (ab)use are already UB I think...
I don't see what is special in this case...

[erichkeane]

Ah, right. I missed that the others already do it. Fine I guess...

[riccibruno]

I don't like these bit-field abuses too much but this is
used all over the place in clang and so if this breaks so
many things are going to break.

[riccibruno]

update the comment in TemplateSpecializationTypeBitfields

cfe/trunk/include/clang/AST/Type.h

class AutoTypeBitfields {
 
     unsigned : NumTypeBits;
 
     /// Was this placeholder type spelled as 'auto', 'decltype(auto)',
     /// or '__auto_type'?  AutoTypeKeyword value.
     unsigned Keyword : 2;
   };
 
+  class TemplateSpecializationTypeBitfields {
+    friend class TemplateSpecializationType;
+
+    unsigned : NumTypeBits;
+
+    /// Whether this template specialization type is a substituted type alias.
+    unsigned TypeAlias : 1;
+
+    /// The number of template arguments named in this class template
+    /// specialization, which is expected to be able to hold at least 1024
+    /// according to [implimits]. However, as this limit is somewhat easy to
+    /// hit with template metaprogramming we'd prefer to keep it as large
+    /// as possible. At the moment it has been left as a non-bitfield since
+    /// this type safely fits in 64 bits as an unsigned, so there is no reason
+    /// to introduce the performance impact of a bitfield.
+    unsigned NumArgs;
+  };
+
   union {
     TypeBitfields TypeBits;
     ArrayTypeBitfields ArrayTypeBits;
     AttributedTypeBitfields AttributedTypeBits;
     AutoTypeBitfields AutoTypeBits;
     BuiltinTypeBitfields BuiltinTypeBits;
     FunctionTypeBitfields FunctionTypeBits;
     ObjCObjectTypeBitfields ObjCObjectTypeBits;
     ReferenceTypeBitfields ReferenceTypeBits;
     TypeWithKeywordBitfields TypeWithKeywordBits;
     VectorTypeBitfields VectorTypeBits;
+    TemplateSpecializationTypeBitfields TemplateSpecializationTypeBits;
 
     static_assert(sizeof(TypeBitfields) <= 8,
                   "TypeBitfields is larger than 8 bytes!");
     static_assert(sizeof(ArrayTypeBitfields) <= 8,
                   "ArrayTypeBitfields is larger than 8 bytes!");
     static_assert(sizeof(AttributedTypeBitfields) <= 8,
                   "AttributedTypeBitfields is larger than 8 bytes!");
     static_assert(sizeof(AutoTypeBitfields) <= 8,
                   "AutoTypeBitfields is larger than 8 bytes!");
     static_assert(sizeof(BuiltinTypeBitfields) <= 8,
                   "BuiltinTypeBitfields is larger than 8 bytes!");
     static_assert(sizeof(FunctionTypeBitfields) <= 8,
                   "FunctionTypeBitfields is larger than 8 bytes!");
     static_assert(sizeof(ObjCObjectTypeBitfields) <= 8,
                   "ObjCObjectTypeBitfields is larger than 8 bytes!");
     static_assert(sizeof(ReferenceTypeBitfields) <= 8,
                   "ReferenceTypeBitfields is larger than 8 bytes!");
     static_assert(sizeof(TypeWithKeywordBitfields) <= 8,
                   "TypeWithKeywordBitfields is larger than 8 bytes!");
     static_assert(sizeof(VectorTypeBitfields) <= 8,
                   "VectorTypeBitfields is larger than 8 bytes!");
+    static_assert(sizeof(TemplateSpecializationTypeBitfields) <= 8,
+                  "TemplateSpecializationTypeBitfields is larger"
+                  " than 8 bytes!");
   };
 
 private:
   template <class T> friend class TypePropertyCache;
 
   /// Set whether this type comes from an AST file.
   void setFromAST(bool V = true) const {
     TypeBits.FromAST = V;
class alignas(8) TemplateSpecializationType
   /// either a TemplateName::Template (in which case it is a
   /// ClassTemplateDecl*, a TemplateTemplateParmDecl*, or a
   /// TypeAliasTemplateDecl*), a
   /// TemplateName::SubstTemplateTemplateParmPack, or a
   /// TemplateName::SubstTemplateTemplateParm (in which case the
   /// replacement must, recursively, be one of these).
   TemplateName Template;
 
-  /// The number of template arguments named in this class template
-  /// specialization.
-  unsigned NumArgs : 31;
-
-  /// Whether this template specialization type is a substituted type alias.
-  unsigned TypeAlias : 1;
-
   TemplateSpecializationType(TemplateName T,
                              ArrayRef<TemplateArgument> Args,
                              QualType Canon,
                              QualType Aliased);
 
 public:
   /// Determine whether any of the given template arguments are dependent.
   static bool anyDependentTemplateArguments(ArrayRef<TemplateArgumentLoc> Args,
public:
   ///
   /// \code
   /// template<typename T, typename U, typename V> struct S;
   /// template<typename T, typename U> using A = S<T, int, U>;
   /// template<typename... Ts> struct X {
   ///   typedef A<Ts...> type; // not a type alias
   /// };
   /// \endcode
-  bool isTypeAlias() const { return TypeAlias; }
+  bool isTypeAlias() const { return TemplateSpecializationTypeBits.TypeAlias; }
 
   /// Get the aliased type, if this is a specialization of a type alias
   /// template.
   QualType getAliasedType() const {
     assert(isTypeAlias() && "not a type alias template specialization");
     return *reinterpret_cast<const QualType*>(end());
   }
 
   using iterator = const TemplateArgument *;
 
   iterator begin() const { return getArgs(); }
   iterator end() const; // defined inline in TemplateBase.h
 
   /// Retrieve the name of the template that we are specializing.
   TemplateName getTemplateName() const { return Template; }
 
   /// Retrieve the template arguments.
   const TemplateArgument *getArgs() const {
     return reinterpret_cast<const TemplateArgument *>(this + 1);
   }
 
   /// Retrieve the number of template arguments.
-  unsigned getNumArgs() const { return NumArgs; }
+  unsigned getNumArgs() const {
+    return TemplateSpecializationTypeBits.NumArgs;
+  }
 
   /// Retrieve a specific template argument as a type.
   /// \pre \c isArgType(Arg)
   const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h
 
   ArrayRef<TemplateArgument> template_arguments() const {
-    return {getArgs(), NumArgs};
+    return {getArgs(), getNumArgs()};
   }
 
   bool isSugared() const {
     return !isDependentType() || isCurrentInstantiation() || isTypeAlias();
   }
 
   QualType desugar() const { return getCanonicalTypeInternal(); }
 

cfe/trunk/lib/AST/Type.cpp

 TemplateSpecializationType(TemplateName T,
                            ArrayRef<TemplateArgument> Args,
                            QualType Canon, QualType AliasedType)
   : Type(TemplateSpecialization,
          Canon.isNull()? QualType(this, 0) : Canon,
          Canon.isNull()? true : Canon->isDependentType(),
          Canon.isNull()? true : Canon->isInstantiationDependentType(),
          false,
-         T.containsUnexpandedParameterPack()),
-    Template(T), NumArgs(Args.size()), TypeAlias(!AliasedType.isNull()) {
+         T.containsUnexpandedParameterPack()), Template(T) {
+  TemplateSpecializationTypeBits.NumArgs = Args.size();
+  TemplateSpecializationTypeBits.TypeAlias = !AliasedType.isNull();
+
   assert(!T.getAsDependentTemplateName() &&
          "Use DependentTemplateSpecializationType for dependent template-name");
   assert((T.getKind() == TemplateName::Template ||
           T.getKind() == TemplateName::SubstTemplateTemplateParm ||
           T.getKind() == TemplateName::SubstTemplateTemplateParmPack) &&
          "Unexpected template name for TemplateSpecializationType");
 
   auto *TemplateArgs = reinterpret_cast<TemplateArgument *>(this + 1);
if (Arg.getKind() == TemplateArgument::Type &&
         Arg.getAsType()->isVariablyModifiedType())
       setVariablyModified();
     if (Arg.containsUnexpandedParameterPack())
       setContainsUnexpandedParameterPack();
     new (TemplateArgs++) TemplateArgument(Arg);
   }
 
   // Store the aliased type if this is a type alias template specialization.
-  if (TypeAlias) {
+  if (isTypeAlias()) {
     auto *Begin = reinterpret_cast<TemplateArgument *>(this + 1);
     *reinterpret_cast<QualType*>(Begin + getNumArgs()) = AliasedType;
   }
 }
 
 void
 TemplateSpecializationType::Profile(llvm::FoldingSetNodeID &ID,
                                     TemplateName T,