svf-tools 1.0.974 → 1.0.976

package/svf/include/MTA/LockAnalysis.h

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

package/svf/include/MTA/MHP.h

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

package/svf/include/MTA/PCG.h

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

package/svf/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 PTACallGraphNode*> PTACGNodeSet;
+    typedef Set<const CallGraphNode*> 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<PTACallGraph*> ThreadCallGraphSCC;
+    typedef SCCDetection<CallGraph*> ThreadCallGraphSCC;
 
     /// Constructor
     TCT(PointerAnalysis* p) :pta(p),TCTNodeNum(0),TCTEdgeNum(0),MaxCxtSize(0)
     {
-        tcg = SVFUtil::cast<ThreadCallGraph>(pta->getPTACallGraph());
+        tcg = SVFUtil::cast<ThreadCallGraph>(pta->getCallGraph());
         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 PTACallGraph::FunctionSet& callees) const
+    inline bool isCandidateFun(const CallGraph::FunctionSet& callees) const
     {
-        for(PTACallGraph::FunctionSet::const_iterator cit = callees.begin(),
+        for(CallGraph::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 PTACallGraphNode* src,const PTACallGraphNode* dst)
+    inline bool inSameCallGraphSCC(const CallGraphNode* src,const CallGraphNode* dst)
     {
         return (tcgSCC->repNode(src->getId()) == tcgSCC->repNode(dst->getId()));
     }
@@ -479,7 +479,7 @@ private:
     //@}
 
     /// Handle call relations
-    void handleCallRelation(CxtThreadProc& ctp, const PTACallGraphEdge* cgEdge, CallSite call);
+    void handleCallRelation(CxtThreadProc& ctp, const CallGraphEdge* cgEdge, CallSite call);
 
     /// Get or create a tct node based on CxtThread
     //@{

package/svf/include/MemoryModel/PointerAnalysis.h

@@ -34,7 +34,7 @@
 #include <signal.h>
 
 #include "Graphs/CHG.h"
-#include "Graphs/PTACallGraph.h"
+#include "Graphs/CallGraph.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<PTACallGraph*> CallGraphSCC;
+    typedef SCCDetection<CallGraph*> 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
-    PTACallGraph* ptaCallGraph;
+    CallGraph* callgraph;
     /// 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 getPTACallGraph()->getNumOfResolvedIndCallEdge();
+        return getCallGraph()->getNumOfResolvedIndCallEdge();
     }
     /// Return call graph
-    inline PTACallGraph* getPTACallGraph() const
+    inline CallGraph* getCallGraph() const
     {
-        return ptaCallGraph;
+        return callgraph;
     }
     /// Return call graph SCC
     inline CallGraphSCC* getCallGraphSCC() const
@@ -367,15 +367,15 @@ public:
     //@{
     inline CallEdgeMap& getIndCallMap()
     {
-        return getPTACallGraph()->getIndCallMap();
+        return getCallGraph()->getIndCallMap();
     }
     inline bool hasIndCSCallees(const CallICFGNode* cs) const
     {
-        return getPTACallGraph()->hasIndCSCallees(cs);
+        return getCallGraph()->hasIndCSCallees(cs);
     }
     inline const FunctionSet& getIndCSCallees(const CallICFGNode* cs) const
     {
-        return getPTACallGraph()->getIndCSCallees(cs);
+        return getCallGraph()->getIndCSCallees(cs);
     }
     //@}
 
@@ -388,7 +388,7 @@ public:
     inline void callGraphSCCDetection()
     {
         if(callGraphSCC==nullptr)
-            callGraphSCC = new CallGraphSCC(ptaCallGraph);
+            callGraphSCC = new CallGraphSCC(callgraph);
 
         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 PTACallGraphNode* src = ptaCallGraph->getCallGraphNode(fun1);
-        const PTACallGraphNode* dst = ptaCallGraph->getCallGraphNode(fun2);
+        const CallGraphNode* src = callgraph->getCallGraphNode(fun1);
+        const CallGraphNode* dst = callgraph->getCallGraphNode(fun2);
         return (getCallGraphSCCRepNode(src->getId()) == getCallGraphSCCRepNode(dst->getId()));
     }
     inline bool isInRecursion(const SVFFunction* fun) const
     {
-        return callGraphSCC->isInCycle(ptaCallGraph->getCallGraphNode(fun)->getId());
+        return callGraphSCC->isInCycle(callgraph->getCallGraphNode(fun)->getId());
     }
     /// Whether a local variable is in function recursions
     bool isLocalVarInRecursiveFun(NodeID id) const;

package/svf/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(PTACallGraph* callgraph);
+    virtual void AddExtActualParmSVFGNodes(CallGraph* callgraph);
 
     /// Collect memory pointed global pointers,
     /// note that this collection is recursively performed, for example gp-->obj-->obj'

package/svf/include/SABER/SrcSnkDDA.h

@@ -76,13 +76,13 @@ private:
 protected:
     SaberSVFGBuilder memSSA;
     SVFG* svfg;
-    PTACallGraph* ptaCallGraph;
+    CallGraph* callgraph;
     SVFBugReport report; /// Bug Reporter
 
 public:
 
     /// Constructor
-    SrcSnkDDA() : _curSlice(nullptr), svfg(nullptr), ptaCallGraph(nullptr)
+    SrcSnkDDA() : _curSlice(nullptr), svfg(nullptr), callgraph(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 (ptaCallGraph != nullptr)
-        //    delete ptaCallGraph;
-        //ptaCallGraph = nullptr;
+        //if (callgraph != nullptr)
+        //    delete callgraph;
+        //callgraph = nullptr;
 
         //if(pathCondAllocator)
         //    delete pathCondAllocator;
@@ -129,9 +129,9 @@ public:
     }
 
     /// Get Callgraph
-    inline PTACallGraph* getCallgraph() const
+    inline CallGraph* getCallgraph() const
     {
-        return ptaCallGraph;
+        return callgraph;
     }
 
     /// Whether this svfg node may access global variable

package/svf/include/Util/CallGraphBuilder.h

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

package/svf/lib/AE/Svfexe/AbstractInterpretation.cpp

@@ -131,7 +131,7 @@ void AbstractInterpretation::initWTO()
     // Detect if the call graph has cycles by finding its strongly connected components (SCC)
     Andersen::CallGraphSCC* callGraphScc = ander->getCallGraphSCC();
     callGraphScc->find();
-    auto callGraph = ander->getPTACallGraph();
+    auto callGraph = ander->getCallGraph();
 
     // Iterate through the call graph
     for (auto it = callGraph->begin(); it != callGraph->end(); it++)
@@ -167,10 +167,9 @@ void AbstractInterpretation::analyse()
 /// handle global node
 void AbstractInterpretation::handleGlobalNode()
 {
-    AbstractState as;
     const ICFGNode* node = _icfg->getGlobalICFGNode();
-    _postAbsTrace[node] = _preAbsTrace[node];
-    _postAbsTrace[node][SymbolTableInfo::NullPtr] = AddressValue();
+    _abstractTrace[node] = AbstractState();
+    _abstractTrace[node][SymbolTableInfo::NullPtr] = AddressValue();
     // Global Node, we just need to handle addr, load, store, copy and gep
     for (const SVFStmt *stmt: node->getSVFStmts())
     {
@@ -181,18 +180,18 @@ void AbstractInterpretation::handleGlobalNode()
 /// get execution state by merging states of predecessor blocks
 /// Scenario 1: preblock -----(intraEdge)----> block, join the preES of inEdges
 /// Scenario 2: preblock -----(callEdge)----> block
-bool AbstractInterpretation::mergeStatesFromPredecessors(const ICFGNode *block)
+bool AbstractInterpretation::mergeStatesFromPredecessors(const ICFGNode * icfgNode)
 {
     std::vector<AbstractState> workList;
-    AbstractState as;
-    for (auto& edge: block->getInEdges())
+    AbstractState preAs;
+    for (auto& edge: icfgNode->getInEdges())
     {
-        if (_postAbsTrace.find(edge->getSrcNode()) != _postAbsTrace.end())
+        if (_abstractTrace.find(edge->getSrcNode()) != _abstractTrace.end())
         {
             const IntraCFGEdge *intraCfgEdge = SVFUtil::dyn_cast<IntraCFGEdge>(edge);
             if (intraCfgEdge && intraCfgEdge->getCondition())
             {
-                AbstractState tmpEs = _postAbsTrace[edge->getSrcNode()];
+                AbstractState tmpEs = _abstractTrace[edge->getSrcNode()];
                 if (isBranchFeasible(intraCfgEdge, tmpEs))
                 {
                     workList.push_back(tmpEs);
@@ -204,7 +203,7 @@ bool AbstractInterpretation::mergeStatesFromPredecessors(const ICFGNode *block)
             }
             else
             {
-                workList.push_back(_postAbsTrace[edge->getSrcNode()]);
+                workList.push_back(_abstractTrace[edge->getSrcNode()]);
             }
         }
         else
@@ -212,7 +211,6 @@ bool AbstractInterpretation::mergeStatesFromPredecessors(const ICFGNode *block)
 
         }
     }
-    _preAbsTrace[block].clear();
     if (workList.size() == 0)
     {
         return false;
@@ -221,9 +219,12 @@ bool AbstractInterpretation::mergeStatesFromPredecessors(const ICFGNode *block)
     {
         while (!workList.empty())
         {
-            _preAbsTrace[block].joinWith(workList.back());
+            preAs.joinWith(workList.back());
             workList.pop_back();
         }
+        // Has ES on the in edges - Feasible block
+        // update post as
+        _abstractTrace[icfgNode] = preAs;
         return true;
     }
 }
@@ -526,20 +527,8 @@ bool AbstractInterpretation::isBranchFeasible(const IntraCFGEdge* intraEdge,
 /// handle instructions in svf basic blocks
 void AbstractInterpretation::handleSingletonWTO(const ICFGSingletonWTO *icfgSingletonWto)
 {
-    const ICFGNode* node = icfgSingletonWto->node();
+    const ICFGNode* node = icfgSingletonWto->getICFGNode();
     _stat->getBlockTrace()++;
-    // Get execution states from in edges
-    if (!mergeStatesFromPredecessors(node))
-    {
-        // No ES on the in edges - Infeasible block
-        return;
-    }
-    else
-    {
-        // Has ES on the in edges - Feasible block
-        // Get execution state from in edges
-        _postAbsTrace[node] = _preAbsTrace[node];
-    }
 
     std::deque<const ICFGNode*> worklist;
 
@@ -573,20 +562,27 @@ void AbstractInterpretation::handleWTOComponents(const std::list<const ICFGWTOCo
 {
     for (const ICFGWTOComp* wtoNode : wtoComps)
     {
-        if (const ICFGSingletonWTO* node = SVFUtil::dyn_cast<ICFGSingletonWTO>(wtoNode))
-        {
+        handleWTOComponent(wtoNode);
+    }
+}
+
+void AbstractInterpretation::handleWTOComponent(const SVF::ICFGWTOComp* wtoNode)
+{
+    if (const ICFGSingletonWTO* node = SVFUtil::dyn_cast<ICFGSingletonWTO>(wtoNode))
+    {
+        if (mergeStatesFromPredecessors(node->getICFGNode()))
             handleSingletonWTO(node);
-        }
-        // Handle WTO cycles
-        else if (const ICFGCycleWTO* cycle = SVFUtil::dyn_cast<ICFGCycleWTO>(wtoNode))
-        {
+    }
+    // Handle WTO cycles
+    else if (const ICFGCycleWTO* cycle = SVFUtil::dyn_cast<ICFGCycleWTO>(wtoNode))
+    {
+        if (mergeStatesFromPredecessors(cycle->head()->getICFGNode()))
             handleCycleWTO(cycle);
-        }
-        // Assert false for unknown WTO types
-        else
-        {
-            assert(false && "unknown WTO type!");
-        }
+    }
+    // Assert false for unknown WTO types
+    else
+    {
+        assert(false && "unknown WTO type!");
     }
 }
 
@@ -656,7 +652,7 @@ void AbstractInterpretation::recursiveCallPass(const SVF::CallICFGNode *callNode
             }
         }
     }
-    _postAbsTrace[retNode] = as;
+    _abstractTrace[retNode] = as;
 }
 
 bool AbstractInterpretation::isDirectCall(const SVF::CallICFGNode *callNode)
@@ -670,7 +666,7 @@ void AbstractInterpretation::directCallFunPass(const SVF::CallICFGNode *callNode
     const SVFFunction *callfun = SVFUtil::getCallee(callNode->getCallSite());
     _callSiteStack.push_back(callNode);
 
-    _postAbsTrace[callNode] = as;
+    _abstractTrace[callNode] = as;
 
     ICFGWTO* wto = _funcToWTO[callfun];
     handleWTOComponents(wto->getWTOComponents());
@@ -679,7 +675,7 @@ void AbstractInterpretation::directCallFunPass(const SVF::CallICFGNode *callNode
     // handle Ret node
     const RetICFGNode *retNode = callNode->getRetICFGNode();
     // resume ES to callnode
-    _postAbsTrace[retNode] = _postAbsTrace[callNode];
+    _abstractTrace[retNode] = _abstractTrace[callNode];
 }
 
 bool AbstractInterpretation::isIndirectCall(const SVF::CallICFGNode *callNode)
@@ -704,14 +700,14 @@ void AbstractInterpretation::indirectCallFunPass(const SVF::CallICFGNode *callNo
     if (callfun)
     {
         _callSiteStack.push_back(callNode);
-        _postAbsTrace[callNode] = as;
+        _abstractTrace[callNode] = as;
 
         ICFGWTO* wto = _funcToWTO[callfun];
         handleWTOComponents(wto->getWTOComponents());
         _callSiteStack.pop_back();
         // handle Ret node
         const RetICFGNode *retNode = callNode->getRetICFGNode();
-        _postAbsTrace[retNode] = _postAbsTrace[callNode];
+        _abstractTrace[retNode] = _abstractTrace[callNode];
     }
 }
 
@@ -720,54 +716,47 @@ void AbstractInterpretation::indirectCallFunPass(const SVF::CallICFGNode *callNo
 /// handle wto cycle (loop)
 void AbstractInterpretation::handleCycleWTO(const ICFGCycleWTO*cycle)
 {
-    // Get execution states from predecessor nodes
-    bool is_feasible = mergeStatesFromPredecessors(cycle->head()->node());
-    if (!is_feasible)
-        return;
-    else
-    {
-        const ICFGNode* cycle_head = cycle->head()->node();
-        // Flag to indicate if we are in the increasing phase
-        bool increasing = true;
-        // Infinite loop until a fixpoint is reached,
-        for (u32_t cur_iter = 0;; cur_iter++)
-        {
-            // Start widening or narrowing if cur_iter >= widen threshold (widen delay)
-            if (cur_iter >= Options::WidenDelay())
+    const ICFGNode* cycle_head = cycle->head()->getICFGNode();
+    // Flag to indicate if we are in the increasing phase
+    bool increasing = true;
+    // Infinite loop until a fixpoint is reached,
+    for (u32_t cur_iter = 0;; cur_iter++)
+    {
+        // Start widening or narrowing if cur_iter >= widen threshold (widen delay)
+        if (cur_iter >= Options::WidenDelay())
+        {
+            // Widen or narrow after processing cycle head node
+            AbstractState prev_head_state = _abstractTrace[cycle_head];
+            handleWTOComponent(cycle->head());
+            AbstractState cur_head_state = _abstractTrace[cycle_head];
+            if (increasing)
             {
-                // Widen or narrow after processing cycle head node
-                AbstractState prev_head_state = _postAbsTrace[cycle_head];
-                handleSingletonWTO(cycle->head());
-                AbstractState cur_head_state = _postAbsTrace[cycle_head];
-                if (increasing)
-                {
-                    // Widening phase
-                    _postAbsTrace[cycle_head] = prev_head_state.widening(cur_head_state);
-                    if (_postAbsTrace[cycle_head] == prev_head_state)
-                    {
-                        increasing = false;
-                        continue;
-                    }
-                }
-                else
+                // Widening phase
+                _abstractTrace[cycle_head] = prev_head_state.widening(cur_head_state);
+                if (_abstractTrace[cycle_head] == prev_head_state)
                 {
-                    // Widening's fixpoint reached in the widening phase, switch to narrowing
-                    _postAbsTrace[cycle_head] = prev_head_state.narrowing(cur_head_state);
-                    if (_postAbsTrace[cycle_head] == prev_head_state)
-                    {
-                        // Narrowing's fixpoint reached in the narrowing phase, exit loop
-                        break;
-                    }
+                    increasing = false;
+                    continue;
                 }
             }
             else
             {
-                // Handle the cycle head
-                handleSingletonWTO(cycle->head());
+                // Widening's fixpoint reached in the widening phase, switch to narrowing
+                _abstractTrace[cycle_head] = prev_head_state.narrowing(cur_head_state);
+                if (_abstractTrace[cycle_head] == prev_head_state)
+                {
+                    // Narrowing's fixpoint reached in the narrowing phase, exit loop
+                    break;
+                }
             }
-            // Handle the cycle body
-            handleWTOComponents(cycle->getWTOComponents());
         }
+        else
+        {
+            // Handle the cycle head
+            handleSingletonWTO(cycle->head());
+        }
+        // Handle the cycle body
+        handleWTOComponents(cycle->getWTOComponents());
     }
 }
 

package/svf/lib/CFL/CFLSVFGBuilder.cpp

@@ -50,7 +50,7 @@ void CFLSVFGBuilder::buildSVFG()
 
     DBOUT(DGENERAL, outs() << pasMsg("\tAdd Sink SVFG Nodes\n"));
 
-    AddExtActualParmSVFGNodes(pta->getPTACallGraph());
+    AddExtActualParmSVFGNodes(pta->getCallGraph());
 
     if(pta->printStat())
         svfg->performStat();

package/svf/lib/DDA/ContextDDA.cpp

@@ -63,7 +63,7 @@ void ContextDDA::initialize()
 {
     CondPTAImpl<ContextCond>::initialize();
     buildSVFG(pag);
-    setCallGraph(getPTACallGraph());
+    setCallGraph(getCallGraph());
     setCallGraphSCC(getCallGraphSCC());
     stat = setDDAStat(new DDAStat(this));
     flowDDA->initialize();
@@ -219,9 +219,9 @@ CallSiteID ContextDDA::getCSIDAtCall(CxtLocDPItem&, const SVFGEdge* edge)
     const CallICFGNode* cbn = getSVFG()->getCallSite(svfg_csId);
     const SVFFunction* callee = edge->getDstNode()->getFun();
 
-    if(getPTACallGraph()->hasCallSiteID(cbn,callee))
+    if(getCallGraph()->hasCallSiteID(cbn,callee))
     {
-        return getPTACallGraph()->getCallSiteID(cbn,callee);
+        return getCallGraph()->getCallSiteID(cbn,callee);
     }
 
     return 0;
@@ -243,9 +243,9 @@ CallSiteID ContextDDA::getCSIDAtRet(CxtLocDPItem&, const SVFGEdge* edge)
     const CallICFGNode* cbn = getSVFG()->getCallSite(svfg_csId);
     const SVFFunction* callee = edge->getSrcNode()->getFun();
 
-    if(getPTACallGraph()->hasCallSiteID(cbn,callee))
+    if(getCallGraph()->hasCallSiteID(cbn,callee))
     {
-        return getPTACallGraph()->getCallSiteID(cbn,callee);
+        return getCallGraph()->getCallSiteID(cbn,callee);
     }
 
     return 0;
@@ -265,8 +265,8 @@ bool ContextDDA::handleBKCondition(CxtLocDPItem& dpm, const SVFGEdge* edge)
 
             if(isEdgeInRecursion(csId))
             {
-                DBOUT(DDDA,outs() << "\t\t call edge " << getPTACallGraph()->getCallerOfCallSite(csId)->getName() <<
-                      "=>" << getPTACallGraph()->getCalleeOfCallSite(csId)->getName() << "in recursion \n");
+                DBOUT(DDDA,outs() << "\t\t call edge " << getCallGraph()->getCallerOfCallSite(csId)->getName() <<
+                      "=>" << getCallGraph()->getCalleeOfCallSite(csId)->getName() << "in recursion \n");
                 popRecursiveCallSites(dpm);
             }
             else
@@ -293,8 +293,8 @@ bool ContextDDA::handleBKCondition(CxtLocDPItem& dpm, const SVFGEdge* edge)
 
             if(isEdgeInRecursion(csId))
             {
-                DBOUT(DDDA,outs() << "\t\t return edge " << getPTACallGraph()->getCalleeOfCallSite(csId)->getName() <<
-                      "=>" << getPTACallGraph()->getCallerOfCallSite(csId)->getName() << "in recursion \n");
+                DBOUT(DDDA,outs() << "\t\t return edge " << getCallGraph()->getCalleeOfCallSite(csId)->getName() <<
+                      "=>" << getCallGraph()->getCallerOfCallSite(csId)->getName() << "in recursion \n");
                 popRecursiveCallSites(dpm);
             }
             else

package/svf/lib/DDA/DDAClient.cpp

@@ -115,7 +115,7 @@ void FunptrDDAClient::performStat(PointerAnalysis* pta)
         const PointsTo& ddaPts = pta->getPts(vtptr);
         const PointsTo& anderPts = ander->getPts(vtptr);
 
-        PTACallGraph* callgraph = ander->getPTACallGraph();
+        CallGraph* callgraph = ander->getCallGraph();
         const CallICFGNode* cbn = nIter->second;
 
         if(!callgraph->hasIndCSCallees(cbn))
@@ -124,7 +124,7 @@ void FunptrDDAClient::performStat(PointerAnalysis* pta)
             continue;
         }
 
-        const PTACallGraph::FunctionSet& callees = callgraph->getIndCSCallees(cbn);
+        const CallGraph::FunctionSet& callees = callgraph->getIndCSCallees(cbn);
         totalCallsites++;
         if(callees.size() == 0)
             zeroTargetCallsites++;
@@ -162,7 +162,7 @@ void FunptrDDAClient::performStat(PointerAnalysis* pta)
     outs() << "=================================================\n";
     outs() << "Total virtual callsites: " << vtableToCallSiteMap.size() << "\n";
     outs() << "Total analyzed virtual callsites: " << totalCallsites << "\n";
-    outs() << "Indirect call map size: " << ander->getPTACallGraph()->getIndCallMap().size() << "\n";
+    outs() << "Indirect call map size: " << ander->getCallGraph()->getIndCallMap().size() << "\n";
     outs() << "Precise callsites: " << morePreciseCallsites << "\n";
     outs() << "Zero target callsites: " << zeroTargetCallsites << "\n";
     outs() << "One target callsites: " << oneTargetCallsites << "\n";