From 2ed01d8f0bdb8aa73d893a8beb23b1838422fa32 Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Tue, 7 May 2002 18:10:55 +0000
Subject: [PATCH] Factor code out to the TransformUtils library

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@2516 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Transforms/Scalar/ConstantProp.cpp | 82 +-------------------------
 lib/Transforms/Scalar/DCE.cpp          | 25 +-------
 2 files changed, 5 insertions(+), 102 deletions(-)

diff --git a/lib/Transforms/Scalar/ConstantProp.cpp b/lib/Transforms/Scalar/ConstantProp.cpp
index b43f23745aa..7085ef98006 100644
--- a/lib/Transforms/Scalar/ConstantProp.cpp
+++ b/lib/Transforms/Scalar/ConstantProp.cpp
@@ -12,91 +12,13 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Transforms/Scalar/ConstantProp.h"
+#include "llvm/Transforms/Utils/Local.h"
 #include "llvm/ConstantHandling.h"
-#include "llvm/Function.h"
-#include "llvm/BasicBlock.h"
-#include "llvm/iTerminators.h"
+#include "llvm/Instruction.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/InstIterator.h"
 #include <set>
 
-// FIXME: ConstantFoldInstruction & ConstantFoldTerminator should be moved out
-// to the Transformations library.
-
-// ConstantFoldInstruction - If an instruction references constants, try to fold
-// them together...
-//
-bool doConstantPropogation(BasicBlock *BB, BasicBlock::iterator &II) {
-  Instruction *Inst = *II;
-  if (Constant *C = ConstantFoldInstruction(Inst)) {
-    // Replaces all of the uses of a variable with uses of the constant.
-    Inst->replaceAllUsesWith(C);
-    
-    // Remove the instruction from the basic block...
-    delete BB->getInstList().remove(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.
-//
-bool ConstantFoldTerminator(BasicBlock *BB, BasicBlock::iterator &II,
-                            TerminatorInst *T) {
-  // Branch - See if we are conditional jumping on constant
-  if (BranchInst *BI = dyn_cast<BranchInst>(T)) {
-    if (BI->isUnconditional()) return false;  // Can't optimize uncond branch
-    BasicBlock *Dest1 = cast<BasicBlock>(BI->getOperand(0));
-    BasicBlock *Dest2 = cast<BasicBlock>(BI->getOperand(1));
-
-    if (ConstantBool *Cond = dyn_cast<ConstantBool>(BI->getCondition())) {
-      // Are we branching on constant?
-      // YES.  Change to unconditional branch...
-      BasicBlock *Destination = Cond->getValue() ? Dest1 : Dest2;
-      BasicBlock *OldDest     = Cond->getValue() ? Dest2 : Dest1;
-
-      //cerr << "Function: " << T->getParent()->getParent() 
-      //     << "\nRemoving branch from " << T->getParent() 
-      //     << "\n\nTo: " << OldDest << endl;
-
-      // Let the basic block know that we are letting go of it.  Based on this,
-      // it will adjust it's PHI nodes.
-      assert(BI->getParent() && "Terminator not inserted in block!");
-      OldDest->removePredecessor(BI->getParent());
-
-      // Set the unconditional destination, and change the insn to be an
-      // unconditional branch.
-      BI->setUnconditionalDest(Destination);
-      II = BB->end()-1;  // Update instruction iterator!
-      return true;
-    }
-#if 0
-    // FIXME: TODO: This doesn't work if the destination has PHI nodes with
-    // different incoming values on each branch!
-    //
-    else if (Dest2 == Dest1) {       // Conditional branch to same location?
-      // This branch matches something like this:  
-      //     br bool %cond, label %Dest, label %Dest
-      // and changes it into:  br label %Dest
-
-      // Let the basic block know that we are letting go of one copy of it.
-      assert(BI->getParent() && "Terminator not inserted in block!");
-      Dest1->removePredecessor(BI->getParent());
-
-      // Change a conditional branch to unconditional.
-      BI->setUnconditionalDest(Dest1);
-      return true;
-    }
-#endif
-  }
-  return false;
-}
-
-
-
 namespace {
   struct ConstantPropogation : public FunctionPass {
     const char *getPassName() const { return "Simple Constant Propogation"; }
diff --git a/lib/Transforms/Scalar/DCE.cpp b/lib/Transforms/Scalar/DCE.cpp
index 5983910c182..ec9a387c18f 100644
--- a/lib/Transforms/Scalar/DCE.cpp
+++ b/lib/Transforms/Scalar/DCE.cpp
@@ -10,31 +10,12 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Transforms/Scalar/DCE.h"
+#include "llvm/Transforms/Utils/Local.h"
+#include "llvm/Instruction.h"
 #include "llvm/Pass.h"
-#include "llvm/InstrTypes.h"
-#include "llvm/Function.h"
 #include "llvm/Support/InstIterator.h"
 #include <set>
 
-static inline bool isInstDead(Instruction *I) {
-  return I->use_empty() && !I->hasSideEffects() && !isa<TerminatorInst>(I);
-}
-
-// 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 dceInstruction(BasicBlock::InstListType &BBIL,
-                    BasicBlock::iterator &BBI) {
-  // Look for un"used" definitions...
-  if (isInstDead(*BBI)) {
-    delete BBIL.remove(BBI);   // Bye bye
-    return true;
-  }
-  return false;
-}
-
 //===----------------------------------------------------------------------===//
 // DeadInstElimination pass implementation
 //
@@ -95,7 +76,7 @@ bool DCE::runOnFunction(Function *F) {
     Instruction *I = WorkList.back();
     WorkList.pop_back();
     
-    if (isInstDead(I)) {       // If the instruction is dead...
+    if (isInstructionTriviallyDead(I)) {       // If the instruction is dead...
       // Loop over all of the values that the instruction uses, if there are
       // instructions being used, add them to the worklist, because they might
       // go dead after this one is removed.