LLVM  12.0.0git
Go to the documentation of this file.
1 //===- EscapeEnumerator.cpp -----------------------------------------------===//
2 //
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
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // Defines a helper class that enumerates all possible exits from a function,
10 // including exception handling.
11 //
12 //===----------------------------------------------------------------------===//
15 #include "llvm/ADT/Triple.h"
17 #include "llvm/IR/Module.h"
20 using namespace llvm;
23  LLVMContext &C = M->getContext();
24  Triple T(M->getTargetTriple());
26  return M->getOrInsertFunction(getEHPersonalityName(Pers),
28 }
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);
94  }
96  Builder.SetInsertPoint(RI);
97  return &Builder;
98 }
uint64_t CallInst * C
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:140
This class represents lattice values for constants.
Definition: AllocatorList.h:23
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:67
static ResumeInst * Create(Value *Exn, Instruction *InsertBefore=nullptr)
A handy container for a FunctionType+Callee-pointer pair, which can be passed around as a single enti...
Definition: DerivedTypes.h:164
const CallInst * getTerminatingMustTailCall() const
Returns the call instruction marked 'musttail' prior to the terminating return instruction of this ba...
Definition: BasicBlock.cpp:154
This class represents a function call, abstracting a target machine's calling convention.
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.cpp:148
static LandingPadInst * Create(Type *RetTy, unsigned NumReservedClauses, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Constructors - NumReservedClauses is a hint for the number of incoming clauses that this landingpad w...
bool isScopedEHPersonality(EHPersonality Pers)
Returns true if this personality uses scope-style EH IR instructions: catchswitch,...
void setCleanup(bool V)
Indicate that this landingpad instruction is a cleanup.
#define F(x, y, z)
Definition: MD5.cpp:56
static FunctionType * get(Type *Result, ArrayRef< Type * > Params, bool isVarArg)
This static method is the primary way of constructing a FunctionType.
Definition: Type.cpp:321
void SetInsertPoint(BasicBlock *TheBB)
This specifies that created instructions should be appended to the end of the specified block.
Definition: IRBuilder.h:184
The landingpad instruction holds all of the information necessary to generate correct exception handl...
LLVM Basic Block Representation.
Definition: BasicBlock.h:58
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:46
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:68
Resume the propagation of an exception.
EHPersonality classifyEHPersonality(const Value *Pers)
See if the given exception handling personality function is one that we understand.
static BasicBlock * Create(LLVMContext &Context, const Twine &Name="", Function *Parent=nullptr, BasicBlock *InsertBefore=nullptr)
Creates a new BasicBlock.
Definition: BasicBlock.h:100
EHPersonality getDefaultEHPersonality(const Triple &T)
static PointerType * getInt8PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:249
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:45
bool doesNotThrow() const
Determine if the function cannot unwind.
Definition: Function.h:585
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:366
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1116
Module.h This file contains the declarations for the Module class.
static FunctionCallee getDefaultPersonalityFn(Module *M)
static IntegerType * getInt32Ty(LLVMContext &C)
Definition: Type.cpp:197
#define I(x, y, z)
Definition: MD5.cpp:59
StringRef getEHPersonalityName(EHPersonality Pers)
BasicBlock * changeToInvokeAndSplitBasicBlock(CallInst *CI, BasicBlock *UnwindEdge)
Convert the CallInst to InvokeInst with the specified unwind edge basic block.
Definition: Local.cpp:2116
constexpr char Args[]
Key for Kernel::Metadata::mArgs.