Lines Matching refs:Delta
99 STATISTIC(DeltaApplications, "Delta applications");
100 STATISTIC(DeltaSuccesses, "Delta successes");
101 STATISTIC(DeltaIndependence, "Delta independence");
102 STATISTIC(DeltaPropagations, "Delta propagations");
989 const SCEV *Delta = SE->getMinusSCEV(X, Y);
992 return Delta->isZero();
994 return SE->isKnownNonZero(Delta);
996 return SE->isKnownNonNegative(Delta);
998 return SE->isKnownNonPositive(Delta);
1000 return SE->isKnownPositive(Delta);
1002 return SE->isKnownNegative(Delta);
1158 const SCEV *Delta = SE->getMinusSCEV(SrcConst, DstConst);
1159 LLVM_DEBUG(dbgs() << "\t Delta = " << *Delta);
1160 LLVM_DEBUG(dbgs() << ", " << *Delta->getType() << "\n");
1162 // check that |Delta| < iteration count
1163 if (const SCEV *UpperBound = collectUpperBound(CurLoop, Delta->getType())) {
1167 SE->isKnownNonNegative(Delta) ? Delta : SE->getNegativeSCEV(Delta);
1180 if (isa<SCEVConstant>(Delta) && isa<SCEVConstant>(Coeff)) {
1181 APInt ConstDelta = cast<SCEVConstant>(Delta)->getAPInt();
1188 // Make sure Coeff divides Delta exactly
1205 else if (Delta->isZero()) {
1207 Result.DV[Level].Distance = Delta;
1208 NewConstraint.setDistance(Delta, CurLoop);
1214 LLVM_DEBUG(dbgs() << "\t Distance = " << *Delta << "\n");
1215 Result.DV[Level].Distance = Delta; // since X/1 == X
1216 NewConstraint.setDistance(Delta, CurLoop);
1222 SE->getNegativeSCEV(Delta), CurLoop);
1226 bool DeltaMaybeZero = !SE->isKnownNonZero(Delta);
1227 bool DeltaMaybePositive = !SE->isKnownNonPositive(Delta);
1228 bool DeltaMaybeNegative = !SE->isKnownNonNegative(Delta);
1232 // It helps to read !SE->isKnownNonZero(Delta)
1233 // as "Delta might be Zero"
1291 const SCEV *Delta = SE->getMinusSCEV(DstConst, SrcConst);
1292 LLVM_DEBUG(dbgs() << "\t Delta = " << *Delta << "\n");
1293 NewConstraint.setLine(Coeff, Coeff, Delta, CurLoop);
1294 if (Delta->isZero()) {
1302 Result.DV[Level].Distance = Delta; // = 0
1314 Delta = SE->getNegativeSCEV(Delta);
1320 SE->getSMaxExpr(SE->getZero(Delta->getType()), Delta),
1321 SE->getMulExpr(SE->getConstant(Delta->getType(), 2), ConstCoeff));
1324 const SCEVConstant *ConstDelta = dyn_cast<SCEVConstant>(Delta);
1329 // if Delta < 0, then no dependence.
1330 LLVM_DEBUG(dbgs() << "\t Delta = " << *Delta << "\n");
1332 if (SE->isKnownNegative(Delta)) {
1333 // No dependence, Delta < 0
1339 // We're certain that Delta > 0 and ConstCoeff > 0.
1340 // Check Delta/(2*ConstCoeff) against upper loop bound
1341 if (const SCEV *UpperBound = collectUpperBound(CurLoop, Delta->getType())) {
1347 if (isKnownPredicate(CmpInst::ICMP_SGT, Delta, ML)) {
1348 // Delta too big, no dependence
1353 if (isKnownPredicate(CmpInst::ICMP_EQ, Delta, ML)) {
1363 Result.DV[Level].Distance = SE->getZero(Delta->getType());
1368 // check that Coeff divides Delta
1376 // Coeff doesn't divide Delta, no dependence
1383 // if 2*Coeff doesn't divide Delta, then the equal direction isn't possible
1405 // Returns true if dependence disproved; i.e., gcd does not divide Delta.
1407 const APInt &Delta, APInt &G, APInt &X, APInt &Y) {
1426 // make sure gcd divides Delta
1427 R = Delta.srem(G);
1429 return true; // gcd doesn't divide Delta, no dependence
1430 Q = Delta.sdiv(G);
1504 const SCEV *Delta = SE->getMinusSCEV(DstConst, SrcConst);
1505 LLVM_DEBUG(dbgs() << "\t Delta = " << *Delta << "\n");
1507 Delta, CurLoop);
1508 const SCEVConstant *ConstDelta = dyn_cast<SCEVConstant>(Delta);
1520 // gcd doesn't divide Delta, no dependence
1533 collectConstantUpperBound(CurLoop, Delta->getType())) {
1716 const SCEV *Delta = SE->getMinusSCEV(SrcConst, DstConst);
1717 NewConstraint.setLine(SE->getZero(Delta->getType()), DstCoeff, Delta,
1719 LLVM_DEBUG(dbgs() << "\t Delta = " << *Delta << "\n");
1735 SE->isKnownNegative(ConstCoeff) ? SE->getNegativeSCEV(Delta) : Delta;
1737 // check that Delta/SrcCoeff < iteration count
1739 if (const SCEV *UpperBound = collectUpperBound(CurLoop, Delta->getType())) {
1758 // check that Delta/SrcCoeff >= 0
1767 // if SrcCoeff doesn't divide Delta, then no dependence
1768 if (isa<SCEVConstant>(Delta) &&
1769 !isRemainderZero(cast<SCEVConstant>(Delta), ConstCoeff)) {
1825 const SCEV *Delta = SE->getMinusSCEV(DstConst, SrcConst);
1826 NewConstraint.setLine(SrcCoeff, SE->getZero(Delta->getType()), Delta,
1828 LLVM_DEBUG(dbgs() << "\t Delta = " << *Delta << "\n");
1844 SE->isKnownNegative(ConstCoeff) ? SE->getNegativeSCEV(Delta) : Delta;
1846 // check that Delta/SrcCoeff < iteration count
1848 if (const SCEV *UpperBound = collectUpperBound(CurLoop, Delta->getType())) {
1867 // check that Delta/SrcCoeff >= 0
1876 // if SrcCoeff doesn't divide Delta, then no dependence
1877 if (isa<SCEVConstant>(Delta) &&
1878 !isRemainderZero(cast<SCEVConstant>(Delta), ConstCoeff)) {
1905 const SCEV *Delta = SE->getMinusSCEV(DstConst, SrcConst);
1906 LLVM_DEBUG(dbgs() << "\t Delta = " << *Delta << "\n");
1907 const SCEVConstant *ConstDelta = dyn_cast<SCEVConstant>(Delta);
1919 // gcd doesn't divide Delta, no dependence
1931 collectConstantUpperBound(SrcLoop, Delta->getType())) {
1941 collectConstantUpperBound(DstLoop, Delta->getType())) {
2372 const SCEV *Delta = SE->getMinusSCEV(DstConst, SrcConst);
2373 LLVM_DEBUG(dbgs() << " Delta = " << *Delta << "\n");
2374 const SCEVConstant *Constant = dyn_cast<SCEVConstant>(Delta);
2375 if (const SCEVAddExpr *Sum = dyn_cast<SCEVAddExpr>(Delta)) {
2376 // If Delta is a sum of products, we may be able to make further progress.
2468 Delta = SE->getMinusSCEV(SrcCoeff, DstCoeff);
2471 Constant = getConstantPart(Delta);
2541 const SCEV *Delta = SE->getMinusSCEV(B0, A0);
2542 LLVM_DEBUG(dbgs() << "\tDelta = " << *Delta << '\n');
2566 if (testBounds(Dependence::DVEntry::ALL, 0, Bound, Delta)) {
2570 Loops, DepthExpanded, Delta);
2613 const SCEV *Delta) const {
2691 if (testBounds(Dependence::DVEntry::LT, Level, Bound, Delta))
2693 Loops, DepthExpanded, Delta);
2696 if (testBounds(Dependence::DVEntry::EQ, Level, Bound, Delta))
2698 Loops, DepthExpanded, Delta);
2701 if (testBounds(Dependence::DVEntry::GT, Level, Bound, Delta))
2703 Loops, DepthExpanded, Delta);
2709 return exploreDirections(Level + 1, A, B, Bound, Loops, DepthExpanded, Delta);
2715 BoundInfo *Bound, const SCEV *Delta) const {
2718 if (isKnownPredicate(CmpInst::ICMP_SGT, LowerBound, Delta))
2721 if (isKnownPredicate(CmpInst::ICMP_SGT, Delta, UpperBound))
2786 const SCEV *Delta = SE->getMinusSCEV(A[K].Coeff, B[K].Coeff);
2787 const SCEV *NegativePart = getNegativePart(Delta);
2790 const SCEV *PositivePart = getPositivePart(Delta);
2797 const SCEV *Delta = SE->getMinusSCEV(A[K].Coeff, B[K].Coeff);
2798 const SCEV *NegativePart = getNegativePart(Delta);
2801 const SCEV *PositivePart = getPositivePart(Delta);
2984 // Constraint manipulation for Delta test.