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