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())) && ICmpInst::isEquality(P);
266 bool OrZero,
unsigned Depth,
269 return ::isKnownToBeAPowerOfTwo(
284 if (
auto *CI = dyn_cast<ConstantInt>(V))
285 return CI->getValue().isStrictlyPositive();
306 return ::isKnownNonEqual(
315 return Mask.isSubsetOf(Known.
Zero);
323 auto *FVTy = dyn_cast<FixedVectorType>(V->getType());
333 return ::ComputeNumSignBits(
342 return V->getType()->getScalarSizeInBits() - SignBits + 1;
347 const APInt &DemandedElts,
354 if (KnownOut.
isUnknown() && !NSW && !NUW)
379 bool isKnownNegativeOp0 = Known2.
isNegative();
382 (isKnownNonNegativeOp1 && isKnownNonNegativeOp0);
387 (isKnownNegativeOp1 && isKnownNonNegativeOp0 &&
389 (isKnownNegativeOp0 && isKnownNonNegativeOp1 && Known.
isNonZero());
393 bool SelfMultiply = Op0 == Op1;
413 unsigned NumRanges = Ranges.getNumOperands() / 2;
419 for (
unsigned i = 0; i < NumRanges; ++i) {
421 mdconst::extract<ConstantInt>(Ranges.getOperand(2 * i + 0));
423 mdconst::extract<ConstantInt>(Ranges.getOperand(2 * i + 1));
427 unsigned CommonPrefixBits =
428 (Range.getUnsignedMax() ^ Range.getUnsignedMin()).
countl_zero();
430 APInt UnsignedMax = Range.getUnsignedMax().zextOrTrunc(
BitWidth);
431 Known.
One &= UnsignedMax & Mask;
432 Known.
Zero &= ~UnsignedMax & Mask;
447 while (!WorkSet.
empty()) {
449 if (!Visited.
insert(V).second)
454 return EphValues.count(U);
459 if (V ==
I || (isa<Instruction>(V) &&
461 !cast<Instruction>(V)->isTerminator())) {
463 if (
const User *U = dyn_cast<User>(V))
475 return CI->isAssumeLikeIntrinsic();
483 bool AllowEphemerals) {
501 if (!AllowEphemerals && Inv == CxtI)
536 if (Pred == ICmpInst::ICMP_UGT)
540 if (Pred == ICmpInst::ICMP_NE)
551 auto *VC = dyn_cast<ConstantDataVector>(
RHS);
555 for (
unsigned ElemIdx = 0, NElem = VC->getNumElements(); ElemIdx < NElem;
558 Pred, VC->getElementAsAPInt(ElemIdx));
577 "Got assumption for the wrong function!");
580 if (!V->getType()->isPointerTy())
583 *
I,
I->bundle_op_info_begin()[Elem.Index])) {
585 (RK.AttrKind == Attribute::NonNull ||
586 (RK.AttrKind == Attribute::Dereferenceable &&
588 V->getType()->getPointerAddressSpace()))) &&
620 case ICmpInst::ICMP_EQ:
623 case ICmpInst::ICMP_SGE:
624 case ICmpInst::ICMP_SGT:
627 case ICmpInst::ICMP_SLT:
645 case ICmpInst::ICMP_EQ:
655 Known.
Zero |= ~*
C & *Mask;
661 Known.
One |= *
C & ~*Mask;
682 Known.
Zero |= RHSKnown.
Zero << ShAmt;
683 Known.
One |= RHSKnown.
One << ShAmt;
686 case ICmpInst::ICMP_NE: {
703 if ((Pred == ICmpInst::ICMP_UGT || Pred == ICmpInst::ICMP_UGE) &&
706 (*
C + (Pred == ICmpInst::ICMP_UGT)).countLeadingOnes());
709 if ((Pred == ICmpInst::ICMP_ULT || Pred == ICmpInst::ICMP_ULE) &&
712 (*
C - (Pred == ICmpInst::ICMP_ULT)).countLeadingZeros());
723 Invert ? Cmp->getInversePredicate() : Cmp->getPredicate();
756 if (
auto *Cmp = dyn_cast<ICmpInst>(
Cond))
797 "Got assumption for the wrong function!");
800 if (!V->getType()->isPointerTy())
803 *
I,
I->bundle_op_info_begin()[Elem.Index])) {
804 if (RK.WasOn == V && RK.AttrKind == Attribute::Alignment &&
816 Value *Arg =
I->getArgOperand(0);
836 ICmpInst *Cmp = dyn_cast<ICmpInst>(Arg);
872 Known = KF(Known2, Known, ShAmtNonZero);
883 Value *
X =
nullptr, *
Y =
nullptr;
885 switch (
I->getOpcode()) {
886 case Instruction::And:
887 KnownOut = KnownLHS & KnownRHS;
897 KnownOut = KnownLHS.
blsi();
899 KnownOut = KnownRHS.
blsi();
902 case Instruction::Or:
903 KnownOut = KnownLHS | KnownRHS;
905 case Instruction::Xor:
906 KnownOut = KnownLHS ^ KnownRHS;
916 const KnownBits &XBits =
I->getOperand(0) ==
X ? KnownLHS : KnownRHS;
917 KnownOut = XBits.
blsmsk();
930 if (!KnownOut.
Zero[0] && !KnownOut.
One[0] &&
952 auto *FVTy = dyn_cast<FixedVectorType>(
I->getType());
961 Attribute Attr =
F->getFnAttribute(Attribute::VScaleRange);
969 return ConstantRange::getEmpty(
BitWidth);
980 const APInt &DemandedElts,
986 switch (
I->getOpcode()) {
988 case Instruction::Load:
993 case Instruction::And:
999 case Instruction::Or:
1005 case Instruction::Xor:
1011 case Instruction::Mul: {
1014 Known, Known2,
Depth, Q);
1017 case Instruction::UDiv: {
1024 case Instruction::SDiv: {
1031 case Instruction::Select: {
1032 auto ComputeForArm = [&](
Value *Arm,
bool Invert) {
1068 ComputeForArm(
I->getOperand(1),
false)
1072 case Instruction::FPTrunc:
1073 case Instruction::FPExt:
1074 case Instruction::FPToUI:
1075 case Instruction::FPToSI:
1076 case Instruction::SIToFP:
1077 case Instruction::UIToFP:
1079 case Instruction::PtrToInt:
1080 case Instruction::IntToPtr:
1083 case Instruction::ZExt:
1084 case Instruction::Trunc: {
1085 Type *SrcTy =
I->getOperand(0)->getType();
1087 unsigned SrcBitWidth;
1095 assert(SrcBitWidth &&
"SrcBitWidth can't be zero");
1098 if (
auto *Inst = dyn_cast<PossiblyNonNegInst>(
I);
1099 Inst && Inst->hasNonNeg() && !Known.
isNegative())
1104 case Instruction::BitCast: {
1105 Type *SrcTy =
I->getOperand(0)->getType();
1109 !
I->getType()->isVectorTy()) {
1115 auto *SrcVecTy = dyn_cast<FixedVectorType>(SrcTy);
1116 if (!SrcVecTy || !SrcVecTy->getElementType()->isIntegerTy() ||
1117 !
I->getType()->isIntOrIntVectorTy() ||
1118 isa<ScalableVectorType>(
I->getType()))
1123 unsigned SubBitWidth = SrcVecTy->getScalarSizeInBits();
1140 unsigned SubScale =
BitWidth / SubBitWidth;
1142 for (
unsigned i = 0; i != NumElts; ++i) {
1143 if (DemandedElts[i])
1144 SubDemandedElts.
setBit(i * SubScale);
1148 for (
unsigned i = 0; i != SubScale; ++i) {
1152 Known.
insertBits(KnownSrc, ShiftElt * SubBitWidth);
1157 case Instruction::SExt: {
1159 unsigned SrcBitWidth =
I->getOperand(0)->getType()->getScalarSizeInBits();
1161 Known = Known.
trunc(SrcBitWidth);
1168 case Instruction::Shl: {
1172 bool ShAmtNonZero) {
1173 return KnownBits::shl(KnownVal, KnownAmt, NUW, NSW, ShAmtNonZero);
1183 case Instruction::LShr: {
1184 bool Exact = Q.
IIQ.
isExact(cast<BinaryOperator>(
I));
1186 bool ShAmtNonZero) {
1197 case Instruction::AShr: {
1198 bool Exact = Q.
IIQ.
isExact(cast<BinaryOperator>(
I));
1200 bool ShAmtNonZero) {
1207 case Instruction::Sub: {
1211 DemandedElts, Known, Known2,
Depth, Q);
1214 case Instruction::Add: {
1218 DemandedElts, Known, Known2,
Depth, Q);
1221 case Instruction::SRem:
1227 case Instruction::URem:
1232 case Instruction::Alloca:
1235 case Instruction::GetElementPtr: {
1244 for (
unsigned i = 1, e =
I->getNumOperands(); i != e; ++i, ++GTI) {
1260 "Access to structure field must be known at compile time");
1265 unsigned Idx = cast<ConstantInt>(
Index)->getZExtValue();
1268 AccConstIndices +=
Offset;
1279 unsigned IndexBitWidth =
Index->getType()->getScalarSizeInBits();
1293 APInt ScalingFactor(IndexBitWidth, TypeSizeInBytes);
1294 IndexConst *= ScalingFactor;
1311 true,
false,
false, Known, IndexBits);
1316 true,
false,
false, Known,
Index);
1320 case Instruction::PHI: {
1323 Value *R =
nullptr, *L =
nullptr;
1333 if ((Opcode == Instruction::LShr || Opcode == Instruction::AShr ||
1334 Opcode == Instruction::Shl) &&
1349 case Instruction::Shl:
1353 case Instruction::LShr:
1358 case Instruction::AShr:
1369 if (Opcode == Instruction::Add ||
1370 Opcode == Instruction::Sub ||
1371 Opcode == Instruction::And ||
1372 Opcode == Instruction::Or ||
1373 Opcode == Instruction::Mul) {
1380 unsigned OpNum =
P->getOperand(0) == R ? 0 : 1;
1381 Instruction *RInst =
P->getIncomingBlock(OpNum)->getTerminator();
1382 Instruction *LInst =
P->getIncomingBlock(1-OpNum)->getTerminator();
1397 auto *OverflowOp = dyn_cast<OverflowingBinaryOperator>(BO);
1408 if (Opcode == Instruction::Add) {
1417 else if (Opcode == Instruction::Sub && BO->
getOperand(0) ==
I) {
1425 else if (Opcode == Instruction::Mul && Known2.
isNonNegative() &&
1435 if (
P->getNumIncomingValues() == 0)
1442 if (isa_and_nonnull<UndefValue>(
P->hasConstantValue()))
1447 for (
unsigned u = 0, e =
P->getNumIncomingValues(); u < e; ++u) {
1448 Value *IncValue =
P->getIncomingValue(u);
1450 if (IncValue ==
P)
continue;
1457 RecQ.
CxtI =
P->getIncomingBlock(u)->getTerminator();
1478 if ((TrueSucc ==
P->getParent()) != (FalseSucc ==
P->getParent())) {
1480 if (FalseSucc ==
P->getParent())
1494 Known2 = KnownUnion;
1508 case Instruction::Call:
1509 case Instruction::Invoke: {
1517 const auto *CB = cast<CallBase>(
I);
1519 if (std::optional<ConstantRange> Range = CB->getRange())
1520 Known = Known.
unionWith(Range->toKnownBits());
1522 if (
const Value *RV = CB->getReturnedArgOperand()) {
1523 if (RV->getType() ==
I->getType()) {
1535 switch (II->getIntrinsicID()) {
1537 case Intrinsic::abs: {
1539 bool IntMinIsPoison =
match(II->getArgOperand(1),
m_One());
1540 Known = Known2.
abs(IntMinIsPoison);
1543 case Intrinsic::bitreverse:
1548 case Intrinsic::bswap:
1553 case Intrinsic::ctlz: {
1559 PossibleLZ = std::min(PossibleLZ,
BitWidth - 1);
1564 case Intrinsic::cttz: {
1570 PossibleTZ = std::min(PossibleTZ,
BitWidth - 1);
1575 case Intrinsic::ctpop: {
1586 case Intrinsic::fshr:
1587 case Intrinsic::fshl: {
1594 if (II->getIntrinsicID() == Intrinsic::fshr)
1607 case Intrinsic::uadd_sat:
1612 case Intrinsic::usub_sat:
1617 case Intrinsic::sadd_sat:
1622 case Intrinsic::ssub_sat:
1629 case Intrinsic::vector_reduce_and:
1630 case Intrinsic::vector_reduce_or:
1631 case Intrinsic::vector_reduce_umax:
1632 case Intrinsic::vector_reduce_umin:
1633 case Intrinsic::vector_reduce_smax:
1634 case Intrinsic::vector_reduce_smin:
1637 case Intrinsic::vector_reduce_xor: {
1642 auto *VecTy = cast<VectorType>(
I->getOperand(0)->getType());
1644 bool EvenCnt = VecTy->getElementCount().isKnownEven();
1648 if (VecTy->isScalableTy() || EvenCnt)
1652 case Intrinsic::umin:
1657 case Intrinsic::umax:
1662 case Intrinsic::smin:
1667 case Intrinsic::smax:
1672 case Intrinsic::ptrmask: {
1675 const Value *Mask =
I->getOperand(1);
1676 Known2 =
KnownBits(Mask->getType()->getScalarSizeInBits());
1682 case Intrinsic::x86_sse42_crc32_64_64:
1685 case Intrinsic::riscv_vsetvli:
1686 case Intrinsic::riscv_vsetvlimax: {
1687 bool HasAVL = II->getIntrinsicID() == Intrinsic::riscv_vsetvli;
1690 cast<ConstantInt>(II->getArgOperand(HasAVL))->getZExtValue());
1692 cast<ConstantInt>(II->getArgOperand(1 + HasAVL))->getZExtValue());
1701 if (
auto *CI = dyn_cast<ConstantInt>(II->getArgOperand(0)))
1702 MaxVL = std::min(MaxVL, CI->getZExtValue());
1704 unsigned KnownZeroFirstBit =
Log2_32(MaxVL) + 1;
1709 case Intrinsic::vscale: {
1710 if (!II->getParent() || !II->getFunction())
1720 case Instruction::ShuffleVector: {
1721 auto *Shuf = dyn_cast<ShuffleVectorInst>(
I);
1729 APInt DemandedLHS, DemandedRHS;
1736 if (!!DemandedLHS) {
1737 const Value *
LHS = Shuf->getOperand(0);
1743 if (!!DemandedRHS) {
1744 const Value *
RHS = Shuf->getOperand(1);
1750 case Instruction::InsertElement: {
1751 if (isa<ScalableVectorType>(
I->getType())) {
1755 const Value *Vec =
I->getOperand(0);
1756 const Value *Elt =
I->getOperand(1);
1757 auto *CIdx = dyn_cast<ConstantInt>(
I->getOperand(2));
1759 APInt DemandedVecElts = DemandedElts;
1760 bool NeedsElt =
true;
1762 if (CIdx && CIdx->getValue().ult(NumElts)) {
1763 DemandedVecElts.
clearBit(CIdx->getZExtValue());
1764 NeedsElt = DemandedElts[CIdx->getZExtValue()];
1776 if (!DemandedVecElts.
isZero()) {
1782 case Instruction::ExtractElement: {
1785 const Value *Vec =
I->getOperand(0);
1787 auto *CIdx = dyn_cast<ConstantInt>(
Idx);
1788 if (isa<ScalableVectorType>(Vec->
getType())) {
1793 unsigned NumElts = cast<FixedVectorType>(Vec->
getType())->getNumElements();
1795 if (CIdx && CIdx->getValue().ult(NumElts))
1800 case Instruction::ExtractValue:
1801 if (
IntrinsicInst *II = dyn_cast<IntrinsicInst>(
I->getOperand(0))) {
1805 switch (II->getIntrinsicID()) {
1807 case Intrinsic::uadd_with_overflow:
1808 case Intrinsic::sadd_with_overflow:
1810 true, II->getArgOperand(0), II->getArgOperand(1),
false,
1811 false, DemandedElts, Known, Known2,
Depth, Q);
1813 case Intrinsic::usub_with_overflow:
1814 case Intrinsic::ssub_with_overflow:
1816 false, II->getArgOperand(0), II->getArgOperand(1),
false,
1817 false, DemandedElts, Known, Known2,
Depth, Q);
1819 case Intrinsic::umul_with_overflow:
1820 case Intrinsic::smul_with_overflow:
1822 DemandedElts, Known, Known2,
Depth, Q);
1828 case Instruction::Freeze:
1872 if (!DemandedElts) {
1878 assert(V &&
"No Value?");
1882 Type *Ty = V->getType();
1886 "Not integer or pointer type!");
1888 if (
auto *FVTy = dyn_cast<FixedVectorType>(Ty)) {
1890 FVTy->getNumElements() == DemandedElts.
getBitWidth() &&
1891 "DemandedElt width should equal the fixed vector number of elements");
1894 "DemandedElt width should be 1 for scalars or scalable vectors");
1900 "V and Known should have same BitWidth");
1903 "V and Known should have same BitWidth");
1914 if (isa<ConstantPointerNull>(V) || isa<ConstantAggregateZero>(V)) {
1921 assert(!isa<ScalableVectorType>(V->getType()));
1925 for (
unsigned i = 0, e = CDV->getNumElements(); i != e; ++i) {
1926 if (!DemandedElts[i])
1928 APInt Elt = CDV->getElementAsAPInt(i);
1937 if (
const auto *CV = dyn_cast<ConstantVector>(V)) {
1938 assert(!isa<ScalableVectorType>(V->getType()));
1942 for (
unsigned i = 0, e = CV->getNumOperands(); i != e; ++i) {
1943 if (!DemandedElts[i])
1946 if (isa<PoisonValue>(Element))
1948 auto *ElementCI = dyn_cast_or_null<ConstantInt>(Element);
1953 const APInt &Elt = ElementCI->getValue();
1966 if (isa<UndefValue>(V))
1971 assert(!isa<ConstantData>(V) &&
"Unhandled constant data!");
1973 if (
const auto *
A = dyn_cast<Argument>(V))
1974 if (std::optional<ConstantRange> Range =
A->getRange())
1975 Known = Range->toKnownBits();
1983 if (
const GlobalAlias *GA = dyn_cast<GlobalAlias>(V)) {
1984 if (!GA->isInterposable())
1989 if (
const Operator *
I = dyn_cast<Operator>(V))
1991 else if (
const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
1992 if (std::optional<ConstantRange> CR = GV->getAbsoluteSymbolRange())
1993 Known = CR->toKnownBits();
1997 if (isa<PointerType>(V->getType())) {
1998 Align Alignment = V->getPointerAlignment(Q.
DL);
2008 assert((Known.
Zero & Known.
One) == 0 &&
"Bits known to be one AND zero?");
2016 Value *Start =
nullptr, *Step =
nullptr;
2022 if (U.get() == Start) {
2038 case Instruction::Mul:
2043 case Instruction::SDiv:
2049 case Instruction::UDiv:
2055 case Instruction::Shl:
2057 case Instruction::AShr:
2061 case Instruction::LShr:
2076 if (isa<Constant>(V))
2080 if (OrZero && V->getType()->getScalarSizeInBits() == 1)
2083 auto *
I = dyn_cast<Instruction>(V);
2090 return F->hasFnAttribute(Attribute::VScaleRange);
2107 switch (
I->getOpcode()) {
2108 case Instruction::ZExt:
2110 case Instruction::Trunc:
2112 case Instruction::Shl:
2116 case Instruction::LShr:
2117 if (OrZero || Q.
IIQ.
isExact(cast<BinaryOperator>(
I)))
2120 case Instruction::UDiv:
2124 case Instruction::Mul:
2128 case Instruction::And:
2139 case Instruction::Add: {
2145 if (
match(
I->getOperand(0),
2149 if (
match(
I->getOperand(1),
2154 unsigned BitWidth = V->getType()->getScalarSizeInBits();
2163 if ((~(LHSBits.
Zero & RHSBits.
Zero)).isPowerOf2())
2171 case Instruction::Select:
2174 case Instruction::PHI: {
2178 auto *PN = cast<PHINode>(
I);
2195 RecQ.CxtI = PN->getIncomingBlock(U)->getTerminator();
2196 return isKnownToBeAPowerOfTwo(U.get(), OrZero, NewDepth, RecQ);
2199 case Instruction::Invoke:
2200 case Instruction::Call: {
2201 if (
auto *II = dyn_cast<IntrinsicInst>(
I)) {
2202 switch (II->getIntrinsicID()) {
2203 case Intrinsic::umax:
2204 case Intrinsic::smax:
2205 case Intrinsic::umin:
2206 case Intrinsic::smin:
2211 case Intrinsic::bitreverse:
2212 case Intrinsic::bswap:
2214 case Intrinsic::fshr:
2215 case Intrinsic::fshl:
2217 if (II->getArgOperand(0) == II->getArgOperand(1))
2241 F =
I->getFunction();
2243 if (!
GEP->isInBounds() ||
2248 assert(
GEP->getType()->isPointerTy() &&
"We only support plain pointer GEP");
2259 GTI != GTE; ++GTI) {
2261 if (
StructType *STy = GTI.getStructTypeOrNull()) {
2262 ConstantInt *OpC = cast<ConstantInt>(GTI.getOperand());
2266 if (ElementOffset > 0)
2272 if (GTI.getSequentialElementStride(Q.
DL).isZero())
2277 if (
ConstantInt *OpC = dyn_cast<ConstantInt>(GTI.getOperand())) {
2301 assert(!isa<Constant>(V) &&
"Called for constant?");
2306 unsigned NumUsesExplored = 0;
2307 for (
const auto *U : V->users()) {
2315 if (
const auto *CB = dyn_cast<CallBase>(U))
2316 if (
auto *CalledFunc = CB->getCalledFunction())
2317 for (
const Argument &Arg : CalledFunc->args())
2318 if (CB->getArgOperand(Arg.getArgNo()) == V &&
2319 Arg.hasNonNullAttr(
false) &&
2327 V->getType()->getPointerAddressSpace()) &&
2345 NonNullIfTrue =
true;
2347 NonNullIfTrue =
false;
2353 for (
const auto *CmpU : U->users()) {
2355 if (Visited.
insert(CmpU).second)
2358 while (!WorkList.
empty()) {
2367 for (
const auto *CurrU : Curr->users())
2368 if (Visited.
insert(CurrU).second)
2373 if (
const BranchInst *BI = dyn_cast<BranchInst>(Curr)) {
2374 assert(BI->isConditional() &&
"uses a comparison!");
2377 BI->getSuccessor(NonNullIfTrue ? 0 : 1);
2381 }
else if (NonNullIfTrue &&
isGuard(Curr) &&
2382 DT->
dominates(cast<Instruction>(Curr), CtxI)) {
2396 const unsigned NumRanges = Ranges->getNumOperands() / 2;
2398 for (
unsigned i = 0; i < NumRanges; ++i) {
2400 mdconst::extract<ConstantInt>(Ranges->getOperand(2 * i + 0));
2402 mdconst::extract<ConstantInt>(Ranges->getOperand(2 * i + 1));
2404 if (Range.contains(
Value))
2414 Value *Start =
nullptr, *Step =
nullptr;
2415 const APInt *StartC, *StepC;
2421 case Instruction::Add:
2427 case Instruction::Mul:
2430 case Instruction::Shl:
2432 case Instruction::AShr:
2433 case Instruction::LShr:
2442 Value *
Y,
bool NSW,
bool NUW) {
2487 if (
auto *
C = dyn_cast<Constant>(
X))
2491 return ::isKnownNonEqual(
X,
Y,
Depth, Q);
2496 Value *
Y,
bool NSW,
bool NUW) {
2525 auto ShiftOp = [&](
const APInt &Lhs,
const APInt &Rhs) {
2526 switch (
I->getOpcode()) {
2527 case Instruction::Shl:
2528 return Lhs.
shl(Rhs);
2529 case Instruction::LShr:
2530 return Lhs.
lshr(Rhs);
2531 case Instruction::AShr:
2532 return Lhs.
ashr(Rhs);
2538 auto InvShiftOp = [&](
const APInt &Lhs,
const APInt &Rhs) {
2539 switch (
I->getOpcode()) {
2540 case Instruction::Shl:
2541 return Lhs.
lshr(Rhs);
2542 case Instruction::LShr:
2543 case Instruction::AShr:
2544 return Lhs.
shl(Rhs);
2557 if (MaxShift.
uge(NumBits))
2560 if (!ShiftOp(KnownVal.
One, MaxShift).isZero())
2565 if (InvShiftOp(KnownVal.
Zero, NumBits - MaxShift)
2574 const APInt &DemandedElts,
2577 switch (
I->getOpcode()) {
2578 case Instruction::Alloca:
2580 return I->getType()->getPointerAddressSpace() == 0;
2581 case Instruction::GetElementPtr:
2582 if (
I->getType()->isPointerTy())
2585 case Instruction::BitCast: {
2613 Type *FromTy =
I->getOperand(0)->getType();
2618 case Instruction::IntToPtr:
2622 if (!isa<ScalableVectorType>(
I->getType()) &&
2627 case Instruction::PtrToInt:
2630 if (!isa<ScalableVectorType>(
I->getType()) &&
2635 case Instruction::Trunc:
2637 if (
auto *TI = dyn_cast<TruncInst>(
I))
2638 if (TI->hasNoSignedWrap() || TI->hasNoUnsignedWrap())
2642 case Instruction::Sub:
2645 case Instruction::Or:
2649 case Instruction::SExt:
2650 case Instruction::ZExt:
2654 case Instruction::Shl: {
2669 case Instruction::LShr:
2670 case Instruction::AShr: {
2685 case Instruction::UDiv:
2686 case Instruction::SDiv: {
2689 if (cast<PossiblyExactOperator>(
I)->isExact())
2701 if (
I->getOpcode() == Instruction::SDiv) {
2703 XKnown = XKnown.
abs(
false);
2704 YKnown = YKnown.
abs(
false);
2710 return XUgeY && *XUgeY;
2712 case Instruction::Add: {
2717 auto *BO = cast<OverflowingBinaryOperator>(
I);
2722 case Instruction::Mul: {
2728 case Instruction::Select: {
2735 auto SelectArmIsNonZero = [&](
bool IsTrueArm) {
2737 Op = IsTrueArm ?
I->getOperand(1) :
I->getOperand(2);
2750 Pred = ICmpInst::getInversePredicate(Pred);
2755 if (SelectArmIsNonZero(
true) &&
2756 SelectArmIsNonZero(
false))
2760 case Instruction::PHI: {
2761 auto *PN = cast<PHINode>(
I);
2771 RecQ.CxtI = PN->getIncomingBlock(U)->getTerminator();
2773 ICmpInst::Predicate Pred;
2775 BasicBlock *TrueSucc, *FalseSucc;
2776 if (match(RecQ.CxtI,
2777 m_Br(m_c_ICmp(Pred, m_Specific(U.get()), m_Value(X)),
2778 m_BasicBlock(TrueSucc), m_BasicBlock(FalseSucc)))) {
2780 if ((TrueSucc == PN->getParent()) != (FalseSucc == PN->getParent())) {
2782 if (FalseSucc == PN->getParent())
2783 Pred = CmpInst::getInversePredicate(Pred);
2784 if (cmpExcludesZero(Pred, X))
2792 case Instruction::InsertElement: {
2793 if (isa<ScalableVectorType>(
I->getType()))
2796 const Value *Vec =
I->getOperand(0);
2797 const Value *Elt =
I->getOperand(1);
2798 auto *CIdx = dyn_cast<ConstantInt>(
I->getOperand(2));
2801 APInt DemandedVecElts = DemandedElts;
2802 bool SkipElt =
false;
2804 if (CIdx && CIdx->getValue().ult(NumElts)) {
2805 DemandedVecElts.
clearBit(CIdx->getZExtValue());
2806 SkipElt = !DemandedElts[CIdx->getZExtValue()];
2812 (DemandedVecElts.
isZero() ||
2815 case Instruction::ExtractElement:
2816 if (
const auto *EEI = dyn_cast<ExtractElementInst>(
I)) {
2817 const Value *Vec = EEI->getVectorOperand();
2818 const Value *
Idx = EEI->getIndexOperand();
2819 auto *CIdx = dyn_cast<ConstantInt>(
Idx);
2820 if (
auto *VecTy = dyn_cast<FixedVectorType>(Vec->
getType())) {
2821 unsigned NumElts = VecTy->getNumElements();
2823 if (CIdx && CIdx->getValue().ult(NumElts))
2829 case Instruction::ShuffleVector: {
2830 auto *Shuf = dyn_cast<ShuffleVectorInst>(
I);
2833 APInt DemandedLHS, DemandedRHS;
2839 return (DemandedRHS.
isZero() ||
2844 case Instruction::Freeze:
2848 case Instruction::Load: {
2849 auto *LI = cast<LoadInst>(
I);
2852 if (
auto *PtrT = dyn_cast<PointerType>(
I->getType())) {
2865 case Instruction::ExtractValue: {
2871 case Instruction::Add:
2876 case Instruction::Sub:
2879 case Instruction::Mul:
2888 case Instruction::Call:
2889 case Instruction::Invoke: {
2890 const auto *Call = cast<CallBase>(
I);
2891 if (
I->getType()->isPointerTy()) {
2892 if (Call->isReturnNonNull())
2899 if (std::optional<ConstantRange> Range = Call->getRange()) {
2900 const APInt ZeroValue(Range->getBitWidth(), 0);
2901 if (!Range->contains(ZeroValue))
2904 if (
const Value *RV = Call->getReturnedArgOperand())
2909 if (
auto *II = dyn_cast<IntrinsicInst>(
I)) {
2910 switch (II->getIntrinsicID()) {
2911 case Intrinsic::sshl_sat:
2912 case Intrinsic::ushl_sat:
2913 case Intrinsic::abs:
2914 case Intrinsic::bitreverse:
2915 case Intrinsic::bswap:
2916 case Intrinsic::ctpop:
2920 case Intrinsic::ssub_sat:
2922 II->getArgOperand(0), II->getArgOperand(1));
2923 case Intrinsic::sadd_sat:
2925 II->getArgOperand(0), II->getArgOperand(1),
2928 case Intrinsic::vector_reduce_or:
2929 case Intrinsic::vector_reduce_umax:
2930 case Intrinsic::vector_reduce_umin:
2931 case Intrinsic::vector_reduce_smax:
2932 case Intrinsic::vector_reduce_smin:
2934 case Intrinsic::umax:
2935 case Intrinsic::uadd_sat:
2938 case Intrinsic::smax: {
2941 auto IsNonZero = [&](
Value *
Op, std::optional<bool> &OpNonZero,
2943 if (!OpNonZero.has_value())
2944 OpNonZero = OpKnown.isNonZero() ||
2949 std::optional<bool> Op0NonZero, Op1NonZero;
2953 IsNonZero(II->getArgOperand(1), Op1NonZero, Op1Known))
2958 IsNonZero(II->getArgOperand(0), Op0NonZero, Op0Known))
2960 return IsNonZero(II->getArgOperand(1), Op1NonZero, Op1Known) &&
2961 IsNonZero(II->getArgOperand(0), Op0NonZero, Op0Known);
2963 case Intrinsic::smin: {
2979 case Intrinsic::umin:
2982 case Intrinsic::cttz:
2985 case Intrinsic::ctlz:
2988 case Intrinsic::fshr:
2989 case Intrinsic::fshl:
2991 if (II->getArgOperand(0) == II->getArgOperand(1))
2994 case Intrinsic::vscale:
2996 case Intrinsic::experimental_get_vector_length:
3010 return Known.
One != 0;
3021 Type *Ty = V->getType();
3026 if (
auto *FVTy = dyn_cast<FixedVectorType>(Ty)) {
3028 FVTy->getNumElements() == DemandedElts.
getBitWidth() &&
3029 "DemandedElt width should equal the fixed vector number of elements");
3032 "DemandedElt width should be 1 for scalars");
3036 if (
auto *
C = dyn_cast<Constant>(V)) {
3037 if (
C->isNullValue())
3039 if (isa<ConstantInt>(
C))
3045 if (
auto *VecTy = dyn_cast<FixedVectorType>(Ty)) {
3046 for (
unsigned i = 0, e = VecTy->getNumElements(); i != e; ++i) {
3047 if (!DemandedElts[i])
3049 Constant *Elt =
C->getAggregateElement(i);
3052 if (!isa<PoisonValue>(Elt) && !isa<ConstantInt>(Elt))
3061 if (
const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
3062 if (!GV->isAbsoluteSymbolRef() && !GV->hasExternalWeakLinkage() &&
3063 GV->getType()->getAddressSpace() == 0)
3068 if (!isa<ConstantExpr>(V))
3072 if (
const auto *
A = dyn_cast<Argument>(V))
3073 if (std::optional<ConstantRange> Range =
A->getRange()) {
3074 const APInt ZeroValue(Range->getBitWidth(), 0);
3075 if (!Range->contains(ZeroValue))
3088 if (
PointerType *PtrTy = dyn_cast<PointerType>(Ty)) {
3091 if (
const Argument *
A = dyn_cast<Argument>(V)) {
3092 if (((
A->hasPassPointeeByValueCopyAttr() &&
3094 A->hasNonNullAttr()))
3099 if (
const auto *
I = dyn_cast<Operator>(V))
3103 if (!isa<Constant>(V) &&
3112 auto *FVTy = dyn_cast<FixedVectorType>(V->getType());
3113 APInt DemandedElts =
3115 return ::isKnownNonZero(V, DemandedElts, Q,
Depth);
3124static std::optional<std::pair<Value*, Value*>>
3128 return std::nullopt;
3137 case Instruction::Or:
3138 if (!cast<PossiblyDisjointInst>(Op1)->isDisjoint() ||
3139 !cast<PossiblyDisjointInst>(Op2)->isDisjoint())
3142 case Instruction::Xor:
3143 case Instruction::Add: {
3151 case Instruction::Sub:
3157 case Instruction::Mul: {
3161 auto *OBO1 = cast<OverflowingBinaryOperator>(Op1);
3162 auto *OBO2 = cast<OverflowingBinaryOperator>(Op2);
3163 if ((!OBO1->hasNoUnsignedWrap() || !OBO2->hasNoUnsignedWrap()) &&
3164 (!OBO1->hasNoSignedWrap() || !OBO2->hasNoSignedWrap()))
3170 !cast<ConstantInt>(Op1->
getOperand(1))->isZero())
3174 case Instruction::Shl: {
3177 auto *OBO1 = cast<OverflowingBinaryOperator>(Op1);
3178 auto *OBO2 = cast<OverflowingBinaryOperator>(Op2);
3179 if ((!OBO1->hasNoUnsignedWrap() || !OBO2->hasNoUnsignedWrap()) &&
3180 (!OBO1->hasNoSignedWrap() || !OBO2->hasNoSignedWrap()))
3187 case Instruction::AShr:
3188 case Instruction::LShr: {
3189 auto *PEO1 = cast<PossiblyExactOperator>(Op1);
3190 auto *PEO2 = cast<PossiblyExactOperator>(Op2);
3191 if (!PEO1->isExact() || !PEO2->isExact())
3198 case Instruction::SExt:
3199 case Instruction::ZExt:
3203 case Instruction::PHI: {
3204 const PHINode *PN1 = cast<PHINode>(Op1);
3205 const PHINode *PN2 = cast<PHINode>(Op2);
3211 Value *Start1 =
nullptr, *Step1 =
nullptr;
3213 Value *Start2 =
nullptr, *Step2 =
nullptr;
3220 cast<Operator>(BO2));
3229 if (Values->first != PN1 || Values->second != PN2)
3232 return std::make_pair(Start1, Start2);
3235 return std::nullopt;
3249 case Instruction::Or:
3250 if (!cast<PossiblyDisjointInst>(V1)->isDisjoint())
3253 case Instruction::Xor:
3254 case Instruction::Add:
3271 if (
auto *OBO = dyn_cast<OverflowingBinaryOperator>(V2)) {
3274 (OBO->hasNoUnsignedWrap() || OBO->hasNoSignedWrap()) &&
3284 if (
auto *OBO = dyn_cast<OverflowingBinaryOperator>(V2)) {
3287 (OBO->hasNoUnsignedWrap() || OBO->hasNoSignedWrap()) &&
3300 bool UsedFullRecursion =
false;
3302 if (!VisitedBBs.
insert(IncomBB).second)
3306 const APInt *C1, *C2;
3311 if (UsedFullRecursion)
3315 RecQ.
CxtI = IncomBB->getTerminator();
3318 UsedFullRecursion =
true;
3325 const SelectInst *SI1 = dyn_cast<SelectInst>(V1);
3329 if (
const SelectInst *SI2 = dyn_cast<SelectInst>(V2)) {
3331 const Value *Cond2 = SI2->getCondition();
3349 if (!
A->getType()->isPointerTy() || !
B->getType()->isPointerTy())
3352 auto *GEPA = dyn_cast<GEPOperator>(
A);
3353 if (!GEPA || GEPA->getNumIndices() != 1 || !isa<Constant>(GEPA->idx_begin()))
3357 auto *PN = dyn_cast<PHINode>(GEPA->getPointerOperand());
3358 if (!PN || PN->getNumIncomingValues() != 2)
3363 Value *Start =
nullptr;
3365 if (PN->getIncomingValue(0) == Step)
3366 Start = PN->getIncomingValue(1);
3367 else if (PN->getIncomingValue(1) == Step)
3368 Start = PN->getIncomingValue(0);
3379 APInt StartOffset(IndexWidth, 0);
3380 Start = Start->stripAndAccumulateInBoundsConstantOffsets(Q.
DL, StartOffset);
3381 APInt StepOffset(IndexWidth, 0);
3387 APInt OffsetB(IndexWidth, 0);
3388 B =
B->stripAndAccumulateInBoundsConstantOffsets(Q.
DL, OffsetB);
3389 return Start ==
B &&
3399 if (V1->
getType() != V2->getType())
3409 auto *O1 = dyn_cast<Operator>(V1);
3410 auto *O2 = dyn_cast<Operator>(V2);
3411 if (O1 && O2 && O1->getOpcode() == O2->getOpcode()) {
3415 if (
const PHINode *PN1 = dyn_cast<PHINode>(V1)) {
3416 const PHINode *PN2 = cast<PHINode>(V2);
3469 "Input should be a Select!");
3479 const Value *LHS2 =
nullptr, *RHS2 =
nullptr;
3491 return CLow->
sle(*CHigh);
3496 const APInt *&CHigh) {
3498 II->
getIntrinsicID() == Intrinsic::smax) &&
"Must be smin/smax");
3501 auto *InnerII = dyn_cast<IntrinsicInst>(II->
getArgOperand(0));
3502 if (!InnerII || InnerII->getIntrinsicID() != InverseID ||
3509 return CLow->
sle(*CHigh);
3517 const APInt &DemandedElts,
3519 const auto *CV = dyn_cast<Constant>(V);
3520 if (!CV || !isa<FixedVectorType>(CV->getType()))
3523 unsigned MinSignBits = TyBits;
3524 unsigned NumElts = cast<FixedVectorType>(CV->getType())->getNumElements();
3525 for (
unsigned i = 0; i != NumElts; ++i) {
3526 if (!DemandedElts[i])
3529 auto *Elt = dyn_cast_or_null<ConstantInt>(CV->getAggregateElement(i));
3533 MinSignBits = std::min(MinSignBits, Elt->getValue().getNumSignBits());
3540 const APInt &DemandedElts,
3546 assert(Result > 0 &&
"At least one sign bit needs to be present!");
3558 const APInt &DemandedElts,
3560 Type *Ty = V->getType();
3564 if (
auto *FVTy = dyn_cast<FixedVectorType>(Ty)) {
3566 FVTy->getNumElements() == DemandedElts.
getBitWidth() &&
3567 "DemandedElt width should equal the fixed vector number of elements");
3570 "DemandedElt width should be 1 for scalars");
3584 unsigned FirstAnswer = 1;
3592 if (
auto *U = dyn_cast<Operator>(V)) {
3595 case Instruction::SExt:
3596 Tmp = TyBits - U->getOperand(0)->getType()->getScalarSizeInBits();
3599 case Instruction::SDiv: {
3600 const APInt *Denominator;
3612 return std::min(TyBits, NumBits + Denominator->
logBase2());
3617 case Instruction::SRem: {
3620 const APInt *Denominator;
3641 unsigned ResBits = TyBits - Denominator->
ceilLogBase2();
3642 Tmp = std::max(Tmp, ResBits);
3648 case Instruction::AShr: {
3653 if (ShAmt->
uge(TyBits))
3656 Tmp += ShAmtLimited;
3657 if (Tmp > TyBits) Tmp = TyBits;
3661 case Instruction::Shl: {
3666 if (ShAmt->
uge(TyBits) ||
3667 ShAmt->
uge(Tmp))
break;
3673 case Instruction::And:
3674 case Instruction::Or:
3675 case Instruction::Xor:
3680 FirstAnswer = std::min(Tmp, Tmp2);
3687 case Instruction::Select: {
3691 const APInt *CLow, *CHigh;
3696 if (Tmp == 1)
break;
3698 return std::min(Tmp, Tmp2);
3701 case Instruction::Add:
3705 if (Tmp == 1)
break;
3708 if (
const auto *CRHS = dyn_cast<Constant>(U->getOperand(1)))
3709 if (CRHS->isAllOnesValue()) {
3715 if ((Known.
Zero | 1).isAllOnes())
3725 if (Tmp2 == 1)
break;
3726 return std::min(Tmp, Tmp2) - 1;
3728 case Instruction::Sub:
3730 if (Tmp2 == 1)
break;
3733 if (
const auto *CLHS = dyn_cast<Constant>(U->getOperand(0)))
3734 if (CLHS->isNullValue()) {
3739 if ((Known.
Zero | 1).isAllOnes())
3754 if (Tmp == 1)
break;
3755 return std::min(Tmp, Tmp2) - 1;
3757 case Instruction::Mul: {
3761 if (SignBitsOp0 == 1)
break;
3763 if (SignBitsOp1 == 1)
break;
3764 unsigned OutValidBits =
3765 (TyBits - SignBitsOp0 + 1) + (TyBits - SignBitsOp1 + 1);
3766 return OutValidBits > TyBits ? 1 : TyBits - OutValidBits + 1;
3769 case Instruction::PHI: {
3770 const PHINode *PN = cast<PHINode>(U);
3773 if (NumIncomingValues > 4)
break;
3775 if (NumIncomingValues == 0)
break;
3781 for (
unsigned i = 0, e = NumIncomingValues; i != e; ++i) {
3782 if (Tmp == 1)
return Tmp;
3790 case Instruction::Trunc: {
3795 unsigned OperandTyBits = U->getOperand(0)->getType()->getScalarSizeInBits();
3796 if (Tmp > (OperandTyBits - TyBits))
3797 return Tmp - (OperandTyBits - TyBits);
3802 case Instruction::ExtractElement:
3809 case Instruction::ShuffleVector: {
3812 auto *Shuf = dyn_cast<ShuffleVectorInst>(U);
3817 APInt DemandedLHS, DemandedRHS;
3822 Tmp = std::numeric_limits<unsigned>::max();
3823 if (!!DemandedLHS) {
3824 const Value *
LHS = Shuf->getOperand(0);
3831 if (!!DemandedRHS) {
3832 const Value *
RHS = Shuf->getOperand(1);
3834 Tmp = std::min(Tmp, Tmp2);
3840 assert(Tmp <= TyBits &&
"Failed to determine minimum sign bits");
3843 case Instruction::Call: {
3844 if (
const auto *II = dyn_cast<IntrinsicInst>(U)) {
3845 switch (II->getIntrinsicID()) {
3847 case Intrinsic::abs:
3849 if (Tmp == 1)
break;
3853 case Intrinsic::smin:
3854 case Intrinsic::smax: {
3855 const APInt *CLow, *CHigh;
3870 if (
unsigned VecSignBits =
3888 if (
F->isIntrinsic())
3889 return F->getIntrinsicID();
3895 if (
F->hasLocalLinkage() || !TLI || !TLI->
getLibFunc(CB, Func) ||
3905 return Intrinsic::sin;
3909 return Intrinsic::cos;
3913 return Intrinsic::exp;
3917 return Intrinsic::exp2;
3921 return Intrinsic::log;
3923 case LibFunc_log10f:
3924 case LibFunc_log10l:
3925 return Intrinsic::log10;
3929 return Intrinsic::log2;
3933 return Intrinsic::fabs;
3937 return Intrinsic::minnum;
3941 return Intrinsic::maxnum;
3942 case LibFunc_copysign:
3943 case LibFunc_copysignf:
3944 case LibFunc_copysignl:
3945 return Intrinsic::copysign;
3947 case LibFunc_floorf:
3948 case LibFunc_floorl:
3949 return Intrinsic::floor;
3953 return Intrinsic::ceil;
3955 case LibFunc_truncf:
3956 case LibFunc_truncl:
3957 return Intrinsic::trunc;
3961 return Intrinsic::rint;
3962 case LibFunc_nearbyint:
3963 case LibFunc_nearbyintf:
3964 case LibFunc_nearbyintl:
3965 return Intrinsic::nearbyint;
3967 case LibFunc_roundf:
3968 case LibFunc_roundl:
3969 return Intrinsic::round;
3970 case LibFunc_roundeven:
3971 case LibFunc_roundevenf:
3972 case LibFunc_roundevenl:
3973 return Intrinsic::roundeven;
3977 return Intrinsic::pow;
3981 return Intrinsic::sqrt;
4029 switch (Mode.Input) {
4049 if (!Src.isKnownNeverPosZero() && !Src.isKnownNeverNegZero())
4053 if (Src.isKnownNeverSubnormal())
4083 bool &TrueIfSigned) {
4086 TrueIfSigned =
true;
4087 return RHS.isZero();
4089 TrueIfSigned =
true;
4090 return RHS.isAllOnes();
4092 TrueIfSigned =
false;
4093 return RHS.isAllOnes();
4095 TrueIfSigned =
false;
4096 return RHS.isZero();
4099 TrueIfSigned =
true;
4100 return RHS.isMaxSignedValue();
4103 TrueIfSigned =
true;
4104 return RHS.isMinSignedValue();
4107 TrueIfSigned =
false;
4108 return RHS.isMinSignedValue();
4111 TrueIfSigned =
false;
4112 return RHS.isMaxSignedValue();
4123 bool LookThroughSrc) {
4131std::pair<Value *, FPClassTest>
4133 const APFloat *ConstRHS,
bool LookThroughSrc) {
4135 auto [Src, ClassIfTrue, ClassIfFalse] =
4137 if (Src && ClassIfTrue == ~ClassIfFalse)
4138 return {Src, ClassIfTrue};
4149std::tuple<Value *, FPClassTest, FPClassTest>
4163 const bool IsNegativeRHS = (RHSClass &
fcNegative) == RHSClass;
4164 const bool IsPositiveRHS = (RHSClass &
fcPositive) == RHSClass;
4165 const bool IsNaN = (RHSClass & ~fcNan) ==
fcNone;
4185 const bool IsZero = (OrigClass &
fcZero) == OrigClass;
4232 const bool IsDenormalRHS = (OrigClass &
fcSubnormal) == OrigClass;
4234 const bool IsInf = (OrigClass &
fcInf) == OrigClass;
4252 if (IsNegativeRHS) {
4275 if (IsNegativeRHS) {
4276 Mask = ~fcNegInf & ~fcNan;
4280 Mask = ~fcPosInf & ~fcNan;
4289 if (IsNegativeRHS) {
4309 if (IsNegativeRHS) {
4329 if (IsNegativeRHS) {
4344 if (IsNegativeRHS) {
4372 return {Src, Class, ~fcNan};
4376 return {Src, ~fcNan, RHSClass |
fcNan};
4385 "should have been recognized as an exact class test");
4387 if (IsNegativeRHS) {
4397 return {Src, ~fcNan,
fcNan};
4406 return {Src,
fcNan, ~fcNan};
4425 return {Src, ClassesGE, ~ClassesGE | RHSClass};
4428 return {Src, ClassesGE |
fcNan, ~(ClassesGE |
fcNan) | RHSClass};
4431 return {Src, ClassesLE, ~ClassesLE | RHSClass};
4434 return {Src, ClassesLE |
fcNan, ~(ClassesLE |
fcNan) | RHSClass};
4438 }
else if (IsPositiveRHS) {
4454 return {Src, ClassesGE, ~ClassesGE | RHSClass};
4457 return {Src, ClassesGE |
fcNan, ~(ClassesGE |
fcNan) | RHSClass};
4460 return {Src, ClassesLE, ~ClassesLE | RHSClass};
4463 return {Src, ClassesLE |
fcNan, ~(ClassesLE |
fcNan) | RHSClass};
4472std::tuple<Value *, FPClassTest, FPClassTest>
4474 const APFloat &ConstRHS,
bool LookThroughSrc) {
4522std::tuple<Value *, FPClassTest, FPClassTest>
4524 Value *RHS,
bool LookThroughSrc) {
4546 KnownFromContext.
knownNot(~(CondIsTrue ? MaskIfTrue : MaskIfFalse));
4547 }
else if (
match(
Cond, m_Intrinsic<Intrinsic::is_fpclass>(
4550 KnownFromContext.
knownNot(CondIsTrue ? ~Mask : Mask);
4556 if (TrueIfSigned == CondIsTrue)
4568 return KnownFromContext;
4588 return KnownFromContext;
4598 "Got assumption for the wrong function!");
4599 assert(
I->getCalledFunction()->getIntrinsicID() == Intrinsic::assume &&
4600 "must be an assume intrinsic");
4606 Q.
CxtI, KnownFromContext);
4609 return KnownFromContext;
4619 auto *FVTy = dyn_cast<FixedVectorType>(V->getType());
4620 APInt DemandedElts =
4626 const APInt &DemandedElts,
4630 if ((InterestedClasses &
4636 KnownSrc,
Depth + 1, Q);
4651 assert(Known.
isUnknown() &&
"should not be called with known information");
4653 if (!DemandedElts) {
4661 if (
auto *CFP = dyn_cast<ConstantFP>(V)) {
4663 Known.
SignBit = CFP->isNegative();
4667 if (isa<ConstantAggregateZero>(V)) {
4673 if (isa<PoisonValue>(V)) {
4680 auto *VFVTy = dyn_cast<FixedVectorType>(V->getType());
4681 const Constant *CV = dyn_cast<Constant>(V);
4684 bool SignBitAllZero =
true;
4685 bool SignBitAllOne =
true;
4688 unsigned NumElts = VFVTy->getNumElements();
4689 for (
unsigned i = 0; i != NumElts; ++i) {
4690 if (!DemandedElts[i])
4698 if (isa<UndefValue>(Elt))
4700 auto *CElt = dyn_cast<ConstantFP>(Elt);
4706 const APFloat &
C = CElt->getValueAPF();
4709 SignBitAllZero =
false;
4711 SignBitAllOne =
false;
4713 if (SignBitAllOne != SignBitAllZero)
4714 Known.
SignBit = SignBitAllOne;
4719 if (
const auto *CB = dyn_cast<CallBase>(V))
4720 KnownNotFromFlags |= CB->getRetNoFPClass();
4721 else if (
const auto *Arg = dyn_cast<Argument>(V))
4722 KnownNotFromFlags |= Arg->getNoFPClass();
4726 if (FPOp->hasNoNaNs())
4727 KnownNotFromFlags |=
fcNan;
4728 if (FPOp->hasNoInfs())
4729 KnownNotFromFlags |=
fcInf;
4733 KnownNotFromFlags |= ~AssumedClasses.KnownFPClasses;
4737 InterestedClasses &= ~KnownNotFromFlags;
4742 if (*AssumedClasses.SignBit)
4743 Known.signBitMustBeOne();
4745 Known.signBitMustBeZero();
4756 const unsigned Opc =
Op->getOpcode();
4758 case Instruction::FNeg: {
4760 Known,
Depth + 1, Q);
4764 case Instruction::Select: {
4772 Value *TestedValue =
nullptr;
4776 const Function *
F = cast<Instruction>(
Op)->getFunction();
4778 Value *CmpLHS, *CmpRHS;
4785 bool LookThroughFAbsFNeg = CmpLHS !=
LHS && CmpLHS !=
RHS;
4786 std::tie(TestedValue, MaskIfTrue, MaskIfFalse) =
4789 m_Intrinsic<Intrinsic::is_fpclass>(
4792 MaskIfTrue = TestedMask;
4793 MaskIfFalse = ~TestedMask;
4796 if (TestedValue ==
LHS) {
4798 FilterLHS = MaskIfTrue;
4799 }
else if (TestedValue ==
RHS) {
4801 FilterRHS = MaskIfFalse;
4810 Known2,
Depth + 1, Q);
4816 case Instruction::Call: {
4820 case Intrinsic::fabs: {
4825 InterestedClasses, Known,
Depth + 1, Q);
4831 case Intrinsic::copysign: {
4835 Known,
Depth + 1, Q);
4837 KnownSign,
Depth + 1, Q);
4841 case Intrinsic::fma:
4842 case Intrinsic::fmuladd: {
4855 KnownAddend,
Depth + 1, Q);
4861 case Intrinsic::sqrt:
4862 case Intrinsic::experimental_constrained_sqrt: {
4865 if (InterestedClasses &
fcNan)
4869 KnownSrc,
Depth + 1, Q);
4895 case Intrinsic::sin:
4896 case Intrinsic::cos: {
4900 KnownSrc,
Depth + 1, Q);
4906 case Intrinsic::maxnum:
4907 case Intrinsic::minnum:
4908 case Intrinsic::minimum:
4909 case Intrinsic::maximum: {
4912 KnownLHS,
Depth + 1, Q);
4914 KnownRHS,
Depth + 1, Q);
4917 Known = KnownLHS | KnownRHS;
4920 if (NeverNaN && (IID == Intrinsic::minnum || IID == Intrinsic::maxnum))
4923 if (IID == Intrinsic::maxnum) {
4931 }
else if (IID == Intrinsic::maximum) {
4937 }
else if (IID == Intrinsic::minnum) {
4979 }
else if ((IID == Intrinsic::maximum || IID == Intrinsic::minimum) ||
4984 if ((IID == Intrinsic::maximum || IID == Intrinsic::maxnum) &&
4987 else if ((IID == Intrinsic::minimum || IID == Intrinsic::minnum) &&
4994 case Intrinsic::canonicalize: {
4997 KnownSrc,
Depth + 1, Q);
5041 case Intrinsic::vector_reduce_fmax:
5042 case Intrinsic::vector_reduce_fmin:
5043 case Intrinsic::vector_reduce_fmaximum:
5044 case Intrinsic::vector_reduce_fminimum: {
5048 InterestedClasses,
Depth + 1, Q);
5054 case Intrinsic::trunc:
5055 case Intrinsic::floor:
5056 case Intrinsic::ceil:
5057 case Intrinsic::rint:
5058 case Intrinsic::nearbyint:
5059 case Intrinsic::round:
5060 case Intrinsic::roundeven: {
5068 KnownSrc,
Depth + 1, Q);
5077 if (IID == Intrinsic::trunc || !V->getType()->isMultiUnitFPType()) {
5092 case Intrinsic::exp:
5093 case Intrinsic::exp2:
5094 case Intrinsic::exp10: {
5101 KnownSrc,
Depth + 1, Q);
5109 case Intrinsic::fptrunc_round: {
5114 case Intrinsic::log:
5115 case Intrinsic::log10:
5116 case Intrinsic::log2:
5117 case Intrinsic::experimental_constrained_log:
5118 case Intrinsic::experimental_constrained_log10:
5119 case Intrinsic::experimental_constrained_log2: {
5135 KnownSrc,
Depth + 1, Q);
5149 case Intrinsic::powi: {
5154 Type *ExpTy = Exp->getType();
5158 ExponentKnownBits,
Depth + 1, Q);
5160 if (ExponentKnownBits.
Zero[0]) {
5175 KnownSrc,
Depth + 1, Q);
5180 case Intrinsic::ldexp: {
5183 KnownSrc,
Depth + 1, Q);
5199 if ((InterestedClasses & ExpInfoMask) ==
fcNone)
5211 const int MantissaBits = Precision - 1;
5217 if (ConstVal && ConstVal->
isZero()) {
5240 case Intrinsic::arithmetic_fence: {
5242 Known,
Depth + 1, Q);
5245 case Intrinsic::experimental_constrained_sitofp:
5246 case Intrinsic::experimental_constrained_uitofp:
5256 if (IID == Intrinsic::experimental_constrained_uitofp)
5267 case Instruction::FAdd:
5268 case Instruction::FSub: {
5271 Op->getOpcode() == Instruction::FAdd &&
5273 bool WantNaN = (InterestedClasses &
fcNan) !=
fcNone;
5276 if (!WantNaN && !WantNegative && !WantNegZero)
5282 if (InterestedClasses &
fcNan)
5283 InterestedSrcs |=
fcInf;
5285 KnownRHS,
Depth + 1, Q);
5289 WantNegZero || Opc == Instruction::FSub) {
5294 KnownLHS,
Depth + 1, Q);
5302 const Function *
F = cast<Instruction>(
Op)->getFunction();
5304 if (
Op->getOpcode() == Instruction::FAdd) {
5332 case Instruction::FMul: {
5334 if (
Op->getOperand(0) ==
Op->getOperand(1))
5367 const Function *
F = cast<Instruction>(
Op)->getFunction();
5379 case Instruction::FDiv:
5380 case Instruction::FRem: {
5381 if (
Op->getOperand(0) ==
Op->getOperand(1)) {
5383 if (
Op->getOpcode() == Instruction::FDiv) {
5394 const bool WantNan = (InterestedClasses &
fcNan) !=
fcNone;
5396 const bool WantPositive =
5398 if (!WantNan && !WantNegative && !WantPositive)
5407 bool KnowSomethingUseful =
5410 if (KnowSomethingUseful || WantPositive) {
5416 InterestedClasses & InterestedLHS, KnownLHS,
5420 const Function *
F = cast<Instruction>(
Op)->getFunction();
5422 if (
Op->getOpcode() == Instruction::FDiv) {
5459 case Instruction::FPExt: {
5462 Known,
Depth + 1, Q);
5465 Op->getType()->getScalarType()->getFltSemantics();
5467 Op->getOperand(0)->getType()->getScalarType()->getFltSemantics();
5483 case Instruction::FPTrunc: {
5488 case Instruction::SIToFP:
5489 case Instruction::UIToFP: {
5498 if (
Op->getOpcode() == Instruction::UIToFP)
5501 if (InterestedClasses &
fcInf) {
5505 int IntSize =
Op->getOperand(0)->getType()->getScalarSizeInBits();
5506 if (
Op->getOpcode() == Instruction::SIToFP)
5511 Type *FPTy =
Op->getType()->getScalarType();
5518 case Instruction::ExtractElement: {
5521 const Value *Vec =
Op->getOperand(0);
5523 auto *CIdx = dyn_cast<ConstantInt>(
Idx);
5525 if (
auto *VecTy = dyn_cast<FixedVectorType>(Vec->
getType())) {
5526 unsigned NumElts = VecTy->getNumElements();
5528 if (CIdx && CIdx->getValue().ult(NumElts))
5536 case Instruction::InsertElement: {
5537 if (isa<ScalableVectorType>(
Op->getType()))
5540 const Value *Vec =
Op->getOperand(0);
5541 const Value *Elt =
Op->getOperand(1);
5542 auto *CIdx = dyn_cast<ConstantInt>(
Op->getOperand(2));
5544 APInt DemandedVecElts = DemandedElts;
5545 bool NeedsElt =
true;
5547 if (CIdx && CIdx->getValue().ult(NumElts)) {
5548 DemandedVecElts.
clearBit(CIdx->getZExtValue());
5549 NeedsElt = DemandedElts[CIdx->getZExtValue()];
5563 if (!DemandedVecElts.
isZero()) {
5572 case Instruction::ShuffleVector: {
5575 APInt DemandedLHS, DemandedRHS;
5576 auto *Shuf = dyn_cast<ShuffleVectorInst>(
Op);
5580 if (!!DemandedLHS) {
5581 const Value *
LHS = Shuf->getOperand(0);
5592 if (!!DemandedRHS) {
5594 const Value *
RHS = Shuf->getOperand(1);
5602 case Instruction::ExtractValue: {
5606 if (isa<StructType>(Src->getType()) && Indices.
size() == 1 &&
5608 if (
const auto *II = dyn_cast<IntrinsicInst>(Src)) {
5609 switch (II->getIntrinsicID()) {
5610 case Intrinsic::frexp: {
5615 InterestedClasses, KnownSrc,
Depth + 1, Q);
5617 const Function *
F = cast<Instruction>(
Op)->getFunction();
5650 case Instruction::PHI: {
5653 if (
P->getNumIncomingValues() == 0)
5660 if (
Depth < PhiRecursionLimit) {
5662 if (isa_and_nonnull<UndefValue>(
P->hasConstantValue()))
5667 for (
const Use &U :
P->operands()) {
5668 Value *IncValue = U.get();
5678 IncValue, DemandedElts, InterestedClasses, KnownSrc,
5702 const APInt &DemandedElts,
5709 return KnownClasses;
5724 if (V->getType()->isIntegerTy(8))
5731 if (isa<UndefValue>(V))
5735 if (
DL.getTypeStoreSize(V->getType()).isZero())
5750 if (
C->isNullValue())
5757 if (CFP->getType()->isHalfTy())
5759 else if (CFP->getType()->isFloatTy())
5761 else if (CFP->getType()->isDoubleTy())
5770 if (CI->getBitWidth() % 8 == 0) {
5771 assert(CI->getBitWidth() > 8 &&
"8 bits should be handled above!");
5772 if (!CI->getValue().isSplat(8))
5774 return ConstantInt::get(Ctx, CI->getValue().trunc(8));
5778 if (
auto *CE = dyn_cast<ConstantExpr>(
C)) {
5779 if (CE->getOpcode() == Instruction::IntToPtr) {
5780 if (
auto *PtrTy = dyn_cast<PointerType>(CE->getType())) {
5781 unsigned BitWidth =
DL.getPointerSizeInBits(PtrTy->getAddressSpace());
5794 if (
LHS == UndefInt8)
5796 if (
RHS == UndefInt8)
5802 Value *Val = UndefInt8;
5803 for (
unsigned I = 0, E = CA->getNumElements();
I != E; ++
I)
5809 if (isa<ConstantAggregate>(
C)) {
5810 Value *Val = UndefInt8;
5811 for (
unsigned I = 0, E =
C->getNumOperands();
I != E; ++
I)
5831 StructType *STy = dyn_cast<StructType>(IndexedType);
5845 while (PrevTo != OrigTo) {
5892 unsigned IdxSkip = Idxs.
size();
5905 std::optional<BasicBlock::iterator> InsertBefore) {
5908 if (idx_range.
empty())
5911 assert((V->getType()->isStructTy() || V->getType()->isArrayTy()) &&
5912 "Not looking at a struct or array?");
5914 "Invalid indices for type?");
5916 if (
Constant *
C = dyn_cast<Constant>(V)) {
5917 C =
C->getAggregateElement(idx_range[0]);
5918 if (!
C)
return nullptr;
5925 const unsigned *req_idx = idx_range.
begin();
5926 for (
const unsigned *i =
I->idx_begin(), *e =
I->idx_end();
5927 i != e; ++i, ++req_idx) {
5928 if (req_idx == idx_range.
end()) {
5958 ArrayRef(req_idx, idx_range.
end()), InsertBefore);
5967 unsigned size =
I->getNumIndices() + idx_range.
size();
5972 Idxs.
append(
I->idx_begin(),
I->idx_end());
5978 &&
"Number of indices added not correct?");
5988 unsigned CharSize) {
5990 if (
GEP->getNumOperands() != 3)
5995 ArrayType *AT = dyn_cast<ArrayType>(
GEP->getSourceElementType());
6001 const ConstantInt *FirstIdx = dyn_cast<ConstantInt>(
GEP->getOperand(1));
6002 if (!FirstIdx || !FirstIdx->
isZero())
6016 assert(V &&
"V should not be null.");
6017 assert((ElementSize % 8) == 0 &&
6018 "ElementSize expected to be a multiple of the size of a byte.");
6019 unsigned ElementSizeInBytes = ElementSize / 8;
6031 APInt Off(
DL.getIndexTypeSizeInBits(V->getType()), 0);
6033 if (GV != V->stripAndAccumulateConstantOffsets(
DL, Off,
6038 uint64_t StartIdx = Off.getLimitedValue();
6045 if ((StartIdx % ElementSizeInBytes) != 0)
6048 Offset += StartIdx / ElementSizeInBytes;
6054 uint64_t SizeInBytes =
DL.getTypeStoreSize(GVTy).getFixedValue();
6057 Slice.
Array =
nullptr;
6068 if (
auto *ArrayInit = dyn_cast<ConstantDataArray>(
Init)) {
6069 Type *InitElTy = ArrayInit->getElementType();
6074 ArrayTy = ArrayInit->getType();
6079 if (ElementSize != 8)
6090 Array = dyn_cast<ConstantDataArray>(
Init);
6091 ArrayTy = dyn_cast<ArrayType>(
Init->getType());
6098 Slice.
Array = Array;
6114 if (Slice.
Array ==
nullptr) {
6137 Str = Str.substr(Slice.
Offset);
6143 Str = Str.substr(0, Str.find(
'\0'));
6156 unsigned CharSize) {
6158 V = V->stripPointerCasts();
6162 if (
const PHINode *PN = dyn_cast<PHINode>(V)) {
6163 if (!PHIs.
insert(PN).second)
6168 for (
Value *IncValue : PN->incoming_values()) {
6170 if (Len == 0)
return 0;
6172 if (Len == ~0ULL)
continue;
6174 if (Len != LenSoFar && LenSoFar != ~0ULL)
6184 if (
const SelectInst *SI = dyn_cast<SelectInst>(V)) {
6186 if (Len1 == 0)
return 0;
6188 if (Len2 == 0)
return 0;
6189 if (Len1 == ~0ULL)
return Len2;
6190 if (Len2 == ~0ULL)
return Len1;
6191 if (Len1 != Len2)
return 0;
6200 if (Slice.
Array ==
nullptr)
6208 unsigned NullIndex = 0;
6209 for (
unsigned E = Slice.
Length; NullIndex < E; ++NullIndex) {
6214 return NullIndex + 1;
6220 if (!V->getType()->isPointerTy())
6227 return Len == ~0ULL ? 1 : Len;
6232 bool MustPreserveNullness) {
6234 "getArgumentAliasingToReturnedPointer only works on nonnull calls");
6235 if (
const Value *RV = Call->getReturnedArgOperand())
6239 Call, MustPreserveNullness))
6240 return Call->getArgOperand(0);
6245 const CallBase *Call,
bool MustPreserveNullness) {
6246 switch (Call->getIntrinsicID()) {
6247 case Intrinsic::launder_invariant_group:
6248 case Intrinsic::strip_invariant_group:
6249 case Intrinsic::aarch64_irg:
6250 case Intrinsic::aarch64_tagp:
6260 case Intrinsic::amdgcn_make_buffer_rsrc:
6262 case Intrinsic::ptrmask:
6263 return !MustPreserveNullness;
6264 case Intrinsic::threadlocal_address:
6267 return !Call->getParent()->getParent()->isPresplitCoroutine();
6284 if (!PrevValue || LI->
getLoopFor(PrevValue->getParent()) != L)
6286 if (!PrevValue || LI->
getLoopFor(PrevValue->getParent()) != L)
6294 if (
auto *Load = dyn_cast<LoadInst>(PrevValue))
6295 if (!L->isLoopInvariant(Load->getPointerOperand()))
6301 if (!V->getType()->isPointerTy())
6303 for (
unsigned Count = 0; MaxLookup == 0 || Count < MaxLookup; ++Count) {
6304 if (
auto *
GEP = dyn_cast<GEPOperator>(V)) {
6305 V =
GEP->getPointerOperand();
6308 V = cast<Operator>(V)->getOperand(0);
6309 if (!V->getType()->isPointerTy())
6311 }
else if (
auto *GA = dyn_cast<GlobalAlias>(V)) {
6312 if (GA->isInterposable())
6314 V = GA->getAliasee();
6316 if (
auto *
PHI = dyn_cast<PHINode>(V)) {
6318 if (
PHI->getNumIncomingValues() == 1) {
6319 V =
PHI->getIncomingValue(0);
6322 }
else if (
auto *Call = dyn_cast<CallBase>(V)) {
6340 assert(V->getType()->isPointerTy() &&
"Unexpected operand type!");
6347 LoopInfo *LI,
unsigned MaxLookup) {
6355 if (!Visited.
insert(
P).second)
6358 if (
auto *SI = dyn_cast<SelectInst>(
P)) {
6360 Worklist.
push_back(SI->getFalseValue());
6364 if (
auto *PN = dyn_cast<PHINode>(
P)) {
6384 }
while (!Worklist.
empty());
6391 if (
const Operator *U = dyn_cast<Operator>(V)) {
6394 if (U->getOpcode() == Instruction::PtrToInt)
6395 return U->getOperand(0);
6402 if (U->getOpcode() != Instruction::Add ||
6403 (!isa<ConstantInt>(U->getOperand(1)) &&
6405 !isa<PHINode>(U->getOperand(1))))
6407 V = U->getOperand(0);
6411 assert(V->getType()->isIntegerTy() &&
"Unexpected operand type!");
6428 for (
const Value *V : Objs) {
6429 if (!Visited.
insert(V).second)
6434 if (O->getType()->isPointerTy()) {
6447 }
while (!Working.
empty());
6456 auto AddWork = [&](
Value *V) {
6457 if (Visited.
insert(V).second)
6466 if (
AllocaInst *AI = dyn_cast<AllocaInst>(V)) {
6467 if (Result && Result != AI)
6470 }
else if (
CastInst *CI = dyn_cast<CastInst>(V)) {
6471 AddWork(CI->getOperand(0));
6472 }
else if (
PHINode *PN = dyn_cast<PHINode>(V)) {
6473 for (
Value *IncValue : PN->incoming_values())
6475 }
else if (
auto *SI = dyn_cast<SelectInst>(V)) {
6476 AddWork(SI->getTrueValue());
6477 AddWork(SI->getFalseValue());
6479 if (OffsetZero && !
GEP->hasAllZeroIndices())
6481 AddWork(
GEP->getPointerOperand());
6482 }
else if (
CallBase *CB = dyn_cast<CallBase>(V)) {
6483 Value *Returned = CB->getReturnedArgOperand();
6491 }
while (!Worklist.
empty());
6497 const Value *V,
bool AllowLifetime,
bool AllowDroppable) {
6498 for (
const User *U : V->users()) {
6528 return F.hasFnAttribute(Attribute::SanitizeThread) ||
6530 F.hasFnAttribute(Attribute::SanitizeAddress) ||
6531 F.hasFnAttribute(Attribute::SanitizeHWAddress);
6550 auto hasEqualReturnAndLeadingOperandTypes =
6551 [](
const Instruction *Inst,
unsigned NumLeadingOperands) {
6555 for (
unsigned ItOp = 0; ItOp < NumLeadingOperands; ++ItOp)
6561 hasEqualReturnAndLeadingOperandTypes(Inst, 2));
6563 hasEqualReturnAndLeadingOperandTypes(Inst, 1));
6570 case Instruction::UDiv:
6571 case Instruction::URem: {
6578 case Instruction::SDiv:
6579 case Instruction::SRem: {
6581 const APInt *Numerator, *Denominator;
6585 if (*Denominator == 0)
6597 case Instruction::Load: {
6598 const LoadInst *LI = dyn_cast<LoadInst>(Inst);
6608 case Instruction::Call: {
6609 auto *CI = dyn_cast<const CallInst>(Inst);
6612 const Function *Callee = CI->getCalledFunction();
6616 return Callee && Callee->isSpeculatable();
6618 case Instruction::VAArg:
6619 case Instruction::Alloca:
6620 case Instruction::Invoke:
6621 case Instruction::CallBr:
6622 case Instruction::PHI:
6623 case Instruction::Store:
6624 case Instruction::Ret:
6625 case Instruction::Br:
6626 case Instruction::IndirectBr:
6627 case Instruction::Switch:
6628 case Instruction::Unreachable:
6629 case Instruction::Fence:
6630 case Instruction::AtomicRMW:
6631 case Instruction::AtomicCmpXchg:
6632 case Instruction::LandingPad:
6633 case Instruction::Resume:
6634 case Instruction::CatchSwitch:
6635 case Instruction::CatchPad:
6636 case Instruction::CatchRet:
6637 case Instruction::CleanupPad:
6638 case Instruction::CleanupRet:
6644 if (
I.mayReadOrWriteMemory())
6751 if (
Add &&
Add->hasNoSignedWrap()) {
6791 bool LHSOrRHSKnownNonNegative =
6793 bool LHSOrRHSKnownNegative =
6795 if (LHSOrRHSKnownNonNegative || LHSOrRHSKnownNegative) {
6798 if ((AddKnown.
isNonNegative() && LHSOrRHSKnownNonNegative) ||
6799 (AddKnown.
isNegative() && LHSOrRHSKnownNegative))
6828 m_Intrinsic<Intrinsic::usub_with_overflow>(
m_Value(),
m_Value())))
6877 if (
const auto *EVI = dyn_cast<ExtractValueInst>(U)) {
6878 assert(EVI->getNumIndices() == 1 &&
"Obvious from CI's type");
6880 if (EVI->getIndices()[0] == 0)
6883 assert(EVI->getIndices()[0] == 1 &&
"Obvious from CI's type");
6885 for (
const auto *U : EVI->users())
6886 if (
const auto *
B = dyn_cast<BranchInst>(U)) {
6887 assert(
B->isConditional() &&
"How else is it using an i1?");
6898 auto AllUsesGuardedByBranch = [&](
const BranchInst *BI) {
6904 for (
const auto *Result :
Results) {
6907 if (DT.
dominates(NoWrapEdge, Result->getParent()))
6910 for (
const auto &RU : Result->uses())
6918 return llvm::any_of(GuardingBranches, AllUsesGuardedByBranch);
6923 auto *
C = dyn_cast<Constant>(ShiftAmount);
6929 if (
auto *FVTy = dyn_cast<FixedVectorType>(
C->getType())) {
6930 unsigned NumElts = FVTy->getNumElements();
6931 for (
unsigned i = 0; i < NumElts; ++i)
6932 ShiftAmounts.
push_back(
C->getAggregateElement(i));
6933 }
else if (isa<ScalableVectorType>(
C->getType()))
6939 auto *CI = dyn_cast_or_null<ConstantInt>(
C);
6940 return CI && CI->getValue().ult(
C->getType()->getIntegerBitWidth());
6953 return (
unsigned(Kind) &
unsigned(UndefPoisonKind::PoisonOnly)) != 0;
6957 return (
unsigned(Kind) &
unsigned(UndefPoisonKind::UndefOnly)) != 0;
6961 bool ConsiderFlagsAndMetadata) {
6964 Op->hasPoisonGeneratingAnnotations())
6967 unsigned Opcode =
Op->getOpcode();
6971 case Instruction::Shl:
6972 case Instruction::AShr:
6973 case Instruction::LShr:
6975 case Instruction::FPToSI:
6976 case Instruction::FPToUI:
6980 case Instruction::Call:
6981 if (
auto *II = dyn_cast<IntrinsicInst>(
Op)) {
6982 switch (II->getIntrinsicID()) {
6984 case Intrinsic::ctlz:
6985 case Intrinsic::cttz:
6986 case Intrinsic::abs:
6987 if (cast<ConstantInt>(II->getArgOperand(1))->isNullValue())
6990 case Intrinsic::ctpop:
6991 case Intrinsic::bswap:
6992 case Intrinsic::bitreverse:
6993 case Intrinsic::fshl:
6994 case Intrinsic::fshr:
6995 case Intrinsic::smax:
6996 case Intrinsic::smin:
6997 case Intrinsic::umax:
6998 case Intrinsic::umin:
6999 case Intrinsic::ptrmask:
7000 case Intrinsic::fptoui_sat:
7001 case Intrinsic::fptosi_sat:
7002 case Intrinsic::sadd_with_overflow:
7003 case Intrinsic::ssub_with_overflow:
7004 case Intrinsic::smul_with_overflow:
7005 case Intrinsic::uadd_with_overflow:
7006 case Intrinsic::usub_with_overflow:
7007 case Intrinsic::umul_with_overflow:
7008 case Intrinsic::sadd_sat:
7009 case Intrinsic::uadd_sat:
7010 case Intrinsic::ssub_sat:
7011 case Intrinsic::usub_sat:
7013 case Intrinsic::sshl_sat:
7014 case Intrinsic::ushl_sat:
7017 case Intrinsic::fma:
7018 case Intrinsic::fmuladd:
7019 case Intrinsic::sqrt:
7020 case Intrinsic::powi:
7021 case Intrinsic::sin:
7022 case Intrinsic::cos:
7023 case Intrinsic::pow:
7024 case Intrinsic::log:
7025 case Intrinsic::log10:
7026 case Intrinsic::log2:
7027 case Intrinsic::exp:
7028 case Intrinsic::exp2:
7029 case Intrinsic::exp10:
7030 case Intrinsic::fabs:
7031 case Intrinsic::copysign:
7032 case Intrinsic::floor:
7033 case Intrinsic::ceil:
7034 case Intrinsic::trunc:
7035 case Intrinsic::rint:
7036 case Intrinsic::nearbyint:
7037 case Intrinsic::round:
7038 case Intrinsic::roundeven:
7039 case Intrinsic::fptrunc_round:
7040 case Intrinsic::canonicalize:
7041 case Intrinsic::arithmetic_fence:
7042 case Intrinsic::minnum:
7043 case Intrinsic::maxnum:
7044 case Intrinsic::minimum:
7045 case Intrinsic::maximum:
7046 case Intrinsic::is_fpclass:
7047 case Intrinsic::ldexp:
7048 case Intrinsic::frexp:
7050 case Intrinsic::lround:
7051 case Intrinsic::llround:
7052 case Intrinsic::lrint:
7053 case Intrinsic::llrint:
7060 case Instruction::CallBr:
7061 case Instruction::Invoke: {
7062 const auto *CB = cast<CallBase>(
Op);
7063 return !CB->hasRetAttr(Attribute::NoUndef);
7065 case Instruction::InsertElement:
7066 case Instruction::ExtractElement: {
7068 auto *VTy = cast<VectorType>(
Op->getOperand(0)->getType());
7069 unsigned IdxOp =
Op->getOpcode() == Instruction::InsertElement ? 2 : 1;
7070 auto *
Idx = dyn_cast<ConstantInt>(
Op->getOperand(IdxOp));
7073 Idx->getValue().uge(VTy->getElementCount().getKnownMinValue());
7076 case Instruction::ShuffleVector: {
7078 ? cast<ConstantExpr>(
Op)->getShuffleMask()
7079 : cast<ShuffleVectorInst>(
Op)->getShuffleMask();
7082 case Instruction::FNeg:
7083 case Instruction::PHI:
7084 case Instruction::Select:
7085 case Instruction::URem:
7086 case Instruction::SRem:
7087 case Instruction::ExtractValue:
7088 case Instruction::InsertValue:
7089 case Instruction::Freeze:
7090 case Instruction::ICmp:
7091 case Instruction::FCmp:
7092 case Instruction::FAdd:
7093 case Instruction::FSub:
7094 case Instruction::FMul:
7095 case Instruction::FDiv:
7096 case Instruction::FRem:
7098 case Instruction::GetElementPtr:
7103 const auto *CE = dyn_cast<ConstantExpr>(
Op);
7104 if (isa<CastInst>(
Op) || (CE && CE->isCast()))
7115 bool ConsiderFlagsAndMetadata) {
7116 return ::canCreateUndefOrPoison(
Op, UndefPoisonKind::UndefOrPoison,
7117 ConsiderFlagsAndMetadata);
7121 return ::canCreateUndefOrPoison(
Op, UndefPoisonKind::PoisonOnly,
7122 ConsiderFlagsAndMetadata);
7127 if (ValAssumedPoison == V)
7134 if (
const auto *
I = dyn_cast<Instruction>(V)) {
7136 return propagatesPoison(Op) &&
7137 directlyImpliesPoison(ValAssumedPoison, Op, Depth + 1);
7165 const auto *
I = dyn_cast<Instruction>(ValAssumedPoison);
7168 return impliesPoison(Op, V, Depth + 1);
7175 return ::impliesPoison(ValAssumedPoison, V, 0);
7186 if (isa<MetadataAsValue>(V))
7189 if (
const auto *
A = dyn_cast<Argument>(V)) {
7190 if (
A->hasAttribute(Attribute::NoUndef) ||
7191 A->hasAttribute(Attribute::Dereferenceable) ||
7192 A->hasAttribute(Attribute::DereferenceableOrNull))
7196 if (
auto *
C = dyn_cast<Constant>(V)) {
7197 if (isa<PoisonValue>(
C))
7200 if (isa<UndefValue>(
C))
7203 if (isa<ConstantInt>(
C) || isa<GlobalVariable>(
C) || isa<ConstantFP>(V) ||
7204 isa<ConstantPointerNull>(
C) || isa<Function>(
C))
7207 if (
C->getType()->isVectorTy() && !isa<ConstantExpr>(
C))
7209 : !
C->containsUndefOrPoisonElement()) &&
7210 !
C->containsConstantExpression();
7221 auto *StrippedV = V->stripPointerCastsSameRepresentation();
7222 if (isa<AllocaInst>(StrippedV) || isa<GlobalVariable>(StrippedV) ||
7223 isa<Function>(StrippedV) || isa<ConstantPointerNull>(StrippedV))
7226 auto OpCheck = [&](
const Value *V) {
7230 if (
auto *Opr = dyn_cast<Operator>(V)) {
7233 if (isa<FreezeInst>(V))
7236 if (
const auto *CB = dyn_cast<CallBase>(V)) {
7237 if (CB->hasRetAttr(Attribute::NoUndef) ||
7238 CB->hasRetAttr(Attribute::Dereferenceable) ||
7239 CB->hasRetAttr(Attribute::DereferenceableOrNull))
7243 if (
const auto *PN = dyn_cast<PHINode>(V)) {
7244 unsigned Num = PN->getNumIncomingValues();
7245 bool IsWellDefined =
true;
7246 for (
unsigned i = 0; i < Num; ++i) {
7247 auto *TI = PN->getIncomingBlock(i)->getTerminator();
7249 DT,
Depth + 1, Kind)) {
7250 IsWellDefined =
false;
7258 all_of(Opr->operands(), OpCheck))
7262 if (
auto *
I = dyn_cast<LoadInst>(V))
7263 if (
I->hasMetadata(LLVMContext::MD_noundef) ||
7264 I->hasMetadata(LLVMContext::MD_dereferenceable) ||
7265 I->hasMetadata(LLVMContext::MD_dereferenceable_or_null))
7285 auto *Dominator = DNode->
getIDom();
7287 auto *TI = Dominator->
getBlock()->getTerminator();
7290 if (
auto BI = dyn_cast_or_null<BranchInst>(TI)) {
7291 if (BI->isConditional())
7292 Cond = BI->getCondition();
7293 }
else if (
auto SI = dyn_cast_or_null<SwitchInst>(TI)) {
7294 Cond = SI->getCondition();
7302 auto *Opr = cast<Operator>(
Cond);
7303 if (
any_of(Opr->operands(),
7304 [V](
const Use &U) { return V == U && propagatesPoison(U); }))
7309 Dominator = Dominator->getIDom();
7322 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT,
Depth,
7323 UndefPoisonKind::UndefOrPoison);
7329 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT,
Depth,
7330 UndefPoisonKind::PoisonOnly);
7336 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT,
Depth,
7337 UndefPoisonKind::UndefOnly);
7360 while (!Worklist.
empty()) {
7369 if (
I != Root && !
any_of(
I->operands(), [&KnownPoison](
const Use &U) {
7370 return KnownPoison.contains(U) && propagatesPoison(U);
7374 if (KnownPoison.
insert(
I).second)
7386 return ::computeOverflowForSignedAdd(
Add->getOperand(0),
Add->getOperand(1),
7394 return ::computeOverflowForSignedAdd(
LHS,
RHS,
nullptr, SQ);
7403 if (isa<ReturnInst>(
I))
7405 if (isa<UnreachableInst>(
I))
7412 if (isa<CatchPadInst>(
I)) {
7426 return !
I->mayThrow() &&
I->willReturn();
7440 unsigned ScanLimit) {
7447 assert(ScanLimit &&
"scan limit must be non-zero");
7449 if (isa<DbgInfoIntrinsic>(
I))
7451 if (--ScanLimit == 0)
7465 if (
I->getParent() != L->getHeader())
return false;
7468 if (&LI ==
I)
return true;
7471 llvm_unreachable(
"Instruction not contained in its own parent basic block.");
7476 switch (
I->getOpcode()) {
7477 case Instruction::Freeze:
7478 case Instruction::PHI:
7479 case Instruction::Invoke:
7481 case Instruction::Select:
7483 case Instruction::Call:
7484 if (
auto *II = dyn_cast<IntrinsicInst>(
I)) {
7485 switch (II->getIntrinsicID()) {
7487 case Intrinsic::sadd_with_overflow:
7488 case Intrinsic::ssub_with_overflow:
7489 case Intrinsic::smul_with_overflow:
7490 case Intrinsic::uadd_with_overflow:
7491 case Intrinsic::usub_with_overflow:
7492 case Intrinsic::umul_with_overflow:
7497 case Intrinsic::ctpop:
7498 case Intrinsic::ctlz:
7499 case Intrinsic::cttz:
7500 case Intrinsic::abs:
7501 case Intrinsic::smax:
7502 case Intrinsic::smin:
7503 case Intrinsic::umax:
7504 case Intrinsic::umin:
7505 case Intrinsic::bitreverse:
7506 case Intrinsic::bswap:
7507 case Intrinsic::sadd_sat:
7508 case Intrinsic::ssub_sat:
7509 case Intrinsic::sshl_sat:
7510 case Intrinsic::uadd_sat:
7511 case Intrinsic::usub_sat:
7512 case Intrinsic::ushl_sat:
7517 case Instruction::ICmp:
7518 case Instruction::FCmp:
7519 case Instruction::GetElementPtr:
7522 if (isa<BinaryOperator>(
I) || isa<UnaryOperator>(
I) || isa<CastInst>(
I))
7533template <
typename CallableT>
7535 const CallableT &Handle) {
7536 switch (
I->getOpcode()) {
7537 case Instruction::Store:
7542 case Instruction::Load:
7549 case Instruction::AtomicCmpXchg:
7554 case Instruction::AtomicRMW:
7559 case Instruction::Call:
7560 case Instruction::Invoke: {
7564 for (
unsigned i = 0; i < CB->
arg_size(); ++i)
7567 CB->
paramHasAttr(i, Attribute::DereferenceableOrNull)) &&
7572 case Instruction::Ret:
7573 if (
I->getFunction()->hasRetAttribute(Attribute::NoUndef) &&
7574 Handle(
I->getOperand(0)))
7577 case Instruction::Switch:
7578 if (Handle(cast<SwitchInst>(
I)->getCondition()))
7581 case Instruction::Br: {
7582 auto *BR = cast<BranchInst>(
I);
7583 if (BR->isConditional() && Handle(BR->getCondition()))
7603template <
typename CallableT>
7605 const CallableT &Handle) {
7608 switch (
I->getOpcode()) {
7610 case Instruction::UDiv:
7611 case Instruction::SDiv:
7612 case Instruction::URem:
7613 case Instruction::SRem:
7614 return Handle(
I->getOperand(1));
7631 I, [&](
const Value *V) {
return KnownPoison.
count(V); });
7645 if (
const auto *Inst = dyn_cast<Instruction>(V)) {
7649 }
else if (
const auto *Arg = dyn_cast<Argument>(V)) {
7650 if (Arg->getParent()->isDeclaration())
7653 Begin = BB->
begin();
7660 unsigned ScanLimit = 32;
7669 if (isa<DbgInfoIntrinsic>(
I))
7671 if (--ScanLimit == 0)
7675 return WellDefinedOp == V;
7695 if (isa<DbgInfoIntrinsic>(
I))
7697 if (--ScanLimit == 0)
7705 for (
const Use &
Op :
I.operands()) {
7715 if (
I.getOpcode() == Instruction::Select &&
7716 YieldsPoison.
count(
I.getOperand(1)) &&
7717 YieldsPoison.
count(
I.getOperand(2))) {
7723 if (!BB || !Visited.
insert(BB).second)
7733 return ::programUndefinedIfUndefOrPoison(Inst,
false);
7737 return ::programUndefinedIfUndefOrPoison(Inst,
true);
7744 if (
auto *
C = dyn_cast<ConstantFP>(V))
7747 if (
auto *
C = dyn_cast<ConstantDataVector>(V)) {
7748 if (!
C->getElementType()->isFloatingPointTy())
7750 for (
unsigned I = 0, E =
C->getNumElements();
I < E; ++
I) {
7751 if (
C->getElementAsAPFloat(
I).isNaN())
7757 if (isa<ConstantAggregateZero>(V))
7764 if (
auto *
C = dyn_cast<ConstantFP>(V))
7765 return !
C->isZero();
7767 if (
auto *
C = dyn_cast<ConstantDataVector>(V)) {
7768 if (!
C->getElementType()->isFloatingPointTy())
7770 for (
unsigned I = 0, E =
C->getNumElements();
I < E; ++
I) {
7771 if (
C->getElementAsAPFloat(
I).isZero())
7794 if (CmpRHS == FalseVal) {
7842 if (CmpRHS != TrueVal) {
7881 Value *
A =
nullptr, *
B =
nullptr;
7886 Value *
C =
nullptr, *
D =
nullptr;
7888 if (L.Flavor != R.Flavor)
7940 return {L.Flavor,
SPNB_NA,
false};
7947 return {L.Flavor,
SPNB_NA,
false};
7954 return {L.Flavor,
SPNB_NA,
false};
7961 return {L.Flavor,
SPNB_NA,
false};
7977 return ConstantInt::get(V->getType(), ~(*
C));
8034 if ((CmpLHS == TrueVal &&
match(FalseVal,
m_APInt(C2))) ||
8054 assert(
X &&
Y &&
"Invalid operand");
8056 auto IsNegationOf = [&](
const Value *
X,
const Value *
Y) {
8060 auto *BO = cast<BinaryOperator>(
X);
8061 if (NeedNSW && !BO->hasNoSignedWrap())
8064 auto *Zero = cast<Constant>(BO->getOperand(0));
8065 if (!AllowPoison && !Zero->isNullValue())
8072 if (IsNegationOf(
X,
Y) || IsNegationOf(
Y,
X))
8089 bool HasMismatchedZeros =
false;
8095 Value *OutputZeroVal =
nullptr;
8097 !cast<Constant>(TrueVal)->containsUndefOrPoisonElement())
8098 OutputZeroVal = TrueVal;
8100 !cast<Constant>(FalseVal)->containsUndefOrPoisonElement())
8101 OutputZeroVal = FalseVal;
8103 if (OutputZeroVal) {
8105 HasMismatchedZeros =
true;
8106 CmpLHS = OutputZeroVal;
8109 HasMismatchedZeros =
true;
8110 CmpRHS = OutputZeroVal;
8127 if (!HasMismatchedZeros)
8138 bool Ordered =
false;
8149 if (LHSSafe && RHSSafe) {
8179 if (TrueVal == CmpRHS && FalseVal == CmpLHS) {
8190 if (TrueVal == CmpLHS && FalseVal == CmpRHS) {
8215 auto MaybeSExtCmpLHS =
8219 if (
match(TrueVal, MaybeSExtCmpLHS)) {
8241 else if (
match(FalseVal, MaybeSExtCmpLHS)) {
8291 auto *Cast1 = dyn_cast<CastInst>(V1);
8295 *CastOp = Cast1->getOpcode();
8296 Type *SrcTy = Cast1->getSrcTy();
8297 if (
auto *Cast2 = dyn_cast<CastInst>(V2)) {
8299 if (*CastOp == Cast2->getOpcode() && SrcTy == Cast2->getSrcTy())
8300 return Cast2->getOperand(0);
8304 auto *
C = dyn_cast<Constant>(V2);
8311 case Instruction::ZExt:
8315 case Instruction::SExt:
8319 case Instruction::Trunc:
8322 CmpConst->
getType() == SrcTy) {
8344 CastedTo = CmpConst;
8346 unsigned ExtOp = CmpI->
isSigned() ? Instruction::SExt : Instruction::ZExt;
8350 case Instruction::FPTrunc:
8353 case Instruction::FPExt:
8356 case Instruction::FPToUI:
8359 case Instruction::FPToSI:
8362 case Instruction::UIToFP:
8365 case Instruction::SIToFP:
8378 if (CastedBack && CastedBack !=
C)
8393 CmpInst *CmpI = dyn_cast<CmpInst>(SI->getCondition());
8396 Value *TrueVal = SI->getTrueValue();
8397 Value *FalseVal = SI->getFalseValue();
8410 if (isa<FPMathOperator>(CmpI))
8418 if (CastOp && CmpLHS->
getType() != TrueVal->getType()) {
8422 if (*CastOp == Instruction::FPToSI || *CastOp == Instruction::FPToUI)
8424 return ::matchSelectPattern(Pred, FMF, CmpLHS, CmpRHS,
8425 cast<CastInst>(TrueVal)->getOperand(0),
C,
8431 if (*CastOp == Instruction::FPToSI || *CastOp == Instruction::FPToUI)
8433 return ::matchSelectPattern(Pred, FMF, CmpLHS, CmpRHS,
8434 C, cast<CastInst>(FalseVal)->getOperand(0),
8438 return ::matchSelectPattern(Pred, FMF, CmpLHS, CmpRHS, TrueVal, FalseVal,
8464 case Intrinsic::smax:
return Intrinsic::smin;
8465 case Intrinsic::smin:
return Intrinsic::smax;
8466 case Intrinsic::umax:
return Intrinsic::umin;
8467 case Intrinsic::umin:
return Intrinsic::umax;
8470 case Intrinsic::maximum:
return Intrinsic::minimum;
8471 case Intrinsic::minimum:
return Intrinsic::maximum;
8472 case Intrinsic::maxnum:
return Intrinsic::minnum;
8473 case Intrinsic::minnum:
return Intrinsic::maxnum;
8488std::pair<Intrinsic::ID, bool>
8493 bool AllCmpSingleUse =
true;
8496 if (
all_of(VL, [&SelectPattern, &AllCmpSingleUse](
Value *
I) {
8502 !
I->getType()->isIntOrIntVectorTy())
8505 SelectPattern.
Flavor != CurrentPattern.Flavor)
8507 SelectPattern = CurrentPattern;
8512 switch (SelectPattern.
Flavor) {
8514 return {Intrinsic::smin, AllCmpSingleUse};
8516 return {Intrinsic::umin, AllCmpSingleUse};
8518 return {Intrinsic::smax, AllCmpSingleUse};
8520 return {Intrinsic::umax, AllCmpSingleUse};
8533 if (
P->getNumIncomingValues() != 2)
8536 for (
unsigned i = 0; i != 2; ++i) {
8537 Value *L =
P->getIncomingValue(i);
8538 Value *R =
P->getIncomingValue(!i);
8539 auto *LU = dyn_cast<BinaryOperator>(L);
8542 unsigned Opcode = LU->getOpcode();
8548 case Instruction::LShr:
8549 case Instruction::AShr:
8550 case Instruction::Shl:
8551 case Instruction::Add:
8552 case Instruction::Sub:
8553 case Instruction::And:
8554 case Instruction::Or:
8555 case Instruction::Mul:
8556 case Instruction::FMul: {
8557 Value *LL = LU->getOperand(0);
8558 Value *LR = LU->getOperand(1);
8588 P = dyn_cast<PHINode>(
I->getOperand(0));
8590 P = dyn_cast<PHINode>(
I->getOperand(1));
8611 return !
C->isNegative();
8623 const APInt *CLHS, *CRHS;
8626 return CLHS->
sle(*CRHS);
8664 const APInt *CLHS, *CRHS;
8667 return CLHS->
ule(*CRHS);
8676static std::optional<bool>
8681 return std::nullopt;
8688 return std::nullopt;
8695 return std::nullopt;
8702 return std::nullopt;
8709 return std::nullopt;
8716static std::optional<bool>
8724 return std::nullopt;
8741 return std::nullopt;
8758 LHSIsTrue ?
LHS->getPredicate() :
LHS->getInversePredicate();
8782 const APInt *LC, *RC;
8787 if (L0 == R0 && L1 == R1)
8795 return LPred == RPred;
8800 return std::nullopt;
8807static std::optional<bool>
8812 assert((
LHS->getOpcode() == Instruction::And ||
8813 LHS->getOpcode() == Instruction::Or ||
8814 LHS->getOpcode() == Instruction::Select) &&
8815 "Expected LHS to be 'and', 'or', or 'select'.");
8822 const Value *ALHS, *ARHS;
8827 ALHS, RHSPred, RHSOp0, RHSOp1,
DL, LHSIsTrue,
Depth + 1))
8830 ARHS, RHSPred, RHSOp0, RHSOp1,
DL, LHSIsTrue,
Depth + 1))
8832 return std::nullopt;
8834 return std::nullopt;
8843 return std::nullopt;
8848 return std::nullopt;
8851 "Expected integer type only!");
8855 LHSIsTrue = !LHSIsTrue;
8866 if ((LHSI->getOpcode() == Instruction::And ||
8867 LHSI->getOpcode() == Instruction::Or ||
8868 LHSI->getOpcode() == Instruction::Select))
8872 return std::nullopt;
8877 bool LHSIsTrue,
unsigned Depth) {
8883 bool InvertRHS =
false;
8890 if (
const ICmpInst *RHSCmp = dyn_cast<ICmpInst>(
RHS)) {
8892 LHS, RHSCmp->getPredicate(), RHSCmp->getOperand(0),
8893 RHSCmp->getOperand(1),
DL, LHSIsTrue,
Depth))
8894 return InvertRHS ? !*Implied : *Implied;
8895 return std::nullopt;
8899 return std::nullopt;
8903 const Value *RHS1, *RHS2;
8905 if (std::optional<bool> Imp =
8909 if (std::optional<bool> Imp =
8915 if (std::optional<bool> Imp =
8919 if (std::optional<bool> Imp =
8925 return std::nullopt;
8930static std::pair<Value *, bool>
8932 if (!ContextI || !ContextI->
getParent())
8933 return {
nullptr,
false};
8940 return {
nullptr,
false};
8946 return {
nullptr,
false};
8949 if (TrueBB == FalseBB)
8950 return {
nullptr,
false};
8952 assert((TrueBB == ContextBB || FalseBB == ContextBB) &&
8953 "Predecessor block does not point to successor?");
8956 return {PredCond, TrueBB == ContextBB};
8962 assert(
Cond->getType()->isIntOrIntVectorTy(1) &&
"Condition must be bool");
8966 return std::nullopt;
8978 return std::nullopt;
8983 bool PreferSignedRange) {
8984 unsigned Width =
Lower.getBitWidth();
8987 case Instruction::Add:
8996 if (PreferSignedRange && HasNSW && HasNUW)
9002 }
else if (HasNSW) {
9003 if (
C->isNegative()) {
9016 case Instruction::And:
9027 case Instruction::Or:
9033 case Instruction::AShr:
9039 unsigned ShiftAmount = Width - 1;
9040 if (!
C->isZero() && IIQ.
isExact(&BO))
9041 ShiftAmount =
C->countr_zero();
9042 if (
C->isNegative()) {
9045 Upper =
C->ashr(ShiftAmount) + 1;
9048 Lower =
C->ashr(ShiftAmount);
9054 case Instruction::LShr:
9060 unsigned ShiftAmount = Width - 1;
9061 if (!
C->isZero() && IIQ.
isExact(&BO))
9062 ShiftAmount =
C->countr_zero();
9063 Lower =
C->lshr(ShiftAmount);
9068 case Instruction::Shl:
9075 if (
C->isNegative()) {
9077 unsigned ShiftAmount =
C->countl_one() - 1;
9078 Lower =
C->shl(ShiftAmount);
9082 unsigned ShiftAmount =
C->countl_zero() - 1;
9084 Upper =
C->shl(ShiftAmount) + 1;
9103 case Instruction::SDiv:
9107 if (
C->isAllOnes()) {
9112 }
else if (
C->countl_zero() < Width - 1) {
9123 if (
C->isMinSignedValue()) {
9135 case Instruction::UDiv:
9145 case Instruction::SRem:
9151 if (
C->isNegative()) {
9162 case Instruction::URem:
9180 case Intrinsic::ctpop:
9181 case Intrinsic::ctlz:
9182 case Intrinsic::cttz:
9185 APInt(Width, Width + 1));
9186 case Intrinsic::uadd_sat:
9192 case Intrinsic::sadd_sat:
9195 if (
C->isNegative())
9206 case Intrinsic::usub_sat:
9216 case Intrinsic::ssub_sat:
9218 if (
C->isNegative())
9228 if (
C->isNegative())
9239 case Intrinsic::umin:
9240 case Intrinsic::umax:
9241 case Intrinsic::smin:
9242 case Intrinsic::smax:
9248 case Intrinsic::umin:
9250 case Intrinsic::umax:
9252 case Intrinsic::smin:
9255 case Intrinsic::smax:
9262 case Intrinsic::abs:
9271 case Intrinsic::vscale:
9279 return ConstantRange::getFull(Width);
9284 unsigned BitWidth = SI.getType()->getScalarSizeInBits();
9288 return ConstantRange::getFull(
BitWidth);
9311 return ConstantRange::getFull(
BitWidth);
9325 return ConstantRange::getFull(
BitWidth);
9332 unsigned BitWidth =
I->getType()->getScalarSizeInBits();
9333 if (!
I->getOperand(0)->getType()->getScalarType()->isHalfTy())
9335 if (isa<FPToSIInst>(
I) &&
BitWidth >= 17) {
9340 if (isa<FPToUIInst>(
I) &&
BitWidth >= 16) {
9351 assert(V->getType()->isIntOrIntVectorTy() &&
"Expected integer instruction");
9354 return ConstantRange::getFull(V->getType()->getScalarSizeInBits());
9359 unsigned BitWidth = V->getType()->getScalarSizeInBits();
9361 if (
auto *VC = dyn_cast<ConstantDataVector>(V)) {
9363 for (
unsigned ElemIdx = 0, NElem = VC->getNumElements(); ElemIdx < NElem;
9365 CR = CR.
unionWith(VC->getElementAsAPInt(ElemIdx));
9371 if (
auto *BO = dyn_cast<BinaryOperator>(V)) {
9377 }
else if (
auto *II = dyn_cast<IntrinsicInst>(V))
9379 else if (
auto *SI = dyn_cast<SelectInst>(V)) {
9381 SI->getTrueValue(), ForSigned, UseInstrInfo, AC, CtxI, DT,
Depth + 1);
9383 SI->getFalseValue(), ForSigned, UseInstrInfo, AC, CtxI, DT,
Depth + 1);
9386 }
else if (isa<FPToUIInst>(V) || isa<FPToSIInst>(V)) {
9392 }
else if (
const auto *
A = dyn_cast<Argument>(V))
9393 if (std::optional<ConstantRange> Range =
A->getRange())
9396 if (
auto *
I = dyn_cast<Instruction>(V)) {
9397 if (
auto *Range = IIQ.
getMetadata(
I, LLVMContext::MD_range))
9400 if (
const auto *CB = dyn_cast<CallBase>(V))
9401 if (std::optional<ConstantRange> Range = CB->getRange())
9412 "Got assumption for the wrong function!");
9413 assert(
I->getCalledFunction()->getIntrinsicID() == Intrinsic::assume &&
9414 "must be an assume intrinsic");
9418 Value *Arg =
I->getArgOperand(0);
9419 ICmpInst *Cmp = dyn_cast<ICmpInst>(Arg);
9421 if (!Cmp || Cmp->getOperand(0) != V)
9426 UseInstrInfo, AC,
I, DT,
Depth + 1);
9439 if (isa<Argument>(V) || isa<GlobalValue>(V)) {
9441 }
else if (
auto *
I = dyn_cast<Instruction>(V)) {
9447 if (isa<Instruction>(
Op) || isa<Argument>(
Op))
9455 auto AddAffected = [&InsertAffected](
Value *V) {
9470 while (!Worklist.
empty()) {
9472 if (!Visited.
insert(V).second)
9495 AddCmpOperands(
A,
B);
9539 AddCmpOperands(
A,
B);
9549 }
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)
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...
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.
OverflowResult computeOverflowForUnsignedMul(const Value *LHS, const Value *RHS, const SimplifyQuery &SQ)
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).
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