mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2025-01-08 18:31:23 +00:00
8a5db46967
death when handling moderately sized SCC's, but what can you do git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@4689 91177308-0d34-0410-b5e6-96231b3b80d8
340 lines
12 KiB
C++
340 lines
12 KiB
C++
//===- BottomUpClosure.cpp - Compute bottom-up interprocedural closure ----===//
|
|
//
|
|
// This file implements the BUDataStructures class, which represents the
|
|
// Bottom-Up Interprocedural closure of the data structure graph over the
|
|
// program. This is useful for applications like pool allocation, but **not**
|
|
// applications like alias analysis.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/Analysis/DataStructure.h"
|
|
#include "llvm/Analysis/DSGraph.h"
|
|
#include "llvm/Module.h"
|
|
#include "Support/Statistic.h"
|
|
using std::map;
|
|
|
|
static RegisterAnalysis<BUDataStructures>
|
|
X("budatastructure", "Bottom-up Data Structure Analysis Closure");
|
|
|
|
using namespace DS;
|
|
|
|
// run - Calculate the bottom up data structure graphs for each function in the
|
|
// program.
|
|
//
|
|
bool BUDataStructures::run(Module &M) {
|
|
GlobalsGraph = new DSGraph();
|
|
|
|
// Simply calculate the graphs for each function...
|
|
for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
|
|
if (!I->isExternal())
|
|
calculateGraph(*I, 0);
|
|
return false;
|
|
}
|
|
|
|
// releaseMemory - If the pass pipeline is done with this pass, we can release
|
|
// our memory... here...
|
|
//
|
|
void BUDataStructures::releaseMemory() {
|
|
for (map<const Function*, DSGraph*>::iterator I = DSInfo.begin(),
|
|
E = DSInfo.end(); I != E; ++I)
|
|
delete I->second;
|
|
|
|
// Empty map so next time memory is released, data structures are not
|
|
// re-deleted.
|
|
DSInfo.clear();
|
|
delete GlobalsGraph;
|
|
GlobalsGraph = 0;
|
|
}
|
|
|
|
|
|
// Return true if a graph was inlined
|
|
// Can not modify the part of the AuxCallList < FirstResolvableCall.
|
|
//
|
|
bool BUDataStructures::ResolveFunctionCalls(DSGraph &G,
|
|
unsigned &FirstResolvableCall,
|
|
std::map<Function*, DSCallSite> &InProcess,
|
|
unsigned Indent) {
|
|
std::vector<DSCallSite> &FCs = G.getAuxFunctionCalls();
|
|
bool Changed = false;
|
|
|
|
// Loop while there are call sites that we can resolve!
|
|
while (FirstResolvableCall != FCs.size()) {
|
|
DSCallSite Call = FCs[FirstResolvableCall];
|
|
|
|
// If the function list is incomplete...
|
|
if (Call.getCallee().getNode()->NodeType & DSNode::Incomplete) {
|
|
// If incomplete, we cannot resolve it, so leave it at the beginning of
|
|
// the call list with the other unresolvable calls...
|
|
++FirstResolvableCall;
|
|
} else {
|
|
// Start inlining all of the functions we can... some may not be
|
|
// inlinable if they are external...
|
|
//
|
|
const std::vector<GlobalValue*> &Callees =
|
|
Call.getCallee().getNode()->getGlobals();
|
|
|
|
bool hasExternalTarget = false;
|
|
|
|
// Loop over the functions, inlining whatever we can...
|
|
for (unsigned c = 0, e = Callees.size(); c != e; ++c) {
|
|
// Must be a function type, so this cast should succeed unless something
|
|
// really wierd is happening.
|
|
Function &FI = cast<Function>(*Callees[c]);
|
|
|
|
if (FI.getName() == "printf" || FI.getName() == "sscanf" ||
|
|
FI.getName() == "fprintf" || FI.getName() == "open" ||
|
|
FI.getName() == "sprintf" || FI.getName() == "fputs") {
|
|
// Ignore
|
|
} else if (FI.isExternal()) {
|
|
// If the function is external, then we cannot resolve this call site!
|
|
hasExternalTarget = true;
|
|
break;
|
|
} else {
|
|
std::map<Function*, DSCallSite>::iterator I =
|
|
InProcess.lower_bound(&FI);
|
|
|
|
if (I != InProcess.end() && I->first == &FI) { // Recursion detected?
|
|
// Merge two call sites to eliminate recursion...
|
|
Call.mergeWith(I->second);
|
|
|
|
DEBUG(std::cerr << std::string(Indent*2, ' ')
|
|
<< "* Recursion detected for function " << FI.getName()<<"\n");
|
|
} else {
|
|
DEBUG(std::cerr << std::string(Indent*2, ' ')
|
|
<< "Inlining: " << FI.getName() << "\n");
|
|
|
|
// Get the data structure graph for the called function, closing it
|
|
// if possible...
|
|
//
|
|
DSGraph &GI = calculateGraph(FI, Indent+1); // Graph to inline
|
|
|
|
DEBUG(std::cerr << std::string(Indent*2, ' ')
|
|
<< "Got graph for: " << FI.getName() << "["
|
|
<< GI.getGraphSize() << "+"
|
|
<< GI.getAuxFunctionCalls().size() << "] "
|
|
<< " in: " << G.getFunction().getName() << "["
|
|
<< G.getGraphSize() << "+"
|
|
<< G.getAuxFunctionCalls().size() << "]\n");
|
|
|
|
// Keep track of how many call sites are added by the inlining...
|
|
unsigned NumCalls = FCs.size();
|
|
|
|
// Resolve the arguments and return value
|
|
G.mergeInGraph(Call, GI, DSGraph::StripAllocaBit |
|
|
DSGraph::DontCloneCallNodes);
|
|
|
|
// Added a call site?
|
|
if (FCs.size() != NumCalls) {
|
|
// Otherwise we need to inline the graph. Temporarily add the
|
|
// current function to the InProcess map to be able to handle
|
|
// recursion successfully.
|
|
//
|
|
I = InProcess.insert(I, std::make_pair(&FI, Call));
|
|
|
|
// ResolveFunctionCalls - Resolve the function calls that just got
|
|
// inlined...
|
|
//
|
|
Changed |= ResolveFunctionCalls(G, NumCalls, InProcess, Indent+1);
|
|
|
|
// Now that we are done processing the inlined graph, remove our
|
|
// cycle detector record...
|
|
//
|
|
//InProcess.erase(I);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (hasExternalTarget) {
|
|
// If we cannot resolve this call site...
|
|
++FirstResolvableCall;
|
|
} else {
|
|
Changed = true;
|
|
FCs.erase(FCs.begin()+FirstResolvableCall);
|
|
}
|
|
}
|
|
}
|
|
|
|
return Changed;
|
|
}
|
|
|
|
DSGraph &BUDataStructures::calculateGraph(Function &F, unsigned Indent) {
|
|
// Make sure this graph has not already been calculated, or that we don't get
|
|
// into an infinite loop with mutually recursive functions.
|
|
//
|
|
DSGraph *&GraphPtr = DSInfo[&F];
|
|
if (GraphPtr) return *GraphPtr;
|
|
|
|
// Copy the local version into DSInfo...
|
|
GraphPtr = new DSGraph(getAnalysis<LocalDataStructures>().getDSGraph(F));
|
|
DSGraph &Graph = *GraphPtr;
|
|
|
|
Graph.setGlobalsGraph(GlobalsGraph);
|
|
Graph.setPrintAuxCalls();
|
|
|
|
// Start resolving calls...
|
|
std::vector<DSCallSite> &FCs = Graph.getAuxFunctionCalls();
|
|
|
|
// Start with a copy of the original call sites...
|
|
FCs = Graph.getFunctionCalls();
|
|
|
|
DEBUG(std::cerr << std::string(Indent*2, ' ')
|
|
<< "[BU] Calculating graph for: " << F.getName() << "\n");
|
|
|
|
bool Changed;
|
|
while (1) {
|
|
unsigned FirstResolvableCall = 0;
|
|
std::map<Function *, DSCallSite> InProcess;
|
|
|
|
// Insert a call site for self to handle self recursion...
|
|
std::vector<DSNodeHandle> Args;
|
|
Args.reserve(F.asize());
|
|
for (Function::aiterator I = F.abegin(), E = F.aend(); I != E; ++I)
|
|
if (isPointerType(I->getType()))
|
|
Args.push_back(Graph.getNodeForValue(I));
|
|
|
|
InProcess.insert(std::make_pair(&F,
|
|
DSCallSite(*(CallInst*)0, Graph.getRetNode(),(DSNode*)0,Args)));
|
|
|
|
Changed = ResolveFunctionCalls(Graph, FirstResolvableCall, InProcess,
|
|
Indent);
|
|
|
|
if (Changed) {
|
|
Graph.maskIncompleteMarkers();
|
|
Graph.markIncompleteNodes();
|
|
Graph.removeDeadNodes();
|
|
break;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
#if 0
|
|
bool Inlined;
|
|
do {
|
|
Inlined = false;
|
|
|
|
for (unsigned i = 0; i != FCs.size(); ++i) {
|
|
// Copy the call, because inlining graphs may invalidate the FCs vector.
|
|
DSCallSite Call = FCs[i];
|
|
|
|
// If the function list is complete...
|
|
if ((Call.getCallee().getNode()->NodeType & DSNode::Incomplete)==0) {
|
|
// Start inlining all of the functions we can... some may not be
|
|
// inlinable if they are external...
|
|
//
|
|
std::vector<GlobalValue*> Callees =
|
|
Call.getCallee().getNode()->getGlobals();
|
|
|
|
unsigned OldNumCalls = FCs.size();
|
|
|
|
// Loop over the functions, inlining whatever we can...
|
|
for (unsigned c = 0; c != Callees.size(); ++c) {
|
|
// Must be a function type, so this cast MUST succeed.
|
|
Function &FI = cast<Function>(*Callees[c]);
|
|
|
|
if (&FI == &F) {
|
|
// Self recursion... simply link up the formal arguments with the
|
|
// actual arguments...
|
|
DEBUG(std::cerr << std::string(Indent*2, ' ')
|
|
<< "[BU] Self Inlining: " << F.getName() << "\n");
|
|
|
|
// Handle self recursion by resolving the arguments and return value
|
|
Graph.mergeInGraph(Call, Graph, DSGraph::StripAllocaBit);
|
|
|
|
// Erase the entry in the callees vector
|
|
Callees.erase(Callees.begin()+c--);
|
|
|
|
} else if (!FI.isExternal()) {
|
|
DEBUG(std::cerr << std::string(Indent*2, ' ')
|
|
<< "[BU] In " << F.getName() << " inlining: "
|
|
<< FI.getName() << "\n");
|
|
|
|
// Get the data structure graph for the called function, closing it
|
|
// if possible (which is only impossible in the case of mutual
|
|
// recursion...
|
|
//
|
|
DSGraph &GI = calculateGraph(FI, Indent+1); // Graph to inline
|
|
|
|
DEBUG(std::cerr << std::string(Indent*2, ' ')
|
|
<< "[BU] Got graph for " << FI.getName()
|
|
<< " in: " << F.getName() << "[" << GI.getGraphSize() << "+"
|
|
<< GI.getAuxFunctionCalls().size() << "]\n");
|
|
|
|
// Handle self recursion by resolving the arguments and return value
|
|
Graph.mergeInGraph(Call, GI, DSGraph::StripAllocaBit |
|
|
DSGraph::DontCloneCallNodes);
|
|
|
|
// Erase the entry in the Callees vector
|
|
Callees.erase(Callees.begin()+c--);
|
|
|
|
} else if (FI.getName() == "printf" || FI.getName() == "sscanf" ||
|
|
FI.getName() == "fprintf" || FI.getName() == "open" ||
|
|
FI.getName() == "sprintf" || FI.getName() == "fputs") {
|
|
// FIXME: These special cases (eg printf) should go away when we can
|
|
// define functions that take a variable number of arguments.
|
|
|
|
// FIXME: at the very least, this should update mod/ref info
|
|
// Erase the entry in the globals vector
|
|
Callees.erase(Callees.begin()+c--);
|
|
}
|
|
}
|
|
|
|
if (Callees.empty()) { // Inlined all of the function calls?
|
|
// Erase the call if it is resolvable...
|
|
FCs.erase(FCs.begin()+i--); // Don't skip a the next call...
|
|
Inlined = true;
|
|
} else if (Callees.size() !=
|
|
Call.getCallee().getNode()->getGlobals().size()) {
|
|
// Was able to inline SOME, but not all of the functions. Construct a
|
|
// new global node here.
|
|
//
|
|
assert(0 && "Unimpl!");
|
|
Inlined = true;
|
|
}
|
|
|
|
|
|
#if 0
|
|
// If we just inlined a function that had call nodes, chances are that
|
|
// the call nodes are redundant with ones we already have. Eliminate
|
|
// those call nodes now.
|
|
//
|
|
if (FCs.size() >= OldNumCalls)
|
|
Graph.removeTriviallyDeadNodes();
|
|
#endif
|
|
}
|
|
|
|
if (FCs.size() > 200) {
|
|
std::cerr << "Aborted inlining fn: '" << F.getName() << "'!"
|
|
<< std::endl;
|
|
Graph.maskIncompleteMarkers();
|
|
Graph.markIncompleteNodes();
|
|
Graph.removeDeadNodes();
|
|
Graph.writeGraphToFile(std::cerr, "crap."+F.getName());
|
|
exit(1);
|
|
return Graph;
|
|
}
|
|
|
|
}
|
|
|
|
// Recompute the Incomplete markers. If there are any function calls left
|
|
// now that are complete, we must loop!
|
|
if (Inlined) {
|
|
Graph.maskIncompleteMarkers();
|
|
Graph.markIncompleteNodes();
|
|
Graph.removeDeadNodes();
|
|
}
|
|
|
|
} while (Inlined && !FCs.empty());
|
|
#endif
|
|
|
|
DEBUG(std::cerr << std::string(Indent*2, ' ')
|
|
<< "[BU] Done inlining: " << F.getName() << " ["
|
|
<< Graph.getGraphSize() << "+" << Graph.getAuxFunctionCalls().size()
|
|
<< "]\n");
|
|
|
|
Graph.writeGraphToFile(std::cerr, "bu_" + F.getName());
|
|
|
|
return Graph;
|
|
}
|