svf-lib 1.0.2205 → 1.0.2207

package/SVF-linux/Release-build/include/Graphs/SCC.h

@@ -130,12 +130,17 @@ public:
         return _T;
     }
 
+    inline const GNodeStack& topoNodeStack() const
+    {
+        return _T;
+    }
+
     /// Return a handle to the stack of nodes in reverse topological
     /// order. This will be used to seed the initial solution
     /// and improve efficiency.
-    inline GNodeStack revTopoNodeStack()
+    inline FIFOWorkList<NodeID> revTopoNodeStack() const
     {
-        GNodeStack revTopoOrder;
+        FIFOWorkList<NodeID> revTopoOrder;
         GNodeStack topoOrder = topoNodeStack();
         while(!topoOrder.empty())
         {

package/SVF-linux/Release-build/include/MSSA/MemRegion.h

@@ -268,8 +268,6 @@ private:
     /// Get all the objects in callee's modref escaped via global objects (the chain pts of globals)
     void getEscapObjviaGlobals(NodeBS& globs, const NodeBS& pts);
 
-    /// Get reverse topo call graph scc
-    void getCallGraphSCCRevTopoOrder(WorkList& worklist);
 
 protected:
     MRGenerator(BVDataPTAImpl* p, bool ptrOnly);

package/SVF-linux/Release-build/include/WPA/WPAFSSolver.h

@@ -73,10 +73,10 @@ protected:
 
         /// Both rep and sub nodes need to be processed later.
         /// Collect sub nodes from SCCDetector.
-        NodeStack revTopoStack = this->getSCCDetector()->revTopoNodeStack();
+        FIFOWorkList<NodeID> revTopoStack = this->getSCCDetector()->revTopoNodeStack();
         while (!revTopoStack.empty())
         {
-            NodeID nodeId = revTopoStack.top();
+            NodeID nodeId = revTopoStack.front();
             revTopoStack.pop();
             const NodeBS& subNodes = this->getSCCDetector()->subNodes(nodeId);
             for (NodeBS::iterator it = subNodes.begin(), eit = subNodes.end(); it != eit; ++it)

package/SVF-osx/Release-build/include/AE/Svfexe/AbstractInterpretation.h

@@ -251,8 +251,8 @@ private:
     AEStat* stat;
 
     std::vector<const CallICFGNode*> callSiteStack;
-    Map<const CallGraphNode*, ICFGWTO*> funcToWTO;
-    Set<const CallGraphNode*> recursiveFuns;
+    Map<const SVFFunction*, ICFGWTO*> funcToWTO;
+    Set<const SVFFunction*> recursiveFuns;
 
 
     AbstractState& getAbsStateFromTrace(const ICFGNode* node)

package/SVF-osx/Release-build/include/Graphs/PTACallGraph.h

@@ -302,7 +302,7 @@ public:
     PTACallGraph(CGEK k = NormCallGraph);
 
     /// Copy constructor
-    PTACallGraph(const CallGraph& other);
+    PTACallGraph(const PTACallGraph& other);
 
     /// Destructor
     virtual ~PTACallGraph()
@@ -351,8 +351,16 @@ public:
     /// Issue a warning if the function which has indirect call sites can not be reached from program entry.
     void verifyCallGraph();
 
+    /// Add direct call edges
+    void addDirectCallGraphEdge(const CallICFGNode* call, const SVFFunction* callerFun, const SVFFunction* calleeFun);
+
+    void addCallGraphNode(const SVFFunction* fun);
+
     /// Get call graph node
     //@{
+
+    const PTACallGraphNode* getCallGraphNode(const std::string& name);
+
     inline PTACallGraphNode* getCallGraphNode(NodeID id) const
     {
         return getGNode(id);

package/SVF-osx/Release-build/include/Graphs/ThreadCallGraph.h

@@ -172,7 +172,7 @@ public:
     typedef Map<const CallICFGNode*, ParForEdgeSet> CallInstToParForEdgesMap;
 
     /// Constructor
-    ThreadCallGraph(const CallGraph& cg);
+    ThreadCallGraph(const PTACallGraph& cg);
 
     ThreadCallGraph(ThreadCallGraph& cg) = delete;
 

package/SVF-osx/Release-build/include/SVF-LLVM/LLVMModule.h

@@ -55,7 +55,6 @@ public:
     typedef Map<const GlobalVariable*, GlobalVariable*> GlobalDefToRepMapTy;
 
     typedef Map<const Function*, SVFFunction*> LLVMFun2SVFFunMap;
-    typedef Map<const Function*, CallGraphNode*> LLVMFun2CallGraphNodeMap;
     typedef Map<const BasicBlock*, SVFBasicBlock*> LLVMBB2SVFBBMap;
     typedef Map<const Instruction*, SVFInstruction*> LLVMInst2SVFInstMap;
     typedef Map<const Argument*, SVFArgument*> LLVMArgument2SVFArgumentMap;
@@ -95,7 +94,6 @@ private:
     GlobalDefToRepMapTy GlobalDefToRepMap;
 
     LLVMFun2SVFFunMap LLVMFunc2SVFFunc; ///< Map an LLVM Function to an SVF Function
-    LLVMFun2CallGraphNodeMap LLVMFunc2CallGraphNode; ///< Map an LLVM Function to an CallGraph Node
     LLVMBB2SVFBBMap LLVMBB2SVFBB;
     LLVMInst2SVFInstMap LLVMInst2SVFInst;
     LLVMArgument2SVFArgumentMap LLVMArgument2SVFArgument;
@@ -112,7 +110,7 @@ private:
     InstToBlockNodeMapTy InstToBlockNodeMap; ///< map a basic block to its ICFGNode
     FunToFunEntryNodeMapTy FunToFunEntryNodeMap; ///< map a function to its FunExitICFGNode
     FunToFunExitNodeMapTy FunToFunExitNodeMap; ///< map a function to its FunEntryICFGNode
-    CallGraph* callgraph;
+    PTACallGraph* callgraph;
 
     Map<const Function*, DominatorTree> FunToDominatorTree;
 
@@ -218,8 +216,6 @@ public:
         setValueAttr(func,svfFunc);
     }
 
-    void addFunctionMap(const Function* func, CallGraphNode* svfFunc);
-
     // create a SVFBasicBlock according to LLVM BasicBlock, then add it to SVFFunction's BasicBlockGraph
     inline void addBasicBlock(SVFFunction* fun, const BasicBlock* bb)
     {
@@ -296,13 +292,6 @@ public:
         return it->second;
     }
 
-    inline CallGraphNode* getCallGraphNode(const Function* fun) const
-    {
-        LLVMFun2CallGraphNodeMap::const_iterator it = LLVMFunc2CallGraphNode.find(fun);
-        assert(it!=LLVMFunc2CallGraphNode.end() && "SVF Function not found!");
-        return it->second;
-    }
-
     inline SVFFunction* getSVFFunction(const Function* fun) const
     {
         LLVMFun2SVFFunMap::const_iterator it = LLVMFunc2SVFFunc.find(fun);

package/SVF-osx/Release-build/include/SVFIR/SVFIR.h

@@ -35,7 +35,6 @@
 namespace SVF
 {
 class CommonCHGraph;
-class CallGraph;
 /*!
  * SVF Intermediate representation, representing variables and statements as a Program Assignment Graph (PAG)
  * Variables as nodes and statements as edges.
@@ -62,7 +61,7 @@ public:
     typedef Map<const CallICFGNode*,SVFVarList> CSToArgsListMap;
     typedef Map<const RetICFGNode*,const SVFVar*> CSToRetMap;
     typedef Map<const SVFFunction*,const SVFVar*> FunToRetMap;
-    typedef Map<const CallGraphNode*,const FunObjVar *> FunToFunObjVarMap;
+    typedef Map<const SVFFunction*,const FunObjVar *> FunToFunObjVarMap;
     typedef Map<const SVFFunction*,SVFStmtSet> FunToPAGEdgeSetMap;
     typedef Map<const ICFGNode*,SVFStmtList> ICFGNode2SVFStmtsMap;
     typedef Map<NodeID, NodeID> NodeToNodeMap;
@@ -100,7 +99,7 @@ private:
     ICFG* icfg; // ICFG
     CommonCHGraph* chgraph; // class hierarchy graph
     CallSiteSet callSiteSet; /// all the callsites of a program
-    CallGraph* callGraph; /// call graph
+    PTACallGraph* callGraph; /// call graph
 
     static std::unique_ptr<SVFIR> pag;	///< Singleton pattern here to enable instance of SVFIR can only be created once.
 
@@ -187,11 +186,11 @@ public:
     }
 
     /// Set/Get CG
-    inline void setCallGraph(CallGraph* c)
+    inline void setCallGraph(PTACallGraph* c)
     {
         callGraph = c;
     }
-    inline CallGraph* getCallGraph()
+    inline PTACallGraph* getCallGraph()
     {
         assert(callGraph && "empty CallGraph! Build SVF IR first!");
         return callGraph;
@@ -331,7 +330,7 @@ public:
     }
     //@}
 
-    inline const FunObjVar* getFunObjVar(const CallGraphNode*  node) const
+    inline const FunObjVar* getFunObjVar(const SVFFunction*  node) const
     {
         FunToFunObjVarMap::const_iterator it = funToFunObjvarMap.find(node);
         assert(it != funToFunObjvarMap.end() && "this function doesn't have funobjvar");
@@ -547,13 +546,13 @@ private:
         return addValNode(node);
     }
 
-    NodeID addFunValNode(NodeID i, const ICFGNode* icfgNode, const CallGraphNode* callGraphNode, const SVFType* type)
+    NodeID addFunValNode(NodeID i, const ICFGNode* icfgNode, const SVFFunction* callGraphNode, const SVFType* type)
     {
         FunValVar* node = new FunValVar(i, icfgNode, callGraphNode, type);
         return addValNode(node);
     }
 
-    NodeID addArgValNode(NodeID i, u32_t argNo, const ICFGNode* icfgNode, const CallGraphNode* callGraphNode, const SVFType* type)
+    NodeID addArgValNode(NodeID i, u32_t argNo, const ICFGNode* icfgNode, const SVFFunction* callGraphNode, const SVFType* type)
     {
         ArgValVar* node =
             new ArgValVar(i, argNo, icfgNode, callGraphNode, type);
@@ -625,7 +624,7 @@ private:
         return addObjNode(stackObj);
     }
 
-    NodeID addFunObjNode(NodeID id,  ObjTypeInfo* ti, const CallGraphNode* callGraphNode, const SVFType* type, const ICFGNode* node)
+    NodeID addFunObjNode(NodeID id,  ObjTypeInfo* ti, const SVFFunction* callGraphNode, const SVFType* type, const ICFGNode* node)
     {
         memToFieldsMap[id].set(id);
         FunObjVar* funObj = new FunObjVar(id, ti, callGraphNode, type, node);
@@ -678,13 +677,13 @@ private:
     }
 
     /// Add a unique return node for a procedure
-    inline NodeID addRetNode(NodeID i, const CallGraphNode* callGraphNode, const SVFType* type, const ICFGNode* icn)
+    inline NodeID addRetNode(NodeID i, const SVFFunction* callGraphNode, const SVFType* type, const ICFGNode* icn)
     {
         SVFVar *node = new RetValPN(i, callGraphNode, type, icn);
         return addRetNode(callGraphNode, node);
     }
     /// Add a unique vararg node for a procedure
-    inline NodeID addVarargNode(NodeID i, const CallGraphNode* val, const SVFType* type, const ICFGNode* n)
+    inline NodeID addVarargNode(NodeID i, const SVFFunction* val, const SVFType* type, const ICFGNode* n)
     {
         SVFVar *node = new VarArgValPN(i, val, type, n);
         return addNode(node);
@@ -758,7 +757,7 @@ private:
         return addNode(node);
     }
     /// Add a unique return node for a procedure
-    inline NodeID addRetNode(const CallGraphNode*, SVFVar *node)
+    inline NodeID addRetNode(const SVFFunction*, SVFVar *node)
     {
         return addNode(node);
     }

package/SVF-osx/Release-build/include/SVFIR/SVFValue.h

@@ -320,14 +320,9 @@ private:
     const SVFFunction* realDefFun;  /// the definition of a function across multiple modules
     std::vector<const ArgValVar*> allArgs;    /// all formal arguments of this function
     SVFBasicBlock *exitBlock;             /// a 'single' basic block having no successors and containing return instruction in a function
-    const CallGraphNode *callGraphNode;          /// call graph node for this function
     BasicBlockGraph* bbGraph; /// the basic block graph of this function
 
 protected:
-    inline void setCallGraphNode(CallGraphNode *cgn)
-    {
-        callGraphNode = cgn;
-    }
 
     inline void addArgument(const ArgValVar* arg)
     {
@@ -355,11 +350,6 @@ public:
     SVFFunction(void) = delete;
     virtual ~SVFFunction();
 
-    inline const CallGraphNode* getCallGraphNode() const
-    {
-        return callGraphNode;
-    }
-
     static inline bool classof(const SVFValue *node)
     {
         return node->getKind() == SVFFunc;

package/SVF-osx/Release-build/include/SVFIR/SVFVariables.h

@@ -366,7 +366,7 @@ class ArgValVar: public ValVar
     friend class SVFIRReader;
 
 private:
-    const CallGraphNode* cgNode;
+    const SVFFunction* cgNode;
     u32_t argNo;
 
 protected:
@@ -399,7 +399,7 @@ public:
     //@}
 
     /// Constructor
-    ArgValVar(NodeID i, u32_t argNo, const ICFGNode* icn, const CallGraphNode* callGraphNode,
+    ArgValVar(NodeID i, u32_t argNo, const ICFGNode* icn, const SVFFunction* callGraphNode,
               const SVFType* svfType);
 
     /// Return name of a LLVM value
@@ -968,7 +968,7 @@ class FunValVar : public ValVar
     friend class SVFIRWriter;
     friend class SVFIRReader;
 private:
-    const CallGraphNode* callGraphNode;
+    const SVFFunction* callGraphNode;
 
 public:
     ///  Methods for support type inquiry through isa, cast, and dyn_cast:
@@ -995,13 +995,13 @@ public:
     }
     //@}
 
-    inline const CallGraphNode* getCallGraphNode() const
+    inline virtual const SVFFunction* getFunction() const
     {
         return callGraphNode;
     }
 
     /// Constructor
-    FunValVar(NodeID i, const ICFGNode* icn, const CallGraphNode* cgn, const SVFType* svfType);
+    FunValVar(NodeID i, const ICFGNode* icn, const SVFFunction* cgn, const SVFType* svfType);
 
 
     virtual bool isPointer() const
@@ -1018,7 +1018,7 @@ class FunObjVar : public BaseObjVar
     friend class SVFIRReader;
 
 private:
-    const CallGraphNode* callGraphNode;
+    const SVFFunction* callGraphNode;
 
 private:
     /// Constructor to create empty ObjVar (for SVFIRReader/deserialization)
@@ -1054,9 +1054,9 @@ public:
     //@}
 
     /// Constructor
-    FunObjVar(NodeID i, ObjTypeInfo* ti, const CallGraphNode* cgNode, const SVFType* svfType, const ICFGNode* node);
+    FunObjVar(NodeID i, ObjTypeInfo* ti, const SVFFunction* cgNode, const SVFType* svfType, const ICFGNode* node);
 
-    inline const CallGraphNode* getCallGraphNode() const
+    inline const SVFFunction* getCallGraphNode() const
     {
         return callGraphNode;
     }
@@ -1782,7 +1782,7 @@ class RetValPN : public ValVar
     friend class SVFIRReader;
 
 private:
-    const CallGraphNode* callGraphNode;
+    const SVFFunction* callGraphNode;
 private:
     /// Constructor to create empty RetValPN (for SVFIRReader/deserialization)
     RetValPN(NodeID i) : ValVar(i, RetValNode) {}
@@ -1813,9 +1813,9 @@ public:
 
 
     /// Constructor
-    RetValPN(NodeID i, const CallGraphNode* node, const SVFType* svfType, const ICFGNode* icn);
+    RetValPN(NodeID i, const SVFFunction* node, const SVFType* svfType, const ICFGNode* icn);
 
-    inline const CallGraphNode* getCallGraphNode() const
+    inline const SVFFunction* getCallGraphNode() const
     {
         return callGraphNode;
     }
@@ -1838,7 +1838,7 @@ class VarArgValPN : public ValVar
     friend class SVFIRWriter;
     friend class SVFIRReader;
 private:
-    const CallGraphNode* callGraphNode;
+    const SVFFunction* callGraphNode;
 
 private:
     /// Constructor to create empty VarArgValPN (for SVFIRReader/deserialization)
@@ -1869,7 +1869,7 @@ public:
     //@}
 
     /// Constructor
-    VarArgValPN(NodeID i, const CallGraphNode* node, const SVFType* svfType, const ICFGNode* icn)
+    VarArgValPN(NodeID i, const SVFFunction* node, const SVFType* svfType, const ICFGNode* icn)
         : ValVar(i, svfType, icn, VarargValNode), callGraphNode(node)
     {
     }

package/SVF-osx/Release-build/include/Util/CallGraphBuilder.h

@@ -47,7 +47,7 @@ public:
     CallGraphBuilder()=default;
 
     /// Buidl SVFIR callgraoh
-    CallGraph* buildSVFIRCallGraph(SVFModule* svfModule);
+    PTACallGraph* buildSVFIRCallGraph(SVFModule* svfModule);
 
     /// Buidl PTA callgraoh
     PTACallGraph* buildPTACallGraph();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-lib",
-  "version": "1.0.2205",
+  "version": "1.0.2207",
   "description": "SVF's npm support",
   "main": "index.js",
   "scripts": {

package/SVF-osx/Release-build/include/Graphs/CallGraph.h

@@ -1,266 +0,0 @@
-//===- CallGraph.h -- Call graph representation----------------------------//
-//
-//                     SVF: Static Value-Flow Analysis
-//
-// Copyright (C) <2013-2017>  <Yulei Sui>
-//
-
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-//===----------------------------------------------------------------------===//
-
-/*
- * CallGraph.h
- *
- *  Created on: Nov 7, 2013
- *      Author: Yulei Sui
- */
-
-#ifndef CALLGRAPH_H_
-#define CALLGRAPH_H_
-
-#include "Graphs/GenericGraph.h"
-#include "SVFIR/SVFValue.h"
-#include "Graphs/ICFG.h"
-#include <set>
-
-namespace SVF
-{
-
-class CallGraphNode;
-class SVFModule;
-
-
-/*
- * Call Graph edge representing a calling relation between two functions
- * Multiple calls from function A to B are merged into one call edge
- * Each call edge has a set of direct callsites and a set of indirect callsites
- */
-typedef GenericEdge<CallGraphNode> GenericCallGraphEdgeTy;
-class CallGraphEdge : public GenericCallGraphEdgeTy
-{
-
-public:
-    typedef Set<const CallICFGNode*> CallInstSet;
-
-private:
-    CallInstSet directCalls;
-public:
-    /// Constructor
-    CallGraphEdge(CallGraphNode* s, CallGraphNode* d, const CallICFGNode* icfgNode) :
-        GenericCallGraphEdgeTy(s, d, icfgNode->getId())
-    {
-    }
-    /// Destructor
-    virtual ~CallGraphEdge()
-    {
-    }
-
-    /// Add direct callsite
-    //@{
-    void addDirectCallSite(const CallICFGNode* call);
-    //@}
-
-    /// Iterators for direct and indirect callsites
-    //@{
-    inline CallInstSet::const_iterator directCallsBegin() const
-    {
-        return directCalls.begin();
-    }
-    inline CallInstSet::const_iterator directCallsEnd() const
-    {
-        return directCalls.end();
-    }
-    //@}
-
-    /// ClassOf
-    //@{
-    static inline bool classof(const CallGraphEdge*)
-    {
-        return true;
-    }
-    //@}
-
-    /// Overloading operator << for dumping ICFG node ID
-    //@{
-    friend OutStream& operator<< (OutStream &o, const CallGraphEdge&edge)
-    {
-        o << edge.toString();
-        return o;
-    }
-    //@}
-
-    virtual const std::string toString() const;
-
-    typedef GenericNode<CallGraphNode, CallGraphEdge>::GEdgeSetTy CallGraphEdgeSet;
-
-};
-
-/*
- * Call Graph node representing a function
- */
-typedef GenericNode<CallGraphNode, CallGraphEdge> GenericCallGraphNodeTy;
-class CallGraphNode : public GenericCallGraphNodeTy
-{
-private:
-    const SVFFunction* fun;
-
-public:
-    /// Constructor
-    CallGraphNode(NodeID i, const SVFFunction* f) : GenericCallGraphNodeTy(i,CallNodeKd), fun(f)
-    {
-    }
-
-    inline const std::string &getName() const
-    {
-        return fun->getName();
-    }
-
-    /// Get function of this call node
-    inline const SVFFunction* getFunction() const
-    {
-        return fun;
-    }
-
-
-    /// Overloading operator << for dumping ICFG node ID
-    //@{
-    friend OutStream& operator<< (OutStream &o, const CallGraphNode&node)
-    {
-        o << node.toString();
-        return o;
-    }
-    //@}
-
-    virtual const std::string toString() const;
-
-    /// Methods for support type inquiry through isa, cast, and dyn_cast:
-    //@{
-    static inline bool classof(const CallGraphNode*)
-    {
-        return true;
-    }
-
-    static inline bool classof(const GenericICFGNodeTy* node)
-    {
-        return node->getNodeKind() == CallNodeKd;
-    }
-
-    static inline bool classof(const SVFBaseNode* node)
-    {
-        return node->getNodeKind() == CallNodeKd;
-    }
-    //@}
-};
-
-/*!
- * Pointer Analysis Call Graph used internally for various pointer analysis
- */
-typedef GenericGraph<CallGraphNode, CallGraphEdge> GenericCallGraphTy;
-class CallGraph : public GenericCallGraphTy
-{
-    friend class PTACallGraph;
-
-public:
-    typedef CallGraphEdge::CallGraphEdgeSet CallGraphEdgeSet;
-    typedef Map<const SVFFunction*, CallGraphNode*> FunToCallGraphNodeMap;
-    typedef Map<const CallICFGNode*, CallGraphEdgeSet> CallInstToCallGraphEdgesMap;
-    typedef Set<const SVFFunction*> FunctionSet;
-    typedef OrderedMap<const CallICFGNode*, FunctionSet> CallEdgeMap;
-
-protected:
-    FunToCallGraphNodeMap funToCallGraphNodeMap; ///< Call Graph node map
-    CallInstToCallGraphEdgesMap callinstToCallGraphEdgesMap; ///< Map a call instruction to its corresponding call edges
-
-    NodeID callGraphNodeNum;
-
-    /// Clean up memory
-    void destroy();
-
-    /// Add call graph edge
-    inline void addEdge(CallGraphEdge* edge)
-    {
-        edge->getDstNode()->addIncomingEdge(edge);
-        edge->getSrcNode()->addOutgoingEdge(edge);
-    }
-
-
-public:
-    /// Constructor
-    CallGraph();
-
-    void addCallGraphNode(const SVFFunction* fun);
-
-    const CallGraphNode* getCallGraphNode(const std::string& name);
-
-    /// Destructor
-    virtual ~CallGraph()
-    {
-        destroy();
-    }
-
-    /// Get call graph node
-    //@{
-    inline CallGraphNode* getCallGraphNode(NodeID id) const
-    {
-        return getGNode(id);
-    }
-    inline CallGraphNode* getCallGraphNode(const SVFFunction* fun) const
-    {
-        FunToCallGraphNodeMap::const_iterator it = funToCallGraphNodeMap.find(fun);
-        assert(it!=funToCallGraphNodeMap.end() && "call graph node not found!!");
-        return it->second;
-    }
-
-    //@}
-
-    /// Whether we have already created this call graph edge
-    CallGraphEdge* hasGraphEdge(CallGraphNode* src, CallGraphNode* dst,
-                                const CallICFGNode* callIcfgNode) const;
-
-    /// Add direct call edges
-    void addDirectCallGraphEdge(const CallICFGNode* call, const SVFFunction* callerFun, const SVFFunction* calleeFun);
-    /// Dump the graph
-    void dump(const std::string& filename);
-
-    /// View the graph from the debugger
-    void view();
-};
-
-} // End namespace SVF
-
-namespace SVF
-{
-/* !
- * GenericGraphTraits specializations for generic graph algorithms.
- * Provide graph traits for traversing from a constraint node using standard graph traversals.
- */
-template<> struct GenericGraphTraits<SVF::CallGraphNode*> : public GenericGraphTraits<SVF::GenericNode<SVF::CallGraphNode,SVF::CallGraphEdge>*  >
-{
-};
-
-/// Inverse GenericGraphTraits specializations for call graph node, it is used for inverse traversal.
-template<>
-struct GenericGraphTraits<Inverse<SVF::CallGraphNode*> > : public GenericGraphTraits<Inverse<SVF::GenericNode<SVF::CallGraphNode,SVF::CallGraphEdge>* > >
-{
-};
-
-template<> struct GenericGraphTraits<SVF::CallGraph*> : public GenericGraphTraits<SVF::GenericGraph<SVF::CallGraphNode,SVF::CallGraphEdge>* >
-{
-    typedef SVF::CallGraphNode*NodeRef;
-};
-
-} // End namespace llvm
-
-#endif /* CALLGRAPH_H_ */