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()) {
1122 auto *SrcVecTy = dyn_cast<FixedVectorType>(SrcTy);
1123 if (!SrcVecTy || !SrcVecTy->getElementType()->isIntegerTy() ||
1124 !
I->getType()->isIntOrIntVectorTy() ||
1125 isa<ScalableVectorType>(
I->getType()))
1130 unsigned SubBitWidth = SrcVecTy->getScalarSizeInBits();
1147 unsigned SubScale =
BitWidth / SubBitWidth;
1149 for (
unsigned i = 0; i != NumElts; ++i) {
1150 if (DemandedElts[i])
1151 SubDemandedElts.
setBit(i * SubScale);
1155 for (
unsigned i = 0; i != SubScale; ++i) {
1159 Known.
insertBits(KnownSrc, ShiftElt * SubBitWidth);
1164 case Instruction::SExt: {
1166 unsigned SrcBitWidth =
I->getOperand(0)->getType()->getScalarSizeInBits();
1168 Known = Known.
trunc(SrcBitWidth);
1175 case Instruction::Shl: {
1179 bool ShAmtNonZero) {
1180 return KnownBits::shl(KnownVal, KnownAmt, NUW, NSW, ShAmtNonZero);
1190 case Instruction::LShr: {
1191 bool Exact = Q.
IIQ.
isExact(cast<BinaryOperator>(
I));
1193 bool ShAmtNonZero) {
1204 case Instruction::AShr: {
1205 bool Exact = Q.
IIQ.
isExact(cast<BinaryOperator>(
I));
1207 bool ShAmtNonZero) {
1214 case Instruction::Sub: {
1218 DemandedElts, Known, Known2,
Depth, Q);
1221 case Instruction::Add: {
1225 DemandedElts, Known, Known2,
Depth, Q);
1228 case Instruction::SRem:
1234 case Instruction::URem:
1239 case Instruction::Alloca:
1242 case Instruction::GetElementPtr: {
1251 for (
unsigned i = 1, e =
I->getNumOperands(); i != e; ++i, ++GTI) {
1267 "Access to structure field must be known at compile time");
1272 unsigned Idx = cast<ConstantInt>(
Index)->getZExtValue();
1275 AccConstIndices +=
Offset;
1286 unsigned IndexBitWidth =
Index->getType()->getScalarSizeInBits();
1300 APInt ScalingFactor(IndexBitWidth, TypeSizeInBytes);
1301 IndexConst *= ScalingFactor;
1318 true,
false,
false, Known, IndexBits);
1323 true,
false,
false, Known,
Index);
1327 case Instruction::PHI: {
1330 Value *R =
nullptr, *L =
nullptr;
1340 if ((Opcode == Instruction::LShr || Opcode == Instruction::AShr ||
1341 Opcode == Instruction::Shl) &&
1356 case Instruction::Shl:
1360 case Instruction::LShr:
1365 case Instruction::AShr:
1376 if (Opcode == Instruction::Add ||
1377 Opcode == Instruction::Sub ||
1378 Opcode == Instruction::And ||
1379 Opcode == Instruction::Or ||
1380 Opcode == Instruction::Mul) {
1387 unsigned OpNum =
P->getOperand(0) == R ? 0 : 1;
1388 Instruction *RInst =
P->getIncomingBlock(OpNum)->getTerminator();
1389 Instruction *LInst =
P->getIncomingBlock(1-OpNum)->getTerminator();
1404 auto *OverflowOp = dyn_cast<OverflowingBinaryOperator>(BO);
1415 if (Opcode == Instruction::Add) {
1424 else if (Opcode == Instruction::Sub && BO->
getOperand(0) ==
I) {
1432 else if (Opcode == Instruction::Mul && Known2.
isNonNegative() &&
1442 if (
P->getNumIncomingValues() == 0)
1449 if (isa_and_nonnull<UndefValue>(
P->hasConstantValue()))
1454 for (
unsigned u = 0, e =
P->getNumIncomingValues(); u < e; ++u) {
1455 Value *IncValue =
P->getIncomingValue(u);
1457 if (IncValue ==
P)
continue;
1464 RecQ.
CxtI =
P->getIncomingBlock(u)->getTerminator();
1485 if ((TrueSucc ==
P->getParent()) != (FalseSucc ==
P->getParent())) {
1487 if (FalseSucc ==
P->getParent())
1501 Known2 = KnownUnion;
1515 case Instruction::Call:
1516 case Instruction::Invoke: {
1524 const auto *CB = cast<CallBase>(
I);
1526 if (std::optional<ConstantRange> Range = CB->getRange())
1527 Known = Known.
unionWith(Range->toKnownBits());
1529 if (
const Value *RV = CB->getReturnedArgOperand()) {
1530 if (RV->getType() ==
I->getType()) {
1542 switch (II->getIntrinsicID()) {
1544 case Intrinsic::abs: {
1546 bool IntMinIsPoison =
match(II->getArgOperand(1),
m_One());
1547 Known = Known2.
abs(IntMinIsPoison);
1550 case Intrinsic::bitreverse:
1555 case Intrinsic::bswap:
1560 case Intrinsic::ctlz: {
1566 PossibleLZ = std::min(PossibleLZ,
BitWidth - 1);
1571 case Intrinsic::cttz: {
1577 PossibleTZ = std::min(PossibleTZ,
BitWidth - 1);
1582 case Intrinsic::ctpop: {
1593 case Intrinsic::fshr:
1594 case Intrinsic::fshl: {
1601 if (II->getIntrinsicID() == Intrinsic::fshr)
1614 case Intrinsic::uadd_sat:
1619 case Intrinsic::usub_sat:
1624 case Intrinsic::sadd_sat:
1629 case Intrinsic::ssub_sat:
1636 case Intrinsic::vector_reduce_and:
1637 case Intrinsic::vector_reduce_or:
1638 case Intrinsic::vector_reduce_umax:
1639 case Intrinsic::vector_reduce_umin:
1640 case Intrinsic::vector_reduce_smax:
1641 case Intrinsic::vector_reduce_smin:
1644 case Intrinsic::vector_reduce_xor: {
1649 auto *VecTy = cast<VectorType>(
I->getOperand(0)->getType());
1651 bool EvenCnt = VecTy->getElementCount().isKnownEven();
1655 if (VecTy->isScalableTy() || EvenCnt)
1659 case Intrinsic::umin:
1664 case Intrinsic::umax:
1669 case Intrinsic::smin:
1674 case Intrinsic::smax:
1679 case Intrinsic::ptrmask: {
1682 const Value *Mask =
I->getOperand(1);
1683 Known2 =
KnownBits(Mask->getType()->getScalarSizeInBits());
1689 case Intrinsic::x86_sse42_crc32_64_64:
1692 case Intrinsic::riscv_vsetvli:
1693 case Intrinsic::riscv_vsetvlimax: {
1694 bool HasAVL = II->getIntrinsicID() == Intrinsic::riscv_vsetvli;
1697 cast<ConstantInt>(II->getArgOperand(HasAVL))->getZExtValue());
1699 cast<ConstantInt>(II->getArgOperand(1 + HasAVL))->getZExtValue());
1708 if (
auto *CI = dyn_cast<ConstantInt>(II->getArgOperand(0)))
1709 MaxVL = std::min(MaxVL, CI->getZExtValue());
1711 unsigned KnownZeroFirstBit =
Log2_32(MaxVL) + 1;
1716 case Intrinsic::vscale: {
1717 if (!II->getParent() || !II->getFunction())
1727 case Instruction::ShuffleVector: {
1728 auto *Shuf = dyn_cast<ShuffleVectorInst>(
I);
1736 APInt DemandedLHS, DemandedRHS;
1743 if (!!DemandedLHS) {
1744 const Value *
LHS = Shuf->getOperand(0);
1750 if (!!DemandedRHS) {
1751 const Value *
RHS = Shuf->getOperand(1);
1757 case Instruction::InsertElement: {
1758 if (isa<ScalableVectorType>(
I->getType())) {
1762 const Value *Vec =
I->getOperand(0);
1763 const Value *Elt =
I->getOperand(1);
1764 auto *CIdx = dyn_cast<ConstantInt>(
I->getOperand(2));
1766 APInt DemandedVecElts = DemandedElts;
1767 bool NeedsElt =
true;
1769 if (CIdx && CIdx->getValue().ult(NumElts)) {
1770 DemandedVecElts.
clearBit(CIdx->getZExtValue());
1771 NeedsElt = DemandedElts[CIdx->getZExtValue()];
1783 if (!DemandedVecElts.
isZero()) {
1789 case Instruction::ExtractElement: {
1792 const Value *Vec =
I->getOperand(0);
1794 auto *CIdx = dyn_cast<ConstantInt>(
Idx);
1795 if (isa<ScalableVectorType>(Vec->
getType())) {
1800 unsigned NumElts = cast<FixedVectorType>(Vec->
getType())->getNumElements();
1802 if (CIdx && CIdx->getValue().ult(NumElts))
1807 case Instruction::ExtractValue:
1808 if (
IntrinsicInst *II = dyn_cast<IntrinsicInst>(
I->getOperand(0))) {
1812 switch (II->getIntrinsicID()) {
1814 case Intrinsic::uadd_with_overflow:
1815 case Intrinsic::sadd_with_overflow:
1817 true, II->getArgOperand(0), II->getArgOperand(1),
false,
1818 false, DemandedElts, Known, Known2,
Depth, Q);
1820 case Intrinsic::usub_with_overflow:
1821 case Intrinsic::ssub_with_overflow:
1823 false, II->getArgOperand(0), II->getArgOperand(1),
false,
1824 false, DemandedElts, Known, Known2,
Depth, Q);
1826 case Intrinsic::umul_with_overflow:
1827 case Intrinsic::smul_with_overflow:
1829 DemandedElts, Known, Known2,
Depth, Q);
1835 case Instruction::Freeze:
1879 if (!DemandedElts) {
1885 assert(V &&
"No Value?");
1889 Type *Ty = V->getType();
1893 "Not integer or pointer type!");
1895 if (
auto *FVTy = dyn_cast<FixedVectorType>(Ty)) {
1897 FVTy->getNumElements() == DemandedElts.
getBitWidth() &&
1898 "DemandedElt width should equal the fixed vector number of elements");
1901 "DemandedElt width should be 1 for scalars or scalable vectors");
1907 "V and Known should have same BitWidth");
1910 "V and Known should have same BitWidth");
1921 if (isa<ConstantPointerNull>(V) || isa<ConstantAggregateZero>(V)) {
1928 assert(!isa<ScalableVectorType>(V->getType()));
1932 for (
unsigned i = 0, e = CDV->getNumElements(); i != e; ++i) {
1933 if (!DemandedElts[i])
1935 APInt Elt = CDV->getElementAsAPInt(i);
1944 if (
const auto *CV = dyn_cast<ConstantVector>(V)) {
1945 assert(!isa<ScalableVectorType>(V->getType()));
1949 for (
unsigned i = 0, e = CV->getNumOperands(); i != e; ++i) {
1950 if (!DemandedElts[i])
1953 if (isa<PoisonValue>(Element))
1955 auto *ElementCI = dyn_cast_or_null<ConstantInt>(Element);
1960 const APInt &Elt = ElementCI->getValue();
1973 if (isa<UndefValue>(V))
1978 assert(!isa<ConstantData>(V) &&
"Unhandled constant data!");
1980 if (
const auto *
A = dyn_cast<Argument>(V))
1981 if (std::optional<ConstantRange> Range =
A->getRange())
1982 Known = Range->toKnownBits();
1990 if (
const GlobalAlias *GA = dyn_cast<GlobalAlias>(V)) {
1991 if (!GA->isInterposable())
1996 if (
const Operator *
I = dyn_cast<Operator>(V))
1998 else if (
const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
1999 if (std::optional<ConstantRange> CR = GV->getAbsoluteSymbolRange())
2000 Known = CR->toKnownBits();
2004 if (isa<PointerType>(V->getType())) {
2005 Align Alignment = V->getPointerAlignment(Q.
DL);
2015 assert((Known.
Zero & Known.
One) == 0 &&
"Bits known to be one AND zero?");
2023 Value *Start =
nullptr, *Step =
nullptr;
2029 if (U.get() == Start) {
2045 case Instruction::Mul:
2050 case Instruction::SDiv:
2056 case Instruction::UDiv:
2062 case Instruction::Shl:
2064 case Instruction::AShr:
2068 case Instruction::LShr:
2083 if (isa<Constant>(V))
2087 if (OrZero && V->getType()->getScalarSizeInBits() == 1)
2090 auto *
I = dyn_cast<Instruction>(V);
2097 return F->hasFnAttribute(Attribute::VScaleRange);
2114 switch (
I->getOpcode()) {
2115 case Instruction::ZExt:
2117 case Instruction::Trunc:
2119 case Instruction::Shl:
2123 case Instruction::LShr:
2124 if (OrZero || Q.
IIQ.
isExact(cast<BinaryOperator>(
I)))
2127 case Instruction::UDiv:
2131 case Instruction::Mul:
2135 case Instruction::And:
2146 case Instruction::Add: {
2152 if (
match(
I->getOperand(0),
2156 if (
match(
I->getOperand(1),
2161 unsigned BitWidth = V->getType()->getScalarSizeInBits();
2170 if ((~(LHSBits.
Zero & RHSBits.
Zero)).isPowerOf2())
2183 case Instruction::Select:
2186 case Instruction::PHI: {
2190 auto *PN = cast<PHINode>(
I);
2207 RecQ.CxtI = PN->getIncomingBlock(U)->getTerminator();
2208 return isKnownToBeAPowerOfTwo(U.get(), OrZero, NewDepth, RecQ);
2211 case Instruction::Invoke:
2212 case Instruction::Call: {
2213 if (
auto *II = dyn_cast<IntrinsicInst>(
I)) {
2214 switch (II->getIntrinsicID()) {
2215 case Intrinsic::umax:
2216 case Intrinsic::smax:
2217 case Intrinsic::umin:
2218 case Intrinsic::smin:
2223 case Intrinsic::bitreverse:
2224 case Intrinsic::bswap:
2226 case Intrinsic::fshr:
2227 case Intrinsic::fshl:
2229 if (II->getArgOperand(0) == II->getArgOperand(1))
2253 F =
I->getFunction();
2255 if (!
GEP->isInBounds() ||
2260 assert(
GEP->getType()->isPointerTy() &&
"We only support plain pointer GEP");
2271 GTI != GTE; ++GTI) {
2273 if (
StructType *STy = GTI.getStructTypeOrNull()) {
2274 ConstantInt *OpC = cast<ConstantInt>(GTI.getOperand());
2278 if (ElementOffset > 0)
2284 if (GTI.getSequentialElementStride(Q.
DL).isZero())
2289 if (
ConstantInt *OpC = dyn_cast<ConstantInt>(GTI.getOperand())) {
2313 assert(!isa<Constant>(V) &&
"Called for constant?");
2318 unsigned NumUsesExplored = 0;
2319 for (
const auto *U : V->users()) {
2327 if (
const auto *CB = dyn_cast<CallBase>(U))
2328 if (
auto *CalledFunc = CB->getCalledFunction())
2329 for (
const Argument &Arg : CalledFunc->args())
2330 if (CB->getArgOperand(Arg.getArgNo()) == V &&
2331 Arg.hasNonNullAttr(
false) &&
2339 V->getType()->getPointerAddressSpace()) &&
2357 NonNullIfTrue =
true;
2359 NonNullIfTrue =
false;
2365 for (
const auto *CmpU : U->users()) {
2367 if (Visited.
insert(CmpU).second)
2370 while (!WorkList.
empty()) {
2379 for (
const auto *CurrU : Curr->users())
2380 if (Visited.
insert(CurrU).second)
2385 if (
const BranchInst *BI = dyn_cast<BranchInst>(Curr)) {
2386 assert(BI->isConditional() &&
"uses a comparison!");
2389 BI->getSuccessor(NonNullIfTrue ? 0 : 1);
2393 }
else if (NonNullIfTrue &&
isGuard(Curr) &&
2394 DT->
dominates(cast<Instruction>(Curr), CtxI)) {
2408 const unsigned NumRanges = Ranges->getNumOperands() / 2;
2410 for (
unsigned i = 0; i < NumRanges; ++i) {
2412 mdconst::extract<ConstantInt>(Ranges->getOperand(2 * i + 0));
2414 mdconst::extract<ConstantInt>(Ranges->getOperand(2 * i + 1));
2416 if (Range.contains(
Value))
2426 Value *Start =
nullptr, *Step =
nullptr;
2427 const APInt *StartC, *StepC;
2433 case Instruction::Add:
2439 case Instruction::Mul:
2442 case Instruction::Shl:
2444 case Instruction::AShr:
2445 case Instruction::LShr:
2454 Value *
Y,
bool NSW,
bool NUW) {
2499 if (
auto *
C = dyn_cast<Constant>(
X))
2503 return ::isKnownNonEqual(
X,
Y,
Depth, Q);
2508 Value *
Y,
bool NSW,
bool NUW) {
2537 auto ShiftOp = [&](
const APInt &Lhs,
const APInt &Rhs) {
2538 switch (
I->getOpcode()) {
2539 case Instruction::Shl:
2540 return Lhs.
shl(Rhs);
2541 case Instruction::LShr:
2542 return Lhs.
lshr(Rhs);
2543 case Instruction::AShr:
2544 return Lhs.
ashr(Rhs);
2550 auto InvShiftOp = [&](
const APInt &Lhs,
const APInt &Rhs) {
2551 switch (
I->getOpcode()) {
2552 case Instruction::Shl:
2553 return Lhs.
lshr(Rhs);
2554 case Instruction::LShr:
2555 case Instruction::AShr:
2556 return Lhs.
shl(Rhs);
2569 if (MaxShift.
uge(NumBits))
2572 if (!ShiftOp(KnownVal.
One, MaxShift).isZero())
2577 if (InvShiftOp(KnownVal.
Zero, NumBits - MaxShift)
2586 const APInt &DemandedElts,
2589 switch (
I->getOpcode()) {
2590 case Instruction::Alloca:
2592 return I->getType()->getPointerAddressSpace() == 0;
2593 case Instruction::GetElementPtr:
2594 if (
I->getType()->isPointerTy())
2597 case Instruction::BitCast: {
2625 Type *FromTy =
I->getOperand(0)->getType();
2630 case Instruction::IntToPtr:
2634 if (!isa<ScalableVectorType>(
I->getType()) &&
2639 case Instruction::PtrToInt:
2642 if (!isa<ScalableVectorType>(
I->getType()) &&
2647 case Instruction::Trunc:
2649 if (
auto *TI = dyn_cast<TruncInst>(
I))
2650 if (TI->hasNoSignedWrap() || TI->hasNoUnsignedWrap())
2654 case Instruction::Sub:
2657 case Instruction::Or:
2661 case Instruction::SExt:
2662 case Instruction::ZExt:
2666 case Instruction::Shl: {
2681 case Instruction::LShr:
2682 case Instruction::AShr: {
2697 case Instruction::UDiv:
2698 case Instruction::SDiv: {
2701 if (cast<PossiblyExactOperator>(
I)->isExact())
2713 if (
I->getOpcode() == Instruction::SDiv) {
2715 XKnown = XKnown.
abs(
false);
2716 YKnown = YKnown.
abs(
false);
2722 return XUgeY && *XUgeY;
2724 case Instruction::Add: {
2729 auto *BO = cast<OverflowingBinaryOperator>(
I);
2734 case Instruction::Mul: {
2740 case Instruction::Select: {
2747 auto SelectArmIsNonZero = [&](
bool IsTrueArm) {
2749 Op = IsTrueArm ?
I->getOperand(1) :
I->getOperand(2);
2762 Pred = ICmpInst::getInversePredicate(Pred);
2767 if (SelectArmIsNonZero(
true) &&
2768 SelectArmIsNonZero(
false))
2772 case Instruction::PHI: {
2773 auto *PN = cast<PHINode>(
I);
2783 RecQ.CxtI = PN->getIncomingBlock(U)->getTerminator();
2785 ICmpInst::Predicate Pred;
2787 BasicBlock *TrueSucc, *FalseSucc;
2788 if (match(RecQ.CxtI,
2789 m_Br(m_c_ICmp(Pred, m_Specific(U.get()), m_Value(X)),
2790 m_BasicBlock(TrueSucc), m_BasicBlock(FalseSucc)))) {
2792 if ((TrueSucc == PN->getParent()) != (FalseSucc == PN->getParent())) {
2794 if (FalseSucc == PN->getParent())
2795 Pred = CmpInst::getInversePredicate(Pred);
2796 if (cmpExcludesZero(Pred, X))
2804 case Instruction::InsertElement: {
2805 if (isa<ScalableVectorType>(
I->getType()))
2808 const Value *Vec =
I->getOperand(0);
2809 const Value *Elt =
I->getOperand(1);
2810 auto *CIdx = dyn_cast<ConstantInt>(
I->getOperand(2));
2813 APInt DemandedVecElts = DemandedElts;
2814 bool SkipElt =
false;
2816 if (CIdx && CIdx->getValue().ult(NumElts)) {
2817 DemandedVecElts.
clearBit(CIdx->getZExtValue());
2818 SkipElt = !DemandedElts[CIdx->getZExtValue()];
2824 (DemandedVecElts.
isZero() ||
2827 case Instruction::ExtractElement:
2828 if (
const auto *EEI = dyn_cast<ExtractElementInst>(
I)) {
2829 const Value *Vec = EEI->getVectorOperand();
2830 const Value *
Idx = EEI->getIndexOperand();
2831 auto *CIdx = dyn_cast<ConstantInt>(
Idx);
2832 if (
auto *VecTy = dyn_cast<FixedVectorType>(Vec->
getType())) {
2833 unsigned NumElts = VecTy->getNumElements();
2835 if (CIdx && CIdx->getValue().ult(NumElts))
2841 case Instruction::ShuffleVector: {
2842 auto *Shuf = dyn_cast<ShuffleVectorInst>(
I);
2845 APInt DemandedLHS, DemandedRHS;
2851 return (DemandedRHS.
isZero() ||
2856 case Instruction::Freeze:
2860 case Instruction::Load: {
2861 auto *LI = cast<LoadInst>(
I);
2864 if (
auto *PtrT = dyn_cast<PointerType>(
I->getType())) {
2877 case Instruction::ExtractValue: {
2883 case Instruction::Add:
2888 case Instruction::Sub:
2891 case Instruction::Mul:
2900 case Instruction::Call:
2901 case Instruction::Invoke: {
2902 const auto *Call = cast<CallBase>(
I);
2903 if (
I->getType()->isPointerTy()) {
2904 if (Call->isReturnNonNull())
2911 if (std::optional<ConstantRange> Range = Call->getRange()) {
2912 const APInt ZeroValue(Range->getBitWidth(), 0);
2913 if (!Range->contains(ZeroValue))
2916 if (
const Value *RV = Call->getReturnedArgOperand())
2921 if (
auto *II = dyn_cast<IntrinsicInst>(
I)) {
2922 switch (II->getIntrinsicID()) {
2923 case Intrinsic::sshl_sat:
2924 case Intrinsic::ushl_sat:
2925 case Intrinsic::abs:
2926 case Intrinsic::bitreverse:
2927 case Intrinsic::bswap:
2928 case Intrinsic::ctpop:
2932 case Intrinsic::ssub_sat:
2934 II->getArgOperand(0), II->getArgOperand(1));
2935 case Intrinsic::sadd_sat:
2937 II->getArgOperand(0), II->getArgOperand(1),
2940 case Intrinsic::vector_reduce_or:
2941 case Intrinsic::vector_reduce_umax:
2942 case Intrinsic::vector_reduce_umin:
2943 case Intrinsic::vector_reduce_smax:
2944 case Intrinsic::vector_reduce_smin:
2946 case Intrinsic::umax:
2947 case Intrinsic::uadd_sat:
2950 case Intrinsic::smax: {
2953 auto IsNonZero = [&](
Value *
Op, std::optional<bool> &OpNonZero,
2955 if (!OpNonZero.has_value())
2956 OpNonZero = OpKnown.isNonZero() ||
2961 std::optional<bool> Op0NonZero, Op1NonZero;
2965 IsNonZero(II->getArgOperand(1), Op1NonZero, Op1Known))
2970 IsNonZero(II->getArgOperand(0), Op0NonZero, Op0Known))
2972 return IsNonZero(II->getArgOperand(1), Op1NonZero, Op1Known) &&
2973 IsNonZero(II->getArgOperand(0), Op0NonZero, Op0Known);
2975 case Intrinsic::smin: {
2991 case Intrinsic::umin:
2994 case Intrinsic::cttz:
2997 case Intrinsic::ctlz:
3000 case Intrinsic::fshr:
3001 case Intrinsic::fshl:
3003 if (II->getArgOperand(0) == II->getArgOperand(1))
3006 case Intrinsic::vscale:
3008 case Intrinsic::experimental_get_vector_length:
3022 return Known.
One != 0;
3033 Type *Ty = V->getType();
3038 if (
auto *FVTy = dyn_cast<FixedVectorType>(Ty)) {
3040 FVTy->getNumElements() == DemandedElts.
getBitWidth() &&
3041 "DemandedElt width should equal the fixed vector number of elements");
3044 "DemandedElt width should be 1 for scalars");
3048 if (
auto *
C = dyn_cast<Constant>(V)) {
3049 if (
C->isNullValue())
3051 if (isa<ConstantInt>(
C))
3057 if (
auto *VecTy = dyn_cast<FixedVectorType>(Ty)) {
3058 for (
unsigned i = 0, e = VecTy->getNumElements(); i != e; ++i) {
3059 if (!DemandedElts[i])
3061 Constant *Elt =
C->getAggregateElement(i);
3064 if (!isa<PoisonValue>(Elt) && !isa<ConstantInt>(Elt))
3073 if (
const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
3074 if (!GV->isAbsoluteSymbolRef() && !GV->hasExternalWeakLinkage() &&
3075 GV->getType()->getAddressSpace() == 0)
3080 if (!isa<ConstantExpr>(V))
3084 if (
const auto *
A = dyn_cast<Argument>(V))
3085 if (std::optional<ConstantRange> Range =
A->getRange()) {
3086 const APInt ZeroValue(Range->getBitWidth(), 0);
3087 if (!Range->contains(ZeroValue))
3100 if (
PointerType *PtrTy = dyn_cast<PointerType>(Ty)) {
3103 if (
const Argument *
A = dyn_cast<Argument>(V)) {
3104 if (((
A->hasPassPointeeByValueCopyAttr() &&
3106 A->hasNonNullAttr()))
3111 if (
const auto *
I = dyn_cast<Operator>(V))
3115 if (!isa<Constant>(V) &&
3124 auto *FVTy = dyn_cast<FixedVectorType>(V->getType());
3125 APInt DemandedElts =
3127 return ::isKnownNonZero(V, DemandedElts, Q,
Depth);
3136static std::optional<std::pair<Value*, Value*>>
3140 return std::nullopt;
3149 case Instruction::Or:
3150 if (!cast<PossiblyDisjointInst>(Op1)->isDisjoint() ||
3151 !cast<PossiblyDisjointInst>(Op2)->isDisjoint())
3154 case Instruction::Xor:
3155 case Instruction::Add: {
3163 case Instruction::Sub:
3169 case Instruction::Mul: {
3173 auto *OBO1 = cast<OverflowingBinaryOperator>(Op1);
3174 auto *OBO2 = cast<OverflowingBinaryOperator>(Op2);
3175 if ((!OBO1->hasNoUnsignedWrap() || !OBO2->hasNoUnsignedWrap()) &&
3176 (!OBO1->hasNoSignedWrap() || !OBO2->hasNoSignedWrap()))
3182 !cast<ConstantInt>(Op1->
getOperand(1))->isZero())
3186 case Instruction::Shl: {
3189 auto *OBO1 = cast<OverflowingBinaryOperator>(Op1);
3190 auto *OBO2 = cast<OverflowingBinaryOperator>(Op2);
3191 if ((!OBO1->hasNoUnsignedWrap() || !OBO2->hasNoUnsignedWrap()) &&
3192 (!OBO1->hasNoSignedWrap() || !OBO2->hasNoSignedWrap()))
3199 case Instruction::AShr:
3200 case Instruction::LShr: {
3201 auto *PEO1 = cast<PossiblyExactOperator>(Op1);
3202 auto *PEO2 = cast<PossiblyExactOperator>(Op2);
3203 if (!PEO1->isExact() || !PEO2->isExact())
3210 case Instruction::SExt:
3211 case Instruction::ZExt:
3215 case Instruction::PHI: {
3216 const PHINode *PN1 = cast<PHINode>(Op1);
3217 const PHINode *PN2 = cast<PHINode>(Op2);
3223 Value *Start1 =
nullptr, *Step1 =
nullptr;
3225 Value *Start2 =
nullptr, *Step2 =
nullptr;
3232 cast<Operator>(BO2));
3241 if (Values->first != PN1 || Values->second != PN2)
3244 return std::make_pair(Start1, Start2);
3247 return std::nullopt;
3261 case Instruction::Or:
3262 if (!cast<PossiblyDisjointInst>(V1)->isDisjoint())
3265 case Instruction::Xor:
3266 case Instruction::Add:
3283 if (
auto *OBO = dyn_cast<OverflowingBinaryOperator>(V2)) {
3286 (OBO->hasNoUnsignedWrap() || OBO->hasNoSignedWrap()) &&
3296 if (
auto *OBO = dyn_cast<OverflowingBinaryOperator>(V2)) {
3299 (OBO->hasNoUnsignedWrap() || OBO->hasNoSignedWrap()) &&
3312 bool UsedFullRecursion =
false;
3314 if (!VisitedBBs.
insert(IncomBB).second)
3318 const APInt *C1, *C2;
3323 if (UsedFullRecursion)
3327 RecQ.
CxtI = IncomBB->getTerminator();
3330 UsedFullRecursion =
true;
3337 const SelectInst *SI1 = dyn_cast<SelectInst>(V1);
3341 if (
const SelectInst *SI2 = dyn_cast<SelectInst>(V2)) {
3343 const Value *Cond2 = SI2->getCondition();
3361 if (!
A->getType()->isPointerTy() || !
B->getType()->isPointerTy())
3364 auto *GEPA = dyn_cast<GEPOperator>(
A);
3365 if (!GEPA || GEPA->getNumIndices() != 1 || !isa<Constant>(GEPA->idx_begin()))
3369 auto *PN = dyn_cast<PHINode>(GEPA->getPointerOperand());
3370 if (!PN || PN->getNumIncomingValues() != 2)
3375 Value *Start =
nullptr;
3377 if (PN->getIncomingValue(0) == Step)
3378 Start = PN->getIncomingValue(1);
3379 else if (PN->getIncomingValue(1) == Step)
3380 Start = PN->getIncomingValue(0);
3391 APInt StartOffset(IndexWidth, 0);
3392 Start = Start->stripAndAccumulateInBoundsConstantOffsets(Q.
DL, StartOffset);
3393 APInt StepOffset(IndexWidth, 0);
3399 APInt OffsetB(IndexWidth, 0);
3400 B =
B->stripAndAccumulateInBoundsConstantOffsets(Q.
DL, OffsetB);
3401 return Start ==
B &&
3411 if (V1->
getType() != V2->getType())
3421 auto *O1 = dyn_cast<Operator>(V1);
3422 auto *O2 = dyn_cast<Operator>(V2);
3423 if (O1 && O2 && O1->getOpcode() == O2->getOpcode()) {
3427 if (
const PHINode *PN1 = dyn_cast<PHINode>(V1)) {
3428 const PHINode *PN2 = cast<PHINode>(V2);
3481 "Input should be a Select!");
3491 const Value *LHS2 =
nullptr, *RHS2 =
nullptr;
3503 return CLow->
sle(*CHigh);
3508 const APInt *&CHigh) {
3510 II->
getIntrinsicID() == Intrinsic::smax) &&
"Must be smin/smax");
3513 auto *InnerII = dyn_cast<IntrinsicInst>(II->
getArgOperand(0));
3514 if (!InnerII || InnerII->getIntrinsicID() != InverseID ||
3521 return CLow->
sle(*CHigh);
3529 const APInt &DemandedElts,
3531 const auto *CV = dyn_cast<Constant>(V);
3532 if (!CV || !isa<FixedVectorType>(CV->getType()))
3535 unsigned MinSignBits = TyBits;
3536 unsigned NumElts = cast<FixedVectorType>(CV->getType())->getNumElements();
3537 for (
unsigned i = 0; i != NumElts; ++i) {
3538 if (!DemandedElts[i])
3541 auto *Elt = dyn_cast_or_null<ConstantInt>(CV->getAggregateElement(i));
3545 MinSignBits = std::min(MinSignBits, Elt->getValue().getNumSignBits());
3552 const APInt &DemandedElts,
3558 assert(Result > 0 &&
"At least one sign bit needs to be present!");
3570 const APInt &DemandedElts,
3572 Type *Ty = V->getType();
3576 if (
auto *FVTy = dyn_cast<FixedVectorType>(Ty)) {
3578 FVTy->getNumElements() == DemandedElts.
getBitWidth() &&
3579 "DemandedElt width should equal the fixed vector number of elements");
3582 "DemandedElt width should be 1 for scalars");
3596 unsigned FirstAnswer = 1;
3604 if (
auto *U = dyn_cast<Operator>(V)) {
3607 case Instruction::SExt:
3608 Tmp = TyBits - U->getOperand(0)->getType()->getScalarSizeInBits();
3611 case Instruction::SDiv: {
3612 const APInt *Denominator;
3624 return std::min(TyBits, NumBits + Denominator->
logBase2());
3629 case Instruction::SRem: {
3632 const APInt *Denominator;
3653 unsigned ResBits = TyBits - Denominator->
ceilLogBase2();
3654 Tmp = std::max(Tmp, ResBits);
3660 case Instruction::AShr: {
3665 if (ShAmt->
uge(TyBits))
3668 Tmp += ShAmtLimited;
3669 if (Tmp > TyBits) Tmp = TyBits;
3673 case Instruction::Shl: {
3678 if (ShAmt->
uge(TyBits) ||
3679 ShAmt->
uge(Tmp))
break;
3685 case Instruction::And:
3686 case Instruction::Or:
3687 case Instruction::Xor:
3692 FirstAnswer = std::min(Tmp, Tmp2);
3699 case Instruction::Select: {
3703 const APInt *CLow, *CHigh;
3708 if (Tmp == 1)
break;
3710 return std::min(Tmp, Tmp2);
3713 case Instruction::Add:
3717 if (Tmp == 1)
break;
3720 if (
const auto *CRHS = dyn_cast<Constant>(U->getOperand(1)))
3721 if (CRHS->isAllOnesValue()) {
3727 if ((Known.
Zero | 1).isAllOnes())
3737 if (Tmp2 == 1)
break;
3738 return std::min(Tmp, Tmp2) - 1;
3740 case Instruction::Sub:
3742 if (Tmp2 == 1)
break;
3745 if (
const auto *CLHS = dyn_cast<Constant>(U->getOperand(0)))
3746 if (CLHS->isNullValue()) {
3751 if ((Known.
Zero | 1).isAllOnes())
3766 if (Tmp == 1)
break;
3767 return std::min(Tmp, Tmp2) - 1;
3769 case Instruction::Mul: {
3773 if (SignBitsOp0 == 1)
break;
3775 if (SignBitsOp1 == 1)
break;
3776 unsigned OutValidBits =
3777 (TyBits - SignBitsOp0 + 1) + (TyBits - SignBitsOp1 + 1);
3778 return OutValidBits > TyBits ? 1 : TyBits - OutValidBits + 1;
3781 case Instruction::PHI: {
3782 const PHINode *PN = cast<PHINode>(U);
3785 if (NumIncomingValues > 4)
break;
3787 if (NumIncomingValues == 0)
break;
3793 for (
unsigned i = 0, e = NumIncomingValues; i != e; ++i) {
3794 if (Tmp == 1)
return Tmp;
3802 case Instruction::Trunc: {
3807 unsigned OperandTyBits = U->getOperand(0)->getType()->getScalarSizeInBits();
3808 if (Tmp > (OperandTyBits - TyBits))
3809 return Tmp - (OperandTyBits - TyBits);
3814 case Instruction::ExtractElement:
3821 case Instruction::ShuffleVector: {
3824 auto *Shuf = dyn_cast<ShuffleVectorInst>(U);
3829 APInt DemandedLHS, DemandedRHS;
3834 Tmp = std::numeric_limits<unsigned>::max();
3835 if (!!DemandedLHS) {
3836 const Value *
LHS = Shuf->getOperand(0);
3843 if (!!DemandedRHS) {
3844 const Value *
RHS = Shuf->getOperand(1);
3846 Tmp = std::min(Tmp, Tmp2);
3852 assert(Tmp <= TyBits &&
"Failed to determine minimum sign bits");
3855 case Instruction::Call: {
3856 if (
const auto *II = dyn_cast<IntrinsicInst>(U)) {
3857 switch (II->getIntrinsicID()) {
3859 case Intrinsic::abs:
3861 if (Tmp == 1)
break;
3865 case Intrinsic::smin:
3866 case Intrinsic::smax: {
3867 const APInt *CLow, *CHigh;
3882 if (
unsigned VecSignBits =
3900 if (
F->isIntrinsic())
3901 return F->getIntrinsicID();
3907 if (
F->hasLocalLinkage() || !TLI || !TLI->
getLibFunc(CB, Func) ||
3917 return Intrinsic::sin;
3921 return Intrinsic::cos;
3925 return Intrinsic::exp;
3929 return Intrinsic::exp2;
3933 return Intrinsic::log;
3935 case LibFunc_log10f:
3936 case LibFunc_log10l:
3937 return Intrinsic::log10;
3941 return Intrinsic::log2;
3945 return Intrinsic::fabs;
3949 return Intrinsic::minnum;
3953 return Intrinsic::maxnum;
3954 case LibFunc_copysign:
3955 case LibFunc_copysignf:
3956 case LibFunc_copysignl:
3957 return Intrinsic::copysign;
3959 case LibFunc_floorf:
3960 case LibFunc_floorl:
3961 return Intrinsic::floor;
3965 return Intrinsic::ceil;
3967 case LibFunc_truncf:
3968 case LibFunc_truncl:
3969 return Intrinsic::trunc;
3973 return Intrinsic::rint;
3974 case LibFunc_nearbyint:
3975 case LibFunc_nearbyintf:
3976 case LibFunc_nearbyintl:
3977 return Intrinsic::nearbyint;
3979 case LibFunc_roundf:
3980 case LibFunc_roundl:
3981 return Intrinsic::round;
3982 case LibFunc_roundeven:
3983 case LibFunc_roundevenf:
3984 case LibFunc_roundevenl:
3985 return Intrinsic::roundeven;
3989 return Intrinsic::pow;
3993 return Intrinsic::sqrt;
4041 switch (Mode.Input) {
4061 if (!Src.isKnownNeverPosZero() && !Src.isKnownNeverNegZero())
4065 if (Src.isKnownNeverSubnormal())
4095 bool &TrueIfSigned) {
4098 TrueIfSigned =
true;
4099 return RHS.isZero();
4101 TrueIfSigned =
true;
4102 return RHS.isAllOnes();
4104 TrueIfSigned =
false;
4105 return RHS.isAllOnes();
4107 TrueIfSigned =
false;
4108 return RHS.isZero();
4111 TrueIfSigned =
true;
4112 return RHS.isMaxSignedValue();
4115 TrueIfSigned =
true;
4116 return RHS.isMinSignedValue();
4119 TrueIfSigned =
false;
4120 return RHS.isMinSignedValue();
4123 TrueIfSigned =
false;
4124 return RHS.isMaxSignedValue();
4135 bool LookThroughSrc) {
4143std::pair<Value *, FPClassTest>
4145 const APFloat *ConstRHS,
bool LookThroughSrc) {
4147 auto [Src, ClassIfTrue, ClassIfFalse] =
4149 if (Src && ClassIfTrue == ~ClassIfFalse)
4150 return {Src, ClassIfTrue};
4161std::tuple<Value *, FPClassTest, FPClassTest>
4175 const bool IsNegativeRHS = (RHSClass &
fcNegative) == RHSClass;
4176 const bool IsPositiveRHS = (RHSClass &
fcPositive) == RHSClass;
4177 const bool IsNaN = (RHSClass & ~fcNan) ==
fcNone;
4197 const bool IsZero = (OrigClass &
fcZero) == OrigClass;
4244 const bool IsDenormalRHS = (OrigClass &
fcSubnormal) == OrigClass;
4246 const bool IsInf = (OrigClass &
fcInf) == OrigClass;
4264 if (IsNegativeRHS) {
4287 if (IsNegativeRHS) {
4288 Mask = ~fcNegInf & ~fcNan;
4292 Mask = ~fcPosInf & ~fcNan;
4301 if (IsNegativeRHS) {
4321 if (IsNegativeRHS) {
4341 if (IsNegativeRHS) {
4356 if (IsNegativeRHS) {
4384 return {Src, Class, ~fcNan};
4388 return {Src, ~fcNan, RHSClass |
fcNan};
4397 "should have been recognized as an exact class test");
4399 if (IsNegativeRHS) {
4409 return {Src, ~fcNan,
fcNan};
4418 return {Src,
fcNan, ~fcNan};
4437 return {Src, ClassesGE, ~ClassesGE | RHSClass};
4440 return {Src, ClassesGE |
fcNan, ~(ClassesGE |
fcNan) | RHSClass};
4443 return {Src, ClassesLE, ~ClassesLE | RHSClass};
4446 return {Src, ClassesLE |
fcNan, ~(ClassesLE |
fcNan) | RHSClass};
4450 }
else if (IsPositiveRHS) {
4466 return {Src, ClassesGE, ~ClassesGE | RHSClass};
4469 return {Src, ClassesGE |
fcNan, ~(ClassesGE |
fcNan) | RHSClass};
4472 return {Src, ClassesLE, ~ClassesLE | RHSClass};
4475 return {Src, ClassesLE |
fcNan, ~(ClassesLE |
fcNan) | RHSClass};
4484std::tuple<Value *, FPClassTest, FPClassTest>
4486 const APFloat &ConstRHS,
bool LookThroughSrc) {
4534std::tuple<Value *, FPClassTest, FPClassTest>
4536 Value *RHS,
bool LookThroughSrc) {
4558 KnownFromContext.
knownNot(~(CondIsTrue ? MaskIfTrue : MaskIfFalse));
4559 }
else if (
match(
Cond, m_Intrinsic<Intrinsic::is_fpclass>(
4562 KnownFromContext.
knownNot(CondIsTrue ? ~Mask : Mask);
4568 if (TrueIfSigned == CondIsTrue)
4580 return KnownFromContext;
4600 return KnownFromContext;
4610 "Got assumption for the wrong function!");
4611 assert(
I->getCalledFunction()->getIntrinsicID() == Intrinsic::assume &&
4612 "must be an assume intrinsic");
4618 Q.
CxtI, KnownFromContext);
4621 return KnownFromContext;
4631 auto *FVTy = dyn_cast<FixedVectorType>(V->getType());
4632 APInt DemandedElts =
4638 const APInt &DemandedElts,
4642 if ((InterestedClasses &
4648 KnownSrc,
Depth + 1, Q);
4663 assert(Known.
isUnknown() &&
"should not be called with known information");
4665 if (!DemandedElts) {
4673 if (
auto *CFP = dyn_cast<ConstantFP>(V)) {
4675 Known.
SignBit = CFP->isNegative();
4679 if (isa<ConstantAggregateZero>(V)) {
4685 if (isa<PoisonValue>(V)) {
4692 auto *VFVTy = dyn_cast<FixedVectorType>(V->getType());
4693 const Constant *CV = dyn_cast<Constant>(V);
4696 bool SignBitAllZero =
true;
4697 bool SignBitAllOne =
true;
4700 unsigned NumElts = VFVTy->getNumElements();
4701 for (
unsigned i = 0; i != NumElts; ++i) {
4702 if (!DemandedElts[i])
4710 if (isa<UndefValue>(Elt))
4712 auto *CElt = dyn_cast<ConstantFP>(Elt);
4718 const APFloat &
C = CElt->getValueAPF();
4721 SignBitAllZero =
false;
4723 SignBitAllOne =
false;
4725 if (SignBitAllOne != SignBitAllZero)
4726 Known.
SignBit = SignBitAllOne;
4731 if (
const auto *CB = dyn_cast<CallBase>(V))
4732 KnownNotFromFlags |= CB->getRetNoFPClass();
4733 else if (
const auto *Arg = dyn_cast<Argument>(V))
4734 KnownNotFromFlags |= Arg->getNoFPClass();
4738 if (FPOp->hasNoNaNs())
4739 KnownNotFromFlags |=
fcNan;
4740 if (FPOp->hasNoInfs())
4741 KnownNotFromFlags |=
fcInf;
4745 KnownNotFromFlags |= ~AssumedClasses.KnownFPClasses;
4749 InterestedClasses &= ~KnownNotFromFlags;
4754 if (*AssumedClasses.SignBit)
4755 Known.signBitMustBeOne();
4757 Known.signBitMustBeZero();
4768 const unsigned Opc =
Op->getOpcode();
4770 case Instruction::FNeg: {
4772 Known,
Depth + 1, Q);
4776 case Instruction::Select: {
4784 Value *TestedValue =
nullptr;
4788 const Function *
F = cast<Instruction>(
Op)->getFunction();
4790 Value *CmpLHS, *CmpRHS;
4797 bool LookThroughFAbsFNeg = CmpLHS !=
LHS && CmpLHS !=
RHS;
4798 std::tie(TestedValue, MaskIfTrue, MaskIfFalse) =
4801 m_Intrinsic<Intrinsic::is_fpclass>(
4804 MaskIfTrue = TestedMask;
4805 MaskIfFalse = ~TestedMask;
4808 if (TestedValue ==
LHS) {
4810 FilterLHS = MaskIfTrue;
4811 }
else if (TestedValue ==
RHS) {
4813 FilterRHS = MaskIfFalse;
4822 Known2,
Depth + 1, Q);
4828 case Instruction::Call: {
4832 case Intrinsic::fabs: {
4837 InterestedClasses, Known,
Depth + 1, Q);
4843 case Intrinsic::copysign: {
4847 Known,
Depth + 1, Q);
4849 KnownSign,
Depth + 1, Q);
4853 case Intrinsic::fma:
4854 case Intrinsic::fmuladd: {
4867 KnownAddend,
Depth + 1, Q);
4873 case Intrinsic::sqrt:
4874 case Intrinsic::experimental_constrained_sqrt: {
4877 if (InterestedClasses &
fcNan)
4881 KnownSrc,
Depth + 1, Q);
4907 case Intrinsic::sin:
4908 case Intrinsic::cos: {
4912 KnownSrc,
Depth + 1, Q);
4918 case Intrinsic::maxnum:
4919 case Intrinsic::minnum:
4920 case Intrinsic::minimum:
4921 case Intrinsic::maximum: {
4924 KnownLHS,
Depth + 1, Q);
4926 KnownRHS,
Depth + 1, Q);
4929 Known = KnownLHS | KnownRHS;
4932 if (NeverNaN && (IID == Intrinsic::minnum || IID == Intrinsic::maxnum))
4935 if (IID == Intrinsic::maxnum) {
4943 }
else if (IID == Intrinsic::maximum) {
4949 }
else if (IID == Intrinsic::minnum) {
4991 }
else if ((IID == Intrinsic::maximum || IID == Intrinsic::minimum) ||
4996 if ((IID == Intrinsic::maximum || IID == Intrinsic::maxnum) &&
4999 else if ((IID == Intrinsic::minimum || IID == Intrinsic::minnum) &&
5006 case Intrinsic::canonicalize: {
5009 KnownSrc,
Depth + 1, Q);
5053 case Intrinsic::vector_reduce_fmax:
5054 case Intrinsic::vector_reduce_fmin:
5055 case Intrinsic::vector_reduce_fmaximum:
5056 case Intrinsic::vector_reduce_fminimum: {
5060 InterestedClasses,
Depth + 1, Q);
5066 case Intrinsic::trunc:
5067 case Intrinsic::floor:
5068 case Intrinsic::ceil:
5069 case Intrinsic::rint:
5070 case Intrinsic::nearbyint:
5071 case Intrinsic::round:
5072 case Intrinsic::roundeven: {
5080 KnownSrc,
Depth + 1, Q);
5089 if (IID == Intrinsic::trunc || !V->getType()->isMultiUnitFPType()) {
5104 case Intrinsic::exp:
5105 case Intrinsic::exp2:
5106 case Intrinsic::exp10: {
5113 KnownSrc,
Depth + 1, Q);
5121 case Intrinsic::fptrunc_round: {
5126 case Intrinsic::log:
5127 case Intrinsic::log10:
5128 case Intrinsic::log2:
5129 case Intrinsic::experimental_constrained_log:
5130 case Intrinsic::experimental_constrained_log10:
5131 case Intrinsic::experimental_constrained_log2: {
5147 KnownSrc,
Depth + 1, Q);
5161 case Intrinsic::powi: {
5166 Type *ExpTy = Exp->getType();
5170 ExponentKnownBits,
Depth + 1, Q);
5172 if (ExponentKnownBits.
Zero[0]) {
5187 KnownSrc,
Depth + 1, Q);
5192 case Intrinsic::ldexp: {
5195 KnownSrc,
Depth + 1, Q);
5211 if ((InterestedClasses & ExpInfoMask) ==
fcNone)
5223 const int MantissaBits = Precision - 1;
5229 if (ConstVal && ConstVal->
isZero()) {
5252 case Intrinsic::arithmetic_fence: {
5254 Known,
Depth + 1, Q);
5257 case Intrinsic::experimental_constrained_sitofp:
5258 case Intrinsic::experimental_constrained_uitofp:
5268 if (IID == Intrinsic::experimental_constrained_uitofp)
5279 case Instruction::FAdd:
5280 case Instruction::FSub: {
5283 Op->getOpcode() == Instruction::FAdd &&
5285 bool WantNaN = (InterestedClasses &
fcNan) !=
fcNone;
5288 if (!WantNaN && !WantNegative && !WantNegZero)
5294 if (InterestedClasses &
fcNan)
5295 InterestedSrcs |=
fcInf;
5297 KnownRHS,
Depth + 1, Q);
5301 WantNegZero || Opc == Instruction::FSub) {
5306 KnownLHS,
Depth + 1, Q);
5314 const Function *
F = cast<Instruction>(
Op)->getFunction();
5316 if (
Op->getOpcode() == Instruction::FAdd) {
5344 case Instruction::FMul: {
5346 if (
Op->getOperand(0) ==
Op->getOperand(1))
5379 const Function *
F = cast<Instruction>(
Op)->getFunction();
5391 case Instruction::FDiv:
5392 case Instruction::FRem: {
5393 if (
Op->getOperand(0) ==
Op->getOperand(1)) {
5395 if (
Op->getOpcode() == Instruction::FDiv) {
5406 const bool WantNan = (InterestedClasses &
fcNan) !=
fcNone;
5408 const bool WantPositive =
5410 if (!WantNan && !WantNegative && !WantPositive)
5419 bool KnowSomethingUseful =
5422 if (KnowSomethingUseful || WantPositive) {
5428 InterestedClasses & InterestedLHS, KnownLHS,
5432 const Function *
F = cast<Instruction>(
Op)->getFunction();
5434 if (
Op->getOpcode() == Instruction::FDiv) {
5471 case Instruction::FPExt: {
5474 Known,
Depth + 1, Q);
5477 Op->getType()->getScalarType()->getFltSemantics();
5479 Op->getOperand(0)->getType()->getScalarType()->getFltSemantics();
5495 case Instruction::FPTrunc: {
5500 case Instruction::SIToFP:
5501 case Instruction::UIToFP: {
5510 if (
Op->getOpcode() == Instruction::UIToFP)
5513 if (InterestedClasses &
fcInf) {
5517 int IntSize =
Op->getOperand(0)->getType()->getScalarSizeInBits();
5518 if (
Op->getOpcode() == Instruction::SIToFP)
5523 Type *FPTy =
Op->getType()->getScalarType();
5530 case Instruction::ExtractElement: {
5533 const Value *Vec =
Op->getOperand(0);
5535 auto *CIdx = dyn_cast<ConstantInt>(
Idx);
5537 if (
auto *VecTy = dyn_cast<FixedVectorType>(Vec->
getType())) {
5538 unsigned NumElts = VecTy->getNumElements();
5540 if (CIdx && CIdx->getValue().ult(NumElts))
5548 case Instruction::InsertElement: {
5549 if (isa<ScalableVectorType>(
Op->getType()))
5552 const Value *Vec =
Op->getOperand(0);
5553 const Value *Elt =
Op->getOperand(1);
5554 auto *CIdx = dyn_cast<ConstantInt>(
Op->getOperand(2));
5556 APInt DemandedVecElts = DemandedElts;
5557 bool NeedsElt =
true;
5559 if (CIdx && CIdx->getValue().ult(NumElts)) {
5560 DemandedVecElts.
clearBit(CIdx->getZExtValue());
5561 NeedsElt = DemandedElts[CIdx->getZExtValue()];
5575 if (!DemandedVecElts.
isZero()) {
5584 case Instruction::ShuffleVector: {
5587 APInt DemandedLHS, DemandedRHS;
5588 auto *Shuf = dyn_cast<ShuffleVectorInst>(
Op);
5592 if (!!DemandedLHS) {
5593 const Value *
LHS = Shuf->getOperand(0);
5604 if (!!DemandedRHS) {
5606 const Value *
RHS = Shuf->getOperand(1);
5614 case Instruction::ExtractValue: {
5618 if (isa<StructType>(Src->getType()) && Indices.
size() == 1 &&
5620 if (
const auto *II = dyn_cast<IntrinsicInst>(Src)) {
5621 switch (II->getIntrinsicID()) {
5622 case Intrinsic::frexp: {
5627 InterestedClasses, KnownSrc,
Depth + 1, Q);
5629 const Function *
F = cast<Instruction>(
Op)->getFunction();
5662 case Instruction::PHI: {
5665 if (
P->getNumIncomingValues() == 0)
5672 if (
Depth < PhiRecursionLimit) {
5674 if (isa_and_nonnull<UndefValue>(
P->hasConstantValue()))
5679 for (
const Use &U :
P->operands()) {
5680 Value *IncValue = U.get();
5690 IncValue, DemandedElts, InterestedClasses, KnownSrc,
5714 const APInt &DemandedElts,
5721 return KnownClasses;
5736 if (V->getType()->isIntegerTy(8))
5743 if (isa<UndefValue>(V))
5747 if (
DL.getTypeStoreSize(V->getType()).isZero())
5762 if (
C->isNullValue())
5769 if (CFP->getType()->isHalfTy())
5771 else if (CFP->getType()->isFloatTy())
5773 else if (CFP->getType()->isDoubleTy())
5782 if (CI->getBitWidth() % 8 == 0) {
5783 assert(CI->getBitWidth() > 8 &&
"8 bits should be handled above!");
5784 if (!CI->getValue().isSplat(8))
5786 return ConstantInt::get(Ctx, CI->getValue().trunc(8));
5790 if (
auto *CE = dyn_cast<ConstantExpr>(
C)) {
5791 if (CE->getOpcode() == Instruction::IntToPtr) {
5792 if (
auto *PtrTy = dyn_cast<PointerType>(CE->getType())) {
5793 unsigned BitWidth =
DL.getPointerSizeInBits(PtrTy->getAddressSpace());
5806 if (
LHS == UndefInt8)
5808 if (
RHS == UndefInt8)
5814 Value *Val = UndefInt8;
5815 for (
unsigned I = 0, E = CA->getNumElements();
I != E; ++
I)
5821 if (isa<ConstantAggregate>(
C)) {
5822 Value *Val = UndefInt8;
5823 for (
unsigned I = 0, E =
C->getNumOperands();
I != E; ++
I)
5843 StructType *STy = dyn_cast<StructType>(IndexedType);
5857 while (PrevTo != OrigTo) {
5904 unsigned IdxSkip = Idxs.
size();
5917 std::optional<BasicBlock::iterator> InsertBefore) {
5920 if (idx_range.
empty())
5923 assert((V->getType()->isStructTy() || V->getType()->isArrayTy()) &&
5924 "Not looking at a struct or array?");
5926 "Invalid indices for type?");
5928 if (
Constant *
C = dyn_cast<Constant>(V)) {
5929 C =
C->getAggregateElement(idx_range[0]);
5930 if (!
C)
return nullptr;
5937 const unsigned *req_idx = idx_range.
begin();
5938 for (
const unsigned *i =
I->idx_begin(), *e =
I->idx_end();
5939 i != e; ++i, ++req_idx) {
5940 if (req_idx == idx_range.
end()) {
5970 ArrayRef(req_idx, idx_range.
end()), InsertBefore);
5979 unsigned size =
I->getNumIndices() + idx_range.
size();
5984 Idxs.
append(
I->idx_begin(),
I->idx_end());
5990 &&
"Number of indices added not correct?");
6000 unsigned CharSize) {
6002 if (
GEP->getNumOperands() != 3)
6007 ArrayType *AT = dyn_cast<ArrayType>(
GEP->getSourceElementType());
6013 const ConstantInt *FirstIdx = dyn_cast<ConstantInt>(
GEP->getOperand(1));
6014 if (!FirstIdx || !FirstIdx->
isZero())
6028 assert(V &&
"V should not be null.");
6029 assert((ElementSize % 8) == 0 &&
6030 "ElementSize expected to be a multiple of the size of a byte.");
6031 unsigned ElementSizeInBytes = ElementSize / 8;
6043 APInt Off(
DL.getIndexTypeSizeInBits(V->getType()), 0);
6045 if (GV != V->stripAndAccumulateConstantOffsets(
DL, Off,
6050 uint64_t StartIdx = Off.getLimitedValue();
6057 if ((StartIdx % ElementSizeInBytes) != 0)
6060 Offset += StartIdx / ElementSizeInBytes;
6066 uint64_t SizeInBytes =
DL.getTypeStoreSize(GVTy).getFixedValue();
6069 Slice.
Array =
nullptr;
6080 if (
auto *ArrayInit = dyn_cast<ConstantDataArray>(
Init)) {
6081 Type *InitElTy = ArrayInit->getElementType();
6086 ArrayTy = ArrayInit->getType();
6091 if (ElementSize != 8)
6102 Array = dyn_cast<ConstantDataArray>(
Init);
6103 ArrayTy = dyn_cast<ArrayType>(
Init->getType());
6110 Slice.
Array = Array;
6126 if (Slice.
Array ==
nullptr) {
6149 Str = Str.substr(Slice.
Offset);
6155 Str = Str.substr(0, Str.find(
'\0'));
6168 unsigned CharSize) {
6170 V = V->stripPointerCasts();
6174 if (
const PHINode *PN = dyn_cast<PHINode>(V)) {
6175 if (!PHIs.
insert(PN).second)
6180 for (
Value *IncValue : PN->incoming_values()) {
6182 if (Len == 0)
return 0;
6184 if (Len == ~0ULL)
continue;
6186 if (Len != LenSoFar && LenSoFar != ~0ULL)
6196 if (
const SelectInst *SI = dyn_cast<SelectInst>(V)) {
6198 if (Len1 == 0)
return 0;
6200 if (Len2 == 0)
return 0;
6201 if (Len1 == ~0ULL)
return Len2;
6202 if (Len2 == ~0ULL)
return Len1;
6203 if (Len1 != Len2)
return 0;
6212 if (Slice.
Array ==
nullptr)
6220 unsigned NullIndex = 0;
6221 for (
unsigned E = Slice.
Length; NullIndex < E; ++NullIndex) {
6226 return NullIndex + 1;
6232 if (!V->getType()->isPointerTy())
6239 return Len == ~0ULL ? 1 : Len;
6244 bool MustPreserveNullness) {
6246 "getArgumentAliasingToReturnedPointer only works on nonnull calls");
6247 if (
const Value *RV = Call->getReturnedArgOperand())
6251 Call, MustPreserveNullness))
6252 return Call->getArgOperand(0);
6257 const CallBase *Call,
bool MustPreserveNullness) {
6258 switch (Call->getIntrinsicID()) {
6259 case Intrinsic::launder_invariant_group:
6260 case Intrinsic::strip_invariant_group:
6261 case Intrinsic::aarch64_irg:
6262 case Intrinsic::aarch64_tagp:
6272 case Intrinsic::amdgcn_make_buffer_rsrc:
6274 case Intrinsic::ptrmask:
6275 return !MustPreserveNullness;
6276 case Intrinsic::threadlocal_address:
6279 return !Call->getParent()->getParent()->isPresplitCoroutine();
6296 if (!PrevValue || LI->
getLoopFor(PrevValue->getParent()) != L)
6298 if (!PrevValue || LI->
getLoopFor(PrevValue->getParent()) != L)
6306 if (
auto *Load = dyn_cast<LoadInst>(PrevValue))
6307 if (!L->isLoopInvariant(Load->getPointerOperand()))
6313 if (!V->getType()->isPointerTy())
6315 for (
unsigned Count = 0; MaxLookup == 0 || Count < MaxLookup; ++Count) {
6316 if (
auto *
GEP = dyn_cast<GEPOperator>(V)) {
6317 V =
GEP->getPointerOperand();
6320 V = cast<Operator>(V)->getOperand(0);
6321 if (!V->getType()->isPointerTy())
6323 }
else if (
auto *GA = dyn_cast<GlobalAlias>(V)) {
6324 if (GA->isInterposable())
6326 V = GA->getAliasee();
6328 if (
auto *
PHI = dyn_cast<PHINode>(V)) {
6330 if (
PHI->getNumIncomingValues() == 1) {
6331 V =
PHI->getIncomingValue(0);
6334 }
else if (
auto *Call = dyn_cast<CallBase>(V)) {
6352 assert(V->getType()->isPointerTy() &&
"Unexpected operand type!");
6359 LoopInfo *LI,
unsigned MaxLookup) {
6367 if (!Visited.
insert(
P).second)
6370 if (
auto *SI = dyn_cast<SelectInst>(
P)) {
6372 Worklist.
push_back(SI->getFalseValue());
6376 if (
auto *PN = dyn_cast<PHINode>(
P)) {
6396 }
while (!Worklist.
empty());
6403 if (
const Operator *U = dyn_cast<Operator>(V)) {
6406 if (U->getOpcode() == Instruction::PtrToInt)
6407 return U->getOperand(0);
6414 if (U->getOpcode() != Instruction::Add ||
6415 (!isa<ConstantInt>(U->getOperand(1)) &&
6417 !isa<PHINode>(U->getOperand(1))))
6419 V = U->getOperand(0);
6423 assert(V->getType()->isIntegerTy() &&
"Unexpected operand type!");
6440 for (
const Value *V : Objs) {
6441 if (!Visited.
insert(V).second)
6446 if (O->getType()->isPointerTy()) {
6459 }
while (!Working.
empty());
6468 auto AddWork = [&](
Value *V) {
6469 if (Visited.
insert(V).second)
6478 if (
AllocaInst *AI = dyn_cast<AllocaInst>(V)) {
6479 if (Result && Result != AI)
6482 }
else if (
CastInst *CI = dyn_cast<CastInst>(V)) {
6483 AddWork(CI->getOperand(0));
6484 }
else if (
PHINode *PN = dyn_cast<PHINode>(V)) {
6485 for (
Value *IncValue : PN->incoming_values())
6487 }
else if (
auto *SI = dyn_cast<SelectInst>(V)) {
6488 AddWork(SI->getTrueValue());
6489 AddWork(SI->getFalseValue());
6491 if (OffsetZero && !
GEP->hasAllZeroIndices())
6493 AddWork(
GEP->getPointerOperand());
6494 }
else if (
CallBase *CB = dyn_cast<CallBase>(V)) {
6495 Value *Returned = CB->getReturnedArgOperand();
6503 }
while (!Worklist.
empty());
6509 const Value *V,
bool AllowLifetime,
bool AllowDroppable) {
6510 for (
const User *U : V->users()) {
6540 return F.hasFnAttribute(Attribute::SanitizeThread) ||
6542 F.hasFnAttribute(Attribute::SanitizeAddress) ||
6543 F.hasFnAttribute(Attribute::SanitizeHWAddress);
6562 auto hasEqualReturnAndLeadingOperandTypes =
6563 [](
const Instruction *Inst,
unsigned NumLeadingOperands) {
6567 for (
unsigned ItOp = 0; ItOp < NumLeadingOperands; ++ItOp)
6573 hasEqualReturnAndLeadingOperandTypes(Inst, 2));
6575 hasEqualReturnAndLeadingOperandTypes(Inst, 1));
6582 case Instruction::UDiv:
6583 case Instruction::URem: {
6590 case Instruction::SDiv:
6591 case Instruction::SRem: {
6593 const APInt *Numerator, *Denominator;
6597 if (*Denominator == 0)
6609 case Instruction::Load: {
6610 const LoadInst *LI = dyn_cast<LoadInst>(Inst);
6620 case Instruction::Call: {
6621 auto *CI = dyn_cast<const CallInst>(Inst);
6624 const Function *Callee = CI->getCalledFunction();
6628 return Callee && Callee->isSpeculatable();
6630 case Instruction::VAArg:
6631 case Instruction::Alloca:
6632 case Instruction::Invoke:
6633 case Instruction::CallBr:
6634 case Instruction::PHI:
6635 case Instruction::Store:
6636 case Instruction::Ret:
6637 case Instruction::Br:
6638 case Instruction::IndirectBr:
6639 case Instruction::Switch:
6640 case Instruction::Unreachable:
6641 case Instruction::Fence:
6642 case Instruction::AtomicRMW:
6643 case Instruction::AtomicCmpXchg:
6644 case Instruction::LandingPad:
6645 case Instruction::Resume:
6646 case Instruction::CatchSwitch:
6647 case Instruction::CatchPad:
6648 case Instruction::CatchRet:
6649 case Instruction::CleanupPad:
6650 case Instruction::CleanupRet:
6656 if (
I.mayReadOrWriteMemory())
6769 if (
Add &&
Add->hasNoSignedWrap()) {
6809 bool LHSOrRHSKnownNonNegative =
6811 bool LHSOrRHSKnownNegative =
6813 if (LHSOrRHSKnownNonNegative || LHSOrRHSKnownNegative) {
6816 if ((AddKnown.
isNonNegative() && LHSOrRHSKnownNonNegative) ||
6817 (AddKnown.
isNegative() && LHSOrRHSKnownNegative))
6846 m_Intrinsic<Intrinsic::usub_with_overflow>(
m_Value(),
m_Value())))
6895 if (
const auto *EVI = dyn_cast<ExtractValueInst>(U)) {
6896 assert(EVI->getNumIndices() == 1 &&
"Obvious from CI's type");
6898 if (EVI->getIndices()[0] == 0)
6901 assert(EVI->getIndices()[0] == 1 &&
"Obvious from CI's type");
6903 for (
const auto *U : EVI->users())
6904 if (
const auto *
B = dyn_cast<BranchInst>(U)) {
6905 assert(
B->isConditional() &&
"How else is it using an i1?");
6916 auto AllUsesGuardedByBranch = [&](
const BranchInst *BI) {
6922 for (
const auto *Result :
Results) {
6925 if (DT.
dominates(NoWrapEdge, Result->getParent()))
6928 for (
const auto &RU : Result->uses())
6936 return llvm::any_of(GuardingBranches, AllUsesGuardedByBranch);
6941 auto *
C = dyn_cast<Constant>(ShiftAmount);
6947 if (
auto *FVTy = dyn_cast<FixedVectorType>(
C->getType())) {
6948 unsigned NumElts = FVTy->getNumElements();
6949 for (
unsigned i = 0; i < NumElts; ++i)
6950 ShiftAmounts.
push_back(
C->getAggregateElement(i));
6951 }
else if (isa<ScalableVectorType>(
C->getType()))
6957 auto *CI = dyn_cast_or_null<ConstantInt>(
C);
6958 return CI && CI->getValue().ult(
C->getType()->getIntegerBitWidth());
6971 return (
unsigned(Kind) &
unsigned(UndefPoisonKind::PoisonOnly)) != 0;
6975 return (
unsigned(Kind) &
unsigned(UndefPoisonKind::UndefOnly)) != 0;
6979 bool ConsiderFlagsAndMetadata) {
6982 Op->hasPoisonGeneratingAnnotations())
6985 unsigned Opcode =
Op->getOpcode();
6989 case Instruction::Shl:
6990 case Instruction::AShr:
6991 case Instruction::LShr:
6993 case Instruction::FPToSI:
6994 case Instruction::FPToUI:
6998 case Instruction::Call:
6999 if (
auto *II = dyn_cast<IntrinsicInst>(
Op)) {
7000 switch (II->getIntrinsicID()) {
7002 case Intrinsic::ctlz:
7003 case Intrinsic::cttz:
7004 case Intrinsic::abs:
7005 if (cast<ConstantInt>(II->getArgOperand(1))->isNullValue())
7008 case Intrinsic::ctpop:
7009 case Intrinsic::bswap:
7010 case Intrinsic::bitreverse:
7011 case Intrinsic::fshl:
7012 case Intrinsic::fshr:
7013 case Intrinsic::smax:
7014 case Intrinsic::smin:
7015 case Intrinsic::umax:
7016 case Intrinsic::umin:
7017 case Intrinsic::ptrmask:
7018 case Intrinsic::fptoui_sat:
7019 case Intrinsic::fptosi_sat:
7020 case Intrinsic::sadd_with_overflow:
7021 case Intrinsic::ssub_with_overflow:
7022 case Intrinsic::smul_with_overflow:
7023 case Intrinsic::uadd_with_overflow:
7024 case Intrinsic::usub_with_overflow:
7025 case Intrinsic::umul_with_overflow:
7026 case Intrinsic::sadd_sat:
7027 case Intrinsic::uadd_sat:
7028 case Intrinsic::ssub_sat:
7029 case Intrinsic::usub_sat:
7031 case Intrinsic::sshl_sat:
7032 case Intrinsic::ushl_sat:
7035 case Intrinsic::fma:
7036 case Intrinsic::fmuladd:
7037 case Intrinsic::sqrt:
7038 case Intrinsic::powi:
7039 case Intrinsic::sin:
7040 case Intrinsic::cos:
7041 case Intrinsic::pow:
7042 case Intrinsic::log:
7043 case Intrinsic::log10:
7044 case Intrinsic::log2:
7045 case Intrinsic::exp:
7046 case Intrinsic::exp2:
7047 case Intrinsic::exp10:
7048 case Intrinsic::fabs:
7049 case Intrinsic::copysign:
7050 case Intrinsic::floor:
7051 case Intrinsic::ceil:
7052 case Intrinsic::trunc:
7053 case Intrinsic::rint:
7054 case Intrinsic::nearbyint:
7055 case Intrinsic::round:
7056 case Intrinsic::roundeven:
7057 case Intrinsic::fptrunc_round:
7058 case Intrinsic::canonicalize:
7059 case Intrinsic::arithmetic_fence:
7060 case Intrinsic::minnum:
7061 case Intrinsic::maxnum:
7062 case Intrinsic::minimum:
7063 case Intrinsic::maximum:
7064 case Intrinsic::is_fpclass:
7065 case Intrinsic::ldexp:
7066 case Intrinsic::frexp:
7068 case Intrinsic::lround:
7069 case Intrinsic::llround:
7070 case Intrinsic::lrint:
7071 case Intrinsic::llrint:
7078 case Instruction::CallBr:
7079 case Instruction::Invoke: {
7080 const auto *CB = cast<CallBase>(
Op);
7081 return !CB->hasRetAttr(Attribute::NoUndef);
7083 case Instruction::InsertElement:
7084 case Instruction::ExtractElement: {
7086 auto *VTy = cast<VectorType>(
Op->getOperand(0)->getType());
7087 unsigned IdxOp =
Op->getOpcode() == Instruction::InsertElement ? 2 : 1;
7088 auto *
Idx = dyn_cast<ConstantInt>(
Op->getOperand(IdxOp));
7091 Idx->getValue().uge(VTy->getElementCount().getKnownMinValue());
7094 case Instruction::ShuffleVector: {
7096 ? cast<ConstantExpr>(
Op)->getShuffleMask()
7097 : cast<ShuffleVectorInst>(
Op)->getShuffleMask();
7100 case Instruction::FNeg:
7101 case Instruction::PHI:
7102 case Instruction::Select:
7103 case Instruction::URem:
7104 case Instruction::SRem:
7105 case Instruction::ExtractValue:
7106 case Instruction::InsertValue:
7107 case Instruction::Freeze:
7108 case Instruction::ICmp:
7109 case Instruction::FCmp:
7110 case Instruction::FAdd:
7111 case Instruction::FSub:
7112 case Instruction::FMul:
7113 case Instruction::FDiv:
7114 case Instruction::FRem:
7116 case Instruction::GetElementPtr:
7121 const auto *CE = dyn_cast<ConstantExpr>(
Op);
7122 if (isa<CastInst>(
Op) || (CE && CE->isCast()))
7133 bool ConsiderFlagsAndMetadata) {
7134 return ::canCreateUndefOrPoison(
Op, UndefPoisonKind::UndefOrPoison,
7135 ConsiderFlagsAndMetadata);
7139 return ::canCreateUndefOrPoison(
Op, UndefPoisonKind::PoisonOnly,
7140 ConsiderFlagsAndMetadata);
7145 if (ValAssumedPoison == V)
7152 if (
const auto *
I = dyn_cast<Instruction>(V)) {
7154 return propagatesPoison(Op) &&
7155 directlyImpliesPoison(ValAssumedPoison, Op, Depth + 1);
7183 const auto *
I = dyn_cast<Instruction>(ValAssumedPoison);
7186 return impliesPoison(Op, V, Depth + 1);
7193 return ::impliesPoison(ValAssumedPoison, V, 0);
7204 if (isa<MetadataAsValue>(V))
7207 if (
const auto *
A = dyn_cast<Argument>(V)) {
7208 if (
A->hasAttribute(Attribute::NoUndef) ||
7209 A->hasAttribute(Attribute::Dereferenceable) ||
7210 A->hasAttribute(Attribute::DereferenceableOrNull))
7214 if (
auto *
C = dyn_cast<Constant>(V)) {
7215 if (isa<PoisonValue>(
C))
7218 if (isa<UndefValue>(
C))
7221 if (isa<ConstantInt>(
C) || isa<GlobalVariable>(
C) || isa<ConstantFP>(V) ||
7222 isa<ConstantPointerNull>(
C) || isa<Function>(
C))
7225 if (
C->getType()->isVectorTy() && !isa<ConstantExpr>(
C))
7227 : !
C->containsUndefOrPoisonElement()) &&
7228 !
C->containsConstantExpression();
7239 auto *StrippedV = V->stripPointerCastsSameRepresentation();
7240 if (isa<AllocaInst>(StrippedV) || isa<GlobalVariable>(StrippedV) ||
7241 isa<Function>(StrippedV) || isa<ConstantPointerNull>(StrippedV))
7244 auto OpCheck = [&](
const Value *V) {
7248 if (
auto *Opr = dyn_cast<Operator>(V)) {
7251 if (isa<FreezeInst>(V))
7254 if (
const auto *CB = dyn_cast<CallBase>(V)) {
7255 if (CB->hasRetAttr(Attribute::NoUndef) ||
7256 CB->hasRetAttr(Attribute::Dereferenceable) ||
7257 CB->hasRetAttr(Attribute::DereferenceableOrNull))
7261 if (
const auto *PN = dyn_cast<PHINode>(V)) {
7262 unsigned Num = PN->getNumIncomingValues();
7263 bool IsWellDefined =
true;
7264 for (
unsigned i = 0; i < Num; ++i) {
7265 auto *TI = PN->getIncomingBlock(i)->getTerminator();
7267 DT,
Depth + 1, Kind)) {
7268 IsWellDefined =
false;
7276 all_of(Opr->operands(), OpCheck))
7280 if (
auto *
I = dyn_cast<LoadInst>(V))
7281 if (
I->hasMetadata(LLVMContext::MD_noundef) ||
7282 I->hasMetadata(LLVMContext::MD_dereferenceable) ||
7283 I->hasMetadata(LLVMContext::MD_dereferenceable_or_null))
7303 auto *Dominator = DNode->
getIDom();
7308 auto *TI = Dominator->
getBlock()->getTerminator();
7311 if (
auto BI = dyn_cast_or_null<BranchInst>(TI)) {
7312 if (BI->isConditional())
7313 Cond = BI->getCondition();
7314 }
else if (
auto SI = dyn_cast_or_null<SwitchInst>(TI)) {
7315 Cond = SI->getCondition();
7323 auto *Opr = cast<Operator>(
Cond);
7324 if (
any_of(Opr->operands(), [V](
const Use &U) {
7325 return V == U && propagatesPoison(U);
7331 Dominator = Dominator->getIDom();
7344 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT,
Depth,
7345 UndefPoisonKind::UndefOrPoison);
7351 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT,
Depth,
7352 UndefPoisonKind::PoisonOnly);
7358 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT,
Depth,
7359 UndefPoisonKind::UndefOnly);
7382 while (!Worklist.
empty()) {
7391 if (
I != Root && !
any_of(
I->operands(), [&KnownPoison](
const Use &U) {
7392 return KnownPoison.contains(U) && propagatesPoison(U);
7396 if (KnownPoison.
insert(
I).second)
7408 return ::computeOverflowForSignedAdd(
Add->getOperand(0),
Add->getOperand(1),
7416 return ::computeOverflowForSignedAdd(
LHS,
RHS,
nullptr, SQ);
7425 if (isa<ReturnInst>(
I))
7427 if (isa<UnreachableInst>(
I))
7434 if (isa<CatchPadInst>(
I)) {
7448 return !
I->mayThrow() &&
I->willReturn();
7462 unsigned ScanLimit) {
7469 assert(ScanLimit &&
"scan limit must be non-zero");
7471 if (isa<DbgInfoIntrinsic>(
I))
7473 if (--ScanLimit == 0)
7487 if (
I->getParent() != L->getHeader())
return false;
7490 if (&LI ==
I)
return true;
7493 llvm_unreachable(
"Instruction not contained in its own parent basic block.");
7498 switch (
I->getOpcode()) {
7499 case Instruction::Freeze:
7500 case Instruction::PHI:
7501 case Instruction::Invoke:
7503 case Instruction::Select:
7505 case Instruction::Call:
7506 if (
auto *II = dyn_cast<IntrinsicInst>(
I)) {
7507 switch (II->getIntrinsicID()) {
7509 case Intrinsic::sadd_with_overflow:
7510 case Intrinsic::ssub_with_overflow:
7511 case Intrinsic::smul_with_overflow:
7512 case Intrinsic::uadd_with_overflow:
7513 case Intrinsic::usub_with_overflow:
7514 case Intrinsic::umul_with_overflow:
7519 case Intrinsic::ctpop:
7520 case Intrinsic::ctlz:
7521 case Intrinsic::cttz:
7522 case Intrinsic::abs:
7523 case Intrinsic::smax:
7524 case Intrinsic::smin:
7525 case Intrinsic::umax:
7526 case Intrinsic::umin:
7527 case Intrinsic::bitreverse:
7528 case Intrinsic::bswap:
7529 case Intrinsic::sadd_sat:
7530 case Intrinsic::ssub_sat:
7531 case Intrinsic::sshl_sat:
7532 case Intrinsic::uadd_sat:
7533 case Intrinsic::usub_sat:
7534 case Intrinsic::ushl_sat:
7539 case Instruction::ICmp:
7540 case Instruction::FCmp:
7541 case Instruction::GetElementPtr:
7544 if (isa<BinaryOperator>(
I) || isa<UnaryOperator>(
I) || isa<CastInst>(
I))
7555template <
typename CallableT>
7557 const CallableT &Handle) {
7558 switch (
I->getOpcode()) {
7559 case Instruction::Store:
7564 case Instruction::Load:
7571 case Instruction::AtomicCmpXchg:
7576 case Instruction::AtomicRMW:
7581 case Instruction::Call:
7582 case Instruction::Invoke: {
7586 for (
unsigned i = 0; i < CB->
arg_size(); ++i)
7589 CB->
paramHasAttr(i, Attribute::DereferenceableOrNull)) &&
7594 case Instruction::Ret:
7595 if (
I->getFunction()->hasRetAttribute(Attribute::NoUndef) &&
7596 Handle(
I->getOperand(0)))
7599 case Instruction::Switch:
7600 if (Handle(cast<SwitchInst>(
I)->getCondition()))
7603 case Instruction::Br: {
7604 auto *BR = cast<BranchInst>(
I);
7605 if (BR->isConditional() && Handle(BR->getCondition()))
7625template <
typename CallableT>
7627 const CallableT &Handle) {
7630 switch (
I->getOpcode()) {
7632 case Instruction::UDiv:
7633 case Instruction::SDiv:
7634 case Instruction::URem:
7635 case Instruction::SRem:
7636 return Handle(
I->getOperand(1));
7653 I, [&](
const Value *V) {
return KnownPoison.
count(V); });
7667 if (
const auto *Inst = dyn_cast<Instruction>(V)) {
7671 }
else if (
const auto *Arg = dyn_cast<Argument>(V)) {
7672 if (Arg->getParent()->isDeclaration())
7675 Begin = BB->
begin();
7682 unsigned ScanLimit = 32;
7691 if (isa<DbgInfoIntrinsic>(
I))
7693 if (--ScanLimit == 0)
7697 return WellDefinedOp == V;
7717 if (isa<DbgInfoIntrinsic>(
I))
7719 if (--ScanLimit == 0)
7727 for (
const Use &
Op :
I.operands()) {
7737 if (
I.getOpcode() == Instruction::Select &&
7738 YieldsPoison.
count(
I.getOperand(1)) &&
7739 YieldsPoison.
count(
I.getOperand(2))) {
7745 if (!BB || !Visited.
insert(BB).second)
7755 return ::programUndefinedIfUndefOrPoison(Inst,
false);
7759 return ::programUndefinedIfUndefOrPoison(Inst,
true);
7766 if (
auto *
C = dyn_cast<ConstantFP>(V))
7769 if (
auto *
C = dyn_cast<ConstantDataVector>(V)) {
7770 if (!
C->getElementType()->isFloatingPointTy())
7772 for (
unsigned I = 0, E =
C->getNumElements();
I < E; ++
I) {
7773 if (
C->getElementAsAPFloat(
I).isNaN())
7779 if (isa<ConstantAggregateZero>(V))
7786 if (
auto *
C = dyn_cast<ConstantFP>(V))
7787 return !
C->isZero();
7789 if (
auto *
C = dyn_cast<ConstantDataVector>(V)) {
7790 if (!
C->getElementType()->isFloatingPointTy())
7792 for (
unsigned I = 0, E =
C->getNumElements();
I < E; ++
I) {
7793 if (
C->getElementAsAPFloat(
I).isZero())
7816 if (CmpRHS == FalseVal) {
7864 if (CmpRHS != TrueVal) {
7903 Value *
A =
nullptr, *
B =
nullptr;
7908 Value *
C =
nullptr, *
D =
nullptr;
7910 if (L.Flavor != R.Flavor)
7962 return {L.Flavor,
SPNB_NA,
false};
7969 return {L.Flavor,
SPNB_NA,
false};
7976 return {L.Flavor,
SPNB_NA,
false};
7983 return {L.Flavor,
SPNB_NA,
false};
7999 return ConstantInt::get(V->getType(), ~(*
C));
8056 if ((CmpLHS == TrueVal &&
match(FalseVal,
m_APInt(C2))) ||
8076 assert(
X &&
Y &&
"Invalid operand");
8078 auto IsNegationOf = [&](
const Value *
X,
const Value *
Y) {
8082 auto *BO = cast<BinaryOperator>(
X);
8083 if (NeedNSW && !BO->hasNoSignedWrap())
8086 auto *Zero = cast<Constant>(BO->getOperand(0));
8087 if (!AllowPoison && !Zero->isNullValue())
8094 if (IsNegationOf(
X,
Y) || IsNegationOf(
Y,
X))
8111 bool HasMismatchedZeros =
false;
8117 Value *OutputZeroVal =
nullptr;
8119 !cast<Constant>(TrueVal)->containsUndefOrPoisonElement())
8120 OutputZeroVal = TrueVal;
8122 !cast<Constant>(FalseVal)->containsUndefOrPoisonElement())
8123 OutputZeroVal = FalseVal;
8125 if (OutputZeroVal) {
8127 HasMismatchedZeros =
true;
8128 CmpLHS = OutputZeroVal;
8131 HasMismatchedZeros =
true;
8132 CmpRHS = OutputZeroVal;
8149 if (!HasMismatchedZeros)
8160 bool Ordered =
false;
8171 if (LHSSafe && RHSSafe) {
8201 if (TrueVal == CmpRHS && FalseVal == CmpLHS) {
8212 if (TrueVal == CmpLHS && FalseVal == CmpRHS) {
8237 auto MaybeSExtCmpLHS =
8241 if (
match(TrueVal, MaybeSExtCmpLHS)) {
8263 else if (
match(FalseVal, MaybeSExtCmpLHS)) {
8313 auto *Cast1 = dyn_cast<CastInst>(V1);
8317 *CastOp = Cast1->getOpcode();
8318 Type *SrcTy = Cast1->getSrcTy();
8319 if (
auto *Cast2 = dyn_cast<CastInst>(V2)) {
8321 if (*CastOp == Cast2->getOpcode() && SrcTy == Cast2->getSrcTy())
8322 return Cast2->getOperand(0);
8326 auto *
C = dyn_cast<Constant>(V2);
8333 case Instruction::ZExt:
8337 case Instruction::SExt:
8341 case Instruction::Trunc:
8344 CmpConst->
getType() == SrcTy) {
8366 CastedTo = CmpConst;
8368 unsigned ExtOp = CmpI->
isSigned() ? Instruction::SExt : Instruction::ZExt;
8372 case Instruction::FPTrunc:
8375 case Instruction::FPExt:
8378 case Instruction::FPToUI:
8381 case Instruction::FPToSI:
8384 case Instruction::UIToFP:
8387 case Instruction::SIToFP:
8400 if (CastedBack && CastedBack !=
C)
8415 CmpInst *CmpI = dyn_cast<CmpInst>(SI->getCondition());
8418 Value *TrueVal = SI->getTrueValue();
8419 Value *FalseVal = SI->getFalseValue();
8432 if (isa<FPMathOperator>(CmpI))
8440 if (CastOp && CmpLHS->
getType() != TrueVal->getType()) {
8444 if (*CastOp == Instruction::FPToSI || *CastOp == Instruction::FPToUI)
8446 return ::matchSelectPattern(Pred, FMF, CmpLHS, CmpRHS,
8447 cast<CastInst>(TrueVal)->getOperand(0),
C,
8453 if (*CastOp == Instruction::FPToSI || *CastOp == Instruction::FPToUI)
8455 return ::matchSelectPattern(Pred, FMF, CmpLHS, CmpRHS,
8456 C, cast<CastInst>(FalseVal)->getOperand(0),
8460 return ::matchSelectPattern(Pred, FMF, CmpLHS, CmpRHS, TrueVal, FalseVal,
8486 case Intrinsic::smax:
return Intrinsic::smin;
8487 case Intrinsic::smin:
return Intrinsic::smax;
8488 case Intrinsic::umax:
return Intrinsic::umin;
8489 case Intrinsic::umin:
return Intrinsic::umax;
8492 case Intrinsic::maximum:
return Intrinsic::minimum;
8493 case Intrinsic::minimum:
return Intrinsic::maximum;
8494 case Intrinsic::maxnum:
return Intrinsic::minnum;
8495 case Intrinsic::minnum:
return Intrinsic::maxnum;
8510std::pair<Intrinsic::ID, bool>
8515 bool AllCmpSingleUse =
true;
8518 if (
all_of(VL, [&SelectPattern, &AllCmpSingleUse](
Value *
I) {
8524 !
I->getType()->isIntOrIntVectorTy())
8527 SelectPattern.
Flavor != CurrentPattern.Flavor)
8529 SelectPattern = CurrentPattern;
8534 switch (SelectPattern.
Flavor) {
8536 return {Intrinsic::smin, AllCmpSingleUse};
8538 return {Intrinsic::umin, AllCmpSingleUse};
8540 return {Intrinsic::smax, AllCmpSingleUse};
8542 return {Intrinsic::umax, AllCmpSingleUse};
8555 if (
P->getNumIncomingValues() != 2)
8558 for (
unsigned i = 0; i != 2; ++i) {
8559 Value *L =
P->getIncomingValue(i);
8560 Value *R =
P->getIncomingValue(!i);
8561 auto *LU = dyn_cast<BinaryOperator>(L);
8564 unsigned Opcode = LU->getOpcode();
8570 case Instruction::LShr:
8571 case Instruction::AShr:
8572 case Instruction::Shl:
8573 case Instruction::Add:
8574 case Instruction::Sub:
8575 case Instruction::And:
8576 case Instruction::Or:
8577 case Instruction::Mul:
8578 case Instruction::FMul: {
8579 Value *LL = LU->getOperand(0);
8580 Value *LR = LU->getOperand(1);
8610 P = dyn_cast<PHINode>(
I->getOperand(0));
8612 P = dyn_cast<PHINode>(
I->getOperand(1));
8633 return !
C->isNegative();
8645 const APInt *CLHS, *CRHS;
8648 return CLHS->
sle(*CRHS);
8686 const APInt *CLHS, *CRHS;
8689 return CLHS->
ule(*CRHS);
8698static std::optional<bool>
8703 return std::nullopt;
8710 return std::nullopt;
8717 return std::nullopt;
8724 return std::nullopt;
8731 return std::nullopt;
8738static std::optional<bool>
8746 return std::nullopt;
8763 return std::nullopt;
8780 LHSIsTrue ?
LHS->getPredicate() :
LHS->getInversePredicate();
8804 const APInt *LC, *RC;
8809 if (L0 == R0 && L1 == R1)
8817 return LPred == RPred;
8822 return std::nullopt;
8829static std::optional<bool>
8834 assert((
LHS->getOpcode() == Instruction::And ||
8835 LHS->getOpcode() == Instruction::Or ||
8836 LHS->getOpcode() == Instruction::Select) &&
8837 "Expected LHS to be 'and', 'or', or 'select'.");
8844 const Value *ALHS, *ARHS;
8849 ALHS, RHSPred, RHSOp0, RHSOp1,
DL, LHSIsTrue,
Depth + 1))
8852 ARHS, RHSPred, RHSOp0, RHSOp1,
DL, LHSIsTrue,
Depth + 1))
8854 return std::nullopt;
8856 return std::nullopt;
8865 return std::nullopt;
8870 return std::nullopt;
8873 "Expected integer type only!");
8877 LHSIsTrue = !LHSIsTrue;
8888 if ((LHSI->getOpcode() == Instruction::And ||
8889 LHSI->getOpcode() == Instruction::Or ||
8890 LHSI->getOpcode() == Instruction::Select))
8894 return std::nullopt;
8899 bool LHSIsTrue,
unsigned Depth) {
8905 bool InvertRHS =
false;
8912 if (
const ICmpInst *RHSCmp = dyn_cast<ICmpInst>(
RHS)) {
8914 LHS, RHSCmp->getPredicate(), RHSCmp->getOperand(0),
8915 RHSCmp->getOperand(1),
DL, LHSIsTrue,
Depth))
8916 return InvertRHS ? !*Implied : *Implied;
8917 return std::nullopt;
8921 return std::nullopt;
8925 const Value *RHS1, *RHS2;
8927 if (std::optional<bool> Imp =
8931 if (std::optional<bool> Imp =
8937 if (std::optional<bool> Imp =
8941 if (std::optional<bool> Imp =
8947 return std::nullopt;
8952static std::pair<Value *, bool>
8954 if (!ContextI || !ContextI->
getParent())
8955 return {
nullptr,
false};
8962 return {
nullptr,
false};
8968 return {
nullptr,
false};
8971 if (TrueBB == FalseBB)
8972 return {
nullptr,
false};
8974 assert((TrueBB == ContextBB || FalseBB == ContextBB) &&
8975 "Predecessor block does not point to successor?");
8978 return {PredCond, TrueBB == ContextBB};
8984 assert(
Cond->getType()->isIntOrIntVectorTy(1) &&
"Condition must be bool");
8988 return std::nullopt;
9000 return std::nullopt;
9005 bool PreferSignedRange) {
9006 unsigned Width =
Lower.getBitWidth();
9009 case Instruction::Add:
9018 if (PreferSignedRange && HasNSW && HasNUW)
9024 }
else if (HasNSW) {
9025 if (
C->isNegative()) {
9038 case Instruction::And:
9049 case Instruction::Or:
9055 case Instruction::AShr:
9061 unsigned ShiftAmount = Width - 1;
9062 if (!
C->isZero() && IIQ.
isExact(&BO))
9063 ShiftAmount =
C->countr_zero();
9064 if (
C->isNegative()) {
9067 Upper =
C->ashr(ShiftAmount) + 1;
9070 Lower =
C->ashr(ShiftAmount);
9076 case Instruction::LShr:
9082 unsigned ShiftAmount = Width - 1;
9083 if (!
C->isZero() && IIQ.
isExact(&BO))
9084 ShiftAmount =
C->countr_zero();
9085 Lower =
C->lshr(ShiftAmount);
9090 case Instruction::Shl:
9097 if (
C->isNegative()) {
9099 unsigned ShiftAmount =
C->countl_one() - 1;
9100 Lower =
C->shl(ShiftAmount);
9104 unsigned ShiftAmount =
C->countl_zero() - 1;
9106 Upper =
C->shl(ShiftAmount) + 1;
9125 case Instruction::SDiv:
9129 if (
C->isAllOnes()) {
9134 }
else if (
C->countl_zero() < Width - 1) {
9145 if (
C->isMinSignedValue()) {
9157 case Instruction::UDiv:
9167 case Instruction::SRem:
9173 if (
C->isNegative()) {
9184 case Instruction::URem:
9202 case Intrinsic::ctpop:
9203 case Intrinsic::ctlz:
9204 case Intrinsic::cttz:
9207 APInt(Width, Width + 1));
9208 case Intrinsic::uadd_sat:
9214 case Intrinsic::sadd_sat:
9217 if (
C->isNegative())
9228 case Intrinsic::usub_sat:
9238 case Intrinsic::ssub_sat:
9240 if (
C->isNegative())
9250 if (
C->isNegative())
9261 case Intrinsic::umin:
9262 case Intrinsic::umax:
9263 case Intrinsic::smin:
9264 case Intrinsic::smax:
9270 case Intrinsic::umin:
9272 case Intrinsic::umax:
9274 case Intrinsic::smin:
9277 case Intrinsic::smax:
9284 case Intrinsic::abs:
9293 case Intrinsic::vscale:
9301 return ConstantRange::getFull(Width);
9306 unsigned BitWidth = SI.getType()->getScalarSizeInBits();
9310 return ConstantRange::getFull(
BitWidth);
9333 return ConstantRange::getFull(
BitWidth);
9347 return ConstantRange::getFull(
BitWidth);
9354 unsigned BitWidth =
I->getType()->getScalarSizeInBits();
9355 if (!
I->getOperand(0)->getType()->getScalarType()->isHalfTy())
9357 if (isa<FPToSIInst>(
I) &&
BitWidth >= 17) {
9362 if (isa<FPToUIInst>(
I) &&
BitWidth >= 16) {
9373 assert(V->getType()->isIntOrIntVectorTy() &&
"Expected integer instruction");
9376 return ConstantRange::getFull(V->getType()->getScalarSizeInBits());
9381 unsigned BitWidth = V->getType()->getScalarSizeInBits();
9383 if (
auto *VC = dyn_cast<ConstantDataVector>(V)) {
9385 for (
unsigned ElemIdx = 0, NElem = VC->getNumElements(); ElemIdx < NElem;
9387 CR = CR.
unionWith(VC->getElementAsAPInt(ElemIdx));
9393 if (
auto *BO = dyn_cast<BinaryOperator>(V)) {
9399 }
else if (
auto *II = dyn_cast<IntrinsicInst>(V))
9401 else if (
auto *SI = dyn_cast<SelectInst>(V)) {
9403 SI->getTrueValue(), ForSigned, UseInstrInfo, AC, CtxI, DT,
Depth + 1);
9405 SI->getFalseValue(), ForSigned, UseInstrInfo, AC, CtxI, DT,
Depth + 1);
9408 }
else if (isa<FPToUIInst>(V) || isa<FPToSIInst>(V)) {
9414 }
else if (
const auto *
A = dyn_cast<Argument>(V))
9415 if (std::optional<ConstantRange> Range =
A->getRange())
9418 if (
auto *
I = dyn_cast<Instruction>(V)) {
9419 if (
auto *Range = IIQ.
getMetadata(
I, LLVMContext::MD_range))
9422 if (
const auto *CB = dyn_cast<CallBase>(V))
9423 if (std::optional<ConstantRange> Range = CB->getRange())
9434 "Got assumption for the wrong function!");
9435 assert(
I->getCalledFunction()->getIntrinsicID() == Intrinsic::assume &&
9436 "must be an assume intrinsic");
9440 Value *Arg =
I->getArgOperand(0);
9441 ICmpInst *Cmp = dyn_cast<ICmpInst>(Arg);
9443 if (!Cmp || Cmp->getOperand(0) != V)
9448 UseInstrInfo, AC,
I, DT,
Depth + 1);
9461 if (isa<Argument>(V) || isa<GlobalValue>(V)) {
9463 }
else if (
auto *
I = dyn_cast<Instruction>(V)) {
9469 if (isa<Instruction>(
Op) || isa<Argument>(
Op))
9477 auto AddAffected = [&InsertAffected](
Value *V) {
9492 while (!Worklist.
empty()) {
9494 if (!Visited.
insert(V).second)
9517 AddCmpOperands(
A,
B);
9561 AddCmpOperands(
A,
B);
9571 }
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)
static APFloat getLargest(const fltSemantics &Sem, bool Negative=false)
Returns the largest finite number in the given semantics.
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.
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