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

7 files changed, 128 insertions, 103 deletions

diff --git a/include/llvm/Function.h b/include/llvm/Function.h
index ece095d380..2abde45f8b 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 2d721bb414..bc5e0b4af9 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 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<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,61 +152,58 @@ 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());
-
-          // 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<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());
+
+        // 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<CallInst>(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);
 
-          ++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<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);
-
-            // 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<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.
diff --git a/test/Transforms/PruneEH/simplenoreturntest.ll b/test/Transforms/PruneEH/simplenoreturntest.ll
index 4a998b1cc3..d2bd50cf5d 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;
 
-int %caller() {
-	 ; noreturn never returns, so the ret is unreachable.
-	call void %noreturn()
-	ret int 17
+define i32 @caller() {
+	call void @noreturn( )
+	ret i32 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
 }
diff --git a/test/Transforms/PruneEH/simpletest.ll b/test/Transforms/PruneEH/simpletest.ll
new file mode 100644
index 0000000000..678e8d76b6
--- /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 c368534eda..0000000000
--- 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
-}