59#include "llvm/IR/IntrinsicsAArch64.h"
60#include "llvm/IR/IntrinsicsAMDGPU.h"
61#include "llvm/IR/IntrinsicsRISCV.h"
62#include "llvm/IR/IntrinsicsX86.h"
98template <
typename InstTy>
105 if (
unsigned BitWidth = Ty->getScalarSizeInBits())
108 return DL.getPointerTypeSizeInBits(Ty);
128 const APInt &DemandedElts,
132 DemandedLHS = DemandedRHS = DemandedElts;
139 DemandedElts, DemandedLHS, DemandedRHS);
160 bool UseInstrInfo,
unsigned Depth) {
233 R->uge(
LHS->getType()->getScalarSizeInBits()))
247 assert(LHS->getType() == RHS->getType() &&
248 "LHS and RHS should have the same type");
249 assert(LHS->getType()->isIntOrIntVectorTy() &&
250 "LHS and RHS should be integers");
281 return !
I->user_empty() &&
286 return !
I->user_empty() &&
all_of(
I->users(), [](
const User *U) {
288 return match(U, m_ICmp(P, m_Value(), m_Zero())) && ICmpInst::isEquality(P);
297 return ::isKnownToBeAPowerOfTwo(
313 return CI->getValue().isStrictlyPositive();
319 return Known.isNonNegative() &&
326 return V.getKnownBits(SQ).isNegative();
345 return ::isKnownNonEqual(
V1, V2, DemandedElts, Q,
Depth);
352 return Mask.isSubsetOf(
Known.Zero);
359 unsigned Depth = 0) {
370 return ::ComputeNumSignBits(
380 return V->getType()->getScalarSizeInBits() - SignBits + 1;
403 const APInt &DemandedElts,
409 const unsigned BitWidth = Ty->getScalarSizeInBits();
412 if (Ty->isVectorTy())
417 const Value *
A =
nullptr, *
B =
nullptr, *
C =
nullptr, *
D =
nullptr;
420 const auto MatchSubBC = [&]() {
437 const auto MatchASubBC = [&]() {
445 const auto MatchCD = [&]() {
462 if (!Match(Op0, Op1) && !Match(Op1, Op0))
465 const auto ComputeKnownBitsOrOne = [&](
const Value *
V) {
473 const KnownBits KnownA = ComputeKnownBitsOrOne(
A);
477 const KnownBits KnownD = ComputeKnownBitsOrOne(
D);
494 if (SubBC->
getOpcode() == Instruction::Xor &&
512 const unsigned MinimumNumberOfLeadingZeros = UpperBound.
countl_zero();
525 if (Ty->isVectorTy())
528 const Value *Divisor =
nullptr, *
Cond =
nullptr, *Remainder =
nullptr,
529 *AdjustmentValue =
nullptr;
531 const APInt *Threshold =
nullptr;
532 bool TrueIfNegative =
false;
534 const auto Match = [&](
const Value *Rem,
const Value *Adjustment) {
545 if (!Match(Op0, Op1) && !Match(Op1, Op0))
549 bool IsPositiveDivisorCase =
551 bool IsAbsoluteValueCase =
552 match(AdjustmentValue,
555 if (!IsPositiveDivisorCase && !IsAbsoluteValueCase)
572 const APInt &DemandedElts,
577 if (KnownOut.
isUnknown() && !NSW && !NUW) {
606 bool NUW,
const APInt &DemandedElts,
620 bool isKnownNonNegativeOp1 =
Known.isNonNegative();
622 bool isKnownNegativeOp1 =
Known.isNegative();
623 bool isKnownNegativeOp0 = Known2.
isNegative();
626 (isKnownNonNegativeOp1 && isKnownNonNegativeOp0);
638 (isKnownNegativeOp1 && isKnownNonNegativeOp0 &&
640 (isKnownNegativeOp0 && isKnownNonNegativeOp1 &&
Known.isNonZero());
644 bool SelfMultiply = Op0 == Op1;
653 unsigned OutValidBits = 2 * (TyBits - SignBits + 1);
655 if (OutValidBits < TyBits) {
656 APInt KnownZeroMask =
658 Known.Zero |= KnownZeroMask;
668 Known.makeNonNegative();
670 Known.makeNegative();
676 unsigned NumRanges = Ranges.getNumOperands() / 2;
679 Known.setAllConflict();
681 for (
unsigned i = 0; i < NumRanges; ++i) {
690 "Known bit width must match range bit width!");
693 unsigned CommonPrefixBits =
694 (
Range.getUnsignedMax() ^
Range.getUnsignedMin()).countl_zero();
697 Known.One &= UnsignedMax & Mask;
698 Known.Zero &= ~UnsignedMax & Mask;
720 bool ReachesI =
false;
721 while (!WorkList.
empty()) {
723 for (
const User *U :
V->users()) {
729 if (UI->mayHaveSideEffects() || UI->isTerminator())
731 if (Visited.
insert(UI).second)
741 return CI->isAssumeLikeIntrinsic();
749 bool AllowEphemerals) {
761 return AllowEphemerals;
797 unsigned &NumChecked) {
802 if (!CB->hasFnAttr(Attribute::NoFree))
804 }
else if (
I.maySynchronize()) {
815 const BasicBlock *AssumeBB = Assume->getParent();
816 unsigned NumChecked = 0;
818 if (CtxBB == AssumeBB) {
819 if (Assume != CtxI && !Assume->comesBefore(CtxI))
834 while (!Worklist.
empty()) {
836 if (!Visited.
insert(CurBB).second)
839 if (CurBB == AssumeBB) {
845 "Blocks between Assume and CtxI must be dominated by AssumeBB");
861 auto StartIt = (CurBB == CtxBB) ? CtxIter : CurBB->
begin();
895 for (
unsigned ElemIdx = 0, NElem = VC->getNumElements(); ElemIdx < NElem;
898 Pred, VC->getElementAsAPInt(ElemIdx));
907 const PHINode **PhiOut =
nullptr) {
911 CtxIOut =
PHI->getIncomingBlock(*U)->getTerminator();
927 IncPhi && IncPhi->getNumIncomingValues() == 2) {
928 for (
int Idx = 0; Idx < 2; ++Idx) {
929 if (IncPhi->getIncomingValue(Idx) ==
PHI) {
930 ValOut = IncPhi->getIncomingValue(1 - Idx);
933 CtxIOut = IncPhi->getIncomingBlock(1 - Idx)->getTerminator();
952 "Got assumption for the wrong function!");
956 I->getOperandBundleAt(Elem.Index)) &&
986 if (
RHS->getType()->isPointerTy()) {
996 Known.makeNonNegative();
999 Known.makeNegative();
1028 Known.Zero |= ~*
C & *Mask;
1034 Known.One |= *
C & ~*Mask;
1057 Known.One |= *BPow2;
1073 Known.One.setHighBits(
1081 Known.Zero.setHighBits(
1093 Invert ? Cmp->getInversePredicate() : Cmp->getPredicate();
1099 KnownBits DstKnown(
LHS->getType()->getScalarSizeInBits());
1113 bool Invert,
unsigned Depth) {
1177 if (
Known.hasConflict())
1195 "Got assumption for the wrong function!");
1198 auto OBU =
I->getOperandBundleAt(Elem.Index);
1200 case BundleAttr::Align: {
1209 case BundleAttr::Range: {
1225 Value *Arg =
I->getArgOperand(0);
1241 if (Trunc && Trunc->getOperand(0) == V &&
1243 if (Trunc->hasNoUnsignedWrap()) {
1247 Known.One.setBit(0);
1267 if (
Known.hasConflict())
1288 Known.isNonZero() ||
1289 (
Known.getMaxValue().ult(
Known.getBitWidth()) &&
1302 Value *
X =
nullptr, *
Y =
nullptr;
1304 switch (
I->getOpcode()) {
1305 case Instruction::And:
1306 KnownOut = KnownLHS & KnownRHS;
1316 KnownOut = KnownLHS.
blsi();
1318 KnownOut = KnownRHS.
blsi();
1321 case Instruction::Or:
1322 KnownOut = KnownLHS | KnownRHS;
1324 case Instruction::Xor:
1325 KnownOut = KnownLHS ^ KnownRHS;
1335 const KnownBits &XBits =
I->getOperand(0) ==
X ? KnownLHS : KnownRHS;
1336 KnownOut = XBits.
blsmsk();
1349 if (!KnownOut.
Zero[0] && !KnownOut.
One[0] &&
1370 APInt DemandedEltsLHS, DemandedEltsRHS;
1372 DemandedElts, DemandedEltsLHS,
1375 const auto ComputeForSingleOpFunc =
1377 return KnownBitsFunc(
1382 if (DemandedEltsRHS.
isZero())
1383 return ComputeForSingleOpFunc(
I->getOperand(0), DemandedEltsLHS);
1384 if (DemandedEltsLHS.
isZero())
1385 return ComputeForSingleOpFunc(
I->getOperand(1), DemandedEltsRHS);
1387 return ComputeForSingleOpFunc(
I->getOperand(0), DemandedEltsLHS)
1388 .intersectWith(ComputeForSingleOpFunc(
I->getOperand(1), DemandedEltsRHS));
1398 APInt DemandedElts =
1406 Attribute Attr =
F->getFnAttribute(Attribute::VScaleRange);
1414 return ConstantRange::getEmpty(
BitWidth);
1432 if (!MD || MD->getNumOperands() != 1)
1452 if (
F->getFnAttribute(Attribute::VScaleRange).isValid()) {
1461 Value *Arm,
bool Invert,
1464 if (
Known.isConstant())
1491 Known = std::move(CondRes);
1500 "Input should be a Select!");
1510 const Value *LHS2 =
nullptr, *RHS2 =
nullptr;
1522 return CLow->
sle(*CHigh);
1527 const APInt *&CHigh) {
1528 assert((
II->getIntrinsicID() == Intrinsic::smin ||
1529 II->getIntrinsicID() == Intrinsic::smax) &&
1530 "Must be smin/smax");
1534 if (!InnerII || InnerII->getIntrinsicID() != InverseID ||
1539 if (
II->getIntrinsicID() == Intrinsic::smin)
1541 return CLow->
sle(*CHigh);
1546 const APInt *CLow, *CHigh;
1560 unsigned OpNum =
P->getOperand(0) == Start ? 0 : 1;
1562 RecQ.
CtxI =
P->getIncomingBlock(OpNum)->getTerminator();
1565 RecQ.
CtxI =
P->getIncomingBlock(1 - OpNum)->getTerminator();
1570 const APInt &DemandedElts,
1577 switch (
I->getOpcode()) {
1579 case Instruction::Load:
1584 case Instruction::And:
1590 case Instruction::Or:
1596 case Instruction::Xor:
1602 case Instruction::Mul: {
1609 case Instruction::UDiv: {
1616 case Instruction::SDiv: {
1623 case Instruction::Select: {
1624 auto ComputeForArm = [&](
Value *Arm,
bool Invert) {
1632 ComputeForArm(
I->getOperand(1),
false)
1633 .intersectWith(ComputeForArm(
I->getOperand(2),
true));
1636 case Instruction::FPToSI: {
1646 Known.makeNonNegative();
1649 case Instruction::FPTrunc:
1650 case Instruction::FPExt:
1651 case Instruction::FPToUI:
1652 case Instruction::SIToFP:
1653 case Instruction::UIToFP:
1655 case Instruction::PtrToInt:
1656 case Instruction::PtrToAddr:
1657 case Instruction::IntToPtr:
1660 case Instruction::ZExt:
1661 case Instruction::Trunc: {
1662 Type *SrcTy =
I->getOperand(0)->getType();
1664 unsigned SrcBitWidth;
1672 assert(SrcBitWidth &&
"SrcBitWidth can't be zero");
1676 Inst && Inst->hasNonNeg() && !
Known.isNegative())
1677 Known.makeNonNegative();
1681 case Instruction::BitCast: {
1682 Type *SrcTy =
I->getOperand(0)->getType();
1683 if (SrcTy->isIntOrPtrTy() &&
1686 !
I->getType()->isVectorTy()) {
1694 V->getType()->isFPOrFPVectorTy()) {
1695 Type *FPType =
V->getType()->getScalarType();
1699 Known = Result.toKnownBits(FPType->getFltSemantics());
1706 if (!SrcVecTy || !SrcVecTy->getElementType()->isIntegerTy() ||
1707 !
I->getType()->isIntOrIntVectorTy() ||
1715 unsigned SubBitWidth = SrcVecTy->getScalarSizeInBits();
1731 unsigned SubScale =
BitWidth / SubBitWidth;
1733 for (
unsigned i = 0; i != NumElts; ++i) {
1734 if (DemandedElts[i])
1735 SubDemandedElts.
setBit(i * SubScale);
1739 for (
unsigned i = 0; i != SubScale; ++i) {
1742 unsigned ShiftElt = IsLE ? i : SubScale - 1 - i;
1743 Known.insertBits(KnownSrc, ShiftElt * SubBitWidth);
1749 unsigned SubScale = SubBitWidth /
BitWidth;
1751 APInt SubDemandedElts =
1756 Known.setAllConflict();
1757 for (
unsigned i = 0; i != NumElts; ++i) {
1758 if (DemandedElts[i]) {
1759 unsigned Shifts = IsLE ? i : NumElts - 1 - i;
1762 if (
Known.isUnknown())
1769 case Instruction::SExt: {
1771 unsigned SrcBitWidth =
I->getOperand(0)->getType()->getScalarSizeInBits();
1780 case Instruction::Shl: {
1784 bool ShAmtNonZero) {
1785 return KnownBits::shl(KnownVal, KnownAmt, NUW, NSW, ShAmtNonZero);
1791 if (
I->getOperand(0) ==
I->getOperand(1) &&
1794 Known.Zero.setBit(0);
1799 Known.Zero.setLowBits(
C->countr_zero());
1812 Known.Zero.setBitsFrom(
Y + 1);
1816 case Instruction::LShr: {
1819 bool ShAmtNonZero) {
1827 Known.Zero.setHighBits(
C->countl_zero());
1830 case Instruction::AShr: {
1833 bool ShAmtNonZero) {
1840 case Instruction::Sub: {
1847 case Instruction::Add: {
1854 case Instruction::SRem:
1860 case Instruction::URem:
1865 case Instruction::Alloca:
1868 case Instruction::GetElementPtr: {
1875 APInt AccConstIndices(IndexWidth, 0);
1877 auto AddIndexToKnown = [&](
KnownBits IndexBits) {
1886 "Index width can't be larger than pointer width");
1892 for (
unsigned i = 1, e =
I->getNumOperands(); i != e; ++i, ++GTI) {
1894 if (
Known.isUnknown())
1897 Value *Index =
I->getOperand(i);
1908 "Access to structure field must be known at compile time");
1916 AccConstIndices +=
Offset;
1933 CI->getValue().
sextOrTrunc(IndexWidth) * StrideInBytes;
1953 if (!
Known.isUnknown() && !AccConstIndices.
isZero())
1957 case Instruction::PHI: {
1960 Value *Start =
nullptr, *Step =
nullptr;
1974 case Instruction::LShr:
1975 case Instruction::AShr:
1976 case Instruction::Shl:
1977 case Instruction::UDiv:
1984 case Instruction::URem: {
1997 case Instruction::Shl:
2001 case Instruction::LShr:
2002 case Instruction::UDiv:
2003 case Instruction::URem:
2008 case Instruction::AShr:
2017 case Instruction::And: {
2022 KnownStart, KnownStep, Q,
Depth);
2028 case Instruction::Or: {
2033 KnownStart, KnownStep, Q,
Depth);
2042 case Instruction::Add:
2043 case Instruction::Sub:
2044 case Instruction::Mul: {
2049 KnownStart, KnownStep, Q,
Depth);
2068 case Instruction::Add: {
2070 Known.makeNonNegative();
2072 Known.makeNegative();
2078 case Instruction::Sub: {
2082 Known.makeNonNegative();
2084 Known.makeNegative();
2089 case Instruction::Mul:
2091 Known.makeNonNegative();
2113 if (IntrinsicID == Intrinsic::umin || IntrinsicID == Intrinsic::umax) {
2116 P, Start, Step, DemandedElts, KnownStart, KnownStep, Q,
Depth);
2118 if (IntrinsicID == Intrinsic::umin) {
2129 }
else if (
Known.isUnknown() &&
I->getType()->isPointerTy() &&
2131 GEP->getPointerOperand() ==
P) {
2141 unsigned StartIdx =
P->getIncomingValue(0) == Start ? 0 : 1;
2143 RecQ.
CtxI =
P->getIncomingBlock(StartIdx)->getTerminator();
2145 Known.Zero.setLowBits(
2147 Log2(
GEP->getMaxPreservedAlignment(Q.
DL))));
2152 if (
P->getNumIncomingValues() == 0)
2162 Known.setAllConflict();
2163 for (
const Use &U :
P->operands()) {
2191 Value *RHSValue =
nullptr;
2198 if ((TrueSucc == CtxPhi->
getParent()) !=
2220 Known2 = KnownUnion;
2229 if (
Known.isUnknown())
2235 case Instruction::Call:
2236 case Instruction::Invoke: {
2246 if (std::optional<ConstantRange>
Range = CB->getRange())
2249 if (
const Value *RV = CB->getReturnedArgOperand()) {
2250 if (RV->getType() ==
I->getType()) {
2257 if (
Known.hasConflict())
2262 switch (
II->getIntrinsicID()) {
2265 case Intrinsic::abs: {
2267 bool IntMinIsPoison =
match(
II->getArgOperand(1),
m_One());
2271 case Intrinsic::bitreverse:
2275 case Intrinsic::bswap:
2279 case Intrinsic::ctlz: {
2285 PossibleLZ = std::min(PossibleLZ,
BitWidth - 1);
2287 Known.Zero.setBitsFrom(LowBits);
2290 case Intrinsic::cttz: {
2296 PossibleTZ = std::min(PossibleTZ,
BitWidth - 1);
2298 Known.Zero.setBitsFrom(LowBits);
2301 case Intrinsic::ctpop: {
2307 Known.Zero.setBitsFrom(LowBits);
2312 case Intrinsic::fshr:
2313 case Intrinsic::fshl: {
2321 Known =
II->getIntrinsicID() == Intrinsic::fshl
2326 case Intrinsic::clmul:
2331 case Intrinsic::pext:
2336 case Intrinsic::pdep:
2341 case Intrinsic::smulh:
2346 case Intrinsic::umulh:
2351 case Intrinsic::uadd_sat:
2356 case Intrinsic::usub_sat:
2361 case Intrinsic::sadd_sat:
2366 case Intrinsic::ssub_sat:
2372 case Intrinsic::vector_reverse:
2378 case Intrinsic::vector_reduce_and:
2379 case Intrinsic::vector_reduce_or:
2380 case Intrinsic::vector_reduce_umax:
2381 case Intrinsic::vector_reduce_umin:
2382 case Intrinsic::vector_reduce_smax:
2383 case Intrinsic::vector_reduce_smin:
2386 case Intrinsic::vector_reduce_xor: {
2393 bool EvenCnt = VecTy->getElementCount().isKnownEven();
2397 if (VecTy->isScalableTy() || EvenCnt)
2398 Known.One.clearAllBits();
2401 case Intrinsic::vector_reduce_add: {
2406 Known =
Known.reduceAdd(VecTy->getNumElements());
2409 case Intrinsic::umin:
2414 case Intrinsic::umax:
2419 case Intrinsic::smin:
2425 case Intrinsic::smax:
2431 case Intrinsic::ptrmask: {
2434 const Value *Mask =
I->getOperand(1);
2435 Known2 =
KnownBits(Mask->getType()->getScalarSizeInBits());
2441 case Intrinsic::x86_sse42_crc32_64_64:
2442 Known.Zero.setBitsFrom(32);
2444 case Intrinsic::x86_ssse3_phadd_d_128:
2445 case Intrinsic::x86_ssse3_phadd_w_128:
2446 case Intrinsic::x86_avx2_phadd_d:
2447 case Intrinsic::x86_avx2_phadd_w: {
2449 I, DemandedElts, Q,
Depth,
2455 case Intrinsic::x86_ssse3_phadd_sw_128:
2456 case Intrinsic::x86_avx2_phadd_sw: {
2461 case Intrinsic::x86_ssse3_phsub_d_128:
2462 case Intrinsic::x86_ssse3_phsub_w_128:
2463 case Intrinsic::x86_avx2_phsub_d:
2464 case Intrinsic::x86_avx2_phsub_w: {
2466 I, DemandedElts, Q,
Depth,
2472 case Intrinsic::x86_ssse3_phsub_sw_128:
2473 case Intrinsic::x86_avx2_phsub_sw: {
2478 case Intrinsic::riscv_vsetvli:
2479 case Intrinsic::riscv_vsetvlimax: {
2480 bool HasAVL =
II->getIntrinsicID() == Intrinsic::riscv_vsetvli;
2493 MaxVL = std::min(MaxVL, CI->getZExtValue());
2495 unsigned KnownZeroFirstBit =
Log2_32(MaxVL) + 1;
2497 Known.Zero.setBitsFrom(KnownZeroFirstBit);
2500 case Intrinsic::amdgcn_mbcnt_hi:
2501 case Intrinsic::amdgcn_mbcnt_lo: {
2506 II->getIntrinsicID() == Intrinsic::amdgcn_mbcnt_lo ? 6 : 5);
2511 case Intrinsic::vscale: {
2512 if (!
II->getParent() || !
II->getFunction())
2518 case Intrinsic::stepvector: {
2520 unsigned MinNumElts = VecTy->getElementCount().getKnownMinValue();
2524 bool Overflow =
false;
2526 if (VecTy->isScalableTy()) {
2527 if (!
II->getParent() || !
II->getFunction())
2531 .
umul_ov(MaxNumElts, Overflow);
2546 case Instruction::ShuffleVector: {
2560 APInt DemandedLHS, DemandedRHS;
2565 Known.setAllConflict();
2566 if (!!DemandedLHS) {
2567 const Value *
LHS = Shuf->getOperand(0);
2570 if (
Known.isUnknown())
2573 if (!!DemandedRHS) {
2574 const Value *
RHS = Shuf->getOperand(1);
2580 case Instruction::InsertElement: {
2585 const Value *Vec =
I->getOperand(0);
2586 const Value *Elt =
I->getOperand(1);
2589 APInt DemandedVecElts = DemandedElts;
2590 bool NeedsElt =
true;
2592 if (CIdx && CIdx->getValue().ult(NumElts)) {
2593 DemandedVecElts.
clearBit(CIdx->getZExtValue());
2594 NeedsElt = DemandedElts[CIdx->getZExtValue()];
2597 Known.setAllConflict();
2601 if (
Known.isUnknown())
2605 if (!DemandedVecElts.
isZero()) {
2611 case Instruction::ExtractElement: {
2614 const Value *Vec =
I->getOperand(0);
2615 const Value *Idx =
I->getOperand(1);
2624 if (CIdx && CIdx->getValue().ult(NumElts))
2629 case Instruction::ExtractValue:
2634 switch (
II->getIntrinsicID()) {
2636 case Intrinsic::uadd_with_overflow:
2637 case Intrinsic::sadd_with_overflow:
2639 true,
II->getArgOperand(0),
II->getArgOperand(1),
false,
2640 false, DemandedElts,
Known, Known2, Q,
Depth);
2642 case Intrinsic::usub_with_overflow:
2643 case Intrinsic::ssub_with_overflow:
2645 false,
II->getArgOperand(0),
II->getArgOperand(1),
false,
2646 false, DemandedElts,
Known, Known2, Q,
Depth);
2648 case Intrinsic::umul_with_overflow:
2649 case Intrinsic::smul_with_overflow:
2651 false, DemandedElts,
Known, Known2, Q,
Depth);
2657 case Instruction::Freeze:
2701 if (!DemandedElts) {
2711 Type *Ty =
V->getType();
2714 assert((Ty->isIntOrIntVectorTy(
BitWidth) || Ty->isPtrOrPtrVectorTy()) &&
2715 "Not integer or pointer type!");
2719 FVTy->getNumElements() == DemandedElts.
getBitWidth() &&
2720 "DemandedElt width should equal the fixed vector number of elements");
2723 "DemandedElt width should be 1 for scalars or scalable vectors");
2729 "V and Known should have same BitWidth");
2732 "V and Known should have same BitWidth");
2753 Known.setAllConflict();
2754 for (
unsigned i = 0, e = CDV->getNumElements(); i != e; ++i) {
2755 if (!DemandedElts[i])
2757 APInt Elt = CDV->getElementAsAPInt(i);
2761 if (
Known.hasConflict())
2770 Known.setAllConflict();
2771 for (
unsigned i = 0, e = CV->getNumOperands(); i != e; ++i) {
2772 if (!DemandedElts[i])
2782 const APInt &Elt = ElementCI->getValue();
2786 if (
Known.hasConflict())
2803 if (std::optional<ConstantRange>
Range =
A->getRange())
2813 if (!GA->isInterposable())
2821 if (std::optional<ConstantRange> CR = GV->getAbsoluteSymbolRange())
2822 Known = CR->toKnownBits();
2827 Align Alignment =
V->getPointerAlignment(Q.
DL);
2843 Value *Start =
nullptr, *Step =
nullptr;
2849 if (U.get() == Start) {
2865 case Instruction::Mul:
2870 case Instruction::SDiv:
2876 case Instruction::UDiv:
2882 case Instruction::Shl:
2884 case Instruction::AShr:
2888 case Instruction::LShr:
2925 if (OrZero && V->getType()->getScalarSizeInBits() == 1)
2967 return F->hasFnAttribute(Attribute::VScaleRange);
2984 switch (
I->getOpcode()) {
2985 case Instruction::ZExt:
2987 case Instruction::Trunc:
2989 case Instruction::Shl:
2993 case Instruction::LShr:
2997 case Instruction::UDiv:
3001 case Instruction::Mul:
3005 case Instruction::And:
3016 case Instruction::Add: {
3022 if (
match(
I->getOperand(0),
3026 if (
match(
I->getOperand(1),
3031 unsigned BitWidth = V->getType()->getScalarSizeInBits();
3040 if ((~(LHSBits.
Zero & RHSBits.
Zero)).isPowerOf2())
3053 case Instruction::Select:
3056 case Instruction::PHI: {
3077 RecQ.CtxI = PN->getIncomingBlock(U)->getTerminator();
3078 return isKnownToBeAPowerOfTwo(U.get(), OrZero, RecQ, NewDepth);
3081 case Instruction::Invoke:
3082 case Instruction::Call: {
3084 switch (
II->getIntrinsicID()) {
3085 case Intrinsic::umax:
3086 case Intrinsic::smax:
3087 case Intrinsic::umin:
3088 case Intrinsic::smin:
3093 case Intrinsic::bitreverse:
3094 case Intrinsic::bswap:
3096 case Intrinsic::fshr:
3097 case Intrinsic::fshl:
3099 if (
II->getArgOperand(0) ==
II->getArgOperand(1))
3102 case Intrinsic::riscv_vsetvlimax:
3106 case Intrinsic::read_register:
3107 case Intrinsic::read_volatile_register: {
3111 if (!M || !M->getTargetTriple().isRISCV())
3136 F =
I->getFunction();
3140 if (!
GEP->hasNoUnsignedWrap() &&
3141 !(
GEP->isInBounds() &&
3146 assert(
GEP->getType()->isPointerTy() &&
"We only support plain pointer GEP");
3157 GTI != GTE; ++GTI) {
3159 if (
StructType *STy = GTI.getStructTypeOrNull()) {
3164 if (ElementOffset > 0)
3170 if (GTI.getSequentialElementStride(Q.
DL).isZero())
3204 unsigned NumUsesExplored = 0;
3205 for (
auto &U :
V->uses()) {
3214 if (
V->getType()->isPointerTy()) {
3216 if (CB->isArgOperand(&U) &&
3217 CB->paramHasNonNullAttr(CB->getArgOperandNo(&U),
3227 V->getType()->getPointerAddressSpace()) &&
3243 NonNullIfTrue =
true;
3245 NonNullIfTrue =
false;
3250 NonNullIfTrue =
true;
3256 for (
const auto *CmpU : UI->
users()) {
3258 if (Visited.
insert(CmpU).second)
3261 while (!WorkList.
empty()) {
3270 for (
const auto *CurrU : Curr->users())
3271 if (Visited.
insert(CurrU).second)
3278 BI->getSuccessor(NonNullIfTrue ? 0 : 1);
3282 }
else if (NonNullIfTrue &&
isGuard(Curr) &&
3297 const unsigned NumRanges = Ranges->getNumOperands() / 2;
3299 for (
unsigned i = 0; i < NumRanges; ++i) {
3315 Value *Start =
nullptr, *Step =
nullptr;
3316 const APInt *StartC, *StepC;
3322 case Instruction::Add:
3328 case Instruction::Mul:
3331 case Instruction::Shl:
3333 case Instruction::AShr:
3334 case Instruction::LShr:
3336 case Instruction::Or:
3368 X->getType()->getScalarSizeInBits() >=
3374 if (!
P->getType()->isPointerTy())
3378 uint64_t DerefBytes =
P->getPointerDereferenceableBytes(
3379 Q.
DL, CanBeNull,
nullptr);
3380 if (CanBeNull || DerefBytes == 0 || !
Off->ule(DerefBytes))
3388 bool NUW,
unsigned Depth) {
3448 return ::isKnownNonEqual(
X,
Y, DemandedElts, Q,
Depth);
3453 bool NUW,
unsigned Depth) {
3482 auto ShiftOp = [&](
const APInt &Lhs,
const APInt &Rhs) {
3483 switch (
I->getOpcode()) {
3484 case Instruction::Shl:
3485 return Lhs.
shl(Rhs);
3486 case Instruction::LShr:
3487 return Lhs.
lshr(Rhs);
3488 case Instruction::AShr:
3489 return Lhs.
ashr(Rhs);
3495 auto InvShiftOp = [&](
const APInt &Lhs,
const APInt &Rhs) {
3496 switch (
I->getOpcode()) {
3497 case Instruction::Shl:
3498 return Lhs.
lshr(Rhs);
3499 case Instruction::LShr:
3500 case Instruction::AShr:
3501 return Lhs.
shl(Rhs);
3514 if (MaxShift.
uge(NumBits))
3517 if (!ShiftOp(KnownVal.
One, MaxShift).isZero())
3522 if (InvShiftOp(KnownVal.
Zero, NumBits - MaxShift)
3531 const APInt &DemandedElts,
3534 switch (
I->getOpcode()) {
3535 case Instruction::Alloca:
3537 return I->getType()->getPointerAddressSpace() == 0;
3538 case Instruction::GetElementPtr:
3539 if (
I->getType()->isPointerTy())
3542 case Instruction::BitCast: {
3570 Type *FromTy =
I->getOperand(0)->getType();
3575 case Instruction::IntToPtr:
3584 case Instruction::PtrToAddr:
3588 case Instruction::PtrToInt:
3592 I->getType()->getScalarSizeInBits())
3595 case Instruction::Trunc:
3598 if (TI->hasNoSignedWrap() || TI->hasNoUnsignedWrap())
3604 case Instruction::Xor:
3605 case Instruction::Sub:
3607 I->getOperand(1),
Depth);
3608 case Instruction::Or:
3619 case Instruction::SExt:
3620 case Instruction::ZExt:
3624 case Instruction::Shl: {
3639 case Instruction::LShr:
3640 case Instruction::AShr: {
3650 if (
Known.isNegative())
3670 case Instruction::UDiv:
3671 case Instruction::SDiv: {
3686 if (
I->getOpcode() == Instruction::SDiv) {
3688 XKnown = XKnown.
abs(
false);
3689 YKnown = YKnown.
abs(
false);
3695 return XUgeY && *XUgeY;
3697 case Instruction::Add: {
3707 case Instruction::Mul: {
3713 case Instruction::Select: {
3720 auto SelectArmIsNonZero = [&](
bool IsTrueArm) {
3722 Op = IsTrueArm ?
I->getOperand(1) :
I->getOperand(2);
3740 if (SelectArmIsNonZero(
true) &&
3741 SelectArmIsNonZero(
false))
3745 case Instruction::PHI: {
3756 RecQ.CtxI = PN->getIncomingBlock(U)->getTerminator();
3760 BasicBlock *TrueSucc, *FalseSucc;
3761 if (match(RecQ.CtxI,
3762 m_Br(m_c_ICmp(Pred, m_Specific(U.get()), m_Value(X)),
3763 m_BasicBlock(TrueSucc), m_BasicBlock(FalseSucc)))) {
3765 if ((TrueSucc == PN->getParent()) != (FalseSucc == PN->getParent())) {
3767 if (FalseSucc == PN->getParent())
3768 Pred = CmpInst::getInversePredicate(Pred);
3769 if (cmpExcludesZero(Pred, X))
3777 case Instruction::InsertElement: {
3781 const Value *Vec =
I->getOperand(0);
3782 const Value *Elt =
I->getOperand(1);
3786 APInt DemandedVecElts = DemandedElts;
3787 bool SkipElt =
false;
3789 if (CIdx && CIdx->getValue().ult(NumElts)) {
3790 DemandedVecElts.
clearBit(CIdx->getZExtValue());
3791 SkipElt = !DemandedElts[CIdx->getZExtValue()];
3797 (DemandedVecElts.
isZero() ||
3800 case Instruction::ExtractElement:
3802 const Value *Vec = EEI->getVectorOperand();
3803 const Value *Idx = EEI->getIndexOperand();
3806 unsigned NumElts = VecTy->getNumElements();
3808 if (CIdx && CIdx->getValue().ult(NumElts))
3814 case Instruction::ShuffleVector: {
3818 APInt DemandedLHS, DemandedRHS;
3824 return (DemandedRHS.
isZero() ||
3829 case Instruction::Freeze:
3833 case Instruction::Load: {
3850 case Instruction::ExtractValue: {
3856 case Instruction::Add:
3861 case Instruction::Sub:
3864 case Instruction::Mul:
3867 false,
false,
Depth);
3873 case Instruction::Call:
3874 case Instruction::Invoke: {
3876 if (
I->getType()->isPointerTy()) {
3877 if (
Call->isReturnNonNull())
3885 if (std::optional<ConstantRange>
Range =
Call->getRange()) {
3886 const APInt ZeroValue(
Range->getBitWidth(), 0);
3887 if (!
Range->contains(ZeroValue))
3890 if (
const Value *RV =
Call->getReturnedArgOperand())
3896 switch (
II->getIntrinsicID()) {
3897 case Intrinsic::sshl_sat:
3898 case Intrinsic::ushl_sat:
3899 case Intrinsic::abs:
3900 case Intrinsic::bitreverse:
3901 case Intrinsic::bswap:
3902 case Intrinsic::ctpop:
3906 case Intrinsic::ssub_sat:
3914 case Intrinsic::sadd_sat:
3916 II->getArgOperand(1),
3917 true,
false,
Depth);
3919 case Intrinsic::vector_reverse:
3923 case Intrinsic::vector_reduce_or:
3924 case Intrinsic::vector_reduce_umax:
3925 case Intrinsic::vector_reduce_umin:
3926 case Intrinsic::vector_reduce_smax:
3927 case Intrinsic::vector_reduce_smin:
3929 case Intrinsic::umax:
3930 case Intrinsic::uadd_sat:
3938 case Intrinsic::smax: {
3941 auto IsNonZero = [&](
Value *
Op, std::optional<bool> &OpNonZero,
3943 if (!OpNonZero.has_value())
3944 OpNonZero = OpKnown.isNonZero() ||
3949 std::optional<bool> Op0NonZero, Op1NonZero;
3953 IsNonZero(
II->getArgOperand(1), Op1NonZero, Op1Known))
3958 IsNonZero(
II->getArgOperand(0), Op0NonZero, Op0Known))
3960 return IsNonZero(
II->getArgOperand(1), Op1NonZero, Op1Known) &&
3961 IsNonZero(
II->getArgOperand(0), Op0NonZero, Op0Known);
3963 case Intrinsic::smin: {
3979 case Intrinsic::umin:
3982 case Intrinsic::cttz:
3985 case Intrinsic::ctlz:
3988 case Intrinsic::fshr:
3989 case Intrinsic::fshl:
3991 if (
II->getArgOperand(0) ==
II->getArgOperand(1))
3994 case Intrinsic::vscale:
3996 case Intrinsic::experimental_get_vector_length:
4010 return Known.One != 0;
4021 Type *Ty =
V->getType();
4028 FVTy->getNumElements() == DemandedElts.
getBitWidth() &&
4029 "DemandedElt width should equal the fixed vector number of elements");
4032 "DemandedElt width should be 1 for scalars");
4037 if (
C->isNullValue())
4046 for (
unsigned i = 0, e = VecTy->getNumElements(); i != e; ++i) {
4047 if (!DemandedElts[i])
4049 Constant *Elt =
C->getAggregateElement(i);
4070 !GV->isAbsoluteSymbolRef() && !GV->hasExternalWeakLinkage() &&
4081 if (std::optional<ConstantRange>
Range =
A->getRange()) {
4082 const APInt ZeroValue(
Range->getBitWidth(), 0);
4083 if (!
Range->contains(ZeroValue))
4100 if (((
A->hasPassPointeeByValueCopyAttr() &&
4102 A->hasNonNullAttr()))
4124 APInt DemandedElts =
4126 return ::isKnownNonZero(V, DemandedElts, Q,
Depth);
4135static std::optional<std::pair<Value*, Value*>>
4139 return std::nullopt;
4141 auto getOperands = [&](
unsigned OpNum) ->
auto {
4148 case Instruction::Or:
4153 case Instruction::Xor:
4154 case Instruction::Add: {
4162 case Instruction::Sub:
4164 return getOperands(1);
4166 return getOperands(0);
4168 case Instruction::Mul: {
4174 if ((!OBO1->hasNoUnsignedWrap() || !OBO2->hasNoUnsignedWrap()) &&
4175 (!OBO1->hasNoSignedWrap() || !OBO2->hasNoSignedWrap()))
4182 return getOperands(0);
4185 case Instruction::Shl: {
4190 if ((!OBO1->hasNoUnsignedWrap() || !OBO2->hasNoUnsignedWrap()) &&
4191 (!OBO1->hasNoSignedWrap() || !OBO2->hasNoSignedWrap()))
4195 return getOperands(0);
4198 case Instruction::AShr:
4199 case Instruction::LShr: {
4202 if (!PEO1->isExact() || !PEO2->isExact())
4206 return getOperands(0);
4209 case Instruction::SExt:
4210 case Instruction::ZExt:
4212 return getOperands(0);
4214 case Instruction::PHI: {
4222 Value *Start1 =
nullptr, *Step1 =
nullptr;
4224 Value *Start2 =
nullptr, *Step2 =
nullptr;
4243 return std::make_pair(Start1, Start2);
4246 return std::nullopt;
4253 const APInt &DemandedElts,
4261 case Instruction::Or:
4265 case Instruction::Xor:
4266 case Instruction::Add:
4287 (OBO->hasNoUnsignedWrap() || OBO->hasNoSignedWrap()) &&
4288 !
C->isZero() && !
C->isOne() &&
4302 (OBO->hasNoUnsignedWrap() || OBO->hasNoSignedWrap()) &&
4316 bool UsedFullRecursion =
false;
4318 if (!VisitedBBs.
insert(IncomBB).second)
4327 if (UsedFullRecursion)
4331 RecQ.
CtxI = IncomBB->getTerminator();
4334 UsedFullRecursion =
true;
4348 const Value *Cond2 = SI2->getCondition();
4351 DemandedElts, Q,
Depth + 1) &&
4353 DemandedElts, Q,
Depth + 1);
4366 if (!
A->getType()->isPointerTy() || !
B->getType()->isPointerTy())
4370 if (!GEPA || GEPA->getNumIndices() != 1 || !
isa<Constant>(GEPA->idx_begin()))
4375 if (!PN || PN->getNumIncomingValues() != 2)
4380 Value *Start =
nullptr;
4382 if (PN->getIncomingValue(0) == Step)
4383 Start = PN->getIncomingValue(1);
4384 else if (PN->getIncomingValue(1) == Step)
4385 Start = PN->getIncomingValue(0);
4396 APInt StartOffset(IndexWidth, 0);
4397 Start = Start->stripAndAccumulateInBoundsConstantOffsets(Q.
DL, StartOffset);
4398 APInt StepOffset(IndexWidth, 0);
4404 APInt OffsetB(IndexWidth, 0);
4405 B =
B->stripAndAccumulateInBoundsConstantOffsets(Q.
DL, OffsetB);
4406 return Start ==
B &&
4418 auto IsKnownNonEqualFromDominatingCondition = [&](
const Value *
V) {
4439 if (IsKnownNonEqualFromDominatingCondition(
V1) ||
4440 IsKnownNonEqualFromDominatingCondition(V2))
4454 "Got assumption for the wrong function!");
4455 assert(
I->getIntrinsicID() == Intrinsic::assume &&
4456 "must be an assume intrinsic");
4479 std::optional<bool> Implied =
4481 return Implied && *Implied;
4502 if (
O1 &&
O2 &&
O1->getOpcode() ==
O2->getOpcode()) {
4528 if (
V1->getType()->isIntOrIntVectorTy()) {
4569 const APInt &DemandedElts,
4575 unsigned MinSignBits = TyBits;
4577 for (
unsigned i = 0; i != NumElts; ++i) {
4578 if (!DemandedElts[i])
4585 MinSignBits = std::min(MinSignBits, Elt->getValue().getNumSignBits());
4592 const APInt &DemandedElts,
4598 assert(Result > 0 &&
"At least one sign bit needs to be present!");
4610 const APInt &DemandedElts,
4612 Type *Ty =
V->getType();
4618 FVTy->getNumElements() == DemandedElts.
getBitWidth() &&
4619 "DemandedElt width should equal the fixed vector number of elements");
4622 "DemandedElt width should be 1 for scalars");
4636 unsigned FirstAnswer = 1;
4647 case Instruction::BitCast: {
4648 Value *Src = U->getOperand(0);
4649 Type *SrcTy = Src->getType();
4653 if (!SrcTy->isIntOrIntVectorTy())
4659 if ((SrcBits % TyBits) != 0)
4672 case Instruction::SExt:
4673 Tmp = TyBits - U->getOperand(0)->getType()->getScalarSizeInBits();
4677 case Instruction::SDiv: {
4678 const APInt *Denominator;
4691 return std::min(TyBits, NumBits + Denominator->
logBase2());
4696 case Instruction::SRem: {
4699 const APInt *Denominator;
4720 unsigned ResBits = TyBits - Denominator->
ceilLogBase2();
4721 Tmp = std::max(Tmp, ResBits);
4727 case Instruction::AShr: {
4732 if (ShAmt->
uge(TyBits))
4735 Tmp += ShAmtLimited;
4736 if (Tmp > TyBits) Tmp = TyBits;
4740 case Instruction::Shl: {
4745 if (ShAmt->
uge(TyBits))
4750 ShAmt->
uge(TyBits -
X->getType()->getScalarSizeInBits())) {
4752 Tmp += TyBits -
X->getType()->getScalarSizeInBits();
4756 if (ShAmt->
uge(Tmp))
4763 case Instruction::And:
4764 case Instruction::Or:
4765 case Instruction::Xor:
4770 FirstAnswer = std::min(Tmp, Tmp2);
4777 case Instruction::Select: {
4781 const APInt *CLow, *CHigh;
4789 return std::min(Tmp, Tmp2);
4792 case Instruction::Add:
4796 if (Tmp == 1)
break;
4800 if (CRHS->isAllOnesValue()) {
4806 if ((
Known.Zero | 1).isAllOnes())
4811 if (
Known.isNonNegative())
4818 return std::min(Tmp, Tmp2) - 1;
4820 case Instruction::Sub:
4827 if (CLHS->isNullValue()) {
4832 if ((
Known.Zero | 1).isAllOnes())
4838 if (
Known.isNonNegative())
4849 return std::min(Tmp, Tmp2) - 1;
4851 case Instruction::Mul: {
4854 unsigned SignBitsOp0 =
4856 if (SignBitsOp0 == 1)
4858 unsigned SignBitsOp1 =
4860 if (SignBitsOp1 == 1)
4862 unsigned OutValidBits =
4863 (TyBits - SignBitsOp0 + 1) + (TyBits - SignBitsOp1 + 1);
4864 return OutValidBits > TyBits ? 1 : TyBits - OutValidBits + 1;
4867 case Instruction::PHI: {
4871 if (NumIncomingValues > 4)
break;
4873 if (NumIncomingValues == 0)
break;
4879 for (
unsigned i = 0, e = NumIncomingValues; i != e; ++i) {
4880 if (Tmp == 1)
return Tmp;
4883 DemandedElts, RecQ,
Depth + 1));
4888 case Instruction::Trunc: {
4893 unsigned OperandTyBits = U->getOperand(0)->getType()->getScalarSizeInBits();
4894 if (Tmp > (OperandTyBits - TyBits))
4895 return Tmp - (OperandTyBits - TyBits);
4900 case Instruction::ExtractElement:
4907 case Instruction::ShuffleVector: {
4915 APInt DemandedLHS, DemandedRHS;
4920 Tmp = std::numeric_limits<unsigned>::max();
4921 if (!!DemandedLHS) {
4922 const Value *
LHS = Shuf->getOperand(0);
4929 if (!!DemandedRHS) {
4930 const Value *
RHS = Shuf->getOperand(1);
4932 Tmp = std::min(Tmp, Tmp2);
4938 assert(Tmp <= TyBits &&
"Failed to determine minimum sign bits");
4941 case Instruction::Call: {
4943 switch (
II->getIntrinsicID()) {
4946 case Intrinsic::abs:
4954 case Intrinsic::smin:
4955 case Intrinsic::smax: {
4956 const APInt *CLow, *CHigh;
4971 if (
unsigned VecSignBits =
4980 return std::max(FirstAnswer,
Known.countMinSignBits());
4989 if (
F->isIntrinsic())
4990 return F->getIntrinsicID();
4998 LibFunc Func =
TLI->getLibFunc(CB);
4999 if (Func == NotLibFunc)
5008 return Intrinsic::sin;
5012 return Intrinsic::cos;
5016 return Intrinsic::tan;
5020 return Intrinsic::asin;
5024 return Intrinsic::acos;
5028 return Intrinsic::atan;
5030 case LibFunc_atan2f:
5031 case LibFunc_atan2l:
5032 return Intrinsic::atan2;
5036 return Intrinsic::sinh;
5040 return Intrinsic::cosh;
5044 return Intrinsic::tanh;
5048 return Intrinsic::exp;
5052 return Intrinsic::exp2;
5054 case LibFunc_exp10f:
5055 case LibFunc_exp10l:
5056 return Intrinsic::exp10;
5060 return Intrinsic::log;
5062 case LibFunc_log10f:
5063 case LibFunc_log10l:
5064 return Intrinsic::log10;
5068 return Intrinsic::log2;
5072 return Intrinsic::fabs;
5076 return Intrinsic::minnum;
5080 return Intrinsic::maxnum;
5081 case LibFunc_copysign:
5082 case LibFunc_copysignf:
5083 case LibFunc_copysignl:
5084 return Intrinsic::copysign;
5086 case LibFunc_floorf:
5087 case LibFunc_floorl:
5088 return Intrinsic::floor;
5092 return Intrinsic::ceil;
5094 case LibFunc_truncf:
5095 case LibFunc_truncl:
5096 return Intrinsic::trunc;
5100 return Intrinsic::rint;
5101 case LibFunc_nearbyint:
5102 case LibFunc_nearbyintf:
5103 case LibFunc_nearbyintl:
5104 return Intrinsic::nearbyint;
5106 case LibFunc_roundf:
5107 case LibFunc_roundl:
5108 return Intrinsic::round;
5109 case LibFunc_roundeven:
5110 case LibFunc_roundevenf:
5111 case LibFunc_roundevenl:
5112 return Intrinsic::roundeven;
5116 return Intrinsic::pow;
5120 return Intrinsic::sqrt;
5130 bool &TrueIfSigned) {
5133 TrueIfSigned =
true;
5134 return RHS.isZero();
5136 TrueIfSigned =
true;
5137 return RHS.isAllOnes();
5139 TrueIfSigned =
false;
5140 return RHS.isAllOnes();
5142 TrueIfSigned =
false;
5143 return RHS.isZero();
5146 TrueIfSigned =
true;
5147 return RHS.isMaxSignedValue();
5150 TrueIfSigned =
true;
5151 return RHS.isMinSignedValue();
5154 TrueIfSigned =
false;
5155 return RHS.isMinSignedValue();
5158 TrueIfSigned =
false;
5159 return RHS.isMaxSignedValue();
5169 unsigned Depth = 0) {
5195 KnownFromContext.
knownNot(~(CondIsTrue ? MaskIfTrue : MaskIfFalse));
5199 KnownFromContext.
knownNot(CondIsTrue ? ~Mask : Mask);
5205 if (TrueIfSigned == CondIsTrue)
5217static std::tuple<int, int, int>
5231 if (!
match(BI->getCondition(),
5246 bool KnownStrictlyLess =
5251 BI->getSuccessor(IsLessEqual ? 0 : 1));
5254 int Exp =
ilogb(*LimitC) + 1;
5265 MaxExpNonZero = std::min(MaxExpNonZero, Exp);
5266 MaxExp = std::min(MaxExp, std::max(Exp, 0));
5282 return KnownFromContext;
5302 return KnownFromContext;
5312 "Got assumption for the wrong function!");
5313 assert(
I->getIntrinsicID() == Intrinsic::assume &&
5314 "must be an assume intrinsic");
5320 true, Q.
CtxI, KnownFromContext);
5323 return KnownFromContext;
5327 Value *Arm,
bool Invert,
5333 !Invert, SQ.
CtxI, KnownSrc,
5351 APInt DemandedElts =
5357 const APInt &DemandedElts,
5362 if ((InterestedClasses &
5368 KnownSrc, Q,
Depth + 1);
5370 const fltSemantics &DstTy =
Op->getType()->getScalarType()->getFltSemantics();
5372 Op->getOperand(0)->getType()->getScalarType()->getFltSemantics();
5375 const Function *
F =
I ?
I->getFunction() :
nullptr;
5388 unsigned Depth,
bool IsAdd,
bool IsStrict) {
5401 bool WantNaN = (InterestedClasses &
fcNan) !=
fcNone;
5404 if (!WantNaN && !WantNegative && !WantNegZero)
5410 if (InterestedClasses &
fcNan)
5411 InterestedSrcs |=
fcInf;
5416 bool Self =
LHS ==
RHS &&
5419 KnownLHS = KnownRHS;
5428 Op->getType()->getScalarType()->getFltSemantics();
5432 if (Self && IsAdd) {
5450 const APInt &DemandedElts,
5461 if (InterestedClasses &
fcNan) {
5483 F ?
F->getDenormalMode(
Op->getType()->getScalarType()->getFltSemantics())
5488 FPClassTest InterestedSrcs = InterestedLHS | InterestedRHS;
5490 if (InterestedSrcs !=
fcNone)
5498 if (InterestedLHS !=
fcNone)
5513 case Intrinsic::minimum:
5515 case Intrinsic::maximum:
5517 case Intrinsic::minimumnum:
5519 case Intrinsic::maximumnum:
5521 case Intrinsic::minnum:
5523 case Intrinsic::maxnum:
5538 const Value *SubFloorX;
5550 assert(
Known.isUnknown() &&
"should not be called with known information");
5552 if (!DemandedElts) {
5582 unsigned NumElts = VFVTy->getNumElements();
5583 for (
unsigned i = 0; i != NumElts; ++i) {
5584 if (!DemandedElts[i])
5607 for (
size_t I = 0,
E = CDS->getNumElements();
I !=
E; ++
I)
5615 for (
const Use &
Op : CA->operands()) {
5630 KnownNotFromFlags |= CB->getRetNoFPClass();
5632 KnownNotFromFlags |= Arg->getNoFPClass();
5636 if (FPOp->hasNoNaNs())
5637 KnownNotFromFlags |=
fcNan;
5638 if (FPOp->hasNoInfs())
5639 KnownNotFromFlags |=
fcInf;
5643 KnownNotFromFlags |= ~AssumedClasses.getKnownFPClasses();
5647 InterestedClasses &= ~KnownNotFromFlags;
5650 Known.knownNot(KnownNotFromFlags);
5653 Known.signBitMustBeOne();
5655 Known.signBitMustBeZero();
5666 const unsigned Opc =
Op->getOpcode();
5668 case Instruction::FNeg: {
5674 case Instruction::Select: {
5675 auto ComputeForArm = [&](
Value *Arm,
bool Invert) {
5685 ComputeForArm(
Op->getOperand(1),
false)
5686 .intersectWith(ComputeForArm(
Op->getOperand(2),
true));
5689 case Instruction::Load: {
5690 const MDNode *NoFPClass =
5700 case Instruction::Call: {
5704 case Intrinsic::fabs: {
5715 case Intrinsic::copysign: {
5721 KnownSign, Q,
Depth + 1);
5722 Known.copysign(KnownSign);
5725 case Intrinsic::fma:
5726 case Intrinsic::fmuladd: {
5730 const bool IsFMA = IID == Intrinsic::fma;
5733 if (
II->getArgOperand(0) ==
II->getArgOperand(1)) {
5734 FPClassTest InterestedSquared = InterestedClasses;
5738 if (InterestedClasses &
fcQNan) {
5745 InterestedAddend, KnownAddend, Q,
Depth + 1);
5747 InterestedSquared, KnownSrc, Q,
Depth + 1);
5751 II->getType()->getScalarType()->getFltSemantics();
5772 for (
int I = 0;
I != 3; ++
I) {
5774 InterestedClasses, KnownSrc[
I], Q,
Depth + 1);
5775 if (KnownSrc[
I].isUnknown())
5786 II->getType()->getScalarType()->getFltSemantics();
5795 case Intrinsic::experimental_constrained_fadd:
5796 case Intrinsic::experimental_constrained_fsub: {
5799 IID == Intrinsic::experimental_constrained_fadd,
5803 case Intrinsic::experimental_constrained_frem: {
5808 case Intrinsic::sqrt:
5809 case Intrinsic::experimental_constrained_sqrt: {
5812 if (InterestedClasses &
fcQNan)
5815 if (InterestedClasses &
fcZero)
5819 KnownSrc, Q,
Depth + 1);
5827 II->getType()->getScalarType()->getFltSemantics();
5837 case Intrinsic::sin: {
5840 KnownSrc, Q,
Depth + 1);
5844 case Intrinsic::cos: {
5847 KnownSrc, Q,
Depth + 1);
5851 case Intrinsic::tan: {
5854 KnownSrc, Q,
Depth + 1);
5858 case Intrinsic::sinh: {
5861 KnownSrc, Q,
Depth + 1);
5865 case Intrinsic::cosh: {
5868 KnownSrc, Q,
Depth + 1);
5872 case Intrinsic::tanh: {
5875 KnownSrc, Q,
Depth + 1);
5879 case Intrinsic::asin: {
5882 KnownSrc, Q,
Depth + 1);
5886 case Intrinsic::acos: {
5889 KnownSrc, Q,
Depth + 1);
5893 case Intrinsic::atan: {
5896 KnownSrc, Q,
Depth + 1);
5900 case Intrinsic::atan2: {
5918 KnownY, Q,
Depth + 1);
5920 KnownX, Q,
Depth + 1);
5924 F ?
F->getDenormalMode(
5925 II->getType()->getScalarType()->getFltSemantics())
5930 case Intrinsic::maxnum:
5931 case Intrinsic::minnum:
5932 case Intrinsic::minimum:
5933 case Intrinsic::maximum:
5934 case Intrinsic::minimumnum:
5935 case Intrinsic::maximumnum: {
5938 KnownLHS, Q,
Depth + 1);
5940 KnownRHS, Q,
Depth + 1);
5945 F ?
F->getDenormalMode(
5946 II->getType()->getScalarType()->getFltSemantics())
5953 case Intrinsic::canonicalize: {
5956 KnownSrc, Q,
Depth + 1);
5960 F ?
F->getDenormalMode(
5961 II->getType()->getScalarType()->getFltSemantics())
5966 case Intrinsic::vector_reduce_fmax:
5967 case Intrinsic::vector_reduce_fmin:
5968 case Intrinsic::vector_reduce_fmaximum:
5969 case Intrinsic::vector_reduce_fminimum:
5970 case Intrinsic::vector_reduce_fmaximumnum:
5971 case Intrinsic::vector_reduce_fminimumnum: {
5975 InterestedClasses, Q,
Depth + 1);
5977 if (!
Known.isKnownNeverNaN())
5978 Known.setSignBit(std::nullopt);
5982 case Intrinsic::vector_reverse:
5985 II->getFastMathFlags(), InterestedClasses, Q,
Depth + 1);
5987 case Intrinsic::trunc:
5988 case Intrinsic::floor:
5989 case Intrinsic::ceil:
5990 case Intrinsic::rint:
5991 case Intrinsic::nearbyint:
5992 case Intrinsic::round:
5993 case Intrinsic::roundeven: {
6006 KnownSrc, Q,
Depth + 1);
6010 F ?
F->getDenormalMode(
6011 II->getType()->getScalarType()->getFltSemantics())
6013 const bool IsMultiUnitFPType =
6014 V->getType()->getScalarType()->isMultiUnitFPType();
6017 case Intrinsic::trunc:
6020 case Intrinsic::floor:
6023 case Intrinsic::ceil:
6033 case Intrinsic::exp:
6034 case Intrinsic::exp2:
6035 case Intrinsic::exp10:
6036 case Intrinsic::amdgcn_exp2: {
6039 KnownSrc, Q,
Depth + 1);
6043 Type *EltTy =
II->getType()->getScalarType();
6044 if (IID == Intrinsic::amdgcn_exp2 && EltTy->
isFloatTy())
6049 case Intrinsic::fptrunc_round: {
6054 case Intrinsic::log:
6055 case Intrinsic::log10:
6056 case Intrinsic::log2:
6057 case Intrinsic::experimental_constrained_log:
6058 case Intrinsic::experimental_constrained_log10:
6059 case Intrinsic::experimental_constrained_log2:
6060 case Intrinsic::amdgcn_log: {
6084 if (InterestedSrcs !=
fcNone)
6086 KnownSrc, Q,
Depth + 1);
6089 F ?
F->getDenormalMode(
6090 II->getType()->getScalarType()->getFltSemantics())
6092 const bool IsMultiUnitFPType =
6093 V->getType()->getScalarType()->isMultiUnitFPType();
6097 case Intrinsic::pow: {
6098 const bool WantNaN = (InterestedClasses &
fcNan) !=
fcNone;
6100 if (!WantNaN && !WantNegative)
6110 InterestedRHS |=
fcNan;
6121 KnownLHS, Q,
Depth + 1);
6130 KnownRHS, Q,
Depth + 1);
6134 case Intrinsic::powi: {
6139 const Value *Exp =
II->getArgOperand(1);
6140 unsigned BitWidth = Exp->getType()->getIntegerBitWidth();
6145 if (InterestedClasses &
fcNan)
6146 InterestedSrcs |=
fcNan;
6147 if (!ExponentKnownBits.
isZero()) {
6148 if (InterestedClasses &
fcInf)
6155 if (InterestedSrcs !=
fcNone)
6157 KnownSrc, Q,
Depth + 1);
6162 case Intrinsic::ldexp: {
6165 KnownSrc, Q,
Depth + 1);
6169 const Value *ExpArg =
II->getArgOperand(1);
6173 : ConstantRange::getFull(
6177 II->getType()->getScalarType()->getFltSemantics();
6187 case Intrinsic::arithmetic_fence: {
6192 case Intrinsic::experimental_constrained_sitofp:
6193 case Intrinsic::experimental_constrained_uitofp:
6203 if (IID == Intrinsic::experimental_constrained_uitofp)
6204 Known.signBitMustBeZero();
6209 case Intrinsic::amdgcn_fract: {
6212 if (InterestedClasses &
fcNan) {
6215 InterestedClasses, KnownSrc, Q,
Depth + 1);
6225 case Intrinsic::amdgcn_rcp: {
6228 KnownSrc, Q,
Depth + 1);
6230 Known.propagateNonNaN(KnownSrc);
6232 Type *EltTy =
II->getType()->getScalarType();
6255 case Intrinsic::amdgcn_rsq: {
6261 KnownSrc, Q,
Depth + 1);
6273 Type *EltTy =
II->getType()->getScalarType();
6293 case Intrinsic::amdgcn_trig_preop: {
6298 case Intrinsic::convert_from_arbitrary_fp: {
6308 II->getType()->getScalarType()->getFltSemantics();
6343 case Instruction::FAdd:
6344 case Instruction::FSub: {
6350 case Instruction::FMul: {
6353 F ?
F->getDenormalMode(
6354 Op->getType()->getScalarType()->getFltSemantics())
6397 case Instruction::FDiv: {
6398 const bool WantNan = (InterestedClasses &
fcNan) !=
fcNone;
6402 Op->getType()->getScalarType()->getFltSemantics();
6406 if (
Op->getOperand(0) ==
Op->getOperand(1) &&
6425 if (!WantNan && !WantNegative && !WantPositive)
6432 bool KnowSomethingUseful =
6437 if (KnowSomethingUseful)
6444 case Instruction::FRem: {
6449 case Instruction::FPExt: {
6452 KnownSrc, Q,
Depth + 1);
6455 Op->getType()->getScalarType()->getFltSemantics();
6457 Op->getOperand(0)->getType()->getScalarType()->getFltSemantics();
6460 const Function *
F =
I ?
I->getFunction() :
nullptr;
6469 case Instruction::FPTrunc: {
6474 case Instruction::SIToFP:
6475 case Instruction::UIToFP: {
6486 if (
Op->getOpcode() == Instruction::UIToFP)
6487 Known.signBitMustBeZero();
6500 if (
Op->getOpcode() == Instruction::SIToFP) {
6505 Known.signBitMustBeZero();
6507 Known.signBitMustBeOne();
6512 if (InterestedClasses &
fcInf) {
6517 if (
Op->getOpcode() == Instruction::UIToFP)
6519 else if (
Op->getOpcode() == Instruction::SIToFP)
6524 Type *FPTy =
Op->getType()->getScalarType();
6531 case Instruction::ExtractElement: {
6534 const Value *Vec =
Op->getOperand(0);
6536 APInt DemandedVecElts;
6538 unsigned NumElts = VecTy->getNumElements();
6541 if (CIdx && CIdx->getValue().ult(NumElts))
6544 DemandedVecElts =
APInt(1, 1);
6550 case Instruction::InsertElement: {
6554 const Value *Vec =
Op->getOperand(0);
6555 const Value *Elt =
Op->getOperand(1);
6558 APInt DemandedVecElts = DemandedElts;
6559 bool NeedsElt =
true;
6561 if (CIdx && CIdx->getValue().ult(NumElts)) {
6562 DemandedVecElts.
clearBit(CIdx->getZExtValue());
6563 NeedsElt = DemandedElts[CIdx->getZExtValue()];
6570 if (
Known.isUnknown())
6577 if (!DemandedVecElts.
isZero()) {
6586 case Instruction::ShuffleVector: {
6595 APInt DemandedLHS, DemandedRHS;
6600 if (!!DemandedLHS) {
6601 const Value *
LHS = Shuf->getOperand(0);
6606 if (
Known.isUnknown())
6612 if (!!DemandedRHS) {
6614 const Value *
RHS = Shuf->getOperand(1);
6622 case Instruction::ExtractValue: {
6629 switch (
II->getIntrinsicID()) {
6630 case Intrinsic::frexp: {
6650 InterestedSrcs, KnownSrc, Q,
Depth + 1);
6654 Op->getType()->getScalarType()->getFltSemantics();
6671 case Instruction::PHI: {
6674 if (
P->getNumIncomingValues() == 0)
6681 if (
Depth < PhiRecursionLimit) {
6688 for (
const Use &U :
P->operands()) {
6719 if (
P->getNumIncomingValues() != 2 ||
Known.cannotBeOrderedLessThanZero())
6721 for (
unsigned I = 0;
I < 2;
I++) {
6722 Value *RecurValue =
P->getIncomingValue(1 -
I);
6730 switch (
II->getIntrinsicID()) {
6731 case Intrinsic::fma:
6732 case Intrinsic::fmuladd: {
6746 case Instruction::BitCast: {
6749 !Src->getType()->isIntOrIntVectorTy())
6752 const Type *Ty =
Op->getType();
6754 Value *CastLHS, *CastRHS;
6766 Known = KnownLHS | KnownRHS;
6785 const APInt &DemandedElts,
6792 return KnownClasses;
6818 InterestedClasses &=
~fcNan;
6820 InterestedClasses &=
~fcInf;
6826 Result.setKnownFPClasses(Result.getKnownFPClasses() & ~
fcNan);
6828 Result.setKnownFPClasses(Result.getKnownFPClasses() & ~
fcInf);
6837 APInt DemandedElts =
6853 return Known.cannotBeOrderedLessThanZero();
6859 return Known.isKnownNeverInfinity();
6866 return Known.isKnownNeverNaN() &&
Known.isKnownNeverInfinity();
6875 return Known.isKnownNeverNaN();
6885 return Known.getSignBit();
6891 if (FPOp->hasNoSignedZeros())
6895 switch (
User->getOpcode()) {
6896 case Instruction::FPToSI:
6897 case Instruction::FPToUI:
6899 case Instruction::FRem:
6901 return U.getOperandNo() == 1;
6902 case Instruction::FCmp:
6905 case Instruction::Call:
6907 switch (
II->getIntrinsicID()) {
6908 case Intrinsic::fabs:
6909 case Intrinsic::exp:
6910 case Intrinsic::exp2:
6911 case Intrinsic::exp10:
6912 case Intrinsic::log:
6913 case Intrinsic::log2:
6914 case Intrinsic::log10:
6915 case Intrinsic::cos:
6916 case Intrinsic::acos:
6917 case Intrinsic::cosh:
6918 case Intrinsic::fptosi_sat:
6919 case Intrinsic::fptoui_sat:
6920 case Intrinsic::lround:
6921 case Intrinsic::llround:
6922 case Intrinsic::lrint:
6923 case Intrinsic::llrint:
6925 case Intrinsic::copysign:
6926 return U.getOperandNo() == 0;
6927 case Intrinsic::pow:
6929 return U.getOperandNo() == 1;
6930 case Intrinsic::is_fpclass: {
6950 if (FPOp->hasNoNaNs())
6954 switch (
User->getOpcode()) {
6955 case Instruction::FPToSI:
6956 case Instruction::FPToUI:
6959 case Instruction::FAdd:
6960 case Instruction::FSub:
6961 case Instruction::FMul:
6962 case Instruction::FDiv:
6963 case Instruction::FRem:
6964 case Instruction::FPTrunc:
6965 case Instruction::FPExt:
6966 case Instruction::FCmp:
6969 case Instruction::FNeg:
6970 case Instruction::Select:
6971 case Instruction::PHI:
6973 case Instruction::Ret:
6974 return User->getFunction()->getAttributes().getRetNoFPClass() &
6976 case Instruction::Call:
6977 case Instruction::Invoke: {
6979 switch (
II->getIntrinsicID()) {
6980 case Intrinsic::fabs:
6982 case Intrinsic::copysign:
6983 return U.getOperandNo() == 0;
6985 case Intrinsic::maxnum:
6986 case Intrinsic::minnum:
6987 case Intrinsic::maximum:
6988 case Intrinsic::minimum:
6989 case Intrinsic::maximumnum:
6990 case Intrinsic::minimumnum:
6991 case Intrinsic::canonicalize:
6992 case Intrinsic::fma:
6993 case Intrinsic::fmuladd:
6994 case Intrinsic::sqrt:
6995 case Intrinsic::pow:
6996 case Intrinsic::powi:
6997 case Intrinsic::fptoui_sat:
6998 case Intrinsic::fptosi_sat:
6999 case Intrinsic::is_fpclass:
7029 switch (
I->getOpcode()) {
7030 case Instruction::SIToFP:
7031 case Instruction::UIToFP:
7039 case Instruction::Call: {
7042 case Intrinsic::trunc:
7043 case Intrinsic::floor:
7044 case Intrinsic::ceil:
7045 case Intrinsic::rint:
7046 case Intrinsic::nearbyint:
7047 case Intrinsic::round:
7048 case Intrinsic::roundeven:
7066 if (V->getType()->isIntegerTy(8))
7077 if (
DL.getTypeStoreSize(V->getType()).isZero())
7092 if (
C->isNullValue())
7101 ConstantInt::get(Ctx, CFP->getValue().bitcastToAPInt()),
DL);
7109 if (CI->getBitWidth() % 8 == 0) {
7110 if (!CI->getValue().isSplat(8))
7112 return ConstantInt::get(Ctx, CI->getValue().trunc(8));
7117 if (CE->getOpcode() == Instruction::IntToPtr) {
7119 unsigned BitWidth =
DL.getPointerSizeInBits(PtrTy->getAddressSpace());
7132 if (LHS == UndefInt8)
7134 if (RHS == UndefInt8)
7140 Value *Val = UndefInt8;
7141 for (uint64_t
I = 0, E = CA->getNumElements();
I != E; ++
I)
7148 Value *Val = UndefInt8;
7183 while (PrevTo != OrigTo) {
7230 unsigned IdxSkip = Idxs.
size();
7243 std::optional<BasicBlock::iterator> InsertBefore) {
7246 if (idx_range.
empty())
7249 assert((V->getType()->isStructTy() || V->getType()->isArrayTy()) &&
7250 "Not looking at a struct or array?");
7252 "Invalid indices for type?");
7255 C =
C->getAggregateElement(idx_range[0]);
7256 if (!
C)
return nullptr;
7263 const unsigned *req_idx = idx_range.
begin();
7264 for (
const unsigned *i =
I->idx_begin(), *e =
I->idx_end();
7265 i != e; ++i, ++req_idx) {
7266 if (req_idx == idx_range.
end()) {
7296 ArrayRef(req_idx, idx_range.
end()), InsertBefore);
7305 unsigned size =
I->getNumIndices() + idx_range.
size();
7310 Idxs.
append(
I->idx_begin(),
I->idx_end());
7316 &&
"Number of indices added not correct?");
7332 unsigned ElementSize, uint64_t
Offset) {
7333 assert(V &&
"V should not be null.");
7334 assert((ElementSize % 8) == 0 &&
7335 "ElementSize expected to be a multiple of the size of a byte.");
7336 unsigned ElementSizeInBytes = ElementSize / 8;
7348 APInt Off(
DL.getIndexTypeSizeInBits(V->getType()), 0);
7355 uint64_t StartIdx =
Off.getLimitedValue();
7362 if ((StartIdx % ElementSizeInBytes) != 0)
7365 Offset += StartIdx / ElementSizeInBytes;
7371 uint64_t SizeInBytes =
DL.getTypeStoreSize(GVTy).getFixedValue();
7372 uint64_t
Length = SizeInBytes / ElementSizeInBytes;
7374 Slice.Array =
nullptr;
7386 Type *InitElTy = ArrayInit->getElementType();
7391 ArrayTy = ArrayInit->getType();
7396 if (ElementSize != 8)
7415 Slice.Array = Array;
7417 Slice.Length = NumElts -
Offset;
7431 if (Slice.Array ==
nullptr) {
7442 if (Slice.Length == 1) {
7454 Str = Str.
substr(Slice.Offset);
7460 Str = Str.substr(0, Str.find(
'\0'));
7473 unsigned CharSize) {
7475 V =
V->stripPointerCasts();
7480 if (!PHIs.
insert(PN).second)
7485 for (
Value *IncValue : PN->incoming_values()) {
7487 if (Len == 0)
return 0;
7489 if (Len == ~0ULL)
continue;
7491 if (Len != LenSoFar && LenSoFar != ~0ULL)
7503 if (Len1 == 0)
return 0;
7505 if (Len2 == 0)
return 0;
7506 if (Len1 == ~0ULL)
return Len2;
7507 if (Len2 == ~0ULL)
return Len1;
7508 if (Len1 != Len2)
return 0;
7517 if (Slice.Array ==
nullptr)
7525 unsigned NullIndex = 0;
7526 for (
unsigned E = Slice.Length; NullIndex <
E; ++NullIndex) {
7527 if (Slice.Array->getElementAsInteger(Slice.Offset + NullIndex) == 0)
7531 return NullIndex + 1;
7537 if (!V->getType()->isPointerTy())
7544 return Len == ~0ULL ? 1 : Len;
7549 bool MustPreserveOffset,
7550 bool MustPreserveProvenance) {
7552 "getArgumentAliasingToReturnedPointer only works on nonnull calls");
7553 if (
const Value *RV =
Call->getReturnedArgOperand())
7557 Call, MustPreserveOffset, MustPreserveProvenance))
7558 return Call->getArgOperand(0);
7564 bool MustPreserveProvenance) {
7565 switch (
Call->getIntrinsicID()) {
7566 case Intrinsic::launder_invariant_group:
7567 case Intrinsic::aarch64_irg:
7568 case Intrinsic::aarch64_tagp:
7578 case Intrinsic::amdgcn_make_buffer_rsrc:
7579 return !MustPreserveProvenance;
7580 case Intrinsic::ptrmask:
7581 return !MustPreserveOffset;
7582 case Intrinsic::threadlocal_address:
7585 return !
Call->getParent()->getParent()->isPresplitCoroutine();
7602 if (!PrevValue || LI->
getLoopFor(PrevValue->getParent()) != L)
7604 if (!PrevValue || LI->
getLoopFor(PrevValue->getParent()) != L)
7613 if (!L->isLoopInvariant(
Load->getPointerOperand()))
7619 bool MustPreserveProvenance) {
7620 for (
unsigned Count = 0; MaxLookup == 0 ||
Count < MaxLookup; ++
Count) {
7622 const Value *PtrOp =
GEP->getPointerOperand();
7633 if (GA->isInterposable())
7635 V = GA->getAliasee();
7639 if (
PHI->getNumIncomingValues() == 1) {
7640 V =
PHI->getIncomingValue(0);
7654 Call,
false, MustPreserveProvenance)) {
7662 assert(V->getType()->isPointerTy() &&
"Unexpected operand type!");
7669 const LoopInfo *LI,
unsigned MaxLookup) {
7677 if (!Visited.
insert(
P).second)
7706 }
while (!Worklist.
empty());
7710 bool MustPreserveProvenance) {
7711 const unsigned MaxVisited = 8;
7716 const Value *Object =
nullptr;
7720 const Value *FirstObject =
7726 MustPreserveProvenance);
7729 if (!Visited.
insert(
P).second)
7732 if (Visited.
size() == MaxVisited)
7748 else if (Object !=
P)
7750 }
while (!Worklist.
empty());
7752 return Object ? Object : FirstObject;
7762 if (U->getOpcode() == Instruction::PtrToInt)
7763 return U->getOperand(0);
7770 if (U->getOpcode() != Instruction::Add ||
7775 V = U->getOperand(0);
7779 assert(
V->getType()->isIntegerTy() &&
"Unexpected operand type!");
7790 bool AllObjectsIdentified =
true;
7797 for (
const Value *V : Objs) {
7798 if (!Visited.
insert(V).second)
7803 if (O->getType()->isPointerTy()) {
7811 }
while (!Working.
empty());
7812 return AllObjectsIdentified;
7820 auto AddWork = [&](
Value *V) {
7821 if (Visited.
insert(V).second)
7831 if (Result && Result != AI)
7835 AddWork(CI->getOperand(0));
7837 for (
Value *IncValue : PN->incoming_values())
7840 AddWork(
SI->getTrueValue());
7841 AddWork(
SI->getFalseValue());
7843 if (OffsetZero && !
GEP->hasAllZeroIndices())
7845 AddWork(
GEP->getPointerOperand());
7847 Value *Returned = CB->getReturnedArgOperand();
7855 }
while (!Worklist.
empty());
7864 return (!Shuffle || Shuffle->isSelect()) &&
7871 bool IgnoreUBImplyingAttrs) {
7873 AC, DT,
TLI, UseVariableInfo,
7874 IgnoreUBImplyingAttrs);
7880 bool UseVariableInfo,
bool IgnoreUBImplyingAttrs) {
7884 auto hasEqualReturnAndLeadingOperandTypes =
7885 [](
const Instruction *Inst,
unsigned NumLeadingOperands) {
7889 for (
unsigned ItOp = 0; ItOp < NumLeadingOperands; ++ItOp)
7895 hasEqualReturnAndLeadingOperandTypes(Inst, 2));
7897 hasEqualReturnAndLeadingOperandTypes(Inst, 1));
7904 case Instruction::UDiv:
7905 case Instruction::URem: {
7912 case Instruction::SDiv:
7913 case Instruction::SRem: {
7915 const APInt *Numerator, *Denominator;
7919 if (*Denominator == 0)
7931 case Instruction::Load: {
7932 if (!UseVariableInfo)
7945 case Instruction::Call: {
7949 const Function *Callee = CI->getCalledFunction();
7953 if (!Callee || !Callee->isSpeculatable())
7957 return IgnoreUBImplyingAttrs || !CI->hasUBImplyingAttrs();
7959 case Instruction::VAArg:
7960 case Instruction::Alloca:
7961 case Instruction::Invoke:
7962 case Instruction::CallBr:
7963 case Instruction::PHI:
7964 case Instruction::Store:
7965 case Instruction::Ret:
7966 case Instruction::UncondBr:
7967 case Instruction::CondBr:
7968 case Instruction::IndirectBr:
7969 case Instruction::Switch:
7970 case Instruction::Unreachable:
7971 case Instruction::Fence:
7972 case Instruction::AtomicRMW:
7973 case Instruction::AtomicCmpXchg:
7974 case Instruction::LandingPad:
7975 case Instruction::Resume:
7976 case Instruction::CatchSwitch:
7977 case Instruction::CatchPad:
7978 case Instruction::CatchRet:
7979 case Instruction::CleanupPad:
7980 case Instruction::CleanupRet:
7986 if (
I.mayReadOrWriteMemory())
8054 unsigned BitWidth = LHS->getType()->getScalarSizeInBits();
8099 if (
Add &&
Add->hasNoSignedWrap()) {
8138 bool LHSOrRHSKnownNonNegative =
8140 bool LHSOrRHSKnownNegative =
8142 if (LHSOrRHSKnownNonNegative || LHSOrRHSKnownNegative) {
8145 if ((AddKnown.
isNonNegative() && LHSOrRHSKnownNonNegative) ||
8146 (AddKnown.
isNegative() && LHSOrRHSKnownNegative))
8221 assert(EVI->getNumIndices() == 1 &&
"Obvious from CI's type");
8223 if (EVI->getIndices()[0] == 0)
8226 assert(EVI->getIndices()[0] == 1 &&
"Obvious from CI's type");
8228 for (
const auto *U : EVI->users())
8239 auto AllUsesGuardedByBranch = [&](
const CondBrInst *BI) {
8243 for (
const auto *Result :
Results) {
8246 if (DT.
dominates(NoWrapEdge, Result->getParent()))
8249 for (
const auto &RU : Result->uses())
8257 return llvm::any_of(GuardingBranches, AllUsesGuardedByBranch);
8269 unsigned NumElts = FVTy->getNumElements();
8270 for (
unsigned i = 0; i < NumElts; ++i)
8271 ShiftAmounts.
push_back(
C->getAggregateElement(i));
8279 return CI && CI->getValue().ult(
C->getType()->getIntegerBitWidth());
8286 bool ConsiderFlagsAndMetadata) {
8288 bool CBHasNoUndef = CB && CB->hasRetAttr(Attribute::NoUndef);
8290 Op->hasPoisonGeneratingAnnotations() && !CBHasNoUndef)
8293 unsigned Opcode =
Op->getOpcode();
8297 case Instruction::Shl:
8298 case Instruction::AShr:
8299 case Instruction::LShr:
8301 case Instruction::FPToSI:
8302 case Instruction::FPToUI:
8306 case Instruction::Call:
8308 switch (
II->getIntrinsicID()) {
8310 case Intrinsic::ctlz:
8311 case Intrinsic::cttz:
8312 case Intrinsic::abs:
8315 case Intrinsic::sshl_sat:
8316 case Intrinsic::ushl_sat:
8324 case Instruction::CallBr:
8325 case Instruction::Invoke: {
8326 return !CBHasNoUndef && !CB->hasFnAttr(Attribute::NoCreateUndefOrPoison);
8328 case Instruction::InsertElement:
8329 case Instruction::ExtractElement: {
8332 unsigned IdxOp =
Op->getOpcode() == Instruction::InsertElement ? 2 : 1;
8336 Idx->getValue().uge(VTy->getElementCount().getKnownMinValue());
8339 case Instruction::ShuffleVector: {
8345 case Instruction::FNeg:
8346 case Instruction::PHI:
8347 case Instruction::Select:
8348 case Instruction::ExtractValue:
8349 case Instruction::InsertValue:
8350 case Instruction::Freeze:
8351 case Instruction::ICmp:
8352 case Instruction::FCmp:
8353 case Instruction::GetElementPtr:
8355 case Instruction::AddrSpaceCast:
8370 bool ConsiderFlagsAndMetadata) {
8372 ConsiderFlagsAndMetadata);
8377 ConsiderFlagsAndMetadata);
8382 if (ValAssumedPoison ==
V)
8385 const unsigned MaxDepth = 2;
8386 if (
Depth >= MaxDepth)
8391 return propagatesPoison(Op) &&
8392 directlyImpliesPoison(ValAssumedPoison, Op, Depth + 1);
8416 const unsigned MaxDepth = 2;
8417 if (
Depth >= MaxDepth)
8423 return impliesPoison(Op, V, Depth + 1);
8430 return ::impliesPoison(ValAssumedPoison, V, 0);
8445 if (
A->hasAttribute(Attribute::NoUndef) ||
8446 A->hasAttribute(Attribute::Dereferenceable) ||
8447 A->hasAttribute(Attribute::DereferenceableOrNull))
8462 if (
C->getType()->isVectorTy() ||
C->getType()->isAggregateType()) {
8465 if (
Constant *SplatC =
C->getSplatValue())
8469 return all_of(CA->operands(), [&](
const Use &
Op) {
8470 return isGuaranteedNotToBeUndefOrPoison(Op.get(), AC, CtxI, DT,
8485 auto *StrippedV =
V->stripPointerCastsSameRepresentation();
8490 auto OpCheck = [&](
const Value *
V) {
8501 if (CB->hasRetAttr(Attribute::NoUndef) ||
8502 CB->hasRetAttr(Attribute::Dereferenceable) ||
8503 CB->hasRetAttr(Attribute::DereferenceableOrNull))
8510 unsigned Num = PN->getNumIncomingValues();
8511 bool IsWellDefined =
true;
8512 for (
unsigned i = 0; i < Num; ++i) {
8513 if (PN == PN->getIncomingValue(i))
8515 auto *TI = PN->getIncomingBlock(i)->getTerminator();
8517 DT,
Depth + 1, Kind)) {
8518 IsWellDefined =
false;
8529 }
else if (
all_of(Opr->operands(), OpCheck))
8535 if (
I->hasMetadata(LLVMContext::MD_noundef) ||
8536 I->hasMetadata(LLVMContext::MD_dereferenceable) ||
8537 I->hasMetadata(LLVMContext::MD_dereferenceable_or_null))
8557 auto *Dominator = DNode->
getIDom();
8562 auto *TI = Dominator->getBlock()->getTerminatorOrNull();
8566 Cond = BI->getCondition();
8568 Cond =
SI->getCondition();
8577 if (
any_of(Opr->operands(), [
V](
const Use &U) {
8578 return V == U && propagatesPoison(U);
8584 Dominator = Dominator->getIDom();
8597 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT,
Depth,
8604 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT,
Depth,
8611 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT,
Depth,
8635 while (!Worklist.
empty()) {
8644 if (
I != Root && !
any_of(
I->operands(), [&KnownPoison](
const Use &U) {
8645 return KnownPoison.contains(U) && propagatesPoison(U);
8649 if (KnownPoison.
insert(
I).second)
8661 return ::computeOverflowForSignedAdd(
Add->getOperand(0),
Add->getOperand(1),
8669 return ::computeOverflowForSignedAdd(LHS, RHS,
nullptr, SQ);
8701 return !
I->mayThrow() &&
I->willReturn();
8715 unsigned ScanLimit) {
8722 assert(ScanLimit &&
"scan limit must be non-zero");
8724 if (--ScanLimit == 0)
8738 if (
I->getParent() != L->getHeader())
return false;
8741 if (&LI ==
I)
return true;
8744 llvm_unreachable(
"Instruction not contained in its own parent basic block.");
8750 case Intrinsic::sadd_with_overflow:
8751 case Intrinsic::ssub_with_overflow:
8752 case Intrinsic::smul_with_overflow:
8753 case Intrinsic::uadd_with_overflow:
8754 case Intrinsic::usub_with_overflow:
8755 case Intrinsic::umul_with_overflow:
8760 case Intrinsic::ctpop:
8761 case Intrinsic::ctlz:
8762 case Intrinsic::cttz:
8763 case Intrinsic::abs:
8764 case Intrinsic::smax:
8765 case Intrinsic::smin:
8766 case Intrinsic::umax:
8767 case Intrinsic::umin:
8768 case Intrinsic::scmp:
8769 case Intrinsic::smulh:
8770 case Intrinsic::umulh:
8771 case Intrinsic::is_fpclass:
8772 case Intrinsic::ptrmask:
8773 case Intrinsic::ucmp:
8774 case Intrinsic::bitreverse:
8775 case Intrinsic::bswap:
8776 case Intrinsic::sadd_sat:
8777 case Intrinsic::ssub_sat:
8778 case Intrinsic::sshl_sat:
8779 case Intrinsic::uadd_sat:
8780 case Intrinsic::usub_sat:
8781 case Intrinsic::ushl_sat:
8782 case Intrinsic::smul_fix:
8783 case Intrinsic::smul_fix_sat:
8784 case Intrinsic::umul_fix:
8785 case Intrinsic::umul_fix_sat:
8786 case Intrinsic::pow:
8787 case Intrinsic::experimental_constrained_pow:
8788 case Intrinsic::powi:
8789 case Intrinsic::experimental_constrained_powi:
8790 case Intrinsic::sin:
8791 case Intrinsic::experimental_constrained_sin:
8792 case Intrinsic::sinh:
8793 case Intrinsic::experimental_constrained_sinh:
8794 case Intrinsic::cos:
8795 case Intrinsic::experimental_constrained_cos:
8796 case Intrinsic::cosh:
8797 case Intrinsic::experimental_constrained_cosh:
8798 case Intrinsic::sincos:
8799 case Intrinsic::sincospi:
8800 case Intrinsic::tan:
8801 case Intrinsic::experimental_constrained_tan:
8802 case Intrinsic::tanh:
8803 case Intrinsic::experimental_constrained_tanh:
8804 case Intrinsic::asin:
8805 case Intrinsic::experimental_constrained_asin:
8806 case Intrinsic::acos:
8807 case Intrinsic::experimental_constrained_acos:
8808 case Intrinsic::atan:
8809 case Intrinsic::experimental_constrained_atan:
8810 case Intrinsic::atan2:
8811 case Intrinsic::experimental_constrained_atan2:
8812 case Intrinsic::canonicalize:
8813 case Intrinsic::sqrt:
8814 case Intrinsic::experimental_constrained_sqrt:
8815 case Intrinsic::fma:
8816 case Intrinsic::experimental_constrained_fma:
8817 case Intrinsic::fmuladd:
8818 case Intrinsic::experimental_constrained_fmuladd:
8819 case Intrinsic::exp:
8820 case Intrinsic::experimental_constrained_exp:
8821 case Intrinsic::exp2:
8822 case Intrinsic::experimental_constrained_exp2:
8823 case Intrinsic::exp10:
8824 case Intrinsic::log:
8825 case Intrinsic::experimental_constrained_log:
8826 case Intrinsic::log2:
8827 case Intrinsic::experimental_constrained_log2:
8828 case Intrinsic::log10:
8829 case Intrinsic::experimental_constrained_log10:
8830 case Intrinsic::modf:
8831 case Intrinsic::floor:
8832 case Intrinsic::experimental_constrained_floor:
8833 case Intrinsic::ceil:
8834 case Intrinsic::experimental_constrained_ceil:
8835 case Intrinsic::trunc:
8836 case Intrinsic::experimental_constrained_trunc:
8837 case Intrinsic::rint:
8838 case Intrinsic::experimental_constrained_rint:
8839 case Intrinsic::nearbyint:
8840 case Intrinsic::experimental_constrained_nearbyint:
8841 case Intrinsic::round:
8842 case Intrinsic::experimental_constrained_round:
8843 case Intrinsic::roundeven:
8844 case Intrinsic::experimental_constrained_roundeven:
8845 case Intrinsic::lrint:
8846 case Intrinsic::experimental_constrained_lrint:
8847 case Intrinsic::llrint:
8848 case Intrinsic::experimental_constrained_llrint:
8849 case Intrinsic::lround:
8850 case Intrinsic::experimental_constrained_lround:
8851 case Intrinsic::llround:
8852 case Intrinsic::experimental_constrained_llround:
8853 case Intrinsic::fshl:
8854 case Intrinsic::fshr:
8855 case Intrinsic::frexp:
8856 case Intrinsic::ldexp:
8857 case Intrinsic::experimental_constrained_ldexp:
8858 case Intrinsic::get_active_lane_mask:
8859 case Intrinsic::mask_beforefirst:
8868 switch (
I->getOpcode()) {
8869 case Instruction::Freeze:
8870 case Instruction::PHI:
8871 case Instruction::Invoke:
8873 case Instruction::Select:
8875 case Instruction::Call:
8879 case Instruction::ICmp:
8880 case Instruction::FCmp:
8881 case Instruction::GetElementPtr:
8895template <
typename CallableT>
8897 const CallableT &Handle) {
8898 switch (
I->getOpcode()) {
8899 case Instruction::Store:
8904 case Instruction::Load:
8911 case Instruction::AtomicCmpXchg:
8916 case Instruction::AtomicRMW:
8921 case Instruction::Call:
8922 case Instruction::Invoke: {
8926 for (
unsigned i = 0; i < CB->
arg_size(); ++i)
8929 CB->
paramHasAttr(i, Attribute::DereferenceableOrNull)) &&
8934 case Instruction::Ret:
8935 if (
I->getFunction()->hasRetAttribute(Attribute::NoUndef) &&
8936 Handle(
I->getOperand(0)))
8939 case Instruction::Switch:
8943 case Instruction::CondBr:
8955template <
typename CallableT>
8957 const CallableT &Handle) {
8960 switch (
I->getOpcode()) {
8962 case Instruction::UDiv:
8963 case Instruction::SDiv:
8964 case Instruction::URem:
8965 case Instruction::SRem:
8966 return Handle(
I->getOperand(1));
8975 I, [&](
const Value *V) {
return KnownPoison.
count(V); });
8994 if (Arg->getParent()->isDeclaration())
8997 Begin = BB->
begin();
9004 unsigned ScanLimit = 32;
9013 if (--ScanLimit == 0)
9017 return WellDefinedOp ==
V;
9037 if (--ScanLimit == 0)
9045 for (
const Use &
Op :
I.operands()) {
9055 if (
I.getOpcode() == Instruction::Select &&
9056 YieldsPoison.
count(
I.getOperand(1)) &&
9057 YieldsPoison.
count(
I.getOperand(2))) {
9063 if (!BB || !Visited.
insert(BB).second)
9073 return ::programUndefinedIfUndefOrPoison(Inst,
false);
9077 return ::programUndefinedIfUndefOrPoison(Inst,
true);
9088 if (!
C->getElementType()->isFloatingPointTy())
9090 for (
unsigned I = 0,
E =
C->getNumElements();
I <
E; ++
I) {
9091 if (
C->getElementAsAPFloat(
I).isNaN())
9105 return !
C->isZero();
9108 if (!
C->getElementType()->isFloatingPointTy())
9110 for (
unsigned I = 0,
E =
C->getNumElements();
I <
E; ++
I) {
9111 if (
C->getElementAsAPFloat(
I).isZero())
9134 if (CmpRHS == FalseVal) {
9184 if (CmpRHS != TrueVal) {
9224 return ConstantInt::get(
V->getType(), ~(*
C));
9276 if ((CmpLHS == TrueVal &&
match(FalseVal,
m_APInt(C2))) ||
9296 assert(
X &&
Y &&
"Invalid operand");
9298 auto IsNegationOf = [&](
const Value *
X,
const Value *
Y) {
9303 if (NeedNSW && !BO->hasNoSignedWrap())
9307 if (!AllowPoison && !
Zero->isNullValue())
9314 if (IsNegationOf(
X,
Y) || IsNegationOf(
Y,
X))
9341 const APInt *RHSC1, *RHSC2;
9352 return CR1.inverse() == CR2;
9386std::optional<std::pair<CmpPredicate, Constant *>>
9389 "Only for relational integer predicates.");
9391 return std::nullopt;
9397 bool WillIncrement =
9402 auto ConstantIsOk = [Pred, WillIncrement, IsSigned](
ConstantInt *
C) {
9403 if (WillIncrement ?
C->isMaxValue(IsSigned) :
C->isMinValue(IsSigned))
9406 if (!Pred.hasSameSign())
9411 return WillIncrement ? !
C->isMaxValue(!IsSigned)
9412 : !
C->isMinValue(!IsSigned);
9415 Constant *SafeReplacementConstant =
nullptr;
9418 if (!ConstantIsOk(CI))
9419 return std::nullopt;
9421 unsigned NumElts = FVTy->getNumElements();
9422 for (
unsigned i = 0; i != NumElts; ++i) {
9423 Constant *Elt =
C->getAggregateElement(i);
9425 return std::nullopt;
9433 if (!CI || !ConstantIsOk(CI))
9434 return std::nullopt;
9436 if (!SafeReplacementConstant)
9437 SafeReplacementConstant = CI;
9441 Value *SplatC =
C->getSplatValue();
9444 if (!CI || !ConstantIsOk(CI))
9445 return std::nullopt;
9448 return std::nullopt;
9455 if (
C->containsUndefOrPoisonElement()) {
9456 assert(SafeReplacementConstant &&
"Replacement constant not set");
9461 Pred.hasSameSign());
9464 Constant *OneOrNegOne = ConstantInt::get(
Type, WillIncrement ? 1 : -1,
true);
9467 return std::make_pair(NewPred, NewC);
9480 Value *OutputZeroVal =
nullptr;
9483 OutputZeroVal = TrueVal;
9486 OutputZeroVal = FalseVal;
9488 if (OutputZeroVal) {
9490 CmpLHS = OutputZeroVal;
9492 CmpRHS = OutputZeroVal;
9511 bool Ordered =
false;
9522 if (LHSSafe && RHSSafe) {
9553 if (TrueVal == CmpRHS && FalseVal == CmpLHS) {
9564 if (TrueVal == CmpLHS && FalseVal == CmpRHS)
9573 auto MaybeSExtOrMulCmpLHS =
9578 if (
match(TrueVal, MaybeSExtOrMulCmpLHS)) {
9599 }
else if (
match(FalseVal, MaybeSExtOrMulCmpLHS)) {
9639 case Instruction::ZExt:
9643 case Instruction::SExt:
9647 case Instruction::Trunc:
9650 CmpConst->
getType() == SrcTy) {
9672 CastedTo = CmpConst;
9674 unsigned ExtOp = CmpI->
isSigned() ? Instruction::SExt : Instruction::ZExt;
9678 case Instruction::FPTrunc:
9681 case Instruction::FPExt:
9684 case Instruction::FPToUI:
9687 case Instruction::FPToSI:
9690 case Instruction::UIToFP:
9693 case Instruction::SIToFP:
9706 if (CastedBack && CastedBack !=
C)
9734 *CastOp = Cast1->getOpcode();
9735 Type *SrcTy = Cast1->getSrcTy();
9738 if (*CastOp == Cast2->getOpcode() && SrcTy == Cast2->getSrcTy())
9739 return Cast2->getOperand(0);
9747 Value *CastedTo =
nullptr;
9748 if (*CastOp == Instruction::Trunc) {
9762 "V2 and Cast1 should be the same type.");
9777 Value *TrueVal =
SI->getTrueValue();
9778 Value *FalseVal =
SI->getFalseValue();
9781 CmpI, TrueVal, FalseVal, LHS, RHS,
SI->getFastMathFlagsOrNone(), CastOp);
9798 if (CastOp && CmpLHS->
getType() != TrueVal->getType()) {
9802 if (*CastOp == Instruction::FPToSI || *CastOp == Instruction::FPToUI)
9804 return ::matchSelectPattern(Pred, FMF, CmpLHS, CmpRHS,
9811 if (*CastOp == Instruction::FPToSI || *CastOp == Instruction::FPToUI)
9813 return ::matchSelectPattern(Pred, FMF, CmpLHS, CmpRHS,
C,
9818 return ::matchSelectPattern(Pred, FMF, CmpLHS, CmpRHS, TrueVal, FalseVal, LHS,
9837 return Intrinsic::umin;
9839 return Intrinsic::umax;
9841 return Intrinsic::smin;
9843 return Intrinsic::smax;
9859 case Intrinsic::smax:
return Intrinsic::smin;
9860 case Intrinsic::smin:
return Intrinsic::smax;
9861 case Intrinsic::umax:
return Intrinsic::umin;
9862 case Intrinsic::umin:
return Intrinsic::umax;
9865 case Intrinsic::maximum:
return Intrinsic::minimum;
9866 case Intrinsic::minimum:
return Intrinsic::maximum;
9867 case Intrinsic::maxnum:
return Intrinsic::minnum;
9868 case Intrinsic::minnum:
return Intrinsic::maxnum;
9869 case Intrinsic::maximumnum:
9870 return Intrinsic::minimumnum;
9871 case Intrinsic::minimumnum:
9872 return Intrinsic::maximumnum;
9887std::pair<Intrinsic::ID, bool>
9892 bool AllCmpSingleUse =
true;
9895 if (
all_of(VL, [&SelectPattern, &AllCmpSingleUse](
Value *
I) {
9901 SelectPattern.
Flavor != CurrentPattern.Flavor)
9903 SelectPattern = CurrentPattern;
9908 switch (SelectPattern.
Flavor) {
9910 return {Intrinsic::smin, AllCmpSingleUse};
9912 return {Intrinsic::umin, AllCmpSingleUse};
9914 return {Intrinsic::smax, AllCmpSingleUse};
9916 return {Intrinsic::umax, AllCmpSingleUse};
9918 return {Intrinsic::maxnum, AllCmpSingleUse};
9920 return {Intrinsic::minnum, AllCmpSingleUse};
9928template <
typename InstTy>
9938 for (
unsigned I = 0;
I != 2; ++
I) {
9943 if (
LHS != PN &&
RHS != PN)
9955template <
typename InstTy>
9962 for (
unsigned I = 0;
I != 2; ++
I) {
9969 if (Op0 != PN && Op1 != PN && Op2 != PN)
9977 }
else if (Op1 == PN) {
10011 if (
I->arg_size() != 2 ||
I->getType() !=
I->getArgOperand(0)->getType() ||
10012 I->getType() !=
I->getArgOperand(1)->getType())
10026 Value *&OtherOp1) {
10027 if (
I->arg_size() != 3 ||
I->getType() !=
I->getArgOperand(0)->getType() ||
10028 I->getType() !=
I->getArgOperand(1)->getType() ||
10029 I->getType() !=
I->getArgOperand(2)->getType())
10059 return !
C->isNegative();
10071 const APInt *CLHS, *CRHS;
10074 return CLHS->
sle(*CRHS);
10112 const APInt *CLHS, *CRHS;
10115 return CLHS->
ule(*CRHS);
10124static std::optional<bool>
10129 return std::nullopt;
10136 return std::nullopt;
10143 return std::nullopt;
10150 return std::nullopt;
10157 return std::nullopt;
10164static std::optional<bool>
10177 return std::nullopt;
10190 return std::nullopt;
10196static std::optional<bool>
10227 const APInt *Unused;
10246 return std::nullopt;
10250 if (L0 == R0 && L1 == R1)
10281 ((
A == R0 &&
B == R1) || (
A == R1 &&
B == R0) ||
10301 const APInt *LC, *RC, *MaskC;
10313 return std::nullopt;
10319static std::optional<bool>
10349 if (L0 == R0 && L1 == R1) {
10350 if ((LPred & RPred) == LPred)
10352 if ((LPred & ~RPred) == LPred)
10360 if (std::optional<ConstantFPRange> DomCR =
10362 if (std::optional<ConstantFPRange> ImpliedCR =
10364 if (ImpliedCR->contains(*DomCR))
10367 if (std::optional<ConstantFPRange> ImpliedCR =
10370 if (ImpliedCR->contains(*DomCR))
10376 return std::nullopt;
10383static std::optional<bool>
10388 assert((
LHS->getOpcode() == Instruction::And ||
10389 LHS->getOpcode() == Instruction::Or ||
10390 LHS->getOpcode() == Instruction::Select) &&
10391 "Expected LHS to be 'and', 'or', or 'select'.");
10398 const Value *ALHS, *ARHS;
10403 ALHS, RHSPred, RHSOp0, RHSOp1,
DL, LHSIsTrue,
Depth + 1))
10404 return Implication;
10406 ARHS, RHSPred, RHSOp0, RHSOp1,
DL, LHSIsTrue,
Depth + 1))
10407 return Implication;
10408 return std::nullopt;
10410 return std::nullopt;
10419 return std::nullopt;
10424 return std::nullopt;
10426 assert(LHS->getType()->isIntOrIntVectorTy(1) &&
10427 "Expected integer type only!");
10431 LHSIsTrue = !LHSIsTrue;
10436 Value *LHSOp0, *LHSOp1;
10439 RHSOp1,
DL, LHSIsTrue);
10442 "Expected floating point type only!");
10445 LHSCmp->getOperand(1), RHSPred, RHSOp0, RHSOp1,
10453 if ((LHSI->getOpcode() == Instruction::And ||
10454 LHSI->getOpcode() == Instruction::Or ||
10455 LHSI->getOpcode() == Instruction::Select))
10459 return std::nullopt;
10464 bool LHSIsTrue,
unsigned Depth) {
10470 bool InvertRHS =
false;
10478 Value *RHSOp0, *RHSOp1;
10482 return InvertRHS ? !*Implied : *Implied;
10483 return std::nullopt;
10487 LHS, RHSCmp->getPredicate(), RHSCmp->getOperand(0),
10488 RHSCmp->getOperand(1),
DL, LHSIsTrue,
Depth))
10489 return InvertRHS ? !*Implied : *Implied;
10490 return std::nullopt;
10494 return std::nullopt;
10498 const Value *RHS1, *RHS2;
10500 if (std::optional<bool> Imp =
10504 if (std::optional<bool> Imp =
10510 if (std::optional<bool> Imp =
10514 if (std::optional<bool> Imp =
10520 return std::nullopt;
10525static std::pair<Value *, bool>
10527 if (!ContextI || !ContextI->
getParent())
10528 return {
nullptr,
false};
10535 return {
nullptr,
false};
10541 return {
nullptr,
false};
10544 if (TrueBB == FalseBB)
10545 return {
nullptr,
false};
10547 assert((TrueBB == ContextBB || FalseBB == ContextBB) &&
10548 "Predecessor block does not point to successor?");
10551 return {PredCond, TrueBB == ContextBB};
10557 assert(
Cond->getType()->isIntOrIntVectorTy(1) &&
"Condition must be bool");
10559 if (PredCond.first)
10561 return std::nullopt;
10570 if (PredCond.first)
10573 return std::nullopt;
10578 bool PreferSignedRange) {
10579 unsigned Width =
Lower.getBitWidth();
10582 case Instruction::Sub:
10592 if (PreferSignedRange && HasNSW && HasNUW)
10598 }
else if (HasNSW) {
10599 if (
C->isNegative()) {
10612 case Instruction::Add:
10621 if (PreferSignedRange && HasNSW && HasNUW)
10627 }
else if (HasNSW) {
10628 if (
C->isNegative()) {
10641 case Instruction::And:
10652 case Instruction::Or:
10658 case Instruction::AShr:
10664 unsigned ShiftAmount = Width - 1;
10665 if (!
C->isZero() && IIQ.
isExact(&BO))
10666 ShiftAmount =
C->countr_zero();
10667 if (
C->isNegative()) {
10670 Upper =
C->ashr(ShiftAmount) + 1;
10673 Lower =
C->ashr(ShiftAmount);
10679 case Instruction::LShr:
10685 unsigned ShiftAmount = Width - 1;
10686 if (!
C->isZero() && IIQ.
isExact(&BO))
10687 ShiftAmount =
C->countr_zero();
10688 Lower =
C->lshr(ShiftAmount);
10693 case Instruction::Shl:
10700 if (
C->isNegative()) {
10702 unsigned ShiftAmount =
C->countl_one() - 1;
10703 Lower =
C->shl(ShiftAmount);
10707 unsigned ShiftAmount =
C->countl_zero() - 1;
10709 Upper =
C->shl(ShiftAmount) + 1;
10728 case Instruction::SDiv:
10732 if (
C->isAllOnes()) {
10735 Lower = IntMin + 1;
10736 Upper = IntMax + 1;
10737 }
else if (
C->countl_zero() < Width - 1) {
10748 if (
C->isMinSignedValue()) {
10760 case Instruction::UDiv:
10770 case Instruction::SRem:
10776 if (
C->isNegative()) {
10787 case Instruction::URem:
10802 bool UseInstrInfo) {
10803 unsigned Width =
II.getType()->getScalarSizeInBits();
10805 switch (
II.getIntrinsicID()) {
10806 case Intrinsic::ctlz:
10807 case Intrinsic::cttz: {
10809 if (!UseInstrInfo || !
match(
II.getArgOperand(1),
m_One()))
10814 case Intrinsic::ctpop:
10817 APInt(Width, Width) + 1);
10818 case Intrinsic::uadd_sat:
10824 case Intrinsic::sadd_sat:
10827 if (
C->isNegative())
10838 case Intrinsic::usub_sat:
10848 case Intrinsic::ssub_sat:
10850 if (
C->isNegative())
10860 if (
C->isNegative())
10871 case Intrinsic::ushl_sat:
10875 case Intrinsic::sshl_sat:
10877 if (
C->isNegative())
10884 case Intrinsic::umin:
10885 case Intrinsic::umax:
10886 case Intrinsic::smin:
10887 case Intrinsic::smax:
10892 switch (
II.getIntrinsicID()) {
10893 case Intrinsic::umin:
10895 case Intrinsic::umax:
10897 case Intrinsic::smin:
10900 case Intrinsic::smax:
10907 case Intrinsic::abs:
10916 case Intrinsic::vscale:
10917 if (!
II.getParent() || !
II.getFunction())
10920 case Intrinsic::read_register:
10921 case Intrinsic::read_volatile_register: {
10923 if (!M || !M->getTargetTriple().isRISCV())
10933 return ConstantRange::getFull(Width);
10938 unsigned BitWidth =
SI.getType()->getScalarSizeInBits();
10942 return ConstantRange::getFull(
BitWidth);
10965 return ConstantRange::getFull(
BitWidth);
10967 switch (R.Flavor) {
10979 return ConstantRange::getFull(
BitWidth);
10986 unsigned BitWidth =
I->getType()->getScalarSizeInBits();
10987 if (!
I->getOperand(0)->getType()->getScalarType()->isHalfTy())
11003 assert(V->getType()->isIntOrIntVectorTy() &&
"Expected integer instruction");
11006 return ConstantRange::getFull(V->getType()->getScalarSizeInBits());
11009 return C->toConstantRange();
11011 unsigned BitWidth = V->getType()->getScalarSizeInBits();
11047 if (std::optional<ConstantRange>
Range =
A->getRange())
11056 if (std::optional<ConstantRange>
Range = CB->getRange())
11079 auto [AdjustedMin, AdjustedMax, AdjustedMaxNonZero] =
11082 DenormalMode Mode =
I->getFunction()->getDenormalMode(FltSem);
11085 MinExp = std::max(AdjustedMin, MinExp);
11086 MaxExp = std::min(NeverLogicalZero ? AdjustedMaxNonZero : AdjustedMax,
11105 "Got assumption for the wrong function!");
11106 assert(
I->getIntrinsicID() == Intrinsic::assume &&
11107 "must be an assume intrinsic");
11110 auto OBU =
I->getOperandBundleAt(AssumeVH.Index);
11121 Value *Arg =
I->getArgOperand(0);
11124 if (!Cmp || Cmp->getOperand(0) != V)
11152 InsertAffected(
Op);
11159 auto AddAffected = [&InsertAffected](
Value *V) {
11163 auto AddCmpOperands = [&AddAffected, IsAssume](
Value *LHS,
Value *RHS) {
11174 while (!Worklist.
empty()) {
11176 if (!Visited.
insert(V).second)
11222 AddCmpOperands(
A,
B);
11258 auto AddNuwSquareOperand = [&AddAffected](
Value *
Op) {
11259 Value *SquareOp =
nullptr;
11261 AddAffected(SquareOp);
11263 AddNuwSquareOperand(
A);
11264 AddNuwSquareOperand(
B);
11269 AddCmpOperands(
A,
B);
11298 if (BO->getOpcode() == Instruction::Add ||
11299 BO->getOpcode() == Instruction::Or) {
11328 unsigned MaxCount,
bool AllowUndefOrPoison) {
11331 auto Push = [&](
const Value *V) ->
bool {
11337 if (Constants.contains(
C))
11339 if (Constants.size() == MaxCount)
11341 Constants.insert(
C);
11346 if (Visited.
insert(Inst).second)
11354 while (!Worklist.
empty()) {
11357 case Instruction::Select:
11363 case Instruction::PHI:
11366 if (IncomingValue == CurInst)
11368 if (!Push(IncomingValue))
const TargetLowering & TLI
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
AMDGPU Register Bank Select
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...
bpf unwind BPF Unwind Lower
static const Function * getParent(const Value *V)
static GCRegistry::Add< ShadowStackGC > C("shadow-stack", "Very portable GC for uncooperative code generators")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
This file contains the declarations for the subclasses of Constant, which represent the different fla...
Utilities for dealing with flags related to floating point properties and mode controls.
static Value * getCondition(Instruction *I)
static MaybeAlign getAlign(Value *Ptr)
Module.h This file contains the declarations for the Module class.
static bool hasNoUnsignedWrap(BinaryOperator &I)
ConstantRange Range(APInt(BitWidth, Low), APInt(BitWidth, High))
uint64_t IntrinsicInst * II
PowerPC Reduce CR logical Operation
SmallVector< MachineOperand, 4 > Cond
static cl::opt< RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode > Mode("regalloc-enable-advisor", cl::Hidden, cl::init(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Default), cl::desc("Enable regalloc advisor mode"), cl::values(clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Default, "default", "Default"), clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Release, "release", "precompiled"), clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Development, "development", "for training")))
std::pair< BasicBlock *, BasicBlock * > Edge
This file defines the scope_exit class, which executes user-defined cleanup logic at scope exit.
This file defines the SmallPtrSet class.
This file defines the SmallVector class.
static TableGen::Emitter::Opt Y("gen-skeleton-entry", EmitSkeleton, "Generate example skeleton entry")
This file contains the UndefPoisonKind enum and helper functions.
static bool isPowerOfTwoRecurrence(const PHINode *PN, bool OrZero, SimplifyQuery &Q, unsigned Depth)
Try to detect a recurrence that the value of the induction variable is always a power of two (or zero...
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 isTruePredicate(CmpInst::Predicate Pred, const Value *LHS, const Value *RHS)
Return true if "icmp Pred LHS RHS" is always true.
static bool isModifyingBinopOfNonZero(const Value *V1, const Value *V2, const APInt &DemandedElts, const SimplifyQuery &Q, unsigned Depth)
Return true if V1 == (binop V2, X), where X is known non-zero.
static bool isGEPKnownNonNull(const GEPOperator *GEP, const SimplifyQuery &Q, unsigned Depth)
Test whether a GEP's result is known to be non-null.
static bool isNonEqualShl(const Value *V1, const Value *V2, const APInt &DemandedElts, const SimplifyQuery &Q, unsigned Depth)
Return true if V2 == V1 << C, where V1 is known non-zero, C is not 0 and the shift is nuw or nsw.
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 isNonZeroMul(const APInt &DemandedElts, const SimplifyQuery &Q, unsigned BitWidth, Value *X, Value *Y, bool NSW, bool NUW, unsigned Depth)
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 KnownBits getKnownBitsFromAndXorOr(const Operator *I, const APInt &DemandedElts, const KnownBits &KnownLHS, const KnownBits &KnownRHS, const SimplifyQuery &Q, unsigned Depth)
static void breakSelfRecursivePHI(const Use *U, const PHINode *PHI, Value *&ValOut, Instruction *&CtxIOut, const PHINode **PhiOut=nullptr)
static bool isNonZeroSub(const APInt &DemandedElts, const SimplifyQuery &Q, unsigned BitWidth, Value *X, Value *Y, unsigned Depth)
static const Instruction * safeCtxI(const Value *V, const Instruction *CtxI)
static OverflowResult mapOverflowResult(ConstantRange::OverflowResult OR)
Convert ConstantRange OverflowResult into ValueTracking OverflowResult.
static void addValueAffectedByCondition(Value *V, function_ref< void(Value *)> InsertAffected)
static bool isNonZeroAddrPlusOffset(const SimplifyQuery &Q, Value *X, Value *Y)
Return true if "addr(P) + Off" cannot be zero.
static unsigned getBitWidth(Type *Ty, const DataLayout &DL)
Returns the bitwidth of the given scalar or pointer type.
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 constexpr unsigned MaxInstrsToCheckForFree
Maximum number of instructions to check between assume and context instruction.
static bool isNonZeroShift(const Operator *I, const APInt &DemandedElts, const SimplifyQuery &Q, const KnownBits &KnownVal, unsigned Depth)
static bool hasNoFreeInRange(BasicBlock::const_iterator Begin, BasicBlock::const_iterator End, unsigned &NumChecked)
static std::optional< bool > isImpliedCondFCmps(FCmpInst::Predicate LPred, const Value *L0, const Value *L1, FCmpInst::Predicate 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 ConstantRange getRISCVVLENBRange(const IntrinsicInst &II, unsigned Width)
Return the value range of a RISC-V vlenb CSR read.
static bool isKnownNonEqualFromContext(const Value *V1, const Value *V2, const SimplifyQuery &Q, unsigned Depth)
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 std::optional< bool > isImpliedCondICmps(CmpPredicate LPred, const Value *L0, const Value *L1, 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 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 SelectPatternResult matchMinMax(CmpInst::Predicate Pred, Value *CmpLHS, Value *CmpRHS, Value *TrueVal, Value *FalseVal, Value *&LHS, Value *&RHS)
Match non-obvious integer minimum and maximum sequences.
static ConstantRange getRangeForSelectPattern(const SelectInst &SI, const InstrInfoQuery &IIQ)
static void computeKnownBitsFromOperator(const Operator *I, const APInt &DemandedElts, KnownBits &Known, const SimplifyQuery &Q, 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 void computeKnownBitsFromShiftOperator(const Operator *I, const APInt &DemandedElts, KnownBits &Known, KnownBits &Known2, const SimplifyQuery &Q, unsigned Depth, 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 void computeKnownFPClassFromCond(const Value *V, Value *Cond, bool CondIsTrue, const Instruction *CtxI, KnownFPClass &KnownFromContext, unsigned Depth=0)
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 std::tuple< int, int, int > computeKnownExponentRangeFromContext(const Value *V, const SimplifyQuery &Q)
Compute the minimum and maximum values (inclusive) for the exponent of V, assuming it is not nan.
static bool isSignedMinMaxClamp(const Value *Select, const Value *&In, const APInt *&CLow, const APInt *&CHigh)
static bool isNonZeroAdd(const APInt &DemandedElts, const SimplifyQuery &Q, unsigned BitWidth, Value *X, Value *Y, bool NSW, bool NUW, unsigned Depth)
static bool directlyImpliesPoison(const Value *ValAssumedPoison, const Value *V, unsigned Depth)
static bool isNonEqualSelect(const Value *V1, const Value *V2, const APInt &DemandedElts, const SimplifyQuery &Q, unsigned Depth)
static bool matchTwoInputRecurrence(const PHINode *PN, InstTy *&Inst, Value *&Init, Value *&OtherOp)
static bool isNonEqualPHIs(const PHINode *PN1, const PHINode *PN2, const APInt &DemandedElts, const SimplifyQuery &Q, unsigned Depth)
static void computeKnownBitsFromCmp(const Value *V, CmpInst::Predicate Pred, Value *LHS, Value *RHS, KnownBits &Known, const SimplifyQuery &Q)
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 bool handleGuaranteedWellDefinedOps(const Instruction *I, const CallableT &Handle)
Enumerates all operands of I that are guaranteed to not be undef or poison.
static bool isAbsoluteValueULEOne(const Value *V)
static void computeKnownBitsFromLerpPattern(const Value *Op0, const Value *Op1, const APInt &DemandedElts, KnownBits &KnownOut, const SimplifyQuery &Q, unsigned Depth)
Try to detect the lerp pattern: a * (b - c) + c * d where a >= 0, b >= 0, c >= 0, d >= 0,...
static KnownFPClass computeKnownFPClassFromContext(const Value *V, const SimplifyQuery &Q)
static void computeKnownBitsAddSub(bool Add, const Value *Op0, const Value *Op1, bool NSW, bool NUW, const APInt &DemandedElts, KnownBits &KnownOut, KnownBits &Known2, const SimplifyQuery &Q, unsigned Depth)
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 constexpr KnownFPClass::MinMaxKind getMinMaxKind(Intrinsic::ID IID)
static bool isReadVLENB(const IntrinsicInst &II)
Return true if II reads a register named "vlenb".
static unsigned ComputeNumSignBitsImpl(const Value *V, const APInt &DemandedElts, const SimplifyQuery &Q, unsigned Depth)
Return the number of times the sign bit of the register is replicated into the other bits.
static void computeKnownBitsFromICmpCond(const Value *V, ICmpInst *Cmp, KnownBits &Known, const SimplifyQuery &SQ, bool Invert)
static void computeKnownBitsFromEuclideanRem(const Value *Op0, const Value *Op1, KnownBits &KnownOut, const SimplifyQuery &Q, unsigned Depth)
Infer non-negativity for R + (R < 0 ?
static bool isKnownNonZeroFromOperator(const Operator *I, const APInt &DemandedElts, const SimplifyQuery &Q, unsigned Depth)
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 SelectPatternResult matchClamp(CmpInst::Predicate Pred, Value *CmpLHS, Value *CmpRHS, Value *TrueVal, Value *FalseVal)
Recognize variations of: CLAMP(v,l,h) ==> ((v) < (l) ?
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 void computeKnownBitsForRecurrenceOperands(const PHINode *P, Value *Start, Value *Step, const APInt &DemandedElts, KnownBits &KnownStart, KnownBits &KnownStep, const SimplifyQuery &Q, unsigned Depth)
static void computeKnownFPClassForFAddSub(const Operator *Op, const APInt &DemandedElts, FPClassTest InterestedClasses, KnownFPClass &Known, const SimplifyQuery &Q, unsigned Depth, bool IsAdd, bool IsStrict)
static KnownBits computeKnownBitsForHorizontalOperation(const Operator *I, const APInt &DemandedElts, const SimplifyQuery &Q, unsigned Depth, const function_ref< KnownBits(const KnownBits &, const KnownBits &)> KnownBitsFunc)
static bool handleGuaranteedNonPoisonOps(const Instruction *I, const CallableT &Handle)
Enumerates all operands of I that are guaranteed to not be poison.
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 bool cmpExcludesZero(CmpInst::Predicate Pred, const Value *RHS)
static void computeKnownBitsFromCond(const Value *V, Value *Cond, KnownBits &Known, const SimplifyQuery &SQ, bool Invert, unsigned Depth)
static NoCommonBitsSetResult haveNoCommonBitsSetSpecialCases(const Value *LHS, const Value *RHS, const SimplifyQuery &SQ)
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 PredALHS ARHS" is true.
static bool isNonEqualMul(const Value *V1, const Value *V2, const APInt &DemandedElts, const SimplifyQuery &Q, unsigned Depth)
Return true if V2 == V1 * C, where V1 is known non-zero, C is not 0/1 and the multiplication is nuw o...
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 void computeKnownBitsMul(const Value *Op0, const Value *Op1, bool NSW, bool NUW, const APInt &DemandedElts, KnownBits &Known, KnownBits &Known2, const SimplifyQuery &Q, unsigned Depth)
static bool matchThreeInputRecurrence(const PHINode *PN, InstTy *&Inst, Value *&Init, Value *&OtherOp0, Value *&OtherOp1)
static bool isKnownNonNaN(const Value *V, FastMathFlags FMF)
static bool isNonEqualURem(const Value *X, const Value *Rem, const SimplifyQuery &Q)
static ConstantRange getRangeForIntrinsic(const IntrinsicInst &II, bool UseInstrInfo)
static void computeKnownFPClassForFPTrunc(const Operator *Op, const APInt &DemandedElts, FPClassTest InterestedClasses, KnownFPClass &Known, const SimplifyQuery &Q, unsigned Depth)
static void computeKnownFPClassForFRem(const Operator *Op, const APInt &DemandedElts, FPClassTest InterestedClasses, KnownFPClass &Known, const SimplifyQuery &Q, unsigned Depth)
static Value * BuildSubAggregate(Value *From, Value *To, Type *IndexedType, SmallVectorImpl< unsigned > &Idxs, unsigned IdxSkip, BasicBlock::iterator InsertBefore)
static LLVM_ABI bool semanticsHasInf(const fltSemantics &)
static LLVM_ABI ExponentType semanticsMinExponent(const fltSemantics &)
static LLVM_ABI bool semanticsHasSignedRepr(const fltSemantics &)
static LLVM_ABI ExponentType semanticsMaxExponent(const fltSemantics &)
static LLVM_ABI unsigned int semanticsPrecision(const fltSemantics &)
static LLVM_ABI bool semanticsHasNaN(const fltSemantics &)
static LLVM_ABI bool semanticsHasZero(const fltSemantics &)
static LLVM_ABI bool isRepresentableAsNormalIn(const fltSemantics &Src, const fltSemantics &Dst)
static LLVM_ABI bool isIEEELikeFP(const fltSemantics &)
static LLVM_ABI const fltSemantics * getArbitraryFPSemantics(StringRef Format)
Returns the fltSemantics for a given arbitrary FP format string, or nullptr if invalid.
LLVM_READONLY int getExactLog2Abs() const
static APFloat getLargest(const fltSemantics &Sem, bool Negative=false)
Returns the largest finite number in the given semantics.
Class for arbitrary precision integers.
LLVM_ABI APInt umul_ov(const APInt &RHS, bool &Overflow) const
LLVM_ABI 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.
unsigned popcount() const
Count the number of bits set.
void setBitsFrom(unsigned loBit)
Set the top bits starting from loBit.
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 isAllOnes() const
Determine if all bits are set. This is true for zero-width values.
bool isZero() const
Determine if this value is zero, i.e. all bits are clear.
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...
LLVM_ABI APInt sdiv(const APInt &RHS) const
Signed division function for APInt.
LLVM_ABI 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.
unsigned countl_zero() const
The APInt version of std::countl_zero.
static APInt getSignedMinValue(unsigned numBits)
Gets minimum signed value of APInt for a specific bit width.
LLVM_ABI 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.
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 isSubsetOf(const APInt &RHS) const
This operation checks that all bits set in this APInt are also set in RHS.
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.
APInt lshr(unsigned shiftAmt) const
Logical right-shift function.
bool uge(const APInt &RHS) const
Unsigned greater or equal comparison.
an instruction to allocate memory on the stack
This class represents an incoming formal argument to a Function.
Represent a constant reference to an array (0 or more elements consecutively in memory),...
size_t size() const
Get the array size.
bool empty() const
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.
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.
Functions, function parameters, and return types can have attributes to indicate how they should be t...
LLVM_ABI std::optional< unsigned > getVScaleRangeMax() const
Returns the maximum value for the vscale_range attribute or std::nullopt when unknown.
LLVM_ABI 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.
LLVM Basic Block Representation.
iterator begin()
Instruction iterator methods.
const Function * getParent() const
Return the enclosing method, or null if none.
LLVM_ABI 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
LLVM_ABI bool isEntryBlock() const
Return true if this is the entry block of the containing function.
LLVM_ABI const BasicBlock * getSinglePredecessor() const
Return the predecessor of this block if it has a single predecessor block.
LLVM_ABI const BasicBlock * getSingleSuccessor() const
Return the successor of this block if it has a single successor.
InstListType::iterator iterator
Instruction iterators...
const Instruction * getTerminator() const LLVM_READONLY
Returns the terminator instruction; assumes that the block is well-formed.
LLVM_ABI Instruction::BinaryOps getBinaryOp() const
Returns the binary operation underlying the intrinsic.
BinaryOps getOpcode() const
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...
LLVM_ABI bool paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const
Determine whether the argument or parameter has the given attribute.
LLVM_ABI 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
LLVM_ABI Intrinsic::ID getIntrinsicID() const
Returns the intrinsic ID of the intrinsic called or Intrinsic::not_intrinsic if the called function i...
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.
static LLVM_ABI Predicate getFlippedStrictnessPredicate(Predicate pred)
This is a static version that you can use without an instruction available.
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_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
@ 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 LLVM_ABI 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.
static bool isFPPredicate(Predicate P)
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 isIntPredicate(Predicate P)
static LLVM_ABI 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 LLVM_ABI std::optional< CmpPredicate > getMatching(CmpPredicate A, CmpPredicate B)
Compares two CmpPredicates taking samesign into account and returns the canonicalized CmpPredicate if...
LLVM_ABI CmpInst::Predicate getPreferredSignedPredicate() const
Attempts to return a signed CmpInst::Predicate from the CmpPredicate.
CmpInst::Predicate dropSameSign() const
Drops samesign information.
bool hasSameSign() const
Query samesign information, for optimizations.
Conditional Branch instruction.
An array constant whose element type is a simple 1/2/4/8-byte integer, bytes 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.
A vector constant whose element type is a simple 1/2/4/8-byte integer or float/double,...
static LLVM_ABI Constant * getAdd(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
static LLVM_ABI Constant * getTrunc(Constant *C, Type *Ty, bool OnlyIfReduced=false)
static LLVM_ABI std::optional< ConstantFPRange > makeExactFCmpRegion(FCmpInst::Predicate Pred, const APFloat &Other)
Produce the exact range such that all values in the returned range satisfy the given predicate with a...
ConstantFP - Floating Point Values [float, double].
This is the shared class of boolean and integer constants.
static LLVM_ABI ConstantInt * getTrue(LLVMContext &Context)
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...
static LLVM_ABI ConstantRange fromKnownBits(const KnownBits &Known, bool IsSigned)
Initialize a range based on a known bits constraint.
LLVM_ABI OverflowResult unsignedSubMayOverflow(const ConstantRange &Other) const
Return whether unsigned sub of the two ranges always/never overflows.
LLVM_ABI bool isAllNegative() const
Return true if all values in this range are negative.
LLVM_ABI OverflowResult unsignedAddMayOverflow(const ConstantRange &Other) const
Return whether unsigned add of the two ranges always/never overflows.
LLVM_ABI KnownBits toKnownBits() const
Return known bits for values in this range.
LLVM_ABI bool icmp(CmpInst::Predicate Pred, const ConstantRange &Other) const
Does the predicate Pred hold between ranges this and Other?
LLVM_ABI ConstantRange zeroExtend(uint32_t BitWidth) const
Return a new range in the specified integer type, which must be strictly larger than the current type...
LLVM_ABI APInt getSignedMin() const
Return the smallest signed value contained in the ConstantRange.
LLVM_ABI OverflowResult unsignedMulMayOverflow(const ConstantRange &Other) const
Return whether unsigned mul of the two ranges always/never overflows.
LLVM_ABI ConstantRange truncate(uint32_t BitWidth, unsigned NoWrapKind=0) const
Return a new range in the specified integer type, which must be strictly smaller than the current typ...
LLVM_ABI bool isAllNonNegative() const
Return true if all values in this range are non-negative.
LLVM_ABI ConstantRange signExtend(uint32_t BitWidth) const
Return a new range in the specified integer type, which must be strictly larger than the current type...
static LLVM_ABI 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...
LLVM_ABI ConstantRange multiply(const ConstantRange &Other, unsigned NoWrapKind=0) const
Return a new range representing the possible values resulting from a multiplication of a value in thi...
LLVM_ABI ConstantRange unionWith(const ConstantRange &CR, PreferredRangeType Type=Smallest) const
Return the range that results from the union of this range with another range.
static LLVM_ABI 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...
LLVM_ABI ConstantRange binaryAnd(const ConstantRange &Other) const
Return a new range representing the possible values resulting from a binary-and of a value in this ra...
LLVM_ABI bool contains(const APInt &Val) const
Return true if the specified value is in the set.
LLVM_ABI OverflowResult signedAddMayOverflow(const ConstantRange &Other) const
Return whether signed add of the two ranges always/never overflows.
LLVM_ABI APInt getUnsignedMax() const
Return the largest unsigned value contained in the ConstantRange.
LLVM_ABI ConstantRange intersectWith(const ConstantRange &CR, PreferredRangeType Type=Smallest) const
Return the range that results from the intersection of this range with another range.
LLVM_ABI APInt getSignedMax() const
Return the largest signed value contained in the ConstantRange.
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.
LLVM_ABI OverflowResult signedSubMayOverflow(const ConstantRange &Other) const
Return whether signed sub of the two ranges always/never overflows.
LLVM_ABI 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 LLVM_ABI Constant * replaceUndefsWith(Constant *C, Constant *Replacement)
Try to replace undefined constant C or undefined elements in C with Replacement.
LLVM_ABI Constant * getSplatValue(bool AllowPoison=false) const
If all elements of the vector constant have the same value, return that value.
bool isNullValue() const
Return true if this is the value that would be returned by getNullValue.
static LLVM_ABI Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
LLVM_ABI Constant * getAggregateElement(unsigned Elt) const
For aggregates (struct/array/vector) return the constant that corresponds to the specified element if...
A parsed version of the target data layout string in and methods for querying it.
bool isLittleEndian() const
Layout endianness...
unsigned getAddressSizeInBits(unsigned AS) const
The size in bits of an address in for the given AS.
LLVM_ABI const StructLayout * getStructLayout(StructType *Ty) const
Returns a StructLayout object, indicating the alignment of the struct, its size, and the offsets of i...
LLVM_ABI unsigned getIndexTypeSizeInBits(Type *Ty) const
The size in bits of the index used in GEP calculation for this type.
LLVM_ABI unsigned getPointerTypeSizeInBits(Type *) const
The pointer representation size in bits for this type.
TypeSize getTypeSizeInBits(Type *Ty) const
Size examples:
ArrayRef< CondBrInst * > 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.
LLVM_ABI bool dominates(const BasicBlock *BB, const Use &U) const
Return true if the (end of the) basic block BB dominates the use U.
This instruction compares its operands according to the predicate given to the constructor.
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)
void setNoNaNs(bool B=true)
const BasicBlock & getEntryBlock() const
an instruction for type-safe pointer arithmetic to access elements of arrays and structs
PointerType * getType() const
Global values are always pointers.
LLVM_ABI 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
CmpPredicate getInverseCmpPredicate() const
Predicate getFlippedSignednessPredicate() const
For example, SLT->ULT, ULT->SLT, SLE->ULE, ULE->SLE, EQ->EQ.
static bool isEquality(Predicate P)
Return true if this predicate is either EQ or NE.
static LLVM_ABI 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)
LLVM_ABI bool hasNoNaNs() const LLVM_READONLY
Determine whether the no-NaNs flag is set.
LLVM_ABI bool hasNoUnsignedWrap() const LLVM_READONLY
Determine whether the no unsigned wrap flag is set.
LLVM_ABI bool hasNoSignedWrap() const LLVM_READONLY
Determine whether the no signed wrap flag is set.
LLVM_ABI InstListType::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
LLVM_ABI bool isExact() const LLVM_READONLY
Determine whether the exact flag is set.
LLVM_ABI const Function * getFunction() const
Return the function this instruction belongs to.
LLVM_ABI bool comesBefore(const Instruction *Other) const
Given an instruction Other in the same basic block as this instruction, return true if this instructi...
iterator_range< user_iterator > users()
unsigned getOpcode() const
Returns a member of one of the enums like Instruction::Add.
LLVM_ABI const DataLayout & getDataLayout() const
Get the data layout of the module this instruction belongs to.
A wrapper class for inspecting calls to intrinsic functions.
bool isKnownNeverInfOrNaN() const
Return true if it's known this can never be an infinity or nan.
static LLVM_ABI KnownFPClass atan2(const KnownFPClass &LHS, const KnownFPClass &RHS, DenormalMode Mode)
Report known values for atan2.
static LLVM_ABI KnownFPClass fma(const KnownFPClass &LHS, const KnownFPClass &RHS, const KnownFPClass &Addend, DenormalMode Mode)
Report known values for fma.
static LLVM_ABI KnownFPClass sin(const KnownFPClass &Src)
Report known values for sin.
static constexpr FPClassTest OrderedLessThanZeroMask
static LLVM_ABI KnownFPClass trunc(const KnownFPClass &Src, DenormalMode Mode)
Propagate known class for trunc.
static LLVM_ABI KnownFPClass fadd(const KnownFPClass &LHS, const KnownFPClass &RHS, RoundingMode RM, DenormalMode Mode)
Report known values for fadd.
bool isKnownNeverSubnormal() const
Return true if it's known this can never be a subnormal.
static LLVM_ABI KnownFPClass fsub(const KnownFPClass &LHS, const KnownFPClass &RHS, RoundingMode RM, DenormalMode Mode)
Report known values for fsub.
static LLVM_ABI KnownFPClass fma_square(const KnownFPClass &Squared, const KnownFPClass &Addend, DenormalMode Mode)
Report known values for fma squared, squared, addend.
KnownFPClass unionWith(const KnownFPClass &RHS) const
static LLVM_ABI KnownFPClass fadd_self(const KnownFPClass &Src, RoundingMode RM, DenormalMode Mode)
Report known values for fadd x, x.
LLVM_ABI bool isKnownNeverLogicalZero(DenormalMode Mode) const
Return true if it's known this can never be interpreted as a zero.
static LLVM_ABI KnownFPClass frem(const KnownFPClass &LHS, const KnownFPClass &RHS, DenormalMode Mode)
Report known values for frem.
static LLVM_ABI KnownFPClass atan(const KnownFPClass &Src)
Report known values for atan.
static LLVM_ABI KnownFPClass ldexp(const KnownFPClass &Src, const APInt &ConstantRangeMin, const APInt &ConstantRangeMax, const fltSemantics &Flt, DenormalMode Mode)
Propagate known class for ldexp, assuming the exponent is known to be within [ConstantRangeMin,...
static LLVM_ABI KnownFPClass frexp_mant(const KnownFPClass &Src, DenormalMode Mode)
Propagate known class for mantissa component of frexp.
static LLVM_ABI KnownFPClass roundToIntegral(const KnownFPClass &Src, bool IsMultiUnitFPType, DenormalMode Mode)
Propagate known class for rounding intrinsics (rint, nearbyint, round, roundeven).
static LLVM_ABI KnownFPClass fmuladd(const KnownFPClass &LHS, const KnownFPClass &RHS, const KnownFPClass &Addend, DenormalMode Mode)
Report known values for fmuladd.
static LLVM_ABI KnownFPClass ceil(const KnownFPClass &Src, bool IsMultiUnitFPType, DenormalMode Mode)
Propagate known class for ceil.
static LLVM_ABI KnownFPClass fmuladd_square(const KnownFPClass &Squared, const KnownFPClass &Addend, DenormalMode Mode)
Report known values for fmuladd squared, squared, addend.
static LLVM_ABI KnownFPClass fpext(const KnownFPClass &KnownSrc, const fltSemantics &DstTy, const fltSemantics &SrcTy, DenormalMode DstMode, DenormalMode SrcMode)
Propagate known class for fpext.
static LLVM_ABI KnownFPClass cos(const KnownFPClass &Src)
Report known values for cos.
static LLVM_ABI KnownFPClass fptrunc(const KnownFPClass &KnownSrc, const fltSemantics &DstTy, const fltSemantics &SrcTy, DenormalMode DstMode, DenormalMode SrcMode)
Propagate known class for fptrunc and fptrunc_round.
static LLVM_ABI KnownFPClass cosh(const KnownFPClass &Src)
Report known values for cosh.
static LLVM_ABI KnownFPClass exp(const KnownFPClass &Src)
Report known values for exp, exp2 and exp10.
static LLVM_ABI KnownFPClass asin(const KnownFPClass &Src)
Report known values for asin.
bool isKnownNeverNaN() const
Return true if it's known this can never be a nan.
static LLVM_ABI KnownFPClass minMaxLike(const KnownFPClass &LHS, const KnownFPClass &RHS, MinMaxKind Kind, DenormalMode Mode)
void knownNot(FPClassMask RuleOut)
std::optional< bool > getSignBit() const
std::nullopt if the sign bit is unknown, true if the sign bit is definitely set or false if the sign ...
static LLVM_ABI KnownFPClass floor(const KnownFPClass &Src, bool IsMultiUnitFPType, DenormalMode Mode)
Propagate known class for floor.
FPClassTest getKnownFPClasses() const
Floating-point classes the value could be one of.
static KnownFPClass getEmpty()
static LLVM_ABI KnownFPClass tan(const KnownFPClass &Src)
Report known values for tan.
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.
static LLVM_ABI KnownFPClass fdiv_self(const KnownFPClass &Src, DenormalMode Mode)
Report known values for fdiv x, x.
void signBitMustBeZero()
Assume the sign bit is zero.
static LLVM_ABI KnownFPClass sqrt(const KnownFPClass &Src, DenormalMode Mode=DenormalMode::getDynamic())
Propagate known class for sqrt.
LLVM_ABI bool isKnownNeverLogicalPosZero(DenormalMode Mode) const
Return true if it's known this can never be interpreted as a positive zero.
bool isKnownNever(FPClassMask Mask) const
Return true if it's known this can never be one of the mask entries.
bool isKnownNeverPosInfinity() const
Return true if it's known this can never be +infinity.
LLVM_ABI bool isKnownNeverLogicalNegZero(DenormalMode Mode) const
Return true if it's known this can never be interpreted as a negative zero.
static LLVM_ABI KnownFPClass bitcast(const fltSemantics &FltSemantics, const KnownBits &Bits)
Report known values for a bitcast into a float with provided semantics.
static LLVM_ABI KnownFPClass square(const KnownFPClass &Src, DenormalMode Mode)
static LLVM_ABI KnownFPClass acos(const KnownFPClass &Src)
Report known values for acos.
static LLVM_ABI KnownFPClass log(const KnownFPClass &Src, DenormalMode Mode, bool IsMultiUnitFPType)
Propagate known class for log/log2/log10.
static LLVM_ABI KnownFPClass frem_self(const KnownFPClass &Src, DenormalMode Mode)
Report known values for frem x, x. Valid for all rounding modes.
static LLVM_ABI KnownFPClass powi(const KnownFPClass &Src, const KnownBits &N)
Propagate known class for powi.
static LLVM_ABI KnownFPClass fdiv(const KnownFPClass &LHS, const KnownFPClass &RHS, DenormalMode Mode)
Report known values for fdiv.
static LLVM_ABI KnownFPClass canonicalize(const KnownFPClass &Src, DenormalMode Mode)
Apply the canonicalize intrinsic to this value.
static LLVM_ABI KnownFPClass fmul(const KnownFPClass &LHS, const KnownFPClass &RHS, DenormalMode Mode)
Report known values for fmul.
static LLVM_ABI KnownFPClass pow(const KnownFPClass &LHS, const KnownFPClass &RHS)
Propagate known class for pow.
static LLVM_ABI KnownFPClass sinh(const KnownFPClass &Src)
Report known values for sinh.
static LLVM_ABI KnownFPClass tanh(const KnownFPClass &Src)
Report known values for tanh.
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.
const MDOperand & getOperand(unsigned I) const
A Module instance is used to store all the information related to an LLVM module.
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.
unsigned getAddressSpace() const
Return the address space of the Pointer type.
static LLVM_ABI PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
A udiv, sdiv, lshr, or ashr instruction, which can be marked as "exact", indicating that no bits are ...
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 LLVM_ABI 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.
bool contains(ConstPtrType Ptr) const
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
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.
Represent a constant reference to a string, i.e.
constexpr StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
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.
The instances of the Type class are immutable: once they are created, they are never changed.
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.
bool isFloatTy() const
Return true if this is 'float', a 32-bit IEEE fp type.
LLVM_ABI uint64_t getArrayNumElements() const
bool isSized() const
Return true if it makes sense to take the size of this type.
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type.
static LLVM_ABI IntegerType * getInt8Ty(LLVMContext &C)
Type * getScalarType() const
If this is a vector type, return the element type, otherwise return 'this'.
LLVM_ABI TypeSize getPrimitiveSizeInBits() const LLVM_READONLY
Return the basic size of this type if it is a primitive type.
bool isHalfTy() const
Return true if this is 'half', a 16-bit IEEE fp type.
bool isDoubleTy() const
Return true if this is 'double', a 64-bit IEEE fp type.
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.
bool isIntegerTy() const
True if this is an instance of IntegerType.
static LLVM_ABI IntegerType * getIntNTy(LLVMContext &C, unsigned N)
bool isFPOrFPVectorTy() const
Return true if this is a FP type or a vector of FP.
LLVM_ABI const fltSemantics & getFltSemantics() const
static LLVM_ABI 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.
LLVM_ABI unsigned getOperandNo() const
Return the operand # of this use in its User.
User * getUser() const
Returns the User that contains this Use.
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...
LLVM_ABI const Value * stripAndAccumulateConstantOffsets(const DataLayout &DL, APInt &Offset, bool AllowNonInbounds, bool AllowInvariantGroup=false, function_ref< bool(Value &Value, APInt &Offset)> ExternalAnalysis=nullptr, bool LookThroughIntToPtr=false) const
Accumulate the constant offset this value has compared to a base pointer.
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.
LLVM_ABI APInt ScaleBitMask(const APInt &A, unsigned NewBitWidth, bool MatchAllBits=false)
Splat/Merge neighboring bits to widen/narrow the bitmask represented by.
const APInt & umax(const APInt &A, const APInt &B)
Determine the larger of two APInts considered to be unsigned.
SpecificConstantMatch m_ZeroInt()
Convenience matchers for specific integer values.
BinaryOp_match< SpecificConstantMatch, SrcTy, TargetOpcode::G_SUB > m_Neg(const SrcTy &&Src)
Matches a register negated by a G_SUB.
AllOnesConstantMatch m_AllOnes()
BinaryOp_match< SrcTy, SpecificConstantMatch, TargetOpcode::G_XOR, true > m_Not(const SrcTy &&Src)
Matches a register not-ed by a G_XOR.
OneUse_match< SubPat > m_OneUse(const SubPat &SP)
match_combine_or< Ty... > m_CombineOr(const Ty &...Ps)
Combine pattern matchers matching any of Ps patterns.
cst_pred_ty< is_lowbit_mask > m_LowBitMask()
Match an integer or vector with only the low bit(s) set.
match_bind< PHINode > m_Phi(PHINode *&PN)
Match a PHI node, capturing it if we match.
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)
auto m_c_UMax(const LHS &L, const RHS &R)
Matches a UMax with LHS and RHS in either order.
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)
auto m_PtrToIntOrAddr(const OpTy &Op)
Matches PtrToInt or PtrToAddr.
BinaryOp_match< LHS, RHS, Instruction::FSub > m_FSub(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.
ap_match< APInt > m_APInt(const APInt *&Res)
Match a ConstantInt or splatted ConstantVector, binding the specified pointer to the contained APInt.
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)
CastOperator_match< OpTy, Instruction::PtrToAddr > m_PtrToAddr(const OpTy &Op)
Matches PtrToAddr.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Sub, OverflowingBinaryOperator::NoSignedWrap > m_NSWSub(const LHS &L, const RHS &R)
specific_intval< false > m_SpecificInt(const APInt &V)
Match a specific integer value or vector with all elements equal to the value.
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.
match_bind< Instruction > m_Instruction(Instruction *&I)
Match an instruction, capturing it if we match.
auto m_UMin(const Opnd0 &Op0, const Opnd1 &Op1)
match_deferred< 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()...
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.
ap_match< APFloat > m_APFloat(const APFloat *&Res)
Match a ConstantFP or splatted ConstantVector, binding the specified pointer to the contained APFloat...
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.
auto match_fn(const Pattern &P)
A match functor that can be used as a UnaryPredicate in functional algorithms like all_of.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap, true > m_c_NUWAdd(const LHS &L, const RHS &R)
cstfp_pred_ty< is_finite > m_Finite()
Match a finite FP constant, i.e.
cst_pred_ty< is_nonnegative > m_NonNegative()
Match an integer or vector of non-negative values.
auto m_SMax(const Opnd0 &Op0, const Opnd1 &Op1)
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.
auto m_UMax(const Opnd0 &Op0, const Opnd1 &Op1)
auto m_BasicBlock()
Match an arbitrary basic block value and ignore it.
ExtractValue_match< Ind, Val_t > m_ExtractValue(const Val_t &V)
Match a single index ExtractValue instruction.
ICmpLike_match< LHS, RHS > m_ICmpLike(CmpPredicate &Pred, const LHS &L, const RHS &R)
auto m_Value()
Match an arbitrary value and ignore it.
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.
auto m_Ctpop(const Opnd0 &Op0)
BinaryOp_match< LHS, RHS, Instruction::Mul > m_Mul(const LHS &L, const RHS &R)
auto m_Constant()
Match an arbitrary Constant and ignore it.
auto m_LogicalOr()
Matches L || R where L and R are arbitrary values.
cst_pred_ty< is_strictlypositive > m_StrictlyPositive()
Match an integer or vector of strictly positive values.
auto m_VScale()
Matches a call to llvm.vscale().
ThreeOps_match< decltype(m_Value()), LHS, RHS, Instruction::Select, true > m_c_Select(const LHS &L, const RHS &R)
Match Select(C, LHS, RHS) or Select(C, RHS, LHS)
OverflowingBinaryOp_match< LHS, RHS, Instruction::Shl, OverflowingBinaryOperator::NoSignedWrap > m_NSWShl(const LHS &L, const RHS &R)
match_bind< WithOverflowInst > m_WithOverflowInst(WithOverflowInst *&I)
Match a with overflow intrinsic, capturing it if we match.
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.
auto m_Ctlz(const Opnd0 &Op0, const Opnd1 &Op1)
match_combine_or< FMaxMin_match< LHS, RHS, ofmin_pred_ty >, FMaxMin_match< LHS, RHS, ufmin_pred_ty > > m_OrdOrUnordFMin(const LHS &L, const RHS &R)
Match an 'ordered' or 'unordered' floating point minimum function.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Mul, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWMul(const LHS &L, const RHS &R)
BinaryOp_match< LHS, RHS, Instruction::UDiv > m_UDiv(const LHS &L, const RHS &R)
is_zero< true > m_Zero()
Match any null constant or a vector with all elements equal to 0.
match_immconstant_ty m_ImmConstant()
Match an arbitrary immediate Constant and ignore it.
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.
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".
CastOperator_match< OpTy, Instruction::BitCast > m_BitCast(const OpTy &Op)
Matches BitCast.
auto m_Intrinsic(const Ts &...Ops)
Match intrinsic calls like this: m_Intrinsic<Intrinsic::fabs>(m_Value(X))
auto m_c_MaxOrMin(const LHS &L, const RHS &R)
cstfp_pred_ty< custom_checkfn< APFloat > > m_CheckedFp(function_ref< bool(const APFloat &)> CheckFn)
Match a float or vector where CheckFn(ele) for each element is true.
auto m_FMinNum(const Opnd0 &Op0, const Opnd1 &Op1)
OverflowingBinaryOp_match< LHS, RHS, Instruction::Sub, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWSub(const LHS &L, const RHS &R)
auto m_SMin(const Opnd0 &Op0, const Opnd1 &Op1)
FNeg_match< OpTy, true > m_FNegOrFSubNegZero(const OpTy &X)
Match fneg X or fsub -0.0, X.
auto m_FAbs(const Opnd0 &Op0)
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".
AnyBinaryOp_match< LHS, RHS, true > m_c_BinOp(const LHS &L, const RHS &R)
Matches a BinaryOperator with LHS and RHS in either order.
match_combine_or< FMaxMin_match< LHS, RHS, ofmax_pred_ty >, FMaxMin_match< LHS, RHS, ufmax_pred_ty > > m_OrdOrUnordFMax(const LHS &L, const RHS &R)
Match an 'ordered' or 'unordered' floating point maximum function.
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)
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.
auto m_LogicalAnd()
Matches L && R where L and R are arbitrary values.
brc_match< Cond_t, match_bind< BasicBlock >, match_bind< BasicBlock > > m_Br(const Cond_t &C, BasicBlock *&T, BasicBlock *&F)
auto m_c_UMin(const LHS &L, const RHS &R)
Matches a UMin with LHS and RHS in either order.
auto m_c_SMax(const LHS &L, const RHS &R)
Matches an SMax with LHS and RHS in either order.
BinaryOp_match< LHS, RHS, Instruction::SRem > m_SRem(const LHS &L, const RHS &R)
auto m_FMaxNum(const Opnd0 &Op0, const Opnd1 &Op1)
cst_pred_ty< is_nonpositive > m_NonPositive()
Match an integer or vector of non-positive values.
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.
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".
auto m_c_SMin(const LHS &L, const RHS &R)
Matches an SMin with LHS and RHS in either order.
ElementWiseBitCast_match< OpTy > m_ElementWiseBitCast(const OpTy &Op)
BinaryOp_match< LHS, RHS, Instruction::Mul, true > m_c_Mul(const LHS &L, const RHS &R)
Matches a Mul with LHS and RHS in either order.
CastOperator_match< OpTy, Instruction::PtrToInt > m_PtrToInt(const OpTy &Op)
Matches PtrToInt.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Mul, OverflowingBinaryOperator::NoSignedWrap > m_NSWMul(const LHS &L, const RHS &R)
BinaryOp_match< LHS, RHS, Instruction::Sub > m_Sub(const LHS &L, const RHS &R)
auto m_ConstantInt()
Match an arbitrary ConstantInt and ignore it.
static unsigned decodeVSEW(unsigned VSEW)
LLVM_ABI unsigned getSEWLMULRatio(unsigned SEW, VLMUL VLMul)
static constexpr unsigned RVVBitsPerBlock
static constexpr unsigned RVVBytesPerBlock
initializer< Ty > init(const Ty &Val)
std::enable_if_t< detail::IsValidPointer< X, Y >::value, X * > extract(Y &&MD)
Extract a Value from Metadata.
This is an optimization pass for GlobalISel generic memory operations.
LLVM_ABI 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.
LLVM_ABI 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...
LLVM_ABI 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.
LLVM_ABI KnownFPClass computeKnownFPClass(const Value *V, const APInt &DemandedElts, FPClassTest InterestedClasses, const SimplifyQuery &SQ, unsigned Depth=0)
Determine which floating-point classes are valid for V, and return them in KnownFPClass bit sets.
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
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.
LLVM_ABI bool canCreatePoison(const Operator *Op, bool ConsiderFlagsAndMetadata=true)
LLVM_ABI 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...
LLVM_ABI bool isKnownNeverInfinity(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Return true if the floating-point scalar value is not an infinity or if the floating-point vector val...
LLVM_ABI void computeKnownBitsFromContext(const Value *V, KnownBits &Known, const SimplifyQuery &Q, unsigned Depth=0)
Merge bits known from context-dependent facts into Known.
RelativeUniformCounterPtr Values
BundleAttr getBundleAttrFromOBU(OperandBundleUse OBU)
LLVM_ABI 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.
@ Known
Known to have no common set bits.
@ Unknown
Not known to have no common set bits.
@ OnlyIfUndefIgnored
Known to have no common set bits only if undef values are ignored.
LLVM_ABI bool isAssumeLikeIntrinsic(const Instruction *I)
Return true if it is an intrinsic that cannot be speculated but also cannot trap.
LLVM_ABI AllocaInst * findAllocaForValue(Value *V, bool OffsetZero=false)
Returns unique alloca where the value comes from, or nullptr.
LLVM_ABI APInt getMinMaxLimit(SelectPatternFlavor SPF, unsigned BitWidth)
Return the minimum or maximum constant value for the specified integer min/max flavor and type.
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
const Value * getLoadStorePointerOperand(const Value *V)
A helper function that returns the pointer operand of a load or store instruction.
@ Load
The value being inserted comes from a load (InsertElement only).
LLVM_ABI 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.
LLVM_ABI Constant * ReadByteArrayFromGlobal(const GlobalVariable *GV, uint64_t Offset)
LLVM_ABI Value * stripNullTest(Value *V)
Returns the inner value X if the expression has the form f(X) where f(X) == 0 if and only if X == 0,...
LLVM_ABI const Value * getArgumentAliasingToReturnedPointer(const CallBase *Call, bool MustPreserveOffset, bool MustPreserveProvenance=false)
This function returns call pointer argument that is considered the same by aliasing rules.
LLVM_ABI bool getUnderlyingObjectsForCodeGen(const Value *V, SmallVectorImpl< Value * > &Objects)
This is a wrapper around getUnderlyingObjects and adds support for basic ptrtoint+arithmetic+inttoptr...
LLVM_ABI 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.
LLVM_ABI 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.
LLVM_ABI 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.
constexpr bool isUIntN(unsigned N, uint64_t x)
Checks if an unsigned integer fits into the given (dynamic) bit width.
LLVM_ABI void computeKnownBits(const Value *V, KnownBits &Known, const DataLayout &DL, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true, unsigned Depth=0)
Determine which bits of V are known to be either zero or one and return them in the KnownZero/KnownOn...
LLVM_ABI bool assumeBundleImpliesNonNull(const Value *Val, const Function *Context, OperandBundleUse OBU)
LLVM_ABI bool mustSuppressSpeculation(const LoadInst &LI)
Return true if speculation of the given load must be suppressed to avoid ordering or interfering with...
@ O1
Optimize quickly without destroying debuggability.
@ O2
Optimize for fast execution as much as possible without triggering significant incremental compile ti...
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)
int ilogb(const APFloat &Arg)
Returns the exponent of the internal representation of the APFloat.
LLVM_ABI bool isSafeToSpeculativelyExecute(const Instruction *I, const Instruction *CtxI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr, bool UseVariableInfo=true, bool IgnoreUBImplyingAttrs=true)
Return true if the instruction does not have any effects besides calculating the result and does not ...
LLVM_ABI Value * getSplatValue(const Value *V)
Get splat value if the input is a splat vector or return nullptr.
LLVM_ABI CmpInst::Predicate getMinMaxPred(SelectPatternFlavor SPF, bool Ordered=false)
Return the canonical comparison predicate for the specified minimum/maximum flavor.
bool isa_and_nonnull(const Y &Val)
LLVM_ABI bool isKnownNegative(const WithCache< const Value * > &V, const SimplifyQuery &SQ, unsigned Depth=0)
Returns true if the given value is known be negative (i.e.
LLVM_ABI unsigned ComputeNumSignBits(const Value *Op, const DataLayout &DL, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true, unsigned Depth=0)
Return the number of times the sign bit of the register is replicated into the other bits.
LLVM_ABI bool canIgnoreSignBitOfZero(const Use &U)
Return true if the sign bit of the FP value can be ignored by the user when the value is zero.
LLVM_ABI 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.
LLVM_ABI ConstantRange getConstantRangeFromMetadata(const MDNode &RangeMD)
Parse out a conservative ConstantRange from !range metadata.
LLVM_ABI unsigned ComputeMaxSignificantBits(const Value *Op, const DataLayout &DL, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, unsigned Depth=0)
Get the upper bound on bit size for this Value Op as a signed integer.
std::tuple< Value *, FPClassTest, FPClassTest > fcmpImpliesClass(CmpInst::Predicate Pred, const Function &F, Value *LHS, FPClassTest RHSClass, bool LookThroughSrc=true)
const Value * getPointerOperand(const Value *V)
A helper function that returns the pointer operand of a load, store or GEP instruction.
LLVM_ABI bool isKnownToBeAPowerOfTwo(const Value *V, const DataLayout &DL, bool OrZero=false, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true, unsigned Depth=0)
Return true if the given value is known to have exactly one bit set when defined.
LLVM_ABI 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.
LLVM_ABI 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...
LLVM_ABI 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,...
LLVM_ABI bool isValidAssumeForContext(const Instruction *I, const Instruction *CtxI, const DominatorTree *DT=nullptr, bool AllowEphemerals=false)
Return true if it is valid to use the assumptions provided by an assume intrinsic,...
auto dyn_cast_or_null(const Y &Val)
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
LLVM_ABI OverflowResult computeOverflowForUnsignedMul(const Value *LHS, const Value *RHS, const SimplifyQuery &SQ, bool IsNSW=false)
LLVM_ABI 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.
LLVM_ABI 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.
LLVM_ABI SelectPatternFlavor getInverseMinMaxFlavor(SelectPatternFlavor SPF)
Return the inverse minimum/maximum flavor of the specified flavor.
constexpr unsigned MaxAnalysisRecursionDepth
LLVM_ABI void adjustKnownBitsForSelectArm(KnownBits &Known, Value *Cond, Value *Arm, bool Invert, const SimplifyQuery &Q, unsigned Depth=0)
Adjust Known for the given select Arm to include information from the select Cond.
LLVM_ABI NoCommonBitsSetResult getNoCommonBitsSetResult(const WithCache< const Value * > &LHSCache, const WithCache< const Value * > &RHSCache, const SimplifyQuery &SQ)
Return how strongly LHS and RHS are known to have no common set bits.
LLVM_ABI OverflowResult computeOverflowForSignedSub(const Value *LHS, const Value *RHS, const SimplifyQuery &SQ)
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.
constexpr bool isPowerOf2_32(uint32_t Value)
Return true if the argument is a power of two > 0.
LLVM_ABI bool isKnownPositive(const WithCache< const Value * > &V, const SimplifyQuery &SQ, unsigned Depth=0)
Returns true if the given value is known be positive (i.e.
LLVM_ABI bool impliesPoison(const Value *ValAssumedPoison, const Value *V)
Return true if V is poison given that ValAssumedPoison is already poison.
LLVM_ABI void getHorizDemandedEltsForFirstOperand(unsigned VectorBitWidth, const APInt &DemandedElts, APInt &DemandedLHS, APInt &DemandedRHS)
Compute the demanded elements mask of horizontal binary operations.
LLVM_ABI 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.
LLVM_ABI bool programUndefinedIfPoison(const Instruction *Inst)
LLVM_ABI bool matchSimpleBinaryIntrinsicRecurrence(const IntrinsicInst *I, PHINode *&P, Value *&Init, Value *&OtherOp)
Attempt to match a simple value-accumulating recurrence of the form: llvm.intrinsic....
LLVM_ABI bool NullPointerIsDefined(const Function *F, unsigned AS=0)
Check whether null pointer dereferencing is considered undefined behavior for a given function or an ...
LLVM_ABI bool cannotBeNegativeZero(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Return true if we can prove that the specified FP value is never equal to -0.0.
LLVM_ABI 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...
LLVM_ABI void adjustKnownFPClassForSelectArm(KnownFPClass &Known, Value *Cond, Value *Arm, bool Invert, const SimplifyQuery &Q, unsigned Depth=0)
Adjust Known for the given select Arm to include information from the select Cond.
generic_gep_type_iterator<> gep_type_iterator
LLVM_ABI bool collectPossibleValues(const Value *V, SmallPtrSetImpl< const Constant * > &Constants, unsigned MaxCount, bool AllowUndefOrPoison=true)
Enumerates all possible immediate values of V and inserts them into the set Constants.
constexpr unsigned MaxLookupSearchDepth
The max limit of the search depth in DecomposeGEPExpression() and getUnderlyingObject().
LLVM_ABI 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'.
LLVM_ABI OverflowResult computeOverflowForSignedMul(const Value *LHS, const Value *RHS, const SimplifyQuery &SQ)
LLVM_ABI 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...
LLVM_ABI Constant * ConstantFoldCastOperand(unsigned Opcode, Constant *C, Type *DestTy, const DataLayout &DL)
Attempt to constant fold a cast with the specified operand.
LLVM_ABI bool canCreateUndefOrPoison(const Operator *Op, bool ConsiderFlagsAndMetadata=true)
canCreateUndefOrPoison returns true if Op can create undef or poison from non-undef & non-poison oper...
LLVM_ABI bool matchSimpleTernaryIntrinsicRecurrence(const IntrinsicInst *I, PHINode *&P, Value *&Init, Value *&OtherOp0, Value *&OtherOp1)
Attempt to match a simple value-accumulating recurrence of the form: llvm.intrinsic....
LLVM_ABI EHPersonality classifyEHPersonality(const Value *Pers)
See if the given exception handling personality function is one that we understand.
LLVM_ABI const Value * getUnderlyingObjectAggressive(const Value *V, bool MustPreserveProvenance=false)
Like getUnderlyingObject(), but will try harder to find a single underlying object.
LLVM_ABI const Value * getUnderlyingObject(const Value *V, unsigned MaxLookup=MaxLookupSearchDepth, bool MustPreserveProvenance=false)
This method strips off any GEP address adjustments, pointer casts or llvm.threadlocal....
LLVM_ABI bool isKnownInversion(const Value *X, const Value *Y)
Return true iff:
bool isa(const From &Val)
isa<X> - Return true if the parameter to the template is an instance of one of the template type argu...
LLVM_ABI bool intrinsicPropagatesPoison(Intrinsic::ID IID)
Return whether this intrinsic propagates poison for all operands.
LLVM_ABI bool isNotCrossLaneOperation(const Instruction *I)
Return true if the instruction doesn't potentially cross vector lanes.
bool includesPoison(UndefPoisonKind Kind)
Returns true if Kind includes the Poison bit.
LLVM_ABI 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
LLVM_ABI RetainedKnowledge getKnowledgeValidInContext(const Value *V, ArrayRef< Attribute::AttrKind > AttrKinds, AssumptionCache &AC, const Instruction *CtxI, const DominatorTree *DT=nullptr)
Return a valid Knowledge associated to the Value V if its Attribute kind is in AttrKinds and the know...
LLVM_ABI 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, bool IgnoreUBImplyingAttrs=true)
This returns the same result as isSafeToSpeculativelyExecute if Opcode is the actual opcode of Inst.
LLVM_ABI 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.
LLVM_ABI Intrinsic::ID getMinMaxIntrinsic(SelectPatternFlavor SPF)
Convert given SPF to equivalent min/max intrinsic.
bool includesUndef(UndefPoisonKind Kind)
Returns true if Kind includes the Undef bit.
LLVM_ABI SelectPatternResult matchDecomposedSelectPattern(CmpInst *CmpI, Value *TrueVal, Value *FalseVal, Value *&LHS, Value *&RHS, FastMathFlags FMF=FastMathFlags(), Instruction::CastOps *CastOp=nullptr)
Determine the pattern that a select with the given compare as its predicate and given values as its t...
LLVM_ABI bool isOnlyUsedInZeroComparison(const Instruction *CtxI)
LLVM_ABI OverflowResult computeOverflowForSignedAdd(const WithCache< const Value * > &LHS, const WithCache< const Value * > &RHS, const SimplifyQuery &SQ)
LLVM_ABI bool propagatesPoison(const Use &PoisonOp)
Return true if PoisonOp's user yields poison or raises UB if its operand PoisonOp is poison.
RelativeUniformCounterPtr ValuesPtrExpr VTableAddr Count
LLVM_ABI bool isOnlyUsedInZeroEqualityComparison(const Instruction *CtxI)
LLVM_ABI 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.
LLVM_ABI bool isIntrinsicReturningPointerAliasingArgumentWithoutCapturing(const CallBase *Call, bool MustPreserveOffset, bool MustPreserveProvenance=false)
launder.invariant.group and similar intrinsics return a pointer that aliases their argument,...
LLVM_ABI bool isKnownNonEqual(const Value *V1, const Value *V2, const SimplifyQuery &SQ, unsigned Depth=0)
Return true if the given values are known to be non-equal when defined.
DWARFExpression::Operation Op
LLVM_ABI bool isDereferenceableAndAlignedPointer(const Value *V, Type *Ty, Align Alignment, const SimplifyQuery &Q, bool IgnoreFree=false)
Returns true if V is always a dereferenceable pointer with alignment greater or equal than requested.
RoundingMode
Rounding mode.
@ NearestTiesToEven
roundTiesToEven.
@ Dynamic
Denotes mode unknown at compile time.
LLVM_ABI 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.
ArrayRef(const T &OneElt) -> ArrayRef< T >
LLVM_ABI bool willNotFreeBetween(const Instruction *Assume, const Instruction *CtxI, const DominatorTree *DT=nullptr)
Returns true, if no instruction between Assume and CtxI may free (including through synchronization).
constexpr unsigned BitWidth
LLVM_ABI KnownBits analyzeKnownBitsFromAndXorOr(const Operator *I, const KnownBits &KnownLHS, const KnownBits &KnownRHS, const SimplifyQuery &SQ, unsigned Depth=0)
Using KnownBits LHS/RHS produce the known bits for logic op (and/xor/or).
LLVM_ABI OverflowResult computeOverflowForUnsignedSub(const Value *LHS, const Value *RHS, const SimplifyQuery &SQ)
LLVM_ABI bool isGuaranteedToTransferExecutionToSuccessor(const Instruction *I)
Return true if this function can prove that the instruction I will always transfer execution to one o...
LLVM_ABI bool isKnownNeverInfOrNaN(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Return true if the floating-point value can never contain a NaN or infinity.
LLVM_ABI AssumeRangeInfo getAssumeRangeInfo(OperandBundleUse)
decltype(auto) cast(const From &Val)
cast<X> - Return the argument parameter cast to the specified type.
LLVM_ABI bool isKnownNeverNaN(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Return true if the floating-point scalar value is not a NaN or if the floating-point vector value has...
gep_type_iterator gep_type_begin(const User *GEP)
UndefPoisonKind
Enumeration to track whether we are interested in Undef, Poison, or both.
LLVM_ABI 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...
auto predecessors(const MachineBasicBlock *BB)
LLVM_ABI 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...
bool is_contained(R &&Range, const E &Element)
Returns true if Element is found in Range.
LLVM_ABI bool isKnownIntegral(const Value *V, const SimplifyQuery &SQ, FastMathFlags FMF)
Return true if the floating-point value V is known to be an integer value.
LLVM_ABI AssumeAlignInfo getAssumeAlignInfo(OperandBundleUse)
bool pred_empty(const BasicBlock *BB)
LLVM_ABI 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.
LLVM_ABI 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...
LLVM_ABI 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.
@ End
Run the machine verifier once, at the end of the pipeline.
LLVM_ABI void computeKnownBitsFromRangeMetadata(const MDNode &Ranges, KnownBits &Known)
Compute known bits from the range metadata.
LLVM_ABI 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...
LLVM_ABI bool isKnownNegation(const Value *X, const Value *Y, bool NeedNSW=false, bool AllowPoison=true)
Return true if the two given values are negation.
LLVM_ABI 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...
LLVM_ABI bool isKnownNonNegative(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Returns true if the give value is known to be non-negative.
LLVM_ABI bool cannotBeOrderedLessThanZero(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Return true if we can prove that the specified FP value is either NaN or never less than -0....
LLVM_ABI void getUnderlyingObjects(const Value *V, SmallVectorImpl< const Value * > &Objects, const LoopInfo *LI=nullptr, unsigned MaxLookup=MaxLookupSearchDepth)
This method is similar to getUnderlyingObject except that it can look through phi and select instruct...
LLVM_ABI SelectPatternResult matchSelectPattern(Value *V, Value *&LHS, Value *&RHS, Instruction::CastOps *CastOp=nullptr)
Pattern match integer [SU]MIN, [SU]MAX and ABS idioms, returning the kind and providing the out param...
LLVM_ABI bool mayHaveNonDefUseDependency(const Instruction &I)
Returns true if the result or effects of the given instructions I depend values not reachable through...
LLVM_ABI bool isTriviallyVectorizable(Intrinsic::ID ID)
Identify if the intrinsic is trivially vectorizable.
LLVM_ABI bool isIdentifiedObject(const Value *V)
Return true if this pointer refers to a distinct and identifiable object.
LLVM_ABI 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.
LLVM_ABI std::optional< bool > computeKnownFPSignBit(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Return false if we can prove that the specified FP value's sign bit is 0.
LLVM_ABI bool canIgnoreSignBitOfNaN(const Use &U)
Return true if the sign bit of the FP value can be ignored by the user when the value is NaN.
LLVM_ABI ConstantRange computeConstantRange(const Value *V, bool ForSigned, const SimplifyQuery &SQ, unsigned Depth=0)
Determine the possible constant range of an integer or vector of integer value.
LLVM_ABI 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.
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.
const ConstantDataArray * Array
ConstantDataArray pointer.
Represent subnormal handling kind for floating point instruction inputs and outputs.
static constexpr DenormalMode getDynamic()
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 LLVM_ABI KnownBits sadd_sat(const KnownBits &LHS, const KnownBits &RHS)
Compute knownbits resulting from llvm.sadd.sat(LHS, RHS)
KnownBits anyextOrTrunc(unsigned BitWidth) const
Return known bits for an "any" extension or truncation of the value we're tracking.
static LLVM_ABI 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 LLVM_ABI 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.
bool isZero() const
Returns true if value is all zero.
LLVM_ABI 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 LLVM_ABI 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 LLVM_ABI KnownBits ashr(const KnownBits &LHS, const KnownBits &RHS, bool ShAmtNonZero=false, bool Exact=false)
Compute known bits for ashr(LHS, RHS).
static LLVM_ABI KnownBits ssub_sat(const KnownBits &LHS, const KnownBits &RHS)
Compute knownbits resulting from llvm.ssub.sat(LHS, RHS)
static LLVM_ABI 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.
LLVM_ABI 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...
KnownBits byteSwap() const
bool hasConflict() const
Returns true if there is conflicting information.
static LLVM_ABI KnownBits fshl(const KnownBits &LHS, const KnownBits &RHS, const APInt &Amt)
Compute known bits for fshl(LHS, RHS, Amt).
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.
KnownBits reverseBits() const
unsigned getBitWidth() const
Get the bit width of this value.
static LLVM_ABI KnownBits umax(const KnownBits &LHS, const KnownBits &RHS)
Compute known bits for umax(LHS, RHS).
KnownBits zext(unsigned BitWidth) const
Return known bits for a zero extension of the value we're tracking.
bool isConstant() const
Returns true if we know the value of all bits.
static KnownBits add(const KnownBits &LHS, const KnownBits &RHS, bool NSW=false, bool NUW=false, bool SelfAdd=false)
Compute knownbits resulting from addition of LHS and RHS.
KnownBits unionWith(const KnownBits &RHS) const
Returns KnownBits information that is known to be true for either this or RHS or both.
static LLVM_ABI 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.
bool isEven() const
Return if the value is known even (the low bit is 0).
KnownBits extractBits(unsigned NumBits, unsigned BitPosition) const
Return a subset of the known bits from [bitPosition,bitPosition+numBits).
static LLVM_ABI KnownBits pdep(const KnownBits &Val, const KnownBits &Mask)
Compute known bits for pdep(Val, Mask).
KnownBits intersectWith(const KnownBits &RHS) const
Returns KnownBits information that is known to be true for both this and RHS.
unsigned countMinTrailingOnes() const
Returns the minimum number of trailing one bits.
unsigned countMinLeadingZeros() const
Returns the minimum number of leading zero bits.
APInt getMaxValue() const
Return the maximal unsigned value possible given these KnownBits.
static LLVM_ABI KnownBits fshr(const KnownBits &LHS, const KnownBits &RHS, const APInt &Amt)
Compute known bits for fshr(LHS, RHS, Amt).
static LLVM_ABI KnownBits smin(const KnownBits &LHS, const KnownBits &RHS)
Compute known bits for smin(LHS, RHS).
static LLVM_ABI KnownBits mulhs(const KnownBits &LHS, const KnownBits &RHS)
Compute known bits from sign-extended multiply-hi.
static LLVM_ABI KnownBits srem(const KnownBits &LHS, const KnownBits &RHS)
Compute known bits for srem(LHS, RHS).
static LLVM_ABI KnownBits udiv(const KnownBits &LHS, const KnownBits &RHS, bool Exact=false)
Compute known bits for udiv(LHS, RHS).
APInt getMinValue() const
Return the minimal unsigned value possible given these KnownBits.
static LLVM_ABI KnownBits computeForAddSub(bool Add, bool NSW, bool NUW, const KnownBits &LHS, const KnownBits &RHS)
Compute known bits resulting from adding LHS and RHS.
static LLVM_ABI 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.
static LLVM_ABI KnownBits uadd_sat(const KnownBits &LHS, const KnownBits &RHS)
Compute knownbits resulting from llvm.uadd.sat(LHS, RHS)
static LLVM_ABI 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...
static LLVM_ABI KnownBits clmul(const KnownBits &LHS, const KnownBits &RHS)
Compute known bits for clmul(LHS, RHS).
LLVM_ABI KnownBits abs(bool IntMinIsPoison=false) const
Compute known bits for the absolute value.
static LLVM_ABI std::optional< bool > sgt(const KnownBits &LHS, const KnownBits &RHS)
Determine if these known bits always give the same ICMP_SGT result.
static LLVM_ABI std::optional< bool > uge(const KnownBits &LHS, const KnownBits &RHS)
Determine if these known bits always give the same ICMP_UGE result.
static LLVM_ABI 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 LLVM_ABI KnownBits umin(const KnownBits &LHS, const KnownBits &RHS)
Compute known bits for umin(LHS, RHS).
static LLVM_ABI KnownBits pext(const KnownBits &Val, const KnownBits &Mask)
Compute known bits for pext(Val, Mask).
KnownBits sextOrTrunc(unsigned BitWidth) const
Return known bits for a sign extension or truncation of the value we're tracking.
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
const Function * getFunction() const
fltNanEncoding nanEncoding