svf-tools 1.0.994 → 1.0.996

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.994",
+  "version": "1.0.996",
   "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;
@@ -354,7 +371,7 @@ struct DOTGraphTraits<SVF::CDG *> : public DOTGraphTraits<SVF::PAG *>
             SVF::PAG::SVFStmtList &edges = SVF::PAG::getPAG()->getPTASVFStmtList(bNode);
             if (edges.empty())
             {
-                rawstr << bNode->getInst()->toString() << " \t";
+                rawstr << (bNode)->toString() << " \t";
             }
             else
             {

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

@@ -61,7 +61,7 @@ public:
     virtual const VFunSet &getCSVFsBasedonCHA(const CallICFGNode* cs) = 0;
     virtual bool csHasVtblsBasedonCHA(const CallICFGNode* cs) = 0;
     virtual const VTableSet &getCSVtblsBasedonCHA(const CallICFGNode* cs) = 0;
-    virtual void getVFnsFromVtbls(const SVFCallInst* cs, const VTableSet& vtbls,
+    virtual void getVFnsFromVtbls(const CallICFGNode* cs, const VTableSet& vtbls,
                                   VFunSet& virtualFunctions) = 0;
 
     CHGKind getKind(void) const
@@ -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;
@@ -222,9 +240,10 @@ public:
     typedef Set<const CHNode*> CHNodeSetTy;
     typedef FIFOWorkList<const CHNode*> WorkList;
     typedef Map<std::string, CHNodeSetTy> NameToCHNodesMap;
-    typedef Map<const SVFInstruction*, CHNodeSetTy> CallSiteToCHNodesMap;
-    typedef Map<const SVFInstruction*, VTableSet> CallSiteToVTableSetMap;
-    typedef Map<const SVFInstruction*, VFunSet> CallSiteToVFunSetMap;
+
+    typedef Map<const ICFGNode*, CHNodeSetTy> CallNodeToCHNodesMap;
+    typedef Map<const ICFGNode*, VTableSet> CallNodeToVTableSetMap;
+    typedef Map<const ICFGNode*, VFunSet> CallNodeToVFunSetMap;
 
     typedef enum
     {
@@ -242,7 +261,7 @@ public:
                  const std::string baseClassName,
                  CHEdge::CHEDGETYPE edgeType);
     CHNode *getNode(const std::string name) const;
-    void getVFnsFromVtbls(const SVFCallInst* cs, const VTableSet &vtbls, VFunSet &virtualFunctions) override;
+    void getVFnsFromVtbls(const CallICFGNode* cs, const VTableSet &vtbls, VFunSet &virtualFunctions) override;
     void dump(const std::string& filename);
     void view();
     void printCH();
@@ -307,11 +326,12 @@ private:
     NameToCHNodesMap classNameToAncestorsMap;
     NameToCHNodesMap classNameToInstAndDescsMap;
     NameToCHNodesMap templateNameToInstancesMap;
-    CallSiteToCHNodesMap csToClassesMap;
+    CallNodeToCHNodesMap callNodeToClassesMap;
 
     Map<const SVFFunction*, u32_t> virtualFunctionToIDMap;
-    CallSiteToVTableSetMap csToCHAVtblsMap;
-    CallSiteToVFunSetMap csToCHAVFnsMap;
+
+    CallNodeToVTableSetMap callNodeToCHAVtblsMap;
+    CallNodeToVFunSetMap callNodeToCHAVFnsMap;
 };
 
 } // End namespace SVF

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,263 @@ 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, SVFType* ty = nullptr): id(i),nodeKind(k), type(ty)
+    {
+
+    }
+
+    /// Get ID
+    inline NodeID getId() const
+    {
+        return id;
+    }
+
+    /// Get node kind
+    inline GNodeK getNodeKind() const
+    {
+        return nodeKind;
+    }
+
+    virtual const SVFType* getType() const
+    {
+        return type;
+    }
+
+    inline virtual void setSourceLoc(const std::string& sourceCodeInfo)
+    {
+        sourceLoc = sourceCodeInfo;
+    }
+
+    virtual const std::string getSourceLoc() const
+    {
+        return sourceLoc;
+    }
+
+    virtual const std::string toString() const;
+
+
+protected:
+    NodeID id;		///< Node ID
+    GNodeK nodeKind;	///< Node kind
+    const SVFType* type; ///< SVF type
+
+    std::string sourceLoc;  ///< Source code information of this value
+
+    /// 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 +399,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 +407,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 +425,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 +571,16 @@ public:
             return nullptr;
     }
     //@}
+
+    static inline bool classof(const GenericNode<NodeTy, EdgeTy>*)
+    {
+        return true;
+    }
+
+    static inline bool classof(const SVFBaseNode*)
+    {
+        return true;
+    }
 };
 
 /*