svf-lib 1.0.788 → 1.0.792

package/SVF-linux/include/Graphs/ICFG.h

@@ -259,7 +259,7 @@ private:
     {
         CallICFGNode* callBlockNode = getCallBlockNode(cs);
         RetICFGNode* sNode = new RetICFGNode(totalICFGNode++, cs, callBlockNode);
-        callBlockNode->setRetBlockNode(sNode);
+        callBlockNode->setRetICFGNode(sNode);
         addICFGNode(sNode);
         CSToRetNodeMap[cs] = sNode;
         return sNode;

package/SVF-linux/include/Graphs/ICFGNode.h

@@ -384,14 +384,14 @@ public:
     }
 
     /// Return callsite
-    inline const RetICFGNode* getRetBlockNode() const
+    inline const RetICFGNode* getRetICFGNode() const
     {
     	assert(ret && "RetICFGNode not set?");
         return ret;
     }
 
     /// Return callsite
-    inline void setRetBlockNode(const RetICFGNode* r)
+    inline void setRetICFGNode(const RetICFGNode* r)
     {
         ret = r;
     }

package/SVF-osx/include/DDA/ContextDDA.h

@@ -82,7 +82,7 @@ public:
     virtual bool isHeapCondMemObj(const CxtVar& var, const StoreSVFGNode* store) override;
 
     /// refine indirect call edge
-    bool testIndCallReachability(CxtLocDPItem& dpm, const SVFFunction* callee, const CallBlockNode* cs);
+    bool testIndCallReachability(CxtLocDPItem& dpm, const SVFFunction* callee, const CallICFGNode* cs);
 
     /// get callsite id from call, return 0 if it is a spurious call edge
     CallSiteID getCSIDAtCall(CxtLocDPItem& dpm, const SVFGEdge* edge);
@@ -111,13 +111,13 @@ public:
     }
     /// Update call graph.
     //@{
-    virtual void updateCallGraphAndSVFG(const CxtLocDPItem& dpm,const CallBlockNode* cs,SVFGEdgeSet& svfgEdges) override
+    virtual void updateCallGraphAndSVFG(const CxtLocDPItem& dpm,const CallICFGNode* cs,SVFGEdgeSet& svfgEdges) override
     {
         CallEdgeMap newEdges;
         resolveIndCalls(cs, getBVPointsTo(getCachedPointsTo(dpm)), newEdges);
         for (CallEdgeMap::const_iterator iter = newEdges.begin(),eiter = newEdges.end(); iter != eiter; iter++)
         {
-            const CallBlockNode* newcs = iter->first;
+            const CallICFGNode* newcs = iter->first;
             const FunctionSet & functions = iter->second;
             for (FunctionSet::const_iterator func_iter = functions.begin(); func_iter != functions.end(); func_iter++)
             {

package/SVF-osx/include/DDA/DDAClient.h

@@ -102,7 +102,7 @@ private:
 class FunptrDDAClient : public DDAClient
 {
 private:
-    typedef OrderedMap<NodeID,const CallBlockNode*> VTablePtrToCallSiteMap;
+    typedef OrderedMap<NodeID,const CallICFGNode*> VTablePtrToCallSiteMap;
     VTablePtrToCallSiteMap vtableToCallSiteMap;
 public:
     FunptrDDAClient(SVFModule* module) : DDAClient(module) {}
@@ -133,7 +133,7 @@ public:
     virtual void performStat(PointerAnalysis* pta);
 
 private:
-    typedef OrderedMap<NodeID,const CallBlockNode*> VTablePtrToCallSiteMap;
+    typedef OrderedMap<NodeID,const CallICFGNode*> VTablePtrToCallSiteMap;
     VTablePtrToCallSiteMap vtableToCallSiteMap;
     PAGNodeSet loadSrcNodes;
     PAGNodeSet storeDstNodes;

package/SVF-osx/include/DDA/DDAVFSolver.h

@@ -467,7 +467,7 @@ protected:
     /// resolve function pointer
     void resolveFunPtr(const DPIm& dpm)
     {
-        if(const CallBlockNode* cbn= getSVFG()->isCallSiteRetSVFGNode(dpm.getLoc()))
+        if(const CallICFGNode* cbn= getSVFG()->isCallSiteRetSVFGNode(dpm.getLoc()))
         {
             if(_pag->isIndirectCallSites(cbn))
             {
@@ -507,7 +507,7 @@ protected:
         return true;
     }
     /// Update call graph
-    virtual inline void updateCallGraphAndSVFG(const DPIm&, const CallBlockNode*, SVFGEdgeSet&) {}
+    virtual inline void updateCallGraphAndSVFG(const DPIm&, const CallICFGNode*, SVFGEdgeSet&) {}
     //@}
 
     ///Visited flags to avoid cycles

package/SVF-osx/include/DDA/FlowDDA.h

@@ -104,13 +104,13 @@ public:
 
     /// Update call graph.
     //@{
-    virtual void updateCallGraphAndSVFG(const LocDPItem& dpm,const CallBlockNode* cs,SVFGEdgeSet& svfgEdges) override
+    virtual void updateCallGraphAndSVFG(const LocDPItem& dpm,const CallICFGNode* cs,SVFGEdgeSet& svfgEdges) override
     {
         CallEdgeMap newEdges;
         resolveIndCalls(cs, getCachedPointsTo(dpm), newEdges);
         for (CallEdgeMap::const_iterator iter = newEdges.begin(),eiter = newEdges.end(); iter != eiter; iter++)
         {
-            const CallBlockNode* newcs = iter->first;
+            const CallICFGNode* newcs = iter->first;
             const FunctionSet & functions = iter->second;
             for (FunctionSet::const_iterator func_iter = functions.begin(); func_iter != functions.end(); func_iter++)
             {

package/SVF-osx/include/Graphs/ICFG.h

@@ -55,21 +55,21 @@ public:
     typedef ICFGNodeIDToNodeMapTy::iterator iterator;
     typedef ICFGNodeIDToNodeMapTy::const_iterator const_iterator;
 
-    typedef Map<const SVFFunction*, FunEntryBlockNode *> FunToFunEntryNodeMapTy;
-    typedef Map<const SVFFunction*, FunExitBlockNode *> FunToFunExitNodeMapTy;
-    typedef Map<const Instruction*, CallBlockNode *> CSToCallNodeMapTy;
-    typedef Map<const Instruction*, RetBlockNode *> CSToRetNodeMapTy;
-    typedef Map<const Instruction*, IntraBlockNode *> InstToBlockNodeMapTy;
+    typedef Map<const SVFFunction*, FunEntryICFGNode *> FunToFunEntryNodeMapTy;
+    typedef Map<const SVFFunction*, FunExitICFGNode *> FunToFunExitNodeMapTy;
+    typedef Map<const Instruction*, CallICFGNode *> CSToCallNodeMapTy;
+    typedef Map<const Instruction*, RetICFGNode *> CSToRetNodeMapTy;
+    typedef Map<const Instruction*, IntraICFGNode *> InstToBlockNodeMapTy;
 
     NodeID totalICFGNode;
 
 private:
-    FunToFunEntryNodeMapTy FunToFunEntryNodeMap; ///< map a function to its FunExitBlockNode
-    FunToFunExitNodeMapTy FunToFunExitNodeMap; ///< map a function to its FunEntryBlockNode
-    CSToCallNodeMapTy CSToCallNodeMap; ///< map a callsite to its CallBlockNode
-    CSToRetNodeMapTy CSToRetNodeMap; ///< map a callsite to its RetBlockNode
+    FunToFunEntryNodeMapTy FunToFunEntryNodeMap; ///< map a function to its FunExitICFGNode
+    FunToFunExitNodeMapTy FunToFunExitNodeMap; ///< map a function to its FunEntryICFGNode
+    CSToCallNodeMapTy CSToCallNodeMap; ///< map a callsite to its CallICFGNode
+    CSToRetNodeMapTy CSToRetNodeMap; ///< map a callsite to its RetICFGNode
     InstToBlockNodeMapTy InstToBlockNodeMap; ///< map a basic block to its ICFGNode
-    GlobalBlockNode* globalBlockNode; ///< unique basic block for all globals
+    GlobalICFGNode* globalBlockNode; ///< unique basic block for all globals
 
 public:
     /// Constructor
@@ -165,17 +165,17 @@ public:
     //@{
     ICFGNode* getBlockICFGNode(const Instruction* inst);
 
-    CallBlockNode* getCallBlockNode(const Instruction* inst);
+    CallICFGNode* getCallBlockNode(const Instruction* inst);
 
-    RetBlockNode* getRetBlockNode(const Instruction* inst);
+    RetICFGNode* getRetBlockNode(const Instruction* inst);
 
-    IntraBlockNode* getIntraBlockNode(const Instruction* inst);
+    IntraICFGNode* getIntraBlockNode(const Instruction* inst);
 
-    FunEntryBlockNode* getFunEntryBlockNode(const SVFFunction*  fun);
+    FunEntryICFGNode* getFunEntryBlockNode(const SVFFunction*  fun);
 
-    FunExitBlockNode* getFunExitBlockNode(const SVFFunction*  fun);
+    FunExitICFGNode* getFunExitBlockNode(const SVFFunction*  fun);
 
-    inline GlobalBlockNode* getGlobalBlockNode() const
+    inline GlobalICFGNode* getGlobalBlockNode() const
     {
         return globalBlockNode;
     }
@@ -184,62 +184,62 @@ public:
 private:
 	
     /// Get/Add IntraBlock ICFGNode
-    inline IntraBlockNode* getIntraBlockICFGNode(const Instruction* inst)
+    inline IntraICFGNode* getIntraBlockICFGNode(const Instruction* inst)
     {
         InstToBlockNodeMapTy::const_iterator it = InstToBlockNodeMap.find(inst);
         if (it == InstToBlockNodeMap.end())
             return nullptr;
         return it->second;
     }
-    inline IntraBlockNode* addIntraBlockICFGNode(const Instruction* inst)
+    inline IntraICFGNode* addIntraBlockICFGNode(const Instruction* inst)
     {
-        IntraBlockNode* sNode = new IntraBlockNode(totalICFGNode++,inst);
+        IntraICFGNode* sNode = new IntraICFGNode(totalICFGNode++,inst);
         addICFGNode(sNode);
         InstToBlockNodeMap[inst] = sNode;
         return sNode;
     }
 
     /// Get/Add a function entry node
-    inline FunEntryBlockNode* getFunEntryICFGNode(const SVFFunction* fun)
+    inline FunEntryICFGNode* getFunEntryICFGNode(const SVFFunction* fun)
     {
         FunToFunEntryNodeMapTy::const_iterator it = FunToFunEntryNodeMap.find(fun);
         if (it == FunToFunEntryNodeMap.end())
             return nullptr;
         return it->second;
     }
-    inline FunEntryBlockNode* addFunEntryICFGNode(const SVFFunction* fun)
+    inline FunEntryICFGNode* addFunEntryICFGNode(const SVFFunction* fun)
     {
-        FunEntryBlockNode* sNode = new FunEntryBlockNode(totalICFGNode++,fun);
+        FunEntryICFGNode* sNode = new FunEntryICFGNode(totalICFGNode++,fun);
         addICFGNode(sNode);
         FunToFunEntryNodeMap[fun] = sNode;
         return sNode;
     }
 
     /// Get/Add a function exit node
-    inline FunExitBlockNode* getFunExitICFGNode(const SVFFunction* fun)
+    inline FunExitICFGNode* getFunExitICFGNode(const SVFFunction* fun)
     {
         FunToFunExitNodeMapTy::const_iterator it = FunToFunExitNodeMap.find(fun);
         if (it == FunToFunExitNodeMap.end())
             return nullptr;
         return it->second;
     }
-    inline FunExitBlockNode* addFunExitICFGNode(const SVFFunction* fun)
+    inline FunExitICFGNode* addFunExitICFGNode(const SVFFunction* fun)
     {
-        FunExitBlockNode* sNode = new FunExitBlockNode(totalICFGNode++, fun);
+        FunExitICFGNode* sNode = new FunExitICFGNode(totalICFGNode++, fun);
         addICFGNode(sNode);
         FunToFunExitNodeMap[fun] = sNode;
         return sNode;
     }
 
     /// Get/Add a call node
-    inline CallBlockNode* addCallICFGNode(const Instruction* cs)
+    inline CallICFGNode* addCallICFGNode(const Instruction* cs)
     {
-        CallBlockNode* sNode = new CallBlockNode(totalICFGNode++, cs);
+        CallICFGNode* sNode = new CallICFGNode(totalICFGNode++, cs);
         addICFGNode(sNode);
         CSToCallNodeMap[cs] = sNode;
         return sNode;
     }
-    inline CallBlockNode* getCallICFGNode(const Instruction* cs)
+    inline CallICFGNode* getCallICFGNode(const Instruction* cs)
     {
         CSToCallNodeMapTy::const_iterator it = CSToCallNodeMap.find(cs);
         if (it == CSToCallNodeMap.end())
@@ -248,18 +248,18 @@ private:
     }
 
     /// Get/Add a return node
-    inline RetBlockNode* getRetICFGNode(const Instruction* cs)
+    inline RetICFGNode* getRetICFGNode(const Instruction* cs)
     {
         CSToRetNodeMapTy::const_iterator it = CSToRetNodeMap.find(cs);
         if (it == CSToRetNodeMap.end())
             return nullptr;
         return it->second;
     }
-    inline RetBlockNode* addRetICFGNode(const Instruction* cs)
+    inline RetICFGNode* addRetICFGNode(const Instruction* cs)
     {
-        CallBlockNode* callBlockNode = getCallBlockNode(cs);
-        RetBlockNode* sNode = new RetBlockNode(totalICFGNode++, cs, callBlockNode);
-        callBlockNode->setRetBlockNode(sNode);
+        CallICFGNode* callBlockNode = getCallBlockNode(cs);
+        RetICFGNode* sNode = new RetICFGNode(totalICFGNode++, cs, callBlockNode);
+        callBlockNode->setRetICFGNode(sNode);
         addICFGNode(sNode);
         CSToRetNodeMap[cs] = sNode;
         return sNode;

package/SVF-osx/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/SVF-osx/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++;