Lines Matching defs:Start
925 const SCEV *Start = AR->getStart();
933 return getAddRecExpr(getZeroExtendExpr(Start, Ty),
953 getTruncateOrZeroExtend(MaxBECount, Start->getType());
958 // Check whether Start+Step*MaxBECount has no unsigned overflow.
960 const SCEV *Add = getAddExpr(Start, ZMul);
962 getAddExpr(getZeroExtendExpr(Start, WideTy),
969 return getAddRecExpr(getZeroExtendExpr(Start, Ty),
976 Add = getAddExpr(Start, SMul);
978 getAddExpr(getZeroExtendExpr(Start, WideTy),
986 return getAddRecExpr(getZeroExtendExpr(Start, Ty),
994 // with the start value and the backedge is guarded by a comparison
1000 (isLoopEntryGuardedByCond(L, ICmpInst::ICMP_ULT, Start, N) &&
1006 return getAddRecExpr(getZeroExtendExpr(Start, Ty),
1014 (isLoopEntryGuardedByCond(L, ICmpInst::ICMP_UGT, Start, N) &&
1021 return getAddRecExpr(getZeroExtendExpr(Start, Ty),
1061 // such: {sext(Step + Start),+,Step} => {(Step + sext(Start),+,Step} As a
1068 const SCEV *Start = AR->getStart();
1072 const SCEVAddExpr *SA = dyn_cast<SCEVAddExpr>(Start);
1105 if (SE->getSignExtendExpr(Start, WideTy) == OperandExtendedStart) {
1125 // Get the normalized sign-extended expression for this AddRec's Start.
1191 const SCEV *Start = AR->getStart();
1219 getTruncateOrZeroExtend(MaxBECount, Start->getType());
1224 // Check whether Start+Step*MaxBECount has no signed overflow.
1226 const SCEV *Add = getAddExpr(Start, SMul);
1228 getAddExpr(getSignExtendExpr(Start, WideTy),
1242 Add = getAddExpr(Start, UMul);
1244 getAddExpr(getSignExtendExpr(Start, WideTy),
1259 // with the start value and the backedge is guarded by a comparison
1265 (isLoopEntryGuardedByCond(L, Pred, Start, OverflowLimit) &&
1734 // NLI + LI + {Start,+,Step} --> NLI + {LI+Start,+,Step}
1989 // NLI * LI * {Start,+,Step} --> NLI * {LI*Start,+,LI*Step}
2227 const SCEV *ScalarEvolution::getAddRecExpr(const SCEV *Start, const SCEV *Step,
2231 Operands.push_back(Start);
3085 // If StartVal = j.start - j.stride, we can use StartVal as the
3348 const SCEV *Start = AddRec->getStart();
3351 ConstantRange StartRange = getUnsignedRange(Start);
3500 const SCEV *Start = AddRec->getStart();
3503 ConstantRange StartRange = getSignedRange(Start);
5296 // Start + Step*N = 0 (mod 2^BW)
5300 // Step*N = -Start (mod 2^BW)
5302 // where BW is the common bit width of Start and Step.
5305 const SCEV *Start = getSCEVAtScope(AddRec->getStart(), L->getParentLoop());
5312 // to 0, it must be counting down to equal 0. Consequently, N = Start / -Step.
5319 // N = -Start/Step (as unsigned)
5321 // N = Start/-Step
5324 const SCEV *Distance = CountDown ? Start : getNegativeSCEV(Start);
5327 // 1*N = -Start; -1*N = Start (mod 2^BW), so:
5330 ConstantRange CR = getUnsignedRange(Start);
5357 // Then, try to solve the above equation provided that Start is constant.
5358 if (const SCEVConstant *StartC = dyn_cast<SCEVConstant>(Start))
6037 /// getBECount - Subtract the end and start values and divide by the step,
6040 const SCEV *ScalarEvolution::getBECount(const SCEV *Start,
6047 Start->getType();
6049 // When Start == End, we have an exact BECount == 0. Short-circuit this case
6052 if (Start == End)
6056 const SCEV *Diff = getMinusSCEV(End, Start);
6059 // Add an adjustment to the difference between End and Start so that
6133 const SCEV *Start = AddRec->getOperand(0);
6135 // Determine the minimum constant start value.
6137 getSignedRange(Start).getSignedMin() :
6138 getUnsignedRange(Start).getUnsignedMin());
6148 getMinusSCEV(Start, Step), RHS))
6149 End = isSigned ? getSMaxExpr(RHS, Start)
6150 : getUMaxExpr(RHS, Start);
6173 const SCEV *BECount = getBECount(Start, End, Step, NoWrap);
6175 // The maximum backedge count is similar, except using the minimum start
6204 // If the start is a non-zero constant, shift the range to simplify things.
6227 // that the start element is zero.
