Lines Matching full:pse

154 const SCEV *llvm::replaceSymbolicStrideSCEV(PredicatedScalarEvolution &PSE,
157   const SCEV *OrigSCEV = PSE.getSCEV(Ptr);
173   ScalarEvolution *SE = PSE.getSE();
175   PSE.addPredicate(*SE->getEqualPredicate(StrideSCEV, CT));
176   auto *Expr = PSE.getSCEV(Ptr);
208     PredicatedScalarEvolution &PSE,
211   ScalarEvolution *SE = PSE.getSE();
225     const SCEV *Ex = PSE.getSymbolicMaxBackedgeTakenCount();
264                                     PredicatedScalarEvolution &PSE,
267       Lp, PtrExpr, AccessTy, PSE, DC.getPointerBounds());
663                  PredicatedScalarEvolution &PSE,
665       : TheLoop(TheLoop), BAA(*AA), AST(BAA), LI(LI), DepCands(DA), PSE(PSE),
801   PredicatedScalarEvolution &PSE;
815 static bool hasComputableBounds(PredicatedScalarEvolution &PSE, Value *Ptr,
818   if (PSE.getSE()->isLoopInvariant(PtrScev, L))
824     AR = PSE.getAsAddRec(Ptr);
833 static bool isNoWrap(PredicatedScalarEvolution &PSE,
836   const SCEV *PtrScev = PSE.getSCEV(Ptr);
837   if (PSE.getSE()->isLoopInvariant(PtrScev, L))
840   int64_t Stride = getPtrStride(PSE, AccessTy, Ptr, L, Strides).value_or(0);
841   if (Stride == 1 || PSE.hasNoOverflow(Ptr, SCEVWrapPredicate::IncrementNUSW))
1042 findForkedPointer(PredicatedScalarEvolution &PSE,
1045   ScalarEvolution *SE = PSE.getSE();
1063   return {{replaceSymbolicStrideSCEV(PSE, StridesMap, Ptr), false}};
1076       findForkedPointer(PSE, StridesMap, Ptr, TheLoop);
1080     if (!hasComputableBounds(PSE, Ptr, PtrExpr, TheLoop, Assume))
1090       if (!isNoWrap(PSE, StridesMap, Ptr, AccessTy, TheLoop)) {
1091         auto *Expr = PSE.getSCEV(Ptr);
1094         PSE.setNoOverflow(Ptr, SCEVWrapPredicate::IncrementNUSW);
1098     // checking, because assumptions might have been added to PSE.
1100       TranslatedPtrs[0] = {replaceSymbolicStrideSCEV(PSE, StridesMap, Ptr),
1119     RtCheck.insert(TheLoop, Ptr, PtrExpr, AccessTy, IsWrite, DepId, ASId, PSE,
1407                            PredicatedScalarEvolution &PSE, const Loop *L) {
1413   if (PSE.hasNoOverflow(Ptr, SCEVWrapPredicate::IncrementNUSW))
1447       auto *OpScev = PSE.getSCEV(OBO->getOperand(0));
1458 llvm::getPtrStride(PredicatedScalarEvolution &PSE, Type *AccessTy, Value *Ptr,
1462   const SCEV *PtrScev = replaceSymbolicStrideSCEV(PSE, StridesMap, Ptr);
1463   if (PSE.getSE()->isLoopInvariant(PtrScev, Lp))
1476     AR = PSE.getAsAddRec(Ptr);
1492   const SCEV *Step = AR->getStepRecurrence(*PSE.getSE());
1524   if (isNoWrapAddRec(Ptr, AR, PSE, Lp))
1544     PSE.setNoOverflow(Ptr, SCEVWrapPredicate::IncrementNUSW);
1904   auto &SE = *PSE.getSE();
1921       getPtrStride(PSE, ATy, APtr, InnermostLoop, SymbolicStrides, true, true);
1923       getPtrStride(PSE, BTy, BPtr, InnermostLoop, SymbolicStrides, true, true);
1925   const SCEV *Src = PSE.getSCEV(APtr);
1926   const SCEV *Sink = PSE.getSCEV(BPtr);
1951         getStartAndEndForAccess(InnermostLoop, Src, ATy, PSE, PointerBounds);
1953         getStartAndEndForAccess(InnermostLoop, Sink, BTy, PSE, PointerBounds);
2031   ScalarEvolution &SE = *PSE.getSE();
2041                          DL, SE, *(PSE.getSymbolicMaxBackedgeTakenCount()),
2378   const SCEV *ExitCount = PSE->getSymbolicMaxBackedgeTakenCount();
2522   AccessAnalysis Accesses(TheLoop, AA, LI, DependentAccesses, *PSE,
2587         !getPtrStride(*PSE, LD->getType(), Ptr, TheLoop, SymbolicStrides).value_or(0)) {
2629       Accesses.canCheckPtrAtRT(*PtrRtChecking, PSE->getSE(), TheLoop,
2658       auto *SE = PSE->getSE();
2794   auto *SE = PSE->getSE();
2932   const SCEV *StrideExpr = getStrideFromPointer(Ptr, PSE->getSE(), TheLoop);
2958   const SCEV *MaxBTC = PSE->getSymbolicMaxBackedgeTakenCount();
2968   ScalarEvolution *SE = PSE->getSE();
2998     : PSE(std::make_unique<PredicatedScalarEvolution>(*SE, *L)),
3015   DepChecker = std::make_unique<MemoryDepChecker>(*PSE, L, SymbolicStrides,
3062   PSE->getPredicate().print(OS, Depth);
3067   PSE->print(OS, Depth);