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