From d99d4d7b70b45d25e7dc91c6e7edb9206509ed39 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Thu, 18 Jul 2002 04:43:16 +0000 Subject: [PATCH] * s/method/function git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@2958 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Analysis/IPA/CallGraph.cpp | 105 +++++++++++++++++---------------- 1 file changed, 53 insertions(+), 52 deletions(-) diff --git a/lib/Analysis/IPA/CallGraph.cpp b/lib/Analysis/IPA/CallGraph.cpp index 1c61ff3d8bb..0e3722a86e3 100644 --- a/lib/Analysis/IPA/CallGraph.cpp +++ b/lib/Analysis/IPA/CallGraph.cpp @@ -3,37 +3,37 @@ // This interface is used to build and manipulate a call graph, which is a very // useful tool for interprocedural optimization. // -// Every method in a module is represented as a node in the call graph. The -// callgraph node keeps track of which methods the are called by the method +// Every function in a module is represented as a node in the call graph. The +// callgraph node keeps track of which functions the are called by the function // corresponding to the node. // -// A call graph will contain nodes where the method that they correspond to is +// A call graph will contain nodes where the function that they correspond to is // null. This 'external' node is used to represent control flow that is not // represented (or analyzable) in the module. As such, the external node will -// have edges to methods with the following properties: -// 1. All methods in the module without internal linkage, since they could -// be called by methods outside of the our analysis capability. -// 2. All methods whose address is used for something more than a direct call, -// for example being stored into a memory location. Since they may be -// called by an unknown caller later, they must be tracked as such. +// have edges to functions with the following properties: +// 1. All functions in the module without internal linkage, since they could +// be called by functions outside of the our analysis capability. +// 2. All functions whose address is used for something more than a direct +// call, for example being stored into a memory location. Since they may +// be called by an unknown caller later, they must be tracked as such. // -// Similarly, methods have a call edge to the external node iff: -// 1. The method is external, reflecting the fact that they could call +// Similarly, functions have a call edge to the external node iff: +// 1. The function is external, reflecting the fact that they could call // anything without internal linkage or that has its address taken. -// 2. The method contains an indirect method call. +// 2. The function contains an indirect function call. // // As an extension in the future, there may be multiple nodes with a null -// method. These will be used when we can prove (through pointer analysis) that -// an indirect call site can call only a specific set of methods. +// function. These will be used when we can prove (through pointer analysis) +// that an indirect call site can call only a specific set of functions. // // Because of these properties, the CallGraph captures a conservative superset // of all of the caller-callee relationships, which is useful for // transformations. // // The CallGraph class also attempts to figure out what the root of the -// CallGraph is, which is currently does by looking for a method named 'main'. -// If no method named 'main' is found, the external node is used as the entry -// node, reflecting the fact that any method without internal linkage could +// CallGraph is, which is currently does by looking for a function named 'main'. +// If no function named 'main' is found, the external node is used as the entry +// node, reflecting the fact that any function without internal linkage could // be called into (which is common for libraries). // //===----------------------------------------------------------------------===// @@ -50,26 +50,26 @@ AnalysisID CallGraph::ID(AnalysisID::create()); -// getNodeFor - Return the node for the specified method or create one if it +// getNodeFor - Return the node for the specified function or create one if it // does not already exist. // CallGraphNode *CallGraph::getNodeFor(Function *F) { - CallGraphNode *&CGN = MethodMap[F]; + CallGraphNode *&CGN = FunctionMap[F]; if (CGN) return CGN; assert((!F || F->getParent() == Mod) && "Function not in current module!"); return CGN = new CallGraphNode(F); } -// addToCallGraph - Add a method to the call graph, and link the node to all of -// the methods that it calls. +// addToCallGraph - Add a function to the call graph, and link the node to all +// of the functions that it calls. // void CallGraph::addToCallGraph(Function *M) { CallGraphNode *Node = getNodeFor(M); - // If this method has external linkage, + // If this function has external linkage, if (!M->hasInternalLinkage()) { - ExternalNode->addCalledMethod(Node); + ExternalNode->addCalledFunction(Node); // Found the entry point? if (M->getName() == "main") { @@ -79,32 +79,32 @@ void CallGraph::addToCallGraph(Function *M) { Root = Node; // Found a main, keep track of it! } } else if (M->isExternal()) { // Not defined in this xlation unit? - Node->addCalledMethod(ExternalNode); // It could call anything... + Node->addCalledFunction(ExternalNode); // It could call anything... } - // Loop over all of the users of the method... looking for callers... + // Loop over all of the users of the function... looking for callers... // for (Value::use_iterator I = M->use_begin(), E = M->use_end(); I != E; ++I) { User *U = *I; if (CallInst *CI = dyn_cast(U)) - getNodeFor(CI->getParent()->getParent())->addCalledMethod(Node); + getNodeFor(CI->getParent()->getParent())->addCalledFunction(Node); else if (InvokeInst *II = dyn_cast(U)) - getNodeFor(II->getParent()->getParent())->addCalledMethod(Node); + getNodeFor(II->getParent()->getParent())->addCalledFunction(Node); else // Can't classify the user! - ExternalNode->addCalledMethod(Node); + ExternalNode->addCalledFunction(Node); } - // Look for an indirect method call... + // Look for an indirect function call... for (Function::iterator BB = M->begin(), BBE = M->end(); BB != BBE; ++BB) for (BasicBlock::iterator II = BB->begin(), IE = BB->end(); II != IE; ++II){ Instruction &I = *II; if (CallInst *CI = dyn_cast(&I)) { if (CI->getCalledFunction() == 0) - Node->addCalledMethod(ExternalNode); + Node->addCalledFunction(ExternalNode); } else if (InvokeInst *II = dyn_cast(&I)) { if (II->getCalledFunction() == 0) - Node->addCalledMethod(ExternalNode); + Node->addCalledFunction(ExternalNode); } } } @@ -116,33 +116,34 @@ bool CallGraph::run(Module &M) { ExternalNode = getNodeFor(0); Root = 0; - // Add every method to the call graph... + // Add every function to the call graph... for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) addToCallGraph(I); - // If we didn't find a main method, use the external call graph node + // If we didn't find a main function, use the external call graph node if (Root == 0) Root = ExternalNode; return false; } void CallGraph::destroy() { - for (MethodMapTy::iterator I = MethodMap.begin(), E = MethodMap.end(); + for (FunctionMapTy::iterator I = FunctionMap.begin(), E = FunctionMap.end(); I != E; ++I) delete I->second; - MethodMap.clear(); + FunctionMap.clear(); } void WriteToOutput(const CallGraphNode *CGN, std::ostream &o) { - if (CGN->getMethod()) - o << "Call graph node for method: '" << CGN->getMethod()->getName() <<"'\n"; + if (CGN->getFunction()) + o << "Call graph node for function: '" + << CGN->getFunction()->getName() <<"'\n"; else - o << "Call graph node null method:\n"; + o << "Call graph node null function:\n"; for (unsigned i = 0; i < CGN->size(); ++i) - if ((*CGN)[i]->getMethod()) - o << " Calls method '" << (*CGN)[i]->getMethod()->getName() << "'\n"; + if ((*CGN)[i]->getFunction()) + o << " Calls function '" << (*CGN)[i]->getFunction()->getName() << "'\n"; else o << " Calls external node\n"; o << "\n"; @@ -160,26 +161,26 @@ void WriteToOutput(const CallGraph &CG, std::ostream &o) { // Implementations of public modification methods // -// Methods to keep a call graph up to date with a method that has been +// Functions to keep a call graph up to date with a function that has been // modified // -void CallGraph::addMethodToModule(Function *Meth) { +void CallGraph::addFunctionToModule(Function *Meth) { assert(0 && "not implemented"); abort(); } -// removeMethodFromModule - Unlink the method from this module, returning it. -// Because this removes the method from the module, the call graph node is -// destroyed. This is only valid if the method does not call any other -// methods (ie, there are no edges in it's CGN). The easiest way to do this +// removeFunctionFromModule - Unlink the function from this module, returning +// it. Because this removes the function from the module, the call graph node +// is destroyed. This is only valid if the function does not call any other +// functions (ie, there are no edges in it's CGN). The easiest way to do this // is to dropAllReferences before calling this. // -Function *CallGraph::removeMethodFromModule(CallGraphNode *CGN) { - assert(CGN->CalledMethods.empty() && "Cannot remove method from call graph" - " if it references other methods!"); - Function *M = CGN->getMethod(); // Get the function for the call graph node - delete CGN; // Delete the call graph node for this func - MethodMap.erase(M); // Remove the call graph node from the map +Function *CallGraph::removeFunctionFromModule(CallGraphNode *CGN) { + assert(CGN->CalledFunctions.empty() && "Cannot remove function from call " + "graph if it references other functions!"); + Function *M = CGN->getFunction(); // Get the function for the call graph node + delete CGN; // Delete the call graph node for this func + FunctionMap.erase(M); // Remove the call graph node from the map Mod->getFunctionList().remove(M); return M; -- 2.34.1