From cbb8badce8838ece47cb806a0399c77d76a7e11b Mon Sep 17 00:00:00 2001 From: Duncan Sands Date: Mon, 10 Dec 2007 19:09:40 +0000 Subject: Make PruneEH update the nounwind/noreturn attributes on functions as it calculates them. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@44802 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Transforms/IPO/PruneEH.cpp | 155 ++++++++++++++++++---------------- lib/Transforms/Scalar/SimplifyCFG.cpp | 2 +- 2 files changed, 81 insertions(+), 76 deletions(-) (limited to 'lib/Transforms') diff --git a/lib/Transforms/IPO/PruneEH.cpp b/lib/Transforms/IPO/PruneEH.cpp index 631b5f797a..b4bcd99518 100644 --- a/lib/Transforms/IPO/PruneEH.cpp +++ b/lib/Transforms/IPO/PruneEH.cpp @@ -9,8 +9,8 @@ // // This file implements a simple interprocedural pass which walks the // call-graph, turning invoke instructions into calls, iff the callee cannot -// throw an exception. It implements this as a bottom-up traversal of the -// call-graph. +// throw an exception, and marking functions 'nounwind' if they cannot throw. +// It implements this as a bottom-up traversal of the call-graph. // //===----------------------------------------------------------------------===// @@ -19,7 +19,6 @@ #include "llvm/CallGraphSCCPass.h" #include "llvm/Constants.h" #include "llvm/Function.h" -#include "llvm/Intrinsics.h" #include "llvm/Instructions.h" #include "llvm/Analysis/CallGraph.h" #include "llvm/ADT/SmallVector.h" @@ -38,14 +37,6 @@ namespace { static char ID; // Pass identification, replacement for typeid PruneEH() : CallGraphSCCPass((intptr_t)&ID) {} - /// DoesNotUnwind - This set contains all of the functions which we have - /// determined cannot unwind. - std::set DoesNotUnwind; - - /// DoesNotReturn - This set contains all of the functions which we have - /// determined cannot return normally (but might unwind). - std::set DoesNotReturn; - // runOnSCC - Analyze the SCC, performing the transformation if possible. bool runOnSCC(const std::vector &SCC); @@ -79,33 +70,41 @@ bool PruneEH::runOnSCC(const std::vector &SCC) { for (unsigned i = 0, e = SCC.size(); (!SCCMightUnwind || !SCCMightReturn) && i != e; ++i) { Function *F = SCC[i]->getFunction(); - if (F == 0 || (F->isDeclaration() && !F->getIntrinsicID())) { + if (F == 0) { SCCMightUnwind = true; SCCMightReturn = true; + } else if (F->isDeclaration()) { + SCCMightUnwind |= !F->isNoUnwind(); + SCCMightReturn |= !F->isNoReturn(); } else { - if (F->isDeclaration()) - SCCMightReturn = true; + bool CheckUnwind = !SCCMightUnwind && !F->isNoUnwind(); + bool CheckReturn = !SCCMightReturn && !F->isNoReturn(); + + if (!CheckUnwind && !CheckReturn) + continue; // Check to see if this function performs an unwind or calls an // unwinding function. for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB) { - if (isa(BB->getTerminator())) { // Uses unwind! + if (CheckUnwind && isa(BB->getTerminator())) { + // Uses unwind! SCCMightUnwind = true; - } else if (isa(BB->getTerminator())) { + } else if (CheckReturn && isa(BB->getTerminator())) { SCCMightReturn = true; } // Invoke instructions don't allow unwinding to continue, so we are // only interested in call instructions. - if (!SCCMightUnwind) + if (CheckUnwind && !SCCMightUnwind) for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) if (CallInst *CI = dyn_cast(I)) { - if (Function *Callee = CI->getCalledFunction()) { + if (CI->isNoUnwind()) { + // This call cannot throw. + } else if (Function *Callee = CI->getCalledFunction()) { CallGraphNode *CalleeNode = CG[Callee]; - // If the callee is outside our current SCC, or if it is not - // known to throw, then we might throw also. - if (std::find(SCC.begin(), SCC.end(), CalleeNode) == SCC.end()&& - !DoesNotUnwind.count(CalleeNode)) { + // If the callee is outside our current SCC then we may + // throw because it might. + if (std::find(SCC.begin(), SCC.end(), CalleeNode) == SCC.end()){ SCCMightUnwind = true; break; } @@ -121,12 +120,21 @@ bool PruneEH::runOnSCC(const std::vector &SCC) { } // If the SCC doesn't unwind or doesn't throw, note this fact. - if (!SCCMightUnwind) - for (unsigned i = 0, e = SCC.size(); i != e; ++i) - DoesNotUnwind.insert(SCC[i]); - if (!SCCMightReturn) - for (unsigned i = 0, e = SCC.size(); i != e; ++i) - DoesNotReturn.insert(SCC[i]); + if (!SCCMightUnwind || !SCCMightReturn) + for (unsigned i = 0, e = SCC.size(); i != e; ++i) { + const ParamAttrsList *PAL = SCC[i]->getFunction()->getParamAttrs(); + uint16_t RAttributes = PAL ? PAL->getParamAttrs(0) : 0; + + if (!SCCMightUnwind) + RAttributes |= ParamAttr::NoUnwind; + if (!SCCMightReturn) + RAttributes |= ParamAttr::NoReturn; + + ParamAttrsVector modVec; + modVec.push_back(ParamAttrsWithIndex::get(0, RAttributes)); + PAL = ParamAttrsList::getModified(PAL, modVec); + SCC[i]->getFunction()->setParamAttrs(PAL); + } for (unsigned i = 0, e = SCC.size(); i != e; ++i) { // Convert any invoke instructions to non-throwing functions in this node @@ -144,61 +152,58 @@ bool PruneEH::runOnSCC(const std::vector &SCC) { // function if we have invokes to non-unwinding functions or code after calls to // no-return functions. bool PruneEH::SimplifyFunction(Function *F) { - CallGraph &CG = getAnalysis(); bool MadeChange = false; for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB) { if (InvokeInst *II = dyn_cast(BB->getTerminator())) - if (Function *F = II->getCalledFunction()) - if (DoesNotUnwind.count(CG[F])) { - SmallVector Args(II->op_begin()+3, II->op_end()); - // Insert a call instruction before the invoke. - CallInst *Call = new CallInst(II->getCalledValue(), - Args.begin(), Args.end(), "", II); - Call->takeName(II); - Call->setCallingConv(II->getCallingConv()); - Call->setParamAttrs(II->getParamAttrs()); - - // Anything that used the value produced by the invoke instruction - // now uses the value produced by the call instruction. - II->replaceAllUsesWith(Call); - BasicBlock *UnwindBlock = II->getUnwindDest(); - UnwindBlock->removePredecessor(II->getParent()); - - // Insert a branch to the normal destination right before the - // invoke. - new BranchInst(II->getNormalDest(), II); - - // Finally, delete the invoke instruction! - BB->getInstList().pop_back(); + if (II->isNoUnwind()) { + SmallVector Args(II->op_begin()+3, II->op_end()); + // Insert a call instruction before the invoke. + CallInst *Call = new CallInst(II->getCalledValue(), + Args.begin(), Args.end(), "", II); + Call->takeName(II); + Call->setCallingConv(II->getCallingConv()); + Call->setParamAttrs(II->getParamAttrs()); + + // Anything that used the value produced by the invoke instruction + // now uses the value produced by the call instruction. + II->replaceAllUsesWith(Call); + BasicBlock *UnwindBlock = II->getUnwindDest(); + UnwindBlock->removePredecessor(II->getParent()); + + // Insert a branch to the normal destination right before the + // invoke. + new BranchInst(II->getNormalDest(), II); + + // Finally, delete the invoke instruction! + BB->getInstList().pop_back(); + + // If the unwind block is now dead, nuke it. + if (pred_begin(UnwindBlock) == pred_end(UnwindBlock)) + DeleteBasicBlock(UnwindBlock); // Delete the new BB. + + ++NumRemoved; + MadeChange = true; + } - // If the unwind block is now dead, nuke it. - if (pred_begin(UnwindBlock) == pred_end(UnwindBlock)) - DeleteBasicBlock(UnwindBlock); // Delete the new BB. + for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ) + if (CallInst *CI = dyn_cast(I++)) + if (CI->isNoReturn() && !isa(I)) { + // This call calls a function that cannot return. Insert an + // unreachable instruction after it and simplify the code. Do this + // by splitting the BB, adding the unreachable, then deleting the + // new BB. + BasicBlock *New = BB->splitBasicBlock(I); + + // Remove the uncond branch and add an unreachable. + BB->getInstList().pop_back(); + new UnreachableInst(BB); - ++NumRemoved; + DeleteBasicBlock(New); // Delete the new BB. MadeChange = true; + ++NumUnreach; + break; } - for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ) - if (CallInst *CI = dyn_cast(I++)) - if (Function *Callee = CI->getCalledFunction()) - if (DoesNotReturn.count(CG[Callee]) && !isa(I)) { - // This call calls a function that cannot return. Insert an - // unreachable instruction after it and simplify the code. Do this - // by splitting the BB, adding the unreachable, then deleting the - // new BB. - BasicBlock *New = BB->splitBasicBlock(I); - - // Remove the uncond branch and add an unreachable. - BB->getInstList().pop_back(); - new UnreachableInst(BB); - - DeleteBasicBlock(New); // Delete the new BB. - MadeChange = true; - ++NumUnreach; - break; - } - } return MadeChange; } diff --git a/lib/Transforms/Scalar/SimplifyCFG.cpp b/lib/Transforms/Scalar/SimplifyCFG.cpp index eb1ed4e60d..1d34d316a1 100644 --- a/lib/Transforms/Scalar/SimplifyCFG.cpp +++ b/lib/Transforms/Scalar/SimplifyCFG.cpp @@ -111,7 +111,7 @@ static bool MarkAliveBlocks(BasicBlock *BB, // canonicalizes unreachable insts into stores to null or undef. for (BasicBlock::iterator BBI = BB->begin(), E = BB->end(); BBI != E;++BBI){ if (CallInst *CI = dyn_cast(BBI)) { - if (CI->paramHasAttr(0, ParamAttr::NoReturn)) { + if (CI->isNoReturn()) { // If we found a call to a no-return function, insert an unreachable // instruction after it. Make sure there isn't *already* one there // though. -- cgit v1.2.3