Revert "Reland [MS][clang] Add support for vector deleting destructors" (#169116)

This reverts 4d10c11 and its two
dependent commits: e6b9805 and
c243406, see discussion in
#165598 (comment).

Author: ZequanWu

clang/docs/ReleaseNotes.rst

@@ -84,12 +84,6 @@ Potentially Breaking Changes
 - Downstream projects that previously linked only against ``clangDriver`` may
   now (also) need to link against the new ``clangOptions`` library, since
   options-related code has been moved out of the Driver into a separate library.
-- Clang now supports MSVC vector deleting destructors when targeting Windows.
-  This means that vtables of classes with virtual destructors will contain a
-  pointer to vector deleting destructor (instead of scalar deleting destructor)
-  which in fact is a different symbol with different name and linkage. This
-  may cause runtime failures if two binaries using the same class defining a
-  virtual destructor are compiled with different versions of clang.
 
 C/C++ Language Potentially Breaking Changes
 -------------------------------------------
@@ -621,8 +615,6 @@ Windows Support
 - clang-cl now supports /arch:AVX10.1 and /arch:AVX10.2.
 - clang-cl now supports /vlen, /vlen=256 and /vlen=512.
 
-- Clang now supports MSVC vector deleting destructors (GH19772).
-
 LoongArch Support
 ^^^^^^^^^^^^^^^^^
 - Enable linker relaxation by default for loongarch64.

clang/include/clang/AST/ASTContext.h

@@ -370,18 +370,6 @@ class ASTContext : public RefCountedBase<ASTContext> {
   mutable llvm::DenseSet<const FunctionDecl *> DestroyingOperatorDeletes;
   mutable llvm::DenseSet<const FunctionDecl *> TypeAwareOperatorNewAndDeletes;
 
-  /// Global and array operators delete are only required for MSVC deleting
-  /// destructors support. Store them here to avoid keeping 4 pointers that are
-  /// not always used in each redeclaration of the destructor.
-  mutable llvm::DenseMap<const CXXDestructorDecl *, FunctionDecl *>
-      OperatorDeletesForVirtualDtor;
-  mutable llvm::DenseMap<const CXXDestructorDecl *, FunctionDecl *>
-      GlobalOperatorDeletesForVirtualDtor;
-  mutable llvm::DenseMap<const CXXDestructorDecl *, FunctionDecl *>
-      ArrayOperatorDeletesForVirtualDtor;
-  mutable llvm::DenseMap<const CXXDestructorDecl *, FunctionDecl *>
-      GlobalArrayOperatorDeletesForVirtualDtor;
-
   /// The next string literal "version" to allocate during constant evaluation.
   /// This is used to distinguish between repeated evaluations of the same
   /// string literal.
@@ -3485,16 +3473,6 @@ class ASTContext : public RefCountedBase<ASTContext> {
                                          bool IsTypeAware);
   bool isTypeAwareOperatorNewOrDelete(const FunctionDecl *FD) const;
 
-  enum OperatorDeleteKind { Regular, GlobalRegular, Array, ArrayGlobal };
-
-  void addOperatorDeleteForVDtor(const CXXDestructorDecl *Dtor,
-                                 FunctionDecl *OperatorDelete,
-                                 OperatorDeleteKind K) const;
-  FunctionDecl *getOperatorDeleteForVDtor(const CXXDestructorDecl *Dtor,
-                                          OperatorDeleteKind K) const;
-  bool dtorHasOperatorDelete(const CXXDestructorDecl *Dtor,
-                             OperatorDeleteKind K) const;
-
   /// Retrieve the context for computing mangling numbers in the given
   /// DeclContext.
   MangleNumberingContext &getManglingNumberContext(const DeclContext *DC);

clang/include/clang/AST/ASTMutationListener.h

@@ -90,15 +90,6 @@ class ASTMutationListener {
   virtual void ResolvedOperatorGlobDelete(const CXXDestructorDecl *DD,
                                           const FunctionDecl *GlobDelete) {}
 
-  /// A virtual destructor's operator array delete has been resolved.
-  virtual void ResolvedOperatorArrayDelete(const CXXDestructorDecl *DD,
-                                           const FunctionDecl *ArrayDelete) {}
-
-  /// A virtual destructor's operator global array delete has been resolved.
-  virtual void
-  ResolvedOperatorGlobArrayDelete(const CXXDestructorDecl *DD,
-                                  const FunctionDecl *GlobArrayDelete) {}
-
   /// An implicit member got a definition.
   virtual void CompletedImplicitDefinition(const FunctionDecl *D) {}
 

clang/include/clang/AST/DeclCXX.h

@@ -2872,6 +2872,8 @@ class CXXDestructorDecl : public CXXMethodDecl {
 
   // FIXME: Don't allocate storage for these except in the first declaration
   // of a virtual destructor.
+  FunctionDecl *OperatorDelete = nullptr;
+  FunctionDecl *OperatorGlobalDelete = nullptr;
   Expr *OperatorDeleteThisArg = nullptr;
 
   CXXDestructorDecl(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
@@ -2898,12 +2900,14 @@ class CXXDestructorDecl : public CXXMethodDecl {
 
   void setOperatorDelete(FunctionDecl *OD, Expr *ThisArg);
   void setOperatorGlobalDelete(FunctionDecl *OD);
-  void setOperatorArrayDelete(FunctionDecl *OD);
-  void setGlobalOperatorArrayDelete(FunctionDecl *OD);
-  const FunctionDecl *getOperatorDelete() const;
-  const FunctionDecl *getOperatorGlobalDelete() const;
-  const FunctionDecl *getArrayOperatorDelete() const;
-  const FunctionDecl *getGlobalArrayOperatorDelete() const;
+
+  const FunctionDecl *getOperatorDelete() const {
+    return getCanonicalDecl()->OperatorDelete;
+  }
+
+  const FunctionDecl *getOperatorGlobalDelete() const {
+    return getCanonicalDecl()->OperatorGlobalDelete;
+  }
 
   Expr *getOperatorDeleteThisArg() const {
     return getCanonicalDecl()->OperatorDeleteThisArg;

clang/include/clang/AST/VTableBuilder.h

@@ -150,7 +150,7 @@ class VTableComponent {
 
   bool isRTTIKind() const { return isRTTIKind(getKind()); }
 
-  GlobalDecl getGlobalDecl(bool HasVectorDeletingDtors) const {
+  GlobalDecl getGlobalDecl() const {
     assert(isUsedFunctionPointerKind() &&
            "GlobalDecl can be created only from virtual function");
 
@@ -161,9 +161,7 @@ class VTableComponent {
     case CK_CompleteDtorPointer:
       return GlobalDecl(DtorDecl, CXXDtorType::Dtor_Complete);
     case CK_DeletingDtorPointer:
-      return GlobalDecl(DtorDecl, (HasVectorDeletingDtors)
-                                      ? CXXDtorType::Dtor_VectorDeleting
-                                      : CXXDtorType::Dtor_Deleting);
+      return GlobalDecl(DtorDecl, CXXDtorType::Dtor_Deleting);
     case CK_VCallOffset:
     case CK_VBaseOffset:
     case CK_OffsetToTop:

clang/include/clang/Basic/ABI.h

@@ -32,12 +32,11 @@ enum CXXCtorType {
 
 /// C++ destructor types.
 enum CXXDtorType {
-  Dtor_Deleting,       ///< Deleting dtor
-  Dtor_Complete,       ///< Complete object dtor
-  Dtor_Base,           ///< Base object dtor
-  Dtor_Comdat,         ///< The COMDAT used for dtors
-  Dtor_Unified,        ///< GCC-style unified dtor
-  Dtor_VectorDeleting, ///< Vector deleting dtor
+  Dtor_Deleting, ///< Deleting dtor
+  Dtor_Complete, ///< Complete object dtor
+  Dtor_Base,     ///< Base object dtor
+  Dtor_Comdat,   ///< The COMDAT used for dtors
+  Dtor_Unified,  ///< GCC-style unified dtor
 };
 
 } // end namespace clang

clang/include/clang/Basic/TargetInfo.h

@@ -1796,11 +1796,6 @@ class TargetInfo : public TransferrableTargetInfo,
   /// destructor body.
   virtual bool callGlobalDeleteInDeletingDtor(const LangOptions &) const;
 
-  /// Controls whether to emit MSVC vector deleting destructors. The support for
-  /// vector deleting affects vtable layout and therefore is an ABI breaking
-  /// change. The support was only implemented at Clang 22 timeframe.
-  virtual bool emitVectorDeletingDtors(const LangOptions &) const;
-
   /// Controls if __builtin_longjmp / __builtin_setjmp can be lowered to
   /// llvm.eh.sjlj.longjmp / llvm.eh.sjlj.setjmp.
   virtual bool hasSjLjLowering() const {

clang/include/clang/Sema/Sema.h

@@ -8581,8 +8581,7 @@ class Sema final : public SemaBase {
   FunctionDecl *FindDeallocationFunctionForDestructor(SourceLocation StartLoc,
                                                       CXXRecordDecl *RD,
                                                       bool Diagnose,
-                                                      bool LookForGlobal,
-                                                      DeclarationName Name);
+                                                      bool LookForGlobal);
 
   /// ActOnCXXDelete - Parsed a C++ 'delete' expression (C++ 5.3.5), as in:
   /// @code ::delete ptr; @endcode

clang/include/clang/Serialization/ASTWriter.h

@@ -955,10 +955,6 @@ class ASTWriter : public ASTDeserializationListener,
                               Expr *ThisArg) override;
   void ResolvedOperatorGlobDelete(const CXXDestructorDecl *DD,
                                   const FunctionDecl *Delete) override;
-  void ResolvedOperatorArrayDelete(const CXXDestructorDecl *DD,
-                                   const FunctionDecl *Delete) override;
-  void ResolvedOperatorGlobArrayDelete(const CXXDestructorDecl *DD,
-                                       const FunctionDecl *Delete) override;
   void CompletedImplicitDefinition(const FunctionDecl *D) override;
   void InstantiationRequested(const ValueDecl *D) override;
   void VariableDefinitionInstantiated(const VarDecl *D) override;

clang/lib/AST/ASTContext.cpp

@@ -13337,71 +13337,6 @@ bool ASTContext::isTypeAwareOperatorNewOrDelete(const FunctionDecl *FD) const {
   return TypeAwareOperatorNewAndDeletes.contains(FD->getCanonicalDecl());
 }
 
-void ASTContext::addOperatorDeleteForVDtor(const CXXDestructorDecl *Dtor,
-                                           FunctionDecl *OperatorDelete,
-                                           OperatorDeleteKind K) const {
-  switch (K) {
-  case OperatorDeleteKind::Regular:
-    OperatorDeletesForVirtualDtor[Dtor->getCanonicalDecl()] = OperatorDelete;
-    break;
-  case OperatorDeleteKind::GlobalRegular:
-    GlobalOperatorDeletesForVirtualDtor[Dtor->getCanonicalDecl()] =
-        OperatorDelete;
-    break;
-  case OperatorDeleteKind::Array:
-    ArrayOperatorDeletesForVirtualDtor[Dtor->getCanonicalDecl()] =
-        OperatorDelete;
-    break;
-  case OperatorDeleteKind::ArrayGlobal:
-    GlobalArrayOperatorDeletesForVirtualDtor[Dtor->getCanonicalDecl()] =
-        OperatorDelete;
-    break;
-  }
-}
-
-bool ASTContext::dtorHasOperatorDelete(const CXXDestructorDecl *Dtor,
-                                       OperatorDeleteKind K) const {
-  switch (K) {
-  case OperatorDeleteKind::Regular:
-    return OperatorDeletesForVirtualDtor.contains(Dtor->getCanonicalDecl());
-  case OperatorDeleteKind::GlobalRegular:
-    return GlobalOperatorDeletesForVirtualDtor.contains(
-        Dtor->getCanonicalDecl());
-  case OperatorDeleteKind::Array:
-    return ArrayOperatorDeletesForVirtualDtor.contains(
-        Dtor->getCanonicalDecl());
-  case OperatorDeleteKind::ArrayGlobal:
-    return GlobalArrayOperatorDeletesForVirtualDtor.contains(
-        Dtor->getCanonicalDecl());
-  }
-  return false;
-}
-
-FunctionDecl *
-ASTContext::getOperatorDeleteForVDtor(const CXXDestructorDecl *Dtor,
-                                      OperatorDeleteKind K) const {
-  const CXXDestructorDecl *Canon = Dtor->getCanonicalDecl();
-  switch (K) {
-  case OperatorDeleteKind::Regular:
-    if (OperatorDeletesForVirtualDtor.contains(Canon))
-      return OperatorDeletesForVirtualDtor[Canon];
-    return nullptr;
-  case OperatorDeleteKind::GlobalRegular:
-    if (GlobalOperatorDeletesForVirtualDtor.contains(Canon))
-      return GlobalOperatorDeletesForVirtualDtor[Canon];
-    return nullptr;
-  case OperatorDeleteKind::Array:
-    if (ArrayOperatorDeletesForVirtualDtor.contains(Canon))
-      return ArrayOperatorDeletesForVirtualDtor[Canon];
-    return nullptr;
-  case OperatorDeleteKind::ArrayGlobal:
-    if (GlobalArrayOperatorDeletesForVirtualDtor.contains(Canon))
-      return GlobalArrayOperatorDeletesForVirtualDtor[Canon];
-    return nullptr;
-  }
-  return nullptr;
-}
-
 MangleNumberingContext &
 ASTContext::getManglingNumberContext(const DeclContext *DC) {
   assert(LangOpts.CPlusPlus);  // We don't need mangling numbers for plain C.