57#include "llvm/IR/IntrinsicsAArch64.h"
58#include "llvm/IR/IntrinsicsAMDGPU.h"
59#include "llvm/IR/IntrinsicsRISCV.h"
60#include "llvm/IR/IntrinsicsX86.h"
97 return DL.getPointerTypeSizeInBits(Ty);
109 CxtI = dyn_cast<Instruction>(V);
123 CxtI = dyn_cast<Instruction>(V1);
127 CxtI = dyn_cast<Instruction>(V2);
135 const APInt &DemandedElts,
137 if (isa<ScalableVectorType>(Shuf->
getType())) {
139 DemandedLHS = DemandedRHS = DemandedElts;
146 DemandedElts, DemandedLHS, DemandedRHS);
158 auto *FVTy = dyn_cast<FixedVectorType>(V->getType());
186 V, DemandedElts,
Depth,
255 "LHS and RHS should have the same type");
257 "LHS and RHS should be integers");
268 return !
I->user_empty() &&
all_of(
I->users(), [](
const User *U) {
269 return match(U, m_ICmp(m_Value(), m_Zero()));
274 return !
I->user_empty() &&
all_of(
I->users(), [](
const User *U) {
276 return match(U, m_ICmp(P, m_Value(), m_Zero())) && ICmpInst::isEquality(P);
281 bool OrZero,
unsigned Depth,
284 return ::isKnownToBeAPowerOfTwo(
299 if (
auto *CI = dyn_cast<ConstantInt>(V))
300 return CI->getValue().isStrictlyPositive();
323 if (V1 == V2 || V1->
getType() != V2->getType())
325 auto *FVTy = dyn_cast<FixedVectorType>(V1->
getType());
328 return ::isKnownNonEqual(
329 V1, V2, DemandedElts, 0,
337 return Mask.isSubsetOf(Known.
Zero);
345 auto *FVTy = dyn_cast<FixedVectorType>(V->getType());
355 return ::ComputeNumSignBits(
364 return V->getType()->getScalarSizeInBits() - SignBits + 1;
369 const APInt &DemandedElts,
376 if (KnownOut.
isUnknown() && !NSW && !NUW)
384 bool NUW,
const APInt &DemandedElts,
401 bool isKnownNegativeOp0 = Known2.
isNegative();
404 (isKnownNonNegativeOp1 && isKnownNonNegativeOp0);
416 (isKnownNegativeOp1 && isKnownNonNegativeOp0 &&
418 (isKnownNegativeOp0 && isKnownNonNegativeOp1 && Known.
isNonZero());
422 bool SelfMultiply = Op0 == Op1;
442 unsigned NumRanges = Ranges.getNumOperands() / 2;
448 for (
unsigned i = 0; i < NumRanges; ++i) {
450 mdconst::extract<ConstantInt>(Ranges.getOperand(2 * i + 0));
452 mdconst::extract<ConstantInt>(Ranges.getOperand(2 * i + 1));
456 unsigned CommonPrefixBits =
460 Known.
One &= UnsignedMax & Mask;
461 Known.
Zero &= ~UnsignedMax & Mask;
476 while (!WorkSet.
empty()) {
478 if (!Visited.
insert(V).second)
483 return EphValues.count(U);
488 if (V ==
I || (isa<Instruction>(V) &&
490 !cast<Instruction>(V)->isTerminator())) {
492 if (
const User *U = dyn_cast<User>(V))
504 return CI->isAssumeLikeIntrinsic();
512 bool AllowEphemerals) {
530 if (!AllowEphemerals && Inv == CxtI)
566 if (Pred == ICmpInst::ICMP_UGT)
570 if (Pred == ICmpInst::ICMP_NE)
581 auto *VC = dyn_cast<ConstantDataVector>(
RHS);
585 for (
unsigned ElemIdx = 0, NElem = VC->getNumElements(); ElemIdx < NElem;
588 Pred, VC->getElementAsAPInt(ElemIdx));
597 const PHINode **PhiOut =
nullptr) {
601 CtxIOut =
PHI->getIncomingBlock(*U)->getTerminator();
616 if (
auto *IncPhi = dyn_cast<PHINode>(ValOut);
617 IncPhi && IncPhi->getNumIncomingValues() == 2) {
619 if (IncPhi->getIncomingValue(
Idx) ==
PHI) {
620 ValOut = IncPhi->getIncomingValue(1 -
Idx);
623 CtxIOut = IncPhi->getIncomingBlock(1 -
Idx)->getTerminator();
642 "Got assumption for the wrong function!");
645 if (!V->getType()->isPointerTy())
648 *
I,
I->bundle_op_info_begin()[Elem.Index])) {
650 (RK.AttrKind == Attribute::NonNull ||
651 (RK.AttrKind == Attribute::Dereferenceable &&
653 V->getType()->getPointerAddressSpace()))) &&
685 case ICmpInst::ICMP_EQ:
688 case ICmpInst::ICMP_SGE:
689 case ICmpInst::ICMP_SGT:
692 case ICmpInst::ICMP_SLT:
710 case ICmpInst::ICMP_EQ:
720 Known.
Zero |= ~*
C & *Mask;
726 Known.
One |= *
C & ~*Mask;
747 Known.
Zero |= RHSKnown.
Zero << ShAmt;
748 Known.
One |= RHSKnown.
One << ShAmt;
751 case ICmpInst::ICMP_NE: {
767 if (Pred == ICmpInst::ICMP_UGT || Pred == ICmpInst::ICMP_UGE) {
773 (*
C + (Pred == ICmpInst::ICMP_UGT)).countLeadingOnes());
775 if (Pred == ICmpInst::ICMP_ULT || Pred == ICmpInst::ICMP_ULE) {
781 (*
C - (Pred == ICmpInst::ICMP_ULT)).countLeadingZeros());
793 Invert ? Cmp->getInversePredicate() : Cmp->getPredicate();
826 if (
auto *Cmp = dyn_cast<ICmpInst>(
Cond))
871 "Got assumption for the wrong function!");
874 if (!V->getType()->isPointerTy())
877 *
I,
I->bundle_op_info_begin()[Elem.Index])) {
881 if (RK.WasOn == V && RK.AttrKind == Attribute::Alignment &&
893 Value *Arg =
I->getArgOperand(0);
913 ICmpInst *Cmp = dyn_cast<ICmpInst>(Arg);
949 Known = KF(Known2, Known, ShAmtNonZero);
960 Value *
X =
nullptr, *
Y =
nullptr;
962 switch (
I->getOpcode()) {
963 case Instruction::And:
964 KnownOut = KnownLHS & KnownRHS;
974 KnownOut = KnownLHS.
blsi();
976 KnownOut = KnownRHS.
blsi();
979 case Instruction::Or:
980 KnownOut = KnownLHS | KnownRHS;
982 case Instruction::Xor:
983 KnownOut = KnownLHS ^ KnownRHS;
993 const KnownBits &XBits =
I->getOperand(0) ==
X ? KnownLHS : KnownRHS;
994 KnownOut = XBits.
blsmsk();
1007 if (!KnownOut.
Zero[0] && !KnownOut.
One[0] &&
1028 APInt DemandedEltsLHS, DemandedEltsRHS;
1030 DemandedElts, DemandedEltsLHS,
1033 const auto ComputeForSingleOpFunc =
1035 return KnownBitsFunc(
1040 if (DemandedEltsRHS.
isZero())
1041 return ComputeForSingleOpFunc(
I->getOperand(0), DemandedEltsLHS);
1042 if (DemandedEltsLHS.
isZero())
1043 return ComputeForSingleOpFunc(
I->getOperand(1), DemandedEltsRHS);
1045 return ComputeForSingleOpFunc(
I->getOperand(0), DemandedEltsLHS)
1046 .intersectWith(ComputeForSingleOpFunc(
I->getOperand(1), DemandedEltsRHS));
1055 auto *FVTy = dyn_cast<FixedVectorType>(
I->getType());
1056 APInt DemandedElts =
1064 Attribute Attr =
F->getFnAttribute(Attribute::VScaleRange);
1072 return ConstantRange::getEmpty(
BitWidth);
1122 "Input should be a Select!");
1132 const Value *LHS2 =
nullptr, *RHS2 =
nullptr;
1144 return CLow->
sle(*CHigh);
1149 const APInt *&CHigh) {
1150 assert((
II->getIntrinsicID() == Intrinsic::smin ||
1151 II->getIntrinsicID() == Intrinsic::smax) &&
1152 "Must be smin/smax");
1155 auto *InnerII = dyn_cast<IntrinsicInst>(
II->getArgOperand(0));
1156 if (!InnerII || InnerII->getIntrinsicID() != InverseID ||
1161 if (
II->getIntrinsicID() == Intrinsic::smin)
1163 return CLow->
sle(*CHigh);
1168 const APInt *CLow, *CHigh;
1175 const APInt &DemandedElts,
1181 switch (
I->getOpcode()) {
1183 case Instruction::Load:
1188 case Instruction::And:
1194 case Instruction::Or:
1200 case Instruction::Xor:
1206 case Instruction::Mul: {
1210 DemandedElts, Known, Known2,
Depth, Q);
1213 case Instruction::UDiv: {
1220 case Instruction::SDiv: {
1227 case Instruction::Select: {
1228 auto ComputeForArm = [&](
Value *Arm,
bool Invert) {
1236 ComputeForArm(
I->getOperand(1),
false)
1240 case Instruction::FPTrunc:
1241 case Instruction::FPExt:
1242 case Instruction::FPToUI:
1243 case Instruction::FPToSI:
1244 case Instruction::SIToFP:
1245 case Instruction::UIToFP:
1247 case Instruction::PtrToInt:
1248 case Instruction::IntToPtr:
1251 case Instruction::ZExt:
1252 case Instruction::Trunc: {
1253 Type *SrcTy =
I->getOperand(0)->getType();
1255 unsigned SrcBitWidth;
1263 assert(SrcBitWidth &&
"SrcBitWidth can't be zero");
1266 if (
auto *Inst = dyn_cast<PossiblyNonNegInst>(
I);
1267 Inst && Inst->hasNonNeg() && !Known.
isNegative())
1272 case Instruction::BitCast: {
1273 Type *SrcTy =
I->getOperand(0)->getType();
1277 !
I->getType()->isVectorTy()) {
1285 V->getType()->isFPOrFPVectorTy()) {
1286 Type *FPType = V->getType()->getScalarType();
1299 if (FPClasses &
fcInf)
1311 if (Result.SignBit) {
1312 if (*Result.SignBit)
1322 auto *SrcVecTy = dyn_cast<FixedVectorType>(SrcTy);
1323 if (!SrcVecTy || !SrcVecTy->getElementType()->isIntegerTy() ||
1324 !
I->getType()->isIntOrIntVectorTy() ||
1325 isa<ScalableVectorType>(
I->getType()))
1330 unsigned SubBitWidth = SrcVecTy->getScalarSizeInBits();
1347 unsigned SubScale =
BitWidth / SubBitWidth;
1349 for (
unsigned i = 0; i != NumElts; ++i) {
1350 if (DemandedElts[i])
1351 SubDemandedElts.
setBit(i * SubScale);
1355 for (
unsigned i = 0; i != SubScale; ++i) {
1359 Known.
insertBits(KnownSrc, ShiftElt * SubBitWidth);
1364 case Instruction::SExt: {
1366 unsigned SrcBitWidth =
I->getOperand(0)->getType()->getScalarSizeInBits();
1368 Known = Known.
trunc(SrcBitWidth);
1375 case Instruction::Shl: {
1379 bool ShAmtNonZero) {
1380 return KnownBits::shl(KnownVal, KnownAmt, NUW, NSW, ShAmtNonZero);
1390 case Instruction::LShr: {
1391 bool Exact = Q.
IIQ.
isExact(cast<BinaryOperator>(
I));
1393 bool ShAmtNonZero) {
1404 case Instruction::AShr: {
1405 bool Exact = Q.
IIQ.
isExact(cast<BinaryOperator>(
I));
1407 bool ShAmtNonZero) {
1414 case Instruction::Sub: {
1418 DemandedElts, Known, Known2,
Depth, Q);
1421 case Instruction::Add: {
1425 DemandedElts, Known, Known2,
Depth, Q);
1428 case Instruction::SRem:
1434 case Instruction::URem:
1439 case Instruction::Alloca:
1442 case Instruction::GetElementPtr: {
1451 for (
unsigned i = 1, e =
I->getNumOperands(); i != e; ++i, ++GTI) {
1456 Value *Index =
I->getOperand(i);
1459 Constant *CIndex = dyn_cast<Constant>(Index);
1467 "Access to structure field must be known at compile time");
1472 unsigned Idx = cast<ConstantInt>(Index)->getZExtValue();
1475 AccConstIndices +=
Offset;
1486 unsigned IndexBitWidth = Index->getType()->getScalarSizeInBits();
1500 APInt ScalingFactor(IndexBitWidth, TypeSizeInBytes);
1501 IndexConst *= ScalingFactor;
1525 case Instruction::PHI: {
1528 Value *R =
nullptr, *L =
nullptr;
1541 case Instruction::LShr:
1542 case Instruction::AShr:
1543 case Instruction::Shl:
1544 case Instruction::UDiv:
1551 case Instruction::URem: {
1564 case Instruction::Shl:
1568 case Instruction::LShr:
1569 case Instruction::UDiv:
1570 case Instruction::URem:
1575 case Instruction::AShr:
1587 case Instruction::Add:
1588 case Instruction::Sub:
1589 case Instruction::And:
1590 case Instruction::Or:
1591 case Instruction::Mul: {
1598 unsigned OpNum =
P->getOperand(0) == R ? 0 : 1;
1599 Instruction *RInst =
P->getIncomingBlock(OpNum)->getTerminator();
1600 Instruction *LInst =
P->getIncomingBlock(1 - OpNum)->getTerminator();
1615 auto *OverflowOp = dyn_cast<OverflowingBinaryOperator>(BO);
1629 case Instruction::Add: {
1639 case Instruction::Sub: {
1650 case Instruction::Mul:
1667 if (
P->getNumIncomingValues() == 0)
1674 if (isa_and_nonnull<UndefValue>(
P->hasConstantValue()))
1679 for (
const Use &U :
P->operands()) {
1714 if ((TrueSucc == CxtPhi->
getParent()) !=
1731 Known2 = KnownUnion;
1745 case Instruction::Call:
1746 case Instruction::Invoke: {
1754 const auto *CB = cast<CallBase>(
I);
1756 if (std::optional<ConstantRange>
Range = CB->getRange())
1759 if (
const Value *RV = CB->getReturnedArgOperand()) {
1760 if (RV->getType() ==
I->getType()) {
1772 switch (
II->getIntrinsicID()) {
1775 case Intrinsic::abs: {
1777 bool IntMinIsPoison =
match(
II->getArgOperand(1),
m_One());
1778 Known = Known2.
abs(IntMinIsPoison);
1781 case Intrinsic::bitreverse:
1786 case Intrinsic::bswap:
1791 case Intrinsic::ctlz: {
1797 PossibleLZ = std::min(PossibleLZ,
BitWidth - 1);
1802 case Intrinsic::cttz: {
1808 PossibleTZ = std::min(PossibleTZ,
BitWidth - 1);
1813 case Intrinsic::ctpop: {
1824 case Intrinsic::fshr:
1825 case Intrinsic::fshl: {
1832 if (
II->getIntrinsicID() == Intrinsic::fshr)
1845 case Intrinsic::uadd_sat:
1850 case Intrinsic::usub_sat:
1855 case Intrinsic::sadd_sat:
1860 case Intrinsic::ssub_sat:
1866 case Intrinsic::vector_reverse:
1872 case Intrinsic::vector_reduce_and:
1873 case Intrinsic::vector_reduce_or:
1874 case Intrinsic::vector_reduce_umax:
1875 case Intrinsic::vector_reduce_umin:
1876 case Intrinsic::vector_reduce_smax:
1877 case Intrinsic::vector_reduce_smin:
1880 case Intrinsic::vector_reduce_xor: {
1885 auto *VecTy = cast<VectorType>(
I->getOperand(0)->getType());
1887 bool EvenCnt = VecTy->getElementCount().isKnownEven();
1891 if (VecTy->isScalableTy() || EvenCnt)
1895 case Intrinsic::umin:
1900 case Intrinsic::umax:
1905 case Intrinsic::smin:
1911 case Intrinsic::smax:
1917 case Intrinsic::ptrmask: {
1920 const Value *Mask =
I->getOperand(1);
1921 Known2 =
KnownBits(Mask->getType()->getScalarSizeInBits());
1927 case Intrinsic::x86_sse2_pmulh_w:
1928 case Intrinsic::x86_avx2_pmulh_w:
1929 case Intrinsic::x86_avx512_pmulh_w_512:
1934 case Intrinsic::x86_sse2_pmulhu_w:
1935 case Intrinsic::x86_avx2_pmulhu_w:
1936 case Intrinsic::x86_avx512_pmulhu_w_512:
1941 case Intrinsic::x86_sse42_crc32_64_64:
1944 case Intrinsic::x86_ssse3_phadd_d_128:
1945 case Intrinsic::x86_ssse3_phadd_w_128:
1946 case Intrinsic::x86_avx2_phadd_d:
1947 case Intrinsic::x86_avx2_phadd_w: {
1949 I, DemandedElts,
Depth, Q,
1955 case Intrinsic::x86_ssse3_phadd_sw_128:
1956 case Intrinsic::x86_avx2_phadd_sw: {
1961 case Intrinsic::x86_ssse3_phsub_d_128:
1962 case Intrinsic::x86_ssse3_phsub_w_128:
1963 case Intrinsic::x86_avx2_phsub_d:
1964 case Intrinsic::x86_avx2_phsub_w: {
1966 I, DemandedElts,
Depth, Q,
1972 case Intrinsic::x86_ssse3_phsub_sw_128:
1973 case Intrinsic::x86_avx2_phsub_sw: {
1978 case Intrinsic::riscv_vsetvli:
1979 case Intrinsic::riscv_vsetvlimax: {
1980 bool HasAVL =
II->getIntrinsicID() == Intrinsic::riscv_vsetvli;
1983 cast<ConstantInt>(
II->getArgOperand(HasAVL))->getZExtValue());
1985 cast<ConstantInt>(
II->getArgOperand(1 + HasAVL))->getZExtValue());
1992 if (
auto *CI = dyn_cast<ConstantInt>(
II->getArgOperand(0)))
1993 MaxVL = std::min(MaxVL, CI->getZExtValue());
1995 unsigned KnownZeroFirstBit =
Log2_32(MaxVL) + 1;
2000 case Intrinsic::vscale: {
2001 if (!
II->getParent() || !
II->getFunction())
2011 case Instruction::ShuffleVector: {
2012 auto *Shuf = dyn_cast<ShuffleVectorInst>(
I);
2020 APInt DemandedLHS, DemandedRHS;
2027 if (!!DemandedLHS) {
2028 const Value *
LHS = Shuf->getOperand(0);
2034 if (!!DemandedRHS) {
2035 const Value *
RHS = Shuf->getOperand(1);
2041 case Instruction::InsertElement: {
2042 if (isa<ScalableVectorType>(
I->getType())) {
2046 const Value *Vec =
I->getOperand(0);
2047 const Value *Elt =
I->getOperand(1);
2048 auto *CIdx = dyn_cast<ConstantInt>(
I->getOperand(2));
2050 APInt DemandedVecElts = DemandedElts;
2051 bool NeedsElt =
true;
2053 if (CIdx && CIdx->getValue().ult(NumElts)) {
2054 DemandedVecElts.
clearBit(CIdx->getZExtValue());
2055 NeedsElt = DemandedElts[CIdx->getZExtValue()];
2067 if (!DemandedVecElts.
isZero()) {
2073 case Instruction::ExtractElement: {
2076 const Value *Vec =
I->getOperand(0);
2078 auto *CIdx = dyn_cast<ConstantInt>(
Idx);
2079 if (isa<ScalableVectorType>(Vec->
getType())) {
2084 unsigned NumElts = cast<FixedVectorType>(Vec->
getType())->getNumElements();
2086 if (CIdx && CIdx->getValue().ult(NumElts))
2091 case Instruction::ExtractValue:
2096 switch (
II->getIntrinsicID()) {
2098 case Intrinsic::uadd_with_overflow:
2099 case Intrinsic::sadd_with_overflow:
2101 true,
II->getArgOperand(0),
II->getArgOperand(1),
false,
2102 false, DemandedElts, Known, Known2,
Depth, Q);
2104 case Intrinsic::usub_with_overflow:
2105 case Intrinsic::ssub_with_overflow:
2107 false,
II->getArgOperand(0),
II->getArgOperand(1),
false,
2108 false, DemandedElts, Known, Known2,
Depth, Q);
2110 case Intrinsic::umul_with_overflow:
2111 case Intrinsic::smul_with_overflow:
2113 false, DemandedElts, Known, Known2,
Depth, Q);
2119 case Instruction::Freeze:
2163 if (!DemandedElts) {
2169 assert(V &&
"No Value?");
2173 Type *Ty = V->getType();
2177 "Not integer or pointer type!");
2179 if (
auto *FVTy = dyn_cast<FixedVectorType>(Ty)) {
2181 FVTy->getNumElements() == DemandedElts.
getBitWidth() &&
2182 "DemandedElt width should equal the fixed vector number of elements");
2185 "DemandedElt width should be 1 for scalars or scalable vectors");
2191 "V and Known should have same BitWidth");
2194 "V and Known should have same BitWidth");
2205 if (isa<ConstantPointerNull>(V) || isa<ConstantAggregateZero>(V)) {
2212 assert(!isa<ScalableVectorType>(V->getType()));
2216 for (
unsigned i = 0, e = CDV->getNumElements(); i != e; ++i) {
2217 if (!DemandedElts[i])
2219 APInt Elt = CDV->getElementAsAPInt(i);
2228 if (
const auto *CV = dyn_cast<ConstantVector>(V)) {
2229 assert(!isa<ScalableVectorType>(V->getType()));
2233 for (
unsigned i = 0, e = CV->getNumOperands(); i != e; ++i) {
2234 if (!DemandedElts[i])
2237 if (isa<PoisonValue>(Element))
2239 auto *ElementCI = dyn_cast_or_null<ConstantInt>(Element);
2244 const APInt &Elt = ElementCI->getValue();
2257 if (isa<UndefValue>(V))
2262 assert(!isa<ConstantData>(V) &&
"Unhandled constant data!");
2264 if (
const auto *
A = dyn_cast<Argument>(V))
2265 if (std::optional<ConstantRange>
Range =
A->getRange())
2274 if (
const GlobalAlias *GA = dyn_cast<GlobalAlias>(V)) {
2275 if (!GA->isInterposable())
2280 if (
const Operator *
I = dyn_cast<Operator>(V))
2282 else if (
const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
2283 if (std::optional<ConstantRange> CR = GV->getAbsoluteSymbolRange())
2284 Known = CR->toKnownBits();
2288 if (isa<PointerType>(V->getType())) {
2289 Align Alignment = V->getPointerAlignment(Q.
DL);
2305 Value *Start =
nullptr, *Step =
nullptr;
2311 if (U.get() == Start) {
2327 case Instruction::Mul:
2332 case Instruction::SDiv:
2338 case Instruction::UDiv:
2344 case Instruction::Shl:
2346 case Instruction::AShr:
2350 case Instruction::LShr:
2368 Pred = ICmpInst::getInversePredicate(Pred);
2370 if (OrZero && Pred == ICmpInst::ICMP_ULT && *RHSC == 2)
2373 return Pred == ICmpInst::ICMP_EQ && *RHSC == 1;
2384 if (isa<Constant>(V))
2388 if (OrZero && V->getType()->getScalarSizeInBits() == 1)
2423 auto *
I = dyn_cast<Instruction>(V);
2430 return F->hasFnAttribute(Attribute::VScaleRange);
2447 switch (
I->getOpcode()) {
2448 case Instruction::ZExt:
2450 case Instruction::Trunc:
2452 case Instruction::Shl:
2456 case Instruction::LShr:
2457 if (OrZero || Q.
IIQ.
isExact(cast<BinaryOperator>(
I)))
2460 case Instruction::UDiv:
2464 case Instruction::Mul:
2468 case Instruction::And:
2479 case Instruction::Add: {
2485 if (
match(
I->getOperand(0),
2489 if (
match(
I->getOperand(1),
2494 unsigned BitWidth = V->getType()->getScalarSizeInBits();
2503 if ((~(LHSBits.
Zero & RHSBits.
Zero)).isPowerOf2())
2516 case Instruction::Select:
2519 case Instruction::PHI: {
2523 auto *PN = cast<PHINode>(
I);
2540 RecQ.CxtI = PN->getIncomingBlock(U)->getTerminator();
2541 return isKnownToBeAPowerOfTwo(U.get(), OrZero, NewDepth, RecQ);
2544 case Instruction::Invoke:
2545 case Instruction::Call: {
2546 if (
auto *
II = dyn_cast<IntrinsicInst>(
I)) {
2547 switch (
II->getIntrinsicID()) {
2548 case Intrinsic::umax:
2549 case Intrinsic::smax:
2550 case Intrinsic::umin:
2551 case Intrinsic::smin:
2556 case Intrinsic::bitreverse:
2557 case Intrinsic::bswap:
2559 case Intrinsic::fshr:
2560 case Intrinsic::fshl:
2562 if (
II->getArgOperand(0) ==
II->getArgOperand(1))
2586 F =
I->getFunction();
2590 if (!
GEP->hasNoUnsignedWrap() &&
2591 !(
GEP->isInBounds() &&
2596 assert(
GEP->getType()->isPointerTy() &&
"We only support plain pointer GEP");
2607 GTI != GTE; ++GTI) {
2609 if (
StructType *STy = GTI.getStructTypeOrNull()) {
2610 ConstantInt *OpC = cast<ConstantInt>(GTI.getOperand());
2614 if (ElementOffset > 0)
2620 if (GTI.getSequentialElementStride(Q.
DL).isZero())
2625 if (
ConstantInt *OpC = dyn_cast<ConstantInt>(GTI.getOperand())) {
2649 assert(!isa<Constant>(V) &&
"Called for constant?");
2654 unsigned NumUsesExplored = 0;
2655 for (
const auto *U : V->users()) {
2663 if (
const auto *CB = dyn_cast<CallBase>(U))
2664 if (
auto *CalledFunc = CB->getCalledFunction())
2665 for (
const Argument &Arg : CalledFunc->args())
2666 if (CB->getArgOperand(Arg.getArgNo()) == V &&
2667 Arg.hasNonNullAttr(
false) &&
2675 V->getType()->getPointerAddressSpace()) &&
2693 NonNullIfTrue =
true;
2695 NonNullIfTrue =
false;
2701 for (
const auto *CmpU : U->users()) {
2703 if (Visited.
insert(CmpU).second)
2706 while (!WorkList.
empty()) {
2715 for (
const auto *CurrU : Curr->users())
2716 if (Visited.
insert(CurrU).second)
2721 if (
const BranchInst *BI = dyn_cast<BranchInst>(Curr)) {
2722 assert(BI->isConditional() &&
"uses a comparison!");
2725 BI->getSuccessor(NonNullIfTrue ? 0 : 1);
2729 }
else if (NonNullIfTrue &&
isGuard(Curr) &&
2730 DT->
dominates(cast<Instruction>(Curr), CtxI)) {
2744 const unsigned NumRanges = Ranges->getNumOperands() / 2;
2746 for (
unsigned i = 0; i < NumRanges; ++i) {
2748 mdconst::extract<ConstantInt>(Ranges->getOperand(2 * i + 0));
2750 mdconst::extract<ConstantInt>(Ranges->getOperand(2 * i + 1));
2762 Value *Start =
nullptr, *Step =
nullptr;
2763 const APInt *StartC, *StepC;
2769 case Instruction::Add:
2775 case Instruction::Mul:
2778 case Instruction::Shl:
2780 case Instruction::AShr:
2781 case Instruction::LShr:
2797 Value *
Y,
bool NSW,
bool NUW) {
2850 if (
auto *
C = dyn_cast<Constant>(
X))
2854 return ::isKnownNonEqual(
X,
Y, DemandedElts,
Depth, Q);
2859 Value *
Y,
bool NSW,
bool NUW) {
2888 auto ShiftOp = [&](
const APInt &Lhs,
const APInt &Rhs) {
2889 switch (
I->getOpcode()) {
2890 case Instruction::Shl:
2891 return Lhs.
shl(Rhs);
2892 case Instruction::LShr:
2893 return Lhs.
lshr(Rhs);
2894 case Instruction::AShr:
2895 return Lhs.
ashr(Rhs);
2901 auto InvShiftOp = [&](
const APInt &Lhs,
const APInt &Rhs) {
2902 switch (
I->getOpcode()) {
2903 case Instruction::Shl:
2904 return Lhs.
lshr(Rhs);
2905 case Instruction::LShr:
2906 case Instruction::AShr:
2907 return Lhs.
shl(Rhs);
2920 if (MaxShift.
uge(NumBits))
2923 if (!ShiftOp(KnownVal.
One, MaxShift).isZero())
2928 if (InvShiftOp(KnownVal.
Zero, NumBits - MaxShift)
2937 const APInt &DemandedElts,
2940 switch (
I->getOpcode()) {
2941 case Instruction::Alloca:
2943 return I->getType()->getPointerAddressSpace() == 0;
2944 case Instruction::GetElementPtr:
2945 if (
I->getType()->isPointerTy())
2948 case Instruction::BitCast: {
2976 Type *FromTy =
I->getOperand(0)->getType();
2981 case Instruction::IntToPtr:
2985 if (!isa<ScalableVectorType>(
I->getType()) &&
2990 case Instruction::PtrToInt:
2993 if (!isa<ScalableVectorType>(
I->getType()) &&
2998 case Instruction::Trunc:
3000 if (
auto *TI = dyn_cast<TruncInst>(
I))
3001 if (TI->hasNoSignedWrap() || TI->hasNoUnsignedWrap())
3005 case Instruction::Sub:
3008 case Instruction::Xor:
3013 case Instruction::Or:
3020 case Instruction::SExt:
3021 case Instruction::ZExt:
3025 case Instruction::Shl: {
3040 case Instruction::LShr:
3041 case Instruction::AShr: {
3056 case Instruction::UDiv:
3057 case Instruction::SDiv: {
3060 if (cast<PossiblyExactOperator>(
I)->isExact())
3072 if (
I->getOpcode() == Instruction::SDiv) {
3074 XKnown = XKnown.
abs(
false);
3075 YKnown = YKnown.
abs(
false);
3081 return XUgeY && *XUgeY;
3083 case Instruction::Add: {
3088 auto *BO = cast<OverflowingBinaryOperator>(
I);
3093 case Instruction::Mul: {
3099 case Instruction::Select: {
3106 auto SelectArmIsNonZero = [&](
bool IsTrueArm) {
3108 Op = IsTrueArm ?
I->getOperand(1) :
I->getOperand(2);
3121 Pred = ICmpInst::getInversePredicate(Pred);
3126 if (SelectArmIsNonZero(
true) &&
3127 SelectArmIsNonZero(
false))
3131 case Instruction::PHI: {
3132 auto *PN = cast<PHINode>(
I);
3142 RecQ.CxtI = PN->getIncomingBlock(U)->getTerminator();
3146 BasicBlock *TrueSucc, *FalseSucc;
3147 if (match(RecQ.CxtI,
3148 m_Br(m_c_ICmp(Pred, m_Specific(U.get()), m_Value(X)),
3149 m_BasicBlock(TrueSucc), m_BasicBlock(FalseSucc)))) {
3151 if ((TrueSucc == PN->getParent()) != (FalseSucc == PN->getParent())) {
3153 if (FalseSucc == PN->getParent())
3154 Pred = CmpInst::getInversePredicate(Pred);
3155 if (cmpExcludesZero(Pred, X))
3163 case Instruction::InsertElement: {
3164 if (isa<ScalableVectorType>(
I->getType()))
3167 const Value *Vec =
I->getOperand(0);
3168 const Value *Elt =
I->getOperand(1);
3169 auto *CIdx = dyn_cast<ConstantInt>(
I->getOperand(2));
3172 APInt DemandedVecElts = DemandedElts;
3173 bool SkipElt =
false;
3175 if (CIdx && CIdx->getValue().ult(NumElts)) {
3176 DemandedVecElts.
clearBit(CIdx->getZExtValue());
3177 SkipElt = !DemandedElts[CIdx->getZExtValue()];
3183 (DemandedVecElts.
isZero() ||
3186 case Instruction::ExtractElement:
3187 if (
const auto *EEI = dyn_cast<ExtractElementInst>(
I)) {
3188 const Value *Vec = EEI->getVectorOperand();
3189 const Value *
Idx = EEI->getIndexOperand();
3190 auto *CIdx = dyn_cast<ConstantInt>(
Idx);
3191 if (
auto *VecTy = dyn_cast<FixedVectorType>(Vec->
getType())) {
3192 unsigned NumElts = VecTy->getNumElements();
3194 if (CIdx && CIdx->getValue().ult(NumElts))
3200 case Instruction::ShuffleVector: {
3201 auto *Shuf = dyn_cast<ShuffleVectorInst>(
I);
3204 APInt DemandedLHS, DemandedRHS;
3210 return (DemandedRHS.
isZero() ||
3215 case Instruction::Freeze:
3219 case Instruction::Load: {
3220 auto *LI = cast<LoadInst>(
I);
3223 if (
auto *PtrT = dyn_cast<PointerType>(
I->getType())) {
3236 case Instruction::ExtractValue: {
3242 case Instruction::Add:
3247 case Instruction::Sub:
3250 case Instruction::Mul:
3259 case Instruction::Call:
3260 case Instruction::Invoke: {
3261 const auto *Call = cast<CallBase>(
I);
3262 if (
I->getType()->isPointerTy()) {
3263 if (Call->isReturnNonNull())
3270 if (std::optional<ConstantRange>
Range = Call->getRange()) {
3275 if (
const Value *RV = Call->getReturnedArgOperand())
3280 if (
auto *
II = dyn_cast<IntrinsicInst>(
I)) {
3281 switch (
II->getIntrinsicID()) {
3282 case Intrinsic::sshl_sat:
3283 case Intrinsic::ushl_sat:
3284 case Intrinsic::abs:
3285 case Intrinsic::bitreverse:
3286 case Intrinsic::bswap:
3287 case Intrinsic::ctpop:
3291 case Intrinsic::ssub_sat:
3293 II->getArgOperand(0),
II->getArgOperand(1));
3294 case Intrinsic::sadd_sat:
3296 II->getArgOperand(0),
II->getArgOperand(1),
3299 case Intrinsic::vector_reverse:
3303 case Intrinsic::vector_reduce_or:
3304 case Intrinsic::vector_reduce_umax:
3305 case Intrinsic::vector_reduce_umin:
3306 case Intrinsic::vector_reduce_smax:
3307 case Intrinsic::vector_reduce_smin:
3309 case Intrinsic::umax:
3310 case Intrinsic::uadd_sat:
3318 case Intrinsic::smax: {
3321 auto IsNonZero = [&](
Value *
Op, std::optional<bool> &OpNonZero,
3323 if (!OpNonZero.has_value())
3324 OpNonZero = OpKnown.isNonZero() ||
3329 std::optional<bool> Op0NonZero, Op1NonZero;
3333 IsNonZero(
II->getArgOperand(1), Op1NonZero, Op1Known))
3338 IsNonZero(
II->getArgOperand(0), Op0NonZero, Op0Known))
3340 return IsNonZero(
II->getArgOperand(1), Op1NonZero, Op1Known) &&
3341 IsNonZero(
II->getArgOperand(0), Op0NonZero, Op0Known);
3343 case Intrinsic::smin: {
3359 case Intrinsic::umin:
3362 case Intrinsic::cttz:
3365 case Intrinsic::ctlz:
3368 case Intrinsic::fshr:
3369 case Intrinsic::fshl:
3371 if (
II->getArgOperand(0) ==
II->getArgOperand(1))
3374 case Intrinsic::vscale:
3376 case Intrinsic::experimental_get_vector_length:
3390 return Known.
One != 0;
3401 Type *Ty = V->getType();
3406 if (
auto *FVTy = dyn_cast<FixedVectorType>(Ty)) {
3408 FVTy->getNumElements() == DemandedElts.
getBitWidth() &&
3409 "DemandedElt width should equal the fixed vector number of elements");
3412 "DemandedElt width should be 1 for scalars");
3416 if (
auto *
C = dyn_cast<Constant>(V)) {
3417 if (
C->isNullValue())
3419 if (isa<ConstantInt>(
C))
3425 if (
auto *VecTy = dyn_cast<FixedVectorType>(Ty)) {
3426 for (
unsigned i = 0, e = VecTy->getNumElements(); i != e; ++i) {
3427 if (!DemandedElts[i])
3429 Constant *Elt =
C->getAggregateElement(i);
3432 if (!isa<PoisonValue>(Elt) && !isa<ConstantInt>(Elt))
3439 if (
auto *CPA = dyn_cast<ConstantPtrAuth>(V))
3445 if (
const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
3446 if (!GV->isAbsoluteSymbolRef() && !GV->hasExternalWeakLinkage() &&
3447 GV->getType()->getAddressSpace() == 0)
3452 if (!isa<ConstantExpr>(V))
3456 if (
const auto *
A = dyn_cast<Argument>(V))
3457 if (std::optional<ConstantRange>
Range =
A->getRange()) {
3472 if (
PointerType *PtrTy = dyn_cast<PointerType>(Ty)) {
3475 if (
const Argument *
A = dyn_cast<Argument>(V)) {
3476 if (((
A->hasPassPointeeByValueCopyAttr() &&
3478 A->hasNonNullAttr()))
3483 if (
const auto *
I = dyn_cast<Operator>(V))
3487 if (!isa<Constant>(V) &&
3496 auto *FVTy = dyn_cast<FixedVectorType>(V->getType());
3497 APInt DemandedElts =
3499 return ::isKnownNonZero(V, DemandedElts, Q,
Depth);
3508static std::optional<std::pair<Value*, Value*>>
3512 return std::nullopt;
3521 case Instruction::Or:
3522 if (!cast<PossiblyDisjointInst>(Op1)->isDisjoint() ||
3523 !cast<PossiblyDisjointInst>(Op2)->isDisjoint())
3526 case Instruction::Xor:
3527 case Instruction::Add: {
3535 case Instruction::Sub:
3541 case Instruction::Mul: {
3545 auto *OBO1 = cast<OverflowingBinaryOperator>(Op1);
3546 auto *OBO2 = cast<OverflowingBinaryOperator>(Op2);
3547 if ((!OBO1->hasNoUnsignedWrap() || !OBO2->hasNoUnsignedWrap()) &&
3548 (!OBO1->hasNoSignedWrap() || !OBO2->hasNoSignedWrap()))
3554 !cast<ConstantInt>(Op1->
getOperand(1))->isZero())
3558 case Instruction::Shl: {
3561 auto *OBO1 = cast<OverflowingBinaryOperator>(Op1);
3562 auto *OBO2 = cast<OverflowingBinaryOperator>(Op2);
3563 if ((!OBO1->hasNoUnsignedWrap() || !OBO2->hasNoUnsignedWrap()) &&
3564 (!OBO1->hasNoSignedWrap() || !OBO2->hasNoSignedWrap()))
3571 case Instruction::AShr:
3572 case Instruction::LShr: {
3573 auto *PEO1 = cast<PossiblyExactOperator>(Op1);
3574 auto *PEO2 = cast<PossiblyExactOperator>(Op2);
3575 if (!PEO1->isExact() || !PEO2->isExact())
3582 case Instruction::SExt:
3583 case Instruction::ZExt:
3587 case Instruction::PHI: {
3588 const PHINode *PN1 = cast<PHINode>(Op1);
3589 const PHINode *PN2 = cast<PHINode>(Op2);
3595 Value *Start1 =
nullptr, *Step1 =
nullptr;
3597 Value *Start2 =
nullptr, *Step2 =
nullptr;
3604 cast<Operator>(BO2));
3613 if (Values->first != PN1 || Values->second != PN2)
3616 return std::make_pair(Start1, Start2);
3619 return std::nullopt;
3634 case Instruction::Or:
3635 if (!cast<PossiblyDisjointInst>(V1)->isDisjoint())
3638 case Instruction::Xor:
3639 case Instruction::Add:
3657 if (
auto *OBO = dyn_cast<OverflowingBinaryOperator>(V2)) {
3660 (OBO->hasNoUnsignedWrap() || OBO->hasNoSignedWrap()) &&
3661 !
C->isZero() && !
C->isOne() &&
3672 if (
auto *OBO = dyn_cast<OverflowingBinaryOperator>(V2)) {
3675 (OBO->hasNoUnsignedWrap() || OBO->hasNoSignedWrap()) &&
3689 bool UsedFullRecursion =
false;
3691 if (!VisitedBBs.
insert(IncomBB).second)
3695 const APInt *C1, *C2;
3700 if (UsedFullRecursion)
3704 RecQ.
CxtI = IncomBB->getTerminator();
3707 UsedFullRecursion =
true;
3715 const SelectInst *SI1 = dyn_cast<SelectInst>(V1);
3719 if (
const SelectInst *SI2 = dyn_cast<SelectInst>(V2)) {
3721 const Value *Cond2 = SI2->getCondition();
3724 DemandedElts,
Depth + 1, Q) &&
3726 DemandedElts,
Depth + 1, Q);
3739 if (!
A->getType()->isPointerTy() || !
B->getType()->isPointerTy())
3742 auto *GEPA = dyn_cast<GEPOperator>(
A);
3743 if (!GEPA || GEPA->getNumIndices() != 1 || !isa<Constant>(GEPA->idx_begin()))
3747 auto *PN = dyn_cast<PHINode>(GEPA->getPointerOperand());
3748 if (!PN || PN->getNumIncomingValues() != 2)
3753 Value *Start =
nullptr;
3755 if (PN->getIncomingValue(0) == Step)
3756 Start = PN->getIncomingValue(1);
3757 else if (PN->getIncomingValue(1) == Step)
3758 Start = PN->getIncomingValue(0);
3769 APInt StartOffset(IndexWidth, 0);
3770 Start = Start->stripAndAccumulateInBoundsConstantOffsets(Q.
DL, StartOffset);
3771 APInt StepOffset(IndexWidth, 0);
3777 APInt OffsetB(IndexWidth, 0);
3778 B =
B->stripAndAccumulateInBoundsConstantOffsets(Q.
DL, OffsetB);
3779 return Start ==
B &&
3790 if (V1->
getType() != V2->getType())
3800 auto *O1 = dyn_cast<Operator>(V1);
3801 auto *O2 = dyn_cast<Operator>(V2);
3802 if (O1 && O2 && O1->getOpcode() == O2->getOpcode()) {
3807 if (
const PHINode *PN1 = dyn_cast<PHINode>(V1)) {
3808 const PHINode *PN2 = cast<PHINode>(V2);
3863 const APInt &DemandedElts,
3865 const auto *CV = dyn_cast<Constant>(V);
3866 if (!CV || !isa<FixedVectorType>(CV->getType()))
3869 unsigned MinSignBits = TyBits;
3870 unsigned NumElts = cast<FixedVectorType>(CV->getType())->getNumElements();
3871 for (
unsigned i = 0; i != NumElts; ++i) {
3872 if (!DemandedElts[i])
3875 auto *Elt = dyn_cast_or_null<ConstantInt>(CV->getAggregateElement(i));
3879 MinSignBits = std::min(MinSignBits, Elt->getValue().getNumSignBits());
3886 const APInt &DemandedElts,
3892 assert(Result > 0 &&
"At least one sign bit needs to be present!");
3904 const APInt &DemandedElts,
3906 Type *Ty = V->getType();
3910 if (
auto *FVTy = dyn_cast<FixedVectorType>(Ty)) {
3912 FVTy->getNumElements() == DemandedElts.
getBitWidth() &&
3913 "DemandedElt width should equal the fixed vector number of elements");
3916 "DemandedElt width should be 1 for scalars");
3930 unsigned FirstAnswer = 1;
3938 if (
auto *U = dyn_cast<Operator>(V)) {
3941 case Instruction::SExt:
3942 Tmp = TyBits - U->getOperand(0)->getType()->getScalarSizeInBits();
3946 case Instruction::SDiv: {
3947 const APInt *Denominator;
3960 return std::min(TyBits, NumBits + Denominator->
logBase2());
3965 case Instruction::SRem: {
3968 const APInt *Denominator;
3989 unsigned ResBits = TyBits - Denominator->
ceilLogBase2();
3990 Tmp = std::max(Tmp, ResBits);
3996 case Instruction::AShr: {
4001 if (ShAmt->
uge(TyBits))
4004 Tmp += ShAmtLimited;
4005 if (Tmp > TyBits) Tmp = TyBits;
4009 case Instruction::Shl: {
4014 if (ShAmt->
uge(TyBits))
4019 ShAmt->
uge(TyBits -
X->getType()->getScalarSizeInBits())) {
4021 Tmp += TyBits -
X->getType()->getScalarSizeInBits();
4025 if (ShAmt->
uge(Tmp))
4032 case Instruction::And:
4033 case Instruction::Or:
4034 case Instruction::Xor:
4039 FirstAnswer = std::min(Tmp, Tmp2);
4046 case Instruction::Select: {
4050 const APInt *CLow, *CHigh;
4058 return std::min(Tmp, Tmp2);
4061 case Instruction::Add:
4065 if (Tmp == 1)
break;
4068 if (
const auto *CRHS = dyn_cast<Constant>(U->getOperand(1)))
4069 if (CRHS->isAllOnesValue()) {
4075 if ((Known.
Zero | 1).isAllOnes())
4087 return std::min(Tmp, Tmp2) - 1;
4089 case Instruction::Sub:
4095 if (
const auto *CLHS = dyn_cast<Constant>(U->getOperand(0)))
4096 if (CLHS->isNullValue()) {
4101 if ((Known.
Zero | 1).isAllOnes())
4118 return std::min(Tmp, Tmp2) - 1;
4120 case Instruction::Mul: {
4123 unsigned SignBitsOp0 =
4125 if (SignBitsOp0 == 1)
4127 unsigned SignBitsOp1 =
4129 if (SignBitsOp1 == 1)
4131 unsigned OutValidBits =
4132 (TyBits - SignBitsOp0 + 1) + (TyBits - SignBitsOp1 + 1);
4133 return OutValidBits > TyBits ? 1 : TyBits - OutValidBits + 1;
4136 case Instruction::PHI: {
4137 const PHINode *PN = cast<PHINode>(U);
4140 if (NumIncomingValues > 4)
break;
4142 if (NumIncomingValues == 0)
break;
4148 for (
unsigned i = 0, e = NumIncomingValues; i != e; ++i) {
4149 if (Tmp == 1)
return Tmp;
4152 DemandedElts,
Depth + 1, RecQ));
4157 case Instruction::Trunc: {
4162 unsigned OperandTyBits = U->getOperand(0)->getType()->getScalarSizeInBits();
4163 if (Tmp > (OperandTyBits - TyBits))
4164 return Tmp - (OperandTyBits - TyBits);
4169 case Instruction::ExtractElement:
4176 case Instruction::ShuffleVector: {
4179 auto *Shuf = dyn_cast<ShuffleVectorInst>(U);
4184 APInt DemandedLHS, DemandedRHS;
4189 Tmp = std::numeric_limits<unsigned>::max();
4190 if (!!DemandedLHS) {
4191 const Value *
LHS = Shuf->getOperand(0);
4198 if (!!DemandedRHS) {
4199 const Value *
RHS = Shuf->getOperand(1);
4201 Tmp = std::min(Tmp, Tmp2);
4207 assert(Tmp <= TyBits &&
"Failed to determine minimum sign bits");
4210 case Instruction::Call: {
4211 if (
const auto *
II = dyn_cast<IntrinsicInst>(U)) {
4212 switch (
II->getIntrinsicID()) {
4215 case Intrinsic::abs:
4223 case Intrinsic::smin:
4224 case Intrinsic::smax: {
4225 const APInt *CLow, *CHigh;
4240 if (
unsigned VecSignBits =
4258 if (
F->isIntrinsic())
4259 return F->getIntrinsicID();
4265 if (
F->hasLocalLinkage() || !TLI || !TLI->
getLibFunc(CB, Func) ||
4275 return Intrinsic::sin;
4279 return Intrinsic::cos;
4283 return Intrinsic::tan;
4287 return Intrinsic::asin;
4291 return Intrinsic::acos;
4295 return Intrinsic::atan;
4297 case LibFunc_atan2f:
4298 case LibFunc_atan2l:
4299 return Intrinsic::atan2;
4303 return Intrinsic::sinh;
4307 return Intrinsic::cosh;
4311 return Intrinsic::tanh;
4315 return Intrinsic::exp;
4319 return Intrinsic::exp2;
4321 case LibFunc_exp10f:
4322 case LibFunc_exp10l:
4323 return Intrinsic::exp10;
4327 return Intrinsic::log;
4329 case LibFunc_log10f:
4330 case LibFunc_log10l:
4331 return Intrinsic::log10;
4335 return Intrinsic::log2;
4339 return Intrinsic::fabs;
4343 return Intrinsic::minnum;
4347 return Intrinsic::maxnum;
4348 case LibFunc_copysign:
4349 case LibFunc_copysignf:
4350 case LibFunc_copysignl:
4351 return Intrinsic::copysign;
4353 case LibFunc_floorf:
4354 case LibFunc_floorl:
4355 return Intrinsic::floor;
4359 return Intrinsic::ceil;
4361 case LibFunc_truncf:
4362 case LibFunc_truncl:
4363 return Intrinsic::trunc;
4367 return Intrinsic::rint;
4368 case LibFunc_nearbyint:
4369 case LibFunc_nearbyintf:
4370 case LibFunc_nearbyintl:
4371 return Intrinsic::nearbyint;
4373 case LibFunc_roundf:
4374 case LibFunc_roundl:
4375 return Intrinsic::round;
4376 case LibFunc_roundeven:
4377 case LibFunc_roundevenf:
4378 case LibFunc_roundevenl:
4379 return Intrinsic::roundeven;
4383 return Intrinsic::pow;
4387 return Intrinsic::sqrt;
4435 switch (Mode.Input) {
4455 if (!Src.isKnownNeverPosZero() && !Src.isKnownNeverNegZero())
4459 if (Src.isKnownNeverSubnormal())
4489 bool &TrueIfSigned) {
4492 TrueIfSigned =
true;
4493 return RHS.isZero();
4495 TrueIfSigned =
true;
4496 return RHS.isAllOnes();
4498 TrueIfSigned =
false;
4499 return RHS.isAllOnes();
4501 TrueIfSigned =
false;
4502 return RHS.isZero();
4505 TrueIfSigned =
true;
4506 return RHS.isMaxSignedValue();
4509 TrueIfSigned =
true;
4510 return RHS.isMinSignedValue();
4513 TrueIfSigned =
false;
4514 return RHS.isMinSignedValue();
4517 TrueIfSigned =
false;
4518 return RHS.isMaxSignedValue();
4529 bool LookThroughSrc) {
4537std::pair<Value *, FPClassTest>
4539 const APFloat *ConstRHS,
bool LookThroughSrc) {
4541 auto [Src, ClassIfTrue, ClassIfFalse] =
4543 if (Src && ClassIfTrue == ~ClassIfFalse)
4544 return {Src, ClassIfTrue};
4555std::tuple<Value *, FPClassTest, FPClassTest>
4569 const bool IsNegativeRHS = (RHSClass &
fcNegative) == RHSClass;
4570 const bool IsPositiveRHS = (RHSClass &
fcPositive) == RHSClass;
4571 const bool IsNaN = (RHSClass & ~fcNan) ==
fcNone;
4591 const bool IsZero = (OrigClass &
fcZero) == OrigClass;
4638 const bool IsDenormalRHS = (OrigClass &
fcSubnormal) == OrigClass;
4640 const bool IsInf = (OrigClass &
fcInf) == OrigClass;
4658 if (IsNegativeRHS) {
4681 if (IsNegativeRHS) {
4682 Mask = ~fcNegInf & ~fcNan;
4686 Mask = ~fcPosInf & ~fcNan;
4695 if (IsNegativeRHS) {
4715 if (IsNegativeRHS) {
4735 if (IsNegativeRHS) {
4750 if (IsNegativeRHS) {
4778 return {Src, Class, ~fcNan};
4782 return {Src, ~fcNan, RHSClass |
fcNan};
4791 "should have been recognized as an exact class test");
4793 if (IsNegativeRHS) {
4803 return {Src, ~fcNan,
fcNan};
4812 return {Src,
fcNan, ~fcNan};
4831 return {Src, ClassesGE, ~ClassesGE | RHSClass};
4834 return {Src, ClassesGE |
fcNan, ~(ClassesGE |
fcNan) | RHSClass};
4837 return {Src, ClassesLE, ~ClassesLE | RHSClass};
4840 return {Src, ClassesLE |
fcNan, ~(ClassesLE |
fcNan) | RHSClass};
4844 }
else if (IsPositiveRHS) {
4860 return {Src, ClassesGE, ~ClassesGE | RHSClass};
4863 return {Src, ClassesGE |
fcNan, ~(ClassesGE |
fcNan) | RHSClass};
4866 return {Src, ClassesLE, ~ClassesLE | RHSClass};
4869 return {Src, ClassesLE |
fcNan, ~(ClassesLE |
fcNan) | RHSClass};
4878std::tuple<Value *, FPClassTest, FPClassTest>
4880 const APFloat &ConstRHS,
bool LookThroughSrc) {
4928std::tuple<Value *, FPClassTest, FPClassTest>
4930 Value *RHS,
bool LookThroughSrc) {
4940 unsigned Depth,
bool CondIsTrue,
4962 KnownFromContext.
knownNot(~(CondIsTrue ? MaskIfTrue : MaskIfFalse));
4963 }
else if (
match(
Cond, m_Intrinsic<Intrinsic::is_fpclass>(
4966 KnownFromContext.
knownNot(CondIsTrue ? ~Mask : Mask);
4972 if (TrueIfSigned == CondIsTrue)
4984 return KnownFromContext;
4994 Q.
CxtI, KnownFromContext);
4999 Q.
CxtI, KnownFromContext);
5004 return KnownFromContext;
5014 "Got assumption for the wrong function!");
5015 assert(
I->getIntrinsicID() == Intrinsic::assume &&
5016 "must be an assume intrinsic");
5022 true, Q.
CxtI, KnownFromContext);
5025 return KnownFromContext;
5035 auto *FVTy = dyn_cast<FixedVectorType>(V->getType());
5036 APInt DemandedElts =
5042 const APInt &DemandedElts,
5046 if ((InterestedClasses &
5052 KnownSrc,
Depth + 1, Q);
5067 assert(Known.
isUnknown() &&
"should not be called with known information");
5069 if (!DemandedElts) {
5077 if (
auto *CFP = dyn_cast<ConstantFP>(V)) {
5079 Known.
SignBit = CFP->isNegative();
5083 if (isa<ConstantAggregateZero>(V)) {
5089 if (isa<PoisonValue>(V)) {
5096 auto *VFVTy = dyn_cast<FixedVectorType>(V->getType());
5097 const Constant *CV = dyn_cast<Constant>(V);
5100 bool SignBitAllZero =
true;
5101 bool SignBitAllOne =
true;
5104 unsigned NumElts = VFVTy->getNumElements();
5105 for (
unsigned i = 0; i != NumElts; ++i) {
5106 if (!DemandedElts[i])
5114 if (isa<PoisonValue>(Elt))
5116 auto *CElt = dyn_cast<ConstantFP>(Elt);
5122 const APFloat &
C = CElt->getValueAPF();
5125 SignBitAllZero =
false;
5127 SignBitAllOne =
false;
5129 if (SignBitAllOne != SignBitAllZero)
5130 Known.
SignBit = SignBitAllOne;
5135 if (
const auto *CB = dyn_cast<CallBase>(V))
5136 KnownNotFromFlags |= CB->getRetNoFPClass();
5137 else if (
const auto *Arg = dyn_cast<Argument>(V))
5138 KnownNotFromFlags |= Arg->getNoFPClass();
5142 if (FPOp->hasNoNaNs())
5143 KnownNotFromFlags |=
fcNan;
5144 if (FPOp->hasNoInfs())
5145 KnownNotFromFlags |=
fcInf;
5149 KnownNotFromFlags |= ~AssumedClasses.KnownFPClasses;
5153 InterestedClasses &= ~KnownNotFromFlags;
5158 if (*AssumedClasses.SignBit)
5159 Known.signBitMustBeOne();
5161 Known.signBitMustBeZero();
5172 const unsigned Opc =
Op->getOpcode();
5174 case Instruction::FNeg: {
5176 Known,
Depth + 1, Q);
5180 case Instruction::Select: {
5188 Value *TestedValue =
nullptr;
5192 const Function *
F = cast<Instruction>(
Op)->getFunction();
5194 Value *CmpLHS, *CmpRHS;
5201 bool LookThroughFAbsFNeg = CmpLHS !=
LHS && CmpLHS !=
RHS;
5202 std::tie(TestedValue, MaskIfTrue, MaskIfFalse) =
5205 m_Intrinsic<Intrinsic::is_fpclass>(
5208 MaskIfTrue = TestedMask;
5209 MaskIfFalse = ~TestedMask;
5212 if (TestedValue ==
LHS) {
5214 FilterLHS = MaskIfTrue;
5215 }
else if (TestedValue ==
RHS) {
5217 FilterRHS = MaskIfFalse;
5226 Known2,
Depth + 1, Q);
5232 case Instruction::Call: {
5236 case Intrinsic::fabs: {
5241 InterestedClasses, Known,
Depth + 1, Q);
5247 case Intrinsic::copysign: {
5251 Known,
Depth + 1, Q);
5253 KnownSign,
Depth + 1, Q);
5257 case Intrinsic::fma:
5258 case Intrinsic::fmuladd: {
5262 if (
II->getArgOperand(0) !=
II->getArgOperand(1))
5271 KnownAddend,
Depth + 1, Q);
5277 case Intrinsic::sqrt:
5278 case Intrinsic::experimental_constrained_sqrt: {
5281 if (InterestedClasses &
fcNan)
5285 KnownSrc,
Depth + 1, Q);
5308 case Intrinsic::sin:
5309 case Intrinsic::cos: {
5313 KnownSrc,
Depth + 1, Q);
5319 case Intrinsic::maxnum:
5320 case Intrinsic::minnum:
5321 case Intrinsic::minimum:
5322 case Intrinsic::maximum: {
5325 KnownLHS,
Depth + 1, Q);
5327 KnownRHS,
Depth + 1, Q);
5330 Known = KnownLHS | KnownRHS;
5333 if (NeverNaN && (IID == Intrinsic::minnum || IID == Intrinsic::maxnum))
5336 if (IID == Intrinsic::maxnum) {
5344 }
else if (IID == Intrinsic::maximum) {
5350 }
else if (IID == Intrinsic::minnum) {
5380 II->getType()->getScalarType()->getFltSemantics());
5392 }
else if ((IID == Intrinsic::maximum || IID == Intrinsic::minimum) ||
5397 if ((IID == Intrinsic::maximum || IID == Intrinsic::maxnum) &&
5400 else if ((IID == Intrinsic::minimum || IID == Intrinsic::minnum) &&
5407 case Intrinsic::canonicalize: {
5410 KnownSrc,
Depth + 1, Q);
5434 II->getType()->getScalarType()->getFltSemantics();
5454 case Intrinsic::vector_reduce_fmax:
5455 case Intrinsic::vector_reduce_fmin:
5456 case Intrinsic::vector_reduce_fmaximum:
5457 case Intrinsic::vector_reduce_fminimum: {
5461 InterestedClasses,
Depth + 1, Q);
5468 case Intrinsic::vector_reverse:
5471 II->getFastMathFlags(), InterestedClasses,
Depth + 1, Q);
5473 case Intrinsic::trunc:
5474 case Intrinsic::floor:
5475 case Intrinsic::ceil:
5476 case Intrinsic::rint:
5477 case Intrinsic::nearbyint:
5478 case Intrinsic::round:
5479 case Intrinsic::roundeven: {
5487 KnownSrc,
Depth + 1, Q);
5496 if (IID == Intrinsic::trunc || !V->getType()->isMultiUnitFPType()) {
5511 case Intrinsic::exp:
5512 case Intrinsic::exp2:
5513 case Intrinsic::exp10: {
5520 KnownSrc,
Depth + 1, Q);
5528 case Intrinsic::fptrunc_round: {
5533 case Intrinsic::log:
5534 case Intrinsic::log10:
5535 case Intrinsic::log2:
5536 case Intrinsic::experimental_constrained_log:
5537 case Intrinsic::experimental_constrained_log10:
5538 case Intrinsic::experimental_constrained_log2: {
5554 KnownSrc,
Depth + 1, Q);
5568 case Intrinsic::powi: {
5572 const Value *Exp =
II->getArgOperand(1);
5573 Type *ExpTy = Exp->getType();
5577 ExponentKnownBits,
Depth + 1, Q);
5579 if (ExponentKnownBits.
Zero[0]) {
5594 KnownSrc,
Depth + 1, Q);
5599 case Intrinsic::ldexp: {
5602 KnownSrc,
Depth + 1, Q);
5618 if ((InterestedClasses & ExpInfoMask) ==
fcNone)
5624 II->getType()->getScalarType()->getFltSemantics();
5626 const Value *ExpArg =
II->getArgOperand(1);
5630 const int MantissaBits = Precision - 1;
5636 if (ConstVal && ConstVal->
isZero()) {
5659 case Intrinsic::arithmetic_fence: {
5661 Known,
Depth + 1, Q);
5664 case Intrinsic::experimental_constrained_sitofp:
5665 case Intrinsic::experimental_constrained_uitofp:
5675 if (IID == Intrinsic::experimental_constrained_uitofp)
5686 case Instruction::FAdd:
5687 case Instruction::FSub: {
5690 Op->getOpcode() == Instruction::FAdd &&
5692 bool WantNaN = (InterestedClasses &
fcNan) !=
fcNone;
5695 if (!WantNaN && !WantNegative && !WantNegZero)
5701 if (InterestedClasses &
fcNan)
5702 InterestedSrcs |=
fcInf;
5704 KnownRHS,
Depth + 1, Q);
5708 WantNegZero || Opc == Instruction::FSub) {
5713 KnownLHS,
Depth + 1, Q);
5721 const Function *
F = cast<Instruction>(
Op)->getFunction();
5723 if (
Op->getOpcode() == Instruction::FAdd) {
5751 case Instruction::FMul: {
5753 if (
Op->getOperand(0) ==
Op->getOperand(1))
5786 const Function *
F = cast<Instruction>(
Op)->getFunction();
5798 case Instruction::FDiv:
5799 case Instruction::FRem: {
5800 if (
Op->getOperand(0) ==
Op->getOperand(1)) {
5802 if (
Op->getOpcode() == Instruction::FDiv) {
5813 const bool WantNan = (InterestedClasses &
fcNan) !=
fcNone;
5815 const bool WantPositive =
5817 if (!WantNan && !WantNegative && !WantPositive)
5826 bool KnowSomethingUseful =
5829 if (KnowSomethingUseful || WantPositive) {
5835 InterestedClasses & InterestedLHS, KnownLHS,
5839 const Function *
F = cast<Instruction>(
Op)->getFunction();
5841 if (
Op->getOpcode() == Instruction::FDiv) {
5878 case Instruction::FPExt: {
5881 Known,
Depth + 1, Q);
5884 Op->getType()->getScalarType()->getFltSemantics();
5886 Op->getOperand(0)->getType()->getScalarType()->getFltSemantics();
5902 case Instruction::FPTrunc: {
5907 case Instruction::SIToFP:
5908 case Instruction::UIToFP: {
5917 if (
Op->getOpcode() == Instruction::UIToFP)
5920 if (InterestedClasses &
fcInf) {
5924 int IntSize =
Op->getOperand(0)->getType()->getScalarSizeInBits();
5925 if (
Op->getOpcode() == Instruction::SIToFP)
5930 Type *FPTy =
Op->getType()->getScalarType();
5937 case Instruction::ExtractElement: {
5940 const Value *Vec =
Op->getOperand(0);
5942 auto *CIdx = dyn_cast<ConstantInt>(
Idx);
5944 if (
auto *VecTy = dyn_cast<FixedVectorType>(Vec->
getType())) {
5945 unsigned NumElts = VecTy->getNumElements();
5947 if (CIdx && CIdx->getValue().ult(NumElts))
5955 case Instruction::InsertElement: {
5956 if (isa<ScalableVectorType>(
Op->getType()))
5959 const Value *Vec =
Op->getOperand(0);
5960 const Value *Elt =
Op->getOperand(1);
5961 auto *CIdx = dyn_cast<ConstantInt>(
Op->getOperand(2));
5963 APInt DemandedVecElts = DemandedElts;
5964 bool NeedsElt =
true;
5966 if (CIdx && CIdx->getValue().ult(NumElts)) {
5967 DemandedVecElts.
clearBit(CIdx->getZExtValue());
5968 NeedsElt = DemandedElts[CIdx->getZExtValue()];
5982 if (!DemandedVecElts.
isZero()) {
5991 case Instruction::ShuffleVector: {
5994 APInt DemandedLHS, DemandedRHS;
5995 auto *Shuf = dyn_cast<ShuffleVectorInst>(
Op);
5999 if (!!DemandedLHS) {
6000 const Value *
LHS = Shuf->getOperand(0);
6011 if (!!DemandedRHS) {
6013 const Value *
RHS = Shuf->getOperand(1);
6021 case Instruction::ExtractValue: {
6025 if (isa<StructType>(Src->getType()) && Indices.
size() == 1 &&
6027 if (
const auto *
II = dyn_cast<IntrinsicInst>(Src)) {
6028 switch (
II->getIntrinsicID()) {
6029 case Intrinsic::frexp: {
6034 InterestedClasses, KnownSrc,
Depth + 1, Q);
6036 const Function *
F = cast<Instruction>(
Op)->getFunction();
6069 case Instruction::PHI: {
6072 if (
P->getNumIncomingValues() == 0)
6079 if (
Depth < PhiRecursionLimit) {
6081 if (isa_and_nonnull<UndefValue>(
P->hasConstantValue()))
6086 for (
const Use &U :
P->operands()) {
6116 case Instruction::BitCast: {
6119 !Src->getType()->isIntOrIntVectorTy())
6122 const Type *Ty =
Op->getType()->getScalarType();
6127 if (Bits.isNonNegative())
6129 else if (Bits.isNegative())
6148 InfKB.Zero.clearSignBit();
6150 assert(!InfResult.value());
6152 }
else if (Bits == InfKB) {
6160 ZeroKB.Zero.clearSignBit();
6162 assert(!ZeroResult.value());
6164 }
else if (Bits == ZeroKB) {
6177 const APInt &DemandedElts,
6184 return KnownClasses;
6199 if (V->getType()->isIntegerTy(8))
6206 if (isa<UndefValue>(V))
6210 if (
DL.getTypeStoreSize(V->getType()).isZero())
6225 if (
C->isNullValue())
6232 if (CFP->getType()->isHalfTy())
6234 else if (CFP->getType()->isFloatTy())
6236 else if (CFP->getType()->isDoubleTy())
6245 if (CI->getBitWidth() % 8 == 0) {
6246 assert(CI->getBitWidth() > 8 &&
"8 bits should be handled above!");
6247 if (!CI->getValue().isSplat(8))
6249 return ConstantInt::get(Ctx, CI->getValue().trunc(8));
6253 if (
auto *CE = dyn_cast<ConstantExpr>(
C)) {
6254 if (CE->getOpcode() == Instruction::IntToPtr) {
6255 if (
auto *PtrTy = dyn_cast<PointerType>(CE->getType())) {
6256 unsigned BitWidth =
DL.getPointerSizeInBits(PtrTy->getAddressSpace());
6269 if (
LHS == UndefInt8)
6271 if (
RHS == UndefInt8)
6277 Value *Val = UndefInt8;
6278 for (
unsigned I = 0, E = CA->getNumElements();
I != E; ++
I)
6284 if (isa<ConstantAggregate>(
C)) {
6285 Value *Val = UndefInt8;
6306 StructType *STy = dyn_cast<StructType>(IndexedType);
6320 while (PrevTo != OrigTo) {
6367 unsigned IdxSkip = Idxs.
size();
6380 std::optional<BasicBlock::iterator> InsertBefore) {
6383 if (idx_range.
empty())
6386 assert((V->getType()->isStructTy() || V->getType()->isArrayTy()) &&
6387 "Not looking at a struct or array?");
6389 "Invalid indices for type?");
6391 if (
Constant *
C = dyn_cast<Constant>(V)) {
6392 C =
C->getAggregateElement(idx_range[0]);
6393 if (!
C)
return nullptr;
6400 const unsigned *req_idx = idx_range.
begin();
6401 for (
const unsigned *i =
I->idx_begin(), *e =
I->idx_end();
6402 i != e; ++i, ++req_idx) {
6403 if (req_idx == idx_range.
end()) {
6433 ArrayRef(req_idx, idx_range.
end()), InsertBefore);
6442 unsigned size =
I->getNumIndices() + idx_range.
size();
6447 Idxs.
append(
I->idx_begin(),
I->idx_end());
6453 &&
"Number of indices added not correct?");
6463 unsigned CharSize) {
6465 if (
GEP->getNumOperands() != 3)
6470 ArrayType *AT = dyn_cast<ArrayType>(
GEP->getSourceElementType());
6476 const ConstantInt *FirstIdx = dyn_cast<ConstantInt>(
GEP->getOperand(1));
6477 if (!FirstIdx || !FirstIdx->
isZero())
6491 assert(V &&
"V should not be null.");
6492 assert((ElementSize % 8) == 0 &&
6493 "ElementSize expected to be a multiple of the size of a byte.");
6494 unsigned ElementSizeInBytes = ElementSize / 8;
6506 APInt Off(
DL.getIndexTypeSizeInBits(V->getType()), 0);
6508 if (GV != V->stripAndAccumulateConstantOffsets(
DL, Off,
6513 uint64_t StartIdx = Off.getLimitedValue();
6520 if ((StartIdx % ElementSizeInBytes) != 0)
6523 Offset += StartIdx / ElementSizeInBytes;
6529 uint64_t SizeInBytes =
DL.getTypeStoreSize(GVTy).getFixedValue();
6532 Slice.
Array =
nullptr;
6543 if (
auto *ArrayInit = dyn_cast<ConstantDataArray>(
Init)) {
6544 Type *InitElTy = ArrayInit->getElementType();
6549 ArrayTy = ArrayInit->getType();
6554 if (ElementSize != 8)
6565 Array = dyn_cast<ConstantDataArray>(
Init);
6566 ArrayTy = dyn_cast<ArrayType>(
Init->getType());
6573 Slice.
Array = Array;
6589 if (Slice.
Array ==
nullptr) {
6612 Str = Str.substr(Slice.
Offset);
6618 Str = Str.substr(0, Str.find(
'\0'));
6631 unsigned CharSize) {
6633 V = V->stripPointerCasts();
6637 if (
const PHINode *PN = dyn_cast<PHINode>(V)) {
6638 if (!PHIs.
insert(PN).second)
6643 for (
Value *IncValue : PN->incoming_values()) {
6645 if (Len == 0)
return 0;
6647 if (Len == ~0ULL)
continue;
6649 if (Len != LenSoFar && LenSoFar != ~0ULL)
6659 if (
const SelectInst *SI = dyn_cast<SelectInst>(V)) {
6661 if (Len1 == 0)
return 0;
6663 if (Len2 == 0)
return 0;
6664 if (Len1 == ~0ULL)
return Len2;
6665 if (Len2 == ~0ULL)
return Len1;
6666 if (Len1 != Len2)
return 0;
6675 if (Slice.
Array ==
nullptr)
6683 unsigned NullIndex = 0;
6684 for (
unsigned E = Slice.
Length; NullIndex < E; ++NullIndex) {
6689 return NullIndex + 1;
6695 if (!V->getType()->isPointerTy())
6702 return Len == ~0ULL ? 1 : Len;
6707 bool MustPreserveNullness) {
6709 "getArgumentAliasingToReturnedPointer only works on nonnull calls");
6710 if (
const Value *RV = Call->getReturnedArgOperand())
6714 Call, MustPreserveNullness))
6715 return Call->getArgOperand(0);
6720 const CallBase *Call,
bool MustPreserveNullness) {
6721 switch (Call->getIntrinsicID()) {
6722 case Intrinsic::launder_invariant_group:
6723 case Intrinsic::strip_invariant_group:
6724 case Intrinsic::aarch64_irg:
6725 case Intrinsic::aarch64_tagp:
6735 case Intrinsic::amdgcn_make_buffer_rsrc:
6737 case Intrinsic::ptrmask:
6738 return !MustPreserveNullness;
6739 case Intrinsic::threadlocal_address:
6742 return !Call->getParent()->getParent()->isPresplitCoroutine();
6759 if (!PrevValue || LI->
getLoopFor(PrevValue->getParent()) != L)
6761 if (!PrevValue || LI->
getLoopFor(PrevValue->getParent()) != L)
6769 if (
auto *Load = dyn_cast<LoadInst>(PrevValue))
6770 if (!L->isLoopInvariant(Load->getPointerOperand()))
6776 for (
unsigned Count = 0; MaxLookup == 0 || Count < MaxLookup; ++Count) {
6777 if (
auto *
GEP = dyn_cast<GEPOperator>(V)) {
6778 const Value *PtrOp =
GEP->getPointerOperand();
6784 Value *NewV = cast<Operator>(V)->getOperand(0);
6788 }
else if (
auto *GA = dyn_cast<GlobalAlias>(V)) {
6789 if (GA->isInterposable())
6791 V = GA->getAliasee();
6793 if (
auto *
PHI = dyn_cast<PHINode>(V)) {
6795 if (
PHI->getNumIncomingValues() == 1) {
6796 V =
PHI->getIncomingValue(0);
6799 }
else if (
auto *Call = dyn_cast<CallBase>(V)) {
6817 assert(V->getType()->isPointerTy() &&
"Unexpected operand type!");
6824 const LoopInfo *LI,
unsigned MaxLookup) {
6832 if (!Visited.
insert(
P).second)
6835 if (
auto *SI = dyn_cast<SelectInst>(
P)) {
6837 Worklist.
push_back(SI->getFalseValue());
6841 if (
auto *PN = dyn_cast<PHINode>(
P)) {
6861 }
while (!Worklist.
empty());
6865 const unsigned MaxVisited = 8;
6870 const Value *Object =
nullptr;
6880 if (!Visited.
insert(
P).second)
6883 if (Visited.
size() == MaxVisited)
6886 if (
auto *SI = dyn_cast<SelectInst>(
P)) {
6888 Worklist.
push_back(SI->getFalseValue());
6892 if (
auto *PN = dyn_cast<PHINode>(
P)) {
6899 else if (Object !=
P)
6901 }
while (!Worklist.
empty());
6903 return Object ? Object : FirstObject;
6910 if (
const Operator *U = dyn_cast<Operator>(V)) {
6913 if (U->getOpcode() == Instruction::PtrToInt)
6914 return U->getOperand(0);
6921 if (U->getOpcode() != Instruction::Add ||
6922 (!isa<ConstantInt>(U->getOperand(1)) &&
6924 !isa<PHINode>(U->getOperand(1))))
6926 V = U->getOperand(0);
6930 assert(V->getType()->isIntegerTy() &&
"Unexpected operand type!");
6947 for (
const Value *V : Objs) {
6948 if (!Visited.
insert(V).second)
6953 if (O->getType()->isPointerTy()) {
6966 }
while (!Working.
empty());
6975 auto AddWork = [&](
Value *V) {
6976 if (Visited.
insert(V).second)
6985 if (
AllocaInst *AI = dyn_cast<AllocaInst>(V)) {
6986 if (Result && Result != AI)
6989 }
else if (
CastInst *CI = dyn_cast<CastInst>(V)) {
6990 AddWork(CI->getOperand(0));
6991 }
else if (
PHINode *PN = dyn_cast<PHINode>(V)) {
6992 for (
Value *IncValue : PN->incoming_values())
6994 }
else if (
auto *SI = dyn_cast<SelectInst>(V)) {
6995 AddWork(SI->getTrueValue());
6996 AddWork(SI->getFalseValue());
6998 if (OffsetZero && !
GEP->hasAllZeroIndices())
7000 AddWork(
GEP->getPointerOperand());
7001 }
else if (
CallBase *CB = dyn_cast<CallBase>(V)) {
7002 Value *Returned = CB->getReturnedArgOperand();
7010 }
while (!Worklist.
empty());
7016 const Value *V,
bool AllowLifetime,
bool AllowDroppable) {
7017 for (
const User *U : V->users()) {
7022 if (AllowLifetime &&
II->isLifetimeStartOrEnd())
7025 if (AllowDroppable &&
II->isDroppable())
7043 if (
auto *
II = dyn_cast<IntrinsicInst>(
I))
7045 auto *Shuffle = dyn_cast<ShuffleVectorInst>(
I);
7046 return (!Shuffle || Shuffle->isSelect()) &&
7047 !isa<CallBase, BitCastInst, ExtractElementInst>(
I);
7055 bool UseVariableInfo) {
7057 AC, DT, TLI, UseVariableInfo);
7063 bool UseVariableInfo) {
7067 auto hasEqualReturnAndLeadingOperandTypes =
7068 [](
const Instruction *Inst,
unsigned NumLeadingOperands) {
7072 for (
unsigned ItOp = 0; ItOp < NumLeadingOperands; ++ItOp)
7078 hasEqualReturnAndLeadingOperandTypes(Inst, 2));
7080 hasEqualReturnAndLeadingOperandTypes(Inst, 1));
7087 case Instruction::UDiv:
7088 case Instruction::URem: {
7095 case Instruction::SDiv:
7096 case Instruction::SRem: {
7098 const APInt *Numerator, *Denominator;
7102 if (*Denominator == 0)
7114 case Instruction::Load: {
7115 if (!UseVariableInfo)
7118 const LoadInst *LI = dyn_cast<LoadInst>(Inst);
7128 case Instruction::Call: {
7129 auto *CI = dyn_cast<const CallInst>(Inst);
7132 const Function *Callee = CI->getCalledFunction();
7136 return Callee && Callee->isSpeculatable();
7138 case Instruction::VAArg:
7139 case Instruction::Alloca:
7140 case Instruction::Invoke:
7141 case Instruction::CallBr:
7142 case Instruction::PHI:
7143 case Instruction::Store:
7144 case Instruction::Ret:
7145 case Instruction::Br:
7146 case Instruction::IndirectBr:
7147 case Instruction::Switch:
7148 case Instruction::Unreachable:
7149 case Instruction::Fence:
7150 case Instruction::AtomicRMW:
7151 case Instruction::AtomicCmpXchg:
7152 case Instruction::LandingPad:
7153 case Instruction::Resume:
7154 case Instruction::CatchSwitch:
7155 case Instruction::CatchPad:
7156 case Instruction::CatchRet:
7157 case Instruction::CleanupPad:
7158 case Instruction::CleanupRet:
7164 if (
I.mayReadOrWriteMemory())
7277 if (
Add &&
Add->hasNoSignedWrap()) {
7317 bool LHSOrRHSKnownNonNegative =
7319 bool LHSOrRHSKnownNegative =
7321 if (LHSOrRHSKnownNonNegative || LHSOrRHSKnownNegative) {
7324 if ((AddKnown.
isNonNegative() && LHSOrRHSKnownNonNegative) ||
7325 (AddKnown.
isNegative() && LHSOrRHSKnownNegative))
7400 if (
const auto *EVI = dyn_cast<ExtractValueInst>(U)) {
7401 assert(EVI->getNumIndices() == 1 &&
"Obvious from CI's type");
7403 if (EVI->getIndices()[0] == 0)
7406 assert(EVI->getIndices()[0] == 1 &&
"Obvious from CI's type");
7408 for (
const auto *U : EVI->users())
7409 if (
const auto *
B = dyn_cast<BranchInst>(U)) {
7410 assert(
B->isConditional() &&
"How else is it using an i1?");
7421 auto AllUsesGuardedByBranch = [&](
const BranchInst *BI) {
7427 for (
const auto *Result :
Results) {
7430 if (DT.
dominates(NoWrapEdge, Result->getParent()))
7433 for (
const auto &RU : Result->uses())
7441 return llvm::any_of(GuardingBranches, AllUsesGuardedByBranch);
7446 auto *
C = dyn_cast<Constant>(ShiftAmount);
7452 if (
auto *FVTy = dyn_cast<FixedVectorType>(
C->getType())) {
7453 unsigned NumElts = FVTy->getNumElements();
7454 for (
unsigned i = 0; i < NumElts; ++i)
7455 ShiftAmounts.
push_back(
C->getAggregateElement(i));
7456 }
else if (isa<ScalableVectorType>(
C->getType()))
7462 auto *CI = dyn_cast_or_null<ConstantInt>(
C);
7463 return CI && CI->getValue().ult(
C->getType()->getIntegerBitWidth());
7476 return (
unsigned(Kind) &
unsigned(UndefPoisonKind::PoisonOnly)) != 0;
7480 return (
unsigned(Kind) &
unsigned(UndefPoisonKind::UndefOnly)) != 0;
7484 bool ConsiderFlagsAndMetadata) {
7487 Op->hasPoisonGeneratingAnnotations())
7490 unsigned Opcode =
Op->getOpcode();
7494 case Instruction::Shl:
7495 case Instruction::AShr:
7496 case Instruction::LShr:
7498 case Instruction::FPToSI:
7499 case Instruction::FPToUI:
7503 case Instruction::Call:
7504 if (
auto *
II = dyn_cast<IntrinsicInst>(
Op)) {
7505 switch (
II->getIntrinsicID()) {
7507 case Intrinsic::ctlz:
7508 case Intrinsic::cttz:
7509 case Intrinsic::abs:
7510 if (cast<ConstantInt>(
II->getArgOperand(1))->isNullValue())
7513 case Intrinsic::ctpop:
7514 case Intrinsic::bswap:
7515 case Intrinsic::bitreverse:
7516 case Intrinsic::fshl:
7517 case Intrinsic::fshr:
7518 case Intrinsic::smax:
7519 case Intrinsic::smin:
7520 case Intrinsic::umax:
7521 case Intrinsic::umin:
7522 case Intrinsic::ptrmask:
7523 case Intrinsic::fptoui_sat:
7524 case Intrinsic::fptosi_sat:
7525 case Intrinsic::sadd_with_overflow:
7526 case Intrinsic::ssub_with_overflow:
7527 case Intrinsic::smul_with_overflow:
7528 case Intrinsic::uadd_with_overflow:
7529 case Intrinsic::usub_with_overflow:
7530 case Intrinsic::umul_with_overflow:
7531 case Intrinsic::sadd_sat:
7532 case Intrinsic::uadd_sat:
7533 case Intrinsic::ssub_sat:
7534 case Intrinsic::usub_sat:
7536 case Intrinsic::sshl_sat:
7537 case Intrinsic::ushl_sat:
7540 case Intrinsic::fma:
7541 case Intrinsic::fmuladd:
7542 case Intrinsic::sqrt:
7543 case Intrinsic::powi:
7544 case Intrinsic::sin:
7545 case Intrinsic::cos:
7546 case Intrinsic::pow:
7547 case Intrinsic::log:
7548 case Intrinsic::log10:
7549 case Intrinsic::log2:
7550 case Intrinsic::exp:
7551 case Intrinsic::exp2:
7552 case Intrinsic::exp10:
7553 case Intrinsic::fabs:
7554 case Intrinsic::copysign:
7555 case Intrinsic::floor:
7556 case Intrinsic::ceil:
7557 case Intrinsic::trunc:
7558 case Intrinsic::rint:
7559 case Intrinsic::nearbyint:
7560 case Intrinsic::round:
7561 case Intrinsic::roundeven:
7562 case Intrinsic::fptrunc_round:
7563 case Intrinsic::canonicalize:
7564 case Intrinsic::arithmetic_fence:
7565 case Intrinsic::minnum:
7566 case Intrinsic::maxnum:
7567 case Intrinsic::minimum:
7568 case Intrinsic::maximum:
7569 case Intrinsic::is_fpclass:
7570 case Intrinsic::ldexp:
7571 case Intrinsic::frexp:
7573 case Intrinsic::lround:
7574 case Intrinsic::llround:
7575 case Intrinsic::lrint:
7576 case Intrinsic::llrint:
7583 case Instruction::CallBr:
7584 case Instruction::Invoke: {
7585 const auto *CB = cast<CallBase>(
Op);
7586 return !CB->hasRetAttr(Attribute::NoUndef);
7588 case Instruction::InsertElement:
7589 case Instruction::ExtractElement: {
7591 auto *VTy = cast<VectorType>(
Op->getOperand(0)->getType());
7592 unsigned IdxOp =
Op->getOpcode() == Instruction::InsertElement ? 2 : 1;
7593 auto *
Idx = dyn_cast<ConstantInt>(
Op->getOperand(IdxOp));
7596 Idx->getValue().uge(VTy->getElementCount().getKnownMinValue());
7599 case Instruction::ShuffleVector: {
7601 ? cast<ConstantExpr>(
Op)->getShuffleMask()
7602 : cast<ShuffleVectorInst>(
Op)->getShuffleMask();
7605 case Instruction::FNeg:
7606 case Instruction::PHI:
7607 case Instruction::Select:
7608 case Instruction::URem:
7609 case Instruction::SRem:
7610 case Instruction::ExtractValue:
7611 case Instruction::InsertValue:
7612 case Instruction::Freeze:
7613 case Instruction::ICmp:
7614 case Instruction::FCmp:
7615 case Instruction::FAdd:
7616 case Instruction::FSub:
7617 case Instruction::FMul:
7618 case Instruction::FDiv:
7619 case Instruction::FRem:
7621 case Instruction::GetElementPtr:
7626 const auto *CE = dyn_cast<ConstantExpr>(
Op);
7627 if (isa<CastInst>(
Op) || (CE && CE->isCast()))
7638 bool ConsiderFlagsAndMetadata) {
7639 return ::canCreateUndefOrPoison(
Op, UndefPoisonKind::UndefOrPoison,
7640 ConsiderFlagsAndMetadata);
7644 return ::canCreateUndefOrPoison(
Op, UndefPoisonKind::PoisonOnly,
7645 ConsiderFlagsAndMetadata);
7650 if (ValAssumedPoison == V)
7653 const unsigned MaxDepth = 2;
7654 if (
Depth >= MaxDepth)
7657 if (
const auto *
I = dyn_cast<Instruction>(V)) {
7659 return propagatesPoison(Op) &&
7660 directlyImpliesPoison(ValAssumedPoison, Op, Depth + 1);
7684 const unsigned MaxDepth = 2;
7685 if (
Depth >= MaxDepth)
7688 const auto *
I = dyn_cast<Instruction>(ValAssumedPoison);
7691 return impliesPoison(Op, V, Depth + 1);
7698 return ::impliesPoison(ValAssumedPoison, V, 0);
7709 if (isa<MetadataAsValue>(V))
7712 if (
const auto *
A = dyn_cast<Argument>(V)) {
7713 if (
A->hasAttribute(Attribute::NoUndef) ||
7714 A->hasAttribute(Attribute::Dereferenceable) ||
7715 A->hasAttribute(Attribute::DereferenceableOrNull))
7719 if (
auto *
C = dyn_cast<Constant>(V)) {
7720 if (isa<PoisonValue>(
C))
7723 if (isa<UndefValue>(
C))
7726 if (isa<ConstantInt>(
C) || isa<GlobalVariable>(
C) || isa<ConstantFP>(V) ||
7727 isa<ConstantPointerNull>(
C) || isa<Function>(
C))
7730 if (
C->getType()->isVectorTy() && !isa<ConstantExpr>(
C)) {
7735 return !
C->containsConstantExpression();
7747 auto *StrippedV = V->stripPointerCastsSameRepresentation();
7748 if (isa<AllocaInst>(StrippedV) || isa<GlobalVariable>(StrippedV) ||
7749 isa<Function>(StrippedV) || isa<ConstantPointerNull>(StrippedV))
7752 auto OpCheck = [&](
const Value *V) {
7756 if (
auto *Opr = dyn_cast<Operator>(V)) {
7759 if (isa<FreezeInst>(V))
7762 if (
const auto *CB = dyn_cast<CallBase>(V)) {
7763 if (CB->hasRetAttr(Attribute::NoUndef) ||
7764 CB->hasRetAttr(Attribute::Dereferenceable) ||
7765 CB->hasRetAttr(Attribute::DereferenceableOrNull))
7769 if (
const auto *PN = dyn_cast<PHINode>(V)) {
7770 unsigned Num = PN->getNumIncomingValues();
7771 bool IsWellDefined =
true;
7772 for (
unsigned i = 0; i < Num; ++i) {
7773 auto *TI = PN->getIncomingBlock(i)->getTerminator();
7775 DT,
Depth + 1, Kind)) {
7776 IsWellDefined =
false;
7784 all_of(Opr->operands(), OpCheck))
7788 if (
auto *
I = dyn_cast<LoadInst>(V))
7789 if (
I->hasMetadata(LLVMContext::MD_noundef) ||
7790 I->hasMetadata(LLVMContext::MD_dereferenceable) ||
7791 I->hasMetadata(LLVMContext::MD_dereferenceable_or_null))
7811 auto *Dominator = DNode->
getIDom();
7816 auto *TI = Dominator->
getBlock()->getTerminator();
7819 if (
auto BI = dyn_cast_or_null<BranchInst>(TI)) {
7820 if (BI->isConditional())
7821 Cond = BI->getCondition();
7822 }
else if (
auto SI = dyn_cast_or_null<SwitchInst>(TI)) {
7823 Cond = SI->getCondition();
7831 auto *Opr = cast<Operator>(
Cond);
7832 if (
any_of(Opr->operands(), [V](
const Use &U) {
7833 return V == U && propagatesPoison(U);
7839 Dominator = Dominator->getIDom();
7852 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT,
Depth,
7853 UndefPoisonKind::UndefOrPoison);
7859 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT,
Depth,
7860 UndefPoisonKind::PoisonOnly);
7866 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT,
Depth,
7867 UndefPoisonKind::UndefOnly);
7890 while (!Worklist.
empty()) {
7899 if (
I != Root && !
any_of(
I->operands(), [&KnownPoison](
const Use &U) {
7900 return KnownPoison.contains(U) && propagatesPoison(U);
7904 if (KnownPoison.
insert(
I).second)
7916 return ::computeOverflowForSignedAdd(
Add->getOperand(0),
Add->getOperand(1),
7924 return ::computeOverflowForSignedAdd(
LHS,
RHS,
nullptr, SQ);
7933 if (isa<ReturnInst>(
I))
7935 if (isa<UnreachableInst>(
I))
7942 if (isa<CatchPadInst>(
I)) {
7956 return !
I->mayThrow() &&
I->willReturn();
7970 unsigned ScanLimit) {
7977 assert(ScanLimit &&
"scan limit must be non-zero");
7979 if (isa<DbgInfoIntrinsic>(
I))
7981 if (--ScanLimit == 0)
7995 if (
I->getParent() != L->getHeader())
return false;
7998 if (&LI ==
I)
return true;
8001 llvm_unreachable(
"Instruction not contained in its own parent basic block.");
8006 switch (
I->getOpcode()) {
8007 case Instruction::Freeze:
8008 case Instruction::PHI:
8009 case Instruction::Invoke:
8011 case Instruction::Select:
8013 case Instruction::Call:
8014 if (
auto *
II = dyn_cast<IntrinsicInst>(
I)) {
8015 switch (
II->getIntrinsicID()) {
8017 case Intrinsic::sadd_with_overflow:
8018 case Intrinsic::ssub_with_overflow:
8019 case Intrinsic::smul_with_overflow:
8020 case Intrinsic::uadd_with_overflow:
8021 case Intrinsic::usub_with_overflow:
8022 case Intrinsic::umul_with_overflow:
8027 case Intrinsic::ctpop:
8028 case Intrinsic::ctlz:
8029 case Intrinsic::cttz:
8030 case Intrinsic::abs:
8031 case Intrinsic::smax:
8032 case Intrinsic::smin:
8033 case Intrinsic::umax:
8034 case Intrinsic::umin:
8035 case Intrinsic::bitreverse:
8036 case Intrinsic::bswap:
8037 case Intrinsic::sadd_sat:
8038 case Intrinsic::ssub_sat:
8039 case Intrinsic::sshl_sat:
8040 case Intrinsic::uadd_sat:
8041 case Intrinsic::usub_sat:
8042 case Intrinsic::ushl_sat:
8047 case Instruction::ICmp:
8048 case Instruction::FCmp:
8049 case Instruction::GetElementPtr:
8052 if (isa<BinaryOperator>(
I) || isa<UnaryOperator>(
I) || isa<CastInst>(
I))
8063template <
typename CallableT>
8065 const CallableT &Handle) {
8066 switch (
I->getOpcode()) {
8067 case Instruction::Store:
8072 case Instruction::Load:
8079 case Instruction::AtomicCmpXchg:
8084 case Instruction::AtomicRMW:
8089 case Instruction::Call:
8090 case Instruction::Invoke: {
8094 for (
unsigned i = 0; i < CB->
arg_size(); ++i)
8097 CB->
paramHasAttr(i, Attribute::DereferenceableOrNull)) &&
8102 case Instruction::Ret:
8103 if (
I->getFunction()->hasRetAttribute(Attribute::NoUndef) &&
8104 Handle(
I->getOperand(0)))
8107 case Instruction::Switch:
8108 if (Handle(cast<SwitchInst>(
I)->getCondition()))
8111 case Instruction::Br: {
8112 auto *BR = cast<BranchInst>(
I);
8113 if (BR->isConditional() && Handle(BR->getCondition()))
8133template <
typename CallableT>
8135 const CallableT &Handle) {
8138 switch (
I->getOpcode()) {
8140 case Instruction::UDiv:
8141 case Instruction::SDiv:
8142 case Instruction::URem:
8143 case Instruction::SRem:
8144 return Handle(
I->getOperand(1));
8161 I, [&](
const Value *V) {
return KnownPoison.
count(V); });
8175 if (
const auto *Inst = dyn_cast<Instruction>(V)) {
8179 }
else if (
const auto *Arg = dyn_cast<Argument>(V)) {
8180 if (Arg->getParent()->isDeclaration())
8183 Begin = BB->
begin();
8190 unsigned ScanLimit = 32;
8199 if (isa<DbgInfoIntrinsic>(
I))
8201 if (--ScanLimit == 0)
8205 return WellDefinedOp == V;
8225 if (isa<DbgInfoIntrinsic>(
I))
8227 if (--ScanLimit == 0)
8235 for (
const Use &
Op :
I.operands()) {
8245 if (
I.getOpcode() == Instruction::Select &&
8246 YieldsPoison.
count(
I.getOperand(1)) &&
8247 YieldsPoison.
count(
I.getOperand(2))) {
8253 if (!BB || !Visited.
insert(BB).second)
8263 return ::programUndefinedIfUndefOrPoison(Inst,
false);
8267 return ::programUndefinedIfUndefOrPoison(Inst,
true);
8274 if (
auto *
C = dyn_cast<ConstantFP>(V))
8277 if (
auto *
C = dyn_cast<ConstantDataVector>(V)) {
8278 if (!
C->getElementType()->isFloatingPointTy())
8280 for (
unsigned I = 0, E =
C->getNumElements();
I < E; ++
I) {
8281 if (
C->getElementAsAPFloat(
I).isNaN())
8287 if (isa<ConstantAggregateZero>(V))
8294 if (
auto *
C = dyn_cast<ConstantFP>(V))
8295 return !
C->isZero();
8297 if (
auto *
C = dyn_cast<ConstantDataVector>(V)) {
8298 if (!
C->getElementType()->isFloatingPointTy())
8300 for (
unsigned I = 0, E =
C->getNumElements();
I < E; ++
I) {
8301 if (
C->getElementAsAPFloat(
I).isZero())
8324 if (CmpRHS == FalseVal) {
8368 if (CmpRHS != TrueVal) {
8407 Value *
A =
nullptr, *
B =
nullptr;
8412 Value *
C =
nullptr, *
D =
nullptr;
8414 if (L.Flavor != R.Flavor)
8466 return {L.Flavor,
SPNB_NA,
false};
8473 return {L.Flavor,
SPNB_NA,
false};
8480 return {L.Flavor,
SPNB_NA,
false};
8487 return {L.Flavor,
SPNB_NA,
false};
8503 return ConstantInt::get(V->getType(), ~(*
C));
8560 if ((CmpLHS == TrueVal &&
match(FalseVal,
m_APInt(C2))) ||
8580 assert(
X &&
Y &&
"Invalid operand");
8582 auto IsNegationOf = [&](
const Value *
X,
const Value *
Y) {
8586 auto *BO = cast<BinaryOperator>(
X);
8587 if (NeedNSW && !BO->hasNoSignedWrap())
8590 auto *Zero = cast<Constant>(BO->getOperand(0));
8591 if (!AllowPoison && !Zero->isNullValue())
8598 if (IsNegationOf(
X,
Y) || IsNegationOf(
Y,
X))
8618 if (cast<ICmpInst>(
X)->hasSameSign() != cast<ICmpInst>(
Y)->hasSameSign())
8625 const APInt *RHSC1, *RHSC2;
8630 if (cast<ICmpInst>(
X)->hasSameSign() &&
8637 return CR1.inverse() == CR2;
8671std::optional<std::pair<CmpPredicate, Constant *>>
8674 "Only for relational integer predicates.");
8675 if (isa<UndefValue>(
C))
8676 return std::nullopt;
8682 bool WillIncrement =
8687 auto ConstantIsOk = [WillIncrement, IsSigned](
ConstantInt *
C) {
8688 return WillIncrement ? !
C->isMaxValue(IsSigned) : !
C->isMinValue(IsSigned);
8691 Constant *SafeReplacementConstant =
nullptr;
8692 if (
auto *CI = dyn_cast<ConstantInt>(
C)) {
8694 if (!ConstantIsOk(CI))
8695 return std::nullopt;
8696 }
else if (
auto *FVTy = dyn_cast<FixedVectorType>(
Type)) {
8697 unsigned NumElts = FVTy->getNumElements();
8698 for (
unsigned i = 0; i != NumElts; ++i) {
8699 Constant *Elt =
C->getAggregateElement(i);
8701 return std::nullopt;
8703 if (isa<UndefValue>(Elt))
8708 auto *CI = dyn_cast<ConstantInt>(Elt);
8709 if (!CI || !ConstantIsOk(CI))
8710 return std::nullopt;
8712 if (!SafeReplacementConstant)
8713 SafeReplacementConstant = CI;
8715 }
else if (isa<VectorType>(
C->getType())) {
8717 Value *SplatC =
C->getSplatValue();
8718 auto *CI = dyn_cast_or_null<ConstantInt>(SplatC);
8720 if (!CI || !ConstantIsOk(CI))
8721 return std::nullopt;
8724 return std::nullopt;
8731 if (
C->containsUndefOrPoisonElement()) {
8732 assert(SafeReplacementConstant &&
"Replacement constant not set");
8739 Constant *OneOrNegOne = ConstantInt::get(
Type, WillIncrement ? 1 : -1,
true);
8742 return std::make_pair(NewPred, NewC);
8751 bool HasMismatchedZeros =
false;
8757 Value *OutputZeroVal =
nullptr;
8759 !cast<Constant>(TrueVal)->containsUndefOrPoisonElement())
8760 OutputZeroVal = TrueVal;
8762 !cast<Constant>(FalseVal)->containsUndefOrPoisonElement())
8763 OutputZeroVal = FalseVal;
8765 if (OutputZeroVal) {
8767 HasMismatchedZeros =
true;
8768 CmpLHS = OutputZeroVal;
8771 HasMismatchedZeros =
true;
8772 CmpRHS = OutputZeroVal;
8789 if (!HasMismatchedZeros)
8800 bool Ordered =
false;
8811 if (LHSSafe && RHSSafe) {
8841 if (TrueVal == CmpRHS && FalseVal == CmpLHS) {
8852 if (TrueVal == CmpLHS && FalseVal == CmpRHS)
8858 auto MaybeSExtCmpLHS =
8862 if (
match(TrueVal, MaybeSExtCmpLHS)) {
8884 else if (
match(FalseVal, MaybeSExtCmpLHS)) {
8924 case Instruction::ZExt:
8928 case Instruction::SExt:
8932 case Instruction::Trunc:
8935 CmpConst->
getType() == SrcTy) {
8957 CastedTo = CmpConst;
8959 unsigned ExtOp = CmpI->
isSigned() ? Instruction::SExt : Instruction::ZExt;
8963 case Instruction::FPTrunc:
8966 case Instruction::FPExt:
8969 case Instruction::FPToUI:
8972 case Instruction::FPToSI:
8975 case Instruction::UIToFP:
8978 case Instruction::SIToFP:
8991 if (CastedBack && CastedBack !=
C)
9015 auto *Cast1 = dyn_cast<CastInst>(V1);
9019 *CastOp = Cast1->getOpcode();
9020 Type *SrcTy = Cast1->getSrcTy();
9021 if (
auto *Cast2 = dyn_cast<CastInst>(V2)) {
9023 if (*CastOp == Cast2->getOpcode() && SrcTy == Cast2->getSrcTy())
9024 return Cast2->getOperand(0);
9028 auto *
C = dyn_cast<Constant>(V2);
9032 Value *CastedTo =
nullptr;
9033 if (*CastOp == Instruction::Trunc) {
9046 assert(V2->getType() == Cast1->getType() &&
9047 "V2 and Cast1 should be the same type.");
9063 CmpInst *CmpI = dyn_cast<CmpInst>(SI->getCondition());
9066 Value *TrueVal = SI->getTrueValue();
9067 Value *FalseVal = SI->getFalseValue();
9080 if (isa<FPMathOperator>(CmpI))
9088 if (CastOp && CmpLHS->
getType() != TrueVal->getType()) {
9092 if (*CastOp == Instruction::FPToSI || *CastOp == Instruction::FPToUI)
9094 return ::matchSelectPattern(Pred, FMF, CmpLHS, CmpRHS,
9095 cast<CastInst>(TrueVal)->getOperand(0),
C,
9101 if (*CastOp == Instruction::FPToSI || *CastOp == Instruction::FPToUI)
9103 return ::matchSelectPattern(Pred, FMF, CmpLHS, CmpRHS,
9104 C, cast<CastInst>(FalseVal)->getOperand(0),
9108 return ::matchSelectPattern(Pred, FMF, CmpLHS, CmpRHS, TrueVal, FalseVal,
9127 return Intrinsic::umin;
9129 return Intrinsic::umax;
9131 return Intrinsic::smin;
9133 return Intrinsic::smax;
9149 case Intrinsic::smax:
return Intrinsic::smin;
9150 case Intrinsic::smin:
return Intrinsic::smax;
9151 case Intrinsic::umax:
return Intrinsic::umin;
9152 case Intrinsic::umin:
return Intrinsic::umax;
9155 case Intrinsic::maximum:
return Intrinsic::minimum;
9156 case Intrinsic::minimum:
return Intrinsic::maximum;
9157 case Intrinsic::maxnum:
return Intrinsic::minnum;
9158 case Intrinsic::minnum:
return Intrinsic::maxnum;
9173std::pair<Intrinsic::ID, bool>
9178 bool AllCmpSingleUse =
true;
9181 if (
all_of(VL, [&SelectPattern, &AllCmpSingleUse](
Value *
I) {
9187 SelectPattern.
Flavor != CurrentPattern.Flavor)
9189 SelectPattern = CurrentPattern;
9194 switch (SelectPattern.
Flavor) {
9196 return {Intrinsic::smin, AllCmpSingleUse};
9198 return {Intrinsic::umin, AllCmpSingleUse};
9200 return {Intrinsic::smax, AllCmpSingleUse};
9202 return {Intrinsic::umax, AllCmpSingleUse};
9204 return {Intrinsic::maxnum, AllCmpSingleUse};
9206 return {Intrinsic::minnum, AllCmpSingleUse};
9219 if (
P->getNumIncomingValues() != 2)
9222 for (
unsigned i = 0; i != 2; ++i) {
9223 Value *L =
P->getIncomingValue(i);
9224 Value *R =
P->getIncomingValue(!i);
9225 auto *LU = dyn_cast<BinaryOperator>(L);
9228 unsigned Opcode = LU->getOpcode();
9234 case Instruction::LShr:
9235 case Instruction::AShr:
9236 case Instruction::Shl:
9237 case Instruction::Add:
9238 case Instruction::Sub:
9239 case Instruction::UDiv:
9240 case Instruction::URem:
9241 case Instruction::And:
9242 case Instruction::Or:
9243 case Instruction::Mul:
9244 case Instruction::FMul: {
9245 Value *LL = LU->getOperand(0);
9246 Value *LR = LU->getOperand(1);
9276 P = dyn_cast<PHINode>(
I->getOperand(0));
9278 P = dyn_cast<PHINode>(
I->getOperand(1));
9299 return !
C->isNegative();
9311 const APInt *CLHS, *CRHS;
9314 return CLHS->
sle(*CRHS);
9352 const APInt *CLHS, *CRHS;
9355 return CLHS->
ule(*CRHS);
9364static std::optional<bool>
9369 return std::nullopt;
9376 return std::nullopt;
9383 return std::nullopt;
9390 return std::nullopt;
9397 return std::nullopt;
9404static std::optional<bool>
9410 if (CR.
icmp(Pred, RCR))
9417 return std::nullopt;
9430 return std::nullopt;
9436static std::optional<bool>
9445 LHSIsTrue ?
LHS->getCmpPredicate() :
LHS->getInverseCmpPredicate();
9469 const APInt *Unused;
9488 return std::nullopt;
9492 if (L0 == R0 && L1 == R1)
9528 return std::nullopt;
9535static std::optional<bool>
9540 assert((
LHS->getOpcode() == Instruction::And ||
9541 LHS->getOpcode() == Instruction::Or ||
9542 LHS->getOpcode() == Instruction::Select) &&
9543 "Expected LHS to be 'and', 'or', or 'select'.");
9550 const Value *ALHS, *ARHS;
9555 ALHS, RHSPred, RHSOp0, RHSOp1,
DL, LHSIsTrue,
Depth + 1))
9558 ARHS, RHSPred, RHSOp0, RHSOp1,
DL, LHSIsTrue,
Depth + 1))
9560 return std::nullopt;
9562 return std::nullopt;
9571 return std::nullopt;
9576 return std::nullopt;
9579 "Expected integer type only!");
9583 LHSIsTrue = !LHSIsTrue;
9594 if ((LHSI->getOpcode() == Instruction::And ||
9595 LHSI->getOpcode() == Instruction::Or ||
9596 LHSI->getOpcode() == Instruction::Select))
9600 return std::nullopt;
9605 bool LHSIsTrue,
unsigned Depth) {
9611 bool InvertRHS =
false;
9618 if (
const ICmpInst *RHSCmp = dyn_cast<ICmpInst>(
RHS)) {
9620 LHS, RHSCmp->getCmpPredicate(), RHSCmp->getOperand(0),
9621 RHSCmp->getOperand(1),
DL, LHSIsTrue,
Depth))
9622 return InvertRHS ? !*Implied : *Implied;
9623 return std::nullopt;
9627 return std::nullopt;
9631 const Value *RHS1, *RHS2;
9633 if (std::optional<bool> Imp =
9637 if (std::optional<bool> Imp =
9643 if (std::optional<bool> Imp =
9647 if (std::optional<bool> Imp =
9653 return std::nullopt;
9658static std::pair<Value *, bool>
9660 if (!ContextI || !ContextI->
getParent())
9661 return {
nullptr,
false};
9668 return {
nullptr,
false};
9674 return {
nullptr,
false};
9677 if (TrueBB == FalseBB)
9678 return {
nullptr,
false};
9680 assert((TrueBB == ContextBB || FalseBB == ContextBB) &&
9681 "Predecessor block does not point to successor?");
9684 return {PredCond, TrueBB == ContextBB};
9690 assert(
Cond->getType()->isIntOrIntVectorTy(1) &&
"Condition must be bool");
9694 return std::nullopt;
9706 return std::nullopt;
9711 bool PreferSignedRange) {
9712 unsigned Width =
Lower.getBitWidth();
9715 case Instruction::Add:
9724 if (PreferSignedRange && HasNSW && HasNUW)
9730 }
else if (HasNSW) {
9731 if (
C->isNegative()) {
9744 case Instruction::And:
9755 case Instruction::Or:
9761 case Instruction::AShr:
9767 unsigned ShiftAmount = Width - 1;
9768 if (!
C->isZero() && IIQ.
isExact(&BO))
9769 ShiftAmount =
C->countr_zero();
9770 if (
C->isNegative()) {
9773 Upper =
C->ashr(ShiftAmount) + 1;
9776 Lower =
C->ashr(ShiftAmount);
9782 case Instruction::LShr:
9788 unsigned ShiftAmount = Width - 1;
9789 if (!
C->isZero() && IIQ.
isExact(&BO))
9790 ShiftAmount =
C->countr_zero();
9791 Lower =
C->lshr(ShiftAmount);
9796 case Instruction::Shl:
9803 if (
C->isNegative()) {
9805 unsigned ShiftAmount =
C->countl_one() - 1;
9806 Lower =
C->shl(ShiftAmount);
9810 unsigned ShiftAmount =
C->countl_zero() - 1;
9812 Upper =
C->shl(ShiftAmount) + 1;
9831 case Instruction::SDiv:
9835 if (
C->isAllOnes()) {
9840 }
else if (
C->countl_zero() < Width - 1) {
9851 if (
C->isMinSignedValue()) {
9863 case Instruction::UDiv:
9873 case Instruction::SRem:
9879 if (
C->isNegative()) {
9890 case Instruction::URem:
9905 bool UseInstrInfo) {
9906 unsigned Width =
II.getType()->getScalarSizeInBits();
9908 switch (
II.getIntrinsicID()) {
9909 case Intrinsic::ctlz:
9910 case Intrinsic::cttz: {
9912 if (!UseInstrInfo || !
match(
II.getArgOperand(1),
m_One()))
9917 case Intrinsic::ctpop:
9920 APInt(Width, Width) + 1);
9921 case Intrinsic::uadd_sat:
9927 case Intrinsic::sadd_sat:
9930 if (
C->isNegative())
9941 case Intrinsic::usub_sat:
9951 case Intrinsic::ssub_sat:
9953 if (
C->isNegative())
9963 if (
C->isNegative())
9974 case Intrinsic::umin:
9975 case Intrinsic::umax:
9976 case Intrinsic::smin:
9977 case Intrinsic::smax:
9982 switch (
II.getIntrinsicID()) {
9983 case Intrinsic::umin:
9985 case Intrinsic::umax:
9987 case Intrinsic::smin:
9990 case Intrinsic::smax:
9997 case Intrinsic::abs:
10006 case Intrinsic::vscale:
10007 if (!
II.getParent() || !
II.getFunction())
10010 case Intrinsic::scmp:
10011 case Intrinsic::ucmp:
10018 return ConstantRange::getFull(Width);
10023 unsigned BitWidth = SI.getType()->getScalarSizeInBits();
10027 return ConstantRange::getFull(
BitWidth);
10050 return ConstantRange::getFull(
BitWidth);
10052 switch (R.Flavor) {
10064 return ConstantRange::getFull(
BitWidth);
10071 unsigned BitWidth =
I->getType()->getScalarSizeInBits();
10072 if (!
I->getOperand(0)->getType()->getScalarType()->isHalfTy())
10074 if (isa<FPToSIInst>(
I) &&
BitWidth >= 17) {
10079 if (isa<FPToUIInst>(
I) &&
BitWidth >= 16) {
10090 assert(V->getType()->isIntOrIntVectorTy() &&
"Expected integer instruction");
10093 return ConstantRange::getFull(V->getType()->getScalarSizeInBits());
10095 if (
auto *
C = dyn_cast<Constant>(V))
10096 return C->toConstantRange();
10098 unsigned BitWidth = V->getType()->getScalarSizeInBits();
10101 if (
auto *BO = dyn_cast<BinaryOperator>(V)) {
10107 }
else if (
auto *
II = dyn_cast<IntrinsicInst>(V))
10109 else if (
auto *SI = dyn_cast<SelectInst>(V)) {
10111 SI->getTrueValue(), ForSigned, UseInstrInfo, AC, CtxI, DT,
Depth + 1);
10113 SI->getFalseValue(), ForSigned, UseInstrInfo, AC, CtxI, DT,
Depth + 1);
10116 }
else if (isa<FPToUIInst>(V) || isa<FPToSIInst>(V)) {
10122 }
else if (
const auto *
A = dyn_cast<Argument>(V))
10123 if (std::optional<ConstantRange>
Range =
A->getRange())
10126 if (
auto *
I = dyn_cast<Instruction>(V)) {
10130 if (
const auto *CB = dyn_cast<CallBase>(V))
10131 if (std::optional<ConstantRange>
Range = CB->getRange())
10140 CallInst *
I = cast<CallInst>(AssumeVH);
10142 "Got assumption for the wrong function!");
10143 assert(
I->getIntrinsicID() == Intrinsic::assume &&
10144 "must be an assume intrinsic");
10148 Value *Arg =
I->getArgOperand(0);
10149 ICmpInst *Cmp = dyn_cast<ICmpInst>(Arg);
10151 if (!Cmp || Cmp->getOperand(0) != V)
10156 UseInstrInfo, AC,
I, DT,
Depth + 1);
10169 if (isa<Argument>(V) || isa<GlobalValue>(V)) {
10171 }
else if (
auto *
I = dyn_cast<Instruction>(V)) {
10177 if (isa<Instruction>(
Op) || isa<Argument>(
Op))
10178 InsertAffected(
Op);
10185 auto AddAffected = [&InsertAffected](
Value *V) {
10200 while (!Worklist.
empty()) {
10202 if (!Visited.
insert(V).second)
10225 AddCmpOperands(
A,
B);
10276 if (HasRHSC &&
match(
A, m_Intrinsic<Intrinsic::ctpop>(
m_Value(
X))))
10279 AddCmpOperands(
A,
B);
10289 }
else if (
match(V, m_Intrinsic<Intrinsic::is_fpclass>(
m_Value(
A),
AMDGPU Register Bank Select
This file declares a class to represent arbitrary precision floating point values and provide a varie...
This file implements a class to represent arbitrary precision integral constant values and operations...
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Function Alias Analysis Results
This file contains the simple types necessary to represent the attributes associated with functions a...
BlockVerifier::State From
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
This file contains the declarations for the subclasses of Constant, which represent the different fla...
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
std::optional< std::vector< StOtherPiece > > Other
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
static MaybeAlign getAlign(Value *Ptr)
Module.h This file contains the declarations for the Module class.
static bool hasNoUnsignedWrap(BinaryOperator &I)
mir Rename Register Operands
ConstantRange Range(APInt(BitWidth, Low), APInt(BitWidth, High))
uint64_t IntrinsicInst * II
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
const SmallVectorImpl< MachineOperand > & Cond
static bool mayHaveSideEffects(MachineInstr &MI)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the make_scope_exit function, which executes user-defined cleanup logic at scope ex...
This file defines the SmallPtrSet class.
This file defines the SmallSet class.
This file defines the SmallVector class.
static std::optional< unsigned > getOpcode(ArrayRef< VPValue * > Values)
Returns the opcode of Values or ~0 if they do not all agree.
static SmallVector< VPValue *, 4 > getOperands(ArrayRef< VPValue * > Values, unsigned OperandIndex)
static bool getShuffleDemandedElts(const ShuffleVectorInst *Shuf, const APInt &DemandedElts, APInt &DemandedLHS, APInt &DemandedRHS)
static cl::opt< unsigned > DomConditionsMaxUses("dom-conditions-max-uses", cl::Hidden, cl::init(20))
static unsigned computeNumSignBitsVectorConstant(const Value *V, const APInt &DemandedElts, unsigned TyBits)
For vector constants, loop over the elements and find the constant with the minimum number of sign bi...
static bool isKnownNonZeroFromOperator(const Operator *I, const APInt &DemandedElts, unsigned Depth, const SimplifyQuery &Q)
static bool isTruePredicate(CmpInst::Predicate Pred, const Value *LHS, const Value *RHS)
Return true if "icmp Pred LHS RHS" is always true.
static bool isNonZeroMul(const APInt &DemandedElts, unsigned Depth, const SimplifyQuery &Q, unsigned BitWidth, Value *X, Value *Y, bool NSW, bool NUW)
static bool isKnownNonNullFromDominatingCondition(const Value *V, const Instruction *CtxI, const DominatorTree *DT)
static const Value * getUnderlyingObjectFromInt(const Value *V)
This is the function that does the work of looking through basic ptrtoint+arithmetic+inttoptr sequenc...
static bool isNonZeroShift(const Operator *I, const APInt &DemandedElts, unsigned Depth, const SimplifyQuery &Q, const KnownBits &KnownVal)
static bool rangeMetadataExcludesValue(const MDNode *Ranges, const APInt &Value)
Does the 'Range' metadata (which must be a valid MD_range operand list) ensure that the value it's at...
static bool outputDenormalIsIEEEOrPosZero(const Function &F, const Type *Ty)
static void breakSelfRecursivePHI(const Use *U, const PHINode *PHI, Value *&ValOut, Instruction *&CtxIOut, const PHINode **PhiOut=nullptr)
static bool inputDenormalIsIEEE(const Function &F, const Type *Ty)
Return true if it's possible to assume IEEE treatment of input denormals in F for Val.
static OverflowResult mapOverflowResult(ConstantRange::OverflowResult OR)
Convert ConstantRange OverflowResult into ValueTracking OverflowResult.
static bool isNonEqualPHIs(const PHINode *PN1, const PHINode *PN2, const APInt &DemandedElts, unsigned Depth, const SimplifyQuery &Q)
static bool isNonEqualShl(const Value *V1, const Value *V2, const APInt &DemandedElts, unsigned Depth, const SimplifyQuery &Q)
Return true if V2 == V1 << C, where V1 is known non-zero, C is not 0 and the shift is nuw or nsw.
static void addValueAffectedByCondition(Value *V, function_ref< void(Value *)> InsertAffected)
static unsigned getBitWidth(Type *Ty, const DataLayout &DL)
Returns the bitwidth of the given scalar or pointer type.
static std::tuple< Value *, FPClassTest, FPClassTest > exactClass(Value *V, FPClassTest M)
Return the return value for fcmpImpliesClass for a compare that produces an exact class test.
static bool haveNoCommonBitsSetSpecialCases(const Value *LHS, const Value *RHS, const SimplifyQuery &SQ)
static void setLimitsForBinOp(const BinaryOperator &BO, APInt &Lower, APInt &Upper, const InstrInfoQuery &IIQ, bool PreferSignedRange)
static Value * lookThroughCast(CmpInst *CmpI, Value *V1, Value *V2, Instruction::CastOps *CastOp)
Helps to match a select pattern in case of a type mismatch.
static std::pair< Value *, bool > getDomPredecessorCondition(const Instruction *ContextI)
static bool isKnownNonEqual(const Value *V1, const Value *V2, const APInt &DemandedElts, unsigned Depth, const SimplifyQuery &Q)
Return true if it is known that V1 != V2.
static bool isKnownNonZero(const Value *V, const APInt &DemandedElts, const SimplifyQuery &Q, unsigned Depth)
Return true if the given value is known to be non-zero when defined.
static bool isNonEqualSelect(const Value *V1, const Value *V2, const APInt &DemandedElts, unsigned Depth, const SimplifyQuery &Q)
static unsigned ComputeNumSignBits(const Value *V, const APInt &DemandedElts, unsigned Depth, const SimplifyQuery &Q)
static bool includesPoison(UndefPoisonKind Kind)
static bool isNonEqualMul(const Value *V1, const Value *V2, const APInt &DemandedElts, unsigned Depth, const SimplifyQuery &Q)
Return true if V2 == V1 * C, where V1 is known non-zero, C is not 0/1 and the multiplication is nuw o...
static SelectPatternResult matchFastFloatClamp(CmpInst::Predicate Pred, Value *CmpLHS, Value *CmpRHS, Value *TrueVal, Value *FalseVal, Value *&LHS, Value *&RHS)
Match clamp pattern for float types without care about NaNs or signed zeros.
static bool includesUndef(UndefPoisonKind Kind)
static std::optional< bool > isImpliedCondCommonOperandWithCR(CmpPredicate LPred, const ConstantRange &LCR, CmpPredicate RPred, const ConstantRange &RCR)
Return true if "icmp LPred X, LCR" implies "icmp RPred X, RCR" is true.
static bool isPowerOfTwoRecurrence(const PHINode *PN, bool OrZero, unsigned Depth, SimplifyQuery &Q)
Try to detect a recurrence that the value of the induction variable is always a power of two (or zero...
static bool isModifyingBinopOfNonZero(const Value *V1, const Value *V2, const APInt &DemandedElts, unsigned Depth, const SimplifyQuery &Q)
Return true if V1 == (binop V2, X), where X is known non-zero.
static ConstantRange getRangeForSelectPattern(const SelectInst &SI, const InstrInfoQuery &IIQ)
static SelectPatternResult matchSelectPattern(CmpInst::Predicate Pred, FastMathFlags FMF, Value *CmpLHS, Value *CmpRHS, Value *TrueVal, Value *FalseVal, Value *&LHS, Value *&RHS, unsigned Depth)
static uint64_t GetStringLengthH(const Value *V, SmallPtrSetImpl< const PHINode * > &PHIs, unsigned CharSize)
If we can compute the length of the string pointed to by the specified pointer, return 'len+1'.
static bool onlyUsedByLifetimeMarkersOrDroppableInstsHelper(const Value *V, bool AllowLifetime, bool AllowDroppable)
static std::optional< bool > isImpliedCondAndOr(const Instruction *LHS, CmpPredicate RHSPred, const Value *RHSOp0, const Value *RHSOp1, const DataLayout &DL, bool LHSIsTrue, unsigned Depth)
Return true if LHS implies RHS is true.
static void computeKnownFPClassFromCond(const Value *V, Value *Cond, unsigned Depth, bool CondIsTrue, const Instruction *CxtI, KnownFPClass &KnownFromContext)
static std::optional< bool > isImpliedCondICmps(const ICmpInst *LHS, CmpPredicate RPred, const Value *R0, const Value *R1, const DataLayout &DL, bool LHSIsTrue)
Return true if LHS implies RHS (expanded to its components as "R0 RPred R1") is true.
static bool isSignedMinMaxClamp(const Value *Select, const Value *&In, const APInt *&CLow, const APInt *&CHigh)
static void computeKnownBitsAddSub(bool Add, const Value *Op0, const Value *Op1, bool NSW, bool NUW, const APInt &DemandedElts, KnownBits &KnownOut, KnownBits &Known2, unsigned Depth, const SimplifyQuery &Q)
static void computeKnownBitsFromOperator(const Operator *I, const APInt &DemandedElts, KnownBits &Known, unsigned Depth, const SimplifyQuery &Q)
static bool directlyImpliesPoison(const Value *ValAssumedPoison, const Value *V, unsigned Depth)
static void computeKnownBitsFromCmp(const Value *V, CmpInst::Predicate Pred, Value *LHS, Value *RHS, KnownBits &Known, const SimplifyQuery &Q)
static SelectPatternResult matchMinMaxOfMinMax(CmpInst::Predicate Pred, Value *CmpLHS, Value *CmpRHS, Value *TVal, Value *FVal, unsigned Depth)
Recognize variations of: a < c ? min(a,b) : min(b,c) ==> min(min(a,b),min(b,c))
static void unionWithMinMaxIntrinsicClamp(const IntrinsicInst *II, KnownBits &Known)
static void setLimitForFPToI(const Instruction *I, APInt &Lower, APInt &Upper)
static bool isSameUnderlyingObjectInLoop(const PHINode *PN, const LoopInfo *LI)
PN defines a loop-variant pointer to an object.
static bool isNonEqualPointersWithRecursiveGEP(const Value *A, const Value *B, const SimplifyQuery &Q)
static bool isSignedMinMaxIntrinsicClamp(const IntrinsicInst *II, const APInt *&CLow, const APInt *&CHigh)
static Value * lookThroughCastConst(CmpInst *CmpI, Type *SrcTy, Constant *C, Instruction::CastOps *CastOp)
static void computeKnownFPClassForFPTrunc(const Operator *Op, const APInt &DemandedElts, FPClassTest InterestedClasses, KnownFPClass &Known, unsigned Depth, const SimplifyQuery &Q)
static bool handleGuaranteedWellDefinedOps(const Instruction *I, const CallableT &Handle)
Enumerates all operands of I that are guaranteed to not be undef or poison.
static void computeKnownBits(const Value *V, const APInt &DemandedElts, KnownBits &Known, unsigned Depth, const SimplifyQuery &Q)
Determine which bits of V are known to be either zero or one and return them in the Known bit set.
static KnownFPClass computeKnownFPClassFromContext(const Value *V, const SimplifyQuery &Q)
static Value * getNotValue(Value *V)
If the input value is the result of a 'not' op, constant integer, or vector splat of a constant integ...
static void computeKnownBitsFromCond(const Value *V, Value *Cond, KnownBits &Known, unsigned Depth, const SimplifyQuery &SQ, bool Invert)
static void computeKnownBitsFromICmpCond(const Value *V, ICmpInst *Cmp, KnownBits &Known, const SimplifyQuery &SQ, bool Invert)
static KnownBits computeKnownBitsForHorizontalOperation(const Operator *I, const APInt &DemandedElts, unsigned Depth, const SimplifyQuery &Q, const function_ref< KnownBits(const KnownBits &, const KnownBits &)> KnownBitsFunc)
static bool matchOpWithOpEqZero(Value *Op0, Value *Op1)
static bool isNonZeroRecurrence(const PHINode *PN)
Try to detect a recurrence that monotonically increases/decreases from a non-zero starting value.
static void computeKnownBitsMul(const Value *Op0, const Value *Op1, bool NSW, bool NUW, const APInt &DemandedElts, KnownBits &Known, KnownBits &Known2, unsigned Depth, const SimplifyQuery &Q)
static SelectPatternResult matchClamp(CmpInst::Predicate Pred, Value *CmpLHS, Value *CmpRHS, Value *TrueVal, Value *FalseVal)
Recognize variations of: CLAMP(v,l,h) ==> ((v) < (l) ? (l) : ((v) > (h) ? (h) : (v)))
static bool shiftAmountKnownInRange(const Value *ShiftAmount)
Shifts return poison if shiftwidth is larger than the bitwidth.
static bool isEphemeralValueOf(const Instruction *I, const Value *E)
static SelectPatternResult matchMinMax(CmpInst::Predicate Pred, Value *CmpLHS, Value *CmpRHS, Value *TrueVal, Value *FalseVal, Value *&LHS, Value *&RHS, unsigned Depth)
Match non-obvious integer minimum and maximum sequences.
static bool isGEPKnownNonNull(const GEPOperator *GEP, unsigned Depth, const SimplifyQuery &Q)
Test whether a GEP's result is known to be non-null.
static bool handleGuaranteedNonPoisonOps(const Instruction *I, const CallableT &Handle)
Enumerates all operands of I that are guaranteed to not be poison.
static bool isNonZeroSub(const APInt &DemandedElts, unsigned Depth, const SimplifyQuery &Q, unsigned BitWidth, Value *X, Value *Y)
static std::optional< std::pair< Value *, Value * > > getInvertibleOperands(const Operator *Op1, const Operator *Op2)
If the pair of operators are the same invertible function, return the the operands of the function co...
static void computeKnownBitsFromShiftOperator(const Operator *I, const APInt &DemandedElts, KnownBits &Known, KnownBits &Known2, unsigned Depth, const SimplifyQuery &Q, function_ref< KnownBits(const KnownBits &, const KnownBits &, bool)> KF)
Compute known bits from a shift operator, including those with a non-constant shift amount.
static bool cmpExcludesZero(CmpInst::Predicate Pred, const Value *RHS)
static bool inputDenormalIsIEEEOrPosZero(const Function &F, const Type *Ty)
static KnownBits getKnownBitsFromAndXorOr(const Operator *I, const APInt &DemandedElts, const KnownBits &KnownLHS, const KnownBits &KnownRHS, unsigned Depth, const SimplifyQuery &Q)
static bool isKnownNonZeroFromAssume(const Value *V, const SimplifyQuery &Q)
static std::optional< bool > isImpliedCondOperands(CmpInst::Predicate Pred, const Value *ALHS, const Value *ARHS, const Value *BLHS, const Value *BRHS)
Return true if "icmp Pred BLHS BRHS" is true whenever "icmp Pred ALHS ARHS" is true.
static unsigned ComputeNumSignBitsImpl(const Value *V, const APInt &DemandedElts, unsigned Depth, const SimplifyQuery &Q)
Return the number of times the sign bit of the register is replicated into the other bits.
static bool isNonZeroAdd(const APInt &DemandedElts, unsigned Depth, const SimplifyQuery &Q, unsigned BitWidth, Value *X, Value *Y, bool NSW, bool NUW)
static const Instruction * safeCxtI(const Value *V, const Instruction *CxtI)
static bool isImpliedToBeAPowerOfTwoFromCond(const Value *V, bool OrZero, const Value *Cond, bool CondIsTrue)
Return true if we can infer that V is known to be a power of 2 from dominating condition Cond (e....
static bool isKnownNonNaN(const Value *V, FastMathFlags FMF)
static ConstantRange getRangeForIntrinsic(const IntrinsicInst &II, bool UseInstrInfo)
static Value * BuildSubAggregate(Value *From, Value *To, Type *IndexedType, SmallVectorImpl< unsigned > &Idxs, unsigned IdxSkip, BasicBlock::iterator InsertBefore)
void computeKnownFPClass(const Value *V, const APInt &DemandedElts, FPClassTest InterestedClasses, KnownFPClass &Known, unsigned Depth, const SimplifyQuery &Q)
APInt bitcastToAPInt() const
static APFloat getLargest(const fltSemantics &Sem, bool Negative=false)
Returns the largest finite number in the given semantics.
static APFloat getInf(const fltSemantics &Sem, bool Negative=false)
Factory for Positive and Negative Infinity.
FPClassTest classify() const
Return the FPClassTest which will return true for the value.
static APFloat getZero(const fltSemantics &Sem, bool Negative=false)
Factory for Positive and Negative Zero.
bool isSmallestNormalized() const
Class for arbitrary precision integers.
APInt udiv(const APInt &RHS) const
Unsigned division operation.
static APInt getAllOnes(unsigned numBits)
Return an APInt of a specified width with all bits set.
void clearBit(unsigned BitPosition)
Set a given bit to 0.
bool isMinSignedValue() const
Determine if this is the smallest signed value.
uint64_t getZExtValue() const
Get zero extended value.
void setHighBits(unsigned hiBits)
Set the top hiBits bits.
void setBitsFrom(unsigned loBit)
Set the top bits starting from loBit.
APInt zextOrTrunc(unsigned width) const
Zero extend or truncate to width.
static APInt getMaxValue(unsigned numBits)
Gets maximum unsigned value of APInt for specific bit width.
void setBit(unsigned BitPosition)
Set the given bit to 1 whose position is given as "bitPosition".
unsigned ceilLogBase2() const
bool sgt(const APInt &RHS) const
Signed greater than comparison.
bool isAllOnes() const
Determine if all bits are set. This is true for zero-width values.
bool ugt(const APInt &RHS) const
Unsigned greater than comparison.
bool isZero() const
Determine if this value is zero, i.e. all bits are clear.
APInt urem(const APInt &RHS) const
Unsigned remainder operation.
unsigned getBitWidth() const
Return the number of bits in the APInt.
bool ult(const APInt &RHS) const
Unsigned less than comparison.
static APInt getSignedMaxValue(unsigned numBits)
Gets maximum signed value of APInt for a specific bit width.
static APInt getMinValue(unsigned numBits)
Gets minimum unsigned value of APInt for a specific bit width.
bool isNegative() const
Determine sign of this APInt.
bool intersects(const APInt &RHS) const
This operation tests if there are any pairs of corresponding bits between this APInt and RHS that are...
APInt sdiv(const APInt &RHS) const
Signed division function for APInt.
void clearAllBits()
Set every bit to 0.
APInt reverseBits() const
bool sle(const APInt &RHS) const
Signed less or equal comparison.
unsigned getNumSignBits() const
Computes the number of leading bits of this APInt that are equal to its sign bit.
static APInt getSignedMinValue(unsigned numBits)
Gets minimum signed value of APInt for a specific bit width.
APInt sextOrTrunc(unsigned width) const
Sign extend or truncate to width.
bool isStrictlyPositive() const
Determine if this APInt Value is positive.
unsigned logBase2() const
APInt ashr(unsigned ShiftAmt) const
Arithmetic right-shift function.
void setAllBits()
Set every bit to 1.
bool getBoolValue() const
Convert APInt to a boolean value.
bool isMaxSignedValue() const
Determine if this is the largest signed value.
bool isNonNegative() const
Determine if this APInt Value is non-negative (>= 0)
bool ule(const APInt &RHS) const
Unsigned less or equal comparison.
APInt shl(unsigned shiftAmt) const
Left-shift function.
bool slt(const APInt &RHS) const
Signed less than comparison.
static APInt getHighBitsSet(unsigned numBits, unsigned hiBitsSet)
Constructs an APInt value that has the top hiBitsSet bits set.
static APInt getZero(unsigned numBits)
Get the '0' value for the specified bit-width.
void setLowBits(unsigned loBits)
Set the bottom loBits bits.
bool sge(const APInt &RHS) const
Signed greater or equal comparison.
static APInt getBitsSetFrom(unsigned numBits, unsigned loBit)
Constructs an APInt value that has a contiguous range of bits set.
static APInt getOneBitSet(unsigned numBits, unsigned BitNo)
Return an APInt with exactly one bit set in the result.
void lshrInPlace(unsigned ShiftAmt)
Logical right-shift this APInt by ShiftAmt in place.
APInt lshr(unsigned shiftAmt) const
Logical right-shift function.
bool uge(const APInt &RHS) const
Unsigned greater or equal comparison.
void clearSignBit()
Set the sign bit to 0.
an instruction to allocate memory on the stack
This class represents an incoming formal argument to a Function.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
size_t size() const
size - Get the array size.
bool empty() const
empty - Check if the array is empty.
ArrayRef< T > slice(size_t N, size_t M) const
slice(n, m) - Chop off the first N elements of the array, and keep M elements in the array.
Class to represent array types.
Type * getElementType() const
This represents the llvm.assume intrinsic.
A cache of @llvm.assume calls within a function.
MutableArrayRef< ResultElem > assumptionsFor(const Value *V)
Access the list of assumptions which affect this value.
std::optional< unsigned > getVScaleRangeMax() const
Returns the maximum value for the vscale_range attribute or std::nullopt when unknown.
unsigned getVScaleRangeMin() const
Returns the minimum value for the vscale_range attribute.
bool isValid() const
Return true if the attribute is any kind of attribute.
bool isSingleEdge() const
Check if this is the only edge between Start and End.
LLVM Basic Block Representation.
iterator begin()
Instruction iterator methods.
InstListType::const_iterator getFirstNonPHIIt() const
Returns an iterator to the first instruction in this block that is not a PHINode instruction.
InstListType::const_iterator const_iterator
const BasicBlock * getSinglePredecessor() const
Return the predecessor of this block if it has a single predecessor block.
const BasicBlock * getSingleSuccessor() const
Return the successor of this block if it has a single successor.
const Function * getParent() const
Return the enclosing method, or null if none.
InstListType::iterator iterator
Instruction iterators...
const Instruction * getTerminator() const LLVM_READONLY
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
Instruction::BinaryOps getBinaryOp() const
Returns the binary operation underlying the intrinsic.
BinaryOps getOpcode() const
Conditional or Unconditional Branch instruction.
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Function * getCalledFunction() const
Returns the function called, or null if this is an indirect function invocation or the function signa...
bool paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const
Determine whether the argument or parameter has the given attribute.
bool isIndirectCall() const
Return true if the callsite is an indirect call.
bool onlyReadsMemory(unsigned OpNo) const
Value * getCalledOperand() const
Value * getArgOperand(unsigned i) const
unsigned arg_size() const
This class represents a function call, abstracting a target machine's calling convention.
This is the base class for all instructions that perform data casts.
This class is the base class for the comparison instructions.
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
@ FCMP_OEQ
0 0 0 1 True if ordered and equal
@ FCMP_TRUE
1 1 1 1 Always true (always folded)
@ ICMP_SLT
signed less than
@ ICMP_SLE
signed less or equal
@ FCMP_OLT
0 1 0 0 True if ordered and less than
@ FCMP_ULE
1 1 0 1 True if unordered, less than, or equal
@ FCMP_OGT
0 0 1 0 True if ordered and greater than
@ FCMP_OGE
0 0 1 1 True if ordered and greater than or equal
@ ICMP_UGE
unsigned greater or equal
@ ICMP_UGT
unsigned greater than
@ ICMP_SGT
signed greater than
@ FCMP_ULT
1 1 0 0 True if unordered or less than
@ FCMP_ONE
0 1 1 0 True if ordered and operands are unequal
@ FCMP_UEQ
1 0 0 1 True if unordered or equal
@ ICMP_ULT
unsigned less than
@ FCMP_UGT
1 0 1 0 True if unordered or greater than
@ FCMP_OLE
0 1 0 1 True if ordered and less than or equal
@ FCMP_ORD
0 1 1 1 True if ordered (no nans)
@ ICMP_SGE
signed greater or equal
@ FCMP_UNE
1 1 1 0 True if unordered or not equal
@ ICMP_ULE
unsigned less or equal
@ FCMP_UGE
1 0 1 1 True if unordered, greater than, or equal
@ FCMP_FALSE
0 0 0 0 Always false (always folded)
@ FCMP_UNO
1 0 0 0 True if unordered: isnan(X) | isnan(Y)
static bool isEquality(Predicate pred)
Determine if this is an equals/not equals predicate.
Predicate getSwappedPredicate() const
For example, EQ->EQ, SLE->SGE, ULT->UGT, OEQ->OEQ, ULE->UGE, OLT->OGT, etc.
bool isTrueWhenEqual() const
This is just a convenience.
bool isFPPredicate() const
Predicate getInversePredicate() const
For example, EQ -> NE, UGT -> ULE, SLT -> SGE, OEQ -> UNE, UGT -> OLE, OLT -> UGE,...
Predicate getPredicate() const
Return the predicate for this instruction.
static bool isUnordered(Predicate predicate)
Determine if the predicate is an unordered operation.
Predicate getFlippedStrictnessPredicate() const
For predicate of kind "is X or equal to 0" returns the predicate "is X".
bool isIntPredicate() const
static bool isOrdered(Predicate predicate)
Determine if the predicate is an ordered operation.
An abstraction over a floating-point predicate, and a pack of an integer predicate with samesign info...
static std::optional< CmpPredicate > getMatching(CmpPredicate A, CmpPredicate B)
Compares two CmpPredicates taking samesign into account and returns the canonicalized CmpPredicate if...
CmpInst::Predicate getPreferredSignedPredicate() const
Attempts to return a signed CmpInst::Predicate from the CmpPredicate.
bool hasSameSign() const
Query samesign information, for optimizations.
An array constant whose element type is a simple 1/2/4/8-byte integer or float/double,...
ConstantDataSequential - A vector or array constant whose element type is a simple 1/2/4/8-byte integ...
StringRef getAsString() const
If this array is isString(), then this method returns the array as a StringRef.
uint64_t getElementAsInteger(unsigned i) const
If this is a sequential container of integers (of any size), return the specified element in the low ...
A vector constant whose element type is a simple 1/2/4/8-byte integer or float/double,...
static Constant * getAdd(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
static Constant * getBitCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
static Constant * getTrunc(Constant *C, Type *Ty, bool OnlyIfReduced=false)
ConstantFP - Floating Point Values [float, double].
This is the shared class of boolean and integer constants.
static ConstantInt * getTrue(LLVMContext &Context)
bool isZero() const
This is just a convenience method to make client code smaller for a common code.
uint64_t getZExtValue() const
Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...
This class represents a range of values.
PreferredRangeType
If represented precisely, the result of some range operations may consist of multiple disjoint ranges...
const APInt * getSingleElement() const
If this set contains a single element, return it, otherwise return null.
static ConstantRange fromKnownBits(const KnownBits &Known, bool IsSigned)
Initialize a range based on a known bits constraint.
OverflowResult unsignedSubMayOverflow(const ConstantRange &Other) const
Return whether unsigned sub of the two ranges always/never overflows.
bool isAllNegative() const
Return true if all values in this range are negative.
OverflowResult unsignedAddMayOverflow(const ConstantRange &Other) const
Return whether unsigned add of the two ranges always/never overflows.
KnownBits toKnownBits() const
Return known bits for values in this range.
APInt getUnsignedMin() const
Return the smallest unsigned value contained in the ConstantRange.
bool icmp(CmpInst::Predicate Pred, const ConstantRange &Other) const
Does the predicate Pred hold between ranges this and Other? NOTE: false does not mean that inverse pr...
APInt getSignedMin() const
Return the smallest signed value contained in the ConstantRange.
OverflowResult unsignedMulMayOverflow(const ConstantRange &Other) const
Return whether unsigned mul of the two ranges always/never overflows.
bool isAllNonNegative() const
Return true if all values in this range are non-negative.
static ConstantRange makeAllowedICmpRegion(CmpInst::Predicate Pred, const ConstantRange &Other)
Produce the smallest range such that all values that may satisfy the given predicate with any value c...
ConstantRange unionWith(const ConstantRange &CR, PreferredRangeType Type=Smallest) const
Return the range that results from the union of this range with another range.
static ConstantRange makeExactICmpRegion(CmpInst::Predicate Pred, const APInt &Other)
Produce the exact range such that all values in the returned range satisfy the given predicate with a...
bool contains(const APInt &Val) const
Return true if the specified value is in the set.
OverflowResult signedAddMayOverflow(const ConstantRange &Other) const
Return whether signed add of the two ranges always/never overflows.
APInt getUnsignedMax() const
Return the largest unsigned value contained in the ConstantRange.
ConstantRange intersectWith(const ConstantRange &CR, PreferredRangeType Type=Smallest) const
Return the range that results from the intersection of this range with another range.
OverflowResult
Represents whether an operation on the given constant range is known to always or never overflow.
@ NeverOverflows
Never overflows.
@ AlwaysOverflowsHigh
Always overflows in the direction of signed/unsigned max value.
@ AlwaysOverflowsLow
Always overflows in the direction of signed/unsigned min value.
@ MayOverflow
May or may not overflow.
static ConstantRange getNonEmpty(APInt Lower, APInt Upper)
Create non-empty constant range with the given bounds.
uint32_t getBitWidth() const
Get the bit width of this ConstantRange.
OverflowResult signedSubMayOverflow(const ConstantRange &Other) const
Return whether signed sub of the two ranges always/never overflows.
ConstantRange sub(const ConstantRange &Other) const
Return a new range representing the possible values resulting from a subtraction of a value in this r...
This is an important base class in LLVM.
static Constant * replaceUndefsWith(Constant *C, Constant *Replacement)
Try to replace undefined constant C or undefined elements in C with Replacement.
Constant * getSplatValue(bool AllowPoison=false) const
If all elements of the vector constant have the same value, return that value.
static Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
Constant * getAggregateElement(unsigned Elt) const
For aggregates (struct/array/vector) return the constant that corresponds to the specified element if...
bool isZeroValue() const
Return true if the value is negative zero or null value.
bool isNullValue() const
Return true if this is the value that would be returned by getNullValue.
This class represents an Operation in the Expression.
A parsed version of the target data layout string in and methods for querying it.
bool isLittleEndian() const
Layout endianness...
const StructLayout * getStructLayout(StructType *Ty) const
Returns a StructLayout object, indicating the alignment of the struct, its size, and the offsets of i...
unsigned getIndexTypeSizeInBits(Type *Ty) const
Layout size of the index used in GEP calculation.
unsigned getPointerTypeSizeInBits(Type *) const
Layout pointer size, in bits, based on the type.
TypeSize getTypeSizeInBits(Type *Ty) const
Size examples:
ArrayRef< BranchInst * > conditionsFor(const Value *V) const
Access the list of branches which affect this value.
DomTreeNodeBase * getIDom() const
DomTreeNodeBase< NodeT > * getNode(const NodeT *BB) const
getNode - return the (Post)DominatorTree node for the specified basic block.
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
bool dominates(const BasicBlock *BB, const Use &U) const
Return true if the (end of the) basic block BB dominates the use U.
Utility class for floating point operations which can have information about relaxed accuracy require...
Convenience struct for specifying and reasoning about fast-math flags.
bool noSignedZeros() const
void setNoSignedZeros(bool B=true)
const BasicBlock & getEntryBlock() const
DenormalMode getDenormalMode(const fltSemantics &FPType) const
Returns the denormal handling type for the default rounding mode of the function.
an instruction for type-safe pointer arithmetic to access elements of arrays and structs
const DataLayout & getDataLayout() const
Get the data layout of the module this global belongs to.
Type * getValueType() const
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
bool isConstant() const
If the value is a global constant, its value is immutable throughout the runtime execution of the pro...
bool hasDefinitiveInitializer() const
hasDefinitiveInitializer - Whether the global variable has an initializer, and any other instances of...
This instruction compares its operands according to the predicate given to the constructor.
CmpPredicate getSwappedCmpPredicate() const
Predicate getFlippedSignednessPredicate() const
For example, SLT->ULT, ULT->SLT, SLE->ULE, ULE->SLE, EQ->EQ.
bool isEquality() const
Return true if this predicate is either EQ or NE.
static std::optional< bool > isImpliedByMatchingCmp(CmpPredicate Pred1, CmpPredicate Pred2)
Determine if Pred1 implies Pred2 is true, false, or if nothing can be inferred about the implication,...
bool isRelational() const
Return true if the predicate is relational (not EQ or NE).
Predicate getUnsignedPredicate() const
For example, EQ->EQ, SLE->ULE, UGT->UGT, etc.
This instruction inserts a struct field of array element value into an aggregate value.
Value * getAggregateOperand()
static InsertValueInst * Create(Value *Agg, Value *Val, ArrayRef< unsigned > Idxs, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
bool hasNoUnsignedWrap() const LLVM_READONLY
Determine whether the no unsigned wrap flag is set.
bool hasNoSignedWrap() const LLVM_READONLY
Determine whether the no signed wrap flag is set.
InstListType::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
bool isExact() const LLVM_READONLY
Determine whether the exact flag is set.
const Function * getFunction() const
Return the function this instruction belongs to.
bool comesBefore(const Instruction *Other) const
Given an instruction Other in the same basic block as this instruction, return true if this instructi...
FastMathFlags getFastMathFlags() const LLVM_READONLY
Convenience function for getting all the fast-math flags, which must be an operator which supports th...
unsigned getOpcode() const
Returns a member of one of the enums like Instruction::Add.
const DataLayout & getDataLayout() const
Get the data layout of the module this instruction belongs to.
A wrapper class for inspecting calls to intrinsic functions.
This is an important class for using LLVM in a threaded context.
An instruction for reading from memory.
Value * getPointerOperand()
Align getAlign() const
Return the alignment of the access that is being performed.
bool isLoopHeader(const BlockT *BB) const
LoopT * getLoopFor(const BlockT *BB) const
Return the inner most loop that BB lives in.
Represents a single loop in the control flow graph.
This is a utility class that provides an abstraction for the common functionality between Instruction...
unsigned getOpcode() const
Return the opcode for this Instruction or ConstantExpr.
Utility class for integer operators which may exhibit overflow - Add, Sub, Mul, and Shl.
iterator_range< const_block_iterator > blocks() const
Value * getIncomingValueForBlock(const BasicBlock *BB) const
BasicBlock * getIncomingBlock(unsigned i) const
Return incoming basic block number i.
Value * getIncomingValue(unsigned i) const
Return incoming value number x.
unsigned getNumIncomingValues() const
Return the number of incoming edges.
static PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
A udiv or sdiv instruction, which can be marked as "exact", indicating that no bits are destroyed.
bool isExact() const
Test whether this division is known to be exact, with zero remainder.
This class represents the LLVM 'select' instruction.
const Value * getFalseValue() const
const Value * getCondition() const
const Value * getTrueValue() const
This instruction constructs a fixed permutation of two input vectors.
VectorType * getType() const
Overload to return most specific vector type.
static void getShuffleMask(const Constant *Mask, SmallVectorImpl< int > &Result)
Convert the input shuffle mask operand to a vector of integers.
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
size_type count(ConstPtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
SmallSet - This maintains a set of unique values, optimizing for the case when the set is small (less...
size_type count(const T &V) const
count - Return 1 if the element is in the set, 0 otherwise.
std::pair< const_iterator, bool > insert(const T &V)
insert - Insert an element into the set if it isn't already there.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
void reserve(size_type N)
void append(ItTy in_start, ItTy in_end)
Add the specified range to the end of the SmallVector.
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringRef - Represent a constant reference to a string, i.e.
Used to lazily calculate structure layout information for a target machine, based on the DataLayout s...
TypeSize getElementOffset(unsigned Idx) const
Class to represent struct types.
unsigned getNumElements() const
Random access to the elements.
Type * getElementType(unsigned N) const
Provides information about what library functions are available for the current target.
bool getLibFunc(StringRef funcName, LibFunc &F) const
Searches for a particular function name.
The instances of the Type class are immutable: once they are created, they are never changed.
unsigned getIntegerBitWidth() const
const fltSemantics & getFltSemantics() const
bool isVectorTy() const
True if this is an instance of VectorType.
bool isIntOrIntVectorTy() const
Return true if this is an integer type or a vector of integer types.
bool isPointerTy() const
True if this is an instance of PointerType.
uint64_t getArrayNumElements() const
static IntegerType * getIntNTy(LLVMContext &C, unsigned N)
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type.
bool isSized(SmallPtrSetImpl< Type * > *Visited=nullptr) const
Return true if it makes sense to take the size of this type.
static IntegerType * getInt16Ty(LLVMContext &C)
static IntegerType * getInt8Ty(LLVMContext &C)
bool isIEEE() const
Return whether the type is IEEE compatible, as defined by the eponymous method in APFloat.
bool isPtrOrPtrVectorTy() const
Return true if this is a pointer type or a vector of pointer types.
bool isIntOrPtrTy() const
Return true if this is an integer type or a pointer type.
static IntegerType * getInt32Ty(LLVMContext &C)
static IntegerType * getInt64Ty(LLVMContext &C)
bool isIntegerTy() const
True if this is an instance of IntegerType.
Type * getScalarType() const
If this is a vector type, return the element type, otherwise return 'this'.
static UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
A Use represents the edge between a Value definition and its users.
User * getUser() const
Returns the User that contains this Use.
unsigned getOperandNo() const
Return the operand # of this use in its User.
Value * getOperand(unsigned i) const
unsigned getNumOperands() const
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
const Value * stripAndAccumulateInBoundsConstantOffsets(const DataLayout &DL, APInt &Offset) const
This is a wrapper around stripAndAccumulateConstantOffsets with the in-bounds requirement set to fals...
iterator_range< user_iterator > users()
const KnownBits & getKnownBits(const SimplifyQuery &Q) const
PointerType getValue() const
Represents an op.with.overflow intrinsic.
constexpr ScalarTy getFixedValue() const
constexpr bool isScalable() const
Returns whether the quantity is scaled by a runtime quantity (vscale).
constexpr ScalarTy getKnownMinValue() const
Returns the minimum value this quantity can represent.
An efficient, type-erasing, non-owning reference to a callable.
StructType * getStructTypeOrNull() const
TypeSize getSequentialElementStride(const DataLayout &DL) const
Type * getIndexedType() const
const ParentTy * getParent() const
self_iterator getIterator()
A range adaptor for a pair of iterators.
This provides a very simple, boring adaptor for a begin and end iterator into a range type.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ C
The default llvm calling convention, compatible with C.
cst_pred_ty< is_all_ones > m_AllOnes()
Match an integer or vector with all bits set.
BinaryOp_match< LHS, RHS, Instruction::And > m_And(const LHS &L, const RHS &R)
PtrToIntSameSize_match< OpTy > m_PtrToIntSameSize(const DataLayout &DL, const OpTy &Op)
BinaryOp_match< LHS, RHS, Instruction::Add > m_Add(const LHS &L, const RHS &R)
CmpClass_match< LHS, RHS, FCmpInst > m_FCmp(CmpPredicate &Pred, const LHS &L, const RHS &R)
cst_pred_ty< is_sign_mask > m_SignMask()
Match an integer or vector with only the sign bit(s) set.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWAdd(const LHS &L, const RHS &R)
cst_pred_ty< is_power2 > m_Power2()
Match an integer or vector power-of-2.
BinaryOp_match< LHS, RHS, Instruction::URem > m_URem(const LHS &L, const RHS &R)
auto m_LogicalOp()
Matches either L && R or L || R where L and R are arbitrary values.
class_match< Constant > m_Constant()
Match an arbitrary Constant and ignore it.
BinaryOp_match< LHS, RHS, Instruction::And, true > m_c_And(const LHS &L, const RHS &R)
Matches an And with LHS and RHS in either order.
cst_pred_ty< is_power2_or_zero > m_Power2OrZero()
Match an integer or vector of 0 or power-of-2 values.
CastInst_match< OpTy, TruncInst > m_Trunc(const OpTy &Op)
Matches Trunc.
BinaryOp_match< LHS, RHS, Instruction::Xor > m_Xor(const LHS &L, const RHS &R)
OverflowingBinaryOp_match< LHS, RHS, Instruction::Sub, OverflowingBinaryOperator::NoSignedWrap > m_NSWSub(const LHS &L, const RHS &R)
bool match(Val *V, const Pattern &P)
BinOpPred_match< LHS, RHS, is_idiv_op > m_IDiv(const LHS &L, const RHS &R)
Matches integer division operations.
cstfp_pred_ty< is_any_zero_fp > m_AnyZeroFP()
Match a floating-point negative zero or positive zero.
specificval_ty m_Specific(const Value *V)
Match if we have a specific specified value.
BinOpPred_match< LHS, RHS, is_right_shift_op > m_Shr(const LHS &L, const RHS &R)
Matches logical shift operations.
CmpClass_match< LHS, RHS, ICmpInst, true > m_c_ICmp(CmpPredicate &Pred, const LHS &L, const RHS &R)
Matches an ICmp with a predicate over LHS and RHS in either order.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap, true > m_c_NUWAdd(const LHS &L, const RHS &R)
cst_pred_ty< is_nonnegative > m_NonNegative()
Match an integer or vector of non-negative values.
class_match< ConstantInt > m_ConstantInt()
Match an arbitrary ConstantInt and ignore it.
cst_pred_ty< is_one > m_One()
Match an integer 1 or a vector with all elements equal to 1.
ThreeOps_match< Cond, LHS, RHS, Instruction::Select > m_Select(const Cond &C, const LHS &L, const RHS &R)
Matches SelectInst.
match_combine_or< MaxMin_match< FCmpInst, LHS, RHS, ofmin_pred_ty >, MaxMin_match< FCmpInst, LHS, RHS, ufmin_pred_ty > > m_OrdOrUnordFMin(const LHS &L, const RHS &R)
Match an 'ordered' or 'unordered' floating point minimum function.
ExtractValue_match< Ind, Val_t > m_ExtractValue(const Val_t &V)
Match a single index ExtractValue instruction.
MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty > m_SMin(const LHS &L, const RHS &R)
bind_ty< WithOverflowInst > m_WithOverflowInst(WithOverflowInst *&I)
Match a with overflow intrinsic, capturing it if we match.
BinaryOp_match< LHS, RHS, Instruction::Xor, true > m_c_Xor(const LHS &L, const RHS &R)
Matches an Xor with LHS and RHS in either order.
BinaryOp_match< LHS, RHS, Instruction::Mul > m_Mul(const LHS &L, const RHS &R)
deferredval_ty< Value > m_Deferred(Value *const &V)
Like m_Specific(), but works if the specific value to match is determined as part of the same match()...
cst_pred_ty< is_zero_int > m_ZeroInt()
Match an integer 0 or a vector with all elements equal to 0.
OneUse_match< T > m_OneUse(const T &SubPattern)
MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty, true > m_c_SMin(const LHS &L, const RHS &R)
Matches an SMin with LHS and RHS in either order.
auto m_LogicalOr()
Matches L || R where L and R are arbitrary values.
BinaryOp_match< cst_pred_ty< is_zero_int >, ValTy, Instruction::Sub > m_Neg(const ValTy &V)
Matches a 'Neg' as 'sub 0, V'.
match_combine_and< class_match< Constant >, match_unless< constantexpr_match > > m_ImmConstant()
Match an arbitrary immediate Constant and ignore it.
MaxMin_match< ICmpInst, LHS, RHS, umax_pred_ty, true > m_c_UMax(const LHS &L, const RHS &R)
Matches a UMax with LHS and RHS in either order.
SpecificCmpClass_match< LHS, RHS, ICmpInst > m_SpecificICmp(CmpPredicate MatchPred, const LHS &L, const RHS &R)
CastInst_match< OpTy, ZExtInst > m_ZExt(const OpTy &Op)
Matches ZExt.
BinaryOp_match< LHS, RHS, Instruction::UDiv > m_UDiv(const LHS &L, const RHS &R)
MaxMin_match< ICmpInst, LHS, RHS, umax_pred_ty > m_UMax(const LHS &L, const RHS &R)
brc_match< Cond_t, bind_ty< BasicBlock >, bind_ty< BasicBlock > > m_Br(const Cond_t &C, BasicBlock *&T, BasicBlock *&F)
MaxMin_match< ICmpInst, LHS, RHS, umin_pred_ty, true > m_c_UMin(const LHS &L, const RHS &R)
Matches a UMin with LHS and RHS in either order.
BinaryOp_match< LHS, RHS, Instruction::Add, true > m_c_Add(const LHS &L, const RHS &R)
Matches a Add with LHS and RHS in either order.
apfloat_match m_APFloatAllowPoison(const APFloat *&Res)
Match APFloat while allowing poison in splat vector constants.
match_combine_or< BinaryOp_match< LHS, RHS, Instruction::Add >, DisjointOr_match< LHS, RHS > > m_AddLike(const LHS &L, const RHS &R)
Match either "add" or "or disjoint".
match_combine_or< MaxMin_match< FCmpInst, LHS, RHS, ofmax_pred_ty >, MaxMin_match< FCmpInst, LHS, RHS, ufmax_pred_ty > > m_OrdOrUnordFMax(const LHS &L, const RHS &R)
Match an 'ordered' or 'unordered' floating point maximum function.
MaxMin_match< ICmpInst, LHS, RHS, smax_pred_ty, true > m_c_SMax(const LHS &L, const RHS &R)
Matches an SMax with LHS and RHS in either order.
VScaleVal_match m_VScale()
OverflowingBinaryOp_match< LHS, RHS, Instruction::Sub, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWSub(const LHS &L, const RHS &R)
MaxMin_match< ICmpInst, LHS, RHS, smax_pred_ty > m_SMax(const LHS &L, const RHS &R)
apint_match m_APInt(const APInt *&Res)
Match a ConstantInt or splatted ConstantVector, binding the specified pointer to the contained APInt.
match_combine_or< OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoSignedWrap >, DisjointOr_match< LHS, RHS > > m_NSWAddLike(const LHS &L, const RHS &R)
Match either "add nsw" or "or disjoint".
class_match< Value > m_Value()
Match an arbitrary value and ignore it.
AnyBinaryOp_match< LHS, RHS, true > m_c_BinOp(const LHS &L, const RHS &R)
Matches a BinaryOperator with LHS and RHS in either order.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoSignedWrap > m_NSWAdd(const LHS &L, const RHS &R)
BinaryOp_match< LHS, RHS, Instruction::LShr > m_LShr(const LHS &L, const RHS &R)
CmpClass_match< LHS, RHS, ICmpInst > m_ICmp(CmpPredicate &Pred, const LHS &L, const RHS &R)
match_combine_or< CastInst_match< OpTy, ZExtInst >, CastInst_match< OpTy, SExtInst > > m_ZExtOrSExt(const OpTy &Op)
FNeg_match< OpTy > m_FNeg(const OpTy &X)
Match 'fneg X' as 'fsub -0.0, X'.
BinOpPred_match< LHS, RHS, is_shift_op > m_Shift(const LHS &L, const RHS &R)
Matches shift operations.
BinaryOp_match< LHS, RHS, Instruction::Shl > m_Shl(const LHS &L, const RHS &R)
BinOpPred_match< LHS, RHS, is_irem_op > m_IRem(const LHS &L, const RHS &R)
Matches integer remainder operations.
apfloat_match m_APFloat(const APFloat *&Res)
Match a ConstantFP or splatted ConstantVector, binding the specified pointer to the contained APFloat...
auto m_LogicalAnd()
Matches L && R where L and R are arbitrary values.
class_match< BasicBlock > m_BasicBlock()
Match an arbitrary basic block value and ignore it.
BinaryOp_match< LHS, RHS, Instruction::SRem > m_SRem(const LHS &L, const RHS &R)
cst_pred_ty< is_nonpositive > m_NonPositive()
Match an integer or vector of non-positive values.
BinaryOp_match< cst_pred_ty< is_all_ones >, ValTy, Instruction::Xor, true > m_Not(const ValTy &V)
Matches a 'Not' as 'xor V, -1' or 'xor -1, V'.
BinaryOp_match< LHS, RHS, Instruction::Or > m_Or(const LHS &L, const RHS &R)
CastInst_match< OpTy, SExtInst > m_SExt(const OpTy &Op)
Matches SExt.
is_zero m_Zero()
Match any null constant or a vector with all elements equal to 0.
BinaryOp_match< LHS, RHS, Instruction::Or, true > m_c_Or(const LHS &L, const RHS &R)
Matches an Or with LHS and RHS in either order.
match_combine_or< OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap >, DisjointOr_match< LHS, RHS > > m_NUWAddLike(const LHS &L, const RHS &R)
Match either "add nuw" or "or disjoint".
BinOpPred_match< LHS, RHS, is_bitwiselogic_op > m_BitwiseLogic(const LHS &L, const RHS &R)
Matches bitwise logic operations.
ElementWiseBitCast_match< OpTy > m_ElementWiseBitCast(const OpTy &Op)
m_Intrinsic_Ty< Opnd0 >::Ty m_FAbs(const Opnd0 &Op0)
CastOperator_match< OpTy, Instruction::PtrToInt > m_PtrToInt(const OpTy &Op)
Matches PtrToInt.
BinaryOp_match< LHS, RHS, Instruction::Sub > m_Sub(const LHS &L, const RHS &R)
MaxMin_match< ICmpInst, LHS, RHS, umin_pred_ty > m_UMin(const LHS &L, const RHS &R)
match_combine_or< LTy, RTy > m_CombineOr(const LTy &L, const RTy &R)
Combine two pattern matchers matching L || R.
static unsigned decodeVSEW(unsigned VSEW)
unsigned getSEWLMULRatio(unsigned SEW, RISCVII::VLMUL VLMul)
static constexpr unsigned RVVBitsPerBlock
initializer< Ty > init(const Ty &Val)
This is an optimization pass for GlobalISel generic memory operations.
bool haveNoCommonBitsSet(const WithCache< const Value * > &LHSCache, const WithCache< const Value * > &RHSCache, const SimplifyQuery &SQ)
Return true if LHS and RHS have no common bits set.
bool mustExecuteUBIfPoisonOnPathTo(Instruction *Root, Instruction *OnPathTo, DominatorTree *DT)
Return true if undefined behavior would provable be executed on the path to OnPathTo if Root produced...
Intrinsic::ID getInverseMinMaxIntrinsic(Intrinsic::ID MinMaxID)
@ NeverOverflows
Never overflows.
@ AlwaysOverflowsHigh
Always overflows in the direction of signed/unsigned max value.
@ AlwaysOverflowsLow
Always overflows in the direction of signed/unsigned min value.
@ MayOverflow
May or may not overflow.
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
bool isValidAssumeForContext(const Instruction *I, const Instruction *CxtI, const DominatorTree *DT=nullptr, bool AllowEphemerals=false)
Return true if it is valid to use the assumptions provided by an assume intrinsic,...
auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)
Get the size of a range.
bool canCreatePoison(const Operator *Op, bool ConsiderFlagsAndMetadata=true)
bool mustTriggerUB(const Instruction *I, const SmallPtrSetImpl< const Value * > &KnownPoison)
Return true if the given instruction must trigger undefined behavior when I is executed with any oper...
detail::scope_exit< std::decay_t< Callable > > make_scope_exit(Callable &&F)
bool isOnlyUsedInZeroEqualityComparison(const Instruction *CxtI)
bool isSignBitCheck(ICmpInst::Predicate Pred, const APInt &RHS, bool &TrueIfSigned)
Given an exploded icmp instruction, return true if the comparison only checks the sign bit.
const Value * getArgumentAliasingToReturnedPointer(const CallBase *Call, bool MustPreserveNullness)
This function returns call pointer argument that is considered the same by aliasing rules.
bool isAssumeLikeIntrinsic(const Instruction *I)
Return true if it is an intrinsic that cannot be speculated but also cannot trap.
AllocaInst * findAllocaForValue(Value *V, bool OffsetZero=false)
Returns unique alloca where the value comes from, or nullptr.
APInt getMinMaxLimit(SelectPatternFlavor SPF, unsigned BitWidth)
Return the minimum or maximum constant value for the specified integer min/max flavor and type.
void getGuaranteedNonPoisonOps(const Instruction *I, SmallVectorImpl< const Value * > &Ops)
Insert operands of I into Ops such that I will trigger undefined behavior if I is executed and that o...
bool isOnlyUsedInZeroComparison(const Instruction *CxtI)
const Value * getLoadStorePointerOperand(const Value *V)
A helper function that returns the pointer operand of a load or store instruction.
bool getConstantStringInfo(const Value *V, StringRef &Str, bool TrimAtNul=true)
This function computes the length of a null-terminated C string pointed to by V.
bool isDereferenceableAndAlignedPointer(const Value *V, Type *Ty, Align Alignment, const DataLayout &DL, const Instruction *CtxI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr)
Returns true if V is always a dereferenceable pointer with alignment greater or equal than requested.
bool onlyUsedByLifetimeMarkersOrDroppableInsts(const Value *V)
Return true if the only users of this pointer are lifetime markers or droppable instructions.
Constant * ReadByteArrayFromGlobal(const GlobalVariable *GV, uint64_t Offset)
bool getUnderlyingObjectsForCodeGen(const Value *V, SmallVectorImpl< Value * > &Objects)
This is a wrapper around getUnderlyingObjects and adds support for basic ptrtoint+arithmetic+inttoptr...
std::pair< Intrinsic::ID, bool > canConvertToMinOrMaxIntrinsic(ArrayRef< Value * > VL)
Check if the values in VL are select instructions that can be converted to a min or max (vector) intr...
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
bool getConstantDataArrayInfo(const Value *V, ConstantDataArraySlice &Slice, unsigned ElementSize, uint64_t Offset=0)
Returns true if the value V is a pointer into a ConstantDataArray.
int bit_width(T Value)
Returns the number of bits needed to represent Value if Value is nonzero.
bool isGuaranteedToExecuteForEveryIteration(const Instruction *I, const Loop *L)
Return true if this function can prove that the instruction I is executed for every iteration of the ...
void append_range(Container &C, Range &&R)
Wrapper function to append range R to container C.
const Value * getUnderlyingObject(const Value *V, unsigned MaxLookup=6)
This method strips off any GEP address adjustments, pointer casts or llvm.threadlocal....
bool isKnownToBeAPowerOfTwo(const Value *V, const DataLayout &DL, bool OrZero=false, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true)
Return true if the given value is known to have exactly one bit set when defined.
bool mustSuppressSpeculation(const LoadInst &LI)
Return true if speculation of the given load must be suppressed to avoid ordering or interfering with...
constexpr bool isPowerOf2_64(uint64_t Value)
Return true if the argument is a power of two > 0 (64 bit edition.)
gep_type_iterator gep_type_end(const User *GEP)
CmpInst::Predicate getMinMaxPred(SelectPatternFlavor SPF, bool Ordered=false)
Return the canonical comparison predicate for the specified minimum/maximum flavor.
void computeKnownBitsFromContext(const Value *V, KnownBits &Known, unsigned Depth, const SimplifyQuery &Q)
Merge bits known from context-dependent facts into Known.
unsigned Log2_64(uint64_t Value)
Return the floor log base 2 of the specified value, -1 if the value is zero.
bool isGuaranteedNotToBeUndef(const Value *V, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, unsigned Depth=0)
Returns true if V cannot be undef, but may be poison.
ConstantRange getConstantRangeFromMetadata(const MDNode &RangeMD)
Parse out a conservative ConstantRange from !range metadata.
ConstantRange computeConstantRange(const Value *V, bool ForSigned, bool UseInstrInfo=true, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, unsigned Depth=0)
Determine the possible constant range of an integer or vector of integer value.
const Value * getPointerOperand(const Value *V)
A helper function that returns the pointer operand of a load, store or GEP instruction.
bool MaskedValueIsZero(const Value *V, const APInt &Mask, const SimplifyQuery &SQ, unsigned Depth=0)
Return true if 'V & Mask' is known to be zero.
int countr_zero(T Val)
Count number of 0's from the least significant bit to the most stopping at the first 1.
bool isOverflowIntrinsicNoWrap(const WithOverflowInst *WO, const DominatorTree &DT)
Returns true if the arithmetic part of the WO 's result is used only along the paths control dependen...
RetainedKnowledge getKnowledgeValidInContext(const Value *V, ArrayRef< Attribute::AttrKind > AttrKinds, const Instruction *CtxI, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr)
Return a valid Knowledge associated to the Value V if its Attribute kind is in AttrKinds and the know...
RetainedKnowledge getKnowledgeFromBundle(AssumeInst &Assume, const CallBase::BundleOpInfo &BOI)
This extracts the Knowledge from an element of an operand bundle.
bool matchSimpleRecurrence(const PHINode *P, BinaryOperator *&BO, Value *&Start, Value *&Step)
Attempt to match a simple first order recurrence cycle of the form: iv = phi Ty [Start,...
bool isSafeToSpeculativelyExecuteWithOpcode(unsigned Opcode, const Instruction *Inst, const Instruction *CtxI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr, bool UseVariableInfo=true)
This returns the same result as isSafeToSpeculativelyExecute if Opcode is the actual opcode of Inst.
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
KnownBits analyzeKnownBitsFromAndXorOr(const Operator *I, const KnownBits &KnownLHS, const KnownBits &KnownRHS, unsigned Depth, const SimplifyQuery &SQ)
Using KnownBits LHS/RHS produce the known bits for logic op (and/xor/or).
OverflowResult computeOverflowForUnsignedMul(const Value *LHS, const Value *RHS, const SimplifyQuery &SQ, bool IsNSW=false)
bool getShuffleDemandedElts(int SrcWidth, ArrayRef< int > Mask, const APInt &DemandedElts, APInt &DemandedLHS, APInt &DemandedRHS, bool AllowUndefElts=false)
Transform a shuffle mask's output demanded element mask into demanded element masks for the 2 operand...
unsigned Log2_32(uint32_t Value)
Return the floor log base 2 of the specified value, -1 if the value is zero.
bool isGuard(const User *U)
Returns true iff U has semantics of a guard expressed in a form of call of llvm.experimental....
int countl_zero(T Val)
Count number of 0's from the most significant bit to the least stopping at the first 1.
SelectPatternFlavor getInverseMinMaxFlavor(SelectPatternFlavor SPF)
Return the inverse minimum/maximum flavor of the specified flavor.
constexpr unsigned MaxAnalysisRecursionDepth
bool isKnownNegative(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Returns true if the given value is known be negative (i.e.
void getGuaranteedWellDefinedOps(const Instruction *I, SmallVectorImpl< const Value * > &Ops)
Insert operands of I into Ops such that I will trigger undefined behavior if I is executed and that o...
OverflowResult computeOverflowForSignedSub(const Value *LHS, const Value *RHS, const SimplifyQuery &SQ)
std::tuple< Value *, FPClassTest, FPClassTest > fcmpImpliesClass(CmpInst::Predicate Pred, const Function &F, Value *LHS, Value *RHS, bool LookThroughSrc=true)
Compute the possible floating-point classes that LHS could be based on fcmp \Pred LHS,...
SelectPatternFlavor
Specific patterns of select instructions we can match.
@ SPF_ABS
Floating point maxnum.
@ SPF_NABS
Absolute value.
@ SPF_FMAXNUM
Floating point minnum.
@ SPF_UMIN
Signed minimum.
@ SPF_UMAX
Signed maximum.
@ SPF_SMAX
Unsigned minimum.
@ SPF_FMINNUM
Unsigned maximum.
bool isIntrinsicReturningPointerAliasingArgumentWithoutCapturing(const CallBase *Call, bool MustPreserveNullness)
{launder,strip}.invariant.group returns pointer that aliases its argument, and it only captures point...
void adjustKnownBitsForSelectArm(KnownBits &Known, Value *Cond, Value *Arm, bool Invert, unsigned Depth, const SimplifyQuery &Q)
Adjust Known for the given select Arm to include information from the select Cond.
bool impliesPoison(const Value *ValAssumedPoison, const Value *V)
Return true if V is poison given that ValAssumedPoison is already poison.
void getHorizDemandedEltsForFirstOperand(unsigned VectorBitWidth, const APInt &DemandedElts, APInt &DemandedLHS, APInt &DemandedRHS)
Compute the demanded elements mask of horizontal binary operations.
SelectPatternResult getSelectPattern(CmpInst::Predicate Pred, SelectPatternNaNBehavior NaNBehavior=SPNB_NA, bool Ordered=false)
Determine the pattern for predicate X Pred Y ? X : Y.
FPClassTest
Floating-point class tests, supported by 'is_fpclass' intrinsic.
bool programUndefinedIfPoison(const Instruction *Inst)
SelectPatternResult matchSelectPattern(Value *V, Value *&LHS, Value *&RHS, Instruction::CastOps *CastOp=nullptr, unsigned Depth=0)
Pattern match integer [SU]MIN, [SU]MAX and ABS idioms, returning the kind and providing the out param...
bool NullPointerIsDefined(const Function *F, unsigned AS=0)
Check whether null pointer dereferencing is considered undefined behavior for a given function or an ...
bool programUndefinedIfUndefOrPoison(const Instruction *Inst)
Return true if this function can prove that if Inst is executed and yields a poison value or undef bi...
bool isSafeToSpeculativelyExecute(const Instruction *I, const Instruction *CtxI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr, bool UseVariableInfo=true)
Return true if the instruction does not have any effects besides calculating the result and does not ...
FPClassTest inverse_fabs(FPClassTest Mask)
Return the test mask which returns true after fabs is applied to the value.
uint64_t GetStringLength(const Value *V, unsigned CharSize=8)
If we can compute the length of the string pointed to by the specified pointer, return 'len+1'.
OverflowResult computeOverflowForSignedMul(const Value *LHS, const Value *RHS, const SimplifyQuery &SQ)
ConstantRange getVScaleRange(const Function *F, unsigned BitWidth)
Determine the possible constant range of vscale with the given bit width, based on the vscale_range f...
Constant * ConstantFoldCastOperand(unsigned Opcode, Constant *C, Type *DestTy, const DataLayout &DL)
Attempt to constant fold a cast with the specified operand.
bool canCreateUndefOrPoison(const Operator *Op, bool ConsiderFlagsAndMetadata=true)
canCreateUndefOrPoison returns true if Op can create undef or poison from non-undef & non-poison oper...
EHPersonality classifyEHPersonality(const Value *Pers)
See if the given exception handling personality function is one that we understand.
bool isKnownInversion(const Value *X, const Value *Y)
Return true iff:
bool isNotCrossLaneOperation(const Instruction *I)
Return true if the instruction doesn't potentially cross vector lanes.
bool isKnownNonZero(const Value *V, const SimplifyQuery &Q, unsigned Depth=0)
Return true if the given value is known to be non-zero when defined.
constexpr int PoisonMaskElem
bool onlyUsedByLifetimeMarkers(const Value *V)
Return true if the only users of this pointer are lifetime markers.
Intrinsic::ID getIntrinsicForCallSite(const CallBase &CB, const TargetLibraryInfo *TLI)
Map a call instruction to an intrinsic ID.
@ First
Helpers to iterate all locations in the MemoryEffectsBase class.
const Value * getUnderlyingObjectAggressive(const Value *V)
Like getUnderlyingObject(), but will try harder to find a single underlying object.
Intrinsic::ID getMinMaxIntrinsic(SelectPatternFlavor SPF)
Convert given SPF to equivalent min/max intrinsic.
OverflowResult computeOverflowForSignedAdd(const WithCache< const Value * > &LHS, const WithCache< const Value * > &RHS, const SimplifyQuery &SQ)
bool propagatesPoison(const Use &PoisonOp)
Return true if PoisonOp's user yields poison or raises UB if its operand PoisonOp is poison.
bool isKnownNonEqual(const Value *V1, const Value *V2, const DataLayout &DL, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true)
Return true if the given values are known to be non-equal when defined.
ConstantRange computeConstantRangeIncludingKnownBits(const WithCache< const Value * > &V, bool ForSigned, const SimplifyQuery &SQ)
Combine constant ranges from computeConstantRange() and computeKnownBits().
SelectPatternNaNBehavior
Behavior when a floating point min/max is given one NaN and one non-NaN as input.
@ SPNB_RETURNS_NAN
NaN behavior not applicable.
@ SPNB_RETURNS_OTHER
Given one NaN input, returns the NaN.
@ SPNB_RETURNS_ANY
Given one NaN input, returns the non-NaN.
void computeKnownBits(const Value *V, KnownBits &Known, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true)
Determine which bits of V are known to be either zero or one and return them in the KnownZero/KnownOn...
DWARFExpression::Operation Op
bool isGuaranteedNotToBeUndefOrPoison(const Value *V, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, unsigned Depth=0)
Return true if this function can prove that V does not have undef bits and is never poison.
constexpr unsigned BitWidth
SelectPatternResult matchDecomposedSelectPattern(CmpInst *CmpI, Value *TrueVal, Value *FalseVal, Value *&LHS, Value *&RHS, Instruction::CastOps *CastOp=nullptr, unsigned Depth=0)
Determine the pattern that a select with the given compare as its predicate and given values as its t...
OverflowResult computeOverflowForUnsignedSub(const Value *LHS, const Value *RHS, const SimplifyQuery &SQ)
bool isGuaranteedToTransferExecutionToSuccessor(const Instruction *I)
Return true if this function can prove that the instruction I will always transfer execution to one o...
gep_type_iterator gep_type_begin(const User *GEP)
std::pair< Value *, FPClassTest > fcmpToClassTest(CmpInst::Predicate Pred, const Function &F, Value *LHS, Value *RHS, bool LookThroughSrc=true)
Returns a pair of values, which if passed to llvm.is.fpclass, returns the same result as an fcmp with...
Value * isBytewiseValue(Value *V, const DataLayout &DL)
If the specified value can be set by repeating the same byte in memory, return the i8 value that it i...
std::optional< std::pair< CmpPredicate, Constant * > > getFlippedStrictnessPredicateAndConstant(CmpPredicate Pred, Constant *C)
Convert an integer comparison with a constant RHS into an equivalent form with the strictness flipped...
void getUnderlyingObjects(const Value *V, SmallVectorImpl< const Value * > &Objects, const LoopInfo *LI=nullptr, unsigned MaxLookup=6)
This method is similar to getUnderlyingObject except that it can look through phi and select instruct...
bool is_contained(R &&Range, const E &Element)
Returns true if Element is found in Range.
unsigned ComputeNumSignBits(const Value *Op, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true)
Return the number of times the sign bit of the register is replicated into the other bits.
OverflowResult computeOverflowForUnsignedAdd(const WithCache< const Value * > &LHS, const WithCache< const Value * > &RHS, const SimplifyQuery &SQ)
unsigned Log2(Align A)
Returns the log2 of the alignment.
std::optional< bool > isImpliedByDomCondition(const Value *Cond, const Instruction *ContextI, const DataLayout &DL)
Return the boolean condition value in the context of the given instruction if it is known based on do...
bool isGEPBasedOnPointerToString(const GEPOperator *GEP, unsigned CharSize=8)
Returns true if the GEP is based on a pointer to a string (array of.
bool isGuaranteedNotToBePoison(const Value *V, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, unsigned Depth=0)
Returns true if V cannot be poison, but may be undef.
KnownFPClass computeKnownFPClass(const Value *V, const APInt &DemandedElts, FPClassTest InterestedClasses, unsigned Depth, const SimplifyQuery &SQ)
Determine which floating-point classes are valid for V, and return them in KnownFPClass bit sets.
void computeKnownBitsFromRangeMetadata(const MDNode &Ranges, KnownBits &Known)
Compute known bits from the range metadata.
Value * FindInsertedValue(Value *V, ArrayRef< unsigned > idx_range, std::optional< BasicBlock::iterator > InsertBefore=std::nullopt)
Given an aggregate and an sequence of indices, see if the scalar value indexed is already around as a...
bool isKnownNegation(const Value *X, const Value *Y, bool NeedNSW=false, bool AllowPoison=true)
Return true if the two given values are negation.
bool isKnownPositive(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Returns true if the given value is known be positive (i.e.
Constant * ConstantFoldIntegerCast(Constant *C, Type *DestTy, bool IsSigned, const DataLayout &DL)
Constant fold a zext, sext or trunc, depending on IsSigned and whether the DestTy is wider or narrowe...
bool isKnownNonNegative(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Returns true if the give value is known to be non-negative.
unsigned ComputeMaxSignificantBits(const Value *Op, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
Get the upper bound on bit size for this Value Op as a signed integer.
bool mayHaveNonDefUseDependency(const Instruction &I)
Returns true if the result or effects of the given instructions I depend values not reachable through...
bool isTriviallyVectorizable(Intrinsic::ID ID)
Identify if the intrinsic is trivially vectorizable.
bool isIdentifiedObject(const Value *V)
Return true if this pointer refers to a distinct and identifiable object.
std::optional< bool > isImpliedCondition(const Value *LHS, const Value *RHS, const DataLayout &DL, bool LHSIsTrue=true, unsigned Depth=0)
Return true if RHS is known to be implied true by LHS.
void findValuesAffectedByCondition(Value *Cond, bool IsAssume, function_ref< void(Value *)> InsertAffected)
Call InsertAffected on all Values whose known bits / value may be affected by the condition Cond.
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
static unsigned int semanticsPrecision(const fltSemantics &)
static bool isRepresentableAsNormalIn(const fltSemantics &Src, const fltSemantics &Dst)
This struct is a compact representation of a valid (non-zero power of two) alignment.
SmallPtrSet< Value *, 4 > AffectedValues
Represents offset+length into a ConstantDataArray.
uint64_t Length
Length of the slice.
uint64_t Offset
Slice starts at this Offset.
const ConstantDataArray * Array
ConstantDataArray pointer.
Represent subnormal handling kind for floating point instruction inputs and outputs.
DenormalModeKind Input
Denormal treatment kind for floating point instruction inputs in the default floating-point environme...
constexpr bool outputsAreZero() const
Return true if output denormals should be flushed to 0.
@ PreserveSign
The sign of a flushed-to-zero number is preserved in the sign of 0.
@ PositiveZero
Denormals are flushed to positive zero.
@ Dynamic
Denormals have unknown treatment.
@ IEEE
IEEE-754 denormal numbers preserved.
static constexpr DenormalMode getPositiveZero()
constexpr bool inputsAreZero() const
Return true if input denormals must be implicitly treated as 0.
DenormalModeKind Output
Denormal flushing mode for floating point instruction results in the default floating point environme...
static constexpr DenormalMode getIEEE()
InstrInfoQuery provides an interface to query additional information for instructions like metadata o...
bool isExact(const BinaryOperator *Op) const
MDNode * getMetadata(const Instruction *I, unsigned KindID) const
bool hasNoSignedZeros(const InstT *Op) const
bool hasNoSignedWrap(const InstT *Op) const
bool hasNoUnsignedWrap(const InstT *Op) const
static KnownBits makeConstant(const APInt &C)
Create known bits from a known constant.
static KnownBits sadd_sat(const KnownBits &LHS, const KnownBits &RHS)
Compute knownbits resulting from llvm.sadd.sat(LHS, RHS)
static std::optional< bool > eq(const KnownBits &LHS, const KnownBits &RHS)
Determine if these known bits always give the same ICMP_EQ result.
KnownBits anyextOrTrunc(unsigned BitWidth) const
Return known bits for an "any" extension or truncation of the value we're tracking.
static KnownBits mulhu(const KnownBits &LHS, const KnownBits &RHS)
Compute known bits from zero-extended multiply-hi.
unsigned countMinSignBits() const
Returns the number of times the sign bit is replicated into the other bits.
static KnownBits smax(const KnownBits &LHS, const KnownBits &RHS)
Compute known bits for smax(LHS, RHS).
bool isNonNegative() const
Returns true if this value is known to be non-negative.
KnownBits blsi() const
Compute known bits for X & -X, which has only the lowest bit set of X set.
void makeNonNegative()
Make this value non-negative.
static KnownBits usub_sat(const KnownBits &LHS, const KnownBits &RHS)
Compute knownbits resulting from llvm.usub.sat(LHS, RHS)
unsigned countMinLeadingOnes() const
Returns the minimum number of leading one bits.
unsigned countMinTrailingZeros() const
Returns the minimum number of trailing zero bits.
static KnownBits ashr(const KnownBits &LHS, const KnownBits &RHS, bool ShAmtNonZero=false, bool Exact=false)
Compute known bits for ashr(LHS, RHS).
static KnownBits ssub_sat(const KnownBits &LHS, const KnownBits &RHS)
Compute knownbits resulting from llvm.ssub.sat(LHS, RHS)
static KnownBits urem(const KnownBits &LHS, const KnownBits &RHS)
Compute known bits for urem(LHS, RHS).
bool isUnknown() const
Returns true if we don't know any bits.
unsigned countMaxTrailingZeros() const
Returns the maximum number of trailing zero bits possible.
KnownBits blsmsk() const
Compute known bits for X ^ (X - 1), which has all bits up to and including the lowest set bit of X se...
void makeNegative()
Make this value negative.
KnownBits trunc(unsigned BitWidth) const
Return known bits for a truncation of the value we're tracking.
bool hasConflict() const
Returns true if there is conflicting information.
unsigned countMaxPopulation() const
Returns the maximum number of bits that could be one.
void setAllZero()
Make all bits known to be zero and discard any previous information.
unsigned getBitWidth() const
Get the bit width of this value.
static KnownBits umax(const KnownBits &LHS, const KnownBits &RHS)
Compute known bits for umax(LHS, RHS).
bool isConstant() const
Returns true if we know the value of all bits.
void resetAll()
Resets the known state of all bits.
KnownBits unionWith(const KnownBits &RHS) const
Returns KnownBits information that is known to be true for either this or RHS or both.
static KnownBits lshr(const KnownBits &LHS, const KnownBits &RHS, bool ShAmtNonZero=false, bool Exact=false)
Compute known bits for lshr(LHS, RHS).
bool isNonZero() const
Returns true if this value is known to be non-zero.
KnownBits intersectWith(const KnownBits &RHS) const
Returns KnownBits information that is known to be true for both this and RHS.
KnownBits sext(unsigned BitWidth) const
Return known bits for a sign extension of the value we're tracking.
unsigned countMinTrailingOnes() const
Returns the minimum number of trailing one bits.
static KnownBits add(const KnownBits &LHS, const KnownBits &RHS, bool NSW=false, bool NUW=false)
Compute knownbits resulting from addition of LHS and RHS.
KnownBits zextOrTrunc(unsigned BitWidth) const
Return known bits for a zero extension or truncation of the value we're tracking.
unsigned countMinLeadingZeros() const
Returns the minimum number of leading zero bits.
APInt getMaxValue() const
Return the maximal unsigned value possible given these KnownBits.
static KnownBits smin(const KnownBits &LHS, const KnownBits &RHS)
Compute known bits for smin(LHS, RHS).
static KnownBits mulhs(const KnownBits &LHS, const KnownBits &RHS)
Compute known bits from sign-extended multiply-hi.
static KnownBits srem(const KnownBits &LHS, const KnownBits &RHS)
Compute known bits for srem(LHS, RHS).
static KnownBits udiv(const KnownBits &LHS, const KnownBits &RHS, bool Exact=false)
Compute known bits for udiv(LHS, RHS).
static KnownBits computeForAddSub(bool Add, bool NSW, bool NUW, const KnownBits &LHS, const KnownBits &RHS)
Compute known bits resulting from adding LHS and RHS.
static KnownBits sdiv(const KnownBits &LHS, const KnownBits &RHS, bool Exact=false)
Compute known bits for sdiv(LHS, RHS).
static bool haveNoCommonBitsSet(const KnownBits &LHS, const KnownBits &RHS)
Return true if LHS and RHS have no common bits set.
bool isNegative() const
Returns true if this value is known to be negative.
static KnownBits sub(const KnownBits &LHS, const KnownBits &RHS, bool NSW=false, bool NUW=false)
Compute knownbits resulting from subtraction of LHS and RHS.
unsigned countMaxLeadingZeros() const
Returns the maximum number of leading zero bits possible.
void setAllOnes()
Make all bits known to be one and discard any previous information.
void insertBits(const KnownBits &SubBits, unsigned BitPosition)
Insert the bits from a smaller known bits starting at bitPosition.
static KnownBits uadd_sat(const KnownBits &LHS, const KnownBits &RHS)
Compute knownbits resulting from llvm.uadd.sat(LHS, RHS)
static KnownBits mul(const KnownBits &LHS, const KnownBits &RHS, bool NoUndefSelfMultiply=false)
Compute known bits resulting from multiplying LHS and RHS.
KnownBits anyext(unsigned BitWidth) const
Return known bits for an "any" extension of the value we're tracking, where we don't know anything ab...
KnownBits abs(bool IntMinIsPoison=false) const
Compute known bits for the absolute value.
static std::optional< bool > sgt(const KnownBits &LHS, const KnownBits &RHS)
Determine if these known bits always give the same ICMP_SGT result.
static std::optional< bool > uge(const KnownBits &LHS, const KnownBits &RHS)
Determine if these known bits always give the same ICMP_UGE result.
static KnownBits shl(const KnownBits &LHS, const KnownBits &RHS, bool NUW=false, bool NSW=false, bool ShAmtNonZero=false)
Compute known bits for shl(LHS, RHS).
static KnownBits umin(const KnownBits &LHS, const KnownBits &RHS)
Compute known bits for umin(LHS, RHS).
KnownBits sextOrTrunc(unsigned BitWidth) const
Return known bits for a sign extension or truncation of the value we're tracking.
const APInt & getConstant() const
Returns the value when all bits have a known value.
FPClassTest KnownFPClasses
Floating-point classes the value could be one of.
bool isKnownNeverInfinity() const
Return true if it's known this can never be an infinity.
bool cannotBeOrderedGreaterThanZero() const
Return true if we can prove that the analyzed floating-point value is either NaN or never greater tha...
static constexpr FPClassTest OrderedGreaterThanZeroMask
static constexpr FPClassTest OrderedLessThanZeroMask
void knownNot(FPClassTest RuleOut)
bool isKnownNeverZero() const
Return true if it's known this can never be a zero.
void copysign(const KnownFPClass &Sign)
bool isKnownNeverSubnormal() const
Return true if it's known this can never be a subnormal.
bool isKnownNeverLogicalNegZero(const Function &F, Type *Ty) const
Return true if it's know this can never be interpreted as a negative zero.
bool isKnownNeverLogicalPosZero(const Function &F, Type *Ty) const
Return true if it's know this can never be interpreted as a positive zero.
void propagateCanonicalizingSrc(const KnownFPClass &Src, const Function &F, Type *Ty)
Report known classes if Src is evaluated through a potentially canonicalizing operation.
void propagateDenormal(const KnownFPClass &Src, const Function &F, Type *Ty)
Propagate knowledge from a source value that could be a denormal or zero.
bool isKnownNeverNegInfinity() const
Return true if it's known this can never be -infinity.
bool isKnownNeverNegSubnormal() const
Return true if it's known this can never be a negative subnormal.
bool isKnownNeverPosZero() const
Return true if it's known this can never be a literal positive zero.
std::optional< bool > SignBit
std::nullopt if the sign bit is unknown, true if the sign bit is definitely set or false if the sign ...
bool isKnownNeverNaN() const
Return true if it's known this can never be a nan.
bool isKnownNever(FPClassTest Mask) const
Return true if it's known this can never be one of the mask entries.
bool isKnownNeverNegZero() const
Return true if it's known this can never be a negative zero.
bool isKnownNeverLogicalZero(const Function &F, Type *Ty) const
Return true if it's know this can never be interpreted as a zero.
void propagateNaN(const KnownFPClass &Src, bool PreserveSign=false)
bool cannotBeOrderedLessThanZero() const
Return true if we can prove that the analyzed floating-point value is either NaN or never less than -...
void signBitMustBeOne()
Assume the sign bit is one.
void signBitMustBeZero()
Assume the sign bit is zero.
bool isKnownNeverPosInfinity() const
Return true if it's known this can never be +infinity.
bool isKnownNeverPosSubnormal() const
Return true if it's known this can never be a positive subnormal.
Represent one information held inside an operand bundle of an llvm.assume.
SelectPatternFlavor Flavor
static bool isMinOrMax(SelectPatternFlavor SPF)
When implementing this min/max pattern as fcmp; select, does the fcmp have to be ordered?
SimplifyQuery getWithoutCondContext() const
SimplifyQuery getWithInstruction(const Instruction *I) const
const DomConditionCache * DC