Lines Matching defs:Delta
97 STATISTIC(DeltaApplications, "Delta applications");
98 STATISTIC(DeltaSuccesses, "Delta successes");
99 STATISTIC(DeltaIndependence, "Delta independence");
100 STATISTIC(DeltaPropagations, "Delta propagations");
1076 const SCEV *Delta = SE->getMinusSCEV(X, Y);
1079 return Delta->isZero();
1081 return SE->isKnownNonZero(Delta);
1083 return SE->isKnownNonNegative(Delta);
1085 return SE->isKnownNonPositive(Delta);
1087 return SE->isKnownPositive(Delta);
1089 return SE->isKnownNegative(Delta);
1245 const SCEV *Delta = SE->getMinusSCEV(SrcConst, DstConst);
1246 LLVM_DEBUG(dbgs() << "\t Delta = " << *Delta);
1247 LLVM_DEBUG(dbgs() << ", " << *Delta->getType() << "\n");
1249 // check that |Delta| < iteration count
1250 if (const SCEV *UpperBound = collectUpperBound(CurLoop, Delta->getType())) {
1254 SE->isKnownNonNegative(Delta) ? Delta : SE->getNegativeSCEV(Delta);
1267 if (isa<SCEVConstant>(Delta) && isa<SCEVConstant>(Coeff)) {
1268 APInt ConstDelta = cast<SCEVConstant>(Delta)->getAPInt();
1275 // Make sure Coeff divides Delta exactly
1292 else if (Delta->isZero()) {
1294 Result.DV[Level].Distance = Delta;
1295 NewConstraint.setDistance(Delta, CurLoop);
1301 LLVM_DEBUG(dbgs() << "\t Distance = " << *Delta << "\n");
1302 Result.DV[Level].Distance = Delta; // since X/1 == X
1303 NewConstraint.setDistance(Delta, CurLoop);
1309 SE->getNegativeSCEV(Delta), CurLoop);
1313 bool DeltaMaybeZero = !SE->isKnownNonZero(Delta);
1314 bool DeltaMaybePositive = !SE->isKnownNonPositive(Delta);
1315 bool DeltaMaybeNegative = !SE->isKnownNonNegative(Delta);
1319 // It helps to read !SE->isKnownNonZero(Delta)
1320 // as "Delta might be Zero"
1378 const SCEV *Delta = SE->getMinusSCEV(DstConst, SrcConst);
1379 LLVM_DEBUG(dbgs() << "\t Delta = " << *Delta << "\n");
1380 NewConstraint.setLine(Coeff, Coeff, Delta, CurLoop);
1381 if (Delta->isZero()) {
1389 Result.DV[Level].Distance = Delta; // = 0
1401 Delta = SE->getNegativeSCEV(Delta);
1407 SE->getSMaxExpr(SE->getZero(Delta->getType()), Delta),
1408 SE->getMulExpr(SE->getConstant(Delta->getType(), 2), ConstCoeff));
1411 const SCEVConstant *ConstDelta = dyn_cast<SCEVConstant>(Delta);
1416 // if Delta < 0, then no dependence.
1417 LLVM_DEBUG(dbgs() << "\t Delta = " << *Delta << "\n");
1419 if (SE->isKnownNegative(Delta)) {
1420 // No dependence, Delta < 0
1426 // We're certain that Delta > 0 and ConstCoeff > 0.
1427 // Check Delta/(2*ConstCoeff) against upper loop bound
1428 if (const SCEV *UpperBound = collectUpperBound(CurLoop, Delta->getType())) {
1434 if (isKnownPredicate(CmpInst::ICMP_SGT, Delta, ML)) {
1435 // Delta too big, no dependence
1440 if (isKnownPredicate(CmpInst::ICMP_EQ, Delta, ML)) {
1450 Result.DV[Level].Distance = SE->getZero(Delta->getType());
1455 // check that Coeff divides Delta
1463 // Coeff doesn't divide Delta, no dependence
1470 // if 2*Coeff doesn't divide Delta, then the equal direction isn't possible
1492 // Returns true if dependence disproved; i.e., gcd does not divide Delta.
1494 const APInt &Delta, APInt &G, APInt &X, APInt &Y) {
1513 // make sure gcd divides Delta
1514 R = Delta.srem(G);
1516 return true; // gcd doesn't divide Delta, no dependence
1517 Q = Delta.sdiv(G);
1580 const SCEV *Delta = SE->getMinusSCEV(DstConst, SrcConst);
1581 LLVM_DEBUG(dbgs() << "\t Delta = " << *Delta << "\n");
1582 NewConstraint.setLine(SrcCoeff, SE->getNegativeSCEV(DstCoeff), Delta,
1584 const SCEVConstant *ConstDelta = dyn_cast<SCEVConstant>(Delta);
1597 // gcd doesn't divide Delta, no dependence
1610 collectConstantUpperBound(CurLoop, Delta->getType())) {
1776 const SCEV *Delta = SE->getMinusSCEV(SrcConst, DstConst);
1777 NewConstraint.setLine(SE->getZero(Delta->getType()), DstCoeff, Delta,
1779 LLVM_DEBUG(dbgs() << "\t Delta = " << *Delta << "\n");
1795 SE->isKnownNegative(ConstCoeff) ? SE->getNegativeSCEV(Delta) : Delta;
1797 // check that Delta/SrcCoeff < iteration count
1799 if (const SCEV *UpperBound = collectUpperBound(CurLoop, Delta->getType())) {
1818 // check that Delta/SrcCoeff >= 0
1827 // if SrcCoeff doesn't divide Delta, then no dependence
1828 if (isa<SCEVConstant>(Delta) &&
1829 !isRemainderZero(cast<SCEVConstant>(Delta), ConstCoeff)) {
1885 const SCEV *Delta = SE->getMinusSCEV(DstConst, SrcConst);
1886 NewConstraint.setLine(SrcCoeff, SE->getZero(Delta->getType()), Delta,
1888 LLVM_DEBUG(dbgs() << "\t Delta = " << *Delta << "\n");
1904 SE->isKnownNegative(ConstCoeff) ? SE->getNegativeSCEV(Delta) : Delta;
1906 // check that Delta/SrcCoeff < iteration count
1908 if (const SCEV *UpperBound = collectUpperBound(CurLoop, Delta->getType())) {
1927 // check that Delta/SrcCoeff >= 0
1936 // if SrcCoeff doesn't divide Delta, then no dependence
1937 if (isa<SCEVConstant>(Delta) &&
1938 !isRemainderZero(cast<SCEVConstant>(Delta), ConstCoeff)) {
1965 const SCEV *Delta = SE->getMinusSCEV(DstConst, SrcConst);
1966 LLVM_DEBUG(dbgs() << "\t Delta = " << *Delta << "\n");
1967 const SCEVConstant *ConstDelta = dyn_cast<SCEVConstant>(Delta);
1980 // gcd doesn't divide Delta, no dependence
1992 collectConstantUpperBound(SrcLoop, Delta->getType())) {
2002 collectConstantUpperBound(DstLoop, Delta->getType())) {
2448 const SCEV *Delta = SE->getMinusSCEV(DstConst, SrcConst);
2449 LLVM_DEBUG(dbgs() << " Delta = " << *Delta << "\n");
2450 const SCEVConstant *Constant = dyn_cast<SCEVConstant>(Delta);
2451 if (const SCEVAddExpr *Sum = dyn_cast<SCEVAddExpr>(Delta)) {
2452 // If Delta is a sum of products, we may be able to make further progress.
2544 Delta = SE->getMinusSCEV(SrcCoeff, DstCoeff);
2547 Constant = getConstantPart(Delta);
2617 const SCEV *Delta = SE->getMinusSCEV(B0, A0);
2618 LLVM_DEBUG(dbgs() << "\tDelta = " << *Delta << '\n');
2642 if (testBounds(Dependence::DVEntry::ALL, 0, Bound, Delta)) {
2646 Loops, DepthExpanded, Delta);
2689 const SCEV *Delta) const {
2780 if (testBounds(Dependence::DVEntry::LT, Level, Bound, Delta))
2782 Loops, DepthExpanded, Delta);
2785 if (testBounds(Dependence::DVEntry::EQ, Level, Bound, Delta))
2787 Loops, DepthExpanded, Delta);
2790 if (testBounds(Dependence::DVEntry::GT, Level, Bound, Delta))
2792 Loops, DepthExpanded, Delta);
2798 return exploreDirections(Level + 1, A, B, Bound, Loops, DepthExpanded, Delta);
2804 BoundInfo *Bound, const SCEV *Delta) const {
2807 if (isKnownPredicate(CmpInst::ICMP_SGT, LowerBound, Delta))
2810 if (isKnownPredicate(CmpInst::ICMP_SGT, Delta, UpperBound))
2875 const SCEV *Delta = SE->getMinusSCEV(A[K].Coeff, B[K].Coeff);
2876 const SCEV *NegativePart = getNegativePart(Delta);
2879 const SCEV *PositivePart = getPositivePart(Delta);
2886 const SCEV *Delta = SE->getMinusSCEV(A[K].Coeff, B[K].Coeff);
2887 const SCEV *NegativePart = getNegativePart(Delta);
2890 const SCEV *PositivePart = getPositivePart(Delta);
3073 // Constraint manipulation for Delta test.