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