svf-tools 1.0.993 → 1.0.995

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.993",
+  "version": "1.0.995",
   "description": "* <b>[TypeClone](https://github.com/SVF-tools/SVF/wiki/TypeClone) published in our [ECOOP paper](https://yuleisui.github.io/publications/ecoop20.pdf) is now available in SVF </b> * <b>SVF now uses a single script for its build. Just type [`source ./build.sh`](https://github.com/SVF-tools/SVF/blob/master/build.sh) in your terminal, that's it!</b> * <b>SVF now supports LLVM-10.0.0! </b> * <b>We thank [bsauce](https://github.com/bsauce) for writing a user manual of SVF ([link1](https://www.jianshu.com/p/068a08ec749c) and [link2](https://www.jianshu.com/p/777c30d4240e)) in Chinese </b> * <b>SVF now supports LLVM-9.0.0 (Thank [Byoungyoung Lee](https://github.com/SVF-tools/SVF/issues/142) for his help!). </b> * <b>SVF now supports a set of [field-sensitive pointer analyses](https://yuleisui.github.io/publications/sas2019a.pdf). </b> * <b>[Use SVF as an external lib](https://github.com/SVF-tools/SVF/wiki/Using-SVF-as-a-lib-in-your-own-tool) for your own project (Contributed by [Hongxu Chen](https://github.com/HongxuChen)). </b> * <b>SVF now supports LLVM-7.0.0. </b> * <b>SVF now supports Docker. [Try SVF in Docker](https://github.com/SVF-tools/SVF/wiki/Try-SVF-in-Docker)! </b> * <b>SVF now supports [LLVM-6.0.0](https://github.com/svf-tools/SVF/pull/38) (Contributed by [Jack Anthony](https://github.com/jackanth)). </b> * <b>SVF now supports [LLVM-4.0.0](https://github.com/svf-tools/SVF/pull/23) (Contributed by Jared Carlson. Thank [Jared](https://github.com/jcarlson23) and [Will](https://github.com/dtzWill) for their in-depth [discussions](https://github.com/svf-tools/SVF/pull/18) about updating SVF!) </b> * <b>SVF now supports analysis for C++ programs.</b> <br />",
   "main": "index.js",
   "scripts": {

package/svf/include/Graphs/CDG.h

@@ -96,7 +96,7 @@ public:
 
 public:
     /// Constructor
-    CDGNode(const ICFGNode *icfgNode) : GenericCDGNodeTy(icfgNode->getId(), 0), _icfgNode(icfgNode)
+    CDGNode(const ICFGNode *icfgNode) : GenericCDGNodeTy(icfgNode->getId(), CDNodeKd), _icfgNode(icfgNode)
     {
 
     }
@@ -114,6 +114,23 @@ public:
         return _icfgNode;
     }
 
+    /// Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const CDGNode *)
+    {
+        return true;
+    }
+
+    static inline bool classof(const GenericICFGNodeTy* node)
+    {
+        return node->getNodeKind() == CDNodeKd;
+    }
+
+    static inline bool classof(const SVFBaseNode* node)
+    {
+        return node->getNodeKind() == CDNodeKd;
+    }
+    //@}
 
 private:
     const ICFGNode *_icfgNode;

package/svf/include/Graphs/CFLGraph.h

@@ -76,7 +76,7 @@ typedef GenericNode<CFLNode,CFLEdge> GenericCFLNodeTy;
 class CFLNode: public GenericCFLNodeTy
 {
 public:
-    CFLNode (NodeID i = 0, GNodeK k = 0):
+    CFLNode (NodeID i = 0, GNodeK k = CFLNodeKd):
         GenericCFLNodeTy(i, k)
     {
     }
@@ -148,6 +148,24 @@ public:
 
         return num1 && num2;
     }
+
+    /// Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const CFLNode *)
+    {
+        return true;
+    }
+
+    static inline bool classof(const GenericICFGNodeTy* node)
+    {
+        return node->getNodeKind() == CFLNodeKd;
+    }
+
+    static inline bool classof(const SVFBaseNode* node)
+    {
+        return node->getNodeKind() == CFLNodeKd;
+    }
+    //@}
 };
 
 /// Edge-labeled graph for CFL Reachability analysis

package/svf/include/Graphs/CHG.h

@@ -120,7 +120,7 @@ public:
 
     typedef std::vector<const SVFFunction*> FuncVector;
 
-    CHNode (const std::string& name, NodeID i = 0, GNodeK k = 0):
+    CHNode (const std::string& name, NodeID i = 0, GNodeK k = CHNodeKd):
         GenericCHNodeTy(i, k), vtable(nullptr), className(name), flags(0)
     {
     }
@@ -191,6 +191,24 @@ public:
         vtable = vtbl;
     }
 
+    /// Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const CHNode *)
+    {
+        return true;
+    }
+
+    static inline bool classof(const GenericCHNodeTy * node)
+    {
+        return node->getNodeKind() == CHNodeKd;
+    }
+
+    static inline bool classof(const SVFBaseNode* node)
+    {
+        return node->getNodeKind() == CHNodeKd;
+    }
+    //@}
+
 private:
     const SVFGlobalValue* vtable;
     std::string className;

package/svf/include/Graphs/CallGraph.h

@@ -184,7 +184,7 @@ private:
 
 public:
     /// Constructor
-    CallGraphNode(NodeID i, const SVFFunction* f) : GenericCallGraphNodeTy(i,0), fun(f)
+    CallGraphNode(NodeID i, const SVFFunction* f) : GenericCallGraphNodeTy(i,CallNodeKd), fun(f)
     {
 
     }
@@ -209,6 +209,24 @@ public:
     //@}
 
     virtual const std::string toString() const;
+
+    /// Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const CallGraphNode *)
+    {
+        return true;
+    }
+
+    static inline bool classof(const GenericICFGNodeTy* node)
+    {
+        return node->getNodeKind() == CallNodeKd;
+    }
+
+    static inline bool classof(const SVFBaseNode* node)
+    {
+        return node->getNodeKind() == CallNodeKd;
+    }
+    //@}
 };
 
 /*!

package/svf/include/Graphs/ConsGNode.h

@@ -71,7 +71,7 @@ public:
     NodeBS strides;
     NodeBS baseIds;
 
-    ConstraintNode(NodeID i) : GenericConsNodeTy(i, 0), _isPWCNode(false)
+    ConstraintNode(NodeID i) : GenericConsNodeTy(i, ConstraintNodeKd), _isPWCNode(false)
     {
 
     }
@@ -393,6 +393,24 @@ public:
         return o;
     }
     //@}
+
+    /// Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const ConstraintNode *)
+    {
+        return true;
+    }
+
+    static inline bool classof(const GenericICFGNodeTy* node)
+    {
+        return node->getNodeKind() == ConstraintNodeKd;
+    }
+
+    static inline bool classof(const SVFBaseNode* node)
+    {
+        return node->getNodeKind() == ConstraintNodeKd;
+    }
+    //@}
 };
 
 } // End namespace SVF

package/svf/include/Graphs/GenericGraph.h

@@ -134,11 +134,242 @@ protected:
 };
 
 
+class SVFBaseNode
+{
+
+public:
+
+    enum GNodeK
+    {
+        // ┌── ICFGNodeKinds: Combines inter-procedural and intra-procedural control flow graph nodes
+        // │   ├── Represents a node within a single procedure
+        IntraBlock,
+        // │   └── Represents a global-level block
+        GlobalBlock,
+        // │   └─ InterICFGNodeKinds: Types of inter-procedural control flow graph nodes
+        // │      ├── Entry point of a function
+        FunEntryBlock,
+        // │      ├── Exit point of a function
+        FunExitBlock,
+        // │      ├── Call site in the function
+        FunCallBlock,
+        // │      └── Return site in the function
+        FunRetBlock,
+        // └────────
+
+        // ┌── SVFVarKinds: Combines ValVarKinds and ObjVarKinds for variable nodes
+        // │   ┌── ValVarKinds: Types of value variable nodes
+        // │   │   ├── Represents a standard value variable
+        ValNode,
+        // │   │   ├── Represents a GEP value variable
+        GepValNode,
+        // │   │   ├── Represents a return value node
+        RetNode,
+        // │   │   ├── Represents a variadic argument node
+        VarargNode,
+        // │   │   └── Dummy node for uninitialized values
+        DummyValNode,
+        // │   └── ObjVarKinds: Types of object variable nodes
+        // │       ├── Represents an object variable
+        ObjNode,
+        // │       ├── GepObjNode: Represents a GEP object variable
+        GepObjNode,
+        // │       ├── FIObjNode: Represents a flow-insensitive object node
+        FIObjNode,
+        // │       └── DummyObjNode: Dummy node for uninitialized objects
+        DummyObjNode,
+        // └────────
+
+        // ┌── VFGNodeKinds: Various Value Flow Graph (VFG) node kinds with operations
+        // │   ├── Represents a comparison operation
+        Cmp,
+        // │   ├── Represents a binary operation
+        BinaryOp,
+        // │   ├── Represents a unary operation
+        UnaryOp,
+        // │   ├── Represents a branch operation
+        Branch,
+        // │   ├── Dummy node for value propagation
+        DummyVProp,
+        // │   └── Represents a null pointer operation
+        NPtr,
+        // │   └── ArgumentVFGNodeKinds: Types of argument nodes in VFG
+        // │        ├── Represents a function return value
+        FRet,
+        // │        ├── Represents an argument return value
+        ARet,
+        // │        ├── Represents an argument parameter
+        AParm,
+        // │        └── FParm: Represents a function parameter
+        FParm,
+        // │   └── StmtVFGNodeKinds: Types of statement nodes in VFG
+        // │        ├── Represents an address operation
+        Addr,
+        // │        ├── Represents a copy operation
+        Copy,
+        // │        ├── Represents a GEP operation
+        Gep,
+        // │        ├── Represents a store operation
+        Store,
+        // │        └── Represents a load operation
+        Load,
+        // │   └── PHIVFGNodeKinds: Types of PHI nodes in VFG
+        // │        ├── Represents a type-based PHI node
+        TPhi,
+        // │        ├── Represents an intra-procedural PHI node
+        TIntraPhi,
+        // │        └── Represents an inter-procedural PHI node
+        TInterPhi,
+        // │   └── MRSVFGNodeKinds: Memory-related SVFG nodes
+        // │        ├── Function parameter input
+        FPIN,
+        // │        ├── Function parameter output
+        FPOUT,
+        // │        ├── Argument parameter input
+        APIN,
+        // │        └── Argument parameter output
+        APOUT,
+        // │        └── MSSAPHISVFGNodeKinds: Mem SSA PHI nodes for SVFG
+        // │            ├── Memory PHI node
+        MPhi,
+        // │            ├── Intra-procedural memory PHI node
+        MIntraPhi,
+        // │            └── MInterPhi: Inter-procedural memory PHI node
+        MInterPhi,
+        // └────────
+
+        // Additional specific graph node types
+        CallNodeKd,    // Callgraph node
+        CDNodeKd,      // Control dependence graph node
+        CFLNodeKd,     // CFL graph node
+        CHNodeKd,      // Class hierarchy graph node
+        ConstraintNodeKd, // Constraint graph node
+        TCTNodeKd,     // Thread creation tree node
+        DCHNodeKd,     // DCHG node
+        OtherKd        // Other node kind
+    };
+
+
+
+    SVFBaseNode(NodeID i, GNodeK k): id(i), nodeKind(k)
+    {
+
+    }
+
+    /// Get ID
+    inline NodeID getId() const
+    {
+        return id;
+    }
+
+    /// Get node kind
+    inline GNodeK getNodeKind() const
+    {
+        return nodeKind;
+    }
+
+protected:
+    NodeID id;		///< Node ID
+    GNodeK nodeKind;	///< Node kind
+
+    /// Helper functions to check node kinds
+    //{@ Check node kind
+    static inline bool isICFGNodeKinds(GNodeK n)
+    {
+        static_assert(FunRetBlock - IntraBlock == 5,
+                      "the number of ICFGNodeKinds has changed, make sure "
+                      "the range is correct");
+        return n <= FunRetBlock && n >= IntraBlock;
+    }
+
+    static inline bool isInterICFGNodeKind(GNodeK n)
+    {
+        static_assert(FunRetBlock - FunEntryBlock == 3,
+                      "the number of InterICFGNodeKind has changed, make sure "
+                      "the range is correct");
+        return n <= FunRetBlock && n >= FunEntryBlock;
+    }
+
+    static inline bool isSVFVarKind(GNodeK n)
+    {
+        static_assert(DummyObjNode - ValNode == 8,
+                      "The number of SVFVarKinds has changed, make sure the "
+                      "range is correct");
+
+        return n <= DummyObjNode && n >= ValNode;
+    }
+
+    static inline bool isValVarKinds(GNodeK n)
+    {
+        static_assert(DummyValNode - ValNode == 4,
+                      "The number of ValVarKinds has changed, make sure the "
+                      "range is correct");
+        return n <= DummyValNode && n >= ValNode;
+    }
+
+    static inline bool isObjVarKinds(GNodeK n)
+    {
+        static_assert(DummyObjNode - ObjNode == 3,
+                      "The number of ObjVarKinds has changed, make sure the "
+                      "range is correct");
+        return n <= DummyObjNode && n >= ObjNode;
+    }
+
+    static inline bool isVFGNodeKinds(GNodeK n)
+    {
+        static_assert(MInterPhi - Cmp == 24,
+                      "The number of VFGNodeKinds has changed, make sure the "
+                      "range is correct");
+        return n <= MInterPhi && n >= Cmp;
+    }
+
+    static inline bool isArgumentVFGNodeKinds(GNodeK n)
+    {
+        static_assert(FParm - FRet == 3,
+                      "The number of ArgumentVFGNodeKinds has changed, make "
+                      "sure the range is correct");
+        return n <= FParm && n >= FRet;
+    }
+
+    static inline bool isStmtVFGNodeKinds(GNodeK n)
+    {
+        static_assert(Load - Addr == 4,
+                      "The number of StmtVFGNodeKinds has changed, make sure "
+                      "the range is correct");
+        return n <= Load && n >= Addr;
+    }
+
+    static inline bool isPHIVFGNodeKinds(GNodeK n)
+    {
+        static_assert(TInterPhi - TPhi == 2,
+                      "The number of PHIVFGNodeKinds has changed, make sure "
+                      "the range is correct");
+        return n <= TInterPhi && n >= TPhi;
+    }
+
+    static inline bool isMRSVFGNodeKinds(GNodeK n)
+    {
+        static_assert(MInterPhi - FPIN == 6,
+                      "The number of MRSVFGNodeKinds has changed, make sure "
+                      "the range is correct");
+        return n <= MInterPhi && n >= FPIN;
+    }
+
+    static inline bool isMSSAPHISVFGNodeKinds(GNodeK n)
+    {
+        static_assert(MInterPhi - MPhi == 2,
+                      "The number of MSSAPHISVFGNodeKinds has changed, make "
+                      "sure the range is correct");
+        return n <= MInterPhi && n >= MPhi;
+    }
+    //@}
+};
+
 /*!
  * Generic node on the graph as base class
  */
 template<class NodeTy,class EdgeTy>
-class GenericNode
+class GenericNode: public SVFBaseNode
 {
     friend class SVFIRWriter;
     friend class SVFIRReader;
@@ -147,7 +378,6 @@ public:
     typedef NodeTy NodeType;
     typedef EdgeTy EdgeType;
     /// Edge kind
-    typedef s64_t GNodeK;
     typedef OrderedSet<EdgeType*, typename EdgeType::equalGEdge> GEdgeSetTy;
     /// Edge iterator
     ///@{
@@ -156,15 +386,13 @@ public:
     ///@}
 
 private:
-    NodeID id;		///< Node ID
-    GNodeK nodeKind;	///< Node kind
 
     GEdgeSetTy InEdges; ///< all incoming edge of this node
     GEdgeSetTy OutEdges; ///< all outgoing edge of this node
 
 public:
     /// Constructor
-    GenericNode(NodeID i, GNodeK k): id(i),nodeKind(k)
+    GenericNode(NodeID i, GNodeK k): SVFBaseNode(i, k)
     {
 
     }
@@ -176,18 +404,6 @@ public:
             delete edge;
     }
 
-    /// Get ID
-    inline NodeID getId() const
-    {
-        return id;
-    }
-
-    /// Get node kind
-    inline GNodeK getNodeKind() const
-    {
-        return nodeKind;
-    }
-
     /// Get incoming/outgoing edge set
     ///@{
     inline const GEdgeSetTy& getOutEdges() const
@@ -334,6 +550,16 @@ public:
             return nullptr;
     }
     //@}
+
+    static inline bool classof(const GenericNode<NodeTy, EdgeTy>*)
+    {
+        return true;
+    }
+
+    static inline bool classof(const SVFBaseNode*)
+    {
+        return true;
+    }
 };
 
 /*

package/svf/include/Graphs/ICFG.h

@@ -60,9 +60,6 @@ public:
 
     typedef Map<const SVFFunction*, FunEntryICFGNode *> FunToFunEntryNodeMapTy;
     typedef Map<const SVFFunction*, FunExitICFGNode *> FunToFunExitNodeMapTy;
-    typedef Map<const SVFInstruction*, CallICFGNode *> CSToCallNodeMapTy;
-    typedef Map<const SVFInstruction*, RetICFGNode *> CSToRetNodeMapTy;
-    typedef Map<const SVFInstruction*, IntraICFGNode *> InstToBlockNodeMapTy;
     typedef std::vector<const SVFLoop *> SVFLoopVec;
     typedef Map<const ICFGNode *, SVFLoopVec> ICFGNodeToSVFLoopVec;
 
@@ -71,9 +68,6 @@ public:
 private:
     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
     GlobalICFGNode* globalBlockNode; ///< unique basic block for all globals
     ICFGNodeToSVFLoopVec icfgNodeToSVFLoopVec; ///< map ICFG node to the SVF loops where it resides
 
@@ -126,12 +120,6 @@ public:
         return it != icfgNodeToSVFLoopVec.end();
     }
 
-    /// Whether node is in a loop
-    inline bool isInLoop(const SVFInstruction* inst)
-    {
-        return isInLoop(getICFGNode(inst));
-    }
-
     /// Insert (node, loop) to icfgNodeToSVFLoopVec
     inline void addNodeToSVFLoop(const ICFGNode *node, const SVFLoop* loop)
     {
@@ -196,22 +184,7 @@ public:
     /// Get a basic block ICFGNode
     /// TODO:: need to fix the assertions
     //@{
-    ICFGNode* getICFGNode(const SVFInstruction* inst);
-
-    /// Whether has the ICFGNode
-    bool hasICFGNode(const SVFInstruction* inst);
-
-    CallICFGNode* getCallICFGNode(const SVFInstruction* inst);
-
-    CallICFGNode* addCallICFGNode(const SVFInstruction* inst);
-
-    RetICFGNode* getRetICFGNode(const SVFInstruction* inst);
-
-    RetICFGNode* addRetICFGNode(const SVFInstruction* inst);
 
-    IntraICFGNode* getIntraICFGNode(const SVFInstruction* inst);
-
-    IntraICFGNode* addIntraICFGNode(const SVFInstruction* inst);
 
     FunEntryICFGNode* getFunEntryICFGNode(const SVFFunction*  fun);
 
@@ -221,11 +194,6 @@ public:
     {
         return globalBlockNode;
     }
-    inline void addGlobalICFGNode()
-    {
-        globalBlockNode = new GlobalICFGNode(totalICFGNode++);
-        addICFGNode(globalBlockNode);
-    }
 
     const std::vector<const ICFGNode*>& getSubNodes(const ICFGNode* node) const
     {
@@ -272,22 +240,6 @@ private:
         return all_added;
     }
 
-    /// Get/Add IntraBlock ICFGNode
-    inline IntraICFGNode* getIntraBlock(const SVFInstruction* inst)
-    {
-        InstToBlockNodeMapTy::const_iterator it = InstToBlockNodeMap.find(inst);
-        if (it == InstToBlockNodeMap.end())
-            return nullptr;
-        return it->second;
-    }
-    inline IntraICFGNode* addIntraBlock(const SVFInstruction* inst)
-    {
-        IntraICFGNode* sNode = new IntraICFGNode(totalICFGNode++,inst);
-        addICFGNode(sNode);
-        InstToBlockNodeMap[inst] = sNode;
-        return sNode;
-    }
-
     /// Get/Add a function entry node
     inline FunEntryICFGNode* getFunEntryBlock(const SVFFunction* fun)
     {
@@ -296,13 +248,6 @@ private:
             return nullptr;
         return it->second;
     }
-    inline FunEntryICFGNode* addFunEntryBlock(const SVFFunction* fun)
-    {
-        FunEntryICFGNode* sNode = new FunEntryICFGNode(totalICFGNode++,fun);
-        addICFGNode(sNode);
-        FunToFunEntryNodeMap[fun] = sNode;
-        return sNode;
-    }
 
     /// Get/Add a function exit node
     inline FunExitICFGNode* getFunExitBlock(const SVFFunction* fun)
@@ -312,47 +257,6 @@ private:
             return nullptr;
         return it->second;
     }
-    inline FunExitICFGNode* addFunExitBlock(const SVFFunction* fun)
-    {
-        FunExitICFGNode* sNode = new FunExitICFGNode(totalICFGNode++, fun);
-        addICFGNode(sNode);
-        FunToFunExitNodeMap[fun] = sNode;
-        return sNode;
-    }
-
-    /// Get/Add a call node
-    inline CallICFGNode* addCallBlock(const SVFInstruction* cs)
-    {
-        CallICFGNode* sNode = new CallICFGNode(totalICFGNode++, cs);
-        addICFGNode(sNode);
-        CSToCallNodeMap[cs] = sNode;
-        return sNode;
-    }
-    inline CallICFGNode* getCallBlock(const SVFInstruction* cs)
-    {
-        CSToCallNodeMapTy::const_iterator it = CSToCallNodeMap.find(cs);
-        if (it == CSToCallNodeMap.end())
-            return nullptr;
-        return it->second;
-    }
-
-    /// Get/Add a return node
-    inline RetICFGNode* getRetBlock(const SVFInstruction* cs)
-    {
-        CSToRetNodeMapTy::const_iterator it = CSToRetNodeMap.find(cs);
-        if (it == CSToRetNodeMap.end())
-            return nullptr;
-        return it->second;
-    }
-    inline RetICFGNode* addRetBlock(const SVFInstruction* cs)
-    {
-        CallICFGNode* callBlockNode = getCallICFGNode(cs);
-        RetICFGNode* sNode = new RetICFGNode(totalICFGNode++, cs, callBlockNode);
-        callBlockNode->setRetICFGNode(sNode);
-        addICFGNode(sNode);
-        CSToRetNodeMap[cs] = sNode;
-        return sNode;
-    }
 
 };