Simplify this pass by using a depth-first iterator to ensure that all

operands are visited before the instructions themselves.

llvm-svn: 122647

1 files changed, 20 insertions, 39 deletions

diff --git a/llvm/lib/Transforms/Utils/SimplifyInstructions.cpp b/llvm/lib/Transforms/Utils/SimplifyInstructions.cpp
index 4205622037a..fc5cb7b7be2 100644
--- a/llvm/lib/Transforms/Utils/SimplifyInstructions.cpp
+++ b/llvm/lib/Transforms/Utils/SimplifyInstructions.cpp
@@ -18,13 +18,13 @@
 #include "llvm/Function.h"
 #include "llvm/Pass.h"
 #include "llvm/Type.h"
+#include "llvm/ADT/DepthFirstIterator.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/Dominators.h"
 #include "llvm/Analysis/InstructionSimplify.h"
 #include "llvm/Target/TargetData.h"
 #include "llvm/Transforms/Scalar.h"
 #include "llvm/Transforms/Utils/Local.h"
-#include <queue>
 using namespace llvm;
 
 STATISTIC(NumSimplified, "Number of redundant instructions removed");
@@ -42,49 +42,30 @@ 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>();
       bool Changed = false;
+      bool LocalChanged;
 
-      // Add all interesting instructions to the worklist.  These are processed
-      // in FIFO order, so instructions are usually visited before their uses.
-      std::queue<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;
-          }
-          // Add all others to the worklist.
-          Worklist.push(I);
-        }
+      do {
+        LocalChanged = false;
 
-      // Simplify everything in the worklist until the cows come home.
-      while (!Worklist.empty()) {
-        Instruction *I = Worklist.front();
-        Worklist.pop();
-        // Don't bother simplifying unused instructions.
-        if (I->use_empty()) continue;
-        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.
-        ++NumSimplified;
-        I->replaceAllUsesWith(V);
-        for (Value::use_iterator UI = I->use_begin(), UE = I->use_end();
-             UI != UE; ++UI)
-          Worklist.push(cast<Instruction>(*UI));
-        Changed = true;
-      }
+        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++;
+            // Don't bother simplifying unused instructions.
+            if (!I->use_empty())
+              if (Value *V = SimplifyInstruction(I, TD, DT)) {
+                I->replaceAllUsesWith(V);
+                LocalChanged = true;
+                ++NumSimplified;
+              }
+            LocalChanged |= RecursivelyDeleteTriviallyDeadInstructions(I);
+          }
 
-      // Finally, run over the function zapping any dead instructions.
-      for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
-        for (BasicBlock::iterator BI = BB->begin(), BE = BB->end(); BI != BE;)
-          Changed |= RecursivelyDeleteTriviallyDeadInstructions(BI++);
+        Changed |= LocalChanged;
+      } while (LocalChanged);
 
       return Changed;
     }