https://github.com/andykaylor created https://github.com/llvm/llvm-project/pull/170753
This adds the `flags` variable to the EHScopeStack::Cleanup class and routes it through the existing handlers. None of the currently implemented handlers use these flags, but the flag will be needed for array and NRVO variable cleanup handling. >From c15d81c730091e536cb2e9d6ba0798d005833be0 Mon Sep 17 00:00:00 2001 From: Andy Kaylor <[email protected]> Date: Thu, 4 Dec 2025 13:33:28 -0800 Subject: [PATCH] [CIR][NFC] Add flag support for eh cleanups This adds the `flags` variable to the EHScopeStack::Cleanup class and routes it through the existing handlers. None of the currently implemented handlers use these flags, but the flag will be needed for array and NRVO variable cleanup handling. --- clang/include/clang/CIR/MissingFeatures.h | 3 +- clang/lib/CIR/CodeGen/CIRGenClass.cpp | 10 +++---- clang/lib/CIR/CodeGen/CIRGenCleanup.cpp | 18 ++++++++---- clang/lib/CIR/CodeGen/CIRGenCleanup.h | 1 + clang/lib/CIR/CodeGen/CIRGenDecl.cpp | 12 +++++--- clang/lib/CIR/CodeGen/CIRGenDeclOpenACC.cpp | 2 +- clang/lib/CIR/CodeGen/CIRGenExprCXX.cpp | 2 +- clang/lib/CIR/CodeGen/EHScopeStack.h | 32 ++++++++++++++++++++- 8 files changed, 61 insertions(+), 19 deletions(-) diff --git a/clang/include/clang/CIR/MissingFeatures.h b/clang/include/clang/CIR/MissingFeatures.h index a8d35a6336ab9..b8df0528ea18d 100644 --- a/clang/include/clang/CIR/MissingFeatures.h +++ b/clang/include/clang/CIR/MissingFeatures.h @@ -255,7 +255,7 @@ struct MissingFeatures { static bool devirtualizeDestructor() { return false; } static bool devirtualizeMemberFunction() { return false; } static bool dtorCleanups() { return false; } - static bool ehCleanupFlags() { return false; } + static bool ehCleanupActiveFlag() { return false; } static bool ehCleanupHasPrebranchedFallthrough() { return false; } static bool ehCleanupScope() { return false; } static bool ehCleanupScopeRequiresEHCleanup() { return false; } @@ -335,6 +335,7 @@ struct MissingFeatures { static bool thunks() { return false; } static bool tryEmitAsConstant() { return false; } static bool typeChecks() { return false; } + static bool useEHCleanupForArray() { return false; } static bool vaArgABILowering() { return false; } static bool vectorConstants() { return false; } static bool vlas() { return false; } diff --git a/clang/lib/CIR/CodeGen/CIRGenClass.cpp b/clang/lib/CIR/CodeGen/CIRGenClass.cpp index ca9fe939139cd..2a26e38bb214d 100644 --- a/clang/lib/CIR/CodeGen/CIRGenClass.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenClass.cpp @@ -149,7 +149,7 @@ struct CallBaseDtor final : EHScopeStack::Cleanup { CallBaseDtor(const CXXRecordDecl *base, bool baseIsVirtual) : baseClass(base), baseIsVirtual(baseIsVirtual) {} - void emit(CIRGenFunction &cgf) override { + void emit(CIRGenFunction &cgf, Flags flags) override { const CXXRecordDecl *derivedClass = cast<CXXMethodDecl>(cgf.curFuncDecl)->getParent(); @@ -924,7 +924,7 @@ mlir::Value loadThisForDtorDelete(CIRGenFunction &cgf, struct CallDtorDelete final : EHScopeStack::Cleanup { CallDtorDelete() {} - void emit(CIRGenFunction &cgf) override { + void emit(CIRGenFunction &cgf, Flags flags) override { const CXXDestructorDecl *dtor = cast<CXXDestructorDecl>(cgf.curFuncDecl); const CXXRecordDecl *classDecl = dtor->getParent(); cgf.emitDeleteCall(dtor->getOperatorDelete(), @@ -941,7 +941,7 @@ class DestroyField final : public EHScopeStack::Cleanup { DestroyField(const FieldDecl *field, CIRGenFunction::Destroyer *destroyer) : field(field), destroyer(destroyer) {} - void emit(CIRGenFunction &cgf) override { + void emit(CIRGenFunction &cgf, Flags flags) override { // Find the address of the field. Address thisValue = cgf.loadCXXThisAddress(); CanQualType recordTy = @@ -950,7 +950,7 @@ class DestroyField final : public EHScopeStack::Cleanup { LValue lv = cgf.emitLValueForField(thisLV, field); assert(lv.isSimple()); - assert(!cir::MissingFeatures::ehCleanupFlags()); + assert(!cir::MissingFeatures::useEHCleanupForArray()); cgf.emitDestroy(lv.getAddress(), field->getType(), destroyer); } }; @@ -1047,7 +1047,7 @@ void CIRGenFunction::enterDtorCleanups(const CXXDestructorDecl *dd, continue; CleanupKind cleanupKind = getCleanupKind(dtorKind); - assert(!cir::MissingFeatures::ehCleanupFlags()); + assert(!cir::MissingFeatures::useEHCleanupForArray()); ehStack.pushCleanup<DestroyField>(cleanupKind, field, getDestroyer(dtorKind)); } diff --git a/clang/lib/CIR/CodeGen/CIRGenCleanup.cpp b/clang/lib/CIR/CodeGen/CIRGenCleanup.cpp index 33f2de9137514..72d75cb443625 100644 --- a/clang/lib/CIR/CodeGen/CIRGenCleanup.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenCleanup.cpp @@ -210,11 +210,12 @@ EHCatchScope *EHScopeStack::pushCatch(unsigned numHandlers) { return scope; } -static void emitCleanup(CIRGenFunction &cgf, EHScopeStack::Cleanup *cleanup) { +static void emitCleanup(CIRGenFunction &cgf, EHScopeStack::Cleanup *cleanup, + EHScopeStack::Cleanup::Flags flags) { // Ask the cleanup to emit itself. assert(cgf.haveInsertPoint() && "expected insertion point"); - assert(!cir::MissingFeatures::ehCleanupFlags()); - cleanup->emit(cgf); + assert(!cir::MissingFeatures::ehCleanupActiveFlag()); + cleanup->emit(cgf, flags); assert(cgf.haveInsertPoint() && "cleanup ended with no insertion point?"); } @@ -284,7 +285,12 @@ void CIRGenFunction::popCleanupBlock() { reinterpret_cast<EHScopeStack::Cleanup *>(cleanupBufferHeap.get()); } - assert(!cir::MissingFeatures::ehCleanupFlags()); + EHScopeStack::Cleanup::Flags cleanupFlags; + if (scope.isNormalCleanup()) + cleanupFlags.setIsNormalCleanupKind(); + if (scope.isEHCleanup()) + cleanupFlags.setIsEHCleanupKind(); + // If we have a fallthrough and no other need for the cleanup, // emit it directly. @@ -292,7 +298,7 @@ void CIRGenFunction::popCleanupBlock() { assert(!cir::MissingFeatures::ehCleanupScopeRequiresEHCleanup()); ehStack.popCleanup(); scope.markEmitted(); - emitCleanup(*this, cleanup); + emitCleanup(*this, cleanup, cleanupFlags); } else { // Otherwise, the best approach is to thread everything through // the cleanup block and then try to clean up after ourselves. @@ -354,7 +360,7 @@ void CIRGenFunction::popCleanupBlock() { ehStack.popCleanup(); assert(ehStack.hasNormalCleanups() == hasEnclosingCleanups); - emitCleanup(*this, cleanup); + emitCleanup(*this, cleanup, cleanupFlags); // Append the prepared cleanup prologue from above. assert(!cir::MissingFeatures::cleanupAppendInsts()); diff --git a/clang/lib/CIR/CodeGen/CIRGenCleanup.h b/clang/lib/CIR/CodeGen/CIRGenCleanup.h index 9cc2556c05967..85dbde4058889 100644 --- a/clang/lib/CIR/CodeGen/CIRGenCleanup.h +++ b/clang/lib/CIR/CodeGen/CIRGenCleanup.h @@ -237,6 +237,7 @@ class alignas(EHScopeStack::ScopeStackAlignment) EHCleanupScope void setNormalBlock(mlir::Block *bb) { normalBlock = bb; } bool isNormalCleanup() const { return cleanupBits.isNormalCleanup; } + bool isEHCleanup() const { return cleanupBits.isEHCleanup; } bool isActive() const { return cleanupBits.isActive; } void setActive(bool isActive) { cleanupBits.isActive = isActive; } diff --git a/clang/lib/CIR/CodeGen/CIRGenDecl.cpp b/clang/lib/CIR/CodeGen/CIRGenDecl.cpp index c9e10840778b4..370b19cdb6191 100644 --- a/clang/lib/CIR/CodeGen/CIRGenDecl.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenDecl.cpp @@ -812,13 +812,16 @@ namespace { struct DestroyObject final : EHScopeStack::Cleanup { DestroyObject(Address addr, QualType type, CIRGenFunction::Destroyer *destroyer) - : addr(addr), type(type), destroyer(destroyer) {} + : addr(addr), type(type), destroyer(destroyer) { + assert(!cir::MissingFeatures::useEHCleanupForArray()); + } Address addr; QualType type; CIRGenFunction::Destroyer *destroyer; - void emit(CIRGenFunction &cgf) override { + void emit(CIRGenFunction &cgf, Flags flags) override { + assert(!cir::MissingFeatures::useEHCleanupForArray()); cgf.emitDestroy(addr, type, destroyer); } }; @@ -855,7 +858,7 @@ struct DestroyNRVOVariableCXX final struct CallStackRestore final : EHScopeStack::Cleanup { Address stack; CallStackRestore(Address stack) : stack(stack) {} - void emit(CIRGenFunction &cgf) override { + void emit(CIRGenFunction &cgf, Flags flags) override { mlir::Location loc = stack.getPointer().getLoc(); mlir::Value v = cgf.getBuilder().createLoad(loc, stack); cgf.getBuilder().createStackRestore(loc, v); @@ -957,6 +960,7 @@ void CIRGenFunction::emitDestroy(Address addr, QualType type, return; mlir::Value begin = addr.getPointer(); + assert(!cir::MissingFeatures::useEHCleanupForArray()); emitArrayDestroy(begin, length, type, elementAlign, destroyer); // If the array destroy didn't use the length op, we can erase it. @@ -1029,7 +1033,7 @@ void CIRGenFunction::emitAutoVarTypeCleanup( if (!destroyer) destroyer = getDestroyer(dtorKind); - assert(!cir::MissingFeatures::ehCleanupFlags()); + assert(!cir::MissingFeatures::useEHCleanupForArray()); ehStack.pushCleanup<DestroyObject>(cleanupKind, addr, type, destroyer); } diff --git a/clang/lib/CIR/CodeGen/CIRGenDeclOpenACC.cpp b/clang/lib/CIR/CodeGen/CIRGenDeclOpenACC.cpp index e72578e73c2fc..050f110c6e365 100644 --- a/clang/lib/CIR/CodeGen/CIRGenDeclOpenACC.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenDeclOpenACC.cpp @@ -45,7 +45,7 @@ struct OpenACCDeclareCleanup final : EHScopeStack::Cleanup { } } - void emit(CIRGenFunction &cgf) override { + void emit(CIRGenFunction &cgf, Flags flags) override { auto exitOp = mlir::acc::DeclareExitOp::create( cgf.getBuilder(), enterOp.getLoc(), enterOp, {}); diff --git a/clang/lib/CIR/CodeGen/CIRGenExprCXX.cpp b/clang/lib/CIR/CodeGen/CIRGenExprCXX.cpp index 81fd8ee106107..a4acbacfa0056 100644 --- a/clang/lib/CIR/CodeGen/CIRGenExprCXX.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenExprCXX.cpp @@ -690,7 +690,7 @@ struct CallObjectDelete final : EHScopeStack::Cleanup { QualType elementType) : ptr(ptr), operatorDelete(operatorDelete), elementType(elementType) {} - void emit(CIRGenFunction &cgf) override { + void emit(CIRGenFunction &cgf, Flags flags) override { cgf.emitDeleteCall(operatorDelete, ptr, elementType); } }; diff --git a/clang/lib/CIR/CodeGen/EHScopeStack.h b/clang/lib/CIR/CodeGen/EHScopeStack.h index 6455bd8a55c83..2ebe6df5c7cba 100644 --- a/clang/lib/CIR/CodeGen/EHScopeStack.h +++ b/clang/lib/CIR/CodeGen/EHScopeStack.h @@ -127,13 +127,43 @@ class EHScopeStack { virtual ~Cleanup() = default; + /// Generation flags. + class Flags { + enum { + F_IsForEH = 0x1, + F_IsNormalCleanupKind = 0x2, + F_IsEHCleanupKind = 0x4, + F_HasExitSwitch = 0x8, + }; + unsigned flags = 0; + + public: + Flags() = default; + + /// isForEH - true if the current emission is for an EH cleanup. + bool isForEHCleanup() const { return flags & F_IsForEH; } + bool isForNormalCleanup() const { return !isForEHCleanup(); } + void setIsForEHCleanup() { flags |= F_IsForEH; } + + bool isNormalCleanupKind() const { return flags & F_IsNormalCleanupKind; } + void setIsNormalCleanupKind() { flags |= F_IsNormalCleanupKind; } + + /// isEHCleanupKind - true if the cleanup was pushed as an EH + /// cleanup. + bool isEHCleanupKind() const { return flags & F_IsEHCleanupKind; } + void setIsEHCleanupKind() { flags |= F_IsEHCleanupKind; } + + bool hasExitSwitch() const { return flags & F_HasExitSwitch; } + void setHasExitSwitch() { flags |= F_HasExitSwitch; } + }; + /// Emit the cleanup. For normal cleanups, this is run in the /// same EH context as when the cleanup was pushed, i.e. the /// immediately-enclosing context of the cleanup scope. For /// EH cleanups, this is run in a terminate context. /// // \param flags cleanup kind. - virtual void emit(CIRGenFunction &cgf) = 0; + virtual void emit(CIRGenFunction &cgf, Flags flags) = 0; }; private: _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
