LLVM 19.0.0git
Go to the documentation of this file.
1//===- EscapeEnumerator.cpp -----------------------------------------------===//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
9// Defines a helper class that enumerates all possible exits from a function,
10// including exception handling.
16#include "llvm/IR/Module.h"
20using namespace llvm;
23 LLVMContext &C = M->getContext();
24 Triple T(M->getTargetTriple());
26 return M->getOrInsertFunction(getEHPersonalityName(Pers),
27 FunctionType::get(Type::getInt32Ty(C), true));
31 if (Done)
32 return nullptr;
34 // Find all 'return', 'resume', and 'unwind' instructions.
35 while (StateBB != StateE) {
36 BasicBlock *CurBB = &*StateBB++;
38 // Branches and invokes do not escape, only unwind, resume, and return
39 // do.
40 Instruction *TI = CurBB->getTerminator();
41 if (!isa<ReturnInst>(TI) && !isa<ResumeInst>(TI))
42 continue;
44 if (CallInst *CI = CurBB->getTerminatingMustTailCall())
45 TI = CI;
46 Builder.SetInsertPoint(TI);
47 return &Builder;
48 }
50 Done = true;
52 if (!HandleExceptions)
53 return nullptr;
55 if (F.doesNotThrow())
56 return nullptr;
58 // Find all 'call' instructions that may throw.
59 // We cannot tranform calls with musttail tag.
61 for (BasicBlock &BB : F)
62 for (Instruction &II : BB)
63 if (CallInst *CI = dyn_cast<CallInst>(&II))
64 if (!CI->doesNotThrow() && !CI->isMustTailCall())
65 Calls.push_back(CI);
67 if (Calls.empty())
68 return nullptr;
70 // Create a cleanup block.
71 LLVMContext &C = F.getContext();
72 BasicBlock *CleanupBB = BasicBlock::Create(C, CleanupBBName, &F);
74 if (!F.hasPersonalityFn()) {
75 FunctionCallee PersFn = getDefaultPersonalityFn(F.getParent());
76 F.setPersonalityFn(cast<Constant>(PersFn.getCallee()));
77 }
79 if (isScopedEHPersonality(classifyEHPersonality(F.getPersonalityFn()))) {
80 report_fatal_error("Scoped EH not supported");
81 }
83 LandingPadInst *LPad =
84 LandingPadInst::Create(ExnTy, 1, "cleanup.lpad", CleanupBB);
85 LPad->setCleanup(true);
86 ResumeInst *RI = ResumeInst::Create(LPad, CleanupBB);
88 // Transform the 'call' instructions into 'invoke's branching to the
89 // cleanup block. Go in reverse order to make prettier BB names.
91 for (unsigned I = Calls.size(); I != 0;) {
92 CallInst *CI = cast<CallInst>(Calls[--I]);
93 changeToInvokeAndSplitBasicBlock(CI, CleanupBB, DTU);
94 }
96 Builder.SetInsertPoint(RI);
97 return &Builder;
static FunctionCallee getDefaultPersonalityFn(Module *M)
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
Module.h This file contains the declarations for the Module class.
uint64_t IntrinsicInst * II
LLVM Basic Block Representation.
Definition: BasicBlock.h:60
static BasicBlock * Create(LLVMContext &Context, const Twine &Name="", Function *Parent=nullptr, BasicBlock *InsertBefore=nullptr)
Creates a new BasicBlock.
Definition: BasicBlock.h:199
const Instruction * getTerminator() const LLVM_READONLY
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
Definition: BasicBlock.h:221
const CallInst * getTerminatingMustTailCall() const
Returns the call instruction marked 'musttail' prior to the terminating return instruction of this ba...
Definition: BasicBlock.cpp:293
This class represents a function call, abstracting a target machine's calling convention.
A handy container for a FunctionType+Callee-pointer pair, which can be passed around as a single enti...
Definition: DerivedTypes.h:168
bool doesNotThrow() const
Determine if the function cannot unwind.
Definition: Function.h:576
void SetInsertPoint(BasicBlock *TheBB)
This specifies that created instructions should be appended to the end of the specified block.
Definition: IRBuilder.h:180
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
Definition: IRBuilder.h:2666
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:67
The landingpad instruction holds all of the information necessary to generate correct exception handl...
void setCleanup(bool V)
Indicate that this landingpad instruction is a cleanup.
static LandingPadInst * Create(Type *RetTy, unsigned NumReservedClauses, const Twine &NameStr, BasicBlock::iterator InsertBefore)
Constructors - NumReservedClauses is a hint for the number of incoming clauses that this landingpad w...
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
static PointerType * getUnqual(Type *ElementType)
This constructs a pointer to an object of the specified type in the default address space (address sp...
Definition: DerivedTypes.h:662
Resume the propagation of an exception.
static ResumeInst * Create(Value *Exn, BasicBlock::iterator InsertBefore)
bool empty() const
Definition: SmallVector.h:94
size_t size() const
Definition: SmallVector.h:91
void push_back(const T &Elt)
Definition: SmallVector.h:426
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
static StructType * get(LLVMContext &Context, ArrayRef< Type * > Elements, bool isPacked=false)
This static method is the primary way to create a literal StructType.
Definition: Type.cpp:373
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
static IntegerType * getInt32Ty(LLVMContext &C)
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
StringRef getEHPersonalityName(EHPersonality Pers)
BasicBlock * changeToInvokeAndSplitBasicBlock(CallInst *CI, BasicBlock *UnwindEdge, DomTreeUpdater *DTU=nullptr)
Convert the CallInst to InvokeInst with the specified unwind edge basic block.
Definition: Local.cpp:2923
bool isScopedEHPersonality(EHPersonality Pers)
Returns true if this personality uses scope-style EH IR instructions: catchswitch,...
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:167
EHPersonality classifyEHPersonality(const Value *Pers)
See if the given exception handling personality function is one that we understand.
EHPersonality getDefaultEHPersonality(const Triple &T)