58#include "llvm/IR/IntrinsicsAArch64.h"
59#include "llvm/IR/IntrinsicsAMDGPU.h"
60#include "llvm/IR/IntrinsicsRISCV.h"
61#include "llvm/IR/IntrinsicsX86.h"
98 return DL.getPointerTypeSizeInBits(Ty);
110 CxtI = dyn_cast<Instruction>(V);
124 CxtI = dyn_cast<Instruction>(V1);
128 CxtI = dyn_cast<Instruction>(V2);
136 const APInt &DemandedElts,
138 if (isa<ScalableVectorType>(Shuf->
getType())) {
140 DemandedLHS = DemandedRHS = DemandedElts;
147 DemandedElts, DemandedLHS, DemandedRHS);
159 auto *FVTy = dyn_cast<FixedVectorType>(V->getType());
187 V, DemandedElts,
Depth,
243 "LHS and RHS should have the same type");
245 "LHS and RHS should be integers");
256 return !
I->user_empty() &&
all_of(
I->users(), [](
const User *U) {
257 ICmpInst::Predicate P;
258 return match(U, m_ICmp(P, m_Value(), m_Zero()));
263 return !
I->user_empty() &&
all_of(
I->users(), [](
const User *U) {
264 ICmpInst::Predicate P;
265 return match(U, m_ICmp(P, m_Value(), m_Zero())) && ICmpInst::isEquality(P);
273 bool OrZero,
unsigned Depth,
276 return ::isKnownToBeAPowerOfTwo(
291 if (
auto *CI = dyn_cast<ConstantInt>(V))
292 return CI->getValue().isStrictlyPositive();
315 "Testing equality of non-equal types!");
316 auto *FVTy = dyn_cast<FixedVectorType>(V1->
getType());
319 return ::isKnownNonEqual(
320 V1, V2, DemandedElts, 0,
328 return Mask.isSubsetOf(Known.
Zero);
336 auto *FVTy = dyn_cast<FixedVectorType>(V->getType());
346 return ::ComputeNumSignBits(
355 return V->getType()->getScalarSizeInBits() - SignBits + 1;
360 const APInt &DemandedElts,
367 if (KnownOut.
isUnknown() && !NSW && !NUW)
392 bool isKnownNegativeOp0 = Known2.
isNegative();
395 (isKnownNonNegativeOp1 && isKnownNonNegativeOp0);
400 (isKnownNegativeOp1 && isKnownNonNegativeOp0 &&
402 (isKnownNegativeOp0 && isKnownNonNegativeOp1 && Known.
isNonZero());
406 bool SelfMultiply = Op0 == Op1;
426 unsigned NumRanges = Ranges.getNumOperands() / 2;
432 for (
unsigned i = 0; i < NumRanges; ++i) {
434 mdconst::extract<ConstantInt>(Ranges.getOperand(2 * i + 0));
436 mdconst::extract<ConstantInt>(Ranges.getOperand(2 * i + 1));
440 unsigned CommonPrefixBits =
444 Known.
One &= UnsignedMax & Mask;
445 Known.
Zero &= ~UnsignedMax & Mask;
460 while (!WorkSet.
empty()) {
462 if (!Visited.
insert(V).second)
467 return EphValues.count(U);
472 if (V ==
I || (isa<Instruction>(V) &&
474 !cast<Instruction>(V)->isTerminator())) {
476 if (
const User *U = dyn_cast<User>(V))
488 return CI->isAssumeLikeIntrinsic();
496 bool AllowEphemerals) {
514 if (!AllowEphemerals && Inv == CxtI)
549 if (Pred == ICmpInst::ICMP_UGT)
553 if (Pred == ICmpInst::ICMP_NE)
564 auto *VC = dyn_cast<ConstantDataVector>(
RHS);
568 for (
unsigned ElemIdx = 0, NElem = VC->getNumElements(); ElemIdx < NElem;
571 Pred, VC->getElementAsAPInt(ElemIdx));
590 "Got assumption for the wrong function!");
593 if (!V->getType()->isPointerTy())
596 *
I,
I->bundle_op_info_begin()[Elem.Index])) {
598 (RK.AttrKind == Attribute::NonNull ||
599 (RK.AttrKind == Attribute::Dereferenceable &&
601 V->getType()->getPointerAddressSpace()))) &&
633 case ICmpInst::ICMP_EQ:
636 case ICmpInst::ICMP_SGE:
637 case ICmpInst::ICMP_SGT:
640 case ICmpInst::ICMP_SLT:
658 case ICmpInst::ICMP_EQ:
668 Known.
Zero |= ~*
C & *Mask;
674 Known.
One |= *
C & ~*Mask;
695 Known.
Zero |= RHSKnown.
Zero << ShAmt;
696 Known.
One |= RHSKnown.
One << ShAmt;
699 case ICmpInst::ICMP_NE: {
715 if (Pred == ICmpInst::ICMP_UGT || Pred == ICmpInst::ICMP_UGE) {
721 (*
C + (Pred == ICmpInst::ICMP_UGT)).countLeadingOnes());
723 if (Pred == ICmpInst::ICMP_ULT || Pred == ICmpInst::ICMP_ULE) {
729 (*
C - (Pred == ICmpInst::ICMP_ULT)).countLeadingZeros());
741 Invert ? Cmp->getInversePredicate() : Cmp->getPredicate();
774 if (
auto *Cmp = dyn_cast<ICmpInst>(
Cond))
819 "Got assumption for the wrong function!");
822 if (!V->getType()->isPointerTy())
825 *
I,
I->bundle_op_info_begin()[Elem.Index])) {
826 if (RK.WasOn == V && RK.AttrKind == Attribute::Alignment &&
838 Value *Arg =
I->getArgOperand(0);
858 ICmpInst *Cmp = dyn_cast<ICmpInst>(Arg);
894 Known = KF(Known2, Known, ShAmtNonZero);
905 Value *
X =
nullptr, *
Y =
nullptr;
907 switch (
I->getOpcode()) {
908 case Instruction::And:
909 KnownOut = KnownLHS & KnownRHS;
919 KnownOut = KnownLHS.
blsi();
921 KnownOut = KnownRHS.
blsi();
924 case Instruction::Or:
925 KnownOut = KnownLHS | KnownRHS;
927 case Instruction::Xor:
928 KnownOut = KnownLHS ^ KnownRHS;
938 const KnownBits &XBits =
I->getOperand(0) ==
X ? KnownLHS : KnownRHS;
939 KnownOut = XBits.
blsmsk();
952 if (!KnownOut.
Zero[0] && !KnownOut.
One[0] &&
973 APInt DemandedEltsLHS, DemandedEltsRHS;
975 DemandedElts, DemandedEltsLHS,
978 const auto ComputeForSingleOpFunc =
980 return KnownBitsFunc(
985 if (DemandedEltsRHS.
isZero())
986 return ComputeForSingleOpFunc(
I->getOperand(0), DemandedEltsLHS);
987 if (DemandedEltsLHS.
isZero())
988 return ComputeForSingleOpFunc(
I->getOperand(1), DemandedEltsRHS);
990 return ComputeForSingleOpFunc(
I->getOperand(0), DemandedEltsLHS)
991 .intersectWith(ComputeForSingleOpFunc(
I->getOperand(1), DemandedEltsRHS));
1000 auto *FVTy = dyn_cast<FixedVectorType>(
I->getType());
1001 APInt DemandedElts =
1009 Attribute Attr =
F->getFnAttribute(Attribute::VScaleRange);
1017 return ConstantRange::getEmpty(
BitWidth);
1062 const APInt &DemandedElts,
1068 switch (
I->getOpcode()) {
1070 case Instruction::Load:
1075 case Instruction::And:
1081 case Instruction::Or:
1087 case Instruction::Xor:
1093 case Instruction::Mul: {
1096 Known, Known2,
Depth, Q);
1099 case Instruction::UDiv: {
1106 case Instruction::SDiv: {
1113 case Instruction::Select: {
1114 auto ComputeForArm = [&](
Value *Arm,
bool Invert) {
1122 ComputeForArm(
I->getOperand(1),
false)
1126 case Instruction::FPTrunc:
1127 case Instruction::FPExt:
1128 case Instruction::FPToUI:
1129 case Instruction::FPToSI:
1130 case Instruction::SIToFP:
1131 case Instruction::UIToFP:
1133 case Instruction::PtrToInt:
1134 case Instruction::IntToPtr:
1137 case Instruction::ZExt:
1138 case Instruction::Trunc: {
1139 Type *SrcTy =
I->getOperand(0)->getType();
1141 unsigned SrcBitWidth;
1149 assert(SrcBitWidth &&
"SrcBitWidth can't be zero");
1152 if (
auto *Inst = dyn_cast<PossiblyNonNegInst>(
I);
1153 Inst && Inst->hasNonNeg() && !Known.
isNegative())
1158 case Instruction::BitCast: {
1159 Type *SrcTy =
I->getOperand(0)->getType();
1163 !
I->getType()->isVectorTy()) {
1171 V->getType()->isFPOrFPVectorTy()) {
1172 Type *FPType = V->getType()->getScalarType();
1185 if (FPClasses &
fcInf)
1197 if (Result.SignBit) {
1198 if (*Result.SignBit)
1208 auto *SrcVecTy = dyn_cast<FixedVectorType>(SrcTy);
1209 if (!SrcVecTy || !SrcVecTy->getElementType()->isIntegerTy() ||
1210 !
I->getType()->isIntOrIntVectorTy() ||
1211 isa<ScalableVectorType>(
I->getType()))
1216 unsigned SubBitWidth = SrcVecTy->getScalarSizeInBits();
1233 unsigned SubScale =
BitWidth / SubBitWidth;
1235 for (
unsigned i = 0; i != NumElts; ++i) {
1236 if (DemandedElts[i])
1237 SubDemandedElts.
setBit(i * SubScale);
1241 for (
unsigned i = 0; i != SubScale; ++i) {
1245 Known.
insertBits(KnownSrc, ShiftElt * SubBitWidth);
1250 case Instruction::SExt: {
1252 unsigned SrcBitWidth =
I->getOperand(0)->getType()->getScalarSizeInBits();
1254 Known = Known.
trunc(SrcBitWidth);
1261 case Instruction::Shl: {
1265 bool ShAmtNonZero) {
1266 return KnownBits::shl(KnownVal, KnownAmt, NUW, NSW, ShAmtNonZero);
1276 case Instruction::LShr: {
1277 bool Exact = Q.
IIQ.
isExact(cast<BinaryOperator>(
I));
1279 bool ShAmtNonZero) {
1290 case Instruction::AShr: {
1291 bool Exact = Q.
IIQ.
isExact(cast<BinaryOperator>(
I));
1293 bool ShAmtNonZero) {
1300 case Instruction::Sub: {
1304 DemandedElts, Known, Known2,
Depth, Q);
1307 case Instruction::Add: {
1311 DemandedElts, Known, Known2,
Depth, Q);
1314 case Instruction::SRem:
1320 case Instruction::URem:
1325 case Instruction::Alloca:
1328 case Instruction::GetElementPtr: {
1337 for (
unsigned i = 1, e =
I->getNumOperands(); i != e; ++i, ++GTI) {
1353 "Access to structure field must be known at compile time");
1358 unsigned Idx = cast<ConstantInt>(
Index)->getZExtValue();
1361 AccConstIndices +=
Offset;
1372 unsigned IndexBitWidth =
Index->getType()->getScalarSizeInBits();
1386 APInt ScalingFactor(IndexBitWidth, TypeSizeInBytes);
1387 IndexConst *= ScalingFactor;
1404 true,
false,
false, Known, IndexBits);
1409 true,
false,
false, Known,
Index);
1413 case Instruction::PHI: {
1416 Value *R =
nullptr, *L =
nullptr;
1426 if ((Opcode == Instruction::LShr || Opcode == Instruction::AShr ||
1427 Opcode == Instruction::Shl) &&
1442 case Instruction::Shl:
1446 case Instruction::LShr:
1451 case Instruction::AShr:
1462 if (Opcode == Instruction::Add ||
1463 Opcode == Instruction::Sub ||
1464 Opcode == Instruction::And ||
1465 Opcode == Instruction::Or ||
1466 Opcode == Instruction::Mul) {
1473 unsigned OpNum =
P->getOperand(0) == R ? 0 : 1;
1474 Instruction *RInst =
P->getIncomingBlock(OpNum)->getTerminator();
1475 Instruction *LInst =
P->getIncomingBlock(1 - OpNum)->getTerminator();
1490 auto *OverflowOp = dyn_cast<OverflowingBinaryOperator>(BO);
1501 if (Opcode == Instruction::Add) {
1510 else if (Opcode == Instruction::Sub && BO->
getOperand(0) ==
I) {
1518 else if (Opcode == Instruction::Mul && Known2.
isNonNegative() &&
1528 if (
P->getNumIncomingValues() == 0)
1535 if (isa_and_nonnull<UndefValue>(
P->hasConstantValue()))
1540 for (
unsigned u = 0, e =
P->getNumIncomingValues(); u < e; ++u) {
1541 Value *IncValue =
P->getIncomingValue(u);
1543 if (IncValue ==
P)
continue;
1550 RecQ.
CxtI =
P->getIncomingBlock(u)->getTerminator();
1572 if ((TrueSucc ==
P->getParent()) != (FalseSucc ==
P->getParent())) {
1574 if (FalseSucc ==
P->getParent())
1588 Known2 = KnownUnion;
1602 case Instruction::Call:
1603 case Instruction::Invoke: {
1611 const auto *CB = cast<CallBase>(
I);
1613 if (std::optional<ConstantRange>
Range = CB->getRange())
1616 if (
const Value *RV = CB->getReturnedArgOperand()) {
1617 if (RV->getType() ==
I->getType()) {
1629 switch (
II->getIntrinsicID()) {
1632 case Intrinsic::abs: {
1634 bool IntMinIsPoison =
match(
II->getArgOperand(1),
m_One());
1635 Known = Known2.
abs(IntMinIsPoison);
1638 case Intrinsic::bitreverse:
1643 case Intrinsic::bswap:
1648 case Intrinsic::ctlz: {
1654 PossibleLZ = std::min(PossibleLZ,
BitWidth - 1);
1659 case Intrinsic::cttz: {
1665 PossibleTZ = std::min(PossibleTZ,
BitWidth - 1);
1670 case Intrinsic::ctpop: {
1681 case Intrinsic::fshr:
1682 case Intrinsic::fshl: {
1689 if (
II->getIntrinsicID() == Intrinsic::fshr)
1702 case Intrinsic::uadd_sat:
1707 case Intrinsic::usub_sat:
1712 case Intrinsic::sadd_sat:
1717 case Intrinsic::ssub_sat:
1723 case Intrinsic::vector_reverse:
1729 case Intrinsic::vector_reduce_and:
1730 case Intrinsic::vector_reduce_or:
1731 case Intrinsic::vector_reduce_umax:
1732 case Intrinsic::vector_reduce_umin:
1733 case Intrinsic::vector_reduce_smax:
1734 case Intrinsic::vector_reduce_smin:
1737 case Intrinsic::vector_reduce_xor: {
1742 auto *VecTy = cast<VectorType>(
I->getOperand(0)->getType());
1744 bool EvenCnt = VecTy->getElementCount().isKnownEven();
1748 if (VecTy->isScalableTy() || EvenCnt)
1752 case Intrinsic::umin:
1757 case Intrinsic::umax:
1762 case Intrinsic::smin:
1767 case Intrinsic::smax:
1772 case Intrinsic::ptrmask: {
1775 const Value *Mask =
I->getOperand(1);
1776 Known2 =
KnownBits(Mask->getType()->getScalarSizeInBits());
1782 case Intrinsic::x86_sse2_pmulh_w:
1783 case Intrinsic::x86_avx2_pmulh_w:
1784 case Intrinsic::x86_avx512_pmulh_w_512:
1789 case Intrinsic::x86_sse2_pmulhu_w:
1790 case Intrinsic::x86_avx2_pmulhu_w:
1791 case Intrinsic::x86_avx512_pmulhu_w_512:
1796 case Intrinsic::x86_sse42_crc32_64_64:
1799 case Intrinsic::x86_ssse3_phadd_d_128:
1800 case Intrinsic::x86_ssse3_phadd_w_128:
1801 case Intrinsic::x86_avx2_phadd_d:
1802 case Intrinsic::x86_avx2_phadd_w: {
1804 I, DemandedElts,
Depth, Q,
1812 case Intrinsic::x86_ssse3_phadd_sw_128:
1813 case Intrinsic::x86_avx2_phadd_sw: {
1818 case Intrinsic::x86_ssse3_phsub_d_128:
1819 case Intrinsic::x86_ssse3_phsub_w_128:
1820 case Intrinsic::x86_avx2_phsub_d:
1821 case Intrinsic::x86_avx2_phsub_w: {
1823 I, DemandedElts,
Depth, Q,
1831 case Intrinsic::x86_ssse3_phsub_sw_128:
1832 case Intrinsic::x86_avx2_phsub_sw: {
1837 case Intrinsic::riscv_vsetvli:
1838 case Intrinsic::riscv_vsetvlimax: {
1839 bool HasAVL =
II->getIntrinsicID() == Intrinsic::riscv_vsetvli;
1842 cast<ConstantInt>(
II->getArgOperand(HasAVL))->getZExtValue());
1844 cast<ConstantInt>(
II->getArgOperand(1 + HasAVL))->getZExtValue());
1851 if (
auto *CI = dyn_cast<ConstantInt>(
II->getArgOperand(0)))
1852 MaxVL = std::min(MaxVL, CI->getZExtValue());
1854 unsigned KnownZeroFirstBit =
Log2_32(MaxVL) + 1;
1859 case Intrinsic::vscale: {
1860 if (!
II->getParent() || !
II->getFunction())
1870 case Instruction::ShuffleVector: {
1871 auto *Shuf = dyn_cast<ShuffleVectorInst>(
I);
1879 APInt DemandedLHS, DemandedRHS;
1886 if (!!DemandedLHS) {
1887 const Value *
LHS = Shuf->getOperand(0);
1893 if (!!DemandedRHS) {
1894 const Value *
RHS = Shuf->getOperand(1);
1900 case Instruction::InsertElement: {
1901 if (isa<ScalableVectorType>(
I->getType())) {
1905 const Value *Vec =
I->getOperand(0);
1906 const Value *Elt =
I->getOperand(1);
1907 auto *CIdx = dyn_cast<ConstantInt>(
I->getOperand(2));
1909 APInt DemandedVecElts = DemandedElts;
1910 bool NeedsElt =
true;
1912 if (CIdx && CIdx->getValue().ult(NumElts)) {
1913 DemandedVecElts.
clearBit(CIdx->getZExtValue());
1914 NeedsElt = DemandedElts[CIdx->getZExtValue()];
1926 if (!DemandedVecElts.
isZero()) {
1932 case Instruction::ExtractElement: {
1935 const Value *Vec =
I->getOperand(0);
1937 auto *CIdx = dyn_cast<ConstantInt>(
Idx);
1938 if (isa<ScalableVectorType>(Vec->
getType())) {
1943 unsigned NumElts = cast<FixedVectorType>(Vec->
getType())->getNumElements();
1945 if (CIdx && CIdx->getValue().ult(NumElts))
1950 case Instruction::ExtractValue:
1955 switch (
II->getIntrinsicID()) {
1957 case Intrinsic::uadd_with_overflow:
1958 case Intrinsic::sadd_with_overflow:
1960 true,
II->getArgOperand(0),
II->getArgOperand(1),
false,
1961 false, DemandedElts, Known, Known2,
Depth, Q);
1963 case Intrinsic::usub_with_overflow:
1964 case Intrinsic::ssub_with_overflow:
1966 false,
II->getArgOperand(0),
II->getArgOperand(1),
false,
1967 false, DemandedElts, Known, Known2,
Depth, Q);
1969 case Intrinsic::umul_with_overflow:
1970 case Intrinsic::smul_with_overflow:
1972 DemandedElts, Known, Known2,
Depth, Q);
1978 case Instruction::Freeze:
2022 if (!DemandedElts) {
2028 assert(V &&
"No Value?");
2032 Type *Ty = V->getType();
2036 "Not integer or pointer type!");
2038 if (
auto *FVTy = dyn_cast<FixedVectorType>(Ty)) {
2040 FVTy->getNumElements() == DemandedElts.
getBitWidth() &&
2041 "DemandedElt width should equal the fixed vector number of elements");
2044 "DemandedElt width should be 1 for scalars or scalable vectors");
2050 "V and Known should have same BitWidth");
2053 "V and Known should have same BitWidth");
2064 if (isa<ConstantPointerNull>(V) || isa<ConstantAggregateZero>(V)) {
2071 assert(!isa<ScalableVectorType>(V->getType()));
2075 for (
unsigned i = 0, e = CDV->getNumElements(); i != e; ++i) {
2076 if (!DemandedElts[i])
2078 APInt Elt = CDV->getElementAsAPInt(i);
2087 if (
const auto *CV = dyn_cast<ConstantVector>(V)) {
2088 assert(!isa<ScalableVectorType>(V->getType()));
2092 for (
unsigned i = 0, e = CV->getNumOperands(); i != e; ++i) {
2093 if (!DemandedElts[i])
2096 if (isa<PoisonValue>(Element))
2098 auto *ElementCI = dyn_cast_or_null<ConstantInt>(Element);
2103 const APInt &Elt = ElementCI->getValue();
2116 if (isa<UndefValue>(V))
2121 assert(!isa<ConstantData>(V) &&
"Unhandled constant data!");
2123 if (
const auto *
A = dyn_cast<Argument>(V))
2124 if (std::optional<ConstantRange>
Range =
A->getRange())
2133 if (
const GlobalAlias *GA = dyn_cast<GlobalAlias>(V)) {
2134 if (!GA->isInterposable())
2139 if (
const Operator *
I = dyn_cast<Operator>(V))
2141 else if (
const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
2142 if (std::optional<ConstantRange> CR = GV->getAbsoluteSymbolRange())
2143 Known = CR->toKnownBits();
2147 if (isa<PointerType>(V->getType())) {
2148 Align Alignment = V->getPointerAlignment(Q.
DL);
2164 Value *Start =
nullptr, *Step =
nullptr;
2170 if (U.get() == Start) {
2186 case Instruction::Mul:
2191 case Instruction::SDiv:
2197 case Instruction::UDiv:
2203 case Instruction::Shl:
2205 case Instruction::AShr:
2209 case Instruction::LShr:
2224 if (isa<Constant>(V))
2228 if (OrZero && V->getType()->getScalarSizeInBits() == 1)
2231 auto *
I = dyn_cast<Instruction>(V);
2238 return F->hasFnAttribute(Attribute::VScaleRange);
2255 switch (
I->getOpcode()) {
2256 case Instruction::ZExt:
2258 case Instruction::Trunc:
2260 case Instruction::Shl:
2264 case Instruction::LShr:
2265 if (OrZero || Q.
IIQ.
isExact(cast<BinaryOperator>(
I)))
2268 case Instruction::UDiv:
2272 case Instruction::Mul:
2276 case Instruction::And:
2287 case Instruction::Add: {
2293 if (
match(
I->getOperand(0),
2297 if (
match(
I->getOperand(1),
2302 unsigned BitWidth = V->getType()->getScalarSizeInBits();
2311 if ((~(LHSBits.
Zero & RHSBits.
Zero)).isPowerOf2())
2324 case Instruction::Select:
2327 case Instruction::PHI: {
2331 auto *PN = cast<PHINode>(
I);
2348 RecQ.CxtI = PN->getIncomingBlock(U)->getTerminator();
2349 return isKnownToBeAPowerOfTwo(U.get(), OrZero, NewDepth, RecQ);
2352 case Instruction::Invoke:
2353 case Instruction::Call: {
2354 if (
auto *
II = dyn_cast<IntrinsicInst>(
I)) {
2355 switch (
II->getIntrinsicID()) {
2356 case Intrinsic::umax:
2357 case Intrinsic::smax:
2358 case Intrinsic::umin:
2359 case Intrinsic::smin:
2364 case Intrinsic::bitreverse:
2365 case Intrinsic::bswap:
2367 case Intrinsic::fshr:
2368 case Intrinsic::fshl:
2370 if (
II->getArgOperand(0) ==
II->getArgOperand(1))
2394 F =
I->getFunction();
2398 if (!
GEP->hasNoUnsignedWrap() &&
2399 !(
GEP->isInBounds() &&
2404 assert(
GEP->getType()->isPointerTy() &&
"We only support plain pointer GEP");
2415 GTI != GTE; ++GTI) {
2417 if (
StructType *STy = GTI.getStructTypeOrNull()) {
2418 ConstantInt *OpC = cast<ConstantInt>(GTI.getOperand());
2422 if (ElementOffset > 0)
2428 if (GTI.getSequentialElementStride(Q.
DL).isZero())
2433 if (
ConstantInt *OpC = dyn_cast<ConstantInt>(GTI.getOperand())) {
2457 assert(!isa<Constant>(V) &&
"Called for constant?");
2462 unsigned NumUsesExplored = 0;
2463 for (
const auto *U : V->users()) {
2471 if (
const auto *CB = dyn_cast<CallBase>(U))
2472 if (
auto *CalledFunc = CB->getCalledFunction())
2473 for (
const Argument &Arg : CalledFunc->args())
2474 if (CB->getArgOperand(Arg.getArgNo()) == V &&
2475 Arg.hasNonNullAttr(
false) &&
2483 V->getType()->getPointerAddressSpace()) &&
2501 NonNullIfTrue =
true;
2503 NonNullIfTrue =
false;
2509 for (
const auto *CmpU : U->users()) {
2511 if (Visited.
insert(CmpU).second)
2514 while (!WorkList.
empty()) {
2523 for (
const auto *CurrU : Curr->users())
2524 if (Visited.
insert(CurrU).second)
2529 if (
const BranchInst *BI = dyn_cast<BranchInst>(Curr)) {
2530 assert(BI->isConditional() &&
"uses a comparison!");
2533 BI->getSuccessor(NonNullIfTrue ? 0 : 1);
2537 }
else if (NonNullIfTrue &&
isGuard(Curr) &&
2538 DT->
dominates(cast<Instruction>(Curr), CtxI)) {
2552 const unsigned NumRanges = Ranges->getNumOperands() / 2;
2554 for (
unsigned i = 0; i < NumRanges; ++i) {
2556 mdconst::extract<ConstantInt>(Ranges->getOperand(2 * i + 0));
2558 mdconst::extract<ConstantInt>(Ranges->getOperand(2 * i + 1));
2570 Value *Start =
nullptr, *Step =
nullptr;
2571 const APInt *StartC, *StepC;
2577 case Instruction::Add:
2583 case Instruction::Mul:
2586 case Instruction::Shl:
2588 case Instruction::AShr:
2589 case Instruction::LShr:
2600 Pred == ICmpInst::ICMP_EQ;
2605 Value *
Y,
bool NSW,
bool NUW) {
2659 if (
auto *
C = dyn_cast<Constant>(
X))
2663 return ::isKnownNonEqual(
X,
Y, DemandedElts,
Depth, Q);
2668 Value *
Y,
bool NSW,
bool NUW) {
2697 auto ShiftOp = [&](
const APInt &Lhs,
const APInt &Rhs) {
2698 switch (
I->getOpcode()) {
2699 case Instruction::Shl:
2700 return Lhs.
shl(Rhs);
2701 case Instruction::LShr:
2702 return Lhs.
lshr(Rhs);
2703 case Instruction::AShr:
2704 return Lhs.
ashr(Rhs);
2710 auto InvShiftOp = [&](
const APInt &Lhs,
const APInt &Rhs) {
2711 switch (
I->getOpcode()) {
2712 case Instruction::Shl:
2713 return Lhs.
lshr(Rhs);
2714 case Instruction::LShr:
2715 case Instruction::AShr:
2716 return Lhs.
shl(Rhs);
2729 if (MaxShift.
uge(NumBits))
2732 if (!ShiftOp(KnownVal.
One, MaxShift).isZero())
2737 if (InvShiftOp(KnownVal.
Zero, NumBits - MaxShift)
2746 const APInt &DemandedElts,
2749 switch (
I->getOpcode()) {
2750 case Instruction::Alloca:
2752 return I->getType()->getPointerAddressSpace() == 0;
2753 case Instruction::GetElementPtr:
2754 if (
I->getType()->isPointerTy())
2757 case Instruction::BitCast: {
2785 Type *FromTy =
I->getOperand(0)->getType();
2790 case Instruction::IntToPtr:
2794 if (!isa<ScalableVectorType>(
I->getType()) &&
2799 case Instruction::PtrToInt:
2802 if (!isa<ScalableVectorType>(
I->getType()) &&
2807 case Instruction::Trunc:
2809 if (
auto *TI = dyn_cast<TruncInst>(
I))
2810 if (TI->hasNoSignedWrap() || TI->hasNoUnsignedWrap())
2814 case Instruction::Sub:
2817 case Instruction::Xor:
2822 case Instruction::Or:
2829 case Instruction::SExt:
2830 case Instruction::ZExt:
2834 case Instruction::Shl: {
2849 case Instruction::LShr:
2850 case Instruction::AShr: {
2865 case Instruction::UDiv:
2866 case Instruction::SDiv: {
2869 if (cast<PossiblyExactOperator>(
I)->isExact())
2881 if (
I->getOpcode() == Instruction::SDiv) {
2883 XKnown = XKnown.
abs(
false);
2884 YKnown = YKnown.
abs(
false);
2890 return XUgeY && *XUgeY;
2892 case Instruction::Add: {
2897 auto *BO = cast<OverflowingBinaryOperator>(
I);
2902 case Instruction::Mul: {
2908 case Instruction::Select: {
2915 auto SelectArmIsNonZero = [&](
bool IsTrueArm) {
2917 Op = IsTrueArm ?
I->getOperand(1) :
I->getOperand(2);
2930 Pred = ICmpInst::getInversePredicate(Pred);
2935 if (SelectArmIsNonZero(
true) &&
2936 SelectArmIsNonZero(
false))
2940 case Instruction::PHI: {
2941 auto *PN = cast<PHINode>(
I);
2951 RecQ.CxtI = PN->getIncomingBlock(U)->getTerminator();
2953 ICmpInst::Predicate Pred;
2955 BasicBlock *TrueSucc, *FalseSucc;
2956 if (match(RecQ.CxtI,
2957 m_Br(m_c_ICmp(Pred, m_Specific(U.get()), m_Value(X)),
2958 m_BasicBlock(TrueSucc), m_BasicBlock(FalseSucc)))) {
2960 if ((TrueSucc == PN->getParent()) != (FalseSucc == PN->getParent())) {
2962 if (FalseSucc == PN->getParent())
2963 Pred = CmpInst::getInversePredicate(Pred);
2964 if (cmpExcludesZero(Pred, X))
2972 case Instruction::InsertElement: {
2973 if (isa<ScalableVectorType>(
I->getType()))
2976 const Value *Vec =
I->getOperand(0);
2977 const Value *Elt =
I->getOperand(1);
2978 auto *CIdx = dyn_cast<ConstantInt>(
I->getOperand(2));
2981 APInt DemandedVecElts = DemandedElts;
2982 bool SkipElt =
false;
2984 if (CIdx && CIdx->getValue().ult(NumElts)) {
2985 DemandedVecElts.
clearBit(CIdx->getZExtValue());
2986 SkipElt = !DemandedElts[CIdx->getZExtValue()];
2992 (DemandedVecElts.
isZero() ||
2995 case Instruction::ExtractElement:
2996 if (
const auto *EEI = dyn_cast<ExtractElementInst>(
I)) {
2997 const Value *Vec = EEI->getVectorOperand();
2998 const Value *
Idx = EEI->getIndexOperand();
2999 auto *CIdx = dyn_cast<ConstantInt>(
Idx);
3000 if (
auto *VecTy = dyn_cast<FixedVectorType>(Vec->
getType())) {
3001 unsigned NumElts = VecTy->getNumElements();
3003 if (CIdx && CIdx->getValue().ult(NumElts))
3009 case Instruction::ShuffleVector: {
3010 auto *Shuf = dyn_cast<ShuffleVectorInst>(
I);
3013 APInt DemandedLHS, DemandedRHS;
3019 return (DemandedRHS.
isZero() ||
3024 case Instruction::Freeze:
3028 case Instruction::Load: {
3029 auto *LI = cast<LoadInst>(
I);
3032 if (
auto *PtrT = dyn_cast<PointerType>(
I->getType())) {
3045 case Instruction::ExtractValue: {
3051 case Instruction::Add:
3056 case Instruction::Sub:
3059 case Instruction::Mul:
3068 case Instruction::Call:
3069 case Instruction::Invoke: {
3070 const auto *Call = cast<CallBase>(
I);
3071 if (
I->getType()->isPointerTy()) {
3072 if (Call->isReturnNonNull())
3079 if (std::optional<ConstantRange>
Range = Call->getRange()) {
3084 if (
const Value *RV = Call->getReturnedArgOperand())
3089 if (
auto *
II = dyn_cast<IntrinsicInst>(
I)) {
3090 switch (
II->getIntrinsicID()) {
3091 case Intrinsic::sshl_sat:
3092 case Intrinsic::ushl_sat:
3093 case Intrinsic::abs:
3094 case Intrinsic::bitreverse:
3095 case Intrinsic::bswap:
3096 case Intrinsic::ctpop:
3100 case Intrinsic::ssub_sat:
3102 II->getArgOperand(0),
II->getArgOperand(1));
3103 case Intrinsic::sadd_sat:
3105 II->getArgOperand(0),
II->getArgOperand(1),
3108 case Intrinsic::vector_reverse:
3112 case Intrinsic::vector_reduce_or:
3113 case Intrinsic::vector_reduce_umax:
3114 case Intrinsic::vector_reduce_umin:
3115 case Intrinsic::vector_reduce_smax:
3116 case Intrinsic::vector_reduce_smin:
3118 case Intrinsic::umax:
3119 case Intrinsic::uadd_sat:
3127 case Intrinsic::smax: {
3130 auto IsNonZero = [&](
Value *
Op, std::optional<bool> &OpNonZero,
3132 if (!OpNonZero.has_value())
3133 OpNonZero = OpKnown.isNonZero() ||
3138 std::optional<bool> Op0NonZero, Op1NonZero;
3142 IsNonZero(
II->getArgOperand(1), Op1NonZero, Op1Known))
3147 IsNonZero(
II->getArgOperand(0), Op0NonZero, Op0Known))
3149 return IsNonZero(
II->getArgOperand(1), Op1NonZero, Op1Known) &&
3150 IsNonZero(
II->getArgOperand(0), Op0NonZero, Op0Known);
3152 case Intrinsic::smin: {
3168 case Intrinsic::umin:
3171 case Intrinsic::cttz:
3174 case Intrinsic::ctlz:
3177 case Intrinsic::fshr:
3178 case Intrinsic::fshl:
3180 if (
II->getArgOperand(0) ==
II->getArgOperand(1))
3183 case Intrinsic::vscale:
3185 case Intrinsic::experimental_get_vector_length:
3199 return Known.
One != 0;
3210 Type *Ty = V->getType();
3215 if (
auto *FVTy = dyn_cast<FixedVectorType>(Ty)) {
3217 FVTy->getNumElements() == DemandedElts.
getBitWidth() &&
3218 "DemandedElt width should equal the fixed vector number of elements");
3221 "DemandedElt width should be 1 for scalars");
3225 if (
auto *
C = dyn_cast<Constant>(V)) {
3226 if (
C->isNullValue())
3228 if (isa<ConstantInt>(
C))
3234 if (
auto *VecTy = dyn_cast<FixedVectorType>(Ty)) {
3235 for (
unsigned i = 0, e = VecTy->getNumElements(); i != e; ++i) {
3236 if (!DemandedElts[i])
3238 Constant *Elt =
C->getAggregateElement(i);
3241 if (!isa<PoisonValue>(Elt) && !isa<ConstantInt>(Elt))
3248 if (
auto *CPA = dyn_cast<ConstantPtrAuth>(V))
3254 if (
const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
3255 if (!GV->isAbsoluteSymbolRef() && !GV->hasExternalWeakLinkage() &&
3256 GV->getType()->getAddressSpace() == 0)
3261 if (!isa<ConstantExpr>(V))
3265 if (
const auto *
A = dyn_cast<Argument>(V))
3266 if (std::optional<ConstantRange>
Range =
A->getRange()) {
3281 if (
PointerType *PtrTy = dyn_cast<PointerType>(Ty)) {
3284 if (
const Argument *
A = dyn_cast<Argument>(V)) {
3285 if (((
A->hasPassPointeeByValueCopyAttr() &&
3287 A->hasNonNullAttr()))
3292 if (
const auto *
I = dyn_cast<Operator>(V))
3296 if (!isa<Constant>(V) &&
3305 auto *FVTy = dyn_cast<FixedVectorType>(V->getType());
3306 APInt DemandedElts =
3308 return ::isKnownNonZero(V, DemandedElts, Q,
Depth);
3317static std::optional<std::pair<Value*, Value*>>
3321 return std::nullopt;
3330 case Instruction::Or:
3331 if (!cast<PossiblyDisjointInst>(Op1)->isDisjoint() ||
3332 !cast<PossiblyDisjointInst>(Op2)->isDisjoint())
3335 case Instruction::Xor:
3336 case Instruction::Add: {
3344 case Instruction::Sub:
3350 case Instruction::Mul: {
3354 auto *OBO1 = cast<OverflowingBinaryOperator>(Op1);
3355 auto *OBO2 = cast<OverflowingBinaryOperator>(Op2);
3356 if ((!OBO1->hasNoUnsignedWrap() || !OBO2->hasNoUnsignedWrap()) &&
3357 (!OBO1->hasNoSignedWrap() || !OBO2->hasNoSignedWrap()))
3363 !cast<ConstantInt>(Op1->
getOperand(1))->isZero())
3367 case Instruction::Shl: {
3370 auto *OBO1 = cast<OverflowingBinaryOperator>(Op1);
3371 auto *OBO2 = cast<OverflowingBinaryOperator>(Op2);
3372 if ((!OBO1->hasNoUnsignedWrap() || !OBO2->hasNoUnsignedWrap()) &&
3373 (!OBO1->hasNoSignedWrap() || !OBO2->hasNoSignedWrap()))
3380 case Instruction::AShr:
3381 case Instruction::LShr: {
3382 auto *PEO1 = cast<PossiblyExactOperator>(Op1);
3383 auto *PEO2 = cast<PossiblyExactOperator>(Op2);
3384 if (!PEO1->isExact() || !PEO2->isExact())
3391 case Instruction::SExt:
3392 case Instruction::ZExt:
3396 case Instruction::PHI: {
3397 const PHINode *PN1 = cast<PHINode>(Op1);
3398 const PHINode *PN2 = cast<PHINode>(Op2);
3404 Value *Start1 =
nullptr, *Step1 =
nullptr;
3406 Value *Start2 =
nullptr, *Step2 =
nullptr;
3413 cast<Operator>(BO2));
3422 if (Values->first != PN1 || Values->second != PN2)
3425 return std::make_pair(Start1, Start2);
3428 return std::nullopt;
3443 case Instruction::Or:
3444 if (!cast<PossiblyDisjointInst>(V1)->isDisjoint())
3447 case Instruction::Xor:
3448 case Instruction::Add:
3466 if (
auto *OBO = dyn_cast<OverflowingBinaryOperator>(V2)) {
3469 (OBO->hasNoUnsignedWrap() || OBO->hasNoSignedWrap()) &&
3470 !
C->isZero() && !
C->isOne() &&
3481 if (
auto *OBO = dyn_cast<OverflowingBinaryOperator>(V2)) {
3484 (OBO->hasNoUnsignedWrap() || OBO->hasNoSignedWrap()) &&
3498 bool UsedFullRecursion =
false;
3500 if (!VisitedBBs.
insert(IncomBB).second)
3504 const APInt *C1, *C2;
3509 if (UsedFullRecursion)
3513 RecQ.
CxtI = IncomBB->getTerminator();
3516 UsedFullRecursion =
true;
3524 const SelectInst *SI1 = dyn_cast<SelectInst>(V1);
3528 if (
const SelectInst *SI2 = dyn_cast<SelectInst>(V2)) {
3530 const Value *Cond2 = SI2->getCondition();
3533 DemandedElts,
Depth + 1, Q) &&
3535 DemandedElts,
Depth + 1, Q);
3548 if (!
A->getType()->isPointerTy() || !
B->getType()->isPointerTy())
3551 auto *GEPA = dyn_cast<GEPOperator>(
A);
3552 if (!GEPA || GEPA->getNumIndices() != 1 || !isa<Constant>(GEPA->idx_begin()))
3556 auto *PN = dyn_cast<PHINode>(GEPA->getPointerOperand());
3557 if (!PN || PN->getNumIncomingValues() != 2)
3562 Value *Start =
nullptr;
3564 if (PN->getIncomingValue(0) == Step)
3565 Start = PN->getIncomingValue(1);
3566 else if (PN->getIncomingValue(1) == Step)
3567 Start = PN->getIncomingValue(0);
3578 APInt StartOffset(IndexWidth, 0);
3579 Start = Start->stripAndAccumulateInBoundsConstantOffsets(Q.
DL, StartOffset);
3580 APInt StepOffset(IndexWidth, 0);
3586 APInt OffsetB(IndexWidth, 0);
3587 B =
B->stripAndAccumulateInBoundsConstantOffsets(Q.
DL, OffsetB);
3588 return Start ==
B &&
3599 if (V1->
getType() != V2->getType())
3609 auto *O1 = dyn_cast<Operator>(V1);
3610 auto *O2 = dyn_cast<Operator>(V2);
3611 if (O1 && O2 && O1->getOpcode() == O2->getOpcode()) {
3616 if (
const PHINode *PN1 = dyn_cast<PHINode>(V1)) {
3617 const PHINode *PN2 = cast<PHINode>(V2);
3673 "Input should be a Select!");
3683 const Value *LHS2 =
nullptr, *RHS2 =
nullptr;
3695 return CLow->
sle(*CHigh);
3700 const APInt *&CHigh) {
3701 assert((
II->getIntrinsicID() == Intrinsic::smin ||
3702 II->getIntrinsicID() == Intrinsic::smax) &&
"Must be smin/smax");
3705 auto *InnerII = dyn_cast<IntrinsicInst>(
II->getArgOperand(0));
3706 if (!InnerII || InnerII->getIntrinsicID() != InverseID ||
3711 if (
II->getIntrinsicID() == Intrinsic::smin)
3713 return CLow->
sle(*CHigh);
3721 const APInt &DemandedElts,
3723 const auto *CV = dyn_cast<Constant>(V);
3724 if (!CV || !isa<FixedVectorType>(CV->getType()))
3727 unsigned MinSignBits = TyBits;
3728 unsigned NumElts = cast<FixedVectorType>(CV->getType())->getNumElements();
3729 for (
unsigned i = 0; i != NumElts; ++i) {
3730 if (!DemandedElts[i])
3733 auto *Elt = dyn_cast_or_null<ConstantInt>(CV->getAggregateElement(i));
3737 MinSignBits = std::min(MinSignBits, Elt->getValue().getNumSignBits());
3744 const APInt &DemandedElts,
3750 assert(Result > 0 &&
"At least one sign bit needs to be present!");
3762 const APInt &DemandedElts,
3764 Type *Ty = V->getType();
3768 if (
auto *FVTy = dyn_cast<FixedVectorType>(Ty)) {
3770 FVTy->getNumElements() == DemandedElts.
getBitWidth() &&
3771 "DemandedElt width should equal the fixed vector number of elements");
3774 "DemandedElt width should be 1 for scalars");
3788 unsigned FirstAnswer = 1;
3796 if (
auto *U = dyn_cast<Operator>(V)) {
3799 case Instruction::SExt:
3800 Tmp = TyBits - U->getOperand(0)->getType()->getScalarSizeInBits();
3804 case Instruction::SDiv: {
3805 const APInt *Denominator;
3818 return std::min(TyBits, NumBits + Denominator->
logBase2());
3823 case Instruction::SRem: {
3826 const APInt *Denominator;
3847 unsigned ResBits = TyBits - Denominator->
ceilLogBase2();
3848 Tmp = std::max(Tmp, ResBits);
3854 case Instruction::AShr: {
3859 if (ShAmt->
uge(TyBits))
3862 Tmp += ShAmtLimited;
3863 if (Tmp > TyBits) Tmp = TyBits;
3867 case Instruction::Shl: {
3872 if (ShAmt->
uge(TyBits))
3877 ShAmt->
uge(TyBits -
X->getType()->getScalarSizeInBits())) {
3879 Tmp += TyBits -
X->getType()->getScalarSizeInBits();
3883 if (ShAmt->
uge(Tmp))
3890 case Instruction::And:
3891 case Instruction::Or:
3892 case Instruction::Xor:
3897 FirstAnswer = std::min(Tmp, Tmp2);
3904 case Instruction::Select: {
3908 const APInt *CLow, *CHigh;
3916 return std::min(Tmp, Tmp2);
3919 case Instruction::Add:
3923 if (Tmp == 1)
break;
3926 if (
const auto *CRHS = dyn_cast<Constant>(U->getOperand(1)))
3927 if (CRHS->isAllOnesValue()) {
3933 if ((Known.
Zero | 1).isAllOnes())
3945 return std::min(Tmp, Tmp2) - 1;
3947 case Instruction::Sub:
3953 if (
const auto *CLHS = dyn_cast<Constant>(U->getOperand(0)))
3954 if (CLHS->isNullValue()) {
3959 if ((Known.
Zero | 1).isAllOnes())
3976 return std::min(Tmp, Tmp2) - 1;
3978 case Instruction::Mul: {
3981 unsigned SignBitsOp0 =
3983 if (SignBitsOp0 == 1)
3985 unsigned SignBitsOp1 =
3987 if (SignBitsOp1 == 1)
3989 unsigned OutValidBits =
3990 (TyBits - SignBitsOp0 + 1) + (TyBits - SignBitsOp1 + 1);
3991 return OutValidBits > TyBits ? 1 : TyBits - OutValidBits + 1;
3994 case Instruction::PHI: {
3995 const PHINode *PN = cast<PHINode>(U);
3998 if (NumIncomingValues > 4)
break;
4000 if (NumIncomingValues == 0)
break;
4006 for (
unsigned i = 0, e = NumIncomingValues; i != e; ++i) {
4007 if (Tmp == 1)
return Tmp;
4010 DemandedElts,
Depth + 1, RecQ));
4015 case Instruction::Trunc: {
4020 unsigned OperandTyBits = U->getOperand(0)->getType()->getScalarSizeInBits();
4021 if (Tmp > (OperandTyBits - TyBits))
4022 return Tmp - (OperandTyBits - TyBits);
4027 case Instruction::ExtractElement:
4034 case Instruction::ShuffleVector: {
4037 auto *Shuf = dyn_cast<ShuffleVectorInst>(U);
4042 APInt DemandedLHS, DemandedRHS;
4047 Tmp = std::numeric_limits<unsigned>::max();
4048 if (!!DemandedLHS) {
4049 const Value *
LHS = Shuf->getOperand(0);
4056 if (!!DemandedRHS) {
4057 const Value *
RHS = Shuf->getOperand(1);
4059 Tmp = std::min(Tmp, Tmp2);
4065 assert(Tmp <= TyBits &&
"Failed to determine minimum sign bits");
4068 case Instruction::Call: {
4069 if (
const auto *
II = dyn_cast<IntrinsicInst>(U)) {
4070 switch (
II->getIntrinsicID()) {
4073 case Intrinsic::abs:
4081 case Intrinsic::smin:
4082 case Intrinsic::smax: {
4083 const APInt *CLow, *CHigh;
4098 if (
unsigned VecSignBits =
4116 if (
F->isIntrinsic())
4117 return F->getIntrinsicID();
4123 if (
F->hasLocalLinkage() || !TLI || !TLI->
getLibFunc(CB, Func) ||
4133 return Intrinsic::sin;
4137 return Intrinsic::cos;
4141 return Intrinsic::tan;
4145 return Intrinsic::exp;
4149 return Intrinsic::exp2;
4153 return Intrinsic::log;
4155 case LibFunc_log10f:
4156 case LibFunc_log10l:
4157 return Intrinsic::log10;
4161 return Intrinsic::log2;
4165 return Intrinsic::fabs;
4169 return Intrinsic::minnum;
4173 return Intrinsic::maxnum;
4174 case LibFunc_copysign:
4175 case LibFunc_copysignf:
4176 case LibFunc_copysignl:
4177 return Intrinsic::copysign;
4179 case LibFunc_floorf:
4180 case LibFunc_floorl:
4181 return Intrinsic::floor;
4185 return Intrinsic::ceil;
4187 case LibFunc_truncf:
4188 case LibFunc_truncl:
4189 return Intrinsic::trunc;
4193 return Intrinsic::rint;
4194 case LibFunc_nearbyint:
4195 case LibFunc_nearbyintf:
4196 case LibFunc_nearbyintl:
4197 return Intrinsic::nearbyint;
4199 case LibFunc_roundf:
4200 case LibFunc_roundl:
4201 return Intrinsic::round;
4202 case LibFunc_roundeven:
4203 case LibFunc_roundevenf:
4204 case LibFunc_roundevenl:
4205 return Intrinsic::roundeven;
4209 return Intrinsic::pow;
4213 return Intrinsic::sqrt;
4261 switch (Mode.Input) {
4281 if (!Src.isKnownNeverPosZero() && !Src.isKnownNeverNegZero())
4285 if (Src.isKnownNeverSubnormal())
4315 bool &TrueIfSigned) {
4318 TrueIfSigned =
true;
4319 return RHS.isZero();
4321 TrueIfSigned =
true;
4322 return RHS.isAllOnes();
4324 TrueIfSigned =
false;
4325 return RHS.isAllOnes();
4327 TrueIfSigned =
false;
4328 return RHS.isZero();
4331 TrueIfSigned =
true;
4332 return RHS.isMaxSignedValue();
4335 TrueIfSigned =
true;
4336 return RHS.isMinSignedValue();
4339 TrueIfSigned =
false;
4340 return RHS.isMinSignedValue();
4343 TrueIfSigned =
false;
4344 return RHS.isMaxSignedValue();
4355 bool LookThroughSrc) {
4363std::pair<Value *, FPClassTest>
4365 const APFloat *ConstRHS,
bool LookThroughSrc) {
4367 auto [Src, ClassIfTrue, ClassIfFalse] =
4369 if (Src && ClassIfTrue == ~ClassIfFalse)
4370 return {Src, ClassIfTrue};
4381std::tuple<Value *, FPClassTest, FPClassTest>
4395 const bool IsNegativeRHS = (RHSClass &
fcNegative) == RHSClass;
4396 const bool IsPositiveRHS = (RHSClass &
fcPositive) == RHSClass;
4397 const bool IsNaN = (RHSClass & ~fcNan) ==
fcNone;
4417 const bool IsZero = (OrigClass &
fcZero) == OrigClass;
4464 const bool IsDenormalRHS = (OrigClass &
fcSubnormal) == OrigClass;
4466 const bool IsInf = (OrigClass &
fcInf) == OrigClass;
4484 if (IsNegativeRHS) {
4507 if (IsNegativeRHS) {
4508 Mask = ~fcNegInf & ~fcNan;
4512 Mask = ~fcPosInf & ~fcNan;
4521 if (IsNegativeRHS) {
4541 if (IsNegativeRHS) {
4561 if (IsNegativeRHS) {
4576 if (IsNegativeRHS) {
4604 return {Src, Class, ~fcNan};
4608 return {Src, ~fcNan, RHSClass |
fcNan};
4617 "should have been recognized as an exact class test");
4619 if (IsNegativeRHS) {
4629 return {Src, ~fcNan,
fcNan};
4638 return {Src,
fcNan, ~fcNan};
4657 return {Src, ClassesGE, ~ClassesGE | RHSClass};
4660 return {Src, ClassesGE |
fcNan, ~(ClassesGE |
fcNan) | RHSClass};
4663 return {Src, ClassesLE, ~ClassesLE | RHSClass};
4666 return {Src, ClassesLE |
fcNan, ~(ClassesLE |
fcNan) | RHSClass};
4670 }
else if (IsPositiveRHS) {
4686 return {Src, ClassesGE, ~ClassesGE | RHSClass};
4689 return {Src, ClassesGE |
fcNan, ~(ClassesGE |
fcNan) | RHSClass};
4692 return {Src, ClassesLE, ~ClassesLE | RHSClass};
4695 return {Src, ClassesLE |
fcNan, ~(ClassesLE |
fcNan) | RHSClass};
4704std::tuple<Value *, FPClassTest, FPClassTest>
4706 const APFloat &ConstRHS,
bool LookThroughSrc) {
4754std::tuple<Value *, FPClassTest, FPClassTest>
4756 Value *RHS,
bool LookThroughSrc) {
4778 KnownFromContext.
knownNot(~(CondIsTrue ? MaskIfTrue : MaskIfFalse));
4779 }
else if (
match(
Cond, m_Intrinsic<Intrinsic::is_fpclass>(
4782 KnownFromContext.
knownNot(CondIsTrue ? ~Mask : Mask);
4788 if (TrueIfSigned == CondIsTrue)
4800 return KnownFromContext;
4820 return KnownFromContext;
4830 "Got assumption for the wrong function!");
4831 assert(
I->getIntrinsicID() == Intrinsic::assume &&
4832 "must be an assume intrinsic");
4838 Q.
CxtI, KnownFromContext);
4841 return KnownFromContext;
4851 auto *FVTy = dyn_cast<FixedVectorType>(V->getType());
4852 APInt DemandedElts =
4858 const APInt &DemandedElts,
4862 if ((InterestedClasses &
4868 KnownSrc,
Depth + 1, Q);
4883 assert(Known.
isUnknown() &&
"should not be called with known information");
4885 if (!DemandedElts) {
4893 if (
auto *CFP = dyn_cast<ConstantFP>(V)) {
4895 Known.
SignBit = CFP->isNegative();
4899 if (isa<ConstantAggregateZero>(V)) {
4905 if (isa<PoisonValue>(V)) {
4912 auto *VFVTy = dyn_cast<FixedVectorType>(V->getType());
4913 const Constant *CV = dyn_cast<Constant>(V);
4916 bool SignBitAllZero =
true;
4917 bool SignBitAllOne =
true;
4920 unsigned NumElts = VFVTy->getNumElements();
4921 for (
unsigned i = 0; i != NumElts; ++i) {
4922 if (!DemandedElts[i])
4930 if (isa<PoisonValue>(Elt))
4932 auto *CElt = dyn_cast<ConstantFP>(Elt);
4938 const APFloat &
C = CElt->getValueAPF();
4941 SignBitAllZero =
false;
4943 SignBitAllOne =
false;
4945 if (SignBitAllOne != SignBitAllZero)
4946 Known.
SignBit = SignBitAllOne;
4951 if (
const auto *CB = dyn_cast<CallBase>(V))
4952 KnownNotFromFlags |= CB->getRetNoFPClass();
4953 else if (
const auto *Arg = dyn_cast<Argument>(V))
4954 KnownNotFromFlags |= Arg->getNoFPClass();
4958 if (FPOp->hasNoNaNs())
4959 KnownNotFromFlags |=
fcNan;
4960 if (FPOp->hasNoInfs())
4961 KnownNotFromFlags |=
fcInf;
4965 KnownNotFromFlags |= ~AssumedClasses.KnownFPClasses;
4969 InterestedClasses &= ~KnownNotFromFlags;
4974 if (*AssumedClasses.SignBit)
4975 Known.signBitMustBeOne();
4977 Known.signBitMustBeZero();
4988 const unsigned Opc =
Op->getOpcode();
4990 case Instruction::FNeg: {
4992 Known,
Depth + 1, Q);
4996 case Instruction::Select: {
5004 Value *TestedValue =
nullptr;
5008 const Function *
F = cast<Instruction>(
Op)->getFunction();
5010 Value *CmpLHS, *CmpRHS;
5017 bool LookThroughFAbsFNeg = CmpLHS !=
LHS && CmpLHS !=
RHS;
5018 std::tie(TestedValue, MaskIfTrue, MaskIfFalse) =
5021 m_Intrinsic<Intrinsic::is_fpclass>(
5024 MaskIfTrue = TestedMask;
5025 MaskIfFalse = ~TestedMask;
5028 if (TestedValue ==
LHS) {
5030 FilterLHS = MaskIfTrue;
5031 }
else if (TestedValue ==
RHS) {
5033 FilterRHS = MaskIfFalse;
5042 Known2,
Depth + 1, Q);
5048 case Instruction::Call: {
5052 case Intrinsic::fabs: {
5057 InterestedClasses, Known,
Depth + 1, Q);
5063 case Intrinsic::copysign: {
5067 Known,
Depth + 1, Q);
5069 KnownSign,
Depth + 1, Q);
5073 case Intrinsic::fma:
5074 case Intrinsic::fmuladd: {
5078 if (
II->getArgOperand(0) !=
II->getArgOperand(1))
5087 KnownAddend,
Depth + 1, Q);
5093 case Intrinsic::sqrt:
5094 case Intrinsic::experimental_constrained_sqrt: {
5097 if (InterestedClasses &
fcNan)
5101 KnownSrc,
Depth + 1, Q);
5124 case Intrinsic::sin:
5125 case Intrinsic::cos: {
5129 KnownSrc,
Depth + 1, Q);
5135 case Intrinsic::maxnum:
5136 case Intrinsic::minnum:
5137 case Intrinsic::minimum:
5138 case Intrinsic::maximum: {
5141 KnownLHS,
Depth + 1, Q);
5143 KnownRHS,
Depth + 1, Q);
5146 Known = KnownLHS | KnownRHS;
5149 if (NeverNaN && (IID == Intrinsic::minnum || IID == Intrinsic::maxnum))
5152 if (IID == Intrinsic::maxnum) {
5160 }
else if (IID == Intrinsic::maximum) {
5166 }
else if (IID == Intrinsic::minnum) {
5196 II->getType()->getScalarType()->getFltSemantics());
5208 }
else if ((IID == Intrinsic::maximum || IID == Intrinsic::minimum) ||
5213 if ((IID == Intrinsic::maximum || IID == Intrinsic::maxnum) &&
5216 else if ((IID == Intrinsic::minimum || IID == Intrinsic::minnum) &&
5223 case Intrinsic::canonicalize: {
5226 KnownSrc,
Depth + 1, Q);
5250 II->getType()->getScalarType()->getFltSemantics();
5270 case Intrinsic::vector_reduce_fmax:
5271 case Intrinsic::vector_reduce_fmin:
5272 case Intrinsic::vector_reduce_fmaximum:
5273 case Intrinsic::vector_reduce_fminimum: {
5277 InterestedClasses,
Depth + 1, Q);
5284 case Intrinsic::vector_reverse:
5287 II->getFastMathFlags(), InterestedClasses,
Depth + 1, Q);
5289 case Intrinsic::trunc:
5290 case Intrinsic::floor:
5291 case Intrinsic::ceil:
5292 case Intrinsic::rint:
5293 case Intrinsic::nearbyint:
5294 case Intrinsic::round:
5295 case Intrinsic::roundeven: {
5303 KnownSrc,
Depth + 1, Q);
5312 if (IID == Intrinsic::trunc || !V->getType()->isMultiUnitFPType()) {
5327 case Intrinsic::exp:
5328 case Intrinsic::exp2:
5329 case Intrinsic::exp10: {
5336 KnownSrc,
Depth + 1, Q);
5344 case Intrinsic::fptrunc_round: {
5349 case Intrinsic::log:
5350 case Intrinsic::log10:
5351 case Intrinsic::log2:
5352 case Intrinsic::experimental_constrained_log:
5353 case Intrinsic::experimental_constrained_log10:
5354 case Intrinsic::experimental_constrained_log2: {
5370 KnownSrc,
Depth + 1, Q);
5384 case Intrinsic::powi: {
5388 const Value *Exp =
II->getArgOperand(1);
5389 Type *ExpTy = Exp->getType();
5393 ExponentKnownBits,
Depth + 1, Q);
5395 if (ExponentKnownBits.
Zero[0]) {
5410 KnownSrc,
Depth + 1, Q);
5415 case Intrinsic::ldexp: {
5418 KnownSrc,
Depth + 1, Q);
5434 if ((InterestedClasses & ExpInfoMask) ==
fcNone)
5440 II->getType()->getScalarType()->getFltSemantics();
5442 const Value *ExpArg =
II->getArgOperand(1);
5446 const int MantissaBits = Precision - 1;
5452 if (ConstVal && ConstVal->
isZero()) {
5475 case Intrinsic::arithmetic_fence: {
5477 Known,
Depth + 1, Q);
5480 case Intrinsic::experimental_constrained_sitofp:
5481 case Intrinsic::experimental_constrained_uitofp:
5491 if (IID == Intrinsic::experimental_constrained_uitofp)
5502 case Instruction::FAdd:
5503 case Instruction::FSub: {
5506 Op->getOpcode() == Instruction::FAdd &&
5508 bool WantNaN = (InterestedClasses &
fcNan) !=
fcNone;
5511 if (!WantNaN && !WantNegative && !WantNegZero)
5517 if (InterestedClasses &
fcNan)
5518 InterestedSrcs |=
fcInf;
5520 KnownRHS,
Depth + 1, Q);
5524 WantNegZero || Opc == Instruction::FSub) {
5529 KnownLHS,
Depth + 1, Q);
5537 const Function *
F = cast<Instruction>(
Op)->getFunction();
5539 if (
Op->getOpcode() == Instruction::FAdd) {
5567 case Instruction::FMul: {
5569 if (
Op->getOperand(0) ==
Op->getOperand(1))
5602 const Function *
F = cast<Instruction>(
Op)->getFunction();
5614 case Instruction::FDiv:
5615 case Instruction::FRem: {
5616 if (
Op->getOperand(0) ==
Op->getOperand(1)) {
5618 if (
Op->getOpcode() == Instruction::FDiv) {
5629 const bool WantNan = (InterestedClasses &
fcNan) !=
fcNone;
5631 const bool WantPositive =
5633 if (!WantNan && !WantNegative && !WantPositive)
5642 bool KnowSomethingUseful =
5645 if (KnowSomethingUseful || WantPositive) {
5651 InterestedClasses & InterestedLHS, KnownLHS,
5655 const Function *
F = cast<Instruction>(
Op)->getFunction();
5657 if (
Op->getOpcode() == Instruction::FDiv) {
5694 case Instruction::FPExt: {
5697 Known,
Depth + 1, Q);
5700 Op->getType()->getScalarType()->getFltSemantics();
5702 Op->getOperand(0)->getType()->getScalarType()->getFltSemantics();
5718 case Instruction::FPTrunc: {
5723 case Instruction::SIToFP:
5724 case Instruction::UIToFP: {
5733 if (
Op->getOpcode() == Instruction::UIToFP)
5736 if (InterestedClasses &
fcInf) {
5740 int IntSize =
Op->getOperand(0)->getType()->getScalarSizeInBits();
5741 if (
Op->getOpcode() == Instruction::SIToFP)
5746 Type *FPTy =
Op->getType()->getScalarType();
5753 case Instruction::ExtractElement: {
5756 const Value *Vec =
Op->getOperand(0);
5758 auto *CIdx = dyn_cast<ConstantInt>(
Idx);
5760 if (
auto *VecTy = dyn_cast<FixedVectorType>(Vec->
getType())) {
5761 unsigned NumElts = VecTy->getNumElements();
5763 if (CIdx && CIdx->getValue().ult(NumElts))
5771 case Instruction::InsertElement: {
5772 if (isa<ScalableVectorType>(
Op->getType()))
5775 const Value *Vec =
Op->getOperand(0);
5776 const Value *Elt =
Op->getOperand(1);
5777 auto *CIdx = dyn_cast<ConstantInt>(
Op->getOperand(2));
5779 APInt DemandedVecElts = DemandedElts;
5780 bool NeedsElt =
true;
5782 if (CIdx && CIdx->getValue().ult(NumElts)) {
5783 DemandedVecElts.
clearBit(CIdx->getZExtValue());
5784 NeedsElt = DemandedElts[CIdx->getZExtValue()];
5798 if (!DemandedVecElts.
isZero()) {
5807 case Instruction::ShuffleVector: {
5810 APInt DemandedLHS, DemandedRHS;
5811 auto *Shuf = dyn_cast<ShuffleVectorInst>(
Op);
5815 if (!!DemandedLHS) {
5816 const Value *
LHS = Shuf->getOperand(0);
5827 if (!!DemandedRHS) {
5829 const Value *
RHS = Shuf->getOperand(1);
5837 case Instruction::ExtractValue: {
5841 if (isa<StructType>(Src->getType()) && Indices.
size() == 1 &&
5843 if (
const auto *
II = dyn_cast<IntrinsicInst>(Src)) {
5844 switch (
II->getIntrinsicID()) {
5845 case Intrinsic::frexp: {
5850 InterestedClasses, KnownSrc,
Depth + 1, Q);
5852 const Function *
F = cast<Instruction>(
Op)->getFunction();
5885 case Instruction::PHI: {
5888 if (
P->getNumIncomingValues() == 0)
5895 if (
Depth < PhiRecursionLimit) {
5897 if (isa_and_nonnull<UndefValue>(
P->hasConstantValue()))
5902 for (
const Use &U :
P->operands()) {
5903 Value *IncValue = U.get();
5913 IncValue, DemandedElts, InterestedClasses, KnownSrc,
5937 const APInt &DemandedElts,
5944 return KnownClasses;
5959 if (V->getType()->isIntegerTy(8))
5966 if (isa<UndefValue>(V))
5970 if (
DL.getTypeStoreSize(V->getType()).isZero())
5985 if (
C->isNullValue())
5992 if (CFP->getType()->isHalfTy())
5994 else if (CFP->getType()->isFloatTy())
5996 else if (CFP->getType()->isDoubleTy())
6005 if (CI->getBitWidth() % 8 == 0) {
6006 assert(CI->getBitWidth() > 8 &&
"8 bits should be handled above!");
6007 if (!CI->getValue().isSplat(8))
6009 return ConstantInt::get(Ctx, CI->getValue().trunc(8));
6013 if (
auto *CE = dyn_cast<ConstantExpr>(
C)) {
6014 if (CE->getOpcode() == Instruction::IntToPtr) {
6015 if (
auto *PtrTy = dyn_cast<PointerType>(CE->getType())) {
6016 unsigned BitWidth =
DL.getPointerSizeInBits(PtrTy->getAddressSpace());
6029 if (
LHS == UndefInt8)
6031 if (
RHS == UndefInt8)
6037 Value *Val = UndefInt8;
6038 for (
unsigned I = 0, E = CA->getNumElements();
I != E; ++
I)
6044 if (isa<ConstantAggregate>(
C)) {
6045 Value *Val = UndefInt8;
6046 for (
unsigned I = 0, E =
C->getNumOperands();
I != E; ++
I)
6066 StructType *STy = dyn_cast<StructType>(IndexedType);
6080 while (PrevTo != OrigTo) {
6127 unsigned IdxSkip = Idxs.
size();
6140 std::optional<BasicBlock::iterator> InsertBefore) {
6143 if (idx_range.
empty())
6146 assert((V->getType()->isStructTy() || V->getType()->isArrayTy()) &&
6147 "Not looking at a struct or array?");
6149 "Invalid indices for type?");
6151 if (
Constant *
C = dyn_cast<Constant>(V)) {
6152 C =
C->getAggregateElement(idx_range[0]);
6153 if (!
C)
return nullptr;
6160 const unsigned *req_idx = idx_range.
begin();
6161 for (
const unsigned *i =
I->idx_begin(), *e =
I->idx_end();
6162 i != e; ++i, ++req_idx) {
6163 if (req_idx == idx_range.
end()) {
6193 ArrayRef(req_idx, idx_range.
end()), InsertBefore);
6202 unsigned size =
I->getNumIndices() + idx_range.
size();
6207 Idxs.
append(
I->idx_begin(),
I->idx_end());
6213 &&
"Number of indices added not correct?");
6223 unsigned CharSize) {
6225 if (
GEP->getNumOperands() != 3)
6230 ArrayType *AT = dyn_cast<ArrayType>(
GEP->getSourceElementType());
6236 const ConstantInt *FirstIdx = dyn_cast<ConstantInt>(
GEP->getOperand(1));
6237 if (!FirstIdx || !FirstIdx->
isZero())
6251 assert(V &&
"V should not be null.");
6252 assert((ElementSize % 8) == 0 &&
6253 "ElementSize expected to be a multiple of the size of a byte.");
6254 unsigned ElementSizeInBytes = ElementSize / 8;
6266 APInt Off(
DL.getIndexTypeSizeInBits(V->getType()), 0);
6268 if (GV != V->stripAndAccumulateConstantOffsets(
DL, Off,
6273 uint64_t StartIdx = Off.getLimitedValue();
6280 if ((StartIdx % ElementSizeInBytes) != 0)
6283 Offset += StartIdx / ElementSizeInBytes;
6289 uint64_t SizeInBytes =
DL.getTypeStoreSize(GVTy).getFixedValue();
6292 Slice.
Array =
nullptr;
6303 if (
auto *ArrayInit = dyn_cast<ConstantDataArray>(
Init)) {
6304 Type *InitElTy = ArrayInit->getElementType();
6309 ArrayTy = ArrayInit->getType();
6314 if (ElementSize != 8)
6325 Array = dyn_cast<ConstantDataArray>(
Init);
6326 ArrayTy = dyn_cast<ArrayType>(
Init->getType());
6333 Slice.
Array = Array;
6349 if (Slice.
Array ==
nullptr) {
6372 Str = Str.substr(Slice.
Offset);
6378 Str = Str.substr(0, Str.find(
'\0'));
6391 unsigned CharSize) {
6393 V = V->stripPointerCasts();
6397 if (
const PHINode *PN = dyn_cast<PHINode>(V)) {
6398 if (!PHIs.
insert(PN).second)
6403 for (
Value *IncValue : PN->incoming_values()) {
6405 if (Len == 0)
return 0;
6407 if (Len == ~0ULL)
continue;
6409 if (Len != LenSoFar && LenSoFar != ~0ULL)
6419 if (
const SelectInst *SI = dyn_cast<SelectInst>(V)) {
6421 if (Len1 == 0)
return 0;
6423 if (Len2 == 0)
return 0;
6424 if (Len1 == ~0ULL)
return Len2;
6425 if (Len2 == ~0ULL)
return Len1;
6426 if (Len1 != Len2)
return 0;
6435 if (Slice.
Array ==
nullptr)
6443 unsigned NullIndex = 0;
6444 for (
unsigned E = Slice.
Length; NullIndex < E; ++NullIndex) {
6449 return NullIndex + 1;
6455 if (!V->getType()->isPointerTy())
6462 return Len == ~0ULL ? 1 : Len;
6467 bool MustPreserveNullness) {
6469 "getArgumentAliasingToReturnedPointer only works on nonnull calls");
6470 if (
const Value *RV = Call->getReturnedArgOperand())
6474 Call, MustPreserveNullness))
6475 return Call->getArgOperand(0);
6480 const CallBase *Call,
bool MustPreserveNullness) {
6481 switch (Call->getIntrinsicID()) {
6482 case Intrinsic::launder_invariant_group:
6483 case Intrinsic::strip_invariant_group:
6484 case Intrinsic::aarch64_irg:
6485 case Intrinsic::aarch64_tagp:
6495 case Intrinsic::amdgcn_make_buffer_rsrc:
6497 case Intrinsic::ptrmask:
6498 return !MustPreserveNullness;
6499 case Intrinsic::threadlocal_address:
6502 return !Call->getParent()->getParent()->isPresplitCoroutine();
6519 if (!PrevValue || LI->
getLoopFor(PrevValue->getParent()) != L)
6521 if (!PrevValue || LI->
getLoopFor(PrevValue->getParent()) != L)
6529 if (
auto *Load = dyn_cast<LoadInst>(PrevValue))
6530 if (!L->isLoopInvariant(Load->getPointerOperand()))
6536 if (!V->getType()->isPointerTy())
6538 for (
unsigned Count = 0; MaxLookup == 0 || Count < MaxLookup; ++Count) {
6539 if (
auto *
GEP = dyn_cast<GEPOperator>(V)) {
6540 V =
GEP->getPointerOperand();
6543 Value *NewV = cast<Operator>(V)->getOperand(0);
6547 }
else if (
auto *GA = dyn_cast<GlobalAlias>(V)) {
6548 if (GA->isInterposable())
6550 V = GA->getAliasee();
6552 if (
auto *
PHI = dyn_cast<PHINode>(V)) {
6554 if (
PHI->getNumIncomingValues() == 1) {
6555 V =
PHI->getIncomingValue(0);
6558 }
else if (
auto *Call = dyn_cast<CallBase>(V)) {
6576 assert(V->getType()->isPointerTy() &&
"Unexpected operand type!");
6583 LoopInfo *LI,
unsigned MaxLookup) {
6591 if (!Visited.
insert(
P).second)
6594 if (
auto *SI = dyn_cast<SelectInst>(
P)) {
6596 Worklist.
push_back(SI->getFalseValue());
6600 if (
auto *PN = dyn_cast<PHINode>(
P)) {
6620 }
while (!Worklist.
empty());
6627 if (
const Operator *U = dyn_cast<Operator>(V)) {
6630 if (U->getOpcode() == Instruction::PtrToInt)
6631 return U->getOperand(0);
6638 if (U->getOpcode() != Instruction::Add ||
6639 (!isa<ConstantInt>(U->getOperand(1)) &&
6641 !isa<PHINode>(U->getOperand(1))))
6643 V = U->getOperand(0);
6647 assert(V->getType()->isIntegerTy() &&
"Unexpected operand type!");
6664 for (
const Value *V : Objs) {
6665 if (!Visited.
insert(V).second)
6670 if (O->getType()->isPointerTy()) {
6683 }
while (!Working.
empty());
6692 auto AddWork = [&](
Value *V) {
6693 if (Visited.
insert(V).second)
6702 if (
AllocaInst *AI = dyn_cast<AllocaInst>(V)) {
6703 if (Result && Result != AI)
6706 }
else if (
CastInst *CI = dyn_cast<CastInst>(V)) {
6707 AddWork(CI->getOperand(0));
6708 }
else if (
PHINode *PN = dyn_cast<PHINode>(V)) {
6709 for (
Value *IncValue : PN->incoming_values())
6711 }
else if (
auto *SI = dyn_cast<SelectInst>(V)) {
6712 AddWork(SI->getTrueValue());
6713 AddWork(SI->getFalseValue());
6715 if (OffsetZero && !
GEP->hasAllZeroIndices())
6717 AddWork(
GEP->getPointerOperand());
6718 }
else if (
CallBase *CB = dyn_cast<CallBase>(V)) {
6719 Value *Returned = CB->getReturnedArgOperand();
6727 }
while (!Worklist.
empty());
6733 const Value *V,
bool AllowLifetime,
bool AllowDroppable) {
6734 for (
const User *U : V->users()) {
6739 if (AllowLifetime &&
II->isLifetimeStartOrEnd())
6742 if (AllowDroppable &&
II->isDroppable())
6764 return F.hasFnAttribute(Attribute::SanitizeThread) ||
6766 F.hasFnAttribute(Attribute::SanitizeAddress) ||
6767 F.hasFnAttribute(Attribute::SanitizeHWAddress);
6786 auto hasEqualReturnAndLeadingOperandTypes =
6787 [](
const Instruction *Inst,
unsigned NumLeadingOperands) {
6791 for (
unsigned ItOp = 0; ItOp < NumLeadingOperands; ++ItOp)
6797 hasEqualReturnAndLeadingOperandTypes(Inst, 2));
6799 hasEqualReturnAndLeadingOperandTypes(Inst, 1));
6806 case Instruction::UDiv:
6807 case Instruction::URem: {
6814 case Instruction::SDiv:
6815 case Instruction::SRem: {
6817 const APInt *Numerator, *Denominator;
6821 if (*Denominator == 0)
6833 case Instruction::Load: {
6834 const LoadInst *LI = dyn_cast<LoadInst>(Inst);
6844 case Instruction::Call: {
6845 auto *CI = dyn_cast<const CallInst>(Inst);
6848 const Function *Callee = CI->getCalledFunction();
6852 return Callee && Callee->isSpeculatable();
6854 case Instruction::VAArg:
6855 case Instruction::Alloca:
6856 case Instruction::Invoke:
6857 case Instruction::CallBr:
6858 case Instruction::PHI:
6859 case Instruction::Store:
6860 case Instruction::Ret:
6861 case Instruction::Br:
6862 case Instruction::IndirectBr:
6863 case Instruction::Switch:
6864 case Instruction::Unreachable:
6865 case Instruction::Fence:
6866 case Instruction::AtomicRMW:
6867 case Instruction::AtomicCmpXchg:
6868 case Instruction::LandingPad:
6869 case Instruction::Resume:
6870 case Instruction::CatchSwitch:
6871 case Instruction::CatchPad:
6872 case Instruction::CatchRet:
6873 case Instruction::CleanupPad:
6874 case Instruction::CleanupRet:
6880 if (
I.mayReadOrWriteMemory())
6993 if (
Add &&
Add->hasNoSignedWrap()) {
7033 bool LHSOrRHSKnownNonNegative =
7035 bool LHSOrRHSKnownNegative =
7037 if (LHSOrRHSKnownNonNegative || LHSOrRHSKnownNegative) {
7040 if ((AddKnown.
isNonNegative() && LHSOrRHSKnownNonNegative) ||
7041 (AddKnown.
isNegative() && LHSOrRHSKnownNegative))
7070 m_Intrinsic<Intrinsic::usub_with_overflow>(
m_Value(),
m_Value())))
7119 if (
const auto *EVI = dyn_cast<ExtractValueInst>(U)) {
7120 assert(EVI->getNumIndices() == 1 &&
"Obvious from CI's type");
7122 if (EVI->getIndices()[0] == 0)
7125 assert(EVI->getIndices()[0] == 1 &&
"Obvious from CI's type");
7127 for (
const auto *U : EVI->users())
7128 if (
const auto *
B = dyn_cast<BranchInst>(U)) {
7129 assert(
B->isConditional() &&
"How else is it using an i1?");
7140 auto AllUsesGuardedByBranch = [&](
const BranchInst *BI) {
7146 for (
const auto *Result :
Results) {
7149 if (DT.
dominates(NoWrapEdge, Result->getParent()))
7152 for (
const auto &RU : Result->uses())
7160 return llvm::any_of(GuardingBranches, AllUsesGuardedByBranch);
7165 auto *
C = dyn_cast<Constant>(ShiftAmount);
7171 if (
auto *FVTy = dyn_cast<FixedVectorType>(
C->getType())) {
7172 unsigned NumElts = FVTy->getNumElements();
7173 for (
unsigned i = 0; i < NumElts; ++i)
7174 ShiftAmounts.
push_back(
C->getAggregateElement(i));
7175 }
else if (isa<ScalableVectorType>(
C->getType()))
7181 auto *CI = dyn_cast_or_null<ConstantInt>(
C);
7182 return CI && CI->getValue().ult(
C->getType()->getIntegerBitWidth());
7195 return (
unsigned(Kind) &
unsigned(UndefPoisonKind::PoisonOnly)) != 0;
7199 return (
unsigned(Kind) &
unsigned(UndefPoisonKind::UndefOnly)) != 0;
7203 bool ConsiderFlagsAndMetadata) {
7206 Op->hasPoisonGeneratingAnnotations())
7209 unsigned Opcode =
Op->getOpcode();
7213 case Instruction::Shl:
7214 case Instruction::AShr:
7215 case Instruction::LShr:
7217 case Instruction::FPToSI:
7218 case Instruction::FPToUI:
7222 case Instruction::Call:
7223 if (
auto *
II = dyn_cast<IntrinsicInst>(
Op)) {
7224 switch (
II->getIntrinsicID()) {
7226 case Intrinsic::ctlz:
7227 case Intrinsic::cttz:
7228 case Intrinsic::abs:
7229 if (cast<ConstantInt>(
II->getArgOperand(1))->isNullValue())
7232 case Intrinsic::ctpop:
7233 case Intrinsic::bswap:
7234 case Intrinsic::bitreverse:
7235 case Intrinsic::fshl:
7236 case Intrinsic::fshr:
7237 case Intrinsic::smax:
7238 case Intrinsic::smin:
7239 case Intrinsic::umax:
7240 case Intrinsic::umin:
7241 case Intrinsic::ptrmask:
7242 case Intrinsic::fptoui_sat:
7243 case Intrinsic::fptosi_sat:
7244 case Intrinsic::sadd_with_overflow:
7245 case Intrinsic::ssub_with_overflow:
7246 case Intrinsic::smul_with_overflow:
7247 case Intrinsic::uadd_with_overflow:
7248 case Intrinsic::usub_with_overflow:
7249 case Intrinsic::umul_with_overflow:
7250 case Intrinsic::sadd_sat:
7251 case Intrinsic::uadd_sat:
7252 case Intrinsic::ssub_sat:
7253 case Intrinsic::usub_sat:
7255 case Intrinsic::sshl_sat:
7256 case Intrinsic::ushl_sat:
7259 case Intrinsic::fma:
7260 case Intrinsic::fmuladd:
7261 case Intrinsic::sqrt:
7262 case Intrinsic::powi:
7263 case Intrinsic::sin:
7264 case Intrinsic::cos:
7265 case Intrinsic::pow:
7266 case Intrinsic::log:
7267 case Intrinsic::log10:
7268 case Intrinsic::log2:
7269 case Intrinsic::exp:
7270 case Intrinsic::exp2:
7271 case Intrinsic::exp10:
7272 case Intrinsic::fabs:
7273 case Intrinsic::copysign:
7274 case Intrinsic::floor:
7275 case Intrinsic::ceil:
7276 case Intrinsic::trunc:
7277 case Intrinsic::rint:
7278 case Intrinsic::nearbyint:
7279 case Intrinsic::round:
7280 case Intrinsic::roundeven:
7281 case Intrinsic::fptrunc_round:
7282 case Intrinsic::canonicalize:
7283 case Intrinsic::arithmetic_fence:
7284 case Intrinsic::minnum:
7285 case Intrinsic::maxnum:
7286 case Intrinsic::minimum:
7287 case Intrinsic::maximum:
7288 case Intrinsic::is_fpclass:
7289 case Intrinsic::ldexp:
7290 case Intrinsic::frexp:
7292 case Intrinsic::lround:
7293 case Intrinsic::llround:
7294 case Intrinsic::lrint:
7295 case Intrinsic::llrint:
7302 case Instruction::CallBr:
7303 case Instruction::Invoke: {
7304 const auto *CB = cast<CallBase>(
Op);
7305 return !CB->hasRetAttr(Attribute::NoUndef);
7307 case Instruction::InsertElement:
7308 case Instruction::ExtractElement: {
7310 auto *VTy = cast<VectorType>(
Op->getOperand(0)->getType());
7311 unsigned IdxOp =
Op->getOpcode() == Instruction::InsertElement ? 2 : 1;
7312 auto *
Idx = dyn_cast<ConstantInt>(
Op->getOperand(IdxOp));
7315 Idx->getValue().uge(VTy->getElementCount().getKnownMinValue());
7318 case Instruction::ShuffleVector: {
7320 ? cast<ConstantExpr>(
Op)->getShuffleMask()
7321 : cast<ShuffleVectorInst>(
Op)->getShuffleMask();
7324 case Instruction::FNeg:
7325 case Instruction::PHI:
7326 case Instruction::Select:
7327 case Instruction::URem:
7328 case Instruction::SRem:
7329 case Instruction::ExtractValue:
7330 case Instruction::InsertValue:
7331 case Instruction::Freeze:
7332 case Instruction::ICmp:
7333 case Instruction::FCmp:
7334 case Instruction::FAdd:
7335 case Instruction::FSub:
7336 case Instruction::FMul:
7337 case Instruction::FDiv:
7338 case Instruction::FRem:
7340 case Instruction::GetElementPtr:
7345 const auto *CE = dyn_cast<ConstantExpr>(
Op);
7346 if (isa<CastInst>(
Op) || (CE && CE->isCast()))
7357 bool ConsiderFlagsAndMetadata) {
7358 return ::canCreateUndefOrPoison(
Op, UndefPoisonKind::UndefOrPoison,
7359 ConsiderFlagsAndMetadata);
7363 return ::canCreateUndefOrPoison(
Op, UndefPoisonKind::PoisonOnly,
7364 ConsiderFlagsAndMetadata);
7369 if (ValAssumedPoison == V)
7376 if (
const auto *
I = dyn_cast<Instruction>(V)) {
7378 return propagatesPoison(Op) &&
7379 directlyImpliesPoison(ValAssumedPoison, Op, Depth + 1);
7407 const auto *
I = dyn_cast<Instruction>(ValAssumedPoison);
7410 return impliesPoison(Op, V, Depth + 1);
7417 return ::impliesPoison(ValAssumedPoison, V, 0);
7428 if (isa<MetadataAsValue>(V))
7431 if (
const auto *
A = dyn_cast<Argument>(V)) {
7432 if (
A->hasAttribute(Attribute::NoUndef) ||
7433 A->hasAttribute(Attribute::Dereferenceable) ||
7434 A->hasAttribute(Attribute::DereferenceableOrNull))
7438 if (
auto *
C = dyn_cast<Constant>(V)) {
7439 if (isa<PoisonValue>(
C))
7442 if (isa<UndefValue>(
C))
7445 if (isa<ConstantInt>(
C) || isa<GlobalVariable>(
C) || isa<ConstantFP>(V) ||
7446 isa<ConstantPointerNull>(
C) || isa<Function>(
C))
7449 if (
C->getType()->isVectorTy() && !isa<ConstantExpr>(
C)) {
7454 return !
C->containsConstantExpression();
7466 auto *StrippedV = V->stripPointerCastsSameRepresentation();
7467 if (isa<AllocaInst>(StrippedV) || isa<GlobalVariable>(StrippedV) ||
7468 isa<Function>(StrippedV) || isa<ConstantPointerNull>(StrippedV))
7471 auto OpCheck = [&](
const Value *V) {
7475 if (
auto *Opr = dyn_cast<Operator>(V)) {
7478 if (isa<FreezeInst>(V))
7481 if (
const auto *CB = dyn_cast<CallBase>(V)) {
7482 if (CB->hasRetAttr(Attribute::NoUndef) ||
7483 CB->hasRetAttr(Attribute::Dereferenceable) ||
7484 CB->hasRetAttr(Attribute::DereferenceableOrNull))
7488 if (
const auto *PN = dyn_cast<PHINode>(V)) {
7489 unsigned Num = PN->getNumIncomingValues();
7490 bool IsWellDefined =
true;
7491 for (
unsigned i = 0; i < Num; ++i) {
7492 auto *TI = PN->getIncomingBlock(i)->getTerminator();
7494 DT,
Depth + 1, Kind)) {
7495 IsWellDefined =
false;
7503 all_of(Opr->operands(), OpCheck))
7507 if (
auto *
I = dyn_cast<LoadInst>(V))
7508 if (
I->hasMetadata(LLVMContext::MD_noundef) ||
7509 I->hasMetadata(LLVMContext::MD_dereferenceable) ||
7510 I->hasMetadata(LLVMContext::MD_dereferenceable_or_null))
7530 auto *Dominator = DNode->
getIDom();
7535 auto *TI = Dominator->
getBlock()->getTerminator();
7538 if (
auto BI = dyn_cast_or_null<BranchInst>(TI)) {
7539 if (BI->isConditional())
7540 Cond = BI->getCondition();
7541 }
else if (
auto SI = dyn_cast_or_null<SwitchInst>(TI)) {
7542 Cond = SI->getCondition();
7550 auto *Opr = cast<Operator>(
Cond);
7551 if (
any_of(Opr->operands(), [V](
const Use &U) {
7552 return V == U && propagatesPoison(U);
7558 Dominator = Dominator->getIDom();
7571 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT,
Depth,
7572 UndefPoisonKind::UndefOrPoison);
7578 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT,
Depth,
7579 UndefPoisonKind::PoisonOnly);
7585 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT,
Depth,
7586 UndefPoisonKind::UndefOnly);
7609 while (!Worklist.
empty()) {
7618 if (
I != Root && !
any_of(
I->operands(), [&KnownPoison](
const Use &U) {
7619 return KnownPoison.contains(U) && propagatesPoison(U);
7623 if (KnownPoison.
insert(
I).second)
7635 return ::computeOverflowForSignedAdd(
Add->getOperand(0),
Add->getOperand(1),
7643 return ::computeOverflowForSignedAdd(
LHS,
RHS,
nullptr, SQ);
7652 if (isa<ReturnInst>(
I))
7654 if (isa<UnreachableInst>(
I))
7661 if (isa<CatchPadInst>(
I)) {
7675 return !
I->mayThrow() &&
I->willReturn();
7689 unsigned ScanLimit) {
7696 assert(ScanLimit &&
"scan limit must be non-zero");
7698 if (isa<DbgInfoIntrinsic>(
I))
7700 if (--ScanLimit == 0)
7714 if (
I->getParent() != L->getHeader())
return false;
7717 if (&LI ==
I)
return true;
7720 llvm_unreachable(
"Instruction not contained in its own parent basic block.");
7725 switch (
I->getOpcode()) {
7726 case Instruction::Freeze:
7727 case Instruction::PHI:
7728 case Instruction::Invoke:
7730 case Instruction::Select:
7732 case Instruction::Call:
7733 if (
auto *
II = dyn_cast<IntrinsicInst>(
I)) {
7734 switch (
II->getIntrinsicID()) {
7736 case Intrinsic::sadd_with_overflow:
7737 case Intrinsic::ssub_with_overflow:
7738 case Intrinsic::smul_with_overflow:
7739 case Intrinsic::uadd_with_overflow:
7740 case Intrinsic::usub_with_overflow:
7741 case Intrinsic::umul_with_overflow:
7746 case Intrinsic::ctpop:
7747 case Intrinsic::ctlz:
7748 case Intrinsic::cttz:
7749 case Intrinsic::abs:
7750 case Intrinsic::smax:
7751 case Intrinsic::smin:
7752 case Intrinsic::umax:
7753 case Intrinsic::umin:
7754 case Intrinsic::bitreverse:
7755 case Intrinsic::bswap:
7756 case Intrinsic::sadd_sat:
7757 case Intrinsic::ssub_sat:
7758 case Intrinsic::sshl_sat:
7759 case Intrinsic::uadd_sat:
7760 case Intrinsic::usub_sat:
7761 case Intrinsic::ushl_sat:
7766 case Instruction::ICmp:
7767 case Instruction::FCmp:
7768 case Instruction::GetElementPtr:
7771 if (isa<BinaryOperator>(
I) || isa<UnaryOperator>(
I) || isa<CastInst>(
I))
7782template <
typename CallableT>
7784 const CallableT &Handle) {
7785 switch (
I->getOpcode()) {
7786 case Instruction::Store:
7791 case Instruction::Load:
7798 case Instruction::AtomicCmpXchg:
7803 case Instruction::AtomicRMW:
7808 case Instruction::Call:
7809 case Instruction::Invoke: {
7813 for (
unsigned i = 0; i < CB->
arg_size(); ++i)
7816 CB->
paramHasAttr(i, Attribute::DereferenceableOrNull)) &&
7821 case Instruction::Ret:
7822 if (
I->getFunction()->hasRetAttribute(Attribute::NoUndef) &&
7823 Handle(
I->getOperand(0)))
7826 case Instruction::Switch:
7827 if (Handle(cast<SwitchInst>(
I)->getCondition()))
7830 case Instruction::Br: {
7831 auto *BR = cast<BranchInst>(
I);
7832 if (BR->isConditional() && Handle(BR->getCondition()))
7852template <
typename CallableT>
7854 const CallableT &Handle) {
7857 switch (
I->getOpcode()) {
7859 case Instruction::UDiv:
7860 case Instruction::SDiv:
7861 case Instruction::URem:
7862 case Instruction::SRem:
7863 return Handle(
I->getOperand(1));
7880 I, [&](
const Value *V) {
return KnownPoison.
count(V); });
7894 if (
const auto *Inst = dyn_cast<Instruction>(V)) {
7898 }
else if (
const auto *Arg = dyn_cast<Argument>(V)) {
7899 if (Arg->getParent()->isDeclaration())
7902 Begin = BB->
begin();
7909 unsigned ScanLimit = 32;
7918 if (isa<DbgInfoIntrinsic>(
I))
7920 if (--ScanLimit == 0)
7924 return WellDefinedOp == V;
7944 if (isa<DbgInfoIntrinsic>(
I))
7946 if (--ScanLimit == 0)
7954 for (
const Use &
Op :
I.operands()) {
7964 if (
I.getOpcode() == Instruction::Select &&
7965 YieldsPoison.
count(
I.getOperand(1)) &&
7966 YieldsPoison.
count(
I.getOperand(2))) {
7972 if (!BB || !Visited.
insert(BB).second)
7982 return ::programUndefinedIfUndefOrPoison(Inst,
false);
7986 return ::programUndefinedIfUndefOrPoison(Inst,
true);
7993 if (
auto *
C = dyn_cast<ConstantFP>(V))
7996 if (
auto *
C = dyn_cast<ConstantDataVector>(V)) {
7997 if (!
C->getElementType()->isFloatingPointTy())
7999 for (
unsigned I = 0, E =
C->getNumElements();
I < E; ++
I) {
8000 if (
C->getElementAsAPFloat(
I).isNaN())
8006 if (isa<ConstantAggregateZero>(V))
8013 if (
auto *
C = dyn_cast<ConstantFP>(V))
8014 return !
C->isZero();
8016 if (
auto *
C = dyn_cast<ConstantDataVector>(V)) {
8017 if (!
C->getElementType()->isFloatingPointTy())
8019 for (
unsigned I = 0, E =
C->getNumElements();
I < E; ++
I) {
8020 if (
C->getElementAsAPFloat(
I).isZero())
8043 if (CmpRHS == FalseVal) {
8091 if (CmpRHS != TrueVal) {
8130 Value *
A =
nullptr, *
B =
nullptr;
8135 Value *
C =
nullptr, *
D =
nullptr;
8137 if (L.Flavor != R.Flavor)
8189 return {L.Flavor,
SPNB_NA,
false};
8196 return {L.Flavor,
SPNB_NA,
false};
8203 return {L.Flavor,
SPNB_NA,
false};
8210 return {L.Flavor,
SPNB_NA,
false};
8226 return ConstantInt::get(V->getType(), ~(*
C));
8283 if ((CmpLHS == TrueVal &&
match(FalseVal,
m_APInt(C2))) ||
8303 assert(
X &&
Y &&
"Invalid operand");
8305 auto IsNegationOf = [&](
const Value *
X,
const Value *
Y) {
8309 auto *BO = cast<BinaryOperator>(
X);
8310 if (NeedNSW && !BO->hasNoSignedWrap())
8313 auto *Zero = cast<Constant>(BO->getOperand(0));
8314 if (!AllowPoison && !Zero->isNullValue())
8321 if (IsNegationOf(
X,
Y) || IsNegationOf(
Y,
X))
8344 const APInt *RHSC1, *RHSC2;
8351 return CR1.inverse() == CR2;
8360 bool HasMismatchedZeros =
false;
8366 Value *OutputZeroVal =
nullptr;
8368 !cast<Constant>(TrueVal)->containsUndefOrPoisonElement())
8369 OutputZeroVal = TrueVal;
8371 !cast<Constant>(FalseVal)->containsUndefOrPoisonElement())
8372 OutputZeroVal = FalseVal;
8374 if (OutputZeroVal) {
8376 HasMismatchedZeros =
true;
8377 CmpLHS = OutputZeroVal;
8380 HasMismatchedZeros =
true;
8381 CmpRHS = OutputZeroVal;
8398 if (!HasMismatchedZeros)
8409 bool Ordered =
false;
8420 if (LHSSafe && RHSSafe) {
8450 if (TrueVal == CmpRHS && FalseVal == CmpLHS) {
8461 if (TrueVal == CmpLHS && FalseVal == CmpRHS) {
8486 auto MaybeSExtCmpLHS =
8490 if (
match(TrueVal, MaybeSExtCmpLHS)) {
8512 else if (
match(FalseVal, MaybeSExtCmpLHS)) {
8562 auto *Cast1 = dyn_cast<CastInst>(V1);
8566 *CastOp = Cast1->getOpcode();
8567 Type *SrcTy = Cast1->getSrcTy();
8568 if (
auto *Cast2 = dyn_cast<CastInst>(V2)) {
8570 if (*CastOp == Cast2->getOpcode() && SrcTy == Cast2->getSrcTy())
8571 return Cast2->getOperand(0);
8575 auto *
C = dyn_cast<Constant>(V2);
8582 case Instruction::ZExt:
8586 case Instruction::SExt:
8590 case Instruction::Trunc:
8593 CmpConst->
getType() == SrcTy) {
8615 CastedTo = CmpConst;
8617 unsigned ExtOp = CmpI->
isSigned() ? Instruction::SExt : Instruction::ZExt;
8621 case Instruction::FPTrunc:
8624 case Instruction::FPExt:
8627 case Instruction::FPToUI:
8630 case Instruction::FPToSI:
8633 case Instruction::UIToFP:
8636 case Instruction::SIToFP:
8649 if (CastedBack && CastedBack !=
C)
8664 CmpInst *CmpI = dyn_cast<CmpInst>(SI->getCondition());
8667 Value *TrueVal = SI->getTrueValue();
8668 Value *FalseVal = SI->getFalseValue();
8681 if (isa<FPMathOperator>(CmpI))
8689 if (CastOp && CmpLHS->
getType() != TrueVal->getType()) {
8693 if (*CastOp == Instruction::FPToSI || *CastOp == Instruction::FPToUI)
8695 return ::matchSelectPattern(Pred, FMF, CmpLHS, CmpRHS,
8696 cast<CastInst>(TrueVal)->getOperand(0),
C,
8702 if (*CastOp == Instruction::FPToSI || *CastOp == Instruction::FPToUI)
8704 return ::matchSelectPattern(Pred, FMF, CmpLHS, CmpRHS,
8705 C, cast<CastInst>(FalseVal)->getOperand(0),
8709 return ::matchSelectPattern(Pred, FMF, CmpLHS, CmpRHS, TrueVal, FalseVal,
8735 case Intrinsic::smax:
return Intrinsic::smin;
8736 case Intrinsic::smin:
return Intrinsic::smax;
8737 case Intrinsic::umax:
return Intrinsic::umin;
8738 case Intrinsic::umin:
return Intrinsic::umax;
8741 case Intrinsic::maximum:
return Intrinsic::minimum;
8742 case Intrinsic::minimum:
return Intrinsic::maximum;
8743 case Intrinsic::maxnum:
return Intrinsic::minnum;
8744 case Intrinsic::minnum:
return Intrinsic::maxnum;
8759std::pair<Intrinsic::ID, bool>
8764 bool AllCmpSingleUse =
true;
8767 if (
all_of(VL, [&SelectPattern, &AllCmpSingleUse](
Value *
I) {
8773 SelectPattern.
Flavor != CurrentPattern.Flavor)
8775 SelectPattern = CurrentPattern;
8780 switch (SelectPattern.
Flavor) {
8782 return {Intrinsic::smin, AllCmpSingleUse};
8784 return {Intrinsic::umin, AllCmpSingleUse};
8786 return {Intrinsic::smax, AllCmpSingleUse};
8788 return {Intrinsic::umax, AllCmpSingleUse};
8790 return {Intrinsic::maxnum, AllCmpSingleUse};
8792 return {Intrinsic::minnum, AllCmpSingleUse};
8805 if (
P->getNumIncomingValues() != 2)
8808 for (
unsigned i = 0; i != 2; ++i) {
8809 Value *L =
P->getIncomingValue(i);
8810 Value *R =
P->getIncomingValue(!i);
8811 auto *LU = dyn_cast<BinaryOperator>(L);
8814 unsigned Opcode = LU->getOpcode();
8820 case Instruction::LShr:
8821 case Instruction::AShr:
8822 case Instruction::Shl:
8823 case Instruction::Add:
8824 case Instruction::Sub:
8825 case Instruction::And:
8826 case Instruction::Or:
8827 case Instruction::Mul:
8828 case Instruction::FMul: {
8829 Value *LL = LU->getOperand(0);
8830 Value *LR = LU->getOperand(1);
8860 P = dyn_cast<PHINode>(
I->getOperand(0));
8862 P = dyn_cast<PHINode>(
I->getOperand(1));
8883 return !
C->isNegative();
8895 const APInt *CLHS, *CRHS;
8898 return CLHS->
sle(*CRHS);
8936 const APInt *CLHS, *CRHS;
8939 return CLHS->
ule(*CRHS);
8948static std::optional<bool>
8953 return std::nullopt;
8960 return std::nullopt;
8967 return std::nullopt;
8974 return std::nullopt;
8981 return std::nullopt;
8988static std::optional<bool>
8996 return std::nullopt;
9007 if (DomCR.
icmp(RPred, RCR))
9013 return std::nullopt;
9030 LHSIsTrue ?
LHS->getPredicate() :
LHS->getInversePredicate();
9054 const APInt *Unused;
9073 return std::nullopt;
9077 if (L0 == R0 && L1 == R1)
9085 return LPred == RPred;
9090 return std::nullopt;
9097static std::optional<bool>
9102 assert((
LHS->getOpcode() == Instruction::And ||
9103 LHS->getOpcode() == Instruction::Or ||
9104 LHS->getOpcode() == Instruction::Select) &&
9105 "Expected LHS to be 'and', 'or', or 'select'.");
9112 const Value *ALHS, *ARHS;
9117 ALHS, RHSPred, RHSOp0, RHSOp1,
DL, LHSIsTrue,
Depth + 1))
9120 ARHS, RHSPred, RHSOp0, RHSOp1,
DL, LHSIsTrue,
Depth + 1))
9122 return std::nullopt;
9124 return std::nullopt;
9133 return std::nullopt;
9138 return std::nullopt;
9141 "Expected integer type only!");
9145 LHSIsTrue = !LHSIsTrue;
9156 if ((LHSI->getOpcode() == Instruction::And ||
9157 LHSI->getOpcode() == Instruction::Or ||
9158 LHSI->getOpcode() == Instruction::Select))
9162 return std::nullopt;
9167 bool LHSIsTrue,
unsigned Depth) {
9173 bool InvertRHS =
false;
9180 if (
const ICmpInst *RHSCmp = dyn_cast<ICmpInst>(
RHS)) {
9182 LHS, RHSCmp->getPredicate(), RHSCmp->getOperand(0),
9183 RHSCmp->getOperand(1),
DL, LHSIsTrue,
Depth))
9184 return InvertRHS ? !*Implied : *Implied;
9185 return std::nullopt;
9189 return std::nullopt;
9193 const Value *RHS1, *RHS2;
9195 if (std::optional<bool> Imp =
9199 if (std::optional<bool> Imp =
9205 if (std::optional<bool> Imp =
9209 if (std::optional<bool> Imp =
9215 return std::nullopt;
9220static std::pair<Value *, bool>
9222 if (!ContextI || !ContextI->
getParent())
9223 return {
nullptr,
false};
9230 return {
nullptr,
false};
9236 return {
nullptr,
false};
9239 if (TrueBB == FalseBB)
9240 return {
nullptr,
false};
9242 assert((TrueBB == ContextBB || FalseBB == ContextBB) &&
9243 "Predecessor block does not point to successor?");
9246 return {PredCond, TrueBB == ContextBB};
9252 assert(
Cond->getType()->isIntOrIntVectorTy(1) &&
"Condition must be bool");
9256 return std::nullopt;
9268 return std::nullopt;
9273 bool PreferSignedRange) {
9274 unsigned Width =
Lower.getBitWidth();
9277 case Instruction::Add:
9286 if (PreferSignedRange && HasNSW && HasNUW)
9292 }
else if (HasNSW) {
9293 if (
C->isNegative()) {
9306 case Instruction::And:
9317 case Instruction::Or:
9323 case Instruction::AShr:
9329 unsigned ShiftAmount = Width - 1;
9330 if (!
C->isZero() && IIQ.
isExact(&BO))
9331 ShiftAmount =
C->countr_zero();
9332 if (
C->isNegative()) {
9335 Upper =
C->ashr(ShiftAmount) + 1;
9338 Lower =
C->ashr(ShiftAmount);
9344 case Instruction::LShr:
9350 unsigned ShiftAmount = Width - 1;
9351 if (!
C->isZero() && IIQ.
isExact(&BO))
9352 ShiftAmount =
C->countr_zero();
9353 Lower =
C->lshr(ShiftAmount);
9358 case Instruction::Shl:
9365 if (
C->isNegative()) {
9367 unsigned ShiftAmount =
C->countl_one() - 1;
9368 Lower =
C->shl(ShiftAmount);
9372 unsigned ShiftAmount =
C->countl_zero() - 1;
9374 Upper =
C->shl(ShiftAmount) + 1;
9393 case Instruction::SDiv:
9397 if (
C->isAllOnes()) {
9402 }
else if (
C->countl_zero() < Width - 1) {
9413 if (
C->isMinSignedValue()) {
9425 case Instruction::UDiv:
9435 case Instruction::SRem:
9441 if (
C->isNegative()) {
9452 case Instruction::URem:
9467 unsigned Width =
II.getType()->getScalarSizeInBits();
9469 switch (
II.getIntrinsicID()) {
9470 case Intrinsic::ctpop:
9471 case Intrinsic::ctlz:
9472 case Intrinsic::cttz:
9475 APInt(Width, Width + 1));
9476 case Intrinsic::uadd_sat:
9482 case Intrinsic::sadd_sat:
9485 if (
C->isNegative())
9496 case Intrinsic::usub_sat:
9506 case Intrinsic::ssub_sat:
9508 if (
C->isNegative())
9518 if (
C->isNegative())
9529 case Intrinsic::umin:
9530 case Intrinsic::umax:
9531 case Intrinsic::smin:
9532 case Intrinsic::smax:
9537 switch (
II.getIntrinsicID()) {
9538 case Intrinsic::umin:
9540 case Intrinsic::umax:
9542 case Intrinsic::smin:
9545 case Intrinsic::smax:
9552 case Intrinsic::abs:
9561 case Intrinsic::vscale:
9562 if (!
II.getParent() || !
II.getFunction())
9565 case Intrinsic::scmp:
9566 case Intrinsic::ucmp:
9573 return ConstantRange::getFull(Width);
9578 unsigned BitWidth = SI.getType()->getScalarSizeInBits();
9582 return ConstantRange::getFull(
BitWidth);
9605 return ConstantRange::getFull(
BitWidth);
9619 return ConstantRange::getFull(
BitWidth);
9626 unsigned BitWidth =
I->getType()->getScalarSizeInBits();
9627 if (!
I->getOperand(0)->getType()->getScalarType()->isHalfTy())
9629 if (isa<FPToSIInst>(
I) &&
BitWidth >= 17) {
9634 if (isa<FPToUIInst>(
I) &&
BitWidth >= 16) {
9645 assert(V->getType()->isIntOrIntVectorTy() &&
"Expected integer instruction");
9648 return ConstantRange::getFull(V->getType()->getScalarSizeInBits());
9650 if (
auto *
C = dyn_cast<Constant>(V))
9651 return C->toConstantRange();
9653 unsigned BitWidth = V->getType()->getScalarSizeInBits();
9656 if (
auto *BO = dyn_cast<BinaryOperator>(V)) {
9662 }
else if (
auto *
II = dyn_cast<IntrinsicInst>(V))
9664 else if (
auto *SI = dyn_cast<SelectInst>(V)) {
9666 SI->getTrueValue(), ForSigned, UseInstrInfo, AC, CtxI, DT,
Depth + 1);
9668 SI->getFalseValue(), ForSigned, UseInstrInfo, AC, CtxI, DT,
Depth + 1);
9671 }
else if (isa<FPToUIInst>(V) || isa<FPToSIInst>(V)) {
9677 }
else if (
const auto *
A = dyn_cast<Argument>(V))
9678 if (std::optional<ConstantRange>
Range =
A->getRange())
9681 if (
auto *
I = dyn_cast<Instruction>(V)) {
9685 if (
const auto *CB = dyn_cast<CallBase>(V))
9686 if (std::optional<ConstantRange>
Range = CB->getRange())
9697 "Got assumption for the wrong function!");
9698 assert(
I->getIntrinsicID() == Intrinsic::assume &&
9699 "must be an assume intrinsic");
9703 Value *Arg =
I->getArgOperand(0);
9704 ICmpInst *Cmp = dyn_cast<ICmpInst>(Arg);
9706 if (!Cmp || Cmp->getOperand(0) != V)
9711 UseInstrInfo, AC,
I, DT,
Depth + 1);
9724 if (isa<Argument>(V) || isa<GlobalValue>(V)) {
9726 }
else if (
auto *
I = dyn_cast<Instruction>(V)) {
9732 if (isa<Instruction>(
Op) || isa<Argument>(
Op))
9740 auto AddAffected = [&InsertAffected](
Value *V) {
9755 while (!Worklist.
empty()) {
9757 if (!Visited.
insert(V).second)
9780 AddCmpOperands(
A,
B);
9830 AddCmpOperands(
A,
B);
9840 }
else if (
match(V, m_Intrinsic<Intrinsic::is_fpclass>(
m_Value(
A),
amdgpu 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)
static const unsigned MaxDepth
static bool hasNoUnsignedWrap(BinaryOperator &I)
mir Rename Register Operands
Module.h This file contains the declarations for the Module class.
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 std::optional< bool > isImpliedCondAndOr(const Instruction *LHS, CmpInst::Predicate RHSPred, const Value *RHSOp0, const Value *RHSOp1, const DataLayout &DL, bool LHSIsTrue, unsigned Depth)
Return true if LHS implies RHS is true.
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 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 computeKnownFPClassFromCond(const Value *V, Value *Cond, bool CondIsTrue, const Instruction *CxtI, KnownFPClass &KnownFromContext)
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 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 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 isKnownToBeAPowerOfTwo(const Value *V, bool OrZero, unsigned Depth, const SimplifyQuery &Q)
Return true if the given value is known to have exactly one bit set when defined.
static bool isKnownNonNaN(const Value *V, FastMathFlags FMF)
static void computeKnownBitsMul(const Value *Op0, const Value *Op1, bool NSW, const APInt &DemandedElts, KnownBits &Known, KnownBits &Known2, unsigned Depth, const SimplifyQuery &Q)
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.
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 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 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 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)
MaxMin_match< FCmpInst, LHS, RHS, ufmin_pred_ty > m_UnordFMin(const LHS &L, const RHS &R)
Match an 'unordered' floating point minimum function.
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)
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.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap, true > m_c_NUWAdd(const LHS &L, const RHS &R)
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.
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)
CmpClass_match< LHS, RHS, FCmpInst, FCmpInst::Predicate > m_FCmp(FCmpInst::Predicate &Pred, 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.
CmpClass_match< LHS, RHS, ICmpInst, ICmpInst::Predicate > m_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R)
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.
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)
CmpClass_match< LHS, RHS, ICmpInst, ICmpInst::Predicate, true > m_c_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R)
Matches an ICmp with a predicate over LHS and RHS in either order.
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".
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.
MaxMin_match< FCmpInst, LHS, RHS, ufmax_pred_ty > m_UnordFMax(const LHS &L, const RHS &R)
Match an 'unordered' floating point maximum function.
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.
MaxMin_match< FCmpInst, LHS, RHS, ofmax_pred_ty > m_OrdFMax(const LHS &L, const RHS &R)
Match an 'ordered' floating point maximum function.
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)
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.
MaxMin_match< FCmpInst, LHS, RHS, ofmin_pred_ty > m_OrdFMin(const LHS &L, const RHS &R)
Match an 'ordered' floating point minimum function.
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)
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 MaskedValueIsZero(const Value *V, const APInt &Mask, const SimplifyQuery &DL, unsigned Depth=0)
Return true if 'V & Mask' is known to be zero.
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.
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...
bool isSafeToSpeculativelyExecuteWithOpcode(unsigned Opcode, const Instruction *Inst, const Instruction *CtxI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr)
This returns the same result as isSafeToSpeculativelyExecute if Opcode is the actual opcode of Inst.
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 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
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.
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...
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 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.
void getUnderlyingObjects(const Value *V, SmallVectorImpl< const Value * > &Objects, LoopInfo *LI=nullptr, unsigned MaxLookup=6)
This method is similar to getUnderlyingObject except that it can look through phi and select instruct...
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 isKnownNegative(const Value *V, const SimplifyQuery &DL, unsigned Depth=0)
Returns true if the given value is known be negative (i.e.
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.
bool isSafeToSpeculativelyExecute(const Instruction *I, const Instruction *CtxI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr)
Return true if the instruction does not have any effects besides calculating the result and does not ...
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...
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 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)
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.
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.
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 > 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 getWithInstruction(const Instruction *I) const
const DomConditionCache * DC