59#include "llvm/IR/IntrinsicsAArch64.h"
60#include "llvm/IR/IntrinsicsAMDGPU.h"
61#include "llvm/IR/IntrinsicsRISCV.h"
62#include "llvm/IR/IntrinsicsX86.h"
98template <
typename InstTy>
105 if (
unsigned BitWidth = Ty->getScalarSizeInBits())
108 return DL.getPointerTypeSizeInBits(Ty);
128 const APInt &DemandedElts,
132 DemandedLHS = DemandedRHS = DemandedElts;
139 DemandedElts, DemandedLHS, DemandedRHS);
160 bool UseInstrInfo,
unsigned Depth) {
233 R->uge(
LHS->getType()->getScalarSizeInBits()))
247 assert(LHS->getType() == RHS->getType() &&
248 "LHS and RHS should have the same type");
249 assert(LHS->getType()->isIntOrIntVectorTy() &&
250 "LHS and RHS should be integers");
281 return !
I->user_empty() &&
286 return !
I->user_empty() &&
all_of(
I->users(), [](
const User *U) {
288 return match(U, m_ICmp(P, m_Value(), m_Zero())) && ICmpInst::isEquality(P);
297 return ::isKnownToBeAPowerOfTwo(
313 return CI->getValue().isStrictlyPositive();
319 return Known.isNonNegative() &&
326 return V.getKnownBits(SQ).isNegative();
345 return ::isKnownNonEqual(
V1, V2, DemandedElts, Q,
Depth);
352 return Mask.isSubsetOf(
Known.Zero);
359 unsigned Depth = 0) {
370 return ::ComputeNumSignBits(
380 return V->getType()->getScalarSizeInBits() - SignBits + 1;
403 const APInt &DemandedElts,
409 const unsigned BitWidth = Ty->getScalarSizeInBits();
412 if (Ty->isVectorTy())
417 const Value *
A =
nullptr, *
B =
nullptr, *
C =
nullptr, *
D =
nullptr;
420 const auto MatchSubBC = [&]() {
437 const auto MatchASubBC = [&]() {
445 const auto MatchCD = [&]() {
462 if (!Match(Op0, Op1) && !Match(Op1, Op0))
465 const auto ComputeKnownBitsOrOne = [&](
const Value *
V) {
473 const KnownBits KnownA = ComputeKnownBitsOrOne(
A);
477 const KnownBits KnownD = ComputeKnownBitsOrOne(
D);
494 if (SubBC->
getOpcode() == Instruction::Xor &&
512 const unsigned MinimumNumberOfLeadingZeros = UpperBound.
countl_zero();
525 if (Ty->isVectorTy())
528 const Value *Divisor =
nullptr, *
Cond =
nullptr, *Remainder =
nullptr,
529 *AdjustmentValue =
nullptr;
531 const APInt *Threshold =
nullptr;
532 bool TrueIfNegative =
false;
534 const auto Match = [&](
const Value *Rem,
const Value *Adjustment) {
545 if (!Match(Op0, Op1) && !Match(Op1, Op0))
549 bool IsPositiveDivisorCase =
551 bool IsAbsoluteValueCase =
552 match(AdjustmentValue,
555 if (!IsPositiveDivisorCase && !IsAbsoluteValueCase)
572 const APInt &DemandedElts,
577 if (KnownOut.
isUnknown() && !NSW && !NUW) {
606 bool NUW,
const APInt &DemandedElts,
620 bool isKnownNonNegativeOp1 =
Known.isNonNegative();
622 bool isKnownNegativeOp1 =
Known.isNegative();
623 bool isKnownNegativeOp0 = Known2.
isNegative();
626 (isKnownNonNegativeOp1 && isKnownNonNegativeOp0);
638 (isKnownNegativeOp1 && isKnownNonNegativeOp0 &&
640 (isKnownNegativeOp0 && isKnownNonNegativeOp1 &&
Known.isNonZero());
644 bool SelfMultiply = Op0 == Op1;
653 unsigned OutValidBits = 2 * (TyBits - SignBits + 1);
655 if (OutValidBits < TyBits) {
656 APInt KnownZeroMask =
658 Known.Zero |= KnownZeroMask;
668 Known.makeNonNegative();
670 Known.makeNegative();
676 unsigned NumRanges = Ranges.getNumOperands() / 2;
679 Known.setAllConflict();
681 for (
unsigned i = 0; i < NumRanges; ++i) {
690 "Known bit width must match range bit width!");
693 unsigned CommonPrefixBits =
694 (
Range.getUnsignedMax() ^
Range.getUnsignedMin()).countl_zero();
697 Known.One &= UnsignedMax & Mask;
698 Known.Zero &= ~UnsignedMax & Mask;
720 bool ReachesI =
false;
721 while (!WorkList.
empty()) {
723 for (
const User *U :
V->users()) {
729 if (UI->mayHaveSideEffects() || UI->isTerminator())
731 if (Visited.
insert(UI).second)
741 return CI->isAssumeLikeIntrinsic();
749 bool AllowEphemerals) {
761 return AllowEphemerals;
797 unsigned &NumChecked) {
802 if (!CB->hasFnAttr(Attribute::NoFree))
804 }
else if (
I.maySynchronize()) {
815 const BasicBlock *AssumeBB = Assume->getParent();
816 unsigned NumChecked = 0;
818 if (CtxBB == AssumeBB) {
819 if (Assume != CtxI && !Assume->comesBefore(CtxI))
834 while (!Worklist.
empty()) {
836 if (!Visited.
insert(CurBB).second)
839 if (CurBB == AssumeBB) {
845 "Blocks between Assume and CtxI must be dominated by AssumeBB");
861 auto StartIt = (CurBB == CtxBB) ? CtxIter : CurBB->
begin();
895 for (
unsigned ElemIdx = 0, NElem = VC->getNumElements(); ElemIdx < NElem;
898 Pred, VC->getElementAsAPInt(ElemIdx));
907 const PHINode **PhiOut =
nullptr) {
911 CtxIOut =
PHI->getIncomingBlock(*U)->getTerminator();
927 IncPhi && IncPhi->getNumIncomingValues() == 2) {
928 for (
int Idx = 0; Idx < 2; ++Idx) {
929 if (IncPhi->getIncomingValue(Idx) ==
PHI) {
930 ValOut = IncPhi->getIncomingValue(1 - Idx);
933 CtxIOut = IncPhi->getIncomingBlock(1 - Idx)->getTerminator();
952 "Got assumption for the wrong function!");
956 I->getOperandBundleAt(Elem.Index)) &&
986 if (
RHS->getType()->isPointerTy()) {
996 Known.makeNonNegative();
999 Known.makeNegative();
1028 Known.Zero |= ~*
C & *Mask;
1034 Known.One |= *
C & ~*Mask;
1057 Known.One |= *BPow2;
1073 Known.One.setHighBits(
1081 Known.Zero.setHighBits(
1093 Invert ? Cmp->getInversePredicate() : Cmp->getPredicate();
1099 KnownBits DstKnown(
LHS->getType()->getScalarSizeInBits());
1113 bool Invert,
unsigned Depth) {
1177 if (
Known.hasConflict())
1195 "Got assumption for the wrong function!");
1198 auto OBU =
I->getOperandBundleAt(Elem.Index);
1200 case BundleAttr::Align: {
1209 case BundleAttr::Range: {
1225 Value *Arg =
I->getArgOperand(0);
1241 if (Trunc && Trunc->getOperand(0) == V &&
1243 if (Trunc->hasNoUnsignedWrap()) {
1247 Known.One.setBit(0);
1267 if (
Known.hasConflict())
1288 Known.isNonZero() ||
1289 (
Known.getMaxValue().ult(
Known.getBitWidth()) &&
1302 Value *
X =
nullptr, *
Y =
nullptr;
1304 switch (
I->getOpcode()) {
1305 case Instruction::And:
1306 KnownOut = KnownLHS & KnownRHS;
1316 KnownOut = KnownLHS.
blsi();
1318 KnownOut = KnownRHS.
blsi();
1321 case Instruction::Or:
1322 KnownOut = KnownLHS | KnownRHS;
1324 case Instruction::Xor:
1325 KnownOut = KnownLHS ^ KnownRHS;
1335 const KnownBits &XBits =
I->getOperand(0) ==
X ? KnownLHS : KnownRHS;
1336 KnownOut = XBits.
blsmsk();
1349 if (!KnownOut.
Zero[0] && !KnownOut.
One[0] &&
1370 APInt DemandedEltsLHS, DemandedEltsRHS;
1372 DemandedElts, DemandedEltsLHS,
1375 const auto ComputeForSingleOpFunc =
1377 return KnownBitsFunc(
1382 if (DemandedEltsRHS.
isZero())
1383 return ComputeForSingleOpFunc(
I->getOperand(0), DemandedEltsLHS);
1384 if (DemandedEltsLHS.
isZero())
1385 return ComputeForSingleOpFunc(
I->getOperand(1), DemandedEltsRHS);
1387 return ComputeForSingleOpFunc(
I->getOperand(0), DemandedEltsLHS)
1388 .intersectWith(ComputeForSingleOpFunc(
I->getOperand(1), DemandedEltsRHS));
1398 APInt DemandedElts =
1406 Attribute Attr =
F->getFnAttribute(Attribute::VScaleRange);
1414 return ConstantRange::getEmpty(
BitWidth);
1432 if (!MD || MD->getNumOperands() != 1)
1452 if (
F->getFnAttribute(Attribute::VScaleRange).isValid()) {
1461 Value *Arm,
bool Invert,
1464 if (
Known.isConstant())
1491 Known = std::move(CondRes);
1500 "Input should be a Select!");
1510 const Value *LHS2 =
nullptr, *RHS2 =
nullptr;
1522 return CLow->
sle(*CHigh);
1527 const APInt *&CHigh) {
1528 assert((
II->getIntrinsicID() == Intrinsic::smin ||
1529 II->getIntrinsicID() == Intrinsic::smax) &&
1530 "Must be smin/smax");
1534 if (!InnerII || InnerII->getIntrinsicID() != InverseID ||
1539 if (
II->getIntrinsicID() == Intrinsic::smin)
1541 return CLow->
sle(*CHigh);
1546 const APInt *CLow, *CHigh;
1560 unsigned OpNum =
P->getOperand(0) == Start ? 0 : 1;
1562 RecQ.
CtxI =
P->getIncomingBlock(OpNum)->getTerminator();
1565 RecQ.
CtxI =
P->getIncomingBlock(1 - OpNum)->getTerminator();
1570 const APInt &DemandedElts,
1577 switch (
I->getOpcode()) {
1579 case Instruction::Load:
1584 case Instruction::And:
1590 case Instruction::Or:
1596 case Instruction::Xor:
1602 case Instruction::Mul: {
1609 case Instruction::UDiv: {
1616 case Instruction::SDiv: {
1623 case Instruction::Select: {
1624 auto ComputeForArm = [&](
Value *Arm,
bool Invert) {
1632 ComputeForArm(
I->getOperand(1),
false)
1633 .intersectWith(ComputeForArm(
I->getOperand(2),
true));
1636 case Instruction::FPToSI: {
1646 Known.makeNonNegative();
1649 case Instruction::FPTrunc:
1650 case Instruction::FPExt:
1651 case Instruction::FPToUI:
1652 case Instruction::SIToFP:
1653 case Instruction::UIToFP:
1655 case Instruction::PtrToInt:
1656 case Instruction::PtrToAddr:
1657 case Instruction::IntToPtr:
1660 case Instruction::ZExt:
1661 case Instruction::Trunc: {
1662 Type *SrcTy =
I->getOperand(0)->getType();
1664 unsigned SrcBitWidth;
1672 assert(SrcBitWidth &&
"SrcBitWidth can't be zero");
1676 Inst && Inst->hasNonNeg() && !
Known.isNegative())
1677 Known.makeNonNegative();
1681 case Instruction::BitCast: {
1682 Type *SrcTy =
I->getOperand(0)->getType();
1683 if (SrcTy->isIntOrPtrTy() &&
1686 !
I->getType()->isVectorTy()) {
1694 V->getType()->isFPOrFPVectorTy()) {
1695 Type *FPType =
V->getType()->getScalarType();
1699 Known = Result.toKnownBits(FPType->getFltSemantics());
1706 if (!SrcVecTy || !SrcVecTy->getElementType()->isIntegerTy() ||
1707 !
I->getType()->isIntOrIntVectorTy() ||
1715 unsigned SubBitWidth = SrcVecTy->getScalarSizeInBits();
1731 unsigned SubScale =
BitWidth / SubBitWidth;
1733 for (
unsigned i = 0; i != NumElts; ++i) {
1734 if (DemandedElts[i])
1735 SubDemandedElts.
setBit(i * SubScale);
1739 for (
unsigned i = 0; i != SubScale; ++i) {
1742 unsigned ShiftElt = IsLE ? i : SubScale - 1 - i;
1743 Known.insertBits(KnownSrc, ShiftElt * SubBitWidth);
1749 unsigned SubScale = SubBitWidth /
BitWidth;
1751 APInt SubDemandedElts =
1756 Known.setAllConflict();
1757 for (
unsigned i = 0; i != NumElts; ++i) {
1758 if (DemandedElts[i]) {
1759 unsigned Shifts = IsLE ? i : NumElts - 1 - i;
1762 if (
Known.isUnknown())
1769 case Instruction::SExt: {
1771 unsigned SrcBitWidth =
I->getOperand(0)->getType()->getScalarSizeInBits();
1780 case Instruction::Shl: {
1784 bool ShAmtNonZero) {
1785 return KnownBits::shl(KnownVal, KnownAmt, NUW, NSW, ShAmtNonZero);
1791 if (
I->getOperand(0) ==
I->getOperand(1) &&
1794 Known.Zero.setBit(0);
1799 Known.Zero.setLowBits(
C->countr_zero());
1812 Known.Zero.setBitsFrom(
Y + 1);
1816 case Instruction::LShr: {
1819 bool ShAmtNonZero) {
1827 Known.Zero.setHighBits(
C->countl_zero());
1830 case Instruction::AShr: {
1833 bool ShAmtNonZero) {
1840 case Instruction::Sub: {
1847 case Instruction::Add: {
1854 case Instruction::SRem:
1860 case Instruction::URem:
1865 case Instruction::Alloca:
1868 case Instruction::GetElementPtr: {
1875 APInt AccConstIndices(IndexWidth, 0);
1877 auto AddIndexToKnown = [&](
KnownBits IndexBits) {
1886 "Index width can't be larger than pointer width");
1892 for (
unsigned i = 1, e =
I->getNumOperands(); i != e; ++i, ++GTI) {
1894 if (
Known.isUnknown())
1897 Value *Index =
I->getOperand(i);
1908 "Access to structure field must be known at compile time");
1916 AccConstIndices +=
Offset;
1933 CI->getValue().
sextOrTrunc(IndexWidth) * StrideInBytes;
1953 if (!
Known.isUnknown() && !AccConstIndices.
isZero())
1957 case Instruction::PHI: {
1960 Value *Start =
nullptr, *Step =
nullptr;
1974 case Instruction::LShr:
1975 case Instruction::AShr:
1976 case Instruction::Shl:
1977 case Instruction::UDiv:
1984 case Instruction::URem: {
1997 case Instruction::Shl:
2001 case Instruction::LShr:
2002 case Instruction::UDiv:
2003 case Instruction::URem:
2008 case Instruction::AShr:
2017 case Instruction::And: {
2022 KnownStart, KnownStep, Q,
Depth);
2028 case Instruction::Or: {
2033 KnownStart, KnownStep, Q,
Depth);
2042 case Instruction::Add:
2043 case Instruction::Sub:
2044 case Instruction::Mul: {
2049 KnownStart, KnownStep, Q,
Depth);
2068 case Instruction::Add: {
2070 Known.makeNonNegative();
2072 Known.makeNegative();
2078 case Instruction::Sub: {
2082 Known.makeNonNegative();
2084 Known.makeNegative();
2089 case Instruction::Mul:
2091 Known.makeNonNegative();
2113 if (IntrinsicID == Intrinsic::umin || IntrinsicID == Intrinsic::umax) {
2116 P, Start, Step, DemandedElts, KnownStart, KnownStep, Q,
Depth);
2118 if (IntrinsicID == Intrinsic::umin) {
2129 }
else if (
Known.isUnknown() &&
I->getType()->isPointerTy() &&
2131 GEP->getPointerOperand() ==
P) {
2141 unsigned StartIdx =
P->getIncomingValue(0) == Start ? 0 : 1;
2143 RecQ.
CtxI =
P->getIncomingBlock(StartIdx)->getTerminator();
2145 Known.Zero.setLowBits(
2147 Log2(
GEP->getMaxPreservedAlignment(Q.
DL))));
2152 if (
P->getNumIncomingValues() == 0)
2162 Known.setAllConflict();
2163 for (
const Use &U :
P->operands()) {
2191 Value *RHSValue =
nullptr;
2198 if ((TrueSucc == CtxPhi->
getParent()) !=
2220 Known2 = KnownUnion;
2229 if (
Known.isUnknown())
2235 case Instruction::Call:
2236 case Instruction::Invoke: {
2246 if (std::optional<ConstantRange>
Range = CB->getRange())
2249 if (
const Value *RV = CB->getReturnedArgOperand()) {
2250 if (RV->getType() ==
I->getType()) {
2257 if (
Known.hasConflict())
2262 switch (
II->getIntrinsicID()) {
2265 case Intrinsic::abs: {
2267 bool IntMinIsPoison =
match(
II->getArgOperand(1),
m_One());
2271 case Intrinsic::bitreverse:
2275 case Intrinsic::bswap:
2279 case Intrinsic::ctlz: {
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)
4667 case Instruction::SExt:
4668 Tmp = TyBits - U->getOperand(0)->getType()->getScalarSizeInBits();
4672 case Instruction::SDiv: {
4673 const APInt *Denominator;
4686 return std::min(TyBits, NumBits + Denominator->
logBase2());
4691 case Instruction::SRem: {
4694 const APInt *Denominator;
4715 unsigned ResBits = TyBits - Denominator->
ceilLogBase2();
4716 Tmp = std::max(Tmp, ResBits);
4722 case Instruction::AShr: {
4727 if (ShAmt->
uge(TyBits))
4730 Tmp += ShAmtLimited;
4731 if (Tmp > TyBits) Tmp = TyBits;
4735 case Instruction::Shl: {
4740 if (ShAmt->
uge(TyBits))
4745 ShAmt->
uge(TyBits -
X->getType()->getScalarSizeInBits())) {
4747 Tmp += TyBits -
X->getType()->getScalarSizeInBits();
4751 if (ShAmt->
uge(Tmp))
4758 case Instruction::And:
4759 case Instruction::Or:
4760 case Instruction::Xor:
4765 FirstAnswer = std::min(Tmp, Tmp2);
4772 case Instruction::Select: {
4776 const APInt *CLow, *CHigh;
4784 return std::min(Tmp, Tmp2);
4787 case Instruction::Add:
4791 if (Tmp == 1)
break;
4795 if (CRHS->isAllOnesValue()) {
4801 if ((
Known.Zero | 1).isAllOnes())
4806 if (
Known.isNonNegative())
4813 return std::min(Tmp, Tmp2) - 1;
4815 case Instruction::Sub:
4822 if (CLHS->isNullValue()) {
4827 if ((
Known.Zero | 1).isAllOnes())
4833 if (
Known.isNonNegative())
4844 return std::min(Tmp, Tmp2) - 1;
4846 case Instruction::Mul: {
4849 unsigned SignBitsOp0 =
4851 if (SignBitsOp0 == 1)
4853 unsigned SignBitsOp1 =
4855 if (SignBitsOp1 == 1)
4857 unsigned OutValidBits =
4858 (TyBits - SignBitsOp0 + 1) + (TyBits - SignBitsOp1 + 1);
4859 return OutValidBits > TyBits ? 1 : TyBits - OutValidBits + 1;
4862 case Instruction::PHI: {
4866 if (NumIncomingValues > 4)
break;
4868 if (NumIncomingValues == 0)
break;
4874 for (
unsigned i = 0, e = NumIncomingValues; i != e; ++i) {
4875 if (Tmp == 1)
return Tmp;
4878 DemandedElts, RecQ,
Depth + 1));
4883 case Instruction::Trunc: {
4888 unsigned OperandTyBits = U->getOperand(0)->getType()->getScalarSizeInBits();
4889 if (Tmp > (OperandTyBits - TyBits))
4890 return Tmp - (OperandTyBits - TyBits);
4895 case Instruction::ExtractElement:
4902 case Instruction::ShuffleVector: {
4910 APInt DemandedLHS, DemandedRHS;
4915 Tmp = std::numeric_limits<unsigned>::max();
4916 if (!!DemandedLHS) {
4917 const Value *
LHS = Shuf->getOperand(0);
4924 if (!!DemandedRHS) {
4925 const Value *
RHS = Shuf->getOperand(1);
4927 Tmp = std::min(Tmp, Tmp2);
4933 assert(Tmp <= TyBits &&
"Failed to determine minimum sign bits");
4936 case Instruction::Call: {
4938 switch (
II->getIntrinsicID()) {
4941 case Intrinsic::abs:
4949 case Intrinsic::smin:
4950 case Intrinsic::smax: {
4951 const APInt *CLow, *CHigh;
4966 if (
unsigned VecSignBits =
4975 return std::max(FirstAnswer,
Known.countMinSignBits());
4984 if (
F->isIntrinsic())
4985 return F->getIntrinsicID();
4993 LibFunc Func =
TLI->getLibFunc(CB);
4994 if (Func == NotLibFunc)
5003 return Intrinsic::sin;
5007 return Intrinsic::cos;
5011 return Intrinsic::tan;
5015 return Intrinsic::asin;
5019 return Intrinsic::acos;
5023 return Intrinsic::atan;
5025 case LibFunc_atan2f:
5026 case LibFunc_atan2l:
5027 return Intrinsic::atan2;
5031 return Intrinsic::sinh;
5035 return Intrinsic::cosh;
5039 return Intrinsic::tanh;
5043 return Intrinsic::exp;
5047 return Intrinsic::exp2;
5049 case LibFunc_exp10f:
5050 case LibFunc_exp10l:
5051 return Intrinsic::exp10;
5055 return Intrinsic::log;
5057 case LibFunc_log10f:
5058 case LibFunc_log10l:
5059 return Intrinsic::log10;
5063 return Intrinsic::log2;
5067 return Intrinsic::fabs;
5071 return Intrinsic::minnum;
5075 return Intrinsic::maxnum;
5076 case LibFunc_copysign:
5077 case LibFunc_copysignf:
5078 case LibFunc_copysignl:
5079 return Intrinsic::copysign;
5081 case LibFunc_floorf:
5082 case LibFunc_floorl:
5083 return Intrinsic::floor;
5087 return Intrinsic::ceil;
5089 case LibFunc_truncf:
5090 case LibFunc_truncl:
5091 return Intrinsic::trunc;
5095 return Intrinsic::rint;
5096 case LibFunc_nearbyint:
5097 case LibFunc_nearbyintf:
5098 case LibFunc_nearbyintl:
5099 return Intrinsic::nearbyint;
5101 case LibFunc_roundf:
5102 case LibFunc_roundl:
5103 return Intrinsic::round;
5104 case LibFunc_roundeven:
5105 case LibFunc_roundevenf:
5106 case LibFunc_roundevenl:
5107 return Intrinsic::roundeven;
5111 return Intrinsic::pow;
5115 return Intrinsic::sqrt;
5125 bool &TrueIfSigned) {
5128 TrueIfSigned =
true;
5129 return RHS.isZero();
5131 TrueIfSigned =
true;
5132 return RHS.isAllOnes();
5134 TrueIfSigned =
false;
5135 return RHS.isAllOnes();
5137 TrueIfSigned =
false;
5138 return RHS.isZero();
5141 TrueIfSigned =
true;
5142 return RHS.isMaxSignedValue();
5145 TrueIfSigned =
true;
5146 return RHS.isMinSignedValue();
5149 TrueIfSigned =
false;
5150 return RHS.isMinSignedValue();
5153 TrueIfSigned =
false;
5154 return RHS.isMaxSignedValue();
5164 unsigned Depth = 0) {
5190 KnownFromContext.
knownNot(~(CondIsTrue ? MaskIfTrue : MaskIfFalse));
5194 KnownFromContext.
knownNot(CondIsTrue ? ~Mask : Mask);
5200 if (TrueIfSigned == CondIsTrue)
5212static std::tuple<int, int, int>
5226 if (!
match(BI->getCondition(),
5241 bool KnownStrictlyLess =
5246 BI->getSuccessor(IsLessEqual ? 0 : 1));
5249 int Exp =
ilogb(*LimitC) + 1;
5260 MaxExpNonZero = std::min(MaxExpNonZero, Exp);
5261 MaxExp = std::min(MaxExp, std::max(Exp, 0));
5277 return KnownFromContext;
5297 return KnownFromContext;
5307 "Got assumption for the wrong function!");
5308 assert(
I->getIntrinsicID() == Intrinsic::assume &&
5309 "must be an assume intrinsic");
5315 true, Q.
CtxI, KnownFromContext);
5318 return KnownFromContext;
5322 Value *Arm,
bool Invert,
5328 !Invert, SQ.
CtxI, KnownSrc,
5346 APInt DemandedElts =
5352 const APInt &DemandedElts,
5357 if ((InterestedClasses &
5363 KnownSrc, Q,
Depth + 1);
5365 const fltSemantics &DstTy =
Op->getType()->getScalarType()->getFltSemantics();
5367 Op->getOperand(0)->getType()->getScalarType()->getFltSemantics();
5370 const Function *
F =
I ?
I->getFunction() :
nullptr;
5383 unsigned Depth,
bool IsAdd,
bool IsStrict) {
5396 bool WantNaN = (InterestedClasses &
fcNan) !=
fcNone;
5400 if (!WantNaN && !WantNegative && !WantNegZero && !WantSubnormal)
5406 if (InterestedClasses &
fcNan)
5407 InterestedSrcs |=
fcInf;
5412 bool Self =
LHS ==
RHS &&
5415 KnownLHS = KnownRHS;
5419 WantSubnormal || !IsAdd) {
5424 Op->getType()->getScalarType()->getFltSemantics();
5428 if (Self && IsAdd) {
5451 const APInt &DemandedElts,
5462 if (InterestedClasses &
fcNan) {
5484 F ?
F->getDenormalMode(
Op->getType()->getScalarType()->getFltSemantics())
5489 FPClassTest InterestedSrcs = InterestedLHS | InterestedRHS;
5491 if (InterestedSrcs !=
fcNone)
5499 if (InterestedLHS !=
fcNone)
5514 case Intrinsic::minimum:
5516 case Intrinsic::maximum:
5518 case Intrinsic::minimumnum:
5520 case Intrinsic::maximumnum:
5522 case Intrinsic::minnum:
5524 case Intrinsic::maxnum:
5539 const Value *SubFloorX;
5551 assert(
Known.isUnknown() &&
"should not be called with known information");
5553 if (!DemandedElts) {
5583 unsigned NumElts = VFVTy->getNumElements();
5584 for (
unsigned i = 0; i != NumElts; ++i) {
5585 if (!DemandedElts[i])
5608 for (
size_t I = 0,
E = CDS->getNumElements();
I !=
E; ++
I)
5616 for (
const Use &
Op : CA->operands()) {
5631 KnownNotFromFlags |= CB->getRetNoFPClass();
5633 KnownNotFromFlags |= Arg->getNoFPClass();
5637 if (FPOp->hasNoNaNs())
5638 KnownNotFromFlags |=
fcNan;
5639 if (FPOp->hasNoInfs())
5640 KnownNotFromFlags |=
fcInf;
5644 KnownNotFromFlags |= ~AssumedClasses.getKnownFPClasses();
5648 InterestedClasses &= ~KnownNotFromFlags;
5651 Known.knownNot(KnownNotFromFlags);
5654 Known.signBitMustBeOne();
5656 Known.signBitMustBeZero();
5667 const unsigned Opc =
Op->getOpcode();
5669 case Instruction::FNeg: {
5675 case Instruction::Select: {
5676 auto ComputeForArm = [&](
Value *Arm,
bool Invert) {
5686 ComputeForArm(
Op->getOperand(1),
false)
5687 .intersectWith(ComputeForArm(
Op->getOperand(2),
true));
5690 case Instruction::Load: {
5691 const MDNode *NoFPClass =
5701 case Instruction::Call: {
5705 case Intrinsic::fabs: {
5716 case Intrinsic::copysign: {
5722 KnownSign, Q,
Depth + 1);
5723 Known.copysign(KnownSign);
5726 case Intrinsic::fma:
5727 case Intrinsic::fmuladd: {
5731 const bool IsFMA = IID == Intrinsic::fma;
5734 if (
II->getArgOperand(0) ==
II->getArgOperand(1)) {
5735 FPClassTest InterestedSquared = InterestedClasses;
5739 if (InterestedClasses &
fcQNan) {
5746 InterestedAddend, KnownAddend, Q,
Depth + 1);
5748 InterestedSquared, KnownSrc, Q,
Depth + 1);
5752 II->getType()->getScalarType()->getFltSemantics();
5773 for (
int I = 0;
I != 3; ++
I) {
5775 InterestedClasses, KnownSrc[
I], Q,
Depth + 1);
5776 if (KnownSrc[
I].isUnknown())
5787 II->getType()->getScalarType()->getFltSemantics();
5796 case Intrinsic::experimental_constrained_fadd:
5797 case Intrinsic::experimental_constrained_fsub: {
5800 IID == Intrinsic::experimental_constrained_fadd,
5804 case Intrinsic::experimental_constrained_frem: {
5809 case Intrinsic::sqrt:
5810 case Intrinsic::experimental_constrained_sqrt: {
5813 if (InterestedClasses &
fcQNan)
5816 if (InterestedClasses &
fcZero)
5820 KnownSrc, Q,
Depth + 1);
5828 II->getType()->getScalarType()->getFltSemantics();
5838 case Intrinsic::sin: {
5841 KnownSrc, Q,
Depth + 1);
5845 case Intrinsic::cos: {
5848 KnownSrc, Q,
Depth + 1);
5852 case Intrinsic::tan: {
5855 KnownSrc, Q,
Depth + 1);
5859 case Intrinsic::sinh: {
5862 KnownSrc, Q,
Depth + 1);
5866 case Intrinsic::cosh: {
5869 KnownSrc, Q,
Depth + 1);
5873 case Intrinsic::tanh: {
5876 KnownSrc, Q,
Depth + 1);
5880 case Intrinsic::asin: {
5883 KnownSrc, Q,
Depth + 1);
5887 case Intrinsic::acos: {
5890 KnownSrc, Q,
Depth + 1);
5894 case Intrinsic::atan: {
5897 KnownSrc, Q,
Depth + 1);
5901 case Intrinsic::atan2: {
5919 KnownY, Q,
Depth + 1);
5921 KnownX, Q,
Depth + 1);
5925 F ?
F->getDenormalMode(
5926 II->getType()->getScalarType()->getFltSemantics())
5931 case Intrinsic::maxnum:
5932 case Intrinsic::minnum:
5933 case Intrinsic::minimum:
5934 case Intrinsic::maximum:
5935 case Intrinsic::minimumnum:
5936 case Intrinsic::maximumnum: {
5939 KnownLHS, Q,
Depth + 1);
5941 KnownRHS, Q,
Depth + 1);
5946 F ?
F->getDenormalMode(
5947 II->getType()->getScalarType()->getFltSemantics())
5954 case Intrinsic::canonicalize: {
5957 KnownSrc, Q,
Depth + 1);
5961 II->getType()->getScalarType()->getFltSemantics();
5967 case Intrinsic::vector_reduce_fmax:
5968 case Intrinsic::vector_reduce_fmin:
5969 case Intrinsic::vector_reduce_fmaximum:
5970 case Intrinsic::vector_reduce_fminimum:
5971 case Intrinsic::vector_reduce_fmaximumnum:
5972 case Intrinsic::vector_reduce_fminimumnum: {
5976 InterestedClasses, Q,
Depth + 1);
5978 if (!
Known.isKnownNeverNaN())
5979 Known.setSignBit(std::nullopt);
5983 case Intrinsic::vector_reverse:
5986 II->getFastMathFlags(), InterestedClasses, Q,
Depth + 1);
5988 case Intrinsic::trunc:
5989 case Intrinsic::floor:
5990 case Intrinsic::ceil:
5991 case Intrinsic::rint:
5992 case Intrinsic::nearbyint:
5993 case Intrinsic::round:
5994 case Intrinsic::roundeven: {
6007 KnownSrc, Q,
Depth + 1);
6011 F ?
F->getDenormalMode(
6012 II->getType()->getScalarType()->getFltSemantics())
6014 const bool IsMultiUnitFPType =
6015 V->getType()->getScalarType()->isMultiUnitFPType();
6018 case Intrinsic::trunc:
6021 case Intrinsic::floor:
6024 case Intrinsic::ceil:
6034 case Intrinsic::exp:
6035 case Intrinsic::exp2:
6036 case Intrinsic::exp10:
6037 case Intrinsic::amdgcn_exp2: {
6040 KnownSrc, Q,
Depth + 1);
6044 Type *EltTy =
II->getType()->getScalarType();
6045 if (IID == Intrinsic::amdgcn_exp2 && EltTy->
isFloatTy())
6050 case Intrinsic::fptrunc_round: {
6055 case Intrinsic::log:
6056 case Intrinsic::log10:
6057 case Intrinsic::log2:
6058 case Intrinsic::experimental_constrained_log:
6059 case Intrinsic::experimental_constrained_log10:
6060 case Intrinsic::experimental_constrained_log2:
6061 case Intrinsic::amdgcn_log: {
6085 if (InterestedSrcs !=
fcNone)
6087 KnownSrc, Q,
Depth + 1);
6090 F ?
F->getDenormalMode(
6091 II->getType()->getScalarType()->getFltSemantics())
6093 const bool IsMultiUnitFPType =
6094 V->getType()->getScalarType()->isMultiUnitFPType();
6098 case Intrinsic::pow: {
6099 const bool WantNaN = (InterestedClasses &
fcNan) !=
fcNone;
6101 if (!WantNaN && !WantNegative)
6111 InterestedRHS |=
fcNan;
6122 KnownLHS, Q,
Depth + 1);
6131 KnownRHS, Q,
Depth + 1);
6135 case Intrinsic::powi: {
6140 const Value *Exp =
II->getArgOperand(1);
6141 unsigned BitWidth = Exp->getType()->getIntegerBitWidth();
6146 if (InterestedClasses &
fcNan)
6147 InterestedSrcs |=
fcNan;
6148 if (!ExponentKnownBits.
isZero()) {
6149 if (InterestedClasses &
fcInf)
6156 if (InterestedSrcs !=
fcNone)
6158 KnownSrc, Q,
Depth + 1);
6163 case Intrinsic::ldexp: {
6166 KnownSrc, Q,
Depth + 1);
6170 const Value *ExpArg =
II->getArgOperand(1);
6174 : ConstantRange::getFull(
6178 II->getType()->getScalarType()->getFltSemantics();
6188 case Intrinsic::arithmetic_fence: {
6193 case Intrinsic::experimental_constrained_sitofp:
6194 case Intrinsic::experimental_constrained_uitofp:
6204 if (IID == Intrinsic::experimental_constrained_uitofp)
6205 Known.signBitMustBeZero();
6210 case Intrinsic::amdgcn_fract: {
6213 if (InterestedClasses &
fcNan) {
6216 InterestedClasses, KnownSrc, Q,
Depth + 1);
6226 case Intrinsic::amdgcn_rcp: {
6229 KnownSrc, Q,
Depth + 1);
6231 Known.propagateNonNaN(KnownSrc);
6233 Type *EltTy =
II->getType()->getScalarType();
6256 case Intrinsic::amdgcn_rsq: {
6262 KnownSrc, Q,
Depth + 1);
6274 Type *EltTy =
II->getType()->getScalarType();
6294 case Intrinsic::amdgcn_trig_preop: {
6299 case Intrinsic::convert_from_arbitrary_fp: {
6309 II->getType()->getScalarType()->getFltSemantics();
6344 case Instruction::FAdd:
6345 case Instruction::FSub: {
6351 case Instruction::FMul: {
6354 F ?
F->getDenormalMode(
6355 Op->getType()->getScalarType()->getFltSemantics())
6398 case Instruction::FDiv: {
6399 const bool WantNan = (InterestedClasses &
fcNan) !=
fcNone;
6403 Op->getType()->getScalarType()->getFltSemantics();
6407 if (
Op->getOperand(0) ==
Op->getOperand(1) &&
6426 if (!WantNan && !WantNegative && !WantPositive)
6433 bool KnowSomethingUseful =
6438 if (KnowSomethingUseful)
6445 case Instruction::FRem: {
6450 case Instruction::FPExt: {
6453 KnownSrc, Q,
Depth + 1);
6456 Op->getType()->getScalarType()->getFltSemantics();
6458 Op->getOperand(0)->getType()->getScalarType()->getFltSemantics();
6461 const Function *
F =
I ?
I->getFunction() :
nullptr;
6470 case Instruction::FPTrunc: {
6475 case Instruction::SIToFP:
6476 case Instruction::UIToFP: {
6487 if (
Op->getOpcode() == Instruction::UIToFP)
6488 Known.signBitMustBeZero();
6501 if (
Op->getOpcode() == Instruction::SIToFP) {
6506 Known.signBitMustBeZero();
6508 Known.signBitMustBeOne();
6513 if (InterestedClasses &
fcInf) {
6518 if (
Op->getOpcode() == Instruction::UIToFP)
6520 else if (
Op->getOpcode() == Instruction::SIToFP)
6525 Type *FPTy =
Op->getType()->getScalarType();
6532 case Instruction::ExtractElement: {
6535 const Value *Vec =
Op->getOperand(0);
6537 APInt DemandedVecElts;
6539 unsigned NumElts = VecTy->getNumElements();
6542 if (CIdx && CIdx->getValue().ult(NumElts))
6545 DemandedVecElts =
APInt(1, 1);
6551 case Instruction::InsertElement: {
6555 const Value *Vec =
Op->getOperand(0);
6556 const Value *Elt =
Op->getOperand(1);
6559 APInt DemandedVecElts = DemandedElts;
6560 bool NeedsElt =
true;
6562 if (CIdx && CIdx->getValue().ult(NumElts)) {
6563 DemandedVecElts.
clearBit(CIdx->getZExtValue());
6564 NeedsElt = DemandedElts[CIdx->getZExtValue()];
6571 if (
Known.isUnknown())
6578 if (!DemandedVecElts.
isZero()) {
6587 case Instruction::ShuffleVector: {
6596 APInt DemandedLHS, DemandedRHS;
6601 if (!!DemandedLHS) {
6602 const Value *
LHS = Shuf->getOperand(0);
6607 if (
Known.isUnknown())
6613 if (!!DemandedRHS) {
6615 const Value *
RHS = Shuf->getOperand(1);
6623 case Instruction::ExtractValue: {
6630 switch (
II->getIntrinsicID()) {
6631 case Intrinsic::frexp: {
6651 InterestedSrcs, KnownSrc, Q,
Depth + 1);
6655 Op->getType()->getScalarType()->getFltSemantics();
6672 case Instruction::PHI: {
6675 if (
P->getNumIncomingValues() == 0)
6682 if (
Depth < PhiRecursionLimit) {
6689 for (
const Use &U :
P->operands()) {
6720 if (
P->getNumIncomingValues() != 2 ||
Known.cannotBeOrderedLessThanZero())
6722 for (
unsigned I = 0;
I < 2;
I++) {
6723 Value *RecurValue =
P->getIncomingValue(1 -
I);
6731 switch (
II->getIntrinsicID()) {
6732 case Intrinsic::fma:
6733 case Intrinsic::fmuladd: {
6747 case Instruction::BitCast: {
6750 !Src->getType()->isIntOrIntVectorTy())
6753 const Type *Ty =
Op->getType();
6755 Value *CastLHS, *CastRHS;
6767 Known = KnownLHS | KnownRHS;
6786 const APInt &DemandedElts,
6793 return KnownClasses;
6819 InterestedClasses &=
~fcNan;
6821 InterestedClasses &=
~fcInf;
6827 Result.setKnownFPClasses(Result.getKnownFPClasses() & ~
fcNan);
6829 Result.setKnownFPClasses(Result.getKnownFPClasses() & ~
fcInf);
6838 APInt DemandedElts =
6854 return Known.cannotBeOrderedLessThanZero();
6860 return Known.isKnownNeverInfinity();
6867 return Known.isKnownNeverNaN() &&
Known.isKnownNeverInfinity();
6876 return Known.isKnownNeverNaN();
6886 return Known.getSignBit();
6892 if (FPOp->hasNoSignedZeros())
6896 switch (
User->getOpcode()) {
6897 case Instruction::FPToSI:
6898 case Instruction::FPToUI:
6900 case Instruction::FRem:
6902 return U.getOperandNo() == 1;
6903 case Instruction::FCmp:
6906 case Instruction::Call:
6908 switch (
II->getIntrinsicID()) {
6909 case Intrinsic::fabs:
6910 case Intrinsic::exp:
6911 case Intrinsic::exp2:
6912 case Intrinsic::exp10:
6913 case Intrinsic::log:
6914 case Intrinsic::log2:
6915 case Intrinsic::log10:
6916 case Intrinsic::cos:
6917 case Intrinsic::acos:
6918 case Intrinsic::cosh:
6919 case Intrinsic::fptosi_sat:
6920 case Intrinsic::fptoui_sat:
6921 case Intrinsic::lround:
6922 case Intrinsic::llround:
6923 case Intrinsic::lrint:
6924 case Intrinsic::llrint:
6926 case Intrinsic::copysign:
6927 return U.getOperandNo() == 0;
6928 case Intrinsic::pow:
6930 return U.getOperandNo() == 1;
6931 case Intrinsic::is_fpclass: {
6951 if (FPOp->hasNoNaNs())
6955 switch (
User->getOpcode()) {
6956 case Instruction::FPToSI:
6957 case Instruction::FPToUI:
6960 case Instruction::FAdd:
6961 case Instruction::FSub:
6962 case Instruction::FMul:
6963 case Instruction::FDiv:
6964 case Instruction::FRem:
6965 case Instruction::FPTrunc:
6966 case Instruction::FPExt:
6967 case Instruction::FCmp:
6970 case Instruction::FNeg:
6971 case Instruction::Select:
6972 case Instruction::PHI:
6974 case Instruction::Ret:
6975 return User->getFunction()->getAttributes().getRetNoFPClass() &
6977 case Instruction::Call:
6978 case Instruction::Invoke: {
6980 switch (
II->getIntrinsicID()) {
6981 case Intrinsic::fabs:
6983 case Intrinsic::copysign:
6984 return U.getOperandNo() == 0;
6986 case Intrinsic::maxnum:
6987 case Intrinsic::minnum:
6988 case Intrinsic::maximum:
6989 case Intrinsic::minimum:
6990 case Intrinsic::maximumnum:
6991 case Intrinsic::minimumnum:
6992 case Intrinsic::canonicalize:
6993 case Intrinsic::fma:
6994 case Intrinsic::fmuladd:
6995 case Intrinsic::sqrt:
6996 case Intrinsic::pow:
6997 case Intrinsic::powi:
6998 case Intrinsic::fptoui_sat:
6999 case Intrinsic::fptosi_sat:
7000 case Intrinsic::is_fpclass:
7030 switch (
I->getOpcode()) {
7031 case Instruction::SIToFP:
7032 case Instruction::UIToFP:
7040 case Instruction::Call: {
7043 case Intrinsic::trunc:
7044 case Intrinsic::floor:
7045 case Intrinsic::ceil:
7046 case Intrinsic::rint:
7047 case Intrinsic::nearbyint:
7048 case Intrinsic::round:
7049 case Intrinsic::roundeven:
7067 if (V->getType()->isIntegerTy(8))
7078 if (
DL.getTypeStoreSize(V->getType()).isZero())
7093 if (
C->isNullValue())
7102 ConstantInt::get(Ctx, CFP->getValue().bitcastToAPInt()),
DL);
7110 if (CI->getBitWidth() % 8 == 0) {
7111 if (!CI->getValue().isSplat(8))
7113 return ConstantInt::get(Ctx, CI->getValue().trunc(8));
7118 if (CE->getOpcode() == Instruction::IntToPtr) {
7120 unsigned BitWidth =
DL.getPointerSizeInBits(PtrTy->getAddressSpace());
7133 if (LHS == UndefInt8)
7135 if (RHS == UndefInt8)
7141 Value *Val = UndefInt8;
7142 for (uint64_t
I = 0, E = CA->getNumElements();
I != E; ++
I)
7149 Value *Val = UndefInt8;
7184 while (PrevTo != OrigTo) {
7231 unsigned IdxSkip = Idxs.
size();
7244 std::optional<BasicBlock::iterator> InsertBefore) {
7247 if (idx_range.
empty())
7250 assert((V->getType()->isStructTy() || V->getType()->isArrayTy()) &&
7251 "Not looking at a struct or array?");
7253 "Invalid indices for type?");
7256 C =
C->getAggregateElement(idx_range[0]);
7257 if (!
C)
return nullptr;
7264 const unsigned *req_idx = idx_range.
begin();
7265 for (
const unsigned *i =
I->idx_begin(), *e =
I->idx_end();
7266 i != e; ++i, ++req_idx) {
7267 if (req_idx == idx_range.
end()) {
7297 ArrayRef(req_idx, idx_range.
end()), InsertBefore);
7306 unsigned size =
I->getNumIndices() + idx_range.
size();
7311 Idxs.
append(
I->idx_begin(),
I->idx_end());
7317 &&
"Number of indices added not correct?");
7333 unsigned ElementSize, uint64_t
Offset) {
7334 assert(V &&
"V should not be null.");
7335 assert((ElementSize % 8) == 0 &&
7336 "ElementSize expected to be a multiple of the size of a byte.");
7337 unsigned ElementSizeInBytes = ElementSize / 8;
7349 APInt Off(
DL.getIndexTypeSizeInBits(V->getType()), 0);
7356 uint64_t StartIdx =
Off.getLimitedValue();
7363 if ((StartIdx % ElementSizeInBytes) != 0)
7366 Offset += StartIdx / ElementSizeInBytes;
7372 uint64_t SizeInBytes =
DL.getTypeStoreSize(GVTy).getFixedValue();
7373 uint64_t
Length = SizeInBytes / ElementSizeInBytes;
7375 Slice.Array =
nullptr;
7387 Type *InitElTy = ArrayInit->getElementType();
7392 ArrayTy = ArrayInit->getType();
7397 if (ElementSize != 8)
7416 Slice.Array = Array;
7418 Slice.Length = NumElts -
Offset;
7432 if (Slice.Array ==
nullptr) {
7443 if (Slice.Length == 1) {
7455 Str = Str.
substr(Slice.Offset);
7461 Str = Str.substr(0, Str.find(
'\0'));
7474 unsigned CharSize) {
7476 V =
V->stripPointerCasts();
7481 if (!PHIs.
insert(PN).second)
7486 for (
Value *IncValue : PN->incoming_values()) {
7488 if (Len == 0)
return 0;
7490 if (Len == ~0ULL)
continue;
7492 if (Len != LenSoFar && LenSoFar != ~0ULL)
7504 if (Len1 == 0)
return 0;
7506 if (Len2 == 0)
return 0;
7507 if (Len1 == ~0ULL)
return Len2;
7508 if (Len2 == ~0ULL)
return Len1;
7509 if (Len1 != Len2)
return 0;
7518 if (Slice.Array ==
nullptr)
7526 unsigned NullIndex = 0;
7527 for (
unsigned E = Slice.Length; NullIndex <
E; ++NullIndex) {
7528 if (Slice.Array->getElementAsInteger(Slice.Offset + NullIndex) == 0)
7532 return NullIndex + 1;
7538 if (!V->getType()->isPointerTy())
7545 return Len == ~0ULL ? 1 : Len;
7550 bool MustPreserveOffset,
7551 bool MustPreserveProvenance) {
7553 "getArgumentAliasingToReturnedPointer only works on nonnull calls");
7554 if (
const Value *RV =
Call->getReturnedArgOperand())
7558 Call, MustPreserveOffset, MustPreserveProvenance))
7559 return Call->getArgOperand(0);
7565 bool MustPreserveProvenance) {
7566 switch (
Call->getIntrinsicID()) {
7567 case Intrinsic::launder_invariant_group:
7568 case Intrinsic::aarch64_irg:
7569 case Intrinsic::aarch64_tagp:
7579 case Intrinsic::amdgcn_make_buffer_rsrc:
7580 return !MustPreserveProvenance;
7581 case Intrinsic::ptrmask:
7582 return !MustPreserveOffset;
7583 case Intrinsic::threadlocal_address:
7586 return !
Call->getParent()->getParent()->isPresplitCoroutine();
7603 if (!PrevValue || LI->
getLoopFor(PrevValue->getParent()) != L)
7605 if (!PrevValue || LI->
getLoopFor(PrevValue->getParent()) != L)
7614 if (!L->isLoopInvariant(
Load->getPointerOperand()))
7620 bool MustPreserveProvenance) {
7621 for (
unsigned Count = 0; MaxLookup == 0 ||
Count < MaxLookup; ++
Count) {
7623 const Value *PtrOp =
GEP->getPointerOperand();
7634 if (GA->isInterposable())
7636 V = GA->getAliasee();
7640 if (
PHI->getNumIncomingValues() == 1) {
7641 V =
PHI->getIncomingValue(0);
7655 Call,
false, MustPreserveProvenance)) {
7663 assert(V->getType()->isPointerTy() &&
"Unexpected operand type!");
7670 const LoopInfo *LI,
unsigned MaxLookup) {
7678 if (!Visited.
insert(
P).second)
7707 }
while (!Worklist.
empty());
7711 bool MustPreserveProvenance) {
7712 const unsigned MaxVisited = 8;
7717 const Value *Object =
nullptr;
7721 const Value *FirstObject =
7727 MustPreserveProvenance);
7730 if (!Visited.
insert(
P).second)
7733 if (Visited.
size() == MaxVisited)
7749 else if (Object !=
P)
7751 }
while (!Worklist.
empty());
7753 return Object ? Object : FirstObject;
7763 if (U->getOpcode() == Instruction::PtrToInt)
7764 return U->getOperand(0);
7771 if (U->getOpcode() != Instruction::Add ||
7776 V = U->getOperand(0);
7780 assert(
V->getType()->isIntegerTy() &&
"Unexpected operand type!");
7791 bool AllObjectsIdentified =
true;
7798 for (
const Value *V : Objs) {
7799 if (!Visited.
insert(V).second)
7804 if (O->getType()->isPointerTy()) {
7812 }
while (!Working.
empty());
7813 return AllObjectsIdentified;
7821 auto AddWork = [&](
Value *V) {
7822 if (Visited.
insert(V).second)
7832 if (Result && Result != AI)
7836 AddWork(CI->getOperand(0));
7838 for (
Value *IncValue : PN->incoming_values())
7841 AddWork(
SI->getTrueValue());
7842 AddWork(
SI->getFalseValue());
7844 if (OffsetZero && !
GEP->hasAllZeroIndices())
7846 AddWork(
GEP->getPointerOperand());
7848 Value *Returned = CB->getReturnedArgOperand();
7856 }
while (!Worklist.
empty());
7865 return (!Shuffle || Shuffle->isSelect()) &&
7872 bool IgnoreUBImplyingAttrs) {
7874 AC, DT,
TLI, UseVariableInfo,
7875 IgnoreUBImplyingAttrs);
7881 bool UseVariableInfo,
bool IgnoreUBImplyingAttrs) {
7885 auto hasEqualReturnAndLeadingOperandTypes =
7886 [](
const Instruction *Inst,
unsigned NumLeadingOperands) {
7890 for (
unsigned ItOp = 0; ItOp < NumLeadingOperands; ++ItOp)
7896 hasEqualReturnAndLeadingOperandTypes(Inst, 2));
7898 hasEqualReturnAndLeadingOperandTypes(Inst, 1));
7905 case Instruction::UDiv:
7906 case Instruction::URem: {
7913 case Instruction::SDiv:
7914 case Instruction::SRem: {
7916 const APInt *Numerator, *Denominator;
7920 if (*Denominator == 0)
7932 case Instruction::Load: {
7933 if (!UseVariableInfo)
7946 case Instruction::Call: {
7950 const Function *Callee = CI->getCalledFunction();
7954 if (!Callee || !Callee->isSpeculatable())
7958 return IgnoreUBImplyingAttrs || !CI->hasUBImplyingAttrs();
7960 case Instruction::VAArg:
7961 case Instruction::Alloca:
7962 case Instruction::Invoke:
7963 case Instruction::CallBr:
7964 case Instruction::PHI:
7965 case Instruction::Store:
7966 case Instruction::Ret:
7967 case Instruction::UncondBr:
7968 case Instruction::CondBr:
7969 case Instruction::IndirectBr:
7970 case Instruction::Switch:
7971 case Instruction::Unreachable:
7972 case Instruction::Fence:
7973 case Instruction::AtomicRMW:
7974 case Instruction::AtomicCmpXchg:
7975 case Instruction::LandingPad:
7976 case Instruction::Resume:
7977 case Instruction::CatchSwitch:
7978 case Instruction::CatchPad:
7979 case Instruction::CatchRet:
7980 case Instruction::CleanupPad:
7981 case Instruction::CleanupRet:
7987 if (
I.mayReadOrWriteMemory())
8055 unsigned BitWidth = LHS->getType()->getScalarSizeInBits();
8100 if (
Add &&
Add->hasNoSignedWrap()) {
8139 bool LHSOrRHSKnownNonNegative =
8141 bool LHSOrRHSKnownNegative =
8143 if (LHSOrRHSKnownNonNegative || LHSOrRHSKnownNegative) {
8146 if ((AddKnown.
isNonNegative() && LHSOrRHSKnownNonNegative) ||
8147 (AddKnown.
isNegative() && LHSOrRHSKnownNegative))
8222 assert(EVI->getNumIndices() == 1 &&
"Obvious from CI's type");
8224 if (EVI->getIndices()[0] == 0)
8227 assert(EVI->getIndices()[0] == 1 &&
"Obvious from CI's type");
8229 for (
const auto *U : EVI->users())
8240 auto AllUsesGuardedByBranch = [&](
const CondBrInst *BI) {
8244 for (
const auto *Result :
Results) {
8247 if (DT.
dominates(NoWrapEdge, Result->getParent()))
8250 for (
const auto &RU : Result->uses())
8258 return llvm::any_of(GuardingBranches, AllUsesGuardedByBranch);
8270 unsigned NumElts = FVTy->getNumElements();
8271 for (
unsigned i = 0; i < NumElts; ++i)
8272 ShiftAmounts.
push_back(
C->getAggregateElement(i));
8280 return CI && CI->getValue().ult(
C->getType()->getIntegerBitWidth());
8287 bool ConsiderFlagsAndMetadata) {
8289 bool CBHasNoUndef = CB && CB->hasRetAttr(Attribute::NoUndef);
8291 Op->hasPoisonGeneratingAnnotations() && !CBHasNoUndef)
8294 unsigned Opcode =
Op->getOpcode();
8298 case Instruction::Shl:
8299 case Instruction::AShr:
8300 case Instruction::LShr:
8302 case Instruction::FPToSI:
8303 case Instruction::FPToUI:
8307 case Instruction::Call:
8309 switch (
II->getIntrinsicID()) {
8311 case Intrinsic::ctlz:
8312 case Intrinsic::cttz:
8313 case Intrinsic::abs:
8316 case Intrinsic::sshl_sat:
8317 case Intrinsic::ushl_sat:
8325 case Instruction::CallBr:
8326 case Instruction::Invoke: {
8327 return !CBHasNoUndef && !CB->hasFnAttr(Attribute::NoCreateUndefOrPoison);
8329 case Instruction::InsertElement:
8330 case Instruction::ExtractElement: {
8333 unsigned IdxOp =
Op->getOpcode() == Instruction::InsertElement ? 2 : 1;
8337 Idx->getValue().uge(VTy->getElementCount().getKnownMinValue());
8340 case Instruction::ShuffleVector: {
8346 case Instruction::FNeg:
8347 case Instruction::PHI:
8348 case Instruction::Select:
8349 case Instruction::ExtractValue:
8350 case Instruction::InsertValue:
8351 case Instruction::Freeze:
8352 case Instruction::ICmp:
8353 case Instruction::FCmp:
8354 case Instruction::GetElementPtr:
8356 case Instruction::AddrSpaceCast:
8371 bool ConsiderFlagsAndMetadata) {
8373 ConsiderFlagsAndMetadata);
8378 ConsiderFlagsAndMetadata);
8383 if (ValAssumedPoison ==
V)
8386 const unsigned MaxDepth = 2;
8387 if (
Depth >= MaxDepth)
8392 return propagatesPoison(Op) &&
8393 directlyImpliesPoison(ValAssumedPoison, Op, Depth + 1);
8417 const unsigned MaxDepth = 2;
8418 if (
Depth >= MaxDepth)
8424 return impliesPoison(Op, V, Depth + 1);
8431 return ::impliesPoison(ValAssumedPoison, V, 0);
8446 if (
A->hasAttribute(Attribute::NoUndef) ||
8447 A->hasAttribute(Attribute::Dereferenceable) ||
8448 A->hasAttribute(Attribute::DereferenceableOrNull))
8463 if (
C->getType()->isVectorTy() ||
C->getType()->isAggregateType()) {
8466 if (
Constant *SplatC =
C->getSplatValue())
8470 return all_of(CA->operands(), [&](
const Use &
Op) {
8471 return isGuaranteedNotToBeUndefOrPoison(Op.get(), AC, CtxI, DT,
8486 auto *StrippedV =
V->stripPointerCastsSameRepresentation();
8491 auto OpCheck = [&](
const Value *
V) {
8502 if (CB->hasRetAttr(Attribute::NoUndef) ||
8503 CB->hasRetAttr(Attribute::Dereferenceable) ||
8504 CB->hasRetAttr(Attribute::DereferenceableOrNull))
8511 unsigned Num = PN->getNumIncomingValues();
8512 bool IsWellDefined =
true;
8513 for (
unsigned i = 0; i < Num; ++i) {
8514 if (PN == PN->getIncomingValue(i))
8516 auto *TI = PN->getIncomingBlock(i)->getTerminator();
8518 DT,
Depth + 1, Kind)) {
8519 IsWellDefined =
false;
8530 }
else if (
all_of(Opr->operands(), OpCheck))
8536 if (
I->hasMetadata(LLVMContext::MD_noundef) ||
8537 I->hasMetadata(LLVMContext::MD_dereferenceable) ||
8538 I->hasMetadata(LLVMContext::MD_dereferenceable_or_null))
8558 auto *Dominator = DNode->
getIDom();
8563 auto *TI = Dominator->getBlock()->getTerminatorOrNull();
8567 Cond = BI->getCondition();
8569 Cond =
SI->getCondition();
8578 if (
any_of(Opr->operands(), [
V](
const Use &U) {
8579 return V == U && propagatesPoison(U);
8585 Dominator = Dominator->getIDom();
8598 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT,
Depth,
8605 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT,
Depth,
8612 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT,
Depth,
8636 while (!Worklist.
empty()) {
8645 if (
I != Root && !
any_of(
I->operands(), [&KnownPoison](
const Use &U) {
8646 return KnownPoison.contains(U) && propagatesPoison(U);
8650 if (KnownPoison.
insert(
I).second)
8662 return ::computeOverflowForSignedAdd(
Add->getOperand(0),
Add->getOperand(1),
8670 return ::computeOverflowForSignedAdd(LHS, RHS,
nullptr, SQ);
8702 return !
I->mayThrow() &&
I->willReturn();
8716 unsigned ScanLimit) {
8723 assert(ScanLimit &&
"scan limit must be non-zero");
8725 if (--ScanLimit == 0)
8739 if (
I->getParent() != L->getHeader())
return false;
8742 if (&LI ==
I)
return true;
8745 llvm_unreachable(
"Instruction not contained in its own parent basic block.");
8751 case Intrinsic::sadd_with_overflow:
8752 case Intrinsic::ssub_with_overflow:
8753 case Intrinsic::smul_with_overflow:
8754 case Intrinsic::uadd_with_overflow:
8755 case Intrinsic::usub_with_overflow:
8756 case Intrinsic::umul_with_overflow:
8761 case Intrinsic::ctpop:
8762 case Intrinsic::ctlz:
8763 case Intrinsic::cttz:
8764 case Intrinsic::abs:
8765 case Intrinsic::smax:
8766 case Intrinsic::smin:
8767 case Intrinsic::umax:
8768 case Intrinsic::umin:
8769 case Intrinsic::scmp:
8770 case Intrinsic::smulh:
8771 case Intrinsic::umulh:
8772 case Intrinsic::is_fpclass:
8773 case Intrinsic::ptrmask:
8774 case Intrinsic::ucmp:
8775 case Intrinsic::bitreverse:
8776 case Intrinsic::bswap:
8777 case Intrinsic::sadd_sat:
8778 case Intrinsic::ssub_sat:
8779 case Intrinsic::sshl_sat:
8780 case Intrinsic::uadd_sat:
8781 case Intrinsic::usub_sat:
8782 case Intrinsic::ushl_sat:
8783 case Intrinsic::smul_fix:
8784 case Intrinsic::smul_fix_sat:
8785 case Intrinsic::umul_fix:
8786 case Intrinsic::umul_fix_sat:
8787 case Intrinsic::pow:
8788 case Intrinsic::experimental_constrained_pow:
8789 case Intrinsic::powi:
8790 case Intrinsic::experimental_constrained_powi:
8791 case Intrinsic::sin:
8792 case Intrinsic::experimental_constrained_sin:
8793 case Intrinsic::sinh:
8794 case Intrinsic::experimental_constrained_sinh:
8795 case Intrinsic::cos:
8796 case Intrinsic::experimental_constrained_cos:
8797 case Intrinsic::cosh:
8798 case Intrinsic::experimental_constrained_cosh:
8799 case Intrinsic::sincos:
8800 case Intrinsic::sincospi:
8801 case Intrinsic::tan:
8802 case Intrinsic::experimental_constrained_tan:
8803 case Intrinsic::tanh:
8804 case Intrinsic::experimental_constrained_tanh:
8805 case Intrinsic::asin:
8806 case Intrinsic::experimental_constrained_asin:
8807 case Intrinsic::acos:
8808 case Intrinsic::experimental_constrained_acos:
8809 case Intrinsic::atan:
8810 case Intrinsic::experimental_constrained_atan:
8811 case Intrinsic::atan2:
8812 case Intrinsic::experimental_constrained_atan2:
8813 case Intrinsic::canonicalize:
8814 case Intrinsic::sqrt:
8815 case Intrinsic::experimental_constrained_sqrt:
8816 case Intrinsic::fma:
8817 case Intrinsic::experimental_constrained_fma:
8818 case Intrinsic::fmuladd:
8819 case Intrinsic::experimental_constrained_fmuladd:
8820 case Intrinsic::exp:
8821 case Intrinsic::experimental_constrained_exp:
8822 case Intrinsic::exp2:
8823 case Intrinsic::experimental_constrained_exp2:
8824 case Intrinsic::exp10:
8825 case Intrinsic::log:
8826 case Intrinsic::experimental_constrained_log:
8827 case Intrinsic::log2:
8828 case Intrinsic::experimental_constrained_log2:
8829 case Intrinsic::log10:
8830 case Intrinsic::experimental_constrained_log10:
8831 case Intrinsic::modf:
8832 case Intrinsic::floor:
8833 case Intrinsic::experimental_constrained_floor:
8834 case Intrinsic::ceil:
8835 case Intrinsic::experimental_constrained_ceil:
8836 case Intrinsic::trunc:
8837 case Intrinsic::experimental_constrained_trunc:
8838 case Intrinsic::rint:
8839 case Intrinsic::experimental_constrained_rint:
8840 case Intrinsic::nearbyint:
8841 case Intrinsic::experimental_constrained_nearbyint:
8842 case Intrinsic::round:
8843 case Intrinsic::experimental_constrained_round:
8844 case Intrinsic::roundeven:
8845 case Intrinsic::experimental_constrained_roundeven:
8846 case Intrinsic::lrint:
8847 case Intrinsic::experimental_constrained_lrint:
8848 case Intrinsic::llrint:
8849 case Intrinsic::experimental_constrained_llrint:
8850 case Intrinsic::lround:
8851 case Intrinsic::experimental_constrained_lround:
8852 case Intrinsic::llround:
8853 case Intrinsic::experimental_constrained_llround:
8854 case Intrinsic::fshl:
8855 case Intrinsic::fshr:
8856 case Intrinsic::frexp:
8857 case Intrinsic::ldexp:
8858 case Intrinsic::experimental_constrained_ldexp:
8859 case Intrinsic::get_active_lane_mask:
8860 case Intrinsic::mask_beforefirst:
8869 switch (
I->getOpcode()) {
8870 case Instruction::Freeze:
8871 case Instruction::PHI:
8872 case Instruction::Invoke:
8874 case Instruction::Select:
8876 case Instruction::Call:
8880 case Instruction::ICmp:
8881 case Instruction::FCmp:
8882 case Instruction::GetElementPtr:
8896template <
typename CallableT>
8898 const CallableT &Handle) {
8899 switch (
I->getOpcode()) {
8900 case Instruction::Store:
8905 case Instruction::Load:
8912 case Instruction::AtomicCmpXchg:
8917 case Instruction::AtomicRMW:
8922 case Instruction::Call:
8923 case Instruction::Invoke: {
8927 for (
unsigned i = 0; i < CB->
arg_size(); ++i)
8930 CB->
paramHasAttr(i, Attribute::DereferenceableOrNull)) &&
8935 case Instruction::Ret:
8936 if (
I->getFunction()->hasRetAttribute(Attribute::NoUndef) &&
8937 Handle(
I->getOperand(0)))
8940 case Instruction::Switch:
8944 case Instruction::CondBr:
8956template <
typename CallableT>
8958 const CallableT &Handle) {
8961 switch (
I->getOpcode()) {
8963 case Instruction::UDiv:
8964 case Instruction::SDiv:
8965 case Instruction::URem:
8966 case Instruction::SRem:
8967 return Handle(
I->getOperand(1));
8976 I, [&](
const Value *V) {
return KnownPoison.
count(V); });
8995 if (Arg->getParent()->isDeclaration())
8998 Begin = BB->
begin();
9005 unsigned ScanLimit = 32;
9014 if (--ScanLimit == 0)
9018 return WellDefinedOp ==
V;
9038 if (--ScanLimit == 0)
9046 for (
const Use &
Op :
I.operands()) {
9056 if (
I.getOpcode() == Instruction::Select &&
9057 YieldsPoison.
count(
I.getOperand(1)) &&
9058 YieldsPoison.
count(
I.getOperand(2))) {
9064 if (!BB || !Visited.
insert(BB).second)
9074 return ::programUndefinedIfUndefOrPoison(Inst,
false);
9078 return ::programUndefinedIfUndefOrPoison(Inst,
true);
9089 if (!
C->getElementType()->isFloatingPointTy())
9091 for (
unsigned I = 0,
E =
C->getNumElements();
I <
E; ++
I) {
9092 if (
C->getElementAsAPFloat(
I).isNaN())
9106 return !
C->isZero();
9109 if (!
C->getElementType()->isFloatingPointTy())
9111 for (
unsigned I = 0,
E =
C->getNumElements();
I <
E; ++
I) {
9112 if (
C->getElementAsAPFloat(
I).isZero())
9135 if (CmpRHS == FalseVal) {
9185 if (CmpRHS != TrueVal) {
9225 return ConstantInt::get(
V->getType(), ~(*
C));
9277 if ((CmpLHS == TrueVal &&
match(FalseVal,
m_APInt(C2))) ||
9297 assert(
X &&
Y &&
"Invalid operand");
9299 auto IsNegationOf = [&](
const Value *
X,
const Value *
Y) {
9304 if (NeedNSW && !BO->hasNoSignedWrap())
9308 if (!AllowPoison && !
Zero->isNullValue())
9315 if (IsNegationOf(
X,
Y) || IsNegationOf(
Y,
X))
9342 const APInt *RHSC1, *RHSC2;
9353 return CR1.inverse() == CR2;
9387std::optional<std::pair<CmpPredicate, Constant *>>
9390 "Only for relational integer predicates.");
9392 return std::nullopt;
9398 bool WillIncrement =
9403 auto ConstantIsOk = [Pred, WillIncrement, IsSigned](
ConstantInt *
C) {
9404 if (WillIncrement ?
C->isMaxValue(IsSigned) :
C->isMinValue(IsSigned))
9407 if (!Pred.hasSameSign())
9412 return WillIncrement ? !
C->isMaxValue(!IsSigned)
9413 : !
C->isMinValue(!IsSigned);
9416 Constant *SafeReplacementConstant =
nullptr;
9419 if (!ConstantIsOk(CI))
9420 return std::nullopt;
9422 unsigned NumElts = FVTy->getNumElements();
9423 for (
unsigned i = 0; i != NumElts; ++i) {
9424 Constant *Elt =
C->getAggregateElement(i);
9426 return std::nullopt;
9434 if (!CI || !ConstantIsOk(CI))
9435 return std::nullopt;
9437 if (!SafeReplacementConstant)
9438 SafeReplacementConstant = CI;
9442 Value *SplatC =
C->getSplatValue();
9445 if (!CI || !ConstantIsOk(CI))
9446 return std::nullopt;
9449 return std::nullopt;
9456 if (
C->containsUndefOrPoisonElement()) {
9457 assert(SafeReplacementConstant &&
"Replacement constant not set");
9462 Pred.hasSameSign());
9465 Constant *OneOrNegOne = ConstantInt::get(
Type, WillIncrement ? 1 : -1,
true);
9468 return std::make_pair(NewPred, NewC);
9481 Value *OutputZeroVal =
nullptr;
9484 OutputZeroVal = TrueVal;
9487 OutputZeroVal = FalseVal;
9489 if (OutputZeroVal) {
9491 CmpLHS = OutputZeroVal;
9493 CmpRHS = OutputZeroVal;
9512 bool Ordered =
false;
9523 if (LHSSafe && RHSSafe) {
9554 if (TrueVal == CmpRHS && FalseVal == CmpLHS) {
9565 if (TrueVal == CmpLHS && FalseVal == CmpRHS)
9574 auto MaybeSExtOrMulCmpLHS =
9579 if (
match(TrueVal, MaybeSExtOrMulCmpLHS)) {
9600 }
else if (
match(FalseVal, MaybeSExtOrMulCmpLHS)) {
9640 case Instruction::ZExt:
9644 case Instruction::SExt:
9648 case Instruction::Trunc:
9651 CmpConst->
getType() == SrcTy) {
9673 CastedTo = CmpConst;
9675 unsigned ExtOp = CmpI->
isSigned() ? Instruction::SExt : Instruction::ZExt;
9679 case Instruction::FPTrunc:
9682 case Instruction::FPExt:
9685 case Instruction::FPToUI:
9688 case Instruction::FPToSI:
9691 case Instruction::UIToFP:
9694 case Instruction::SIToFP:
9707 if (CastedBack && CastedBack !=
C)
9735 *CastOp = Cast1->getOpcode();
9736 Type *SrcTy = Cast1->getSrcTy();
9739 if (*CastOp == Cast2->getOpcode() && SrcTy == Cast2->getSrcTy())
9740 return Cast2->getOperand(0);
9748 Value *CastedTo =
nullptr;
9749 if (*CastOp == Instruction::Trunc) {
9763 "V2 and Cast1 should be the same type.");
9778 Value *TrueVal =
SI->getTrueValue();
9779 Value *FalseVal =
SI->getFalseValue();
9782 CmpI, TrueVal, FalseVal, LHS, RHS,
SI->getFastMathFlagsOrNone(), CastOp);
9799 if (CastOp && CmpLHS->
getType() != TrueVal->getType()) {
9803 if (*CastOp == Instruction::FPToSI || *CastOp == Instruction::FPToUI)
9805 return ::matchSelectPattern(Pred, FMF, CmpLHS, CmpRHS,
9812 if (*CastOp == Instruction::FPToSI || *CastOp == Instruction::FPToUI)
9814 return ::matchSelectPattern(Pred, FMF, CmpLHS, CmpRHS,
C,
9819 return ::matchSelectPattern(Pred, FMF, CmpLHS, CmpRHS, TrueVal, FalseVal, LHS,
9838 return Intrinsic::umin;
9840 return Intrinsic::umax;
9842 return Intrinsic::smin;
9844 return Intrinsic::smax;
9860 case Intrinsic::smax:
return Intrinsic::smin;
9861 case Intrinsic::smin:
return Intrinsic::smax;
9862 case Intrinsic::umax:
return Intrinsic::umin;
9863 case Intrinsic::umin:
return Intrinsic::umax;
9866 case Intrinsic::maximum:
return Intrinsic::minimum;
9867 case Intrinsic::minimum:
return Intrinsic::maximum;
9868 case Intrinsic::maxnum:
return Intrinsic::minnum;
9869 case Intrinsic::minnum:
return Intrinsic::maxnum;
9870 case Intrinsic::maximumnum:
9871 return Intrinsic::minimumnum;
9872 case Intrinsic::minimumnum:
9873 return Intrinsic::maximumnum;
9888std::pair<Intrinsic::ID, bool>
9893 bool AllCmpSingleUse =
true;
9896 if (
all_of(VL, [&SelectPattern, &AllCmpSingleUse](
Value *
I) {
9902 SelectPattern.
Flavor != CurrentPattern.Flavor)
9904 SelectPattern = CurrentPattern;
9909 switch (SelectPattern.
Flavor) {
9911 return {Intrinsic::smin, AllCmpSingleUse};
9913 return {Intrinsic::umin, AllCmpSingleUse};
9915 return {Intrinsic::smax, AllCmpSingleUse};
9917 return {Intrinsic::umax, AllCmpSingleUse};
9919 return {Intrinsic::maxnum, AllCmpSingleUse};
9921 return {Intrinsic::minnum, AllCmpSingleUse};
9929template <
typename InstTy>
9939 for (
unsigned I = 0;
I != 2; ++
I) {
9944 if (
LHS != PN &&
RHS != PN)
9956template <
typename InstTy>
9963 for (
unsigned I = 0;
I != 2; ++
I) {
9970 if (Op0 != PN && Op1 != PN && Op2 != PN)
9978 }
else if (Op1 == PN) {
10012 if (
I->arg_size() != 2 ||
I->getType() !=
I->getArgOperand(0)->getType() ||
10013 I->getType() !=
I->getArgOperand(1)->getType())
10027 Value *&OtherOp1) {
10028 if (
I->arg_size() != 3 ||
I->getType() !=
I->getArgOperand(0)->getType() ||
10029 I->getType() !=
I->getArgOperand(1)->getType() ||
10030 I->getType() !=
I->getArgOperand(2)->getType())
10060 return !
C->isNegative();
10072 const APInt *CLHS, *CRHS;
10075 return CLHS->
sle(*CRHS);
10113 const APInt *CLHS, *CRHS;
10116 return CLHS->
ule(*CRHS);
10125static std::optional<bool>
10130 return std::nullopt;
10137 return std::nullopt;
10144 return std::nullopt;
10151 return std::nullopt;
10158 return std::nullopt;
10165static std::optional<bool>
10178 return std::nullopt;
10191 return std::nullopt;
10197static std::optional<bool>
10228 const APInt *Unused;
10247 return std::nullopt;
10251 if (L0 == R0 && L1 == R1)
10282 ((
A == R0 &&
B == R1) || (
A == R1 &&
B == R0) ||
10302 const APInt *LC, *RC, *MaskC;
10314 return std::nullopt;
10320static std::optional<bool>
10350 if (L0 == R0 && L1 == R1) {
10351 if ((LPred & RPred) == LPred)
10353 if ((LPred & ~RPred) == LPred)
10361 if (std::optional<ConstantFPRange> DomCR =
10363 if (std::optional<ConstantFPRange> ImpliedCR =
10365 if (ImpliedCR->contains(*DomCR))
10368 if (std::optional<ConstantFPRange> ImpliedCR =
10371 if (ImpliedCR->contains(*DomCR))
10377 return std::nullopt;
10384static std::optional<bool>
10389 assert((
LHS->getOpcode() == Instruction::And ||
10390 LHS->getOpcode() == Instruction::Or ||
10391 LHS->getOpcode() == Instruction::Select) &&
10392 "Expected LHS to be 'and', 'or', or 'select'.");
10399 const Value *ALHS, *ARHS;
10404 ALHS, RHSPred, RHSOp0, RHSOp1,
DL, LHSIsTrue,
Depth + 1))
10405 return Implication;
10407 ARHS, RHSPred, RHSOp0, RHSOp1,
DL, LHSIsTrue,
Depth + 1))
10408 return Implication;
10409 return std::nullopt;
10411 return std::nullopt;
10420 return std::nullopt;
10425 return std::nullopt;
10427 assert(LHS->getType()->isIntOrIntVectorTy(1) &&
10428 "Expected integer type only!");
10432 LHSIsTrue = !LHSIsTrue;
10437 Value *LHSOp0, *LHSOp1;
10440 RHSOp1,
DL, LHSIsTrue);
10443 "Expected floating point type only!");
10446 LHSCmp->getOperand(1), RHSPred, RHSOp0, RHSOp1,
10454 if ((LHSI->getOpcode() == Instruction::And ||
10455 LHSI->getOpcode() == Instruction::Or ||
10456 LHSI->getOpcode() == Instruction::Select))
10460 return std::nullopt;
10465 bool LHSIsTrue,
unsigned Depth) {
10471 bool InvertRHS =
false;
10479 Value *RHSOp0, *RHSOp1;
10483 return InvertRHS ? !*Implied : *Implied;
10484 return std::nullopt;
10488 LHS, RHSCmp->getPredicate(), RHSCmp->getOperand(0),
10489 RHSCmp->getOperand(1),
DL, LHSIsTrue,
Depth))
10490 return InvertRHS ? !*Implied : *Implied;
10491 return std::nullopt;
10495 return std::nullopt;
10499 const Value *RHS1, *RHS2;
10501 if (std::optional<bool> Imp =
10505 if (std::optional<bool> Imp =
10511 if (std::optional<bool> Imp =
10515 if (std::optional<bool> Imp =
10521 return std::nullopt;
10526static std::pair<Value *, bool>
10528 if (!ContextI || !ContextI->
getParent())
10529 return {
nullptr,
false};
10536 return {
nullptr,
false};
10542 return {
nullptr,
false};
10545 if (TrueBB == FalseBB)
10546 return {
nullptr,
false};
10548 assert((TrueBB == ContextBB || FalseBB == ContextBB) &&
10549 "Predecessor block does not point to successor?");
10552 return {PredCond, TrueBB == ContextBB};
10558 assert(
Cond->getType()->isIntOrIntVectorTy(1) &&
"Condition must be bool");
10560 if (PredCond.first)
10562 return std::nullopt;
10571 if (PredCond.first)
10574 return std::nullopt;
10579 bool PreferSignedRange) {
10580 unsigned Width =
Lower.getBitWidth();
10583 case Instruction::Sub:
10593 if (PreferSignedRange && HasNSW && HasNUW)
10599 }
else if (HasNSW) {
10600 if (
C->isNegative()) {
10613 case Instruction::Add:
10622 if (PreferSignedRange && HasNSW && HasNUW)
10628 }
else if (HasNSW) {
10629 if (
C->isNegative()) {
10642 case Instruction::And:
10653 case Instruction::Or:
10659 case Instruction::AShr:
10665 unsigned ShiftAmount = Width - 1;
10666 if (!
C->isZero() && IIQ.
isExact(&BO))
10667 ShiftAmount =
C->countr_zero();
10668 if (
C->isNegative()) {
10671 Upper =
C->ashr(ShiftAmount) + 1;
10674 Lower =
C->ashr(ShiftAmount);
10680 case Instruction::LShr:
10686 unsigned ShiftAmount = Width - 1;
10687 if (!
C->isZero() && IIQ.
isExact(&BO))
10688 ShiftAmount =
C->countr_zero();
10689 Lower =
C->lshr(ShiftAmount);
10694 case Instruction::Shl:
10701 if (
C->isNegative()) {
10703 unsigned ShiftAmount =
C->countl_one() - 1;
10704 Lower =
C->shl(ShiftAmount);
10708 unsigned ShiftAmount =
C->countl_zero() - 1;
10710 Upper =
C->shl(ShiftAmount) + 1;
10729 case Instruction::SDiv:
10733 if (
C->isAllOnes()) {
10736 Lower = IntMin + 1;
10737 Upper = IntMax + 1;
10738 }
else if (
C->countl_zero() < Width - 1) {
10749 if (
C->isMinSignedValue()) {
10761 case Instruction::UDiv:
10771 case Instruction::SRem:
10777 if (
C->isNegative()) {
10788 case Instruction::URem:
10803 bool UseInstrInfo) {
10804 unsigned Width =
II.getType()->getScalarSizeInBits();
10806 switch (
II.getIntrinsicID()) {
10807 case Intrinsic::ctlz:
10808 case Intrinsic::cttz: {
10810 if (!UseInstrInfo || !
match(
II.getArgOperand(1),
m_One()))
10815 case Intrinsic::ctpop:
10818 APInt(Width, Width) + 1);
10819 case Intrinsic::uadd_sat:
10825 case Intrinsic::sadd_sat:
10828 if (
C->isNegative())
10839 case Intrinsic::usub_sat:
10849 case Intrinsic::ssub_sat:
10851 if (
C->isNegative())
10861 if (
C->isNegative())
10872 case Intrinsic::ushl_sat:
10876 case Intrinsic::sshl_sat:
10878 if (
C->isNegative())
10885 case Intrinsic::umin:
10886 case Intrinsic::umax:
10887 case Intrinsic::smin:
10888 case Intrinsic::smax:
10893 switch (
II.getIntrinsicID()) {
10894 case Intrinsic::umin:
10896 case Intrinsic::umax:
10898 case Intrinsic::smin:
10901 case Intrinsic::smax:
10908 case Intrinsic::abs:
10917 case Intrinsic::vscale:
10918 if (!
II.getParent() || !
II.getFunction())
10921 case Intrinsic::read_register:
10922 case Intrinsic::read_volatile_register: {
10924 if (!M || !M->getTargetTriple().isRISCV())
10934 return ConstantRange::getFull(Width);
10939 unsigned BitWidth =
SI.getType()->getScalarSizeInBits();
10943 return ConstantRange::getFull(
BitWidth);
10966 return ConstantRange::getFull(
BitWidth);
10968 switch (R.Flavor) {
10980 return ConstantRange::getFull(
BitWidth);
10987 unsigned BitWidth =
I->getType()->getScalarSizeInBits();
10988 if (!
I->getOperand(0)->getType()->getScalarType()->isHalfTy())
11004 assert(V->getType()->isIntOrIntVectorTy() &&
"Expected integer instruction");
11007 return ConstantRange::getFull(V->getType()->getScalarSizeInBits());
11010 return C->toConstantRange();
11012 unsigned BitWidth = V->getType()->getScalarSizeInBits();
11049 if (std::optional<ConstantRange>
Range =
A->getRange())
11058 if (std::optional<ConstantRange>
Range = CB->getRange())
11081 auto [AdjustedMin, AdjustedMax, AdjustedMaxNonZero] =
11084 DenormalMode Mode =
I->getFunction()->getDenormalMode(FltSem);
11087 MinExp = std::max(AdjustedMin, MinExp);
11088 MaxExp = std::min(NeverLogicalZero ? AdjustedMaxNonZero : AdjustedMax,
11107 "Got assumption for the wrong function!");
11108 assert(
I->getIntrinsicID() == Intrinsic::assume &&
11109 "must be an assume intrinsic");
11112 auto OBU =
I->getOperandBundleAt(AssumeVH.Index);
11123 Value *Arg =
I->getArgOperand(0);
11126 if (!Cmp || Cmp->getOperand(0) != V)
11154 InsertAffected(
Op);
11161 auto AddAffected = [&InsertAffected](
Value *V) {
11165 auto AddCmpOperands = [&AddAffected, IsAssume](
Value *LHS,
Value *RHS) {
11176 while (!Worklist.
empty()) {
11178 if (!Visited.
insert(V).second)
11224 AddCmpOperands(
A,
B);
11260 auto AddNuwSquareOperand = [&AddAffected](
Value *
Op) {
11261 Value *SquareOp =
nullptr;
11263 AddAffected(SquareOp);
11265 AddNuwSquareOperand(
A);
11266 AddNuwSquareOperand(
B);
11271 AddCmpOperands(
A,
B);
11300 if (BO->getOpcode() == Instruction::Add ||
11301 BO->getOpcode() == Instruction::Or) {
11330 unsigned MaxCount,
bool AllowUndefOrPoison) {
11333 auto Push = [&](
const Value *V) ->
bool {
11339 if (Constants.contains(
C))
11341 if (Constants.size() == MaxCount)
11343 Constants.insert(
C);
11348 if (Visited.
insert(Inst).second)
11356 while (!Worklist.
empty()) {
11359 case Instruction::Select:
11365 case Instruction::PHI:
11368 if (IncomingValue == CurInst)
11370 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.
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