X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FAnalysis%2FCallGraph.h;h=651d1901f3e7e444cfafee88e4e01c868692ddc8;hb=0d2d02d317247c811e79ad80a0c027ea1d867c1a;hp=9a6a4a76eb730adbc5f6bbc699672a0b5c7ff944;hpb=f4ccd110750a3f3fe6a107d5c74c649c2a0dc407;p=oota-llvm.git diff --git a/include/llvm/Analysis/CallGraph.h b/include/llvm/Analysis/CallGraph.h index 9a6a4a76eb7..651d1901f3e 100644 --- a/include/llvm/Analysis/CallGraph.h +++ b/include/llvm/Analysis/CallGraph.h @@ -56,9 +56,9 @@ #include "llvm/ADT/STLExtras.h" #include "llvm/IR/CallSite.h" #include "llvm/IR/Function.h" +#include "llvm/IR/Intrinsics.h" #include "llvm/IR/ValueHandle.h" #include "llvm/Pass.h" -#include "llvm/Support/IncludeFile.h" #include namespace llvm { @@ -75,7 +75,8 @@ class CallGraphNode; class CallGraph { Module &M; - typedef std::map FunctionMapTy; + typedef std::map> + FunctionMapTy; /// \brief A map from \c Function* to \c CallGraphNode*. FunctionMapTy FunctionMap; @@ -90,7 +91,7 @@ class CallGraph { /// \brief This node has edges to it from all functions making indirect calls /// or calling an external function. - CallGraphNode *CallsExternalNode; + std::unique_ptr CallsExternalNode; /// \brief Replace the function represented by this node by another. /// @@ -125,21 +126,23 @@ public: inline const CallGraphNode *operator[](const Function *F) const { const_iterator I = FunctionMap.find(F); assert(I != FunctionMap.end() && "Function not in callgraph!"); - return I->second; + return I->second.get(); } /// \brief Returns the call graph node for the provided function. inline CallGraphNode *operator[](const Function *F) { const_iterator I = FunctionMap.find(F); assert(I != FunctionMap.end() && "Function not in callgraph!"); - return I->second; + return I->second.get(); } /// \brief Returns the \c CallGraphNode which is used to represent /// undetermined calls into the callgraph. CallGraphNode *getExternalCallingNode() const { return ExternalCallingNode; } - CallGraphNode *getCallsExternalNode() const { return CallsExternalNode; } + CallGraphNode *getCallsExternalNode() const { + return CallsExternalNode.get(); + } //===--------------------------------------------------------------------- // Functions to keep a call graph up to date with a function that has been @@ -230,8 +233,9 @@ public: /// \brief Adds a function to the list of functions called by this one. void addCalledFunction(CallSite CS, CallGraphNode *M) { assert(!CS.getInstruction() || !CS.getCalledFunction() || - !CS.getCalledFunction()->isIntrinsic()); - CalledFunctions.push_back(std::make_pair(CS.getInstruction(), M)); + !CS.getCalledFunction()->isIntrinsic() || + !Intrinsic::isLeaf(CS.getCalledFunction()->getIntrinsicID())); + CalledFunctions.emplace_back(CS.getInstruction(), M); M->AddRef(); } @@ -274,8 +278,8 @@ private: /// CalledFunctions array of this or other CallGraphNodes. unsigned NumReferences; - CallGraphNode(const CallGraphNode &) LLVM_DELETED_FUNCTION; - void operator=(const CallGraphNode &) LLVM_DELETED_FUNCTION; + CallGraphNode(const CallGraphNode &) = delete; + void operator=(const CallGraphNode &) = delete; void DropRef() { --NumReferences; } void AddRef() { ++NumReferences; } @@ -284,27 +288,6 @@ private: void allReferencesDropped() { NumReferences = 0; } }; -/// \brief An analysis pass to compute the \c CallGraph for a \c Module. -/// -/// This class implements the concept of an analysis pass used by the \c -/// ModuleAnalysisManager to run an analysis over a module and cache the -/// resulting data. -class CallGraphAnalysis { -public: - /// \brief A formulaic typedef to inform clients of the result type. - typedef CallGraph Result; - - static void *ID() { return (void *)&PassID; } - - /// \brief Compute the \c CallGraph for the module \c M. - /// - /// The real work here is done in the \c CallGraph constructor. - CallGraph run(Module *M) { return CallGraph(*M); } - -private: - static char PassID; -}; - /// \brief The \c ModulePass which wraps up a \c CallGraph and the logic to /// build it. /// @@ -319,7 +302,7 @@ public: static char ID; // Class identification, replacement for typeinfo CallGraphWrapperPass(); - virtual ~CallGraphWrapperPass(); + ~CallGraphWrapperPass() override; /// \brief The internal \c CallGraph around which the rest of this interface /// is wrapped. @@ -418,13 +401,24 @@ template <> struct GraphTraits { template <> struct GraphTraits { typedef const CallGraphNode NodeType; - typedef NodeType::const_iterator ChildIteratorType; + + typedef CallGraphNode::CallRecord CGNPairTy; + typedef std::pointer_to_unary_function + CGNDerefFun; static NodeType *getEntryNode(const CallGraphNode *CGN) { return CGN; } + + typedef mapped_iterator + ChildIteratorType; + static inline ChildIteratorType child_begin(NodeType *N) { - return N->begin(); + return map_iterator(N->begin(), CGNDerefFun(CGNDeref)); + } + static inline ChildIteratorType child_end(NodeType *N) { + return map_iterator(N->end(), CGNDerefFun(CGNDeref)); } - static inline ChildIteratorType child_end(NodeType *N) { return N->end(); } + + static const CallGraphNode *CGNDeref(CGNPairTy P) { return P.second; } }; template <> @@ -432,8 +426,10 @@ struct GraphTraits : public GraphTraits { static NodeType *getEntryNode(CallGraph *CGN) { return CGN->getExternalCallingNode(); // Start at the external node! } - typedef std::pair PairTy; - typedef std::pointer_to_unary_function DerefFun; + typedef std::pair> + PairTy; + typedef std::pointer_to_unary_function + DerefFun; // nodes_iterator/begin/end - Allow iteration over all nodes in the graph typedef mapped_iterator nodes_iterator; @@ -444,24 +440,34 @@ struct GraphTraits : public GraphTraits { return map_iterator(CG->end(), DerefFun(CGdereference)); } - static CallGraphNode &CGdereference(PairTy P) { return *P.second; } + static CallGraphNode &CGdereference(const PairTy &P) { return *P.second; } }; template <> struct GraphTraits : public GraphTraits< const CallGraphNode *> { static NodeType *getEntryNode(const CallGraph *CGN) { - return CGN->getExternalCallingNode(); + return CGN->getExternalCallingNode(); // Start at the external node! } + typedef std::pair> + PairTy; + typedef std::pointer_to_unary_function + DerefFun; + // nodes_iterator/begin/end - Allow iteration over all nodes in the graph - typedef CallGraph::const_iterator nodes_iterator; - static nodes_iterator nodes_begin(const CallGraph *CG) { return CG->begin(); } - static nodes_iterator nodes_end(const CallGraph *CG) { return CG->end(); } + typedef mapped_iterator nodes_iterator; + static nodes_iterator nodes_begin(const CallGraph *CG) { + return map_iterator(CG->begin(), DerefFun(CGdereference)); + } + static nodes_iterator nodes_end(const CallGraph *CG) { + return map_iterator(CG->end(), DerefFun(CGdereference)); + } + + static const CallGraphNode &CGdereference(const PairTy &P) { + return *P.second; + } }; } // End llvm namespace -// Make sure that any clients of this file link in CallGraph.cpp -FORCE_DEFINING_FILE_TO_BE_LINKED(CallGraph) - #endif