| //===-- CGCleanup.h - Classes for cleanups IR generation --------*- C++ -*-===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // These classes support the generation of LLVM IR for cleanups. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef LLVM_CLANG_LIB_CODEGEN_CGCLEANUP_H |
| #define LLVM_CLANG_LIB_CODEGEN_CGCLEANUP_H |
| |
| #include "EHScopeStack.h" |
| |
| #include "Address.h" |
| #include "llvm/ADT/SmallPtrSet.h" |
| #include "llvm/ADT/SmallVector.h" |
| |
| namespace llvm { |
| class BasicBlock; |
| class Value; |
| class ConstantInt; |
| class AllocaInst; |
| } |
| |
| namespace clang { |
| class FunctionDecl; |
| namespace CodeGen { |
| class CodeGenModule; |
| class CodeGenFunction; |
| |
| /// The MS C++ ABI needs a pointer to RTTI data plus some flags to describe the |
| /// type of a catch handler, so we use this wrapper. |
| struct CatchTypeInfo { |
| llvm::Constant *RTTI; |
| unsigned Flags; |
| }; |
| |
| /// A protected scope for zero-cost EH handling. |
| class EHScope { |
| llvm::BasicBlock *CachedLandingPad; |
| llvm::BasicBlock *CachedEHDispatchBlock; |
| |
| EHScopeStack::stable_iterator EnclosingEHScope; |
| |
| class CommonBitFields { |
| friend class EHScope; |
| unsigned Kind : 3; |
| }; |
| enum { NumCommonBits = 3 }; |
| |
| protected: |
| class CatchBitFields { |
| friend class EHCatchScope; |
| unsigned : NumCommonBits; |
| |
| unsigned NumHandlers : 32 - NumCommonBits; |
| }; |
| |
| class CleanupBitFields { |
| friend class EHCleanupScope; |
| unsigned : NumCommonBits; |
| |
| /// Whether this cleanup needs to be run along normal edges. |
| unsigned IsNormalCleanup : 1; |
| |
| /// Whether this cleanup needs to be run along exception edges. |
| unsigned IsEHCleanup : 1; |
| |
| /// Whether this cleanup is currently active. |
| unsigned IsActive : 1; |
| |
| /// Whether this cleanup is a lifetime marker |
| unsigned IsLifetimeMarker : 1; |
| |
| /// Whether the normal cleanup should test the activation flag. |
| unsigned TestFlagInNormalCleanup : 1; |
| |
| /// Whether the EH cleanup should test the activation flag. |
| unsigned TestFlagInEHCleanup : 1; |
| |
| /// The amount of extra storage needed by the Cleanup. |
| /// Always a multiple of the scope-stack alignment. |
| unsigned CleanupSize : 12; |
| }; |
| |
| class FilterBitFields { |
| friend class EHFilterScope; |
| unsigned : NumCommonBits; |
| |
| unsigned NumFilters : 32 - NumCommonBits; |
| }; |
| |
| union { |
| CommonBitFields CommonBits; |
| CatchBitFields CatchBits; |
| CleanupBitFields CleanupBits; |
| FilterBitFields FilterBits; |
| }; |
| |
| public: |
| enum Kind { Cleanup, Catch, Terminate, Filter }; |
| |
| EHScope(Kind kind, EHScopeStack::stable_iterator enclosingEHScope) |
| : CachedLandingPad(nullptr), CachedEHDispatchBlock(nullptr), |
| EnclosingEHScope(enclosingEHScope) { |
| CommonBits.Kind = kind; |
| } |
| |
| Kind getKind() const { return static_cast<Kind>(CommonBits.Kind); } |
| |
| llvm::BasicBlock *getCachedLandingPad() const { |
| return CachedLandingPad; |
| } |
| |
| void setCachedLandingPad(llvm::BasicBlock *block) { |
| CachedLandingPad = block; |
| } |
| |
| llvm::BasicBlock *getCachedEHDispatchBlock() const { |
| return CachedEHDispatchBlock; |
| } |
| |
| void setCachedEHDispatchBlock(llvm::BasicBlock *block) { |
| CachedEHDispatchBlock = block; |
| } |
| |
| bool hasEHBranches() const { |
| if (llvm::BasicBlock *block = getCachedEHDispatchBlock()) |
| return !block->use_empty(); |
| return false; |
| } |
| |
| EHScopeStack::stable_iterator getEnclosingEHScope() const { |
| return EnclosingEHScope; |
| } |
| }; |
| |
| /// A scope which attempts to handle some, possibly all, types of |
| /// exceptions. |
| /// |
| /// Objective C \@finally blocks are represented using a cleanup scope |
| /// after the catch scope. |
| class EHCatchScope : public EHScope { |
| // In effect, we have a flexible array member |
| // Handler Handlers[0]; |
| // But that's only standard in C99, not C++, so we have to do |
| // annoying pointer arithmetic instead. |
| |
| public: |
| struct Handler { |
| /// A type info value, or null (C++ null, not an LLVM null pointer) |
| /// for a catch-all. |
| CatchTypeInfo Type; |
| |
| /// The catch handler for this type. |
| llvm::BasicBlock *Block; |
| |
| bool isCatchAll() const { return Type.RTTI == nullptr; } |
| }; |
| |
| private: |
| friend class EHScopeStack; |
| |
| Handler *getHandlers() { |
| return reinterpret_cast<Handler*>(this+1); |
| } |
| |
| const Handler *getHandlers() const { |
| return reinterpret_cast<const Handler*>(this+1); |
| } |
| |
| public: |
| static size_t getSizeForNumHandlers(unsigned N) { |
| return sizeof(EHCatchScope) + N * sizeof(Handler); |
| } |
| |
| EHCatchScope(unsigned numHandlers, |
| EHScopeStack::stable_iterator enclosingEHScope) |
| : EHScope(Catch, enclosingEHScope) { |
| CatchBits.NumHandlers = numHandlers; |
| assert(CatchBits.NumHandlers == numHandlers && "NumHandlers overflow?"); |
| } |
| |
| unsigned getNumHandlers() const { |
| return CatchBits.NumHandlers; |
| } |
| |
| void setCatchAllHandler(unsigned I, llvm::BasicBlock *Block) { |
| setHandler(I, CatchTypeInfo{nullptr, 0}, Block); |
| } |
| |
| void setHandler(unsigned I, llvm::Constant *Type, llvm::BasicBlock *Block) { |
| assert(I < getNumHandlers()); |
| getHandlers()[I].Type = CatchTypeInfo{Type, 0}; |
| getHandlers()[I].Block = Block; |
| } |
| |
| void setHandler(unsigned I, CatchTypeInfo Type, llvm::BasicBlock *Block) { |
| assert(I < getNumHandlers()); |
| getHandlers()[I].Type = Type; |
| getHandlers()[I].Block = Block; |
| } |
| |
| const Handler &getHandler(unsigned I) const { |
| assert(I < getNumHandlers()); |
| return getHandlers()[I]; |
| } |
| |
| // Clear all handler blocks. |
| // FIXME: it's better to always call clearHandlerBlocks in DTOR and have a |
| // 'takeHandler' or some such function which removes ownership from the |
| // EHCatchScope object if the handlers should live longer than EHCatchScope. |
| void clearHandlerBlocks() { |
| for (unsigned I = 0, N = getNumHandlers(); I != N; ++I) |
| delete getHandler(I).Block; |
| } |
| |
| typedef const Handler *iterator; |
| iterator begin() const { return getHandlers(); } |
| iterator end() const { return getHandlers() + getNumHandlers(); } |
| |
| static bool classof(const EHScope *Scope) { |
| return Scope->getKind() == Catch; |
| } |
| }; |
| |
| /// A cleanup scope which generates the cleanup blocks lazily. |
| class alignas(8) EHCleanupScope : public EHScope { |
| /// The nearest normal cleanup scope enclosing this one. |
| EHScopeStack::stable_iterator EnclosingNormal; |
| |
| /// The nearest EH scope enclosing this one. |
| EHScopeStack::stable_iterator EnclosingEH; |
| |
| /// The dual entry/exit block along the normal edge. This is lazily |
| /// created if needed before the cleanup is popped. |
| llvm::BasicBlock *NormalBlock; |
| |
| /// An optional i1 variable indicating whether this cleanup has been |
| /// activated yet. |
| llvm::AllocaInst *ActiveFlag; |
| |
| /// Extra information required for cleanups that have resolved |
| /// branches through them. This has to be allocated on the side |
| /// because everything on the cleanup stack has be trivially |
| /// movable. |
| struct ExtInfo { |
| /// The destinations of normal branch-afters and branch-throughs. |
| llvm::SmallPtrSet<llvm::BasicBlock*, 4> Branches; |
| |
| /// Normal branch-afters. |
| SmallVector<std::pair<llvm::BasicBlock*,llvm::ConstantInt*>, 4> |
| BranchAfters; |
| }; |
| mutable struct ExtInfo *ExtInfo; |
| |
| /// The number of fixups required by enclosing scopes (not including |
| /// this one). If this is the top cleanup scope, all the fixups |
| /// from this index onwards belong to this scope. |
| unsigned FixupDepth; |
| |
| struct ExtInfo &getExtInfo() { |
| if (!ExtInfo) ExtInfo = new struct ExtInfo(); |
| return *ExtInfo; |
| } |
| |
| const struct ExtInfo &getExtInfo() const { |
| if (!ExtInfo) ExtInfo = new struct ExtInfo(); |
| return *ExtInfo; |
| } |
| |
| public: |
| /// Gets the size required for a lazy cleanup scope with the given |
| /// cleanup-data requirements. |
| static size_t getSizeForCleanupSize(size_t Size) { |
| return sizeof(EHCleanupScope) + Size; |
| } |
| |
| size_t getAllocatedSize() const { |
| return sizeof(EHCleanupScope) + CleanupBits.CleanupSize; |
| } |
| |
| EHCleanupScope(bool isNormal, bool isEH, unsigned cleanupSize, |
| unsigned fixupDepth, |
| EHScopeStack::stable_iterator enclosingNormal, |
| EHScopeStack::stable_iterator enclosingEH) |
| : EHScope(EHScope::Cleanup, enclosingEH), |
| EnclosingNormal(enclosingNormal), NormalBlock(nullptr), |
| ActiveFlag(nullptr), ExtInfo(nullptr), FixupDepth(fixupDepth) { |
| CleanupBits.IsNormalCleanup = isNormal; |
| CleanupBits.IsEHCleanup = isEH; |
| CleanupBits.IsActive = true; |
| CleanupBits.IsLifetimeMarker = false; |
| CleanupBits.TestFlagInNormalCleanup = false; |
| CleanupBits.TestFlagInEHCleanup = false; |
| CleanupBits.CleanupSize = cleanupSize; |
| |
| assert(CleanupBits.CleanupSize == cleanupSize && "cleanup size overflow"); |
| } |
| |
| void Destroy() { |
| delete ExtInfo; |
| } |
| // Objects of EHCleanupScope are not destructed. Use Destroy(). |
| ~EHCleanupScope() = delete; |
| |
| bool isNormalCleanup() const { return CleanupBits.IsNormalCleanup; } |
| llvm::BasicBlock *getNormalBlock() const { return NormalBlock; } |
| void setNormalBlock(llvm::BasicBlock *BB) { NormalBlock = BB; } |
| |
| bool isEHCleanup() const { return CleanupBits.IsEHCleanup; } |
| |
| bool isActive() const { return CleanupBits.IsActive; } |
| void setActive(bool A) { CleanupBits.IsActive = A; } |
| |
| bool isLifetimeMarker() const { return CleanupBits.IsLifetimeMarker; } |
| void setLifetimeMarker() { CleanupBits.IsLifetimeMarker = true; } |
| |
| bool hasActiveFlag() const { return ActiveFlag != nullptr; } |
| Address getActiveFlag() const { |
| return Address(ActiveFlag, CharUnits::One()); |
| } |
| void setActiveFlag(Address Var) { |
| assert(Var.getAlignment().isOne()); |
| ActiveFlag = cast<llvm::AllocaInst>(Var.getPointer()); |
| } |
| |
| void setTestFlagInNormalCleanup() { |
| CleanupBits.TestFlagInNormalCleanup = true; |
| } |
| bool shouldTestFlagInNormalCleanup() const { |
| return CleanupBits.TestFlagInNormalCleanup; |
| } |
| |
| void setTestFlagInEHCleanup() { |
| CleanupBits.TestFlagInEHCleanup = true; |
| } |
| bool shouldTestFlagInEHCleanup() const { |
| return CleanupBits.TestFlagInEHCleanup; |
| } |
| |
| unsigned getFixupDepth() const { return FixupDepth; } |
| EHScopeStack::stable_iterator getEnclosingNormalCleanup() const { |
| return EnclosingNormal; |
| } |
| |
| size_t getCleanupSize() const { return CleanupBits.CleanupSize; } |
| void *getCleanupBuffer() { return this + 1; } |
| |
| EHScopeStack::Cleanup *getCleanup() { |
| return reinterpret_cast<EHScopeStack::Cleanup*>(getCleanupBuffer()); |
| } |
| |
| /// True if this cleanup scope has any branch-afters or branch-throughs. |
| bool hasBranches() const { return ExtInfo && !ExtInfo->Branches.empty(); } |
| |
| /// Add a branch-after to this cleanup scope. A branch-after is a |
| /// branch from a point protected by this (normal) cleanup to a |
| /// point in the normal cleanup scope immediately containing it. |
| /// For example, |
| /// for (;;) { A a; break; } |
| /// contains a branch-after. |
| /// |
| /// Branch-afters each have their own destination out of the |
| /// cleanup, guaranteed distinct from anything else threaded through |
| /// it. Therefore branch-afters usually force a switch after the |
| /// cleanup. |
| void addBranchAfter(llvm::ConstantInt *Index, |
| llvm::BasicBlock *Block) { |
| struct ExtInfo &ExtInfo = getExtInfo(); |
| if (ExtInfo.Branches.insert(Block).second) |
| ExtInfo.BranchAfters.push_back(std::make_pair(Block, Index)); |
| } |
| |
| /// Return the number of unique branch-afters on this scope. |
| unsigned getNumBranchAfters() const { |
| return ExtInfo ? ExtInfo->BranchAfters.size() : 0; |
| } |
| |
| llvm::BasicBlock *getBranchAfterBlock(unsigned I) const { |
| assert(I < getNumBranchAfters()); |
| return ExtInfo->BranchAfters[I].first; |
| } |
| |
| llvm::ConstantInt *getBranchAfterIndex(unsigned I) const { |
| assert(I < getNumBranchAfters()); |
| return ExtInfo->BranchAfters[I].second; |
| } |
| |
| /// Add a branch-through to this cleanup scope. A branch-through is |
| /// a branch from a scope protected by this (normal) cleanup to an |
| /// enclosing scope other than the immediately-enclosing normal |
| /// cleanup scope. |
| /// |
| /// In the following example, the branch through B's scope is a |
| /// branch-through, while the branch through A's scope is a |
| /// branch-after: |
| /// for (;;) { A a; B b; break; } |
| /// |
| /// All branch-throughs have a common destination out of the |
| /// cleanup, one possibly shared with the fall-through. Therefore |
| /// branch-throughs usually don't force a switch after the cleanup. |
| /// |
| /// \return true if the branch-through was new to this scope |
| bool addBranchThrough(llvm::BasicBlock *Block) { |
| return getExtInfo().Branches.insert(Block).second; |
| } |
| |
| /// Determines if this cleanup scope has any branch throughs. |
| bool hasBranchThroughs() const { |
| if (!ExtInfo) return false; |
| return (ExtInfo->BranchAfters.size() != ExtInfo->Branches.size()); |
| } |
| |
| static bool classof(const EHScope *Scope) { |
| return (Scope->getKind() == Cleanup); |
| } |
| }; |
| // NOTE: there's a bunch of different data classes tacked on after an |
| // EHCleanupScope. It is asserted (in EHScopeStack::pushCleanup*) that |
| // they don't require greater alignment than ScopeStackAlignment. So, |
| // EHCleanupScope ought to have alignment equal to that -- not more |
| // (would be misaligned by the stack allocator), and not less (would |
| // break the appended classes). |
| static_assert(alignof(EHCleanupScope) == EHScopeStack::ScopeStackAlignment, |
| "EHCleanupScope expected alignment"); |
| |
| /// An exceptions scope which filters exceptions thrown through it. |
| /// Only exceptions matching the filter types will be permitted to be |
| /// thrown. |
| /// |
| /// This is used to implement C++ exception specifications. |
| class EHFilterScope : public EHScope { |
| // Essentially ends in a flexible array member: |
| // llvm::Value *FilterTypes[0]; |
| |
| llvm::Value **getFilters() { |
| return reinterpret_cast<llvm::Value**>(this+1); |
| } |
| |
| llvm::Value * const *getFilters() const { |
| return reinterpret_cast<llvm::Value* const *>(this+1); |
| } |
| |
| public: |
| EHFilterScope(unsigned numFilters) |
| : EHScope(Filter, EHScopeStack::stable_end()) { |
| FilterBits.NumFilters = numFilters; |
| assert(FilterBits.NumFilters == numFilters && "NumFilters overflow"); |
| } |
| |
| static size_t getSizeForNumFilters(unsigned numFilters) { |
| return sizeof(EHFilterScope) + numFilters * sizeof(llvm::Value*); |
| } |
| |
| unsigned getNumFilters() const { return FilterBits.NumFilters; } |
| |
| void setFilter(unsigned i, llvm::Value *filterValue) { |
| assert(i < getNumFilters()); |
| getFilters()[i] = filterValue; |
| } |
| |
| llvm::Value *getFilter(unsigned i) const { |
| assert(i < getNumFilters()); |
| return getFilters()[i]; |
| } |
| |
| static bool classof(const EHScope *scope) { |
| return scope->getKind() == Filter; |
| } |
| }; |
| |
| /// An exceptions scope which calls std::terminate if any exception |
| /// reaches it. |
| class EHTerminateScope : public EHScope { |
| public: |
| EHTerminateScope(EHScopeStack::stable_iterator enclosingEHScope) |
| : EHScope(Terminate, enclosingEHScope) {} |
| static size_t getSize() { return sizeof(EHTerminateScope); } |
| |
| static bool classof(const EHScope *scope) { |
| return scope->getKind() == Terminate; |
| } |
| }; |
| |
| /// A non-stable pointer into the scope stack. |
| class EHScopeStack::iterator { |
| char *Ptr; |
| |
| friend class EHScopeStack; |
| explicit iterator(char *Ptr) : Ptr(Ptr) {} |
| |
| public: |
| iterator() : Ptr(nullptr) {} |
| |
| EHScope *get() const { |
| return reinterpret_cast<EHScope*>(Ptr); |
| } |
| |
| EHScope *operator->() const { return get(); } |
| EHScope &operator*() const { return *get(); } |
| |
| iterator &operator++() { |
| size_t Size; |
| switch (get()->getKind()) { |
| case EHScope::Catch: |
| Size = EHCatchScope::getSizeForNumHandlers( |
| static_cast<const EHCatchScope *>(get())->getNumHandlers()); |
| break; |
| |
| case EHScope::Filter: |
| Size = EHFilterScope::getSizeForNumFilters( |
| static_cast<const EHFilterScope *>(get())->getNumFilters()); |
| break; |
| |
| case EHScope::Cleanup: |
| Size = static_cast<const EHCleanupScope *>(get())->getAllocatedSize(); |
| break; |
| |
| case EHScope::Terminate: |
| Size = EHTerminateScope::getSize(); |
| break; |
| } |
| Ptr += llvm::alignTo(Size, ScopeStackAlignment); |
| return *this; |
| } |
| |
| iterator next() { |
| iterator copy = *this; |
| ++copy; |
| return copy; |
| } |
| |
| iterator operator++(int) { |
| iterator copy = *this; |
| operator++(); |
| return copy; |
| } |
| |
| bool encloses(iterator other) const { return Ptr >= other.Ptr; } |
| bool strictlyEncloses(iterator other) const { return Ptr > other.Ptr; } |
| |
| bool operator==(iterator other) const { return Ptr == other.Ptr; } |
| bool operator!=(iterator other) const { return Ptr != other.Ptr; } |
| }; |
| |
| inline EHScopeStack::iterator EHScopeStack::begin() const { |
| return iterator(StartOfData); |
| } |
| |
| inline EHScopeStack::iterator EHScopeStack::end() const { |
| return iterator(EndOfBuffer); |
| } |
| |
| inline void EHScopeStack::popCatch() { |
| assert(!empty() && "popping exception stack when not empty"); |
| |
| EHCatchScope &scope = cast<EHCatchScope>(*begin()); |
| InnermostEHScope = scope.getEnclosingEHScope(); |
| deallocate(EHCatchScope::getSizeForNumHandlers(scope.getNumHandlers())); |
| } |
| |
| inline void EHScopeStack::popTerminate() { |
| assert(!empty() && "popping exception stack when not empty"); |
| |
| EHTerminateScope &scope = cast<EHTerminateScope>(*begin()); |
| InnermostEHScope = scope.getEnclosingEHScope(); |
| deallocate(EHTerminateScope::getSize()); |
| } |
| |
| inline EHScopeStack::iterator EHScopeStack::find(stable_iterator sp) const { |
| assert(sp.isValid() && "finding invalid savepoint"); |
| assert(sp.Size <= stable_begin().Size && "finding savepoint after pop"); |
| return iterator(EndOfBuffer - sp.Size); |
| } |
| |
| inline EHScopeStack::stable_iterator |
| EHScopeStack::stabilize(iterator ir) const { |
| assert(StartOfData <= ir.Ptr && ir.Ptr <= EndOfBuffer); |
| return stable_iterator(EndOfBuffer - ir.Ptr); |
| } |
| |
| /// The exceptions personality for a function. |
| struct EHPersonality { |
| const char *PersonalityFn; |
| |
| // If this is non-null, this personality requires a non-standard |
| // function for rethrowing an exception after a catchall cleanup. |
| // This function must have prototype void(void*). |
| const char *CatchallRethrowFn; |
| |
| static const EHPersonality &get(CodeGenModule &CGM, const FunctionDecl *FD); |
| static const EHPersonality &get(CodeGenFunction &CGF); |
| |
| static const EHPersonality GNU_C; |
| static const EHPersonality GNU_C_SJLJ; |
| static const EHPersonality GNU_C_SEH; |
| static const EHPersonality GNU_ObjC; |
| static const EHPersonality GNU_ObjC_SJLJ; |
| static const EHPersonality GNU_ObjC_SEH; |
| static const EHPersonality GNUstep_ObjC; |
| static const EHPersonality GNU_ObjCXX; |
| static const EHPersonality NeXT_ObjC; |
| static const EHPersonality GNU_CPlusPlus; |
| static const EHPersonality GNU_CPlusPlus_SJLJ; |
| static const EHPersonality GNU_CPlusPlus_SEH; |
| static const EHPersonality MSVC_except_handler; |
| static const EHPersonality MSVC_C_specific_handler; |
| static const EHPersonality MSVC_CxxFrameHandler3; |
| static const EHPersonality GNU_Wasm_CPlusPlus; |
| static const EHPersonality XL_CPlusPlus; |
| |
| /// Does this personality use landingpads or the family of pad instructions |
| /// designed to form funclets? |
| bool usesFuncletPads() const { |
| return isMSVCPersonality() || isWasmPersonality(); |
| } |
| |
| bool isMSVCPersonality() const { |
| return this == &MSVC_except_handler || this == &MSVC_C_specific_handler || |
| this == &MSVC_CxxFrameHandler3; |
| } |
| |
| bool isWasmPersonality() const { return this == &GNU_Wasm_CPlusPlus; } |
| |
| bool isMSVCXXPersonality() const { return this == &MSVC_CxxFrameHandler3; } |
| }; |
| } |
| } |
| |
| #endif |