Lines Matching refs:SE
129 SE = &getAnalysis<ScalarEvolution>();
333 return SE->getNegativeSCEV(C);
370 A = SE->getConstant(D->getType(), 1);
371 B = SE->getNegativeSCEV(A);
372 C = SE->getNegativeSCEV(D);
383 SE = NewSE;
463 const SCEV *Prod1 = SE->getMulExpr(X->getA(), Y->getB());
464 const SCEV *Prod2 = SE->getMulExpr(X->getB(), Y->getA());
468 Prod1 = SE->getMulExpr(X->getC(), Y->getB());
469 Prod2 = SE->getMulExpr(X->getB(), Y->getC());
482 const SCEV *C1B2 = SE->getMulExpr(X->getC(), Y->getB());
483 const SCEV *C1A2 = SE->getMulExpr(X->getC(), Y->getA());
484 const SCEV *C2B1 = SE->getMulExpr(Y->getC(), X->getB());
485 const SCEV *C2A1 = SE->getMulExpr(Y->getC(), X->getA());
486 const SCEV *A1B2 = SE->getMulExpr(X->getA(), Y->getB());
487 const SCEV *A2B1 = SE->getMulExpr(Y->getA(), X->getB());
489 dyn_cast<SCEVConstant>(SE->getMinusSCEV(C1A2, C2A1));
491 dyn_cast<SCEVConstant>(SE->getMinusSCEV(C1B2, C2B1));
493 dyn_cast<SCEVConstant>(SE->getMinusSCEV(A1B2, A2B1));
495 dyn_cast<SCEVConstant>(SE->getMinusSCEV(A2B1, A1B2));
534 X->setPoint(SE->getConstant(Xq),
535 SE->getConstant(Yq),
548 const SCEV *A1X1 = SE->getMulExpr(Y->getA(), X->getX());
549 const SCEV *B1Y1 = SE->getMulExpr(Y->getB(), X->getY());
550 const SCEV *Sum = SE->getAddExpr(A1X1, B1Y1);
761 return SE->isLoopInvariant(Expression, LoopNest) &&
774 if (Level <= CommonLevels && !SE->isLoopInvariant(Expression, LoopNest))
809 const SCEV *Step = AddRec->getStepRecurrence(*SE);
827 const SCEV *Step = AddRec->getStepRecurrence(*SE);
892 if (SE->isKnownPredicate(Pred, X, Y))
894 // If SE->isKnownPredicate can't prove the condition,
897 // By testing with SE->isKnownPredicate first, we avoid
899 const SCEV *Delta = SE->getMinusSCEV(X, Y);
904 return SE->isKnownNonZero(Delta);
906 return SE->isKnownNonNegative(Delta);
908 return SE->isKnownNonPositive(Delta);
910 return SE->isKnownPositive(Delta);
912 return SE->isKnownNegative(Delta);
926 if (SE->hasLoopInvariantBackedgeTakenCount(L)) {
927 const SCEV *UB = SE->getBackedgeTakenCount(L);
928 return SE->getNoopOrZeroExtend(UB, T);
1021 const SCEV *Delta = SE->getMinusSCEV(SrcConst, DstConst);
1030 SE->isKnownNonNegative(Delta) ? Delta : SE->getNegativeSCEV(Delta);
1032 SE->isKnownNonNegative(Coeff) ? Coeff : SE->getNegativeSCEV(Coeff);
1033 const SCEV *Product = SE->getMulExpr(UpperBound, AbsCoeff);
1058 Result.DV[Level].Distance = SE->getConstant(Distance);
1059 NewConstraint.setDistance(SE->getConstant(Distance), CurLoop);
1084 SE->getNegativeSCEV(Coeff),
1085 SE->getNegativeSCEV(Delta), CurLoop);
1089 bool DeltaMaybeZero = !SE->isKnownNonZero(Delta);
1090 bool DeltaMaybePositive = !SE->isKnownNonPositive(Delta);
1091 bool DeltaMaybeNegative = !SE->isKnownNonNegative(Delta);
1092 bool CoeffMaybePositive = !SE->isKnownNonPositive(Coeff);
1093 bool CoeffMaybeNegative = !SE->isKnownNonNegative(Coeff);
1095 // It helps to read !SE->isKnownNonZero(Delta)
1158 const SCEV *Delta = SE->getMinusSCEV(DstConst, SrcConst);
1177 if (SE->isKnownNegative(ConstCoeff)) {
1178 ConstCoeff = dyn_cast<SCEVConstant>(SE->getNegativeSCEV(ConstCoeff));
1181 Delta = SE->getNegativeSCEV(Delta);
1183 assert(SE->isKnownPositive(ConstCoeff) && "ConstCoeff should be positive");
1187 SE->getUDivExpr(SE->getSMaxExpr(SE->getConstant(Delta->getType(), 0),
1189 SE->getMulExpr(SE->getConstant(Delta->getType(), 2),
1201 if (SE->isKnownNegative(Delta)) {
1212 const SCEV *ConstantTwo = SE->getConstant(UpperBound->getType(), 2);
1213 const SCEV *ML = SE->getMulExpr(SE->getMulExpr(ConstCoeff, UpperBound),
1232 Result.DV[Level].Distance = SE->getConstant(Delta->getType(), 0);
1381 const SCEV *Delta = SE->getMinusSCEV(DstConst, SrcConst);
1383 NewConstraint.setLine(SrcCoeff, SE->getNegativeSCEV(DstCoeff),
1594 const SCEV *Delta = SE->getMinusSCEV(SrcConst, DstConst);
1595 NewConstraint.setLine(SE->getConstant(Delta->getType(), 0),
1610 SE->isKnownNegative(ConstCoeff) ?
1611 SE->getNegativeSCEV(ConstCoeff) : ConstCoeff;
1613 SE->isKnownNegative(ConstCoeff) ? SE->getNegativeSCEV(Delta) : Delta;
1619 const SCEV *Product = SE->getMulExpr(AbsCoeff, UpperBound);
1638 if (SE->isKnownNegative(NewDelta)) {
1704 const SCEV *Delta = SE->getMinusSCEV(DstConst, SrcConst);
1705 NewConstraint.setLine(SrcCoeff, SE->getConstant(Delta->getType(), 0),
1720 SE->isKnownNegative(ConstCoeff) ?
1721 SE->getNegativeSCEV(ConstCoeff) : ConstCoeff;
1723 SE->isKnownNegative(ConstCoeff) ? SE->getNegativeSCEV(Delta) : Delta;
1729 const SCEV *Product = SE->getMulExpr(AbsCoeff, UpperBound);
1748 if (SE->isKnownNegative(NewDelta)) {
1787 const SCEV *Delta = SE->getMinusSCEV(DstConst, SrcConst);
1934 const SCEV *C2_C1 = SE->getMinusSCEV(C2, C1);
1935 const SCEV *C1_C2 = SE->getMinusSCEV(C1, C2);
1938 if (SE->isKnownNonNegative(A1)) {
1939 if (SE->isKnownNonNegative(A2)) {
1943 const SCEV *A1N1 = SE->getMulExpr(A1, N1);
1952 const SCEV *A2N2 = SE->getMulExpr(A2, N2);
1960 else if (SE->isKnownNonPositive(A2)) {
1964 const SCEV *A1N1 = SE->getMulExpr(A1, N1);
1965 const SCEV *A2N2 = SE->getMulExpr(A2, N2);
1966 const SCEV *A1N1_A2N2 = SE->getMinusSCEV(A1N1, A2N2);
1974 if (SE->isKnownNegative(C2_C1)) {
1980 else if (SE->isKnownNonPositive(A1)) {
1981 if (SE->isKnownNonNegative(A2)) {
1985 const SCEV *A1N1 = SE->getMulExpr(A1, N1);
1986 const SCEV *A2N2 = SE->getMulExpr(A2, N2);
1987 const SCEV *A1N1_A2N2 = SE->getMinusSCEV(A1N1, A2N2);
1995 if (SE->isKnownPositive(C2_C1)) {
2000 else if (SE->isKnownNonPositive(A2)) {
2004 const SCEV *A1N1 = SE->getMulExpr(A1, N1);
2013 const SCEV *A2N2 = SE->getMulExpr(A2, N2);
2047 const SCEV *SrcCoeff = SrcAddRec->getStepRecurrence(*SE);
2048 const SCEV *DstCoeff = DstAddRec->getStepRecurrence(*SE);
2057 else if (SrcCoeff == SE->getNegativeSCEV(DstCoeff))
2069 const SCEV *SrcCoeff = SrcAddRec->getStepRecurrence(*SE);
2079 const SCEV *DstCoeff = DstAddRec->getStepRecurrence(*SE);
2124 SrcCoeff = SrcAddRec->getStepRecurrence(*SE);
2127 DstCoeff = DstAddRec->getStepRecurrence(*SE);
2134 SrcCoeff = tmpAddRec->getStepRecurrence(*SE);
2137 DstCoeff = SE->getNegativeSCEV(SrcAddRec->getStepRecurrence(*SE));
2147 DstCoeff = tmpAddRec->getStepRecurrence(*SE);
2150 SrcCoeff = SE->getNegativeSCEV(DstAddRec->getStepRecurrence(*SE));
2219 unsigned BitWidth = SE->getTypeSizeInBits(Src->getType());
2229 const SCEV *Coeff = AddRec->getStepRecurrence(*SE);
2250 const SCEV *Coeff = AddRec->getStepRecurrence(*SE);
2265 const SCEV *Delta = SE->getMinusSCEV(DstConst, SrcConst);
2325 const SCEV *SrcCoeff = AddRec->getStepRecurrence(*SE);
2326 const SCEV *DstCoeff = SE->getMinusSCEV(SrcCoeff, SrcCoeff);
2330 const SCEV *Coeff = AddRec->getStepRecurrence(*SE);
2348 const SCEV *Coeff = AddRec->getStepRecurrence(*SE);
2363 Delta = SE->getMinusSCEV(SrcCoeff, DstCoeff);
2441 const SCEV *Delta = SE->getMinusSCEV(B0, A0);
2648 SE->getMulExpr(SE->getMinusSCEV(A[K].NegPart, B[K].PosPart),
2651 SE->getMulExpr(SE->getMinusSCEV(A[K].PosPart, B[K].NegPart),
2658 SE->getConstant(A[K].Coeff->getType(), 0);
2661 SE->getConstant(A[K].Coeff->getType(), 0);
2688 const SCEV *Delta = SE->getMinusSCEV(A[K].Coeff, B[K].Coeff);
2691 SE->getMulExpr(NegativePart, Bound[K].Iterations);
2694 SE->getMulExpr(PositivePart, Bound[K].Iterations);
2699 const SCEV *Delta = SE->getMinusSCEV(A[K].Coeff, B[K].Coeff);
2731 SE->getMinusSCEV(Bound[K].Iterations,
2732 SE->getConstant(Bound[K].Iterations->getType(), 1));
2734 getNegativePart(SE->getMinusSCEV(A[K].NegPart, B[K].Coeff));
2736 SE->getMinusSCEV(SE->getMulExpr(NegPart, Iter_1), B[K].Coeff);
2738 getPositivePart(SE->getMinusSCEV(A[K].PosPart, B[K].Coeff));
2740 SE->getMinusSCEV(SE->getMulExpr(PosPart, Iter_1), B[K].Coeff);
2746 getNegativePart(SE->getMinusSCEV(A[K].NegPart, B[K].Coeff));
2748 Bound[K].Lower[Dependence::DVEntry::LT] = SE->getNegativeSCEV(B[K].Coeff);
2750 getPositivePart(SE->getMinusSCEV(A[K].PosPart, B[K].Coeff));
2752 Bound[K].Upper[Dependence::DVEntry::LT] = SE->getNegativeSCEV(B[K].Coeff);
2778 SE->getMinusSCEV(Bound[K].Iterations,
2779 SE->getConstant(Bound[K].Iterations->getType(), 1));
2781 getNegativePart(SE->getMinusSCEV(A[K].Coeff, B[K].PosPart));
2783 SE->getAddExpr(SE->getMulExpr(NegPart, Iter_1), A[K].Coeff);
2785 getPositivePart(SE->getMinusSCEV(A[K].Coeff, B[K].NegPart));
2787 SE->getAddExpr(SE->getMulExpr(PosPart, Iter_1), A[K].Coeff);
2792 const SCEV *NegPart = getNegativePart(SE->getMinusSCEV(A[K].Coeff, B[K].PosPart));
2795 const SCEV *PosPart = getPositivePart(SE->getMinusSCEV(A[K].Coeff, B[K].NegPart));
2804 return SE->getSMaxExpr(X, SE->getConstant(X->getType(), 0));
2810 return SE->getSMinExpr(X, SE->getConstant(X->getType(), 0));
2821 const SCEV *Zero = SE->getConstant(Subscript->getType(), 0);
2832 CI[K].Coeff = AddRec->getStepRecurrence(*SE);
2868 Sum = SE->getAddExpr(Sum, Bound[K].Lower[Bound[K].Direction]);
2884 Sum = SE->getAddExpr(Sum, Bound[K].Upper[Bound[K].Direction]);
2905 return SE->getConstant(Expr->getType(), 0);
2907 return AddRec->getStepRecurrence(*SE);
2924 return SE->getAddRecExpr(zeroCoefficient(AddRec->getStart(), TargetLoop),
2925 AddRec->getStepRecurrence(*SE),
2941 return SE->getAddRecExpr(Expr,
2946 const SCEV *Sum = SE->getAddExpr(AddRec->getStepRecurrence(*SE), Value);
2949 return SE->getAddRecExpr(AddRec->getStart(),
2954 return SE->getAddRecExpr(addToCoefficient(AddRec->getStart(),
2956 AddRec->getStepRecurrence(*SE),
3006 const SCEV *DA_K = SE->getMulExpr(A_K, CurConstraint.getD());
3007 Src = SE->getMinusSCEV(Src, DA_K);
3011 Dst = addToCoefficient(Dst, CurLoop, SE->getNegativeSCEV(A_K));
3044 // Src = SE->getAddExpr(Src, SE->getMulExpr(AP_K, SE->getConstant(CdivB)));
3045 Src = SE->getMinusSCEV(Src, SE->getMulExpr(AP_K, SE->getConstant(CdivB)));
3059 Src = SE->getAddExpr(Src, SE->getMulExpr(A_K, SE->getConstant(CdivA)));
3073 Src = SE->getAddExpr(Src, SE->getMulExpr(A_K, SE->getConstant(CdivA)));
3082 Src = SE->getMulExpr(Src, A);
3083 Dst = SE->getMulExpr(Dst, A);
3084 Src = SE->getAddExpr(Src, SE->getMulExpr(A_K, C));
3086 Dst = addToCoefficient(Dst, CurLoop, SE->getMulExpr(A_K, B));
3105 const SCEV *XA_K = SE->getMulExpr(A_K, CurConstraint.getX());
3106 const SCEV *YAP_K = SE->getMulExpr(AP_K, CurConstraint.getY());
3108 Src = SE->getAddExpr(Src, SE->getMinusSCEV(XA_K, YAP_K));
3131 if (!SE->isKnownNonZero(Level.Distance)) // if may be zero
3133 if (!SE->isKnownNonPositive(Level.Distance)) // if may be positive
3135 if (!SE->isKnownNonNegative(Level.Distance)) // if may be negative
3245 const SCEV *SrcPtrSCEV = SE->getSCEV(SrcGEP->getPointerOperand());
3246 const SCEV *DstPtrSCEV = SE->getSCEV(DstGEP->getPointerOperand());
3264 Pair[P].Src = SE->getSCEV(*SrcIdx);
3265 Pair[P].Dst = SE->getSCEV(*DstIdx);
3270 const SCEV *SrcSCEV = SE->getSCEV(SrcPtr);
3271 const SCEV *DstSCEV = SE->getSCEV(DstPtr);
3406 NewConstraint.setAny(SE);
3447 Constraints[II].setAny(SE);
3670 const SCEV *SrcPtrSCEV = SE->getSCEV(SrcGEP->getPointerOperand());
3671 const SCEV *DstPtrSCEV = SE->getSCEV(DstGEP->getPointerOperand());
3685 Pair[P].Src = SE->getSCEV(*SrcIdx);
3686 Pair[P].Dst = SE->getSCEV(*DstIdx);
3690 const SCEV *SrcSCEV = SE->getSCEV(SrcPtr);
3691 const SCEV *DstSCEV = SE->getSCEV(DstPtr);
3750 NewConstraint.setAny(SE);
3779 Constraints[II].setAny(SE);
