Home | History | Annotate | Download | only in Analysis

Lines Matching refs:Pred

1151                                                  ICmpInst::Predicate *Pred,
1155 *Pred = ICmpInst::ICMP_SLT;
1160 *Pred = ICmpInst::ICMP_SGT;
1171 ICmpInst::Predicate *Pred,
1174 *Pred = ICmpInst::ICMP_ULT;
1195 // ICmpInst::Predicate *Pred,
1206 ICmpInst::Predicate *Pred,
1208 return getSignedOverflowLimitForStep(Step, Pred, SE);
1222 ICmpInst::Predicate *Pred,
1224 return getUnsignedOverflowLimitForStep(Step, Pred, SE);
1301 ICmpInst::Predicate Pred;
1303 ExtendOpTraits<ExtendOpTy>::getOverflowLimitForStep(Step, &Pred, SE);
1306 SE->isLoopEntryGuardedByCond(L, Pred, PreStart, OverflowLimit))
1392 ICmpInst::Predicate Pred = ICmpInst::BAD_ICMP_PREDICATE;
1394 DeltaS, &Pred, this);
1395 if (Limit && isKnownPredicate(Pred, PreAR, Limit)) // proves (1)
1740 ICmpInst::Predicate Pred;
1742 getSignedOverflowLimitForStep(Step, &Pred, this);
1744 (isLoopBackedgeGuardedByCond(L, Pred, AR, OverflowLimit) ||
1745 (isLoopEntryGuardedByCond(L, Pred, Start, OverflowLimit) &&
1746 isLoopBackedgeGuardedByCond(L, Pred, AR->getPostIncExpr(*this),
5283 BasicBlock *Pred = BB->getUniquePredecessor();
5284 if (!Pred)
5286 TerminatorInst *PredTerm = Pred->getTerminator();
5295 if (Pred == L->getHeader()) {
5299 BB = Pred;
5639 Value *LHS, Value *RHSV, const Loop *L, ICmpInst::Predicate Pred) {
5768 ConstantFoldCompareInstOperands(Pred, StableValue, RHS, DL, &TLI);
6753 if (BasicBlock *Pred = BB->getSinglePredecessor())
6754 return std::make_pair(Pred, BB);
6796 /// predicate Pred. Return true iff any changes were made.
6798 bool ScalarEvolution::SimplifyICmpOperands(ICmpInst::Predicate &Pred,
6811 if (ConstantExpr::getICmp(Pred,
6820 Pred = ICmpInst::getSwappedPredicate(Pred);
6831 Pred = ICmpInst::getSwappedPredicate(Pred);
6840 switch (Pred) {
6857 Pred = ICmpInst::ICMP_NE;
6863 Pred = ICmpInst::ICMP_EQ;
6869 Pred = ICmpInst::ICMP_UGT;
6875 Pred = ICmpInst::ICMP_NE;
6881 Pred = ICmpInst::ICMP_EQ;
6887 Pred = ICmpInst::ICMP_ULT;
6893 Pred = ICmpInst::ICMP_NE;
6899 Pred = ICmpInst::ICMP_EQ;
6905 Pred = ICmpInst::ICMP_SGT;
6911 Pred = ICmpInst::ICMP_NE;
6917 Pred = ICmpInst::ICMP_EQ;
6923 Pred = ICmpInst::ICMP_SLT;
6929 Pred = ICmpInst::ICMP_NE;
6934 Pred = ICmpInst::ICMP_EQ;
6943 Pred = ICmpInst::ICMP_NE;
6948 Pred = ICmpInst::ICMP_EQ;
6957 Pred = ICmpInst::ICMP_NE;
6962 Pred = ICmpInst::ICMP_EQ;
6971 Pred = ICmpInst::ICMP_NE;
6976 Pred = ICmpInst::ICMP_EQ;
6988 if (ICmpInst::isTrueWhenEqual(Pred))
6990 if (ICmpInst::isFalseWhenEqual(Pred))
6996 switch (Pred) {
7001 Pred = ICmpInst::ICMP_SLT;
7006 Pred = ICmpInst::ICMP_SLT;
7014 Pred = ICmpInst::ICMP_SGT;
7019 Pred = ICmpInst::ICMP_SGT;
7027 Pred = ICmpInst::ICMP_ULT;
7031 Pred = ICmpInst::ICMP_ULT;
7038 Pred = ICmpInst::ICMP_UGT;
7043 Pred = ICmpInst::ICMP_UGT;
7056 return SimplifyICmpOperands(Pred, LHS, RHS, Depth+1);
7063 Pred = ICmpInst::ICMP_EQ;
7069 Pred = ICmpInst::ICMP_NE;
7093 bool ScalarEvolution::isKnownPredicate(ICmpInst::Predicate Pred,
7096 (void)SimplifyICmpOperands(Pred, LHS, RHS);
7108 if (isLoopEntryGuardedByCond(L, Pred, LAR->getStart(), RHS) &&
7109 isLoopBackedgeGuardedByCond(L, Pred, LAR->getPostIncExpr(*this), RHS)) {
7116 if (isLoopEntryGuardedByCond(L, Pred, LHS, RAR->getStart()) &&
7117 isLoopBackedgeGuardedByCond(L, Pred, LHS, RAR->getPostIncExpr(*this))) {
7125 if (isKnownPredicateViaSplitting(Pred, LHS, RHS))
7129 return isKnownPredicateWithRanges(Pred, LHS, RHS);
7133 ICmpInst::Predicate Pred,
7135 bool Result = isMonotonicPredicateImpl(LHS, Pred, Increasing);
7142 LHS, ICmpInst::getSwappedPredicate(Pred), IncreasingSwapped);
7154 ICmpInst::Predicate Pred,
7167 switch (Pred) {
7178 Increasing = Pred == ICmpInst::ICMP_UGT || Pred == ICmpInst::ICMP_UGE;
7191 Increasing = Pred == ICmpInst::ICMP_SGT || Pred == ICmpInst::ICMP_SGE;
7196 Increasing = Pred == ICmpInst::ICMP_SLT || Pred == ICmpInst::ICMP_SLE;
7209 ICmpInst::Predicate Pred, const SCEV *LHS, const SCEV *RHS, const Loop *L,
7219 Pred = ICmpInst::getSwappedPredicate(Pred);
7227 if (!isMonotonicPredicate(ArLHS, Pred, Increasing))
7230 // If the predicate "ArLHS `Pred` RHS" monotonically increases from false to
7232 // "ArLHS `Pred` RHS" == true then we can reason as follows:
7248 auto P = Increasing ? Pred : ICmpInst::getInversePredicate(Pred);
7253 InvariantPred = Pred;
7260 ScalarEvolution::isKnownPredicateWithRanges(ICmpInst::Predicate Pred,
7263 return ICmpInst::isTrueWhenEqual(Pred);
7267 switch (Pred) {
7333 bool ScalarEvolution::isKnownPredicateViaNoOverflow(ICmpInst::Predicate Pred,
7355 switch (Pred) {
7389 bool ScalarEvolution::isKnownPredicateViaSplitting(ICmpInst::Predicate Pred,
7392 if (Pred != ICmpInst::ICMP_ULT || ProvingSplitPredicate)
7416 ICmpInst::Predicate Pred,
7422 if (isKnownPredicateWithRanges(Pred, LHS, RHS)) return true;
7431 isImpliedCond(Pred, LHS, RHS,
7454 if (isImpliedCond(Pred, LHS, RHS, ICmpInst::ICMP_ULT, LoopCounter,
7467 if (isImpliedCond(Pred, LHS, RHS, CI->getArgOperand(0), false))
7504 if (isImpliedCond(Pred, LHS, RHS, Condition,
7518 ICmpInst::Predicate Pred,
7524 if (isKnownPredicateWithRanges(Pred, LHS, RHS)) return true;
7540 if (isImpliedCond(Pred, LHS, RHS,
7554 if (isImpliedCond(Pred, LHS, RHS, CI->getArgOperand(0), false))
7581 /// isImpliedCond - Test whether the condition described by Pred, LHS,
7583 bool ScalarEvolution::isImpliedCond(ICmpInst::Predicate Pred,
7595 return isImpliedCond(Pred, LHS, RHS, BO->getOperand(0), Inverse) ||
7596 isImpliedCond(Pred, LHS, RHS, BO->getOperand(1), Inverse);
7599 return isImpliedCond(Pred, LHS, RHS, BO->getOperand(0), Inverse) ||
7600 isImpliedCond(Pred, LHS, RHS, BO->getOperand(1), Inverse);
7618 return isImpliedCond(Pred, LHS, RHS, FoundPred, FoundLHS, FoundRHS);
7621 bool ScalarEvolution::isImpliedCond(ICmpInst::Predicate Pred, const SCEV *LHS,
7629 if (CmpInst::isSigned(Pred)) {
7649 if (SimplifyICmpOperands(Pred, LHS, RHS))
7651 return CmpInst::isTrueWhenEqual(Pred);
7663 Pred = ICmpInst::getSwappedPredicate(Pred);
7668 if (FoundPred == Pred)
7669 return isImpliedCondOperands(Pred, LHS, RHS, FoundLHS, FoundRHS);
7673 if (ICmpInst::getSwappedPredicate(FoundPred) == Pred) {
7675 return isImpliedCondOperands(Pred, LHS, RHS, FoundRHS, FoundLHS);
7677 return isImpliedCondOperands(ICmpInst::getSwappedPredicate(Pred),
7684 CmpInst::getSignedPredicate(FoundPred) == Pred &&
7686 return isImpliedCondOperands(Pred, LHS, RHS, FoundLHS, FoundRHS);
7708 APInt Min = ICmpInst::isSigned(Pred) ?
7718 switch (Pred) {
7721 // We know V `Pred` SharperMin. If this implies LHS `Pred`
7723 if (isImpliedCondOperands(Pred, LHS, RHS, V,
7729 // We know from the range information that (V `Pred` Min ||
7733 // V `Pred` Min || V == Min && !(V == Min)
7734 // => V `Pred` Min
7736 // If V `Pred` Min implies LHS `Pred` RHS, we're done.
7738 if (isImpliedCondOperands(Pred, LHS, RHS, V, getConstant(Min)))
7750 if (ICmpInst::isTrueWhenEqual(Pred))
7751 if (isImpliedCondOperands(Pred, LHS, RHS, FoundLHS, FoundRHS))
7753 if (Pred == ICmpInst::ICMP_NE)
7829 ICmpInst::Predicate Pred, const SCEV *LHS, const SCEV *RHS,
7831 if (Pred != CmpInst::ICMP_SLT && Pred != CmpInst::ICMP_ULT)
7893 if (Pred == CmpInst::ICMP_ULT) {
7896 assert(Pred == CmpInst::ICMP_SLT && "Checked above!");
7901 return isLoopEntryGuardedByCond(L, Pred, FoundRHS,
7905 /// isImpliedCondOperands - Test whether the condition described by Pred,
7906 /// LHS, and RHS is true whenever the condition described by Pred, FoundLHS,
7908 bool ScalarEvolution::isImpliedCondOperands(ICmpInst::Predicate Pred,
7912 if (isImpliedCondOperandsViaRanges(Pred, LHS, RHS, FoundLHS, FoundRHS))
7915 if (isImpliedCondOperandsViaNoOverflow(Pred, LHS, RHS, FoundLHS, FoundRHS))
7918 return isImpliedCondOperandsHelper(Pred, LHS, RHS,
7921 isImpliedCondOperandsHelper(Pred, LHS, RHS,
7967 Pred,
7974 if (!ICmpInst::isRelational(Pred))
7991 SCEV::NoWrapFlags NW = ICmpInst::isSigned(Pred) ?
7996 return SE.isKnownPredicate(Pred, LAR->getStart(), RAR->getStart());
7999 /// Is LHS `Pred` RHS true on the virtue of LHS or RHS being a Min or Max
8002 ICmpInst::Predicate Pred,
8004 switch (Pred) {
8033 /// Pred, LHS, and RHS is true whenever the condition described by Pred,
8036 ScalarEvolution::isImpliedCondOperandsHelper(ICmpInst::Predicate Pred,
8041 [this](ICmpInst::Predicate Pred, const SCEV *LHS, const SCEV *RHS) {
8042 return isKnownPredicateWithRanges(Pred, LHS, RHS) ||
8043 IsKnownPredicateViaMinOrMax(*this, Pred, LHS, RHS) ||
8044 IsKnownPredicateViaAddRecStart(*this, Pred, LHS, RHS) ||
8045 isKnownPredicateViaNoOverflow(Pred, LHS, RHS);
8048 switch (Pred) {
8086 bool ScalarEvolution::isImpliedCondOperandsViaRanges(ICmpInst::Predicate Pred,
8104 // antecedent "`FoundLHS` `Pred` `FoundRHS`".
8106 ConstantRange::makeAllowedICmpRegion(Pred, ConstFoundRHS);
8114 // consequent, "`LHS` `Pred` `RHS`":
8117 ConstantRange::makeSatisfyingICmpRegion(Pred, ConstRHS);
9600 for (auto *Pred : ExprPreds)
9601 if (const auto *IPred = dyn_cast<const SCEVEqualPredicate>(Pred))
9679 for (auto Pred : Preds)
9680 Pred->print(OS, Depth);
9685 for (auto Pred : Set->Preds)
9686 add(Pred);
9723 void PredicatedScalarEvolution::addPredicate(const SCEVPredicate &Pred) {
9724 if (Preds.implies(&Pred))
9726 Preds.add(&Pred);