|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Declarations
include/llvm/Analysis/DependenceAnalysis.h 53 class SCEVConstant;
tools/polly/include/polly/Support/SCEVValidator.h 17 class SCEVConstant;
References
include/llvm/Analysis/DependenceAnalysis.h 584 const SCEVConstant *collectConstantUpperBound(const Loop *l, Type *T) const;
include/llvm/Analysis/ScalarEvolutionExpander.h 362 Value *visitConstant(const SCEVConstant *S) {
include/llvm/Analysis/ScalarEvolutionExpressions.h 672 const SCEV *visitConstant(const SCEVConstant *Constant) {
include/llvm/Analysis/TargetTransformInfoImpl.h 665 const SCEVConstant *getConstantStrideStep(ScalarEvolution *SE,
670 return dyn_cast<SCEVConstant>(AddRec->getStepRecurrence(*SE));
675 const SCEVConstant *Step = getConstantStrideStep(SE, Ptr);
include/llvm/Support/Casting.h 58 return To::classof(&Val);
66 static inline bool doit(const From &) { return true; }
104 static inline bool doit(const From *Val) {
106 return isa_impl<To, From>::doit(*Val);
106 return isa_impl<To, From>::doit(*Val);
122 return isa_impl_wrap<To, SimpleFrom,
132 return isa_impl_cl<To,FromTy>::doit(Val);
142 return isa_impl_wrap<X, const Y,
176 using ret_type = const To *; // Constant pointer arg case, return const Ty*
198 using ret_type = typename cast_retty<To, SimpleFrom>::ret_type;
204 using ret_type = typename cast_retty_impl<To,FromTy>::ret_type;
210 To, From, typename simplify_type<From>::SimpleType>::ret_type;
227 static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
228 typename cast_retty<To, FromTy>::ret_type Res2
256 inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
265 return cast_convert_val<X, Y*,
337 LLVM_NODISCARD inline typename cast_retty<X, Y>::ret_type dyn_cast(Y &Val) {
342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
343 return isa<X>(Val) ? cast<X>(Val) : nullptr;
343 return isa<X>(Val) ? cast<X>(Val) : nullptr;
366 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
368 return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
368 return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
lib/Analysis/DependenceAnalysis.cpp 460 if (isa<SCEVConstant>(Y->getD())) {
503 const SCEVConstant *C1A2_C2A1 =
504 dyn_cast<SCEVConstant>(SE->getMinusSCEV(C1A2, C2A1));
505 const SCEVConstant *C1B2_C2B1 =
506 dyn_cast<SCEVConstant>(SE->getMinusSCEV(C1B2, C2B1));
507 const SCEVConstant *A1B2_A2B1 =
508 dyn_cast<SCEVConstant>(SE->getMinusSCEV(A1B2, A2B1));
509 const SCEVConstant *A2B1_A1B2 =
510 dyn_cast<SCEVConstant>(SE->getMinusSCEV(A2B1, A1B2));
539 if (const SCEVConstant *CUB =
1081 const SCEVConstant *DependenceInfo::collectConstantUpperBound(const Loop *L,
1084 return dyn_cast<SCEVConstant>(UB);
1183 if (isa<SCEVConstant>(Delta) && isa<SCEVConstant>(Coeff)) {
1183 if (isa<SCEVConstant>(Delta) && isa<SCEVConstant>(Coeff)) {
1184 APInt ConstDelta = cast<SCEVConstant>(Delta)->getAPInt();
1185 APInt ConstCoeff = cast<SCEVConstant>(Coeff)->getAPInt();
1308 const SCEVConstant *ConstCoeff = dyn_cast<SCEVConstant>(Coeff);
1308 const SCEVConstant *ConstCoeff = dyn_cast<SCEVConstant>(Coeff);
1314 ConstCoeff = dyn_cast<SCEVConstant>(SE->getNegativeSCEV(ConstCoeff));
1327 const SCEVConstant *ConstDelta = dyn_cast<SCEVConstant>(Delta);
1327 const SCEVConstant *ConstDelta = dyn_cast<SCEVConstant>(Delta);
1511 const SCEVConstant *ConstDelta = dyn_cast<SCEVConstant>(Delta);
1511 const SCEVConstant *ConstDelta = dyn_cast<SCEVConstant>(Delta);
1512 const SCEVConstant *ConstSrcCoeff = dyn_cast<SCEVConstant>(SrcCoeff);
1512 const SCEVConstant *ConstSrcCoeff = dyn_cast<SCEVConstant>(SrcCoeff);
1513 const SCEVConstant *ConstDstCoeff = dyn_cast<SCEVConstant>(DstCoeff);
1513 const SCEVConstant *ConstDstCoeff = dyn_cast<SCEVConstant>(DstCoeff);
1535 if (const SCEVConstant *CUB =
1663 bool isRemainderZero(const SCEVConstant *Dividend,
1664 const SCEVConstant *Divisor) {
1731 const SCEVConstant *ConstCoeff = dyn_cast<SCEVConstant>(DstCoeff);
1731 const SCEVConstant *ConstCoeff = dyn_cast<SCEVConstant>(DstCoeff);
1771 if (isa<SCEVConstant>(Delta) &&
1772 !isRemainderZero(cast<SCEVConstant>(Delta), ConstCoeff)) {
1840 const SCEVConstant *ConstCoeff = dyn_cast<SCEVConstant>(SrcCoeff);
1840 const SCEVConstant *ConstCoeff = dyn_cast<SCEVConstant>(SrcCoeff);
1880 if (isa<SCEVConstant>(Delta) &&
1881 !isRemainderZero(cast<SCEVConstant>(Delta), ConstCoeff)) {
1910 const SCEVConstant *ConstDelta = dyn_cast<SCEVConstant>(Delta);
1910 const SCEVConstant *ConstDelta = dyn_cast<SCEVConstant>(Delta);
1911 const SCEVConstant *ConstSrcCoeff = dyn_cast<SCEVConstant>(SrcCoeff);
1911 const SCEVConstant *ConstSrcCoeff = dyn_cast<SCEVConstant>(SrcCoeff);
1912 const SCEVConstant *ConstDstCoeff = dyn_cast<SCEVConstant>(DstCoeff);
1912 const SCEVConstant *ConstDstCoeff = dyn_cast<SCEVConstant>(DstCoeff);
1933 if (const SCEVConstant *UpperBound =
1943 if (const SCEVConstant *UpperBound =
2301 const SCEVConstant *getConstantPart(const SCEV *Expr) {
2302 if (const auto *Constant = dyn_cast<SCEVConstant>(Expr))
2302 if (const auto *Constant = dyn_cast<SCEVConstant>(Expr))
2305 if (const auto *Constant = dyn_cast<SCEVConstant>(Product->getOperand(0)))
2305 if (const auto *Constant = dyn_cast<SCEVConstant>(Product->getOperand(0)))
2346 const auto *Constant = getConstantPart(Coeff);
2365 const auto *Constant = getConstantPart(Coeff);
2377 const SCEVConstant *Constant = dyn_cast<SCEVConstant>(Delta);
2377 const SCEVConstant *Constant = dyn_cast<SCEVConstant>(Delta);
2382 if (isa<SCEVConstant>(Operand)) {
2384 Constant = cast<SCEVConstant>(Operand);
2389 const SCEVConstant *ConstOp = getConstantPart(Product);
2402 APInt ConstDelta = cast<SCEVConstant>(Constant)->getAPInt();
3129 const SCEVConstant *Bconst = dyn_cast<SCEVConstant>(B);
3129 const SCEVConstant *Bconst = dyn_cast<SCEVConstant>(B);
3130 const SCEVConstant *Cconst = dyn_cast<SCEVConstant>(C);
3130 const SCEVConstant *Cconst = dyn_cast<SCEVConstant>(C);
3144 const SCEVConstant *Aconst = dyn_cast<SCEVConstant>(A);
3144 const SCEVConstant *Aconst = dyn_cast<SCEVConstant>(A);
3145 const SCEVConstant *Cconst = dyn_cast<SCEVConstant>(C);
3145 const SCEVConstant *Cconst = dyn_cast<SCEVConstant>(C);
3158 const SCEVConstant *Aconst = dyn_cast<SCEVConstant>(A);
3158 const SCEVConstant *Aconst = dyn_cast<SCEVConstant>(A);
3159 const SCEVConstant *Cconst = dyn_cast<SCEVConstant>(C);
3159 const SCEVConstant *Cconst = dyn_cast<SCEVConstant>(C);
lib/Analysis/IVDescriptors.cpp 822 if (isa<SCEVConstant>(Step))
823 return dyn_cast<ConstantInt>(cast<SCEVConstant>(Step)->getValue());
1067 const SCEVConstant *ConstStep = dyn_cast<SCEVConstant>(Step);
1067 const SCEVConstant *ConstStep = dyn_cast<SCEVConstant>(Step);
lib/Analysis/Loads.cpp 221 auto* Step = dyn_cast<SCEVConstant>(AddRec->getStepRecurrence(SE));
lib/Analysis/LoopAccessAnalysis.cpp 161 const auto *CT =
213 if (const auto *CStep = dyn_cast<SCEVConstant>(Step)) {
213 if (const auto *CStep = dyn_cast<SCEVConstant>(Step)) {
270 const SCEVConstant *C = dyn_cast<const SCEVConstant>(Diff);
270 const SCEVConstant *C = dyn_cast<const SCEVConstant>(Diff);
1056 const SCEVConstant *C = dyn_cast<SCEVConstant>(Step);
1056 const SCEVConstant *C = dyn_cast<SCEVConstant>(Step);
1129 const auto *Diff = dyn_cast<SCEVConstant>(SE.getMinusSCEV(Scev, Scev0));
1129 const auto *Diff = dyn_cast<SCEVConstant>(SE.getMinusSCEV(Scev, Scev0));
1215 const APInt &OffsetDelta = cast<SCEVConstant>(OffsetDeltaSCEV)->getAPInt();
1497 const SCEVConstant *C = dyn_cast<SCEVConstant>(Dist);
1497 const SCEVConstant *C = dyn_cast<SCEVConstant>(Dist);
lib/Analysis/LoopCacheAnalysis.cpp 100 !isa<SCEVConstant>(BackedgeTakenCount))
172 const SCEVConstant *Diff = dyn_cast<SCEVConstant>(
172 const SCEVConstant *Diff = dyn_cast<SCEVConstant>(
228 const SCEVConstant *SCEVConst = dyn_cast_or_null<SCEVConstant>(Distance);
228 const SCEVConstant *SCEVConst = dyn_cast_or_null<SCEVConstant>(Distance);
297 if (auto ConstantCost = dyn_cast<SCEVConstant>(RefCost))
lib/Analysis/LoopUnrollAnalyzer.cpp 32 if (auto *SC = dyn_cast<SCEVConstant>(S)) {
43 if (auto *SC = dyn_cast<SCEVConstant>(ValueAtIteration)) {
53 dyn_cast<SCEVConstant>(SE.getMinusSCEV(ValueAtIteration, Base));
lib/Analysis/ScalarEvolution.cpp 241 cast<SCEVConstant>(this)->getValue()->printAsOperand(OS, false);
359 return cast<SCEVConstant>(this)->getType();
384 if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(this))
384 if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(this))
390 if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(this))
390 if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(this))
396 if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(this))
396 if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(this))
406 const SCEVConstant *SC = dyn_cast<SCEVConstant>(Mul->getOperand(0));
406 const SCEVConstant *SC = dyn_cast<SCEVConstant>(Mul->getOperand(0));
426 SCEV *S = new (SCEVAllocator) SCEVConstant(ID.Intern(SCEVAllocator), V);
683 const SCEVConstant *LC = cast<SCEVConstant>(LHS);
683 const SCEVConstant *LC = cast<SCEVConstant>(LHS);
684 const SCEVConstant *RC = cast<SCEVConstant>(RHS);
684 const SCEVConstant *RC = cast<SCEVConstant>(RHS);
951 void visitConstant(const SCEVConstant *Numerator) {
952 if (const SCEVConstant *D = dyn_cast<SCEVConstant>(Denominator)) {
952 if (const SCEVConstant *D = dyn_cast<SCEVConstant>(Denominator)) {
1061 cast<SCEVConstant>(Zero)->getValue();
1067 cast<SCEVConstant>(One)->getValue();
1270 if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(Op))
1270 if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(Op))
1567 const SCEVConstant *StartC = dyn_cast<SCEVConstant>(Start);
1567 const SCEVConstant *StartC = dyn_cast<SCEVConstant>(Start);
1606 const SCEVConstant *ConstantTerm,
1646 if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(Op))
1646 if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(Op))
1826 if (const auto *SC = dyn_cast<SCEVConstant>(Start)) {
1826 if (const auto *SC = dyn_cast<SCEVConstant>(Start)) {
1881 if (const auto *SC = dyn_cast<SCEVConstant>(SA->getOperand(0))) {
1881 if (const auto *SC = dyn_cast<SCEVConstant>(SA->getOperand(0))) {
1919 if (auto *MulLHS = dyn_cast<SCEVConstant>(SM->getOperand(0)))
1952 if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(Op))
1952 if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(Op))
2014 if (const auto *SC = dyn_cast<SCEVConstant>(SA->getOperand(0))) {
2014 if (const auto *SC = dyn_cast<SCEVConstant>(SA->getOperand(0))) {
2158 if (const auto *SC = dyn_cast<SCEVConstant>(Start)) {
2158 if (const auto *SC = dyn_cast<SCEVConstant>(Start)) {
2206 if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(Op))
2206 if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(Op))
2278 while (const SCEVConstant *C = dyn_cast<SCEVConstant>(Ops[i])) {
2278 while (const SCEVConstant *C = dyn_cast<SCEVConstant>(Ops[i])) {
2290 if (Mul && isa<SCEVConstant>(Mul->getOperand(0))) {
2292 Scale * cast<SCEVConstant>(Mul->getOperand(0))->getAPInt();
2366 isa<SCEVConstant>(Ops[0])) {
2379 const APInt &C = cast<SCEVConstant>(Ops[0])->getAPInt();
2427 if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(Ops[0])) {
2427 if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(Ops[0])) {
2430 while (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(Ops[Idx])) {
2430 while (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(Ops[Idx])) {
2435 LHSC = cast<SCEVConstant>(Ops[0]);
2505 } else if (const SCEVConstant *C = dyn_cast<SCEVConstant>(Ops[i])) {
2505 } else if (const SCEVConstant *C = dyn_cast<SCEVConstant>(Ops[i])) {
2517 } else if (const auto *C = dyn_cast<SCEVConstant>(M->getOperand(j))) {
2517 } else if (const auto *C = dyn_cast<SCEVConstant>(M->getOperand(j))) {
2535 if (isa<SCEVConstant>(Fold) || isa<SCEVUnknown>(Fold))
2616 if (isa<SCEVConstant>(MulOpSCEV))
2891 FoundConstant |= isa<SCEVConstant>(S);
2932 if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(Ops[0])) {
2932 if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(Ops[0])) {
2951 while (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(Ops[Idx])) {
2951 while (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(Ops[Idx])) {
2958 LHSC = cast<SCEVConstant>(Ops[0]);
2962 if (cast<SCEVConstant>(Ops[0])->getValue()->isOne()) {
2965 } else if (cast<SCEVConstant>(Ops[0])->getValue()->isZero()) {
3165 if (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(RHS)) {
3165 if (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(RHS)) {
3193 if (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(RHS)) {
3193 if (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(RHS)) {
3213 if (const SCEVConstant *Step =
3214 dyn_cast<SCEVConstant>(AR->getStepRecurrence(*this))) {
3231 const SCEVConstant *StartC = dyn_cast<SCEVConstant>(AR->getStart());
3231 const SCEVConstant *StartC = dyn_cast<SCEVConstant>(AR->getStart());
3266 dyn_cast<SCEVConstant>(OtherDiv->getRHS())) {
3297 if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(LHS)) {
3297 if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(LHS)) {
3319 static const APInt gcd(const SCEVConstant *C1, const SCEVConstant *C2) {
3319 static const APInt gcd(const SCEVConstant *C1, const SCEVConstant *C2) {
3347 if (const SCEVConstant *RHSCst = dyn_cast<SCEVConstant>(RHS)) {
3347 if (const SCEVConstant *RHSCst = dyn_cast<SCEVConstant>(RHS)) {
3350 if (const auto *LHSCst = dyn_cast<SCEVConstant>(Mul->getOperand(0))) {
3350 if (const auto *LHSCst = dyn_cast<SCEVConstant>(Mul->getOperand(0))) {
3363 cast<SCEVConstant>(getConstant(LHSCst->getAPInt().udiv(Factor)));
3365 cast<SCEVConstant>(getConstant(RHSCst->getAPInt().udiv(Factor)));
3508 ConstantInt *Index = cast<SCEVConstant>(IndexExpr)->getValue();
3573 if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(Ops[0])) {
3573 if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(Ops[0])) {
3588 while (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(Ops[Idx])) {
3588 while (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(Ops[Idx])) {
3595 LHSC = cast<SCEVConstant>(Ops[0]);
3832 auto *ConstOp = dyn_cast<SCEVConstant>(Add->getOperand(0));
3948 if (const SCEVConstant *VC = dyn_cast<SCEVConstant>(V))
3948 if (const SCEVConstant *VC = dyn_cast<SCEVConstant>(V))
3975 if (const SCEVConstant *VC = dyn_cast<SCEVConstant>(V))
3975 if (const SCEVConstant *VC = dyn_cast<SCEVConstant>(V))
4355 bool IsOne = cast<SCEVConstant>(Res.getValue())->getValue()->isOne();
5439 if (const SCEVConstant *C = dyn_cast<SCEVConstant>(S))
5439 if (const SCEVConstant *C = dyn_cast<SCEVConstant>(S))
5551 if (const SCEVConstant *C = dyn_cast<SCEVConstant>(S))
5551 if (const SCEVConstant *C = dyn_cast<SCEVConstant>(S))
5651 if (const SCEVConstant *C = dyn_cast<SCEVConstant>(AddRec->getStart()))
5651 if (const SCEVConstant *C = dyn_cast<SCEVConstant>(AddRec->getStart()))
5875 if (SA->getNumOperands() != 2 || !isa<SCEVConstant>(SA->getOperand(0)))
5878 Offset = cast<SCEVConstant>(SA->getOperand(0))->getAPInt();
6274 if (auto *OpC = dyn_cast<SCEVConstant>(LHSMul->getOperand(0))) {
6512 static unsigned getConstantTripCount(const SCEVConstant *ExitCount) {
6539 const SCEVConstant *ExitCount =
6540 dyn_cast<SCEVConstant>(getExitCount(L, ExitingBlock));
6545 const auto *MaxExitCount =
6546 dyn_cast<SCEVConstant>(getConstantMaxBackedgeTakenCount(L));
6583 const SCEVConstant *TC = dyn_cast<SCEVConstant>(TCExpr);
6583 const SCEVConstant *TC = dyn_cast<SCEVConstant>(TCExpr);
7398 if (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(RHS))
7398 if (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(RHS))
7485 return cast<SCEVConstant>(Val)->getValue();
7538 !isa<SCEVConstant>(IdxExpr->getOperand(0)) ||
7539 !isa<SCEVConstant>(IdxExpr->getOperand(1)))
8054 return cast<SCEVConstant>(V)->getValue();
8146 if (isa<SCEVConstant>(V)) return V;
8190 if (auto *BTCC = dyn_cast<SCEVConstant>(BackedgeTakenCount)) {
8207 if (isa<SCEVConstant>(InputAtScope)) return InputAtScope;
8444 const SCEVConstant *LC = dyn_cast<SCEVConstant>(AddRec->getOperand(0));
8444 const SCEVConstant *LC = dyn_cast<SCEVConstant>(AddRec->getOperand(0));
8445 const SCEVConstant *MC = dyn_cast<SCEVConstant>(AddRec->getOperand(1));
8445 const SCEVConstant *MC = dyn_cast<SCEVConstant>(AddRec->getOperand(1));
8446 const SCEVConstant *NC = dyn_cast<SCEVConstant>(AddRec->getOperand(2));
8446 const SCEVConstant *NC = dyn_cast<SCEVConstant>(AddRec->getOperand(2));
8712 if (const SCEVConstant *C = dyn_cast<SCEVConstant>(V)) {
8712 if (const SCEVConstant *C = dyn_cast<SCEVConstant>(V)) {
8737 const auto *R = cast<SCEVConstant>(getConstant(S.getValue()));
8737 const auto *R = cast<SCEVConstant>(getConstant(S.getValue()));
8768 const SCEVConstant *StepC = dyn_cast<SCEVConstant>(Step);
8768 const SCEVConstant *StepC = dyn_cast<SCEVConstant>(Step);
8838 if (const SCEVConstant *C = dyn_cast<SCEVConstant>(V)) {
8838 if (const SCEVConstant *C = dyn_cast<SCEVConstant>(V)) {
8910 if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(LHS)) {
8910 if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(LHS)) {
8912 if (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(RHS)) {
8912 if (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(RHS)) {
8940 if (const SCEVConstant *RC = dyn_cast<SCEVConstant>(RHS)) {
8940 if (const SCEVConstant *RC = dyn_cast<SCEVConstant>(RHS)) {
9364 !isa<SCEVConstant>(ConstOp) || NonConstOp != X)
9367 OutY = cast<SCEVConstant>(ConstOp)->getAPInt();
9749 if (isa<SCEVConstant>(RHS)) {
9765 if (isa<SCEVConstant>(RHS))
9781 (isa<SCEVConstant>(FoundLHS) || isa<SCEVConstant>(FoundRHS))) {
9781 (isa<SCEVConstant>(FoundLHS) || isa<SCEVConstant>(FoundRHS))) {
9783 const SCEVConstant *C = nullptr;
9786 if (isa<SCEVConstant>(FoundLHS)) {
9787 C = cast<SCEVConstant>(FoundLHS);
9790 C = cast<SCEVConstant>(FoundRHS);
9898 if (isa<SCEVConstant>(Less) && isa<SCEVConstant>(More)) {
9898 if (isa<SCEVConstant>(Less) && isa<SCEVConstant>(More)) {
9899 const auto &M = cast<SCEVConstant>(More)->getAPInt();
9900 const auto &L = cast<SCEVConstant>(Less)->getAPInt();
9907 const SCEVConstant *C1 = nullptr, *C2 = nullptr;
9910 if ((C1 = dyn_cast<SCEVConstant>(LLess)))
9916 if ((C2 = dyn_cast<SCEVConstant>(LMore)))
10297 auto *Denominator = cast<SCEVConstant>(getSCEV(LR));
10450 if (!isa<SCEVConstant>(RHS) || !isa<SCEVConstant>(FoundRHS))
10450 if (!isa<SCEVConstant>(RHS) || !isa<SCEVConstant>(FoundRHS))
10459 const APInt &ConstFoundRHS = cast<SCEVConstant>(FoundRHS)->getAPInt();
10471 const APInt &ConstRHS = cast<SCEVConstant>(RHS)->getAPInt();
10702 if (isa<SCEVConstant>(BECount))
10704 else if (isa<SCEVConstant>(BECountIfBackedgeTaken)) {
10785 const SCEV *MaxBECount = isa<SCEVConstant>(BECount)
10802 if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(getStart()))
10802 if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(getStart()))
10817 if (any_of(operands(), [](const SCEV *Op) { return !isa<SCEVConstant>(Op); }))
10837 APInt A = cast<SCEVConstant>(getOperand(1))->getAPInt();
11064 if (!isa<SCEVConstant>(Op))
11088 remove_if(Terms, [](const SCEV *E) { return isa<SCEVConstant>(E); }),
11115 if (isa<SCEVConstant>(T))
11124 if (!isa<SCEVConstant>(Op))
11928 const SCEV *visitConstant(const SCEVConstant *Constant) {
11981 if ((VerifySCEVStrict || isa<SCEVConstant>(Delta)) && !Delta->isZero()) {
12313 if (const auto *Step = dyn_cast<SCEVConstant>(AR->getStepRecurrence(SE)))
12313 if (const auto *Step = dyn_cast<SCEVConstant>(AR->getStepRecurrence(SE)))
12536 if (Mul->getNumOperands() == 3 && isa<SCEVConstant>(Mul->getOperand(0)))
lib/Analysis/ScalarEvolutionExpander.cpp 257 if (const SCEVConstant *C = dyn_cast<SCEVConstant>(S)) {
257 if (const SCEVConstant *C = dyn_cast<SCEVConstant>(S)) {
262 if (const SCEVConstant *FC = dyn_cast<SCEVConstant>(Factor)) {
262 if (const SCEVConstant *FC = dyn_cast<SCEVConstant>(Factor)) {
283 const SCEVConstant *FC = cast<SCEVConstant>(Factor);
283 const SCEVConstant *FC = cast<SCEVConstant>(Factor);
284 if (const SCEVConstant *C = dyn_cast<SCEVConstant>(M->getOperand(0)))
284 if (const SCEVConstant *C = dyn_cast<SCEVConstant>(M->getOperand(0)))
472 if (const SCEVConstant *C = dyn_cast<SCEVConstant>(Ops[0]))
472 if (const SCEVConstant *C = dyn_cast<SCEVConstant>(Ops[0]))
624 if (isa<SCEVConstant>(S))
859 if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(S->getRHS())) {
859 if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(S->getRHS())) {
1823 if (const auto *SC = dyn_cast<SCEVConstant>(D->getRHS()))
1823 if (const auto *SC = dyn_cast<SCEVConstant>(D->getRHS()))
1976 auto *Const = dyn_cast<SCEVConstant>(SE.getSCEV(PN));
2164 if (auto *SC = dyn_cast<SCEVConstant>(UDivExpr->getRHS()))
2404 const SCEVConstant *SC = dyn_cast<SCEVConstant>(D->getRHS());
2404 const SCEVConstant *SC = dyn_cast<SCEVConstant>(D->getRHS());
lib/Analysis/TargetTransformInfo.cpp 74 if (const SCEVConstant *ConstEC = dyn_cast<SCEVConstant>(EC)) {
74 if (const SCEVConstant *ConstEC = dyn_cast<SCEVConstant>(EC)) {
lib/Analysis/VectorUtils.cpp 221 const APInt &APStepVal = cast<SCEVConstant>(M->getOperand(0))->getAPInt();
1012 const SCEVConstant *DistToB = dyn_cast<SCEVConstant>(
1012 const SCEVConstant *DistToB = dyn_cast<SCEVConstant>(
lib/Target/ARM/MVETailPredication.cpp 328 if (auto *Const = dyn_cast<SCEVConstant>(S->getOperand(0))) {
337 if (auto *Const = dyn_cast<SCEVConstant>(S->getOperand(0))) {
346 if (auto *Const = dyn_cast<SCEVConstant>(S->getRHS())) {
353 if (auto *Const = dyn_cast<SCEVConstant>(RoundUp->getOperand(0))) {
lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp 1785 if (auto *CV = dyn_cast<SCEVConstant>(CT))
1908 if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(S->getOperand(1)))
1908 if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(S->getOperand(1)))
1978 if (const SCEVConstant *BECst = dyn_cast<SCEVConstant>(BECount))
1978 if (const SCEVConstant *BECst = dyn_cast<SCEVConstant>(BECount))
lib/Target/PowerPC/PPCLoopPreIncPrep.cpp 70 BucketElement(const SCEVConstant *O, Instruction *I) : Offset(O), Instr(I) {}
73 const SCEVConstant *Offset;
119 const SCEVConstant *BasePtrIncSCEV);
225 if (const auto *CDiff = dyn_cast<SCEVConstant>(Diff)) {
225 if (const auto *CDiff = dyn_cast<SCEVConstant>(Diff)) {
315 E.Offset = cast<SCEVConstant>(SE->getMinusSCEV(E.Offset, Offset));
317 E.Offset = cast<SCEVConstant>(SE->getNegativeSCEV(Offset));
352 const SCEVConstant *BasePtrIncSCEV =
353 dyn_cast<SCEVConstant>(BasePtrSCEV->getStepRecurrence(*SE));
492 const SCEVConstant *BasePtrIncSCEV) {
519 const SCEVConstant *PHIBasePtrIncSCEV =
520 dyn_cast<SCEVConstant>(PHIBasePtrSCEV->getStepRecurrence(*SE));
585 if (const SCEVConstant *StepConst =
586 dyn_cast<SCEVConstant>(LARSCEV->getStepRecurrence(*SE))) {
lib/Transforms/Scalar/AlignmentFromAssumptions.cpp 101 if (const SCEVConstant *ConstDUSCEV =
102 dyn_cast<SCEVConstant>(DiffUnitsSCEV)) {
110 cast<SCEVConstant>(AlignSCEV)->getValue()->getSExtValue();
231 if (isa<SCEVConstant>(AndLHSSCEV)) {
236 const SCEVConstant *MaskSCEV = dyn_cast<SCEVConstant>(AndRHSSCEV);
236 const SCEVConstant *MaskSCEV = dyn_cast<SCEVConstant>(AndRHSSCEV);
lib/Transforms/Scalar/IndVarSimplify.cpp 669 !isa<SCEVConstant>(ExitValue) && !isa<SCEVUnknown>(ExitValue) &&
2231 const SCEV *Step = dyn_cast<SCEVConstant>(AR->getStepRecurrence(*SE));
2392 if (isa<SCEVConstant>(IVInit) && isa<SCEVConstant>(ExitCount))
2392 if (isa<SCEVConstant>(IVInit) && isa<SCEVConstant>(ExitCount))
lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp 849 if (!isa<SCEVConstant>(StepRec)) {
853 ConstantInt *StepCI = cast<SCEVConstant>(StepRec)->getValue();
1422 const SCEVConstant *MinusOneS =
1423 cast<SCEVConstant>(SE.getConstant(IVTy, -1, true /* isSigned */));
1599 const SCEVConstant *B = dyn_cast<SCEVConstant>(
1599 const SCEVConstant *B = dyn_cast<SCEVConstant>(
1606 const SCEVConstant *D = dyn_cast<SCEVConstant>(getStep());
1606 const SCEVConstant *D = dyn_cast<SCEVConstant>(getStep());
lib/Transforms/Scalar/LoopDataPrefetch.cpp 146 const auto *ConstStride = dyn_cast<SCEVConstant>(AR->getStepRecurrence(*SE));
146 const auto *ConstStride = dyn_cast<SCEVConstant>(AR->getStepRecurrence(*SE));
288 if (const SCEVConstant *ConstPtrDiff =
289 dyn_cast<SCEVConstant>(PtrDiff)) {
lib/Transforms/Scalar/LoopIdiomRecognize.cpp 390 if (const SCEVConstant *BECst = dyn_cast<SCEVConstant>(BECount))
390 if (const SCEVConstant *BECst = dyn_cast<SCEVConstant>(BECount))
423 const SCEVConstant *ConstStride = cast<SCEVConstant>(StoreEv->getOperand(1));
423 const SCEVConstant *ConstStride = cast<SCEVConstant>(StoreEv->getOperand(1));
506 if (!isa<SCEVConstant>(StoreEv->getOperand(1)))
832 const SCEVConstant *ConstStride = dyn_cast<SCEVConstant>(Ev->getOperand(1));
832 const SCEVConstant *ConstStride = dyn_cast<SCEVConstant>(Ev->getOperand(1));
869 if (const SCEVConstant *BECst = dyn_cast<SCEVConstant>(BECount))
869 if (const SCEVConstant *BECst = dyn_cast<SCEVConstant>(BECount))
2056 RecStepForA != RecStepForB || !isa<SCEVConstant>(RecStepForA) ||
2057 cast<SCEVConstant>(RecStepForA)->getAPInt() != BCmpTyBytes) {
lib/Transforms/Scalar/LoopInterchange.cpp 136 const SCEVConstant *SCEVConst =
137 dyn_cast_or_null<SCEVConstant>(Distance);
312 if (!isa<SCEVConstant>(Step))
lib/Transforms/Scalar/LoopLoadElimination.cpp 124 auto *Dist = cast<SCEVConstant>(
lib/Transforms/Scalar/LoopPredication.cpp 437 auto *Limit = dyn_cast<SCEVConstant>(LatchCheck.Limit);
438 auto *Start = dyn_cast<SCEVConstant>(LatchCheck.IV->getStart());
lib/Transforms/Scalar/LoopRerollPass.cpp 588 auto IncSCEV = dyn_cast<SCEVConstant>(PHISCEV->getStepRecurrence(*SE));
lib/Transforms/Scalar/LoopStrengthReduce.cpp 666 const SCEVConstant *RC = dyn_cast<SCEVConstant>(RHS);
666 const SCEVConstant *RC = dyn_cast<SCEVConstant>(RHS);
679 if (const SCEVConstant *C = dyn_cast<SCEVConstant>(LHS)) {
679 if (const SCEVConstant *C = dyn_cast<SCEVConstant>(LHS)) {
746 if (const SCEVConstant *C = dyn_cast<SCEVConstant>(S)) {
746 if (const SCEVConstant *C = dyn_cast<SCEVConstant>(S)) {
936 if (isa<SCEVConstant>(Mul->getOperand(0)))
1216 if (isa<SCEVUnknown>(Reg) || isa<SCEVConstant>(Reg))
1266 if (auto *Step = dyn_cast<SCEVConstant>(AR->getStepRecurrence(*SE)))
1273 if (isa<SCEVConstant>(LoopStep)) {
1275 if (!isa<SCEVConstant>(LoopStart) &&
1285 if (!AR->isAffine() || !isa<SCEVConstant>(AR->getOperand(1))) {
2439 if (const SCEVConstant *D =
2440 dyn_cast_or_null<SCEVConstant>(getExactSDiv(B, A, SE))) {
2692 if (const SCEVConstant *Factor =
2693 dyn_cast_or_null<SCEVConstant>(getExactSDiv(NewStride, OldStride,
2697 } else if (const SCEVConstant *Factor =
2698 dyn_cast_or_null<SCEVConstant>(getExactSDiv(OldStride,
2812 if (!isa<SCEVConstant>(IncExpr)) {
2814 if (isa<SCEVConstant>(SE.getMinusSCEV(OperExpr, HeadExpr)))
2869 if (isa<SCEVConstant>(Inc.IncExpr)) {
3120 const SCEVConstant *IncConst = dyn_cast<SCEVConstant>(IncExpr);
3120 const SCEVConstant *IncConst = dyn_cast<SCEVConstant>(IncExpr);
3485 static const SCEV *CollectSubexprs(const SCEV *S, const SCEVConstant *C,
3528 if (const SCEVConstant *Op0 =
3529 dyn_cast<SCEVConstant>(Mul->getOperand(0))) {
3530 C = C ? cast<SCEVConstant>(SE.getMulExpr(C, Op0)) : Op0;
3553 if (!isa<SCEVConstant>(LoopStep))
3562 if (!isa<SCEVConstant>(LoopStart) && SE.isLoopInvariant(LoopStart, L))
3621 const SCEVConstant *InnerSumSC = dyn_cast<SCEVConstant>(InnerSum);
3621 const SCEVConstant *InnerSumSC = dyn_cast<SCEVConstant>(InnerSum);
3637 const SCEVConstant *SC = dyn_cast<SCEVConstant>(*J);
3637 const SCEVConstant *SC = dyn_cast<SCEVConstant>(*J);
3816 dyn_cast<SCEVConstant>(GAR->getStepRecurrence(SE))) {
4144 if (!isa<SCEVConstant>(OrigReg) &&
4219 if (const SCEVConstant *C = dyn_cast<SCEVConstant>(NewF.ScaledReg))
4219 if (const SCEVConstant *C = dyn_cast<SCEVConstant>(NewF.ScaledReg))
4252 if (const SCEVConstant *C = dyn_cast<SCEVConstant>(NewReg))
4252 if (const SCEVConstant *C = dyn_cast<SCEVConstant>(NewReg))
4447 if (const SCEVConstant *C = dyn_cast<SCEVConstant>(*I)) {
4447 if (const SCEVConstant *C = dyn_cast<SCEVConstant>(*I)) {
lib/Transforms/Utils/SimplifyIndVar.cpp 224 if (auto *ConstLHS = dyn_cast<SCEVConstant>(InvariantLHS))
227 if (auto *ConstRHS = dyn_cast<SCEVConstant>(InvariantRHS))
lib/Transforms/Vectorize/SLPVectorizer.cpp 2447 const auto *Diff =
2448 dyn_cast<SCEVConstant>(SE->getMinusSCEV(ScevN, Scev0));
7069 if (isa<SCEVConstant>(SE->getMinusSCEV(SCEVI, SCEVJ))) {
tools/polly/include/polly/Support/SCEVAffinator.h 97 PWACtx visitConstant(const llvm::SCEVConstant *E);
tools/polly/include/polly/Support/SCEVValidator.h 86 std::pair<const llvm::SCEVConstant *, const llvm::SCEV *>
tools/polly/lib/Analysis/ScopBuilder.cpp 1714 cast<SCEVConstant>(Sizes.back())->getAPInt().getSExtValue();
2963 if (!isa<SCEVConstant>(MA->getSubscript(u)))
tools/polly/lib/Analysis/ScopDetection.cpp 502 if (isa<SCEVConstant>(PtrSCEV))
878 if (auto *Const = dyn_cast<SCEVConstant>(MulOp))
1345 if (auto *TripCountC = dyn_cast<SCEVConstant>(TripCount))
tools/polly/lib/Analysis/ScopInfo.cpp 425 auto *DimSizeCst = dyn_cast<SCEVConstant>(DimSize);
773 if (Sizes.size() < 2 || isa<SCEVConstant>(Sizes[1]))
tools/polly/lib/Support/SCEVAffinator.cpp 241 PWACtx SCEVAffinator::visitConstant(const SCEVConstant *Expr) {
tools/polly/lib/Support/SCEVValidator.cpp 145 class ValidatorResult visitConstant(const SCEVConstant *Constant) {
380 if (isa<SCEVConstant>(Divisor) && !Divisor->isZero())
598 if (!isa<SCEVConstant>(Dividend))
712 std::pair<const SCEVConstant *, const SCEV *>
714 auto *ConstPart = cast<SCEVConstant>(SE.getConstant(S->getType(), 1));
716 if (auto *Constant = dyn_cast<SCEVConstant>(S))
737 Factor = cast<SCEVConstant>(SE.getNegativeSCEV(Factor));
764 if (isa<SCEVConstant>(Op))
765 ConstPart = cast<SCEVConstant>(SE.getMulExpr(ConstPart, Op));
tools/polly/lib/Support/ScopHelper.cpp 333 const SCEV *visitConstant(const SCEVConstant *E) { return E; }
684 if (auto *Const = dyn_cast<SCEVConstant>(Expr))