svf-tools 1.0.1032 → 1.0.1033

package/package.json

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

@@ -141,96 +141,110 @@ 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
+        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 +340,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 +364,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 +447,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)
     {
 
     }

package/svf/include/SVFIR/SVFIR.h

@@ -473,7 +473,7 @@ public:
     //@}
     inline NodeID addDummyValNode()
     {
-        return addDummyValNode(NodeIDAllocator::get()->allocateValueId());
+        return addDummyValNode(NodeIDAllocator::get()->allocateValueId(), nullptr);
     }
     inline NodeID addDummyObjNode(const SVFType* type)
     {
@@ -544,165 +544,164 @@ private:
     /// add node into SVFIR
     //@{
     /// Add a value (pointer) node
-    inline NodeID addValNode(const SVFValue* val, NodeID i, const ICFGNode* icfgNode)
+    inline NodeID addValNode(NodeID i, const SVFType* type, const ICFGNode* icfgNode)
     {
-        SVFVar *node = new ValVar(val,i, ValVar::ValNode, icfgNode);
-        return addValNode(val, node);
+        SVFVar *node = new ValVar(i, type, icfgNode, ValVar::ValNode);
+        return addValNode(node);
     }
 
-    NodeID addFunValNode(NodeID i, const ICFGNode* icfgNode, const CallGraphNode* callGraphNode)
+    NodeID addFunValNode(NodeID i, const ICFGNode* icfgNode, const CallGraphNode* callGraphNode, const SVFType* type)
     {
-        FunValVar* node = new FunValVar(i, icfgNode, callGraphNode);
-        return addValNode(nullptr, node);
+        FunValVar* node = new FunValVar(i, icfgNode, callGraphNode, type);
+        return addValNode(node);
     }
 
-    NodeID addArgValNode(NodeID i, u32_t argNo, const ICFGNode* icfgNode, const CallGraphNode* callGraphNode, bool isUncalled = false)
+    NodeID addArgValNode(NodeID i, u32_t argNo, const ICFGNode* icfgNode, const CallGraphNode* callGraphNode, const SVFType* type, bool isUncalled = false)
     {
         ArgValVar* node =
-            new ArgValVar(i, argNo, icfgNode, callGraphNode, isUncalled);
-        return addValNode(nullptr, node);
+            new ArgValVar(i, argNo, icfgNode, callGraphNode, type, isUncalled);
+        return addValNode(node);
     }
 
-    inline NodeID addConstantFPValNode(const SVFValue* curInst, const NodeID i, double dval,
-                                       const ICFGNode* icfgNode)
+    inline NodeID addConstantFPValNode(const NodeID i, double dval,
+                                       const ICFGNode* icfgNode, const SVFType* type)
     {
-        SVFVar* node = new ConstantFPValVar(curInst,  i, dval, icfgNode);
+        SVFVar* node = new ConstFPValVar(i, dval, icfgNode, type);
         return addNode(node);
     }
 
-    inline NodeID addConstantIntValNode(const SVFValue* curInst, NodeID i, const std::pair<s64_t, u64_t>& intValue,
-                                        const ICFGNode* icfgNode)
+    inline NodeID addConstantIntValNode(NodeID i, const std::pair<s64_t, u64_t>& intValue,
+                                        const ICFGNode* icfgNode, const SVFType* type)
     {
-        SVFVar* node = new ConstantIntValVar(curInst, i, intValue.first, intValue.second, icfgNode);
+        SVFVar* node = new ConstIntValVar(i, intValue.first, intValue.second, icfgNode, type);
         return addNode(node);
     }
 
-    inline NodeID addConstantNullPtrValNode(const SVFValue* curInst, const NodeID i, const ICFGNode* icfgNode)
+    inline NodeID addConstantNullPtrValNode(const NodeID i, const ICFGNode* icfgNode, const SVFType* type)
     {
-        SVFVar* node = new ConstantNullPtrValVar(curInst, i, icfgNode);
+        SVFVar* node = new ConstNullPtrValVar(i, icfgNode, type);
         return addNode(node);
     }
 
-    inline NodeID addGlobalValueValNode(const SVFValue* curInst, const NodeID i, const ICFGNode* icfgNode)
+    inline NodeID addGlobalValNode(const NodeID i, const ICFGNode* icfgNode, const SVFType* svfType)
     {
-        SVFVar* node = new GlobalValVar(curInst, i, icfgNode);
+        SVFVar* node = new GlobalValVar(i, icfgNode, svfType);
         return addNode(node);
     }
 
-    inline NodeID addConstantAggValNode(const SVFValue* curInst, const NodeID i, const ICFGNode* icfgNode)
+    inline NodeID addConstantAggValNode(const NodeID i, const ICFGNode* icfgNode, const SVFType* svfType)
     {
-        SVFVar* node = new ConstantAggValVar(curInst, i, icfgNode);
+        SVFVar* node = new ConstAggValVar(i, icfgNode, svfType);
         return addNode(node);
     }
 
-    inline NodeID addConstantDataValNode(const SVFValue* curInst, const NodeID i, const ICFGNode* icfgNode)
+    inline NodeID addConstantDataValNode(const NodeID i, const ICFGNode* icfgNode, const SVFType* type)
     {
-        SVFVar* node = new ConstantDataValVar(curInst, i, icfgNode);
+        SVFVar* node = new ConstDataValVar(i, icfgNode, type);
         return addNode(node);
     }
 
 
     /// Add a memory obj node
-    inline NodeID addObjNode(const SVFValue* val, NodeID i, ObjTypeInfo* ti)
+    inline NodeID addObjNode(NodeID i, ObjTypeInfo* ti, const SVFType* type, const ICFGNode* node)
     {
-        return addFIObjNode(val, i, ti);
+        return addFIObjNode( i, ti, type, node);
     }
 
     /**
      * Creates and adds a heap object node to the SVFIR
      */
-    inline NodeID addHeapObjNode(const SVFValue* val, NodeID i, ObjTypeInfo* ti, const SVFFunction* f)
+    inline NodeID addHeapObjNode(NodeID i, ObjTypeInfo* ti, const SVFType* type, const ICFGNode* node)
     {
         memToFieldsMap[i].set(i);
-        HeapObjVar *heapObj = new HeapObjVar(val, i, ti, f);
-        return addObjNode(val, heapObj);
+        HeapObjVar *heapObj = new HeapObjVar(i, ti, type, node);
+        return addObjNode(heapObj);
     }
 
     /**
      * Creates and adds a stack object node to the SVFIR
      */
-    inline NodeID addStackObjNode(const SVFValue* val, NodeID i, ObjTypeInfo* ti, const SVFFunction* f)
+    inline NodeID addStackObjNode(NodeID i, ObjTypeInfo* ti, const SVFType* type, const ICFGNode* node)
     {
         memToFieldsMap[i].set(i);
-        StackObjVar *stackObj = new StackObjVar(val, i, ti, f);
-        return addObjNode(val, stackObj);
+        StackObjVar *stackObj = new StackObjVar(i, ti, type, node);
+        return addObjNode(stackObj);
     }
 
-    NodeID addFunObjNode(const SVFValue* val, NodeID id,  ObjTypeInfo* ti, const CallGraphNode* callGraphNode)
+    NodeID addFunObjNode(NodeID id,  ObjTypeInfo* ti, const CallGraphNode* callGraphNode, const SVFType* type, const ICFGNode* node)
     {
         memToFieldsMap[id].set(id);
-        FunObjVar* funObj = new FunObjVar(val, id, ti, callGraphNode);
-        return addObjNode(val, funObj);
+        FunObjVar* funObj = new FunObjVar(id, ti, callGraphNode, type, node);
+        return addObjNode(funObj);
     }
 
 
-    inline NodeID addConstantFPObjNode(const SVFValue* curInst, NodeID i, ObjTypeInfo* ti, double dval)
+    inline NodeID addConstantFPObjNode(NodeID i, ObjTypeInfo* ti, double dval, const SVFType* type, const ICFGNode* node)
     {
         memToFieldsMap[i].set(i);
-        ConstantFPObjVar* conObj = new ConstantFPObjVar(curInst, i, dval, ti);
-        return addObjNode(curInst, conObj);
+        ConstFPObjVar* conObj = new ConstFPObjVar(i, dval, ti, type, node);
+        return addObjNode(conObj);
     }
 
 
-    inline NodeID addConstantIntObjNode(const SVFValue* curInst, NodeID i, ObjTypeInfo* ti, const std::pair<s64_t, u64_t>& intValue)
+    inline NodeID addConstantIntObjNode(NodeID i, ObjTypeInfo* ti, const std::pair<s64_t, u64_t>& intValue, const SVFType* type, const ICFGNode* node)
     {
         memToFieldsMap[i].set(i);
-        ConstantIntObjVar* conObj =
-            new ConstantIntObjVar(curInst, i, intValue.first, intValue.second, ti);
-        return addObjNode(curInst, conObj);
+        ConstIntObjVar* conObj =
+            new ConstIntObjVar(i, intValue.first, intValue.second, ti, type, node);
+        return addObjNode(conObj);
     }
 
 
-    inline NodeID addConstantNullPtrObjNode(const SVFValue* curInst, const NodeID i, ObjTypeInfo* ti)
+    inline NodeID addConstantNullPtrObjNode(const NodeID i, ObjTypeInfo* ti, const SVFType* type, const ICFGNode* node)
     {
         memToFieldsMap[i].set(i);
-        ConstantNullPtrObjVar* conObj = new ConstantNullPtrObjVar(curInst, i, ti);
-        return addObjNode(curInst, conObj);
+        ConstNullPtrObjVar* conObj = new ConstNullPtrObjVar(i, ti, type, node);
+        return addObjNode(conObj);
     }
 
-    inline NodeID addGlobalValueObjNode(const SVFValue* curInst, const NodeID i, ObjTypeInfo* ti)
+    inline NodeID addGlobalObjNode(const NodeID i, ObjTypeInfo* ti, const SVFType* type, const ICFGNode* node)
     {
         memToFieldsMap[i].set(i);
-        GlobalObjVar* gObj = new GlobalObjVar(curInst, i, ti);
-        return addObjNode(curInst, gObj);
+        GlobalObjVar* gObj = new GlobalObjVar(i, ti, type, node);
+        return addObjNode(gObj);
     }
-    inline NodeID addConstantAggObjNode(const SVFValue* curInst,
-                                        const NodeID i, ObjTypeInfo* ti)
+    inline NodeID addConstantAggObjNode(const NodeID i, ObjTypeInfo* ti, const SVFType* type, const ICFGNode* node)
     {
         memToFieldsMap[i].set(i);
-        ConstantAggObjVar* conObj = new ConstantAggObjVar(curInst, i, ti);
-        return addObjNode(curInst, conObj);
+        ConstAggObjVar* conObj = new ConstAggObjVar(i, ti, type, node);
+        return addObjNode(conObj);
     }
-    inline NodeID addConstantDataObjNode(const SVFValue* curInst, const NodeID i, ObjTypeInfo* ti)
+    inline NodeID addConstantDataObjNode(const NodeID i, ObjTypeInfo* ti, const SVFType* type, const ICFGNode* node)
     {
         memToFieldsMap[i].set(i);
-        ConstantDataObjVar* conObj = new ConstantDataObjVar(curInst, i, ti);
-        return addObjNode(curInst, conObj);
+        ConstDataObjVar* conObj = new ConstDataObjVar(i, ti, type, node);
+        return addObjNode(conObj);
     }
 
     /// Add a unique return node for a procedure
-    inline NodeID addRetNode(NodeID i, const CallGraphNode* callGraphNode)
+    inline NodeID addRetNode(NodeID i, const CallGraphNode* callGraphNode, const SVFType* type, const ICFGNode* icn)
     {
-        SVFVar *node = new RetPN(i, callGraphNode);
+        SVFVar *node = new RetValPN(i, callGraphNode, type, icn);
         return addRetNode(callGraphNode, node);
     }
     /// Add a unique vararg node for a procedure
-    inline NodeID addVarargNode(NodeID i, const CallGraphNode* val)
+    inline NodeID addVarargNode(NodeID i, const CallGraphNode* val, const SVFType* type, const ICFGNode* n)
     {
-        SVFVar *node = new VarArgPN(i, val);
+        SVFVar *node = new VarArgValPN(i, val, type, n);
         return addNode(node);
     }
 
     /// Add a temp field value node, this method can only invoked by getGepValVar
-    NodeID addGepValNode(const SVFValue* curInst,const SVFValue* val, const AccessPath& ap, NodeID i, const SVFType* type);
+    NodeID addGepValNode(const SVFValue* curInst,const SVFValue* val, const AccessPath& ap, NodeID i, const SVFType* type, const ICFGNode* node);
     /// Add a field obj node, this method can only invoked by getGepObjVar
     NodeID addGepObjNode(const BaseObjVar* baseObj, const APOffset& apOffset, const NodeID gepId);
     /// Add a field-insensitive node, this method can only invoked by getFIGepObjNode
-    NodeID addFIObjNode(const SVFValue* val, NodeID i, ObjTypeInfo* ti)
+    NodeID addFIObjNode(NodeID i, ObjTypeInfo* ti, const SVFType* type, const ICFGNode* node)
     {
         memToFieldsMap[i].set(i);
-        BaseObjVar* baseObj = new BaseObjVar(val, i, ti);
-        return addObjNode(val, baseObj);
+        BaseObjVar* baseObj = new BaseObjVar(i, ti, type, node);
+        return addObjNode(baseObj);
     }
 
 
@@ -710,9 +709,9 @@ private:
 
     ///  Add a dummy value/object node according to node ID (llvm value is null)
     //@{
-    inline NodeID addDummyValNode(NodeID i)
+    inline NodeID addDummyValNode(NodeID i, const ICFGNode* node)
     {
-        return addValNode(nullptr, new DummyValVar(i));
+        return addValNode(new DummyValVar(i, node));
     }
     inline NodeID addDummyObjNode(NodeID i, const SVFType* type)
     {
@@ -720,31 +719,30 @@ private:
         {
             ObjTypeInfo* ti = symInfo->createObjTypeInfo(type);
             symInfo->idToObjTypeInfoMap()[i] = ti;
-            return addObjNode(nullptr, new DummyObjVar(i, ti));
+            return addObjNode(new DummyObjVar(i, ti, nullptr, type));
         }
         else
         {
-            return addObjNode(nullptr, new DummyObjVar(i, symInfo->getObjTypeInfo(i)));
+            return addObjNode(new DummyObjVar(i, symInfo->getObjTypeInfo(i), nullptr, type));
         }
     }
 
     inline NodeID addBlackholeObjNode()
     {
-        return addObjNode(
-                   nullptr, new DummyObjVar(getBlackHoleNode(), symInfo->getObjTypeInfo(getBlackHoleNode())));
+        return addObjNode(new DummyObjVar(getBlackHoleNode(), symInfo->getObjTypeInfo(getBlackHoleNode()), nullptr));
     }
     inline NodeID addConstantObjNode()
     {
-        return addObjNode(nullptr, new DummyObjVar(getConstantNode(), symInfo->getObjTypeInfo(getConstantNode())));
+        return addObjNode(new DummyObjVar(getConstantNode(), symInfo->getObjTypeInfo(getConstantNode()), nullptr));
     }
     inline NodeID addBlackholePtrNode()
     {
-        return addDummyValNode(getBlkPtr());
+        return addDummyValNode(getBlkPtr(), nullptr);
     }
     //@}
 
     /// Add a value (pointer) node
-    inline NodeID addValNode(const SVFValue*, SVFVar *node)
+    inline NodeID addValNode(SVFVar *node)
     {
         assert(node && "node cannot be nullptr.");
         assert(hasGNode(node->getId()) == false &&
@@ -753,7 +751,7 @@ private:
         return addNode(node);
     }
     /// Add a memory obj node
-    inline NodeID addObjNode(const SVFValue*, SVFVar *node)
+    inline NodeID addObjNode(SVFVar *node)
     {
         assert(node && "node cannot be nullptr.");
         assert(hasGNode(node->getId()) == false &&