VFGNode.h

Go to the documentation of this file.

//===- VFGNode.h ----------------------------------------------------------------//
//
//                     SVF: Static Value-Flow Analysis
//
// Copyright (C) <2013-2018>  <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/>.
//
//===----------------------------------------------------------------------===//
 
/*
 * VFGNode.h
 *
 *  Created on: 18 Sep. 2018
 *      Author: Yulei Sui
 */
 
#ifndef INCLUDE_UTIL_VFGNODE_H_
#define INCLUDE_UTIL_VFGNODE_H_
 
#include "Graphs/GenericGraph.h"
#include "Graphs/SVFGEdge.h"
#include "Graphs/ICFGNode.h"
#include "SVFIR/SVFIR.h"
 
namespace SVF
{
 
typedef GenericNode<VFGNode,VFGEdge> GenericVFGNodeTy;
class VFGNode : public GenericVFGNodeTy
{
 
public:
    typedef GNodeK VFGNodeK;
 
    typedef VFGEdge::VFGEdgeSetTy::iterator iterator;
    typedef VFGEdge::VFGEdgeSetTy::const_iterator const_iterator;
    typedef Set<const CallPE*> CallPESet;
    typedef Set<const RetPE*> RetPESet;
 
public:
    VFGNode(NodeID i, VFGNodeK k): GenericVFGNodeTy(i,k), icfgNode(nullptr)
    {
 
    }
 
    virtual const ICFGNode* getICFGNode() const
    {
        return icfgNode;
    }
 
    virtual void setICFGNode(const ICFGNode* node )
    {
        icfgNode = node;
    }
 
    virtual const FunObjVar* getFun() const
    {
        return icfgNode->getFun();
    }
 
    virtual const SVFVar* getValue() const
    {
        return nullptr;
    }
 
    virtual const NodeBS getDefSVFVars() const = 0;
 
 
    friend OutStream& operator<< (OutStream &o, const VFGNode &node)
    {
        o << node.toString();
        return o;
    }
 
    virtual const std::string toString() const;
 
    static inline bool classof(const VFGNode *)
    {
        return true;
    }
 
    static inline bool classof(const GenericVFGNodeTy * node)
    {
        return isVFGNodeKinds(node->getNodeKind());
    }
 
 
    static inline bool classof(const SVFValue* node)
    {
        return isVFGNodeKinds(node->getNodeKind());
    }
 
protected:
    const ICFGNode* icfgNode;
};
 
class StmtVFGNode : public VFGNode
{
 
private:
    const SVFStmt* svfStmt;
 
public:
    StmtVFGNode(NodeID id, const SVFStmt* e, VFGNodeK k): VFGNode(id,k), svfStmt(e)
    {
    }
 
    inline bool isPTANode() const
    {
        return svfStmt->isPTAEdge();
    }
 
    inline const SVFStmt* getSVFStmt() const
    {
        return svfStmt;
    }
 
    inline NodeID getSrcNodeID() const
    {
        return svfStmt->getSrcID();
    }
 
    inline NodeID getDstNodeID() const
    {
        return svfStmt->getDstID();
    }
 
    inline SVFVar* getSrcNode() const
    {
        return svfStmt->getSrcNode();
    }
 
    inline SVFVar* getDstNode() const
    {
        return svfStmt->getDstNode();
    }
 
 
    static inline bool classof(const StmtVFGNode *)
    {
        return true;
    }
    static inline bool classof(const VFGNode *node)
    {
        return isStmtVFGNodeKinds(node->getNodeKind());
    }
    static inline bool classof(const GenericVFGNodeTy *node)
    {
        return isStmtVFGNodeKinds(node->getNodeKind());
    }
    static inline bool classof(const SVFValue*node)
    {
        return isStmtVFGNodeKinds(node->getNodeKind());
    }
 
    const SVFVar* getValue() const override;
    const std::string toString() const override;
};
 
class LoadVFGNode: public StmtVFGNode
{
private:
    LoadVFGNode();                      
    LoadVFGNode(const LoadVFGNode &);  
    void operator=(const LoadVFGNode &); 
 
public:
    LoadVFGNode(NodeID id, const LoadStmt* edge): StmtVFGNode(id, edge,Load)
    {
 
    }
    inline const ValVar* getSrcNode() const
    {
        return SVFUtil::cast<ValVar>(StmtVFGNode::getSrcNode());
    }
    inline const ValVar* getDstNode() const
    {
        return SVFUtil::cast<ValVar>(StmtVFGNode::getDstNode());
    }
    inline const ValVar* getRHSVar() const
    {
        return getSrcNode();
    }
    inline const ValVar* getLHSVar() const
    {
        return getDstNode();
    }
 
    static inline bool classof(const LoadVFGNode *)
    {
        return true;
    }
    static inline bool classof(const StmtVFGNode *node)
    {
        return node->getNodeKind() == Load;
    }
    static inline bool classof(const VFGNode *node)
    {
        return node->getNodeKind() == Load;
    }
    static inline bool classof(const GenericVFGNodeTy *node)
    {
        return node->getNodeKind() == Load;
    }
    static inline bool classof(const SVFValue*node)
    {
        return node->getNodeKind() == Load;
    }
 
    const NodeBS getDefSVFVars() const override;
 
    const std::string toString() const override;
};
 
class StoreVFGNode: public StmtVFGNode
{
private:
    StoreVFGNode();                      
    StoreVFGNode(const StoreVFGNode &);  
    void operator=(const StoreVFGNode &); 
 
public:
    StoreVFGNode(NodeID id,const StoreStmt* edge): StmtVFGNode(id,edge,Store)
    {
 
    }
    inline const ValVar* getSrcNode() const
    {
        return SVFUtil::cast<ValVar>(StmtVFGNode::getSrcNode());
    }
    inline const ValVar* getDstNode() const
    {
        return SVFUtil::cast<ValVar>(StmtVFGNode::getDstNode());
    }
    inline const ValVar* getRHSVar() const
    {
        return getSrcNode();
    }
    inline const ValVar* getLHSVar() const
    {
        return getDstNode();
    }
 
    static inline bool classof(const StoreVFGNode *)
    {
        return true;
    }
    static inline bool classof(const StmtVFGNode *node)
    {
        return node->getNodeKind() == Store;
    }
    static inline bool classof(const VFGNode *node)
    {
        return node->getNodeKind() == Store;
    }
    static inline bool classof(const GenericVFGNodeTy *node)
    {
        return node->getNodeKind() == Store;
    }
    static inline bool classof(const SVFValue*node)
    {
        return node->getNodeKind() == Store;
    }
 
    const NodeBS getDefSVFVars() const override;
 
    const std::string toString() const override;
};
 
class CopyVFGNode: public StmtVFGNode
{
private:
    CopyVFGNode();                      
    CopyVFGNode(const CopyVFGNode &);  
    void operator=(const CopyVFGNode &); 
 
public:
    CopyVFGNode(NodeID id,const CopyStmt* copy): StmtVFGNode(id,copy,Copy)
    {
 
    }
    inline const ValVar* getSrcNode() const
    {
        return SVFUtil::cast<ValVar>(StmtVFGNode::getSrcNode());
    }
    inline const ValVar* getDstNode() const
    {
        return SVFUtil::cast<ValVar>(StmtVFGNode::getDstNode());
    }
    inline const ValVar* getRHSVar() const
    {
        return getSrcNode();
    }
    inline const ValVar* getLHSVar() const
    {
        return getDstNode();
    }
 
    static inline bool classof(const CopyVFGNode *)
    {
        return true;
    }
    static inline bool classof(const StmtVFGNode *node)
    {
        return node->getNodeKind() == Copy;
    }
    static inline bool classof(const VFGNode *node)
    {
        return node->getNodeKind() == Copy;
    }
    static inline bool classof(const GenericVFGNodeTy *node)
    {
        return node->getNodeKind() == Copy;
    }
    static inline bool classof(const SVFValue*node)
    {
        return node->getNodeKind() == Copy;
    }
 
    const NodeBS getDefSVFVars() const override;
 
    const std::string toString() const override;
};
 
 
class CmpVFGNode: public VFGNode
{
public:
    typedef Map<u32_t,const ValVar*> OPVers;
protected:
    const ValVar* res;
    OPVers opVers;
 
private:
    CmpVFGNode();                      
    CmpVFGNode(const CmpVFGNode &);  
    void operator=(const CmpVFGNode &); 
 
public:
    CmpVFGNode(NodeID id,const ValVar* r): VFGNode(id,Cmp), res(r) { }
 
    static inline bool classof(const CmpVFGNode *)
    {
        return true;
    }
    static inline bool classof(const VFGNode *node)
    {
        return node->getNodeKind() == Cmp;
    }
    static inline bool classof(const GenericVFGNodeTy *node)
    {
        return node->getNodeKind() == Cmp;
    }
    static inline bool classof(const SVFValue*node)
    {
        return node->getNodeKind() == Cmp;
    }
 
    inline const ValVar* getOpVer(u32_t pos) const
    {
        OPVers::const_iterator it = opVers.find(pos);
        assert(it!=opVers.end() && "version is nullptr, did not rename?");
        return it->second;
    }
    inline void setOpVer(u32_t pos, const ValVar* node)
    {
        opVers[pos] = node;
    }
    inline const ValVar* getRes() const
    {
        return res;
    }
    inline u32_t getOpVerNum() const
    {
        return opVers.size();
    }
    inline OPVers::const_iterator opVerBegin() const
    {
        return opVers.begin();
    }
    inline OPVers::const_iterator opVerEnd() const
    {
        return opVers.end();
    }
 
    const NodeBS getDefSVFVars() const override;
 
    const SVFVar* getValue() const override;
 
 
    const std::string toString() const override;
};
 
 
class BinaryOPVFGNode: public VFGNode
{
public:
    typedef Map<u32_t,const ValVar*> OPVers;
protected:
    const ValVar* res;
    OPVers opVers;
 
private:
    BinaryOPVFGNode();                      
    BinaryOPVFGNode(const BinaryOPVFGNode &);  
    void operator=(const BinaryOPVFGNode &); 
 
public:
    BinaryOPVFGNode(NodeID id,const ValVar* r): VFGNode(id,BinaryOp), res(r) { }
 
    static inline bool classof(const BinaryOPVFGNode *)
    {
        return true;
    }
    static inline bool classof(const VFGNode *node)
    {
        return node->getNodeKind() == BinaryOp;
    }
    static inline bool classof(const GenericVFGNodeTy *node)
    {
        return node->getNodeKind() == BinaryOp;
    }
    static inline bool classof(const SVFValue*node)
    {
        return node->getNodeKind() == BinaryOp;
    }
 
    inline const ValVar* getOpVer(u32_t pos) const
    {
        OPVers::const_iterator it = opVers.find(pos);
        assert(it!=opVers.end() && "version is nullptr, did not rename?");
        return it->second;
    }
    inline void setOpVer(u32_t pos, const ValVar* node)
    {
        opVers[pos] = node;
    }
    inline const ValVar* getRes() const
    {
        return res;
    }
    inline u32_t getOpVerNum() const
    {
        return opVers.size();
    }
    inline OPVers::const_iterator opVerBegin() const
    {
        return opVers.begin();
    }
    inline OPVers::const_iterator opVerEnd() const
    {
        return opVers.end();
    }
 
    const NodeBS getDefSVFVars() const override;
 
    const SVFVar* getValue() const override;
    const std::string toString() const override;
};
 
class UnaryOPVFGNode: public VFGNode
{
public:
    typedef Map<u32_t,const ValVar*> OPVers;
protected:
    const ValVar* res;
    OPVers opVers;
 
private:
    UnaryOPVFGNode();                      
    UnaryOPVFGNode(const UnaryOPVFGNode &);  
    void operator=(const UnaryOPVFGNode &); 
 
public:
    UnaryOPVFGNode(NodeID id, const ValVar *r) : VFGNode(id, UnaryOp), res(r) { }
 
    static inline bool classof(const UnaryOPVFGNode *)
    {
        return true;
    }
    static inline bool classof(const VFGNode *node)
    {
        return node->getNodeKind() == UnaryOp;
    }
    static inline bool classof(const GenericVFGNodeTy *node)
    {
        return node->getNodeKind() == UnaryOp;
    }
    static inline bool classof(const SVFValue*node)
    {
        return node->getNodeKind() == UnaryOp;
    }
 
    inline const ValVar* getOpVer(u32_t pos) const
    {
        OPVers::const_iterator it = opVers.find(pos);
        assert(it!=opVers.end() && "version is nullptr, did not rename?");
        return it->second;
    }
    inline void setOpVer(u32_t pos, const ValVar* node)
    {
        opVers[pos] = node;
    }
    inline const ValVar* getRes() const
    {
        return res;
    }
    inline const ValVar* getOpVar() const
    {
        assert(getOpVerNum()==1 && "UnaryNode can only have one operand!");
        return getOpVer(0);
    }
    inline u32_t getOpVerNum() const
    {
        return opVers.size();
    }
    inline OPVers::const_iterator opVerBegin() const
    {
        return opVers.begin();
    }
    inline OPVers::const_iterator opVerEnd() const
    {
        return opVers.end();
    }
 
    const NodeBS getDefSVFVars() const override;
 
    virtual const std::string toString() const override;
};
 
/*
* Branch VFGNode including if/else and switch statements
*/
class BranchVFGNode: public VFGNode
{
private:
    BranchVFGNode();                      
    BranchVFGNode(const BranchVFGNode &);  
    void operator=(const BranchVFGNode &); 
    const BranchStmt* brstmt;
public:
    BranchVFGNode(NodeID id, const BranchStmt* r) : VFGNode(id, Branch), brstmt(r) { }
 
    static inline bool classof(const BranchVFGNode *)
    {
        return true;
    }
    static inline bool classof(const VFGNode *node)
    {
        return node->getNodeKind() == Branch;
    }
    static inline bool classof(const GenericVFGNodeTy *node)
    {
        return node->getNodeKind() == Branch;
    }
    static inline bool classof(const SVFValue*node)
    {
        return node->getNodeKind() == Branch;
    }
 
    const BranchStmt* getBranchStmt() const
    {
        return brstmt;
    }
    u32_t getNumSuccessors() const
    {
        return brstmt->getNumSuccessors();
    }
    const BranchStmt::SuccAndCondPairVec& getSuccessors() const
    {
        return brstmt->getSuccessors();
    }
    const ICFGNode* getSuccessor (u32_t i) const
    {
        return brstmt->getSuccessor(i);
    }
 
    const NodeBS getDefSVFVars() const override;
 
    virtual const std::string toString() const override;
};
 
class GepVFGNode: public StmtVFGNode
{
private:
    GepVFGNode();                      
    GepVFGNode(const GepVFGNode &);  
    void operator=(const GepVFGNode &); 
 
public:
    GepVFGNode(NodeID id,const GepStmt* edge): StmtVFGNode(id,edge,Gep)
    {
 
    }
    inline const ValVar* getSrcNode() const
    {
        return SVFUtil::cast<ValVar>(StmtVFGNode::getSrcNode());
    }
    inline const ValVar* getDstNode() const
    {
        return SVFUtil::cast<ValVar>(StmtVFGNode::getDstNode());
    }
    inline const ValVar* getRHSVar() const
    {
        return getSrcNode();
    }
    inline const ValVar* getLHSVar() const
    {
        return getDstNode();
    }
 
    static inline bool classof(const GepVFGNode *)
    {
        return true;
    }
    static inline bool classof(const StmtVFGNode *node)
    {
        return node->getNodeKind() == Gep;
    }
    static inline bool classof(const VFGNode *node)
    {
        return node->getNodeKind() == Gep;
    }
    static inline bool classof(const GenericVFGNodeTy *node)
    {
        return node->getNodeKind() == Gep;
    }
    static inline bool classof(const SVFValue*node)
    {
        return node->getNodeKind() == Gep;
    }
 
    const NodeBS getDefSVFVars() const override;
 
    const std::string toString() const override;
};
 
/*
 * ICFG Node stands for a top level pointer ssa phi node or a formal parameter or a return parameter
 */
class PHIVFGNode : public VFGNode
{
 
public:
    typedef Map<u32_t,const ValVar*> OPVers;
protected:
    const ValVar* res;
    OPVers opVers;
 
public:
    PHIVFGNode(NodeID id, const ValVar* r,VFGNodeK k = TPhi);
 
    inline bool isPTANode() const
    {
        return res->isPointer();
    }
 
 
    inline const ValVar* getOpVer(u32_t pos) const
    {
        OPVers::const_iterator it = opVers.find(pos);
        assert(it!=opVers.end() && "version is nullptr, did not rename?");
        return it->second;
    }
    inline void setOpVer(u32_t pos, const ValVar* node)
    {
        opVers[pos] = node;
    }
    inline const ValVar* getRes() const
    {
        return res;
    }
    inline u32_t getOpVerNum() const
    {
        return opVers.size();
    }
    inline OPVers::const_iterator opVerBegin() const
    {
        return opVers.begin();
    }
    inline OPVers::const_iterator opVerEnd() const
    {
        return opVers.end();
    }
 
 
    static inline bool classof(const PHIVFGNode *)
    {
        return true;
    }
    static inline bool classof(const VFGNode *node)
    {
        return isPHIVFGNodeKinds(node->getNodeKind());
    }
    static inline bool classof(const GenericVFGNodeTy *node)
    {
        return isPHIVFGNodeKinds(node->getNodeKind());
    }
    static inline bool classof(const SVFValue*node)
    {
        return isPHIVFGNodeKinds(node->getNodeKind());
    }
 
    const NodeBS getDefSVFVars() const override;
 
    const SVFVar* getValue() const override;
    const std::string toString() const override;
};
 
 
/*
 * Intra LLVM PHI Node
 */
class IntraPHIVFGNode : public PHIVFGNode
{
 
public:
    typedef Map<u32_t,const ICFGNode*> OPIncomingBBs;
 
private:
    OPIncomingBBs opIncomingBBs;
public:
    IntraPHIVFGNode(NodeID id, const ValVar* r): PHIVFGNode(id, r, TIntraPhi)
    {
    }
 
    inline const ICFGNode* getOpIncomingBB(u32_t pos) const
    {
        OPIncomingBBs::const_iterator it = opIncomingBBs.find(pos);
        assert(it!=opIncomingBBs.end() && "version is nullptr, did not rename?");
        return it->second;
    }
    inline void setOpVerAndBB(u32_t pos, const ValVar* node, const ICFGNode* bb)
    {
        opVers[pos] = node;
        opIncomingBBs[pos] = bb;
    }
 
 
    static inline bool classof(const IntraPHIVFGNode*)
    {
        return true;
    }
    static inline bool classof(const PHIVFGNode *node)
    {
        return node->getNodeKind() == TIntraPhi;
    }
    static inline bool classof(const VFGNode *node)
    {
        return node->getNodeKind() == TIntraPhi;
    }
    static inline bool classof(const GenericVFGNodeTy *node)
    {
        return node->getNodeKind() == TIntraPhi;
    }
    static inline bool classof(const SVFValue*node)
    {
        return node->getNodeKind() == TIntraPhi;
    }
 
    const std::string toString() const override;
};
 
 
class AddrVFGNode: public StmtVFGNode
{
private:
    AddrVFGNode();                      
    AddrVFGNode(const AddrVFGNode &);  
    void operator=(const AddrVFGNode &); 
 
public:
    AddrVFGNode(NodeID id, const AddrStmt* edge): StmtVFGNode(id, edge,Addr)
    {
 
    }
    inline const ObjVar* getSrcNode() const
    {
        return SVFUtil::cast<ObjVar>(StmtVFGNode::getSrcNode());
    }
    inline const ValVar* getDstNode() const
    {
        return SVFUtil::cast<ValVar>(StmtVFGNode::getDstNode());
    }
    inline const ValVar* getLHSVar() const
    {
        return getDstNode();
    }
    inline const ObjVar* getRHSVar() const
    {
        return getSrcNode();
    }
 
    static inline bool classof(const AddrVFGNode *)
    {
        return true;
    }
    static inline bool classof(const StmtVFGNode *node)
    {
        return node->getNodeKind() == Addr;
    }
    static inline bool classof(const VFGNode *node)
    {
        return node->getNodeKind() == Addr;
    }
    static inline bool classof(const GenericVFGNodeTy *node)
    {
        return node->getNodeKind() == Addr;
    }
    static inline bool classof(const SVFValue*node)
    {
        return node->getNodeKind() == Addr;
    }
 
    const NodeBS getDefSVFVars() const override;
 
    const std::string toString() const override;
};
 
 
class ArgumentVFGNode : public VFGNode
{
 
protected:
    const ValVar* param;
 
public:
    ArgumentVFGNode(NodeID id, const ValVar* p, VFGNodeK k): VFGNode(id,k), param(p)
    {
    }
 
    inline bool isPTANode() const
    {
        return param->isPointer();
    }
 
 
    static inline bool classof(const ArgumentVFGNode *)
    {
        return true;
    }
    static inline bool classof(const VFGNode *node)
    {
        return isArgumentVFGNodeKinds(node->getNodeKind());
    }
    static inline bool classof(const GenericVFGNodeTy *node)
    {
        return isArgumentVFGNodeKinds(node->getNodeKind());
    }
    static inline bool classof(const SVFValue*node)
    {
        return isArgumentVFGNodeKinds(node->getNodeKind());
    }
 
    const SVFVar* getValue() const override;
    const std::string toString() const override;
};
 
/*
 * ICFG Node stands for actual parameter node (top level pointers)
 */
class ActualParmVFGNode : public ArgumentVFGNode
{
private:
    const CallICFGNode* cs;
public:
    ActualParmVFGNode(NodeID id, const ValVar* n, const CallICFGNode* c) :
        ArgumentVFGNode(id, n, AParm), cs(c)
    {
    }
 
    inline const CallICFGNode* getCallSite() const
    {
        return cs;
    }
 
    inline const ValVar* getParam() const
    {
        return param;
    }
 
 
    static inline bool classof(const ActualParmVFGNode *)
    {
        return true;
    }
    static inline bool classof(const ArgumentVFGNode *node)
    {
        return node->getNodeKind() == AParm;
    }
    static inline bool classof(const VFGNode *node)
    {
        return node->getNodeKind() == AParm;
    }
    static inline bool classof(const GenericVFGNodeTy *node)
    {
        return node->getNodeKind() == AParm;
    }
    static inline bool classof(const SVFValue*node)
    {
        return node->getNodeKind() == AParm;
    }
 
    const NodeBS getDefSVFVars() const override;
 
    const std::string toString() const override;
};
 
 
/*
 * ICFG Node stands for formal parameter node (top level pointers)
 */
class FormalParmVFGNode : public ArgumentVFGNode
{
private:
    const FunObjVar* fun;
    CallPESet callPEs;
 
public:
    FormalParmVFGNode(NodeID id, const ValVar* n, const FunObjVar* f):
        ArgumentVFGNode(id, n, FParm),  fun(f)
    {
    }
 
    inline const ValVar* getParam() const
    {
        return param;
    }
 
    inline const FunObjVar* getFun() const override
    {
        return fun;
    }
    inline void addCallPE(const CallPE* call)
    {
        callPEs.insert(call);
    }
    inline CallPESet::const_iterator callPEBegin() const
    {
        return callPEs.begin();
    }
    inline CallPESet::const_iterator callPEEnd() const
    {
        return callPEs.end();
    }
 
 
    static inline bool classof(const FormalParmVFGNode *)
    {
        return true;
    }
    static inline bool classof(const VFGNode *node)
    {
        return node->getNodeKind() == FParm;
    }
    static inline bool classof(const ArgumentVFGNode *node)
    {
        return node->getNodeKind() == FParm;
    }
    static inline bool classof(const GenericVFGNodeTy *node)
    {
        return node->getNodeKind() == FParm;
    }
    static inline bool classof(const SVFValue*node)
    {
        return node->getNodeKind() == FParm;
    }
 
    const NodeBS getDefSVFVars() const override;
 
    const std::string toString() const override;
};
 
class ActualRetVFGNode: public ArgumentVFGNode
{
private:
    const CallICFGNode* cs;
 
    ActualRetVFGNode();                      
    ActualRetVFGNode(const ActualRetVFGNode &);  
    void operator=(const ActualRetVFGNode &); 
 
public:
    ActualRetVFGNode(NodeID id, const ValVar* n, const CallICFGNode* c) :
        ArgumentVFGNode(id, n, ARet), cs(c)
    {
    }
    inline const CallICFGNode* getCallSite() const
    {
        return cs;
    }
    inline const FunObjVar* getCaller() const
    {
        return cs->getCaller();
    }
    inline const ValVar* getRev() const
    {
        return param;
    }
 
    static inline bool classof(const ActualRetVFGNode *)
    {
        return true;
    }
    static inline bool classof(const ArgumentVFGNode *node)
    {
        return node->getNodeKind() == ARet;
    }
    static inline bool classof(const VFGNode *node)
    {
        return node->getNodeKind() == ARet;
    }
    static inline bool classof(const GenericVFGNodeTy *node)
    {
        return node->getNodeKind() == ARet;
    }
    static inline bool classof(const SVFValue*node)
    {
        return node->getNodeKind() == ARet;
    }
 
    const NodeBS getDefSVFVars() const override;
 
    const std::string toString() const override;
};
 
class FormalRetVFGNode: public ArgumentVFGNode
{
private:
    const FunObjVar* fun;
    RetPESet retPEs;
 
    FormalRetVFGNode();                      
    FormalRetVFGNode(const FormalRetVFGNode &);  
    void operator=(const FormalRetVFGNode &); 
 
public:
    FormalRetVFGNode(NodeID id, const ValVar* n, const FunObjVar* f);
 
    inline const ValVar* getRet() const
    {
        return param;
    }
    inline const FunObjVar* getFun() const override
    {
        return fun;
    }
    inline void addRetPE(const RetPE* retPE)
    {
        retPEs.insert(retPE);
    }
    inline RetPESet::const_iterator retPEBegin() const
    {
        return retPEs.begin();
    }
    inline RetPESet::const_iterator retPEEnd() const
    {
        return retPEs.end();
    }
 
    static inline bool classof(const FormalRetVFGNode )
    {
        return true;
    }
    static inline bool classof(const VFGNode *node)
    {
        return node->getNodeKind() == FRet;
    }
    static inline bool classof(const ArgumentVFGNode *node)
    {
        return node->getNodeKind() == FRet;
    }
    static inline bool classof(const GenericVFGNodeTy *node)
    {
        return node->getNodeKind() == FRet;
    }
    static inline bool classof(const SVFValue*node)
    {
        return node->getNodeKind() == FRet;
    }
 
    const NodeBS getDefSVFVars() const override;
 
    const std::string toString() const override;
};
 
/*
 * Inter LLVM PHI node (formal parameter)
 */
class InterPHIVFGNode : public PHIVFGNode
{
 
public:
    InterPHIVFGNode(NodeID id, const FormalParmVFGNode* fp) : PHIVFGNode(id, fp->getParam(), TInterPhi),fun(fp->getFun()),callInst(nullptr) {}
    InterPHIVFGNode(NodeID id, const ActualRetVFGNode* ar) : PHIVFGNode(id, ar->getRev(), TInterPhi), fun(ar->getCaller()),callInst(ar->getCallSite()) {}
 
    inline bool isFormalParmPHI() const
    {
        return (fun!=nullptr) && (callInst == nullptr);
    }
 
    inline bool isActualRetPHI() const
    {
        return (fun!=nullptr) && (callInst != nullptr);
    }
 
    inline const FunObjVar* getFun() const override
    {
        assert((isFormalParmPHI() || isActualRetPHI())  && "expect a formal parameter phi");
        return fun;
    }
 
    inline const CallICFGNode* getCallSite() const
    {
        assert(isActualRetPHI() && "expect a actual return phi");
        return callInst;
    }
 
 
    static inline bool classof(const InterPHIVFGNode*)
    {
        return true;
    }
    static inline bool classof(const PHIVFGNode *node)
    {
        return node->getNodeKind() == TInterPhi;
    }
    static inline bool classof(const VFGNode *node)
    {
        return node->getNodeKind() == TInterPhi;
    }
    static inline bool classof(const GenericVFGNodeTy *node)
    {
        return node->getNodeKind() == TInterPhi;
    }
    static inline bool classof(const SVFValue*node)
    {
        return node->getNodeKind() == TInterPhi;
    }
 
    const std::string toString() const override;
 
private:
    const FunObjVar* fun;
    const CallICFGNode* callInst;
};
 
 
 
class NullPtrVFGNode : public VFGNode
{
private:
    const SVFVar* node;
public:
    NullPtrVFGNode(NodeID id, const SVFVar* n) : VFGNode(id,NPtr), node(n)
    {
 
    }
    inline bool isPTANode() const
    {
        return node->isPointer();
    }
    const SVFVar* getSVFVar() const
    {
        return node;
    }
 
    static inline bool classof(const NullPtrVFGNode *)
    {
        return true;
    }
    static inline bool classof(const VFGNode *node)
    {
        return node->getNodeKind() == NPtr;
    }
    static inline bool classof(const GenericVFGNodeTy *node)
    {
        return node->getNodeKind() == NPtr;
    }
    static inline bool classof(const SVFValue*node)
    {
        return node->getNodeKind() == NPtr;
    }
 
    const NodeBS getDefSVFVars() const override;
 
    const std::string toString() const override;
};
 
} // End namespace SVF
 
#endif /* INCLUDE_UTIL_VFGNODE_H_ */