57#include "llvm/IR/IntrinsicsAArch64.h"
58#include "llvm/IR/IntrinsicsAMDGPU.h"
59#include "llvm/IR/IntrinsicsRISCV.h"
60#include "llvm/IR/IntrinsicsX86.h"
97 return DL.getPointerTypeSizeInBits(Ty);
109 CxtI = dyn_cast<Instruction>(V);
123 CxtI = dyn_cast<Instruction>(V1);
127 CxtI = dyn_cast<Instruction>(V2);
135 const APInt &DemandedElts,
137 if (isa<ScalableVectorType>(Shuf->
getType())) {
139 DemandedLHS = DemandedRHS = DemandedElts;
146 DemandedElts, DemandedLHS, DemandedRHS);
158 auto *FVTy = dyn_cast<FixedVectorType>(V->getType());
186 V, DemandedElts,
Depth,
242 "LHS and RHS should have the same type");
244 "LHS and RHS should be integers");
255 return !
I->user_empty() &&
all_of(
I->users(), [](
const User *U) {
256 return match(U, m_ICmp(m_Value(), m_Zero()));
261 return !
I->user_empty() &&
all_of(
I->users(), [](
const User *U) {
263 return match(U, m_ICmp(P, m_Value(), m_Zero())) && ICmpInst::isEquality(P);
268 bool OrZero,
unsigned Depth,
271 return ::isKnownToBeAPowerOfTwo(
286 if (
auto *CI = dyn_cast<ConstantInt>(V))
287 return CI->getValue().isStrictlyPositive();
310 if (V1 == V2 || V1->
getType() != V2->getType())
312 auto *FVTy = dyn_cast<FixedVectorType>(V1->
getType());
315 return ::isKnownNonEqual(
316 V1, V2, DemandedElts, 0,
324 return Mask.isSubsetOf(Known.
Zero);
332 auto *FVTy = dyn_cast<FixedVectorType>(V->getType());
342 return ::ComputeNumSignBits(
351 return V->getType()->getScalarSizeInBits() - SignBits + 1;
356 const APInt &DemandedElts,
363 if (KnownOut.
isUnknown() && !NSW && !NUW)
371 bool NUW,
const APInt &DemandedElts,
388 bool isKnownNegativeOp0 = Known2.
isNegative();
391 (isKnownNonNegativeOp1 && isKnownNonNegativeOp0);
403 (isKnownNegativeOp1 && isKnownNonNegativeOp0 &&
405 (isKnownNegativeOp0 && isKnownNonNegativeOp1 && Known.
isNonZero());
409 bool SelfMultiply = Op0 == Op1;
429 unsigned NumRanges = Ranges.getNumOperands() / 2;
435 for (
unsigned i = 0; i < NumRanges; ++i) {
437 mdconst::extract<ConstantInt>(Ranges.getOperand(2 * i + 0));
439 mdconst::extract<ConstantInt>(Ranges.getOperand(2 * i + 1));
443 unsigned CommonPrefixBits =
447 Known.
One &= UnsignedMax & Mask;
448 Known.
Zero &= ~UnsignedMax & Mask;
463 while (!WorkSet.
empty()) {
465 if (!Visited.
insert(V).second)
470 return EphValues.count(U);
475 if (V ==
I || (isa<Instruction>(V) &&
477 !cast<Instruction>(V)->isTerminator())) {
479 if (
const User *U = dyn_cast<User>(V))
491 return CI->isAssumeLikeIntrinsic();
499 bool AllowEphemerals) {
517 if (!AllowEphemerals && Inv == CxtI)
553 if (Pred == ICmpInst::ICMP_UGT)
557 if (Pred == ICmpInst::ICMP_NE)
568 auto *VC = dyn_cast<ConstantDataVector>(
RHS);
572 for (
unsigned ElemIdx = 0, NElem = VC->getNumElements(); ElemIdx < NElem;
575 Pred, VC->getElementAsAPInt(ElemIdx));
594 "Got assumption for the wrong function!");
597 if (!V->getType()->isPointerTy())
600 *
I,
I->bundle_op_info_begin()[Elem.Index])) {
602 (RK.AttrKind == Attribute::NonNull ||
603 (RK.AttrKind == Attribute::Dereferenceable &&
605 V->getType()->getPointerAddressSpace()))) &&
637 case ICmpInst::ICMP_EQ:
640 case ICmpInst::ICMP_SGE:
641 case ICmpInst::ICMP_SGT:
644 case ICmpInst::ICMP_SLT:
662 case ICmpInst::ICMP_EQ:
672 Known.
Zero |= ~*
C & *Mask;
678 Known.
One |= *
C & ~*Mask;
699 Known.
Zero |= RHSKnown.
Zero << ShAmt;
700 Known.
One |= RHSKnown.
One << ShAmt;
703 case ICmpInst::ICMP_NE: {
719 if (Pred == ICmpInst::ICMP_UGT || Pred == ICmpInst::ICMP_UGE) {
725 (*
C + (Pred == ICmpInst::ICMP_UGT)).countLeadingOnes());
727 if (Pred == ICmpInst::ICMP_ULT || Pred == ICmpInst::ICMP_ULE) {
733 (*
C - (Pred == ICmpInst::ICMP_ULT)).countLeadingZeros());
745 Invert ? Cmp->getInversePredicate() : Cmp->getPredicate();
778 if (
auto *Cmp = dyn_cast<ICmpInst>(
Cond))
823 "Got assumption for the wrong function!");
826 if (!V->getType()->isPointerTy())
829 *
I,
I->bundle_op_info_begin()[Elem.Index])) {
833 if (RK.WasOn == V && RK.AttrKind == Attribute::Alignment &&
845 Value *Arg =
I->getArgOperand(0);
865 ICmpInst *Cmp = dyn_cast<ICmpInst>(Arg);
901 Known = KF(Known2, Known, ShAmtNonZero);
912 Value *
X =
nullptr, *
Y =
nullptr;
914 switch (
I->getOpcode()) {
915 case Instruction::And:
916 KnownOut = KnownLHS & KnownRHS;
926 KnownOut = KnownLHS.
blsi();
928 KnownOut = KnownRHS.
blsi();
931 case Instruction::Or:
932 KnownOut = KnownLHS | KnownRHS;
934 case Instruction::Xor:
935 KnownOut = KnownLHS ^ KnownRHS;
945 const KnownBits &XBits =
I->getOperand(0) ==
X ? KnownLHS : KnownRHS;
946 KnownOut = XBits.
blsmsk();
959 if (!KnownOut.
Zero[0] && !KnownOut.
One[0] &&
980 APInt DemandedEltsLHS, DemandedEltsRHS;
982 DemandedElts, DemandedEltsLHS,
985 const auto ComputeForSingleOpFunc =
987 return KnownBitsFunc(
992 if (DemandedEltsRHS.
isZero())
993 return ComputeForSingleOpFunc(
I->getOperand(0), DemandedEltsLHS);
994 if (DemandedEltsLHS.
isZero())
995 return ComputeForSingleOpFunc(
I->getOperand(1), DemandedEltsRHS);
997 return ComputeForSingleOpFunc(
I->getOperand(0), DemandedEltsLHS)
998 .intersectWith(ComputeForSingleOpFunc(
I->getOperand(1), DemandedEltsRHS));
1007 auto *FVTy = dyn_cast<FixedVectorType>(
I->getType());
1008 APInt DemandedElts =
1016 Attribute Attr =
F->getFnAttribute(Attribute::VScaleRange);
1024 return ConstantRange::getEmpty(
BitWidth);
1069 const APInt &DemandedElts,
1075 switch (
I->getOpcode()) {
1077 case Instruction::Load:
1082 case Instruction::And:
1088 case Instruction::Or:
1094 case Instruction::Xor:
1100 case Instruction::Mul: {
1104 DemandedElts, Known, Known2,
Depth, Q);
1107 case Instruction::UDiv: {
1114 case Instruction::SDiv: {
1121 case Instruction::Select: {
1122 auto ComputeForArm = [&](
Value *Arm,
bool Invert) {
1130 ComputeForArm(
I->getOperand(1),
false)
1134 case Instruction::FPTrunc:
1135 case Instruction::FPExt:
1136 case Instruction::FPToUI:
1137 case Instruction::FPToSI:
1138 case Instruction::SIToFP:
1139 case Instruction::UIToFP:
1141 case Instruction::PtrToInt:
1142 case Instruction::IntToPtr:
1145 case Instruction::ZExt:
1146 case Instruction::Trunc: {
1147 Type *SrcTy =
I->getOperand(0)->getType();
1149 unsigned SrcBitWidth;
1157 assert(SrcBitWidth &&
"SrcBitWidth can't be zero");
1160 if (
auto *Inst = dyn_cast<PossiblyNonNegInst>(
I);
1161 Inst && Inst->hasNonNeg() && !Known.
isNegative())
1166 case Instruction::BitCast: {
1167 Type *SrcTy =
I->getOperand(0)->getType();
1171 !
I->getType()->isVectorTy()) {
1179 V->getType()->isFPOrFPVectorTy()) {
1180 Type *FPType = V->getType()->getScalarType();
1193 if (FPClasses &
fcInf)
1205 if (Result.SignBit) {
1206 if (*Result.SignBit)
1216 auto *SrcVecTy = dyn_cast<FixedVectorType>(SrcTy);
1217 if (!SrcVecTy || !SrcVecTy->getElementType()->isIntegerTy() ||
1218 !
I->getType()->isIntOrIntVectorTy() ||
1219 isa<ScalableVectorType>(
I->getType()))
1224 unsigned SubBitWidth = SrcVecTy->getScalarSizeInBits();
1241 unsigned SubScale =
BitWidth / SubBitWidth;
1243 for (
unsigned i = 0; i != NumElts; ++i) {
1244 if (DemandedElts[i])
1245 SubDemandedElts.
setBit(i * SubScale);
1249 for (
unsigned i = 0; i != SubScale; ++i) {
1253 Known.
insertBits(KnownSrc, ShiftElt * SubBitWidth);
1258 case Instruction::SExt: {
1260 unsigned SrcBitWidth =
I->getOperand(0)->getType()->getScalarSizeInBits();
1262 Known = Known.
trunc(SrcBitWidth);
1269 case Instruction::Shl: {
1273 bool ShAmtNonZero) {
1274 return KnownBits::shl(KnownVal, KnownAmt, NUW, NSW, ShAmtNonZero);
1284 case Instruction::LShr: {
1285 bool Exact = Q.
IIQ.
isExact(cast<BinaryOperator>(
I));
1287 bool ShAmtNonZero) {
1298 case Instruction::AShr: {
1299 bool Exact = Q.
IIQ.
isExact(cast<BinaryOperator>(
I));
1301 bool ShAmtNonZero) {
1308 case Instruction::Sub: {
1312 DemandedElts, Known, Known2,
Depth, Q);
1315 case Instruction::Add: {
1319 DemandedElts, Known, Known2,
Depth, Q);
1322 case Instruction::SRem:
1328 case Instruction::URem:
1333 case Instruction::Alloca:
1336 case Instruction::GetElementPtr: {
1345 for (
unsigned i = 1, e =
I->getNumOperands(); i != e; ++i, ++GTI) {
1350 Value *Index =
I->getOperand(i);
1353 Constant *CIndex = dyn_cast<Constant>(Index);
1361 "Access to structure field must be known at compile time");
1366 unsigned Idx = cast<ConstantInt>(Index)->getZExtValue();
1369 AccConstIndices +=
Offset;
1380 unsigned IndexBitWidth = Index->getType()->getScalarSizeInBits();
1394 APInt ScalingFactor(IndexBitWidth, TypeSizeInBytes);
1395 IndexConst *= ScalingFactor;
1419 case Instruction::PHI: {
1422 Value *R =
nullptr, *L =
nullptr;
1435 case Instruction::LShr:
1436 case Instruction::AShr:
1437 case Instruction::Shl:
1438 case Instruction::UDiv:
1445 case Instruction::URem: {
1458 case Instruction::Shl:
1462 case Instruction::LShr:
1463 case Instruction::UDiv:
1464 case Instruction::URem:
1469 case Instruction::AShr:
1481 case Instruction::Add:
1482 case Instruction::Sub:
1483 case Instruction::And:
1484 case Instruction::Or:
1485 case Instruction::Mul: {
1492 unsigned OpNum =
P->getOperand(0) == R ? 0 : 1;
1493 Instruction *RInst =
P->getIncomingBlock(OpNum)->getTerminator();
1494 Instruction *LInst =
P->getIncomingBlock(1 - OpNum)->getTerminator();
1509 auto *OverflowOp = dyn_cast<OverflowingBinaryOperator>(BO);
1523 case Instruction::Add: {
1533 case Instruction::Sub: {
1544 case Instruction::Mul:
1561 if (
P->getNumIncomingValues() == 0)
1568 if (isa_and_nonnull<UndefValue>(
P->hasConstantValue()))
1573 for (
unsigned u = 0, e =
P->getNumIncomingValues(); u < e; ++u) {
1574 Value *IncValue =
P->getIncomingValue(u);
1576 if (IncValue ==
P)
continue;
1580 if (
auto *SI = dyn_cast<SelectInst>(IncValue)) {
1581 if (SI->getTrueValue() ==
P || SI->getFalseValue() ==
P)
1582 IncValue = SI->getTrueValue() ==
P ? SI->getFalseValue()
1583 : SI->getTrueValue();
1591 RecQ.
CxtI =
P->getIncomingBlock(u)->getTerminator();
1613 if ((TrueSucc ==
P->getParent()) != (FalseSucc ==
P->getParent())) {
1615 if (FalseSucc ==
P->getParent())
1629 Known2 = KnownUnion;
1643 case Instruction::Call:
1644 case Instruction::Invoke: {
1652 const auto *CB = cast<CallBase>(
I);
1654 if (std::optional<ConstantRange>
Range = CB->getRange())
1657 if (
const Value *RV = CB->getReturnedArgOperand()) {
1658 if (RV->getType() ==
I->getType()) {
1670 switch (
II->getIntrinsicID()) {
1673 case Intrinsic::abs: {
1675 bool IntMinIsPoison =
match(
II->getArgOperand(1),
m_One());
1676 Known = Known2.
abs(IntMinIsPoison);
1679 case Intrinsic::bitreverse:
1684 case Intrinsic::bswap:
1689 case Intrinsic::ctlz: {
1695 PossibleLZ = std::min(PossibleLZ,
BitWidth - 1);
1700 case Intrinsic::cttz: {
1706 PossibleTZ = std::min(PossibleTZ,
BitWidth - 1);
1711 case Intrinsic::ctpop: {
1722 case Intrinsic::fshr:
1723 case Intrinsic::fshl: {
1730 if (
II->getIntrinsicID() == Intrinsic::fshr)
1743 case Intrinsic::uadd_sat:
1748 case Intrinsic::usub_sat:
1753 case Intrinsic::sadd_sat:
1758 case Intrinsic::ssub_sat:
1764 case Intrinsic::vector_reverse:
1770 case Intrinsic::vector_reduce_and:
1771 case Intrinsic::vector_reduce_or:
1772 case Intrinsic::vector_reduce_umax:
1773 case Intrinsic::vector_reduce_umin:
1774 case Intrinsic::vector_reduce_smax:
1775 case Intrinsic::vector_reduce_smin:
1778 case Intrinsic::vector_reduce_xor: {
1783 auto *VecTy = cast<VectorType>(
I->getOperand(0)->getType());
1785 bool EvenCnt = VecTy->getElementCount().isKnownEven();
1789 if (VecTy->isScalableTy() || EvenCnt)
1793 case Intrinsic::umin:
1798 case Intrinsic::umax:
1803 case Intrinsic::smin:
1808 case Intrinsic::smax:
1813 case Intrinsic::ptrmask: {
1816 const Value *Mask =
I->getOperand(1);
1817 Known2 =
KnownBits(Mask->getType()->getScalarSizeInBits());
1823 case Intrinsic::x86_sse2_pmulh_w:
1824 case Intrinsic::x86_avx2_pmulh_w:
1825 case Intrinsic::x86_avx512_pmulh_w_512:
1830 case Intrinsic::x86_sse2_pmulhu_w:
1831 case Intrinsic::x86_avx2_pmulhu_w:
1832 case Intrinsic::x86_avx512_pmulhu_w_512:
1837 case Intrinsic::x86_sse42_crc32_64_64:
1840 case Intrinsic::x86_ssse3_phadd_d_128:
1841 case Intrinsic::x86_ssse3_phadd_w_128:
1842 case Intrinsic::x86_avx2_phadd_d:
1843 case Intrinsic::x86_avx2_phadd_w: {
1845 I, DemandedElts,
Depth, Q,
1851 case Intrinsic::x86_ssse3_phadd_sw_128:
1852 case Intrinsic::x86_avx2_phadd_sw: {
1857 case Intrinsic::x86_ssse3_phsub_d_128:
1858 case Intrinsic::x86_ssse3_phsub_w_128:
1859 case Intrinsic::x86_avx2_phsub_d:
1860 case Intrinsic::x86_avx2_phsub_w: {
1862 I, DemandedElts,
Depth, Q,
1868 case Intrinsic::x86_ssse3_phsub_sw_128:
1869 case Intrinsic::x86_avx2_phsub_sw: {
1874 case Intrinsic::riscv_vsetvli:
1875 case Intrinsic::riscv_vsetvlimax: {
1876 bool HasAVL =
II->getIntrinsicID() == Intrinsic::riscv_vsetvli;
1879 cast<ConstantInt>(
II->getArgOperand(HasAVL))->getZExtValue());
1881 cast<ConstantInt>(
II->getArgOperand(1 + HasAVL))->getZExtValue());
1888 if (
auto *CI = dyn_cast<ConstantInt>(
II->getArgOperand(0)))
1889 MaxVL = std::min(MaxVL, CI->getZExtValue());
1891 unsigned KnownZeroFirstBit =
Log2_32(MaxVL) + 1;
1896 case Intrinsic::vscale: {
1897 if (!
II->getParent() || !
II->getFunction())
1907 case Instruction::ShuffleVector: {
1908 auto *Shuf = dyn_cast<ShuffleVectorInst>(
I);
1916 APInt DemandedLHS, DemandedRHS;
1923 if (!!DemandedLHS) {
1924 const Value *
LHS = Shuf->getOperand(0);
1930 if (!!DemandedRHS) {
1931 const Value *
RHS = Shuf->getOperand(1);
1937 case Instruction::InsertElement: {
1938 if (isa<ScalableVectorType>(
I->getType())) {
1942 const Value *Vec =
I->getOperand(0);
1943 const Value *Elt =
I->getOperand(1);
1944 auto *CIdx = dyn_cast<ConstantInt>(
I->getOperand(2));
1946 APInt DemandedVecElts = DemandedElts;
1947 bool NeedsElt =
true;
1949 if (CIdx && CIdx->getValue().ult(NumElts)) {
1950 DemandedVecElts.
clearBit(CIdx->getZExtValue());
1951 NeedsElt = DemandedElts[CIdx->getZExtValue()];
1963 if (!DemandedVecElts.
isZero()) {
1969 case Instruction::ExtractElement: {
1972 const Value *Vec =
I->getOperand(0);
1974 auto *CIdx = dyn_cast<ConstantInt>(
Idx);
1975 if (isa<ScalableVectorType>(Vec->
getType())) {
1980 unsigned NumElts = cast<FixedVectorType>(Vec->
getType())->getNumElements();
1982 if (CIdx && CIdx->getValue().ult(NumElts))
1987 case Instruction::ExtractValue:
1992 switch (
II->getIntrinsicID()) {
1994 case Intrinsic::uadd_with_overflow:
1995 case Intrinsic::sadd_with_overflow:
1997 true,
II->getArgOperand(0),
II->getArgOperand(1),
false,
1998 false, DemandedElts, Known, Known2,
Depth, Q);
2000 case Intrinsic::usub_with_overflow:
2001 case Intrinsic::ssub_with_overflow:
2003 false,
II->getArgOperand(0),
II->getArgOperand(1),
false,
2004 false, DemandedElts, Known, Known2,
Depth, Q);
2006 case Intrinsic::umul_with_overflow:
2007 case Intrinsic::smul_with_overflow:
2009 false, DemandedElts, Known, Known2,
Depth, Q);
2015 case Instruction::Freeze:
2059 if (!DemandedElts) {
2065 assert(V &&
"No Value?");
2069 Type *Ty = V->getType();
2073 "Not integer or pointer type!");
2075 if (
auto *FVTy = dyn_cast<FixedVectorType>(Ty)) {
2077 FVTy->getNumElements() == DemandedElts.
getBitWidth() &&
2078 "DemandedElt width should equal the fixed vector number of elements");
2081 "DemandedElt width should be 1 for scalars or scalable vectors");
2087 "V and Known should have same BitWidth");
2090 "V and Known should have same BitWidth");
2101 if (isa<ConstantPointerNull>(V) || isa<ConstantAggregateZero>(V)) {
2108 assert(!isa<ScalableVectorType>(V->getType()));
2112 for (
unsigned i = 0, e = CDV->getNumElements(); i != e; ++i) {
2113 if (!DemandedElts[i])
2115 APInt Elt = CDV->getElementAsAPInt(i);
2124 if (
const auto *CV = dyn_cast<ConstantVector>(V)) {
2125 assert(!isa<ScalableVectorType>(V->getType()));
2129 for (
unsigned i = 0, e = CV->getNumOperands(); i != e; ++i) {
2130 if (!DemandedElts[i])
2133 if (isa<PoisonValue>(Element))
2135 auto *ElementCI = dyn_cast_or_null<ConstantInt>(Element);
2140 const APInt &Elt = ElementCI->getValue();
2153 if (isa<UndefValue>(V))
2158 assert(!isa<ConstantData>(V) &&
"Unhandled constant data!");
2160 if (
const auto *
A = dyn_cast<Argument>(V))
2161 if (std::optional<ConstantRange>
Range =
A->getRange())
2170 if (
const GlobalAlias *GA = dyn_cast<GlobalAlias>(V)) {
2171 if (!GA->isInterposable())
2176 if (
const Operator *
I = dyn_cast<Operator>(V))
2178 else if (
const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
2179 if (std::optional<ConstantRange> CR = GV->getAbsoluteSymbolRange())
2180 Known = CR->toKnownBits();
2184 if (isa<PointerType>(V->getType())) {
2185 Align Alignment = V->getPointerAlignment(Q.
DL);
2201 Value *Start =
nullptr, *Step =
nullptr;
2207 if (U.get() == Start) {
2223 case Instruction::Mul:
2228 case Instruction::SDiv:
2234 case Instruction::UDiv:
2240 case Instruction::Shl:
2242 case Instruction::AShr:
2246 case Instruction::LShr:
2264 Pred = ICmpInst::getInversePredicate(Pred);
2266 if (OrZero && Pred == ICmpInst::ICMP_ULT && *RHSC == 2)
2269 return Pred == ICmpInst::ICMP_EQ && *RHSC == 1;
2280 if (isa<Constant>(V))
2284 if (OrZero && V->getType()->getScalarSizeInBits() == 1)
2319 auto *
I = dyn_cast<Instruction>(V);
2326 return F->hasFnAttribute(Attribute::VScaleRange);
2343 switch (
I->getOpcode()) {
2344 case Instruction::ZExt:
2346 case Instruction::Trunc:
2348 case Instruction::Shl:
2352 case Instruction::LShr:
2353 if (OrZero || Q.
IIQ.
isExact(cast<BinaryOperator>(
I)))
2356 case Instruction::UDiv:
2360 case Instruction::Mul:
2364 case Instruction::And:
2375 case Instruction::Add: {
2381 if (
match(
I->getOperand(0),
2385 if (
match(
I->getOperand(1),
2390 unsigned BitWidth = V->getType()->getScalarSizeInBits();
2399 if ((~(LHSBits.
Zero & RHSBits.
Zero)).isPowerOf2())
2412 case Instruction::Select:
2415 case Instruction::PHI: {
2419 auto *PN = cast<PHINode>(
I);
2436 RecQ.CxtI = PN->getIncomingBlock(U)->getTerminator();
2437 return isKnownToBeAPowerOfTwo(U.get(), OrZero, NewDepth, RecQ);
2440 case Instruction::Invoke:
2441 case Instruction::Call: {
2442 if (
auto *
II = dyn_cast<IntrinsicInst>(
I)) {
2443 switch (
II->getIntrinsicID()) {
2444 case Intrinsic::umax:
2445 case Intrinsic::smax:
2446 case Intrinsic::umin:
2447 case Intrinsic::smin:
2452 case Intrinsic::bitreverse:
2453 case Intrinsic::bswap:
2455 case Intrinsic::fshr:
2456 case Intrinsic::fshl:
2458 if (
II->getArgOperand(0) ==
II->getArgOperand(1))
2482 F =
I->getFunction();
2486 if (!
GEP->hasNoUnsignedWrap() &&
2487 !(
GEP->isInBounds() &&
2492 assert(
GEP->getType()->isPointerTy() &&
"We only support plain pointer GEP");
2503 GTI != GTE; ++GTI) {
2505 if (
StructType *STy = GTI.getStructTypeOrNull()) {
2506 ConstantInt *OpC = cast<ConstantInt>(GTI.getOperand());
2510 if (ElementOffset > 0)
2516 if (GTI.getSequentialElementStride(Q.
DL).isZero())
2521 if (
ConstantInt *OpC = dyn_cast<ConstantInt>(GTI.getOperand())) {
2545 assert(!isa<Constant>(V) &&
"Called for constant?");
2550 unsigned NumUsesExplored = 0;
2551 for (
const auto *U : V->users()) {
2559 if (
const auto *CB = dyn_cast<CallBase>(U))
2560 if (
auto *CalledFunc = CB->getCalledFunction())
2561 for (
const Argument &Arg : CalledFunc->args())
2562 if (CB->getArgOperand(Arg.getArgNo()) == V &&
2563 Arg.hasNonNullAttr(
false) &&
2571 V->getType()->getPointerAddressSpace()) &&
2589 NonNullIfTrue =
true;
2591 NonNullIfTrue =
false;
2597 for (
const auto *CmpU : U->users()) {
2599 if (Visited.
insert(CmpU).second)
2602 while (!WorkList.
empty()) {
2611 for (
const auto *CurrU : Curr->users())
2612 if (Visited.
insert(CurrU).second)
2617 if (
const BranchInst *BI = dyn_cast<BranchInst>(Curr)) {
2618 assert(BI->isConditional() &&
"uses a comparison!");
2621 BI->getSuccessor(NonNullIfTrue ? 0 : 1);
2625 }
else if (NonNullIfTrue &&
isGuard(Curr) &&
2626 DT->
dominates(cast<Instruction>(Curr), CtxI)) {
2640 const unsigned NumRanges = Ranges->getNumOperands() / 2;
2642 for (
unsigned i = 0; i < NumRanges; ++i) {
2644 mdconst::extract<ConstantInt>(Ranges->getOperand(2 * i + 0));
2646 mdconst::extract<ConstantInt>(Ranges->getOperand(2 * i + 1));
2658 Value *Start =
nullptr, *Step =
nullptr;
2659 const APInt *StartC, *StepC;
2665 case Instruction::Add:
2671 case Instruction::Mul:
2674 case Instruction::Shl:
2676 case Instruction::AShr:
2677 case Instruction::LShr:
2693 Value *
Y,
bool NSW,
bool NUW) {
2746 if (
auto *
C = dyn_cast<Constant>(
X))
2750 return ::isKnownNonEqual(
X,
Y, DemandedElts,
Depth, Q);
2755 Value *
Y,
bool NSW,
bool NUW) {
2784 auto ShiftOp = [&](
const APInt &Lhs,
const APInt &Rhs) {
2785 switch (
I->getOpcode()) {
2786 case Instruction::Shl:
2787 return Lhs.
shl(Rhs);
2788 case Instruction::LShr:
2789 return Lhs.
lshr(Rhs);
2790 case Instruction::AShr:
2791 return Lhs.
ashr(Rhs);
2797 auto InvShiftOp = [&](
const APInt &Lhs,
const APInt &Rhs) {
2798 switch (
I->getOpcode()) {
2799 case Instruction::Shl:
2800 return Lhs.
lshr(Rhs);
2801 case Instruction::LShr:
2802 case Instruction::AShr:
2803 return Lhs.
shl(Rhs);
2816 if (MaxShift.
uge(NumBits))
2819 if (!ShiftOp(KnownVal.
One, MaxShift).isZero())
2824 if (InvShiftOp(KnownVal.
Zero, NumBits - MaxShift)
2833 const APInt &DemandedElts,
2836 switch (
I->getOpcode()) {
2837 case Instruction::Alloca:
2839 return I->getType()->getPointerAddressSpace() == 0;
2840 case Instruction::GetElementPtr:
2841 if (
I->getType()->isPointerTy())
2844 case Instruction::BitCast: {
2872 Type *FromTy =
I->getOperand(0)->getType();
2877 case Instruction::IntToPtr:
2881 if (!isa<ScalableVectorType>(
I->getType()) &&
2886 case Instruction::PtrToInt:
2889 if (!isa<ScalableVectorType>(
I->getType()) &&
2894 case Instruction::Trunc:
2896 if (
auto *TI = dyn_cast<TruncInst>(
I))
2897 if (TI->hasNoSignedWrap() || TI->hasNoUnsignedWrap())
2901 case Instruction::Sub:
2904 case Instruction::Xor:
2909 case Instruction::Or:
2916 case Instruction::SExt:
2917 case Instruction::ZExt:
2921 case Instruction::Shl: {
2936 case Instruction::LShr:
2937 case Instruction::AShr: {
2952 case Instruction::UDiv:
2953 case Instruction::SDiv: {
2956 if (cast<PossiblyExactOperator>(
I)->isExact())
2968 if (
I->getOpcode() == Instruction::SDiv) {
2970 XKnown = XKnown.
abs(
false);
2971 YKnown = YKnown.
abs(
false);
2977 return XUgeY && *XUgeY;
2979 case Instruction::Add: {
2984 auto *BO = cast<OverflowingBinaryOperator>(
I);
2989 case Instruction::Mul: {
2995 case Instruction::Select: {
3002 auto SelectArmIsNonZero = [&](
bool IsTrueArm) {
3004 Op = IsTrueArm ?
I->getOperand(1) :
I->getOperand(2);
3017 Pred = ICmpInst::getInversePredicate(Pred);
3022 if (SelectArmIsNonZero(
true) &&
3023 SelectArmIsNonZero(
false))
3027 case Instruction::PHI: {
3028 auto *PN = cast<PHINode>(
I);
3038 RecQ.CxtI = PN->getIncomingBlock(U)->getTerminator();
3042 BasicBlock *TrueSucc, *FalseSucc;
3043 if (match(RecQ.CxtI,
3044 m_Br(m_c_ICmp(Pred, m_Specific(U.get()), m_Value(X)),
3045 m_BasicBlock(TrueSucc), m_BasicBlock(FalseSucc)))) {
3047 if ((TrueSucc == PN->getParent()) != (FalseSucc == PN->getParent())) {
3049 if (FalseSucc == PN->getParent())
3050 Pred = CmpInst::getInversePredicate(Pred);
3051 if (cmpExcludesZero(Pred, X))
3059 case Instruction::InsertElement: {
3060 if (isa<ScalableVectorType>(
I->getType()))
3063 const Value *Vec =
I->getOperand(0);
3064 const Value *Elt =
I->getOperand(1);
3065 auto *CIdx = dyn_cast<ConstantInt>(
I->getOperand(2));
3068 APInt DemandedVecElts = DemandedElts;
3069 bool SkipElt =
false;
3071 if (CIdx && CIdx->getValue().ult(NumElts)) {
3072 DemandedVecElts.
clearBit(CIdx->getZExtValue());
3073 SkipElt = !DemandedElts[CIdx->getZExtValue()];
3079 (DemandedVecElts.
isZero() ||
3082 case Instruction::ExtractElement:
3083 if (
const auto *EEI = dyn_cast<ExtractElementInst>(
I)) {
3084 const Value *Vec = EEI->getVectorOperand();
3085 const Value *
Idx = EEI->getIndexOperand();
3086 auto *CIdx = dyn_cast<ConstantInt>(
Idx);
3087 if (
auto *VecTy = dyn_cast<FixedVectorType>(Vec->
getType())) {
3088 unsigned NumElts = VecTy->getNumElements();
3090 if (CIdx && CIdx->getValue().ult(NumElts))
3096 case Instruction::ShuffleVector: {
3097 auto *Shuf = dyn_cast<ShuffleVectorInst>(
I);
3100 APInt DemandedLHS, DemandedRHS;
3106 return (DemandedRHS.
isZero() ||
3111 case Instruction::Freeze:
3115 case Instruction::Load: {
3116 auto *LI = cast<LoadInst>(
I);
3119 if (
auto *PtrT = dyn_cast<PointerType>(
I->getType())) {
3132 case Instruction::ExtractValue: {
3138 case Instruction::Add:
3143 case Instruction::Sub:
3146 case Instruction::Mul:
3155 case Instruction::Call:
3156 case Instruction::Invoke: {
3157 const auto *Call = cast<CallBase>(
I);
3158 if (
I->getType()->isPointerTy()) {
3159 if (Call->isReturnNonNull())
3166 if (std::optional<ConstantRange>
Range = Call->getRange()) {
3171 if (
const Value *RV = Call->getReturnedArgOperand())
3176 if (
auto *
II = dyn_cast<IntrinsicInst>(
I)) {
3177 switch (
II->getIntrinsicID()) {
3178 case Intrinsic::sshl_sat:
3179 case Intrinsic::ushl_sat:
3180 case Intrinsic::abs:
3181 case Intrinsic::bitreverse:
3182 case Intrinsic::bswap:
3183 case Intrinsic::ctpop:
3187 case Intrinsic::ssub_sat:
3189 II->getArgOperand(0),
II->getArgOperand(1));
3190 case Intrinsic::sadd_sat:
3192 II->getArgOperand(0),
II->getArgOperand(1),
3195 case Intrinsic::vector_reverse:
3199 case Intrinsic::vector_reduce_or:
3200 case Intrinsic::vector_reduce_umax:
3201 case Intrinsic::vector_reduce_umin:
3202 case Intrinsic::vector_reduce_smax:
3203 case Intrinsic::vector_reduce_smin:
3205 case Intrinsic::umax:
3206 case Intrinsic::uadd_sat:
3214 case Intrinsic::smax: {
3217 auto IsNonZero = [&](
Value *
Op, std::optional<bool> &OpNonZero,
3219 if (!OpNonZero.has_value())
3220 OpNonZero = OpKnown.isNonZero() ||
3225 std::optional<bool> Op0NonZero, Op1NonZero;
3229 IsNonZero(
II->getArgOperand(1), Op1NonZero, Op1Known))
3234 IsNonZero(
II->getArgOperand(0), Op0NonZero, Op0Known))
3236 return IsNonZero(
II->getArgOperand(1), Op1NonZero, Op1Known) &&
3237 IsNonZero(
II->getArgOperand(0), Op0NonZero, Op0Known);
3239 case Intrinsic::smin: {
3255 case Intrinsic::umin:
3258 case Intrinsic::cttz:
3261 case Intrinsic::ctlz:
3264 case Intrinsic::fshr:
3265 case Intrinsic::fshl:
3267 if (
II->getArgOperand(0) ==
II->getArgOperand(1))
3270 case Intrinsic::vscale:
3272 case Intrinsic::experimental_get_vector_length:
3286 return Known.
One != 0;
3297 Type *Ty = V->getType();
3302 if (
auto *FVTy = dyn_cast<FixedVectorType>(Ty)) {
3304 FVTy->getNumElements() == DemandedElts.
getBitWidth() &&
3305 "DemandedElt width should equal the fixed vector number of elements");
3308 "DemandedElt width should be 1 for scalars");
3312 if (
auto *
C = dyn_cast<Constant>(V)) {
3313 if (
C->isNullValue())
3315 if (isa<ConstantInt>(
C))
3321 if (
auto *VecTy = dyn_cast<FixedVectorType>(Ty)) {
3322 for (
unsigned i = 0, e = VecTy->getNumElements(); i != e; ++i) {
3323 if (!DemandedElts[i])
3325 Constant *Elt =
C->getAggregateElement(i);
3328 if (!isa<PoisonValue>(Elt) && !isa<ConstantInt>(Elt))
3335 if (
auto *CPA = dyn_cast<ConstantPtrAuth>(V))
3341 if (
const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
3342 if (!GV->isAbsoluteSymbolRef() && !GV->hasExternalWeakLinkage() &&
3343 GV->getType()->getAddressSpace() == 0)
3348 if (!isa<ConstantExpr>(V))
3352 if (
const auto *
A = dyn_cast<Argument>(V))
3353 if (std::optional<ConstantRange>
Range =
A->getRange()) {
3368 if (
PointerType *PtrTy = dyn_cast<PointerType>(Ty)) {
3371 if (
const Argument *
A = dyn_cast<Argument>(V)) {
3372 if (((
A->hasPassPointeeByValueCopyAttr() &&
3374 A->hasNonNullAttr()))
3379 if (
const auto *
I = dyn_cast<Operator>(V))
3383 if (!isa<Constant>(V) &&
3392 auto *FVTy = dyn_cast<FixedVectorType>(V->getType());
3393 APInt DemandedElts =
3395 return ::isKnownNonZero(V, DemandedElts, Q,
Depth);
3404static std::optional<std::pair<Value*, Value*>>
3408 return std::nullopt;
3417 case Instruction::Or:
3418 if (!cast<PossiblyDisjointInst>(Op1)->isDisjoint() ||
3419 !cast<PossiblyDisjointInst>(Op2)->isDisjoint())
3422 case Instruction::Xor:
3423 case Instruction::Add: {
3431 case Instruction::Sub:
3437 case Instruction::Mul: {
3441 auto *OBO1 = cast<OverflowingBinaryOperator>(Op1);
3442 auto *OBO2 = cast<OverflowingBinaryOperator>(Op2);
3443 if ((!OBO1->hasNoUnsignedWrap() || !OBO2->hasNoUnsignedWrap()) &&
3444 (!OBO1->hasNoSignedWrap() || !OBO2->hasNoSignedWrap()))
3450 !cast<ConstantInt>(Op1->
getOperand(1))->isZero())
3454 case Instruction::Shl: {
3457 auto *OBO1 = cast<OverflowingBinaryOperator>(Op1);
3458 auto *OBO2 = cast<OverflowingBinaryOperator>(Op2);
3459 if ((!OBO1->hasNoUnsignedWrap() || !OBO2->hasNoUnsignedWrap()) &&
3460 (!OBO1->hasNoSignedWrap() || !OBO2->hasNoSignedWrap()))
3467 case Instruction::AShr:
3468 case Instruction::LShr: {
3469 auto *PEO1 = cast<PossiblyExactOperator>(Op1);
3470 auto *PEO2 = cast<PossiblyExactOperator>(Op2);
3471 if (!PEO1->isExact() || !PEO2->isExact())
3478 case Instruction::SExt:
3479 case Instruction::ZExt:
3483 case Instruction::PHI: {
3484 const PHINode *PN1 = cast<PHINode>(Op1);
3485 const PHINode *PN2 = cast<PHINode>(Op2);
3491 Value *Start1 =
nullptr, *Step1 =
nullptr;
3493 Value *Start2 =
nullptr, *Step2 =
nullptr;
3500 cast<Operator>(BO2));
3509 if (Values->first != PN1 || Values->second != PN2)
3512 return std::make_pair(Start1, Start2);
3515 return std::nullopt;
3530 case Instruction::Or:
3531 if (!cast<PossiblyDisjointInst>(V1)->isDisjoint())
3534 case Instruction::Xor:
3535 case Instruction::Add:
3553 if (
auto *OBO = dyn_cast<OverflowingBinaryOperator>(V2)) {
3556 (OBO->hasNoUnsignedWrap() || OBO->hasNoSignedWrap()) &&
3557 !
C->isZero() && !
C->isOne() &&
3568 if (
auto *OBO = dyn_cast<OverflowingBinaryOperator>(V2)) {
3571 (OBO->hasNoUnsignedWrap() || OBO->hasNoSignedWrap()) &&
3585 bool UsedFullRecursion =
false;
3587 if (!VisitedBBs.
insert(IncomBB).second)
3591 const APInt *C1, *C2;
3596 if (UsedFullRecursion)
3600 RecQ.
CxtI = IncomBB->getTerminator();
3603 UsedFullRecursion =
true;
3611 const SelectInst *SI1 = dyn_cast<SelectInst>(V1);
3615 if (
const SelectInst *SI2 = dyn_cast<SelectInst>(V2)) {
3617 const Value *Cond2 = SI2->getCondition();
3620 DemandedElts,
Depth + 1, Q) &&
3622 DemandedElts,
Depth + 1, Q);
3635 if (!
A->getType()->isPointerTy() || !
B->getType()->isPointerTy())
3638 auto *GEPA = dyn_cast<GEPOperator>(
A);
3639 if (!GEPA || GEPA->getNumIndices() != 1 || !isa<Constant>(GEPA->idx_begin()))
3643 auto *PN = dyn_cast<PHINode>(GEPA->getPointerOperand());
3644 if (!PN || PN->getNumIncomingValues() != 2)
3649 Value *Start =
nullptr;
3651 if (PN->getIncomingValue(0) == Step)
3652 Start = PN->getIncomingValue(1);
3653 else if (PN->getIncomingValue(1) == Step)
3654 Start = PN->getIncomingValue(0);
3665 APInt StartOffset(IndexWidth, 0);
3666 Start = Start->stripAndAccumulateInBoundsConstantOffsets(Q.
DL, StartOffset);
3667 APInt StepOffset(IndexWidth, 0);
3673 APInt OffsetB(IndexWidth, 0);
3674 B =
B->stripAndAccumulateInBoundsConstantOffsets(Q.
DL, OffsetB);
3675 return Start ==
B &&
3686 if (V1->
getType() != V2->getType())
3696 auto *O1 = dyn_cast<Operator>(V1);
3697 auto *O2 = dyn_cast<Operator>(V2);
3698 if (O1 && O2 && O1->getOpcode() == O2->getOpcode()) {
3703 if (
const PHINode *PN1 = dyn_cast<PHINode>(V1)) {
3704 const PHINode *PN2 = cast<PHINode>(V2);
3760 "Input should be a Select!");
3770 const Value *LHS2 =
nullptr, *RHS2 =
nullptr;
3782 return CLow->
sle(*CHigh);
3787 const APInt *&CHigh) {
3788 assert((
II->getIntrinsicID() == Intrinsic::smin ||
3789 II->getIntrinsicID() == Intrinsic::smax) &&
"Must be smin/smax");
3792 auto *InnerII = dyn_cast<IntrinsicInst>(
II->getArgOperand(0));
3793 if (!InnerII || InnerII->getIntrinsicID() != InverseID ||
3798 if (
II->getIntrinsicID() == Intrinsic::smin)
3800 return CLow->
sle(*CHigh);
3808 const APInt &DemandedElts,
3810 const auto *CV = dyn_cast<Constant>(V);
3811 if (!CV || !isa<FixedVectorType>(CV->getType()))
3814 unsigned MinSignBits = TyBits;
3815 unsigned NumElts = cast<FixedVectorType>(CV->getType())->getNumElements();
3816 for (
unsigned i = 0; i != NumElts; ++i) {
3817 if (!DemandedElts[i])
3820 auto *Elt = dyn_cast_or_null<ConstantInt>(CV->getAggregateElement(i));
3824 MinSignBits = std::min(MinSignBits, Elt->getValue().getNumSignBits());
3831 const APInt &DemandedElts,
3837 assert(Result > 0 &&
"At least one sign bit needs to be present!");
3849 const APInt &DemandedElts,
3851 Type *Ty = V->getType();
3855 if (
auto *FVTy = dyn_cast<FixedVectorType>(Ty)) {
3857 FVTy->getNumElements() == DemandedElts.
getBitWidth() &&
3858 "DemandedElt width should equal the fixed vector number of elements");
3861 "DemandedElt width should be 1 for scalars");
3875 unsigned FirstAnswer = 1;
3883 if (
auto *U = dyn_cast<Operator>(V)) {
3886 case Instruction::SExt:
3887 Tmp = TyBits - U->getOperand(0)->getType()->getScalarSizeInBits();
3891 case Instruction::SDiv: {
3892 const APInt *Denominator;
3905 return std::min(TyBits, NumBits + Denominator->
logBase2());
3910 case Instruction::SRem: {
3913 const APInt *Denominator;
3934 unsigned ResBits = TyBits - Denominator->
ceilLogBase2();
3935 Tmp = std::max(Tmp, ResBits);
3941 case Instruction::AShr: {
3946 if (ShAmt->
uge(TyBits))
3949 Tmp += ShAmtLimited;
3950 if (Tmp > TyBits) Tmp = TyBits;
3954 case Instruction::Shl: {
3959 if (ShAmt->
uge(TyBits))
3964 ShAmt->
uge(TyBits -
X->getType()->getScalarSizeInBits())) {
3966 Tmp += TyBits -
X->getType()->getScalarSizeInBits();
3970 if (ShAmt->
uge(Tmp))
3977 case Instruction::And:
3978 case Instruction::Or:
3979 case Instruction::Xor:
3984 FirstAnswer = std::min(Tmp, Tmp2);
3991 case Instruction::Select: {
3995 const APInt *CLow, *CHigh;
4003 return std::min(Tmp, Tmp2);
4006 case Instruction::Add:
4010 if (Tmp == 1)
break;
4013 if (
const auto *CRHS = dyn_cast<Constant>(U->getOperand(1)))
4014 if (CRHS->isAllOnesValue()) {
4020 if ((Known.
Zero | 1).isAllOnes())
4032 return std::min(Tmp, Tmp2) - 1;
4034 case Instruction::Sub:
4040 if (
const auto *CLHS = dyn_cast<Constant>(U->getOperand(0)))
4041 if (CLHS->isNullValue()) {
4046 if ((Known.
Zero | 1).isAllOnes())
4063 return std::min(Tmp, Tmp2) - 1;
4065 case Instruction::Mul: {
4068 unsigned SignBitsOp0 =
4070 if (SignBitsOp0 == 1)
4072 unsigned SignBitsOp1 =
4074 if (SignBitsOp1 == 1)
4076 unsigned OutValidBits =
4077 (TyBits - SignBitsOp0 + 1) + (TyBits - SignBitsOp1 + 1);
4078 return OutValidBits > TyBits ? 1 : TyBits - OutValidBits + 1;
4081 case Instruction::PHI: {
4082 const PHINode *PN = cast<PHINode>(U);
4085 if (NumIncomingValues > 4)
break;
4087 if (NumIncomingValues == 0)
break;
4093 for (
unsigned i = 0, e = NumIncomingValues; i != e; ++i) {
4094 if (Tmp == 1)
return Tmp;
4097 DemandedElts,
Depth + 1, RecQ));
4102 case Instruction::Trunc: {
4107 unsigned OperandTyBits = U->getOperand(0)->getType()->getScalarSizeInBits();
4108 if (Tmp > (OperandTyBits - TyBits))
4109 return Tmp - (OperandTyBits - TyBits);
4114 case Instruction::ExtractElement:
4121 case Instruction::ShuffleVector: {
4124 auto *Shuf = dyn_cast<ShuffleVectorInst>(U);
4129 APInt DemandedLHS, DemandedRHS;
4134 Tmp = std::numeric_limits<unsigned>::max();
4135 if (!!DemandedLHS) {
4136 const Value *
LHS = Shuf->getOperand(0);
4143 if (!!DemandedRHS) {
4144 const Value *
RHS = Shuf->getOperand(1);
4146 Tmp = std::min(Tmp, Tmp2);
4152 assert(Tmp <= TyBits &&
"Failed to determine minimum sign bits");
4155 case Instruction::Call: {
4156 if (
const auto *
II = dyn_cast<IntrinsicInst>(U)) {
4157 switch (
II->getIntrinsicID()) {
4160 case Intrinsic::abs:
4168 case Intrinsic::smin:
4169 case Intrinsic::smax: {
4170 const APInt *CLow, *CHigh;
4185 if (
unsigned VecSignBits =
4203 if (
F->isIntrinsic())
4204 return F->getIntrinsicID();
4210 if (
F->hasLocalLinkage() || !TLI || !TLI->
getLibFunc(CB, Func) ||
4220 return Intrinsic::sin;
4224 return Intrinsic::cos;
4228 return Intrinsic::tan;
4232 return Intrinsic::asin;
4236 return Intrinsic::acos;
4240 return Intrinsic::atan;
4242 case LibFunc_atan2f:
4243 case LibFunc_atan2l:
4244 return Intrinsic::atan2;
4248 return Intrinsic::sinh;
4252 return Intrinsic::cosh;
4256 return Intrinsic::tanh;
4260 return Intrinsic::exp;
4264 return Intrinsic::exp2;
4266 case LibFunc_exp10f:
4267 case LibFunc_exp10l:
4268 return Intrinsic::exp10;
4272 return Intrinsic::log;
4274 case LibFunc_log10f:
4275 case LibFunc_log10l:
4276 return Intrinsic::log10;
4280 return Intrinsic::log2;
4284 return Intrinsic::fabs;
4288 return Intrinsic::minnum;
4292 return Intrinsic::maxnum;
4293 case LibFunc_copysign:
4294 case LibFunc_copysignf:
4295 case LibFunc_copysignl:
4296 return Intrinsic::copysign;
4298 case LibFunc_floorf:
4299 case LibFunc_floorl:
4300 return Intrinsic::floor;
4304 return Intrinsic::ceil;
4306 case LibFunc_truncf:
4307 case LibFunc_truncl:
4308 return Intrinsic::trunc;
4312 return Intrinsic::rint;
4313 case LibFunc_nearbyint:
4314 case LibFunc_nearbyintf:
4315 case LibFunc_nearbyintl:
4316 return Intrinsic::nearbyint;
4318 case LibFunc_roundf:
4319 case LibFunc_roundl:
4320 return Intrinsic::round;
4321 case LibFunc_roundeven:
4322 case LibFunc_roundevenf:
4323 case LibFunc_roundevenl:
4324 return Intrinsic::roundeven;
4328 return Intrinsic::pow;
4332 return Intrinsic::sqrt;
4380 switch (Mode.Input) {
4400 if (!Src.isKnownNeverPosZero() && !Src.isKnownNeverNegZero())
4404 if (Src.isKnownNeverSubnormal())
4434 bool &TrueIfSigned) {
4437 TrueIfSigned =
true;
4438 return RHS.isZero();
4440 TrueIfSigned =
true;
4441 return RHS.isAllOnes();
4443 TrueIfSigned =
false;
4444 return RHS.isAllOnes();
4446 TrueIfSigned =
false;
4447 return RHS.isZero();
4450 TrueIfSigned =
true;
4451 return RHS.isMaxSignedValue();
4454 TrueIfSigned =
true;
4455 return RHS.isMinSignedValue();
4458 TrueIfSigned =
false;
4459 return RHS.isMinSignedValue();
4462 TrueIfSigned =
false;
4463 return RHS.isMaxSignedValue();
4474 bool LookThroughSrc) {
4482std::pair<Value *, FPClassTest>
4484 const APFloat *ConstRHS,
bool LookThroughSrc) {
4486 auto [Src, ClassIfTrue, ClassIfFalse] =
4488 if (Src && ClassIfTrue == ~ClassIfFalse)
4489 return {Src, ClassIfTrue};
4500std::tuple<Value *, FPClassTest, FPClassTest>
4514 const bool IsNegativeRHS = (RHSClass &
fcNegative) == RHSClass;
4515 const bool IsPositiveRHS = (RHSClass &
fcPositive) == RHSClass;
4516 const bool IsNaN = (RHSClass & ~fcNan) ==
fcNone;
4536 const bool IsZero = (OrigClass &
fcZero) == OrigClass;
4583 const bool IsDenormalRHS = (OrigClass &
fcSubnormal) == OrigClass;
4585 const bool IsInf = (OrigClass &
fcInf) == OrigClass;
4603 if (IsNegativeRHS) {
4626 if (IsNegativeRHS) {
4627 Mask = ~fcNegInf & ~fcNan;
4631 Mask = ~fcPosInf & ~fcNan;
4640 if (IsNegativeRHS) {
4660 if (IsNegativeRHS) {
4680 if (IsNegativeRHS) {
4695 if (IsNegativeRHS) {
4723 return {Src, Class, ~fcNan};
4727 return {Src, ~fcNan, RHSClass |
fcNan};
4736 "should have been recognized as an exact class test");
4738 if (IsNegativeRHS) {
4748 return {Src, ~fcNan,
fcNan};
4757 return {Src,
fcNan, ~fcNan};
4776 return {Src, ClassesGE, ~ClassesGE | RHSClass};
4779 return {Src, ClassesGE |
fcNan, ~(ClassesGE |
fcNan) | RHSClass};
4782 return {Src, ClassesLE, ~ClassesLE | RHSClass};
4785 return {Src, ClassesLE |
fcNan, ~(ClassesLE |
fcNan) | RHSClass};
4789 }
else if (IsPositiveRHS) {
4805 return {Src, ClassesGE, ~ClassesGE | RHSClass};
4808 return {Src, ClassesGE |
fcNan, ~(ClassesGE |
fcNan) | RHSClass};
4811 return {Src, ClassesLE, ~ClassesLE | RHSClass};
4814 return {Src, ClassesLE |
fcNan, ~(ClassesLE |
fcNan) | RHSClass};
4823std::tuple<Value *, FPClassTest, FPClassTest>
4825 const APFloat &ConstRHS,
bool LookThroughSrc) {
4873std::tuple<Value *, FPClassTest, FPClassTest>
4875 Value *RHS,
bool LookThroughSrc) {
4885 unsigned Depth,
bool CondIsTrue,
4907 KnownFromContext.
knownNot(~(CondIsTrue ? MaskIfTrue : MaskIfFalse));
4908 }
else if (
match(
Cond, m_Intrinsic<Intrinsic::is_fpclass>(
4911 KnownFromContext.
knownNot(CondIsTrue ? ~Mask : Mask);
4917 if (TrueIfSigned == CondIsTrue)
4929 return KnownFromContext;
4939 Q.
CxtI, KnownFromContext);
4944 Q.
CxtI, KnownFromContext);
4949 return KnownFromContext;
4959 "Got assumption for the wrong function!");
4960 assert(
I->getIntrinsicID() == Intrinsic::assume &&
4961 "must be an assume intrinsic");
4967 true, Q.
CxtI, KnownFromContext);
4970 return KnownFromContext;
4980 auto *FVTy = dyn_cast<FixedVectorType>(V->getType());
4981 APInt DemandedElts =
4987 const APInt &DemandedElts,
4991 if ((InterestedClasses &
4997 KnownSrc,
Depth + 1, Q);
5012 assert(Known.
isUnknown() &&
"should not be called with known information");
5014 if (!DemandedElts) {
5022 if (
auto *CFP = dyn_cast<ConstantFP>(V)) {
5024 Known.
SignBit = CFP->isNegative();
5028 if (isa<ConstantAggregateZero>(V)) {
5034 if (isa<PoisonValue>(V)) {
5041 auto *VFVTy = dyn_cast<FixedVectorType>(V->getType());
5042 const Constant *CV = dyn_cast<Constant>(V);
5045 bool SignBitAllZero =
true;
5046 bool SignBitAllOne =
true;
5049 unsigned NumElts = VFVTy->getNumElements();
5050 for (
unsigned i = 0; i != NumElts; ++i) {
5051 if (!DemandedElts[i])
5059 if (isa<PoisonValue>(Elt))
5061 auto *CElt = dyn_cast<ConstantFP>(Elt);
5067 const APFloat &
C = CElt->getValueAPF();
5070 SignBitAllZero =
false;
5072 SignBitAllOne =
false;
5074 if (SignBitAllOne != SignBitAllZero)
5075 Known.
SignBit = SignBitAllOne;
5080 if (
const auto *CB = dyn_cast<CallBase>(V))
5081 KnownNotFromFlags |= CB->getRetNoFPClass();
5082 else if (
const auto *Arg = dyn_cast<Argument>(V))
5083 KnownNotFromFlags |= Arg->getNoFPClass();
5087 if (FPOp->hasNoNaNs())
5088 KnownNotFromFlags |=
fcNan;
5089 if (FPOp->hasNoInfs())
5090 KnownNotFromFlags |=
fcInf;
5094 KnownNotFromFlags |= ~AssumedClasses.KnownFPClasses;
5098 InterestedClasses &= ~KnownNotFromFlags;
5103 if (*AssumedClasses.SignBit)
5104 Known.signBitMustBeOne();
5106 Known.signBitMustBeZero();
5117 const unsigned Opc =
Op->getOpcode();
5119 case Instruction::FNeg: {
5121 Known,
Depth + 1, Q);
5125 case Instruction::Select: {
5133 Value *TestedValue =
nullptr;
5137 const Function *
F = cast<Instruction>(
Op)->getFunction();
5139 Value *CmpLHS, *CmpRHS;
5146 bool LookThroughFAbsFNeg = CmpLHS !=
LHS && CmpLHS !=
RHS;
5147 std::tie(TestedValue, MaskIfTrue, MaskIfFalse) =
5150 m_Intrinsic<Intrinsic::is_fpclass>(
5153 MaskIfTrue = TestedMask;
5154 MaskIfFalse = ~TestedMask;
5157 if (TestedValue ==
LHS) {
5159 FilterLHS = MaskIfTrue;
5160 }
else if (TestedValue ==
RHS) {
5162 FilterRHS = MaskIfFalse;
5171 Known2,
Depth + 1, Q);
5177 case Instruction::Call: {
5181 case Intrinsic::fabs: {
5186 InterestedClasses, Known,
Depth + 1, Q);
5192 case Intrinsic::copysign: {
5196 Known,
Depth + 1, Q);
5198 KnownSign,
Depth + 1, Q);
5202 case Intrinsic::fma:
5203 case Intrinsic::fmuladd: {
5207 if (
II->getArgOperand(0) !=
II->getArgOperand(1))
5216 KnownAddend,
Depth + 1, Q);
5222 case Intrinsic::sqrt:
5223 case Intrinsic::experimental_constrained_sqrt: {
5226 if (InterestedClasses &
fcNan)
5230 KnownSrc,
Depth + 1, Q);
5253 case Intrinsic::sin:
5254 case Intrinsic::cos: {
5258 KnownSrc,
Depth + 1, Q);
5264 case Intrinsic::maxnum:
5265 case Intrinsic::minnum:
5266 case Intrinsic::minimum:
5267 case Intrinsic::maximum: {
5270 KnownLHS,
Depth + 1, Q);
5272 KnownRHS,
Depth + 1, Q);
5275 Known = KnownLHS | KnownRHS;
5278 if (NeverNaN && (IID == Intrinsic::minnum || IID == Intrinsic::maxnum))
5281 if (IID == Intrinsic::maxnum) {
5289 }
else if (IID == Intrinsic::maximum) {
5295 }
else if (IID == Intrinsic::minnum) {
5325 II->getType()->getScalarType()->getFltSemantics());
5337 }
else if ((IID == Intrinsic::maximum || IID == Intrinsic::minimum) ||
5342 if ((IID == Intrinsic::maximum || IID == Intrinsic::maxnum) &&
5345 else if ((IID == Intrinsic::minimum || IID == Intrinsic::minnum) &&
5352 case Intrinsic::canonicalize: {
5355 KnownSrc,
Depth + 1, Q);
5379 II->getType()->getScalarType()->getFltSemantics();
5399 case Intrinsic::vector_reduce_fmax:
5400 case Intrinsic::vector_reduce_fmin:
5401 case Intrinsic::vector_reduce_fmaximum:
5402 case Intrinsic::vector_reduce_fminimum: {
5406 InterestedClasses,
Depth + 1, Q);
5413 case Intrinsic::vector_reverse:
5416 II->getFastMathFlags(), InterestedClasses,
Depth + 1, Q);
5418 case Intrinsic::trunc:
5419 case Intrinsic::floor:
5420 case Intrinsic::ceil:
5421 case Intrinsic::rint:
5422 case Intrinsic::nearbyint:
5423 case Intrinsic::round:
5424 case Intrinsic::roundeven: {
5432 KnownSrc,
Depth + 1, Q);
5441 if (IID == Intrinsic::trunc || !V->getType()->isMultiUnitFPType()) {
5456 case Intrinsic::exp:
5457 case Intrinsic::exp2:
5458 case Intrinsic::exp10: {
5465 KnownSrc,
Depth + 1, Q);
5473 case Intrinsic::fptrunc_round: {
5478 case Intrinsic::log:
5479 case Intrinsic::log10:
5480 case Intrinsic::log2:
5481 case Intrinsic::experimental_constrained_log:
5482 case Intrinsic::experimental_constrained_log10:
5483 case Intrinsic::experimental_constrained_log2: {
5499 KnownSrc,
Depth + 1, Q);
5513 case Intrinsic::powi: {
5517 const Value *Exp =
II->getArgOperand(1);
5518 Type *ExpTy = Exp->getType();
5522 ExponentKnownBits,
Depth + 1, Q);
5524 if (ExponentKnownBits.
Zero[0]) {
5539 KnownSrc,
Depth + 1, Q);
5544 case Intrinsic::ldexp: {
5547 KnownSrc,
Depth + 1, Q);
5563 if ((InterestedClasses & ExpInfoMask) ==
fcNone)
5569 II->getType()->getScalarType()->getFltSemantics();
5571 const Value *ExpArg =
II->getArgOperand(1);
5575 const int MantissaBits = Precision - 1;
5581 if (ConstVal && ConstVal->
isZero()) {
5604 case Intrinsic::arithmetic_fence: {
5606 Known,
Depth + 1, Q);
5609 case Intrinsic::experimental_constrained_sitofp:
5610 case Intrinsic::experimental_constrained_uitofp:
5620 if (IID == Intrinsic::experimental_constrained_uitofp)
5631 case Instruction::FAdd:
5632 case Instruction::FSub: {
5635 Op->getOpcode() == Instruction::FAdd &&
5637 bool WantNaN = (InterestedClasses &
fcNan) !=
fcNone;
5640 if (!WantNaN && !WantNegative && !WantNegZero)
5646 if (InterestedClasses &
fcNan)
5647 InterestedSrcs |=
fcInf;
5649 KnownRHS,
Depth + 1, Q);
5653 WantNegZero || Opc == Instruction::FSub) {
5658 KnownLHS,
Depth + 1, Q);
5666 const Function *
F = cast<Instruction>(
Op)->getFunction();
5668 if (
Op->getOpcode() == Instruction::FAdd) {
5696 case Instruction::FMul: {
5698 if (
Op->getOperand(0) ==
Op->getOperand(1))
5731 const Function *
F = cast<Instruction>(
Op)->getFunction();
5743 case Instruction::FDiv:
5744 case Instruction::FRem: {
5745 if (
Op->getOperand(0) ==
Op->getOperand(1)) {
5747 if (
Op->getOpcode() == Instruction::FDiv) {
5758 const bool WantNan = (InterestedClasses &
fcNan) !=
fcNone;
5760 const bool WantPositive =
5762 if (!WantNan && !WantNegative && !WantPositive)
5771 bool KnowSomethingUseful =
5774 if (KnowSomethingUseful || WantPositive) {
5780 InterestedClasses & InterestedLHS, KnownLHS,
5784 const Function *
F = cast<Instruction>(
Op)->getFunction();
5786 if (
Op->getOpcode() == Instruction::FDiv) {
5823 case Instruction::FPExt: {
5826 Known,
Depth + 1, Q);
5829 Op->getType()->getScalarType()->getFltSemantics();
5831 Op->getOperand(0)->getType()->getScalarType()->getFltSemantics();
5847 case Instruction::FPTrunc: {
5852 case Instruction::SIToFP:
5853 case Instruction::UIToFP: {
5862 if (
Op->getOpcode() == Instruction::UIToFP)
5865 if (InterestedClasses &
fcInf) {
5869 int IntSize =
Op->getOperand(0)->getType()->getScalarSizeInBits();
5870 if (
Op->getOpcode() == Instruction::SIToFP)
5875 Type *FPTy =
Op->getType()->getScalarType();
5882 case Instruction::ExtractElement: {
5885 const Value *Vec =
Op->getOperand(0);
5887 auto *CIdx = dyn_cast<ConstantInt>(
Idx);
5889 if (
auto *VecTy = dyn_cast<FixedVectorType>(Vec->
getType())) {
5890 unsigned NumElts = VecTy->getNumElements();
5892 if (CIdx && CIdx->getValue().ult(NumElts))
5900 case Instruction::InsertElement: {
5901 if (isa<ScalableVectorType>(
Op->getType()))
5904 const Value *Vec =
Op->getOperand(0);
5905 const Value *Elt =
Op->getOperand(1);
5906 auto *CIdx = dyn_cast<ConstantInt>(
Op->getOperand(2));
5908 APInt DemandedVecElts = DemandedElts;
5909 bool NeedsElt =
true;
5911 if (CIdx && CIdx->getValue().ult(NumElts)) {
5912 DemandedVecElts.
clearBit(CIdx->getZExtValue());
5913 NeedsElt = DemandedElts[CIdx->getZExtValue()];
5927 if (!DemandedVecElts.
isZero()) {
5936 case Instruction::ShuffleVector: {
5939 APInt DemandedLHS, DemandedRHS;
5940 auto *Shuf = dyn_cast<ShuffleVectorInst>(
Op);
5944 if (!!DemandedLHS) {
5945 const Value *
LHS = Shuf->getOperand(0);
5956 if (!!DemandedRHS) {
5958 const Value *
RHS = Shuf->getOperand(1);
5966 case Instruction::ExtractValue: {
5970 if (isa<StructType>(Src->getType()) && Indices.
size() == 1 &&
5972 if (
const auto *
II = dyn_cast<IntrinsicInst>(Src)) {
5973 switch (
II->getIntrinsicID()) {
5974 case Intrinsic::frexp: {
5979 InterestedClasses, KnownSrc,
Depth + 1, Q);
5981 const Function *
F = cast<Instruction>(
Op)->getFunction();
6014 case Instruction::PHI: {
6017 if (
P->getNumIncomingValues() == 0)
6024 if (
Depth < PhiRecursionLimit) {
6026 if (isa_and_nonnull<UndefValue>(
P->hasConstantValue()))
6031 for (
const Use &U :
P->operands()) {
6032 Value *IncValue = U.get();
6037 Instruction *CxtI =
P->getIncomingBlock(U)->getTerminator();
6045 }
else if (
auto *IncPhi = dyn_cast<PHINode>(IncValue);
6046 IncPhi && IncPhi->getNumIncomingValues() == 2) {
6048 if (IncPhi->getIncomingValue(
Idx) ==
P) {
6049 IncValue = IncPhi->getIncomingValue(1 -
Idx);
6050 CxtI = IncPhi->getIncomingBlock(1 -
Idx)->getTerminator();
6078 case Instruction::BitCast: {
6081 !Src->getType()->isIntOrIntVectorTy())
6084 const Type *Ty =
Op->getType()->getScalarType();
6089 if (Bits.isNonNegative())
6091 else if (Bits.isNegative())
6110 InfKB.Zero.clearSignBit();
6112 assert(!InfResult.value());
6114 }
else if (Bits == InfKB) {
6122 ZeroKB.Zero.clearSignBit();
6124 assert(!ZeroResult.value());
6126 }
else if (Bits == ZeroKB) {
6139 const APInt &DemandedElts,
6146 return KnownClasses;
6161 if (V->getType()->isIntegerTy(8))
6168 if (isa<UndefValue>(V))
6172 if (
DL.getTypeStoreSize(V->getType()).isZero())
6187 if (
C->isNullValue())
6194 if (CFP->getType()->isHalfTy())
6196 else if (CFP->getType()->isFloatTy())
6198 else if (CFP->getType()->isDoubleTy())
6207 if (CI->getBitWidth() % 8 == 0) {
6208 assert(CI->getBitWidth() > 8 &&
"8 bits should be handled above!");
6209 if (!CI->getValue().isSplat(8))
6211 return ConstantInt::get(Ctx, CI->getValue().trunc(8));
6215 if (
auto *CE = dyn_cast<ConstantExpr>(
C)) {
6216 if (CE->getOpcode() == Instruction::IntToPtr) {
6217 if (
auto *PtrTy = dyn_cast<PointerType>(CE->getType())) {
6218 unsigned BitWidth =
DL.getPointerSizeInBits(PtrTy->getAddressSpace());
6231 if (
LHS == UndefInt8)
6233 if (
RHS == UndefInt8)
6239 Value *Val = UndefInt8;
6240 for (
unsigned I = 0, E = CA->getNumElements();
I != E; ++
I)
6246 if (isa<ConstantAggregate>(
C)) {
6247 Value *Val = UndefInt8;
6268 StructType *STy = dyn_cast<StructType>(IndexedType);
6282 while (PrevTo != OrigTo) {
6329 unsigned IdxSkip = Idxs.
size();
6342 std::optional<BasicBlock::iterator> InsertBefore) {
6345 if (idx_range.
empty())
6348 assert((V->getType()->isStructTy() || V->getType()->isArrayTy()) &&
6349 "Not looking at a struct or array?");
6351 "Invalid indices for type?");
6353 if (
Constant *
C = dyn_cast<Constant>(V)) {
6354 C =
C->getAggregateElement(idx_range[0]);
6355 if (!
C)
return nullptr;
6362 const unsigned *req_idx = idx_range.
begin();
6363 for (
const unsigned *i =
I->idx_begin(), *e =
I->idx_end();
6364 i != e; ++i, ++req_idx) {
6365 if (req_idx == idx_range.
end()) {
6395 ArrayRef(req_idx, idx_range.
end()), InsertBefore);
6404 unsigned size =
I->getNumIndices() + idx_range.
size();
6409 Idxs.
append(
I->idx_begin(),
I->idx_end());
6415 &&
"Number of indices added not correct?");
6425 unsigned CharSize) {
6427 if (
GEP->getNumOperands() != 3)
6432 ArrayType *AT = dyn_cast<ArrayType>(
GEP->getSourceElementType());
6438 const ConstantInt *FirstIdx = dyn_cast<ConstantInt>(
GEP->getOperand(1));
6439 if (!FirstIdx || !FirstIdx->
isZero())
6453 assert(V &&
"V should not be null.");
6454 assert((ElementSize % 8) == 0 &&
6455 "ElementSize expected to be a multiple of the size of a byte.");
6456 unsigned ElementSizeInBytes = ElementSize / 8;
6468 APInt Off(
DL.getIndexTypeSizeInBits(V->getType()), 0);
6470 if (GV != V->stripAndAccumulateConstantOffsets(
DL, Off,
6475 uint64_t StartIdx = Off.getLimitedValue();
6482 if ((StartIdx % ElementSizeInBytes) != 0)
6485 Offset += StartIdx / ElementSizeInBytes;
6491 uint64_t SizeInBytes =
DL.getTypeStoreSize(GVTy).getFixedValue();
6494 Slice.
Array =
nullptr;
6505 if (
auto *ArrayInit = dyn_cast<ConstantDataArray>(
Init)) {
6506 Type *InitElTy = ArrayInit->getElementType();
6511 ArrayTy = ArrayInit->getType();
6516 if (ElementSize != 8)
6527 Array = dyn_cast<ConstantDataArray>(
Init);
6528 ArrayTy = dyn_cast<ArrayType>(
Init->getType());
6535 Slice.
Array = Array;
6551 if (Slice.
Array ==
nullptr) {
6574 Str = Str.substr(Slice.
Offset);
6580 Str = Str.substr(0, Str.find(
'\0'));
6593 unsigned CharSize) {
6595 V = V->stripPointerCasts();
6599 if (
const PHINode *PN = dyn_cast<PHINode>(V)) {
6600 if (!PHIs.
insert(PN).second)
6605 for (
Value *IncValue : PN->incoming_values()) {
6607 if (Len == 0)
return 0;
6609 if (Len == ~0ULL)
continue;
6611 if (Len != LenSoFar && LenSoFar != ~0ULL)
6621 if (
const SelectInst *SI = dyn_cast<SelectInst>(V)) {
6623 if (Len1 == 0)
return 0;
6625 if (Len2 == 0)
return 0;
6626 if (Len1 == ~0ULL)
return Len2;
6627 if (Len2 == ~0ULL)
return Len1;
6628 if (Len1 != Len2)
return 0;
6637 if (Slice.
Array ==
nullptr)
6645 unsigned NullIndex = 0;
6646 for (
unsigned E = Slice.
Length; NullIndex < E; ++NullIndex) {
6651 return NullIndex + 1;
6657 if (!V->getType()->isPointerTy())
6664 return Len == ~0ULL ? 1 : Len;
6669 bool MustPreserveNullness) {
6671 "getArgumentAliasingToReturnedPointer only works on nonnull calls");
6672 if (
const Value *RV = Call->getReturnedArgOperand())
6676 Call, MustPreserveNullness))
6677 return Call->getArgOperand(0);
6682 const CallBase *Call,
bool MustPreserveNullness) {
6683 switch (Call->getIntrinsicID()) {
6684 case Intrinsic::launder_invariant_group:
6685 case Intrinsic::strip_invariant_group:
6686 case Intrinsic::aarch64_irg:
6687 case Intrinsic::aarch64_tagp:
6697 case Intrinsic::amdgcn_make_buffer_rsrc:
6699 case Intrinsic::ptrmask:
6700 return !MustPreserveNullness;
6701 case Intrinsic::threadlocal_address:
6704 return !Call->getParent()->getParent()->isPresplitCoroutine();
6721 if (!PrevValue || LI->
getLoopFor(PrevValue->getParent()) != L)
6723 if (!PrevValue || LI->
getLoopFor(PrevValue->getParent()) != L)
6731 if (
auto *Load = dyn_cast<LoadInst>(PrevValue))
6732 if (!L->isLoopInvariant(Load->getPointerOperand()))
6738 for (
unsigned Count = 0; MaxLookup == 0 || Count < MaxLookup; ++Count) {
6739 if (
auto *
GEP = dyn_cast<GEPOperator>(V)) {
6740 const Value *PtrOp =
GEP->getPointerOperand();
6746 Value *NewV = cast<Operator>(V)->getOperand(0);
6750 }
else if (
auto *GA = dyn_cast<GlobalAlias>(V)) {
6751 if (GA->isInterposable())
6753 V = GA->getAliasee();
6755 if (
auto *
PHI = dyn_cast<PHINode>(V)) {
6757 if (
PHI->getNumIncomingValues() == 1) {
6758 V =
PHI->getIncomingValue(0);
6761 }
else if (
auto *Call = dyn_cast<CallBase>(V)) {
6779 assert(V->getType()->isPointerTy() &&
"Unexpected operand type!");
6786 const LoopInfo *LI,
unsigned MaxLookup) {
6794 if (!Visited.
insert(
P).second)
6797 if (
auto *SI = dyn_cast<SelectInst>(
P)) {
6799 Worklist.
push_back(SI->getFalseValue());
6803 if (
auto *PN = dyn_cast<PHINode>(
P)) {
6823 }
while (!Worklist.
empty());
6827 const unsigned MaxVisited = 8;
6832 const Value *Object =
nullptr;
6842 if (!Visited.
insert(
P).second)
6845 if (Visited.
size() == MaxVisited)
6848 if (
auto *SI = dyn_cast<SelectInst>(
P)) {
6850 Worklist.
push_back(SI->getFalseValue());
6854 if (
auto *PN = dyn_cast<PHINode>(
P)) {
6861 else if (Object !=
P)
6863 }
while (!Worklist.
empty());
6872 if (
const Operator *U = dyn_cast<Operator>(V)) {
6875 if (U->getOpcode() == Instruction::PtrToInt)
6876 return U->getOperand(0);
6883 if (U->getOpcode() != Instruction::Add ||
6884 (!isa<ConstantInt>(U->getOperand(1)) &&
6886 !isa<PHINode>(U->getOperand(1))))
6888 V = U->getOperand(0);
6892 assert(V->getType()->isIntegerTy() &&
"Unexpected operand type!");
6909 for (
const Value *V : Objs) {
6910 if (!Visited.
insert(V).second)
6915 if (O->getType()->isPointerTy()) {
6928 }
while (!Working.
empty());
6937 auto AddWork = [&](
Value *V) {
6938 if (Visited.
insert(V).second)
6947 if (
AllocaInst *AI = dyn_cast<AllocaInst>(V)) {
6948 if (Result && Result != AI)
6951 }
else if (
CastInst *CI = dyn_cast<CastInst>(V)) {
6952 AddWork(CI->getOperand(0));
6953 }
else if (
PHINode *PN = dyn_cast<PHINode>(V)) {
6954 for (
Value *IncValue : PN->incoming_values())
6956 }
else if (
auto *SI = dyn_cast<SelectInst>(V)) {
6957 AddWork(SI->getTrueValue());
6958 AddWork(SI->getFalseValue());
6960 if (OffsetZero && !
GEP->hasAllZeroIndices())
6962 AddWork(
GEP->getPointerOperand());
6963 }
else if (
CallBase *CB = dyn_cast<CallBase>(V)) {
6964 Value *Returned = CB->getReturnedArgOperand();
6972 }
while (!Worklist.
empty());
6978 const Value *V,
bool AllowLifetime,
bool AllowDroppable) {
6979 for (
const User *U : V->users()) {
6984 if (AllowLifetime &&
II->isLifetimeStartOrEnd())
6987 if (AllowDroppable &&
II->isDroppable())
7005 if (
auto *
II = dyn_cast<IntrinsicInst>(
I))
7007 auto *Shuffle = dyn_cast<ShuffleVectorInst>(
I);
7008 return (!Shuffle || Shuffle->isSelect()) &&
7009 !isa<CallBase, BitCastInst, ExtractElementInst>(
I);
7017 bool UseVariableInfo) {
7019 AC, DT, TLI, UseVariableInfo);
7025 bool UseVariableInfo) {
7029 auto hasEqualReturnAndLeadingOperandTypes =
7030 [](
const Instruction *Inst,
unsigned NumLeadingOperands) {
7034 for (
unsigned ItOp = 0; ItOp < NumLeadingOperands; ++ItOp)
7040 hasEqualReturnAndLeadingOperandTypes(Inst, 2));
7042 hasEqualReturnAndLeadingOperandTypes(Inst, 1));
7049 case Instruction::UDiv:
7050 case Instruction::URem: {
7057 case Instruction::SDiv:
7058 case Instruction::SRem: {
7060 const APInt *Numerator, *Denominator;
7064 if (*Denominator == 0)
7076 case Instruction::Load: {
7077 if (!UseVariableInfo)
7080 const LoadInst *LI = dyn_cast<LoadInst>(Inst);
7090 case Instruction::Call: {
7091 auto *CI = dyn_cast<const CallInst>(Inst);
7094 const Function *Callee = CI->getCalledFunction();
7098 return Callee && Callee->isSpeculatable();
7100 case Instruction::VAArg:
7101 case Instruction::Alloca:
7102 case Instruction::Invoke:
7103 case Instruction::CallBr:
7104 case Instruction::PHI:
7105 case Instruction::Store:
7106 case Instruction::Ret:
7107 case Instruction::Br:
7108 case Instruction::IndirectBr:
7109 case Instruction::Switch:
7110 case Instruction::Unreachable:
7111 case Instruction::Fence:
7112 case Instruction::AtomicRMW:
7113 case Instruction::AtomicCmpXchg:
7114 case Instruction::LandingPad:
7115 case Instruction::Resume:
7116 case Instruction::CatchSwitch:
7117 case Instruction::CatchPad:
7118 case Instruction::CatchRet:
7119 case Instruction::CleanupPad:
7120 case Instruction::CleanupRet:
7126 if (
I.mayReadOrWriteMemory())
7239 if (
Add &&
Add->hasNoSignedWrap()) {
7279 bool LHSOrRHSKnownNonNegative =
7281 bool LHSOrRHSKnownNegative =
7283 if (LHSOrRHSKnownNonNegative || LHSOrRHSKnownNegative) {
7286 if ((AddKnown.
isNonNegative() && LHSOrRHSKnownNonNegative) ||
7287 (AddKnown.
isNegative() && LHSOrRHSKnownNegative))
7362 if (
const auto *EVI = dyn_cast<ExtractValueInst>(U)) {
7363 assert(EVI->getNumIndices() == 1 &&
"Obvious from CI's type");
7365 if (EVI->getIndices()[0] == 0)
7368 assert(EVI->getIndices()[0] == 1 &&
"Obvious from CI's type");
7370 for (
const auto *U : EVI->users())
7371 if (
const auto *
B = dyn_cast<BranchInst>(U)) {
7372 assert(
B->isConditional() &&
"How else is it using an i1?");
7383 auto AllUsesGuardedByBranch = [&](
const BranchInst *BI) {
7389 for (
const auto *Result :
Results) {
7392 if (DT.
dominates(NoWrapEdge, Result->getParent()))
7395 for (
const auto &RU : Result->uses())
7403 return llvm::any_of(GuardingBranches, AllUsesGuardedByBranch);
7408 auto *
C = dyn_cast<Constant>(ShiftAmount);
7414 if (
auto *FVTy = dyn_cast<FixedVectorType>(
C->getType())) {
7415 unsigned NumElts = FVTy->getNumElements();
7416 for (
unsigned i = 0; i < NumElts; ++i)
7417 ShiftAmounts.
push_back(
C->getAggregateElement(i));
7418 }
else if (isa<ScalableVectorType>(
C->getType()))
7424 auto *CI = dyn_cast_or_null<ConstantInt>(
C);
7425 return CI && CI->getValue().ult(
C->getType()->getIntegerBitWidth());
7438 return (
unsigned(Kind) &
unsigned(UndefPoisonKind::PoisonOnly)) != 0;
7442 return (
unsigned(Kind) &
unsigned(UndefPoisonKind::UndefOnly)) != 0;
7446 bool ConsiderFlagsAndMetadata) {
7449 Op->hasPoisonGeneratingAnnotations())
7452 unsigned Opcode =
Op->getOpcode();
7456 case Instruction::Shl:
7457 case Instruction::AShr:
7458 case Instruction::LShr:
7460 case Instruction::FPToSI:
7461 case Instruction::FPToUI:
7465 case Instruction::Call:
7466 if (
auto *
II = dyn_cast<IntrinsicInst>(
Op)) {
7467 switch (
II->getIntrinsicID()) {
7469 case Intrinsic::ctlz:
7470 case Intrinsic::cttz:
7471 case Intrinsic::abs:
7472 if (cast<ConstantInt>(
II->getArgOperand(1))->isNullValue())
7475 case Intrinsic::ctpop:
7476 case Intrinsic::bswap:
7477 case Intrinsic::bitreverse:
7478 case Intrinsic::fshl:
7479 case Intrinsic::fshr:
7480 case Intrinsic::smax:
7481 case Intrinsic::smin:
7482 case Intrinsic::umax:
7483 case Intrinsic::umin:
7484 case Intrinsic::ptrmask:
7485 case Intrinsic::fptoui_sat:
7486 case Intrinsic::fptosi_sat:
7487 case Intrinsic::sadd_with_overflow:
7488 case Intrinsic::ssub_with_overflow:
7489 case Intrinsic::smul_with_overflow:
7490 case Intrinsic::uadd_with_overflow:
7491 case Intrinsic::usub_with_overflow:
7492 case Intrinsic::umul_with_overflow:
7493 case Intrinsic::sadd_sat:
7494 case Intrinsic::uadd_sat:
7495 case Intrinsic::ssub_sat:
7496 case Intrinsic::usub_sat:
7498 case Intrinsic::sshl_sat:
7499 case Intrinsic::ushl_sat:
7502 case Intrinsic::fma:
7503 case Intrinsic::fmuladd:
7504 case Intrinsic::sqrt:
7505 case Intrinsic::powi:
7506 case Intrinsic::sin:
7507 case Intrinsic::cos:
7508 case Intrinsic::pow:
7509 case Intrinsic::log:
7510 case Intrinsic::log10:
7511 case Intrinsic::log2:
7512 case Intrinsic::exp:
7513 case Intrinsic::exp2:
7514 case Intrinsic::exp10:
7515 case Intrinsic::fabs:
7516 case Intrinsic::copysign:
7517 case Intrinsic::floor:
7518 case Intrinsic::ceil:
7519 case Intrinsic::trunc:
7520 case Intrinsic::rint:
7521 case Intrinsic::nearbyint:
7522 case Intrinsic::round:
7523 case Intrinsic::roundeven:
7524 case Intrinsic::fptrunc_round:
7525 case Intrinsic::canonicalize:
7526 case Intrinsic::arithmetic_fence:
7527 case Intrinsic::minnum:
7528 case Intrinsic::maxnum:
7529 case Intrinsic::minimum:
7530 case Intrinsic::maximum:
7531 case Intrinsic::is_fpclass:
7532 case Intrinsic::ldexp:
7533 case Intrinsic::frexp:
7535 case Intrinsic::lround:
7536 case Intrinsic::llround:
7537 case Intrinsic::lrint:
7538 case Intrinsic::llrint:
7545 case Instruction::CallBr:
7546 case Instruction::Invoke: {
7547 const auto *CB = cast<CallBase>(
Op);
7548 return !CB->hasRetAttr(Attribute::NoUndef);
7550 case Instruction::InsertElement:
7551 case Instruction::ExtractElement: {
7553 auto *VTy = cast<VectorType>(
Op->getOperand(0)->getType());
7554 unsigned IdxOp =
Op->getOpcode() == Instruction::InsertElement ? 2 : 1;
7555 auto *
Idx = dyn_cast<ConstantInt>(
Op->getOperand(IdxOp));
7558 Idx->getValue().uge(VTy->getElementCount().getKnownMinValue());
7561 case Instruction::ShuffleVector: {
7563 ? cast<ConstantExpr>(
Op)->getShuffleMask()
7564 : cast<ShuffleVectorInst>(
Op)->getShuffleMask();
7567 case Instruction::FNeg:
7568 case Instruction::PHI:
7569 case Instruction::Select:
7570 case Instruction::URem:
7571 case Instruction::SRem:
7572 case Instruction::ExtractValue:
7573 case Instruction::InsertValue:
7574 case Instruction::Freeze:
7575 case Instruction::ICmp:
7576 case Instruction::FCmp:
7577 case Instruction::FAdd:
7578 case Instruction::FSub:
7579 case Instruction::FMul:
7580 case Instruction::FDiv:
7581 case Instruction::FRem:
7583 case Instruction::GetElementPtr:
7588 const auto *CE = dyn_cast<ConstantExpr>(
Op);
7589 if (isa<CastInst>(
Op) || (CE && CE->isCast()))
7600 bool ConsiderFlagsAndMetadata) {
7601 return ::canCreateUndefOrPoison(
Op, UndefPoisonKind::UndefOrPoison,
7602 ConsiderFlagsAndMetadata);
7606 return ::canCreateUndefOrPoison(
Op, UndefPoisonKind::PoisonOnly,
7607 ConsiderFlagsAndMetadata);
7612 if (ValAssumedPoison == V)
7619 if (
const auto *
I = dyn_cast<Instruction>(V)) {
7621 return propagatesPoison(Op) &&
7622 directlyImpliesPoison(ValAssumedPoison, Op, Depth + 1);
7650 const auto *
I = dyn_cast<Instruction>(ValAssumedPoison);
7653 return impliesPoison(Op, V, Depth + 1);
7660 return ::impliesPoison(ValAssumedPoison, V, 0);
7671 if (isa<MetadataAsValue>(V))
7674 if (
const auto *
A = dyn_cast<Argument>(V)) {
7675 if (
A->hasAttribute(Attribute::NoUndef) ||
7676 A->hasAttribute(Attribute::Dereferenceable) ||
7677 A->hasAttribute(Attribute::DereferenceableOrNull))
7681 if (
auto *
C = dyn_cast<Constant>(V)) {
7682 if (isa<PoisonValue>(
C))
7685 if (isa<UndefValue>(
C))
7688 if (isa<ConstantInt>(
C) || isa<GlobalVariable>(
C) || isa<ConstantFP>(V) ||
7689 isa<ConstantPointerNull>(
C) || isa<Function>(
C))
7692 if (
C->getType()->isVectorTy() && !isa<ConstantExpr>(
C)) {
7697 return !
C->containsConstantExpression();
7709 auto *StrippedV = V->stripPointerCastsSameRepresentation();
7710 if (isa<AllocaInst>(StrippedV) || isa<GlobalVariable>(StrippedV) ||
7711 isa<Function>(StrippedV) || isa<ConstantPointerNull>(StrippedV))
7714 auto OpCheck = [&](
const Value *V) {
7718 if (
auto *Opr = dyn_cast<Operator>(V)) {
7721 if (isa<FreezeInst>(V))
7724 if (
const auto *CB = dyn_cast<CallBase>(V)) {
7725 if (CB->hasRetAttr(Attribute::NoUndef) ||
7726 CB->hasRetAttr(Attribute::Dereferenceable) ||
7727 CB->hasRetAttr(Attribute::DereferenceableOrNull))
7731 if (
const auto *PN = dyn_cast<PHINode>(V)) {
7732 unsigned Num = PN->getNumIncomingValues();
7733 bool IsWellDefined =
true;
7734 for (
unsigned i = 0; i < Num; ++i) {
7735 auto *TI = PN->getIncomingBlock(i)->getTerminator();
7737 DT,
Depth + 1, Kind)) {
7738 IsWellDefined =
false;
7746 all_of(Opr->operands(), OpCheck))
7750 if (
auto *
I = dyn_cast<LoadInst>(V))
7751 if (
I->hasMetadata(LLVMContext::MD_noundef) ||
7752 I->hasMetadata(LLVMContext::MD_dereferenceable) ||
7753 I->hasMetadata(LLVMContext::MD_dereferenceable_or_null))
7773 auto *Dominator = DNode->
getIDom();
7778 auto *TI = Dominator->
getBlock()->getTerminator();
7781 if (
auto BI = dyn_cast_or_null<BranchInst>(TI)) {
7782 if (BI->isConditional())
7783 Cond = BI->getCondition();
7784 }
else if (
auto SI = dyn_cast_or_null<SwitchInst>(TI)) {
7785 Cond = SI->getCondition();
7793 auto *Opr = cast<Operator>(
Cond);
7794 if (
any_of(Opr->operands(), [V](
const Use &U) {
7795 return V == U && propagatesPoison(U);
7801 Dominator = Dominator->getIDom();
7814 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT,
Depth,
7815 UndefPoisonKind::UndefOrPoison);
7821 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT,
Depth,
7822 UndefPoisonKind::PoisonOnly);
7828 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT,
Depth,
7829 UndefPoisonKind::UndefOnly);
7852 while (!Worklist.
empty()) {
7861 if (
I != Root && !
any_of(
I->operands(), [&KnownPoison](
const Use &U) {
7862 return KnownPoison.contains(U) && propagatesPoison(U);
7866 if (KnownPoison.
insert(
I).second)
7878 return ::computeOverflowForSignedAdd(
Add->getOperand(0),
Add->getOperand(1),
7886 return ::computeOverflowForSignedAdd(
LHS,
RHS,
nullptr, SQ);
7895 if (isa<ReturnInst>(
I))
7897 if (isa<UnreachableInst>(
I))
7904 if (isa<CatchPadInst>(
I)) {
7918 return !
I->mayThrow() &&
I->willReturn();
7932 unsigned ScanLimit) {
7939 assert(ScanLimit &&
"scan limit must be non-zero");
7941 if (isa<DbgInfoIntrinsic>(
I))
7943 if (--ScanLimit == 0)
7957 if (
I->getParent() != L->getHeader())
return false;
7960 if (&LI ==
I)
return true;
7963 llvm_unreachable(
"Instruction not contained in its own parent basic block.");
7968 switch (
I->getOpcode()) {
7969 case Instruction::Freeze:
7970 case Instruction::PHI:
7971 case Instruction::Invoke:
7973 case Instruction::Select:
7975 case Instruction::Call:
7976 if (
auto *
II = dyn_cast<IntrinsicInst>(
I)) {
7977 switch (
II->getIntrinsicID()) {
7979 case Intrinsic::sadd_with_overflow:
7980 case Intrinsic::ssub_with_overflow:
7981 case Intrinsic::smul_with_overflow:
7982 case Intrinsic::uadd_with_overflow:
7983 case Intrinsic::usub_with_overflow:
7984 case Intrinsic::umul_with_overflow:
7989 case Intrinsic::ctpop:
7990 case Intrinsic::ctlz:
7991 case Intrinsic::cttz:
7992 case Intrinsic::abs:
7993 case Intrinsic::smax:
7994 case Intrinsic::smin:
7995 case Intrinsic::umax:
7996 case Intrinsic::umin:
7997 case Intrinsic::bitreverse:
7998 case Intrinsic::bswap:
7999 case Intrinsic::sadd_sat:
8000 case Intrinsic::ssub_sat:
8001 case Intrinsic::sshl_sat:
8002 case Intrinsic::uadd_sat:
8003 case Intrinsic::usub_sat:
8004 case Intrinsic::ushl_sat:
8009 case Instruction::ICmp:
8010 case Instruction::FCmp:
8011 case Instruction::GetElementPtr:
8014 if (isa<BinaryOperator>(
I) || isa<UnaryOperator>(
I) || isa<CastInst>(
I))
8025template <
typename CallableT>
8027 const CallableT &Handle) {
8028 switch (
I->getOpcode()) {
8029 case Instruction::Store:
8034 case Instruction::Load:
8041 case Instruction::AtomicCmpXchg:
8046 case Instruction::AtomicRMW:
8051 case Instruction::Call:
8052 case Instruction::Invoke: {
8056 for (
unsigned i = 0; i < CB->
arg_size(); ++i)
8059 CB->
paramHasAttr(i, Attribute::DereferenceableOrNull)) &&
8064 case Instruction::Ret:
8065 if (
I->getFunction()->hasRetAttribute(Attribute::NoUndef) &&
8066 Handle(
I->getOperand(0)))
8069 case Instruction::Switch:
8070 if (Handle(cast<SwitchInst>(
I)->getCondition()))
8073 case Instruction::Br: {
8074 auto *BR = cast<BranchInst>(
I);
8075 if (BR->isConditional() && Handle(BR->getCondition()))
8095template <
typename CallableT>
8097 const CallableT &Handle) {
8100 switch (
I->getOpcode()) {
8102 case Instruction::UDiv:
8103 case Instruction::SDiv:
8104 case Instruction::URem:
8105 case Instruction::SRem:
8106 return Handle(
I->getOperand(1));
8123 I, [&](
const Value *V) {
return KnownPoison.
count(V); });
8137 if (
const auto *Inst = dyn_cast<Instruction>(V)) {
8141 }
else if (
const auto *Arg = dyn_cast<Argument>(V)) {
8142 if (Arg->getParent()->isDeclaration())
8145 Begin = BB->
begin();
8152 unsigned ScanLimit = 32;
8161 if (isa<DbgInfoIntrinsic>(
I))
8163 if (--ScanLimit == 0)
8167 return WellDefinedOp == V;
8187 if (isa<DbgInfoIntrinsic>(
I))
8189 if (--ScanLimit == 0)
8197 for (
const Use &
Op :
I.operands()) {
8207 if (
I.getOpcode() == Instruction::Select &&
8208 YieldsPoison.
count(
I.getOperand(1)) &&
8209 YieldsPoison.
count(
I.getOperand(2))) {
8215 if (!BB || !Visited.
insert(BB).second)
8225 return ::programUndefinedIfUndefOrPoison(Inst,
false);
8229 return ::programUndefinedIfUndefOrPoison(Inst,
true);
8236 if (
auto *
C = dyn_cast<ConstantFP>(V))
8239 if (
auto *
C = dyn_cast<ConstantDataVector>(V)) {
8240 if (!
C->getElementType()->isFloatingPointTy())
8242 for (
unsigned I = 0, E =
C->getNumElements();
I < E; ++
I) {
8243 if (
C->getElementAsAPFloat(
I).isNaN())
8249 if (isa<ConstantAggregateZero>(V))
8256 if (
auto *
C = dyn_cast<ConstantFP>(V))
8257 return !
C->isZero();
8259 if (
auto *
C = dyn_cast<ConstantDataVector>(V)) {
8260 if (!
C->getElementType()->isFloatingPointTy())
8262 for (
unsigned I = 0, E =
C->getNumElements();
I < E; ++
I) {
8263 if (
C->getElementAsAPFloat(
I).isZero())
8286 if (CmpRHS == FalseVal) {
8330 if (CmpRHS != TrueVal) {
8369 Value *
A =
nullptr, *
B =
nullptr;
8374 Value *
C =
nullptr, *
D =
nullptr;
8376 if (L.Flavor != R.Flavor)
8428 return {L.Flavor,
SPNB_NA,
false};
8435 return {L.Flavor,
SPNB_NA,
false};
8442 return {L.Flavor,
SPNB_NA,
false};
8449 return {L.Flavor,
SPNB_NA,
false};
8465 return ConstantInt::get(V->getType(), ~(*
C));
8522 if ((CmpLHS == TrueVal &&
match(FalseVal,
m_APInt(C2))) ||
8542 assert(
X &&
Y &&
"Invalid operand");
8544 auto IsNegationOf = [&](
const Value *
X,
const Value *
Y) {
8548 auto *BO = cast<BinaryOperator>(
X);
8549 if (NeedNSW && !BO->hasNoSignedWrap())
8552 auto *Zero = cast<Constant>(BO->getOperand(0));
8553 if (!AllowPoison && !Zero->isNullValue())
8560 if (IsNegationOf(
X,
Y) || IsNegationOf(
Y,
X))
8580 if (cast<ICmpInst>(
X)->hasSameSign() != cast<ICmpInst>(
Y)->hasSameSign())
8587 const APInt *RHSC1, *RHSC2;
8592 if (cast<ICmpInst>(
X)->hasSameSign() &&
8599 return CR1.inverse() == CR2;
8639 bool HasMismatchedZeros =
false;
8645 Value *OutputZeroVal =
nullptr;
8647 !cast<Constant>(TrueVal)->containsUndefOrPoisonElement())
8648 OutputZeroVal = TrueVal;
8650 !cast<Constant>(FalseVal)->containsUndefOrPoisonElement())
8651 OutputZeroVal = FalseVal;
8653 if (OutputZeroVal) {
8655 HasMismatchedZeros =
true;
8656 CmpLHS = OutputZeroVal;
8659 HasMismatchedZeros =
true;
8660 CmpRHS = OutputZeroVal;
8677 if (!HasMismatchedZeros)
8688 bool Ordered =
false;
8699 if (LHSSafe && RHSSafe) {
8729 if (TrueVal == CmpRHS && FalseVal == CmpLHS) {
8740 if (TrueVal == CmpLHS && FalseVal == CmpRHS)
8746 auto MaybeSExtCmpLHS =
8750 if (
match(TrueVal, MaybeSExtCmpLHS)) {
8772 else if (
match(FalseVal, MaybeSExtCmpLHS)) {
8812 case Instruction::ZExt:
8816 case Instruction::SExt:
8820 case Instruction::Trunc:
8823 CmpConst->
getType() == SrcTy) {
8845 CastedTo = CmpConst;
8847 unsigned ExtOp = CmpI->
isSigned() ? Instruction::SExt : Instruction::ZExt;
8851 case Instruction::FPTrunc:
8854 case Instruction::FPExt:
8857 case Instruction::FPToUI:
8860 case Instruction::FPToSI:
8863 case Instruction::UIToFP:
8866 case Instruction::SIToFP:
8879 if (CastedBack && CastedBack !=
C)
8903 auto *Cast1 = dyn_cast<CastInst>(V1);
8907 *CastOp = Cast1->getOpcode();
8908 Type *SrcTy = Cast1->getSrcTy();
8909 if (
auto *Cast2 = dyn_cast<CastInst>(V2)) {
8911 if (*CastOp == Cast2->getOpcode() && SrcTy == Cast2->getSrcTy())
8912 return Cast2->getOperand(0);
8916 auto *
C = dyn_cast<Constant>(V2);
8920 Value *CastedTo =
nullptr;
8921 if (*CastOp == Instruction::Trunc) {
8934 assert(V2->getType() == Cast1->getType() &&
8935 "V2 and Cast1 should be the same type.");
8951 CmpInst *CmpI = dyn_cast<CmpInst>(SI->getCondition());
8954 Value *TrueVal = SI->getTrueValue();
8955 Value *FalseVal = SI->getFalseValue();
8968 if (isa<FPMathOperator>(CmpI))
8976 if (CastOp && CmpLHS->
getType() != TrueVal->getType()) {
8980 if (*CastOp == Instruction::FPToSI || *CastOp == Instruction::FPToUI)
8982 return ::matchSelectPattern(Pred, FMF, CmpLHS, CmpRHS,
8983 cast<CastInst>(TrueVal)->getOperand(0),
C,
8989 if (*CastOp == Instruction::FPToSI || *CastOp == Instruction::FPToUI)
8991 return ::matchSelectPattern(Pred, FMF, CmpLHS, CmpRHS,
8992 C, cast<CastInst>(FalseVal)->getOperand(0),
8996 return ::matchSelectPattern(Pred, FMF, CmpLHS, CmpRHS, TrueVal, FalseVal,
9015 return Intrinsic::umin;
9017 return Intrinsic::umax;
9019 return Intrinsic::smin;
9021 return Intrinsic::smax;
9037 case Intrinsic::smax:
return Intrinsic::smin;
9038 case Intrinsic::smin:
return Intrinsic::smax;
9039 case Intrinsic::umax:
return Intrinsic::umin;
9040 case Intrinsic::umin:
return Intrinsic::umax;
9043 case Intrinsic::maximum:
return Intrinsic::minimum;
9044 case Intrinsic::minimum:
return Intrinsic::maximum;
9045 case Intrinsic::maxnum:
return Intrinsic::minnum;
9046 case Intrinsic::minnum:
return Intrinsic::maxnum;
9061std::pair<Intrinsic::ID, bool>
9066 bool AllCmpSingleUse =
true;
9069 if (
all_of(VL, [&SelectPattern, &AllCmpSingleUse](
Value *
I) {
9075 SelectPattern.
Flavor != CurrentPattern.Flavor)
9077 SelectPattern = CurrentPattern;
9082 switch (SelectPattern.
Flavor) {
9084 return {Intrinsic::smin, AllCmpSingleUse};
9086 return {Intrinsic::umin, AllCmpSingleUse};
9088 return {Intrinsic::smax, AllCmpSingleUse};
9090 return {Intrinsic::umax, AllCmpSingleUse};
9092 return {Intrinsic::maxnum, AllCmpSingleUse};
9094 return {Intrinsic::minnum, AllCmpSingleUse};
9107 if (
P->getNumIncomingValues() != 2)
9110 for (
unsigned i = 0; i != 2; ++i) {
9111 Value *L =
P->getIncomingValue(i);
9112 Value *R =
P->getIncomingValue(!i);
9113 auto *LU = dyn_cast<BinaryOperator>(L);
9116 unsigned Opcode = LU->getOpcode();
9122 case Instruction::LShr:
9123 case Instruction::AShr:
9124 case Instruction::Shl:
9125 case Instruction::Add:
9126 case Instruction::Sub:
9127 case Instruction::UDiv:
9128 case Instruction::URem:
9129 case Instruction::And:
9130 case Instruction::Or:
9131 case Instruction::Mul:
9132 case Instruction::FMul: {
9133 Value *LL = LU->getOperand(0);
9134 Value *LR = LU->getOperand(1);
9164 P = dyn_cast<PHINode>(
I->getOperand(0));
9166 P = dyn_cast<PHINode>(
I->getOperand(1));
9187 return !
C->isNegative();
9199 const APInt *CLHS, *CRHS;
9202 return CLHS->
sle(*CRHS);
9240 const APInt *CLHS, *CRHS;
9243 return CLHS->
ule(*CRHS);
9252static std::optional<bool>
9257 return std::nullopt;
9264 return std::nullopt;
9271 return std::nullopt;
9278 return std::nullopt;
9285 return std::nullopt;
9292static std::optional<bool>
9300 return std::nullopt;
9311 if (DomCR.
icmp(RPred, RCR))
9317 return std::nullopt;
9334 LHSIsTrue ?
LHS->getPredicate() :
LHS->getInversePredicate();
9358 const APInt *Unused;
9377 return std::nullopt;
9381 if (L0 == R0 && L1 == R1)
9414 return std::nullopt;
9421static std::optional<bool>
9426 assert((
LHS->getOpcode() == Instruction::And ||
9427 LHS->getOpcode() == Instruction::Or ||
9428 LHS->getOpcode() == Instruction::Select) &&
9429 "Expected LHS to be 'and', 'or', or 'select'.");
9436 const Value *ALHS, *ARHS;
9441 ALHS, RHSPred, RHSOp0, RHSOp1,
DL, LHSIsTrue,
Depth + 1))
9444 ARHS, RHSPred, RHSOp0, RHSOp1,
DL, LHSIsTrue,
Depth + 1))
9446 return std::nullopt;
9448 return std::nullopt;
9457 return std::nullopt;
9462 return std::nullopt;
9465 "Expected integer type only!");
9469 LHSIsTrue = !LHSIsTrue;
9480 if ((LHSI->getOpcode() == Instruction::And ||
9481 LHSI->getOpcode() == Instruction::Or ||
9482 LHSI->getOpcode() == Instruction::Select))
9486 return std::nullopt;
9491 bool LHSIsTrue,
unsigned Depth) {
9497 bool InvertRHS =
false;
9504 if (
const ICmpInst *RHSCmp = dyn_cast<ICmpInst>(
RHS)) {
9506 LHS, RHSCmp->getCmpPredicate(), RHSCmp->getOperand(0),
9507 RHSCmp->getOperand(1),
DL, LHSIsTrue,
Depth))
9508 return InvertRHS ? !*Implied : *Implied;
9509 return std::nullopt;
9513 return std::nullopt;
9517 const Value *RHS1, *RHS2;
9519 if (std::optional<bool> Imp =
9523 if (std::optional<bool> Imp =
9529 if (std::optional<bool> Imp =
9533 if (std::optional<bool> Imp =
9539 return std::nullopt;
9544static std::pair<Value *, bool>
9546 if (!ContextI || !ContextI->
getParent())
9547 return {
nullptr,
false};
9554 return {
nullptr,
false};
9560 return {
nullptr,
false};
9563 if (TrueBB == FalseBB)
9564 return {
nullptr,
false};
9566 assert((TrueBB == ContextBB || FalseBB == ContextBB) &&
9567 "Predecessor block does not point to successor?");
9570 return {PredCond, TrueBB == ContextBB};
9576 assert(
Cond->getType()->isIntOrIntVectorTy(1) &&
"Condition must be bool");
9580 return std::nullopt;
9592 return std::nullopt;
9597 bool PreferSignedRange) {
9598 unsigned Width =
Lower.getBitWidth();
9601 case Instruction::Add:
9610 if (PreferSignedRange && HasNSW && HasNUW)
9616 }
else if (HasNSW) {
9617 if (
C->isNegative()) {
9630 case Instruction::And:
9641 case Instruction::Or:
9647 case Instruction::AShr:
9653 unsigned ShiftAmount = Width - 1;
9654 if (!
C->isZero() && IIQ.
isExact(&BO))
9655 ShiftAmount =
C->countr_zero();
9656 if (
C->isNegative()) {
9659 Upper =
C->ashr(ShiftAmount) + 1;
9662 Lower =
C->ashr(ShiftAmount);
9668 case Instruction::LShr:
9674 unsigned ShiftAmount = Width - 1;
9675 if (!
C->isZero() && IIQ.
isExact(&BO))
9676 ShiftAmount =
C->countr_zero();
9677 Lower =
C->lshr(ShiftAmount);
9682 case Instruction::Shl:
9689 if (
C->isNegative()) {
9691 unsigned ShiftAmount =
C->countl_one() - 1;
9692 Lower =
C->shl(ShiftAmount);
9696 unsigned ShiftAmount =
C->countl_zero() - 1;
9698 Upper =
C->shl(ShiftAmount) + 1;
9717 case Instruction::SDiv:
9721 if (
C->isAllOnes()) {
9726 }
else if (
C->countl_zero() < Width - 1) {
9737 if (
C->isMinSignedValue()) {
9749 case Instruction::UDiv:
9759 case Instruction::SRem:
9765 if (
C->isNegative()) {
9776 case Instruction::URem:
9791 unsigned Width =
II.getType()->getScalarSizeInBits();
9793 switch (
II.getIntrinsicID()) {
9794 case Intrinsic::ctpop:
9795 case Intrinsic::ctlz:
9796 case Intrinsic::cttz:
9799 APInt(Width, Width) + 1);
9800 case Intrinsic::uadd_sat:
9806 case Intrinsic::sadd_sat:
9809 if (
C->isNegative())
9820 case Intrinsic::usub_sat:
9830 case Intrinsic::ssub_sat:
9832 if (
C->isNegative())
9842 if (
C->isNegative())
9853 case Intrinsic::umin:
9854 case Intrinsic::umax:
9855 case Intrinsic::smin:
9856 case Intrinsic::smax:
9861 switch (
II.getIntrinsicID()) {
9862 case Intrinsic::umin:
9864 case Intrinsic::umax:
9866 case Intrinsic::smin:
9869 case Intrinsic::smax:
9876 case Intrinsic::abs:
9885 case Intrinsic::vscale:
9886 if (!
II.getParent() || !
II.getFunction())
9889 case Intrinsic::scmp:
9890 case Intrinsic::ucmp:
9897 return ConstantRange::getFull(Width);
9902 unsigned BitWidth = SI.getType()->getScalarSizeInBits();
9906 return ConstantRange::getFull(
BitWidth);
9929 return ConstantRange::getFull(
BitWidth);
9943 return ConstantRange::getFull(
BitWidth);
9950 unsigned BitWidth =
I->getType()->getScalarSizeInBits();
9951 if (!
I->getOperand(0)->getType()->getScalarType()->isHalfTy())
9953 if (isa<FPToSIInst>(
I) &&
BitWidth >= 17) {
9958 if (isa<FPToUIInst>(
I) &&
BitWidth >= 16) {
9969 assert(V->getType()->isIntOrIntVectorTy() &&
"Expected integer instruction");
9972 return ConstantRange::getFull(V->getType()->getScalarSizeInBits());
9974 if (
auto *
C = dyn_cast<Constant>(V))
9975 return C->toConstantRange();
9977 unsigned BitWidth = V->getType()->getScalarSizeInBits();
9980 if (
auto *BO = dyn_cast<BinaryOperator>(V)) {
9986 }
else if (
auto *
II = dyn_cast<IntrinsicInst>(V))
9988 else if (
auto *SI = dyn_cast<SelectInst>(V)) {
9990 SI->getTrueValue(), ForSigned, UseInstrInfo, AC, CtxI, DT,
Depth + 1);
9992 SI->getFalseValue(), ForSigned, UseInstrInfo, AC, CtxI, DT,
Depth + 1);
9995 }
else if (isa<FPToUIInst>(V) || isa<FPToSIInst>(V)) {
10001 }
else if (
const auto *
A = dyn_cast<Argument>(V))
10002 if (std::optional<ConstantRange>
Range =
A->getRange())
10005 if (
auto *
I = dyn_cast<Instruction>(V)) {
10009 if (
const auto *CB = dyn_cast<CallBase>(V))
10010 if (std::optional<ConstantRange>
Range = CB->getRange())
10019 CallInst *
I = cast<CallInst>(AssumeVH);
10021 "Got assumption for the wrong function!");
10022 assert(
I->getIntrinsicID() == Intrinsic::assume &&
10023 "must be an assume intrinsic");
10027 Value *Arg =
I->getArgOperand(0);
10028 ICmpInst *Cmp = dyn_cast<ICmpInst>(Arg);
10030 if (!Cmp || Cmp->getOperand(0) != V)
10035 UseInstrInfo, AC,
I, DT,
Depth + 1);
10048 if (isa<Argument>(V) || isa<GlobalValue>(V)) {
10050 }
else if (
auto *
I = dyn_cast<Instruction>(V)) {
10056 if (isa<Instruction>(
Op) || isa<Argument>(
Op))
10057 InsertAffected(
Op);
10064 auto AddAffected = [&InsertAffected](
Value *V) {
10079 while (!Worklist.
empty()) {
10081 if (!Visited.
insert(V).second)
10104 AddCmpOperands(
A,
B);
10155 if (HasRHSC &&
match(
A, m_Intrinsic<Intrinsic::ctpop>(
m_Value(
X))))
10158 AddCmpOperands(
A,
B);
10168 }
else if (
match(V, m_Intrinsic<Intrinsic::is_fpclass>(
m_Value(
A),
AMDGPU Register Bank Select
This file declares a class to represent arbitrary precision floating point values and provide a varie...
This file implements a class to represent arbitrary precision integral constant values and operations...
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Function Alias Analysis Results
This file contains the simple types necessary to represent the attributes associated with functions a...
BlockVerifier::State From
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
This file contains the declarations for the subclasses of Constant, which represent the different fla...
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
std::optional< std::vector< StOtherPiece > > Other
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
static MaybeAlign getAlign(Value *Ptr)
Module.h This file contains the declarations for the Module class.
static const unsigned MaxDepth
static bool hasNoUnsignedWrap(BinaryOperator &I)
mir Rename Register Operands
ConstantRange Range(APInt(BitWidth, Low), APInt(BitWidth, High))
uint64_t IntrinsicInst * II
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
const SmallVectorImpl< MachineOperand > & Cond
static bool mayHaveSideEffects(MachineInstr &MI)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the make_scope_exit function, which executes user-defined cleanup logic at scope ex...
This file defines the SmallPtrSet class.
This file defines the SmallSet class.
This file defines the SmallVector class.
static std::optional< unsigned > getOpcode(ArrayRef< VPValue * > Values)
Returns the opcode of Values or ~0 if they do not all agree.
static SmallVector< VPValue *, 4 > getOperands(ArrayRef< VPValue * > Values, unsigned OperandIndex)
static bool getShuffleDemandedElts(const ShuffleVectorInst *Shuf, const APInt &DemandedElts, APInt &DemandedLHS, APInt &DemandedRHS)
static std::optional< bool > isImpliedCondICmps(const ICmpInst *LHS, CmpInst::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 cl::opt< unsigned > DomConditionsMaxUses("dom-conditions-max-uses", cl::Hidden, cl::init(20))
static unsigned computeNumSignBitsVectorConstant(const Value *V, const APInt &DemandedElts, unsigned TyBits)
For vector constants, loop over the elements and find the constant with the minimum number of sign bi...
static bool isKnownNonZeroFromOperator(const Operator *I, const APInt &DemandedElts, unsigned Depth, const SimplifyQuery &Q)
static bool isTruePredicate(CmpInst::Predicate Pred, const Value *LHS, const Value *RHS)
Return true if "icmp Pred LHS RHS" is always true.
static bool isNonZeroMul(const APInt &DemandedElts, unsigned Depth, const SimplifyQuery &Q, unsigned BitWidth, Value *X, Value *Y, bool NSW, bool NUW)
static bool isKnownNonNullFromDominatingCondition(const Value *V, const Instruction *CtxI, const DominatorTree *DT)
static const Value * getUnderlyingObjectFromInt(const Value *V)
This is the function that does the work of looking through basic ptrtoint+arithmetic+inttoptr sequenc...
static bool isNonZeroShift(const Operator *I, const APInt &DemandedElts, unsigned Depth, const SimplifyQuery &Q, const KnownBits &KnownVal)
static bool rangeMetadataExcludesValue(const MDNode *Ranges, const APInt &Value)
Does the 'Range' metadata (which must be a valid MD_range operand list) ensure that the value it's at...
static bool outputDenormalIsIEEEOrPosZero(const Function &F, const Type *Ty)
static bool inputDenormalIsIEEE(const Function &F, const Type *Ty)
Return true if it's possible to assume IEEE treatment of input denormals in F for Val.
static OverflowResult mapOverflowResult(ConstantRange::OverflowResult OR)
Convert ConstantRange OverflowResult into ValueTracking OverflowResult.
static bool isNonEqualPHIs(const PHINode *PN1, const PHINode *PN2, const APInt &DemandedElts, unsigned Depth, const SimplifyQuery &Q)
static bool isNonEqualShl(const Value *V1, const Value *V2, const APInt &DemandedElts, unsigned Depth, const SimplifyQuery &Q)
Return true if V2 == V1 << C, where V1 is known non-zero, C is not 0 and the shift is nuw or nsw.
static void addValueAffectedByCondition(Value *V, function_ref< void(Value *)> InsertAffected)
static unsigned getBitWidth(Type *Ty, const DataLayout &DL)
Returns the bitwidth of the given scalar or pointer type.
static std::tuple< Value *, FPClassTest, FPClassTest > exactClass(Value *V, FPClassTest M)
Return the return value for fcmpImpliesClass for a compare that produces an exact class test.
static bool haveNoCommonBitsSetSpecialCases(const Value *LHS, const Value *RHS, const SimplifyQuery &SQ)
static void setLimitsForBinOp(const BinaryOperator &BO, APInt &Lower, APInt &Upper, const InstrInfoQuery &IIQ, bool PreferSignedRange)
static Value * lookThroughCast(CmpInst *CmpI, Value *V1, Value *V2, Instruction::CastOps *CastOp)
Helps to match a select pattern in case of a type mismatch.
static std::pair< Value *, bool > getDomPredecessorCondition(const Instruction *ContextI)
static bool isKnownNonEqual(const Value *V1, const Value *V2, const APInt &DemandedElts, unsigned Depth, const SimplifyQuery &Q)
Return true if it is known that V1 != V2.
static bool isKnownNonZero(const Value *V, const APInt &DemandedElts, const SimplifyQuery &Q, unsigned Depth)
Return true if the given value is known to be non-zero when defined.
static bool isNonEqualSelect(const Value *V1, const Value *V2, const APInt &DemandedElts, unsigned Depth, const SimplifyQuery &Q)
static unsigned ComputeNumSignBits(const Value *V, const APInt &DemandedElts, unsigned Depth, const SimplifyQuery &Q)
static bool includesPoison(UndefPoisonKind Kind)
static bool isNonEqualMul(const Value *V1, const Value *V2, const APInt &DemandedElts, unsigned Depth, const SimplifyQuery &Q)
Return true if V2 == V1 * C, where V1 is known non-zero, C is not 0/1 and the multiplication is nuw o...
static SelectPatternResult matchFastFloatClamp(CmpInst::Predicate Pred, Value *CmpLHS, Value *CmpRHS, Value *TrueVal, Value *FalseVal, Value *&LHS, Value *&RHS)
Match clamp pattern for float types without care about NaNs or signed zeros.
static bool includesUndef(UndefPoisonKind Kind)
static bool isPowerOfTwoRecurrence(const PHINode *PN, bool OrZero, unsigned Depth, SimplifyQuery &Q)
Try to detect a recurrence that the value of the induction variable is always a power of two (or zero...
static bool isModifyingBinopOfNonZero(const Value *V1, const Value *V2, const APInt &DemandedElts, unsigned Depth, const SimplifyQuery &Q)
Return true if V1 == (binop V2, X), where X is known non-zero.
static ConstantRange getRangeForSelectPattern(const SelectInst &SI, const InstrInfoQuery &IIQ)
static SelectPatternResult matchSelectPattern(CmpInst::Predicate Pred, FastMathFlags FMF, Value *CmpLHS, Value *CmpRHS, Value *TrueVal, Value *FalseVal, Value *&LHS, Value *&RHS, unsigned Depth)
static uint64_t GetStringLengthH(const Value *V, SmallPtrSetImpl< const PHINode * > &PHIs, unsigned CharSize)
If we can compute the length of the string pointed to by the specified pointer, return 'len+1'.
static bool onlyUsedByLifetimeMarkersOrDroppableInstsHelper(const Value *V, bool AllowLifetime, bool AllowDroppable)
static std::optional< bool > isImpliedCondAndOr(const Instruction *LHS, CmpPredicate RHSPred, const Value *RHSOp0, const Value *RHSOp1, const DataLayout &DL, bool LHSIsTrue, unsigned Depth)
Return true if LHS implies RHS is true.
static void computeKnownFPClassFromCond(const Value *V, Value *Cond, unsigned Depth, bool CondIsTrue, const Instruction *CxtI, KnownFPClass &KnownFromContext)
static bool isSignedMinMaxClamp(const Value *Select, const Value *&In, const APInt *&CLow, const APInt *&CHigh)
static void computeKnownBitsAddSub(bool Add, const Value *Op0, const Value *Op1, bool NSW, bool NUW, const APInt &DemandedElts, KnownBits &KnownOut, KnownBits &Known2, unsigned Depth, const SimplifyQuery &Q)
static void computeKnownBitsFromOperator(const Operator *I, const APInt &DemandedElts, KnownBits &Known, unsigned Depth, const SimplifyQuery &Q)
static bool directlyImpliesPoison(const Value *ValAssumedPoison, const Value *V, unsigned Depth)
static void computeKnownBitsFromCmp(const Value *V, CmpInst::Predicate Pred, Value *LHS, Value *RHS, KnownBits &Known, const SimplifyQuery &Q)
static SelectPatternResult matchMinMaxOfMinMax(CmpInst::Predicate Pred, Value *CmpLHS, Value *CmpRHS, Value *TVal, Value *FVal, unsigned Depth)
Recognize variations of: a < c ? min(a,b) : min(b,c) ==> min(min(a,b),min(b,c))
static void 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 std::optional< bool > isImpliedCondCommonOperandWithCR(CmpInst::Predicate LPred, const ConstantRange &LCR, CmpInst::Predicate RPred, const ConstantRange &RCR)
Return true if "icmp LPred X, LCR" implies "icmp RPred X, RCR" is true.
static Value * lookThroughCastConst(CmpInst *CmpI, Type *SrcTy, Constant *C, Instruction::CastOps *CastOp)
static void computeKnownFPClassForFPTrunc(const Operator *Op, const APInt &DemandedElts, FPClassTest InterestedClasses, KnownFPClass &Known, unsigned Depth, const SimplifyQuery &Q)
static bool handleGuaranteedWellDefinedOps(const Instruction *I, const CallableT &Handle)
Enumerates all operands of I that are guaranteed to not be undef or poison.
static void computeKnownBits(const Value *V, const APInt &DemandedElts, KnownBits &Known, unsigned Depth, const SimplifyQuery &Q)
Determine which bits of V are known to be either zero or one and return them in the Known bit set.
static KnownFPClass computeKnownFPClassFromContext(const Value *V, const SimplifyQuery &Q)
static Value * getNotValue(Value *V)
If the input value is the result of a 'not' op, constant integer, or vector splat of a constant integ...
static void computeKnownBitsFromCond(const Value *V, Value *Cond, KnownBits &Known, unsigned Depth, const SimplifyQuery &SQ, bool Invert)
static void computeKnownBitsFromICmpCond(const Value *V, ICmpInst *Cmp, KnownBits &Known, const SimplifyQuery &SQ, bool Invert)
static ConstantRange getRangeForIntrinsic(const IntrinsicInst &II)
static KnownBits computeKnownBitsForHorizontalOperation(const Operator *I, const APInt &DemandedElts, unsigned Depth, const SimplifyQuery &Q, const function_ref< KnownBits(const KnownBits &, const KnownBits &)> KnownBitsFunc)
static bool matchOpWithOpEqZero(Value *Op0, Value *Op1)
static bool isNonZeroRecurrence(const PHINode *PN)
Try to detect a recurrence that monotonically increases/decreases from a non-zero starting value.
static void computeKnownBitsMul(const Value *Op0, const Value *Op1, bool NSW, bool NUW, const APInt &DemandedElts, KnownBits &Known, KnownBits &Known2, unsigned Depth, const SimplifyQuery &Q)
static SelectPatternResult matchClamp(CmpInst::Predicate Pred, Value *CmpLHS, Value *CmpRHS, Value *TrueVal, Value *FalseVal)
Recognize variations of: CLAMP(v,l,h) ==> ((v) < (l) ? (l) : ((v) > (h) ? (h) : (v)))
static bool shiftAmountKnownInRange(const Value *ShiftAmount)
Shifts return poison if shiftwidth is larger than the bitwidth.
static bool isEphemeralValueOf(const Instruction *I, const Value *E)
static SelectPatternResult matchMinMax(CmpInst::Predicate Pred, Value *CmpLHS, Value *CmpRHS, Value *TrueVal, Value *FalseVal, Value *&LHS, Value *&RHS, unsigned Depth)
Match non-obvious integer minimum and maximum sequences.
static bool isGEPKnownNonNull(const GEPOperator *GEP, unsigned Depth, const SimplifyQuery &Q)
Test whether a GEP's result is known to be non-null.
static bool handleGuaranteedNonPoisonOps(const Instruction *I, const CallableT &Handle)
Enumerates all operands of I that are guaranteed to not be poison.
static bool isNonZeroSub(const APInt &DemandedElts, unsigned Depth, const SimplifyQuery &Q, unsigned BitWidth, Value *X, Value *Y)
static std::optional< std::pair< Value *, Value * > > getInvertibleOperands(const Operator *Op1, const Operator *Op2)
If the pair of operators are the same invertible function, return the the operands of the function co...
static void computeKnownBitsFromShiftOperator(const Operator *I, const APInt &DemandedElts, KnownBits &Known, KnownBits &Known2, unsigned Depth, const SimplifyQuery &Q, function_ref< KnownBits(const KnownBits &, const KnownBits &, bool)> KF)
Compute known bits from a shift operator, including those with a non-constant shift amount.
static bool cmpExcludesZero(CmpInst::Predicate Pred, const Value *RHS)
static bool inputDenormalIsIEEEOrPosZero(const Function &F, const Type *Ty)
static KnownBits getKnownBitsFromAndXorOr(const Operator *I, const APInt &DemandedElts, const KnownBits &KnownLHS, const KnownBits &KnownRHS, unsigned Depth, const SimplifyQuery &Q)
static bool isKnownNonZeroFromAssume(const Value *V, const SimplifyQuery &Q)
static std::optional< bool > isImpliedCondOperands(CmpInst::Predicate Pred, const Value *ALHS, const Value *ARHS, const Value *BLHS, const Value *BRHS)
Return true if "icmp Pred BLHS BRHS" is true whenever "icmp Pred ALHS ARHS" is true.
static unsigned ComputeNumSignBitsImpl(const Value *V, const APInt &DemandedElts, unsigned Depth, const SimplifyQuery &Q)
Return the number of times the sign bit of the register is replicated into the other bits.
static bool isNonZeroAdd(const APInt &DemandedElts, unsigned Depth, const SimplifyQuery &Q, unsigned BitWidth, Value *X, Value *Y, bool NSW, bool NUW)
static const Instruction * safeCxtI(const Value *V, const Instruction *CxtI)
static bool isImpliedToBeAPowerOfTwoFromCond(const Value *V, bool OrZero, const Value *Cond, bool CondIsTrue)
Return true if we can infer that V is known to be a power of 2 from dominating condition Cond (e....
static bool isKnownNonNaN(const Value *V, FastMathFlags FMF)
static std::optional< bool > isImpliedCondMatchingOperands(CmpInst::Predicate LPred, CmpInst::Predicate RPred)
Return true if "icmp1 LPred X, Y" implies "icmp2 RPred X, Y" is true.
static Value * BuildSubAggregate(Value *From, Value *To, Type *IndexedType, SmallVectorImpl< unsigned > &Idxs, unsigned IdxSkip, BasicBlock::iterator InsertBefore)
void computeKnownFPClass(const Value *V, const APInt &DemandedElts, FPClassTest InterestedClasses, KnownFPClass &Known, unsigned Depth, const SimplifyQuery &Q)
APInt bitcastToAPInt() const
static APFloat getLargest(const fltSemantics &Sem, bool Negative=false)
Returns the largest finite number in the given semantics.
static APFloat getInf(const fltSemantics &Sem, bool Negative=false)
Factory for Positive and Negative Infinity.
FPClassTest classify() const
Return the FPClassTest which will return true for the value.
static APFloat getZero(const fltSemantics &Sem, bool Negative=false)
Factory for Positive and Negative Zero.
bool isSmallestNormalized() const
Class for arbitrary precision integers.
APInt udiv(const APInt &RHS) const
Unsigned division operation.
static APInt getAllOnes(unsigned numBits)
Return an APInt of a specified width with all bits set.
void clearBit(unsigned BitPosition)
Set a given bit to 0.
bool isMinSignedValue() const
Determine if this is the smallest signed value.
uint64_t getZExtValue() const
Get zero extended value.
void setHighBits(unsigned hiBits)
Set the top hiBits bits.
void setBitsFrom(unsigned loBit)
Set the top bits starting from loBit.
APInt zextOrTrunc(unsigned width) const
Zero extend or truncate to width.
static APInt getMaxValue(unsigned numBits)
Gets maximum unsigned value of APInt for specific bit width.
void setBit(unsigned BitPosition)
Set the given bit to 1 whose position is given as "bitPosition".
unsigned ceilLogBase2() const
bool sgt(const APInt &RHS) const
Signed greater than comparison.
bool isAllOnes() const
Determine if all bits are set. This is true for zero-width values.
bool ugt(const APInt &RHS) const
Unsigned greater than comparison.
bool isZero() const
Determine if this value is zero, i.e. all bits are clear.
APInt urem(const APInt &RHS) const
Unsigned remainder operation.
unsigned getBitWidth() const
Return the number of bits in the APInt.
bool ult(const APInt &RHS) const
Unsigned less than comparison.
static APInt getSignedMaxValue(unsigned numBits)
Gets maximum signed value of APInt for a specific bit width.
static APInt getMinValue(unsigned numBits)
Gets minimum unsigned value of APInt for a specific bit width.
bool isNegative() const
Determine sign of this APInt.
bool intersects(const APInt &RHS) const
This operation tests if there are any pairs of corresponding bits between this APInt and RHS that are...
APInt sdiv(const APInt &RHS) const
Signed division function for APInt.
void clearAllBits()
Set every bit to 0.
APInt reverseBits() const
bool sle(const APInt &RHS) const
Signed less or equal comparison.
unsigned getNumSignBits() const
Computes the number of leading bits of this APInt that are equal to its sign bit.
static APInt getSignedMinValue(unsigned numBits)
Gets minimum signed value of APInt for a specific bit width.
APInt sextOrTrunc(unsigned width) const
Sign extend or truncate to width.
bool isStrictlyPositive() const
Determine if this APInt Value is positive.
unsigned logBase2() const
APInt ashr(unsigned ShiftAmt) const
Arithmetic right-shift function.
void setAllBits()
Set every bit to 1.
bool getBoolValue() const
Convert APInt to a boolean value.
bool isMaxSignedValue() const
Determine if this is the largest signed value.
bool isNonNegative() const
Determine if this APInt Value is non-negative (>= 0)
bool ule(const APInt &RHS) const
Unsigned less or equal comparison.
APInt shl(unsigned shiftAmt) const
Left-shift function.
bool slt(const APInt &RHS) const
Signed less than comparison.
static APInt getHighBitsSet(unsigned numBits, unsigned hiBitsSet)
Constructs an APInt value that has the top hiBitsSet bits set.
static APInt getZero(unsigned numBits)
Get the '0' value for the specified bit-width.
void setLowBits(unsigned loBits)
Set the bottom loBits bits.
bool sge(const APInt &RHS) const
Signed greater or equal comparison.
static APInt getBitsSetFrom(unsigned numBits, unsigned loBit)
Constructs an APInt value that has a contiguous range of bits set.
static APInt getOneBitSet(unsigned numBits, unsigned BitNo)
Return an APInt with exactly one bit set in the result.
void lshrInPlace(unsigned ShiftAmt)
Logical right-shift this APInt by ShiftAmt in place.
APInt lshr(unsigned shiftAmt) const
Logical right-shift function.
bool uge(const APInt &RHS) const
Unsigned greater or equal comparison.
void clearSignBit()
Set the sign bit to 0.
an instruction to allocate memory on the stack
This class represents an incoming formal argument to a Function.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
size_t size() const
size - Get the array size.
bool empty() const
empty - Check if the array is empty.
ArrayRef< T > slice(size_t N, size_t M) const
slice(n, m) - Chop off the first N elements of the array, and keep M elements in the array.
Class to represent array types.
Type * getElementType() const
This represents the llvm.assume intrinsic.
A cache of @llvm.assume calls within a function.
MutableArrayRef< ResultElem > assumptionsFor(const Value *V)
Access the list of assumptions which affect this value.
std::optional< unsigned > getVScaleRangeMax() const
Returns the maximum value for the vscale_range attribute or std::nullopt when unknown.
unsigned getVScaleRangeMin() const
Returns the minimum value for the vscale_range attribute.
bool isValid() const
Return true if the attribute is any kind of attribute.
bool isSingleEdge() const
Check if this is the only edge between Start and End.
LLVM Basic Block Representation.
iterator begin()
Instruction iterator methods.
InstListType::const_iterator const_iterator
const Instruction * getFirstNonPHI() const
Returns a pointer to the first instruction in this block that is not a PHINode instruction.
const BasicBlock * getSinglePredecessor() const
Return the predecessor of this block if it has a single predecessor block.
const BasicBlock * getSingleSuccessor() const
Return the successor of this block if it has a single successor.
const Function * getParent() const
Return the enclosing method, or null if none.
InstListType::iterator iterator
Instruction iterators...
const Instruction * getTerminator() const LLVM_READONLY
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
Instruction::BinaryOps getBinaryOp() const
Returns the binary operation underlying the intrinsic.
BinaryOps getOpcode() const
Conditional or Unconditional Branch instruction.
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Function * getCalledFunction() const
Returns the function called, or null if this is an indirect function invocation or the function signa...
bool paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const
Determine whether the argument or parameter has the given attribute.
bool isIndirectCall() const
Return true if the callsite is an indirect call.
bool onlyReadsMemory(unsigned OpNo) const
Value * getCalledOperand() const
Value * getArgOperand(unsigned i) const
unsigned arg_size() const
This class represents a function call, abstracting a target machine's calling convention.
This is the base class for all instructions that perform data casts.
This class is the base class for the comparison instructions.
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
@ FCMP_OEQ
0 0 0 1 True if ordered and equal
@ FCMP_TRUE
1 1 1 1 Always true (always folded)
@ ICMP_SLT
signed less than
@ ICMP_SLE
signed less or equal
@ FCMP_OLT
0 1 0 0 True if ordered and less than
@ FCMP_ULE
1 1 0 1 True if unordered, less than, or equal
@ FCMP_OGT
0 0 1 0 True if ordered and greater than
@ FCMP_OGE
0 0 1 1 True if ordered and greater than or equal
@ ICMP_UGE
unsigned greater or equal
@ ICMP_UGT
unsigned greater than
@ ICMP_SGT
signed greater than
@ FCMP_ULT
1 1 0 0 True if unordered or less than
@ FCMP_ONE
0 1 1 0 True if ordered and operands are unequal
@ FCMP_UEQ
1 0 0 1 True if unordered or equal
@ ICMP_ULT
unsigned less than
@ FCMP_UGT
1 0 1 0 True if unordered or greater than
@ FCMP_OLE
0 1 0 1 True if ordered and less than or equal
@ FCMP_ORD
0 1 1 1 True if ordered (no nans)
@ ICMP_SGE
signed greater or equal
@ FCMP_UNE
1 1 1 0 True if unordered or not equal
@ ICMP_ULE
unsigned less or equal
@ FCMP_UGE
1 0 1 1 True if unordered, greater than, or equal
@ FCMP_FALSE
0 0 0 0 Always false (always folded)
@ FCMP_UNO
1 0 0 0 True if unordered: isnan(X) | isnan(Y)
static bool isEquality(Predicate pred)
Determine if this is an equals/not equals predicate.
Predicate getSwappedPredicate() const
For example, EQ->EQ, SLE->SGE, ULT->UGT, OEQ->OEQ, ULE->UGE, OLT->OGT, etc.
bool isTrueWhenEqual() const
This is just a convenience.
bool isFPPredicate() const
Predicate getInversePredicate() const
For example, EQ -> NE, UGT -> ULE, SLT -> SGE, OEQ -> UNE, UGT -> OLE, OLT -> UGE,...
Predicate getPredicate() const
Return the predicate for this instruction.
static bool isUnordered(Predicate predicate)
Determine if the predicate is an unordered operation.
static bool isImpliedTrueByMatchingCmp(Predicate Pred1, Predicate Pred2)
Determine if Pred1 implies Pred2 is true when two compares have matching operands.
bool isIntPredicate() const
static bool isOrdered(Predicate predicate)
Determine if the predicate is an ordered operation.
static bool isImpliedFalseByMatchingCmp(Predicate Pred1, Predicate Pred2)
Determine if Pred1 implies Pred2 is false when two compares have matching operands.
An abstraction over a floating-point predicate, and a pack of an integer predicate with samesign info...
static std::optional< CmpPredicate > getMatching(CmpPredicate A, CmpPredicate B)
Compares two CmpPredicates taking samesign into account and returns the canonicalized CmpPredicate if...
An array constant whose element type is a simple 1/2/4/8-byte integer or float/double,...
ConstantDataSequential - A vector or array constant whose element type is a simple 1/2/4/8-byte integ...
StringRef getAsString() const
If this array is isString(), then this method returns the array as a StringRef.
uint64_t getElementAsInteger(unsigned i) const
If this is a sequential container of integers (of any size), return the specified element in the low ...
A vector constant whose element type is a simple 1/2/4/8-byte integer or float/double,...
static Constant * getBitCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
static Constant * getTrunc(Constant *C, Type *Ty, bool OnlyIfReduced=false)
ConstantFP - Floating Point Values [float, double].
This is the shared class of boolean and integer constants.
static ConstantInt * getTrue(LLVMContext &Context)
bool isZero() const
This is just a convenience method to make client code smaller for a common code.
uint64_t getZExtValue() const
Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...
This class represents a range of values.
PreferredRangeType
If represented precisely, the result of some range operations may consist of multiple disjoint ranges...
const APInt * getSingleElement() const
If this set contains a single element, return it, otherwise return null.
static ConstantRange fromKnownBits(const KnownBits &Known, bool IsSigned)
Initialize a range based on a known bits constraint.
OverflowResult unsignedSubMayOverflow(const ConstantRange &Other) const
Return whether unsigned sub of the two ranges always/never overflows.
bool isAllNegative() const
Return true if all values in this range are negative.
OverflowResult unsignedAddMayOverflow(const ConstantRange &Other) const
Return whether unsigned add of the two ranges always/never overflows.
KnownBits toKnownBits() const
Return known bits for values in this range.
APInt getUnsignedMin() const
Return the smallest unsigned value contained in the ConstantRange.
bool icmp(CmpInst::Predicate Pred, const ConstantRange &Other) const
Does the predicate Pred hold between ranges this and Other? NOTE: false does not mean that inverse pr...
APInt getSignedMin() const
Return the smallest signed value contained in the ConstantRange.
OverflowResult unsignedMulMayOverflow(const ConstantRange &Other) const
Return whether unsigned mul of the two ranges always/never overflows.
bool isAllNonNegative() const
Return true if all values in this range are non-negative.
static ConstantRange makeAllowedICmpRegion(CmpInst::Predicate Pred, const ConstantRange &Other)
Produce the smallest range such that all values that may satisfy the given predicate with any value c...
ConstantRange unionWith(const ConstantRange &CR, PreferredRangeType Type=Smallest) const
Return the range that results from the union of this range with another range.
static ConstantRange makeExactICmpRegion(CmpInst::Predicate Pred, const APInt &Other)
Produce the exact range such that all values in the returned range satisfy the given predicate with a...
bool contains(const APInt &Val) const
Return true if the specified value is in the set.
OverflowResult signedAddMayOverflow(const ConstantRange &Other) const
Return whether signed add of the two ranges always/never overflows.
APInt getUnsignedMax() const
Return the largest unsigned value contained in the ConstantRange.
ConstantRange intersectWith(const ConstantRange &CR, PreferredRangeType Type=Smallest) const
Return the range that results from the intersection of this range with another range.
OverflowResult
Represents whether an operation on the given constant range is known to always or never overflow.
@ NeverOverflows
Never overflows.
@ AlwaysOverflowsHigh
Always overflows in the direction of signed/unsigned max value.
@ AlwaysOverflowsLow
Always overflows in the direction of signed/unsigned min value.
@ MayOverflow
May or may not overflow.
static ConstantRange getNonEmpty(APInt Lower, APInt Upper)
Create non-empty constant range with the given bounds.
uint32_t getBitWidth() const
Get the bit width of this ConstantRange.
OverflowResult signedSubMayOverflow(const ConstantRange &Other) const
Return whether signed sub of the two ranges always/never overflows.
ConstantRange sub(const ConstantRange &Other) const
Return a new range representing the possible values resulting from a subtraction of a value in this r...
This is an important base class in LLVM.
Constant * getSplatValue(bool AllowPoison=false) const
If all elements of the vector constant have the same value, return that value.
static Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
Constant * getAggregateElement(unsigned Elt) const
For aggregates (struct/array/vector) return the constant that corresponds to the specified element if...
bool isZeroValue() const
Return true if the value is negative zero or null value.
bool isNullValue() const
Return true if this is the value that would be returned by getNullValue.
This class represents an Operation in the Expression.
A parsed version of the target data layout string in and methods for querying it.
bool isLittleEndian() const
Layout endianness...
const StructLayout * getStructLayout(StructType *Ty) const
Returns a StructLayout object, indicating the alignment of the struct, its size, and the offsets of i...
unsigned getIndexTypeSizeInBits(Type *Ty) const
Layout size of the index used in GEP calculation.
unsigned getPointerTypeSizeInBits(Type *) const
Layout pointer size, in bits, based on the type.
TypeSize getTypeSizeInBits(Type *Ty) const
Size examples:
ArrayRef< BranchInst * > conditionsFor(const Value *V) const
Access the list of branches which affect this value.
DomTreeNodeBase * getIDom() const
DomTreeNodeBase< NodeT > * getNode(const NodeT *BB) const
getNode - return the (Post)DominatorTree node for the specified basic block.
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
bool dominates(const BasicBlock *BB, const Use &U) const
Return true if the (end of the) basic block BB dominates the use U.
Utility class for floating point operations which can have information about relaxed accuracy require...
Convenience struct for specifying and reasoning about fast-math flags.
bool noSignedZeros() const
void setNoSignedZeros(bool B=true)
const BasicBlock & getEntryBlock() const
DenormalMode getDenormalMode(const fltSemantics &FPType) const
Returns the denormal handling type for the default rounding mode of the function.
an instruction for type-safe pointer arithmetic to access elements of arrays and structs
const DataLayout & getDataLayout() const
Get the data layout of the module this global belongs to.
Type * getValueType() const
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
bool isConstant() const
If the value is a global constant, its value is immutable throughout the runtime execution of the pro...
bool hasDefinitiveInitializer() const
hasDefinitiveInitializer - Whether the global variable has an initializer, and any other instances of...
This instruction compares its operands according to the predicate given to the constructor.
bool isEquality() const
Return true if this predicate is either EQ or NE.
This instruction inserts a struct field of array element value into an aggregate value.
Value * getAggregateOperand()
static InsertValueInst * Create(Value *Agg, Value *Val, ArrayRef< unsigned > Idxs, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
bool hasNoUnsignedWrap() const LLVM_READONLY
Determine whether the no unsigned wrap flag is set.
bool hasNoSignedWrap() const LLVM_READONLY
Determine whether the no signed wrap flag is set.
InstListType::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
bool isExact() const LLVM_READONLY
Determine whether the exact flag is set.
const Function * getFunction() const
Return the function this instruction belongs to.
bool comesBefore(const Instruction *Other) const
Given an instruction Other in the same basic block as this instruction, return true if this instructi...
FastMathFlags getFastMathFlags() const LLVM_READONLY
Convenience function for getting all the fast-math flags, which must be an operator which supports th...
unsigned getOpcode() const
Returns a member of one of the enums like Instruction::Add.
const DataLayout & getDataLayout() const
Get the data layout of the module this instruction belongs to.
A wrapper class for inspecting calls to intrinsic functions.
This is an important class for using LLVM in a threaded context.
An instruction for reading from memory.
Value * getPointerOperand()
Align getAlign() const
Return the alignment of the access that is being performed.
bool isLoopHeader(const BlockT *BB) const
LoopT * getLoopFor(const BlockT *BB) const
Return the inner most loop that BB lives in.
Represents a single loop in the control flow graph.
This is a utility class that provides an abstraction for the common functionality between Instruction...
unsigned getOpcode() const
Return the opcode for this Instruction or ConstantExpr.
Utility class for integer operators which may exhibit overflow - Add, Sub, Mul, and Shl.
iterator_range< const_block_iterator > blocks() const
Value * getIncomingValueForBlock(const BasicBlock *BB) const
BasicBlock * getIncomingBlock(unsigned i) const
Return incoming basic block number i.
Value * getIncomingValue(unsigned i) const
Return incoming value number x.
unsigned getNumIncomingValues() const
Return the number of incoming edges.
static PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
A udiv or sdiv instruction, which can be marked as "exact", indicating that no bits are destroyed.
bool isExact() const
Test whether this division is known to be exact, with zero remainder.
This class represents the LLVM 'select' instruction.
const Value * getFalseValue() const
const Value * getCondition() const
const Value * getTrueValue() const
This instruction constructs a fixed permutation of two input vectors.
VectorType * getType() const
Overload to return most specific vector type.
static void getShuffleMask(const Constant *Mask, SmallVectorImpl< int > &Result)
Convert the input shuffle mask operand to a vector of integers.
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
size_type count(ConstPtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
SmallSet - This maintains a set of unique values, optimizing for the case when the set is small (less...
size_type count(const T &V) const
count - Return 1 if the element is in the set, 0 otherwise.
std::pair< const_iterator, bool > insert(const T &V)
insert - Insert an element into the set if it isn't already there.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
void reserve(size_type N)
void append(ItTy in_start, ItTy in_end)
Add the specified range to the end of the SmallVector.
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringRef - Represent a constant reference to a string, i.e.
Used to lazily calculate structure layout information for a target machine, based on the DataLayout s...
TypeSize getElementOffset(unsigned Idx) const
Class to represent struct types.
unsigned getNumElements() const
Random access to the elements.
Type * getElementType(unsigned N) const
Provides information about what library functions are available for the current target.
bool getLibFunc(StringRef funcName, LibFunc &F) const
Searches for a particular function name.
The instances of the Type class are immutable: once they are created, they are never changed.
unsigned getIntegerBitWidth() const
const fltSemantics & getFltSemantics() const
bool isVectorTy() const
True if this is an instance of VectorType.
bool isIntOrIntVectorTy() const
Return true if this is an integer type or a vector of integer types.
bool isPointerTy() const
True if this is an instance of PointerType.
uint64_t getArrayNumElements() const
static IntegerType * getIntNTy(LLVMContext &C, unsigned N)
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type.
bool isSized(SmallPtrSetImpl< Type * > *Visited=nullptr) const
Return true if it makes sense to take the size of this type.
static IntegerType * getInt16Ty(LLVMContext &C)
static IntegerType * getInt8Ty(LLVMContext &C)
bool isIEEE() const
Return whether the type is IEEE compatible, as defined by the eponymous method in APFloat.
bool isPtrOrPtrVectorTy() const
Return true if this is a pointer type or a vector of pointer types.
bool isIntOrPtrTy() const
Return true if this is an integer type or a pointer type.
static IntegerType * getInt32Ty(LLVMContext &C)
static IntegerType * getInt64Ty(LLVMContext &C)
bool isIntegerTy() const
True if this is an instance of IntegerType.
Type * getScalarType() const
If this is a vector type, return the element type, otherwise return 'this'.
static UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
A Use represents the edge between a Value definition and its users.
User * getUser() const
Returns the User that contains this Use.
unsigned getOperandNo() const
Return the operand # of this use in its User.
Value * getOperand(unsigned i) const
unsigned getNumOperands() const
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
const Value * stripAndAccumulateInBoundsConstantOffsets(const DataLayout &DL, APInt &Offset) const
This is a wrapper around stripAndAccumulateConstantOffsets with the in-bounds requirement set to fals...
iterator_range< user_iterator > users()
const KnownBits & getKnownBits(const SimplifyQuery &Q) const
PointerType getValue() const
Represents an op.with.overflow intrinsic.
constexpr ScalarTy getFixedValue() const
constexpr bool isScalable() const
Returns whether the quantity is scaled by a runtime quantity (vscale).
constexpr ScalarTy getKnownMinValue() const
Returns the minimum value this quantity can represent.
An efficient, type-erasing, non-owning reference to a callable.
StructType * getStructTypeOrNull() const
TypeSize getSequentialElementStride(const DataLayout &DL) const
Type * getIndexedType() const
const ParentTy * getParent() const
self_iterator getIterator()
A range adaptor for a pair of iterators.
This provides a very simple, boring adaptor for a begin and end iterator into a range type.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ C
The default llvm calling convention, compatible with C.
cst_pred_ty< is_all_ones > m_AllOnes()
Match an integer or vector with all bits set.
BinaryOp_match< LHS, RHS, Instruction::And > m_And(const LHS &L, const RHS &R)
PtrToIntSameSize_match< OpTy > m_PtrToIntSameSize(const DataLayout &DL, const OpTy &Op)
BinaryOp_match< LHS, RHS, Instruction::Add > m_Add(const LHS &L, const RHS &R)
CmpClass_match< LHS, RHS, FCmpInst > m_FCmp(CmpPredicate &Pred, const LHS &L, const RHS &R)
cst_pred_ty< is_sign_mask > m_SignMask()
Match an integer or vector with only the sign bit(s) set.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWAdd(const LHS &L, const RHS &R)
cst_pred_ty< is_power2 > m_Power2()
Match an integer or vector power-of-2.
BinaryOp_match< LHS, RHS, Instruction::URem > m_URem(const LHS &L, const RHS &R)
auto m_LogicalOp()
Matches either L && R or L || R where L and R are arbitrary values.
class_match< Constant > m_Constant()
Match an arbitrary Constant and ignore it.
BinaryOp_match< LHS, RHS, Instruction::And, true > m_c_And(const LHS &L, const RHS &R)
Matches an And with LHS and RHS in either order.
cst_pred_ty< is_power2_or_zero > m_Power2OrZero()
Match an integer or vector of 0 or power-of-2 values.
CastInst_match< OpTy, TruncInst > m_Trunc(const OpTy &Op)
Matches Trunc.
BinaryOp_match< LHS, RHS, Instruction::Xor > m_Xor(const LHS &L, const RHS &R)
OverflowingBinaryOp_match< LHS, RHS, Instruction::Sub, OverflowingBinaryOperator::NoSignedWrap > m_NSWSub(const LHS &L, const RHS &R)
bool match(Val *V, const Pattern &P)
BinOpPred_match< LHS, RHS, is_idiv_op > m_IDiv(const LHS &L, const RHS &R)
Matches integer division operations.
cstfp_pred_ty< is_any_zero_fp > m_AnyZeroFP()
Match a floating-point negative zero or positive zero.
specificval_ty m_Specific(const Value *V)
Match if we have a specific specified value.
BinOpPred_match< LHS, RHS, is_right_shift_op > m_Shr(const LHS &L, const RHS &R)
Matches logical shift operations.
CmpClass_match< LHS, RHS, ICmpInst, true > m_c_ICmp(CmpPredicate &Pred, const LHS &L, const RHS &R)
Matches an ICmp with a predicate over LHS and RHS in either order.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap, true > m_c_NUWAdd(const LHS &L, const RHS &R)
cst_pred_ty< is_nonnegative > m_NonNegative()
Match an integer or vector of non-negative values.
class_match< ConstantInt > m_ConstantInt()
Match an arbitrary ConstantInt and ignore it.
cst_pred_ty< is_one > m_One()
Match an integer 1 or a vector with all elements equal to 1.
ThreeOps_match< Cond, LHS, RHS, Instruction::Select > m_Select(const Cond &C, const LHS &L, const RHS &R)
Matches SelectInst.
match_combine_or< MaxMin_match< FCmpInst, LHS, RHS, ofmin_pred_ty >, MaxMin_match< FCmpInst, LHS, RHS, ufmin_pred_ty > > m_OrdOrUnordFMin(const LHS &L, const RHS &R)
Match an 'ordered' or 'unordered' floating point minimum function.
ExtractValue_match< Ind, Val_t > m_ExtractValue(const Val_t &V)
Match a single index ExtractValue instruction.
MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty > m_SMin(const LHS &L, const RHS &R)
bind_ty< WithOverflowInst > m_WithOverflowInst(WithOverflowInst *&I)
Match a with overflow intrinsic, capturing it if we match.
BinaryOp_match< LHS, RHS, Instruction::Xor, true > m_c_Xor(const LHS &L, const RHS &R)
Matches an Xor with LHS and RHS in either order.
BinaryOp_match< LHS, RHS, Instruction::Mul > m_Mul(const LHS &L, const RHS &R)
deferredval_ty< Value > m_Deferred(Value *const &V)
Like m_Specific(), but works if the specific value to match is determined as part of the same match()...
cst_pred_ty< is_zero_int > m_ZeroInt()
Match an integer 0 or a vector with all elements equal to 0.
OneUse_match< T > m_OneUse(const T &SubPattern)
MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty, true > m_c_SMin(const LHS &L, const RHS &R)
Matches an SMin with LHS and RHS in either order.
auto m_LogicalOr()
Matches L || R where L and R are arbitrary values.
BinaryOp_match< cst_pred_ty< is_zero_int >, ValTy, Instruction::Sub > m_Neg(const ValTy &V)
Matches a 'Neg' as 'sub 0, V'.
match_combine_and< class_match< Constant >, match_unless< constantexpr_match > > m_ImmConstant()
Match an arbitrary immediate Constant and ignore it.
MaxMin_match< ICmpInst, LHS, RHS, umax_pred_ty, true > m_c_UMax(const LHS &L, const RHS &R)
Matches a UMax with LHS and RHS in either order.
SpecificCmpClass_match< LHS, RHS, ICmpInst > m_SpecificICmp(CmpPredicate MatchPred, const LHS &L, const RHS &R)
CastInst_match< OpTy, ZExtInst > m_ZExt(const OpTy &Op)
Matches ZExt.
BinaryOp_match< LHS, RHS, Instruction::UDiv > m_UDiv(const LHS &L, const RHS &R)
MaxMin_match< ICmpInst, LHS, RHS, umax_pred_ty > m_UMax(const LHS &L, const RHS &R)
brc_match< Cond_t, bind_ty< BasicBlock >, bind_ty< BasicBlock > > m_Br(const Cond_t &C, BasicBlock *&T, BasicBlock *&F)
MaxMin_match< ICmpInst, LHS, RHS, umin_pred_ty, true > m_c_UMin(const LHS &L, const RHS &R)
Matches a UMin with LHS and RHS in either order.
BinaryOp_match< LHS, RHS, Instruction::Add, true > m_c_Add(const LHS &L, const RHS &R)
Matches a Add with LHS and RHS in either order.
apfloat_match m_APFloatAllowPoison(const APFloat *&Res)
Match APFloat while allowing poison in splat vector constants.
match_combine_or< BinaryOp_match< LHS, RHS, Instruction::Add >, DisjointOr_match< LHS, RHS > > m_AddLike(const LHS &L, const RHS &R)
Match either "add" or "or disjoint".
match_combine_or< MaxMin_match< FCmpInst, LHS, RHS, ofmax_pred_ty >, MaxMin_match< FCmpInst, LHS, RHS, ufmax_pred_ty > > m_OrdOrUnordFMax(const LHS &L, const RHS &R)
Match an 'ordered' or 'unordered' floating point maximum function.
MaxMin_match< ICmpInst, LHS, RHS, smax_pred_ty, true > m_c_SMax(const LHS &L, const RHS &R)
Matches an SMax with LHS and RHS in either order.
VScaleVal_match m_VScale()
OverflowingBinaryOp_match< LHS, RHS, Instruction::Sub, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWSub(const LHS &L, const RHS &R)
MaxMin_match< ICmpInst, LHS, RHS, smax_pred_ty > m_SMax(const LHS &L, const RHS &R)
apint_match m_APInt(const APInt *&Res)
Match a ConstantInt or splatted ConstantVector, binding the specified pointer to the contained APInt.
match_combine_or< OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoSignedWrap >, DisjointOr_match< LHS, RHS > > m_NSWAddLike(const LHS &L, const RHS &R)
Match either "add nsw" or "or disjoint".
class_match< Value > m_Value()
Match an arbitrary value and ignore it.
AnyBinaryOp_match< LHS, RHS, true > m_c_BinOp(const LHS &L, const RHS &R)
Matches a BinaryOperator with LHS and RHS in either order.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoSignedWrap > m_NSWAdd(const LHS &L, const RHS &R)
BinaryOp_match< LHS, RHS, Instruction::LShr > m_LShr(const LHS &L, const RHS &R)
CmpClass_match< LHS, RHS, ICmpInst > m_ICmp(CmpPredicate &Pred, const LHS &L, const RHS &R)
match_combine_or< CastInst_match< OpTy, ZExtInst >, CastInst_match< OpTy, SExtInst > > m_ZExtOrSExt(const OpTy &Op)
FNeg_match< OpTy > m_FNeg(const OpTy &X)
Match 'fneg X' as 'fsub -0.0, X'.
BinOpPred_match< LHS, RHS, is_shift_op > m_Shift(const LHS &L, const RHS &R)
Matches shift operations.
BinaryOp_match< LHS, RHS, Instruction::Shl > m_Shl(const LHS &L, const RHS &R)
BinOpPred_match< LHS, RHS, is_irem_op > m_IRem(const LHS &L, const RHS &R)
Matches integer remainder operations.
apfloat_match m_APFloat(const APFloat *&Res)
Match a ConstantFP or splatted ConstantVector, binding the specified pointer to the contained APFloat...
auto m_LogicalAnd()
Matches L && R where L and R are arbitrary values.
class_match< BasicBlock > m_BasicBlock()
Match an arbitrary basic block value and ignore it.
BinaryOp_match< LHS, RHS, Instruction::SRem > m_SRem(const LHS &L, const RHS &R)
cst_pred_ty< is_nonpositive > m_NonPositive()
Match an integer or vector of non-positive values.
BinaryOp_match< cst_pred_ty< is_all_ones >, ValTy, Instruction::Xor, true > m_Not(const ValTy &V)
Matches a 'Not' as 'xor V, -1' or 'xor -1, V'.
BinaryOp_match< LHS, RHS, Instruction::Or > m_Or(const LHS &L, const RHS &R)
CastInst_match< OpTy, SExtInst > m_SExt(const OpTy &Op)
Matches SExt.
is_zero m_Zero()
Match any null constant or a vector with all elements equal to 0.
BinaryOp_match< LHS, RHS, Instruction::Or, true > m_c_Or(const LHS &L, const RHS &R)
Matches an Or with LHS and RHS in either order.
match_combine_or< OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap >, DisjointOr_match< LHS, RHS > > m_NUWAddLike(const LHS &L, const RHS &R)
Match either "add nuw" or "or disjoint".
BinOpPred_match< LHS, RHS, is_bitwiselogic_op > m_BitwiseLogic(const LHS &L, const RHS &R)
Matches bitwise logic operations.
ElementWiseBitCast_match< OpTy > m_ElementWiseBitCast(const OpTy &Op)
m_Intrinsic_Ty< Opnd0 >::Ty m_FAbs(const Opnd0 &Op0)
CastOperator_match< OpTy, Instruction::PtrToInt > m_PtrToInt(const OpTy &Op)
Matches PtrToInt.
BinaryOp_match< LHS, RHS, Instruction::Sub > m_Sub(const LHS &L, const RHS &R)
MaxMin_match< ICmpInst, LHS, RHS, umin_pred_ty > m_UMin(const LHS &L, const RHS &R)
match_combine_or< LTy, RTy > m_CombineOr(const LTy &L, const RTy &R)
Combine two pattern matchers matching L || R.
static unsigned decodeVSEW(unsigned VSEW)
unsigned getSEWLMULRatio(unsigned SEW, RISCVII::VLMUL VLMul)
static constexpr unsigned RVVBitsPerBlock
initializer< Ty > init(const Ty &Val)
This is an optimization pass for GlobalISel generic memory operations.
bool haveNoCommonBitsSet(const WithCache< const Value * > &LHSCache, const WithCache< const Value * > &RHSCache, const SimplifyQuery &SQ)
Return true if LHS and RHS have no common bits set.
bool mustExecuteUBIfPoisonOnPathTo(Instruction *Root, Instruction *OnPathTo, DominatorTree *DT)
Return true if undefined behavior would provable be executed on the path to OnPathTo if Root produced...
Intrinsic::ID getInverseMinMaxIntrinsic(Intrinsic::ID MinMaxID)
@ NeverOverflows
Never overflows.
@ AlwaysOverflowsHigh
Always overflows in the direction of signed/unsigned max value.
@ AlwaysOverflowsLow
Always overflows in the direction of signed/unsigned min value.
@ MayOverflow
May or may not overflow.
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
bool isValidAssumeForContext(const Instruction *I, const Instruction *CxtI, const DominatorTree *DT=nullptr, bool AllowEphemerals=false)
Return true if it is valid to use the assumptions provided by an assume intrinsic,...
auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)
Get the size of a range.
bool canCreatePoison(const Operator *Op, bool ConsiderFlagsAndMetadata=true)
bool mustTriggerUB(const Instruction *I, const SmallPtrSetImpl< const Value * > &KnownPoison)
Return true if the given instruction must trigger undefined behavior when I is executed with any oper...
detail::scope_exit< std::decay_t< Callable > > make_scope_exit(Callable &&F)
bool isOnlyUsedInZeroEqualityComparison(const Instruction *CxtI)
bool isSignBitCheck(ICmpInst::Predicate Pred, const APInt &RHS, bool &TrueIfSigned)
Given an exploded icmp instruction, return true if the comparison only checks the sign bit.
const Value * getArgumentAliasingToReturnedPointer(const CallBase *Call, bool MustPreserveNullness)
This function returns call pointer argument that is considered the same by aliasing rules.
bool isAssumeLikeIntrinsic(const Instruction *I)
Return true if it is an intrinsic that cannot be speculated but also cannot trap.
AllocaInst * findAllocaForValue(Value *V, bool OffsetZero=false)
Returns unique alloca where the value comes from, or nullptr.
APInt getMinMaxLimit(SelectPatternFlavor SPF, unsigned BitWidth)
Return the minimum or maximum constant value for the specified integer min/max flavor and type.
void getGuaranteedNonPoisonOps(const Instruction *I, SmallVectorImpl< const Value * > &Ops)
Insert operands of I into Ops such that I will trigger undefined behavior if I is executed and that o...
bool isOnlyUsedInZeroComparison(const Instruction *CxtI)
const Value * getLoadStorePointerOperand(const Value *V)
A helper function that returns the pointer operand of a load or store instruction.
bool getConstantStringInfo(const Value *V, StringRef &Str, bool TrimAtNul=true)
This function computes the length of a null-terminated C string pointed to by V.
bool isDereferenceableAndAlignedPointer(const Value *V, Type *Ty, Align Alignment, const DataLayout &DL, const Instruction *CtxI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr)
Returns true if V is always a dereferenceable pointer with alignment greater or equal than requested.
bool onlyUsedByLifetimeMarkersOrDroppableInsts(const Value *V)
Return true if the only users of this pointer are lifetime markers or droppable instructions.
Constant * ReadByteArrayFromGlobal(const GlobalVariable *GV, uint64_t Offset)
bool getUnderlyingObjectsForCodeGen(const Value *V, SmallVectorImpl< Value * > &Objects)
This is a wrapper around getUnderlyingObjects and adds support for basic ptrtoint+arithmetic+inttoptr...
std::pair< Intrinsic::ID, bool > canConvertToMinOrMaxIntrinsic(ArrayRef< Value * > VL)
Check if the values in VL are select instructions that can be converted to a min or max (vector) intr...
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
bool getConstantDataArrayInfo(const Value *V, ConstantDataArraySlice &Slice, unsigned ElementSize, uint64_t Offset=0)
Returns true if the value V is a pointer into a ConstantDataArray.
int bit_width(T Value)
Returns the number of bits needed to represent Value if Value is nonzero.
bool isGuaranteedToExecuteForEveryIteration(const Instruction *I, const Loop *L)
Return true if this function can prove that the instruction I is executed for every iteration of the ...
void append_range(Container &C, Range &&R)
Wrapper function to append range R to container C.
const Value * getUnderlyingObject(const Value *V, unsigned MaxLookup=6)
This method strips off any GEP address adjustments, pointer casts or llvm.threadlocal....
bool isKnownToBeAPowerOfTwo(const Value *V, const DataLayout &DL, bool OrZero=false, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true)
Return true if the given value is known to have exactly one bit set when defined.
bool mustSuppressSpeculation(const LoadInst &LI)
Return true if speculation of the given load must be suppressed to avoid ordering or interfering with...
constexpr bool isPowerOf2_64(uint64_t Value)
Return true if the argument is a power of two > 0 (64 bit edition.)
gep_type_iterator gep_type_end(const User *GEP)
CmpInst::Predicate getMinMaxPred(SelectPatternFlavor SPF, bool Ordered=false)
Return the canonical comparison predicate for the specified minimum/maximum flavor.
void computeKnownBitsFromContext(const Value *V, KnownBits &Known, unsigned Depth, const SimplifyQuery &Q)
Merge bits known from context-dependent facts into Known.
unsigned Log2_64(uint64_t Value)
Return the floor log base 2 of the specified value, -1 if the value is zero.
bool isGuaranteedNotToBeUndef(const Value *V, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, unsigned Depth=0)
Returns true if V cannot be undef, but may be poison.
ConstantRange getConstantRangeFromMetadata(const MDNode &RangeMD)
Parse out a conservative ConstantRange from !range metadata.
ConstantRange computeConstantRange(const Value *V, bool ForSigned, bool UseInstrInfo=true, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, unsigned Depth=0)
Determine the possible constant range of an integer or vector of integer value.
const Value * getPointerOperand(const Value *V)
A helper function that returns the pointer operand of a load, store or GEP instruction.
bool MaskedValueIsZero(const Value *V, const APInt &Mask, const SimplifyQuery &SQ, unsigned Depth=0)
Return true if 'V & Mask' is known to be zero.
int countr_zero(T Val)
Count number of 0's from the least significant bit to the most stopping at the first 1.
bool isOverflowIntrinsicNoWrap(const WithOverflowInst *WO, const DominatorTree &DT)
Returns true if the arithmetic part of the WO 's result is used only along the paths control dependen...
RetainedKnowledge getKnowledgeValidInContext(const Value *V, ArrayRef< Attribute::AttrKind > AttrKinds, const Instruction *CtxI, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr)
Return a valid Knowledge associated to the Value V if its Attribute kind is in AttrKinds and the know...
RetainedKnowledge getKnowledgeFromBundle(AssumeInst &Assume, const CallBase::BundleOpInfo &BOI)
This extracts the Knowledge from an element of an operand bundle.
bool matchSimpleRecurrence(const PHINode *P, BinaryOperator *&BO, Value *&Start, Value *&Step)
Attempt to match a simple first order recurrence cycle of the form: iv = phi Ty [Start,...
bool isSafeToSpeculativelyExecuteWithOpcode(unsigned Opcode, const Instruction *Inst, const Instruction *CtxI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr, bool UseVariableInfo=true)
This returns the same result as isSafeToSpeculativelyExecute if Opcode is the actual opcode of Inst.
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
KnownBits analyzeKnownBitsFromAndXorOr(const Operator *I, const KnownBits &KnownLHS, const KnownBits &KnownRHS, unsigned Depth, const SimplifyQuery &SQ)
Using KnownBits LHS/RHS produce the known bits for logic op (and/xor/or).
OverflowResult computeOverflowForUnsignedMul(const Value *LHS, const Value *RHS, const SimplifyQuery &SQ, bool IsNSW=false)
bool getShuffleDemandedElts(int SrcWidth, ArrayRef< int > Mask, const APInt &DemandedElts, APInt &DemandedLHS, APInt &DemandedRHS, bool AllowUndefElts=false)
Transform a shuffle mask's output demanded element mask into demanded element masks for the 2 operand...
unsigned Log2_32(uint32_t Value)
Return the floor log base 2 of the specified value, -1 if the value is zero.
bool isGuard(const User *U)
Returns true iff U has semantics of a guard expressed in a form of call of llvm.experimental....
int countl_zero(T Val)
Count number of 0's from the most significant bit to the least stopping at the first 1.
SelectPatternFlavor getInverseMinMaxFlavor(SelectPatternFlavor SPF)
Return the inverse minimum/maximum flavor of the specified flavor.
constexpr unsigned MaxAnalysisRecursionDepth
bool isKnownNegative(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Returns true if the given value is known be negative (i.e.
void getGuaranteedWellDefinedOps(const Instruction *I, SmallVectorImpl< const Value * > &Ops)
Insert operands of I into Ops such that I will trigger undefined behavior if I is executed and that o...
OverflowResult computeOverflowForSignedSub(const Value *LHS, const Value *RHS, const SimplifyQuery &SQ)
std::tuple< Value *, FPClassTest, FPClassTest > fcmpImpliesClass(CmpInst::Predicate Pred, const Function &F, Value *LHS, Value *RHS, bool LookThroughSrc=true)
Compute the possible floating-point classes that LHS could be based on fcmp \Pred LHS,...
SelectPatternFlavor
Specific patterns of select instructions we can match.
@ SPF_ABS
Floating point maxnum.
@ SPF_NABS
Absolute value.
@ SPF_FMAXNUM
Floating point minnum.
@ SPF_UMIN
Signed minimum.
@ SPF_UMAX
Signed maximum.
@ SPF_SMAX
Unsigned minimum.
@ SPF_FMINNUM
Unsigned maximum.
bool isIntrinsicReturningPointerAliasingArgumentWithoutCapturing(const CallBase *Call, bool MustPreserveNullness)
{launder,strip}.invariant.group returns pointer that aliases its argument, and it only captures point...
void adjustKnownBitsForSelectArm(KnownBits &Known, Value *Cond, Value *Arm, bool Invert, unsigned Depth, const SimplifyQuery &Q)
Adjust Known for the given select Arm to include information from the select Cond.
bool impliesPoison(const Value *ValAssumedPoison, const Value *V)
Return true if V is poison given that ValAssumedPoison is already poison.
void getHorizDemandedEltsForFirstOperand(unsigned VectorBitWidth, const APInt &DemandedElts, APInt &DemandedLHS, APInt &DemandedRHS)
Compute the demanded elements mask of horizontal binary operations.
SelectPatternResult getSelectPattern(CmpInst::Predicate Pred, SelectPatternNaNBehavior NaNBehavior=SPNB_NA, bool Ordered=false)
Determine the pattern for predicate X Pred Y ? X : Y.
FPClassTest
Floating-point class tests, supported by 'is_fpclass' intrinsic.
bool programUndefinedIfPoison(const Instruction *Inst)
SelectPatternResult matchSelectPattern(Value *V, Value *&LHS, Value *&RHS, Instruction::CastOps *CastOp=nullptr, unsigned Depth=0)
Pattern match integer [SU]MIN, [SU]MAX and ABS idioms, returning the kind and providing the out param...
bool NullPointerIsDefined(const Function *F, unsigned AS=0)
Check whether null pointer dereferencing is considered undefined behavior for a given function or an ...
bool programUndefinedIfUndefOrPoison(const Instruction *Inst)
Return true if this function can prove that if Inst is executed and yields a poison value or undef bi...
bool isSafeToSpeculativelyExecute(const Instruction *I, const Instruction *CtxI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr, bool UseVariableInfo=true)
Return true if the instruction does not have any effects besides calculating the result and does not ...
FPClassTest inverse_fabs(FPClassTest Mask)
Return the test mask which returns true after fabs is applied to the value.
uint64_t GetStringLength(const Value *V, unsigned CharSize=8)
If we can compute the length of the string pointed to by the specified pointer, return 'len+1'.
OverflowResult computeOverflowForSignedMul(const Value *LHS, const Value *RHS, const SimplifyQuery &SQ)
ConstantRange getVScaleRange(const Function *F, unsigned BitWidth)
Determine the possible constant range of vscale with the given bit width, based on the vscale_range f...
Constant * ConstantFoldCastOperand(unsigned Opcode, Constant *C, Type *DestTy, const DataLayout &DL)
Attempt to constant fold a cast with the specified operand.
bool canCreateUndefOrPoison(const Operator *Op, bool ConsiderFlagsAndMetadata=true)
canCreateUndefOrPoison returns true if Op can create undef or poison from non-undef & non-poison oper...
EHPersonality classifyEHPersonality(const Value *Pers)
See if the given exception handling personality function is one that we understand.
bool isKnownInversion(const Value *X, const Value *Y)
Return true iff:
bool isNotCrossLaneOperation(const Instruction *I)
Return true if the instruction doesn't potentially cross vector lanes.
bool isKnownNonZero(const Value *V, const SimplifyQuery &Q, unsigned Depth=0)
Return true if the given value is known to be non-zero when defined.
constexpr int PoisonMaskElem
bool onlyUsedByLifetimeMarkers(const Value *V)
Return true if the only users of this pointer are lifetime markers.
Intrinsic::ID getIntrinsicForCallSite(const CallBase &CB, const TargetLibraryInfo *TLI)
Map a call instruction to an intrinsic ID.
@ First
Helpers to iterate all locations in the MemoryEffectsBase class.
const Value * getUnderlyingObjectAggressive(const Value *V)
Like getUnderlyingObject(), but will try harder to find a single underlying object.
Intrinsic::ID getMinMaxIntrinsic(SelectPatternFlavor SPF)
Convert given SPF to equivalent min/max intrinsic.
OverflowResult computeOverflowForSignedAdd(const WithCache< const Value * > &LHS, const WithCache< const Value * > &RHS, const SimplifyQuery &SQ)
bool propagatesPoison(const Use &PoisonOp)
Return true if PoisonOp's user yields poison or raises UB if its operand PoisonOp is poison.
bool isKnownNonEqual(const Value *V1, const Value *V2, const DataLayout &DL, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true)
Return true if the given values are known to be non-equal when defined.
ConstantRange computeConstantRangeIncludingKnownBits(const WithCache< const Value * > &V, bool ForSigned, const SimplifyQuery &SQ)
Combine constant ranges from computeConstantRange() and computeKnownBits().
SelectPatternNaNBehavior
Behavior when a floating point min/max is given one NaN and one non-NaN as input.
@ SPNB_RETURNS_NAN
NaN behavior not applicable.
@ SPNB_RETURNS_OTHER
Given one NaN input, returns the NaN.
@ SPNB_RETURNS_ANY
Given one NaN input, returns the non-NaN.
void computeKnownBits(const Value *V, KnownBits &Known, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true)
Determine which bits of V are known to be either zero or one and return them in the KnownZero/KnownOn...
DWARFExpression::Operation Op
bool isGuaranteedNotToBeUndefOrPoison(const Value *V, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, unsigned Depth=0)
Return true if this function can prove that V does not have undef bits and is never poison.
constexpr unsigned BitWidth
SelectPatternResult matchDecomposedSelectPattern(CmpInst *CmpI, Value *TrueVal, Value *FalseVal, Value *&LHS, Value *&RHS, Instruction::CastOps *CastOp=nullptr, unsigned Depth=0)
Determine the pattern that a select with the given compare as its predicate and given values as its t...
OverflowResult computeOverflowForUnsignedSub(const Value *LHS, const Value *RHS, const SimplifyQuery &SQ)
bool isGuaranteedToTransferExecutionToSuccessor(const Instruction *I)
Return true if this function can prove that the instruction I will always transfer execution to one o...
gep_type_iterator gep_type_begin(const User *GEP)
std::pair< Value *, FPClassTest > fcmpToClassTest(CmpInst::Predicate Pred, const Function &F, Value *LHS, Value *RHS, bool LookThroughSrc=true)
Returns a pair of values, which if passed to llvm.is.fpclass, returns the same result as an fcmp with...
Value * isBytewiseValue(Value *V, const DataLayout &DL)
If the specified value can be set by repeating the same byte in memory, return the i8 value that it i...
void getUnderlyingObjects(const Value *V, SmallVectorImpl< const Value * > &Objects, const LoopInfo *LI=nullptr, unsigned MaxLookup=6)
This method is similar to getUnderlyingObject except that it can look through phi and select instruct...
bool is_contained(R &&Range, const E &Element)
Returns true if Element is found in Range.
unsigned ComputeNumSignBits(const Value *Op, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true)
Return the number of times the sign bit of the register is replicated into the other bits.
OverflowResult computeOverflowForUnsignedAdd(const WithCache< const Value * > &LHS, const WithCache< const Value * > &RHS, const SimplifyQuery &SQ)
unsigned Log2(Align A)
Returns the log2 of the alignment.
std::optional< bool > isImpliedByDomCondition(const Value *Cond, const Instruction *ContextI, const DataLayout &DL)
Return the boolean condition value in the context of the given instruction if it is known based on do...
bool isGEPBasedOnPointerToString(const GEPOperator *GEP, unsigned CharSize=8)
Returns true if the GEP is based on a pointer to a string (array of.
bool isGuaranteedNotToBePoison(const Value *V, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, unsigned Depth=0)
Returns true if V cannot be poison, but may be undef.
KnownFPClass computeKnownFPClass(const Value *V, const APInt &DemandedElts, FPClassTest InterestedClasses, unsigned Depth, const SimplifyQuery &SQ)
Determine which floating-point classes are valid for V, and return them in KnownFPClass bit sets.
void computeKnownBitsFromRangeMetadata(const MDNode &Ranges, KnownBits &Known)
Compute known bits from the range metadata.
Value * FindInsertedValue(Value *V, ArrayRef< unsigned > idx_range, std::optional< BasicBlock::iterator > InsertBefore=std::nullopt)
Given an aggregate and an sequence of indices, see if the scalar value indexed is already around as a...
bool isKnownNegation(const Value *X, const Value *Y, bool NeedNSW=false, bool AllowPoison=true)
Return true if the two given values are negation.
bool isKnownPositive(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Returns true if the given value is known be positive (i.e.
Constant * ConstantFoldIntegerCast(Constant *C, Type *DestTy, bool IsSigned, const DataLayout &DL)
Constant fold a zext, sext or trunc, depending on IsSigned and whether the DestTy is wider or narrowe...
bool isKnownNonNegative(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Returns true if the give value is known to be non-negative.
unsigned ComputeMaxSignificantBits(const Value *Op, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
Get the upper bound on bit size for this Value Op as a signed integer.
bool mayHaveNonDefUseDependency(const Instruction &I)
Returns true if the result or effects of the given instructions I depend values not reachable through...
bool isTriviallyVectorizable(Intrinsic::ID ID)
Identify if the intrinsic is trivially vectorizable.
bool isIdentifiedObject(const Value *V)
Return true if this pointer refers to a distinct and identifiable object.
std::optional< bool > isImpliedCondition(const Value *LHS, const Value *RHS, const DataLayout &DL, bool LHSIsTrue=true, unsigned Depth=0)
Return true if RHS is known to be implied true by LHS.
void findValuesAffectedByCondition(Value *Cond, bool IsAssume, function_ref< void(Value *)> InsertAffected)
Call InsertAffected on all Values whose known bits / value may be affected by the condition Cond.
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
static unsigned int semanticsPrecision(const fltSemantics &)
static bool isRepresentableAsNormalIn(const fltSemantics &Src, const fltSemantics &Dst)
This struct is a compact representation of a valid (non-zero power of two) alignment.
SmallPtrSet< Value *, 4 > AffectedValues
Represents offset+length into a ConstantDataArray.
uint64_t Length
Length of the slice.
uint64_t Offset
Slice starts at this Offset.
const ConstantDataArray * Array
ConstantDataArray pointer.
Represent subnormal handling kind for floating point instruction inputs and outputs.
DenormalModeKind Input
Denormal treatment kind for floating point instruction inputs in the default floating-point environme...
constexpr bool outputsAreZero() const
Return true if output denormals should be flushed to 0.
@ PreserveSign
The sign of a flushed-to-zero number is preserved in the sign of 0.
@ PositiveZero
Denormals are flushed to positive zero.
@ Dynamic
Denormals have unknown treatment.
@ IEEE
IEEE-754 denormal numbers preserved.
static constexpr DenormalMode getPositiveZero()
constexpr bool inputsAreZero() const
Return true if input denormals must be implicitly treated as 0.
DenormalModeKind Output
Denormal flushing mode for floating point instruction results in the default floating point environme...
static constexpr DenormalMode getIEEE()
InstrInfoQuery provides an interface to query additional information for instructions like metadata o...
bool isExact(const BinaryOperator *Op) const
MDNode * getMetadata(const Instruction *I, unsigned KindID) const
bool hasNoSignedZeros(const InstT *Op) const
bool hasNoSignedWrap(const InstT *Op) const
bool hasNoUnsignedWrap(const InstT *Op) const
static KnownBits makeConstant(const APInt &C)
Create known bits from a known constant.
static KnownBits sadd_sat(const KnownBits &LHS, const KnownBits &RHS)
Compute knownbits resulting from llvm.sadd.sat(LHS, RHS)
static std::optional< bool > eq(const KnownBits &LHS, const KnownBits &RHS)
Determine if these known bits always give the same ICMP_EQ result.
KnownBits anyextOrTrunc(unsigned BitWidth) const
Return known bits for an "any" extension or truncation of the value we're tracking.
static KnownBits mulhu(const KnownBits &LHS, const KnownBits &RHS)
Compute known bits from zero-extended multiply-hi.
unsigned countMinSignBits() const
Returns the number of times the sign bit is replicated into the other bits.
static KnownBits smax(const KnownBits &LHS, const KnownBits &RHS)
Compute known bits for smax(LHS, RHS).
bool isNonNegative() const
Returns true if this value is known to be non-negative.
KnownBits blsi() const
Compute known bits for X & -X, which has only the lowest bit set of X set.
void makeNonNegative()
Make this value non-negative.
static KnownBits usub_sat(const KnownBits &LHS, const KnownBits &RHS)
Compute knownbits resulting from llvm.usub.sat(LHS, RHS)
unsigned countMinLeadingOnes() const
Returns the minimum number of leading one bits.
unsigned countMinTrailingZeros() const
Returns the minimum number of trailing zero bits.
static KnownBits ashr(const KnownBits &LHS, const KnownBits &RHS, bool ShAmtNonZero=false, bool Exact=false)
Compute known bits for ashr(LHS, RHS).
static KnownBits ssub_sat(const KnownBits &LHS, const KnownBits &RHS)
Compute knownbits resulting from llvm.ssub.sat(LHS, RHS)
static KnownBits urem(const KnownBits &LHS, const KnownBits &RHS)
Compute known bits for urem(LHS, RHS).
bool isUnknown() const
Returns true if we don't know any bits.
unsigned countMaxTrailingZeros() const
Returns the maximum number of trailing zero bits possible.
KnownBits blsmsk() const
Compute known bits for X ^ (X - 1), which has all bits up to and including the lowest set bit of X se...
void makeNegative()
Make this value negative.
KnownBits trunc(unsigned BitWidth) const
Return known bits for a truncation of the value we're tracking.
bool hasConflict() const
Returns true if there is conflicting information.
unsigned countMaxPopulation() const
Returns the maximum number of bits that could be one.
void setAllZero()
Make all bits known to be zero and discard any previous information.
unsigned getBitWidth() const
Get the bit width of this value.
static KnownBits umax(const KnownBits &LHS, const KnownBits &RHS)
Compute known bits for umax(LHS, RHS).
bool isConstant() const
Returns true if we know the value of all bits.
void resetAll()
Resets the known state of all bits.
KnownBits unionWith(const KnownBits &RHS) const
Returns KnownBits information that is known to be true for either this or RHS or both.
static KnownBits lshr(const KnownBits &LHS, const KnownBits &RHS, bool ShAmtNonZero=false, bool Exact=false)
Compute known bits for lshr(LHS, RHS).
bool isNonZero() const
Returns true if this value is known to be non-zero.
KnownBits intersectWith(const KnownBits &RHS) const
Returns KnownBits information that is known to be true for both this and RHS.
KnownBits sext(unsigned BitWidth) const
Return known bits for a sign extension of the value we're tracking.
unsigned countMinTrailingOnes() const
Returns the minimum number of trailing one bits.
static KnownBits add(const KnownBits &LHS, const KnownBits &RHS, bool NSW=false, bool NUW=false)
Compute knownbits resulting from addition of LHS and RHS.
KnownBits zextOrTrunc(unsigned BitWidth) const
Return known bits for a zero extension or truncation of the value we're tracking.
unsigned countMinLeadingZeros() const
Returns the minimum number of leading zero bits.
APInt getMaxValue() const
Return the maximal unsigned value possible given these KnownBits.
static KnownBits smin(const KnownBits &LHS, const KnownBits &RHS)
Compute known bits for smin(LHS, RHS).
static KnownBits mulhs(const KnownBits &LHS, const KnownBits &RHS)
Compute known bits from sign-extended multiply-hi.
static KnownBits srem(const KnownBits &LHS, const KnownBits &RHS)
Compute known bits for srem(LHS, RHS).
static KnownBits udiv(const KnownBits &LHS, const KnownBits &RHS, bool Exact=false)
Compute known bits for udiv(LHS, RHS).
static KnownBits computeForAddSub(bool Add, bool NSW, bool NUW, const KnownBits &LHS, const KnownBits &RHS)
Compute known bits resulting from adding LHS and RHS.
static KnownBits sdiv(const KnownBits &LHS, const KnownBits &RHS, bool Exact=false)
Compute known bits for sdiv(LHS, RHS).
static bool haveNoCommonBitsSet(const KnownBits &LHS, const KnownBits &RHS)
Return true if LHS and RHS have no common bits set.
bool isNegative() const
Returns true if this value is known to be negative.
static KnownBits sub(const KnownBits &LHS, const KnownBits &RHS, bool NSW=false, bool NUW=false)
Compute knownbits resulting from subtraction of LHS and RHS.
unsigned countMaxLeadingZeros() const
Returns the maximum number of leading zero bits possible.
void setAllOnes()
Make all bits known to be one and discard any previous information.
void insertBits(const KnownBits &SubBits, unsigned BitPosition)
Insert the bits from a smaller known bits starting at bitPosition.
static KnownBits uadd_sat(const KnownBits &LHS, const KnownBits &RHS)
Compute knownbits resulting from llvm.uadd.sat(LHS, RHS)
static KnownBits mul(const KnownBits &LHS, const KnownBits &RHS, bool NoUndefSelfMultiply=false)
Compute known bits resulting from multiplying LHS and RHS.
KnownBits anyext(unsigned BitWidth) const
Return known bits for an "any" extension of the value we're tracking, where we don't know anything ab...
KnownBits abs(bool IntMinIsPoison=false) const
Compute known bits for the absolute value.
static std::optional< bool > sgt(const KnownBits &LHS, const KnownBits &RHS)
Determine if these known bits always give the same ICMP_SGT result.
static std::optional< bool > uge(const KnownBits &LHS, const KnownBits &RHS)
Determine if these known bits always give the same ICMP_UGE result.
static KnownBits shl(const KnownBits &LHS, const KnownBits &RHS, bool NUW=false, bool NSW=false, bool ShAmtNonZero=false)
Compute known bits for shl(LHS, RHS).
static KnownBits umin(const KnownBits &LHS, const KnownBits &RHS)
Compute known bits for umin(LHS, RHS).
KnownBits sextOrTrunc(unsigned BitWidth) const
Return known bits for a sign extension or truncation of the value we're tracking.
const APInt & getConstant() const
Returns the value when all bits have a known value.
FPClassTest KnownFPClasses
Floating-point classes the value could be one of.
bool isKnownNeverInfinity() const
Return true if it's known this can never be an infinity.
bool cannotBeOrderedGreaterThanZero() const
Return true if we can prove that the analyzed floating-point value is either NaN or never greater tha...
static constexpr FPClassTest OrderedGreaterThanZeroMask
static constexpr FPClassTest OrderedLessThanZeroMask
void knownNot(FPClassTest RuleOut)
bool isKnownNeverZero() const
Return true if it's known this can never be a zero.
void copysign(const KnownFPClass &Sign)
bool isKnownNeverSubnormal() const
Return true if it's known this can never be a subnormal.
bool isKnownNeverLogicalNegZero(const Function &F, Type *Ty) const
Return true if it's know this can never be interpreted as a negative zero.
bool isKnownNeverLogicalPosZero(const Function &F, Type *Ty) const
Return true if it's know this can never be interpreted as a positive zero.
void propagateCanonicalizingSrc(const KnownFPClass &Src, const Function &F, Type *Ty)
Report known classes if Src is evaluated through a potentially canonicalizing operation.
void propagateDenormal(const KnownFPClass &Src, const Function &F, Type *Ty)
Propagate knowledge from a source value that could be a denormal or zero.
bool isKnownNeverNegInfinity() const
Return true if it's known this can never be -infinity.
bool isKnownNeverNegSubnormal() const
Return true if it's known this can never be a negative subnormal.
bool isKnownNeverPosZero() const
Return true if it's known this can never be a literal positive zero.
std::optional< bool > SignBit
std::nullopt if the sign bit is unknown, true if the sign bit is definitely set or false if the sign ...
bool isKnownNeverNaN() const
Return true if it's known this can never be a nan.
bool isKnownNever(FPClassTest Mask) const
Return true if it's known this can never be one of the mask entries.
bool isKnownNeverNegZero() const
Return true if it's known this can never be a negative zero.
bool isKnownNeverLogicalZero(const Function &F, Type *Ty) const
Return true if it's know this can never be interpreted as a zero.
void propagateNaN(const KnownFPClass &Src, bool PreserveSign=false)
bool cannotBeOrderedLessThanZero() const
Return true if we can prove that the analyzed floating-point value is either NaN or never less than -...
void signBitMustBeOne()
Assume the sign bit is one.
void signBitMustBeZero()
Assume the sign bit is zero.
bool isKnownNeverPosInfinity() const
Return true if it's known this can never be +infinity.
bool isKnownNeverPosSubnormal() const
Return true if it's known this can never be a positive subnormal.
Represent one information held inside an operand bundle of an llvm.assume.
SelectPatternFlavor Flavor
static bool isMinOrMax(SelectPatternFlavor SPF)
When implementing this min/max pattern as fcmp; select, does the fcmp have to be ordered?
SimplifyQuery getWithoutCondContext() const
SimplifyQuery getWithInstruction(const Instruction *I) const
const DomConditionCache * DC