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