[llvm-commits] [llvm] r122336 - /llvm/trunk/lib/Transforms/Utils/SimplifyInstructions.cpp

[Duncan Sands]

Author: baldrick
Date: Tue Dec 21 10:12:03 2010
New Revision: 122336

URL: http://llvm.org/viewvc/llvm-project?rev=122336&view=rev
Log:
If an instruction simplifies, try again to simplify any uses of it.  This is
not very important since the pass is only used for testing, but it does make
it more realistic.  Suggested by Frits van Bommel.

Modified:
    llvm/trunk/lib/Transforms/Utils/SimplifyInstructions.cpp

Modified: llvm/trunk/lib/Transforms/Utils/SimplifyInstructions.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/SimplifyInstructions.cpp?rev=122336&r1=122335&r2=122336&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Utils/SimplifyInstructions.cpp (original)
+++ llvm/trunk/lib/Transforms/Utils/SimplifyInstructions.cpp Tue Dec 21 10:12:03 2010
@@ -23,6 +23,7 @@
 #include "llvm/Analysis/InstructionSimplify.h"
 #include "llvm/Target/TargetData.h"
 #include "llvm/Transforms/Scalar.h"
+#include "llvm/Transforms/Utils/Local.h"
 using namespace llvm;
 
 STATISTIC(NumSimplified, "Number of redundant instructions removed");
@@ -40,19 +41,46 @@
 
     /// runOnFunction - Remove instructions that simplify.
     bool runOnFunction(Function &F) {
-      bool Changed = false;
       const TargetData *TD = getAnalysisIfAvailable<TargetData>();
       const DominatorTree *DT = getAnalysisIfAvailable<DominatorTree>();
+      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++;
-          if (Value *V = SimplifyInstruction(I, TD, DT)) {
-            I->replaceAllUsesWith(V);
+          // Zap any dead instructions.
+          if (isInstructionTriviallyDead(I)) {
             I->eraseFromParent();
             Changed = true;
-            ++NumSimplified;
+            continue;
           }
+          // 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;
+      }
+
       return Changed;
     }
   };