13#ifndef LLVM_CLANG_LIB_CODEGEN_CGCLEANUP_H
14#define LLVM_CLANG_LIB_CODEGEN_CGCLEANUP_H
19#include "llvm/ADT/SmallPtrSet.h"
20#include "llvm/ADT/SmallVector.h"
47 llvm::BasicBlock *CachedLandingPad;
48 llvm::BasicBlock *CachedEHDispatchBlock;
52 class CommonBitFields {
54 LLVM_PREFERRED_TYPE(Kind)
57 enum { NumCommonBits = 3 };
64 unsigned NumHandlers : 32 - NumCommonBits;
72 LLVM_PREFERRED_TYPE(
bool)
73 unsigned IsNormalCleanup : 1;
76 LLVM_PREFERRED_TYPE(
bool)
77 unsigned IsEHCleanup : 1;
80 LLVM_PREFERRED_TYPE(
bool)
81 unsigned IsActive : 1;
84 LLVM_PREFERRED_TYPE(
bool)
85 unsigned IsLifetimeMarker : 1;
88 LLVM_PREFERRED_TYPE(
bool)
89 unsigned TestFlagInNormalCleanup : 1;
92 LLVM_PREFERRED_TYPE(
bool)
93 unsigned TestFlagInEHCleanup : 1;
97 unsigned CleanupSize : 12;
104 unsigned NumFilters : 32 - NumCommonBits;
116 : CachedLandingPad(nullptr), CachedEHDispatchBlock(nullptr),
117 EnclosingEHScope(enclosingEHScope) {
124 return CachedLandingPad;
128 CachedLandingPad = block;
132 return CachedEHDispatchBlock;
136 CachedEHDispatchBlock = block;
141 return !block->use_empty();
146 return EnclosingEHScope;
177 return reinterpret_cast<Handler*
>(
this+1);
180 const Handler *getHandlers()
const {
181 return reinterpret_cast<const Handler*
>(
this+1);
193 assert(
CatchBits.NumHandlers == numHandlers &&
"NumHandlers overflow?");
218 return getHandlers()[I];
249 llvm::BasicBlock *NormalBlock;
267 mutable struct ExtInfo *ExtInfo;
274 struct ExtInfo &getExtInfo() {
275 if (!ExtInfo) ExtInfo =
new struct ExtInfo();
279 const struct ExtInfo &getExtInfo()
const {
280 if (!ExtInfo) ExtInfo =
new struct ExtInfo();
300 EnclosingNormal(enclosingNormal), NormalBlock(nullptr),
301 ActiveFlag(
Address::invalid()), ExtInfo(nullptr),
302 FixupDepth(fixupDepth) {
311 assert(
CleanupBits.CleanupSize == cleanupSize &&
"cleanup size overflow");
357 return EnclosingNormal;
368 bool hasBranches()
const {
return ExtInfo && !ExtInfo->Branches.empty(); }
382 llvm::BasicBlock *
Block) {
383 struct ExtInfo &ExtInfo = getExtInfo();
384 if (ExtInfo.Branches.insert(
Block).second)
385 ExtInfo.BranchAfters.push_back(std::make_pair(
Block, Index));
390 return ExtInfo ? ExtInfo->BranchAfters.size() : 0;
395 return ExtInfo->BranchAfters[I].first;
400 return ExtInfo->BranchAfters[I].second;
419 return getExtInfo().Branches.insert(
Block).second;
424 if (!ExtInfo)
return false;
425 return (ExtInfo->BranchAfters.size() != ExtInfo->Branches.size());
439 "EHCleanupScope expected alignment");
450 llvm::Value **getFilters() {
451 return reinterpret_cast<llvm::Value**
>(
this+1);
454 llvm::Value *
const *getFilters()
const {
455 return reinterpret_cast<llvm::Value*
const *
>(
this+1);
462 assert(
FilterBits.NumFilters == numFilters &&
"NumFilters overflow");
466 return sizeof(
EHFilterScope) + numFilters *
sizeof(llvm::Value*);
473 getFilters()[i] = filterValue;
478 return getFilters()[i];
504 explicit iterator(
char *Ptr) : Ptr(Ptr) {}
510 return reinterpret_cast<EHScope*
>(Ptr);
569 assert(!
empty() &&
"popping exception stack when not empty");
577 assert(!
empty() &&
"popping exception stack when not empty");
585 assert(sp.
isValid() &&
"finding invalid savepoint");
586 assert(sp.Size <=
stable_begin().Size &&
"finding savepoint after pop");
587 return iterator(EndOfBuffer - sp.Size);
592 assert(StartOfData <= ir.Ptr && ir.Ptr <= EndOfBuffer);
static Decl::Kind getKind(const Decl *D)
bool isOne() const
isOne - Test whether the quantity equals one.
CharUnits getAlignment() const
Return the alignment of this pointer.
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
This class organizes the cross-function state that is used while generating LLVM code.
A scope which attempts to handle some, possibly all, types of exceptions.
EHCatchScope(unsigned numHandlers, EHScopeStack::stable_iterator enclosingEHScope)
const Handler & getHandler(unsigned I) const
void setHandler(unsigned I, llvm::Constant *Type, llvm::BasicBlock *Block)
static size_t getSizeForNumHandlers(unsigned N)
void setHandler(unsigned I, CatchTypeInfo Type, llvm::BasicBlock *Block)
void setCatchAllHandler(unsigned I, llvm::BasicBlock *Block)
void clearHandlerBlocks()
static bool classof(const EHScope *Scope)
unsigned getNumHandlers() const
A cleanup scope which generates the cleanup blocks lazily.
bool shouldTestFlagInEHCleanup() const
bool isLifetimeMarker() const
void setActiveFlag(Address Var)
Address getActiveFlag() const
EHScopeStack::stable_iterator getEnclosingNormalCleanup() const
size_t getAllocatedSize() const
bool hasActiveFlag() const
void setNormalBlock(llvm::BasicBlock *BB)
llvm::ConstantInt * getBranchAfterIndex(unsigned I) const
bool shouldTestFlagInNormalCleanup() const
bool addBranchThrough(llvm::BasicBlock *Block)
Add a branch-through to this cleanup scope.
llvm::BasicBlock * getBranchAfterBlock(unsigned I) const
void setTestFlagInNormalCleanup()
void setTestFlagInEHCleanup()
void * getCleanupBuffer()
unsigned getNumBranchAfters() const
Return the number of unique branch-afters on this scope.
bool isNormalCleanup() const
static size_t getSizeForCleanupSize(size_t Size)
Gets the size required for a lazy cleanup scope with the given cleanup-data requirements.
bool hasBranches() const
True if this cleanup scope has any branch-afters or branch-throughs.
void addBranchAfter(llvm::ConstantInt *Index, llvm::BasicBlock *Block)
Add a branch-after to this cleanup scope.
EHCleanupScope(bool isNormal, bool isEH, unsigned cleanupSize, unsigned fixupDepth, EHScopeStack::stable_iterator enclosingNormal, EHScopeStack::stable_iterator enclosingEH)
EHScopeStack::Cleanup * getCleanup()
unsigned getFixupDepth() const
size_t getCleanupSize() const
static bool classof(const EHScope *Scope)
llvm::BasicBlock * getNormalBlock() const
bool hasBranchThroughs() const
Determines if this cleanup scope has any branch throughs.
An exceptions scope which filters exceptions thrown through it.
void setFilter(unsigned i, llvm::Value *filterValue)
static size_t getSizeForNumFilters(unsigned numFilters)
EHFilterScope(unsigned numFilters)
llvm::Value * getFilter(unsigned i) const
unsigned getNumFilters() const
static bool classof(const EHScope *scope)
Information for lazily generating a cleanup.
A non-stable pointer into the scope stack.
bool operator!=(iterator other) const
EHScope & operator*() const
bool encloses(iterator other) const
bool strictlyEncloses(iterator other) const
EHScope * operator->() const
bool operator==(iterator other) const
A saved depth on the scope stack.
A stack of scopes which respond to exceptions, including cleanups and catch blocks.
stable_iterator stable_begin() const
Create a stable reference to the top of the EH stack.
bool empty() const
Determines whether the exception-scopes stack is empty.
iterator end() const
Returns an iterator pointing to the outermost EH scope.
iterator begin() const
Returns an iterator pointing to the innermost EH scope.
void popCatch()
Pops a catch scope off the stack. This is private to CGException.cpp.
iterator find(stable_iterator save) const
Turn a stable reference to a scope depth into a unstable pointer to the EH stack.
stable_iterator stabilize(iterator it) const
Translates an iterator into a stable_iterator.
void popTerminate()
Pops a terminate handler off the stack.
A protected scope for zero-cost EH handling.
llvm::BasicBlock * getCachedLandingPad() const
EHScope(Kind kind, EHScopeStack::stable_iterator enclosingEHScope)
void setCachedLandingPad(llvm::BasicBlock *block)
CleanupBitFields CleanupBits
FilterBitFields FilterBits
EHScopeStack::stable_iterator getEnclosingEHScope() const
llvm::BasicBlock * getCachedEHDispatchBlock() const
void setCachedEHDispatchBlock(llvm::BasicBlock *block)
bool hasEHBranches() const
CommonBitFields CommonBits
An exceptions scope which calls std::terminate if any exception reaches it.
EHTerminateScope(EHScopeStack::stable_iterator enclosingEHScope)
static bool classof(const EHScope *scope)
Represents a function declaration or definition.
Scope - A scope is a transient data structure that is used while parsing the program.
The base class of the type hierarchy.
@ Type
The l-value was considered opaque, so the alignment was determined from a type.
The JSON file list parser is used to communicate input to InstallAPI.
YAML serialization mapping.
The MS C++ ABI needs a pointer to RTTI data plus some flags to describe the type of a catch handler,...
CatchTypeInfo Type
A type info value, or null (C++ null, not an LLVM null pointer) for a catch-all.
llvm::BasicBlock * Block
The catch handler for this type.
The exceptions personality for a function.
bool isMSVCXXPersonality() const
static const EHPersonality & get(CodeGenModule &CGM, const FunctionDecl *FD)
static const EHPersonality XL_CPlusPlus
static const EHPersonality GNU_ObjC_SJLJ
bool isWasmPersonality() const
static const EHPersonality ZOS_CPlusPlus
static const EHPersonality GNUstep_ObjC
static const EHPersonality MSVC_CxxFrameHandler3
bool usesFuncletPads() const
Does this personality use landingpads or the family of pad instructions designed to form funclets?
static const EHPersonality MSVC_C_specific_handler
static const EHPersonality GNU_CPlusPlus_SEH
static const EHPersonality GNU_ObjC
static const EHPersonality GNU_CPlusPlus_SJLJ
static const EHPersonality GNU_C_SJLJ
static const EHPersonality GNU_C
static const EHPersonality NeXT_ObjC
const char * CatchallRethrowFn
static const EHPersonality GNU_CPlusPlus
static const EHPersonality GNU_ObjCXX
bool isMSVCPersonality() const
static const EHPersonality GNU_C_SEH
static const EHPersonality MSVC_except_handler
static const EHPersonality GNU_ObjC_SEH
const char * PersonalityFn
static const EHPersonality GNU_Wasm_CPlusPlus