From e2b013ff76d6050ef15f6aa6003759adae1119cc Mon Sep 17 00:00:00 2001 From: Sanjoy Das Date: Fri, 6 Nov 2015 19:01:08 +0000 Subject: [PATCH] [ValueTracking] Add parameters to isImpliedCondition; NFC Summary: This change makes the `isImpliedCondition` interface similar to the rest of the functions in ValueTracking (in that it takes a DataLayout, AssumptionCache etc.). This is an NFC, intended to make a later diff less noisy. Depends on D14369 Subscribers: llvm-commits Differential Revision: http://reviews.llvm.org/D14391 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@252333 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Analysis/ValueTracking.h | 5 ++++- lib/Analysis/InstructionSimplify.cpp | 6 ++--- lib/Analysis/ValueTracking.cpp | 30 ++++++++++++++++++------- lib/Transforms/Scalar/JumpThreading.cpp | 4 +++- lib/Transforms/Utils/SimplifyCFG.cpp | 2 +- 5 files changed, 33 insertions(+), 14 deletions(-) diff --git a/include/llvm/Analysis/ValueTracking.h b/include/llvm/Analysis/ValueTracking.h index 6d5f4ac0ad2..b34d6bac1f3 100644 --- a/include/llvm/Analysis/ValueTracking.h +++ b/include/llvm/Analysis/ValueTracking.h @@ -444,7 +444,10 @@ namespace llvm { /// T | T | F /// F | T | T /// (A) - bool isImpliedCondition(Value *LHS, Value *RHS); + bool isImpliedCondition(Value *LHS, Value *RHS, const DataLayout &DL, + unsigned Depth = 0, AssumptionCache *AC = nullptr, + const Instruction *CxtI = nullptr, + const DominatorTree *DT = nullptr); } // end namespace llvm #endif diff --git a/lib/Analysis/InstructionSimplify.cpp b/lib/Analysis/InstructionSimplify.cpp index 9ba33f49d8f..5ed7f8748c9 100644 --- a/lib/Analysis/InstructionSimplify.cpp +++ b/lib/Analysis/InstructionSimplify.cpp @@ -2176,7 +2176,7 @@ static Value *SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS, // X >=u 1 -> X if (match(RHS, m_One())) return LHS; - if (isImpliedCondition(RHS, LHS)) + if (isImpliedCondition(RHS, LHS, Q.DL)) return getTrue(ITy); break; case ICmpInst::ICMP_SGE: @@ -2187,7 +2187,7 @@ static Value *SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS, /// 0 | 1 | 1 (0 >= -1) | 1 /// 1 | 0 | 0 (-1 >= 0) | 0 /// 1 | 1 | 1 (-1 >= -1) | 1 - if (isImpliedCondition(LHS, RHS)) + if (isImpliedCondition(LHS, RHS, Q.DL)) return getTrue(ITy); break; case ICmpInst::ICMP_SLT: @@ -2201,7 +2201,7 @@ static Value *SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS, return LHS; break; case ICmpInst::ICMP_ULE: - if (isImpliedCondition(LHS, RHS)) + if (isImpliedCondition(LHS, RHS, Q.DL)) return getTrue(ITy); break; } diff --git a/lib/Analysis/ValueTracking.cpp b/lib/Analysis/ValueTracking.cpp index f4824aebe52..abec5962266 100644 --- a/lib/Analysis/ValueTracking.cpp +++ b/lib/Analysis/ValueTracking.cpp @@ -4083,7 +4083,10 @@ ConstantRange llvm::getConstantRangeFromMetadata(MDNode &Ranges) { } /// Return true if "icmp Pred LHS RHS" is always true. -static bool isTruePredicate(CmpInst::Predicate Pred, Value *LHS, Value *RHS) { +static bool isTruePredicate(CmpInst::Predicate Pred, Value *LHS, Value *RHS, + const DataLayout &DL, unsigned Depth, + AssumptionCache *AC, const Instruction *CxtI, + const DominatorTree *DT) { if (ICmpInst::isTrueWhenEqual(Pred) && LHS == RHS) return true; @@ -4124,24 +4127,34 @@ static bool isTruePredicate(CmpInst::Predicate Pred, Value *LHS, Value *RHS) { /// Return true if "icmp Pred BLHS BRHS" is true whenever "icmp Pred /// ALHS ARHS" is true. static bool isImpliedCondOperands(CmpInst::Predicate Pred, Value *ALHS, - Value *ARHS, Value *BLHS, Value *BRHS) { + Value *ARHS, Value *BLHS, Value *BRHS, + const DataLayout &DL, unsigned Depth, + AssumptionCache *AC, const Instruction *CxtI, + const DominatorTree *DT) { switch (Pred) { default: return false; case CmpInst::ICMP_SLT: case CmpInst::ICMP_SLE: - return isTruePredicate(CmpInst::ICMP_SLE, BLHS, ALHS) && - isTruePredicate(CmpInst::ICMP_SLE, ARHS, BRHS); + return isTruePredicate(CmpInst::ICMP_SLE, BLHS, ALHS, DL, Depth, AC, CxtI, + DT) && + isTruePredicate(CmpInst::ICMP_SLE, ARHS, BRHS, DL, Depth, AC, CxtI, + DT); case CmpInst::ICMP_ULT: case CmpInst::ICMP_ULE: - return isTruePredicate(CmpInst::ICMP_ULE, BLHS, ALHS) && - isTruePredicate(CmpInst::ICMP_ULE, ARHS, BRHS); + return isTruePredicate(CmpInst::ICMP_ULE, BLHS, ALHS, DL, Depth, AC, CxtI, + DT) && + isTruePredicate(CmpInst::ICMP_ULE, ARHS, BRHS, DL, Depth, AC, CxtI, + DT); } } -bool llvm::isImpliedCondition(Value *LHS, Value *RHS) { +bool llvm::isImpliedCondition(Value *LHS, Value *RHS, const DataLayout &DL, + unsigned Depth, AssumptionCache *AC, + const Instruction *CxtI, + const DominatorTree *DT) { assert(LHS->getType() == RHS->getType() && "mismatched type"); Type *OpTy = LHS->getType(); assert(OpTy->getScalarType()->isIntegerTy(1)); @@ -4163,7 +4176,8 @@ bool llvm::isImpliedCondition(Value *LHS, Value *RHS) { return false; if (APred == BPred) - return isImpliedCondOperands(APred, ALHS, ARHS, BLHS, BRHS); + return isImpliedCondOperands(APred, ALHS, ARHS, BLHS, BRHS, DL, Depth, AC, + CxtI, DT); return false; } diff --git a/lib/Transforms/Scalar/JumpThreading.cpp b/lib/Transforms/Scalar/JumpThreading.cpp index ab83553f81b..6ab00ee2b19 100644 --- a/lib/Transforms/Scalar/JumpThreading.cpp +++ b/lib/Transforms/Scalar/JumpThreading.cpp @@ -895,12 +895,14 @@ bool JumpThreading::ProcessImpliedCondition(BasicBlock *BB) { BasicBlock *CurrentPred = BB->getSinglePredecessor(); unsigned Iter = 0; + auto &DL = BB->getModule()->getDataLayout(); + while (CurrentPred && Iter++ < ImplicationSearchThreshold) { auto *PBI = dyn_cast(CurrentPred->getTerminator()); if (!PBI || !PBI->isConditional() || PBI->getSuccessor(0) != CurrentBB) return false; - if (isImpliedCondition(PBI->getCondition(), Cond)) { + if (isImpliedCondition(PBI->getCondition(), Cond, DL)) { BI->getSuccessor(1)->removePredecessor(BB); BranchInst::Create(BI->getSuccessor(0), BI); BI->eraseFromParent(); diff --git a/lib/Transforms/Utils/SimplifyCFG.cpp b/lib/Transforms/Utils/SimplifyCFG.cpp index b119d2df035..25b83e256a6 100644 --- a/lib/Transforms/Utils/SimplifyCFG.cpp +++ b/lib/Transforms/Utils/SimplifyCFG.cpp @@ -2686,7 +2686,7 @@ static bool SimplifyCondBranchToCondBranch(BranchInst *PBI, BranchInst *BI, // If BI is reached from the true path of PBI and PBI's condition implies // BI's condition, we know the direction of the BI branch. if (PBI->getSuccessor(0) == BI->getParent() && - isImpliedCondition(PBI->getCondition(), BI->getCondition()) && + isImpliedCondition(PBI->getCondition(), BI->getCondition(), DL) && PBI->getSuccessor(0) != PBI->getSuccessor(1) && BB->getSinglePredecessor()) { // Turn this into a branch on constant. -- 2.34.1