remove doConstantPropagation and dceInstruction, they are just

wrappers around the interesting code and use an obscure iterator
abstraction that dates back many many years.

Move EraseDeadInstructions to Transforms/Utils and name it
RecursivelyDeleteTriviallyDeadInstructions.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@60191 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/Transforms/Utils/Local.h b/include/llvm/Transforms/Utils/Local.h
index 42927297565768befaa8596d3f9642c98311ddf7..65438aa5e4ad595218a2cb4d231122359d6e5290 100644 (file)
--- a/include/llvm/Transforms/Utils/Local.h
+++ b/include/llvm/Transforms/Utils/Local.h
@@ -26,14 +26,9 @@ class ConstantExpr;
 class TargetData;
 
 //===----------------------------------------------------------------------===//
-//  Local constant propagation...
+//  Local constant propagation.
 //
 
-/// doConstantPropagation - Constant prop a specific instruction.  Returns true
-/// and potentially moves the iterator if constant propagation was performed.
-///
-bool doConstantPropagation(BasicBlock::iterator &I, const TargetData *TD = 0);
-
 /// ConstantFoldTerminator - If a terminator instruction is predicated on a
 /// constant value, convert it into an unconditional branch to the constant
 /// destination.  This is a nontrivial operation because the successors of this
@@ -42,7 +37,7 @@ bool doConstantPropagation(BasicBlock::iterator &I, const TargetData *TD = 0);
 bool ConstantFoldTerminator(BasicBlock *BB);
 
 //===----------------------------------------------------------------------===//
-//  Local dead code elimination...
+//  Local dead code elimination.
 //
 
 /// isInstructionTriviallyDead - Return true if the result produced by the
@@ -50,14 +45,12 @@ bool ConstantFoldTerminator(BasicBlock *BB);
 ///
 bool isInstructionTriviallyDead(Instruction *I);
 
-
-/// dceInstruction - Inspect the instruction at *BBI and figure out if it
-/// isTriviallyDead.  If so, remove the instruction and update the iterator to
-/// point to the instruction that immediately succeeded the original
-/// instruction.
-///
-bool dceInstruction(BasicBlock::iterator &BBI);
-
+  
+/// RecursivelyDeleteTriviallyDeadInstructions - If the specified value is a
+/// trivially dead instruction, delete it.  If that makes any of its operands
+/// trivially dead, delete them too, recursively.
+void RecursivelyDeleteTriviallyDeadInstructions(Value *V);
+    
 //===----------------------------------------------------------------------===//
 //  Control Flow Graph Restructuring...
 //

diff --git a/lib/Transforms/Scalar/CodeGenPrepare.cpp b/lib/Transforms/Scalar/CodeGenPrepare.cpp
index 9bf39911b6c697f80a2059766b225f506fd9f2a8..e6b7497d6bcadc9ff6cd206fc67c16b227f82d77 100644 (file)
--- a/lib/Transforms/Scalar/CodeGenPrepare.cpp
+++ b/lib/Transforms/Scalar/CodeGenPrepare.cpp
@@ -454,26 +454,6 @@ static bool OptimizeCmpExpression(CmpInst *CI) {
   return MadeChange;
 }
 
-/// EraseDeadInstructions - Erase any dead instructions, recursively.
-static void EraseDeadInstructions(Value *V) {
-  Instruction *I = dyn_cast<Instruction>(V);
-  if (!I || !I->use_empty()) return;
-
-  SmallPtrSet<Instruction*, 16> Insts;
-  Insts.insert(I);
-
-  while (!Insts.empty()) {
-    I = *Insts.begin();
-    Insts.erase(I);
-    if (isInstructionTriviallyDead(I)) {
-      for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i)
-        if (Instruction *U = dyn_cast<Instruction>(I->getOperand(i)))
-          Insts.insert(U);
-      I->eraseFromParent();
-    }
-  }
-}
-
 //===----------------------------------------------------------------------===//
 // Addressing Mode Analysis and Optimization
 //===----------------------------------------------------------------------===//
@@ -1234,7 +1214,7 @@ bool CodeGenPrepare::OptimizeMemoryInst(Instruction *MemoryInst, Value *Addr,
   MemoryInst->replaceUsesOfWith(Addr, SunkAddr);
 
   if (Addr->use_empty())
-    EraseDeadInstructions(Addr);
+    RecursivelyDeleteTriviallyDeadInstructions(Addr);
   return true;
 }
 

diff --git a/lib/Transforms/Utils/Local.cpp b/lib/Transforms/Utils/Local.cpp
index efb902267d99d835b746e7219c91389fbd5efe82..e3a0917eb02bd2275477331f58372ca0a3521d9e 100644 (file)
--- a/lib/Transforms/Utils/Local.cpp
+++ b/lib/Transforms/Utils/Local.cpp
@@ -22,30 +22,13 @@
 #include "llvm/Target/TargetData.h"
 #include "llvm/Support/GetElementPtrTypeIterator.h"
 #include "llvm/Support/MathExtras.h"
-#include <cerrno>
+#include "llvm/ADT/SmallPtrSet.h"
 using namespace llvm;
 
 //===----------------------------------------------------------------------===//
-//  Local constant propagation...
+//  Local constant propagation.
 //
 
-/// doConstantPropagation - If an instruction references constants, try to fold
-/// them together...
-///
-bool llvm::doConstantPropagation(BasicBlock::iterator &II,
-                                 const TargetData *TD) {
-  if (Constant *C = ConstantFoldInstruction(II, TD)) {
-    // Replaces all of the uses of a variable with uses of the constant.
-    II->replaceAllUsesWith(C);
-
-    // Remove the instruction from the basic block...
-    II = II->getParent()->getInstList().erase(II);
-    return true;
-  }
-
-  return false;
-}
-
 // ConstantFoldTerminator - If a terminator instruction is predicated on a
 // constant value, convert it into an unconditional branch to the constant
 // destination.
@@ -171,6 +154,9 @@ bool llvm::ConstantFoldTerminator(BasicBlock *BB) {
 //  Local dead code elimination...
 //
 
+/// isInstructionTriviallyDead - Return true if the result produced by the
+/// instruction is not used, and the instruction has no side effects.
+///
 bool llvm::isInstructionTriviallyDead(Instruction *I) {
   if (!I->use_empty() || isa<TerminatorInst>(I)) return false;
 
@@ -187,20 +173,29 @@ bool llvm::isInstructionTriviallyDead(Instruction *I) {
   return false;
 }
 
-// dceInstruction - Inspect the instruction at *BBI and figure out if it's
-// [trivially] dead.  If so, remove the instruction and update the iterator
-// to point to the instruction that immediately succeeded the original
-// instruction.
-//
-bool llvm::dceInstruction(BasicBlock::iterator &BBI) {
-  // Look for un"used" definitions...
-  if (isInstructionTriviallyDead(BBI)) {
-    BBI = BBI->getParent()->getInstList().erase(BBI);   // Bye bye
-    return true;
+/// RecursivelyDeleteTriviallyDeadInstructions - If the specified value is a
+/// trivially dead instruction, delete it.  If that makes any of its operands
+/// trivially dead, delete them too, recursively.
+void llvm::RecursivelyDeleteTriviallyDeadInstructions(Value *V) {
+  Instruction *I = dyn_cast<Instruction>(V);
+  if (!I || !I->use_empty()) return;
+  
+  SmallPtrSet<Instruction*, 16> Insts;
+  Insts.insert(I);
+  
+  while (!Insts.empty()) {
+    I = *Insts.begin();
+    Insts.erase(I);
+    if (isInstructionTriviallyDead(I)) {
+      for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i)
+        if (Instruction *U = dyn_cast<Instruction>(I->getOperand(i)))
+          Insts.insert(U);
+      I->eraseFromParent();
+    }
   }
-  return false;
 }
 
+
 //===----------------------------------------------------------------------===//
 //  Control Flow Graph Restructuring...
 //