svf-tools 1.0.1005 → 1.0.1006

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.1005",
+  "version": "1.0.1006",
   "description": "* <b>[TypeClone](https://github.com/SVF-tools/SVF/wiki/TypeClone) published in our [ECOOP paper](https://yuleisui.github.io/publications/ecoop20.pdf) is now available in SVF </b> * <b>SVF now uses a single script for its build. Just type [`source ./build.sh`](https://github.com/SVF-tools/SVF/blob/master/build.sh) in your terminal, that's it!</b> * <b>SVF now supports LLVM-10.0.0! </b> * <b>We thank [bsauce](https://github.com/bsauce) for writing a user manual of SVF ([link1](https://www.jianshu.com/p/068a08ec749c) and [link2](https://www.jianshu.com/p/777c30d4240e)) in Chinese </b> * <b>SVF now supports LLVM-9.0.0 (Thank [Byoungyoung Lee](https://github.com/SVF-tools/SVF/issues/142) for his help!). </b> * <b>SVF now supports a set of [field-sensitive pointer analyses](https://yuleisui.github.io/publications/sas2019a.pdf). </b> * <b>[Use SVF as an external lib](https://github.com/SVF-tools/SVF/wiki/Using-SVF-as-a-lib-in-your-own-tool) for your own project (Contributed by [Hongxu Chen](https://github.com/HongxuChen)). </b> * <b>SVF now supports LLVM-7.0.0. </b> * <b>SVF now supports Docker. [Try SVF in Docker](https://github.com/SVF-tools/SVF/wiki/Try-SVF-in-Docker)! </b> * <b>SVF now supports [LLVM-6.0.0](https://github.com/svf-tools/SVF/pull/38) (Contributed by [Jack Anthony](https://github.com/jackanth)). </b> * <b>SVF now supports [LLVM-4.0.0](https://github.com/svf-tools/SVF/pull/23) (Contributed by Jared Carlson. Thank [Jared](https://github.com/jcarlson23) and [Will](https://github.com/dtzWill) for their in-depth [discussions](https://github.com/svf-tools/SVF/pull/18) about updating SVF!) </b> * <b>SVF now supports analysis for C++ programs.</b> <br />",
   "main": "index.js",
   "scripts": {

package/svf/include/Graphs/CallGraph.h

@@ -0,0 +1,264 @@
+//===- 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);
+
+    /// 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_ */

package/svf/include/Graphs/PTACallGraph.h

@@ -40,6 +40,7 @@ namespace SVF
 
 class PTACallGraphNode;
 class SVFModule;
+class CallGraph;
 
 
 /*
@@ -47,8 +48,8 @@ class SVFModule;
  * 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<PTACallGraphNode> GenericCallGraphEdgeTy;
-class PTACallGraphEdge : public GenericCallGraphEdgeTy
+typedef GenericEdge<PTACallGraphNode> GenericPTACallGraphEdgeTy;
+class PTACallGraphEdge : public GenericPTACallGraphEdgeTy
 {
 
 public:
@@ -66,7 +67,7 @@ private:
 public:
     /// Constructor
     PTACallGraphEdge(PTACallGraphNode* s, PTACallGraphNode* d, CEDGEK kind, CallSiteID cs) :
-        GenericCallGraphEdgeTy(s, d, makeEdgeFlagWithInvokeID(kind, cs)), csId(cs)
+        GenericPTACallGraphEdgeTy(s, d, makeEdgeFlagWithInvokeID(kind, cs)), csId(cs)
     {
     }
     /// Destructor
@@ -144,7 +145,7 @@ public:
     {
         return true;
     }
-    static inline bool classof(const GenericCallGraphEdgeTy *edge)
+    static inline bool classof(const GenericPTACallGraphEdgeTy *edge)
     {
         return edge->getEdgeKind() == PTACallGraphEdge::CallRetEdge ||
                edge->getEdgeKind() == PTACallGraphEdge::TDForkEdge ||
@@ -170,21 +171,15 @@ public:
 /*
  * Call Graph node representing a function
  */
-typedef GenericNode<PTACallGraphNode, PTACallGraphEdge> GenericCallGraphNodeTy;
-class PTACallGraphNode : public GenericCallGraphNodeTy
+typedef GenericNode<PTACallGraphNode, PTACallGraphEdge> GenericPTACallGraphNodeTy;
+class PTACallGraphNode : public GenericPTACallGraphNodeTy
 {
-
-public:
-    typedef PTACallGraphEdge::CallGraphEdgeSet CallGraphEdgeSet;
-    typedef PTACallGraphEdge::CallGraphEdgeSet::iterator iterator;
-    typedef PTACallGraphEdge::CallGraphEdgeSet::const_iterator const_iterator;
-
 private:
     const SVFFunction* fun;
 
 public:
     /// Constructor
-    PTACallGraphNode(NodeID i, const SVFFunction* f) : GenericCallGraphNodeTy(i,CallNodeKd), fun(f)
+    PTACallGraphNode(NodeID i, const SVFFunction* f) : GenericPTACallGraphNodeTy(i,CallNodeKd), fun(f)
     {
 
     }
@@ -237,8 +232,8 @@ public:
 /*!
  * Pointer Analysis Call Graph used internally for various pointer analysis
  */
-typedef GenericGraph<PTACallGraphNode, PTACallGraphEdge> GenericCallGraphTy;
-class PTACallGraph : public GenericCallGraphTy
+typedef GenericGraph<PTACallGraphNode, PTACallGraphEdge> GenericPTACallGraphTy;
+class PTACallGraph : public GenericPTACallGraphTy
 {
 
 public:
@@ -278,14 +273,36 @@ protected:
     /// Clean up memory
     void destroy();
 
+protected:
+    /// Add CallSiteID
+    inline CallSiteID addCallSite(const CallICFGNode* cs, const SVFFunction* callee)
+    {
+        std::pair<const CallICFGNode*, const SVFFunction*> newCS(std::make_pair(cs, callee));
+        CallSiteToIdMap::const_iterator it = csToIdMap.find(newCS);
+        //assert(it == csToIdMap.end() && "cannot add a callsite twice");
+        if(it == csToIdMap.end())
+        {
+            CallSiteID id = totalCallSiteNum++;
+            csToIdMap.insert(std::make_pair(newCS, id));
+            idToCSMap.insert(std::make_pair(id, newCS));
+            return id;
+        }
+        return it->second;
+    }
+
+    /// Add call graph edge
+    inline void addEdge(PTACallGraphEdge* edge)
+    {
+        edge->getDstNode()->addIncomingEdge(edge);
+        edge->getSrcNode()->addOutgoingEdge(edge);
+    }
+
 public:
     /// Constructor
     PTACallGraph(CGEK k = NormCallGraph);
 
     /// Copy constructor
-    PTACallGraph(const PTACallGraph& other);
-
-    void addCallGraphNode(const SVFFunction* fun);
+    PTACallGraph(const CallGraph& other);
 
     /// Destructor
     virtual ~PTACallGraph()
@@ -349,22 +366,8 @@ public:
 
     //@}
 
-    /// Add/Get CallSiteID
+    /// Get CallSiteID
     //@{
-    inline CallSiteID addCallSite(const CallICFGNode* cs, const SVFFunction* callee)
-    {
-        std::pair<const CallICFGNode*, const SVFFunction*> newCS(std::make_pair(cs, callee));
-        CallSiteToIdMap::const_iterator it = csToIdMap.find(newCS);
-        //assert(it == csToIdMap.end() && "cannot add a callsite twice");
-        if(it == csToIdMap.end())
-        {
-            CallSiteID id = totalCallSiteNum++;
-            csToIdMap.insert(std::make_pair(newCS, id));
-            idToCSMap.insert(std::make_pair(id, newCS));
-            return id;
-        }
-        return it->second;
-    }
     inline CallSiteID getCallSiteID(const CallICFGNode* cs, const SVFFunction* callee) const
     {
         CallSitePair newCS(std::make_pair(cs, callee));
@@ -439,16 +442,10 @@ public:
         return it->second.end();
     }
     //@}
-    /// Add call graph edge
-    inline void addEdge(PTACallGraphEdge* edge)
-    {
-        edge->getDstNode()->addIncomingEdge(edge);
-        edge->getSrcNode()->addOutgoingEdge(edge);
-    }
 
-    /// Add direct/indirect call edges
+
+    /// Add indirect call edges
     //@{
-    void addDirectCallGraphEdge(const CallICFGNode* call, const SVFFunction* callerFun, const SVFFunction* calleeFun);
     void addIndirectCallGraphEdge(const CallICFGNode* cs,const SVFFunction* callerFun, const SVFFunction* calleeFun);
     //@}
 
@@ -494,4 +491,4 @@ template<> struct GenericGraphTraits<SVF::PTACallGraph*> : public GenericGraphTr
 
 } // End namespace llvm
 
-#endif /* CALLGRAPH_H_ */
+#endif /* PTACALLGRAPH_H_ */

package/svf/include/Graphs/ThreadCallGraph.h

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

package/svf/include/SVFIR/SVFIR.h

@@ -35,6 +35,7 @@
 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.
@@ -98,7 +99,7 @@ private:
     ICFG* icfg; // ICFG
     CommonCHGraph* chgraph; // class hierarchy graph
     CallSiteSet callSiteSet; /// all the callsites of a program
-    PTACallGraph* callGraph; /// call graph
+    CallGraph* callGraph; /// call graph
 
     static std::unique_ptr<SVFIR> pag;	///< Singleton pattern here to enable instance of SVFIR can only be created once.
 
@@ -185,13 +186,13 @@ public:
     }
 
     /// Set/Get CG
-    inline void setCallGraph(PTACallGraph* c)
+    inline void setCallGraph(CallGraph* c)
     {
         callGraph = c;
     }
-    inline PTACallGraph* getCallGraph()
+    inline CallGraph* getCallGraph()
     {
-        assert(callGraph && "empty PTACallGraph! Build SVF IR first!");
+        assert(callGraph && "empty CallGraph! Build SVF IR first!");
         return callGraph;
     }
 

package/svf/include/Util/CallGraphBuilder.h

@@ -31,7 +31,6 @@
 #ifndef INCLUDE_SVF_FE_CALLGRAPHBUILDER_H_
 #define INCLUDE_SVF_FE_CALLGRAPHBUILDER_H_
 
-#include "Graphs/PTACallGraph.h"
 #include "Graphs/ThreadCallGraph.h"
 
 namespace SVF
@@ -39,6 +38,8 @@ namespace SVF
 
 class ICFG;
 class SVFModule;
+class CallGraph;
+class ThreadCallGraph;
 
 class CallGraphBuilder
 {
@@ -46,7 +47,10 @@ public:
     CallGraphBuilder()=default;
 
     /// Buidl SVFIR callgraoh
-    PTACallGraph* buildSVFIRCallGraph(SVFModule* svfModule);
+    CallGraph* buildSVFIRCallGraph(SVFModule* svfModule);
+
+    /// Buidl PTA callgraoh
+    PTACallGraph* buildPTACallGraph();
 
     /// Build thread-aware callgraph
     ThreadCallGraph* buildThreadCallGraph();

package/svf/lib/Graphs/CallGraph.cpp

@@ -0,0 +1,211 @@
+//===- CallGraph.cpp -- Call graph used internally in SVF------------------//
+//
+//                     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.cpp
+ *
+ *  Created on: Nov 7, 2013
+ *      Author: Yulei Sui
+ */
+
+#include "Graphs/CallGraph.h"
+#include "SVFIR/SVFIR.h"
+#include "SVFIR/SVFModule.h"
+#include "Util/SVFUtil.h"
+#include <sstream>
+
+using namespace SVF;
+using namespace SVFUtil;
+
+
+/// Add direct callsite
+//@{
+void CallGraphEdge::addDirectCallSite(const CallICFGNode* call)
+{
+    assert(call->getCalledFunction() && "not a direct callsite??");
+    directCalls.insert(call);
+}
+//@}
+
+const std::string CallGraphEdge::toString() const
+{
+    std::string str;
+    std::stringstream  rawstr(str);
+    rawstr << "CallICFGNode ID: " << getEdgeKindWithoutMask();
+    rawstr << "direct call";
+    rawstr << "[" << getDstID() << "<--" << getSrcID() << "]\t";
+    return rawstr.str();
+}
+
+const std::string CallGraphNode::toString() const
+{
+    std::string str;
+    std::stringstream  rawstr(str);
+    rawstr << "CallGraphNode ID: " << getId() << " {fun: " << fun->getName() << "}";
+    return rawstr.str();
+}
+
+
+/// Constructor
+CallGraph::CallGraph()
+{
+    callGraphNodeNum = 0;
+}
+
+
+/*!
+ *  Memory has been cleaned up at GenericGraph
+ */
+void CallGraph::destroy()
+{
+}
+
+/*!
+ * Add call graph node
+ */
+void CallGraph::addCallGraphNode(const SVFFunction* fun)
+{
+    NodeID id  = callGraphNodeNum;
+    CallGraphNode*callGraphNode = new CallGraphNode(id, fun);
+    addGNode(id, callGraphNode);
+    funToCallGraphNodeMap[callGraphNode->getFunction()] = callGraphNode;
+    callGraphNodeNum++;
+}
+
+/*!
+ *  Whether we have already created this call graph edge
+ */
+CallGraphEdge* CallGraph::hasGraphEdge(CallGraphNode* src,
+                                       CallGraphNode* dst,
+                                       const CallICFGNode* callIcfgNode) const
+{
+    CallGraphEdge edge(src,dst,callIcfgNode);
+    CallGraphEdge* outEdge = src->hasOutgoingEdge(&edge);
+    CallGraphEdge* inEdge = dst->hasIncomingEdge(&edge);
+    if (outEdge && inEdge)
+    {
+        assert(outEdge == inEdge && "edges not match");
+        return outEdge;
+    }
+    else
+        return nullptr;
+}
+
+/*!
+ * Add direct call edges
+ */
+void CallGraph::addDirectCallGraphEdge(const CallICFGNode* cs,const SVFFunction* callerFun, const SVFFunction* calleeFun)
+{
+
+    CallGraphNode* caller = getCallGraphNode(callerFun);
+    CallGraphNode* callee = getCallGraphNode(calleeFun);
+
+
+    if(!hasGraphEdge(caller,callee, cs))
+    {
+        CallGraphEdge* edge = new CallGraphEdge(caller,callee, cs);
+        edge->addDirectCallSite(cs);
+        addEdge(edge);
+        callinstToCallGraphEdgesMap[cs].insert(edge);
+    }
+}
+
+/*!
+ * Dump call graph into dot file
+ */
+void CallGraph::dump(const std::string& filename)
+{
+    GraphPrinter::WriteGraphToFile(outs(), filename, this);
+}
+
+void CallGraph::view()
+{
+    SVF::ViewGraph(this, "Call Graph");
+}
+
+namespace SVF
+{
+
+/*!
+ * Write value flow graph into dot file for debugging
+ */
+template<>
+struct DOTGraphTraits<CallGraph*> : public DefaultDOTGraphTraits
+{
+
+    typedef CallGraphNode NodeType;
+    typedef NodeType::iterator ChildIteratorType;
+    DOTGraphTraits(bool isSimple = false) :
+        DefaultDOTGraphTraits(isSimple)
+    {
+    }
+
+    /// Return name of the graph
+    static std::string getGraphName(CallGraph*)
+    {
+        return "Call Graph";
+    }
+    /// Return function name;
+    static std::string getNodeLabel(CallGraphNode*node, CallGraph*)
+    {
+        return node->toString();
+    }
+
+    static std::string getNodeAttributes(CallGraphNode*node, CallGraph*)
+    {
+        const SVFFunction* fun = node->getFunction();
+        if (!SVFUtil::isExtCall(fun))
+        {
+            return "shape=box";
+        }
+        else
+            return "shape=Mrecord";
+    }
+
+    template<class EdgeIter>
+    static std::string getEdgeAttributes(CallGraphNode*, EdgeIter EI,
+                                         CallGraph*)
+    {
+
+        //TODO: mark indirect call of Fork with different color
+        CallGraphEdge* edge = *(EI.getCurrent());
+        assert(edge && "No edge found!!");
+
+        std::string color = "color=black";
+        return color;
+    }
+
+    template<class EdgeIter>
+    static std::string getEdgeSourceLabel(NodeType*, EdgeIter EI)
+    {
+        CallGraphEdge* edge = *(EI.getCurrent());
+        assert(edge && "No edge found!!");
+
+        std::string str;
+        std::stringstream rawstr(str);
+        rawstr << edge->getEdgeKindWithoutMask();
+
+        return rawstr.str();
+    }
+};
+} // End namespace llvm

package/svf/lib/Graphs/PTACallGraph.cpp

@@ -29,6 +29,7 @@
  */
 
 #include "Graphs/PTACallGraph.h"
+#include "Graphs/CallGraph.h"
 #include "SVFIR/SVFIR.h"
 #include "SVFIR/SVFModule.h"
 #include "Util/SVFUtil.h"
@@ -39,8 +40,7 @@ using namespace SVFUtil;
 
 PTACallGraph::CallSiteToIdMap PTACallGraph::csToIdMap;
 PTACallGraph::IdToCallSiteMap PTACallGraph::idToCSMap;
-CallSiteID PTACallGraph::totalCallSiteNum = 1;
-
+CallSiteID PTACallGraph::totalCallSiteNum=1;
 
 /// Add direct and indirect callsite
 //@{
@@ -113,16 +113,16 @@ PTACallGraph::PTACallGraph(CGEK k): kind(k)
 }
 
 /// Copy constructor
-PTACallGraph::PTACallGraph(const PTACallGraph& other)
+PTACallGraph::PTACallGraph(const CallGraph& other)
 {
-    callGraphNodeNum = other.callGraphNodeNum;
+    callGraphNodeNum = other.getTotalNodeNum();
     numOfResolvedIndCallEdge = 0;
-    kind = other.kind;
+    kind = NormCallGraph;
 
     /// copy call graph nodes
     for (const auto& item : other)
     {
-        const PTACallGraphNode* cgn = item.second;
+        const CallGraphNode* cgn = item.second;
         PTACallGraphNode* callGraphNode = new PTACallGraphNode(cgn->getId(), cgn->getFunction());
         addGNode(cgn->getId(),callGraphNode);
         funToCallGraphNodeMap[cgn->getFunction()] = callGraphNode;
@@ -132,11 +132,13 @@ PTACallGraph::PTACallGraph(const PTACallGraph& other)
     for (const auto& item : other.callinstToCallGraphEdgesMap)
     {
         const CallICFGNode* cs = item.first;
-        for (const PTACallGraphEdge* edge : item.second)
+        for (const CallGraphEdge* edge : item.second)
         {
             PTACallGraphNode* src = getCallGraphNode(edge->getSrcID());
             PTACallGraphNode* dst = getCallGraphNode(edge->getDstID());
-            PTACallGraphEdge* newEdge = new PTACallGraphEdge(src,dst, PTACallGraphEdge::CallRetEdge,edge->getCallSiteID());
+            CallSiteID csId = addCallSite(cs, dst->getFunction());
+
+            PTACallGraphEdge* newEdge = new PTACallGraphEdge(src,dst, PTACallGraphEdge::CallRetEdge,csId);
             newEdge->addDirectCallSite(cs);
             addEdge(newEdge);
             callinstToCallGraphEdgesMap[cs].insert(newEdge);
@@ -152,18 +154,6 @@ void PTACallGraph::destroy()
 {
 }
 
-/*!
- * Add call graph node
- */
-void PTACallGraph::addCallGraphNode(const SVFFunction* fun)
-{
-    NodeID id  = callGraphNodeNum;
-    PTACallGraphNode*callGraphNode = new PTACallGraphNode(id, fun);
-    addGNode(id, callGraphNode);
-    funToCallGraphNodeMap[callGraphNode->getFunction()] = callGraphNode;
-    callGraphNodeNum++;
-}
-
 /*!
  *  Whether we have already created this call graph edge
  */
@@ -200,25 +190,6 @@ PTACallGraphEdge* PTACallGraph::getGraphEdge(PTACallGraphNode* src,
     return nullptr;
 }
 
-/*!
- * Add direct call edges
- */
-void PTACallGraph::addDirectCallGraphEdge(const CallICFGNode* cs,const SVFFunction* callerFun, const SVFFunction* calleeFun)
-{
-
-    PTACallGraphNode* caller = getCallGraphNode(callerFun);
-    PTACallGraphNode* callee = getCallGraphNode(calleeFun);
-
-    CallSiteID csId = addCallSite(cs, callee->getFunction());
-
-    if(!hasGraphEdge(caller,callee, PTACallGraphEdge::CallRetEdge,csId))
-    {
-        PTACallGraphEdge* edge = new PTACallGraphEdge(caller,callee, PTACallGraphEdge::CallRetEdge,csId);
-        edge->addDirectCallSite(cs);
-        addEdge(edge);
-        callinstToCallGraphEdgesMap[cs].insert(edge);
-    }
-}
 
 /*!
  * Add indirect call edge to update call graph

package/svf/lib/Graphs/ThreadCallGraph.cpp

@@ -39,7 +39,7 @@ using namespace SVFUtil;
 /*!
  * Constructor
  */
-ThreadCallGraph::ThreadCallGraph(const PTACallGraph& cg) :
+ThreadCallGraph::ThreadCallGraph(const CallGraph& cg) :
     PTACallGraph(cg), tdAPI(ThreadAPI::getThreadAPI())
 {
     kind = ThdCallGraph;

package/svf/lib/MSSA/MemRegion.cpp

@@ -31,6 +31,7 @@
 #include "SVFIR/SVFModule.h"
 #include "MSSA/MemRegion.h"
 #include "MSSA/MSSAMuChi.h"
+#include "Graphs/CallGraph.h"
 
 using namespace SVF;
 using namespace SVFUtil;
@@ -173,7 +174,7 @@ SVFIR::SVFStmtList& MRGenerator::getPAGEdgesFromInst(const ICFGNode* node)
 void MRGenerator::collectModRefForLoadStore()
 {
 
-    PTACallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
+    CallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
     for (const auto& item: *svfirCallGraph)
     {
         const SVFFunction& fun = *item.second->getFunction();

package/svf/lib/MSSA/MemSSA.cpp

@@ -31,6 +31,7 @@
 #include "MSSA/MemPartition.h"
 #include "MSSA/MemSSA.h"
 #include "Graphs/SVFGStat.h"
+#include "Graphs/CallGraph.h"
 
 using namespace SVF;
 using namespace SVFUtil;
@@ -575,7 +576,7 @@ u32_t MemSSA::getBBPhiNum() const
 void MemSSA::dumpMSSA(OutStream& Out)
 {
 
-    PTACallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
+    CallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
     for (const auto& item: *svfirCallGraph)
     {
         const SVFFunction* fun = item.second->getFunction();

package/svf/lib/MSSA/SVFGBuilder.cpp

@@ -33,6 +33,8 @@
 #include "Graphs/SVFG.h"
 #include "MSSA/SVFGBuilder.h"
 #include "WPA/Andersen.h"
+#include "Graphs/CallGraph.h"
+
 
 using namespace SVF;
 using namespace SVFUtil;
@@ -101,7 +103,7 @@ std::unique_ptr<MemSSA> SVFGBuilder::buildMSSA(BVDataPTAImpl* pta, bool ptrOnlyM
 
     auto mssa = std::make_unique<MemSSA>(pta, ptrOnlyMSSA);
 
-    PTACallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
+    CallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
     for (const auto& item: *svfirCallGraph)
     {
 

package/svf/lib/MTA/TCT.cpp

@@ -31,6 +31,7 @@
 #include "Util/Options.h"
 #include "MTA/TCT.h"
 #include "MTA/MTA.h"
+#include "Graphs/CallGraph.h"
 
 #include <string>
 
@@ -185,7 +186,7 @@ void TCT::markRelProcs(const SVFFunction* svffun)
  */
 void TCT::collectEntryFunInCallGraph()
 {
-    PTACallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
+    CallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
     for (const auto& item: *svfirCallGraph)
     {
         const SVFFunction* fun = item.second->getFunction();

package/svf/lib/MemoryModel/PointerAnalysis.cpp

@@ -116,8 +116,8 @@ void PointerAnalysis::initialize()
     }
     else
     {
-        PTACallGraph* cg = pag->getCallGraph();
-        callgraph = new PTACallGraph(*cg);
+        CallGraphBuilder bd;
+        callgraph = bd.buildPTACallGraph();
     }
     callGraphSCCDetection();
 

package/svf/lib/SABER/SaberCondAllocator.cpp

@@ -35,6 +35,7 @@
 #include <climits>
 #include <cmath>
 #include "SVFIR/SVFStatements.h"
+#include "Graphs/CallGraph.h"
 
 using namespace SVF;
 using namespace SVFUtil;
@@ -59,7 +60,7 @@ void SaberCondAllocator::allocate(const SVFModule *M)
 {
     DBOUT(DGENERAL, outs() << pasMsg("path condition allocation starts\n"));
 
-    PTACallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
+    CallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
     for (const auto& item: *svfirCallGraph)
     {
         const SVFFunction *func = (item.second)->getFunction();

package/svf/lib/SVFIR/SVFIR.cpp

@@ -29,6 +29,7 @@
 
 #include "Util/Options.h"
 #include "SVFIR/SVFIR.h"
+#include "Graphs/CallGraph.h"
 
 using namespace SVF;
 using namespace SVFUtil;

package/svf/lib/Util/CDGBuilder.cpp

@@ -27,7 +27,7 @@
  *      Author: Xiao Cheng
  */
 #include "Util/CDGBuilder.h"
-#include "Graphs/PTACallGraph.h"
+#include "Graphs/CallGraph.h"
 
 using namespace SVF;
 using namespace SVFUtil;
@@ -123,7 +123,7 @@ s64_t CDGBuilder::getBBSuccessorBranchID(const SVFBasicBlock *BB, const SVFBasic
  */
 void CDGBuilder::buildControlDependence(const SVFModule *svfgModule)
 {
-    PTACallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
+    CallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
     for (const auto& item: *svfirCallGraph)
     {
         const SVFFunction *svfFun = (item.second)->getFunction();

package/svf/lib/Util/CallGraphBuilder.cpp

@@ -32,13 +32,15 @@
 #include "Util/CallGraphBuilder.h"
 #include "Graphs/ICFG.h"
 #include "SVFIR/SVFIR.h"
+#include "Graphs/CallGraph.h"
+#include "Graphs/ThreadCallGraph.h"
 
 using namespace SVF;
 using namespace SVFUtil;
 
-PTACallGraph* CallGraphBuilder::buildSVFIRCallGraph(SVFModule* svfModule)
+CallGraph* CallGraphBuilder::buildSVFIRCallGraph(SVFModule* svfModule)
 {
-    PTACallGraph* callgraph = new PTACallGraph();
+    CallGraph* callgraph = new CallGraph();
     for (const SVFFunction* svfFunc: svfModule->getFunctionSet())
     {
         callgraph->addCallGraphNode(svfFunc);
@@ -64,9 +66,15 @@ PTACallGraph* CallGraphBuilder::buildSVFIRCallGraph(SVFModule* svfModule)
     return callgraph;
 }
 
+PTACallGraph* CallGraphBuilder::buildPTACallGraph()
+{
+    CallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
+    return new PTACallGraph(*svfirCallGraph);
+}
+
 ThreadCallGraph* CallGraphBuilder::buildThreadCallGraph()
 {
-    PTACallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
+    CallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
     ThreadCallGraph* cg = new ThreadCallGraph(*svfirCallGraph);
 
     ThreadAPI* tdAPI = ThreadAPI::getThreadAPI();

package/svf/lib/Util/SVFStat.cpp

@@ -29,6 +29,7 @@
 
 #include "Util/Options.h"
 #include "Util/SVFStat.h"
+#include "Graphs/CallGraph.h"
 
 using namespace SVF;
 using namespace std;
@@ -216,7 +217,7 @@ void SVFStat::branchStat()
 {
     u32_t numOfBB_2Succ = 0;
     u32_t numOfBB_3Succ = 0;
-    PTACallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
+    CallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
     for (const auto& item: *svfirCallGraph)
     {
         const SVFFunction* func = item.second->getFunction();

package/svf/lib/Util/SVFUtil.cpp

@@ -30,6 +30,7 @@
 #include "Util/Options.h"
 #include "Util/SVFUtil.h"
 #include "MemoryModel/PointsTo.h"
+#include "Graphs/CallGraph.h"
 
 #include <sys/resource.h>		/// increase stack size
 
@@ -401,10 +402,10 @@ bool SVFUtil::isProgExitCall(const CallICFGNode* cs)
 /// Get program entry function from module.
 const SVFFunction* SVFUtil::getProgFunction(const std::string& funName)
 {
-    PTACallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
+    CallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
     for (const auto& item: *svfirCallGraph)
     {
-        const PTACallGraphNode*fun = item.second;
+        const CallGraphNode*fun = item.second;
         if (fun->getName()==funName)
             return fun->getFunction();
     }
@@ -414,10 +415,10 @@ const SVFFunction* SVFUtil::getProgFunction(const std::string& funName)
 /// Get program entry function from module.
 const SVFFunction* SVFUtil::getProgEntryFunction()
 {
-    PTACallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
+    CallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
     for (const auto& item: *svfirCallGraph)
     {
-        const PTACallGraphNode*fun = item.second;
+        const CallGraphNode*fun = item.second;
         if (isProgEntryFunction(fun->getFunction()))
             return (fun->getFunction());
     }

package/svf/lib/Util/ThreadAPI.cpp

@@ -32,7 +32,7 @@
 
 #include "Util/ThreadAPI.h"
 #include "Util/SVFUtil.h"
-#include "Graphs/PTACallGraph.h"
+#include "Graphs/CallGraph.h"
 #include "SVFIR/SVFIR.h"
 
 #include <iostream>		/// std output
@@ -270,7 +270,7 @@ void ThreadAPI::performAPIStat(SVFModule* module)
 
     statInit(tdAPIStatMap);
 
-    PTACallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
+    CallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
     for (const auto& item: *svfirCallGraph)
     {
         for (SVFFunction::const_iterator bit = (item.second)->getFunction()->begin(), ebit = (item.second)->getFunction()->end(); bit != ebit; ++bit)

package/svf-llvm/include/SVF-LLVM/LLVMModule.h

@@ -105,7 +105,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
-    PTACallGraph* callgraph;
+    CallGraph* callgraph;
 
     /// Constructor
     LLVMModuleSet();