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/iOther.h"
12 #include "Support/Statistic.h"
13 #include "Support/STLExtras.h"
14 #include "Support/StringExtras.h"
16 //----------------------------------------------------------------------------
17 // Private constants and data
18 //----------------------------------------------------------------------------
20 static RegisterAnalysis<IPModRef>
21 Z("ipmodref", "Interprocedural mod/ref analysis");
24 //----------------------------------------------------------------------------
26 //----------------------------------------------------------------------------
28 void ModRefInfo::print(std::ostream &O) const
30 O << std::endl << "Modified nodes = " << modNodeSet;
31 O << "Referenced nodes = " << refNodeSet << std::endl;
34 void ModRefInfo::dump() const
39 //----------------------------------------------------------------------------
40 // class FunctionModRefInfo
41 //----------------------------------------------------------------------------
44 // This constructor computes a node numbering for the TD graph.
46 FunctionModRefInfo::FunctionModRefInfo(const Function& func,
50 : F(func), IPModRefObj(ipmro),
53 funcModRefInfo(tdg.getGraphSize())
55 for (unsigned i=0, N = funcTDGraph.getGraphSize(); i < N; ++i)
56 NodeIds[funcTDGraph.getNodes()[i]] = i;
60 FunctionModRefInfo::~FunctionModRefInfo()
62 for(std::map<const CallInst*, ModRefInfo*>::iterator
63 I=callSiteModRefInfo.begin(), E=callSiteModRefInfo.end(); I != E; ++I)
66 // Empty map just to make problems easier to track down
67 callSiteModRefInfo.clear();
70 unsigned FunctionModRefInfo::getNodeId(const Value* value) const {
71 return getNodeId(funcTDGraph.getNodeForValue(const_cast<Value*>(value))
77 // Compute Mod/Ref bit vectors for the entire function.
78 // These are simply copies of the Read/Write flags from the nodes of
79 // the top-down DS graph.
81 void FunctionModRefInfo::computeModRef(const Function &func)
83 // Mark all nodes in the graph that are marked MOD as being mod
84 // and all those marked REF as being ref.
85 for (unsigned i = 0, N = funcTDGraph.getGraphSize(); i < N; ++i)
87 if (funcTDGraph.getNodes()[i]->isModified())
88 funcModRefInfo.setNodeIsMod(i);
89 if (funcTDGraph.getNodes()[i]->isRead())
90 funcModRefInfo.setNodeIsRef(i);
93 // Compute the Mod/Ref info for all call sites within the function
94 // Use the Local DSgraph, which includes all the call sites in the
96 const std::vector<DSCallSite>& callSites = funcLocalGraph.getFunctionCalls();
97 for (unsigned i = 0, N = callSites.size(); i < N; ++i)
98 computeModRef(callSites[i].getCallInst());
101 // ResolveCallSiteModRefInfo - This method performs the following actions:
103 // 1. It clones the top-down graph for the current function
104 // 2. It clears all of the mod/ref bits in the cloned graph
105 // 3. It then merges the bottom-up graph(s) for the specified call-site into
106 // the clone (bringing new mod/ref bits).
107 // 4. It returns the clone, and a mapping of nodes from the original TDGraph to
108 // the cloned graph with Mod/Ref info for the callsite.
110 // NOTE: Because this clones a dsgraph and returns it, the caller is responsible
111 // for deleting the returned graph!
112 // NOTE: This method may return a null pointer if it is unable to determine the
113 // requested information (because the call site calls an external
114 // function or we cannot determine the complete set of functions invoked).
116 DSGraph *FunctionModRefInfo::ResolveCallSiteModRefInfo(CallInst &CI,
117 std::map<const DSNode*, DSNodeHandle> &NodeMap) {
119 // Step #1: Clone the top-down graph...
120 DSGraph *Result = new DSGraph(funcTDGraph, NodeMap);
122 // Step #2: Clear Mod/Ref information...
123 Result->maskNodeTypes(~(DSNode::Modified | DSNode::Read));
125 // Step #3: clone the bottom up graphs for the callees into the caller graph
126 if (const Function *F = CI.getCalledFunction()) {
127 if (F->isExternal()) {
129 return 0; // We cannot compute Mod/Ref info for this callsite...
132 // Build up a DSCallSite for our invocation point here...
134 // If the call returns a value, make sure to merge the nodes...
136 if (DS::isPointerType(CI.getType()))
137 RetVal = Result->getNodeForValue(&CI);
139 // Populate the arguments list...
140 std::vector<DSNodeHandle> Args;
141 for (unsigned i = 1, e = CI.getNumOperands(); i != e; ++i)
142 if (DS::isPointerType(CI.getOperand(i)->getType()))
143 Args.push_back(Result->getNodeForValue(CI.getOperand(i)));
145 // Build the call site...
146 DSCallSite CS(CI, RetVal, 0, Args);
148 // Perform the merging now of the graph for the callee, which will come with
149 // mod/ref bits set...
150 Result->mergeInGraph(CS, IPModRefObj.getBUDSGraph(*F),
151 DSGraph::StripAllocaBit | DSGraph::DontCloneCallNodes |
152 DSGraph::DontCloneAuxCallNodes);
155 std::cerr << "IP Mod/Ref indirect call not implemented yet: "
156 << "Being conservative\n";
161 // Remove trivial dead nodes... don't aggressively prune graph though... the
162 // graph is short lived anyway.
163 Result->removeTriviallyDeadNodes(false);
165 // Step #4: Return the clone + the mapping (by ref)
169 // Compute Mod/Ref bit vectors for a single call site.
170 // These are copies of the Read/Write flags from the nodes of
171 // the graph produced by clearing all flags in teh caller's TD graph
172 // and then inlining the callee's BU graph into the caller's TD graph.
175 FunctionModRefInfo::computeModRef(const CallInst& callInst)
177 // Allocate the mod/ref info for the call site. Bits automatically cleared.
178 ModRefInfo* callModRefInfo = new ModRefInfo(funcTDGraph.getGraphSize());
179 callSiteModRefInfo[&callInst] = callModRefInfo;
181 // Get a copy of the graph for the callee with the callee inlined
182 std::map<const DSNode*, DSNodeHandle> NodeMap;
184 ResolveCallSiteModRefInfo(const_cast<CallInst&>(callInst), NodeMap);
186 assert(csgp && "FIXME: Cannot handle case where call site mod/ref info"
187 " is not available yet!");
189 // For all nodes in the graph, extract the mod/ref information
190 const std::vector<DSNode*>& csgNodes = csgp->getNodes();
191 const std::vector<DSNode*>& origNodes = funcTDGraph.getNodes();
192 assert(csgNodes.size() == origNodes.size());
193 for (unsigned i=0, N = csgNodes.size(); i < N; ++i)
195 if (csgNodes[i]->isModified())
196 callModRefInfo->setNodeIsMod(getNodeId(origNodes[i]));
197 if (csgNodes[i]->isRead())
198 callModRefInfo->setNodeIsRef(getNodeId(origNodes[i]));
201 // Drop nodemap before we delete the graph...
207 // Print the results of the pass.
208 // Currently this just prints bit-vectors and is not very readable.
210 void FunctionModRefInfo::print(std::ostream &O) const
212 O << "---------- Mod/ref information for function "
213 << F.getName() << "---------- \n\n";
215 O << "Mod/ref info for function body:\n";
216 funcModRefInfo.print(O);
218 for (std::map<const CallInst*, ModRefInfo*>::const_iterator
219 CI = callSiteModRefInfo.begin(), CE = callSiteModRefInfo.end();
222 O << "Mod/ref info for call site " << CI->first << ":\n";
223 CI->second->print(O);
229 void FunctionModRefInfo::dump() const
235 //----------------------------------------------------------------------------
236 // class IPModRef: An interprocedural pass that computes IP Mod/Ref info.
237 //----------------------------------------------------------------------------
239 // Free the FunctionModRefInfo objects cached in funcToModRefInfoMap.
241 void IPModRef::releaseMemory()
243 for(std::map<const Function*, FunctionModRefInfo*>::iterator
244 I=funcToModRefInfoMap.begin(), E=funcToModRefInfoMap.end(); I != E; ++I)
247 // Clear map so memory is not re-released if we are called again
248 funcToModRefInfoMap.clear();
251 // Run the "interprocedural" pass on each function. This needs to do
252 // NO real interprocedural work because all that has been done the
253 // data structure analysis.
255 bool IPModRef::run(Module &theModule)
259 for (Module::const_iterator FI = M->begin(), FE = M->end(); FI != FE; ++FI)
260 if (! FI->isExternal())
261 getFuncInfo(*FI, /*computeIfMissing*/ true);
266 FunctionModRefInfo& IPModRef::getFuncInfo(const Function& func,
267 bool computeIfMissing)
269 FunctionModRefInfo*& funcInfo = funcToModRefInfoMap[&func];
270 assert (funcInfo != NULL || computeIfMissing);
271 if (funcInfo == NULL)
272 { // Create a new FunctionModRefInfo object
273 funcInfo = new FunctionModRefInfo(func, *this, // inserts into map
274 getAnalysis<TDDataStructures>().getDSGraph(func),
275 getAnalysis<LocalDataStructures>().getDSGraph(func));
276 funcInfo->computeModRef(func); // computes the mod/ref info
281 /// getBUDSGraph - This method returns the BU data structure graph for F through
282 /// the use of the BUDataStructures object.
284 const DSGraph &IPModRef::getBUDSGraph(const Function &F) {
285 return getAnalysis<BUDataStructures>().getDSGraph(F);
289 // getAnalysisUsage - This pass requires top-down data structure graphs.
290 // It modifies nothing.
292 void IPModRef::getAnalysisUsage(AnalysisUsage &AU) const {
293 AU.setPreservesAll();
294 AU.addRequired<LocalDataStructures>();
295 AU.addRequired<BUDataStructures>();
296 AU.addRequired<TDDataStructures>();
300 void IPModRef::print(std::ostream &O) const
302 O << "\n========== Results of Interprocedural Mod/Ref Analysis ==========\n";
304 for (std::map<const Function*, FunctionModRefInfo*>::const_iterator
305 mapI = funcToModRefInfoMap.begin(), mapE = funcToModRefInfoMap.end();
306 mapI != mapE; ++mapI)
307 mapI->second->print(O);
313 void IPModRef::dump() const