Changes For Bug 352

[oota-llvm.git] / lib / Transforms / Scalar / ADCE.cpp

diff --git a/lib/Transforms/Scalar/ADCE.cpp b/lib/Transforms/Scalar/ADCE.cpp
index afc24f95f11b0658aad8368d37ab2f449214c511..5770bb692c23196095a9040e1ecfef85e3af95d3 100644 (file)
--- a/lib/Transforms/Scalar/ADCE.cpp
+++ b/lib/Transforms/Scalar/ADCE.cpp
@@ -23,10 +23,10 @@
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include "llvm/Transforms/Utils/Local.h"
 #include "llvm/Transforms/Utils/UnifyFunctionExitNodes.h"
-#include "Support/Debug.h"
-#include "Support/DepthFirstIterator.h"
-#include "Support/Statistic.h"
-#include "Support/STLExtras.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/ADT/DepthFirstIterator.h"
+#include "llvm/ADT/Statistic.h"
+#include "llvm/ADT/STLExtras.h"
 #include <algorithm>
 using namespace llvm;
 
@@ -43,7 +43,6 @@ namespace {
 //
 class ADCE : public FunctionPass {
   Function *Func;                       // The function that we are working on
-  AliasAnalysis *AA;                    // Current AliasAnalysis object
   std::vector<Instruction*> WorkList;   // Instructions that just became live
   std::set<Instruction*>    LiveSet;    // The set of live instructions
 
@@ -55,7 +54,6 @@ public:
   //
   virtual bool runOnFunction(Function &F) {
     Func = &F;
-    AA = &getAnalysis<AliasAnalysis>();
     bool Changed = doADCE();
     assert(WorkList.empty());
     LiveSet.clear();
@@ -94,13 +92,13 @@ private:
 
   inline void markInstructionLive(Instruction *I) {
     if (LiveSet.count(I)) return;
-    DEBUG(std::cerr << "Insn Live: " << I);
+    DEBUG(std::cerr << "Insn Live: " << *I);
     LiveSet.insert(I);
     WorkList.push_back(I);
   }
 
   inline void markTerminatorLive(const BasicBlock *BB) {
-    DEBUG(std::cerr << "Terminator Live: " << BB->getTerminator());
+    DEBUG(std::cerr << "Terminator Live: " << *BB->getTerminator());
     markInstructionLive(const_cast<TerminatorInst*>(BB->getTerminator()));
   }
 };
@@ -144,9 +142,10 @@ bool ADCE::dropReferencesOfDeadInstructionsInLiveBlock(BasicBlock *BB) {
         // #arguments != #predecessors, so we remove them now.
         //
         PN->replaceAllUsesWith(Constant::getNullValue(PN->getType()));
-        
+
         // Delete the instruction...
-        I = BB->getInstList().erase(I);
+        ++I;
+        BB->getInstList().erase(PN);
         Changed = true;
         ++NumInstRemoved;
       } else {
@@ -183,20 +182,49 @@ TerminatorInst *ADCE::convertToUnconditionalBranch(TerminatorInst *TI) {
 bool ADCE::doADCE() {
   bool MadeChanges = false;
 
+  AliasAnalysis &AA = getAnalysis<AliasAnalysis>();
+
+
+  // Iterate over all invokes in the function, turning invokes into calls if
+  // they cannot throw.
+  for (Function::iterator BB = Func->begin(), E = Func->end(); BB != E; ++BB)
+    if (InvokeInst *II = dyn_cast<InvokeInst>(BB->getTerminator()))
+      if (Function *F = II->getCalledFunction())
+        if (AA.onlyReadsMemory(F)) {
+          // The function cannot unwind.  Convert it to a call with a branch
+          // after it to the normal destination.
+          std::vector<Value*> Args(II->op_begin()+3, II->op_end());
+          std::string Name = II->getName(); II->setName("");
+          Instruction *NewCall = new CallInst(F, Args, Name, II);
+          II->replaceAllUsesWith(NewCall);
+          new BranchInst(II->getNormalDest(), II);
+
+          // Update PHI nodes in the unwind destination
+          II->getUnwindDest()->removePredecessor(BB);
+          BB->getInstList().erase(II);
+
+          if (NewCall->use_empty()) {
+            BB->getInstList().erase(NewCall);
+            ++NumCallRemoved;
+          }
+        }
+
   // Iterate over all of the instructions in the function, eliminating trivially
   // dead instructions, and marking instructions live that are known to be 
   // needed.  Perform the walk in depth first order so that we avoid marking any
   // instructions live in basic blocks that are unreachable.  These blocks will
   // be eliminated later, along with the instructions inside.
   //
-  for (df_iterator<Function*> BBI = df_begin(Func), BBE = df_end(Func);
-       BBI != BBE; ++BBI) {
+  std::set<BasicBlock*> ReachableBBs;
+  for (df_ext_iterator<BasicBlock*>
+         BBI = df_ext_begin(&Func->front(), ReachableBBs),
+         BBE = df_ext_end(&Func->front(), ReachableBBs); BBI != BBE; ++BBI) {
     BasicBlock *BB = *BBI;
     for (BasicBlock::iterator II = BB->begin(), EI = BB->end(); II != EI; ) {
       Instruction *I = II++;
       if (CallInst *CI = dyn_cast<CallInst>(I)) {
         Function *F = CI->getCalledFunction();
-        if (F && AA->onlyReadsMemory(F)) {
+        if (F && AA.onlyReadsMemory(F)) {
           if (CI->use_empty()) {
             BB->getInstList().erase(CI);
             ++NumCallRemoved;
@@ -204,25 +232,6 @@ bool ADCE::doADCE() {
         } else {
           markInstructionLive(I);
         }
-      } else if (InvokeInst *II = dyn_cast<InvokeInst>(I)) {
-        Function *F = II->getCalledFunction();
-        if (F && AA->onlyReadsMemory(F)) {
-          // The function cannot unwind.  Convert it to a call with a branch
-          // after it to the normal destination.
-          std::vector<Value*> Args(II->op_begin()+1, II->op_end());
-          std::string Name = II->getName(); II->setName("");
-          Instruction *NewCall = new CallInst(F, Args, Name, II);
-          II->replaceAllUsesWith(NewCall);
-          new BranchInst(II->getNormalDest(), II);
-          BB->getInstList().erase(II);
-
-          if (NewCall->use_empty()) {
-            BB->getInstList().erase(NewCall);
-            ++NumCallRemoved;
-          }
-        } else {
-          markInstructionLive(I);
-        }
       } else if (I->mayWriteToMemory() || isa<ReturnInst>(I) ||
                  isa<UnwindInst>(I)) {
        markInstructionLive(I);
@@ -272,6 +281,7 @@ bool ADCE::doADCE() {
     WorkList.pop_back();
 
     BasicBlock *BB = I->getParent();
+    if (!ReachableBBs.count(BB)) continue;
     if (!AliveBlocks.count(BB)) {     // Basic block not alive yet...
       AliveBlocks.insert(BB);         // Block is now ALIVE!
       markBlockAlive(BB);             // Make it so now!
@@ -497,8 +507,11 @@ bool ADCE::doADCE() {
       for (BasicBlock::iterator II = BI->begin(); II != --BI->end(); )
         if (!LiveSet.count(II)) {             // Is this instruction alive?
           // Nope... remove the instruction from it's basic block...
+          if (isa<CallInst>(II))
+            ++NumCallRemoved;
+          else
+            ++NumInstRemoved;
           II = BI->getInstList().erase(II);
-          ++NumInstRemoved;
           MadeChanges = true;
         } else {
           ++II;