1eabae1d07bffac60d9f4f2473cf6736d6a1c372dBill Wendling//===- SjLjEHPrepare.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 15d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/CodeGen/Passes.h" 16d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/DenseMap.h" 17d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/SetVector.h" 18d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/SmallPtrSet.h" 19d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/SmallVector.h" 20d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/Statistic.h" 210b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Constants.h" 220b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/DataLayout.h" 230b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/DerivedTypes.h" 240b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/IRBuilder.h" 250b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Instructions.h" 260b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Intrinsics.h" 270b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/LLVMContext.h" 280b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Module.h" 298b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach#include "llvm/Pass.h" 3006cb8ed00696eb14d1b831921452e50ec0568ea2Chandler Carruth#include "llvm/Support/CommandLine.h" 3106cb8ed00696eb14d1b831921452e50ec0568ea2Chandler Carruth#include "llvm/Support/Debug.h" 3206cb8ed00696eb14d1b831921452e50ec0568ea2Chandler Carruth#include "llvm/Support/raw_ostream.h" 3306cb8ed00696eb14d1b831921452e50ec0568ea2Chandler Carruth#include "llvm/Target/TargetLowering.h" 3406cb8ed00696eb14d1b831921452e50ec0568ea2Chandler Carruth#include "llvm/Transforms/Scalar.h" 3506cb8ed00696eb14d1b831921452e50ec0568ea2Chandler Carruth#include "llvm/Transforms/Utils/BasicBlockUtils.h" 3606cb8ed00696eb14d1b831921452e50ec0568ea2Chandler Carruth#include "llvm/Transforms/Utils/Local.h" 37f788854d20b12c60fd8b43c587adb3227b6b1bffBenjamin Kramer#include <set> 388b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbachusing namespace llvm; 398b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 40dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines#define DEBUG_TYPE "sjljehprepare" 41dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 428b818d7e98309125c6058c4ea72a7dc73b031db2Jim GrosbachSTATISTIC(NumInvokes, "Number of invokes replaced"); 438b818d7e98309125c6058c4ea72a7dc73b031db2Jim GrosbachSTATISTIC(NumSpilled, "Number of registers live across unwind edges"); 448b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 458b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbachnamespace { 4654e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendlingclass SjLjEHPrepare : public FunctionPass { 4754e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling const TargetMachine *TM; 4854e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling Type *FunctionContextTy; 4954e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling Constant *RegisterFn; 5054e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling Constant *UnregisterFn; 5154e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling Constant *BuiltinSetjmpFn; 5254e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling Constant *FrameAddrFn; 5354e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling Constant *StackAddrFn; 5454e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling Constant *StackRestoreFn; 5554e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling Constant *LSDAAddrFn; 5654e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling Value *PersonalityFn; 5754e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling Constant *CallSiteFn; 5854e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling Constant *FuncCtxFn; 5954e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling AllocaInst *FuncCtx; 6054e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling 6154e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendlingpublic: 6254e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling static char ID; // Pass identification, replacement for typeid 6354e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling explicit SjLjEHPrepare(const TargetMachine *TM) : FunctionPass(ID), TM(TM) {} 6436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool doInitialization(Module &M) override; 6536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool runOnFunction(Function &F) override; 6654e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling 6736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines void getAnalysisUsage(AnalysisUsage &AU) const override {} 6836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const char *getPassName() const override { 6954e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling return "SJLJ Exception Handling preparation"; 7054e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling } 718b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 7254e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendlingprivate: 7354e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling bool setupEntryBlockAndCallSites(Function &F); 7454e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling void substituteLPadValues(LandingPadInst *LPI, Value *ExnVal, Value *SelVal); 7554e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling Value *setupFunctionContext(Function &F, ArrayRef<LandingPadInst *> LPads); 7654e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling void lowerIncomingArguments(Function &F); 7754e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling void lowerAcrossUnwindEdges(Function &F, ArrayRef<InvokeInst *> Invokes); 7854e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling void insertCallSiteStore(Instruction *I, int Number); 7954e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling}; 808b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach} // end anonymous namespace 818b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 82eabae1d07bffac60d9f4f2473cf6736d6a1c372dBill Wendlingchar SjLjEHPrepare::ID = 0; 838b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 84eabae1d07bffac60d9f4f2473cf6736d6a1c372dBill Wendling// Public Interface To the SjLjEHPrepare pass. 85ea44281d5da5096de50ce1cb358ff0c6f20e1a2aBill WendlingFunctionPass *llvm::createSjLjEHPreparePass(const TargetMachine *TM) { 86ea44281d5da5096de50ce1cb358ff0c6f20e1a2aBill Wendling return new SjLjEHPrepare(TM); 878b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach} 88a235d13217ff14621a88f3ea96a8a3b980c56d02Jim Grosbach// doInitialization - Set up decalarations and types needed to process 89a235d13217ff14621a88f3ea96a8a3b980c56d02Jim Grosbach// exceptions. 90eabae1d07bffac60d9f4f2473cf6736d6a1c372dBill Wendlingbool SjLjEHPrepare::doInitialization(Module &M) { 918b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach // Build the function context structure. 928b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach // builtin_setjmp uses a five word jbuf 935fdd6c8793462549e3593890ec61573da06e3346Jay Foad Type *VoidPtrTy = Type::getInt8PtrTy(M.getContext()); 945fdd6c8793462549e3593890ec61573da06e3346Jay Foad Type *Int32Ty = Type::getInt32Ty(M.getContext()); 9554e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling FunctionContextTy = StructType::get(VoidPtrTy, // __prev 9654e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling Int32Ty, // call_site 9754e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling ArrayType::get(Int32Ty, 4), // __data 9854e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling VoidPtrTy, // __personality 9954e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling VoidPtrTy, // __lsda 10054e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling ArrayType::get(VoidPtrTy, 5), // __jbuf 10154e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling NULL); 10254e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling RegisterFn = M.getOrInsertFunction( 10354e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling "_Unwind_SjLj_Register", Type::getVoidTy(M.getContext()), 104dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines PointerType::getUnqual(FunctionContextTy), (Type *)nullptr); 10554e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling UnregisterFn = M.getOrInsertFunction( 10654e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling "_Unwind_SjLj_Unregister", Type::getVoidTy(M.getContext()), 107dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines PointerType::getUnqual(FunctionContextTy), (Type *)nullptr); 1088b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach FrameAddrFn = Intrinsic::getDeclaration(&M, Intrinsic::frameaddress); 1090798eddd07b8dc827a4e6e9028c4c3a8d9444286Jim Grosbach StackAddrFn = Intrinsic::getDeclaration(&M, Intrinsic::stacksave); 11020c918dfed5830f6d0c54c9c38817bd660cb6a13Bob Wilson StackRestoreFn = Intrinsic::getDeclaration(&M, Intrinsic::stackrestore); 1118b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach BuiltinSetjmpFn = Intrinsic::getDeclaration(&M, Intrinsic::eh_sjlj_setjmp); 1128b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach LSDAAddrFn = Intrinsic::getDeclaration(&M, Intrinsic::eh_sjlj_lsda); 113ca752c9020a1b1cf151142bd9e0cbca9af12d807Jim Grosbach CallSiteFn = Intrinsic::getDeclaration(&M, Intrinsic::eh_sjlj_callsite); 114cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling FuncCtxFn = Intrinsic::getDeclaration(&M, Intrinsic::eh_sjlj_functioncontext); 115dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines PersonalityFn = nullptr; 1168b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 1178b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach return true; 1188b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach} 1198b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 120b58a59b3c1563ab5bd7225748e32933bf6d76c03Jim Grosbach/// insertCallSiteStore - Insert a store of the call-site value to the 121b58a59b3c1563ab5bd7225748e32933bf6d76c03Jim Grosbach/// function context 122eabae1d07bffac60d9f4f2473cf6736d6a1c372dBill Wendlingvoid SjLjEHPrepare::insertCallSiteStore(Instruction *I, int Number) { 1234cc4666268c6c62de763c46fefe304adf08a01a1Bill Wendling IRBuilder<> Builder(I); 1244cc4666268c6c62de763c46fefe304adf08a01a1Bill Wendling 1254cc4666268c6c62de763c46fefe304adf08a01a1Bill Wendling // Get a reference to the call_site field. 1264cc4666268c6c62de763c46fefe304adf08a01a1Bill Wendling Type *Int32Ty = Type::getInt32Ty(I->getContext()); 1274cc4666268c6c62de763c46fefe304adf08a01a1Bill Wendling Value *Zero = ConstantInt::get(Int32Ty, 0); 1284cc4666268c6c62de763c46fefe304adf08a01a1Bill Wendling Value *One = ConstantInt::get(Int32Ty, 1); 1294cc4666268c6c62de763c46fefe304adf08a01a1Bill Wendling Value *Idxs[2] = { Zero, One }; 1304cc4666268c6c62de763c46fefe304adf08a01a1Bill Wendling Value *CallSite = Builder.CreateGEP(FuncCtx, Idxs, "call_site"); 1314cc4666268c6c62de763c46fefe304adf08a01a1Bill Wendling 1324cc4666268c6c62de763c46fefe304adf08a01a1Bill Wendling // Insert a store of the call-site number 13354e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling ConstantInt *CallSiteNoC = 13454e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling ConstantInt::get(Type::getInt32Ty(I->getContext()), Number); 13554e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling Builder.CreateStore(CallSiteNoC, CallSite, true /*volatile*/); 136b58a59b3c1563ab5bd7225748e32933bf6d76c03Jim Grosbach} 137b58a59b3c1563ab5bd7225748e32933bf6d76c03Jim Grosbach 138bace5da91dbfc15d04c0e9897805ed4c5c0461adChad Rosier/// MarkBlocksLiveIn - Insert BB and all of its predescessors into LiveBBs until 1398b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach/// we reach blocks we've already seen. 140bace5da91dbfc15d04c0e9897805ed4c5c0461adChad Rosierstatic void MarkBlocksLiveIn(BasicBlock *BB, 14154e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling SmallPtrSet<BasicBlock *, 64> &LiveBBs) { 14254e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling if (!LiveBBs.insert(BB)) 14354e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling return; // already been here. 1448b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 145bace5da91dbfc15d04c0e9897805ed4c5c0461adChad Rosier for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) 146bace5da91dbfc15d04c0e9897805ed4c5c0461adChad Rosier MarkBlocksLiveIn(*PI, LiveBBs); 1478b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach} 1488b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach 14969fdcd7f902256d6deec8f085f5bb12bd39f762eBill Wendling/// substituteLPadValues - Substitute the values returned by the landingpad 15069fdcd7f902256d6deec8f085f5bb12bd39f762eBill Wendling/// instruction with those returned by the personality function. 151eabae1d07bffac60d9f4f2473cf6736d6a1c372dBill Wendlingvoid SjLjEHPrepare::substituteLPadValues(LandingPadInst *LPI, Value *ExnVal, 152eabae1d07bffac60d9f4f2473cf6736d6a1c372dBill Wendling Value *SelVal) { 15336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines SmallVector<Value *, 8> UseWorkList(LPI->user_begin(), LPI->user_end()); 15469fdcd7f902256d6deec8f085f5bb12bd39f762eBill Wendling while (!UseWorkList.empty()) { 15569fdcd7f902256d6deec8f085f5bb12bd39f762eBill Wendling Value *Val = UseWorkList.pop_back_val(); 15669fdcd7f902256d6deec8f085f5bb12bd39f762eBill Wendling ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(Val); 15754e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling if (!EVI) 15854e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling continue; 15954e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling if (EVI->getNumIndices() != 1) 16054e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling continue; 16169fdcd7f902256d6deec8f085f5bb12bd39f762eBill Wendling if (*EVI->idx_begin() == 0) 16269fdcd7f902256d6deec8f085f5bb12bd39f762eBill Wendling EVI->replaceAllUsesWith(ExnVal); 16369fdcd7f902256d6deec8f085f5bb12bd39f762eBill Wendling else if (*EVI->idx_begin() == 1) 16469fdcd7f902256d6deec8f085f5bb12bd39f762eBill Wendling EVI->replaceAllUsesWith(SelVal); 16569fdcd7f902256d6deec8f085f5bb12bd39f762eBill Wendling if (EVI->getNumUses() == 0) 16669fdcd7f902256d6deec8f085f5bb12bd39f762eBill Wendling EVI->eraseFromParent(); 16769fdcd7f902256d6deec8f085f5bb12bd39f762eBill Wendling } 16869fdcd7f902256d6deec8f085f5bb12bd39f762eBill Wendling 16954e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling if (LPI->getNumUses() == 0) 17054e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling return; 17169fdcd7f902256d6deec8f085f5bb12bd39f762eBill Wendling 17269fdcd7f902256d6deec8f085f5bb12bd39f762eBill Wendling // There are still some uses of LPI. Construct an aggregate with the exception 17369fdcd7f902256d6deec8f085f5bb12bd39f762eBill Wendling // values and replace the LPI with that aggregate. 17469fdcd7f902256d6deec8f085f5bb12bd39f762eBill Wendling Type *LPadType = LPI->getType(); 17569fdcd7f902256d6deec8f085f5bb12bd39f762eBill Wendling Value *LPadVal = UndefValue::get(LPadType); 17654e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling IRBuilder<> Builder( 17736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines std::next(BasicBlock::iterator(cast<Instruction>(SelVal)))); 17869fdcd7f902256d6deec8f085f5bb12bd39f762eBill Wendling LPadVal = Builder.CreateInsertValue(LPadVal, ExnVal, 0, "lpad.val"); 17969fdcd7f902256d6deec8f085f5bb12bd39f762eBill Wendling LPadVal = Builder.CreateInsertValue(LPadVal, SelVal, 1, "lpad.val"); 18069fdcd7f902256d6deec8f085f5bb12bd39f762eBill Wendling 18169fdcd7f902256d6deec8f085f5bb12bd39f762eBill Wendling LPI->replaceAllUsesWith(LPadVal); 18269fdcd7f902256d6deec8f085f5bb12bd39f762eBill Wendling} 18369fdcd7f902256d6deec8f085f5bb12bd39f762eBill Wendling 1842b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling/// setupFunctionContext - Allocate the function context on the stack and fill 1852b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling/// it with all of the data that we know at this point. 18654e82495e99632c2d1009ac0dde796c0e9e651f7Bill WendlingValue *SjLjEHPrepare::setupFunctionContext(Function &F, 18754e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling ArrayRef<LandingPadInst *> LPads) { 1882b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling BasicBlock *EntryBB = F.begin(); 1892b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 1902b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling // Create an alloca for the incoming jump buffer ptr and the new jump buffer 1912b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling // that needs to be restored on all exits from the function. This is an alloca 1922b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling // because the value needs to be added to the global context list. 193ea44281d5da5096de50ce1cb358ff0c6f20e1a2aBill Wendling const TargetLowering *TLI = TM->getTargetLowering(); 1942b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling unsigned Align = 19554e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling TLI->getDataLayout()->getPrefTypeAlignment(FunctionContextTy); 196dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines FuncCtx = new AllocaInst(FunctionContextTy, nullptr, Align, "fn_context", 19754e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling EntryBB->begin()); 1982b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 1992b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling // Fill in the function context structure. 2002b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling for (unsigned I = 0, E = LPads.size(); I != E; ++I) { 2012b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling LandingPadInst *LPI = LPads[I]; 2022b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling IRBuilder<> Builder(LPI->getParent()->getFirstInsertionPt()); 2032b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 2044cc4666268c6c62de763c46fefe304adf08a01a1Bill Wendling // Reference the __data field. 205f68b87f5fc1985c897e7a84ee040bcfff75b4959Benjamin Kramer Value *FCData = Builder.CreateConstGEP2_32(FuncCtx, 0, 2, "__data"); 2064cc4666268c6c62de763c46fefe304adf08a01a1Bill Wendling 2074cc4666268c6c62de763c46fefe304adf08a01a1Bill Wendling // The exception values come back in context->__data[0]. 20854e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling Value *ExceptionAddr = 20954e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling Builder.CreateConstGEP2_32(FCData, 0, 0, "exception_gep"); 2102b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling Value *ExnVal = Builder.CreateLoad(ExceptionAddr, true, "exn_val"); 211f68b87f5fc1985c897e7a84ee040bcfff75b4959Benjamin Kramer ExnVal = Builder.CreateIntToPtr(ExnVal, Builder.getInt8PtrTy()); 2124cc4666268c6c62de763c46fefe304adf08a01a1Bill Wendling 21354e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling Value *SelectorAddr = 21454e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling Builder.CreateConstGEP2_32(FCData, 0, 1, "exn_selector_gep"); 2152b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling Value *SelVal = Builder.CreateLoad(SelectorAddr, true, "exn_selector_val"); 2162b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 21769fdcd7f902256d6deec8f085f5bb12bd39f762eBill Wendling substituteLPadValues(LPI, ExnVal, SelVal); 2182b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling } 2192b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 2202b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling // Personality function 221f68b87f5fc1985c897e7a84ee040bcfff75b4959Benjamin Kramer IRBuilder<> Builder(EntryBB->getTerminator()); 2222b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling if (!PersonalityFn) 2232b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling PersonalityFn = LPads[0]->getPersonalityFn(); 22454e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling Value *PersonalityFieldPtr = 22554e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling Builder.CreateConstGEP2_32(FuncCtx, 0, 3, "pers_fn_gep"); 22654e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling Builder.CreateStore( 22754e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling Builder.CreateBitCast(PersonalityFn, Builder.getInt8PtrTy()), 22854e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling PersonalityFieldPtr, /*isVolatile=*/true); 2292b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 2302b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling // LSDA address 231f68b87f5fc1985c897e7a84ee040bcfff75b4959Benjamin Kramer Value *LSDA = Builder.CreateCall(LSDAAddrFn, "lsda_addr"); 232f68b87f5fc1985c897e7a84ee040bcfff75b4959Benjamin Kramer Value *LSDAFieldPtr = Builder.CreateConstGEP2_32(FuncCtx, 0, 4, "lsda_gep"); 233f68b87f5fc1985c897e7a84ee040bcfff75b4959Benjamin Kramer Builder.CreateStore(LSDA, LSDAFieldPtr, /*isVolatile=*/true); 2342b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 235631d11765b9f7ebdb49679c92bd41083fbab3f62Bill Wendling return FuncCtx; 2362b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling} 2372b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 238d5d170097241534401bbbebb4be59451d5c312caBill Wendling/// lowerIncomingArguments - To avoid having to handle incoming arguments 239d5d170097241534401bbbebb4be59451d5c312caBill Wendling/// specially, we lower each arg to a copy instruction in the entry block. This 240d5d170097241534401bbbebb4be59451d5c312caBill Wendling/// ensures that the argument value itself cannot be live out of the entry 241d5d170097241534401bbbebb4be59451d5c312caBill Wendling/// block. 242eabae1d07bffac60d9f4f2473cf6736d6a1c372dBill Wendlingvoid SjLjEHPrepare::lowerIncomingArguments(Function &F) { 243d5d170097241534401bbbebb4be59451d5c312caBill Wendling BasicBlock::iterator AfterAllocaInsPt = F.begin()->begin(); 244d5d170097241534401bbbebb4be59451d5c312caBill Wendling while (isa<AllocaInst>(AfterAllocaInsPt) && 245d5d170097241534401bbbebb4be59451d5c312caBill Wendling isa<ConstantInt>(cast<AllocaInst>(AfterAllocaInsPt)->getArraySize())) 246d5d170097241534401bbbebb4be59451d5c312caBill Wendling ++AfterAllocaInsPt; 247d5d170097241534401bbbebb4be59451d5c312caBill Wendling 24854e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling for (Function::arg_iterator AI = F.arg_begin(), AE = F.arg_end(); AI != AE; 24954e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling ++AI) { 250d5d170097241534401bbbebb4be59451d5c312caBill Wendling Type *Ty = AI->getType(); 251d5d170097241534401bbbebb4be59451d5c312caBill Wendling 252d5d170097241534401bbbebb4be59451d5c312caBill Wendling // Aggregate types can't be cast, but are legal argument types, so we have 253d5d170097241534401bbbebb4be59451d5c312caBill Wendling // to handle them differently. We use an extract/insert pair as a 254d5d170097241534401bbbebb4be59451d5c312caBill Wendling // lightweight method to achieve the same goal. 25536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (isa<StructType>(Ty) || isa<ArrayType>(Ty)) { 256d5d170097241534401bbbebb4be59451d5c312caBill Wendling Instruction *EI = ExtractValueInst::Create(AI, 0, "", AfterAllocaInsPt); 257d5d170097241534401bbbebb4be59451d5c312caBill Wendling Instruction *NI = InsertValueInst::Create(AI, EI, 0); 258d5d170097241534401bbbebb4be59451d5c312caBill Wendling NI->insertAfter(EI); 259d5d170097241534401bbbebb4be59451d5c312caBill Wendling AI->replaceAllUsesWith(NI); 260d5d170097241534401bbbebb4be59451d5c312caBill Wendling 261d5d170097241534401bbbebb4be59451d5c312caBill Wendling // Set the operand of the instructions back to the AllocaInst. 262d5d170097241534401bbbebb4be59451d5c312caBill Wendling EI->setOperand(0, AI); 263d5d170097241534401bbbebb4be59451d5c312caBill Wendling NI->setOperand(0, AI); 264d5d170097241534401bbbebb4be59451d5c312caBill Wendling } else { 265d5d170097241534401bbbebb4be59451d5c312caBill Wendling // This is always a no-op cast because we're casting AI to AI->getType() 266d5d170097241534401bbbebb4be59451d5c312caBill Wendling // so src and destination types are identical. BitCast is the only 267d5d170097241534401bbbebb4be59451d5c312caBill Wendling // possibility. 26854e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling CastInst *NC = new BitCastInst(AI, AI->getType(), AI->getName() + ".tmp", 26954e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling AfterAllocaInsPt); 270d5d170097241534401bbbebb4be59451d5c312caBill Wendling AI->replaceAllUsesWith(NC); 271d5d170097241534401bbbebb4be59451d5c312caBill Wendling 272d5d170097241534401bbbebb4be59451d5c312caBill Wendling // Set the operand of the cast instruction back to the AllocaInst. 273d5d170097241534401bbbebb4be59451d5c312caBill Wendling // Normally it's forbidden to replace a CastInst's operand because it 274d5d170097241534401bbbebb4be59451d5c312caBill Wendling // could cause the opcode to reflect an illegal conversion. However, we're 275d5d170097241534401bbbebb4be59451d5c312caBill Wendling // replacing it here with the same value it was constructed with. We do 276d5d170097241534401bbbebb4be59451d5c312caBill Wendling // this because the above replaceAllUsesWith() clobbered the operand, but 277d5d170097241534401bbbebb4be59451d5c312caBill Wendling // we want this one to remain. 278d5d170097241534401bbbebb4be59451d5c312caBill Wendling NC->setOperand(0, AI); 279d5d170097241534401bbbebb4be59451d5c312caBill Wendling } 280d5d170097241534401bbbebb4be59451d5c312caBill Wendling } 281d5d170097241534401bbbebb4be59451d5c312caBill Wendling} 282d5d170097241534401bbbebb4be59451d5c312caBill Wendling 283d5d170097241534401bbbebb4be59451d5c312caBill Wendling/// lowerAcrossUnwindEdges - Find all variables which are alive across an unwind 284d5d170097241534401bbbebb4be59451d5c312caBill Wendling/// edge and spill them. 285eabae1d07bffac60d9f4f2473cf6736d6a1c372dBill Wendlingvoid SjLjEHPrepare::lowerAcrossUnwindEdges(Function &F, 28654e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling ArrayRef<InvokeInst *> Invokes) { 287d5d170097241534401bbbebb4be59451d5c312caBill Wendling // Finally, scan the code looking for instructions with bad live ranges. 28854e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling for (Function::iterator BB = F.begin(), BBE = F.end(); BB != BBE; ++BB) { 28954e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling for (BasicBlock::iterator II = BB->begin(), IIE = BB->end(); II != IIE; 29054e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling ++II) { 291d5d170097241534401bbbebb4be59451d5c312caBill Wendling // Ignore obvious cases we don't have to handle. In particular, most 292d5d170097241534401bbbebb4be59451d5c312caBill Wendling // instructions either have no uses or only have a single use inside the 293d5d170097241534401bbbebb4be59451d5c312caBill Wendling // current block. Ignore them quickly. 294d5d170097241534401bbbebb4be59451d5c312caBill Wendling Instruction *Inst = II; 29554e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling if (Inst->use_empty()) 29654e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling continue; 297d5d170097241534401bbbebb4be59451d5c312caBill Wendling if (Inst->hasOneUse() && 29836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines cast<Instruction>(Inst->user_back())->getParent() == BB && 29936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines !isa<PHINode>(Inst->user_back())) 30054e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling continue; 301d5d170097241534401bbbebb4be59451d5c312caBill Wendling 302d5d170097241534401bbbebb4be59451d5c312caBill Wendling // If this is an alloca in the entry block, it's not a real register 303d5d170097241534401bbbebb4be59451d5c312caBill Wendling // value. 304d5d170097241534401bbbebb4be59451d5c312caBill Wendling if (AllocaInst *AI = dyn_cast<AllocaInst>(Inst)) 305d5d170097241534401bbbebb4be59451d5c312caBill Wendling if (isa<ConstantInt>(AI->getArraySize()) && BB == F.begin()) 306d5d170097241534401bbbebb4be59451d5c312caBill Wendling continue; 307d5d170097241534401bbbebb4be59451d5c312caBill Wendling 308d5d170097241534401bbbebb4be59451d5c312caBill Wendling // Avoid iterator invalidation by copying users to a temporary vector. 30954e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling SmallVector<Instruction *, 16> Users; 31036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines for (User *U : Inst->users()) { 31136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Instruction *UI = cast<Instruction>(U); 31236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (UI->getParent() != BB || isa<PHINode>(UI)) 31336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Users.push_back(UI); 314d5d170097241534401bbbebb4be59451d5c312caBill Wendling } 315d5d170097241534401bbbebb4be59451d5c312caBill Wendling 316d5d170097241534401bbbebb4be59451d5c312caBill Wendling // Find all of the blocks that this value is live in. 31754e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling SmallPtrSet<BasicBlock *, 64> LiveBBs; 318bace5da91dbfc15d04c0e9897805ed4c5c0461adChad Rosier LiveBBs.insert(Inst->getParent()); 319d5d170097241534401bbbebb4be59451d5c312caBill Wendling while (!Users.empty()) { 320bace5da91dbfc15d04c0e9897805ed4c5c0461adChad Rosier Instruction *U = Users.back(); 321bace5da91dbfc15d04c0e9897805ed4c5c0461adChad Rosier Users.pop_back(); 322d5d170097241534401bbbebb4be59451d5c312caBill Wendling 323bace5da91dbfc15d04c0e9897805ed4c5c0461adChad Rosier if (!isa<PHINode>(U)) { 324bace5da91dbfc15d04c0e9897805ed4c5c0461adChad Rosier MarkBlocksLiveIn(U->getParent(), LiveBBs); 325bace5da91dbfc15d04c0e9897805ed4c5c0461adChad Rosier } else { 326d5d170097241534401bbbebb4be59451d5c312caBill Wendling // Uses for a PHI node occur in their predecessor block. 327bace5da91dbfc15d04c0e9897805ed4c5c0461adChad Rosier PHINode *PN = cast<PHINode>(U); 328d5d170097241534401bbbebb4be59451d5c312caBill Wendling for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) 329d5d170097241534401bbbebb4be59451d5c312caBill Wendling if (PN->getIncomingValue(i) == Inst) 330bace5da91dbfc15d04c0e9897805ed4c5c0461adChad Rosier MarkBlocksLiveIn(PN->getIncomingBlock(i), LiveBBs); 331d5d170097241534401bbbebb4be59451d5c312caBill Wendling } 332d5d170097241534401bbbebb4be59451d5c312caBill Wendling } 333d5d170097241534401bbbebb4be59451d5c312caBill Wendling 334bace5da91dbfc15d04c0e9897805ed4c5c0461adChad Rosier // Now that we know all of the blocks that this thing is live in, see if 335bace5da91dbfc15d04c0e9897805ed4c5c0461adChad Rosier // it includes any of the unwind locations. 336bace5da91dbfc15d04c0e9897805ed4c5c0461adChad Rosier bool NeedsSpill = false; 337bace5da91dbfc15d04c0e9897805ed4c5c0461adChad Rosier for (unsigned i = 0, e = Invokes.size(); i != e; ++i) { 338bace5da91dbfc15d04c0e9897805ed4c5c0461adChad Rosier BasicBlock *UnwindBlock = Invokes[i]->getUnwindDest(); 339bace5da91dbfc15d04c0e9897805ed4c5c0461adChad Rosier if (UnwindBlock != BB && LiveBBs.count(UnwindBlock)) { 340bace5da91dbfc15d04c0e9897805ed4c5c0461adChad Rosier DEBUG(dbgs() << "SJLJ Spill: " << *Inst << " around " 34154e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling << UnwindBlock->getName() << "\n"); 342bace5da91dbfc15d04c0e9897805ed4c5c0461adChad Rosier NeedsSpill = true; 343bace5da91dbfc15d04c0e9897805ed4c5c0461adChad Rosier break; 344d5d170097241534401bbbebb4be59451d5c312caBill Wendling } 345d5d170097241534401bbbebb4be59451d5c312caBill Wendling } 346d5d170097241534401bbbebb4be59451d5c312caBill Wendling 347bace5da91dbfc15d04c0e9897805ed4c5c0461adChad Rosier // If we decided we need a spill, do it. 348bace5da91dbfc15d04c0e9897805ed4c5c0461adChad Rosier // FIXME: Spilling this way is overkill, as it forces all uses of 349bace5da91dbfc15d04c0e9897805ed4c5c0461adChad Rosier // the value to be reloaded from the stack slot, even those that aren't 350bace5da91dbfc15d04c0e9897805ed4c5c0461adChad Rosier // in the unwind blocks. We should be more selective. 351bace5da91dbfc15d04c0e9897805ed4c5c0461adChad Rosier if (NeedsSpill) { 352bace5da91dbfc15d04c0e9897805ed4c5c0461adChad Rosier DemoteRegToStack(*Inst, true); 353bace5da91dbfc15d04c0e9897805ed4c5c0461adChad Rosier ++NumSpilled; 3549eb5f170a219decc4ee07b57b0403d3836a8d946Bill Wendling } 355d5d170097241534401bbbebb4be59451d5c312caBill Wendling } 356d5d170097241534401bbbebb4be59451d5c312caBill Wendling } 3570ad56122e585d3d27ea852115390a9e53cabc9d5Bill Wendling 3580ad56122e585d3d27ea852115390a9e53cabc9d5Bill Wendling // Go through the landing pads and remove any PHIs there. 3590ad56122e585d3d27ea852115390a9e53cabc9d5Bill Wendling for (unsigned i = 0, e = Invokes.size(); i != e; ++i) { 3600ad56122e585d3d27ea852115390a9e53cabc9d5Bill Wendling BasicBlock *UnwindBlock = Invokes[i]->getUnwindDest(); 3610ad56122e585d3d27ea852115390a9e53cabc9d5Bill Wendling LandingPadInst *LPI = UnwindBlock->getLandingPadInst(); 3620ad56122e585d3d27ea852115390a9e53cabc9d5Bill Wendling 3630ad56122e585d3d27ea852115390a9e53cabc9d5Bill Wendling // Place PHIs into a set to avoid invalidating the iterator. 36454e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling SmallPtrSet<PHINode *, 8> PHIsToDemote; 36554e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling for (BasicBlock::iterator PN = UnwindBlock->begin(); isa<PHINode>(PN); ++PN) 3660ad56122e585d3d27ea852115390a9e53cabc9d5Bill Wendling PHIsToDemote.insert(cast<PHINode>(PN)); 36754e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling if (PHIsToDemote.empty()) 36854e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling continue; 3690ad56122e585d3d27ea852115390a9e53cabc9d5Bill Wendling 3700ad56122e585d3d27ea852115390a9e53cabc9d5Bill Wendling // Demote the PHIs to the stack. 37154e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling for (SmallPtrSet<PHINode *, 8>::iterator I = PHIsToDemote.begin(), 37254e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling E = PHIsToDemote.end(); 37354e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling I != E; ++I) 3740ad56122e585d3d27ea852115390a9e53cabc9d5Bill Wendling DemotePHIToStack(*I); 3750ad56122e585d3d27ea852115390a9e53cabc9d5Bill Wendling 3760ad56122e585d3d27ea852115390a9e53cabc9d5Bill Wendling // Move the landingpad instruction back to the top of the landing pad block. 3770ad56122e585d3d27ea852115390a9e53cabc9d5Bill Wendling LPI->moveBefore(UnwindBlock->begin()); 3780ad56122e585d3d27ea852115390a9e53cabc9d5Bill Wendling } 379d5d170097241534401bbbebb4be59451d5c312caBill Wendling} 380d5d170097241534401bbbebb4be59451d5c312caBill Wendling 3812b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling/// setupEntryBlockAndCallSites - Setup the entry block by creating and filling 3822b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling/// the function context and marking the call sites with the appropriate 3832b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling/// values. These values are used by the DWARF EH emitter. 384eabae1d07bffac60d9f4f2473cf6736d6a1c372dBill Wendlingbool SjLjEHPrepare::setupEntryBlockAndCallSites(Function &F) { 38554e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling SmallVector<ReturnInst *, 16> Returns; 38654e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling SmallVector<InvokeInst *, 16> Invokes; 38754e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling SmallSetVector<LandingPadInst *, 16> LPads; 3882b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 3892b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling // Look through the terminators of the basic blocks to find invokes. 3902b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) 3912b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling if (InvokeInst *II = dyn_cast<InvokeInst>(BB->getTerminator())) { 392e36b47e17be0e3289890f33fe8aaecfc231d83a0Bill Wendling if (Function *Callee = II->getCalledFunction()) 393e36b47e17be0e3289890f33fe8aaecfc231d83a0Bill Wendling if (Callee->isIntrinsic() && 394e36b47e17be0e3289890f33fe8aaecfc231d83a0Bill Wendling Callee->getIntrinsicID() == Intrinsic::donothing) { 395e36b47e17be0e3289890f33fe8aaecfc231d83a0Bill Wendling // Remove the NOP invoke. 396e36b47e17be0e3289890f33fe8aaecfc231d83a0Bill Wendling BranchInst::Create(II->getNormalDest(), II); 397e36b47e17be0e3289890f33fe8aaecfc231d83a0Bill Wendling II->eraseFromParent(); 398e36b47e17be0e3289890f33fe8aaecfc231d83a0Bill Wendling continue; 399e36b47e17be0e3289890f33fe8aaecfc231d83a0Bill Wendling } 400e36b47e17be0e3289890f33fe8aaecfc231d83a0Bill Wendling 4012b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling Invokes.push_back(II); 402f1b41dd38d2b2713e3870f384525b020bbac05f6Bob Wilson LPads.insert(II->getUnwindDest()->getLandingPadInst()); 403cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling } else if (ReturnInst *RI = dyn_cast<ReturnInst>(BB->getTerminator())) { 404cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling Returns.push_back(RI); 4052b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling } 4062b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 40754e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling if (Invokes.empty()) 40854e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling return false; 4092b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 410d2dae0cfa00ca3c5164b2543ed712ace6c08386bBill Wendling NumInvokes += Invokes.size(); 411d2dae0cfa00ca3c5164b2543ed712ace6c08386bBill Wendling 412d5d170097241534401bbbebb4be59451d5c312caBill Wendling lowerIncomingArguments(F); 413d5d170097241534401bbbebb4be59451d5c312caBill Wendling lowerAcrossUnwindEdges(F, Invokes); 414d5d170097241534401bbbebb4be59451d5c312caBill Wendling 415f1b41dd38d2b2713e3870f384525b020bbac05f6Bob Wilson Value *FuncCtx = 41654e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling setupFunctionContext(F, makeArrayRef(LPads.begin(), LPads.end())); 417cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling BasicBlock *EntryBB = F.begin(); 418f68b87f5fc1985c897e7a84ee040bcfff75b4959Benjamin Kramer IRBuilder<> Builder(EntryBB->getTerminator()); 419631d11765b9f7ebdb49679c92bd41083fbab3f62Bill Wendling 420631d11765b9f7ebdb49679c92bd41083fbab3f62Bill Wendling // Get a reference to the jump buffer. 421f68b87f5fc1985c897e7a84ee040bcfff75b4959Benjamin Kramer Value *JBufPtr = Builder.CreateConstGEP2_32(FuncCtx, 0, 5, "jbuf_gep"); 422631d11765b9f7ebdb49679c92bd41083fbab3f62Bill Wendling 423631d11765b9f7ebdb49679c92bd41083fbab3f62Bill Wendling // Save the frame pointer. 424f68b87f5fc1985c897e7a84ee040bcfff75b4959Benjamin Kramer Value *FramePtr = Builder.CreateConstGEP2_32(JBufPtr, 0, 0, "jbuf_fp_gep"); 425631d11765b9f7ebdb49679c92bd41083fbab3f62Bill Wendling 426f68b87f5fc1985c897e7a84ee040bcfff75b4959Benjamin Kramer Value *Val = Builder.CreateCall(FrameAddrFn, Builder.getInt32(0), "fp"); 427f68b87f5fc1985c897e7a84ee040bcfff75b4959Benjamin Kramer Builder.CreateStore(Val, FramePtr, /*isVolatile=*/true); 428631d11765b9f7ebdb49679c92bd41083fbab3f62Bill Wendling 429631d11765b9f7ebdb49679c92bd41083fbab3f62Bill Wendling // Save the stack pointer. 430f68b87f5fc1985c897e7a84ee040bcfff75b4959Benjamin Kramer Value *StackPtr = Builder.CreateConstGEP2_32(JBufPtr, 0, 2, "jbuf_sp_gep"); 431cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling 432f68b87f5fc1985c897e7a84ee040bcfff75b4959Benjamin Kramer Val = Builder.CreateCall(StackAddrFn, "sp"); 433f68b87f5fc1985c897e7a84ee040bcfff75b4959Benjamin Kramer Builder.CreateStore(Val, StackPtr, /*isVolatile=*/true); 434cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling 435cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling // Call the setjmp instrinsic. It fills in the rest of the jmpbuf. 436f68b87f5fc1985c897e7a84ee040bcfff75b4959Benjamin Kramer Value *SetjmpArg = Builder.CreateBitCast(JBufPtr, Builder.getInt8PtrTy()); 437f68b87f5fc1985c897e7a84ee040bcfff75b4959Benjamin Kramer Builder.CreateCall(BuiltinSetjmpFn, SetjmpArg); 438cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling 439cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling // Store a pointer to the function context so that the back-end will know 440cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling // where to look for it. 441f68b87f5fc1985c897e7a84ee040bcfff75b4959Benjamin Kramer Value *FuncCtxArg = Builder.CreateBitCast(FuncCtx, Builder.getInt8PtrTy()); 442f68b87f5fc1985c897e7a84ee040bcfff75b4959Benjamin Kramer Builder.CreateCall(FuncCtxFn, FuncCtxArg); 4432b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 4442b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling // At this point, we are all set up, update the invoke instructions to mark 4452130ab0131ca0c0f5607937fe1f6ed48c28d39a2Bill Wendling // their call_site values. 4462b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling for (unsigned I = 0, E = Invokes.size(); I != E; ++I) { 4474cc4666268c6c62de763c46fefe304adf08a01a1Bill Wendling insertCallSiteStore(Invokes[I], I + 1); 4482b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 4492b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling ConstantInt *CallSiteNum = 45054e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling ConstantInt::get(Type::getInt32Ty(F.getContext()), I + 1); 4512b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 4522b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling // Record the call site value for the back end so it stays associated with 4532b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling // the invoke. 4542b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling CallInst::Create(CallSiteFn, CallSiteNum, "", Invokes[I]); 4552b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling } 4562b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 4572b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling // Mark call instructions that aren't nounwind as no-action (call_site == 4582b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling // -1). Skip the entry block, as prior to then, no function context has been 4592b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling // created for this function and any unexpected exceptions thrown will go 4602b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling // directly to the caller's context, which is what we want anyway, so no need 4612b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling // to do anything here. 462da7e6a9c8888fe9c4198214cc19f6f55e21e72e4Bill Wendling for (Function::iterator BB = F.begin(), E = F.end(); ++BB != E;) 4632b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling for (BasicBlock::iterator I = BB->begin(), end = BB->end(); I != end; ++I) 4642b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling if (CallInst *CI = dyn_cast<CallInst>(I)) { 4652b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling if (!CI->doesNotThrow()) 4664cc4666268c6c62de763c46fefe304adf08a01a1Bill Wendling insertCallSiteStore(CI, -1); 4672b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling } else if (ResumeInst *RI = dyn_cast<ResumeInst>(I)) { 4684cc4666268c6c62de763c46fefe304adf08a01a1Bill Wendling insertCallSiteStore(RI, -1); 4692b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling } 4702b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 471cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling // Register the function context and make sure it's known to not throw 47254e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling CallInst *Register = 47354e82495e99632c2d1009ac0dde796c0e9e651f7Bill Wendling CallInst::Create(RegisterFn, FuncCtx, "", EntryBB->getTerminator()); 474cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling Register->setDoesNotThrow(); 475cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling 47620c918dfed5830f6d0c54c9c38817bd660cb6a13Bob Wilson // Following any allocas not in the entry block, update the saved SP in the 47720c918dfed5830f6d0c54c9c38817bd660cb6a13Bob Wilson // jmpbuf to the new value. 47820c918dfed5830f6d0c54c9c38817bd660cb6a13Bob Wilson for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) { 47920c918dfed5830f6d0c54c9c38817bd660cb6a13Bob Wilson if (BB == F.begin()) 48020c918dfed5830f6d0c54c9c38817bd660cb6a13Bob Wilson continue; 48120c918dfed5830f6d0c54c9c38817bd660cb6a13Bob Wilson for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) { 48220c918dfed5830f6d0c54c9c38817bd660cb6a13Bob Wilson if (CallInst *CI = dyn_cast<CallInst>(I)) { 48320c918dfed5830f6d0c54c9c38817bd660cb6a13Bob Wilson if (CI->getCalledFunction() != StackRestoreFn) 48420c918dfed5830f6d0c54c9c38817bd660cb6a13Bob Wilson continue; 48520c918dfed5830f6d0c54c9c38817bd660cb6a13Bob Wilson } else if (!isa<AllocaInst>(I)) { 48620c918dfed5830f6d0c54c9c38817bd660cb6a13Bob Wilson continue; 48720c918dfed5830f6d0c54c9c38817bd660cb6a13Bob Wilson } 48820c918dfed5830f6d0c54c9c38817bd660cb6a13Bob Wilson Instruction *StackAddr = CallInst::Create(StackAddrFn, "sp"); 48920c918dfed5830f6d0c54c9c38817bd660cb6a13Bob Wilson StackAddr->insertAfter(I); 49020c918dfed5830f6d0c54c9c38817bd660cb6a13Bob Wilson Instruction *StoreStackAddr = new StoreInst(StackAddr, StackPtr, true); 49120c918dfed5830f6d0c54c9c38817bd660cb6a13Bob Wilson StoreStackAddr->insertAfter(StackAddr); 49220c918dfed5830f6d0c54c9c38817bd660cb6a13Bob Wilson } 49320c918dfed5830f6d0c54c9c38817bd660cb6a13Bob Wilson } 49420c918dfed5830f6d0c54c9c38817bd660cb6a13Bob Wilson 495cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling // Finally, for any returns from this function, if this function contains an 496cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling // invoke, add a call to unregister the function context. 497cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling for (unsigned I = 0, E = Returns.size(); I != E; ++I) 498631d11765b9f7ebdb49679c92bd41083fbab3f62Bill Wendling CallInst::Create(UnregisterFn, FuncCtx, "", Returns[I]); 499cc8cf97be434b4e2b9c0388db1bfb709f09098ebBill Wendling 5002b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling return true; 5012b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling} 5022b6bd7ba5819d8c73c89291c6de89a86dbbffe9cBill Wendling 503eabae1d07bffac60d9f4f2473cf6736d6a1c372dBill Wendlingbool SjLjEHPrepare::runOnFunction(Function &F) { 504d2dae0cfa00ca3c5164b2543ed712ace6c08386bBill Wendling bool Res = setupEntryBlockAndCallSites(F); 5058b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach return Res; 5068b818d7e98309125c6058c4ea72a7dc73b031db2Jim Grosbach} 507