diff --git a/include/llvm/Instructions.h b/include/llvm/Instructions.h index e6f1c54483a..71f47385289 100644 --- a/include/llvm/Instructions.h +++ b/include/llvm/Instructions.h @@ -31,6 +31,7 @@ class ConstantInt; class ConstantRange; class APInt; class LLVMContext; +class DominatorTree; //===----------------------------------------------------------------------===// // AllocationInst Class @@ -1950,7 +1951,12 @@ public: /// hasConstantValue - If the specified PHI node always merges together the /// same value, return the value, otherwise return null. /// - Value *hasConstantValue(bool AllowNonDominatingInstruction = false) const; + /// If the PHI has undef operands, but all the rest of the operands are + /// some unique value, return that value if it can be proved that the + /// value dominates the PHI. If DT is null, use a conservative check, + /// otherwise use DT to test for dominance. + /// + Value *hasConstantValue(DominatorTree *DT = 0) const; /// Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const PHINode *) { return true; } diff --git a/lib/Transforms/Scalar/GVN.cpp b/lib/Transforms/Scalar/GVN.cpp index 56bc816c4f4..36c90f519f2 100644 --- a/lib/Transforms/Scalar/GVN.cpp +++ b/lib/Transforms/Scalar/GVN.cpp @@ -769,7 +769,7 @@ static bool isSafeReplacement(PHINode* p, Instruction* inst) { } Value* GVN::CollapsePhi(PHINode* p) { - Value* constVal = p->hasConstantValue(); + Value* constVal = p->hasConstantValue(DT); if (!constVal) return 0; Instruction* inst = dyn_cast(constVal); diff --git a/lib/Transforms/Utils/BasicBlockUtils.cpp b/lib/Transforms/Utils/BasicBlockUtils.cpp index c3d6194801d..c165e04fb8a 100644 --- a/lib/Transforms/Utils/BasicBlockUtils.cpp +++ b/lib/Transforms/Utils/BasicBlockUtils.cpp @@ -429,13 +429,10 @@ BasicBlock *llvm::SplitBlockPredecessors(BasicBlock *BB, PN->addIncoming(InVal, NewBB); // Check to see if we can eliminate this phi node. - if (Value *V = PN->hasConstantValue(DT != 0)) { - Instruction *I = dyn_cast(V); - if (!I || DT == 0 || DT->dominates(I, PN)) { - PN->replaceAllUsesWith(V); - if (AA) AA->deleteValue(PN); - PN->eraseFromParent(); - } + if (Value *V = PN->hasConstantValue(DT)) { + PN->replaceAllUsesWith(V); + if (AA) AA->deleteValue(PN); + PN->eraseFromParent(); } } diff --git a/lib/Transforms/Utils/LoopSimplify.cpp b/lib/Transforms/Utils/LoopSimplify.cpp index c981a014cb3..56e5a46cb78 100644 --- a/lib/Transforms/Utils/LoopSimplify.cpp +++ b/lib/Transforms/Utils/LoopSimplify.cpp @@ -255,7 +255,7 @@ ReprocessLoop: PHINode *PN; for (BasicBlock::iterator I = L->getHeader()->begin(); (PN = dyn_cast(I++)); ) - if (Value *V = PN->hasConstantValue()) { + if (Value *V = PN->hasConstantValue(DT)) { if (AA) AA->deleteValue(PN); PN->replaceAllUsesWith(V); PN->eraseFromParent(); @@ -417,14 +417,13 @@ static PHINode *FindPHIToPartitionLoops(Loop *L, DominatorTree *DT, for (BasicBlock::iterator I = L->getHeader()->begin(); isa(I); ) { PHINode *PN = cast(I); ++I; - if (Value *V = PN->hasConstantValue()) - if (!isa(V) || DT->dominates(cast(V), PN)) { - // This is a degenerate PHI already, don't modify it! - PN->replaceAllUsesWith(V); - if (AA) AA->deleteValue(PN); - PN->eraseFromParent(); - continue; - } + if (Value *V = PN->hasConstantValue(DT)) { + // This is a degenerate PHI already, don't modify it! + PN->replaceAllUsesWith(V); + if (AA) AA->deleteValue(PN); + PN->eraseFromParent(); + continue; + } // Scan this PHI node looking for a use of the PHI node by itself. for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) diff --git a/lib/Transforms/Utils/PromoteMemoryToRegister.cpp b/lib/Transforms/Utils/PromoteMemoryToRegister.cpp index 6a56a8d8245..8274e5aeb61 100644 --- a/lib/Transforms/Utils/PromoteMemoryToRegister.cpp +++ b/lib/Transforms/Utils/PromoteMemoryToRegister.cpp @@ -494,17 +494,14 @@ void PromoteMem2Reg::run() { PHINode *PN = I->second; // If this PHI node merges one value and/or undefs, get the value. - if (Value *V = PN->hasConstantValue(true)) { - if (!isa(V) || - properlyDominates(cast(V), PN)) { - if (AST && isa(PN->getType())) - AST->deleteValue(PN); - PN->replaceAllUsesWith(V); - PN->eraseFromParent(); - NewPhiNodes.erase(I++); - EliminatedAPHI = true; - continue; - } + if (Value *V = PN->hasConstantValue(&DT)) { + if (AST && isa(PN->getType())) + AST->deleteValue(PN); + PN->replaceAllUsesWith(V); + PN->eraseFromParent(); + NewPhiNodes.erase(I++); + EliminatedAPHI = true; + continue; } ++I; } diff --git a/lib/VMCore/Instructions.cpp b/lib/VMCore/Instructions.cpp index a12075fe0d9..2d4ab557217 100644 --- a/lib/VMCore/Instructions.cpp +++ b/lib/VMCore/Instructions.cpp @@ -17,6 +17,7 @@ #include "llvm/Function.h" #include "llvm/Instructions.h" #include "llvm/Operator.h" +#include "llvm/Analysis/Dominators.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/CallSite.h" #include "llvm/Support/ConstantRange.h" @@ -226,7 +227,12 @@ void PHINode::resizeOperands(unsigned NumOps) { /// hasConstantValue - If the specified PHI node always merges together the same /// value, return the value, otherwise return null. /// -Value *PHINode::hasConstantValue(bool AllowNonDominatingInstruction) const { +/// If the PHI has undef operands, but all the rest of the operands are +/// some unique value, return that value if it can be proved that the +/// value dominates the PHI. If DT is null, use a conservative check, +/// otherwise use DT to test for dominance. +/// +Value *PHINode::hasConstantValue(DominatorTree *DT) const { // If the PHI node only has one incoming value, eliminate the PHI node... if (getNumIncomingValues() == 1) { if (getIncomingValue(0) != this) // not X = phi X @@ -260,12 +266,19 @@ Value *PHINode::hasConstantValue(bool AllowNonDominatingInstruction) const { // instruction, we cannot always return X as the result of the PHI node. Only // do this if X is not an instruction (thus it must dominate the PHI block), // or if the client is prepared to deal with this possibility. - if (HasUndefInput && !AllowNonDominatingInstruction) - if (Instruction *IV = dyn_cast(InVal)) - // If it's in the entry block, it dominates everything. - if (IV->getParent() != &IV->getParent()->getParent()->getEntryBlock() || - isa(IV)) - return 0; // Cannot guarantee that InVal dominates this PHINode. + if (HasUndefInput) + if (Instruction *IV = dyn_cast(InVal)) { + if (DT) { + // We have a DominatorTree. Do a precise test. + if (!DT->dominates(IV, this)) + return 0; + } else { + // If it's in the entry block, it dominates everything. + if (IV->getParent() != &IV->getParent()->getParent()->getEntryBlock() || + isa(IV)) + return 0; // Cannot guarantee that InVal dominates this PHINode. + } + } // All of the incoming values are the same, return the value now. return InVal; diff --git a/test/Transforms/GVN/2008-07-02-Unreachable.ll b/test/Transforms/GVN/2008-07-02-Unreachable.ll index 15667d2bfb2..fc273c30f7f 100644 --- a/test/Transforms/GVN/2008-07-02-Unreachable.ll +++ b/test/Transforms/GVN/2008-07-02-Unreachable.ll @@ -1,4 +1,4 @@ -; RUN: llvm-as < %s | opt -gvn | llvm-dis | grep undef +; RUN: llvm-as < %s | opt -gvn | llvm-dis | grep {ret i8 \[%\]tmp3} ; PR2503 @g_3 = external global i8 ; [#uses=2]