SVFVariables.h

Go to the documentation of this file.

//===- SVFSymbols.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
 */
 
#ifndef INCLUDE_SVFIR_SVFVARIABLE_H_
#define INCLUDE_SVFIR_SVFVARIABLE_H_
 
#include "Graphs/GenericGraph.h"
#include "SVFIR/SymbolTableInfo.h"
#include "SVFIR/SVFStatements.h"
 
namespace SVF
{
 
class SVFVar;
/*
 * SVFIR program variables (PAGNodes)
 */
typedef GenericNode<SVFVar, SVFStmt> GenericPAGNodeTy;
class SVFVar : public GenericPAGNodeTy
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
    friend class IRGraph;
    friend class SVFIR;
    friend class VFG;
 
public:
    typedef GNodeK PNODEK;
    typedef s64_t GEdgeKind;
 
protected:
    const SVFValue* value; 
    SVFStmt::KindToSVFStmtMapTy InEdgeKindToSetMap;
    SVFStmt::KindToSVFStmtMapTy OutEdgeKindToSetMap;
    bool isPtr; 
    const SVFFunction* func; 
 
    SVFVar(NodeID i, PNODEK k) : GenericPAGNodeTy(i, k), value{} {}
 
public:
    SVFVar(const SVFValue* val, NodeID i, PNODEK k);
    virtual ~SVFVar() {}
 
 
    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;
    }
 
    inline virtual const SVFType* getType() const
    {
        return value ? value->getType() : nullptr;
    }
 
    inline bool hasValue() const
    {
        return value != nullptr;
    }
    virtual inline bool isPointer() const
    {
        return isPtr;
    }
    bool isConstDataOrAggDataButNotNullPtr() const;
 
    virtual bool isIsolatedNode() const;
 
    // TODO: (Optimization) Should it return const reference instead of value?
    virtual const std::string getValueName() const = 0;
 
    virtual inline const SVFFunction* getFunction() const
    {
        // Return cached function if available
        if(func) return func;
 
        // If we have an associated LLVM value, check its parent function
        if (value)
        {
            // For instructions, return the function containing the parent basic block
            if (auto inst = SVFUtil::dyn_cast<SVFInstruction>(value))
            {
                return inst->getParent()->getParent();
            }
            // For function arguments, return their parent function
            else if (auto arg = SVFUtil::dyn_cast<SVFArgument>(value))
            {
                return arg->getParent();
            }
        }
 
        // Return nullptr for globals/constants with no parent function
        return nullptr;
    }
 
    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() && "The node does not have such kind of edge");
        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() && "The node does not have such kind of edge");
        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() && "The node does not have such kind of edge");
        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() && "The node does not have such kind of edge");
        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 SVFBaseNode* node)
    {
        return isSVFVarKind(node->getNodeKind());
    }
 
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 SVFBaseNode* node)
    {
        return isValVarKinds(node->getNodeKind());
    }
 
    ValVar(const SVFValue* val, NodeID i, PNODEK ty = ValNode, const ICFGNode* node = nullptr)
        : SVFVar(val, i, ty), icfgNode(node)
    {
    }
    inline const std::string getValueName() const
    {
        if (value)
            return value->getName();
        return "";
    }
 
    const ICFGNode* getICFGNode() const
    {
        return icfgNode;
    }
 
    virtual const std::string toString() const;
};
 
/*
 * Memory Object variable
 */
class ObjVar: public SVFVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
 
protected:
    const MemObj* mem;  
    ObjVar(NodeID i, PNODEK ty = ObjNode) : SVFVar(i, ty), mem{} {}
    ObjVar(const SVFValue* val, NodeID i, const MemObj* m, PNODEK ty = ObjNode) :
        SVFVar(val, i, ty), mem(m)
    {
    }
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 SVFBaseNode* node)
    {
        return isObjVarKinds(node->getNodeKind());
    }
 
    const MemObj* getMemObj() const
    {
        return mem;
    }
 
    virtual const std::string getValueName() const
    {
        if (value)
            return value->getName();
        return "";
    }
    inline virtual const SVFType* getType() const
    {
        return mem->getType();
    }
 
    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
    NodeID base;    // base node id
    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;
    }
 
    GepValVar(NodeID baseID, const SVFValue* val, NodeID i, const AccessPath& ap,
              const SVFType* ty)
        : ValVar(val, i, GepValNode), ap(ap), base(baseID), gepValType(ty)
    {
    }
 
    inline APOffset getConstantFieldIdx() const
    {
        return ap.getConstantStructFldIdx();
    }
 
    inline NodeID getBaseNode(void) const
    {
        return base;
    }
 
    inline const std::string getValueName() const
    {
        if (value)
            return value->getName() + "_" +
                   std::to_string(getConstantFieldIdx());
        return "offset_" + std::to_string(getConstantFieldIdx());
    }
 
    inline const SVFType* getType() const
    {
        return gepValType;
    }
 
    virtual const std::string toString() const;
};
 
 
/*
 * Gep Obj variable, this is dynamic generated for field sensitive analysis
 * Each gep obj variable is one field of a MemObj (base)
 */
class GepObjVar: public ObjVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
 
private:
    APOffset apOffset = 0;
    NodeID base = 0;
 
    //  only for reading from file when we don't have MemObj*
    GepObjVar(NodeID i, PNODEK ty = GepObjNode) : ObjVar(i, ty) {}
 
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 SVFBaseNode* node)
    {
        return node->getNodeKind() == SVFVar::GepObjNode;
    }
 
    GepObjVar(const MemObj* mem, NodeID i, const APOffset& apOffset,
              PNODEK ty = GepObjNode)
        : ObjVar(mem->getValue(), i, mem, ty), apOffset(apOffset)
    {
        base = mem->getId();
    }
 
    inline APOffset getConstantFieldIdx() const
    {
        return apOffset;
    }
 
    inline void setBaseNode(NodeID bs)
    {
        this->base = bs;
    }
 
    inline NodeID getBaseNode(void) const
    {
        return base;
    }
 
    inline virtual const SVFType* getType() const
    {
        return SymbolTableInfo::SymbolInfo()->getFlatternedElemType(mem->getType(), apOffset);
    }
 
    inline const std::string getValueName() const
    {
        if (value)
            return value->getName() + "_" + std::to_string(apOffset);
        return "offset_" + std::to_string(apOffset);
    }
 
    virtual const std::string toString() const;
};
 
/*
 * Field-insensitive Gep Obj variable, this is dynamic generated for field sensitive analysis
 * Each field-insensitive gep obj node represents all fields of a MemObj (base)
 */
class BaseObjVar : public ObjVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
 
protected:
    BaseObjVar(NodeID i, PNODEK ty = BaseObjNode) : ObjVar(i, ty) {}
 
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 SVFBaseNode* node)
    {
        return isBaseObjVarKinds(node->getNodeKind());
    }
 
    BaseObjVar(const SVFValue* val, NodeID i, const MemObj* mem,
               PNODEK ty = BaseObjNode)
        : ObjVar(val, i, mem, ty)
    {
    }
 
    inline const std::string getValueName() const
    {
        if (value)
            return value->getName() + " (base object)";
        return " (base object)";
    }
 
    virtual const std::string toString() const;
};
 
 
class HeapObjVar: public BaseObjVar
{
 
    friend class SVFIRWriter;
    friend class SVFIRReader;
 
protected:
    HeapObjVar(NodeID i, PNODEK ty = HeapObjNode) : BaseObjVar(i, ty) {}
 
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 SVFBaseNode* node)
    {
        return node->getNodeKind() == HeapObjNode;
    }
 
    HeapObjVar(const SVFFunction* func, const SVFType* svfType, NodeID i,
               const MemObj* mem, PNODEK ty = 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, PNODEK ty = StackObjNode) : BaseObjVar(i, ty) {}
 
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 SVFBaseNode* node)
    {
        return node->getNodeKind() == StackObjNode;
    }
 
    StackObjVar(const SVFFunction* f, const SVFType* svfType, NodeID i,
                const MemObj* mem, PNODEK ty = StackObjNode);
 
    inline const std::string getValueName() const
    {
        return " (stack base object)";
    }
 
    virtual const std::string toString() const;
};
 
 
class CallGraphNode;
 
class FunValVar : public ValVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
private:
    const CallGraphNode* callGraphNode;
 
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 SVFBaseNode* node)
    {
        return node->getNodeKind() == FunValNode;
    }
 
    inline const CallGraphNode* getCallGraphNode() const
    {
        return callGraphNode;
    }
 
    FunValVar(const CallGraphNode* cgn, NodeID i, const ICFGNode* icn,
              PNODEK ty = FunValNode);
 
    virtual const std::string toString() const;
};
 
class FunObjVar : public BaseObjVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
 
private:
    const CallGraphNode* callGraphNode;
 
private:
    FunObjVar(NodeID i, PNODEK ty = FunObjNode) : BaseObjVar(i, ty) {}
 
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 SVFBaseNode* node)
    {
        return node->getNodeKind() == FunObjNode;
    }
 
    FunObjVar(const CallGraphNode* cgNode, NodeID i, const MemObj* mem,
              PNODEK ty = FunObjNode);
 
    inline const CallGraphNode* getCallGraphNode() const
    {
        return callGraphNode;
    }
 
    virtual bool isIsolatedNode() const;
 
    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 SVFBaseNode* node)
    {
        return node->getNodeKind() == GlobalValNode;
    }
 
    GlobalValVar(const SVFValue* val, NodeID i, const ICFGNode* icn,
                 PNODEK ty = GlobalValNode)
        : ValVar(val, i, ty, icn)
    {
    }
 
    virtual const std::string toString() const;
};
 
class ConstantDataValVar: public ValVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
 
public:
 
    static inline bool classof(const ConstantDataValVar*)
    {
        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 SVFBaseNode* node)
    {
        return isConstantDataValVar(node->getNodeKind());
    }
 
    ConstantDataValVar(const SVFValue* val, NodeID i, const ICFGNode* icn,
                       PNODEK ty = ConstantDataValNode)
        : ValVar(val, i,  ty,  icn)
    {
 
    }
 
    virtual const std::string toString() const;
};
 
class BlackHoleVar: public ConstantDataValVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
 
public:
 
    static inline bool classof(const BlackHoleVar*)
    {
        return true;
    }
    static inline bool classof(const ConstantDataValVar* node)
    {
        return node->getNodeKind() == BlackHoleNode;
    }
    static inline bool classof(const ValVar* node)
    {
        return node->getNodeKind() == BlackHoleNode;
    }
    static inline bool classof(const SVFVar* node)
    {
        return node->getNodeKind() == BlackHoleNode;
    }
    static inline bool classof(const GenericPAGNodeTy* node)
    {
        return node->getNodeKind() == BlackHoleNode;
    }
    static inline bool classof(const SVFBaseNode* node)
    {
        return node->getNodeKind() == BlackHoleNode;
    }
 
    BlackHoleVar(NodeID i, PNODEK ty = BlackHoleNode)
        : ConstantDataValVar(nullptr, i,  nullptr, ty)
    {
 
    }
 
    virtual const std::string toString() const
    {
        return "BlackHoleVar";
    }
};
 
class ConstantFPValVar: public ConstantDataValVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
private:
    double dval;
 
public:
 
    static inline bool classof(const ConstantFPValVar*)
    {
        return true;
    }
    static inline bool classof(const ConstantDataValVar* node)
    {
        return node->getNodeKind() == ConstantFPValNode;
    }
    static inline bool classof(const ValVar* node)
    {
        return node->getNodeKind() == ConstantFPValNode;
    }
    static inline bool classof(const SVFVar* node)
    {
        return node->getNodeKind() == ConstantFPValNode;
    }
    static inline bool classof(const GenericPAGNodeTy* node)
    {
        return node->getNodeKind() == ConstantFPValNode;
    }
    static inline bool classof(const SVFBaseNode* node)
    {
        return node->getNodeKind() == ConstantFPValNode;
    }
 
    inline double getFPValue() const
    {
        return dval;
    }
 
    ConstantFPValVar(const SVFValue* val, double dv, NodeID i, const ICFGNode* icn,
                     PNODEK ty = ConstantFPValNode)
        : ConstantDataValVar(val, i,  icn, ty), dval(dv)
    {
 
    }
 
    virtual const std::string toString() const;
};
 
class ConstantIntValVar: public ConstantDataValVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
private:
    u64_t zval;
    s64_t sval;
 
public:
 
    static inline bool classof(const ConstantIntValVar*)
    {
        return true;
    }
    static inline bool classof(const ConstantDataValVar* node)
    {
        return node->getNodeKind() == ConstantIntValNode;
    }
    static inline bool classof(const ValVar* node)
    {
        return node->getNodeKind() == ConstantIntValNode;
    }
    static inline bool classof(const SVFVar* node)
    {
        return node->getNodeKind() == ConstantIntValNode;
    }
    static inline bool classof(const GenericPAGNodeTy* node)
    {
        return node->getNodeKind() == ConstantIntValNode;
    }
    static inline bool classof(const SVFBaseNode* node)
    {
        return node->getNodeKind() == ConstantIntValNode;
    }
 
    s64_t getSExtValue() const
    {
        return sval;
    }
 
 
    u64_t getZExtValue() const
    {
        return zval;
    }
 
    ConstantIntValVar(const SVFValue* val, s64_t sv, u64_t zv, NodeID i, const ICFGNode* icn,
                      PNODEK ty = ConstantIntValNode)
        : ConstantDataValVar(val, i,  icn, ty), zval(zv), sval(sv)
    {
 
    }
    virtual const std::string toString() const;
};
 
class ConstantNullPtrValVar: public ConstantDataValVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
 
public:
 
    static inline bool classof(const ConstantNullPtrValVar*)
    {
        return true;
    }
    static inline bool classof(const ConstantDataValVar* node)
    {
        return node->getNodeKind() == ConstantNullptrValNode;
    }
    static inline bool classof(const ValVar* node)
    {
        return node->getNodeKind() == ConstantNullptrValNode;
    }
    static inline bool classof(const SVFVar* node)
    {
        return node->getNodeKind() == ConstantNullptrValNode;
    }
    static inline bool classof(const GenericPAGNodeTy* node)
    {
        return node->getNodeKind() == ConstantNullptrValNode;
    }
    static inline bool classof(const SVFBaseNode* node)
    {
        return node->getNodeKind() == ConstantNullptrValNode;
    }
 
    ConstantNullPtrValVar(const SVFValue* val, NodeID i, const ICFGNode* icn,
                          PNODEK ty = ConstantNullptrValNode)
        : ConstantDataValVar(val, i,  icn, ty)
    {
 
    }
 
    virtual const std::string toString() const;
};
 
class GlobalObjVar : public BaseObjVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
 
private:
    GlobalObjVar(NodeID i, PNODEK ty = GlobalObjNode) : BaseObjVar(i, ty) {}
 
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 SVFBaseNode* node)
    {
        return node->getNodeKind() == GlobalObjNode;
    }
 
    GlobalObjVar(const SVFValue* val, NodeID i, const MemObj* mem,
                 PNODEK ty = GlobalObjNode): BaseObjVar(val, i,mem,ty)
    {
 
    }
 
 
    virtual const std::string toString() const;
};
 
class ConstantDataObjVar: public BaseObjVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
 
protected:
    ConstantDataObjVar(NodeID i) : BaseObjVar(i, ConstantDataObjNode) {}
 
public:
    static inline bool classof(const ConstantDataObjVar*)
    {
        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 SVFBaseNode* node)
    {
        return isConstantDataObjVarKinds(node->getNodeKind());
    }
 
    ConstantDataObjVar(const SVFValue* val, NodeID i, const MemObj* m, PNODEK ty = ConstantDataObjNode)
        : BaseObjVar(val, i, m, ty)
    {
    }
 
    virtual const std::string toString() const;
};
 
class ConstantFPObjVar: public ConstantDataObjVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
 
private:
    ConstantFPObjVar(NodeID i) : ConstantDataObjVar(i) {}
 
private:
    float dval;
 
public:
    static inline bool classof(const ConstantFPObjVar*)
    {
        return true;
    }
    static inline bool classof(const ConstantDataObjVar* node)
    {
        return node->getNodeKind() == SVFVar::ConstantFPObjNode;
    }
    static inline bool classof(const BaseObjVar* node)
    {
        return node->getNodeKind() == SVFVar::ConstantFPObjNode;
    }
 
    static inline bool classof(const SVFVar* node)
    {
        return node->getNodeKind() == SVFVar::ConstantFPObjNode;
    }
 
    static inline bool classof(const ObjVar* node)
    {
        return node->getNodeKind() == SVFVar::ConstantFPObjNode;
    }
 
    static inline bool classof(const GenericPAGNodeTy* node)
    {
        return node->getNodeKind() == SVFVar::ConstantFPObjNode;
    }
 
    static inline bool classof(const SVFBaseNode* node)
    {
        return node->getNodeKind() == SVFVar::ConstantFPObjNode;
    }
 
    ConstantFPObjVar(const SVFValue* val, double dv, NodeID i, const MemObj* m, PNODEK ty = ConstantFPObjNode)
        : ConstantDataObjVar(val, i, m, ty), dval(dv)
    {
    }
 
    inline double getFPValue() const
    {
        return dval;
    }
 
 
    virtual const std::string toString() const;
};
 
class ConstantIntObjVar: public ConstantDataObjVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
 
private:
    ConstantIntObjVar(NodeID i) : ConstantDataObjVar(i) {}
 
private:
    u64_t zval;
    s64_t sval;
 
public:
    static inline bool classof(const ConstantIntObjVar*)
    {
        return true;
    }
 
    static inline bool classof(const ConstantDataObjVar* node)
    {
        return node->getNodeKind() == SVFVar::ConstantIntObjNode;
    }
 
    static inline bool classof(const BaseObjVar* node)
    {
        return node->getNodeKind() == SVFVar::ConstantIntObjNode;
    }
 
    static inline bool classof(const SVFVar* node)
    {
        return node->getNodeKind() == SVFVar::ConstantIntObjNode;
    }
    static inline bool classof(const ObjVar* node)
    {
        return node->getNodeKind() == SVFVar::ConstantIntObjNode;
    }
    static inline bool classof(const GenericPAGNodeTy* node)
    {
        return node->getNodeKind() == SVFVar::ConstantIntObjNode;
    }
 
    static inline bool classof(const SVFBaseNode* node)
    {
        return node->getNodeKind() == SVFVar::ConstantIntObjNode;
    }
 
    s64_t getSExtValue() const
    {
        return sval;
    }
 
 
    u64_t getZExtValue() const
    {
        return zval;
    }
 
    ConstantIntObjVar(const SVFValue* val, s64_t sv, u64_t zv, NodeID i, const MemObj* m, PNODEK ty = ConstantIntObjNode)
        : ConstantDataObjVar(val, i, m, ty), zval(zv), sval(sv)
    {
    }
 
 
    virtual const std::string toString() const;
};
 
class ConstantNullPtrObjVar: public ConstantDataObjVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
 
private:
    ConstantNullPtrObjVar(NodeID i) : ConstantDataObjVar(i) {}
 
public:
    static inline bool classof(const ConstantNullPtrObjVar*)
    {
        return true;
    }
 
    static inline bool classof(const ConstantDataObjVar* node)
    {
        return node->getNodeKind() == SVFVar::ConstantNullptrObjNode;
    }
 
    static inline bool classof(const BaseObjVar* node)
    {
        return node->getNodeKind() == SVFVar::ConstantNullptrObjNode;
    }
 
    static inline bool classof(const SVFVar* node)
    {
        return node->getNodeKind() == SVFVar::ConstantNullptrObjNode;
    }
    static inline bool classof(const ObjVar* node)
    {
        return node->getNodeKind() == SVFVar::ConstantNullptrObjNode;
    }
    static inline bool classof(const GenericPAGNodeTy* node)
    {
        return node->getNodeKind() == SVFVar::ConstantNullptrObjNode;
    }
 
    static inline bool classof(const SVFBaseNode* node)
    {
        return node->getNodeKind() == SVFVar::ConstantNullptrObjNode;
    }
 
    ConstantNullPtrObjVar(const SVFValue* val, NodeID i, const MemObj* m, PNODEK ty = ConstantNullptrObjNode)
        : ConstantDataObjVar(val, i, m, ty)
    {
    }
 
 
    virtual const std::string toString() const;
};
/*
 * Unique Return node of a procedure
 */
class RetPN: public ValVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
 
private:
    const CallGraphNode* callGraphNode;
private:
    RetPN(NodeID i) : ValVar(i, RetNode) {}
 
public:
    static inline bool classof(const RetPN*)
    {
        return true;
    }
    static inline bool classof(const SVFVar* node)
    {
        return node->getNodeKind() == SVFVar::RetNode;
    }
    static inline bool classof(const ValVar* node)
    {
        return node->getNodeKind() == SVFVar::RetNode;
    }
    static inline bool classof(const GenericPAGNodeTy* node)
    {
        return node->getNodeKind() == SVFVar::RetNode;
    }
    static inline bool classof(const SVFBaseNode* node)
    {
        return node->getNodeKind() == SVFVar::RetNode;
    }
 
 
    RetPN(const CallGraphNode* node, NodeID i);
 
    inline const CallGraphNode* getCallGraphNode() const
    {
        return callGraphNode;
    }
 
    virtual const SVFFunction* getFunction() const;
 
    const std::string getValueName() const;
 
    virtual const std::string toString() const;
};
 
/*
 * Unique vararg node of a procedure
 */
class VarArgPN: public ValVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
private:
    const CallGraphNode* callGraphNode;
 
private:
    VarArgPN(NodeID i) : ValVar(i, VarargNode) {}
 
public:
    static inline bool classof(const VarArgPN*)
    {
        return true;
    }
    static inline bool classof(const SVFVar* node)
    {
        return node->getNodeKind() == SVFVar::VarargNode;
    }
    static inline bool classof(const ValVar* node)
    {
        return node->getNodeKind() == SVFVar::VarargNode;
    }
    static inline bool classof(const GenericPAGNodeTy* node)
    {
        return node->getNodeKind() == SVFVar::VarargNode;
    }
    static inline bool classof(const SVFBaseNode* node)
    {
        return node->getNodeKind() == SVFVar::VarargNode;
    }
 
    VarArgPN(const CallGraphNode* node, NodeID i) : ValVar(nullptr, i, VarargNode), callGraphNode(node) {}
 
    virtual const SVFFunction* getFunction() const;
 
    const std::string getValueName() const;
 
    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 SVFBaseNode* node)
    {
        return node->getNodeKind() == SVFVar::DummyValNode;
    }
 
    DummyValVar(NodeID i) : ValVar(nullptr, i, DummyValNode) {}
 
    inline const std::string getValueName() const
    {
        return "dummyVal";
    }
 
    virtual const std::string toString() const;
};
 
/*
 * Dummy object variable
 */
class DummyObjVar: public BaseObjVar
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
 
private:
    DummyObjVar(NodeID i) : BaseObjVar(i, 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 SVFBaseNode* node)
    {
        return node->getNodeKind() == SVFVar::DummyObjNode;
    }
 
    DummyObjVar(NodeID i, const MemObj* m, PNODEK ty = DummyObjNode)
        : BaseObjVar(nullptr, i, m, ty)
    {
    }
 
    inline const std::string getValueName() const
    {
        return "dummyObj";
    }
 
    virtual const std::string toString() const;
};
 
} // End namespace SVF
 
#endif /* INCLUDE_SVFIR_SVFVARIABLE_H_ */