From: Chris Lattner Date: Wed, 6 Mar 2002 17:16:43 +0000 (+0000) Subject: Take CallGraph out of the CFG namespace. It has nothing to do with CFGs X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=4ce0f8aa9ee0038ba741291e2ae1188be75d1d8b;p=oota-llvm.git Take CallGraph out of the CFG namespace. It has nothing to do with CFGs git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@1820 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/llvm/Analysis/CallGraph.h b/include/llvm/Analysis/CallGraph.h index cc6d023d6dd..a2494654c5d 100644 --- a/include/llvm/Analysis/CallGraph.h +++ b/include/llvm/Analysis/CallGraph.h @@ -21,8 +21,6 @@ class Method; class Module; -namespace cfg { - class CallGraph; class CallGraphNode { Method *Meth; @@ -141,41 +139,39 @@ private: // Implementation of CallGraph construction void addToCallGraph(Method *M); }; -} // end namespace cfg - // Provide graph traits for tranversing call graphs using standard graph // traversals. -template <> struct GraphTraits { - typedef cfg::CallGraphNode NodeType; +template <> struct GraphTraits { + typedef CallGraphNode NodeType; typedef NodeType::iterator ChildIteratorType; - static NodeType *getEntryNode(cfg::CallGraphNode *CGN) { return CGN; } + static NodeType *getEntryNode(CallGraphNode *CGN) { return CGN; } static inline ChildIteratorType child_begin(NodeType *N) { return N->begin();} static inline ChildIteratorType child_end (NodeType *N) { return N->end(); } }; -template <> struct GraphTraits { - typedef const cfg::CallGraphNode NodeType; +template <> struct GraphTraits { + typedef const CallGraphNode NodeType; typedef NodeType::const_iterator ChildIteratorType; - static NodeType *getEntryNode(const cfg::CallGraphNode *CGN) { return CGN; } + static NodeType *getEntryNode(const CallGraphNode *CGN) { return CGN; } static inline ChildIteratorType child_begin(NodeType *N) { return N->begin();} static inline ChildIteratorType child_end (NodeType *N) { return N->end(); } }; -template<> struct GraphTraits : - public GraphTraits { - static NodeType *getEntryNode(cfg::CallGraph *CGN) { +template<> struct GraphTraits : + public GraphTraits { + static NodeType *getEntryNode(CallGraph *CGN) { return CGN->getRoot(); } }; -template<> struct GraphTraits : - public GraphTraits { - static NodeType *getEntryNode(const cfg::CallGraph *CGN) { +template<> struct GraphTraits : + public GraphTraits { + static NodeType *getEntryNode(const CallGraph *CGN) { return CGN->getRoot(); } }; @@ -185,6 +181,6 @@ template<> struct GraphTraits : // Note that this uses the call graph only if one is provided. // It does not build the call graph. // -bool isLeafMethod(const Method* method, const cfg::CallGraph *callGraph = 0); +bool isLeafMethod(const Method* method, const CallGraph *callGraph = 0); #endif diff --git a/lib/Analysis/IPA/CallGraph.cpp b/lib/Analysis/IPA/CallGraph.cpp index 04b8c2d6bc8..713c181fbcc 100644 --- a/lib/Analysis/IPA/CallGraph.cpp +++ b/lib/Analysis/IPA/CallGraph.cpp @@ -20,13 +20,13 @@ #include "Support/STLExtras.h" #include -AnalysisID cfg::CallGraph::ID(AnalysisID::create()); -//AnalysisID cfg::CallGraph::ID(AnalysisID::template AnalysisID()); +AnalysisID CallGraph::ID(AnalysisID::create()); +//AnalysisID CallGraph::ID(AnalysisID::template AnalysisID()); // getNodeFor - Return the node for the specified method or create one if it // does not already exist. // -cfg::CallGraphNode *cfg::CallGraph::getNodeFor(Method *M) { +CallGraphNode *CallGraph::getNodeFor(Method *M) { iterator I = MethodMap.find(M); if (I != MethodMap.end()) return I->second; @@ -40,7 +40,7 @@ cfg::CallGraphNode *cfg::CallGraph::getNodeFor(Method *M) { // addToCallGraph - Add a method to the call graph, and link the node to all of // the methods that it calls. // -void cfg::CallGraph::addToCallGraph(Method *M) { +void CallGraph::addToCallGraph(Method *M) { CallGraphNode *Node = getNodeFor(M); // If this method has external linkage, @@ -56,7 +56,7 @@ void cfg::CallGraph::addToCallGraph(Method *M) { } } -bool cfg::CallGraph::run(Module *TheModule) { +bool CallGraph::run(Module *TheModule) { destroy(); Mod = TheModule; @@ -70,7 +70,7 @@ bool cfg::CallGraph::run(Module *TheModule) { return false; } -void cfg::CallGraph::destroy() { +void CallGraph::destroy() { for (MethodMapTy::iterator I = MethodMap.begin(), E = MethodMap.end(); I != E; ++I) { delete I->second; @@ -79,7 +79,7 @@ void cfg::CallGraph::destroy() { } -void cfg::WriteToOutput(const CallGraphNode *CGN, std::ostream &o) { +void WriteToOutput(const CallGraphNode *CGN, std::ostream &o) { if (CGN->getMethod()) o << "Call graph node for method: '" << CGN->getMethod()->getName() <<"'\n"; else @@ -90,7 +90,7 @@ void cfg::WriteToOutput(const CallGraphNode *CGN, std::ostream &o) { o << "\n"; } -void cfg::WriteToOutput(const CallGraph &CG, std::ostream &o) { +void WriteToOutput(const CallGraph &CG, std::ostream &o) { WriteToOutput(CG.getRoot(), o); for (CallGraph::const_iterator I = CG.begin(), E = CG.end(); I != E; ++I) o << I->second; @@ -104,7 +104,7 @@ void cfg::WriteToOutput(const CallGraph &CG, std::ostream &o) { // Methods to keep a call graph up to date with a method that has been // modified // -void cfg::CallGraph::addMethodToModule(Method *Meth) { +void CallGraph::addMethodToModule(Method *Meth) { assert(0 && "not implemented"); abort(); } @@ -115,7 +115,7 @@ void cfg::CallGraph::addMethodToModule(Method *Meth) { // methods (ie, there are no edges in it's CGN). The easiest way to do this // is to dropAllReferences before calling this. // -Method *cfg::CallGraph::removeMethodFromModule(CallGraphNode *CGN) { +Method *CallGraph::removeMethodFromModule(CallGraphNode *CGN) { assert(CGN->CalledMethods.empty() && "Cannot remove method from call graph" " if it references other methods!"); Method *M = CGN->getMethod(); // Get the method for the call graph node @@ -132,9 +132,9 @@ Method *cfg::CallGraph::removeMethodFromModule(CallGraphNode *CGN) { // Note that this uses the call graph only if one is provided. // It does not build the call graph. // -bool IsLeafMethod(const Method* M, const cfg::CallGraph* CG) { +bool IsLeafMethod(const Method* M, const CallGraph* CG) { if (CG) { - const cfg::CallGraphNode *cgn = (*CG)[M]; + const CallGraphNode *cgn = (*CG)[M]; return (cgn->begin() == cgn->end()); } diff --git a/lib/Transforms/IPO/GlobalDCE.cpp b/lib/Transforms/IPO/GlobalDCE.cpp index 454f6014e6d..ea23dbedda1 100644 --- a/lib/Transforms/IPO/GlobalDCE.cpp +++ b/lib/Transforms/IPO/GlobalDCE.cpp @@ -12,20 +12,20 @@ #include "Support/DepthFirstIterator.h" #include -static bool RemoveUnreachableMethods(Module *M, cfg::CallGraph &CallGraph) { +static bool RemoveUnreachableMethods(Module *M, CallGraph &CallGraph) { // Calculate which methods are reachable from the external methods in the call // graph. // - std::set ReachableNodes(df_begin(&CallGraph), - df_end(&CallGraph)); + std::set ReachableNodes(df_begin(&CallGraph), + df_end(&CallGraph)); // Loop over the methods in the module twice. The first time is used to drop // references that methods have to each other before they are deleted. The // second pass removes the methods that need to be removed. // - std::vector MethodsToDelete; // Track unused methods + std::vector MethodsToDelete; // Track unused methods for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I) { - cfg::CallGraphNode *N = CallGraph[*I]; + CallGraphNode *N = CallGraph[*I]; if (!ReachableNodes.count(N)) { // Not reachable?? (*I)->dropAllReferences(); N->removeAllCalledMethods(); @@ -39,7 +39,7 @@ static bool RemoveUnreachableMethods(Module *M, cfg::CallGraph &CallGraph) { // Unreachables methods have been found and should have no references to them, // delete them now. // - for (std::vector::iterator I = MethodsToDelete.begin(), + for (std::vector::iterator I = MethodsToDelete.begin(), E = MethodsToDelete.end(); I != E; ++I) delete CallGraph.removeMethodFromModule(*I); @@ -52,7 +52,7 @@ namespace { // the specified callgraph to reflect the changes. // bool run(Module *M) { - return RemoveUnreachableMethods(M, getAnalysis()); + return RemoveUnreachableMethods(M, getAnalysis()); } // getAnalysisUsageInfo - This function works on the call graph of a module. @@ -62,9 +62,9 @@ namespace { virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Required, Pass::AnalysisSet &Destroyed, Pass::AnalysisSet &Provided) { - Required.push_back(cfg::CallGraph::ID); + Required.push_back(CallGraph::ID); // FIXME: This should update the callgraph, not destroy it! - Destroyed.push_back(cfg::CallGraph::ID); + Destroyed.push_back(CallGraph::ID); } }; } diff --git a/lib/Transforms/IPO/MutateStructTypes.cpp b/lib/Transforms/IPO/MutateStructTypes.cpp index 77109330c4e..c67a2e006d2 100644 --- a/lib/Transforms/IPO/MutateStructTypes.cpp +++ b/lib/Transforms/IPO/MutateStructTypes.cpp @@ -531,5 +531,5 @@ void MutateStructTypes::getAnalysisUsageInfo(Pass::AnalysisSet &Required, Pass::AnalysisSet &Provided) { Destroyed.push_back(FindUsedTypes::ID); Destroyed.push_back(FindUnsafePointerTypes::ID); - Destroyed.push_back(cfg::CallGraph::ID); + Destroyed.push_back(CallGraph::ID); }