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

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

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

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
+// throw an exception, and marking functions 'nounwind' if they cannot throw.
-// call-graph.
+// 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())
+      bool CheckUnwind = !SCCMightUnwind && !F->isNoUnwind();
-        SCCMightReturn = true;
+      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
+                // If the callee is outside our current SCC then we may
-                // known to throw, then we might throw also.
+                // throw because it might.
-                if (std::find(SCC.begin(), SCC.end(), CalleeNode) == SCC.end()&&
+                if (std::find(SCC.begin(), SCC.end(), CalleeNode) == SCC.end()){
-                    !DoesNotUnwind.count(CalleeNode)) {
                   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 || !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)
-    for (unsigned i = 0, e = SCC.size(); i != e; ++i)
+        RAttributes |= ParamAttr::NoUnwind;
-      DoesNotUnwind.insert(SCC[i]);
       if (!SCCMightReturn)
-    for (unsigned i = 0, e = SCC.size(); i != e; ++i)
+        RAttributes |= ParamAttr::NoReturn;
-      DoesNotReturn.insert(SCC[i]);
+
+      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,12 +152,10 @@ 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 (II->isNoUnwind()) {
-        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(),
@@ -181,8 +187,7 @@ bool PruneEH::SimplifyFunction(Function *F) {
 
     for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; )
       if (CallInst *CI = dyn_cast<CallInst>(I++))
-        if (Function *Callee = CI->getCalledFunction())
+        if (CI->isNoReturn() && !isa<UnreachableInst>(I)) {
-          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

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.

test/Transforms/PruneEH/simplenoreturntest.ll

@@ -1,17 +1,13 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -prune-eh | llvm-dis | \
+; RUN: llvm-as < %s | opt -prune-eh | llvm-dis | not grep {ret i32}
-; RUN:   not grep {ret i32}
 
-void %noreturn() {
+declare void @noreturn() noreturn;
-	unwind
+
+define i32 @caller() {
+	call void @noreturn( )
+	ret i32 17
 }
 
-int %caller() {
+define i32 @caller2() {
-	 ; noreturn never returns, so the ret is unreachable.
+	%T = call i32 @caller( )		; <i32> [#uses=1]
-	call void %noreturn()
+	ret i32 %T
-	ret int 17
-}
-
-int %caller2() {
-	%T = call int %caller()
-	ret int %T            ;; this is also unreachable!
 }

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

test/Transforms/PruneEH/simpletest.llx

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