svf-tools 1.0.340 → 1.0.344

package/include/SABER/ProgSlice.h

@@ -162,8 +162,8 @@ public:
 
     /// Get callsite ID and get returnsiteID from SVFGEdge
     //@{
-    const CallBlockNode* getCallSite(const SVFGEdge* edge) const;
-    const CallBlockNode* getRetSite(const SVFGEdge* edge) const;
+    const CallICFGNode* getCallSite(const SVFGEdge* edge) const;
+    const CallICFGNode* getRetSite(const SVFGEdge* edge) const;
     //@}
 
     /// Condition operations

package/include/SABER/SaberCheckerAPI.h

@@ -105,7 +105,7 @@ public:
     {
         return getType(SVFUtil::getCallee(inst)) == CK_ALLOC;
     }
-    inline bool isMemAlloc(const CallBlockNode* cs) const
+    inline bool isMemAlloc(const CallICFGNode* cs) const
     {
         return isMemAlloc(cs->getCallSite());
     }
@@ -121,7 +121,7 @@ public:
     {
         return getType(SVFUtil::getCallee(inst)) == CK_FREE;
     }
-    inline bool isMemDealloc(const CallBlockNode* cs) const
+    inline bool isMemDealloc(const CallICFGNode* cs) const
     {
         return isMemDealloc(cs->getCallSite());
     }
@@ -137,7 +137,7 @@ public:
     {
         return getType(SVFUtil::getCallee(inst)) == CK_FOPEN;
     }
-    inline bool isFOpen(const CallBlockNode* cs) const
+    inline bool isFOpen(const CallICFGNode* cs) const
     {
         return isFOpen(cs->getCallSite());
     }
@@ -153,7 +153,7 @@ public:
     {
         return getType(SVFUtil::getCallee(inst)) == CK_FCLOSE;
     }
-    inline bool isFClose(const CallBlockNode* cs) const
+    inline bool isFClose(const CallICFGNode* cs) const
     {
         return isFClose(cs->getCallSite());
     }

package/include/SABER/SaberSVFGBuilder.h

@@ -57,7 +57,7 @@ public:
     }
 
     /// Add ActualParmVFGNode
-    inline void addActualParmVFGNode(const PAGNode* pagNode, const CallBlockNode* cs)
+    inline void addActualParmVFGNode(const PAGNode* pagNode, const CallICFGNode* cs)
     {
     	svfg->addActualParmVFGNode(pagNode, cs);
     }

package/include/SABER/SrcSnkDDA.h

@@ -53,7 +53,7 @@ public:
     typedef CxtDPItem DPIm;
     typedef Set<DPIm> DPImSet;							///< dpitem set
     typedef Map<const SVFGNode*, DPImSet> SVFGNodeToDPItemsMap; 	///< map a SVFGNode to its visited dpitems
-    typedef Set<const CallBlockNode*> CallSiteSet;
+    typedef Set<const CallICFGNode*> CallSiteSet;
     typedef NodeBS SVFGNodeBS;
     typedef ProgSlice::VFWorkList WorkList;
 

package/include/SVF-FE/ICFGBuilder.h

@@ -69,7 +69,7 @@ private:
     void connectGlobalToProgEntry(SVFModule* svfModule);
 
     /// Add/Get an inter block ICFGNode
-    InterBlockNode* getOrAddInterBlockICFGNode(const Instruction* inst);
+    InterICFGNode* getOrAddInterBlockICFGNode(const Instruction* inst);
 
     /// Add/Get a basic block ICFGNode
     inline ICFGNode* getOrAddBlockICFGNode(const Instruction* inst)
@@ -84,18 +84,18 @@ private:
     void addICFGInterEdges(const Instruction*  cs, const SVFFunction*  callee);
 
     /// Add a call node
-    inline CallBlockNode* getOrAddCallICFGNode(const Instruction*  cs)
+    inline CallICFGNode* getOrAddCallICFGNode(const Instruction*  cs)
     {
         return icfg->getCallBlockNode(cs);
     }
     /// Add a return node
-    inline RetBlockNode* getOrAddRetICFGNode(const Instruction*  cs)
+    inline RetICFGNode* getOrAddRetICFGNode(const Instruction*  cs)
     {
         return icfg->getRetBlockNode(cs);
     }
 
     /// Add and get IntraBlock ICFGNode
-    IntraBlockNode* getOrAddIntraBlockICFGNode(const Instruction* inst)
+    IntraICFGNode* getOrAddIntraBlockICFGNode(const Instruction* inst)
     {
         return icfg->getIntraBlockNode(inst);
     }

package/include/SVF-FE/SVFIRBuilder.h

@@ -343,7 +343,7 @@ public:
     /// Add Store edge
     inline StoreStmt* addStoreEdge(NodeID src, NodeID dst)
     {
-        IntraBlockNode* node;
+        IntraICFGNode* node;
         if(const Instruction* inst = SVFUtil::dyn_cast<Instruction>(curVal))
             node = pag->getICFG()->getIntraBlockNode(inst);
         else
@@ -353,14 +353,14 @@ public:
         return edge;
     }
     /// Add Call edge
-    inline CallPE* addCallEdge(NodeID src, NodeID dst, const CallBlockNode* cs)
+    inline CallPE* addCallEdge(NodeID src, NodeID dst, const CallICFGNode* cs)
     {
         CallPE *edge = pag->addCallPE(src, dst, cs);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
     /// Add Return edge
-    inline RetPE* addRetEdge(NodeID src, NodeID dst, const CallBlockNode* cs)
+    inline RetPE* addRetEdge(NodeID src, NodeID dst, const CallICFGNode* cs)
     {
         RetPE *edge = pag->addRetPE(src, dst, cs);
         setCurrentBBAndValueForPAGEdge(edge);
@@ -388,14 +388,14 @@ public:
         return edge;
     }
     /// Add Thread fork edge for parameter passing
-    inline TDForkPE* addThreadForkEdge(NodeID src, NodeID dst, const CallBlockNode* cs)
+    inline TDForkPE* addThreadForkEdge(NodeID src, NodeID dst, const CallICFGNode* cs)
     {
         TDForkPE *edge = pag->addThreadForkPE(src, dst, cs);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
     /// Add Thread join edge for parameter passing
-    inline TDJoinPE* addThreadJoinEdge(NodeID src, NodeID dst, const CallBlockNode* cs)
+    inline TDJoinPE* addThreadJoinEdge(NodeID src, NodeID dst, const CallICFGNode* cs)
     {
         TDJoinPE *edge = pag->addThreadJoinPE(src, dst, cs);
         setCurrentBBAndValueForPAGEdge(edge);

package/include/Util/Options.h

@@ -131,7 +131,7 @@ public:
     static const llvm::cl::opt<bool> PStat;
     static const llvm::cl::opt<unsigned> StatBudget;
     static const llvm::cl::opt<bool> PAGDotGraph;
-    static const llvm::cl::opt<bool> PAGDotGraphShorter;
+    static const llvm::cl::opt<bool> ShowSVFIRValue;
     static const llvm::cl::opt<bool> DumpICFG;
     static const llvm::cl::opt<bool> CallGraphDotGraph;
     static const llvm::cl::opt<bool> PAGPrint;

package/lib/DDA/ContextDDA.cpp

@@ -164,7 +164,7 @@ CxtPtSet ContextDDA::processGepPts(const GepSVFGNode* gep, const CxtPtSet& srcPt
     return tmpDstPts;
 }
 
-bool ContextDDA::testIndCallReachability(CxtLocDPItem& dpm, const SVFFunction* callee, const CallBlockNode* cs)
+bool ContextDDA::testIndCallReachability(CxtLocDPItem& dpm, const SVFFunction* callee, const CallICFGNode* cs)
 {
     if(getPAG()->isIndirectCallSites(cs))
     {
@@ -194,7 +194,7 @@ CallSiteID ContextDDA::getCSIDAtCall(CxtLocDPItem&, const SVFGEdge* edge)
     else
         svfg_csId = SVFUtil::cast<CallIndSVFGEdge>(edge)->getCallSiteId();
 
-    const CallBlockNode* cbn = getSVFG()->getCallSite(svfg_csId);
+    const CallICFGNode* cbn = getSVFG()->getCallSite(svfg_csId);
     const SVFFunction* callee = edge->getDstNode()->getFun();
 
     if(getPTACallGraph()->hasCallSiteID(cbn,callee))
@@ -218,7 +218,7 @@ CallSiteID ContextDDA::getCSIDAtRet(CxtLocDPItem&, const SVFGEdge* edge)
     else
         svfg_csId = SVFUtil::cast<RetIndSVFGEdge>(edge)->getCallSiteId();
 
-    const CallBlockNode* cbn = getSVFG()->getCallSite(svfg_csId);
+    const CallICFGNode* cbn = getSVFG()->getCallSite(svfg_csId);
     const SVFFunction* callee = edge->getSrcNode()->getFun();
 
     if(getPTACallGraph()->hasCallSiteID(cbn,callee))

package/lib/DDA/DDAClient.cpp

@@ -95,7 +95,7 @@ void FunptrDDAClient::performStat(PointerAnalysis* pta)
         const PointsTo& anderPts = ander->getPts(vtptr);
 
         PTACallGraph* callgraph = ander->getPTACallGraph();
-        const CallBlockNode* cbn = nIter->second;
+        const CallICFGNode* cbn = nIter->second;
 
         if(!callgraph->hasIndCSCallees(cbn))
         {

package/lib/DDA/FlowDDA.cpp

@@ -59,7 +59,7 @@ void FlowDDA::handleOutOfBudgetDpm(const LocDPItem& dpm)
 bool FlowDDA::testIndCallReachability(LocDPItem&, const SVFFunction* callee, CallSiteID csId)
 {
 
-    const CallBlockNode* cbn = getSVFG()->getCallSite(csId);
+    const CallICFGNode* cbn = getSVFG()->getCallSite(csId);
 
     if(getPAG()->isIndirectCallSites(cbn))
     {

package/lib/Graphs/ICFG.cpp

@@ -38,7 +38,7 @@ using namespace SVF;
 using namespace SVFUtil;
 
 
-FunEntryBlockNode::FunEntryBlockNode(NodeID id, const SVFFunction* f) : InterBlockNode(id, FunEntryBlock)
+FunEntryICFGNode::FunEntryICFGNode(NodeID id, const SVFFunction* f) : InterICFGNode(id, FunEntryBlock)
 {
     fun = f;
     // if function is implemented
@@ -47,7 +47,7 @@ FunEntryBlockNode::FunEntryBlockNode(NodeID id, const SVFFunction* f) : InterBlo
     }
 }
 
-FunExitBlockNode::FunExitBlockNode(NodeID id, const SVFFunction* f) : InterBlockNode(id, FunExitBlock), fun(f), formalRet(nullptr)
+FunExitICFGNode::FunExitICFGNode(NodeID id, const SVFFunction* f) : InterICFGNode(id, FunExitBlock), fun(f), formalRet(nullptr)
 {
     fun = f;
     // if function is implemented
@@ -61,7 +61,7 @@ FunExitBlockNode::FunExitBlockNode(NodeID id, const SVFFunction* f) : InterBlock
 const std::string ICFGNode::toString() const {
     std::string str;
     raw_string_ostream rawstr(str);
-    rawstr << "ICFGNode ID: " << getId();
+    rawstr << "ICFGNode" << getId();
     return rawstr.str();
 }
 
@@ -69,68 +69,80 @@ void ICFGNode::dump() const {
     outs() << this->toString() << "\n";
 }
 
-const std::string GlobalBlockNode::toString() const {
+const std::string GlobalICFGNode::toString() const {
     std::string str;
     raw_string_ostream rawstr(str);
-    rawstr << "GlobalBlockNode ID: " << getId();
+    rawstr << "GlobalICFGNode" << getId();
+    for (const SVFStmt *stmt : getSVFStmts())
+        rawstr << "\n" << stmt->toString();
     return rawstr.str();
 }
 
 
-const std::string IntraBlockNode::toString() const {
+const std::string IntraICFGNode::toString() const {
     std::string str;
     raw_string_ostream rawstr(str);
-    rawstr << "IntraBlockNode ID: " << getId();
-    rawstr << value2String(getInst()) << " {fun: " << getFun()->getName() << "}";
+    rawstr << "IntraICFGNode" << getId();
+    rawstr << " {fun: " << getFun()->getName() << getSourceLoc(getInst()) << "}";
+    for (const SVFStmt *stmt : getSVFStmts())
+        rawstr << "\n" << stmt->toString();
+    if(getSVFStmts().empty())
+        rawstr << "\n" << value2String(getInst());
     return rawstr.str();
 }
 
 
-const std::string FunEntryBlockNode::toString() const {
+const std::string FunEntryICFGNode::toString() const {
     std::string str;
     raw_string_ostream rawstr(str);
-    rawstr << "FunEntryBlockNode ID: " << getId();
-    if (isExtCall(getFun()))
-        rawstr << " Entry(" << ")\n";
-    else
-        rawstr << " Entry(" << getSourceLoc(getFun()->getLLVMFun()) << ")\n";
-    rawstr << " {fun: " << getFun()->getName() << "}";
+    rawstr << "FunEntryICFGNode" << getId();
+    rawstr << " {fun: " << getFun()->getName();
+    if (isExtCall(getFun())==false)
+        rawstr << getSourceLoc(getFun()->getLLVMFun());
+    rawstr << "}";
+    for (const SVFStmt *stmt : getSVFStmts())
+        rawstr << "\n" << stmt->toString();
     return rawstr.str();
 }
 
-const std::string FunExitBlockNode::toString() const {
+const std::string FunExitICFGNode::toString() const {
     std::string str;
     raw_string_ostream rawstr(str);
-    rawstr << "FunExitBlockNode ID: " << getId();
-    if (isExtCall(getFun()))
-        rawstr << " Exit(" << ")\n";
-    else
-        rawstr << " Exit(" << getSourceLoc(getFunExitBB(getFun()->getLLVMFun())->getFirstNonPHI()) << ")\n";
-    rawstr << " {fun: " << getFun()->getName() << "}";
+    rawstr << "FunExitICFGNode" << getId();
+    rawstr << " {fun: " << getFun()->getName();
+    if (isExtCall(getFun())==false)
+        rawstr << getSourceLoc(getFunExitBB(getFun()->getLLVMFun())->getFirstNonPHI());
+    rawstr << "}";
+    for (const SVFStmt *stmt : getSVFStmts())
+        rawstr << "\n" << stmt->toString();
     return rawstr.str();
 }
 
 
-const std::string CallBlockNode::toString() const {
+const std::string CallICFGNode::toString() const {
     std::string str;
     raw_string_ostream rawstr(str);
-    rawstr << "CallBlockNode ID: " << getId();
-    rawstr << value2String(getCallSite()) << " {fun: " << getFun()->getName() << "}";
+    rawstr << "CallICFGNode" << getId();
+    rawstr << " {fun: " << getFun()->getName() << getSourceLoc(getCallSite()) << "}";
+    for (const SVFStmt *stmt : getSVFStmts())
+        rawstr << "\n" << stmt->toString();
     return rawstr.str();
 }
 
-const std::string RetBlockNode::toString() const {
+const std::string RetICFGNode::toString() const {
     std::string str;
     raw_string_ostream rawstr(str);
-    rawstr << "RetBlockNode ID: " << getId();
-    rawstr << value2String(getCallSite()) << " {fun: " << getFun()->getName() << "}";
+    rawstr << "RetICFGNode" << getId();
+    rawstr << " {fun: " << getFun()->getName() << getSourceLoc(getCallSite()) << "}";
+    for (const SVFStmt *stmt : getSVFStmts())
+        rawstr << "\n" << stmt->toString();
     return rawstr.str();
 }
 
 const std::string ICFGEdge::toString() const {
     std::string str;
     raw_string_ostream rawstr(str);
-    rawstr << "ICFGEdge: [" << getDstID() << "<--" << getSrcID() << "]\t";
+    rawstr << "ICFGEdge: [ICFGNode" << getDstID() << " <-- ICFGNode" << getSrcID() << "]\t";
     return rawstr.str();
 }
 
@@ -138,9 +150,9 @@ const std::string IntraCFGEdge::toString() const {
     std::string str;
     raw_string_ostream rawstr(str);
     if(brCondition.first == nullptr)
-        rawstr << "IntraCFGEdge: [" << getDstID() << "<--" << getSrcID() << "]\t";
+        rawstr << "IntraCFGEdge: [ICFGNode" << getDstID() << " <-- ICFGNode" << getSrcID() << "]\t";
     else
-        rawstr << "IntraCFGEdge: [" << getDstID() << "<--" << getSrcID() << "] with condition (" << *brCondition.first << "==" << brCondition.second << ") \t";
+        rawstr << "IntraCFGEdge: [ICFGNode" << getDstID() << " <-- ICFGNode" << getSrcID() << "] with condition (" << *brCondition.first << "==" << brCondition.second << ") \t";
 
     return rawstr.str();
 }
@@ -148,16 +160,16 @@ const std::string IntraCFGEdge::toString() const {
 const std::string CallCFGEdge::toString() const {
     std::string str;
     raw_string_ostream rawstr(str);
-    rawstr << "CallCFGEdge " << " [";
-    rawstr << getDstID() << "<--" << getSrcID() << "]\t CallSite: " << *cs << "\t";
+    rawstr << "CallCFGEdge " << " [ICFGNode";
+    rawstr << getDstID() << " <-- ICFGNode" << getSrcID() << "]\t CallSite: " << *cs << "\t";
     return rawstr.str();
 }
 
 const std::string RetCFGEdge::toString() const {
     std::string str;
     raw_string_ostream rawstr(str);
-    rawstr << "RetCFGEdge " << " [";
-    rawstr << getDstID() << "<--" << getSrcID() << "]\t CallSite: " << *cs << "\t";
+    rawstr << "RetCFGEdge " << " [ICFGNode";
+    rawstr << getDstID() << " <-- ICFGNode" << getSrcID() << "]\t CallSite: " << *cs << "\t";
     return rawstr.str();
 }
 
@@ -172,7 +184,7 @@ const std::string RetCFGEdge::toString() const {
 ICFG::ICFG(): totalICFGNode(0)
 {
     DBOUT(DGENERAL, outs() << pasMsg("\tCreate ICFG ...\n"));
-    globalBlockNode = new GlobalBlockNode(totalICFGNode++);
+    globalBlockNode = new GlobalICFGNode(totalICFGNode++);
     addICFGNode(globalBlockNode);
 }
 
@@ -194,51 +206,51 @@ ICFGNode* ICFG::getBlockICFGNode(const Instruction* inst)
 }
 
 
-CallBlockNode* ICFG::getCallBlockNode(const Instruction* inst)
+CallICFGNode* ICFG::getCallBlockNode(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!");
-    CallBlockNode* node = getCallICFGNode(inst);
+    CallICFGNode* node = getCallICFGNode(inst);
     if(node==nullptr)
         node = addCallICFGNode(inst);
-    assert (node!=nullptr && "no CallBlockNode for this instruction?");
+    assert (node!=nullptr && "no CallICFGNode for this instruction?");
     return node;
 }
 
-RetBlockNode* ICFG::getRetBlockNode(const Instruction* inst)
+RetICFGNode* ICFG::getRetBlockNode(const Instruction* inst)
 {
     assert(SVFUtil::isCallSite(inst) && "not a call instruction?");
     assert(SVFUtil::isNonInstricCallSite(inst) && "associating an intrinsic debug instruction with an ICFGNode!");
-    RetBlockNode* node = getRetICFGNode(inst);
+    RetICFGNode* node = getRetICFGNode(inst);
     if(node==nullptr)
         node = addRetICFGNode(inst);
-    assert (node!=nullptr && "no RetBlockNode for this instruction?");
+    assert (node!=nullptr && "no RetICFGNode for this instruction?");
     return node;
 }
 
-IntraBlockNode* ICFG::getIntraBlockNode(const Instruction* inst)
+IntraICFGNode* ICFG::getIntraBlockNode(const Instruction* inst)
 {
-    IntraBlockNode* node = getIntraBlockICFGNode(inst);
+    IntraICFGNode* node = getIntraBlockICFGNode(inst);
     if(node==nullptr)
         node = addIntraBlockICFGNode(inst);
     return node;
 }
 
 /// Add a function entry node
-FunEntryBlockNode* ICFG::getFunEntryBlockNode(const SVFFunction*  fun)
+FunEntryICFGNode* ICFG::getFunEntryBlockNode(const SVFFunction*  fun)
 {
-    FunEntryBlockNode* b = getFunEntryICFGNode(fun);
+    FunEntryICFGNode* b = getFunEntryICFGNode(fun);
     if (b == nullptr)
         return addFunEntryICFGNode(fun);
     else
         return b;
 }
 /// Add a function exit node
-FunExitBlockNode* ICFG::getFunExitBlockNode(const SVFFunction*  fun)
+FunExitICFGNode* ICFG::getFunExitBlockNode(const SVFFunction*  fun)
 {
-    FunExitBlockNode* b = getFunExitICFGNode(fun);
+    FunExitICFGNode* b = getFunExitICFGNode(fun);
     if (b == nullptr)
         return addFunExitICFGNode(fun);
     else
@@ -417,22 +429,27 @@ void ICFG::updateCallGraph(PTACallGraph* callgraph)
     PTACallGraph::CallEdgeMap::const_iterator eiter = callgraph->getIndCallMap().end();
     for (; iter != eiter; iter++)
     {
-        const CallBlockNode* callBlock = iter->first;
+        const CallICFGNode* callBlock = iter->first;
         const Instruction* cs = callBlock->getCallSite();
         assert(callBlock->isIndirectCall() && "this is not an indirect call?");
         const PTACallGraph::FunctionSet & functions = iter->second;
         for (PTACallGraph::FunctionSet::const_iterator func_iter = functions.begin(); func_iter != functions.end(); func_iter++)
         {
             const SVFFunction*  callee = *func_iter;
-            CallBlockNode* CallBlockNode = getCallBlockNode(cs);
-            if (!isExtCall(callee))
-            {
-                FunEntryBlockNode* calleeEntryNode = getFunEntryICFGNode(callee);
-                addCallEdge(CallBlockNode, calleeEntryNode, cs);
-                RetBlockNode* retBlockNode = getRetBlockNode(cs);
-                FunExitBlockNode* calleeExitNode = getFunExitICFGNode(callee);
-                addRetEdge(calleeExitNode, retBlockNode, cs);
-            }
+            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
+            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);
         }
     }
 }
@@ -469,9 +486,9 @@ struct DOTGraphTraits<ICFG*> : public DOTGraphTraits<SVFIR*>
         std::string str;
         raw_string_ostream rawstr(str);
         rawstr << "NodeID: " << node->getId() << "\n";
-        if (IntraBlockNode* bNode = SVFUtil::dyn_cast<IntraBlockNode>(node))
+        if (IntraICFGNode* bNode = SVFUtil::dyn_cast<IntraICFGNode>(node))
         {
-            rawstr << "IntraBlockNode ID: " << bNode->getId() << " \t";
+            rawstr << "IntraICFGNode ID: " << bNode->getId() << " \t";
             SVFIR::SVFStmtList&  edges = SVFIR::getPAG()->getSVFStmtList(bNode);
             if (edges.empty()) {
                 rawstr << value2String(bNode->getInst()) << " \t";
@@ -484,23 +501,23 @@ struct DOTGraphTraits<ICFG*> : public DOTGraphTraits<SVFIR*>
             }
             rawstr << " {fun: " << bNode->getFun()->getName() << "}";
         }
-        else if (FunEntryBlockNode* entry = SVFUtil::dyn_cast<FunEntryBlockNode>(node))
+        else if (FunEntryICFGNode* entry = SVFUtil::dyn_cast<FunEntryICFGNode>(node))
         {
             rawstr << entry->toString();
         }
-        else if (FunExitBlockNode* exit = SVFUtil::dyn_cast<FunExitBlockNode>(node))
+        else if (FunExitICFGNode* exit = SVFUtil::dyn_cast<FunExitICFGNode>(node))
         {
             rawstr << exit->toString();
         }
-        else if (CallBlockNode* call = SVFUtil::dyn_cast<CallBlockNode>(node))
+        else if (CallICFGNode* call = SVFUtil::dyn_cast<CallICFGNode>(node))
         {
             rawstr << call->toString();
         }
-        else if (RetBlockNode* ret = SVFUtil::dyn_cast<RetBlockNode>(node))
+        else if (RetICFGNode* ret = SVFUtil::dyn_cast<RetICFGNode>(node))
         {
             rawstr << ret->toString();
         }
-        else if (GlobalBlockNode* glob  = SVFUtil::dyn_cast<GlobalBlockNode>(node) )
+        else if (GlobalICFGNode* glob  = SVFUtil::dyn_cast<GlobalICFGNode>(node) )
         {
             SVFIR::SVFStmtList&  edges = SVFIR::getPAG()->getSVFStmtList(glob);
             for (SVFIR::SVFStmtList::iterator it = edges.begin(), eit = edges.end(); it != eit; ++it)
@@ -520,27 +537,27 @@ struct DOTGraphTraits<ICFG*> : public DOTGraphTraits<SVFIR*>
         std::string str;
         raw_string_ostream rawstr(str);
 
-        if(SVFUtil::isa<IntraBlockNode>(node))
+        if(SVFUtil::isa<IntraICFGNode>(node))
         {
             rawstr <<  "color=black";
         }
-        else if(SVFUtil::isa<FunEntryBlockNode>(node))
+        else if(SVFUtil::isa<FunEntryICFGNode>(node))
         {
             rawstr <<  "color=yellow";
         }
-        else if(SVFUtil::isa<FunExitBlockNode>(node))
+        else if(SVFUtil::isa<FunExitICFGNode>(node))
         {
             rawstr <<  "color=green";
         }
-        else if(SVFUtil::isa<CallBlockNode>(node))
+        else if(SVFUtil::isa<CallICFGNode>(node))
         {
             rawstr <<  "color=red";
         }
-        else if(SVFUtil::isa<RetBlockNode>(node))
+        else if(SVFUtil::isa<RetICFGNode>(node))
         {
             rawstr <<  "color=blue";
         }
-        else if(SVFUtil::isa<GlobalBlockNode>(node))
+        else if(SVFUtil::isa<GlobalICFGNode>(node))
         {
             rawstr <<  "color=purple";
         }

package/lib/Graphs/PTACallGraph.cpp

@@ -42,13 +42,13 @@ CallSiteID PTACallGraph::totalCallSiteNum = 1;
 
 /// Add direct and indirect callsite
 //@{
-void PTACallGraphEdge::addDirectCallSite(const CallBlockNode* call)
+void PTACallGraphEdge::addDirectCallSite(const CallICFGNode* call)
 {
     assert(SVFUtil::getCallee(call->getCallSite()) && "not a direct callsite??");
     directCalls.insert(call);
 }
 
-void PTACallGraphEdge::addInDirectCallSite(const CallBlockNode* call)
+void PTACallGraphEdge::addInDirectCallSite(const CallICFGNode* call)
 {
     assert((nullptr == SVFUtil::getCallee(call->getCallSite()) || nullptr == SVFUtil::dyn_cast<Function> (SVFUtil::getForkedFun(call->getCallSite()))) && "not an indirect callsite??");
     indirectCalls.insert(call);
@@ -162,7 +162,7 @@ PTACallGraphEdge* PTACallGraph::getGraphEdge(PTACallGraphNode* src, PTACallGraph
 /*!
  * Add direct call edges
  */
-void PTACallGraph::addDirectCallGraphEdge(const CallBlockNode* cs,const SVFFunction* callerFun, const SVFFunction* calleeFun)
+void PTACallGraph::addDirectCallGraphEdge(const CallICFGNode* cs,const SVFFunction* callerFun, const SVFFunction* calleeFun)
 {
 
     PTACallGraphNode* caller = getCallGraphNode(callerFun);
@@ -182,7 +182,7 @@ void PTACallGraph::addDirectCallGraphEdge(const CallBlockNode* cs,const SVFFunct
 /*!
  * Add indirect call edge to update call graph
  */
-void PTACallGraph::addIndirectCallGraphEdge(const CallBlockNode* cs,const SVFFunction* callerFun, const SVFFunction* calleeFun)
+void PTACallGraph::addIndirectCallGraphEdge(const CallICFGNode* cs,const SVFFunction* callerFun, const SVFFunction* calleeFun)
 {
 
     PTACallGraphNode* caller = getCallGraphNode(callerFun);
@@ -269,7 +269,7 @@ void PTACallGraph::verifyCallGraph()
         const FunctionSet& targets = it->second;
         if (targets.empty() == false)
         {
-            const CallBlockNode* cs = it->first;
+            const CallICFGNode* cs = it->first;
             const SVFFunction* func = cs->getCaller();
             if (getCallGraphNode(func)->isReachableFromProgEntry() == false)
                 writeWrnMsg(func->getName().str() + " has indirect call site but not reachable from main");

package/lib/Graphs/SVFG.cpp

@@ -163,7 +163,7 @@ const std::string ThreadMHPIndSVFGEdge::toString() const {
 }
 
 
-FormalOUTSVFGNode::FormalOUTSVFGNode(NodeID id, const MRVer* mrVer, const FunExitBlockNode* funExit): MRSVFGNode(id, FPOUT)
+FormalOUTSVFGNode::FormalOUTSVFGNode(NodeID id, const MRVer* mrVer, const FunExitICFGNode* funExit): MRSVFGNode(id, FPOUT)
 {
     cpts = mrVer->getMR()->getPointsTo();
     ver = mrVer;
@@ -326,7 +326,7 @@ void SVFG::connectIndirectSVFGEdges()
             mssa->getPTA()->getPTACallGraph()->getDirCallSitesInvokingCallee(formalIn->getFun(),callInstSet);
             for(PTACallGraphEdge::CallInstSet::iterator it = callInstSet.begin(), eit = callInstSet.end(); it!=eit; ++it)
             {
-                const CallBlockNode* cs = *it;
+                const CallICFGNode* cs = *it;
                 if(!mssa->hasMU(cs))
                     continue;
                 ActualINSVFGNodeSet& actualIns = getActualINSVFGNodes(cs);
@@ -344,7 +344,7 @@ void SVFG::connectIndirectSVFGEdges()
             mssa->getPTA()->getPTACallGraph()->getDirCallSitesInvokingCallee(formalOut->getFun(),callInstSet);
             for(PTACallGraphEdge::CallInstSet::iterator it = callInstSet.begin(), eit = callInstSet.end(); it!=eit; ++it)
             {
-                const CallBlockNode* cs = *it;
+                const CallICFGNode* cs = *it;
                 if(!mssa->hasCHI(cs))
                     continue;
                 ActualOUTSVFGNodeSet& actualOuts = getActualOUTSVFGNodes(cs);
@@ -564,10 +564,10 @@ std::set<const SVFGNode*> SVFG::fromValue(const llvm::Value* value) const
 /**
  * Get all inter value flow edges at this indirect call site, including call and return edges.
  */
-void SVFG::getInterVFEdgesForIndirectCallSite(const CallBlockNode* callBlockNode, const SVFFunction* callee, SVFGEdgeSetTy& edges)
+void SVFG::getInterVFEdgesForIndirectCallSite(const CallICFGNode* callBlockNode, const SVFFunction* callee, SVFGEdgeSetTy& edges)
 {
     CallSiteID csId = getCallSiteID(callBlockNode, callee);
-    RetBlockNode* retBlockNode = pag->getICFG()->getRetBlockNode(callBlockNode->getCallSite());
+    RetICFGNode* retBlockNode = pag->getICFG()->getRetBlockNode(callBlockNode->getCallSite());
 
     // Find inter direct call edges between actual param and formal param.
     if (pag->hasCallSiteArgsMap(callBlockNode) && pag->hasFunArgsList(callee))
@@ -638,7 +638,7 @@ void SVFG::getInterVFEdgesForIndirectCallSite(const CallBlockNode* callBlockNode
  * Connect actual params/return to formal params/return for top-level variables.
  * Also connect indirect actual in/out and formal in/out.
  */
-void SVFG::connectCallerAndCallee(const CallBlockNode* cs, const SVFFunction* callee, SVFGEdgeSetTy& edges)
+void SVFG::connectCallerAndCallee(const CallICFGNode* cs, const SVFFunction* callee, SVFGEdgeSetTy& edges)
 {
     VFG::connectCallerAndCallee(cs,callee,edges);
 
@@ -712,7 +712,7 @@ const SVFFunction* SVFG::isFunEntrySVFGNode(const SVFGNode* node) const
 /*!
  * Whether this is an callsite return SVFGNode (actual return, actual out)
  */
-const CallBlockNode* SVFG::isCallSiteRetSVFGNode(const SVFGNode* node) const
+const CallICFGNode* SVFG::isCallSiteRetSVFGNode(const SVFGNode* node) const
 {
     if(const ActualRetSVFGNode* ar = SVFUtil::dyn_cast<ActualRetSVFGNode>(node))
     {