1 //===- LoopDependenceAnalysis.cpp - LDA Implementation ----------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This is the (beginning) of an implementation of a loop dependence analysis
11 // framework, which is used to detect dependences in memory accesses in loops.
13 // Please note that this is work in progress and the interface is subject to
16 // TODO: adapt as implementation progresses.
18 //===----------------------------------------------------------------------===//
20 #define DEBUG_TYPE "lda"
21 #include "llvm/Analysis/LoopDependenceAnalysis.h"
22 #include "llvm/Analysis/LoopPass.h"
23 #include "llvm/Analysis/ScalarEvolution.h"
24 #include "llvm/Instructions.h"
27 LoopPass *llvm::createLoopDependenceAnalysisPass() {
28 return new LoopDependenceAnalysis();
31 static RegisterPass<LoopDependenceAnalysis>
32 R("lda", "Loop Dependence Analysis", false, true);
33 char LoopDependenceAnalysis::ID = 0;
35 //===----------------------------------------------------------------------===//
37 //===----------------------------------------------------------------------===//
39 static inline bool isMemRefInstr(const Value *I) {
40 return isa<LoadInst>(I) || isa<StoreInst>(I);
43 static void getMemRefInstrs(
44 const Loop *L, SmallVectorImpl<Instruction*> &memrefs) {
45 for (Loop::block_iterator b = L->block_begin(), be = L->block_end();
47 for (BasicBlock::iterator i = (*b)->begin(), ie = (*b)->end();
53 //===----------------------------------------------------------------------===//
55 //===----------------------------------------------------------------------===//
57 bool LoopDependenceAnalysis::isDependencePair(const Value *x,
58 const Value *y) const {
59 return isMemRefInstr(x) && isMemRefInstr(y)
60 && (isa<StoreInst>(x) || isa<StoreInst>(y));
63 bool LoopDependenceAnalysis::depends(Value *src, Value *dst) {
64 assert(isDependencePair(src, dst) && "Values form no dependence pair!");
68 //===----------------------------------------------------------------------===//
69 // LoopDependenceAnalysis Implementation
70 //===----------------------------------------------------------------------===//
72 bool LoopDependenceAnalysis::runOnLoop(Loop *L, LPPassManager &) {
74 SE = &getAnalysis<ScalarEvolution>();
78 void LoopDependenceAnalysis::getAnalysisUsage(AnalysisUsage &AU) const {
80 AU.addRequiredTransitive<ScalarEvolution>();
83 static void PrintLoopInfo(
84 raw_ostream &OS, LoopDependenceAnalysis *LDA, const Loop *L) {
85 if (!L->empty()) return; // ignore non-innermost loops
87 OS << "Loop at depth " << L->getLoopDepth() << ", header block: ";
88 WriteAsOperand(OS, L->getHeader(), false);
91 SmallVector<Instruction*, 8> memrefs;
92 getMemRefInstrs(L, memrefs);
93 OS << " Load/store instructions: " << memrefs.size() << "\n";
94 OS << " Pairwise dependence results:\n";
95 for (SmallVector<Instruction*, 8>::const_iterator x = memrefs.begin(),
96 end = memrefs.end(); x != end; ++x)
97 for (SmallVector<Instruction*, 8>::const_iterator y = x + 1;
99 if (LDA->isDependencePair(*x, *y))
100 OS << "\t" << (x - memrefs.begin()) << "," << (y - memrefs.begin())
101 << ": " << (LDA->depends(*x, *y) ? "dependent" : "independent")
105 void LoopDependenceAnalysis::print(raw_ostream &OS, const Module*) const {
106 // TODO: doc why const_cast is safe
107 PrintLoopInfo(OS, const_cast<LoopDependenceAnalysis*>(this), this->L);
110 void LoopDependenceAnalysis::print(std::ostream &OS, const Module *M) const {
111 raw_os_ostream os(OS);