[llvm] r279831 - [InstCombine] rename variables in foldICmpAndConstant(); NFC
Sanjay Patel via llvm-commits
llvm-commits at lists.llvm.org
Fri Aug 26 09:14:06 PDT 2016
Author: spatel
Date: Fri Aug 26 11:14:06 2016
New Revision: 279831
URL: http://llvm.org/viewvc/llvm-project?rev=279831&view=rev
Log:
[InstCombine] rename variables in foldICmpAndConstant(); NFC
Modified:
llvm/trunk/lib/Transforms/InstCombine/InstCombineCompares.cpp
Modified: llvm/trunk/lib/Transforms/InstCombine/InstCombineCompares.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstCombineCompares.cpp?rev=279831&r1=279830&r2=279831&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/InstCombine/InstCombineCompares.cpp (original)
+++ llvm/trunk/lib/Transforms/InstCombine/InstCombineCompares.cpp Fri Aug 26 11:14:06 2016
@@ -1389,48 +1389,49 @@ Instruction *InstCombiner::foldICmpXorCo
return nullptr;
}
-Instruction *InstCombiner::foldICmpAndConstant(ICmpInst &ICI,
- BinaryOperator *LHSI,
- const APInt *RHSV) {
+/// Fold icmp (and X, Y), C.
+Instruction *InstCombiner::foldICmpAndConstant(ICmpInst &Cmp,
+ BinaryOperator *And,
+ const APInt *C) {
// FIXME: This check restricts all folds under here to scalar types.
- ConstantInt *RHS = dyn_cast<ConstantInt>(ICI.getOperand(1));
+ ConstantInt *RHS = dyn_cast<ConstantInt>(Cmp.getOperand(1));
if (!RHS)
return nullptr;
- if (LHSI->hasOneUse() && isa<ConstantInt>(LHSI->getOperand(1)) &&
- LHSI->getOperand(0)->hasOneUse()) {
- ConstantInt *AndCst = cast<ConstantInt>(LHSI->getOperand(1));
+ if (And->hasOneUse() && isa<ConstantInt>(And->getOperand(1)) &&
+ And->getOperand(0)->hasOneUse()) {
+ ConstantInt *AndCst = cast<ConstantInt>(And->getOperand(1));
// If the LHS is an AND of a truncating cast, we can widen the
// and/compare to be the input width without changing the value
// produced, eliminating a cast.
- if (TruncInst *Cast = dyn_cast<TruncInst>(LHSI->getOperand(0))) {
+ if (TruncInst *Cast = dyn_cast<TruncInst>(And->getOperand(0))) {
// We can do this transformation if either the AND constant does not
// have its sign bit set or if it is an equality comparison.
// Extending a relational comparison when we're checking the sign
// bit would not work.
- if (ICI.isEquality() ||
- (!AndCst->isNegative() && RHSV->isNonNegative())) {
+ if (Cmp.isEquality() ||
+ (!AndCst->isNegative() && C->isNonNegative())) {
Value *NewAnd =
Builder->CreateAnd(Cast->getOperand(0),
ConstantExpr::getZExt(AndCst, Cast->getSrcTy()));
- NewAnd->takeName(LHSI);
- return new ICmpInst(ICI.getPredicate(), NewAnd,
+ NewAnd->takeName(And);
+ return new ICmpInst(Cmp.getPredicate(), NewAnd,
ConstantExpr::getZExt(RHS, Cast->getSrcTy()));
}
}
// If the LHS is an AND of a zext, and we have an equality compare, we can
// shrink the and/compare to the smaller type, eliminating the cast.
- if (ZExtInst *Cast = dyn_cast<ZExtInst>(LHSI->getOperand(0))) {
+ if (ZExtInst *Cast = dyn_cast<ZExtInst>(And->getOperand(0))) {
IntegerType *Ty = cast<IntegerType>(Cast->getSrcTy());
// Make sure we don't compare the upper bits, SimplifyDemandedBits
// should fold the icmp to true/false in that case.
- if (ICI.isEquality() && RHSV->getActiveBits() <= Ty->getBitWidth()) {
+ if (Cmp.isEquality() && C->getActiveBits() <= Ty->getBitWidth()) {
Value *NewAnd = Builder->CreateAnd(Cast->getOperand(0),
ConstantExpr::getTrunc(AndCst, Ty));
- NewAnd->takeName(LHSI);
- return new ICmpInst(ICI.getPredicate(), NewAnd,
+ NewAnd->takeName(And);
+ return new ICmpInst(Cmp.getPredicate(), NewAnd,
ConstantExpr::getTrunc(RHS, Ty));
}
}
@@ -1439,7 +1440,7 @@ Instruction *InstCombiner::foldICmpAndCo
// could exist), turn it into (X & (C2 << C1)) != (C3 << C1). This
// happens a LOT in code produced by the C front-end, for bitfield
// access.
- BinaryOperator *Shift = dyn_cast<BinaryOperator>(LHSI->getOperand(0));
+ BinaryOperator *Shift = dyn_cast<BinaryOperator>(And->getOperand(0));
if (Shift && !Shift->isShift())
Shift = nullptr;
@@ -1462,7 +1463,7 @@ Instruction *InstCombiner::foldICmpAndCo
// comparison value are not negative. These constraints may not be
// obvious, but we can prove that they are correct using an SMT
// solver.
- if (!ICI.isSigned() || (!AndCst->isNegative() && !RHS->isNegative()))
+ if (!Cmp.isSigned() || (!AndCst->isNegative() && !RHS->isNegative()))
CanFold = true;
} else if (ShiftOpcode == Instruction::LShr) {
// For a logical right shift, we can fold if the comparison is not
@@ -1470,7 +1471,7 @@ Instruction *InstCombiner::foldICmpAndCo
// value and the shifted comparison value are not negative.
// These constraints may not be obvious, but we can prove that they
// are correct using an SMT solver.
- if (!ICI.isSigned())
+ if (!Cmp.isSigned())
CanFold = true;
else {
ConstantInt *ShiftedAndCst =
@@ -1496,21 +1497,21 @@ Instruction *InstCombiner::foldICmpAndCo
// If we shifted bits out, the fold is not going to work out.
// As a special case, check to see if this means that the
// result is always true or false now.
- if (ICI.getPredicate() == ICmpInst::ICMP_EQ)
- return replaceInstUsesWith(ICI, Builder->getFalse());
- if (ICI.getPredicate() == ICmpInst::ICMP_NE)
- return replaceInstUsesWith(ICI, Builder->getTrue());
+ if (Cmp.getPredicate() == ICmpInst::ICMP_EQ)
+ return replaceInstUsesWith(Cmp, Builder->getFalse());
+ if (Cmp.getPredicate() == ICmpInst::ICMP_NE)
+ return replaceInstUsesWith(Cmp, Builder->getTrue());
} else {
- ICI.setOperand(1, NewCst);
+ Cmp.setOperand(1, NewCst);
Constant *NewAndCst;
if (ShiftOpcode == Instruction::Shl)
NewAndCst = ConstantExpr::getLShr(AndCst, ShAmt);
else
NewAndCst = ConstantExpr::getShl(AndCst, ShAmt);
- LHSI->setOperand(1, NewAndCst);
- LHSI->setOperand(0, Shift->getOperand(0));
+ And->setOperand(1, NewAndCst);
+ And->setOperand(0, Shift->getOperand(0));
Worklist.Add(Shift); // Shift is dead.
- return &ICI;
+ return &Cmp;
}
}
}
@@ -1518,7 +1519,7 @@ Instruction *InstCombiner::foldICmpAndCo
// Turn ((X >> Y) & C) == 0 into (X & (C << Y)) == 0. The later is
// preferable because it allows the C<<Y expression to be hoisted out
// of a loop if Y is invariant and X is not.
- if (Shift && Shift->hasOneUse() && *RHSV == 0 && ICI.isEquality() &&
+ if (Shift && Shift->hasOneUse() && *C == 0 && Cmp.isEquality() &&
!Shift->isArithmeticShift() && !isa<Constant>(Shift->getOperand(0))) {
// Compute C << Y.
Value *NS;
@@ -1531,10 +1532,10 @@ Instruction *InstCombiner::foldICmpAndCo
// Compute X & (C << Y).
Value *NewAnd =
- Builder->CreateAnd(Shift->getOperand(0), NS, LHSI->getName());
+ Builder->CreateAnd(Shift->getOperand(0), NS, And->getName());
- ICI.setOperand(0, NewAnd);
- return &ICI;
+ Cmp.setOperand(0, NewAnd);
+ return &Cmp;
}
// (icmp pred (and (or (lshr X, Y), X), 1), 0) -->
@@ -1543,14 +1544,14 @@ Instruction *InstCombiner::foldICmpAndCo
// iff pred isn't signed
{
Value *X, *Y, *LShr;
- if (!ICI.isSigned() && *RHSV == 0) {
- if (match(LHSI->getOperand(1), m_One())) {
- Constant *One = cast<Constant>(LHSI->getOperand(1));
- Value *Or = LHSI->getOperand(0);
+ if (!Cmp.isSigned() && *C == 0) {
+ if (match(And->getOperand(1), m_One())) {
+ Constant *One = cast<Constant>(And->getOperand(1));
+ Value *Or = And->getOperand(0);
if (match(Or, m_Or(m_Value(LShr), m_Value(X))) &&
match(LShr, m_LShr(m_Specific(X), m_Value(Y)))) {
unsigned UsesRemoved = 0;
- if (LHSI->hasOneUse())
+ if (And->hasOneUse())
++UsesRemoved;
if (Or->hasOneUse())
++UsesRemoved;
@@ -1570,9 +1571,9 @@ Instruction *InstCombiner::foldICmpAndCo
One, Or->getName());
}
if (NewOr) {
- Value *NewAnd = Builder->CreateAnd(X, NewOr, LHSI->getName());
- ICI.setOperand(0, NewAnd);
- return &ICI;
+ Value *NewAnd = Builder->CreateAnd(X, NewOr, And->getName());
+ Cmp.setOperand(0, NewAnd);
+ return &Cmp;
}
}
}
@@ -1581,23 +1582,23 @@ Instruction *InstCombiner::foldICmpAndCo
// Replace ((X & AndCst) > RHSV) with ((X & AndCst) != 0), if any
// bit set in (X & AndCst) will produce a result greater than RHSV.
- if (ICI.getPredicate() == ICmpInst::ICMP_UGT) {
+ if (Cmp.getPredicate() == ICmpInst::ICMP_UGT) {
unsigned NTZ = AndCst->getValue().countTrailingZeros();
if ((NTZ < AndCst->getBitWidth()) &&
- APInt::getOneBitSet(AndCst->getBitWidth(), NTZ).ugt(*RHSV))
- return new ICmpInst(ICmpInst::ICMP_NE, LHSI,
+ APInt::getOneBitSet(AndCst->getBitWidth(), NTZ).ugt(*C))
+ return new ICmpInst(ICmpInst::ICMP_NE, And,
Constant::getNullValue(RHS->getType()));
}
}
// Try to optimize things like "A[i]&42 == 0" to index computations.
- if (LoadInst *LI = dyn_cast<LoadInst>(LHSI->getOperand(0))) {
+ if (LoadInst *LI = dyn_cast<LoadInst>(And->getOperand(0))) {
if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(LI->getOperand(0)))
if (GlobalVariable *GV = dyn_cast<GlobalVariable>(GEP->getOperand(0)))
if (GV->isConstant() && GV->hasDefinitiveInitializer() &&
- !LI->isVolatile() && isa<ConstantInt>(LHSI->getOperand(1))) {
- ConstantInt *C = cast<ConstantInt>(LHSI->getOperand(1));
- if (Instruction *Res = foldCmpLoadFromIndexedGlobal(GEP, GV, ICI, C))
+ !LI->isVolatile() && isa<ConstantInt>(And->getOperand(1))) {
+ ConstantInt *C = cast<ConstantInt>(And->getOperand(1));
+ if (Instruction *Res = foldCmpLoadFromIndexedGlobal(GEP, GV, Cmp, C))
return Res;
}
}
@@ -1605,22 +1606,22 @@ Instruction *InstCombiner::foldICmpAndCo
// X & -C == -C -> X > u ~C
// X & -C != -C -> X <= u ~C
// iff C is a power of 2
- if (ICI.isEquality() && RHS == LHSI->getOperand(1) && (-(*RHSV)).isPowerOf2())
- return new ICmpInst(ICI.getPredicate() == ICmpInst::ICMP_EQ
+ if (Cmp.isEquality() && RHS == And->getOperand(1) && (-(*C)).isPowerOf2())
+ return new ICmpInst(Cmp.getPredicate() == ICmpInst::ICMP_EQ
? ICmpInst::ICMP_UGT
: ICmpInst::ICMP_ULE,
- LHSI->getOperand(0), SubOne(RHS));
+ And->getOperand(0), SubOne(RHS));
// (icmp eq (and %A, C), 0) -> (icmp sgt (trunc %A), -1)
// iff C is a power of 2
- if (ICI.isEquality() && LHSI->hasOneUse() && match(RHS, m_Zero())) {
- if (auto *CI = dyn_cast<ConstantInt>(LHSI->getOperand(1))) {
+ if (Cmp.isEquality() && And->hasOneUse() && match(RHS, m_Zero())) {
+ if (auto *CI = dyn_cast<ConstantInt>(And->getOperand(1))) {
const APInt &AI = CI->getValue();
int32_t ExactLogBase2 = AI.exactLogBase2();
if (ExactLogBase2 != -1 && DL.isLegalInteger(ExactLogBase2 + 1)) {
- Type *NTy = IntegerType::get(ICI.getContext(), ExactLogBase2 + 1);
- Value *Trunc = Builder->CreateTrunc(LHSI->getOperand(0), NTy);
- return new ICmpInst(ICI.getPredicate() == ICmpInst::ICMP_EQ
+ Type *NTy = IntegerType::get(Cmp.getContext(), ExactLogBase2 + 1);
+ Value *Trunc = Builder->CreateTrunc(And->getOperand(0), NTy);
+ return new ICmpInst(Cmp.getPredicate() == ICmpInst::ICMP_EQ
? ICmpInst::ICMP_SGE
: ICmpInst::ICMP_SLT,
Trunc, Constant::getNullValue(NTy));
More information about the llvm-commits
mailing list