svf-tools 1.0.977 → 1.0.978

package/svf/lib/MTA/MTA.cpp

@@ -35,7 +35,6 @@
 #include "MTA/LockAnalysis.h"
 #include "MTA/MTAStat.h"
 #include "WPA/Andersen.h"
-#include "MTA/FSMPTA.h"
 #include "Util/SVFUtil.h"
 
 using namespace SVF;
@@ -66,43 +65,6 @@ bool MTA::runOnModule(SVFIR* pag)
 
     if(Options::RaceCheck())
         detect(pag->getModule());
-    /*
-    if (Options::AndersenAnno()) {
-        pta = mhp->getTCT()->getPTA();
-        if (pta->printStat())
-            stat->performMHPPairStat(mhp,lsa);
-        AndersenWaveDiff::releaseAndersenWaveDiff();
-    } else if (Options::FSAnno()) {
-
-        reportMemoryUsageKB("Mem before analysis");
-        DBOUT(DGENERAL, outs() << pasMsg("FSMPTA analysis\n"));
-        DBOUT(DMTA, outs() << pasMsg("FSMPTA analysis\n"));
-
-        DOTIMESTAT(double ptStart = stat->getClk());
-        pta = FSMPTA::createFSMPTA(module, mhp,lsa);
-        DOTIMESTAT(double ptEnd = stat->getClk());
-        DOTIMESTAT(stat->FSMPTATime += (ptEnd - ptStart) / TIMEINTERVAL);
-
-        reportMemoryUsageKB("Mem after analysis");
-
-        if (pta->printStat())
-            stat->performMHPPairStat(mhp,lsa);
-
-        FSMPTA::releaseFSMPTA();
-    }
-
-    if (DoInstrumentation) {
-        DBOUT(DGENERAL, outs() << pasMsg("ThreadSanitizer Instrumentation\n"));
-        DBOUT(DMTA, outs() << pasMsg("ThreadSanitizer Instrumentation\n"));
-        TSan tsan;
-        tsan.doInitialization(*pta->getModule());
-        for (Module::iterator it = pta->getModule()->begin(), eit = pta->getModule()->end(); it != eit; ++it) {
-            tsan.runOnFunction(*it);
-        }
-        if (pta->printStat())
-            PrintStatistics();
-    }
-    */
 
     return false;
 }
@@ -124,7 +86,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"));
@@ -205,8 +167,8 @@ void MTA::detect(SVFModule* module)
             const StoreStmt* store = *sit;
             if(load->getInst()==nullptr || store->getInst()==nullptr)
                 continue;
-            if(mhp->mayHappenInParallelInst(load->getInst(),store->getInst()) && pta->alias(load->getRHSVarID(),store->getLHSVarID()))
-                if(lsa->isProtectedByCommonLock(load->getInst(),store->getInst()) == false)
+            if(mhp->mayHappenInParallelInst(load->getICFGNode(),store->getICFGNode()) && pta->alias(load->getRHSVarID(),store->getLHSVarID()))
+                if(lsa->isProtectedByCommonLock(load->getICFGNode(),store->getICFGNode()) == false)
                     outs() << SVFUtil::bugMsg1("race pair(") << " store: " << store->toString() << ", load: " << load->toString() << SVFUtil::bugMsg1(")") << "\n";
         }
     }

package/svf/lib/MTA/MTAStat.cpp

@@ -32,7 +32,6 @@
 #include "MTA/TCT.h"
 #include "MTA/MHP.h"
 #include "MTA/LockAnalysis.h"
-#include "MTA/FSMPTA.h"
 #include "Graphs/ThreadCallGraph.h"
 
 using namespace SVF;
@@ -115,8 +114,8 @@ void MTAStat::performMHPPairStat(MHP* mhp, LockAnalysis* lsa)
     SVFIR* pag = SVFIR::getPAG();
     if(Options::AllPairMHP())
     {
-        Set<const SVFInstruction*> instSet1;
-        Set<const SVFInstruction*> instSet2;
+        Set<const ICFGNode*> instSet1;
+        Set<const ICFGNode*> instSet2;
         SVFModule* mod = mhp->getTCT()->getSVFModule();
         for (const SVFFunction* fun : mod->getFunctionSet())
         {
@@ -134,12 +133,12 @@ void MTAStat::performMHPPairStat(MHP* mhp, LockAnalysis* lsa)
                     {
                         if(SVFUtil::isa<LoadStmt>(stmt))
                         {
-                            instSet1.insert(inst);
+                            instSet1.insert(stmt->getICFGNode());
                         }
                         else if(SVFUtil::isa<StoreStmt>(stmt))
                         {
-                            instSet1.insert(inst);
-                            instSet2.insert(inst);
+                            instSet1.insert(stmt->getICFGNode());
+                            instSet2.insert(stmt->getICFGNode());
                         }
                     }
 
@@ -148,9 +147,9 @@ void MTAStat::performMHPPairStat(MHP* mhp, LockAnalysis* lsa)
         }
 
 
-        for(Set<const SVFInstruction*>::const_iterator it1 = instSet1.begin(), eit1 = instSet1.end(); it1!=eit1; ++it1)
+        for(Set<const ICFGNode*>::const_iterator it1 = instSet1.begin(), eit1 = instSet1.end(); it1!=eit1; ++it1)
         {
-            for(Set<const SVFInstruction*>::const_iterator it2 = instSet2.begin(), eit2 = instSet2.end(); it2!=eit2; ++it2)
+            for(Set<const ICFGNode*>::const_iterator it2 = instSet2.begin(), eit2 = instSet2.end(); it2!=eit2; ++it2)
             {
                 mhp->mayHappenInParallel(*it1,*it2);
             }
@@ -166,38 +165,13 @@ void MTAStat::performMHPPairStat(MHP* mhp, LockAnalysis* lsa)
     PTNumStatMap["TotalLockQueries"] = lsa->numOfTotalQueries;
     PTNumStatMap["NumOfLockedPairs"] = lsa->numOfLockedQueries;
     PTNumStatMap["NumOfCxtLocks"] = lsa->getNumOfCxtLocks();
-    PTNumStatMap["NumOfNewSVFGEdges"] = MTASVFGBuilder::numOfNewSVFGEdges;
-    PTNumStatMap["NumOfRemovedEdges"] = MTASVFGBuilder::numOfRemovedSVFGEdges;
-    PTNumStatMap["NumOfRemovedPTS"] = MTASVFGBuilder::numOfRemovedPTS;
     timeStatMap["InterlevAnaTime"] = mhp->interleavingTime;
     timeStatMap["LockAnaTime"] = lsa->lockTime;
     timeStatMap["InterlevQueryTime"] = mhp->interleavingQueriesTime;
     timeStatMap["LockQueryTime"] = lsa->lockQueriesTime;
     timeStatMap["MHPAnalysisTime"] = MHPTime;
-    timeStatMap["MFSPTATime"] = FSMPTATime;
 
     SVFUtil::outs() << "\n****MHP Stmt Pairs Statistics****\n";
     PTAStat::printStat();
 }
 
-// void MTAStat::performAnnotationStat(MTAAnnotator* anno)
-// {
-
-//     PTNumStatMap.clear();
-//     timeStatMap.clear();
-//     PTNumStatMap["TotalNumOfStore"] = anno->numOfAllSt;
-//     PTNumStatMap["TotalNumOfLoad"] = anno->numOfAllLd;
-//     PTNumStatMap["NumOfNonLocalStore"] = anno->numOfNonLocalSt;
-//     PTNumStatMap["NumOfNonLocalLoad"] = anno->numOfNonLocalLd;
-//     PTNumStatMap["NumOfAliasStore"] = anno->numOfAliasSt;
-//     PTNumStatMap["NumOfAliasLoad"] = anno->numOfAliasLd;
-//     PTNumStatMap["NumOfMHPStore"] = anno->numOfMHPSt;
-//     PTNumStatMap["NumOfMHPLoad"] = anno->numOfMHPLd;
-//     PTNumStatMap["NumOfAnnotatedStore"] = anno->numOfAnnotatedSt;
-//     PTNumStatMap["NumOfAnnotatedLoad"] = anno->numOfAnnotatedLd;
-//     timeStatMap["AnnotationTime"] = AnnotationTime;
-
-//     SVFUtil::outs() << "\n****Annotation Statistics****\n";
-//     PTAStat::printStat();
-// }
-

package/svf/lib/MTA/TCT.cpp

@@ -42,40 +42,39 @@ using namespace SVFUtil;
  * (1) the instruction i itself
  * (2) all the callsites invoke the function where i resides in
  */
-bool TCT::isInLoopInstruction(const SVFInstruction* inst)
+bool TCT::isInLoopInstruction(const ICFGNode* inst)
 {
     assert(inst && "null value instruction!!");
 
-    InstSet insts;
-    FIFOWorkList<const SVFInstruction*> worklist;
+    Set<const ICFGNode*> insts;
+    FIFOWorkList<const ICFGNode*> worklist;
     worklist.push(inst);
 
     while(!worklist.empty())
     {
-        const SVFInstruction* inst = worklist.pop();
+        const ICFGNode* 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->getFun());
+        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());
+                if(insts.insert(*cit).second)
+                    worklist.push(*cit);
             }
-            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)
-                    worklist.push((*cit)->getCallSite());
+                if(insts.insert(*cit).second)
+                    worklist.push(*cit);
             }
         }
     }
 
-    for(InstSet::const_iterator it = insts.begin(), eit = insts.end(); it!=eit; ++it)
+    for(const ICFGNode* i : insts)
     {
-        const SVFInstruction* i = *it;
-        if(i->getFunction()->hasLoopInfo(i->getParent()))
+        if(i->getFun()->hasLoopInfo(i->getBB()))
             return true;
     }
 
@@ -88,9 +87,9 @@ bool TCT::isInLoopInstruction(const SVFInstruction* inst)
  * (1) the function f where i resides in is in a recursion
  * (2) any caller function starting from the function f in is in a recursion
  */
-bool TCT::isInRecursion(const SVFInstruction* inst) const
+bool TCT::isInRecursion(const ICFGNode* inst) const
 {
-    const SVFFunction* f = inst->getFunction();
+    const SVFFunction* f = inst->getFun();
     FIFOWorkList<const SVFFunction*> worklist;
     Set<const SVFFunction*> visits;
     worklist.push(f);
@@ -102,18 +101,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 +138,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 +159,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);
@@ -189,9 +188,9 @@ void TCT::collectEntryFunInCallGraph()
     for(SVFModule::const_iterator it = getSVFModule()->begin(), eit = getSVFModule()->end(); it!=eit; ++it)
     {
         const SVFFunction* fun = (*it);
-        if (isExtCall(fun))
+        if (SVFUtil::isExtCall(fun))
             continue;
-        PTACallGraphNode* node = tcg->getCallGraphNode(fun);
+        CallGraphNode* node = tcg->getCallGraphNode(fun);
         if (!node->hasIncomingEdge())
         {
             entryFuncSet.insert(fun);
@@ -241,15 +240,16 @@ 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();
 
     CallStrCxt cxt(ctp.getContext());
     CallStrCxt oldCxt = cxt;
-    pushCxt(cxt,cs.getInstruction(),callee);
+    const CallICFGNode* callNode = SVFUtil::cast<CallICFGNode>(getICFGNode(cs.getInstruction()));
+    pushCxt(cxt,callNode,callee);
 
-    if(cgEdge->getEdgeKind() == PTACallGraphEdge::CallRetEdge)
+    if(cgEdge->getEdgeKind() == CallGraphEdge::CallRetEdge)
     {
         CxtThreadProc newctp(ctp.getTid(),cxt,callee);
         if(pushToCTPWorkList(newctp))
@@ -259,10 +259,10 @@ 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);
+        TCTNode* spawneeNode = getOrCreateTCTNode(cxt,callNode, oldCxt, callee);
         CxtThreadProc newctp(spawneeNode->getId(),cxt,callee);
 
         if(pushToCTPWorkList(newctp))
@@ -286,12 +286,12 @@ void TCT::handleCallRelation(CxtThreadProc& ctp, const PTACallGraphEdge* cgEdge,
  * Return true if a join instruction must be executed inside a loop
  * joinbb should post dominate the successive basic block of a loop header
  */
-bool TCT::isJoinMustExecutedInLoop(const LoopBBs& lp,const SVFInstruction* join)
+bool TCT::isJoinMustExecutedInLoop(const LoopBBs& lp,const ICFGNode* join)
 {
     assert(!lp.empty() && "this is not a loop, empty basic block");
-    const SVFFunction* svffun = join->getFunction();
+    const SVFFunction* svffun = join->getFun();
     const SVFBasicBlock* loopheadbb = svffun->getLoopHeader(lp);
-    const SVFBasicBlock* joinbb = join->getParent();
+    const SVFBasicBlock* joinbb = join->getBB();
     assert(loopheadbb->getParent()==joinbb->getParent() && "should inside same function");
 
     for (const SVFBasicBlock* svf_scc_bb : loopheadbb->getSuccessors())
@@ -314,9 +314,9 @@ void TCT::collectLoopInfoForJoin()
 {
     for(ThreadCallGraph::CallSiteSet::const_iterator it = tcg->joinsitesBegin(), eit = tcg->joinsitesEnd(); it!=eit; ++it)
     {
-        const SVFInstruction* join = (*it)->getCallSite();
-        const SVFFunction* svffun = join->getFunction();
-        const SVFBasicBlock* svfbb = join->getParent();
+        const ICFGNode* join = *it;
+        const SVFFunction* svffun = join->getFun();
+        const SVFBasicBlock* svfbb = join->getBB();
 
         if(svffun->hasLoopInfo(svfbb))
         {
@@ -354,7 +354,7 @@ bool TCT::isLoopExitOfJoinLoop(const SVFBasicBlock* bb)
     for(InstToLoopMap::const_iterator it = joinSiteToLoopMap.begin(), eit = joinSiteToLoopMap.end(); it!=eit; ++it)
     {
         std::vector<const SVFBasicBlock*> exitbbs;
-        it->first->getFunction()->getExitBlocksOfLoop(it->first->getParent(),exitbbs);
+        it->first->getFun()->getExitBlocksOfLoop(it->first->getBB(),exitbbs);
         while(!exitbbs.empty())
         {
             const SVFBasicBlock* eb = exitbbs.back();
@@ -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");
@@ -440,11 +440,11 @@ void TCT::build()
 /*!
  * Push calling context
  */
-void TCT::pushCxt(CallStrCxt& cxt, const SVFInstruction* call, const SVFFunction* callee)
+void TCT::pushCxt(CallStrCxt& cxt, const CallICFGNode* call, const SVFFunction* callee)
 {
 
-    const SVFFunction* caller = call->getFunction();
-    CallSiteID csId = tcg->getCallSiteID(getCallICFGNode(call), callee);
+    const SVFFunction* caller = call->getFun();
+    CallSiteID csId = tcg->getCallSiteID(call, callee);
 
     /// handle calling context for candidate functions only
     if(isCandidateFun(caller) == false)
@@ -461,11 +461,11 @@ void TCT::pushCxt(CallStrCxt& cxt, const SVFInstruction* call, const SVFFunction
 /*!
  * Match calling context
  */
-bool TCT::matchCxt(CallStrCxt& cxt, const SVFInstruction* call, const SVFFunction* callee)
+bool TCT::matchCxt(CallStrCxt& cxt, const CallICFGNode* call, const SVFFunction* callee)
 {
 
-    const SVFFunction* caller = call->getFunction();
-    CallSiteID csId = tcg->getCallSiteID(getCallICFGNode(call), callee);
+    const SVFFunction* caller = call->getFun();
+    CallSiteID csId = tcg->getCallSiteID(call, callee);
 
     /// handle calling context for candidate functions only
     if(isCandidateFun(caller) == false)

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);
@@ -95,21 +95,6 @@ PTACallGraph* ThreadCallGraphBuilder::buildThreadCallGraph(SVFModule* svfModule)
                         cg->addThreadForkEdgeSetMap(cs,nullptr);
                     }
                 }
-                else if (tdAPI->isHareParFor(inst))
-                {
-                    const CallICFGNode* cs = icfg->getCallICFGNode(inst);
-                    cg->addParForSite(cs);
-                    const SVFFunction* taskFunc = SVFUtil::dyn_cast<SVFFunction>(tdAPI->getTaskFuncAtHareParForSite(inst));
-                    if (taskFunc)
-                    {
-                        cg->addDirectParForEdge(cs);
-                    }
-                    // indirect call to the start routine function
-                    else
-                    {
-                        cg->addHareParForEdgeSetMap(cs,nullptr);
-                    }
-                }
             }
         }
     }