ICFGEdge.h

Go to the documentation of this file.

//===- ICFGEdge.h -- ICFG edge------------------------------------------------//
//
//                     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/>.
//
//===----------------------------------------------------------------------===//
 
/*
 * ICFGEdge.h
 *
 *  Created on: Sep 11, 2018
 *      Author: Yulei Sui
 */
 
#ifndef ICFGEdge_H_
#define ICFGEdge_H_
 
namespace SVF
{
 
class ICFGNode;
class CallPE;
class RetPE;
 
typedef GenericEdge<ICFGNode> GenericICFGEdgeTy;
class ICFGEdge : public GenericICFGEdgeTy
{
 
public:
    enum ICFGEdgeK
    {
        IntraCF,
        CallCF,
        RetCF,
    };
 
    typedef ICFGEdgeK SVFGEdgeK;
 
public:
    ICFGEdge(ICFGNode* s, ICFGNode* d, GEdgeFlag k) : GenericICFGEdgeTy(s, d, k)
    {
    }
    ~ICFGEdge() {}
 
 
    inline bool isCFGEdge() const
    {
        return getEdgeKind() == IntraCF || getEdgeKind() == CallCF ||
               getEdgeKind() == RetCF;
    }
    inline bool isCallCFGEdge() const
    {
        return getEdgeKind() == CallCF;
    }
    inline bool isRetCFGEdge() const
    {
        return getEdgeKind() == RetCF;
    }
    inline bool isIntraCFGEdge() const
    {
        return getEdgeKind() == IntraCF;
    }
    typedef GenericNode<ICFGNode, ICFGEdge>::GEdgeSetTy ICFGEdgeSetTy;
    typedef ICFGEdgeSetTy SVFGEdgeSetTy;
    static inline GEdgeFlag makeEdgeFlagWithInvokeID(GEdgeKind k, CallSiteID cs)
    {
        return (cs << EdgeKindMaskBits) | k;
    }
 
 
    friend OutStream& operator<<(OutStream& o, const ICFGEdge& edge)
    {
        o << edge.toString();
        return o;
    }
 
    virtual const std::string toString() const;
};
 
class IntraCFGEdge : public ICFGEdge
{
    friend class ICFG;
    friend class SVFIRBuilder;
 
public:
    IntraCFGEdge(ICFGNode* s, ICFGNode* d)
        : ICFGEdge(s, d, IntraCF), conditionVar(nullptr), branchCondVal(0)
    {
    }
 
    static inline bool classof(const IntraCFGEdge*)
    {
        return true;
    }
    static inline bool classof(const ICFGEdge* edge)
    {
        return edge->getEdgeKind() == IntraCF;
    }
    static inline bool classof(const GenericICFGEdgeTy* edge)
    {
        return edge->getEdgeKind() == IntraCF;
    }
 
    const SVFVar* getCondition() const
    {
        return conditionVar;
    }
 
    s64_t getSuccessorCondValue() const
    {
        assert(getCondition() && "this is not a conditional branch edge");
        return branchCondVal;
    }
 
    virtual const std::string toString() const;
 
private:
    const SVFVar* conditionVar;
    s64_t branchCondVal;
 
    inline void setConditionVar(const SVFVar* c)
    {
        conditionVar = c;
    }
 
    inline void setBranchCondVal(s64_t bVal)
    {
        branchCondVal = bVal;
    }
};
 
class CallCFGEdge : public ICFGEdge
{
 
private:
    std::vector<const CallPE*> callPEs;
 
public:
    CallCFGEdge(ICFGNode* s, ICFGNode* d)
        : ICFGEdge(s, d, CallCF)
    {
    }
    inline void addCallPE(const CallPE* callPE)
    {
        callPEs.push_back(callPE);
    }
    inline const CallICFGNode* getCallSite() const
    {
        assert(SVFUtil::isa<CallICFGNode>(getSrcNode()) && "not a CallICFGNode?");
        return SVFUtil::cast<CallICFGNode>(getSrcNode());
    }
    inline const std::vector<const CallPE*>& getCallPEs() const
    {
        return callPEs;
    }
 
    static inline bool classof(const CallCFGEdge*)
    {
        return true;
    }
    static inline bool classof(const ICFGEdge* edge)
    {
        return edge->getEdgeKind() == CallCF;
    }
    static inline bool classof(const GenericICFGEdgeTy* edge)
    {
        return edge->getEdgeKind() == CallCF;
    }
    virtual const std::string toString() const;
};
 
class RetCFGEdge : public ICFGEdge
{
 
private:
    const RetPE* retPE;
 
public:
    RetCFGEdge(ICFGNode* s, ICFGNode* d)
        : ICFGEdge(s, d, RetCF), retPE(nullptr)
    {
    }
    inline void addRetPE(const RetPE* ret)
    {
        assert(!retPE && "we can only have one retPE for each RetCFGEdge");
        retPE = ret;
    }
    inline const RetPE* getRetPE() const
    {
        return retPE;
    }
    const CallICFGNode* getCallSite() const;
 
 
    static inline bool classof(const RetCFGEdge*)
    {
        return true;
    }
    static inline bool classof(const ICFGEdge* edge)
    {
        return edge->getEdgeKind() == RetCF;
    }
    static inline bool classof(const GenericICFGEdgeTy* edge)
    {
        return edge->getEdgeKind() == RetCF;
    }
    virtual const std::string toString() const;
};
 
} // End namespace SVF
 
#endif /* ICFGEdge_H_ */