We actually don't have spiff anymore

[oota-llvm.git] / lib / Transforms / IPO / PruneEH.cpp

diff --git a/lib/Transforms/IPO/PruneEH.cpp b/lib/Transforms/IPO/PruneEH.cpp
index 74e0d33d4127e43fd888c2355f9faf8d2bd6d603..418c3528d305d8f0d39afe64bc29ecd9bd537cca 100644 (file)
--- a/lib/Transforms/IPO/PruneEH.cpp
+++ b/lib/Transforms/IPO/PruneEH.cpp
@@ -51,21 +51,43 @@ bool PruneEH::runOnSCC(const std::vector<CallGraphNode *> &SCC) {
   // obviously the SCC might throw.
   //
   bool SCCMightThrow = false;
-  for (unsigned i = 0, e = SCC.size(); i != e; ++i)
-    if (!DoesNotThrow.count(SCC[i]) &&          // Calls maybe throwing fn
-        // Make sure this is not one of the fn's in the SCC.
-        std::find(SCC.begin(), SCC.end(), SCC[i]) == SCC.end()) {
-      SCCMightThrow = true; break;
-    } else if (Function *F = SCC[i]->getFunction())
-      if (F->isExternal()) {
-        SCCMightThrow = true; break;
-      } else {
-        for (Function::iterator I = F->begin(), E = F->end(); I != E; ++I)
-          if (isa<UnwindInst>(I->getTerminator())) {  // Uses unwind!
-            SCCMightThrow = true; break;
+  for (unsigned i = 0, e = SCC.size(); !SCCMightThrow && i != e; ++i) {
+    Function *F = SCC[i]->getFunction();
+    if (F == 0 || (F->isExternal() && !F->getIntrinsicID())) {
+      SCCMightThrow = true;
+    } else {
+      // 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!
+          SCCMightThrow = true;
+          break;
+        }
+
+        // Invoke instructions don't allow unwinding to continue, so we are
+        // only interested in call instructions.
+        for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I)
+          if (CallInst *CI = dyn_cast<CallInst>(I)) {
+            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()&&
+                  !DoesNotThrow.count(CalleeNode)) {
+                SCCMightThrow = true;
+                break;
+              }
+                
+            } else {
+              // Indirect call, it might throw.
+              SCCMightThrow = true;
+              break;
+            }
           }
+        if (SCCMightThrow) break;
       }
-
+    }
+  }
   bool MadeChange = false;
 
   for (unsigned i = 0, e = SCC.size(); i != e; ++i) {
@@ -91,6 +113,7 @@ bool PruneEH::runOnSCC(const std::vector<CallGraphNode *> &SCC) {
               // Anything that used the value produced by the invoke instruction
               // now uses the value produced by the call instruction.
               II->replaceAllUsesWith(Call);
+              II->getUnwindDest()->removePredecessor(II->getParent());
           
               // Insert a branch to the normal destination right before the
               // invoke.