VFGEdge.h

Go to the documentation of this file.

//===- VFGEdge.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/>.
//
//===----------------------------------------------------------------------===//
 
/*
 * VFGEdge.h
 *
 *  Created on: 18 Sep. 2018
 *      Author: Yulei Sui
 */
 
#ifndef INCLUDE_UTIL_VFGEDGE_H_
#define INCLUDE_UTIL_VFGEDGE_H_
 
#include "Graphs/GenericGraph.h"
 
namespace SVF
{
 
class VFGNode;
 
typedef GenericEdge<VFGNode> GenericVFGEdgeTy;
class VFGEdge : public GenericVFGEdgeTy
{
 
public:
    enum VFGEdgeK
    {
        IntraDirectVF,
        IntraIndirectVF,
        CallDirVF,
        RetDirVF,
        CallIndVF,
        RetIndVF,
        TheadMHPIndirectVF
    };
 
    typedef VFGEdgeK SVFGEdgeK;
 
public:
    VFGEdge(VFGNode* s, VFGNode* d, GEdgeFlag k) : GenericVFGEdgeTy(s,d,k)
    {
    }
    ~VFGEdge()
    {
    }
 
 
    inline bool isDirectVFGEdge() const
    {
        return getEdgeKind() == IntraDirectVF || getEdgeKind() == CallDirVF || getEdgeKind() == RetDirVF;
    }
    inline bool isIndirectVFGEdge() const
    {
        return getEdgeKind() == IntraIndirectVF || getEdgeKind() == CallIndVF || getEdgeKind() == RetIndVF || getEdgeKind() == TheadMHPIndirectVF;
    }
    inline bool isCallVFGEdge() const
    {
        return getEdgeKind() == CallDirVF || getEdgeKind() == CallIndVF;
    }
    inline bool isRetVFGEdge() const
    {
        return getEdgeKind() == RetDirVF || getEdgeKind() == RetIndVF;
    }
    inline bool isCallDirectVFGEdge() const
    {
        return getEdgeKind() == CallDirVF;
    }
    inline bool isRetDirectVFGEdge() const
    {
        return getEdgeKind() == RetDirVF;
    }
    inline bool isCallIndirectVFGEdge() const
    {
        return getEdgeKind() == CallIndVF;
    }
    inline bool isRetIndirectVFGEdge() const
    {
        return getEdgeKind() == RetIndVF;
    }
    inline bool isIntraVFGEdge() const
    {
        return getEdgeKind() == IntraDirectVF || getEdgeKind() == IntraIndirectVF;
    }
    inline bool isThreadMHPIndirectVFGEdge() const
    {
        return getEdgeKind() == TheadMHPIndirectVF;
    }
    typedef GenericNode<VFGNode,VFGEdge>::GEdgeSetTy VFGEdgeSetTy;
    typedef VFGEdgeSetTy SVFGEdgeSetTy;
    static inline GEdgeFlag makeEdgeFlagWithInvokeID(GEdgeKind k, CallSiteID cs)
    {
        return (cs << EdgeKindMaskBits) | k;
    }
 
 
    friend OutStream& operator<< (OutStream &o, const VFGEdge &edge)
    {
        o << edge.toString();
        return o;
    }
 
    virtual const std::string toString() const;
};
 
 
class DirectSVFGEdge : public VFGEdge
{
 
public:
    DirectSVFGEdge(VFGNode* s, VFGNode* d, GEdgeFlag k): VFGEdge(s,d,k)
    {
    }
 
    static inline bool classof(const DirectSVFGEdge *)
    {
        return true;
    }
    static inline bool classof(const VFGEdge *edge)
    {
        return edge->getEdgeKind() == IntraDirectVF  ||
               edge->getEdgeKind() == CallDirVF ||
               edge->getEdgeKind() == RetDirVF;
    }
    static inline bool classof(const GenericVFGEdgeTy *edge)
    {
        return edge->getEdgeKind() == IntraDirectVF  ||
               edge->getEdgeKind() == CallDirVF ||
               edge->getEdgeKind() == RetDirVF;
    }
 
    virtual const std::string toString() const;
};
 
 
class IntraDirSVFGEdge : public DirectSVFGEdge
{
 
public:
    IntraDirSVFGEdge(VFGNode* s, VFGNode* d): DirectSVFGEdge(s,d,IntraDirectVF)
    {
    }
 
    static inline bool classof(const IntraDirSVFGEdge*)
    {
        return true;
    }
    static inline bool classof(const DirectSVFGEdge *edge)
    {
        return edge->getEdgeKind() == IntraDirectVF;
    }
    static inline bool classof(const VFGEdge *edge)
    {
        return edge->getEdgeKind() == IntraDirectVF;
    }
    static inline bool classof(const GenericVFGEdgeTy *edge)
    {
        return edge->getEdgeKind() == IntraDirectVF;
    }
 
    virtual const std::string toString() const;
};
 
 
class CallDirSVFGEdge : public DirectSVFGEdge
{
 
private:
    CallSiteID csId;
public:
    CallDirSVFGEdge(VFGNode* s, VFGNode* d, CallSiteID id):
        DirectSVFGEdge(s,d,makeEdgeFlagWithInvokeID(CallDirVF,id)),csId(id)
    {
    }
    inline CallSiteID getCallSiteId() const
    {
        return csId;
    }
 
 
    static inline bool classof(const CallDirSVFGEdge *)
    {
        return true;
    }
    static inline bool classof(const DirectSVFGEdge *edge)
    {
        return edge->getEdgeKind() == CallDirVF;
    }
    static inline bool classof(const VFGEdge *edge)
    {
        return edge->getEdgeKind() == CallDirVF ;
    }
    static inline bool classof(const GenericVFGEdgeTy *edge)
    {
        return edge->getEdgeKind() == CallDirVF ;
    }
 
    virtual const std::string toString() const;
};
 
class RetDirSVFGEdge : public DirectSVFGEdge
{
 
private:
    CallSiteID csId;
public:
    RetDirSVFGEdge(VFGNode* s, VFGNode* d, CallSiteID id):
        DirectSVFGEdge(s,d,makeEdgeFlagWithInvokeID(RetDirVF,id)),csId(id)
    {
    }
    inline CallSiteID getCallSiteId() const
    {
        return csId;
    }
 
    static inline bool classof(const RetDirSVFGEdge *)
    {
        return true;
    }
    static inline bool classof(const DirectSVFGEdge *edge)
    {
        return edge->getEdgeKind() == RetDirVF;
    }
    static inline bool classof(const VFGEdge *edge)
    {
        return edge->getEdgeKind() == RetDirVF;
    }
    static inline bool classof(const GenericVFGEdgeTy *edge)
    {
        return edge->getEdgeKind() == RetDirVF;
    }
 
    virtual const std::string toString() const;
};
 
} // End namespace SVF
 
#endif /* INCLUDE_UTIL_VFGEDGE_H_ */