Migrate off the extra bits in FunctionDecl

Now record the information in ASTContext, this has the handy effect of
allowing us to short circuit any consideration of type aware allocators
entirely, though future refactoring of the operator resolution logic
will likely make that less irksome.

Author: ojhunt

clang/include/clang/AST/ASTContext.h

@@ -329,6 +329,9 @@ class ASTContext : public RefCountedBase<ASTContext> {
   /// This is lazily created.  This is intentionally not serialized.
   mutable llvm::StringMap<StringLiteral *> StringLiteralCache;
 
+  mutable llvm::DenseSet<const FunctionDecl *> DestroyingOperatorDeletes;
+  mutable llvm::DenseSet<const FunctionDecl *> TypeAwareOperatorNewAndDeletes;
+
   /// The next string literal "version" to allocate during constant evaluation.
   /// This is used to distinguish between repeated evaluations of the same
   /// string literal.
@@ -3337,6 +3340,15 @@ class ASTContext : public RefCountedBase<ASTContext> {
   void setStaticLocalNumber(const VarDecl *VD, unsigned Number);
   unsigned getStaticLocalNumber(const VarDecl *VD) const;
 
+  bool hasSeenTypeAwareOperatorNewOrDelete() const {
+    return !TypeAwareOperatorNewAndDeletes.empty();
+  }
+  void setIsDestroyingOperatorDelete(const FunctionDecl *FD, bool IsDestroying);
+  bool isDestroyingOperatorDelete(const FunctionDecl *FD) const;
+  void setIsTypeAwareOperatorNewOrDelete(const FunctionDecl *FD,
+                                         bool IsTypeAware);
+  bool isTypeAwareOperatorNewOrDelete(const FunctionDecl *FD) const;
+
   /// Retrieve the context for computing mangling numbers in the given
   /// DeclContext.
   MangleNumberingContext &getManglingNumberContext(const DeclContext *DC);

clang/include/clang/AST/Decl.h

@@ -2541,13 +2541,19 @@ class FunctionDecl : public DeclaratorDecl,
   /// This adds support for potentially templated type aware global allocation
   /// functions of the form:
   ///    void *operator new(type-identity, std::size_t, std::align_val_t)
-  ///    void *operator new(type-identity, std::size_t, std::align_val_t, const std::nothrow_t &) noexcept;
+  ///    void *operator new(type-identity, std::size_t, std::align_val_t,
+  ///                       const std::nothrow_t &) noexcept;
   ///    void *operator new[](type-identity, std::size_t, std::align_val_t)
-  ///    void *operator new[](type-identity, std::size_t, std::align_val_t, const std::nothrow_t &) noexcept;
-  ///    void operator delete(type-identity, void*, std::size_t, std::align_val_t) noexcept;
-  ///    void operator delete(type-identity, void*, std::size_t, std::align_val_t, const std::nothrow_t &) noexcept;
-  ///    void operator delete[](type-identity, void*, std::size_t, std::align_val_t) noexcept;
-  ///    void operator delete[](type-identity, void*, std::size_t, std::align_val_t, const std::nothrow_t &) noexcept;
+  ///    void *operator new[](type-identity, std::size_t, std::align_val_t,
+  ///                         const std::nothrow_t &) noexcept;
+  ///    void operator delete(type-identity, void*, std::size_t,
+  ///                         std::align_val_t) noexcept;
+  ///    void operator delete(type-identity, void*, std::size_t,
+  ///                         std::align_val_t, const std::nothrow_t&) noexcept;
+  ///    void operator delete[](type-identity, void*, std::size_t,
+  ///                         std::align_val_t) noexcept;
+  ///    void operator delete[](type-identity, void*, std::size_t,
+  ///                         std::align_val_t, const std::nothrow_t&) noexcept;
   /// Where `type-identity` is a specialization of std::type_identity. If the
   /// declaration is a templated function, it may not include a parameter pack
   /// in the argument list, the type-identity parameter is required to be
@@ -2560,12 +2566,8 @@ class FunctionDecl : public DeclaratorDecl,
   bool isInlineBuiltinDeclaration() const;
 
   /// Determine whether this is a destroying operator delete.
-  bool isDestroyingOperatorDelete() const {
-    return FunctionDeclBits.IsDestroyingOperatorDelete;
-  }
-  void setIsDestroyingOperatorDelete(bool IsDestroyingDelete) {
-    FunctionDeclBits.IsDestroyingOperatorDelete = IsDestroyingDelete;
-  }
+  bool isDestroyingOperatorDelete() const;
+  void setIsDestroyingOperatorDelete(bool IsDestroyingDelete);
 
   /// Count of mandatory parameters for type aware operator new
   static constexpr unsigned RequiredTypeAwareNewParameterCount =
@@ -2577,12 +2579,8 @@ class FunctionDecl : public DeclaratorDecl,
       /* alignment */ 1;
 
   /// Determine whether this is a type aware operator new or delete.
-  bool isTypeAwareOperatorNewOrDelete() const {
-    return FunctionDeclBits.IsTypeAwareOperatorNewOrDelete;
-  }
-  void setIsTypeAwareOperatorNewOrDelete(bool IsTypeAwareOperator = true) {
-    FunctionDeclBits.IsTypeAwareOperatorNewOrDelete = IsTypeAwareOperator;
-  }
+  bool isTypeAwareOperatorNewOrDelete() const;
+  void setIsTypeAwareOperatorNewOrDelete(bool IsTypeAwareOperator = true);
 
   /// Compute the language linkage.
   LanguageLinkage getLanguageLinkage() const;

clang/include/clang/AST/DeclBase.h

@@ -1829,18 +1829,10 @@ class DeclContext {
     // refers to an enclosing template for hte purposes of [temp.friend]p9.
     LLVM_PREFERRED_TYPE(bool)
     uint64_t FriendConstraintRefersToEnclosingTemplate : 1;
-
-    // Indicates this function is type aware operator new or delete
-    LLVM_PREFERRED_TYPE(bool)
-    uint64_t IsDestroyingOperatorDelete : 1;
-
-    // Indicates this function is type aware operator new or delete
-    LLVM_PREFERRED_TYPE(bool)
-    uint64_t IsTypeAwareOperatorNewOrDelete : 1;
   };
 
   /// Number of inherited and non-inherited bits in FunctionDeclBitfields.
-  enum { NumFunctionDeclBits = NumDeclContextBits + 34 };
+  enum { NumFunctionDeclBits = NumDeclContextBits + 32 };
 
   /// Stores the bits used by CXXConstructorDecl. If modified
   /// NumCXXConstructorDeclBits and the accessor
@@ -1851,12 +1843,12 @@ class DeclContext {
     LLVM_PREFERRED_TYPE(FunctionDeclBitfields)
     uint64_t : NumFunctionDeclBits;
 
-    /// 17 bits to fit in the remaining available space.
+    /// 19 bits to fit in the remaining available space.
     /// Note that this makes CXXConstructorDeclBitfields take
     /// exactly 64 bits and thus the width of NumCtorInitializers
     /// will need to be shrunk if some bit is added to NumDeclContextBitfields,
     /// NumFunctionDeclBitfields or CXXConstructorDeclBitfields.
-    uint64_t NumCtorInitializers : 14;
+    uint64_t NumCtorInitializers : 16;
     LLVM_PREFERRED_TYPE(bool)
     uint64_t IsInheritingConstructor : 1;
 
@@ -1870,9 +1862,7 @@ class DeclContext {
   };
 
   /// Number of inherited and non-inherited bits in CXXConstructorDeclBitfields.
-  enum { NumCXXConstructorDeclBits = NumFunctionDeclBits + 17 };
-  static_assert(NumCXXConstructorDeclBits == 64);
-  static_assert(sizeof(CXXConstructorDeclBitfields) == 8);
+  enum { NumCXXConstructorDeclBits = NumFunctionDeclBits + 19 };
 
   /// Stores the bits used by ObjCMethodDecl.
   /// If modified NumObjCMethodDeclBits and the accessor

clang/include/clang/Sema/Sema.h

@@ -4882,6 +4882,7 @@ class Sema final : public SemaBase {
   CXXRecordDecl *getStdBadAlloc() const;
   EnumDecl *getStdAlignValT() const;
 
+  TypeAwareAllocationMode ShouldUseTypeAwareOperatorNewOrDelete() const;
   bool isTypeAwareOperatorNewOrDelete(const NamedDecl *FnDecl) const;
   FunctionDecl *BuildTypeAwareUsualDelete(FunctionTemplateDecl *FnDecl,
                                           QualType AllocType, SourceLocation);
@@ -4913,7 +4914,13 @@ class Sema final : public SemaBase {
   /// it is and Element is not NULL, assigns the element type to Element.
   bool isStdInitializerList(QualType Ty, QualType *Element);
 
-  bool isStdTypeIdentity(QualType Ty, QualType *TypeArgument);
+  /// Tests whether Ty is an instance of std::type_identity and, if
+  /// it is and TypeArgument is not NULL, assigns the element type to Element.
+  /// If MalformedDecl is not null, and type_identity was ruled out due to being
+  /// incorrectly structured despite having the correct name, the faulty Decl
+  /// will be assigned to MalformedDecl.
+  bool isStdTypeIdentity(QualType Ty, QualType *TypeArgument,
+                         const Decl **MalformedDecl = nullptr);
 
   /// Looks for the std::initializer_list template and instantiates it
   /// with Element, or emits an error if it's not found.

clang/include/clang/Serialization/ASTWriter.h

@@ -1072,7 +1072,6 @@ class BitsPacker {
     UnderlyingValue |= Value << CurrentBitIndex;
     CurrentBitIndex += BitsWidth;
   }
-  uint32_t currentBitCount() const { return CurrentBitIndex; }
 
   operator uint32_t() { return UnderlyingValue; }
 

clang/lib/AST/ASTContext.cpp

@@ -13117,6 +13117,31 @@ unsigned ASTContext::getStaticLocalNumber(const VarDecl *VD) const {
   return I != StaticLocalNumbers.end() ? I->second : 1;
 }
 
+void ASTContext::setIsDestroyingOperatorDelete(const FunctionDecl *FD,
+                                               bool IsDestroying) {
+  if (!IsDestroying) {
+    assert(!DestroyingOperatorDeletes.contains(FD->getCanonicalDecl()));
+    return;
+  }
+  DestroyingOperatorDeletes.insert(FD->getCanonicalDecl());
+}
+
+bool ASTContext::isDestroyingOperatorDelete(const FunctionDecl *FD) const {
+  return DestroyingOperatorDeletes.contains(FD->getCanonicalDecl());
+}
+void ASTContext::setIsTypeAwareOperatorNewOrDelete(const FunctionDecl *FD,
+                                                   bool IsTypeAware) {
+  if (!IsTypeAware) {
+    assert(!TypeAwareOperatorNewAndDeletes.contains(FD->getCanonicalDecl()));
+    return;
+  }
+  TypeAwareOperatorNewAndDeletes.insert(FD->getCanonicalDecl());
+}
+
+bool ASTContext::isTypeAwareOperatorNewOrDelete(const FunctionDecl *FD) const {
+  return TypeAwareOperatorNewAndDeletes.contains(FD->getCanonicalDecl());
+}
+
 MangleNumberingContext &
 ASTContext::getManglingNumberContext(const DeclContext *DC) {
   assert(LangOpts.CPlusPlus);  // We don't need mangling numbers for plain C.

clang/lib/AST/Decl.cpp

@@ -3083,8 +3083,6 @@ FunctionDecl::FunctionDecl(Kind DK, ASTContext &C, DeclContext *DC,
       static_cast<unsigned char>(DeductionCandidate::Normal);
   FunctionDeclBits.HasODRHash = false;
   FunctionDeclBits.FriendConstraintRefersToEnclosingTemplate = false;
-  FunctionDeclBits.IsDestroyingOperatorDelete = false;
-  FunctionDeclBits.IsTypeAwareOperatorNewOrDelete = false;
 
   if (TrailingRequiresClause)
     setTrailingRequiresClause(TrailingRequiresClause);
@@ -3513,6 +3511,22 @@ bool FunctionDecl::isInlineBuiltinDeclaration() const {
   llvm_unreachable("Unknown GVALinkage");
 }
 
+bool FunctionDecl::isDestroyingOperatorDelete() const {
+  return getASTContext().isDestroyingOperatorDelete(this);
+}
+
+void FunctionDecl::setIsDestroyingOperatorDelete(bool IsDestroyingDelete) {
+  getASTContext().setIsDestroyingOperatorDelete(this, IsDestroyingDelete);
+}
+
+bool FunctionDecl::isTypeAwareOperatorNewOrDelete() const {
+  return getASTContext().isTypeAwareOperatorNewOrDelete(this);
+}
+
+void FunctionDecl::setIsTypeAwareOperatorNewOrDelete(bool IsTypeAware) {
+  getASTContext().setIsTypeAwareOperatorNewOrDelete(this, IsTypeAware);
+}
+
 LanguageLinkage FunctionDecl::getLanguageLinkage() const {
   return getDeclLanguageLinkage(*this);
 }

clang/lib/Sema/SemaCoroutine.cpp

@@ -1143,7 +1143,7 @@ static bool findDeleteForPromise(Sema &S, SourceLocation Loc, QualType PromiseTy
   ImplicitDeallocationParameters IDP = {
       alignedAllocationModeFromBool(Overaligned), SizedDeallocationMode::Yes};
   if (S.FindDeallocationFunction(Loc, PointeeRD, DeleteName, OperatorDelete,
-                                 IDP, /*Diagnose*/ true))
+                                 IDP, /*Diagnose=*/true))
     return false;
 
   // [dcl.fct.def.coroutine]p12
@@ -1476,11 +1476,11 @@ bool CoroutineStmtBuilder::makeNewAndDeleteExpr() {
 
     FunctionDecl *UnusedResult = nullptr;
     S.FindAllocationFunctions(Loc, SourceRange(), NewScope,
-                              /*DeleteScope*/ Sema::AFS_Both, PromiseType,
-                              /*isArray*/ false, IAP,
+                              /*DeleteScope=*/Sema::AFS_Both, PromiseType,
+                              /*isArray=*/false, IAP,
                               WithoutPlacementArgs ? MultiExprArg{}
                                                    : PlacementArgs,
-                              OperatorNew, UnusedResult, /*Diagnose*/ false);
+                              OperatorNew, UnusedResult, /*Diagnose=*/false);
     assert(!OperatorNew || !OperatorNew->isTypeAwareOperatorNewOrDelete());
   };