Chris Lattner | 3e64b2e | 2003-08-31 02:47:32 +0000 | [diff] [blame] | 1 | //===- PruneEH.cpp - Pass which deletes unused exception handlers ---------===// |
Misha Brukman | fd93908 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 2 | // |
John Criswell | b576c94 | 2003-10-20 19:43:21 +0000 | [diff] [blame] | 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
Chris Lattner | 4ee451d | 2007-12-29 20:36:04 +0000 | [diff] [blame] | 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
Misha Brukman | fd93908 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 7 | // |
John Criswell | b576c94 | 2003-10-20 19:43:21 +0000 | [diff] [blame] | 8 | //===----------------------------------------------------------------------===// |
Chris Lattner | 3e64b2e | 2003-08-31 02:47:32 +0000 | [diff] [blame] | 9 | // |
| 10 | // This file implements a simple interprocedural pass which walks the |
| 11 | // call-graph, turning invoke instructions into calls, iff the callee cannot |
Duncan Sands | cbb8bad | 2007-12-10 19:09:40 +0000 | [diff] [blame] | 12 | // throw an exception, and marking functions 'nounwind' if they cannot throw. |
| 13 | // It implements this as a bottom-up traversal of the call-graph. |
Chris Lattner | 3e64b2e | 2003-08-31 02:47:32 +0000 | [diff] [blame] | 14 | // |
| 15 | //===----------------------------------------------------------------------===// |
| 16 | |
Chris Lattner | 86453c5 | 2006-12-19 22:09:18 +0000 | [diff] [blame] | 17 | #define DEBUG_TYPE "prune-eh" |
Chris Lattner | 1e2385b | 2003-11-21 21:54:22 +0000 | [diff] [blame] | 18 | #include "llvm/Transforms/IPO.h" |
Chris Lattner | 3e64b2e | 2003-08-31 02:47:32 +0000 | [diff] [blame] | 19 | #include "llvm/CallGraphSCCPass.h" |
Chris Lattner | d651f44 | 2005-04-27 04:52:23 +0000 | [diff] [blame] | 20 | #include "llvm/Constants.h" |
Chris Lattner | 3e64b2e | 2003-08-31 02:47:32 +0000 | [diff] [blame] | 21 | #include "llvm/Function.h" |
Misha Brukman | 47b14a4 | 2004-07-29 17:30:56 +0000 | [diff] [blame] | 22 | #include "llvm/Instructions.h" |
Chris Lattner | 3e64b2e | 2003-08-31 02:47:32 +0000 | [diff] [blame] | 23 | #include "llvm/Analysis/CallGraph.h" |
Chris Lattner | 93e985f | 2007-02-13 02:10:56 +0000 | [diff] [blame] | 24 | #include "llvm/ADT/SmallVector.h" |
Reid Spencer | 551ccae | 2004-09-01 22:55:40 +0000 | [diff] [blame] | 25 | #include "llvm/ADT/Statistic.h" |
Chris Lattner | d651f44 | 2005-04-27 04:52:23 +0000 | [diff] [blame] | 26 | #include "llvm/Support/CFG.h" |
Reid Spencer | 9133fe2 | 2007-02-05 23:32:05 +0000 | [diff] [blame] | 27 | #include "llvm/Support/Compiler.h" |
Chris Lattner | 3e64b2e | 2003-08-31 02:47:32 +0000 | [diff] [blame] | 28 | #include <set> |
Chris Lattner | f26801b | 2004-10-18 15:43:46 +0000 | [diff] [blame] | 29 | #include <algorithm> |
Chris Lattner | 1e2385b | 2003-11-21 21:54:22 +0000 | [diff] [blame] | 30 | using namespace llvm; |
Brian Gaeke | d0fde30 | 2003-11-11 22:41:34 +0000 | [diff] [blame] | 31 | |
Chris Lattner | 86453c5 | 2006-12-19 22:09:18 +0000 | [diff] [blame] | 32 | STATISTIC(NumRemoved, "Number of invokes removed"); |
| 33 | STATISTIC(NumUnreach, "Number of noreturn calls optimized"); |
Nick Lewycky | 9be3c97 | 2008-03-10 02:20:00 +0000 | [diff] [blame] | 34 | STATISTIC(NumBBUnwind, "Number of unwind dest removed from blocks"); |
Chris Lattner | 3e64b2e | 2003-08-31 02:47:32 +0000 | [diff] [blame] | 35 | |
Chris Lattner | 86453c5 | 2006-12-19 22:09:18 +0000 | [diff] [blame] | 36 | namespace { |
Reid Spencer | 9133fe2 | 2007-02-05 23:32:05 +0000 | [diff] [blame] | 37 | struct VISIBILITY_HIDDEN PruneEH : public CallGraphSCCPass { |
Nick Lewycky | ecd94c8 | 2007-05-06 13:37:16 +0000 | [diff] [blame] | 38 | static char ID; // Pass identification, replacement for typeid |
Devang Patel | 794fd75 | 2007-05-01 21:15:47 +0000 | [diff] [blame] | 39 | PruneEH() : CallGraphSCCPass((intptr_t)&ID) {} |
| 40 | |
Chris Lattner | 3e64b2e | 2003-08-31 02:47:32 +0000 | [diff] [blame] | 41 | // runOnSCC - Analyze the SCC, performing the transformation if possible. |
| 42 | bool runOnSCC(const std::vector<CallGraphNode *> &SCC); |
Chris Lattner | d651f44 | 2005-04-27 04:52:23 +0000 | [diff] [blame] | 43 | |
| 44 | bool SimplifyFunction(Function *F); |
| 45 | void DeleteBasicBlock(BasicBlock *BB); |
Chris Lattner | 3e64b2e | 2003-08-31 02:47:32 +0000 | [diff] [blame] | 46 | }; |
Devang Patel | 794fd75 | 2007-05-01 21:15:47 +0000 | [diff] [blame] | 47 | |
Devang Patel | 1997473 | 2007-05-03 01:11:54 +0000 | [diff] [blame] | 48 | char PruneEH::ID = 0; |
Chris Lattner | 7f8897f | 2006-08-27 22:42:52 +0000 | [diff] [blame] | 49 | RegisterPass<PruneEH> X("prune-eh", "Remove unused exception handling info"); |
Chris Lattner | 3e64b2e | 2003-08-31 02:47:32 +0000 | [diff] [blame] | 50 | } |
| 51 | |
Devang Patel | c71ca3c | 2007-01-26 00:47:38 +0000 | [diff] [blame] | 52 | Pass *llvm::createPruneEHPass() { return new PruneEH(); } |
Chris Lattner | f6fb96f | 2003-08-31 16:30:07 +0000 | [diff] [blame] | 53 | |
Chris Lattner | 3e64b2e | 2003-08-31 02:47:32 +0000 | [diff] [blame] | 54 | |
| 55 | bool PruneEH::runOnSCC(const std::vector<CallGraphNode *> &SCC) { |
| 56 | CallGraph &CG = getAnalysis<CallGraph>(); |
Chris Lattner | d651f44 | 2005-04-27 04:52:23 +0000 | [diff] [blame] | 57 | bool MadeChange = false; |
Chris Lattner | 3e64b2e | 2003-08-31 02:47:32 +0000 | [diff] [blame] | 58 | |
Chris Lattner | d651f44 | 2005-04-27 04:52:23 +0000 | [diff] [blame] | 59 | // First pass, scan all of the functions in the SCC, simplifying them |
| 60 | // according to what we know. |
| 61 | for (unsigned i = 0, e = SCC.size(); i != e; ++i) |
| 62 | if (Function *F = SCC[i]->getFunction()) |
| 63 | MadeChange |= SimplifyFunction(F); |
| 64 | |
| 65 | // Next, check to see if any callees might throw or if there are any external |
Chris Lattner | 3e64b2e | 2003-08-31 02:47:32 +0000 | [diff] [blame] | 66 | // functions in this SCC: if so, we cannot prune any functions in this SCC. |
Chris Lattner | ee5457c | 2003-09-08 19:44:26 +0000 | [diff] [blame] | 67 | // If this SCC includes the unwind instruction, we KNOW it throws, so |
Chris Lattner | 3e64b2e | 2003-08-31 02:47:32 +0000 | [diff] [blame] | 68 | // obviously the SCC might throw. |
| 69 | // |
Chris Lattner | d651f44 | 2005-04-27 04:52:23 +0000 | [diff] [blame] | 70 | bool SCCMightUnwind = false, SCCMightReturn = false; |
| 71 | for (unsigned i = 0, e = SCC.size(); |
| 72 | (!SCCMightUnwind || !SCCMightReturn) && i != e; ++i) { |
Chris Lattner | d08ddd3 | 2004-04-12 04:06:38 +0000 | [diff] [blame] | 73 | Function *F = SCC[i]->getFunction(); |
Duncan Sands | cbb8bad | 2007-12-10 19:09:40 +0000 | [diff] [blame] | 74 | if (F == 0) { |
Chris Lattner | bc9fa58 | 2005-04-26 23:53:25 +0000 | [diff] [blame] | 75 | SCCMightUnwind = true; |
Chris Lattner | d651f44 | 2005-04-27 04:52:23 +0000 | [diff] [blame] | 76 | SCCMightReturn = true; |
Duncan Sands | cbb8bad | 2007-12-10 19:09:40 +0000 | [diff] [blame] | 77 | } else if (F->isDeclaration()) { |
Duncan Sands | 2b0e899 | 2007-12-18 09:59:50 +0000 | [diff] [blame] | 78 | SCCMightUnwind |= !F->doesNotThrow(); |
| 79 | SCCMightReturn |= !F->doesNotReturn(); |
Chris Lattner | d08ddd3 | 2004-04-12 04:06:38 +0000 | [diff] [blame] | 80 | } else { |
Duncan Sands | 2b0e899 | 2007-12-18 09:59:50 +0000 | [diff] [blame] | 81 | bool CheckUnwind = !SCCMightUnwind && !F->doesNotThrow(); |
| 82 | bool CheckReturn = !SCCMightReturn && !F->doesNotReturn(); |
Duncan Sands | cbb8bad | 2007-12-10 19:09:40 +0000 | [diff] [blame] | 83 | |
| 84 | if (!CheckUnwind && !CheckReturn) |
| 85 | continue; |
Chris Lattner | d651f44 | 2005-04-27 04:52:23 +0000 | [diff] [blame] | 86 | |
Chris Lattner | d08ddd3 | 2004-04-12 04:06:38 +0000 | [diff] [blame] | 87 | // Check to see if this function performs an unwind or calls an |
| 88 | // unwinding function. |
| 89 | for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB) { |
Duncan Sands | cbb8bad | 2007-12-10 19:09:40 +0000 | [diff] [blame] | 90 | if (CheckUnwind && isa<UnwindInst>(BB->getTerminator())) { |
| 91 | // Uses unwind! |
Chris Lattner | bc9fa58 | 2005-04-26 23:53:25 +0000 | [diff] [blame] | 92 | SCCMightUnwind = true; |
Duncan Sands | cbb8bad | 2007-12-10 19:09:40 +0000 | [diff] [blame] | 93 | } else if (CheckReturn && isa<ReturnInst>(BB->getTerminator())) { |
Chris Lattner | d651f44 | 2005-04-27 04:52:23 +0000 | [diff] [blame] | 94 | SCCMightReturn = true; |
Chris Lattner | d08ddd3 | 2004-04-12 04:06:38 +0000 | [diff] [blame] | 95 | } |
Chris Lattner | e0def04 | 2004-02-08 21:15:59 +0000 | [diff] [blame] | 96 | |
Chris Lattner | d08ddd3 | 2004-04-12 04:06:38 +0000 | [diff] [blame] | 97 | // Invoke instructions don't allow unwinding to continue, so we are |
| 98 | // only interested in call instructions. |
Duncan Sands | cbb8bad | 2007-12-10 19:09:40 +0000 | [diff] [blame] | 99 | if (CheckUnwind && !SCCMightUnwind) |
Chris Lattner | d651f44 | 2005-04-27 04:52:23 +0000 | [diff] [blame] | 100 | for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) |
| 101 | if (CallInst *CI = dyn_cast<CallInst>(I)) { |
Duncan Sands | 2b0e899 | 2007-12-18 09:59:50 +0000 | [diff] [blame] | 102 | if (CI->doesNotThrow()) { |
Duncan Sands | cbb8bad | 2007-12-10 19:09:40 +0000 | [diff] [blame] | 103 | // This call cannot throw. |
| 104 | } else if (Function *Callee = CI->getCalledFunction()) { |
Chris Lattner | d651f44 | 2005-04-27 04:52:23 +0000 | [diff] [blame] | 105 | CallGraphNode *CalleeNode = CG[Callee]; |
Duncan Sands | cbb8bad | 2007-12-10 19:09:40 +0000 | [diff] [blame] | 106 | // If the callee is outside our current SCC then we may |
| 107 | // throw because it might. |
| 108 | if (std::find(SCC.begin(), SCC.end(), CalleeNode) == SCC.end()){ |
Chris Lattner | d651f44 | 2005-04-27 04:52:23 +0000 | [diff] [blame] | 109 | SCCMightUnwind = true; |
| 110 | break; |
| 111 | } |
| 112 | } else { |
| 113 | // Indirect call, it might throw. |
Chris Lattner | bc9fa58 | 2005-04-26 23:53:25 +0000 | [diff] [blame] | 114 | SCCMightUnwind = true; |
Chris Lattner | e0def04 | 2004-02-08 21:15:59 +0000 | [diff] [blame] | 115 | break; |
| 116 | } |
| 117 | } |
Chris Lattner | d651f44 | 2005-04-27 04:52:23 +0000 | [diff] [blame] | 118 | if (SCCMightUnwind && SCCMightReturn) break; |
Chris Lattner | ad9b5f3 | 2003-09-15 02:22:50 +0000 | [diff] [blame] | 119 | } |
Chris Lattner | d08ddd3 | 2004-04-12 04:06:38 +0000 | [diff] [blame] | 120 | } |
| 121 | } |
Chris Lattner | d651f44 | 2005-04-27 04:52:23 +0000 | [diff] [blame] | 122 | |
| 123 | // If the SCC doesn't unwind or doesn't throw, note this fact. |
Duncan Sands | cbb8bad | 2007-12-10 19:09:40 +0000 | [diff] [blame] | 124 | if (!SCCMightUnwind || !SCCMightReturn) |
| 125 | for (unsigned i = 0, e = SCC.size(); i != e; ++i) { |
Dale Johannesen | 0d51e7e | 2008-02-19 21:38:47 +0000 | [diff] [blame] | 126 | ParameterAttributes NewAttributes = ParamAttr::None; |
Duncan Sands | cbb8bad | 2007-12-10 19:09:40 +0000 | [diff] [blame] | 127 | |
| 128 | if (!SCCMightUnwind) |
Duncan Sands | f0c3354 | 2007-12-19 21:13:37 +0000 | [diff] [blame] | 129 | NewAttributes |= ParamAttr::NoUnwind; |
Duncan Sands | cbb8bad | 2007-12-10 19:09:40 +0000 | [diff] [blame] | 130 | if (!SCCMightReturn) |
Duncan Sands | f0c3354 | 2007-12-19 21:13:37 +0000 | [diff] [blame] | 131 | NewAttributes |= ParamAttr::NoReturn; |
Duncan Sands | cbb8bad | 2007-12-10 19:09:40 +0000 | [diff] [blame] | 132 | |
Chris Lattner | 58d7491 | 2008-03-12 17:45:29 +0000 | [diff] [blame] | 133 | const PAListPtr &PAL = SCC[i]->getFunction()->getParamAttrs(); |
| 134 | SCC[i]->getFunction()->setParamAttrs(PAL.addAttr(0, NewAttributes)); |
Duncan Sands | cbb8bad | 2007-12-10 19:09:40 +0000 | [diff] [blame] | 135 | } |
Chris Lattner | 3e64b2e | 2003-08-31 02:47:32 +0000 | [diff] [blame] | 136 | |
| 137 | for (unsigned i = 0, e = SCC.size(); i != e; ++i) { |
Chris Lattner | 3e64b2e | 2003-08-31 02:47:32 +0000 | [diff] [blame] | 138 | // Convert any invoke instructions to non-throwing functions in this node |
| 139 | // into call instructions with a branch. This makes the exception blocks |
| 140 | // dead. |
| 141 | if (Function *F = SCC[i]->getFunction()) |
Chris Lattner | d651f44 | 2005-04-27 04:52:23 +0000 | [diff] [blame] | 142 | MadeChange |= SimplifyFunction(F); |
Chris Lattner | 3e64b2e | 2003-08-31 02:47:32 +0000 | [diff] [blame] | 143 | } |
| 144 | |
Misha Brukman | fd93908 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 145 | return MadeChange; |
Chris Lattner | 3e64b2e | 2003-08-31 02:47:32 +0000 | [diff] [blame] | 146 | } |
Brian Gaeke | d0fde30 | 2003-11-11 22:41:34 +0000 | [diff] [blame] | 147 | |
Chris Lattner | d651f44 | 2005-04-27 04:52:23 +0000 | [diff] [blame] | 148 | |
| 149 | // SimplifyFunction - Given information about callees, simplify the specified |
| 150 | // function if we have invokes to non-unwinding functions or code after calls to |
| 151 | // no-return functions. |
| 152 | bool PruneEH::SimplifyFunction(Function *F) { |
Chris Lattner | d651f44 | 2005-04-27 04:52:23 +0000 | [diff] [blame] | 153 | bool MadeChange = false; |
| 154 | for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB) { |
Nick Lewycky | c0d025f | 2008-03-09 04:55:16 +0000 | [diff] [blame] | 155 | bool couldUnwind = false; |
| 156 | |
Chris Lattner | d651f44 | 2005-04-27 04:52:23 +0000 | [diff] [blame] | 157 | if (InvokeInst *II = dyn_cast<InvokeInst>(BB->getTerminator())) |
Duncan Sands | 2b0e899 | 2007-12-18 09:59:50 +0000 | [diff] [blame] | 158 | if (II->doesNotThrow()) { |
Duncan Sands | cbb8bad | 2007-12-10 19:09:40 +0000 | [diff] [blame] | 159 | SmallVector<Value*, 8> Args(II->op_begin()+3, II->op_end()); |
| 160 | // Insert a call instruction before the invoke. |
Gabor Greif | 051a950 | 2008-04-06 20:25:17 +0000 | [diff] [blame^] | 161 | CallInst *Call = CallInst::Create(II->getCalledValue(), |
| 162 | Args.begin(), Args.end(), "", II); |
Duncan Sands | cbb8bad | 2007-12-10 19:09:40 +0000 | [diff] [blame] | 163 | Call->takeName(II); |
| 164 | Call->setCallingConv(II->getCallingConv()); |
| 165 | Call->setParamAttrs(II->getParamAttrs()); |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 166 | |
Duncan Sands | cbb8bad | 2007-12-10 19:09:40 +0000 | [diff] [blame] | 167 | // Anything that used the value produced by the invoke instruction |
| 168 | // now uses the value produced by the call instruction. |
| 169 | II->replaceAllUsesWith(Call); |
| 170 | BasicBlock *UnwindBlock = II->getUnwindDest(); |
| 171 | UnwindBlock->removePredecessor(II->getParent()); |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 172 | |
Duncan Sands | cbb8bad | 2007-12-10 19:09:40 +0000 | [diff] [blame] | 173 | // Insert a branch to the normal destination right before the |
| 174 | // invoke. |
Gabor Greif | 051a950 | 2008-04-06 20:25:17 +0000 | [diff] [blame^] | 175 | BranchInst::Create(II->getNormalDest(), II); |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 176 | |
Duncan Sands | cbb8bad | 2007-12-10 19:09:40 +0000 | [diff] [blame] | 177 | // Finally, delete the invoke instruction! |
| 178 | BB->getInstList().pop_back(); |
Chris Lattner | d651f44 | 2005-04-27 04:52:23 +0000 | [diff] [blame] | 179 | |
Duncan Sands | cbb8bad | 2007-12-10 19:09:40 +0000 | [diff] [blame] | 180 | // If the unwind block is now dead, nuke it. |
| 181 | if (pred_begin(UnwindBlock) == pred_end(UnwindBlock)) |
| 182 | DeleteBasicBlock(UnwindBlock); // Delete the new BB. |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 183 | |
Duncan Sands | cbb8bad | 2007-12-10 19:09:40 +0000 | [diff] [blame] | 184 | ++NumRemoved; |
| 185 | MadeChange = true; |
Nick Lewycky | f336983 | 2008-03-09 17:11:18 +0000 | [diff] [blame] | 186 | } else { |
Nick Lewycky | c0d025f | 2008-03-09 04:55:16 +0000 | [diff] [blame] | 187 | couldUnwind = true; |
Nick Lewycky | f336983 | 2008-03-09 17:11:18 +0000 | [diff] [blame] | 188 | } |
Chris Lattner | d651f44 | 2005-04-27 04:52:23 +0000 | [diff] [blame] | 189 | |
Chris Lattner | 209a0ae | 2005-04-27 20:12:17 +0000 | [diff] [blame] | 190 | for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ) |
Nick Lewycky | c0d025f | 2008-03-09 04:55:16 +0000 | [diff] [blame] | 191 | if (CallInst *CI = dyn_cast<CallInst>(I++)) { |
Duncan Sands | 2b0e899 | 2007-12-18 09:59:50 +0000 | [diff] [blame] | 192 | if (CI->doesNotReturn() && !isa<UnreachableInst>(I)) { |
Duncan Sands | cbb8bad | 2007-12-10 19:09:40 +0000 | [diff] [blame] | 193 | // This call calls a function that cannot return. Insert an |
| 194 | // unreachable instruction after it and simplify the code. Do this |
| 195 | // by splitting the BB, adding the unreachable, then deleting the |
| 196 | // new BB. |
| 197 | BasicBlock *New = BB->splitBasicBlock(I); |
Chris Lattner | d651f44 | 2005-04-27 04:52:23 +0000 | [diff] [blame] | 198 | |
Duncan Sands | cbb8bad | 2007-12-10 19:09:40 +0000 | [diff] [blame] | 199 | // Remove the uncond branch and add an unreachable. |
| 200 | BB->getInstList().pop_back(); |
| 201 | new UnreachableInst(BB); |
Chris Lattner | d651f44 | 2005-04-27 04:52:23 +0000 | [diff] [blame] | 202 | |
Duncan Sands | cbb8bad | 2007-12-10 19:09:40 +0000 | [diff] [blame] | 203 | DeleteBasicBlock(New); // Delete the new BB. |
| 204 | MadeChange = true; |
| 205 | ++NumUnreach; |
| 206 | break; |
Nick Lewycky | 3c4a262 | 2008-03-09 17:13:05 +0000 | [diff] [blame] | 207 | } else if (!CI->doesNotThrow()) { |
Nick Lewycky | c0d025f | 2008-03-09 04:55:16 +0000 | [diff] [blame] | 208 | couldUnwind = true; |
Nick Lewycky | 3c4a262 | 2008-03-09 17:13:05 +0000 | [diff] [blame] | 209 | } |
Nick Lewycky | c0d025f | 2008-03-09 04:55:16 +0000 | [diff] [blame] | 210 | } |
Chris Lattner | d651f44 | 2005-04-27 04:52:23 +0000 | [diff] [blame] | 211 | |
Nick Lewycky | c0d025f | 2008-03-09 04:55:16 +0000 | [diff] [blame] | 212 | // Strip 'unwindTo' off of BBs that have no calls/invokes without nounwind. |
| 213 | if (!couldUnwind && BB->getUnwindDest()) { |
| 214 | MadeChange = true; |
| 215 | ++NumBBUnwind; |
| 216 | BB->getUnwindDest()->removePredecessor(BB, false, true); |
| 217 | BB->setUnwindDest(NULL); |
| 218 | } |
Chris Lattner | d651f44 | 2005-04-27 04:52:23 +0000 | [diff] [blame] | 219 | } |
| 220 | return MadeChange; |
| 221 | } |
| 222 | |
| 223 | /// DeleteBasicBlock - remove the specified basic block from the program, |
| 224 | /// updating the callgraph to reflect any now-obsolete edges due to calls that |
| 225 | /// exist in the BB. |
| 226 | void PruneEH::DeleteBasicBlock(BasicBlock *BB) { |
| 227 | assert(pred_begin(BB) == pred_end(BB) && "BB is not dead!"); |
| 228 | CallGraph &CG = getAnalysis<CallGraph>(); |
| 229 | |
| 230 | CallGraphNode *CGN = CG[BB->getParent()]; |
| 231 | for (BasicBlock::iterator I = BB->end(), E = BB->begin(); I != E; ) { |
| 232 | --I; |
| 233 | if (CallInst *CI = dyn_cast<CallInst>(I)) { |
| 234 | if (Function *Callee = CI->getCalledFunction()) |
| 235 | CGN->removeCallEdgeTo(CG[Callee]); |
| 236 | } else if (InvokeInst *II = dyn_cast<InvokeInst>(I)) { |
| 237 | if (Function *Callee = II->getCalledFunction()) |
| 238 | CGN->removeCallEdgeTo(CG[Callee]); |
| 239 | } |
| 240 | if (!I->use_empty()) |
| 241 | I->replaceAllUsesWith(UndefValue::get(I->getType())); |
| 242 | } |
| 243 | |
| 244 | // Get the list of successors of this block. |
| 245 | std::vector<BasicBlock*> Succs(succ_begin(BB), succ_end(BB)); |
| 246 | |
| 247 | for (unsigned i = 0, e = Succs.size(); i != e; ++i) |
| 248 | Succs[i]->removePredecessor(BB); |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 249 | |
Chris Lattner | d651f44 | 2005-04-27 04:52:23 +0000 | [diff] [blame] | 250 | BB->eraseFromParent(); |
| 251 | } |