From: Vikram S. Adve Date: Sun, 20 Oct 2002 21:41:02 +0000 (+0000) Subject: Remove spurious caller pointer in DSCallSite. X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=26b98265b7edb493e220822e7967c0eb15d52fa6;p=oota-llvm.git Remove spurious caller pointer in DSCallSite. Also add functions to access pointer argument nodes cleanly. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@4235 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/llvm/Analysis/DSGraph.h b/include/llvm/Analysis/DSGraph.h index dc8f1adcf54..80ad040c1b9 100644 --- a/include/llvm/Analysis/DSGraph.h +++ b/include/llvm/Analysis/DSGraph.h @@ -362,26 +362,27 @@ inline void DSNodeHandle::mergeWith(const DSNodeHandle &Node) { /// the DSNode handles for the function arguments. /// class DSCallSite: public std::vector { - Function* caller; CallInst* callInst; DSCallSite(); // do not implement public: - DSCallSite(Function& _caller, CallInst& _callInst) - : caller(&_caller), callInst(&_callInst) { } + DSCallSite(CallInst& _callInst) : callInst(&_callInst) { } // Copy constructor with helper for cloning nodes. The helper should be a // model of unary_function, i.e., it // should take a pointer to DSNodeHandle and return a fresh DSNodeHandle. // If no helper is specified, this defaults to a simple copy constructor. template - DSCallSite::DSCallSite(const DSCallSite& FromCall, - _CopierFunction nodeCopier = *(_CopierFunction*) 0); - - Function& getCaller() const { return *caller; } - CallInst& getCallInst() const { return *callInst; } - DSNodeHandle getReturnValueNode() const { return (*this)[0]; } - DSNodeHandle getCalleeNode() const { return (*this)[1]; } + DSCallSite(const DSCallSite& FromCall, + _CopierFunction nodeCopier = *(_CopierFunction*) 0); + + Function& getCaller() const; + CallInst& getCallInst() const { return *callInst; } + DSNodeHandle getReturnValueNode() const { return (*this)[0]; } + DSNodeHandle getCalleeNode() const { return (*this)[1]; } + unsigned getNumPtrArgs() const { return (size() - 2); } + DSNodeHandle getPtrArgNode(unsigned i) const { assert(i < getNumPtrArgs()); + return (*this)[i+2]; } }; diff --git a/include/llvm/Analysis/DataStructure/DSGraph.h b/include/llvm/Analysis/DataStructure/DSGraph.h index dc8f1adcf54..80ad040c1b9 100644 --- a/include/llvm/Analysis/DataStructure/DSGraph.h +++ b/include/llvm/Analysis/DataStructure/DSGraph.h @@ -362,26 +362,27 @@ inline void DSNodeHandle::mergeWith(const DSNodeHandle &Node) { /// the DSNode handles for the function arguments. /// class DSCallSite: public std::vector { - Function* caller; CallInst* callInst; DSCallSite(); // do not implement public: - DSCallSite(Function& _caller, CallInst& _callInst) - : caller(&_caller), callInst(&_callInst) { } + DSCallSite(CallInst& _callInst) : callInst(&_callInst) { } // Copy constructor with helper for cloning nodes. The helper should be a // model of unary_function, i.e., it // should take a pointer to DSNodeHandle and return a fresh DSNodeHandle. // If no helper is specified, this defaults to a simple copy constructor. template - DSCallSite::DSCallSite(const DSCallSite& FromCall, - _CopierFunction nodeCopier = *(_CopierFunction*) 0); - - Function& getCaller() const { return *caller; } - CallInst& getCallInst() const { return *callInst; } - DSNodeHandle getReturnValueNode() const { return (*this)[0]; } - DSNodeHandle getCalleeNode() const { return (*this)[1]; } + DSCallSite(const DSCallSite& FromCall, + _CopierFunction nodeCopier = *(_CopierFunction*) 0); + + Function& getCaller() const; + CallInst& getCallInst() const { return *callInst; } + DSNodeHandle getReturnValueNode() const { return (*this)[0]; } + DSNodeHandle getCalleeNode() const { return (*this)[1]; } + unsigned getNumPtrArgs() const { return (size() - 2); } + DSNodeHandle getPtrArgNode(unsigned i) const { assert(i < getNumPtrArgs()); + return (*this)[i+2]; } }; diff --git a/lib/Analysis/DataStructure/BottomUpClosure.cpp b/lib/Analysis/DataStructure/BottomUpClosure.cpp index b6748d8e38b..52b473883cc 100644 --- a/lib/Analysis/DataStructure/BottomUpClosure.cpp +++ b/lib/Analysis/DataStructure/BottomUpClosure.cpp @@ -60,13 +60,13 @@ static void ResolveArguments(DSCallSite &Call, Function &F, map &ValueMap) { // Resolve all of the function arguments... Function::aiterator AI = F.abegin(); - for (unsigned i = 2, e = Call.size(); i != e; ++i) { + for (unsigned i = 0, e = Call.getNumPtrArgs(); i != e; ++i) { // Advance the argument iterator to the first pointer argument... while (!isPointerType(AI->getType())) ++AI; // Add the link from the argument scalar to the provided value DSNodeHandle &NN = ValueMap[AI]; - NN.addEdgeTo(Call[i]); + NN.addEdgeTo(Call.getPtrArgNode(i)); ++AI; } } @@ -111,10 +111,6 @@ DSGraph &BUDataStructures::calculateGraph(Function &F) { // Must be a function type, so this cast MUST succeed. Function &FI = cast(*Callees[c]); - // Record that this is a call site of FI. - assert(&Call.getCaller() == &F && "Invalid caller in DSCallSite?"); - CallSites[&FI].push_back(Call); - if (&FI == &F) { // Self recursion... simply link up the formal arguments with the // actual arguments... @@ -143,6 +139,11 @@ DSGraph &BUDataStructures::calculateGraph(Function &F) { DEBUG(std::cerr << "\t\t[BU] Got graph for " << FI.getName() << " in: " << F.getName() << "\n"); + // Record that the original DSCallSite was a call site of FI. + // This may or may not have been known when the DSCallSite was + // originally created. + CallSites[&FI].push_back(Call); + // Clone the callee's graph into the current graph, keeping // track of where scalars in the old graph _used_ to point, // and of the new nodes matching nodes of the old graph. diff --git a/lib/Analysis/DataStructure/DataStructure.cpp b/lib/Analysis/DataStructure/DataStructure.cpp index 3a55c5420b1..356736289c0 100644 --- a/lib/Analysis/DataStructure/DataStructure.cpp +++ b/lib/Analysis/DataStructure/DataStructure.cpp @@ -6,6 +6,8 @@ #include "llvm/Analysis/DSGraph.h" #include "llvm/Function.h" +#include "llvm/BasicBlock.h" +#include "llvm/iOther.h" #include "llvm/DerivedTypes.h" #include "llvm/Target/TargetData.h" #include "Support/STLExtras.h" @@ -351,12 +353,15 @@ void DSNode::mergeWith(const DSNodeHandle &NH, unsigned Offset) { } } +// Define here to avoid including iOther.h and BasicBlock.h in DSGraph.h +Function& DSCallSite::getCaller() const { + return * callInst->getParent()->getParent(); +} template DSCallSite::DSCallSite(const DSCallSite& FromCall, _CopierFunction nodeCopier) : std::vector(), - caller(&FromCall.getCaller()), callInst(&FromCall.getCallInst()) { reserve(FromCall.size()); @@ -547,15 +552,15 @@ void DSGraph::markIncompleteNodes(bool markFormalArgs) { // Mark stuff passed into functions calls as being incomplete... for (unsigned i = 0, e = FunctionCalls.size(); i != e; ++i) { - DSCallSite &Args = FunctionCalls[i]; + DSCallSite &Call = FunctionCalls[i]; // Then the return value is certainly incomplete! - markIncompleteNode(Args.getReturnValueNode().getNode()); + markIncompleteNode(Call.getReturnValueNode().getNode()); // The call does not make the function argument incomplete... // All arguments to the function call are incomplete though! - for (unsigned i = 2, e = Args.size(); i != e; ++i) - markIncompleteNode(Args[i].getNode()); + for (unsigned i = 0, e = Call.getNumPtrArgs(); i != e; ++i) + markIncompleteNode(Call.getPtrArgNode(i).getNode()); } // Mark all of the nodes pointed to by global or cast nodes as incomplete... diff --git a/lib/Analysis/DataStructure/Local.cpp b/lib/Analysis/DataStructure/Local.cpp index 15b3a96b877..037e36197c8 100644 --- a/lib/Analysis/DataStructure/Local.cpp +++ b/lib/Analysis/DataStructure/Local.cpp @@ -356,7 +356,7 @@ void GraphBuilder::visitReturnInst(ReturnInst &RI) { void GraphBuilder::visitCallInst(CallInst &CI) { // Add a new function call entry... - FunctionCalls.push_back(DSCallSite(G.getFunction(), CI)); + FunctionCalls.push_back(DSCallSite(CI)); DSCallSite &Args = FunctionCalls.back(); // Set up the return value... diff --git a/lib/Analysis/DataStructure/Steensgaard.cpp b/lib/Analysis/DataStructure/Steensgaard.cpp index 9bc3db79e73..f0072a02abb 100644 --- a/lib/Analysis/DataStructure/Steensgaard.cpp +++ b/lib/Analysis/DataStructure/Steensgaard.cpp @@ -91,14 +91,14 @@ void Steens::ResolveFunctionCall(Function *F, RetVal.mergeWith(Call.getReturnValueNode()); // Loop over all pointer arguments, resolving them to their provided pointers - unsigned ArgIdx = 2; // Skip retval and function to call... + unsigned PtrArgIdx = 0; for (Function::aiterator AI = F->abegin(), AE = F->aend(); AI != AE; ++AI) { std::map::iterator I = ValMap.find(AI); if (I != ValMap.end()) // If its a pointer argument... - I->second.addEdgeTo(Call[ArgIdx++]); + I->second.addEdgeTo(Call.getPtrArgNode(PtrArgIdx++)); } - assert(ArgIdx == Call.size() && "Argument resolution mismatch!"); + assert(PtrArgIdx == Call.getNumPtrArgs() && "Argument resolution mismatch!"); } diff --git a/lib/Analysis/DataStructure/TopDownClosure.cpp b/lib/Analysis/DataStructure/TopDownClosure.cpp index 1ceaedbe60b..f4b7017b2ea 100644 --- a/lib/Analysis/DataStructure/TopDownClosure.cpp +++ b/lib/Analysis/DataStructure/TopDownClosure.cpp @@ -53,14 +53,14 @@ void TDDataStructures::ResolveCallSite(DSGraph &Graph, Function &F = Graph.getFunction(); Function::aiterator AI = F.abegin(); - for (unsigned i = 2, e = CallSite.size(); i != e; ++i, ++AI) { + for (unsigned i = 0, e = CallSite.getNumPtrArgs(); i != e; ++i, ++AI) { // Advance the argument iterator to the first pointer argument... while (!DataStructureAnalysis::isPointerType(AI->getType())) ++AI; // TD ...Merge the formal arg scalar with the actual arg node DSNodeHandle &NodeForFormal = Graph.getNodeForValue(AI); if (NodeForFormal.getNode()) - NodeForFormal.mergeWith(CallSite[i]); + NodeForFormal.mergeWith(CallSite.getPtrArgNode(i)); } // Merge returned node in the caller with the "return" node in callee @@ -68,6 +68,13 @@ void TDDataStructures::ResolveCallSite(DSGraph &Graph, Graph.getRetNode().mergeWith(CallSite.getReturnValueNode()); } + +static DSNodeHandle copyHelper(const DSNodeHandle* fromNode, + std::map *NodeMap) { + return DSNodeHandle((*NodeMap)[fromNode->getNode()], fromNode->getOffset()); +} + + DSGraph &TDDataStructures::calculateGraph(Function &F) { // Make sure this graph has not already been calculated, or that we don't get // into an infinite loop with mutually recursive functions. @@ -128,12 +135,8 @@ DSGraph &TDDataStructures::calculateGraph(Function &F) { // Make a temporary copy of the call site, and transform the argument node // pointers. - DSCallSite TmpCallSite = CallSite; - for (unsigned i = 0, e = CallSite.size(); i != e; ++i) { - const DSNode *OldNode = TmpCallSite[i].getNode(); - TmpCallSite[i].setNode(OldNodeMap[OldNode]); - } - + DSCallSite TmpCallSite(CallSite, std::bind2nd(std::ptr_fun(©Helper), + &OldNodeMap)); ResolveCallSite(*Graph, CallSite); } }