svf-tools 1.0.975 → 1.0.976

package/svf/lib/MTA/LockAnalysis.cpp

@@ -97,12 +97,12 @@ void LockAnalysis::buildCandidateFuncSetforLock()
     ThreadCallGraph* tcg=tct->getThreadCallGraph();
 
     TCT::PTACGNodeSet visited;
-    FIFOWorkList<const PTACallGraphNode*> worklist;
+    FIFOWorkList<const CallGraphNode*> worklist;
 
     for (InstSet::iterator it = locksites.begin(), eit = locksites.end(); it != eit; ++it)
     {
         const SVFFunction* fun=(*it)->getParent()->getParent();
-        PTACallGraphNode* cgnode = tcg->getCallGraphNode(fun);
+        CallGraphNode* cgnode = tcg->getCallGraphNode(fun);
         if (visited.find(cgnode) == visited.end())
         {
             worklist.push(cgnode);
@@ -112,7 +112,7 @@ void LockAnalysis::buildCandidateFuncSetforLock()
     for (InstSet::iterator it = unlocksites.begin(), eit = unlocksites.end(); it != eit; ++it)
     {
         const SVFFunction* fun = (*it)->getParent()->getParent();
-        PTACallGraphNode* cgnode = tcg->getCallGraphNode(fun);
+        CallGraphNode* cgnode = tcg->getCallGraphNode(fun);
         if (visited.find(cgnode) == visited.end())
         {
             worklist.push(cgnode);
@@ -121,11 +121,11 @@ void LockAnalysis::buildCandidateFuncSetforLock()
     }
     while (!worklist.empty())
     {
-        const PTACallGraphNode* node = worklist.pop();
+        const CallGraphNode* node = worklist.pop();
         lockcandidateFuncSet.insert(node->getFunction());
-        for (PTACallGraphNode::const_iterator nit = node->InEdgeBegin(), neit = node->InEdgeEnd(); nit != neit; nit++)
+        for (CallGraphNode::const_iterator nit = node->InEdgeBegin(), neit = node->InEdgeEnd(); nit != neit; nit++)
         {
-            const PTACallGraphNode* srcNode = (*nit)->getSrcNode();
+            const CallGraphNode* srcNode = (*nit)->getSrcNode();
             if (visited.find(srcNode) == visited.end())
             {
                 visited.insert(srcNode);
@@ -266,16 +266,16 @@ void LockAnalysis::collectCxtLock()
     while (!clpList.empty())
     {
         CxtLockProc clp = popFromCTPWorkList();
-        PTACallGraphNode* cgNode = getTCG()->getCallGraphNode(clp.getProc());
+        CallGraphNode* cgNode = getTCG()->getCallGraphNode(clp.getProc());
         // lzh TODO.
         if (!isLockCandidateFun(cgNode->getFunction()))
             continue;
 
-        for (PTACallGraphNode::const_iterator nit = cgNode->OutEdgeBegin(), neit = cgNode->OutEdgeEnd(); nit != neit; nit++)
+        for (CallGraphNode::const_iterator nit = cgNode->OutEdgeBegin(), neit = cgNode->OutEdgeEnd(); nit != neit; nit++)
         {
-            const PTACallGraphEdge* cgEdge = (*nit);
+            const CallGraphEdge* cgEdge = (*nit);
 
-            for (PTACallGraphEdge::CallInstSet::const_iterator cit = cgEdge->directCallsBegin(), ecit = cgEdge->directCallsEnd();
+            for (CallGraphEdge::CallInstSet::const_iterator cit = cgEdge->directCallsBegin(), ecit = cgEdge->directCallsEnd();
                     cit != ecit; ++cit)
             {
                 DBOUT(DMTA,
@@ -283,7 +283,7 @@ void LockAnalysis::collectCxtLock()
                       << "-->" << cgEdge->getDstNode()->getFunction()->getName() << "\n");
                 handleCallRelation(clp, cgEdge, getSVFCallSite((*cit)->getCallSite()));
             }
-            for (PTACallGraphEdge::CallInstSet::const_iterator ind = cgEdge->indirectCallsBegin(), eind = cgEdge->indirectCallsEnd();
+            for (CallGraphEdge::CallInstSet::const_iterator ind = cgEdge->indirectCallsBegin(), eind = cgEdge->indirectCallsEnd();
                     ind != eind; ++ind)
             {
                 DBOUT(DMTA,
@@ -300,7 +300,7 @@ void LockAnalysis::collectCxtLock()
 /*!
  * Handling call relations when collecting context-sensitive locks
  */
-void LockAnalysis::handleCallRelation(CxtLockProc& clp, const PTACallGraphEdge* cgEdge, CallSite cs)
+void LockAnalysis::handleCallRelation(CxtLockProc& clp, const CallGraphEdge* cgEdge, CallSite cs)
 {
 
     CallStrCxt cxt(clp.getContext());
@@ -429,7 +429,7 @@ void LockAnalysis::handleCall(const CxtStmt& cts)
     CallICFGNode* cbn = tct->getCallICFGNode(call);
     if (getTCG()->hasCallGraphEdge(cbn))
     {
-        for (PTACallGraph::CallGraphEdgeSet::const_iterator cgIt = getTCG()->getCallEdgeBegin(cbn), ecgIt = getTCG()->getCallEdgeEnd(cbn);
+        for (CallGraph::CallGraphEdgeSet::const_iterator cgIt = getTCG()->getCallEdgeBegin(cbn), ecgIt = getTCG()->getCallEdgeEnd(cbn);
                 cgIt != ecgIt; ++cgIt)
         {
             const SVFFunction* svfcallee = (*cgIt)->getDstNode()->getFunction();
@@ -451,14 +451,14 @@ void LockAnalysis::handleRet(const CxtStmt& cts)
     const SVFInstruction* curInst = cts.getStmt();
     const CallStrCxt& curCxt = cts.getContext();
     const SVFFunction* svffun = curInst->getFunction();
-    PTACallGraphNode* curFunNode = getTCG()->getCallGraphNode(svffun);
+    CallGraphNode* curFunNode = getTCG()->getCallGraphNode(svffun);
 
-    for (PTACallGraphNode::const_iterator it = curFunNode->getInEdges().begin(), eit = curFunNode->getInEdges().end(); it != eit; ++it)
+    for (CallGraphNode::const_iterator it = curFunNode->getInEdges().begin(), eit = curFunNode->getInEdges().end(); it != eit; ++it)
     {
-        PTACallGraphEdge* edge = *it;
+        CallGraphEdge* edge = *it;
         if (SVFUtil::isa<ThreadForkEdge, ThreadJoinEdge>(edge))
             continue;
-        for (PTACallGraphEdge::CallInstSet::const_iterator cit = (edge)->directCallsBegin(), ecit = (edge)->directCallsEnd(); cit != ecit;
+        for (CallGraphEdge::CallInstSet::const_iterator cit = (edge)->directCallsBegin(), ecit = (edge)->directCallsEnd(); cit != ecit;
                 ++cit)
         {
             CallStrCxt newCxt = curCxt;
@@ -473,7 +473,7 @@ void LockAnalysis::handleRet(const CxtStmt& cts)
                 }
             }
         }
-        for (PTACallGraphEdge::CallInstSet::const_iterator cit = (edge)->indirectCallsBegin(), ecit = (edge)->indirectCallsEnd();
+        for (CallGraphEdge::CallInstSet::const_iterator cit = (edge)->indirectCallsBegin(), ecit = (edge)->indirectCallsEnd();
                 cit != ecit; ++cit)
         {
             CallStrCxt newCxt = curCxt;

package/svf/lib/MTA/MHP.cpp

@@ -115,7 +115,7 @@ void MHP::analyzeInterleaving()
                 else if (SVFUtil::isCallSite(curInst) && !isExtCall(curInst))
                 {
                     handleCall(cts, rootTid);
-                    PTACallGraph::FunctionSet callees;
+                    CallGraph::FunctionSet callees;
                     if (!tct->isCandidateFun(getCallee(curInst, callees)))
                         handleIntra(cts);
                 }
@@ -183,8 +183,8 @@ void MHP::handleNonCandidateFun(const CxtThreadStmt& cts)
     const SVFFunction* curfun = curInst->getParent()->getParent();
     assert((curInst == curfun->getEntryBlock()->front()) && "curInst is not the entry of non candidate function.");
     const CallStrCxt& curCxt = cts.getContext();
-    PTACallGraphNode* node = tcg->getCallGraphNode(curfun);
-    for (PTACallGraphNode::const_iterator nit = node->OutEdgeBegin(), neit = node->OutEdgeEnd(); nit != neit; nit++)
+    CallGraphNode* node = tcg->getCallGraphNode(curfun);
+    for (CallGraphNode::const_iterator nit = node->OutEdgeBegin(), neit = node->OutEdgeEnd(); nit != neit; nit++)
     {
         const SVFFunction* callee = (*nit)->getDstNode()->getFunction();
         if (!isExtCall(callee))
@@ -293,7 +293,7 @@ void MHP::handleCall(const CxtThreadStmt& cts, NodeID rootTid)
     CallICFGNode* cbn = getCBN(call);
     if (tct->getThreadCallGraph()->hasCallGraphEdge(cbn))
     {
-        for (PTACallGraph::CallGraphEdgeSet::const_iterator cgIt = tcg->getCallEdgeBegin(cbn),
+        for (CallGraph::CallGraphEdgeSet::const_iterator cgIt = tcg->getCallEdgeBegin(cbn),
                 ecgIt = tcg->getCallEdgeEnd(cbn);
                 cgIt != ecgIt; ++cgIt)
         {
@@ -315,12 +315,12 @@ void MHP::handleCall(const CxtThreadStmt& cts, NodeID rootTid)
  */
 void MHP::handleRet(const CxtThreadStmt& cts)
 {
-    PTACallGraphNode* curFunNode = tcg->getCallGraphNode(cts.getStmt()->getParent()->getParent());
-    for (PTACallGraphEdge* edge : curFunNode->getInEdges())
+    CallGraphNode* curFunNode = tcg->getCallGraphNode(cts.getStmt()->getParent()->getParent());
+    for (CallGraphEdge* edge : curFunNode->getInEdges())
     {
         if (SVFUtil::isa<ThreadForkEdge, ThreadJoinEdge>(edge))
             continue;
-        for (PTACallGraphEdge::CallInstSet::const_iterator cit = (edge)->directCallsBegin(),
+        for (CallGraphEdge::CallInstSet::const_iterator cit = (edge)->directCallsBegin(),
                 ecit = (edge)->directCallsEnd();
                 cit != ecit; ++cit)
         {
@@ -335,7 +335,7 @@ void MHP::handleRet(const CxtThreadStmt& cts)
                 }
             }
         }
-        for (PTACallGraphEdge::CallInstSet::const_iterator cit = (edge)->indirectCallsBegin(),
+        for (CallGraphEdge::CallInstSet::const_iterator cit = (edge)->indirectCallsBegin(),
                 ecit = (edge)->indirectCallsEnd();
                 cit != ecit; ++cit)
         {
@@ -508,19 +508,19 @@ bool MHP::isHBPair(NodeID tid1, NodeID tid2)
 
 bool MHP::isConnectedfromMain(const SVFFunction* fun)
 {
-    PTACallGraphNode* cgnode = tcg->getCallGraphNode(fun);
-    FIFOWorkList<const PTACallGraphNode*> worklist;
+    CallGraphNode* cgnode = tcg->getCallGraphNode(fun);
+    FIFOWorkList<const CallGraphNode*> worklist;
     TCT::PTACGNodeSet visited;
     worklist.push(cgnode);
     visited.insert(cgnode);
     while (!worklist.empty())
     {
-        const PTACallGraphNode* node = worklist.pop();
+        const CallGraphNode* node = worklist.pop();
         if ("main" == node->getFunction()->getName())
             return true;
-        for (PTACallGraphNode::const_iterator nit = node->InEdgeBegin(), neit = node->InEdgeEnd(); nit != neit; nit++)
+        for (CallGraphNode::const_iterator nit = node->InEdgeBegin(), neit = node->InEdgeEnd(); nit != neit; nit++)
         {
-            const PTACallGraphNode* srcNode = (*nit)->getSrcNode();
+            const CallGraphNode* srcNode = (*nit)->getSrcNode();
             if (visited.find(srcNode) == visited.end())
             {
                 visited.insert(srcNode);
@@ -733,7 +733,7 @@ void ForkJoinAnalysis::analyzeForkJoinPair()
                 DBOUT(DMTA, outs() << "-----\nForkJoinAnalysis root thread: " << tpair.first << " ");
                 DBOUT(DMTA, cts.dump());
                 DBOUT(DMTA, outs() << "-----\n");
-                PTACallGraph::FunctionSet callees;
+                CallGraph::FunctionSet callees;
                 if (isTDFork(curInst))
                 {
                     handleFork(cts, rootTid);
@@ -869,7 +869,7 @@ void ForkJoinAnalysis::handleCall(const CxtStmt& cts, NodeID rootTid)
     CallICFGNode* cbn = getCBN(call);
     if (getTCG()->hasCallGraphEdge(cbn))
     {
-        for (PTACallGraph::CallGraphEdgeSet::const_iterator cgIt = getTCG()->getCallEdgeBegin(cbn),
+        for (CallGraph::CallGraphEdgeSet::const_iterator cgIt = getTCG()->getCallEdgeBegin(cbn),
                 ecgIt = getTCG()->getCallEdgeEnd(cbn);
                 cgIt != ecgIt; ++cgIt)
         {
@@ -892,12 +892,12 @@ void ForkJoinAnalysis::handleRet(const CxtStmt& cts)
     const SVFInstruction* curInst = cts.getStmt();
     const CallStrCxt& curCxt = cts.getContext();
 
-    PTACallGraphNode* curFunNode = getTCG()->getCallGraphNode(curInst->getFunction());
-    for (PTACallGraphEdge* edge : curFunNode->getInEdges())
+    CallGraphNode* curFunNode = getTCG()->getCallGraphNode(curInst->getFunction());
+    for (CallGraphEdge* edge : curFunNode->getInEdges())
     {
         if (SVFUtil::isa<ThreadForkEdge, ThreadJoinEdge>(edge))
             continue;
-        for (PTACallGraphEdge::CallInstSet::const_iterator cit = edge->directCallsBegin(),
+        for (CallGraphEdge::CallInstSet::const_iterator cit = edge->directCallsBegin(),
                 ecit = edge->directCallsEnd();
                 cit != ecit; ++cit)
         {
@@ -912,7 +912,7 @@ void ForkJoinAnalysis::handleRet(const CxtStmt& cts)
                 }
             }
         }
-        for (PTACallGraphEdge::CallInstSet::const_iterator cit = edge->indirectCallsBegin(),
+        for (CallGraphEdge::CallInstSet::const_iterator cit = edge->indirectCallsBegin(),
                 ecit = edge->indirectCallsEnd();
                 cit != ecit; ++cit)
         {

package/svf/lib/MTA/MTA.cpp

@@ -124,7 +124,7 @@ MHP* MTA::computeMHP(SVFModule* module)
     DBOUT(DMTA, outs() << pasMsg("MTA analysis\n"));
     SVFIR* pag = PAG::getPAG();
     PointerAnalysis* pta = AndersenWaveDiff::createAndersenWaveDiff(pag);
-    pta->getPTACallGraph()->dump("ptacg");
+    pta->getCallGraph()->dump("ptacg");
 
     DBOUT(DGENERAL, outs() << pasMsg("Build TCT\n"));
     DBOUT(DMTA, outs() << pasMsg("Build TCT\n"));

package/svf/lib/MTA/PCG.cpp

@@ -49,7 +49,7 @@ using namespace SVFUtil;
 bool PCG::analyze()
 {
 
-    //callgraph = new PTACallGraph(mod);
+    //callgraph = new CallGraph(mod);
 
     DBOUT(DMTA, outs() << pasMsg("Starting MHP analysis\n"));
 
@@ -155,11 +155,11 @@ void PCG::collectSpawners()
     while (!worklist.empty())
     {
         const SVFFunction* svffun = worklist.pop();
-        PTACallGraphNode* funNode = callgraph->getCallGraphNode(svffun);
-        for (PTACallGraphNode::const_iterator it = funNode->InEdgeBegin(), eit = funNode->InEdgeEnd(); it != eit;
+        CallGraphNode* funNode = callgraph->getCallGraphNode(svffun);
+        for (CallGraphNode::const_iterator it = funNode->InEdgeBegin(), eit = funNode->InEdgeEnd(); it != eit;
                 ++it)
         {
-            PTACallGraphEdge* callEdge = (*it);
+            CallGraphEdge* callEdge = (*it);
             const SVFFunction* caller = callEdge->getSrcNode()->getFunction();
             if (isSpawnerFun(caller) == false)
             {
@@ -167,12 +167,12 @@ void PCG::collectSpawners()
                 addSpawnerFun(caller);
             }
             /// add all the callsites from callers to callee (spawner) as a spawn site.
-            for (PTACallGraphEdge::CallInstSet::const_iterator dit = callEdge->directCallsBegin(), deit =
+            for (CallGraphEdge::CallInstSet::const_iterator dit = callEdge->directCallsBegin(), deit =
                         callEdge->directCallsEnd(); dit != deit; ++dit)
             {
                 addSpawnsite((*dit)->getCallSite());
             }
-            for (PTACallGraphEdge::CallInstSet::const_iterator dit = callEdge->indirectCallsBegin(), deit =
+            for (CallGraphEdge::CallInstSet::const_iterator dit = callEdge->indirectCallsBegin(), deit =
                         callEdge->indirectCallsEnd(); dit != deit; ++dit)
             {
                 addSpawnsite((*dit)->getCallSite());
@@ -196,8 +196,8 @@ void PCG::collectSpawnees()
     while (!worklist.empty())
     {
         const SVFFunction* svffun = worklist.pop();
-        PTACallGraphNode* funNode = callgraph->getCallGraphNode(svffun);
-        for (PTACallGraphNode::const_iterator it = funNode->OutEdgeBegin(), eit = funNode->OutEdgeEnd(); it != eit;
+        CallGraphNode* funNode = callgraph->getCallGraphNode(svffun);
+        for (CallGraphNode::const_iterator it = funNode->OutEdgeBegin(), eit = funNode->OutEdgeEnd(); it != eit;
                 ++it)
         {
             const SVFFunction* caller = (*it)->getDstNode()->getFunction();
@@ -236,10 +236,10 @@ void PCG::identifyFollowers()
                     CallICFGNode* cbn = getCallICFGNode(inst);
                     if (callgraph->hasCallGraphEdge(cbn))
                     {
-                        for (PTACallGraph::CallGraphEdgeSet::const_iterator cgIt = callgraph->getCallEdgeBegin(cbn),
+                        for (CallGraph::CallGraphEdgeSet::const_iterator cgIt = callgraph->getCallEdgeBegin(cbn),
                                 ecgIt = callgraph->getCallEdgeEnd(cbn); cgIt != ecgIt; ++cgIt)
                         {
-                            const PTACallGraphEdge* edge = *cgIt;
+                            const CallGraphEdge* edge = *cgIt;
                             addFollowerFun(edge->getDstNode()->getFunction());
                         }
                     }
@@ -277,8 +277,8 @@ void PCG::collectFollowers()
     while (!worklist.empty())
     {
         const SVFFunction* svffun = worklist.pop();
-        PTACallGraphNode* funNode = callgraph->getCallGraphNode(svffun);
-        for (PTACallGraphNode::const_iterator it = funNode->OutEdgeBegin(), eit = funNode->OutEdgeEnd(); it != eit;
+        CallGraphNode* funNode = callgraph->getCallGraphNode(svffun);
+        for (CallGraphNode::const_iterator it = funNode->OutEdgeBegin(), eit = funNode->OutEdgeEnd(); it != eit;
                 ++it)
         {
             const SVFFunction* caller = (*it)->getDstNode()->getFunction();

package/svf/lib/MTA/TCT.cpp

@@ -54,16 +54,16 @@ bool TCT::isInLoopInstruction(const SVFInstruction* inst)
     {
         const SVFInstruction* inst = worklist.pop();
         insts.insert(inst);
-        PTACallGraphNode* cgnode = tcg->getCallGraphNode(inst->getFunction());
-        for(PTACallGraphNode::const_iterator nit = cgnode->InEdgeBegin(), neit = cgnode->InEdgeEnd(); nit!=neit; nit++)
+        CallGraphNode* cgnode = tcg->getCallGraphNode(inst->getFunction());
+        for(CallGraphNode::const_iterator nit = cgnode->InEdgeBegin(), neit = cgnode->InEdgeEnd(); nit!=neit; nit++)
         {
-            for(PTACallGraphEdge::CallInstSet::const_iterator cit = (*nit)->directCallsBegin(),
+            for(CallGraphEdge::CallInstSet::const_iterator cit = (*nit)->directCallsBegin(),
                     ecit = (*nit)->directCallsEnd(); cit!=ecit; ++cit)
             {
                 if(insts.insert((*cit)->getCallSite()).second)
                     worklist.push((*cit)->getCallSite());
             }
-            for(PTACallGraphEdge::CallInstSet::const_iterator cit = (*nit)->indirectCallsBegin(),
+            for(CallGraphEdge::CallInstSet::const_iterator cit = (*nit)->indirectCallsBegin(),
                     ecit = (*nit)->indirectCallsEnd(); cit!=ecit; ++cit)
             {
                 if(insts.insert((*cit)->getCallSite()).second)
@@ -102,18 +102,18 @@ bool TCT::isInRecursion(const SVFInstruction* inst) const
         if(tcgSCC->isInCycle(tcg->getCallGraphNode(svffun)->getId()))
             return true;
 
-        const PTACallGraphNode* cgnode = tcg->getCallGraphNode(svffun);
+        const CallGraphNode* cgnode = tcg->getCallGraphNode(svffun);
 
-        for(PTACallGraphNode::const_iterator nit = cgnode->InEdgeBegin(), neit = cgnode->InEdgeEnd(); nit!=neit; nit++)
+        for(CallGraphNode::const_iterator nit = cgnode->InEdgeBegin(), neit = cgnode->InEdgeEnd(); nit!=neit; nit++)
         {
-            for(PTACallGraphEdge::CallInstSet::const_iterator cit = (*nit)->directCallsBegin(),
+            for(CallGraphEdge::CallInstSet::const_iterator cit = (*nit)->directCallsBegin(),
                     ecit = (*nit)->directCallsEnd(); cit!=ecit; ++cit)
             {
                 const SVFFunction* caller = (*cit)->getCallSite()->getFunction();
                 if(visits.find(caller)==visits.end())
                     worklist.push(caller);
             }
-            for(PTACallGraphEdge::CallInstSet::const_iterator cit = (*nit)->indirectCallsBegin(),
+            for(CallGraphEdge::CallInstSet::const_iterator cit = (*nit)->indirectCallsBegin(),
                     ecit = (*nit)->indirectCallsEnd(); cit!=ecit; ++cit)
             {
                 const SVFFunction* caller = (*cit)->getCallSite()->getFunction();
@@ -139,7 +139,7 @@ void TCT::markRelProcs()
 
         for(ThreadCallGraph::ForkEdgeSet::const_iterator nit = tcg->getForkEdgeBegin(*it), neit = tcg->getForkEdgeEnd(*it); nit!=neit; nit++)
         {
-            const PTACallGraphNode* forkeeNode = (*nit)->getDstNode();
+            const CallGraphNode* forkeeNode = (*nit)->getDstNode();
             candidateFuncSet.insert(forkeeNode->getFunction());
         }
 
@@ -160,18 +160,18 @@ void TCT::markRelProcs()
  */
 void TCT::markRelProcs(const SVFFunction* svffun)
 {
-    PTACallGraphNode* cgnode = tcg->getCallGraphNode(svffun);
-    FIFOWorkList<const PTACallGraphNode*> worklist;
+    CallGraphNode* cgnode = tcg->getCallGraphNode(svffun);
+    FIFOWorkList<const CallGraphNode*> worklist;
     PTACGNodeSet visited;
     worklist.push(cgnode);
     visited.insert(cgnode);
     while(!worklist.empty())
     {
-        const PTACallGraphNode* node = worklist.pop();
+        const CallGraphNode* node = worklist.pop();
         candidateFuncSet.insert(node->getFunction());
-        for(PTACallGraphNode::const_iterator nit = node->InEdgeBegin(), neit = node->InEdgeEnd(); nit!=neit; nit++)
+        for(CallGraphNode::const_iterator nit = node->InEdgeBegin(), neit = node->InEdgeEnd(); nit!=neit; nit++)
         {
-            const PTACallGraphNode* srcNode = (*nit)->getSrcNode();
+            const CallGraphNode* srcNode = (*nit)->getSrcNode();
             if(visited.find(srcNode)==visited.end())
             {
                 visited.insert(srcNode);
@@ -191,7 +191,7 @@ void TCT::collectEntryFunInCallGraph()
         const SVFFunction* fun = (*it);
         if (isExtCall(fun))
             continue;
-        PTACallGraphNode* node = tcg->getCallGraphNode(fun);
+        CallGraphNode* node = tcg->getCallGraphNode(fun);
         if (!node->hasIncomingEdge())
         {
             entryFuncSet.insert(fun);
@@ -241,7 +241,7 @@ void TCT::collectMultiForkedThreads()
 /*!
  * Handle call relations
  */
-void TCT::handleCallRelation(CxtThreadProc& ctp, const PTACallGraphEdge* cgEdge, CallSite cs)
+void TCT::handleCallRelation(CxtThreadProc& ctp, const CallGraphEdge* cgEdge, CallSite cs)
 {
     const SVFFunction* callee = cgEdge->getDstNode()->getFunction();
 
@@ -249,7 +249,7 @@ void TCT::handleCallRelation(CxtThreadProc& ctp, const PTACallGraphEdge* cgEdge,
     CallStrCxt oldCxt = cxt;
     pushCxt(cxt,cs.getInstruction(),callee);
 
-    if(cgEdge->getEdgeKind() == PTACallGraphEdge::CallRetEdge)
+    if(cgEdge->getEdgeKind() == CallGraphEdge::CallRetEdge)
     {
         CxtThreadProc newctp(ctp.getTid(),cxt,callee);
         if(pushToCTPWorkList(newctp))
@@ -259,7 +259,7 @@ void TCT::handleCallRelation(CxtThreadProc& ctp, const PTACallGraphEdge* cgEdge,
         }
     }
 
-    else if(cgEdge->getEdgeKind() == PTACallGraphEdge::TDForkEdge)
+    else if(cgEdge->getEdgeKind() == CallGraphEdge::TDForkEdge)
     {
         /// Create spawnee TCT node
         TCTNode* spawneeNode = getOrCreateTCTNode(cxt,cs.getInstruction(), oldCxt, callee);
@@ -404,21 +404,21 @@ void TCT::build()
     while(!ctpList.empty())
     {
         CxtThreadProc ctp = popFromCTPWorkList();
-        PTACallGraphNode* cgNode = tcg->getCallGraphNode(ctp.getProc());
+        CallGraphNode* cgNode = tcg->getCallGraphNode(ctp.getProc());
         if(isCandidateFun(cgNode->getFunction()) == false)
             continue;
 
-        for(PTACallGraphNode::const_iterator nit = cgNode->OutEdgeBegin(), neit = cgNode->OutEdgeEnd(); nit!=neit; nit++)
+        for(CallGraphNode::const_iterator nit = cgNode->OutEdgeBegin(), neit = cgNode->OutEdgeEnd(); nit!=neit; nit++)
         {
-            const PTACallGraphEdge* cgEdge = (*nit);
+            const CallGraphEdge* cgEdge = (*nit);
 
-            for(PTACallGraphEdge::CallInstSet::const_iterator cit = cgEdge->directCallsBegin(),
+            for(CallGraphEdge::CallInstSet::const_iterator cit = cgEdge->directCallsBegin(),
                     ecit = cgEdge->directCallsEnd(); cit!=ecit; ++cit)
             {
                 DBOUT(DMTA,outs() << "\nTCT handling direct call:" << **cit << "\t" << cgEdge->getSrcNode()->getFunction()->getName() << "-->" << cgEdge->getDstNode()->getFunction()->getName() << "\n");
                 handleCallRelation(ctp,cgEdge,getSVFCallSite((*cit)->getCallSite()));
             }
-            for(PTACallGraphEdge::CallInstSet::const_iterator ind = cgEdge->indirectCallsBegin(),
+            for(CallGraphEdge::CallInstSet::const_iterator ind = cgEdge->indirectCallsBegin(),
                     eind = cgEdge->indirectCallsEnd(); ind!=eind; ++ind)
             {
                 DBOUT(DMTA,outs() << "\nTCT handling indirect call:" << **ind << "\t" << cgEdge->getSrcNode()->getFunction()->getName() << "-->" << cgEdge->getDstNode()->getFunction()->getName() << "\n");

package/svf/lib/MemoryModel/PointerAnalysis.cpp

@@ -66,7 +66,7 @@ const std::string PointerAnalysis::aliasTestFailNoAliasMangled  = "_Z20EXPECTEDF
  * Constructor
  */
 PointerAnalysis::PointerAnalysis(SVFIR* p, PTATY ty, bool alias_check) :
-    svfMod(nullptr),ptaTy(ty),stat(nullptr),ptaCallGraph(nullptr),callGraphSCC(nullptr),icfg(nullptr),chgraph(nullptr)
+    svfMod(nullptr),ptaTy(ty),stat(nullptr),callgraph(nullptr),callGraphSCC(nullptr),icfg(nullptr),chgraph(nullptr)
 {
     pag = p;
     OnTheFlyIterBudgetForStat = Options::StatBudget();
@@ -88,8 +88,8 @@ PointerAnalysis::~PointerAnalysis()
 
 void PointerAnalysis::destroy()
 {
-    delete ptaCallGraph;
-    ptaCallGraph = nullptr;
+    delete callgraph;
+    callgraph = nullptr;
 
     delete callGraphSCC;
     callGraphSCC = nullptr;
@@ -113,19 +113,19 @@ void PointerAnalysis::initialize()
     {
         ThreadCallGraph* cg = new ThreadCallGraph();
         ThreadCallGraphBuilder bd(cg, pag->getICFG());
-        ptaCallGraph = bd.buildThreadCallGraph(pag->getModule());
+        callgraph = bd.buildThreadCallGraph(pag->getModule());
     }
     else
     {
-        PTACallGraph* cg = new PTACallGraph();
+        CallGraph* cg = new CallGraph();
         CallGraphBuilder bd(cg,pag->getICFG());
-        ptaCallGraph = bd.buildCallGraph(pag->getModule());
+        callgraph = bd.buildCallGraph(pag->getModule());
     }
     callGraphSCCDetection();
 
     // dump callgraph
     if (Options::CallGraphDotGraph())
-        getPTACallGraph()->dump("callgraph_initial");
+        getCallGraph()->dump("callgraph_initial");
 }
 
 
@@ -140,7 +140,7 @@ bool PointerAnalysis::isLocalVarInRecursiveFun(NodeID id) const
     {
         if(const SVFFunction* svffun = pag->getGNode(id)->getFunction())
         {
-            return callGraphSCC->isInCycle(getPTACallGraph()->getCallGraphNode(svffun)->getId());
+            return callGraphSCC->isInCycle(getCallGraph()->getCallGraphNode(svffun)->getId());
         }
     }
     return false;
@@ -198,10 +198,10 @@ void PointerAnalysis::finalize()
     if (Options::FuncPointerPrint())
         printIndCSTargets();
 
-    getPTACallGraph()->verifyCallGraph();
+    getCallGraph()->verifyCallGraph();
 
     if (Options::CallGraphDotGraph())
-        getPTACallGraph()->dump("callgraph_final");
+        getCallGraph()->dump("callgraph_final");
 
     if(!pag->isBuiltFromFile() && alias_validation)
         validateTests();
@@ -412,7 +412,7 @@ void PointerAnalysis::resolveIndCalls(const CallICFGNode* cs, const PointsTo& ta
                     newEdges[cs].insert(callee);
                     getIndCallMap()[cs].insert(callee);
 
-                    ptaCallGraph->addIndirectCallGraphEdge(cs, cs->getCaller(), callee);
+                    callgraph->addIndirectCallGraphEdge(cs, cs->getCaller(), callee);
                     // FIXME: do we need to update llvm call graph here?
                     // The indirect call is maintained by ourself, We may update llvm's when we need to
                     //CallGraphNode* callgraphNode = callgraph->getOrInsertFunction(cs.getCaller());
@@ -477,7 +477,7 @@ void PointerAnalysis::connectVCallToVFns(const CallICFGNode* cs, const VFunSet &
             newEdges[cs].insert(callee);
             getIndCallMap()[cs].insert(callee);
             const CallICFGNode* callBlockNode = pag->getICFG()->getCallICFGNode(cs->getCallSite());
-            ptaCallGraph->addIndirectCallGraphEdge(callBlockNode, cs->getCaller(),callee);
+            callgraph->addIndirectCallGraphEdge(callBlockNode, cs->getCaller(),callee);
         }
     }
 }

package/svf/lib/SABER/LeakChecker.cpp

@@ -52,9 +52,9 @@ void LeakChecker::initSrcs()
         if(cs->getCallSite()->ptrInUncalledFunction() || !cs->getCallSite()->getType()->isPointerTy())
             continue;
 
-        PTACallGraph::FunctionSet callees;
+        CallGraph::FunctionSet callees;
         getCallgraph()->getCallees(cs->getCallICFGNode(),callees);
-        for(PTACallGraph::FunctionSet::const_iterator cit = callees.begin(), ecit = callees.end(); cit!=ecit; cit++)
+        for(CallGraph::FunctionSet::const_iterator cit = callees.begin(), ecit = callees.end(); cit!=ecit; cit++)
         {
             const SVFFunction* fun = *cit;
             if (isSourceLikeFun(fun))
@@ -112,9 +112,9 @@ void LeakChecker::initSnks()
             eit = pag->getCallSiteArgsMap().end(); it!=eit; ++it)
     {
 
-        PTACallGraph::FunctionSet callees;
+        CallGraph::FunctionSet callees;
         getCallgraph()->getCallees(it->first,callees);
-        for(PTACallGraph::FunctionSet::const_iterator cit = callees.begin(), ecit = callees.end(); cit!=ecit; cit++)
+        for(CallGraph::FunctionSet::const_iterator cit = callees.begin(), ecit = callees.end(); cit!=ecit; cit++)
         {
             const SVFFunction* fun = *cit;
             if (isSinkLikeFun(fun))

package/svf/lib/SABER/SaberSVFGBuilder.cpp

@@ -57,7 +57,7 @@ void SaberSVFGBuilder::buildSVFG()
 
     DBOUT(DGENERAL, outs() << pasMsg("\tAdd Sink SVFG Nodes\n"));
 
-    AddExtActualParmSVFGNodes(pta->getPTACallGraph());
+    AddExtActualParmSVFGNodes(pta->getCallGraph());
 
     if(pta->printStat())
         svfg->performStat();
@@ -291,15 +291,15 @@ void SaberSVFGBuilder::rmIncomingEdgeForSUStore(BVDataPTAImpl* pta)
 
 
 /// Add actual parameter SVFGNode for 1st argument of a deallocation like external function
-void SaberSVFGBuilder::AddExtActualParmSVFGNodes(PTACallGraph* callgraph)
+void SaberSVFGBuilder::AddExtActualParmSVFGNodes(CallGraph* callgraph)
 {
     SVFIR* pag = SVFIR::getPAG();
     for(SVFIR::CSToArgsListMap::iterator it = pag->getCallSiteArgsMap().begin(),
             eit = pag->getCallSiteArgsMap().end(); it!=eit; ++it)
     {
-        PTACallGraph::FunctionSet callees;
+        CallGraph::FunctionSet callees;
         callgraph->getCallees(it->first, callees);
-        for (PTACallGraph::FunctionSet::const_iterator cit = callees.begin(),
+        for (CallGraph::FunctionSet::const_iterator cit = callees.begin(),
                 ecit = callees.end(); cit != ecit; cit++)
         {
 

package/svf/lib/SABER/SrcSnkDDA.cpp

@@ -49,7 +49,7 @@ void SrcSnkDDA::initialize(SVFModule* module)
     else
         svfg =  memSSA.buildPTROnlySVFG(ander);
     setGraph(memSSA.getSVFG());
-    ptaCallGraph = ander->getPTACallGraph();
+    callgraph = ander->getCallGraph();
     //AndersenWaveDiff::releaseAndersenWaveDiff();
     /// allocate control-flow graph branch conditions
     getSaberCondAllocator()->allocate(getPAG()->getModule());

package/svf/lib/Util/CallGraphBuilder.cpp

@@ -35,7 +35,7 @@
 using namespace SVF;
 using namespace SVFUtil;
 
-PTACallGraph* CallGraphBuilder::buildCallGraph(SVFModule* svfModule)
+CallGraph* CallGraphBuilder::buildCallGraph(SVFModule* svfModule)
 {
     /// create nodes
     for (SVFModule::const_iterator F = svfModule->begin(), E = svfModule->end(); F != E; ++F)
@@ -65,7 +65,7 @@ PTACallGraph* CallGraphBuilder::buildCallGraph(SVFModule* svfModule)
     return callgraph;
 }
 
-PTACallGraph* ThreadCallGraphBuilder::buildThreadCallGraph(SVFModule* svfModule)
+CallGraph* ThreadCallGraphBuilder::buildThreadCallGraph(SVFModule* svfModule)
 {
 
     buildCallGraph(svfModule);