From a83ba0f5c934e2cdbb5724cab365ecc0b5aae6c6 Mon Sep 17 00:00:00 2001 From: Nate Begeman Date: Thu, 4 Aug 2005 23:24:19 +0000 Subject: [PATCH] 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 --- include/llvm/Instructions.h | 5 +++ include/llvm/Transforms/Utils/Local.h | 10 ------ lib/Transforms/Scalar/CondPropagate.cpp | 11 ------ .../Scalar/InstructionCombining.cpp | 2 +- lib/Transforms/Utils/Local.cpp | 34 ------------------- lib/Transforms/Utils/LoopSimplify.cpp | 5 ++- .../Utils/PromoteMemoryToRegister.cpp | 3 +- lib/VMCore/BasicBlock.cpp | 10 +++++- lib/VMCore/Instructions.cpp | 30 ++++++++++++++++ 9 files changed, 48 insertions(+), 62 deletions(-) diff --git a/include/llvm/Instructions.h b/include/llvm/Instructions.h index b1214afef3d..cc2998d52bd 100644 --- 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 11abb5b6667..2cf47e622ab 100644 --- 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 d3ad5778bb4..101acef6dcb 100644 --- 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(I++)); ) - if (Value *PNV = hasConstantValue(PN)) - if (!isa(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 d644d279359..5767afc4099 100644 --- a/lib/Transforms/Scalar/InstructionCombining.cpp +++ b/lib/Transforms/Scalar/InstructionCombining.cpp @@ -4401,7 +4401,7 @@ static bool DeadPHICycle(PHINode *PN, std::set &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(V)) { diff --git a/lib/Transforms/Utils/Local.cpp b/lib/Transforms/Utils/Local.cpp index 4ce9d8f11a1..9744af3c605 100644 --- 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(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 3e4312681d1..5ddcc4163db 100644 --- 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(V) || getAnalysis().dominates(cast(V), PN)) { PN->replaceAllUsesWith(V); @@ -443,7 +442,7 @@ static PHINode *FindPHIToPartitionLoops(Loop *L, DominatorSet &DS, for (BasicBlock::iterator I = L->getHeader()->begin(); isa(I); ) { PHINode *PN = cast(I); ++I; - if (Value *V = hasConstantValue(PN)) + if (Value *V = PN->hasConstantValue()) if (!isa(V) || DS.dominates(cast(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 1edc1193766..bb7f8680933 100644 --- 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 @@ -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(V) || dominates(cast(V), PNs[i])) { if (AST && isa(PNs[i]->getType())) AST->deleteValue(PNs[i]); diff --git a/lib/VMCore/BasicBlock.cpp b/lib/VMCore/BasicBlock.cpp index 98d12d8f138..407080cf68b 100644 --- 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(II)); ++II) + for (iterator II = begin(); (PN = dyn_cast(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(PNV)) { + PN->replaceAllUsesWith(PNV); + PN->eraseFromParent(); + } + } } } diff --git a/lib/VMCore/Instructions.cpp b/lib/VMCore/Instructions.cpp index 68b685e7fcb..e454d6b3a0d 100644 --- 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(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