Speed up instsimplify by about 10-15% by not bothering to retry

[oota-llvm.git] / lib / Transforms / Utils / SimplifyInstructions.cpp

diff --git a/lib/Transforms/Utils/SimplifyInstructions.cpp b/lib/Transforms/Utils/SimplifyInstructions.cpp
index 6074a5f2c21e0a40857b898e71b6b9fc846f9c95..ac005f95b33a0073857d1b81e49462288e456c5e 100644 (file)
--- a/lib/Transforms/Utils/SimplifyInstructions.cpp
+++ b/lib/Transforms/Utils/SimplifyInstructions.cpp
@@ -18,6 +18,8 @@
 #include "llvm/Function.h"
 #include "llvm/Pass.h"
 #include "llvm/Type.h"
+#include "llvm/ADT/DepthFirstIterator.h"
+#include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/Dominators.h"
 #include "llvm/Analysis/InstructionSimplify.h"
@@ -41,45 +43,40 @@ namespace {
 
     /// runOnFunction - Remove instructions that simplify.
     bool runOnFunction(Function &F) {
-      const TargetData *TD = getAnalysisIfAvailable<TargetData>();
       const DominatorTree *DT = getAnalysisIfAvailable<DominatorTree>();
+      const TargetData *TD = getAnalysisIfAvailable<TargetData>();
+      SmallPtrSet<const Instruction*, 8> S1, S2, *ToSimplify = &S1, *Next = &S2;
       bool Changed = false;
 
-      // Add all interesting instructions to the worklist.
-      std::set<Instruction*> Worklist;
-      for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
-        for (BasicBlock::iterator BI = BB->begin(), BE = BB->end(); BI != BE;) {
-          Instruction *I = BI++;
-          // Zap any dead instructions.
-          if (isInstructionTriviallyDead(I)) {
-            I->eraseFromParent();
-            Changed = true;
-            continue;
+      do {
+        for (df_iterator<BasicBlock*> DI = df_begin(&F.getEntryBlock()),
+             DE = df_end(&F.getEntryBlock()); DI != DE; ++DI)
+          for (BasicBlock::iterator BI = DI->begin(), BE = DI->end(); BI != BE;) {
+            Instruction *I = BI++;
+            // The first time through the loop ToSimplify is empty and we try to
+            // simplify all instructions.  On later iterations ToSimplify is not
+            // empty and we only bother simplifying instructions that are in it.
+            if (!ToSimplify->empty() && !ToSimplify->count(I))
+              continue;
+            // Don't waste time simplifying unused instructions.
+            if (!I->use_empty())
+              if (Value *V = SimplifyInstruction(I, TD, DT)) {
+                // Mark all uses for resimplification next time round the loop.
+                for (Value::use_iterator UI = I->use_begin(), UE = I->use_end();
+                     UI != UE; ++UI)
+                  Next->insert(cast<Instruction>(*UI));
+                I->replaceAllUsesWith(V);
+                ++NumSimplified;
+                Changed = true;
+              }
+            Changed |= RecursivelyDeleteTriviallyDeadInstructions(I);
           }
-          // Add all others to the worklist.
-          Worklist.insert(I);
-        }
-
-      // Simplify everything in the worklist until the cows come home.
-      while (!Worklist.empty()) {
-        Instruction *I = *Worklist.begin();
-        Worklist.erase(Worklist.begin());
-        Value *V = SimplifyInstruction(I, TD, DT);
-        if (!V) continue;
 
-        // This instruction simplifies!  Replace it with its simplification and
-        // add all uses to the worklist, since they may now simplify.
-        I->replaceAllUsesWith(V);
-        for (Value::use_iterator UI = I->use_begin(), UE = I->use_end();
-             UI != UE; ++UI)
-          // In unreachable code an instruction can use itself, in which case
-          // don't add it to the worklist since we are about to erase it.
-          if (*UI != I) Worklist.insert(cast<Instruction>(*UI));
-        if (isInstructionTriviallyDead(I))
-          I->eraseFromParent();
-        ++NumSimplified;
-        Changed = true;
-      }
+        // Place the list of instructions to simplify on the next loop iteration
+        // into ToSimplify.
+        std::swap(ToSimplify, Next);
+        Next->clear();
+      } while (!ToSimplify->empty());
 
       return Changed;
     }