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

Declarations

include/llvm/Analysis/ScalarEvolution.h
  511   const SCEV *getConstant(const APInt &Val);

References

include/llvm/Analysis/LoopUnrollAnalyzer.h
   52       IterationNumber = SE.getConstant(APInt(64, Iteration));
lib/Analysis/DependenceAnalysis.cpp
  549       X->setPoint(SE->getConstant(Xq),
  550                   SE->getConstant(Yq),
 1198     Result.DV[Level].Distance = SE->getConstant(Distance);
 1199     NewConstraint.setDistance(SE->getConstant(Distance), CurLoop);
 3138     Src = SE->getMinusSCEV(Src, SE->getMulExpr(AP_K, SE->getConstant(CdivB)));
 3152     Src = SE->getAddExpr(Src, SE->getMulExpr(A_K, SE->getConstant(CdivA)));
 3166     Src = SE->getAddExpr(Src, SE->getMulExpr(A_K, SE->getConstant(CdivA)));
lib/Analysis/LoopAccessAnalysis.cpp
 1212   const SCEV *OffsetSCEVA = SE.getConstant(OffsetA);
 1213   const SCEV *OffsetSCEVB = SE.getConstant(OffsetB);
 1225   const SCEV *SizeSCEV = SE.getConstant(Size);
lib/Analysis/ScalarEvolution.cpp
  966       Quotient = SE.getConstant(QuotientVal);
  967       Remainder = SE.getConstant(RemainderVal);
 1218   const SCEV *DivResult = SE.getUDivExpr(Dividend, SE.getConstant(DivFactor));
 1222   return SE.getMulExpr(SE.getConstant(MultiplyFactor),
 1351     return SE->getConstant(APInt::getSignedMinValue(BitWidth) -
 1356     return SE->getConstant(APInt::getSignedMaxValue(BitWidth) -
 1371   return SE->getConstant(APInt::getMinValue(BitWidth) -
 1574     const SCEV *PreStart = getConstant(StartAI - Delta);
 1790           const SCEV *N = getConstant(APInt::getMinValue(BitWidth) -
 1805           const SCEV *N = getConstant(APInt::getMaxValue(BitWidth) -
 1830           const SCEV *SZExtD = getZeroExtendExpr(getConstant(D), Ty, Depth);
 1832               getAddRecExpr(getConstant(C - D), Step, L, AR->getNoWrapFlags());
 1884         const SCEV *SZExtD = getZeroExtendExpr(getConstant(D), Ty, Depth);
 1886             getAddExpr(getConstant(-D), SA, SCEV::FlagAnyWrap, Depth);
 2017         const SCEV *SSExtD = getSignExtendExpr(getConstant(D), Ty, Depth);
 2019             getAddExpr(getConstant(-D), SA, SCEV::FlagAnyWrap, Depth);
 2162           const SCEV *SSExtD = getSignExtendExpr(getConstant(D), Ty, Depth);
 2164               getAddRecExpr(getConstant(C - D), Step, L, AR->getNoWrapFlags());
 2432       Ops[0] = getConstant(LHSC->getAPInt() + RHSC->getAPInt());
 2594         Ops.push_back(getConstant(AccumulatedConstant));
 2598               getConstant(MulOp.first),
 3240               LHS = getAddRecExpr(getConstant(StartInt - StartRem), Step,
 3273           return getUDivExpr(OtherDiv->getLHS(), getConstant(NewRHS));
 3363             cast<SCEVConstant>(getConstant(LHSCst->getAPInt().udiv(Factor)));
 3365             cast<SCEVConstant>(getConstant(RHSCst->getAPInt().udiv(Factor)));
 5953   const SCEV *TrueStart = this->getConstant(StartPattern.TrueValue);
 5954   const SCEV *TrueStep = this->getConstant(StepPattern.TrueValue);
 5955   const SCEV *FalseStart = this->getConstant(StartPattern.FalseValue);
 5956   const SCEV *FalseStep = this->getConstant(StepPattern.FalseValue);
 6270           const SCEV *MulCount = getConstant(APInt::getOneBitSet(BitWidth, TZ));
 6280               MulOps.push_back(getConstant(OpC->getAPInt().lshr(GCD)));
 6283               ShiftedLHS = getUDivExpr(NewMul, getConstant(DivAmt));
 6357                   return getZeroExtendExpr(getAddExpr(Z0, getConstant(Trunc)),
 6437                 getConstant(Mul)), OuterTy);
 7271         MaxBECount = getConstant(getUnsignedRangeMax(BECount));
 7318         MaxBECount = getConstant(getUnsignedRangeMax(BECount));
 8428   const SCEV *D = SE.getConstant(APInt::getOneBitSet(BW, Mult2));
 8429   return SE.getUDivExactExpr(SE.getMulExpr(B, SE.getConstant(I)), D);
 8737       const auto *R = cast<SCEVConstant>(getConstant(S.getValue()));
 8802     return ExitLimit(Distance, getConstant(MaxBECount), false, Predicates);
 8817             : getConstant(getUnsignedRangeMax(Exact));
 8826                       : getConstant(getUnsignedRangeMax(E));
 8958         RHS = getConstant(NewRHS);
 8991         RHS = getConstant(RA - 1);
 8997         RHS = getConstant(RA + 1);
 9003         RHS = getConstant(RA - 1);
 9009         RHS = getConstant(RA + 1);
 9815                                     getConstant(SharperMin)))
 9830           if (isImpliedCondOperands(Pred, LHS, RHS, V, getConstant(Min)))
10001                                   getConstant(FoundRHSLimit));
10574   MaxBECount = computeBECount(getConstant(MaxEnd - MinStart) /* Delta */,
10575                               getConstant(StrideForMaxBECount) /* Step */,
10717     MaxBECount = getConstant(getUnsignedRangeMax(BECount));
10787                                : computeBECount(getConstant(MaxStart - MinEnd),
10788                                                 getConstant(MinStride), false);
10861       return SE.getConstant(S.getValue());
11929       return SE.getConstant(Constant->getAPInt());
lib/Analysis/ScalarEvolutionExpander.cpp
  272             Remainder, SE.getConstant(C->getAPInt().srem(FC->getAPInt())));
  287         NewMulOps[0] = SE.getConstant(C->getAPInt().sdiv(FC->getAPInt()));
lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp
  378     const SCEV *SIntMax = SE.getConstant(APInt::getSignedMaxValue(BitWidth));
  680   const SCEV *Limit = SE.getMinusSCEV(SE.getConstant(Min), StepPlusOne);
  728   const SCEV *Limit = SE.getMinusSCEV(SE.getConstant(Max), StepMinusOne);
 1612   const SCEV *SIntMax = SE.getConstant(APInt::getSignedMaxValue(BitWidth));
lib/Transforms/Scalar/LoopStrengthReduce.cpp
  686     return SE.getConstant(LA.sdiv(RA));
lib/Transforms/Utils/LoopUtils.cpp
 1020                                      SE.getConstant(Min));
 1031                                      SE.getConstant(Max));
lib/Transforms/Vectorize/LoadStoreVectorizer.cpp
  376   const SCEV *C = SE.getConstant(BaseDelta);
  481   const SCEV *C = SE.getConstant(IdxDiff.trunc(BitWidth));
unittests/Analysis/ScalarEvolutionTest.cpp
  868   auto *Five = SE.getConstant(APInt(/*numBits=*/64, 5));
 1637     return SE.getAddRecExpr(SE.getConstant(APInt(ARBitWidth, 5)),
 1899     SmallVector<const SCEV *, 3> Ops = {SE.getConstant(APInt(ARBitWidth, 5)),
 1909     SmallVector<const SCEV *, 4> Ops = {SE.getConstant(APInt(ARBitWidth, 5)),
 1920     SmallVector<const SCEV *, 5> Ops = {SE.getConstant(APInt(ARBitWidth, 5)),