llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-clangir @llvm/pr-subscribers-clang-modules Author: Mariya Podchishchaeva (Fznamznon) <details> <summary>Changes</summary> This reverts commit https://github.com/llvm/llvm-project/commit/54a4da9df6906b63878ad6d0ea6da3ed7d2d8432. MSVC supports an extension allowing to delete an array of objects via pointer whose static type doesn't match its dynamic type. This is done via generation of special destructors - vector deleting destructors. MSVC's virtual tables always contain a pointer to the vector deleting destructor for classes with virtual destructors, so not having this extension implemented causes clang to generate code that is not compatible with the code generated by MSVC, because clang always puts a pointer to a scalar deleting destructor to the vtable. As a bonus the deletion of an array of polymorphic object will work just like it does with MSVC - no memory leaks and correct destructors are called. This patch will cause clang to emit code that is compatible with code produced by MSVC but not compatible with code produced with clang of older versions, so the new behavior can be disabled via passing -fclang-abi-compat=21 (or lower). --- Patch is 125.55 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/170337.diff 61 Files Affected: - (modified) clang/docs/ReleaseNotes.rst (+8) - (modified) clang/include/clang/AST/ASTContext.h (+27) - (modified) clang/include/clang/AST/ASTMutationListener.h (+9) - (modified) clang/include/clang/AST/DeclCXX.h (+6-10) - (modified) clang/include/clang/AST/VTableBuilder.h (+4-2) - (modified) clang/include/clang/Basic/ABI.h (+6-5) - (modified) clang/include/clang/Basic/TargetInfo.h (+5) - (modified) clang/include/clang/Sema/Sema.h (+2-1) - (modified) clang/include/clang/Serialization/ASTWriter.h (+4) - (modified) clang/lib/AST/ASTContext.cpp (+85) - (modified) clang/lib/AST/DeclCXX.cpp (+63-10) - (modified) clang/lib/AST/Expr.cpp (+3) - (modified) clang/lib/AST/ItaniumMangle.cpp (+2) - (modified) clang/lib/AST/MicrosoftMangle.cpp (+13-9) - (modified) clang/lib/AST/VTableBuilder.cpp (+14-4) - (modified) clang/lib/Basic/TargetInfo.cpp (+7) - (modified) clang/lib/CIR/CodeGen/CIRGenExprCXX.cpp (+7) - (modified) clang/lib/CIR/CodeGen/CIRGenFunction.cpp (+4-1) - (modified) clang/lib/CIR/CodeGen/CIRGenVTables.cpp (+3-1) - (modified) clang/lib/CodeGen/CGCXX.cpp (+36-1) - (modified) clang/lib/CodeGen/CGCXXABI.cpp (+14) - (modified) clang/lib/CodeGen/CGCXXABI.h (+6) - (modified) clang/lib/CodeGen/CGClass.cpp (+94-1) - (modified) clang/lib/CodeGen/CGDebugInfo.cpp (+7-1) - (modified) clang/lib/CodeGen/CGExprCXX.cpp (+38-4) - (modified) clang/lib/CodeGen/CGVTables.cpp (+3-1) - (modified) clang/lib/CodeGen/CodeGenModule.h (+1) - (modified) clang/lib/CodeGen/ItaniumCXXABI.cpp (+4-1) - (modified) clang/lib/CodeGen/MicrosoftCXXABI.cpp (+56-14) - (modified) clang/lib/Sema/SemaDeclCXX.cpp (+33-2) - (modified) clang/lib/Sema/SemaExprCXX.cpp (+20-6) - (modified) clang/lib/Serialization/ASTCommon.h (+3-1) - (modified) clang/lib/Serialization/ASTReaderDecl.cpp (+53-13) - (modified) clang/lib/Serialization/ASTWriter.cpp (+36) - (modified) clang/lib/Serialization/ASTWriterDecl.cpp (+2) - (modified) clang/test/CodeGenCXX/dllexport.cpp (+3-2) - (modified) clang/test/CodeGenCXX/microsoft-abi-extern-template.cpp (+1-1) - (modified) clang/test/CodeGenCXX/microsoft-abi-structors.cpp (+1-1) - (modified) clang/test/CodeGenCXX/microsoft-abi-thunks.cpp (+1-2) - (modified) clang/test/CodeGenCXX/microsoft-abi-vftables.cpp (+10-10) - (modified) clang/test/CodeGenCXX/microsoft-abi-virtual-inheritance.cpp (+9-8) - (modified) clang/test/CodeGenCXX/microsoft-abi-vtables-multiple-nonvirtual-inheritance-vdtors.cpp (+9-9) - (modified) clang/test/CodeGenCXX/microsoft-abi-vtables-return-thunks.cpp (+1-1) - (modified) clang/test/CodeGenCXX/microsoft-abi-vtables-single-inheritance.cpp (+10-10) - (modified) clang/test/CodeGenCXX/microsoft-abi-vtables-virtual-inheritance-vtordisps.cpp (+15-15) - (modified) clang/test/CodeGenCXX/microsoft-abi-vtables-virtual-inheritance.cpp (+9-9) - (modified) clang/test/CodeGenCXX/microsoft-no-rtti-data.cpp (+1-1) - (added) clang/test/CodeGenCXX/microsoft-vector-deleting-dtors.cpp (+336) - (added) clang/test/CodeGenCXX/microsoft-vector-deleting-dtors2.cpp (+56) - (modified) clang/test/CodeGenCXX/vtable-consteval.cpp (+2-2) - (modified) clang/test/DebugInfo/CXX/ms-dtor-thunks.cpp (+3-3) - (modified) clang/test/DebugInfo/CXX/windows-dtor.cpp (+1-1) - (added) clang/test/Modules/Inputs/msvc-vector-deleting-dtors/module.modulemap (+1) - (added) clang/test/Modules/Inputs/msvc-vector-deleting-dtors/msvc-vector-deleting-dtors.h (+16) - (added) clang/test/Modules/msvc-vector-deleting-destructors.cpp (+30) - (modified) clang/test/Modules/vtable-windows.cppm (+1-1) - (added) clang/test/PCH/Inputs/msvc-vector-deleting-dtors.h (+16) - (added) clang/test/PCH/msvc-vector-deleting-destructors.cpp (+34) - (modified) clang/test/Profile/cxx-abc-deleting-dtor.cpp (+4-5) - (added) clang/test/SemaCXX/gh134265.cpp (+62) - (modified) lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp (+1) ``````````diff diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst index da064534c25d9..81cdf1627593c 100644 --- a/clang/docs/ReleaseNotes.rst +++ b/clang/docs/ReleaseNotes.rst @@ -86,6 +86,12 @@ Potentially Breaking Changes options-related code has been moved out of the Driver into a separate library. - The ``clangFrontend`` library no longer depends on ``clangDriver``, which may break downstream projects that relied on this transitive dependency. +- 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 ------------------------------------------- @@ -625,6 +631,8 @@ 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. diff --git a/clang/include/clang/AST/ASTContext.h b/clang/include/clang/AST/ASTContext.h index 33aa2d343aa7a..303d919448718 100644 --- a/clang/include/clang/AST/ASTContext.h +++ b/clang/include/clang/AST/ASTContext.h @@ -370,6 +370,21 @@ 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; + + /// To remember which types did require a vector deleting dtor. + llvm::DenseSet<const CXXRecordDecl *> RequireVectorDeletingDtor; + /// The next string literal "version" to allocate during constant evaluation. /// This is used to distinguish between repeated evaluations of the same /// string literal. @@ -3473,6 +3488,18 @@ 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; + void setClassNeedsVectorDeletingDestructor(const CXXRecordDecl *RD); + bool classNeedsVectorDeletingDestructor(const CXXRecordDecl *RD); + /// Retrieve the context for computing mangling numbers in the given /// DeclContext. MangleNumberingContext &getManglingNumberContext(const DeclContext *DC); diff --git a/clang/include/clang/AST/ASTMutationListener.h b/clang/include/clang/AST/ASTMutationListener.h index 352af42391782..c8448a25c23a4 100644 --- a/clang/include/clang/AST/ASTMutationListener.h +++ b/clang/include/clang/AST/ASTMutationListener.h @@ -90,6 +90,15 @@ 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) {} diff --git a/clang/include/clang/AST/DeclCXX.h b/clang/include/clang/AST/DeclCXX.h index dfa3befb27dd0..5c4ad3c45da19 100644 --- a/clang/include/clang/AST/DeclCXX.h +++ b/clang/include/clang/AST/DeclCXX.h @@ -2872,8 +2872,6 @@ 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, @@ -2900,14 +2898,12 @@ class CXXDestructorDecl : public CXXMethodDecl { void setOperatorDelete(FunctionDecl *OD, Expr *ThisArg); void setOperatorGlobalDelete(FunctionDecl *OD); - - const FunctionDecl *getOperatorDelete() const { - return getCanonicalDecl()->OperatorDelete; - } - - const FunctionDecl *getOperatorGlobalDelete() const { - return getCanonicalDecl()->OperatorGlobalDelete; - } + void setOperatorArrayDelete(FunctionDecl *OD); + void setGlobalOperatorArrayDelete(FunctionDecl *OD); + const FunctionDecl *getOperatorDelete() const; + const FunctionDecl *getOperatorGlobalDelete() const; + const FunctionDecl *getArrayOperatorDelete() const; + const FunctionDecl *getGlobalArrayOperatorDelete() const; Expr *getOperatorDeleteThisArg() const { return getCanonicalDecl()->OperatorDeleteThisArg; diff --git a/clang/include/clang/AST/VTableBuilder.h b/clang/include/clang/AST/VTableBuilder.h index a5de41dbc22f1..e1efe8cddcc5e 100644 --- a/clang/include/clang/AST/VTableBuilder.h +++ b/clang/include/clang/AST/VTableBuilder.h @@ -150,7 +150,7 @@ class VTableComponent { bool isRTTIKind() const { return isRTTIKind(getKind()); } - GlobalDecl getGlobalDecl() const { + GlobalDecl getGlobalDecl(bool HasVectorDeletingDtors) const { assert(isUsedFunctionPointerKind() && "GlobalDecl can be created only from virtual function"); @@ -161,7 +161,9 @@ class VTableComponent { case CK_CompleteDtorPointer: return GlobalDecl(DtorDecl, CXXDtorType::Dtor_Complete); case CK_DeletingDtorPointer: - return GlobalDecl(DtorDecl, CXXDtorType::Dtor_Deleting); + return GlobalDecl(DtorDecl, (HasVectorDeletingDtors) + ? CXXDtorType::Dtor_VectorDeleting + : CXXDtorType::Dtor_Deleting); case CK_VCallOffset: case CK_VBaseOffset: case CK_OffsetToTop: diff --git a/clang/include/clang/Basic/ABI.h b/clang/include/clang/Basic/ABI.h index 8279529c316cf..be3edccbf50b2 100644 --- a/clang/include/clang/Basic/ABI.h +++ b/clang/include/clang/Basic/ABI.h @@ -32,11 +32,12 @@ 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_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 }; } // end namespace clang diff --git a/clang/include/clang/Basic/TargetInfo.h b/clang/include/clang/Basic/TargetInfo.h index 1f5932225d31e..655f79a2e6ce1 100644 --- a/clang/include/clang/Basic/TargetInfo.h +++ b/clang/include/clang/Basic/TargetInfo.h @@ -1796,6 +1796,11 @@ 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 { diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h index 78ecbccbe4efc..ba921b39a1f63 100644 --- a/clang/include/clang/Sema/Sema.h +++ b/clang/include/clang/Sema/Sema.h @@ -8581,7 +8581,8 @@ class Sema final : public SemaBase { FunctionDecl *FindDeallocationFunctionForDestructor(SourceLocation StartLoc, CXXRecordDecl *RD, bool Diagnose, - bool LookForGlobal); + bool LookForGlobal, + DeclarationName Name); /// ActOnCXXDelete - Parsed a C++ 'delete' expression (C++ 5.3.5), as in: /// @code ::delete ptr; @endcode diff --git a/clang/include/clang/Serialization/ASTWriter.h b/clang/include/clang/Serialization/ASTWriter.h index c77c98dffc39f..dbbfc29058f43 100644 --- a/clang/include/clang/Serialization/ASTWriter.h +++ b/clang/include/clang/Serialization/ASTWriter.h @@ -955,6 +955,10 @@ 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; diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp index b359fc8350375..f508291a91bca 100644 --- a/clang/lib/AST/ASTContext.cpp +++ b/clang/lib/AST/ASTContext.cpp @@ -13337,6 +13337,91 @@ 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; +} + +bool ASTContext::classNeedsVectorDeletingDestructor(const CXXRecordDecl *RD) { + if (!getTargetInfo().emitVectorDeletingDtors(getLangOpts())) + return false; + CXXDestructorDecl *Dtor = RD->getDestructor(); + // The compiler can't know if new[]/delete[] will be used outside of the DLL, + // so just force vector deleting destructor emission if dllexport is present. + // This matches MSVC behavior. + if (Dtor && Dtor->isVirtual() && Dtor->hasAttr<DLLExportAttr>()) + return true; + + return RequireVectorDeletingDtor.count(RD); +} + +void ASTContext::setClassNeedsVectorDeletingDestructor( + const CXXRecordDecl *RD) { + if (!getTargetInfo().emitVectorDeletingDtors(getLangOpts())) + return; + RequireVectorDeletingDtor.insert(RD); +} + MangleNumberingContext & ASTContext::getManglingNumberContext(const DeclContext *DC) { assert(LangOpts.CPlusPlus); // We don't need mangling numbers for plain C. diff --git a/clang/lib/AST/DeclCXX.cpp b/clang/lib/AST/DeclCXX.cpp index 24e4f189cbe4a..c16b1bb7a3453 100644 --- a/clang/lib/AST/DeclCXX.cpp +++ b/clang/lib/AST/DeclCXX.cpp @@ -3110,12 +3110,15 @@ CXXDestructorDecl *CXXDestructorDecl::Create( } void CXXDestructorDecl::setOperatorDelete(FunctionDecl *OD, Expr *ThisArg) { - auto *First = cast<CXXDestructorDecl>(getFirstDecl()); - if (OD && !First->OperatorDelete) { - First->OperatorDelete = OD; - First->OperatorDeleteThisArg = ThisArg; + assert(!OD || (OD->getDeclName().getCXXOverloadedOperator() == OO_Delete)); + if (OD && !getASTContext().dtorHasOperatorDelete( + this, ASTContext::OperatorDeleteKind::Regular)) { + getASTContext().addOperatorDeleteForVDtor( + this, OD, ASTContext::OperatorDeleteKind::Regular); + getCanonicalDecl()->OperatorDeleteThisArg = ThisArg; if (auto *L = getASTMutationListener()) - L->ResolvedOperatorDelete(First, OD, ThisArg); + L->ResolvedOperatorDelete(cast<CXXDestructorDecl>(getCanonicalDecl()), OD, + ThisArg); } } @@ -3127,14 +3130,63 @@ void CXXDestructorDecl::setOperatorGlobalDelete(FunctionDecl *OD) { assert(!OD || (OD->getDeclName().getCXXOverloadedOperator() == OO_Delete && OD->getDeclContext()->getRedeclContext()->isTranslationUnit())); - auto *Canonical = cast<CXXDestructorDecl>(getCanonicalDecl()); - if (!Canonical->OperatorGlobalDelete) { - Canonical->OperatorGlobalDelete = OD; + if (OD && !getASTContext().dtorHasOperatorDelete( + this, ASTContext::OperatorDeleteKind::GlobalRegular)) { + getASTContext().addOperatorDeleteForVDtor( + this, OD, ASTContext::OperatorDeleteKind::GlobalRegular); if (auto *L = getASTMutationListener()) - L->ResolvedOperatorGlobDelete(Canonical, OD); + L->ResolvedOperatorGlobDelete(cast<CXXDestructorDecl>(getCanonicalDecl()), + OD); } } +void CXXDestructorDecl::setOperatorArrayDelete(FunctionDecl *OD) { + assert(!OD || + (OD->getDeclName().getCXXOverloadedOperator() == OO_Array_Delete)); + if (OD && !getASTContext().dtorHasOperatorDelete( + this, ASTContext::OperatorDeleteKind::Array)) { + getASTContext().addOperatorDeleteForVDtor( + this, OD, ASTContext::OperatorDeleteKind::Array); + if (auto *L = getASTMutationListener()) + L->ResolvedOperatorArrayDelete( + cast<CXXDestructorDecl>(getCanonicalDecl()), OD); + } +} + +void CXXDestructorDecl::setGlobalOperatorArrayDelete(FunctionDecl *OD) { + assert(!OD || + (OD->getDeclName().getCXXOverloadedOperator() == OO_Array_Delete && + OD->getDeclContext()->getRedeclContext()->isTranslationUnit())); + if (OD && !getASTContext().dtorHasOperatorDelete( + this, ASTContext::OperatorDeleteKind::ArrayGlobal)) { + getASTContext().addOperatorDeleteForVDtor( + this, OD, ASTContext::OperatorDeleteKind::ArrayGlobal); + if (auto *L = getASTMutationListener()) + L->ResolvedOperatorGlobArrayDelete( + cast<CXXDestructorDecl>(getCanonicalDecl()), OD); + } +} + +const FunctionDecl *CXXDestructorDecl::getOperatorDelete() const { + return getASTContext().getOperatorDeleteForVDtor( + this, ASTContext::OperatorDeleteKind::Regular); +} + +const FunctionDecl *CXXDestructorDecl::getOperatorGlobalDelete() const { + return getASTContext().getOperatorDeleteForVDtor( + this, ASTContext::OperatorDeleteKind::GlobalRegular); +} + +const FunctionDecl *CXXDestructorDecl::getArrayOperatorDelete() const { + return getASTContext().getOperatorDeleteForVDtor( + this, ASTContext::OperatorDeleteKind::Array); +} + +const FunctionDecl *CXXDestructorDecl::getGlobalArrayOperatorDelete() const { + return getASTContext().getOperatorDeleteForVDtor( + this, ASTContext::OperatorDeleteKind::ArrayGlobal); +} + bool CXXDestructorDecl::isCalledByDelete(const FunctionDecl *OpDel) const { // C++20 [expr.delete]p6: If the value of the operand of the delete- // expression is not a null pointer value and the selected deallocation @@ -3146,7 +3198,8 @@ bool CXXDestructorDecl::isCalledByDelete(const FunctionDecl *OpDel) const { // delete operator, as that destructor is never called, unless the // destructor is virtual (see [expr.delete]p8.1) because then the // selected operator depends on the dynamic type of the pointer. - const FunctionDecl *SelectedOperatorDelete = OpDel ? OpDel : OperatorDelete; + const FunctionDecl *SelectedOperatorDelete = + OpDel ? OpDel : getOperatorDelete(); if (!SelectedOperatorDelete) return true; diff --git a/clang/lib/AST/Expr.cpp b/clang/lib/AST/Expr.cpp index 1f405920ce6b5..e29967adbb09f 100644 --- a/clang/lib/AST/Expr.cpp +++ b/clang/lib/AST/Expr.cpp @@ -71,6 +71,9 @@ const CXXRecordDecl *Expr::getBestDynamicClassType() const { if (const PointerType *PTy = DerivedType->getAs<PointerType>()) DerivedType = PTy->getPointeeType(); + while (const ArrayType *ATy = DerivedType->getAsArrayTypeUnsafe()) + DerivedType = ATy->getElementType(); + if (DerivedType->isDependentType()) return nullptr; diff --git a/clang/lib/AST/ItaniumMangle.cpp b/clang/lib/AST/ItaniumMangle.cpp index 5572e0a7ae59c..a5bcf5c97e837 100644 --- a/clang/lib/AST/ItaniumMangle.cpp +++ b/clang/lib/AST/ItaniumMangle.cpp @@ -6040,6 +6040,8 @@ void CXXNameMangler::mangleCXXDtorType(CXXDtorType T) { case Dtor_Comdat: Out << "D5"; break; + case Dtor_VectorDeleting: + llvm_unreachable("Itanium ABI does not use vector deleting dtors"); } } diff --git a/clang/lib/AST/MicrosoftMangle.cpp b/clang/lib/AST/MicrosoftMangle.cpp index f1baf9f49384b..551aa7bf3321c 100644 --- a/clang/li... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/170337 _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
