reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Declarations

include/llvm/Analysis/ScalarEvolution.h

  600   const SCEV *getNegativeSCEV(const SCEV *V,

References

lib/Analysis/DependenceAnalysis.cpp

  358   return SE->getNegativeSCEV(C);
  390   B = SE->getNegativeSCEV(A);
  391   C = SE->getNegativeSCEV(D);
 1170       SE->isKnownNonNegative(Delta) ? Delta : SE->getNegativeSCEV(Delta);
 1172       SE->isKnownNonNegative(Coeff) ? Coeff : SE->getNegativeSCEV(Coeff);
 1224                             SE->getNegativeSCEV(Coeff),
 1225                             SE->getNegativeSCEV(Delta), CurLoop);
 1314     ConstCoeff = dyn_cast<SCEVConstant>(SE->getNegativeSCEV(ConstCoeff));
 1317     Delta = SE->getNegativeSCEV(Delta);
 1509   NewConstraint.setLine(SrcCoeff, SE->getNegativeSCEV(DstCoeff),
 1736     SE->getNegativeSCEV(ConstCoeff) : ConstCoeff;
 1738     SE->isKnownNegative(ConstCoeff) ? SE->getNegativeSCEV(Delta) : Delta;
 1845     SE->getNegativeSCEV(ConstCoeff) : ConstCoeff;
 1847     SE->isKnownNegative(ConstCoeff) ? SE->getNegativeSCEV(Delta) : Delta;
 2173     else if (SrcCoeff == SE->getNegativeSCEV(DstCoeff))
 2252       DstCoeff = SE->getNegativeSCEV(SrcAddRec->getStepRecurrence(*SE));
 2265       SrcCoeff = SE->getNegativeSCEV(DstAddRec->getStepRecurrence(*SE));
 2846       Bound[K].Lower[Dependence::DVEntry::LT] = SE->getNegativeSCEV(B[K].Coeff);
 2850       Bound[K].Upper[Dependence::DVEntry::LT] = SE->getNegativeSCEV(B[K].Coeff);
 3104   Dst = addToCoefficient(Dst, CurLoop, SE->getNegativeSCEV(A_K));

lib/Analysis/LoopAccessAnalysis.cpp

 1397   const SCEV *NegDist = SE.getNegativeSCEV(CastedDist);

lib/Analysis/ScalarEvolution.cpp

 4040   return getAddExpr(LHS, getNegativeSCEV(RHS, NegFlags), AddFlags, Depth);
 6192           AddOps.push_back(getNegativeSCEV(getSCEV(BO->RHS)));
 8778   const SCEV *Distance = CountDown ? Start : getNegativeSCEV(Start);
 8813         getUDivExpr(Distance, CountDown ? getNegativeSCEV(Step) : Step);
 8823                                                getNegativeSCEV(Start), *this);
10268     auto *MinusOne = getNegativeSCEV(getOne(RHS->getType()));
10341       auto *MinusOne = getNegativeSCEV(getOne(WTy));
10745   const SCEV *Stride = getNegativeSCEV(IV->getStepRecurrence(*this));
12544            MatchURemWithDivisor(getNegativeSCEV(Mul->getOperand(1))) ||
12545            MatchURemWithDivisor(getNegativeSCEV(Mul->getOperand(0)));

lib/Analysis/ScalarEvolutionExpander.cpp

  740       Value *W = expandCodeFor(SE.getNegativeSCEV(Op), Ty);
 1119                     SE.getNegativeSCEV(Requested)) == Phi) {
 1282     Step = SE.getNegativeSCEV(Step);
 1425         Step = SE.getNegativeSCEV(Step);
 2270   Value *NegStepValue = expandCodeFor(SE.getNegativeSCEV(Step), Ty, Loc);
 2297     const SCEV *NegMulS = SE.getNegativeSCEV(MulS);

lib/Target/PowerPC/PPCLoopPreIncPrep.cpp

  317         E.Offset = cast<SCEVConstant>(SE->getNegativeSCEV(Offset));

lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp

  864   const SCEV *Addend = SE.getNegativeSCEV(IndVarBase->getStepRecurrence(SE));
 1672     const SCEV *NegOne = SE.getNegativeSCEV(One);

lib/Transforms/Scalar/LoopIdiomRecognize.cpp

  921           SE->getNegativeSCEV(SE->getOne(BECount->getType())))) {

tools/polly/lib/Support/SCEVValidator.cpp

  737       Factor = cast<SCEVConstant>(SE.getNegativeSCEV(Factor));
  738       LeftOvers.push_back(SE.getNegativeSCEV(Op0Pair.second));
  748       else if (Factor == SE.getNegativeSCEV(OpUPair.first))
  749         LeftOvers.push_back(SE.getNegativeSCEV(OpUPair.second));

unittests/Analysis/ScalarEvolutionTest.cpp

 1112   const auto *A0 = SE.getNegativeSCEV(ArgSCEV);
 1114   const auto *A = SE.getNegativeSCEV(A1);
 1117   const auto *B = SE.getNegativeSCEV(B0);