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"
22 using namespace llvm;
23
24 namespace {
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
MemDepPrinter__anonddc488440111::MemDepPrinter35 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
getAnalysisUsage__anonddc488440111::MemDepPrinter43 virtual void getAnalysisUsage(AnalysisUsage &AU) const {
44 AU.addRequiredTransitive<AliasAnalysis>();
45 AU.addRequiredTransitive<MemoryDependenceAnalysis>();
46 AU.setPreservesAll();
47 }
48
releaseMemory__anonddc488440111::MemDepPrinter49 virtual void releaseMemory() {
50 Deps.clear();
51 F = 0;
52 }
53 };
54 }
55
56 char MemDepPrinter::ID = 0;
57 INITIALIZE_PASS_BEGIN(MemDepPrinter, "print-memdeps",
58 "Print MemDeps of function", false, true)
INITIALIZE_PASS_DEPENDENCY(MemoryDependenceAnalysis)59 INITIALIZE_PASS_DEPENDENCY(MemoryDependenceAnalysis)
60 INITIALIZE_PASS_END(MemDepPrinter, "print-memdeps",
61 "Print MemDeps of function", false, true)
62
63 FunctionPass *llvm::createMemDepPrinter() {
64 return new MemDepPrinter();
65 }
66
runOnFunction(Function & F)67 bool 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.isUnknown() || Res.isClobber() || Res.isDef()) &&
83 "Local dep should be unknown, 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.isUnknown() || Res.isClobber() || Res.isDef()) &&
96 "Resolved non-local call dep should be unknown, def or "
97 "clobber!");
98 InstDeps.insert(std::make_pair(InstAndClobberFlag(Res.getInst(),
99 Res.isClobber()),
100 I->getBB()));
101 }
102 } else {
103 SmallVector<NonLocalDepResult, 4> NLDI;
104 if (LoadInst *LI = dyn_cast<LoadInst>(Inst)) {
105 // FIXME: Volatile is not handled properly here.
106 AliasAnalysis::Location Loc = AA.getLocation(LI);
107 MDA.getNonLocalPointerDependency(Loc, !LI->isVolatile(),
108 LI->getParent(), NLDI);
109 } else if (StoreInst *SI = dyn_cast<StoreInst>(Inst)) {
110 // FIXME: Volatile is not handled properly here.
111 AliasAnalysis::Location Loc = AA.getLocation(SI);
112 MDA.getNonLocalPointerDependency(Loc, false, SI->getParent(), NLDI);
113 } else if (VAArgInst *VI = dyn_cast<VAArgInst>(Inst)) {
114 AliasAnalysis::Location Loc = AA.getLocation(VI);
115 MDA.getNonLocalPointerDependency(Loc, false, VI->getParent(), NLDI);
116 } else {
117 llvm_unreachable("Unknown memory instruction!");
118 }
119
120 DepSet &InstDeps = Deps[Inst];
121 for (SmallVectorImpl<NonLocalDepResult>::const_iterator
122 I = NLDI.begin(), E = NLDI.end(); I != E; ++I) {
123 const MemDepResult &Res = I->getResult();
124 assert(Res.isClobber() != Res.isDef() &&
125 "Resolved non-local pointer dep should be def or clobber!");
126 InstDeps.insert(std::make_pair(InstAndClobberFlag(Res.getInst(),
127 Res.isClobber()),
128 I->getBB()));
129 }
130 }
131 }
132
133 return false;
134 }
135
print(raw_ostream & OS,const Module * M) const136 void MemDepPrinter::print(raw_ostream &OS, const Module *M) const {
137 for (const_inst_iterator I = inst_begin(*F), E = inst_end(*F); I != E; ++I) {
138 const Instruction *Inst = &*I;
139
140 DepSetMap::const_iterator DI = Deps.find(Inst);
141 if (DI == Deps.end())
142 continue;
143
144 const DepSet &InstDeps = DI->second;
145
146 for (DepSet::const_iterator I = InstDeps.begin(), E = InstDeps.end();
147 I != E; ++I) {
148 const Instruction *DepInst = I->first.getPointer();
149 bool isClobber = I->first.getInt();
150 const BasicBlock *DepBB = I->second;
151
152 OS << " ";
153 if (!DepInst)
154 OS << "Unknown";
155 else if (isClobber)
156 OS << "Clobber";
157 else
158 OS << " Def";
159 if (DepBB) {
160 OS << " in block ";
161 WriteAsOperand(OS, DepBB, /*PrintType=*/false, M);
162 }
163 if (DepInst) {
164 OS << " from: ";
165 if (DepInst == Inst)
166 OS << "<unspecified>";
167 else
168 DepInst->print(OS);
169 }
170 OS << "\n";
171 }
172
173 Inst->print(OS);
174 OS << "\n\n";
175 }
176 }
177