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