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);
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: {
2281 bool ZeroIsPoison =
match(
II->getArgOperand(1),
m_One());
2285 case Intrinsic::cttz: {
2291 PossibleTZ = std::min(PossibleTZ,
BitWidth - 1);
2293 Known.Zero.setBitsFrom(LowBits);
2296 case Intrinsic::ctpop: {
2302 Known.Zero.setBitsFrom(LowBits);
2307 case Intrinsic::fshr:
2308 case Intrinsic::fshl: {
2316 Known =
II->getIntrinsicID() == Intrinsic::fshl
2321 case Intrinsic::clmul:
2326 case Intrinsic::pext:
2331 case Intrinsic::pdep:
2336 case Intrinsic::smulh:
2341 case Intrinsic::umulh:
2346 case Intrinsic::uadd_sat:
2351 case Intrinsic::usub_sat:
2356 case Intrinsic::sadd_sat:
2361 case Intrinsic::ssub_sat:
2367 case Intrinsic::vector_reverse:
2373 case Intrinsic::vector_reduce_and:
2374 case Intrinsic::vector_reduce_or:
2375 case Intrinsic::vector_reduce_umax:
2376 case Intrinsic::vector_reduce_umin:
2377 case Intrinsic::vector_reduce_smax:
2378 case Intrinsic::vector_reduce_smin:
2381 case Intrinsic::vector_reduce_xor: {
2388 bool EvenCnt = VecTy->getElementCount().isKnownEven();
2392 if (VecTy->isScalableTy() || EvenCnt)
2393 Known.One.clearAllBits();
2396 case Intrinsic::vector_reduce_add: {
2401 Known =
Known.reduceAdd(VecTy->getNumElements());
2404 case Intrinsic::umin:
2409 case Intrinsic::umax:
2414 case Intrinsic::smin:
2420 case Intrinsic::smax:
2426 case Intrinsic::ptrmask: {
2429 const Value *Mask =
I->getOperand(1);
2430 Known2 =
KnownBits(Mask->getType()->getScalarSizeInBits());
2436 case Intrinsic::x86_sse42_crc32_64_64:
2437 Known.Zero.setBitsFrom(32);
2439 case Intrinsic::x86_ssse3_phadd_d_128:
2440 case Intrinsic::x86_ssse3_phadd_w_128:
2441 case Intrinsic::x86_avx2_phadd_d:
2442 case Intrinsic::x86_avx2_phadd_w: {
2444 I, DemandedElts, Q,
Depth,
2450 case Intrinsic::x86_ssse3_phadd_sw_128:
2451 case Intrinsic::x86_avx2_phadd_sw: {
2456 case Intrinsic::x86_ssse3_phsub_d_128:
2457 case Intrinsic::x86_ssse3_phsub_w_128:
2458 case Intrinsic::x86_avx2_phsub_d:
2459 case Intrinsic::x86_avx2_phsub_w: {
2461 I, DemandedElts, Q,
Depth,
2467 case Intrinsic::x86_ssse3_phsub_sw_128:
2468 case Intrinsic::x86_avx2_phsub_sw: {
2473 case Intrinsic::riscv_vsetvli:
2474 case Intrinsic::riscv_vsetvlimax: {
2475 bool HasAVL =
II->getIntrinsicID() == Intrinsic::riscv_vsetvli;
2488 MaxVL = std::min(MaxVL, CI->getZExtValue());
2490 unsigned KnownZeroFirstBit =
Log2_32(MaxVL) + 1;
2492 Known.Zero.setBitsFrom(KnownZeroFirstBit);
2495 case Intrinsic::amdgcn_mbcnt_hi:
2496 case Intrinsic::amdgcn_mbcnt_lo: {
2501 II->getIntrinsicID() == Intrinsic::amdgcn_mbcnt_lo ? 6 : 5);
2506 case Intrinsic::vscale: {
2507 if (!
II->getParent() || !
II->getFunction())
2513 case Intrinsic::stepvector: {
2515 unsigned MinNumElts = VecTy->getElementCount().getKnownMinValue();
2519 bool Overflow =
false;
2521 if (VecTy->isScalableTy()) {
2522 if (!
II->getParent() || !
II->getFunction())
2526 .
umul_ov(MaxNumElts, Overflow);
2541 case Instruction::ShuffleVector: {
2555 APInt DemandedLHS, DemandedRHS;
2560 Known.setAllConflict();
2561 if (!!DemandedLHS) {
2562 const Value *
LHS = Shuf->getOperand(0);
2565 if (
Known.isUnknown())
2568 if (!!DemandedRHS) {
2569 const Value *
RHS = Shuf->getOperand(1);
2575 case Instruction::InsertElement: {
2580 const Value *Vec =
I->getOperand(0);
2581 const Value *Elt =
I->getOperand(1);
2584 APInt DemandedVecElts = DemandedElts;
2585 bool NeedsElt =
true;
2587 if (CIdx && CIdx->getValue().ult(NumElts)) {
2588 DemandedVecElts.
clearBit(CIdx->getZExtValue());
2589 NeedsElt = DemandedElts[CIdx->getZExtValue()];
2592 Known.setAllConflict();
2596 if (
Known.isUnknown())
2600 if (!DemandedVecElts.
isZero()) {
2606 case Instruction::ExtractElement: {
2609 const Value *Vec =
I->getOperand(0);
2610 const Value *Idx =
I->getOperand(1);
2619 if (CIdx && CIdx->getValue().ult(NumElts))
2624 case Instruction::ExtractValue:
2629 switch (
II->getIntrinsicID()) {
2631 case Intrinsic::uadd_with_overflow:
2632 case Intrinsic::sadd_with_overflow:
2634 true,
II->getArgOperand(0),
II->getArgOperand(1),
false,
2635 false, DemandedElts,
Known, Known2, Q,
Depth);
2637 case Intrinsic::usub_with_overflow:
2638 case Intrinsic::ssub_with_overflow:
2640 false,
II->getArgOperand(0),
II->getArgOperand(1),
false,
2641 false, DemandedElts,
Known, Known2, Q,
Depth);
2643 case Intrinsic::umul_with_overflow:
2644 case Intrinsic::smul_with_overflow:
2646 false, DemandedElts,
Known, Known2, Q,
Depth);
2652 case Instruction::Freeze:
2696 if (!DemandedElts) {
2706 Type *Ty =
V->getType();
2709 assert((Ty->isIntOrIntVectorTy(
BitWidth) || Ty->isPtrOrPtrVectorTy()) &&
2710 "Not integer or pointer type!");
2714 FVTy->getNumElements() == DemandedElts.
getBitWidth() &&
2715 "DemandedElt width should equal the fixed vector number of elements");
2718 "DemandedElt width should be 1 for scalars or scalable vectors");
2724 "V and Known should have same BitWidth");
2727 "V and Known should have same BitWidth");
2748 Known.setAllConflict();
2749 for (
unsigned i = 0, e = CDV->getNumElements(); i != e; ++i) {
2750 if (!DemandedElts[i])
2752 APInt Elt = CDV->getElementAsAPInt(i);
2756 if (
Known.hasConflict())
2765 Known.setAllConflict();
2766 for (
unsigned i = 0, e = CV->getNumOperands(); i != e; ++i) {
2767 if (!DemandedElts[i])
2777 const APInt &Elt = ElementCI->getValue();
2781 if (
Known.hasConflict())
2798 if (std::optional<ConstantRange>
Range =
A->getRange())
2808 if (!GA->isInterposable())
2816 if (std::optional<ConstantRange> CR = GV->getAbsoluteSymbolRange())
2817 Known = CR->toKnownBits();
2822 Align Alignment =
V->getPointerAlignment(Q.
DL);
2838 Value *Start =
nullptr, *Step =
nullptr;
2844 if (U.get() == Start) {
2860 case Instruction::Mul:
2865 case Instruction::SDiv:
2871 case Instruction::UDiv:
2877 case Instruction::Shl:
2879 case Instruction::AShr:
2883 case Instruction::LShr:
2920 if (OrZero && V->getType()->getScalarSizeInBits() == 1)
2962 return F->hasFnAttribute(Attribute::VScaleRange);
2979 switch (
I->getOpcode()) {
2980 case Instruction::ZExt:
2982 case Instruction::Trunc:
2984 case Instruction::Shl:
2988 case Instruction::LShr:
2992 case Instruction::UDiv:
2996 case Instruction::Mul:
3000 case Instruction::And:
3011 case Instruction::Add: {
3017 if (
match(
I->getOperand(0),
3021 if (
match(
I->getOperand(1),
3026 unsigned BitWidth = V->getType()->getScalarSizeInBits();
3035 if ((~(LHSBits.
Zero & RHSBits.
Zero)).isPowerOf2())
3048 case Instruction::Select:
3051 case Instruction::PHI: {
3072 RecQ.CtxI = PN->getIncomingBlock(U)->getTerminator();
3073 return isKnownToBeAPowerOfTwo(U.get(), OrZero, RecQ, NewDepth);
3076 case Instruction::Invoke:
3077 case Instruction::Call: {
3079 switch (
II->getIntrinsicID()) {
3080 case Intrinsic::umax:
3081 case Intrinsic::smax:
3082 case Intrinsic::umin:
3083 case Intrinsic::smin:
3088 case Intrinsic::bitreverse:
3089 case Intrinsic::bswap:
3091 case Intrinsic::fshr:
3092 case Intrinsic::fshl:
3094 if (
II->getArgOperand(0) ==
II->getArgOperand(1))
3097 case Intrinsic::riscv_vsetvlimax:
3101 case Intrinsic::read_register:
3102 case Intrinsic::read_volatile_register: {
3106 if (!M || !M->getTargetTriple().isRISCV())
3131 F =
I->getFunction();
3135 if (!
GEP->hasNoUnsignedWrap() &&
3136 !(
GEP->isInBounds() &&
3141 assert(
GEP->getType()->isPointerTy() &&
"We only support plain pointer GEP");
3152 GTI != GTE; ++GTI) {
3154 if (
StructType *STy = GTI.getStructTypeOrNull()) {
3159 if (ElementOffset > 0)
3165 if (GTI.getSequentialElementStride(Q.
DL).isZero())
3199 unsigned NumUsesExplored = 0;
3200 for (
auto &U :
V->uses()) {
3209 if (
V->getType()->isPointerTy()) {
3211 if (CB->isArgOperand(&U) &&
3212 CB->paramHasNonNullAttr(CB->getArgOperandNo(&U),
3222 V->getType()->getPointerAddressSpace()) &&
3238 NonNullIfTrue =
true;
3240 NonNullIfTrue =
false;
3245 NonNullIfTrue =
true;
3251 for (
const auto *CmpU : UI->
users()) {
3253 if (Visited.
insert(CmpU).second)
3256 while (!WorkList.
empty()) {
3265 for (
const auto *CurrU : Curr->users())
3266 if (Visited.
insert(CurrU).second)
3273 BI->getSuccessor(NonNullIfTrue ? 0 : 1);
3277 }
else if (NonNullIfTrue &&
isGuard(Curr) &&
3292 const unsigned NumRanges = Ranges->getNumOperands() / 2;
3294 for (
unsigned i = 0; i < NumRanges; ++i) {
3310 Value *Start =
nullptr, *Step =
nullptr;
3311 const APInt *StartC, *StepC;
3317 case Instruction::Add:
3323 case Instruction::Mul:
3326 case Instruction::Shl:
3328 case Instruction::AShr:
3329 case Instruction::LShr:
3331 case Instruction::Or:
3363 X->getType()->getScalarSizeInBits() >=
3369 if (!
P->getType()->isPointerTy())
3373 uint64_t DerefBytes =
P->getPointerDereferenceableBytes(
3374 Q.
DL, CanBeNull,
nullptr);
3375 if (CanBeNull || DerefBytes == 0 || !
Off->ule(DerefBytes))
3383 bool NUW,
unsigned Depth) {
3443 return ::isKnownNonEqual(
X,
Y, DemandedElts, Q,
Depth);
3448 bool NUW,
unsigned Depth) {
3477 auto ShiftOp = [&](
const APInt &Lhs,
const APInt &Rhs) {
3478 switch (
I->getOpcode()) {
3479 case Instruction::Shl:
3480 return Lhs.
shl(Rhs);
3481 case Instruction::LShr:
3482 return Lhs.
lshr(Rhs);
3483 case Instruction::AShr:
3484 return Lhs.
ashr(Rhs);
3490 auto InvShiftOp = [&](
const APInt &Lhs,
const APInt &Rhs) {
3491 switch (
I->getOpcode()) {
3492 case Instruction::Shl:
3493 return Lhs.
lshr(Rhs);
3494 case Instruction::LShr:
3495 case Instruction::AShr:
3496 return Lhs.
shl(Rhs);
3509 if (MaxShift.
uge(NumBits))
3512 if (!ShiftOp(KnownVal.
One, MaxShift).isZero())
3517 if (InvShiftOp(KnownVal.
Zero, NumBits - MaxShift)
3526 const APInt &DemandedElts,
3529 switch (
I->getOpcode()) {
3530 case Instruction::Alloca:
3532 return I->getType()->getPointerAddressSpace() == 0;
3533 case Instruction::GetElementPtr:
3534 if (
I->getType()->isPointerTy())
3537 case Instruction::BitCast: {
3565 Type *FromTy =
I->getOperand(0)->getType();
3570 case Instruction::IntToPtr:
3579 case Instruction::PtrToAddr:
3583 case Instruction::PtrToInt:
3587 I->getType()->getScalarSizeInBits())
3590 case Instruction::Trunc:
3593 if (TI->hasNoSignedWrap() || TI->hasNoUnsignedWrap())
3599 case Instruction::Xor:
3600 case Instruction::Sub:
3602 I->getOperand(1),
Depth);
3603 case Instruction::Or:
3614 case Instruction::SExt:
3615 case Instruction::ZExt:
3619 case Instruction::Shl: {
3634 case Instruction::LShr:
3635 case Instruction::AShr: {
3645 if (
Known.isNegative())
3665 case Instruction::UDiv:
3666 case Instruction::SDiv: {
3681 if (
I->getOpcode() == Instruction::SDiv) {
3683 XKnown = XKnown.
abs(
false);
3684 YKnown = YKnown.
abs(
false);
3690 return XUgeY && *XUgeY;
3692 case Instruction::Add: {
3702 case Instruction::Mul: {
3708 case Instruction::Select: {
3715 auto SelectArmIsNonZero = [&](
bool IsTrueArm) {
3717 Op = IsTrueArm ?
I->getOperand(1) :
I->getOperand(2);
3735 if (SelectArmIsNonZero(
true) &&
3736 SelectArmIsNonZero(
false))
3740 case Instruction::PHI: {
3751 RecQ.CtxI = PN->getIncomingBlock(U)->getTerminator();
3755 BasicBlock *TrueSucc, *FalseSucc;
3756 if (match(RecQ.CtxI,
3757 m_Br(m_c_ICmp(Pred, m_Specific(U.get()), m_Value(X)),
3758 m_BasicBlock(TrueSucc), m_BasicBlock(FalseSucc)))) {
3760 if ((TrueSucc == PN->getParent()) != (FalseSucc == PN->getParent())) {
3762 if (FalseSucc == PN->getParent())
3763 Pred = CmpInst::getInversePredicate(Pred);
3764 if (cmpExcludesZero(Pred, X))
3772 case Instruction::InsertElement: {
3776 const Value *Vec =
I->getOperand(0);
3777 const Value *Elt =
I->getOperand(1);
3781 APInt DemandedVecElts = DemandedElts;
3782 bool SkipElt =
false;
3784 if (CIdx && CIdx->getValue().ult(NumElts)) {
3785 DemandedVecElts.
clearBit(CIdx->getZExtValue());
3786 SkipElt = !DemandedElts[CIdx->getZExtValue()];
3792 (DemandedVecElts.
isZero() ||
3795 case Instruction::ExtractElement:
3797 const Value *Vec = EEI->getVectorOperand();
3798 const Value *Idx = EEI->getIndexOperand();
3801 unsigned NumElts = VecTy->getNumElements();
3803 if (CIdx && CIdx->getValue().ult(NumElts))
3809 case Instruction::ShuffleVector: {
3813 APInt DemandedLHS, DemandedRHS;
3819 return (DemandedRHS.
isZero() ||
3824 case Instruction::Freeze:
3828 case Instruction::Load: {
3845 case Instruction::ExtractValue: {
3851 case Instruction::Add:
3856 case Instruction::Sub:
3859 case Instruction::Mul:
3862 false,
false,
Depth);
3868 case Instruction::Call:
3869 case Instruction::Invoke: {
3871 if (
I->getType()->isPointerTy()) {
3872 if (
Call->isReturnNonNull())
3880 if (std::optional<ConstantRange>
Range =
Call->getRange()) {
3881 const APInt ZeroValue(
Range->getBitWidth(), 0);
3882 if (!
Range->contains(ZeroValue))
3885 if (
const Value *RV =
Call->getReturnedArgOperand())
3891 switch (
II->getIntrinsicID()) {
3892 case Intrinsic::sshl_sat:
3893 case Intrinsic::ushl_sat:
3894 case Intrinsic::abs:
3895 case Intrinsic::bitreverse:
3896 case Intrinsic::bswap:
3897 case Intrinsic::ctpop:
3901 case Intrinsic::ssub_sat:
3909 case Intrinsic::sadd_sat:
3911 II->getArgOperand(1),
3912 true,
false,
Depth);
3914 case Intrinsic::vector_reverse:
3918 case Intrinsic::vector_reduce_or:
3919 case Intrinsic::vector_reduce_umax:
3920 case Intrinsic::vector_reduce_umin:
3921 case Intrinsic::vector_reduce_smax:
3922 case Intrinsic::vector_reduce_smin:
3924 case Intrinsic::umax:
3925 case Intrinsic::uadd_sat:
3933 case Intrinsic::smax: {
3936 auto IsNonZero = [&](
Value *
Op, std::optional<bool> &OpNonZero,
3938 if (!OpNonZero.has_value())
3939 OpNonZero = OpKnown.isNonZero() ||
3944 std::optional<bool> Op0NonZero, Op1NonZero;
3948 IsNonZero(
II->getArgOperand(1), Op1NonZero, Op1Known))
3953 IsNonZero(
II->getArgOperand(0), Op0NonZero, Op0Known))
3955 return IsNonZero(
II->getArgOperand(1), Op1NonZero, Op1Known) &&
3956 IsNonZero(
II->getArgOperand(0), Op0NonZero, Op0Known);
3958 case Intrinsic::smin: {
3974 case Intrinsic::umin:
3977 case Intrinsic::cttz:
3980 case Intrinsic::ctlz:
3983 case Intrinsic::fshr:
3984 case Intrinsic::fshl:
3986 if (
II->getArgOperand(0) ==
II->getArgOperand(1))
3989 case Intrinsic::vscale:
3991 case Intrinsic::experimental_get_vector_length:
4005 return Known.One != 0;
4016 Type *Ty =
V->getType();
4023 FVTy->getNumElements() == DemandedElts.
getBitWidth() &&
4024 "DemandedElt width should equal the fixed vector number of elements");
4027 "DemandedElt width should be 1 for scalars");
4032 if (
C->isNullValue())
4041 for (
unsigned i = 0, e = VecTy->getNumElements(); i != e; ++i) {
4042 if (!DemandedElts[i])
4044 Constant *Elt =
C->getAggregateElement(i);
4065 !GV->isAbsoluteSymbolRef() && !GV->hasExternalWeakLinkage() &&
4076 if (std::optional<ConstantRange>
Range =
A->getRange()) {
4077 const APInt ZeroValue(
Range->getBitWidth(), 0);
4078 if (!
Range->contains(ZeroValue))
4095 if (((
A->hasPassPointeeByValueCopyAttr() &&
4097 A->hasNonNullAttr()))
4119 APInt DemandedElts =
4121 return ::isKnownNonZero(V, DemandedElts, Q,
Depth);
4130static std::optional<std::pair<Value*, Value*>>
4134 return std::nullopt;
4136 auto getOperands = [&](
unsigned OpNum) ->
auto {
4143 case Instruction::Or:
4148 case Instruction::Xor:
4149 case Instruction::Add: {
4157 case Instruction::Sub:
4159 return getOperands(1);
4161 return getOperands(0);
4163 case Instruction::Mul: {
4169 if ((!OBO1->hasNoUnsignedWrap() || !OBO2->hasNoUnsignedWrap()) &&
4170 (!OBO1->hasNoSignedWrap() || !OBO2->hasNoSignedWrap()))
4177 return getOperands(0);
4180 case Instruction::Shl: {
4185 if ((!OBO1->hasNoUnsignedWrap() || !OBO2->hasNoUnsignedWrap()) &&
4186 (!OBO1->hasNoSignedWrap() || !OBO2->hasNoSignedWrap()))
4190 return getOperands(0);
4193 case Instruction::AShr:
4194 case Instruction::LShr: {
4197 if (!PEO1->isExact() || !PEO2->isExact())
4201 return getOperands(0);
4204 case Instruction::SExt:
4205 case Instruction::ZExt:
4207 return getOperands(0);
4209 case Instruction::PHI: {
4217 Value *Start1 =
nullptr, *Step1 =
nullptr;
4219 Value *Start2 =
nullptr, *Step2 =
nullptr;
4238 return std::make_pair(Start1, Start2);
4241 return std::nullopt;
4248 const APInt &DemandedElts,
4256 case Instruction::Or:
4260 case Instruction::Xor:
4261 case Instruction::Add:
4282 (OBO->hasNoUnsignedWrap() || OBO->hasNoSignedWrap()) &&
4283 !
C->isZero() && !
C->isOne() &&
4297 (OBO->hasNoUnsignedWrap() || OBO->hasNoSignedWrap()) &&
4311 bool UsedFullRecursion =
false;
4313 if (!VisitedBBs.
insert(IncomBB).second)
4322 if (UsedFullRecursion)
4326 RecQ.
CtxI = IncomBB->getTerminator();
4329 UsedFullRecursion =
true;
4343 const Value *Cond2 = SI2->getCondition();
4346 DemandedElts, Q,
Depth + 1) &&
4348 DemandedElts, Q,
Depth + 1);
4361 if (!
A->getType()->isPointerTy() || !
B->getType()->isPointerTy())
4365 if (!GEPA || GEPA->getNumIndices() != 1 || !
isa<Constant>(GEPA->idx_begin()))
4370 if (!PN || PN->getNumIncomingValues() != 2)
4375 Value *Start =
nullptr;
4377 if (PN->getIncomingValue(0) == Step)
4378 Start = PN->getIncomingValue(1);
4379 else if (PN->getIncomingValue(1) == Step)
4380 Start = PN->getIncomingValue(0);
4391 APInt StartOffset(IndexWidth, 0);
4392 Start = Start->stripAndAccumulateInBoundsConstantOffsets(Q.
DL, StartOffset);
4393 APInt StepOffset(IndexWidth, 0);
4399 APInt OffsetB(IndexWidth, 0);
4400 B =
B->stripAndAccumulateInBoundsConstantOffsets(Q.
DL, OffsetB);
4401 return Start ==
B &&
4413 auto IsKnownNonEqualFromDominatingCondition = [&](
const Value *
V) {
4434 if (IsKnownNonEqualFromDominatingCondition(
V1) ||
4435 IsKnownNonEqualFromDominatingCondition(V2))
4449 "Got assumption for the wrong function!");
4450 assert(
I->getIntrinsicID() == Intrinsic::assume &&
4451 "must be an assume intrinsic");
4474 std::optional<bool> Implied =
4476 return Implied && *Implied;
4497 if (
O1 &&
O2 &&
O1->getOpcode() ==
O2->getOpcode()) {
4523 if (
V1->getType()->isIntOrIntVectorTy()) {
4564 const APInt &DemandedElts,
4570 unsigned MinSignBits = TyBits;
4572 for (
unsigned i = 0; i != NumElts; ++i) {
4573 if (!DemandedElts[i])
4580 MinSignBits = std::min(MinSignBits, Elt->getValue().getNumSignBits());
4587 const APInt &DemandedElts,
4593 assert(Result > 0 &&
"At least one sign bit needs to be present!");
4605 const APInt &DemandedElts,
4607 Type *Ty =
V->getType();
4613 FVTy->getNumElements() == DemandedElts.
getBitWidth() &&
4614 "DemandedElt width should equal the fixed vector number of elements");
4617 "DemandedElt width should be 1 for scalars");
4631 unsigned FirstAnswer = 1;
4642 case Instruction::BitCast: {
4643 Value *Src = U->getOperand(0);
4644 Type *SrcTy = Src->getType();
4648 if (!SrcTy->isIntOrIntVectorTy())
4654 if ((SrcBits % TyBits) != 0)
4661 unsigned Scale = SrcBits / TyBits;
4663 DemandedElts, DemandedElts.
getBitWidth() / Scale);
4670 case Instruction::SExt:
4671 Tmp = TyBits - U->getOperand(0)->getType()->getScalarSizeInBits();
4675 case Instruction::SDiv: {
4676 const APInt *Denominator;
4689 return std::min(TyBits, NumBits + Denominator->
logBase2());
4694 case Instruction::SRem: {
4697 const APInt *Denominator;
4718 unsigned ResBits = TyBits - Denominator->
ceilLogBase2();
4719 Tmp = std::max(Tmp, ResBits);
4725 case Instruction::AShr: {
4730 if (ShAmt->
uge(TyBits))
4733 Tmp += ShAmtLimited;
4734 if (Tmp > TyBits) Tmp = TyBits;
4738 case Instruction::Shl: {
4743 if (ShAmt->
uge(TyBits))
4748 ShAmt->
uge(TyBits -
X->getType()->getScalarSizeInBits())) {
4750 Tmp += TyBits -
X->getType()->getScalarSizeInBits();
4754 if (ShAmt->
uge(Tmp))
4761 case Instruction::And:
4762 case Instruction::Or:
4763 case Instruction::Xor:
4768 FirstAnswer = std::min(Tmp, Tmp2);
4775 case Instruction::Select: {
4779 const APInt *CLow, *CHigh;
4787 return std::min(Tmp, Tmp2);
4790 case Instruction::Add:
4794 if (Tmp == 1)
break;
4798 if (CRHS->isAllOnesValue()) {
4804 if ((
Known.Zero | 1).isAllOnes())
4809 if (
Known.isNonNegative())
4816 return std::min(Tmp, Tmp2) - 1;
4818 case Instruction::Sub:
4825 if (CLHS->isNullValue()) {
4830 if ((
Known.Zero | 1).isAllOnes())
4836 if (
Known.isNonNegative())
4847 return std::min(Tmp, Tmp2) - 1;
4849 case Instruction::Mul: {
4852 unsigned SignBitsOp0 =
4854 if (SignBitsOp0 == 1)
4856 unsigned SignBitsOp1 =
4858 if (SignBitsOp1 == 1)
4860 unsigned OutValidBits =
4861 (TyBits - SignBitsOp0 + 1) + (TyBits - SignBitsOp1 + 1);
4862 return OutValidBits > TyBits ? 1 : TyBits - OutValidBits + 1;
4865 case Instruction::PHI: {
4869 if (NumIncomingValues > 4)
break;
4871 if (NumIncomingValues == 0)
break;
4877 for (
unsigned i = 0, e = NumIncomingValues; i != e; ++i) {
4878 if (Tmp == 1)
return Tmp;
4881 DemandedElts, RecQ,
Depth + 1));
4886 case Instruction::Trunc: {
4891 unsigned OperandTyBits = U->getOperand(0)->getType()->getScalarSizeInBits();
4892 if (Tmp > (OperandTyBits - TyBits))
4893 return Tmp - (OperandTyBits - TyBits);
4898 case Instruction::ExtractElement: {
4899 const Value *Vec = U->getOperand(0);
4904 unsigned NumElts = VecTy->getNumElements();
4907 if (CIdx->getValue().ult(NumElts))
4912 case Instruction::ShuffleVector: {
4920 APInt DemandedLHS, DemandedRHS;
4925 Tmp = std::numeric_limits<unsigned>::max();
4926 if (!!DemandedLHS) {
4927 const Value *
LHS = Shuf->getOperand(0);
4934 if (!!DemandedRHS) {
4935 const Value *
RHS = Shuf->getOperand(1);
4937 Tmp = std::min(Tmp, Tmp2);
4943 assert(Tmp <= TyBits &&
"Failed to determine minimum sign bits");
4946 case Instruction::Call: {
4948 switch (
II->getIntrinsicID()) {
4951 case Intrinsic::abs:
4959 case Intrinsic::smin:
4960 case Intrinsic::smax: {
4961 const APInt *CLow, *CHigh;
4976 if (
unsigned VecSignBits =
4985 return std::max(FirstAnswer,
Known.countMinSignBits());
4994 if (
F->isIntrinsic())
4995 return F->getIntrinsicID();
5003 LibFunc Func =
TLI->getLibFunc(CB);
5004 if (Func == NotLibFunc)
5013 return Intrinsic::sin;
5017 return Intrinsic::cos;
5021 return Intrinsic::tan;
5025 return Intrinsic::asin;
5029 return Intrinsic::acos;
5033 return Intrinsic::atan;
5035 case LibFunc_atan2f:
5036 case LibFunc_atan2l:
5037 return Intrinsic::atan2;
5041 return Intrinsic::sinh;
5045 return Intrinsic::cosh;
5049 return Intrinsic::tanh;
5053 return Intrinsic::exp;
5057 return Intrinsic::exp2;
5059 case LibFunc_exp10f:
5060 case LibFunc_exp10l:
5061 return Intrinsic::exp10;
5065 return Intrinsic::log;
5067 case LibFunc_log10f:
5068 case LibFunc_log10l:
5069 return Intrinsic::log10;
5073 return Intrinsic::log2;
5077 return Intrinsic::fabs;
5081 return Intrinsic::minnum;
5085 return Intrinsic::maxnum;
5086 case LibFunc_copysign:
5087 case LibFunc_copysignf:
5088 case LibFunc_copysignl:
5089 return Intrinsic::copysign;
5091 case LibFunc_floorf:
5092 case LibFunc_floorl:
5093 return Intrinsic::floor;
5097 return Intrinsic::ceil;
5099 case LibFunc_truncf:
5100 case LibFunc_truncl:
5101 return Intrinsic::trunc;
5105 return Intrinsic::rint;
5106 case LibFunc_nearbyint:
5107 case LibFunc_nearbyintf:
5108 case LibFunc_nearbyintl:
5109 return Intrinsic::nearbyint;
5111 case LibFunc_roundf:
5112 case LibFunc_roundl:
5113 return Intrinsic::round;
5114 case LibFunc_roundeven:
5115 case LibFunc_roundevenf:
5116 case LibFunc_roundevenl:
5117 return Intrinsic::roundeven;
5121 return Intrinsic::pow;
5125 return Intrinsic::sqrt;
5135 bool &TrueIfSigned) {
5138 TrueIfSigned =
true;
5139 return RHS.isZero();
5141 TrueIfSigned =
true;
5142 return RHS.isAllOnes();
5144 TrueIfSigned =
false;
5145 return RHS.isAllOnes();
5147 TrueIfSigned =
false;
5148 return RHS.isZero();
5151 TrueIfSigned =
true;
5152 return RHS.isMaxSignedValue();
5155 TrueIfSigned =
true;
5156 return RHS.isMinSignedValue();
5159 TrueIfSigned =
false;
5160 return RHS.isMinSignedValue();
5163 TrueIfSigned =
false;
5164 return RHS.isMaxSignedValue();
5174 unsigned Depth = 0) {
5200 KnownFromContext.
knownNot(~(CondIsTrue ? MaskIfTrue : MaskIfFalse));
5204 KnownFromContext.
knownNot(CondIsTrue ? ~Mask : Mask);
5210 if (TrueIfSigned == CondIsTrue)
5222static std::tuple<int, int, int>
5236 if (!
match(BI->getCondition(),
5251 bool KnownStrictlyLess =
5256 BI->getSuccessor(IsLessEqual ? 0 : 1));
5259 int Exp =
ilogb(*LimitC) + 1;
5270 MaxExpNonZero = std::min(MaxExpNonZero, Exp);
5271 MaxExp = std::min(MaxExp, std::max(Exp, 0));
5287 return KnownFromContext;
5307 return KnownFromContext;
5317 "Got assumption for the wrong function!");
5318 assert(
I->getIntrinsicID() == Intrinsic::assume &&
5319 "must be an assume intrinsic");
5325 true, Q.
CtxI, KnownFromContext);
5328 return KnownFromContext;
5332 Value *Arm,
bool Invert,
5338 !Invert, SQ.
CtxI, KnownSrc,
5356 APInt DemandedElts =
5362 const APInt &DemandedElts,
5367 if ((InterestedClasses &
5373 KnownSrc, Q,
Depth + 1);
5375 const fltSemantics &DstTy =
Op->getType()->getScalarType()->getFltSemantics();
5377 Op->getOperand(0)->getType()->getScalarType()->getFltSemantics();
5380 const Function *
F =
I ?
I->getFunction() :
nullptr;
5393 unsigned Depth,
bool IsAdd,
bool IsStrict) {
5406 bool WantNaN = (InterestedClasses &
fcNan) !=
fcNone;
5410 if (!WantNaN && !WantNegative && !WantNegZero && !WantSubnormal)
5416 if (InterestedClasses &
fcNan)
5417 InterestedSrcs |=
fcInf;
5422 bool Self =
LHS ==
RHS &&
5425 KnownLHS = KnownRHS;
5429 WantSubnormal || !IsAdd) {
5434 Op->getType()->getScalarType()->getFltSemantics();
5438 if (Self && IsAdd) {
5461 const APInt &DemandedElts,
5472 if (InterestedClasses &
fcNan) {
5494 F ?
F->getDenormalMode(
Op->getType()->getScalarType()->getFltSemantics())
5499 FPClassTest InterestedSrcs = InterestedLHS | InterestedRHS;
5501 if (InterestedSrcs !=
fcNone)
5509 if (InterestedLHS !=
fcNone)
5524 case Intrinsic::minimum:
5526 case Intrinsic::maximum:
5528 case Intrinsic::minimumnum:
5530 case Intrinsic::maximumnum:
5532 case Intrinsic::minnum:
5534 case Intrinsic::maxnum:
5549 const Value *SubFloorX;
5561 assert(
Known.isUnknown() &&
"should not be called with known information");
5563 if (!DemandedElts) {
5593 unsigned NumElts = VFVTy->getNumElements();
5594 for (
unsigned i = 0; i != NumElts; ++i) {
5595 if (!DemandedElts[i])
5618 for (
size_t I = 0,
E = CDS->getNumElements();
I !=
E; ++
I)
5626 for (
const Use &
Op : CA->operands()) {
5641 KnownNotFromFlags |= CB->getRetNoFPClass();
5643 KnownNotFromFlags |= Arg->getNoFPClass();
5647 if (
FPOp->hasNoNaNs())
5648 KnownNotFromFlags |=
fcNan;
5649 if (
FPOp->hasNoInfs())
5650 KnownNotFromFlags |=
fcInf;
5654 KnownNotFromFlags |= ~AssumedClasses.getKnownFPClasses();
5658 InterestedClasses &= ~KnownNotFromFlags;
5661 Known.knownNot(KnownNotFromFlags);
5664 Known.signBitMustBeOne();
5666 Known.signBitMustBeZero();
5677 const unsigned Opc =
Op->getOpcode();
5679 case Instruction::FNeg: {
5685 case Instruction::Select: {
5686 auto ComputeForArm = [&](
Value *Arm,
bool Invert) {
5696 ComputeForArm(
Op->getOperand(1),
false)
5697 .intersectWith(ComputeForArm(
Op->getOperand(2),
true));
5700 case Instruction::Load: {
5701 const MDNode *NoFPClass =
5711 case Instruction::Call: {
5715 case Intrinsic::fabs: {
5726 case Intrinsic::copysign: {
5732 KnownSign, Q,
Depth + 1);
5733 Known.copysign(KnownSign);
5736 case Intrinsic::fma:
5737 case Intrinsic::fmuladd: {
5741 const bool IsFMA = IID == Intrinsic::fma;
5744 if (
II->getArgOperand(0) ==
II->getArgOperand(1)) {
5745 FPClassTest InterestedSquared = InterestedClasses;
5749 if (InterestedClasses &
fcQNan) {
5756 InterestedAddend, KnownAddend, Q,
Depth + 1);
5758 InterestedSquared, KnownSrc, Q,
Depth + 1);
5762 II->getType()->getScalarType()->getFltSemantics();
5783 for (
int I = 0;
I != 3; ++
I) {
5785 InterestedClasses, KnownSrc[
I], Q,
Depth + 1);
5786 if (KnownSrc[
I].isUnknown())
5797 II->getType()->getScalarType()->getFltSemantics();
5806 case Intrinsic::experimental_constrained_fadd:
5807 case Intrinsic::experimental_constrained_fsub: {
5810 IID == Intrinsic::experimental_constrained_fadd,
5814 case Intrinsic::experimental_constrained_frem: {
5819 case Intrinsic::sqrt:
5820 case Intrinsic::experimental_constrained_sqrt: {
5823 if (InterestedClasses &
fcQNan)
5826 if (InterestedClasses &
fcZero)
5830 KnownSrc, Q,
Depth + 1);
5838 II->getType()->getScalarType()->getFltSemantics();
5848 case Intrinsic::sin: {
5851 KnownSrc, Q,
Depth + 1);
5855 case Intrinsic::cos: {
5858 KnownSrc, Q,
Depth + 1);
5862 case Intrinsic::tan: {
5865 KnownSrc, Q,
Depth + 1);
5869 case Intrinsic::sinh: {
5872 KnownSrc, Q,
Depth + 1);
5876 case Intrinsic::cosh: {
5879 KnownSrc, Q,
Depth + 1);
5883 case Intrinsic::tanh: {
5886 KnownSrc, Q,
Depth + 1);
5890 case Intrinsic::asin: {
5893 KnownSrc, Q,
Depth + 1);
5897 case Intrinsic::acos: {
5900 KnownSrc, Q,
Depth + 1);
5904 case Intrinsic::atan: {
5907 KnownSrc, Q,
Depth + 1);
5911 case Intrinsic::atan2: {
5929 KnownY, Q,
Depth + 1);
5931 KnownX, Q,
Depth + 1);
5935 F ?
F->getDenormalMode(
5936 II->getType()->getScalarType()->getFltSemantics())
5941 case Intrinsic::maxnum:
5942 case Intrinsic::minnum:
5943 case Intrinsic::minimum:
5944 case Intrinsic::maximum:
5945 case Intrinsic::minimumnum:
5946 case Intrinsic::maximumnum: {
5949 KnownLHS, Q,
Depth + 1);
5951 KnownRHS, Q,
Depth + 1);
5956 F ?
F->getDenormalMode(
5957 II->getType()->getScalarType()->getFltSemantics())
5964 case Intrinsic::canonicalize: {
5967 KnownSrc, Q,
Depth + 1);
5971 II->getType()->getScalarType()->getFltSemantics();
5977 case Intrinsic::vector_reduce_fmax:
5978 case Intrinsic::vector_reduce_fmin:
5979 case Intrinsic::vector_reduce_fmaximum:
5980 case Intrinsic::vector_reduce_fminimum:
5981 case Intrinsic::vector_reduce_fmaximumnum:
5982 case Intrinsic::vector_reduce_fminimumnum: {
5986 InterestedClasses, Q,
Depth + 1);
5988 if (!
Known.isKnownNeverNaN())
5989 Known.setSignBit(std::nullopt);
5993 case Intrinsic::vector_reverse:
5996 II->getFastMathFlags(), InterestedClasses, Q,
Depth + 1);
5998 case Intrinsic::trunc:
5999 case Intrinsic::floor:
6000 case Intrinsic::ceil:
6001 case Intrinsic::rint:
6002 case Intrinsic::nearbyint:
6003 case Intrinsic::round:
6004 case Intrinsic::roundeven: {
6017 KnownSrc, Q,
Depth + 1);
6021 F ?
F->getDenormalMode(
6022 II->getType()->getScalarType()->getFltSemantics())
6024 const bool IsMultiUnitFPType =
6025 V->getType()->getScalarType()->isMultiUnitFPType();
6028 case Intrinsic::trunc:
6031 case Intrinsic::floor:
6034 case Intrinsic::ceil:
6044 case Intrinsic::exp:
6045 case Intrinsic::exp2:
6046 case Intrinsic::exp10:
6047 case Intrinsic::amdgcn_exp2: {
6050 KnownSrc, Q,
Depth + 1);
6054 Type *EltTy =
II->getType()->getScalarType();
6055 if (IID == Intrinsic::amdgcn_exp2 && EltTy->
isFloatTy())
6060 case Intrinsic::fptrunc_round: {
6065 case Intrinsic::log:
6066 case Intrinsic::log10:
6067 case Intrinsic::log2:
6068 case Intrinsic::experimental_constrained_log:
6069 case Intrinsic::experimental_constrained_log10:
6070 case Intrinsic::experimental_constrained_log2:
6071 case Intrinsic::amdgcn_log: {
6095 if (InterestedSrcs !=
fcNone)
6097 KnownSrc, Q,
Depth + 1);
6100 F ?
F->getDenormalMode(
6101 II->getType()->getScalarType()->getFltSemantics())
6103 const bool IsMultiUnitFPType =
6104 V->getType()->getScalarType()->isMultiUnitFPType();
6108 case Intrinsic::pow: {
6109 const bool WantNaN = (InterestedClasses &
fcNan) !=
fcNone;
6111 if (!WantNaN && !WantNegative)
6121 InterestedRHS |=
fcNan;
6132 KnownLHS, Q,
Depth + 1);
6141 KnownRHS, Q,
Depth + 1);
6145 case Intrinsic::powi: {
6150 const Value *Exp =
II->getArgOperand(1);
6151 unsigned BitWidth = Exp->getType()->getIntegerBitWidth();
6156 if (InterestedClasses &
fcNan)
6157 InterestedSrcs |=
fcNan;
6158 if (!ExponentKnownBits.
isZero()) {
6159 if (InterestedClasses &
fcInf)
6166 if (InterestedSrcs !=
fcNone)
6168 KnownSrc, Q,
Depth + 1);
6173 case Intrinsic::ldexp: {
6176 KnownSrc, Q,
Depth + 1);
6180 const Value *ExpArg =
II->getArgOperand(1);
6184 : ConstantRange::getFull(
6188 II->getType()->getScalarType()->getFltSemantics();
6198 case Intrinsic::arithmetic_fence: {
6203 case Intrinsic::experimental_constrained_sitofp:
6204 case Intrinsic::experimental_constrained_uitofp:
6214 if (IID == Intrinsic::experimental_constrained_uitofp)
6215 Known.signBitMustBeZero();
6220 case Intrinsic::amdgcn_fract: {
6223 if (InterestedClasses &
fcNan) {
6226 InterestedClasses, KnownSrc, Q,
Depth + 1);
6236 case Intrinsic::amdgcn_rcp: {
6239 KnownSrc, Q,
Depth + 1);
6241 Known.propagateNonNaN(KnownSrc);
6243 Type *EltTy =
II->getType()->getScalarType();
6266 case Intrinsic::amdgcn_rsq: {
6272 KnownSrc, Q,
Depth + 1);
6284 Type *EltTy =
II->getType()->getScalarType();
6304 case Intrinsic::amdgcn_trig_preop: {
6309 case Intrinsic::convert_from_arbitrary_fp: {
6319 II->getType()->getScalarType()->getFltSemantics();
6354 case Instruction::FAdd:
6355 case Instruction::FSub: {
6361 case Instruction::FMul: {
6364 F ?
F->getDenormalMode(
6365 Op->getType()->getScalarType()->getFltSemantics())
6408 case Instruction::FDiv: {
6409 const bool WantNan = (InterestedClasses &
fcNan) !=
fcNone;
6413 Op->getType()->getScalarType()->getFltSemantics();
6417 if (
Op->getOperand(0) ==
Op->getOperand(1) &&
6436 if (!WantNan && !WantNegative && !WantPositive)
6443 bool KnowSomethingUseful =
6448 if (KnowSomethingUseful)
6455 case Instruction::FRem: {
6460 case Instruction::FPExt: {
6463 KnownSrc, Q,
Depth + 1);
6466 Op->getType()->getScalarType()->getFltSemantics();
6468 Op->getOperand(0)->getType()->getScalarType()->getFltSemantics();
6471 const Function *
F =
I ?
I->getFunction() :
nullptr;
6480 case Instruction::FPTrunc: {
6485 case Instruction::SIToFP:
6486 case Instruction::UIToFP: {
6497 if (
Op->getOpcode() == Instruction::UIToFP)
6498 Known.signBitMustBeZero();
6511 if (
Op->getOpcode() == Instruction::SIToFP) {
6516 Known.signBitMustBeZero();
6518 Known.signBitMustBeOne();
6523 if (InterestedClasses &
fcInf) {
6528 if (
Op->getOpcode() == Instruction::UIToFP)
6530 else if (
Op->getOpcode() == Instruction::SIToFP)
6535 Type *FPTy =
Op->getType()->getScalarType();
6542 case Instruction::ExtractElement: {
6545 const Value *Vec =
Op->getOperand(0);
6547 APInt DemandedVecElts;
6549 unsigned NumElts = VecTy->getNumElements();
6552 if (CIdx && CIdx->getValue().ult(NumElts))
6555 DemandedVecElts =
APInt(1, 1);
6561 case Instruction::InsertElement: {
6565 const Value *Vec =
Op->getOperand(0);
6566 const Value *Elt =
Op->getOperand(1);
6569 APInt DemandedVecElts = DemandedElts;
6570 bool NeedsElt =
true;
6572 if (CIdx && CIdx->getValue().ult(NumElts)) {
6573 DemandedVecElts.
clearBit(CIdx->getZExtValue());
6574 NeedsElt = DemandedElts[CIdx->getZExtValue()];
6581 if (
Known.isUnknown())
6588 if (!DemandedVecElts.
isZero()) {
6597 case Instruction::ShuffleVector: {
6606 APInt DemandedLHS, DemandedRHS;
6611 if (!!DemandedLHS) {
6612 const Value *
LHS = Shuf->getOperand(0);
6617 if (
Known.isUnknown())
6623 if (!!DemandedRHS) {
6625 const Value *
RHS = Shuf->getOperand(1);
6633 case Instruction::ExtractValue: {
6640 switch (
II->getIntrinsicID()) {
6641 case Intrinsic::frexp: {
6661 InterestedSrcs, KnownSrc, Q,
Depth + 1);
6665 Op->getType()->getScalarType()->getFltSemantics();
6682 case Instruction::PHI: {
6685 if (
P->getNumIncomingValues() == 0)
6692 if (
Depth < PhiRecursionLimit) {
6699 for (
const Use &U :
P->operands()) {
6730 if (
P->getNumIncomingValues() != 2 ||
Known.cannotBeOrderedLessThanZero())
6732 for (
unsigned I = 0;
I < 2;
I++) {
6733 Value *RecurValue =
P->getIncomingValue(1 -
I);
6741 switch (
II->getIntrinsicID()) {
6742 case Intrinsic::fma:
6743 case Intrinsic::fmuladd: {
6757 case Instruction::BitCast: {
6760 !Src->getType()->isIntOrIntVectorTy())
6763 const Type *Ty =
Op->getType();
6765 Value *CastLHS, *CastRHS;
6777 Known = KnownLHS | KnownRHS;
6796 const APInt &DemandedElts,
6803 return KnownClasses;
6829 InterestedClasses &=
~fcNan;
6831 InterestedClasses &=
~fcInf;
6837 Result.setKnownFPClasses(Result.getKnownFPClasses() & ~
fcNan);
6839 Result.setKnownFPClasses(Result.getKnownFPClasses() & ~
fcInf);
6848 APInt DemandedElts =
6864 return Known.cannotBeOrderedLessThanZero();
6870 return Known.isKnownNeverInfinity();
6877 return Known.isKnownNeverNaN() &&
Known.isKnownNeverInfinity();
6886 return Known.isKnownNeverNaN();
6896 return Known.getSignBit();
6902 if (
FPOp->hasNoSignedZeros())
6906 switch (
User->getOpcode()) {
6907 case Instruction::FPToSI:
6908 case Instruction::FPToUI:
6910 case Instruction::FRem:
6912 return U.getOperandNo() == 1;
6913 case Instruction::FCmp:
6916 case Instruction::Call:
6918 switch (
II->getIntrinsicID()) {
6919 case Intrinsic::fabs:
6920 case Intrinsic::exp:
6921 case Intrinsic::exp2:
6922 case Intrinsic::exp10:
6923 case Intrinsic::log:
6924 case Intrinsic::log2:
6925 case Intrinsic::log10:
6926 case Intrinsic::cos:
6927 case Intrinsic::acos:
6928 case Intrinsic::cosh:
6929 case Intrinsic::fptosi_sat:
6930 case Intrinsic::fptoui_sat:
6931 case Intrinsic::lround:
6932 case Intrinsic::llround:
6933 case Intrinsic::lrint:
6934 case Intrinsic::llrint:
6936 case Intrinsic::copysign:
6937 return U.getOperandNo() == 0;
6938 case Intrinsic::pow:
6940 return U.getOperandNo() == 1;
6941 case Intrinsic::is_fpclass: {
6961 if (
FPOp->hasNoNaNs())
6965 switch (
User->getOpcode()) {
6966 case Instruction::FPToSI:
6967 case Instruction::FPToUI:
6970 case Instruction::FAdd:
6971 case Instruction::FSub:
6972 case Instruction::FMul:
6973 case Instruction::FDiv:
6974 case Instruction::FRem:
6975 case Instruction::FPTrunc:
6976 case Instruction::FPExt:
6977 case Instruction::FCmp:
6980 case Instruction::FNeg:
6981 case Instruction::Select:
6982 case Instruction::PHI:
6984 case Instruction::Ret:
6985 return User->getFunction()->getAttributes().getRetNoFPClass() &
6987 case Instruction::Call:
6988 case Instruction::Invoke: {
6990 switch (
II->getIntrinsicID()) {
6991 case Intrinsic::fabs:
6993 case Intrinsic::copysign:
6994 return U.getOperandNo() == 0;
6996 case Intrinsic::maxnum:
6997 case Intrinsic::minnum:
6998 case Intrinsic::maximum:
6999 case Intrinsic::minimum:
7000 case Intrinsic::maximumnum:
7001 case Intrinsic::minimumnum:
7002 case Intrinsic::canonicalize:
7003 case Intrinsic::fma:
7004 case Intrinsic::fmuladd:
7005 case Intrinsic::sqrt:
7006 case Intrinsic::pow:
7007 case Intrinsic::powi:
7008 case Intrinsic::fptoui_sat:
7009 case Intrinsic::fptosi_sat:
7010 case Intrinsic::is_fpclass:
7040 switch (
I->getOpcode()) {
7041 case Instruction::SIToFP:
7042 case Instruction::UIToFP:
7050 case Instruction::Call: {
7053 case Intrinsic::trunc:
7054 case Intrinsic::floor:
7055 case Intrinsic::ceil:
7056 case Intrinsic::rint:
7057 case Intrinsic::nearbyint:
7058 case Intrinsic::round:
7059 case Intrinsic::roundeven:
7077 if (V->getType()->isIntegerTy(8))
7088 if (
DL.getTypeStoreSize(V->getType()).isZero())
7103 if (
C->isNullValue())
7112 ConstantInt::get(Ctx, CFP->getValue().bitcastToAPInt()),
DL);
7120 if (CI->getBitWidth() % 8 == 0) {
7121 if (!CI->getValue().isSplat(8))
7123 return ConstantInt::get(Ctx, CI->getValue().trunc(8));
7128 if (CE->getOpcode() == Instruction::IntToPtr) {
7130 unsigned BitWidth =
DL.getPointerSizeInBits(PtrTy->getAddressSpace());
7143 if (LHS == UndefInt8)
7145 if (RHS == UndefInt8)
7151 Value *Val = UndefInt8;
7152 for (uint64_t
I = 0, E = CA->getNumElements();
I != E; ++
I)
7159 Value *Val = UndefInt8;
7194 while (PrevTo != OrigTo) {
7241 unsigned IdxSkip = Idxs.
size();
7254 std::optional<BasicBlock::iterator> InsertBefore) {
7257 if (idx_range.
empty())
7260 assert((V->getType()->isStructTy() || V->getType()->isArrayTy()) &&
7261 "Not looking at a struct or array?");
7263 "Invalid indices for type?");
7266 C =
C->getAggregateElement(idx_range[0]);
7267 if (!
C)
return nullptr;
7274 const unsigned *req_idx = idx_range.
begin();
7275 for (
const unsigned *i =
I->idx_begin(), *e =
I->idx_end();
7276 i != e; ++i, ++req_idx) {
7277 if (req_idx == idx_range.
end()) {
7307 ArrayRef(req_idx, idx_range.
end()), InsertBefore);
7316 unsigned size =
I->getNumIndices() + idx_range.
size();
7321 Idxs.
append(
I->idx_begin(),
I->idx_end());
7327 &&
"Number of indices added not correct?");
7343 unsigned ElementSize, uint64_t
Offset) {
7344 assert(V &&
"V should not be null.");
7345 assert((ElementSize % 8) == 0 &&
7346 "ElementSize expected to be a multiple of the size of a byte.");
7347 unsigned ElementSizeInBytes = ElementSize / 8;
7359 APInt Off(
DL.getIndexTypeSizeInBits(V->getType()), 0);
7366 uint64_t StartIdx =
Off.getLimitedValue();
7373 if ((StartIdx % ElementSizeInBytes) != 0)
7376 Offset += StartIdx / ElementSizeInBytes;
7382 uint64_t SizeInBytes =
DL.getTypeStoreSize(GVTy).getFixedValue();
7383 uint64_t
Length = SizeInBytes / ElementSizeInBytes;
7385 Slice.Array =
nullptr;
7397 Type *InitElTy = ArrayInit->getElementType();
7402 ArrayTy = ArrayInit->getType();
7407 if (ElementSize != 8)
7426 Slice.Array = Array;
7428 Slice.Length = NumElts -
Offset;
7442 if (Slice.Array ==
nullptr) {
7453 if (Slice.Length == 1) {
7465 Str = Str.
substr(Slice.Offset);
7471 Str = Str.substr(0, Str.find(
'\0'));
7484 unsigned CharSize) {
7486 V =
V->stripPointerCasts();
7491 if (!PHIs.
insert(PN).second)
7496 for (
Value *IncValue : PN->incoming_values()) {
7498 if (Len == 0)
return 0;
7500 if (Len == ~0ULL)
continue;
7502 if (Len != LenSoFar && LenSoFar != ~0ULL)
7514 if (Len1 == 0)
return 0;
7516 if (Len2 == 0)
return 0;
7517 if (Len1 == ~0ULL)
return Len2;
7518 if (Len2 == ~0ULL)
return Len1;
7519 if (Len1 != Len2)
return 0;
7528 if (Slice.Array ==
nullptr)
7536 unsigned NullIndex = 0;
7537 for (
unsigned E = Slice.Length; NullIndex <
E; ++NullIndex) {
7538 if (Slice.Array->getElementAsInteger(Slice.Offset + NullIndex) == 0)
7542 return NullIndex + 1;
7548 if (!V->getType()->isPointerTy())
7555 return Len == ~0ULL ? 1 : Len;
7560 bool MustPreserveOffset,
7561 bool MustPreserveProvenance) {
7563 "getArgumentAliasingToReturnedPointer only works on nonnull calls");
7564 if (
const Value *RV =
Call->getReturnedArgOperand())
7568 Call, MustPreserveOffset, MustPreserveProvenance))
7569 return Call->getArgOperand(0);
7575 bool MustPreserveProvenance) {
7576 switch (
Call->getIntrinsicID()) {
7577 case Intrinsic::launder_invariant_group:
7578 case Intrinsic::aarch64_irg:
7579 case Intrinsic::aarch64_tagp:
7589 case Intrinsic::amdgcn_make_buffer_rsrc:
7590 return !MustPreserveProvenance;
7591 case Intrinsic::ptrmask:
7592 return !MustPreserveOffset;
7593 case Intrinsic::threadlocal_address:
7596 return !
Call->getParent()->getParent()->isPresplitCoroutine();
7613 if (!PrevValue || LI->
getLoopFor(PrevValue->getParent()) != L)
7615 if (!PrevValue || LI->
getLoopFor(PrevValue->getParent()) != L)
7624 if (!L->isLoopInvariant(
Load->getPointerOperand()))
7630 bool MustPreserveProvenance) {
7631 for (
unsigned Count = 0; MaxLookup == 0 ||
Count < MaxLookup; ++
Count) {
7633 const Value *PtrOp =
GEP->getPointerOperand();
7644 if (GA->isInterposable())
7646 V = GA->getAliasee();
7650 if (
PHI->getNumIncomingValues() == 1) {
7651 V =
PHI->getIncomingValue(0);
7665 Call,
false, MustPreserveProvenance)) {
7673 assert(V->getType()->isPointerTy() &&
"Unexpected operand type!");
7680 const LoopInfo *LI,
unsigned MaxLookup) {
7688 if (!Visited.
insert(
P).second)
7717 }
while (!Worklist.
empty());
7721 bool MustPreserveProvenance) {
7722 const unsigned MaxVisited = 8;
7727 const Value *Object =
nullptr;
7731 const Value *FirstObject =
7737 MustPreserveProvenance);
7740 if (!Visited.
insert(
P).second)
7743 if (Visited.
size() == MaxVisited)
7759 else if (Object !=
P)
7761 }
while (!Worklist.
empty());
7763 return Object ? Object : FirstObject;
7773 if (U->getOpcode() == Instruction::PtrToInt)
7774 return U->getOperand(0);
7781 if (U->getOpcode() != Instruction::Add ||
7786 V = U->getOperand(0);
7790 assert(
V->getType()->isIntegerTy() &&
"Unexpected operand type!");
7801 bool AllObjectsIdentified =
true;
7808 for (
const Value *V : Objs) {
7809 if (!Visited.
insert(V).second)
7814 if (O->getType()->isPointerTy()) {
7822 }
while (!Working.
empty());
7823 return AllObjectsIdentified;
7831 auto AddWork = [&](
Value *V) {
7832 if (Visited.
insert(V).second)
7842 if (Result && Result != AI)
7846 AddWork(CI->getOperand(0));
7848 for (
Value *IncValue : PN->incoming_values())
7851 AddWork(
SI->getTrueValue());
7852 AddWork(
SI->getFalseValue());
7854 if (OffsetZero && !
GEP->hasAllZeroIndices())
7856 AddWork(
GEP->getPointerOperand());
7858 Value *Returned = CB->getReturnedArgOperand();
7866 }
while (!Worklist.
empty());
7875 return (!Shuffle || Shuffle->isSelect()) &&
7882 bool IgnoreUBImplyingAttrs) {
7884 AC, DT,
TLI, UseVariableInfo,
7885 IgnoreUBImplyingAttrs);
7891 bool UseVariableInfo,
bool IgnoreUBImplyingAttrs) {
7895 auto hasEqualReturnAndLeadingOperandTypes =
7896 [](
const Instruction *Inst,
unsigned NumLeadingOperands) {
7900 for (
unsigned ItOp = 0; ItOp < NumLeadingOperands; ++ItOp)
7906 hasEqualReturnAndLeadingOperandTypes(Inst, 2));
7908 hasEqualReturnAndLeadingOperandTypes(Inst, 1));
7915 case Instruction::UDiv:
7916 case Instruction::URem: {
7923 case Instruction::SDiv:
7924 case Instruction::SRem: {
7926 const APInt *Numerator, *Denominator;
7930 if (*Denominator == 0)
7942 case Instruction::Load: {
7943 if (!UseVariableInfo)
7956 case Instruction::Call: {
7960 const Function *Callee = CI->getCalledFunction();
7964 if (!Callee || !Callee->isSpeculatable())
7968 return IgnoreUBImplyingAttrs || !CI->hasUBImplyingAttrs();
7970 case Instruction::VAArg:
7971 case Instruction::Alloca:
7972 case Instruction::Invoke:
7973 case Instruction::CallBr:
7974 case Instruction::PHI:
7975 case Instruction::Store:
7976 case Instruction::Ret:
7977 case Instruction::UncondBr:
7978 case Instruction::CondBr:
7979 case Instruction::IndirectBr:
7980 case Instruction::Switch:
7981 case Instruction::Unreachable:
7982 case Instruction::Fence:
7983 case Instruction::AtomicRMW:
7984 case Instruction::AtomicCmpXchg:
7985 case Instruction::LandingPad:
7986 case Instruction::Resume:
7987 case Instruction::CatchSwitch:
7988 case Instruction::CatchPad:
7989 case Instruction::CatchRet:
7990 case Instruction::CleanupPad:
7991 case Instruction::CleanupRet:
7997 if (
I.mayReadOrWriteMemory())
8065 unsigned BitWidth = LHS->getType()->getScalarSizeInBits();
8110 if (
Add &&
Add->hasNoSignedWrap()) {
8149 bool LHSOrRHSKnownNonNegative =
8151 bool LHSOrRHSKnownNegative =
8153 if (LHSOrRHSKnownNonNegative || LHSOrRHSKnownNegative) {
8156 if ((AddKnown.
isNonNegative() && LHSOrRHSKnownNonNegative) ||
8157 (AddKnown.
isNegative() && LHSOrRHSKnownNegative))
8232 assert(EVI->getNumIndices() == 1 &&
"Obvious from CI's type");
8234 if (EVI->getIndices()[0] == 0)
8237 assert(EVI->getIndices()[0] == 1 &&
"Obvious from CI's type");
8239 for (
const auto *U : EVI->users())
8250 auto AllUsesGuardedByBranch = [&](
const CondBrInst *BI) {
8254 for (
const auto *Result :
Results) {
8257 if (DT.
dominates(NoWrapEdge, Result->getParent()))
8260 for (
const auto &RU : Result->uses())
8268 return llvm::any_of(GuardingBranches, AllUsesGuardedByBranch);
8280 unsigned NumElts = FVTy->getNumElements();
8281 for (
unsigned i = 0; i < NumElts; ++i)
8282 ShiftAmounts.
push_back(
C->getAggregateElement(i));
8290 return CI && CI->getValue().ult(
C->getType()->getIntegerBitWidth());
8297 bool ConsiderFlagsAndMetadata) {
8299 bool CBHasNoUndef = CB && CB->hasRetAttr(Attribute::NoUndef);
8301 Op->hasPoisonGeneratingAnnotations() && !CBHasNoUndef)
8304 unsigned Opcode =
Op->getOpcode();
8308 case Instruction::Shl:
8309 case Instruction::AShr:
8310 case Instruction::LShr:
8312 case Instruction::FPToSI:
8313 case Instruction::FPToUI:
8317 case Instruction::Call:
8319 switch (
II->getIntrinsicID()) {
8321 case Intrinsic::ctlz:
8322 case Intrinsic::cttz:
8323 case Intrinsic::abs:
8326 case Intrinsic::sshl_sat:
8327 case Intrinsic::ushl_sat:
8335 case Instruction::CallBr:
8336 case Instruction::Invoke: {
8337 return !CBHasNoUndef && !CB->hasFnAttr(Attribute::NoCreateUndefOrPoison);
8339 case Instruction::InsertElement:
8340 case Instruction::ExtractElement: {
8343 unsigned IdxOp =
Op->getOpcode() == Instruction::InsertElement ? 2 : 1;
8347 Idx->getValue().uge(VTy->getElementCount().getKnownMinValue());
8350 case Instruction::ShuffleVector: {
8356 case Instruction::FNeg:
8357 case Instruction::PHI:
8358 case Instruction::Select:
8359 case Instruction::ExtractValue:
8360 case Instruction::InsertValue:
8361 case Instruction::Freeze:
8362 case Instruction::ICmp:
8363 case Instruction::FCmp:
8364 case Instruction::GetElementPtr:
8366 case Instruction::AddrSpaceCast:
8381 bool ConsiderFlagsAndMetadata) {
8383 ConsiderFlagsAndMetadata);
8388 ConsiderFlagsAndMetadata);
8393 if (ValAssumedPoison ==
V)
8396 const unsigned MaxDepth = 2;
8397 if (
Depth >= MaxDepth)
8402 return propagatesPoison(Op) &&
8403 directlyImpliesPoison(ValAssumedPoison, Op, Depth + 1);
8427 const unsigned MaxDepth = 2;
8428 if (
Depth >= MaxDepth)
8434 return impliesPoison(Op, V, Depth + 1);
8441 return ::impliesPoison(ValAssumedPoison, V, 0);
8456 if (
A->hasAttribute(Attribute::NoUndef) ||
8457 A->hasAttribute(Attribute::Dereferenceable) ||
8458 A->hasAttribute(Attribute::DereferenceableOrNull))
8473 if (
C->getType()->isVectorTy() ||
C->getType()->isAggregateType()) {
8476 if (
Constant *SplatC =
C->getSplatValue())
8480 return all_of(CA->operands(), [&](
const Use &
Op) {
8481 return isGuaranteedNotToBeUndefOrPoison(Op.get(), AC, CtxI, DT,
8496 auto *StrippedV =
V->stripPointerCastsSameRepresentation();
8501 auto OpCheck = [&](
const Value *
V) {
8512 if (CB->hasRetAttr(Attribute::NoUndef) ||
8513 CB->hasRetAttr(Attribute::Dereferenceable) ||
8514 CB->hasRetAttr(Attribute::DereferenceableOrNull))
8521 unsigned Num = PN->getNumIncomingValues();
8522 bool IsWellDefined =
true;
8523 for (
unsigned i = 0; i < Num; ++i) {
8524 if (PN == PN->getIncomingValue(i))
8526 auto *TI = PN->getIncomingBlock(i)->getTerminator();
8528 DT,
Depth + 1, Kind)) {
8529 IsWellDefined =
false;
8540 }
else if (
all_of(Opr->operands(), OpCheck))
8546 if (
I->hasMetadata(LLVMContext::MD_noundef) ||
8547 I->hasMetadata(LLVMContext::MD_dereferenceable) ||
8548 I->hasMetadata(LLVMContext::MD_dereferenceable_or_null))
8568 auto *Dominator = DNode->
getIDom();
8573 auto *TI = Dominator->getBlock()->getTerminatorOrNull();
8577 Cond = BI->getCondition();
8579 Cond =
SI->getCondition();
8588 if (
any_of(Opr->operands(), [
V](
const Use &U) {
8589 return V == U && propagatesPoison(U);
8595 Dominator = Dominator->getIDom();
8608 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT,
Depth,
8615 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT,
Depth,
8622 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT,
Depth,
8646 while (!Worklist.
empty()) {
8655 if (
I != Root && !
any_of(
I->operands(), [&KnownPoison](
const Use &U) {
8656 return KnownPoison.contains(U) && propagatesPoison(U);
8660 if (KnownPoison.
insert(
I).second)
8672 return ::computeOverflowForSignedAdd(
Add->getOperand(0),
Add->getOperand(1),
8680 return ::computeOverflowForSignedAdd(LHS, RHS,
nullptr, SQ);
8712 return !
I->mayThrow() &&
I->willReturn();
8726 unsigned ScanLimit) {
8733 assert(ScanLimit &&
"scan limit must be non-zero");
8735 if (--ScanLimit == 0)
8749 if (
I->getParent() != L->getHeader())
return false;
8752 if (&LI ==
I)
return true;
8755 llvm_unreachable(
"Instruction not contained in its own parent basic block.");
8761 case Intrinsic::sadd_with_overflow:
8762 case Intrinsic::ssub_with_overflow:
8763 case Intrinsic::smul_with_overflow:
8764 case Intrinsic::uadd_with_overflow:
8765 case Intrinsic::usub_with_overflow:
8766 case Intrinsic::umul_with_overflow:
8771 case Intrinsic::ctpop:
8772 case Intrinsic::ctlz:
8773 case Intrinsic::cttz:
8774 case Intrinsic::abs:
8775 case Intrinsic::smax:
8776 case Intrinsic::smin:
8777 case Intrinsic::umax:
8778 case Intrinsic::umin:
8779 case Intrinsic::scmp:
8780 case Intrinsic::smulh:
8781 case Intrinsic::umulh:
8782 case Intrinsic::is_fpclass:
8783 case Intrinsic::ptrmask:
8784 case Intrinsic::ucmp:
8785 case Intrinsic::bitreverse:
8786 case Intrinsic::bswap:
8787 case Intrinsic::sadd_sat:
8788 case Intrinsic::ssub_sat:
8789 case Intrinsic::sshl_sat:
8790 case Intrinsic::uadd_sat:
8791 case Intrinsic::usub_sat:
8792 case Intrinsic::ushl_sat:
8793 case Intrinsic::smul_fix:
8794 case Intrinsic::smul_fix_sat:
8795 case Intrinsic::umul_fix:
8796 case Intrinsic::umul_fix_sat:
8797 case Intrinsic::pow:
8798 case Intrinsic::experimental_constrained_pow:
8799 case Intrinsic::powi:
8800 case Intrinsic::experimental_constrained_powi:
8801 case Intrinsic::sin:
8802 case Intrinsic::experimental_constrained_sin:
8803 case Intrinsic::sinh:
8804 case Intrinsic::experimental_constrained_sinh:
8805 case Intrinsic::cos:
8806 case Intrinsic::experimental_constrained_cos:
8807 case Intrinsic::cosh:
8808 case Intrinsic::experimental_constrained_cosh:
8809 case Intrinsic::sincos:
8810 case Intrinsic::sincospi:
8811 case Intrinsic::tan:
8812 case Intrinsic::experimental_constrained_tan:
8813 case Intrinsic::tanh:
8814 case Intrinsic::experimental_constrained_tanh:
8815 case Intrinsic::asin:
8816 case Intrinsic::experimental_constrained_asin:
8817 case Intrinsic::acos:
8818 case Intrinsic::experimental_constrained_acos:
8819 case Intrinsic::atan:
8820 case Intrinsic::experimental_constrained_atan:
8821 case Intrinsic::atan2:
8822 case Intrinsic::experimental_constrained_atan2:
8823 case Intrinsic::canonicalize:
8824 case Intrinsic::sqrt:
8825 case Intrinsic::experimental_constrained_sqrt:
8826 case Intrinsic::fma:
8827 case Intrinsic::experimental_constrained_fma:
8828 case Intrinsic::fmuladd:
8829 case Intrinsic::experimental_constrained_fmuladd:
8830 case Intrinsic::exp:
8831 case Intrinsic::experimental_constrained_exp:
8832 case Intrinsic::exp2:
8833 case Intrinsic::experimental_constrained_exp2:
8834 case Intrinsic::exp10:
8835 case Intrinsic::log:
8836 case Intrinsic::experimental_constrained_log:
8837 case Intrinsic::log2:
8838 case Intrinsic::experimental_constrained_log2:
8839 case Intrinsic::log10:
8840 case Intrinsic::experimental_constrained_log10:
8841 case Intrinsic::modf:
8842 case Intrinsic::floor:
8843 case Intrinsic::experimental_constrained_floor:
8844 case Intrinsic::ceil:
8845 case Intrinsic::experimental_constrained_ceil:
8846 case Intrinsic::trunc:
8847 case Intrinsic::experimental_constrained_trunc:
8848 case Intrinsic::rint:
8849 case Intrinsic::experimental_constrained_rint:
8850 case Intrinsic::nearbyint:
8851 case Intrinsic::experimental_constrained_nearbyint:
8852 case Intrinsic::round:
8853 case Intrinsic::experimental_constrained_round:
8854 case Intrinsic::roundeven:
8855 case Intrinsic::experimental_constrained_roundeven:
8856 case Intrinsic::lrint:
8857 case Intrinsic::experimental_constrained_lrint:
8858 case Intrinsic::llrint:
8859 case Intrinsic::experimental_constrained_llrint:
8860 case Intrinsic::lround:
8861 case Intrinsic::experimental_constrained_lround:
8862 case Intrinsic::llround:
8863 case Intrinsic::experimental_constrained_llround:
8864 case Intrinsic::fshl:
8865 case Intrinsic::fshr:
8866 case Intrinsic::frexp:
8867 case Intrinsic::ldexp:
8868 case Intrinsic::experimental_constrained_ldexp:
8869 case Intrinsic::get_active_lane_mask:
8870 case Intrinsic::mask_beforefirst:
8879 switch (
I->getOpcode()) {
8880 case Instruction::Freeze:
8881 case Instruction::PHI:
8882 case Instruction::Invoke:
8884 case Instruction::Select:
8886 case Instruction::Call:
8890 case Instruction::ICmp:
8891 case Instruction::FCmp:
8892 case Instruction::GetElementPtr:
8906template <
typename CallableT>
8908 const CallableT &Handle) {
8909 switch (
I->getOpcode()) {
8910 case Instruction::Store:
8915 case Instruction::Load:
8922 case Instruction::AtomicCmpXchg:
8927 case Instruction::AtomicRMW:
8932 case Instruction::Call:
8933 case Instruction::Invoke: {
8937 for (
unsigned i = 0; i < CB->
arg_size(); ++i)
8940 CB->
paramHasAttr(i, Attribute::DereferenceableOrNull)) &&
8945 case Instruction::Ret:
8946 if (
I->getFunction()->hasRetAttribute(Attribute::NoUndef) &&
8947 Handle(
I->getOperand(0)))
8950 case Instruction::Switch:
8954 case Instruction::CondBr:
8966template <
typename CallableT>
8968 const CallableT &Handle) {
8971 switch (
I->getOpcode()) {
8973 case Instruction::UDiv:
8974 case Instruction::SDiv:
8975 case Instruction::URem:
8976 case Instruction::SRem:
8977 return Handle(
I->getOperand(1));
8986 I, [&](
const Value *V) {
return KnownPoison.
count(V); });
9005 if (Arg->getParent()->isDeclaration())
9008 Begin = BB->
begin();
9015 unsigned ScanLimit = 32;
9024 if (--ScanLimit == 0)
9028 return WellDefinedOp ==
V;
9048 if (--ScanLimit == 0)
9056 for (
const Use &
Op :
I.operands()) {
9066 if (
I.getOpcode() == Instruction::Select &&
9067 YieldsPoison.
count(
I.getOperand(1)) &&
9068 YieldsPoison.
count(
I.getOperand(2))) {
9074 if (!BB || !Visited.
insert(BB).second)
9084 return ::programUndefinedIfUndefOrPoison(Inst,
false);
9088 return ::programUndefinedIfUndefOrPoison(Inst,
true);
9099 if (!
C->getElementType()->isFloatingPointTy())
9101 for (
unsigned I = 0,
E =
C->getNumElements();
I <
E; ++
I) {
9102 if (
C->getElementAsAPFloat(
I).isNaN())
9116 return !
C->isZero();
9119 if (!
C->getElementType()->isFloatingPointTy())
9121 for (
unsigned I = 0,
E =
C->getNumElements();
I <
E; ++
I) {
9122 if (
C->getElementAsAPFloat(
I).isZero())
9145 if (CmpRHS == FalseVal) {
9195 if (CmpRHS != TrueVal) {
9235 return ConstantInt::get(
V->getType(), ~(*
C));
9287 if ((CmpLHS == TrueVal &&
match(FalseVal,
m_APInt(C2))) ||
9307 assert(
X &&
Y &&
"Invalid operand");
9309 auto IsNegationOf = [&](
const Value *
X,
const Value *
Y) {
9314 if (NeedNSW && !BO->hasNoSignedWrap())
9318 if (!AllowPoison && !
Zero->isNullValue())
9325 if (IsNegationOf(
X,
Y) || IsNegationOf(
Y,
X))
9352 const APInt *RHSC1, *RHSC2;
9363 return CR1.inverse() == CR2;
9397std::optional<std::pair<CmpPredicate, Constant *>>
9400 "Only for relational integer predicates.");
9402 return std::nullopt;
9408 bool WillIncrement =
9413 auto ConstantIsOk = [Pred, WillIncrement, IsSigned](
ConstantInt *
C) {
9414 if (WillIncrement ?
C->isMaxValue(IsSigned) :
C->isMinValue(IsSigned))
9417 if (!Pred.hasSameSign())
9422 return WillIncrement ? !
C->isMaxValue(!IsSigned)
9423 : !
C->isMinValue(!IsSigned);
9426 Constant *SafeReplacementConstant =
nullptr;
9429 if (!ConstantIsOk(CI))
9430 return std::nullopt;
9432 unsigned NumElts = FVTy->getNumElements();
9433 for (
unsigned i = 0; i != NumElts; ++i) {
9434 Constant *Elt =
C->getAggregateElement(i);
9436 return std::nullopt;
9444 if (!CI || !ConstantIsOk(CI))
9445 return std::nullopt;
9447 if (!SafeReplacementConstant)
9448 SafeReplacementConstant = CI;
9452 Value *SplatC =
C->getSplatValue();
9455 if (!CI || !ConstantIsOk(CI))
9456 return std::nullopt;
9459 return std::nullopt;
9466 if (
C->containsUndefOrPoisonElement()) {
9467 assert(SafeReplacementConstant &&
"Replacement constant not set");
9472 Pred.hasSameSign());
9475 Constant *OneOrNegOne = ConstantInt::get(
Type, WillIncrement ? 1 : -1,
true);
9478 return std::make_pair(NewPred, NewC);
9491 Value *OutputZeroVal =
nullptr;
9494 OutputZeroVal = TrueVal;
9497 OutputZeroVal = FalseVal;
9499 if (OutputZeroVal) {
9501 CmpLHS = OutputZeroVal;
9503 CmpRHS = OutputZeroVal;
9522 bool Ordered =
false;
9533 if (LHSSafe && RHSSafe) {
9564 if (TrueVal == CmpRHS && FalseVal == CmpLHS) {
9575 if (TrueVal == CmpLHS && FalseVal == CmpRHS)
9584 auto MaybeSExtOrMulCmpLHS =
9589 if (
match(TrueVal, MaybeSExtOrMulCmpLHS)) {
9610 }
else if (
match(FalseVal, MaybeSExtOrMulCmpLHS)) {
9650 case Instruction::ZExt:
9654 case Instruction::SExt:
9658 case Instruction::Trunc:
9661 CmpConst->
getType() == SrcTy) {
9683 CastedTo = CmpConst;
9685 unsigned ExtOp = CmpI->
isSigned() ? Instruction::SExt : Instruction::ZExt;
9689 case Instruction::FPTrunc:
9692 case Instruction::FPExt:
9695 case Instruction::FPToUI:
9698 case Instruction::FPToSI:
9701 case Instruction::UIToFP:
9704 case Instruction::SIToFP:
9717 if (CastedBack && CastedBack !=
C)
9745 *CastOp = Cast1->getOpcode();
9746 Type *SrcTy = Cast1->getSrcTy();
9749 if (*CastOp == Cast2->getOpcode() && SrcTy == Cast2->getSrcTy())
9750 return Cast2->getOperand(0);
9758 Value *CastedTo =
nullptr;
9759 if (*CastOp == Instruction::Trunc) {
9773 "V2 and Cast1 should be the same type.");
9788 Value *TrueVal =
SI->getTrueValue();
9789 Value *FalseVal =
SI->getFalseValue();
9792 CmpI, TrueVal, FalseVal, LHS, RHS,
SI->getFastMathFlagsOrNone(), CastOp);
9809 if (CastOp && CmpLHS->
getType() != TrueVal->getType()) {
9813 if (*CastOp == Instruction::FPToSI || *CastOp == Instruction::FPToUI)
9815 return ::matchSelectPattern(Pred, FMF, CmpLHS, CmpRHS,
9822 if (*CastOp == Instruction::FPToSI || *CastOp == Instruction::FPToUI)
9824 return ::matchSelectPattern(Pred, FMF, CmpLHS, CmpRHS,
C,
9829 return ::matchSelectPattern(Pred, FMF, CmpLHS, CmpRHS, TrueVal, FalseVal, LHS,
9848 return Intrinsic::umin;
9850 return Intrinsic::umax;
9852 return Intrinsic::smin;
9854 return Intrinsic::smax;
9870 case Intrinsic::smax:
return Intrinsic::smin;
9871 case Intrinsic::smin:
return Intrinsic::smax;
9872 case Intrinsic::umax:
return Intrinsic::umin;
9873 case Intrinsic::umin:
return Intrinsic::umax;
9876 case Intrinsic::maximum:
return Intrinsic::minimum;
9877 case Intrinsic::minimum:
return Intrinsic::maximum;
9878 case Intrinsic::maxnum:
return Intrinsic::minnum;
9879 case Intrinsic::minnum:
return Intrinsic::maxnum;
9880 case Intrinsic::maximumnum:
9881 return Intrinsic::minimumnum;
9882 case Intrinsic::minimumnum:
9883 return Intrinsic::maximumnum;
9898std::pair<Intrinsic::ID, bool>
9903 bool AllCmpSingleUse =
true;
9906 if (
all_of(VL, [&SelectPattern, &AllCmpSingleUse](
Value *
I) {
9912 SelectPattern.
Flavor != CurrentPattern.Flavor)
9914 SelectPattern = CurrentPattern;
9919 switch (SelectPattern.
Flavor) {
9921 return {Intrinsic::smin, AllCmpSingleUse};
9923 return {Intrinsic::umin, AllCmpSingleUse};
9925 return {Intrinsic::smax, AllCmpSingleUse};
9927 return {Intrinsic::umax, AllCmpSingleUse};
9929 return {Intrinsic::maxnum, AllCmpSingleUse};
9931 return {Intrinsic::minnum, AllCmpSingleUse};
9939template <
typename InstTy>
9949 for (
unsigned I = 0;
I != 2; ++
I) {
9954 if (
LHS != PN &&
RHS != PN)
9966template <
typename InstTy>
9973 for (
unsigned I = 0;
I != 2; ++
I) {
9980 if (Op0 != PN && Op1 != PN && Op2 != PN)
9988 }
else if (Op1 == PN) {
10022 if (
I->arg_size() != 2 ||
I->getType() !=
I->getArgOperand(0)->getType() ||
10023 I->getType() !=
I->getArgOperand(1)->getType())
10037 Value *&OtherOp1) {
10038 if (
I->arg_size() != 3 ||
I->getType() !=
I->getArgOperand(0)->getType() ||
10039 I->getType() !=
I->getArgOperand(1)->getType() ||
10040 I->getType() !=
I->getArgOperand(2)->getType())
10070 return !
C->isNegative();
10082 const APInt *CLHS, *CRHS;
10085 return CLHS->
sle(*CRHS);
10123 const APInt *CLHS, *CRHS;
10126 return CLHS->
ule(*CRHS);
10135static std::optional<bool>
10140 return std::nullopt;
10147 return std::nullopt;
10154 return std::nullopt;
10161 return std::nullopt;
10168 return std::nullopt;
10175static std::optional<bool>
10188 return std::nullopt;
10201 return std::nullopt;
10207static std::optional<bool>
10238 const APInt *Unused;
10257 return std::nullopt;
10261 if (L0 == R0 && L1 == R1)
10292 ((
A == R0 &&
B == R1) || (
A == R1 &&
B == R0) ||
10312 const APInt *LC, *RC, *MaskC;
10324 return std::nullopt;
10330static std::optional<bool>
10360 if (L0 == R0 && L1 == R1) {
10361 if ((LPred & RPred) == LPred)
10363 if ((LPred & ~RPred) == LPred)
10371 if (std::optional<ConstantFPRange> DomCR =
10373 if (std::optional<ConstantFPRange> ImpliedCR =
10375 if (ImpliedCR->contains(*DomCR))
10378 if (std::optional<ConstantFPRange> ImpliedCR =
10381 if (ImpliedCR->contains(*DomCR))
10387 return std::nullopt;
10394static std::optional<bool>
10399 assert((
LHS->getOpcode() == Instruction::And ||
10400 LHS->getOpcode() == Instruction::Or ||
10401 LHS->getOpcode() == Instruction::Select) &&
10402 "Expected LHS to be 'and', 'or', or 'select'.");
10409 const Value *ALHS, *ARHS;
10414 ALHS, RHSPred, RHSOp0, RHSOp1,
DL, LHSIsTrue,
Depth + 1))
10415 return Implication;
10417 ARHS, RHSPred, RHSOp0, RHSOp1,
DL, LHSIsTrue,
Depth + 1))
10418 return Implication;
10419 return std::nullopt;
10421 return std::nullopt;
10430 return std::nullopt;
10435 return std::nullopt;
10437 assert(LHS->getType()->isIntOrIntVectorTy(1) &&
10438 "Expected integer type only!");
10442 LHSIsTrue = !LHSIsTrue;
10447 Value *LHSOp0, *LHSOp1;
10450 RHSOp1,
DL, LHSIsTrue);
10453 "Expected floating point type only!");
10456 LHSCmp->getOperand(1), RHSPred, RHSOp0, RHSOp1,
10464 if ((LHSI->getOpcode() == Instruction::And ||
10465 LHSI->getOpcode() == Instruction::Or ||
10466 LHSI->getOpcode() == Instruction::Select))
10470 return std::nullopt;
10475 bool LHSIsTrue,
unsigned Depth) {
10481 bool InvertRHS =
false;
10489 Value *RHSOp0, *RHSOp1;
10493 return InvertRHS ? !*Implied : *Implied;
10494 return std::nullopt;
10498 LHS, RHSCmp->getPredicate(), RHSCmp->getOperand(0),
10499 RHSCmp->getOperand(1),
DL, LHSIsTrue,
Depth))
10500 return InvertRHS ? !*Implied : *Implied;
10501 return std::nullopt;
10505 return std::nullopt;
10509 const Value *RHS1, *RHS2;
10511 if (std::optional<bool> Imp =
10515 if (std::optional<bool> Imp =
10521 if (std::optional<bool> Imp =
10525 if (std::optional<bool> Imp =
10531 return std::nullopt;
10536static std::pair<Value *, bool>
10538 if (!ContextI || !ContextI->
getParent())
10539 return {
nullptr,
false};
10546 return {
nullptr,
false};
10552 return {
nullptr,
false};
10555 if (TrueBB == FalseBB)
10556 return {
nullptr,
false};
10558 assert((TrueBB == ContextBB || FalseBB == ContextBB) &&
10559 "Predecessor block does not point to successor?");
10562 return {PredCond, TrueBB == ContextBB};
10568 assert(
Cond->getType()->isIntOrIntVectorTy(1) &&
"Condition must be bool");
10570 if (PredCond.first)
10572 return std::nullopt;
10581 if (PredCond.first)
10584 return std::nullopt;
10589 bool PreferSignedRange) {
10590 unsigned Width =
Lower.getBitWidth();
10593 case Instruction::Sub:
10603 if (PreferSignedRange && HasNSW && HasNUW)
10609 }
else if (HasNSW) {
10610 if (
C->isNegative()) {
10623 case Instruction::Add:
10632 if (PreferSignedRange && HasNSW && HasNUW)
10638 }
else if (HasNSW) {
10639 if (
C->isNegative()) {
10652 case Instruction::And:
10663 case Instruction::Or:
10669 case Instruction::AShr:
10675 unsigned ShiftAmount = Width - 1;
10676 if (!
C->isZero() && IIQ.
isExact(&BO))
10677 ShiftAmount =
C->countr_zero();
10678 if (
C->isNegative()) {
10681 Upper =
C->ashr(ShiftAmount) + 1;
10684 Lower =
C->ashr(ShiftAmount);
10690 case Instruction::LShr:
10696 unsigned ShiftAmount = Width - 1;
10697 if (!
C->isZero() && IIQ.
isExact(&BO))
10698 ShiftAmount =
C->countr_zero();
10699 Lower =
C->lshr(ShiftAmount);
10704 case Instruction::Shl:
10711 if (
C->isNegative()) {
10713 unsigned ShiftAmount =
C->countl_one() - 1;
10714 Lower =
C->shl(ShiftAmount);
10718 unsigned ShiftAmount =
C->countl_zero() - 1;
10720 Upper =
C->shl(ShiftAmount) + 1;
10739 case Instruction::SDiv:
10743 if (
C->isAllOnes()) {
10746 Lower = IntMin + 1;
10747 Upper = IntMax + 1;
10748 }
else if (
C->countl_zero() < Width - 1) {
10759 if (
C->isMinSignedValue()) {
10771 case Instruction::UDiv:
10781 case Instruction::SRem:
10787 if (
C->isNegative()) {
10798 case Instruction::URem:
10813 bool UseInstrInfo) {
10814 unsigned Width =
II.getType()->getScalarSizeInBits();
10816 switch (
II.getIntrinsicID()) {
10817 case Intrinsic::ctlz:
10818 case Intrinsic::cttz: {
10820 if (!UseInstrInfo || !
match(
II.getArgOperand(1),
m_One()))
10825 case Intrinsic::ctpop:
10828 APInt(Width, Width) + 1);
10829 case Intrinsic::uadd_sat:
10835 case Intrinsic::sadd_sat:
10838 if (
C->isNegative())
10849 case Intrinsic::usub_sat:
10859 case Intrinsic::ssub_sat:
10861 if (
C->isNegative())
10871 if (
C->isNegative())
10882 case Intrinsic::ushl_sat:
10886 case Intrinsic::sshl_sat:
10888 if (
C->isNegative())
10895 case Intrinsic::umin:
10896 case Intrinsic::umax:
10897 case Intrinsic::smin:
10898 case Intrinsic::smax:
10903 switch (
II.getIntrinsicID()) {
10904 case Intrinsic::umin:
10906 case Intrinsic::umax:
10908 case Intrinsic::smin:
10911 case Intrinsic::smax:
10918 case Intrinsic::abs:
10927 case Intrinsic::vscale:
10928 if (!
II.getParent() || !
II.getFunction())
10931 case Intrinsic::read_register:
10932 case Intrinsic::read_volatile_register: {
10934 if (!M || !M->getTargetTriple().isRISCV())
10944 return ConstantRange::getFull(Width);
10949 unsigned BitWidth =
SI.getType()->getScalarSizeInBits();
10953 return ConstantRange::getFull(
BitWidth);
10976 return ConstantRange::getFull(
BitWidth);
10978 switch (R.Flavor) {
10990 return ConstantRange::getFull(
BitWidth);
10997 unsigned BitWidth =
I->getType()->getScalarSizeInBits();
10998 if (!
I->getOperand(0)->getType()->getScalarType()->isHalfTy())
11014 assert(V->getType()->isIntOrIntVectorTy() &&
"Expected integer instruction");
11017 return ConstantRange::getFull(V->getType()->getScalarSizeInBits());
11020 return C->toConstantRange();
11022 unsigned BitWidth = V->getType()->getScalarSizeInBits();
11059 if (std::optional<ConstantRange>
Range =
A->getRange())
11068 if (std::optional<ConstantRange>
Range = CB->getRange())
11091 auto [AdjustedMin, AdjustedMax, AdjustedMaxNonZero] =
11094 DenormalMode Mode =
I->getFunction()->getDenormalMode(FltSem);
11097 MinExp = std::max(AdjustedMin, MinExp);
11098 MaxExp = std::min(NeverLogicalZero ? AdjustedMaxNonZero : AdjustedMax,
11117 "Got assumption for the wrong function!");
11118 assert(
I->getIntrinsicID() == Intrinsic::assume &&
11119 "must be an assume intrinsic");
11122 auto OBU =
I->getOperandBundleAt(AssumeVH.Index);
11133 Value *Arg =
I->getArgOperand(0);
11136 if (!Cmp || Cmp->getOperand(0) != V)
11164 InsertAffected(
Op);
11171 auto AddAffected = [&InsertAffected](
Value *V) {
11175 auto AddCmpOperands = [&AddAffected, IsAssume](
Value *LHS,
Value *RHS) {
11186 while (!Worklist.
empty()) {
11188 if (!Visited.
insert(V).second)
11234 AddCmpOperands(
A,
B);
11270 auto AddNuwSquareOperand = [&AddAffected](
Value *
Op) {
11271 Value *SquareOp =
nullptr;
11273 AddAffected(SquareOp);
11275 AddNuwSquareOperand(
A);
11276 AddNuwSquareOperand(
B);
11281 AddCmpOperands(
A,
B);
11310 if (BO->getOpcode() == Instruction::Add ||
11311 BO->getOpcode() == Instruction::Or) {
11340 unsigned MaxCount,
bool AllowUndefOrPoison) {
11343 auto Push = [&](
const Value *V) ->
bool {
11349 if (Constants.contains(
C))
11351 if (Constants.size() == MaxCount)
11353 Constants.insert(
C);
11358 if (Visited.
insert(Inst).second)
11366 while (!Worklist.
empty()) {
11369 case Instruction::Select:
11375 case Instruction::PHI:
11378 if (IncomingValue == CurInst)
11380 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)
static LLVM_ABI KnownFPClass canonicalize(const KnownFPClass &Src, const fltSemantics &Flt, DenormalMode Mode)
Apply the canonicalize intrinsic to this value.
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 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.
FPOp
The floating-point operations supported by the folding helpers.
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...
LLVM_ABI KnownBits ctlz(bool ZeroIsPoison=false) const
Compute known bits for the count of leading zeros.
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.
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