Rework TD pass to work with the precise call graph constructed by the BU phase

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@7031 91177308-0d34-0410-b5e6-96231b3b80d8

lib/Analysis/DataStructure/DataStructure.cpp

@@ -977,6 +977,7 @@ static inline bool nodeContainsExternalFunction(const DSNode *N) {
 }
 
 static void removeIdenticalCalls(std::vector<DSCallSite> &Calls) {
+
   // Remove trivially identical function calls
   unsigned NumFns = Calls.size();
   std::sort(Calls.begin(), Calls.end());  // Sort by callee as primary key!
@@ -1022,6 +1023,7 @@ static void removeIdenticalCalls(std::vector<DSCallSite> &Calls) {
             LastCalleeContainsExternalFunction = LastCalleeFunc->isExternal();
         }
         
+#if 0
         if (LastCalleeContainsExternalFunction ||
             // This should be more than enough context sensitivity!
             // FIXME: Evaluate how many times this is tripped!
@@ -1035,6 +1037,7 @@ static void removeIdenticalCalls(std::vector<DSCallSite> &Calls) {
           else if (CS.getNumPtrArgs() > OCS.getNumPtrArgs())
             OCS = CS;
         }
+#endif
       } else {
         if (CS.isDirectCall()) {
           LastCalleeFunc = CS.getCalleeFunc();

lib/Analysis/DataStructure/TopDownClosure.cpp

@@ -8,10 +8,10 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Analysis/DataStructure.h"
-#include "llvm/Analysis/DSGraph.h"
 #include "llvm/Module.h"
 #include "llvm/DerivedTypes.h"
 #include "Support/Statistic.h"
+#include "DSCallSiteIterator.h"
 
 namespace {
   RegisterAnalysis<TDDataStructures>   // Register the pass
@@ -27,14 +27,13 @@ bool TDDataStructures::run(Module &M) {
 
   // Calculate top-down from main...
   if (Function *F = M.getMainFunction())
-    calculateGraph(*F);
+    calculateGraphFrom(*F);
 
   // Next calculate the graphs for each function unreachable function...
   for (Module::reverse_iterator I = M.rbegin(), E = M.rend(); I != E; ++I)
-    if (!I->isExternal())
+    if (!I->isExternal() && !DSInfo.count(&*I))
-      calculateGraph(*I);
+      calculateGraphFrom(*I);
 
-  GraphDone.clear();    // Free temporary memory...
   return false;
 }
 
@@ -82,68 +81,98 @@ static bool FunctionHasCompleteArguments(Function &F) {
   return F.hasInternalLinkage();
 }
 
+void TDDataStructures::ComputePostOrder(Function &F,hash_set<DSGraph*> &Visited,
+                                        std::vector<DSGraph*> &PostOrder,
+                      const BUDataStructures::ActualCalleesTy &ActualCallees) {
+  if (F.isExternal()) return;
+  DSGraph &G = getOrCreateDSGraph(F);
+  if (Visited.count(&G)) return;
+  Visited.insert(&G);
   
-void TDDataStructures::calculateGraph(Function &F) {
+  // Recursively traverse all of the callee graphs.
-  // Make sure this graph has not already been calculated, and that we don't get
+  const std::vector<DSCallSite> &FunctionCalls = G.getFunctionCalls();
-  // into an infinite loop with mutually recursive functions.
-  //
-  if (GraphDone.count(&F)) return;
-  GraphDone.insert(&F);
 
-  // Get the current functions graph...
+  for (unsigned i = 0, e = FunctionCalls.size(); i != e; ++i) {
-  DSGraph &Graph = getOrCreateDSGraph(F);
+    std::pair<BUDataStructures::ActualCalleesTy::const_iterator,
+      BUDataStructures::ActualCalleesTy::const_iterator>
+      IP = ActualCallees.equal_range(&FunctionCalls[i].getCallInst());
 
+    for (BUDataStructures::ActualCalleesTy::const_iterator I = IP.first;
+         I != IP.second; ++I)
+      ComputePostOrder(*I->second, Visited, PostOrder, ActualCallees);
+  }
+
+  PostOrder.push_back(&G);
+}
+
+
+
+void TDDataStructures::calculateGraphFrom(Function &F) {
+  // We want to traverse the call graph in reverse post-order.  To do this, we
+  // calculate a post-order traversal, then reverse it.
+  hash_set<DSGraph*> VisitedGraph;
+  std::vector<DSGraph*> PostOrder;
+  ComputePostOrder(F, VisitedGraph, PostOrder,
+                   getAnalysis<BUDataStructures>().getActualCallees());
+  VisitedGraph.clear();   // Release memory!
+
+  // Visit each of the graphs in reverse post-order now!
+  while (!PostOrder.empty()) {
+    inlineGraphIntoCallees(*PostOrder.back());
+    PostOrder.pop_back();
+  }
+}
+
+
+void TDDataStructures::inlineGraphIntoCallees(DSGraph &Graph) {
   // Recompute the Incomplete markers and eliminate unreachable nodes.
   Graph.maskIncompleteMarkers();
-  unsigned Flags = FunctionHasCompleteArguments(F) ?
+  unsigned Flags = true /* FIXME!! FunctionHasCompleteArguments(F)*/ ?
                             DSGraph::IgnoreFormalArgs : DSGraph::MarkFormalArgs;
   Graph.markIncompleteNodes(Flags | DSGraph::IgnoreGlobals);
   Graph.removeDeadNodes(DSGraph::RemoveUnreachableGlobals);
 
-  const std::vector<DSCallSite> &CallSites = Graph.getFunctionCalls();
+  DSCallSiteIterator CalleeI = DSCallSiteIterator::begin_std(Graph);
-  if (CallSites.empty()) {
+  DSCallSiteIterator CalleeE = DSCallSiteIterator::end_std(Graph);
-    DEBUG(std::cerr << "  [TD] No callees for: " << F.getName() << "\n");
+
-  } else {
+  if (CalleeI == CalleeE) {
+    DEBUG(std::cerr << "  [TD] No callees for: " << Graph.getFunctionNames()
+                    << "\n");
+    return;
+  }
+
   // Loop over all of the call sites, building a multi-map from Callees to
   // DSCallSite*'s.  With this map we can then loop over each callee, cloning
   // this graph once into it, then resolving arguments.
   //
-    std::multimap<Function*, const DSCallSite*> CalleeSites;
+  std::multimap<std::pair<DSGraph*,Function*>, const DSCallSite*> CalleeSites;
-    for (unsigned i = 0, e = CallSites.size(); i != e; ++i) {
+  for (; CalleeI != CalleeE; ++CalleeI)
-      const DSCallSite &CS = CallSites[i];
+    if (!(*CalleeI)->isExternal()) {
-      if (CS.isDirectCall()) {
+      // We should have already created the graph here...
-        if (!CS.getCalleeFunc()->isExternal())           // If it's not external
+      if (!DSInfo.count(*CalleeI))
-          CalleeSites.insert(std::make_pair(CS.getCalleeFunc(), &CS));// Keep it
+        std::cerr << "WARNING: TD pass, did not know about callee: '"
-      } else {
+                  << (*CalleeI)->getName() << "'\n";
-        const std::vector<GlobalValue*> &Callees =
-          CS.getCalleeNode()->getGlobals();
 
-        // Loop over all of the functions that this call may invoke...
+      DSGraph &IG = getOrCreateDSGraph(**CalleeI);
-        for (unsigned c = 0, e = Callees.size(); c != e; ++c)
+      if (&IG != &Graph)
-          if (Function *F = dyn_cast<Function>(Callees[c]))// If this is a fn...
+        CalleeSites.insert(std::make_pair(std::make_pair(&IG, *CalleeI),
-            if (!F->isExternal())                          // If it's not extern
+                                          &CalleeI.getCallSite()));
-              CalleeSites.insert(std::make_pair(F, &CS));  // Keep track of it!
-      }
     }
 
   // Now that we have information about all of the callees, propagate the
   // current graph into the callees.
   //
-    DEBUG(std::cerr << "  [TD] Inlining '" << F.getName() << "' into "
+  DEBUG(std::cerr << "  [TD] Inlining '" << Graph.getFunctionNames() <<"' into "
                   << CalleeSites.size() << " callees.\n");
 
   // Loop over all the callees...
-    for (std::multimap<Function*, const DSCallSite*>::iterator
+  for (std::multimap<std::pair<DSGraph*, Function*>,
-           I = CalleeSites.begin(), E = CalleeSites.end(); I != E; )
+         const DSCallSite*>::iterator I = CalleeSites.begin(),
-      if (I->first == &F) {  // Bottom-up pass takes care of self loops!
+         E = CalleeSites.end(); I != E; ) {
-        ++I;
+    DSGraph &CG = *I->first.first;
-      } else {
-        // For each callee...
-        Function &Callee = *I->first;
-        DSGraph &CG = getOrCreateDSGraph(Callee);  // Get the callee's graph...
 
-        DEBUG(std::cerr << "\t [TD] Inlining into callee '" << Callee.getName()
+    DEBUG(std::cerr << "     [TD] Inlining graph into callee graph '"
-                        << "'\n");
+                    << CG.getFunctionNames() << "'\n");
     
     // Clone our current graph into the callee...
     DSGraph::ScalarMapTy OldValMap;
@@ -161,7 +190,11 @@ void TDDataStructures::calculateGraph(Function &F) {
     // current function calls this callee multiple times with different
     // signatures.
     //
-        for (; I != E && I->first == &Callee; ++I) {
+    for (; I != E && I->first.first == &CG; ++I) {
+      Function &Callee = *I->first.second;
+      DEBUG(std::cerr << "\t   [TD] Merging args for callee '"
+                      << Callee.getName() << "'\n");
+
       // Map call site into callee graph
       DSCallSite NewCS(*I->second, OldNodeMap);
         
@@ -189,15 +222,16 @@ void TDDataStructures::calculateGraph(Function &F) {
 
     // Recompute the Incomplete markers and eliminate unreachable nodes.
     CG.removeTriviallyDeadNodes();
-        CG.maskIncompleteMarkers();
+    //CG.maskIncompleteMarkers();
-        CG.markIncompleteNodes(DSGraph::MarkFormalArgs |DSGraph::IgnoreGlobals);
+    //CG.markIncompleteNodes(DSGraph::MarkFormalArgs | DSGraph::IgnoreGlobals);
-        CG.removeDeadNodes(DSGraph::RemoveUnreachableGlobals);
+    //CG.removeDeadNodes(DSGraph::RemoveUnreachableGlobals);
   }
 
-    DEBUG(std::cerr << "  [TD] Done inlining into callees for: " << F.getName()
+  DEBUG(std::cerr << "  [TD] Done inlining into callees for: "
-          << " [" << Graph.getGraphSize() << "+"
+        << Graph.getFunctionNames() << " [" << Graph.getGraphSize() << "+"
         << Graph.getFunctionCalls().size() << "]\n");
 
+#if 0
   // Loop over all the callees... making sure they are all resolved now...
   Function *LastFunc = 0;
   for (std::multimap<Function*, const DSCallSite*>::iterator
@@ -206,6 +240,6 @@ void TDDataStructures::calculateGraph(Function &F) {
       LastFunc = I->first;
       calculateGraph(*I->first);
     }
-  }
+#endif
 }