Lines Matching defs:FoundLHS
11777 const SCEV *FoundLHS = getSCEV(ICI->getOperand(0));
11780 return isImpliedCond(Pred, LHS, RHS, FoundPred, FoundLHS, FoundRHS, CtxI);
11785 const SCEV *FoundLHS, const SCEV *FoundRHS,
11789 getTypeSizeInBits(FoundLHS->getType())) {
11793 if (!CmpInst::isSigned(FoundPred) && !FoundLHS->getType()->isPointerTy() &&
11796 auto *WideType = FoundLHS->getType();
11800 if (isKnownViaNonRecursiveReasoning(ICmpInst::ICMP_ULE, FoundLHS,
11804 const SCEV *TruncFoundLHS = getTruncateExpr(FoundLHS, NarrowType);
11815 LHS = getSignExtendExpr(LHS, FoundLHS->getType());
11816 RHS = getSignExtendExpr(RHS, FoundLHS->getType());
11818 LHS = getZeroExtendExpr(LHS, FoundLHS->getType());
11819 RHS = getZeroExtendExpr(RHS, FoundLHS->getType());
11822 getTypeSizeInBits(FoundLHS->getType())) {
11823 if (FoundLHS->getType()->isPointerTy() || FoundRHS->getType()->isPointerTy())
11826 FoundLHS = getSignExtendExpr(FoundLHS, LHS->getType());
11829 FoundLHS = getZeroExtendExpr(FoundLHS, LHS->getType());
11833 return isImpliedCondBalancedTypes(Pred, LHS, RHS, FoundPred, FoundLHS,
11839 const SCEV *FoundLHS, const SCEV *FoundRHS, const Instruction *CtxI) {
11841 getTypeSizeInBits(FoundLHS->getType()) &&
11848 if (SimplifyICmpOperands(FoundPred, FoundLHS, FoundRHS))
11849 if (FoundLHS == FoundRHS)
11853 if (LHS == FoundRHS || RHS == FoundLHS) {
11855 std::swap(FoundLHS, FoundRHS);
11866 return isImpliedCondOperands(Pred, LHS, RHS, FoundLHS, FoundRHS, CtxI);
11874 // 0. LHS Pred RHS <- FoundLHS SwapPred FoundRHS
11876 // 1. LHS Pred RHS <- FoundRHS Pred FoundLHS
11877 // 2. RHS SwapPred LHS <- FoundLHS SwapPred FoundRHS
11878 // 3. LHS Pred RHS <- ~FoundLHS Pred ~FoundRHS
11879 // 4. ~LHS SwapPred ~RHS <- FoundLHS SwapPred FoundRHS
11883 return isImpliedCondOperands(FoundPred, RHS, LHS, FoundLHS, FoundRHS,
11885 if (!isa<SCEVConstant>(FoundRHS) && !isa<SCEVAddRecExpr>(FoundLHS))
11886 return isImpliedCondOperands(Pred, LHS, RHS, FoundRHS, FoundLHS, CtxI);
11893 FoundLHS, FoundRHS, CtxI))
11896 if (!FoundLHS->getType()->isPointerTy() &&
11898 isImpliedCondOperands(Pred, LHS, RHS, getNotSCEV(FoundLHS),
11914 if ((isKnownNonNegative(FoundLHS) && isKnownNonNegative(FoundRHS)) ||
11915 (isKnownNegative(FoundLHS) && isKnownNegative(FoundRHS)))
11916 return isImpliedCondOperands(Pred, LHS, RHS, FoundLHS, FoundRHS, CtxI);
11921 *CanonicalFoundLHS = FoundLHS, *CanonicalFoundRHS = FoundRHS;
11951 (isa<SCEVConstant>(FoundLHS) || isa<SCEVConstant>(FoundRHS))) {
11956 if (isa<SCEVConstant>(FoundLHS)) {
11957 C = cast<SCEVConstant>(FoundLHS);
11961 V = FoundLHS;
12029 if (isImpliedCondOperands(Pred, LHS, RHS, FoundLHS, FoundRHS, CtxI))
12033 if (isImpliedCondOperands(FoundPred, LHS, RHS, FoundLHS, FoundRHS, CtxI))
12036 if (isImpliedCondOperandsViaRanges(Pred, LHS, RHS, FoundPred, FoundLHS, FoundRHS))
12174 CmpPredicate Pred, const SCEV *LHS, const SCEV *RHS, const SCEV *FoundLHS,
12181 // FoundLHS = {Start,+,W}
12183 // known(Pred, FoundLHS, FoundRHS)
12187 // this case, `FoundLHS Pred FoundRHS` implies `Start Pred FoundRHS`. Try to
12193 if (auto *AR = dyn_cast<SCEVAddRecExpr>(FoundLHS)) {
12210 if (!isAvailableAtLoopEntry(FoundLHS, AR->getLoop()))
12212 return isImpliedCondOperands(Pred, LHS, RHS, FoundLHS, AR->getStart());
12221 const SCEV *FoundLHS,
12230 const auto *AddRecFoundLHS = dyn_cast<SCEVAddRecExpr>(FoundLHS);
12242 // FoundLHS u< FoundRHS u< -C => (FoundLHS + C) u< (FoundRHS + C) ... (1)
12244 // FoundLHS s< FoundRHS s< INT_MIN - C => (FoundLHS + C) s< (FoundRHS + C)
12253 // FoundLHS s< FoundRHS s< INT_MIN - C
12254 // <=> (FoundLHS + INT_MIN) u< (FoundRHS + INT_MIN) u< -C [ using (3) ]
12255 // <=> (FoundLHS + INT_MIN + C) u< (FoundRHS + INT_MIN + C) [ using (1) ]
12256 // <=> (FoundLHS + INT_MIN + C + INT_MIN) s<
12258 // <=> FoundLHS + C s< FoundRHS + C
12268 // will not sign underflow. For instance, say FoundLHS = (i8 -128), FoundRHS
12271 // neither necessary nor sufficient to prove "(FoundLHS + C) s< (FoundRHS +
12274 std::optional<APInt> LDiff = computeConstantDifference(LHS, FoundLHS);
12300 const SCEV *RHS, const SCEV *FoundLHS,
12346 std::swap(FoundLHS, FoundRHS);
12357 isImpliedCondOperandsViaRanges(Pred, S1, S2, Pred, FoundLHS, FoundRHS) ||
12358 isImpliedViaOperations(Pred, S1, S2, FoundLHS, FoundRHS, Depth);
12415 const SCEV *FoundLHS,
12421 std::swap(FoundLHS, FoundRHS);
12424 if (LHS != FoundLHS)
12456 const SCEV *FoundLHS,
12459 if (isImpliedCondOperandsViaRanges(Pred, LHS, RHS, Pred, FoundLHS, FoundRHS))
12462 if (isImpliedCondOperandsViaNoOverflow(Pred, LHS, RHS, FoundLHS, FoundRHS))
12465 if (isImpliedCondOperandsViaShift(Pred, LHS, RHS, FoundLHS, FoundRHS))
12468 if (isImpliedCondOperandsViaAddRecStart(Pred, LHS, RHS, FoundLHS, FoundRHS,
12473 FoundLHS, FoundRHS);
12554 const SCEV *FoundLHS,
12560 assert(getTypeSizeInBits(FoundLHS->getType()) ==
12562 "FoundLHS and FoundRHS have different sizes?");
12571 std::swap(FoundLHS, FoundRHS);
12579 if (isKnownNonNegative(FoundLHS) && isKnownNonNegative(FoundRHS)) {
12580 // Knowing that both FoundLHS and FoundRHS are non-negative, and knowing
12581 // FoundLHS >u FoundRHS, we also know that FoundLHS >s FoundRHS. Let us
12584 if (isImpliedCondOperands(ICmpInst::ICMP_SGT, LHS, MinusOne, FoundLHS,
12586 isImpliedCondOperands(ICmpInst::ICMP_SGT, RHS, MinusOne, FoundLHS,
12604 auto *OrigFoundLHS = FoundLHS;
12606 FoundLHS = GetOpFromSExt(FoundLHS);
12661 // We want to make sure that LHS = FoundLHS / Denominator. If it is so,
12662 // then a SCEV for the numerator already exists and matches with FoundLHS.
12664 if (!Numerator || Numerator->getType() != FoundLHS->getType())
12667 // Make sure that the numerator matches with FoundLHS and the denominator
12669 if (!HasSameValue(Numerator, FoundLHS) || !isKnownPositive(Denominator))
12682 // FoundLHS > FoundRHS, LHS = FoundLHS / Denominator, Denominator > 0.
12689 // For example, given that FoundLHS > 2. It means that FoundLHS is at
12698 // For example, given that FoundLHS > -3. Then FoundLHS is at least -2.
12700 // 1. If FoundLHS is negative, then the result is 0.
12701 // 2. If FoundLHS is non-negative, then the result is non-negative.
12760 const SCEV *FoundLHS,
12767 if (HasSameValue(LHS, FoundLHS) && HasSameValue(RHS, FoundRHS))
12772 if (isKnownViaNonRecursiveReasoning(ICmpInst::ICMP_SLE, LHS, FoundLHS) &&
12778 if (isKnownViaNonRecursiveReasoning(ICmpInst::ICMP_SGE, LHS, FoundLHS) &&
12784 if (isKnownViaNonRecursiveReasoning(ICmpInst::ICMP_ULE, LHS, FoundLHS) &&
12790 if (isKnownViaNonRecursiveReasoning(ICmpInst::ICMP_UGE, LHS, FoundLHS) &&
12797 if (isImpliedViaOperations(Pred, LHS, RHS, FoundLHS, FoundRHS))
12805 const SCEV *FoundLHS, const SCEV *FoundRHS) {
12811 std::optional<APInt> Addend = computeConstantDifference(LHS, FoundLHS);
12817 // `FoundLHSRange` is the range we know `FoundLHS` to be in by virtue of the
12818 // antecedent "`FoundLHS` `FoundPred` `FoundRHS`".
12822 // Since `LHS` is `FoundLHS` + `Addend`, we can compute a range for `LHS`: