svf-lib 1.0.2078 → 1.0.2080

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

@@ -111,7 +111,7 @@ class AbstractInterpretation
 
 public:
     enum ExtAPIType { UNCLASSIFIED, MEMCPY, MEMSET, STRCPY, STRCAT };
-    typedef SCCDetection<CallGraph*> CallGraphSCC;
+    typedef SCCDetection<PTACallGraph*> CallGraphSCC;
     /// Constructor
     AbstractInterpretation();
 

package/SVF-linux/Release-build/include/DDA/ContextDDA.h

@@ -133,8 +133,8 @@ public:
     /// Whether call/return inside recursion
     inline virtual bool isEdgeInRecursion(CallSiteID csId)
     {
-        const SVFFunction* caller = getCallGraph()->getCallerOfCallSite(csId);
-        const SVFFunction* callee = getCallGraph()->getCalleeOfCallSite(csId);
+        const SVFFunction* caller = getPTACallGraph()->getCallerOfCallSite(csId);
+        const SVFFunction* callee = getPTACallGraph()->getCalleeOfCallSite(csId);
         return inSameCallGraphSCC(caller, callee);
     }
     /// Update call graph.

package/SVF-linux/Release-build/include/DDA/DDAVFSolver.h

@@ -49,8 +49,8 @@ class DDAVFSolver
     friend class DDAStat;
 public:
     typedef SCCDetection<SVFG*> SVFGSCC;
-    typedef SCCDetection<CallGraph*> CallGraphSCC;
-    typedef CallGraphEdge::CallInstSet CallInstSet;
+    typedef SCCDetection<PTACallGraph*> CallGraphSCC;
+    typedef PTACallGraphEdge::CallInstSet CallInstSet;
     typedef SVFIR::CallSiteSet CallSiteSet;
     typedef OrderedSet<DPIm> DPTItemSet;
     typedef OrderedMap<DPIm, CPtSet> DPImToCPtSetMap;
@@ -505,7 +505,7 @@ protected:
         {
             CallInstSet csSet;
             /// use pre-analysis call graph to approximate all potential callsites
-            _ander->getCallGraph()->getIndCallSitesInvokingCallee(fun,csSet);
+            _ander->getPTACallGraph()->getIndCallSitesInvokingCallee(fun,csSet);
             for(CallInstSet::const_iterator it = csSet.begin(), eit = csSet.end(); it!=eit; ++it)
             {
                 NodeID funPtr = _pag->getFunPtr(*it);
@@ -624,7 +624,7 @@ protected:
         return (getSVFGSCCRepNode(edge->getSrcID()) == getSVFGSCCRepNode(edge->getDstID()));
     }
     /// Set callgraph
-    inline void setCallGraph (CallGraph* cg)
+    inline void setCallGraph (PTACallGraph* cg)
     {
         _callGraph = cg;
     }
@@ -775,7 +775,7 @@ protected:
     SVFG* _svfg;					///< SVFG
     AndersenWaveDiff* _ander;		///< Andersen's analysis
     NodeBS candidateQueries;		///< candidate pointers;
-    CallGraph* _callGraph;		///< CallGraph
+    PTACallGraph* _callGraph;		///< CallGraph
     CallGraphSCC* _callGraphSCC;	///< SCC for CallGraph
     SVFGSCC* _svfgSCC;				///< SCC for SVFG
     DPTItemSet backwardVisited;		///< visited map during backward traversing

package/SVF-linux/Release-build/include/DDA/FlowDDA.h

@@ -87,7 +87,7 @@ public:
     {
         BVDataPTAImpl::initialize();
         buildSVFG(pag);
-        setCallGraph(getCallGraph());
+        setCallGraph(getPTACallGraph());
         setCallGraphSCC(getCallGraphSCC());
         stat = setDDAStat(new DDAStat(this));
     }

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

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

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

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

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

@@ -32,7 +32,7 @@
 
 
 #include "SVFIR/SVFIR.h"
-#include "Graphs/CallGraph.h"
+#include "Graphs/PTACallGraph.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
-    CallGraph* callgraph;
+    PTACallGraph* callgraph;
     SVFIR* pag;
     VFGK kind;
 
@@ -109,7 +109,7 @@ protected:
 
 public:
     /// Constructor
-    VFG(CallGraph* callgraph, VFGK k = FULLSVFG);
+    VFG(PTACallGraph* callgraph, VFGK k = FULLSVFG);
 
     /// Destructor
     virtual ~VFG()
@@ -136,7 +136,7 @@ public:
     }
 
     /// Return CallGraph
-    inline CallGraph* getCallGraph() const
+    inline PTACallGraph* getCallGraph() const
     {
         return callgraph;
     }

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

@@ -35,7 +35,7 @@
 #define MEMORYREGION_H_
 
 #include "Graphs/ICFG.h"
-#include "Graphs/CallGraph.h"
+#include "Graphs/PTACallGraph.h"
 #include "Graphs/SCC.h"
 #include "SVFIR/SVFIR.h"
 #include "Util/WorkList.h"
@@ -175,7 +175,7 @@ public:
     /// SVFIR edge list
     typedef SVFIR::SVFStmtList SVFStmtList;
     /// Call Graph SCC
-    typedef SCCDetection<CallGraph*> SCC;
+    typedef SCCDetection<PTACallGraph*> SCC;
 
     MRSet& getMRSet()
     {
@@ -196,7 +196,7 @@ private:
 
     BVDataPTAImpl* pta;
     SCC* callGraphSCC;
-    CallGraph* callGraph;
+    PTACallGraph* callGraph;
     bool ptrOnlyMSSA;
 
     /// Map a function to all its memory regions
@@ -330,7 +330,7 @@ protected:
     }
 
     /// Mod-Ref analysis for callsite invoking this callGraphNode
-    virtual void modRefAnalysis(CallGraphNode* callGraphNode, WorkList& worklist);
+    virtual void modRefAnalysis(PTACallGraphNode* callGraphNode, WorkList& worklist);
 
     /// Get Mod-Ref of a callee function
     virtual bool handleCallsiteModRef(NodeBS& mod, NodeBS& ref, const CallICFGNode* cs, const SVFFunction* fun);

package/SVF-linux/Release-build/include/MTA/LockAnalysis.h

@@ -339,7 +339,7 @@ private:
     void handleIntra(const CxtStmt& cts);
 
     /// Handle call relations
-    void handleCallRelation(CxtLockProc& clp, const CallGraphEdge* cgEdge, CallSite call);
+    void handleCallRelation(CxtLockProc& clp, const PTACallGraphEdge* cgEdge, CallSite call);
 
     /// Return true it a lock matches an unlock
     bool isAliasedLocks(const CxtLock& cl1, const CxtLock& cl2)

package/SVF-linux/Release-build/include/MTA/MHP.h

@@ -140,7 +140,7 @@ public:
 
 private:
 
-    inline const CallGraph::FunctionSet& getCallee(const SVFInstruction* inst, CallGraph::FunctionSet& callees)
+    inline const PTACallGraph::FunctionSet& getCallee(const SVFInstruction* inst, PTACallGraph::FunctionSet& callees)
     {
         tcg->getCallees(getCBN(inst), callees);
         return callees;
@@ -501,7 +501,7 @@ private:
     {
         return getTCG()->getThreadAPI()->getJoinedThread(call);
     }
-    inline const CallGraph::FunctionSet& getCallee(const SVFInstruction* inst, CallGraph::FunctionSet& callees)
+    inline const PTACallGraph::FunctionSet& getCallee(const SVFInstruction* inst, PTACallGraph::FunctionSet& callees)
     {
         getTCG()->getCallees(getCBN(inst), callees);
         return callees;

package/SVF-linux/Release-build/include/MTA/PCG.h

@@ -31,7 +31,7 @@
 #define PCG_H_
 
 #include "Util/ThreadAPI.h"
-#include "Graphs/CallGraph.h"
+#include "Graphs/PTACallGraph.h"
 #include "Util/WorkList.h"
 #include "WPA/Andersen.h"
 #include <set>
@@ -62,7 +62,7 @@ private:
     FunSet spawnees;
     FunSet followers;
     FunSet mhpfuns;
-    CallGraph* callgraph;
+    PTACallGraph* callgraph;
     SVFModule* mod;
     PointerAnalysis* pta;
     ThreadAPI* tdAPI;
@@ -134,7 +134,7 @@ public:
     {
         mod = pta->getModule();
         tdAPI=ThreadAPI::getThreadAPI();
-        callgraph = pta->getCallGraph();
+        callgraph = pta->getPTACallGraph();
     }
 
     /// We start the pass here

package/SVF-linux/Release-build/include/MTA/TCT.h

@@ -142,19 +142,19 @@ public:
     typedef Set<const SVFFunction*> FunSet;
     typedef std::vector<const SVFInstruction*> InstVec;
     typedef Set<const SVFInstruction*> InstSet;
-    typedef Set<const CallGraphNode*> PTACGNodeSet;
+    typedef Set<const PTACallGraphNode*> PTACGNodeSet;
     typedef Map<CxtThread,TCTNode*> CxtThreadToNodeMap;
     typedef Map<CxtThread,CallStrCxt> CxtThreadToForkCxt;
     typedef Map<CxtThread,const SVFFunction*> CxtThreadToFun;
     typedef Map<const SVFInstruction*, LoopBBs> InstToLoopMap;
     typedef FIFOWorkList<CxtThreadProc> CxtThreadProcVec;
     typedef Set<CxtThreadProc> CxtThreadProcSet;
-    typedef SCCDetection<CallGraph*> ThreadCallGraphSCC;
+    typedef SCCDetection<PTACallGraph*> ThreadCallGraphSCC;
 
     /// Constructor
     TCT(PointerAnalysis* p) :pta(p),TCTNodeNum(0),TCTEdgeNum(0),MaxCxtSize(0)
     {
-        tcg = SVFUtil::cast<ThreadCallGraph>(pta->getCallGraph());
+        tcg = SVFUtil::cast<ThreadCallGraph>(pta->getPTACallGraph());
         tcg->updateCallGraph(pta);
         //tcg->updateJoinEdge(pta);
         tcgSCC = pta->getCallGraphSCC();
@@ -261,9 +261,9 @@ public:
     //@}
 
     /// Whether it is a candidate function for indirect call
-    inline bool isCandidateFun(const CallGraph::FunctionSet& callees) const
+    inline bool isCandidateFun(const PTACallGraph::FunctionSet& callees) const
     {
-        for(CallGraph::FunctionSet::const_iterator cit = callees.begin(),
+        for(PTACallGraph::FunctionSet::const_iterator cit = callees.begin(),
                 ecit = callees.end(); cit!=ecit; cit++)
         {
             if(candidateFuncSet.find((*cit))!=candidateFuncSet.end())
@@ -276,7 +276,7 @@ public:
         return candidateFuncSet.find(fun)!=candidateFuncSet.end();
     }
     /// Whether two functions in the same callgraph scc
-    inline bool inSameCallGraphSCC(const CallGraphNode* src,const CallGraphNode* dst)
+    inline bool inSameCallGraphSCC(const PTACallGraphNode* src,const PTACallGraphNode* dst)
     {
         return (tcgSCC->repNode(src->getId()) == tcgSCC->repNode(dst->getId()));
     }
@@ -479,7 +479,7 @@ private:
     //@}
 
     /// Handle call relations
-    void handleCallRelation(CxtThreadProc& ctp, const CallGraphEdge* cgEdge, CallSite call);
+    void handleCallRelation(CxtThreadProc& ctp, const PTACallGraphEdge* cgEdge, CallSite call);
 
     /// Get or create a tct node based on CxtThread
     //@{

package/SVF-linux/Release-build/include/MemoryModel/PointerAnalysis.h

@@ -34,7 +34,7 @@
 #include <signal.h>
 
 #include "Graphs/CHG.h"
-#include "Graphs/CallGraph.h"
+#include "Graphs/PTACallGraph.h"
 #include "Graphs/SCC.h"
 #include "MemoryModel/AbstractPointsToDS.h"
 #include "MemoryModel/ConditionalPT.h"
@@ -103,7 +103,7 @@ public:
     typedef SVFIR::CallSiteToFunPtrMap CallSiteToFunPtrMap;
     typedef Set<const SVFFunction*> FunctionSet;
     typedef OrderedMap<const CallICFGNode*, FunctionSet> CallEdgeMap;
-    typedef SCCDetection<CallGraph*> CallGraphSCC;
+    typedef SCCDetection<PTACallGraph*> CallGraphSCC;
     typedef Set<const SVFGlobalValue*> VTableSet;
     typedef Set<const SVFFunction*> VFunSet;
     //@}
@@ -148,7 +148,7 @@ protected:
     /// Statistics
     PTAStat* stat;
     /// Call graph used for pointer analysis
-    CallGraph* callgraph;
+    PTACallGraph* ptaCallGraph;
     /// SCC for CallGraph
     CallGraphSCC* callGraphSCC;
     /// Interprocedural control-flow graph
@@ -165,12 +165,12 @@ public:
     /// Return number of resolved indirect call edges
     inline u32_t getNumOfResolvedIndCallEdge() const
     {
-        return getCallGraph()->getNumOfResolvedIndCallEdge();
+        return getPTACallGraph()->getNumOfResolvedIndCallEdge();
     }
     /// Return call graph
-    inline CallGraph* getCallGraph() const
+    inline PTACallGraph* getPTACallGraph() const
     {
-        return callgraph;
+        return ptaCallGraph;
     }
     /// Return call graph SCC
     inline CallGraphSCC* getCallGraphSCC() const
@@ -367,15 +367,15 @@ public:
     //@{
     inline CallEdgeMap& getIndCallMap()
     {
-        return getCallGraph()->getIndCallMap();
+        return getPTACallGraph()->getIndCallMap();
     }
     inline bool hasIndCSCallees(const CallICFGNode* cs) const
     {
-        return getCallGraph()->hasIndCSCallees(cs);
+        return getPTACallGraph()->hasIndCSCallees(cs);
     }
     inline const FunctionSet& getIndCSCallees(const CallICFGNode* cs) const
     {
-        return getCallGraph()->getIndCSCallees(cs);
+        return getPTACallGraph()->getIndCSCallees(cs);
     }
     //@}
 
@@ -388,7 +388,7 @@ public:
     inline void callGraphSCCDetection()
     {
         if(callGraphSCC==nullptr)
-            callGraphSCC = new CallGraphSCC(callgraph);
+            callGraphSCC = new CallGraphSCC(ptaCallGraph);
 
         callGraphSCC->find();
     }
@@ -400,13 +400,13 @@ public:
     /// Return TRUE if this edge is inside a CallGraph SCC, i.e., src node and dst node are in the same SCC on the SVFG.
     inline bool inSameCallGraphSCC(const SVFFunction* fun1,const SVFFunction* fun2)
     {
-        const CallGraphNode* src = callgraph->getCallGraphNode(fun1);
-        const CallGraphNode* dst = callgraph->getCallGraphNode(fun2);
+        const PTACallGraphNode* src = ptaCallGraph->getCallGraphNode(fun1);
+        const PTACallGraphNode* dst = ptaCallGraph->getCallGraphNode(fun2);
         return (getCallGraphSCCRepNode(src->getId()) == getCallGraphSCCRepNode(dst->getId()));
     }
     inline bool isInRecursion(const SVFFunction* fun) const
     {
-        return callGraphSCC->isInCycle(callgraph->getCallGraphNode(fun)->getId());
+        return callGraphSCC->isInCycle(ptaCallGraph->getCallGraphNode(fun)->getId());
     }
     /// Whether a local variable is in function recursions
     bool isLocalVarInRecursiveFun(NodeID id) const;

package/SVF-linux/Release-build/include/SABER/SaberSVFGBuilder.h

@@ -89,7 +89,7 @@ protected:
 
     /// Add actual parameter SVFGNode for 1st argument of a deallocation like external function
     /// In order to path sensitive leak detection
-    virtual void AddExtActualParmSVFGNodes(CallGraph* callgraph);
+    virtual void AddExtActualParmSVFGNodes(PTACallGraph* callgraph);
 
     /// Collect memory pointed global pointers,
     /// note that this collection is recursively performed, for example gp-->obj-->obj'

package/SVF-linux/Release-build/include/SABER/SrcSnkDDA.h

@@ -76,13 +76,13 @@ private:
 protected:
     SaberSVFGBuilder memSSA;
     SVFG* svfg;
-    CallGraph* callgraph;
+    PTACallGraph* ptaCallGraph;
     SVFBugReport report; /// Bug Reporter
 
 public:
 
     /// Constructor
-    SrcSnkDDA() : _curSlice(nullptr), svfg(nullptr), callgraph(nullptr)
+    SrcSnkDDA() : _curSlice(nullptr), svfg(nullptr), ptaCallGraph(nullptr)
     {
         saberCondAllocator = std::make_unique<SaberCondAllocator>();
     }
@@ -95,9 +95,9 @@ public:
         _curSlice = nullptr;
 
         /// the following shared by multiple checkers, thus can not be released.
-        //if (callgraph != nullptr)
-        //    delete callgraph;
-        //callgraph = nullptr;
+        //if (ptaCallGraph != nullptr)
+        //    delete ptaCallGraph;
+        //ptaCallGraph = nullptr;
 
         //if(pathCondAllocator)
         //    delete pathCondAllocator;
@@ -129,9 +129,9 @@ public:
     }
 
     /// Get Callgraph
-    inline CallGraph* getCallgraph() const
+    inline PTACallGraph* getCallgraph() const
     {
-        return callgraph;
+        return ptaCallGraph;
     }
 
     /// Whether this svfg node may access global variable

package/SVF-linux/Release-build/include/SVF-LLVM/SVFIRBuilder.h

@@ -201,7 +201,7 @@ public:
     //}@
 
     /// connect PAG edges based on callgraph
-    void updateCallGraph(CallGraph* callgraph);
+    void updateCallGraph(PTACallGraph* callgraph);
 
 protected:
     /// Handle globals including (global variable and functions)

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

@@ -31,7 +31,7 @@
 #ifndef INCLUDE_SVF_FE_CALLGRAPHBUILDER_H_
 #define INCLUDE_SVF_FE_CALLGRAPHBUILDER_H_
 
-#include "Graphs/CallGraph.h"
+#include "Graphs/PTACallGraph.h"
 #include "Graphs/ThreadCallGraph.h"
 
 namespace SVF
@@ -43,15 +43,15 @@ class CallGraphBuilder
 {
 
 protected:
-    CallGraph* callgraph;
+    PTACallGraph* callgraph;
     ICFG* icfg;
 public:
-    CallGraphBuilder(CallGraph* cg, ICFG* i): callgraph(cg),icfg(i)
+    CallGraphBuilder(PTACallGraph* cg, ICFG* i): callgraph(cg),icfg(i)
     {
     }
 
     /// Build normal callgraph
-    CallGraph* buildCallGraph(SVFModule* svfModule);
+    PTACallGraph* buildCallGraph(SVFModule* svfModule);
 
 };
 
@@ -64,7 +64,7 @@ public:
     }
 
     /// Build thread-aware callgraph
-    CallGraph* buildThreadCallGraph(SVFModule* svfModule);
+    PTACallGraph* buildThreadCallGraph(SVFModule* svfModule);
 
 };
 

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

@@ -111,7 +111,7 @@ class AbstractInterpretation
 
 public:
     enum ExtAPIType { UNCLASSIFIED, MEMCPY, MEMSET, STRCPY, STRCAT };
-    typedef SCCDetection<PTACallGraph*> CallGraphSCC;
+    typedef SCCDetection<CallGraph*> CallGraphSCC;
     /// Constructor
     AbstractInterpretation();