svf-tools 1.0.1032 → 1.0.1034

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.1032",
+  "version": "1.0.1034",
   "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/BasicBlockG.h

@@ -0,0 +1,310 @@
+//===- BasicBlockG.h -- BasicBlock node------------------------------------------------//
+//
+//                     SVF: Static Value-Flow Analysis
+//
+// Copyright (C) <2013-2025>  <Yulei Sui>
+//
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * ICFGNode.h
+ *
+ *  Created on: 23 Jan, 2025
+ *      Author: Jiawei, Xiao
+ */
+
+#ifndef BASICBLOCKGRAPH_H_
+#define BASICBLOCKGRAPH_H_
+#include "GenericGraph.h"
+#include <sstream>
+#include <algorithm>
+
+
+namespace SVF
+{
+class SVFBasicBlock;
+class BasicBlockEdge;
+class ICFGNode;
+class SVFFunction;
+typedef GenericEdge<SVFBasicBlock> GenericBasicBlockEdgeTy;
+class BasicBlockEdge: public GenericBasicBlockEdgeTy
+{
+    friend class SVFIRWriter;
+    friend class SVFIRReader;
+
+public:
+public:
+    /// Constructor
+    BasicBlockEdge(SVFBasicBlock* s, SVFBasicBlock* d) : GenericBasicBlockEdgeTy(s, d, 0)
+    {
+    }
+    /// Destructor
+    ~BasicBlockEdge() {}
+
+    /// Overloading operator << for dumping ICFG node ID
+    //@{
+    friend OutStream& operator<<(OutStream& o, const BasicBlockEdge& edge)
+    {
+        o << edge.toString();
+        return o;
+    }
+    //@}
+
+    virtual const std::string toString() const;
+};
+
+
+typedef GenericNode<SVFBasicBlock, BasicBlockEdge> GenericBasicBlockNodeTy;
+class SVFBasicBlock : public GenericBasicBlockNodeTy
+{
+    friend class LLVMModuleSet;
+    friend class SVFIRWriter;
+    friend class SVFIRReader;
+    friend class SVFIRBuilder;
+    friend class SVFFunction;
+    friend class ICFGBuilder;
+    friend class ICFG;
+
+public:
+    typedef std::vector<const ICFGNode*>::const_iterator const_iterator;
+    std::vector<const SVFBasicBlock*> succBBs;
+    std::vector<const SVFBasicBlock*> predBBs;
+
+private:
+    std::vector<const ICFGNode*> allICFGNodes;    ///< all ICFGNodes in this BasicBlock
+    const SVFFunction* fun;                 /// Function where this BasicBlock is
+
+
+
+protected:
+    ///@{ attributes to be set only through Module builders e.g., LLVMModule
+
+    inline void addICFGNode(const ICFGNode* icfgNode)
+    {
+        assert(std::find(getICFGNodeList().begin(), getICFGNodeList().end(),
+                         icfgNode) == getICFGNodeList().end() && "duplicated icfgnode");
+        allICFGNodes.push_back(icfgNode);
+    }
+
+    /// @}
+
+public:
+    /// Constructor without name
+    SVFBasicBlock(NodeID id, const SVFFunction* f): GenericBasicBlockNodeTy(id, BasicBlockKd), fun(f)
+    {
+
+    }
+    SVFBasicBlock() = delete;
+    ~SVFBasicBlock()
+    {
+
+    }
+
+    static inline bool classof(const SVFBaseNode* node)
+    {
+        return node->getNodeKind() == SVFBaseNode::BasicBlockKd;
+    }
+
+    static inline bool classof(const SVFBasicBlock* node)
+    {
+        return true;
+    }
+
+    //@{
+    friend OutStream &operator<<(OutStream &o, const SVFBasicBlock&node)
+    {
+        o << node.toString();
+        return o;
+    }
+    //@}
+
+
+    inline const std::vector<const ICFGNode*>& getICFGNodeList() const
+    {
+        return allICFGNodes;
+    }
+
+    inline const_iterator begin() const
+    {
+        return allICFGNodes.begin();
+    }
+
+    inline const_iterator end() const
+    {
+        return allICFGNodes.end();
+    }
+
+    inline void addSuccBasicBlock(const SVFBasicBlock* succ2)
+    {
+        // check if the edge already exists
+        for (auto edge: this->getOutEdges())
+        {
+            if (edge->getDstNode() == succ2)
+                return;
+        }
+
+        SVFBasicBlock* succ = const_cast<SVFBasicBlock*>(succ2);
+        BasicBlockEdge* edge = new BasicBlockEdge(this, succ);
+        this->addOutgoingEdge(edge);
+        succ->addIncomingEdge(edge);
+        this->succBBs.push_back(succ);
+        succ->predBBs.push_back(this);
+    }
+
+    inline void addPredBasicBlock(const SVFBasicBlock* pred2)
+    {
+        // check if the edge already exists
+        for (auto edge: this->getInEdges())
+        {
+            if (edge->getSrcNode() == pred2)
+                return;
+        }
+        SVFBasicBlock* pred = const_cast<SVFBasicBlock*>(pred2);
+        BasicBlockEdge* edge = new BasicBlockEdge(pred, this);
+        this->addIncomingEdge(edge);
+        pred->addOutgoingEdge(edge);
+        this->predBBs.push_back(pred);
+        pred->succBBs.push_back(this);
+    }
+
+    inline const SVFFunction* getParent() const
+    {
+        return fun;
+    }
+
+    inline const SVFFunction* getFunction() const
+    {
+        return fun;
+    }
+
+    inline const ICFGNode* front() const
+    {
+        assert(!allICFGNodes.empty() && "bb empty?");
+        return allICFGNodes.front();
+    }
+
+    inline const ICFGNode* back() const
+    {
+        assert(!allICFGNodes.empty() && "bb empty?");
+        return allICFGNodes.back();
+    }
+
+    inline std::vector<const SVFBasicBlock*> getSuccessors() const
+    {
+        std::vector<const SVFBasicBlock*> res;
+        for (auto edge : this->getOutEdges())
+        {
+            res.push_back(edge->getDstNode());
+        }
+        return res;
+    }
+
+    inline std::vector<const SVFBasicBlock*> getPredecessors() const
+    {
+        std::vector<const SVFBasicBlock*> res;
+        for (auto edge : this->getInEdges())
+        {
+            res.push_back(edge->getSrcNode());
+        }
+        return res;
+    }
+    u32_t getNumSuccessors() const
+    {
+        return this->getOutEdges().size();
+    }
+    u32_t getBBSuccessorPos(const SVFBasicBlock* Succ)
+    {
+        u32_t i = 0;
+        for (const SVFBasicBlock* SuccBB: succBBs)
+        {
+            if (SuccBB == Succ)
+                return i;
+            i++;
+        }
+        assert(false && "Didn't find successor edge?");
+        return 0;
+    }
+    u32_t getBBSuccessorPos(const SVFBasicBlock* Succ) const
+    {
+        u32_t i = 0;
+        for (const SVFBasicBlock* SuccBB: succBBs)
+        {
+            if (SuccBB == Succ)
+                return i;
+            i++;
+        }
+        assert(false && "Didn't find successor edge?");
+        return 0;
+
+    }
+    u32_t getBBPredecessorPos(const SVFBasicBlock* succbb)
+    {
+        u32_t pos = 0;
+        for (const SVFBasicBlock* PredBB : succbb->getPredecessors())
+        {
+            if(PredBB == this)
+                return pos;
+            ++pos;
+        }
+        assert(false && "Didn't find predecessor edge?");
+        return pos;
+    }
+    u32_t getBBPredecessorPos(const SVFBasicBlock* succbb) const
+    {
+        u32_t pos = 0;
+        for (const SVFBasicBlock* PredBB : succbb->getPredecessors())
+        {
+            if(PredBB == this)
+                return pos;
+            ++pos;
+        }
+        assert(false && "Didn't find predecessor edge?");
+        return pos;
+    }
+
+    const std::string toString() const;
+
+};
+
+
+
+typedef GenericGraph<SVFBasicBlock, BasicBlockEdge> GenericBasicBlockGraphTy;
+class BasicBlockGraph: public GenericBasicBlockGraphTy
+{
+private:
+    NodeID id{0};
+    const SVFFunction* fun;
+public:
+    /// Constructor
+    BasicBlockGraph(const SVFFunction* f): fun(f)
+    {
+
+    }
+
+    SVFBasicBlock* addBasicBlock(const std::string& bbname)
+    {
+        id++;
+        SVFBasicBlock* bb = new SVFBasicBlock(id, fun);
+        addGNode(id, bb);
+        bb->setName(bbname);
+        return bb;
+    }
+
+};
+}
+
+#endif

package/svf/include/Graphs/GenericGraph.h

@@ -141,96 +141,111 @@ public:
 
     enum GNodeK
     {
-        // ┌── ICFGNode: Classes of inter-procedural and intra-procedural control flow graph nodes
-        IntraBlock,       // ├──Represents a node within a single procedure
-        GlobalBlock,      // ├──Represents a global-level block
-        // │   └─ InterICFGNode: Classes of inter-procedural control flow graph nodes
-        FunEntryBlock,    // ├──Entry point of a function
-        FunExitBlock,     // ├──Exit point of a function
-        FunCallBlock,     // ├──Call site in the function
-        FunRetBlock,      // ├──Return site in the function
-        // └────────
-
-        // ┌── SVFVar: Classes of top-level variables (ValVar) and address-taken variables (ObjVar)
-        // │   └── ValVar: Classes of top-level variable nodes
-        ValNode,                 // ├──Represents a standard value variable
-        ArgNode,                 // ├──Represents an argument value variable
-        FunValNode,              // ├──Represents a Function value variable
-        GepValNode,              // ├──Represents a GEP value variable
-        RetNode,                 // ├──Represents a return value node
-        VarargNode,              // ├──Represents a variadic argument node
-        GlobalValNode,           // ├──Represents a global variable node
-        ConstantAggValNode,      // ├──Represents a constant aggregate value node
-        ConstantDataValNode,     // ├──Represents a constant data variable
-        BlackHoleNode,           // ├──Represents a black hole node
-        ConstantFPValNode,       // ├──Represents a constant float-point value node
-        ConstantIntValNode,      // ├── Represents a constant integer value node
-        ConstantNullptrValNode,  // ├── Represents a constant nullptr value node
-        DummyValNode,            // ├──Represents a dummy node for uninitialized values
-        // │   └── ObjVar: Classes of object variable nodes
-        ObjNode,                 // ├──Represents an object variable
-        GepObjNode,              // ├──Represents a GEP object variable
-        // │        └── BaseObjVar: Classes of base object nodes
-        BaseObjNode,             // ├──Represents a base object node
-        FunObjNode,              // ├──Types of function object
-        HeapObjNode,             // ├──Types of heap object
-        StackObjNode,            // ├──Types of stack object
-        GlobalObjNode,           // ├──Types of global object
-        ConstantAggObjNode,      // ├──Types of constant aggregate object
-        ConstantDataObjNode,     // ├──Types of constant data object
-        ConstantFPObjNode,       // ├──Types of constant float-point object
-        ConstantIntObjNode,      // ├──Types of constant integer object
-        ConstantNullptrObjNode,  // ├──Types of constant nullptr object
-        DummyObjNode,            // ├──Dummy node for uninitialized objects
-        // └────────
-
-        // ┌── VFGNode: Classes of Value Flow Graph (VFG) node kinds with operations
-        Cmp,              // ├──Represents a comparison operation
-        BinaryOp,         // ├──Represents a binary operation
-        UnaryOp,          // ├──Represents a unary operation
-        Branch,           // ├──Represents a branch operation
-        DummyVProp,       // ├──Dummy node for value propagation
-        NPtr,             // ├──Represents a null pointer operation
-        // │   └── ArgumentVFGNode: Classes of argument nodes in VFG
-        FRet,             // ├──Represents a function return value
-        ARet,             // ├──Represents an argument return value
-        AParm,            // ├──Represents an argument parameter
-        FParm,            // ├──Represents a function parameter
-        // │   └── StmtVFGNode: Classes of statement nodes in VFG
-        Addr,             // ├──Represents an address operation
-        Copy,             // ├──Represents a copy operation
-        Gep,              // ├──Represents a GEP operation
-        Store,            // ├──Represents a store operation
-        Load,             // ├──Represents a load operation
-        // │   └── PHIVFGNode: Classes of PHI nodes in VFG
-        TPhi,             // ├──Represents a type-based PHI node
-        TIntraPhi,        // ├──Represents an intra-procedural PHI node
-        TInterPhi,        // ├──Represents an inter-procedural PHI node
-        // │   └── MRSVFGNode: Classes of Memory-related SVFG nodes
-        FPIN,             // ├──Function parameter input
-        FPOUT,            // ├──Function parameter output
-        APIN,             // ├──Argument parameter input
-        APOUT,            // ├──Argument parameter output
-        // │        └── MSSAPHISVFGNode: Classes of Mem SSA PHI nodes for SVFG
-        MPhi,             // ├──Memory PHI node
-        MIntraPhi,        // ├──Intra-procedural memory PHI node
-        MInterPhi,        // ├──Inter-procedural memory PHI node
-        // └────────
-
-        // Additional specific graph node types
-        CallNodeKd,    // Callgraph node
-        CDNodeKd,      // Control dependence graph node
-        CFLNodeKd,     // CFL graph node
-        CHNodeKd,      // Class hierarchy graph node
+        // ┌─────────────────────────────────────────────────────────────────────────┐
+        // │ ICFGNode: Classes of inter-procedural and intra-procedural control flow │
+        // │ graph nodes (Parent class: ICFGNode)                                   │
+        // └─────────────────────────────────────────────────────────────────────────┘
+        IntraBlock,       // ├── Represents a node within a single procedure
+        GlobalBlock,      // ├── Represents a global-level block
+        // │   └─ Subclass: InterICFGNode
+        FunEntryBlock,    // │   ├── Entry point of a function
+        FunExitBlock,     // │   ├── Exit point of a function
+        FunCallBlock,     // │   ├── Call site in the function
+        FunRetBlock,      // │   └── Return site in the function
+
+        // ┌─────────────────────────────────────────────────────────────────────────┐
+        // │ SVFVar: Classes of variable nodes (Parent class: SVFVar)               │
+        // │   Includes two main subclasses: ValVar and ObjVar                      │
+        // └─────────────────────────────────────────────────────────────────────────┘
+        // └─ Subclass: ValVar (Top-level variable nodes)
+        ValNode,                 // ├── Represents a standard value variable
+        ArgValNode,              // ├── Represents an argument value variable
+        FunValNode,              // ├── Represents a function value variable
+        GepValNode,              // ├── Represents a GEP value variable
+        RetValNode,              // ├── Represents a return value node
+        VarargValNode,           // ├── Represents a variadic argument node
+        GlobalValNode,           // ├── Represents a global variable node
+        ConstAggValNode,         // ├── Represents a constant aggregate value node
+        // │   └─ Subclass: ConstDataValVar
+        ConstDataValNode,        // │   ├── Represents a constant data variable
+        BlackHoleValNode,        // │   ├── Represents a black hole node
+        ConstFPValNode,          // │   ├── Represents a constant floating-point value node
+        ConstIntValNode,         // │   ├── Represents a constant integer value node
+        ConstNullptrValNode,     // │   └── Represents a constant nullptr value node
+        // │   └─ Subclass: DummyValVar
+        DummyValNode,            // │   └── Dummy node for uninitialized values
+
+        // └─ Subclass: ObjVar (Object variable nodes)
+        ObjNode,                 // ├── Represents an object variable
+        // │   └─ Subclass: GepObjVar
+        GepObjNode,              // │   ├── Represents a GEP object variable
+        // │   └─ Subclass: BaseObjVar
+        BaseObjNode,             // │   ├── Represents a base object node
+        FunObjNode,              // │   ├── Represents a function object
+        HeapObjNode,             // │   ├── Represents a heap object
+        StackObjNode,            // │   ├── Represents a stack object
+        GlobalObjNode,           // │   ├── Represents a global object
+        ConstAggObjNode,         // │   ├── Represents a constant aggregate object
+        // │   └─ Subclass: ConstDataObjVar
+        ConstDataObjNode,        // │   ├── Represents a constant data object
+        ConstFPObjNode,          // │   ├── Represents a constant floating-point object
+        ConstIntObjNode,         // │   ├── Represents a constant integer object
+        ConstNullptrObjNode,     // │   └── Represents a constant nullptr object
+        // │   └─ Subclass: DummyObjVar
+        DummyObjNode,            // │   └── Dummy node for uninitialized objects
+
+        // ┌─────────────────────────────────────────────────────────────────────────┐
+        // │ VFGNode: Classes of Value Flow Graph (VFG) node kinds (Parent class:   │
+        // │ VFGNode)                                                               │
+        // │   Includes operation nodes and specialized subclasses                  │
+        // └─────────────────────────────────────────────────────────────────────────┘
+        Cmp,              // ├── Represents a comparison operation
+        BinaryOp,         // ├── Represents a binary operation
+        UnaryOp,          // ├── Represents a unary operation
+        Branch,           // ├── Represents a branch operation
+        DummyVProp,       // ├── Dummy node for value propagation
+        NPtr,             // ├── Represents a null pointer operation
+        // │   └─ Subclass: ArgumentVFGNode
+        FRet,             // │   ├── Represents a function return value
+        ARet,             // │   ├── Represents an argument return value
+        AParm,            // │   ├── Represents an argument parameter
+        FParm,            // │   └── Represents a function parameter
+        // │   └─ Subclass: StmtVFGNode
+        Addr,             // │   ├── Represents an address operation
+        Copy,             // │   ├── Represents a copy operation
+        Gep,              // │   ├── Represents a GEP operation
+        Store,            // │   ├── Represents a store operation
+        Load,             // │   └── Represents a load operation
+        // │   └─ Subclass: PHIVFGNode
+        TPhi,             // │   ├── Represents a type-based PHI node
+        TIntraPhi,        // │   ├── Represents an intra-procedural PHI node
+        TInterPhi,        // │   └── Represents an inter-procedural PHI node
+        // │   └─ Subclass: MRSVFGNode
+        FPIN,             // │   ├── Function parameter input
+        FPOUT,            // │   ├── Function parameter output
+        APIN,             // │   ├── Argument parameter input
+        APOUT,            // │   └── Argument parameter output
+        // │       └─ Subclass: MSSAPHISVFGNode
+        MPhi,             // │       ├── Memory PHI node
+        MIntraPhi,        // │       ├── Intra-procedural memory PHI node
+        MInterPhi,        // │       └── Inter-procedural memory PHI node
+
+        // ┌─────────────────────────────────────────────────────────────────────────┐
+        // │ 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
+        TCTNodeKd,        // Thread creation tree node
+        DCHNodeKd,        // DCHG node
+        BasicBlockKd,     // Basic block node
+        OtherKd           // Other node kind
     };
 
 
-
-    SVFBaseNode(NodeID i, GNodeK k, SVFType* ty = nullptr): id(i),nodeKind(k), type(ty)
+    SVFBaseNode(NodeID i, GNodeK k, const SVFType* ty = nullptr): id(i),nodeKind(k), type(ty)
     {
 
     }
@@ -326,10 +341,10 @@ protected:
 
     static inline bool isConstantDataValVar(GNodeK n)
     {
-        static_assert(ConstantNullptrValNode - ConstantDataValNode == 4,
+        static_assert(ConstNullptrValNode - ConstDataValNode == 4,
                       "The number of ConstantDataValVarKinds has changed, make "
                       "sure the range is correct");
-        return n <= ConstantNullptrValNode && n >= ConstantDataValNode;
+        return n <= ConstNullptrValNode && n >= ConstDataValNode;
     }
 
     static inline bool isObjVarKinds(GNodeK n)
@@ -350,10 +365,10 @@ protected:
 
     static inline bool isConstantDataObjVarKinds(GNodeK n)
     {
-        static_assert(ConstantNullptrObjNode - ConstantDataObjNode == 3,
+        static_assert(ConstNullptrObjNode - ConstDataObjNode == 3,
                       "The number of ConstantDataObjVarKinds has changed, make "
                       "sure the range is correct");
-        return n <= ConstantNullptrObjNode && n >= ConstantDataObjNode;
+        return n <= ConstNullptrObjNode && n >= ConstDataObjNode;
     }
 
     static inline bool isVFGNodeKinds(GNodeK n)
@@ -433,7 +448,7 @@ private:
 
 public:
     /// Constructor
-    GenericNode(NodeID i, GNodeK k): SVFBaseNode(i, k)
+    GenericNode(NodeID i, GNodeK k, const SVFType* svfType = nullptr): SVFBaseNode(i, k, svfType)
     {
 
     }