svf-tools 1.0.342 → 1.0.346

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();
-	CallBlockNode* cbn = tct->getCallBlockNode(call);
+	CallICFGNode* cbn = tct->getCallBlockNode(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();
-	CallBlockNode* cbn = tct->getCallBlockNode(call);
+	CallICFGNode* cbn = tct->getCallBlockNode(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);
-    CallBlockNode* cbn = tct->getCallBlockNode(call);
+    CallICFGNode* cbn = tct->getCallBlockNode(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);
-    CallBlockNode* cbn = tct->getCallBlockNode(call);
+    CallICFGNode* cbn = tct->getCallBlockNode(call);
     CallSiteID csId = getTCG()->getCallSiteID(cbn, svfcallee);
 
 //    /// handle calling context for candidate functions only

package/lib/MTA/MHP.cpp

@@ -244,7 +244,7 @@ void MHP::handleFork(const CxtThreadStmt& cts, NodeID rootTid)
     const CallStrCxt& curCxt = cts.getContext();
 
     assert(isTDFork(call));
-    CallBlockNode* cbn = getCBN(call);
+    CallICFGNode* cbn = getCBN(call);
     if(tct->getThreadCallGraph()->hasCallGraphEdge(cbn))
     {
     	
@@ -324,7 +324,7 @@ void MHP::handleCall(const CxtThreadStmt& cts, NodeID rootTid)
 
     const CallInst* call = SVFUtil::cast<CallInst>(cts.getStmt());
     const CallStrCxt& curCxt = cts.getContext();
-	CallBlockNode* cbn = getCBN(call);
+	CallICFGNode* cbn = getCBN(call);
     if(tct->getThreadCallGraph()->hasCallGraphEdge(cbn))
     {
         for (PTACallGraph::CallGraphEdgeSet::const_iterator cgIt = tcg->getCallEdgeBegin(cbn),
@@ -830,7 +830,7 @@ void ForkJoinAnalysis::handleFork(const CxtStmt& cts, NodeID rootTid)
     const CallStrCxt& curCxt = cts.getContext();
 
     assert(isTDFork(call));
-	CallBlockNode* cbn = getCBN(call);
+	CallICFGNode* cbn = getCBN(call);
     if(getTCG()->hasThreadForkEdge(cbn))
     {
         for (ThreadCallGraph::ForkEdgeSet::const_iterator cgIt = getTCG()->getForkEdgeBegin(cbn),
@@ -856,7 +856,7 @@ void ForkJoinAnalysis::handleJoin(const CxtStmt& cts, NodeID rootTid)
     const CallStrCxt& curCxt = cts.getContext();
 
     assert(isTDJoin(call));
-	CallBlockNode* cbn = getCBN(call);
+	CallICFGNode* cbn = getCBN(call);
     if(getTCG()->hasCallGraphEdge(cbn))
     {
         const Instruction* forkSite = tct->getTCTNode(rootTid)->getCxtThread().getThread();
@@ -915,7 +915,7 @@ void ForkJoinAnalysis::handleCall(const CxtStmt& cts, NodeID rootTid)
 
     const CallInst* call = SVFUtil::cast<CallInst>(cts.getStmt());
     const CallStrCxt& curCxt = cts.getContext();
-	CallBlockNode* cbn = getCBN(call);
+	CallICFGNode* cbn = getCBN(call);
     if(getTCG()->hasCallGraphEdge(cbn))
     {
         for (PTACallGraph::CallGraphEdgeSet::const_iterator cgIt = getTCG()->getCallEdgeBegin(cbn),

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");
-        CallBlockNode* cbn = mhp->getTCT()->getCallBlockNode(cs.getInstruction());
+        CallICFGNode* cbn = mhp->getTCT()->getCallBlockNode(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))
                 {
-                	CallBlockNode* cbn = getCallBlockNode(inst);
+                	CallICFGNode* cbn = getCallBlockNode(inst);
                     if (callgraph->hasCallGraphEdge(cbn))
                     {
                         for (PTACallGraph::CallGraphEdgeSet::const_iterator cgIt = callgraph->getCallEdgeBegin(cbn),

package/lib/MemoryModel/PointerAnalysis.cpp

@@ -348,7 +348,7 @@ void PointerAnalysis::dumpPts(NodeID ptr, const PointsTo& pts)
 /*!
  * Print indirect call targets at an indirect callsite
  */
-void PointerAnalysis::printIndCSTargets(const CallBlockNode* cs, const FunctionSet& targets)
+void PointerAnalysis::printIndCSTargets(const CallICFGNode* cs, const FunctionSet& targets)
 {
     outs() << "\nNodeID: " << getFunPtr(cs);
     outs() << "\nCallSite: ";
@@ -385,7 +385,7 @@ void PointerAnalysis::printIndCSTargets()
     CallEdgeMap::const_iterator eit = callEdges.end();
     for (; it != eit; ++it)
     {
-        const CallBlockNode* cs = it->first;
+        const CallICFGNode* cs = it->first;
         const FunctionSet& targets = it->second;
         printIndCSTargets(cs, targets);
     }
@@ -395,7 +395,7 @@ void PointerAnalysis::printIndCSTargets()
     CallSiteToFunPtrMap::const_iterator csEit = indCS.end();
     for (; csIt != csEit; ++csIt)
     {
-        const CallBlockNode* cs = csIt->first;
+        const CallICFGNode* cs = csIt->first;
         if (hasIndCSCallees(cs) == false)
         {
             outs() << "\nNodeID: " << csIt->second;
@@ -412,7 +412,7 @@ void PointerAnalysis::printIndCSTargets()
 /*!
  * Resolve indirect calls
  */
-void PointerAnalysis::resolveIndCalls(const CallBlockNode* cs, const PointsTo& target, CallEdgeMap& newEdges, LLVMCallGraph*)
+void PointerAnalysis::resolveIndCalls(const CallICFGNode* cs, const PointsTo& target, CallEdgeMap& newEdges, LLVMCallGraph*)
 {
 
     assert(pag->isIndirectCallSites(cs) && "not an indirect callsite?");
@@ -460,7 +460,7 @@ void PointerAnalysis::resolveIndCalls(const CallBlockNode* cs, const PointsTo& t
 /*!
  * Match arguments for callsite at caller and callee
  */
-bool PointerAnalysis::matchArgs(const CallBlockNode* cs, const SVFFunction* callee)
+bool PointerAnalysis::matchArgs(const CallICFGNode* cs, const SVFFunction* callee)
 {
     if(ThreadAPI::getThreadAPI()->isTDFork(cs->getCallSite()))
         return true;
@@ -471,7 +471,7 @@ bool PointerAnalysis::matchArgs(const CallBlockNode* cs, const SVFFunction* call
 /*
  * Get virtual functions "vfns" based on CHA
  */
-void PointerAnalysis::getVFnsFromCHA(const CallBlockNode* cs, VFunSet &vfns)
+void PointerAnalysis::getVFnsFromCHA(const CallICFGNode* cs, VFunSet &vfns)
 {
     if (chgraph->csHasVFnsBasedonCHA(SVFUtil::getLLVMCallSite(cs->getCallSite())))
         vfns = chgraph->getCSVFsBasedonCHA(SVFUtil::getLLVMCallSite(cs->getCallSite()));
@@ -480,7 +480,7 @@ void PointerAnalysis::getVFnsFromCHA(const CallBlockNode* cs, VFunSet &vfns)
 /*
  * Get virtual functions "vfns" from PoninsTo set "target" for callsite "cs"
  */
-void PointerAnalysis::getVFnsFromPts(const CallBlockNode* cs, const PointsTo &target, VFunSet &vfns)
+void PointerAnalysis::getVFnsFromPts(const CallICFGNode* cs, const PointsTo &target, VFunSet &vfns)
 {
 
     if (chgraph->csHasVtblsBasedonCHA(SVFUtil::getLLVMCallSite(cs->getCallSite())))
@@ -506,7 +506,7 @@ void PointerAnalysis::getVFnsFromPts(const CallBlockNode* cs, const PointsTo &ta
 /*
  * Connect callsite "cs" to virtual functions in "vfns"
  */
-void PointerAnalysis::connectVCallToVFns(const CallBlockNode* cs, const VFunSet &vfns, CallEdgeMap& newEdges)
+void PointerAnalysis::connectVCallToVFns(const CallICFGNode* cs, const VFunSet &vfns, CallEdgeMap& newEdges)
 {
     //// connect all valid functions
     for (VFunSet::const_iterator fit = vfns.begin(),
@@ -521,14 +521,14 @@ void PointerAnalysis::connectVCallToVFns(const CallBlockNode* cs, const VFunSet
         {
             newEdges[cs].insert(callee);
             getIndCallMap()[cs].insert(callee);
-            const CallBlockNode* callBlockNode = pag->getICFG()->getCallBlockNode(cs->getCallSite());
+            const CallICFGNode* callBlockNode = pag->getICFG()->getCallBlockNode(cs->getCallSite());
             ptaCallGraph->addIndirectCallGraphEdge(callBlockNode, cs->getCaller(),callee);
         }
     }
 }
 
 /// Resolve cpp indirect call edges
-void PointerAnalysis::resolveCPPIndCalls(const CallBlockNode* cs, const PointsTo& target, CallEdgeMap& newEdges)
+void PointerAnalysis::resolveCPPIndCalls(const CallICFGNode* cs, const PointsTo& target, CallEdgeMap& newEdges)
 {
     assert(isVirtualCallSite(SVFUtil::getLLVMCallSite(cs->getCallSite())) && "not cpp virtual call");
 

package/lib/MemoryModel/PointerAnalysisImpl.cpp

@@ -382,7 +382,7 @@ void BVDataPTAImpl::onTheFlyCallGraphSolve(const CallSiteToFunPtrMap& callsites,
 {
     for(CallSiteToFunPtrMap::const_iterator iter = callsites.begin(), eiter = callsites.end(); iter!=eiter; ++iter)
     {
-        const CallBlockNode* cs = iter->first;
+        const CallICFGNode* cs = iter->first;
 
         if (isVirtualCallSite(SVFUtil::getLLVMCallSite(cs->getCallSite())))
         {

package/lib/MemoryModel/SVFIR.cpp

@@ -201,7 +201,7 @@ LoadStmt* SVFIR::addLoadStmt(NodeID src, NodeID dst)
  * Add Store edge
  * Note that two store instructions may share the same Store SVFStmt
  */
-StoreStmt* SVFIR::addStoreStmt(NodeID src, NodeID dst, const IntraBlockNode* curVal)
+StoreStmt* SVFIR::addStoreStmt(NodeID src, NodeID dst, const IntraICFGNode* curVal)
 {
     SVFVar* srcNode = getGNode(src);
     SVFVar* dstNode = getGNode(dst);
@@ -219,7 +219,7 @@ StoreStmt* SVFIR::addStoreStmt(NodeID src, NodeID dst, const IntraBlockNode* cur
 /*!
  * Add Call edge
  */
-CallPE* SVFIR::addCallPE(NodeID src, NodeID dst, const CallBlockNode* cs)
+CallPE* SVFIR::addCallPE(NodeID src, NodeID dst, const CallICFGNode* cs)
 {
     SVFVar* srcNode = getGNode(src);
     SVFVar* dstNode = getGNode(dst);
@@ -237,7 +237,7 @@ CallPE* SVFIR::addCallPE(NodeID src, NodeID dst, const CallBlockNode* cs)
 /*!
  * Add Return edge
  */
-RetPE* SVFIR::addRetPE(NodeID src, NodeID dst, const CallBlockNode* cs)
+RetPE* SVFIR::addRetPE(NodeID src, NodeID dst, const CallICFGNode* cs)
 {
     SVFVar* srcNode = getGNode(src);
     SVFVar* dstNode = getGNode(dst);
@@ -266,7 +266,7 @@ SVFStmt* SVFIR::addBlackHoleAddrStmt(NodeID node)
 /*!
  * Add Thread fork edge for parameter passing from a spawner to its spawnees
  */
-TDForkPE* SVFIR::addThreadForkPE(NodeID src, NodeID dst, const CallBlockNode* cs)
+TDForkPE* SVFIR::addThreadForkPE(NodeID src, NodeID dst, const CallICFGNode* cs)
 {
     SVFVar* srcNode = getGNode(src);
     SVFVar* dstNode = getGNode(dst);
@@ -284,7 +284,7 @@ TDForkPE* SVFIR::addThreadForkPE(NodeID src, NodeID dst, const CallBlockNode* cs
 /*!
  * Add Thread fork edge for parameter passing from a spawnee back to its spawners
  */
-TDJoinPE* SVFIR::addThreadJoinPE(NodeID src, NodeID dst, const CallBlockNode* cs)
+TDJoinPE* SVFIR::addThreadJoinPE(NodeID src, NodeID dst, const CallICFGNode* cs)
 {
     SVFVar* srcNode = getGNode(src);
     SVFVar* dstNode = getGNode(dst);

package/lib/SABER/DoubleFreeChecker.cpp

@@ -38,7 +38,7 @@ void DoubleFreeChecker::reportBug(ProgSlice* slice)
     if(slice->isSatisfiableForPairs() == false)
     {
         const SVFGNode* src = slice->getSource();
-        const CallBlockNode* cs = getSrcCSID(src);
+        const CallICFGNode* cs = getSrcCSID(src);
         SVFUtil::errs() << bugMsg2("\t Double Free :") <<  " memory allocation at : ("
                         << getSourceLoc(cs->getCallSite()) << ")\n";
         SVFUtil::errs() << "\t\t double free path: \n" << slice->evalFinalCond() << "\n";

package/lib/SABER/FileChecker.cpp

@@ -35,14 +35,14 @@ using namespace SVFUtil;
 
 void FileChecker::reportNeverClose(const SVFGNode* src)
 {
-    const CallBlockNode* cs = getSrcCSID(src);
+    const CallICFGNode* cs = getSrcCSID(src);
     SVFUtil::errs() << bugMsg1("\t FileNeverClose :") <<  " file open location at : ("
                     << getSourceLoc(cs->getCallSite()) << ")\n";
 }
 
 void FileChecker::reportPartialClose(const SVFGNode* src)
 {
-    const CallBlockNode* cs = getSrcCSID(src);
+    const CallICFGNode* cs = getSrcCSID(src);
     SVFUtil::errs() << bugMsg2("\t PartialFileClose :") <<  " file open location at : ("
                     << getSourceLoc(cs->getCallSite()) << ")\n";
 }

package/lib/SABER/LeakChecker.cpp

@@ -46,7 +46,7 @@ void LeakChecker::initSrcs()
     for(SVFIR::CSToRetMap::iterator it = pag->getCallSiteRets().begin(),
             eit = pag->getCallSiteRets().end(); it!=eit; ++it)
     {
-        const RetBlockNode* cs = it->first;
+        const RetICFGNode* cs = it->first;
         /// if this callsite return reside in a dead function then we do not care about its leaks
         /// for example instruction `int* p = malloc(size)` is in a dead function, then program won't allocate this memory
         /// for example a customized malloc `int p = malloc()` returns an integer value, then program treat it as a system malloc
@@ -65,8 +65,8 @@ void LeakChecker::initSrcs()
                 worklist.push(it->first->getCallBlockNode());
                 while (!worklist.empty())
                 {
-                    const CallBlockNode* cs = worklist.pop();
-                    const RetBlockNode* retBlockNode = icfg->getRetBlockNode(cs->getCallSite());
+                    const CallICFGNode* cs = worklist.pop();
+                    const RetICFGNode* retBlockNode = icfg->getRetBlockNode(cs->getCallSite());
                     const PAGNode* pagNode = pag->getCallSiteRet(retBlockNode);
                     const SVFGNode* node = getSVFG()->getDefSVFGNode(pagNode);
                     if (visited.test(node->getId()) == 0)
@@ -138,14 +138,14 @@ void LeakChecker::initSnks()
 
 void LeakChecker::reportNeverFree(const SVFGNode* src)
 {
-    const CallBlockNode* cs = getSrcCSID(src);
+    const CallICFGNode* cs = getSrcCSID(src);
     SVFUtil::errs() << bugMsg1("\t NeverFree :") <<  " memory allocation at : ("
                     << getSourceLoc(cs->getCallSite()) << ")\n";
 }
 
 void LeakChecker::reportPartialLeak(const SVFGNode* src)
 {
-    const CallBlockNode* cs = getSrcCSID(src);
+    const CallICFGNode* cs = getSrcCSID(src);
     SVFUtil::errs() << bugMsg2("\t PartialLeak :") <<  " memory allocation at : ("
                     << getSourceLoc(cs->getCallSite()) << ")\n";
 }
@@ -175,7 +175,7 @@ void LeakChecker::reportBug(ProgSlice* slice)
 void LeakChecker::testsValidation(const ProgSlice* slice)
 {
     const SVFGNode* source = slice->getSource();
-    const CallBlockNode* cs = getSrcCSID(source);
+    const CallICFGNode* cs = getSrcCSID(source);
     const SVFFunction* fun = getCallee(cs->getCallSite());
     if(fun==nullptr)
         return;
@@ -188,7 +188,7 @@ void LeakChecker::testsValidation(const ProgSlice* slice)
 void LeakChecker::validateSuccessTests(const SVFGNode* source, const SVFFunction* fun)
 {
 
-    const CallBlockNode* cs = getSrcCSID(source);
+    const CallICFGNode* cs = getSrcCSID(source);
 
     bool success = false;
 
@@ -241,7 +241,7 @@ void LeakChecker::validateSuccessTests(const SVFGNode* source, const SVFFunction
 void LeakChecker::validateExpectedFailureTests(const SVFGNode* source, const SVFFunction* fun)
 {
 
-    const CallBlockNode* cs = getSrcCSID(source);
+    const CallICFGNode* cs = getSrcCSID(source);
 
     bool expectedFailure = false;
 

package/lib/SABER/ProgSlice.cpp

@@ -130,7 +130,7 @@ bool ProgSlice::isSatisfiableForPairs()
     return true;
 }
 
-const CallBlockNode* ProgSlice::getCallSite(const SVFGEdge* edge) const
+const CallICFGNode* ProgSlice::getCallSite(const SVFGEdge* edge) const
 {
     assert(edge->isCallVFGEdge() && "not a call svfg edge?");
     if(const CallDirSVFGEdge* callEdge = SVFUtil::dyn_cast<CallDirSVFGEdge>(edge))
@@ -138,7 +138,7 @@ const CallBlockNode* ProgSlice::getCallSite(const SVFGEdge* edge) const
     else
         return getSVFG()->getCallSite(SVFUtil::cast<CallIndSVFGEdge>(edge)->getCallSiteId());
 }
-const CallBlockNode* ProgSlice::getRetSite(const SVFGEdge* edge) const
+const CallICFGNode* ProgSlice::getRetSite(const SVFGEdge* edge) const
 {
     assert(edge->isRetVFGEdge() && "not a return svfg edge?");
     if(const RetDirSVFGEdge* callEdge = SVFUtil::dyn_cast<RetDirSVFGEdge>(edge))

package/lib/SVF-FE/CallGraphBuilder.cpp

@@ -55,7 +55,7 @@ PTACallGraph* CallGraphBuilder::buildCallGraph(SVFModule* svfModule)
             {
                 if(const SVFFunction* callee = getCallee(inst))
                 {
-                    const CallBlockNode* callBlockNode = icfg->getCallBlockNode(inst);
+                    const CallICFGNode* callBlockNode = icfg->getCallBlockNode(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 CallBlockNode* cs = icfg->getCallBlockNode(inst);
+                const CallICFGNode* cs = icfg->getCallBlockNode(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 CallBlockNode* cs = icfg->getCallBlockNode(inst);
+                const CallICFGNode* cs = icfg->getCallBlockNode(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 CallBlockNode* cs = icfg->getCallBlockNode(inst);
+                const CallICFGNode* cs = icfg->getCallBlockNode(inst);
                 cg->addJoinsite(cs);
             }
         }

package/lib/SVF-FE/Graph2Json.cpp

@@ -31,7 +31,7 @@ void ICFGPrinter::printICFGToJson(const std::string& filename)
         llvm::json::Object ICFGNode_Obj;
         ICFGNode_Obj["ICFG_ID"] = id;
         ICFGNode_Obj["Node Type"] = getICFGKind(node->getNodeKind());
-        if(IntraBlockNode* bNode = SVFUtil::dyn_cast<IntraBlockNode>(node))
+        if(IntraICFGNode* bNode = SVFUtil::dyn_cast<IntraICFGNode>(node))
         {
             ICFGNode_Obj["Source Location"] = getSourceLoc(bNode->getInst());
             SVFIR::SVFStmtList&  edges = SVFIR::getPAG()->getPTASVFStmtList(bNode);
@@ -61,7 +61,7 @@ void ICFGPrinter::printICFGToJson(const std::string& filename)
             llvm::json::Value PagEdge_value = llvm::json::Array{PAGEdge_array};
             ICFGNode_Obj["SVFIR Edges"] = PagEdge_value;
         }
-        else if(FunEntryBlockNode* entry = SVFUtil::dyn_cast<FunEntryBlockNode>(node))
+        else if(FunEntryICFGNode* entry = SVFUtil::dyn_cast<FunEntryICFGNode>(node))
         {
             if (isExtCall(entry->getFun()))
                 ICFGNode_Obj["isExtCall"] = true;
@@ -72,7 +72,7 @@ void ICFGPrinter::printICFGToJson(const std::string& filename)
             }
             ICFGNode_Obj["Function Name"] = entry->getFun()->getName();
         }
-        else if (FunExitBlockNode* exit = SVFUtil::dyn_cast<FunExitBlockNode>(node))
+        else if (FunExitICFGNode* exit = SVFUtil::dyn_cast<FunExitICFGNode>(node))
         {
             if (isExtCall(exit->getFun()))
                 ICFGNode_Obj["isExtCall"] = true;
@@ -83,11 +83,11 @@ void ICFGPrinter::printICFGToJson(const std::string& filename)
             }
             ICFGNode_Obj["Function Name"] = exit->getFun()->getName();
         }
-        else if (CallBlockNode* call = SVFUtil::dyn_cast<CallBlockNode>(node))
+        else if (CallICFGNode* call = SVFUtil::dyn_cast<CallICFGNode>(node))
         {
             ICFGNode_Obj["Source Location"] = getSourceLoc(call->getCallSite());
         }
-        else if (RetBlockNode* ret = SVFUtil::dyn_cast<RetBlockNode>(node))
+        else if (RetICFGNode* ret = SVFUtil::dyn_cast<RetICFGNode>(node))
         {
             ICFGNode_Obj["Source Location"] = getSourceLoc(ret->getCallSite());
         }

package/lib/SVF-FE/ICFGBuilder.cpp

@@ -58,7 +58,7 @@ void ICFGBuilder::build(SVFModule* svfModule)
  */
 void ICFGBuilder::processFunEntry(const SVFFunction*  fun, WorkList& worklist)
 {
-    FunEntryBlockNode* FunEntryBlockNode = icfg->getFunEntryBlockNode(fun);
+    FunEntryICFGNode* FunEntryICFGNode = icfg->getFunEntryBlockNode(fun);
     const Instruction* entryInst = &((fun->getLLVMFun()->getEntryBlock()).front());
     InstVec insts;
     if (isIntrinsicInst(entryInst))
@@ -69,7 +69,7 @@ void ICFGBuilder::processFunEntry(const SVFFunction*  fun, WorkList& worklist)
             nit != enit; ++nit)
     {
         ICFGNode* instNode = getOrAddBlockICFGNode(*nit);           //add interprocedure edge
-        icfg->addIntraEdge(FunEntryBlockNode, instNode);
+        icfg->addIntraEdge(FunEntryICFGNode, instNode);
         worklist.push(*nit);
     }
 }
@@ -92,8 +92,8 @@ void ICFGBuilder::processFunBody(WorkList& worklist)
             {
                 const Function* fun = inst->getFunction();
                 const SVFFunction* svfFun = LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(fun);
-                FunExitBlockNode* FunExitBlockNode = icfg->getFunExitBlockNode(svfFun);
-                icfg->addIntraEdge(srcNode, FunExitBlockNode);
+                FunExitICFGNode* FunExitICFGNode = icfg->getFunExitBlockNode(svfFun);
+                icfg->addIntraEdge(srcNode, FunExitICFGNode);
             }
             InstVec nextInsts;
             getNextInsts(inst, nextInsts);
@@ -105,8 +105,7 @@ void ICFGBuilder::processFunBody(WorkList& worklist)
                 ICFGNode* dstNode = getOrAddBlockICFGNode(succ);
                 if (isNonInstricCallSite(inst))
                 {
-                    RetBlockNode* retICFGNode = getOrAddRetICFGNode(inst);
-                    icfg->addIntraEdge(srcNode, retICFGNode);
+                    RetICFGNode* retICFGNode = getOrAddRetICFGNode(inst);
                     srcNode = retICFGNode;
                 }
 
@@ -118,8 +117,7 @@ void ICFGBuilder::processFunBody(WorkList& worklist)
                     else 
                         icfg->addIntraEdge(srcNode, dstNode);
                 }
-
-                if (const SwitchInst* si = SVFUtil::dyn_cast<SwitchInst>(inst))
+                else if (const SwitchInst* si = SVFUtil::dyn_cast<SwitchInst>(inst))
                 {
                     icfg->addConditionalIntraEdge(srcNode, dstNode, si->getCondition(),branchID);
                 }
@@ -140,14 +138,14 @@ void ICFGBuilder::processFunBody(WorkList& worklist)
  */
 void ICFGBuilder::processFunExit(const SVFFunction*  fun)
 {
-    FunExitBlockNode* FunExitBlockNode = icfg->getFunExitBlockNode(fun);
+    FunExitICFGNode* FunExitICFGNode = icfg->getFunExitBlockNode(fun);
 
     for (inst_iterator II = inst_begin(fun->getLLVMFun()), EE = inst_end(fun->getLLVMFun()); II != EE; ++II)
     {
         const Instruction *inst = &*II;
         if(SVFUtil::isa<ReturnInst>(inst)) {
             ICFGNode* instNode = getOrAddBlockICFGNode(inst);
-            icfg->addIntraEdge(instNode, FunExitBlockNode);
+            icfg->addIntraEdge(instNode, FunExitICFGNode);
         }
     }
 }
@@ -159,13 +157,12 @@ void ICFGBuilder::processFunExit(const SVFFunction*  fun)
  * (1) Add and get CallBlockICFGNode
  * (2) Handle call instruction by creating interprocedural edges
  */
-InterBlockNode* ICFGBuilder::getOrAddInterBlockICFGNode(const Instruction* inst)
+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!");
-    CallBlockNode* callICFGNode = getOrAddCallICFGNode(inst);
-    if (const SVFFunction*  callee = getCallee(inst))
-        addICFGInterEdges(inst, callee);                       //creating interprocedural edges
+    CallICFGNode* callICFGNode = getOrAddCallICFGNode(inst);
+    addICFGInterEdges(inst, getCallee(inst));                       //creating interprocedural edges
     return callICFGNode;
 }
 
@@ -174,15 +171,24 @@ InterBlockNode* ICFGBuilder::getOrAddInterBlockICFGNode(const Instruction* inst)
  */
 void ICFGBuilder::addICFGInterEdges(const Instruction* cs, const SVFFunction* callee)
 {
-    CallBlockNode* CallBlockNode = getOrAddCallICFGNode(cs);
-    FunEntryBlockNode* calleeEntryNode = icfg->getFunEntryBlockNode(callee);
-    icfg->addCallEdge(CallBlockNode, calleeEntryNode, cs);
-
-    if (!isExtCall(callee))
-    {
-        RetBlockNode* retBlockNode = getOrAddRetICFGNode(cs);
-        FunExitBlockNode* calleeExitNode = icfg->getFunExitBlockNode(callee);
+    CallICFGNode* CallICFGNode = getOrAddCallICFGNode(cs);
+    RetICFGNode* retBlockNode = getOrAddRetICFGNode(cs);
+
+    /// direct call  
+    if(callee){
+        FunEntryICFGNode* calleeEntryNode = icfg->getFunEntryBlockNode(callee);
+        FunExitICFGNode* calleeExitNode = icfg->getFunExitBlockNode(callee);
+        icfg->addCallEdge(CallICFGNode, calleeEntryNode, cs);
         icfg->addRetEdge(calleeExitNode, retBlockNode, cs);
+        /// if this is an external function (no function body)
+        if (isExtCall(callee))
+        {
+           icfg->addIntraEdge(calleeEntryNode, calleeExitNode); 
+        }
+    }
+    /// indirect call (don't know callee)
+    else{
+        icfg->addIntraEdge(CallICFGNode, retBlockNode); 
     }
 }
 /*
@@ -196,15 +202,15 @@ void ICFGBuilder::connectGlobalToProgEntry(SVFModule* svfModule)
     if(mainFunc == nullptr)
         return;
 
-    FunEntryBlockNode* entryNode = icfg->getFunEntryBlockNode(mainFunc);
-    GlobalBlockNode* globalNode = icfg->getGlobalBlockNode();
+    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 FunEntryBlockNode is not an intraCFGEdge?");
+        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); 

package/lib/SVF-FE/SVFIRBuilder.cpp

@@ -754,8 +754,8 @@ void SVFIRBuilder::visitCallSite(CallSite cs)
     DBOUT(DPAGBuild,
           outs() << "process callsite " << *cs.getInstruction() << "\n");
 
-    CallBlockNode* callBlockNode = pag->getICFG()->getCallBlockNode(cs.getInstruction());
-    RetBlockNode* retBlockNode = pag->getICFG()->getRetBlockNode(cs.getInstruction());
+    CallICFGNode* callBlockNode = pag->getICFG()->getCallBlockNode(cs.getInstruction());
+    RetICFGNode* retBlockNode = pag->getICFG()->getRetBlockNode(cs.getInstruction());
 
     pag->addCallSite(callBlockNode);
 
@@ -918,7 +918,7 @@ void SVFIRBuilder::handleDirectCall(CallSite cs, const SVFFunction *F)
     if (!cs.getType()->isVoidTy())
     {
         NodeID srcret = getReturnNode(F);
-        CallBlockNode* icfgNode = pag->getICFG()->getCallBlockNode(cs.getInstruction());
+        CallICFGNode* icfgNode = pag->getICFG()->getCallBlockNode(cs.getInstruction());
         addRetEdge(srcret, dstrec,icfgNode);
     }
     //Iterators for the actual and formal parameters
@@ -940,7 +940,7 @@ void SVFIRBuilder::handleDirectCall(CallSite cs, const SVFFunction *F)
 
         NodeID dstFA = getValueNode(FA);
         NodeID srcAA = getValueNode(AA);
-        CallBlockNode* icfgNode = pag->getICFG()->getCallBlockNode(cs.getInstruction());
+        CallICFGNode* icfgNode = pag->getICFG()->getCallBlockNode(cs.getInstruction());
         addCallEdge(srcAA, dstFA, icfgNode);
     }
     //Any remaining actual args must be varargs.
@@ -952,7 +952,7 @@ void SVFIRBuilder::handleDirectCall(CallSite cs, const SVFFunction *F)
         {
             Value *AA = *itA;
             NodeID vnAA = getValueNode(AA);
-            CallBlockNode* icfgNode = pag->getICFG()->getCallBlockNode(cs.getInstruction());
+            CallICFGNode* icfgNode = pag->getICFG()->getCallBlockNode(cs.getInstruction());
             addCallEdge(vnAA,vaF, icfgNode);
         }
     }
@@ -1435,7 +1435,7 @@ void SVFIRBuilder::handleExtCall(CallSite cs, const SVFFunction *callee)
                     /// Connect actual parameter to formal parameter of the start routine
                     if(SVFUtil::isa<PointerType>(actualParm->getType()) && SVFUtil::isa<PointerType>(formalParm->getType()) )
                     {
-                        CallBlockNode* icfgNode = pag->getICFG()->getCallBlockNode(inst);
+                        CallICFGNode* icfgNode = pag->getICFG()->getCallBlockNode(inst);
                         addThreadForkEdge(pag->getValueNode(actualParm), pag->getValueNode(formalParm),icfgNode);
                     }
                 }
@@ -1464,7 +1464,7 @@ void SVFIRBuilder::handleExtCall(CallSite cs, const SVFFunction *callee)
                 /// Connect actual parameter to formal parameter of the start routine
                 if(SVFUtil::isa<PointerType>(actualParm->getType()) && SVFUtil::isa<PointerType>(formalParm->getType()) )
                 {
-                    CallBlockNode* icfgNode = pag->getICFG()->getCallBlockNode(inst);
+                    CallICFGNode* icfgNode = pag->getICFG()->getCallBlockNode(inst);
                     addThreadForkEdge(pag->getValueNode(actualParm), pag->getValueNode(formalParm),icfgNode);
                 }
             }
@@ -1486,7 +1486,7 @@ void SVFIRBuilder::handleExtCall(CallSite cs, const SVFFunction *callee)
  */
 void SVFIRBuilder::handleIndCall(CallSite cs)
 {
-    const CallBlockNode* cbn = pag->getICFG()->getCallBlockNode(cs.getInstruction());
+    const CallICFGNode* cbn = pag->getICFG()->getCallBlockNode(cs.getInstruction());
     pag->addIndirectCallsites(cbn,pag->getValueNode(cs.getCalledValue()));
 }