From 0969c50cb812efb9dba9577a58cad19c56c21642 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Mon, 21 Oct 2002 02:08:03 +0000 Subject: [PATCH] - 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 --- include/llvm/Analysis/DSGraph.h | 79 ++++++++++++----- include/llvm/Analysis/DataStructure/DSGraph.h | 79 ++++++++++++----- .../DataStructure/BottomUpClosure.cpp | 17 ++-- lib/Analysis/DataStructure/DataStructure.cpp | 86 ++++++++++++------- lib/Analysis/DataStructure/Local.cpp | 31 ++++--- lib/Analysis/DataStructure/Printer.cpp | 10 +-- lib/Analysis/DataStructure/Steensgaard.cpp | 9 +- lib/Analysis/DataStructure/TopDownClosure.cpp | 6 +- 8 files changed, 213 insertions(+), 104 deletions(-) diff --git a/include/llvm/Analysis/DSGraph.h b/include/llvm/Analysis/DSGraph.h index 80ad040c1b9..f07b69e4cee 100644 --- a/include/llvm/Analysis/DSGraph.h +++ b/include/llvm/Analysis/DSGraph.h @@ -47,6 +47,7 @@ public: bool operator<(const DSNodeHandle &H) const { // Allow sorting return N < H.N || (N == H.N && Offset < H.Offset); } + bool operator>(const DSNodeHandle &H) const { return H < *this; } bool operator==(const DSNodeHandle &H) const { // Allow comparison return N == H.N && Offset == H.Offset; } @@ -361,28 +362,66 @@ inline void DSNodeHandle::mergeWith(const DSNodeHandle &Node) { /// the DSNode handle for the callee function (or function pointer), and /// the DSNode handles for the function arguments. /// -class DSCallSite: public std::vector { - CallInst* callInst; - DSCallSite(); // do not implement +class DSCallSite { + CallInst *Inst; // Actual call site + DSNodeHandle RetVal; // Returned value + DSNodeHandle Callee; // The function node called + std::vector CallArgs; // The pointer arguments + DSCallSite(); // DO NOT IMPLEMENT public: - 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(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]; } + /// Note - This ctor destroys the argument vector passed in. On exit, the + /// argument vector is empty. + /// + DSCallSite(CallInst &inst, const DSNodeHandle &rv, const DSNodeHandle &callee, + std::vector &Args) + : Inst(&inst), RetVal(rv), Callee(callee) { + Args.swap(CallArgs); + } + + /// 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(const DSCallSite &FromCall, CopyFunctor nodeCopier); + DSCallSite(const DSCallSite &DSCS) + : Inst(DSCS.Inst), RetVal(DSCS.RetVal), + Callee(DSCS.Callee), CallArgs(DSCS.CallArgs) {} + + // Accessor functions... + Function &getCaller() const; + CallInst &getCallInst() const { return *Inst; } + DSNodeHandle &getRetVal() { return RetVal; } + DSNodeHandle &getCallee() { return Callee; } + const DSNodeHandle &getRetVal() const { return RetVal; } + const DSNodeHandle &getCallee() const { return Callee; } + unsigned getNumPtrArgs() const { return CallArgs.size(); } + + DSNodeHandle &getPtrArg(unsigned i) { + assert(i < CallArgs.size() && "Argument to getPtrArgNode is out of range!"); + return CallArgs[i]; + } + const DSNodeHandle &getPtrArg(unsigned i) const { + assert(i < CallArgs.size() && "Argument to getPtrArgNode is out of range!"); + return CallArgs[i]; + } + + bool operator<(const DSCallSite &CS) const { + if (Inst < CS.Inst) return true; + if (Inst > CS.Inst) return false; + if (RetVal < CS.RetVal) return true; + if (RetVal > CS.RetVal) return false; + if (Callee < CS.Callee) return true; + if (Callee > CS.Callee) return false; + return CallArgs < CS.CallArgs; + } + + bool operator==(const DSCallSite &CS) const { + return Inst == CS.Inst && RetVal == CS.RetVal && Callee == CS.Callee && + CallArgs == CS.CallArgs; + } }; diff --git a/include/llvm/Analysis/DataStructure/DSGraph.h b/include/llvm/Analysis/DataStructure/DSGraph.h index 80ad040c1b9..f07b69e4cee 100644 --- a/include/llvm/Analysis/DataStructure/DSGraph.h +++ b/include/llvm/Analysis/DataStructure/DSGraph.h @@ -47,6 +47,7 @@ public: bool operator<(const DSNodeHandle &H) const { // Allow sorting return N < H.N || (N == H.N && Offset < H.Offset); } + bool operator>(const DSNodeHandle &H) const { return H < *this; } bool operator==(const DSNodeHandle &H) const { // Allow comparison return N == H.N && Offset == H.Offset; } @@ -361,28 +362,66 @@ inline void DSNodeHandle::mergeWith(const DSNodeHandle &Node) { /// the DSNode handle for the callee function (or function pointer), and /// the DSNode handles for the function arguments. /// -class DSCallSite: public std::vector { - CallInst* callInst; - DSCallSite(); // do not implement +class DSCallSite { + CallInst *Inst; // Actual call site + DSNodeHandle RetVal; // Returned value + DSNodeHandle Callee; // The function node called + std::vector CallArgs; // The pointer arguments + DSCallSite(); // DO NOT IMPLEMENT public: - 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(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]; } + /// Note - This ctor destroys the argument vector passed in. On exit, the + /// argument vector is empty. + /// + DSCallSite(CallInst &inst, const DSNodeHandle &rv, const DSNodeHandle &callee, + std::vector &Args) + : Inst(&inst), RetVal(rv), Callee(callee) { + Args.swap(CallArgs); + } + + /// 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(const DSCallSite &FromCall, CopyFunctor nodeCopier); + DSCallSite(const DSCallSite &DSCS) + : Inst(DSCS.Inst), RetVal(DSCS.RetVal), + Callee(DSCS.Callee), CallArgs(DSCS.CallArgs) {} + + // Accessor functions... + Function &getCaller() const; + CallInst &getCallInst() const { return *Inst; } + DSNodeHandle &getRetVal() { return RetVal; } + DSNodeHandle &getCallee() { return Callee; } + const DSNodeHandle &getRetVal() const { return RetVal; } + const DSNodeHandle &getCallee() const { return Callee; } + unsigned getNumPtrArgs() const { return CallArgs.size(); } + + DSNodeHandle &getPtrArg(unsigned i) { + assert(i < CallArgs.size() && "Argument to getPtrArgNode is out of range!"); + return CallArgs[i]; + } + const DSNodeHandle &getPtrArg(unsigned i) const { + assert(i < CallArgs.size() && "Argument to getPtrArgNode is out of range!"); + return CallArgs[i]; + } + + bool operator<(const DSCallSite &CS) const { + if (Inst < CS.Inst) return true; + if (Inst > CS.Inst) return false; + if (RetVal < CS.RetVal) return true; + if (RetVal > CS.RetVal) return false; + if (Callee < CS.Callee) return true; + if (Callee > CS.Callee) return false; + return CallArgs < CS.CallArgs; + } + + bool operator==(const DSCallSite &CS) const { + return Inst == CS.Inst && RetVal == CS.RetVal && Callee == CS.Callee && + CallArgs == CS.CallArgs; + } }; diff --git a/lib/Analysis/DataStructure/BottomUpClosure.cpp b/lib/Analysis/DataStructure/BottomUpClosure.cpp index 89b6b01bf63..53b997f69a3 100644 --- a/lib/Analysis/DataStructure/BottomUpClosure.cpp +++ b/lib/Analysis/DataStructure/BottomUpClosure.cpp @@ -66,7 +66,7 @@ static void ResolveArguments(DSCallSite &Call, Function &F, // 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 @@ DSGraph &BUDataStructures::calculateGraph(Function &F) { 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 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 @@ DSGraph &BUDataStructures::calculateGraph(Function &F) { 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 @@ DSGraph &BUDataStructures::calculateGraph(Function &F) { // 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 @@ DSGraph &BUDataStructures::calculateGraph(Function &F) { // 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 cf18d57dd20..7a57507b9f0 100644 --- a/lib/Analysis/DataStructure/DataStructure.cpp +++ b/lib/Analysis/DataStructure/DataStructure.cpp @@ -358,17 +358,19 @@ 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(); + return *Inst->getParent()->getParent(); } template 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 @@ void DSGraph::markIncompleteNodes(bool markFormalArgs) { 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 @@ static void markGlobalsIteration(std::set& GlobalNodes, // Iterate, marking globals or cast nodes alive until no new live nodes // are added to Alive std::set Visiting; // Used to identify cycles - std::set::iterator I=GlobalNodes.begin(), E=GlobalNodes.end(); + std::set::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 @@ static void markGlobalsIteration(std::set& GlobalNodes, // 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 @@ static void markGlobalsAlive(DSGraph &G, std::set &Alive, // Add all call nodes to the same set vector &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 @@ static void markGlobalsAlive(DSGraph &G, std::set &Alive, 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 @@ void DSGraph::removeDeadNodes(bool KeepAllGlobals, bool KeepCalls) { // 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 @@ void DSGraph::removeDeadNodes(bool KeepAllGlobals, bool KeepCalls) { // 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 7a749a1a795..0e17d7232fd 100644 --- a/lib/Analysis/DataStructure/Local.cpp +++ b/lib/Analysis/DataStructure/Local.cpp @@ -257,6 +257,7 @@ DSNodeHandle &GraphBuilder::getLink(const DSNodeHandle &node, /// 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::visitReturnInst(ReturnInst &RI) { } 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(CI.getOperand(0))) { - Args.push_back(getGlobalNode(*GV)); - Start = 1; - } + if (GlobalValue *GV = dyn_cast(CI.getOperand(0))) + Callee = getGlobalNode(*GV); + else + Callee = getLink(getValueNode(*CI.getOperand(0)), 0, + CI.getOperand(0)->getType()); + + std::vector Args; + Args.reserve(CI.getNumOperands()-1); - // Pass the arguments in... - for (unsigned i = Start, e = CI.getNumOperands(); i != e; ++i) + // 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 25e51f1cbad..8b6e362cbc1 100644 --- a/lib/Analysis/DataStructure/Printer.cpp +++ b/lib/Analysis/DataStructure/Printer.cpp @@ -110,13 +110,13 @@ struct DOTGraphTraits : public DefaultDOTGraphTraits { const std::vector &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 f0072a02abb..74f61c61266 100644 --- a/lib/Analysis/DataStructure/Steensgaard.cpp +++ b/lib/Analysis/DataStructure/Steensgaard.cpp @@ -87,15 +87,15 @@ void Steens::ResolveFunctionCall(Function *F, std::map &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::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 @@ bool Steens::run(Module &M) { DSCallSite &CurCall = Calls[i]; // Loop over the called functions, eliminating as many as possible... - std::vector CallTargets = CurCall.getCalleeNode().getNode()->getGlobals(); + std::vector 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 f4b7017b2ea..7db811dbca9 100644 --- a/lib/Analysis/DataStructure/TopDownClosure.cpp +++ b/lib/Analysis/DataStructure/TopDownClosure.cpp @@ -60,12 +60,12 @@ void TDDataStructures::ResolveCallSite(DSGraph &Graph, // 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()); } -- 2.34.1