RPCS3/llvm
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm.git synced 2025-01-18 07:52:35 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Make PruneEH update the nounwind/noreturn attributes

Browse Source 
on functions as it calculates them.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@44802 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Duncan Sands 2007-12-10 19:09:40 +00:00
parent 1eff70451f
commit cbb8badce8
7 changed files with 123 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
include/llvm/Function.h
View File

@ -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);

10
include/llvm/Instructions.h
View File

@ -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);

143
lib/Transforms/IPO/PruneEH.cpp
View File

@ -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<CallGraphNode*> DoesNotUnwind;
/// DoesNotReturn - This set contains all of the functions which we have
/// determined cannot return normally (but might unwind).
std::set<CallGraphNode*> DoesNotReturn;
// runOnSCC - Analyze the SCC, performing the transformation if possible.
bool runOnSCC(const std::vector<CallGraphNode *> &SCC);
@ -79,33 +70,41 @@ bool PruneEH::runOnSCC(const std::vector<CallGraphNode *> &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<UnwindInst>(BB->getTerminator())) { // Uses unwind!
if (CheckUnwind && isa<UnwindInst>(BB->getTerminator())) {
// Uses unwind!
SCCMightUnwind = true;
} else if (isa<ReturnInst>(BB->getTerminator())) {
} else if (CheckReturn && isa<ReturnInst>(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<CallInst>(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<CallGraphNode *> &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<CallGraphNode *> &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<CallGraph>();
bool MadeChange = false;
for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB) {
if (InvokeInst *II = dyn_cast<InvokeInst>(BB->getTerminator()))
if (Function *F = II->getCalledFunction())
if (DoesNotUnwind.count(CG[F])) {
SmallVector<Value*, 8> 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<Value*, 8> 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<CallInst>(I++))
if (Function *Callee = CI->getCalledFunction())
if (DoesNotReturn.count(CG[Callee]) && !isa<UnreachableInst>(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<UnreachableInst>(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;

2
lib/Transforms/Scalar/SimplifyCFG.cpp
View File

@ -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<CallInst>(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.

22
test/Transforms/PruneEH/simplenoreturntest.ll
View File

@ -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( ) ; <i32> [#uses=1]
ret i32 %T
}

19
test/Transforms/PruneEH/simpletest.ll Normal file
View File

@ -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
}

15
test/Transforms/PruneEH/simpletest.llx
View File

@ -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
}