Lines Matching defs:SE
173 ScalarEvolution *SE = PSE.getSE();
174 const auto *CT = SE->getOne(StrideSCEV->getType());
175 PSE.addPredicate(*SE->getEqualPredicate(StrideSCEV, CT));
211 ScalarEvolution *SE = PSE.getSE();
215 {SE->getCouldNotCompute(), SE->getCouldNotCompute()}});
222 if (SE->isLoopInvariant(PtrExpr, Lp)) {
228 ScEnd = AR->evaluateAtIteration(Ex, *SE);
229 const SCEV *Step = AR->getStepRecurrence(*SE);
240 ScStart = SE->getUMinExpr(ScStart, ScEnd);
241 ScEnd = SE->getUMaxExpr(AR->getStart(), ScEnd);
244 return {SE->getCouldNotCompute(), SE->getCouldNotCompute()};
246 assert(SE->isLoopInvariant(ScStart, Lp) && "ScStart needs to be invariant");
247 assert(SE->isLoopInvariant(ScEnd, Lp)&& "ScEnd needs to be invariant");
252 const SCEV *EltSizeSCEV = SE->getStoreSizeOfExpr(IdxTy, AccessTy);
253 ScEnd = SE->getAddExpr(ScEnd, EltSizeSCEV);
328 auto *Step = dyn_cast<SCEVConstant>(SinkAR->getStepRecurrence(*SE));
329 if (!Step || Step != SrcAR->getStepRecurrence(*SE) ||
341 const SCEV *SinkStartInt = SE->getPtrToIntExpr(SinkAR->getStart(), IntTy);
342 const SCEV *SrcStartInt = SE->getPtrToIntExpr(SrcAR->getStart(), IntTy);
362 SrcStartAR->getStepRecurrence(*SE) !=
363 SinkStartAR->getStepRecurrence(*SE)) {
414 ScalarEvolution *SE) {
415 const SCEV *Diff = SE->getMinusSCEV(J, I);
428 RtCheck.Pointers[Index].NeedsFreeze, *RtCheck.SE);
434 ScalarEvolution &SE) {
441 const SCEV *Min0 = getMinFromExprs(Start, Low, &SE);
445 const SCEV *Min1 = getMinFromExprs(End, High, &SE);
706 bool canCheckPtrAtRT(RuntimePointerChecking &RtCheck, ScalarEvolution *SE,
888 ScalarEvolution *SE, const Loop *L, Value *Ptr,
895 const SCEV *Scev = SE->getSCEV(Ptr);
908 auto GetBinOpExpr = [&SE](unsigned Opcode, const SCEV *L, const SCEV *R) {
911 return SE->getAddExpr(L, R);
913 return SE->getMinusSCEV(L, R);
933 findForkedSCEVs(SE, L, I->getOperand(0), BaseScevs, Depth);
934 findForkedSCEVs(SE, L, I->getOperand(1), OffsetScevs, Depth);
953 Type *IntPtrTy = SE->getEffectiveSCEVType(
954 SE->getSCEV(GEP->getPointerOperand())->getType());
959 const SCEV *Size = SE->getSizeOfExpr(IntPtrTy, SourceTy);
962 const SCEV *Scaled1 = SE->getMulExpr(
963 Size, SE->getTruncateOrSignExtend(get<0>(OffsetScevs[0]), IntPtrTy));
964 const SCEV *Scaled2 = SE->getMulExpr(
965 Size, SE->getTruncateOrSignExtend(get<0>(OffsetScevs[1]), IntPtrTy));
966 ScevList.emplace_back(SE->getAddExpr(get<0>(BaseScevs[0]), Scaled1),
968 ScevList.emplace_back(SE->getAddExpr(get<0>(BaseScevs[1]), Scaled2),
977 findForkedSCEVs(SE, L, I->getOperand(1), ChildScevs, Depth);
978 findForkedSCEVs(SE, L, I->getOperand(2), ChildScevs, Depth);
992 findForkedSCEVs(SE, L, I->getOperand(0), ChildScevs, Depth);
993 findForkedSCEVs(SE, L, I->getOperand(1), ChildScevs, Depth);
1006 findForkedSCEVs(SE, L, I->getOperand(0), LScevs, Depth);
1007 findForkedSCEVs(SE, L, I->getOperand(1), RScevs, Depth);
1045 ScalarEvolution *SE = PSE.getSE();
1046 assert(SE->isSCEVable(Ptr->getType()) && "Value is not SCEVable!");
1048 findForkedSCEVs(SE, L, Ptr, Scevs, MaxForkedSCEVDepth);
1054 SE->isLoopInvariant(get<0>(Scevs[0]), L)) &&
1056 SE->isLoopInvariant(get<0>(Scevs[1]), L))) {
1128 ScalarEvolution *SE, Loop *TheLoop,
1560 ScalarEvolution &SE, bool StrictCheck,
1602 const SCEV *PtrSCEVA = SE.getSCEV(PtrA);
1603 const SCEV *PtrSCEVB = SE.getSCEV(PtrB);
1605 dyn_cast<SCEVConstant>(SE.getMinusSCEV(PtrSCEVB, PtrSCEVA));
1621 const DataLayout &DL, ScalarEvolution &SE,
1636 std::optional<int> Diff = getPointersDiff(ElemTy, Ptr0, ElemTy, Ptr, DL, SE,
1661 ScalarEvolution &SE, bool CheckType) {
1669 getPointersDiff(ElemTyA, PtrA, ElemTyB, PtrB, DL, SE,
1810 static bool isSafeDependenceDistance(const DataLayout &DL, ScalarEvolution &SE,
1833 const SCEV *Step = SE.getConstant(MaxBTC.getType(), ByteStride);
1834 const SCEV *Product = SE.getMulExpr(&MaxBTC, Step);
1845 CastedProduct = SE.getZeroExtendExpr(Product, Dist.getType());
1847 CastedDist = SE.getNoopOrSignExtend(&Dist, Product->getType());
1851 const SCEV *Minus = SE.getMinusSCEV(CastedDist, CastedProduct);
1852 if (SE.isKnownPositive(Minus))
1857 const SCEV *NegDist = SE.getNegativeSCEV(CastedDist);
1858 Minus = SE.getMinusSCEV(NegDist, CastedProduct);
1859 return SE.isKnownPositive(Minus);
1904 auto &SE = *PSE.getSE();
1937 const SCEV *Dist = SE.getMinusSCEV(Sink, Src);
1948 if (SE.isLoopInvariant(Src, InnermostLoop) ||
1949 SE.isLoopInvariant(Sink, InnermostLoop)) {
1958 if (SE.isKnownPredicate(CmpInst::ICMP_ULE, SrcEnd, SinkStart))
1960 if (SE.isKnownPredicate(CmpInst::ICMP_ULE, SinkEnd, SrcStart))
2031 ScalarEvolution &SE = *PSE.getSE();
2041 DL, SE, *(PSE.getSymbolicMaxBackedgeTakenCount()),
2062 Dist = SE.applyLoopGuards(Dist, InnermostLoop);
2065 if (SE.isKnownNonPositive(Dist)) {
2066 if (SE.isKnownNonNegative(Dist)) {
2107 int64_t MinDistance = SE.getSignedRangeMin(Dist).getSExtValue();
2658 auto *SE = PSE->getSE();
2661 *PtrRtChecking, SE, TheLoop, SymbolicStrides, UncomputablePtr, true);
2794 auto *SE = PSE->getSE();
2797 if (!SE->isSCEVable(V->getType()))
2799 const SCEV *S = SE->getSCEV(V);
2800 return SE->isLoopInvariant(S, TheLoop);
2833 static Value *stripGetElementPtr(Value *Ptr, ScalarEvolution *SE, Loop *Lp) {
2844 !SE->isLoopInvariant(SE->getSCEV(GEP->getOperand(I)), Lp))
2851 static const SCEV *getStrideFromPointer(Value *Ptr, ScalarEvolution *SE, Loop *Lp) {
2864 Ptr = stripGetElementPtr(Ptr, SE, Lp);
2865 const SCEV *V = SE->getSCEV(Ptr);
2881 V = S->getStepRecurrence(*SE);
2907 if (!SE->isLoopInvariant(V, Lp))
2968 ScalarEvolution *SE = PSE->getSE();
2970 CastedStride = SE->getNoopOrSignExtend(StrideExpr, MaxBTC->getType());
2972 CastedBECount = SE->getZeroExtendExpr(MaxBTC, StrideExpr->getType());
2973 const SCEV *StrideMinusBETaken = SE->getMinusSCEV(CastedStride, CastedBECount);
2977 if (SE->isKnownPositive(StrideMinusBETaken)) {
2994 LoopAccessInfo::LoopAccessInfo(Loop *L, ScalarEvolution *SE,
2998 : PSE(std::make_unique<PredicatedScalarEvolution>(*SE, *L)),
3017 PtrRtChecking = std::make_unique<RuntimePointerChecking>(*DepChecker, SE);
3075 std::make_unique<LoopAccessInfo>(&L, &SE, TTI, TLI, &AA, &DT, &LI);
3116 auto &SE = FAM.getResult<ScalarEvolutionAnalysis>(F);
3122 return LoopAccessInfoManager(SE, AA, DT, LI, &TTI, &TLI);