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