lib/Analysis/DependenceAnalysis.cpp

   1 //===-- DependenceAnalysis.cpp - DA Implementation --------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // DependenceAnalysis is an LLVM pass that analyses dependences between memory
  11 // accesses. Currently, it is an (incomplete) implementation of the approach
  12 // described in
  13 //
  14 //            Practical Dependence Testing
  15 //            Goff, Kennedy, Tseng
  16 //            PLDI 1991
  17 //
  18 // There's a single entry point that analyzes the dependence between a pair
  19 // of memory references in a function, returning either NULL, for no dependence,
  20 // or a more-or-less detailed description of the dependence between them.
  21 //
  22 // Currently, the implementation cannot propagate constraints between
  23 // coupled RDIV subscripts and lacks a multi-subscript MIV test.
  24 // Both of these are conservative weaknesses;
  25 // that is, not a source of correctness problems.
  26 //
  27 // The implementation depends on the GEP instruction to differentiate
  28 // subscripts. Since Clang linearizes some array subscripts, the dependence
  29 // analysis is using SCEV->delinearize to recover the representation of multiple
  30 // subscripts, and thus avoid the more expensive and less precise MIV tests. The
  31 // delinearization is controlled by the flag -da-delinearize.
  32 //
  33 // We should pay some careful attention to the possibility of integer overflow
  34 // in the implementation of the various tests. This could happen with Add,
  35 // Subtract, or Multiply, with both APInt's and SCEV's.
  36 //
  37 // Some non-linear subscript pairs can be handled by the GCD test
  38 // (and perhaps other tests).
  39 // Should explore how often these things occur.
  40 //
  41 // Finally, it seems like certain test cases expose weaknesses in the SCEV
  42 // simplification, especially in the handling of sign and zero extensions.
  43 // It could be useful to spend time exploring these.
  44 //
  45 // Please note that this is work in progress and the interface is subject to
  46 // change.
  47 //
  48 //===----------------------------------------------------------------------===//
  49 //                                                                            //
  50 //                   In memory of Ken Kennedy, 1945 - 2007                    //
  51 //                                                                            //
  52 //===----------------------------------------------------------------------===//
  53
  54 #include "llvm/Analysis/DependenceAnalysis.h"
  55 #include "llvm/ADT/STLExtras.h"
  56 #include "llvm/ADT/Statistic.h"
  57 #include "llvm/Analysis/AliasAnalysis.h"
  58 #include "llvm/Analysis/LoopInfo.h"
  59 #include "llvm/Analysis/ScalarEvolution.h"
  60 #include "llvm/Analysis/ScalarEvolutionExpressions.h"
  61 #include "llvm/Analysis/ValueTracking.h"
  62 #include "llvm/IR/InstIterator.h"
  63 #include "llvm/IR/Module.h"
  64 #include "llvm/IR/Operator.h"
  65 #include "llvm/Support/CommandLine.h"
  66 #include "llvm/Support/Debug.h"
  67 #include "llvm/Support/ErrorHandling.h"
  68 #include "llvm/Support/raw_ostream.h"
  69
  70 using namespace llvm;
  71
  72 #define DEBUG_TYPE "da"
  73
  74 //===----------------------------------------------------------------------===//
  75 // statistics
  76
  77 STATISTIC(TotalArrayPairs, "Array pairs tested");
  78 STATISTIC(SeparableSubscriptPairs, "Separable subscript pairs");
  79 STATISTIC(CoupledSubscriptPairs, "Coupled subscript pairs");
  80 STATISTIC(NonlinearSubscriptPairs, "Nonlinear subscript pairs");
  81 STATISTIC(ZIVapplications, "ZIV applications");
  82 STATISTIC(ZIVindependence, "ZIV independence");
  83 STATISTIC(StrongSIVapplications, "Strong SIV applications");
  84 STATISTIC(StrongSIVsuccesses, "Strong SIV successes");
  85 STATISTIC(StrongSIVindependence, "Strong SIV independence");
  86 STATISTIC(WeakCrossingSIVapplications, "Weak-Crossing SIV applications");
  87 STATISTIC(WeakCrossingSIVsuccesses, "Weak-Crossing SIV successes");
  88 STATISTIC(WeakCrossingSIVindependence, "Weak-Crossing SIV independence");
  89 STATISTIC(ExactSIVapplications, "Exact SIV applications");
  90 STATISTIC(ExactSIVsuccesses, "Exact SIV successes");
  91 STATISTIC(ExactSIVindependence, "Exact SIV independence");
  92 STATISTIC(WeakZeroSIVapplications, "Weak-Zero SIV applications");
  93 STATISTIC(WeakZeroSIVsuccesses, "Weak-Zero SIV successes");
  94 STATISTIC(WeakZeroSIVindependence, "Weak-Zero SIV independence");
  95 STATISTIC(ExactRDIVapplications, "Exact RDIV applications");
  96 STATISTIC(ExactRDIVindependence, "Exact RDIV independence");
  97 STATISTIC(SymbolicRDIVapplications, "Symbolic RDIV applications");
  98 STATISTIC(SymbolicRDIVindependence, "Symbolic RDIV independence");
  99 STATISTIC(DeltaApplications, "Delta applications");
 100 STATISTIC(DeltaSuccesses, "Delta successes");
 101 STATISTIC(DeltaIndependence, "Delta independence");
 102 STATISTIC(DeltaPropagations, "Delta propagations");
 103 STATISTIC(GCDapplications, "GCD applications");
 104 STATISTIC(GCDsuccesses, "GCD successes");
 105 STATISTIC(GCDindependence, "GCD independence");
 106 STATISTIC(BanerjeeApplications, "Banerjee applications");
 107 STATISTIC(BanerjeeIndependence, "Banerjee independence");
 108 STATISTIC(BanerjeeSuccesses, "Banerjee successes");
 109
 110 static cl::opt<bool>
 111 Delinearize("da-delinearize", cl::init(false), cl::Hidden, cl::ZeroOrMore,
 112             cl::desc("Try to delinearize array references."));
 113
 114 //===----------------------------------------------------------------------===//
 115 // basics
 116
 117 INITIALIZE_PASS_BEGIN(DependenceAnalysis, "da",
 118                       "Dependence Analysis", true, true)
 119 INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass)
 120 INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass)
 121 INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass)
 122 INITIALIZE_PASS_END(DependenceAnalysis, "da",
 123                     "Dependence Analysis", true, true)
 124
 125 char DependenceAnalysis::ID = 0;
 126
 127
 128 FunctionPass *llvm::createDependenceAnalysisPass() {
 129   return new DependenceAnalysis();
 130 }
 131
 132
 133 bool DependenceAnalysis::runOnFunction(Function &F) {
 134   this->F = &F;
 135   AA = &getAnalysis<AAResultsWrapperPass>().getAAResults();
 136   SE = &getAnalysis<ScalarEvolutionWrapperPass>().getSE();
 137   LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
 138   return false;
 139 }
 140
 141
 142 void DependenceAnalysis::releaseMemory() {
 143 }
 144
 145
 146 void DependenceAnalysis::getAnalysisUsage(AnalysisUsage &AU) const {
 147   AU.setPreservesAll();
 148   AU.addRequiredTransitive<AAResultsWrapperPass>();
 149   AU.addRequiredTransitive<ScalarEvolutionWrapperPass>();
 150   AU.addRequiredTransitive<LoopInfoWrapperPass>();
 151 }
 152
 153
 154 // Used to test the dependence analyzer.
 155 // Looks through the function, noting loads and stores.
 156 // Calls depends() on every possible pair and prints out the result.
 157 // Ignores all other instructions.
 158 static
 159 void dumpExampleDependence(raw_ostream &OS, Function *F,
 160                            DependenceAnalysis *DA) {
 161   for (inst_iterator SrcI = inst_begin(F), SrcE = inst_end(F);
 162        SrcI != SrcE; ++SrcI) {
 163     if (isa<StoreInst>(*SrcI) || isa<LoadInst>(*SrcI)) {
 164       for (inst_iterator DstI = SrcI, DstE = inst_end(F);
 165            DstI != DstE; ++DstI) {
 166         if (isa<StoreInst>(*DstI) || isa<LoadInst>(*DstI)) {
 167           OS << "da analyze - ";
 168           if (auto D = DA->depends(&*SrcI, &*DstI, true)) {
 169             D->dump(OS);
 170             for (unsigned Level = 1; Level <= D->getLevels(); Level++) {
 171               if (D->isSplitable(Level)) {
 172                 OS << "da analyze - split level = " << Level;
 173                 OS << ", iteration = " << *DA->getSplitIteration(*D, Level);
 174                 OS << "!\n";
 175               }
 176             }
 177           }
 178           else
 179             OS << "none!\n";
 180         }
 181       }
 182     }
 183   }
 184 }
 185
 186
 187 void DependenceAnalysis::print(raw_ostream &OS, const Module*) const {
 188   dumpExampleDependence(OS, F, const_cast<DependenceAnalysis *>(this));
 189 }
 190
 191 //===----------------------------------------------------------------------===//
 192 // Dependence methods
 193
 194 // Returns true if this is an input dependence.
 195 bool Dependence::isInput() const {
 196   return Src->mayReadFromMemory() && Dst->mayReadFromMemory();
 197 }
 198
 199
 200 // Returns true if this is an output dependence.
 201 bool Dependence::isOutput() const {
 202   return Src->mayWriteToMemory() && Dst->mayWriteToMemory();
 203 }
 204
 205
 206 // Returns true if this is an flow (aka true)  dependence.
 207 bool Dependence::isFlow() const {
 208   return Src->mayWriteToMemory() && Dst->mayReadFromMemory();
 209 }
 210
 211
 212 // Returns true if this is an anti dependence.
 213 bool Dependence::isAnti() const {
 214   return Src->mayReadFromMemory() && Dst->mayWriteToMemory();
 215 }
 216
 217
 218 // Returns true if a particular level is scalar; that is,
 219 // if no subscript in the source or destination mention the induction
 220 // variable associated with the loop at this level.
 221 // Leave this out of line, so it will serve as a virtual method anchor
 222 bool Dependence::isScalar(unsigned level) const {
 223   return false;
 224 }
 225
 226
 227 //===----------------------------------------------------------------------===//
 228 // FullDependence methods
 229
 230 FullDependence::FullDependence(Instruction *Source, Instruction *Destination,
 231                                bool PossiblyLoopIndependent,
 232                                unsigned CommonLevels)
 233     : Dependence(Source, Destination), Levels(CommonLevels),
 234       LoopIndependent(PossiblyLoopIndependent) {
 235   Consistent = true;
 236   if (CommonLevels)
 237     DV = make_unique<DVEntry[]>(CommonLevels);
 238 }
 239
 240 // The rest are simple getters that hide the implementation.
 241
 242 // getDirection - Returns the direction associated with a particular level.
 243 unsigned FullDependence::getDirection(unsigned Level) const {
 244   assert(0 < Level && Level <= Levels && "Level out of range");
 245   return DV[Level - 1].Direction;
 246 }
 247
 248
 249 // Returns the distance (or NULL) associated with a particular level.
 250 const SCEV *FullDependence::getDistance(unsigned Level) const {
 251   assert(0 < Level && Level <= Levels && "Level out of range");
 252   return DV[Level - 1].Distance;
 253 }
 254
 255
 256 // Returns true if a particular level is scalar; that is,
 257 // if no subscript in the source or destination mention the induction
 258 // variable associated with the loop at this level.
 259 bool FullDependence::isScalar(unsigned Level) const {
 260   assert(0 < Level && Level <= Levels && "Level out of range");
 261   return DV[Level - 1].Scalar;
 262 }
 263
 264
 265 // Returns true if peeling the first iteration from this loop
 266 // will break this dependence.
 267 bool FullDependence::isPeelFirst(unsigned Level) const {
 268   assert(0 < Level && Level <= Levels && "Level out of range");
 269   return DV[Level - 1].PeelFirst;
 270 }
 271
 272
 273 // Returns true if peeling the last iteration from this loop
 274 // will break this dependence.
 275 bool FullDependence::isPeelLast(unsigned Level) const {
 276   assert(0 < Level && Level <= Levels && "Level out of range");
 277   return DV[Level - 1].PeelLast;
 278 }
 279
 280
 281 // Returns true if splitting this loop will break the dependence.
 282 bool FullDependence::isSplitable(unsigned Level) const {
 283   assert(0 < Level && Level <= Levels && "Level out of range");
 284   return DV[Level - 1].Splitable;
 285 }
 286
 287
 288 //===----------------------------------------------------------------------===//
 289 // DependenceAnalysis::Constraint methods
 290
 291 // If constraint is a point <X, Y>, returns X.
 292 // Otherwise assert.
 293 const SCEV *DependenceAnalysis::Constraint::getX() const {
 294   assert(Kind == Point && "Kind should be Point");
 295   return A;
 296 }
 297
 298
 299 // If constraint is a point <X, Y>, returns Y.
 300 // Otherwise assert.
 301 const SCEV *DependenceAnalysis::Constraint::getY() const {
 302   assert(Kind == Point && "Kind should be Point");
 303   return B;
 304 }
 305
 306
 307 // If constraint is a line AX + BY = C, returns A.
 308 // Otherwise assert.
 309 const SCEV *DependenceAnalysis::Constraint::getA() const {
 310   assert((Kind == Line || Kind == Distance) &&
 311          "Kind should be Line (or Distance)");
 312   return A;
 313 }
 314
 315
 316 // If constraint is a line AX + BY = C, returns B.
 317 // Otherwise assert.
 318 const SCEV *DependenceAnalysis::Constraint::getB() const {
 319   assert((Kind == Line || Kind == Distance) &&
 320          "Kind should be Line (or Distance)");
 321   return B;
 322 }
 323
 324
 325 // If constraint is a line AX + BY = C, returns C.
 326 // Otherwise assert.
 327 const SCEV *DependenceAnalysis::Constraint::getC() const {
 328   assert((Kind == Line || Kind == Distance) &&
 329          "Kind should be Line (or Distance)");
 330   return C;
 331 }
 332
 333
 334 // If constraint is a distance, returns D.
 335 // Otherwise assert.
 336 const SCEV *DependenceAnalysis::Constraint::getD() const {
 337   assert(Kind == Distance && "Kind should be Distance");
 338   return SE->getNegativeSCEV(C);
 339 }
 340
 341
 342 // Returns the loop associated with this constraint.
 343 const Loop *DependenceAnalysis::Constraint::getAssociatedLoop() const {
 344   assert((Kind == Distance || Kind == Line || Kind == Point) &&
 345          "Kind should be Distance, Line, or Point");
 346   return AssociatedLoop;
 347 }
 348
 349
 350 void DependenceAnalysis::Constraint::setPoint(const SCEV *X,
 351                                               const SCEV *Y,
 352                                               const Loop *CurLoop) {
 353   Kind = Point;
 354   A = X;
 355   B = Y;
 356   AssociatedLoop = CurLoop;
 357 }
 358
 359
 360 void DependenceAnalysis::Constraint::setLine(const SCEV *AA,
 361                                              const SCEV *BB,
 362                                              const SCEV *CC,
 363                                              const Loop *CurLoop) {
 364   Kind = Line;
 365   A = AA;
 366   B = BB;
 367   C = CC;
 368   AssociatedLoop = CurLoop;
 369 }
 370
 371
 372 void DependenceAnalysis::Constraint::setDistance(const SCEV *D,
 373                                                  const Loop *CurLoop) {
 374   Kind = Distance;
 375   A = SE->getOne(D->getType());
 376   B = SE->getNegativeSCEV(A);
 377   C = SE->getNegativeSCEV(D);
 378   AssociatedLoop = CurLoop;
 379 }
 380
 381
 382 void DependenceAnalysis::Constraint::setEmpty() {
 383   Kind = Empty;
 384 }
 385
 386
 387 void DependenceAnalysis::Constraint::setAny(ScalarEvolution *NewSE) {
 388   SE = NewSE;
 389   Kind = Any;
 390 }
 391
 392
 393 // For debugging purposes. Dumps the constraint out to OS.
 394 void DependenceAnalysis::Constraint::dump(raw_ostream &OS) const {
 395   if (isEmpty())
 396     OS << " Empty\n";
 397   else if (isAny())
 398     OS << " Any\n";
 399   else if (isPoint())
 400     OS << " Point is <" << *getX() << ", " << *getY() << ">\n";
 401   else if (isDistance())
 402     OS << " Distance is " << *getD() <<
 403       " (" << *getA() << "*X + " << *getB() << "*Y = " << *getC() << ")\n";
 404   else if (isLine())
 405     OS << " Line is " << *getA() << "*X + " <<
 406       *getB() << "*Y = " << *getC() << "\n";
 407   else
 408     llvm_unreachable("unknown constraint type in Constraint::dump");
 409 }
 410
 411
 412 // Updates X with the intersection
 413 // of the Constraints X and Y. Returns true if X has changed.
 414 // Corresponds to Figure 4 from the paper
 415 //
 416 //            Practical Dependence Testing
 417 //            Goff, Kennedy, Tseng
 418 //            PLDI 1991
 419 bool DependenceAnalysis::intersectConstraints(Constraint *X,
 420                                               const Constraint *Y) {
 421   ++DeltaApplications;
 422   DEBUG(dbgs() << "\tintersect constraints\n");
 423   DEBUG(dbgs() << "\t    X ="; X->dump(dbgs()));
 424   DEBUG(dbgs() << "\t    Y ="; Y->dump(dbgs()));
 425   assert(!Y->isPoint() && "Y must not be a Point");
 426   if (X->isAny()) {
 427     if (Y->isAny())
 428       return false;
 429     *X = *Y;
 430     return true;
 431   }
 432   if (X->isEmpty())
 433     return false;
 434   if (Y->isEmpty()) {
 435     X->setEmpty();
 436     return true;
 437   }
 438
 439   if (X->isDistance() && Y->isDistance()) {
 440     DEBUG(dbgs() << "\t    intersect 2 distances\n");
 441     if (isKnownPredicate(CmpInst::ICMP_EQ, X->getD(), Y->getD()))
 442       return false;
 443     if (isKnownPredicate(CmpInst::ICMP_NE, X->getD(), Y->getD())) {
 444       X->setEmpty();
 445       ++DeltaSuccesses;
 446       return true;
 447     }
 448     // Hmmm, interesting situation.
 449     // I guess if either is constant, keep it and ignore the other.
 450     if (isa<SCEVConstant>(Y->getD())) {
 451       *X = *Y;
 452       return true;
 453     }
 454     return false;
 455   }
 456
 457   // At this point, the pseudo-code in Figure 4 of the paper
 458   // checks if (X->isPoint() && Y->isPoint()).
 459   // This case can't occur in our implementation,
 460   // since a Point can only arise as the result of intersecting
 461   // two Line constraints, and the right-hand value, Y, is never
 462   // the result of an intersection.
 463   assert(!(X->isPoint() && Y->isPoint()) &&
 464          "We shouldn't ever see X->isPoint() && Y->isPoint()");
 465
 466   if (X->isLine() && Y->isLine()) {
 467     DEBUG(dbgs() << "\t    intersect 2 lines\n");
 468     const SCEV *Prod1 = SE->getMulExpr(X->getA(), Y->getB());
 469     const SCEV *Prod2 = SE->getMulExpr(X->getB(), Y->getA());
 470     if (isKnownPredicate(CmpInst::ICMP_EQ, Prod1, Prod2)) {
 471       // slopes are equal, so lines are parallel
 472       DEBUG(dbgs() << "\t\tsame slope\n");
 473       Prod1 = SE->getMulExpr(X->getC(), Y->getB());
 474       Prod2 = SE->getMulExpr(X->getB(), Y->getC());
 475       if (isKnownPredicate(CmpInst::ICMP_EQ, Prod1, Prod2))
 476         return false;
 477       if (isKnownPredicate(CmpInst::ICMP_NE, Prod1, Prod2)) {
 478         X->setEmpty();
 479         ++DeltaSuccesses;
 480         return true;
 481       }
 482       return false;
 483     }
 484     if (isKnownPredicate(CmpInst::ICMP_NE, Prod1, Prod2)) {
 485       // slopes differ, so lines intersect
 486       DEBUG(dbgs() << "\t\tdifferent slopes\n");
 487       const SCEV *C1B2 = SE->getMulExpr(X->getC(), Y->getB());
 488       const SCEV *C1A2 = SE->getMulExpr(X->getC(), Y->getA());
 489       const SCEV *C2B1 = SE->getMulExpr(Y->getC(), X->getB());
 490       const SCEV *C2A1 = SE->getMulExpr(Y->getC(), X->getA());
 491       const SCEV *A1B2 = SE->getMulExpr(X->getA(), Y->getB());
 492       const SCEV *A2B1 = SE->getMulExpr(Y->getA(), X->getB());
 493       const SCEVConstant *C1A2_C2A1 =
 494         dyn_cast<SCEVConstant>(SE->getMinusSCEV(C1A2, C2A1));
 495       const SCEVConstant *C1B2_C2B1 =
 496         dyn_cast<SCEVConstant>(SE->getMinusSCEV(C1B2, C2B1));
 497       const SCEVConstant *A1B2_A2B1 =
 498         dyn_cast<SCEVConstant>(SE->getMinusSCEV(A1B2, A2B1));
 499       const SCEVConstant *A2B1_A1B2 =
 500         dyn_cast<SCEVConstant>(SE->getMinusSCEV(A2B1, A1B2));
 501       if (!C1B2_C2B1 || !C1A2_C2A1 ||
 502           !A1B2_A2B1 || !A2B1_A1B2)
 503         return false;
 504       APInt Xtop = C1B2_C2B1->getAPInt();
 505       APInt Xbot = A1B2_A2B1->getAPInt();
 506       APInt Ytop = C1A2_C2A1->getAPInt();
 507       APInt Ybot = A2B1_A1B2->getAPInt();
 508       DEBUG(dbgs() << "\t\tXtop = " << Xtop << "\n");
 509       DEBUG(dbgs() << "\t\tXbot = " << Xbot << "\n");
 510       DEBUG(dbgs() << "\t\tYtop = " << Ytop << "\n");
 511       DEBUG(dbgs() << "\t\tYbot = " << Ybot << "\n");
 512       APInt Xq = Xtop; // these need to be initialized, even
 513       APInt Xr = Xtop; // though they're just going to be overwritten
 514       APInt::sdivrem(Xtop, Xbot, Xq, Xr);
 515       APInt Yq = Ytop;
 516       APInt Yr = Ytop;
 517       APInt::sdivrem(Ytop, Ybot, Yq, Yr);
 518       if (Xr != 0 || Yr != 0) {
 519         X->setEmpty();
 520         ++DeltaSuccesses;
 521         return true;
 522       }
 523       DEBUG(dbgs() << "\t\tX = " << Xq << ", Y = " << Yq << "\n");
 524       if (Xq.slt(0) || Yq.slt(0)) {
 525         X->setEmpty();
 526         ++DeltaSuccesses;
 527         return true;
 528       }
 529       if (const SCEVConstant *CUB =
 530           collectConstantUpperBound(X->getAssociatedLoop(), Prod1->getType())) {
 531         APInt UpperBound = CUB->getAPInt();
 532         DEBUG(dbgs() << "\t\tupper bound = " << UpperBound << "\n");
 533         if (Xq.sgt(UpperBound) || Yq.sgt(UpperBound)) {
 534           X->setEmpty();
 535           ++DeltaSuccesses;
 536           return true;
 537         }
 538       }
 539       X->setPoint(SE->getConstant(Xq),
 540                   SE->getConstant(Yq),
 541                   X->getAssociatedLoop());
 542       ++DeltaSuccesses;
 543       return true;
 544     }
 545     return false;
 546   }
 547
 548   // if (X->isLine() && Y->isPoint()) This case can't occur.
 549   assert(!(X->isLine() && Y->isPoint()) && "This case should never occur");
 550
 551   if (X->isPoint() && Y->isLine()) {
 552     DEBUG(dbgs() << "\t    intersect Point and Line\n");
 553     const SCEV *A1X1 = SE->getMulExpr(Y->getA(), X->getX());
 554     const SCEV *B1Y1 = SE->getMulExpr(Y->getB(), X->getY());
 555     const SCEV *Sum = SE->getAddExpr(A1X1, B1Y1);
 556     if (isKnownPredicate(CmpInst::ICMP_EQ, Sum, Y->getC()))
 557       return false;
 558     if (isKnownPredicate(CmpInst::ICMP_NE, Sum, Y->getC())) {
 559       X->setEmpty();
 560       ++DeltaSuccesses;
 561       return true;
 562     }
 563     return false;
 564   }
 565
 566   llvm_unreachable("shouldn't reach the end of Constraint intersection");
 567   return false;
 568 }
 569
 570
 571 //===----------------------------------------------------------------------===//
 572 // DependenceAnalysis methods
 573
 574 // For debugging purposes. Dumps a dependence to OS.
 575 void Dependence::dump(raw_ostream &OS) const {
 576   bool Splitable = false;
 577   if (isConfused())
 578     OS << "confused";
 579   else {
 580     if (isConsistent())
 581       OS << "consistent ";
 582     if (isFlow())
 583       OS << "flow";
 584     else if (isOutput())
 585       OS << "output";
 586     else if (isAnti())
 587       OS << "anti";
 588     else if (isInput())
 589       OS << "input";
 590     unsigned Levels = getLevels();
 591     OS << " [";
 592     for (unsigned II = 1; II <= Levels; ++II) {
 593       if (isSplitable(II))
 594         Splitable = true;
 595       if (isPeelFirst(II))
 596         OS << 'p';
 597       const SCEV *Distance = getDistance(II);
 598       if (Distance)
 599         OS << *Distance;
 600       else if (isScalar(II))
 601         OS << "S";
 602       else {
 603         unsigned Direction = getDirection(II);
 604         if (Direction == DVEntry::ALL)
 605           OS << "*";
 606         else {
 607           if (Direction & DVEntry::LT)
 608             OS << "<";
 609           if (Direction & DVEntry::EQ)
 610             OS << "=";
 611           if (Direction & DVEntry::GT)
 612             OS << ">";
 613         }
 614       }
 615       if (isPeelLast(II))
 616         OS << 'p';
 617       if (II < Levels)
 618         OS << " ";
 619     }
 620     if (isLoopIndependent())
 621       OS << "|<";
 622     OS << "]";
 623     if (Splitable)
 624       OS << " splitable";
 625   }
 626   OS << "!\n";
 627 }
 628
 629 static AliasResult underlyingObjectsAlias(AliasAnalysis *AA,
 630                                           const DataLayout &DL, const Value *A,
 631                                           const Value *B) {
 632   const Value *AObj = GetUnderlyingObject(A, DL);
 633   const Value *BObj = GetUnderlyingObject(B, DL);
 634   return AA->alias(AObj, DL.getTypeStoreSize(AObj->getType()),
 635                    BObj, DL.getTypeStoreSize(BObj->getType()));
 636 }
 637
 638
 639 // Returns true if the load or store can be analyzed. Atomic and volatile
 640 // operations have properties which this analysis does not understand.
 641 static
 642 bool isLoadOrStore(const Instruction *I) {
 643   if (const LoadInst *LI = dyn_cast<LoadInst>(I))
 644     return LI->isUnordered();
 645   else if (const StoreInst *SI = dyn_cast<StoreInst>(I))
 646     return SI->isUnordered();
 647   return false;
 648 }
 649
 650
 651 static
 652 Value *getPointerOperand(Instruction *I) {
 653   if (LoadInst *LI = dyn_cast<LoadInst>(I))
 654     return LI->getPointerOperand();
 655   if (StoreInst *SI = dyn_cast<StoreInst>(I))
 656     return SI->getPointerOperand();
 657   llvm_unreachable("Value is not load or store instruction");
 658   return nullptr;
 659 }
 660
 661
 662 // Examines the loop nesting of the Src and Dst
 663 // instructions and establishes their shared loops. Sets the variables
 664 // CommonLevels, SrcLevels, and MaxLevels.
 665 // The source and destination instructions needn't be contained in the same
 666 // loop. The routine establishNestingLevels finds the level of most deeply
 667 // nested loop that contains them both, CommonLevels. An instruction that's
 668 // not contained in a loop is at level = 0. MaxLevels is equal to the level
 669 // of the source plus the level of the destination, minus CommonLevels.
 670 // This lets us allocate vectors MaxLevels in length, with room for every
 671 // distinct loop referenced in both the source and destination subscripts.
 672 // The variable SrcLevels is the nesting depth of the source instruction.
 673 // It's used to help calculate distinct loops referenced by the destination.
 674 // Here's the map from loops to levels:
 675 //            0 - unused
 676 //            1 - outermost common loop
 677 //          ... - other common loops
 678 // CommonLevels - innermost common loop
 679 //          ... - loops containing Src but not Dst
 680 //    SrcLevels - innermost loop containing Src but not Dst
 681 //          ... - loops containing Dst but not Src
 682 //    MaxLevels - innermost loops containing Dst but not Src
 683 // Consider the follow code fragment:
 684 //   for (a = ...) {
 685 //     for (b = ...) {
 686 //       for (c = ...) {
 687 //         for (d = ...) {
 688 //           A[] = ...;
 689 //         }
 690 //       }
 691 //       for (e = ...) {
 692 //         for (f = ...) {
 693 //           for (g = ...) {
 694 //             ... = A[];
 695 //           }
 696 //         }
 697 //       }
 698 //     }
 699 //   }
 700 // If we're looking at the possibility of a dependence between the store
 701 // to A (the Src) and the load from A (the Dst), we'll note that they
 702 // have 2 loops in common, so CommonLevels will equal 2 and the direction
 703 // vector for Result will have 2 entries. SrcLevels = 4 and MaxLevels = 7.
 704 // A map from loop names to loop numbers would look like
 705 //     a - 1
 706 //     b - 2 = CommonLevels
 707 //     c - 3
 708 //     d - 4 = SrcLevels
 709 //     e - 5
 710 //     f - 6
 711 //     g - 7 = MaxLevels
 712 void DependenceAnalysis::establishNestingLevels(const Instruction *Src,
 713                                                 const Instruction *Dst) {
 714   const BasicBlock *SrcBlock = Src->getParent();
 715   const BasicBlock *DstBlock = Dst->getParent();
 716   unsigned SrcLevel = LI->getLoopDepth(SrcBlock);
 717   unsigned DstLevel = LI->getLoopDepth(DstBlock);
 718   const Loop *SrcLoop = LI->getLoopFor(SrcBlock);
 719   const Loop *DstLoop = LI->getLoopFor(DstBlock);
 720   SrcLevels = SrcLevel;
 721   MaxLevels = SrcLevel + DstLevel;
 722   while (SrcLevel > DstLevel) {
 723     SrcLoop = SrcLoop->getParentLoop();
 724     SrcLevel--;
 725   }
 726   while (DstLevel > SrcLevel) {
 727     DstLoop = DstLoop->getParentLoop();
 728     DstLevel--;
 729   }
 730   while (SrcLoop != DstLoop) {
 731     SrcLoop = SrcLoop->getParentLoop();
 732     DstLoop = DstLoop->getParentLoop();
 733     SrcLevel--;
 734   }
 735   CommonLevels = SrcLevel;
 736   MaxLevels -= CommonLevels;
 737 }
 738
 739
 740 // Given one of the loops containing the source, return
 741 // its level index in our numbering scheme.
 742 unsigned DependenceAnalysis::mapSrcLoop(const Loop *SrcLoop) const {
 743   return SrcLoop->getLoopDepth();
 744 }
 745
 746
 747 // Given one of the loops containing the destination,
 748 // return its level index in our numbering scheme.
 749 unsigned DependenceAnalysis::mapDstLoop(const Loop *DstLoop) const {
 750   unsigned D = DstLoop->getLoopDepth();
 751   if (D > CommonLevels)
 752     return D - CommonLevels + SrcLevels;
 753   else
 754     return D;
 755 }
 756
 757
 758 // Returns true if Expression is loop invariant in LoopNest.
 759 bool DependenceAnalysis::isLoopInvariant(const SCEV *Expression,
 760                                          const Loop *LoopNest) const {
 761   if (!LoopNest)
 762     return true;
 763   return SE->isLoopInvariant(Expression, LoopNest) &&
 764     isLoopInvariant(Expression, LoopNest->getParentLoop());
 765 }
 766
 767
 768
 769 // Finds the set of loops from the LoopNest that
 770 // have a level <= CommonLevels and are referred to by the SCEV Expression.
 771 void DependenceAnalysis::collectCommonLoops(const SCEV *Expression,
 772                                             const Loop *LoopNest,
 773                                             SmallBitVector &Loops) const {
 774   while (LoopNest) {
 775     unsigned Level = LoopNest->getLoopDepth();
 776     if (Level <= CommonLevels && !SE->isLoopInvariant(Expression, LoopNest))
 777       Loops.set(Level);
 778     LoopNest = LoopNest->getParentLoop();
 779   }
 780 }
 781
 782 void DependenceAnalysis::unifySubscriptType(ArrayRef<Subscript *> Pairs) {
 783
 784   unsigned widestWidthSeen = 0;
 785   Type *widestType;
 786
 787   // Go through each pair and find the widest bit to which we need
 788   // to extend all of them.
 789   for (unsigned i = 0; i < Pairs.size(); i++) {
 790     const SCEV *Src = Pairs[i]->Src;
 791     const SCEV *Dst = Pairs[i]->Dst;
 792     IntegerType *SrcTy = dyn_cast<IntegerType>(Src->getType());
 793     IntegerType *DstTy = dyn_cast<IntegerType>(Dst->getType());
 794     if (SrcTy == nullptr || DstTy == nullptr) {
 795       assert(SrcTy == DstTy && "This function only unify integer types and "
 796              "expect Src and Dst share the same type "
 797              "otherwise.");
 798       continue;
 799     }
 800     if (SrcTy->getBitWidth() > widestWidthSeen) {
 801       widestWidthSeen = SrcTy->getBitWidth();
 802       widestType = SrcTy;
 803     }
 804     if (DstTy->getBitWidth() > widestWidthSeen) {
 805       widestWidthSeen = DstTy->getBitWidth();
 806       widestType = DstTy;
 807     }
 808   }
 809
 810
 811   assert(widestWidthSeen > 0);
 812
 813   // Now extend each pair to the widest seen.
 814   for (unsigned i = 0; i < Pairs.size(); i++) {
 815     const SCEV *Src = Pairs[i]->Src;
 816     const SCEV *Dst = Pairs[i]->Dst;
 817     IntegerType *SrcTy = dyn_cast<IntegerType>(Src->getType());
 818     IntegerType *DstTy = dyn_cast<IntegerType>(Dst->getType());
 819     if (SrcTy == nullptr || DstTy == nullptr) {
 820       assert(SrcTy == DstTy && "This function only unify integer types and "
 821              "expect Src and Dst share the same type "
 822              "otherwise.");
 823       continue;
 824     }
 825     if (SrcTy->getBitWidth() < widestWidthSeen)
 826       // Sign-extend Src to widestType
 827       Pairs[i]->Src = SE->getSignExtendExpr(Src, widestType);
 828     if (DstTy->getBitWidth() < widestWidthSeen) {
 829       // Sign-extend Dst to widestType
 830       Pairs[i]->Dst = SE->getSignExtendExpr(Dst, widestType);
 831     }
 832   }
 833 }
 834
 835 // removeMatchingExtensions - Examines a subscript pair.
 836 // If the source and destination are identically sign (or zero)
 837 // extended, it strips off the extension in an effect to simplify
 838 // the actual analysis.
 839 void DependenceAnalysis::removeMatchingExtensions(Subscript *Pair) {
 840   const SCEV *Src = Pair->Src;
 841   const SCEV *Dst = Pair->Dst;
 842   if ((isa<SCEVZeroExtendExpr>(Src) && isa<SCEVZeroExtendExpr>(Dst)) ||
 843       (isa<SCEVSignExtendExpr>(Src) && isa<SCEVSignExtendExpr>(Dst))) {
 844     const SCEVCastExpr *SrcCast = cast<SCEVCastExpr>(Src);
 845     const SCEVCastExpr *DstCast = cast<SCEVCastExpr>(Dst);
 846     const SCEV *SrcCastOp = SrcCast->getOperand();
 847     const SCEV *DstCastOp = DstCast->getOperand();
 848     if (SrcCastOp->getType() == DstCastOp->getType()) {
 849       Pair->Src = SrcCastOp;
 850       Pair->Dst = DstCastOp;
 851     }
 852   }
 853 }
 854
 855
 856 // Examine the scev and return true iff it's linear.
 857 // Collect any loops mentioned in the set of "Loops".
 858 bool DependenceAnalysis::checkSrcSubscript(const SCEV *Src,
 859                                            const Loop *LoopNest,
 860                                            SmallBitVector &Loops) {
 861   const SCEVAddRecExpr *AddRec = dyn_cast<SCEVAddRecExpr>(Src);
 862   if (!AddRec)
 863     return isLoopInvariant(Src, LoopNest);
 864   const SCEV *Start = AddRec->getStart();
 865   const SCEV *Step = AddRec->getStepRecurrence(*SE);
 866   const SCEV *UB = SE->getBackedgeTakenCount(AddRec->getLoop());
 867   if (!isa<SCEVCouldNotCompute>(UB)) {
 868     if (SE->getTypeSizeInBits(Start->getType()) <
 869         SE->getTypeSizeInBits(UB->getType())) {
 870       if (!AddRec->getNoWrapFlags())
 871         return false;
 872     }
 873   }
 874   if (!isLoopInvariant(Step, LoopNest))
 875     return false;
 876   Loops.set(mapSrcLoop(AddRec->getLoop()));
 877   return checkSrcSubscript(Start, LoopNest, Loops);
 878 }
 879
 880
 881
 882 // Examine the scev and return true iff it's linear.
 883 // Collect any loops mentioned in the set of "Loops".
 884 bool DependenceAnalysis::checkDstSubscript(const SCEV *Dst,
 885                                            const Loop *LoopNest,
 886                                            SmallBitVector &Loops) {
 887   const SCEVAddRecExpr *AddRec = dyn_cast<SCEVAddRecExpr>(Dst);
 888   if (!AddRec)
 889     return isLoopInvariant(Dst, LoopNest);
 890   const SCEV *Start = AddRec->getStart();
 891   const SCEV *Step = AddRec->getStepRecurrence(*SE);
 892   const SCEV *UB = SE->getBackedgeTakenCount(AddRec->getLoop());
 893   if (!isa<SCEVCouldNotCompute>(UB)) {
 894     if (SE->getTypeSizeInBits(Start->getType()) <
 895         SE->getTypeSizeInBits(UB->getType())) {
 896       if (!AddRec->getNoWrapFlags())
 897         return false;
 898     }
 899   }
 900   if (!isLoopInvariant(Step, LoopNest))
 901     return false;
 902   Loops.set(mapDstLoop(AddRec->getLoop()));
 903   return checkDstSubscript(Start, LoopNest, Loops);
 904 }
 905
 906
 907 // Examines the subscript pair (the Src and Dst SCEVs)
 908 // and classifies it as either ZIV, SIV, RDIV, MIV, or Nonlinear.
 909 // Collects the associated loops in a set.
 910 DependenceAnalysis::Subscript::ClassificationKind
 911 DependenceAnalysis::classifyPair(const SCEV *Src, const Loop *SrcLoopNest,
 912                                  const SCEV *Dst, const Loop *DstLoopNest,
 913                                  SmallBitVector &Loops) {
 914   SmallBitVector SrcLoops(MaxLevels + 1);
 915   SmallBitVector DstLoops(MaxLevels + 1);
 916   if (!checkSrcSubscript(Src, SrcLoopNest, SrcLoops))
 917     return Subscript::NonLinear;
 918   if (!checkDstSubscript(Dst, DstLoopNest, DstLoops))
 919     return Subscript::NonLinear;
 920   Loops = SrcLoops;
 921   Loops |= DstLoops;
 922   unsigned N = Loops.count();
 923   if (N == 0)
 924     return Subscript::ZIV;
 925   if (N == 1)
 926     return Subscript::SIV;
 927   if (N == 2 && (SrcLoops.count() == 0 ||
 928                  DstLoops.count() == 0 ||
 929                  (SrcLoops.count() == 1 && DstLoops.count() == 1)))
 930     return Subscript::RDIV;
 931   return Subscript::MIV;
 932 }
 933
 934
 935 // A wrapper around SCEV::isKnownPredicate.
 936 // Looks for cases where we're interested in comparing for equality.
 937 // If both X and Y have been identically sign or zero extended,
 938 // it strips off the (confusing) extensions before invoking
 939 // SCEV::isKnownPredicate. Perhaps, someday, the ScalarEvolution package
 940 // will be similarly updated.
 941 //
 942 // If SCEV::isKnownPredicate can't prove the predicate,
 943 // we try simple subtraction, which seems to help in some cases
 944 // involving symbolics.
 945 bool DependenceAnalysis::isKnownPredicate(ICmpInst::Predicate Pred,
 946                                           const SCEV *X,
 947                                           const SCEV *Y) const {
 948   if (Pred == CmpInst::ICMP_EQ ||
 949       Pred == CmpInst::ICMP_NE) {
 950     if ((isa<SCEVSignExtendExpr>(X) &&
 951          isa<SCEVSignExtendExpr>(Y)) ||
 952         (isa<SCEVZeroExtendExpr>(X) &&
 953          isa<SCEVZeroExtendExpr>(Y))) {
 954       const SCEVCastExpr *CX = cast<SCEVCastExpr>(X);
 955       const SCEVCastExpr *CY = cast<SCEVCastExpr>(Y);
 956       const SCEV *Xop = CX->getOperand();
 957       const SCEV *Yop = CY->getOperand();
 958       if (Xop->getType() == Yop->getType()) {
 959         X = Xop;
 960         Y = Yop;
 961       }
 962     }
 963   }
 964   if (SE->isKnownPredicate(Pred, X, Y))
 965     return true;
 966   // If SE->isKnownPredicate can't prove the condition,
 967   // we try the brute-force approach of subtracting
 968   // and testing the difference.
 969   // By testing with SE->isKnownPredicate first, we avoid
 970   // the possibility of overflow when the arguments are constants.
 971   const SCEV *Delta = SE->getMinusSCEV(X, Y);
 972   switch (Pred) {
 973   case CmpInst::ICMP_EQ:
 974     return Delta->isZero();
 975   case CmpInst::ICMP_NE:
 976     return SE->isKnownNonZero(Delta);
 977   case CmpInst::ICMP_SGE:
 978     return SE->isKnownNonNegative(Delta);
 979   case CmpInst::ICMP_SLE:
 980     return SE->isKnownNonPositive(Delta);
 981   case CmpInst::ICMP_SGT:
 982     return SE->isKnownPositive(Delta);
 983   case CmpInst::ICMP_SLT:
 984     return SE->isKnownNegative(Delta);
 985   default:
 986     llvm_unreachable("unexpected predicate in isKnownPredicate");
 987   }
 988 }
 989
 990
 991 // All subscripts are all the same type.
 992 // Loop bound may be smaller (e.g., a char).
 993 // Should zero extend loop bound, since it's always >= 0.
 994 // This routine collects upper bound and extends or truncates if needed.
 995 // Truncating is safe when subscripts are known not to wrap. Cases without
 996 // nowrap flags should have been rejected earlier.
 997 // Return null if no bound available.
 998 const SCEV *DependenceAnalysis::collectUpperBound(const Loop *L,
 999                                                   Type *T) const {
1000   if (SE->hasLoopInvariantBackedgeTakenCount(L)) {
1001     const SCEV *UB = SE->getBackedgeTakenCount(L);
1002     return SE->getTruncateOrZeroExtend(UB, T);
1003   }
1004   return nullptr;
1005 }
1006
1007
1008 // Calls collectUpperBound(), then attempts to cast it to SCEVConstant.
1009 // If the cast fails, returns NULL.
1010 const SCEVConstant *DependenceAnalysis::collectConstantUpperBound(const Loop *L,
1011                                                                   Type *T
1012                                                                   ) const {
1013   if (const SCEV *UB = collectUpperBound(L, T))
1014     return dyn_cast<SCEVConstant>(UB);
1015   return nullptr;
1016 }
1017
1018
1019 // testZIV -
1020 // When we have a pair of subscripts of the form [c1] and [c2],
1021 // where c1 and c2 are both loop invariant, we attack it using
1022 // the ZIV test. Basically, we test by comparing the two values,
1023 // but there are actually three possible results:
1024 // 1) the values are equal, so there's a dependence
1025 // 2) the values are different, so there's no dependence
1026 // 3) the values might be equal, so we have to assume a dependence.
1027 //
1028 // Return true if dependence disproved.
1029 bool DependenceAnalysis::testZIV(const SCEV *Src,
1030                                  const SCEV *Dst,
1031                                  FullDependence &Result) const {
1032   DEBUG(dbgs() << "    src = " << *Src << "\n");
1033   DEBUG(dbgs() << "    dst = " << *Dst << "\n");
1034   ++ZIVapplications;
1035   if (isKnownPredicate(CmpInst::ICMP_EQ, Src, Dst)) {
1036     DEBUG(dbgs() << "    provably dependent\n");
1037     return false; // provably dependent
1038   }
1039   if (isKnownPredicate(CmpInst::ICMP_NE, Src, Dst)) {
1040     DEBUG(dbgs() << "    provably independent\n");
1041     ++ZIVindependence;
1042     return true; // provably independent
1043   }
1044   DEBUG(dbgs() << "    possibly dependent\n");
1045   Result.Consistent = false;
1046   return false; // possibly dependent
1047 }
1048
1049
1050 // strongSIVtest -
1051 // From the paper, Practical Dependence Testing, Section 4.2.1
1052 //
1053 // When we have a pair of subscripts of the form [c1 + a*i] and [c2 + a*i],
1054 // where i is an induction variable, c1 and c2 are loop invariant,
1055 //  and a is a constant, we can solve it exactly using the Strong SIV test.
1056 //
1057 // Can prove independence. Failing that, can compute distance (and direction).
1058 // In the presence of symbolic terms, we can sometimes make progress.
1059 //
1060 // If there's a dependence,
1061 //
1062 //    c1 + a*i = c2 + a*i'
1063 //
1064 // The dependence distance is
1065 //
1066 //    d = i' - i = (c1 - c2)/a
1067 //
1068 // A dependence only exists if d is an integer and abs(d) <= U, where U is the
1069 // loop's upper bound. If a dependence exists, the dependence direction is
1070 // defined as
1071 //
1072 //                { < if d > 0
1073 //    direction = { = if d = 0
1074 //                { > if d < 0
1075 //
1076 // Return true if dependence disproved.
1077 bool DependenceAnalysis::strongSIVtest(const SCEV *Coeff,
1078                                        const SCEV *SrcConst,
1079                                        const SCEV *DstConst,
1080                                        const Loop *CurLoop,
1081                                        unsigned Level,
1082                                        FullDependence &Result,
1083                                        Constraint &NewConstraint) const {
1084   DEBUG(dbgs() << "\tStrong SIV test\n");
1085   DEBUG(dbgs() << "\t    Coeff = " << *Coeff);
1086   DEBUG(dbgs() << ", " << *Coeff->getType() << "\n");
1087   DEBUG(dbgs() << "\t    SrcConst = " << *SrcConst);
1088   DEBUG(dbgs() << ", " << *SrcConst->getType() << "\n");
1089   DEBUG(dbgs() << "\t    DstConst = " << *DstConst);
1090   DEBUG(dbgs() << ", " << *DstConst->getType() << "\n");
1091   ++StrongSIVapplications;
1092   assert(0 < Level && Level <= CommonLevels && "level out of range");
1093   Level--;
1094
1095   const SCEV *Delta = SE->getMinusSCEV(SrcConst, DstConst);
1096   DEBUG(dbgs() << "\t    Delta = " << *Delta);
1097   DEBUG(dbgs() << ", " << *Delta->getType() << "\n");
1098
1099   // check that |Delta| < iteration count
1100   if (const SCEV *UpperBound = collectUpperBound(CurLoop, Delta->getType())) {
1101     DEBUG(dbgs() << "\t    UpperBound = " << *UpperBound);
1102     DEBUG(dbgs() << ", " << *UpperBound->getType() << "\n");
1103     const SCEV *AbsDelta =
1104       SE->isKnownNonNegative(Delta) ? Delta : SE->getNegativeSCEV(Delta);
1105     const SCEV *AbsCoeff =
1106       SE->isKnownNonNegative(Coeff) ? Coeff : SE->getNegativeSCEV(Coeff);
1107     const SCEV *Product = SE->getMulExpr(UpperBound, AbsCoeff);
1108     if (isKnownPredicate(CmpInst::ICMP_SGT, AbsDelta, Product)) {
1109       // Distance greater than trip count - no dependence
1110       ++StrongSIVindependence;
1111       ++StrongSIVsuccesses;
1112       return true;
1113     }
1114   }
1115
1116   // Can we compute distance?
1117   if (isa<SCEVConstant>(Delta) && isa<SCEVConstant>(Coeff)) {
1118     APInt ConstDelta = cast<SCEVConstant>(Delta)->getAPInt();
1119     APInt ConstCoeff = cast<SCEVConstant>(Coeff)->getAPInt();
1120     APInt Distance  = ConstDelta; // these need to be initialized
1121     APInt Remainder = ConstDelta;
1122     APInt::sdivrem(ConstDelta, ConstCoeff, Distance, Remainder);
1123     DEBUG(dbgs() << "\t    Distance = " << Distance << "\n");
1124     DEBUG(dbgs() << "\t    Remainder = " << Remainder << "\n");
1125     // Make sure Coeff divides Delta exactly
1126     if (Remainder != 0) {
1127       // Coeff doesn't divide Distance, no dependence
1128       ++StrongSIVindependence;
1129       ++StrongSIVsuccesses;
1130       return true;
1131     }
1132     Result.DV[Level].Distance = SE->getConstant(Distance);
1133     NewConstraint.setDistance(SE->getConstant(Distance), CurLoop);
1134     if (Distance.sgt(0))
1135       Result.DV[Level].Direction &= Dependence::DVEntry::LT;
1136     else if (Distance.slt(0))
1137       Result.DV[Level].Direction &= Dependence::DVEntry::GT;
1138     else
1139       Result.DV[Level].Direction &= Dependence::DVEntry::EQ;
1140     ++StrongSIVsuccesses;
1141   }
1142   else if (Delta->isZero()) {
1143     // since 0/X == 0
1144     Result.DV[Level].Distance = Delta;
1145     NewConstraint.setDistance(Delta, CurLoop);
1146     Result.DV[Level].Direction &= Dependence::DVEntry::EQ;
1147     ++StrongSIVsuccesses;
1148   }
1149   else {
1150     if (Coeff->isOne()) {
1151       DEBUG(dbgs() << "\t    Distance = " << *Delta << "\n");
1152       Result.DV[Level].Distance = Delta; // since X/1 == X
1153       NewConstraint.setDistance(Delta, CurLoop);
1154     }
1155     else {
1156       Result.Consistent = false;
1157       NewConstraint.setLine(Coeff,
1158                             SE->getNegativeSCEV(Coeff),
1159                             SE->getNegativeSCEV(Delta), CurLoop);
1160     }
1161
1162     // maybe we can get a useful direction
1163     bool DeltaMaybeZero     = !SE->isKnownNonZero(Delta);
1164     bool DeltaMaybePositive = !SE->isKnownNonPositive(Delta);
1165     bool DeltaMaybeNegative = !SE->isKnownNonNegative(Delta);
1166     bool CoeffMaybePositive = !SE->isKnownNonPositive(Coeff);
1167     bool CoeffMaybeNegative = !SE->isKnownNonNegative(Coeff);
1168     // The double negatives above are confusing.
1169     // It helps to read !SE->isKnownNonZero(Delta)
1170     // as "Delta might be Zero"
1171     unsigned NewDirection = Dependence::DVEntry::NONE;
1172     if ((DeltaMaybePositive && CoeffMaybePositive) ||
1173         (DeltaMaybeNegative && CoeffMaybeNegative))
1174       NewDirection = Dependence::DVEntry::LT;
1175     if (DeltaMaybeZero)
1176       NewDirection |= Dependence::DVEntry::EQ;
1177     if ((DeltaMaybeNegative && CoeffMaybePositive) ||
1178         (DeltaMaybePositive && CoeffMaybeNegative))
1179       NewDirection |= Dependence::DVEntry::GT;
1180     if (NewDirection < Result.DV[Level].Direction)
1181       ++StrongSIVsuccesses;
1182     Result.DV[Level].Direction &= NewDirection;
1183   }
1184   return false;
1185 }
1186
1187
1188 // weakCrossingSIVtest -
1189 // From the paper, Practical Dependence Testing, Section 4.2.2
1190 //
1191 // When we have a pair of subscripts of the form [c1 + a*i] and [c2 - a*i],
1192 // where i is an induction variable, c1 and c2 are loop invariant,
1193 // and a is a constant, we can solve it exactly using the
1194 // Weak-Crossing SIV test.
1195 //
1196 // Given c1 + a*i = c2 - a*i', we can look for the intersection of
1197 // the two lines, where i = i', yielding
1198 //
1199 //    c1 + a*i = c2 - a*i
1200 //    2a*i = c2 - c1
1201 //    i = (c2 - c1)/2a
1202 //
1203 // If i < 0, there is no dependence.
1204 // If i > upperbound, there is no dependence.
1205 // If i = 0 (i.e., if c1 = c2), there's a dependence with distance = 0.
1206 // If i = upperbound, there's a dependence with distance = 0.
1207 // If i is integral, there's a dependence (all directions).
1208 // If the non-integer part = 1/2, there's a dependence (<> directions).
1209 // Otherwise, there's no dependence.
1210 //
1211 // Can prove independence. Failing that,
1212 // can sometimes refine the directions.
1213 // Can determine iteration for splitting.
1214 //
1215 // Return true if dependence disproved.
1216 bool DependenceAnalysis::weakCrossingSIVtest(const SCEV *Coeff,
1217                                              const SCEV *SrcConst,
1218                                              const SCEV *DstConst,
1219                                              const Loop *CurLoop,
1220                                              unsigned Level,
1221                                              FullDependence &Result,
1222                                              Constraint &NewConstraint,
1223                                              const SCEV *&SplitIter) const {
1224   DEBUG(dbgs() << "\tWeak-Crossing SIV test\n");
1225   DEBUG(dbgs() << "\t    Coeff = " << *Coeff << "\n");
1226   DEBUG(dbgs() << "\t    SrcConst = " << *SrcConst << "\n");
1227   DEBUG(dbgs() << "\t    DstConst = " << *DstConst << "\n");
1228   ++WeakCrossingSIVapplications;
1229   assert(0 < Level && Level <= CommonLevels && "Level out of range");
1230   Level--;
1231   Result.Consistent = false;
1232   const SCEV *Delta = SE->getMinusSCEV(DstConst, SrcConst);
1233   DEBUG(dbgs() << "\t    Delta = " << *Delta << "\n");
1234   NewConstraint.setLine(Coeff, Coeff, Delta, CurLoop);
1235   if (Delta->isZero()) {
1236     Result.DV[Level].Direction &= unsigned(~Dependence::DVEntry::LT);
1237     Result.DV[Level].Direction &= unsigned(~Dependence::DVEntry::GT);
1238     ++WeakCrossingSIVsuccesses;
1239     if (!Result.DV[Level].Direction) {
1240       ++WeakCrossingSIVindependence;
1241       return true;
1242     }
1243     Result.DV[Level].Distance = Delta; // = 0
1244     return false;
1245   }
1246   const SCEVConstant *ConstCoeff = dyn_cast<SCEVConstant>(Coeff);
1247   if (!ConstCoeff)
1248     return false;
1249
1250   Result.DV[Level].Splitable = true;
1251   if (SE->isKnownNegative(ConstCoeff)) {
1252     ConstCoeff = dyn_cast<SCEVConstant>(SE->getNegativeSCEV(ConstCoeff));
1253     assert(ConstCoeff &&
1254            "dynamic cast of negative of ConstCoeff should yield constant");
1255     Delta = SE->getNegativeSCEV(Delta);
1256   }
1257   assert(SE->isKnownPositive(ConstCoeff) && "ConstCoeff should be positive");
1258
1259   // compute SplitIter for use by DependenceAnalysis::getSplitIteration()
1260   SplitIter = SE->getUDivExpr(
1261       SE->getSMaxExpr(SE->getZero(Delta->getType()), Delta),
1262       SE->getMulExpr(SE->getConstant(Delta->getType(), 2), ConstCoeff));
1263   DEBUG(dbgs() << "\t    Split iter = " << *SplitIter << "\n");
1264
1265   const SCEVConstant *ConstDelta = dyn_cast<SCEVConstant>(Delta);
1266   if (!ConstDelta)
1267     return false;
1268
1269   // We're certain that ConstCoeff > 0; therefore,
1270   // if Delta < 0, then no dependence.
1271   DEBUG(dbgs() << "\t    Delta = " << *Delta << "\n");
1272   DEBUG(dbgs() << "\t    ConstCoeff = " << *ConstCoeff << "\n");
1273   if (SE->isKnownNegative(Delta)) {
1274     // No dependence, Delta < 0
1275     ++WeakCrossingSIVindependence;
1276     ++WeakCrossingSIVsuccesses;
1277     return true;
1278   }
1279
1280   // We're certain that Delta > 0 and ConstCoeff > 0.
1281   // Check Delta/(2*ConstCoeff) against upper loop bound
1282   if (const SCEV *UpperBound = collectUpperBound(CurLoop, Delta->getType())) {
1283     DEBUG(dbgs() << "\t    UpperBound = " << *UpperBound << "\n");
1284     const SCEV *ConstantTwo = SE->getConstant(UpperBound->getType(), 2);
1285     const SCEV *ML = SE->getMulExpr(SE->getMulExpr(ConstCoeff, UpperBound),
1286                                     ConstantTwo);
1287     DEBUG(dbgs() << "\t    ML = " << *ML << "\n");
1288     if (isKnownPredicate(CmpInst::ICMP_SGT, Delta, ML)) {
1289       // Delta too big, no dependence
1290       ++WeakCrossingSIVindependence;
1291       ++WeakCrossingSIVsuccesses;
1292       return true;
1293     }
1294     if (isKnownPredicate(CmpInst::ICMP_EQ, Delta, ML)) {
1295       // i = i' = UB
1296       Result.DV[Level].Direction &= unsigned(~Dependence::DVEntry::LT);
1297       Result.DV[Level].Direction &= unsigned(~Dependence::DVEntry::GT);
1298       ++WeakCrossingSIVsuccesses;
1299       if (!Result.DV[Level].Direction) {
1300         ++WeakCrossingSIVindependence;
1301         return true;
1302       }
1303       Result.DV[Level].Splitable = false;
1304       Result.DV[Level].Distance = SE->getZero(Delta->getType());
1305       return false;
1306     }
1307   }
1308
1309   // check that Coeff divides Delta
1310   APInt APDelta = ConstDelta->getAPInt();
1311   APInt APCoeff = ConstCoeff->getAPInt();
1312   APInt Distance = APDelta; // these need to be initialzed
1313   APInt Remainder = APDelta;
1314   APInt::sdivrem(APDelta, APCoeff, Distance, Remainder);
1315   DEBUG(dbgs() << "\t    Remainder = " << Remainder << "\n");
1316   if (Remainder != 0) {
1317     // Coeff doesn't divide Delta, no dependence
1318     ++WeakCrossingSIVindependence;
1319     ++WeakCrossingSIVsuccesses;
1320     return true;
1321   }
1322   DEBUG(dbgs() << "\t    Distance = " << Distance << "\n");
1323
1324   // if 2*Coeff doesn't divide Delta, then the equal direction isn't possible
1325   APInt Two = APInt(Distance.getBitWidth(), 2, true);
1326   Remainder = Distance.srem(Two);
1327   DEBUG(dbgs() << "\t    Remainder = " << Remainder << "\n");
1328   if (Remainder != 0) {
1329     // Equal direction isn't possible
1330     Result.DV[Level].Direction &= unsigned(~Dependence::DVEntry::EQ);
1331     ++WeakCrossingSIVsuccesses;
1332   }
1333   return false;
1334 }
1335
1336
1337 // Kirch's algorithm, from
1338 //
1339 //        Optimizing Supercompilers for Supercomputers
1340 //        Michael Wolfe
1341 //        MIT Press, 1989
1342 //
1343 // Program 2.1, page 29.
1344 // Computes the GCD of AM and BM.
1345 // Also finds a solution to the equation ax - by = gcd(a, b).
1346 // Returns true if dependence disproved; i.e., gcd does not divide Delta.
1347 static
1348 bool findGCD(unsigned Bits, APInt AM, APInt BM, APInt Delta,
1349              APInt &G, APInt &X, APInt &Y) {
1350   APInt A0(Bits, 1, true), A1(Bits, 0, true);
1351   APInt B0(Bits, 0, true), B1(Bits, 1, true);
1352   APInt G0 = AM.abs();
1353   APInt G1 = BM.abs();
1354   APInt Q = G0; // these need to be initialized
1355   APInt R = G0;
1356   APInt::sdivrem(G0, G1, Q, R);
1357   while (R != 0) {
1358     APInt A2 = A0 - Q*A1; A0 = A1; A1 = A2;
1359     APInt B2 = B0 - Q*B1; B0 = B1; B1 = B2;
1360     G0 = G1; G1 = R;
1361     APInt::sdivrem(G0, G1, Q, R);
1362   }
1363   G = G1;
1364   DEBUG(dbgs() << "\t    GCD = " << G << "\n");
1365   X = AM.slt(0) ? -A1 : A1;
1366   Y = BM.slt(0) ? B1 : -B1;
1367
1368   // make sure gcd divides Delta
1369   R = Delta.srem(G);
1370   if (R != 0)
1371     return true; // gcd doesn't divide Delta, no dependence
1372   Q = Delta.sdiv(G);
1373   X *= Q;
1374   Y *= Q;
1375   return false;
1376 }
1377
1378
1379 static
1380 APInt floorOfQuotient(APInt A, APInt B) {
1381   APInt Q = A; // these need to be initialized
1382   APInt R = A;
1383   APInt::sdivrem(A, B, Q, R);
1384   if (R == 0)
1385     return Q;
1386   if ((A.sgt(0) && B.sgt(0)) ||
1387       (A.slt(0) && B.slt(0)))
1388     return Q;
1389   else
1390     return Q - 1;
1391 }
1392
1393
1394 static
1395 APInt ceilingOfQuotient(APInt A, APInt B) {
1396   APInt Q = A; // these need to be initialized
1397   APInt R = A;
1398   APInt::sdivrem(A, B, Q, R);
1399   if (R == 0)
1400     return Q;
1401   if ((A.sgt(0) && B.sgt(0)) ||
1402       (A.slt(0) && B.slt(0)))
1403     return Q + 1;
1404   else
1405     return Q;
1406 }
1407
1408
1409 static
1410 APInt maxAPInt(APInt A, APInt B) {
1411   return A.sgt(B) ? A : B;
1412 }
1413
1414
1415 static
1416 APInt minAPInt(APInt A, APInt B) {
1417   return A.slt(B) ? A : B;
1418 }
1419
1420
1421 // exactSIVtest -
1422 // When we have a pair of subscripts of the form [c1 + a1*i] and [c2 + a2*i],
1423 // where i is an induction variable, c1 and c2 are loop invariant, and a1
1424 // and a2 are constant, we can solve it exactly using an algorithm developed
1425 // by Banerjee and Wolfe. See Section 2.5.3 in
1426 //
1427 //        Optimizing Supercompilers for Supercomputers
1428 //        Michael Wolfe
1429 //        MIT Press, 1989
1430 //
1431 // It's slower than the specialized tests (strong SIV, weak-zero SIV, etc),
1432 // so use them if possible. They're also a bit better with symbolics and,
1433 // in the case of the strong SIV test, can compute Distances.
1434 //
1435 // Return true if dependence disproved.
1436 bool DependenceAnalysis::exactSIVtest(const SCEV *SrcCoeff,
1437                                       const SCEV *DstCoeff,
1438                                       const SCEV *SrcConst,
1439                                       const SCEV *DstConst,
1440                                       const Loop *CurLoop,
1441                                       unsigned Level,
1442                                       FullDependence &Result,
1443                                       Constraint &NewConstraint) const {
1444   DEBUG(dbgs() << "\tExact SIV test\n");
1445   DEBUG(dbgs() << "\t    SrcCoeff = " << *SrcCoeff << " = AM\n");
1446   DEBUG(dbgs() << "\t    DstCoeff = " << *DstCoeff << " = BM\n");
1447   DEBUG(dbgs() << "\t    SrcConst = " << *SrcConst << "\n");
1448   DEBUG(dbgs() << "\t    DstConst = " << *DstConst << "\n");
1449   ++ExactSIVapplications;
1450   assert(0 < Level && Level <= CommonLevels && "Level out of range");
1451   Level--;
1452   Result.Consistent = false;
1453   const SCEV *Delta = SE->getMinusSCEV(DstConst, SrcConst);
1454   DEBUG(dbgs() << "\t    Delta = " << *Delta << "\n");
1455   NewConstraint.setLine(SrcCoeff, SE->getNegativeSCEV(DstCoeff),
1456                         Delta, CurLoop);
1457   const SCEVConstant *ConstDelta = dyn_cast<SCEVConstant>(Delta);
1458   const SCEVConstant *ConstSrcCoeff = dyn_cast<SCEVConstant>(SrcCoeff);
1459   const SCEVConstant *ConstDstCoeff = dyn_cast<SCEVConstant>(DstCoeff);
1460   if (!ConstDelta || !ConstSrcCoeff || !ConstDstCoeff)
1461     return false;
1462
1463   // find gcd
1464   APInt G, X, Y;
1465   APInt AM = ConstSrcCoeff->getAPInt();
1466   APInt BM = ConstDstCoeff->getAPInt();
1467   unsigned Bits = AM.getBitWidth();
1468   if (findGCD(Bits, AM, BM, ConstDelta->getAPInt(), G, X, Y)) {
1469     // gcd doesn't divide Delta, no dependence
1470     ++ExactSIVindependence;
1471     ++ExactSIVsuccesses;
1472     return true;
1473   }
1474
1475   DEBUG(dbgs() << "\t    X = " << X << ", Y = " << Y << "\n");
1476
1477   // since SCEV construction normalizes, LM = 0
1478   APInt UM(Bits, 1, true);
1479   bool UMvalid = false;
1480   // UM is perhaps unavailable, let's check
1481   if (const SCEVConstant *CUB =
1482       collectConstantUpperBound(CurLoop, Delta->getType())) {
1483     UM = CUB->getAPInt();
1484     DEBUG(dbgs() << "\t    UM = " << UM << "\n");
1485     UMvalid = true;
1486   }
1487
1488   APInt TU(APInt::getSignedMaxValue(Bits));
1489   APInt TL(APInt::getSignedMinValue(Bits));
1490
1491   // test(BM/G, LM-X) and test(-BM/G, X-UM)
1492   APInt TMUL = BM.sdiv(G);
1493   if (TMUL.sgt(0)) {
1494     TL = maxAPInt(TL, ceilingOfQuotient(-X, TMUL));
1495     DEBUG(dbgs() << "\t    TL = " << TL << "\n");
1496     if (UMvalid) {
1497       TU = minAPInt(TU, floorOfQuotient(UM - X, TMUL));
1498       DEBUG(dbgs() << "\t    TU = " << TU << "\n");
1499     }
1500   }
1501   else {
1502     TU = minAPInt(TU, floorOfQuotient(-X, TMUL));
1503     DEBUG(dbgs() << "\t    TU = " << TU << "\n");
1504     if (UMvalid) {
1505       TL = maxAPInt(TL, ceilingOfQuotient(UM - X, TMUL));
1506       DEBUG(dbgs() << "\t    TL = " << TL << "\n");
1507     }
1508   }
1509
1510   // test(AM/G, LM-Y) and test(-AM/G, Y-UM)
1511   TMUL = AM.sdiv(G);
1512   if (TMUL.sgt(0)) {
1513     TL = maxAPInt(TL, ceilingOfQuotient(-Y, TMUL));
1514     DEBUG(dbgs() << "\t    TL = " << TL << "\n");
1515     if (UMvalid) {
1516       TU = minAPInt(TU, floorOfQuotient(UM - Y, TMUL));
1517       DEBUG(dbgs() << "\t    TU = " << TU << "\n");
1518     }
1519   }
1520   else {
1521     TU = minAPInt(TU, floorOfQuotient(-Y, TMUL));
1522     DEBUG(dbgs() << "\t    TU = " << TU << "\n");
1523     if (UMvalid) {
1524       TL = maxAPInt(TL, ceilingOfQuotient(UM - Y, TMUL));
1525       DEBUG(dbgs() << "\t    TL = " << TL << "\n");
1526     }
1527   }
1528   if (TL.sgt(TU)) {
1529     ++ExactSIVindependence;
1530     ++ExactSIVsuccesses;
1531     return true;
1532   }
1533
1534   // explore directions
1535   unsigned NewDirection = Dependence::DVEntry::NONE;
1536
1537   // less than
1538   APInt SaveTU(TU); // save these
1539   APInt SaveTL(TL);
1540   DEBUG(dbgs() << "\t    exploring LT direction\n");
1541   TMUL = AM - BM;
1542   if (TMUL.sgt(0)) {
1543     TL = maxAPInt(TL, ceilingOfQuotient(X - Y + 1, TMUL));
1544     DEBUG(dbgs() << "\t\t    TL = " << TL << "\n");
1545   }
1546   else {
1547     TU = minAPInt(TU, floorOfQuotient(X - Y + 1, TMUL));
1548     DEBUG(dbgs() << "\t\t    TU = " << TU << "\n");
1549   }
1550   if (TL.sle(TU)) {
1551     NewDirection |= Dependence::DVEntry::LT;
1552     ++ExactSIVsuccesses;
1553   }
1554
1555   // equal
1556   TU = SaveTU; // restore
1557   TL = SaveTL;
1558   DEBUG(dbgs() << "\t    exploring EQ direction\n");
1559   if (TMUL.sgt(0)) {
1560     TL = maxAPInt(TL, ceilingOfQuotient(X - Y, TMUL));
1561     DEBUG(dbgs() << "\t\t    TL = " << TL << "\n");
1562   }
1563   else {
1564     TU = minAPInt(TU, floorOfQuotient(X - Y, TMUL));
1565     DEBUG(dbgs() << "\t\t    TU = " << TU << "\n");
1566   }
1567   TMUL = BM - AM;
1568   if (TMUL.sgt(0)) {
1569     TL = maxAPInt(TL, ceilingOfQuotient(Y - X, TMUL));
1570     DEBUG(dbgs() << "\t\t    TL = " << TL << "\n");
1571   }
1572   else {
1573     TU = minAPInt(TU, floorOfQuotient(Y - X, TMUL));
1574     DEBUG(dbgs() << "\t\t    TU = " << TU << "\n");
1575   }
1576   if (TL.sle(TU)) {
1577     NewDirection |= Dependence::DVEntry::EQ;
1578     ++ExactSIVsuccesses;
1579   }
1580
1581   // greater than
1582   TU = SaveTU; // restore
1583   TL = SaveTL;
1584   DEBUG(dbgs() << "\t    exploring GT direction\n");
1585   if (TMUL.sgt(0)) {
1586     TL = maxAPInt(TL, ceilingOfQuotient(Y - X + 1, TMUL));
1587     DEBUG(dbgs() << "\t\t    TL = " << TL << "\n");
1588   }
1589   else {
1590     TU = minAPInt(TU, floorOfQuotient(Y - X + 1, TMUL));
1591     DEBUG(dbgs() << "\t\t    TU = " << TU << "\n");
1592   }
1593   if (TL.sle(TU)) {
1594     NewDirection |= Dependence::DVEntry::GT;
1595     ++ExactSIVsuccesses;
1596   }
1597
1598   // finished
1599   Result.DV[Level].Direction &= NewDirection;
1600   if (Result.DV[Level].Direction == Dependence::DVEntry::NONE)
1601     ++ExactSIVindependence;
1602   return Result.DV[Level].Direction == Dependence::DVEntry::NONE;
1603 }
1604
1605
1606
1607 // Return true if the divisor evenly divides the dividend.
1608 static
1609 bool isRemainderZero(const SCEVConstant *Dividend,
1610                      const SCEVConstant *Divisor) {
1611   APInt ConstDividend = Dividend->getAPInt();
1612   APInt ConstDivisor = Divisor->getAPInt();
1613   return ConstDividend.srem(ConstDivisor) == 0;
1614 }
1615
1616
1617 // weakZeroSrcSIVtest -
1618 // From the paper, Practical Dependence Testing, Section 4.2.2
1619 //
1620 // When we have a pair of subscripts of the form [c1] and [c2 + a*i],
1621 // where i is an induction variable, c1 and c2 are loop invariant,
1622 // and a is a constant, we can solve it exactly using the
1623 // Weak-Zero SIV test.
1624 //
1625 // Given
1626 //
1627 //    c1 = c2 + a*i
1628 //
1629 // we get
1630 //
1631 //    (c1 - c2)/a = i
1632 //
1633 // If i is not an integer, there's no dependence.
1634 // If i < 0 or > UB, there's no dependence.
1635 // If i = 0, the direction is <= and peeling the
1636 // 1st iteration will break the dependence.
1637 // If i = UB, the direction is >= and peeling the
1638 // last iteration will break the dependence.
1639 // Otherwise, the direction is *.
1640 //
1641 // Can prove independence. Failing that, we can sometimes refine
1642 // the directions. Can sometimes show that first or last
1643 // iteration carries all the dependences (so worth peeling).
1644 //
1645 // (see also weakZeroDstSIVtest)
1646 //
1647 // Return true if dependence disproved.
1648 bool DependenceAnalysis::weakZeroSrcSIVtest(const SCEV *DstCoeff,
1649                                             const SCEV *SrcConst,
1650                                             const SCEV *DstConst,
1651                                             const Loop *CurLoop,
1652                                             unsigned Level,
1653                                             FullDependence &Result,
1654                                             Constraint &NewConstraint) const {
1655   // For the WeakSIV test, it's possible the loop isn't common to
1656   // the Src and Dst loops. If it isn't, then there's no need to
1657   // record a direction.
1658   DEBUG(dbgs() << "\tWeak-Zero (src) SIV test\n");
1659   DEBUG(dbgs() << "\t    DstCoeff = " << *DstCoeff << "\n");
1660   DEBUG(dbgs() << "\t    SrcConst = " << *SrcConst << "\n");
1661   DEBUG(dbgs() << "\t    DstConst = " << *DstConst << "\n");
1662   ++WeakZeroSIVapplications;
1663   assert(0 < Level && Level <= MaxLevels && "Level out of range");
1664   Level--;
1665   Result.Consistent = false;
1666   const SCEV *Delta = SE->getMinusSCEV(SrcConst, DstConst);
1667   NewConstraint.setLine(SE->getZero(Delta->getType()), DstCoeff, Delta,
1668                         CurLoop);
1669   DEBUG(dbgs() << "\t    Delta = " << *Delta << "\n");
1670   if (isKnownPredicate(CmpInst::ICMP_EQ, SrcConst, DstConst)) {
1671     if (Level < CommonLevels) {
1672       Result.DV[Level].Direction &= Dependence::DVEntry::LE;
1673       Result.DV[Level].PeelFirst = true;
1674       ++WeakZeroSIVsuccesses;
1675     }
1676     return false; // dependences caused by first iteration
1677   }
1678   const SCEVConstant *ConstCoeff = dyn_cast<SCEVConstant>(DstCoeff);
1679   if (!ConstCoeff)
1680     return false;
1681   const SCEV *AbsCoeff =
1682     SE->isKnownNegative(ConstCoeff) ?
1683     SE->getNegativeSCEV(ConstCoeff) : ConstCoeff;
1684   const SCEV *NewDelta =
1685     SE->isKnownNegative(ConstCoeff) ? SE->getNegativeSCEV(Delta) : Delta;
1686
1687   // check that Delta/SrcCoeff < iteration count
1688   // really check NewDelta < count*AbsCoeff
1689   if (const SCEV *UpperBound = collectUpperBound(CurLoop, Delta->getType())) {
1690     DEBUG(dbgs() << "\t    UpperBound = " << *UpperBound << "\n");
1691     const SCEV *Product = SE->getMulExpr(AbsCoeff, UpperBound);
1692     if (isKnownPredicate(CmpInst::ICMP_SGT, NewDelta, Product)) {
1693       ++WeakZeroSIVindependence;
1694       ++WeakZeroSIVsuccesses;
1695       return true;
1696     }
1697     if (isKnownPredicate(CmpInst::ICMP_EQ, NewDelta, Product)) {
1698       // dependences caused by last iteration
1699       if (Level < CommonLevels) {
1700         Result.DV[Level].Direction &= Dependence::DVEntry::GE;
1701         Result.DV[Level].PeelLast = true;
1702         ++WeakZeroSIVsuccesses;
1703       }
1704       return false;
1705     }
1706   }
1707
1708   // check that Delta/SrcCoeff >= 0
1709   // really check that NewDelta >= 0
1710   if (SE->isKnownNegative(NewDelta)) {
1711     // No dependence, newDelta < 0
1712     ++WeakZeroSIVindependence;
1713     ++WeakZeroSIVsuccesses;
1714     return true;
1715   }
1716
1717   // if SrcCoeff doesn't divide Delta, then no dependence
1718   if (isa<SCEVConstant>(Delta) &&
1719       !isRemainderZero(cast<SCEVConstant>(Delta), ConstCoeff)) {
1720     ++WeakZeroSIVindependence;
1721     ++WeakZeroSIVsuccesses;
1722     return true;
1723   }
1724   return false;
1725 }
1726
1727
1728 // weakZeroDstSIVtest -
1729 // From the paper, Practical Dependence Testing, Section 4.2.2
1730 //
1731 // When we have a pair of subscripts of the form [c1 + a*i] and [c2],
1732 // where i is an induction variable, c1 and c2 are loop invariant,
1733 // and a is a constant, we can solve it exactly using the
1734 // Weak-Zero SIV test.
1735 //
1736 // Given
1737 //
1738 //    c1 + a*i = c2
1739 //
1740 // we get
1741 //
1742 //    i = (c2 - c1)/a
1743 //
1744 // If i is not an integer, there's no dependence.
1745 // If i < 0 or > UB, there's no dependence.
1746 // If i = 0, the direction is <= and peeling the
1747 // 1st iteration will break the dependence.
1748 // If i = UB, the direction is >= and peeling the
1749 // last iteration will break the dependence.
1750 // Otherwise, the direction is *.
1751 //
1752 // Can prove independence. Failing that, we can sometimes refine
1753 // the directions. Can sometimes show that first or last
1754 // iteration carries all the dependences (so worth peeling).
1755 //
1756 // (see also weakZeroSrcSIVtest)
1757 //
1758 // Return true if dependence disproved.
1759 bool DependenceAnalysis::weakZeroDstSIVtest(const SCEV *SrcCoeff,
1760                                             const SCEV *SrcConst,
1761                                             const SCEV *DstConst,
1762                                             const Loop *CurLoop,
1763                                             unsigned Level,
1764                                             FullDependence &Result,
1765                                             Constraint &NewConstraint) const {
1766   // For the WeakSIV test, it's possible the loop isn't common to the
1767   // Src and Dst loops. If it isn't, then there's no need to record a direction.
1768   DEBUG(dbgs() << "\tWeak-Zero (dst) SIV test\n");
1769   DEBUG(dbgs() << "\t    SrcCoeff = " << *SrcCoeff << "\n");
1770   DEBUG(dbgs() << "\t    SrcConst = " << *SrcConst << "\n");
1771   DEBUG(dbgs() << "\t    DstConst = " << *DstConst << "\n");
1772   ++WeakZeroSIVapplications;
1773   assert(0 < Level && Level <= SrcLevels && "Level out of range");
1774   Level--;
1775   Result.Consistent = false;
1776   const SCEV *Delta = SE->getMinusSCEV(DstConst, SrcConst);
1777   NewConstraint.setLine(SrcCoeff, SE->getZero(Delta->getType()), Delta,
1778                         CurLoop);
1779   DEBUG(dbgs() << "\t    Delta = " << *Delta << "\n");
1780   if (isKnownPredicate(CmpInst::ICMP_EQ, DstConst, SrcConst)) {
1781     if (Level < CommonLevels) {
1782       Result.DV[Level].Direction &= Dependence::DVEntry::LE;
1783       Result.DV[Level].PeelFirst = true;
1784       ++WeakZeroSIVsuccesses;
1785     }
1786     return false; // dependences caused by first iteration
1787   }
1788   const SCEVConstant *ConstCoeff = dyn_cast<SCEVConstant>(SrcCoeff);
1789   if (!ConstCoeff)
1790     return false;
1791   const SCEV *AbsCoeff =
1792     SE->isKnownNegative(ConstCoeff) ?
1793     SE->getNegativeSCEV(ConstCoeff) : ConstCoeff;
1794   const SCEV *NewDelta =
1795     SE->isKnownNegative(ConstCoeff) ? SE->getNegativeSCEV(Delta) : Delta;
1796
1797   // check that Delta/SrcCoeff < iteration count
1798   // really check NewDelta < count*AbsCoeff
1799   if (const SCEV *UpperBound = collectUpperBound(CurLoop, Delta->getType())) {
1800     DEBUG(dbgs() << "\t    UpperBound = " << *UpperBound << "\n");
1801     const SCEV *Product = SE->getMulExpr(AbsCoeff, UpperBound);
1802     if (isKnownPredicate(CmpInst::ICMP_SGT, NewDelta, Product)) {
1803       ++WeakZeroSIVindependence;
1804       ++WeakZeroSIVsuccesses;
1805       return true;
1806     }
1807     if (isKnownPredicate(CmpInst::ICMP_EQ, NewDelta, Product)) {
1808       // dependences caused by last iteration
1809       if (Level < CommonLevels) {
1810         Result.DV[Level].Direction &= Dependence::DVEntry::GE;
1811         Result.DV[Level].PeelLast = true;
1812         ++WeakZeroSIVsuccesses;
1813       }
1814       return false;
1815     }
1816   }
1817
1818   // check that Delta/SrcCoeff >= 0
1819   // really check that NewDelta >= 0
1820   if (SE->isKnownNegative(NewDelta)) {
1821     // No dependence, newDelta < 0
1822     ++WeakZeroSIVindependence;
1823     ++WeakZeroSIVsuccesses;
1824     return true;
1825   }
1826
1827   // if SrcCoeff doesn't divide Delta, then no dependence
1828   if (isa<SCEVConstant>(Delta) &&
1829       !isRemainderZero(cast<SCEVConstant>(Delta), ConstCoeff)) {
1830     ++WeakZeroSIVindependence;
1831     ++WeakZeroSIVsuccesses;
1832     return true;
1833   }
1834   return false;
1835 }
1836
1837
1838 // exactRDIVtest - Tests the RDIV subscript pair for dependence.
1839 // Things of the form [c1 + a*i] and [c2 + b*j],
1840 // where i and j are induction variable, c1 and c2 are loop invariant,
1841 // and a and b are constants.
1842 // Returns true if any possible dependence is disproved.
1843 // Marks the result as inconsistent.
1844 // Works in some cases that symbolicRDIVtest doesn't, and vice versa.
1845 bool DependenceAnalysis::exactRDIVtest(const SCEV *SrcCoeff,
1846                                        const SCEV *DstCoeff,
1847                                        const SCEV *SrcConst,
1848                                        const SCEV *DstConst,
1849                                        const Loop *SrcLoop,
1850                                        const Loop *DstLoop,
1851                                        FullDependence &Result) const {
1852   DEBUG(dbgs() << "\tExact RDIV test\n");
1853   DEBUG(dbgs() << "\t    SrcCoeff = " << *SrcCoeff << " = AM\n");
1854   DEBUG(dbgs() << "\t    DstCoeff = " << *DstCoeff << " = BM\n");
1855   DEBUG(dbgs() << "\t    SrcConst = " << *SrcConst << "\n");
1856   DEBUG(dbgs() << "\t    DstConst = " << *DstConst << "\n");
1857   ++ExactRDIVapplications;
1858   Result.Consistent = false;
1859   const SCEV *Delta = SE->getMinusSCEV(DstConst, SrcConst);
1860   DEBUG(dbgs() << "\t    Delta = " << *Delta << "\n");
1861   const SCEVConstant *ConstDelta = dyn_cast<SCEVConstant>(Delta);
1862   const SCEVConstant *ConstSrcCoeff = dyn_cast<SCEVConstant>(SrcCoeff);
1863   const SCEVConstant *ConstDstCoeff = dyn_cast<SCEVConstant>(DstCoeff);
1864   if (!ConstDelta || !ConstSrcCoeff || !ConstDstCoeff)
1865     return false;
1866
1867   // find gcd
1868   APInt G, X, Y;
1869   APInt AM = ConstSrcCoeff->getAPInt();
1870   APInt BM = ConstDstCoeff->getAPInt();
1871   unsigned Bits = AM.getBitWidth();
1872   if (findGCD(Bits, AM, BM, ConstDelta->getAPInt(), G, X, Y)) {
1873     // gcd doesn't divide Delta, no dependence
1874     ++ExactRDIVindependence;
1875     return true;
1876   }
1877
1878   DEBUG(dbgs() << "\t    X = " << X << ", Y = " << Y << "\n");
1879
1880   // since SCEV construction seems to normalize, LM = 0
1881   APInt SrcUM(Bits, 1, true);
1882   bool SrcUMvalid = false;
1883   // SrcUM is perhaps unavailable, let's check
1884   if (const SCEVConstant *UpperBound =
1885       collectConstantUpperBound(SrcLoop, Delta->getType())) {
1886     SrcUM = UpperBound->getAPInt();
1887     DEBUG(dbgs() << "\t    SrcUM = " << SrcUM << "\n");
1888     SrcUMvalid = true;
1889   }
1890
1891   APInt DstUM(Bits, 1, true);
1892   bool DstUMvalid = false;
1893   // UM is perhaps unavailable, let's check
1894   if (const SCEVConstant *UpperBound =
1895       collectConstantUpperBound(DstLoop, Delta->getType())) {
1896     DstUM = UpperBound->getAPInt();
1897     DEBUG(dbgs() << "\t    DstUM = " << DstUM << "\n");
1898     DstUMvalid = true;
1899   }
1900
1901   APInt TU(APInt::getSignedMaxValue(Bits));
1902   APInt TL(APInt::getSignedMinValue(Bits));
1903
1904   // test(BM/G, LM-X) and test(-BM/G, X-UM)
1905   APInt TMUL = BM.sdiv(G);
1906   if (TMUL.sgt(0)) {
1907     TL = maxAPInt(TL, ceilingOfQuotient(-X, TMUL));
1908     DEBUG(dbgs() << "\t    TL = " << TL << "\n");
1909     if (SrcUMvalid) {
1910       TU = minAPInt(TU, floorOfQuotient(SrcUM - X, TMUL));
1911       DEBUG(dbgs() << "\t    TU = " << TU << "\n");
1912     }
1913   }
1914   else {
1915     TU = minAPInt(TU, floorOfQuotient(-X, TMUL));
1916     DEBUG(dbgs() << "\t    TU = " << TU << "\n");
1917     if (SrcUMvalid) {
1918       TL = maxAPInt(TL, ceilingOfQuotient(SrcUM - X, TMUL));
1919       DEBUG(dbgs() << "\t    TL = " << TL << "\n");
1920     }
1921   }
1922
1923   // test(AM/G, LM-Y) and test(-AM/G, Y-UM)
1924   TMUL = AM.sdiv(G);
1925   if (TMUL.sgt(0)) {
1926     TL = maxAPInt(TL, ceilingOfQuotient(-Y, TMUL));
1927     DEBUG(dbgs() << "\t    TL = " << TL << "\n");
1928     if (DstUMvalid) {
1929       TU = minAPInt(TU, floorOfQuotient(DstUM - Y, TMUL));
1930       DEBUG(dbgs() << "\t    TU = " << TU << "\n");
1931     }
1932   }
1933   else {
1934     TU = minAPInt(TU, floorOfQuotient(-Y, TMUL));
1935     DEBUG(dbgs() << "\t    TU = " << TU << "\n");
1936     if (DstUMvalid) {
1937       TL = maxAPInt(TL, ceilingOfQuotient(DstUM - Y, TMUL));
1938       DEBUG(dbgs() << "\t    TL = " << TL << "\n");
1939     }
1940   }
1941   if (TL.sgt(TU))
1942     ++ExactRDIVindependence;
1943   return TL.sgt(TU);
1944 }
1945
1946
1947 // symbolicRDIVtest -
1948 // In Section 4.5 of the Practical Dependence Testing paper,the authors
1949 // introduce a special case of Banerjee's Inequalities (also called the
1950 // Extreme-Value Test) that can handle some of the SIV and RDIV cases,
1951 // particularly cases with symbolics. Since it's only able to disprove
1952 // dependence (not compute distances or directions), we'll use it as a
1953 // fall back for the other tests.
1954 //
1955 // When we have a pair of subscripts of the form [c1 + a1*i] and [c2 + a2*j]
1956 // where i and j are induction variables and c1 and c2 are loop invariants,
1957 // we can use the symbolic tests to disprove some dependences, serving as a
1958 // backup for the RDIV test. Note that i and j can be the same variable,
1959 // letting this test serve as a backup for the various SIV tests.
1960 //
1961 // For a dependence to exist, c1 + a1*i must equal c2 + a2*j for some
1962 //  0 <= i <= N1 and some 0 <= j <= N2, where N1 and N2 are the (normalized)
1963 // loop bounds for the i and j loops, respectively. So, ...
1964 //
1965 // c1 + a1*i = c2 + a2*j
1966 // a1*i - a2*j = c2 - c1
1967 //
1968 // To test for a dependence, we compute c2 - c1 and make sure it's in the
1969 // range of the maximum and minimum possible values of a1*i - a2*j.
1970 // Considering the signs of a1 and a2, we have 4 possible cases:
1971 //
1972 // 1) If a1 >= 0 and a2 >= 0, then
1973 //        a1*0 - a2*N2 <= c2 - c1 <= a1*N1 - a2*0
1974 //              -a2*N2 <= c2 - c1 <= a1*N1
1975 //
1976 // 2) If a1 >= 0 and a2 <= 0, then
1977 //        a1*0 - a2*0 <= c2 - c1 <= a1*N1 - a2*N2
1978 //                  0 <= c2 - c1 <= a1*N1 - a2*N2
1979 //
1980 // 3) If a1 <= 0 and a2 >= 0, then
1981 //        a1*N1 - a2*N2 <= c2 - c1 <= a1*0 - a2*0
1982 //        a1*N1 - a2*N2 <= c2 - c1 <= 0
1983 //
1984 // 4) If a1 <= 0 and a2 <= 0, then
1985 //        a1*N1 - a2*0  <= c2 - c1 <= a1*0 - a2*N2
1986 //        a1*N1         <= c2 - c1 <=       -a2*N2
1987 //
1988 // return true if dependence disproved
1989 bool DependenceAnalysis::symbolicRDIVtest(const SCEV *A1,
1990                                           const SCEV *A2,
1991                                           const SCEV *C1,
1992                                           const SCEV *C2,
1993                                           const Loop *Loop1,
1994                                           const Loop *Loop2) const {
1995   ++SymbolicRDIVapplications;
1996   DEBUG(dbgs() << "\ttry symbolic RDIV test\n");
1997   DEBUG(dbgs() << "\t    A1 = " << *A1);
1998   DEBUG(dbgs() << ", type = " << *A1->getType() << "\n");
1999   DEBUG(dbgs() << "\t    A2 = " << *A2 << "\n");
2000   DEBUG(dbgs() << "\t    C1 = " << *C1 << "\n");
2001   DEBUG(dbgs() << "\t    C2 = " << *C2 << "\n");
2002   const SCEV *N1 = collectUpperBound(Loop1, A1->getType());
2003   const SCEV *N2 = collectUpperBound(Loop2, A1->getType());
2004   DEBUG(if (N1) dbgs() << "\t    N1 = " << *N1 << "\n");
2005   DEBUG(if (N2) dbgs() << "\t    N2 = " << *N2 << "\n");
2006   const SCEV *C2_C1 = SE->getMinusSCEV(C2, C1);
2007   const SCEV *C1_C2 = SE->getMinusSCEV(C1, C2);
2008   DEBUG(dbgs() << "\t    C2 - C1 = " << *C2_C1 << "\n");
2009   DEBUG(dbgs() << "\t    C1 - C2 = " << *C1_C2 << "\n");
2010   if (SE->isKnownNonNegative(A1)) {
2011     if (SE->isKnownNonNegative(A2)) {
2012       // A1 >= 0 && A2 >= 0
2013       if (N1) {
2014         // make sure that c2 - c1 <= a1*N1
2015         const SCEV *A1N1 = SE->getMulExpr(A1, N1);
2016         DEBUG(dbgs() << "\t    A1*N1 = " << *A1N1 << "\n");
2017         if (isKnownPredicate(CmpInst::ICMP_SGT, C2_C1, A1N1)) {
2018           ++SymbolicRDIVindependence;
2019           return true;
2020         }
2021       }
2022       if (N2) {
2023         // make sure that -a2*N2 <= c2 - c1, or a2*N2 >= c1 - c2
2024         const SCEV *A2N2 = SE->getMulExpr(A2, N2);
2025         DEBUG(dbgs() << "\t    A2*N2 = " << *A2N2 << "\n");
2026         if (isKnownPredicate(CmpInst::ICMP_SLT, A2N2, C1_C2)) {
2027           ++SymbolicRDIVindependence;
2028           return true;
2029         }
2030       }
2031     }
2032     else if (SE->isKnownNonPositive(A2)) {
2033       // a1 >= 0 && a2 <= 0
2034       if (N1 && N2) {
2035         // make sure that c2 - c1 <= a1*N1 - a2*N2
2036         const SCEV *A1N1 = SE->getMulExpr(A1, N1);
2037         const SCEV *A2N2 = SE->getMulExpr(A2, N2);
2038         const SCEV *A1N1_A2N2 = SE->getMinusSCEV(A1N1, A2N2);
2039         DEBUG(dbgs() << "\t    A1*N1 - A2*N2 = " << *A1N1_A2N2 << "\n");
2040         if (isKnownPredicate(CmpInst::ICMP_SGT, C2_C1, A1N1_A2N2)) {
2041           ++SymbolicRDIVindependence;
2042           return true;
2043         }
2044       }
2045       // make sure that 0 <= c2 - c1
2046       if (SE->isKnownNegative(C2_C1)) {
2047         ++SymbolicRDIVindependence;
2048         return true;
2049       }
2050     }
2051   }
2052   else if (SE->isKnownNonPositive(A1)) {
2053     if (SE->isKnownNonNegative(A2)) {
2054       // a1 <= 0 && a2 >= 0
2055       if (N1 && N2) {
2056         // make sure that a1*N1 - a2*N2 <= c2 - c1
2057         const SCEV *A1N1 = SE->getMulExpr(A1, N1);
2058         const SCEV *A2N2 = SE->getMulExpr(A2, N2);
2059         const SCEV *A1N1_A2N2 = SE->getMinusSCEV(A1N1, A2N2);
2060         DEBUG(dbgs() << "\t    A1*N1 - A2*N2 = " << *A1N1_A2N2 << "\n");
2061         if (isKnownPredicate(CmpInst::ICMP_SGT, A1N1_A2N2, C2_C1)) {
2062           ++SymbolicRDIVindependence;
2063           return true;
2064         }
2065       }
2066       // make sure that c2 - c1 <= 0
2067       if (SE->isKnownPositive(C2_C1)) {
2068         ++SymbolicRDIVindependence;
2069         return true;
2070       }
2071     }
2072     else if (SE->isKnownNonPositive(A2)) {
2073       // a1 <= 0 && a2 <= 0
2074       if (N1) {
2075         // make sure that a1*N1 <= c2 - c1
2076         const SCEV *A1N1 = SE->getMulExpr(A1, N1);
2077         DEBUG(dbgs() << "\t    A1*N1 = " << *A1N1 << "\n");
2078         if (isKnownPredicate(CmpInst::ICMP_SGT, A1N1, C2_C1)) {
2079           ++SymbolicRDIVindependence;
2080           return true;
2081         }
2082       }
2083       if (N2) {
2084         // make sure that c2 - c1 <= -a2*N2, or c1 - c2 >= a2*N2
2085         const SCEV *A2N2 = SE->getMulExpr(A2, N2);
2086         DEBUG(dbgs() << "\t    A2*N2 = " << *A2N2 << "\n");
2087         if (isKnownPredicate(CmpInst::ICMP_SLT, C1_C2, A2N2)) {
2088           ++SymbolicRDIVindependence;
2089           return true;
2090         }
2091       }
2092     }
2093   }
2094   return false;
2095 }
2096
2097
2098 // testSIV -
2099 // When we have a pair of subscripts of the form [c1 + a1*i] and [c2 - a2*i]
2100 // where i is an induction variable, c1 and c2 are loop invariant, and a1 and
2101 // a2 are constant, we attack it with an SIV test. While they can all be
2102 // solved with the Exact SIV test, it's worthwhile to use simpler tests when
2103 // they apply; they're cheaper and sometimes more precise.
2104 //
2105 // Return true if dependence disproved.
2106 bool DependenceAnalysis::testSIV(const SCEV *Src,
2107                                  const SCEV *Dst,
2108                                  unsigned &Level,
2109                                  FullDependence &Result,
2110                                  Constraint &NewConstraint,
2111                                  const SCEV *&SplitIter) const {
2112   DEBUG(dbgs() << "    src = " << *Src << "\n");
2113   DEBUG(dbgs() << "    dst = " << *Dst << "\n");
2114   const SCEVAddRecExpr *SrcAddRec = dyn_cast<SCEVAddRecExpr>(Src);
2115   const SCEVAddRecExpr *DstAddRec = dyn_cast<SCEVAddRecExpr>(Dst);
2116   if (SrcAddRec && DstAddRec) {
2117     const SCEV *SrcConst = SrcAddRec->getStart();
2118     const SCEV *DstConst = DstAddRec->getStart();
2119     const SCEV *SrcCoeff = SrcAddRec->getStepRecurrence(*SE);
2120     const SCEV *DstCoeff = DstAddRec->getStepRecurrence(*SE);
2121     const Loop *CurLoop = SrcAddRec->getLoop();
2122     assert(CurLoop == DstAddRec->getLoop() &&
2123            "both loops in SIV should be same");
2124     Level = mapSrcLoop(CurLoop);
2125     bool disproven;
2126     if (SrcCoeff == DstCoeff)
2127       disproven = strongSIVtest(SrcCoeff, SrcConst, DstConst, CurLoop,
2128                                 Level, Result, NewConstraint);
2129     else if (SrcCoeff == SE->getNegativeSCEV(DstCoeff))
2130       disproven = weakCrossingSIVtest(SrcCoeff, SrcConst, DstConst, CurLoop,
2131                                       Level, Result, NewConstraint, SplitIter);
2132     else
2133       disproven = exactSIVtest(SrcCoeff, DstCoeff, SrcConst, DstConst, CurLoop,
2134                                Level, Result, NewConstraint);
2135     return disproven ||
2136       gcdMIVtest(Src, Dst, Result) ||
2137       symbolicRDIVtest(SrcCoeff, DstCoeff, SrcConst, DstConst, CurLoop, CurLoop);
2138   }
2139   if (SrcAddRec) {
2140     const SCEV *SrcConst = SrcAddRec->getStart();
2141     const SCEV *SrcCoeff = SrcAddRec->getStepRecurrence(*SE);
2142     const SCEV *DstConst = Dst;
2143     const Loop *CurLoop = SrcAddRec->getLoop();
2144     Level = mapSrcLoop(CurLoop);
2145     return weakZeroDstSIVtest(SrcCoeff, SrcConst, DstConst, CurLoop,
2146                               Level, Result, NewConstraint) ||
2147       gcdMIVtest(Src, Dst, Result);
2148   }
2149   if (DstAddRec) {
2150     const SCEV *DstConst = DstAddRec->getStart();
2151     const SCEV *DstCoeff = DstAddRec->getStepRecurrence(*SE);
2152     const SCEV *SrcConst = Src;
2153     const Loop *CurLoop = DstAddRec->getLoop();
2154     Level = mapDstLoop(CurLoop);
2155     return weakZeroSrcSIVtest(DstCoeff, SrcConst, DstConst,
2156                               CurLoop, Level, Result, NewConstraint) ||
2157       gcdMIVtest(Src, Dst, Result);
2158   }
2159   llvm_unreachable("SIV test expected at least one AddRec");
2160   return false;
2161 }
2162
2163
2164 // testRDIV -
2165 // When we have a pair of subscripts of the form [c1 + a1*i] and [c2 + a2*j]
2166 // where i and j are induction variables, c1 and c2 are loop invariant,
2167 // and a1 and a2 are constant, we can solve it exactly with an easy adaptation
2168 // of the Exact SIV test, the Restricted Double Index Variable (RDIV) test.
2169 // It doesn't make sense to talk about distance or direction in this case,
2170 // so there's no point in making special versions of the Strong SIV test or
2171 // the Weak-crossing SIV test.
2172 //
2173 // With minor algebra, this test can also be used for things like
2174 // [c1 + a1*i + a2*j][c2].
2175 //
2176 // Return true if dependence disproved.
2177 bool DependenceAnalysis::testRDIV(const SCEV *Src,
2178                                   const SCEV *Dst,
2179                                   FullDependence &Result) const {
2180   // we have 3 possible situations here:
2181   //   1) [a*i + b] and [c*j + d]
2182   //   2) [a*i + c*j + b] and [d]
2183   //   3) [b] and [a*i + c*j + d]
2184   // We need to find what we've got and get organized
2185
2186   const SCEV *SrcConst, *DstConst;
2187   const SCEV *SrcCoeff, *DstCoeff;
2188   const Loop *SrcLoop, *DstLoop;
2189
2190   DEBUG(dbgs() << "    src = " << *Src << "\n");
2191   DEBUG(dbgs() << "    dst = " << *Dst << "\n");
2192   const SCEVAddRecExpr *SrcAddRec = dyn_cast<SCEVAddRecExpr>(Src);
2193   const SCEVAddRecExpr *DstAddRec = dyn_cast<SCEVAddRecExpr>(Dst);
2194   if (SrcAddRec && DstAddRec) {
2195     SrcConst = SrcAddRec->getStart();
2196     SrcCoeff = SrcAddRec->getStepRecurrence(*SE);
2197     SrcLoop = SrcAddRec->getLoop();
2198     DstConst = DstAddRec->getStart();
2199     DstCoeff = DstAddRec->getStepRecurrence(*SE);
2200     DstLoop = DstAddRec->getLoop();
2201   }
2202   else if (SrcAddRec) {
2203     if (const SCEVAddRecExpr *tmpAddRec =
2204         dyn_cast<SCEVAddRecExpr>(SrcAddRec->getStart())) {
2205       SrcConst = tmpAddRec->getStart();
2206       SrcCoeff = tmpAddRec->getStepRecurrence(*SE);
2207       SrcLoop = tmpAddRec->getLoop();
2208       DstConst = Dst;
2209       DstCoeff = SE->getNegativeSCEV(SrcAddRec->getStepRecurrence(*SE));
2210       DstLoop = SrcAddRec->getLoop();
2211     }
2212     else
2213       llvm_unreachable("RDIV reached by surprising SCEVs");
2214   }
2215   else if (DstAddRec) {
2216     if (const SCEVAddRecExpr *tmpAddRec =
2217         dyn_cast<SCEVAddRecExpr>(DstAddRec->getStart())) {
2218       DstConst = tmpAddRec->getStart();
2219       DstCoeff = tmpAddRec->getStepRecurrence(*SE);
2220       DstLoop = tmpAddRec->getLoop();
2221       SrcConst = Src;
2222       SrcCoeff = SE->getNegativeSCEV(DstAddRec->getStepRecurrence(*SE));
2223       SrcLoop = DstAddRec->getLoop();
2224     }
2225     else
2226       llvm_unreachable("RDIV reached by surprising SCEVs");
2227   }
2228   else
2229     llvm_unreachable("RDIV expected at least one AddRec");
2230   return exactRDIVtest(SrcCoeff, DstCoeff,
2231                        SrcConst, DstConst,
2232                        SrcLoop, DstLoop,
2233                        Result) ||
2234     gcdMIVtest(Src, Dst, Result) ||
2235     symbolicRDIVtest(SrcCoeff, DstCoeff,
2236                      SrcConst, DstConst,
2237                      SrcLoop, DstLoop);
2238 }
2239
2240
2241 // Tests the single-subscript MIV pair (Src and Dst) for dependence.
2242 // Return true if dependence disproved.
2243 // Can sometimes refine direction vectors.
2244 bool DependenceAnalysis::testMIV(const SCEV *Src,
2245                                  const SCEV *Dst,
2246                                  const SmallBitVector &Loops,
2247                                  FullDependence &Result) const {
2248   DEBUG(dbgs() << "    src = " << *Src << "\n");
2249   DEBUG(dbgs() << "    dst = " << *Dst << "\n");
2250   Result.Consistent = false;
2251   return gcdMIVtest(Src, Dst, Result) ||
2252     banerjeeMIVtest(Src, Dst, Loops, Result);
2253 }
2254
2255
2256 // Given a product, e.g., 10*X*Y, returns the first constant operand,
2257 // in this case 10. If there is no constant part, returns NULL.
2258 static
2259 const SCEVConstant *getConstantPart(const SCEVMulExpr *Product) {
2260   for (unsigned Op = 0, Ops = Product->getNumOperands(); Op < Ops; Op++) {
2261     if (const SCEVConstant *Constant = dyn_cast<SCEVConstant>(Product->getOperand(Op)))
2262       return Constant;
2263   }
2264   return nullptr;
2265 }
2266
2267
2268 //===----------------------------------------------------------------------===//
2269 // gcdMIVtest -
2270 // Tests an MIV subscript pair for dependence.
2271 // Returns true if any possible dependence is disproved.
2272 // Marks the result as inconsistent.
2273 // Can sometimes disprove the equal direction for 1 or more loops,
2274 // as discussed in Michael Wolfe's book,
2275 // High Performance Compilers for Parallel Computing, page 235.
2276 //
2277 // We spend some effort (code!) to handle cases like
2278 // [10*i + 5*N*j + 15*M + 6], where i and j are induction variables,
2279 // but M and N are just loop-invariant variables.
2280 // This should help us handle linearized subscripts;
2281 // also makes this test a useful backup to the various SIV tests.
2282 //
2283 // It occurs to me that the presence of loop-invariant variables
2284 // changes the nature of the test from "greatest common divisor"
2285 // to "a common divisor".
2286 bool DependenceAnalysis::gcdMIVtest(const SCEV *Src,
2287                                     const SCEV *Dst,
2288                                     FullDependence &Result) const {
2289   DEBUG(dbgs() << "starting gcd\n");
2290   ++GCDapplications;
2291   unsigned BitWidth = SE->getTypeSizeInBits(Src->getType());
2292   APInt RunningGCD = APInt::getNullValue(BitWidth);
2293
2294   // Examine Src coefficients.
2295   // Compute running GCD and record source constant.
2296   // Because we're looking for the constant at the end of the chain,
2297   // we can't quit the loop just because the GCD == 1.
2298   const SCEV *Coefficients = Src;
2299   while (const SCEVAddRecExpr *AddRec =
2300          dyn_cast<SCEVAddRecExpr>(Coefficients)) {
2301     const SCEV *Coeff = AddRec->getStepRecurrence(*SE);
2302     const SCEVConstant *Constant = dyn_cast<SCEVConstant>(Coeff);
2303     if (const SCEVMulExpr *Product = dyn_cast<SCEVMulExpr>(Coeff))
2304       // If the coefficient is the product of a constant and other stuff,
2305       // we can use the constant in the GCD computation.
2306       Constant = getConstantPart(Product);
2307     if (!Constant)
2308       return false;
2309     APInt ConstCoeff = Constant->getAPInt();
2310     RunningGCD = APIntOps::GreatestCommonDivisor(RunningGCD, ConstCoeff.abs());
2311     Coefficients = AddRec->getStart();
2312   }
2313   const SCEV *SrcConst = Coefficients;
2314
2315   // Examine Dst coefficients.
2316   // Compute running GCD and record destination constant.
2317   // Because we're looking for the constant at the end of the chain,
2318   // we can't quit the loop just because the GCD == 1.
2319   Coefficients = Dst;
2320   while (const SCEVAddRecExpr *AddRec =
2321          dyn_cast<SCEVAddRecExpr>(Coefficients)) {
2322     const SCEV *Coeff = AddRec->getStepRecurrence(*SE);
2323     const SCEVConstant *Constant = dyn_cast<SCEVConstant>(Coeff);
2324     if (const SCEVMulExpr *Product = dyn_cast<SCEVMulExpr>(Coeff))
2325       // If the coefficient is the product of a constant and other stuff,
2326       // we can use the constant in the GCD computation.
2327       Constant = getConstantPart(Product);
2328     if (!Constant)
2329       return false;
2330     APInt ConstCoeff = Constant->getAPInt();
2331     RunningGCD = APIntOps::GreatestCommonDivisor(RunningGCD, ConstCoeff.abs());
2332     Coefficients = AddRec->getStart();
2333   }
2334   const SCEV *DstConst = Coefficients;
2335
2336   APInt ExtraGCD = APInt::getNullValue(BitWidth);
2337   const SCEV *Delta = SE->getMinusSCEV(DstConst, SrcConst);
2338   DEBUG(dbgs() << "    Delta = " << *Delta << "\n");
2339   const SCEVConstant *Constant = dyn_cast<SCEVConstant>(Delta);
2340   if (const SCEVAddExpr *Sum = dyn_cast<SCEVAddExpr>(Delta)) {
2341     // If Delta is a sum of products, we may be able to make further progress.
2342     for (unsigned Op = 0, Ops = Sum->getNumOperands(); Op < Ops; Op++) {
2343       const SCEV *Operand = Sum->getOperand(Op);
2344       if (isa<SCEVConstant>(Operand)) {
2345         assert(!Constant && "Surprised to find multiple constants");
2346         Constant = cast<SCEVConstant>(Operand);
2347       }
2348       else if (const SCEVMulExpr *Product = dyn_cast<SCEVMulExpr>(Operand)) {
2349         // Search for constant operand to participate in GCD;
2350         // If none found; return false.
2351         const SCEVConstant *ConstOp = getConstantPart(Product);
2352         if (!ConstOp)
2353           return false;
2354         APInt ConstOpValue = ConstOp->getAPInt();
2355         ExtraGCD = APIntOps::GreatestCommonDivisor(ExtraGCD,
2356                                                    ConstOpValue.abs());
2357       }
2358       else
2359         return false;
2360     }
2361   }
2362   if (!Constant)
2363     return false;
2364   APInt ConstDelta = cast<SCEVConstant>(Constant)->getAPInt();
2365   DEBUG(dbgs() << "    ConstDelta = " << ConstDelta << "\n");
2366   if (ConstDelta == 0)
2367     return false;
2368   RunningGCD = APIntOps::GreatestCommonDivisor(RunningGCD, ExtraGCD);
2369   DEBUG(dbgs() << "    RunningGCD = " << RunningGCD << "\n");
2370   APInt Remainder = ConstDelta.srem(RunningGCD);
2371   if (Remainder != 0) {
2372     ++GCDindependence;
2373     return true;
2374   }
2375
2376   // Try to disprove equal directions.
2377   // For example, given a subscript pair [3*i + 2*j] and [i' + 2*j' - 1],
2378   // the code above can't disprove the dependence because the GCD = 1.
2379   // So we consider what happen if i = i' and what happens if j = j'.
2380   // If i = i', we can simplify the subscript to [2*i + 2*j] and [2*j' - 1],
2381   // which is infeasible, so we can disallow the = direction for the i level.
2382   // Setting j = j' doesn't help matters, so we end up with a direction vector
2383   // of [<>, *]
2384   //
2385   // Given A[5*i + 10*j*M + 9*M*N] and A[15*i + 20*j*M - 21*N*M + 5],
2386   // we need to remember that the constant part is 5 and the RunningGCD should
2387   // be initialized to ExtraGCD = 30.
2388   DEBUG(dbgs() << "    ExtraGCD = " << ExtraGCD << '\n');
2389
2390   bool Improved = false;
2391   Coefficients = Src;
2392   while (const SCEVAddRecExpr *AddRec =
2393          dyn_cast<SCEVAddRecExpr>(Coefficients)) {
2394     Coefficients = AddRec->getStart();
2395     const Loop *CurLoop = AddRec->getLoop();
2396     RunningGCD = ExtraGCD;
2397     const SCEV *SrcCoeff = AddRec->getStepRecurrence(*SE);
2398     const SCEV *DstCoeff = SE->getMinusSCEV(SrcCoeff, SrcCoeff);
2399     const SCEV *Inner = Src;
2400     while (RunningGCD != 1 && isa<SCEVAddRecExpr>(Inner)) {
2401       AddRec = cast<SCEVAddRecExpr>(Inner);
2402       const SCEV *Coeff = AddRec->getStepRecurrence(*SE);
2403       if (CurLoop == AddRec->getLoop())
2404         ; // SrcCoeff == Coeff
2405       else {
2406         if (const SCEVMulExpr *Product = dyn_cast<SCEVMulExpr>(Coeff))
2407           // If the coefficient is the product of a constant and other stuff,
2408           // we can use the constant in the GCD computation.
2409           Constant = getConstantPart(Product);
2410         else
2411           Constant = cast<SCEVConstant>(Coeff);
2412         APInt ConstCoeff = Constant->getAPInt();
2413         RunningGCD = APIntOps::GreatestCommonDivisor(RunningGCD, ConstCoeff.abs());
2414       }
2415       Inner = AddRec->getStart();
2416     }
2417     Inner = Dst;
2418     while (RunningGCD != 1 && isa<SCEVAddRecExpr>(Inner)) {
2419       AddRec = cast<SCEVAddRecExpr>(Inner);
2420       const SCEV *Coeff = AddRec->getStepRecurrence(*SE);
2421       if (CurLoop == AddRec->getLoop())
2422         DstCoeff = Coeff;
2423       else {
2424         if (const SCEVMulExpr *Product = dyn_cast<SCEVMulExpr>(Coeff))
2425           // If the coefficient is the product of a constant and other stuff,
2426           // we can use the constant in the GCD computation.
2427           Constant = getConstantPart(Product);
2428         else
2429           Constant = cast<SCEVConstant>(Coeff);
2430         APInt ConstCoeff = Constant->getAPInt();
2431         RunningGCD = APIntOps::GreatestCommonDivisor(RunningGCD, ConstCoeff.abs());
2432       }
2433       Inner = AddRec->getStart();
2434     }
2435     Delta = SE->getMinusSCEV(SrcCoeff, DstCoeff);
2436     if (const SCEVMulExpr *Product = dyn_cast<SCEVMulExpr>(Delta))
2437       // If the coefficient is the product of a constant and other stuff,
2438       // we can use the constant in the GCD computation.
2439       Constant = getConstantPart(Product);
2440     else if (isa<SCEVConstant>(Delta))
2441       Constant = cast<SCEVConstant>(Delta);
2442     else {
2443       // The difference of the two coefficients might not be a product
2444       // or constant, in which case we give up on this direction.
2445       continue;
2446     }
2447     APInt ConstCoeff = Constant->getAPInt();
2448     RunningGCD = APIntOps::GreatestCommonDivisor(RunningGCD, ConstCoeff.abs());
2449     DEBUG(dbgs() << "\tRunningGCD = " << RunningGCD << "\n");
2450     if (RunningGCD != 0) {
2451       Remainder = ConstDelta.srem(RunningGCD);
2452       DEBUG(dbgs() << "\tRemainder = " << Remainder << "\n");
2453       if (Remainder != 0) {
2454         unsigned Level = mapSrcLoop(CurLoop);
2455         Result.DV[Level - 1].Direction &= unsigned(~Dependence::DVEntry::EQ);
2456         Improved = true;
2457       }
2458     }
2459   }
2460   if (Improved)
2461     ++GCDsuccesses;
2462   DEBUG(dbgs() << "all done\n");
2463   return false;
2464 }
2465
2466
2467 //===----------------------------------------------------------------------===//
2468 // banerjeeMIVtest -
2469 // Use Banerjee's Inequalities to test an MIV subscript pair.
2470 // (Wolfe, in the race-car book, calls this the Extreme Value Test.)
2471 // Generally follows the discussion in Section 2.5.2 of
2472 //
2473 //    Optimizing Supercompilers for Supercomputers
2474 //    Michael Wolfe
2475 //
2476 // The inequalities given on page 25 are simplified in that loops are
2477 // normalized so that the lower bound is always 0 and the stride is always 1.
2478 // For example, Wolfe gives
2479 //
2480 //     LB^<_k = (A^-_k - B_k)^- (U_k - L_k - N_k) + (A_k - B_k)L_k - B_k N_k
2481 //
2482 // where A_k is the coefficient of the kth index in the source subscript,
2483 // B_k is the coefficient of the kth index in the destination subscript,
2484 // U_k is the upper bound of the kth index, L_k is the lower bound of the Kth
2485 // index, and N_k is the stride of the kth index. Since all loops are normalized
2486 // by the SCEV package, N_k = 1 and L_k = 0, allowing us to simplify the
2487 // equation to
2488 //
2489 //     LB^<_k = (A^-_k - B_k)^- (U_k - 0 - 1) + (A_k - B_k)0 - B_k 1
2490 //            = (A^-_k - B_k)^- (U_k - 1)  - B_k
2491 //
2492 // Similar simplifications are possible for the other equations.
2493 //
2494 // When we can't determine the number of iterations for a loop,
2495 // we use NULL as an indicator for the worst case, infinity.
2496 // When computing the upper bound, NULL denotes +inf;
2497 // for the lower bound, NULL denotes -inf.
2498 //
2499 // Return true if dependence disproved.
2500 bool DependenceAnalysis::banerjeeMIVtest(const SCEV *Src,
2501                                          const SCEV *Dst,
2502                                          const SmallBitVector &Loops,
2503                                          FullDependence &Result) const {
2504   DEBUG(dbgs() << "starting Banerjee\n");
2505   ++BanerjeeApplications;
2506   DEBUG(dbgs() << "    Src = " << *Src << '\n');
2507   const SCEV *A0;
2508   CoefficientInfo *A = collectCoeffInfo(Src, true, A0);
2509   DEBUG(dbgs() << "    Dst = " << *Dst << '\n');
2510   const SCEV *B0;
2511   CoefficientInfo *B = collectCoeffInfo(Dst, false, B0);
2512   BoundInfo *Bound = new BoundInfo[MaxLevels + 1];
2513   const SCEV *Delta = SE->getMinusSCEV(B0, A0);
2514   DEBUG(dbgs() << "\tDelta = " << *Delta << '\n');
2515
2516   // Compute bounds for all the * directions.
2517   DEBUG(dbgs() << "\tBounds[*]\n");
2518   for (unsigned K = 1; K <= MaxLevels; ++K) {
2519     Bound[K].Iterations = A[K].Iterations ? A[K].Iterations : B[K].Iterations;
2520     Bound[K].Direction = Dependence::DVEntry::ALL;
2521     Bound[K].DirSet = Dependence::DVEntry::NONE;
2522     findBoundsALL(A, B, Bound, K);
2523 #ifndef NDEBUG
2524     DEBUG(dbgs() << "\t    " << K << '\t');
2525     if (Bound[K].Lower[Dependence::DVEntry::ALL])
2526       DEBUG(dbgs() << *Bound[K].Lower[Dependence::DVEntry::ALL] << '\t');
2527     else
2528       DEBUG(dbgs() << "-inf\t");
2529     if (Bound[K].Upper[Dependence::DVEntry::ALL])
2530       DEBUG(dbgs() << *Bound[K].Upper[Dependence::DVEntry::ALL] << '\n');
2531     else
2532       DEBUG(dbgs() << "+inf\n");
2533 #endif
2534   }
2535
2536   // Test the *, *, *, ... case.
2537   bool Disproved = false;
2538   if (testBounds(Dependence::DVEntry::ALL, 0, Bound, Delta)) {
2539     // Explore the direction vector hierarchy.
2540     unsigned DepthExpanded = 0;
2541     unsigned NewDeps = exploreDirections(1, A, B, Bound,
2542                                          Loops, DepthExpanded, Delta);
2543     if (NewDeps > 0) {
2544       bool Improved = false;
2545       for (unsigned K = 1; K <= CommonLevels; ++K) {
2546         if (Loops[K]) {
2547           unsigned Old = Result.DV[K - 1].Direction;
2548           Result.DV[K - 1].Direction = Old & Bound[K].DirSet;
2549           Improved |= Old != Result.DV[K - 1].Direction;
2550           if (!Result.DV[K - 1].Direction) {
2551             Improved = false;
2552             Disproved = true;
2553             break;
2554           }
2555         }
2556       }
2557       if (Improved)
2558         ++BanerjeeSuccesses;
2559     }
2560     else {
2561       ++BanerjeeIndependence;
2562       Disproved = true;
2563     }
2564   }
2565   else {
2566     ++BanerjeeIndependence;
2567     Disproved = true;
2568   }
2569   delete [] Bound;
2570   delete [] A;
2571   delete [] B;
2572   return Disproved;
2573 }
2574
2575
2576 // Hierarchically expands the direction vector
2577 // search space, combining the directions of discovered dependences
2578 // in the DirSet field of Bound. Returns the number of distinct
2579 // dependences discovered. If the dependence is disproved,
2580 // it will return 0.
2581 unsigned DependenceAnalysis::exploreDirections(unsigned Level,
2582                                                CoefficientInfo *A,
2583                                                CoefficientInfo *B,
2584                                                BoundInfo *Bound,
2585                                                const SmallBitVector &Loops,
2586                                                unsigned &DepthExpanded,
2587                                                const SCEV *Delta) const {
2588   if (Level > CommonLevels) {
2589     // record result
2590     DEBUG(dbgs() << "\t[");
2591     for (unsigned K = 1; K <= CommonLevels; ++K) {
2592       if (Loops[K]) {
2593         Bound[K].DirSet |= Bound[K].Direction;
2594 #ifndef NDEBUG
2595         switch (Bound[K].Direction) {
2596         case Dependence::DVEntry::LT:
2597           DEBUG(dbgs() << " <");
2598           break;
2599         case Dependence::DVEntry::EQ:
2600           DEBUG(dbgs() << " =");
2601           break;
2602         case Dependence::DVEntry::GT:
2603           DEBUG(dbgs() << " >");
2604           break;
2605         case Dependence::DVEntry::ALL:
2606           DEBUG(dbgs() << " *");
2607           break;
2608         default:
2609           llvm_unreachable("unexpected Bound[K].Direction");
2610         }
2611 #endif
2612       }
2613     }
2614     DEBUG(dbgs() << " ]\n");
2615     return 1;
2616   }
2617   if (Loops[Level]) {
2618     if (Level > DepthExpanded) {
2619       DepthExpanded = Level;
2620       // compute bounds for <, =, > at current level
2621       findBoundsLT(A, B, Bound, Level);
2622       findBoundsGT(A, B, Bound, Level);
2623       findBoundsEQ(A, B, Bound, Level);
2624 #ifndef NDEBUG
2625       DEBUG(dbgs() << "\tBound for level = " << Level << '\n');
2626       DEBUG(dbgs() << "\t    <\t");
2627       if (Bound[Level].Lower[Dependence::DVEntry::LT])
2628         DEBUG(dbgs() << *Bound[Level].Lower[Dependence::DVEntry::LT] << '\t');
2629       else
2630         DEBUG(dbgs() << "-inf\t");
2631       if (Bound[Level].Upper[Dependence::DVEntry::LT])
2632         DEBUG(dbgs() << *Bound[Level].Upper[Dependence::DVEntry::LT] << '\n');
2633       else
2634         DEBUG(dbgs() << "+inf\n");
2635       DEBUG(dbgs() << "\t    =\t");
2636       if (Bound[Level].Lower[Dependence::DVEntry::EQ])
2637         DEBUG(dbgs() << *Bound[Level].Lower[Dependence::DVEntry::EQ] << '\t');
2638       else
2639         DEBUG(dbgs() << "-inf\t");
2640       if (Bound[Level].Upper[Dependence::DVEntry::EQ])
2641         DEBUG(dbgs() << *Bound[Level].Upper[Dependence::DVEntry::EQ] << '\n');
2642       else
2643         DEBUG(dbgs() << "+inf\n");
2644       DEBUG(dbgs() << "\t    >\t");
2645       if (Bound[Level].Lower[Dependence::DVEntry::GT])
2646         DEBUG(dbgs() << *Bound[Level].Lower[Dependence::DVEntry::GT] << '\t');
2647       else
2648         DEBUG(dbgs() << "-inf\t");
2649       if (Bound[Level].Upper[Dependence::DVEntry::GT])
2650         DEBUG(dbgs() << *Bound[Level].Upper[Dependence::DVEntry::GT] << '\n');
2651       else
2652         DEBUG(dbgs() << "+inf\n");
2653 #endif
2654     }
2655
2656     unsigned NewDeps = 0;
2657
2658     // test bounds for <, *, *, ...
2659     if (testBounds(Dependence::DVEntry::LT, Level, Bound, Delta))
2660       NewDeps += exploreDirections(Level + 1, A, B, Bound,
2661                                    Loops, DepthExpanded, Delta);
2662
2663     // Test bounds for =, *, *, ...
2664     if (testBounds(Dependence::DVEntry::EQ, Level, Bound, Delta))
2665       NewDeps += exploreDirections(Level + 1, A, B, Bound,
2666                                    Loops, DepthExpanded, Delta);
2667
2668     // test bounds for >, *, *, ...
2669     if (testBounds(Dependence::DVEntry::GT, Level, Bound, Delta))
2670       NewDeps += exploreDirections(Level + 1, A, B, Bound,
2671                                    Loops, DepthExpanded, Delta);
2672
2673     Bound[Level].Direction = Dependence::DVEntry::ALL;
2674     return NewDeps;
2675   }
2676   else
2677     return exploreDirections(Level + 1, A, B, Bound, Loops, DepthExpanded, Delta);
2678 }
2679
2680
2681 // Returns true iff the current bounds are plausible.
2682 bool DependenceAnalysis::testBounds(unsigned char DirKind,
2683                                     unsigned Level,
2684                                     BoundInfo *Bound,
2685                                     const SCEV *Delta) const {
2686   Bound[Level].Direction = DirKind;
2687   if (const SCEV *LowerBound = getLowerBound(Bound))
2688     if (isKnownPredicate(CmpInst::ICMP_SGT, LowerBound, Delta))
2689       return false;
2690   if (const SCEV *UpperBound = getUpperBound(Bound))
2691     if (isKnownPredicate(CmpInst::ICMP_SGT, Delta, UpperBound))
2692       return false;
2693   return true;
2694 }
2695
2696
2697 // Computes the upper and lower bounds for level K
2698 // using the * direction. Records them in Bound.
2699 // Wolfe gives the equations
2700 //
2701 //    LB^*_k = (A^-_k - B^+_k)(U_k - L_k) + (A_k - B_k)L_k
2702 //    UB^*_k = (A^+_k - B^-_k)(U_k - L_k) + (A_k - B_k)L_k
2703 //
2704 // Since we normalize loops, we can simplify these equations to
2705 //
2706 //    LB^*_k = (A^-_k - B^+_k)U_k
2707 //    UB^*_k = (A^+_k - B^-_k)U_k
2708 //
2709 // We must be careful to handle the case where the upper bound is unknown.
2710 // Note that the lower bound is always <= 0
2711 // and the upper bound is always >= 0.
2712 void DependenceAnalysis::findBoundsALL(CoefficientInfo *A,
2713                                        CoefficientInfo *B,
2714                                        BoundInfo *Bound,
2715                                        unsigned K) const {
2716   Bound[K].Lower[Dependence::DVEntry::ALL] = nullptr; // Default value = -infinity.
2717   Bound[K].Upper[Dependence::DVEntry::ALL] = nullptr; // Default value = +infinity.
2718   if (Bound[K].Iterations) {
2719     Bound[K].Lower[Dependence::DVEntry::ALL] =
2720       SE->getMulExpr(SE->getMinusSCEV(A[K].NegPart, B[K].PosPart),
2721                      Bound[K].Iterations);
2722     Bound[K].Upper[Dependence::DVEntry::ALL] =
2723       SE->getMulExpr(SE->getMinusSCEV(A[K].PosPart, B[K].NegPart),
2724                      Bound[K].Iterations);
2725   }
2726   else {
2727     // If the difference is 0, we won't need to know the number of iterations.
2728     if (isKnownPredicate(CmpInst::ICMP_EQ, A[K].NegPart, B[K].PosPart))
2729       Bound[K].Lower[Dependence::DVEntry::ALL] =
2730           SE->getZero(A[K].Coeff->getType());
2731     if (isKnownPredicate(CmpInst::ICMP_EQ, A[K].PosPart, B[K].NegPart))
2732       Bound[K].Upper[Dependence::DVEntry::ALL] =
2733           SE->getZero(A[K].Coeff->getType());
2734   }
2735 }
2736
2737
2738 // Computes the upper and lower bounds for level K
2739 // using the = direction. Records them in Bound.
2740 // Wolfe gives the equations
2741 //
2742 //    LB^=_k = (A_k - B_k)^- (U_k - L_k) + (A_k - B_k)L_k
2743 //    UB^=_k = (A_k - B_k)^+ (U_k - L_k) + (A_k - B_k)L_k
2744 //
2745 // Since we normalize loops, we can simplify these equations to
2746 //
2747 //    LB^=_k = (A_k - B_k)^- U_k
2748 //    UB^=_k = (A_k - B_k)^+ U_k
2749 //
2750 // We must be careful to handle the case where the upper bound is unknown.
2751 // Note that the lower bound is always <= 0
2752 // and the upper bound is always >= 0.
2753 void DependenceAnalysis::findBoundsEQ(CoefficientInfo *A,
2754                                       CoefficientInfo *B,
2755                                       BoundInfo *Bound,
2756                                       unsigned K) const {
2757   Bound[K].Lower[Dependence::DVEntry::EQ] = nullptr; // Default value = -infinity.
2758   Bound[K].Upper[Dependence::DVEntry::EQ] = nullptr; // Default value = +infinity.
2759   if (Bound[K].Iterations) {
2760     const SCEV *Delta = SE->getMinusSCEV(A[K].Coeff, B[K].Coeff);
2761     const SCEV *NegativePart = getNegativePart(Delta);
2762     Bound[K].Lower[Dependence::DVEntry::EQ] =
2763       SE->getMulExpr(NegativePart, Bound[K].Iterations);
2764     const SCEV *PositivePart = getPositivePart(Delta);
2765     Bound[K].Upper[Dependence::DVEntry::EQ] =
2766       SE->getMulExpr(PositivePart, Bound[K].Iterations);
2767   }
2768   else {
2769     // If the positive/negative part of the difference is 0,
2770     // we won't need to know the number of iterations.
2771     const SCEV *Delta = SE->getMinusSCEV(A[K].Coeff, B[K].Coeff);
2772     const SCEV *NegativePart = getNegativePart(Delta);
2773     if (NegativePart->isZero())
2774       Bound[K].Lower[Dependence::DVEntry::EQ] = NegativePart; // Zero
2775     const SCEV *PositivePart = getPositivePart(Delta);
2776     if (PositivePart->isZero())
2777       Bound[K].Upper[Dependence::DVEntry::EQ] = PositivePart; // Zero
2778   }
2779 }
2780
2781
2782 // Computes the upper and lower bounds for level K
2783 // using the < direction. Records them in Bound.
2784 // Wolfe gives the equations
2785 //
2786 //    LB^<_k = (A^-_k - B_k)^- (U_k - L_k - N_k) + (A_k - B_k)L_k - B_k N_k
2787 //    UB^<_k = (A^+_k - B_k)^+ (U_k - L_k - N_k) + (A_k - B_k)L_k - B_k N_k
2788 //
2789 // Since we normalize loops, we can simplify these equations to
2790 //
2791 //    LB^<_k = (A^-_k - B_k)^- (U_k - 1) - B_k
2792 //    UB^<_k = (A^+_k - B_k)^+ (U_k - 1) - B_k
2793 //
2794 // We must be careful to handle the case where the upper bound is unknown.
2795 void DependenceAnalysis::findBoundsLT(CoefficientInfo *A,
2796                                       CoefficientInfo *B,
2797                                       BoundInfo *Bound,
2798                                       unsigned K) const {
2799   Bound[K].Lower[Dependence::DVEntry::LT] = nullptr; // Default value = -infinity.
2800   Bound[K].Upper[Dependence::DVEntry::LT] = nullptr; // Default value = +infinity.
2801   if (Bound[K].Iterations) {
2802     const SCEV *Iter_1 = SE->getMinusSCEV(
2803         Bound[K].Iterations, SE->getOne(Bound[K].Iterations->getType()));
2804     const SCEV *NegPart =
2805       getNegativePart(SE->getMinusSCEV(A[K].NegPart, B[K].Coeff));
2806     Bound[K].Lower[Dependence::DVEntry::LT] =
2807       SE->getMinusSCEV(SE->getMulExpr(NegPart, Iter_1), B[K].Coeff);
2808     const SCEV *PosPart =
2809       getPositivePart(SE->getMinusSCEV(A[K].PosPart, B[K].Coeff));
2810     Bound[K].Upper[Dependence::DVEntry::LT] =
2811       SE->getMinusSCEV(SE->getMulExpr(PosPart, Iter_1), B[K].Coeff);
2812   }
2813   else {
2814     // If the positive/negative part of the difference is 0,
2815     // we won't need to know the number of iterations.
2816     const SCEV *NegPart =
2817       getNegativePart(SE->getMinusSCEV(A[K].NegPart, B[K].Coeff));
2818     if (NegPart->isZero())
2819       Bound[K].Lower[Dependence::DVEntry::LT] = SE->getNegativeSCEV(B[K].Coeff);
2820     const SCEV *PosPart =
2821       getPositivePart(SE->getMinusSCEV(A[K].PosPart, B[K].Coeff));
2822     if (PosPart->isZero())
2823       Bound[K].Upper[Dependence::DVEntry::LT] = SE->getNegativeSCEV(B[K].Coeff);
2824   }
2825 }
2826
2827
2828 // Computes the upper and lower bounds for level K
2829 // using the > direction. Records them in Bound.
2830 // Wolfe gives the equations
2831 //
2832 //    LB^>_k = (A_k - B^+_k)^- (U_k - L_k - N_k) + (A_k - B_k)L_k + A_k N_k
2833 //    UB^>_k = (A_k - B^-_k)^+ (U_k - L_k - N_k) + (A_k - B_k)L_k + A_k N_k
2834 //
2835 // Since we normalize loops, we can simplify these equations to
2836 //
2837 //    LB^>_k = (A_k - B^+_k)^- (U_k - 1) + A_k
2838 //    UB^>_k = (A_k - B^-_k)^+ (U_k - 1) + A_k
2839 //
2840 // We must be careful to handle the case where the upper bound is unknown.
2841 void DependenceAnalysis::findBoundsGT(CoefficientInfo *A,
2842                                       CoefficientInfo *B,
2843                                       BoundInfo *Bound,
2844                                       unsigned K) const {
2845   Bound[K].Lower[Dependence::DVEntry::GT] = nullptr; // Default value = -infinity.
2846   Bound[K].Upper[Dependence::DVEntry::GT] = nullptr; // Default value = +infinity.
2847   if (Bound[K].Iterations) {
2848     const SCEV *Iter_1 = SE->getMinusSCEV(
2849         Bound[K].Iterations, SE->getOne(Bound[K].Iterations->getType()));
2850     const SCEV *NegPart =
2851       getNegativePart(SE->getMinusSCEV(A[K].Coeff, B[K].PosPart));
2852     Bound[K].Lower[Dependence::DVEntry::GT] =
2853       SE->getAddExpr(SE->getMulExpr(NegPart, Iter_1), A[K].Coeff);
2854     const SCEV *PosPart =
2855       getPositivePart(SE->getMinusSCEV(A[K].Coeff, B[K].NegPart));
2856     Bound[K].Upper[Dependence::DVEntry::GT] =
2857       SE->getAddExpr(SE->getMulExpr(PosPart, Iter_1), A[K].Coeff);
2858   }
2859   else {
2860     // If the positive/negative part of the difference is 0,
2861     // we won't need to know the number of iterations.
2862     const SCEV *NegPart = getNegativePart(SE->getMinusSCEV(A[K].Coeff, B[K].PosPart));
2863     if (NegPart->isZero())
2864       Bound[K].Lower[Dependence::DVEntry::GT] = A[K].Coeff;
2865     const SCEV *PosPart = getPositivePart(SE->getMinusSCEV(A[K].Coeff, B[K].NegPart));
2866     if (PosPart->isZero())
2867       Bound[K].Upper[Dependence::DVEntry::GT] = A[K].Coeff;
2868   }
2869 }
2870
2871
2872 // X^+ = max(X, 0)
2873 const SCEV *DependenceAnalysis::getPositivePart(const SCEV *X) const {
2874   return SE->getSMaxExpr(X, SE->getZero(X->getType()));
2875 }
2876
2877
2878 // X^- = min(X, 0)
2879 const SCEV *DependenceAnalysis::getNegativePart(const SCEV *X) const {
2880   return SE->getSMinExpr(X, SE->getZero(X->getType()));
2881 }
2882
2883
2884 // Walks through the subscript,
2885 // collecting each coefficient, the associated loop bounds,
2886 // and recording its positive and negative parts for later use.
2887 DependenceAnalysis::CoefficientInfo *
2888 DependenceAnalysis::collectCoeffInfo(const SCEV *Subscript,
2889                                      bool SrcFlag,
2890                                      const SCEV *&Constant) const {
2891   const SCEV *Zero = SE->getZero(Subscript->getType());
2892   CoefficientInfo *CI = new CoefficientInfo[MaxLevels + 1];
2893   for (unsigned K = 1; K <= MaxLevels; ++K) {
2894     CI[K].Coeff = Zero;
2895     CI[K].PosPart = Zero;
2896     CI[K].NegPart = Zero;
2897     CI[K].Iterations = nullptr;
2898   }
2899   while (const SCEVAddRecExpr *AddRec = dyn_cast<SCEVAddRecExpr>(Subscript)) {
2900     const Loop *L = AddRec->getLoop();
2901     unsigned K = SrcFlag ? mapSrcLoop(L) : mapDstLoop(L);
2902     CI[K].Coeff = AddRec->getStepRecurrence(*SE);
2903     CI[K].PosPart = getPositivePart(CI[K].Coeff);
2904     CI[K].NegPart = getNegativePart(CI[K].Coeff);
2905     CI[K].Iterations = collectUpperBound(L, Subscript->getType());
2906     Subscript = AddRec->getStart();
2907   }
2908   Constant = Subscript;
2909 #ifndef NDEBUG
2910   DEBUG(dbgs() << "\tCoefficient Info\n");
2911   for (unsigned K = 1; K <= MaxLevels; ++K) {
2912     DEBUG(dbgs() << "\t    " << K << "\t" << *CI[K].Coeff);
2913     DEBUG(dbgs() << "\tPos Part = ");
2914     DEBUG(dbgs() << *CI[K].PosPart);
2915     DEBUG(dbgs() << "\tNeg Part = ");
2916     DEBUG(dbgs() << *CI[K].NegPart);
2917     DEBUG(dbgs() << "\tUpper Bound = ");
2918     if (CI[K].Iterations)
2919       DEBUG(dbgs() << *CI[K].Iterations);
2920     else
2921       DEBUG(dbgs() << "+inf");
2922     DEBUG(dbgs() << '\n');
2923   }
2924   DEBUG(dbgs() << "\t    Constant = " << *Subscript << '\n');
2925 #endif
2926   return CI;
2927 }
2928
2929
2930 // Looks through all the bounds info and
2931 // computes the lower bound given the current direction settings
2932 // at each level. If the lower bound for any level is -inf,
2933 // the result is -inf.
2934 const SCEV *DependenceAnalysis::getLowerBound(BoundInfo *Bound) const {
2935   const SCEV *Sum = Bound[1].Lower[Bound[1].Direction];
2936   for (unsigned K = 2; Sum && K <= MaxLevels; ++K) {
2937     if (Bound[K].Lower[Bound[K].Direction])
2938       Sum = SE->getAddExpr(Sum, Bound[K].Lower[Bound[K].Direction]);
2939     else
2940       Sum = nullptr;
2941   }
2942   return Sum;
2943 }
2944
2945
2946 // Looks through all the bounds info and
2947 // computes the upper bound given the current direction settings
2948 // at each level. If the upper bound at any level is +inf,
2949 // the result is +inf.
2950 const SCEV *DependenceAnalysis::getUpperBound(BoundInfo *Bound) const {
2951   const SCEV *Sum = Bound[1].Upper[Bound[1].Direction];
2952   for (unsigned K = 2; Sum && K <= MaxLevels; ++K) {
2953     if (Bound[K].Upper[Bound[K].Direction])
2954       Sum = SE->getAddExpr(Sum, Bound[K].Upper[Bound[K].Direction]);
2955     else
2956       Sum = nullptr;
2957   }
2958   return Sum;
2959 }
2960
2961
2962 //===----------------------------------------------------------------------===//
2963 // Constraint manipulation for Delta test.
2964
2965 // Given a linear SCEV,
2966 // return the coefficient (the step)
2967 // corresponding to the specified loop.
2968 // If there isn't one, return 0.
2969 // For example, given a*i + b*j + c*k, finding the coefficient
2970 // corresponding to the j loop would yield b.
2971 const SCEV *DependenceAnalysis::findCoefficient(const SCEV *Expr,
2972                                                 const Loop *TargetLoop)  const {
2973   const SCEVAddRecExpr *AddRec = dyn_cast<SCEVAddRecExpr>(Expr);
2974   if (!AddRec)
2975     return SE->getZero(Expr->getType());
2976   if (AddRec->getLoop() == TargetLoop)
2977     return AddRec->getStepRecurrence(*SE);
2978   return findCoefficient(AddRec->getStart(), TargetLoop);
2979 }
2980
2981
2982 // Given a linear SCEV,
2983 // return the SCEV given by zeroing out the coefficient
2984 // corresponding to the specified loop.
2985 // For example, given a*i + b*j + c*k, zeroing the coefficient
2986 // corresponding to the j loop would yield a*i + c*k.
2987 const SCEV *DependenceAnalysis::zeroCoefficient(const SCEV *Expr,
2988                                                 const Loop *TargetLoop)  const {
2989   const SCEVAddRecExpr *AddRec = dyn_cast<SCEVAddRecExpr>(Expr);
2990   if (!AddRec)
2991     return Expr; // ignore
2992   if (AddRec->getLoop() == TargetLoop)
2993     return AddRec->getStart();
2994   return SE->getAddRecExpr(zeroCoefficient(AddRec->getStart(), TargetLoop),
2995                            AddRec->getStepRecurrence(*SE),
2996                            AddRec->getLoop(),
2997                            AddRec->getNoWrapFlags());
2998 }
2999
3000
3001 // Given a linear SCEV Expr,
3002 // return the SCEV given by adding some Value to the
3003 // coefficient corresponding to the specified TargetLoop.
3004 // For example, given a*i + b*j + c*k, adding 1 to the coefficient
3005 // corresponding to the j loop would yield a*i + (b+1)*j + c*k.
3006 const SCEV *DependenceAnalysis::addToCoefficient(const SCEV *Expr,
3007                                                  const Loop *TargetLoop,
3008                                                  const SCEV *Value)  const {
3009   const SCEVAddRecExpr *AddRec = dyn_cast<SCEVAddRecExpr>(Expr);
3010   if (!AddRec) // create a new addRec
3011     return SE->getAddRecExpr(Expr,
3012                              Value,
3013                              TargetLoop,
3014                              SCEV::FlagAnyWrap); // Worst case, with no info.
3015   if (AddRec->getLoop() == TargetLoop) {
3016     const SCEV *Sum = SE->getAddExpr(AddRec->getStepRecurrence(*SE), Value);
3017     if (Sum->isZero())
3018       return AddRec->getStart();
3019     return SE->getAddRecExpr(AddRec->getStart(),
3020                              Sum,
3021                              AddRec->getLoop(),
3022                              AddRec->getNoWrapFlags());
3023   }
3024   if (SE->isLoopInvariant(AddRec, TargetLoop))
3025     return SE->getAddRecExpr(AddRec, Value, TargetLoop, SCEV::FlagAnyWrap);
3026   return SE->getAddRecExpr(
3027       addToCoefficient(AddRec->getStart(), TargetLoop, Value),
3028       AddRec->getStepRecurrence(*SE), AddRec->getLoop(),
3029       AddRec->getNoWrapFlags());
3030 }
3031
3032
3033 // Review the constraints, looking for opportunities
3034 // to simplify a subscript pair (Src and Dst).
3035 // Return true if some simplification occurs.
3036 // If the simplification isn't exact (that is, if it is conservative
3037 // in terms of dependence), set consistent to false.
3038 // Corresponds to Figure 5 from the paper
3039 //
3040 //            Practical Dependence Testing
3041 //            Goff, Kennedy, Tseng
3042 //            PLDI 1991
3043 bool DependenceAnalysis::propagate(const SCEV *&Src,
3044                                    const SCEV *&Dst,
3045                                    SmallBitVector &Loops,
3046                                    SmallVectorImpl<Constraint> &Constraints,
3047                                    bool &Consistent) {
3048   bool Result = false;
3049   for (int LI = Loops.find_first(); LI >= 0; LI = Loops.find_next(LI)) {
3050     DEBUG(dbgs() << "\t    Constraint[" << LI << "] is");
3051     DEBUG(Constraints[LI].dump(dbgs()));
3052     if (Constraints[LI].isDistance())
3053       Result |= propagateDistance(Src, Dst, Constraints[LI], Consistent);
3054     else if (Constraints[LI].isLine())
3055       Result |= propagateLine(Src, Dst, Constraints[LI], Consistent);
3056     else if (Constraints[LI].isPoint())
3057       Result |= propagatePoint(Src, Dst, Constraints[LI]);
3058   }
3059   return Result;
3060 }
3061
3062
3063 // Attempt to propagate a distance
3064 // constraint into a subscript pair (Src and Dst).
3065 // Return true if some simplification occurs.
3066 // If the simplification isn't exact (that is, if it is conservative
3067 // in terms of dependence), set consistent to false.
3068 bool DependenceAnalysis::propagateDistance(const SCEV *&Src,
3069                                            const SCEV *&Dst,
3070                                            Constraint &CurConstraint,
3071                                            bool &Consistent) {
3072   const Loop *CurLoop = CurConstraint.getAssociatedLoop();
3073   DEBUG(dbgs() << "\t\tSrc is " << *Src << "\n");
3074   const SCEV *A_K = findCoefficient(Src, CurLoop);
3075   if (A_K->isZero())
3076     return false;
3077   const SCEV *DA_K = SE->getMulExpr(A_K, CurConstraint.getD());
3078   Src = SE->getMinusSCEV(Src, DA_K);
3079   Src = zeroCoefficient(Src, CurLoop);
3080   DEBUG(dbgs() << "\t\tnew Src is " << *Src << "\n");
3081   DEBUG(dbgs() << "\t\tDst is " << *Dst << "\n");
3082   Dst = addToCoefficient(Dst, CurLoop, SE->getNegativeSCEV(A_K));
3083   DEBUG(dbgs() << "\t\tnew Dst is " << *Dst << "\n");
3084   if (!findCoefficient(Dst, CurLoop)->isZero())
3085     Consistent = false;
3086   return true;
3087 }
3088
3089
3090 // Attempt to propagate a line
3091 // constraint into a subscript pair (Src and Dst).
3092 // Return true if some simplification occurs.
3093 // If the simplification isn't exact (that is, if it is conservative
3094 // in terms of dependence), set consistent to false.
3095 bool DependenceAnalysis::propagateLine(const SCEV *&Src,
3096                                        const SCEV *&Dst,
3097                                        Constraint &CurConstraint,
3098                                        bool &Consistent) {
3099   const Loop *CurLoop = CurConstraint.getAssociatedLoop();
3100   const SCEV *A = CurConstraint.getA();
3101   const SCEV *B = CurConstraint.getB();
3102   const SCEV *C = CurConstraint.getC();
3103   DEBUG(dbgs() << "\t\tA = " << *A << ", B = " << *B << ", C = " << *C << "\n");
3104   DEBUG(dbgs() << "\t\tSrc = " << *Src << "\n");
3105   DEBUG(dbgs() << "\t\tDst = " << *Dst << "\n");
3106   if (A->isZero()) {
3107     const SCEVConstant *Bconst = dyn_cast<SCEVConstant>(B);
3108     const SCEVConstant *Cconst = dyn_cast<SCEVConstant>(C);
3109     if (!Bconst || !Cconst) return false;
3110     APInt Beta = Bconst->getAPInt();
3111     APInt Charlie = Cconst->getAPInt();
3112     APInt CdivB = Charlie.sdiv(Beta);
3113     assert(Charlie.srem(Beta) == 0 && "C should be evenly divisible by B");
3114     const SCEV *AP_K = findCoefficient(Dst, CurLoop);
3115     //    Src = SE->getAddExpr(Src, SE->getMulExpr(AP_K, SE->getConstant(CdivB)));
3116     Src = SE->getMinusSCEV(Src, SE->getMulExpr(AP_K, SE->getConstant(CdivB)));
3117     Dst = zeroCoefficient(Dst, CurLoop);
3118     if (!findCoefficient(Src, CurLoop)->isZero())
3119       Consistent = false;
3120   }
3121   else if (B->isZero()) {
3122     const SCEVConstant *Aconst = dyn_cast<SCEVConstant>(A);
3123     const SCEVConstant *Cconst = dyn_cast<SCEVConstant>(C);
3124     if (!Aconst || !Cconst) return false;
3125     APInt Alpha = Aconst->getAPInt();
3126     APInt Charlie = Cconst->getAPInt();
3127     APInt CdivA = Charlie.sdiv(Alpha);
3128     assert(Charlie.srem(Alpha) == 0 && "C should be evenly divisible by A");
3129     const SCEV *A_K = findCoefficient(Src, CurLoop);
3130     Src = SE->getAddExpr(Src, SE->getMulExpr(A_K, SE->getConstant(CdivA)));
3131     Src = zeroCoefficient(Src, CurLoop);
3132     if (!findCoefficient(Dst, CurLoop)->isZero())
3133       Consistent = false;
3134   }
3135   else if (isKnownPredicate(CmpInst::ICMP_EQ, A, B)) {
3136     const SCEVConstant *Aconst = dyn_cast<SCEVConstant>(A);
3137     const SCEVConstant *Cconst = dyn_cast<SCEVConstant>(C);
3138     if (!Aconst || !Cconst) return false;
3139     APInt Alpha = Aconst->getAPInt();
3140     APInt Charlie = Cconst->getAPInt();
3141     APInt CdivA = Charlie.sdiv(Alpha);
3142     assert(Charlie.srem(Alpha) == 0 && "C should be evenly divisible by A");
3143     const SCEV *A_K = findCoefficient(Src, CurLoop);
3144     Src = SE->getAddExpr(Src, SE->getMulExpr(A_K, SE->getConstant(CdivA)));
3145     Src = zeroCoefficient(Src, CurLoop);
3146     Dst = addToCoefficient(Dst, CurLoop, A_K);
3147     if (!findCoefficient(Dst, CurLoop)->isZero())
3148       Consistent = false;
3149   }
3150   else {
3151     // paper is incorrect here, or perhaps just misleading
3152     const SCEV *A_K = findCoefficient(Src, CurLoop);
3153     Src = SE->getMulExpr(Src, A);
3154     Dst = SE->getMulExpr(Dst, A);
3155     Src = SE->getAddExpr(Src, SE->getMulExpr(A_K, C));
3156     Src = zeroCoefficient(Src, CurLoop);
3157     Dst = addToCoefficient(Dst, CurLoop, SE->getMulExpr(A_K, B));
3158     if (!findCoefficient(Dst, CurLoop)->isZero())
3159       Consistent = false;
3160   }
3161   DEBUG(dbgs() << "\t\tnew Src = " << *Src << "\n");
3162   DEBUG(dbgs() << "\t\tnew Dst = " << *Dst << "\n");
3163   return true;
3164 }
3165
3166
3167 // Attempt to propagate a point
3168 // constraint into a subscript pair (Src and Dst).
3169 // Return true if some simplification occurs.
3170 bool DependenceAnalysis::propagatePoint(const SCEV *&Src,
3171                                         const SCEV *&Dst,
3172                                         Constraint &CurConstraint) {
3173   const Loop *CurLoop = CurConstraint.getAssociatedLoop();
3174   const SCEV *A_K = findCoefficient(Src, CurLoop);
3175   const SCEV *AP_K = findCoefficient(Dst, CurLoop);
3176   const SCEV *XA_K = SE->getMulExpr(A_K, CurConstraint.getX());
3177   const SCEV *YAP_K = SE->getMulExpr(AP_K, CurConstraint.getY());
3178   DEBUG(dbgs() << "\t\tSrc is " << *Src << "\n");
3179   Src = SE->getAddExpr(Src, SE->getMinusSCEV(XA_K, YAP_K));
3180   Src = zeroCoefficient(Src, CurLoop);
3181   DEBUG(dbgs() << "\t\tnew Src is " << *Src << "\n");
3182   DEBUG(dbgs() << "\t\tDst is " << *Dst << "\n");
3183   Dst = zeroCoefficient(Dst, CurLoop);
3184   DEBUG(dbgs() << "\t\tnew Dst is " << *Dst << "\n");
3185   return true;
3186 }
3187
3188
3189 // Update direction vector entry based on the current constraint.
3190 void DependenceAnalysis::updateDirection(Dependence::DVEntry &Level,
3191                                          const Constraint &CurConstraint
3192                                          ) const {
3193   DEBUG(dbgs() << "\tUpdate direction, constraint =");
3194   DEBUG(CurConstraint.dump(dbgs()));
3195   if (CurConstraint.isAny())
3196     ; // use defaults
3197   else if (CurConstraint.isDistance()) {
3198     // this one is consistent, the others aren't
3199     Level.Scalar = false;
3200     Level.Distance = CurConstraint.getD();
3201     unsigned NewDirection = Dependence::DVEntry::NONE;
3202     if (!SE->isKnownNonZero(Level.Distance)) // if may be zero
3203       NewDirection = Dependence::DVEntry::EQ;
3204     if (!SE->isKnownNonPositive(Level.Distance)) // if may be positive
3205       NewDirection |= Dependence::DVEntry::LT;
3206     if (!SE->isKnownNonNegative(Level.Distance)) // if may be negative
3207       NewDirection |= Dependence::DVEntry::GT;
3208     Level.Direction &= NewDirection;
3209   }
3210   else if (CurConstraint.isLine()) {
3211     Level.Scalar = false;
3212     Level.Distance = nullptr;
3213     // direction should be accurate
3214   }
3215   else if (CurConstraint.isPoint()) {
3216     Level.Scalar = false;
3217     Level.Distance = nullptr;
3218     unsigned NewDirection = Dependence::DVEntry::NONE;
3219     if (!isKnownPredicate(CmpInst::ICMP_NE,
3220                           CurConstraint.getY(),
3221                           CurConstraint.getX()))
3222       // if X may be = Y
3223       NewDirection |= Dependence::DVEntry::EQ;
3224     if (!isKnownPredicate(CmpInst::ICMP_SLE,
3225                           CurConstraint.getY(),
3226                           CurConstraint.getX()))
3227       // if Y may be > X
3228       NewDirection |= Dependence::DVEntry::LT;
3229     if (!isKnownPredicate(CmpInst::ICMP_SGE,
3230                           CurConstraint.getY(),
3231                           CurConstraint.getX()))
3232       // if Y may be < X
3233       NewDirection |= Dependence::DVEntry::GT;
3234     Level.Direction &= NewDirection;
3235   }
3236   else
3237     llvm_unreachable("constraint has unexpected kind");
3238 }
3239
3240 /// Check if we can delinearize the subscripts. If the SCEVs representing the
3241 /// source and destination array references are recurrences on a nested loop,
3242 /// this function flattens the nested recurrences into separate recurrences
3243 /// for each loop level.
3244 bool DependenceAnalysis::tryDelinearize(Instruction *Src,
3245                                         Instruction *Dst,
3246                                         SmallVectorImpl<Subscript> &Pair)
3247 {
3248   Value *SrcPtr = getPointerOperand(Src);
3249   Value *DstPtr = getPointerOperand(Dst);
3250
3251   Loop *SrcLoop = LI->getLoopFor(Src->getParent());
3252   Loop *DstLoop = LI->getLoopFor(Dst->getParent());
3253
3254   // Below code mimics the code in Delinearization.cpp
3255   const SCEV *SrcAccessFn =
3256     SE->getSCEVAtScope(SrcPtr, SrcLoop);
3257   const SCEV *DstAccessFn =
3258     SE->getSCEVAtScope(DstPtr, DstLoop);
3259
3260   const SCEVUnknown *SrcBase =
3261       dyn_cast<SCEVUnknown>(SE->getPointerBase(SrcAccessFn));
3262   const SCEVUnknown *DstBase =
3263       dyn_cast<SCEVUnknown>(SE->getPointerBase(DstAccessFn));
3264
3265   if (!SrcBase || !DstBase || SrcBase != DstBase)
3266     return false;
3267
3268   const SCEV *ElementSize = SE->getElementSize(Src);
3269   if (ElementSize != SE->getElementSize(Dst))
3270     return false;
3271
3272   const SCEV *SrcSCEV = SE->getMinusSCEV(SrcAccessFn, SrcBase);
3273   const SCEV *DstSCEV = SE->getMinusSCEV(DstAccessFn, DstBase);
3274
3275   const SCEVAddRecExpr *SrcAR = dyn_cast<SCEVAddRecExpr>(SrcSCEV);
3276   const SCEVAddRecExpr *DstAR = dyn_cast<SCEVAddRecExpr>(DstSCEV);
3277   if (!SrcAR || !DstAR || !SrcAR->isAffine() || !DstAR->isAffine())
3278     return false;
3279
3280   // First step: collect parametric terms in both array references.
3281   SmallVector<const SCEV *, 4> Terms;
3282   SE->collectParametricTerms(SrcAR, Terms);
3283   SE->collectParametricTerms(DstAR, Terms);
3284
3285   // Second step: find subscript sizes.
3286   SmallVector<const SCEV *, 4> Sizes;
3287   SE->findArrayDimensions(Terms, Sizes, ElementSize);
3288
3289   // Third step: compute the access functions for each subscript.
3290   SmallVector<const SCEV *, 4> SrcSubscripts, DstSubscripts;
3291   SE->computeAccessFunctions(SrcAR, SrcSubscripts, Sizes);
3292   SE->computeAccessFunctions(DstAR, DstSubscripts, Sizes);
3293
3294   // Fail when there is only a subscript: that's a linearized access function.
3295   if (SrcSubscripts.size() < 2 || DstSubscripts.size() < 2 ||
3296       SrcSubscripts.size() != DstSubscripts.size())
3297     return false;
3298
3299   int size = SrcSubscripts.size();
3300
3301   DEBUG({
3302       dbgs() << "\nSrcSubscripts: ";
3303     for (int i = 0; i < size; i++)
3304       dbgs() << *SrcSubscripts[i];
3305     dbgs() << "\nDstSubscripts: ";
3306     for (int i = 0; i < size; i++)
3307       dbgs() << *DstSubscripts[i];
3308     });
3309
3310   // The delinearization transforms a single-subscript MIV dependence test into
3311   // a multi-subscript SIV dependence test that is easier to compute. So we
3312   // resize Pair to contain as many pairs of subscripts as the delinearization
3313   // has found, and then initialize the pairs following the delinearization.
3314   Pair.resize(size);
3315   for (int i = 0; i < size; ++i) {
3316     Pair[i].Src = SrcSubscripts[i];
3317     Pair[i].Dst = DstSubscripts[i];
3318     unifySubscriptType(&Pair[i]);
3319
3320     // FIXME: we should record the bounds SrcSizes[i] and DstSizes[i] that the
3321     // delinearization has found, and add these constraints to the dependence
3322     // check to avoid memory accesses overflow from one dimension into another.
3323     // This is related to the problem of determining the existence of data
3324     // dependences in array accesses using a different number of subscripts: in
3325     // C one can access an array A[100][100]; as A[0][9999], *A[9999], etc.
3326   }
3327
3328   return true;
3329 }
3330
3331 //===----------------------------------------------------------------------===//
3332
3333 #ifndef NDEBUG
3334 // For debugging purposes, dump a small bit vector to dbgs().
3335 static void dumpSmallBitVector(SmallBitVector &BV) {
3336   dbgs() << "{";
3337   for (int VI = BV.find_first(); VI >= 0; VI = BV.find_next(VI)) {
3338     dbgs() << VI;
3339     if (BV.find_next(VI) >= 0)
3340       dbgs() << ' ';
3341   }
3342   dbgs() << "}\n";
3343 }
3344 #endif
3345
3346 // depends -
3347 // Returns NULL if there is no dependence.
3348 // Otherwise, return a Dependence with as many details as possible.
3349 // Corresponds to Section 3.1 in the paper
3350 //
3351 //            Practical Dependence Testing
3352 //            Goff, Kennedy, Tseng
3353 //            PLDI 1991
3354 //
3355 // Care is required to keep the routine below, getSplitIteration(),
3356 // up to date with respect to this routine.
3357 std::unique_ptr<Dependence>
3358 DependenceAnalysis::depends(Instruction *Src, Instruction *Dst,
3359                             bool PossiblyLoopIndependent) {
3360   if (Src == Dst)
3361     PossiblyLoopIndependent = false;
3362
3363   if ((!Src->mayReadFromMemory() && !Src->mayWriteToMemory()) ||
3364       (!Dst->mayReadFromMemory() && !Dst->mayWriteToMemory()))
3365     // if both instructions don't reference memory, there's no dependence
3366     return nullptr;
3367
3368   if (!isLoadOrStore(Src) || !isLoadOrStore(Dst)) {
3369     // can only analyze simple loads and stores, i.e., no calls, invokes, etc.
3370     DEBUG(dbgs() << "can only handle simple loads and stores\n");
3371     return make_unique<Dependence>(Src, Dst);
3372   }
3373
3374   Value *SrcPtr = getPointerOperand(Src);
3375   Value *DstPtr = getPointerOperand(Dst);
3376
3377   switch (underlyingObjectsAlias(AA, F->getParent()->getDataLayout(), DstPtr,
3378                                  SrcPtr)) {
3379   case MayAlias:
3380   case PartialAlias:
3381     // cannot analyse objects if we don't understand their aliasing.
3382     DEBUG(dbgs() << "can't analyze may or partial alias\n");
3383     return make_unique<Dependence>(Src, Dst);
3384   case NoAlias:
3385     // If the objects noalias, they are distinct, accesses are independent.
3386     DEBUG(dbgs() << "no alias\n");
3387     return nullptr;
3388   case MustAlias:
3389     break; // The underlying objects alias; test accesses for dependence.
3390   }
3391
3392   // establish loop nesting levels
3393   establishNestingLevels(Src, Dst);
3394   DEBUG(dbgs() << "    common nesting levels = " << CommonLevels << "\n");
3395   DEBUG(dbgs() << "    maximum nesting levels = " << MaxLevels << "\n");
3396
3397   FullDependence Result(Src, Dst, PossiblyLoopIndependent, CommonLevels);
3398   ++TotalArrayPairs;
3399
3400   // See if there are GEPs we can use.
3401   bool UsefulGEP = false;
3402   GEPOperator *SrcGEP = dyn_cast<GEPOperator>(SrcPtr);
3403   GEPOperator *DstGEP = dyn_cast<GEPOperator>(DstPtr);
3404   if (SrcGEP && DstGEP &&
3405       SrcGEP->getPointerOperandType() == DstGEP->getPointerOperandType()) {
3406     const SCEV *SrcPtrSCEV = SE->getSCEV(SrcGEP->getPointerOperand());
3407     const SCEV *DstPtrSCEV = SE->getSCEV(DstGEP->getPointerOperand());
3408     DEBUG(dbgs() << "    SrcPtrSCEV = " << *SrcPtrSCEV << "\n");
3409     DEBUG(dbgs() << "    DstPtrSCEV = " << *DstPtrSCEV << "\n");
3410
3411     UsefulGEP = isLoopInvariant(SrcPtrSCEV, LI->getLoopFor(Src->getParent())) &&
3412                 isLoopInvariant(DstPtrSCEV, LI->getLoopFor(Dst->getParent())) &&
3413                 (SrcGEP->getNumOperands() == DstGEP->getNumOperands());
3414   }
3415   unsigned Pairs = UsefulGEP ? SrcGEP->idx_end() - SrcGEP->idx_begin() : 1;
3416   SmallVector<Subscript, 4> Pair(Pairs);
3417   if (UsefulGEP) {
3418     DEBUG(dbgs() << "    using GEPs\n");
3419     unsigned P = 0;
3420     for (GEPOperator::const_op_iterator SrcIdx = SrcGEP->idx_begin(),
3421            SrcEnd = SrcGEP->idx_end(),
3422            DstIdx = DstGEP->idx_begin();
3423          SrcIdx != SrcEnd;
3424          ++SrcIdx, ++DstIdx, ++P) {
3425       Pair[P].Src = SE->getSCEV(*SrcIdx);
3426       Pair[P].Dst = SE->getSCEV(*DstIdx);
3427       unifySubscriptType(&Pair[P]);
3428     }
3429   }
3430   else {
3431     DEBUG(dbgs() << "    ignoring GEPs\n");
3432     const SCEV *SrcSCEV = SE->getSCEV(SrcPtr);
3433     const SCEV *DstSCEV = SE->getSCEV(DstPtr);
3434     DEBUG(dbgs() << "    SrcSCEV = " << *SrcSCEV << "\n");
3435     DEBUG(dbgs() << "    DstSCEV = " << *DstSCEV << "\n");
3436     Pair[0].Src = SrcSCEV;
3437     Pair[0].Dst = DstSCEV;
3438   }
3439
3440   if (Delinearize && CommonLevels > 1) {
3441     if (tryDelinearize(Src, Dst, Pair)) {
3442       DEBUG(dbgs() << "    delinerized GEP\n");
3443       Pairs = Pair.size();
3444     }
3445   }
3446
3447   for (unsigned P = 0; P < Pairs; ++P) {
3448     Pair[P].Loops.resize(MaxLevels + 1);
3449     Pair[P].GroupLoops.resize(MaxLevels + 1);
3450     Pair[P].Group.resize(Pairs);
3451     removeMatchingExtensions(&Pair[P]);
3452     Pair[P].Classification =
3453       classifyPair(Pair[P].Src, LI->getLoopFor(Src->getParent()),
3454                    Pair[P].Dst, LI->getLoopFor(Dst->getParent()),
3455                    Pair[P].Loops);
3456     Pair[P].GroupLoops = Pair[P].Loops;
3457     Pair[P].Group.set(P);
3458     DEBUG(dbgs() << "    subscript " << P << "\n");
3459     DEBUG(dbgs() << "\tsrc = " << *Pair[P].Src << "\n");
3460     DEBUG(dbgs() << "\tdst = " << *Pair[P].Dst << "\n");
3461     DEBUG(dbgs() << "\tclass = " << Pair[P].Classification << "\n");
3462     DEBUG(dbgs() << "\tloops = ");
3463     DEBUG(dumpSmallBitVector(Pair[P].Loops));
3464   }
3465
3466   SmallBitVector Separable(Pairs);
3467   SmallBitVector Coupled(Pairs);
3468
3469   // Partition subscripts into separable and minimally-coupled groups
3470   // Algorithm in paper is algorithmically better;
3471   // this may be faster in practice. Check someday.
3472   //
3473   // Here's an example of how it works. Consider this code:
3474   //
3475   //   for (i = ...) {
3476   //     for (j = ...) {
3477   //       for (k = ...) {
3478   //         for (l = ...) {
3479   //           for (m = ...) {
3480   //             A[i][j][k][m] = ...;
3481   //             ... = A[0][j][l][i + j];
3482   //           }
3483   //         }
3484   //       }
3485   //     }
3486   //   }
3487   //
3488   // There are 4 subscripts here:
3489   //    0 [i] and [0]
3490   //    1 [j] and [j]
3491   //    2 [k] and [l]
3492   //    3 [m] and [i + j]
3493   //
3494   // We've already classified each subscript pair as ZIV, SIV, etc.,
3495   // and collected all the loops mentioned by pair P in Pair[P].Loops.
3496   // In addition, we've initialized Pair[P].GroupLoops to Pair[P].Loops
3497   // and set Pair[P].Group = {P}.
3498   //
3499   //      Src Dst    Classification Loops  GroupLoops Group
3500   //    0 [i] [0]         SIV       {1}      {1}        {0}
3501   //    1 [j] [j]         SIV       {2}      {2}        {1}
3502   //    2 [k] [l]         RDIV      {3,4}    {3,4}      {2}
3503   //    3 [m] [i + j]     MIV       {1,2,5}  {1,2,5}    {3}
3504   //
3505   // For each subscript SI 0 .. 3, we consider each remaining subscript, SJ.
3506   // So, 0 is compared against 1, 2, and 3; 1 is compared against 2 and 3, etc.
3507   //
3508   // We begin by comparing 0 and 1. The intersection of the GroupLoops is empty.
3509   // Next, 0 and 2. Again, the intersection of their GroupLoops is empty.
3510   // Next 0 and 3. The intersection of their GroupLoop = {1}, not empty,
3511   // so Pair[3].Group = {0,3} and Done = false (that is, 0 will not be added
3512   // to either Separable or Coupled).
3513   //
3514   // Next, we consider 1 and 2. The intersection of the GroupLoops is empty.
3515   // Next, 1 and 3. The intersectionof their GroupLoops = {2}, not empty,
3516   // so Pair[3].Group = {0, 1, 3} and Done = false.
3517   //
3518   // Next, we compare 2 against 3. The intersection of the GroupLoops is empty.
3519   // Since Done remains true, we add 2 to the set of Separable pairs.
3520   //
3521   // Finally, we consider 3. There's nothing to compare it with,
3522   // so Done remains true and we add it to the Coupled set.
3523   // Pair[3].Group = {0, 1, 3} and GroupLoops = {1, 2, 5}.
3524   //
3525   // In the end, we've got 1 separable subscript and 1 coupled group.
3526   for (unsigned SI = 0; SI < Pairs; ++SI) {
3527     if (Pair[SI].Classification == Subscript::NonLinear) {
3528       // ignore these, but collect loops for later
3529       ++NonlinearSubscriptPairs;
3530       collectCommonLoops(Pair[SI].Src,
3531                          LI->getLoopFor(Src->getParent()),
3532                          Pair[SI].Loops);
3533       collectCommonLoops(Pair[SI].Dst,
3534                          LI->getLoopFor(Dst->getParent()),
3535                          Pair[SI].Loops);
3536       Result.Consistent = false;
3537     } else if (Pair[SI].Classification == Subscript::ZIV) {
3538       // always separable
3539       Separable.set(SI);
3540     }
3541     else {
3542       // SIV, RDIV, or MIV, so check for coupled group
3543       bool Done = true;
3544       for (unsigned SJ = SI + 1; SJ < Pairs; ++SJ) {
3545         SmallBitVector Intersection = Pair[SI].GroupLoops;
3546         Intersection &= Pair[SJ].GroupLoops;
3547         if (Intersection.any()) {
3548           // accumulate set of all the loops in group
3549           Pair[SJ].GroupLoops |= Pair[SI].GroupLoops;
3550           // accumulate set of all subscripts in group
3551           Pair[SJ].Group |= Pair[SI].Group;
3552           Done = false;
3553         }
3554       }
3555       if (Done) {
3556         if (Pair[SI].Group.count() == 1) {
3557           Separable.set(SI);
3558           ++SeparableSubscriptPairs;
3559         }
3560         else {
3561           Coupled.set(SI);
3562           ++CoupledSubscriptPairs;
3563         }
3564       }
3565     }
3566   }
3567
3568   DEBUG(dbgs() << "    Separable = ");
3569   DEBUG(dumpSmallBitVector(Separable));
3570   DEBUG(dbgs() << "    Coupled = ");
3571   DEBUG(dumpSmallBitVector(Coupled));
3572
3573   Constraint NewConstraint;
3574   NewConstraint.setAny(SE);
3575
3576   // test separable subscripts
3577   for (int SI = Separable.find_first(); SI >= 0; SI = Separable.find_next(SI)) {
3578     DEBUG(dbgs() << "testing subscript " << SI);
3579     switch (Pair[SI].Classification) {
3580     case Subscript::ZIV:
3581       DEBUG(dbgs() << ", ZIV\n");
3582       if (testZIV(Pair[SI].Src, Pair[SI].Dst, Result))
3583         return nullptr;
3584       break;
3585     case Subscript::SIV: {
3586       DEBUG(dbgs() << ", SIV\n");
3587       unsigned Level;
3588       const SCEV *SplitIter = nullptr;
3589       if (testSIV(Pair[SI].Src, Pair[SI].Dst, Level, Result, NewConstraint,
3590                   SplitIter))
3591         return nullptr;
3592       break;
3593     }
3594     case Subscript::RDIV:
3595       DEBUG(dbgs() << ", RDIV\n");
3596       if (testRDIV(Pair[SI].Src, Pair[SI].Dst, Result))
3597         return nullptr;
3598       break;
3599     case Subscript::MIV:
3600       DEBUG(dbgs() << ", MIV\n");
3601       if (testMIV(Pair[SI].Src, Pair[SI].Dst, Pair[SI].Loops, Result))
3602         return nullptr;
3603       break;
3604     default:
3605       llvm_unreachable("subscript has unexpected classification");
3606     }
3607   }
3608
3609   if (Coupled.count()) {
3610     // test coupled subscript groups
3611     DEBUG(dbgs() << "starting on coupled subscripts\n");
3612     DEBUG(dbgs() << "MaxLevels + 1 = " << MaxLevels + 1 << "\n");
3613     SmallVector<Constraint, 4> Constraints(MaxLevels + 1);
3614     for (unsigned II = 0; II <= MaxLevels; ++II)
3615       Constraints[II].setAny(SE);
3616     for (int SI = Coupled.find_first(); SI >= 0; SI = Coupled.find_next(SI)) {
3617       DEBUG(dbgs() << "testing subscript group " << SI << " { ");
3618       SmallBitVector Group(Pair[SI].Group);
3619       SmallBitVector Sivs(Pairs);
3620       SmallBitVector Mivs(Pairs);
3621       SmallBitVector ConstrainedLevels(MaxLevels + 1);
3622       SmallVector<Subscript *, 4> PairsInGroup;
3623       for (int SJ = Group.find_first(); SJ >= 0; SJ = Group.find_next(SJ)) {
3624         DEBUG(dbgs() << SJ << " ");
3625         if (Pair[SJ].Classification == Subscript::SIV)
3626           Sivs.set(SJ);
3627         else
3628           Mivs.set(SJ);
3629         PairsInGroup.push_back(&Pair[SJ]);
3630       }
3631       unifySubscriptType(PairsInGroup);
3632       DEBUG(dbgs() << "}\n");
3633       while (Sivs.any()) {
3634         bool Changed = false;
3635         for (int SJ = Sivs.find_first(); SJ >= 0; SJ = Sivs.find_next(SJ)) {
3636           DEBUG(dbgs() << "testing subscript " << SJ << ", SIV\n");
3637           // SJ is an SIV subscript that's part of the current coupled group
3638           unsigned Level;
3639           const SCEV *SplitIter = nullptr;
3640           DEBUG(dbgs() << "SIV\n");
3641           if (testSIV(Pair[SJ].Src, Pair[SJ].Dst, Level, Result, NewConstraint,
3642                       SplitIter))
3643             return nullptr;
3644           ConstrainedLevels.set(Level);
3645           if (intersectConstraints(&Constraints[Level], &NewConstraint)) {
3646             if (Constraints[Level].isEmpty()) {
3647               ++DeltaIndependence;
3648               return nullptr;
3649             }
3650             Changed = true;
3651           }
3652           Sivs.reset(SJ);
3653         }
3654         if (Changed) {
3655           // propagate, possibly creating new SIVs and ZIVs
3656           DEBUG(dbgs() << "    propagating\n");
3657           DEBUG(dbgs() << "\tMivs = ");
3658           DEBUG(dumpSmallBitVector(Mivs));
3659           for (int SJ = Mivs.find_first(); SJ >= 0; SJ = Mivs.find_next(SJ)) {
3660             // SJ is an MIV subscript that's part of the current coupled group
3661             DEBUG(dbgs() << "\tSJ = " << SJ << "\n");
3662             if (propagate(Pair[SJ].Src, Pair[SJ].Dst, Pair[SJ].Loops,
3663                           Constraints, Result.Consistent)) {
3664               DEBUG(dbgs() << "\t    Changed\n");
3665               ++DeltaPropagations;
3666               Pair[SJ].Classification =
3667                 classifyPair(Pair[SJ].Src, LI->getLoopFor(Src->getParent()),
3668                              Pair[SJ].Dst, LI->getLoopFor(Dst->getParent()),
3669                              Pair[SJ].Loops);
3670               switch (Pair[SJ].Classification) {
3671               case Subscript::ZIV:
3672                 DEBUG(dbgs() << "ZIV\n");
3673                 if (testZIV(Pair[SJ].Src, Pair[SJ].Dst, Result))
3674                   return nullptr;
3675                 Mivs.reset(SJ);
3676                 break;
3677               case Subscript::SIV:
3678                 Sivs.set(SJ);
3679                 Mivs.reset(SJ);
3680                 break;
3681               case Subscript::RDIV:
3682               case Subscript::MIV:
3683                 break;
3684               default:
3685                 llvm_unreachable("bad subscript classification");
3686               }
3687             }
3688           }
3689         }
3690       }
3691
3692       // test & propagate remaining RDIVs
3693       for (int SJ = Mivs.find_first(); SJ >= 0; SJ = Mivs.find_next(SJ)) {
3694         if (Pair[SJ].Classification == Subscript::RDIV) {
3695           DEBUG(dbgs() << "RDIV test\n");
3696           if (testRDIV(Pair[SJ].Src, Pair[SJ].Dst, Result))
3697             return nullptr;
3698           // I don't yet understand how to propagate RDIV results
3699           Mivs.reset(SJ);
3700         }
3701       }
3702
3703       // test remaining MIVs
3704       // This code is temporary.
3705       // Better to somehow test all remaining subscripts simultaneously.
3706       for (int SJ = Mivs.find_first(); SJ >= 0; SJ = Mivs.find_next(SJ)) {
3707         if (Pair[SJ].Classification == Subscript::MIV) {
3708           DEBUG(dbgs() << "MIV test\n");
3709           if (testMIV(Pair[SJ].Src, Pair[SJ].Dst, Pair[SJ].Loops, Result))
3710             return nullptr;
3711         }
3712         else
3713           llvm_unreachable("expected only MIV subscripts at this point");
3714       }
3715
3716       // update Result.DV from constraint vector
3717       DEBUG(dbgs() << "    updating\n");
3718       for (int SJ = ConstrainedLevels.find_first(); SJ >= 0;
3719            SJ = ConstrainedLevels.find_next(SJ)) {
3720         if (SJ > (int)CommonLevels)
3721           break;
3722         updateDirection(Result.DV[SJ - 1], Constraints[SJ]);
3723         if (Result.DV[SJ - 1].Direction == Dependence::DVEntry::NONE)
3724           return nullptr;
3725       }
3726     }
3727   }
3728
3729   // Make sure the Scalar flags are set correctly.
3730   SmallBitVector CompleteLoops(MaxLevels + 1);
3731   for (unsigned SI = 0; SI < Pairs; ++SI)
3732     CompleteLoops |= Pair[SI].Loops;
3733   for (unsigned II = 1; II <= CommonLevels; ++II)
3734     if (CompleteLoops[II])
3735       Result.DV[II - 1].Scalar = false;
3736
3737   if (PossiblyLoopIndependent) {
3738     // Make sure the LoopIndependent flag is set correctly.
3739     // All directions must include equal, otherwise no
3740     // loop-independent dependence is possible.
3741     for (unsigned II = 1; II <= CommonLevels; ++II) {
3742       if (!(Result.getDirection(II) & Dependence::DVEntry::EQ)) {
3743         Result.LoopIndependent = false;
3744         break;
3745       }
3746     }
3747   }
3748   else {
3749     // On the other hand, if all directions are equal and there's no
3750     // loop-independent dependence possible, then no dependence exists.
3751     bool AllEqual = true;
3752     for (unsigned II = 1; II <= CommonLevels; ++II) {
3753       if (Result.getDirection(II) != Dependence::DVEntry::EQ) {
3754         AllEqual = false;
3755         break;
3756       }
3757     }
3758     if (AllEqual)
3759       return nullptr;
3760   }
3761
3762   return make_unique<FullDependence>(std::move(Result));
3763 }
3764
3765
3766
3767 //===----------------------------------------------------------------------===//
3768 // getSplitIteration -
3769 // Rather than spend rarely-used space recording the splitting iteration
3770 // during the Weak-Crossing SIV test, we re-compute it on demand.
3771 // The re-computation is basically a repeat of the entire dependence test,
3772 // though simplified since we know that the dependence exists.
3773 // It's tedious, since we must go through all propagations, etc.
3774 //
3775 // Care is required to keep this code up to date with respect to the routine
3776 // above, depends().
3777 //
3778 // Generally, the dependence analyzer will be used to build
3779 // a dependence graph for a function (basically a map from instructions
3780 // to dependences). Looking for cycles in the graph shows us loops
3781 // that cannot be trivially vectorized/parallelized.
3782 //
3783 // We can try to improve the situation by examining all the dependences
3784 // that make up the cycle, looking for ones we can break.
3785 // Sometimes, peeling the first or last iteration of a loop will break
3786 // dependences, and we've got flags for those possibilities.
3787 // Sometimes, splitting a loop at some other iteration will do the trick,
3788 // and we've got a flag for that case. Rather than waste the space to
3789 // record the exact iteration (since we rarely know), we provide
3790 // a method that calculates the iteration. It's a drag that it must work
3791 // from scratch, but wonderful in that it's possible.
3792 //
3793 // Here's an example:
3794 //
3795 //    for (i = 0; i < 10; i++)
3796 //        A[i] = ...
3797 //        ... = A[11 - i]
3798 //
3799 // There's a loop-carried flow dependence from the store to the load,
3800 // found by the weak-crossing SIV test. The dependence will have a flag,
3801 // indicating that the dependence can be broken by splitting the loop.
3802 // Calling getSplitIteration will return 5.
3803 // Splitting the loop breaks the dependence, like so:
3804 //
3805 //    for (i = 0; i <= 5; i++)
3806 //        A[i] = ...
3807 //        ... = A[11 - i]
3808 //    for (i = 6; i < 10; i++)
3809 //        A[i] = ...
3810 //        ... = A[11 - i]
3811 //
3812 // breaks the dependence and allows us to vectorize/parallelize
3813 // both loops.
3814 const  SCEV *DependenceAnalysis::getSplitIteration(const Dependence &Dep,
3815                                                    unsigned SplitLevel) {
3816   assert(Dep.isSplitable(SplitLevel) &&
3817          "Dep should be splitable at SplitLevel");
3818   Instruction *Src = Dep.getSrc();
3819   Instruction *Dst = Dep.getDst();
3820   assert(Src->mayReadFromMemory() || Src->mayWriteToMemory());
3821   assert(Dst->mayReadFromMemory() || Dst->mayWriteToMemory());
3822   assert(isLoadOrStore(Src));
3823   assert(isLoadOrStore(Dst));
3824   Value *SrcPtr = getPointerOperand(Src);
3825   Value *DstPtr = getPointerOperand(Dst);
3826   assert(underlyingObjectsAlias(AA, F->getParent()->getDataLayout(), DstPtr,
3827                                 SrcPtr) == MustAlias);
3828
3829   // establish loop nesting levels
3830   establishNestingLevels(Src, Dst);
3831
3832   FullDependence Result(Src, Dst, false, CommonLevels);
3833
3834   // See if there are GEPs we can use.
3835   bool UsefulGEP = false;
3836   GEPOperator *SrcGEP = dyn_cast<GEPOperator>(SrcPtr);
3837   GEPOperator *DstGEP = dyn_cast<GEPOperator>(DstPtr);
3838   if (SrcGEP && DstGEP &&
3839       SrcGEP->getPointerOperandType() == DstGEP->getPointerOperandType()) {
3840     const SCEV *SrcPtrSCEV = SE->getSCEV(SrcGEP->getPointerOperand());
3841     const SCEV *DstPtrSCEV = SE->getSCEV(DstGEP->getPointerOperand());
3842     UsefulGEP = isLoopInvariant(SrcPtrSCEV, LI->getLoopFor(Src->getParent())) &&
3843                 isLoopInvariant(DstPtrSCEV, LI->getLoopFor(Dst->getParent())) &&
3844                 (SrcGEP->getNumOperands() == DstGEP->getNumOperands());
3845   }
3846   unsigned Pairs = UsefulGEP ? SrcGEP->idx_end() - SrcGEP->idx_begin() : 1;
3847   SmallVector<Subscript, 4> Pair(Pairs);
3848   if (UsefulGEP) {
3849     unsigned P = 0;
3850     for (GEPOperator::const_op_iterator SrcIdx = SrcGEP->idx_begin(),
3851            SrcEnd = SrcGEP->idx_end(),
3852            DstIdx = DstGEP->idx_begin();
3853          SrcIdx != SrcEnd;
3854          ++SrcIdx, ++DstIdx, ++P) {
3855       Pair[P].Src = SE->getSCEV(*SrcIdx);
3856       Pair[P].Dst = SE->getSCEV(*DstIdx);
3857     }
3858   }
3859   else {
3860     const SCEV *SrcSCEV = SE->getSCEV(SrcPtr);
3861     const SCEV *DstSCEV = SE->getSCEV(DstPtr);
3862     Pair[0].Src = SrcSCEV;
3863     Pair[0].Dst = DstSCEV;
3864   }
3865
3866   if (Delinearize && CommonLevels > 1) {
3867     if (tryDelinearize(Src, Dst, Pair)) {
3868       DEBUG(dbgs() << "    delinerized GEP\n");
3869       Pairs = Pair.size();
3870     }
3871   }
3872
3873   for (unsigned P = 0; P < Pairs; ++P) {
3874     Pair[P].Loops.resize(MaxLevels + 1);
3875     Pair[P].GroupLoops.resize(MaxLevels + 1);
3876     Pair[P].Group.resize(Pairs);
3877     removeMatchingExtensions(&Pair[P]);
3878     Pair[P].Classification =
3879       classifyPair(Pair[P].Src, LI->getLoopFor(Src->getParent()),
3880                    Pair[P].Dst, LI->getLoopFor(Dst->getParent()),
3881                    Pair[P].Loops);
3882     Pair[P].GroupLoops = Pair[P].Loops;
3883     Pair[P].Group.set(P);
3884   }
3885
3886   SmallBitVector Separable(Pairs);
3887   SmallBitVector Coupled(Pairs);
3888
3889   // partition subscripts into separable and minimally-coupled groups
3890   for (unsigned SI = 0; SI < Pairs; ++SI) {
3891     if (Pair[SI].Classification == Subscript::NonLinear) {
3892       // ignore these, but collect loops for later
3893       collectCommonLoops(Pair[SI].Src,
3894                          LI->getLoopFor(Src->getParent()),
3895                          Pair[SI].Loops);
3896       collectCommonLoops(Pair[SI].Dst,
3897                          LI->getLoopFor(Dst->getParent()),
3898                          Pair[SI].Loops);
3899       Result.Consistent = false;
3900     }
3901     else if (Pair[SI].Classification == Subscript::ZIV)
3902       Separable.set(SI);
3903     else {
3904       // SIV, RDIV, or MIV, so check for coupled group
3905       bool Done = true;
3906       for (unsigned SJ = SI + 1; SJ < Pairs; ++SJ) {
3907         SmallBitVector Intersection = Pair[SI].GroupLoops;
3908         Intersection &= Pair[SJ].GroupLoops;
3909         if (Intersection.any()) {
3910           // accumulate set of all the loops in group
3911           Pair[SJ].GroupLoops |= Pair[SI].GroupLoops;
3912           // accumulate set of all subscripts in group
3913           Pair[SJ].Group |= Pair[SI].Group;
3914           Done = false;
3915         }
3916       }
3917       if (Done) {
3918         if (Pair[SI].Group.count() == 1)
3919           Separable.set(SI);
3920         else
3921           Coupled.set(SI);
3922       }
3923     }
3924   }
3925
3926   Constraint NewConstraint;
3927   NewConstraint.setAny(SE);
3928
3929   // test separable subscripts
3930   for (int SI = Separable.find_first(); SI >= 0; SI = Separable.find_next(SI)) {
3931     switch (Pair[SI].Classification) {
3932     case Subscript::SIV: {
3933       unsigned Level;
3934       const SCEV *SplitIter = nullptr;
3935       (void) testSIV(Pair[SI].Src, Pair[SI].Dst, Level,
3936                      Result, NewConstraint, SplitIter);
3937       if (Level == SplitLevel) {
3938         assert(SplitIter != nullptr);
3939         return SplitIter;
3940       }
3941       break;
3942     }
3943     case Subscript::ZIV:
3944     case Subscript::RDIV:
3945     case Subscript::MIV:
3946       break;
3947     default:
3948       llvm_unreachable("subscript has unexpected classification");
3949     }
3950   }
3951
3952   if (Coupled.count()) {
3953     // test coupled subscript groups
3954     SmallVector<Constraint, 4> Constraints(MaxLevels + 1);
3955     for (unsigned II = 0; II <= MaxLevels; ++II)
3956       Constraints[II].setAny(SE);
3957     for (int SI = Coupled.find_first(); SI >= 0; SI = Coupled.find_next(SI)) {
3958       SmallBitVector Group(Pair[SI].Group);
3959       SmallBitVector Sivs(Pairs);
3960       SmallBitVector Mivs(Pairs);
3961       SmallBitVector ConstrainedLevels(MaxLevels + 1);
3962       for (int SJ = Group.find_first(); SJ >= 0; SJ = Group.find_next(SJ)) {
3963         if (Pair[SJ].Classification == Subscript::SIV)
3964           Sivs.set(SJ);
3965         else
3966           Mivs.set(SJ);
3967       }
3968       while (Sivs.any()) {
3969         bool Changed = false;
3970         for (int SJ = Sivs.find_first(); SJ >= 0; SJ = Sivs.find_next(SJ)) {
3971           // SJ is an SIV subscript that's part of the current coupled group
3972           unsigned Level;
3973           const SCEV *SplitIter = nullptr;
3974           (void) testSIV(Pair[SJ].Src, Pair[SJ].Dst, Level,
3975                          Result, NewConstraint, SplitIter);
3976           if (Level == SplitLevel && SplitIter)
3977             return SplitIter;
3978           ConstrainedLevels.set(Level);
3979           if (intersectConstraints(&Constraints[Level], &NewConstraint))
3980             Changed = true;
3981           Sivs.reset(SJ);
3982         }
3983         if (Changed) {
3984           // propagate, possibly creating new SIVs and ZIVs
3985           for (int SJ = Mivs.find_first(); SJ >= 0; SJ = Mivs.find_next(SJ)) {
3986             // SJ is an MIV subscript that's part of the current coupled group
3987             if (propagate(Pair[SJ].Src, Pair[SJ].Dst,
3988                           Pair[SJ].Loops, Constraints, Result.Consistent)) {
3989               Pair[SJ].Classification =
3990                 classifyPair(Pair[SJ].Src, LI->getLoopFor(Src->getParent()),
3991                              Pair[SJ].Dst, LI->getLoopFor(Dst->getParent()),
3992                              Pair[SJ].Loops);
3993               switch (Pair[SJ].Classification) {
3994               case Subscript::ZIV:
3995                 Mivs.reset(SJ);
3996                 break;
3997               case Subscript::SIV:
3998                 Sivs.set(SJ);
3999                 Mivs.reset(SJ);
4000                 break;
4001               case Subscript::RDIV:
4002               case Subscript::MIV:
4003                 break;
4004               default:
4005                 llvm_unreachable("bad subscript classification");
4006               }
4007             }
4008           }
4009         }
4010       }
4011     }
4012   }
4013   llvm_unreachable("somehow reached end of routine");
4014   return nullptr;
4015 }