From cbb8badce8838ece47cb806a0399c77d76a7e11b Mon Sep 17 00:00:00 2001 From: Duncan Sands Date: Mon, 10 Dec 2007 19:09:40 +0000 Subject: [PATCH] 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 --- include/llvm/Function.h | 10 ++ include/llvm/Instructions.h | 10 ++ lib/Transforms/IPO/PruneEH.cpp | 143 +++++++++--------- lib/Transforms/Scalar/SimplifyCFG.cpp | 2 +- test/Transforms/PruneEH/simplenoreturntest.ll | 22 ++- test/Transforms/PruneEH/simpletest.ll | 19 +++ test/Transforms/PruneEH/simpletest.llx | 15 -- 7 files changed, 123 insertions(+), 98 deletions(-) create mode 100644 test/Transforms/PruneEH/simpletest.ll delete mode 100644 test/Transforms/PruneEH/simpletest.llx diff --git a/include/llvm/Function.h b/include/llvm/Function.h index ece095d3808..2abde45f8b3 100644 --- a/include/llvm/Function.h +++ b/include/llvm/Function.h @@ -165,6 +165,16 @@ public: return ParamAttrs && ParamAttrs->paramHasAttr(i, attr); } + /// @brief Determine if the function cannot return. + bool isNoReturn() const { + return paramHasAttr(0, ParamAttr::NoReturn); + } + + /// @brief Determine if the function cannot unwind. + bool isNoUnwind() const { + return paramHasAttr(0, ParamAttr::NoUnwind); + } + /// @brief Determine if the function does not access memory. bool doesNotAccessMemory() const { return paramHasAttr(0, ParamAttr::ReadNone); diff --git a/include/llvm/Instructions.h b/include/llvm/Instructions.h index 2d721bb4147..bc5e0b4af9c 100644 --- a/include/llvm/Instructions.h +++ b/include/llvm/Instructions.h @@ -937,6 +937,11 @@ public: return doesNotAccessMemory() || paramHasAttr(0, ParamAttr::ReadOnly); } + /// @brief Determine if the call cannot return. + bool isNoReturn() const { + return paramHasAttr(0, ParamAttr::NoReturn); + } + /// @brief Determine if the call cannot unwind. bool isNoUnwind() const { return paramHasAttr(0, ParamAttr::NoUnwind); @@ -1736,6 +1741,11 @@ public: return doesNotAccessMemory() || paramHasAttr(0, ParamAttr::ReadOnly); } + /// @brief Determine if the call cannot return. + bool isNoReturn() const { + return paramHasAttr(0, ParamAttr::NoReturn); + } + /// @brief Determine if the call cannot unwind. bool isNoUnwind() const { return paramHasAttr(0, ParamAttr::NoUnwind); diff --git a/lib/Transforms/IPO/PruneEH.cpp b/lib/Transforms/IPO/PruneEH.cpp index 631b5f797a2..b4bcd995189 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,60 +152,57 @@ 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()); + 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()); + // 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); + // 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(); + // 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. + // 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; - } + ++NumRemoved; + MadeChange = true; + } 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); + 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); + // 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; - } + 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 eb1ed4e60d3..1d34d316a1d 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. diff --git a/test/Transforms/PruneEH/simplenoreturntest.ll b/test/Transforms/PruneEH/simplenoreturntest.ll index 4a998b1cc36..d2bd50cf5da 100644 --- a/test/Transforms/PruneEH/simplenoreturntest.ll +++ b/test/Transforms/PruneEH/simplenoreturntest.ll @@ -1,17 +1,13 @@ -; RUN: llvm-upgrade < %s | llvm-as | opt -prune-eh | llvm-dis | \ -; RUN: not grep {ret i32} +; RUN: llvm-as < %s | opt -prune-eh | llvm-dis | not grep {ret i32} -void %noreturn() { - unwind +declare void @noreturn() noreturn; + +define i32 @caller() { + call void @noreturn( ) + ret i32 17 } -int %caller() { - ; noreturn never returns, so the ret is unreachable. - call void %noreturn() - ret int 17 -} - -int %caller2() { - %T = call int %caller() - ret int %T ;; this is also unreachable! +define i32 @caller2() { + %T = call i32 @caller( ) ; [#uses=1] + ret i32 %T } diff --git a/test/Transforms/PruneEH/simpletest.ll b/test/Transforms/PruneEH/simpletest.ll new file mode 100644 index 00000000000..678e8d76b68 --- /dev/null +++ b/test/Transforms/PruneEH/simpletest.ll @@ -0,0 +1,19 @@ +; RUN: llvm-as < %s | opt -prune-eh | llvm-dis | not grep invoke + +declare void @nounwind() nounwind + +define internal void @foo() { + call void @nounwind() + ret void +} + +define i32 @caller() { + invoke void @foo( ) + to label %Normal unwind label %Except + +Normal: ; preds = %0 + ret i32 0 + +Except: ; preds = %0 + ret i32 1 +} diff --git a/test/Transforms/PruneEH/simpletest.llx b/test/Transforms/PruneEH/simpletest.llx deleted file mode 100644 index c368534eda8..00000000000 --- a/test/Transforms/PruneEH/simpletest.llx +++ /dev/null @@ -1,15 +0,0 @@ -; RUN: llvm-upgrade < %s | llvm-as | opt -prune-eh | llvm-dis | not grep invoke - -implementation - -internal void %foo() { - ret void ; does not throw -} - -int %caller() { - invoke void %foo() to label %Normal except label %Except -Normal: - ret int 0 -Except: - ret int 1 -}