maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

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

llvm-svn: 7031
This commit is contained in:
Chris Lattner 2003-07-01 16:28:11 +00:00
parent e809e3afd8
commit 23428214e9
2 changed files with 152 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
llvm/lib/Analysis/DataStructure/DataStructure.cpp
View File

@ -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();

136
llvm/lib/Analysis/DataStructure/TopDownClosure.cpp
View File

@ -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())
calculateGraph(*I);
if (!I->isExternal() && !DSInfo.count(&*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) {
// Make sure this graph has not already been calculated, and that we don't get
// into an infinite loop with mutually recursive functions.
//
if (GraphDone.count(&F)) return;
GraphDone.insert(&F);
// Recursively traverse all of the callee graphs.
const std::vector<DSCallSite> &FunctionCalls = G.getFunctionCalls();
// Get the current functions graph...
DSGraph &Graph = getOrCreateDSGraph(F);
for (unsigned i = 0, e = FunctionCalls.size(); i != e; ++i) {
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();
if (CallSites.empty()) {
DEBUG(std::cerr << " [TD] No callees for: " << F.getName() << "\n");
} else {
DSCallSiteIterator CalleeI = DSCallSiteIterator::begin_std(Graph);
DSCallSiteIterator CalleeE = DSCallSiteIterator::end_std(Graph);
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;
for (unsigned i = 0, e = CallSites.size(); i != e; ++i) {
const DSCallSite &CS = CallSites[i];
if (CS.isDirectCall()) {
if (!CS.getCalleeFunc()->isExternal()) // If it's not external
CalleeSites.insert(std::make_pair(CS.getCalleeFunc(), &CS));// Keep it
} else {
const std::vector<GlobalValue*> &Callees =
CS.getCalleeNode()->getGlobals();
std::multimap<std::pair<DSGraph*,Function*>, const DSCallSite*> CalleeSites;
for (; CalleeI != CalleeE; ++CalleeI)
if (!(*CalleeI)->isExternal()) {
// We should have already created the graph here...
if (!DSInfo.count(*CalleeI))
std::cerr << "WARNING: TD pass, did not know about callee: '"
<< (*CalleeI)->getName() << "'\n";
// Loop over all of the functions that this call may invoke...
for (unsigned c = 0, e = Callees.size(); c != e; ++c)
if (Function *F = dyn_cast<Function>(Callees[c]))// If this is a fn...
if (!F->isExternal()) // If it's not extern
CalleeSites.insert(std::make_pair(F, &CS)); // Keep track of it!
}
DSGraph &IG = getOrCreateDSGraph(**CalleeI);
if (&IG != &Graph)
CalleeSites.insert(std::make_pair(std::make_pair(&IG, *CalleeI),
&CalleeI.getCallSite()));
}
// 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
I = CalleeSites.begin(), E = CalleeSites.end(); I != E; )
if (I->first == &F) { // Bottom-up pass takes care of self loops!
++I;
} else {
// For each callee...
Function &Callee = *I->first;
DSGraph &CG = getOrCreateDSGraph(Callee); // Get the callee's graph...
for (std::multimap<std::pair<DSGraph*, Function*>,
const DSCallSite*>::iterator I = CalleeSites.begin(),
E = CalleeSites.end(); I != E; ) {
DSGraph &CG = *I->first.first;
DEBUG(std::cerr << "\t [TD] Inlining into callee '" << Callee.getName()
<< "'\n");
DEBUG(std::cerr << " [TD] Inlining graph into callee graph '"
<< 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.markIncompleteNodes(DSGraph::MarkFormalArgs |DSGraph::IgnoreGlobals);
CG.removeDeadNodes(DSGraph::RemoveUnreachableGlobals);
//CG.maskIncompleteMarkers();
//CG.markIncompleteNodes(DSGraph::MarkFormalArgs | DSGraph::IgnoreGlobals);
//CG.removeDeadNodes(DSGraph::RemoveUnreachableGlobals);
}
DEBUG(std::cerr << " [TD] Done inlining into callees for: " << F.getName()
<< " [" << Graph.getGraphSize() << "+"
DEBUG(std::cerr << " [TD] Done inlining into callees for: "
<< 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
}