Chris Lattner | 86e4445 | 2003-10-05 19:14:42 +0000 | [diff] [blame] | 1 | //===- LowerInvoke.cpp - Eliminate Invoke & Unwind instructions -----------===// |
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 | 86e4445 | 2003-10-05 19:14:42 +0000 | [diff] [blame] | 9 | // |
| 10 | // This transformation is designed for use by code generators which do not yet |
Chris Lattner | 6d78457 | 2004-02-08 19:53:56 +0000 | [diff] [blame] | 11 | // support stack unwinding. This pass supports two models of exception handling |
| 12 | // lowering, the 'cheap' support and the 'expensive' support. |
| 13 | // |
| 14 | // 'Cheap' exception handling support gives the program the ability to execute |
| 15 | // any program which does not "throw an exception", by turning 'invoke' |
| 16 | // instructions into calls and by turning 'unwind' instructions into calls to |
| 17 | // abort(). If the program does dynamically use the unwind instruction, the |
| 18 | // program will print a message then abort. |
| 19 | // |
| 20 | // 'Expensive' exception handling support gives the full exception handling |
John Criswell | fe3706a | 2005-05-02 14:47:42 +0000 | [diff] [blame] | 21 | // support to the program at the cost of making the 'invoke' instruction |
| 22 | // really expensive. It basically inserts setjmp/longjmp calls to emulate the |
| 23 | // exception handling as necessary. |
Chris Lattner | 6d78457 | 2004-02-08 19:53:56 +0000 | [diff] [blame] | 24 | // |
| 25 | // Because the 'expensive' support slows down programs a lot, and EH is only |
| 26 | // used for a subset of the programs, it must be specifically enabled by an |
| 27 | // option. |
Chris Lattner | 86e4445 | 2003-10-05 19:14:42 +0000 | [diff] [blame] | 28 | // |
Chris Lattner | 0e28eca | 2004-03-31 22:00:30 +0000 | [diff] [blame] | 29 | // Note that after this pass runs the CFG is not entirely accurate (exceptional |
| 30 | // control flow edges are not correct anymore) so only very simple things should |
| 31 | // be done after the lowerinvoke pass has run (like generation of native code). |
| 32 | // This should not be used as a general purpose "my LLVM-to-LLVM pass doesn't |
| 33 | // support the invoke instruction yet" lowering pass. |
| 34 | // |
Chris Lattner | 86e4445 | 2003-10-05 19:14:42 +0000 | [diff] [blame] | 35 | //===----------------------------------------------------------------------===// |
| 36 | |
Chris Lattner | d216e8b | 2006-12-19 22:17:40 +0000 | [diff] [blame] | 37 | #define DEBUG_TYPE "lowerinvoke" |
Chris Lattner | 86e4445 | 2003-10-05 19:14:42 +0000 | [diff] [blame] | 38 | #include "llvm/Transforms/Scalar.h" |
Chris Lattner | e1c0930 | 2004-02-08 07:30:29 +0000 | [diff] [blame] | 39 | #include "llvm/Constants.h" |
| 40 | #include "llvm/DerivedTypes.h" |
Chris Lattner | 6d78457 | 2004-02-08 19:53:56 +0000 | [diff] [blame] | 41 | #include "llvm/Instructions.h" |
Chris Lattner | e1c0930 | 2004-02-08 07:30:29 +0000 | [diff] [blame] | 42 | #include "llvm/Module.h" |
Chris Lattner | 86e4445 | 2003-10-05 19:14:42 +0000 | [diff] [blame] | 43 | #include "llvm/Pass.h" |
Chris Lattner | 6d78457 | 2004-02-08 19:53:56 +0000 | [diff] [blame] | 44 | #include "llvm/Transforms/Utils/BasicBlockUtils.h" |
Chris Lattner | f4e6c3a | 2005-09-27 21:18:17 +0000 | [diff] [blame] | 45 | #include "llvm/Transforms/Utils/Local.h" |
Reid Spencer | 551ccae | 2004-09-01 22:55:40 +0000 | [diff] [blame] | 46 | #include "llvm/ADT/Statistic.h" |
| 47 | #include "llvm/Support/CommandLine.h" |
Chris Lattner | a4f0b3a | 2006-08-27 12:54:02 +0000 | [diff] [blame] | 48 | #include "llvm/Support/Compiler.h" |
Duraid Madina | 2a0013f | 2006-09-04 06:21:35 +0000 | [diff] [blame] | 49 | #include "llvm/Target/TargetLowering.h" |
Chris Lattner | 6d78457 | 2004-02-08 19:53:56 +0000 | [diff] [blame] | 50 | #include <csetjmp> |
Reid Spencer | 6734b57 | 2007-02-04 00:40:42 +0000 | [diff] [blame] | 51 | #include <set> |
Chris Lattner | dead993 | 2003-12-10 20:22:42 +0000 | [diff] [blame] | 52 | using namespace llvm; |
Brian Gaeke | d0fde30 | 2003-11-11 22:41:34 +0000 | [diff] [blame] | 53 | |
Chris Lattner | d216e8b | 2006-12-19 22:17:40 +0000 | [diff] [blame] | 54 | STATISTIC(NumInvokes, "Number of invokes replaced"); |
| 55 | STATISTIC(NumUnwinds, "Number of unwinds replaced"); |
| 56 | STATISTIC(NumSpilled, "Number of registers live across unwind edges"); |
| 57 | |
| 58 | static cl::opt<bool> ExpensiveEHSupport("enable-correct-eh-support", |
Chris Lattner | 6d78457 | 2004-02-08 19:53:56 +0000 | [diff] [blame] | 59 | cl::desc("Make the -lowerinvoke pass insert expensive, but correct, EH code")); |
Chris Lattner | 86e4445 | 2003-10-05 19:14:42 +0000 | [diff] [blame] | 60 | |
Chris Lattner | d216e8b | 2006-12-19 22:17:40 +0000 | [diff] [blame] | 61 | namespace { |
Chris Lattner | f4b5461 | 2006-06-28 22:08:15 +0000 | [diff] [blame] | 62 | class VISIBILITY_HIDDEN LowerInvoke : public FunctionPass { |
Chris Lattner | 6d78457 | 2004-02-08 19:53:56 +0000 | [diff] [blame] | 63 | // Used for both models. |
Chris Lattner | b76efb7 | 2007-01-07 08:12:01 +0000 | [diff] [blame] | 64 | Constant *WriteFn; |
| 65 | Constant *AbortFn; |
Chris Lattner | 6d78457 | 2004-02-08 19:53:56 +0000 | [diff] [blame] | 66 | Value *AbortMessage; |
| 67 | unsigned AbortMessageLength; |
| 68 | |
| 69 | // Used for expensive EH support. |
| 70 | const Type *JBLinkTy; |
| 71 | GlobalVariable *JBListHead; |
Chris Lattner | b76efb7 | 2007-01-07 08:12:01 +0000 | [diff] [blame] | 72 | Constant *SetJmpFn, *LongJmpFn; |
Duraid Madina | 2a0013f | 2006-09-04 06:21:35 +0000 | [diff] [blame] | 73 | |
| 74 | // We peek in TLI to grab the target's jmp_buf size and alignment |
| 75 | const TargetLowering *TLI; |
| 76 | |
Chris Lattner | 86e4445 | 2003-10-05 19:14:42 +0000 | [diff] [blame] | 77 | public: |
Nick Lewycky | ecd94c8 | 2007-05-06 13:37:16 +0000 | [diff] [blame] | 78 | static char ID; // Pass identification, replacement for typeid |
Dan Gohman | c2bbfc1 | 2007-08-01 15:32:29 +0000 | [diff] [blame] | 79 | explicit LowerInvoke(const TargetLowering *tli = NULL) |
| 80 | : FunctionPass((intptr_t)&ID), TLI(tli) { } |
Chris Lattner | 86e4445 | 2003-10-05 19:14:42 +0000 | [diff] [blame] | 81 | bool doInitialization(Module &M); |
| 82 | bool runOnFunction(Function &F); |
Chris Lattner | ed96fe8 | 2006-05-17 21:05:27 +0000 | [diff] [blame] | 83 | |
| 84 | virtual void getAnalysisUsage(AnalysisUsage &AU) const { |
Anton Korobeynikov | bed2946 | 2007-04-16 18:10:23 +0000 | [diff] [blame] | 85 | // This is a cluster of orthogonal Transforms |
Chris Lattner | ed96fe8 | 2006-05-17 21:05:27 +0000 | [diff] [blame] | 86 | AU.addPreservedID(PromoteMemoryToRegisterID); |
Chris Lattner | ed96fe8 | 2006-05-17 21:05:27 +0000 | [diff] [blame] | 87 | AU.addPreservedID(LowerSwitchID); |
| 88 | AU.addPreservedID(LowerAllocationsID); |
| 89 | } |
| 90 | |
Chris Lattner | 6d78457 | 2004-02-08 19:53:56 +0000 | [diff] [blame] | 91 | private: |
Chris Lattner | b76efb7 | 2007-01-07 08:12:01 +0000 | [diff] [blame] | 92 | void createAbortMessage(Module *M); |
Chris Lattner | 501825e | 2004-02-08 22:14:44 +0000 | [diff] [blame] | 93 | void writeAbortMessage(Instruction *IB); |
Chris Lattner | 6d78457 | 2004-02-08 19:53:56 +0000 | [diff] [blame] | 94 | bool insertCheapEHSupport(Function &F); |
Chris Lattner | f4e6c3a | 2005-09-27 21:18:17 +0000 | [diff] [blame] | 95 | void splitLiveRangesLiveAcrossInvokes(std::vector<InvokeInst*> &Invokes); |
| 96 | void rewriteExpensiveInvoke(InvokeInst *II, unsigned InvokeNo, |
| 97 | AllocaInst *InvokeNum, SwitchInst *CatchSwitch); |
Chris Lattner | 6d78457 | 2004-02-08 19:53:56 +0000 | [diff] [blame] | 98 | bool insertExpensiveEHSupport(Function &F); |
Chris Lattner | 86e4445 | 2003-10-05 19:14:42 +0000 | [diff] [blame] | 99 | }; |
| 100 | |
Devang Patel | 1997473 | 2007-05-03 01:11:54 +0000 | [diff] [blame] | 101 | char LowerInvoke::ID = 0; |
Chris Lattner | 7f8897f | 2006-08-27 22:42:52 +0000 | [diff] [blame] | 102 | RegisterPass<LowerInvoke> |
Chris Lattner | 86e4445 | 2003-10-05 19:14:42 +0000 | [diff] [blame] | 103 | X("lowerinvoke", "Lower invoke and unwind, for unwindless code generators"); |
| 104 | } |
| 105 | |
Chris Lattner | cefc18e | 2004-02-13 16:16:16 +0000 | [diff] [blame] | 106 | const PassInfo *llvm::LowerInvokePassID = X.getPassInfo(); |
| 107 | |
Brian Gaeke | d0fde30 | 2003-11-11 22:41:34 +0000 | [diff] [blame] | 108 | // Public Interface To the LowerInvoke pass. |
Duraid Madina | 2a0013f | 2006-09-04 06:21:35 +0000 | [diff] [blame] | 109 | FunctionPass *llvm::createLowerInvokePass(const TargetLowering *TLI) { |
| 110 | return new LowerInvoke(TLI); |
Nate Begeman | 14b0529 | 2005-11-05 09:21:28 +0000 | [diff] [blame] | 111 | } |
Chris Lattner | 86e4445 | 2003-10-05 19:14:42 +0000 | [diff] [blame] | 112 | |
| 113 | // doInitialization - Make sure that there is a prototype for abort in the |
| 114 | // current module. |
| 115 | bool LowerInvoke::doInitialization(Module &M) { |
Christopher Lamb | 43ad6b3 | 2007-12-17 01:12:55 +0000 | [diff] [blame] | 116 | const Type *VoidPtrTy = PointerType::getUnqual(Type::Int8Ty); |
Jim Laskey | 7d48538 | 2007-02-22 16:21:18 +0000 | [diff] [blame] | 117 | AbortMessage = 0; |
| 118 | if (ExpensiveEHSupport) { |
| 119 | // Insert a type for the linked list of jump buffers. |
| 120 | unsigned JBSize = TLI ? TLI->getJumpBufSize() : 0; |
| 121 | JBSize = JBSize ? JBSize : 200; |
| 122 | const Type *JmpBufTy = ArrayType::get(VoidPtrTy, JBSize); |
Chris Lattner | e1c0930 | 2004-02-08 07:30:29 +0000 | [diff] [blame] | 123 | |
Jim Laskey | 7d48538 | 2007-02-22 16:21:18 +0000 | [diff] [blame] | 124 | { // The type is recursive, so use a type holder. |
| 125 | std::vector<const Type*> Elements; |
| 126 | Elements.push_back(JmpBufTy); |
| 127 | OpaqueType *OT = OpaqueType::get(); |
Christopher Lamb | 43ad6b3 | 2007-12-17 01:12:55 +0000 | [diff] [blame] | 128 | Elements.push_back(PointerType::getUnqual(OT)); |
Jim Laskey | 7d48538 | 2007-02-22 16:21:18 +0000 | [diff] [blame] | 129 | PATypeHolder JBLType(StructType::get(Elements)); |
| 130 | OT->refineAbstractTypeTo(JBLType.get()); // Complete the cycle. |
| 131 | JBLinkTy = JBLType.get(); |
| 132 | M.addTypeName("llvm.sjljeh.jmpbufty", JBLinkTy); |
Chris Lattner | 6d78457 | 2004-02-08 19:53:56 +0000 | [diff] [blame] | 133 | } |
| 134 | |
Christopher Lamb | 43ad6b3 | 2007-12-17 01:12:55 +0000 | [diff] [blame] | 135 | const Type *PtrJBList = PointerType::getUnqual(JBLinkTy); |
Jim Laskey | 7d48538 | 2007-02-22 16:21:18 +0000 | [diff] [blame] | 136 | |
| 137 | // Now that we've done that, insert the jmpbuf list head global, unless it |
| 138 | // already exists. |
| 139 | if (!(JBListHead = M.getGlobalVariable("llvm.sjljeh.jblist", PtrJBList))) { |
| 140 | JBListHead = new GlobalVariable(PtrJBList, false, |
| 141 | GlobalValue::LinkOnceLinkage, |
| 142 | Constant::getNullValue(PtrJBList), |
| 143 | "llvm.sjljeh.jblist", &M); |
| 144 | } |
| 145 | SetJmpFn = M.getOrInsertFunction("llvm.setjmp", Type::Int32Ty, |
Christopher Lamb | 43ad6b3 | 2007-12-17 01:12:55 +0000 | [diff] [blame] | 146 | PointerType::getUnqual(JmpBufTy), |
| 147 | (Type *)0); |
Jim Laskey | 7d48538 | 2007-02-22 16:21:18 +0000 | [diff] [blame] | 148 | LongJmpFn = M.getOrInsertFunction("llvm.longjmp", Type::VoidTy, |
Christopher Lamb | 43ad6b3 | 2007-12-17 01:12:55 +0000 | [diff] [blame] | 149 | PointerType::getUnqual(JmpBufTy), |
Jim Laskey | 7d48538 | 2007-02-22 16:21:18 +0000 | [diff] [blame] | 150 | Type::Int32Ty, (Type *)0); |
Chris Lattner | 6d78457 | 2004-02-08 19:53:56 +0000 | [diff] [blame] | 151 | } |
Jim Laskey | 7d48538 | 2007-02-22 16:21:18 +0000 | [diff] [blame] | 152 | |
| 153 | // We need the 'write' and 'abort' functions for both models. |
| 154 | AbortFn = M.getOrInsertFunction("abort", Type::VoidTy, (Type *)0); |
Jeff Cohen | 09b362c | 2007-04-20 22:40:10 +0000 | [diff] [blame] | 155 | #if 0 // "write" is Unix-specific.. code is going away soon anyway. |
Jim Laskey | 7d48538 | 2007-02-22 16:21:18 +0000 | [diff] [blame] | 156 | WriteFn = M.getOrInsertFunction("write", Type::VoidTy, Type::Int32Ty, |
| 157 | VoidPtrTy, Type::Int32Ty, (Type *)0); |
Jeff Cohen | 09b362c | 2007-04-20 22:40:10 +0000 | [diff] [blame] | 158 | #else |
| 159 | WriteFn = 0; |
| 160 | #endif |
Chris Lattner | 86e4445 | 2003-10-05 19:14:42 +0000 | [diff] [blame] | 161 | return true; |
| 162 | } |
| 163 | |
Chris Lattner | b76efb7 | 2007-01-07 08:12:01 +0000 | [diff] [blame] | 164 | void LowerInvoke::createAbortMessage(Module *M) { |
Chris Lattner | 0c3b390 | 2004-11-13 19:07:32 +0000 | [diff] [blame] | 165 | if (ExpensiveEHSupport) { |
| 166 | // The abort message for expensive EH support tells the user that the |
| 167 | // program 'unwound' without an 'invoke' instruction. |
| 168 | Constant *Msg = |
| 169 | ConstantArray::get("ERROR: Exception thrown, but not caught!\n"); |
| 170 | AbortMessageLength = Msg->getNumOperands()-1; // don't include \0 |
Misha Brukman | fd93908 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 171 | |
Chris Lattner | 0c3b390 | 2004-11-13 19:07:32 +0000 | [diff] [blame] | 172 | GlobalVariable *MsgGV = new GlobalVariable(Msg->getType(), true, |
| 173 | GlobalValue::InternalLinkage, |
Chris Lattner | b76efb7 | 2007-01-07 08:12:01 +0000 | [diff] [blame] | 174 | Msg, "abortmsg", M); |
Reid Spencer | c5b206b | 2006-12-31 05:48:39 +0000 | [diff] [blame] | 175 | std::vector<Constant*> GEPIdx(2, Constant::getNullValue(Type::Int32Ty)); |
Chris Lattner | ec1f752 | 2007-02-19 07:34:47 +0000 | [diff] [blame] | 176 | AbortMessage = ConstantExpr::getGetElementPtr(MsgGV, &GEPIdx[0], 2); |
Chris Lattner | 0c3b390 | 2004-11-13 19:07:32 +0000 | [diff] [blame] | 177 | } else { |
| 178 | // The abort message for cheap EH support tells the user that EH is not |
| 179 | // enabled. |
| 180 | Constant *Msg = |
| 181 | ConstantArray::get("Exception handler needed, but not enabled. Recompile" |
| 182 | " program with -enable-correct-eh-support.\n"); |
| 183 | AbortMessageLength = Msg->getNumOperands()-1; // don't include \0 |
| 184 | |
| 185 | GlobalVariable *MsgGV = new GlobalVariable(Msg->getType(), true, |
| 186 | GlobalValue::InternalLinkage, |
Chris Lattner | b76efb7 | 2007-01-07 08:12:01 +0000 | [diff] [blame] | 187 | Msg, "abortmsg", M); |
Reid Spencer | c5b206b | 2006-12-31 05:48:39 +0000 | [diff] [blame] | 188 | std::vector<Constant*> GEPIdx(2, Constant::getNullValue(Type::Int32Ty)); |
Chris Lattner | ec1f752 | 2007-02-19 07:34:47 +0000 | [diff] [blame] | 189 | AbortMessage = ConstantExpr::getGetElementPtr(MsgGV, &GEPIdx[0], 2); |
Chris Lattner | 0c3b390 | 2004-11-13 19:07:32 +0000 | [diff] [blame] | 190 | } |
| 191 | } |
| 192 | |
| 193 | |
Chris Lattner | 501825e | 2004-02-08 22:14:44 +0000 | [diff] [blame] | 194 | void LowerInvoke::writeAbortMessage(Instruction *IB) { |
Jeff Cohen | 09b362c | 2007-04-20 22:40:10 +0000 | [diff] [blame] | 195 | #if 0 |
Chris Lattner | b76efb7 | 2007-01-07 08:12:01 +0000 | [diff] [blame] | 196 | if (AbortMessage == 0) |
| 197 | createAbortMessage(IB->getParent()->getParent()->getParent()); |
Chris Lattner | 0c3b390 | 2004-11-13 19:07:32 +0000 | [diff] [blame] | 198 | |
Chris Lattner | b76efb7 | 2007-01-07 08:12:01 +0000 | [diff] [blame] | 199 | // These are the arguments we WANT... |
Chris Lattner | 93e985f | 2007-02-13 02:10:56 +0000 | [diff] [blame] | 200 | Value* Args[3]; |
| 201 | Args[0] = ConstantInt::get(Type::Int32Ty, 2); |
| 202 | Args[1] = AbortMessage; |
| 203 | Args[2] = ConstantInt::get(Type::Int32Ty, AbortMessageLength); |
| 204 | (new CallInst(WriteFn, Args, 3, "", IB))->setTailCall(); |
Jeff Cohen | 09b362c | 2007-04-20 22:40:10 +0000 | [diff] [blame] | 205 | #endif |
Chris Lattner | 501825e | 2004-02-08 22:14:44 +0000 | [diff] [blame] | 206 | } |
| 207 | |
Chris Lattner | 6d78457 | 2004-02-08 19:53:56 +0000 | [diff] [blame] | 208 | bool LowerInvoke::insertCheapEHSupport(Function &F) { |
Chris Lattner | 86e4445 | 2003-10-05 19:14:42 +0000 | [diff] [blame] | 209 | bool Changed = false; |
Chris Lattner | dead993 | 2003-12-10 20:22:42 +0000 | [diff] [blame] | 210 | for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) |
| 211 | if (InvokeInst *II = dyn_cast<InvokeInst>(BB->getTerminator())) { |
Chris Lattner | 93e985f | 2007-02-13 02:10:56 +0000 | [diff] [blame] | 212 | std::vector<Value*> CallArgs(II->op_begin()+3, II->op_end()); |
Chris Lattner | 86e4445 | 2003-10-05 19:14:42 +0000 | [diff] [blame] | 213 | // Insert a normal call instruction... |
Chris Lattner | efd9168 | 2005-05-13 06:27:02 +0000 | [diff] [blame] | 214 | CallInst *NewCall = new CallInst(II->getCalledValue(), |
Duncan Sands | dc02467 | 2007-11-27 13:23:08 +0000 | [diff] [blame] | 215 | CallArgs.begin(), CallArgs.end(), "",II); |
Chris Lattner | 86cc423 | 2007-02-11 01:37:51 +0000 | [diff] [blame] | 216 | NewCall->takeName(II); |
Chris Lattner | efd9168 | 2005-05-13 06:27:02 +0000 | [diff] [blame] | 217 | NewCall->setCallingConv(II->getCallingConv()); |
Duncan Sands | dc02467 | 2007-11-27 13:23:08 +0000 | [diff] [blame] | 218 | NewCall->setParamAttrs(II->getParamAttrs()); |
Chris Lattner | 86e4445 | 2003-10-05 19:14:42 +0000 | [diff] [blame] | 219 | II->replaceAllUsesWith(NewCall); |
Misha Brukman | fd93908 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 220 | |
Chris Lattner | dead993 | 2003-12-10 20:22:42 +0000 | [diff] [blame] | 221 | // Insert an unconditional branch to the normal destination. |
Chris Lattner | 86e4445 | 2003-10-05 19:14:42 +0000 | [diff] [blame] | 222 | new BranchInst(II->getNormalDest(), II); |
| 223 | |
Chris Lattner | dead993 | 2003-12-10 20:22:42 +0000 | [diff] [blame] | 224 | // Remove any PHI node entries from the exception destination. |
Chris Lattner | aeb2a1d | 2004-02-08 21:44:31 +0000 | [diff] [blame] | 225 | II->getUnwindDest()->removePredecessor(BB); |
Chris Lattner | dead993 | 2003-12-10 20:22:42 +0000 | [diff] [blame] | 226 | |
Chris Lattner | 86e4445 | 2003-10-05 19:14:42 +0000 | [diff] [blame] | 227 | // Remove the invoke instruction now. |
Chris Lattner | dead993 | 2003-12-10 20:22:42 +0000 | [diff] [blame] | 228 | BB->getInstList().erase(II); |
Chris Lattner | 86e4445 | 2003-10-05 19:14:42 +0000 | [diff] [blame] | 229 | |
Chris Lattner | f4e6c3a | 2005-09-27 21:18:17 +0000 | [diff] [blame] | 230 | ++NumInvokes; Changed = true; |
Chris Lattner | dead993 | 2003-12-10 20:22:42 +0000 | [diff] [blame] | 231 | } else if (UnwindInst *UI = dyn_cast<UnwindInst>(BB->getTerminator())) { |
Chris Lattner | e1c0930 | 2004-02-08 07:30:29 +0000 | [diff] [blame] | 232 | // Insert a new call to write(2, AbortMessage, AbortMessageLength); |
Chris Lattner | 501825e | 2004-02-08 22:14:44 +0000 | [diff] [blame] | 233 | writeAbortMessage(UI); |
Chris Lattner | e1c0930 | 2004-02-08 07:30:29 +0000 | [diff] [blame] | 234 | |
Chris Lattner | 86e4445 | 2003-10-05 19:14:42 +0000 | [diff] [blame] | 235 | // Insert a call to abort() |
Chris Lattner | 93e985f | 2007-02-13 02:10:56 +0000 | [diff] [blame] | 236 | (new CallInst(AbortFn, "", UI))->setTailCall(); |
Chris Lattner | 86e4445 | 2003-10-05 19:14:42 +0000 | [diff] [blame] | 237 | |
Chris Lattner | 6d78457 | 2004-02-08 19:53:56 +0000 | [diff] [blame] | 238 | // Insert a return instruction. This really should be a "barrier", as it |
| 239 | // is unreachable. |
Chris Lattner | 86e4445 | 2003-10-05 19:14:42 +0000 | [diff] [blame] | 240 | new ReturnInst(F.getReturnType() == Type::VoidTy ? 0 : |
| 241 | Constant::getNullValue(F.getReturnType()), UI); |
| 242 | |
| 243 | // Remove the unwind instruction now. |
Chris Lattner | dead993 | 2003-12-10 20:22:42 +0000 | [diff] [blame] | 244 | BB->getInstList().erase(UI); |
Chris Lattner | 86e4445 | 2003-10-05 19:14:42 +0000 | [diff] [blame] | 245 | |
Chris Lattner | f4e6c3a | 2005-09-27 21:18:17 +0000 | [diff] [blame] | 246 | ++NumUnwinds; Changed = true; |
Chris Lattner | 86e4445 | 2003-10-05 19:14:42 +0000 | [diff] [blame] | 247 | } |
| 248 | return Changed; |
| 249 | } |
Chris Lattner | 6d78457 | 2004-02-08 19:53:56 +0000 | [diff] [blame] | 250 | |
Chris Lattner | f4e6c3a | 2005-09-27 21:18:17 +0000 | [diff] [blame] | 251 | /// rewriteExpensiveInvoke - Insert code and hack the function to replace the |
| 252 | /// specified invoke instruction with a call. |
| 253 | void LowerInvoke::rewriteExpensiveInvoke(InvokeInst *II, unsigned InvokeNo, |
| 254 | AllocaInst *InvokeNum, |
| 255 | SwitchInst *CatchSwitch) { |
Reid Spencer | c5b206b | 2006-12-31 05:48:39 +0000 | [diff] [blame] | 256 | ConstantInt *InvokeNoC = ConstantInt::get(Type::Int32Ty, InvokeNo); |
Chris Lattner | 6d78457 | 2004-02-08 19:53:56 +0000 | [diff] [blame] | 257 | |
Chris Lattner | 8c5c22f | 2008-02-14 19:18:13 +0000 | [diff] [blame] | 258 | // If the unwind edge has phi nodes, split the edge. |
| 259 | if (isa<PHINode>(II->getUnwindDest()->begin())) { |
| 260 | SplitCriticalEdge(II, 1, this); |
| 261 | |
| 262 | // If there are any phi nodes left, they must have a single predecessor. |
| 263 | while (PHINode *PN = dyn_cast<PHINode>(II->getUnwindDest()->begin())) { |
| 264 | PN->replaceAllUsesWith(PN->getIncomingValue(0)); |
| 265 | PN->eraseFromParent(); |
| 266 | } |
| 267 | } |
| 268 | |
Chris Lattner | f4e6c3a | 2005-09-27 21:18:17 +0000 | [diff] [blame] | 269 | // Insert a store of the invoke num before the invoke and store zero into the |
| 270 | // location afterward. |
| 271 | new StoreInst(InvokeNoC, InvokeNum, true, II); // volatile |
Chris Lattner | 93e50ce | 2005-09-29 17:44:20 +0000 | [diff] [blame] | 272 | |
| 273 | BasicBlock::iterator NI = II->getNormalDest()->begin(); |
| 274 | while (isa<PHINode>(NI)) ++NI; |
| 275 | // nonvolatile. |
Reid Spencer | c5b206b | 2006-12-31 05:48:39 +0000 | [diff] [blame] | 276 | new StoreInst(Constant::getNullValue(Type::Int32Ty), InvokeNum, false, NI); |
Chris Lattner | f4e6c3a | 2005-09-27 21:18:17 +0000 | [diff] [blame] | 277 | |
| 278 | // Add a switch case to our unwind block. |
| 279 | CatchSwitch->addCase(InvokeNoC, II->getUnwindDest()); |
| 280 | |
| 281 | // Insert a normal call instruction. |
Chris Lattner | 93e985f | 2007-02-13 02:10:56 +0000 | [diff] [blame] | 282 | std::vector<Value*> CallArgs(II->op_begin()+3, II->op_end()); |
Chris Lattner | f4e6c3a | 2005-09-27 21:18:17 +0000 | [diff] [blame] | 283 | CallInst *NewCall = new CallInst(II->getCalledValue(), |
David Greene | 52eec54 | 2007-08-01 03:43:44 +0000 | [diff] [blame] | 284 | CallArgs.begin(), CallArgs.end(), "", |
Chris Lattner | f4e6c3a | 2005-09-27 21:18:17 +0000 | [diff] [blame] | 285 | II); |
Chris Lattner | 86cc423 | 2007-02-11 01:37:51 +0000 | [diff] [blame] | 286 | NewCall->takeName(II); |
Chris Lattner | f4e6c3a | 2005-09-27 21:18:17 +0000 | [diff] [blame] | 287 | NewCall->setCallingConv(II->getCallingConv()); |
Duncan Sands | dc02467 | 2007-11-27 13:23:08 +0000 | [diff] [blame] | 288 | NewCall->setParamAttrs(II->getParamAttrs()); |
Chris Lattner | f4e6c3a | 2005-09-27 21:18:17 +0000 | [diff] [blame] | 289 | II->replaceAllUsesWith(NewCall); |
| 290 | |
| 291 | // Replace the invoke with an uncond branch. |
| 292 | new BranchInst(II->getNormalDest(), NewCall->getParent()); |
| 293 | II->eraseFromParent(); |
| 294 | } |
Chris Lattner | 6d78457 | 2004-02-08 19:53:56 +0000 | [diff] [blame] | 295 | |
Chris Lattner | f4e6c3a | 2005-09-27 21:18:17 +0000 | [diff] [blame] | 296 | /// MarkBlocksLiveIn - Insert BB and all of its predescessors into LiveBBs until |
| 297 | /// we reach blocks we've already seen. |
| 298 | static void MarkBlocksLiveIn(BasicBlock *BB, std::set<BasicBlock*> &LiveBBs) { |
| 299 | if (!LiveBBs.insert(BB).second) return; // already been here. |
| 300 | |
| 301 | for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) |
| 302 | MarkBlocksLiveIn(*PI, LiveBBs); |
| 303 | } |
Chris Lattner | 6d78457 | 2004-02-08 19:53:56 +0000 | [diff] [blame] | 304 | |
Chris Lattner | f4e6c3a | 2005-09-27 21:18:17 +0000 | [diff] [blame] | 305 | // First thing we need to do is scan the whole function for values that are |
| 306 | // live across unwind edges. Each value that is live across an unwind edge |
| 307 | // we spill into a stack location, guaranteeing that there is nothing live |
| 308 | // across the unwind edge. This process also splits all critical edges |
| 309 | // coming out of invoke's. |
| 310 | void LowerInvoke:: |
| 311 | splitLiveRangesLiveAcrossInvokes(std::vector<InvokeInst*> &Invokes) { |
| 312 | // First step, split all critical edges from invoke instructions. |
| 313 | for (unsigned i = 0, e = Invokes.size(); i != e; ++i) { |
| 314 | InvokeInst *II = Invokes[i]; |
| 315 | SplitCriticalEdge(II, 0, this); |
| 316 | SplitCriticalEdge(II, 1, this); |
| 317 | assert(!isa<PHINode>(II->getNormalDest()) && |
| 318 | !isa<PHINode>(II->getUnwindDest()) && |
| 319 | "critical edge splitting left single entry phi nodes?"); |
Chris Lattner | 6d78457 | 2004-02-08 19:53:56 +0000 | [diff] [blame] | 320 | } |
| 321 | |
Chris Lattner | f4e6c3a | 2005-09-27 21:18:17 +0000 | [diff] [blame] | 322 | Function *F = Invokes.back()->getParent()->getParent(); |
| 323 | |
| 324 | // To avoid having to handle incoming arguments specially, we lower each arg |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame] | 325 | // to a copy instruction in the entry block. This ensures that the argument |
Chris Lattner | f4e6c3a | 2005-09-27 21:18:17 +0000 | [diff] [blame] | 326 | // value itself cannot be live across the entry block. |
| 327 | BasicBlock::iterator AfterAllocaInsertPt = F->begin()->begin(); |
| 328 | while (isa<AllocaInst>(AfterAllocaInsertPt) && |
| 329 | isa<ConstantInt>(cast<AllocaInst>(AfterAllocaInsertPt)->getArraySize())) |
| 330 | ++AfterAllocaInsertPt; |
| 331 | for (Function::arg_iterator AI = F->arg_begin(), E = F->arg_end(); |
| 332 | AI != E; ++AI) { |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame] | 333 | // This is always a no-op cast because we're casting AI to AI->getType() so |
| 334 | // src and destination types are identical. BitCast is the only possibility. |
| 335 | CastInst *NC = new BitCastInst( |
| 336 | AI, AI->getType(), AI->getName()+".tmp", AfterAllocaInsertPt); |
Chris Lattner | f4e6c3a | 2005-09-27 21:18:17 +0000 | [diff] [blame] | 337 | AI->replaceAllUsesWith(NC); |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame] | 338 | // Normally its is forbidden to replace a CastInst's operand because it |
| 339 | // could cause the opcode to reflect an illegal conversion. However, we're |
| 340 | // replacing it here with the same value it was constructed with to simply |
| 341 | // make NC its user. |
| 342 | NC->setOperand(0, AI); |
Chris Lattner | f4e6c3a | 2005-09-27 21:18:17 +0000 | [diff] [blame] | 343 | } |
| 344 | |
| 345 | // Finally, scan the code looking for instructions with bad live ranges. |
| 346 | for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB) |
| 347 | for (BasicBlock::iterator II = BB->begin(), E = BB->end(); II != E; ++II) { |
| 348 | // Ignore obvious cases we don't have to handle. In particular, most |
| 349 | // instructions either have no uses or only have a single use inside the |
| 350 | // current block. Ignore them quickly. |
| 351 | Instruction *Inst = II; |
| 352 | if (Inst->use_empty()) continue; |
| 353 | if (Inst->hasOneUse() && |
| 354 | cast<Instruction>(Inst->use_back())->getParent() == BB && |
| 355 | !isa<PHINode>(Inst->use_back())) continue; |
| 356 | |
Chris Lattner | 4531371 | 2005-09-27 21:33:12 +0000 | [diff] [blame] | 357 | // If this is an alloca in the entry block, it's not a real register |
| 358 | // value. |
| 359 | if (AllocaInst *AI = dyn_cast<AllocaInst>(Inst)) |
| 360 | if (isa<ConstantInt>(AI->getArraySize()) && BB == F->begin()) |
| 361 | continue; |
| 362 | |
Chris Lattner | f4e6c3a | 2005-09-27 21:18:17 +0000 | [diff] [blame] | 363 | // Avoid iterator invalidation by copying users to a temporary vector. |
| 364 | std::vector<Instruction*> Users; |
| 365 | for (Value::use_iterator UI = Inst->use_begin(), E = Inst->use_end(); |
| 366 | UI != E; ++UI) { |
| 367 | Instruction *User = cast<Instruction>(*UI); |
| 368 | if (User->getParent() != BB || isa<PHINode>(User)) |
| 369 | Users.push_back(User); |
| 370 | } |
| 371 | |
| 372 | // Scan all of the uses and see if the live range is live across an unwind |
| 373 | // edge. If we find a use live across an invoke edge, create an alloca |
| 374 | // and spill the value. |
Chris Lattner | f4e6c3a | 2005-09-27 21:18:17 +0000 | [diff] [blame] | 375 | std::set<InvokeInst*> InvokesWithStoreInserted; |
| 376 | |
| 377 | // Find all of the blocks that this value is live in. |
| 378 | std::set<BasicBlock*> LiveBBs; |
| 379 | LiveBBs.insert(Inst->getParent()); |
| 380 | while (!Users.empty()) { |
| 381 | Instruction *U = Users.back(); |
| 382 | Users.pop_back(); |
| 383 | |
Chris Lattner | f4e6c3a | 2005-09-27 21:18:17 +0000 | [diff] [blame] | 384 | if (!isa<PHINode>(U)) { |
| 385 | MarkBlocksLiveIn(U->getParent(), LiveBBs); |
| 386 | } else { |
| 387 | // Uses for a PHI node occur in their predecessor block. |
| 388 | PHINode *PN = cast<PHINode>(U); |
| 389 | for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) |
| 390 | if (PN->getIncomingValue(i) == Inst) |
| 391 | MarkBlocksLiveIn(PN->getIncomingBlock(i), LiveBBs); |
| 392 | } |
| 393 | } |
| 394 | |
| 395 | // Now that we know all of the blocks that this thing is live in, see if |
| 396 | // it includes any of the unwind locations. |
| 397 | bool NeedsSpill = false; |
| 398 | for (unsigned i = 0, e = Invokes.size(); i != e; ++i) { |
| 399 | BasicBlock *UnwindBlock = Invokes[i]->getUnwindDest(); |
| 400 | if (UnwindBlock != BB && LiveBBs.count(UnwindBlock)) { |
| 401 | NeedsSpill = true; |
| 402 | } |
| 403 | } |
| 404 | |
| 405 | // If we decided we need a spill, do it. |
| 406 | if (NeedsSpill) { |
| 407 | ++NumSpilled; |
| 408 | DemoteRegToStack(*Inst, true); |
| 409 | } |
| 410 | } |
| 411 | } |
| 412 | |
| 413 | bool LowerInvoke::insertExpensiveEHSupport(Function &F) { |
| 414 | std::vector<ReturnInst*> Returns; |
| 415 | std::vector<UnwindInst*> Unwinds; |
| 416 | std::vector<InvokeInst*> Invokes; |
| 417 | |
| 418 | for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) |
| 419 | if (ReturnInst *RI = dyn_cast<ReturnInst>(BB->getTerminator())) { |
| 420 | // Remember all return instructions in case we insert an invoke into this |
| 421 | // function. |
| 422 | Returns.push_back(RI); |
| 423 | } else if (InvokeInst *II = dyn_cast<InvokeInst>(BB->getTerminator())) { |
| 424 | Invokes.push_back(II); |
| 425 | } else if (UnwindInst *UI = dyn_cast<UnwindInst>(BB->getTerminator())) { |
| 426 | Unwinds.push_back(UI); |
| 427 | } |
| 428 | |
| 429 | if (Unwinds.empty() && Invokes.empty()) return false; |
| 430 | |
| 431 | NumInvokes += Invokes.size(); |
| 432 | NumUnwinds += Unwinds.size(); |
Chris Lattner | 5b3c702 | 2005-09-27 22:44:59 +0000 | [diff] [blame] | 433 | |
| 434 | // TODO: This is not an optimal way to do this. In particular, this always |
| 435 | // inserts setjmp calls into the entries of functions with invoke instructions |
| 436 | // even though there are possibly paths through the function that do not |
| 437 | // execute any invokes. In particular, for functions with early exits, e.g. |
| 438 | // the 'addMove' method in hexxagon, it would be nice to not have to do the |
| 439 | // setjmp stuff on the early exit path. This requires a bit of dataflow, but |
| 440 | // would not be too hard to do. |
Chris Lattner | f4e6c3a | 2005-09-27 21:18:17 +0000 | [diff] [blame] | 441 | |
| 442 | // If we have an invoke instruction, insert a setjmp that dominates all |
| 443 | // invokes. After the setjmp, use a cond branch that goes to the original |
| 444 | // code path on zero, and to a designated 'catch' block of nonzero. |
| 445 | Value *OldJmpBufPtr = 0; |
| 446 | if (!Invokes.empty()) { |
| 447 | // First thing we need to do is scan the whole function for values that are |
| 448 | // live across unwind edges. Each value that is live across an unwind edge |
| 449 | // we spill into a stack location, guaranteeing that there is nothing live |
| 450 | // across the unwind edge. This process also splits all critical edges |
| 451 | // coming out of invoke's. |
| 452 | splitLiveRangesLiveAcrossInvokes(Invokes); |
| 453 | |
| 454 | BasicBlock *EntryBB = F.begin(); |
| 455 | |
| 456 | // Create an alloca for the incoming jump buffer ptr and the new jump buffer |
| 457 | // that needs to be restored on all exits from the function. This is an |
| 458 | // alloca because the value needs to be live across invokes. |
Chris Lattner | 97d2dbd | 2006-09-05 17:48:07 +0000 | [diff] [blame] | 459 | unsigned Align = TLI ? TLI->getJumpBufAlignment() : 0; |
Chris Lattner | f4e6c3a | 2005-09-27 21:18:17 +0000 | [diff] [blame] | 460 | AllocaInst *JmpBuf = |
Chris Lattner | 97d2dbd | 2006-09-05 17:48:07 +0000 | [diff] [blame] | 461 | new AllocaInst(JBLinkTy, 0, Align, "jblink", F.begin()->begin()); |
Chris Lattner | f4e6c3a | 2005-09-27 21:18:17 +0000 | [diff] [blame] | 462 | |
| 463 | std::vector<Value*> Idx; |
Reid Spencer | c5b206b | 2006-12-31 05:48:39 +0000 | [diff] [blame] | 464 | Idx.push_back(Constant::getNullValue(Type::Int32Ty)); |
| 465 | Idx.push_back(ConstantInt::get(Type::Int32Ty, 1)); |
David Greene | b8f7479 | 2007-09-04 15:46:09 +0000 | [diff] [blame] | 466 | OldJmpBufPtr = new GetElementPtrInst(JmpBuf, Idx.begin(), Idx.end(), |
| 467 | "OldBuf", EntryBB->getTerminator()); |
Chris Lattner | f4e6c3a | 2005-09-27 21:18:17 +0000 | [diff] [blame] | 468 | |
| 469 | // Copy the JBListHead to the alloca. |
| 470 | Value *OldBuf = new LoadInst(JBListHead, "oldjmpbufptr", true, |
| 471 | EntryBB->getTerminator()); |
| 472 | new StoreInst(OldBuf, OldJmpBufPtr, true, EntryBB->getTerminator()); |
| 473 | |
| 474 | // Add the new jumpbuf to the list. |
| 475 | new StoreInst(JmpBuf, JBListHead, true, EntryBB->getTerminator()); |
| 476 | |
| 477 | // Create the catch block. The catch block is basically a big switch |
| 478 | // statement that goes to all of the invoke catch blocks. |
| 479 | BasicBlock *CatchBB = new BasicBlock("setjmp.catch", &F); |
| 480 | |
| 481 | // Create an alloca which keeps track of which invoke is currently |
| 482 | // executing. For normal calls it contains zero. |
Reid Spencer | c5b206b | 2006-12-31 05:48:39 +0000 | [diff] [blame] | 483 | AllocaInst *InvokeNum = new AllocaInst(Type::Int32Ty, 0, "invokenum", |
Chris Lattner | f4e6c3a | 2005-09-27 21:18:17 +0000 | [diff] [blame] | 484 | EntryBB->begin()); |
Reid Spencer | c5b206b | 2006-12-31 05:48:39 +0000 | [diff] [blame] | 485 | new StoreInst(ConstantInt::get(Type::Int32Ty, 0), InvokeNum, true, |
Chris Lattner | f4e6c3a | 2005-09-27 21:18:17 +0000 | [diff] [blame] | 486 | EntryBB->getTerminator()); |
| 487 | |
| 488 | // Insert a load in the Catch block, and a switch on its value. By default, |
| 489 | // we go to a block that just does an unwind (which is the correct action |
| 490 | // for a standard call). |
| 491 | BasicBlock *UnwindBB = new BasicBlock("unwindbb", &F); |
| 492 | Unwinds.push_back(new UnwindInst(UnwindBB)); |
| 493 | |
| 494 | Value *CatchLoad = new LoadInst(InvokeNum, "invoke.num", true, CatchBB); |
| 495 | SwitchInst *CatchSwitch = |
| 496 | new SwitchInst(CatchLoad, UnwindBB, Invokes.size(), CatchBB); |
| 497 | |
| 498 | // Now that things are set up, insert the setjmp call itself. |
| 499 | |
| 500 | // Split the entry block to insert the conditional branch for the setjmp. |
| 501 | BasicBlock *ContBlock = EntryBB->splitBasicBlock(EntryBB->getTerminator(), |
| 502 | "setjmp.cont"); |
| 503 | |
Reid Spencer | c5b206b | 2006-12-31 05:48:39 +0000 | [diff] [blame] | 504 | Idx[1] = ConstantInt::get(Type::Int32Ty, 0); |
David Greene | b8f7479 | 2007-09-04 15:46:09 +0000 | [diff] [blame] | 505 | Value *JmpBufPtr = new GetElementPtrInst(JmpBuf, Idx.begin(), Idx.end(), |
Chris Lattner | 1ccd185 | 2007-02-12 22:56:41 +0000 | [diff] [blame] | 506 | "TheJmpBuf", |
Chris Lattner | f4e6c3a | 2005-09-27 21:18:17 +0000 | [diff] [blame] | 507 | EntryBB->getTerminator()); |
| 508 | Value *SJRet = new CallInst(SetJmpFn, JmpBufPtr, "sjret", |
| 509 | EntryBB->getTerminator()); |
| 510 | |
| 511 | // Compare the return value to zero. |
Reid Spencer | e4d87aa | 2006-12-23 06:05:41 +0000 | [diff] [blame] | 512 | Value *IsNormal = new ICmpInst(ICmpInst::ICMP_EQ, SJRet, |
| 513 | Constant::getNullValue(SJRet->getType()), |
| 514 | "notunwind", EntryBB->getTerminator()); |
Chris Lattner | f4e6c3a | 2005-09-27 21:18:17 +0000 | [diff] [blame] | 515 | // Nuke the uncond branch. |
| 516 | EntryBB->getTerminator()->eraseFromParent(); |
| 517 | |
| 518 | // Put in a new condbranch in its place. |
| 519 | new BranchInst(ContBlock, CatchBB, IsNormal, EntryBB); |
| 520 | |
| 521 | // At this point, we are all set up, rewrite each invoke instruction. |
| 522 | for (unsigned i = 0, e = Invokes.size(); i != e; ++i) |
| 523 | rewriteExpensiveInvoke(Invokes[i], i+1, InvokeNum, CatchSwitch); |
| 524 | } |
| 525 | |
| 526 | // We know that there is at least one unwind. |
| 527 | |
| 528 | // Create three new blocks, the block to load the jmpbuf ptr and compare |
| 529 | // against null, the block to do the longjmp, and the error block for if it |
| 530 | // is null. Add them at the end of the function because they are not hot. |
| 531 | BasicBlock *UnwindHandler = new BasicBlock("dounwind", &F); |
| 532 | BasicBlock *UnwindBlock = new BasicBlock("unwind", &F); |
| 533 | BasicBlock *TermBlock = new BasicBlock("unwinderror", &F); |
| 534 | |
| 535 | // If this function contains an invoke, restore the old jumpbuf ptr. |
| 536 | Value *BufPtr; |
| 537 | if (OldJmpBufPtr) { |
| 538 | // Before the return, insert a copy from the saved value to the new value. |
| 539 | BufPtr = new LoadInst(OldJmpBufPtr, "oldjmpbufptr", UnwindHandler); |
| 540 | new StoreInst(BufPtr, JBListHead, UnwindHandler); |
| 541 | } else { |
| 542 | BufPtr = new LoadInst(JBListHead, "ehlist", UnwindHandler); |
| 543 | } |
| 544 | |
| 545 | // Load the JBList, if it's null, then there was no catch! |
Reid Spencer | e4d87aa | 2006-12-23 06:05:41 +0000 | [diff] [blame] | 546 | Value *NotNull = new ICmpInst(ICmpInst::ICMP_NE, BufPtr, |
| 547 | Constant::getNullValue(BufPtr->getType()), |
| 548 | "notnull", UnwindHandler); |
Chris Lattner | f4e6c3a | 2005-09-27 21:18:17 +0000 | [diff] [blame] | 549 | new BranchInst(UnwindBlock, TermBlock, NotNull, UnwindHandler); |
| 550 | |
| 551 | // Create the block to do the longjmp. |
| 552 | // Get a pointer to the jmpbuf and longjmp. |
| 553 | std::vector<Value*> Idx; |
Reid Spencer | c5b206b | 2006-12-31 05:48:39 +0000 | [diff] [blame] | 554 | Idx.push_back(Constant::getNullValue(Type::Int32Ty)); |
| 555 | Idx.push_back(ConstantInt::get(Type::Int32Ty, 0)); |
David Greene | b8f7479 | 2007-09-04 15:46:09 +0000 | [diff] [blame] | 556 | Idx[0] = new GetElementPtrInst(BufPtr, Idx.begin(), Idx.end(), "JmpBuf", |
| 557 | UnwindBlock); |
Reid Spencer | c5b206b | 2006-12-31 05:48:39 +0000 | [diff] [blame] | 558 | Idx[1] = ConstantInt::get(Type::Int32Ty, 1); |
David Greene | 52eec54 | 2007-08-01 03:43:44 +0000 | [diff] [blame] | 559 | new CallInst(LongJmpFn, Idx.begin(), Idx.end(), "", UnwindBlock); |
Chris Lattner | f4e6c3a | 2005-09-27 21:18:17 +0000 | [diff] [blame] | 560 | new UnreachableInst(UnwindBlock); |
| 561 | |
| 562 | // Set up the term block ("throw without a catch"). |
| 563 | new UnreachableInst(TermBlock); |
| 564 | |
| 565 | // Insert a new call to write(2, AbortMessage, AbortMessageLength); |
| 566 | writeAbortMessage(TermBlock->getTerminator()); |
| 567 | |
| 568 | // Insert a call to abort() |
Chris Lattner | 93e985f | 2007-02-13 02:10:56 +0000 | [diff] [blame] | 569 | (new CallInst(AbortFn, "", |
Chris Lattner | f4e6c3a | 2005-09-27 21:18:17 +0000 | [diff] [blame] | 570 | TermBlock->getTerminator()))->setTailCall(); |
| 571 | |
| 572 | |
| 573 | // Replace all unwinds with a branch to the unwind handler. |
| 574 | for (unsigned i = 0, e = Unwinds.size(); i != e; ++i) { |
| 575 | new BranchInst(UnwindHandler, Unwinds[i]); |
| 576 | Unwinds[i]->eraseFromParent(); |
| 577 | } |
| 578 | |
| 579 | // Finally, for any returns from this function, if this function contains an |
| 580 | // invoke, restore the old jmpbuf pointer to its input value. |
| 581 | if (OldJmpBufPtr) { |
| 582 | for (unsigned i = 0, e = Returns.size(); i != e; ++i) { |
| 583 | ReturnInst *R = Returns[i]; |
| 584 | |
| 585 | // Before the return, insert a copy from the saved value to the new value. |
| 586 | Value *OldBuf = new LoadInst(OldJmpBufPtr, "oldjmpbufptr", true, R); |
| 587 | new StoreInst(OldBuf, JBListHead, true, R); |
| 588 | } |
| 589 | } |
| 590 | |
| 591 | return true; |
Chris Lattner | 6d78457 | 2004-02-08 19:53:56 +0000 | [diff] [blame] | 592 | } |
| 593 | |
| 594 | bool LowerInvoke::runOnFunction(Function &F) { |
| 595 | if (ExpensiveEHSupport) |
| 596 | return insertExpensiveEHSupport(F); |
| 597 | else |
| 598 | return insertCheapEHSupport(F); |
| 599 | } |