18b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach//===- SjLjEHPass.cpp - Eliminate Invoke & Unwind instructions -----------===// 28b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach// 38b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach// The LLVM Compiler Infrastructure 48b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach// 58b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach// This file is distributed under the University of Illinois Open Source 68b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach// License. See LICENSE.TXT for details. 78b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach// 88b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach//===----------------------------------------------------------------------===// 98b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach// 108b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach// This transformation is designed for use by code generators which use SjLj 118b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach// based exception handling. 128b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach// 138b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach//===----------------------------------------------------------------------===// 148b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 158b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach#define DEBUG_TYPE "sjljehprepare" 168b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach#include "llvm/Transforms/Scalar.h" 178b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach#include "llvm/Constants.h" 188b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach#include "llvm/DerivedTypes.h" 198b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach#include "llvm/Instructions.h" 208b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach#include "llvm/Intrinsics.h" 218b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach#include "llvm/LLVMContext.h" 228b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach#include "llvm/Module.h" 238b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach#include "llvm/Pass.h" 24f788854d20b12c60fd8b43c587adb3227b6b1bffBenjamin Kramer#include "llvm/CodeGen/Passes.h" 252b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling#include "llvm/Target/TargetData.h" 268b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach#include "llvm/Target/TargetLowering.h" 27f788854d20b12c60fd8b43c587adb3227b6b1bffBenjamin Kramer#include "llvm/Transforms/Utils/BasicBlockUtils.h" 28f788854d20b12c60fd8b43c587adb3227b6b1bffBenjamin Kramer#include "llvm/Transforms/Utils/Local.h" 292b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling#include "llvm/Support/CommandLine.h" 30d36b3e36811e8b50476076ee4986068481916f66Bill Wendling#include "llvm/Support/Debug.h" 312b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling#include "llvm/Support/IRBuilder.h" 32aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling#include "llvm/ADT/DenseMap.h" 33d36b3e36811e8b50476076ee4986068481916f66Bill Wendling#include "llvm/ADT/SmallVector.h" 34d36b3e36811e8b50476076ee4986068481916f66Bill Wendling#include "llvm/ADT/Statistic.h" 35f788854d20b12c60fd8b43c587adb3227b6b1bffBenjamin Kramer#include <set> 368b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbachusing namespace llvm; 378b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 382b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendlingstatic cl::opt<bool> DisableOldSjLjEH("disable-old-sjlj-eh", cl::Hidden, 3913a7121858238bc3490b27206a609bf8a2ce1f21Bill Wendling cl::init(true), 402b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling cl::desc("Disable the old SjLj EH preparation pass")); 412b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 428b818d7e98309125c6058c4ea72a7dc73b031db2Jim GrosbachSTATISTIC(NumInvokes, "Number of invokes replaced"); 438b818d7e98309125c6058c4ea72a7dc73b031db2Jim GrosbachSTATISTIC(NumUnwinds, "Number of unwinds replaced"); 448b818d7e98309125c6058c4ea72a7dc73b031db2Jim GrosbachSTATISTIC(NumSpilled, "Number of registers live across unwind edges"); 458b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 468b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbachnamespace { 476726b6d75a8b679068a58cb954ba97cf9d1690baNick Lewycky class SjLjEHPass : public FunctionPass { 488b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach const TargetLowering *TLI; 49db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *FunctionContextTy; 508b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach Constant *RegisterFn; 518b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach Constant *UnregisterFn; 528b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach Constant *BuiltinSetjmpFn; 538b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach Constant *FrameAddrFn; 540798eddd07b8dc827a4e6e9028c4c3a8d9444286Jim Grosbach Constant *StackAddrFn; 550798eddd07b8dc827a4e6e9028c4c3a8d9444286Jim Grosbach Constant *StackRestoreFn; 568b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach Constant *LSDAAddrFn; 578b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach Value *PersonalityFn; 58b01bbdcc1af27bd90b552bb1b62b48916e0d4be3Duncan Sands Constant *SelectorFn; 598b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach Constant *ExceptionFn; 60ca752c9020a1b1cf151142bd9e0cbca9af12d807Jim Grosbach Constant *CallSiteFn; 61e4ad387a5a88dae20f0f7578e55170bbc8eee2a9Jim Grosbach Constant *DispatchSetupFn; 62cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling Constant *FuncCtxFn; 638b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach Value *CallSite; 64aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling DenseMap<InvokeInst*, BasicBlock*> LPadSuccMap; 658b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach public: 668b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach static char ID; // Pass identification, replacement for typeid 678b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach explicit SjLjEHPass(const TargetLowering *tli = NULL) 6890c579de5a383cee278acc3f7e7b9d0a656e6a35Owen Anderson : FunctionPass(ID), TLI(tli) { } 698b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach bool doInitialization(Module &M); 708b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach bool runOnFunction(Function &F); 718b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 72d36b3e36811e8b50476076ee4986068481916f66Bill Wendling virtual void getAnalysisUsage(AnalysisUsage &AU) const {} 738b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach const char *getPassName() const { 748b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach return "SJLJ Exception Handling preparation"; 758b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach } 768b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 778b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach private: 782b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling bool setupEntryBlockAndCallSites(Function &F); 79631d11765b9f7ebdb49679c92bd41083fbab3f62Bill Wendling Value *setupFunctionContext(Function &F, ArrayRef<LandingPadInst*> LPads); 80d5d170097241534401bbbebb4be59451d5c312caBill Wendling void lowerIncomingArguments(Function &F); 81d5d170097241534401bbbebb4be59451d5c312caBill Wendling void lowerAcrossUnwindEdges(Function &F, ArrayRef<InvokeInst*> Invokes); 822b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 83b58a59b3c1563ab5bd7225748e32933bf6d76c03Jim Grosbach void insertCallSiteStore(Instruction *I, int Number, Value *CallSite); 84b58a59b3c1563ab5bd7225748e32933bf6d76c03Jim Grosbach void markInvokeCallSite(InvokeInst *II, int InvokeNo, Value *CallSite, 850bb61c56bcad7a738d50f705b5966be446ef06c1Jim Grosbach SwitchInst *CatchSwitch); 86288694f430bc227d12b74f84f7e26e64d3b7f56bJim Grosbach void splitLiveRangesAcrossInvokes(SmallVector<InvokeInst*,16> &Invokes); 873669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling void splitLandingPad(InvokeInst *II); 888b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach bool insertSjLjEHSupport(Function &F); 898b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach }; 908b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach} // end anonymous namespace 918b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 928b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbachchar SjLjEHPass::ID = 0; 938b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 948b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach// Public Interface To the SjLjEHPass pass. 958b818d7e98309125c6058c4ea72a7dc73b031db2Jim GrosbachFunctionPass *llvm::createSjLjEHPass(const TargetLowering *TLI) { 968b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach return new SjLjEHPass(TLI); 978b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach} 98a235d13217ff14621a88f3ea96a8a3b980c56d02Jim Grosbach// doInitialization - Set up decalarations and types needed to process 99a235d13217ff14621a88f3ea96a8a3b980c56d02Jim Grosbach// exceptions. 1008b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbachbool SjLjEHPass::doInitialization(Module &M) { 1018b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach // Build the function context structure. 1028b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach // builtin_setjmp uses a five word jbuf 1035fdd6c8793462549e3593890ec61573da06e3346Jay Foad Type *VoidPtrTy = Type::getInt8PtrTy(M.getContext()); 1045fdd6c8793462549e3593890ec61573da06e3346Jay Foad Type *Int32Ty = Type::getInt32Ty(M.getContext()); 1058b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach FunctionContextTy = 106b2318662b6d2e6d9ea9917fd280dde0ba9a938adChris Lattner StructType::get(VoidPtrTy, // __prev 1078b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach Int32Ty, // call_site 1088b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach ArrayType::get(Int32Ty, 4), // __data 1098b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach VoidPtrTy, // __personality 1108b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach VoidPtrTy, // __lsda 1118b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach ArrayType::get(VoidPtrTy, 5), // __jbuf 1128b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach NULL); 1138b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach RegisterFn = M.getOrInsertFunction("_Unwind_SjLj_Register", 1148b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach Type::getVoidTy(M.getContext()), 1158b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach PointerType::getUnqual(FunctionContextTy), 1168b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach (Type *)0); 1178b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach UnregisterFn = 1188b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach M.getOrInsertFunction("_Unwind_SjLj_Unregister", 1198b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach Type::getVoidTy(M.getContext()), 1208b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach PointerType::getUnqual(FunctionContextTy), 1218b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach (Type *)0); 1228b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach FrameAddrFn = Intrinsic::getDeclaration(&M, Intrinsic::frameaddress); 1230798eddd07b8dc827a4e6e9028c4c3a8d9444286Jim Grosbach StackAddrFn = Intrinsic::getDeclaration(&M, Intrinsic::stacksave); 1240798eddd07b8dc827a4e6e9028c4c3a8d9444286Jim Grosbach StackRestoreFn = Intrinsic::getDeclaration(&M, Intrinsic::stackrestore); 1258b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach BuiltinSetjmpFn = Intrinsic::getDeclaration(&M, Intrinsic::eh_sjlj_setjmp); 1268b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach LSDAAddrFn = Intrinsic::getDeclaration(&M, Intrinsic::eh_sjlj_lsda); 127b01bbdcc1af27bd90b552bb1b62b48916e0d4be3Duncan Sands SelectorFn = Intrinsic::getDeclaration(&M, Intrinsic::eh_selector); 1288b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach ExceptionFn = Intrinsic::getDeclaration(&M, Intrinsic::eh_exception); 129ca752c9020a1b1cf151142bd9e0cbca9af12d807Jim Grosbach CallSiteFn = Intrinsic::getDeclaration(&M, Intrinsic::eh_sjlj_callsite); 130e4ad387a5a88dae20f0f7578e55170bbc8eee2a9Jim Grosbach DispatchSetupFn 131e4ad387a5a88dae20f0f7578e55170bbc8eee2a9Jim Grosbach = Intrinsic::getDeclaration(&M, Intrinsic::eh_sjlj_dispatch_setup); 132cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling FuncCtxFn = Intrinsic::getDeclaration(&M, Intrinsic::eh_sjlj_functioncontext); 133a235d13217ff14621a88f3ea96a8a3b980c56d02Jim Grosbach PersonalityFn = 0; 1348b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 1358b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach return true; 1368b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach} 1378b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 138b58a59b3c1563ab5bd7225748e32933bf6d76c03Jim Grosbach/// insertCallSiteStore - Insert a store of the call-site value to the 139b58a59b3c1563ab5bd7225748e32933bf6d76c03Jim Grosbach/// function context 140b58a59b3c1563ab5bd7225748e32933bf6d76c03Jim Grosbachvoid SjLjEHPass::insertCallSiteStore(Instruction *I, int Number, 141b58a59b3c1563ab5bd7225748e32933bf6d76c03Jim Grosbach Value *CallSite) { 142b58a59b3c1563ab5bd7225748e32933bf6d76c03Jim Grosbach ConstantInt *CallSiteNoC = ConstantInt::get(Type::getInt32Ty(I->getContext()), 143b58a59b3c1563ab5bd7225748e32933bf6d76c03Jim Grosbach Number); 144b58a59b3c1563ab5bd7225748e32933bf6d76c03Jim Grosbach // Insert a store of the call-site number 145b58a59b3c1563ab5bd7225748e32933bf6d76c03Jim Grosbach new StoreInst(CallSiteNoC, CallSite, true, I); // volatile 146b58a59b3c1563ab5bd7225748e32933bf6d76c03Jim Grosbach} 147b58a59b3c1563ab5bd7225748e32933bf6d76c03Jim Grosbach 1483669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling/// splitLandingPad - Split a landing pad. This takes considerable care because 1493669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling/// of PHIs and other nasties. The problem is that the jump table needs to jump 1503669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling/// to the landing pad block. However, the landing pad block can be jumped to 1513669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling/// only by an invoke instruction. So we clone the landingpad instruction into 1523669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling/// its own basic block, have the invoke jump to there. The landingpad 1533669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling/// instruction's basic block's successor is now the target for the jump table. 1543669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling/// 1553669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling/// But because of PHI nodes, we need to create another basic block for the jump 1563669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling/// table to jump to. This is definitely a hack, because the values for the PHI 1573669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling/// nodes may not be defined on the edge from the jump table. But that's okay, 1583669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling/// because the jump table is simply a construct to mimic what is happening in 1593669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling/// the CFG. So the values are mysteriously there, even though there is no value 1603669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling/// for the PHI from the jump table's edge (hence calling this a hack). 1613669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendlingvoid SjLjEHPass::splitLandingPad(InvokeInst *II) { 1623669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling SmallVector<BasicBlock*, 2> NewBBs; 1633669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling SplitLandingPadPredecessors(II->getUnwindDest(), II->getParent(), 1643669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling ".1", ".2", this, NewBBs); 1653669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling 1663669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling // Create an empty block so that the jump table has something to jump to 1673669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling // which doesn't have any PHI nodes. 1683669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling BasicBlock *LPad = NewBBs[0]; 1693669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling BasicBlock *Succ = *succ_begin(LPad); 1703669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling BasicBlock *JumpTo = BasicBlock::Create(II->getContext(), "jt.land", 1713669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling LPad->getParent(), Succ); 1723669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling LPad->getTerminator()->eraseFromParent(); 1733669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling BranchInst::Create(JumpTo, LPad); 1743669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling BranchInst::Create(Succ, JumpTo); 1753669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling LPadSuccMap[II] = JumpTo; 1763669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling 1773669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling for (BasicBlock::iterator I = Succ->begin(); isa<PHINode>(I); ++I) { 1783669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling PHINode *PN = cast<PHINode>(I); 1793669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling Value *Val = PN->removeIncomingValue(LPad, false); 1803669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling PN->addIncoming(Val, JumpTo); 1813669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling } 1823669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling} 1833669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling 1848b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach/// markInvokeCallSite - Insert code to mark the call_site for this invoke 185b58a59b3c1563ab5bd7225748e32933bf6d76c03Jim Grosbachvoid SjLjEHPass::markInvokeCallSite(InvokeInst *II, int InvokeNo, 1860bb61c56bcad7a738d50f705b5966be446ef06c1Jim Grosbach Value *CallSite, 1870bb61c56bcad7a738d50f705b5966be446ef06c1Jim Grosbach SwitchInst *CatchSwitch) { 1888b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach ConstantInt *CallSiteNoC= ConstantInt::get(Type::getInt32Ty(II->getContext()), 189b58a59b3c1563ab5bd7225748e32933bf6d76c03Jim Grosbach InvokeNo); 1900bb61c56bcad7a738d50f705b5966be446ef06c1Jim Grosbach // The runtime comes back to the dispatcher with the call_site - 1 in 1910bb61c56bcad7a738d50f705b5966be446ef06c1Jim Grosbach // the context. Odd, but there it is. 1920bb61c56bcad7a738d50f705b5966be446ef06c1Jim Grosbach ConstantInt *SwitchValC = ConstantInt::get(Type::getInt32Ty(II->getContext()), 1933669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling InvokeNo - 1); 1948b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 1958b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach // If the unwind edge has phi nodes, split the edge. 1968b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach if (isa<PHINode>(II->getUnwindDest()->begin())) { 19751fb91c04c920703fbd4a67ac3f85c0971b2c5a5Bill Wendling // FIXME: New EH - This if-condition will be always true in the new scheme. 1983669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling if (II->getUnwindDest()->isLandingPad()) 1993669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling splitLandingPad(II); 2003669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling else 20151fb91c04c920703fbd4a67ac3f85c0971b2c5a5Bill Wendling SplitCriticalEdge(II, 1, this); 2028b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 2038b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach // If there are any phi nodes left, they must have a single predecessor. 2048b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach while (PHINode *PN = dyn_cast<PHINode>(II->getUnwindDest()->begin())) { 2058b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach PN->replaceAllUsesWith(PN->getIncomingValue(0)); 2068b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach PN->eraseFromParent(); 2078b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach } 2088b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach } 2098b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 210b58a59b3c1563ab5bd7225748e32933bf6d76c03Jim Grosbach // Insert the store of the call site value 211b58a59b3c1563ab5bd7225748e32933bf6d76c03Jim Grosbach insertCallSiteStore(II, InvokeNo, CallSite); 212b58a59b3c1563ab5bd7225748e32933bf6d76c03Jim Grosbach 213b58a59b3c1563ab5bd7225748e32933bf6d76c03Jim Grosbach // Record the call site value for the back end so it stays associated with 214b58a59b3c1563ab5bd7225748e32933bf6d76c03Jim Grosbach // the invoke. 215ca752c9020a1b1cf151142bd9e0cbca9af12d807Jim Grosbach CallInst::Create(CallSiteFn, CallSiteNoC, "", II); 2168b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 2170bb61c56bcad7a738d50f705b5966be446ef06c1Jim Grosbach // Add a switch case to our unwind block. 218aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling if (BasicBlock *SuccBB = LPadSuccMap[II]) { 219aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling CatchSwitch->addCase(SwitchValC, SuccBB); 220aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling } else { 221aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling CatchSwitch->addCase(SwitchValC, II->getUnwindDest()); 222aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling } 223aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling 224ca752c9020a1b1cf151142bd9e0cbca9af12d807Jim Grosbach // We still want this to look like an invoke so we emit the LSDA properly, 225ca752c9020a1b1cf151142bd9e0cbca9af12d807Jim Grosbach // so we don't transform the invoke into a call here. 2268b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach} 2278b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 2288b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach/// MarkBlocksLiveIn - Insert BB and all of its predescessors into LiveBBs until 2298b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach/// we reach blocks we've already seen. 2308b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbachstatic void MarkBlocksLiveIn(BasicBlock *BB, std::set<BasicBlock*> &LiveBBs) { 2318b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach if (!LiveBBs.insert(BB).second) return; // already been here. 2328b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 2338b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) 2348b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach MarkBlocksLiveIn(*PI, LiveBBs); 2358b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach} 2368b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 237606f3d696ff78211524fa49c3ca0c4de6db37041Jim Grosbach/// splitLiveRangesAcrossInvokes - Each value that is live across an unwind edge 238606f3d696ff78211524fa49c3ca0c4de6db37041Jim Grosbach/// we spill into a stack location, guaranteeing that there is nothing live 239606f3d696ff78211524fa49c3ca0c4de6db37041Jim Grosbach/// across the unwind edge. This process also splits all critical edges 240606f3d696ff78211524fa49c3ca0c4de6db37041Jim Grosbach/// coming out of invoke's. 2412f3257ef04a40adfeb6440d1b02f7bbfee0dd4fcJim Grosbach/// FIXME: Move this function to a common utility file (Local.cpp?) so 2422f3257ef04a40adfeb6440d1b02f7bbfee0dd4fcJim Grosbach/// both SjLj and LowerInvoke can use it. 2438b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbachvoid SjLjEHPass:: 244288694f430bc227d12b74f84f7e26e64d3b7f56bJim GrosbachsplitLiveRangesAcrossInvokes(SmallVector<InvokeInst*,16> &Invokes) { 2458b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach // First step, split all critical edges from invoke instructions. 2468b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach for (unsigned i = 0, e = Invokes.size(); i != e; ++i) { 2478b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach InvokeInst *II = Invokes[i]; 2488b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach SplitCriticalEdge(II, 0, this); 249aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling 250aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling // FIXME: New EH - This if-condition will be always true in the new scheme. 2513669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling if (II->getUnwindDest()->isLandingPad()) 2523669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling splitLandingPad(II); 2533669915c6dc8d57a4525fb0c592e6c8c1df098f5Bill Wendling else 254aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling SplitCriticalEdge(II, 1, this); 255aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling 2568b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach assert(!isa<PHINode>(II->getNormalDest()) && 2578b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach !isa<PHINode>(II->getUnwindDest()) && 258d36b3e36811e8b50476076ee4986068481916f66Bill Wendling "Critical edge splitting left single entry phi nodes?"); 2598b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach } 2608b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 2618b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach Function *F = Invokes.back()->getParent()->getParent(); 2628b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 2638b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach // To avoid having to handle incoming arguments specially, we lower each arg 2648b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach // to a copy instruction in the entry block. This ensures that the argument 2658b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach // value itself cannot be live across the entry block. 2668b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach BasicBlock::iterator AfterAllocaInsertPt = F->begin()->begin(); 2678b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach while (isa<AllocaInst>(AfterAllocaInsertPt) && 2688b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach isa<ConstantInt>(cast<AllocaInst>(AfterAllocaInsertPt)->getArraySize())) 2698b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach ++AfterAllocaInsertPt; 2708b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach for (Function::arg_iterator AI = F->arg_begin(), E = F->arg_end(); 2718b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach AI != E; ++AI) { 272db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty = AI->getType(); 273e70fc8ea6427934ee780db68d72aca07c629e0cdJim Grosbach // Aggregate types can't be cast, but are legal argument types, so we have 274dc58b25ebc4d6b79f36db09a0b718ca957a610ebJim Grosbach // to handle them differently. We use an extract/insert pair as a 275dc58b25ebc4d6b79f36db09a0b718ca957a610ebJim Grosbach // lightweight method to achieve the same goal. 276e70fc8ea6427934ee780db68d72aca07c629e0cdJim Grosbach if (isa<StructType>(Ty) || isa<ArrayType>(Ty) || isa<VectorType>(Ty)) { 277e70fc8ea6427934ee780db68d72aca07c629e0cdJim Grosbach Instruction *EI = ExtractValueInst::Create(AI, 0, "",AfterAllocaInsertPt); 278dc58b25ebc4d6b79f36db09a0b718ca957a610ebJim Grosbach Instruction *NI = InsertValueInst::Create(AI, EI, 0); 279dc58b25ebc4d6b79f36db09a0b718ca957a610ebJim Grosbach NI->insertAfter(EI); 280dc58b25ebc4d6b79f36db09a0b718ca957a610ebJim Grosbach AI->replaceAllUsesWith(NI); 281e70fc8ea6427934ee780db68d72aca07c629e0cdJim Grosbach // Set the operand of the instructions back to the AllocaInst. 282dc58b25ebc4d6b79f36db09a0b718ca957a610ebJim Grosbach EI->setOperand(0, AI); 283dc58b25ebc4d6b79f36db09a0b718ca957a610ebJim Grosbach NI->setOperand(0, AI); 284dc58b25ebc4d6b79f36db09a0b718ca957a610ebJim Grosbach } else { 285dc58b25ebc4d6b79f36db09a0b718ca957a610ebJim Grosbach // This is always a no-op cast because we're casting AI to AI->getType() 286dc58b25ebc4d6b79f36db09a0b718ca957a610ebJim Grosbach // so src and destination types are identical. BitCast is the only 287dc58b25ebc4d6b79f36db09a0b718ca957a610ebJim Grosbach // possibility. 288dc58b25ebc4d6b79f36db09a0b718ca957a610ebJim Grosbach CastInst *NC = new BitCastInst( 289dc58b25ebc4d6b79f36db09a0b718ca957a610ebJim Grosbach AI, AI->getType(), AI->getName()+".tmp", AfterAllocaInsertPt); 290dc58b25ebc4d6b79f36db09a0b718ca957a610ebJim Grosbach AI->replaceAllUsesWith(NC); 291dc58b25ebc4d6b79f36db09a0b718ca957a610ebJim Grosbach // Set the operand of the cast instruction back to the AllocaInst. 292dc58b25ebc4d6b79f36db09a0b718ca957a610ebJim Grosbach // Normally it's forbidden to replace a CastInst's operand because it 293dc58b25ebc4d6b79f36db09a0b718ca957a610ebJim Grosbach // could cause the opcode to reflect an illegal conversion. However, 294dc58b25ebc4d6b79f36db09a0b718ca957a610ebJim Grosbach // we're replacing it here with the same value it was constructed with. 295dc58b25ebc4d6b79f36db09a0b718ca957a610ebJim Grosbach // We do this because the above replaceAllUsesWith() clobbered the 296dc58b25ebc4d6b79f36db09a0b718ca957a610ebJim Grosbach // operand, but we want this one to remain. 297dc58b25ebc4d6b79f36db09a0b718ca957a610ebJim Grosbach NC->setOperand(0, AI); 298dc58b25ebc4d6b79f36db09a0b718ca957a610ebJim Grosbach } 2998b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach } 3008b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 3018b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach // Finally, scan the code looking for instructions with bad live ranges. 3028b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB) 3038b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach for (BasicBlock::iterator II = BB->begin(), E = BB->end(); II != E; ++II) { 3048b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach // Ignore obvious cases we don't have to handle. In particular, most 3058b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach // instructions either have no uses or only have a single use inside the 3068b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach // current block. Ignore them quickly. 3078b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach Instruction *Inst = II; 3088b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach if (Inst->use_empty()) continue; 3098b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach if (Inst->hasOneUse() && 3108b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach cast<Instruction>(Inst->use_back())->getParent() == BB && 3118b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach !isa<PHINode>(Inst->use_back())) continue; 3128b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 3138b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach // If this is an alloca in the entry block, it's not a real register 3148b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach // value. 3158b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach if (AllocaInst *AI = dyn_cast<AllocaInst>(Inst)) 3168b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach if (isa<ConstantInt>(AI->getArraySize()) && BB == F->begin()) 3178b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach continue; 3188b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 3198b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach // Avoid iterator invalidation by copying users to a temporary vector. 320606f3d696ff78211524fa49c3ca0c4de6db37041Jim Grosbach SmallVector<Instruction*,16> Users; 3218b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach for (Value::use_iterator UI = Inst->use_begin(), E = Inst->use_end(); 3228b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach UI != E; ++UI) { 3238b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach Instruction *User = cast<Instruction>(*UI); 3248b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach if (User->getParent() != BB || isa<PHINode>(User)) 3258b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach Users.push_back(User); 3268b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach } 3278b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 3288b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach // Find all of the blocks that this value is live in. 3298b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach std::set<BasicBlock*> LiveBBs; 3308b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach LiveBBs.insert(Inst->getParent()); 3318b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach while (!Users.empty()) { 3328b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach Instruction *U = Users.back(); 3338b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach Users.pop_back(); 3348b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 3358b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach if (!isa<PHINode>(U)) { 3368b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach MarkBlocksLiveIn(U->getParent(), LiveBBs); 3378b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach } else { 3388b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach // Uses for a PHI node occur in their predecessor block. 3398b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach PHINode *PN = cast<PHINode>(U); 3408b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) 3418b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach if (PN->getIncomingValue(i) == Inst) 3428b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach MarkBlocksLiveIn(PN->getIncomingBlock(i), LiveBBs); 3438b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach } 3448b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach } 3458b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 3468b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach // Now that we know all of the blocks that this thing is live in, see if 3478b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach // it includes any of the unwind locations. 3488b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach bool NeedsSpill = false; 3498b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach for (unsigned i = 0, e = Invokes.size(); i != e; ++i) { 3508b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach BasicBlock *UnwindBlock = Invokes[i]->getUnwindDest(); 351d5d170097241534401bbbebb4be59451d5c312caBill Wendling if (UnwindBlock != BB && LiveBBs.count(UnwindBlock)) 3528b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach NeedsSpill = true; 3538b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach } 3548b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 3558b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach // If we decided we need a spill, do it. 356956352eb4682ba7000486d8712a4435a843a48d4Jim Grosbach // FIXME: Spilling this way is overkill, as it forces all uses of 357956352eb4682ba7000486d8712a4435a843a48d4Jim Grosbach // the value to be reloaded from the stack slot, even those that aren't 358956352eb4682ba7000486d8712a4435a843a48d4Jim Grosbach // in the unwind blocks. We should be more selective. 3598b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach if (NeedsSpill) { 3608b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach ++NumSpilled; 3618b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach DemoteRegToStack(*Inst, true); 3628b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach } 3638b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach } 3648b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach} 3658b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 366aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling/// CreateLandingPadLoad - Load the exception handling values and insert them 367aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling/// into a structure. 368aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendlingstatic Instruction *CreateLandingPadLoad(Function &F, Value *ExnAddr, 369aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling Value *SelAddr, 370aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling BasicBlock::iterator InsertPt) { 371aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling Value *Exn = new LoadInst(ExnAddr, "exn", false, 372aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling InsertPt); 373aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling Type *Ty = Type::getInt8PtrTy(F.getContext()); 374aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling Exn = CastInst::Create(Instruction::IntToPtr, Exn, Ty, "", InsertPt); 375aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling Value *Sel = new LoadInst(SelAddr, "sel", false, InsertPt); 376aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling 377aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling Ty = StructType::get(Exn->getType(), Sel->getType(), NULL); 378aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling InsertValueInst *LPadVal = InsertValueInst::Create(llvm::UndefValue::get(Ty), 379aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling Exn, 0, 380aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling "lpad.val", InsertPt); 381aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling return InsertValueInst::Create(LPadVal, Sel, 1, "lpad.val", InsertPt); 382aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling} 383aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling 384aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling/// ReplaceLandingPadVal - Replace the landingpad instruction's value with a 385aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling/// load from the stored values (via CreateLandingPadLoad). This looks through 386aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling/// PHI nodes, and removes them if they are dead. 387aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendlingstatic void ReplaceLandingPadVal(Function &F, Instruction *Inst, Value *ExnAddr, 388aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling Value *SelAddr) { 389aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling if (Inst->use_empty()) return; 390aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling 391aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling while (!Inst->use_empty()) { 392aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling Instruction *I = cast<Instruction>(Inst->use_back()); 393aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling 394aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling if (PHINode *PN = dyn_cast<PHINode>(I)) { 395aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling ReplaceLandingPadVal(F, PN, ExnAddr, SelAddr); 396aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling if (PN->use_empty()) PN->eraseFromParent(); 397aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling continue; 398aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling } 399aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling 400fc8713ff74c2ed83d453057b24c578a0709fc180Bill Wendling I->replaceUsesOfWith(Inst, CreateLandingPadLoad(F, ExnAddr, SelAddr, I)); 401aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling } 402aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling} 403aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling 4048b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbachbool SjLjEHPass::insertSjLjEHSupport(Function &F) { 405606f3d696ff78211524fa49c3ca0c4de6db37041Jim Grosbach SmallVector<ReturnInst*,16> Returns; 406606f3d696ff78211524fa49c3ca0c4de6db37041Jim Grosbach SmallVector<UnwindInst*,16> Unwinds; 407606f3d696ff78211524fa49c3ca0c4de6db37041Jim Grosbach SmallVector<InvokeInst*,16> Invokes; 4088b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 4098b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach // Look through the terminators of the basic blocks to find invokes, returns 410b58a59b3c1563ab5bd7225748e32933bf6d76c03Jim Grosbach // and unwinds. 411b58a59b3c1563ab5bd7225748e32933bf6d76c03Jim Grosbach for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) { 4128b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach if (ReturnInst *RI = dyn_cast<ReturnInst>(BB->getTerminator())) { 4138b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach // Remember all return instructions in case we insert an invoke into this 4148b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach // function. 4158b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach Returns.push_back(RI); 4168b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach } else if (InvokeInst *II = dyn_cast<InvokeInst>(BB->getTerminator())) { 4178b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach Invokes.push_back(II); 4188b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach } else if (UnwindInst *UI = dyn_cast<UnwindInst>(BB->getTerminator())) { 4198b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach Unwinds.push_back(UI); 4208b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach } 421b58a59b3c1563ab5bd7225748e32933bf6d76c03Jim Grosbach } 4228d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling 4238d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling NumInvokes += Invokes.size(); 4248d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling NumUnwinds += Unwinds.size(); 4258d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling 4268d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // If we don't have any invokes, there's nothing to do. 4278d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling if (Invokes.empty()) return false; 4288b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 4290798eddd07b8dc827a4e6e9028c4c3a8d9444286Jim Grosbach // Find the eh.selector.*, eh.exception and alloca calls. 4300798eddd07b8dc827a4e6e9028c4c3a8d9444286Jim Grosbach // 4310798eddd07b8dc827a4e6e9028c4c3a8d9444286Jim Grosbach // Remember any allocas() that aren't in the entry block, as the 4320798eddd07b8dc827a4e6e9028c4c3a8d9444286Jim Grosbach // jmpbuf saved SP will need to be updated for them. 4330798eddd07b8dc827a4e6e9028c4c3a8d9444286Jim Grosbach // 4340798eddd07b8dc827a4e6e9028c4c3a8d9444286Jim Grosbach // We'll use the first eh.selector to determine the right personality 4350798eddd07b8dc827a4e6e9028c4c3a8d9444286Jim Grosbach // function to use. For SJLJ, we always use the same personality for the 4360798eddd07b8dc827a4e6e9028c4c3a8d9444286Jim Grosbach // whole function, not on a per-selector basis. 437a235d13217ff14621a88f3ea96a8a3b980c56d02Jim Grosbach // FIXME: That's a bit ugly. Better way? 438a235d13217ff14621a88f3ea96a8a3b980c56d02Jim Grosbach SmallVector<CallInst*,16> EH_Selectors; 439a235d13217ff14621a88f3ea96a8a3b980c56d02Jim Grosbach SmallVector<CallInst*,16> EH_Exceptions; 4400798eddd07b8dc827a4e6e9028c4c3a8d9444286Jim Grosbach SmallVector<Instruction*,16> JmpbufUpdatePoints; 4418d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling 442cfcccef926bd142c885dfa3f506bff933939350cBill Wendling for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) { 443cfcccef926bd142c885dfa3f506bff933939350cBill Wendling // Note: Skip the entry block since there's nothing there that interests 444cfcccef926bd142c885dfa3f506bff933939350cBill Wendling // us. eh.selector and eh.exception shouldn't ever be there, and we 445cfcccef926bd142c885dfa3f506bff933939350cBill Wendling // want to disregard any allocas that are there. 446cfcccef926bd142c885dfa3f506bff933939350cBill Wendling // 447cfcccef926bd142c885dfa3f506bff933939350cBill Wendling // FIXME: This is awkward. The new EH scheme won't need to skip the entry 448cfcccef926bd142c885dfa3f506bff933939350cBill Wendling // block. 449cfcccef926bd142c885dfa3f506bff933939350cBill Wendling if (BB == F.begin()) { 450cfcccef926bd142c885dfa3f506bff933939350cBill Wendling if (InvokeInst *II = dyn_cast<InvokeInst>(F.begin()->getTerminator())) { 451cfcccef926bd142c885dfa3f506bff933939350cBill Wendling // FIXME: This will be always non-NULL in the new EH. 452cfcccef926bd142c885dfa3f506bff933939350cBill Wendling if (LandingPadInst *LPI = II->getUnwindDest()->getLandingPadInst()) 453cfcccef926bd142c885dfa3f506bff933939350cBill Wendling if (!PersonalityFn) PersonalityFn = LPI->getPersonalityFn(); 454cfcccef926bd142c885dfa3f506bff933939350cBill Wendling } 455cfcccef926bd142c885dfa3f506bff933939350cBill Wendling 456cfcccef926bd142c885dfa3f506bff933939350cBill Wendling continue; 457cfcccef926bd142c885dfa3f506bff933939350cBill Wendling } 458cfcccef926bd142c885dfa3f506bff933939350cBill Wendling 459a235d13217ff14621a88f3ea96a8a3b980c56d02Jim Grosbach for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) { 460a235d13217ff14621a88f3ea96a8a3b980c56d02Jim Grosbach if (CallInst *CI = dyn_cast<CallInst>(I)) { 461b01bbdcc1af27bd90b552bb1b62b48916e0d4be3Duncan Sands if (CI->getCalledFunction() == SelectorFn) { 46245c097fe43d565905041d2a9fc77567d2deca709Gabor Greif if (!PersonalityFn) PersonalityFn = CI->getArgOperand(1); 463a235d13217ff14621a88f3ea96a8a3b980c56d02Jim Grosbach EH_Selectors.push_back(CI); 464a235d13217ff14621a88f3ea96a8a3b980c56d02Jim Grosbach } else if (CI->getCalledFunction() == ExceptionFn) { 465a235d13217ff14621a88f3ea96a8a3b980c56d02Jim Grosbach EH_Exceptions.push_back(CI); 4660798eddd07b8dc827a4e6e9028c4c3a8d9444286Jim Grosbach } else if (CI->getCalledFunction() == StackRestoreFn) { 4670798eddd07b8dc827a4e6e9028c4c3a8d9444286Jim Grosbach JmpbufUpdatePoints.push_back(CI); 468a235d13217ff14621a88f3ea96a8a3b980c56d02Jim Grosbach } 4690798eddd07b8dc827a4e6e9028c4c3a8d9444286Jim Grosbach } else if (AllocaInst *AI = dyn_cast<AllocaInst>(I)) { 4700798eddd07b8dc827a4e6e9028c4c3a8d9444286Jim Grosbach JmpbufUpdatePoints.push_back(AI); 471aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling } else if (InvokeInst *II = dyn_cast<InvokeInst>(I)) { 472aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling // FIXME: This will be always non-NULL in the new EH. 473aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling if (LandingPadInst *LPI = II->getUnwindDest()->getLandingPadInst()) 474aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling if (!PersonalityFn) PersonalityFn = LPI->getPersonalityFn(); 475a235d13217ff14621a88f3ea96a8a3b980c56d02Jim Grosbach } 476a235d13217ff14621a88f3ea96a8a3b980c56d02Jim Grosbach } 477a235d13217ff14621a88f3ea96a8a3b980c56d02Jim Grosbach } 4788d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling 479a235d13217ff14621a88f3ea96a8a3b980c56d02Jim Grosbach // If we don't have any eh.selector calls, we can't determine the personality 480a235d13217ff14621a88f3ea96a8a3b980c56d02Jim Grosbach // function. Without a personality function, we can't process exceptions. 481a235d13217ff14621a88f3ea96a8a3b980c56d02Jim Grosbach if (!PersonalityFn) return false; 482a235d13217ff14621a88f3ea96a8a3b980c56d02Jim Grosbach 4838d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // We have invokes, so we need to add register/unregister calls to get this 4848d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // function onto the global unwind stack. 4858d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // 4868d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // First thing we need to do is scan the whole function for values that are 4878d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // live across unwind edges. Each value that is live across an unwind edge we 4888d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // spill into a stack location, guaranteeing that there is nothing live across 4898d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // the unwind edge. This process also splits all critical edges coming out of 4908d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // invoke's. 4918d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling splitLiveRangesAcrossInvokes(Invokes); 4928d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling 493aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling 494aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling SmallVector<LandingPadInst*, 16> LandingPads; 495aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) { 496aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling if (InvokeInst *II = dyn_cast<InvokeInst>(BB->getTerminator())) 497aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling // FIXME: This will be always non-NULL in the new EH. 498aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling if (LandingPadInst *LPI = II->getUnwindDest()->getLandingPadInst()) 499aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling LandingPads.push_back(LPI); 500aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling } 501aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling 502aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling 5038d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling BasicBlock *EntryBB = F.begin(); 5048d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // Create an alloca for the incoming jump buffer ptr and the new jump buffer 5058d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // that needs to be restored on all exits from the function. This is an 5068d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // alloca because the value needs to be added to the global context list. 5078d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling unsigned Align = 4; // FIXME: Should be a TLI check? 5088d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling AllocaInst *FunctionContext = 5098d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling new AllocaInst(FunctionContextTy, 0, Align, 5108d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling "fcn_context", F.begin()->begin()); 5118d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling 5128d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling Value *Idxs[2]; 513db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Int32Ty = Type::getInt32Ty(F.getContext()); 5148d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling Value *Zero = ConstantInt::get(Int32Ty, 0); 5158d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // We need to also keep around a reference to the call_site field 5168d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling Idxs[0] = Zero; 5178d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling Idxs[1] = ConstantInt::get(Int32Ty, 1); 518a9203109f4ac95aa7e9624f2838e3d89623ec902Jay Foad CallSite = GetElementPtrInst::Create(FunctionContext, Idxs, "call_site", 5198d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling EntryBB->getTerminator()); 5208d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling 5218d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // The exception selector comes back in context->data[1] 5228d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling Idxs[1] = ConstantInt::get(Int32Ty, 2); 523a9203109f4ac95aa7e9624f2838e3d89623ec902Jay Foad Value *FCData = GetElementPtrInst::Create(FunctionContext, Idxs, "fc_data", 5248d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling EntryBB->getTerminator()); 5258d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling Idxs[1] = ConstantInt::get(Int32Ty, 1); 526a9203109f4ac95aa7e9624f2838e3d89623ec902Jay Foad Value *SelectorAddr = GetElementPtrInst::Create(FCData, Idxs, 5278d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling "exc_selector_gep", 5288d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling EntryBB->getTerminator()); 5298d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // The exception value comes back in context->data[0] 5308d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling Idxs[1] = Zero; 531a9203109f4ac95aa7e9624f2838e3d89623ec902Jay Foad Value *ExceptionAddr = GetElementPtrInst::Create(FCData, Idxs, 5328d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling "exception_gep", 5338d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling EntryBB->getTerminator()); 5348d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling 5358d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // The result of the eh.selector call will be replaced with a a reference to 5368d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // the selector value returned in the function context. We leave the selector 5378d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // itself so the EH analysis later can use it. 5388d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling for (int i = 0, e = EH_Selectors.size(); i < e; ++i) { 5398d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling CallInst *I = EH_Selectors[i]; 5408d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling Value *SelectorVal = new LoadInst(SelectorAddr, "select_val", true, I); 5418d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling I->replaceAllUsesWith(SelectorVal); 5428d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling } 5438b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 5448d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // eh.exception calls are replaced with references to the proper location in 5458d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // the context. Unlike eh.selector, the eh.exception calls are removed 5468d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // entirely. 5478d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling for (int i = 0, e = EH_Exceptions.size(); i < e; ++i) { 5488d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling CallInst *I = EH_Exceptions[i]; 5498d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // Possible for there to be duplicates, so check to make sure the 5508d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // instruction hasn't already been removed. 5518d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling if (!I->getParent()) continue; 5528d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling Value *Val = new LoadInst(ExceptionAddr, "exception", true, I); 553db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty = Type::getInt8PtrTy(F.getContext()); 5548d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling Val = CastInst::Create(Instruction::IntToPtr, Val, Ty, "", I); 5558d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling 5568d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling I->replaceAllUsesWith(Val); 5578d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling I->eraseFromParent(); 5588d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling } 5598b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 560aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling for (unsigned i = 0, e = LandingPads.size(); i != e; ++i) 561aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling ReplaceLandingPadVal(F, LandingPads[i], ExceptionAddr, SelectorAddr); 562aef508dfc1d844bb3a4f7606f54bf4c616c10effBill Wendling 5638d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // The entry block changes to have the eh.sjlj.setjmp, with a conditional 5648d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // branch to a dispatch block for non-zero returns. If we return normally, 5658d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // we're not handling an exception and just register the function context and 5668d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // continue. 5678d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling 5688d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // Create the dispatch block. The dispatch block is basically a big switch 5698d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // statement that goes to all of the invoke landing pads. 5708d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling BasicBlock *DispatchBlock = 5718d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling BasicBlock::Create(F.getContext(), "eh.sjlj.setjmp.catch", &F); 5728d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling 5738d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // Insert a load of the callsite in the dispatch block, and a switch on its 574cc88595bce813464f4dc0c8351f7311bb233a3e2Bill Wendling // value. By default, we issue a trap statement. 575cc88595bce813464f4dc0c8351f7311bb233a3e2Bill Wendling BasicBlock *TrapBlock = 576cc88595bce813464f4dc0c8351f7311bb233a3e2Bill Wendling BasicBlock::Create(F.getContext(), "trapbb", &F); 577cc88595bce813464f4dc0c8351f7311bb233a3e2Bill Wendling CallInst::Create(Intrinsic::getDeclaration(F.getParent(), Intrinsic::trap), 578cc88595bce813464f4dc0c8351f7311bb233a3e2Bill Wendling "", TrapBlock); 579cc88595bce813464f4dc0c8351f7311bb233a3e2Bill Wendling new UnreachableInst(F.getContext(), TrapBlock); 5808d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling 5818d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling Value *DispatchLoad = new LoadInst(CallSite, "invoke.num", true, 5828d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling DispatchBlock); 5838d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling SwitchInst *DispatchSwitch = 584cc88595bce813464f4dc0c8351f7311bb233a3e2Bill Wendling SwitchInst::Create(DispatchLoad, TrapBlock, Invokes.size(), 585e4ad387a5a88dae20f0f7578e55170bbc8eee2a9Jim Grosbach DispatchBlock); 5868d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // Split the entry block to insert the conditional branch for the setjmp. 5878d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling BasicBlock *ContBlock = EntryBB->splitBasicBlock(EntryBB->getTerminator(), 5888d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling "eh.sjlj.setjmp.cont"); 5898d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling 5908d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // Populate the Function Context 5918d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // 1. LSDA address 5928d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // 2. Personality function address 5938d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // 3. jmpbuf (save SP, FP and call eh.sjlj.setjmp) 5948d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling 5958d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // LSDA address 5968d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling Idxs[0] = Zero; 5978d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling Idxs[1] = ConstantInt::get(Int32Ty, 4); 5988d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling Value *LSDAFieldPtr = 599a9203109f4ac95aa7e9624f2838e3d89623ec902Jay Foad GetElementPtrInst::Create(FunctionContext, Idxs, "lsda_gep", 6008d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling EntryBB->getTerminator()); 6018d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling Value *LSDA = CallInst::Create(LSDAAddrFn, "lsda_addr", 6028d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling EntryBB->getTerminator()); 6038d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling new StoreInst(LSDA, LSDAFieldPtr, true, EntryBB->getTerminator()); 6048d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling 6058d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling Idxs[1] = ConstantInt::get(Int32Ty, 3); 6068d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling Value *PersonalityFieldPtr = 607a9203109f4ac95aa7e9624f2838e3d89623ec902Jay Foad GetElementPtrInst::Create(FunctionContext, Idxs, "lsda_gep", 6088d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling EntryBB->getTerminator()); 6098d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling new StoreInst(PersonalityFn, PersonalityFieldPtr, true, 6108d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling EntryBB->getTerminator()); 6118d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling 6128d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // Save the frame pointer. 6138d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling Idxs[1] = ConstantInt::get(Int32Ty, 5); 6148d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling Value *JBufPtr 615a9203109f4ac95aa7e9624f2838e3d89623ec902Jay Foad = GetElementPtrInst::Create(FunctionContext, Idxs, "jbuf_gep", 6168b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach EntryBB->getTerminator()); 6178d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling Idxs[1] = ConstantInt::get(Int32Ty, 0); 6188d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling Value *FramePtr = 619a9203109f4ac95aa7e9624f2838e3d89623ec902Jay Foad GetElementPtrInst::Create(JBufPtr, Idxs, "jbuf_fp_gep", 6208d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling EntryBB->getTerminator()); 6218d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling 6228d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling Value *Val = CallInst::Create(FrameAddrFn, 6238d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling ConstantInt::get(Int32Ty, 0), 6248d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling "fp", 6258b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach EntryBB->getTerminator()); 6268d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling new StoreInst(Val, FramePtr, true, EntryBB->getTerminator()); 6278d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling 6288d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // Save the stack pointer. 6298d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling Idxs[1] = ConstantInt::get(Int32Ty, 2); 6308d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling Value *StackPtr = 631a9203109f4ac95aa7e9624f2838e3d89623ec902Jay Foad GetElementPtrInst::Create(JBufPtr, Idxs, "jbuf_sp_gep", 6328d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling EntryBB->getTerminator()); 6338d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling 6348d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling Val = CallInst::Create(StackAddrFn, "sp", EntryBB->getTerminator()); 6358d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling new StoreInst(Val, StackPtr, true, EntryBB->getTerminator()); 6368d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling 6378d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // Call the setjmp instrinsic. It fills in the rest of the jmpbuf. 6388d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling Value *SetjmpArg = 6398d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling CastInst::Create(Instruction::BitCast, JBufPtr, 6408d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling Type::getInt8PtrTy(F.getContext()), "", 6418d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling EntryBB->getTerminator()); 6428d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling Value *DispatchVal = CallInst::Create(BuiltinSetjmpFn, SetjmpArg, 643da7e6a9c8888fe9c4198214cc19f6f55e21e72e4Bill Wendling "", 6448d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling EntryBB->getTerminator()); 645f05b1dcf870346094f8aaee8e387c92d3e47e98dBill Wendling 646f05b1dcf870346094f8aaee8e387c92d3e47e98dBill Wendling // Add a call to dispatch_setup after the setjmp call. This is expanded to any 647f05b1dcf870346094f8aaee8e387c92d3e47e98dBill Wendling // target-specific setup that needs to be done. 64861512ba251097888963a8f07a35605564bcfc537Bill Wendling CallInst::Create(DispatchSetupFn, DispatchVal, "", EntryBB->getTerminator()); 649f05b1dcf870346094f8aaee8e387c92d3e47e98dBill Wendling 6508d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // check the return value of the setjmp. non-zero goes to dispatcher. 6518d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling Value *IsNormal = new ICmpInst(EntryBB->getTerminator(), 6528d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling ICmpInst::ICMP_EQ, DispatchVal, Zero, 6538d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling "notunwind"); 6548d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // Nuke the uncond branch. 6558d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling EntryBB->getTerminator()->eraseFromParent(); 6568d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling 6578d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // Put in a new condbranch in its place. 6588d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling BranchInst::Create(ContBlock, DispatchBlock, IsNormal, EntryBB); 6598d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling 6608d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // Register the function context and make sure it's known to not throw 6618d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling CallInst *Register = 6628d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling CallInst::Create(RegisterFn, FunctionContext, "", 6638d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling ContBlock->getTerminator()); 6648d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling Register->setDoesNotThrow(); 6658d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling 6668d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // At this point, we are all set up, update the invoke instructions to mark 6678d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // their call_site values, and fill in the dispatch switch accordingly. 6688d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling for (unsigned i = 0, e = Invokes.size(); i != e; ++i) 6698d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling markInvokeCallSite(Invokes[i], i+1, CallSite, DispatchSwitch); 6708d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling 6718d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // Mark call instructions that aren't nounwind as no-action (call_site == 6728d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // -1). Skip the entry block, as prior to then, no function context has been 6738d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // created for this function and any unexpected exceptions thrown will go 6748d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // directly to the caller's context, which is what we want anyway, so no need 6758d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // to do anything here. 6768d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling for (Function::iterator BB = F.begin(), E = F.end(); ++BB != E;) { 6778d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling for (BasicBlock::iterator I = BB->begin(), end = BB->end(); I != end; ++I) 6788d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling if (CallInst *CI = dyn_cast<CallInst>(I)) { 6798d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // Ignore calls to the EH builtins (eh.selector, eh.exception) 6808d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling Constant *Callee = CI->getCalledFunction(); 6818d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling if (Callee != SelectorFn && Callee != ExceptionFn 6828d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling && !CI->doesNotThrow()) 6838d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling insertCallSiteStore(CI, -1, CallSite); 6843ae96d69ef0695460eb3d046427d22dcda10d9f0Bill Wendling } else if (ResumeInst *RI = dyn_cast<ResumeInst>(I)) { 6853ae96d69ef0695460eb3d046427d22dcda10d9f0Bill Wendling insertCallSiteStore(RI, -1, CallSite); 6868d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling } 6878d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling } 6888b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 6898d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // Replace all unwinds with a branch to the unwind handler. 6908d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // ??? Should this ever happen with sjlj exceptions? 6918d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling for (unsigned i = 0, e = Unwinds.size(); i != e; ++i) { 692cc88595bce813464f4dc0c8351f7311bb233a3e2Bill Wendling BranchInst::Create(TrapBlock, Unwinds[i]); 6938d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling Unwinds[i]->eraseFromParent(); 6948d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling } 6950798eddd07b8dc827a4e6e9028c4c3a8d9444286Jim Grosbach 6968d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // Following any allocas not in the entry block, update the saved SP in the 6978d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // jmpbuf to the new value. 6988d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling for (unsigned i = 0, e = JmpbufUpdatePoints.size(); i != e; ++i) { 6998d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling Instruction *AI = JmpbufUpdatePoints[i]; 7008d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling Instruction *StackAddr = CallInst::Create(StackAddrFn, "sp"); 7018d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling StackAddr->insertAfter(AI); 7028d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling Instruction *StoreStackAddr = new StoreInst(StackAddr, StackPtr, true); 7038d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling StoreStackAddr->insertAfter(StackAddr); 7048b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach } 7058b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 7068d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // Finally, for any returns from this function, if this function contains an 7078d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling // invoke, add a call to unregister the function context. 7088d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling for (unsigned i = 0, e = Returns.size(); i != e; ++i) 7098d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling CallInst::Create(UnregisterFn, FunctionContext, "", Returns[i]); 7108d90b7190f9411e0e48d8a29705240f7679ae201Bill Wendling 7118b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach return true; 7128b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach} 7138b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 7142b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling/// setupFunctionContext - Allocate the function context on the stack and fill 7152b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling/// it with all of the data that we know at this point. 716631d11765b9f7ebdb49679c92bd41083fbab3f62Bill WendlingValue *SjLjEHPass:: 717cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill WendlingsetupFunctionContext(Function &F, ArrayRef<LandingPadInst*> LPads) { 7182b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling BasicBlock *EntryBB = F.begin(); 7192b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 7202b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling // Create an alloca for the incoming jump buffer ptr and the new jump buffer 7212b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling // that needs to be restored on all exits from the function. This is an alloca 7222b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling // because the value needs to be added to the global context list. 7232b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling unsigned Align = 7242b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling TLI->getTargetData()->getPrefTypeAlignment(FunctionContextTy); 7252b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling AllocaInst *FuncCtx = 7262b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling new AllocaInst(FunctionContextTy, 0, Align, "fn_context", EntryBB->begin()); 7272b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 7282b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling // Fill in the function context structure. 7292b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling Value *Idxs[2]; 7302b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling Type *Int32Ty = Type::getInt32Ty(F.getContext()); 7312b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling Value *Zero = ConstantInt::get(Int32Ty, 0); 7322b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling Value *One = ConstantInt::get(Int32Ty, 1); 7332b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 7342b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling // Keep around a reference to the call_site field. 7352b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling Idxs[0] = Zero; 7362b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling Idxs[1] = One; 7372b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling CallSite = GetElementPtrInst::Create(FuncCtx, Idxs, "call_site", 7382b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling EntryBB->getTerminator()); 7392b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 7402b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling // Reference the __data field. 7412b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling Idxs[1] = ConstantInt::get(Int32Ty, 2); 7422b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling Value *FCData = GetElementPtrInst::Create(FuncCtx, Idxs, "__data", 7432b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling EntryBB->getTerminator()); 7442b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 7452b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling // The exception value comes back in context->__data[0]. 7462b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling Idxs[1] = Zero; 7472b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling Value *ExceptionAddr = GetElementPtrInst::Create(FCData, Idxs, 7482b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling "exception_gep", 7492b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling EntryBB->getTerminator()); 7502b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 7512b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling // The exception selector comes back in context->__data[1]. 7522b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling Idxs[1] = One; 7532b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling Value *SelectorAddr = GetElementPtrInst::Create(FCData, Idxs, 7542b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling "exn_selector_gep", 7552b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling EntryBB->getTerminator()); 7562b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 7572b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling for (unsigned I = 0, E = LPads.size(); I != E; ++I) { 7582b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling LandingPadInst *LPI = LPads[I]; 7592b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling IRBuilder<> Builder(LPI->getParent()->getFirstInsertionPt()); 7602b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 7612b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling Value *ExnVal = Builder.CreateLoad(ExceptionAddr, true, "exn_val"); 7622b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling ExnVal = Builder.CreateIntToPtr(ExnVal, Type::getInt8PtrTy(F.getContext())); 7632b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling Value *SelVal = Builder.CreateLoad(SelectorAddr, true, "exn_selector_val"); 7642b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 7652b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling Type *LPadType = LPI->getType(); 7662b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling Value *LPadVal = UndefValue::get(LPadType); 7672b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling LPadVal = Builder.CreateInsertValue(LPadVal, ExnVal, 0, "lpad.val"); 7682b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling LPadVal = Builder.CreateInsertValue(LPadVal, SelVal, 1, "lpad.val"); 7692b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 7702b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling LPI->replaceAllUsesWith(LPadVal); 7712b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling } 7722b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 7732b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling // Personality function 7742b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling Idxs[1] = ConstantInt::get(Int32Ty, 3); 7752b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling if (!PersonalityFn) 7762b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling PersonalityFn = LPads[0]->getPersonalityFn(); 7772b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling Value *PersonalityFieldPtr = 7782b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling GetElementPtrInst::Create(FuncCtx, Idxs, "pers_fn_gep", 7792b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling EntryBB->getTerminator()); 7802b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling new StoreInst(PersonalityFn, PersonalityFieldPtr, true, 7812b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling EntryBB->getTerminator()); 7822b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 7832b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling // LSDA address 7842b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling Idxs[1] = ConstantInt::get(Int32Ty, 4); 785da7e6a9c8888fe9c4198214cc19f6f55e21e72e4Bill Wendling Value *LSDAFieldPtr = GetElementPtrInst::Create(FuncCtx, Idxs, "lsda_gep", 786da7e6a9c8888fe9c4198214cc19f6f55e21e72e4Bill Wendling EntryBB->getTerminator()); 7872b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling Value *LSDA = CallInst::Create(LSDAAddrFn, "lsda_addr", 7882b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling EntryBB->getTerminator()); 7892b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling new StoreInst(LSDA, LSDAFieldPtr, true, EntryBB->getTerminator()); 7902b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 791631d11765b9f7ebdb49679c92bd41083fbab3f62Bill Wendling return FuncCtx; 7922b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling} 7932b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 794d5d170097241534401bbbebb4be59451d5c312caBill Wendling/// lowerIncomingArguments - To avoid having to handle incoming arguments 795d5d170097241534401bbbebb4be59451d5c312caBill Wendling/// specially, we lower each arg to a copy instruction in the entry block. This 796d5d170097241534401bbbebb4be59451d5c312caBill Wendling/// ensures that the argument value itself cannot be live out of the entry 797d5d170097241534401bbbebb4be59451d5c312caBill Wendling/// block. 798d5d170097241534401bbbebb4be59451d5c312caBill Wendlingvoid SjLjEHPass::lowerIncomingArguments(Function &F) { 799d5d170097241534401bbbebb4be59451d5c312caBill Wendling BasicBlock::iterator AfterAllocaInsPt = F.begin()->begin(); 800d5d170097241534401bbbebb4be59451d5c312caBill Wendling while (isa<AllocaInst>(AfterAllocaInsPt) && 801d5d170097241534401bbbebb4be59451d5c312caBill Wendling isa<ConstantInt>(cast<AllocaInst>(AfterAllocaInsPt)->getArraySize())) 802d5d170097241534401bbbebb4be59451d5c312caBill Wendling ++AfterAllocaInsPt; 803d5d170097241534401bbbebb4be59451d5c312caBill Wendling 804d5d170097241534401bbbebb4be59451d5c312caBill Wendling for (Function::arg_iterator 805d5d170097241534401bbbebb4be59451d5c312caBill Wendling AI = F.arg_begin(), AE = F.arg_end(); AI != AE; ++AI) { 806d5d170097241534401bbbebb4be59451d5c312caBill Wendling Type *Ty = AI->getType(); 807d5d170097241534401bbbebb4be59451d5c312caBill Wendling 808d5d170097241534401bbbebb4be59451d5c312caBill Wendling // Aggregate types can't be cast, but are legal argument types, so we have 809d5d170097241534401bbbebb4be59451d5c312caBill Wendling // to handle them differently. We use an extract/insert pair as a 810d5d170097241534401bbbebb4be59451d5c312caBill Wendling // lightweight method to achieve the same goal. 811d5d170097241534401bbbebb4be59451d5c312caBill Wendling if (isa<StructType>(Ty) || isa<ArrayType>(Ty) || isa<VectorType>(Ty)) { 812d5d170097241534401bbbebb4be59451d5c312caBill Wendling Instruction *EI = ExtractValueInst::Create(AI, 0, "", AfterAllocaInsPt); 813d5d170097241534401bbbebb4be59451d5c312caBill Wendling Instruction *NI = InsertValueInst::Create(AI, EI, 0); 814d5d170097241534401bbbebb4be59451d5c312caBill Wendling NI->insertAfter(EI); 815d5d170097241534401bbbebb4be59451d5c312caBill Wendling AI->replaceAllUsesWith(NI); 816d5d170097241534401bbbebb4be59451d5c312caBill Wendling 817d5d170097241534401bbbebb4be59451d5c312caBill Wendling // Set the operand of the instructions back to the AllocaInst. 818d5d170097241534401bbbebb4be59451d5c312caBill Wendling EI->setOperand(0, AI); 819d5d170097241534401bbbebb4be59451d5c312caBill Wendling NI->setOperand(0, AI); 820d5d170097241534401bbbebb4be59451d5c312caBill Wendling } else { 821d5d170097241534401bbbebb4be59451d5c312caBill Wendling // This is always a no-op cast because we're casting AI to AI->getType() 822d5d170097241534401bbbebb4be59451d5c312caBill Wendling // so src and destination types are identical. BitCast is the only 823d5d170097241534401bbbebb4be59451d5c312caBill Wendling // possibility. 824d5d170097241534401bbbebb4be59451d5c312caBill Wendling CastInst *NC = 825d5d170097241534401bbbebb4be59451d5c312caBill Wendling new BitCastInst(AI, AI->getType(), AI->getName() + ".tmp", 826d5d170097241534401bbbebb4be59451d5c312caBill Wendling AfterAllocaInsPt); 827d5d170097241534401bbbebb4be59451d5c312caBill Wendling AI->replaceAllUsesWith(NC); 828d5d170097241534401bbbebb4be59451d5c312caBill Wendling 829d5d170097241534401bbbebb4be59451d5c312caBill Wendling // Set the operand of the cast instruction back to the AllocaInst. 830d5d170097241534401bbbebb4be59451d5c312caBill Wendling // Normally it's forbidden to replace a CastInst's operand because it 831d5d170097241534401bbbebb4be59451d5c312caBill Wendling // could cause the opcode to reflect an illegal conversion. However, we're 832d5d170097241534401bbbebb4be59451d5c312caBill Wendling // replacing it here with the same value it was constructed with. We do 833d5d170097241534401bbbebb4be59451d5c312caBill Wendling // this because the above replaceAllUsesWith() clobbered the operand, but 834d5d170097241534401bbbebb4be59451d5c312caBill Wendling // we want this one to remain. 835d5d170097241534401bbbebb4be59451d5c312caBill Wendling NC->setOperand(0, AI); 836d5d170097241534401bbbebb4be59451d5c312caBill Wendling } 837d5d170097241534401bbbebb4be59451d5c312caBill Wendling } 838d5d170097241534401bbbebb4be59451d5c312caBill Wendling} 839d5d170097241534401bbbebb4be59451d5c312caBill Wendling 840d5d170097241534401bbbebb4be59451d5c312caBill Wendling/// lowerAcrossUnwindEdges - Find all variables which are alive across an unwind 841d5d170097241534401bbbebb4be59451d5c312caBill Wendling/// edge and spill them. 842d5d170097241534401bbbebb4be59451d5c312caBill Wendlingvoid SjLjEHPass::lowerAcrossUnwindEdges(Function &F, 843d5d170097241534401bbbebb4be59451d5c312caBill Wendling ArrayRef<InvokeInst*> Invokes) { 844d5d170097241534401bbbebb4be59451d5c312caBill Wendling // Finally, scan the code looking for instructions with bad live ranges. 845d5d170097241534401bbbebb4be59451d5c312caBill Wendling for (Function::iterator 846d5d170097241534401bbbebb4be59451d5c312caBill Wendling BB = F.begin(), BBE = F.end(); BB != BBE; ++BB) { 847d5d170097241534401bbbebb4be59451d5c312caBill Wendling for (BasicBlock::iterator 848d5d170097241534401bbbebb4be59451d5c312caBill Wendling II = BB->begin(), IIE = BB->end(); II != IIE; ++II) { 849d5d170097241534401bbbebb4be59451d5c312caBill Wendling // Ignore obvious cases we don't have to handle. In particular, most 850d5d170097241534401bbbebb4be59451d5c312caBill Wendling // instructions either have no uses or only have a single use inside the 851d5d170097241534401bbbebb4be59451d5c312caBill Wendling // current block. Ignore them quickly. 852d5d170097241534401bbbebb4be59451d5c312caBill Wendling Instruction *Inst = II; 853d5d170097241534401bbbebb4be59451d5c312caBill Wendling if (Inst->use_empty()) continue; 854d5d170097241534401bbbebb4be59451d5c312caBill Wendling if (Inst->hasOneUse() && 855d5d170097241534401bbbebb4be59451d5c312caBill Wendling cast<Instruction>(Inst->use_back())->getParent() == BB && 856d5d170097241534401bbbebb4be59451d5c312caBill Wendling !isa<PHINode>(Inst->use_back())) continue; 857d5d170097241534401bbbebb4be59451d5c312caBill Wendling 858d5d170097241534401bbbebb4be59451d5c312caBill Wendling // If this is an alloca in the entry block, it's not a real register 859d5d170097241534401bbbebb4be59451d5c312caBill Wendling // value. 860d5d170097241534401bbbebb4be59451d5c312caBill Wendling if (AllocaInst *AI = dyn_cast<AllocaInst>(Inst)) 861d5d170097241534401bbbebb4be59451d5c312caBill Wendling if (isa<ConstantInt>(AI->getArraySize()) && BB == F.begin()) 862d5d170097241534401bbbebb4be59451d5c312caBill Wendling continue; 863d5d170097241534401bbbebb4be59451d5c312caBill Wendling 864d5d170097241534401bbbebb4be59451d5c312caBill Wendling // Avoid iterator invalidation by copying users to a temporary vector. 865d5d170097241534401bbbebb4be59451d5c312caBill Wendling SmallVector<Instruction*, 16> Users; 866d5d170097241534401bbbebb4be59451d5c312caBill Wendling for (Value::use_iterator 867d5d170097241534401bbbebb4be59451d5c312caBill Wendling UI = Inst->use_begin(), E = Inst->use_end(); UI != E; ++UI) { 868d5d170097241534401bbbebb4be59451d5c312caBill Wendling Instruction *User = cast<Instruction>(*UI); 869d5d170097241534401bbbebb4be59451d5c312caBill Wendling if (User->getParent() != BB || isa<PHINode>(User)) 870d5d170097241534401bbbebb4be59451d5c312caBill Wendling Users.push_back(User); 871d5d170097241534401bbbebb4be59451d5c312caBill Wendling } 872d5d170097241534401bbbebb4be59451d5c312caBill Wendling 873d5d170097241534401bbbebb4be59451d5c312caBill Wendling // Find all of the blocks that this value is live in. 874d5d170097241534401bbbebb4be59451d5c312caBill Wendling std::set<BasicBlock*> LiveBBs; 875d5d170097241534401bbbebb4be59451d5c312caBill Wendling LiveBBs.insert(Inst->getParent()); 876d5d170097241534401bbbebb4be59451d5c312caBill Wendling while (!Users.empty()) { 877d5d170097241534401bbbebb4be59451d5c312caBill Wendling Instruction *U = Users.back(); 878d5d170097241534401bbbebb4be59451d5c312caBill Wendling Users.pop_back(); 879d5d170097241534401bbbebb4be59451d5c312caBill Wendling 880d5d170097241534401bbbebb4be59451d5c312caBill Wendling if (!isa<PHINode>(U)) { 881d5d170097241534401bbbebb4be59451d5c312caBill Wendling MarkBlocksLiveIn(U->getParent(), LiveBBs); 882d5d170097241534401bbbebb4be59451d5c312caBill Wendling } else { 883d5d170097241534401bbbebb4be59451d5c312caBill Wendling // Uses for a PHI node occur in their predecessor block. 884d5d170097241534401bbbebb4be59451d5c312caBill Wendling PHINode *PN = cast<PHINode>(U); 885d5d170097241534401bbbebb4be59451d5c312caBill Wendling for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) 886d5d170097241534401bbbebb4be59451d5c312caBill Wendling if (PN->getIncomingValue(i) == Inst) 887d5d170097241534401bbbebb4be59451d5c312caBill Wendling MarkBlocksLiveIn(PN->getIncomingBlock(i), LiveBBs); 888d5d170097241534401bbbebb4be59451d5c312caBill Wendling } 889d5d170097241534401bbbebb4be59451d5c312caBill Wendling } 890d5d170097241534401bbbebb4be59451d5c312caBill Wendling 891d5d170097241534401bbbebb4be59451d5c312caBill Wendling // Now that we know all of the blocks that this thing is live in, see if 892d5d170097241534401bbbebb4be59451d5c312caBill Wendling // it includes any of the unwind locations. 893d5d170097241534401bbbebb4be59451d5c312caBill Wendling bool NeedsSpill = false; 894d5d170097241534401bbbebb4be59451d5c312caBill Wendling for (unsigned i = 0, e = Invokes.size(); i != e; ++i) { 895d5d170097241534401bbbebb4be59451d5c312caBill Wendling BasicBlock *UnwindBlock = Invokes[i]->getUnwindDest(); 896d5d170097241534401bbbebb4be59451d5c312caBill Wendling if (UnwindBlock != BB && LiveBBs.count(UnwindBlock)) { 897d5d170097241534401bbbebb4be59451d5c312caBill Wendling NeedsSpill = true; 898d5d170097241534401bbbebb4be59451d5c312caBill Wendling } 899d5d170097241534401bbbebb4be59451d5c312caBill Wendling } 900d5d170097241534401bbbebb4be59451d5c312caBill Wendling 901d5d170097241534401bbbebb4be59451d5c312caBill Wendling // If we decided we need a spill, do it. 902d5d170097241534401bbbebb4be59451d5c312caBill Wendling // FIXME: Spilling this way is overkill, as it forces all uses of 903d5d170097241534401bbbebb4be59451d5c312caBill Wendling // the value to be reloaded from the stack slot, even those that aren't 904d5d170097241534401bbbebb4be59451d5c312caBill Wendling // in the unwind blocks. We should be more selective. 905d5d170097241534401bbbebb4be59451d5c312caBill Wendling if (NeedsSpill) { 906d5d170097241534401bbbebb4be59451d5c312caBill Wendling ++NumSpilled; 907d5d170097241534401bbbebb4be59451d5c312caBill Wendling DemoteRegToStack(*Inst, true); 908d5d170097241534401bbbebb4be59451d5c312caBill Wendling } 909d5d170097241534401bbbebb4be59451d5c312caBill Wendling } 910d5d170097241534401bbbebb4be59451d5c312caBill Wendling } 911d5d170097241534401bbbebb4be59451d5c312caBill Wendling} 912d5d170097241534401bbbebb4be59451d5c312caBill Wendling 9132b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling/// setupEntryBlockAndCallSites - Setup the entry block by creating and filling 9142b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling/// the function context and marking the call sites with the appropriate 9152b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling/// values. These values are used by the DWARF EH emitter. 9162b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendlingbool SjLjEHPass::setupEntryBlockAndCallSites(Function &F) { 917cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling SmallVector<ReturnInst*, 16> Returns; 9182b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling SmallVector<InvokeInst*, 16> Invokes; 9192b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling SmallVector<LandingPadInst*, 16> LPads; 9202b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 9212b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling // Look through the terminators of the basic blocks to find invokes. 9222b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) 9232b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling if (InvokeInst *II = dyn_cast<InvokeInst>(BB->getTerminator())) { 9242b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling Invokes.push_back(II); 9252b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling LPads.push_back(II->getUnwindDest()->getLandingPadInst()); 926cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling } else if (ReturnInst *RI = dyn_cast<ReturnInst>(BB->getTerminator())) { 927cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling Returns.push_back(RI); 9282b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling } 9292b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 9302b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling if (Invokes.empty()) return false; 9312b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 932d5d170097241534401bbbebb4be59451d5c312caBill Wendling lowerIncomingArguments(F); 933d5d170097241534401bbbebb4be59451d5c312caBill Wendling lowerAcrossUnwindEdges(F, Invokes); 934d5d170097241534401bbbebb4be59451d5c312caBill Wendling 935631d11765b9f7ebdb49679c92bd41083fbab3f62Bill Wendling Value *FuncCtx = setupFunctionContext(F, LPads); 936cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling BasicBlock *EntryBB = F.begin(); 937cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling Type *Int32Ty = Type::getInt32Ty(F.getContext()); 938631d11765b9f7ebdb49679c92bd41083fbab3f62Bill Wendling 939cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling Value *Idxs[2] = { 940631d11765b9f7ebdb49679c92bd41083fbab3f62Bill Wendling ConstantInt::get(Int32Ty, 0), 0 941cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling }; 942631d11765b9f7ebdb49679c92bd41083fbab3f62Bill Wendling 943631d11765b9f7ebdb49679c92bd41083fbab3f62Bill Wendling // Get a reference to the jump buffer. 944631d11765b9f7ebdb49679c92bd41083fbab3f62Bill Wendling Idxs[1] = ConstantInt::get(Int32Ty, 5); 945da7e6a9c8888fe9c4198214cc19f6f55e21e72e4Bill Wendling Value *JBufPtr = GetElementPtrInst::Create(FuncCtx, Idxs, "jbuf_gep", 946da7e6a9c8888fe9c4198214cc19f6f55e21e72e4Bill Wendling EntryBB->getTerminator()); 947631d11765b9f7ebdb49679c92bd41083fbab3f62Bill Wendling 948631d11765b9f7ebdb49679c92bd41083fbab3f62Bill Wendling // Save the frame pointer. 949631d11765b9f7ebdb49679c92bd41083fbab3f62Bill Wendling Idxs[1] = ConstantInt::get(Int32Ty, 0); 950da7e6a9c8888fe9c4198214cc19f6f55e21e72e4Bill Wendling Value *FramePtr = GetElementPtrInst::Create(JBufPtr, Idxs, "jbuf_fp_gep", 951da7e6a9c8888fe9c4198214cc19f6f55e21e72e4Bill Wendling EntryBB->getTerminator()); 952631d11765b9f7ebdb49679c92bd41083fbab3f62Bill Wendling 953631d11765b9f7ebdb49679c92bd41083fbab3f62Bill Wendling Value *Val = CallInst::Create(FrameAddrFn, 954631d11765b9f7ebdb49679c92bd41083fbab3f62Bill Wendling ConstantInt::get(Int32Ty, 0), 955631d11765b9f7ebdb49679c92bd41083fbab3f62Bill Wendling "fp", 956631d11765b9f7ebdb49679c92bd41083fbab3f62Bill Wendling EntryBB->getTerminator()); 957631d11765b9f7ebdb49679c92bd41083fbab3f62Bill Wendling new StoreInst(Val, FramePtr, true, EntryBB->getTerminator()); 958631d11765b9f7ebdb49679c92bd41083fbab3f62Bill Wendling 959631d11765b9f7ebdb49679c92bd41083fbab3f62Bill Wendling // Save the stack pointer. 960631d11765b9f7ebdb49679c92bd41083fbab3f62Bill Wendling Idxs[1] = ConstantInt::get(Int32Ty, 2); 961da7e6a9c8888fe9c4198214cc19f6f55e21e72e4Bill Wendling Value *StackPtr = GetElementPtrInst::Create(JBufPtr, Idxs, "jbuf_sp_gep", 962da7e6a9c8888fe9c4198214cc19f6f55e21e72e4Bill Wendling EntryBB->getTerminator()); 963cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling 964631d11765b9f7ebdb49679c92bd41083fbab3f62Bill Wendling Val = CallInst::Create(StackAddrFn, "sp", EntryBB->getTerminator()); 965cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling new StoreInst(Val, StackPtr, true, EntryBB->getTerminator()); 966cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling 967cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling // Call the setjmp instrinsic. It fills in the rest of the jmpbuf. 968da7e6a9c8888fe9c4198214cc19f6f55e21e72e4Bill Wendling Value *SetjmpArg = CastInst::Create(Instruction::BitCast, JBufPtr, 969da7e6a9c8888fe9c4198214cc19f6f55e21e72e4Bill Wendling Type::getInt8PtrTy(F.getContext()), "", 970da7e6a9c8888fe9c4198214cc19f6f55e21e72e4Bill Wendling EntryBB->getTerminator()); 971f8520d564c095e3ee278090b605c4b827604c817Bill Wendling CallInst::Create(BuiltinSetjmpFn, SetjmpArg, "", EntryBB->getTerminator()); 972cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling 973cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling // Store a pointer to the function context so that the back-end will know 974cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling // where to look for it. 975da7e6a9c8888fe9c4198214cc19f6f55e21e72e4Bill Wendling Value *FuncCtxArg = CastInst::Create(Instruction::BitCast, FuncCtx, 976da7e6a9c8888fe9c4198214cc19f6f55e21e72e4Bill Wendling Type::getInt8PtrTy(F.getContext()), "", 977da7e6a9c8888fe9c4198214cc19f6f55e21e72e4Bill Wendling EntryBB->getTerminator()); 978cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling CallInst::Create(FuncCtxFn, FuncCtxArg, "", EntryBB->getTerminator()); 9792b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 9802b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling // At this point, we are all set up, update the invoke instructions to mark 9812130ab0131ca0c0f5607937fe1f6ed48c28d39a2Bill Wendling // their call_site values. 9822b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling for (unsigned I = 0, E = Invokes.size(); I != E; ++I) { 9832b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling insertCallSiteStore(Invokes[I], I + 1, CallSite); 9842b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 9852b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling ConstantInt *CallSiteNum = 9862b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling ConstantInt::get(Type::getInt32Ty(F.getContext()), I + 1); 9872b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 9882b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling // Record the call site value for the back end so it stays associated with 9892b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling // the invoke. 9902b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling CallInst::Create(CallSiteFn, CallSiteNum, "", Invokes[I]); 9912b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling } 9922b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 9932b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling // Mark call instructions that aren't nounwind as no-action (call_site == 9942b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling // -1). Skip the entry block, as prior to then, no function context has been 9952b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling // created for this function and any unexpected exceptions thrown will go 9962b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling // directly to the caller's context, which is what we want anyway, so no need 9972b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling // to do anything here. 998da7e6a9c8888fe9c4198214cc19f6f55e21e72e4Bill Wendling for (Function::iterator BB = F.begin(), E = F.end(); ++BB != E;) 9992b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling for (BasicBlock::iterator I = BB->begin(), end = BB->end(); I != end; ++I) 10002b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling if (CallInst *CI = dyn_cast<CallInst>(I)) { 10012b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling if (!CI->doesNotThrow()) 10022b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling insertCallSiteStore(CI, -1, CallSite); 10032b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling } else if (ResumeInst *RI = dyn_cast<ResumeInst>(I)) { 10042b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling insertCallSiteStore(RI, -1, CallSite); 10052b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling } 10062b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 1007cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling // Register the function context and make sure it's known to not throw 1008631d11765b9f7ebdb49679c92bd41083fbab3f62Bill Wendling CallInst *Register = CallInst::Create(RegisterFn, FuncCtx, "", 1009cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling EntryBB->getTerminator()); 1010cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling Register->setDoesNotThrow(); 1011cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling 1012cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling // Finally, for any returns from this function, if this function contains an 1013cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling // invoke, add a call to unregister the function context. 1014cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling for (unsigned I = 0, E = Returns.size(); I != E; ++I) 1015631d11765b9f7ebdb49679c92bd41083fbab3f62Bill Wendling CallInst::Create(UnregisterFn, FuncCtx, "", Returns[I]); 1016cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling 10172b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling return true; 10182b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling} 10192b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 10208b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbachbool SjLjEHPass::runOnFunction(Function &F) { 10212b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling bool Res = false; 10222b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling if (!DisableOldSjLjEH) 10232b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling Res = insertSjLjEHSupport(F); 10242b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling else 10252b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling Res = setupEntryBlockAndCallSites(F); 10268b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach return Res; 10278b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach} 1028