1 //===- IPModRef.cpp - Compute IP Mod/Ref information ------------*- C++ -*-===//
3 // See high-level comments in include/llvm/Analysis/IPModRef.h
5 //===----------------------------------------------------------------------===//
7 #include "llvm/Analysis/IPModRef.h"
8 #include "llvm/Analysis/DataStructure.h"
9 #include "llvm/Analysis/DSGraph.h"
10 #include "llvm/Module.h"
11 #include "llvm/Function.h"
12 #include "llvm/iMemory.h"
13 #include "llvm/iOther.h"
14 #include "Support/Statistic.h"
15 #include "Support/STLExtras.h"
16 #include "Support/StringExtras.h"
19 //----------------------------------------------------------------------------
20 // Private constants and data
21 //----------------------------------------------------------------------------
23 static RegisterAnalysis<IPModRef>
24 Z("ipmodref", "Interprocedural mod/ref analysis");
27 //----------------------------------------------------------------------------
29 //----------------------------------------------------------------------------
31 void ModRefInfo::print(std::ostream &O,
32 const std::string& sprefix) const
34 O << sprefix << "Modified nodes = " << modNodeSet;
35 O << sprefix << "Referenced nodes = " << refNodeSet;
38 void ModRefInfo::dump() const
43 //----------------------------------------------------------------------------
44 // class FunctionModRefInfo
45 //----------------------------------------------------------------------------
48 // This constructor computes a node numbering for the TD graph.
50 FunctionModRefInfo::FunctionModRefInfo(const Function& func,
53 : F(func), IPModRefObj(ipmro),
54 funcTDGraph(tdgClone),
55 funcModRefInfo(tdgClone->getGraphSize())
57 for (unsigned i=0, N = funcTDGraph->getGraphSize(); i < N; ++i)
58 NodeIds[funcTDGraph->getNodes()[i]] = i;
62 FunctionModRefInfo::~FunctionModRefInfo()
64 for(std::map<const CallInst*, ModRefInfo*>::iterator
65 I=callSiteModRefInfo.begin(), E=callSiteModRefInfo.end(); I != E; ++I)
68 // Empty map just to make problems easier to track down
69 callSiteModRefInfo.clear();
74 unsigned FunctionModRefInfo::getNodeId(const Value* value) const {
75 return getNodeId(funcTDGraph->getNodeForValue(const_cast<Value*>(value))
81 // Compute Mod/Ref bit vectors for the entire function.
82 // These are simply copies of the Read/Write flags from the nodes of
83 // the top-down DS graph.
85 void FunctionModRefInfo::computeModRef(const Function &func)
87 // Mark all nodes in the graph that are marked MOD as being mod
88 // and all those marked REF as being ref.
89 for (unsigned i = 0, N = funcTDGraph->getGraphSize(); i < N; ++i)
91 if (funcTDGraph->getNodes()[i]->isModified())
92 funcModRefInfo.setNodeIsMod(i);
93 if (funcTDGraph->getNodes()[i]->isRead())
94 funcModRefInfo.setNodeIsRef(i);
97 // Compute the Mod/Ref info for all call sites within the function.
98 // The call sites are recorded in the TD graph.
99 const std::vector<DSCallSite>& callSites = funcTDGraph->getFunctionCalls();
100 for (unsigned i = 0, N = callSites.size(); i < N; ++i)
101 computeModRef(callSites[i].getCallInst());
105 // ResolveCallSiteModRefInfo - This method performs the following actions:
107 // 1. It clones the top-down graph for the current function
108 // 2. It clears all of the mod/ref bits in the cloned graph
109 // 3. It then merges the bottom-up graph(s) for the specified call-site into
110 // the clone (bringing new mod/ref bits).
111 // 4. It returns the clone, and a mapping of nodes from the original TDGraph to
112 // the cloned graph with Mod/Ref info for the callsite.
114 // NOTE: Because this clones a dsgraph and returns it, the caller is responsible
115 // for deleting the returned graph!
116 // NOTE: This method may return a null pointer if it is unable to determine the
117 // requested information (because the call site calls an external
118 // function or we cannot determine the complete set of functions invoked).
120 DSGraph* FunctionModRefInfo::ResolveCallSiteModRefInfo(CallInst &CI,
121 hash_map<const DSNode*, DSNodeHandle> &NodeMap)
123 // Step #0: Quick check if we are going to fail anyway: avoid
124 // all the graph cloning and map copying in steps #1 and #2.
126 if (const Function *F = CI.getCalledFunction())
129 return 0; // We cannot compute Mod/Ref info for this callsite...
133 // Eventually, should check here if any callee is external.
134 // For now we are not handling this case anyway.
135 std::cerr << "IP Mod/Ref indirect call not implemented yet: "
136 << "Being conservative\n";
137 return 0; // We cannot compute Mod/Ref info for this callsite...
140 // Step #1: Clone the top-down graph...
141 DSGraph *Result = new DSGraph(*funcTDGraph, NodeMap);
143 // Step #2: Clear Mod/Ref information...
144 Result->maskNodeTypes(~(DSNode::Modified | DSNode::Read));
146 // Step #3: clone the bottom up graphs for the callees into the caller graph
147 if (Function *F = CI.getCalledFunction())
149 assert(!F->isExternal());
151 // Build up a DSCallSite for our invocation point here...
153 // If the call returns a value, make sure to merge the nodes...
155 if (DS::isPointerType(CI.getType()))
156 RetVal = Result->getNodeForValue(&CI);
158 // Populate the arguments list...
159 std::vector<DSNodeHandle> Args;
160 for (unsigned i = 1, e = CI.getNumOperands(); i != e; ++i)
161 if (DS::isPointerType(CI.getOperand(i)->getType()))
162 Args.push_back(Result->getNodeForValue(CI.getOperand(i)));
164 // Build the call site...
165 DSCallSite CS(CI, RetVal, F, Args);
167 // Perform the merging now of the graph for the callee, which will
168 // come with mod/ref bits set...
169 Result->mergeInGraph(CS, *F, IPModRefObj.getBUDSGraph(*F),
170 DSGraph::StripAllocaBit
171 | DSGraph::DontCloneCallNodes
172 | DSGraph::DontCloneAuxCallNodes);
175 assert(0 && "See error message");
177 // Remove dead nodes aggressively to match the caller's original graph.
178 Result->removeDeadNodes(DSGraph::KeepUnreachableGlobals);
180 // Step #4: Return the clone + the mapping (by ref)
184 // Compute Mod/Ref bit vectors for a single call site.
185 // These are copies of the Read/Write flags from the nodes of
186 // the graph produced by clearing all flags in teh caller's TD graph
187 // and then inlining the callee's BU graph into the caller's TD graph.
190 FunctionModRefInfo::computeModRef(const CallInst& callInst)
192 // Allocate the mod/ref info for the call site. Bits automatically cleared.
193 ModRefInfo* callModRefInfo = new ModRefInfo(funcTDGraph->getGraphSize());
194 callSiteModRefInfo[&callInst] = callModRefInfo;
196 // Get a copy of the graph for the callee with the callee inlined
197 hash_map<const DSNode*, DSNodeHandle> NodeMap;
198 DSGraph* csgp = ResolveCallSiteModRefInfo(const_cast<CallInst&>(callInst),
201 { // Callee's side effects are unknown: mark all nodes Mod and Ref.
202 // Eventually this should only mark nodes visible to the callee, i.e.,
203 // exclude stack variables not reachable from any outgoing argument
205 callModRefInfo->getModSet().set();
206 callModRefInfo->getRefSet().set();
210 // For all nodes in the graph, extract the mod/ref information
211 const std::vector<DSNode*>& csgNodes = csgp->getNodes();
212 const std::vector<DSNode*>& origNodes = funcTDGraph->getNodes();
213 assert(csgNodes.size() == origNodes.size());
214 for (unsigned i=0, N = origNodes.size(); i < N; ++i)
216 DSNode* csgNode = NodeMap[origNodes[i]].getNode();
217 assert(csgNode && "Inlined and original graphs do not correspond!");
218 if (csgNode->isModified())
219 callModRefInfo->setNodeIsMod(getNodeId(origNodes[i]));
220 if (csgNode->isRead())
221 callModRefInfo->setNodeIsRef(getNodeId(origNodes[i]));
224 // Drop nodemap before we delete the graph...
230 class DSGraphPrintHelper {
231 const DSGraph& tdGraph;
232 std::vector<std::vector<const Value*> > knownValues; // identifiable objects
235 /*ctor*/ DSGraphPrintHelper(const FunctionModRefInfo& fmrInfo)
236 : tdGraph(fmrInfo.getFuncGraph())
238 knownValues.resize(tdGraph.getGraphSize());
240 // For every identifiable value, save Value pointer in knownValues[i]
241 for (hash_map<Value*, DSNodeHandle>::const_iterator
242 I = tdGraph.getScalarMap().begin(),
243 E = tdGraph.getScalarMap().end(); I != E; ++I)
244 if (isa<GlobalValue>(I->first) ||
245 isa<Argument>(I->first) ||
246 isa<LoadInst>(I->first) ||
247 isa<AllocaInst>(I->first) ||
248 isa<MallocInst>(I->first))
250 unsigned nodeId = fmrInfo.getNodeId(I->second.getNode());
251 knownValues[nodeId].push_back(I->first);
255 void printValuesInBitVec(std::ostream &O, const BitSetVector& bv) const
257 assert(bv.size() == knownValues.size());
260 { // No bits are set: just say so and return
266 { // All bits are set: just say so and return
267 O << "\tALL GRAPH NODES.\n";
271 for (unsigned i=0, N=bv.size(); i < N; ++i)
274 O << "\tNode# " << i << " : ";
275 if (! knownValues[i].empty())
276 for (unsigned j=0, NV=knownValues[i].size(); j < NV; j++)
278 const Value* V = knownValues[i][j];
280 if (isa<GlobalValue>(V)) O << "(Global) ";
281 else if (isa<Argument>(V)) O << "(Target of FormalParm) ";
282 else if (isa<LoadInst>(V)) O << "(Target of LoadInst ) ";
283 else if (isa<AllocaInst>(V)) O << "(Target of AllocaInst) ";
284 else if (isa<MallocInst>(V)) O << "(Target of MallocInst) ";
286 if (V->hasName()) O << V->getName();
287 else if (isa<Instruction>(V)) O << *V;
288 else O << "(Value*) 0x" << (void*) V;
290 O << std::string((j < NV-1)? "; " : "\n");
293 tdGraph.getNodes()[i]->print(O, /*graph*/ NULL);
299 // Print the results of the pass.
300 // Currently this just prints bit-vectors and is not very readable.
302 void FunctionModRefInfo::print(std::ostream &O) const
304 DSGraphPrintHelper DPH(*this);
306 O << "========== Mod/ref information for function "
307 << F.getName() << "========== \n\n";
309 // First: Print Globals and Locals modified anywhere in the function.
311 O << " -----Mod/Ref in the body of function " << F.getName()<< ":\n";
313 O << " --Objects modified in the function body:\n";
314 DPH.printValuesInBitVec(O, funcModRefInfo.getModSet());
316 O << " --Objects referenced in the function body:\n";
317 DPH.printValuesInBitVec(O, funcModRefInfo.getRefSet());
319 O << " --Mod and Ref vectors for the nodes listed above:\n";
320 funcModRefInfo.print(O, "\t");
324 // Second: Print Globals and Locals modified at each call site in function
326 for (std::map<const CallInst*, ModRefInfo*>::const_iterator
327 CI = callSiteModRefInfo.begin(), CE = callSiteModRefInfo.end();
330 O << " ----Mod/Ref information for call site\n" << CI->first;
332 O << " --Objects modified at call site:\n";
333 DPH.printValuesInBitVec(O, CI->second->getModSet());
335 O << " --Objects referenced at call site:\n";
336 DPH.printValuesInBitVec(O, CI->second->getRefSet());
338 O << " --Mod and Ref vectors for the nodes listed above:\n";
339 CI->second->print(O, "\t");
347 void FunctionModRefInfo::dump() const
353 //----------------------------------------------------------------------------
354 // class IPModRef: An interprocedural pass that computes IP Mod/Ref info.
355 //----------------------------------------------------------------------------
357 // Free the FunctionModRefInfo objects cached in funcToModRefInfoMap.
359 void IPModRef::releaseMemory()
361 for(std::map<const Function*, FunctionModRefInfo*>::iterator
362 I=funcToModRefInfoMap.begin(), E=funcToModRefInfoMap.end(); I != E; ++I)
365 // Clear map so memory is not re-released if we are called again
366 funcToModRefInfoMap.clear();
369 // Run the "interprocedural" pass on each function. This needs to do
370 // NO real interprocedural work because all that has been done the
371 // data structure analysis.
373 bool IPModRef::run(Module &theModule)
377 for (Module::const_iterator FI = M->begin(), FE = M->end(); FI != FE; ++FI)
378 if (! FI->isExternal())
379 getFuncInfo(*FI, /*computeIfMissing*/ true);
384 FunctionModRefInfo& IPModRef::getFuncInfo(const Function& func,
385 bool computeIfMissing)
387 FunctionModRefInfo*& funcInfo = funcToModRefInfoMap[&func];
388 assert (funcInfo != NULL || computeIfMissing);
389 if (funcInfo == NULL)
390 { // Create a new FunctionModRefInfo object.
391 // Clone the top-down graph and remove any dead nodes first, because
392 // otherwise original and merged graphs will not match.
393 // The memory for this graph clone will be freed by FunctionModRefInfo.
394 DSGraph* funcTDGraph =
395 new DSGraph(getAnalysis<TDDataStructures>().getDSGraph(func));
396 funcTDGraph->removeDeadNodes(DSGraph::KeepUnreachableGlobals);
398 funcInfo = new FunctionModRefInfo(func, *this, funcTDGraph); //auto-insert
399 funcInfo->computeModRef(func); // computes the mod/ref info
404 /// getBUDSGraph - This method returns the BU data structure graph for F through
405 /// the use of the BUDataStructures object.
407 const DSGraph &IPModRef::getBUDSGraph(const Function &F) {
408 return getAnalysis<BUDataStructures>().getDSGraph(F);
412 // getAnalysisUsage - This pass requires top-down data structure graphs.
413 // It modifies nothing.
415 void IPModRef::getAnalysisUsage(AnalysisUsage &AU) const {
416 AU.setPreservesAll();
417 AU.addRequired<LocalDataStructures>();
418 AU.addRequired<BUDataStructures>();
419 AU.addRequired<TDDataStructures>();
423 void IPModRef::print(std::ostream &O) const
425 O << "\nRESULTS OF INTERPROCEDURAL MOD/REF ANALYSIS:\n\n";
427 for (std::map<const Function*, FunctionModRefInfo*>::const_iterator
428 mapI = funcToModRefInfoMap.begin(), mapE = funcToModRefInfoMap.end();
429 mapI != mapE; ++mapI)
430 mapI->second->print(O);
436 void IPModRef::dump() const