svf-tools 1.0.1040 → 1.0.1042

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.1040",
+  "version": "1.0.1042",
   "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/AE/Svfexe/AbstractInterpretation.h

@@ -106,7 +106,7 @@ class AbstractInterpretation
     friend class BufOverflowDetector;
 
 public:
-    typedef SCCDetection<PTACallGraph*> CallGraphSCC;
+    typedef SCCDetection<CallGraph*> CallGraphSCC;
     /// Constructor
     AbstractInterpretation();
 
@@ -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/include/DDA/DDAVFSolver.h

@@ -49,8 +49,8 @@ class DDAVFSolver
     friend class DDAStat;
 public:
     typedef SCCDetection<SVFG*> SVFGSCC;
-    typedef SCCDetection<PTACallGraph*> CallGraphSCC;
-    typedef PTACallGraphEdge::CallInstSet CallInstSet;
+    typedef SCCDetection<CallGraph*> CallGraphSCC;
+    typedef CallGraphEdge::CallInstSet CallInstSet;
     typedef SVFIR::CallSiteSet CallSiteSet;
     typedef OrderedSet<DPIm> DPTItemSet;
     typedef OrderedMap<DPIm, CPtSet> DPImToCPtSetMap;
@@ -624,7 +624,7 @@ protected:
         return (getSVFGSCCRepNode(edge->getSrcID()) == getSVFGSCCRepNode(edge->getDstID()));
     }
     /// Set callgraph
-    inline void setCallGraph (PTACallGraph* cg)
+    inline void setCallGraph (CallGraph* cg)
     {
         _callGraph = cg;
     }
@@ -774,7 +774,7 @@ protected:
     SVFG* _svfg;					///< SVFG
     AndersenWaveDiff* _ander;		///< Andersen's analysis
     NodeBS candidateQueries;		///< candidate pointers;
-    PTACallGraph* _callGraph;		///< PTACallGraph
+    CallGraph* _callGraph;		///< PTACallGraph
     CallGraphSCC* _callGraphSCC;	///< SCC for PTACallGraph
     SVFGSCC* _svfgSCC;				///< SCC for SVFG
     DPTItemSet backwardVisited;		///< visited map during backward traversing

package/svf/include/Graphs/CallGraph.h

@@ -1,4 +1,4 @@
-//===- CallGraph.h -- Call graph representation----------------------------//
+//===- PTACallGraph.h -- Call graph representation----------------------------//
 //
 //                     SVF: Static Value-Flow Analysis
 //
@@ -21,14 +21,14 @@
 //===----------------------------------------------------------------------===//
 
 /*
- * CallGraph.h
+ * PTACallGraph.h
  *
  *  Created on: Nov 7, 2013
  *      Author: Yulei Sui
  */
 
-#ifndef CALLGRAPH_H_
-#define CALLGRAPH_H_
+#ifndef PTACALLGRAPH_H_
+#define PTACALLGRAPH_H_
 
 #include "Graphs/GenericGraph.h"
 #include "SVFIR/SVFValue.h"
@@ -40,6 +40,7 @@ namespace SVF
 
 class CallGraphNode;
 class SVFModule;
+class CallGraph;
 
 
 /*
@@ -47,29 +48,74 @@ 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<CallGraphNode> GenericCallGraphEdgeTy;
-class CallGraphEdge : public GenericCallGraphEdgeTy
+typedef GenericEdge<CallGraphNode> GenericPTACallGraphEdgeTy;
+class CallGraphEdge : public GenericPTACallGraphEdgeTy
 {
 
 public:
     typedef Set<const CallICFGNode*> CallInstSet;
+    enum CEDGEK
+    {
+        CallRetEdge,TDForkEdge,TDJoinEdge,HareParForEdge
+    };
+
 
 private:
     CallInstSet directCalls;
+    CallInstSet indirectCalls;
+    CallSiteID csId;
 public:
     /// Constructor
-    CallGraphEdge(CallGraphNode* s, CallGraphNode* d, const CallICFGNode* icfgNode) :
-        GenericCallGraphEdgeTy(s, d, icfgNode->getId())
+    CallGraphEdge(CallGraphNode* s, CallGraphNode* d, CEDGEK kind, CallSiteID cs) :
+        GenericPTACallGraphEdgeTy(s, d, makeEdgeFlagWithInvokeID(kind, cs)), csId(cs)
     {
     }
     /// Destructor
     virtual ~CallGraphEdge()
     {
     }
+    /// Compute the unique edgeFlag value from edge kind and CallSiteID.
+    static inline GEdgeFlag makeEdgeFlagWithInvokeID(GEdgeKind k, CallSiteID cs)
+    {
+        return (cs << EdgeKindMaskBits) | k;
+    }
+    /// Get direct and indirect calls
+    //@{
+    inline CallSiteID getCallSiteID() const
+    {
+        return csId;
+    }
+    inline bool isDirectCallEdge() const
+    {
+        return !directCalls.empty() && indirectCalls.empty();
+    }
+    inline bool isIndirectCallEdge() const
+    {
+        return directCalls.empty() && !indirectCalls.empty();
+    }
+    inline CallInstSet& getDirectCalls()
+    {
+        return directCalls;
+    }
+    inline CallInstSet& getIndirectCalls()
+    {
+        return indirectCalls;
+    }
+    inline const CallInstSet& getDirectCalls() const
+    {
+        return directCalls;
+    }
+    inline const CallInstSet& getIndirectCalls() const
+    {
+        return indirectCalls;
+    }
+    //@}
 
-    /// Add direct callsite
+    /// Add direct and indirect callsite
     //@{
     void addDirectCallSite(const CallICFGNode* call);
+
+    void addInDirectCallSite(const CallICFGNode* call);
     //@}
 
     /// Iterators for direct and indirect callsites
@@ -82,6 +128,15 @@ public:
     {
         return directCalls.end();
     }
+
+    inline CallInstSet::const_iterator indirectCallsBegin() const
+    {
+        return indirectCalls.begin();
+    }
+    inline CallInstSet::const_iterator indirectCallsEnd() const
+    {
+        return indirectCalls.end();
+    }
     //@}
 
     /// ClassOf
@@ -90,6 +145,12 @@ public:
     {
         return true;
     }
+    static inline bool classof(const GenericPTACallGraphEdgeTy *edge)
+    {
+        return edge->getEdgeKind() == CallGraphEdge::CallRetEdge ||
+               edge->getEdgeKind() == CallGraphEdge::TDForkEdge ||
+               edge->getEdgeKind() == CallGraphEdge::TDJoinEdge;
+    }
     //@}
 
     /// Overloading operator << for dumping ICFG node ID
@@ -110,16 +171,17 @@ public:
 /*
  * Call Graph node representing a function
  */
-typedef GenericNode<CallGraphNode, CallGraphEdge> GenericCallGraphNodeTy;
-class CallGraphNode : public GenericCallGraphNodeTy
+typedef GenericNode<CallGraphNode, CallGraphEdge> GenericPTACallGraphNodeTy;
+class CallGraphNode : public GenericPTACallGraphNodeTy
 {
 private:
     const SVFFunction* fun;
 
 public:
     /// Constructor
-    CallGraphNode(NodeID i, const SVFFunction* f) : GenericCallGraphNodeTy(i,CallNodeKd), fun(f)
+    CallGraphNode(NodeID i, const SVFFunction* f) : GenericPTACallGraphNodeTy(i,CallNodeKd), fun(f)
     {
+
     }
 
     inline const std::string &getName() const
@@ -133,6 +195,9 @@ public:
         return fun;
     }
 
+    /// Return TRUE if this function can be reached from main.
+    bool isReachableFromProgEntry() const;
+
 
     /// Overloading operator << for dumping ICFG node ID
     //@{
@@ -167,27 +232,64 @@ public:
 /*!
  * Pointer Analysis Call Graph used internally for various pointer analysis
  */
-typedef GenericGraph<CallGraphNode, CallGraphEdge> GenericCallGraphTy;
-class CallGraph : public GenericCallGraphTy
+typedef GenericGraph<CallGraphNode, CallGraphEdge> GenericPTACallGraphTy;
+class CallGraph : public GenericPTACallGraphTy
 {
-    friend class PTACallGraph;
 
 public:
     typedef CallGraphEdge::CallGraphEdgeSet CallGraphEdgeSet;
     typedef Map<const SVFFunction*, CallGraphNode*> FunToCallGraphNodeMap;
     typedef Map<const CallICFGNode*, CallGraphEdgeSet> CallInstToCallGraphEdgesMap;
+    typedef std::pair<const CallICFGNode*, const SVFFunction*> CallSitePair;
+    typedef Map<CallSitePair, CallSiteID> CallSiteToIdMap;
+    typedef Map<CallSiteID, CallSitePair> IdToCallSiteMap;
     typedef Set<const SVFFunction*> FunctionSet;
     typedef OrderedMap<const CallICFGNode*, FunctionSet> CallEdgeMap;
+    typedef CallGraphEdgeSet::iterator CallGraphEdgeIter;
+    typedef CallGraphEdgeSet::const_iterator CallGraphEdgeConstIter;
+
+    enum CGEK
+    {
+        NormCallGraph, ThdCallGraph
+    };
+
+private:
+    /// Indirect call map
+    CallEdgeMap indirectCallMap;
+
+    /// Call site information
+    static CallSiteToIdMap csToIdMap;	///< Map a pair of call instruction and callee to a callsite ID
+    static IdToCallSiteMap idToCSMap;	///< Map a callsite ID to a pair of call instruction and callee
+    static CallSiteID totalCallSiteNum;	///< CallSiteIDs, start from 1;
 
 protected:
     FunToCallGraphNodeMap funToCallGraphNodeMap; ///< Call Graph node map
     CallInstToCallGraphEdgesMap callinstToCallGraphEdgesMap; ///< Map a call instruction to its corresponding call edges
 
     NodeID callGraphNodeNum;
+    u32_t numOfResolvedIndCallEdge;
+    CGEK kind;
 
     /// 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(CallGraphEdge* edge)
     {
@@ -195,14 +297,12 @@ protected:
         edge->getSrcNode()->addOutgoingEdge(edge);
     }
 
-
 public:
     /// Constructor
-    CallGraph();
-
-    void addCallGraphNode(const SVFFunction* fun);
+    CallGraph(CGEK k = NormCallGraph);
 
-    const CallGraphNode* getCallGraphNode(const std::string& name);
+    /// Copy constructor
+    CallGraph(const CallGraph& other);
 
     /// Destructor
     virtual ~CallGraph()
@@ -210,8 +310,57 @@ public:
         destroy();
     }
 
+    /// Return type of this callgraph
+    inline CGEK getKind() const
+    {
+        return kind;
+    }
+
+    /// Get callees from an indirect callsite
+    //@{
+    inline CallEdgeMap& getIndCallMap()
+    {
+        return indirectCallMap;
+    }
+    inline bool hasIndCSCallees(const CallICFGNode* cs) const
+    {
+        return (indirectCallMap.find(cs) != indirectCallMap.end());
+    }
+    inline const FunctionSet& getIndCSCallees(const CallICFGNode* cs) const
+    {
+        CallEdgeMap::const_iterator it = indirectCallMap.find(cs);
+        assert(it!=indirectCallMap.end() && "not an indirect callsite!");
+        return it->second;
+    }
+    //@}
+    inline u32_t getTotalCallSiteNumber() const
+    {
+        return totalCallSiteNum;
+    }
+
+    inline u32_t getNumOfResolvedIndCallEdge() const
+    {
+        return numOfResolvedIndCallEdge;
+    }
+
+    inline const CallInstToCallGraphEdgesMap& getCallInstToCallGraphEdgesMap() const
+    {
+        return callinstToCallGraphEdgesMap;
+    }
+
+    /// 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 CallGraphNode* getCallGraphNode(const std::string& name);
+
     inline CallGraphNode* getCallGraphNode(NodeID id) const
     {
         return getGNode(id);
@@ -225,12 +374,99 @@ public:
 
     //@}
 
+    /// Get CallSiteID
+    //@{
+    inline CallSiteID getCallSiteID(const CallICFGNode* cs, const SVFFunction* callee) const
+    {
+        CallSitePair newCS(std::make_pair(cs, callee));
+        CallSiteToIdMap::const_iterator it = csToIdMap.find(newCS);
+        assert(it != csToIdMap.end() && "callsite id not found! This maybe a partially resolved callgraph, please check the indCallEdge limit");
+        return it->second;
+    }
+    inline bool hasCallSiteID(const CallICFGNode* cs, const SVFFunction* callee) const
+    {
+        CallSitePair newCS(std::make_pair(cs, callee));
+        CallSiteToIdMap::const_iterator it = csToIdMap.find(newCS);
+        return it != csToIdMap.end();
+    }
+    inline const CallSitePair& getCallSitePair(CallSiteID id) const
+    {
+        IdToCallSiteMap::const_iterator it = idToCSMap.find(id);
+        assert(it != idToCSMap.end() && "cannot find call site for this CallSiteID");
+        return (it->second);
+    }
+    inline const CallICFGNode* getCallSite(CallSiteID id) const
+    {
+        return getCallSitePair(id).first;
+    }
+    inline const SVFFunction* getCallerOfCallSite(CallSiteID id) const
+    {
+        return getCallSite(id)->getCaller();
+    }
+    inline const SVFFunction* getCalleeOfCallSite(CallSiteID id) const
+    {
+        return getCallSitePair(id).second;
+    }
+    //@}
     /// Whether we have already created this call graph edge
     CallGraphEdge* hasGraphEdge(CallGraphNode* src, CallGraphNode* dst,
-                                const CallICFGNode* callIcfgNode) const;
+                                CallGraphEdge::CEDGEK kind, CallSiteID csId) const;
+    /// Get call graph edge via nodes
+    CallGraphEdge* getGraphEdge(CallGraphNode* src, CallGraphNode* dst,
+                                CallGraphEdge::CEDGEK kind, CallSiteID csId);
+
+    /// Get all callees for a callsite
+    inline void getCallees(const CallICFGNode* cs, FunctionSet& callees)
+    {
+        if(hasCallGraphEdge(cs))
+        {
+            for (CallGraphEdgeSet::const_iterator it = getCallEdgeBegin(cs), eit =
+                        getCallEdgeEnd(cs); it != eit; ++it)
+            {
+                callees.insert((*it)->getDstNode()->getFunction());
+            }
+        }
+    }
+
+    /// Get call graph edge via call instruction
+    //@{
+    /// whether this call instruction has a valid call graph edge
+    inline bool hasCallGraphEdge(const CallICFGNode* inst) const
+    {
+        return callinstToCallGraphEdgesMap.find(inst)!=callinstToCallGraphEdgesMap.end();
+    }
+    inline CallGraphEdgeSet::const_iterator getCallEdgeBegin(const CallICFGNode* inst) const
+    {
+        CallInstToCallGraphEdgesMap::const_iterator it = callinstToCallGraphEdgesMap.find(inst);
+        assert(it!=callinstToCallGraphEdgesMap.end()
+               && "call instruction does not have a valid callee");
+        return it->second.begin();
+    }
+    inline CallGraphEdgeSet::const_iterator getCallEdgeEnd(const CallICFGNode* inst) const
+    {
+        CallInstToCallGraphEdgesMap::const_iterator it = callinstToCallGraphEdgesMap.find(inst);
+        assert(it!=callinstToCallGraphEdgesMap.end()
+               && "call instruction does not have a valid callee");
+        return it->second.end();
+    }
+    //@}
+
+
+    /// Add indirect call edges
+    //@{
+    void addIndirectCallGraphEdge(const CallICFGNode* cs,const SVFFunction* callerFun, const SVFFunction* calleeFun);
+    //@}
+
+    /// Get callsites invoking the callee
+    //@{
+    void getAllCallSitesInvokingCallee(const SVFFunction* callee, CallGraphEdge::CallInstSet& csSet);
+    void getDirCallSitesInvokingCallee(const SVFFunction* callee, CallGraphEdge::CallInstSet& csSet);
+    void getIndCallSitesInvokingCallee(const SVFFunction* callee, CallGraphEdge::CallInstSet& csSet);
+    //@}
+
+    /// Whether its reachable between two functions
+    bool isReachableBetweenFunctions(const SVFFunction* srcFn, const SVFFunction* dstFn) 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);
 
@@ -263,4 +499,4 @@ template<> struct GenericGraphTraits<SVF::CallGraph*> : public GenericGraphTrait
 
 } // End namespace llvm
 
-#endif /* CALLGRAPH_H_ */
+#endif /* PTACALLGRAPH_H_ */

package/svf/include/Graphs/ICFG.h

@@ -38,7 +38,7 @@
 namespace SVF
 {
 
-class PTACallGraph;
+class CallGraph;
 
 /*!
  * Interprocedural Control-Flow Graph (ICFG)
@@ -111,7 +111,7 @@ public:
     void view();
 
     /// update ICFG for indirect calls
-    void updateCallGraph(PTACallGraph* callgraph);
+    void updateCallGraph(CallGraph* callgraph);
 
     /// Whether node is in a loop
     inline bool isInLoop(const ICFGNode *node)

package/svf/include/Graphs/ThreadCallGraph.h

@@ -30,7 +30,7 @@
 #ifndef RCG_H_
 #define RCG_H_
 
-#include "Graphs/PTACallGraph.h"
+#include "Graphs/CallGraph.h"
 
 namespace SVF
 {
@@ -41,13 +41,13 @@ class PointerAnalysis;
 /*!
  * PTA thread fork edge from fork site to the entry of a start routine function
  */
-class ThreadForkEdge: public PTACallGraphEdge
+class ThreadForkEdge: public CallGraphEdge
 {
 
 public:
     /// Constructor
-    ThreadForkEdge(PTACallGraphNode* s, PTACallGraphNode* d, CallSiteID csId) :
-        PTACallGraphEdge(s, d, PTACallGraphEdge::TDForkEdge, csId)
+    ThreadForkEdge(CallGraphNode* s, CallGraphNode* d, CallSiteID csId) :
+        CallGraphEdge(s, d, CallGraphEdge::TDForkEdge, csId)
     {
     }
     /// Destructor
@@ -61,9 +61,9 @@ public:
     {
         return true;
     }
-    static inline bool classof(const PTACallGraphEdge*edge)
+    static inline bool classof(const CallGraphEdge*edge)
     {
-        return edge->getEdgeKind() == PTACallGraphEdge::TDForkEdge;
+        return edge->getEdgeKind() == CallGraphEdge::TDForkEdge;
     }
     //@}
 
@@ -78,19 +78,19 @@ public:
         return rawstr.str();
     }
 
-    typedef GenericNode<PTACallGraphNode, ThreadForkEdge>::GEdgeSetTy ForkEdgeSet;
+    typedef GenericNode<CallGraphNode, ThreadForkEdge>::GEdgeSetTy ForkEdgeSet;
 };
 
 /*!
  * PTA thread join edge from the exit of a start routine function to a join point of the thread
  */
-class ThreadJoinEdge: public PTACallGraphEdge
+class ThreadJoinEdge: public CallGraphEdge
 {
 
 public:
     /// Constructor
-    ThreadJoinEdge(PTACallGraphNode* s, PTACallGraphNode* d, CallSiteID csId) :
-        PTACallGraphEdge(s, d, PTACallGraphEdge::TDJoinEdge, csId)
+    ThreadJoinEdge(CallGraphNode* s, CallGraphNode* d, CallSiteID csId) :
+        CallGraphEdge(s, d, CallGraphEdge::TDJoinEdge, csId)
     {
     }
     /// Destructor
@@ -102,9 +102,9 @@ public:
     {
         return true;
     }
-    static inline bool classof(const PTACallGraphEdge*edge)
+    static inline bool classof(const CallGraphEdge*edge)
     {
-        return edge->getEdgeKind() == PTACallGraphEdge::TDJoinEdge;
+        return edge->getEdgeKind() == CallGraphEdge::TDJoinEdge;
     }
 
     virtual const std::string toString() const
@@ -118,19 +118,19 @@ public:
         return rawstr.str();
     }
 
-    typedef GenericNode<PTACallGraphNode, ThreadJoinEdge>::GEdgeSetTy JoinEdgeSet;
+    typedef GenericNode<CallGraphNode, ThreadJoinEdge>::GEdgeSetTy JoinEdgeSet;
 };
 
 /*!
  * hare_parallel_for edge from fork site to the entry of a start routine function
  */
-class HareParForEdge: public PTACallGraphEdge
+class HareParForEdge: public CallGraphEdge
 {
 
 public:
     /// Constructor
-    HareParForEdge(PTACallGraphNode* s, PTACallGraphNode* d, CallSiteID csId) :
-        PTACallGraphEdge(s, d, PTACallGraphEdge::HareParForEdge, csId)
+    HareParForEdge(CallGraphNode* s, CallGraphNode* d, CallSiteID csId) :
+        CallGraphEdge(s, d, CallGraphEdge::HareParForEdge, csId)
     {
     }
     /// Destructor
@@ -144,20 +144,20 @@ public:
     {
         return true;
     }
-    static inline bool classof(const PTACallGraphEdge*edge)
+    static inline bool classof(const CallGraphEdge*edge)
     {
-        return edge->getEdgeKind() == PTACallGraphEdge::HareParForEdge;
+        return edge->getEdgeKind() == CallGraphEdge::HareParForEdge;
     }
     //@}
 
-    typedef GenericNode<PTACallGraphNode, HareParForEdge>::GEdgeSetTy ParForEdgeSet;
+    typedef GenericNode<CallGraphNode, HareParForEdge>::GEdgeSetTy ParForEdgeSet;
 };
 
 
 /*!
  * Thread sensitive call graph
  */
-class ThreadCallGraph: public PTACallGraph
+class ThreadCallGraph: public CallGraph
 {
 
 public:
@@ -187,9 +187,9 @@ public:
     {
         return true;
     }
-    static inline bool classof(const PTACallGraph*g)
+    static inline bool classof(const CallGraph*g)
     {
-        return g->getKind() == PTACallGraph::ThdCallGraph;
+        return g->getKind() == CallGraph::ThdCallGraph;
     }
     //@}
 
@@ -239,7 +239,7 @@ public:
         assert(it != callinstToThreadJoinEdgesMap.end() && "call instruction does not have a valid callee");
         return it->second.end();
     }
-    inline void getJoinSites(const PTACallGraphNode* routine, InstSet& csSet)
+    inline void getJoinSites(const CallGraphNode* routine, InstSet& csSet)
     {
         for(CallInstToJoinEdgesMap::const_iterator it = callinstToThreadJoinEdgesMap.begin(), eit = callinstToThreadJoinEdgesMap.end(); it!=eit; ++it)
         {
@@ -390,7 +390,7 @@ public:
     }
 
     /// has thread join edge
-    inline ThreadJoinEdge* hasThreadJoinEdge(const CallICFGNode* call, PTACallGraphNode* joinFunNode, PTACallGraphNode* threadRoutineFunNode, CallSiteID csId) const
+    inline ThreadJoinEdge* hasThreadJoinEdge(const CallICFGNode* call, CallGraphNode* joinFunNode, CallGraphNode* threadRoutineFunNode, CallSiteID csId) const
     {
         ThreadJoinEdge joinEdge(joinFunNode,threadRoutineFunNode, csId);
         CallInstToJoinEdgesMap::const_iterator it = callinstToThreadJoinEdgesMap.find(call);

package/svf/include/Graphs/VFG.h

@@ -32,7 +32,7 @@
 
 
 #include "SVFIR/SVFIR.h"
-#include "Graphs/PTACallGraph.h"
+#include "Graphs/CallGraph.h"
 #include "Graphs/VFGNode.h"
 #include "Graphs/VFGEdge.h"
 
@@ -100,7 +100,7 @@ protected:
     FunToVFGNodesMapTy funToVFGNodesMap; ///< map a function to its VFGNodes;
 
     GlobalVFGNodeSet globalVFGNodes;	///< set of global store VFG nodes
-    PTACallGraph* callgraph;
+    CallGraph* callgraph;
     SVFIR* pag;
     VFGK kind;
 
@@ -109,7 +109,7 @@ protected:
 
 public:
     /// Constructor
-    VFG(PTACallGraph* callgraph, VFGK k = FULLSVFG);
+    VFG(CallGraph* callgraph, VFGK k = FULLSVFG);
 
     /// Destructor
     virtual ~VFG()
@@ -136,7 +136,7 @@ public:
     }
 
     /// Return PTACallGraph
-    inline PTACallGraph* getCallGraph() const
+    inline CallGraph* getCallGraph() const
     {
         return callgraph;
     }