58#include "llvm/IR/IntrinsicsAArch64.h"
59#include "llvm/IR/IntrinsicsAMDGPU.h"
60#include "llvm/IR/IntrinsicsRISCV.h"
61#include "llvm/IR/IntrinsicsX86.h"
98 return DL.getPointerTypeSizeInBits(Ty);
110 CxtI = dyn_cast<Instruction>(V);
124 CxtI = dyn_cast<Instruction>(V1);
128 CxtI = dyn_cast<Instruction>(V2);
136 const APInt &DemandedElts,
138 if (isa<ScalableVectorType>(Shuf->
getType())) {
140 DemandedLHS = DemandedRHS = DemandedElts;
147 DemandedElts, DemandedLHS, DemandedRHS);
159 auto *FVTy = dyn_cast<FixedVectorType>(V->getType());
187 V, DemandedElts,
Depth,
243 "LHS and RHS should have the same type");
245 "LHS and RHS should be integers");
256 return !
I->user_empty() &&
all_of(
I->users(), [](
const User *U) {
257 ICmpInst::Predicate P;
258 return match(U, m_ICmp(P, m_Value(), m_Zero()));
263 return !
I->user_empty() &&
all_of(
I->users(), [](
const User *U) {
264 ICmpInst::Predicate P;
265 return match(U, m_ICmp(P, m_Value(), m_Zero())) && ICmpInst::isEquality(P);
273 bool OrZero,
unsigned Depth,
276 return ::isKnownToBeAPowerOfTwo(
291 if (
auto *CI = dyn_cast<ConstantInt>(V))
292 return CI->getValue().isStrictlyPositive();
313 return ::isKnownNonEqual(
322 return Mask.isSubsetOf(Known.
Zero);
330 auto *FVTy = dyn_cast<FixedVectorType>(V->getType());
340 return ::ComputeNumSignBits(
349 return V->getType()->getScalarSizeInBits() - SignBits + 1;
354 const APInt &DemandedElts,
361 if (KnownOut.
isUnknown() && !NSW && !NUW)
386 bool isKnownNegativeOp0 = Known2.
isNegative();
389 (isKnownNonNegativeOp1 && isKnownNonNegativeOp0);
394 (isKnownNegativeOp1 && isKnownNonNegativeOp0 &&
396 (isKnownNegativeOp0 && isKnownNonNegativeOp1 && Known.
isNonZero());
400 bool SelfMultiply = Op0 == Op1;
420 unsigned NumRanges = Ranges.getNumOperands() / 2;
426 for (
unsigned i = 0; i < NumRanges; ++i) {
428 mdconst::extract<ConstantInt>(Ranges.getOperand(2 * i + 0));
430 mdconst::extract<ConstantInt>(Ranges.getOperand(2 * i + 1));
434 unsigned CommonPrefixBits =
438 Known.
One &= UnsignedMax & Mask;
439 Known.
Zero &= ~UnsignedMax & Mask;
454 while (!WorkSet.
empty()) {
456 if (!Visited.
insert(V).second)
461 return EphValues.count(U);
466 if (V ==
I || (isa<Instruction>(V) &&
468 !cast<Instruction>(V)->isTerminator())) {
470 if (
const User *U = dyn_cast<User>(V))
482 return CI->isAssumeLikeIntrinsic();
490 bool AllowEphemerals) {
508 if (!AllowEphemerals && Inv == CxtI)
543 if (Pred == ICmpInst::ICMP_UGT)
547 if (Pred == ICmpInst::ICMP_NE)
558 auto *VC = dyn_cast<ConstantDataVector>(
RHS);
562 for (
unsigned ElemIdx = 0, NElem = VC->getNumElements(); ElemIdx < NElem;
565 Pred, VC->getElementAsAPInt(ElemIdx));
584 "Got assumption for the wrong function!");
587 if (!V->getType()->isPointerTy())
590 *
I,
I->bundle_op_info_begin()[Elem.Index])) {
592 (RK.AttrKind == Attribute::NonNull ||
593 (RK.AttrKind == Attribute::Dereferenceable &&
595 V->getType()->getPointerAddressSpace()))) &&
627 case ICmpInst::ICMP_EQ:
630 case ICmpInst::ICMP_SGE:
631 case ICmpInst::ICMP_SGT:
634 case ICmpInst::ICMP_SLT:
652 case ICmpInst::ICMP_EQ:
662 Known.
Zero |= ~*
C & *Mask;
668 Known.
One |= *
C & ~*Mask;
689 Known.
Zero |= RHSKnown.
Zero << ShAmt;
690 Known.
One |= RHSKnown.
One << ShAmt;
693 case ICmpInst::ICMP_NE: {
709 if (Pred == ICmpInst::ICMP_UGT || Pred == ICmpInst::ICMP_UGE) {
715 (*
C + (Pred == ICmpInst::ICMP_UGT)).countLeadingOnes());
717 if (Pred == ICmpInst::ICMP_ULT || Pred == ICmpInst::ICMP_ULE) {
723 (*
C - (Pred == ICmpInst::ICMP_ULT)).countLeadingZeros());
735 Invert ? Cmp->getInversePredicate() : Cmp->getPredicate();
768 if (
auto *Cmp = dyn_cast<ICmpInst>(
Cond))
809 "Got assumption for the wrong function!");
812 if (!V->getType()->isPointerTy())
815 *
I,
I->bundle_op_info_begin()[Elem.Index])) {
816 if (RK.WasOn == V && RK.AttrKind == Attribute::Alignment &&
828 Value *Arg =
I->getArgOperand(0);
848 ICmpInst *Cmp = dyn_cast<ICmpInst>(Arg);
884 Known = KF(Known2, Known, ShAmtNonZero);
895 Value *
X =
nullptr, *
Y =
nullptr;
897 switch (
I->getOpcode()) {
898 case Instruction::And:
899 KnownOut = KnownLHS & KnownRHS;
909 KnownOut = KnownLHS.
blsi();
911 KnownOut = KnownRHS.
blsi();
914 case Instruction::Or:
915 KnownOut = KnownLHS | KnownRHS;
917 case Instruction::Xor:
918 KnownOut = KnownLHS ^ KnownRHS;
928 const KnownBits &XBits =
I->getOperand(0) ==
X ? KnownLHS : KnownRHS;
929 KnownOut = XBits.
blsmsk();
942 if (!KnownOut.
Zero[0] && !KnownOut.
One[0] &&
964 auto *FVTy = dyn_cast<FixedVectorType>(
I->getType());
973 Attribute Attr =
F->getFnAttribute(Attribute::VScaleRange);
981 return ConstantRange::getEmpty(
BitWidth);
992 const APInt &DemandedElts,
998 switch (
I->getOpcode()) {
1000 case Instruction::Load:
1005 case Instruction::And:
1011 case Instruction::Or:
1017 case Instruction::Xor:
1023 case Instruction::Mul: {
1026 Known, Known2,
Depth, Q);
1029 case Instruction::UDiv: {
1036 case Instruction::SDiv: {
1043 case Instruction::Select: {
1044 auto ComputeForArm = [&](
Value *Arm,
bool Invert) {
1080 ComputeForArm(
I->getOperand(1),
false)
1084 case Instruction::FPTrunc:
1085 case Instruction::FPExt:
1086 case Instruction::FPToUI:
1087 case Instruction::FPToSI:
1088 case Instruction::SIToFP:
1089 case Instruction::UIToFP:
1091 case Instruction::PtrToInt:
1092 case Instruction::IntToPtr:
1095 case Instruction::ZExt:
1096 case Instruction::Trunc: {
1097 Type *SrcTy =
I->getOperand(0)->getType();
1099 unsigned SrcBitWidth;
1107 assert(SrcBitWidth &&
"SrcBitWidth can't be zero");
1110 if (
auto *Inst = dyn_cast<PossiblyNonNegInst>(
I);
1111 Inst && Inst->hasNonNeg() && !Known.
isNegative())
1116 case Instruction::BitCast: {
1117 Type *SrcTy =
I->getOperand(0)->getType();
1121 !
I->getType()->isVectorTy()) {
1129 V->getType()->isFPOrFPVectorTy()) {
1130 Type *FPType = V->getType()->getScalarType();
1142 if (FPClasses &
fcInf)
1154 if (Result.SignBit) {
1155 if (*Result.SignBit)
1165 auto *SrcVecTy = dyn_cast<FixedVectorType>(SrcTy);
1166 if (!SrcVecTy || !SrcVecTy->getElementType()->isIntegerTy() ||
1167 !
I->getType()->isIntOrIntVectorTy() ||
1168 isa<ScalableVectorType>(
I->getType()))
1173 unsigned SubBitWidth = SrcVecTy->getScalarSizeInBits();
1190 unsigned SubScale =
BitWidth / SubBitWidth;
1192 for (
unsigned i = 0; i != NumElts; ++i) {
1193 if (DemandedElts[i])
1194 SubDemandedElts.
setBit(i * SubScale);
1198 for (
unsigned i = 0; i != SubScale; ++i) {
1202 Known.
insertBits(KnownSrc, ShiftElt * SubBitWidth);
1207 case Instruction::SExt: {
1209 unsigned SrcBitWidth =
I->getOperand(0)->getType()->getScalarSizeInBits();
1211 Known = Known.
trunc(SrcBitWidth);
1218 case Instruction::Shl: {
1222 bool ShAmtNonZero) {
1223 return KnownBits::shl(KnownVal, KnownAmt, NUW, NSW, ShAmtNonZero);
1233 case Instruction::LShr: {
1234 bool Exact = Q.
IIQ.
isExact(cast<BinaryOperator>(
I));
1236 bool ShAmtNonZero) {
1247 case Instruction::AShr: {
1248 bool Exact = Q.
IIQ.
isExact(cast<BinaryOperator>(
I));
1250 bool ShAmtNonZero) {
1257 case Instruction::Sub: {
1261 DemandedElts, Known, Known2,
Depth, Q);
1264 case Instruction::Add: {
1268 DemandedElts, Known, Known2,
Depth, Q);
1271 case Instruction::SRem:
1277 case Instruction::URem:
1282 case Instruction::Alloca:
1285 case Instruction::GetElementPtr: {
1294 for (
unsigned i = 1, e =
I->getNumOperands(); i != e; ++i, ++GTI) {
1310 "Access to structure field must be known at compile time");
1315 unsigned Idx = cast<ConstantInt>(
Index)->getZExtValue();
1318 AccConstIndices +=
Offset;
1329 unsigned IndexBitWidth =
Index->getType()->getScalarSizeInBits();
1343 APInt ScalingFactor(IndexBitWidth, TypeSizeInBytes);
1344 IndexConst *= ScalingFactor;
1361 true,
false,
false, Known, IndexBits);
1366 true,
false,
false, Known,
Index);
1370 case Instruction::PHI: {
1373 Value *R =
nullptr, *L =
nullptr;
1383 if ((Opcode == Instruction::LShr || Opcode == Instruction::AShr ||
1384 Opcode == Instruction::Shl) &&
1399 case Instruction::Shl:
1403 case Instruction::LShr:
1408 case Instruction::AShr:
1419 if (Opcode == Instruction::Add ||
1420 Opcode == Instruction::Sub ||
1421 Opcode == Instruction::And ||
1422 Opcode == Instruction::Or ||
1423 Opcode == Instruction::Mul) {
1430 unsigned OpNum =
P->getOperand(0) == R ? 0 : 1;
1431 Instruction *RInst =
P->getIncomingBlock(OpNum)->getTerminator();
1432 Instruction *LInst =
P->getIncomingBlock(1-OpNum)->getTerminator();
1447 auto *OverflowOp = dyn_cast<OverflowingBinaryOperator>(BO);
1458 if (Opcode == Instruction::Add) {
1467 else if (Opcode == Instruction::Sub && BO->
getOperand(0) ==
I) {
1475 else if (Opcode == Instruction::Mul && Known2.
isNonNegative() &&
1485 if (
P->getNumIncomingValues() == 0)
1492 if (isa_and_nonnull<UndefValue>(
P->hasConstantValue()))
1497 for (
unsigned u = 0, e =
P->getNumIncomingValues(); u < e; ++u) {
1498 Value *IncValue =
P->getIncomingValue(u);
1500 if (IncValue ==
P)
continue;
1507 RecQ.
CxtI =
P->getIncomingBlock(u)->getTerminator();
1528 if ((TrueSucc ==
P->getParent()) != (FalseSucc ==
P->getParent())) {
1530 if (FalseSucc ==
P->getParent())
1544 Known2 = KnownUnion;
1558 case Instruction::Call:
1559 case Instruction::Invoke: {
1567 const auto *CB = cast<CallBase>(
I);
1569 if (std::optional<ConstantRange>
Range = CB->getRange())
1572 if (
const Value *RV = CB->getReturnedArgOperand()) {
1573 if (RV->getType() ==
I->getType()) {
1585 switch (
II->getIntrinsicID()) {
1587 case Intrinsic::abs: {
1589 bool IntMinIsPoison =
match(
II->getArgOperand(1),
m_One());
1590 Known = Known2.
abs(IntMinIsPoison);
1593 case Intrinsic::bitreverse:
1598 case Intrinsic::bswap:
1603 case Intrinsic::ctlz: {
1609 PossibleLZ = std::min(PossibleLZ,
BitWidth - 1);
1614 case Intrinsic::cttz: {
1620 PossibleTZ = std::min(PossibleTZ,
BitWidth - 1);
1625 case Intrinsic::ctpop: {
1636 case Intrinsic::fshr:
1637 case Intrinsic::fshl: {
1644 if (
II->getIntrinsicID() == Intrinsic::fshr)
1657 case Intrinsic::uadd_sat:
1662 case Intrinsic::usub_sat:
1667 case Intrinsic::sadd_sat:
1672 case Intrinsic::ssub_sat:
1679 case Intrinsic::vector_reduce_and:
1680 case Intrinsic::vector_reduce_or:
1681 case Intrinsic::vector_reduce_umax:
1682 case Intrinsic::vector_reduce_umin:
1683 case Intrinsic::vector_reduce_smax:
1684 case Intrinsic::vector_reduce_smin:
1687 case Intrinsic::vector_reduce_xor: {
1692 auto *VecTy = cast<VectorType>(
I->getOperand(0)->getType());
1694 bool EvenCnt = VecTy->getElementCount().isKnownEven();
1698 if (VecTy->isScalableTy() || EvenCnt)
1702 case Intrinsic::umin:
1707 case Intrinsic::umax:
1712 case Intrinsic::smin:
1717 case Intrinsic::smax:
1722 case Intrinsic::ptrmask: {
1725 const Value *Mask =
I->getOperand(1);
1726 Known2 =
KnownBits(Mask->getType()->getScalarSizeInBits());
1732 case Intrinsic::x86_sse42_crc32_64_64:
1735 case Intrinsic::riscv_vsetvli:
1736 case Intrinsic::riscv_vsetvlimax: {
1737 bool HasAVL =
II->getIntrinsicID() == Intrinsic::riscv_vsetvli;
1740 cast<ConstantInt>(
II->getArgOperand(HasAVL))->getZExtValue());
1742 cast<ConstantInt>(
II->getArgOperand(1 + HasAVL))->getZExtValue());
1749 if (
auto *CI = dyn_cast<ConstantInt>(
II->getArgOperand(0)))
1750 MaxVL = std::min(MaxVL, CI->getZExtValue());
1752 unsigned KnownZeroFirstBit =
Log2_32(MaxVL) + 1;
1757 case Intrinsic::vscale: {
1758 if (!
II->getParent() || !
II->getFunction())
1768 case Instruction::ShuffleVector: {
1769 auto *Shuf = dyn_cast<ShuffleVectorInst>(
I);
1777 APInt DemandedLHS, DemandedRHS;
1784 if (!!DemandedLHS) {
1785 const Value *
LHS = Shuf->getOperand(0);
1791 if (!!DemandedRHS) {
1792 const Value *
RHS = Shuf->getOperand(1);
1798 case Instruction::InsertElement: {
1799 if (isa<ScalableVectorType>(
I->getType())) {
1803 const Value *Vec =
I->getOperand(0);
1804 const Value *Elt =
I->getOperand(1);
1805 auto *CIdx = dyn_cast<ConstantInt>(
I->getOperand(2));
1807 APInt DemandedVecElts = DemandedElts;
1808 bool NeedsElt =
true;
1810 if (CIdx && CIdx->getValue().ult(NumElts)) {
1811 DemandedVecElts.
clearBit(CIdx->getZExtValue());
1812 NeedsElt = DemandedElts[CIdx->getZExtValue()];
1824 if (!DemandedVecElts.
isZero()) {
1830 case Instruction::ExtractElement: {
1833 const Value *Vec =
I->getOperand(0);
1835 auto *CIdx = dyn_cast<ConstantInt>(
Idx);
1836 if (isa<ScalableVectorType>(Vec->
getType())) {
1841 unsigned NumElts = cast<FixedVectorType>(Vec->
getType())->getNumElements();
1843 if (CIdx && CIdx->getValue().ult(NumElts))
1848 case Instruction::ExtractValue:
1853 switch (
II->getIntrinsicID()) {
1855 case Intrinsic::uadd_with_overflow:
1856 case Intrinsic::sadd_with_overflow:
1858 true,
II->getArgOperand(0),
II->getArgOperand(1),
false,
1859 false, DemandedElts, Known, Known2,
Depth, Q);
1861 case Intrinsic::usub_with_overflow:
1862 case Intrinsic::ssub_with_overflow:
1864 false,
II->getArgOperand(0),
II->getArgOperand(1),
false,
1865 false, DemandedElts, Known, Known2,
Depth, Q);
1867 case Intrinsic::umul_with_overflow:
1868 case Intrinsic::smul_with_overflow:
1870 DemandedElts, Known, Known2,
Depth, Q);
1876 case Instruction::Freeze:
1920 if (!DemandedElts) {
1926 assert(V &&
"No Value?");
1930 Type *Ty = V->getType();
1934 "Not integer or pointer type!");
1936 if (
auto *FVTy = dyn_cast<FixedVectorType>(Ty)) {
1938 FVTy->getNumElements() == DemandedElts.
getBitWidth() &&
1939 "DemandedElt width should equal the fixed vector number of elements");
1942 "DemandedElt width should be 1 for scalars or scalable vectors");
1948 "V and Known should have same BitWidth");
1951 "V and Known should have same BitWidth");
1962 if (isa<ConstantPointerNull>(V) || isa<ConstantAggregateZero>(V)) {
1969 assert(!isa<ScalableVectorType>(V->getType()));
1973 for (
unsigned i = 0, e = CDV->getNumElements(); i != e; ++i) {
1974 if (!DemandedElts[i])
1976 APInt Elt = CDV->getElementAsAPInt(i);
1985 if (
const auto *CV = dyn_cast<ConstantVector>(V)) {
1986 assert(!isa<ScalableVectorType>(V->getType()));
1990 for (
unsigned i = 0, e = CV->getNumOperands(); i != e; ++i) {
1991 if (!DemandedElts[i])
1994 if (isa<PoisonValue>(Element))
1996 auto *ElementCI = dyn_cast_or_null<ConstantInt>(Element);
2001 const APInt &Elt = ElementCI->getValue();
2014 if (isa<UndefValue>(V))
2019 assert(!isa<ConstantData>(V) &&
"Unhandled constant data!");
2021 if (
const auto *
A = dyn_cast<Argument>(V))
2022 if (std::optional<ConstantRange>
Range =
A->getRange())
2031 if (
const GlobalAlias *GA = dyn_cast<GlobalAlias>(V)) {
2032 if (!GA->isInterposable())
2037 if (
const Operator *
I = dyn_cast<Operator>(V))
2039 else if (
const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
2040 if (std::optional<ConstantRange> CR = GV->getAbsoluteSymbolRange())
2041 Known = CR->toKnownBits();
2045 if (isa<PointerType>(V->getType())) {
2046 Align Alignment = V->getPointerAlignment(Q.
DL);
2062 Value *Start =
nullptr, *Step =
nullptr;
2068 if (U.get() == Start) {
2084 case Instruction::Mul:
2089 case Instruction::SDiv:
2095 case Instruction::UDiv:
2101 case Instruction::Shl:
2103 case Instruction::AShr:
2107 case Instruction::LShr:
2122 if (isa<Constant>(V))
2126 if (OrZero && V->getType()->getScalarSizeInBits() == 1)
2129 auto *
I = dyn_cast<Instruction>(V);
2136 return F->hasFnAttribute(Attribute::VScaleRange);
2153 switch (
I->getOpcode()) {
2154 case Instruction::ZExt:
2156 case Instruction::Trunc:
2158 case Instruction::Shl:
2162 case Instruction::LShr:
2163 if (OrZero || Q.
IIQ.
isExact(cast<BinaryOperator>(
I)))
2166 case Instruction::UDiv:
2170 case Instruction::Mul:
2174 case Instruction::And:
2185 case Instruction::Add: {
2191 if (
match(
I->getOperand(0),
2195 if (
match(
I->getOperand(1),
2200 unsigned BitWidth = V->getType()->getScalarSizeInBits();
2209 if ((~(LHSBits.
Zero & RHSBits.
Zero)).isPowerOf2())
2222 case Instruction::Select:
2225 case Instruction::PHI: {
2229 auto *PN = cast<PHINode>(
I);
2246 RecQ.CxtI = PN->getIncomingBlock(U)->getTerminator();
2247 return isKnownToBeAPowerOfTwo(U.get(), OrZero, NewDepth, RecQ);
2250 case Instruction::Invoke:
2251 case Instruction::Call: {
2252 if (
auto *
II = dyn_cast<IntrinsicInst>(
I)) {
2253 switch (
II->getIntrinsicID()) {
2254 case Intrinsic::umax:
2255 case Intrinsic::smax:
2256 case Intrinsic::umin:
2257 case Intrinsic::smin:
2262 case Intrinsic::bitreverse:
2263 case Intrinsic::bswap:
2265 case Intrinsic::fshr:
2266 case Intrinsic::fshl:
2268 if (
II->getArgOperand(0) ==
II->getArgOperand(1))
2292 F =
I->getFunction();
2296 if (!
GEP->hasNoUnsignedWrap() &&
2297 !(
GEP->isInBounds() &&
2302 assert(
GEP->getType()->isPointerTy() &&
"We only support plain pointer GEP");
2313 GTI != GTE; ++GTI) {
2315 if (
StructType *STy = GTI.getStructTypeOrNull()) {
2316 ConstantInt *OpC = cast<ConstantInt>(GTI.getOperand());
2320 if (ElementOffset > 0)
2326 if (GTI.getSequentialElementStride(Q.
DL).isZero())
2331 if (
ConstantInt *OpC = dyn_cast<ConstantInt>(GTI.getOperand())) {
2355 assert(!isa<Constant>(V) &&
"Called for constant?");
2360 unsigned NumUsesExplored = 0;
2361 for (
const auto *U : V->users()) {
2369 if (
const auto *CB = dyn_cast<CallBase>(U))
2370 if (
auto *CalledFunc = CB->getCalledFunction())
2371 for (
const Argument &Arg : CalledFunc->args())
2372 if (CB->getArgOperand(Arg.getArgNo()) == V &&
2373 Arg.hasNonNullAttr(
false) &&
2381 V->getType()->getPointerAddressSpace()) &&
2399 NonNullIfTrue =
true;
2401 NonNullIfTrue =
false;
2407 for (
const auto *CmpU : U->users()) {
2409 if (Visited.
insert(CmpU).second)
2412 while (!WorkList.
empty()) {
2421 for (
const auto *CurrU : Curr->users())
2422 if (Visited.
insert(CurrU).second)
2427 if (
const BranchInst *BI = dyn_cast<BranchInst>(Curr)) {
2428 assert(BI->isConditional() &&
"uses a comparison!");
2431 BI->getSuccessor(NonNullIfTrue ? 0 : 1);
2435 }
else if (NonNullIfTrue &&
isGuard(Curr) &&
2436 DT->
dominates(cast<Instruction>(Curr), CtxI)) {
2450 const unsigned NumRanges = Ranges->getNumOperands() / 2;
2452 for (
unsigned i = 0; i < NumRanges; ++i) {
2454 mdconst::extract<ConstantInt>(Ranges->getOperand(2 * i + 0));
2456 mdconst::extract<ConstantInt>(Ranges->getOperand(2 * i + 1));
2468 Value *Start =
nullptr, *Step =
nullptr;
2469 const APInt *StartC, *StepC;
2475 case Instruction::Add:
2481 case Instruction::Mul:
2484 case Instruction::Shl:
2486 case Instruction::AShr:
2487 case Instruction::LShr:
2498 Pred == ICmpInst::ICMP_EQ;
2503 Value *
Y,
bool NSW,
bool NUW) {
2557 if (
auto *
C = dyn_cast<Constant>(
X))
2561 return ::isKnownNonEqual(
X,
Y,
Depth, Q);
2566 Value *
Y,
bool NSW,
bool NUW) {
2595 auto ShiftOp = [&](
const APInt &Lhs,
const APInt &Rhs) {
2596 switch (
I->getOpcode()) {
2597 case Instruction::Shl:
2598 return Lhs.
shl(Rhs);
2599 case Instruction::LShr:
2600 return Lhs.
lshr(Rhs);
2601 case Instruction::AShr:
2602 return Lhs.
ashr(Rhs);
2608 auto InvShiftOp = [&](
const APInt &Lhs,
const APInt &Rhs) {
2609 switch (
I->getOpcode()) {
2610 case Instruction::Shl:
2611 return Lhs.
lshr(Rhs);
2612 case Instruction::LShr:
2613 case Instruction::AShr:
2614 return Lhs.
shl(Rhs);
2627 if (MaxShift.
uge(NumBits))
2630 if (!ShiftOp(KnownVal.
One, MaxShift).isZero())
2635 if (InvShiftOp(KnownVal.
Zero, NumBits - MaxShift)
2644 const APInt &DemandedElts,
2647 switch (
I->getOpcode()) {
2648 case Instruction::Alloca:
2650 return I->getType()->getPointerAddressSpace() == 0;
2651 case Instruction::GetElementPtr:
2652 if (
I->getType()->isPointerTy())
2655 case Instruction::BitCast: {
2683 Type *FromTy =
I->getOperand(0)->getType();
2688 case Instruction::IntToPtr:
2692 if (!isa<ScalableVectorType>(
I->getType()) &&
2697 case Instruction::PtrToInt:
2700 if (!isa<ScalableVectorType>(
I->getType()) &&
2705 case Instruction::Trunc:
2707 if (
auto *TI = dyn_cast<TruncInst>(
I))
2708 if (TI->hasNoSignedWrap() || TI->hasNoUnsignedWrap())
2712 case Instruction::Sub:
2715 case Instruction::Xor:
2720 case Instruction::Or:
2727 case Instruction::SExt:
2728 case Instruction::ZExt:
2732 case Instruction::Shl: {
2747 case Instruction::LShr:
2748 case Instruction::AShr: {
2763 case Instruction::UDiv:
2764 case Instruction::SDiv: {
2767 if (cast<PossiblyExactOperator>(
I)->isExact())
2779 if (
I->getOpcode() == Instruction::SDiv) {
2781 XKnown = XKnown.
abs(
false);
2782 YKnown = YKnown.
abs(
false);
2788 return XUgeY && *XUgeY;
2790 case Instruction::Add: {
2795 auto *BO = cast<OverflowingBinaryOperator>(
I);
2800 case Instruction::Mul: {
2806 case Instruction::Select: {
2813 auto SelectArmIsNonZero = [&](
bool IsTrueArm) {
2815 Op = IsTrueArm ?
I->getOperand(1) :
I->getOperand(2);
2828 Pred = ICmpInst::getInversePredicate(Pred);
2833 if (SelectArmIsNonZero(
true) &&
2834 SelectArmIsNonZero(
false))
2838 case Instruction::PHI: {
2839 auto *PN = cast<PHINode>(
I);
2849 RecQ.CxtI = PN->getIncomingBlock(U)->getTerminator();
2851 ICmpInst::Predicate Pred;
2853 BasicBlock *TrueSucc, *FalseSucc;
2854 if (match(RecQ.CxtI,
2855 m_Br(m_c_ICmp(Pred, m_Specific(U.get()), m_Value(X)),
2856 m_BasicBlock(TrueSucc), m_BasicBlock(FalseSucc)))) {
2858 if ((TrueSucc == PN->getParent()) != (FalseSucc == PN->getParent())) {
2860 if (FalseSucc == PN->getParent())
2861 Pred = CmpInst::getInversePredicate(Pred);
2862 if (cmpExcludesZero(Pred, X))
2870 case Instruction::InsertElement: {
2871 if (isa<ScalableVectorType>(
I->getType()))
2874 const Value *Vec =
I->getOperand(0);
2875 const Value *Elt =
I->getOperand(1);
2876 auto *CIdx = dyn_cast<ConstantInt>(
I->getOperand(2));
2879 APInt DemandedVecElts = DemandedElts;
2880 bool SkipElt =
false;
2882 if (CIdx && CIdx->getValue().ult(NumElts)) {
2883 DemandedVecElts.
clearBit(CIdx->getZExtValue());
2884 SkipElt = !DemandedElts[CIdx->getZExtValue()];
2890 (DemandedVecElts.
isZero() ||
2893 case Instruction::ExtractElement:
2894 if (
const auto *EEI = dyn_cast<ExtractElementInst>(
I)) {
2895 const Value *Vec = EEI->getVectorOperand();
2896 const Value *
Idx = EEI->getIndexOperand();
2897 auto *CIdx = dyn_cast<ConstantInt>(
Idx);
2898 if (
auto *VecTy = dyn_cast<FixedVectorType>(Vec->
getType())) {
2899 unsigned NumElts = VecTy->getNumElements();
2901 if (CIdx && CIdx->getValue().ult(NumElts))
2907 case Instruction::ShuffleVector: {
2908 auto *Shuf = dyn_cast<ShuffleVectorInst>(
I);
2911 APInt DemandedLHS, DemandedRHS;
2917 return (DemandedRHS.
isZero() ||
2922 case Instruction::Freeze:
2926 case Instruction::Load: {
2927 auto *LI = cast<LoadInst>(
I);
2930 if (
auto *PtrT = dyn_cast<PointerType>(
I->getType())) {
2943 case Instruction::ExtractValue: {
2949 case Instruction::Add:
2954 case Instruction::Sub:
2957 case Instruction::Mul:
2966 case Instruction::Call:
2967 case Instruction::Invoke: {
2968 const auto *Call = cast<CallBase>(
I);
2969 if (
I->getType()->isPointerTy()) {
2970 if (Call->isReturnNonNull())
2977 if (std::optional<ConstantRange>
Range = Call->getRange()) {
2982 if (
const Value *RV = Call->getReturnedArgOperand())
2987 if (
auto *
II = dyn_cast<IntrinsicInst>(
I)) {
2988 switch (
II->getIntrinsicID()) {
2989 case Intrinsic::sshl_sat:
2990 case Intrinsic::ushl_sat:
2991 case Intrinsic::abs:
2992 case Intrinsic::bitreverse:
2993 case Intrinsic::bswap:
2994 case Intrinsic::ctpop:
2998 case Intrinsic::ssub_sat:
3000 II->getArgOperand(0),
II->getArgOperand(1));
3001 case Intrinsic::sadd_sat:
3003 II->getArgOperand(0),
II->getArgOperand(1),
3006 case Intrinsic::vector_reduce_or:
3007 case Intrinsic::vector_reduce_umax:
3008 case Intrinsic::vector_reduce_umin:
3009 case Intrinsic::vector_reduce_smax:
3010 case Intrinsic::vector_reduce_smin:
3012 case Intrinsic::umax:
3013 case Intrinsic::uadd_sat:
3021 case Intrinsic::smax: {
3024 auto IsNonZero = [&](
Value *
Op, std::optional<bool> &OpNonZero,
3026 if (!OpNonZero.has_value())
3027 OpNonZero = OpKnown.isNonZero() ||
3032 std::optional<bool> Op0NonZero, Op1NonZero;
3036 IsNonZero(
II->getArgOperand(1), Op1NonZero, Op1Known))
3041 IsNonZero(
II->getArgOperand(0), Op0NonZero, Op0Known))
3043 return IsNonZero(
II->getArgOperand(1), Op1NonZero, Op1Known) &&
3044 IsNonZero(
II->getArgOperand(0), Op0NonZero, Op0Known);
3046 case Intrinsic::smin: {
3062 case Intrinsic::umin:
3065 case Intrinsic::cttz:
3068 case Intrinsic::ctlz:
3071 case Intrinsic::fshr:
3072 case Intrinsic::fshl:
3074 if (
II->getArgOperand(0) ==
II->getArgOperand(1))
3077 case Intrinsic::vscale:
3079 case Intrinsic::experimental_get_vector_length:
3093 return Known.
One != 0;
3104 Type *Ty = V->getType();
3109 if (
auto *FVTy = dyn_cast<FixedVectorType>(Ty)) {
3111 FVTy->getNumElements() == DemandedElts.
getBitWidth() &&
3112 "DemandedElt width should equal the fixed vector number of elements");
3115 "DemandedElt width should be 1 for scalars");
3119 if (
auto *
C = dyn_cast<Constant>(V)) {
3120 if (
C->isNullValue())
3122 if (isa<ConstantInt>(
C))
3128 if (
auto *VecTy = dyn_cast<FixedVectorType>(Ty)) {
3129 for (
unsigned i = 0, e = VecTy->getNumElements(); i != e; ++i) {
3130 if (!DemandedElts[i])
3132 Constant *Elt =
C->getAggregateElement(i);
3135 if (!isa<PoisonValue>(Elt) && !isa<ConstantInt>(Elt))
3142 if (
auto *CPA = dyn_cast<ConstantPtrAuth>(V))
3148 if (
const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
3149 if (!GV->isAbsoluteSymbolRef() && !GV->hasExternalWeakLinkage() &&
3150 GV->getType()->getAddressSpace() == 0)
3155 if (!isa<ConstantExpr>(V))
3159 if (
const auto *
A = dyn_cast<Argument>(V))
3160 if (std::optional<ConstantRange>
Range =
A->getRange()) {
3175 if (
PointerType *PtrTy = dyn_cast<PointerType>(Ty)) {
3178 if (
const Argument *
A = dyn_cast<Argument>(V)) {
3179 if (((
A->hasPassPointeeByValueCopyAttr() &&
3181 A->hasNonNullAttr()))
3186 if (
const auto *
I = dyn_cast<Operator>(V))
3190 if (!isa<Constant>(V) &&
3199 auto *FVTy = dyn_cast<FixedVectorType>(V->getType());
3200 APInt DemandedElts =
3202 return ::isKnownNonZero(V, DemandedElts, Q,
Depth);
3211static std::optional<std::pair<Value*, Value*>>
3215 return std::nullopt;
3224 case Instruction::Or:
3225 if (!cast<PossiblyDisjointInst>(Op1)->isDisjoint() ||
3226 !cast<PossiblyDisjointInst>(Op2)->isDisjoint())
3229 case Instruction::Xor:
3230 case Instruction::Add: {
3238 case Instruction::Sub:
3244 case Instruction::Mul: {
3248 auto *OBO1 = cast<OverflowingBinaryOperator>(Op1);
3249 auto *OBO2 = cast<OverflowingBinaryOperator>(Op2);
3250 if ((!OBO1->hasNoUnsignedWrap() || !OBO2->hasNoUnsignedWrap()) &&
3251 (!OBO1->hasNoSignedWrap() || !OBO2->hasNoSignedWrap()))
3257 !cast<ConstantInt>(Op1->
getOperand(1))->isZero())
3261 case Instruction::Shl: {
3264 auto *OBO1 = cast<OverflowingBinaryOperator>(Op1);
3265 auto *OBO2 = cast<OverflowingBinaryOperator>(Op2);
3266 if ((!OBO1->hasNoUnsignedWrap() || !OBO2->hasNoUnsignedWrap()) &&
3267 (!OBO1->hasNoSignedWrap() || !OBO2->hasNoSignedWrap()))
3274 case Instruction::AShr:
3275 case Instruction::LShr: {
3276 auto *PEO1 = cast<PossiblyExactOperator>(Op1);
3277 auto *PEO2 = cast<PossiblyExactOperator>(Op2);
3278 if (!PEO1->isExact() || !PEO2->isExact())
3285 case Instruction::SExt:
3286 case Instruction::ZExt:
3290 case Instruction::PHI: {
3291 const PHINode *PN1 = cast<PHINode>(Op1);
3292 const PHINode *PN2 = cast<PHINode>(Op2);
3298 Value *Start1 =
nullptr, *Step1 =
nullptr;
3300 Value *Start2 =
nullptr, *Step2 =
nullptr;
3307 cast<Operator>(BO2));
3316 if (Values->first != PN1 || Values->second != PN2)
3319 return std::make_pair(Start1, Start2);
3322 return std::nullopt;
3336 case Instruction::Or:
3337 if (!cast<PossiblyDisjointInst>(V1)->isDisjoint())
3340 case Instruction::Xor:
3341 case Instruction::Add:
3358 if (
auto *OBO = dyn_cast<OverflowingBinaryOperator>(V2)) {
3361 (OBO->hasNoUnsignedWrap() || OBO->hasNoSignedWrap()) &&
3371 if (
auto *OBO = dyn_cast<OverflowingBinaryOperator>(V2)) {
3374 (OBO->hasNoUnsignedWrap() || OBO->hasNoSignedWrap()) &&
3387 bool UsedFullRecursion =
false;
3389 if (!VisitedBBs.
insert(IncomBB).second)
3393 const APInt *C1, *C2;
3398 if (UsedFullRecursion)
3402 RecQ.
CxtI = IncomBB->getTerminator();
3405 UsedFullRecursion =
true;
3412 const SelectInst *SI1 = dyn_cast<SelectInst>(V1);
3416 if (
const SelectInst *SI2 = dyn_cast<SelectInst>(V2)) {
3418 const Value *Cond2 = SI2->getCondition();
3436 if (!
A->getType()->isPointerTy() || !
B->getType()->isPointerTy())
3439 auto *GEPA = dyn_cast<GEPOperator>(
A);
3440 if (!GEPA || GEPA->getNumIndices() != 1 || !isa<Constant>(GEPA->idx_begin()))
3444 auto *PN = dyn_cast<PHINode>(GEPA->getPointerOperand());
3445 if (!PN || PN->getNumIncomingValues() != 2)
3450 Value *Start =
nullptr;
3452 if (PN->getIncomingValue(0) == Step)
3453 Start = PN->getIncomingValue(1);
3454 else if (PN->getIncomingValue(1) == Step)
3455 Start = PN->getIncomingValue(0);
3466 APInt StartOffset(IndexWidth, 0);
3467 Start = Start->stripAndAccumulateInBoundsConstantOffsets(Q.
DL, StartOffset);
3468 APInt StepOffset(IndexWidth, 0);
3474 APInt OffsetB(IndexWidth, 0);
3475 B =
B->stripAndAccumulateInBoundsConstantOffsets(Q.
DL, OffsetB);
3476 return Start ==
B &&
3486 if (V1->
getType() != V2->getType())
3496 auto *O1 = dyn_cast<Operator>(V1);
3497 auto *O2 = dyn_cast<Operator>(V2);
3498 if (O1 && O2 && O1->getOpcode() == O2->getOpcode()) {
3502 if (
const PHINode *PN1 = dyn_cast<PHINode>(V1)) {
3503 const PHINode *PN2 = cast<PHINode>(V2);
3556 "Input should be a Select!");
3566 const Value *LHS2 =
nullptr, *RHS2 =
nullptr;
3578 return CLow->
sle(*CHigh);
3583 const APInt *&CHigh) {
3584 assert((
II->getIntrinsicID() == Intrinsic::smin ||
3585 II->getIntrinsicID() == Intrinsic::smax) &&
"Must be smin/smax");
3588 auto *InnerII = dyn_cast<IntrinsicInst>(
II->getArgOperand(0));
3589 if (!InnerII || InnerII->getIntrinsicID() != InverseID ||
3594 if (
II->getIntrinsicID() == Intrinsic::smin)
3596 return CLow->
sle(*CHigh);
3604 const APInt &DemandedElts,
3606 const auto *CV = dyn_cast<Constant>(V);
3607 if (!CV || !isa<FixedVectorType>(CV->getType()))
3610 unsigned MinSignBits = TyBits;
3611 unsigned NumElts = cast<FixedVectorType>(CV->getType())->getNumElements();
3612 for (
unsigned i = 0; i != NumElts; ++i) {
3613 if (!DemandedElts[i])
3616 auto *Elt = dyn_cast_or_null<ConstantInt>(CV->getAggregateElement(i));
3620 MinSignBits = std::min(MinSignBits, Elt->getValue().getNumSignBits());
3627 const APInt &DemandedElts,
3633 assert(Result > 0 &&
"At least one sign bit needs to be present!");
3645 const APInt &DemandedElts,
3647 Type *Ty = V->getType();
3651 if (
auto *FVTy = dyn_cast<FixedVectorType>(Ty)) {
3653 FVTy->getNumElements() == DemandedElts.
getBitWidth() &&
3654 "DemandedElt width should equal the fixed vector number of elements");
3657 "DemandedElt width should be 1 for scalars");
3671 unsigned FirstAnswer = 1;
3679 if (
auto *U = dyn_cast<Operator>(V)) {
3682 case Instruction::SExt:
3683 Tmp = TyBits - U->getOperand(0)->getType()->getScalarSizeInBits();
3686 case Instruction::SDiv: {
3687 const APInt *Denominator;
3699 return std::min(TyBits, NumBits + Denominator->
logBase2());
3704 case Instruction::SRem: {
3707 const APInt *Denominator;
3728 unsigned ResBits = TyBits - Denominator->
ceilLogBase2();
3729 Tmp = std::max(Tmp, ResBits);
3735 case Instruction::AShr: {
3740 if (ShAmt->
uge(TyBits))
3743 Tmp += ShAmtLimited;
3744 if (Tmp > TyBits) Tmp = TyBits;
3748 case Instruction::Shl: {
3753 if (ShAmt->
uge(TyBits) ||
3754 ShAmt->
uge(Tmp))
break;
3760 case Instruction::And:
3761 case Instruction::Or:
3762 case Instruction::Xor:
3767 FirstAnswer = std::min(Tmp, Tmp2);
3774 case Instruction::Select: {
3778 const APInt *CLow, *CHigh;
3783 if (Tmp == 1)
break;
3785 return std::min(Tmp, Tmp2);
3788 case Instruction::Add:
3792 if (Tmp == 1)
break;
3795 if (
const auto *CRHS = dyn_cast<Constant>(U->getOperand(1)))
3796 if (CRHS->isAllOnesValue()) {
3802 if ((Known.
Zero | 1).isAllOnes())
3812 if (Tmp2 == 1)
break;
3813 return std::min(Tmp, Tmp2) - 1;
3815 case Instruction::Sub:
3817 if (Tmp2 == 1)
break;
3820 if (
const auto *CLHS = dyn_cast<Constant>(U->getOperand(0)))
3821 if (CLHS->isNullValue()) {
3826 if ((Known.
Zero | 1).isAllOnes())
3841 if (Tmp == 1)
break;
3842 return std::min(Tmp, Tmp2) - 1;
3844 case Instruction::Mul: {
3848 if (SignBitsOp0 == 1)
break;
3850 if (SignBitsOp1 == 1)
break;
3851 unsigned OutValidBits =
3852 (TyBits - SignBitsOp0 + 1) + (TyBits - SignBitsOp1 + 1);
3853 return OutValidBits > TyBits ? 1 : TyBits - OutValidBits + 1;
3856 case Instruction::PHI: {
3857 const PHINode *PN = cast<PHINode>(U);
3860 if (NumIncomingValues > 4)
break;
3862 if (NumIncomingValues == 0)
break;
3868 for (
unsigned i = 0, e = NumIncomingValues; i != e; ++i) {
3869 if (Tmp == 1)
return Tmp;
3877 case Instruction::Trunc: {
3882 unsigned OperandTyBits = U->getOperand(0)->getType()->getScalarSizeInBits();
3883 if (Tmp > (OperandTyBits - TyBits))
3884 return Tmp - (OperandTyBits - TyBits);
3889 case Instruction::ExtractElement:
3896 case Instruction::ShuffleVector: {
3899 auto *Shuf = dyn_cast<ShuffleVectorInst>(U);
3904 APInt DemandedLHS, DemandedRHS;
3909 Tmp = std::numeric_limits<unsigned>::max();
3910 if (!!DemandedLHS) {
3911 const Value *
LHS = Shuf->getOperand(0);
3918 if (!!DemandedRHS) {
3919 const Value *
RHS = Shuf->getOperand(1);
3921 Tmp = std::min(Tmp, Tmp2);
3927 assert(Tmp <= TyBits &&
"Failed to determine minimum sign bits");
3930 case Instruction::Call: {
3931 if (
const auto *
II = dyn_cast<IntrinsicInst>(U)) {
3932 switch (
II->getIntrinsicID()) {
3934 case Intrinsic::abs:
3936 if (Tmp == 1)
break;
3940 case Intrinsic::smin:
3941 case Intrinsic::smax: {
3942 const APInt *CLow, *CHigh;
3957 if (
unsigned VecSignBits =
3975 if (
F->isIntrinsic())
3976 return F->getIntrinsicID();
3982 if (
F->hasLocalLinkage() || !TLI || !TLI->
getLibFunc(CB, Func) ||
3992 return Intrinsic::sin;
3996 return Intrinsic::cos;
4000 return Intrinsic::tan;
4004 return Intrinsic::exp;
4008 return Intrinsic::exp2;
4012 return Intrinsic::log;
4014 case LibFunc_log10f:
4015 case LibFunc_log10l:
4016 return Intrinsic::log10;
4020 return Intrinsic::log2;
4024 return Intrinsic::fabs;
4028 return Intrinsic::minnum;
4032 return Intrinsic::maxnum;
4033 case LibFunc_copysign:
4034 case LibFunc_copysignf:
4035 case LibFunc_copysignl:
4036 return Intrinsic::copysign;
4038 case LibFunc_floorf:
4039 case LibFunc_floorl:
4040 return Intrinsic::floor;
4044 return Intrinsic::ceil;
4046 case LibFunc_truncf:
4047 case LibFunc_truncl:
4048 return Intrinsic::trunc;
4052 return Intrinsic::rint;
4053 case LibFunc_nearbyint:
4054 case LibFunc_nearbyintf:
4055 case LibFunc_nearbyintl:
4056 return Intrinsic::nearbyint;
4058 case LibFunc_roundf:
4059 case LibFunc_roundl:
4060 return Intrinsic::round;
4061 case LibFunc_roundeven:
4062 case LibFunc_roundevenf:
4063 case LibFunc_roundevenl:
4064 return Intrinsic::roundeven;
4068 return Intrinsic::pow;
4072 return Intrinsic::sqrt;
4120 switch (Mode.Input) {
4140 if (!Src.isKnownNeverPosZero() && !Src.isKnownNeverNegZero())
4144 if (Src.isKnownNeverSubnormal())
4174 bool &TrueIfSigned) {
4177 TrueIfSigned =
true;
4178 return RHS.isZero();
4180 TrueIfSigned =
true;
4181 return RHS.isAllOnes();
4183 TrueIfSigned =
false;
4184 return RHS.isAllOnes();
4186 TrueIfSigned =
false;
4187 return RHS.isZero();
4190 TrueIfSigned =
true;
4191 return RHS.isMaxSignedValue();
4194 TrueIfSigned =
true;
4195 return RHS.isMinSignedValue();
4198 TrueIfSigned =
false;
4199 return RHS.isMinSignedValue();
4202 TrueIfSigned =
false;
4203 return RHS.isMaxSignedValue();
4214 bool LookThroughSrc) {
4222std::pair<Value *, FPClassTest>
4224 const APFloat *ConstRHS,
bool LookThroughSrc) {
4226 auto [Src, ClassIfTrue, ClassIfFalse] =
4228 if (Src && ClassIfTrue == ~ClassIfFalse)
4229 return {Src, ClassIfTrue};
4240std::tuple<Value *, FPClassTest, FPClassTest>
4254 const bool IsNegativeRHS = (RHSClass &
fcNegative) == RHSClass;
4255 const bool IsPositiveRHS = (RHSClass &
fcPositive) == RHSClass;
4256 const bool IsNaN = (RHSClass & ~fcNan) ==
fcNone;
4276 const bool IsZero = (OrigClass &
fcZero) == OrigClass;
4323 const bool IsDenormalRHS = (OrigClass &
fcSubnormal) == OrigClass;
4325 const bool IsInf = (OrigClass &
fcInf) == OrigClass;
4343 if (IsNegativeRHS) {
4366 if (IsNegativeRHS) {
4367 Mask = ~fcNegInf & ~fcNan;
4371 Mask = ~fcPosInf & ~fcNan;
4380 if (IsNegativeRHS) {
4400 if (IsNegativeRHS) {
4420 if (IsNegativeRHS) {
4435 if (IsNegativeRHS) {
4463 return {Src, Class, ~fcNan};
4467 return {Src, ~fcNan, RHSClass |
fcNan};
4476 "should have been recognized as an exact class test");
4478 if (IsNegativeRHS) {
4488 return {Src, ~fcNan,
fcNan};
4497 return {Src,
fcNan, ~fcNan};
4516 return {Src, ClassesGE, ~ClassesGE | RHSClass};
4519 return {Src, ClassesGE |
fcNan, ~(ClassesGE |
fcNan) | RHSClass};
4522 return {Src, ClassesLE, ~ClassesLE | RHSClass};
4525 return {Src, ClassesLE |
fcNan, ~(ClassesLE |
fcNan) | RHSClass};
4529 }
else if (IsPositiveRHS) {
4545 return {Src, ClassesGE, ~ClassesGE | RHSClass};
4548 return {Src, ClassesGE |
fcNan, ~(ClassesGE |
fcNan) | RHSClass};
4551 return {Src, ClassesLE, ~ClassesLE | RHSClass};
4554 return {Src, ClassesLE |
fcNan, ~(ClassesLE |
fcNan) | RHSClass};
4563std::tuple<Value *, FPClassTest, FPClassTest>
4565 const APFloat &ConstRHS,
bool LookThroughSrc) {
4613std::tuple<Value *, FPClassTest, FPClassTest>
4615 Value *RHS,
bool LookThroughSrc) {
4637 KnownFromContext.
knownNot(~(CondIsTrue ? MaskIfTrue : MaskIfFalse));
4638 }
else if (
match(
Cond, m_Intrinsic<Intrinsic::is_fpclass>(
4641 KnownFromContext.
knownNot(CondIsTrue ? ~Mask : Mask);
4647 if (TrueIfSigned == CondIsTrue)
4659 return KnownFromContext;
4679 return KnownFromContext;
4689 "Got assumption for the wrong function!");
4690 assert(
I->getCalledFunction()->getIntrinsicID() == Intrinsic::assume &&
4691 "must be an assume intrinsic");
4697 Q.
CxtI, KnownFromContext);
4700 return KnownFromContext;
4710 auto *FVTy = dyn_cast<FixedVectorType>(V->getType());
4711 APInt DemandedElts =
4717 const APInt &DemandedElts,
4721 if ((InterestedClasses &
4727 KnownSrc,
Depth + 1, Q);
4742 assert(Known.
isUnknown() &&
"should not be called with known information");
4744 if (!DemandedElts) {
4752 if (
auto *CFP = dyn_cast<ConstantFP>(V)) {
4754 Known.
SignBit = CFP->isNegative();
4758 if (isa<ConstantAggregateZero>(V)) {
4764 if (isa<PoisonValue>(V)) {
4771 auto *VFVTy = dyn_cast<FixedVectorType>(V->getType());
4772 const Constant *CV = dyn_cast<Constant>(V);
4775 bool SignBitAllZero =
true;
4776 bool SignBitAllOne =
true;
4779 unsigned NumElts = VFVTy->getNumElements();
4780 for (
unsigned i = 0; i != NumElts; ++i) {
4781 if (!DemandedElts[i])
4789 if (isa<PoisonValue>(Elt))
4791 auto *CElt = dyn_cast<ConstantFP>(Elt);
4797 const APFloat &
C = CElt->getValueAPF();
4800 SignBitAllZero =
false;
4802 SignBitAllOne =
false;
4804 if (SignBitAllOne != SignBitAllZero)
4805 Known.
SignBit = SignBitAllOne;
4810 if (
const auto *CB = dyn_cast<CallBase>(V))
4811 KnownNotFromFlags |= CB->getRetNoFPClass();
4812 else if (
const auto *Arg = dyn_cast<Argument>(V))
4813 KnownNotFromFlags |= Arg->getNoFPClass();
4817 if (FPOp->hasNoNaNs())
4818 KnownNotFromFlags |=
fcNan;
4819 if (FPOp->hasNoInfs())
4820 KnownNotFromFlags |=
fcInf;
4824 KnownNotFromFlags |= ~AssumedClasses.KnownFPClasses;
4828 InterestedClasses &= ~KnownNotFromFlags;
4833 if (*AssumedClasses.SignBit)
4834 Known.signBitMustBeOne();
4836 Known.signBitMustBeZero();
4847 const unsigned Opc =
Op->getOpcode();
4849 case Instruction::FNeg: {
4851 Known,
Depth + 1, Q);
4855 case Instruction::Select: {
4863 Value *TestedValue =
nullptr;
4867 const Function *
F = cast<Instruction>(
Op)->getFunction();
4869 Value *CmpLHS, *CmpRHS;
4876 bool LookThroughFAbsFNeg = CmpLHS !=
LHS && CmpLHS !=
RHS;
4877 std::tie(TestedValue, MaskIfTrue, MaskIfFalse) =
4880 m_Intrinsic<Intrinsic::is_fpclass>(
4883 MaskIfTrue = TestedMask;
4884 MaskIfFalse = ~TestedMask;
4887 if (TestedValue ==
LHS) {
4889 FilterLHS = MaskIfTrue;
4890 }
else if (TestedValue ==
RHS) {
4892 FilterRHS = MaskIfFalse;
4901 Known2,
Depth + 1, Q);
4907 case Instruction::Call: {
4911 case Intrinsic::fabs: {
4916 InterestedClasses, Known,
Depth + 1, Q);
4922 case Intrinsic::copysign: {
4926 Known,
Depth + 1, Q);
4928 KnownSign,
Depth + 1, Q);
4932 case Intrinsic::fma:
4933 case Intrinsic::fmuladd: {
4937 if (
II->getArgOperand(0) !=
II->getArgOperand(1))
4946 KnownAddend,
Depth + 1, Q);
4952 case Intrinsic::sqrt:
4953 case Intrinsic::experimental_constrained_sqrt: {
4956 if (InterestedClasses &
fcNan)
4960 KnownSrc,
Depth + 1, Q);
4983 case Intrinsic::sin:
4984 case Intrinsic::cos: {
4988 KnownSrc,
Depth + 1, Q);
4994 case Intrinsic::maxnum:
4995 case Intrinsic::minnum:
4996 case Intrinsic::minimum:
4997 case Intrinsic::maximum: {
5000 KnownLHS,
Depth + 1, Q);
5002 KnownRHS,
Depth + 1, Q);
5005 Known = KnownLHS | KnownRHS;
5008 if (NeverNaN && (IID == Intrinsic::minnum || IID == Intrinsic::maxnum))
5011 if (IID == Intrinsic::maxnum) {
5019 }
else if (IID == Intrinsic::maximum) {
5025 }
else if (IID == Intrinsic::minnum) {
5055 II->getType()->getScalarType()->getFltSemantics());
5067 }
else if ((IID == Intrinsic::maximum || IID == Intrinsic::minimum) ||
5072 if ((IID == Intrinsic::maximum || IID == Intrinsic::maxnum) &&
5075 else if ((IID == Intrinsic::minimum || IID == Intrinsic::minnum) &&
5082 case Intrinsic::canonicalize: {
5085 KnownSrc,
Depth + 1, Q);
5109 II->getType()->getScalarType()->getFltSemantics();
5129 case Intrinsic::vector_reduce_fmax:
5130 case Intrinsic::vector_reduce_fmin:
5131 case Intrinsic::vector_reduce_fmaximum:
5132 case Intrinsic::vector_reduce_fminimum: {
5136 InterestedClasses,
Depth + 1, Q);
5142 case Intrinsic::trunc:
5143 case Intrinsic::floor:
5144 case Intrinsic::ceil:
5145 case Intrinsic::rint:
5146 case Intrinsic::nearbyint:
5147 case Intrinsic::round:
5148 case Intrinsic::roundeven: {
5156 KnownSrc,
Depth + 1, Q);
5165 if (IID == Intrinsic::trunc || !V->getType()->isMultiUnitFPType()) {
5180 case Intrinsic::exp:
5181 case Intrinsic::exp2:
5182 case Intrinsic::exp10: {
5189 KnownSrc,
Depth + 1, Q);
5197 case Intrinsic::fptrunc_round: {
5202 case Intrinsic::log:
5203 case Intrinsic::log10:
5204 case Intrinsic::log2:
5205 case Intrinsic::experimental_constrained_log:
5206 case Intrinsic::experimental_constrained_log10:
5207 case Intrinsic::experimental_constrained_log2: {
5223 KnownSrc,
Depth + 1, Q);
5237 case Intrinsic::powi: {
5241 const Value *Exp =
II->getArgOperand(1);
5242 Type *ExpTy = Exp->getType();
5246 ExponentKnownBits,
Depth + 1, Q);
5248 if (ExponentKnownBits.
Zero[0]) {
5263 KnownSrc,
Depth + 1, Q);
5268 case Intrinsic::ldexp: {
5271 KnownSrc,
Depth + 1, Q);
5287 if ((InterestedClasses & ExpInfoMask) ==
fcNone)
5293 II->getType()->getScalarType()->getFltSemantics();
5295 const Value *ExpArg =
II->getArgOperand(1);
5299 const int MantissaBits = Precision - 1;
5305 if (ConstVal && ConstVal->
isZero()) {
5328 case Intrinsic::arithmetic_fence: {
5330 Known,
Depth + 1, Q);
5333 case Intrinsic::experimental_constrained_sitofp:
5334 case Intrinsic::experimental_constrained_uitofp:
5344 if (IID == Intrinsic::experimental_constrained_uitofp)
5355 case Instruction::FAdd:
5356 case Instruction::FSub: {
5359 Op->getOpcode() == Instruction::FAdd &&
5361 bool WantNaN = (InterestedClasses &
fcNan) !=
fcNone;
5364 if (!WantNaN && !WantNegative && !WantNegZero)
5370 if (InterestedClasses &
fcNan)
5371 InterestedSrcs |=
fcInf;
5373 KnownRHS,
Depth + 1, Q);
5377 WantNegZero || Opc == Instruction::FSub) {
5382 KnownLHS,
Depth + 1, Q);
5390 const Function *
F = cast<Instruction>(
Op)->getFunction();
5392 if (
Op->getOpcode() == Instruction::FAdd) {
5420 case Instruction::FMul: {
5422 if (
Op->getOperand(0) ==
Op->getOperand(1))
5455 const Function *
F = cast<Instruction>(
Op)->getFunction();
5467 case Instruction::FDiv:
5468 case Instruction::FRem: {
5469 if (
Op->getOperand(0) ==
Op->getOperand(1)) {
5471 if (
Op->getOpcode() == Instruction::FDiv) {
5482 const bool WantNan = (InterestedClasses &
fcNan) !=
fcNone;
5484 const bool WantPositive =
5486 if (!WantNan && !WantNegative && !WantPositive)
5495 bool KnowSomethingUseful =
5498 if (KnowSomethingUseful || WantPositive) {
5504 InterestedClasses & InterestedLHS, KnownLHS,
5508 const Function *
F = cast<Instruction>(
Op)->getFunction();
5510 if (
Op->getOpcode() == Instruction::FDiv) {
5547 case Instruction::FPExt: {
5550 Known,
Depth + 1, Q);
5553 Op->getType()->getScalarType()->getFltSemantics();
5555 Op->getOperand(0)->getType()->getScalarType()->getFltSemantics();
5571 case Instruction::FPTrunc: {
5576 case Instruction::SIToFP:
5577 case Instruction::UIToFP: {
5586 if (
Op->getOpcode() == Instruction::UIToFP)
5589 if (InterestedClasses &
fcInf) {
5593 int IntSize =
Op->getOperand(0)->getType()->getScalarSizeInBits();
5594 if (
Op->getOpcode() == Instruction::SIToFP)
5599 Type *FPTy =
Op->getType()->getScalarType();
5606 case Instruction::ExtractElement: {
5609 const Value *Vec =
Op->getOperand(0);
5611 auto *CIdx = dyn_cast<ConstantInt>(
Idx);
5613 if (
auto *VecTy = dyn_cast<FixedVectorType>(Vec->
getType())) {
5614 unsigned NumElts = VecTy->getNumElements();
5616 if (CIdx && CIdx->getValue().ult(NumElts))
5624 case Instruction::InsertElement: {
5625 if (isa<ScalableVectorType>(
Op->getType()))
5628 const Value *Vec =
Op->getOperand(0);
5629 const Value *Elt =
Op->getOperand(1);
5630 auto *CIdx = dyn_cast<ConstantInt>(
Op->getOperand(2));
5632 APInt DemandedVecElts = DemandedElts;
5633 bool NeedsElt =
true;
5635 if (CIdx && CIdx->getValue().ult(NumElts)) {
5636 DemandedVecElts.
clearBit(CIdx->getZExtValue());
5637 NeedsElt = DemandedElts[CIdx->getZExtValue()];
5651 if (!DemandedVecElts.
isZero()) {
5660 case Instruction::ShuffleVector: {
5663 APInt DemandedLHS, DemandedRHS;
5664 auto *Shuf = dyn_cast<ShuffleVectorInst>(
Op);
5668 if (!!DemandedLHS) {
5669 const Value *
LHS = Shuf->getOperand(0);
5680 if (!!DemandedRHS) {
5682 const Value *
RHS = Shuf->getOperand(1);
5690 case Instruction::ExtractValue: {
5694 if (isa<StructType>(Src->getType()) && Indices.
size() == 1 &&
5696 if (
const auto *
II = dyn_cast<IntrinsicInst>(Src)) {
5697 switch (
II->getIntrinsicID()) {
5698 case Intrinsic::frexp: {
5703 InterestedClasses, KnownSrc,
Depth + 1, Q);
5705 const Function *
F = cast<Instruction>(
Op)->getFunction();
5738 case Instruction::PHI: {
5741 if (
P->getNumIncomingValues() == 0)
5748 if (
Depth < PhiRecursionLimit) {
5750 if (isa_and_nonnull<UndefValue>(
P->hasConstantValue()))
5755 for (
const Use &U :
P->operands()) {
5756 Value *IncValue = U.get();
5766 IncValue, DemandedElts, InterestedClasses, KnownSrc,
5790 const APInt &DemandedElts,
5797 return KnownClasses;
5812 if (V->getType()->isIntegerTy(8))
5819 if (isa<UndefValue>(V))
5823 if (
DL.getTypeStoreSize(V->getType()).isZero())
5838 if (
C->isNullValue())
5845 if (CFP->getType()->isHalfTy())
5847 else if (CFP->getType()->isFloatTy())
5849 else if (CFP->getType()->isDoubleTy())
5858 if (CI->getBitWidth() % 8 == 0) {
5859 assert(CI->getBitWidth() > 8 &&
"8 bits should be handled above!");
5860 if (!CI->getValue().isSplat(8))
5862 return ConstantInt::get(Ctx, CI->getValue().trunc(8));
5866 if (
auto *CE = dyn_cast<ConstantExpr>(
C)) {
5867 if (CE->getOpcode() == Instruction::IntToPtr) {
5868 if (
auto *PtrTy = dyn_cast<PointerType>(CE->getType())) {
5869 unsigned BitWidth =
DL.getPointerSizeInBits(PtrTy->getAddressSpace());
5882 if (
LHS == UndefInt8)
5884 if (
RHS == UndefInt8)
5890 Value *Val = UndefInt8;
5891 for (
unsigned I = 0, E = CA->getNumElements();
I != E; ++
I)
5897 if (isa<ConstantAggregate>(
C)) {
5898 Value *Val = UndefInt8;
5899 for (
unsigned I = 0, E =
C->getNumOperands();
I != E; ++
I)
5919 StructType *STy = dyn_cast<StructType>(IndexedType);
5933 while (PrevTo != OrigTo) {
5980 unsigned IdxSkip = Idxs.
size();
5993 std::optional<BasicBlock::iterator> InsertBefore) {
5996 if (idx_range.
empty())
5999 assert((V->getType()->isStructTy() || V->getType()->isArrayTy()) &&
6000 "Not looking at a struct or array?");
6002 "Invalid indices for type?");
6004 if (
Constant *
C = dyn_cast<Constant>(V)) {
6005 C =
C->getAggregateElement(idx_range[0]);
6006 if (!
C)
return nullptr;
6013 const unsigned *req_idx = idx_range.
begin();
6014 for (
const unsigned *i =
I->idx_begin(), *e =
I->idx_end();
6015 i != e; ++i, ++req_idx) {
6016 if (req_idx == idx_range.
end()) {
6046 ArrayRef(req_idx, idx_range.
end()), InsertBefore);
6055 unsigned size =
I->getNumIndices() + idx_range.
size();
6060 Idxs.
append(
I->idx_begin(),
I->idx_end());
6066 &&
"Number of indices added not correct?");
6076 unsigned CharSize) {
6078 if (
GEP->getNumOperands() != 3)
6083 ArrayType *AT = dyn_cast<ArrayType>(
GEP->getSourceElementType());
6089 const ConstantInt *FirstIdx = dyn_cast<ConstantInt>(
GEP->getOperand(1));
6090 if (!FirstIdx || !FirstIdx->
isZero())
6104 assert(V &&
"V should not be null.");
6105 assert((ElementSize % 8) == 0 &&
6106 "ElementSize expected to be a multiple of the size of a byte.");
6107 unsigned ElementSizeInBytes = ElementSize / 8;
6119 APInt Off(
DL.getIndexTypeSizeInBits(V->getType()), 0);
6121 if (GV != V->stripAndAccumulateConstantOffsets(
DL, Off,
6126 uint64_t StartIdx = Off.getLimitedValue();
6133 if ((StartIdx % ElementSizeInBytes) != 0)
6136 Offset += StartIdx / ElementSizeInBytes;
6142 uint64_t SizeInBytes =
DL.getTypeStoreSize(GVTy).getFixedValue();
6145 Slice.
Array =
nullptr;
6156 if (
auto *ArrayInit = dyn_cast<ConstantDataArray>(
Init)) {
6157 Type *InitElTy = ArrayInit->getElementType();
6162 ArrayTy = ArrayInit->getType();
6167 if (ElementSize != 8)
6178 Array = dyn_cast<ConstantDataArray>(
Init);
6179 ArrayTy = dyn_cast<ArrayType>(
Init->getType());
6186 Slice.
Array = Array;
6202 if (Slice.
Array ==
nullptr) {
6225 Str = Str.substr(Slice.
Offset);
6231 Str = Str.substr(0, Str.find(
'\0'));
6244 unsigned CharSize) {
6246 V = V->stripPointerCasts();
6250 if (
const PHINode *PN = dyn_cast<PHINode>(V)) {
6251 if (!PHIs.
insert(PN).second)
6256 for (
Value *IncValue : PN->incoming_values()) {
6258 if (Len == 0)
return 0;
6260 if (Len == ~0ULL)
continue;
6262 if (Len != LenSoFar && LenSoFar != ~0ULL)
6272 if (
const SelectInst *SI = dyn_cast<SelectInst>(V)) {
6274 if (Len1 == 0)
return 0;
6276 if (Len2 == 0)
return 0;
6277 if (Len1 == ~0ULL)
return Len2;
6278 if (Len2 == ~0ULL)
return Len1;
6279 if (Len1 != Len2)
return 0;
6288 if (Slice.
Array ==
nullptr)
6296 unsigned NullIndex = 0;
6297 for (
unsigned E = Slice.
Length; NullIndex < E; ++NullIndex) {
6302 return NullIndex + 1;
6308 if (!V->getType()->isPointerTy())
6315 return Len == ~0ULL ? 1 : Len;
6320 bool MustPreserveNullness) {
6322 "getArgumentAliasingToReturnedPointer only works on nonnull calls");
6323 if (
const Value *RV = Call->getReturnedArgOperand())
6327 Call, MustPreserveNullness))
6328 return Call->getArgOperand(0);
6333 const CallBase *Call,
bool MustPreserveNullness) {
6334 switch (Call->getIntrinsicID()) {
6335 case Intrinsic::launder_invariant_group:
6336 case Intrinsic::strip_invariant_group:
6337 case Intrinsic::aarch64_irg:
6338 case Intrinsic::aarch64_tagp:
6348 case Intrinsic::amdgcn_make_buffer_rsrc:
6350 case Intrinsic::ptrmask:
6351 return !MustPreserveNullness;
6352 case Intrinsic::threadlocal_address:
6355 return !Call->getParent()->getParent()->isPresplitCoroutine();
6372 if (!PrevValue || LI->
getLoopFor(PrevValue->getParent()) != L)
6374 if (!PrevValue || LI->
getLoopFor(PrevValue->getParent()) != L)
6382 if (
auto *Load = dyn_cast<LoadInst>(PrevValue))
6383 if (!L->isLoopInvariant(Load->getPointerOperand()))
6389 if (!V->getType()->isPointerTy())
6391 for (
unsigned Count = 0; MaxLookup == 0 || Count < MaxLookup; ++Count) {
6392 if (
auto *
GEP = dyn_cast<GEPOperator>(V)) {
6393 V =
GEP->getPointerOperand();
6396 V = cast<Operator>(V)->getOperand(0);
6397 if (!V->getType()->isPointerTy())
6399 }
else if (
auto *GA = dyn_cast<GlobalAlias>(V)) {
6400 if (GA->isInterposable())
6402 V = GA->getAliasee();
6404 if (
auto *
PHI = dyn_cast<PHINode>(V)) {
6406 if (
PHI->getNumIncomingValues() == 1) {
6407 V =
PHI->getIncomingValue(0);
6410 }
else if (
auto *Call = dyn_cast<CallBase>(V)) {
6428 assert(V->getType()->isPointerTy() &&
"Unexpected operand type!");
6435 LoopInfo *LI,
unsigned MaxLookup) {
6443 if (!Visited.
insert(
P).second)
6446 if (
auto *SI = dyn_cast<SelectInst>(
P)) {
6448 Worklist.
push_back(SI->getFalseValue());
6452 if (
auto *PN = dyn_cast<PHINode>(
P)) {
6472 }
while (!Worklist.
empty());
6479 if (
const Operator *U = dyn_cast<Operator>(V)) {
6482 if (U->getOpcode() == Instruction::PtrToInt)
6483 return U->getOperand(0);
6490 if (U->getOpcode() != Instruction::Add ||
6491 (!isa<ConstantInt>(U->getOperand(1)) &&
6493 !isa<PHINode>(U->getOperand(1))))
6495 V = U->getOperand(0);
6499 assert(V->getType()->isIntegerTy() &&
"Unexpected operand type!");
6516 for (
const Value *V : Objs) {
6517 if (!Visited.
insert(V).second)
6522 if (O->getType()->isPointerTy()) {
6535 }
while (!Working.
empty());
6544 auto AddWork = [&](
Value *V) {
6545 if (Visited.
insert(V).second)
6554 if (
AllocaInst *AI = dyn_cast<AllocaInst>(V)) {
6555 if (Result && Result != AI)
6558 }
else if (
CastInst *CI = dyn_cast<CastInst>(V)) {
6559 AddWork(CI->getOperand(0));
6560 }
else if (
PHINode *PN = dyn_cast<PHINode>(V)) {
6561 for (
Value *IncValue : PN->incoming_values())
6563 }
else if (
auto *SI = dyn_cast<SelectInst>(V)) {
6564 AddWork(SI->getTrueValue());
6565 AddWork(SI->getFalseValue());
6567 if (OffsetZero && !
GEP->hasAllZeroIndices())
6569 AddWork(
GEP->getPointerOperand());
6570 }
else if (
CallBase *CB = dyn_cast<CallBase>(V)) {
6571 Value *Returned = CB->getReturnedArgOperand();
6579 }
while (!Worklist.
empty());
6585 const Value *V,
bool AllowLifetime,
bool AllowDroppable) {
6586 for (
const User *U : V->users()) {
6591 if (AllowLifetime &&
II->isLifetimeStartOrEnd())
6594 if (AllowDroppable &&
II->isDroppable())
6616 return F.hasFnAttribute(Attribute::SanitizeThread) ||
6618 F.hasFnAttribute(Attribute::SanitizeAddress) ||
6619 F.hasFnAttribute(Attribute::SanitizeHWAddress);
6638 auto hasEqualReturnAndLeadingOperandTypes =
6639 [](
const Instruction *Inst,
unsigned NumLeadingOperands) {
6643 for (
unsigned ItOp = 0; ItOp < NumLeadingOperands; ++ItOp)
6649 hasEqualReturnAndLeadingOperandTypes(Inst, 2));
6651 hasEqualReturnAndLeadingOperandTypes(Inst, 1));
6658 case Instruction::UDiv:
6659 case Instruction::URem: {
6666 case Instruction::SDiv:
6667 case Instruction::SRem: {
6669 const APInt *Numerator, *Denominator;
6673 if (*Denominator == 0)
6685 case Instruction::Load: {
6686 const LoadInst *LI = dyn_cast<LoadInst>(Inst);
6696 case Instruction::Call: {
6697 auto *CI = dyn_cast<const CallInst>(Inst);
6700 const Function *Callee = CI->getCalledFunction();
6704 return Callee && Callee->isSpeculatable();
6706 case Instruction::VAArg:
6707 case Instruction::Alloca:
6708 case Instruction::Invoke:
6709 case Instruction::CallBr:
6710 case Instruction::PHI:
6711 case Instruction::Store:
6712 case Instruction::Ret:
6713 case Instruction::Br:
6714 case Instruction::IndirectBr:
6715 case Instruction::Switch:
6716 case Instruction::Unreachable:
6717 case Instruction::Fence:
6718 case Instruction::AtomicRMW:
6719 case Instruction::AtomicCmpXchg:
6720 case Instruction::LandingPad:
6721 case Instruction::Resume:
6722 case Instruction::CatchSwitch:
6723 case Instruction::CatchPad:
6724 case Instruction::CatchRet:
6725 case Instruction::CleanupPad:
6726 case Instruction::CleanupRet:
6732 if (
I.mayReadOrWriteMemory())
6845 if (
Add &&
Add->hasNoSignedWrap()) {
6885 bool LHSOrRHSKnownNonNegative =
6887 bool LHSOrRHSKnownNegative =
6889 if (LHSOrRHSKnownNonNegative || LHSOrRHSKnownNegative) {
6892 if ((AddKnown.
isNonNegative() && LHSOrRHSKnownNonNegative) ||
6893 (AddKnown.
isNegative() && LHSOrRHSKnownNegative))
6922 m_Intrinsic<Intrinsic::usub_with_overflow>(
m_Value(),
m_Value())))
6971 if (
const auto *EVI = dyn_cast<ExtractValueInst>(U)) {
6972 assert(EVI->getNumIndices() == 1 &&
"Obvious from CI's type");
6974 if (EVI->getIndices()[0] == 0)
6977 assert(EVI->getIndices()[0] == 1 &&
"Obvious from CI's type");
6979 for (
const auto *U : EVI->users())
6980 if (
const auto *
B = dyn_cast<BranchInst>(U)) {
6981 assert(
B->isConditional() &&
"How else is it using an i1?");
6992 auto AllUsesGuardedByBranch = [&](
const BranchInst *BI) {
6998 for (
const auto *Result :
Results) {
7001 if (DT.
dominates(NoWrapEdge, Result->getParent()))
7004 for (
const auto &RU : Result->uses())
7012 return llvm::any_of(GuardingBranches, AllUsesGuardedByBranch);
7017 auto *
C = dyn_cast<Constant>(ShiftAmount);
7023 if (
auto *FVTy = dyn_cast<FixedVectorType>(
C->getType())) {
7024 unsigned NumElts = FVTy->getNumElements();
7025 for (
unsigned i = 0; i < NumElts; ++i)
7026 ShiftAmounts.
push_back(
C->getAggregateElement(i));
7027 }
else if (isa<ScalableVectorType>(
C->getType()))
7033 auto *CI = dyn_cast_or_null<ConstantInt>(
C);
7034 return CI && CI->getValue().ult(
C->getType()->getIntegerBitWidth());
7047 return (
unsigned(Kind) &
unsigned(UndefPoisonKind::PoisonOnly)) != 0;
7051 return (
unsigned(Kind) &
unsigned(UndefPoisonKind::UndefOnly)) != 0;
7055 bool ConsiderFlagsAndMetadata) {
7058 Op->hasPoisonGeneratingAnnotations())
7061 unsigned Opcode =
Op->getOpcode();
7065 case Instruction::Shl:
7066 case Instruction::AShr:
7067 case Instruction::LShr:
7069 case Instruction::FPToSI:
7070 case Instruction::FPToUI:
7074 case Instruction::Call:
7075 if (
auto *
II = dyn_cast<IntrinsicInst>(
Op)) {
7076 switch (
II->getIntrinsicID()) {
7078 case Intrinsic::ctlz:
7079 case Intrinsic::cttz:
7080 case Intrinsic::abs:
7081 if (cast<ConstantInt>(
II->getArgOperand(1))->isNullValue())
7084 case Intrinsic::ctpop:
7085 case Intrinsic::bswap:
7086 case Intrinsic::bitreverse:
7087 case Intrinsic::fshl:
7088 case Intrinsic::fshr:
7089 case Intrinsic::smax:
7090 case Intrinsic::smin:
7091 case Intrinsic::umax:
7092 case Intrinsic::umin:
7093 case Intrinsic::ptrmask:
7094 case Intrinsic::fptoui_sat:
7095 case Intrinsic::fptosi_sat:
7096 case Intrinsic::sadd_with_overflow:
7097 case Intrinsic::ssub_with_overflow:
7098 case Intrinsic::smul_with_overflow:
7099 case Intrinsic::uadd_with_overflow:
7100 case Intrinsic::usub_with_overflow:
7101 case Intrinsic::umul_with_overflow:
7102 case Intrinsic::sadd_sat:
7103 case Intrinsic::uadd_sat:
7104 case Intrinsic::ssub_sat:
7105 case Intrinsic::usub_sat:
7107 case Intrinsic::sshl_sat:
7108 case Intrinsic::ushl_sat:
7111 case Intrinsic::fma:
7112 case Intrinsic::fmuladd:
7113 case Intrinsic::sqrt:
7114 case Intrinsic::powi:
7115 case Intrinsic::sin:
7116 case Intrinsic::cos:
7117 case Intrinsic::pow:
7118 case Intrinsic::log:
7119 case Intrinsic::log10:
7120 case Intrinsic::log2:
7121 case Intrinsic::exp:
7122 case Intrinsic::exp2:
7123 case Intrinsic::exp10:
7124 case Intrinsic::fabs:
7125 case Intrinsic::copysign:
7126 case Intrinsic::floor:
7127 case Intrinsic::ceil:
7128 case Intrinsic::trunc:
7129 case Intrinsic::rint:
7130 case Intrinsic::nearbyint:
7131 case Intrinsic::round:
7132 case Intrinsic::roundeven:
7133 case Intrinsic::fptrunc_round:
7134 case Intrinsic::canonicalize:
7135 case Intrinsic::arithmetic_fence:
7136 case Intrinsic::minnum:
7137 case Intrinsic::maxnum:
7138 case Intrinsic::minimum:
7139 case Intrinsic::maximum:
7140 case Intrinsic::is_fpclass:
7141 case Intrinsic::ldexp:
7142 case Intrinsic::frexp:
7144 case Intrinsic::lround:
7145 case Intrinsic::llround:
7146 case Intrinsic::lrint:
7147 case Intrinsic::llrint:
7154 case Instruction::CallBr:
7155 case Instruction::Invoke: {
7156 const auto *CB = cast<CallBase>(
Op);
7157 return !CB->hasRetAttr(Attribute::NoUndef);
7159 case Instruction::InsertElement:
7160 case Instruction::ExtractElement: {
7162 auto *VTy = cast<VectorType>(
Op->getOperand(0)->getType());
7163 unsigned IdxOp =
Op->getOpcode() == Instruction::InsertElement ? 2 : 1;
7164 auto *
Idx = dyn_cast<ConstantInt>(
Op->getOperand(IdxOp));
7167 Idx->getValue().uge(VTy->getElementCount().getKnownMinValue());
7170 case Instruction::ShuffleVector: {
7172 ? cast<ConstantExpr>(
Op)->getShuffleMask()
7173 : cast<ShuffleVectorInst>(
Op)->getShuffleMask();
7176 case Instruction::FNeg:
7177 case Instruction::PHI:
7178 case Instruction::Select:
7179 case Instruction::URem:
7180 case Instruction::SRem:
7181 case Instruction::ExtractValue:
7182 case Instruction::InsertValue:
7183 case Instruction::Freeze:
7184 case Instruction::ICmp:
7185 case Instruction::FCmp:
7186 case Instruction::FAdd:
7187 case Instruction::FSub:
7188 case Instruction::FMul:
7189 case Instruction::FDiv:
7190 case Instruction::FRem:
7192 case Instruction::GetElementPtr:
7197 const auto *CE = dyn_cast<ConstantExpr>(
Op);
7198 if (isa<CastInst>(
Op) || (CE && CE->isCast()))
7209 bool ConsiderFlagsAndMetadata) {
7210 return ::canCreateUndefOrPoison(
Op, UndefPoisonKind::UndefOrPoison,
7211 ConsiderFlagsAndMetadata);
7215 return ::canCreateUndefOrPoison(
Op, UndefPoisonKind::PoisonOnly,
7216 ConsiderFlagsAndMetadata);
7221 if (ValAssumedPoison == V)
7228 if (
const auto *
I = dyn_cast<Instruction>(V)) {
7230 return propagatesPoison(Op) &&
7231 directlyImpliesPoison(ValAssumedPoison, Op, Depth + 1);
7259 const auto *
I = dyn_cast<Instruction>(ValAssumedPoison);
7262 return impliesPoison(Op, V, Depth + 1);
7269 return ::impliesPoison(ValAssumedPoison, V, 0);
7280 if (isa<MetadataAsValue>(V))
7283 if (
const auto *
A = dyn_cast<Argument>(V)) {
7284 if (
A->hasAttribute(Attribute::NoUndef) ||
7285 A->hasAttribute(Attribute::Dereferenceable) ||
7286 A->hasAttribute(Attribute::DereferenceableOrNull))
7290 if (
auto *
C = dyn_cast<Constant>(V)) {
7291 if (isa<PoisonValue>(
C))
7294 if (isa<UndefValue>(
C))
7297 if (isa<ConstantInt>(
C) || isa<GlobalVariable>(
C) || isa<ConstantFP>(V) ||
7298 isa<ConstantPointerNull>(
C) || isa<Function>(
C))
7301 if (
C->getType()->isVectorTy() && !isa<ConstantExpr>(
C)) {
7306 return !
C->containsConstantExpression();
7318 auto *StrippedV = V->stripPointerCastsSameRepresentation();
7319 if (isa<AllocaInst>(StrippedV) || isa<GlobalVariable>(StrippedV) ||
7320 isa<Function>(StrippedV) || isa<ConstantPointerNull>(StrippedV))
7323 auto OpCheck = [&](
const Value *V) {
7327 if (
auto *Opr = dyn_cast<Operator>(V)) {
7330 if (isa<FreezeInst>(V))
7333 if (
const auto *CB = dyn_cast<CallBase>(V)) {
7334 if (CB->hasRetAttr(Attribute::NoUndef) ||
7335 CB->hasRetAttr(Attribute::Dereferenceable) ||
7336 CB->hasRetAttr(Attribute::DereferenceableOrNull))
7340 if (
const auto *PN = dyn_cast<PHINode>(V)) {
7341 unsigned Num = PN->getNumIncomingValues();
7342 bool IsWellDefined =
true;
7343 for (
unsigned i = 0; i < Num; ++i) {
7344 auto *TI = PN->getIncomingBlock(i)->getTerminator();
7346 DT,
Depth + 1, Kind)) {
7347 IsWellDefined =
false;
7355 all_of(Opr->operands(), OpCheck))
7359 if (
auto *
I = dyn_cast<LoadInst>(V))
7360 if (
I->hasMetadata(LLVMContext::MD_noundef) ||
7361 I->hasMetadata(LLVMContext::MD_dereferenceable) ||
7362 I->hasMetadata(LLVMContext::MD_dereferenceable_or_null))
7382 auto *Dominator = DNode->
getIDom();
7387 auto *TI = Dominator->
getBlock()->getTerminator();
7390 if (
auto BI = dyn_cast_or_null<BranchInst>(TI)) {
7391 if (BI->isConditional())
7392 Cond = BI->getCondition();
7393 }
else if (
auto SI = dyn_cast_or_null<SwitchInst>(TI)) {
7394 Cond = SI->getCondition();
7402 auto *Opr = cast<Operator>(
Cond);
7403 if (
any_of(Opr->operands(), [V](
const Use &U) {
7404 return V == U && propagatesPoison(U);
7410 Dominator = Dominator->getIDom();
7423 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT,
Depth,
7424 UndefPoisonKind::UndefOrPoison);
7430 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT,
Depth,
7431 UndefPoisonKind::PoisonOnly);
7437 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT,
Depth,
7438 UndefPoisonKind::UndefOnly);
7461 while (!Worklist.
empty()) {
7470 if (
I != Root && !
any_of(
I->operands(), [&KnownPoison](
const Use &U) {
7471 return KnownPoison.contains(U) && propagatesPoison(U);
7475 if (KnownPoison.
insert(
I).second)
7487 return ::computeOverflowForSignedAdd(
Add->getOperand(0),
Add->getOperand(1),
7495 return ::computeOverflowForSignedAdd(
LHS,
RHS,
nullptr, SQ);
7504 if (isa<ReturnInst>(
I))
7506 if (isa<UnreachableInst>(
I))
7513 if (isa<CatchPadInst>(
I)) {
7527 return !
I->mayThrow() &&
I->willReturn();
7541 unsigned ScanLimit) {
7548 assert(ScanLimit &&
"scan limit must be non-zero");
7550 if (isa<DbgInfoIntrinsic>(
I))
7552 if (--ScanLimit == 0)
7566 if (
I->getParent() != L->getHeader())
return false;
7569 if (&LI ==
I)
return true;
7572 llvm_unreachable(
"Instruction not contained in its own parent basic block.");
7577 switch (
I->getOpcode()) {
7578 case Instruction::Freeze:
7579 case Instruction::PHI:
7580 case Instruction::Invoke:
7582 case Instruction::Select:
7584 case Instruction::Call:
7585 if (
auto *
II = dyn_cast<IntrinsicInst>(
I)) {
7586 switch (
II->getIntrinsicID()) {
7588 case Intrinsic::sadd_with_overflow:
7589 case Intrinsic::ssub_with_overflow:
7590 case Intrinsic::smul_with_overflow:
7591 case Intrinsic::uadd_with_overflow:
7592 case Intrinsic::usub_with_overflow:
7593 case Intrinsic::umul_with_overflow:
7598 case Intrinsic::ctpop:
7599 case Intrinsic::ctlz:
7600 case Intrinsic::cttz:
7601 case Intrinsic::abs:
7602 case Intrinsic::smax:
7603 case Intrinsic::smin:
7604 case Intrinsic::umax:
7605 case Intrinsic::umin:
7606 case Intrinsic::bitreverse:
7607 case Intrinsic::bswap:
7608 case Intrinsic::sadd_sat:
7609 case Intrinsic::ssub_sat:
7610 case Intrinsic::sshl_sat:
7611 case Intrinsic::uadd_sat:
7612 case Intrinsic::usub_sat:
7613 case Intrinsic::ushl_sat:
7618 case Instruction::ICmp:
7619 case Instruction::FCmp:
7620 case Instruction::GetElementPtr:
7623 if (isa<BinaryOperator>(
I) || isa<UnaryOperator>(
I) || isa<CastInst>(
I))
7634template <
typename CallableT>
7636 const CallableT &Handle) {
7637 switch (
I->getOpcode()) {
7638 case Instruction::Store:
7643 case Instruction::Load:
7650 case Instruction::AtomicCmpXchg:
7655 case Instruction::AtomicRMW:
7660 case Instruction::Call:
7661 case Instruction::Invoke: {
7665 for (
unsigned i = 0; i < CB->
arg_size(); ++i)
7668 CB->
paramHasAttr(i, Attribute::DereferenceableOrNull)) &&
7673 case Instruction::Ret:
7674 if (
I->getFunction()->hasRetAttribute(Attribute::NoUndef) &&
7675 Handle(
I->getOperand(0)))
7678 case Instruction::Switch:
7679 if (Handle(cast<SwitchInst>(
I)->getCondition()))
7682 case Instruction::Br: {
7683 auto *BR = cast<BranchInst>(
I);
7684 if (BR->isConditional() && Handle(BR->getCondition()))
7704template <
typename CallableT>
7706 const CallableT &Handle) {
7709 switch (
I->getOpcode()) {
7711 case Instruction::UDiv:
7712 case Instruction::SDiv:
7713 case Instruction::URem:
7714 case Instruction::SRem:
7715 return Handle(
I->getOperand(1));
7732 I, [&](
const Value *V) {
return KnownPoison.
count(V); });
7746 if (
const auto *Inst = dyn_cast<Instruction>(V)) {
7750 }
else if (
const auto *Arg = dyn_cast<Argument>(V)) {
7751 if (Arg->getParent()->isDeclaration())
7754 Begin = BB->
begin();
7761 unsigned ScanLimit = 32;
7770 if (isa<DbgInfoIntrinsic>(
I))
7772 if (--ScanLimit == 0)
7776 return WellDefinedOp == V;
7796 if (isa<DbgInfoIntrinsic>(
I))
7798 if (--ScanLimit == 0)
7806 for (
const Use &
Op :
I.operands()) {
7816 if (
I.getOpcode() == Instruction::Select &&
7817 YieldsPoison.
count(
I.getOperand(1)) &&
7818 YieldsPoison.
count(
I.getOperand(2))) {
7824 if (!BB || !Visited.
insert(BB).second)
7834 return ::programUndefinedIfUndefOrPoison(Inst,
false);
7838 return ::programUndefinedIfUndefOrPoison(Inst,
true);
7845 if (
auto *
C = dyn_cast<ConstantFP>(V))
7848 if (
auto *
C = dyn_cast<ConstantDataVector>(V)) {
7849 if (!
C->getElementType()->isFloatingPointTy())
7851 for (
unsigned I = 0, E =
C->getNumElements();
I < E; ++
I) {
7852 if (
C->getElementAsAPFloat(
I).isNaN())
7858 if (isa<ConstantAggregateZero>(V))
7865 if (
auto *
C = dyn_cast<ConstantFP>(V))
7866 return !
C->isZero();
7868 if (
auto *
C = dyn_cast<ConstantDataVector>(V)) {
7869 if (!
C->getElementType()->isFloatingPointTy())
7871 for (
unsigned I = 0, E =
C->getNumElements();
I < E; ++
I) {
7872 if (
C->getElementAsAPFloat(
I).isZero())
7895 if (CmpRHS == FalseVal) {
7943 if (CmpRHS != TrueVal) {
7982 Value *
A =
nullptr, *
B =
nullptr;
7987 Value *
C =
nullptr, *
D =
nullptr;
7989 if (L.Flavor != R.Flavor)
8041 return {L.Flavor,
SPNB_NA,
false};
8048 return {L.Flavor,
SPNB_NA,
false};
8055 return {L.Flavor,
SPNB_NA,
false};
8062 return {L.Flavor,
SPNB_NA,
false};
8078 return ConstantInt::get(V->getType(), ~(*
C));
8135 if ((CmpLHS == TrueVal &&
match(FalseVal,
m_APInt(C2))) ||
8155 assert(
X &&
Y &&
"Invalid operand");
8157 auto IsNegationOf = [&](
const Value *
X,
const Value *
Y) {
8161 auto *BO = cast<BinaryOperator>(
X);
8162 if (NeedNSW && !BO->hasNoSignedWrap())
8165 auto *Zero = cast<Constant>(BO->getOperand(0));
8166 if (!AllowPoison && !Zero->isNullValue())
8173 if (IsNegationOf(
X,
Y) || IsNegationOf(
Y,
X))
8196 const APInt *RHSC1, *RHSC2;
8203 return CR1.inverse() == CR2;
8212 bool HasMismatchedZeros =
false;
8218 Value *OutputZeroVal =
nullptr;
8220 !cast<Constant>(TrueVal)->containsUndefOrPoisonElement())
8221 OutputZeroVal = TrueVal;
8223 !cast<Constant>(FalseVal)->containsUndefOrPoisonElement())
8224 OutputZeroVal = FalseVal;
8226 if (OutputZeroVal) {
8228 HasMismatchedZeros =
true;
8229 CmpLHS = OutputZeroVal;
8232 HasMismatchedZeros =
true;
8233 CmpRHS = OutputZeroVal;
8250 if (!HasMismatchedZeros)
8261 bool Ordered =
false;
8272 if (LHSSafe && RHSSafe) {
8302 if (TrueVal == CmpRHS && FalseVal == CmpLHS) {
8313 if (TrueVal == CmpLHS && FalseVal == CmpRHS) {
8338 auto MaybeSExtCmpLHS =
8342 if (
match(TrueVal, MaybeSExtCmpLHS)) {
8364 else if (
match(FalseVal, MaybeSExtCmpLHS)) {
8414 auto *Cast1 = dyn_cast<CastInst>(V1);
8418 *CastOp = Cast1->getOpcode();
8419 Type *SrcTy = Cast1->getSrcTy();
8420 if (
auto *Cast2 = dyn_cast<CastInst>(V2)) {
8422 if (*CastOp == Cast2->getOpcode() && SrcTy == Cast2->getSrcTy())
8423 return Cast2->getOperand(0);
8427 auto *
C = dyn_cast<Constant>(V2);
8434 case Instruction::ZExt:
8438 case Instruction::SExt:
8442 case Instruction::Trunc:
8445 CmpConst->
getType() == SrcTy) {
8467 CastedTo = CmpConst;
8469 unsigned ExtOp = CmpI->
isSigned() ? Instruction::SExt : Instruction::ZExt;
8473 case Instruction::FPTrunc:
8476 case Instruction::FPExt:
8479 case Instruction::FPToUI:
8482 case Instruction::FPToSI:
8485 case Instruction::UIToFP:
8488 case Instruction::SIToFP:
8501 if (CastedBack && CastedBack !=
C)
8516 CmpInst *CmpI = dyn_cast<CmpInst>(SI->getCondition());
8519 Value *TrueVal = SI->getTrueValue();
8520 Value *FalseVal = SI->getFalseValue();
8533 if (isa<FPMathOperator>(CmpI))
8541 if (CastOp && CmpLHS->
getType() != TrueVal->getType()) {
8545 if (*CastOp == Instruction::FPToSI || *CastOp == Instruction::FPToUI)
8547 return ::matchSelectPattern(Pred, FMF, CmpLHS, CmpRHS,
8548 cast<CastInst>(TrueVal)->getOperand(0),
C,
8554 if (*CastOp == Instruction::FPToSI || *CastOp == Instruction::FPToUI)
8556 return ::matchSelectPattern(Pred, FMF, CmpLHS, CmpRHS,
8557 C, cast<CastInst>(FalseVal)->getOperand(0),
8561 return ::matchSelectPattern(Pred, FMF, CmpLHS, CmpRHS, TrueVal, FalseVal,
8587 case Intrinsic::smax:
return Intrinsic::smin;
8588 case Intrinsic::smin:
return Intrinsic::smax;
8589 case Intrinsic::umax:
return Intrinsic::umin;
8590 case Intrinsic::umin:
return Intrinsic::umax;
8593 case Intrinsic::maximum:
return Intrinsic::minimum;
8594 case Intrinsic::minimum:
return Intrinsic::maximum;
8595 case Intrinsic::maxnum:
return Intrinsic::minnum;
8596 case Intrinsic::minnum:
return Intrinsic::maxnum;
8611std::pair<Intrinsic::ID, bool>
8616 bool AllCmpSingleUse =
true;
8619 if (
all_of(VL, [&SelectPattern, &AllCmpSingleUse](
Value *
I) {
8625 !
I->getType()->isIntOrIntVectorTy())
8628 SelectPattern.
Flavor != CurrentPattern.Flavor)
8630 SelectPattern = CurrentPattern;
8635 switch (SelectPattern.
Flavor) {
8637 return {Intrinsic::smin, AllCmpSingleUse};
8639 return {Intrinsic::umin, AllCmpSingleUse};
8641 return {Intrinsic::smax, AllCmpSingleUse};
8643 return {Intrinsic::umax, AllCmpSingleUse};
8656 if (
P->getNumIncomingValues() != 2)
8659 for (
unsigned i = 0; i != 2; ++i) {
8660 Value *L =
P->getIncomingValue(i);
8661 Value *R =
P->getIncomingValue(!i);
8662 auto *LU = dyn_cast<BinaryOperator>(L);
8665 unsigned Opcode = LU->getOpcode();
8671 case Instruction::LShr:
8672 case Instruction::AShr:
8673 case Instruction::Shl:
8674 case Instruction::Add:
8675 case Instruction::Sub:
8676 case Instruction::And:
8677 case Instruction::Or:
8678 case Instruction::Mul:
8679 case Instruction::FMul: {
8680 Value *LL = LU->getOperand(0);
8681 Value *LR = LU->getOperand(1);
8711 P = dyn_cast<PHINode>(
I->getOperand(0));
8713 P = dyn_cast<PHINode>(
I->getOperand(1));
8734 return !
C->isNegative();
8746 const APInt *CLHS, *CRHS;
8749 return CLHS->
sle(*CRHS);
8787 const APInt *CLHS, *CRHS;
8790 return CLHS->
ule(*CRHS);
8799static std::optional<bool>
8804 return std::nullopt;
8811 return std::nullopt;
8818 return std::nullopt;
8825 return std::nullopt;
8832 return std::nullopt;
8839static std::optional<bool>
8847 return std::nullopt;
8864 return std::nullopt;
8881 LHSIsTrue ?
LHS->getPredicate() :
LHS->getInversePredicate();
8905 const APInt *LC, *RC;
8910 if (L0 == R0 && L1 == R1)
8918 return LPred == RPred;
8923 return std::nullopt;
8930static std::optional<bool>
8935 assert((
LHS->getOpcode() == Instruction::And ||
8936 LHS->getOpcode() == Instruction::Or ||
8937 LHS->getOpcode() == Instruction::Select) &&
8938 "Expected LHS to be 'and', 'or', or 'select'.");
8945 const Value *ALHS, *ARHS;
8950 ALHS, RHSPred, RHSOp0, RHSOp1,
DL, LHSIsTrue,
Depth + 1))
8953 ARHS, RHSPred, RHSOp0, RHSOp1,
DL, LHSIsTrue,
Depth + 1))
8955 return std::nullopt;
8957 return std::nullopt;
8966 return std::nullopt;
8971 return std::nullopt;
8974 "Expected integer type only!");
8978 LHSIsTrue = !LHSIsTrue;
8989 if ((LHSI->getOpcode() == Instruction::And ||
8990 LHSI->getOpcode() == Instruction::Or ||
8991 LHSI->getOpcode() == Instruction::Select))
8995 return std::nullopt;
9000 bool LHSIsTrue,
unsigned Depth) {
9006 bool InvertRHS =
false;
9013 if (
const ICmpInst *RHSCmp = dyn_cast<ICmpInst>(
RHS)) {
9015 LHS, RHSCmp->getPredicate(), RHSCmp->getOperand(0),
9016 RHSCmp->getOperand(1),
DL, LHSIsTrue,
Depth))
9017 return InvertRHS ? !*Implied : *Implied;
9018 return std::nullopt;
9022 return std::nullopt;
9026 const Value *RHS1, *RHS2;
9028 if (std::optional<bool> Imp =
9032 if (std::optional<bool> Imp =
9038 if (std::optional<bool> Imp =
9042 if (std::optional<bool> Imp =
9048 return std::nullopt;
9053static std::pair<Value *, bool>
9055 if (!ContextI || !ContextI->
getParent())
9056 return {
nullptr,
false};
9063 return {
nullptr,
false};
9069 return {
nullptr,
false};
9072 if (TrueBB == FalseBB)
9073 return {
nullptr,
false};
9075 assert((TrueBB == ContextBB || FalseBB == ContextBB) &&
9076 "Predecessor block does not point to successor?");
9079 return {PredCond, TrueBB == ContextBB};
9085 assert(
Cond->getType()->isIntOrIntVectorTy(1) &&
"Condition must be bool");
9089 return std::nullopt;
9101 return std::nullopt;
9106 bool PreferSignedRange) {
9107 unsigned Width =
Lower.getBitWidth();
9110 case Instruction::Add:
9119 if (PreferSignedRange && HasNSW && HasNUW)
9125 }
else if (HasNSW) {
9126 if (
C->isNegative()) {
9139 case Instruction::And:
9150 case Instruction::Or:
9156 case Instruction::AShr:
9162 unsigned ShiftAmount = Width - 1;
9163 if (!
C->isZero() && IIQ.
isExact(&BO))
9164 ShiftAmount =
C->countr_zero();
9165 if (
C->isNegative()) {
9168 Upper =
C->ashr(ShiftAmount) + 1;
9171 Lower =
C->ashr(ShiftAmount);
9177 case Instruction::LShr:
9183 unsigned ShiftAmount = Width - 1;
9184 if (!
C->isZero() && IIQ.
isExact(&BO))
9185 ShiftAmount =
C->countr_zero();
9186 Lower =
C->lshr(ShiftAmount);
9191 case Instruction::Shl:
9198 if (
C->isNegative()) {
9200 unsigned ShiftAmount =
C->countl_one() - 1;
9201 Lower =
C->shl(ShiftAmount);
9205 unsigned ShiftAmount =
C->countl_zero() - 1;
9207 Upper =
C->shl(ShiftAmount) + 1;
9226 case Instruction::SDiv:
9230 if (
C->isAllOnes()) {
9235 }
else if (
C->countl_zero() < Width - 1) {
9246 if (
C->isMinSignedValue()) {
9258 case Instruction::UDiv:
9268 case Instruction::SRem:
9274 if (
C->isNegative()) {
9285 case Instruction::URem:
9300 unsigned Width =
II.getType()->getScalarSizeInBits();
9302 switch (
II.getIntrinsicID()) {
9303 case Intrinsic::ctpop:
9304 case Intrinsic::ctlz:
9305 case Intrinsic::cttz:
9308 APInt(Width, Width + 1));
9309 case Intrinsic::uadd_sat:
9315 case Intrinsic::sadd_sat:
9318 if (
C->isNegative())
9329 case Intrinsic::usub_sat:
9339 case Intrinsic::ssub_sat:
9341 if (
C->isNegative())
9351 if (
C->isNegative())
9362 case Intrinsic::umin:
9363 case Intrinsic::umax:
9364 case Intrinsic::smin:
9365 case Intrinsic::smax:
9370 switch (
II.getIntrinsicID()) {
9371 case Intrinsic::umin:
9373 case Intrinsic::umax:
9375 case Intrinsic::smin:
9378 case Intrinsic::smax:
9385 case Intrinsic::abs:
9394 case Intrinsic::vscale:
9395 if (!
II.getParent() || !
II.getFunction())
9398 case Intrinsic::scmp:
9399 case Intrinsic::ucmp:
9406 return ConstantRange::getFull(Width);
9411 unsigned BitWidth = SI.getType()->getScalarSizeInBits();
9415 return ConstantRange::getFull(
BitWidth);
9438 return ConstantRange::getFull(
BitWidth);
9452 return ConstantRange::getFull(
BitWidth);
9459 unsigned BitWidth =
I->getType()->getScalarSizeInBits();
9460 if (!
I->getOperand(0)->getType()->getScalarType()->isHalfTy())
9462 if (isa<FPToSIInst>(
I) &&
BitWidth >= 17) {
9467 if (isa<FPToUIInst>(
I) &&
BitWidth >= 16) {
9478 assert(V->getType()->isIntOrIntVectorTy() &&
"Expected integer instruction");
9481 return ConstantRange::getFull(V->getType()->getScalarSizeInBits());
9486 unsigned BitWidth = V->getType()->getScalarSizeInBits();
9488 if (
auto *VC = dyn_cast<ConstantDataVector>(V)) {
9490 for (
unsigned ElemIdx = 0, NElem = VC->getNumElements(); ElemIdx < NElem;
9492 CR = CR.
unionWith(VC->getElementAsAPInt(ElemIdx));
9498 if (
auto *BO = dyn_cast<BinaryOperator>(V)) {
9504 }
else if (
auto *
II = dyn_cast<IntrinsicInst>(V))
9506 else if (
auto *SI = dyn_cast<SelectInst>(V)) {
9508 SI->getTrueValue(), ForSigned, UseInstrInfo, AC, CtxI, DT,
Depth + 1);
9510 SI->getFalseValue(), ForSigned, UseInstrInfo, AC, CtxI, DT,
Depth + 1);
9513 }
else if (isa<FPToUIInst>(V) || isa<FPToSIInst>(V)) {
9519 }
else if (
const auto *
A = dyn_cast<Argument>(V))
9520 if (std::optional<ConstantRange>
Range =
A->getRange())
9523 if (
auto *
I = dyn_cast<Instruction>(V)) {
9527 if (
const auto *CB = dyn_cast<CallBase>(V))
9528 if (std::optional<ConstantRange>
Range = CB->getRange())
9539 "Got assumption for the wrong function!");
9540 assert(
I->getCalledFunction()->getIntrinsicID() == Intrinsic::assume &&
9541 "must be an assume intrinsic");
9545 Value *Arg =
I->getArgOperand(0);
9546 ICmpInst *Cmp = dyn_cast<ICmpInst>(Arg);
9548 if (!Cmp || Cmp->getOperand(0) != V)
9553 UseInstrInfo, AC,
I, DT,
Depth + 1);
9566 if (isa<Argument>(V) || isa<GlobalValue>(V)) {
9568 }
else if (
auto *
I = dyn_cast<Instruction>(V)) {
9574 if (isa<Instruction>(
Op) || isa<Argument>(
Op))
9582 auto AddAffected = [&InsertAffected](
Value *V) {
9597 while (!Worklist.
empty()) {
9599 if (!Visited.
insert(V).second)
9622 AddCmpOperands(
A,
B);
9672 AddCmpOperands(
A,
B);
9682 }
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.
ConstantRange Range(APInt(BitWidth, Low), APInt(BitWidth, High))
uint64_t IntrinsicInst * II
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
const SmallVectorImpl< MachineOperand > & Cond
static bool mayHaveSideEffects(MachineInstr &MI)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the make_scope_exit function, which executes user-defined cleanup logic at scope ex...
This file defines the SmallPtrSet class.
This file defines the SmallSet class.
This file defines the SmallVector class.
static std::optional< unsigned > getOpcode(ArrayRef< VPValue * > Values)
Returns the opcode of Values or ~0 if they do not all agree.
static SmallVector< VPValue *, 4 > getOperands(ArrayRef< VPValue * > Values, unsigned OperandIndex)
static bool getShuffleDemandedElts(const ShuffleVectorInst *Shuf, const APInt &DemandedElts, APInt &DemandedLHS, APInt &DemandedRHS)
static std::optional< bool > isImpliedCondICmps(const ICmpInst *LHS, CmpInst::Predicate RPred, const Value *R0, const Value *R1, const DataLayout &DL, bool LHSIsTrue)
Return true if LHS implies RHS (expanded to its components as "R0 RPred R1") is true.
static cl::opt< unsigned > DomConditionsMaxUses("dom-conditions-max-uses", cl::Hidden, cl::init(20))
static unsigned computeNumSignBitsVectorConstant(const Value *V, const APInt &DemandedElts, unsigned TyBits)
For vector constants, loop over the elements and find the constant with the minimum number of sign bi...
static bool isKnownNonZeroFromOperator(const Operator *I, const APInt &DemandedElts, unsigned Depth, const SimplifyQuery &Q)
static bool isTruePredicate(CmpInst::Predicate Pred, const Value *LHS, const Value *RHS)
Return true if "icmp Pred LHS RHS" is always true.
static bool isNonZeroMul(const APInt &DemandedElts, unsigned Depth, const SimplifyQuery &Q, unsigned BitWidth, Value *X, Value *Y, bool NSW, bool NUW)
static bool isKnownNonNullFromDominatingCondition(const Value *V, const Instruction *CtxI, const DominatorTree *DT)
static const Value * getUnderlyingObjectFromInt(const Value *V)
This is the function that does the work of looking through basic ptrtoint+arithmetic+inttoptr sequenc...
static bool isNonZeroShift(const Operator *I, const APInt &DemandedElts, unsigned Depth, const SimplifyQuery &Q, const KnownBits &KnownVal)
static bool rangeMetadataExcludesValue(const MDNode *Ranges, const APInt &Value)
Does the 'Range' metadata (which must be a valid MD_range operand list) ensure that the value it's at...
static bool outputDenormalIsIEEEOrPosZero(const Function &F, const Type *Ty)
static bool inputDenormalIsIEEE(const Function &F, const Type *Ty)
Return true if it's possible to assume IEEE treatment of input denormals in F for Val.
static OverflowResult mapOverflowResult(ConstantRange::OverflowResult OR)
Convert ConstantRange OverflowResult into ValueTracking OverflowResult.
static bool 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 matchOpWithOpEqZero(Value *Op0, Value *Op1)
static bool isNonZeroRecurrence(const PHINode *PN)
Try to detect a recurrence that monotonically increases/decreases from a non-zero starting value.
static SelectPatternResult matchClamp(CmpInst::Predicate Pred, Value *CmpLHS, Value *CmpRHS, Value *TrueVal, Value *FalseVal)
Recognize variations of: CLAMP(v,l,h) ==> ((v) < (l) ? (l) : ((v) > (h) ? (h) : (v)))
static bool shiftAmountKnownInRange(const Value *ShiftAmount)
Shifts return poison if shiftwidth is larger than the bitwidth.
static bool isEphemeralValueOf(const Instruction *I, const Value *E)
static SelectPatternResult matchMinMax(CmpInst::Predicate Pred, Value *CmpLHS, Value *CmpRHS, Value *TrueVal, Value *FalseVal, Value *&LHS, Value *&RHS, unsigned Depth)
Match non-obvious integer minimum and maximum sequences.
static bool isNonEqualPHIs(const PHINode *PN1, const PHINode *PN2, unsigned Depth, const SimplifyQuery &Q)
static bool isNonEqualShl(const Value *V1, const Value *V2, unsigned Depth, const SimplifyQuery &Q)
Return true if V2 == V1 << C, where V1 is known non-zero, C is not 0 and the shift is nuw or nsw.
static bool isGEPKnownNonNull(const GEPOperator *GEP, unsigned Depth, const SimplifyQuery &Q)
Test whether a GEP's result is known to be non-null.
static bool handleGuaranteedNonPoisonOps(const Instruction *I, const CallableT &Handle)
Enumerates all operands of I that are guaranteed to not be poison.
static bool isNonZeroSub(const APInt &DemandedElts, unsigned Depth, const SimplifyQuery &Q, unsigned BitWidth, Value *X, Value *Y)
static std::optional< std::pair< Value *, Value * > > getInvertibleOperands(const Operator *Op1, const Operator *Op2)
If the pair of operators are the same invertible function, return the the operands of the function co...
static void computeKnownBitsFromShiftOperator(const Operator *I, const APInt &DemandedElts, KnownBits &Known, KnownBits &Known2, unsigned Depth, const SimplifyQuery &Q, function_ref< KnownBits(const KnownBits &, const KnownBits &, bool)> KF)
Compute known bits from a shift operator, including those with a non-constant shift amount.
static bool cmpExcludesZero(CmpInst::Predicate Pred, const Value *RHS)
static bool inputDenormalIsIEEEOrPosZero(const Function &F, const Type *Ty)
static KnownBits getKnownBitsFromAndXorOr(const Operator *I, const APInt &DemandedElts, const KnownBits &KnownLHS, const KnownBits &KnownRHS, unsigned Depth, const SimplifyQuery &Q)
static bool isKnownNonZeroFromAssume(const Value *V, const SimplifyQuery &Q)
static std::optional< bool > isImpliedCondOperands(CmpInst::Predicate Pred, const Value *ALHS, const Value *ARHS, const Value *BLHS, const Value *BRHS)
Return true if "icmp Pred BLHS BRHS" is true whenever "icmp Pred ALHS ARHS" is true.
static unsigned ComputeNumSignBitsImpl(const Value *V, const APInt &DemandedElts, unsigned Depth, const SimplifyQuery &Q)
Return the number of times the sign bit of the register is replicated into the other bits.
static bool isNonZeroAdd(const APInt &DemandedElts, unsigned Depth, const SimplifyQuery &Q, unsigned BitWidth, Value *X, Value *Y, bool NSW, bool NUW)
static const Instruction * safeCxtI(const Value *V, const Instruction *CxtI)
static bool isKnownToBeAPowerOfTwo(const Value *V, bool OrZero, unsigned Depth, const SimplifyQuery &Q)
Return true if the given value is known to have exactly one bit set when defined.
static bool isKnownNonNaN(const Value *V, FastMathFlags FMF)
static void computeKnownBitsMul(const Value *Op0, const Value *Op1, bool NSW, const APInt &DemandedElts, KnownBits &Known, KnownBits &Known2, unsigned Depth, const SimplifyQuery &Q)
static std::optional< bool > isImpliedCondMatchingOperands(CmpInst::Predicate LPred, CmpInst::Predicate RPred)
Return true if "icmp1 LPred X, Y" implies "icmp2 RPred X, Y" is true.
static Value * BuildSubAggregate(Value *From, Value *To, Type *IndexedType, SmallVectorImpl< unsigned > &Idxs, unsigned IdxSkip, BasicBlock::iterator InsertBefore)
void computeKnownFPClass(const Value *V, const APInt &DemandedElts, FPClassTest InterestedClasses, KnownFPClass &Known, unsigned Depth, const SimplifyQuery &Q)
APInt bitcastToAPInt() const
static APFloat getLargest(const fltSemantics &Sem, bool Negative=false)
Returns the largest finite number in the given semantics.
static APFloat getInf(const fltSemantics &Sem, bool Negative=false)
Factory for Positive and Negative Infinity.
FPClassTest classify() const
Return the FPClassTest which will return true for the value.
bool isSmallestNormalized() const
Class for arbitrary precision integers.
APInt udiv(const APInt &RHS) const
Unsigned division operation.
static APInt getAllOnes(unsigned numBits)
Return an APInt of a specified width with all bits set.
void clearBit(unsigned BitPosition)
Set a given bit to 0.
bool isMinSignedValue() const
Determine if this is the smallest signed value.
uint64_t getZExtValue() const
Get zero extended value.
void setHighBits(unsigned hiBits)
Set the top hiBits bits.
void setBitsFrom(unsigned loBit)
Set the top bits starting from loBit.
APInt zextOrTrunc(unsigned width) const
Zero extend or truncate to width.
static APInt getMaxValue(unsigned numBits)
Gets maximum unsigned value of APInt for specific bit width.
void setBit(unsigned BitPosition)
Set the given bit to 1 whose position is given as "bitPosition".
unsigned ceilLogBase2() const
bool sgt(const APInt &RHS) const
Signed greater than comparison.
bool isAllOnes() const
Determine if all bits are set. This is true for zero-width values.
bool ugt(const APInt &RHS) const
Unsigned greater than comparison.
bool isZero() const
Determine if this value is zero, i.e. all bits are clear.
APInt urem(const APInt &RHS) const
Unsigned remainder operation.
unsigned getBitWidth() const
Return the number of bits in the APInt.
bool ult(const APInt &RHS) const
Unsigned less than comparison.
static APInt getSignedMaxValue(unsigned numBits)
Gets maximum signed value of APInt for a specific bit width.
static APInt getMinValue(unsigned numBits)
Gets minimum unsigned value of APInt for a specific bit width.
bool isNegative() const
Determine sign of this APInt.
bool intersects(const APInt &RHS) const
This operation tests if there are any pairs of corresponding bits between this APInt and RHS that are...
APInt sdiv(const APInt &RHS) const
Signed division function for APInt.
void clearAllBits()
Set every bit to 0.
APInt reverseBits() const
bool sle(const APInt &RHS) const
Signed less or equal comparison.
unsigned getNumSignBits() const
Computes the number of leading bits of this APInt that are equal to its sign bit.
static APInt getSignedMinValue(unsigned numBits)
Gets minimum signed value of APInt for a specific bit width.
APInt sextOrTrunc(unsigned width) const
Sign extend or truncate to width.
bool isStrictlyPositive() const
Determine if this APInt Value is positive.
unsigned logBase2() const
APInt ashr(unsigned ShiftAmt) const
Arithmetic right-shift function.
void setAllBits()
Set every bit to 1.
bool getBoolValue() const
Convert APInt to a boolean value.
bool isMaxSignedValue() const
Determine if this is the largest signed value.
bool ule(const APInt &RHS) const
Unsigned less or equal comparison.
APInt shl(unsigned shiftAmt) const
Left-shift function.
bool slt(const APInt &RHS) const
Signed less than comparison.
static APInt getHighBitsSet(unsigned numBits, unsigned hiBitsSet)
Constructs an APInt value that has the top hiBitsSet bits set.
static APInt getZero(unsigned numBits)
Get the '0' value for the specified bit-width.
void setLowBits(unsigned loBits)
Set the bottom loBits bits.
bool sge(const APInt &RHS) const
Signed greater or equal comparison.
static APInt getBitsSetFrom(unsigned numBits, unsigned loBit)
Constructs an APInt value that has a contiguous range of bits set.
static APInt getOneBitSet(unsigned numBits, unsigned BitNo)
Return an APInt with exactly one bit set in the result.
void lshrInPlace(unsigned ShiftAmt)
Logical right-shift this APInt by ShiftAmt in place.
APInt lshr(unsigned shiftAmt) const
Logical right-shift function.
bool uge(const APInt &RHS) const
Unsigned greater or equal comparison.
void clearSignBit()
Set the sign bit to 0.
an instruction to allocate memory on the stack
This class represents an incoming formal argument to a Function.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
size_t size() const
size - Get the array size.
bool empty() const
empty - Check if the array is empty.
ArrayRef< T > slice(size_t N, size_t M) const
slice(n, m) - Chop off the first N elements of the array, and keep M elements in the array.
Class to represent array types.
Type * getElementType() const
This represents the llvm.assume intrinsic.
A cache of @llvm.assume calls within a function.
MutableArrayRef< ResultElem > assumptionsFor(const Value *V)
Access the list of assumptions which affect this value.
std::optional< unsigned > getVScaleRangeMax() const
Returns the maximum value for the vscale_range attribute or std::nullopt when unknown.
unsigned getVScaleRangeMin() const
Returns the minimum value for the vscale_range attribute.
bool isValid() const
Return true if the attribute is any kind of attribute.
bool isSingleEdge() const
Check if this is the only edge between Start and End.
LLVM Basic Block Representation.
iterator begin()
Instruction iterator methods.
InstListType::const_iterator const_iterator
const Instruction * getFirstNonPHI() const
Returns a pointer to the first instruction in this block that is not a PHINode instruction.
const BasicBlock * getSinglePredecessor() const
Return the predecessor of this block if it has a single predecessor block.
const BasicBlock * getSingleSuccessor() const
Return the successor of this block if it has a single successor.
const Function * getParent() const
Return the enclosing method, or null if none.
InstListType::iterator iterator
Instruction iterators...
const Instruction * getTerminator() const LLVM_READONLY
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
Instruction::BinaryOps getBinaryOp() const
Returns the binary operation underlying the intrinsic.
BinaryOps getOpcode() const
Conditional or Unconditional Branch instruction.
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Function * getCalledFunction() const
Returns the function called, or null if this is an indirect function invocation or the function signa...
bool paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const
Determine whether the argument or parameter has the given attribute.
bool isIndirectCall() const
Return true if the callsite is an indirect call.
bool onlyReadsMemory(unsigned OpNo) const
Value * getCalledOperand() const
Value * getArgOperand(unsigned i) const
unsigned arg_size() const
This class represents a function call, abstracting a target machine's calling convention.
This is the base class for all instructions that perform data casts.
This class is the base class for the comparison instructions.
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
@ FCMP_OEQ
0 0 0 1 True if ordered and equal
@ FCMP_TRUE
1 1 1 1 Always true (always folded)
@ ICMP_SLT
signed less than
@ ICMP_SLE
signed less or equal
@ FCMP_OLT
0 1 0 0 True if ordered and less than
@ FCMP_ULE
1 1 0 1 True if unordered, less than, or equal
@ FCMP_OGT
0 0 1 0 True if ordered and greater than
@ FCMP_OGE
0 0 1 1 True if ordered and greater than or equal
@ ICMP_UGE
unsigned greater or equal
@ ICMP_UGT
unsigned greater than
@ ICMP_SGT
signed greater than
@ FCMP_ULT
1 1 0 0 True if unordered or less than
@ FCMP_ONE
0 1 1 0 True if ordered and operands are unequal
@ FCMP_UEQ
1 0 0 1 True if unordered or equal
@ ICMP_ULT
unsigned less than
@ FCMP_UGT
1 0 1 0 True if unordered or greater than
@ FCMP_OLE
0 1 0 1 True if ordered and less than or equal
@ FCMP_ORD
0 1 1 1 True if ordered (no nans)
@ ICMP_SGE
signed greater or equal
@ FCMP_UNE
1 1 1 0 True if unordered or not equal
@ ICMP_ULE
unsigned less or equal
@ FCMP_UGE
1 0 1 1 True if unordered, greater than, or equal
@ FCMP_FALSE
0 0 0 0 Always false (always folded)
@ FCMP_UNO
1 0 0 0 True if unordered: isnan(X) | isnan(Y)
static bool isEquality(Predicate pred)
Determine if this is an equals/not equals predicate.
Predicate getSwappedPredicate() const
For example, EQ->EQ, SLE->SGE, ULT->UGT, OEQ->OEQ, ULE->UGE, OLT->OGT, etc.
bool isTrueWhenEqual() const
This is just a convenience.
bool isFPPredicate() const
Predicate getInversePredicate() const
For example, EQ -> NE, UGT -> ULE, SLT -> SGE, OEQ -> UNE, UGT -> OLE, OLT -> UGE,...
Predicate getPredicate() const
Return the predicate for this instruction.
static bool isUnordered(Predicate predicate)
Determine if the predicate is an unordered operation.
static bool isImpliedTrueByMatchingCmp(Predicate Pred1, Predicate Pred2)
Determine if Pred1 implies Pred2 is true when two compares have matching operands.
bool isIntPredicate() const
static bool isOrdered(Predicate predicate)
Determine if the predicate is an ordered operation.
static bool isImpliedFalseByMatchingCmp(Predicate Pred1, Predicate Pred2)
Determine if Pred1 implies Pred2 is false when two compares have matching operands.
An array constant whose element type is a simple 1/2/4/8-byte integer or float/double,...
ConstantDataSequential - A vector or array constant whose element type is a simple 1/2/4/8-byte integ...
StringRef getAsString() const
If this array is isString(), then this method returns the array as a StringRef.
uint64_t getElementAsInteger(unsigned i) const
If this is a sequential container of integers (of any size), return the specified element in the low ...
A vector constant whose element type is a simple 1/2/4/8-byte integer or float/double,...
static Constant * getBitCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
static Constant * getTrunc(Constant *C, Type *Ty, bool OnlyIfReduced=false)
ConstantFP - Floating Point Values [float, double].
This is the shared class of boolean and integer constants.
static ConstantInt * getTrue(LLVMContext &Context)
bool isZero() const
This is just a convenience method to make client code smaller for a common code.
uint64_t getZExtValue() const
Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...
This class represents a range of values.
PreferredRangeType
If represented precisely, the result of some range operations may consist of multiple disjoint ranges...
const APInt * getSingleElement() const
If this set contains a single element, return it, otherwise return null.
static ConstantRange fromKnownBits(const KnownBits &Known, bool IsSigned)
Initialize a range based on a known bits constraint.
OverflowResult unsignedSubMayOverflow(const ConstantRange &Other) const
Return whether unsigned sub of the two ranges always/never overflows.
bool isAllNegative() const
Return true if all values in this range are negative.
OverflowResult unsignedAddMayOverflow(const ConstantRange &Other) const
Return whether unsigned add of the two ranges always/never overflows.
KnownBits toKnownBits() const
Return known bits for values in this range.
APInt getUnsignedMin() const
Return the smallest unsigned value contained in the ConstantRange.
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.
APInt getUnsignedMax() const
Return the largest unsigned value contained in the ConstantRange.
ConstantRange intersectWith(const ConstantRange &CR, PreferredRangeType Type=Smallest) const
Return the range that results from the intersection of this range with another range.
OverflowResult
Represents whether an operation on the given constant range is known to always or never overflow.
@ NeverOverflows
Never overflows.
@ AlwaysOverflowsHigh
Always overflows in the direction of signed/unsigned max value.
@ AlwaysOverflowsLow
Always overflows in the direction of signed/unsigned min value.
@ MayOverflow
May or may not overflow.
static ConstantRange getNonEmpty(APInt Lower, APInt Upper)
Create non-empty constant range with the given bounds.
uint32_t getBitWidth() const
Get the bit width of this ConstantRange.
OverflowResult signedSubMayOverflow(const ConstantRange &Other) const
Return whether signed sub of the two ranges always/never overflows.
ConstantRange sub(const ConstantRange &Other) const
Return a new range representing the possible values resulting from a subtraction of a value in this r...
This is an important base class in LLVM.
Constant * getSplatValue(bool AllowPoison=false) const
If all elements of the vector constant have the same value, return that value.
static Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
Constant * getAggregateElement(unsigned Elt) const
For aggregates (struct/array/vector) return the constant that corresponds to the specified element if...
bool isZeroValue() const
Return true if the value is negative zero or null value.
bool isNullValue() const
Return true if this is the value that would be returned by getNullValue.
This class represents an Operation in the Expression.
A parsed version of the target data layout string in and methods for querying it.
bool isLittleEndian() const
Layout endianness...
const StructLayout * getStructLayout(StructType *Ty) const
Returns a StructLayout object, indicating the alignment of the struct, its size, and the offsets of i...
unsigned getIndexTypeSizeInBits(Type *Ty) const
Layout size of the index used in GEP calculation.
unsigned getPointerTypeSizeInBits(Type *) const
Layout pointer size, in bits, based on the type.
TypeSize getTypeSizeInBits(Type *Ty) const
Size examples:
ArrayRef< BranchInst * > conditionsFor(const Value *V) const
Access the list of branches which affect this value.
DomTreeNodeBase * getIDom() const
DomTreeNodeBase< NodeT > * getNode(const NodeT *BB) const
getNode - return the (Post)DominatorTree node for the specified basic block.
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
bool dominates(const BasicBlock *BB, const Use &U) const
Return true if the (end of the) basic block BB dominates the use U.
Utility class for floating point operations which can have information about relaxed accuracy require...
Convenience struct for specifying and reasoning about fast-math flags.
bool noSignedZeros() const
void setNoSignedZeros(bool B=true)
const BasicBlock & getEntryBlock() const
DenormalMode getDenormalMode(const fltSemantics &FPType) const
Returns the denormal handling type for the default rounding mode of the function.
an instruction for type-safe pointer arithmetic to access elements of arrays and structs
const DataLayout & getDataLayout() const
Get the data layout of the module this global belongs to.
Type * getValueType() const
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
bool isConstant() const
If the value is a global constant, its value is immutable throughout the runtime execution of the pro...
bool hasDefinitiveInitializer() const
hasDefinitiveInitializer - Whether the global variable has an initializer, and any other instances of...
This instruction compares its operands according to the predicate given to the constructor.
bool isEquality() const
Return true if this predicate is either EQ or NE.
This instruction inserts a struct field of array element value into an aggregate value.
Value * getAggregateOperand()
static InsertValueInst * Create(Value *Agg, Value *Val, ArrayRef< unsigned > Idxs, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
bool hasNoUnsignedWrap() const LLVM_READONLY
Determine whether the no unsigned wrap flag is set.
bool hasNoSignedWrap() const LLVM_READONLY
Determine whether the no signed wrap flag is set.
InstListType::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
bool isExact() const LLVM_READONLY
Determine whether the exact flag is set.
const Function * getFunction() const
Return the function this instruction belongs to.
bool comesBefore(const Instruction *Other) const
Given an instruction Other in the same basic block as this instruction, return true if this instructi...
FastMathFlags getFastMathFlags() const LLVM_READONLY
Convenience function for getting all the fast-math flags, which must be an operator which supports th...
unsigned getOpcode() const
Returns a member of one of the enums like Instruction::Add.
const DataLayout & getDataLayout() const
Get the data layout of the module this instruction belongs to.
A wrapper class for inspecting calls to intrinsic functions.
This is an important class for using LLVM in a threaded context.
An instruction for reading from memory.
Value * getPointerOperand()
Align getAlign() const
Return the alignment of the access that is being performed.
bool isLoopHeader(const BlockT *BB) const
LoopT * getLoopFor(const BlockT *BB) const
Return the inner most loop that BB lives in.
Represents a single loop in the control flow graph.
This is a utility class that provides an abstraction for the common functionality between Instruction...
unsigned getOpcode() const
Return the opcode for this Instruction or ConstantExpr.
Utility class for integer operators which may exhibit overflow - Add, Sub, Mul, and Shl.
iterator_range< const_block_iterator > blocks() const
Value * getIncomingValueForBlock(const BasicBlock *BB) const
BasicBlock * getIncomingBlock(unsigned i) const
Return incoming basic block number i.
Value * getIncomingValue(unsigned i) const
Return incoming value number x.
unsigned getNumIncomingValues() const
Return the number of incoming edges.
static PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
A udiv or sdiv instruction, which can be marked as "exact", indicating that no bits are destroyed.
bool isExact() const
Test whether this division is known to be exact, with zero remainder.
This class represents the LLVM 'select' instruction.
const Value * getFalseValue() const
const Value * getCondition() const
const Value * getTrueValue() const
This instruction constructs a fixed permutation of two input vectors.
VectorType * getType() const
Overload to return most specific vector type.
static void getShuffleMask(const Constant *Mask, SmallVectorImpl< int > &Result)
Convert the input shuffle mask operand to a vector of integers.
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
size_type count(ConstPtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
SmallSet - This maintains a set of unique values, optimizing for the case when the set is small (less...
size_type count(const T &V) const
count - Return 1 if the element is in the set, 0 otherwise.
std::pair< const_iterator, bool > insert(const T &V)
insert - Insert an element into the set if it isn't already there.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
void reserve(size_type N)
void append(ItTy in_start, ItTy in_end)
Add the specified range to the end of the SmallVector.
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringRef - Represent a constant reference to a string, i.e.
Used to lazily calculate structure layout information for a target machine, based on the DataLayout s...
TypeSize getElementOffset(unsigned Idx) const
Class to represent struct types.
unsigned getNumElements() const
Random access to the elements.
Type * getElementType(unsigned N) const
Provides information about what library functions are available for the current target.
bool getLibFunc(StringRef funcName, LibFunc &F) const
Searches for a particular function name.
The instances of the Type class are immutable: once they are created, they are never changed.
unsigned getIntegerBitWidth() const
const fltSemantics & getFltSemantics() const
bool isVectorTy() const
True if this is an instance of VectorType.
bool isIntOrIntVectorTy() const
Return true if this is an integer type or a vector of integer types.
bool isPointerTy() const
True if this is an instance of PointerType.
uint64_t getArrayNumElements() const
static IntegerType * getIntNTy(LLVMContext &C, unsigned N)
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type.
bool isSized(SmallPtrSetImpl< Type * > *Visited=nullptr) const
Return true if it makes sense to take the size of this type.
static IntegerType * getInt16Ty(LLVMContext &C)
static IntegerType * getInt8Ty(LLVMContext &C)
bool isPtrOrPtrVectorTy() const
Return true if this is a pointer type or a vector of pointer types.
bool isIntOrPtrTy() const
Return true if this is an integer type or a pointer type.
static IntegerType * getInt32Ty(LLVMContext &C)
static IntegerType * getInt64Ty(LLVMContext &C)
bool isIntegerTy() const
True if this is an instance of IntegerType.
Type * getScalarType() const
If this is a vector type, return the element type, otherwise return 'this'.
static UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
A Use represents the edge between a Value definition and its users.
User * getUser() const
Returns the User that contains this Use.
unsigned getOperandNo() const
Return the operand # of this use in its User.
Value * getOperand(unsigned i) const
unsigned getNumOperands() const
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
const Value * stripAndAccumulateInBoundsConstantOffsets(const DataLayout &DL, APInt &Offset) const
This is a wrapper around stripAndAccumulateConstantOffsets with the in-bounds requirement set to fals...
iterator_range< user_iterator > users()
const KnownBits & getKnownBits(const SimplifyQuery &Q) const
PointerType getValue() const
Represents an op.with.overflow intrinsic.
constexpr ScalarTy getFixedValue() const
constexpr bool isScalable() const
Returns whether the quantity is scaled by a runtime quantity (vscale).
constexpr ScalarTy getKnownMinValue() const
Returns the minimum value this quantity can represent.
An efficient, type-erasing, non-owning reference to a callable.
StructType * getStructTypeOrNull() const
TypeSize getSequentialElementStride(const DataLayout &DL) const
Type * getIndexedType() const
const ParentTy * getParent() const
self_iterator getIterator()
A range adaptor for a pair of iterators.
This provides a very simple, boring adaptor for a begin and end iterator into a range type.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ C
The default llvm calling convention, compatible with C.
cst_pred_ty< is_all_ones > m_AllOnes()
Match an integer or vector with all bits set.
BinaryOp_match< LHS, RHS, Instruction::And > m_And(const LHS &L, const RHS &R)
MaxMin_match< FCmpInst, LHS, RHS, ufmin_pred_ty > m_UnordFMin(const LHS &L, const RHS &R)
Match an 'unordered' floating point minimum function.
PtrToIntSameSize_match< OpTy > m_PtrToIntSameSize(const DataLayout &DL, const OpTy &Op)
BinaryOp_match< LHS, RHS, Instruction::Add > m_Add(const LHS &L, const RHS &R)
cst_pred_ty< is_sign_mask > m_SignMask()
Match an integer or vector with only the sign bit(s) set.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWAdd(const LHS &L, const RHS &R)
cst_pred_ty< is_power2 > m_Power2()
Match an integer or vector power-of-2.
BinaryOp_match< LHS, RHS, Instruction::URem > m_URem(const LHS &L, const RHS &R)
auto m_LogicalOp()
Matches either L && R or L || R where L and R are arbitrary values.
class_match< Constant > m_Constant()
Match an arbitrary Constant and ignore it.
BinaryOp_match< LHS, RHS, Instruction::And, true > m_c_And(const LHS &L, const RHS &R)
Matches an And with LHS and RHS in either order.
cst_pred_ty< is_power2_or_zero > m_Power2OrZero()
Match an integer or vector of 0 or power-of-2 values.
CastInst_match< OpTy, TruncInst > m_Trunc(const OpTy &Op)
Matches Trunc.
BinaryOp_match< LHS, RHS, Instruction::Xor > m_Xor(const LHS &L, const RHS &R)
OverflowingBinaryOp_match< LHS, RHS, Instruction::Sub, OverflowingBinaryOperator::NoSignedWrap > m_NSWSub(const LHS &L, const RHS &R)
bool match(Val *V, const Pattern &P)
BinOpPred_match< LHS, RHS, is_idiv_op > m_IDiv(const LHS &L, const RHS &R)
Matches integer division operations.
cstfp_pred_ty< is_any_zero_fp > m_AnyZeroFP()
Match a floating-point negative zero or positive zero.
specificval_ty m_Specific(const Value *V)
Match if we have a specific specified value.
BinOpPred_match< LHS, RHS, is_right_shift_op > m_Shr(const LHS &L, const RHS &R)
Matches logical shift operations.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap, true > m_c_NUWAdd(const LHS &L, const RHS &R)
class_match< ConstantInt > m_ConstantInt()
Match an arbitrary ConstantInt and ignore it.
cst_pred_ty< is_one > m_One()
Match an integer 1 or a vector with all elements equal to 1.
ThreeOps_match< Cond, LHS, RHS, Instruction::Select > m_Select(const Cond &C, const LHS &L, const RHS &R)
Matches SelectInst.
ExtractValue_match< Ind, Val_t > m_ExtractValue(const Val_t &V)
Match a single index ExtractValue instruction.
MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty > m_SMin(const LHS &L, const RHS &R)
CmpClass_match< LHS, RHS, FCmpInst, FCmpInst::Predicate > m_FCmp(FCmpInst::Predicate &Pred, const LHS &L, const RHS &R)
bind_ty< WithOverflowInst > m_WithOverflowInst(WithOverflowInst *&I)
Match a with overflow intrinsic, capturing it if we match.
BinaryOp_match< LHS, RHS, Instruction::Xor, true > m_c_Xor(const LHS &L, const RHS &R)
Matches an Xor with LHS and RHS in either order.
BinaryOp_match< LHS, RHS, Instruction::Mul > m_Mul(const LHS &L, const RHS &R)
deferredval_ty< Value > m_Deferred(Value *const &V)
Like m_Specific(), but works if the specific value to match is determined as part of the same match()...
cst_pred_ty< is_zero_int > m_ZeroInt()
Match an integer 0 or a vector with all elements equal to 0.
CmpClass_match< LHS, RHS, ICmpInst, ICmpInst::Predicate > m_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R)
OneUse_match< T > m_OneUse(const T &SubPattern)
MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty, true > m_c_SMin(const LHS &L, const RHS &R)
Matches an SMin with LHS and RHS in either order.
auto m_LogicalOr()
Matches L || R where L and R are arbitrary values.
BinaryOp_match< cst_pred_ty< is_zero_int >, ValTy, Instruction::Sub > m_Neg(const ValTy &V)
Matches a 'Neg' as 'sub 0, V'.
match_combine_and< class_match< Constant >, match_unless< constantexpr_match > > m_ImmConstant()
Match an arbitrary immediate Constant and ignore it.
MaxMin_match< ICmpInst, LHS, RHS, umax_pred_ty, true > m_c_UMax(const LHS &L, const RHS &R)
Matches a UMax with LHS and RHS in either order.
BinaryOp_match< LHS, RHS, Instruction::UDiv > m_UDiv(const LHS &L, const RHS &R)
MaxMin_match< ICmpInst, LHS, RHS, umax_pred_ty > m_UMax(const LHS &L, const RHS &R)
brc_match< Cond_t, bind_ty< BasicBlock >, bind_ty< BasicBlock > > m_Br(const Cond_t &C, BasicBlock *&T, BasicBlock *&F)
CmpClass_match< LHS, RHS, ICmpInst, ICmpInst::Predicate, true > m_c_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R)
Matches an ICmp with a predicate over LHS and RHS in either order.
MaxMin_match< ICmpInst, LHS, RHS, umin_pred_ty, true > m_c_UMin(const LHS &L, const RHS &R)
Matches a UMin with LHS and RHS in either order.
BinaryOp_match< LHS, RHS, Instruction::Add, true > m_c_Add(const LHS &L, const RHS &R)
Matches a Add with LHS and RHS in either order.
apfloat_match m_APFloatAllowPoison(const APFloat *&Res)
Match APFloat while allowing poison in splat vector constants.
match_combine_or< BinaryOp_match< LHS, RHS, Instruction::Add >, DisjointOr_match< LHS, RHS > > m_AddLike(const LHS &L, const RHS &R)
Match either "add" or "or disjoint".
MaxMin_match< ICmpInst, LHS, RHS, smax_pred_ty, true > m_c_SMax(const LHS &L, const RHS &R)
Matches an SMax with LHS and RHS in either order.
MaxMin_match< FCmpInst, LHS, RHS, ufmax_pred_ty > m_UnordFMax(const LHS &L, const RHS &R)
Match an 'unordered' floating point maximum function.
VScaleVal_match m_VScale()
OverflowingBinaryOp_match< LHS, RHS, Instruction::Sub, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWSub(const LHS &L, const RHS &R)
MaxMin_match< ICmpInst, LHS, RHS, smax_pred_ty > m_SMax(const LHS &L, const RHS &R)
apint_match m_APInt(const APInt *&Res)
Match a ConstantInt or splatted ConstantVector, binding the specified pointer to the contained APInt.
MaxMin_match< FCmpInst, LHS, RHS, ofmax_pred_ty > m_OrdFMax(const LHS &L, const RHS &R)
Match an 'ordered' floating point maximum function.
match_combine_or< OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoSignedWrap >, DisjointOr_match< LHS, RHS > > m_NSWAddLike(const LHS &L, const RHS &R)
Match either "add nsw" or "or disjoint".
class_match< Value > m_Value()
Match an arbitrary value and ignore it.
AnyBinaryOp_match< LHS, RHS, true > m_c_BinOp(const LHS &L, const RHS &R)
Matches a BinaryOperator with LHS and RHS in either order.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoSignedWrap > m_NSWAdd(const LHS &L, const RHS &R)
BinaryOp_match< LHS, RHS, Instruction::LShr > m_LShr(const LHS &L, const RHS &R)
match_combine_or< CastInst_match< OpTy, ZExtInst >, CastInst_match< OpTy, SExtInst > > m_ZExtOrSExt(const OpTy &Op)
FNeg_match< OpTy > m_FNeg(const OpTy &X)
Match 'fneg X' as 'fsub -0.0, X'.
BinOpPred_match< LHS, RHS, is_shift_op > m_Shift(const LHS &L, const RHS &R)
Matches shift operations.
BinaryOp_match< LHS, RHS, Instruction::Shl > m_Shl(const LHS &L, const RHS &R)
BinOpPred_match< LHS, RHS, is_irem_op > m_IRem(const LHS &L, const RHS &R)
Matches integer remainder operations.
apfloat_match m_APFloat(const APFloat *&Res)
Match a ConstantFP or splatted ConstantVector, binding the specified pointer to the contained APFloat...
auto m_LogicalAnd()
Matches L && R where L and R are arbitrary values.
MaxMin_match< FCmpInst, LHS, RHS, ofmin_pred_ty > m_OrdFMin(const LHS &L, const RHS &R)
Match an 'ordered' floating point minimum function.
class_match< BasicBlock > m_BasicBlock()
Match an arbitrary basic block value and ignore it.
BinaryOp_match< LHS, RHS, Instruction::SRem > m_SRem(const LHS &L, const RHS &R)
BinaryOp_match< cst_pred_ty< is_all_ones >, ValTy, Instruction::Xor, true > m_Not(const ValTy &V)
Matches a 'Not' as 'xor V, -1' or 'xor -1, V'.
BinaryOp_match< LHS, RHS, Instruction::Or > m_Or(const LHS &L, const RHS &R)
CastInst_match< OpTy, SExtInst > m_SExt(const OpTy &Op)
Matches SExt.
is_zero m_Zero()
Match any null constant or a vector with all elements equal to 0.
BinaryOp_match< LHS, RHS, Instruction::Or, true > m_c_Or(const LHS &L, const RHS &R)
Matches an Or with LHS and RHS in either order.
match_combine_or< OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap >, DisjointOr_match< LHS, RHS > > m_NUWAddLike(const LHS &L, const RHS &R)
Match either "add nuw" or "or disjoint".
BinOpPred_match< LHS, RHS, is_bitwiselogic_op > m_BitwiseLogic(const LHS &L, const RHS &R)
Matches bitwise logic operations.
ElementWiseBitCast_match< OpTy > m_ElementWiseBitCast(const OpTy &Op)
m_Intrinsic_Ty< Opnd0 >::Ty m_FAbs(const Opnd0 &Op0)
CastOperator_match< OpTy, Instruction::PtrToInt > m_PtrToInt(const OpTy &Op)
Matches PtrToInt.
BinaryOp_match< LHS, RHS, Instruction::Sub > m_Sub(const LHS &L, const RHS &R)
MaxMin_match< ICmpInst, LHS, RHS, umin_pred_ty > m_UMin(const LHS &L, const RHS &R)
match_combine_or< LTy, RTy > m_CombineOr(const LTy &L, const RTy &R)
Combine two pattern matchers matching L || R.
static unsigned decodeVSEW(unsigned VSEW)
unsigned getSEWLMULRatio(unsigned SEW, RISCVII::VLMUL VLMul)
static constexpr unsigned RVVBitsPerBlock
initializer< Ty > init(const Ty &Val)
This is an optimization pass for GlobalISel generic memory operations.
bool haveNoCommonBitsSet(const WithCache< const Value * > &LHSCache, const WithCache< const Value * > &RHSCache, const SimplifyQuery &SQ)
Return true if LHS and RHS have no common bits set.
bool mustExecuteUBIfPoisonOnPathTo(Instruction *Root, Instruction *OnPathTo, DominatorTree *DT)
Return true if undefined behavior would provable be executed on the path to OnPathTo if Root produced...
Intrinsic::ID getInverseMinMaxIntrinsic(Intrinsic::ID MinMaxID)
@ NeverOverflows
Never overflows.
@ AlwaysOverflowsHigh
Always overflows in the direction of signed/unsigned max value.
@ AlwaysOverflowsLow
Always overflows in the direction of signed/unsigned min value.
@ MayOverflow
May or may not overflow.
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
bool isValidAssumeForContext(const Instruction *I, const Instruction *CxtI, const DominatorTree *DT=nullptr, bool AllowEphemerals=false)
Return true if it is valid to use the assumptions provided by an assume intrinsic,...
auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)
Get the size of a range.
bool canCreatePoison(const Operator *Op, bool ConsiderFlagsAndMetadata=true)
bool MaskedValueIsZero(const Value *V, const APInt &Mask, const SimplifyQuery &DL, unsigned Depth=0)
Return true if 'V & Mask' is known to be zero.
bool mustTriggerUB(const Instruction *I, const SmallPtrSetImpl< const Value * > &KnownPoison)
Return true if the given instruction must trigger undefined behavior when I is executed with any oper...
detail::scope_exit< std::decay_t< Callable > > make_scope_exit(Callable &&F)
bool isOnlyUsedInZeroEqualityComparison(const Instruction *CxtI)
bool isSignBitCheck(ICmpInst::Predicate Pred, const APInt &RHS, bool &TrueIfSigned)
Given an exploded icmp instruction, return true if the comparison only checks the sign bit.
const Value * getArgumentAliasingToReturnedPointer(const CallBase *Call, bool MustPreserveNullness)
This function returns call pointer argument that is considered the same by aliasing rules.
bool isAssumeLikeIntrinsic(const Instruction *I)
Return true if it is an intrinsic that cannot be speculated but also cannot trap.
AllocaInst * findAllocaForValue(Value *V, bool OffsetZero=false)
Returns unique alloca where the value comes from, or nullptr.
APInt getMinMaxLimit(SelectPatternFlavor SPF, unsigned BitWidth)
Return the minimum or maximum constant value for the specified integer min/max flavor and type.
void getGuaranteedNonPoisonOps(const Instruction *I, SmallVectorImpl< const Value * > &Ops)
Insert operands of I into Ops such that I will trigger undefined behavior if I is executed and that o...
bool isOnlyUsedInZeroComparison(const Instruction *CxtI)
const Value * getLoadStorePointerOperand(const Value *V)
A helper function that returns the pointer operand of a load or store instruction.
bool getConstantStringInfo(const Value *V, StringRef &Str, bool TrimAtNul=true)
This function computes the length of a null-terminated C string pointed to by V.
bool isDereferenceableAndAlignedPointer(const Value *V, Type *Ty, Align Alignment, const DataLayout &DL, const Instruction *CtxI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr)
Returns true if V is always a dereferenceable pointer with alignment greater or equal than requested.
bool onlyUsedByLifetimeMarkersOrDroppableInsts(const Value *V)
Return true if the only users of this pointer are lifetime markers or droppable instructions.
Constant * ReadByteArrayFromGlobal(const GlobalVariable *GV, uint64_t Offset)
bool getUnderlyingObjectsForCodeGen(const Value *V, SmallVectorImpl< Value * > &Objects)
This is a wrapper around getUnderlyingObjects and adds support for basic ptrtoint+arithmetic+inttoptr...
std::pair< Intrinsic::ID, bool > canConvertToMinOrMaxIntrinsic(ArrayRef< Value * > VL)
Check if the values in VL are select instructions that can be converted to a min or max (vector) intr...
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
bool getConstantDataArrayInfo(const Value *V, ConstantDataArraySlice &Slice, unsigned ElementSize, uint64_t Offset=0)
Returns true if the value V is a pointer into a ConstantDataArray.
int bit_width(T Value)
Returns the number of bits needed to represent Value if Value is nonzero.
bool isGuaranteedToExecuteForEveryIteration(const Instruction *I, const Loop *L)
Return true if this function can prove that the instruction I is executed for every iteration of the ...
void append_range(Container &C, Range &&R)
Wrapper function to append range R to container C.
const Value * getUnderlyingObject(const Value *V, unsigned MaxLookup=6)
This method strips off any GEP address adjustments, pointer casts or llvm.threadlocal....
bool isKnownToBeAPowerOfTwo(const Value *V, const DataLayout &DL, bool OrZero=false, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true)
Return true if the given value is known to have exactly one bit set when defined.
bool mustSuppressSpeculation(const LoadInst &LI)
Return true if speculation of the given load must be suppressed to avoid ordering or interfering with...
constexpr bool isPowerOf2_64(uint64_t Value)
Return true if the argument is a power of two > 0 (64 bit edition.)
gep_type_iterator gep_type_end(const User *GEP)
CmpInst::Predicate getMinMaxPred(SelectPatternFlavor SPF, bool Ordered=false)
Return the canonical comparison predicate for the specified minimum/maximum flavor.
void computeKnownBitsFromContext(const Value *V, KnownBits &Known, unsigned Depth, const SimplifyQuery &Q)
Merge bits known from context-dependent facts into Known.
unsigned Log2_64(uint64_t Value)
Return the floor log base 2 of the specified value, -1 if the value is zero.
bool isGuaranteedNotToBeUndef(const Value *V, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, unsigned Depth=0)
Returns true if V cannot be undef, but may be poison.
ConstantRange getConstantRangeFromMetadata(const MDNode &RangeMD)
Parse out a conservative ConstantRange from !range metadata.
ConstantRange computeConstantRange(const Value *V, bool ForSigned, bool UseInstrInfo=true, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, unsigned Depth=0)
Determine the possible constant range of an integer or vector of integer value.
const Value * getPointerOperand(const Value *V)
A helper function that returns the pointer operand of a load, store or GEP instruction.
int countr_zero(T Val)
Count number of 0's from the least significant bit to the most stopping at the first 1.
bool isOverflowIntrinsicNoWrap(const WithOverflowInst *WO, const DominatorTree &DT)
Returns true if the arithmetic part of the WO 's result is used only along the paths control dependen...
bool isSafeToSpeculativelyExecuteWithOpcode(unsigned Opcode, const Instruction *Inst, const Instruction *CtxI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr)
This returns the same result as isSafeToSpeculativelyExecute if Opcode is the actual opcode of Inst.
RetainedKnowledge getKnowledgeValidInContext(const Value *V, ArrayRef< Attribute::AttrKind > AttrKinds, const Instruction *CtxI, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr)
Return a valid Knowledge associated to the Value V if its Attribute kind is in AttrKinds and the know...
RetainedKnowledge getKnowledgeFromBundle(AssumeInst &Assume, const CallBase::BundleOpInfo &BOI)
This extracts the Knowledge from an element of an operand bundle.
bool matchSimpleRecurrence(const PHINode *P, BinaryOperator *&BO, Value *&Start, Value *&Step)
Attempt to match a simple first order recurrence cycle of the form: iv = phi Ty [Start,...
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
KnownBits analyzeKnownBitsFromAndXorOr(const Operator *I, const KnownBits &KnownLHS, const KnownBits &KnownRHS, unsigned Depth, const SimplifyQuery &SQ)
Using KnownBits LHS/RHS produce the known bits for logic op (and/xor/or).
OverflowResult computeOverflowForUnsignedMul(const Value *LHS, const Value *RHS, const SimplifyQuery &SQ, bool IsNSW=false)
bool getShuffleDemandedElts(int SrcWidth, ArrayRef< int > Mask, const APInt &DemandedElts, APInt &DemandedLHS, APInt &DemandedRHS, bool AllowUndefElts=false)
Transform a shuffle mask's output demanded element mask into demanded element masks for the 2 operand...
unsigned Log2_32(uint32_t Value)
Return the floor log base 2 of the specified value, -1 if the value is zero.
bool isGuard(const User *U)
Returns true iff U has semantics of a guard expressed in a form of call of llvm.experimental....
int countl_zero(T Val)
Count number of 0's from the most significant bit to the least stopping at the first 1.
SelectPatternFlavor getInverseMinMaxFlavor(SelectPatternFlavor SPF)
Return the inverse minimum/maximum flavor of the specified flavor.
constexpr unsigned MaxAnalysisRecursionDepth
void getGuaranteedWellDefinedOps(const Instruction *I, SmallVectorImpl< const Value * > &Ops)
Insert operands of I into Ops such that I will trigger undefined behavior if I is executed and that o...
OverflowResult computeOverflowForSignedSub(const Value *LHS, const Value *RHS, const SimplifyQuery &SQ)
std::tuple< Value *, FPClassTest, FPClassTest > fcmpImpliesClass(CmpInst::Predicate Pred, const Function &F, Value *LHS, Value *RHS, bool LookThroughSrc=true)
Compute the possible floating-point classes that LHS could be based on fcmp \Pred LHS,...
SelectPatternFlavor
Specific patterns of select instructions we can match.
@ SPF_ABS
Floating point maxnum.
@ SPF_NABS
Absolute value.
@ SPF_FMAXNUM
Floating point minnum.
@ SPF_UMIN
Signed minimum.
@ SPF_UMAX
Signed maximum.
@ SPF_SMAX
Unsigned minimum.
@ SPF_FMINNUM
Unsigned maximum.
bool isIntrinsicReturningPointerAliasingArgumentWithoutCapturing(const CallBase *Call, bool MustPreserveNullness)
{launder,strip}.invariant.group returns pointer that aliases its argument, and it only captures point...
bool impliesPoison(const Value *ValAssumedPoison, const Value *V)
Return true if V is poison given that ValAssumedPoison is already poison.
FPClassTest
Floating-point class tests, supported by 'is_fpclass' intrinsic.
bool programUndefinedIfPoison(const Instruction *Inst)
SelectPatternResult matchSelectPattern(Value *V, Value *&LHS, Value *&RHS, Instruction::CastOps *CastOp=nullptr, unsigned Depth=0)
Pattern match integer [SU]MIN, [SU]MAX and ABS idioms, returning the kind and providing the out param...
bool NullPointerIsDefined(const Function *F, unsigned AS=0)
Check whether null pointer dereferencing is considered undefined behavior for a given function or an ...
bool programUndefinedIfUndefOrPoison(const Instruction *Inst)
Return true if this function can prove that if Inst is executed and yields a poison value or undef bi...
FPClassTest inverse_fabs(FPClassTest Mask)
Return the test mask which returns true after fabs is applied to the value.
uint64_t GetStringLength(const Value *V, unsigned CharSize=8)
If we can compute the length of the string pointed to by the specified pointer, return 'len+1'.
OverflowResult computeOverflowForSignedMul(const Value *LHS, const Value *RHS, const SimplifyQuery &SQ)
ConstantRange getVScaleRange(const Function *F, unsigned BitWidth)
Determine the possible constant range of vscale with the given bit width, based on the vscale_range f...
Constant * ConstantFoldCastOperand(unsigned Opcode, Constant *C, Type *DestTy, const DataLayout &DL)
Attempt to constant fold a cast with the specified operand.
bool canCreateUndefOrPoison(const Operator *Op, bool ConsiderFlagsAndMetadata=true)
canCreateUndefOrPoison returns true if Op can create undef or poison from non-undef & non-poison oper...
EHPersonality classifyEHPersonality(const Value *Pers)
See if the given exception handling personality function is one that we understand.
bool isKnownInversion(const Value *X, const Value *Y)
Return true iff:
bool isKnownNonZero(const Value *V, const SimplifyQuery &Q, unsigned Depth=0)
Return true if the given value is known to be non-zero when defined.
constexpr int PoisonMaskElem
bool onlyUsedByLifetimeMarkers(const Value *V)
Return true if the only users of this pointer are lifetime markers.
Intrinsic::ID getIntrinsicForCallSite(const CallBase &CB, const TargetLibraryInfo *TLI)
Map a call instruction to an intrinsic ID.
@ First
Helpers to iterate all locations in the MemoryEffectsBase class.
void getUnderlyingObjects(const Value *V, SmallVectorImpl< const Value * > &Objects, LoopInfo *LI=nullptr, unsigned MaxLookup=6)
This method is similar to getUnderlyingObject except that it can look through phi and select instruct...
OverflowResult computeOverflowForSignedAdd(const WithCache< const Value * > &LHS, const WithCache< const Value * > &RHS, const SimplifyQuery &SQ)
bool propagatesPoison(const Use &PoisonOp)
Return true if PoisonOp's user yields poison or raises UB if its operand PoisonOp is poison.
bool isKnownNegative(const Value *V, const SimplifyQuery &DL, unsigned Depth=0)
Returns true if the given value is known be negative (i.e.
bool isKnownNonEqual(const Value *V1, const Value *V2, const DataLayout &DL, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true)
Return true if the given values are known to be non-equal when defined.
ConstantRange computeConstantRangeIncludingKnownBits(const WithCache< const Value * > &V, bool ForSigned, const SimplifyQuery &SQ)
Combine constant ranges from computeConstantRange() and computeKnownBits().
SelectPatternNaNBehavior
Behavior when a floating point min/max is given one NaN and one non-NaN as input.
@ SPNB_RETURNS_NAN
NaN behavior not applicable.
@ SPNB_RETURNS_OTHER
Given one NaN input, returns the NaN.
@ SPNB_RETURNS_ANY
Given one NaN input, returns the non-NaN.
void computeKnownBits(const Value *V, KnownBits &Known, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true)
Determine which bits of V are known to be either zero or one and return them in the KnownZero/KnownOn...
DWARFExpression::Operation Op
bool isGuaranteedNotToBeUndefOrPoison(const Value *V, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, unsigned Depth=0)
Return true if this function can prove that V does not have undef bits and is never poison.
bool isSafeToSpeculativelyExecute(const Instruction *I, const Instruction *CtxI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr)
Return true if the instruction does not have any effects besides calculating the result and does not ...
constexpr unsigned BitWidth
SelectPatternResult matchDecomposedSelectPattern(CmpInst *CmpI, Value *TrueVal, Value *FalseVal, Value *&LHS, Value *&RHS, Instruction::CastOps *CastOp=nullptr, unsigned Depth=0)
Determine the pattern that a select with the given compare as its predicate and given values as its t...
OverflowResult computeOverflowForUnsignedSub(const Value *LHS, const Value *RHS, const SimplifyQuery &SQ)
bool isGuaranteedToTransferExecutionToSuccessor(const Instruction *I)
Return true if this function can prove that the instruction I will always transfer execution to one o...
gep_type_iterator gep_type_begin(const User *GEP)
std::pair< Value *, FPClassTest > fcmpToClassTest(CmpInst::Predicate Pred, const Function &F, Value *LHS, Value *RHS, bool LookThroughSrc=true)
Returns a pair of values, which if passed to llvm.is.fpclass, returns the same result as an fcmp with...
Value * isBytewiseValue(Value *V, const DataLayout &DL)
If the specified value can be set by repeating the same byte in memory, return the i8 value that it i...
bool is_contained(R &&Range, const E &Element)
Returns true if Element is found in Range.
unsigned ComputeNumSignBits(const Value *Op, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true)
Return the number of times the sign bit of the register is replicated into the other bits.
OverflowResult computeOverflowForUnsignedAdd(const WithCache< const Value * > &LHS, const WithCache< const Value * > &RHS, const SimplifyQuery &SQ)
unsigned Log2(Align A)
Returns the log2 of the alignment.
std::optional< bool > isImpliedByDomCondition(const Value *Cond, const Instruction *ContextI, const DataLayout &DL)
Return the boolean condition value in the context of the given instruction if it is known based on do...
bool isGEPBasedOnPointerToString(const GEPOperator *GEP, unsigned CharSize=8)
Returns true if the GEP is based on a pointer to a string (array of.
bool isGuaranteedNotToBePoison(const Value *V, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, unsigned Depth=0)
Returns true if V cannot be poison, but may be undef.
KnownFPClass computeKnownFPClass(const Value *V, const APInt &DemandedElts, FPClassTest InterestedClasses, unsigned Depth, const SimplifyQuery &SQ)
Determine which floating-point classes are valid for V, and return them in KnownFPClass bit sets.
void computeKnownBitsFromRangeMetadata(const MDNode &Ranges, KnownBits &Known)
Compute known bits from the range metadata.
Value * FindInsertedValue(Value *V, ArrayRef< unsigned > idx_range, std::optional< BasicBlock::iterator > InsertBefore=std::nullopt)
Given an aggregate and an sequence of indices, see if the scalar value indexed is already around as a...
bool isKnownNegation(const Value *X, const Value *Y, bool NeedNSW=false, bool AllowPoison=true)
Return true if the two given values are negation.
bool isKnownPositive(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Returns true if the given value is known be positive (i.e.
Constant * ConstantFoldIntegerCast(Constant *C, Type *DestTy, bool IsSigned, const DataLayout &DL)
Constant fold a zext, sext or trunc, depending on IsSigned and whether the DestTy is wider or narrowe...
bool isKnownNonNegative(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Returns true if the give value is known to be non-negative.
unsigned ComputeMaxSignificantBits(const Value *Op, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
Get the upper bound on bit size for this Value Op as a signed integer.
bool mayHaveNonDefUseDependency(const Instruction &I)
Returns true if the result or effects of the given instructions I depend values not reachable through...
bool isIdentifiedObject(const Value *V)
Return true if this pointer refers to a distinct and identifiable object.
std::optional< bool > isImpliedCondition(const Value *LHS, const Value *RHS, const DataLayout &DL, bool LHSIsTrue=true, unsigned Depth=0)
Return true if RHS is known to be implied true by LHS.
void findValuesAffectedByCondition(Value *Cond, bool IsAssume, function_ref< void(Value *)> InsertAffected)
Call InsertAffected on all Values whose known bits / value may be affected by the condition Cond.
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
static unsigned int semanticsPrecision(const fltSemantics &)
static bool isRepresentableAsNormalIn(const fltSemantics &Src, const fltSemantics &Dst)
This struct is a compact representation of a valid (non-zero power of two) alignment.
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