diff --git a/include/llvm/Analysis/InstructionSimplify.h b/include/llvm/Analysis/InstructionSimplify.h index 9825caff8f0..d1ad061d5cd 100644 --- a/include/llvm/Analysis/InstructionSimplify.h +++ b/include/llvm/Analysis/InstructionSimplify.h @@ -17,6 +17,7 @@ #define LLVM_ANALYSIS_INSTRUCTIONSIMPLIFY_H namespace llvm { + class DominatorTree; class Instruction; class Value; class TargetData; @@ -73,7 +74,8 @@ namespace llvm { /// instruction. If not, this returns null. /// WARNING: If called on unreachable code, an instruction may be reported /// to simplify to itself. - Value *SimplifyInstruction(Instruction *I, const TargetData *TD = 0); + Value *SimplifyInstruction(Instruction *I, const TargetData *TD = 0, + const DominatorTree *DT = 0); /// ReplaceAndSimplifyAllUses - Perform From->replaceAllUsesWith(To) and then @@ -83,7 +85,8 @@ namespace llvm { /// simplifies and deletes scalar operations, it does not change the CFG. /// void ReplaceAndSimplifyAllUses(Instruction *From, Value *To, - const TargetData *TD = 0); + const TargetData *TD = 0, + const DominatorTree *DT = 0); } // end namespace llvm #endif diff --git a/include/llvm/Instructions.h b/include/llvm/Instructions.h index fd300ea47a3..91f7729a11d 100644 --- a/include/llvm/Instructions.h +++ b/include/llvm/Instructions.h @@ -1952,7 +1952,7 @@ public: /// 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; + Value *hasConstantValue(const 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/Analysis/InstructionSimplify.cpp b/lib/Analysis/InstructionSimplify.cpp index 210399d7291..282e0d31bed 100644 --- a/lib/Analysis/InstructionSimplify.cpp +++ b/lib/Analysis/InstructionSimplify.cpp @@ -674,7 +674,8 @@ Value *llvm::SimplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS, /// SimplifyInstruction - See if we can compute a simplified version of this /// instruction. If not, this returns null. -Value *llvm::SimplifyInstruction(Instruction *I, const TargetData *TD) { +Value *llvm::SimplifyInstruction(Instruction *I, const TargetData *TD, + const DominatorTree *DT) { switch (I->getOpcode()) { default: return ConstantFoldInstruction(I, TD); @@ -700,7 +701,7 @@ Value *llvm::SimplifyInstruction(Instruction *I, const TargetData *TD) { return SimplifyGEPInst(&Ops[0], Ops.size(), TD); } case Instruction::PHI: - return cast(I)->hasConstantValue(); + return cast(I)->hasConstantValue(DT); } } @@ -711,7 +712,8 @@ Value *llvm::SimplifyInstruction(Instruction *I, const TargetData *TD) { /// simplifies and deletes scalar operations, it does not change the CFG. /// void llvm::ReplaceAndSimplifyAllUses(Instruction *From, Value *To, - const TargetData *TD) { + const TargetData *TD, + const DominatorTree *DT) { assert(From != To && "ReplaceAndSimplifyAllUses(X,X) is not valid!"); // FromHandle/ToHandle - This keeps a WeakVH on the from/to values so that @@ -735,12 +737,12 @@ void llvm::ReplaceAndSimplifyAllUses(Instruction *From, Value *To, // SimplifyInstruction. AssertingVH<> UserHandle(User); - SimplifiedVal = SimplifyInstruction(User, TD); + SimplifiedVal = SimplifyInstruction(User, TD, DT); if (SimplifiedVal == 0) continue; } // Recursively simplify this user to the new value. - ReplaceAndSimplifyAllUses(User, SimplifiedVal, TD); + ReplaceAndSimplifyAllUses(User, SimplifiedVal, TD, DT); From = dyn_cast_or_null((Value*)FromHandle); To = ToHandle; diff --git a/lib/Transforms/Scalar/GVN.cpp b/lib/Transforms/Scalar/GVN.cpp index db3cd803645..732f6c823cc 100644 --- a/lib/Transforms/Scalar/GVN.cpp +++ b/lib/Transforms/Scalar/GVN.cpp @@ -1903,7 +1903,7 @@ bool GVN::processInstruction(Instruction *I, // to value numbering it. Value numbering often exposes redundancies, for // example if it determines that %y is equal to %x then the instruction // "%z = and i32 %x, %y" becomes "%z = and i32 %x, %x" which we now simplify. - if (Value *V = SimplifyInstruction(I, TD)) { + if (Value *V = SimplifyInstruction(I, TD, DT)) { I->replaceAllUsesWith(V); if (MD && V->getType()->isPointerTy()) MD->invalidateCachedPointerInfo(V); diff --git a/lib/Transforms/Scalar/LoopUnswitch.cpp b/lib/Transforms/Scalar/LoopUnswitch.cpp index eb05f995c78..009ee7b95ea 100644 --- a/lib/Transforms/Scalar/LoopUnswitch.cpp +++ b/lib/Transforms/Scalar/LoopUnswitch.cpp @@ -994,7 +994,7 @@ void LoopUnswitch::SimplifyCode(std::vector &Worklist, Loop *L) { // See if instruction simplification can hack this up. This is common for // things like "select false, X, Y" after unswitching made the condition be // 'false'. - if (Value *V = SimplifyInstruction(I)) { + if (Value *V = SimplifyInstruction(I, 0, DT)) { ReplaceUsesOfWith(I, V, Worklist, L, LPM); continue; } diff --git a/lib/VMCore/Instructions.cpp b/lib/VMCore/Instructions.cpp index 57181e32e1f..7306d86877c 100644 --- a/lib/VMCore/Instructions.cpp +++ b/lib/VMCore/Instructions.cpp @@ -170,7 +170,7 @@ void PHINode::resizeOperands(unsigned NumOps) { /// 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 { +Value *PHINode::hasConstantValue(const 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