diff --git a/include/llvm/CodeGen/Passes.h b/include/llvm/CodeGen/Passes.h index d0d610370bd..f753eecba2d 100644 --- a/include/llvm/CodeGen/Passes.h +++ b/include/llvm/CodeGen/Passes.h @@ -186,7 +186,7 @@ namespace llvm { /// createDwarfEHPass - This pass mulches exception handling code into a form /// adapted to code generation. Required if using dwarf exception handling. - FunctionPass *createDwarfEHPass(const TargetLowering *tli, bool fast); + FunctionPass *createDwarfEHPass(const TargetLowering *tli); /// createSjLjEHPass - This pass adapts exception handling code to use /// the GCC-style builtin setjmp/longjmp (sjlj) to handling EH control flow. diff --git a/include/llvm/IntrinsicInst.h b/include/llvm/IntrinsicInst.h index 6a8f3763926..ee5f23a7511 100644 --- a/include/llvm/IntrinsicInst.h +++ b/include/llvm/IntrinsicInst.h @@ -307,6 +307,19 @@ namespace llvm { } }; + /// EHExceptionInst - This represents the llvm.eh.exception instruction. + /// + struct EHExceptionInst : public IntrinsicInst { + // Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const EHExceptionInst *) { return true; } + static inline bool classof(const IntrinsicInst *I) { + return I->getIntrinsicID() == Intrinsic::eh_exception; + } + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } + }; + /// EHSelectorInst - This represents the llvm.eh.selector instruction. /// struct EHSelectorInst : public IntrinsicInst { diff --git a/lib/CodeGen/DwarfEHPrepare.cpp b/lib/CodeGen/DwarfEHPrepare.cpp index 7fc62a9a96c..cfaaa70b929 100644 --- a/lib/CodeGen/DwarfEHPrepare.cpp +++ b/lib/CodeGen/DwarfEHPrepare.cpp @@ -21,27 +21,41 @@ #include "llvm/IntrinsicInst.h" #include "llvm/Module.h" #include "llvm/Pass.h" +#include "llvm/Support/Compiler.h" +#include "llvm/Support/IRBuilder.h" #include "llvm/Target/TargetLowering.h" #include "llvm/Transforms/Utils/BasicBlockUtils.h" #include "llvm/Transforms/Utils/PromoteMemToReg.h" using namespace llvm; -STATISTIC(NumLandingPadsSplit, "Number of landing pads split"); -STATISTIC(NumUnwindsLowered, "Number of unwind instructions lowered"); STATISTIC(NumExceptionValuesMoved, "Number of eh.exception calls moved"); +STATISTIC(NumLonelyLandingPads, "Number of landing pads with no selector"); +STATISTIC(NumLonelySelectors, "Number of lonely selectors lowered"); +STATISTIC(NumLandingPadsSplit, "Number of landing pads split"); +STATISTIC(NumSelectorsAdjusted, "Number of selector results adjusted"); +STATISTIC(NumSelectorsSimplified, "Number of selectors truncated"); STATISTIC(NumStackTempsIntroduced, "Number of stack temporaries introduced"); +STATISTIC(NumUnwindsLowered, "Number of unwind instructions lowered"); namespace { class DwarfEHPrepare : public FunctionPass { const TargetLowering *TLI; - bool CompileFast; // The eh.exception intrinsic. - Function *ExceptionValueIntrinsic; + Function *ExceptionIntrinsic; + + // The eh.selector intrinsic. + Function *SelectorIntrinsic; + + // The eh.typeid.for intrinsic. + Function *TypeIdIntrinsic; // _Unwind_Resume or the target equivalent. Constant *RewindFunction; + // _Unwind_RaiseException. + Constant *UnwindFunction; + // Dominator info is used when turning stack temporaries into registers. DominatorTree *DT; DominanceFrontier *DF; @@ -49,6 +63,13 @@ namespace { // The function we are running on. Function *F; + // The current context. + LLVMContext *Context; + + // The personality and catch-all value for this function. + Constant *Personality; + Constant *CatchAll; + // The landing pads for this function. typedef SmallPtrSet BBSet; BBSet LandingPads; @@ -58,7 +79,10 @@ namespace { bool NormalizeLandingPads(); bool LowerUnwinds(); + bool MoveSelectorCalls(); + bool RectifySelectorCalls(); bool MoveExceptionValueCalls(); + bool AddMissingSelectors(); bool FinishStackTemporaries(); bool PromoteStackTemporaries(); @@ -75,22 +99,13 @@ namespace { public: static char ID; // Pass identification, replacement for typeid. - DwarfEHPrepare(const TargetLowering *tli, bool fast) : - FunctionPass(&ID), TLI(tli), CompileFast(fast), - ExceptionValueIntrinsic(0), RewindFunction(0) {} + DwarfEHPrepare(const TargetLowering *tli) : + FunctionPass(&ID), TLI(tli), ExceptionIntrinsic(0), + SelectorIntrinsic(0), TypeIdIntrinsic(0), RewindFunction(0), + UnwindFunction(0) {} virtual bool runOnFunction(Function &Fn); - // getAnalysisUsage - We need dominance frontiers for memory promotion. - virtual void getAnalysisUsage(AnalysisUsage &AU) const { - if (!CompileFast) - AU.addRequired(); - AU.addPreserved(); - if (!CompileFast) - AU.addRequired(); - AU.addPreserved(); - } - const char *getPassName() const { return "Exception handling preparation"; } @@ -100,8 +115,8 @@ namespace { char DwarfEHPrepare::ID = 0; -FunctionPass *llvm::createDwarfEHPass(const TargetLowering *tli, bool fast) { - return new DwarfEHPrepare(tli, fast); +FunctionPass *llvm::createDwarfEHPass(const TargetLowering *tli) { + return new DwarfEHPrepare(tli); } /// NormalizeLandingPads - Normalize and discover landing pads, noting them @@ -144,7 +159,7 @@ bool DwarfEHPrepare::NormalizeLandingPads() { // edges to a new basic block which falls through into this one. // Create the new basic block. - BasicBlock *NewBB = BasicBlock::Create(F->getContext(), + BasicBlock *NewBB = BasicBlock::Create(*Context, LPad->getName() + "_unwind_edge"); // Insert it into the function right before the original landing pad. @@ -233,17 +248,14 @@ bool DwarfEHPrepare::LowerUnwinds() { // Find the rewind function if we didn't already. if (!RewindFunction) { - LLVMContext &Ctx = UnwindInsts[0]->getContext(); std::vector - Params(1, Type::getInt8PtrTy(Ctx)); - FunctionType *FTy = FunctionType::get(Type::getVoidTy(Ctx), + Params(1, Type::getInt8PtrTy(*Context)); + FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Context), Params, false); const char *RewindName = TLI->getLibcallName(RTLIB::UNWIND_RESUME); RewindFunction = F->getParent()->getOrInsertFunction(RewindName, FTy); } - bool Changed = false; - for (SmallVectorImpl::iterator I = UnwindInsts.begin(), E = UnwindInsts.end(); I != E; ++I) { TerminatorInst *TI = *I; @@ -257,11 +269,244 @@ bool DwarfEHPrepare::LowerUnwinds() { "", TI); CI->setCallingConv(TLI->getLibcallCallingConv(RTLIB::UNWIND_RESUME)); // ...followed by an UnreachableInst. - new UnreachableInst(TI->getContext(), TI); + new UnreachableInst(*Context, TI); // Nuke the unwind instruction. TI->eraseFromParent(); ++NumUnwindsLowered; + } + + return true; +} + +/// MoveSelectorCalls - Make sure that every call to eh.selector occurs in its +/// own landing pad, the landing pad corresponding to the exception object. +bool DwarfEHPrepare::MoveSelectorCalls() { + // If the eh.selector intrinsic is not declared in the module then there is + // nothing to do. Speed up compilation by checking for this common case. + if (!F->getParent()->getFunction(Intrinsic::getName(Intrinsic::eh_selector))) + return false; + + // TODO: There is a lot of room for optimization here. + + bool Changed = false; + BasicBlock *UnrBB = 0; + + for (Function::iterator BB = F->begin(); BB != F->end(); ++BB) { + // If this basic block is not a landing pad then synthesize a landing pad + // for every selector in it. + bool SynthesizeLandingPad = !LandingPads.count(BB); + + for (BasicBlock::iterator II = BB->begin(), IE = BB->end(); II != IE; ++II) { + EHSelectorInst *SI = dyn_cast(II); + // Only interested in eh.selector calls. + if (!SI) + continue; + + // Note the personality and catch-all for later use. + Personality = cast(SI->getOperand(2)); + CatchAll = cast(SI->getOperand(SI->getNumOperands() - 1) + ->stripPointerCasts()); + + // The exception object. + Value *Exception = SI->getOperand(1); + + if (!SynthesizeLandingPad) { + // Did the exception come from unwinding to this landing pad or another? + // If it comes from a different landing pad then we need to synthesize a + // new landing pad for the selector. + EHExceptionInst *EI = dyn_cast(Exception); + SynthesizeLandingPad = !EI || EI->getParent() != BB; + } + + if (!SynthesizeLandingPad) { + // This is the first selector in this landing pad, and it is the landing + // pad corresponding to the exception object. No need to do anything to + // this selector, but any subsequent selectors in this landing pad will + // need their own invoke in order to make them independent of this one. + SynthesizeLandingPad = true; + continue; + } + + // Rethrow the exception and catch it again, generating a landing pad for + // this selector to live in. + + // Find _Unwind_RaiseException if we didn't already. + if (!UnwindFunction) { + std::vector ArgTys(1, Type::getInt8PtrTy(*Context)); + const FunctionType *FTy = + FunctionType::get(Type::getInt32Ty(*Context), ArgTys, true); + + const char *Name = "_Unwind_RaiseException"; + UnwindFunction = F->getParent()->getOrInsertFunction(Name, FTy); + } + + // Create a basic block containing only an unreachable instruction if we + // didn't already. + if (!UnrBB) { + UnrBB = BasicBlock::Create(*Context, "unreachable", F); + new UnreachableInst(*Context, UnrBB); + } + + // Split the basic block before the selector. + BasicBlock *NewBB = SplitBlock(BB, SI, this); + + // Replace the terminator with an invoke of _Unwind_RaiseException. + BB->getTerminator()->eraseFromParent(); + InvokeInst::Create(UnwindFunction, UnrBB, NewBB, &Exception, + 1 + &Exception, "", BB); + + // The split off basic block is now a landing pad. + LandingPads.insert(NewBB); + + // Replace the exception argument in the selector call with a call to + // eh.exception. This is not really necessary but it makes things more + // regular. + Exception = CreateExceptionValueCall(NewBB); + SI->setOperand(1, Exception); + + ++NumLonelySelectors; + Changed = true; + + // All instructions still in the original basic block have been scanned. + // Move on to the next basic block. + break; + } + } + + return Changed; +} + +/// RectifySelectorCalls - Remove useless catch-all clauses from the ends of +/// selectors, or correct the selector result for the presence of the catch-all +/// if it is really needed. +bool DwarfEHPrepare::RectifySelectorCalls() { + // If the eh.selector intrinsic is not declared in the module then there is + // nothing to do. Speed up compilation by checking for this common case. + if (!F->getParent()->getFunction(Intrinsic::getName(Intrinsic::eh_selector))) + return false; + + bool Changed = false; + + for (BBSet::iterator I = LandingPads.begin(), E = LandingPads.end(); I != E; + ++I) + for (BasicBlock::iterator II = (*I)->begin(), IE = (*I)->end(); II != IE; ) + if (EHSelectorInst *SI = dyn_cast(II++)) { + // Found a call to eh.selector. Check whether it has a catch-all in the + // middle. + unsigned LastIndex = 0; + for (unsigned i = 3, e = SI->getNumOperands() - 1; i < e; ++i) { + Value *V = SI->getOperand(i); + if (V->stripPointerCasts() == CatchAll) { + // A catch-all. The catch-all at the end was not needed. + LastIndex = i; + break; + } else if (ConstantInt *FilterLength = dyn_cast(V)) { + // A cleanup or a filter. + unsigned Length = FilterLength->getZExtValue(); + if (Length == 0) + // A cleanup - skip it. + continue; + if (Length == 1) { + // A catch-all filter. Drop everything that follows. + LastIndex = i; + break; + } + // A filter, skip over the typeinfos. + i += Length - 1; + } + } + + if (LastIndex) { + // Drop the pointless catch-all from the end. In fact drop everything + // after LastIndex as an optimization. + SmallVector Args; + Args.reserve(LastIndex); + for (unsigned i = 1; i <= LastIndex; ++i) + Args.push_back(SI->getOperand(i)); + CallInst *CI = CallInst::Create(SI->getOperand(0), Args.begin(), + Args.end(), "", SI); + CI->takeName(SI); + SI->replaceAllUsesWith(CI); + SI->eraseFromParent(); + ++NumSelectorsSimplified; + } else if (!isa(CatchAll) && // Not a cleanup. + !SI->use_empty()) { + // Correct the selector value to return zero if the catch-all matches. + Constant *Zero = ConstantInt::getNullValue(Type::getInt32Ty(*Context)); + + // Create the new selector value, with placeholders instead of the + // real operands and make everyone use it. The reason for this round + // about approach is that the computation of the new value makes use + // of the old value, so we can't just compute it then do RAUW. + SelectInst *S = SelectInst::Create(ConstantInt::getFalse(*Context), + Zero, Zero, "", II); + SI->replaceAllUsesWith(S); + + // Now calculate the operands of the select. + IRBuilder<> Builder(*I, S); + + // Find the eh.typeid.for intrinsic if we didn't already. + if (!TypeIdIntrinsic) + TypeIdIntrinsic = Intrinsic::getDeclaration(F->getParent(), + Intrinsic::eh_typeid_for); + + // Obtain the id of the catch-all. + Value *CatchAllId = Builder.CreateCall(TypeIdIntrinsic, + ConstantExpr::getBitCast(CatchAll, Type::getInt8PtrTy(*Context))); + + // Compare it with the original selector result. If it matched then + // the selector result is zero, otherwise it is the original selector. + Value *MatchesCatchAll = Builder.CreateICmpEQ(SI, CatchAllId); + S->setOperand(0, MatchesCatchAll); + S->setOperand(2, SI); + ++NumSelectorsAdjusted; + } + + Changed = true; + break; + } + + return Changed; +} + +/// Make sure every landing pad has a selector in it. +bool DwarfEHPrepare::AddMissingSelectors() { + if (!Personality) + // We only know how to codegen invokes if there is a personality. + // FIXME: This results in wrong code. + return false; + + bool Changed = false; + + for (BBSet::iterator I = LandingPads.begin(), E = LandingPads.end(); I != E; + ++I) { + bool FoundSelector = false; + + // Check whether the landing pad already contains a call to eh.selector. + for (BasicBlock::iterator II = (*I)->begin(), IE = (*I)->end(); II != IE; + ++II) + if (isa(II)) { + FoundSelector = true; + break; + } + + if (FoundSelector) + continue; + + // Find the eh.selector intrinsic if we didn't already. + if (!SelectorIntrinsic) + SelectorIntrinsic = Intrinsic::getDeclaration(F->getParent(), + Intrinsic::eh_selector); + + // Get the exception object. + Instruction *Exception = CreateExceptionValueCall(*I); + + Value *Args[3] = { Exception, Personality, CatchAll }; + CallInst *Selector = CallInst::Create(SelectorIntrinsic, Args, Args + 3); + Selector->insertAfter(Exception); + + ++NumLonelyLandingPads; Changed = true; } @@ -275,7 +520,7 @@ bool DwarfEHPrepare::LowerUnwinds() { bool DwarfEHPrepare::MoveExceptionValueCalls() { // If the eh.exception intrinsic is not declared in the module then there is // nothing to do. Speed up compilation by checking for this common case. - if (!ExceptionValueIntrinsic && + if (!ExceptionIntrinsic && !F->getParent()->getFunction(Intrinsic::getName(Intrinsic::eh_exception))) return false; @@ -332,7 +577,7 @@ bool DwarfEHPrepare::PromoteStackTemporaries() { if (ExceptionValueVar && DT && DF && isAllocaPromotable(ExceptionValueVar)) { // Turn the exception temporary into registers and phi nodes if possible. std::vector Allocas(1, ExceptionValueVar); - PromoteMemToReg(Allocas, *DT, *DF, ExceptionValueVar->getContext()); + PromoteMemToReg(Allocas, *DT, *DF, *Context); return true; } return false; @@ -350,12 +595,12 @@ Instruction *DwarfEHPrepare::CreateExceptionValueCall(BasicBlock *BB) { return Start; // Find the eh.exception intrinsic if we didn't already. - if (!ExceptionValueIntrinsic) - ExceptionValueIntrinsic = Intrinsic::getDeclaration(F->getParent(), + if (!ExceptionIntrinsic) + ExceptionIntrinsic = Intrinsic::getDeclaration(F->getParent(), Intrinsic::eh_exception); // Create the call. - return CallInst::Create(ExceptionValueIntrinsic, "eh.value.call", Start); + return CallInst::Create(ExceptionIntrinsic, "eh.value.call", Start); } /// CreateValueLoad - Insert a load of the exception value stack variable @@ -373,7 +618,7 @@ Instruction *DwarfEHPrepare::CreateValueLoad(BasicBlock *BB) { // Create the temporary if we didn't already. if (!ExceptionValueVar) { ExceptionValueVar = new AllocaInst(PointerType::getUnqual( - Type::getInt8Ty(BB->getContext())), "eh.value", F->begin()->begin()); + Type::getInt8Ty(*Context)), "eh.value", F->begin()->begin()); ++NumStackTempsIntroduced; } @@ -388,6 +633,9 @@ bool DwarfEHPrepare::runOnFunction(Function &Fn) { DT = getAnalysisIfAvailable(); DF = getAnalysisIfAvailable(); ExceptionValueVar = 0; + Personality = 0; + CatchAll = 0; + Context = &Fn.getContext(); F = &Fn; // Ensure that only unwind edges end at landing pads (a landing pad is a @@ -397,7 +645,15 @@ bool DwarfEHPrepare::runOnFunction(Function &Fn) { // Turn unwind instructions into libcalls. Changed |= LowerUnwinds(); - // TODO: Move eh.selector calls to landing pads and combine them. + // Make sure that every call to eh.selector occurs in its own landing pad. + Changed |= MoveSelectorCalls(); + + // Remove useless catch-all clauses from the ends of selectors, or correct the + // selector result for the presence of the catch-all if it is really needed. + Changed |= RectifySelectorCalls(); + + // Make sure every landing pad has a selector in it. + Changed |= AddMissingSelectors(); // Move eh.exception calls to landing pads. Changed |= MoveExceptionValueCalls(); @@ -406,8 +662,8 @@ bool DwarfEHPrepare::runOnFunction(Function &Fn) { Changed |= FinishStackTemporaries(); // Turn any stack temporaries into registers if possible. - if (!CompileFast) - Changed |= PromoteStackTemporaries(); +//TODO if (!CompileFast) +//TODO Changed |= PromoteStackTemporaries(); LandingPads.clear(); diff --git a/lib/CodeGen/LLVMTargetMachine.cpp b/lib/CodeGen/LLVMTargetMachine.cpp index e58a9ca82c6..1000b2e3809 100644 --- a/lib/CodeGen/LLVMTargetMachine.cpp +++ b/lib/CodeGen/LLVMTargetMachine.cpp @@ -239,11 +239,11 @@ bool LLVMTargetMachine::addCommonCodeGenPasses(PassManagerBase &PM, { case ExceptionHandling::SjLj: // SjLj piggy-backs on dwarf for this bit. The cleanups done apply to both - PM.add(createDwarfEHPass(getTargetLowering(), OptLevel==CodeGenOpt::None)); + PM.add(createDwarfEHPass(getTargetLowering())); PM.add(createSjLjEHPass(getTargetLowering())); break; case ExceptionHandling::Dwarf: - PM.add(createDwarfEHPass(getTargetLowering(), OptLevel==CodeGenOpt::None)); + PM.add(createDwarfEHPass(getTargetLowering())); break; case ExceptionHandling::None: PM.add(createLowerInvokePass(getTargetLowering())); diff --git a/lib/CodeGen/SimpleRegisterCoalescing.cpp b/lib/CodeGen/SimpleRegisterCoalescing.cpp index 430df54081e..f8784f60f5e 100644 --- a/lib/CodeGen/SimpleRegisterCoalescing.cpp +++ b/lib/CodeGen/SimpleRegisterCoalescing.cpp @@ -1861,21 +1861,6 @@ bool SimpleRegisterCoalescing::RangeIsDefinedByCopyFromReg(LiveInterval &li, return false; } - -/// ValueLiveAt - Return true if the LiveRange pointed to by the given -/// iterator, or any subsequent range with the same value number, -/// is live at the given point. -bool SimpleRegisterCoalescing::ValueLiveAt(LiveInterval::iterator LRItr, - LiveIndex defPoint) const { - for (const VNInfo *valno = LRItr->valno; LRItr->valno == valno; ++LRItr) { - if (LRItr->contains(defPoint)) - return true; - } - - return false; -} - - /// SimpleJoin - Attempt to joint the specified interval into this one. The /// caller of this method must guarantee that the RHS only contains a single /// value number and that the RHS is not defined by a copy from this @@ -1922,7 +1907,7 @@ bool SimpleRegisterCoalescing::SimpleJoin(LiveInterval &LHS, LiveInterval &RHS){ if (!RangeIsDefinedByCopyFromReg(LHS, LHSIt, RHS.reg)) return false; // Nope, bail out. - if (ValueLiveAt(LHSIt, RHSIt->valno->def)) + if (LHSIt->contains(RHSIt->valno->def)) // Here is an interesting situation: // BB1: // vr1025 = copy vr1024 @@ -1960,7 +1945,7 @@ bool SimpleRegisterCoalescing::SimpleJoin(LiveInterval &LHS, LiveInterval &RHS){ // Otherwise, if this is a copy from the RHS, mark it as being merged // in. if (RangeIsDefinedByCopyFromReg(LHS, LHSIt, RHS.reg)) { - if (ValueLiveAt(LHSIt, RHSIt->valno->def)) + if (LHSIt->contains(RHSIt->valno->def)) // Here is an interesting situation: // BB1: // vr1025 = copy vr1024 diff --git a/lib/CodeGen/SimpleRegisterCoalescing.h b/lib/CodeGen/SimpleRegisterCoalescing.h index a381ae78afe..3ebe3a1f7de 100644 --- a/lib/CodeGen/SimpleRegisterCoalescing.h +++ b/lib/CodeGen/SimpleRegisterCoalescing.h @@ -201,11 +201,6 @@ namespace llvm { bool CanJoinInsertSubRegToPhysReg(unsigned DstReg, unsigned SrcReg, unsigned SubIdx, unsigned &RealDstReg); - /// ValueLiveAt - Return true if the LiveRange pointed to by the given - /// iterator, or any subsequent range with the same value number, - /// is live at the given point. - bool ValueLiveAt(LiveInterval::iterator LRItr, LiveIndex defPoint) const; - /// RangeIsDefinedByCopyFromReg - Return true if the specified live range of /// the specified live interval is defined by a copy from the specified /// register.