If "These should be used only by the auto-parallelization pass", we might as

[oota-llvm.git] / lib / Analysis / DataStructure / BottomUpClosure.cpp

diff --git a/lib/Analysis/DataStructure/BottomUpClosure.cpp b/lib/Analysis/DataStructure/BottomUpClosure.cpp
index e2c44c8caabc56484d4dfa09ab0d3ff8710e66ab..dd141f2daf697d1af5bcd9a29fb6c16a9bd80428 100644 (file)
--- a/lib/Analysis/DataStructure/BottomUpClosure.cpp
+++ b/lib/Analysis/DataStructure/BottomUpClosure.cpp
@@ -10,10 +10,13 @@
 #include "llvm/Analysis/DataStructure.h"
 #include "llvm/Module.h"
 #include "Support/Statistic.h"
+#include "Support/Debug.h"
 #include "DSCallSiteIterator.h"
 
 namespace {
   Statistic<> MaxSCC("budatastructure", "Maximum SCC Size in Call Graph");
+  Statistic<> NumBUInlines("budatastructures", "Number of graphs inlined");
+  Statistic<> NumCallEdges("budatastructures", "Number of 'actual' call edges");
   
   RegisterAnalysis<BUDataStructures>
   X("budatastructure", "Bottom-up Data Structure Analysis");
@@ -43,6 +46,8 @@ bool BUDataStructures::run(Module &M) {
 #endif
       calculateReachableGraphs(I);    // Calculate all graphs...
     }
+
+  NumCallEdges += ActualCallees.size();
   return false;
 }
 
@@ -173,6 +178,9 @@ unsigned BUDataStructures::calculateGraphs(Function *F,
       }
     }
 
+    // Clean up the graph before we start inlining a bunch again...
+    SCCGraph->removeTriviallyDeadNodes();
+
     // Now that we have one big happy family, resolve all of the call sites in
     // the graph...
     calculateGraph(*SCCGraph);
@@ -232,8 +240,7 @@ void BUDataStructures::calculateGraph(DSGraph &Graph) {
     
     // Resolve the current call...
     Function *Callee = *I;
-    const DSCallSite &CS = I.getCallSite();
-    ActualCallees.insert(std::make_pair(&CS.getCallInst(), Callee));
+    DSCallSite CS = I.getCallSite();
 
     if (Callee->isExternal()) {
       // Ignore this case, simple varargs functions we cannot stub out!
@@ -246,6 +253,8 @@ void BUDataStructures::calculateGraph(DSGraph &Graph) {
       Graph.mergeInGraph(CS, *Callee, Graph, 0);
 
     } else {
+      ActualCallees.insert(std::make_pair(&CS.getCallInst(), Callee));
+
       // Get the data structure graph for the called function.
       //
       DSGraph &GI = getDSGraph(*Callee);  // Graph to inline
@@ -260,6 +269,7 @@ void BUDataStructures::calculateGraph(DSGraph &Graph) {
       Graph.mergeInGraph(CS, *Callee, GI,
                          DSGraph::KeepModRefBits | 
                          DSGraph::StripAllocaBit | DSGraph::DontCloneCallNodes);
+      ++NumBUInlines;
 
 #if 0
       Graph.writeGraphToFile(std::cerr, "bu_" + F.getName() + "_after_" +
@@ -274,11 +284,17 @@ void BUDataStructures::calculateGraph(DSGraph &Graph) {
 
   TempFCs.clear();
 
-  // Recompute the Incomplete markers.  If there are any function calls left
-  // now that are complete, we must loop!
+  // Re-materialize nodes from the globals graph.
+  // Do not ignore globals inlined from callees -- they are not up-to-date!
+  Graph.getInlinedGlobals().clear();
+  Graph.updateFromGlobalGraph();
+
+  // Recompute the Incomplete markers
   Graph.maskIncompleteMarkers();
   Graph.markIncompleteNodes(DSGraph::MarkFormalArgs);
-  // FIXME: materialize nodes from the globals graph as neccesary...
+
+  // Delete dead nodes.  Treat globals that are unreachable but that can
+  // reach live nodes as live.
   Graph.removeDeadNodes(DSGraph::KeepUnreachableGlobals);
 
   //Graph.writeGraphToFile(std::cerr, "bu_" + F.getName());