[llvm] d9e8ae7 - [ValueTracking] Convert MaskedValueIsZero() to use SimplifyQuery (NFC)
Nikita Popov via llvm-commits
llvm-commits at lists.llvm.org
Wed Nov 29 02:21:23 PST 2023
Author: Nikita Popov
Date: 2023-11-29T11:18:42+01:00
New Revision: d9e8ae7d2f74fff629a8be10835677ce8039d452
URL: https://github.com/llvm/llvm-project/commit/d9e8ae7d2f74fff629a8be10835677ce8039d452
DIFF: https://github.com/llvm/llvm-project/commit/d9e8ae7d2f74fff629a8be10835677ce8039d452.diff
LOG: [ValueTracking] Convert MaskedValueIsZero() to use SimplifyQuery (NFC)
Added:
Modified:
llvm/include/llvm/Analysis/ValueTracking.h
llvm/include/llvm/Transforms/InstCombine/InstCombiner.h
llvm/lib/Analysis/BasicAliasAnalysis.cpp
llvm/lib/Analysis/InstructionSimplify.cpp
llvm/lib/Analysis/ValueTracking.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/Analysis/ValueTracking.h b/llvm/include/llvm/Analysis/ValueTracking.h
index f54067916659668..a04562dc874be51 100644
--- a/llvm/include/llvm/Analysis/ValueTracking.h
+++ b/llvm/include/llvm/Analysis/ValueTracking.h
@@ -168,11 +168,8 @@ bool isKnownNonEqual(const Value *V1, const Value *V2, const DataLayout &DL,
/// where V is a vector, the mask, known zero, and known one values are the
/// same width as the vector element, and the bit is set only if it is true
/// for all of the elements in the vector.
-bool MaskedValueIsZero(const Value *V, const APInt &Mask, const DataLayout &DL,
- unsigned Depth = 0, AssumptionCache *AC = nullptr,
- const Instruction *CxtI = nullptr,
- const DominatorTree *DT = nullptr,
- bool UseInstrInfo = true);
+bool MaskedValueIsZero(const Value *V, const APInt &Mask,
+ const SimplifyQuery &DL, unsigned Depth = 0);
/// Return the number of times the sign bit of the register is replicated into
/// the other bits. We know that at least 1 bit is always equal to the sign
diff --git a/llvm/include/llvm/Transforms/InstCombine/InstCombiner.h b/llvm/include/llvm/Transforms/InstCombine/InstCombiner.h
index 160fc2ebe493521..e220d1ad4222ad0 100644
--- a/llvm/include/llvm/Transforms/InstCombine/InstCombiner.h
+++ b/llvm/include/llvm/Transforms/InstCombine/InstCombiner.h
@@ -480,7 +480,7 @@ class LLVM_LIBRARY_VISIBILITY InstCombiner {
bool MaskedValueIsZero(const Value *V, const APInt &Mask, unsigned Depth = 0,
const Instruction *CxtI = nullptr) const {
- return llvm::MaskedValueIsZero(V, Mask, DL, Depth, &AC, CxtI, &DT);
+ return llvm::MaskedValueIsZero(V, Mask, SQ.getWithInstruction(CxtI), Depth);
}
unsigned ComputeNumSignBits(const Value *Op, unsigned Depth = 0,
diff --git a/llvm/lib/Analysis/BasicAliasAnalysis.cpp b/llvm/lib/Analysis/BasicAliasAnalysis.cpp
index 01b43f1c0e3137d..3de147368f23466 100644
--- a/llvm/lib/Analysis/BasicAliasAnalysis.cpp
+++ b/llvm/lib/Analysis/BasicAliasAnalysis.cpp
@@ -395,8 +395,8 @@ static LinearExpression GetLinearExpression(
case Instruction::Or:
// X|C == X+C if all the bits in C are unset in X. Otherwise we can't
// analyze it.
- if (!MaskedValueIsZero(BOp->getOperand(0), RHSC->getValue(), DL, 0, AC,
- BOp, DT))
+ if (!MaskedValueIsZero(BOp->getOperand(0), RHSC->getValue(),
+ SimplifyQuery(DL, DT, AC, BOp)))
return Val;
[[fallthrough]];
diff --git a/llvm/lib/Analysis/InstructionSimplify.cpp b/llvm/lib/Analysis/InstructionSimplify.cpp
index 7ef2ffd23b95e76..ad608702b859f79 100644
--- a/llvm/lib/Analysis/InstructionSimplify.cpp
+++ b/llvm/lib/Analysis/InstructionSimplify.cpp
@@ -2445,13 +2445,13 @@ static Value *simplifyOrInst(Value *Op0, Value *Op1, const SimplifyQuery &Q,
if (C2->isMask() && // C2 == 0+1+
match(A, m_c_Add(m_Specific(B), m_Value(N)))) {
// Add commutes, try both ways.
- if (MaskedValueIsZero(N, *C2, Q.DL, 0, Q.AC, Q.CxtI, Q.DT))
+ if (MaskedValueIsZero(N, *C2, Q))
return A;
}
// Or commutes, try both ways.
if (C1->isMask() && match(B, m_c_Add(m_Specific(A), m_Value(N)))) {
// Add commutes, try both ways.
- if (MaskedValueIsZero(N, *C1, Q.DL, 0, Q.AC, Q.CxtI, Q.DT))
+ if (MaskedValueIsZero(N, *C1, Q))
return B;
}
}
@@ -6202,7 +6202,7 @@ static Value *simplifyUnaryIntrinsic(Function *F, Value *Op0,
// ctpop(and X, 1) --> and X, 1
unsigned BitWidth = Op0->getType()->getScalarSizeInBits();
if (MaskedValueIsZero(Op0, APInt::getHighBitsSet(BitWidth, BitWidth - 1),
- Q.DL, 0, Q.AC, Q.CxtI, Q.DT))
+ Q))
return Op0;
break;
}
diff --git a/llvm/lib/Analysis/ValueTracking.cpp b/llvm/lib/Analysis/ValueTracking.cpp
index 01e542829258442..71884dd0fbd559b 100644
--- a/llvm/lib/Analysis/ValueTracking.cpp
+++ b/llvm/lib/Analysis/ValueTracking.cpp
@@ -308,16 +308,11 @@ bool llvm::isKnownNonEqual(const Value *V1, const Value *V2,
SimplifyQuery(DL, DT, AC, safeCxtI(V2, V1, CxtI), UseInstrInfo));
}
-static bool MaskedValueIsZero(const Value *V, const APInt &Mask, unsigned Depth,
- const SimplifyQuery &Q);
-
bool llvm::MaskedValueIsZero(const Value *V, const APInt &Mask,
- const DataLayout &DL, unsigned Depth,
- AssumptionCache *AC, const Instruction *CxtI,
- const DominatorTree *DT, bool UseInstrInfo) {
- return ::MaskedValueIsZero(
- V, Mask, Depth,
- SimplifyQuery(DL, DT, AC, safeCxtI(V, CxtI), UseInstrInfo));
+ const SimplifyQuery &SQ, unsigned Depth) {
+ KnownBits Known(Mask.getBitWidth());
+ computeKnownBits(V, Known, Depth, SQ);
+ return Mask.isSubsetOf(Known.Zero);
}
static unsigned ComputeNumSignBits(const Value *V, const APInt &DemandedElts,
@@ -3124,22 +3119,6 @@ static bool isKnownNonEqual(const Value *V1, const Value *V2, unsigned Depth,
return false;
}
-/// Return true if 'V & Mask' is known to be zero. We use this predicate to
-/// simplify operations downstream. Mask is known to be zero for bits that V
-/// cannot have.
-///
-/// This function is defined on values with integer type, values with pointer
-/// type, and vectors of integers. In the case
-/// where V is a vector, the mask, known zero, and known one values are the
-/// same width as the vector element, and the bit is set only if it is true
-/// for all of the elements in the vector.
-bool MaskedValueIsZero(const Value *V, const APInt &Mask, unsigned Depth,
- const SimplifyQuery &Q) {
- KnownBits Known(Mask.getBitWidth());
- computeKnownBits(V, Known, Depth, Q);
- return Mask.isSubsetOf(Known.Zero);
-}
-
// Match a signed min+max clamp pattern like smax(smin(In, CHigh), CLow).
// Returns the input and lower/upper bounds.
static bool isSignedMinMaxClamp(const Value *Select, const Value *&In,
More information about the llvm-commits
mailing list