svf-tools 1.0.342 → 1.0.346

package/include/Graphs/ICFGNode.h

@@ -38,7 +38,7 @@ namespace SVF
 {
 
 class ICFGNode;
-class RetBlockNode;
+class RetICFGNode;
 class CallPE;
 class RetPE;
 class SVFStmt;
@@ -139,18 +139,18 @@ protected:
 /*!
  * Unique ICFG node stands for all global initializations
  */
-class GlobalBlockNode : public ICFGNode
+class GlobalICFGNode : public ICFGNode
 {
 
 public:
-    GlobalBlockNode(NodeID id) : ICFGNode(id, GlobalBlock)
+    GlobalICFGNode(NodeID id) : ICFGNode(id, GlobalBlock)
     {
     	bb = nullptr;
     }
 
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const GlobalBlockNode *)
+    static inline bool classof(const GlobalICFGNode *)
     {
         return true;
     }
@@ -172,13 +172,13 @@ public:
 /*!
  * ICFG node stands for a program statement
  */
-class IntraBlockNode : public ICFGNode
+class IntraICFGNode : public ICFGNode
 {
 private:
     const Instruction *inst;
 
 public:
-    IntraBlockNode(NodeID id, const Instruction *i) : ICFGNode(id, IntraBlock), inst(i)
+    IntraICFGNode(NodeID id, const Instruction *i) : ICFGNode(id, IntraBlock), inst(i)
     {
         fun = LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(inst->getFunction());
         bb = inst->getParent();
@@ -191,7 +191,7 @@ public:
 
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const IntraBlockNode *)
+    static inline bool classof(const IntraICFGNode *)
     {
         return true;
     }
@@ -210,18 +210,18 @@ public:
     const std::string toString() const;
 };
 
-class InterBlockNode : public ICFGNode
+class InterICFGNode : public ICFGNode
 {
 
 public:
     /// Constructor
-    InterBlockNode(NodeID id, ICFGNodeK k) : ICFGNode(id, k)
+    InterICFGNode(NodeID id, ICFGNodeK k) : ICFGNode(id, k)
     {
     }
 
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const InterBlockNode *)
+    static inline bool classof(const InterICFGNode *)
     {
         return true;
     }
@@ -248,7 +248,7 @@ public:
 /*!
  * Function entry ICFGNode containing a set of FormalParmVFGNodes of a function
  */
-class FunEntryBlockNode : public InterBlockNode
+class FunEntryICFGNode : public InterICFGNode
 {
 
 public:
@@ -256,7 +256,7 @@ public:
 private:
     FormalParmNodeVec FPNodes;
 public:
-    FunEntryBlockNode(NodeID id, const SVFFunction* f);
+    FunEntryICFGNode(NodeID id, const SVFFunction* f);
 
     /// Return function
     inline const SVFFunction* getFun() const
@@ -278,12 +278,12 @@ public:
 
     ///Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const FunEntryBlockNode *)
+    static inline bool classof(const FunEntryICFGNode *)
     {
         return true;
     }
 
-    static inline bool classof(const InterBlockNode *node)
+    static inline bool classof(const InterICFGNode *node)
     {
         return node->getNodeKind() == FunEntryBlock;
     }
@@ -305,14 +305,14 @@ public:
 /*!
  * Function exit ICFGNode containing (at most one) FormalRetVFGNodes of a function
  */
-class FunExitBlockNode : public InterBlockNode
+class FunExitICFGNode : public InterICFGNode
 {
 
 private:
     const SVFFunction* fun;
     const SVFVar *formalRet;
 public:
-    FunExitBlockNode(NodeID id, const SVFFunction* f);
+    FunExitICFGNode(NodeID id, const SVFFunction* f);
 
     /// Return function
     inline const SVFFunction* getFun() const
@@ -334,7 +334,7 @@ public:
 
     ///Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const FunEntryBlockNode *)
+    static inline bool classof(const FunEntryICFGNode *)
     {
         return true;
     }
@@ -344,7 +344,7 @@ public:
         return node->getNodeKind() == FunExitBlock;
     }
 
-    static inline bool classof(const InterBlockNode *node)
+    static inline bool classof(const InterICFGNode *node)
     {
         return node->getNodeKind() == FunExitBlock;
     }
@@ -361,17 +361,17 @@ public:
 /*!
  * Call ICFGNode containing a set of ActualParmVFGNodes at a callsite
  */
-class CallBlockNode : public InterBlockNode
+class CallICFGNode : public InterICFGNode
 {
 
 public:
     typedef std::vector<const SVFVar *> ActualParmNodeVec;
 private:
     const Instruction* cs;
-    const RetBlockNode* ret;
+    const RetICFGNode* ret;
     ActualParmNodeVec APNodes;
 public:
-    CallBlockNode(NodeID id, const Instruction* c) : InterBlockNode(id, FunCallBlock), cs(c), ret(nullptr)
+    CallICFGNode(NodeID id, const Instruction* c) : InterICFGNode(id, FunCallBlock), cs(c), ret(nullptr)
     {
         fun = LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(cs->getFunction());
         bb = cs->getParent();
@@ -384,14 +384,14 @@ public:
     }
 
     /// Return callsite
-    inline const RetBlockNode* getRetBlockNode() const
+    inline const RetICFGNode* getRetICFGNode() const
     {
-    	assert(ret && "RetBlockNode not set?");
+    	assert(ret && "RetICFGNode not set?");
         return ret;
     }
 
     /// Return callsite
-    inline void setRetBlockNode(const RetBlockNode* r)
+    inline void setRetICFGNode(const RetICFGNode* r)
     {
         ret = r;
     }
@@ -428,7 +428,7 @@ public:
 
     ///Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const CallBlockNode *)
+    static inline bool classof(const CallICFGNode *)
     {
         return true;
     }
@@ -438,7 +438,7 @@ public:
         return node->getNodeKind() == FunCallBlock;
     }
 
-    static inline bool classof(const InterBlockNode *node)
+    static inline bool classof(const InterICFGNode *node)
     {
         return node->getNodeKind() == FunCallBlock;
     }
@@ -456,16 +456,16 @@ public:
 /*!
  * Return ICFGNode containing (at most one) ActualRetVFGNode at a callsite
  */
-class RetBlockNode : public InterBlockNode
+class RetICFGNode : public InterICFGNode
 {
 
 private:
     const Instruction* cs;
     const SVFVar *actualRet;
-    const CallBlockNode* callBlockNode;
+    const CallICFGNode* callBlockNode;
 public:
-    RetBlockNode(NodeID id, const Instruction* c, CallBlockNode* cb) :
-        InterBlockNode(id, FunRetBlock), cs(c), actualRet(nullptr), callBlockNode(cb)
+    RetICFGNode(NodeID id, const Instruction* c, CallICFGNode* cb) :
+        InterICFGNode(id, FunRetBlock), cs(c), actualRet(nullptr), callBlockNode(cb)
     {
         fun = LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(cs->getFunction());
         bb = cs->getParent();
@@ -477,7 +477,7 @@ public:
         return cs;
     }
 
-    inline const CallBlockNode* getCallBlockNode() const
+    inline const CallICFGNode* getCallBlockNode() const
     {
         return callBlockNode;
     }
@@ -495,12 +495,12 @@ public:
 
     ///Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const RetBlockNode *)
+    static inline bool classof(const RetICFGNode *)
     {
         return true;
     }
 
-    static inline bool classof(const InterBlockNode *node)
+    static inline bool classof(const InterICFGNode *node)
     {
         return node->getNodeKind() == FunRetBlock;
     }

package/include/Graphs/ICFGStat.h

@@ -78,11 +78,11 @@ public:
         countStat();
 
         PTNumStatMap["ICFGNode"] = numOfNodes;
-        PTNumStatMap["IntraBlockNode"] = numOfIntraNodes;
-        PTNumStatMap["CallBlockNode"] = numOfCallNodes;
-        PTNumStatMap["RetBlockNode"] = numOfRetNodes;
-        PTNumStatMap["FunEntryBlockNode"] = numOfEntryNodes;
-        PTNumStatMap["FunExitBlockNode"] = numOfExitNodes;
+        PTNumStatMap["IntraICFGNode"] = numOfIntraNodes;
+        PTNumStatMap["CallICFGNode"] = numOfCallNodes;
+        PTNumStatMap["RetICFGNode"] = numOfRetNodes;
+        PTNumStatMap["FunEntryICFGNode"] = numOfEntryNodes;
+        PTNumStatMap["FunExitICFGNode"] = numOfExitNodes;
 
         PTNumStatMap["ICFGEdge"] = numOfEdges;
         PTNumStatMap["CallCFGEdge"] = numOfCallEdges;
@@ -97,7 +97,7 @@ public:
 
         countStat();
         PTNumStatMap["ICFGNode(N)"] = numOfNodes;
-        PTNumStatMap["CallBlockNode(Call)"] = numOfCallNodes;
+        PTNumStatMap["CallICFGNode(Call)"] = numOfCallNodes;
         PTNumStatMap["ICFGEdge(E)"] = numOfEdges;
         printStat("IFDS Stat");
     }
@@ -112,15 +112,15 @@ public:
 
             ICFGNode *node = it->second;
 
-            if (SVFUtil::isa<IntraBlockNode>(node))
+            if (SVFUtil::isa<IntraICFGNode>(node))
                 numOfIntraNodes++;
-            else if (SVFUtil::isa<CallBlockNode>(node))
+            else if (SVFUtil::isa<CallICFGNode>(node))
                 numOfCallNodes++;
-            else if (SVFUtil::isa<RetBlockNode>(node))
+            else if (SVFUtil::isa<RetICFGNode>(node))
                 numOfRetNodes++;
-            else if (SVFUtil::isa<FunEntryBlockNode>(node))
+            else if (SVFUtil::isa<FunEntryICFGNode>(node))
                 numOfEntryNodes++;
-            else if (SVFUtil::isa<FunExitBlockNode>(node))
+            else if (SVFUtil::isa<FunExitICFGNode>(node))
                 numOfExitNodes++;
 
 

package/include/Graphs/PTACallGraph.h

@@ -52,7 +52,7 @@ class PTACallGraphEdge : public GenericCallGraphEdgeTy
 {
 
 public:
-    typedef Set<const CallBlockNode*> CallInstSet;
+    typedef Set<const CallICFGNode*> CallInstSet;
     enum CEDGEK
     {
         CallRetEdge,TDForkEdge,TDJoinEdge,HareParForEdge
@@ -112,9 +112,9 @@ public:
 
     /// Add direct and indirect callsite
     //@{
-    void addDirectCallSite(const CallBlockNode* call);
+    void addDirectCallSite(const CallICFGNode* call);
 
-    void addInDirectCallSite(const CallBlockNode* call);
+    void addInDirectCallSite(const CallICFGNode* call);
     //@}
 
     /// Iterators for direct and indirect callsites
@@ -221,12 +221,12 @@ class PTACallGraph : public GenericCallGraphTy
 public:
     typedef PTACallGraphEdge::CallGraphEdgeSet CallGraphEdgeSet;
     typedef Map<const SVFFunction*, PTACallGraphNode *> FunToCallGraphNodeMap;
-    typedef Map<const CallBlockNode*, CallGraphEdgeSet> CallInstToCallGraphEdgesMap;
-    typedef std::pair<const CallBlockNode*, const SVFFunction*> CallSitePair;
+    typedef Map<const CallICFGNode*, CallGraphEdgeSet> CallInstToCallGraphEdgesMap;
+    typedef std::pair<const CallICFGNode*, const SVFFunction*> CallSitePair;
     typedef Map<CallSitePair, CallSiteID> CallSiteToIdMap;
     typedef Map<CallSiteID, CallSitePair> IdToCallSiteMap;
     typedef Set<const SVFFunction*> FunctionSet;
-    typedef OrderedMap<const CallBlockNode*, FunctionSet> CallEdgeMap;
+    typedef OrderedMap<const CallICFGNode*, FunctionSet> CallEdgeMap;
     typedef CallGraphEdgeSet::iterator CallGraphEdgeIter;
     typedef CallGraphEdgeSet::const_iterator CallGraphEdgeConstIter;
 
@@ -281,11 +281,11 @@ public:
     {
         return indirectCallMap;
     }
-    inline bool hasIndCSCallees(const CallBlockNode* cs) const
+    inline bool hasIndCSCallees(const CallICFGNode* cs) const
     {
         return (indirectCallMap.find(cs) != indirectCallMap.end());
     }
-    inline const FunctionSet& getIndCSCallees(const CallBlockNode* cs) const
+    inline const FunctionSet& getIndCSCallees(const CallICFGNode* cs) const
     {
         CallEdgeMap::const_iterator it = indirectCallMap.find(cs);
         assert(it!=indirectCallMap.end() && "not an indirect callsite!");
@@ -327,9 +327,9 @@ public:
 
     /// Add/Get CallSiteID
     //@{
-    inline CallSiteID addCallSite(const CallBlockNode* cs, const SVFFunction* callee)
+    inline CallSiteID addCallSite(const CallICFGNode* cs, const SVFFunction* callee)
     {
-        std::pair<const CallBlockNode*, const SVFFunction*> newCS(std::make_pair(cs, callee));
+        std::pair<const CallICFGNode*, const SVFFunction*> newCS(std::make_pair(cs, callee));
         CallSiteToIdMap::const_iterator it = csToIdMap.find(newCS);
         //assert(it == csToIdMap.end() && "cannot add a callsite twice");
         if(it == csToIdMap.end())
@@ -341,14 +341,14 @@ public:
         }
         return it->second;
     }
-    inline CallSiteID getCallSiteID(const CallBlockNode* cs, const SVFFunction* callee) const
+    inline CallSiteID getCallSiteID(const CallICFGNode* cs, const SVFFunction* callee) const
     {
         CallSitePair newCS(std::make_pair(cs, callee));
         CallSiteToIdMap::const_iterator it = csToIdMap.find(newCS);
         assert(it != csToIdMap.end() && "callsite id not found! This maybe a partially resolved callgraph, please check the indCallEdge limit");
         return it->second;
     }
-    inline bool hasCallSiteID(const CallBlockNode* cs, const SVFFunction* callee) const
+    inline bool hasCallSiteID(const CallICFGNode* cs, const SVFFunction* callee) const
     {
         CallSitePair newCS(std::make_pair(cs, callee));
         CallSiteToIdMap::const_iterator it = csToIdMap.find(newCS);
@@ -360,7 +360,7 @@ public:
         assert(it != idToCSMap.end() && "cannot find call site for this CallSiteID");
         return (it->second);
     }
-    inline const CallBlockNode* getCallSite(CallSiteID id) const
+    inline const CallICFGNode* getCallSite(CallSiteID id) const
     {
         return getCallSitePair(id).first;
     }
@@ -379,7 +379,7 @@ public:
     PTACallGraphEdge* getGraphEdge(PTACallGraphNode* src, PTACallGraphNode* dst,PTACallGraphEdge::CEDGEK kind, CallSiteID csId);
 
     /// Get all callees for a callsite
-    inline void getCallees(const CallBlockNode* cs, FunctionSet& callees)
+    inline void getCallees(const CallICFGNode* cs, FunctionSet& callees)
     {
         if(hasCallGraphEdge(cs))
         {
@@ -394,18 +394,18 @@ public:
     /// Get call graph edge via call instruction
     //@{
     /// whether this call instruction has a valid call graph edge
-    inline bool hasCallGraphEdge(const CallBlockNode* inst) const
+    inline bool hasCallGraphEdge(const CallICFGNode* inst) const
     {
         return callinstToCallGraphEdgesMap.find(inst)!=callinstToCallGraphEdgesMap.end();
     }
-    inline CallGraphEdgeSet::const_iterator getCallEdgeBegin(const CallBlockNode* inst) const
+    inline CallGraphEdgeSet::const_iterator getCallEdgeBegin(const CallICFGNode* inst) const
     {
         CallInstToCallGraphEdgesMap::const_iterator it = callinstToCallGraphEdgesMap.find(inst);
         assert(it!=callinstToCallGraphEdgesMap.end()
                && "call instruction does not have a valid callee");
         return it->second.begin();
     }
-    inline CallGraphEdgeSet::const_iterator getCallEdgeEnd(const CallBlockNode* inst) const
+    inline CallGraphEdgeSet::const_iterator getCallEdgeEnd(const CallICFGNode* inst) const
     {
         CallInstToCallGraphEdgesMap::const_iterator it = callinstToCallGraphEdgesMap.find(inst);
         assert(it!=callinstToCallGraphEdgesMap.end()
@@ -422,8 +422,8 @@ public:
 
     /// Add direct/indirect call edges
     //@{
-    void addDirectCallGraphEdge(const CallBlockNode* call, const SVFFunction* callerFun, const SVFFunction* calleeFun);
-    void addIndirectCallGraphEdge(const CallBlockNode* cs,const SVFFunction* callerFun, const SVFFunction* calleeFun);
+    void addDirectCallGraphEdge(const CallICFGNode* call, const SVFFunction* callerFun, const SVFFunction* calleeFun);
+    void addIndirectCallGraphEdge(const CallICFGNode* cs,const SVFFunction* callerFun, const SVFFunction* calleeFun);
     //@}
 
     /// Get callsites invoking the callee

package/include/Graphs/SVFG.h

@@ -79,8 +79,8 @@ public:
     typedef NodeBS ActualOUTSVFGNodeSet;
     typedef NodeBS FormalINSVFGNodeSet;
     typedef NodeBS FormalOUTSVFGNodeSet;
-    typedef Map<const CallBlockNode*, ActualINSVFGNodeSet>  CallSiteToActualINsMapTy;
-    typedef Map<const CallBlockNode*, ActualOUTSVFGNodeSet>  CallSiteToActualOUTsMapTy;
+    typedef Map<const CallICFGNode*, ActualINSVFGNodeSet>  CallSiteToActualINsMapTy;
+    typedef Map<const CallICFGNode*, ActualOUTSVFGNodeSet>  CallSiteToActualOUTsMapTy;
     typedef Map<const SVFFunction*, FormalINSVFGNodeSet>  FunctionToFormalINsMapTy;
     typedef Map<const SVFFunction*, FormalOUTSVFGNodeSet>  FunctionToFormalOUTsMapTy;
     typedef MemSSA::MUSet MUSet;
@@ -159,13 +159,13 @@ public:
     }
 
     /// Get all inter value flow edges of a indirect call site
-    void getInterVFEdgesForIndirectCallSite(const CallBlockNode* cs, const SVFFunction* callee, SVFGEdgeSetTy& edges);
+    void getInterVFEdgesForIndirectCallSite(const CallICFGNode* cs, const SVFFunction* callee, SVFGEdgeSetTy& edges);
 
     /// Dump graph into dot file
     void dump(const std::string& file, bool simple = false);
 
     /// Connect SVFG nodes between caller and callee for indirect call site
-    virtual void connectCallerAndCallee(const CallBlockNode* cs, const SVFFunction* callee, SVFGEdgeSetTy& edges);
+    virtual void connectCallerAndCallee(const CallICFGNode* cs, const SVFFunction* callee, SVFGEdgeSetTy& edges);
 
     /// Given a pagNode, return its definition site
     inline const SVFGNode* getDefSVFGNode(const PAGNode* pagNode) const
@@ -183,12 +183,12 @@ public:
 
     /// Has a SVFGNode
     //@{
-    inline bool hasActualINSVFGNodes(const CallBlockNode* cs) const
+    inline bool hasActualINSVFGNodes(const CallICFGNode* cs) const
     {
         return callSiteToActualINMap.find(cs)!=callSiteToActualINMap.end();
     }
 
-    inline bool hasActualOUTSVFGNodes(const CallBlockNode* cs) const
+    inline bool hasActualOUTSVFGNodes(const CallICFGNode* cs) const
     {
         return callSiteToActualOUTMap.find(cs)!=callSiteToActualOUTMap.end();
     }
@@ -206,12 +206,12 @@ public:
 
     /// Get SVFGNode set
     //@{
-    inline ActualINSVFGNodeSet& getActualINSVFGNodes(const CallBlockNode* cs)
+    inline ActualINSVFGNodeSet& getActualINSVFGNodes(const CallICFGNode* cs)
     {
         return callSiteToActualINMap[cs];
     }
 
-    inline ActualOUTSVFGNodeSet& getActualOUTSVFGNodes(const CallBlockNode* cs)
+    inline ActualOUTSVFGNodeSet& getActualOUTSVFGNodes(const CallICFGNode* cs)
     {
         return callSiteToActualOUTMap[cs];
     }
@@ -231,7 +231,7 @@ public:
     const SVFFunction* isFunEntrySVFGNode(const SVFGNode* node) const;
 
     /// Whether a node is callsite return SVFGNode
-    const CallBlockNode* isCallSiteRetSVFGNode(const SVFGNode* node) const;
+    const CallICFGNode* isCallSiteRetSVFGNode(const SVFGNode* node) const;
 
     /// Remove a SVFG edge
     inline void removeSVFGEdge(SVFGEdge* edge)
@@ -301,7 +301,7 @@ protected:
 
     /// Get inter value flow edges between indirect call site and callee.
     //@{
-    virtual inline void getInterVFEdgeAtIndCSFromAPToFP(const PAGNode* cs_arg, const PAGNode* fun_arg, const CallBlockNode*, CallSiteID csId, SVFGEdgeSetTy& edges)
+    virtual inline void getInterVFEdgeAtIndCSFromAPToFP(const PAGNode* cs_arg, const PAGNode* fun_arg, const CallICFGNode*, CallSiteID csId, SVFGEdgeSetTy& edges)
     {
         SVFGNode* actualParam = getSVFGNode(getDef(cs_arg));
         SVFGNode* formalParam = getSVFGNode(getDef(fun_arg));
@@ -394,7 +394,7 @@ protected:
     }
 
     /// Add memory Function entry chi SVFG node
-    inline void addFormalINSVFGNode(const FunEntryBlockNode* funEntry,  const MRVer* resVer, const NodeID nodeId)
+    inline void addFormalINSVFGNode(const FunEntryICFGNode* funEntry,  const MRVer* resVer, const NodeID nodeId)
     {
         FormalINSVFGNode* sNode = new FormalINSVFGNode(nodeId, resVer, funEntry);
         addSVFGNode(sNode, pag->getICFG()->getFunEntryBlockNode(funEntry->getFun()));
@@ -403,7 +403,7 @@ protected:
     }
 
     /// Add memory Function return mu SVFG node
-    inline void addFormalOUTSVFGNode(const FunExitBlockNode* funExit, const MRVer* ver, const NodeID nodeId)
+    inline void addFormalOUTSVFGNode(const FunExitICFGNode* funExit, const MRVer* ver, const NodeID nodeId)
     {
         FormalOUTSVFGNode* sNode = new FormalOUTSVFGNode(nodeId, ver, funExit);
         addSVFGNode(sNode,pag->getICFG()->getFunExitBlockNode(funExit->getFun()));
@@ -411,7 +411,7 @@ protected:
     }
 
     /// Add memory callsite mu SVFG node
-    inline void addActualINSVFGNode(const CallBlockNode* callsite, const MRVer* ver, const NodeID nodeId)
+    inline void addActualINSVFGNode(const CallICFGNode* callsite, const MRVer* ver, const NodeID nodeId)
     {
         ActualINSVFGNode* sNode = new ActualINSVFGNode(nodeId, callsite, ver);
         addSVFGNode(sNode,pag->getICFG()->getCallBlockNode(callsite->getCallSite()));
@@ -419,7 +419,7 @@ protected:
     }
 
     /// Add memory callsite chi SVFG node
-    inline void addActualOUTSVFGNode(const CallBlockNode* callsite, const MRVer* resVer, const NodeID nodeId)
+    inline void addActualOUTSVFGNode(const CallICFGNode* callsite, const MRVer* resVer, const NodeID nodeId)
     {
         ActualOUTSVFGNode* sNode = new ActualOUTSVFGNode(nodeId, callsite, resVer);
         addSVFGNode(sNode, pag->getICFG()->getRetBlockNode(callsite->getCallSite()));
@@ -448,11 +448,11 @@ protected:
     {
         return (funToFormalOUTMap.find(func) != funToFormalOUTMap.end());
     }
-    inline bool hasCallSiteChi(const CallBlockNode* cs) const
+    inline bool hasCallSiteChi(const CallICFGNode* cs) const
     {
         return (callSiteToActualOUTMap.find(cs) != callSiteToActualOUTMap.end());
     }
-    inline bool hasCallSiteMu(const CallBlockNode* cs) const
+    inline bool hasCallSiteMu(const CallICFGNode* cs) const
     {
         return (callSiteToActualINMap.find(cs) != callSiteToActualINMap.end());
     }

package/include/Graphs/SVFGNode.h

@@ -91,11 +91,11 @@ class FormalINSVFGNode : public MRSVFGNode
 {
 private:
     const MRVer* ver;
-    const FunEntryBlockNode* funEntryNode; 
+    const FunEntryICFGNode* funEntryNode; 
 
 public:
     /// Constructor
-    FormalINSVFGNode(NodeID id, const MRVer* resVer, const FunEntryBlockNode* funEntry): MRSVFGNode(id, FPIN)
+    FormalINSVFGNode(NodeID id, const MRVer* resVer, const FunEntryICFGNode* funEntry): MRSVFGNode(id, FPIN)
     {
         cpts = resVer->getMR()->getPointsTo();
         ver = resVer;
@@ -105,7 +105,7 @@ public:
     {
         return ver;
     }
-    inline const FunEntryBlockNode* getFunEntryNode() const
+    inline const FunEntryICFGNode* getFunEntryNode() const
     {
         return funEntryNode;
     }
@@ -136,13 +136,13 @@ class FormalOUTSVFGNode : public MRSVFGNode
 {
 private:
     const MRVer* ver;
-    const FunExitBlockNode* funExitNode; 
+    const FunExitICFGNode* funExitNode; 
 
 public:
     /// Constructor
-    FormalOUTSVFGNode(NodeID id, const MRVer* ver, const FunExitBlockNode* funExitNode);
+    FormalOUTSVFGNode(NodeID id, const MRVer* ver, const FunExitICFGNode* funExitNode);
 
-    inline const FunExitBlockNode* getFunExitNode() const
+    inline const FunExitICFGNode* getFunExitNode() const
     {
         return funExitNode;
     }
@@ -177,18 +177,18 @@ public:
 class ActualINSVFGNode : public MRSVFGNode
 {
 private:
-    const CallBlockNode* cs;
+    const CallICFGNode* cs;
     const MRVer* ver;
 public:
     /// Constructor
-    ActualINSVFGNode(NodeID id, const CallBlockNode* c, const MRVer* mrver):
+    ActualINSVFGNode(NodeID id, const CallICFGNode* c, const MRVer* mrver):
         MRSVFGNode(id, APIN), cs(c)
     {
         cpts = mrver->getMR()->getPointsTo();
         ver = mrver;
     }
     /// Callsite
-    inline const CallBlockNode* getCallSite() const
+    inline const CallICFGNode* getCallSite() const
     {
         return cs;
     }
@@ -226,19 +226,19 @@ public:
 class ActualOUTSVFGNode : public MRSVFGNode
 {
 private:
-    const CallBlockNode* cs;
+    const CallICFGNode* cs;
     const MRVer* ver;
 
 public:
     /// Constructor
-    ActualOUTSVFGNode(NodeID id, const CallBlockNode* cal, const MRVer* resVer):
+    ActualOUTSVFGNode(NodeID id, const CallICFGNode* cal, const MRVer* resVer):
         MRSVFGNode(id, APOUT), cs(cal)
     {
         cpts = resVer->getMR()->getPointsTo();
         ver = resVer;
     }
     /// Callsite
-    inline const CallBlockNode* getCallSite() const
+    inline const CallICFGNode* getCallSite() const
     {
         return cs;
     }
@@ -425,7 +425,7 @@ public:
         return fun;
     }
 
-    inline const CallBlockNode* getCallSite() const
+    inline const CallICFGNode* getCallSite() const
     {
         assert(isActualOUTPHI() && "expect a actual return phi");
         return callInst;
@@ -459,7 +459,7 @@ public:
 
 private:
     const SVFFunction* fun;
-    const CallBlockNode* callInst;
+    const CallICFGNode* callInst;
 };
 
 /*

package/include/Graphs/SVFGOPT.h

@@ -86,7 +86,7 @@ protected:
 
     /// Connect SVFG nodes between caller and callee for indirect call sites
     //@{
-    virtual inline void connectAParamAndFParam(const PAGNode* cs_arg, const PAGNode* fun_arg, const CallBlockNode*, CallSiteID csId, SVFGEdgeSetTy& edges)
+    virtual inline void connectAParamAndFParam(const PAGNode* cs_arg, const PAGNode* fun_arg, const CallICFGNode*, CallSiteID csId, SVFGEdgeSetTy& edges)
     {
         NodeID phiId = getDef(fun_arg);
         SVFGEdge* edge = addCallEdge(getDef(cs_arg), phiId, csId);