42#define DEBUG_TYPE "instcombine"
50 bool IsSigned =
false) {
53 Result = In1.
sadd_ov(In2, Overflow);
55 Result = In1.
uadd_ov(In2, Overflow);
63 bool IsSigned =
false) {
66 Result = In1.
ssub_ov(In2, Overflow);
68 Result = In1.
usub_ov(In2, Overflow);
76 for (
auto *U :
I.users())
98 }
else if (
C.isAllOnes()) {
126 if (LI->
isVolatile() || !GV || !GV->isConstant() ||
127 !GV->hasDefinitiveInitializer())
131 TypeSize EltSize =
DL.getTypeStoreSize(EltTy);
147 if (!ConstOffset.
ult(Stride))
169 uint64_t ArrayElementCount =
172 if (ArrayElementCount >
CLOpts.maxarray_size)
175 enum { Overdefined = -3, Undefined = -2 };
184 int FirstTrueElement = Undefined, SecondTrueElement = Undefined;
188 int FirstFalseElement = Undefined, SecondFalseElement = Undefined;
196 int TrueRangeEnd = Undefined, FalseRangeEnd = Undefined;
201 uint64_t MagicBitvector = 0;
205 for (
unsigned i = 0, e = ArrayElementCount; i != e; ++i,
Offset += Stride) {
226 if (TrueRangeEnd == (
int)i - 1)
228 if (FalseRangeEnd == (
int)i - 1)
245 if (FirstTrueElement == Undefined)
246 FirstTrueElement = TrueRangeEnd = i;
249 if (SecondTrueElement == Undefined)
250 SecondTrueElement = i;
252 SecondTrueElement = Overdefined;
255 if (TrueRangeEnd == (
int)i - 1)
258 TrueRangeEnd = Overdefined;
262 if (FirstFalseElement == Undefined)
263 FirstFalseElement = FalseRangeEnd = i;
266 if (SecondFalseElement == Undefined)
267 SecondFalseElement = i;
269 SecondFalseElement = Overdefined;
272 if (FalseRangeEnd == (
int)i - 1)
275 FalseRangeEnd = Overdefined;
280 if (i < 64 && IsTrueForElt)
281 MagicBitvector |= 1ULL << i;
285 if (i >= 64 && SecondTrueElement == Overdefined &&
286 SecondFalseElement == Overdefined && TrueRangeEnd == Overdefined &&
287 FalseRangeEnd == Overdefined)
302 auto MaskIdx = [&](
Value *Idx) {
307 Idx =
Builder.CreateAnd(Idx, Mask);
314 if (SecondTrueElement != Overdefined) {
317 if (FirstTrueElement == Undefined)
320 Value *FirstTrueIdx = ConstantInt::get(Idx->getType(), FirstTrueElement);
323 if (SecondTrueElement == Undefined)
328 Value *SecondTrueIdx = ConstantInt::get(Idx->getType(), SecondTrueElement);
330 return BinaryOperator::CreateOr(
C1, C2);
335 if (SecondFalseElement != Overdefined) {
338 if (FirstFalseElement == Undefined)
341 Value *FirstFalseIdx = ConstantInt::get(Idx->getType(), FirstFalseElement);
344 if (SecondFalseElement == Undefined)
349 Value *SecondFalseIdx =
350 ConstantInt::get(Idx->getType(), SecondFalseElement);
352 return BinaryOperator::CreateAnd(
C1, C2);
357 if (TrueRangeEnd != Overdefined) {
358 assert(TrueRangeEnd != FirstTrueElement &&
"Should emit single compare");
362 if (FirstTrueElement) {
364 Idx =
Builder.CreateAdd(Idx, Offs);
368 ConstantInt::get(Idx->getType(), TrueRangeEnd - FirstTrueElement + 1);
373 if (FalseRangeEnd != Overdefined) {
374 assert(FalseRangeEnd != FirstFalseElement &&
"Should emit single compare");
377 if (FirstFalseElement) {
379 Idx =
Builder.CreateAdd(Idx, Offs);
383 ConstantInt::get(Idx->getType(), FalseRangeEnd - FirstFalseElement);
396 if (ArrayElementCount <= Idx->
getType()->getIntegerBitWidth())
399 Ty =
DL.getSmallestLegalIntType(
Init->getContext(), ArrayElementCount);
404 V =
Builder.CreateLShr(ConstantInt::get(Ty, MagicBitvector), V);
405 V =
Builder.CreateAnd(ConstantInt::get(Ty, 1), V);
430 while (!WorkList.
empty()) {
433 while (!WorkList.
empty()) {
434 if (Explored.
size() >= 100)
452 if (!
GEP->isInBounds() ||
count_if(
GEP->indices(), IsNonConst) > 1)
460 if (WorkList.
back() ==
V) {
476 for (
auto *PN : PHIs)
477 for (
Value *
Op : PN->incoming_values())
485 for (
Value *Val : Explored) {
491 if (Inst ==
Base || Inst ==
PHI || !Inst || !
PHI ||
495 if (
PHI->getParent() == Inst->getParent())
505 bool Before =
true) {
513 I = &*std::next(
I->getIterator());
514 Builder.SetInsertPoint(
I);
519 BasicBlock &Entry =
A->getParent()->getEntryBlock();
520 Builder.SetInsertPoint(Entry.getFirstInsertionPt());
542 Base->getContext(),
DL.getIndexTypeSizeInBits(Start->getType()));
548 for (
Value *Val : Explored) {
556 PHI->getName() +
".idx",
PHI->getIterator());
561 for (
Value *Val : Explored) {
570 NewInsts[
GEP] = OffsetV;
572 NewInsts[
GEP] = Builder.CreateAdd(
573 Op, OffsetV,
GEP->getOperand(0)->getName() +
".add",
585 for (
Value *Val : Explored) {
592 for (
unsigned I = 0,
E =
PHI->getNumIncomingValues();
I <
E; ++
I) {
593 Value *NewIncoming =
PHI->getIncomingValue(
I);
595 auto It = NewInsts.
find(NewIncoming);
596 if (It != NewInsts.
end())
597 NewIncoming = It->second;
604 for (
Value *Val : Explored) {
610 Value *NewVal = Builder.CreateGEP(Builder.getInt8Ty(),
Base, NewInsts[Val],
611 Val->getName() +
".ptr", NW);
618 return NewInsts[Start];
704 if (
Base.Ptr == RHS && CanFold(
Base.LHSNW) && !
Base.isExpensive()) {
708 EmitGEPOffsets(
Base.LHSGEPs,
Base.LHSNW, IdxTy,
true);
716 RHS->getType()->getPointerAddressSpace())) {
747 if (GEPLHS->
getOperand(0) != GEPRHS->getOperand(0)) {
748 bool IndicesTheSame =
751 GEPRHS->getPointerOperand()->getType() &&
755 if (GEPLHS->
getOperand(i) != GEPRHS->getOperand(i)) {
756 IndicesTheSame =
false;
762 if (IndicesTheSame &&
770 if (GEPLHS->
isInBounds() && GEPRHS->isInBounds() &&
772 (GEPRHS->hasAllConstantIndices() || GEPRHS->hasOneUse()) &&
776 Value *LOffset = EmitGEPOffset(GEPLHS);
777 Value *ROffset = EmitGEPOffset(GEPRHS);
784 if (LHSIndexTy != RHSIndexTy) {
787 ROffset =
Builder.CreateTrunc(ROffset, LHSIndexTy);
789 LOffset =
Builder.CreateTrunc(LOffset, RHSIndexTy);
798 if (GEPLHS->
getOperand(0) == GEPRHS->getOperand(0) &&
802 unsigned NumDifferences = 0;
803 unsigned DiffOperand = 0;
804 for (
unsigned i = 1, e = GEPRHS->getNumOperands(); i != e; ++i)
805 if (GEPLHS->
getOperand(i) != GEPRHS->getOperand(i)) {
807 Type *RHSType = GEPRHS->getOperand(i)->getType();
818 if (NumDifferences++)
823 if (NumDifferences == 0)
831 Value *RHSV = GEPRHS->getOperand(DiffOperand);
832 return NewICmp(NW, LHSV, RHSV);
836 if (
Base.Ptr && !
Base.isExpensive()) {
838 bool DoFold = CanFold(
Base.LHSNW &
Base.RHSNW);
840 if (!DoFold &&
Base.Ptr->getType()->isPointerTy()) {
844 unsigned BW =
DL.getIndexTypeSizeInBits(GEPLHS->
getType());
849 DL, LOff,
true) ==
Base.Ptr &&
850 RHS->stripAndAccumulateConstantOffsets(
851 DL, ROff,
true) ==
Base.Ptr)
863 return NewICmp(
Base.LHSNW &
Base.RHSNW, L, R);
890 bool Captured =
false;
895 CmpCaptureTracker(
AllocaInst *Alloca) : Alloca(Alloca) {}
897 void tooManyUses()
override { Captured =
true; }
909 ICmps[ICmp] |= 1u << U->getOperandNo();
918 CmpCaptureTracker Tracker(Alloca);
920 if (Tracker.Captured)
924 for (
auto [ICmp,
Operands] : Tracker.ICmps) {
930 auto *Res = ConstantInt::get(ICmp->getType(),
956 assert(!!
C &&
"C should not be zero!");
972 ConstantInt::get(
X->getType(), -
C));
984 ConstantInt::get(
X->getType(),
SMax -
C));
995 ConstantInt::get(
X->getType(),
SMax - (
C - 1)));
1004 assert(
I.isEquality() &&
"Cannot fold icmp gt/lt");
1007 if (
I.getPredicate() ==
I.ICMP_NE)
1009 return new ICmpInst(Pred, LHS, RHS);
1028 return getICmp(
I.ICMP_UGT,
A,
1029 ConstantInt::get(
A->getType(), AP2.
logBase2()));
1041 if (IsAShr && AP1 == AP2.
ashr(Shift)) {
1045 return getICmp(
I.ICMP_UGE,
A, ConstantInt::get(
A->getType(), Shift));
1046 return getICmp(
I.ICMP_EQ,
A, ConstantInt::get(
A->getType(), Shift));
1047 }
else if (AP1 == AP2.
lshr(Shift)) {
1048 return getICmp(
I.ICMP_EQ,
A, ConstantInt::get(
A->getType(), Shift));
1054 auto *TorF = ConstantInt::get(
I.getType(),
I.getPredicate() ==
I.ICMP_NE);
1063 assert(
I.isEquality() &&
"Cannot fold icmp gt/lt");
1066 if (
I.getPredicate() ==
I.ICMP_NE)
1068 return new ICmpInst(Pred, LHS, RHS);
1077 if (!AP1 && AP2TrailingZeros != 0)
1080 ConstantInt::get(
A->getType(), AP2.
getBitWidth() - AP2TrailingZeros));
1088 if (Shift > 0 && AP2.
shl(Shift) == AP1)
1089 return getICmp(
I.ICMP_EQ,
A, ConstantInt::get(
A->getType(), Shift));
1093 auto *TorF = ConstantInt::get(
I.getType(),
I.getPredicate() ==
I.ICMP_NE);
1122 if (NewWidth != 7 && NewWidth != 15 && NewWidth != 31)
1146 if (U == AddWithCst)
1164 I.getModule(), Intrinsic::sadd_with_overflow, NewType);
1172 Value *TruncA = Builder.CreateTrunc(
A, NewType,
A->getName() +
".trunc");
1173 Value *TruncB = Builder.CreateTrunc(
B, NewType,
B->getName() +
".trunc");
1174 CallInst *
Call = Builder.CreateCall(
F, {TruncA, TruncB},
"sadd");
1175 Value *
Add = Builder.CreateExtractValue(
Call, 0,
"sadd.result");
1193 if (!
I.isEquality())
1224 APInt(XBitWidth, XBitWidth - 1))))
1251 return new ICmpInst(Pred,
B, Cmp.getOperand(1));
1253 return new ICmpInst(Pred,
A, Cmp.getOperand(1));
1270 return new ICmpInst(Pred,
X, Cmp.getOperand(1));
1282 return new ICmpInst(Pred,
Y, Cmp.getOperand(1));
1288 return new ICmpInst(Pred,
X, Cmp.getOperand(1));
1291 if (BO0->hasNoUnsignedWrap() || BO0->hasNoSignedWrap()) {
1299 return new ICmpInst(Pred,
Y, Cmp.getOperand(1));
1304 return new ICmpInst(Pred,
X, Cmp.getOperand(1));
1320 return new ICmpInst(Pred, Stripped,
1333 const APInt *Mask, *Neg;
1349 auto *NewAnd =
Builder.CreateAnd(Num, *Mask);
1373 Value *Op0 = Cmp.getOperand(0), *Op1 = Cmp.getOperand(1);
1389 for (
Value *V : Phi->incoming_values()) {
1397 PHINode *NewPhi =
Builder.CreatePHI(Cmp.getType(), Phi->getNumOperands());
1398 for (
auto [V, Pred] :
zip(
Ops, Phi->blocks()))
1413 Value *
X = Cmp.getOperand(0), *
Y = Cmp.getOperand(1);
1446 if (Cmp.isEquality() || (IsSignBit &&
hasBranchUse(Cmp)))
1451 if (Cmp.hasOneUse() &&
1465 if (!
match(BI->getCondition(),
1470 if (
DT.dominates(Edge0, Cmp.getParent())) {
1471 if (
auto *V = handleDomCond(DomPred, DomC))
1475 if (
DT.dominates(Edge1, Cmp.getParent()))
1491 Type *SrcTy =
X->getType();
1493 SrcBits = SrcTy->getScalarSizeInBits();
1497 if (shouldChangeType(Trunc->
getType(), SrcTy)) {
1499 return new ICmpInst(Pred,
X, ConstantInt::get(SrcTy,
C.sext(SrcBits)));
1501 return new ICmpInst(Pred,
X, ConstantInt::get(SrcTy,
C.zext(SrcBits)));
1504 if (
C.isOne() &&
C.getBitWidth() > 1) {
1509 ConstantInt::get(V->getType(), 1));
1521 auto NewPred = (Pred == Cmp.ICMP_EQ) ? Cmp.ICMP_UGE : Cmp.ICMP_ULT;
1523 ConstantInt::get(SrcTy, DstBits - Pow2->
logBase2()));
1529 Pred,
Y, ConstantInt::get(SrcTy,
C.logBase2() - Pow2->
logBase2()));
1535 if (!SrcTy->isVectorTy() && shouldChangeType(DstBits, SrcBits)) {
1539 Constant *WideC = ConstantInt::get(SrcTy,
C.zext(SrcBits));
1548 if ((
Known.Zero |
Known.One).countl_one() >= SrcBits - DstBits) {
1550 APInt NewRHS =
C.zext(SrcBits);
1552 return new ICmpInst(Pred,
X, ConstantInt::get(SrcTy, NewRHS));
1564 DstBits == SrcBits - ShAmt) {
1581 bool YIsSExt =
false;
1584 unsigned NoWrapFlags =
cast<TruncInst>(Cmp.getOperand(0))->getNoWrapKind() &
1586 if (Cmp.isSigned()) {
1597 if (
X->getType() !=
Y->getType() &&
1598 (!Cmp.getOperand(0)->hasOneUse() || !Cmp.getOperand(1)->hasOneUse()))
1600 if (!isDesirableIntType(
X->getType()->getScalarSizeInBits()) &&
1601 isDesirableIntType(
Y->getType()->getScalarSizeInBits())) {
1603 Pred = Cmp.getSwappedPredicate(Pred);
1608 else if (!Cmp.isSigned() &&
1622 Type *TruncTy = Cmp.getOperand(0)->getType();
1627 if (isDesirableIntType(TruncBits) &&
1628 !isDesirableIntType(
X->getType()->getScalarSizeInBits()))
1651 bool TrueIfSigned =
false;
1668 if (
Xor->hasOneUse()) {
1670 if (!Cmp.isEquality() && XorC->
isSignMask()) {
1671 Pred = Cmp.getFlippedSignednessPredicate();
1672 return new ICmpInst(Pred,
X, ConstantInt::get(
X->getType(),
C ^ *XorC));
1677 Pred = Cmp.getFlippedSignednessPredicate();
1678 Pred = Cmp.getSwappedPredicate(Pred);
1679 return new ICmpInst(Pred,
X, ConstantInt::get(
X->getType(),
C ^ *XorC));
1686 if (*XorC == ~
C && (
C + 1).isPowerOf2())
1689 if (*XorC ==
C && (
C + 1).isPowerOf2())
1694 if (*XorC == -
C &&
C.isPowerOf2())
1696 ConstantInt::get(
X->getType(), ~
C));
1698 if (*XorC ==
C && (-
C).isPowerOf2())
1700 ConstantInt::get(
X->getType(), ~
C));
1722 const APInt *ShiftC;
1727 Type *XType =
X->getType();
1733 return new ICmpInst(Pred,
Add, ConstantInt::get(XType, Bound));
1742 if (!Shift || !Shift->
isShift())
1750 unsigned ShiftOpcode = Shift->
getOpcode();
1751 bool IsShl = ShiftOpcode == Instruction::Shl;
1754 APInt NewAndCst, NewCmpCst;
1755 bool AnyCmpCstBitsShiftedOut;
1756 if (ShiftOpcode == Instruction::Shl) {
1761 if (Cmp.isSigned() && (C2.
isNegative() ||
C1.isNegative()))
1764 NewCmpCst =
C1.lshr(*C3);
1765 NewAndCst = C2.
lshr(*C3);
1766 AnyCmpCstBitsShiftedOut = NewCmpCst.
shl(*C3) !=
C1;
1767 }
else if (ShiftOpcode == Instruction::LShr) {
1772 NewCmpCst =
C1.shl(*C3);
1773 NewAndCst = C2.
shl(*C3);
1774 AnyCmpCstBitsShiftedOut = NewCmpCst.
lshr(*C3) !=
C1;
1780 assert(ShiftOpcode == Instruction::AShr &&
"Unknown shift opcode");
1781 NewCmpCst =
C1.shl(*C3);
1782 NewAndCst = C2.
shl(*C3);
1783 AnyCmpCstBitsShiftedOut = NewCmpCst.
ashr(*C3) !=
C1;
1784 if (NewAndCst.
ashr(*C3) != C2)
1788 if (AnyCmpCstBitsShiftedOut) {
1798 Shift->
getOperand(0), ConstantInt::get(
And->getType(), NewAndCst));
1799 return new ICmpInst(Cmp.getPredicate(), NewAnd,
1800 ConstantInt::get(
And->getType(), NewCmpCst));
1807 if (Shift->
hasOneUse() &&
C1.isZero() && Cmp.isEquality() &&
1817 return new ICmpInst(Cmp.getPredicate(), NewAnd, Cmp.getOperand(1));
1831 return new TruncInst(
And->getOperand(0), Cmp.getType());
1842 ConstantInt::get(
X->getType(), ~*C2));
1847 ConstantInt::get(
X->getType(), -*C2));
1850 if (!
And->hasOneUse())
1853 if (Cmp.isEquality() &&
C1.isZero()) {
1871 Constant *NegBOC = ConstantInt::get(
And->getType(), -NewC2);
1873 return new ICmpInst(NewPred,
X, NegBOC);
1887 (Cmp.isEquality() || (!
C1.isNegative() && !C2->
isNegative()))) {
1891 if (!Cmp.getType()->isVectorTy()) {
1892 Type *WideType = W->getType();
1894 Constant *ZextC1 = ConstantInt::get(WideType,
C1.zext(WideScalarBits));
1895 Constant *ZextC2 = ConstantInt::get(WideType, C2->
zext(WideScalarBits));
1897 return new ICmpInst(Cmp.getPredicate(), NewAnd, ZextC1);
1908 if (!Cmp.isSigned() &&
C1.isZero() &&
And->getOperand(0)->hasOneUse() &&
1915 unsigned UsesRemoved = 0;
1916 if (
And->hasOneUse())
1918 if (
Or->hasOneUse())
1925 if (UsesRemoved >= RequireUsesRemoved) {
1929 One,
Or->getName());
1931 return new ICmpInst(Cmp.getPredicate(), NewAnd, Cmp.getOperand(1));
1945 if (!Cmp.getParent()->getParent()->hasFnAttribute(
1946 Attribute::NoImplicitFloat) &&
1949 Type *FPType = V->getType()->getScalarType();
1950 if (FPType->isIEEELikeFPTy() && (
C1.isZero() ||
C1 == *C2)) {
1951 APInt ExponentMask =
1953 if (*C2 == ExponentMask) {
1954 unsigned Mask =
C1.isZero()
1988 Constant *MinSignedC = ConstantInt::get(
1992 return new ICmpInst(NewPred,
X, MinSignedC);
2008 if (!Cmp.isEquality())
2018 if (
C.getBitWidth() > 1 && (
C.isZero() ||
C.isOne()) &&
2022 return new ICmpInst(Pred, MatchedX, Cmp.getOperand(1));
2026 return new TruncInst(MatchedX, Cmp.getType());
2030 if (
And->hasOneUse()) {
2031 Value *Trunc =
Builder.CreateTrunc(MatchedX, Cmp.getType());
2039 if (Cmp.getOperand(1) ==
Y &&
C.isNegatedPowerOf2()) {
2050 X->getType()->isIntOrIntVectorTy(1) && (
C.isZero() ||
C.isOne())) {
2056 return BinaryOperator::CreateAnd(TruncY,
X);
2074 const APInt *Addend, *Msk;
2078 APInt NewComperand = (
C - *Addend) & *Msk;
2079 Value *MaskA =
Builder.CreateAnd(
A, ConstantInt::get(
A->getType(), *Msk));
2081 ConstantInt::get(MaskA->
getType(), NewComperand));
2103 while (!WorkList.
empty()) {
2104 auto MatchOrOperatorArgument = [&](
Value *OrOperatorArgument) {
2107 if (
match(OrOperatorArgument,
2113 if (
match(OrOperatorArgument,
2123 Value *OrOperatorLhs, *OrOperatorRhs;
2125 if (!
match(CurrentValue,
2130 MatchOrOperatorArgument(OrOperatorRhs);
2131 MatchOrOperatorArgument(OrOperatorLhs);
2137 CmpValues.
rbegin()->second);
2139 for (
auto It = CmpValues.
rbegin() + 1; It != CmpValues.
rend(); ++It) {
2140 Value *RhsCmp = Builder.CreateICmp(
Pred, It->first, It->second);
2141 LhsCmp = Builder.CreateBinOp(BOpc, LhsCmp, RhsCmp);
2157 ConstantInt::get(V->getType(), 1));
2160 Value *OrOp0 =
Or->getOperand(0), *OrOp1 =
Or->getOperand(1);
2167 Builder.CreateXor(OrOp1, ConstantInt::get(OrOp1->getType(),
C));
2168 return new ICmpInst(Pred, OrOp0, NewC);
2172 if (
match(OrOp1,
m_APInt(MaskC)) && Cmp.isEquality()) {
2173 if (*MaskC ==
C && (
C + 1).isPowerOf2()) {
2178 return new ICmpInst(Pred, OrOp0, OrOp1);
2185 if (
Or->hasOneUse()) {
2187 Constant *NewC = ConstantInt::get(
Or->getType(),
C ^ (*MaskC));
2199 Constant *NewC = ConstantInt::get(
X->getType(), TrueIfSigned ? 1 : 0);
2227 if (!Cmp.isEquality() || !
C.isZero() || !
Or->hasOneUse())
2258 if (
X ==
Mul->getOperand(1) && !Cmp.isSigned()) {
2260 bool IsSqr =
C == R * R;
2263 if (Cmp.isEquality() &&
2264 (
Mul->hasNoUnsignedWrap() || (
Mul->hasNoSignedWrap() &&
C.isZero()))) {
2272 return new ICmpInst(Pred,
X, ConstantInt::get(MulTy, R));
2277 if (
Mul->hasNoUnsignedWrap()) {
2280 return new ICmpInst(Pred,
X, ConstantInt::get(MulTy, R));
2294 return new ICmpInst(Cmp.getStrictPredicate(),
X,
2295 ConstantInt::get(MulTy, R));
2318 if (Cmp.isEquality()) {
2320 if (
Mul->hasNoSignedWrap() &&
C.srem(*MulC).isZero()) {
2321 Constant *NewC = ConstantInt::get(MulTy,
C.sdiv(*MulC));
2329 if (
C.urem(*MulC).isZero()) {
2332 if ((*MulC & 1).isOne() ||
Mul->hasNoUnsignedWrap()) {
2333 Constant *NewC = ConstantInt::get(MulTy,
C.udiv(*MulC));
2346 if (
C.isMinSignedValue() && MulC->
isAllOnes())
2352 NewC = ConstantInt::get(
2356 "Unexpected predicate");
2357 NewC = ConstantInt::get(
2362 NewC = ConstantInt::get(
2366 "Unexpected predicate");
2367 NewC = ConstantInt::get(
2372 return NewC ?
new ICmpInst(Pred,
X, NewC) :
nullptr;
2384 unsigned TypeBits =
C.getBitWidth();
2386 if (Cmp.isUnsigned()) {
2406 return new ICmpInst(
Pred,
Y, ConstantInt::get(ShiftType, CLog2));
2407 }
else if (Cmp.isSigned() && C2->
isOne()) {
2408 Constant *BitWidthMinusOne = ConstantInt::get(ShiftType, TypeBits - 1);
2429 const APInt *ShiftVal;
2459 const APInt *ShiftAmt;
2465 unsigned TypeBits =
C.getBitWidth();
2466 if (ShiftAmt->
uge(TypeBits))
2478 APInt ShiftedC =
C.ashr(*ShiftAmt);
2479 return new ICmpInst(Pred,
X, ConstantInt::get(ShType, ShiftedC));
2482 C.ashr(*ShiftAmt).shl(*ShiftAmt) ==
C) {
2483 APInt ShiftedC =
C.ashr(*ShiftAmt);
2484 return new ICmpInst(Pred,
X, ConstantInt::get(ShType, ShiftedC));
2491 assert(!
C.isMinSignedValue() &&
"Unexpected icmp slt");
2492 APInt ShiftedC = (
C - 1).ashr(*ShiftAmt) + 1;
2493 return new ICmpInst(Pred,
X, ConstantInt::get(ShType, ShiftedC));
2503 APInt ShiftedC =
C.lshr(*ShiftAmt);
2504 return new ICmpInst(Pred,
X, ConstantInt::get(ShType, ShiftedC));
2507 C.lshr(*ShiftAmt).shl(*ShiftAmt) ==
C) {
2508 APInt ShiftedC =
C.lshr(*ShiftAmt);
2509 return new ICmpInst(Pred,
X, ConstantInt::get(ShType, ShiftedC));
2516 assert(
C.ugt(0) &&
"ult 0 should have been eliminated");
2517 APInt ShiftedC = (
C - 1).lshr(*ShiftAmt) + 1;
2518 return new ICmpInst(Pred,
X, ConstantInt::get(ShType, ShiftedC));
2522 if (Cmp.isEquality() && Shl->
hasOneUse()) {
2528 Constant *LShrC = ConstantInt::get(ShType,
C.lshr(*ShiftAmt));
2533 bool TrueIfSigned =
false;
2545 if (Cmp.isUnsigned() && Shl->
hasOneUse()) {
2547 if ((
C + 1).isPowerOf2() &&
2555 if (
C.isPowerOf2() &&
2585 Pred, ConstantInt::get(ShType->
getContext(),
C))) {
2586 CmpPred = FlippedStrictness->first;
2594 ConstantInt::get(TruncTy, RHSC.
ashr(*ShiftAmt).
trunc(TypeBits - Amt));
2596 Builder.CreateTrunc(
X, TruncTy,
"",
false,
2613 if (Cmp.isEquality() && Shr->
isExact() &&
C.isZero())
2614 return new ICmpInst(Pred,
X, Cmp.getOperand(1));
2616 bool IsAShr = Shr->
getOpcode() == Instruction::AShr;
2617 const APInt *ShiftValC;
2619 if (Cmp.isEquality())
2637 assert(ShiftValC->
uge(
C) &&
"Expected simplify of compare");
2638 assert((IsUGT || !
C.isZero()) &&
"Expected X u< 0 to simplify");
2640 unsigned CmpLZ = IsUGT ?
C.countl_zero() : (
C - 1).
countl_zero();
2648 const APInt *ShiftAmtC;
2654 unsigned TypeBits =
C.getBitWidth();
2656 if (ShAmtVal >= TypeBits || ShAmtVal == 0)
2659 bool IsExact = Shr->
isExact();
2667 (
C - 1).isPowerOf2() &&
C.countLeadingZeros() > ShAmtVal) {
2673 APInt ShiftedC = (
C - 1).shl(ShAmtVal) + 1;
2674 return new ICmpInst(Pred,
X, ConstantInt::get(ShrTy, ShiftedC));
2680 APInt ShiftedC =
C.shl(ShAmtVal);
2681 if (ShiftedC.
ashr(ShAmtVal) ==
C)
2682 return new ICmpInst(Pred,
X, ConstantInt::get(ShrTy, ShiftedC));
2686 APInt ShiftedC = (
C + 1).shl(ShAmtVal) - 1;
2687 if (!
C.isMaxSignedValue() && !(
C + 1).shl(ShAmtVal).isMinSignedValue() &&
2688 (ShiftedC + 1).ashr(ShAmtVal) == (
C + 1))
2689 return new ICmpInst(Pred,
X, ConstantInt::get(ShrTy, ShiftedC));
2695 APInt ShiftedC = (
C + 1).shl(ShAmtVal) - 1;
2696 if ((ShiftedC + 1).ashr(ShAmtVal) == (
C + 1) ||
2697 (
C + 1).shl(ShAmtVal).isMinSignedValue())
2698 return new ICmpInst(Pred,
X, ConstantInt::get(ShrTy, ShiftedC));
2705 if (
C.getBitWidth() > 2 &&
C.getNumSignBits() <= ShAmtVal) {
2715 }
else if (!IsAShr) {
2719 APInt ShiftedC =
C.shl(ShAmtVal);
2720 if (ShiftedC.
lshr(ShAmtVal) ==
C)
2721 return new ICmpInst(Pred,
X, ConstantInt::get(ShrTy, ShiftedC));
2725 APInt ShiftedC = (
C + 1).shl(ShAmtVal) - 1;
2726 if ((ShiftedC + 1).lshr(ShAmtVal) == (
C + 1))
2727 return new ICmpInst(Pred,
X, ConstantInt::get(ShrTy, ShiftedC));
2731 if (!Cmp.isEquality())
2739 assert(((IsAShr &&
C.shl(ShAmtVal).ashr(ShAmtVal) ==
C) ||
2740 (!IsAShr &&
C.shl(ShAmtVal).lshr(ShAmtVal) ==
C)) &&
2741 "Expected icmp+shr simplify did not occur.");
2746 return new ICmpInst(Pred,
X, ConstantInt::get(ShrTy,
C << ShAmtVal));
2752 Constant *Mask = ConstantInt::get(ShrTy, Val);
2754 return new ICmpInst(Pred,
And, ConstantInt::get(ShrTy,
C << ShAmtVal));
2771 const APInt *DivisorC;
2780 "ult X, 0 should have been simplified already.");
2785 if (!NormalizedC.
uge(DivisorC->
abs() - 1))
2808 const APInt *DivisorC;
2817 !
C.isStrictlyPositive()))
2823 Constant *MaskC = ConstantInt::get(Ty, SignMask | (*DivisorC - 1));
2827 return new ICmpInst(Pred,
And, ConstantInt::get(Ty,
C));
2854 assert(*C2 != 0 &&
"udiv 0, X should have been simplified already.");
2859 "icmp ugt X, UINT_MAX should have been simplified already.");
2861 ConstantInt::get(Ty, C2->
udiv(
C + 1)));
2866 assert(
C != 0 &&
"icmp ult X, 0 should have been simplified already.");
2868 ConstantInt::get(Ty, C2->
udiv(
C)));
2882 bool DivIsSigned = Div->
getOpcode() == Instruction::SDiv;
2892 if (Cmp.isEquality() && Div->
hasOneUse() &&
C.isSignBitSet() &&
2893 (!DivIsSigned ||
C.isMinSignedValue())) {
2894 Value *XBig =
Builder.CreateICmp(Pred,
X, ConstantInt::get(Ty,
C));
2895 Value *YOne =
Builder.CreateICmp(Pred,
Y, ConstantInt::get(Ty, 1));
2921 if (!Cmp.isEquality() && DivIsSigned != Cmp.isSigned()) {
2925 DivIsSigned =
false;
2944 bool ProdOV = (DivIsSigned ? Prod.
sdiv(*C2) : Prod.
udiv(*C2)) !=
C;
2957 int LoOverflow = 0, HiOverflow = 0;
2958 APInt LoBound, HiBound;
2963 HiOverflow = LoOverflow = ProdOV;
2972 LoBound = -(RangeSize - 1);
2973 HiBound = RangeSize;
2974 }
else if (
C.isStrictlyPositive()) {
2976 HiOverflow = LoOverflow = ProdOV;
2982 LoOverflow = HiOverflow = ProdOV ? -1 : 0;
2984 APInt DivNeg = -RangeSize;
2985 LoOverflow =
addWithOverflow(LoBound, HiBound, DivNeg,
true) ? -1 : 0;
2993 LoBound = RangeSize + 1;
2994 HiBound = -RangeSize;
2995 if (HiBound == *C2) {
2999 }
else if (
C.isStrictlyPositive()) {
3002 HiOverflow = LoOverflow = ProdOV ? -1 : 0;
3008 LoOverflow = HiOverflow = ProdOV;
3021 if (LoOverflow && HiOverflow)
3025 X, ConstantInt::get(Ty, LoBound));
3028 X, ConstantInt::get(Ty, HiBound));
3032 if (LoOverflow && HiOverflow)
3036 X, ConstantInt::get(Ty, LoBound));
3039 X, ConstantInt::get(Ty, HiBound));
3044 if (LoOverflow == +1)
3046 if (LoOverflow == -1)
3048 return new ICmpInst(Pred,
X, ConstantInt::get(Ty, LoBound));
3051 if (HiOverflow == +1)
3053 if (HiOverflow == -1)
3095 bool HasNSW =
Sub->hasNoSignedWrap();
3096 bool HasNUW =
Sub->hasNoUnsignedWrap();
3098 ((Cmp.isUnsigned() && HasNUW) || (Cmp.isSigned() && HasNSW)) &&
3100 return new ICmpInst(SwappedPred,
Y, ConstantInt::get(Ty, SubResult));
3108 if (Cmp.isEquality() &&
C.isZero() &&
3109 none_of((
Sub->users()), [](
const User *U) { return isa<PHINode>(U); }))
3117 if (!
Sub->hasOneUse())
3120 if (
Sub->hasNoSignedWrap()) {
3144 (*C2 & (
C - 1)) == (
C - 1))
3157 return new ICmpInst(SwappedPred,
Add, ConstantInt::get(Ty, ~
C));
3163 auto FoldConstant = [&](
bool Val) {
3164 Constant *Res = Val ? Builder.getTrue() : Builder.getFalse();
3171 switch (
Table.to_ulong()) {
3173 return FoldConstant(
false);
3175 return HasOneUse ? Builder.CreateNot(Builder.CreateOr(Op0, Op1)) :
nullptr;
3177 return HasOneUse ? Builder.CreateAnd(Builder.CreateNot(Op0), Op1) :
nullptr;
3179 return Builder.CreateNot(Op0);
3181 return HasOneUse ? Builder.CreateAnd(Op0, Builder.CreateNot(Op1)) :
nullptr;
3183 return Builder.CreateNot(Op1);
3185 return Builder.CreateXor(Op0, Op1);
3187 return HasOneUse ? Builder.CreateNot(Builder.CreateAnd(Op0, Op1)) :
nullptr;
3189 return Builder.CreateAnd(Op0, Op1);
3191 return HasOneUse ? Builder.CreateNot(Builder.CreateXor(Op0, Op1)) :
nullptr;
3195 return HasOneUse ? Builder.CreateOr(Builder.CreateNot(Op0), Op1) :
nullptr;
3199 return HasOneUse ? Builder.CreateOr(Op0, Builder.CreateNot(Op1)) :
nullptr;
3201 return Builder.CreateOr(Op0, Op1);
3203 return FoldConstant(
true);
3218 Cmp.getType() !=
A->getType() || Cmp.getType() !=
B->getType())
3221 std::bitset<4>
Table;
3222 auto ComputeTable = [&](
bool First,
bool Second) -> std::optional<bool> {
3226 auto *Val = Res->getType()->isVectorTy() ? Res->getSplatValue() : Res;
3230 return std::nullopt;
3233 for (
unsigned I = 0;
I < 4; ++
I) {
3234 bool First = (
I >> 1) & 1;
3235 bool Second =
I & 1;
3236 if (
auto Res = ComputeTable(
First, Second))
3258 const APInt *ShAmtC;
3266 return new ICmpInst(Pred,
A, ConstantInt::get(
A->getType(),
C));
3278 if (
Add->hasNoUnsignedWrap() &&
3281 APInt NewC =
C.usub_ov(*C2, Overflow);
3285 return new ICmpInst(Pred,
X, ConstantInt::get(Ty, NewC));
3290 if (
Add->hasNoSignedWrap() &&
3293 APInt NewC =
C.ssub_ov(*C2, Overflow);
3297 return new ICmpInst(ChosenPred,
X, ConstantInt::get(Ty, NewC));
3301 C.isNonNegative() && (
C - *C2).isNonNegative() &&
3304 .isAllNonNegative())
3306 ConstantInt::get(Ty,
C - *C2));
3311 if (Cmp.isSigned()) {
3312 if (
Lower.isSignMask())
3314 if (
Upper.isSignMask())
3317 if (
Lower.isMinValue())
3319 if (
Upper.isMinValue())
3352 if (!
Add->hasOneUse())
3367 ConstantInt::get(Ty,
C * 2));
3381 Builder.CreateAdd(
X, ConstantInt::get(Ty, *C2 -
C - 1)),
3382 ConstantInt::get(Ty, ~
C));
3387 Type *NewCmpTy = V->getType();
3389 if (shouldChangeType(Ty, NewCmpTy)) {
3400 :
Builder.CreateAdd(V, ConstantInt::get(NewCmpTy, EquivOffset)),
3401 ConstantInt::get(NewCmpTy, EquivInt));
3423 Value *EqualVal =
SI->getTrueValue();
3424 Value *UnequalVal =
SI->getFalseValue();
3447 auto FlippedStrictness =
3449 if (!FlippedStrictness)
3452 "basic correctness failure");
3453 RHS2 = FlippedStrictness->second;
3465 assert(
C &&
"Cmp RHS should be a constant int!");
3471 Value *OrigLHS, *OrigRHS;
3472 ConstantInt *C1LessThan, *C2Equal, *C3GreaterThan;
3473 if (Cmp.hasOneUse() &&
3476 assert(C1LessThan && C2Equal && C3GreaterThan);
3479 C1LessThan->
getValue(),
C->getValue(), Cmp.getPredicate());
3481 Cmp.getPredicate());
3483 C3GreaterThan->
getValue(),
C->getValue(), Cmp.getPredicate());
3494 if (TrueWhenLessThan)
3500 if (TrueWhenGreaterThan)
3515 Value *Op1 = Cmp.getOperand(1);
3516 Value *BCSrcOp = Bitcast->getOperand(0);
3517 Type *SrcType = Bitcast->getSrcTy();
3518 Type *DstType = Bitcast->getType();
3522 if (SrcType->isVectorTy() == DstType->isVectorTy() &&
3523 SrcType->getScalarSizeInBits() == DstType->getScalarSizeInBits()) {
3538 return new ICmpInst(Pred,
X, ConstantInt::get(
X->getType(), 1));
3565 Type *XType =
X->getType();
3568 if (!(XType->
isPPC_FP128Ty() || SrcType->isPPC_FP128Ty())) {
3583 Type *FPType = SrcType->getScalarType();
3584 if (!Cmp.getParent()->getParent()->hasFnAttribute(
3585 Attribute::NoImplicitFloat) &&
3586 Cmp.isEquality() && FPType->isIEEELikeFPTy()) {
3592 Builder.createIsFPClass(BCSrcOp, Mask));
3615 if (!
match(Cmp.getOperand(1),
m_APInt(
C)) || !DstType->isIntegerTy() ||
3616 !SrcType->isIntOrIntVectorTy())
3626 if (Cmp.isEquality() &&
C->isAllOnes() && Bitcast->hasOneUse()) {
3627 if (
Value *NotBCSrcOp =
3629 Value *Cast =
Builder.CreateBitCast(NotBCSrcOp, DstType);
3638 if (Cmp.isEquality() &&
C->isZero() && Bitcast->hasOneUse() &&
3641 Type *NewType =
Builder.getIntNTy(VecTy->getPrimitiveSizeInBits());
3661 if (
C->isSplat(EltTy->getBitWidth())) {
3667 Value *Extract =
Builder.CreateExtractElement(Vec, Mask[0]);
3668 Value *NewC = ConstantInt::get(EltTy,
C->trunc(EltTy->getBitWidth()));
3669 return new ICmpInst(Pred, Extract, NewC);
3707 if (
match(Cmp.getOperand(0),
3713 bool ValidPred =
true;
3731 X->getType()->getScalarType()->getFltSemantics();
3734 if (!Exp.isNegative() && Exp.sle(MaxExp + 1) &&
3736 int ExpVal =
static_cast<int>(Exp.getSExtValue());
3741 ConstantFP::get(
X->getType(), CmpConst));
3750 Value *Cmp0 = Cmp.getOperand(0);
3752 if (
C->isZero() && Cmp.isEquality() && Cmp0->
hasOneUse() &&
3759 return new ICmpInst(Cmp.getPredicate(),
X,
Y);
3774 if (!Cmp.isEquality())
3783 case Instruction::SRem:
3794 case Instruction::Add: {
3801 }
else if (
C.isZero()) {
3804 if (
Value *NegVal = dyn_castNegVal(BOp1))
3805 return new ICmpInst(Pred, BOp0, NegVal);
3806 if (
Value *NegVal = dyn_castNegVal(BOp0))
3807 return new ICmpInst(Pred, NegVal, BOp1);
3816 return new ICmpInst(Pred, BOp0, Neg);
3821 case Instruction::Xor:
3826 }
else if (
C.isZero()) {
3828 return new ICmpInst(Pred, BOp0, BOp1);
3831 case Instruction::Or: {
3852 Cond->getType() == Cmp.getType()) {
3890 case Instruction::UDiv:
3891 case Instruction::SDiv:
3901 return new ICmpInst(Pred, BOp0, BOp1);
3904 Instruction::Mul, BO->
getOpcode() == Instruction::SDiv, BOp1,
3905 Cmp.getOperand(1), BO);
3909 return new ICmpInst(Pred, YC, BOp0);
3913 if (BO->
getOpcode() == Instruction::UDiv &&
C.isZero()) {
3916 return new ICmpInst(NewPred, BOp1, BOp0);
3930 "Non-ctpop intrin in ctpop fold");
3965 Type *Ty =
II->getType();
3969 switch (
II->getIntrinsicID()) {
3970 case Intrinsic::abs:
3973 if (
C.isZero() ||
C.isMinSignedValue())
3974 return new ICmpInst(Pred,
II->getArgOperand(0), ConstantInt::get(Ty,
C));
3977 case Intrinsic::bswap:
3979 return new ICmpInst(Pred,
II->getArgOperand(0),
3980 ConstantInt::get(Ty,
C.byteSwap()));
3982 case Intrinsic::bitreverse:
3984 return new ICmpInst(Pred,
II->getArgOperand(0),
3985 ConstantInt::get(Ty,
C.reverseBits()));
3987 case Intrinsic::ctlz:
3988 case Intrinsic::cttz: {
3991 return new ICmpInst(Pred,
II->getArgOperand(0),
3997 unsigned Num =
C.getLimitedValue(
BitWidth);
3999 bool IsTrailing =
II->getIntrinsicID() == Intrinsic::cttz;
4002 APInt Mask2 = IsTrailing
4006 ConstantInt::get(Ty, Mask2));
4011 case Intrinsic::ctpop: {
4014 bool IsZero =
C.isZero();
4016 return new ICmpInst(Pred,
II->getArgOperand(0),
4023 case Intrinsic::fshl:
4024 case Intrinsic::fshr:
4025 if (
II->getArgOperand(0) ==
II->getArgOperand(1)) {
4026 const APInt *RotAmtC;
4030 return new ICmpInst(Pred,
II->getArgOperand(0),
4031 II->getIntrinsicID() == Intrinsic::fshl
4032 ? ConstantInt::get(Ty,
C.rotr(*RotAmtC))
4033 : ConstantInt::get(Ty,
C.rotl(*RotAmtC)));
4037 case Intrinsic::umax:
4038 case Intrinsic::uadd_sat: {
4041 if (
C.isZero() &&
II->hasOneUse()) {
4048 case Intrinsic::ssub_sat:
4053 if (
C.isZero() &&
II->getType()->getScalarSizeInBits() > 1)
4054 return new ICmpInst(Pred,
II->getArgOperand(0),
II->getArgOperand(1));
4056 case Intrinsic::usub_sat: {
4061 return new ICmpInst(NewPred,
II->getArgOperand(0),
II->getArgOperand(1));
4076 assert(Cmp.isEquality());
4079 Value *Op0 = Cmp.getOperand(0);
4080 Value *Op1 = Cmp.getOperand(1);
4083 if (!IIOp0 || !IIOp1 || IIOp0->getIntrinsicID() != IIOp1->getIntrinsicID())
4086 switch (IIOp0->getIntrinsicID()) {
4087 case Intrinsic::bswap:
4088 case Intrinsic::bitreverse:
4091 return new ICmpInst(
Pred, IIOp0->getOperand(0), IIOp1->getOperand(0));
4092 case Intrinsic::fshl:
4093 case Intrinsic::fshr: {
4096 if (IIOp0->getOperand(0) != IIOp0->getOperand(1))
4098 if (IIOp1->getOperand(0) != IIOp1->getOperand(1))
4100 if (IIOp0->getOperand(2) == IIOp1->getOperand(2))
4101 return new ICmpInst(
Pred, IIOp0->getOperand(0), IIOp1->getOperand(0));
4107 const unsigned BW = IIOp0->getType()->getScalarSizeInBits();
4108 unsigned OneUses = IIOp0->hasOneUse() + IIOp1->hasOneUse();
4117 Builder.CreateSub(IIOp0->getOperand(2), IIOp1->getOperand(2));
4118 Value *CombinedRotate = Builder.CreateIntrinsic(
4119 Op0->
getType(), IIOp0->getIntrinsicID(),
4120 {IIOp0->getOperand(0), IIOp0->getOperand(0), SubAmt});
4121 return new ICmpInst(
Pred, IIOp1->getOperand(0), CombinedRotate);
4140 switch (
II->getIntrinsicID()) {
4143 case Intrinsic::fshl:
4144 case Intrinsic::fshr:
4145 if (Cmp.isEquality() &&
II->getArgOperand(0) ==
II->getArgOperand(1)) {
4147 if (
C.isZero() ||
C.isAllOnes())
4148 return new ICmpInst(Pred,
II->getArgOperand(0), Cmp.getOperand(1));
4162 case Instruction::Xor:
4166 case Instruction::And:
4170 case Instruction::Or:
4174 case Instruction::Mul:
4178 case Instruction::Shl:
4182 case Instruction::LShr:
4183 case Instruction::AShr:
4187 case Instruction::SRem:
4191 case Instruction::UDiv:
4195 case Instruction::SDiv:
4199 case Instruction::Sub:
4203 case Instruction::Add:
4227 if (!
II->hasOneUse())
4243 Value *Op0 =
II->getOperand(0);
4244 Value *Op1 =
II->getOperand(1);
4253 switch (
II->getIntrinsicID()) {
4256 "This function only works with usub_sat and uadd_sat for now!");
4257 case Intrinsic::uadd_sat:
4260 case Intrinsic::usub_sat:
4270 II->getBinaryOp(), *COp1,
II->getNoWrapKind());
4277 if (
II->getBinaryOp() == Instruction::Add)
4283 SatValCheck ? Instruction::BinaryOps::Or : Instruction::BinaryOps::And;
4285 std::optional<ConstantRange> Combination;
4286 if (CombiningOp == Instruction::BinaryOps::Or)
4287 Combination =
C1.exactUnionWith(C2);
4289 Combination =
C1.exactIntersectWith(C2);
4298 Combination->getEquivalentICmp(EquivPred, EquivInt, EquivOffset);
4302 Builder.CreateAdd(Op0, ConstantInt::get(Op1->
getType(), EquivOffset)),
4303 ConstantInt::get(Op1->
getType(), EquivInt));
4310 std::optional<ICmpInst::Predicate> NewPredicate = std::nullopt;
4315 NewPredicate =
Pred;
4319 else if (
C.isAllOnes())
4327 else if (
C.isZero())
4344 if (!
C.isZero() && !
C.isAllOnes())
4355 if (
I->getIntrinsicID() == Intrinsic::scmp)
4369 switch (
II->getIntrinsicID()) {
4372 case Intrinsic::uadd_sat:
4373 case Intrinsic::usub_sat:
4378 case Intrinsic::ctpop: {
4383 case Intrinsic::scmp:
4384 case Intrinsic::ucmp:
4390 if (Cmp.isEquality())
4393 Type *Ty =
II->getType();
4395 switch (
II->getIntrinsicID()) {
4396 case Intrinsic::ctpop: {
4408 case Intrinsic::ctlz: {
4411 unsigned Num =
C.getLimitedValue();
4414 II->getArgOperand(0), ConstantInt::get(Ty, Limit));
4419 unsigned Num =
C.getLimitedValue();
4422 II->getArgOperand(0), ConstantInt::get(Ty, Limit));
4426 case Intrinsic::cttz: {
4428 if (!
II->hasOneUse())
4435 Builder.CreateAnd(
II->getArgOperand(0), Mask),
4443 Builder.CreateAnd(
II->getArgOperand(0), Mask),
4448 case Intrinsic::ssub_sat:
4455 return new ICmpInst(Pred,
II->getArgOperand(0),
II->getArgOperand(1));
4459 II->getArgOperand(1));
4463 II->getArgOperand(1));
4466 case Intrinsic::abs: {
4467 if (!
II->hasOneUse())
4476 Builder.CreateAdd(
X, ConstantInt::get(Ty,
C)),
4477 ConstantInt::get(Ty, 2 *
C));
4484 Builder.CreateAdd(
X, ConstantInt::get(Ty,
C - 1)),
4485 ConstantInt::get(Ty, 2 * (
C - 1)));
4498 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1);
4507 case Instruction::Select: {
4514 Instruction::PtrToAddr, RHSC,
DL.getIndexType(RHSC->
getType()),
DL);
4515 if (!RHSIndexBits || !RHSIndexBits->
isNullValue())
4520 if (!
SI->hasOneUse() || !
SI->getCondition()->hasOneUse())
4527 if (!
match(
SI->getCondition(),
4540 case Instruction::IntToPtr:
4545 APInt NullPtrValue =
4553 case Instruction::Load:
4568 auto SimplifyOp = [&](
Value *
Op,
bool SelectCondIsTrue) ->
Value * {
4572 SI->getCondition(), Pred,
Op, RHS,
DL, SelectCondIsTrue))
4573 return ConstantInt::get(
I.getType(), *Impl);
4578 Value *Op1 = SimplifyOp(
SI->getOperand(1),
true);
4582 Value *Op2 = SimplifyOp(
SI->getOperand(2),
false);
4586 auto Simplifies = [&](
Value *
Op,
unsigned Idx) {
4601 bool Transform =
false;
4604 else if (Simplifies(Op1, 1) || Simplifies(Op2, 2)) {
4606 if (
SI->hasOneUse())
4609 else if (CI && !CI->
isZero())
4617 Op1 =
Builder.CreateICmp(Pred,
SI->getOperand(1), RHS,
I.getName());
4619 Op2 =
Builder.CreateICmp(Pred,
SI->getOperand(2), RHS,
I.getName());
4637 if (C1SatisfiesCond && !C2SatisfiesCond) {
4641 Value *Cmp2 =
Builder.CreateICmp(Pred, RHS,
SI->getFalseValue());
4643 return BinaryOperator::CreateOr(Cmp1, Cmp2);
4644 return BinaryOperator::CreateAnd(Cmp1, Cmp2);
4654 unsigned Depth = 0) {
4657 if (
V->getType()->getScalarSizeInBits() == 1)
4665 switch (
I->getOpcode()) {
4666 case Instruction::ZExt:
4669 case Instruction::SExt:
4673 case Instruction::And:
4674 case Instruction::Or:
4681 case Instruction::Xor:
4691 case Instruction::Select:
4695 case Instruction::Shl:
4698 case Instruction::LShr:
4701 case Instruction::AShr:
4705 case Instruction::Add:
4711 case Instruction::Sub:
4717 case Instruction::Call: {
4719 switch (
II->getIntrinsicID()) {
4722 case Intrinsic::umax:
4723 case Intrinsic::smax:
4724 case Intrinsic::umin:
4725 case Intrinsic::smin:
4730 case Intrinsic::bitreverse:
4820 auto IsLowBitMask = [&]() {
4838 auto Check = [&]() {
4856 auto Check = [&]() {
4875 if (!IsLowBitMask())
4911 const APInt &MaskedBits = *
C0;
4912 assert(MaskedBits != 0 &&
"shift by zero should be folded away already.");
4933 auto *XType =
X->getType();
4934 const unsigned XBitWidth = XType->getScalarSizeInBits();
4936 assert(
BitWidth.ugt(MaskedBits) &&
"shifts should leave some bits untouched");
4949 Value *T0 = Builder.CreateAdd(
X, ConstantInt::get(XType, AddCst));
4951 Value *
T1 = Builder.CreateICmp(DstPred, T0, ConstantInt::get(XType, ICmpCst));
4967 !
I.getOperand(0)->hasOneUse())
4992 assert(NarrowestTy ==
I.getOperand(0)->getType() &&
4993 "We did not look past any shifts while matching XShift though.");
4994 bool HadTrunc = WidestTy !=
I.getOperand(0)->getType();
5001 auto XShiftOpcode = XShift->
getOpcode();
5002 if (XShiftOpcode == YShift->
getOpcode())
5005 Value *
X, *XShAmt, *
Y, *YShAmt;
5014 if (!
match(
I.getOperand(0),
5040 unsigned MaximalPossibleTotalShiftAmount =
5043 APInt MaximalRepresentableShiftAmount =
5045 if (MaximalRepresentableShiftAmount.
ult(MaximalPossibleTotalShiftAmount))
5054 if (NewShAmt->getType() != WidestTy) {
5064 if (!
match(NewShAmt,
5066 APInt(WidestBitWidth, WidestBitWidth))))
5071 auto CanFold = [NewShAmt, WidestBitWidth, NarrowestShift, SQ,
5077 ? NewShAmt->getSplatValue()
5080 if (NewShAmtSplat &&
5088 unsigned MinLeadZero =
Known.countMinLeadingZeros();
5090 unsigned MaxActiveBits =
Known.getBitWidth() - MinLeadZero;
5091 if (MaxActiveBits <= 1)
5099 unsigned MinLeadZero =
Known.countMinLeadingZeros();
5101 unsigned MaxActiveBits =
Known.getBitWidth() - MinLeadZero;
5102 if (MaxActiveBits <= 1)
5105 if (NewShAmtSplat) {
5108 if (AdjNewShAmt.
ule(MinLeadZero))
5119 X = Builder.CreateZExt(
X, WidestTy);
5120 Y = Builder.CreateZExt(
Y, WidestTy);
5122 Value *T0 = XShiftOpcode == Instruction::BinaryOps::LShr
5123 ? Builder.CreateLShr(
X, NewShAmt)
5124 : Builder.CreateShl(
X, NewShAmt);
5125 Value *
T1 = Builder.CreateAnd(T0,
Y);
5126 return Builder.CreateICmp(
I.getPredicate(),
T1,
5144 if (!
I.isEquality() &&
5154 NeedNegation =
false;
5157 NeedNegation =
true;
5163 if (
I.isEquality() &&
5178 bool MulHadOtherUses =
Mul && !
Mul->hasOneUse();
5179 if (MulHadOtherUses)
5183 Div->
getOpcode() == Instruction::UDiv ? Intrinsic::umul_with_overflow
5184 : Intrinsic::smul_with_overflow,
5185 X->getType(), {X, Y},
nullptr,
"mul");
5190 if (MulHadOtherUses)
5195 Res =
Builder.CreateNot(Res,
"mul.not.ov");
5199 if (MulHadOtherUses)
5225 Type *Ty =
X->getType();
5229 Value *
And = Builder.CreateAnd(
X, MaxSignedVal);
5239 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1), *
A;
5301 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1), *
A;
5336 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1), *
A;
5352 return new ICmpInst(PredOut, Op0, Op1);
5372 return new ICmpInst(NewPred, Op0, Const);
5384 if (!
C.isPowerOf2())
5391 bool &HasNSW,
bool &HasNUW) {
5399 if (BO.
getOpcode() == Instruction::Or) {
5421 bool Op0HasNSW =
false, Op0HasNUW =
false;
5422 bool Op1HasNSW =
false, Op1HasNUW =
false;
5423 bool NoOp0WrapProblem =
hasNoWrapProblem(*BO0, Pred, Op0HasNSW, Op0HasNUW);
5424 bool NoOp1WrapProblem =
hasNoWrapProblem(*BO1, Pred, Op1HasNSW, Op1HasNUW);
5431 if (!NoOp0WrapProblem || !NoOp1WrapProblem)
5461 if (BO0->getOpcode() != BO1->getOpcode())
5464 A = BO0->getOperand(0);
5465 B = BO0->getOperand(1);
5466 C = BO1->getOperand(0);
5467 D = BO1->getOperand(1);
5469 switch (BO0->getOpcode()) {
5470 case Instruction::Sub:
5471 if (!NoOp0WrapProblem || !NoOp1WrapProblem)
5488 case Instruction::Mul: {
5491 if (IsEquality || !NoOp0WrapProblem || !NoOp1WrapProblem)
5501 }
else if (
A ==
D) {
5506 }
else if (
B ==
C) {
5511 }
else if (
B ==
D) {
5546 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1);
5561 Value *Dividend, *Divisor;
5562 if (
I.isEquality() &&
5567 return new ICmpInst(NewPred, Dividend, Divisor);
5639 bool NoOp0WrapProblem =
false, NoOp1WrapProblem =
false;
5640 bool Op0HasNUW =
false, Op1HasNUW =
false;
5641 bool Op0HasNSW =
false, Op1HasNSW =
false;
5644 Value *
A =
nullptr, *
B =
nullptr, *
C =
nullptr, *
D =
nullptr;
5657 if ((
A == Op1 ||
B == Op1) && NoOp0WrapProblem)
5663 if ((
C == Op0 ||
D == Op0) && NoOp1WrapProblem)
5671 return new ICmpInst(Pred, LHS, RHS);
5677 bool IsNegative) ->
bool {
5678 const APInt *OffsetC;
5690 if (!
C.isStrictlyPositive())
5717 if (
A && NoOp0WrapProblem && IsAddOrSignedPred &&
5718 ShareCommonDivisor(
A, Op1,
B, IsNegative))
5728 if (
C && NoOp1WrapProblem &&
5729 ShareCommonDivisor(Op0,
C,
D,
5742 if (
A &&
C && NoOp0WrapProblem && NoOp1WrapProblem &&
5744 const APInt *AP1, *AP2;
5752 if (AP1Abs.
uge(AP2Abs)) {
5753 APInt Diff = *AP1 - *AP2;
5756 A, C3,
"", Op0HasNUW && Diff.
ule(*AP1), Op0HasNSW);
5759 APInt Diff = *AP2 - *AP1;
5762 C, C3,
"", Op1HasNUW && Diff.
ule(*AP2), Op1HasNSW);
5781 if (BO0 && BO0->
getOpcode() == Instruction::Sub) {
5785 if (BO1 && BO1->
getOpcode() == Instruction::Sub) {
5791 if (
A == Op1 && NoOp0WrapProblem)
5794 if (
C == Op0 && NoOp1WrapProblem)
5818 if (RHSC->isNotMinSignedValue())
5819 return new ICmpInst(
I.getSwappedPredicate(),
X,
5837 if (Op0HasNSW && Op1HasNSW) {
5839 SQ.getWithInstruction(&
I));
5844 SQ.getWithInstruction(&
I));
5845 if (GreaterThan &&
match(GreaterThan,
m_One()))
5851 if (((Op0HasNSW && Op1HasNSW) || (Op0HasNUW && Op1HasNUW)) &&
5863 if (NonZero && Op0HasNSW && Op1HasNSW)
5868 if (NonZero && Op0HasNUW && Op1HasNUW)
5879 else if (BO1 && BO1->
getOpcode() == Instruction::SRem &&
5909 case Instruction::Add:
5910 case Instruction::Sub:
5911 case Instruction::Xor: {
5918 if (
C->isSignMask()) {
5924 if (BO0->
getOpcode() == Instruction::Xor &&
C->isMaxSignedValue()) {
5926 NewPred =
I.getSwappedPredicate(NewPred);
5932 case Instruction::Mul: {
5933 if (!
I.isEquality())
5941 if (
unsigned TZs =
C->countr_zero()) {
5947 return new ICmpInst(Pred, And1, And2);
5952 case Instruction::UDiv:
5953 case Instruction::LShr:
5958 case Instruction::SDiv:
5964 case Instruction::AShr:
5969 case Instruction::Shl: {
5970 bool NUW = Op0HasNUW && Op1HasNUW;
5971 bool NSW = Op0HasNSW && Op1HasNSW;
5974 if (!NSW &&
I.isSigned())
6038 auto IsCondKnownTrue = [](
Value *Val) -> std::optional<bool> {
6040 return std::nullopt;
6045 return std::nullopt;
6051 Pred = Pred.dropSameSign();
6054 if (!CmpXZ.has_value() && !CmpYZ.has_value())
6056 if (!CmpXZ.has_value()) {
6062 if (CmpYZ.has_value())
6086 if (!MinMaxCmpXZ.has_value()) {
6094 if (!MinMaxCmpXZ.has_value())
6110 return FoldIntoCmpYZ();
6137 return FoldIntoCmpYZ();
6146 return FoldIntoCmpYZ();
6178 const APInt *
Lo =
nullptr, *
Hi =
nullptr;
6201 I,
Builder.CreateICmp(Pred,
X, ConstantInt::get(
X->getType(),
C)));
6207 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1);
6211 if (
I.isEquality()) {
6246 Type *Ty =
A->getType();
6247 Value *CtPop = Builder.CreateUnaryIntrinsic(Intrinsic::ctpop,
A);
6249 ConstantInt::get(Ty, 2))
6251 ConstantInt::get(Ty, 1));
6258using OffsetOp = std::pair<Instruction::BinaryOps, Value *>;
6260 bool AllowRecursion) {
6266 case Instruction::Add:
6267 Offsets.emplace_back(Instruction::Sub, Inst->
getOperand(1));
6268 Offsets.emplace_back(Instruction::Sub, Inst->
getOperand(0));
6270 case Instruction::Sub:
6271 Offsets.emplace_back(Instruction::Add, Inst->
getOperand(1));
6273 case Instruction::Xor:
6274 Offsets.emplace_back(Instruction::Xor, Inst->
getOperand(1));
6275 Offsets.emplace_back(Instruction::Xor, Inst->
getOperand(0));
6277 case Instruction::Shl:
6279 Offsets.emplace_back(Instruction::AShr, Inst->
getOperand(1));
6281 Offsets.emplace_back(Instruction::LShr, Inst->
getOperand(1));
6283 case Instruction::Select:
6284 if (AllowRecursion) {
6331 assert(
I.isEquality() &&
"Expected an equality icmp");
6332 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1);
6343 case Instruction::AShr: {
6344 const APInt *CV, *CRHS;
6346 CV->
ashr(*CRHS).
shl(*CRHS) == *CV) &&
6352 case Instruction::LShr: {
6353 const APInt *CV, *CRHS;
6355 CV->
lshr(*CRHS).
shl(*CRHS) == *CV) &&
6374 auto ApplyOffset = [&](
Value *
V,
unsigned BinOpc,
6377 if (!Sel->hasOneUse())
6379 Value *TrueVal = ApplyOffsetImpl(Sel->getTrueValue(), BinOpc,
RHS);
6382 Value *FalseVal = ApplyOffsetImpl(Sel->getFalseValue(), BinOpc,
RHS);
6387 if (
Value *Simplified = ApplyOffsetImpl(
V, BinOpc,
RHS))
6392 for (
auto [BinOp,
RHS] : OffsetOps) {
6393 auto BinOpc =
static_cast<unsigned>(BinOp);
6395 auto Op0Result = ApplyOffset(Op0, BinOpc,
RHS);
6396 if (!Op0Result.isValid())
6398 auto Op1Result = ApplyOffset(Op1, BinOpc,
RHS);
6399 if (!Op1Result.isValid())
6402 Value *NewLHS = Op0Result.materialize(Builder);
6403 Value *NewRHS = Op1Result.materialize(Builder);
6404 return new ICmpInst(
I.getPredicate(), NewLHS, NewRHS);
6411 if (!
I.isEquality())
6414 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1);
6418 if (
A == Op1 ||
B == Op1) {
6419 Value *OtherVal =
A == Op1 ?
B :
A;
6447 Value *OtherVal =
A == Op0 ?
B :
A;
6454 Value *
X =
nullptr, *
Y =
nullptr, *Z =
nullptr;
6460 }
else if (
A ==
D) {
6464 }
else if (
B ==
C) {
6468 }
else if (
B ==
D) {
6480 (*
C0 ^ *
C1).isNegatedPowerOf2();
6486 int(Op0->
hasOneUse()) + int(Op1->hasOneUse()) +
6488 if (XorIsNegP2 || UseCnt >= 2) {
6491 Op1 =
Builder.CreateAnd(Op1, Z);
6511 (Op0->
hasOneUse() || Op1->hasOneUse())) {
6516 MaskC->
countr_one() ==
A->getType()->getScalarSizeInBits())
6522 const APInt *AP1, *AP2;
6531 if (ShAmt < TypeBits && ShAmt != 0) {
6536 return new ICmpInst(NewPred,
Xor, ConstantInt::get(
A->getType(), CmpVal));
6546 if (ShAmt < TypeBits && ShAmt != 0) {
6566 if (ShAmt < ASize) {
6589 A->getType()->getScalarSizeInBits() ==
BitWidth * 2 &&
6590 (
I.getOperand(0)->hasOneUse() ||
I.getOperand(1)->hasOneUse())) {
6595 Add, ConstantInt::get(
A->getType(),
C.shl(1)));
6622 Builder.CreateIntrinsic(Op0->
getType(), Intrinsic::fshl, {A, A, B}));
6637 std::optional<bool> IsZero = std::nullopt;
6679 Constant *
C = ConstantInt::get(Res->X->getType(), Res->C);
6683 unsigned SrcBits =
X->getType()->getScalarSizeInBits();
6685 if (
II->getIntrinsicID() == Intrinsic::cttz ||
6686 II->getIntrinsicID() == Intrinsic::ctlz) {
6687 unsigned MaxRet = SrcBits;
6713 bool IsSignedExt = CastOp0->getOpcode() == Instruction::SExt;
6714 bool IsSignedCmp = ICmp.
isSigned();
6722 if (IsZext0 != IsZext1) {
6727 if (ICmp.
isEquality() &&
X->getType()->isIntOrIntVectorTy(1) &&
6728 Y->getType()->isIntOrIntVectorTy(1))
6738 bool IsNonNeg0 = NonNegInst0 && NonNegInst0->hasNonNeg();
6739 bool IsNonNeg1 = NonNegInst1 && NonNegInst1->hasNonNeg();
6741 if ((IsZext0 && IsNonNeg0) || (IsZext1 && IsNonNeg1))
6748 Type *XTy =
X->getType(), *YTy =
Y->getType();
6755 IsSignedExt ? Instruction::SExt : Instruction::ZExt;
6757 X =
Builder.CreateCast(CastOpcode,
X, YTy);
6759 Y =
Builder.CreateCast(CastOpcode,
Y, XTy);
6771 if (IsSignedCmp && IsSignedExt)
6784 Type *SrcTy = CastOp0->getSrcTy();
6792 if (IsSignedExt && IsSignedCmp)
6823 Value *SimplifiedOp0 = simplifyIntToPtrRoundTripCast(ICmp.
getOperand(0));
6824 Value *SimplifiedOp1 = simplifyIntToPtrRoundTripCast(ICmp.
getOperand(1));
6825 if (SimplifiedOp0 || SimplifiedOp1)
6827 SimplifiedOp0 ? SimplifiedOp0 : ICmp.
getOperand(0),
6828 SimplifiedOp1 ? SimplifiedOp1 : ICmp.
getOperand(1));
6837 Value *Op0Src = CastOp0->getOperand(0);
6838 Type *SrcTy = CastOp0->getSrcTy();
6839 Type *DestTy = CastOp0->getDestTy();
6843 auto CompatibleSizes = [&](
Type *PtrTy,
Type *IntTy) {
6844 unsigned IntWidth = IntTy->getScalarType()->getIntegerBitWidth();
6845 unsigned IndexWidth =
DL.getAddressSizeInBits(PtrTy);
6846 unsigned PtrWidth =
DL.getPointerTypeSizeInBits(PtrTy);
6849 return IntWidth == IndexWidth && IndexWidth == PtrWidth;
6853 Value *NewOp1 =
nullptr;
6855 NewOp1 = PtrToIntOp1->getOperand(0);
6858 NewOp1 = PtrToAddrOp1->getOperand(0);
6865 if ((!HasPtrToInt || CompatibleSizes(SrcTy, DestTy)) &&
6871 if (CastOp0->getOpcode() == Instruction::IntToPtr &&
6872 CompatibleSizes(DestTy, SrcTy)) {
6873 Value *NewOp1 =
nullptr;
6875 Value *IntSrc = IntToPtrOp1->getOperand(0);
6877 NewOp1 = IntToPtrOp1->getOperand(0);
6897 case Instruction::Add:
6898 case Instruction::Sub:
6900 case Instruction::Mul:
6901 return !(
RHS->getType()->isIntOrIntVectorTy(1) && IsSigned) &&
6913 case Instruction::Add:
6918 case Instruction::Sub:
6923 case Instruction::Mul:
6932 bool IsSigned,
Value *LHS,
6943 Builder.SetInsertPoint(&OrigI);
6960 Result = Builder.CreateBinOp(BinaryOp,
LHS,
RHS);
6961 Result->takeName(&OrigI);
6965 Result = Builder.CreateBinOp(BinaryOp,
LHS,
RHS);
6966 Result->takeName(&OrigI);
6970 Inst->setHasNoSignedWrap();
6972 Inst->setHasNoUnsignedWrap();
6997 const APInt *OtherVal,
7005 unsigned Opcode = Instr->getOpcode();
7006 assert(Opcode == Instruction::Add || Opcode == Instruction::Mul);
7013 Type *TyA =
A->getType(), *TyB =
B->getType();
7015 WidthB = TyB->getPrimitiveSizeInBits();
7016 unsigned ResultWidth;
7018 if (WidthB > WidthA) {
7019 ResultWidth = WidthB;
7022 ResultWidth = WidthA;
7035 unsigned TruncWidth = TI->getType()->getPrimitiveSizeInBits();
7036 if (TruncWidth > ResultWidth)
7040 if (BO->getOpcode() != Instruction::And)
7043 const APInt &CVal = CI->getValue();
7059 switch (
I.getPredicate()) {
7066 if (MaxVal.
eq(*OtherVal))
7076 if (MaxVal.
eq(*OtherVal))
7089 Value *ResultA =
A, *ResultB =
B;
7090 if (WidthA < ResultWidth)
7091 ResultA = Builder.CreateZExt(
A, ResultType);
7092 if (WidthB < ResultWidth)
7093 ResultB = Builder.CreateZExt(
B, ResultType);
7096 Value *OverflowCheck;
7098 if (Opcode == Instruction::Add) {
7100 ArithResult = Builder.CreateAdd(ResultA, ResultB,
"add");
7104 Builder.CreateICmpUGE(ArithResult, ResultA,
"not.add.overflow");
7107 Builder.CreateICmpULT(ArithResult, ResultA,
"add.overflow");
7110 Value *
Call = Builder.CreateIntrinsic(Intrinsic::umul_with_overflow,
7111 ResultType, {ResultA, ResultB},
7113 ArithResult = Builder.CreateExtractValue(
Call, 0,
"umul.value");
7114 OverflowCheck = Builder.CreateExtractValue(
Call, 1,
"umul.overflow");
7116 OverflowCheck = Builder.CreateNot(OverflowCheck);
7127 if (TI->getType()->getPrimitiveSizeInBits() == ResultWidth)
7132 assert(BO->getOpcode() == Instruction::And);
7136 Value *ShortAnd = Builder.CreateAnd(ArithResult, ShortMask);
7137 Value *Zext = Builder.CreateZExt(ShortAnd, BO->
getType());
7163 switch (
I.getPredicate()) {
7194 assert(DI && UI &&
"Instruction not defined\n");
7206 if (Usr != UI && !
DT.dominates(DB, Usr->getParent()))
7221 if (!IC || (IC->getOperand(0) !=
SI && IC->getOperand(1) !=
SI))
7268 const unsigned SIOpd) {
7269 assert((SIOpd == 1 || SIOpd == 2) &&
"Invalid select operand!");
7271 BasicBlock *Succ =
SI->getParent()->getTerminator()->getSuccessor(1);
7285 SI->replaceUsesOutsideBlock(
SI->getOperand(SIOpd),
SI->getParent());
7295 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1);
7300 unsigned BitWidth = Ty->isIntOrIntVectorTy()
7301 ? Ty->getScalarSizeInBits()
7302 :
DL.getPointerTypeSizeInBits(Ty->getScalarType());
7326 if (
I.hasSameSign() &&
I.isUnsigned()) {
7328 if (To.isNegative() || To.isNonNegative())
7333 To.makeNonNegative();
7335 PropagateSignBit(Op0Known, Op1Known);
7336 PropagateSignBit(Op1Known, Op0Known);
7371 if (!Cmp.hasOneUse())
7380 if (!isMinMaxCmp(
I)) {
7385 if (Op1Min == Op0Max)
7390 if (*CmpC == Op0Min + 1)
7392 ConstantInt::get(Op1->getType(), *CmpC - 1));
7402 if (Op1Max == Op0Min)
7407 if (*CmpC == Op0Max - 1)
7409 ConstantInt::get(Op1->getType(), *CmpC + 1));
7419 if (Op1Min == Op0Max)
7423 if (*CmpC == Op0Min + 1)
7425 ConstantInt::get(Op1->getType(), *CmpC - 1));
7430 if (Op1Max == Op0Min)
7434 if (*CmpC == Op0Max - 1)
7436 ConstantInt::get(Op1->getType(), *CmpC + 1));
7453 APInt Op0KnownZeroInverted = ~Op0Known.Zero;
7456 Value *LHS =
nullptr;
7459 *LHSC != Op0KnownZeroInverted)
7465 Type *XTy =
X->getType();
7466 unsigned Log2C1 =
C1->countr_zero();
7467 APInt C2 = Op0KnownZeroInverted;
7474 auto *CmpC = ConstantInt::get(XTy, Log2C2 - Log2C1);
7484 (Op0Known & Op1Known) == Op0Known)
7490 if (Op1Min == Op0Max)
7494 if (Op1Max == Op0Min)
7498 if (Op1Min == Op0Max)
7502 if (Op1Max == Op0Min)
7510 if ((
I.isSigned() || (
I.isUnsigned() && !
I.hasSameSign())) &&
7513 I.setPredicate(
I.getUnsignedPredicate());
7531 return BinaryOperator::CreateAnd(
Builder.CreateIsNull(
X),
Y);
7537 return BinaryOperator::CreateOr(
Builder.CreateIsNull(
X),
Y);
7548 bool IsSExt = ExtI->
getOpcode() == Instruction::SExt;
7550 auto CreateRangeCheck = [&] {
7565 }
else if (!IsSExt || HasOneUse) {
7570 return CreateRangeCheck();
7572 }
else if (IsSExt ?
C->isAllOnes() :
C->isOne()) {
7580 }
else if (!IsSExt || HasOneUse) {
7585 return CreateRangeCheck();
7599 Instruction::ICmp, Pred1,
X,
7618 Value *Op0 =
I.getOperand(0);
7619 Value *Op1 =
I.getOperand(1);
7625 if (!FlippedStrictness)
7629 new ICmpInst(FlippedStrictness->first, Op0, FlippedStrictness->second);
7630 NewCmp->setSameSign(FlippedStrictness->first.hasSameSign());
7649 I.setName(
I.getName() +
".not");
7660 Value *
A =
I.getOperand(0), *
B =
I.getOperand(1);
7661 assert(
A->getType()->isIntOrIntVectorTy(1) &&
"Bools only");
7667 switch (
I.getPredicate()) {
7676 switch (
I.getPredicate()) {
7686 switch (
I.getPredicate()) {
7695 return BinaryOperator::CreateXor(
A,
B);
7703 return BinaryOperator::CreateAnd(Builder.CreateNot(
A),
B);
7711 return BinaryOperator::CreateAnd(Builder.CreateNot(
B),
A);
7719 return BinaryOperator::CreateOr(Builder.CreateNot(
A),
B);
7727 return BinaryOperator::CreateOr(Builder.CreateNot(
B),
A);
7775 Value *NewX = Builder.CreateLShr(
X,
Y,
X->getName() +
".highbits");
7783 Value *
LHS = Cmp.getOperand(0), *
RHS = Cmp.getOperand(1);
7787 Value *
V = Builder.CreateCmp(
Pred,
X,
Y, Cmp.getName());
7789 I->copyIRFlags(&Cmp);
7790 Module *M = Cmp.getModule();
7792 M, Intrinsic::vector_reverse,
V->getType());
7799 (
LHS->hasOneUse() ||
RHS->hasOneUse()))
7800 return createCmpReverse(
Pred,
V1, V2);
7808 return createCmpReverse(
Pred,
LHS, V2);
7817 Type *V1Ty =
V1->getType();
7819 V1Ty == V2->
getType() && (
LHS->hasOneUse() ||
RHS->hasOneUse())) {
7833 Constant *ScalarC =
C->getSplatValue(
true);
7852 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1);
7858 if (
match(Op0, UAddOvResultPat) &&
7869 (Op0 ==
A || Op0 ==
B))
7879 if (!
I.getOperand(0)->getType()->isPointerTy() ||
7881 I.getParent()->getParent(),
7882 I.getOperand(0)->getType()->getPointerAddressSpace())) {
7886 if (
match(
I.getOperand(0),
7902 Value *Const =
I.getOperand(1);
7920 Type *VecEltTy = VecTy->getElementType();
7922 DL.getTypeSizeInBits(VecEltTy) * VecTy->getNumElements();
7923 if (!
DL.fitsInLegalInteger(ScalarBW))
7927 ? ConstantInt::get(ScalarTy, 0)
7930 Builder.CreateBitCast(Vec, ScalarTy), NewConst);
7942 if (
I.getType()->isVectorTy())
7965 if (!LHSTy || !LHSTy->getElementType()->isIntegerTy())
7968 LHSTy->getNumElements() * LHSTy->getElementType()->getIntegerBitWidth();
7970 if (!
DL.isLegalInteger(NumBits))
7974 auto *ScalarTy = Builder.getIntNTy(NumBits);
7975 LHS = Builder.CreateBitCast(
LHS, ScalarTy,
LHS->getName() +
".scalar");
7976 RHS = Builder.CreateBitCast(
RHS, ScalarTy,
RHS->getName() +
".scalar");
8032 bool IsIntMinPosion =
C->isAllOnesValue();
8044 CtxI, IsIntMinPosion
8045 ?
Builder.CreateICmpSGT(
X, AllOnesValue)
8047 X, ConstantInt::get(
X->getType(),
SMin + 1)));
8053 CtxI, IsIntMinPosion
8054 ?
Builder.CreateICmpSLT(
X, NullValue)
8056 X, ConstantInt::get(
X->getType(),
SMin)));
8083 auto CheckUGT1 = [](
const APInt &Divisor) {
return Divisor.ugt(1); };
8098 auto CheckNE0 = [](
const APInt &Shift) {
return !Shift.isZero(); };
8119 if (ShAmt >=
X->getType()->getScalarSizeInBits())
8121 if (canEvaluateShifted(Op1, ShAmt,
false,
8123 Value *NewOp1 = getShiftedValue(Op1, ShAmt,
false,
8131 if (ShAmt >=
X->getType()->getScalarSizeInBits())
8133 if (canEvaluateShifted(Op1, ShAmt,
false,
8135 Value *NewOp1 = getShiftedValue(Op1, ShAmt,
false,
8146 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1);
8153 if (Op0Cplxity < Op1Cplxity) {
8216 if (
C->isNonNegative())
8220 ConstantInt::get(
X->getType(), ~*
C));
8226 if (
C->isNonNegative())
8230 ConstantInt::get(
X->getType(), ~*
C));
8286 if (
I.isCommutative()) {
8287 if (
auto Pair = matchSymmetricPair(
I.getOperand(0),
I.getOperand(1))) {
8316 (Op0->
hasOneUse() || Op1->hasOneUse())) {
8344 bool I0NUW = I0->hasNoUnsignedWrap();
8345 bool I1NUW = I1->hasNoUnsignedWrap();
8346 bool I0NSW = I0->hasNoSignedWrap();
8347 bool I1NSW = I1->hasNoSignedWrap();
8351 ((I0NUW || I0NSW) && (I1NUW || I1NSW)))) {
8353 ConstantInt::get(Op0->
getType(), 0));
8360 assert(Op1->getType()->isPointerTy() &&
8361 "Comparing pointer with non-pointer?");
8385 Type *SmallType =
X->getType();
8387 if (Mask->isMask(SmallWidth) &&
8388 shouldChangeType(
I.getOperand(0)->getType(), SmallType)) {
8390 return new ICmpInst(
I.getUnsignedPredicate(), NewTrunc,
X);
8408 bool ConsumesOp0, ConsumesOp1;
8411 (ConsumesOp0 || ConsumesOp1)) {
8414 assert(InvOp0 && InvOp1 &&
8415 "Mismatch between isFreeToInvert and getFreelyInverted");
8416 return new ICmpInst(
I.getSwappedPredicate(), InvOp0, InvOp1);
8428 if (AddI->
getOpcode() == Instruction::Add &&
8429 OptimizeOverflowCheck(Instruction::Add,
false,
X,
Y, *AddI,
8430 Result, Overflow)) {
8450 if ((
I.isUnsigned() ||
I.isEquality()) &&
8453 Y->getType()->getScalarSizeInBits() == 1 &&
8454 (Op0->
hasOneUse() || Op1->hasOneUse())) {
8461 unsigned ShiftOpc = ShiftI->
getOpcode();
8462 if ((ExtOpc == Instruction::ZExt && ShiftOpc == Instruction::LShr) ||
8463 (ExtOpc == Instruction::SExt && ShiftOpc == Instruction::AShr)) {
8497 if (EVI->getIndices()[0] == 0 && ACXI->getCompareOperand() == Op1 &&
8504 if (
I.getType()->isVectorTy())
8523 Type *InputTy =
A->getType();
8527 APInt TruncC1 =
C1->trunc(InputBitWidth);
8530 TruncC1.
setBit(InputBitWidth - 1);
8534 ConstantInt::get(InputTy, C2->
trunc(InputBitWidth)));
8554 if (MantissaWidth == -1)
8561 if (
I.isEquality()) {
8563 bool IsExact =
false;
8564 APSInt RHSCvt(IntWidth, LHSUnsigned);
8573 if (*RHS != RHSRoundInt) {
8593 if ((
int)IntWidth > MantissaWidth) {
8595 int Exp =
ilogb(*RHS);
8598 if (MaxExponent < (
int)IntWidth - !LHSUnsigned)
8604 if (MantissaWidth <= Exp && Exp <= (
int)IntWidth - !LHSUnsigned)
8613 assert(!RHS->isNaN() &&
"NaN comparison not already folded!");
8616 switch (
I.getPredicate()) {
8707 APSInt RHSInt(IntWidth, LHSUnsigned);
8710 if (!RHS->isZero()) {
8725 if (RHS->isNegative())
8731 if (RHS->isNegative())
8737 if (RHS->isNegative())
8744 if (!RHS->isNegative())
8750 if (RHS->isNegative())
8756 if (RHS->isNegative())
8762 if (RHS->isNegative())
8769 if (!RHS->isNegative())
8788 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1);
8796 if (
I.getType() !=
C1->getType() ||
I.getType() != C2->
getType())
8799 unsigned Pred =
I.getPredicate();
8807 if (!Res00 || !Res01 || !Res10 || !Res11)
8816 std::bitset<4>
Table;
8874 if (
C->isNegative())
8875 Pred =
I.getSwappedPredicate();
8902 "X ord/uno NaN should be folded away by simplifyFCmpInst()");
8908 bool RoundDown =
false;
8929 auto NextValue = [](
const APFloat &
Value,
bool RoundDown) {
8931 NextValue.
next(RoundDown);
8935 APFloat NextCValue = NextValue(*CValue, RoundDown);
8940 APFloat ExtCValue = ConvertFltSema(*CValue, DestFltSema);
8941 APFloat ExtNextCValue = ConvertFltSema(NextCValue, DestFltSema);
8948 APFloat PrevCValue = NextValue(*CValue, !RoundDown);
8949 APFloat Bias = ConvertFltSema(*CValue - PrevCValue, DestFltSema);
8951 ExtNextCValue = ExtCValue + Bias;
8958 C.getType()->getScalarType()->getFltSemantics();
8961 APFloat MidValue = ConvertFltSema(ExtMidValue, SrcFltSema);
8962 if (MidValue != *CValue)
8963 ExtMidValue.
next(!RoundDown);
8971 if (ConvertFltSema(ExtMidValue, SrcFltSema).isInfinity())
8975 APFloat NextExtMidValue = NextValue(ExtMidValue, RoundDown);
8976 if (ConvertFltSema(NextExtMidValue, SrcFltSema).
isFinite())
8981 ConstantFP::get(DestType, ExtMidValue),
"", &
I);
8994 if (!
C->isPosZero()) {
8995 if (!
C->isSmallestNormalized())
9008 switch (
I.getPredicate()) {
9034 switch (
I.getPredicate()) {
9059 assert(!
I.hasNoNaNs() &&
"fcmp should have simplified");
9064 assert(!
I.hasNoNaNs() &&
"fcmp should have simplified");
9078 return replacePredAndOp0(&
I,
I.getPredicate(),
X);
9101 I.setHasNoInfs(
false);
9103 switch (
I.getPredicate()) {
9148 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1);
9155 Pred =
I.getSwappedPredicate();
9201 I.getFunction()->getDenormalMode(
9208 I.setHasNoNaNs(
true);
9233 if (MantissaWidth != -1 &&
ilogb(*
C) < MantissaWidth) {
9235 I.setPredicate(
I.getSwappedPredicate());
9272 if (!IsStrictLt && !IsStrictGt && !IsGe)
9294 }
else if (
match(FAbsArg,
9302 if (
A->getType() !=
B->getType())
9317 Type *OpType =
LHS->getType();
9323 if (!FloorX && !CeilX) {
9327 Pred =
I.getSwappedPredicate();
9403 if (!
I || !(
I->getOpcode() == Instruction::SIToFP ||
9404 I->getOpcode() == Instruction::UIToFP))
9407 bool IsUnsigned =
I->getOpcode() == Instruction::UIToFP;
9408 unsigned BitWidth =
I->getOperand(0)->getType()->getScalarSizeInBits();
9431 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1);
9433 SQ.getWithInstruction(&
I)))
9438 assert(OpType == Op1->getType() &&
"fcmp with different-typed operands?");
9463 if (
I.isCommutative()) {
9464 if (
auto Pair = matchSymmetricPair(
I.getOperand(0),
I.getOperand(1))) {
9488 return new FCmpInst(
I.getSwappedPredicate(),
X,
Y,
"", &
I);
9504 bool IsRedundantMinMaxClamp =
9566 X->getType()->isIntOrIntVectorTy() &&
9567 !
F.getDenormalMode(Op1->getType()->getScalarType()->getFltSemantics())
9568 .inputsMayBeZero()) {
9576 Type *IntTy =
X->getType();
9577 const APInt &SignMask =
~APInt::getSignMask(IntTy->getScalarSizeInBits());
9578 Value *MaskX =
Builder.CreateAnd(
X, ConstantInt::get(IntTy, SignMask));
9588 case Instruction::Select:
9598 case Instruction::FSub:
9603 case Instruction::PHI:
9607 case Instruction::SIToFP:
9608 case Instruction::UIToFP:
9612 case Instruction::FDiv:
9616 case Instruction::Load:
9621 case Instruction::FPTrunc:
9649 return new FCmpInst(
I.getSwappedPredicate(),
X, NegC,
"", &
I);
9663 X->getType() ==
Y->getType())
9674 X->getType()->getScalarType()->getFltSemantics();
9710 Constant *NewC = ConstantFP::get(
X->getType(), TruncC);
9723 Type *IntType =
Builder.getIntNTy(
X->getType()->getScalarSizeInBits());
9736 Value *CanonLHS =
nullptr;
9739 if (CanonLHS == Op1)
9740 return new FCmpInst(Pred, Op1, Op1,
"", &
I);
9742 Value *CanonRHS =
nullptr;
9745 if (CanonRHS == Op0)
9746 return new FCmpInst(Pred, Op0, Op0,
"", &
I);
9749 if (CanonLHS && CanonRHS)
9750 return new FCmpInst(Pred, CanonLHS, CanonRHS,
"", &
I);
9753 if (
I.getType()->isVectorTy())
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
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...
This file implements the APSInt class, which is a simple class that represents an arbitrary sized int...
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static GCRegistry::Add< ShadowStackGC > C("shadow-stack", "Very portable GC for uncooperative code generators")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
This file contains the declarations for the subclasses of Constant, which represent the different fla...
static Instruction * foldFCmpReciprocalAndZero(FCmpInst &I, Instruction *LHSI, Constant *RHSC)
Fold (C / X) < 0.0 --> X < 0.0 if possible. Swap predicate if necessary.
static Instruction * foldFabsWithFcmpZero(FCmpInst &I, InstCombinerImpl &IC)
Optimize fabs(X) compared with zero.
static void collectOffsetOp(Value *V, SmallVectorImpl< OffsetOp > &Offsets, bool AllowRecursion)
static Value * rewriteGEPAsOffset(Value *Start, Value *Base, GEPNoWrapFlags NW, const DataLayout &DL, SetVector< Value * > &Explored, InstCombiner &IC)
Returns a re-written value of Start as an indexed GEP using Base as a pointer.
static bool isMinMaxCmpSelectEliminable(SelectPatternFlavor Flavor, Value *A, Value *B)
Returns true if a select that implements a min/max is redundant and select result can be replaced wit...
static Instruction * foldICmpEqualityWithOffset(ICmpInst &I, InstCombiner::BuilderTy &Builder, const SimplifyQuery &SQ)
Offset both sides of an equality icmp to see if we can save some instructions: icmp eq/ne X,...
static bool addWithOverflow(APInt &Result, const APInt &In1, const APInt &In2, bool IsSigned=false)
Compute Result = In1+In2, returning true if the result overflowed for this type.
static Instruction * foldICmpOfVectorReduce(ICmpInst &I, const DataLayout &DL, IRBuilderBase &Builder)
static Instruction * foldICmpAndXX(ICmpInst &I, const SimplifyQuery &Q, InstCombinerImpl &IC)
static Instruction * foldVectorCmp(CmpInst &Cmp, InstCombiner::BuilderTy &Builder)
static bool isMaskOrZero(const Value *V, bool Not, const SimplifyQuery &Q, unsigned Depth=0)
static Value * createLogicFromTable(const std::bitset< 4 > &Table, Value *Op0, Value *Op1, IRBuilderBase &Builder, bool HasOneUse)
static Instruction * foldICmpOfUAddOv(ICmpInst &I)
static bool isChainSelectCmpBranch(const SelectInst *SI)
Return true when the instruction sequence within a block is select-cmp-br.
static Instruction * foldICmpInvariantGroup(ICmpInst &I)
std::pair< Instruction::BinaryOps, Value * > OffsetOp
Find all possible pairs (BinOp, RHS) that BinOp V, RHS can be simplified.
static Instruction * foldReductionIdiom(ICmpInst &I, InstCombiner::BuilderTy &Builder, const DataLayout &DL)
This function folds patterns produced by lowering of reduce idioms, such as llvm.vector....
static Instruction * canonicalizeICmpBool(ICmpInst &I, InstCombiner::BuilderTy &Builder)
Integer compare with boolean values can always be turned into bitwise ops.
static Instruction * foldFCmpFSubIntoFCmp(FCmpInst &I, Instruction *LHSI, Constant *RHSC, InstCombinerImpl &CI)
static Value * foldICmpOrXorSubChain(ICmpInst &Cmp, BinaryOperator *Or, InstCombiner::BuilderTy &Builder)
Fold icmp eq/ne (or (xor/sub (X1, X2), xor/sub (X3, X4))), 0.
static bool hasBranchUse(ICmpInst &I)
Given an icmp instruction, return true if any use of this comparison is a branch on sign bit comparis...
static Value * foldICmpWithLowBitMaskedVal(CmpPredicate Pred, Value *Op0, Value *Op1, const SimplifyQuery &Q, InstCombiner &IC)
Some comparisons can be simplified.
static APInt getDemandedBitsLHSMask(ICmpInst &I, unsigned BitWidth)
When performing a comparison against a constant, it is possible that not all the bits in the LHS are ...
static Instruction * foldICmpShlLHSC(ICmpInst &Cmp, Instruction *Shl, const APInt &C)
Fold icmp (shl nuw C2, Y), C.
static Instruction * foldFCmpWithFloorAndCeil(FCmpInst &I, InstCombinerImpl &IC)
static Instruction * foldICmpXorXX(ICmpInst &I, const SimplifyQuery &Q, InstCombinerImpl &IC)
static Instruction * processUZExtIdiom(ICmpInst &I, Value *Val, const APInt *OtherVal, InstCombinerImpl &IC)
Recognize and process idiom involving test for unsigned overflow.
static Instruction * foldICmpOfCmpIntrinsicWithConstant(CmpPredicate Pred, IntrinsicInst *I, const APInt &C, InstCombiner::BuilderTy &Builder)
static Instruction * foldSqrtWithFcmpZero(FCmpInst &I, InstCombinerImpl &IC)
Optimize sqrt(X) compared with zero.
static Instruction * foldFCmpFNegCommonOp(FCmpInst &I)
static bool hasNoWrapProblem(const BinaryOperator &BO, CmpInst::Predicate Pred, bool &HasNSW, bool &HasNUW)
static Instruction * foldICmpWithHighBitMask(ICmpInst &Cmp, InstCombiner::BuilderTy &Builder)
static ICmpInst * canonicalizeCmpWithConstant(ICmpInst &I)
If we have an icmp le or icmp ge instruction with a constant operand, turn it into the appropriate ic...
static Instruction * foldICmpIntrinsicWithIntrinsic(ICmpInst &Cmp, InstCombiner::BuilderTy &Builder)
Fold an icmp with LLVM intrinsics.
static Instruction * foldICmpUSubSatOrUAddSatWithConstant(CmpPredicate Pred, SaturatingInst *II, const APInt &C, InstCombiner::BuilderTy &Builder)
static Instruction * foldICmpPow2Test(ICmpInst &I, InstCombiner::BuilderTy &Builder)
static bool subWithOverflow(APInt &Result, const APInt &In1, const APInt &In2, bool IsSigned=false)
Compute Result = In1-In2, returning true if the result overflowed for this type.
static bool canRewriteGEPAsOffset(Value *Start, Value *Base, GEPNoWrapFlags &NW, const DataLayout &DL, SetVector< Value * > &Explored)
Returns true if we can rewrite Start as a GEP with pointer Base and some integer offset.
static Instruction * foldFCmpFpTrunc(FCmpInst &I, const Instruction &FPTrunc, const Constant &C)
static Instruction * foldICmpXNegX(ICmpInst &I, InstCombiner::BuilderTy &Builder)
static Instruction * processUGT_ADDCST_ADD(ICmpInst &I, Value *A, Value *B, ConstantInt *CI2, ConstantInt *CI1, InstCombinerImpl &IC)
The caller has matched a pattern of the form: I = icmp ugt (add (add A, B), CI2), CI1 If this is of t...
static Value * foldShiftIntoShiftInAnotherHandOfAndInICmp(ICmpInst &I, const SimplifyQuery SQ, InstCombiner::BuilderTy &Builder)
static bool isSignTest(ICmpInst::Predicate &Pred, const APInt &C)
Returns true if the exploded icmp can be expressed as a signed comparison to zero and updates the pre...
static Instruction * transformToIndexedCompare(GEPOperator *GEPLHS, Value *RHS, CmpPredicate Cond, const DataLayout &DL, InstCombiner &IC)
Converts (CMP GEPLHS, RHS) if this change would make RHS a constant.
static Instruction * foldCtpopPow2Test(ICmpInst &I, IntrinsicInst *CtpopLhs, const APInt &CRhs, InstCombiner::BuilderTy &Builder, const SimplifyQuery &Q)
static Instruction * foldFCmpFAbsFSubIntToFP(FCmpInst &I, InstCombinerImpl &IC)
Fold: fabs(uitofp(a) - uitofp(b)) pred C --> a == b where 'pred' is olt, ult, ogt,...
static void setInsertionPoint(IRBuilder<> &Builder, Value *V, bool Before=true)
static bool isNeutralValue(Instruction::BinaryOps BinaryOp, Value *RHS, bool IsSigned)
static bool isMultipleOf(Value *X, const APInt &C, const SimplifyQuery &Q)
Return true if X is a multiple of C.
static Value * foldICmpWithTruncSignExtendedVal(ICmpInst &I, InstCombiner::BuilderTy &Builder)
Some comparisons can be simplified.
static Instruction * foldICmpOrXX(ICmpInst &I, const SimplifyQuery &Q, InstCombinerImpl &IC)
This file provides internal interfaces used to implement the InstCombine.
This file provides the interface for the instcombine pass implementation.
const AbstractManglingParser< Derived, Alloc >::OperatorInfo AbstractManglingParser< Derived, Alloc >::Ops[]
static bool isZero(Value *V, const DataLayout &DL, DominatorTree *DT, AssumptionCache *AC)
uint64_t IntrinsicInst * II
MachineBasicBlock * Folded
SmallVector< MachineOperand, 4 > Cond
static cl::opt< RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode > Mode("regalloc-enable-advisor", cl::Hidden, cl::init(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Default), cl::desc("Enable regalloc advisor mode"), cl::values(clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Default, "default", "Default"), clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Release, "release", "precompiled"), clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Development, "development", "for training")))
This file implements a set that has insertion order iteration characteristics.
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
#define STATISTIC(VARNAME, DESC)
static TableGen::Emitter::Opt Y("gen-skeleton-entry", EmitSkeleton, "Generate example skeleton entry")
static SymbolRef::Type getType(const Symbol *Sym)
cmpResult
IEEE-754R 5.11: Floating Point Comparison Relations.
static constexpr roundingMode rmTowardZero
static constexpr roundingMode rmNearestTiesToEven
static LLVM_ABI ExponentType semanticsMaxExponent(const fltSemantics &)
opStatus
IEEE-754R 7: Default exception handling.
LLVM_ABI opStatus convert(const fltSemantics &ToSemantics, roundingMode RM, bool *losesInfo)
static APFloat getOne(const fltSemantics &Sem, bool Negative=false)
Factory for Positive and Negative One.
static APFloat getSmallestNormalized(const fltSemantics &Sem, bool Negative=false)
Returns the smallest (by magnitude) normalized finite number in the given semantics.
APInt bitcastToAPInt() const
static APFloat getLargest(const fltSemantics &Sem, bool Negative=false)
Returns the largest finite number in the given semantics.
opStatus convertToInteger(MutableArrayRef< integerPart > Input, unsigned int Width, bool IsSigned, roundingMode RM, bool *IsExact) const
opStatus next(bool nextDown)
static APFloat getInf(const fltSemantics &Sem, bool Negative=false)
Factory for Positive and Negative Infinity.
LLVM_ABI FPClassTest classify() const
Return the FPClassTest which will return true for the value.
opStatus roundToIntegral(roundingMode RM)
Class for arbitrary precision integers.
LLVM_ABI 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.
static LLVM_ABI void udivrem(const APInt &LHS, const APInt &RHS, APInt &Quotient, APInt &Remainder)
Dual division/remainder interface.
bool isNegatedPowerOf2() const
Check if this APInt's negated value is a power of two greater than zero.
LLVM_ABI APInt zext(unsigned width) const
Zero extend to a new width.
static APInt getSignMask(unsigned BitWidth)
Get the SignMask for a specific bit width.
bool isMinSignedValue() const
Determine if this is the smallest signed value.
uint64_t getZExtValue() const
Get zero extended value.
unsigned getActiveBits() const
Compute the number of active bits in the value.
LLVM_ABI APInt trunc(unsigned width) const
Truncate to new 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".
APInt abs() const
Get the absolute value.
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.
LLVM_ABI APInt usub_ov(const APInt &RHS, bool &Overflow) const
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.
bool isSignMask() const
Check if the APInt's value is returned by getSignMask.
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.
LLVM_ABI APInt sadd_ov(const APInt &RHS, bool &Overflow) const
bool eq(const APInt &RHS) const
Equality comparison.
LLVM_ABI APInt sdiv(const APInt &RHS) const
Signed division function for APInt.
LLVM_ABI APInt uadd_ov(const APInt &RHS, bool &Overflow) const
void negate()
Negate this APInt in place.
unsigned countr_zero() const
Count the number of trailing zero bits.
unsigned countl_zero() const
The APInt version of std::countl_zero.
static APInt getSignedMinValue(unsigned numBits)
Gets minimum signed value of APInt for a specific bit width.
bool isStrictlyPositive() const
Determine if this APInt Value is positive.
void flipAllBits()
Toggle every bit to its opposite value.
unsigned countl_one() const
Count the number of leading one bits.
unsigned logBase2() const
uint64_t getLimitedValue(uint64_t Limit=UINT64_MAX) const
If this value is smaller than the specified limit, return it, otherwise return the limit value.
APInt ashr(unsigned ShiftAmt) const
Arithmetic right-shift function.
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 isPowerOf2() const
Check if this APInt's value is a power of two greater than zero.
static APInt getLowBitsSet(unsigned numBits, unsigned loBitsSet)
Constructs an APInt value that has the bottom loBitsSet bits set.
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.
bool sge(const APInt &RHS) const
Signed greater or equal comparison.
LLVM_ABI APInt ssub_ov(const APInt &RHS, bool &Overflow) const
bool isOne() const
Determine if this is a value of 1.
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.
APInt lshr(unsigned shiftAmt) const
Logical right-shift function.
unsigned countr_one() const
Count the number of trailing one bits.
bool uge(const APInt &RHS) const
Unsigned greater or equal comparison.
An arbitrary precision integer that knows its signedness.
static APSInt getMinValue(uint32_t numBits, bool Unsigned)
Return the APSInt representing the minimum integer value with the given bit width and signedness.
static APSInt getMaxValue(uint32_t numBits, bool Unsigned)
Return the APSInt representing the maximum integer value with the given bit width and signedness.
an instruction to allocate memory on the stack
Represent a constant reference to an array (0 or more elements consecutively in memory),...
LLVM Basic Block Representation.
LLVM_ABI const_iterator getFirstInsertionPt() const
Returns an iterator to the first instruction in this block that is suitable for inserting a non-PHI i...
LLVM_ABI const BasicBlock * getSinglePredecessor() const
Return the predecessor of this block if it has a single predecessor block.
const Instruction * getTerminator() const LLVM_READONLY
Returns the terminator instruction; assumes that the block is well-formed.
BinaryOps getOpcode() const
static LLVM_ABI BinaryOperator * CreateNot(Value *Op, const Twine &Name="", InsertPosition InsertBefore=nullptr)
static LLVM_ABI BinaryOperator * Create(BinaryOps Op, Value *S1, Value *S2, const Twine &Name=Twine(), InsertPosition InsertBefore=nullptr)
Construct a binary instruction, given the opcode and the two operands.
Value * getArgOperand(unsigned i) const
This class represents a function call, abstracting a target machine's calling convention.
static CallInst * Create(FunctionType *Ty, Value *F, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
This class is the base class for the comparison instructions.
static Type * makeCmpResultType(Type *opnd_type)
Create a result type for fcmp/icmp.
Predicate getStrictPredicate() const
For example, SGE -> SGT, SLE -> SLT, ULE -> ULT, UGE -> UGT.
bool isEquality() const
Determine if this is an equals/not equals predicate.
static LLVM_ABI Predicate getFlippedStrictnessPredicate(Predicate pred)
This is a static version that you can use without an instruction available.
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 LLVM_ABI 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.
static LLVM_ABI CmpInst * Create(OtherOps Op, Predicate Pred, Value *S1, Value *S2, const Twine &Name="", InsertPosition InsertBefore=nullptr)
Construct a compare instruction, given the opcode, the predicate and the two operands.
Predicate getNonStrictPredicate() const
For example, SGT -> SGE, SLT -> SLE, ULT -> ULE, UGT -> UGE.
static LLVM_ABI bool isStrictPredicate(Predicate predicate)
This is a static version that you can use without an instruction available.
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 isIntPredicate(Predicate P)
An abstraction over a floating-point predicate, and a pack of an integer predicate with samesign info...
static LLVM_ABI CmpPredicate getSwapped(CmpPredicate P)
Get the swapped predicate of a CmpPredicate.
Conditional Branch instruction.
static LLVM_ABI Constant * getIntToPtr(Constant *C, Type *Ty, bool OnlyIfReduced=false)
static LLVM_ABI Constant * getPointerBitCastOrAddrSpaceCast(Constant *C, Type *Ty)
Create a BitCast or AddrSpaceCast for a pointer type depending on the address space.
static LLVM_ABI Constant * getSub(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
static LLVM_ABI Constant * getNot(Constant *C)
static LLVM_ABI Constant * getPtrToInt(Constant *C, Type *Ty, bool OnlyIfReduced=false)
static LLVM_ABI Constant * getXor(Constant *C1, Constant *C2)
static LLVM_ABI Constant * getNeg(Constant *C, bool HasNSW=false)
static LLVM_ABI ConstantFP * getZero(Type *Ty, bool Negative=false)
This is the shared class of boolean and integer constants.
uint64_t getLimitedValue(uint64_t Limit=~0ULL) const
getLimitedValue - If the value is smaller than the specified limit, return it, otherwise return the l...
static LLVM_ABI ConstantInt * getTrue(LLVMContext &Context)
static ConstantInt * getSigned(IntegerType *Ty, int64_t V, bool ImplicitTrunc=false)
Return a ConstantInt with the specified value for the specified type.
bool isZero() const
This is just a convenience method to make client code smaller for a common code.
static LLVM_ABI ConstantInt * getFalse(LLVMContext &Context)
unsigned getBitWidth() const
getBitWidth - Return the scalar bitwidth of this constant.
const APInt & getValue() const
Return the constant as an APInt value reference.
static LLVM_ABI ConstantInt * getBool(LLVMContext &Context, bool V)
This class represents a range of values.
LLVM_ABI ConstantRange add(const ConstantRange &Other) const
Return a new range representing the possible values resulting from an addition of a value in this ran...
LLVM_ABI bool getEquivalentICmp(CmpInst::Predicate &Pred, APInt &RHS) const
Set up Pred and RHS such that ConstantRange::makeExactICmpRegion(Pred, RHS) == *this.
LLVM_ABI ConstantRange subtract(const APInt &CI) const
Subtract the specified constant from the endpoints of this constant range.
const APInt * getSingleElement() const
If this set contains a single element, return it, otherwise return null.
LLVM_ABI ConstantRange difference(const ConstantRange &CR) const
Subtract the specified range from this range (aka relative complement of the sets).
LLVM_ABI bool isEmptySet() const
Return true if this set contains no members.
LLVM_ABI ConstantRange truncate(uint32_t BitWidth, unsigned NoWrapKind=0) const
Return a new range in the specified integer type, which must be strictly smaller than the current typ...
static LLVM_ABI 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...
LLVM_ABI ConstantRange inverse() const
Return a new range that is the logical not of the current set.
LLVM_ABI ConstantRange intersectWith(const ConstantRange &CR, PreferredRangeType Type=Smallest) const
Return the range that results from the intersection of this range with another range.
static ConstantRange getNonEmpty(APInt Lower, APInt Upper)
Create non-empty constant range with the given bounds.
LLVM_ABI ConstantRange sub(const ConstantRange &Other) const
Return a new range representing the possible values resulting from a subtraction of a value in this r...
static LLVM_ABI ConstantRange makeExactNoWrapRegion(Instruction::BinaryOps BinOp, const APInt &Other, unsigned NoWrapKind)
Produce the range that contains X if and only if "X BinOp Other" does not wrap.
static LLVM_ABI Constant * getSplat(ElementCount EC, Constant *Elt)
Return a ConstantVector with the specified constant in each element.
This is an important base class in LLVM.
static LLVM_ABI Constant * getIntegerValue(Type *Ty, const APInt &V)
Return the value for an integer or pointer constant, or a vector thereof, with the given scalar value...
bool isNullValue() const
Return true if this is the value that would be returned by getNullValue.
static LLVM_ABI Constant * getAllOnesValue(Type *Ty)
LLVM_ABI bool isAllOnesValue() const
Return true if this is the value that would be returned by getAllOnesValue.
LLVM_ABI const APInt & getUniqueInteger() const
If C is a constant integer then return its value, otherwise C must be a vector of constant integers,...
static LLVM_ABI Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
A parsed version of the target data layout string in and methods for querying it.
bool contains(const_arg_type_t< KeyT > Val) const
Return true if the specified key is in the map, false otherwise.
iterator find(const_arg_type_t< KeyT > Val)
This instruction compares its operands according to the predicate given to the constructor.
static bool isCommutative(Predicate Pred)
static bool isEquality(Predicate Pred)
Represents flags for the getelementptr instruction/expression.
bool hasNoUnsignedSignedWrap() const
bool hasNoUnsignedWrap() const
GEPNoWrapFlags intersectForOffsetAdd(GEPNoWrapFlags Other) const
Given (gep (gep p, x), y), determine the nowrap flags for (gep p, x+y).
static GEPNoWrapFlags none()
bool isInBounds() const
Test whether this is an inbounds GEP, as defined by LangRef.html.
LLVM_ABI Type * getSourceElementType() const
Value * getPointerOperand()
GEPNoWrapFlags getNoWrapFlags() const
bool hasAllConstantIndices() const
Return true if all of the indices of this GEP are constant integers.
This instruction compares its operands according to the predicate given to the constructor.
static bool isGE(Predicate P)
Return true if the predicate is SGE or UGE.
static LLVM_ABI bool compare(const APInt &LHS, const APInt &RHS, ICmpInst::Predicate Pred)
Return result of LHS Pred RHS comparison.
static bool isLT(Predicate P)
Return true if the predicate is SLT or ULT.
static bool isGT(Predicate P)
Return true if the predicate is SGT or UGT.
Predicate getFlippedSignednessPredicate() const
For example, SLT->ULT, ULT->SLT, SLE->ULE, ULE->SLE, EQ->EQ.
Predicate getSignedPredicate() const
For example, EQ->EQ, SLE->SLE, UGT->SGT, etc.
bool isEquality() const
Return true if this predicate is either EQ or NE.
static bool isEquality(Predicate P)
Return true if this predicate is either EQ or NE.
bool isRelational() const
Return true if the predicate is relational (not EQ or NE).
Predicate getUnsignedPredicate() const
For example, EQ->EQ, SLE->ULE, UGT->UGT, etc.
static bool isLE(Predicate P)
Return true if the predicate is SLE or ULE.
Common base class shared among various IRBuilders.
Value * CreateICmp(CmpInst::Predicate P, Value *LHS, Value *RHS, const Twine &Name="", bool HasSameSign=false)
Value * CreateAnd(Value *LHS, Value *RHS, const Twine &Name="")
void SetInsertPoint(BasicBlock *TheBB)
This specifies that created instructions should be appended to the end of the specified block.
Value * CreateOr(Value *LHS, Value *RHS, const Twine &Name="", bool IsDisjoint=false)
ConstantInt * getInt(const APInt &AI)
Get a constant integer value.
LLVM_ABI Value * CreateUnaryIntrinsic(Intrinsic::ID ID, Value *Op, FMFSource FMFSource={}, const Twine &Name="")
Create a call to intrinsic ID with 1 operand which is mangled on its type.
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
Instruction * foldICmpShrConstant(ICmpInst &Cmp, BinaryOperator *Shr, const APInt &C)
Fold icmp ({al}shr X, Y), C.
Instruction * foldICmpWithZextOrSext(ICmpInst &ICmp)
Instruction * foldICmpSelectConstant(ICmpInst &Cmp, SelectInst *Select, ConstantInt *C)
Instruction * foldICmpSRemConstant(ICmpInst &Cmp, BinaryOperator *UDiv, const APInt &C)
Instruction * foldICmpBinOpWithConstant(ICmpInst &Cmp, BinaryOperator *BO, const APInt &C)
Fold an icmp with BinaryOp and constant operand: icmp Pred BO, C.
Instruction * foldICmpOrConstant(ICmpInst &Cmp, BinaryOperator *Or, const APInt &C)
Fold icmp (or X, Y), C.
Instruction * foldICmpTruncWithTruncOrExt(ICmpInst &Cmp, const SimplifyQuery &Q)
Fold icmp (trunc nuw/nsw X), (trunc nuw/nsw Y).
Instruction * foldSignBitTest(ICmpInst &I)
Fold equality-comparison between zero and any (maybe truncated) right-shift by one-less-than-bitwidth...
Instruction * foldCmpLoadFromIndexedGlobal(LoadInst *LI, CmpPredicate Pred, Constant *RHSC, Instruction &CtxI, ConstantInt *AndCst=nullptr)
Try to fold cmp pred (load (gep GV, ...)), cmpcst where GV is a global variable with a constant initi...
Instruction * foldOpIntoPhi(Instruction &I, PHINode *PN, bool AllowMultipleUses=false)
Given a binary operator, cast instruction, or select which has a PHI node as operand #0,...
Value * insertRangeTest(Value *V, const APInt &Lo, const APInt &Hi, bool isSigned, bool Inside)
Emit a computation of: (V >= Lo && V < Hi) if Inside is true, otherwise (V < Lo || V >= Hi).
Instruction * foldICmpBinOp(ICmpInst &Cmp, const SimplifyQuery &SQ)
Try to fold icmp (binop), X or icmp X, (binop).
Instruction * foldICmpSubConstant(ICmpInst &Cmp, BinaryOperator *Sub, const APInt &C)
Fold icmp (sub X, Y), C.
Instruction * foldICmpWithClamp(ICmpInst &Cmp, Value *X, MinMaxIntrinsic *Min)
Match and fold patterns like: icmp eq/ne X, min(max(X, Lo), Hi) which represents a range check and ca...
Instruction * foldICmpInstWithConstantNotInt(ICmpInst &Cmp)
Handle icmp with constant (but not simple integer constant) RHS.
bool matchCommonBinOpOperands(Value *Op0, Value *Op1, CmpInst::Predicate Pred, Value *&LHS, Value *&RHS, const SimplifyQuery &Q)
Match Op0 Pred Op1 on binops with a removable common operand.
bool SimplifyDemandedBits(Instruction *I, unsigned Op, const APInt &DemandedMask, KnownBits &Known, const SimplifyQuery &Q, unsigned Depth=0) override
This form of SimplifyDemandedBits simplifies the specified instruction operand if possible,...
Instruction * foldICmpShlConstConst(ICmpInst &I, Value *ShAmt, const APInt &C1, const APInt &C2)
Handle "(icmp eq/ne (shl AP2, A), AP1)" -> (icmp eq/ne A, TrailingZeros(AP1) - TrailingZeros(AP2)).
Value * reassociateShiftAmtsOfTwoSameDirectionShifts(BinaryOperator *Sh0, const SimplifyQuery &SQ, bool AnalyzeForSignBitExtraction=false)
Instruction * foldICmpEqIntrinsicWithConstant(ICmpInst &ICI, IntrinsicInst *II, const APInt &C)
Fold an equality icmp with LLVM intrinsic and constant operand.
Instruction * FoldOpIntoSelect(Instruction &Op, SelectInst *SI, bool FoldWithMultiUse=false, bool SimplifyBothArms=false)
Given an instruction with a select as one operand and a constant as the other operand,...
Value * foldMultiplicationOverflowCheck(ICmpInst &Cmp)
Fold (-1 u/ x) u< y ((x * y) ?
Instruction * foldICmpWithConstant(ICmpInst &Cmp)
Fold icmp Pred X, C.
OverflowResult computeOverflow(Instruction::BinaryOps BinaryOp, bool IsSigned, Value *LHS, Value *RHS, Instruction *CtxI) const
CmpInst * canonicalizeICmpPredicate(CmpInst &I)
If we have a comparison with a non-canonical predicate, if we can update all the users,...
Instruction * eraseInstFromFunction(Instruction &I) override
Combiner aware instruction erasure.
Instruction * foldICmpWithZero(ICmpInst &Cmp)
Instruction * foldICmpBinOpEqualityWithConstant(ICmpInst &Cmp, BinaryOperator *BO, const APInt &C)
Fold an icmp equality instruction with binary operator LHS and constant RHS: icmp eq/ne BO,...
Instruction * foldICmpUsingBoolRange(ICmpInst &I)
If one operand of an icmp is effectively a bool (value range of {0,1}), then try to reduce patterns b...
Instruction * foldICmpWithTrunc(ICmpInst &Cmp)
Instruction * foldCmpSelectOfConstants(CmpInst &I)
Fold fcmp/icmp pred (select C1, TV1, FV1), (select C2, TV2, FV2) where all true/false values are cons...
Instruction * foldICmpIntrinsicWithConstant(ICmpInst &ICI, IntrinsicInst *II, const APInt &C)
Fold an icmp with LLVM intrinsic and constant operand: icmp Pred II, C.
bool matchThreeWayIntCompare(SelectInst *SI, Value *&LHS, Value *&RHS, ConstantInt *&Less, ConstantInt *&Equal, ConstantInt *&Greater)
Match a select chain which produces one of three values based on whether the LHS is less than,...
const InstCombineCLOptions & CLOpts
Instruction * visitFCmpInst(FCmpInst &I)
Instruction * foldICmpUsingKnownBits(ICmpInst &Cmp)
Try to fold the comparison based on range information we can get by checking whether bits are known t...
Instruction * foldICmpDivConstant(ICmpInst &Cmp, BinaryOperator *Div, const APInt &C)
Fold icmp ({su}div X, Y), C.
Instruction * foldIRemByPowerOfTwoToBitTest(ICmpInst &I)
If we have: icmp eq/ne (urem/srem x, y), 0 iff y is a power-of-two, we can replace this with a bit te...
Instruction * foldFCmpIntToFPConst(FCmpInst &I, Instruction *LHSI, Constant *RHSC)
Fold fcmp ([us]itofp x, cst) if possible.
Instruction * foldICmpUDivConstant(ICmpInst &Cmp, BinaryOperator *UDiv, const APInt &C)
Fold icmp (udiv X, Y), C.
Instruction * foldICmpAddOpConst(Value *X, const APInt &C, CmpPredicate Pred)
Fold "icmp pred (X+C), X".
Instruction * foldICmpWithCastOp(ICmpInst &ICmp)
Handle icmp (cast x), (cast or constant).
Instruction * foldICmpTruncConstant(ICmpInst &Cmp, TruncInst *Trunc, const APInt &C)
Fold icmp (trunc X), C.
Instruction * foldICmpAddConstant(ICmpInst &Cmp, BinaryOperator *Add, const APInt &C)
Fold icmp (add X, Y), C.
Instruction * foldICmpMulConstant(ICmpInst &Cmp, BinaryOperator *Mul, const APInt &C)
Fold icmp (mul X, Y), C.
Instruction * foldICmpCommutative(CmpPredicate Pred, Value *Op0, Value *Op1, ICmpInst &CtxI)
Instruction * tryFoldInstWithCtpopWithNot(Instruction *I)
Instruction * foldICmpXorConstant(ICmpInst &Cmp, BinaryOperator *Xor, const APInt &C)
Fold icmp (xor X, Y), C.
Instruction * foldSelectICmp(CmpPredicate Pred, SelectInst *SI, Value *RHS, const ICmpInst &I)
Instruction * foldICmpInstWithConstantAllowPoison(ICmpInst &Cmp, const APInt &C)
Try to fold integer comparisons with a constant operand: icmp Pred X, C where X is some kind of instr...
Instruction * foldIsMultipleOfAPowerOfTwo(ICmpInst &Cmp)
Fold icmp eq (num + mask) & ~mask, num to icmp eq (and num, mask), 0 Where mask is a low bit mask.
Instruction * foldICmpAndShift(ICmpInst &Cmp, BinaryOperator *And, const APInt &C1, const APInt &C2)
Fold icmp (and (sh X, Y), C2), C1.
Instruction * foldICmpBinOpWithConstantViaTruthTable(ICmpInst &Cmp, BinaryOperator *BO, const APInt &C)
Instruction * foldICmpInstWithConstant(ICmpInst &Cmp)
Try to fold integer comparisons with a constant operand: icmp Pred X, C where X is some kind of instr...
Instruction * foldICmpXorShiftConst(ICmpInst &Cmp, BinaryOperator *Xor, const APInt &C)
For power-of-2 C: ((X s>> ShiftC) ^ X) u< C --> (X + C) u< (C << 1) ((X s>> ShiftC) ^ X) u> (C - 1) -...
Instruction * foldICmpShlConstant(ICmpInst &Cmp, BinaryOperator *Shl, const APInt &C)
Fold icmp (shl X, Y), C.
Instruction * foldICmpAndConstant(ICmpInst &Cmp, BinaryOperator *And, const APInt &C)
Fold icmp (and X, Y), C.
Instruction * foldICmpEquality(ICmpInst &Cmp)
Instruction * foldICmpWithMinMax(Instruction &I, MinMaxIntrinsic *MinMax, Value *Z, CmpPredicate Pred)
Fold icmp Pred min|max(X, Y), Z.
bool dominatesAllUses(const Instruction *DI, const Instruction *UI, const BasicBlock *DB) const
True when DB dominates all uses of DI except UI.
bool foldAllocaCmp(AllocaInst *Alloca)
Instruction * visitICmpInst(ICmpInst &I)
Instruction * foldICmpWithDominatingICmp(ICmpInst &Cmp)
Canonicalize icmp instructions based on dominating conditions.
bool replacedSelectWithOperand(SelectInst *SI, const ICmpInst *Icmp, const unsigned SIOpd)
Try to replace select with select operand SIOpd in SI-ICmp sequence.
Instruction * foldICmpShrConstConst(ICmpInst &I, Value *ShAmt, const APInt &C1, const APInt &C2)
Handle "(icmp eq/ne (ashr/lshr AP2, A), AP1)" -> (icmp eq/ne A, Log2(AP2/AP1)) -> (icmp eq/ne A,...
void freelyInvertAllUsersOf(Value *V, Value *IgnoredUser=nullptr)
Freely adapt every user of V as-if V was changed to !V.
Instruction * foldICmpAndConstConst(ICmpInst &Cmp, BinaryOperator *And, const APInt &C1)
Fold icmp (and X, C2), C1.
Instruction * foldICmpBitCast(ICmpInst &Cmp)
Instruction * foldGEPICmp(GEPOperator *GEPLHS, Value *RHS, CmpPredicate Cond, Instruction &I)
Fold comparisons between a GEP instruction and something else.
The core instruction combiner logic.
OverflowResult computeOverflowForSignedMul(const Value *LHS, const Value *RHS, const Instruction *CtxI) const
Module & getModule() const
LLVM_ABI bool canBeCastedExactlyIntToFP(Value *V, Type *FPTy, bool IsSigned, const Instruction *CtxI=nullptr) const
bool isFreeToInvert(Value *V, bool WillInvertAllUses, bool &DoesConsume)
Return true if the specified value is free to invert (apply ~ to).
static unsigned getComplexity(Value *V)
Assign a complexity or rank value to LLVM Values.
unsigned ComputeMaxSignificantBits(const Value *Op, const Instruction *CtxI=nullptr, unsigned Depth=0) const
bool isKnownToBeAPowerOfTwo(const Value *V, bool OrZero=false, const Instruction *CtxI=nullptr, unsigned Depth=0)
Instruction * replaceInstUsesWith(Instruction &I, Value *V)
A combiner-aware RAUW-like routine.
static Constant * SubOne(Constant *C)
Subtract one from a Constant.
OverflowResult computeOverflowForUnsignedSub(const Value *LHS, const Value *RHS, const Instruction *CtxI) const
static bool isCanonicalPredicate(CmpPredicate Pred)
Predicate canonicalization reduces the number of patterns that need to be matched by other transforms...
IRBuilder< TargetFolder, IRBuilderInstCombineInserter > BuilderTy
An IRBuilder that automatically inserts new instructions into the worklist.
bool canFreelyInvertAllUsersOf(Instruction *V, Value *IgnoredUser)
Given i1 V, can every user of V be freely adapted if V is changed to !V ?
OverflowResult computeOverflowForSignedAdd(const WithCache< const Value * > &LHS, const WithCache< const Value * > &RHS, const Instruction *CtxI) const
void addToWorklist(Instruction *I)
Instruction * replaceOperand(Instruction &I, unsigned OpNum, Value *V)
Replace operand of instruction and add old operand to the worklist.
OverflowResult computeOverflowForUnsignedMul(const Value *LHS, const Value *RHS, const Instruction *CtxI, bool IsNSW=false) const
OverflowResult computeOverflowForSignedSub(const Value *LHS, const Value *RHS, const Instruction *CtxI) const
OverflowResult computeOverflowForUnsignedAdd(const WithCache< const Value * > &LHS, const WithCache< const Value * > &RHS, const Instruction *CtxI) const
void computeKnownBits(const Value *V, KnownBits &Known, const Instruction *CtxI, unsigned Depth=0) const
Value * getFreelyInverted(Value *V, bool WillInvertAllUses, BuilderTy *Builder, bool &DoesConsume)
const SimplifyQuery & getSimplifyQuery() const
LLVM_ABI bool hasNoNaNs() const LLVM_READONLY
Determine whether the no-NaNs flag is set.
LLVM_ABI bool hasNoUnsignedWrap() const LLVM_READONLY
Determine whether the no unsigned wrap flag is set.
LLVM_ABI bool hasNoInfs() const LLVM_READONLY
Determine whether the no-infs flag is set.
bool isArithmeticShift() const
Return true if this is an arithmetic shift right.
LLVM_ABI bool hasNoSignedWrap() const LLVM_READONLY
Determine whether the no signed wrap flag is set.
LLVM_ABI bool isCommutative() const LLVM_READONLY
Return true if the instruction is commutative:
LLVM_ABI bool isExact() const LLVM_READONLY
Determine whether the exact flag is set.
iterator_range< user_iterator > users()
unsigned getOpcode() const
Returns a member of one of the enums like Instruction::Add.
static LLVM_ABI IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
A wrapper class for inspecting calls to intrinsic functions.
Intrinsic::ID getIntrinsicID() const
Return the intrinsic ID of this intrinsic.
An instruction for reading from memory.
Value * getPointerOperand()
bool isVolatile() const
Return true if this is a load from a volatile memory location.
This class represents min/max intrinsics.
static bool isMin(Intrinsic::ID ID)
Whether the intrinsic is a smin or umin.
static bool isSigned(Intrinsic::ID ID)
Whether the intrinsic is signed or unsigned.
A Module instance is used to store all the information related to an LLVM module.
void addIncoming(Value *V, BasicBlock *BB)
Add an incoming value to the end of the PHI list.
static PHINode * Create(Type *Ty, unsigned NumReservedValues, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
Constructors - NumReservedValues is a hint for the number of incoming edges that this phi node will h...
Represents a saturating add/sub intrinsic.
This class represents the LLVM 'select' instruction.
static SelectInst * Create(Value *C, Value *S1, Value *S2, const Twine &NameStr="", InsertPosition InsertBefore=nullptr, const Instruction *MDFrom=nullptr)
A vector that has set insertion semantics.
size_type size() const
Determine the number of elements in the SetVector.
bool contains(const_arg_type key) const
Check if the SetVector contains the given key.
bool insert(const value_type &X)
Insert a new element into the SetVector.
This instruction constructs a fixed permutation of two input vectors.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
reference emplace_back(ArgTypes &&... Args)
void push_back(const T &Elt)
reverse_iterator rbegin()
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
This class represents a truncation of integer types.
bool hasNoSignedWrap() const
Test whether this operation is known to never undergo signed overflow, aka the nsw property.
bool hasNoUnsignedWrap() const
Test whether this operation is known to never undergo unsigned overflow, aka the nuw property.
The instances of the Type class are immutable: once they are created, they are never changed.
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.
LLVM_ABI unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
bool isPPC_FP128Ty() const
Return true if this is powerpc long double.
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type.
Type * getScalarType() const
If this is a vector type, return the element type, otherwise return 'this'.
LLVM_ABI TypeSize getPrimitiveSizeInBits() const LLVM_READONLY
Return the basic size of this type if it is a primitive type.
LLVM_ABI Type * getWithNewBitWidth(unsigned NewBitWidth) const
Given an integer or vector type, change the lane bitwidth to NewBitwidth, whilst keeping the old numb...
LLVMContext & getContext() const
Return the LLVMContext in which this type was uniqued.
static LLVM_ABI IntegerType * getInt1Ty(LLVMContext &C)
bool isPtrOrPtrVectorTy() const
Return true if this is a pointer type or a vector of pointer types.
LLVM_ABI int getFPMantissaWidth() const
Return the width of the mantissa of this type.
LLVM_ABI const fltSemantics & getFltSemantics() const
A Use represents the edge between a Value definition and its users.
void setOperand(unsigned i, Value *Val)
Value * getOperand(unsigned i) const
unsigned getNumOperands() const
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
bool hasOneUse() const
Return true if there is exactly one use of this value.
LLVMContext & getContext() const
All values hold a context through their type.
iterator_range< user_iterator > users()
LLVM_ABI bool hasNUsesOrMore(unsigned N) const
Return true if this value has N uses or more.
LLVM_ABI const Value * stripAndAccumulateConstantOffsets(const DataLayout &DL, APInt &Offset, bool AllowNonInbounds, bool AllowInvariantGroup=false, function_ref< bool(Value &Value, APInt &Offset)> ExternalAnalysis=nullptr, bool LookThroughIntToPtr=false) const
Accumulate the constant offset this value has compared to a base pointer.
LLVM_ABI const Value * stripPointerCasts() const
Strip off pointer casts, all-zero GEPs and address space casts.
iterator_range< use_iterator > uses()
LLVM_ABI StringRef getName() const
Return a constant reference to the value's name.
LLVM_ABI void takeName(Value *V)
Transfer the name from V to this value.
static LLVM_ABI VectorType * get(Type *ElementType, ElementCount EC)
This static method is the primary way to construct an VectorType.
constexpr ScalarTy getFixedValue() const
constexpr bool isScalable() const
Returns whether the quantity is scaled by a runtime quantity (vscale).
const ParentTy * getParent() const
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
LLVM_ABI APInt RoundingUDiv(const APInt &A, const APInt &B, APInt::Rounding RM)
Return A unsign-divided by B, rounded by the given rounding mode.
LLVM_ABI APInt RoundingSDiv(const APInt &A, const APInt &B, APInt::Rounding RM)
Return A sign-divided by B, rounded by the given rounding mode.
LLVM_ABI Function * getOrInsertDeclaration(Module *M, ID id, ArrayRef< Type * > OverloadTys={})
Look up the Function declaration of the intrinsic id in the Module M.
SpecificConstantMatch m_ZeroInt()
Convenience matchers for specific integer values.
auto m_PosZeroFP()
Matches a floating-point positive zero.
BinaryOp_match< SpecificConstantMatch, SrcTy, TargetOpcode::G_SUB > m_Neg(const SrcTy &&Src)
Matches a register negated by a G_SUB.
AllOnesConstantMatch m_AllOnes()
BinaryOp_match< SrcTy, SpecificConstantMatch, TargetOpcode::G_XOR, true > m_Not(const SrcTy &&Src)
Matches a register not-ed by a G_XOR.
OneUse_match< SubPat > m_OneUse(const SubPat &SP)
match_unless< Pattern > m_Unless(const Pattern &P)
Match if the inner matcher does NOT match.
match_combine_or< Ty... > m_CombineOr(const Ty &...Ps)
Combine pattern matchers matching any of Ps patterns.
match_combine_and< Ty... > m_CombineAnd(const Ty &...Ps)
Combine pattern matchers matching all of Ps patterns.
cst_pred_ty< is_lowbit_mask > m_LowBitMask()
Match an integer or vector with only the low bit(s) set.
BinaryOp_match< LHS, RHS, Instruction::And > m_And(const LHS &L, const RHS &R)
cst_pred_ty< is_negative > m_Negative()
Match an integer or vector of negative values.
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)
BinaryOp_match< LHS, RHS, Instruction::AShr > m_AShr(const LHS &L, const RHS &R)
BinaryOp_match< LHS, RHS, Instruction::FSub > m_FSub(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)
match_combine_or< CastInst_match< OpTy, TruncInst >, OpTy > m_TruncOrSelf(const OpTy &Op)
ap_match< APInt > m_APInt(const APInt *&Res)
Match a ConstantInt or splatted ConstantVector, binding the specified pointer to the contained APInt.
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.
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)
auto m_Sqrt(const Opnd0 &Op0)
ap_match< APInt > m_APIntAllowPoison(const APInt *&Res)
Match APInt while allowing poison in splat vector constants.
specific_intval< false > m_SpecificInt(const APInt &V)
Match a specific integer value or vector with all elements equal to the value.
match_combine_or< CastInst_match< OpTy, ZExtInst >, OpTy > m_ZExtOrSelf(const OpTy &Op)
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.
match_bind< Instruction > m_Instruction(Instruction *&I)
Match an instruction, capturing it if we match.
match_deferred< 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()...
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.
specific_intval< true > m_SpecificIntAllowPoison(const APInt &V)
ap_match< APFloat > m_APFloat(const APFloat *&Res)
Match a ConstantFP or splatted ConstantVector, binding the specified pointer to the contained APFloat...
CmpClass_match< LHS, RHS, ICmpInst, true > m_c_ICmp(CmpPredicate &Pred, const LHS &L, const RHS &R)
Matches an ICmp with a predicate over LHS and RHS in either order.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap, true > m_c_NUWAdd(const LHS &L, const RHS &R)
OverflowingBinaryOp_match< cst_pred_ty< is_zero_int >, ValTy, Instruction::Sub, OverflowingBinaryOperator::NoSignedWrap > m_NSWNeg(const ValTy &V)
Matches a 'Neg' as 'sub nsw 0, V'.
cst_pred_ty< is_nonnegative > m_NonNegative()
Match an integer or vector of non-negative values.
auto m_SMax(const Opnd0 &Op0, const Opnd1 &Op1)
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.
auto m_BinOp()
Match an arbitrary binary operation and ignore it.
auto m_UMax(const Opnd0 &Op0, const Opnd1 &Op1)
ExtractValue_match< Ind, Val_t > m_ExtractValue(const Val_t &V)
Match a single index ExtractValue instruction.
BinOpPred_match< LHS, RHS, is_logical_shift_op > m_LogicalShift(const LHS &L, const RHS &R)
Matches logical shift operations.
match_combine_or< CastInst_match< OpTy, UIToFPInst >, CastInst_match< OpTy, SIToFPInst > > m_IToFP(const OpTy &Op)
auto m_Value()
Match an arbitrary value and ignore it.
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::FAdd > m_FAdd(const LHS &L, const RHS &R)
BinaryOp_match< LHS, RHS, Instruction::Mul > m_Mul(const LHS &L, const RHS &R)
auto m_Constant()
Match an arbitrary Constant and ignore it.
NoWrapTrunc_match< OpTy, TruncInst::NoSignedWrap > m_NSWTrunc(const OpTy &Op)
Matches trunc nsw.
TwoOps_match< V1_t, V2_t, Instruction::ShuffleVector > m_Shuffle(const V1_t &v1, const V2_t &v2)
Matches ShuffleVectorInst independently of mask value.
cst_pred_ty< is_non_zero_int > m_NonZeroInt()
Match a non-zero integer or a vector with all non-zero elements.
ThreeOps_match< decltype(m_Value()), LHS, RHS, Instruction::Select, true > m_c_Select(const LHS &L, const RHS &R)
Match Select(C, LHS, RHS) or Select(C, RHS, LHS)
CastInst_match< OpTy, FPExtInst > m_FPExt(const OpTy &Op)
OverflowingBinaryOp_match< LHS, RHS, Instruction::Shl, OverflowingBinaryOperator::NoSignedWrap > m_NSWShl(const LHS &L, const RHS &R)
CastInst_match< OpTy, ZExtInst > m_ZExt(const OpTy &Op)
Matches ZExt.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Shl, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWShl(const LHS &L, const RHS &R)
OverflowingBinaryOp_match< LHS, RHS, Instruction::Mul, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWMul(const LHS &L, const RHS &R)
BinaryOp_match< LHS, RHS, Instruction::UDiv > m_UDiv(const LHS &L, const RHS &R)
is_zero< true > m_Zero()
Match any null constant or a vector with all elements equal to 0.
match_immconstant_ty m_ImmConstant()
Match an arbitrary immediate Constant and ignore it.
cst_pred_ty< is_negated_power2_or_zero > m_NegatedPower2OrZero()
Match a integer or vector negated power-of-2.
NoWrapTrunc_match< OpTy, TruncInst::NoUnsignedWrap > m_NUWTrunc(const OpTy &Op)
Matches trunc nuw.
cst_pred_ty< custom_checkfn< APInt > > m_CheckedInt(function_ref< bool(const APInt &)> CheckFn)
Match an integer or vector where CheckFn(ele) for each element is true.
SelectLike_match< CondTy, LTy, RTy > m_SelectLike(const CondTy &C, const LTy &TrueC, const RTy &FalseC)
Matches a value that behaves like a boolean-controlled select, i.e.
cst_pred_ty< is_lowbit_mask_or_zero > m_LowBitMaskOrZero()
Match an integer or vector with only the low bit(s) set.
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.
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".
CastInst_match< OpTy, UIToFPInst > m_UIToFP(const OpTy &Op)
CastOperator_match< OpTy, Instruction::BitCast > m_BitCast(const OpTy &Op)
Matches BitCast.
cstfp_pred_ty< is_finitenonzero > m_FiniteNonZero()
Match a finite non-zero FP constant.
auto m_Intrinsic(const Ts &...Ops)
Match intrinsic calls like this: m_Intrinsic<Intrinsic::fabs>(m_Value(X))
BinaryOp_match< LHS, RHS, Instruction::SDiv > m_SDiv(const LHS &L, const RHS &R)
auto m_SMin(const Opnd0 &Op0, const Opnd1 &Op1)
FNeg_match< OpTy, true > m_FNegOrFSubNegZero(const OpTy &X)
Match fneg X or fsub -0.0, X.
auto m_FAbs(const Opnd0 &Op0)
Signum_match< Val_t > m_Signum(const Val_t &V)
Matches a signum pattern.
CastInst_match< OpTy, SIToFPInst > m_SIToFP(const OpTy &Op)
BinaryOp_match< LHS, RHS, Instruction::LShr > m_LShr(const LHS &L, const RHS &R)
CmpClass_match< LHS, RHS, ICmpInst > m_ICmp(CmpPredicate &Pred, const LHS &L, const RHS &R)
match_combine_or< CastInst_match< OpTy, ZExtInst >, CastInst_match< OpTy, SExtInst > > m_ZExtOrSExt(const OpTy &Op)
BinaryOp_match< LHS, RHS, Instruction::Shl > m_Shl(const LHS &L, const RHS &R)
UAddWithOverflow_match< LHS_t, RHS_t, Sum_t > m_UAddWithOverflow(const LHS_t &L, const RHS_t &R, const Sum_t &S)
Match an icmp instruction checking for unsigned overflow on addition.
BinOpPred_match< LHS, RHS, is_irem_op > m_IRem(const LHS &L, const RHS &R)
Matches integer remainder operations.
auto m_MaxOrMin(const Opnd0 &Op0, const Opnd1 &Op1)
CastInst_match< OpTy, FPTruncInst > m_FPTrunc(const OpTy &Op)
auto m_Undef()
Match an arbitrary undef constant.
auto m_VecReverse(const Opnd0 &Op0)
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.
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.
ElementWiseBitCast_match< OpTy > m_ElementWiseBitCast(const OpTy &Op)
BinaryOp_match< LHS, RHS, Instruction::Mul, true > m_c_Mul(const LHS &L, const RHS &R)
Matches a Mul with LHS and RHS in either order.
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)
cst_pred_ty< icmp_pred_with_threshold > m_SpecificInt_ICMP(ICmpInst::Predicate Predicate, const APInt &Threshold)
Match an integer or vector with every element comparing 'pred' (eg/ne/...) to Threshold.
auto m_ConstantInt()
Match an arbitrary ConstantInt and ignore it.
This is an optimization pass for GlobalISel generic memory operations.
detail::zippy< detail::zip_shortest, T, U, Args... > zip(T &&t, U &&u, Args &&...args)
zip iterator for two or more iteratable types.
@ 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.
LLVM_ABI bool isKnownNeverInfinity(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Return true if the floating-point scalar value is not an infinity or if the floating-point vector val...
LLVM_ABI 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.
@ Known
Known to have no common set bits.
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
@ BinaryOp
One of the operands is a binary op.
LLVM_ABI Value * stripNullTest(Value *V)
Returns the inner value X if the expression has the form f(X) where f(X) == 0 if and only if X == 0,...
iterator_range< early_inc_iterator_impl< detail::IterOfRange< RangeT > > > make_early_inc_range(RangeT &&Range)
Make a range that does early increment to allow mutation of the underlying range without disrupting i...
LLVM_ABI void computeKnownBits(const Value *V, KnownBits &Known, const DataLayout &DL, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true, unsigned Depth=0)
Determine which bits of V are known to be either zero or one and return them in the KnownZero/KnownOn...
LLVM_ABI Value * simplifyFCmpInst(CmpPredicate Predicate, Value *LHS, Value *RHS, FastMathFlags FMF, const SimplifyQuery &Q)
Given operands for an FCmpInst, fold the result or return null.
int ilogb(const APFloat &Arg)
Returns the exponent of the internal representation of the APFloat.
LLVM_ABI bool isKnownNegative(const WithCache< const Value * > &V, const SimplifyQuery &SQ, unsigned Depth=0)
Returns true if the given value is known be negative (i.e.
LLVM_ABI bool isKnownToBeAPowerOfTwo(const Value *V, const DataLayout &DL, bool OrZero=false, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true, unsigned Depth=0)
Return true if the given value is known to have exactly one bit set when defined.
LLVM_ABI bool MaskedValueIsZero(const Value *V, const APInt &Mask, const SimplifyQuery &SQ, unsigned Depth=0)
Return true if 'V & Mask' is known to be zero.
LLVM_ABI Constant * ConstantFoldCompareInstOperands(unsigned Predicate, Constant *LHS, Constant *RHS, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const Function *CtxF=nullptr)
Attempt to constant fold a compare instruction (icmp/fcmp) with the specified operands.
LLVM_ABI Value * simplifyAddInst(Value *LHS, Value *RHS, bool IsNSW, bool IsNUW, const SimplifyQuery &Q)
Given operands for an Add, fold the result or return null.
LLVM_ABI Constant * ConstantFoldConstant(const Constant *C, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr)
ConstantFoldConstant - Fold the constant using the specified DataLayout.
auto dyn_cast_or_null(const Y &Val)
LLVM_ABI bool isSplatValue(const Value *V, int Index=-1, unsigned Depth=0)
Return true if each element of the vector value V is poisoned or equal to every other non-poisoned el...
unsigned Log2_32(uint32_t Value)
Return the floor log base 2 of the specified value, -1 if the value is zero.
int countl_zero(T Val)
Count number of 0's from the most significant bit to the least stopping at the first 1.
LLVM_ABI Value * emitGEPOffset(IRBuilderBase *Builder, const DataLayout &DL, User *GEP, bool NoAssumptions=false)
Given a getelementptr instruction/constantexpr, emit the code necessary to compute the offset from th...
constexpr unsigned MaxAnalysisRecursionDepth
LLVM_ABI Constant * ConstantFoldUnaryOpOperand(unsigned Opcode, Constant *Op, const DataLayout &DL)
Attempt to constant fold a unary operation with the specified operand.
SelectPatternFlavor
Specific patterns of select instructions we can match.
@ SPF_FMAXNUM
Floating point minnum.
@ SPF_FMINNUM
Unsigned maximum.
constexpr bool isPowerOf2_32(uint32_t Value)
Return true if the argument is a power of two > 0.
LLVM_ABI bool isKnownPositive(const WithCache< const Value * > &V, const SimplifyQuery &SQ, unsigned Depth=0)
Returns true if the given value is known be positive (i.e.
LLVM_ABI bool impliesPoison(const Value *ValAssumedPoison, const Value *V)
Return true if V is poison given that ValAssumedPoison is already poison.
LLVM_ABI LinearExpression decomposeLinearExpression(const DataLayout &DL, Value *Ptr)
Decompose a pointer into a linear expression.
LLVM_ABI bool isFinite(const Loop *L)
Return true if this loop can be assumed to run for a finite number of iterations.
FPClassTest
Floating-point class tests, supported by 'is_fpclass' intrinsic.
APFloat scalbn(APFloat X, int Exp, APFloat::roundingMode RM)
Returns: X * 2^Exp for integral exponents.
LLVM_ABI bool NullPointerIsDefined(const Function *F, unsigned AS=0)
Check whether null pointer dereferencing is considered undefined behavior for a given function or an ...
bool none_of(R &&Range, UnaryPredicate P)
Provide wrappers to std::none_of which take ranges instead of having to pass begin/end explicitly.
LLVM_ABI Value * simplifyICmpInst(CmpPredicate Pred, Value *LHS, Value *RHS, const SimplifyQuery &Q)
Given operands for an ICmpInst, fold the result or return null.
LLVM_ABI Constant * ConstantFoldCastOperand(unsigned Opcode, Constant *C, Type *DestTy, const DataLayout &DL)
Attempt to constant fold a cast with the specified operand.
LLVM_ABI Constant * ConstantFoldLoadFromConst(Constant *C, Type *Ty, const APInt &Offset, const DataLayout &DL)
Extract value of C at the given Offset reinterpreted as Ty.
LLVM_ABI const Value * getUnderlyingObject(const Value *V, unsigned MaxLookup=MaxLookupSearchDepth, bool MustPreserveProvenance=false)
This method strips off any GEP address adjustments, pointer casts or llvm.threadlocal....
bool isa(const From &Val)
isa<X> - Return true if the parameter to the template is an instance of one of the template type argu...
LLVM_ABI Constant * ConstantFoldBinaryOpOperands(unsigned Opcode, Constant *LHS, Constant *RHS, const DataLayout &DL)
Attempt to constant fold a binary operation with the specified operands.
LLVM_ABI 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 T divideCeil(U Numerator, V Denominator)
Returns the integer ceil(Numerator / Denominator).
@ First
Helpers to iterate all locations in the MemoryEffectsBase class.
LLVM_ABI Value * simplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS, const SimplifyQuery &Q)
Given operands for a BinaryOperator, fold the result or return null.
@ UMin
Unsigned integer min implemented in terms of select(cmp()).
@ Mul
Product of integers.
@ Xor
Bitwise or logical XOR of integers.
@ SMax
Signed integer max implemented in terms of select(cmp()).
@ SMin
Signed integer min implemented in terms of select(cmp()).
@ Sub
Subtraction of integers.
@ UMax
Unsigned integer max implemented in terms of select(cmp()).
LLVM_ABI bool isKnownNonEqual(const Value *V1, const Value *V2, const SimplifyQuery &SQ, unsigned Depth=0)
Return true if the given values are known to be non-equal when defined.
DWARFExpression::Operation Op
LLVM_ABI bool PointerMayBeCaptured(const Value *V, bool ReturnCaptures, unsigned MaxUsesToExplore=0)
PointerMayBeCaptured - Return true if this pointer value may be captured by the enclosing function (w...
constexpr unsigned BitWidth
LLVM_ABI Constant * getLosslessInvCast(Constant *C, Type *InvCastTo, unsigned CastOp, const DataLayout &DL, PreservedCastFlags *Flags=nullptr)
Try to cast C to InvC losslessly, satisfying CastOp(InvC) equals C, or CastOp(InvC) is a refined valu...
auto count_if(R &&Range, UnaryPredicate P)
Wrapper function around std::count_if to count the number of times an element satisfying a given pred...
LLVM_ABI bool isKnownNeverInfOrNaN(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Return true if the floating-point value can never contain a NaN or infinity.
decltype(auto) cast(const From &Val)
cast<X> - Return the argument parameter cast to the specified type.
LLVM_ABI bool isKnownNeverNaN(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Return true if the floating-point scalar value is not a NaN or if the floating-point vector value has...
LLVM_ABI std::optional< std::pair< CmpPredicate, Constant * > > getFlippedStrictnessPredicateAndConstant(CmpPredicate Pred, Constant *C)
Convert an integer comparison with a constant RHS into an equivalent form with the strictness flipped...
bool all_equal(std::initializer_list< T > Values)
Returns true if all Values in the initializer lists are equal or the list.
@ End
Run the machine verifier once, at the end of the pipeline.
LLVM_ABI bool isKnownNonNegative(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Returns true if the give value is known to be non-negative.
LLVM_ABI SelectPatternResult matchSelectPattern(Value *V, Value *&LHS, Value *&RHS, Instruction::CastOps *CastOp=nullptr)
Pattern match integer [SU]MIN, [SU]MAX and ABS idioms, returning the kind and providing the out param...
constexpr detail::IsaCheckPredicate< Types... > IsaPred
Function object wrapper for the llvm::isa type check.
LLVM_ABI 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.
LLVM_ABI std::optional< DecomposedBitTest > decomposeBitTestICmp(Value *LHS, Value *RHS, CmpInst::Predicate Pred, bool LookThroughTrunc=true, bool AllowNonZeroC=false, bool DecomposeAnd=false)
Decompose an icmp into the form ((X & Mask) pred C) if possible.
LLVM_ABI ConstantRange computeConstantRange(const Value *V, bool ForSigned, const SimplifyQuery &SQ, unsigned Depth=0)
Determine the possible constant range of an integer or vector of integer value.
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Value * materialize(InstCombiner::BuilderTy &Builder) const
static OffsetResult select(Value *Cond, Value *TrueV, Value *FalseV, Instruction *MDFrom)
static OffsetResult value(Value *V)
static OffsetResult invalid()
This callback is used in conjunction with PointerMayBeCaptured.
static CommonPointerBase compute(Value *LHS, Value *RHS)
Represent subnormal handling kind for floating point instruction inputs and outputs.
@ PreserveSign
The sign of a flushed-to-zero number is preserved in the sign of 0.
@ PositiveZero
Denormals are flushed to positive zero.
static constexpr DenormalMode getIEEE()
bool isNonNegative() const
Returns true if this value is known to be non-negative.
bool isZero() const
Returns true if value is all zero.
unsigned countMinTrailingZeros() const
Returns the minimum number of trailing zero bits.
unsigned countMaxTrailingZeros() const
Returns the maximum number of trailing zero bits possible.
APInt getSignedMaxValue() const
Return the maximal signed value possible given these KnownBits.
unsigned countMaxPopulation() const
Returns the maximum number of bits that could be one.
bool isConstant() const
Returns true if we know the value of all bits.
unsigned countMinLeadingZeros() const
Returns the minimum number of leading zero bits.
APInt getMaxValue() const
Return the maximal unsigned value possible given these KnownBits.
APInt getMinValue() const
Return the minimal unsigned value possible given these KnownBits.
bool isNegative() const
Returns true if this value is known to be negative.
unsigned countMinPopulation() const
Returns the number of bits known to be one.
APInt getSignedMinValue() const
Return the minimal signed value possible given these KnownBits.
const APInt & getConstant() const
Returns the value when all bits have a known value.
Linear expression BasePtr + Index * Scale + Offset.
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
A MapVector that performs no allocations if smaller than a certain size.
Capture information for a specific Use.