ObjC: Squeeze in one more bit for the count of protocols in 'id' types

[jordan_rose]

Summary

Someone actually had an Objective-C object pointer type with more than 64 protocols, probably collected through typedefs. Raise the ceiling by one order of magnitude...even though this is just kicking the can down the road, and we need a proper diagnostic for this.

[jfb]

DO you have a test for that many protocols? That way when we add a diagnostic we know it won't fail.

[jordan_rose]

Yeah, I'll write one.

include/clang/AST/Type.h

     friend class ObjCObjectType;
 
     unsigned : NumTypeBits;
 
     /// The number of type arguments stored directly on this object type.
     unsigned NumTypeArgs : 7;
 
     /// The number of protocols stored directly on this object type.
-    unsigned NumProtocols : 6;
-
-    /// Whether this is a "kindof" type.
-    unsigned IsKindOf : 1;
+    unsigned NumProtocols : 7;
   };
 
   class ReferenceTypeBitfields {
     friend class ReferenceType;
 
     unsigned : NumTypeBits;
 
     /// True if the type was originally spelled with an lvalue sigil.

   // to get kindof complicated.
   //
   // In the canonical object type, these are sorted alphabetically
   // and uniqued.
 
   /// Either a BuiltinType or an InterfaceType or sugar for either.
   QualType BaseType;
 
-  /// Cached superclass type.
-  mutable llvm::PointerIntPair<const ObjCObjectType *, 1, bool>
-    CachedSuperClassType;
+  using CachedSuperClassStorage =
+      llvm::PointerIntPair<const ObjCObjectType *, 1, bool>;
+
+  /// Cached superclass type plus whether this type was written with '__kindof'.
+  mutable llvm::PointerIntPair<CachedSuperClassStorage, 1, bool>
+      CachedSuperClassAndIsKindOf;
 
   QualType *getTypeArgStorage();
   const QualType *getTypeArgStorage() const {
     return const_cast<ObjCObjectType *>(this)->getTypeArgStorage();
   }
 
   ObjCProtocolDecl **getProtocolStorageImpl();
   /// Return the number of qualifying protocols in this interface type,

                  ArrayRef<ObjCProtocolDecl *> protocols,
                  bool isKindOf);
 
   ObjCObjectType(enum Nonce_ObjCInterface)
         : Type(ObjCInterface, QualType(), false, false, false, false),
           BaseType(QualType(this_(), 0)) {
     ObjCObjectTypeBits.NumProtocols = 0;
     ObjCObjectTypeBits.NumTypeArgs = 0;
-    ObjCObjectTypeBits.IsKindOf = 0;
   }
 
   void computeSuperClassTypeSlow() const;
 
 public:
   /// Gets the base type of this object type.  This is always (possibly
   /// sugar for) one of:
   ///  - the 'id' builtin type (as opposed to the 'id' type visible to the

   /// Retrieve the type arguments of this object type as they were
   /// written.
   ArrayRef<QualType> getTypeArgsAsWritten() const {
     return llvm::makeArrayRef(getTypeArgStorage(),
                               ObjCObjectTypeBits.NumTypeArgs);
   }
 
   /// Whether this is a "__kindof" type as written.
-  bool isKindOfTypeAsWritten() const { return ObjCObjectTypeBits.IsKindOf; }
+  bool isKindOfTypeAsWritten() const {
+    return CachedSuperClassAndIsKindOf.getInt();
+  }
 
   /// Whether this ia a "__kindof" type (semantically).
   bool isKindOfType() const;
 
   /// Retrieve the type of the superclass of this object type.
   ///
   /// This operation substitutes any type arguments into the
   /// superclass of the current class type, potentially producing a
   /// specialization of the superclass type. Produces a null type if
   /// there is no superclass.
   QualType getSuperClassType() const {
-    if (!CachedSuperClassType.getInt())
+    if (!CachedSuperClassAndIsKindOf.getPointer().getInt())
       computeSuperClassTypeSlow();
 
-    assert(CachedSuperClassType.getInt() && "Superclass not set?");
-    return QualType(CachedSuperClassType.getPointer(), 0);
+    assert(CachedSuperClassAndIsKindOf.getPointer().getInt() &&
+           "Superclass not set?");
+    return QualType(CachedSuperClassAndIsKindOf.getPointer().getPointer(), 0);
   }
 
   /// Strip off the Objective-C "kindof" type and (with it) any
   /// protocol qualifiers.
   QualType stripObjCKindOfTypeAndQuals(const ASTContext &ctx) const;
 
   bool isSugared() const { return false; }
   QualType desugar() const { return QualType(this, 0); }

lib/AST/Type.cpp

ObjCObjectType::ObjCObjectType(QualType Canonical, QualType Base,
                                ArrayRef<QualType> typeArgs,
                                ArrayRef<ObjCProtocolDecl *> protocols,
                                bool isKindOf)
     : Type(ObjCObject, Canonical, Base->isDependentType(),
            Base->isInstantiationDependentType(),
            Base->isVariablyModifiedType(),
            Base->containsUnexpandedParameterPack()),
       BaseType(Base) {
-  ObjCObjectTypeBits.IsKindOf = isKindOf;
+  CachedSuperClassAndIsKindOf.setInt(isKindOf);
 
   ObjCObjectTypeBits.NumTypeArgs = typeArgs.size();
   assert(getTypeArgsAsWritten().size() == typeArgs.size() &&
          "bitfield overflow in type argument count");
   if (!typeArgs.empty())
     memcpy(getTypeArgStorage(), typeArgs.data(),
            typeArgs.size() * sizeof(QualType));
 

 }
 
 void ObjCObjectType::computeSuperClassTypeSlow() const {
   // Retrieve the class declaration for this type. If there isn't one
   // (e.g., this is some variant of "id" or "Class"), then there is no
   // superclass type.
   ObjCInterfaceDecl *classDecl = getInterface();
   if (!classDecl) {
-    CachedSuperClassType.setInt(true);
+    CachedSuperClassAndIsKindOf.setPointer({nullptr, true});
     return;
   }
 
   // Extract the superclass type.
   const ObjCObjectType *superClassObjTy = classDecl->getSuperClassType();
   if (!superClassObjTy) {
-    CachedSuperClassType.setInt(true);
+    CachedSuperClassAndIsKindOf.setPointer({nullptr, true});
     return;
   }
 
   ObjCInterfaceDecl *superClassDecl = superClassObjTy->getInterface();
   if (!superClassDecl) {
-    CachedSuperClassType.setInt(true);
+    CachedSuperClassAndIsKindOf.setPointer({nullptr, true});
     return;
   }
 
   // If the superclass doesn't have type parameters, then there is no
   // substitution to perform.
   QualType superClassType(superClassObjTy, 0);
   ObjCTypeParamList *superClassTypeParams = superClassDecl->getTypeParamList();
   if (!superClassTypeParams) {
-    CachedSuperClassType.setPointerAndInt(
-      superClassType->castAs<ObjCObjectType>(), true);
+    CachedSuperClassAndIsKindOf.setPointer({
+      superClassType->castAs<ObjCObjectType>(), true});
     return;
   }
 
   // If the superclass reference is unspecialized, return it.
   if (superClassObjTy->isUnspecialized()) {
-    CachedSuperClassType.setPointerAndInt(superClassObjTy, true);
+    CachedSuperClassAndIsKindOf.setPointer({superClassObjTy, true});
     return;
   }
 
   // If the subclass is not parameterized, there aren't any type
   // parameters in the superclass reference to substitute.
   ObjCTypeParamList *typeParams = classDecl->getTypeParamList();
   if (!typeParams) {
-    CachedSuperClassType.setPointerAndInt(
-      superClassType->castAs<ObjCObjectType>(), true);
+    CachedSuperClassAndIsKindOf.setPointer({
+      superClassType->castAs<ObjCObjectType>(), true});
     return;
   }
 
   // If the subclass type isn't specialized, return the unspecialized
   // superclass.
   if (isUnspecialized()) {
     QualType unspecializedSuper
       = classDecl->getASTContext().getObjCInterfaceType(
           superClassObjTy->getInterface());
-    CachedSuperClassType.setPointerAndInt(
-      unspecializedSuper->castAs<ObjCObjectType>(),
-      true);
+    CachedSuperClassAndIsKindOf.setPointer({
+      unspecializedSuper->castAs<ObjCObjectType>(), true});
     return;
   }
 
   // Substitute the provided type arguments into the superclass type.
   ArrayRef<QualType> typeArgs = getTypeArgs();
   assert(typeArgs.size() == typeParams->size());
-  CachedSuperClassType.setPointerAndInt(
+  CachedSuperClassAndIsKindOf.setPointer({
     superClassType.substObjCTypeArgs(classDecl->getASTContext(), typeArgs,
                                      ObjCSubstitutionContext::Superclass)
       ->castAs<ObjCObjectType>(),
-    true);
+    true});
 }
 
 const ObjCInterfaceType *ObjCObjectPointerType::getInterfaceType() const {
   if (auto interfaceDecl = getObjectType()->getInterface()) {
     return interfaceDecl->getASTContext().getObjCInterfaceType(interfaceDecl)
              ->castAs<ObjCInterfaceType>();
   }