svf-lib 1.0.2191 → 1.0.2192

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

@@ -39,7 +39,8 @@ namespace SVF
 
 class SVFVar;
 /*
- * SVFIR program variables (PAGNodes)
+ * Program variables in SVFIR (based on PAG nodes)
+ * These represent variables in the program analysis graph
  */
 typedef GenericNode<SVFVar, SVFStmt> GenericPAGNodeTy;
 class SVFVar : public GenericPAGNodeTy
@@ -52,110 +53,71 @@ class SVFVar : public GenericPAGNodeTy
     friend class VFG;
 
 public:
-    /// Nine kinds of SVFIR variables
-    /// ValNode: llvm pointer value
-    /// ObjNode: memory object
-    /// RetNode: unique return node
-    /// Vararg: unique node for vararg parameter
-    /// GepValNode: temporary gep value node for field sensitivity
-    /// GepValNode: temporary gep obj node for field sensitivity
-    /// BaseObjNode: for field insensitive analysis
-    /// DummyValNode and DummyObjNode: for non-llvm-value node
+    /// Node kinds for SVFIR variables:
+    /// ValNode - LLVM pointer value
+    /// ObjNode - Memory object
+    /// RetValNode - Function return value
+    /// VarargNode - Variable argument parameter
+    /// GepValNode - Temporary value for field-sensitive analysis
+    /// GepObjNode - Temporary object for field-sensitive analysis
+    /// BaseObjNode - Base object for field-insensitive analysis
+    /// DummyValNode/DummyObjNode - Nodes for non-LLVM values
     typedef GNodeK PNODEK;
     typedef s64_t GEdgeKind;
 
 protected:
-    const SVFValue* value; ///< value of this SVFIR node
+    /// Maps tracking incoming and outgoing edges by kind
     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{} {}
+    /// Empty constructor for deserialization
+    SVFVar(NodeID i, PNODEK k) : GenericPAGNodeTy(i, k) {}
 
 
 public:
-    /// Constructor
-    SVFVar(const SVFValue* val, NodeID i, PNODEK k);
-    /// Destructor
-    virtual ~SVFVar() {}
-
-    ///  Get/has methods of the components
-    //@{
-    inline const SVFValue* getValue() const
-    {
-        assert(this->getNodeKind() != DummyValNode &&
-               this->getNodeKind() != DummyObjNode &&
-               "dummy node do not have value!");
-        assert(!SymbolTableInfo::isBlkObjOrConstantObj(this->getId()) &&
-               "blackhole and constant obj do not have value");
-        assert(value && "value is null (GepObjNode whose basenode is a DummyObj?)");
-        return value;
-    }
+    /// Standard constructor with ID, type and kind
+    SVFVar(NodeID i, const SVFType* svfType, PNODEK k);
 
-    /// Return type of the value
-    inline virtual const SVFType* getType() const
-    {
-        return value ? value->getType() : nullptr;
-    }
+    /// Virtual destructor
+    virtual ~SVFVar() {}
 
-    inline bool hasValue() const
-    {
-        return value != nullptr;
-    }
-    /// Whether it is a pointer
+    /// Check if this variable represents a pointer
     virtual inline bool isPointer() const
     {
-        return isPtr;
+        assert(type && "type is null?");
+        return type->isPointerTy();
     }
-    /// Whether it is constant data, i.e., "0", "1.001", "str"
-    /// or llvm's metadata, i.e., metadata !4087
+
+    /// Check if this variable represents constant data/metadata but not null pointer
     virtual bool isConstDataOrAggDataButNotNullPtr() const
     {
         return false;
     }
 
-    /// Whether this is an isolated node on the SVFIR graph
+    /// Check if this node is isolated (no edges) in the SVFIR graph
     virtual bool isIsolatedNode() const;
 
-    /// Get name of the LLVM value
-    // TODO: (Optimization) Should it return const reference instead of value?
+    /// Get string name of the represented LLVM value
     virtual const std::string getValueName() const = 0;
 
-    /// Return the function containing this SVFVar
-    /// @return The SVFFunction containing this variable, or nullptr if it's a global/constant expression
+    /// Get containing function, or null for globals/constants
     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();
-            }
-        }
-
-        // Return nullptr for globals/constants with no parent function
         return nullptr;
     }
 
-    /// Get incoming SVFIR statements (edges)
+    /// Edge accessors and checkers
+    //@{
     inline SVFStmt::SVFStmtSetTy& getIncomingEdges(SVFStmt::PEDGEK kind)
     {
         return InEdgeKindToSetMap[kind];
     }
-    /// Get outgoing SVFIR statements (edges)
+
     inline SVFStmt::SVFStmtSetTy& getOutgoingEdges(SVFStmt::PEDGEK kind)
     {
         return OutEdgeKindToSetMap[kind];
     }
-    /// Has incoming SVFIR statements (edges)
+
     inline bool hasIncomingEdges(SVFStmt::PEDGEK kind) const
     {
         SVFStmt::KindToSVFStmtMapTy::const_iterator it = InEdgeKindToSetMap.find(kind);
@@ -164,7 +126,7 @@ public:
         else
             return false;
     }
-    /// Has outgoing SVFIR statements (edges)
+
     inline bool hasOutgoingEdges(SVFStmt::PEDGEK kind) const
     {
         SVFStmt::KindToSVFStmtMapTy::const_iterator it = OutEdgeKindToSetMap.find(kind);
@@ -174,39 +136,37 @@ public:
             return false;
     }
 
-    /// Get incoming SVFStmt iterator
+    /// Edge iterators
     inline SVFStmt::SVFStmtSetTy::iterator getIncomingEdgesBegin(SVFStmt::PEDGEK kind) const
     {
         SVFStmt::KindToSVFStmtMapTy::const_iterator it = InEdgeKindToSetMap.find(kind);
-        assert(it!=InEdgeKindToSetMap.end() && "The node does not have such kind of edge");
+        assert(it!=InEdgeKindToSetMap.end() && "Edge kind not found");
         return it->second.begin();
     }
 
-    /// Get incoming SVFStmt iterator
     inline SVFStmt::SVFStmtSetTy::iterator getIncomingEdgesEnd(SVFStmt::PEDGEK kind) const
     {
         SVFStmt::KindToSVFStmtMapTy::const_iterator it = InEdgeKindToSetMap.find(kind);
-        assert(it!=InEdgeKindToSetMap.end() && "The node does not have such kind of edge");
+        assert(it!=InEdgeKindToSetMap.end() && "Edge kind not found");
         return it->second.end();
     }
 
-    /// Get outgoing SVFStmt iterator
     inline SVFStmt::SVFStmtSetTy::iterator getOutgoingEdgesBegin(SVFStmt::PEDGEK kind) const
     {
         SVFStmt::KindToSVFStmtMapTy::const_iterator it = OutEdgeKindToSetMap.find(kind);
-        assert(it!=OutEdgeKindToSetMap.end() && "The node does not have such kind of edge");
+        assert(it!=OutEdgeKindToSetMap.end() && "Edge kind not found");
         return it->second.begin();
     }
 
-    /// Get outgoing SVFStmt iterator
     inline SVFStmt::SVFStmtSetTy::iterator getOutgoingEdgesEnd(SVFStmt::PEDGEK kind) const
     {
         SVFStmt::KindToSVFStmtMapTy::const_iterator it = OutEdgeKindToSetMap.find(kind);
-        assert(it!=OutEdgeKindToSetMap.end() && "The node does not have such kind of edge");
+        assert(it!=OutEdgeKindToSetMap.end() && "Edge kind not found");
         return it->second.end();
     }
     //@}
 
+    /// Type checking support for LLVM-style RTTI
     static inline bool classof(const SVFVar *)
     {
         return true;
@@ -222,6 +182,7 @@ public:
         return isSVFVarKind(node->getNodeKind());
     }
 
+    /// Check if this pointer is in an uncalled function
     inline virtual bool ptrInUncalledFunction() const
     {
         if (const SVFFunction* fun = getFunction())
@@ -234,6 +195,7 @@ public:
         }
     }
 
+    /// Check if this variable represents constant/aggregate data
     virtual bool isConstDataOrAggData() const
     {
         return false;
@@ -241,7 +203,7 @@ public:
 
 
 private:
-    ///  add methods of the components
+    /// Edge management methods
     //@{
     inline void addInEdge(SVFStmt* inEdge)
     {
@@ -256,7 +218,8 @@ private:
         OutEdgeKindToSetMap[kind].insert(outEdge);
         addOutgoingEdge(outEdge);
     }
-    /// Has incoming VariantGepEdges
+
+    /// Check for incoming variable field GEP edges
     inline bool hasIncomingVariantGepEdge() const
     {
         SVFStmt::KindToSVFStmtMapTy::const_iterator it = InEdgeKindToSetMap.find(SVFStmt::Gep);
@@ -272,20 +235,18 @@ private:
     }
 
 public:
+    /// Get string representation
     virtual const std::string toString() const;
 
-    /// Dump to console for debugging
+    /// Debug dump to console
     void dump() const;
 
-    //@}
-    /// Overloading operator << for dumping SVFVar value
-    //@{
+    /// Stream operator overload for output
     friend OutStream& operator<< (OutStream &o, const SVFVar &node)
     {
         o << node.toString();
         return o;
     }
-    //@}
 };
 
 
@@ -326,16 +287,14 @@ public:
     //@}
 
     /// Constructor
-    ValVar(const SVFValue* val, NodeID i, PNODEK ty = ValNode, const ICFGNode* node = nullptr)
-        : SVFVar(val, i, ty), icfgNode(node)
+    ValVar(NodeID i, const SVFType* svfType, const ICFGNode* node, PNODEK ty = ValNode)
+        : SVFVar(i, svfType, ty), icfgNode(node)
     {
     }
     /// Return name of a LLVM value
     inline const std::string getValueName() const
     {
-        if (value)
-            return value->getName();
-        return "";
+        return getName();
     }
 
     const ICFGNode* getICFGNode() const
@@ -343,6 +302,8 @@ public:
         return icfgNode;
     }
 
+    virtual const SVFFunction* getFunction() const;
+
     virtual const std::string toString() const;
 };
 
@@ -358,8 +319,8 @@ protected:
     /// Constructor to create an empty ObjVar (for SVFIRReader/deserialization)
     ObjVar(NodeID i, PNODEK ty = ObjNode) : SVFVar(i, ty) {}
     /// Constructor
-    ObjVar(const SVFValue* val, NodeID i, PNODEK ty = ObjNode) :
-        SVFVar(val, i, ty)
+    ObjVar(NodeID i, const SVFType* svfType, PNODEK ty = ObjNode) :
+        SVFVar(i, svfType, ty)
     {
     }
 public:
@@ -386,14 +347,7 @@ public:
     /// Return name of a LLVM value
     virtual const std::string getValueName() const
     {
-        if (value)
-            return value->getName();
-        return "";
-    }
-    /// Return type of the value
-    inline virtual const SVFType* getType() const
-    {
-        return value->getType();
+        return getName();
     }
 
     virtual const std::string toString() const;
@@ -418,7 +372,7 @@ private:
 
 protected:
     /// Constructor to create function argument (for SVFIRReader/deserialization)
-    ArgValVar(NodeID i, PNODEK ty = ArgNode) : ValVar(i, ty) {}
+    ArgValVar(NodeID i, PNODEK ty = ArgValNode) : ValVar(i, ty) {}
 
 public:
     ///  Methods for support type inquiry through isa, cast, and dyn_cast:
@@ -429,32 +383,30 @@ public:
     }
     static inline bool classof(const ValVar* node)
     {
-        return node->getNodeKind() == ArgNode;
+        return node->getNodeKind() == ArgValNode;
     }
     static inline bool classof(const SVFVar* node)
     {
-        return node->getNodeKind() == ArgNode;
+        return node->getNodeKind() == ArgValNode;
     }
     static inline bool classof(const GenericPAGNodeTy* node)
     {
-        return node->getNodeKind() == ArgNode;
+        return node->getNodeKind() == ArgValNode;
     }
     static inline bool classof(const SVFBaseNode* node)
     {
-        return node->getNodeKind() == ArgNode;
+        return node->getNodeKind() == ArgValNode;
     }
     //@}
 
     /// Constructor
     ArgValVar(NodeID i, u32_t argNo, const ICFGNode* icn, const CallGraphNode* callGraphNode,
-              bool isUncalled = false, PNODEK ty = ArgNode);
+              const SVFType* svfType, bool isUncalled = false);
 
     /// Return name of a LLVM value
     inline const std::string getValueName() const
     {
-        if (value)
-            return value->getName() + " (argument valvar)";
-        return " (argument valvar)";
+        return getName() + " (argument valvar)";
     }
 
     virtual const SVFFunction* getFunction() const;
@@ -473,6 +425,8 @@ public:
         return uncalled;
     }
 
+    virtual bool isPointer() const;
+
     virtual const std::string toString() const;
 };
 
@@ -521,8 +475,8 @@ public:
     //@}
 
     /// Constructor
-    GepValVar(ValVar* baseNode, const SVFValue* val, NodeID i, const AccessPath& ap,
-              const SVFType* ty);
+    GepValVar(ValVar* baseNode, NodeID i, const AccessPath& ap,
+              const SVFType* ty, const ICFGNode* node);
 
     /// offset of the base value variable
     inline APOffset getConstantFieldIdx() const
@@ -539,10 +493,13 @@ public:
     /// Return name of a LLVM value
     inline const std::string getValueName() const
     {
-        if (value)
-            return value->getName() + "_" +
-                   std::to_string(getConstantFieldIdx());
-        return "offset_" + std::to_string(getConstantFieldIdx());
+        return getName() + "_" +
+               std::to_string(getConstantFieldIdx());
+    }
+
+    virtual bool isPointer() const
+    {
+        return base->isPointer();
     }
 
     inline const SVFType* getType() const
@@ -550,6 +507,11 @@ public:
         return gepValType;
     }
 
+    virtual const SVFFunction* getFunction() const
+    {
+        return base->getFunction();
+    }
+
     virtual const std::string toString() const;
 
     virtual bool isConstDataOrAggDataButNotNullPtr() const
@@ -582,7 +544,7 @@ private:
 
 protected:
     /// Constructor to create empty ObjVar (for SVFIRReader/deserialization)
-    BaseObjVar(NodeID i, PNODEK ty = BaseObjNode) : ObjVar(i, ty) {}
+    BaseObjVar(NodeID i, const ICFGNode* node, PNODEK ty = BaseObjNode) : ObjVar(i, ty), icfgNode(node) {}
 
 public:
     ///  Methods for support type inquiry through isa, cast, and dyn_cast:
@@ -610,8 +572,9 @@ public:
     //@}
 
     /// Constructor
-    BaseObjVar(const SVFValue* val, NodeID i, ObjTypeInfo* ti, PNODEK ty = BaseObjNode)
-        :  ObjVar(val, i, ty), typeInfo(ti)
+    BaseObjVar(NodeID i, ObjTypeInfo* ti,
+               const SVFType* svfType, const ICFGNode* node, PNODEK ty = BaseObjNode)
+        : ObjVar(i, svfType, ty), typeInfo(ti), icfgNode(node)
     {
     }
 
@@ -629,9 +592,7 @@ public:
     /// Return name of a LLVM value
     inline const std::string getValueName() const
     {
-        if (value)
-            return value->getName() + " (base object)";
-        return " (base object)";
+        return getName() + " (base object)";
     }
 
     virtual const std::string toString() const;
@@ -768,6 +729,7 @@ public:
         typeInfo = nullptr;
     }
 
+    virtual const SVFFunction* getFunction() const;
 
 };
 
@@ -818,7 +780,7 @@ public:
     /// Constructor
     GepObjVar(const BaseObjVar* baseObj, NodeID i,
               const APOffset& apOffset, PNODEK ty = GepObjNode)
-        : ObjVar(baseObj->hasValue()? baseObj->getValue(): nullptr, i, ty), apOffset(apOffset), base(baseObj)
+        : ObjVar(i, baseObj->getType(), ty), apOffset(apOffset), base(baseObj)
     {
     }
 
@@ -842,15 +804,18 @@ public:
     /// Return the type of this gep object
     inline virtual const SVFType* getType() const
     {
-        return SymbolTableInfo::SymbolInfo()->getFlatternedElemType(value->getType(), apOffset);
+        return SymbolTableInfo::SymbolInfo()->getFlatternedElemType(type, apOffset);
     }
 
     /// Return name of a LLVM value
     inline const std::string getValueName() const
     {
-        if (value)
-            return value->getName() + "_" + std::to_string(apOffset);
-        return "offset_" + std::to_string(apOffset);
+        return getName() + "_" + std::to_string(apOffset);
+    }
+
+    virtual const SVFFunction* getFunction() const
+    {
+        return base->getFunction();
     }
 
     virtual const std::string toString() const;
@@ -869,6 +834,11 @@ public:
     {
         return base->isConstDataOrAggDataButNotNullPtr();
     }
+
+    virtual bool isPointer() const
+    {
+        return base->isPointer();
+    }
 };
 
 
@@ -887,7 +857,7 @@ class HeapObjVar: public BaseObjVar
 
 protected:
     /// Constructor to create heap object var
-    HeapObjVar(NodeID i, PNODEK ty = HeapObjNode) : BaseObjVar(i, ty) {}
+    HeapObjVar(NodeID i, const ICFGNode* node) : BaseObjVar(i, node, HeapObjNode) {}
 
 public:
     ///  Methods for support type inquiry through isa, cast, and dyn_cast:
@@ -919,12 +889,9 @@ public:
     //@}
 
     /// Constructor
-    HeapObjVar(const SVFValue* val, NodeID i, ObjTypeInfo* ti,
-               const SVFFunction* f, PNODEK ty = HeapObjNode):
-        BaseObjVar(val, i, ti, ty)
+    HeapObjVar(NodeID i, ObjTypeInfo* ti, const SVFType* svfType, const ICFGNode* node):
+        BaseObjVar(i, ti, svfType, node, HeapObjNode)
     {
-        isPtr = val->getType()->isPointerTy();
-        func = f;
     }
 
     /// Return name of a LLVM value
@@ -953,7 +920,7 @@ class StackObjVar: public BaseObjVar
 
 protected:
     /// Constructor to create stack object var
-    StackObjVar(NodeID i, PNODEK ty = StackObjNode) : BaseObjVar(i, ty) {}
+    StackObjVar(NodeID i, const ICFGNode* node) : BaseObjVar(i, node, StackObjNode) {}
 
 public:
     ///  Methods for support type inquiry through isa, cast, and dyn_cast:
@@ -985,12 +952,9 @@ public:
     //@}
 
     /// Constructor
-    StackObjVar(const SVFValue* val, NodeID i, ObjTypeInfo* ti,
-                const SVFFunction* fun, PNODEK ty = StackObjNode):
-        BaseObjVar(val, i, ti, ty)
+    StackObjVar(NodeID i, ObjTypeInfo* ti, const SVFType* svfType, const ICFGNode* node):
+        BaseObjVar(i, ti, svfType, node, StackObjNode)
     {
-        isPtr = val->getType()->isPointerTy();
-        func = fun;
     }
 
     /// Return name of a LLVM value
@@ -1043,8 +1007,13 @@ public:
     }
 
     /// Constructor
-    FunValVar(NodeID i, const ICFGNode* icn, const CallGraphNode* cgn,
-              PNODEK ty = FunValNode);
+    FunValVar(NodeID i, const ICFGNode* icn, const CallGraphNode* cgn, const SVFType* svfType);
+
+
+    virtual bool isPointer() const
+    {
+        return true;
+    }
 
     virtual const std::string toString() const;
 };
@@ -1059,7 +1028,7 @@ private:
 
 private:
     /// Constructor to create empty ObjVar (for SVFIRReader/deserialization)
-    FunObjVar(NodeID i, PNODEK ty = FunObjNode) : BaseObjVar(i, ty) {}
+    FunObjVar(NodeID i, const ICFGNode* node) : BaseObjVar(i,node, FunObjNode) {}
 
 public:
     ///  Methods for support type inquiry through isa, cast, and dyn_cast:
@@ -1091,8 +1060,7 @@ public:
     //@}
 
     /// Constructor
-    FunObjVar(const SVFValue* val, NodeID i, ObjTypeInfo* ti, const CallGraphNode* cgNode,
-              PNODEK ty = FunObjNode);
+    FunObjVar(NodeID i, ObjTypeInfo* ti, const CallGraphNode* cgNode, const SVFType* svfType, const ICFGNode* node);
 
     inline const CallGraphNode* getCallGraphNode() const
     {
@@ -1101,6 +1069,8 @@ public:
 
     virtual const SVFFunction* getFunction() const;
 
+    virtual bool isPointer() const;
+
     virtual bool isIsolatedNode() const;
 
     virtual const std::string toString() const;
@@ -1137,16 +1107,17 @@ public:
     //@}
 
     /// Constructor
-    GlobalValVar(const SVFValue* val, NodeID i, const ICFGNode* icn,
-                 PNODEK ty = GlobalValNode)
-        : ValVar(val, i, ty, icn)
+    GlobalValVar(NodeID i, const ICFGNode* icn, const SVFType* svfType)
+        : ValVar(i, svfType, icn, GlobalValNode)
     {
+        type = svfType;
     }
 
+
     virtual const std::string toString() const;
 };
 
-class ConstantAggValVar: public ValVar
+class ConstAggValVar: public ValVar
 {
     friend class SVFIRWriter;
     friend class SVFIRReader;
@@ -1154,36 +1125,36 @@ class ConstantAggValVar: public ValVar
 public:
     ///  Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const ConstantAggValVar*)
+    static inline bool classof(const ConstAggValVar*)
     {
         return true;
     }
     static inline bool classof(const ValVar* node)
     {
-        return node->getNodeKind() == ConstantAggValNode;
+        return node->getNodeKind() == ConstAggValNode;
     }
     static inline bool classof(const SVFVar* node)
     {
-        return node->getNodeKind() == ConstantAggValNode;
+        return node->getNodeKind() == ConstAggValNode;
     }
     static inline bool classof(const GenericPAGNodeTy* node)
     {
-        return node->getNodeKind() == ConstantAggValNode;
+        return node->getNodeKind() == ConstAggValNode;
     }
     static inline bool classof(const SVFBaseNode* node)
     {
-        return node->getNodeKind() == ConstantAggValNode;
+        return node->getNodeKind() == ConstAggValNode;
     }
     //@}
 
     /// Constructor
-    ConstantAggValVar(const SVFValue* val, NodeID i, const ICFGNode* icn,
-                      PNODEK ty = ConstantAggValNode)
-        : ValVar(val, i,  ty,  icn)
+    ConstAggValVar(NodeID i, const ICFGNode* icn, const SVFType* svfTy)
+        : ValVar(i, svfTy, icn, ConstAggValNode)
     {
-
+        type = svfTy;
     }
 
+
     virtual bool isConstDataOrAggData() const
     {
         return true;
@@ -1198,7 +1169,7 @@ public:
 };
 
 
-class ConstantDataValVar: public ValVar
+class ConstDataValVar : public ValVar
 {
     friend class SVFIRWriter;
     friend class SVFIRReader;
@@ -1206,7 +1177,7 @@ class ConstantDataValVar: public ValVar
 public:
     ///  Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const ConstantDataValVar*)
+    static inline bool classof(const ConstDataValVar*)
     {
         return true;
     }
@@ -1229,9 +1200,9 @@ public:
     //@}
 
     /// Constructor
-    ConstantDataValVar(const SVFValue* val, NodeID i, const ICFGNode* icn,
-                       PNODEK ty = ConstantDataValNode)
-        : ValVar(val, i,  ty,  icn)
+    ConstDataValVar(NodeID i, const ICFGNode* icn, const SVFType* svfType,
+                    PNODEK ty = ConstDataValNode)
+        : ValVar(i, svfType, icn, ty)
     {
 
     }
@@ -1249,7 +1220,7 @@ public:
     virtual const std::string toString() const;
 };
 
-class BlackHoleVar: public ConstantDataValVar
+class BlackHoleValVar : public ConstDataValVar
 {
     friend class SVFIRWriter;
     friend class SVFIRReader;
@@ -1257,35 +1228,35 @@ class BlackHoleVar: public ConstantDataValVar
 public:
     ///  Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const BlackHoleVar*)
+    static inline bool classof(const BlackHoleValVar*)
     {
         return true;
     }
-    static inline bool classof(const ConstantDataValVar* node)
+    static inline bool classof(const ConstDataValVar* node)
     {
-        return node->getNodeKind() == BlackHoleNode;
+        return node->getNodeKind() == BlackHoleValNode;
     }
     static inline bool classof(const ValVar* node)
     {
-        return node->getNodeKind() == BlackHoleNode;
+        return node->getNodeKind() == BlackHoleValNode;
     }
     static inline bool classof(const SVFVar* node)
     {
-        return node->getNodeKind() == BlackHoleNode;
+        return node->getNodeKind() == BlackHoleValNode;
     }
     static inline bool classof(const GenericPAGNodeTy* node)
     {
-        return node->getNodeKind() == BlackHoleNode;
+        return node->getNodeKind() == BlackHoleValNode;
     }
     static inline bool classof(const SVFBaseNode* node)
     {
-        return node->getNodeKind() == BlackHoleNode;
+        return node->getNodeKind() == BlackHoleValNode;
     }
     //@}
 
     /// Constructor
-    BlackHoleVar(NodeID i, PNODEK ty = BlackHoleNode)
-        : ConstantDataValVar(nullptr, i,  nullptr, ty)
+    BlackHoleValVar(NodeID i, const SVFType* svfType, PNODEK ty = BlackHoleValNode)
+        : ConstDataValVar(i,  nullptr, svfType, ty)
     {
 
     }
@@ -1297,11 +1268,11 @@ public:
 
     virtual const std::string toString() const
     {
-        return "BlackHoleVar";
+        return "BlackHoleValVar";
     }
 };
 
-class ConstantFPValVar: public ConstantDataValVar
+class ConstFPValVar : public ConstDataValVar
 {
     friend class SVFIRWriter;
     friend class SVFIRReader;
@@ -1311,29 +1282,29 @@ private:
 public:
     ///  Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const ConstantFPValVar*)
+    static inline bool classof(const ConstFPValVar*)
     {
         return true;
     }
-    static inline bool classof(const ConstantDataValVar* node)
+    static inline bool classof(const ConstDataValVar* node)
     {
-        return node->getNodeKind() == ConstantFPValNode;
+        return node->getNodeKind() == ConstFPValNode;
     }
     static inline bool classof(const ValVar* node)
     {
-        return node->getNodeKind() == ConstantFPValNode;
+        return node->getNodeKind() == ConstFPValNode;
     }
     static inline bool classof(const SVFVar* node)
     {
-        return node->getNodeKind() == ConstantFPValNode;
+        return node->getNodeKind() == ConstFPValNode;
     }
     static inline bool classof(const GenericPAGNodeTy* node)
     {
-        return node->getNodeKind() == ConstantFPValNode;
+        return node->getNodeKind() == ConstFPValNode;
     }
     static inline bool classof(const SVFBaseNode* node)
     {
-        return node->getNodeKind() == ConstantFPValNode;
+        return node->getNodeKind() == ConstFPValNode;
     }
     //@}
 
@@ -1343,17 +1314,16 @@ public:
     }
 
     /// Constructor
-    ConstantFPValVar(const SVFValue* val, NodeID i, double dv, const ICFGNode* icn,
-                     PNODEK ty = ConstantFPValNode)
-        : ConstantDataValVar(val, i,  icn, ty), dval(dv)
+    ConstFPValVar(NodeID i, double dv,
+                  const ICFGNode* icn, const SVFType* svfType)
+        : ConstDataValVar(i, icn, svfType, ConstFPValNode), dval(dv)
     {
-
     }
 
     virtual const std::string toString() const;
 };
 
-class ConstantIntValVar: public ConstantDataValVar
+class ConstIntValVar : public ConstDataValVar
 {
     friend class SVFIRWriter;
     friend class SVFIRReader;
@@ -1364,29 +1334,29 @@ private:
 public:
     ///  Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const ConstantIntValVar*)
+    static inline bool classof(const ConstIntValVar*)
     {
         return true;
     }
-    static inline bool classof(const ConstantDataValVar* node)
+    static inline bool classof(const ConstDataValVar* node)
     {
-        return node->getNodeKind() == ConstantIntValNode;
+        return node->getNodeKind() == ConstIntValNode;
     }
     static inline bool classof(const ValVar* node)
     {
-        return node->getNodeKind() == ConstantIntValNode;
+        return node->getNodeKind() == ConstIntValNode;
     }
     static inline bool classof(const SVFVar* node)
     {
-        return node->getNodeKind() == ConstantIntValNode;
+        return node->getNodeKind() == ConstIntValNode;
     }
     static inline bool classof(const GenericPAGNodeTy* node)
     {
-        return node->getNodeKind() == ConstantIntValNode;
+        return node->getNodeKind() == ConstIntValNode;
     }
     static inline bool classof(const SVFBaseNode* node)
     {
-        return node->getNodeKind() == ConstantIntValNode;
+        return node->getNodeKind() == ConstIntValNode;
     }
     //@}
 
@@ -1402,16 +1372,15 @@ public:
     }
 
     /// Constructor
-    ConstantIntValVar(const SVFValue* val, NodeID i, s64_t sv, u64_t zv, const ICFGNode* icn,
-                      PNODEK ty = ConstantIntValNode)
-        : ConstantDataValVar(val, i,  icn, ty), zval(zv), sval(sv)
+    ConstIntValVar(NodeID i, s64_t sv, u64_t zv, const ICFGNode* icn, const SVFType* svfType)
+        : ConstDataValVar(i,  icn, svfType, ConstIntValNode), zval(zv), sval(sv)
     {
 
     }
     virtual const std::string toString() const;
 };
 
-class ConstantNullPtrValVar: public ConstantDataValVar
+class ConstNullPtrValVar : public ConstDataValVar
 {
     friend class SVFIRWriter;
     friend class SVFIRReader;
@@ -1419,36 +1388,35 @@ class ConstantNullPtrValVar: public ConstantDataValVar
 public:
     ///  Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const ConstantNullPtrValVar*)
+    static inline bool classof(const ConstNullPtrValVar*)
     {
         return true;
     }
-    static inline bool classof(const ConstantDataValVar* node)
+    static inline bool classof(const ConstDataValVar* node)
     {
-        return node->getNodeKind() == ConstantNullptrValNode;
+        return node->getNodeKind() == ConstNullptrValNode;
     }
     static inline bool classof(const ValVar* node)
     {
-        return node->getNodeKind() == ConstantNullptrValNode;
+        return node->getNodeKind() == ConstNullptrValNode;
     }
     static inline bool classof(const SVFVar* node)
     {
-        return node->getNodeKind() == ConstantNullptrValNode;
+        return node->getNodeKind() == ConstNullptrValNode;
     }
     static inline bool classof(const GenericPAGNodeTy* node)
     {
-        return node->getNodeKind() == ConstantNullptrValNode;
+        return node->getNodeKind() == ConstNullptrValNode;
     }
     static inline bool classof(const SVFBaseNode* node)
     {
-        return node->getNodeKind() == ConstantNullptrValNode;
+        return node->getNodeKind() == ConstNullptrValNode;
     }
     //@}
 
     /// Constructor
-    ConstantNullPtrValVar(const SVFValue* val, NodeID i, const ICFGNode* icn,
-                          PNODEK ty = ConstantNullptrValNode)
-        : ConstantDataValVar(val, i,  icn, ty)
+    ConstNullPtrValVar(NodeID i, const ICFGNode* icn, const SVFType* svfType)
+        : ConstDataValVar(i,  icn, svfType, ConstNullptrValNode)
     {
 
     }
@@ -1468,7 +1436,7 @@ class GlobalObjVar : public BaseObjVar
 
 private:
     /// Constructor to create empty ObjVar (for SVFIRReader/deserialization)
-    GlobalObjVar(NodeID i, PNODEK ty = GlobalObjNode) : BaseObjVar(i, ty) {}
+    GlobalObjVar(NodeID i, const ICFGNode* node) : BaseObjVar(i, node, GlobalObjNode) {}
 
 public:
     ///  Methods for support type inquiry through isa, cast, and dyn_cast:
@@ -1500,8 +1468,8 @@ public:
     //@}
 
     /// Constructor
-    GlobalObjVar(const SVFValue* val, NodeID i, ObjTypeInfo* ti,
-                 PNODEK ty = GlobalObjNode): BaseObjVar(val, i, ti, ty)
+    GlobalObjVar(NodeID i, ObjTypeInfo* ti, const SVFType* svfType, const ICFGNode* node,
+                 PNODEK ty = GlobalObjNode): BaseObjVar(i, ti, svfType, node, ty)
     {
 
     }
@@ -1510,7 +1478,7 @@ public:
     virtual const std::string toString() const;
 };
 
-class ConstantAggObjVar: public BaseObjVar
+class ConstAggObjVar : public BaseObjVar
 {
     friend class SVFIRWriter;
     friend class SVFIRReader;
@@ -1518,37 +1486,36 @@ class ConstantAggObjVar: public BaseObjVar
 public:
     ///  Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const ConstantAggObjVar*)
+    static inline bool classof(const ConstAggObjVar*)
     {
         return true;
     }
     static inline bool classof(const BaseObjVar* node)
     {
-        return node->getNodeKind() == ConstantAggObjNode;
+        return node->getNodeKind() == ConstAggObjNode;
     }
 
     static inline bool classof(const ObjVar* node)
     {
-        return node->getNodeKind() == ConstantAggObjNode;
+        return node->getNodeKind() == ConstAggObjNode;
     }
     static inline bool classof(const SVFVar* node)
     {
-        return node->getNodeKind() == ConstantAggObjNode;
+        return node->getNodeKind() == ConstAggObjNode;
     }
     static inline bool classof(const GenericPAGNodeTy* node)
     {
-        return node->getNodeKind() == ConstantAggObjNode;
+        return node->getNodeKind() == ConstAggObjNode;
     }
     static inline bool classof(const SVFBaseNode* node)
     {
-        return node->getNodeKind() == ConstantAggObjNode;
+        return node->getNodeKind() == ConstAggObjNode;
     }
     //@}
 
     /// Constructor
-    ConstantAggObjVar(const SVFValue* val, NodeID i, ObjTypeInfo* ti,
-                      PNODEK ty = ConstantAggObjNode)
-        : BaseObjVar(val, i,  ti, ty)
+    ConstAggObjVar(NodeID i, ObjTypeInfo* ti, const SVFType* svfType, const ICFGNode* node)
+        : BaseObjVar(i,  ti, svfType, node, ConstAggObjNode)
     {
 
     }
@@ -1566,18 +1533,18 @@ public:
     virtual const std::string toString() const;
 };
 
-class ConstantDataObjVar: public BaseObjVar
+class ConstDataObjVar : public BaseObjVar
 {
     friend class SVFIRWriter;
     friend class SVFIRReader;
 
 protected:
     /// Constructor to create empty DummyObjVar (for SVFIRReader/deserialization)
-    ConstantDataObjVar(NodeID i) : BaseObjVar(i, ConstantDataObjNode) {}
+    ConstDataObjVar(NodeID i, const ICFGNode* node) : BaseObjVar(i, node, ConstDataObjNode) {}
 
 public:
     //@{ Methods for support type inquiry through isa, cast, and dyn_cast:
-    static inline bool classof(const ConstantDataObjVar*)
+    static inline bool classof(const ConstDataObjVar*)
     {
         return true;
     }
@@ -1605,8 +1572,8 @@ public:
     //@}
 
     /// Constructor
-    ConstantDataObjVar(const SVFValue* val, NodeID i, ObjTypeInfo* ti,  PNODEK ty = ConstantDataObjNode)
-        : BaseObjVar(val, i, ti, ty)
+    ConstDataObjVar(NodeID i, ObjTypeInfo* ti, const SVFType* svfType, const ICFGNode* node, PNODEK ty = ConstDataObjNode)
+        : BaseObjVar(i, ti, svfType, node, ty)
     {
     }
 
@@ -1623,57 +1590,57 @@ public:
     virtual const std::string toString() const;
 };
 
-class ConstantFPObjVar: public ConstantDataObjVar
+class ConstFPObjVar : public ConstDataObjVar
 {
     friend class SVFIRWriter;
     friend class SVFIRReader;
 
 private:
     /// Constructor to create empty DummyObjVar (for SVFIRReader/deserialization)
-    ConstantFPObjVar(NodeID i) : ConstantDataObjVar(i) {}
+    ConstFPObjVar(NodeID i, const ICFGNode* node) : ConstDataObjVar(i, node) {}
 
 private:
     float dval;
 
 public:
     //@{ Methods for support type inquiry through isa, cast, and dyn_cast:
-    static inline bool classof(const ConstantFPObjVar*)
+    static inline bool classof(const ConstFPObjVar*)
     {
         return true;
     }
-    static inline bool classof(const ConstantDataObjVar* node)
+    static inline bool classof(const ConstDataObjVar* node)
     {
-        return node->getNodeKind() == SVFVar::ConstantFPObjNode;
+        return node->getNodeKind() == SVFVar::ConstFPObjNode;
     }
     static inline bool classof(const BaseObjVar* node)
     {
-        return node->getNodeKind() == SVFVar::ConstantFPObjNode;
+        return node->getNodeKind() == SVFVar::ConstFPObjNode;
     }
 
     static inline bool classof(const SVFVar* node)
     {
-        return node->getNodeKind() == SVFVar::ConstantFPObjNode;
+        return node->getNodeKind() == SVFVar::ConstFPObjNode;
     }
 
     static inline bool classof(const ObjVar* node)
     {
-        return node->getNodeKind() == SVFVar::ConstantFPObjNode;
+        return node->getNodeKind() == SVFVar::ConstFPObjNode;
     }
 
     static inline bool classof(const GenericPAGNodeTy* node)
     {
-        return node->getNodeKind() == SVFVar::ConstantFPObjNode;
+        return node->getNodeKind() == SVFVar::ConstFPObjNode;
     }
 
     static inline bool classof(const SVFBaseNode* node)
     {
-        return node->getNodeKind() == SVFVar::ConstantFPObjNode;
+        return node->getNodeKind() == SVFVar::ConstFPObjNode;
     }
     //@}
 
     /// Constructor
-    ConstantFPObjVar(const SVFValue* val, NodeID i, double dv, ObjTypeInfo* ti, PNODEK ty = ConstantFPObjNode)
-        : ConstantDataObjVar(val, i, ti, ty), dval(dv)
+    ConstFPObjVar(NodeID i, double dv, ObjTypeInfo* ti, const SVFType* svfType, const ICFGNode* node)
+        : ConstDataObjVar(i, ti, svfType, node, ConstFPObjNode), dval(dv)
     {
     }
 
@@ -1686,14 +1653,14 @@ public:
     virtual const std::string toString() const;
 };
 
-class ConstantIntObjVar: public ConstantDataObjVar
+class ConstIntObjVar : public ConstDataObjVar
 {
     friend class SVFIRWriter;
     friend class SVFIRReader;
 
 private:
     /// Constructor to create empty DummyObjVar (for SVFIRReader/deserialization)
-    ConstantIntObjVar(NodeID i) : ConstantDataObjVar(i) {}
+    ConstIntObjVar(NodeID i, const ICFGNode* node) : ConstDataObjVar(i, node) {}
 
 private:
     u64_t zval;
@@ -1701,37 +1668,37 @@ private:
 
 public:
     //@{ Methods for support type inquiry through isa, cast, and dyn_cast:
-    static inline bool classof(const ConstantIntObjVar*)
+    static inline bool classof(const ConstIntObjVar*)
     {
         return true;
     }
 
-    static inline bool classof(const ConstantDataObjVar* node)
+    static inline bool classof(const ConstDataObjVar* node)
     {
-        return node->getNodeKind() == SVFVar::ConstantIntObjNode;
+        return node->getNodeKind() == SVFVar::ConstIntObjNode;
     }
 
     static inline bool classof(const BaseObjVar* node)
     {
-        return node->getNodeKind() == SVFVar::ConstantIntObjNode;
+        return node->getNodeKind() == SVFVar::ConstIntObjNode;
     }
 
     static inline bool classof(const SVFVar* node)
     {
-        return node->getNodeKind() == SVFVar::ConstantIntObjNode;
+        return node->getNodeKind() == SVFVar::ConstIntObjNode;
     }
     static inline bool classof(const ObjVar* node)
     {
-        return node->getNodeKind() == SVFVar::ConstantIntObjNode;
+        return node->getNodeKind() == SVFVar::ConstIntObjNode;
     }
     static inline bool classof(const GenericPAGNodeTy* node)
     {
-        return node->getNodeKind() == SVFVar::ConstantIntObjNode;
+        return node->getNodeKind() == SVFVar::ConstIntObjNode;
     }
 
     static inline bool classof(const SVFBaseNode* node)
     {
-        return node->getNodeKind() == SVFVar::ConstantIntObjNode;
+        return node->getNodeKind() == SVFVar::ConstIntObjNode;
     }
 
     s64_t getSExtValue() const
@@ -1747,8 +1714,8 @@ public:
     //@}
 
     /// Constructor
-    ConstantIntObjVar(const SVFValue* val, NodeID i, s64_t sv, u64_t zv, ObjTypeInfo* ti, PNODEK ty = ConstantIntObjNode)
-        : ConstantDataObjVar(val, i, ti, ty), zval(zv), sval(sv)
+    ConstIntObjVar(NodeID i, s64_t sv, u64_t zv, ObjTypeInfo* ti, const SVFType* svfType, const ICFGNode* node)
+        : ConstDataObjVar(i, ti, svfType, node, ConstIntObjNode), zval(zv), sval(sv)
     {
     }
 
@@ -1756,68 +1723,66 @@ public:
     virtual const std::string toString() const;
 };
 
-class ConstantNullPtrObjVar: public ConstantDataObjVar
+class ConstNullPtrObjVar : public ConstDataObjVar
 {
     friend class SVFIRWriter;
     friend class SVFIRReader;
 
 private:
     /// Constructor to create empty DummyObjVar (for SVFIRReader/deserialization)
-    ConstantNullPtrObjVar(NodeID i) : ConstantDataObjVar(i) {}
+    ConstNullPtrObjVar(NodeID i, const ICFGNode* node) : ConstDataObjVar(i, node) {}
 
 public:
     //@{ Methods for support type inquiry through isa, cast, and dyn_cast:
-    static inline bool classof(const ConstantNullPtrObjVar*)
+    static inline bool classof(const ConstNullPtrObjVar*)
     {
         return true;
     }
 
-    static inline bool classof(const ConstantDataObjVar* node)
+    static inline bool classof(const ConstDataObjVar* node)
     {
-        return node->getNodeKind() == SVFVar::ConstantNullptrObjNode;
+        return node->getNodeKind() == SVFVar::ConstNullptrObjNode;
     }
 
     static inline bool classof(const BaseObjVar* node)
     {
-        return node->getNodeKind() == SVFVar::ConstantNullptrObjNode;
+        return node->getNodeKind() == SVFVar::ConstNullptrObjNode;
     }
 
     static inline bool classof(const SVFVar* node)
     {
-        return node->getNodeKind() == SVFVar::ConstantNullptrObjNode;
+        return node->getNodeKind() == SVFVar::ConstNullptrObjNode;
     }
     static inline bool classof(const ObjVar* node)
     {
-        return node->getNodeKind() == SVFVar::ConstantNullptrObjNode;
+        return node->getNodeKind() == SVFVar::ConstNullptrObjNode;
     }
     static inline bool classof(const GenericPAGNodeTy* node)
     {
-        return node->getNodeKind() == SVFVar::ConstantNullptrObjNode;
+        return node->getNodeKind() == SVFVar::ConstNullptrObjNode;
     }
 
     static inline bool classof(const SVFBaseNode* node)
     {
-        return node->getNodeKind() == SVFVar::ConstantNullptrObjNode;
+        return node->getNodeKind() == SVFVar::ConstNullptrObjNode;
     }
     //@}
 
     /// Constructor
-    ConstantNullPtrObjVar(const SVFValue* val, NodeID i, ObjTypeInfo* ti, PNODEK ty = ConstantNullptrObjNode)
-        : ConstantDataObjVar(val, i, ti, ty)
+    ConstNullPtrObjVar(NodeID i, ObjTypeInfo* ti, const SVFType* svfType, const ICFGNode* node)
+        : ConstDataObjVar(i, ti, svfType, node, ConstNullptrObjNode)
     {
     }
-
     virtual bool isConstDataOrAggDataButNotNullPtr() const
     {
         return false;
     }
-
     virtual const std::string toString() const;
 };
 /*
  * Unique Return node of a procedure
  */
-class RetPN: public ValVar
+class RetValPN : public ValVar
 {
     friend class SVFIRWriter;
     friend class SVFIRReader;
@@ -1825,36 +1790,36 @@ class RetPN: public ValVar
 private:
     const CallGraphNode* callGraphNode;
 private:
-    /// Constructor to create empty RetPN (for SVFIRReader/deserialization)
-    RetPN(NodeID i) : ValVar(i, RetNode) {}
+    /// Constructor to create empty RetValPN (for SVFIRReader/deserialization)
+    RetValPN(NodeID i) : ValVar(i, RetValNode) {}
 
 public:
     //@{ Methods for support type inquiry through isa, cast, and dyn_cast:
-    static inline bool classof(const RetPN*)
+    static inline bool classof(const RetValPN*)
     {
         return true;
     }
     static inline bool classof(const SVFVar* node)
     {
-        return node->getNodeKind() == SVFVar::RetNode;
+        return node->getNodeKind() == SVFVar::RetValNode;
     }
     static inline bool classof(const ValVar* node)
     {
-        return node->getNodeKind() == SVFVar::RetNode;
+        return node->getNodeKind() == SVFVar::RetValNode;
     }
     static inline bool classof(const GenericPAGNodeTy* node)
     {
-        return node->getNodeKind() == SVFVar::RetNode;
+        return node->getNodeKind() == SVFVar::RetValNode;
     }
     static inline bool classof(const SVFBaseNode* node)
     {
-        return node->getNodeKind() == SVFVar::RetNode;
+        return node->getNodeKind() == SVFVar::RetValNode;
     }
     //@}
 
 
     /// Constructor
-    RetPN(NodeID i, const CallGraphNode* node);
+    RetValPN(NodeID i, const CallGraphNode* node, const SVFType* svfType, const ICFGNode* icn);
 
     inline const CallGraphNode* getCallGraphNode() const
     {
@@ -1863,6 +1828,8 @@ public:
 
     virtual const SVFFunction* getFunction() const;
 
+    virtual bool isPointer() const;
+
     /// Return name of a LLVM value
     const std::string getValueName() const;
 
@@ -1872,7 +1839,7 @@ public:
 /*
  * Unique vararg node of a procedure
  */
-class VarArgPN: public ValVar
+class VarArgValPN : public ValVar
 {
     friend class SVFIRWriter;
     friend class SVFIRReader;
@@ -1880,41 +1847,48 @@ private:
     const CallGraphNode* callGraphNode;
 
 private:
-    /// Constructor to create empty VarArgPN (for SVFIRReader/deserialization)
-    VarArgPN(NodeID i) : ValVar(i, VarargNode) {}
+    /// Constructor to create empty VarArgValPN (for SVFIRReader/deserialization)
+    VarArgValPN(NodeID i) : ValVar(i, VarargValNode) {}
 
 public:
     //@{ Methods for support type inquiry through isa, cast, and dyn_cast:
-    static inline bool classof(const VarArgPN*)
+    static inline bool classof(const VarArgValPN*)
     {
         return true;
     }
     static inline bool classof(const SVFVar* node)
     {
-        return node->getNodeKind() == SVFVar::VarargNode;
+        return node->getNodeKind() == SVFVar::VarargValNode;
     }
     static inline bool classof(const ValVar* node)
     {
-        return node->getNodeKind() == SVFVar::VarargNode;
+        return node->getNodeKind() == SVFVar::VarargValNode;
     }
     static inline bool classof(const GenericPAGNodeTy* node)
     {
-        return node->getNodeKind() == SVFVar::VarargNode;
+        return node->getNodeKind() == SVFVar::VarargValNode;
     }
     static inline bool classof(const SVFBaseNode* node)
     {
-        return node->getNodeKind() == SVFVar::VarargNode;
+        return node->getNodeKind() == SVFVar::VarargValNode;
     }
     //@}
 
     /// Constructor
-    VarArgPN(NodeID i, const CallGraphNode* node) : ValVar(nullptr, i, VarargNode), callGraphNode(node) {}
+    VarArgValPN(NodeID i, const CallGraphNode* node, const SVFType* svfType, const ICFGNode* icn)
+        : ValVar(i, svfType, icn, VarargValNode), callGraphNode(node)
+    {
+    }
 
     virtual const SVFFunction* getFunction() const;
 
     /// Return name of a LLVM value
     const std::string getValueName() const;
 
+    virtual bool isPointer() const
+    {
+        return true;
+    }
     virtual const std::string toString() const;
 };
 
@@ -1951,7 +1925,10 @@ public:
     //@}
 
     /// Constructor
-    DummyValVar(NodeID i) : ValVar(nullptr, i, DummyValNode) {}
+    DummyValVar(NodeID i, const ICFGNode* node, const SVFType* svfType = SVFType::getSVFPtrType())
+        : ValVar(i, svfType, node, DummyValNode)
+    {
+    }
 
     /// Return name of this node
     inline const std::string getValueName() const
@@ -1959,6 +1936,11 @@ public:
         return "dummyVal";
     }
 
+    virtual bool isPointer() const
+    {
+        return true;
+    }
+
     virtual const std::string toString() const;
 };
 
@@ -1972,7 +1954,7 @@ class DummyObjVar: public BaseObjVar
 
 private:
     /// Constructor to create empty DummyObjVar (for SVFIRReader/deserialization)
-    DummyObjVar(NodeID i) : BaseObjVar(i, DummyObjNode) {}
+    DummyObjVar(NodeID i, const ICFGNode* node) : BaseObjVar(i, node, DummyObjNode) {}
 
 public:
     //@{ Methods for support type inquiry through isa, cast, and dyn_cast:
@@ -2004,8 +1986,8 @@ public:
     //@}
 
     /// Constructor
-    DummyObjVar(NodeID i, ObjTypeInfo* ti, PNODEK ty = DummyObjNode)
-        : BaseObjVar(nullptr, i, ti, ty)
+    DummyObjVar(NodeID i, ObjTypeInfo* ti, const ICFGNode* node, const SVFType* svfType = SVFType::getSVFPtrType())
+        : BaseObjVar(i, ti, svfType, node, DummyObjNode)
     {
     }
 
@@ -2015,6 +1997,11 @@ public:
         return "dummyObj";
     }
 
+    virtual bool isPointer() const
+    {
+        return true;
+    }
+
     virtual const std::string toString() const;
 };