lib/Analysis/LoopDependenceAnalysis.cpp

   1 //===- LoopDependenceAnalysis.cpp - LDA Implementation ----------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // 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.
  12 //
  13 // Please note that this is work in progress and the interface is subject to
  14 // change.
  15 //
  16 // TODO: adapt as implementation progresses.
  17 //
  18 //===----------------------------------------------------------------------===//
  19
  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"
  25 using namespace llvm;
  26
  27 LoopPass *llvm::createLoopDependenceAnalysisPass() {
  28   return new LoopDependenceAnalysis();
  29 }
  30
  31 static RegisterPass<LoopDependenceAnalysis>
  32 R("lda", "Loop Dependence Analysis", false, true);
  33 char LoopDependenceAnalysis::ID = 0;
  34
  35 //===----------------------------------------------------------------------===//
  36 //                             Utility Functions
  37 //===----------------------------------------------------------------------===//
  38
  39 static inline bool isMemRefInstr(const Value *I) {
  40   return isa<LoadInst>(I) || isa<StoreInst>(I);
  41 }
  42
  43 //===----------------------------------------------------------------------===//
  44 //                             Dependence Testing
  45 //===----------------------------------------------------------------------===//
  46
  47 bool LoopDependenceAnalysis::isDependencePair(const Value *x,
  48                                               const Value *y) const {
  49   return isMemRefInstr(x) && isMemRefInstr(y)
  50       && (isa<StoreInst>(x) || isa<StoreInst>(y));
  51 }
  52
  53 bool LoopDependenceAnalysis::depends(Value *src, Value *dst) {
  54   assert(isDependencePair(src, dst) && "Values form no dependence pair!");
  55   return true;
  56 }
  57
  58 //===----------------------------------------------------------------------===//
  59 //                   LoopDependenceAnalysis Implementation
  60 //===----------------------------------------------------------------------===//
  61
  62 bool LoopDependenceAnalysis::runOnLoop(Loop *L, LPPassManager &) {
  63   this->L = L;
  64   SE = &getAnalysis<ScalarEvolution>();
  65   return false;
  66 }
  67
  68 void LoopDependenceAnalysis::getAnalysisUsage(AnalysisUsage &AU) const {
  69   AU.setPreservesAll();
  70   AU.addRequiredTransitive<ScalarEvolution>();
  71 }
  72
  73 static void PrintLoopInfo(
  74     raw_ostream &OS, const LoopDependenceAnalysis *LDA, const Loop *L) {
  75   if (!L->empty()) return; // ignore non-innermost loops
  76
  77   OS << "Loop at depth " << L->getLoopDepth() << ", header block: ";
  78   WriteAsOperand(OS, L->getHeader(), false);
  79   OS << "\n";
  80 }
  81
  82 void LoopDependenceAnalysis::print(raw_ostream &OS, const Module*) const {
  83   PrintLoopInfo(OS, this, this->L);
  84 }
  85
  86 void LoopDependenceAnalysis::print(std::ostream &OS, const Module *M) const {
  87   raw_os_ostream os(OS);
  88   print(os, M);
  89 }