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

References

include/llvm/Analysis/TargetTransformInfoImpl.h

  670     return dyn_cast<SCEVConstant>(AddRec->getStepRecurrence(*SE));

lib/Analysis/DependenceAnalysis.cpp

  888   const SCEV *Step = AddRec->getStepRecurrence(*SE);
  913   const SCEV *Step = AddRec->getStepRecurrence(*SE);
 2163     const SCEV *SrcCoeff = SrcAddRec->getStepRecurrence(*SE);
 2164     const SCEV *DstCoeff = DstAddRec->getStepRecurrence(*SE);
 2185     const SCEV *SrcCoeff = SrcAddRec->getStepRecurrence(*SE);
 2195     const SCEV *DstCoeff = DstAddRec->getStepRecurrence(*SE);
 2239     SrcCoeff = SrcAddRec->getStepRecurrence(*SE);
 2242     DstCoeff = DstAddRec->getStepRecurrence(*SE);
 2249       SrcCoeff = tmpAddRec->getStepRecurrence(*SE);
 2252       DstCoeff = SE->getNegativeSCEV(SrcAddRec->getStepRecurrence(*SE));
 2262       DstCoeff = tmpAddRec->getStepRecurrence(*SE);
 2265       SrcCoeff = SE->getNegativeSCEV(DstAddRec->getStepRecurrence(*SE));
 2343     const SCEV *Coeff = AddRec->getStepRecurrence(*SE);
 2362     const SCEV *Coeff = AddRec->getStepRecurrence(*SE);
 2435     const SCEV *SrcCoeff = AddRec->getStepRecurrence(*SE);
 2440       const SCEV *Coeff = AddRec->getStepRecurrence(*SE);
 2457       const SCEV *Coeff = AddRec->getStepRecurrence(*SE);
 2926     CI[K].Coeff = AddRec->getStepRecurrence(*SE);
 3001     return AddRec->getStepRecurrence(*SE);
 3019                            AddRec->getStepRecurrence(*SE),
 3040     const SCEV *Sum = SE->getAddExpr(AddRec->getStepRecurrence(*SE), Value);
 3052       AddRec->getStepRecurrence(*SE), AddRec->getLoop(),

lib/Analysis/IVDescriptors.cpp

 1064   const SCEV *Step = AR->getStepRecurrence(*SE);

lib/Analysis/IVUsers.cpp

   73           !isInteresting(AR->getStepRecurrence(*SE), I, L, SE, LI);
  413     return AR->getStepRecurrence(*SE);

lib/Analysis/Loads.cpp

  221   auto* Step = dyn_cast<SCEVConstant>(AddRec->getStepRecurrence(SE));

lib/Analysis/LoopAccessAnalysis.cpp

  209     const SCEV *Step = AR->getStepRecurrence(*SE);
 1053   const SCEV *Step = AR->getStepRecurrence(*PSE.getSE());

lib/Analysis/LoopCacheAnalysis.cpp

   84   const SCEV *Step = AR->getStepRecurrence(SE);
   92   return AR->getStepRecurrence(SE) == &ElemSize;
  403   return AR->getStepRecurrence(SE);
  425   const SCEV *Step = AR->getStepRecurrence(SE);

lib/Analysis/LoopInfo.cpp

  273     if (const SCEV *StepRecur = StepAddRecExpr->getStepRecurrence(SE)) {

lib/Analysis/ScalarEvolution.cpp

  977     divide(SE, Numerator->getStepRecurrence(SE), Denominator, &StepQ, &StepR);
 1444   const SCEV *Step = AR->getStepRecurrence(*SE);
 1520   return SE->getAddExpr((SE->*GetExtendExpr)(AR->getStepRecurrence(*SE), Ty,
 1690       const SCEV *Step = AR->getStepRecurrence(*this);
 2034       const SCEV *Step = AR->getStepRecurrence(*this);
 3214             dyn_cast<SCEVConstant>(AR->getStepRecurrence(*this))) {
 4416       return SE.getMinusSCEV(Expr, Expr->getStepRecurrence(SE));
 4444     ConstantRange IncRange = getSignedRange(AR->getStepRecurrence(*this));
 4454     ConstantRange IncRange = getUnsignedRange(AR->getStepRecurrence(*this));
 4948       !areExprsEqual(AR1->getStepRecurrence(SE), AR2->getStepRecurrence(SE)))
 4948       !areExprsEqual(AR1->getStepRecurrence(SE), AR2->getStepRecurrence(SE)))
 5681             AddRec->getStart(), AddRec->getStepRecurrence(*this), MaxBECount,
 5688             AddRec->getStart(), AddRec->getStepRecurrence(*this), MaxBECount,
 9251     const SCEV *Step = LHS->getStepRecurrence(*this);
 9889     if (LAR->getStepRecurrence(*this) != MAR->getStepRecurrence(*this))
 9889     if (LAR->getStepRecurrence(*this) != MAR->getStepRecurrence(*this))
10164   if (LAR->getStepRecurrence(SE) != RAR->getStepRecurrence(SE))
10164   if (LAR->getStepRecurrence(SE) != RAR->getStepRecurrence(SE))
10605   const SCEV *Stride = IV->getStepRecurrence(*this);
10745   const SCEV *Stride = getNegativeSCEV(IV->getStepRecurrence(*this));
10913       Strides.push_back(AR->getStepRecurrence(SE));
12136       const SCEV *Step = AR->getStepRecurrence(SE);
12152       const SCEV *Step = AR->getStepRecurrence(SE);
12313     if (const auto *Step = dyn_cast<SCEVConstant>(AR->getStepRecurrence(SE)))

lib/Analysis/ScalarEvolutionExpander.cpp

  295     const SCEV *Step = A->getStepRecurrence(SE);
  356                                          A->getStepRecurrence(SE),
  881                                           A->getStepRecurrence(SE),
 1133   const SCEV *Step = AR->getStepRecurrence(SE);
 1147   const SCEV *Step = AR->getStepRecurrence(SE);
 1276   const SCEV *Step = Normalized->getStepRecurrence(SE);
 1358       SE.getAddRecExpr(Start, Normalized->getStepRecurrence(SE),
 1364   const SCEV *Step = Normalized->getStepRecurrence(SE);
 2249   const SCEV *Step = AR->getStepRecurrence(SE);
 2411       const SCEV *Step = AR->getStepRecurrence(SE);

lib/Analysis/VectorUtils.cpp

  210   V = S->getStepRecurrence(*SE);

lib/Target/PowerPC/PPCLoopPreIncPrep.cpp

  353     dyn_cast<SCEVConstant>(BasePtrSCEV->getStepRecurrence(*SE));
  520       dyn_cast<SCEVConstant>(PHIBasePtrSCEV->getStepRecurrence(*SE));
  586               dyn_cast<SCEVConstant>(LARSCEV->getStepRecurrence(*SE))) {

lib/Transforms/Scalar/AlignmentFromAssumptions.cpp

  158     const SCEV *DiffIncSCEV = DiffARSCEV->getStepRecurrence(*SE);

lib/Transforms/Scalar/IndVarSimplify.cpp

 1749       SE->properlyDominates(AddRec->getStepRecurrence(*SE), L->getHeader()) &&
 2231   const SCEV *Step = dyn_cast<SCEVConstant>(AR->getStepRecurrence(*SE));
 2381     assert(AR->getStepRecurrence(*SE)->isOne() && "only handles unit stride");

lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp

  385   IRC.Step = IndexAddRec->getStepRecurrence(SE);
  827           SE.getSignExtendExpr(AR->getStepRecurrence(SE), WideTy);
  830                           ExtendAfterOp->getStepRecurrence(SE) == ExtendedStep;
  848   const SCEV* StepRec = IndVarBase->getStepRecurrence(SE);
  864   const SCEV *Addend = SE.getNegativeSCEV(IndVarBase->getStepRecurrence(SE));
 1600       NoopOrExtend(IndVar->getStepRecurrence(SE), RCType, SE, IsLatchSigned));

lib/Transforms/Scalar/LoopDataPrefetch.cpp

  146   const auto *ConstStride = dyn_cast<SCEVConstant>(AR->getStepRecurrence(*SE));
  302         LSCEVAddRec->getStepRecurrence(*SE)));

lib/Transforms/Scalar/LoopFuse.cpp

  855         bool Pos = SE.isKnownPositive(Expr->getStepRecurrence(SE));

lib/Transforms/Scalar/LoopIdiomRecognize.cpp

 2052   const SCEV *RecStepForA = ScevForSrcA->getStepRecurrence(*SE);
 2053   const SCEV *RecStepForB = ScevForSrcB->getStepRecurrence(*SE);

lib/Transforms/Scalar/LoopInterchange.cpp

  311     const SCEV *Step = AddRec->getStepRecurrence(*SE);

lib/Transforms/Scalar/LoopPredication.cpp

  653       RC.IV->getStepRecurrence(*SE)->isOne() &&
  690   auto *Step = RangeCheckIV->getStepRecurrence(*SE);
  710              CurrLatchCheck.IV->getStepRecurrence(*SE)->getType() &&
  712   if (Step != CurrLatchCheck.IV->getStepRecurrence(*SE)) {
  874   auto *Step = Result->IV->getStepRecurrence(*SE);

lib/Transforms/Scalar/LoopRerollPass.cpp

  588       auto IncSCEV = dyn_cast<SCEVConstant>(PHISCEV->getStepRecurrence(*SE));
  899   if (ADR->getStepRecurrence(*SE) != SE->getMulExpr(StepSCEV, ScaleSCEV))

lib/Transforms/Scalar/LoopStrengthReduce.cpp

  411                                       AR->getStepRecurrence(SE),
  692       const SCEV *Step = getExactSDiv(AR->getStepRecurrence(SE), RHS, SE,
 1266         if (auto *Step = dyn_cast<SCEVConstant>(AR->getStepRecurrence(*SE)))
 1272         const SCEV *LoopStep = AR->getStepRecurrence(*SE);
 2304       AR->getStepRecurrence(SE) != One)
 2668           Strides.insert(AR->getStepRecurrence(SE));
 3519                               AR->getStepRecurrence(SE),
 3552   const SCEV *LoopStep = AR->getStepRecurrence(SE);
 3816           dyn_cast<SCEVConstant>(GAR->getStepRecurrence(SE))) {

lib/Transforms/Utils/LoopUnrollPeel.cpp

  240     const SCEV *Step = LeftAR->getStepRecurrence(SE);

tools/polly/lib/Analysis/ScopInfo.cpp

 1405                                     visit(E->getStepRecurrence(SE)),

tools/polly/lib/Support/SCEVAffinator.cpp

  418                        Expr->getStepRecurrence(SE), Expr->getLoop(), Flags);

tools/polly/lib/Support/SCEVValidator.cpp

  234     ValidatorResult Recurrence = visit(Expr->getStepRecurrence(SE));
  273         Expr->getStepRecurrence(SE), Expr->getLoop(), Expr->getNoWrapFlags());
  723       auto StepPair = extractConstantFactor(AddRec->getStepRecurrence(SE), SE);