Lines Matching refs:FoundRHS

8077   const SCEV *FoundRHS = getSCEV(ICI->getOperand(1));
8079   return isImpliedCond(Pred, LHS, RHS, FoundPred, FoundLHS, FoundRHS);
8086                                     const SCEV *FoundRHS) {
8101       FoundRHS = getSignExtendExpr(FoundRHS, LHS->getType());
8104       FoundRHS = getZeroExtendExpr(FoundRHS, LHS->getType());
8113   if (SimplifyICmpOperands(FoundPred, FoundLHS, FoundRHS))
8114     if (FoundLHS == FoundRHS)
8118   if (LHS == FoundRHS || RHS == FoundLHS) {
8120       std::swap(FoundLHS, FoundRHS);
8130     return isImpliedCondOperands(Pred, LHS, RHS, FoundLHS, FoundRHS);
8136       return isImpliedCondOperands(Pred, LHS, RHS, FoundRHS, FoundLHS);
8139                                    RHS, LHS, FoundLHS, FoundRHS);
8146       isKnownNonNegative(FoundLHS) && isKnownNonNegative(FoundRHS))
8147     return isImpliedCondOperands(Pred, LHS, RHS, FoundLHS, FoundRHS);
8151       (isa<SCEVConstant>(FoundLHS) || isa<SCEVConstant>(FoundRHS))) {
8158       V = FoundRHS;
8160       C = cast<SCEVConstant>(FoundRHS);
8212       if (isImpliedCondOperands(Pred, LHS, RHS, FoundLHS, FoundRHS))
8216       if (isImpliedCondOperands(FoundPred, LHS, RHS, FoundLHS, FoundRHS))
8291     const SCEV *FoundLHS, const SCEV *FoundRHS) {
8311   //  FoundLHS u< FoundRHS u< -C =>  (FoundLHS + C) u< (FoundRHS + C) ... (1)
8313   //  FoundLHS s< FoundRHS s< INT_MIN - C => (FoundLHS + C) s< (FoundRHS + C)
8322   //       FoundLHS s< FoundRHS s< INT_MIN - C
8323   // <=>  (FoundLHS + INT_MIN) u< (FoundRHS + INT_MIN) u< -C   [ using (3) ]
8324   // <=>  (FoundLHS + INT_MIN + C) u< (FoundRHS + INT_MIN + C) [ using (1) ]
8326   //                        (FoundRHS + INT_MIN + C + INT_MIN) [ using (3) ]
8327   // <=>  FoundLHS + C s< FoundRHS + C
8336   // Despite (2), "FoundRHS s< INT_MIN - C" does not mean that "FoundRHS + C"
8337   // will not sign underflow.  For instance, say FoundLHS = (i8 -128), FoundRHS
8338   // = (i8 -127) and C = (i8 -100).  Then INT_MIN - C = (i8 -28), and FoundRHS
8339   // s< (INT_MIN - C).  Lack of sign overflow / underflow in "FoundRHS + C" is
8340   // neither necessary nor sufficient to prove "(FoundLHS + C) s< (FoundRHS +
8345       !computeConstantDifference(FoundRHS, RHS, RDiff) ||
8362   return isLoopEntryGuardedByCond(L, Pred, FoundRHS,
8369                                             const SCEV *FoundRHS) {
8370   if (isImpliedCondOperandsViaRanges(Pred, LHS, RHS, FoundLHS, FoundRHS))
8373   if (isImpliedCondOperandsViaNoOverflow(Pred, LHS, RHS, FoundLHS, FoundRHS))
8377                                      FoundLHS, FoundRHS) ||
8380                                      getNotSCEV(FoundRHS),
8494                                              const SCEV *FoundRHS) {
8507     if (HasSameValue(LHS, FoundLHS) && HasSameValue(RHS, FoundRHS))
8513         IsKnownPredicateFull(ICmpInst::ICMP_SGE, RHS, FoundRHS))
8519         IsKnownPredicateFull(ICmpInst::ICMP_SLE, RHS, FoundRHS))
8525         IsKnownPredicateFull(ICmpInst::ICMP_UGE, RHS, FoundRHS))
8531         IsKnownPredicateFull(ICmpInst::ICMP_ULE, RHS, FoundRHS))
8543                                                      const SCEV *FoundRHS) {
8544   if (!isa<SCEVConstant>(RHS) || !isa<SCEVConstant>(FoundRHS))
8545     // The restriction on `FoundRHS` be lifted easily -- it exists only to
8554   APInt ConstFoundRHS = cast<SCEVConstant>(FoundRHS)->getAPInt();
8557   // antecedent "`FoundLHS` `Pred` `FoundRHS`".