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