Lines Matching defs:Pred
81 static bool isSignTest(ICmpInst::Predicate &Pred, const APInt &C) {
82 if (!ICmpInst::isSigned(Pred))
86 return ICmpInst::isRelational(Pred);
89 if (Pred == ICmpInst::ICMP_SLT) {
90 Pred = ICmpInst::ICMP_SLE;
94 if (Pred == ICmpInst::ICMP_SGT) {
95 Pred = ICmpInst::ICMP_SGE;
913 ICmpInst::Predicate Pred) {
922 if (Pred == ICmpInst::ICMP_ULT || Pred == ICmpInst::ICMP_ULE) {
931 if (Pred == ICmpInst::ICMP_UGT || Pred == ICmpInst::ICMP_UGE)
943 if (Pred == ICmpInst::ICMP_SLT || Pred == ICmpInst::ICMP_SLE)
954 assert(Pred == ICmpInst::ICMP_SGT || Pred == ICmpInst::ICMP_SGE);
967 auto getICmp = [&I](CmpInst::Predicate Pred, Value *LHS, Value *RHS) {
969 Pred = CmpInst::getInversePredicate(Pred);
970 return new ICmpInst(Pred, LHS, RHS);
1026 auto getICmp = [&I](CmpInst::Predicate Pred, Value *LHS, Value *RHS) {
1028 Pred = CmpInst::getInversePredicate(Pred);
1029 return new ICmpInst(Pred, LHS, RHS);
1156 ICmpInst::Predicate Pred;
1158 if (!match(&I, m_ICmp(Pred, m_OneUse(m_IRem(m_Value(X), m_Value(Y))),
1166 return ICmpInst::Create(Instruction::ICmp, Pred, Masked, Zero);
1173 ICmpInst::Predicate Pred;
1174 if (!I.isEquality() || !match(&I, m_ICmp(Pred, m_Instruction(Val), m_Zero())))
1196 Pred == ICmpInst::ICMP_EQ ? ICmpInst::ICMP_SGE
1203 CmpInst::Predicate Pred = Cmp.getPredicate();
1208 if (Pred == ICmpInst::ICMP_SGT) {
1212 return new ICmpInst(Pred, B, Cmp.getOperand(1));
1214 return new ICmpInst(Pred, A, Cmp.getOperand(1));
1227 ICmpInst::isEquality(Pred)) {
1231 return new ICmpInst(Pred, X, Cmp.getOperand(1));
1237 ICmpInst::isEquality(Pred)) {
1243 return new ICmpInst(Pred, Y, Cmp.getOperand(1));
1249 return new ICmpInst(Pred, X, Cmp.getOperand(1));
1260 return new ICmpInst(Pred, Y, Cmp.getOperand(1));
1265 return new ICmpInst(Pred, X, Cmp.getOperand(1));
1279 /// Fold icmp Pred X, C.
1296 CmpInst::Predicate Pred = Cmp.getPredicate();
1300 if (Pred == ICmpInst::ICMP_UGT && match(Op1, m_ConstantInt(CI)) &&
1315 ConstantFoldCompareInstOperands(Pred, cast<Constant>(V), C, DL);
1322 for (auto [V, Pred] : zip(Ops, Phi->blocks()))
1323 NewPhi->addIncoming(V, Pred);
1342 CmpInst::Predicate Pred = Cmp.getPredicate();
1343 ConstantRange CR = ConstantRange::makeExactICmpRegion(Pred, *C);
1353 // Cmp = icmp Pred X, C
1369 bool IsSignBit = isSignBitCheck(Pred, *C, UnusedBit);
1413 ICmpInst::Predicate Pred = Cmp.getPredicate();
1423 return new ICmpInst(Pred, X, ConstantInt::get(SrcTy, C.sext(SrcBits)));
1425 return new ICmpInst(Pred, X, ConstantInt::get(SrcTy, C.zext(SrcBits)));
1431 if (Pred == ICmpInst::ICMP_SLT && match(X, m_Signum(m_Value(V))))
1443 auto NewPred = (Pred == Cmp.ICMP_EQ) ? Cmp.ICMP_UGE : Cmp.ICMP_ULT;
1449 return new ICmpInst(Pred, Y, ConstantInt::get(SrcTy, C.logBase2()));
1460 return new ICmpInst(Pred, And, WideC);
1472 return new ICmpInst(Pred, X, ConstantInt::get(SrcTy, NewRHS));
1482 if (isSignBitCheck(Pred, C, TrueIfSigned) &&
1500 ICmpInst::Predicate Pred;
1503 if (match(&Cmp, m_ICmp(Pred, m_Trunc(m_Value(X)), m_Trunc(m_Value(Y))))) {
1523 Pred = Cmp.getSwappedPredicate(Pred);
1529 match(&Cmp, m_c_ICmp(Pred, m_NUWTrunc(m_Value(X)),
1534 else if (match(&Cmp, m_c_ICmp(Pred, m_NSWTrunc(m_Value(X)),
1552 return new ICmpInst(Pred, X, NewY);
1570 ICmpInst::Predicate Pred = Cmp.getPredicate();
1591 Pred = Cmp.getFlippedSignednessPredicate();
1592 return new ICmpInst(Pred, X, ConstantInt::get(X->getType(), C ^ *XorC));
1597 Pred = Cmp.getFlippedSignednessPredicate();
1598 Pred = Cmp.getSwappedPredicate(Pred);
1599 return new ICmpInst(Pred, X, ConstantInt::get(X->getType(), C ^ *XorC));
1604 if (Pred == ICmpInst::ICMP_UGT) {
1612 if (Pred == ICmpInst::ICMP_ULT) {
1631 CmpInst::Predicate Pred = Cmp.getPredicate();
1633 if (Pred == ICmpInst::ICMP_ULT)
1635 else if (Pred == ICmpInst::ICMP_UGT && !C.isMaxValue())
1652 Pred == ICmpInst::ICMP_ULT ? PowerOf2 << 1 : ((PowerOf2 << 1) - 1);
1653 return new ICmpInst(Pred, Add, ConstantInt::get(XType, Bound));
1879 const ICmpInst::Predicate Pred = Cmp.getPredicate();
1881 if (isSignBitCheck(Pred, C, TrueIfNeg)) {
1922 Pred == CmpInst::ICMP_EQ ? CmpInst::ICMP_UGT : CmpInst::ICMP_ULE;
1935 if (C.isZero() && (Pred == CmpInst::ICMP_EQ || And->hasOneUse())) {
1944 if (Pred == CmpInst::ICMP_NE)
1957 if (C.isZero() ^ (Pred == CmpInst::ICMP_NE)) {
1972 return new ICmpInst(Pred, LShr, Constant::getNullValue(LShr->getType()));
2024 ICmpInst::Predicate Pred = Cmp.getPredicate();
2025 auto BOpc = Pred == CmpInst::ICMP_EQ ? Instruction::And : Instruction::Or;
2026 Value *LhsCmp = Builder.CreateICmp(Pred, CmpValues.rbegin()->first,
2030 Value *RhsCmp = Builder.CreateICmp(Pred, It->first, It->second);
2041 ICmpInst::Predicate Pred = Cmp.getPredicate();
2045 if (Pred == ICmpInst::ICMP_SLT && match(Or, m_Signum(m_Value(V))))
2058 return new ICmpInst(Pred, OrOp0, NewC);
2067 Pred = (Pred == CmpInst::ICMP_EQ) ? CmpInst::ICMP_ULE : CmpInst::ICMP_UGT;
2068 return new ICmpInst(Pred, OrOp0, OrOp1);
2078 return new ICmpInst(Pred, And, NewC);
2086 if (isSignBitCheck(Pred, C, TrueIfSigned) &&
2096 switch (Pred) {
2102 return new ICmpInst(Pred, X, ConstantInt::getNullValue(X->getType()));
2109 return new ICmpInst(ICmpInst::getFlippedStrictnessPredicate(Pred), X,
2125 Builder.CreateICmp(Pred, P, ConstantInt::getNullValue(P->getType()));
2127 Builder.CreateICmp(Pred, Q, ConstantInt::getNullValue(Q->getType()));
2128 auto BOpc = Pred == CmpInst::ICMP_EQ ? Instruction::And : Instruction::Or;
2142 ICmpInst::Predicate Pred = Cmp.getPredicate();
2151 return new ICmpInst(Pred, X, ConstantInt::getNullValue(MulTy));
2161 if (isSignTest(Pred, C) && Mul->hasNoSignedWrap()) {
2163 Pred = ICmpInst::getSwappedPredicate(Pred);
2164 return new ICmpInst(Pred, X, ConstantInt::getNullValue(MulTy));
2176 return new ICmpInst(Pred, X, NewC);
2188 return new ICmpInst(Pred, X, NewC);
2196 // TODO: Assert that Pred is not equal to SGE, SLE, UGE, ULE?
2198 if (Mul->hasNoSignedWrap() && ICmpInst::isSigned(Pred)) {
2203 Pred = ICmpInst::getSwappedPredicate(Pred);
2205 if (Pred == ICmpInst::ICMP_SLT || Pred == ICmpInst::ICMP_SGE) {
2209 assert((Pred == ICmpInst::ICMP_SLE || Pred == ICmpInst::ICMP_SGT) &&
2214 } else if (Mul->hasNoUnsignedWrap() && ICmpInst::isUnsigned(Pred)) {
2215 if (Pred == ICmpInst::ICMP_ULT || Pred == ICmpInst::ICMP_UGE) {
2219 assert((Pred == ICmpInst::ICMP_ULE || Pred == ICmpInst::ICMP_UGT) &&
2226 return NewC ? new ICmpInst(Pred, X, NewC) : nullptr;
2239 ICmpInst::Predicate Pred = Cmp.getPredicate();
2247 if (Pred == ICmpInst::ICMP_ULT)
2248 Pred = ICmpInst::ICMP_ULE;
2249 else if (Pred == ICmpInst::ICMP_UGE)
2250 Pred = ICmpInst::ICMP_UGT;
2254 return new ICmpInst(Pred, Y, ConstantInt::get(ShiftType, CLog2));
2259 if (Pred == ICmpInst::ICMP_SGT && C.sle(0))
2266 if (Pred == ICmpInst::ICMP_SLT && (C-1).sle(0))
2281 ICmpInst::Predicate Pred = Cmp.getPredicate();
2288 return new ICmpInst(Pred, Shl->getOperand(0), Cmp.getOperand(1));
2292 if (ICmpInst::isEquality(Pred) && C.isZero() &&
2294 return new ICmpInst(Pred, Shl->getOperand(0), Cmp.getOperand(1));
2303 (Pred == ICmpInst::ICMP_SGT || Pred == ICmpInst::ICMP_SLT))
2304 if (C.isZero() || (Pred == ICmpInst::ICMP_SGT ? C.isAllOnes() : C.isOne()))
2305 return new ICmpInst(Pred, Shl->getOperand(0), Cmp.getOperand(1));
2324 if (Pred == ICmpInst::ICMP_SGT) {
2325 // icmp Pred (shl nsw X, ShiftAmt), C --> icmp Pred X, (C >>s ShiftAmt)
2327 return new ICmpInst(Pred, X, ConstantInt::get(ShType, ShiftedC));
2329 if ((Pred == ICmpInst::ICMP_EQ || Pred == ICmpInst::ICMP_NE) &&
2332 return new ICmpInst(Pred, X, ConstantInt::get(ShType, ShiftedC));
2334 if (Pred == ICmpInst::ICMP_SLT) {
2341 return new ICmpInst(Pred, X, ConstantInt::get(ShType, ShiftedC));
2349 if (Pred == ICmpInst::ICMP_UGT) {
2350 // icmp Pred (shl nuw X, ShiftAmt), C --> icmp Pred X, (C >>u ShiftAmt)
2352 return new ICmpInst(Pred, X, ConstantInt::get(ShType, ShiftedC));
2354 if ((Pred == ICmpInst::ICMP_EQ || Pred == ICmpInst::ICMP_NE) &&
2357 return new ICmpInst(Pred, X, ConstantInt::get(ShType, ShiftedC));
2359 if (Pred == ICmpInst::ICMP_ULT) {
2366 return new ICmpInst(Pred, X, ConstantInt::get(ShType, ShiftedC));
2377 return new ICmpInst(Pred, And, LShrC);
2382 if (Shl->hasOneUse() && isSignBitCheck(Pred, C, TrueIfSigned)) {
2396 (Pred == ICmpInst::ICMP_ULE || Pred == ICmpInst::ICMP_UGT)) {
2398 return new ICmpInst(Pred == ICmpInst::ICMP_ULE ? ICmpInst::ICMP_EQ
2404 (Pred == ICmpInst::ICMP_ULT || Pred == ICmpInst::ICMP_UGE)) {
2407 return new ICmpInst(Pred == ICmpInst::ICMP_ULT ? ICmpInst::ICMP_EQ
2422 ICmpInst::Predicate CmpPred = Pred;
2434 Pred, ConstantInt::get(ShType->getContext(), C))) {
2461 CmpInst::Predicate Pred = Cmp.getPredicate();
2463 return new ICmpInst(Pred, X, Cmp.getOperand(1));
2475 isSignBitCheck(Pred, C, TrueIfSigned))
2484 (Pred == CmpInst::ICMP_UGT || Pred == CmpInst::ICMP_ULT)) {
2485 bool IsUGT = Pred == CmpInst::ICMP_UGT;
2515 if (IsExact && (Pred == CmpInst::ICMP_SLT || Pred == CmpInst::ICMP_ULT) &&
2523 return new ICmpInst(Pred, X, ConstantInt::get(ShrTy, ShiftedC));
2525 if (IsExact || Pred == CmpInst::ICMP_SLT || Pred == CmpInst::ICMP_ULT) {
2531 return new ICmpInst(Pred, X, ConstantInt::get(ShrTy, ShiftedC));
2533 if (Pred == CmpInst::ICMP_SGT) {
2538 return new ICmpInst(Pred, X, ConstantInt::get(ShrTy, ShiftedC));
2540 if (Pred == CmpInst::ICMP_UGT) {
2547 return new ICmpInst(Pred, X, ConstantInt::get(ShrTy, ShiftedC));
2555 if (Pred == CmpInst::ICMP_UGT) {
2559 if (Pred == CmpInst::ICMP_ULT) {
2565 if (Pred == CmpInst::ICMP_ULT || (Pred == CmpInst::ICMP_UGT && IsExact)) {
2570 return new ICmpInst(Pred, X, ConstantInt::get(ShrTy, ShiftedC));
2572 if (Pred == CmpInst::ICMP_UGT) {
2576 return new ICmpInst(Pred, X, ConstantInt::get(ShrTy, ShiftedC));
2595 return new ICmpInst(Pred, X, ConstantInt::get(ShrTy, C << ShAmtVal));
2599 if (Pred == CmpInst::ICMP_EQ)
2613 return new ICmpInst(Pred, And, ConstantInt::get(ShrTy, C << ShAmtVal));
2625 const ICmpInst::Predicate Pred = Cmp.getPredicate();
2626 if (Pred != ICmpInst::ICMP_SGT && Pred != ICmpInst::ICMP_SLT &&
2627 Pred != ICmpInst::ICMP_EQ && Pred != ICmpInst::ICMP_NE)
2642 if (((Pred == ICmpInst::ICMP_SGT || Pred == ICmpInst::ICMP_SLT) &&
2644 ((Pred == ICmpInst::ICMP_EQ || Pred == ICmpInst::ICMP_NE) &&
2654 if (Pred == ICmpInst::ICMP_EQ || Pred == ICmpInst::ICMP_NE)
2655 return new ICmpInst(Pred, And, ConstantInt::get(Ty, C));
2660 if (Pred == ICmpInst::ICMP_SGT)
2673 ICmpInst::Predicate Pred = Cmp.getPredicate();
2685 if (Pred == ICmpInst::ICMP_UGT) {
2693 if (Pred == ICmpInst::ICMP_ULT) {
2706 ICmpInst::Predicate Pred = Cmp.getPredicate();
2722 Value *XBig = Builder.CreateICmp(Pred, X, ConstantInt::get(Ty, C));
2723 Value *YOne = Builder.CreateICmp(Pred, Y, ConstantInt::get(Ty, 1));
2724 auto Logic = Pred == ICmpInst::ICMP_EQ ? Instruction::And : Instruction::Or;
2835 Pred = ICmpInst::getSwappedPredicate(Pred);
2838 switch (Pred) {
2869 return new ICmpInst(Pred, X, ConstantInt::get(Ty, LoBound));
2876 if (Pred == ICmpInst::ICMP_UGT)
2889 ICmpInst::Predicate Pred = Cmp.getPredicate();
2896 return new ICmpInst(Pred, Y,
2919 return new ICmpInst(Pred, X, Y);
2931 if (Pred == ICmpInst::ICMP_SGT && C.isAllOnes())
2935 if (Pred == ICmpInst::ICMP_SGT && C.isZero())
2939 if (Pred == ICmpInst::ICMP_SLT && C.isZero())
2943 if (Pred == ICmpInst::ICMP_SLT && C.isOne())
2952 if (Pred == ICmpInst::ICMP_ULT && C.isPowerOf2() &&
2958 if (Pred == ICmpInst::ICMP_UGT && (C + 1).isPowerOf2() && (*C2 & C) == C)
3028 const CmpInst::Predicate Pred = Cmp.getPredicate();
3043 return ICmpInst::compare(APInt(BW, Res, true), C, Pred);
3065 (Pred == ICmpInst::ICMP_SGT || Pred == ICmpInst::ICMP_SLT)) ||
3067 (Pred == ICmpInst::ICMP_UGT || Pred == ICmpInst::ICMP_ULT))) {
3075 // icmp Pred (add nsw X, C2), C --> icmp Pred X, (C - C2)
3076 return new ICmpInst(Pred, X, ConstantInt::get(Ty, NewC));
3079 auto CR = ConstantRange::makeExactICmpRegion(Pred, C).subtract(*C2);
3101 if (Pred == CmpInst::ICMP_UGT && C == *C2 + SMax)
3105 if (Pred == CmpInst::ICMP_ULT && C == *C2 + SMin)
3109 if (Pred == CmpInst::ICMP_SGT && C == *C2 - 1)
3113 if (Pred == CmpInst::ICMP_SLT && C == *C2)
3117 if (Pred == CmpInst::ICMP_ULT && C2->isAllOnes()) {
3129 if (Pred == ICmpInst::ICMP_ULT && C.isPowerOf2() && (*C2 & (C - 1)) == 0)
3136 if (Pred == ICmpInst::ICMP_ULT && C2->isPowerOf2() && C == -*C2)
3143 if (Pred == ICmpInst::ICMP_UGT && (C + 1).isPowerOf2() && (*C2 & C) == 0)
3150 if (Pred == ICmpInst::ICMP_UGT)
3265 ICmpInst::Predicate Pred = Cmp.getPredicate();
3282 if ((Pred == ICmpInst::ICMP_EQ || Pred == ICmpInst::ICMP_SLT ||
3283 Pred == ICmpInst::ICMP_NE || Pred == ICmpInst::ICMP_SGT) &&
3285 return new ICmpInst(Pred, X, ConstantInt::getNullValue(X->getType()));
3288 if (Pred == ICmpInst::ICMP_SLT && match(Op1, m_One()))
3289 return new ICmpInst(Pred, X, ConstantInt::get(X->getType(), 1));
3292 if (Pred == ICmpInst::ICMP_SGT && match(Op1, m_AllOnes()))
3293 return new ICmpInst(Pred, X,
3302 return new ICmpInst(Pred, X, ConstantInt::getNullValue(X->getType()));
3311 if (isSignBitCheck(Pred, *C, TrueIfSigned) &&
3340 if (Pred == ICmpInst::ICMP_NE)
3365 return new ICmpInst(Pred, Cast, ConstantInt::getNullValue(DstType));
3378 return new ICmpInst(Pred, NewCast, ConstantInt::getNullValue(NewType));
3405 return new ICmpInst(Pred, Extract, NewC);
3412 /// Try to fold integer comparisons with a constant operand: icmp Pred X, C
3468 ICmpInst::Predicate Pred = Cmp.getPredicate();
3469 bool isICMP_NE = Pred == ICmpInst::ICMP_NE;
3480 return new ICmpInst(Pred, NewRem,
3491 return new ICmpInst(Pred, BOp0, ConstantExpr::getSub(RHS, C2));
3496 return new ICmpInst(Pred, BOp0, NegVal);
3498 return new ICmpInst(Pred, NegVal, BOp1);
3503 return new ICmpInst(Pred, Or, Constant::getNullValue(BO->getType()));
3507 return new ICmpInst(Pred, BOp0, Neg);
3516 return new ICmpInst(Pred, BOp0, ConstantExpr::getXor(RHS, BOC));
3519 return new ICmpInst(Pred, BOp0, BOp1);
3530 return new ICmpInst(Pred, And, NotBOC);
3543 return new ICmpInst(Pred, BOp0, Constant::getNullValue(BO->getType()));
3545 return new ICmpInst(Pred, BOp0, BOp1);
3553 return new ICmpInst(Pred, YC, BOp0);
3586 const ICmpInst::Predicate Pred = I.getPredicate();
3587 if (((I.isEquality() || Pred == ICmpInst::ICMP_UGT) && CRhs == 1) ||
3588 (Pred == ICmpInst::ICMP_ULT && CRhs == 2)) {
3597 (Pred == ICmpInst::ICMP_EQ || Pred == ICmpInst::ICMP_ULT)
3612 const ICmpInst::Predicate Pred = Cmp.getPredicate();
3619 return new ICmpInst(Pred, II->getArgOperand(0), ConstantInt::get(Ty, C));
3624 return new ICmpInst(Pred, II->getArgOperand(0),
3629 return new ICmpInst(Pred, II->getArgOperand(0),
3636 return new ICmpInst(Pred, II->getArgOperand(0),
3650 return new ICmpInst(Pred, Builder.CreateAnd(II->getArgOperand(0), Mask1),
3661 return new ICmpInst(Pred, II->getArgOperand(0),
3675 return new ICmpInst(Pred, II->getArgOperand(0),
3688 return new ICmpInst(Pred, Or, Constant::getNullValue(Ty));
3696 return new ICmpInst(Pred, II->getArgOperand(0), II->getArgOperand(1));
3702 Pred == ICmpInst::ICMP_EQ ? ICmpInst::ICMP_ULE : ICmpInst::ICMP_UGT;
3720 ICmpInst::Predicate Pred = Cmp.getPredicate();
3733 return new ICmpInst(Pred, IIOp0->getOperand(0), IIOp1->getOperand(0));
3743 return new ICmpInst(Pred, IIOp0->getOperand(0), IIOp1->getOperand(0));
3758 return new ICmpInst(Pred, IIOp1->getOperand(0), CombinedRotate);
3768 /// Try to fold integer comparisons with a constant operand: icmp Pred X, C
3774 const ICmpInst::Predicate Pred = Cmp.getPredicate();
3784 return new ICmpInst(Pred, II->getArgOperand(0), Cmp.getOperand(1));
3793 /// Fold an icmp with BinaryOp and constant operand: icmp Pred BO, C.
3852 foldICmpUSubSatOrUAddSatWithConstant(ICmpInst::Predicate Pred,
3896 bool SatValCheck = ICmpInst::compare(SatVal, C, Pred);
3906 ConstantRange C2 = ConstantRange::makeExactICmpRegion(Pred, C);
3937 foldICmpOfCmpIntrinsicWithConstant(ICmpInst::Predicate Pred, IntrinsicInst *I,
3941 switch (Pred) {
3945 NewPredicate = Pred;
3948 Pred == ICmpInst::ICMP_EQ ? ICmpInst::ICMP_UGT : ICmpInst::ICMP_ULE;
3951 Pred == ICmpInst::ICMP_EQ ? ICmpInst::ICMP_ULT : ICmpInst::ICMP_UGE;
3982 /// Fold an icmp with LLVM intrinsic and constant operand: icmp Pred II, C.
3986 ICmpInst::Predicate Pred = Cmp.getPredicate();
3995 Pred, cast<SaturatingInst>(II), C, Builder))
4005 if (auto *Folded = foldICmpOfCmpIntrinsicWithConstant(Pred, II, C, Builder))
4019 if (C == BitWidth - 1 && Pred == ICmpInst::ICMP_UGT)
4023 if (C == BitWidth && Pred == ICmpInst::ICMP_ULT)
4030 if (Pred == ICmpInst::ICMP_UGT && C.ult(BitWidth)) {
4038 if (Pred == ICmpInst::ICMP_ULT && C.uge(1) && C.ule(BitWidth)) {
4052 if (Pred == ICmpInst::ICMP_UGT && C.ult(BitWidth)) {
4060 if (Pred == ICmpInst::ICMP_ULT && C.uge(1) && C.ule(BitWidth)) {
4070 if (ICmpInst::isSigned(Pred)) {
4072 return new ICmpInst(Pred, II->getArgOperand(0), II->getArgOperand(1));
4074 if (Pred == ICmpInst::ICMP_SLT && C.isOne())
4078 if (Pred == ICmpInst::ICMP_SGT && C.isAllOnes())
4126 Instruction *InstCombinerImpl::foldSelectICmp(ICmpInst::Predicate Pred,
4132 if (Value *Res = simplifyICmpInst(Pred, Op, RHS, SQ))
4135 SI->getCondition(), Pred, Op, RHS, DL, SelectCondIsTrue))
4172 Op1 = Builder.CreateICmp(Pred, SI->getOperand(1), RHS, I.getName());
4174 Op2 = Builder.CreateICmp(Pred, SI->getOperand(2), RHS, I.getName());
4289 static Value *foldICmpWithLowBitMaskedVal(ICmpInst::Predicate Pred, Value *Op0,
4294 switch (Pred) {
4354 return !ICmpInst::isSigned(Pred) ||
4360 return !ICmpInst::isSigned(Pred) || isKnownNonZero(X, Q);
4364 if (ICmpInst::isEquality(Pred) && match(Op1, m_AllOnes()) &&
4383 if (ICmpInst::isEquality(Pred) && match(Op1, m_Zero()) &&
4667 ICmpInst::Predicate Pred;
4674 match(&I, m_c_ICmp(Pred,
4681 switch (Pred) {
4694 m_c_ICmp(Pred, m_Value(Y),
4701 NeedNegation = Pred == ICmpInst::Predicate::ICMP_EQ;
4739 CmpInst::Predicate Pred;
4741 if (match(&I, m_c_ICmp(Pred, m_NSWNeg(m_Value(X)), m_Deferred(X)))) {
4743 if (ICmpInst::isSigned(Pred))
4744 Pred = ICmpInst::getSwappedPredicate(Pred);
4745 else if (ICmpInst::isUnsigned(Pred))
4746 Pred = ICmpInst::getSignedPredicate(Pred);
4749 return ICmpInst::Create(Instruction::ICmp, Pred, X,
4755 if (match(&I, m_c_ICmp(Pred, m_OneUse(m_Neg(m_Value(X))), m_Deferred(X))) &&
4756 ICmpInst::isEquality(Pred)) {
4763 return CmpInst::Create(Instruction::ICmp, Pred, And, Zero);
4773 CmpInst::Predicate Pred = I.getPredicate();
4776 Pred = ICmpInst::getSwappedPredicate(Pred);
4783 if (Pred == ICmpInst::ICMP_ULT)
4787 if (Pred == ICmpInst::ICMP_UGE)
4790 if (ICmpInst::isEquality(Pred) && Op0->hasOneUse()) {
4797 return new ICmpInst(Pred, IC.Builder.CreateOr(A, NotOp1),
4801 return new ICmpInst(Pred, IC.Builder.CreateAnd(Op1, NotA),
4805 if (!ICmpInst::isSigned(Pred))
4811 return new ICmpInst(ICmpInst::getUnsignedPredicate(Pred), Op0, Op1);
4813 if (Pred != ICmpInst::ICMP_SLE && Pred != ICmpInst::ICMP_SGT)
4819 return new ICmpInst(ICmpInst::getSwappedPredicate(Pred), Op1,
4825 return new ICmpInst(ICmpInst::getFlippedStrictnessPredicate(Pred), A,
4836 CmpInst::Predicate Pred = I.getPredicate();
4839 Pred = ICmpInst::getSwappedPredicate(Pred);
4845 if (Pred == ICmpInst::ICMP_ULE)
4849 if (Pred == ICmpInst::ICMP_UGT)
4852 if (ICmpInst::isEquality(Pred) && Op0->hasOneUse()) {
4856 return new ICmpInst(Pred, IC.Builder.CreateAnd(A, NotOp1),
4860 return new ICmpInst(Pred, IC.Builder.CreateOr(Op1, NotA),
4870 CmpInst::Predicate Pred = I.getPredicate();
4873 Pred = ICmpInst::getSwappedPredicate(Pred);
4882 CmpInst::Predicate PredOut = CmpInst::getStrictPredicate(Pred);
4883 if (PredOut != Pred && isKnownNonZero(A, Q))
4907 const CmpInst::Predicate Pred = I.getPredicate();
4913 (Pred == ICmpInst::ICMP_ULT || Pred == ICmpInst::ICMP_UGE))
4914 return new ICmpInst(Pred, Builder.CreateNot(Op1), X);
4917 (Pred == ICmpInst::ICMP_UGT || Pred == ICmpInst::ICMP_ULE))
4918 return new ICmpInst(Pred, X, Builder.CreateNot(Op0));
4925 (Pred == ICmpInst::ICMP_ULT || Pred == ICmpInst::ICMP_UGE)) {
4927 return new ICmpInst(Pred, Builder.CreateSub(C2, X), Op1);
4932 (Pred == ICmpInst::ICMP_UGT || Pred == ICmpInst::ICMP_ULE)) {
4934 return new ICmpInst(Pred, Op0, Builder.CreateSub(C2, X));
4946 if ((Pred == ICmpInst::ICMP_ULT || Pred == ICmpInst::ICMP_UGE) &&
4950 Pred == ICmpInst::ICMP_ULT ? ICmpInst::ICMP_NE : ICmpInst::ICMP_EQ;
4955 if ((Pred == ICmpInst::ICMP_UGT || Pred == ICmpInst::ICMP_ULE) &&
4959 Pred == ICmpInst::ICMP_UGT ? ICmpInst::ICMP_NE : ICmpInst::ICMP_EQ;
4970 auto hasNoWrapProblem = [](const BinaryOperator &BO, CmpInst::Predicate Pred,
4975 return ICmpInst::isEquality(Pred) ||
4976 (CmpInst::isUnsigned(Pred) && HasNUW) ||
4977 (CmpInst::isSigned(Pred) && HasNSW);
4990 NoOp0WrapProblem = hasNoWrapProblem(*BO0, Pred, Op0HasNSW, Op0HasNUW);
4994 NoOp1WrapProblem = hasNoWrapProblem(*BO1, Pred, Op1HasNSW, Op1HasNUW);
5000 return new ICmpInst(Pred, A == Op1 ? B : A,
5006 return new ICmpInst(Pred, Constant::getNullValue(Op0->getType()),
5032 return new ICmpInst(Pred, Y, Z);
5036 if (A && NoOp0WrapProblem && Pred == CmpInst::ICMP_SLT &&
5041 if (A && NoOp0WrapProblem && Pred == CmpInst::ICMP_SGE &&
5046 if (A && NoOp0WrapProblem && Pred == CmpInst::ICMP_SLE && match(B, m_One()))
5050 if (A && NoOp0WrapProblem && Pred == CmpInst::ICMP_SGT && match(B, m_One()))
5054 if (C && NoOp1WrapProblem && Pred == CmpInst::ICMP_SGT &&
5059 if (C && NoOp1WrapProblem && Pred == CmpInst::ICMP_SLE &&
5064 if (C && NoOp1WrapProblem && Pred == CmpInst::ICMP_SGE && match(D, m_One()))
5068 if (C && NoOp1WrapProblem && Pred == CmpInst::ICMP_SLT && match(D, m_One()))
5081 if (A && NoOp0WrapProblem && Pred == CmpInst::ICMP_ULE && match(B, m_One()))
5085 if (A && NoOp0WrapProblem && Pred == CmpInst::ICMP_UGT && match(B, m_One()))
5089 if (C && NoOp1WrapProblem && Pred == CmpInst::ICMP_UGE && match(D, m_One()))
5093 if (C && NoOp1WrapProblem && Pred == CmpInst::ICMP_ULT && match(D, m_One()))
5118 return new ICmpInst(Pred, NewAdd, C);
5124 return new ICmpInst(Pred, A, NewAdd);
5129 ICmpInst::isEquality(Pred)) {
5132 return new ICmpInst(Pred, A, NewAdd);
5153 return new ICmpInst(Pred, Constant::getNullValue(Op1->getType()), B);
5156 return new ICmpInst(Pred, D, Constant::getNullValue(Op0->getType()));
5160 if (A == Op1 && (Pred == ICmpInst::ICMP_UGT || Pred == ICmpInst::ICMP_ULE))
5161 return new ICmpInst(Pred, B, A);
5163 if (C == Op0 && (Pred == ICmpInst::ICMP_ULT || Pred == ICmpInst::ICMP_UGE))
5164 return new ICmpInst(Pred, C, D);
5166 if (A == Op1 && (Pred == ICmpInst::ICMP_UGE || Pred == ICmpInst::ICMP_ULT) &&
5168 return new ICmpInst(CmpInst::getFlippedStrictnessPredicate(Pred), B, A);
5170 if (C == Op0 && (Pred == ICmpInst::ICMP_ULE || Pred == ICmpInst::ICMP_UGT) &&
5172 return new ICmpInst(CmpInst::getFlippedStrictnessPredicate(Pred), C, D);
5176 return new ICmpInst(Pred, A, C);
5180 return new ICmpInst(Pred, D, B);
5183 if (NoOp0WrapProblem && ICmpInst::isSigned(Pred)) {
5201 if (Pred == ICmpInst::getUnsignedPredicate(Pred) &&
5207 if (ICmpInst::isEquality(Pred)) {
5212 return new ICmpInst(Pred, X, Y);
5217 return new ICmpInst(Pred, X, Y);
5224 return new ICmpInst(Pred, X, Y);
5239 switch (SRem == BO0 ? ICmpInst::getSwappedPredicate(Pred) : Pred) {
5267 return new ICmpInst(Pred, BO0->getOperand(0), BO1->getOperand(0));
5301 return new ICmpInst(Pred, And1, And2);
5310 return new ICmpInst(Pred, BO0->getOperand(0), BO1->getOperand(0));
5316 return new ICmpInst(Pred, BO0->getOperand(0), BO1->getOperand(0));
5321 return new ICmpInst(Pred, BO0->getOperand(0), BO1->getOperand(0));
5330 return new ICmpInst(Pred, BO0->getOperand(0), BO1->getOperand(0));
5340 if (match(BO0, BitwiseAnd) && Pred == ICmpInst::ICMP_ULT) {
5349 if (!ICmpInst::isSigned(Pred)) {
5351 return new ICmpInst(ICmpInst::getSignedPredicate(Pred), Op1,
5354 return new ICmpInst(ICmpInst::getSignedPredicate(Pred),
5373 /// Fold icmp Pred min|max(X, Y), Z.
5377 ICmpInst::Predicate Pred) {
5380 if (ICmpInst::isSigned(Pred) && !MinMax->isSigned())
5382 if (ICmpInst::isUnsigned(Pred) && MinMax->isSigned()) {
5388 Pred = ICmpInst::getFlippedSignednessPredicate(Pred);
5402 auto CmpXZ = IsCondKnownTrue(simplifyICmpInst(Pred, X, Z, Q));
5403 auto CmpYZ = IsCondKnownTrue(simplifyICmpInst(Pred, Y, Z, Q));
5414 return ICmpInst::Create(Instruction::ICmp, Pred, Y, Z);
5417 switch (Pred) {
5426 if ((Pred == ICmpInst::ICMP_EQ) == *CmpXZ) {
5429 if (Pred == ICmpInst::ICMP_NE)
5440 if (!CmpXZ.has_value() || (Pred == ICmpInst::ICMP_EQ) == *CmpXZ)
5453 I, ConstantInt::getBool(I.getType(), Pred == ICmpInst::ICMP_NE));
5472 bool IsSame = MinMax->getPredicate() == ICmpInst::getStrictPredicate(Pred);
5519 const CmpInst::Predicate Pred = I.getPredicate();
5538 CheckIs = Pred == ICmpInst::ICMP_EQ;
5539 } else if (ICmpInst::isUnsigned(Pred)) {
5543 if ((Pred == ICmpInst::ICMP_UGE || Pred == ICmpInst::ICMP_ULT) &&
5547 CheckIs = Pred == ICmpInst::ICMP_UGE;
5548 } else if ((Pred == ICmpInst::ICMP_UGT || Pred == ICmpInst::ICMP_ULE) &&
5552 CheckIs = Pred == ICmpInst::ICMP_ULE;
5573 const CmpInst::Predicate Pred = I.getPredicate();
5578 return new ICmpInst(Pred, OtherVal, Constant::getNullValue(A->getType()));
5588 return new ICmpInst(Pred, A, Xor);
5593 return new ICmpInst(Pred, B, D);
5595 return new ICmpInst(Pred, B, C);
5597 return new ICmpInst(Pred, A, D);
5599 return new ICmpInst(Pred, A, C);
5606 return new ICmpInst(Pred, OtherVal, Constant::getNullValue(A->getType()));
5650 return new ICmpInst(Pred, Op1, Constant::getNullValue(Op1->getType()));
5664 return new ICmpInst(Pred, And, Constant::getNullValue(And->getType()));
5675 return new ICmpInst(Pred, A, Builder.CreateTrunc(B, A->getType()));
5691 Pred == ICmpInst::ICMP_NE ? ICmpInst::ICMP_UGE : ICmpInst::ICMP_ULT;
5709 return new ICmpInst(Pred, And, Constant::getNullValue(Cst1->getType()));
5733 return new ICmpInst(Pred, Mask, Builder.getInt(CmpV));
5751 return new ICmpInst(Pred == ICmpInst::ICMP_EQ ? ICmpInst::ICMP_ULT
5762 return new ICmpInst(CmpInst::getInversePredicate(Pred), Op0,
5767 return new ICmpInst(CmpInst::getInversePredicate(Pred), Op1,
5775 CmpInst::Predicate PredUnused = Pred;
5780 Pred, A,
5789 return new ICmpInst(Pred, Builder.CreateXor(A, B), Cst);
5812 return new ICmpInst(Pred, Builder.CreateAnd(B, A),
5821 ICmpInst::Predicate Pred = ICmp.getPredicate();
5835 if (decomposeBitTestICmp(Op0, Op1, Pred, X, Mask, true /* WithTrunc */)) {
5838 return new ICmpInst(Pred, And, Zero);
5842 if (Pred == ICmpInst::ICMP_ULT && C->isNegatedPowerOf2()) {
5850 if (Pred == ICmpInst::ICMP_UGT && (~*C).isPowerOf2()) {
5890 // icmp Pred (ext X), (ext Y)
6437 ICmpInst::Predicate Pred = I.getPredicate();
6485 return new ICmpInst(Pred, ConstantExpr::getIntegerValue(Ty, Op0Min), Op1);
6487 return new ICmpInst(Pred, Op0, ConstantExpr::getIntegerValue(Ty, Op1Min));
6504 switch (Pred) {
6568 switch (Pred) {
6575 I, ConstantInt::getBool(I.getType(), Pred == CmpInst::ICMP_NE));
6603 Pred == CmpInst::ICMP_EQ ? CmpInst::ICMP_UGE : CmpInst::ICMP_ULT;
6612 return new ICmpInst(CmpInst::getInversePredicate(Pred), Op0,
6696 ICmpInst::Predicate Pred;
6700 if (match(&I, m_c_ICmp(Pred, m_Value(X), m_OneUse(m_ZExt(m_Value(Y))))) &&
6701 Y->getType()->isIntOrIntVectorTy(1) && Pred == ICmpInst::ICMP_ULT)
6706 if (match(&I, m_c_ICmp(Pred, m_Value(X), m_OneUse(m_SExt(m_Value(Y))))) &&
6707 Y->getType()->isIntOrIntVectorTy(1) && Pred == ICmpInst::ICMP_ULE)
6781 InstCombiner::getFlippedStrictnessPredicateAndConstant(CmpInst::Predicate Pred,
6783 assert(ICmpInst::isRelational(Pred) && ICmpInst::isIntPredicate(Pred) &&
6787 bool IsSigned = ICmpInst::isSigned(Pred);
6789 CmpInst::Predicate UnsignedPred = ICmpInst::getUnsignedPredicate(Pred);
6844 CmpInst::Predicate NewPred = CmpInst::getFlippedStrictnessPredicate(Pred);
6857 ICmpInst::Predicate Pred = I.getPredicate();
6858 if (ICmpInst::isEquality(Pred) || !ICmpInst::isIntPredicate(Pred) ||
6859 InstCombiner::isCanonicalPredicate(Pred))
6869 InstCombiner::getFlippedStrictnessPredicateAndConstant(Pred, Op1C);
6880 CmpInst::Predicate Pred = I.getPredicate();
6881 if (InstCombiner::isCanonicalPredicate(Pred))
6890 I.setPredicate(CmpInst::getInversePredicate(Pred));
6981 ICmpInst::Predicate Pred, NewPred;
6984 m_c_ICmp(Pred, m_OneUse(m_Shl(m_One(), m_Value(Y))), m_Value(X)))) {
6985 switch (Pred) {
6995 } else if (match(&Cmp, m_c_ICmp(Pred,
7004 switch (Pred) {
7024 const CmpInst::Predicate Pred = Cmp.getPredicate();
7028 auto createCmpReverse = [&](CmpInst::Predicate Pred, Value *X, Value *Y) {
7029 Value *V = Builder.CreateCmp(Pred, X, Y, Cmp.getName());
7039 // cmp Pred, rev(V1), rev(V2) --> rev(cmp Pred, V1, V2)
7042 return createCmpReverse(Pred, V1, V2);
7044 // cmp Pred, rev(V1), RHSSplat --> rev(cmp Pred, V1, RHSSplat)
7046 return createCmpReverse(Pred, V1, RHS);
7048 // cmp Pred, LHSSplat, rev(V2) --> rev(cmp Pred, LHSSplat, V2)
7050 return createCmpReverse(Pred, LHS, V2);
7062 Value *NewCmp = Builder.CreateCmp(Pred, V1, V2);
7083 Value *NewCmp = Builder.CreateCmp(Pred, V1, C);
7093 CmpInst::Predicate Pred = I.getPredicate();
7101 ((Pred == ICmpInst::ICMP_ULT && (Op1 == A || Op1 == B)) ||
7102 (Pred == ICmpInst::ICMP_EQ && match(Op1, m_ZeroInt()) &&
7104 (Pred == ICmpInst::ICMP_NE && match(Op1, m_AllOnes()) &&
7111 Pred == ICmpInst::ICMP_UGT && (Op0 == A || Op0 == B))
7187 Instruction *InstCombinerImpl::foldICmpCommutative(ICmpInst::Predicate Pred,
7192 if (Instruction *NI = foldGEPICmp(GEP, Op1, Pred, CxtI))
7196 if (Instruction *NI = foldSelectICmp(Pred, SI, Op1, CxtI))
7200 if (Instruction *Res = foldICmpWithMinMax(CxtI, MinMax, Op1, Pred))
7208 return foldICmpAddOpConst(X, *C, Pred);
7231 switch (Pred) {
7263 if (Value *V = foldICmpWithLowBitMaskedVal(Pred, Op0, Op1, Q, *this))
7270 return new ICmpInst(ICmpInst::getSwappedPredicate(Pred), Op1,
7274 if (!ICmpInst::isUnsigned(Pred) &&
7276 return new ICmpInst(ICmpInst::getSwappedPredicate(Pred), Op1,
7285 return new ICmpInst(ICmpInst::getSwappedPredicate(Pred), Op1,
7289 if ((Pred == CmpInst::ICMP_SLT || Pred == CmpInst::ICMP_SGE) &&
7291 return new ICmpInst(ICmpInst::getSwappedPredicate(Pred), Op1,
7386 ICmpInst::Predicate Pred = I.getPredicate();
7390 if (Pred == ICmpInst::ICMP_UGT && C->isMaxSignedValue()) {
7396 if (Pred == ICmpInst::ICMP_ULT && C->isMinSignedValue()) {
7455 if (Value *Res = simplifyICmpInst(Pred, A, C, SQ)) {
7456 Value *NewICMP = Builder.CreateICmp(Pred, B, D);
7460 if (Value *Res = simplifyICmpInst(Pred, B, D, SQ)) {
7461 Value *NewICMP = Builder.CreateICmp(Pred, A, C);
7535 // Fold (X u>> BitWidth - 1 Pred ZExt(i1)) --> X s< 0 Pred i1
7536 // Fold (X s>> BitWidth - 1 Pred SExt(i1)) --> X s< 0 Pred i1
7554 Value *Cmp = Builder.CreateICmp(Pred, SLTZero, Y, I.getName());
7673 ICmpInst::Predicate Pred;
7678 Pred = ICmpInst::ICMP_EQ;
7682 Pred = LHSUnsigned ? ICmpInst::ICMP_UGT : ICmpInst::ICMP_SGT;
7686 Pred = LHSUnsigned ? ICmpInst::ICMP_UGE : ICmpInst::ICMP_SGE;
7690 Pred = LHSUnsigned ? ICmpInst::ICMP_ULT : ICmpInst::ICMP_SLT;
7694 Pred = LHSUnsigned ? ICmpInst::ICMP_ULE : ICmpInst::ICMP_SLE;
7698 Pred = ICmpInst::ICMP_NE;
7717 if (Pred == ICmpInst::ICMP_NE || Pred == ICmpInst::ICMP_SLT ||
7718 Pred == ICmpInst::ICMP_SLE)
7729 if (Pred == ICmpInst::ICMP_NE || Pred == ICmpInst::ICMP_ULT ||
7730 Pred == ICmpInst::ICMP_ULE)
7742 if (Pred == ICmpInst::ICMP_NE || Pred == ICmpInst::ICMP_SGT ||
7743 Pred == ICmpInst::ICMP_SGE)
7753 if (Pred == ICmpInst::ICMP_NE || Pred == ICmpInst::ICMP_UGT ||
7754 Pred == ICmpInst::ICMP_UGE)
7772 switch (Pred) {
7788 Pred = ICmpInst::ICMP_SLT;
7795 Pred = ICmpInst::ICMP_ULE;
7801 Pred = ICmpInst::ICMP_SLE;
7813 Pred = ICmpInst::ICMP_SGE;
7820 Pred = ICmpInst::ICMP_UGT;
7826 Pred = ICmpInst::ICMP_SGT;
7834 return new ICmpInst(Pred, LHSI->getOperand(0),
7854 FCmpInst::Predicate Pred = I.getPredicate();
7857 if ((Pred != FCmpInst::FCMP_OGT) && (Pred != FCmpInst::FCMP_OLT) &&
7858 (Pred != FCmpInst::FCMP_OGE) && (Pred != FCmpInst::FCMP_OLE))
7880 Pred = I.getSwappedPredicate();
7882 return new FCmpInst(Pred, LHSI->getOperand(1), RHSC, "", &I);
7987 CmpInst::Predicate Pred = I.getPredicate();
7993 Pred = I.getSwappedPredicate();
8000 // fcmp Pred Op0, -Op0 --> fcmp Pred Op0, 0.0
8002 return new FCmpInst(Pred, Op0, Zero, "", &I);
8007 const CmpInst::Predicate Pred = I.getPredicate();
8010 switch (Pred) {
8063 const CmpInst::Predicate Pred = I.getPredicate();
8065 if (Value *V = simplifyFCmpInst(Pred, Op0, Op1, I.getFastMathFlags(),
8073 switch (Pred) {
8105 if (Pred == CmpInst::FCMP_ORD || Pred == CmpInst::FCMP_UNO) {
8139 // fcmp Pred X, -0.0 --> fcmp Pred X, 0.0
8162 switch (C->isNegative() ? FCmpInst::getSwappedPredicate(Pred) : Pred) {
8194 if (Pred == FCmpInst::FCMP_OEQ)
8196 else if (Pred == FCmpInst::FCMP_UNE)
8214 if (FCmpInst::isEquality(Pred) && match(RHSC, m_AnyZeroFP()) &&
8263 return new FCmpInst(Pred, X, Op1, "", &I);
8267 return new FCmpInst(Pred, Op0, Y, "", &I);
8272 return new FCmpInst(Pred, X, Y, "", &I);
8286 switch (Pred) {
8314 return new FCmpInst(Pred, X, NewC, "", &I);
8331 if (Pred == FCmpInst::FCMP_OLT) {
8345 return new FCmpInst(Pred, Op1, Op1, "", &I);
8349 return new FCmpInst(Pred, Op0, Op0, "", &I);
8353 return new FCmpInst(Pred, CanonLHS, CanonRHS, "", &I);