svf-tools 1.0.342 → 1.0.346

package/include/MemoryModel/PointerAnalysis.h

@@ -105,10 +105,10 @@ public:
     /// Indirect call edges type, map a callsite to a set of callees
     //@{
     typedef llvm::AliasAnalysis AliasAnalysis;
-    typedef Set<const CallBlockNode*> CallSiteSet;
+    typedef Set<const CallICFGNode*> CallSiteSet;
     typedef SVFIR::CallSiteToFunPtrMap CallSiteToFunPtrMap;
     typedef Set<const SVFFunction*> FunctionSet;
-    typedef OrderedMap<const CallBlockNode*, FunctionSet> CallEdgeMap;
+    typedef OrderedMap<const CallICFGNode*, FunctionSet> CallEdgeMap;
     typedef SCCDetection<PTACallGraph*> CallGraphSCC;
     typedef Set<const GlobalValue*> VTableSet;
     typedef Set<const SVFFunction*> VFunSet;
@@ -263,7 +263,7 @@ public:
     }
 
     /// Print targets of a function pointer
-    void printIndCSTargets(const CallBlockNode* cs, const FunctionSet& targets);
+    void printIndCSTargets(const CallICFGNode* cs, const FunctionSet& targets);
 
     // Debug purpose
     //@{
@@ -282,7 +282,7 @@ protected:
         return pag->getIndirectCallsites();
     }
     /// Return function pointer PAGNode at a callsite cs
-    inline NodeID getFunPtr(const CallBlockNode* cs) const
+    inline NodeID getFunPtr(const CallICFGNode* cs) const
     {
         return pag->getFunPtr(cs);
     }
@@ -389,20 +389,20 @@ public:
     {
         return getPTACallGraph()->getIndCallMap();
     }
-    inline bool hasIndCSCallees(const CallBlockNode* cs) const
+    inline bool hasIndCSCallees(const CallICFGNode* cs) const
     {
         return getPTACallGraph()->hasIndCSCallees(cs);
     }
-    inline const FunctionSet& getIndCSCallees(const CallBlockNode* cs) const
+    inline const FunctionSet& getIndCSCallees(const CallICFGNode* cs) const
     {
         return getPTACallGraph()->getIndCSCallees(cs);
     }
     //@}
 
     /// Resolve indirect call edges
-    virtual void resolveIndCalls(const CallBlockNode* cs, const PointsTo& target, CallEdgeMap& newEdges,LLVMCallGraph* callgraph = nullptr);
+    virtual void resolveIndCalls(const CallICFGNode* cs, const PointsTo& target, CallEdgeMap& newEdges,LLVMCallGraph* callgraph = nullptr);
     /// Match arguments for callsite at caller and callee
-    bool matchArgs(const CallBlockNode* cs, const SVFFunction* callee);
+    bool matchArgs(const CallICFGNode* cs, const SVFFunction* callee);
 
     /// CallGraph SCC related methods
     //@{
@@ -446,10 +446,10 @@ public:
         return chgraph;
     }
 
-    void getVFnsFromCHA(const CallBlockNode* cs, VFunSet &vfns);
-    void getVFnsFromPts(const CallBlockNode* cs, const PointsTo &target, VFunSet &vfns);
-    void connectVCallToVFns(const CallBlockNode* cs, const VFunSet &vfns, CallEdgeMap& newEdges);
-    virtual void resolveCPPIndCalls(const CallBlockNode* cs,
+    void getVFnsFromCHA(const CallICFGNode* cs, VFunSet &vfns);
+    void getVFnsFromPts(const CallICFGNode* cs, const PointsTo &target, VFunSet &vfns);
+    void connectVCallToVFns(const CallICFGNode* cs, const VFunSet &vfns, CallEdgeMap& newEdges);
+    virtual void resolveCPPIndCalls(const CallICFGNode* cs,
                                     const PointsTo& target,
                                     CallEdgeMap& newEdges);
 

package/include/MemoryModel/SVFIR.h

@@ -49,16 +49,16 @@ friend class PAGBuilderFromFile;
 friend class TypeBasedHeapCloning;  
 
 public:
-    typedef Set<const CallBlockNode*> CallSiteSet;
-    typedef OrderedMap<const CallBlockNode*,NodeID> CallSiteToFunPtrMap;
+    typedef Set<const CallICFGNode*> CallSiteSet;
+    typedef OrderedMap<const CallICFGNode*,NodeID> CallSiteToFunPtrMap;
     typedef Map<NodeID,CallSiteSet> FunPtrToCallSitesMap;
     typedef Map<NodeID,NodeBS> MemObjToFieldsMap;
     typedef std::vector<const SVFStmt*> SVFStmtList;
     typedef std::vector<const SVFVar*> SVFVarList;
     typedef Map<const SVFVar*,PhiStmt*> PHINodeMap;
     typedef Map<const SVFFunction*,SVFVarList> FunToArgsListMap;
-    typedef Map<const CallBlockNode*,SVFVarList> CSToArgsListMap;
-    typedef Map<const RetBlockNode*,const SVFVar*> CSToRetMap;
+    typedef Map<const CallICFGNode*,SVFVarList> CSToArgsListMap;
+    typedef Map<const RetICFGNode*,const SVFVar*> CSToRetMap;
     typedef Map<const SVFFunction*,const SVFVar*> FunToRetMap;
     typedef Map<const SVFFunction*,SVFStmtSet> FunToPAGEdgeSetMap;
     typedef Map<const ICFGNode*,SVFStmtList> ICFGNode2SVFStmtsMap;
@@ -229,7 +229,7 @@ public:
         return it->second;
     }
     /// Callsite has argument list
-    inline bool hasCallSiteArgsMap(const CallBlockNode* cs) const
+    inline bool hasCallSiteArgsMap(const CallICFGNode* cs) const
     {
         return (callSiteArgsListMap.find(cs) != callSiteArgsListMap.end());
     }
@@ -239,7 +239,7 @@ public:
         return callSiteArgsListMap;
     }
     /// Get callsite argument list
-    inline const SVFVarList& getCallSiteArgsList(const CallBlockNode* cs) const
+    inline const SVFVarList& getCallSiteArgsList(const CallICFGNode* cs) const
     {
         CSToArgsListMap::const_iterator it = callSiteArgsListMap.find(cs);
         assert(it != callSiteArgsListMap.end() && "this call site doesn't have arguments");
@@ -251,13 +251,13 @@ public:
         return callSiteRetMap;
     }
     /// Get callsite return
-    inline const SVFVar* getCallSiteRet(const RetBlockNode* cs) const
+    inline const SVFVar* getCallSiteRet(const RetICFGNode* cs) const
     {
         CSToRetMap::const_iterator it = callSiteRetMap.find(cs);
         assert(it != callSiteRetMap.end() && "this call site doesn't have return");
         return it->second;
     }
-    inline bool callsiteHasRet(const RetBlockNode* cs) const
+    inline bool callsiteHasRet(const RetICFGNode* cs) const
     {
         return callSiteRetMap.find(cs) != callSiteRetMap.end();
     }
@@ -313,7 +313,7 @@ public:
     {
         return indCallSiteToFunPtrMap;
     }
-    inline NodeID getFunPtr(const CallBlockNode* cs) const
+    inline NodeID getFunPtr(const CallICFGNode* cs) const
     {
         CallSiteToFunPtrMap::const_iterator it = indCallSiteToFunPtrMap.find(cs);
         assert(it!=indCallSiteToFunPtrMap.end() && "indirect callsite not have a function pointer?");
@@ -325,7 +325,7 @@ public:
         assert(it!=funPtrToCallSitesMap.end() && "function pointer not used at any indirect callsite?");
         return it->second;
     }
-    inline bool isIndirectCallSites(const CallBlockNode* cs) const
+    inline bool isIndirectCallSites(const CallICFGNode* cs) const
     {
         return (indCallSiteToFunPtrMap.find(cs) != indCallSiteToFunPtrMap.end());
     }
@@ -493,31 +493,31 @@ private:
     /// Add function arguments
     inline void addFunArgs(const SVFFunction* fun, const SVFVar* arg)
     {
-        FunEntryBlockNode* funEntryBlockNode = icfg->getFunEntryBlockNode(fun);
+        FunEntryICFGNode* funEntryBlockNode = icfg->getFunEntryBlockNode(fun);
         funEntryBlockNode->addFormalParms(arg);
         funArgsListMap[fun].push_back(arg);
     }
     /// Add function returns
     inline void addFunRet(const SVFFunction* fun, const SVFVar* ret)
     {
-        FunExitBlockNode* funExitBlockNode = icfg->getFunExitBlockNode(fun);
+        FunExitICFGNode* funExitBlockNode = icfg->getFunExitBlockNode(fun);
         funExitBlockNode->addFormalRet(ret);
         funRetMap[fun] = ret;
     }
     /// Add callsite arguments
-    inline void addCallSiteArgs(CallBlockNode* callBlockNode,const SVFVar* arg)
+    inline void addCallSiteArgs(CallICFGNode* callBlockNode,const SVFVar* arg)
     {
         callBlockNode->addActualParms(arg);
         callSiteArgsListMap[callBlockNode].push_back(arg);
     }
     /// Add callsite returns
-    inline void addCallSiteRets(RetBlockNode* retBlockNode,const SVFVar* arg)
+    inline void addCallSiteRets(RetICFGNode* retBlockNode,const SVFVar* arg)
     {
         retBlockNode->addActualRet(arg);
         callSiteRetMap[retBlockNode]= arg;
     }
     /// Add indirect callsites
-    inline void addIndirectCallsites(const CallBlockNode* cs,NodeID funPtr)
+    inline void addIndirectCallsites(const CallICFGNode* cs,NodeID funPtr)
     {
         bool added = indCallSiteToFunPtrMap.insert(std::make_pair(cs,funPtr)).second;
         funPtrToCallSitesMap[funPtr].insert(cs);
@@ -618,7 +618,7 @@ private:
         globSVFStmtSet.insert(edge);
     }
     /// Add callsites
-    inline void addCallSite(const CallBlockNode* call)
+    inline void addCallSite(const CallICFGNode* call)
     {
         callSiteSet.insert(call);
     }
@@ -641,11 +641,11 @@ private:
     /// Add Load edge
     LoadStmt* addLoadStmt(NodeID src, NodeID dst);
     /// Add Store edge
-    StoreStmt* addStoreStmt(NodeID src, NodeID dst, const IntraBlockNode* val);
+    StoreStmt* addStoreStmt(NodeID src, NodeID dst, const IntraICFGNode* val);
     /// Add Call edge
-    CallPE* addCallPE(NodeID src, NodeID dst, const CallBlockNode* cs);
+    CallPE* addCallPE(NodeID src, NodeID dst, const CallICFGNode* cs);
     /// Add Return edge
-    RetPE* addRetPE(NodeID src, NodeID dst, const CallBlockNode* cs);
+    RetPE* addRetPE(NodeID src, NodeID dst, const CallICFGNode* cs);
     /// Add Gep edge
     GepStmt* addGepStmt(NodeID src, NodeID dst, const LocationSet& ls, bool constGep);
     /// Add Offset(Gep) edge
@@ -653,9 +653,9 @@ private:
     /// Add Variant(Gep) edge
     VariantGepStmt* addVariantGepStmt(NodeID src, NodeID dst, const LocationSet& ls);
     /// Add Thread fork edge for parameter passing
-    TDForkPE* addThreadForkPE(NodeID src, NodeID dst, const CallBlockNode* cs);
+    TDForkPE* addThreadForkPE(NodeID src, NodeID dst, const CallICFGNode* cs);
     /// Add Thread join edge for parameter passing
-    TDJoinPE* addThreadJoinPE(NodeID src, NodeID dst, const CallBlockNode* cs);
+    TDJoinPE* addThreadJoinPE(NodeID src, NodeID dst, const CallICFGNode* cs);
     //@}
 
     /// Set a pointer points-to black hole (e.g. int2ptr)

package/include/MemoryModel/SVFStatements.h

@@ -361,7 +361,7 @@ public:
     //@}
 
     /// constructor
-    StoreStmt(SVFVar* s, SVFVar* d, const IntraBlockNode* st) :
+    StoreStmt(SVFVar* s, SVFVar* d, const IntraICFGNode* st) :
         AssignStmt(s, d, makeEdgeFlagWithStoreInst(SVFStmt::Store, st))
     {
     }
@@ -546,7 +546,7 @@ private:
     CallPE(const CallPE &);  ///< place holder
     void operator=(const CallPE &); ///< place holder
 
-    const CallBlockNode* inst;		///< llvm instruction for this call
+    const CallICFGNode* inst;		///< llvm instruction for this call
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
@@ -567,18 +567,18 @@ public:
     //@}
 
     /// constructor
-    CallPE(SVFVar* s, SVFVar* d, const CallBlockNode* i, GEdgeKind k = SVFStmt::Call) :
+    CallPE(SVFVar* s, SVFVar* d, const CallICFGNode* i, GEdgeKind k = SVFStmt::Call) :
         AssignStmt(s,d,makeEdgeFlagWithCallInst(k,i)), inst(i)
     {
     }
 
     /// Get method for the call instruction
     //@{
-    inline const CallBlockNode* getCallInst() const
+    inline const CallICFGNode* getCallInst() const
     {
         return inst;
     }
-    inline const CallBlockNode* getCallSite() const
+    inline const CallICFGNode* getCallSite() const
     {
         return inst;
     }
@@ -598,7 +598,7 @@ private:
     RetPE(const RetPE &);  ///< place holder
     void operator=(const RetPE &); ///< place holder
 
-    const CallBlockNode* inst;		/// the callsite instruction return to
+    const CallICFGNode* inst;		/// the callsite instruction return to
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
@@ -619,18 +619,18 @@ public:
     //@}
 
     /// constructor
-    RetPE(SVFVar* s, SVFVar* d, const CallBlockNode* i, GEdgeKind k = SVFStmt::Ret) :
+    RetPE(SVFVar* s, SVFVar* d, const CallICFGNode* i, GEdgeKind k = SVFStmt::Ret) :
         AssignStmt(s,d,makeEdgeFlagWithCallInst(k,i)), inst(i)
     {
     }
 
     /// Get method for call instruction at caller
     //@{
-    inline const CallBlockNode* getCallInst() const
+    inline const CallICFGNode* getCallInst() const
     {
         return inst;
     }
-    inline const CallBlockNode* getCallSite() const
+    inline const CallICFGNode* getCallSite() const
     {
         return inst;
     }
@@ -999,7 +999,7 @@ public:
     //@}
 
     /// constructor
-    TDForkPE(SVFVar* s, SVFVar* d, const CallBlockNode* i) :
+    TDForkPE(SVFVar* s, SVFVar* d, const CallICFGNode* i) :
         CallPE(s,d,i,SVFStmt::ThreadFork)
     {
     }
@@ -1037,7 +1037,7 @@ public:
     //@}
 
     /// Constructor
-    TDJoinPE(SVFVar* s, SVFVar* d, const CallBlockNode* i) :
+    TDJoinPE(SVFVar* s, SVFVar* d, const CallICFGNode* i) :
         RetPE(s,d,i,SVFStmt::ThreadJoin)
     {
     }

package/include/SABER/LeakChecker.h

@@ -43,8 +43,8 @@ class LeakChecker : public SrcSnkDDA
 {
 
 public:
-    typedef Map<const SVFGNode*,const CallBlockNode*> SVFGNodeToCSIDMap;
-    typedef FIFOWorkList<const CallBlockNode*> CSWorkList;
+    typedef Map<const SVFGNode*,const CallICFGNode*> SVFGNodeToCSIDMap;
+    typedef FIFOWorkList<const CallICFGNode*> CSWorkList;
     typedef ProgSlice::VFWorkList WorkList;
     typedef NodeBS SVFGNodeBS;
     enum LEAK_TYPE
@@ -104,11 +104,11 @@ protected:
 
     /// Record a source to its callsite
     //@{
-    inline void addSrcToCSID(const SVFGNode* src, const CallBlockNode* cs)
+    inline void addSrcToCSID(const SVFGNode* src, const CallICFGNode* cs)
     {
         srcToCSIDMap[src] = cs;
     }
-    inline const CallBlockNode* getSrcCSID(const SVFGNode* src)
+    inline const CallICFGNode* getSrcCSID(const SVFGNode* src)
     {
         SVFGNodeToCSIDMap::iterator it =srcToCSIDMap.find(src);
         assert(it!=srcToCSIDMap.end() && "source node not at a callsite??");

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/NodeIDAllocator.h

@@ -27,6 +27,9 @@ public:
         /// If [****...*****] is the space of unsigned integers, we allocate as,
         /// [ssssooooooo...vvvvvvv] (o = object, v = value, s = special).
         DENSE,
+        /// Like dense, but with order flipped:
+        /// [ssssvvvvvvv...ooooooo]
+        REVERSE_DENSE,
         /// Allocate objects objects and values sequentially, intermixed.
         SEQ,
         /// Allocate values and objects as they come in with a single counter.

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