lib/Transforms/Utils/LowerInvoke.cpp

   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 }