- Make DSCallSite not inherit from std::vector. Renamed methods slightly.
Make copy ctor have two versions to avoid dealing with conditional template
argument. DSCallSite ctor now takes all arguments instead of taking one
and being populated later.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@4240 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/lib/Analysis/DataStructure/BottomUpClosure.cpp b/lib/Analysis/DataStructure/BottomUpClosure.cpp
index 89b6b01..53b997f 100644
--- a/lib/Analysis/DataStructure/BottomUpClosure.cpp
+++ b/lib/Analysis/DataStructure/BottomUpClosure.cpp
@@ -66,7 +66,7 @@
// Add the link from the argument scalar to the provided value
DSNodeHandle &NN = ValueMap[AI];
- NN.addEdgeTo(Call.getPtrArgNode(i));
+ NN.addEdgeTo(Call.getPtrArg(i));
++AI;
}
}
@@ -100,12 +100,12 @@
DSCallSite Call = FCs[i];
// If the function list is complete...
- if ((Call.getCalleeNode().getNode()->NodeType & DSNode::Incomplete)==0) {
+ 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.getCalleeNode().getNode()->getGlobals();
+ Call.getCallee().getNode()->getGlobals();
// Loop over the functions, inlining whatever we can...
for (unsigned c = 0; c != Callees.size(); ++c) {
@@ -118,8 +118,8 @@
DEBUG(std::cerr << "\t[BU] Self Inlining: " << F.getName() << "\n");
// Handle the return value if present...
- if (Call.getReturnValueNode().getNode())
- Graph->getRetNode().mergeWith(Call.getReturnValueNode());
+ if (Call.getRetVal().getNode())
+ Graph->getRetNode().mergeWith(Call.getRetVal());
// Resolve the arguments in the call to the actual values...
ResolveArguments(Call, F, Graph->getValueMap());
@@ -162,8 +162,8 @@
// Resolve the arguments in the call to the actual values...
ResolveArguments(Call, FI, OldValMap);
- if (Call.getReturnValueNode().getNode()) // Handle the return value if present
- RetVal.mergeWith(Call.getReturnValueNode());
+ if (Call.getRetVal().getNode())// Handle the return value if present
+ RetVal.mergeWith(Call.getRetVal());
// Erase the entry in the Callees vector
Callees.erase(Callees.begin()+c--);
@@ -181,7 +181,8 @@
// 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.getCalleeNode().getNode()->getGlobals().size()) {
+ } 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.
//
diff --git a/lib/Analysis/DataStructure/DataStructure.cpp b/lib/Analysis/DataStructure/DataStructure.cpp
index cf18d57..7a57507 100644
--- a/lib/Analysis/DataStructure/DataStructure.cpp
+++ b/lib/Analysis/DataStructure/DataStructure.cpp
@@ -358,17 +358,19 @@
// Define here to avoid including iOther.h and BasicBlock.h in DSGraph.h
Function &DSCallSite::getCaller() const {
- return *callInst->getParent()->getParent();
+ return *Inst->getParent()->getParent();
}
template <typename CopyFunctor>
DSCallSite::DSCallSite(const DSCallSite &FromCall, CopyFunctor nodeCopier)
- : callInst(&FromCall.getCallInst()) {
+ : Inst(FromCall.Inst) {
- reserve(FromCall.size());
- for (unsigned j = 0, ej = FromCall.size(); j != ej; ++j)
- push_back(&nodeCopier == 0 ? DSNodeHandle(FromCall[j])
- : nodeCopier(&FromCall[j]));
+ RetVal = nodeCopier(&RetVal);
+ Callee = nodeCopier(&Callee);
+
+ CallArgs.reserve(FromCall.CallArgs.size());
+ for (unsigned j = 0, ej = FromCall.CallArgs.size(); j != ej; ++j)
+ CallArgs.push_back(nodeCopier(&FromCall.CallArgs[j]));
}
@@ -555,13 +557,13 @@
for (unsigned i = 0, e = FunctionCalls.size(); i != e; ++i) {
DSCallSite &Call = FunctionCalls[i];
// Then the return value is certainly incomplete!
- markIncompleteNode(Call.getReturnValueNode().getNode());
+ markIncompleteNode(Call.getRetVal().getNode());
// The call does not make the function argument incomplete...
// All arguments to the function call are incomplete though!
for (unsigned i = 0, e = Call.getNumPtrArgs(); i != e; ++i)
- markIncompleteNode(Call.getPtrArgNode(i).getNode());
+ markIncompleteNode(Call.getPtrArg(i).getNode());
}
// Mark all of the nodes pointed to by global or cast nodes as incomplete...
@@ -693,7 +695,7 @@
// Iterate, marking globals or cast nodes alive until no new live nodes
// are added to Alive
std::set<DSNode*> Visiting; // Used to identify cycles
- std::set<DSNode*>::iterator I=GlobalNodes.begin(), E=GlobalNodes.end();
+ std::set<DSNode*>::iterator I = GlobalNodes.begin(), E = GlobalNodes.end();
for (size_t liveCount = 0; liveCount < Alive.size(); ) {
liveCount = Alive.size();
for ( ; I != E; ++I)
@@ -708,24 +710,39 @@
// Since all call nodes must be live if any one is live, we have to mark
// all nodes of the call as live and continue the iteration (via recursion).
if (FilterCalls) {
- bool recurse = false;
- for (int i = 0, ei = Calls.size(); i < ei; ++i) {
+ bool Recurse = false;
+ for (unsigned i = 0, ei = Calls.size(); i < ei; ++i) {
bool CallIsDead = true, CallHasDeadArg = false;
- for (unsigned j = 0, ej = Calls[i].size(); j != ej; ++j) {
- bool argIsDead = Calls[i][j].getNode() == 0 ||
- Alive.count(Calls[i][j].getNode()) == 0;
- CallHasDeadArg |= (Calls[i][j].getNode() != 0 && argIsDead);
- CallIsDead &= argIsDead;
+ DSCallSite &CS = Calls[i];
+ for (unsigned j = 0, ej = CS.getNumPtrArgs(); j != ej; ++j)
+ if (DSNode *N = CS.getPtrArg(j).getNode()) {
+ bool ArgIsDead = !Alive.count(N);
+ CallHasDeadArg |= ArgIsDead;
+ CallIsDead &= ArgIsDead;
+ }
+
+ if (DSNode *N = CS.getRetVal().getNode()) {
+ bool RetIsDead = !Alive.count(N);
+ CallHasDeadArg |= RetIsDead;
+ CallIsDead &= RetIsDead;
}
+
+ DSNode *N = CS.getCallee().getNode();
+ bool FnIsDead = !Alive.count(N);
+ CallHasDeadArg |= FnIsDead;
+ CallIsDead &= FnIsDead;
+
if (!CallIsDead && CallHasDeadArg) {
// Some node in this call is live and another is dead.
// Mark all nodes of call as live and iterate once more.
- recurse = true;
- for (unsigned j = 0, ej = Calls[i].size(); j != ej; ++j)
- markAlive(Calls[i][j].getNode(), Alive);
+ Recurse = true;
+ for (unsigned j = 0, ej = CS.getNumPtrArgs(); j != ej; ++j)
+ markAlive(CS.getPtrArg(j).getNode(), Alive);
+ markAlive(CS.getRetVal().getNode(), Alive);
+ markAlive(CS.getCallee().getNode(), Alive);
}
}
- if (recurse)
+ if (Recurse)
markGlobalsIteration(GlobalNodes, Calls, Alive, FilterCalls);
}
}
@@ -746,10 +763,15 @@
// Add all call nodes to the same set
vector<DSCallSite> &Calls = G.getFunctionCalls();
if (FilterCalls) {
- for (unsigned i = 0, e = Calls.size(); i != e; ++i)
- for (unsigned j = 0, e = Calls[i].size(); j != e; ++j)
- if (Calls[i][j].getNode())
- GlobalNodes.insert(Calls[i][j].getNode());
+ for (unsigned i = 0, e = Calls.size(); i != e; ++i) {
+ for (unsigned j = 0, e = Calls[i].getNumPtrArgs(); j != e; ++j)
+ if (DSNode *N = Calls[i].getPtrArg(j).getNode())
+ GlobalNodes.insert(N);
+ if (DSNode *N = Calls[i].getRetVal().getNode())
+ GlobalNodes.insert(N);
+ if (DSNode *N = Calls[i].getCallee().getNode())
+ GlobalNodes.insert(N);
+ }
}
// Iterate and recurse until no new live node are discovered.
@@ -766,8 +788,9 @@
if (FilterCalls)
for (int ei = Calls.size(), i = ei-1; i >= 0; --i) {
bool CallIsDead = true;
- for (unsigned j = 0, ej = Calls[i].size(); CallIsDead && j != ej; ++j)
- CallIsDead = Alive.count(Calls[i][j].getNode()) == 0;
+ for (unsigned j = 0, ej = Calls[i].getNumPtrArgs();
+ CallIsDead && j != ej; ++j)
+ CallIsDead = Alive.count(Calls[i].getPtrArg(j).getNode()) == 0;
if (CallIsDead)
Calls.erase(Calls.begin() + i); // remove the call entirely
}
@@ -793,9 +816,12 @@
// If KeepCalls, mark all nodes reachable by call nodes as alive...
if (KeepCalls)
- for (unsigned i = 0, e = FunctionCalls.size(); i != e; ++i)
- for (unsigned j = 0, e = FunctionCalls[i].size(); j != e; ++j)
- markAlive(FunctionCalls[i][j].getNode(), Alive);
+ for (unsigned i = 0, e = FunctionCalls.size(); i != e; ++i) {
+ for (unsigned j = 0, e = FunctionCalls[i].getNumPtrArgs(); j != e; ++j)
+ markAlive(FunctionCalls[i].getPtrArg(j).getNode(), Alive);
+ markAlive(FunctionCalls[i].getRetVal().getNode(), Alive);
+ markAlive(FunctionCalls[i].getCallee().getNode(), Alive);
+ }
#if 0
for (unsigned i = 0, e = OrigFunctionCalls.size(); i != e; ++i)
@@ -817,7 +843,7 @@
// Mark all globals or cast nodes that can reach a live node as alive.
// This also marks all nodes reachable from such nodes as alive.
// Of course, if KeepAllGlobals is specified, they would be live already.
- if (! KeepAllGlobals)
+ if (!KeepAllGlobals)
markGlobalsAlive(*this, Alive, ! KeepCalls);
// Loop over all unreachable nodes, dropping their references...
diff --git a/lib/Analysis/DataStructure/Local.cpp b/lib/Analysis/DataStructure/Local.cpp
index 7a749a1..0e17d72 100644
--- a/lib/Analysis/DataStructure/Local.cpp
+++ b/lib/Analysis/DataStructure/Local.cpp
@@ -257,6 +257,7 @@
/// object, pointing the scalar to it.
///
void GraphBuilder::handleAlloc(AllocationInst &AI, DSNode::NodeTy NodeType) {
+ //DSNode *New = createNode(NodeType, Type::VoidTy);
DSNode *New = createNode(NodeType, AI.getAllocatedType());
// Make the scalar point to the new node...
@@ -354,28 +355,30 @@
}
void GraphBuilder::visitCallInst(CallInst &CI) {
- // Add a new function call entry...
- FunctionCalls.push_back(CI);
- DSCallSite &Args = FunctionCalls.back();
-
// Set up the return value...
+ DSNodeHandle RetVal;
if (isPointerType(CI.getType()))
- Args.push_back(getLink(getValueNode(CI), 0, CI.getType()));
- else
- Args.push_back(DSNodeHandle());
+ RetVal = getLink(getValueNode(CI), 0, CI.getType());
- unsigned Start = 0;
+ DSNodeHandle Callee;
// Special case for a direct call, avoid creating spurious scalar node...
- if (GlobalValue *GV = dyn_cast<GlobalValue>(CI.getOperand(0))) {
- Args.push_back(getGlobalNode(*GV));
- Start = 1;
- }
+ if (GlobalValue *GV = dyn_cast<GlobalValue>(CI.getOperand(0)))
+ Callee = getGlobalNode(*GV);
+ else
+ Callee = getLink(getValueNode(*CI.getOperand(0)), 0,
+ CI.getOperand(0)->getType());
- // Pass the arguments in...
- for (unsigned i = Start, e = CI.getNumOperands(); i != e; ++i)
+ std::vector<DSNodeHandle> Args;
+ Args.reserve(CI.getNumOperands()-1);
+
+ // Calculate the arguments vector...
+ for (unsigned i = 1, e = CI.getNumOperands(); i != e; ++i)
if (isPointerType(CI.getOperand(i)->getType()))
Args.push_back(getLink(getValueNode(*CI.getOperand(i)), 0,
CI.getOperand(i)->getType()));
+
+ // Add a new function call entry...
+ FunctionCalls.push_back(DSCallSite(CI, RetVal, Callee, Args));
}
/// Handle casts...
diff --git a/lib/Analysis/DataStructure/Printer.cpp b/lib/Analysis/DataStructure/Printer.cpp
index 25e51f1..8b6e362 100644
--- a/lib/Analysis/DataStructure/Printer.cpp
+++ b/lib/Analysis/DataStructure/Printer.cpp
@@ -110,13 +110,13 @@
const std::vector<DSCallSite> &FCs = G->getFunctionCalls();
for (unsigned i = 0, e = FCs.size(); i != e; ++i) {
const DSCallSite &Call = FCs[i];
- GW.emitSimpleNode(&Call, "shape=record", "call", Call.size());
+ GW.emitSimpleNode(&Call, "shape=record", "call", Call.getNumPtrArgs()+2);
- for (unsigned j = 0, e = Call.size(); j != e; ++j)
- if (Call[j].getNode()) {
- int EdgeDest = Call[j].getOffset();
+ for (unsigned j = 0, e = Call.getNumPtrArgs(); j != e; ++j)
+ if (DSNode *N = Call.getPtrArg(j).getNode()) {
+ int EdgeDest = Call.getPtrArg(j).getOffset();
if (EdgeDest == 0) EdgeDest = -1;
- GW.emitEdge(&Call, j, Call[j].getNode(), EdgeDest, "color=gray63");
+ GW.emitEdge(&Call, j+2, N, EdgeDest, "color=gray63");
}
}
}
diff --git a/lib/Analysis/DataStructure/Steensgaard.cpp b/lib/Analysis/DataStructure/Steensgaard.cpp
index f0072a0..74f61c6 100644
--- a/lib/Analysis/DataStructure/Steensgaard.cpp
+++ b/lib/Analysis/DataStructure/Steensgaard.cpp
@@ -87,15 +87,15 @@
std::map<Value*, DSNodeHandle> &ValMap = ResultGraph->getValueMap();
// Handle the return value of the function...
- if (Call.getReturnValueNode().getNode() && RetVal.getNode())
- RetVal.mergeWith(Call.getReturnValueNode());
+ if (Call.getRetVal().getNode() && RetVal.getNode())
+ RetVal.mergeWith(Call.getRetVal());
// Loop over all pointer arguments, resolving them to their provided pointers
unsigned PtrArgIdx = 0;
for (Function::aiterator AI = F->abegin(), AE = F->aend(); AI != AE; ++AI) {
std::map<Value*, DSNodeHandle>::iterator I = ValMap.find(AI);
if (I != ValMap.end()) // If its a pointer argument...
- I->second.addEdgeTo(Call.getPtrArgNode(PtrArgIdx++));
+ I->second.addEdgeTo(Call.getPtrArg(PtrArgIdx++));
}
assert(PtrArgIdx == Call.getNumPtrArgs() && "Argument resolution mismatch!");
@@ -160,7 +160,8 @@
DSCallSite &CurCall = Calls[i];
// Loop over the called functions, eliminating as many as possible...
- std::vector<GlobalValue*> CallTargets = CurCall.getCalleeNode().getNode()->getGlobals();
+ std::vector<GlobalValue*> CallTargets =
+ CurCall.getCallee().getNode()->getGlobals();
for (unsigned c = 0; c != CallTargets.size(); ) {
// If we can eliminate this function call, do so!
bool Eliminated = false;
diff --git a/lib/Analysis/DataStructure/TopDownClosure.cpp b/lib/Analysis/DataStructure/TopDownClosure.cpp
index f4b7017..7db811d 100644
--- a/lib/Analysis/DataStructure/TopDownClosure.cpp
+++ b/lib/Analysis/DataStructure/TopDownClosure.cpp
@@ -60,12 +60,12 @@
// TD ...Merge the formal arg scalar with the actual arg node
DSNodeHandle &NodeForFormal = Graph.getNodeForValue(AI);
if (NodeForFormal.getNode())
- NodeForFormal.mergeWith(CallSite.getPtrArgNode(i));
+ NodeForFormal.mergeWith(CallSite.getPtrArg(i));
}
// Merge returned node in the caller with the "return" node in callee
- if (CallSite.getReturnValueNode().getNode() && Graph.getRetNode().getNode())
- Graph.getRetNode().mergeWith(CallSite.getReturnValueNode());
+ if (CallSite.getRetVal().getNode() && Graph.getRetNode().getNode())
+ Graph.getRetNode().mergeWith(CallSite.getRetVal());
}