lib/Analysis/DataStructure/IPModRef.cpp

   1 //===- IPModRef.cpp - Compute IP Mod/Ref information ------------*- C++ -*-===//
   2 //
   3 // See high-level comments in include/llvm/Analysis/IPModRef.h
   4 //
   5 //===----------------------------------------------------------------------===//
   6
   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"
  15
  16 //----------------------------------------------------------------------------
  17 // Private constants and data
  18 //----------------------------------------------------------------------------
  19
  20 static RegisterAnalysis<IPModRef>
  21 Z("ipmodref", "Interprocedural mod/ref analysis");
  22
  23
  24 //----------------------------------------------------------------------------
  25 // class ModRefInfo
  26 //----------------------------------------------------------------------------
  27
  28 void ModRefInfo::print(std::ostream &O) const
  29 {
  30   O << std::endl << "Modified   nodes = " << modNodeSet;
  31   O              << "Referenced nodes = " << refNodeSet << std::endl;
  32 }
  33
  34 void ModRefInfo::dump() const
  35 {
  36   print(std::cerr);
  37 }
  38
  39 //----------------------------------------------------------------------------
  40 // class FunctionModRefInfo
  41 //----------------------------------------------------------------------------
  42
  43
  44 // This constructor computes a node numbering for the TD graph.
  45 //
  46 FunctionModRefInfo::FunctionModRefInfo(const Function& func,
  47                                        IPModRef& ipmro,
  48                                        const DSGraph& tdg,
  49                                        const DSGraph& ldg)
  50   : F(func), IPModRefObj(ipmro),
  51     funcTDGraph(tdg),
  52     funcLocalGraph(ldg),
  53     funcModRefInfo(tdg.getGraphSize())
  54 {
  55   for (unsigned i=0, N = funcTDGraph.getGraphSize(); i < N; ++i)
  56     NodeIds[funcTDGraph.getNodes()[i]] = i;
  57 }
  58
  59
  60 FunctionModRefInfo::~FunctionModRefInfo()
  61 {
  62   for(std::map<const CallInst*, ModRefInfo*>::iterator
  63         I=callSiteModRefInfo.begin(), E=callSiteModRefInfo.end(); I != E; ++I)
  64     delete(I->second);
  65
  66   // Empty map just to make problems easier to track down
  67   callSiteModRefInfo.clear();
  68 }
  69
  70 unsigned FunctionModRefInfo::getNodeId(const Value* value) const {
  71   return getNodeId(funcTDGraph.getNodeForValue(const_cast<Value*>(value))
  72                    .getNode());
  73 }
  74
  75
  76
  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.
  80 //
  81 void FunctionModRefInfo::computeModRef(const Function &func)
  82 {
  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)
  86     {
  87       if (funcTDGraph.getNodes()[i]->isModified())
  88         funcModRefInfo.setNodeIsMod(i);
  89       if (funcTDGraph.getNodes()[i]->isRead())
  90         funcModRefInfo.setNodeIsRef(i);
  91     }
  92
  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
  95   // original program.
  96   const std::vector<DSCallSite>& callSites = funcLocalGraph.getFunctionCalls();
  97   for (unsigned i = 0, N = callSites.size(); i < N; ++i)
  98     computeModRef(callSites[i].getCallInst());
  99 }
 100
 101 // ResolveCallSiteModRefInfo - This method performs the following actions:
 102 //
 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.
 109 //
 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).
 115 //
 116 DSGraph *FunctionModRefInfo::ResolveCallSiteModRefInfo(CallInst &CI,
 117                                std::map<const DSNode*, DSNodeHandle> &NodeMap) {
 118
 119   // Step #1: Clone the top-down graph...
 120   std::map<const DSNode*, DSNode*> RawNodeMap;
 121   DSGraph *Result = new DSGraph(funcTDGraph, RawNodeMap);
 122
 123   // Convert the NodeMap from a map to DSNode* to be a map to DSNodeHandle's
 124   NodeMap.insert(RawNodeMap.begin(), RawNodeMap.end());
 125
 126   // We are now done with the old map... so free it's memory...
 127   RawNodeMap.clear();
 128
 129   // Step #2: Clear Mod/Ref information...
 130   Result->maskNodeTypes(~(DSNode::Modified | DSNode::Read));
 131
 132   // Step #3: clone the bottom up graphs for the callees into the caller graph
 133   if (const Function *F = CI.getCalledFunction()) {
 134     if (F->isExternal()) {
 135       delete Result;
 136       return 0;   // We cannot compute Mod/Ref info for this callsite...
 137     }
 138
 139     // Build up a DSCallSite for our invocation point here...
 140
 141     // If the call returns a value, make sure to merge the nodes...
 142     DSNodeHandle RetVal;
 143     if (DS::isPointerType(CI.getType()))
 144       RetVal = Result->getNodeForValue(&CI);
 145
 146     // Populate the arguments list...
 147     std::vector<DSNodeHandle> Args;
 148     for (unsigned i = 1, e = CI.getNumOperands(); i != e; ++i)
 149       if (DS::isPointerType(CI.getOperand(i)->getType()))
 150         Args.push_back(Result->getNodeForValue(CI.getOperand(i)));
 151
 152     // Build the call site...
 153     DSCallSite CS(CI, RetVal, 0, Args);
 154
 155     // Perform the merging now of the graph for the callee, which will come with
 156     // mod/ref bits set...
 157     Result->mergeInGraph(CS, IPModRefObj.getBUDSGraph(*F),
 158                          DSGraph::StripAllocaBit);
 159
 160   } else {
 161     std::cerr << "IP Mod/Ref indirect call not implemented yet: "
 162               << "Being conservative\n";
 163     delete Result;
 164     return 0;
 165   }
 166
 167   // Remove trivial dead nodes... don't aggressively prune graph though... the
 168   // graph is short lived anyway.
 169   Result->removeTriviallyDeadNodes(false);
 170
 171   // Step #4: Return the clone + the mapping (by ref)
 172   return Result;
 173 }
 174
 175 // Compute Mod/Ref bit vectors for a single call site.
 176 // These are copies of the Read/Write flags from the nodes of
 177 // the graph produced by clearing all flags in teh caller's TD graph
 178 // and then inlining the callee's BU graph into the caller's TD graph.
 179 //
 180 void
 181 FunctionModRefInfo::computeModRef(const CallInst& callInst)
 182 {
 183   // Allocate the mod/ref info for the call site.  Bits automatically cleared.
 184   ModRefInfo* callModRefInfo = new ModRefInfo(funcTDGraph.getGraphSize());
 185   callSiteModRefInfo[&callInst] = callModRefInfo;
 186
 187   // Get a copy of the graph for the callee with the callee inlined
 188   std::map<const DSNode*, DSNodeHandle> NodeMap;
 189   DSGraph* csgp =
 190     ResolveCallSiteModRefInfo(const_cast<CallInst&>(callInst), NodeMap);
 191
 192   assert(csgp && "FIXME: Cannot handle case where call site mod/ref info"
 193          " is not available yet!");
 194
 195   // For all nodes in the graph, extract the mod/ref information
 196   const std::vector<DSNode*>& csgNodes = csgp->getNodes();
 197   const std::vector<DSNode*>& origNodes = funcTDGraph.getNodes();
 198   assert(csgNodes.size() == origNodes.size());
 199   for (unsigned i=0, N = csgNodes.size(); i < N; ++i)
 200     {
 201       if (csgNodes[i]->isModified())
 202         callModRefInfo->setNodeIsMod(getNodeId(origNodes[i]));
 203       if (csgNodes[i]->isRead())
 204         callModRefInfo->setNodeIsRef(getNodeId(origNodes[i]));
 205     }
 206
 207   // Drop nodemap before we delete the graph...
 208   NodeMap.clear();
 209   delete csgp;
 210 }
 211
 212
 213 // Print the results of the pass.
 214 // Currently this just prints bit-vectors and is not very readable.
 215 //
 216 void FunctionModRefInfo::print(std::ostream &O) const
 217 {
 218   O << "---------- Mod/ref information for function "
 219     << F.getName() << "---------- \n\n";
 220
 221   O << "Mod/ref info for function body:\n";
 222   funcModRefInfo.print(O);
 223
 224   for (std::map<const CallInst*, ModRefInfo*>::const_iterator
 225          CI = callSiteModRefInfo.begin(), CE = callSiteModRefInfo.end();
 226        CI != CE; ++CI)
 227     {
 228       O << "Mod/ref info for call site " << CI->first << ":\n";
 229       CI->second->print(O);
 230     }
 231
 232   O << "\n";
 233 }
 234
 235 void FunctionModRefInfo::dump() const
 236 {
 237   print(std::cerr);
 238 }
 239
 240
 241 //----------------------------------------------------------------------------
 242 // class IPModRef: An interprocedural pass that computes IP Mod/Ref info.
 243 //----------------------------------------------------------------------------
 244
 245 // Free the FunctionModRefInfo objects cached in funcToModRefInfoMap.
 246 //
 247 void IPModRef::releaseMemory()
 248 {
 249   for(std::map<const Function*, FunctionModRefInfo*>::iterator
 250         I=funcToModRefInfoMap.begin(), E=funcToModRefInfoMap.end(); I != E; ++I)
 251     delete(I->second);
 252
 253   // Clear map so memory is not re-released if we are called again
 254   funcToModRefInfoMap.clear();
 255 }
 256
 257 // Run the "interprocedural" pass on each function.  This needs to do
 258 // NO real interprocedural work because all that has been done the
 259 // data structure analysis.
 260 //
 261 bool IPModRef::run(Module &theModule)
 262 {
 263   M = &theModule;
 264
 265   for (Module::const_iterator FI = M->begin(), FE = M->end(); FI != FE; ++FI)
 266     if (! FI->isExternal())
 267       getFuncInfo(*FI, /*computeIfMissing*/ true);
 268   return true;
 269 }
 270
 271
 272 FunctionModRefInfo& IPModRef::getFuncInfo(const Function& func,
 273                                           bool computeIfMissing)
 274 {
 275   FunctionModRefInfo*& funcInfo = funcToModRefInfoMap[&func];
 276   assert (funcInfo != NULL || computeIfMissing);
 277   if (funcInfo == NULL)
 278     { // Create a new FunctionModRefInfo object
 279       funcInfo = new FunctionModRefInfo(func, *this, // inserts into map
 280                               getAnalysis<TDDataStructures>().getDSGraph(func),
 281                           getAnalysis<LocalDataStructures>().getDSGraph(func));
 282       funcInfo->computeModRef(func);            // computes the mod/ref info
 283     }
 284   return *funcInfo;
 285 }
 286
 287 /// getBUDSGraph - This method returns the BU data structure graph for F through
 288 /// the use of the BUDataStructures object.
 289 ///
 290 const DSGraph &IPModRef::getBUDSGraph(const Function &F) {
 291   return getAnalysis<BUDataStructures>().getDSGraph(F);
 292 }
 293
 294
 295 // getAnalysisUsage - This pass requires top-down data structure graphs.
 296 // It modifies nothing.
 297 //
 298 void IPModRef::getAnalysisUsage(AnalysisUsage &AU) const {
 299   AU.setPreservesAll();
 300   AU.addRequired<LocalDataStructures>();
 301   AU.addRequired<BUDataStructures>();
 302   AU.addRequired<TDDataStructures>();
 303 }
 304
 305
 306 void IPModRef::print(std::ostream &O) const
 307 {
 308   O << "\n========== Results of Interprocedural Mod/Ref Analysis ==========\n";
 309
 310   for (std::map<const Function*, FunctionModRefInfo*>::const_iterator
 311          mapI = funcToModRefInfoMap.begin(), mapE = funcToModRefInfoMap.end();
 312        mapI != mapE; ++mapI)
 313     mapI->second->print(O);
 314
 315   O << "\n";
 316 }
 317
 318
 319 void IPModRef::dump() const
 320 {
 321   print(std::cerr);
 322 }