svf-tools 1.0.358 → 1.0.362

package/include/SVF-FE/ICFGBuilder.h

@@ -84,20 +84,20 @@ private:
     void addICFGInterEdges(const Instruction*  cs, const SVFFunction*  callee);
 
     /// Add a call node
-    inline CallICFGNode* getOrAddCallICFGNode(const Instruction*  cs)
+    inline CallICFGNode* getCallICFGNode(const Instruction*  cs)
     {
-        return icfg->getCallBlockNode(cs);
+        return icfg->getCallICFGNode(cs);
     }
     /// Add a return node
-    inline RetICFGNode* getOrAddRetICFGNode(const Instruction*  cs)
+    inline RetICFGNode* getRetICFGNode(const Instruction*  cs)
     {
-        return icfg->getRetBlockNode(cs);
+        return icfg->getRetICFGNode(cs);
     }
 
     /// Add and get IntraBlock ICFGNode
     IntraICFGNode* getOrAddIntraBlockICFGNode(const Instruction* inst)
     {
-        return icfg->getIntraBlockNode(inst);
+        return icfg->getIntraICFGNode(inst);
     }
 };
 

package/include/SVF-FE/SVFIRBuilder.h

@@ -348,7 +348,7 @@ public:
     {
         IntraICFGNode* node;
         if(const Instruction* inst = SVFUtil::dyn_cast<Instruction>(curVal))
-            node = pag->getICFG()->getIntraBlockNode(inst);
+            node = pag->getICFG()->getIntraICFGNode(inst);
         else
             node = nullptr;
         StoreStmt *edge = pag->addStoreStmt(src, dst, node);

package/lib/Graphs/ICFG.cpp

@@ -190,69 +190,69 @@ ICFG::ICFG(): totalICFGNode(0)
 
 
 /// Get a basic block ICFGNode
-ICFGNode* ICFG::getBlockICFGNode(const Instruction* inst)
+ICFGNode* ICFG::getICFGNode(const Instruction* inst)
 {
     ICFGNode* node;
     if(SVFUtil::isNonInstricCallSite(inst))
-        node = getCallBlockNode(inst);
+        node = getCallICFGNode(inst);
     else if(SVFUtil::isIntrinsicInst(inst))
-        node = getIntraBlockNode(inst);
+        node = getIntraICFGNode(inst);
 //			assert (false && "associating an intrinsic instruction with an ICFGNode!");
     else
-        node = getIntraBlockNode(inst);
+        node = getIntraICFGNode(inst);
 
     assert (node!=nullptr && "no ICFGNode for this instruction?");
     return node;
 }
 
 
-CallICFGNode* ICFG::getCallBlockNode(const Instruction* inst)
+CallICFGNode* ICFG::getCallICFGNode(const Instruction* inst)
 {
 	if(SVFUtil::isCallSite(inst) ==false)
 		outs() << *inst << "\n";
     assert(SVFUtil::isCallSite(inst) && "not a call instruction?");
     assert(SVFUtil::isNonInstricCallSite(inst) && "associating an intrinsic debug instruction with an ICFGNode!");
-    CallICFGNode* node = getCallICFGNode(inst);
+    CallICFGNode* node = getCallBlock(inst);
     if(node==nullptr)
-        node = addCallICFGNode(inst);
+        node = addCallBlock(inst);
     assert (node!=nullptr && "no CallICFGNode for this instruction?");
     return node;
 }
 
-RetICFGNode* ICFG::getRetBlockNode(const Instruction* inst)
+RetICFGNode* ICFG::getRetICFGNode(const Instruction* inst)
 {
     assert(SVFUtil::isCallSite(inst) && "not a call instruction?");
     assert(SVFUtil::isNonInstricCallSite(inst) && "associating an intrinsic debug instruction with an ICFGNode!");
-    RetICFGNode* node = getRetICFGNode(inst);
+    RetICFGNode* node = getRetBlock(inst);
     if(node==nullptr)
-        node = addRetICFGNode(inst);
+        node = addRetBlock(inst);
     assert (node!=nullptr && "no RetICFGNode for this instruction?");
     return node;
 }
 
-IntraICFGNode* ICFG::getIntraBlockNode(const Instruction* inst)
+IntraICFGNode* ICFG::getIntraICFGNode(const Instruction* inst)
 {
-    IntraICFGNode* node = getIntraBlockICFGNode(inst);
+    IntraICFGNode* node = getIntraBlock(inst);
     if(node==nullptr)
-        node = addIntraBlockICFGNode(inst);
+        node = addIntraBlock(inst);
     return node;
 }
 
 /// Add a function entry node
-FunEntryICFGNode* ICFG::getFunEntryBlockNode(const SVFFunction*  fun)
+FunEntryICFGNode* ICFG::getFunEntryICFGNode(const SVFFunction*  fun)
 {
-    FunEntryICFGNode* b = getFunEntryICFGNode(fun);
+    FunEntryICFGNode* b = getFunEntryBlock(fun);
     if (b == nullptr)
-        return addFunEntryICFGNode(fun);
+        return addFunEntryBlock(fun);
     else
         return b;
 }
 /// Add a function exit node
-FunExitICFGNode* ICFG::getFunExitBlockNode(const SVFFunction*  fun)
+FunExitICFGNode* ICFG::getFunExitICFGNode(const SVFFunction*  fun)
 {
-    FunExitICFGNode* b = getFunExitICFGNode(fun);
+    FunExitICFGNode* b = getFunExitBlock(fun);
     if (b == nullptr)
-        return addFunExitICFGNode(fun);
+        return addFunExitBlock(fun);
     else
         return b;
 }
@@ -436,20 +436,25 @@ void ICFG::updateCallGraph(PTACallGraph* callgraph)
         for (PTACallGraph::FunctionSet::const_iterator func_iter = functions.begin(); func_iter != functions.end(); func_iter++)
         {
             const SVFFunction*  callee = *func_iter;
-            CallICFGNode* callBlockNode = getCallBlockNode(cs);
-            RetICFGNode* retBlockNode = getRetBlockNode(cs);
-            FunEntryICFGNode* calleeEntryNode = getFunEntryICFGNode(callee);
-            FunExitICFGNode* calleeExitNode = getFunExitICFGNode(callee);
-            addCallEdge(callBlockNode, calleeEntryNode, cs);
-            addRetEdge(calleeExitNode, retBlockNode, cs);
-
-            /// if this is an external function (no function body), connect calleeEntryNode to calleeExitNode
+            CallICFGNode* callICFGNode = getCallICFGNode(cs);
+            RetICFGNode* retBlockNode = getRetICFGNode(cs);
+            /// if this is an external function (no function body or specified in ExAPI.cpp)
             if (isExtCall(callee))
-                addIntraEdge(calleeEntryNode, calleeExitNode); 
-
-            /// Remove callBlockNode to retBlockNode intraICFGEdge since we found at least one inter procedural edge
-            if(ICFGEdge* edge = hasIntraICFGEdge(callBlockNode,retBlockNode, ICFGEdge::IntraCF))
-                removeICFGEdge(edge);
+            {
+                addIntraEdge(callICFGNode, retBlockNode); 
+            }
+            /// otherwise connect interprocedural edges 
+            else
+            {
+                FunEntryICFGNode* calleeEntryNode = getFunEntryICFGNode(callee);
+                FunExitICFGNode* calleeExitNode = getFunExitICFGNode(callee);
+                addCallEdge(callICFGNode, calleeEntryNode, cs);
+                addRetEdge(calleeExitNode, retBlockNode, cs);
+
+                /// Remove callBlockNode to retBlockNode intraICFGEdge since we found at least one inter procedural edge
+                if(ICFGEdge* edge = hasIntraICFGEdge(callICFGNode,retBlockNode, ICFGEdge::IntraCF))
+                    removeICFGEdge(edge);
+            }
         }
     }
     // dump ICFG

package/lib/Graphs/SVFG.cpp

@@ -242,7 +242,7 @@ void SVFG::addSVFGNodesForAddrTakenVars()
     {
         for(PHISet::iterator pi = it->second.begin(), epi = it->second.end(); pi!=epi; ++pi){
             MemSSA::PHI* phi =  *pi;
-            addIntraMSSAPHISVFGNode(pag->getICFG()->getBlockICFGNode(&(phi->getBasicBlock()->front())), phi->opVerBegin(), phi->opVerEnd(),phi->getResVer(), totalVFGNode++);
+            addIntraMSSAPHISVFGNode(pag->getICFG()->getICFGNode(&(phi->getBasicBlock()->front())), phi->opVerBegin(), phi->opVerEnd(),phi->getResVer(), totalVFGNode++);
         }
     }
     /// initialize memory SSA entry chi nodes
@@ -251,7 +251,7 @@ void SVFG::addSVFGNodesForAddrTakenVars()
     {
         for(CHISet::iterator pi = it->second.begin(), epi = it->second.end(); pi!=epi; ++pi){
             const MemSSA::ENTRYCHI* chi = SVFUtil::cast<ENTRYCHI>(*pi);
-            addFormalINSVFGNode(pag->getICFG()->getFunEntryBlockNode(chi->getFunction()), chi->getResVer(), totalVFGNode++);
+            addFormalINSVFGNode(pag->getICFG()->getFunEntryICFGNode(chi->getFunction()), chi->getResVer(), totalVFGNode++);
         }
     }
     /// initialize memory SSA return mu nodes
@@ -260,7 +260,7 @@ void SVFG::addSVFGNodesForAddrTakenVars()
     {
         for(MUSet::iterator pi = it->second.begin(), epi = it->second.end(); pi!=epi; ++pi){
               const MemSSA::RETMU* mu = SVFUtil::cast<RETMU>(*pi);
-              addFormalOUTSVFGNode(pag->getICFG()->getFunExitBlockNode(mu->getFunction()), mu->getMRVer(), totalVFGNode++);
+              addFormalOUTSVFGNode(pag->getICFG()->getFunExitICFGNode(mu->getFunction()), mu->getMRVer(), totalVFGNode++);
         }
     }
     /// initialize memory SSA callsite mu nodes
@@ -567,7 +567,7 @@ std::set<const SVFGNode*> SVFG::fromValue(const llvm::Value* value) const
 void SVFG::getInterVFEdgesForIndirectCallSite(const CallICFGNode* callBlockNode, const SVFFunction* callee, SVFGEdgeSetTy& edges)
 {
     CallSiteID csId = getCallSiteID(callBlockNode, callee);
-    RetICFGNode* retBlockNode = pag->getICFG()->getRetBlockNode(callBlockNode->getCallSite());
+    RetICFGNode* retBlockNode = pag->getICFG()->getRetICFGNode(callBlockNode->getCallSite());
 
     // Find inter direct call edges between actual param and formal param.
     if (pag->hasCallSiteArgsMap(callBlockNode) && pag->hasFunArgsList(callee))

package/lib/Graphs/VFG.cpp

@@ -407,7 +407,7 @@ void VFG::addVFGNodes()
         if(isInterestedPAGNode(it->second) == false || hasDef(it->second))
             continue;
 
-        addActualRetVFGNode(it->second,it->first->getCallBlockNode());
+        addActualRetVFGNode(it->second,it->first->getCallICFGNode());
     }
 
     // initialize formal parameter nodes
@@ -674,7 +674,7 @@ void VFG::connectDirectVFGEdges()
             {
                 ActualRetVFGNode* callsiteRev = getActualRetVFGNode((*it)->getLHSVar());
                 const CallICFGNode* retBlockNode = (*it)->getCallSite();
-                CallICFGNode* callBlockNode = pag->getICFG()->getCallBlockNode(retBlockNode->getCallSite());
+                CallICFGNode* callBlockNode = pag->getICFG()->getCallICFGNode(retBlockNode->getCallSite());
                 addInterEdgeFromFRToAR(calleeRet,callsiteRev, getCallSiteID(callBlockNode, calleeRet->getFun()));
             }
         }
@@ -813,7 +813,7 @@ void VFG::connectCallerAndCallee(const CallICFGNode* callBlockNode, const SVFFun
     SVFIR * pag = SVFIR::getPAG();
     ICFG * icfg = pag->getICFG();
     CallSiteID csId = getCallSiteID(callBlockNode, callee);
-    RetICFGNode* retBlockNode = icfg->getRetBlockNode(callBlockNode->getCallSite());
+    RetICFGNode* retBlockNode = icfg->getRetICFGNode(callBlockNode->getCallSite());
     // connect actual and formal param
     if (pag->hasCallSiteArgsMap(callBlockNode) && pag->hasFunArgsList(callee))
     {

package/lib/MSSA/MemRegion.cpp

@@ -152,18 +152,18 @@ bool MRGenerator::hasSVFStmtList(const Instruction* inst)
 {
     SVFIR* pag = pta->getPAG();
     if (ptrOnlyMSSA)
-        return pag->hasPTASVFStmtList(pag->getICFG()->getBlockICFGNode(inst));
+        return pag->hasPTASVFStmtList(pag->getICFG()->getICFGNode(inst));
     else
-        return pag->hasSVFStmtList(pag->getICFG()->getBlockICFGNode(inst));
+        return pag->hasSVFStmtList(pag->getICFG()->getICFGNode(inst));
 }
 
 SVFIR::SVFStmtList& MRGenerator::getPAGEdgesFromInst(const Instruction* inst)
 {
     SVFIR* pag = pta->getPAG();
     if (ptrOnlyMSSA)
-        return pag->getPTASVFStmtList(pag->getICFG()->getBlockICFGNode(inst));
+        return pag->getPTASVFStmtList(pag->getICFG()->getICFGNode(inst));
     else
-        return pag->getSVFStmtList(pag->getICFG()->getBlockICFGNode(inst));
+        return pag->getSVFStmtList(pag->getICFG()->getICFGNode(inst));
 }
 
 /*!
@@ -259,7 +259,7 @@ void MRGenerator::collectModRefForCall()
 
     for (CallSite cs : SymbolTableInfo::SymbolInfo()->getCallSiteSet())
     {
-        const CallICFGNode* callBlockNode = pta->getPAG()->getICFG()->getCallBlockNode(cs.getInstruction());
+        const CallICFGNode* callBlockNode = pta->getPAG()->getICFG()->getCallICFGNode(cs.getInstruction());
         if(hasRefSideEffectOfCallSite(callBlockNode))
         {
             NodeBS refs = getRefSideEffectOfCallSite(callBlockNode);
@@ -481,8 +481,8 @@ void MRGenerator::collectCallSitePts(const CallICFGNode* cs)
     /// collect the pts chain of the callsite arguments
     NodeBS& argsPts = csToCallSiteArgsPtsMap[cs];
     SVFIR* pag = pta->getPAG();
-    CallICFGNode* callBlockNode = pag->getICFG()->getCallBlockNode(cs->getCallSite());
-    RetICFGNode* retBlockNode = pag->getICFG()->getRetBlockNode(cs->getCallSite());
+    CallICFGNode* callBlockNode = pag->getICFG()->getCallICFGNode(cs->getCallSite());
+    RetICFGNode* retBlockNode = pag->getICFG()->getRetICFGNode(cs->getCallSite());
 
     WorkList worklist;
     if (pag->hasCallSiteArgsMap(callBlockNode))

package/lib/MSSA/MemSSA.cpp

@@ -174,7 +174,7 @@ void MemSSA::createMUCHI(const SVFFunction& fun)
             }
             if (isNonInstricCallSite(inst))
             {
-                const CallICFGNode* cs = pag->getICFG()->getCallBlockNode(inst);
+                const CallICFGNode* cs = pag->getICFG()->getCallICFGNode(inst);
                 if(mrGen->hasRefMRSet(cs))
                     AddCallSiteMU(cs,mrGen->getCallSiteRefMRSet(cs));
 
@@ -318,7 +318,7 @@ void MemSSA::SSARenameBB(const BasicBlock& bb)
         }
         if (isNonInstricCallSite(inst))
         {
-            const CallICFGNode* cs = pag->getICFG()->getCallBlockNode(inst);
+            const CallICFGNode* cs = pag->getICFG()->getCallICFGNode(inst);
             if(mrGen->hasRefMRSet(cs))
                 RenameMuSet(getMUSet(cs));
 
@@ -634,7 +634,7 @@ void MemSSA::dumpMSSA(raw_ostream& Out)
                 bool isAppCall = isNonInstricCallSite(&inst) && !isExtCall(&inst);
                 if (isAppCall || isHeapAllocExtCall(&inst))
                 {
-                    const CallICFGNode* cs = pag->getICFG()->getCallBlockNode(&inst);
+                    const CallICFGNode* cs = pag->getICFG()->getCallICFGNode(&inst);
                     if(hasMU(cs))
                     {
                         if (!last_is_chi)

package/lib/MTA/LockAnalysis.cpp

@@ -406,7 +406,7 @@ void LockAnalysis::handleFork(const CxtStmt& cts)
 {
     const CallInst* call = SVFUtil::cast<CallInst>(cts.getStmt());
     const CallStrCxt& curCxt = cts.getContext();
-	CallICFGNode* cbn = tct->getCallBlockNode(call);
+	CallICFGNode* cbn = tct->getCallICFGNode(call);
     if(getTCG()->hasThreadForkEdge(cbn))
     {
         for (ThreadCallGraph::ForkEdgeSet::const_iterator cgIt = getTCG()->getForkEdgeBegin(cbn),
@@ -429,7 +429,7 @@ void LockAnalysis::handleCall(const CxtStmt& cts)
 
     const CallInst* call = SVFUtil::cast<CallInst>(cts.getStmt());
     const CallStrCxt& curCxt = cts.getContext();
-	CallICFGNode* cbn = tct->getCallBlockNode(call);
+	CallICFGNode* cbn = tct->getCallICFGNode(call);
     if (getTCG()->hasCallGraphEdge(cbn))
     {
         for (PTACallGraph::CallGraphEdgeSet::const_iterator cgIt = getTCG()->getCallEdgeBegin(cbn), ecgIt = getTCG()->getCallEdgeEnd(cbn);
@@ -518,7 +518,7 @@ void LockAnalysis::pushCxt(CallStrCxt& cxt, const Instruction* call, const Funct
     const Function* caller = call->getParent()->getParent();
     const SVFFunction* svfcallee = tct->getSVFFun(callee);
     const SVFFunction* svfcaller = tct->getSVFFun(caller);
-    CallICFGNode* cbn = tct->getCallBlockNode(call);
+    CallICFGNode* cbn = tct->getCallICFGNode(call);
     CallSiteID csId = getTCG()->getCallSiteID(cbn, svfcallee);
 	
 //    /// handle calling context for candidate functions only
@@ -537,7 +537,7 @@ bool LockAnalysis::matchCxt(CallStrCxt& cxt, const Instruction* call, const Func
     const Function* caller = call->getParent()->getParent();
     const SVFFunction* svfcallee = tct->getSVFFun(callee);
     const SVFFunction* svfcaller = tct->getSVFFun(caller);
-    CallICFGNode* cbn = tct->getCallBlockNode(call);
+    CallICFGNode* cbn = tct->getCallICFGNode(call);
     CallSiteID csId = getTCG()->getCallSiteID(cbn, svfcallee);
 
 //    /// handle calling context for candidate functions only

package/lib/MTA/MTAResultValidator.cpp

@@ -96,7 +96,7 @@ CallStrCxt MTAResultValidator::getCxtArg(const Instruction* inst, unsigned int a
         const SVFFunction* callee = SVFUtil::getFunction(y[1]);
         CallSite cs = SVFUtil::getLLVMCallSite(csnumToInstMap[atoi(y[0].c_str())]);
         assert(callee && "callee error");
-        CallICFGNode* cbn = mhp->getTCT()->getCallBlockNode(cs.getInstruction());
+        CallICFGNode* cbn = mhp->getTCT()->getCallICFGNode(cs.getInstruction());
         CallSiteID csId = tcg->getCallSiteID(cbn, callee);
         cxt.push_back(csId);
     }

package/lib/MTA/PCG.cpp

@@ -206,7 +206,7 @@ void PCG::identifyFollowers()
                 // if this is an call/invoke instruction but not a spawn site
                 if ((SVFUtil::isa<CallInst>(inst) || SVFUtil::isa<InvokeInst>(inst)) && !isSpawnsite(inst))
                 {
-                	CallICFGNode* cbn = getCallBlockNode(inst);
+                	CallICFGNode* cbn = getCallICFGNode(inst);
                     if (callgraph->hasCallGraphEdge(cbn))
                     {
                         for (PTACallGraph::CallGraphEdgeSet::const_iterator cgIt = callgraph->getCallEdgeBegin(cbn),

package/lib/MTA/TCT.cpp

@@ -476,7 +476,7 @@ void TCT::pushCxt(CallStrCxt& cxt, const Instruction* call, const Function* call
     const Function* caller = call->getParent()->getParent();
     const SVFFunction* svfcaller = getSVFFun(caller);
     const SVFFunction* svfcallee = getSVFFun(callee);
-    CallSiteID csId = tcg->getCallSiteID(getCallBlockNode(call), svfcallee);
+    CallSiteID csId = tcg->getCallSiteID(getCallICFGNode(call), svfcallee);
 
     /// handle calling context for candidate functions only
     if(isCandidateFun(caller) == false)
@@ -498,7 +498,7 @@ bool TCT::matchCxt(CallStrCxt& cxt, const Instruction* call, const Function* cal
 
     const Function* caller = call->getParent()->getParent();
     const SVFFunction* svfcallee = getSVFFun(callee);
-    CallSiteID csId = tcg->getCallSiteID(getCallBlockNode(call), svfcallee);
+    CallSiteID csId = tcg->getCallSiteID(getCallICFGNode(call), svfcallee);
 
     /// handle calling context for candidate functions only
     if(isCandidateFun(caller) == false)

package/lib/MemoryModel/PointerAnalysis.cpp

@@ -515,7 +515,7 @@ void PointerAnalysis::connectVCallToVFns(const CallICFGNode* cs, const VFunSet &
         {
             newEdges[cs].insert(callee);
             getIndCallMap()[cs].insert(callee);
-            const CallICFGNode* callBlockNode = pag->getICFG()->getCallBlockNode(cs->getCallSite());
+            const CallICFGNode* callBlockNode = pag->getICFG()->getCallICFGNode(cs->getCallSite());
             ptaCallGraph->addIndirectCallGraphEdge(callBlockNode, cs->getCaller(),callee);
         }
     }

package/lib/SABER/LeakChecker.cpp

@@ -54,7 +54,7 @@ void LeakChecker::initSrcs()
             continue;
 
         PTACallGraph::FunctionSet callees;
-        getCallgraph()->getCallees(cs->getCallBlockNode(),callees);
+        getCallgraph()->getCallees(cs->getCallICFGNode(),callees);
         for(PTACallGraph::FunctionSet::const_iterator cit = callees.begin(), ecit = callees.end(); cit!=ecit; cit++)
         {
             const SVFFunction* fun = *cit;
@@ -62,11 +62,11 @@ void LeakChecker::initSrcs()
             {
                 CSWorkList worklist;
                 SVFGNodeBS visited;
-                worklist.push(it->first->getCallBlockNode());
+                worklist.push(it->first->getCallICFGNode());
                 while (!worklist.empty())
                 {
                     const CallICFGNode* cs = worklist.pop();
-                    const RetICFGNode* retBlockNode = icfg->getRetBlockNode(cs->getCallSite());
+                    const RetICFGNode* retBlockNode = icfg->getRetICFGNode(cs->getCallSite());
                     const PAGNode* pagNode = pag->getCallSiteRet(retBlockNode);
                     const SVFGNode* node = getSVFG()->getDefSVFGNode(pagNode);
                     if (visited.test(node->getId()) == 0)

package/lib/SVF-FE/CallGraphBuilder.cpp

@@ -55,7 +55,7 @@ PTACallGraph* CallGraphBuilder::buildCallGraph(SVFModule* svfModule)
             {
                 if(const SVFFunction* callee = getCallee(inst))
                 {
-                    const CallICFGNode* callBlockNode = icfg->getCallBlockNode(inst);
+                    const CallICFGNode* callBlockNode = icfg->getCallICFGNode(inst);
                     const SVFFunction* caller = LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(fun);
                     callgraph->addDirectCallGraphEdge(callBlockNode,caller,callee);
                 }
@@ -83,7 +83,7 @@ PTACallGraph* ThreadCallGraphBuilder::buildThreadCallGraph(SVFModule* svfModule)
             const Instruction *inst = &*II;
             if (tdAPI->isTDFork(inst))
             {
-                const CallICFGNode* cs = icfg->getCallBlockNode(inst);
+                const CallICFGNode* cs = icfg->getCallICFGNode(inst);
                 cg->addForksite(cs);
                 const Function* forkee = SVFUtil::dyn_cast<Function>(tdAPI->getForkedFun(inst));
                 if (forkee)
@@ -98,7 +98,7 @@ PTACallGraph* ThreadCallGraphBuilder::buildThreadCallGraph(SVFModule* svfModule)
             }
             else if (tdAPI->isHareParFor(inst))
             {
-                const CallICFGNode* cs = icfg->getCallBlockNode(inst);
+                const CallICFGNode* cs = icfg->getCallICFGNode(inst);
                 cg->addParForSite(cs);
                 const Function* taskFunc = SVFUtil::dyn_cast<Function>(tdAPI->getTaskFuncAtHareParForSite(inst));
                 if (taskFunc)
@@ -122,7 +122,7 @@ PTACallGraph* ThreadCallGraphBuilder::buildThreadCallGraph(SVFModule* svfModule)
             const Instruction *inst = &*II;
             if (tdAPI->isTDJoin(inst))
             {
-                const CallICFGNode* cs = icfg->getCallBlockNode(inst);
+                const CallICFGNode* cs = icfg->getCallICFGNode(inst);
                 cg->addJoinsite(cs);
             }
         }

package/lib/SVF-FE/ICFGBuilder.cpp

@@ -58,7 +58,7 @@ void ICFGBuilder::build(SVFModule* svfModule)
  */
 void ICFGBuilder::processFunEntry(const SVFFunction*  fun, WorkList& worklist)
 {
-    FunEntryICFGNode* FunEntryICFGNode = icfg->getFunEntryBlockNode(fun);
+    FunEntryICFGNode* FunEntryICFGNode = icfg->getFunEntryICFGNode(fun);
     const Instruction* entryInst = &((fun->getLLVMFun()->getEntryBlock()).front());
     InstVec insts;
     if (isIntrinsicInst(entryInst))
@@ -92,7 +92,7 @@ void ICFGBuilder::processFunBody(WorkList& worklist)
             {
                 const Function* fun = inst->getFunction();
                 const SVFFunction* svfFun = LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(fun);
-                FunExitICFGNode* FunExitICFGNode = icfg->getFunExitBlockNode(svfFun);
+                FunExitICFGNode* FunExitICFGNode = icfg->getFunExitICFGNode(svfFun);
                 icfg->addIntraEdge(srcNode, FunExitICFGNode);
             }
             InstVec nextInsts;
@@ -105,7 +105,7 @@ void ICFGBuilder::processFunBody(WorkList& worklist)
                 ICFGNode* dstNode = getOrAddBlockICFGNode(succ);
                 if (isNonInstricCallSite(inst))
                 {
-                    RetICFGNode* retICFGNode = getOrAddRetICFGNode(inst);
+                    RetICFGNode* retICFGNode = getRetICFGNode(inst);
                     srcNode = retICFGNode;
                 }
 
@@ -138,7 +138,7 @@ void ICFGBuilder::processFunBody(WorkList& worklist)
  */
 void ICFGBuilder::processFunExit(const SVFFunction*  fun)
 {
-    FunExitICFGNode* FunExitICFGNode = icfg->getFunExitBlockNode(fun);
+    FunExitICFGNode* FunExitICFGNode = icfg->getFunExitICFGNode(fun);
 
     for (inst_iterator II = inst_begin(fun->getLLVMFun()), EE = inst_end(fun->getLLVMFun()); II != EE; ++II)
     {
@@ -161,7 +161,7 @@ InterICFGNode* ICFGBuilder::getOrAddInterBlockICFGNode(const Instruction* inst)
 {
     assert(SVFUtil::isCallSite(inst) && "not a call instruction?");
     assert(SVFUtil::isNonInstricCallSite(inst) && "associating an intrinsic debug instruction with an ICFGNode!");
-    CallICFGNode* callICFGNode = getOrAddCallICFGNode(inst);
+    CallICFGNode* callICFGNode = getCallICFGNode(inst);
     addICFGInterEdges(inst, getCallee(inst));                       //creating interprocedural edges
     return callICFGNode;
 }
@@ -171,28 +171,28 @@ InterICFGNode* ICFGBuilder::getOrAddInterBlockICFGNode(const Instruction* inst)
  */
 void ICFGBuilder::addICFGInterEdges(const Instruction* cs, const SVFFunction* callee)
 {
-    CallICFGNode* CallICFGNode = getOrAddCallICFGNode(cs);
-    RetICFGNode* retBlockNode = getOrAddRetICFGNode(cs);
+    CallICFGNode* callICFGNode = getCallICFGNode(cs);
+    RetICFGNode* retBlockNode = getRetICFGNode(cs);
 
     /// direct call  
     if(callee){
         /// if this is an external function (no function body)
         if (isExtCall(callee))
         {
-           icfg->addIntraEdge(CallICFGNode, retBlockNode); 
+           icfg->addIntraEdge(callICFGNode, retBlockNode); 
         }
         /// otherwise connect interprocedural edges 
         else
         {
-            FunEntryICFGNode* calleeEntryNode = icfg->getFunEntryBlockNode(callee);
-            FunExitICFGNode* calleeExitNode = icfg->getFunExitBlockNode(callee);
-            icfg->addCallEdge(CallICFGNode, calleeEntryNode, cs);
+            FunEntryICFGNode* calleeEntryNode = icfg->getFunEntryICFGNode(callee);
+            FunExitICFGNode* calleeExitNode = icfg->getFunExitICFGNode(callee);
+            icfg->addCallEdge(callICFGNode, calleeEntryNode, cs);
             icfg->addRetEdge(calleeExitNode, retBlockNode, cs);
         }
     }
     /// indirect call (don't know callee)
     else{
-        icfg->addIntraEdge(CallICFGNode, retBlockNode); 
+        icfg->addIntraEdge(callICFGNode, retBlockNode); 
     }
 }
 /*
@@ -206,21 +206,9 @@ void ICFGBuilder::connectGlobalToProgEntry(SVFModule* svfModule)
     if(mainFunc == nullptr)
         return;
 
-    FunEntryICFGNode* entryNode = icfg->getFunEntryBlockNode(mainFunc);
-    GlobalICFGNode* globalNode = icfg->getGlobalBlockNode();
-
-    std::vector<ICFGEdge*> toBeRemovedEdges;
-    for(ICFGEdge* edge : entryNode->getOutEdges())
-        toBeRemovedEdges.push_back(edge);
-    
-    for(ICFGEdge* edge : toBeRemovedEdges){
-        assert(SVFUtil::isa<IntraCFGEdge>(edge) && "the outgoing edge of FunEntryICFGNode is not an intraCFGEdge?");
-        icfg->removeICFGEdge(edge);
-        IntraCFGEdge* intraEdge = new IntraCFGEdge(globalNode, edge->getDstNode());
-        icfg->addICFGEdge(intraEdge); 
-    }
-
-    IntraCFGEdge* intraEdge = new IntraCFGEdge(entryNode, globalNode);
+    FunEntryICFGNode* entryNode = icfg->getFunEntryICFGNode(mainFunc);
+    GlobalICFGNode* globalNode = icfg->getGlobalICFGNode();
+    IntraCFGEdge* intraEdge = new IntraCFGEdge(globalNode, entryNode);
     icfg->addICFGEdge(intraEdge);
 }