svf-tools 1.0.976 → 1.0.978

package/svf/lib/MTA/MHP.cpp

@@ -80,7 +80,7 @@ void MHP::analyzeInterleaving()
         NodeID rootTid = tpair.first;
         const SVFFunction* routine = tct->getStartRoutineOfCxtThread(ct);
         const SVFInstruction* svfInst = routine->getEntryBlock()->front();
-        CxtThreadStmt rootcts(rootTid, ct.getContext(), svfInst);
+        CxtThreadStmt rootcts(rootTid, ct.getContext(), tct->getICFGNode(svfInst));
 
         addInterleavingThread(rootcts, rootTid);
         updateAncestorThreads(rootTid);
@@ -89,7 +89,7 @@ void MHP::analyzeInterleaving()
         while (!cxtStmtList.empty())
         {
             CxtThreadStmt cts = popFromCTSWorkList();
-            const SVFInstruction* curInst = cts.getStmt();
+            const ICFGNode* curInst = cts.getStmt();
             DBOUT(DMTA, outs() << "-----\nMHP analysis root thread: " << rootTid << " ");
             DBOUT(DMTA, cts.dump());
             DBOUT(DMTA, outs() << "current thread interleaving: < ");
@@ -97,7 +97,7 @@ void MHP::analyzeInterleaving()
             DBOUT(DMTA, outs() << " >\n-----\n");
 
             /// handle non-candidate function
-            if (!tct->isCandidateFun(curInst->getParent()->getParent()))
+            if (!tct->isCandidateFun(curInst->getFun()))
             {
                 handleNonCandidateFun(cts);
             }
@@ -112,14 +112,14 @@ void MHP::analyzeInterleaving()
                 {
                     handleJoin(cts, rootTid);
                 }
-                else if (SVFUtil::isCallSite(curInst) && !isExtCall(curInst))
+                else if (tct->isCallSite(curInst) && !tct->isExtCall(curInst))
                 {
                     handleCall(cts, rootTid);
                     CallGraph::FunctionSet callees;
-                    if (!tct->isCandidateFun(getCallee(curInst, callees)))
+                    if (!tct->isCandidateFun(getCallee(SVFUtil::cast<CallICFGNode>(curInst), callees)))
                         handleIntra(cts);
                 }
-                else if (curInst->isRetInst())
+                else if (isa<IntraICFGNode>(curInst) && cast<IntraICFGNode>(curInst)->getInst()->isRetInst())
                 {
                     handleRet(cts);
                 }
@@ -149,10 +149,12 @@ void MHP::updateNonCandidateFunInterleaving()
         if (!tct->isCandidateFun(fun) && !isExtCall(fun))
         {
             const SVFInstruction* entryinst = fun->getEntryBlock()->front();
-            if (!hasThreadStmtSet(entryinst))
+            const ICFGNode* entryNode = tct->getICFGNode(entryinst);
+
+            if (!hasThreadStmtSet(entryNode))
                 continue;
 
-            const CxtThreadStmtSet& tsSet = getThreadStmtSet(entryinst);
+            const CxtThreadStmtSet& tsSet = getThreadStmtSet(entryNode);
 
             for (const CxtThreadStmt& cts : tsSet)
             {
@@ -164,9 +166,10 @@ void MHP::updateNonCandidateFunInterleaving()
                     {
                         if (svfInst == entryinst)
                             continue;
-                        CxtThreadStmt newCts(cts.getTid(), curCxt, svfInst);
+                        const ICFGNode* curNode = tct->getICFGNode(svfInst);
+                        CxtThreadStmt newCts(cts.getTid(), curCxt, curNode);
                         threadStmtToTheadInterLeav[newCts] |= threadStmtToTheadInterLeav[cts];
-                        instToTSMap[svfInst].insert(newCts);
+                        instToTSMap[curNode].insert(newCts);
                     }
                 }
             }
@@ -179,9 +182,9 @@ void MHP::updateNonCandidateFunInterleaving()
  */
 void MHP::handleNonCandidateFun(const CxtThreadStmt& cts)
 {
-    const SVFInstruction* curInst = cts.getStmt();
-    const SVFFunction* curfun = curInst->getParent()->getParent();
-    assert((curInst == curfun->getEntryBlock()->front()) && "curInst is not the entry of non candidate function.");
+    const ICFGNode* curInst = cts.getStmt();
+    const SVFFunction* curfun = curInst->getFun();
+    assert((curInst == tct->getICFGNode(curfun->getEntryBlock()->front())) && "curInst is not the entry of non candidate function.");
     const CallStrCxt& curCxt = cts.getContext();
     CallGraphNode* node = tcg->getCallGraphNode(curfun);
     for (CallGraphNode::const_iterator nit = node->OutEdgeBegin(), neit = node->OutEdgeEnd(); nit != neit; nit++)
@@ -190,7 +193,7 @@ void MHP::handleNonCandidateFun(const CxtThreadStmt& cts)
         if (!isExtCall(callee))
         {
             const SVFInstruction* calleeInst = callee->getEntryBlock()->front();
-            CxtThreadStmt newCts(cts.getTid(), curCxt, calleeInst);
+            CxtThreadStmt newCts(cts.getTid(), curCxt, tct->getICFGNode(calleeInst));
             addInterleavingThread(newCts, cts);
         }
     }
@@ -202,11 +205,11 @@ void MHP::handleNonCandidateFun(const CxtThreadStmt& cts)
 void MHP::handleFork(const CxtThreadStmt& cts, NodeID rootTid)
 {
 
-    const SVFInstruction* call = cts.getStmt();
+    const ICFGNode* call = cts.getStmt();
     const CallStrCxt& curCxt = cts.getContext();
 
     assert(isTDFork(call));
-    CallICFGNode* cbn = getCBN(call);
+    const CallICFGNode* cbn = cast<CallICFGNode>(call);
     if (tct->getThreadCallGraph()->hasCallGraphEdge(cbn))
     {
 
@@ -216,10 +219,10 @@ void MHP::handleFork(const CxtThreadStmt& cts, NodeID rootTid)
         {
             const SVFFunction* svfroutine = (*cgIt)->getDstNode()->getFunction();
             CallStrCxt newCxt = curCxt;
-            pushCxt(newCxt, call, svfroutine);
+            pushCxt(newCxt, cbn, svfroutine);
             const SVFInstruction* stmt = svfroutine->getEntryBlock()->front();
             CxtThread ct(newCxt, call);
-            CxtThreadStmt newcts(tct->getTCTNode(ct)->getId(), ct.getContext(), stmt);
+            CxtThreadStmt newcts(tct->getTCTNode(ct)->getId(), ct.getContext(), tct->getICFGNode(stmt));
             addInterleavingThread(newcts, cts);
         }
     }
@@ -232,7 +235,7 @@ void MHP::handleFork(const CxtThreadStmt& cts, NodeID rootTid)
 void MHP::handleJoin(const CxtThreadStmt& cts, NodeID rootTid)
 {
 
-    const SVFInstruction* call = cts.getStmt();
+    const ICFGNode* call = cts.getStmt();
     const CallStrCxt& curCxt = cts.getContext();
 
     assert(isTDJoin(call));
@@ -243,13 +246,13 @@ void MHP::handleJoin(const CxtThreadStmt& cts, NodeID rootTid)
         if (fja->hasJoinLoop(call))
         {
             std::vector<const SVFBasicBlock*> exitbbs;
-            call->getFunction()->getExitBlocksOfLoop(call->getParent(), exitbbs);
+            call->getFun()->getExitBlocksOfLoop(call->getBB(), exitbbs);
             while (!exitbbs.empty())
             {
                 const SVFBasicBlock* eb = exitbbs.back();
                 exitbbs.pop_back();
                 const SVFInstruction* svfEntryInst = eb->front();
-                CxtThreadStmt newCts(cts.getTid(), curCxt, svfEntryInst);
+                CxtThreadStmt newCts(cts.getTid(), curCxt, tct->getICFGNode(svfEntryInst));
                 addInterleavingThread(newCts, cts);
                 if (hasJoinInSymmetricLoop(curCxt, call))
                     rmInterleavingThread(newCts, joinedTids, call);
@@ -268,13 +271,13 @@ void MHP::handleJoin(const CxtThreadStmt& cts, NodeID rootTid)
         if (fja->hasJoinLoop(call))
         {
             std::vector<const SVFBasicBlock*> exitbbs;
-            call->getFunction()->getExitBlocksOfLoop(call->getParent(), exitbbs);
+            call->getFun()->getExitBlocksOfLoop(call->getBB(), exitbbs);
             while (!exitbbs.empty())
             {
                 const SVFBasicBlock* eb = exitbbs.back();
                 exitbbs.pop_back();
                 const SVFInstruction* svfEntryInst = eb->front();
-                CxtThreadStmt newCts(cts.getTid(), cts.getContext(), svfEntryInst);
+                CxtThreadStmt newCts(cts.getTid(), cts.getContext(), tct->getICFGNode(svfEntryInst));
                 addInterleavingThread(newCts, cts);
             }
         }
@@ -288,9 +291,9 @@ void MHP::handleJoin(const CxtThreadStmt& cts, NodeID rootTid)
 void MHP::handleCall(const CxtThreadStmt& cts, NodeID rootTid)
 {
 
-    const SVFInstruction* call = cts.getStmt();
+    const ICFGNode* call = cts.getStmt();
     const CallStrCxt& curCxt = cts.getContext();
-    CallICFGNode* cbn = getCBN(call);
+    const CallICFGNode* cbn = cast<CallICFGNode>(call);
     if (tct->getThreadCallGraph()->hasCallGraphEdge(cbn))
     {
         for (CallGraph::CallGraphEdgeSet::const_iterator cgIt = tcg->getCallEdgeBegin(cbn),
@@ -302,9 +305,10 @@ void MHP::handleCall(const CxtThreadStmt& cts, NodeID rootTid)
             if (isExtCall(svfcallee))
                 continue;
             CallStrCxt newCxt = curCxt;
-            pushCxt(newCxt, call, svfcallee);
+            const CallICFGNode* callicfgnode = SVFUtil::cast<CallICFGNode>(call);
+            pushCxt(newCxt, callicfgnode, svfcallee);
             const SVFInstruction* svfEntryInst = svfcallee->getEntryBlock()->front();
-            CxtThreadStmt newCts(cts.getTid(), newCxt, svfEntryInst);
+            CxtThreadStmt newCts(cts.getTid(), newCxt, tct->getICFGNode(svfEntryInst));
             addInterleavingThread(newCts, cts);
         }
     }
@@ -315,7 +319,7 @@ void MHP::handleCall(const CxtThreadStmt& cts, NodeID rootTid)
  */
 void MHP::handleRet(const CxtThreadStmt& cts)
 {
-    CallGraphNode* curFunNode = tcg->getCallGraphNode(cts.getStmt()->getParent()->getParent());
+    CallGraphNode* curFunNode = tcg->getCallGraphNode(cts.getStmt()->getFun());
     for (CallGraphEdge* edge : curFunNode->getInEdges())
     {
         if (SVFUtil::isa<ThreadForkEdge, ThreadJoinEdge>(edge))
@@ -325,13 +329,15 @@ void MHP::handleRet(const CxtThreadStmt& cts)
                 cit != ecit; ++cit)
         {
             CallStrCxt newCxt = cts.getContext();
-            if (matchCxt(newCxt, (*cit)->getCallSite(), curFunNode->getFunction()))
+            if (matchCxt(newCxt, *cit, curFunNode->getFunction()))
             {
-                const InstVec& nextInsts = (*cit)->getCallSite()->getSuccInstructions();
-                for (const auto& ni : nextInsts)
+                for(const ICFGEdge* outEdge : cts.getStmt()->getOutEdges())
                 {
-                    CxtThreadStmt newCts(cts.getTid(), newCxt, ni);
-                    addInterleavingThread(newCts, cts);
+                    if(outEdge->getDstNode()->getFun() == cts.getStmt()->getFun())
+                    {
+                        CxtThreadStmt newCts(cts.getTid(), newCxt, outEdge->getDstNode());
+                        addInterleavingThread(newCts, cts);
+                    }
                 }
             }
         }
@@ -340,13 +346,15 @@ void MHP::handleRet(const CxtThreadStmt& cts)
                 cit != ecit; ++cit)
         {
             CallStrCxt newCxt = cts.getContext();
-            if (matchCxt(newCxt, (*cit)->getCallSite(), curFunNode->getFunction()))
+            if (matchCxt(newCxt, *cit, curFunNode->getFunction()))
             {
-                const InstVec& nextInsts = (*cit)->getCallSite()->getSuccInstructions();
-                for (const auto& ni: nextInsts)
+                for(const ICFGEdge* outEdge : cts.getStmt()->getOutEdges())
                 {
-                    CxtThreadStmt newCts(cts.getTid(), newCxt, ni);
-                    addInterleavingThread(newCts, cts);
+                    if(outEdge->getDstNode()->getFun() == cts.getStmt()->getFun())
+                    {
+                        CxtThreadStmt newCts(cts.getTid(), newCxt, outEdge->getDstNode());
+                        addInterleavingThread(newCts, cts);
+                    }
                 }
             }
         }
@@ -359,11 +367,13 @@ void MHP::handleRet(const CxtThreadStmt& cts)
 void MHP::handleIntra(const CxtThreadStmt& cts)
 {
 
-    const InstVec& nextInsts = cts.getStmt()->getSuccInstructions();
-    for (const auto& ni: nextInsts)
+    for(const ICFGEdge* outEdge : cts.getStmt()->getOutEdges())
     {
-        CxtThreadStmt newCts(cts.getTid(), cts.getContext(), ni);
-        addInterleavingThread(newCts, cts);
+        if(outEdge->getDstNode()->getFun() == cts.getStmt()->getFun())
+        {
+            CxtThreadStmt newCts(cts.getTid(), cts.getContext(), outEdge->getDstNode());
+            addInterleavingThread(newCts, cts);
+        }
     }
 }
 
@@ -381,14 +391,16 @@ void MHP::updateAncestorThreads(NodeID curTid)
     for (const unsigned i : tds)
     {
         const CxtThread& ct = tct->getTCTNode(i)->getCxtThread();
-        if (const SVFInstruction* forkInst = ct.getThread())
+        if (const ICFGNode* forkInst = ct.getThread())
         {
             CallStrCxt forkSiteCxt = tct->getCxtOfCxtThread(ct);
-            const InstVec& nextInsts = forkInst->getSuccInstructions();
-            for (const auto& ni: nextInsts)
+            for(const ICFGEdge* outEdge : forkInst->getOutEdges())
             {
-                CxtThreadStmt cts(tct->getParentThread(i), forkSiteCxt, ni);
-                addInterleavingThread(cts, curTid);
+                if(outEdge->getDstNode()->getFun() == forkInst->getFun())
+                {
+                    CxtThreadStmt cts(tct->getParentThread(i), forkSiteCxt, outEdge->getDstNode());
+                    addInterleavingThread(cts, curTid);
+                }
             }
         }
     }
@@ -419,7 +431,7 @@ void MHP::updateSiblingThreads(NodeID curTid)
             const CxtThread& ct = tct->getTCTNode(stid)->getCxtThread();
             const SVFFunction* routine = tct->getStartRoutineOfCxtThread(ct);
             const SVFInstruction* stmt = routine->getEntryBlock()->front();
-            CxtThreadStmt cts(stid, ct.getContext(), stmt);
+            CxtThreadStmt cts(stid, ct.getContext(), tct->getICFGNode(stmt));
             addInterleavingThread(cts, curTid);
         }
 
@@ -467,7 +479,7 @@ bool MHP::isRecurFullJoin(NodeID parentTid, NodeID curTid)
  * (1) t is not a multiforked thread
  * (2) the join site of t is not in recursion
  */
-bool MHP::isMustJoin(NodeID curTid, const SVFInstruction* joinsite)
+bool MHP::isMustJoin(NodeID curTid, const ICFGNode* joinsite)
 {
     assert(isTDJoin(joinsite) && "not a join site!");
     return !isMultiForkedThread(curTid) && !tct->isJoinSiteInRecursion(joinsite);
@@ -476,7 +488,7 @@ bool MHP::isMustJoin(NodeID curTid, const SVFInstruction* joinsite)
 /*!
  * Return thread id(s) which are directly or indirectly joined at this join site
  */
-NodeBS MHP::getDirAndIndJoinedTid(const CallStrCxt& cxt, const SVFInstruction* call)
+NodeBS MHP::getDirAndIndJoinedTid(const CallStrCxt& cxt, const ICFGNode* call)
 {
     CxtStmt cs(cxt, call);
     return fja->getDirAndIndJoinedTid(cs);
@@ -485,14 +497,14 @@ NodeBS MHP::getDirAndIndJoinedTid(const CallStrCxt& cxt, const SVFInstruction* c
 /*!
  *  Whether a context-sensitive join satisfies symmetric loop pattern
  */
-bool MHP::hasJoinInSymmetricLoop(const CallStrCxt& cxt, const SVFInstruction* call) const
+bool MHP::hasJoinInSymmetricLoop(const CallStrCxt& cxt, const ICFGNode* call) const
 {
     CxtStmt cs(cxt, call);
     return fja->hasJoinInSymmetricLoop(cs);
 }
 
 /// Whether a context-sensitive join satisfies symmetric loop pattern
-const MHP::LoopBBs& MHP::getJoinInSymmetricLoop(const CallStrCxt& cxt, const SVFInstruction* call) const
+const MHP::LoopBBs& MHP::getJoinInSymmetricLoop(const CallStrCxt& cxt, const ICFGNode* call) const
 {
     CxtStmt cs(cxt, call);
     return fja->getJoinInSymmetricLoop(cs);
@@ -541,7 +553,7 @@ bool MHP::isConnectedfromMain(const SVFFunction* fun)
  * (2) t1!=t2 and t1 \in l2 and t2 \in l1
  */
 
-bool MHP::mayHappenInParallelInst(const SVFInstruction* i1, const SVFInstruction* i2)
+bool MHP::mayHappenInParallelInst(const ICFGNode* i1, const ICFGNode* i2)
 {
 
     /// TODO: Any instruction in dead function is assumed no MHP with others
@@ -577,11 +589,11 @@ bool MHP::mayHappenInParallelInst(const SVFInstruction* i1, const SVFInstruction
     return false;
 }
 
-bool MHP::mayHappenInParallelCache(const SVFInstruction* i1, const SVFInstruction* i2)
+bool MHP::mayHappenInParallelCache(const ICFGNode* i1, const ICFGNode* i2)
 {
-    if (!tct->isCandidateFun(i1->getParent()->getParent()) && !tct->isCandidateFun(i2->getParent()->getParent()))
+    if (!tct->isCandidateFun(i1->getFun()) && !tct->isCandidateFun(i2->getFun()))
     {
-        FuncPair funpair = std::make_pair(i1->getFunction(), i2->getFunction());
+        FuncPair funpair = std::make_pair(i1->getFun(), i2->getFun());
         FuncPairToBool::const_iterator it = nonCandidateFuncMHPRelMap.find(funpair);
         if (it == nonCandidateFuncMHPRelMap.end())
         {
@@ -599,7 +611,7 @@ bool MHP::mayHappenInParallelCache(const SVFInstruction* i1, const SVFInstructio
     return mayHappenInParallelInst(i1, i2);
 }
 
-bool MHP::mayHappenInParallel(const SVFInstruction* i1, const SVFInstruction* i2)
+bool MHP::mayHappenInParallel(const ICFGNode* i1, const ICFGNode* i2)
 {
     numOfTotalQueries++;
 
@@ -611,7 +623,7 @@ bool MHP::mayHappenInParallel(const SVFInstruction* i1, const SVFInstruction* i2
     return mhp;
 }
 
-bool MHP::executedByTheSameThread(const SVFInstruction* i1, const SVFInstruction* i2)
+bool MHP::executedByTheSameThread(const ICFGNode* i1, const ICFGNode* i2)
 {
     if (!hasThreadStmtSet(i1) || !hasThreadStmtSet(i2))
         return true;
@@ -637,8 +649,7 @@ void MHP::printInterleaving()
     for (const auto& pair : threadStmtToTheadInterLeav)
     {
         outs() << "( t" << pair.first.getTid()
-               << " , $" << pair.first.getStmt()->getSourceLoc()
-               << "$" << pair.first.getStmt()->toString() << " ) ==> [";
+               << pair.first.getStmt()->toString() << " ) ==> [";
         for (unsigned i : pair.second)
         {
             outs() << " " << i << " ";
@@ -655,25 +666,25 @@ void MHP::printInterleaving()
  */
 void ForkJoinAnalysis::collectSCEVInfo()
 {
-    typedef Set<const SVFInstruction*> CallInstSet;
-    typedef Map<const SVFFunction*, CallInstSet> FunToFJSites;
-    FunToFJSites funToFJSites;
+    // typedef Set<const ICFGNode*> CallInstSet;
+    // typedef Map<const SVFFunction*, CallInstSet> FunToFJSites;
+    // FunToFJSites funToFJSites;
 
-    for (ThreadCallGraph::CallSiteSet::const_iterator it = tct->getThreadCallGraph()->forksitesBegin(),
-            eit = tct->getThreadCallGraph()->forksitesEnd();
-            it != eit; ++it)
-    {
-        const SVFInstruction* fork = (*it)->getCallSite();
-        funToFJSites[fork->getFunction()].insert(fork);
-    }
+    // for (ThreadCallGraph::CallSiteSet::const_iterator it = tct->getThreadCallGraph()->forksitesBegin(),
+    //         eit = tct->getThreadCallGraph()->forksitesEnd();
+    //         it != eit; ++it)
+    // {
+    //     const ICFGNode* fork = *it;
+    //     funToFJSites[fork->getFun()].insert(fork);
+    // }
 
-    for (ThreadCallGraph::CallSiteSet::const_iterator it = tct->getThreadCallGraph()->joinsitesBegin(),
-            eit = tct->getThreadCallGraph()->joinsitesEnd();
-            it != eit; ++it)
-    {
-        const SVFInstruction* join = (*it)->getCallSite();
-        funToFJSites[join->getFunction()].insert(join);
-    }
+    // for (ThreadCallGraph::CallSiteSet::const_iterator it = tct->getThreadCallGraph()->joinsitesBegin(),
+    //         eit = tct->getThreadCallGraph()->joinsitesEnd();
+    //         it != eit; ++it)
+    // {
+    //     const ICFGNode* join = *it;
+    //     funToFJSites[join->getFun()].insert(join);
+    // }
 
     // for(FunToFJSites::const_iterator it = funToFJSites.begin(), eit = funToFJSites.end(); it!=eit; ++it)
     // {
@@ -714,22 +725,24 @@ void ForkJoinAnalysis::analyzeForkJoinPair()
         const CxtThread& ct = tpair.second->getCxtThread();
         const NodeID rootTid = tpair.first;
         clearFlagMap();
-        if (const SVFInstruction* forkInst = ct.getThread())
+        if (const ICFGNode* forkInst = ct.getThread())
         {
             CallStrCxt forkSiteCxt = tct->getCxtOfCxtThread(ct);
-            const SVFInstruction* exitInst = getExitInstOfParentRoutineFun(rootTid);
+            const ICFGNode* exitInst = getExitInstOfParentRoutineFun(rootTid);
 
-            const InstVec& nextInsts = forkInst->getSuccInstructions();
-            for (const SVFInstruction* ni : nextInsts)
+            for(const ICFGEdge* outEdge : forkInst->getOutEdges())
             {
-                CxtStmt cs(forkSiteCxt, ni);
-                markCxtStmtFlag(cs, TDAlive);
+                if(outEdge->getDstNode()->getFun() == forkInst->getFun())
+                {
+                    CxtStmt newCts(forkSiteCxt, outEdge->getDstNode());
+                    markCxtStmtFlag(newCts, TDAlive);
+                }
             }
 
             while (!cxtStmtList.empty())
             {
                 CxtStmt cts = popFromCTSWorkList();
-                const SVFInstruction* curInst = cts.getStmt();
+                const ICFGNode* curInst = cts.getStmt();
                 DBOUT(DMTA, outs() << "-----\nForkJoinAnalysis root thread: " << tpair.first << " ");
                 DBOUT(DMTA, cts.dump());
                 DBOUT(DMTA, outs() << "-----\n");
@@ -742,12 +755,12 @@ void ForkJoinAnalysis::analyzeForkJoinPair()
                 {
                     handleJoin(cts, rootTid);
                 }
-                else if (SVFUtil::isCallSite(curInst) && tct->isCandidateFun(getCallee(curInst, callees)))
+                else if (tct->isCallSite(curInst) && tct->isCandidateFun(getCallee(curInst, callees)))
                 {
 
                     handleCall(cts, rootTid);
                 }
-                else if (curInst->isRetInst())
+                else if (isa<IntraICFGNode>(curInst) && cast<IntraICFGNode>(curInst)->getInst()->isRetInst())
                 {
                     handleRet(cts);
                 }
@@ -771,11 +784,11 @@ void ForkJoinAnalysis::analyzeForkJoinPair()
 /// Handle fork
 void ForkJoinAnalysis::handleFork(const CxtStmt& cts, NodeID rootTid)
 {
-    const SVFInstruction* call = cts.getStmt();
+    const ICFGNode* call = cts.getStmt();
     const CallStrCxt& curCxt = cts.getContext();
 
     assert(isTDFork(call));
-    CallICFGNode* cbn = getCBN(call);
+    const CallICFGNode* cbn = cast<CallICFGNode>(call);
     if (getTCG()->hasThreadForkEdge(cbn))
     {
         for (ThreadCallGraph::ForkEdgeSet::const_iterator cgIt = getTCG()->getForkEdgeBegin(cbn),
@@ -784,7 +797,7 @@ void ForkJoinAnalysis::handleFork(const CxtStmt& cts, NodeID rootTid)
         {
             const SVFFunction* callee = (*cgIt)->getDstNode()->getFunction();
             CallStrCxt newCxt = curCxt;
-            pushCxt(newCxt, call, callee);
+            pushCxt(newCxt, cbn, callee);
             CxtThread ct(newCxt, call);
             if (getMarkedFlag(cts) != TDAlive)
                 addToHBPair(rootTid, tct->getTCTNode(ct)->getId());
@@ -798,15 +811,15 @@ void ForkJoinAnalysis::handleFork(const CxtStmt& cts, NodeID rootTid)
 /// Handle join
 void ForkJoinAnalysis::handleJoin(const CxtStmt& cts, NodeID rootTid)
 {
-    const SVFInstruction* call = cts.getStmt();
+    const ICFGNode* call = cts.getStmt();
     const CallStrCxt& curCxt = cts.getContext();
 
     assert(isTDJoin(call));
-    CallICFGNode* cbn = getCBN(call);
+    const CallICFGNode* cbn = cast<CallICFGNode>(call);
     if (getTCG()->hasCallGraphEdge(cbn))
     {
-        const SVFInstruction* forkSite = tct->getTCTNode(rootTid)->getCxtThread().getThread();
-        const SVFInstruction* joinSite = cts.getStmt();
+        const ICFGNode* forkSite = tct->getTCTNode(rootTid)->getCxtThread().getThread();
+        const ICFGNode* joinSite = cts.getStmt();
 
         if (isAliasedForkJoin(forkSite, joinSite))
         {
@@ -814,13 +827,13 @@ void ForkJoinAnalysis::handleJoin(const CxtStmt& cts, NodeID rootTid)
             {
                 LoopBBs& joinLoop = getJoinLoop(joinSite);
                 std::vector<const SVFBasicBlock *> exitbbs;
-                joinSite->getFunction()->getExitBlocksOfLoop(joinSite->getParent(), exitbbs);
+                joinSite->getFun()->getExitBlocksOfLoop(joinSite->getBB(), exitbbs);
                 while (!exitbbs.empty())
                 {
                     const SVFBasicBlock* eb = exitbbs.back();
                     exitbbs.pop_back();
                     const SVFInstruction* svfEntryInst = eb->front();
-                    CxtStmt newCts(curCxt, svfEntryInst);
+                    CxtStmt newCts(curCxt, tct->getICFGNode(svfEntryInst));
                     addDirectlyJoinTID(cts, rootTid);
                     if (isSameSCEV(forkSite, joinSite))
                     {
@@ -845,13 +858,13 @@ void ForkJoinAnalysis::handleJoin(const CxtStmt& cts, NodeID rootTid)
             if (hasJoinLoop(joinSite))
             {
                 std::vector<const SVFBasicBlock*> exitbbs;
-                joinSite->getFunction()->getExitBlocksOfLoop(joinSite->getParent(), exitbbs);
+                joinSite->getFun()->getExitBlocksOfLoop(joinSite->getBB(), exitbbs);
                 while (!exitbbs.empty())
                 {
                     const SVFBasicBlock* eb = exitbbs.back();
                     exitbbs.pop_back();
                     const SVFInstruction* svfEntryInst = eb->front();
-                    CxtStmt newCts(curCxt, svfEntryInst);
+                    CxtStmt newCts(curCxt, tct->getICFGNode(svfEntryInst));
                     markCxtStmtFlag(newCts, cts);
                 }
             }
@@ -864,9 +877,9 @@ void ForkJoinAnalysis::handleJoin(const CxtStmt& cts, NodeID rootTid)
 void ForkJoinAnalysis::handleCall(const CxtStmt& cts, NodeID rootTid)
 {
 
-    const SVFInstruction* call = cts.getStmt();
+    const ICFGNode* call = cts.getStmt();
     const CallStrCxt& curCxt = cts.getContext();
-    CallICFGNode* cbn = getCBN(call);
+    const CallICFGNode* cbn = SVFUtil::cast<CallICFGNode>(call);
     if (getTCG()->hasCallGraphEdge(cbn))
     {
         for (CallGraph::CallGraphEdgeSet::const_iterator cgIt = getTCG()->getCallEdgeBegin(cbn),
@@ -877,9 +890,9 @@ void ForkJoinAnalysis::handleCall(const CxtStmt& cts, NodeID rootTid)
             if (isExtCall(svfcallee))
                 continue;
             CallStrCxt newCxt = curCxt;
-            pushCxt(newCxt, call, svfcallee);
+            pushCxt(newCxt, cbn, svfcallee);
             const SVFInstruction* svfEntryInst = svfcallee->getEntryBlock()->front();
-            CxtStmt newCts(newCxt, svfEntryInst);
+            CxtStmt newCts(newCxt, tct->getICFGNode(svfEntryInst));
             markCxtStmtFlag(newCts, cts);
         }
     }
@@ -888,11 +901,10 @@ void ForkJoinAnalysis::handleCall(const CxtStmt& cts, NodeID rootTid)
 /// Handle return
 void ForkJoinAnalysis::handleRet(const CxtStmt& cts)
 {
-
-    const SVFInstruction* curInst = cts.getStmt();
+    const ICFGNode* curInst = cts.getStmt();
     const CallStrCxt& curCxt = cts.getContext();
 
-    CallGraphNode* curFunNode = getTCG()->getCallGraphNode(curInst->getFunction());
+    CallGraphNode* curFunNode = getTCG()->getCallGraphNode(curInst->getFun());
     for (CallGraphEdge* edge : curFunNode->getInEdges())
     {
         if (SVFUtil::isa<ThreadForkEdge, ThreadJoinEdge>(edge))
@@ -902,13 +914,16 @@ void ForkJoinAnalysis::handleRet(const CxtStmt& cts)
                 cit != ecit; ++cit)
         {
             CallStrCxt newCxt = curCxt;
-            if (matchCxt(newCxt, (*cit)->getCallSite(), curFunNode->getFunction()))
+            const ICFGNode* curNode = tct->getICFGNode((*cit)->getCallSite());
+            if (matchCxt(newCxt, SVFUtil::cast<CallICFGNode>(curNode), curFunNode->getFunction()))
             {
-                const InstVec& nextInsts = (*cit)->getCallSite()->getSuccInstructions();
-                for (const auto& ni : nextInsts)
+                for(const ICFGEdge* outEdge : curNode->getOutEdges())
                 {
-                    CxtStmt newCts(newCxt, ni);
-                    markCxtStmtFlag(newCts, cts);
+                    if(outEdge->getDstNode()->getFun() == curNode->getFun())
+                    {
+                        CxtStmt newCts(newCxt, outEdge->getDstNode());
+                        markCxtStmtFlag(newCts, cts);
+                    }
                 }
             }
         }
@@ -917,13 +932,17 @@ void ForkJoinAnalysis::handleRet(const CxtStmt& cts)
                 cit != ecit; ++cit)
         {
             CallStrCxt newCxt = curCxt;
-            if (matchCxt(newCxt, (*cit)->getCallSite(), curFunNode->getFunction()))
+            const ICFGNode* curNode = tct->getICFGNode((*cit)->getCallSite());
+
+            if (matchCxt(newCxt, SVFUtil::cast<CallICFGNode>(curNode), curFunNode->getFunction()))
             {
-                const InstVec& nextInsts = (*cit)->getCallSite()->getSuccInstructions();
-                for (const auto& ni : nextInsts)
+                for(const ICFGEdge* outEdge : curNode->getOutEdges())
                 {
-                    CxtStmt newCts(newCxt, ni);
-                    markCxtStmtFlag(newCts, cts);
+                    if(outEdge->getDstNode()->getFun() == curNode->getFun())
+                    {
+                        CxtStmt newCts(newCxt, outEdge->getDstNode());
+                        markCxtStmtFlag(newCts, cts);
+                    }
                 }
             }
         }
@@ -934,14 +953,16 @@ void ForkJoinAnalysis::handleRet(const CxtStmt& cts)
 void ForkJoinAnalysis::handleIntra(const CxtStmt& cts)
 {
 
-    const SVFInstruction* curInst = cts.getStmt();
+    const ICFGNode* curInst = cts.getStmt();
     const CallStrCxt& curCxt = cts.getContext();
 
-    const InstVec& nextInsts = curInst->getSuccInstructions();
-    for (const auto& ni: nextInsts)
+    for(const ICFGEdge* outEdge : curInst->getOutEdges())
     {
-        CxtStmt newCts(curCxt, ni);
-        markCxtStmtFlag(newCts, cts);
+        if(outEdge->getDstNode()->getFun() == curInst->getFun())
+        {
+            CxtStmt newCts(curCxt, outEdge->getDstNode());
+            markCxtStmtFlag(newCts, cts);
+        }
     }
 }
 
@@ -1025,7 +1046,7 @@ NodeBS ForkJoinAnalysis::getDirAndIndJoinedTid(const CxtStmt& cs)
  *  pointers of fork thread and join thread should have same scev start and step.
  *  and should have same loop trip count
  */
-bool ForkJoinAnalysis::isSameSCEV(const SVFInstruction* forkSite, const SVFInstruction* joinSite)
+bool ForkJoinAnalysis::isSameSCEV(const ICFGNode* forkSite, const ICFGNode* joinSite)
 {
 
     // const PTASCEV& forkse = fkjnToPTASCEVMap[forkSite];
@@ -1049,7 +1070,7 @@ bool ForkJoinAnalysis::isSameSCEV(const SVFInstruction* forkSite, const SVFInstr
 /*!
  * The fork and join have same loop trip count
  */
-bool ForkJoinAnalysis::sameLoopTripCount(const SVFInstruction* forkSite, const SVFInstruction* joinSite)
+bool ForkJoinAnalysis::sameLoopTripCount(const ICFGNode* forkSite, const ICFGNode* joinSite)
 {
 
     // ScalarEvolution* forkSE = getSE(forkSite);