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();
313 return ::isKnownNonEqual(
322 return Mask.isSubsetOf(Known.
Zero);
330 auto *FVTy = dyn_cast<FixedVectorType>(V->getType());
340 return ::ComputeNumSignBits(
349 return V->getType()->getScalarSizeInBits() - SignBits + 1;
354 const APInt &DemandedElts,
361 if (KnownOut.
isUnknown() && !NSW && !NUW)
386 bool isKnownNegativeOp0 = Known2.
isNegative();
389 (isKnownNonNegativeOp1 && isKnownNonNegativeOp0);
394 (isKnownNegativeOp1 && isKnownNonNegativeOp0 &&
396 (isKnownNegativeOp0 && isKnownNonNegativeOp1 && Known.
isNonZero());
400 bool SelfMultiply = Op0 == Op1;
420 unsigned NumRanges = Ranges.getNumOperands() / 2;
426 for (
unsigned i = 0; i < NumRanges; ++i) {
428 mdconst::extract<ConstantInt>(Ranges.getOperand(2 * i + 0));
430 mdconst::extract<ConstantInt>(Ranges.getOperand(2 * i + 1));
434 unsigned CommonPrefixBits =
435 (Range.getUnsignedMax() ^ Range.getUnsignedMin()).
countl_zero();
437 APInt UnsignedMax = Range.getUnsignedMax().zextOrTrunc(
BitWidth);
438 Known.
One &= UnsignedMax & Mask;
439 Known.
Zero &= ~UnsignedMax & Mask;
454 while (!WorkSet.
empty()) {
456 if (!Visited.
insert(V).second)
461 return EphValues.count(U);
466 if (V ==
I || (isa<Instruction>(V) &&
468 !cast<Instruction>(V)->isTerminator())) {
470 if (
const User *U = dyn_cast<User>(V))
482 return CI->isAssumeLikeIntrinsic();
490 bool AllowEphemerals) {
508 if (!AllowEphemerals && Inv == CxtI)
543 if (Pred == ICmpInst::ICMP_UGT)
547 if (Pred == ICmpInst::ICMP_NE)
558 auto *VC = dyn_cast<ConstantDataVector>(
RHS);
562 for (
unsigned ElemIdx = 0, NElem = VC->getNumElements(); ElemIdx < NElem;
565 Pred, VC->getElementAsAPInt(ElemIdx));
584 "Got assumption for the wrong function!");
587 if (!V->getType()->isPointerTy())
590 *
I,
I->bundle_op_info_begin()[Elem.Index])) {
592 (RK.AttrKind == Attribute::NonNull ||
593 (RK.AttrKind == Attribute::Dereferenceable &&
595 V->getType()->getPointerAddressSpace()))) &&
627 case ICmpInst::ICMP_EQ:
630 case ICmpInst::ICMP_SGE:
631 case ICmpInst::ICMP_SGT:
634 case ICmpInst::ICMP_SLT:
652 case ICmpInst::ICMP_EQ:
662 Known.
Zero |= ~*
C & *Mask;
668 Known.
One |= *
C & ~*Mask;
689 Known.
Zero |= RHSKnown.
Zero << ShAmt;
690 Known.
One |= RHSKnown.
One << ShAmt;
693 case ICmpInst::ICMP_NE: {
710 if ((Pred == ICmpInst::ICMP_UGT || Pred == ICmpInst::ICMP_UGE) &&
713 (*
C + (Pred == ICmpInst::ICMP_UGT)).countLeadingOnes());
716 if ((Pred == ICmpInst::ICMP_ULT || Pred == ICmpInst::ICMP_ULE) &&
719 (*
C - (Pred == ICmpInst::ICMP_ULT)).countLeadingZeros());
730 Invert ? Cmp->getInversePredicate() : Cmp->getPredicate();
763 if (
auto *Cmp = dyn_cast<ICmpInst>(
Cond))
804 "Got assumption for the wrong function!");
807 if (!V->getType()->isPointerTy())
810 *
I,
I->bundle_op_info_begin()[Elem.Index])) {
811 if (RK.WasOn == V && RK.AttrKind == Attribute::Alignment &&
823 Value *Arg =
I->getArgOperand(0);
843 ICmpInst *Cmp = dyn_cast<ICmpInst>(Arg);
879 Known = KF(Known2, Known, ShAmtNonZero);
890 Value *
X =
nullptr, *
Y =
nullptr;
892 switch (
I->getOpcode()) {
893 case Instruction::And:
894 KnownOut = KnownLHS & KnownRHS;
904 KnownOut = KnownLHS.
blsi();
906 KnownOut = KnownRHS.
blsi();
909 case Instruction::Or:
910 KnownOut = KnownLHS | KnownRHS;
912 case Instruction::Xor:
913 KnownOut = KnownLHS ^ KnownRHS;
923 const KnownBits &XBits =
I->getOperand(0) ==
X ? KnownLHS : KnownRHS;
924 KnownOut = XBits.
blsmsk();
937 if (!KnownOut.
Zero[0] && !KnownOut.
One[0] &&
959 auto *FVTy = dyn_cast<FixedVectorType>(
I->getType());
968 Attribute Attr =
F->getFnAttribute(Attribute::VScaleRange);
976 return ConstantRange::getEmpty(
BitWidth);
987 const APInt &DemandedElts,
993 switch (
I->getOpcode()) {
995 case Instruction::Load:
1000 case Instruction::And:
1006 case Instruction::Or:
1012 case Instruction::Xor:
1018 case Instruction::Mul: {
1021 Known, Known2,
Depth, Q);
1024 case Instruction::UDiv: {
1031 case Instruction::SDiv: {
1038 case Instruction::Select: {
1039 auto ComputeForArm = [&](
Value *Arm,
bool Invert) {
1075 ComputeForArm(
I->getOperand(1),
false)
1079 case Instruction::FPTrunc:
1080 case Instruction::FPExt:
1081 case Instruction::FPToUI:
1082 case Instruction::FPToSI:
1083 case Instruction::SIToFP:
1084 case Instruction::UIToFP:
1086 case Instruction::PtrToInt:
1087 case Instruction::IntToPtr:
1090 case Instruction::ZExt:
1091 case Instruction::Trunc: {
1092 Type *SrcTy =
I->getOperand(0)->getType();
1094 unsigned SrcBitWidth;
1102 assert(SrcBitWidth &&
"SrcBitWidth can't be zero");
1105 if (
auto *Inst = dyn_cast<PossiblyNonNegInst>(
I);
1106 Inst && Inst->hasNonNeg() && !Known.
isNegative())
1111 case Instruction::BitCast: {
1112 Type *SrcTy =
I->getOperand(0)->getType();
1116 !
I->getType()->isVectorTy()) {
1124 V->getType()->isFPOrFPVectorTy()) {
1125 Type *FPType = V->getType()->getScalarType();
1133 if (FPClasses &
fcInf)
1145 if (Result.SignBit) {
1146 if (*Result.SignBit)
1157 auto *SrcVecTy = dyn_cast<FixedVectorType>(SrcTy);
1158 if (!SrcVecTy || !SrcVecTy->getElementType()->isIntegerTy() ||
1159 !
I->getType()->isIntOrIntVectorTy() ||
1160 isa<ScalableVectorType>(
I->getType()))
1165 unsigned SubBitWidth = SrcVecTy->getScalarSizeInBits();
1182 unsigned SubScale =
BitWidth / SubBitWidth;
1184 for (
unsigned i = 0; i != NumElts; ++i) {
1185 if (DemandedElts[i])
1186 SubDemandedElts.
setBit(i * SubScale);
1190 for (
unsigned i = 0; i != SubScale; ++i) {
1194 Known.
insertBits(KnownSrc, ShiftElt * SubBitWidth);
1199 case Instruction::SExt: {
1201 unsigned SrcBitWidth =
I->getOperand(0)->getType()->getScalarSizeInBits();
1203 Known = Known.
trunc(SrcBitWidth);
1210 case Instruction::Shl: {
1214 bool ShAmtNonZero) {
1215 return KnownBits::shl(KnownVal, KnownAmt, NUW, NSW, ShAmtNonZero);
1225 case Instruction::LShr: {
1226 bool Exact = Q.
IIQ.
isExact(cast<BinaryOperator>(
I));
1228 bool ShAmtNonZero) {
1239 case Instruction::AShr: {
1240 bool Exact = Q.
IIQ.
isExact(cast<BinaryOperator>(
I));
1242 bool ShAmtNonZero) {
1249 case Instruction::Sub: {
1253 DemandedElts, Known, Known2,
Depth, Q);
1256 case Instruction::Add: {
1260 DemandedElts, Known, Known2,
Depth, Q);
1263 case Instruction::SRem:
1269 case Instruction::URem:
1274 case Instruction::Alloca:
1277 case Instruction::GetElementPtr: {
1286 for (
unsigned i = 1, e =
I->getNumOperands(); i != e; ++i, ++GTI) {
1302 "Access to structure field must be known at compile time");
1307 unsigned Idx = cast<ConstantInt>(
Index)->getZExtValue();
1310 AccConstIndices +=
Offset;
1321 unsigned IndexBitWidth =
Index->getType()->getScalarSizeInBits();
1335 APInt ScalingFactor(IndexBitWidth, TypeSizeInBytes);
1336 IndexConst *= ScalingFactor;
1353 true,
false,
false, Known, IndexBits);
1358 true,
false,
false, Known,
Index);
1362 case Instruction::PHI: {
1365 Value *R =
nullptr, *L =
nullptr;
1375 if ((Opcode == Instruction::LShr || Opcode == Instruction::AShr ||
1376 Opcode == Instruction::Shl) &&
1391 case Instruction::Shl:
1395 case Instruction::LShr:
1400 case Instruction::AShr:
1411 if (Opcode == Instruction::Add ||
1412 Opcode == Instruction::Sub ||
1413 Opcode == Instruction::And ||
1414 Opcode == Instruction::Or ||
1415 Opcode == Instruction::Mul) {
1422 unsigned OpNum =
P->getOperand(0) == R ? 0 : 1;
1423 Instruction *RInst =
P->getIncomingBlock(OpNum)->getTerminator();
1424 Instruction *LInst =
P->getIncomingBlock(1-OpNum)->getTerminator();
1439 auto *OverflowOp = dyn_cast<OverflowingBinaryOperator>(BO);
1450 if (Opcode == Instruction::Add) {
1459 else if (Opcode == Instruction::Sub && BO->
getOperand(0) ==
I) {
1467 else if (Opcode == Instruction::Mul && Known2.
isNonNegative() &&
1477 if (
P->getNumIncomingValues() == 0)
1484 if (isa_and_nonnull<UndefValue>(
P->hasConstantValue()))
1489 for (
unsigned u = 0, e =
P->getNumIncomingValues(); u < e; ++u) {
1490 Value *IncValue =
P->getIncomingValue(u);
1492 if (IncValue ==
P)
continue;
1499 RecQ.
CxtI =
P->getIncomingBlock(u)->getTerminator();
1520 if ((TrueSucc ==
P->getParent()) != (FalseSucc ==
P->getParent())) {
1522 if (FalseSucc ==
P->getParent())
1536 Known2 = KnownUnion;
1550 case Instruction::Call:
1551 case Instruction::Invoke: {
1559 const auto *CB = cast<CallBase>(
I);
1561 if (std::optional<ConstantRange> Range = CB->getRange())
1562 Known = Known.
unionWith(Range->toKnownBits());
1564 if (
const Value *RV = CB->getReturnedArgOperand()) {
1565 if (RV->getType() ==
I->getType()) {
1577 switch (II->getIntrinsicID()) {
1579 case Intrinsic::abs: {
1581 bool IntMinIsPoison =
match(II->getArgOperand(1),
m_One());
1582 Known = Known2.
abs(IntMinIsPoison);
1585 case Intrinsic::bitreverse:
1590 case Intrinsic::bswap:
1595 case Intrinsic::ctlz: {
1601 PossibleLZ = std::min(PossibleLZ,
BitWidth - 1);
1606 case Intrinsic::cttz: {
1612 PossibleTZ = std::min(PossibleTZ,
BitWidth - 1);
1617 case Intrinsic::ctpop: {
1628 case Intrinsic::fshr:
1629 case Intrinsic::fshl: {
1636 if (II->getIntrinsicID() == Intrinsic::fshr)
1649 case Intrinsic::uadd_sat:
1654 case Intrinsic::usub_sat:
1659 case Intrinsic::sadd_sat:
1664 case Intrinsic::ssub_sat:
1671 case Intrinsic::vector_reduce_and:
1672 case Intrinsic::vector_reduce_or:
1673 case Intrinsic::vector_reduce_umax:
1674 case Intrinsic::vector_reduce_umin:
1675 case Intrinsic::vector_reduce_smax:
1676 case Intrinsic::vector_reduce_smin:
1679 case Intrinsic::vector_reduce_xor: {
1684 auto *VecTy = cast<VectorType>(
I->getOperand(0)->getType());
1686 bool EvenCnt = VecTy->getElementCount().isKnownEven();
1690 if (VecTy->isScalableTy() || EvenCnt)
1694 case Intrinsic::umin:
1699 case Intrinsic::umax:
1704 case Intrinsic::smin:
1709 case Intrinsic::smax:
1714 case Intrinsic::ptrmask: {
1717 const Value *Mask =
I->getOperand(1);
1718 Known2 =
KnownBits(Mask->getType()->getScalarSizeInBits());
1724 case Intrinsic::x86_sse42_crc32_64_64:
1727 case Intrinsic::riscv_vsetvli:
1728 case Intrinsic::riscv_vsetvlimax: {
1729 bool HasAVL = II->getIntrinsicID() == Intrinsic::riscv_vsetvli;
1732 cast<ConstantInt>(II->getArgOperand(HasAVL))->getZExtValue());
1734 cast<ConstantInt>(II->getArgOperand(1 + HasAVL))->getZExtValue());
1743 if (
auto *CI = dyn_cast<ConstantInt>(II->getArgOperand(0)))
1744 MaxVL = std::min(MaxVL, CI->getZExtValue());
1746 unsigned KnownZeroFirstBit =
Log2_32(MaxVL) + 1;
1751 case Intrinsic::vscale: {
1752 if (!II->getParent() || !II->getFunction())
1762 case Instruction::ShuffleVector: {
1763 auto *Shuf = dyn_cast<ShuffleVectorInst>(
I);
1771 APInt DemandedLHS, DemandedRHS;
1778 if (!!DemandedLHS) {
1779 const Value *
LHS = Shuf->getOperand(0);
1785 if (!!DemandedRHS) {
1786 const Value *
RHS = Shuf->getOperand(1);
1792 case Instruction::InsertElement: {
1793 if (isa<ScalableVectorType>(
I->getType())) {
1797 const Value *Vec =
I->getOperand(0);
1798 const Value *Elt =
I->getOperand(1);
1799 auto *CIdx = dyn_cast<ConstantInt>(
I->getOperand(2));
1801 APInt DemandedVecElts = DemandedElts;
1802 bool NeedsElt =
true;
1804 if (CIdx && CIdx->getValue().ult(NumElts)) {
1805 DemandedVecElts.
clearBit(CIdx->getZExtValue());
1806 NeedsElt = DemandedElts[CIdx->getZExtValue()];
1818 if (!DemandedVecElts.
isZero()) {
1824 case Instruction::ExtractElement: {
1827 const Value *Vec =
I->getOperand(0);
1829 auto *CIdx = dyn_cast<ConstantInt>(
Idx);
1830 if (isa<ScalableVectorType>(Vec->
getType())) {
1835 unsigned NumElts = cast<FixedVectorType>(Vec->
getType())->getNumElements();
1837 if (CIdx && CIdx->getValue().ult(NumElts))
1842 case Instruction::ExtractValue:
1843 if (
IntrinsicInst *II = dyn_cast<IntrinsicInst>(
I->getOperand(0))) {
1847 switch (II->getIntrinsicID()) {
1849 case Intrinsic::uadd_with_overflow:
1850 case Intrinsic::sadd_with_overflow:
1852 true, II->getArgOperand(0), II->getArgOperand(1),
false,
1853 false, DemandedElts, Known, Known2,
Depth, Q);
1855 case Intrinsic::usub_with_overflow:
1856 case Intrinsic::ssub_with_overflow:
1858 false, II->getArgOperand(0), II->getArgOperand(1),
false,
1859 false, DemandedElts, Known, Known2,
Depth, Q);
1861 case Intrinsic::umul_with_overflow:
1862 case Intrinsic::smul_with_overflow:
1864 DemandedElts, Known, Known2,
Depth, Q);
1870 case Instruction::Freeze:
1914 if (!DemandedElts) {
1920 assert(V &&
"No Value?");
1924 Type *Ty = V->getType();
1928 "Not integer or pointer type!");
1930 if (
auto *FVTy = dyn_cast<FixedVectorType>(Ty)) {
1932 FVTy->getNumElements() == DemandedElts.
getBitWidth() &&
1933 "DemandedElt width should equal the fixed vector number of elements");
1936 "DemandedElt width should be 1 for scalars or scalable vectors");
1942 "V and Known should have same BitWidth");
1945 "V and Known should have same BitWidth");
1956 if (isa<ConstantPointerNull>(V) || isa<ConstantAggregateZero>(V)) {
1963 assert(!isa<ScalableVectorType>(V->getType()));
1967 for (
unsigned i = 0, e = CDV->getNumElements(); i != e; ++i) {
1968 if (!DemandedElts[i])
1970 APInt Elt = CDV->getElementAsAPInt(i);
1979 if (
const auto *CV = dyn_cast<ConstantVector>(V)) {
1980 assert(!isa<ScalableVectorType>(V->getType()));
1984 for (
unsigned i = 0, e = CV->getNumOperands(); i != e; ++i) {
1985 if (!DemandedElts[i])
1988 if (isa<PoisonValue>(Element))
1990 auto *ElementCI = dyn_cast_or_null<ConstantInt>(Element);
1995 const APInt &Elt = ElementCI->getValue();
2008 if (isa<UndefValue>(V))
2013 assert(!isa<ConstantData>(V) &&
"Unhandled constant data!");
2015 if (
const auto *
A = dyn_cast<Argument>(V))
2016 if (std::optional<ConstantRange> Range =
A->getRange())
2017 Known = Range->toKnownBits();
2025 if (
const GlobalAlias *GA = dyn_cast<GlobalAlias>(V)) {
2026 if (!GA->isInterposable())
2031 if (
const Operator *
I = dyn_cast<Operator>(V))
2033 else if (
const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
2034 if (std::optional<ConstantRange> CR = GV->getAbsoluteSymbolRange())
2035 Known = CR->toKnownBits();
2039 if (isa<PointerType>(V->getType())) {
2040 Align Alignment = V->getPointerAlignment(Q.
DL);
2050 assert((Known.
Zero & Known.
One) == 0 &&
"Bits known to be one AND zero?");
2058 Value *Start =
nullptr, *Step =
nullptr;
2064 if (U.get() == Start) {
2080 case Instruction::Mul:
2085 case Instruction::SDiv:
2091 case Instruction::UDiv:
2097 case Instruction::Shl:
2099 case Instruction::AShr:
2103 case Instruction::LShr:
2118 if (isa<Constant>(V))
2122 if (OrZero && V->getType()->getScalarSizeInBits() == 1)
2125 auto *
I = dyn_cast<Instruction>(V);
2132 return F->hasFnAttribute(Attribute::VScaleRange);
2149 switch (
I->getOpcode()) {
2150 case Instruction::ZExt:
2152 case Instruction::Trunc:
2154 case Instruction::Shl:
2158 case Instruction::LShr:
2159 if (OrZero || Q.
IIQ.
isExact(cast<BinaryOperator>(
I)))
2162 case Instruction::UDiv:
2166 case Instruction::Mul:
2170 case Instruction::And:
2181 case Instruction::Add: {
2187 if (
match(
I->getOperand(0),
2191 if (
match(
I->getOperand(1),
2196 unsigned BitWidth = V->getType()->getScalarSizeInBits();
2205 if ((~(LHSBits.
Zero & RHSBits.
Zero)).isPowerOf2())
2218 case Instruction::Select:
2221 case Instruction::PHI: {
2225 auto *PN = cast<PHINode>(
I);
2242 RecQ.CxtI = PN->getIncomingBlock(U)->getTerminator();
2243 return isKnownToBeAPowerOfTwo(U.get(), OrZero, NewDepth, RecQ);
2246 case Instruction::Invoke:
2247 case Instruction::Call: {
2248 if (
auto *II = dyn_cast<IntrinsicInst>(
I)) {
2249 switch (II->getIntrinsicID()) {
2250 case Intrinsic::umax:
2251 case Intrinsic::smax:
2252 case Intrinsic::umin:
2253 case Intrinsic::smin:
2258 case Intrinsic::bitreverse:
2259 case Intrinsic::bswap:
2261 case Intrinsic::fshr:
2262 case Intrinsic::fshl:
2264 if (II->getArgOperand(0) == II->getArgOperand(1))
2288 F =
I->getFunction();
2290 if (!
GEP->isInBounds() ||
2295 assert(
GEP->getType()->isPointerTy() &&
"We only support plain pointer GEP");
2306 GTI != GTE; ++GTI) {
2308 if (
StructType *STy = GTI.getStructTypeOrNull()) {
2309 ConstantInt *OpC = cast<ConstantInt>(GTI.getOperand());
2313 if (ElementOffset > 0)
2319 if (GTI.getSequentialElementStride(Q.
DL).isZero())
2324 if (
ConstantInt *OpC = dyn_cast<ConstantInt>(GTI.getOperand())) {
2348 assert(!isa<Constant>(V) &&
"Called for constant?");
2353 unsigned NumUsesExplored = 0;
2354 for (
const auto *U : V->users()) {
2362 if (
const auto *CB = dyn_cast<CallBase>(U))
2363 if (
auto *CalledFunc = CB->getCalledFunction())
2364 for (
const Argument &Arg : CalledFunc->args())
2365 if (CB->getArgOperand(Arg.getArgNo()) == V &&
2366 Arg.hasNonNullAttr(
false) &&
2374 V->getType()->getPointerAddressSpace()) &&
2392 NonNullIfTrue =
true;
2394 NonNullIfTrue =
false;
2400 for (
const auto *CmpU : U->users()) {
2402 if (Visited.
insert(CmpU).second)
2405 while (!WorkList.
empty()) {
2414 for (
const auto *CurrU : Curr->users())
2415 if (Visited.
insert(CurrU).second)
2420 if (
const BranchInst *BI = dyn_cast<BranchInst>(Curr)) {
2421 assert(BI->isConditional() &&
"uses a comparison!");
2424 BI->getSuccessor(NonNullIfTrue ? 0 : 1);
2428 }
else if (NonNullIfTrue &&
isGuard(Curr) &&
2429 DT->
dominates(cast<Instruction>(Curr), CtxI)) {
2443 const unsigned NumRanges = Ranges->getNumOperands() / 2;
2445 for (
unsigned i = 0; i < NumRanges; ++i) {
2447 mdconst::extract<ConstantInt>(Ranges->getOperand(2 * i + 0));
2449 mdconst::extract<ConstantInt>(Ranges->getOperand(2 * i + 1));
2451 if (Range.contains(
Value))
2461 Value *Start =
nullptr, *Step =
nullptr;
2462 const APInt *StartC, *StepC;
2468 case Instruction::Add:
2474 case Instruction::Mul:
2477 case Instruction::Shl:
2479 case Instruction::AShr:
2480 case Instruction::LShr:
2489 Value *
Y,
bool NSW,
bool NUW) {
2534 if (
auto *
C = dyn_cast<Constant>(
X))
2538 return ::isKnownNonEqual(
X,
Y,
Depth, Q);
2543 Value *
Y,
bool NSW,
bool NUW) {
2572 auto ShiftOp = [&](
const APInt &Lhs,
const APInt &Rhs) {
2573 switch (
I->getOpcode()) {
2574 case Instruction::Shl:
2575 return Lhs.
shl(Rhs);
2576 case Instruction::LShr:
2577 return Lhs.
lshr(Rhs);
2578 case Instruction::AShr:
2579 return Lhs.
ashr(Rhs);
2585 auto InvShiftOp = [&](
const APInt &Lhs,
const APInt &Rhs) {
2586 switch (
I->getOpcode()) {
2587 case Instruction::Shl:
2588 return Lhs.
lshr(Rhs);
2589 case Instruction::LShr:
2590 case Instruction::AShr:
2591 return Lhs.
shl(Rhs);
2604 if (MaxShift.
uge(NumBits))
2607 if (!ShiftOp(KnownVal.
One, MaxShift).isZero())
2612 if (InvShiftOp(KnownVal.
Zero, NumBits - MaxShift)
2621 const APInt &DemandedElts,
2624 switch (
I->getOpcode()) {
2625 case Instruction::Alloca:
2627 return I->getType()->getPointerAddressSpace() == 0;
2628 case Instruction::GetElementPtr:
2629 if (
I->getType()->isPointerTy())
2632 case Instruction::BitCast: {
2660 Type *FromTy =
I->getOperand(0)->getType();
2665 case Instruction::IntToPtr:
2669 if (!isa<ScalableVectorType>(
I->getType()) &&
2674 case Instruction::PtrToInt:
2677 if (!isa<ScalableVectorType>(
I->getType()) &&
2682 case Instruction::Trunc:
2684 if (
auto *TI = dyn_cast<TruncInst>(
I))
2685 if (TI->hasNoSignedWrap() || TI->hasNoUnsignedWrap())
2689 case Instruction::Sub:
2692 case Instruction::Or:
2696 case Instruction::SExt:
2697 case Instruction::ZExt:
2701 case Instruction::Shl: {
2716 case Instruction::LShr:
2717 case Instruction::AShr: {
2732 case Instruction::UDiv:
2733 case Instruction::SDiv: {
2736 if (cast<PossiblyExactOperator>(
I)->isExact())
2748 if (
I->getOpcode() == Instruction::SDiv) {
2750 XKnown = XKnown.
abs(
false);
2751 YKnown = YKnown.
abs(
false);
2757 return XUgeY && *XUgeY;
2759 case Instruction::Add: {
2764 auto *BO = cast<OverflowingBinaryOperator>(
I);
2769 case Instruction::Mul: {
2775 case Instruction::Select: {
2782 auto SelectArmIsNonZero = [&](
bool IsTrueArm) {
2784 Op = IsTrueArm ?
I->getOperand(1) :
I->getOperand(2);
2797 Pred = ICmpInst::getInversePredicate(Pred);
2802 if (SelectArmIsNonZero(
true) &&
2803 SelectArmIsNonZero(
false))
2807 case Instruction::PHI: {
2808 auto *PN = cast<PHINode>(
I);
2818 RecQ.CxtI = PN->getIncomingBlock(U)->getTerminator();
2820 ICmpInst::Predicate Pred;
2822 BasicBlock *TrueSucc, *FalseSucc;
2823 if (match(RecQ.CxtI,
2824 m_Br(m_c_ICmp(Pred, m_Specific(U.get()), m_Value(X)),
2825 m_BasicBlock(TrueSucc), m_BasicBlock(FalseSucc)))) {
2827 if ((TrueSucc == PN->getParent()) != (FalseSucc == PN->getParent())) {
2829 if (FalseSucc == PN->getParent())
2830 Pred = CmpInst::getInversePredicate(Pred);
2831 if (cmpExcludesZero(Pred, X))
2839 case Instruction::InsertElement: {
2840 if (isa<ScalableVectorType>(
I->getType()))
2843 const Value *Vec =
I->getOperand(0);
2844 const Value *Elt =
I->getOperand(1);
2845 auto *CIdx = dyn_cast<ConstantInt>(
I->getOperand(2));
2848 APInt DemandedVecElts = DemandedElts;
2849 bool SkipElt =
false;
2851 if (CIdx && CIdx->getValue().ult(NumElts)) {
2852 DemandedVecElts.
clearBit(CIdx->getZExtValue());
2853 SkipElt = !DemandedElts[CIdx->getZExtValue()];
2859 (DemandedVecElts.
isZero() ||
2862 case Instruction::ExtractElement:
2863 if (
const auto *EEI = dyn_cast<ExtractElementInst>(
I)) {
2864 const Value *Vec = EEI->getVectorOperand();
2865 const Value *
Idx = EEI->getIndexOperand();
2866 auto *CIdx = dyn_cast<ConstantInt>(
Idx);
2867 if (
auto *VecTy = dyn_cast<FixedVectorType>(Vec->
getType())) {
2868 unsigned NumElts = VecTy->getNumElements();
2870 if (CIdx && CIdx->getValue().ult(NumElts))
2876 case Instruction::ShuffleVector: {
2877 auto *Shuf = dyn_cast<ShuffleVectorInst>(
I);
2880 APInt DemandedLHS, DemandedRHS;
2886 return (DemandedRHS.
isZero() ||
2891 case Instruction::Freeze:
2895 case Instruction::Load: {
2896 auto *LI = cast<LoadInst>(
I);
2899 if (
auto *PtrT = dyn_cast<PointerType>(
I->getType())) {
2912 case Instruction::ExtractValue: {
2918 case Instruction::Add:
2923 case Instruction::Sub:
2926 case Instruction::Mul:
2935 case Instruction::Call:
2936 case Instruction::Invoke: {
2937 const auto *Call = cast<CallBase>(
I);
2938 if (
I->getType()->isPointerTy()) {
2939 if (Call->isReturnNonNull())
2946 if (std::optional<ConstantRange> Range = Call->getRange()) {
2947 const APInt ZeroValue(Range->getBitWidth(), 0);
2948 if (!Range->contains(ZeroValue))
2951 if (
const Value *RV = Call->getReturnedArgOperand())
2956 if (
auto *II = dyn_cast<IntrinsicInst>(
I)) {
2957 switch (II->getIntrinsicID()) {
2958 case Intrinsic::sshl_sat:
2959 case Intrinsic::ushl_sat:
2960 case Intrinsic::abs:
2961 case Intrinsic::bitreverse:
2962 case Intrinsic::bswap:
2963 case Intrinsic::ctpop:
2967 case Intrinsic::ssub_sat:
2969 II->getArgOperand(0), II->getArgOperand(1));
2970 case Intrinsic::sadd_sat:
2972 II->getArgOperand(0), II->getArgOperand(1),
2975 case Intrinsic::vector_reduce_or:
2976 case Intrinsic::vector_reduce_umax:
2977 case Intrinsic::vector_reduce_umin:
2978 case Intrinsic::vector_reduce_smax:
2979 case Intrinsic::vector_reduce_smin:
2981 case Intrinsic::umax:
2982 case Intrinsic::uadd_sat:
2985 case Intrinsic::smax: {
2988 auto IsNonZero = [&](
Value *
Op, std::optional<bool> &OpNonZero,
2990 if (!OpNonZero.has_value())
2991 OpNonZero = OpKnown.isNonZero() ||
2996 std::optional<bool> Op0NonZero, Op1NonZero;
3000 IsNonZero(II->getArgOperand(1), Op1NonZero, Op1Known))
3005 IsNonZero(II->getArgOperand(0), Op0NonZero, Op0Known))
3007 return IsNonZero(II->getArgOperand(1), Op1NonZero, Op1Known) &&
3008 IsNonZero(II->getArgOperand(0), Op0NonZero, Op0Known);
3010 case Intrinsic::smin: {
3026 case Intrinsic::umin:
3029 case Intrinsic::cttz:
3032 case Intrinsic::ctlz:
3035 case Intrinsic::fshr:
3036 case Intrinsic::fshl:
3038 if (II->getArgOperand(0) == II->getArgOperand(1))
3041 case Intrinsic::vscale:
3043 case Intrinsic::experimental_get_vector_length:
3057 return Known.
One != 0;
3068 Type *Ty = V->getType();
3073 if (
auto *FVTy = dyn_cast<FixedVectorType>(Ty)) {
3075 FVTy->getNumElements() == DemandedElts.
getBitWidth() &&
3076 "DemandedElt width should equal the fixed vector number of elements");
3079 "DemandedElt width should be 1 for scalars");
3083 if (
auto *
C = dyn_cast<Constant>(V)) {
3084 if (
C->isNullValue())
3086 if (isa<ConstantInt>(
C))
3092 if (
auto *VecTy = dyn_cast<FixedVectorType>(Ty)) {
3093 for (
unsigned i = 0, e = VecTy->getNumElements(); i != e; ++i) {
3094 if (!DemandedElts[i])
3096 Constant *Elt =
C->getAggregateElement(i);
3099 if (!isa<PoisonValue>(Elt) && !isa<ConstantInt>(Elt))
3108 if (
const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
3109 if (!GV->isAbsoluteSymbolRef() && !GV->hasExternalWeakLinkage() &&
3110 GV->getType()->getAddressSpace() == 0)
3115 if (!isa<ConstantExpr>(V))
3119 if (
const auto *
A = dyn_cast<Argument>(V))
3120 if (std::optional<ConstantRange> Range =
A->getRange()) {
3121 const APInt ZeroValue(Range->getBitWidth(), 0);
3122 if (!Range->contains(ZeroValue))
3135 if (
PointerType *PtrTy = dyn_cast<PointerType>(Ty)) {
3138 if (
const Argument *
A = dyn_cast<Argument>(V)) {
3139 if (((
A->hasPassPointeeByValueCopyAttr() &&
3141 A->hasNonNullAttr()))
3146 if (
const auto *
I = dyn_cast<Operator>(V))
3150 if (!isa<Constant>(V) &&
3159 auto *FVTy = dyn_cast<FixedVectorType>(V->getType());
3160 APInt DemandedElts =
3162 return ::isKnownNonZero(V, DemandedElts, Q,
Depth);
3171static std::optional<std::pair<Value*, Value*>>
3175 return std::nullopt;
3184 case Instruction::Or:
3185 if (!cast<PossiblyDisjointInst>(Op1)->isDisjoint() ||
3186 !cast<PossiblyDisjointInst>(Op2)->isDisjoint())
3189 case Instruction::Xor:
3190 case Instruction::Add: {
3198 case Instruction::Sub:
3204 case Instruction::Mul: {
3208 auto *OBO1 = cast<OverflowingBinaryOperator>(Op1);
3209 auto *OBO2 = cast<OverflowingBinaryOperator>(Op2);
3210 if ((!OBO1->hasNoUnsignedWrap() || !OBO2->hasNoUnsignedWrap()) &&
3211 (!OBO1->hasNoSignedWrap() || !OBO2->hasNoSignedWrap()))
3217 !cast<ConstantInt>(Op1->
getOperand(1))->isZero())
3221 case Instruction::Shl: {
3224 auto *OBO1 = cast<OverflowingBinaryOperator>(Op1);
3225 auto *OBO2 = cast<OverflowingBinaryOperator>(Op2);
3226 if ((!OBO1->hasNoUnsignedWrap() || !OBO2->hasNoUnsignedWrap()) &&
3227 (!OBO1->hasNoSignedWrap() || !OBO2->hasNoSignedWrap()))
3234 case Instruction::AShr:
3235 case Instruction::LShr: {
3236 auto *PEO1 = cast<PossiblyExactOperator>(Op1);
3237 auto *PEO2 = cast<PossiblyExactOperator>(Op2);
3238 if (!PEO1->isExact() || !PEO2->isExact())
3245 case Instruction::SExt:
3246 case Instruction::ZExt:
3250 case Instruction::PHI: {
3251 const PHINode *PN1 = cast<PHINode>(Op1);
3252 const PHINode *PN2 = cast<PHINode>(Op2);
3258 Value *Start1 =
nullptr, *Step1 =
nullptr;
3260 Value *Start2 =
nullptr, *Step2 =
nullptr;
3267 cast<Operator>(BO2));
3276 if (Values->first != PN1 || Values->second != PN2)
3279 return std::make_pair(Start1, Start2);
3282 return std::nullopt;
3296 case Instruction::Or:
3297 if (!cast<PossiblyDisjointInst>(V1)->isDisjoint())
3300 case Instruction::Xor:
3301 case Instruction::Add:
3318 if (
auto *OBO = dyn_cast<OverflowingBinaryOperator>(V2)) {
3321 (OBO->hasNoUnsignedWrap() || OBO->hasNoSignedWrap()) &&
3331 if (
auto *OBO = dyn_cast<OverflowingBinaryOperator>(V2)) {
3334 (OBO->hasNoUnsignedWrap() || OBO->hasNoSignedWrap()) &&
3347 bool UsedFullRecursion =
false;
3349 if (!VisitedBBs.
insert(IncomBB).second)
3353 const APInt *C1, *C2;
3358 if (UsedFullRecursion)
3362 RecQ.
CxtI = IncomBB->getTerminator();
3365 UsedFullRecursion =
true;
3372 const SelectInst *SI1 = dyn_cast<SelectInst>(V1);
3376 if (
const SelectInst *SI2 = dyn_cast<SelectInst>(V2)) {
3378 const Value *Cond2 = SI2->getCondition();
3396 if (!
A->getType()->isPointerTy() || !
B->getType()->isPointerTy())
3399 auto *GEPA = dyn_cast<GEPOperator>(
A);
3400 if (!GEPA || GEPA->getNumIndices() != 1 || !isa<Constant>(GEPA->idx_begin()))
3404 auto *PN = dyn_cast<PHINode>(GEPA->getPointerOperand());
3405 if (!PN || PN->getNumIncomingValues() != 2)
3410 Value *Start =
nullptr;
3412 if (PN->getIncomingValue(0) == Step)
3413 Start = PN->getIncomingValue(1);
3414 else if (PN->getIncomingValue(1) == Step)
3415 Start = PN->getIncomingValue(0);
3426 APInt StartOffset(IndexWidth, 0);
3427 Start = Start->stripAndAccumulateInBoundsConstantOffsets(Q.
DL, StartOffset);
3428 APInt StepOffset(IndexWidth, 0);
3434 APInt OffsetB(IndexWidth, 0);
3435 B =
B->stripAndAccumulateInBoundsConstantOffsets(Q.
DL, OffsetB);
3436 return Start ==
B &&
3446 if (V1->
getType() != V2->getType())
3456 auto *O1 = dyn_cast<Operator>(V1);
3457 auto *O2 = dyn_cast<Operator>(V2);
3458 if (O1 && O2 && O1->getOpcode() == O2->getOpcode()) {
3462 if (
const PHINode *PN1 = dyn_cast<PHINode>(V1)) {
3463 const PHINode *PN2 = cast<PHINode>(V2);
3516 "Input should be a Select!");
3526 const Value *LHS2 =
nullptr, *RHS2 =
nullptr;
3538 return CLow->
sle(*CHigh);
3543 const APInt *&CHigh) {
3545 II->
getIntrinsicID() == Intrinsic::smax) &&
"Must be smin/smax");
3548 auto *InnerII = dyn_cast<IntrinsicInst>(II->
getArgOperand(0));
3549 if (!InnerII || InnerII->getIntrinsicID() != InverseID ||
3556 return CLow->
sle(*CHigh);
3564 const APInt &DemandedElts,
3566 const auto *CV = dyn_cast<Constant>(V);
3567 if (!CV || !isa<FixedVectorType>(CV->getType()))
3570 unsigned MinSignBits = TyBits;
3571 unsigned NumElts = cast<FixedVectorType>(CV->getType())->getNumElements();
3572 for (
unsigned i = 0; i != NumElts; ++i) {
3573 if (!DemandedElts[i])
3576 auto *Elt = dyn_cast_or_null<ConstantInt>(CV->getAggregateElement(i));
3580 MinSignBits = std::min(MinSignBits, Elt->getValue().getNumSignBits());
3587 const APInt &DemandedElts,
3593 assert(Result > 0 &&
"At least one sign bit needs to be present!");
3605 const APInt &DemandedElts,
3607 Type *Ty = V->getType();
3611 if (
auto *FVTy = dyn_cast<FixedVectorType>(Ty)) {
3613 FVTy->getNumElements() == DemandedElts.
getBitWidth() &&
3614 "DemandedElt width should equal the fixed vector number of elements");
3617 "DemandedElt width should be 1 for scalars");
3631 unsigned FirstAnswer = 1;
3639 if (
auto *U = dyn_cast<Operator>(V)) {
3642 case Instruction::SExt:
3643 Tmp = TyBits - U->getOperand(0)->getType()->getScalarSizeInBits();
3646 case Instruction::SDiv: {
3647 const APInt *Denominator;
3659 return std::min(TyBits, NumBits + Denominator->
logBase2());
3664 case Instruction::SRem: {
3667 const APInt *Denominator;
3688 unsigned ResBits = TyBits - Denominator->
ceilLogBase2();
3689 Tmp = std::max(Tmp, ResBits);
3695 case Instruction::AShr: {
3700 if (ShAmt->
uge(TyBits))
3703 Tmp += ShAmtLimited;
3704 if (Tmp > TyBits) Tmp = TyBits;
3708 case Instruction::Shl: {
3713 if (ShAmt->
uge(TyBits) ||
3714 ShAmt->
uge(Tmp))
break;
3720 case Instruction::And:
3721 case Instruction::Or:
3722 case Instruction::Xor:
3727 FirstAnswer = std::min(Tmp, Tmp2);
3734 case Instruction::Select: {
3738 const APInt *CLow, *CHigh;
3743 if (Tmp == 1)
break;
3745 return std::min(Tmp, Tmp2);
3748 case Instruction::Add:
3752 if (Tmp == 1)
break;
3755 if (
const auto *CRHS = dyn_cast<Constant>(U->getOperand(1)))
3756 if (CRHS->isAllOnesValue()) {
3762 if ((Known.
Zero | 1).isAllOnes())
3772 if (Tmp2 == 1)
break;
3773 return std::min(Tmp, Tmp2) - 1;
3775 case Instruction::Sub:
3777 if (Tmp2 == 1)
break;
3780 if (
const auto *CLHS = dyn_cast<Constant>(U->getOperand(0)))
3781 if (CLHS->isNullValue()) {
3786 if ((Known.
Zero | 1).isAllOnes())
3801 if (Tmp == 1)
break;
3802 return std::min(Tmp, Tmp2) - 1;
3804 case Instruction::Mul: {
3808 if (SignBitsOp0 == 1)
break;
3810 if (SignBitsOp1 == 1)
break;
3811 unsigned OutValidBits =
3812 (TyBits - SignBitsOp0 + 1) + (TyBits - SignBitsOp1 + 1);
3813 return OutValidBits > TyBits ? 1 : TyBits - OutValidBits + 1;
3816 case Instruction::PHI: {
3817 const PHINode *PN = cast<PHINode>(U);
3820 if (NumIncomingValues > 4)
break;
3822 if (NumIncomingValues == 0)
break;
3828 for (
unsigned i = 0, e = NumIncomingValues; i != e; ++i) {
3829 if (Tmp == 1)
return Tmp;
3837 case Instruction::Trunc: {
3842 unsigned OperandTyBits = U->getOperand(0)->getType()->getScalarSizeInBits();
3843 if (Tmp > (OperandTyBits - TyBits))
3844 return Tmp - (OperandTyBits - TyBits);
3849 case Instruction::ExtractElement:
3856 case Instruction::ShuffleVector: {
3859 auto *Shuf = dyn_cast<ShuffleVectorInst>(U);
3864 APInt DemandedLHS, DemandedRHS;
3869 Tmp = std::numeric_limits<unsigned>::max();
3870 if (!!DemandedLHS) {
3871 const Value *
LHS = Shuf->getOperand(0);
3878 if (!!DemandedRHS) {
3879 const Value *
RHS = Shuf->getOperand(1);
3881 Tmp = std::min(Tmp, Tmp2);
3887 assert(Tmp <= TyBits &&
"Failed to determine minimum sign bits");
3890 case Instruction::Call: {
3891 if (
const auto *II = dyn_cast<IntrinsicInst>(U)) {
3892 switch (II->getIntrinsicID()) {
3894 case Intrinsic::abs:
3896 if (Tmp == 1)
break;
3900 case Intrinsic::smin:
3901 case Intrinsic::smax: {
3902 const APInt *CLow, *CHigh;
3917 if (
unsigned VecSignBits =
3935 if (
F->isIntrinsic())
3936 return F->getIntrinsicID();
3942 if (
F->hasLocalLinkage() || !TLI || !TLI->
getLibFunc(CB, Func) ||
3952 return Intrinsic::sin;
3956 return Intrinsic::cos;
3960 return Intrinsic::exp;
3964 return Intrinsic::exp2;
3968 return Intrinsic::log;
3970 case LibFunc_log10f:
3971 case LibFunc_log10l:
3972 return Intrinsic::log10;
3976 return Intrinsic::log2;
3980 return Intrinsic::fabs;
3984 return Intrinsic::minnum;
3988 return Intrinsic::maxnum;
3989 case LibFunc_copysign:
3990 case LibFunc_copysignf:
3991 case LibFunc_copysignl:
3992 return Intrinsic::copysign;
3994 case LibFunc_floorf:
3995 case LibFunc_floorl:
3996 return Intrinsic::floor;
4000 return Intrinsic::ceil;
4002 case LibFunc_truncf:
4003 case LibFunc_truncl:
4004 return Intrinsic::trunc;
4008 return Intrinsic::rint;
4009 case LibFunc_nearbyint:
4010 case LibFunc_nearbyintf:
4011 case LibFunc_nearbyintl:
4012 return Intrinsic::nearbyint;
4014 case LibFunc_roundf:
4015 case LibFunc_roundl:
4016 return Intrinsic::round;
4017 case LibFunc_roundeven:
4018 case LibFunc_roundevenf:
4019 case LibFunc_roundevenl:
4020 return Intrinsic::roundeven;
4024 return Intrinsic::pow;
4028 return Intrinsic::sqrt;
4076 switch (Mode.Input) {
4096 if (!Src.isKnownNeverPosZero() && !Src.isKnownNeverNegZero())
4100 if (Src.isKnownNeverSubnormal())
4130 bool &TrueIfSigned) {
4133 TrueIfSigned =
true;
4134 return RHS.isZero();
4136 TrueIfSigned =
true;
4137 return RHS.isAllOnes();
4139 TrueIfSigned =
false;
4140 return RHS.isAllOnes();
4142 TrueIfSigned =
false;
4143 return RHS.isZero();
4146 TrueIfSigned =
true;
4147 return RHS.isMaxSignedValue();
4150 TrueIfSigned =
true;
4151 return RHS.isMinSignedValue();
4154 TrueIfSigned =
false;
4155 return RHS.isMinSignedValue();
4158 TrueIfSigned =
false;
4159 return RHS.isMaxSignedValue();
4170 bool LookThroughSrc) {
4178std::pair<Value *, FPClassTest>
4180 const APFloat *ConstRHS,
bool LookThroughSrc) {
4182 auto [Src, ClassIfTrue, ClassIfFalse] =
4184 if (Src && ClassIfTrue == ~ClassIfFalse)
4185 return {Src, ClassIfTrue};
4196std::tuple<Value *, FPClassTest, FPClassTest>
4210 const bool IsNegativeRHS = (RHSClass &
fcNegative) == RHSClass;
4211 const bool IsPositiveRHS = (RHSClass &
fcPositive) == RHSClass;
4212 const bool IsNaN = (RHSClass & ~fcNan) ==
fcNone;
4232 const bool IsZero = (OrigClass &
fcZero) == OrigClass;
4279 const bool IsDenormalRHS = (OrigClass &
fcSubnormal) == OrigClass;
4281 const bool IsInf = (OrigClass &
fcInf) == OrigClass;
4299 if (IsNegativeRHS) {
4322 if (IsNegativeRHS) {
4323 Mask = ~fcNegInf & ~fcNan;
4327 Mask = ~fcPosInf & ~fcNan;
4336 if (IsNegativeRHS) {
4356 if (IsNegativeRHS) {
4376 if (IsNegativeRHS) {
4391 if (IsNegativeRHS) {
4419 return {Src, Class, ~fcNan};
4423 return {Src, ~fcNan, RHSClass |
fcNan};
4432 "should have been recognized as an exact class test");
4434 if (IsNegativeRHS) {
4444 return {Src, ~fcNan,
fcNan};
4453 return {Src,
fcNan, ~fcNan};
4472 return {Src, ClassesGE, ~ClassesGE | RHSClass};
4475 return {Src, ClassesGE |
fcNan, ~(ClassesGE |
fcNan) | RHSClass};
4478 return {Src, ClassesLE, ~ClassesLE | RHSClass};
4481 return {Src, ClassesLE |
fcNan, ~(ClassesLE |
fcNan) | RHSClass};
4485 }
else if (IsPositiveRHS) {
4501 return {Src, ClassesGE, ~ClassesGE | RHSClass};
4504 return {Src, ClassesGE |
fcNan, ~(ClassesGE |
fcNan) | RHSClass};
4507 return {Src, ClassesLE, ~ClassesLE | RHSClass};
4510 return {Src, ClassesLE |
fcNan, ~(ClassesLE |
fcNan) | RHSClass};
4519std::tuple<Value *, FPClassTest, FPClassTest>
4521 const APFloat &ConstRHS,
bool LookThroughSrc) {
4569std::tuple<Value *, FPClassTest, FPClassTest>
4571 Value *RHS,
bool LookThroughSrc) {
4593 KnownFromContext.
knownNot(~(CondIsTrue ? MaskIfTrue : MaskIfFalse));
4594 }
else if (
match(
Cond, m_Intrinsic<Intrinsic::is_fpclass>(
4597 KnownFromContext.
knownNot(CondIsTrue ? ~Mask : Mask);
4603 if (TrueIfSigned == CondIsTrue)
4615 return KnownFromContext;
4635 return KnownFromContext;
4645 "Got assumption for the wrong function!");
4646 assert(
I->getCalledFunction()->getIntrinsicID() == Intrinsic::assume &&
4647 "must be an assume intrinsic");
4653 Q.
CxtI, KnownFromContext);
4656 return KnownFromContext;
4666 auto *FVTy = dyn_cast<FixedVectorType>(V->getType());
4667 APInt DemandedElts =
4673 const APInt &DemandedElts,
4677 if ((InterestedClasses &
4683 KnownSrc,
Depth + 1, Q);
4698 assert(Known.
isUnknown() &&
"should not be called with known information");
4700 if (!DemandedElts) {
4708 if (
auto *CFP = dyn_cast<ConstantFP>(V)) {
4710 Known.
SignBit = CFP->isNegative();
4714 if (isa<ConstantAggregateZero>(V)) {
4720 if (isa<PoisonValue>(V)) {
4727 auto *VFVTy = dyn_cast<FixedVectorType>(V->getType());
4728 const Constant *CV = dyn_cast<Constant>(V);
4731 bool SignBitAllZero =
true;
4732 bool SignBitAllOne =
true;
4735 unsigned NumElts = VFVTy->getNumElements();
4736 for (
unsigned i = 0; i != NumElts; ++i) {
4737 if (!DemandedElts[i])
4745 if (isa<UndefValue>(Elt))
4747 auto *CElt = dyn_cast<ConstantFP>(Elt);
4753 const APFloat &
C = CElt->getValueAPF();
4756 SignBitAllZero =
false;
4758 SignBitAllOne =
false;
4760 if (SignBitAllOne != SignBitAllZero)
4761 Known.
SignBit = SignBitAllOne;
4766 if (
const auto *CB = dyn_cast<CallBase>(V))
4767 KnownNotFromFlags |= CB->getRetNoFPClass();
4768 else if (
const auto *Arg = dyn_cast<Argument>(V))
4769 KnownNotFromFlags |= Arg->getNoFPClass();
4773 if (FPOp->hasNoNaNs())
4774 KnownNotFromFlags |=
fcNan;
4775 if (FPOp->hasNoInfs())
4776 KnownNotFromFlags |=
fcInf;
4780 KnownNotFromFlags |= ~AssumedClasses.KnownFPClasses;
4784 InterestedClasses &= ~KnownNotFromFlags;
4789 if (*AssumedClasses.SignBit)
4790 Known.signBitMustBeOne();
4792 Known.signBitMustBeZero();
4803 const unsigned Opc =
Op->getOpcode();
4805 case Instruction::FNeg: {
4807 Known,
Depth + 1, Q);
4811 case Instruction::Select: {
4819 Value *TestedValue =
nullptr;
4823 const Function *
F = cast<Instruction>(
Op)->getFunction();
4825 Value *CmpLHS, *CmpRHS;
4832 bool LookThroughFAbsFNeg = CmpLHS !=
LHS && CmpLHS !=
RHS;
4833 std::tie(TestedValue, MaskIfTrue, MaskIfFalse) =
4836 m_Intrinsic<Intrinsic::is_fpclass>(
4839 MaskIfTrue = TestedMask;
4840 MaskIfFalse = ~TestedMask;
4843 if (TestedValue ==
LHS) {
4845 FilterLHS = MaskIfTrue;
4846 }
else if (TestedValue ==
RHS) {
4848 FilterRHS = MaskIfFalse;
4857 Known2,
Depth + 1, Q);
4863 case Instruction::Call: {
4867 case Intrinsic::fabs: {
4872 InterestedClasses, Known,
Depth + 1, Q);
4878 case Intrinsic::copysign: {
4882 Known,
Depth + 1, Q);
4884 KnownSign,
Depth + 1, Q);
4888 case Intrinsic::fma:
4889 case Intrinsic::fmuladd: {
4902 KnownAddend,
Depth + 1, Q);
4908 case Intrinsic::sqrt:
4909 case Intrinsic::experimental_constrained_sqrt: {
4912 if (InterestedClasses &
fcNan)
4916 KnownSrc,
Depth + 1, Q);
4942 case Intrinsic::sin:
4943 case Intrinsic::cos: {
4947 KnownSrc,
Depth + 1, Q);
4953 case Intrinsic::maxnum:
4954 case Intrinsic::minnum:
4955 case Intrinsic::minimum:
4956 case Intrinsic::maximum: {
4959 KnownLHS,
Depth + 1, Q);
4961 KnownRHS,
Depth + 1, Q);
4964 Known = KnownLHS | KnownRHS;
4967 if (NeverNaN && (IID == Intrinsic::minnum || IID == Intrinsic::maxnum))
4970 if (IID == Intrinsic::maxnum) {
4978 }
else if (IID == Intrinsic::maximum) {
4984 }
else if (IID == Intrinsic::minnum) {
5026 }
else if ((IID == Intrinsic::maximum || IID == Intrinsic::minimum) ||
5031 if ((IID == Intrinsic::maximum || IID == Intrinsic::maxnum) &&
5034 else if ((IID == Intrinsic::minimum || IID == Intrinsic::minnum) &&
5041 case Intrinsic::canonicalize: {
5044 KnownSrc,
Depth + 1, Q);
5088 case Intrinsic::vector_reduce_fmax:
5089 case Intrinsic::vector_reduce_fmin:
5090 case Intrinsic::vector_reduce_fmaximum:
5091 case Intrinsic::vector_reduce_fminimum: {
5095 InterestedClasses,
Depth + 1, Q);
5101 case Intrinsic::trunc:
5102 case Intrinsic::floor:
5103 case Intrinsic::ceil:
5104 case Intrinsic::rint:
5105 case Intrinsic::nearbyint:
5106 case Intrinsic::round:
5107 case Intrinsic::roundeven: {
5115 KnownSrc,
Depth + 1, Q);
5124 if (IID == Intrinsic::trunc || !V->getType()->isMultiUnitFPType()) {
5139 case Intrinsic::exp:
5140 case Intrinsic::exp2:
5141 case Intrinsic::exp10: {
5148 KnownSrc,
Depth + 1, Q);
5156 case Intrinsic::fptrunc_round: {
5161 case Intrinsic::log:
5162 case Intrinsic::log10:
5163 case Intrinsic::log2:
5164 case Intrinsic::experimental_constrained_log:
5165 case Intrinsic::experimental_constrained_log10:
5166 case Intrinsic::experimental_constrained_log2: {
5182 KnownSrc,
Depth + 1, Q);
5196 case Intrinsic::powi: {
5201 Type *ExpTy = Exp->getType();
5205 ExponentKnownBits,
Depth + 1, Q);
5207 if (ExponentKnownBits.
Zero[0]) {
5222 KnownSrc,
Depth + 1, Q);
5227 case Intrinsic::ldexp: {
5230 KnownSrc,
Depth + 1, Q);
5246 if ((InterestedClasses & ExpInfoMask) ==
fcNone)
5258 const int MantissaBits = Precision - 1;
5264 if (ConstVal && ConstVal->
isZero()) {
5287 case Intrinsic::arithmetic_fence: {
5289 Known,
Depth + 1, Q);
5292 case Intrinsic::experimental_constrained_sitofp:
5293 case Intrinsic::experimental_constrained_uitofp:
5303 if (IID == Intrinsic::experimental_constrained_uitofp)
5314 case Instruction::FAdd:
5315 case Instruction::FSub: {
5318 Op->getOpcode() == Instruction::FAdd &&
5320 bool WantNaN = (InterestedClasses &
fcNan) !=
fcNone;
5323 if (!WantNaN && !WantNegative && !WantNegZero)
5329 if (InterestedClasses &
fcNan)
5330 InterestedSrcs |=
fcInf;
5332 KnownRHS,
Depth + 1, Q);
5336 WantNegZero || Opc == Instruction::FSub) {
5341 KnownLHS,
Depth + 1, Q);
5349 const Function *
F = cast<Instruction>(
Op)->getFunction();
5351 if (
Op->getOpcode() == Instruction::FAdd) {
5379 case Instruction::FMul: {
5381 if (
Op->getOperand(0) ==
Op->getOperand(1))
5414 const Function *
F = cast<Instruction>(
Op)->getFunction();
5426 case Instruction::FDiv:
5427 case Instruction::FRem: {
5428 if (
Op->getOperand(0) ==
Op->getOperand(1)) {
5430 if (
Op->getOpcode() == Instruction::FDiv) {
5441 const bool WantNan = (InterestedClasses &
fcNan) !=
fcNone;
5443 const bool WantPositive =
5445 if (!WantNan && !WantNegative && !WantPositive)
5454 bool KnowSomethingUseful =
5457 if (KnowSomethingUseful || WantPositive) {
5463 InterestedClasses & InterestedLHS, KnownLHS,
5467 const Function *
F = cast<Instruction>(
Op)->getFunction();
5469 if (
Op->getOpcode() == Instruction::FDiv) {
5506 case Instruction::FPExt: {
5509 Known,
Depth + 1, Q);
5512 Op->getType()->getScalarType()->getFltSemantics();
5514 Op->getOperand(0)->getType()->getScalarType()->getFltSemantics();
5530 case Instruction::FPTrunc: {
5535 case Instruction::SIToFP:
5536 case Instruction::UIToFP: {
5545 if (
Op->getOpcode() == Instruction::UIToFP)
5548 if (InterestedClasses &
fcInf) {
5552 int IntSize =
Op->getOperand(0)->getType()->getScalarSizeInBits();
5553 if (
Op->getOpcode() == Instruction::SIToFP)
5558 Type *FPTy =
Op->getType()->getScalarType();
5565 case Instruction::ExtractElement: {
5568 const Value *Vec =
Op->getOperand(0);
5570 auto *CIdx = dyn_cast<ConstantInt>(
Idx);
5572 if (
auto *VecTy = dyn_cast<FixedVectorType>(Vec->
getType())) {
5573 unsigned NumElts = VecTy->getNumElements();
5575 if (CIdx && CIdx->getValue().ult(NumElts))
5583 case Instruction::InsertElement: {
5584 if (isa<ScalableVectorType>(
Op->getType()))
5587 const Value *Vec =
Op->getOperand(0);
5588 const Value *Elt =
Op->getOperand(1);
5589 auto *CIdx = dyn_cast<ConstantInt>(
Op->getOperand(2));
5591 APInt DemandedVecElts = DemandedElts;
5592 bool NeedsElt =
true;
5594 if (CIdx && CIdx->getValue().ult(NumElts)) {
5595 DemandedVecElts.
clearBit(CIdx->getZExtValue());
5596 NeedsElt = DemandedElts[CIdx->getZExtValue()];
5610 if (!DemandedVecElts.
isZero()) {
5619 case Instruction::ShuffleVector: {
5622 APInt DemandedLHS, DemandedRHS;
5623 auto *Shuf = dyn_cast<ShuffleVectorInst>(
Op);
5627 if (!!DemandedLHS) {
5628 const Value *
LHS = Shuf->getOperand(0);
5639 if (!!DemandedRHS) {
5641 const Value *
RHS = Shuf->getOperand(1);
5649 case Instruction::ExtractValue: {
5653 if (isa<StructType>(Src->getType()) && Indices.
size() == 1 &&
5655 if (
const auto *II = dyn_cast<IntrinsicInst>(Src)) {
5656 switch (II->getIntrinsicID()) {
5657 case Intrinsic::frexp: {
5662 InterestedClasses, KnownSrc,
Depth + 1, Q);
5664 const Function *
F = cast<Instruction>(
Op)->getFunction();
5697 case Instruction::PHI: {
5700 if (
P->getNumIncomingValues() == 0)
5707 if (
Depth < PhiRecursionLimit) {
5709 if (isa_and_nonnull<UndefValue>(
P->hasConstantValue()))
5714 for (
const Use &U :
P->operands()) {
5715 Value *IncValue = U.get();
5725 IncValue, DemandedElts, InterestedClasses, KnownSrc,
5749 const APInt &DemandedElts,
5756 return KnownClasses;
5771 if (V->getType()->isIntegerTy(8))
5778 if (isa<UndefValue>(V))
5782 if (
DL.getTypeStoreSize(V->getType()).isZero())
5797 if (
C->isNullValue())
5804 if (CFP->getType()->isHalfTy())
5806 else if (CFP->getType()->isFloatTy())
5808 else if (CFP->getType()->isDoubleTy())
5817 if (CI->getBitWidth() % 8 == 0) {
5818 assert(CI->getBitWidth() > 8 &&
"8 bits should be handled above!");
5819 if (!CI->getValue().isSplat(8))
5821 return ConstantInt::get(Ctx, CI->getValue().trunc(8));
5825 if (
auto *CE = dyn_cast<ConstantExpr>(
C)) {
5826 if (CE->getOpcode() == Instruction::IntToPtr) {
5827 if (
auto *PtrTy = dyn_cast<PointerType>(CE->getType())) {
5828 unsigned BitWidth =
DL.getPointerSizeInBits(PtrTy->getAddressSpace());
5841 if (
LHS == UndefInt8)
5843 if (
RHS == UndefInt8)
5849 Value *Val = UndefInt8;
5850 for (
unsigned I = 0, E = CA->getNumElements();
I != E; ++
I)
5856 if (isa<ConstantAggregate>(
C)) {
5857 Value *Val = UndefInt8;
5858 for (
unsigned I = 0, E =
C->getNumOperands();
I != E; ++
I)
5878 StructType *STy = dyn_cast<StructType>(IndexedType);
5892 while (PrevTo != OrigTo) {
5939 unsigned IdxSkip = Idxs.
size();
5952 std::optional<BasicBlock::iterator> InsertBefore) {
5955 if (idx_range.
empty())
5958 assert((V->getType()->isStructTy() || V->getType()->isArrayTy()) &&
5959 "Not looking at a struct or array?");
5961 "Invalid indices for type?");
5963 if (
Constant *
C = dyn_cast<Constant>(V)) {
5964 C =
C->getAggregateElement(idx_range[0]);
5965 if (!
C)
return nullptr;
5972 const unsigned *req_idx = idx_range.
begin();
5973 for (
const unsigned *i =
I->idx_begin(), *e =
I->idx_end();
5974 i != e; ++i, ++req_idx) {
5975 if (req_idx == idx_range.
end()) {
6005 ArrayRef(req_idx, idx_range.
end()), InsertBefore);
6014 unsigned size =
I->getNumIndices() + idx_range.
size();
6019 Idxs.
append(
I->idx_begin(),
I->idx_end());
6025 &&
"Number of indices added not correct?");
6035 unsigned CharSize) {
6037 if (
GEP->getNumOperands() != 3)
6042 ArrayType *AT = dyn_cast<ArrayType>(
GEP->getSourceElementType());
6048 const ConstantInt *FirstIdx = dyn_cast<ConstantInt>(
GEP->getOperand(1));
6049 if (!FirstIdx || !FirstIdx->
isZero())
6063 assert(V &&
"V should not be null.");
6064 assert((ElementSize % 8) == 0 &&
6065 "ElementSize expected to be a multiple of the size of a byte.");
6066 unsigned ElementSizeInBytes = ElementSize / 8;
6078 APInt Off(
DL.getIndexTypeSizeInBits(V->getType()), 0);
6080 if (GV != V->stripAndAccumulateConstantOffsets(
DL, Off,
6085 uint64_t StartIdx = Off.getLimitedValue();
6092 if ((StartIdx % ElementSizeInBytes) != 0)
6095 Offset += StartIdx / ElementSizeInBytes;
6101 uint64_t SizeInBytes =
DL.getTypeStoreSize(GVTy).getFixedValue();
6104 Slice.
Array =
nullptr;
6115 if (
auto *ArrayInit = dyn_cast<ConstantDataArray>(
Init)) {
6116 Type *InitElTy = ArrayInit->getElementType();
6121 ArrayTy = ArrayInit->getType();
6126 if (ElementSize != 8)
6137 Array = dyn_cast<ConstantDataArray>(
Init);
6138 ArrayTy = dyn_cast<ArrayType>(
Init->getType());
6145 Slice.
Array = Array;
6161 if (Slice.
Array ==
nullptr) {
6184 Str = Str.substr(Slice.
Offset);
6190 Str = Str.substr(0, Str.find(
'\0'));
6203 unsigned CharSize) {
6205 V = V->stripPointerCasts();
6209 if (
const PHINode *PN = dyn_cast<PHINode>(V)) {
6210 if (!PHIs.
insert(PN).second)
6215 for (
Value *IncValue : PN->incoming_values()) {
6217 if (Len == 0)
return 0;
6219 if (Len == ~0ULL)
continue;
6221 if (Len != LenSoFar && LenSoFar != ~0ULL)
6231 if (
const SelectInst *SI = dyn_cast<SelectInst>(V)) {
6233 if (Len1 == 0)
return 0;
6235 if (Len2 == 0)
return 0;
6236 if (Len1 == ~0ULL)
return Len2;
6237 if (Len2 == ~0ULL)
return Len1;
6238 if (Len1 != Len2)
return 0;
6247 if (Slice.
Array ==
nullptr)
6255 unsigned NullIndex = 0;
6256 for (
unsigned E = Slice.
Length; NullIndex < E; ++NullIndex) {
6261 return NullIndex + 1;
6267 if (!V->getType()->isPointerTy())
6274 return Len == ~0ULL ? 1 : Len;
6279 bool MustPreserveNullness) {
6281 "getArgumentAliasingToReturnedPointer only works on nonnull calls");
6282 if (
const Value *RV = Call->getReturnedArgOperand())
6286 Call, MustPreserveNullness))
6287 return Call->getArgOperand(0);
6292 const CallBase *Call,
bool MustPreserveNullness) {
6293 switch (Call->getIntrinsicID()) {
6294 case Intrinsic::launder_invariant_group:
6295 case Intrinsic::strip_invariant_group:
6296 case Intrinsic::aarch64_irg:
6297 case Intrinsic::aarch64_tagp:
6307 case Intrinsic::amdgcn_make_buffer_rsrc:
6309 case Intrinsic::ptrmask:
6310 return !MustPreserveNullness;
6311 case Intrinsic::threadlocal_address:
6314 return !Call->getParent()->getParent()->isPresplitCoroutine();
6331 if (!PrevValue || LI->
getLoopFor(PrevValue->getParent()) != L)
6333 if (!PrevValue || LI->
getLoopFor(PrevValue->getParent()) != L)
6341 if (
auto *Load = dyn_cast<LoadInst>(PrevValue))
6342 if (!L->isLoopInvariant(Load->getPointerOperand()))
6348 if (!V->getType()->isPointerTy())
6350 for (
unsigned Count = 0; MaxLookup == 0 || Count < MaxLookup; ++Count) {
6351 if (
auto *
GEP = dyn_cast<GEPOperator>(V)) {
6352 V =
GEP->getPointerOperand();
6355 V = cast<Operator>(V)->getOperand(0);
6356 if (!V->getType()->isPointerTy())
6358 }
else if (
auto *GA = dyn_cast<GlobalAlias>(V)) {
6359 if (GA->isInterposable())
6361 V = GA->getAliasee();
6363 if (
auto *
PHI = dyn_cast<PHINode>(V)) {
6365 if (
PHI->getNumIncomingValues() == 1) {
6366 V =
PHI->getIncomingValue(0);
6369 }
else if (
auto *Call = dyn_cast<CallBase>(V)) {
6387 assert(V->getType()->isPointerTy() &&
"Unexpected operand type!");
6394 LoopInfo *LI,
unsigned MaxLookup) {
6402 if (!Visited.
insert(
P).second)
6405 if (
auto *SI = dyn_cast<SelectInst>(
P)) {
6407 Worklist.
push_back(SI->getFalseValue());
6411 if (
auto *PN = dyn_cast<PHINode>(
P)) {
6431 }
while (!Worklist.
empty());
6438 if (
const Operator *U = dyn_cast<Operator>(V)) {
6441 if (U->getOpcode() == Instruction::PtrToInt)
6442 return U->getOperand(0);
6449 if (U->getOpcode() != Instruction::Add ||
6450 (!isa<ConstantInt>(U->getOperand(1)) &&
6452 !isa<PHINode>(U->getOperand(1))))
6454 V = U->getOperand(0);
6458 assert(V->getType()->isIntegerTy() &&
"Unexpected operand type!");
6475 for (
const Value *V : Objs) {
6476 if (!Visited.
insert(V).second)
6481 if (O->getType()->isPointerTy()) {
6494 }
while (!Working.
empty());
6503 auto AddWork = [&](
Value *V) {
6504 if (Visited.
insert(V).second)
6513 if (
AllocaInst *AI = dyn_cast<AllocaInst>(V)) {
6514 if (Result && Result != AI)
6517 }
else if (
CastInst *CI = dyn_cast<CastInst>(V)) {
6518 AddWork(CI->getOperand(0));
6519 }
else if (
PHINode *PN = dyn_cast<PHINode>(V)) {
6520 for (
Value *IncValue : PN->incoming_values())
6522 }
else if (
auto *SI = dyn_cast<SelectInst>(V)) {
6523 AddWork(SI->getTrueValue());
6524 AddWork(SI->getFalseValue());
6526 if (OffsetZero && !
GEP->hasAllZeroIndices())
6528 AddWork(
GEP->getPointerOperand());
6529 }
else if (
CallBase *CB = dyn_cast<CallBase>(V)) {
6530 Value *Returned = CB->getReturnedArgOperand();
6538 }
while (!Worklist.
empty());
6544 const Value *V,
bool AllowLifetime,
bool AllowDroppable) {
6545 for (
const User *U : V->users()) {
6575 return F.hasFnAttribute(Attribute::SanitizeThread) ||
6577 F.hasFnAttribute(Attribute::SanitizeAddress) ||
6578 F.hasFnAttribute(Attribute::SanitizeHWAddress);
6597 auto hasEqualReturnAndLeadingOperandTypes =
6598 [](
const Instruction *Inst,
unsigned NumLeadingOperands) {
6602 for (
unsigned ItOp = 0; ItOp < NumLeadingOperands; ++ItOp)
6608 hasEqualReturnAndLeadingOperandTypes(Inst, 2));
6610 hasEqualReturnAndLeadingOperandTypes(Inst, 1));
6617 case Instruction::UDiv:
6618 case Instruction::URem: {
6625 case Instruction::SDiv:
6626 case Instruction::SRem: {
6628 const APInt *Numerator, *Denominator;
6632 if (*Denominator == 0)
6644 case Instruction::Load: {
6645 const LoadInst *LI = dyn_cast<LoadInst>(Inst);
6655 case Instruction::Call: {
6656 auto *CI = dyn_cast<const CallInst>(Inst);
6659 const Function *Callee = CI->getCalledFunction();
6663 return Callee && Callee->isSpeculatable();
6665 case Instruction::VAArg:
6666 case Instruction::Alloca:
6667 case Instruction::Invoke:
6668 case Instruction::CallBr:
6669 case Instruction::PHI:
6670 case Instruction::Store:
6671 case Instruction::Ret:
6672 case Instruction::Br:
6673 case Instruction::IndirectBr:
6674 case Instruction::Switch:
6675 case Instruction::Unreachable:
6676 case Instruction::Fence:
6677 case Instruction::AtomicRMW:
6678 case Instruction::AtomicCmpXchg:
6679 case Instruction::LandingPad:
6680 case Instruction::Resume:
6681 case Instruction::CatchSwitch:
6682 case Instruction::CatchPad:
6683 case Instruction::CatchRet:
6684 case Instruction::CleanupPad:
6685 case Instruction::CleanupRet:
6691 if (
I.mayReadOrWriteMemory())
6804 if (
Add &&
Add->hasNoSignedWrap()) {
6844 bool LHSOrRHSKnownNonNegative =
6846 bool LHSOrRHSKnownNegative =
6848 if (LHSOrRHSKnownNonNegative || LHSOrRHSKnownNegative) {
6851 if ((AddKnown.
isNonNegative() && LHSOrRHSKnownNonNegative) ||
6852 (AddKnown.
isNegative() && LHSOrRHSKnownNegative))
6881 m_Intrinsic<Intrinsic::usub_with_overflow>(
m_Value(),
m_Value())))
6930 if (
const auto *EVI = dyn_cast<ExtractValueInst>(U)) {
6931 assert(EVI->getNumIndices() == 1 &&
"Obvious from CI's type");
6933 if (EVI->getIndices()[0] == 0)
6936 assert(EVI->getIndices()[0] == 1 &&
"Obvious from CI's type");
6938 for (
const auto *U : EVI->users())
6939 if (
const auto *
B = dyn_cast<BranchInst>(U)) {
6940 assert(
B->isConditional() &&
"How else is it using an i1?");
6951 auto AllUsesGuardedByBranch = [&](
const BranchInst *BI) {
6957 for (
const auto *Result :
Results) {
6960 if (DT.
dominates(NoWrapEdge, Result->getParent()))
6963 for (
const auto &RU : Result->uses())
6971 return llvm::any_of(GuardingBranches, AllUsesGuardedByBranch);
6976 auto *
C = dyn_cast<Constant>(ShiftAmount);
6982 if (
auto *FVTy = dyn_cast<FixedVectorType>(
C->getType())) {
6983 unsigned NumElts = FVTy->getNumElements();
6984 for (
unsigned i = 0; i < NumElts; ++i)
6985 ShiftAmounts.
push_back(
C->getAggregateElement(i));
6986 }
else if (isa<ScalableVectorType>(
C->getType()))
6992 auto *CI = dyn_cast_or_null<ConstantInt>(
C);
6993 return CI && CI->getValue().ult(
C->getType()->getIntegerBitWidth());
7006 return (
unsigned(Kind) &
unsigned(UndefPoisonKind::PoisonOnly)) != 0;
7010 return (
unsigned(Kind) &
unsigned(UndefPoisonKind::UndefOnly)) != 0;
7014 bool ConsiderFlagsAndMetadata) {
7017 Op->hasPoisonGeneratingAnnotations())
7020 unsigned Opcode =
Op->getOpcode();
7024 case Instruction::Shl:
7025 case Instruction::AShr:
7026 case Instruction::LShr:
7028 case Instruction::FPToSI:
7029 case Instruction::FPToUI:
7033 case Instruction::Call:
7034 if (
auto *II = dyn_cast<IntrinsicInst>(
Op)) {
7035 switch (II->getIntrinsicID()) {
7037 case Intrinsic::ctlz:
7038 case Intrinsic::cttz:
7039 case Intrinsic::abs:
7040 if (cast<ConstantInt>(II->getArgOperand(1))->isNullValue())
7043 case Intrinsic::ctpop:
7044 case Intrinsic::bswap:
7045 case Intrinsic::bitreverse:
7046 case Intrinsic::fshl:
7047 case Intrinsic::fshr:
7048 case Intrinsic::smax:
7049 case Intrinsic::smin:
7050 case Intrinsic::umax:
7051 case Intrinsic::umin:
7052 case Intrinsic::ptrmask:
7053 case Intrinsic::fptoui_sat:
7054 case Intrinsic::fptosi_sat:
7055 case Intrinsic::sadd_with_overflow:
7056 case Intrinsic::ssub_with_overflow:
7057 case Intrinsic::smul_with_overflow:
7058 case Intrinsic::uadd_with_overflow:
7059 case Intrinsic::usub_with_overflow:
7060 case Intrinsic::umul_with_overflow:
7061 case Intrinsic::sadd_sat:
7062 case Intrinsic::uadd_sat:
7063 case Intrinsic::ssub_sat:
7064 case Intrinsic::usub_sat:
7066 case Intrinsic::sshl_sat:
7067 case Intrinsic::ushl_sat:
7070 case Intrinsic::fma:
7071 case Intrinsic::fmuladd:
7072 case Intrinsic::sqrt:
7073 case Intrinsic::powi:
7074 case Intrinsic::sin:
7075 case Intrinsic::cos:
7076 case Intrinsic::pow:
7077 case Intrinsic::log:
7078 case Intrinsic::log10:
7079 case Intrinsic::log2:
7080 case Intrinsic::exp:
7081 case Intrinsic::exp2:
7082 case Intrinsic::exp10:
7083 case Intrinsic::fabs:
7084 case Intrinsic::copysign:
7085 case Intrinsic::floor:
7086 case Intrinsic::ceil:
7087 case Intrinsic::trunc:
7088 case Intrinsic::rint:
7089 case Intrinsic::nearbyint:
7090 case Intrinsic::round:
7091 case Intrinsic::roundeven:
7092 case Intrinsic::fptrunc_round:
7093 case Intrinsic::canonicalize:
7094 case Intrinsic::arithmetic_fence:
7095 case Intrinsic::minnum:
7096 case Intrinsic::maxnum:
7097 case Intrinsic::minimum:
7098 case Intrinsic::maximum:
7099 case Intrinsic::is_fpclass:
7100 case Intrinsic::ldexp:
7101 case Intrinsic::frexp:
7103 case Intrinsic::lround:
7104 case Intrinsic::llround:
7105 case Intrinsic::lrint:
7106 case Intrinsic::llrint:
7113 case Instruction::CallBr:
7114 case Instruction::Invoke: {
7115 const auto *CB = cast<CallBase>(
Op);
7116 return !CB->hasRetAttr(Attribute::NoUndef);
7118 case Instruction::InsertElement:
7119 case Instruction::ExtractElement: {
7121 auto *VTy = cast<VectorType>(
Op->getOperand(0)->getType());
7122 unsigned IdxOp =
Op->getOpcode() == Instruction::InsertElement ? 2 : 1;
7123 auto *
Idx = dyn_cast<ConstantInt>(
Op->getOperand(IdxOp));
7126 Idx->getValue().uge(VTy->getElementCount().getKnownMinValue());
7129 case Instruction::ShuffleVector: {
7131 ? cast<ConstantExpr>(
Op)->getShuffleMask()
7132 : cast<ShuffleVectorInst>(
Op)->getShuffleMask();
7135 case Instruction::FNeg:
7136 case Instruction::PHI:
7137 case Instruction::Select:
7138 case Instruction::URem:
7139 case Instruction::SRem:
7140 case Instruction::ExtractValue:
7141 case Instruction::InsertValue:
7142 case Instruction::Freeze:
7143 case Instruction::ICmp:
7144 case Instruction::FCmp:
7145 case Instruction::FAdd:
7146 case Instruction::FSub:
7147 case Instruction::FMul:
7148 case Instruction::FDiv:
7149 case Instruction::FRem:
7151 case Instruction::GetElementPtr:
7156 const auto *CE = dyn_cast<ConstantExpr>(
Op);
7157 if (isa<CastInst>(
Op) || (CE && CE->isCast()))
7168 bool ConsiderFlagsAndMetadata) {
7169 return ::canCreateUndefOrPoison(
Op, UndefPoisonKind::UndefOrPoison,
7170 ConsiderFlagsAndMetadata);
7174 return ::canCreateUndefOrPoison(
Op, UndefPoisonKind::PoisonOnly,
7175 ConsiderFlagsAndMetadata);
7180 if (ValAssumedPoison == V)
7187 if (
const auto *
I = dyn_cast<Instruction>(V)) {
7189 return propagatesPoison(Op) &&
7190 directlyImpliesPoison(ValAssumedPoison, Op, Depth + 1);
7218 const auto *
I = dyn_cast<Instruction>(ValAssumedPoison);
7221 return impliesPoison(Op, V, Depth + 1);
7228 return ::impliesPoison(ValAssumedPoison, V, 0);
7239 if (isa<MetadataAsValue>(V))
7242 if (
const auto *
A = dyn_cast<Argument>(V)) {
7243 if (
A->hasAttribute(Attribute::NoUndef) ||
7244 A->hasAttribute(Attribute::Dereferenceable) ||
7245 A->hasAttribute(Attribute::DereferenceableOrNull))
7249 if (
auto *
C = dyn_cast<Constant>(V)) {
7250 if (isa<PoisonValue>(
C))
7253 if (isa<UndefValue>(
C))
7256 if (isa<ConstantInt>(
C) || isa<GlobalVariable>(
C) || isa<ConstantFP>(V) ||
7257 isa<ConstantPointerNull>(
C) || isa<Function>(
C))
7260 if (
C->getType()->isVectorTy() && !isa<ConstantExpr>(
C))
7262 : !
C->containsUndefOrPoisonElement()) &&
7263 !
C->containsConstantExpression();
7274 auto *StrippedV = V->stripPointerCastsSameRepresentation();
7275 if (isa<AllocaInst>(StrippedV) || isa<GlobalVariable>(StrippedV) ||
7276 isa<Function>(StrippedV) || isa<ConstantPointerNull>(StrippedV))
7279 auto OpCheck = [&](
const Value *V) {
7283 if (
auto *Opr = dyn_cast<Operator>(V)) {
7286 if (isa<FreezeInst>(V))
7289 if (
const auto *CB = dyn_cast<CallBase>(V)) {
7290 if (CB->hasRetAttr(Attribute::NoUndef) ||
7291 CB->hasRetAttr(Attribute::Dereferenceable) ||
7292 CB->hasRetAttr(Attribute::DereferenceableOrNull))
7296 if (
const auto *PN = dyn_cast<PHINode>(V)) {
7297 unsigned Num = PN->getNumIncomingValues();
7298 bool IsWellDefined =
true;
7299 for (
unsigned i = 0; i < Num; ++i) {
7300 auto *TI = PN->getIncomingBlock(i)->getTerminator();
7302 DT,
Depth + 1, Kind)) {
7303 IsWellDefined =
false;
7311 all_of(Opr->operands(), OpCheck))
7315 if (
auto *
I = dyn_cast<LoadInst>(V))
7316 if (
I->hasMetadata(LLVMContext::MD_noundef) ||
7317 I->hasMetadata(LLVMContext::MD_dereferenceable) ||
7318 I->hasMetadata(LLVMContext::MD_dereferenceable_or_null))
7338 auto *Dominator = DNode->
getIDom();
7343 auto *TI = Dominator->
getBlock()->getTerminator();
7346 if (
auto BI = dyn_cast_or_null<BranchInst>(TI)) {
7347 if (BI->isConditional())
7348 Cond = BI->getCondition();
7349 }
else if (
auto SI = dyn_cast_or_null<SwitchInst>(TI)) {
7350 Cond = SI->getCondition();
7358 auto *Opr = cast<Operator>(
Cond);
7359 if (
any_of(Opr->operands(), [V](
const Use &U) {
7360 return V == U && propagatesPoison(U);
7366 Dominator = Dominator->getIDom();
7379 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT,
Depth,
7380 UndefPoisonKind::UndefOrPoison);
7386 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT,
Depth,
7387 UndefPoisonKind::PoisonOnly);
7393 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT,
Depth,
7394 UndefPoisonKind::UndefOnly);
7417 while (!Worklist.
empty()) {
7426 if (
I != Root && !
any_of(
I->operands(), [&KnownPoison](
const Use &U) {
7427 return KnownPoison.contains(U) && propagatesPoison(U);
7431 if (KnownPoison.
insert(
I).second)
7443 return ::computeOverflowForSignedAdd(
Add->getOperand(0),
Add->getOperand(1),
7451 return ::computeOverflowForSignedAdd(
LHS,
RHS,
nullptr, SQ);
7460 if (isa<ReturnInst>(
I))
7462 if (isa<UnreachableInst>(
I))
7469 if (isa<CatchPadInst>(
I)) {
7483 return !
I->mayThrow() &&
I->willReturn();
7497 unsigned ScanLimit) {
7504 assert(ScanLimit &&
"scan limit must be non-zero");
7506 if (isa<DbgInfoIntrinsic>(
I))
7508 if (--ScanLimit == 0)
7522 if (
I->getParent() != L->getHeader())
return false;
7525 if (&LI ==
I)
return true;
7528 llvm_unreachable(
"Instruction not contained in its own parent basic block.");
7533 switch (
I->getOpcode()) {
7534 case Instruction::Freeze:
7535 case Instruction::PHI:
7536 case Instruction::Invoke:
7538 case Instruction::Select:
7540 case Instruction::Call:
7541 if (
auto *II = dyn_cast<IntrinsicInst>(
I)) {
7542 switch (II->getIntrinsicID()) {
7544 case Intrinsic::sadd_with_overflow:
7545 case Intrinsic::ssub_with_overflow:
7546 case Intrinsic::smul_with_overflow:
7547 case Intrinsic::uadd_with_overflow:
7548 case Intrinsic::usub_with_overflow:
7549 case Intrinsic::umul_with_overflow:
7554 case Intrinsic::ctpop:
7555 case Intrinsic::ctlz:
7556 case Intrinsic::cttz:
7557 case Intrinsic::abs:
7558 case Intrinsic::smax:
7559 case Intrinsic::smin:
7560 case Intrinsic::umax:
7561 case Intrinsic::umin:
7562 case Intrinsic::bitreverse:
7563 case Intrinsic::bswap:
7564 case Intrinsic::sadd_sat:
7565 case Intrinsic::ssub_sat:
7566 case Intrinsic::sshl_sat:
7567 case Intrinsic::uadd_sat:
7568 case Intrinsic::usub_sat:
7569 case Intrinsic::ushl_sat:
7574 case Instruction::ICmp:
7575 case Instruction::FCmp:
7576 case Instruction::GetElementPtr:
7579 if (isa<BinaryOperator>(
I) || isa<UnaryOperator>(
I) || isa<CastInst>(
I))
7590template <
typename CallableT>
7592 const CallableT &Handle) {
7593 switch (
I->getOpcode()) {
7594 case Instruction::Store:
7599 case Instruction::Load:
7606 case Instruction::AtomicCmpXchg:
7611 case Instruction::AtomicRMW:
7616 case Instruction::Call:
7617 case Instruction::Invoke: {
7621 for (
unsigned i = 0; i < CB->
arg_size(); ++i)
7624 CB->
paramHasAttr(i, Attribute::DereferenceableOrNull)) &&
7629 case Instruction::Ret:
7630 if (
I->getFunction()->hasRetAttribute(Attribute::NoUndef) &&
7631 Handle(
I->getOperand(0)))
7634 case Instruction::Switch:
7635 if (Handle(cast<SwitchInst>(
I)->getCondition()))
7638 case Instruction::Br: {
7639 auto *BR = cast<BranchInst>(
I);
7640 if (BR->isConditional() && Handle(BR->getCondition()))
7660template <
typename CallableT>
7662 const CallableT &Handle) {
7665 switch (
I->getOpcode()) {
7667 case Instruction::UDiv:
7668 case Instruction::SDiv:
7669 case Instruction::URem:
7670 case Instruction::SRem:
7671 return Handle(
I->getOperand(1));
7688 I, [&](
const Value *V) {
return KnownPoison.
count(V); });
7702 if (
const auto *Inst = dyn_cast<Instruction>(V)) {
7706 }
else if (
const auto *Arg = dyn_cast<Argument>(V)) {
7707 if (Arg->getParent()->isDeclaration())
7710 Begin = BB->
begin();
7717 unsigned ScanLimit = 32;
7726 if (isa<DbgInfoIntrinsic>(
I))
7728 if (--ScanLimit == 0)
7732 return WellDefinedOp == V;
7752 if (isa<DbgInfoIntrinsic>(
I))
7754 if (--ScanLimit == 0)
7762 for (
const Use &
Op :
I.operands()) {
7772 if (
I.getOpcode() == Instruction::Select &&
7773 YieldsPoison.
count(
I.getOperand(1)) &&
7774 YieldsPoison.
count(
I.getOperand(2))) {
7780 if (!BB || !Visited.
insert(BB).second)
7790 return ::programUndefinedIfUndefOrPoison(Inst,
false);
7794 return ::programUndefinedIfUndefOrPoison(Inst,
true);
7801 if (
auto *
C = dyn_cast<ConstantFP>(V))
7804 if (
auto *
C = dyn_cast<ConstantDataVector>(V)) {
7805 if (!
C->getElementType()->isFloatingPointTy())
7807 for (
unsigned I = 0, E =
C->getNumElements();
I < E; ++
I) {
7808 if (
C->getElementAsAPFloat(
I).isNaN())
7814 if (isa<ConstantAggregateZero>(V))
7821 if (
auto *
C = dyn_cast<ConstantFP>(V))
7822 return !
C->isZero();
7824 if (
auto *
C = dyn_cast<ConstantDataVector>(V)) {
7825 if (!
C->getElementType()->isFloatingPointTy())
7827 for (
unsigned I = 0, E =
C->getNumElements();
I < E; ++
I) {
7828 if (
C->getElementAsAPFloat(
I).isZero())
7851 if (CmpRHS == FalseVal) {
7899 if (CmpRHS != TrueVal) {
7938 Value *
A =
nullptr, *
B =
nullptr;
7943 Value *
C =
nullptr, *
D =
nullptr;
7945 if (L.Flavor != R.Flavor)
7997 return {L.Flavor,
SPNB_NA,
false};
8004 return {L.Flavor,
SPNB_NA,
false};
8011 return {L.Flavor,
SPNB_NA,
false};
8018 return {L.Flavor,
SPNB_NA,
false};
8034 return ConstantInt::get(V->getType(), ~(*
C));
8091 if ((CmpLHS == TrueVal &&
match(FalseVal,
m_APInt(C2))) ||
8111 assert(
X &&
Y &&
"Invalid operand");
8113 auto IsNegationOf = [&](
const Value *
X,
const Value *
Y) {
8117 auto *BO = cast<BinaryOperator>(
X);
8118 if (NeedNSW && !BO->hasNoSignedWrap())
8121 auto *Zero = cast<Constant>(BO->getOperand(0));
8122 if (!AllowPoison && !Zero->isNullValue())
8129 if (IsNegationOf(
X,
Y) || IsNegationOf(
Y,
X))
8146 bool HasMismatchedZeros =
false;
8152 Value *OutputZeroVal =
nullptr;
8154 !cast<Constant>(TrueVal)->containsUndefOrPoisonElement())
8155 OutputZeroVal = TrueVal;
8157 !cast<Constant>(FalseVal)->containsUndefOrPoisonElement())
8158 OutputZeroVal = FalseVal;
8160 if (OutputZeroVal) {
8162 HasMismatchedZeros =
true;
8163 CmpLHS = OutputZeroVal;
8166 HasMismatchedZeros =
true;
8167 CmpRHS = OutputZeroVal;
8184 if (!HasMismatchedZeros)
8195 bool Ordered =
false;
8206 if (LHSSafe && RHSSafe) {
8236 if (TrueVal == CmpRHS && FalseVal == CmpLHS) {
8247 if (TrueVal == CmpLHS && FalseVal == CmpRHS) {
8272 auto MaybeSExtCmpLHS =
8276 if (
match(TrueVal, MaybeSExtCmpLHS)) {
8298 else if (
match(FalseVal, MaybeSExtCmpLHS)) {
8348 auto *Cast1 = dyn_cast<CastInst>(V1);
8352 *CastOp = Cast1->getOpcode();
8353 Type *SrcTy = Cast1->getSrcTy();
8354 if (
auto *Cast2 = dyn_cast<CastInst>(V2)) {
8356 if (*CastOp == Cast2->getOpcode() && SrcTy == Cast2->getSrcTy())
8357 return Cast2->getOperand(0);
8361 auto *
C = dyn_cast<Constant>(V2);
8368 case Instruction::ZExt:
8372 case Instruction::SExt:
8376 case Instruction::Trunc:
8379 CmpConst->
getType() == SrcTy) {
8401 CastedTo = CmpConst;
8403 unsigned ExtOp = CmpI->
isSigned() ? Instruction::SExt : Instruction::ZExt;
8407 case Instruction::FPTrunc:
8410 case Instruction::FPExt:
8413 case Instruction::FPToUI:
8416 case Instruction::FPToSI:
8419 case Instruction::UIToFP:
8422 case Instruction::SIToFP:
8435 if (CastedBack && CastedBack !=
C)
8450 CmpInst *CmpI = dyn_cast<CmpInst>(SI->getCondition());
8453 Value *TrueVal = SI->getTrueValue();
8454 Value *FalseVal = SI->getFalseValue();
8467 if (isa<FPMathOperator>(CmpI))
8475 if (CastOp && CmpLHS->
getType() != TrueVal->getType()) {
8479 if (*CastOp == Instruction::FPToSI || *CastOp == Instruction::FPToUI)
8481 return ::matchSelectPattern(Pred, FMF, CmpLHS, CmpRHS,
8482 cast<CastInst>(TrueVal)->getOperand(0),
C,
8488 if (*CastOp == Instruction::FPToSI || *CastOp == Instruction::FPToUI)
8490 return ::matchSelectPattern(Pred, FMF, CmpLHS, CmpRHS,
8491 C, cast<CastInst>(FalseVal)->getOperand(0),
8495 return ::matchSelectPattern(Pred, FMF, CmpLHS, CmpRHS, TrueVal, FalseVal,
8521 case Intrinsic::smax:
return Intrinsic::smin;
8522 case Intrinsic::smin:
return Intrinsic::smax;
8523 case Intrinsic::umax:
return Intrinsic::umin;
8524 case Intrinsic::umin:
return Intrinsic::umax;
8527 case Intrinsic::maximum:
return Intrinsic::minimum;
8528 case Intrinsic::minimum:
return Intrinsic::maximum;
8529 case Intrinsic::maxnum:
return Intrinsic::minnum;
8530 case Intrinsic::minnum:
return Intrinsic::maxnum;
8545std::pair<Intrinsic::ID, bool>
8550 bool AllCmpSingleUse =
true;
8553 if (
all_of(VL, [&SelectPattern, &AllCmpSingleUse](
Value *
I) {
8559 !
I->getType()->isIntOrIntVectorTy())
8562 SelectPattern.
Flavor != CurrentPattern.Flavor)
8564 SelectPattern = CurrentPattern;
8569 switch (SelectPattern.
Flavor) {
8571 return {Intrinsic::smin, AllCmpSingleUse};
8573 return {Intrinsic::umin, AllCmpSingleUse};
8575 return {Intrinsic::smax, AllCmpSingleUse};
8577 return {Intrinsic::umax, AllCmpSingleUse};
8590 if (
P->getNumIncomingValues() != 2)
8593 for (
unsigned i = 0; i != 2; ++i) {
8594 Value *L =
P->getIncomingValue(i);
8595 Value *R =
P->getIncomingValue(!i);
8596 auto *LU = dyn_cast<BinaryOperator>(L);
8599 unsigned Opcode = LU->getOpcode();
8605 case Instruction::LShr:
8606 case Instruction::AShr:
8607 case Instruction::Shl:
8608 case Instruction::Add:
8609 case Instruction::Sub:
8610 case Instruction::And:
8611 case Instruction::Or:
8612 case Instruction::Mul:
8613 case Instruction::FMul: {
8614 Value *LL = LU->getOperand(0);
8615 Value *LR = LU->getOperand(1);
8645 P = dyn_cast<PHINode>(
I->getOperand(0));
8647 P = dyn_cast<PHINode>(
I->getOperand(1));
8668 return !
C->isNegative();
8680 const APInt *CLHS, *CRHS;
8683 return CLHS->
sle(*CRHS);
8721 const APInt *CLHS, *CRHS;
8724 return CLHS->
ule(*CRHS);
8733static std::optional<bool>
8738 return std::nullopt;
8745 return std::nullopt;
8752 return std::nullopt;
8759 return std::nullopt;
8766 return std::nullopt;
8773static std::optional<bool>
8781 return std::nullopt;
8798 return std::nullopt;
8815 LHSIsTrue ?
LHS->getPredicate() :
LHS->getInversePredicate();
8839 const APInt *LC, *RC;
8844 if (L0 == R0 && L1 == R1)
8852 return LPred == RPred;
8857 return std::nullopt;
8864static std::optional<bool>
8869 assert((
LHS->getOpcode() == Instruction::And ||
8870 LHS->getOpcode() == Instruction::Or ||
8871 LHS->getOpcode() == Instruction::Select) &&
8872 "Expected LHS to be 'and', 'or', or 'select'.");
8879 const Value *ALHS, *ARHS;
8884 ALHS, RHSPred, RHSOp0, RHSOp1,
DL, LHSIsTrue,
Depth + 1))
8887 ARHS, RHSPred, RHSOp0, RHSOp1,
DL, LHSIsTrue,
Depth + 1))
8889 return std::nullopt;
8891 return std::nullopt;
8900 return std::nullopt;
8905 return std::nullopt;
8908 "Expected integer type only!");
8912 LHSIsTrue = !LHSIsTrue;
8923 if ((LHSI->getOpcode() == Instruction::And ||
8924 LHSI->getOpcode() == Instruction::Or ||
8925 LHSI->getOpcode() == Instruction::Select))
8929 return std::nullopt;
8934 bool LHSIsTrue,
unsigned Depth) {
8940 bool InvertRHS =
false;
8947 if (
const ICmpInst *RHSCmp = dyn_cast<ICmpInst>(
RHS)) {
8949 LHS, RHSCmp->getPredicate(), RHSCmp->getOperand(0),
8950 RHSCmp->getOperand(1),
DL, LHSIsTrue,
Depth))
8951 return InvertRHS ? !*Implied : *Implied;
8952 return std::nullopt;
8956 return std::nullopt;
8960 const Value *RHS1, *RHS2;
8962 if (std::optional<bool> Imp =
8966 if (std::optional<bool> Imp =
8972 if (std::optional<bool> Imp =
8976 if (std::optional<bool> Imp =
8982 return std::nullopt;
8987static std::pair<Value *, bool>
8989 if (!ContextI || !ContextI->
getParent())
8990 return {
nullptr,
false};
8997 return {
nullptr,
false};
9003 return {
nullptr,
false};
9006 if (TrueBB == FalseBB)
9007 return {
nullptr,
false};
9009 assert((TrueBB == ContextBB || FalseBB == ContextBB) &&
9010 "Predecessor block does not point to successor?");
9013 return {PredCond, TrueBB == ContextBB};
9019 assert(
Cond->getType()->isIntOrIntVectorTy(1) &&
"Condition must be bool");
9023 return std::nullopt;
9035 return std::nullopt;
9040 bool PreferSignedRange) {
9041 unsigned Width =
Lower.getBitWidth();
9044 case Instruction::Add:
9053 if (PreferSignedRange && HasNSW && HasNUW)
9059 }
else if (HasNSW) {
9060 if (
C->isNegative()) {
9073 case Instruction::And:
9084 case Instruction::Or:
9090 case Instruction::AShr:
9096 unsigned ShiftAmount = Width - 1;
9097 if (!
C->isZero() && IIQ.
isExact(&BO))
9098 ShiftAmount =
C->countr_zero();
9099 if (
C->isNegative()) {
9102 Upper =
C->ashr(ShiftAmount) + 1;
9105 Lower =
C->ashr(ShiftAmount);
9111 case Instruction::LShr:
9117 unsigned ShiftAmount = Width - 1;
9118 if (!
C->isZero() && IIQ.
isExact(&BO))
9119 ShiftAmount =
C->countr_zero();
9120 Lower =
C->lshr(ShiftAmount);
9125 case Instruction::Shl:
9132 if (
C->isNegative()) {
9134 unsigned ShiftAmount =
C->countl_one() - 1;
9135 Lower =
C->shl(ShiftAmount);
9139 unsigned ShiftAmount =
C->countl_zero() - 1;
9141 Upper =
C->shl(ShiftAmount) + 1;
9160 case Instruction::SDiv:
9164 if (
C->isAllOnes()) {
9169 }
else if (
C->countl_zero() < Width - 1) {
9180 if (
C->isMinSignedValue()) {
9192 case Instruction::UDiv:
9202 case Instruction::SRem:
9208 if (
C->isNegative()) {
9219 case Instruction::URem:
9237 case Intrinsic::ctpop:
9238 case Intrinsic::ctlz:
9239 case Intrinsic::cttz:
9242 APInt(Width, Width + 1));
9243 case Intrinsic::uadd_sat:
9249 case Intrinsic::sadd_sat:
9252 if (
C->isNegative())
9263 case Intrinsic::usub_sat:
9273 case Intrinsic::ssub_sat:
9275 if (
C->isNegative())
9285 if (
C->isNegative())
9296 case Intrinsic::umin:
9297 case Intrinsic::umax:
9298 case Intrinsic::smin:
9299 case Intrinsic::smax:
9305 case Intrinsic::umin:
9307 case Intrinsic::umax:
9309 case Intrinsic::smin:
9312 case Intrinsic::smax:
9319 case Intrinsic::abs:
9328 case Intrinsic::vscale:
9336 return ConstantRange::getFull(Width);
9341 unsigned BitWidth = SI.getType()->getScalarSizeInBits();
9345 return ConstantRange::getFull(
BitWidth);
9368 return ConstantRange::getFull(
BitWidth);
9382 return ConstantRange::getFull(
BitWidth);
9389 unsigned BitWidth =
I->getType()->getScalarSizeInBits();
9390 if (!
I->getOperand(0)->getType()->getScalarType()->isHalfTy())
9392 if (isa<FPToSIInst>(
I) &&
BitWidth >= 17) {
9397 if (isa<FPToUIInst>(
I) &&
BitWidth >= 16) {
9408 assert(V->getType()->isIntOrIntVectorTy() &&
"Expected integer instruction");
9411 return ConstantRange::getFull(V->getType()->getScalarSizeInBits());
9416 unsigned BitWidth = V->getType()->getScalarSizeInBits();
9418 if (
auto *VC = dyn_cast<ConstantDataVector>(V)) {
9420 for (
unsigned ElemIdx = 0, NElem = VC->getNumElements(); ElemIdx < NElem;
9422 CR = CR.
unionWith(VC->getElementAsAPInt(ElemIdx));
9428 if (
auto *BO = dyn_cast<BinaryOperator>(V)) {
9434 }
else if (
auto *II = dyn_cast<IntrinsicInst>(V))
9436 else if (
auto *SI = dyn_cast<SelectInst>(V)) {
9438 SI->getTrueValue(), ForSigned, UseInstrInfo, AC, CtxI, DT,
Depth + 1);
9440 SI->getFalseValue(), ForSigned, UseInstrInfo, AC, CtxI, DT,
Depth + 1);
9443 }
else if (isa<FPToUIInst>(V) || isa<FPToSIInst>(V)) {
9449 }
else if (
const auto *
A = dyn_cast<Argument>(V))
9450 if (std::optional<ConstantRange> Range =
A->getRange())
9453 if (
auto *
I = dyn_cast<Instruction>(V)) {
9454 if (
auto *Range = IIQ.
getMetadata(
I, LLVMContext::MD_range))
9457 if (
const auto *CB = dyn_cast<CallBase>(V))
9458 if (std::optional<ConstantRange> Range = CB->getRange())
9469 "Got assumption for the wrong function!");
9470 assert(
I->getCalledFunction()->getIntrinsicID() == Intrinsic::assume &&
9471 "must be an assume intrinsic");
9475 Value *Arg =
I->getArgOperand(0);
9476 ICmpInst *Cmp = dyn_cast<ICmpInst>(Arg);
9478 if (!Cmp || Cmp->getOperand(0) != V)
9483 UseInstrInfo, AC,
I, DT,
Depth + 1);
9496 if (isa<Argument>(V) || isa<GlobalValue>(V)) {
9498 }
else if (
auto *
I = dyn_cast<Instruction>(V)) {
9504 if (isa<Instruction>(
Op) || isa<Argument>(
Op))
9512 auto AddAffected = [&InsertAffected](
Value *V) {
9527 while (!Worklist.
empty()) {
9529 if (!Visited.
insert(V).second)
9552 AddCmpOperands(
A,
B);
9596 AddCmpOperands(
A,
B);
9606 }
else if (
match(V, m_Intrinsic<Intrinsic::is_fpclass>(
m_Value(
A),
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
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...
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.
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 isModifyingBinopOfNonZero(const Value *V1, const Value *V2, unsigned Depth, const SimplifyQuery &Q)
Return true if V1 == (binop V2, X), where X is known non-zero.
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 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 isNonEqualMul(const Value *V1, const Value *V2, 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 unsigned ComputeNumSignBits(const Value *V, const APInt &DemandedElts, unsigned Depth, const SimplifyQuery &Q)
static bool includesPoison(UndefPoisonKind Kind)
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 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 std::optional< bool > isImpliedCondCommonOperandWithConstants(CmpInst::Predicate LPred, const APInt &LC, CmpInst::Predicate RPred, const APInt &RC)
Return true if "icmp LPred X, LC" implies "icmp RPred X, RC" is true.
static void setLimitForFPToI(const Instruction *I, APInt &Lower, APInt &Upper)
static bool isKnownNonEqual(const Value *V1, const Value *V2, unsigned Depth, const SimplifyQuery &Q)
Return true if it is known that V1 != V2.
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 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 bool isNonEqualSelect(const Value *V1, const Value *V2, unsigned Depth, const SimplifyQuery &Q)
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 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 isNonEqualPHIs(const PHINode *PN1, const PHINode *PN2, unsigned Depth, const SimplifyQuery &Q)
static bool isNonEqualShl(const Value *V1, const Value *V2, 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 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.
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
Intrinsic::ID getIntrinsicID() const
Returns the intrinsic ID of the intrinsic called or Intrinsic::not_intrinsic if the called function i...
iterator_range< User::op_iterator > args()
Iteration adapter for range-for loops.
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.
ConstantRange difference(const ConstantRange &CR) const
Subtract the specified range from this range (aka relative complement of the sets).
bool isEmptySet() const
Return true if this set contains no members.
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.
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
Module * getParent()
Get the module that this global value is contained inside of...
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, BasicBlock::iterator InsertBefore)
bool hasNoUnsignedWrap() const LLVM_READONLY
Determine whether the no unsigned wrap flag is set.
bool isLifetimeStartOrEnd() const LLVM_READONLY
Return true if the instruction is a llvm.lifetime.start or llvm.lifetime.end marker.
bool hasNoSignedWrap() const LLVM_READONLY
Determine whether the no signed wrap flag is set.
const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
const BasicBlock * getParent() const
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.
A wrapper class for inspecting calls to intrinsic functions.
Intrinsic::ID getIntrinsicID() const
Return the intrinsic ID of this intrinsic.
This is an important class for using LLVM in a threaded context.
An instruction for reading from memory.
Value * getPointerOperand()
Align getAlign() const
Return the alignment of the access that is being performed.
bool isLoopHeader(const BlockT *BB) const
LoopT * getLoopFor(const BlockT *BB) const
Return the inner most loop that BB lives in.
Represents a single loop in the control flow graph.
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
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
bool isDroppable() const
A droppable user is a user for which uses can be dropped without affecting correctness and should be ...
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
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.
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.
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.
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)
CastOperator_match< OpTy, Instruction::Trunc > m_Trunc(const OpTy &Op)
Matches Trunc.
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.
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...
bool impliesPoison(const Value *ValAssumedPoison, const Value *V)
Return true if V is poison given that ValAssumedPoison is already poison.
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 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.
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.
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 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