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