svf-tools 1.0.993 → 1.0.995

package/svf/include/Graphs/ICFGNode.h

@@ -57,17 +57,6 @@ class ICFGNode : public GenericICFGNodeTy
     friend class SVFIRReader;
 
 public:
-    /// 22 kinds of ICFG node
-    /// Gep represents offset edge for field sensitivity
-    enum ICFGNodeK
-    {
-        IntraBlock,
-        FunEntryBlock,
-        FunExitBlock,
-        FunCallBlock,
-        FunRetBlock,
-        GlobalBlock
-    };
 
     typedef ICFGEdge::ICFGEdgeSetTy::iterator iterator;
     typedef ICFGEdge::ICFGEdgeSetTy::const_iterator const_iterator;
@@ -75,10 +64,11 @@ public:
     typedef Set<const RetPE *> RetPESet;
     typedef std::list<const VFGNode*> VFGNodeList;
     typedef std::list<const SVFStmt*> SVFStmtList;
+    typedef GNodeK ICFGNodeK;
 
 public:
     /// Constructor
-    ICFGNode(NodeID i, ICFGNodeK k) : GenericICFGNodeTy(i, k), fun(nullptr), bb(nullptr)
+    ICFGNode(NodeID i, GNodeK k) : GenericICFGNodeTy(i, k), fun(nullptr), bb(nullptr)
     {
     }
 
@@ -136,6 +126,22 @@ public:
 
     void dump() const;
 
+
+    static inline bool classof(const ICFGNode *)
+    {
+        return true;
+    }
+
+    static inline bool classof(const GenericICFGNodeTy* node)
+    {
+        return isICFGNodeKinds(node->getNodeKind());
+    }
+
+    static inline bool classof(const SVFBaseNode* node)
+    {
+        return isICFGNodeKinds(node->getNodeKind());
+    }
+
 protected:
     const SVFFunction* fun;
     const SVFBasicBlock* bb;
@@ -248,26 +254,28 @@ public:
         return true;
     }
 
-    static inline bool classof(const ICFGNode *node)
+    static inline bool classof(const ICFGNode* node)
     {
-        return node->getNodeKind() == FunEntryBlock
-               || node->getNodeKind() == FunExitBlock
-               || node->getNodeKind() == FunCallBlock
-               || node->getNodeKind() == FunRetBlock;
+        return isInterICFGNodeKind(node->getNodeKind());
     }
 
-    static inline bool classof(const GenericICFGNodeTy *node)
+    static inline bool classof(const GenericICFGNodeTy* node)
     {
-        return node->getNodeKind() == FunEntryBlock
-               || node->getNodeKind() == FunExitBlock
-               || node->getNodeKind() == FunCallBlock
-               || node->getNodeKind() == FunRetBlock;
+        return isInterICFGNodeKind(node->getNodeKind());
     }
+
+    static inline bool classof(const SVFBaseNode* node)
+    {
+        return isInterICFGNodeKind(node->getNodeKind());
+    }
+
     //@}
     virtual const std::string getSourceLoc() const = 0;
 };
 
 
+
+
 /*!
  * Function entry ICFGNode containing a set of FormalParmVFGNodes of a function
  */
@@ -326,6 +334,11 @@ public:
     {
         return node->getNodeKind() == FunEntryBlock;
     }
+
+    static inline bool classof(const SVFBaseNode*node)
+    {
+        return node->getNodeKind() == FunEntryBlock;
+    }
     //@}
 
     const virtual std::string toString() const;
@@ -392,6 +405,11 @@ public:
     {
         return node->getNodeKind() == FunExitBlock;
     }
+
+    static inline bool classof(const SVFBaseNode*node)
+    {
+        return node->getNodeKind() == FunExitBlock;
+    }
     //@}
 
     virtual const std::string toString() const;
@@ -482,6 +500,12 @@ public:
     {
         return SVFUtil::cast<SVFCallInst>(cs)->getArgOperand(ArgNo);
     }
+
+    const SVFVar* getArgumentVar(u32_t ArgNo) const
+    {
+        return getActualParms()[ArgNo];
+    }
+
     const SVFType* getType() const
     {
         return SVFUtil::cast<SVFCallInst>(cs)->getType();
@@ -556,6 +580,11 @@ public:
     {
         return node->getNodeKind() == FunCallBlock;
     }
+
+    static inline bool classof(const SVFBaseNode*node)
+    {
+        return node->getNodeKind() == FunCallBlock;
+    }
     //@}
 
     virtual const std::string toString() const;
@@ -637,6 +666,10 @@ public:
     {
         return node->getNodeKind() == FunRetBlock;
     }
+    static inline bool classof(const SVFBaseNode*node)
+    {
+        return node->getNodeKind() == FunRetBlock;
+    }
     //@}
 
     virtual const std::string toString() const;

package/svf/include/Graphs/SVFG.h

@@ -420,7 +420,7 @@ protected:
     inline void addActualINSVFGNode(const CallICFGNode* callsite, const MRVer* ver, const NodeID nodeId)
     {
         ActualINSVFGNode* sNode = new ActualINSVFGNode(nodeId, callsite, ver);
-        addSVFGNode(sNode,pag->getICFG()->getCallICFGNode(callsite->getCallSite()));
+        addSVFGNode(sNode, const_cast<CallICFGNode*>(callsite));
         callSiteToActualINMap[callsite].set(sNode->getId());
     }
 
@@ -428,7 +428,7 @@ protected:
     inline void addActualOUTSVFGNode(const CallICFGNode* callsite, const MRVer* resVer, const NodeID nodeId)
     {
         ActualOUTSVFGNode* sNode = new ActualOUTSVFGNode(nodeId, callsite, resVer);
-        addSVFGNode(sNode, pag->getICFG()->getRetICFGNode(callsite->getCallSite()));
+        addSVFGNode(sNode,const_cast<RetICFGNode*>(callsite->getRetICFGNode()));
         setDef(resVer,sNode);
         callSiteToActualOUTMap[callsite].set(sNode->getId());
     }

package/svf/include/Graphs/SVFGNode.h

@@ -64,23 +64,11 @@ public:
     }
     static inline bool classof(const VFGNode *node)
     {
-        return node->getNodeKind() == FPIN ||
-               node->getNodeKind() == FPOUT ||
-               node->getNodeKind() == APIN ||
-               node->getNodeKind() == APOUT ||
-               node->getNodeKind() == MPhi ||
-               node->getNodeKind() == MIntraPhi ||
-               node->getNodeKind() == MInterPhi;
+        return isMRSVFGNodeKinds(node->getNodeKind());
     }
     static inline bool classof(const GenericVFGNodeTy *node)
     {
-        return node->getNodeKind() == FPIN ||
-               node->getNodeKind() == FPOUT ||
-               node->getNodeKind() == APIN ||
-               node->getNodeKind() == APOUT ||
-               node->getNodeKind() == MPhi ||
-               node->getNodeKind() == MIntraPhi ||
-               node->getNodeKind() == MInterPhi;
+        return isMRSVFGNodeKinds(node->getNodeKind());
     }
     //@}
 
@@ -328,15 +316,15 @@ public:
     }
     static inline bool classof(const MRSVFGNode *node)
     {
-        return (node->getNodeKind() == MPhi || node->getNodeKind() == MIntraPhi || node->getNodeKind() == MInterPhi);
+        return isMSSAPHISVFGNodeKinds(node->getNodeKind());
     }
     static inline bool classof(const VFGNode *node)
     {
-        return (node->getNodeKind() == MPhi || node->getNodeKind() == MIntraPhi || node->getNodeKind() == MInterPhi);
+        return isMSSAPHISVFGNodeKinds(node->getNodeKind());
     }
     static inline bool classof(const GenericVFGNodeTy *node)
     {
-        return (node->getNodeKind() == MPhi || node->getNodeKind() == MIntraPhi || node->getNodeKind() == MInterPhi);
+        return isMSSAPHISVFGNodeKinds(node->getNodeKind());
     }
     //@}
 

package/svf/include/Graphs/SVFGOPT.h

@@ -252,7 +252,8 @@ private:
     inline InterPHISVFGNode* addInterPHIForAR(const ActualRetSVFGNode* ar)
     {
         InterPHISVFGNode* sNode = new InterPHISVFGNode(totalVFGNode++,ar);
-        addSVFGNode(sNode, pag->getICFG()->getRetICFGNode(ar->getCallSite()->getCallSite()));
+        addSVFGNode(sNode, const_cast<RetICFGNode*>(
+                        ar->getCallSite()->getRetICFGNode()));
         resetDef(ar->getRev(),sNode);
         return sNode;
     }

package/svf/include/Graphs/ThreadCallGraph.h

@@ -31,13 +31,13 @@
 #define RCG_H_
 
 #include "Graphs/CallGraph.h"
-#include "MemoryModel/PointerAnalysisImpl.h"
 
 namespace SVF
 {
 
 class SVFModule;
 class ThreadAPI;
+class PointerAnalysis;
 /*!
  * PTA thread fork edge from fork site to the entry of a start routine function
  */
@@ -201,7 +201,8 @@ public:
     /// whether this call instruction has a valid call graph edge
     inline bool hasThreadForkEdge(const CallICFGNode* cs) const
     {
-        return callinstToThreadForkEdgesMap.find(cs) != callinstToThreadForkEdgesMap.end();
+        return callinstToThreadForkEdgesMap.find(cs) !=
+               callinstToThreadForkEdgesMap.end();
     }
     inline ForkEdgeSet::const_iterator getForkEdgeBegin(const CallICFGNode* cs) const
     {
@@ -345,8 +346,8 @@ public:
 
     /// Add direct/indirect thread fork edges
     //@{
-    void addDirectForkEdge(const CallICFGNode* cs);
-    void addIndirectForkEdge(const CallICFGNode* cs, const SVFFunction* callee);
+    bool addDirectForkEdge(const CallICFGNode* cs);
+    bool addIndirectForkEdge(const CallICFGNode* cs, const SVFFunction* callee);
     //@}
 
     /// Add thread join edges

package/svf/include/Graphs/VFG.h

@@ -530,7 +530,7 @@ protected:
     inline void addActualParmVFGNode(const PAGNode* aparm, const CallICFGNode* cs)
     {
         ActualParmVFGNode* sNode = new ActualParmVFGNode(totalVFGNode++,aparm,cs);
-        addVFGNode(sNode, pag->getICFG()->getCallICFGNode(cs->getCallSite()));
+        addVFGNode(sNode, const_cast<CallICFGNode*>(cs));
         PAGNodeToActualParmMap[std::make_pair(aparm->getId(),cs)] = sNode;
         /// do not set def here, this node is not a variable definition
     }
@@ -571,7 +571,7 @@ protected:
     inline void addActualRetVFGNode(const PAGNode* ret,const CallICFGNode* cs)
     {
         ActualRetVFGNode* sNode = new ActualRetVFGNode(totalVFGNode++,ret,cs);
-        addVFGNode(sNode, pag->getICFG()->getRetICFGNode(cs->getCallSite()));
+        addVFGNode(sNode, const_cast<RetICFGNode*>(cs->getRetICFGNode()));
         setDef(ret,sNode);
         PAGNodeToActualRetMap[ret] = sNode;
     }

package/svf/include/Graphs/VFGNode.h

@@ -49,12 +49,7 @@ class VFGNode : public GenericVFGNodeTy
 public:
     /// 25 kinds of ICFG node
     /// Gep represents offset edge for field sensitivity
-    enum VFGNodeK
-    {
-        Addr, Copy, Gep, Store, Load, Cmp, BinaryOp, UnaryOp, Branch, TPhi, TIntraPhi, TInterPhi,
-        MPhi, MIntraPhi, MInterPhi, FRet, ARet, AParm, FParm,
-        APIN, APOUT, FPIN, FPOUT, NPtr, DummyVProp
-    };
+    typedef GNodeK VFGNodeK;
 
     typedef VFGEdge::VFGEdgeSetTy::iterator iterator;
     typedef VFGEdge::VFGEdgeSetTy::const_iterator const_iterator;
@@ -106,6 +101,22 @@ public:
 
     virtual const std::string toString() const;
 
+    static inline bool classof(const VFGNode *)
+    {
+        return true;
+    }
+
+    static inline bool classof(const GenericVFGNodeTy * node)
+    {
+        return isVFGNodeKinds(node->getNodeKind());
+    }
+
+
+    static inline bool classof(const SVFBaseNode* node)
+    {
+        return isVFGNodeKinds(node->getNodeKind());
+    }
+
 protected:
     const ICFGNode* icfgNode;
 };
@@ -167,19 +178,15 @@ public:
     }
     static inline bool classof(const VFGNode *node)
     {
-        return node->getNodeKind() == Addr
-               || node->getNodeKind() == Copy
-               || node->getNodeKind() == Gep
-               || node->getNodeKind() == Store
-               || node->getNodeKind() == Load;
+        return isStmtVFGNodeKinds(node->getNodeKind());
     }
     static inline bool classof(const GenericVFGNodeTy *node)
     {
-        return node->getNodeKind() == Addr
-               || node->getNodeKind() == Copy
-               || node->getNodeKind() == Gep
-               || node->getNodeKind() == Store
-               || node->getNodeKind() == Load;
+        return isStmtVFGNodeKinds(node->getNodeKind());
+    }
+    static inline bool classof(const SVFBaseNode*node)
+    {
+        return isStmtVFGNodeKinds(node->getNodeKind());
     }
     //@}
 
@@ -221,6 +228,10 @@ public:
     {
         return node->getNodeKind() == Load;
     }
+    static inline bool classof(const SVFBaseNode*node)
+    {
+        return node->getNodeKind() == Load;
+    }
     //@}
 
     const NodeBS getDefSVFVars() const override;
@@ -262,6 +273,10 @@ public:
     {
         return node->getNodeKind() == Store;
     }
+    static inline bool classof(const SVFBaseNode*node)
+    {
+        return node->getNodeKind() == Store;
+    }
     //@}
 
     const NodeBS getDefSVFVars() const override;
@@ -303,6 +318,10 @@ public:
     {
         return node->getNodeKind() == Copy;
     }
+    static inline bool classof(const SVFBaseNode*node)
+    {
+        return node->getNodeKind() == Copy;
+    }
     //@}
 
     const NodeBS getDefSVFVars() const override;
@@ -345,6 +364,10 @@ public:
     {
         return node->getNodeKind() == Cmp;
     }
+    static inline bool classof(const SVFBaseNode*node)
+    {
+        return node->getNodeKind() == Cmp;
+    }
     //@}
     /// Operands at a BinaryNode
     //@{
@@ -416,6 +439,10 @@ public:
     {
         return node->getNodeKind() == BinaryOp;
     }
+    static inline bool classof(const SVFBaseNode*node)
+    {
+        return node->getNodeKind() == BinaryOp;
+    }
     //@}
     /// Operands at a BinaryNode
     //@{
@@ -486,6 +513,10 @@ public:
     {
         return node->getNodeKind() == UnaryOp;
     }
+    static inline bool classof(const SVFBaseNode*node)
+    {
+        return node->getNodeKind() == UnaryOp;
+    }
     //@}
     /// Operands at a UnaryNode
     //@{
@@ -554,6 +585,10 @@ public:
     {
         return node->getNodeKind() == Branch;
     }
+    static inline bool classof(const SVFBaseNode*node)
+    {
+        return node->getNodeKind() == Branch;
+    }
     //@}
 
     /// Return the branch statement
@@ -616,6 +651,10 @@ public:
     {
         return node->getNodeKind() == Gep;
     }
+    static inline bool classof(const SVFBaseNode*node)
+    {
+        return node->getNodeKind() == Gep;
+    }
     //@}
 
     const NodeBS getDefSVFVars() const override;
@@ -683,11 +722,15 @@ public:
     }
     static inline bool classof(const VFGNode *node)
     {
-        return (node->getNodeKind() == TPhi || node->getNodeKind() == TIntraPhi || node->getNodeKind() == TInterPhi);
+        return isPHIVFGNodeKinds(node->getNodeKind());
     }
     static inline bool classof(const GenericVFGNodeTy *node)
     {
-        return (node->getNodeKind() == TPhi || node->getNodeKind() == TIntraPhi || node->getNodeKind() == TInterPhi);
+        return isPHIVFGNodeKinds(node->getNodeKind());
+    }
+    static inline bool classof(const SVFBaseNode*node)
+    {
+        return isPHIVFGNodeKinds(node->getNodeKind());
     }
     //@}
 
@@ -745,6 +788,10 @@ public:
     {
         return node->getNodeKind() == TIntraPhi;
     }
+    static inline bool classof(const SVFBaseNode*node)
+    {
+        return node->getNodeKind() == TIntraPhi;
+    }
     //@}
 
     const std::string toString() const override;
@@ -782,6 +829,10 @@ public:
     {
         return node->getNodeKind() == Addr;
     }
+    static inline bool classof(const SVFBaseNode*node)
+    {
+        return node->getNodeKind() == Addr;
+    }
     //@}
 
     const NodeBS getDefSVFVars() const override;
@@ -816,17 +867,15 @@ public:
     }
     static inline bool classof(const VFGNode *node)
     {
-        return node->getNodeKind() == FRet
-               || node->getNodeKind() == ARet
-               || node->getNodeKind() == AParm
-               || node->getNodeKind() == FParm;
+        return isArgumentVFGNodeKinds(node->getNodeKind());
     }
     static inline bool classof(const GenericVFGNodeTy *node)
     {
-        return node->getNodeKind() == FRet
-               || node->getNodeKind() == ARet
-               || node->getNodeKind() == AParm
-               || node->getNodeKind() == FParm;
+        return isArgumentVFGNodeKinds(node->getNodeKind());
+    }
+    static inline bool classof(const SVFBaseNode*node)
+    {
+        return isArgumentVFGNodeKinds(node->getNodeKind());
     }
     //@}
 
@@ -878,6 +927,10 @@ public:
     {
         return node->getNodeKind() == AParm;
     }
+    static inline bool classof(const SVFBaseNode*node)
+    {
+        return node->getNodeKind() == AParm;
+    }
     //@}
 
     const NodeBS getDefSVFVars() const override;
@@ -948,6 +1001,10 @@ public:
     {
         return node->getNodeKind() == FParm;
     }
+    static inline bool classof(const SVFBaseNode*node)
+    {
+        return node->getNodeKind() == FParm;
+    }
     //@}
 
     const NodeBS getDefSVFVars() const override;
@@ -1006,6 +1063,10 @@ public:
     {
         return node->getNodeKind() == ARet;
     }
+    static inline bool classof(const SVFBaseNode*node)
+    {
+        return node->getNodeKind() == ARet;
+    }
     //@}
 
     const NodeBS getDefSVFVars() const override;
@@ -1072,6 +1133,10 @@ public:
     {
         return node->getNodeKind() == FRet;
     }
+    static inline bool classof(const SVFBaseNode*node)
+    {
+        return node->getNodeKind() == FRet;
+    }
     //@}
 
     const NodeBS getDefSVFVars() const override;
@@ -1131,6 +1196,10 @@ public:
     {
         return node->getNodeKind() == TInterPhi;
     }
+    static inline bool classof(const SVFBaseNode*node)
+    {
+        return node->getNodeKind() == TInterPhi;
+    }
     //@}
 
     const std::string toString() const override;
@@ -1179,6 +1248,10 @@ public:
     {
         return node->getNodeKind() == NPtr;
     }
+    static inline bool classof(const SVFBaseNode*node)
+    {
+        return node->getNodeKind() == NPtr;
+    }
     //@}
 
     const NodeBS getDefSVFVars() const override;

package/svf/include/MTA/TCT.h

@@ -88,7 +88,7 @@ class TCTNode: public GenericTCTNodeTy
 public:
     /// Constructor
     TCTNode(NodeID i, const CxtThread& cctx) :
-        GenericTCTNodeTy(i, 0), ctx(cctx), multiforked(false)
+        GenericTCTNodeTy(i, TCTNodeKd), ctx(cctx), multiforked(false)
     {
     }
 
@@ -123,6 +123,24 @@ public:
     }
     //@}
 
+    ///Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const TCTNode *)
+    {
+        return true;
+    }
+
+    static inline bool classof(const GenericTCTNodeTy *node)
+    {
+        return node->getNodeKind() == TCTNodeKd;
+    }
+    static inline bool classof(const SVFBaseNode*node)
+    {
+        return node->getNodeKind() == TCTNodeKd;
+    }
+    //@}
+
+
 private:
     const CxtThread ctx;
     bool multiforked;

package/svf/include/MemoryModel/PointerAnalysis.h

@@ -34,7 +34,7 @@
 #include <signal.h>
 
 #include "Graphs/CHG.h"
-#include "Graphs/CallGraph.h"
+#include "Graphs/ThreadCallGraph.h"
 #include "Graphs/SCC.h"
 #include "MemoryModel/AbstractPointsToDS.h"
 #include "MemoryModel/ConditionalPT.h"

package/svf/include/MemoryModel/PointerAnalysisImpl.h

@@ -199,6 +199,10 @@ protected:
     /// On the fly call graph construction
     virtual void onTheFlyCallGraphSolve(const CallSiteToFunPtrMap& callsites, CallEdgeMap& newEdges);
 
+    /// On the fly thread call graph construction respecting forksite
+    virtual void onTheFlyThreadCallGraphSolve(const CallSiteToFunPtrMap& callsites,
+            CallEdgeMap& newForkEdges);
+
     /// Normalize points-to information for field-sensitive analysis,
     /// i.e., replace fieldObj with baseObj if it is field-insensitive
     virtual void normalizePointsTo();

package/svf/include/SABER/SaberCondAllocator.h

@@ -282,9 +282,9 @@ private:
     /// Return true if the predicate of this compare instruction is not equal
     bool isNECmp(const CmpStmt* cmp) const;
     /// Return true if this is a test null expression
-    bool isTestNullExpr(const SVFValue* test) const;
+    bool isTestNullExpr(const ICFGNode* test) const;
     /// Return true if this is a test not null expression
-    bool isTestNotNullExpr(const SVFValue* test) const;
+    bool isTestNotNullExpr(const ICFGNode* test) const;
     /// Return true if two values on the predicate are what we want
     bool isTestContainsNullAndTheValue(const CmpStmt* cmp) const;
     //@}

package/svf/include/SVFIR/SVFFileSystem.h

@@ -1064,7 +1064,7 @@ public:
     }
 
 private:
-    using GNodeK = GenericNode<int, GenericEdge<void>>::GNodeK;
+    using GNodeK = s32_t;
     using GEdgeFlag = GenericEdge<void>::GEdgeFlag;
     using GEdgeKind = GenericEdge<void>::GEdgeKind;
     static ICFGNode* createICFGNode(NodeID id, GNodeK type);

package/svf/include/SVFIR/SVFIR.h

@@ -531,9 +531,9 @@ private:
     /// add node into SVFIR
     //@{
     /// Add a value (pointer) node
-    inline NodeID addValNode(const SVFValue* val, NodeID i)
+    inline NodeID addValNode(const SVFValue* val, NodeID i, const SVFBaseNode* gNode)
     {
-        SVFVar *node = new ValVar(val,i);
+        SVFVar *node = new ValVar(val,i, ValVar::ValNode, gNode);
         return addValNode(val, node, i);
     }
     /// Add a memory obj node