MemDepPrinter.cpp revision 6d8eb156e6be727570b300bac7712f745a318c7d 
1//===- MemDepPrinter.cpp - Printer for MemoryDependenceAnalysis -----------===//
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//
11//===----------------------------------------------------------------------===//
12
13#include "llvm/Analysis/MemoryDependenceAnalysis.h"
14#include "llvm/LLVMContext.h"
15#include "llvm/Analysis/Passes.h"
16#include "llvm/Assembly/Writer.h"
17#include "llvm/Support/CallSite.h"
18#include "llvm/Support/InstIterator.h"
19#include "llvm/Support/ErrorHandling.h"
20#include "llvm/Support/raw_ostream.h"
21#include "llvm/ADT/SetVector.h"
22using namespace llvm;
23
24namespace {
25  struct MemDepPrinter : public FunctionPass {
26    const Function *F;
27
28    typedef PointerIntPair<const Instruction *, 1> InstAndClobberFlag;
29    typedef std::pair<InstAndClobberFlag, const BasicBlock *> Dep;
30    typedef SmallSetVector<Dep, 4> DepSet;
31    typedef DenseMap<const Instruction *, DepSet> DepSetMap;
32    DepSetMap Deps;
33
34    static char ID; // Pass identifcation, replacement for typeid
35    MemDepPrinter() : FunctionPass(ID) {
36      initializeMemDepPrinterPass(*PassRegistry::getPassRegistry());
37    }
38
39    virtual bool runOnFunction(Function &F);
40
41    void print(raw_ostream &OS, const Module * = 0) const;
42
43    virtual void getAnalysisUsage(AnalysisUsage &AU) const {
44      AU.addRequiredTransitive<AliasAnalysis>();
45      AU.addRequiredTransitive<MemoryDependenceAnalysis>();
46      AU.setPreservesAll();
47    }
48
49    virtual void releaseMemory() {
50      Deps.clear();
51      F = 0;
52    }
53  };
54}
55
56char MemDepPrinter::ID = 0;
57INITIALIZE_PASS_BEGIN(MemDepPrinter, "print-memdeps",
58                      "Print MemDeps of function", false, true)
59INITIALIZE_PASS_DEPENDENCY(MemoryDependenceAnalysis)
60INITIALIZE_PASS_END(MemDepPrinter, "print-memdeps",
61                      "Print MemDeps of function", false, true)
62
63FunctionPass *llvm::createMemDepPrinter() {
64  return new MemDepPrinter();
65}
66
67bool MemDepPrinter::runOnFunction(Function &F) {
68  this->F = &F;
69  AliasAnalysis &AA = getAnalysis<AliasAnalysis>();
70  MemoryDependenceAnalysis &MDA = getAnalysis<MemoryDependenceAnalysis>();
71
72  // All this code uses non-const interfaces because MemDep is not
73  // const-friendly, though nothing is actually modified.
74  for (inst_iterator I = inst_begin(F), E = inst_end(F); I != E; ++I) {
75    Instruction *Inst = &*I;
76
77    if (!Inst->mayReadFromMemory() && !Inst->mayWriteToMemory())
78      continue;
79
80    MemDepResult Res = MDA.getDependency(Inst);
81    if (!Res.isNonLocal()) {
82      assert(Res.isClobber() != Res.isDef() &&
83             "Local dep should be def or clobber!");
84      Deps[Inst].insert(std::make_pair(InstAndClobberFlag(Res.getInst(),
85                                                          Res.isClobber()),
86                                       static_cast<BasicBlock *>(0)));
87    } else if (CallSite CS = cast<Value>(Inst)) {
88      const MemoryDependenceAnalysis::NonLocalDepInfo &NLDI =
89        MDA.getNonLocalCallDependency(CS);
90
91      DepSet &InstDeps = Deps[Inst];
92      for (MemoryDependenceAnalysis::NonLocalDepInfo::const_iterator
93           I = NLDI.begin(), E = NLDI.end(); I != E; ++I) {
94        const MemDepResult &Res = I->getResult();
95        assert(Res.isClobber() != Res.isDef() &&
96               "Resolved non-local call dep should be def or clobber!");
97        InstDeps.insert(std::make_pair(InstAndClobberFlag(Res.getInst(),
98                                                          Res.isClobber()),
99                                       I->getBB()));
100      }
101    } else {
102      SmallVector<NonLocalDepResult, 4> NLDI;
103      if (LoadInst *LI = dyn_cast<LoadInst>(Inst)) {
104        // FIXME: Volatile is not handled properly here.
105        AliasAnalysis::Location Loc = AA.getLocation(LI);
106        MDA.getNonLocalPointerDependency(Loc, !LI->isVolatile(),
107                                         LI->getParent(), NLDI);
108      } else if (StoreInst *SI = dyn_cast<StoreInst>(Inst)) {
109        // FIXME: Volatile is not handled properly here.
110        AliasAnalysis::Location Loc = AA.getLocation(SI);
111        MDA.getNonLocalPointerDependency(Loc, false, SI->getParent(), NLDI);
112      } else if (VAArgInst *VI = dyn_cast<VAArgInst>(Inst)) {
113        AliasAnalysis::Location Loc = AA.getLocation(VI);
114        MDA.getNonLocalPointerDependency(Loc, false, VI->getParent(), NLDI);
115      } else {
116        llvm_unreachable("Unknown memory instruction!");
117      }
118
119      DepSet &InstDeps = Deps[Inst];
120      for (SmallVectorImpl<NonLocalDepResult>::const_iterator
121           I = NLDI.begin(), E = NLDI.end(); I != E; ++I) {
122        const MemDepResult &Res = I->getResult();
123        assert(Res.isClobber() != Res.isDef() &&
124               "Resolved non-local pointer dep should be def or clobber!");
125        InstDeps.insert(std::make_pair(InstAndClobberFlag(Res.getInst(),
126                                                          Res.isClobber()),
127                                       I->getBB()));
128      }
129    }
130  }
131
132  return false;
133}
134
135void MemDepPrinter::print(raw_ostream &OS, const Module *M) const {
136  for (const_inst_iterator I = inst_begin(*F), E = inst_end(*F); I != E; ++I) {
137    const Instruction *Inst = &*I;
138
139    DepSetMap::const_iterator DI = Deps.find(Inst);
140    if (DI == Deps.end())
141      continue;
142
143    const DepSet &InstDeps = DI->second;
144
145    for (DepSet::const_iterator I = InstDeps.begin(), E = InstDeps.end();
146         I != E; ++I) {
147      const Instruction *DepInst = I->first.getPointer();
148      bool isClobber = I->first.getInt();
149      const BasicBlock *DepBB = I->second;
150
151      OS << "    " << (isClobber ? "Clobber" : "    Def");
152      if (DepBB) {
153        OS << " in block ";
154        WriteAsOperand(OS, DepBB, /*PrintType=*/false, M);
155      }
156      OS << " from: ";
157      if (DepInst == Inst)
158        OS << "<unspecified>";
159      else
160        DepInst->print(OS);
161      OS << "\n";
162    }
163
164    Inst->print(OS);
165    OS << "\n\n";
166  }
167}
168