| //===-- CGCleanup.h - Classes for cleanups IR generation --------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // These classes support the generation of LLVM IR for cleanups. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef CLANG_CODEGEN_CGCLEANUP_H |
| #define CLANG_CODEGEN_CGCLEANUP_H |
| |
| #include "clang/Basic/LLVM.h" |
| #include "llvm/ADT/SmallPtrSet.h" |
| #include "llvm/ADT/SmallVector.h" |
| #include "llvm/IR/BasicBlock.h" |
| #include "llvm/IR/Value.h" |
| #include "llvm/IR/Instructions.h" |
| |
| namespace clang { |
| namespace CodeGen { |
| |
| class CodeGenFunction; |
| |
| /// A branch fixup. These are required when emitting a goto to a |
| /// label which hasn't been emitted yet. The goto is optimistically |
| /// emitted as a branch to the basic block for the label, and (if it |
| /// occurs in a scope with non-trivial cleanups) a fixup is added to |
| /// the innermost cleanup. When a (normal) cleanup is popped, any |
| /// unresolved fixups in that scope are threaded through the cleanup. |
| struct BranchFixup { |
| /// The block containing the terminator which needs to be modified |
| /// into a switch if this fixup is resolved into the current scope. |
| /// If null, LatestBranch points directly to the destination. |
| llvm::BasicBlock *OptimisticBranchBlock; |
| |
| /// The ultimate destination of the branch. |
| /// |
| /// This can be set to null to indicate that this fixup was |
| /// successfully resolved. |
| llvm::BasicBlock *Destination; |
| |
| /// The destination index value. |
| unsigned DestinationIndex; |
| |
| /// The initial branch of the fixup. |
| llvm::BranchInst *InitialBranch; |
| }; |
| |
| template <class T> struct InvariantValue { |
| typedef T type; |
| typedef T saved_type; |
| static bool needsSaving(type value) { return false; } |
| static saved_type save(CodeGenFunction &CGF, type value) { return value; } |
| static type restore(CodeGenFunction &CGF, saved_type value) { return value; } |
| }; |
| |
| /// A metaprogramming class for ensuring that a value will dominate an |
| /// arbitrary position in a function. |
| template <class T> struct DominatingValue : InvariantValue<T> {}; |
| |
| template <class T, bool mightBeInstruction = |
| llvm::is_base_of<llvm::Value, T>::value && |
| !llvm::is_base_of<llvm::Constant, T>::value && |
| !llvm::is_base_of<llvm::BasicBlock, T>::value> |
| struct DominatingPointer; |
| template <class T> struct DominatingPointer<T,false> : InvariantValue<T*> {}; |
| // template <class T> struct DominatingPointer<T,true> at end of file |
| |
| template <class T> struct DominatingValue<T*> : DominatingPointer<T> {}; |
| |
| enum CleanupKind { |
| EHCleanup = 0x1, |
| NormalCleanup = 0x2, |
| NormalAndEHCleanup = EHCleanup | NormalCleanup, |
| |
| InactiveCleanup = 0x4, |
| InactiveEHCleanup = EHCleanup | InactiveCleanup, |
| InactiveNormalCleanup = NormalCleanup | InactiveCleanup, |
| InactiveNormalAndEHCleanup = NormalAndEHCleanup | InactiveCleanup |
| }; |
| |
| /// A stack of scopes which respond to exceptions, including cleanups |
| /// and catch blocks. |
| class EHScopeStack { |
| public: |
| /// A saved depth on the scope stack. This is necessary because |
| /// pushing scopes onto the stack invalidates iterators. |
| class stable_iterator { |
| friend class EHScopeStack; |
| |
| /// Offset from StartOfData to EndOfBuffer. |
| ptrdiff_t Size; |
| |
| stable_iterator(ptrdiff_t Size) : Size(Size) {} |
| |
| public: |
| static stable_iterator invalid() { return stable_iterator(-1); } |
| stable_iterator() : Size(-1) {} |
| |
| bool isValid() const { return Size >= 0; } |
| |
| /// Returns true if this scope encloses I. |
| /// Returns false if I is invalid. |
| /// This scope must be valid. |
| bool encloses(stable_iterator I) const { return Size <= I.Size; } |
| |
| /// Returns true if this scope strictly encloses I: that is, |
| /// if it encloses I and is not I. |
| /// Returns false is I is invalid. |
| /// This scope must be valid. |
| bool strictlyEncloses(stable_iterator I) const { return Size < I.Size; } |
| |
| friend bool operator==(stable_iterator A, stable_iterator B) { |
| return A.Size == B.Size; |
| } |
| friend bool operator!=(stable_iterator A, stable_iterator B) { |
| return A.Size != B.Size; |
| } |
| }; |
| |
| /// Information for lazily generating a cleanup. Subclasses must be |
| /// POD-like: cleanups will not be destructed, and they will be |
| /// allocated on the cleanup stack and freely copied and moved |
| /// around. |
| /// |
| /// Cleanup implementations should generally be declared in an |
| /// anonymous namespace. |
| class Cleanup { |
| // Anchor the construction vtable. |
| virtual void anchor(); |
| public: |
| /// Generation flags. |
| class Flags { |
| enum { |
| F_IsForEH = 0x1, |
| F_IsNormalCleanupKind = 0x2, |
| F_IsEHCleanupKind = 0x4 |
| }; |
| unsigned flags; |
| |
| public: |
| Flags() : flags(0) {} |
| |
| /// 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; } |
| }; |
| |
| // Provide a virtual destructor to suppress a very common warning |
| // that unfortunately cannot be suppressed without this. Cleanups |
| // should not rely on this destructor ever being called. |
| virtual ~Cleanup() {} |
| |
| /// 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(CodeGenFunction &CGF, Flags flags) = 0; |
| }; |
| |
| /// ConditionalCleanupN stores the saved form of its N parameters, |
| /// then restores them and performs the cleanup. |
| template <class T, class A0> |
| class ConditionalCleanup1 : public Cleanup { |
| typedef typename DominatingValue<A0>::saved_type A0_saved; |
| A0_saved a0_saved; |
| |
| void Emit(CodeGenFunction &CGF, Flags flags) { |
| A0 a0 = DominatingValue<A0>::restore(CGF, a0_saved); |
| T(a0).Emit(CGF, flags); |
| } |
| |
| public: |
| ConditionalCleanup1(A0_saved a0) |
| : a0_saved(a0) {} |
| }; |
| |
| template <class T, class A0, class A1> |
| class ConditionalCleanup2 : public Cleanup { |
| typedef typename DominatingValue<A0>::saved_type A0_saved; |
| typedef typename DominatingValue<A1>::saved_type A1_saved; |
| A0_saved a0_saved; |
| A1_saved a1_saved; |
| |
| void Emit(CodeGenFunction &CGF, Flags flags) { |
| A0 a0 = DominatingValue<A0>::restore(CGF, a0_saved); |
| A1 a1 = DominatingValue<A1>::restore(CGF, a1_saved); |
| T(a0, a1).Emit(CGF, flags); |
| } |
| |
| public: |
| ConditionalCleanup2(A0_saved a0, A1_saved a1) |
| : a0_saved(a0), a1_saved(a1) {} |
| }; |
| |
| template <class T, class A0, class A1, class A2> |
| class ConditionalCleanup3 : public Cleanup { |
| typedef typename DominatingValue<A0>::saved_type A0_saved; |
| typedef typename DominatingValue<A1>::saved_type A1_saved; |
| typedef typename DominatingValue<A2>::saved_type A2_saved; |
| A0_saved a0_saved; |
| A1_saved a1_saved; |
| A2_saved a2_saved; |
| |
| void Emit(CodeGenFunction &CGF, Flags flags) { |
| A0 a0 = DominatingValue<A0>::restore(CGF, a0_saved); |
| A1 a1 = DominatingValue<A1>::restore(CGF, a1_saved); |
| A2 a2 = DominatingValue<A2>::restore(CGF, a2_saved); |
| T(a0, a1, a2).Emit(CGF, flags); |
| } |
| |
| public: |
| ConditionalCleanup3(A0_saved a0, A1_saved a1, A2_saved a2) |
| : a0_saved(a0), a1_saved(a1), a2_saved(a2) {} |
| }; |
| |
| template <class T, class A0, class A1, class A2, class A3> |
| class ConditionalCleanup4 : public Cleanup { |
| typedef typename DominatingValue<A0>::saved_type A0_saved; |
| typedef typename DominatingValue<A1>::saved_type A1_saved; |
| typedef typename DominatingValue<A2>::saved_type A2_saved; |
| typedef typename DominatingValue<A3>::saved_type A3_saved; |
| A0_saved a0_saved; |
| A1_saved a1_saved; |
| A2_saved a2_saved; |
| A3_saved a3_saved; |
| |
| void Emit(CodeGenFunction &CGF, Flags flags) { |
| A0 a0 = DominatingValue<A0>::restore(CGF, a0_saved); |
| A1 a1 = DominatingValue<A1>::restore(CGF, a1_saved); |
| A2 a2 = DominatingValue<A2>::restore(CGF, a2_saved); |
| A3 a3 = DominatingValue<A3>::restore(CGF, a3_saved); |
| T(a0, a1, a2, a3).Emit(CGF, flags); |
| } |
| |
| public: |
| ConditionalCleanup4(A0_saved a0, A1_saved a1, A2_saved a2, A3_saved a3) |
| : a0_saved(a0), a1_saved(a1), a2_saved(a2), a3_saved(a3) {} |
| }; |
| |
| private: |
| // The implementation for this class is in CGException.h and |
| // CGException.cpp; the definition is here because it's used as a |
| // member of CodeGenFunction. |
| |
| /// The start of the scope-stack buffer, i.e. the allocated pointer |
| /// for the buffer. All of these pointers are either simultaneously |
| /// null or simultaneously valid. |
| char *StartOfBuffer; |
| |
| /// The end of the buffer. |
| char *EndOfBuffer; |
| |
| /// The first valid entry in the buffer. |
| char *StartOfData; |
| |
| /// The innermost normal cleanup on the stack. |
| stable_iterator InnermostNormalCleanup; |
| |
| /// The innermost EH scope on the stack. |
| stable_iterator InnermostEHScope; |
| |
| /// The current set of branch fixups. A branch fixup is a jump to |
| /// an as-yet unemitted label, i.e. a label for which we don't yet |
| /// know the EH stack depth. Whenever we pop a cleanup, we have |
| /// to thread all the current branch fixups through it. |
| /// |
| /// Fixups are recorded as the Use of the respective branch or |
| /// switch statement. The use points to the final destination. |
| /// When popping out of a cleanup, these uses are threaded through |
| /// the cleanup and adjusted to point to the new cleanup. |
| /// |
| /// Note that branches are allowed to jump into protected scopes |
| /// in certain situations; e.g. the following code is legal: |
| /// struct A { ~A(); }; // trivial ctor, non-trivial dtor |
| /// goto foo; |
| /// A a; |
| /// foo: |
| /// bar(); |
| SmallVector<BranchFixup, 8> BranchFixups; |
| |
| char *allocate(size_t Size); |
| |
| void *pushCleanup(CleanupKind K, size_t DataSize); |
| |
| public: |
| EHScopeStack() : StartOfBuffer(0), EndOfBuffer(0), StartOfData(0), |
| InnermostNormalCleanup(stable_end()), |
| InnermostEHScope(stable_end()) {} |
| ~EHScopeStack() { delete[] StartOfBuffer; } |
| |
| // Variadic templates would make this not terrible. |
| |
| /// Push a lazily-created cleanup on the stack. |
| template <class T> |
| void pushCleanup(CleanupKind Kind) { |
| void *Buffer = pushCleanup(Kind, sizeof(T)); |
| Cleanup *Obj = new(Buffer) T(); |
| (void) Obj; |
| } |
| |
| /// Push a lazily-created cleanup on the stack. |
| template <class T, class A0> |
| void pushCleanup(CleanupKind Kind, A0 a0) { |
| void *Buffer = pushCleanup(Kind, sizeof(T)); |
| Cleanup *Obj = new(Buffer) T(a0); |
| (void) Obj; |
| } |
| |
| /// Push a lazily-created cleanup on the stack. |
| template <class T, class A0, class A1> |
| void pushCleanup(CleanupKind Kind, A0 a0, A1 a1) { |
| void *Buffer = pushCleanup(Kind, sizeof(T)); |
| Cleanup *Obj = new(Buffer) T(a0, a1); |
| (void) Obj; |
| } |
| |
| /// Push a lazily-created cleanup on the stack. |
| template <class T, class A0, class A1, class A2> |
| void pushCleanup(CleanupKind Kind, A0 a0, A1 a1, A2 a2) { |
| void *Buffer = pushCleanup(Kind, sizeof(T)); |
| Cleanup *Obj = new(Buffer) T(a0, a1, a2); |
| (void) Obj; |
| } |
| |
| /// Push a lazily-created cleanup on the stack. |
| template <class T, class A0, class A1, class A2, class A3> |
| void pushCleanup(CleanupKind Kind, A0 a0, A1 a1, A2 a2, A3 a3) { |
| void *Buffer = pushCleanup(Kind, sizeof(T)); |
| Cleanup *Obj = new(Buffer) T(a0, a1, a2, a3); |
| (void) Obj; |
| } |
| |
| /// Push a lazily-created cleanup on the stack. |
| template <class T, class A0, class A1, class A2, class A3, class A4> |
| void pushCleanup(CleanupKind Kind, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { |
| void *Buffer = pushCleanup(Kind, sizeof(T)); |
| Cleanup *Obj = new(Buffer) T(a0, a1, a2, a3, a4); |
| (void) Obj; |
| } |
| |
| // Feel free to add more variants of the following: |
| |
| /// Push a cleanup with non-constant storage requirements on the |
| /// stack. The cleanup type must provide an additional static method: |
| /// static size_t getExtraSize(size_t); |
| /// The argument to this method will be the value N, which will also |
| /// be passed as the first argument to the constructor. |
| /// |
| /// The data stored in the extra storage must obey the same |
| /// restrictions as normal cleanup member data. |
| /// |
| /// The pointer returned from this method is valid until the cleanup |
| /// stack is modified. |
| template <class T, class A0, class A1, class A2> |
| T *pushCleanupWithExtra(CleanupKind Kind, size_t N, A0 a0, A1 a1, A2 a2) { |
| void *Buffer = pushCleanup(Kind, sizeof(T) + T::getExtraSize(N)); |
| return new (Buffer) T(N, a0, a1, a2); |
| } |
| |
| void pushCopyOfCleanup(CleanupKind Kind, const void *Cleanup, size_t Size) { |
| void *Buffer = pushCleanup(Kind, Size); |
| std::memcpy(Buffer, Cleanup, Size); |
| } |
| |
| /// Pops a cleanup scope off the stack. This is private to CGCleanup.cpp. |
| void popCleanup(); |
| |
| /// Push a set of catch handlers on the stack. The catch is |
| /// uninitialized and will need to have the given number of handlers |
| /// set on it. |
| class EHCatchScope *pushCatch(unsigned NumHandlers); |
| |
| /// Pops a catch scope off the stack. This is private to CGException.cpp. |
| void popCatch(); |
| |
| /// Push an exceptions filter on the stack. |
| class EHFilterScope *pushFilter(unsigned NumFilters); |
| |
| /// Pops an exceptions filter off the stack. |
| void popFilter(); |
| |
| /// Push a terminate handler on the stack. |
| void pushTerminate(); |
| |
| /// Pops a terminate handler off the stack. |
| void popTerminate(); |
| |
| /// Determines whether the exception-scopes stack is empty. |
| bool empty() const { return StartOfData == EndOfBuffer; } |
| |
| bool requiresLandingPad() const { |
| return InnermostEHScope != stable_end(); |
| } |
| |
| /// Determines whether there are any normal cleanups on the stack. |
| bool hasNormalCleanups() const { |
| return InnermostNormalCleanup != stable_end(); |
| } |
| |
| /// Returns the innermost normal cleanup on the stack, or |
| /// stable_end() if there are no normal cleanups. |
| stable_iterator getInnermostNormalCleanup() const { |
| return InnermostNormalCleanup; |
| } |
| stable_iterator getInnermostActiveNormalCleanup() const; |
| |
| stable_iterator getInnermostEHScope() const { |
| return InnermostEHScope; |
| } |
| |
| stable_iterator getInnermostActiveEHScope() const; |
| |
| /// An unstable reference to a scope-stack depth. Invalidated by |
| /// pushes but not pops. |
| class iterator; |
| |
| /// Returns an iterator pointing to the innermost EH scope. |
| iterator begin() const; |
| |
| /// Returns an iterator pointing to the outermost EH scope. |
| iterator end() const; |
| |
| /// Create a stable reference to the top of the EH stack. The |
| /// returned reference is valid until that scope is popped off the |
| /// stack. |
| stable_iterator stable_begin() const { |
| return stable_iterator(EndOfBuffer - StartOfData); |
| } |
| |
| /// Create a stable reference to the bottom of the EH stack. |
| static stable_iterator stable_end() { |
| return stable_iterator(0); |
| } |
| |
| /// Translates an iterator into a stable_iterator. |
| stable_iterator stabilize(iterator it) const; |
| |
| /// Turn a stable reference to a scope depth into a unstable pointer |
| /// to the EH stack. |
| iterator find(stable_iterator save) const; |
| |
| /// Removes the cleanup pointed to by the given stable_iterator. |
| void removeCleanup(stable_iterator save); |
| |
| /// Add a branch fixup to the current cleanup scope. |
| BranchFixup &addBranchFixup() { |
| assert(hasNormalCleanups() && "adding fixup in scope without cleanups"); |
| BranchFixups.push_back(BranchFixup()); |
| return BranchFixups.back(); |
| } |
| |
| unsigned getNumBranchFixups() const { return BranchFixups.size(); } |
| BranchFixup &getBranchFixup(unsigned I) { |
| assert(I < getNumBranchFixups()); |
| return BranchFixups[I]; |
| } |
| |
| /// Pops lazily-removed fixups from the end of the list. This |
| /// should only be called by procedures which have just popped a |
| /// cleanup or resolved one or more fixups. |
| void popNullFixups(); |
| |
| /// Clears the branch-fixups list. This should only be called by |
| /// ResolveAllBranchFixups. |
| void clearFixups() { BranchFixups.clear(); } |
| }; |
| |
| /// 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 : 2; |
| }; |
| enum { NumCommonBits = 2 }; |
| |
| 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 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; |
| |
| /// 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 : 32 - 17 - NumCommonBits; // currently 13 |
| }; |
| |
| 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(0), CachedEHDispatchBlock(0), |
| 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. |
| llvm::Value *Type; |
| |
| /// The catch handler for this type. |
| llvm::BasicBlock *Block; |
| |
| bool isCatchAll() const { return Type == 0; } |
| }; |
| |
| 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; |
| } |
| |
| unsigned getNumHandlers() const { |
| return CatchBits.NumHandlers; |
| } |
| |
| void setCatchAllHandler(unsigned I, llvm::BasicBlock *Block) { |
| setHandler(I, /*catchall*/ 0, Block); |
| } |
| |
| void setHandler(unsigned I, llvm::Value *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]; |
| } |
| |
| 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 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; |
| |
| 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, bool isActive, |
| unsigned cleanupSize, unsigned fixupDepth, |
| EHScopeStack::stable_iterator enclosingNormal, |
| EHScopeStack::stable_iterator enclosingEH) |
| : EHScope(EHScope::Cleanup, enclosingEH), EnclosingNormal(enclosingNormal), |
| NormalBlock(0), ActiveFlag(0), ExtInfo(0) { |
| CleanupBits.IsNormalCleanup = isNormal; |
| CleanupBits.IsEHCleanup = isEH; |
| CleanupBits.IsActive = isActive; |
| CleanupBits.TestFlagInNormalCleanup = false; |
| CleanupBits.TestFlagInEHCleanup = false; |
| CleanupBits.CleanupSize = cleanupSize; |
| CleanupBits.FixupDepth = fixupDepth; |
| |
| assert(CleanupBits.CleanupSize == cleanupSize && "cleanup size overflow"); |
| } |
| |
| ~EHCleanupScope() { |
| delete ExtInfo; |
| } |
| |
| 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; } |
| llvm::BasicBlock *getEHBlock() const { return getCachedEHDispatchBlock(); } |
| void setEHBlock(llvm::BasicBlock *BB) { setCachedEHDispatchBlock(BB); } |
| |
| bool isActive() const { return CleanupBits.IsActive; } |
| void setActive(bool A) { CleanupBits.IsActive = A; } |
| |
| llvm::AllocaInst *getActiveFlag() const { return ActiveFlag; } |
| void setActiveFlag(llvm::AllocaInst *Var) { ActiveFlag = Var; } |
| |
| 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 CleanupBits.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)) |
| 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); |
| } |
| |
| /// 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); |
| } |
| }; |
| |
| /// 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; |
| } |
| |
| 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(0) {} |
| |
| EHScope *get() const { |
| return reinterpret_cast<EHScope*>(Ptr); |
| } |
| |
| EHScope *operator->() const { return get(); } |
| EHScope &operator*() const { return *get(); } |
| |
| iterator &operator++() { |
| switch (get()->getKind()) { |
| case EHScope::Catch: |
| Ptr += EHCatchScope::getSizeForNumHandlers( |
| static_cast<const EHCatchScope*>(get())->getNumHandlers()); |
| break; |
| |
| case EHScope::Filter: |
| Ptr += EHFilterScope::getSizeForNumFilters( |
| static_cast<const EHFilterScope*>(get())->getNumFilters()); |
| break; |
| |
| case EHScope::Cleanup: |
| Ptr += static_cast<const EHCleanupScope*>(get()) |
| ->getAllocatedSize(); |
| break; |
| |
| case EHScope::Terminate: |
| Ptr += EHTerminateScope::getSize(); |
| break; |
| } |
| |
| 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(); |
| StartOfData += EHCatchScope::getSizeForNumHandlers(scope.getNumHandlers()); |
| } |
| |
| inline void EHScopeStack::popTerminate() { |
| assert(!empty() && "popping exception stack when not empty"); |
| |
| EHTerminateScope &scope = cast<EHTerminateScope>(*begin()); |
| InnermostEHScope = scope.getEnclosingEHScope(); |
| StartOfData += 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); |
| } |
| |
| } |
| } |
| |
| #endif |