1 //===- LowerInvoke.cpp - Eliminate Invoke instructions --------------------===// 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 // This transformation is designed for use by code generators which do not yet 10 // support stack unwinding. This pass converts 'invoke' instructions to 'call' 11 // instructions, so that any exception-handling 'landingpad' blocks become dead 12 // code (which can be removed by running the '-simplifycfg' pass afterwards). 13 // 14 //===----------------------------------------------------------------------===// 15 16 #include "llvm/Transforms/Utils/LowerInvoke.h" 17 #include "llvm/ADT/SmallVector.h" 18 #include "llvm/ADT/Statistic.h" 19 #include "llvm/IR/Instructions.h" 20 #include "llvm/IR/LLVMContext.h" 21 #include "llvm/IR/Module.h" 22 #include "llvm/Pass.h" 23 #include "llvm/Transforms/Utils.h" 24 using namespace llvm; 25 26 #define DEBUG_TYPE "lowerinvoke" 27 28 STATISTIC(NumInvokes, "Number of invokes replaced"); 29 30 namespace { 31 class LowerInvokeLegacyPass : public FunctionPass { 32 public: 33 static char ID; // Pass identification, replacement for typeid 34 explicit LowerInvokeLegacyPass() : FunctionPass(ID) { 35 initializeLowerInvokeLegacyPassPass(*PassRegistry::getPassRegistry()); 36 } 37 bool runOnFunction(Function &F) override; 38 }; 39 } 40 41 char LowerInvokeLegacyPass::ID = 0; 42 INITIALIZE_PASS(LowerInvokeLegacyPass, "lowerinvoke", 43 "Lower invoke and unwind, for unwindless code generators", 44 false, false) 45 46 static bool runImpl(Function &F) { 47 bool Changed = false; 48 for (BasicBlock &BB : F) 49 if (InvokeInst *II = dyn_cast<InvokeInst>(BB.getTerminator())) { 50 SmallVector<Value *, 16> CallArgs(II->arg_begin(), II->arg_end()); 51 SmallVector<OperandBundleDef, 1> OpBundles; 52 II->getOperandBundlesAsDefs(OpBundles); 53 // Insert a normal call instruction... 54 CallInst *NewCall = 55 CallInst::Create(II->getFunctionType(), II->getCalledValue(), 56 CallArgs, OpBundles, "", II); 57 NewCall->takeName(II); 58 NewCall->setCallingConv(II->getCallingConv()); 59 NewCall->setAttributes(II->getAttributes()); 60 NewCall->setDebugLoc(II->getDebugLoc()); 61 II->replaceAllUsesWith(NewCall); 62 63 // Insert an unconditional branch to the normal destination. 64 BranchInst::Create(II->getNormalDest(), II); 65 66 // Remove any PHI node entries from the exception destination. 67 II->getUnwindDest()->removePredecessor(&BB); 68 69 // Remove the invoke instruction now. 70 BB.getInstList().erase(II); 71 72 ++NumInvokes; 73 Changed = true; 74 } 75 return Changed; 76 } 77 78 bool LowerInvokeLegacyPass::runOnFunction(Function &F) { 79 return runImpl(F); 80 } 81 82 namespace llvm { 83 char &LowerInvokePassID = LowerInvokeLegacyPass::ID; 84 85 // Public Interface To the LowerInvoke pass. 86 FunctionPass *createLowerInvokePass() { return new LowerInvokeLegacyPass(); } 87 88 PreservedAnalyses LowerInvokePass::run(Function &F, 89 FunctionAnalysisManager &AM) { 90 bool Changed = runImpl(F); 91 if (!Changed) 92 return PreservedAnalyses::all(); 93 94 return PreservedAnalyses::none(); 95 } 96 } 97