Fix a fixme in CondPropagate.cpp by moving a PhiNode optimization into

BasicBlock's removePredecessor routine.  This requires shuffling around
the definition and implementation of hasContantValue from Utils.h,cpp into
Instructions.h,cpp

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

diff --git a/include/llvm/Instructions.h b/include/llvm/Instructions.h
index b1214afef3dfdc958665191f22edd7ee12b90797..cc2998d52bd7d15109b202718ad25db33fdc1873 100644 (file)
--- a/include/llvm/Instructions.h
+++ b/include/llvm/Instructions.h
@@ -804,6 +804,11 @@ public:
     return getIncomingValue(getBasicBlockIndex(BB));
   }
 
+  /// hasConstantValue - If the specified PHI node always merges together the 
+  /// same value, return the value, otherwise return null.
+  ///
+  Value *hasConstantValue();
+  
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const PHINode *) { return true; }
   static inline bool classof(const Instruction *I) {

diff --git a/include/llvm/Transforms/Utils/Local.h b/include/llvm/Transforms/Utils/Local.h
index 11abb5b666726e07b42c8e4232a3816f8e1c5bfd..2cf47e622ab671ecd0f2e92c65250debe2b35422 100644 (file)
--- a/include/llvm/Transforms/Utils/Local.h
+++ b/include/llvm/Transforms/Utils/Local.h
@@ -73,16 +73,6 @@ bool isInstructionTriviallyDead(Instruction *I);
 ///
 bool dceInstruction(BasicBlock::iterator &BBI);
 
-//===----------------------------------------------------------------------===//
-//  PHI Instruction Simplification
-//
-
-/// hasConstantValue - If the specified PHI node always merges together the same
-/// value, return the value, otherwise return null.
-///
-Value *hasConstantValue(PHINode *PN);
-
-
 //===----------------------------------------------------------------------===//
 //  Control Flow Graph Restructuring...
 //

diff --git a/lib/Transforms/Scalar/CondPropagate.cpp b/lib/Transforms/Scalar/CondPropagate.cpp
index d3ad5778bb4a16ca54d26fba75a410a85059467d..101acef6dcb479d1eca8f4cc1c42380f2fbec990 100644 (file)
--- a/lib/Transforms/Scalar/CondPropagate.cpp
+++ b/lib/Transforms/Scalar/CondPropagate.cpp
@@ -80,17 +80,6 @@ void CondProp::SimplifyBlock(BasicBlock *BB) {
       SimplifyPredecessors(SI);
   }
 
-  // See if we can fold any PHI nodes in this block now.
-  // FIXME: This would not be required if removePredecessor did this for us!!
-  PHINode *PN;
-  for (BasicBlock::iterator I = BB->begin(); (PN = dyn_cast<PHINode>(I++)); )
-    if (Value *PNV = hasConstantValue(PN))
-      if (!isa<Instruction>(PNV)) {
-        PN->replaceAllUsesWith(PNV);
-        PN->eraseFromParent();
-        MadeChange = true;
-      }
-
   // If possible, simplify the terminator of this block.
   if (ConstantFoldTerminator(BB))
     MadeChange = true;

diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp
index d644d279359b94e652e4f32e5f48619cc8071ecd..5767afc40999a3c13809244c4d4ae3c2aa9579a1 100644 (file)
--- a/lib/Transforms/Scalar/InstructionCombining.cpp
+++ b/lib/Transforms/Scalar/InstructionCombining.cpp
@@ -4401,7 +4401,7 @@ static bool DeadPHICycle(PHINode *PN, std::set<PHINode*> &PotentiallyDeadPHIs) {
 // PHINode simplification
 //
 Instruction *InstCombiner::visitPHINode(PHINode &PN) {
-  if (Value *V = hasConstantValue(&PN)) {
+  if (Value *V = PN.hasConstantValue()) {
     // If V is an instruction, we have to be certain that it dominates PN.
     // However, because we don't have dom info, we can't do a perfect job.
     if (Instruction *I = dyn_cast<Instruction>(V)) {

diff --git a/lib/Transforms/Utils/Local.cpp b/lib/Transforms/Utils/Local.cpp
index 4ce9d8f11a180d17b903c95ce918364a48ac8ae1..9744af3c605285ec40d3bf084b33195a1eeb87eb 100644 (file)
--- a/lib/Transforms/Utils/Local.cpp
+++ b/lib/Transforms/Utils/Local.cpp
@@ -406,37 +406,3 @@ bool llvm::dceInstruction(BasicBlock::iterator &BBI) {
   }
   return false;
 }
-
-//===----------------------------------------------------------------------===//
-//  PHI Instruction Simplification
-//
-
-/// hasConstantValue - If the specified PHI node always merges together the same
-/// value, return the value, otherwise return null.
-///
-Value *llvm::hasConstantValue(PHINode *PN) {
-  // If the PHI node only has one incoming value, eliminate the PHI node...
-  if (PN->getNumIncomingValues() == 1)
-    return PN->getIncomingValue(0);
-
-  // Otherwise if all of the incoming values are the same for the PHI, replace
-  // the PHI node with the incoming value.
-  //
-  Value *InVal = 0;
-  for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i)
-    if (PN->getIncomingValue(i) != PN &&  // Not the PHI node itself...
-        !isa<UndefValue>(PN->getIncomingValue(i)))
-      if (InVal && PN->getIncomingValue(i) != InVal)
-        return 0;  // Not the same, bail out.
-      else
-        InVal = PN->getIncomingValue(i);
-
-  // The only case that could cause InVal to be null is if we have a PHI node
-  // that only has entries for itself.  In this case, there is no entry into the
-  // loop, so kill the PHI.
-  //
-  if (InVal == 0) InVal = UndefValue::get(PN->getType());
-
-  // All of the incoming values are the same, return the value now.
-  return InVal;
-}

diff --git a/lib/Transforms/Utils/LoopSimplify.cpp b/lib/Transforms/Utils/LoopSimplify.cpp
index 3e4312681d138366d31098934370271ee017efa4..5ddcc4163db067fae26134a9bad309f2a956764c 100644 (file)
--- a/lib/Transforms/Utils/LoopSimplify.cpp
+++ b/lib/Transforms/Utils/LoopSimplify.cpp
@@ -41,7 +41,6 @@
 #include "llvm/Analysis/Dominators.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Support/CFG.h"
-#include "llvm/Transforms/Utils/Local.h"
 #include "llvm/ADT/SetOperations.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/Statistic.h"
@@ -257,7 +256,7 @@ BasicBlock *LoopSimplify::SplitBlockPredecessors(BasicBlock *BB,
       PN->addIncoming(InVal, NewBB);
 
       // Can we eliminate this phi node now?
-      if (Value *V = hasConstantValue(PN)) {
+      if (Value *V = PN->hasConstantValue()) {
         if (!isa<Instruction>(V) ||
             getAnalysis<DominatorSet>().dominates(cast<Instruction>(V), PN)) {
           PN->replaceAllUsesWith(V);
@@ -443,7 +442,7 @@ static PHINode *FindPHIToPartitionLoops(Loop *L, DominatorSet &DS,
   for (BasicBlock::iterator I = L->getHeader()->begin(); isa<PHINode>(I); ) {
     PHINode *PN = cast<PHINode>(I);
     ++I;
-    if (Value *V = hasConstantValue(PN))
+    if (Value *V = PN->hasConstantValue())
       if (!isa<Instruction>(V) || DS.dominates(cast<Instruction>(V), PN)) {
         // This is a degenerate PHI already, don't modify it!
         PN->replaceAllUsesWith(V);

diff --git a/lib/Transforms/Utils/PromoteMemoryToRegister.cpp b/lib/Transforms/Utils/PromoteMemoryToRegister.cpp
index 1edc1193766c299d345ecad743101201f7f1a7a7..bb7f8680933b5f87d0d90484a5cc025d00208e66 100644 (file)
--- a/lib/Transforms/Utils/PromoteMemoryToRegister.cpp
+++ b/lib/Transforms/Utils/PromoteMemoryToRegister.cpp
@@ -24,7 +24,6 @@
 #include "llvm/Analysis/Dominators.h"
 #include "llvm/Analysis/AliasSetTracker.h"
 #include "llvm/ADT/StringExtras.h"
-#include "llvm/Transforms/Utils/Local.h"
 #include "llvm/Support/CFG.h"
 #include "llvm/Support/StableBasicBlockNumbering.h"
 #include <algorithm>
@@ -348,7 +347,7 @@ void PromoteMem2Reg::run() {
     PHINode *SomePHI = 0;
     for (unsigned i = 0, e = PNs.size(); i != e; ++i)
       if (PNs[i]) {
-        if (Value *V = hasConstantValue(PNs[i])) {
+        if (Value *V = PNs[i]->hasConstantValue()) {
           if (!isa<Instruction>(V) || dominates(cast<Instruction>(V), PNs[i])) {
             if (AST && isa<PointerType>(PNs[i]->getType()))
               AST->deleteValue(PNs[i]);

diff --git a/lib/VMCore/BasicBlock.cpp b/lib/VMCore/BasicBlock.cpp
index 98d12d8f1381368a497887dec4fe6037a4942545..407080cf68b98ed68485e963f4a61fcaae3fdaef 100644 (file)
--- a/lib/VMCore/BasicBlock.cpp
+++ b/lib/VMCore/BasicBlock.cpp
@@ -189,8 +189,16 @@ void BasicBlock::removePredecessor(BasicBlock *Pred,
     // Okay, now we know that we need to remove predecessor #pred_idx from all
     // PHI nodes.  Iterate over each PHI node fixing them up
     PHINode *PN;
-    for (iterator II = begin(); (PN = dyn_cast<PHINode>(II)); ++II)
+    for (iterator II = begin(); (PN = dyn_cast<PHINode>(II)); ++II) {
       PN->removeIncomingValue(Pred, false);
+      // If all incoming values to the Phi are the same, we can replace the Phi
+      // with that value.
+      if (Value *PNV = PN->hasConstantValue())
+        if (!isa<Instruction>(PNV)) {
+          PN->replaceAllUsesWith(PNV);
+          PN->eraseFromParent();
+        }
+    }
   }
 }
 

diff --git a/lib/VMCore/Instructions.cpp b/lib/VMCore/Instructions.cpp
index 68b685e7fcb45724a622f39195a69b6a733f5362..e454d6b3a0df3a0b7172221430e2d24f3e6f27e4 100644 (file)
--- a/lib/VMCore/Instructions.cpp
+++ b/lib/VMCore/Instructions.cpp
@@ -132,6 +132,36 @@ void PHINode::resizeOperands(unsigned NumOps) {
   OperandList = NewOps;
 }
 
+/// hasConstantValue - If the specified PHI node always merges together the same
+/// value, return the value, otherwise return null.
+///
+Value *PHINode::hasConstantValue() {
+  // If the PHI node only has one incoming value, eliminate the PHI node...
+  if (getNumIncomingValues() == 1)
+    return getIncomingValue(0);
+  
+  // Otherwise if all of the incoming values are the same for the PHI, replace
+  // the PHI node with the incoming value.
+  //
+  Value *InVal = 0;
+  for (unsigned i = 0, e = getNumIncomingValues(); i != e; ++i)
+    if (getIncomingValue(i) != this &&  // Not the PHI node itself...
+        !isa<UndefValue>(getIncomingValue(i)))
+      if (InVal && getIncomingValue(i) != InVal)
+        return 0;  // Not the same, bail out.
+      else
+        InVal = getIncomingValue(i);
+  
+  // The only case that could cause InVal to be null is if we have a PHI node
+  // that only has entries for itself.  In this case, there is no entry into the
+  // loop, so kill the PHI.
+  //
+  if (InVal == 0) InVal = UndefValue::get(getType());
+  
+  // All of the incoming values are the same, return the value now.
+  return InVal;
+}
+
 
 //===----------------------------------------------------------------------===//
 //                        CallInst Implementation