svf-lib 1.0.2161 → 1.0.2163

package/SVF-linux/Release-build/include/DDA/DDAVFSolver.h

@@ -471,9 +471,11 @@ protected:
     virtual inline bool isLocalCVarInRecursion(const CVar& var) const
     {
         NodeID id = getPtrNodeID(var);
+        const BaseObjVar* baseObj = _pag->getBaseObject(id);
+        assert(baseObj && "base object is null??");
         const MemObj* obj = _pag->getObject(id);
         assert(obj && "object not found!!");
-        if(obj->isStack())
+        if(SVFUtil::isa<StackObjVar>(baseObj))
         {
             if(const SVFFunction* svffun = _pag->getGNode(id)->getFunction())
             {
@@ -637,9 +639,8 @@ protected:
     //@{
     virtual inline bool isHeapCondMemObj(const CVar& var, const StoreSVFGNode*)
     {
-        const MemObj* mem = _pag->getObject(getPtrNodeID(var));
-        assert(mem && "memory object is null??");
-        return mem->isHeap();
+        const BaseObjVar* pVar = _pag->getBaseObject(getPtrNodeID(var));
+        return pVar && SVFUtil::isa<HeapObjVar, DummyObjVar>(pVar);
     }
 
     inline bool isArrayCondMemObj(const CVar& var) const

package/SVF-linux/Release-build/include/Graphs/GenericGraph.h

@@ -141,105 +141,66 @@ 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,
+        // ┌── 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
         // └────────
 
-        // ┌── SVFVarKinds: Combines ValVarKinds and ObjVarKinds for variable nodes
-        // │   ┌── ValVarKinds: Types of value variable nodes
-        // │   │   ├── Represents a standard value variable
-        ValNode,
-        // │   │   ├── Represents a Function value variable
-        FunValNode,
-        // │   │   ├── 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,
-        // │            ├──FunObjNode: Types of function object
-        FunObjNode,
-        // │       └── DummyObjNode: Dummy node for uninitialized objects
-        DummyObjNode,
+        // ┌── 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
+        FunValNode,       // ├──Represents a Function value variable
+        GepValNode,       // ├──Represents a GEP value variable
+        RetNode,          // ├──Represents a return value node
+        VarargNode,       // ├──Represents a variadic argument node
+        DummyValNode,     // ├──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
+        DummyObjNode,     // ├──Dummy node for uninitialized objects
         // └────────
 
-        // ┌── 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,
+        // ┌── 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
@@ -317,7 +278,7 @@ protected:
 
     static inline bool isSVFVarKind(GNodeK n)
     {
-        static_assert(DummyObjNode - ValNode == 10,
+        static_assert(DummyObjNode - ValNode == 12,
                       "The number of SVFVarKinds has changed, make sure the "
                       "range is correct");
 
@@ -334,18 +295,18 @@ protected:
 
     static inline bool isObjVarKinds(GNodeK n)
     {
-        static_assert(DummyObjNode - ObjNode == 4,
+        static_assert(DummyObjNode - ObjNode == 6,
                       "The number of ObjVarKinds has changed, make sure the "
                       "range is correct");
         return n <= DummyObjNode && n >= ObjNode;
     }
 
-    static inline bool isFIObjVarKinds(GNodeK n)
+    static inline bool isBaseObjVarKinds(GNodeK n)
     {
-        static_assert(FunObjNode - FIObjNode == 1,
-                      "The number of FIObjVarKinds has changed, make sure the "
+        static_assert(DummyObjNode - BaseObjNode == 4,
+                      "The number of BaseObjVarKinds has changed, make sure the "
                       "range is correct");
-        return n <= FunObjNode && n >= FIObjNode;
+        return n <= DummyObjNode && n >= BaseObjNode;
     }
 
     static inline bool isVFGNodeKinds(GNodeK n)

package/SVF-linux/Release-build/include/MemoryModel/PointerAnalysis.h

@@ -304,9 +304,7 @@ public:
     //@{
     inline bool isHeapMemObj(NodeID id) const
     {
-        const MemObj* mem = pag->getObject(id);
-        assert(mem && "memory object is null??");
-        return mem->isHeap();
+        return pag->getBaseObject(id) && SVFUtil::isa<HeapObjVar, DummyObjVar>(pag->getBaseObject(id));
     }
 
     inline bool isArrayMemObj(NodeID id) const
@@ -321,7 +319,7 @@ public:
     ///@{
     inline bool isFIObjNode(NodeID id) const
     {
-        return (SVFUtil::isa<FIObjVar>(pag->getGNode(id)));
+        return (SVFUtil::isa<BaseObjVar>(pag->getGNode(id)));
     }
     inline NodeID getBaseObjVar(NodeID id)
     {

package/SVF-linux/Release-build/include/SVF-LLVM/LLVMUtil.h

@@ -360,6 +360,9 @@ inline bool isHeapAllocExtCall(const Instruction *inst)
     return isHeapAllocExtCallViaRet(inst) || isHeapAllocExtCallViaArg(inst);
 }
 
+// Check if a given value represents a heap object.
+bool isHeapObj(const Value* val);
+
 /// Whether an instruction is a callsite in the application code, excluding llvm intrinsic calls
 bool isNonInstricCallSite(const Instruction* inst);
 

package/SVF-linux/Release-build/include/SVFIR/SVFFileSystem.h

@@ -166,7 +166,7 @@ class ValVar;
 class ObjVar;
 class GepValVar;
 class GepObjVar;
-class FIObjVar;
+class BaseObjVar;
 class RetPN;
 class VarArgPN;
 class DummyValVar;
@@ -456,7 +456,7 @@ private:
     cJSON* contentToJson(const ObjVar* var);
     cJSON* contentToJson(const GepValVar* var);
     cJSON* contentToJson(const GepObjVar* var);
-    cJSON* contentToJson(const FIObjVar* var);
+    cJSON* contentToJson(const BaseObjVar* var);
     cJSON* contentToJson(const RetPN* var);
     cJSON* contentToJson(const VarArgPN* var);
     cJSON* contentToJson(const DummyValVar* var);
@@ -1231,7 +1231,7 @@ private:
     void fill(const cJSON*& fieldJson, ObjVar* var);
     void fill(const cJSON*& fieldJson, GepValVar* var);
     void fill(const cJSON*& fieldJson, GepObjVar* var);
-    void fill(const cJSON*& fieldJson, FIObjVar* var);
+    void fill(const cJSON*& fieldJson, BaseObjVar* var);
     void fill(const cJSON*& fieldJson, RetPN* var);
     void fill(const cJSON*& fieldJson, VarArgPN* var);
     void fill(const cJSON*& fieldJson, DummyValVar* var);

package/SVF-linux/Release-build/include/SVFIR/SVFIR.h

@@ -401,6 +401,17 @@ public:
         else
             return nullptr;
     }
+
+    inline const BaseObjVar* getBaseObject(NodeID id) const
+    {
+        const SVFVar* node = getGNode(id);
+        if(const GepObjVar* gepObjVar = SVFUtil::dyn_cast<GepObjVar>(node))
+            return SVFUtil::dyn_cast<BaseObjVar>(
+                       getGNode(gepObjVar->getBaseNode()));
+        else
+            return SVFUtil::dyn_cast<BaseObjVar>(node);
+    }
+
     inline const MemObj*getObject(const ObjVar* node) const
     {
         return node->getMemObj();
@@ -565,6 +576,30 @@ private:
         return addFIObjNode(mem);
     }
 
+    /**
+     * Creates and adds a heap object node to the SVFIR
+     */
+    inline NodeID addHeapObjNode(const SVFValue* val, const SVFFunction* f, NodeID i)
+    {
+        const MemObj* mem = getMemObj(val);
+        assert(mem->getId() == i && "not same object id?");
+        memToFieldsMap[i].set(i);
+        HeapObjVar *node = new HeapObjVar(f, val->getType(), i, mem);
+        return addObjNode(val, node, i);
+    }
+
+    /**
+     * Creates and adds a stack object node to the SVFIR
+     */
+    inline NodeID addStackObjNode(const SVFValue* val, const SVFFunction* f, NodeID i)
+    {
+        const MemObj* mem = getMemObj(val);
+        assert(mem->getId() == i && "not same object id?");
+        memToFieldsMap[i].set(i);
+        StackObjVar *node = new  StackObjVar(f, val->getType(), i, mem);
+        return addObjNode(val, node, i);
+    }
+
     NodeID addFunObjNode(const CallGraphNode* callGraphNode, NodeID id);
     /// Add a unique return node for a procedure
     inline NodeID addRetNode(const CallGraphNode* callGraphNode, NodeID i)

package/SVF-linux/Release-build/include/SVFIR/SVFVariables.h

@@ -58,7 +58,7 @@ public:
     /// Vararg: unique node for vararg parameter
     /// GepValNode: temporary gep value node for field sensitivity
     /// GepValNode: temporary gep obj node for field sensitivity
-    /// FIObjNode: for field insensitive analysis
+    /// BaseObjNode: for field insensitive analysis
     /// DummyValNode and DummyObjNode: for non-llvm-value node
     typedef GNodeK PNODEK;
     typedef s64_t GEdgeKind;
@@ -68,6 +68,7 @@ protected:
     SVFStmt::KindToSVFStmtMapTy InEdgeKindToSetMap;
     SVFStmt::KindToSVFStmtMapTy OutEdgeKindToSetMap;
     bool isPtr;	/// whether it is a pointer (top-level or address-taken)
+    const SVFFunction* func; /// function containing this variable
 
     /// Constructor to create an empty object (for deserialization)
     SVFVar(NodeID i, PNODEK k) : GenericPAGNodeTy(i, k), value{} {}
@@ -117,16 +118,29 @@ public:
     // TODO: (Optimization) Should it return const reference instead of value?
     virtual const std::string getValueName() const = 0;
 
-    /// Return the function that this SVFVar resides in. Return nullptr if it is a global or constantexpr node
+    /// Return the function containing this SVFVar
+    /// @return The SVFFunction containing this variable, or nullptr if it's a global/constant expression
     virtual inline const SVFFunction* getFunction() const
     {
+        // Return cached function if available
+        if(func) return func;
+
+        // If we have an associated LLVM value, check its parent function
         if (value)
         {
+            // For instructions, return the function containing the parent basic block
             if (auto inst = SVFUtil::dyn_cast<SVFInstruction>(value))
+            {
                 return inst->getParent()->getParent();
+            }
+            // For function arguments, return their parent function
             else if (auto arg = SVFUtil::dyn_cast<SVFArgument>(value))
+            {
                 return arg->getParent();
+            }
         }
+
+        // Return nullptr for globals/constants with no parent function
         return nullptr;
     }
 
@@ -532,43 +546,43 @@ public:
  * Field-insensitive Gep Obj variable, this is dynamic generated for field sensitive analysis
  * Each field-insensitive gep obj node represents all fields of a MemObj (base)
  */
-class FIObjVar: public ObjVar
+class BaseObjVar : public ObjVar
 {
     friend class SVFIRWriter;
     friend class SVFIRReader;
 
 protected:
     /// Constructor to create empty ObjVar (for SVFIRReader/deserialization)
-    FIObjVar(NodeID i, PNODEK ty = FIObjNode) : ObjVar(i, ty) {}
+    BaseObjVar(NodeID i, PNODEK ty = BaseObjNode) : ObjVar(i, ty) {}
 
 public:
     ///  Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const FIObjVar*)
+    static inline bool classof(const BaseObjVar*)
     {
         return true;
     }
     static inline bool classof(const ObjVar* node)
     {
-        return isFIObjVarKinds(node->getNodeKind());
+        return isBaseObjVarKinds(node->getNodeKind());
     }
     static inline bool classof(const SVFVar* node)
     {
-        return isFIObjVarKinds(node->getNodeKind());
+        return isBaseObjVarKinds(node->getNodeKind());
     }
     static inline bool classof(const GenericPAGNodeTy* node)
     {
-        return isFIObjVarKinds(node->getNodeKind());
+        return isBaseObjVarKinds(node->getNodeKind());
     }
     static inline bool classof(const SVFBaseNode* node)
     {
-        return isFIObjVarKinds(node->getNodeKind());
+        return isBaseObjVarKinds(node->getNodeKind());
     }
     //@}
 
     /// Constructor
-    FIObjVar(const SVFValue* val, NodeID i, const MemObj* mem,
-             PNODEK ty = FIObjNode)
+    BaseObjVar(const SVFValue* val, NodeID i, const MemObj* mem,
+               PNODEK ty = BaseObjNode)
         : ObjVar(val, i, mem, ty)
     {
     }
@@ -584,6 +598,127 @@ public:
     virtual const std::string toString() const;
 };
 
+
+/**
+ * @brief Class representing a heap object variable in the SVFIR
+ *
+ * This class models heap-allocated objects in the program analysis. It extends BaseObjVar
+ * to specifically handle heap memory locations.
+ */
+class HeapObjVar: public BaseObjVar
+{
+
+    friend class SVFIRWriter;
+    friend class SVFIRReader;
+
+protected:
+    /// Constructor to create heap object var
+    HeapObjVar(NodeID i, PNODEK ty = HeapObjNode) : BaseObjVar(i, ty) {}
+
+public:
+    ///  Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const HeapObjVar*)
+    {
+        return true;
+    }
+    static inline bool classof(const BaseObjVar* node)
+    {
+        return node->getNodeKind() == HeapObjNode;
+    }
+    static inline bool classof(const ObjVar* node)
+    {
+        return node->getNodeKind() == HeapObjNode;
+    }
+    static inline bool classof(const SVFVar* node)
+    {
+        return node->getNodeKind() == HeapObjNode;
+    }
+    static inline bool classof(const GenericPAGNodeTy* node)
+    {
+        return node->getNodeKind() == HeapObjNode;
+    }
+    static inline bool classof(const SVFBaseNode* node)
+    {
+        return node->getNodeKind() == HeapObjNode;
+    }
+    //@}
+
+    /// Constructor
+    HeapObjVar(const SVFFunction* func, const SVFType* svfType, NodeID i,
+               const MemObj* mem, PNODEK ty = HeapObjNode);
+
+    /// Return name of a LLVM value
+    inline const std::string getValueName() const
+    {
+        return " (heap base object)";
+    }
+
+    virtual const std::string toString() const;
+};
+
+
+/**
+ * @brief Represents a stack-allocated object variable in the SVFIR (SVF Intermediate Representation)
+ * @inherits BaseObjVar
+ *
+ * This class models variables that are allocated on the stack in the program.
+ * It provides type checking functionality through LLVM-style RTTI (Runtime Type Information)
+ * methods like classof.
+ */
+class StackObjVar: public BaseObjVar
+{
+
+    friend class SVFIRWriter;
+    friend class SVFIRReader;
+
+protected:
+    /// Constructor to create stack object var
+    StackObjVar(NodeID i, PNODEK ty = StackObjNode) : BaseObjVar(i, ty) {}
+
+public:
+    ///  Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const StackObjVar*)
+    {
+        return true;
+    }
+    static inline bool classof(const BaseObjVar* node)
+    {
+        return node->getNodeKind() == StackObjNode;
+    }
+    static inline bool classof(const ObjVar* node)
+    {
+        return node->getNodeKind() == StackObjNode;
+    }
+    static inline bool classof(const SVFVar* node)
+    {
+        return node->getNodeKind() == StackObjNode;
+    }
+    static inline bool classof(const GenericPAGNodeTy* node)
+    {
+        return node->getNodeKind() == StackObjNode;
+    }
+    static inline bool classof(const SVFBaseNode* node)
+    {
+        return node->getNodeKind() == StackObjNode;
+    }
+    //@}
+
+    /// Constructor
+    StackObjVar(const SVFFunction* f, const SVFType* svfType, NodeID i,
+                const MemObj* mem, PNODEK ty = StackObjNode);
+
+    /// Return name of a LLVM value
+    inline const std::string getValueName() const
+    {
+        return " (stack base object)";
+    }
+
+    virtual const std::string toString() const;
+};
+
+
 class CallGraphNode;
 
 class FunValVar : public ValVar
@@ -625,16 +760,12 @@ public:
 
     /// Constructor
     FunValVar(const CallGraphNode* cgn, NodeID i, const ICFGNode* icn,
-              PNODEK ty = FunValNode)
-        : ValVar(nullptr, i, ty, icn), callGraphNode(cgn)
-    {
-
-    }
+              PNODEK ty = FunValNode);
 
     virtual const std::string toString() const;
 };
 
-class FunObjVar : public FIObjVar
+class FunObjVar : public BaseObjVar
 {
     friend class SVFIRWriter;
     friend class SVFIRReader;
@@ -644,7 +775,7 @@ private:
 
 private:
     /// Constructor to create empty ObjVar (for SVFIRReader/deserialization)
-    FunObjVar(NodeID i, PNODEK ty = FunObjNode) : FIObjVar(i, ty) {}
+    FunObjVar(NodeID i, PNODEK ty = FunObjNode) : BaseObjVar(i, ty) {}
 
 public:
     ///  Methods for support type inquiry through isa, cast, and dyn_cast:
@@ -653,7 +784,7 @@ public:
     {
         return true;
     }
-    static inline bool classof(const FIObjVar* node)
+    static inline bool classof(const BaseObjVar* node)
     {
         return node->getNodeKind() == FunObjNode;
     }
@@ -840,14 +971,14 @@ public:
 /*
  * Dummy object variable
  */
-class DummyObjVar: public ObjVar
+class DummyObjVar: public BaseObjVar
 {
     friend class SVFIRWriter;
     friend class SVFIRReader;
 
 private:
     /// Constructor to create empty DummyObjVar (for SVFIRReader/deserialization)
-    DummyObjVar(NodeID i) : ObjVar(i, DummyObjNode) {}
+    DummyObjVar(NodeID i) : BaseObjVar(i, DummyObjNode) {}
 
 public:
     //@{ Methods for support type inquiry through isa, cast, and dyn_cast:
@@ -876,7 +1007,7 @@ public:
 
     /// Constructor
     DummyObjVar(NodeID i, const MemObj* m, PNODEK ty = DummyObjNode)
-        : ObjVar(nullptr, i, m, ty)
+        : BaseObjVar(nullptr, i, m, ty)
     {
     }
 

package/SVF-linux/Release-build/include/Util/SVFUtil.h

@@ -374,8 +374,6 @@ bool isHeapAllocExtCallViaRet(const CallICFGNode* cs);
 
 bool isHeapAllocExtCall(const ICFGNode* cs);
 
-
-
 //@}
 
 u32_t getHeapAllocHoldingArgPosition(const CallICFGNode* cs);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-lib",
-  "version": "1.0.2161",
+  "version": "1.0.2163",
   "description": "SVF's npm support",
   "main": "index.js",
   "scripts": {