svf-tools 1.0.340 → 1.0.344

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);

package/include/Graphs/ThreadCallGraph.h

@@ -159,17 +159,17 @@ class ThreadCallGraph: public PTACallGraph
 {
 
 public:
-    typedef Set<const CallBlockNode*> InstSet;
+    typedef Set<const CallICFGNode*> InstSet;
     typedef InstSet CallSiteSet;
     typedef std::vector<const Instruction*> InstVector;
     typedef Map<const Instruction*, InstSet> CallToInstMap;
     typedef Set<CallSiteSet*> CtxSet;
     typedef ThreadForkEdge::ForkEdgeSet ForkEdgeSet;
-    typedef Map<const CallBlockNode*, ForkEdgeSet> CallInstToForkEdgesMap;
+    typedef Map<const CallICFGNode*, ForkEdgeSet> CallInstToForkEdgesMap;
     typedef ThreadJoinEdge::JoinEdgeSet JoinEdgeSet;
-    typedef Map<const CallBlockNode*, JoinEdgeSet> CallInstToJoinEdgesMap;
+    typedef Map<const CallICFGNode*, JoinEdgeSet> CallInstToJoinEdgesMap;
     typedef HareParForEdge::ParForEdgeSet ParForEdgeSet;
-    typedef Map<const CallBlockNode*, ParForEdgeSet> CallInstToParForEdgesMap;
+    typedef Map<const CallICFGNode*, ParForEdgeSet> CallInstToParForEdgesMap;
 
     /// Constructor
     ThreadCallGraph();
@@ -199,17 +199,17 @@ public:
     /// Get call graph edge via call instruction
     //@{
     /// whether this call instruction has a valid call graph edge
-    inline bool hasThreadForkEdge(const CallBlockNode* cs) const
+    inline bool hasThreadForkEdge(const CallICFGNode* cs) const
     {
         return callinstToThreadForkEdgesMap.find(cs) != callinstToThreadForkEdgesMap.end();
     }
-    inline ForkEdgeSet::const_iterator getForkEdgeBegin(const CallBlockNode* cs) const
+    inline ForkEdgeSet::const_iterator getForkEdgeBegin(const CallICFGNode* cs) const
     {
         CallInstToForkEdgesMap::const_iterator it = callinstToThreadForkEdgesMap.find(cs);
         assert(it != callinstToThreadForkEdgesMap.end() && "call instruction not found");
         return it->second.begin();
     }
-    inline ForkEdgeSet::const_iterator getForkEdgeEnd(const CallBlockNode* cs) const
+    inline ForkEdgeSet::const_iterator getForkEdgeEnd(const CallICFGNode* cs) const
     {
         CallInstToForkEdgesMap::const_iterator it = callinstToThreadForkEdgesMap.find(cs);
         assert(it != callinstToThreadForkEdgesMap.end() && "call instruction not found");
@@ -219,17 +219,17 @@ public:
     /// Get call graph edge via call instruction
     //@{
     /// whether this call instruction has a valid call graph edge
-    inline bool hasThreadJoinEdge(const CallBlockNode* cs) const
+    inline bool hasThreadJoinEdge(const CallICFGNode* cs) const
     {
         return callinstToThreadJoinEdgesMap.find(cs) != callinstToThreadJoinEdgesMap.end();
     }
-    inline JoinEdgeSet::const_iterator getJoinEdgeBegin(const CallBlockNode* cs) const
+    inline JoinEdgeSet::const_iterator getJoinEdgeBegin(const CallICFGNode* cs) const
     {
         CallInstToJoinEdgesMap::const_iterator it = callinstToThreadJoinEdgesMap.find(cs);
         assert(it != callinstToThreadJoinEdgesMap.end() && "call instruction does not have a valid callee");
         return it->second.begin();
     }
-    inline JoinEdgeSet::const_iterator getJoinEdgeEnd(const CallBlockNode* cs) const
+    inline JoinEdgeSet::const_iterator getJoinEdgeEnd(const CallICFGNode* cs) const
     {
         CallInstToJoinEdgesMap::const_iterator it = callinstToThreadJoinEdgesMap.find(cs);
         assert(it != callinstToThreadJoinEdgesMap.end() && "call instruction does not have a valid callee");
@@ -252,15 +252,15 @@ public:
 
     /// Whether a callsite is a fork or join or hare_parallel_for
     ///@{
-    inline bool isForksite(const CallBlockNode* csInst)
+    inline bool isForksite(const CallICFGNode* csInst)
     {
         return forksites.find(csInst) != forksites.end();
     }
-    inline bool isJoinsite(const CallBlockNode* csInst)
+    inline bool isJoinsite(const CallICFGNode* csInst)
     {
         return joinsites.find(csInst) != joinsites.end();
     }
-    inline bool isParForSite(const CallBlockNode* csInst)
+    inline bool isParForSite(const CallICFGNode* csInst)
     {
         return parForSites.find(csInst) != parForSites.end();
     }
@@ -326,17 +326,17 @@ public:
 
     /// Add fork sites which directly or indirectly create a thread
     //@{
-    inline bool addForksite(const CallBlockNode* cs)
+    inline bool addForksite(const CallICFGNode* cs)
     {
         callinstToThreadForkEdgesMap[cs];
         return forksites.insert(cs).second;
     }
-    inline bool addJoinsite(const CallBlockNode* cs)
+    inline bool addJoinsite(const CallICFGNode* cs)
     {
         callinstToThreadJoinEdgesMap[cs];
         return joinsites.insert(cs).second;
     }
-    inline bool addParForSite(const CallBlockNode* cs)
+    inline bool addParForSite(const CallICFGNode* cs)
     {
         callinstToHareParForEdgesMap[cs];
         return parForSites.insert(cs).second;
@@ -345,24 +345,24 @@ public:
 
     /// Add direct/indirect thread fork edges
     //@{
-    void addDirectForkEdge(const CallBlockNode* cs);
-    void addIndirectForkEdge(const CallBlockNode* cs, const SVFFunction* callee);
+    void addDirectForkEdge(const CallICFGNode* cs);
+    void addIndirectForkEdge(const CallICFGNode* cs, const SVFFunction* callee);
     //@}
 
     /// Add thread join edges
     //@{
-    void addDirectJoinEdge(const CallBlockNode* cs,const CallSiteSet& forksite);
+    void addDirectJoinEdge(const CallICFGNode* cs,const CallSiteSet& forksite);
     //@}
 
     /// Add direct/indirect parallel for edges
     //@{
-    void addDirectParForEdge(const CallBlockNode* cs);
-    void addIndirectParForEdge(const CallBlockNode* cs, const SVFFunction* callee);
+    void addDirectParForEdge(const CallICFGNode* cs);
+    void addIndirectParForEdge(const CallICFGNode* cs, const SVFFunction* callee);
     //@}
 
 
     /// map call instruction to its CallGraphEdge map
-    inline void addThreadForkEdgeSetMap(const CallBlockNode* cs, ThreadForkEdge* edge)
+    inline void addThreadForkEdgeSetMap(const CallICFGNode* cs, ThreadForkEdge* edge)
     {
         if(edge!=nullptr)
         {
@@ -372,7 +372,7 @@ public:
     }
 
     /// map call instruction to its CallGraphEdge map
-    inline void addThreadJoinEdgeSetMap(const CallBlockNode* cs, ThreadJoinEdge* edge)
+    inline void addThreadJoinEdgeSetMap(const CallICFGNode* cs, ThreadJoinEdge* edge)
     {
         if(edge!=nullptr)
         {
@@ -382,7 +382,7 @@ public:
     }
 
     /// map call instruction to its CallGraphEdge map
-    inline void addHareParForEdgeSetMap(const CallBlockNode* cs, HareParForEdge* edge)
+    inline void addHareParForEdgeSetMap(const CallICFGNode* cs, HareParForEdge* edge)
     {
         if(edge!=nullptr)
         {
@@ -392,7 +392,7 @@ public:
     }
 
     /// has thread join edge
-    inline ThreadJoinEdge* hasThreadJoinEdge(const CallBlockNode* call, PTACallGraphNode* joinFunNode, PTACallGraphNode* threadRoutineFunNode, CallSiteID csId) const
+    inline ThreadJoinEdge* hasThreadJoinEdge(const CallICFGNode* call, PTACallGraphNode* joinFunNode, PTACallGraphNode* threadRoutineFunNode, CallSiteID csId) const
     {
         ThreadJoinEdge joinEdge(joinFunNode,threadRoutineFunNode, csId);
         CallInstToJoinEdgesMap::const_iterator it = callinstToThreadJoinEdgesMap.find(call);

package/include/Graphs/VFG.h

@@ -41,7 +41,7 @@ namespace SVF
 
 class PointerAnalysis;
 class VFGStat;
-class CallBlockNode;
+class CallICFGNode;
 
 /*!
  * Interprocedural Control-Flow Graph (VFG)
@@ -60,7 +60,7 @@ public:
     typedef Map<NodeID, VFGNode *> VFGNodeIDToNodeMapTy;
     typedef Set<VFGNode*> VFGNodeSet;
     typedef Map<const PAGNode*, NodeID> PAGNodeToDefMapTy;
-    typedef Map<std::pair<NodeID,const CallBlockNode*>, ActualParmVFGNode *> PAGNodeToActualParmMapTy;
+    typedef Map<std::pair<NodeID,const CallICFGNode*>, ActualParmVFGNode *> PAGNodeToActualParmMapTy;
     typedef Map<const PAGNode*, ActualRetVFGNode *> PAGNodeToActualRetMapTy;
     typedef Map<const PAGNode*, FormalParmVFGNode *> PAGNodeToFormalParmMapTy;
     typedef Map<const PAGNode*, FormalRetVFGNode *> PAGNodeToFormalRetMapTy;
@@ -171,15 +171,15 @@ public:
     void updateCallGraph(PointerAnalysis* pta);
 
     /// Connect VFG nodes between caller and callee for indirect call site
-    virtual void connectCallerAndCallee(const CallBlockNode* cs, const SVFFunction* callee, VFGEdgeSetTy& edges);
+    virtual void connectCallerAndCallee(const CallICFGNode* cs, const SVFFunction* callee, VFGEdgeSetTy& edges);
 
     /// Get callsite given a callsiteID
     //@{
-    inline CallSiteID getCallSiteID(const CallBlockNode* cs, const SVFFunction* func) const
+    inline CallSiteID getCallSiteID(const CallICFGNode* cs, const SVFFunction* func) const
     {
         return callgraph->getCallSiteID(cs, func);
     }
-    inline const CallBlockNode* getCallSite(CallSiteID id) const
+    inline const CallICFGNode* getCallSite(CallSiteID id) const
     {
         return callgraph->getCallSite(id);
     }
@@ -232,7 +232,7 @@ public:
         assert(it != PAGNodeToCmpVFGNodeMap.end() && "CmpVFGNode can not be found??");
         return it->second;
     }
-    inline ActualParmVFGNode* getActualParmVFGNode(const PAGNode* aparm,const CallBlockNode* cs) const
+    inline ActualParmVFGNode* getActualParmVFGNode(const PAGNode* aparm,const CallICFGNode* cs) const
     {
         PAGNodeToActualParmMapTy::const_iterator it = PAGNodeToActualParmMap.find(std::make_pair(aparm->getId(),cs));
         assert(it!=PAGNodeToActualParmMap.end() && "actual parameter VFG node can not be found??");
@@ -377,7 +377,7 @@ protected:
     /// Connect VFG nodes between caller and callee for indirect call site
     //@{
     /// Connect actual-param and formal param
-    virtual inline void connectAParamAndFParam(const PAGNode* csArg, const PAGNode* funArg, const CallBlockNode* cbn, CallSiteID csId, VFGEdgeSetTy& edges)
+    virtual inline void connectAParamAndFParam(const PAGNode* csArg, const PAGNode* funArg, const CallICFGNode* cbn, CallSiteID csId, VFGEdgeSetTy& edges)
     {
         NodeID actualParam = getActualParmVFGNode(csArg, cbn)->getId();
         NodeID formalParam = getFormalParmVFGNode(funArg)->getId();
@@ -447,7 +447,7 @@ protected:
     void connectDirectVFGEdges();
 
     /// Create edges between VFG nodes across functions
-    void addVFGInterEdges(const CallBlockNode* cs, const SVFFunction* callee);
+    void addVFGInterEdges(const CallICFGNode* cs, const SVFFunction* callee);
 
     inline bool isPhiCopyEdge(const PAGEdge* copy) const
     {
@@ -521,7 +521,7 @@ protected:
     /// Add an actual parameter VFG node
     /// To be noted that multiple actual parameters may have same value (PAGNode)
     /// So we need to make a pair <PAGNodeID,CallSiteID> to find the right VFGParmNode
-    inline void addActualParmVFGNode(const PAGNode* aparm, const CallBlockNode* cs)
+    inline void addActualParmVFGNode(const PAGNode* aparm, const CallICFGNode* cs)
     {
         ActualParmVFGNode* sNode = new ActualParmVFGNode(totalVFGNode++,aparm,cs);
         addVFGNode(sNode, pag->getICFG()->getCallBlockNode(cs->getCallSite()));
@@ -561,7 +561,7 @@ protected:
 		}
     }
     /// Add a callsite Receive VFG node
-    inline void addActualRetVFGNode(const PAGNode* ret,const CallBlockNode* cs)
+    inline void addActualRetVFGNode(const PAGNode* ret,const CallICFGNode* cs)
     {
         ActualRetVFGNode* sNode = new ActualRetVFGNode(totalVFGNode++,ret,cs);
         addVFGNode(sNode, pag->getICFG()->getRetBlockNode(cs->getCallSite()));

package/include/Graphs/VFGNode.h

@@ -831,16 +831,16 @@ public:
 class ActualParmVFGNode : public ArgumentVFGNode
 {
 private:
-    const CallBlockNode* cs;
+    const CallICFGNode* cs;
 public:
     /// Constructor
-    ActualParmVFGNode(NodeID id, const PAGNode* n, const CallBlockNode* c) :
+    ActualParmVFGNode(NodeID id, const PAGNode* n, const CallICFGNode* c) :
         ArgumentVFGNode(id, n, AParm), cs(c)
     {
     }
 
     /// Return callsite
-    inline const CallBlockNode* getCallSite() const
+    inline const CallICFGNode* getCallSite() const
     {
         return cs;
     }
@@ -948,7 +948,7 @@ public:
 class ActualRetVFGNode: public ArgumentVFGNode
 {
 private:
-    const CallBlockNode* cs;
+    const CallICFGNode* cs;
 
     ActualRetVFGNode();                      ///< place holder
     ActualRetVFGNode(const ActualRetVFGNode &);  ///< place holder
@@ -956,12 +956,12 @@ private:
 
 public:
     /// Constructor
-    ActualRetVFGNode(NodeID id, const PAGNode* n, const CallBlockNode* c) :
+    ActualRetVFGNode(NodeID id, const PAGNode* n, const CallICFGNode* c) :
         ArgumentVFGNode(id, n, ARet), cs(c)
     {
     }
     /// Return callsite
-    inline const CallBlockNode* getCallSite() const
+    inline const CallICFGNode* getCallSite() const
     {
         return cs;
     }
@@ -1090,7 +1090,7 @@ public:
         return fun;
     }
 
-    inline const CallBlockNode* getCallSite() const
+    inline const CallICFGNode* getCallSite() const
     {
         assert(isActualRetPHI() && "expect a actual return phi");
         return callInst;
@@ -1120,7 +1120,7 @@ public:
 
 private:
     const SVFFunction* fun;
-    const CallBlockNode* callInst;
+    const CallICFGNode* callInst;
 };
 
 

package/include/MSSA/MSSAMuChi.h

@@ -222,12 +222,12 @@ class CallMU : public MSSAMU<Cond>
 {
 
 private:
-    const CallBlockNode* callsite;
+    const CallICFGNode* callsite;
 
 public:
     /// Constructor/Destructor for MU
     //@{
-    CallMU(const CallBlockNode* cs, const MemRegion* m, Cond c = true) :
+    CallMU(const CallICFGNode* cs, const MemRegion* m, Cond c = true) :
         MSSAMU<Cond>(MSSAMU<Cond>::CallMSSAMU,m,c), callsite(cs)
     {
     }
@@ -238,7 +238,7 @@ public:
     //@}
 
     /// Return callsite
-    inline const CallBlockNode* getCallSite() const
+    inline const CallICFGNode* getCallSite() const
     {
         return callsite;
     }
@@ -521,11 +521,11 @@ template<class Cond>
 class CallCHI : public MSSACHI<Cond>
 {
 private:
-    const CallBlockNode* callsite;
+    const CallICFGNode* callsite;
 public:
     /// Constructors for StoreCHI
     //@{
-    CallCHI(const CallBlockNode* cs, const MemRegion* m, Cond c = true) :
+    CallCHI(const CallICFGNode* cs, const MemRegion* m, Cond c = true) :
         MSSACHI<Cond>(MSSADEF::CallMSSACHI,m,c), callsite(cs)
     {
     }
@@ -541,7 +541,7 @@ public:
     }
 
     /// Return callsite
-    inline const CallBlockNode* getCallSite() const
+    inline const CallICFGNode* getCallSite() const
     {
         return callsite;
     }