SVFVariables.h

Go to the documentation of this file.

//===- SVFVariables.h -- SVF Variables------------------------//
//
//                     SVF: Static Value-Flow Analysis
//
// Copyright (C) <2013->  <Yulei Sui>
//
 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
 
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
//===----------------------------------------------------------------------===//
 
/*
 * SVFVariables.h
 *
 *  Created on: Nov 11, 2013
 *      Author: Yulei Sui
 *  Refactored on: Nov 30, 2024
 *      Author: Xiao Cheng, Yulei Sui
 */
 
#ifndef INCLUDE_SVFIR_SVFVARIABLE_H_
#define INCLUDE_SVFIR_SVFVARIABLE_H_
 
#include "Graphs/GenericGraph.h"
#include "SVFIR/ObjTypeInfo.h"
#include "SVFIR/SVFStatements.h"
 
namespace SVF
{
 
class SVFVar;
/*
 * 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
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
    friend class SVFIRBuilder;
    friend class IRGraph;
    friend class SVFIR;
    friend class VFG;
 
public:
    typedef GNodeK PNODEK;
    typedef s64_t GEdgeKind;
 
protected:
    SVFStmt::KindToSVFStmtMapTy InEdgeKindToSetMap;
    SVFStmt::KindToSVFStmtMapTy OutEdgeKindToSetMap;
 
    SVFVar(NodeID i, PNODEK k) : GenericPAGNodeTy(i, k) {}
 
 
public:
    SVFVar(NodeID i, const SVFType* svfType, PNODEK k);
 
    virtual ~SVFVar() {}
 
    virtual inline bool isPointer() const
    {
        assert(type && "type is null?");
        return type->isPointerTy();
    }
 
    virtual bool isConstDataOrAggDataButNotNullPtr() const
    {
        return false;
    }
 
    virtual bool isIsolatedNode() const;
 
    virtual const std::string getValueName() const = 0;
 
    virtual inline const FunObjVar* getFunction() const
    {
        return nullptr;
    }
 
 
    inline SVFStmt::SVFStmtSetTy& getIncomingEdges(SVFStmt::PEDGEK kind)
    {
        return InEdgeKindToSetMap[kind];
    }
 
    inline SVFStmt::SVFStmtSetTy& getOutgoingEdges(SVFStmt::PEDGEK kind)
    {
        return OutEdgeKindToSetMap[kind];
    }
 
    inline bool hasIncomingEdges(SVFStmt::PEDGEK kind) const
    {
        SVFStmt::KindToSVFStmtMapTy::const_iterator it = InEdgeKindToSetMap.find(kind);
        if (it != InEdgeKindToSetMap.end())
            return (!it->second.empty());
        else
            return false;
    }
 
    inline bool hasOutgoingEdges(SVFStmt::PEDGEK kind) const
    {
        SVFStmt::KindToSVFStmtMapTy::const_iterator it = OutEdgeKindToSetMap.find(kind);
        if (it != OutEdgeKindToSetMap.end())
            return (!it->second.empty());
        else
            return false;
    }
 
    inline SVFStmt::SVFStmtSetTy::iterator getIncomingEdgesBegin(SVFStmt::PEDGEK kind) const
    {
        SVFStmt::KindToSVFStmtMapTy::const_iterator it = InEdgeKindToSetMap.find(kind);
        assert(it!=InEdgeKindToSetMap.end() && "Edge kind not found");
        return it->second.begin();
    }
 
    inline SVFStmt::SVFStmtSetTy::iterator getIncomingEdgesEnd(SVFStmt::PEDGEK kind) const
    {
        SVFStmt::KindToSVFStmtMapTy::const_iterator it = InEdgeKindToSetMap.find(kind);
        assert(it!=InEdgeKindToSetMap.end() && "Edge kind not found");
        return it->second.end();
    }
 
    inline SVFStmt::SVFStmtSetTy::iterator getOutgoingEdgesBegin(SVFStmt::PEDGEK kind) const
    {
        SVFStmt::KindToSVFStmtMapTy::const_iterator it = OutEdgeKindToSetMap.find(kind);
        assert(it!=OutEdgeKindToSetMap.end() && "Edge kind not found");
        return it->second.begin();
    }
 
    inline SVFStmt::SVFStmtSetTy::iterator getOutgoingEdgesEnd(SVFStmt::PEDGEK kind) const
    {
        SVFStmt::KindToSVFStmtMapTy::const_iterator it = OutEdgeKindToSetMap.find(kind);
        assert(it!=OutEdgeKindToSetMap.end() && "Edge kind not found");
        return it->second.end();
    }
 
    static inline bool classof(const SVFVar *)
    {
        return true;
    }
 
    static inline bool classof(const GenericPAGNodeTy * node)
    {
        return isSVFVarKind(node->getNodeKind());
    }
 
    static inline bool classof(const SVFValue* node)
    {
        return isSVFVarKind(node->getNodeKind());
    }
 
    virtual bool ptrInUncalledFunction() const;
 
    virtual bool isConstDataOrAggData() const
    {
        return false;
    }
 
 
private:
 
    inline void addInEdge(SVFStmt* inEdge)
    {
        GEdgeKind kind = inEdge->getEdgeKind();
        InEdgeKindToSetMap[kind].insert(inEdge);
        addIncomingEdge(inEdge);
    }
 
    inline void addOutEdge(SVFStmt* outEdge)
    {
        GEdgeKind kind = outEdge->getEdgeKind();
        OutEdgeKindToSetMap[kind].insert(outEdge);
        addOutgoingEdge(outEdge);
    }
 
    inline bool hasIncomingVariantGepEdge() const
    {
        SVFStmt::KindToSVFStmtMapTy::const_iterator it = InEdgeKindToSetMap.find(SVFStmt::Gep);
        if (it != InEdgeKindToSetMap.end())
        {
            for(auto gep : it->second)
            {
                if(SVFUtil::cast<GepStmt>(gep)->isVariantFieldGep())
                    return true;
            }
        }
        return false;
    }
 
public:
    virtual const std::string toString() const;
 
    void dump() const;
 
    friend OutStream& operator<< (OutStream &o, const SVFVar &node)
    {
        o << node.toString();
        return o;
    }
};
 
 
 
/*
 * Value (Pointer) variable
 */
class ValVar: public SVFVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
 
private:
    const ICFGNode* icfgNode; // icfgnode related to valvar
protected:
    ValVar(NodeID i, PNODEK ty = ValNode) : SVFVar(i, ty), icfgNode(nullptr) {}
 
public:
 
    static inline bool classof(const ValVar*)
    {
        return true;
    }
    static inline bool classof(const SVFVar* node)
    {
        return isValVarKinds(node->getNodeKind());
    }
    static inline bool classof(const GenericPAGNodeTy* node)
    {
        return isValVarKinds(node->getNodeKind());
    }
    static inline bool classof(const SVFValue* node)
    {
        return isValVarKinds(node->getNodeKind());
    }
 
    ValVar(NodeID i, const SVFType* svfType, const ICFGNode* node, PNODEK ty = ValNode)
        : SVFVar(i, svfType, ty), icfgNode(node)
    {
    }
    inline const std::string getValueName() const
    {
        return getName();
    }
 
    const ICFGNode* getICFGNode() const
    {
        return icfgNode;
    }
 
    virtual const FunObjVar* getFunction() const;
 
    virtual const std::string toString() const;
};
 
/*
 * Memory Object variable
 */
class ObjVar: public SVFVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
 
protected:
    ObjVar(NodeID i, PNODEK ty = ObjNode) : SVFVar(i, ty) {}
    ObjVar(NodeID i, const SVFType* svfType, PNODEK ty = ObjNode) :
        SVFVar(i, svfType, ty)
    {
    }
public:
 
    static inline bool classof(const ObjVar*)
    {
        return true;
    }
    static inline bool classof(const SVFVar* node)
    {
        return isObjVarKinds(node->getNodeKind());
    }
    static inline bool classof(const GenericPAGNodeTy* node)
    {
        return isObjVarKinds(node->getNodeKind());
    }
    static inline bool classof(const SVFValue* node)
    {
        return isObjVarKinds(node->getNodeKind());
    }
 
    virtual const std::string getValueName() const
    {
        return getName();
    }
 
    virtual const std::string toString() const;
};
 
 
class ArgValVar: public ValVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
 
private:
    const FunObjVar* cgNode;
    u32_t argNo;
 
protected:
    ArgValVar(NodeID i, PNODEK ty = ArgValNode) : ValVar(i, ty) {}
 
public:
 
    static inline bool classof(const ArgValVar*)
    {
        return true;
    }
    static inline bool classof(const ValVar* node)
    {
        return node->getNodeKind() == ArgValNode;
    }
    static inline bool classof(const SVFVar* node)
    {
        return node->getNodeKind() == ArgValNode;
    }
    static inline bool classof(const GenericPAGNodeTy* node)
    {
        return node->getNodeKind() == ArgValNode;
    }
    static inline bool classof(const SVFValue* node)
    {
        return node->getNodeKind() == ArgValNode;
    }
 
    ArgValVar(NodeID i, u32_t argNo, const ICFGNode* icn, const FunObjVar* callGraphNode,
              const SVFType* svfType);
 
    inline const std::string getValueName() const
    {
        return getName() + " (argument valvar)";
    }
 
    virtual const FunObjVar* getFunction() const;
 
    const FunObjVar* getParent() const;
 
    inline u32_t getArgNo() const
    {
        return argNo;
    }
 
    bool isArgOfUncalledFunction() const;
 
    virtual bool isPointer() const;
 
    virtual const std::string toString() const;
};
 
 
/*
 * Gep Value (Pointer) variable, this variable can be dynamic generated for field sensitive analysis
 * e.g. memcpy, temp gep value variable needs to be created
 * Each Gep Value variable is connected to base value variable via gep edge
 */
class GepValVar: public ValVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
 
private:
    AccessPath ap;  // AccessPath
    const ValVar* base; // base node
    const SVFType* gepValType;
 
    GepValVar(NodeID i) : ValVar(i, GepValNode), gepValType{} {}
 
public:
 
    static inline bool classof(const GepValVar *)
    {
        return true;
    }
    static inline bool classof(const ValVar * node)
    {
        return node->getNodeKind() == SVFVar::GepValNode;
    }
    static inline bool classof(const SVFVar *node)
    {
        return node->getNodeKind() == SVFVar::GepValNode;
    }
    static inline bool classof(const GenericPAGNodeTy *node)
    {
        return node->getNodeKind() == SVFVar::GepValNode;
    }
    static inline bool classof(const SVFValue* node)
    {
        return node->getNodeKind() == SVFVar::GepValNode;
    }
 
    GepValVar(const ValVar* baseNode, NodeID i, const AccessPath& ap,
              const SVFType* ty, const ICFGNode* node);
 
    inline APOffset getConstantFieldIdx() const
    {
        return ap.getConstantStructFldIdx();
    }
 
    inline const ValVar* getBaseNode(void) const
    {
        return base;
    }
 
    inline const std::string getValueName() const
    {
        return getName() + "_" +
               std::to_string(getConstantFieldIdx());
    }
 
    virtual bool isPointer() const
    {
        return base->isPointer();
    }
 
    inline const SVFType* getType() const
    {
        return gepValType;
    }
 
    virtual const FunObjVar* getFunction() const
    {
        return base->getFunction();
    }
 
    virtual const std::string toString() const;
 
    virtual bool isConstDataOrAggDataButNotNullPtr() const
    {
        return base->isConstDataOrAggDataButNotNullPtr();
    }
    virtual inline bool ptrInUncalledFunction() const
    {
        return base->ptrInUncalledFunction();
    }
 
    virtual inline bool isConstDataOrAggData() const
    {
        return base->isConstDataOrAggData();
    }
};
 
/*
 * Base memory object variable (address-taken variables in LLVM-based languages)
 */
class BaseObjVar : public ObjVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
    friend class SVFIRBuilder;
private:
    ObjTypeInfo* typeInfo;
 
    const ICFGNode* icfgNode; 
 
protected:
    BaseObjVar(NodeID i, const ICFGNode* node, PNODEK ty = BaseObjNode) : ObjVar(i, ty), icfgNode(node) {}
 
public:
 
    static inline bool classof(const BaseObjVar*)
    {
        return true;
    }
    static inline bool classof(const ObjVar* node)
    {
        return isBaseObjVarKinds(node->getNodeKind());
    }
    static inline bool classof(const SVFVar* node)
    {
        return isBaseObjVarKinds(node->getNodeKind());
    }
    static inline bool classof(const GenericPAGNodeTy* node)
    {
        return isBaseObjVarKinds(node->getNodeKind());
    }
    static inline bool classof(const SVFValue* node)
    {
        return isBaseObjVarKinds(node->getNodeKind());
    }
 
    BaseObjVar(NodeID i, ObjTypeInfo* ti,
               const SVFType* svfType, const ICFGNode* node, PNODEK ty = BaseObjNode)
        : ObjVar(i, svfType, ty), typeInfo(ti), icfgNode(node)
    {
    }
 
    virtual const BaseObjVar* getBaseMemObj() const
    {
        return this;
    }
 
    inline const ICFGNode* getICFGNode() const
    {
        return icfgNode;
    }
 
    inline const std::string getValueName() const
    {
        return getName() + " (base object)";
    }
 
    virtual const std::string toString() const;
 
    inline NodeID getId() const
    {
        return id;
    }
 
    const SVFType* getType() const
    {
        return typeInfo->getType();
    }
 
    u32_t getNumOfElements() const
    {
        return typeInfo->getNumOfElements();
    }
 
    void setNumOfElements(u32_t num)
    {
        return typeInfo->setNumOfElements(num);
    }
 
    u32_t getMaxFieldOffsetLimit() const
    {
        return typeInfo->getMaxFieldOffsetLimit();
    }
 
 
    bool isFieldInsensitive() const
    {
        return getMaxFieldOffsetLimit() == 0;
    }
 
    void setFieldInsensitive()
    {
        typeInfo->setMaxFieldOffsetLimit(0);
    }
 
 
    void setFieldSensitive()
    {
        typeInfo->setMaxFieldOffsetLimit(typeInfo->getNumOfElements());
    }
 
    bool isBlackHoleObj() const;
 
    u32_t getByteSizeOfObj() const
    {
        return typeInfo->getByteSizeOfObj();
    }
 
    bool isConstantByteSize() const
    {
        return typeInfo->isConstantByteSize();
    }
 
 
 
    bool isFunction() const
    {
        return typeInfo->isFunction();
    }
    bool isGlobalObj() const
    {
        return typeInfo->isGlobalObj();
    }
    bool isStaticObj() const
    {
        return typeInfo->isStaticObj();
    }
    bool isStack() const
    {
        return typeInfo->isStack();
    }
    bool isHeap() const
    {
        return typeInfo->isHeap();
    }
    bool isStruct() const
    {
        return typeInfo->isStruct();
    }
    bool isArray() const
    {
        return typeInfo->isArray();
    }
    bool isVarStruct() const
    {
        return typeInfo->isVarStruct();
    }
    bool isVarArray() const
    {
        return typeInfo->isVarArray();
    }
    bool isConstantStruct() const
    {
        return typeInfo->isConstantStruct();
    }
    bool isConstantArray() const
    {
        return typeInfo->isConstantArray();
    }
    bool isConstDataOrConstGlobal() const
    {
        return typeInfo->isConstDataOrConstGlobal();
    }
    virtual inline bool isConstDataOrAggData() const
    {
        return typeInfo->isConstDataOrAggData();
    }
 
    void destroy()
    {
        delete typeInfo;
        typeInfo = nullptr;
    }
 
    virtual const FunObjVar* getFunction() const;
 
};
 
 
/*
 * Gep Obj variable, this is dynamic generated for field sensitive analysis
 * Each gep obj variable is one field of a BaseObjVar (base)
 */
class GepObjVar: public ObjVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
 
private:
    APOffset apOffset = 0;
 
    const BaseObjVar* base;
 
    //  only for reading from file when we don't have BaseObjVar*
    GepObjVar(NodeID i, PNODEK ty = GepObjNode) : ObjVar(i, ty), base{} {}
 
public:
 
    static inline bool classof(const GepObjVar*)
    {
        return true;
    }
    static inline bool classof(const ObjVar* node)
    {
        return node->getNodeKind() == SVFVar::GepObjNode;
    }
    static inline bool classof(const SVFVar* node)
    {
        return node->getNodeKind() == SVFVar::GepObjNode;
    }
    static inline bool classof(const GenericPAGNodeTy* node)
    {
        return node->getNodeKind() == SVFVar::GepObjNode;
    }
    static inline bool classof(const SVFValue* node)
    {
        return node->getNodeKind() == SVFVar::GepObjNode;
    }
 
    GepObjVar(const BaseObjVar* baseObj, NodeID i,
              const APOffset& apOffset, PNODEK ty = GepObjNode)
        : ObjVar(i, baseObj->getType(), ty), apOffset(apOffset), base(baseObj)
    {
    }
 
    inline APOffset getConstantFieldIdx() const
    {
        return apOffset;
    }
 
    inline NodeID getBaseNode(void) const
    {
        return base->getId();
    }
 
    inline const BaseObjVar* getBaseObj() const
    {
        return base;
    }
 
    inline virtual const SVFType* getType() const;
 
 
    inline const std::string getValueName() const
    {
        return getName() + "_" + std::to_string(apOffset);
    }
 
    virtual const FunObjVar* getFunction() const
    {
        return base->getFunction();
    }
 
    virtual const std::string toString() const;
 
    virtual inline bool ptrInUncalledFunction() const
    {
        return base->ptrInUncalledFunction();
    }
 
    virtual inline bool isConstDataOrAggData() const
    {
        return base->isConstDataOrAggData();
    }
 
    virtual bool isConstDataOrAggDataButNotNullPtr() const
    {
        return base->isConstDataOrAggDataButNotNullPtr();
    }
 
    virtual bool isPointer() const
    {
        return base->isPointer();
    }
};
 
 
 
class HeapObjVar: public BaseObjVar
{
 
    friend class SVFIRWriter;
    friend class SVFIRReader;
 
protected:
    HeapObjVar(NodeID i, const ICFGNode* node) : BaseObjVar(i, node, HeapObjNode) {}
 
public:
 
    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 SVFValue* node)
    {
        return node->getNodeKind() == HeapObjNode;
    }
 
    HeapObjVar(NodeID i, ObjTypeInfo* ti, const SVFType* svfType, const ICFGNode* node):
        BaseObjVar(i, ti, svfType, node, HeapObjNode)
    {
    }
 
    inline const std::string getValueName() const
    {
        return " (heap base object)";
    }
 
    virtual const std::string toString() const;
};
 
 
class StackObjVar: public BaseObjVar
{
 
    friend class SVFIRWriter;
    friend class SVFIRReader;
 
protected:
    StackObjVar(NodeID i, const ICFGNode* node) : BaseObjVar(i, node, StackObjNode) {}
 
public:
 
    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 SVFValue* node)
    {
        return node->getNodeKind() == StackObjNode;
    }
 
    StackObjVar(NodeID i, ObjTypeInfo* ti, const SVFType* svfType, const ICFGNode* node):
        BaseObjVar(i, ti, svfType, node, StackObjNode)
    {
    }
 
    inline const std::string getValueName() const
    {
        return " (stack base object)";
    }
 
    virtual const std::string toString() const;
};
 
 
class CallGraphNode;
 
class FunObjVar : public BaseObjVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
    friend class SVFIRBuilder;
    friend class LLVMModuleSet;
 
public:
    typedef SVFLoopAndDomInfo::BBSet BBSet;
    typedef SVFLoopAndDomInfo::BBList BBList;
    typedef SVFLoopAndDomInfo::LoopBBs LoopBBs;
 
    typedef BasicBlockGraph::IDToNodeMapTy::const_iterator const_bb_iterator;
 
 
private:
    bool isDecl;   
    bool intrinsic; 
    bool isAddrTaken; 
    bool isUncalled;    
    bool isNotRet;   
    bool supVarArg;    
    const SVFFunctionType* funcType; 
    SVFLoopAndDomInfo* loopAndDom;  
    const FunObjVar * realDefFun;  
    BasicBlockGraph* bbGraph; 
    std::vector<const ArgValVar*> allArgs;    
    const SVFBasicBlock *exitBlock;             
 
 
private:
    FunObjVar(NodeID i, const ICFGNode* node) : BaseObjVar(i,node, FunObjNode) {}
 
public:
 
    static inline bool classof(const FunObjVar*)
    {
        return true;
    }
    static inline bool classof(const BaseObjVar* node)
    {
        return node->getNodeKind() == FunObjNode;
    }
    static inline bool classof(const ObjVar* node)
    {
        return node->getNodeKind() == FunObjNode;
    }
    static inline bool classof(const SVFVar* node)
    {
        return node->getNodeKind() == FunObjNode;
    }
    static inline bool classof(const GenericPAGNodeTy* node)
    {
        return node->getNodeKind() == FunObjNode;
    }
    static inline bool classof(const SVFValue* node)
    {
        return node->getNodeKind() == FunObjNode;
    }
 
    FunObjVar(NodeID i, ObjTypeInfo* ti, const SVFType* svfType, const ICFGNode* node);
 
 
    virtual ~FunObjVar()
    {
        delete loopAndDom;
        delete bbGraph;
    }
 
    void initFunObjVar(bool decl, bool intrinc, bool addr, bool uncalled, bool notret, bool vararg, const SVFFunctionType *ft,
                       SVFLoopAndDomInfo *ld, const FunObjVar *real, BasicBlockGraph *bbg,
                       const std::vector<const ArgValVar *> &allarg, const SVFBasicBlock *exit);
 
    void setRelDefFun(const FunObjVar *real)
    {
        realDefFun = real;
    }
 
    virtual const FunObjVar*getFunction() const;
 
    inline void addArgument(const ArgValVar *arg)
    {
        allArgs.push_back(arg);
    }
    inline bool isDeclaration() const
    {
        return isDecl;
    }
 
    inline bool isIntrinsic() const
    {
        return intrinsic;
    }
 
    inline bool hasAddressTaken() const
    {
        return isAddrTaken;
    }
 
    inline bool isVarArg() const
    {
        return supVarArg;
    }
 
    inline bool isUncalledFunction() const
    {
        return isUncalled;
    }
 
    inline bool hasReturn() const
    {
        return  !isNotRet;
    }
 
    inline const SVFFunctionType* getFunctionType() const
    {
        return funcType;
    }
 
    inline const SVFType* getReturnType() const
    {
        return funcType->getReturnType();
    }
 
    inline SVFLoopAndDomInfo* getLoopAndDomInfo() const
    {
        return loopAndDom;
    }
 
    inline const std::vector<const SVFBasicBlock*>& getReachableBBs() const
    {
        return loopAndDom->getReachableBBs();
    }
 
    inline void getExitBlocksOfLoop(const SVFBasicBlock* bb, BBList& exitbbs) const
    {
        return loopAndDom->getExitBlocksOfLoop(bb,exitbbs);
    }
 
    inline bool hasLoopInfo(const SVFBasicBlock* bb) const
    {
        return loopAndDom->hasLoopInfo(bb);
    }
 
    const LoopBBs& getLoopInfo(const SVFBasicBlock* bb) const
    {
        return loopAndDom->getLoopInfo(bb);
    }
 
    inline const SVFBasicBlock* getLoopHeader(const BBList& lp) const
    {
        return loopAndDom->getLoopHeader(lp);
    }
 
    inline bool loopContainsBB(const BBList& lp, const SVFBasicBlock* bb) const
    {
        return loopAndDom->loopContainsBB(lp,bb);
    }
 
    inline const Map<const SVFBasicBlock*,BBSet>& getDomTreeMap() const
    {
        return loopAndDom->getDomTreeMap();
    }
 
    inline const Map<const SVFBasicBlock*,BBSet>& getDomFrontierMap() const
    {
        return loopAndDom->getDomFrontierMap();
    }
 
    inline bool isLoopHeader(const SVFBasicBlock* bb) const
    {
        return loopAndDom->isLoopHeader(bb);
    }
 
    inline bool dominate(const SVFBasicBlock* bbKey, const SVFBasicBlock* bbValue) const
    {
        return loopAndDom->dominate(bbKey,bbValue);
    }
 
    inline bool postDominate(const SVFBasicBlock* bbKey, const SVFBasicBlock* bbValue) const
    {
        return loopAndDom->postDominate(bbKey,bbValue);
    }
 
    inline const FunObjVar* getDefFunForMultipleModule() const
    {
        if(realDefFun==nullptr)
            return this;
        return realDefFun;
    }
 
    void setBasicBlockGraph(BasicBlockGraph* graph)
    {
        this->bbGraph = graph;
    }
 
    BasicBlockGraph* getBasicBlockGraph()
    {
        return bbGraph;
    }
 
    const BasicBlockGraph* getBasicBlockGraph() const
    {
        return bbGraph;
    }
 
    inline bool hasBasicBlock() const
    {
        return bbGraph && bbGraph->begin() != bbGraph->end();
    }
 
    inline const SVFBasicBlock* getEntryBlock() const
    {
        assert(hasBasicBlock() && "function does not have any Basicblock, external function?");
        assert(bbGraph->begin()->second->getInEdges().size() == 0 && "the first basic block is not entry block");
        return bbGraph->begin()->second;
    }
 
    inline const SVFBasicBlock* getExitBB() const
    {
        assert(hasBasicBlock() && "function does not have any Basicblock, external function?");
        assert(exitBlock && "must have an exitBlock");
        return exitBlock;
    }
 
    inline void setExitBlock(SVFBasicBlock *bb)
    {
        assert(!exitBlock && "have already set exit Basicblock!");
        exitBlock = bb;
    }
 
 
    u32_t inline arg_size() const
    {
        return allArgs.size();
    }
 
    inline const ArgValVar*  getArg(u32_t idx) const
    {
        assert (idx < allArgs.size() && "getArg() out of range!");
        return allArgs[idx];
    }
 
    inline const SVFBasicBlock* front() const
    {
        return getEntryBlock();
    }
 
    inline const SVFBasicBlock* back() const
    {
        assert(hasBasicBlock() && "function does not have any Basicblock, external function?");
        return std::prev(bbGraph->end())->second;
    }
 
    inline const_bb_iterator begin() const
    {
        return bbGraph->begin();
    }
 
    inline const_bb_iterator end() const
    {
        return bbGraph->end();
    }
 
    virtual bool isIsolatedNode() const;
 
    virtual const std::string toString() const;
};
class FunValVar : public ValVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
private:
    const FunObjVar* funObjVar;
 
public:
 
    static inline bool classof(const FunValVar*)
    {
        return true;
    }
    static inline bool classof(const ValVar* node)
    {
        return node->getNodeKind() == FunValNode;
    }
    static inline bool classof(const SVFVar* node)
    {
        return node->getNodeKind() == FunValNode;
    }
    static inline bool classof(const GenericPAGNodeTy* node)
    {
        return node->getNodeKind() == FunValNode;
    }
    static inline bool classof(const SVFValue* node)
    {
        return node->getNodeKind() == FunValNode;
    }
 
    inline virtual const FunObjVar* getFunction() const
    {
        return funObjVar->getFunction();
    }
 
    FunValVar(NodeID i, const ICFGNode* icn, const FunObjVar* cgn, const SVFType* svfType);
 
 
    virtual bool isPointer() const
    {
        return true;
    }
 
    virtual const std::string toString() const;
};
 
 
 
class GlobalValVar : public ValVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
 
public:
 
    static inline bool classof(const GlobalValVar*)
    {
        return true;
    }
    static inline bool classof(const ValVar* node)
    {
        return node->getNodeKind() == GlobalValNode;
    }
    static inline bool classof(const SVFVar* node)
    {
        return node->getNodeKind() == GlobalValNode;
    }
    static inline bool classof(const GenericPAGNodeTy* node)
    {
        return node->getNodeKind() == GlobalValNode;
    }
    static inline bool classof(const SVFValue* node)
    {
        return node->getNodeKind() == GlobalValNode;
    }
 
    GlobalValVar(NodeID i, const ICFGNode* icn, const SVFType* svfType)
        : ValVar(i, svfType, icn, GlobalValNode)
    {
        type = svfType;
    }
 
 
    virtual const std::string toString() const;
};
 
class ConstAggValVar: public ValVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
 
public:
 
    static inline bool classof(const ConstAggValVar*)
    {
        return true;
    }
    static inline bool classof(const ValVar* node)
    {
        return node->getNodeKind() == ConstAggValNode;
    }
    static inline bool classof(const SVFVar* node)
    {
        return node->getNodeKind() == ConstAggValNode;
    }
    static inline bool classof(const GenericPAGNodeTy* node)
    {
        return node->getNodeKind() == ConstAggValNode;
    }
    static inline bool classof(const SVFValue* node)
    {
        return node->getNodeKind() == ConstAggValNode;
    }
 
    ConstAggValVar(NodeID i, const ICFGNode* icn, const SVFType* svfTy)
        : ValVar(i, svfTy, icn, ConstAggValNode)
    {
        type = svfTy;
    }
 
 
    virtual bool isConstDataOrAggData() const
    {
        return true;
    }
 
    virtual bool isConstDataOrAggDataButNotNullPtr() const
    {
        return true;
    }
 
    virtual const std::string toString() const;
};
 
 
class ConstDataValVar : public ValVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
 
public:
 
    static inline bool classof(const ConstDataValVar*)
    {
        return true;
    }
    static inline bool classof(const ValVar* node)
    {
        return isConstantDataValVar(node->getNodeKind());
    }
    static inline bool classof(const SVFVar* node)
    {
        return isConstantDataValVar(node->getNodeKind());
    }
    static inline bool classof(const GenericPAGNodeTy* node)
    {
        return isConstantDataValVar(node->getNodeKind());
    }
    static inline bool classof(const SVFValue* node)
    {
        return isConstantDataValVar(node->getNodeKind());
    }
 
    ConstDataValVar(NodeID i, const ICFGNode* icn, const SVFType* svfType,
                    PNODEK ty = ConstDataValNode)
        : ValVar(i, svfType, icn, ty)
    {
 
    }
 
    virtual bool isConstDataOrAggData() const
    {
        return true;
    }
 
    virtual bool isConstDataOrAggDataButNotNullPtr() const
    {
        return true;
    }
 
    virtual const std::string toString() const;
};
 
class BlackHoleValVar : public ConstDataValVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
 
public:
 
    static inline bool classof(const BlackHoleValVar*)
    {
        return true;
    }
    static inline bool classof(const ConstDataValVar* node)
    {
        return node->getNodeKind() == BlackHoleValNode;
    }
    static inline bool classof(const ValVar* node)
    {
        return node->getNodeKind() == BlackHoleValNode;
    }
    static inline bool classof(const SVFVar* node)
    {
        return node->getNodeKind() == BlackHoleValNode;
    }
    static inline bool classof(const GenericPAGNodeTy* node)
    {
        return node->getNodeKind() == BlackHoleValNode;
    }
    static inline bool classof(const SVFValue* node)
    {
        return node->getNodeKind() == BlackHoleValNode;
    }
 
    BlackHoleValVar(NodeID i, const SVFType* svfType, PNODEK ty = BlackHoleValNode)
        : ConstDataValVar(i,  nullptr, svfType, ty)
    {
 
    }
 
    virtual bool isConstDataOrAggDataButNotNullPtr() const
    {
        return false;
    }
 
    virtual const std::string toString() const
    {
        return "BlackHoleValVar";
    }
};
 
class ConstFPValVar : public ConstDataValVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
private:
    double dval;
 
public:
 
    static inline bool classof(const ConstFPValVar*)
    {
        return true;
    }
    static inline bool classof(const ConstDataValVar* node)
    {
        return node->getNodeKind() == ConstFPValNode;
    }
    static inline bool classof(const ValVar* node)
    {
        return node->getNodeKind() == ConstFPValNode;
    }
    static inline bool classof(const SVFVar* node)
    {
        return node->getNodeKind() == ConstFPValNode;
    }
    static inline bool classof(const GenericPAGNodeTy* node)
    {
        return node->getNodeKind() == ConstFPValNode;
    }
    static inline bool classof(const SVFValue* node)
    {
        return node->getNodeKind() == ConstFPValNode;
    }
 
    inline double getFPValue() const
    {
        return dval;
    }
 
    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 ConstIntValVar : public ConstDataValVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
private:
    u64_t zval;
    s64_t sval;
 
public:
 
    static inline bool classof(const ConstIntValVar*)
    {
        return true;
    }
    static inline bool classof(const ConstDataValVar* node)
    {
        return node->getNodeKind() == ConstIntValNode;
    }
    static inline bool classof(const ValVar* node)
    {
        return node->getNodeKind() == ConstIntValNode;
    }
    static inline bool classof(const SVFVar* node)
    {
        return node->getNodeKind() == ConstIntValNode;
    }
    static inline bool classof(const GenericPAGNodeTy* node)
    {
        return node->getNodeKind() == ConstIntValNode;
    }
    static inline bool classof(const SVFValue* node)
    {
        return node->getNodeKind() == ConstIntValNode;
    }
 
    s64_t getSExtValue() const
    {
        return sval;
    }
 
 
    u64_t getZExtValue() const
    {
        return zval;
    }
 
    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 ConstNullPtrValVar : public ConstDataValVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
 
public:
 
    static inline bool classof(const ConstNullPtrValVar*)
    {
        return true;
    }
    static inline bool classof(const ConstDataValVar* node)
    {
        return node->getNodeKind() == ConstNullptrValNode;
    }
    static inline bool classof(const ValVar* node)
    {
        return node->getNodeKind() == ConstNullptrValNode;
    }
    static inline bool classof(const SVFVar* node)
    {
        return node->getNodeKind() == ConstNullptrValNode;
    }
    static inline bool classof(const GenericPAGNodeTy* node)
    {
        return node->getNodeKind() == ConstNullptrValNode;
    }
    static inline bool classof(const SVFValue* node)
    {
        return node->getNodeKind() == ConstNullptrValNode;
    }
 
    ConstNullPtrValVar(NodeID i, const ICFGNode* icn, const SVFType* svfType)
        : ConstDataValVar(i,  icn, svfType, ConstNullptrValNode)
    {
 
    }
 
    virtual bool isConstDataOrAggDataButNotNullPtr() const
    {
        return false;
    }
 
    virtual const std::string toString() const;
};
 
class GlobalObjVar : public BaseObjVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
 
private:
    GlobalObjVar(NodeID i, const ICFGNode* node) : BaseObjVar(i, node, GlobalObjNode) {}
 
public:
 
    static inline bool classof(const GlobalObjVar*)
    {
        return true;
    }
    static inline bool classof(const BaseObjVar* node)
    {
        return node->getNodeKind() == GlobalObjNode;
    }
    static inline bool classof(const ObjVar* node)
    {
        return node->getNodeKind() == GlobalObjNode;
    }
    static inline bool classof(const SVFVar* node)
    {
        return node->getNodeKind() == GlobalObjNode;
    }
    static inline bool classof(const GenericPAGNodeTy* node)
    {
        return node->getNodeKind() == GlobalObjNode;
    }
    static inline bool classof(const SVFValue* node)
    {
        return node->getNodeKind() == GlobalObjNode;
    }
 
    GlobalObjVar(NodeID i, ObjTypeInfo* ti, const SVFType* svfType, const ICFGNode* node,
                 PNODEK ty = GlobalObjNode): BaseObjVar(i, ti, svfType, node, ty)
    {
 
    }
 
 
    virtual const std::string toString() const;
};
 
class ConstAggObjVar : public BaseObjVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
 
public:
 
    static inline bool classof(const ConstAggObjVar*)
    {
        return true;
    }
    static inline bool classof(const BaseObjVar* node)
    {
        return node->getNodeKind() == ConstAggObjNode;
    }
 
    static inline bool classof(const ObjVar* node)
    {
        return node->getNodeKind() == ConstAggObjNode;
    }
    static inline bool classof(const SVFVar* node)
    {
        return node->getNodeKind() == ConstAggObjNode;
    }
    static inline bool classof(const GenericPAGNodeTy* node)
    {
        return node->getNodeKind() == ConstAggObjNode;
    }
    static inline bool classof(const SVFValue* node)
    {
        return node->getNodeKind() == ConstAggObjNode;
    }
 
    ConstAggObjVar(NodeID i, ObjTypeInfo* ti, const SVFType* svfType, const ICFGNode* node)
        : BaseObjVar(i,  ti, svfType, node, ConstAggObjNode)
    {
 
    }
 
    virtual bool isConstDataOrAggData() const
    {
        return true;
    }
 
    virtual bool isConstDataOrAggDataButNotNullPtr() const
    {
        return true;
    }
 
    virtual const std::string toString() const;
};
 
class ConstDataObjVar : public BaseObjVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
 
protected:
    ConstDataObjVar(NodeID i, const ICFGNode* node) : BaseObjVar(i, node, ConstDataObjNode) {}
 
public:
    static inline bool classof(const ConstDataObjVar*)
    {
        return true;
    }
    static inline bool classof(const BaseObjVar* node)
    {
        return isConstantDataObjVarKinds(node->getNodeKind());
    }
    static inline bool classof(const SVFVar* node)
    {
        return isConstantDataObjVarKinds(node->getNodeKind());
    }
    static inline bool classof(const ObjVar* node)
    {
        return isConstantDataObjVarKinds(node->getNodeKind());
    }
    static inline bool classof(const GenericPAGNodeTy* node)
    {
        return isConstantDataObjVarKinds(node->getNodeKind());
    }
 
    static inline bool classof(const SVFValue* node)
    {
        return isConstantDataObjVarKinds(node->getNodeKind());
    }
 
    ConstDataObjVar(NodeID i, ObjTypeInfo* ti, const SVFType* svfType, const ICFGNode* node, PNODEK ty = ConstDataObjNode)
        : BaseObjVar(i, ti, svfType, node, ty)
    {
    }
 
    virtual bool isConstDataOrAggData() const
    {
        return true;
    }
 
    virtual bool isConstDataOrAggDataButNotNullPtr() const
    {
        return true;
    }
 
    virtual const std::string toString() const;
};
 
class ConstFPObjVar : public ConstDataObjVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
 
private:
    ConstFPObjVar(NodeID i, const ICFGNode* node) : ConstDataObjVar(i, node) {}
 
private:
    float dval;
 
public:
    static inline bool classof(const ConstFPObjVar*)
    {
        return true;
    }
    static inline bool classof(const ConstDataObjVar* node)
    {
        return node->getNodeKind() == SVFVar::ConstFPObjNode;
    }
    static inline bool classof(const BaseObjVar* node)
    {
        return node->getNodeKind() == SVFVar::ConstFPObjNode;
    }
 
    static inline bool classof(const SVFVar* node)
    {
        return node->getNodeKind() == SVFVar::ConstFPObjNode;
    }
 
    static inline bool classof(const ObjVar* node)
    {
        return node->getNodeKind() == SVFVar::ConstFPObjNode;
    }
 
    static inline bool classof(const GenericPAGNodeTy* node)
    {
        return node->getNodeKind() == SVFVar::ConstFPObjNode;
    }
 
    static inline bool classof(const SVFValue* node)
    {
        return node->getNodeKind() == SVFVar::ConstFPObjNode;
    }
 
    ConstFPObjVar(NodeID i, double dv, ObjTypeInfo* ti, const SVFType* svfType, const ICFGNode* node)
        : ConstDataObjVar(i, ti, svfType, node, ConstFPObjNode), dval(dv)
    {
    }
 
    inline double getFPValue() const
    {
        return dval;
    }
 
 
    virtual const std::string toString() const;
};
 
class ConstIntObjVar : public ConstDataObjVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
 
private:
    ConstIntObjVar(NodeID i, const ICFGNode* node) : ConstDataObjVar(i, node) {}
 
private:
    u64_t zval;
    s64_t sval;
 
public:
    static inline bool classof(const ConstIntObjVar*)
    {
        return true;
    }
 
    static inline bool classof(const ConstDataObjVar* node)
    {
        return node->getNodeKind() == SVFVar::ConstIntObjNode;
    }
 
    static inline bool classof(const BaseObjVar* node)
    {
        return node->getNodeKind() == SVFVar::ConstIntObjNode;
    }
 
    static inline bool classof(const SVFVar* node)
    {
        return node->getNodeKind() == SVFVar::ConstIntObjNode;
    }
    static inline bool classof(const ObjVar* node)
    {
        return node->getNodeKind() == SVFVar::ConstIntObjNode;
    }
    static inline bool classof(const GenericPAGNodeTy* node)
    {
        return node->getNodeKind() == SVFVar::ConstIntObjNode;
    }
 
    static inline bool classof(const SVFValue* node)
    {
        return node->getNodeKind() == SVFVar::ConstIntObjNode;
    }
 
    s64_t getSExtValue() const
    {
        return sval;
    }
 
 
    u64_t getZExtValue() const
    {
        return zval;
    }
 
    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)
    {
    }
 
 
    virtual const std::string toString() const;
};
 
class ConstNullPtrObjVar : public ConstDataObjVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
 
private:
    ConstNullPtrObjVar(NodeID i, const ICFGNode* node) : ConstDataObjVar(i, node) {}
 
public:
    static inline bool classof(const ConstNullPtrObjVar*)
    {
        return true;
    }
 
    static inline bool classof(const ConstDataObjVar* node)
    {
        return node->getNodeKind() == SVFVar::ConstNullptrObjNode;
    }
 
    static inline bool classof(const BaseObjVar* node)
    {
        return node->getNodeKind() == SVFVar::ConstNullptrObjNode;
    }
 
    static inline bool classof(const SVFVar* node)
    {
        return node->getNodeKind() == SVFVar::ConstNullptrObjNode;
    }
    static inline bool classof(const ObjVar* node)
    {
        return node->getNodeKind() == SVFVar::ConstNullptrObjNode;
    }
    static inline bool classof(const GenericPAGNodeTy* node)
    {
        return node->getNodeKind() == SVFVar::ConstNullptrObjNode;
    }
 
    static inline bool classof(const SVFValue* node)
    {
        return node->getNodeKind() == SVFVar::ConstNullptrObjNode;
    }
 
    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 RetValPN : public ValVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
 
private:
    const FunObjVar* callGraphNode;
private:
    RetValPN(NodeID i) : ValVar(i, RetValNode) {}
 
public:
    static inline bool classof(const RetValPN*)
    {
        return true;
    }
    static inline bool classof(const SVFVar* node)
    {
        return node->getNodeKind() == SVFVar::RetValNode;
    }
    static inline bool classof(const ValVar* node)
    {
        return node->getNodeKind() == SVFVar::RetValNode;
    }
    static inline bool classof(const GenericPAGNodeTy* node)
    {
        return node->getNodeKind() == SVFVar::RetValNode;
    }
    static inline bool classof(const SVFValue* node)
    {
        return node->getNodeKind() == SVFVar::RetValNode;
    }
 
 
    RetValPN(NodeID i, const FunObjVar* node, const SVFType* svfType, const ICFGNode* icn);
 
    inline const FunObjVar* getCallGraphNode() const
    {
        return callGraphNode;
    }
 
    virtual const FunObjVar* getFunction() const;
 
    virtual bool isPointer() const;
 
    const std::string getValueName() const;
 
    virtual const std::string toString() const;
};
 
/*
 * Unique vararg node of a procedure
 */
class VarArgValPN : public ValVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
private:
    const FunObjVar* callGraphNode;
 
private:
    VarArgValPN(NodeID i) : ValVar(i, VarargValNode) {}
 
public:
    static inline bool classof(const VarArgValPN*)
    {
        return true;
    }
    static inline bool classof(const SVFVar* node)
    {
        return node->getNodeKind() == SVFVar::VarargValNode;
    }
    static inline bool classof(const ValVar* node)
    {
        return node->getNodeKind() == SVFVar::VarargValNode;
    }
    static inline bool classof(const GenericPAGNodeTy* node)
    {
        return node->getNodeKind() == SVFVar::VarargValNode;
    }
    static inline bool classof(const SVFValue* node)
    {
        return node->getNodeKind() == SVFVar::VarargValNode;
    }
 
    VarArgValPN(NodeID i, const FunObjVar* node, const SVFType* svfType, const ICFGNode* icn)
        : ValVar(i, svfType, icn, VarargValNode), callGraphNode(node)
    {
    }
 
    virtual const FunObjVar* getFunction() const;
 
    const std::string getValueName() const;
 
    virtual bool isPointer() const
    {
        return true;
    }
    virtual const std::string toString() const;
};
 
/*
 * Dummy variable without any LLVM value
 */
class DummyValVar: public ValVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
 
public:
    static inline bool classof(const DummyValVar*)
    {
        return true;
    }
    static inline bool classof(const SVFVar* node)
    {
        return node->getNodeKind() == SVFVar::DummyValNode;
    }
    static inline bool classof(const ValVar* node)
    {
        return node->getNodeKind() == SVFVar::DummyValNode;
    }
    static inline bool classof(const GenericPAGNodeTy* node)
    {
        return node->getNodeKind() == SVFVar::DummyValNode;
    }
    static inline bool classof(const SVFValue* node)
    {
        return node->getNodeKind() == SVFVar::DummyValNode;
    }
 
    DummyValVar(NodeID i, const ICFGNode* node, const SVFType* svfType = SVFType::getSVFPtrType())
        : ValVar(i, svfType, node, DummyValNode)
    {
    }
 
    inline const std::string getValueName() const
    {
        return "dummyVal";
    }
 
    virtual bool isPointer() const
    {
        return true;
    }
 
    virtual const std::string toString() const;
};
 
/*
 * Dummy object variable
 */
class DummyObjVar: public BaseObjVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
 
private:
    DummyObjVar(NodeID i, const ICFGNode* node) : BaseObjVar(i, node, DummyObjNode) {}
 
public:
    static inline bool classof(const DummyObjVar*)
    {
        return true;
    }
    static inline bool classof(const BaseObjVar* node)
    {
        return node->getNodeKind() == SVFVar::DummyObjNode;
    }
    static inline bool classof(const SVFVar* node)
    {
        return node->getNodeKind() == SVFVar::DummyObjNode;
    }
    static inline bool classof(const ObjVar* node)
    {
        return node->getNodeKind() == SVFVar::DummyObjNode;
    }
    static inline bool classof(const GenericPAGNodeTy* node)
    {
        return node->getNodeKind() == SVFVar::DummyObjNode;
    }
 
    static inline bool classof(const SVFValue* node)
    {
        return node->getNodeKind() == SVFVar::DummyObjNode;
    }
 
    DummyObjVar(NodeID i, ObjTypeInfo* ti, const ICFGNode* node, const SVFType* svfType = SVFType::getSVFPtrType())
        : BaseObjVar(i, ti, svfType, node, DummyObjNode)
    {
    }
 
    inline const std::string getValueName() const
    {
        return "dummyObj";
    }
 
    virtual bool isPointer() const
    {
        return true;
    }
 
    virtual const std::string toString() const;
};
 
} // End namespace SVF
 
#endif /* INCLUDE_SVFIR_SVFVARIABLE_H_ */