SVFStatements.h

Go to the documentation of this file.

//===- SVFStatements.h -- SVF statements-------------------------------------------//
//
//                     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/>.
//
//===----------------------------------------------------------------------===//
 
 
/*
 * SVFStatements.h
 *
 *  Created on: Nov 10, 2013
 *      Author: Yulei Sui
 */
 
#ifndef INCLUDE_SVFIR_SVFSTATEMENT_H_
#define INCLUDE_SVFIR_SVFSTATEMENT_H_
 
#include "Graphs/GenericGraph.h"
#include "MemoryModel/AccessPath.h"
 
namespace SVF
{
 
class SVFVar;
class ICFGNode;
class IntraICFGNode;
class CallICFGNode;
class FunEntryICFGNode;
class FunExitICFGNode;
class SVFBasicBlock;
 
/*
 * SVFIR program statements (PAGEdges)
 */
typedef GenericEdge<SVFVar> GenericPAGEdgeTy;
class SVFStmt : public GenericPAGEdgeTy
{
 
public:
    enum PEDGEK
    {
        Addr,
        Copy,
        Store,
        Load,
        Call,
        Ret,
        Gep,
        Phi,
        Select,
        Cmp,
        BinaryOp,
        UnaryOp,
        Branch,
        ThreadFork,
        ThreadJoin
    };
 
private:
    const SVFVar* value;           
    const SVFBasicBlock* basicBlock; 
    ICFGNode* icfgNode;              
    EdgeID edgeId;                   
 
protected:
    SVFStmt(GEdgeFlag k)
        : GenericPAGEdgeTy({}, {}, k), value{}, basicBlock{}, icfgNode{}
    {
    }
 
public:
    static u32_t totalEdgeNum; 
 
    SVFStmt(SVFVar* s, SVFVar* d, GEdgeFlag k, bool real = true);
    ~SVFStmt() {}
 
 
    static inline bool classof(const SVFStmt*)
    {
        return true;
    }
    static inline bool classof(const GenericPAGEdgeTy* edge)
    {
        return edge->getEdgeKind() == SVFStmt::Addr ||
               edge->getEdgeKind() == SVFStmt::Copy ||
               edge->getEdgeKind() == SVFStmt::Store ||
               edge->getEdgeKind() == SVFStmt::Load ||
               edge->getEdgeKind() == SVFStmt::Call ||
               edge->getEdgeKind() == SVFStmt::Ret ||
               edge->getEdgeKind() == SVFStmt::Gep ||
               edge->getEdgeKind() == SVFStmt::Phi ||
               edge->getEdgeKind() == SVFStmt::Select ||
               edge->getEdgeKind() == SVFStmt::Cmp ||
               edge->getEdgeKind() == SVFStmt::BinaryOp ||
               edge->getEdgeKind() == SVFStmt::UnaryOp ||
               edge->getEdgeKind() == SVFStmt::Branch ||
               edge->getEdgeKind() == SVFStmt::ThreadFork ||
               edge->getEdgeKind() == SVFStmt::ThreadJoin;
    }
 
    inline EdgeID getEdgeID() const
    {
        return edgeId;
    }
    virtual bool isPTAEdge() const;
 
 
 
    inline void setValue(const SVFVar* val)
    {
        value = val;
    }
    inline const SVFVar* getValue() const
    {
        return value;
    }
 
    inline void setBB(const SVFBasicBlock* bb)
    {
        basicBlock = bb;
    }
    inline const SVFBasicBlock* getBB() const
    {
        return basicBlock;
    }
    inline void setICFGNode(ICFGNode* node)
    {
        icfgNode = node;
    }
    inline ICFGNode* getICFGNode() const
    {
        return icfgNode;
    }
 
    static inline GEdgeFlag makeEdgeFlagWithAddionalOpnd(GEdgeKind k,
            const SVFVar* var)
    {
        auto it_inserted = var2LabelMap.emplace(var, multiOpndLabelCounter);
        if (it_inserted.second)
            ++multiOpndLabelCounter;
        u64_t label = it_inserted.first->second;
        return (label << EdgeKindMaskBits) | k;
    }
 
    static inline GEdgeFlag makeEdgeFlagWithCallInst(GEdgeKind k,
            const ICFGNode* cs)
    {
        auto it_inserted = inst2LabelMap.emplace(cs, callEdgeLabelCounter);
        if (it_inserted.second)
            ++callEdgeLabelCounter;
        u64_t label = it_inserted.first->second;
        return (label << EdgeKindMaskBits) | k;
    }
 
    static inline GEdgeFlag makeEdgeFlagWithStoreInst(GEdgeKind k,
            const ICFGNode* store)
    {
        auto it_inserted = inst2LabelMap.emplace(store, storeEdgeLabelCounter);
        if (it_inserted.second)
            ++storeEdgeLabelCounter;
        u64_t label = it_inserted.first->second;
        return (label << EdgeKindMaskBits) | k;
    }
 
    virtual const std::string toString() const;
 
 
    friend OutStream& operator<<(OutStream& o, const SVFStmt& edge)
    {
        o << edge.toString();
        return o;
    }
 
    typedef GenericNode<SVFVar,SVFStmt>::GEdgeSetTy SVFStmtSetTy;
    typedef Map<EdgeID, SVFStmtSetTy> PAGEdgeToSetMapTy;
    typedef PAGEdgeToSetMapTy KindToSVFStmtMapTy;
    typedef SVFStmtSetTy PAGEdgeSetTy;
 
private:
    typedef Map<const ICFGNode*, u32_t> Inst2LabelMap;
    typedef Map<const SVFVar*, u32_t> Var2LabelMap;
    static Inst2LabelMap inst2LabelMap; 
    static Var2LabelMap var2LabelMap;  
    static u64_t callEdgeLabelCounter;  
    static u64_t storeEdgeLabelCounter;  
    static u64_t multiOpndLabelCounter;  
};
 
/*
 Parent class of Addr, Copy, Store, Load, Call, Ret, NormalGep, VariantGep, ThreadFork, ThreadJoin
 connecting RHS expression and LHS expression with an assignment  (e.g., LHSExpr = RHSExpr)
 Only one operand on the right hand side of an assignment
*/
class AssignStmt : public SVFStmt
{
 
private:
    AssignStmt();                      
    AssignStmt(const AssignStmt &);  
    void operator=(const AssignStmt &); 
    SVFVar* getSrcNode();  
    SVFVar* getDstNode();    
    NodeID getSrcID();  
    NodeID getDstID();    
 
protected:
    AssignStmt(SVFVar* s, SVFVar* d, GEdgeFlag k) : SVFStmt(s, d, k) {}
 
public:
 
    static inline bool classof(const AssignStmt*)
    {
        return true;
    }
    static inline bool classof(const SVFStmt* edge)
    {
        return edge->getEdgeKind() == SVFStmt::Addr ||
               edge->getEdgeKind() == SVFStmt::Copy ||
               edge->getEdgeKind() == SVFStmt::Store ||
               edge->getEdgeKind() == SVFStmt::Load ||
               edge->getEdgeKind() == SVFStmt::Call ||
               edge->getEdgeKind() == SVFStmt::Ret ||
               edge->getEdgeKind() == SVFStmt::Gep ||
               edge->getEdgeKind() == SVFStmt::ThreadFork ||
               edge->getEdgeKind() == SVFStmt::ThreadJoin;
    }
    static inline bool classof(const GenericPAGEdgeTy* edge)
    {
        return edge->getEdgeKind() == SVFStmt::Addr ||
               edge->getEdgeKind() == SVFStmt::Copy ||
               edge->getEdgeKind() == SVFStmt::Store ||
               edge->getEdgeKind() == SVFStmt::Load ||
               edge->getEdgeKind() == SVFStmt::Call ||
               edge->getEdgeKind() == SVFStmt::Ret ||
               edge->getEdgeKind() == SVFStmt::Gep ||
               edge->getEdgeKind() == SVFStmt::ThreadFork ||
               edge->getEdgeKind() == SVFStmt::ThreadJoin;
    }
 
    inline SVFVar* getRHSVar() const
    {
        return SVFStmt::getSrcNode();
    }
    inline SVFVar* getLHSVar() const
    {
        return SVFStmt::getDstNode();
    }
    inline NodeID getRHSVarID() const
    {
        return SVFStmt::getSrcID();
    }
    inline NodeID getLHSVarID() const
    {
        return SVFStmt::getDstID();
    }
 
    virtual const std::string toString() const = 0;
};
 
class AddrStmt: public AssignStmt
{
 
private:
    AddrStmt(const AddrStmt&);       
    void operator=(const AddrStmt&); 
 
    std::vector<SVFVar*> arrSize;   
 
public:
 
    static inline bool classof(const AddrStmt*)
    {
        return true;
    }
    static inline bool classof(const SVFStmt* edge)
    {
        return edge->getEdgeKind() == SVFStmt::Addr;
    }
    static inline bool classof(const GenericPAGEdgeTy* edge)
    {
        return edge->getEdgeKind() == SVFStmt::Addr;
    }
 
    AddrStmt(SVFVar* s, SVFVar* d) : AssignStmt(s, d, SVFStmt::Addr) {}
 
    virtual const std::string toString() const override;
 
    inline void addArrSize(SVFVar* size)   //TODO:addSizeVar
    {
        arrSize.push_back(size);
    }
 
    inline const std::vector<SVFVar*>& getArrSize() const   //TODO:getSizeVars
    {
        return arrSize;
    }
 
    virtual bool isPTAEdge() const override
    {
        return true;
    }
};
 
class CopyStmt: public AssignStmt
{
 
private:
    CopyStmt(const CopyStmt&);       
    void operator=(const CopyStmt&); 
public:
    enum CopyKind
    {
        COPYVAL,    // Value copies (default one)
        ZEXT,       // Zero extend integers
        SEXT,       // Sign extend integers
        BITCAST,    // Type cast
        TRUNC,      // Truncate integers
        FPTRUNC,    // Truncate floating point
        FPTOUI,     // floating point -> UInt
        FPTOSI,     // floating point -> SInt
        UITOFP,     // UInt -> floating point
        SITOFP,     // SInt -> floating point
        INTTOPTR,   // Integer -> Pointer
        PTRTOINT    // Pointer -> Integer
    };
 
    static inline bool classof(const CopyStmt*)
    {
        return true;
    }
    static inline bool classof(const SVFStmt* edge)
    {
        return edge->getEdgeKind() == SVFStmt::Copy;
    }
    static inline bool classof(const GenericPAGEdgeTy* edge)
    {
        return edge->getEdgeKind() == SVFStmt::Copy;
    }
 
    inline u32_t getCopyKind() const
    {
        return copyKind;
    }
 
    inline bool isBitCast() const
    {
        return copyKind == BITCAST;
    }
 
    inline bool isValueCopy() const
    {
        return copyKind == COPYVAL;
    }
 
    inline bool isInt2Ptr() const
    {
        return copyKind == INTTOPTR;
    }
 
    inline bool isPtr2Int() const
    {
        return copyKind == PTRTOINT;
    }
 
    inline bool isZext() const
    {
        return copyKind == ZEXT;
    }
 
    inline bool isSext() const
    {
        return copyKind == SEXT;
    }
 
    CopyStmt(SVFVar* s, SVFVar* d, CopyKind k) : AssignStmt(s, d, SVFStmt::Copy), copyKind(k) {}
 
    virtual const std::string toString() const override;
private:
    u32_t copyKind;
};
 
class StoreStmt: public AssignStmt
{
 
private:
    StoreStmt(const StoreStmt&);      
    void operator=(const StoreStmt&); 
 
public:
 
    static inline bool classof(const StoreStmt*)
    {
        return true;
    }
    static inline bool classof(const SVFStmt* edge)
    {
        return edge->getEdgeKind() == SVFStmt::Store;
    }
    static inline bool classof(const GenericPAGEdgeTy* edge)
    {
        return edge->getEdgeKind() == SVFStmt::Store;
    }
 
    StoreStmt(SVFVar* s, SVFVar* d, const ICFGNode* st);
 
    virtual const std::string toString() const override;
};
 
class LoadStmt: public AssignStmt
{
 
private:
    LoadStmt(const LoadStmt&);       
    void operator=(const LoadStmt&); 
 
public:
 
    static inline bool classof(const LoadStmt*)
    {
        return true;
    }
    static inline bool classof(const SVFStmt* edge)
    {
        return edge->getEdgeKind() == SVFStmt::Load;
    }
    static inline bool classof(const GenericPAGEdgeTy* edge)
    {
        return edge->getEdgeKind() == SVFStmt::Load;
    }
 
    LoadStmt(SVFVar* s, SVFVar* d) : AssignStmt(s, d, SVFStmt::Load) {}
 
    virtual const std::string toString() const override;
};
 
class GepStmt: public AssignStmt
{
 
private:
    GepStmt(const GepStmt &);  
    void operator=(const GepStmt &); 
 
    AccessPath ap;  
    bool variantField;  
public:
 
    static inline bool classof(const GepStmt*)
    {
        return true;
    }
    static inline bool classof(const SVFStmt* edge)
    {
        return  edge->getEdgeKind() == SVFStmt::Gep;
    }
    static inline bool classof(const GenericPAGEdgeTy* edge)
    {
        return  edge->getEdgeKind() == SVFStmt::Gep;
    }
 
    inline const AccessPath& getAccessPath() const
    {
        return ap;
    }
    inline const AccessPath::IdxOperandPairs getOffsetVarAndGepTypePairVec() const
    {
        return getAccessPath().getIdxOperandPairVec();
    }
    inline bool isConstantOffset() const
    {
        return getAccessPath().isConstantOffset();
    }
 
    inline APOffset accumulateConstantByteOffset() const
    {
        return getAccessPath().computeConstantByteOffset();
    }
 
    inline APOffset accumulateConstantOffset() const
    {
        return getAccessPath().computeConstantOffset();
    }
    inline APOffset getConstantStructFldIdx() const
    {
        assert(isVariantFieldGep()==false && "Can't retrieve the AccessPath if using a variable field index (pointer arithmetic) for struct field access ");
        return getAccessPath().getConstantStructFldIdx();
    }
    inline bool isVariantFieldGep() const
    {
        return variantField;
    }
 
    GepStmt(SVFVar* s, SVFVar* d, const AccessPath& ap, bool varfld = false)
        : AssignStmt(s, d, SVFStmt::Gep), ap(ap), variantField(varfld)
    {
    }
 
    virtual const std::string toString() const;
 
};
 
 
class CallPE: public AssignStmt
{
 
private:
    CallPE(const CallPE&);         
    void operator=(const CallPE&); 
 
    const CallICFGNode* call;      
    const FunEntryICFGNode* entry; 
 
public:
 
    static inline bool classof(const CallPE*)
    {
        return true;
    }
    static inline bool classof(const SVFStmt* edge)
    {
        return edge->getEdgeKind() == SVFStmt::Call ||
               edge->getEdgeKind() == SVFStmt::ThreadFork;
    }
    static inline bool classof(const GenericPAGEdgeTy* edge)
    {
        return edge->getEdgeKind() == SVFStmt::Call ||
               edge->getEdgeKind() == SVFStmt::ThreadFork;
    }
 
    CallPE(SVFVar* s, SVFVar* d, const CallICFGNode* i,
           const FunEntryICFGNode* e, GEdgeKind k = SVFStmt::Call);
 
 
    inline const CallICFGNode* getCallInst() const
    {
        return call;
    }
    inline const CallICFGNode* getCallSite() const
    {
        return call;
    }
    inline const FunEntryICFGNode* getFunEntryICFGNode() const
    {
        return entry;
    }
 
    virtual const std::string toString() const override;
};
 
class RetPE: public AssignStmt
{
 
private:
    RetPE(const RetPE&);          
    void operator=(const RetPE&); 
 
    const CallICFGNode* call;    
    const FunExitICFGNode* exit; 
 
public:
 
    static inline bool classof(const RetPE*)
    {
        return true;
    }
    static inline bool classof(const SVFStmt* edge)
    {
        return edge->getEdgeKind() == SVFStmt::Ret ||
               edge->getEdgeKind() == SVFStmt::ThreadJoin;
    }
    static inline bool classof(const GenericPAGEdgeTy* edge)
    {
        return edge->getEdgeKind() == SVFStmt::Ret ||
               edge->getEdgeKind() == SVFStmt::ThreadJoin;
    }
 
    RetPE(SVFVar* s, SVFVar* d, const CallICFGNode* i, const FunExitICFGNode* e,
          GEdgeKind k = SVFStmt::Ret);
 
 
    inline const CallICFGNode* getCallInst() const
    {
        return call;
    }
    inline const CallICFGNode* getCallSite() const
    {
        return call;
    }
    inline const FunExitICFGNode* getFunExitICFGNode() const
    {
        return exit;
    }
 
    virtual const std::string toString() const override;
};
 
/*
* Program statements with multiple operands including BinaryOPStmt, CmpStmt and PhiStmt
*/
class MultiOpndStmt : public SVFStmt
{
 
public:
    typedef std::vector<SVFVar*> OPVars;
 
private:
    MultiOpndStmt();                      
    MultiOpndStmt(const MultiOpndStmt&);  
    void operator=(const MultiOpndStmt&); 
    SVFVar* getSrcNode(); 
    SVFVar* getDstNode(); 
    NodeID getSrcID();    
    NodeID getDstID();    
 
protected:
    OPVars opVars;
    MultiOpndStmt(SVFVar* r, const OPVars& opnds, GEdgeFlag k);
 
public:
 
    static inline bool classof(const MultiOpndStmt*)
    {
        return true;
    }
    static inline bool classof(const SVFStmt* node)
    {
        return node->getEdgeKind() == Phi || node->getEdgeKind() == Select ||
               node->getEdgeKind() == BinaryOp || node->getEdgeKind() == Cmp;
    }
    static inline bool classof(const GenericPAGEdgeTy* node)
    {
        return node->getEdgeKind() == Phi || node->getEdgeKind() == Select ||
               node->getEdgeKind() == BinaryOp || node->getEdgeKind() == Cmp;
    }
 
 
 
    inline const SVFVar* getOpVar(u32_t pos) const
    {
        return opVars.at(pos);
    }
    inline const SVFVar* getRes() const
    {
        return SVFStmt::getDstNode();
    }
 
    NodeID getOpVarID(u32_t pos) const;
    NodeID getResID() const;
 
    inline u32_t getOpVarNum() const
    {
        return opVars.size();
    }
    inline const OPVars& getOpndVars() const
    {
        return opVars;
    }
    inline OPVars::const_iterator opVarBegin() const
    {
        return opVars.begin();
    }
    inline OPVars::const_iterator opVerEnd() const
    {
        return opVars.end();
    }
};
 
class PhiStmt: public MultiOpndStmt
{
 
public:
    typedef std::vector<const ICFGNode*> OpICFGNodeVec;
 
private:
    PhiStmt(const PhiStmt&);        
    void operator=(const PhiStmt&); 
 
    OpICFGNodeVec opICFGNodes;
 
public:
 
    static inline bool classof(const PhiStmt*)
    {
        return true;
    }
    static inline bool classof(const SVFStmt* edge)
    {
        return edge->getEdgeKind() == SVFStmt::Phi;
    }
    static inline bool classof(const MultiOpndStmt* edge)
    {
        return edge->getEdgeKind() == SVFStmt::Phi;
    }
    static inline bool classof(const GenericPAGEdgeTy* edge)
    {
        return edge->getEdgeKind() == SVFStmt::Phi;
    }
 
    PhiStmt(SVFVar* s, const OPVars& opnds, const OpICFGNodeVec& icfgNodes)
        : MultiOpndStmt(s, opnds, SVFStmt::Phi), opICFGNodes(icfgNodes)
    {
        assert(opnds.size() == icfgNodes.size() &&
               "Numbers of operands and their ICFGNodes are not consistent?");
    }
    void addOpVar(SVFVar* op, const ICFGNode* inode)
    {
        opVars.push_back(op);
        opICFGNodes.push_back(inode);
        assert(opVars.size() == opICFGNodes.size() &&
               "Numbers of operands and their ICFGNodes are not consistent?");
    }
 
    inline const ICFGNode* getOpICFGNode(u32_t op_idx) const
    {
        return opICFGNodes.at(op_idx);
    }
 
    bool isFunctionRetPhi() const;
 
    virtual const std::string toString() const override;
};
 
class SelectStmt: public MultiOpndStmt
{
 
private:
    SelectStmt(const SelectStmt&);     
    void operator=(const SelectStmt&); 
 
    const SVFVar* condition;
 
public:
 
    static inline bool classof(const SelectStmt*)
    {
        return true;
    }
    static inline bool classof(const SVFStmt* edge)
    {
        return edge->getEdgeKind() == SVFStmt::Select;
    }
    static inline bool classof(const MultiOpndStmt* edge)
    {
        return edge->getEdgeKind() == SVFStmt::Select;
    }
    static inline bool classof(const GenericPAGEdgeTy* edge)
    {
        return edge->getEdgeKind() == SVFStmt::Select;
    }
 
    SelectStmt(SVFVar* s, const OPVars& opnds, const SVFVar* cond);
    virtual const std::string toString() const override;
 
    inline const SVFVar* getCondition() const
    {
        return condition;
    }
    inline const SVFVar* getTrueValue() const
    {
        return getOpVar(0);
    }
    inline const SVFVar* getFalseValue() const
    {
        return getOpVar(1);
    }
};
 
class CmpStmt: public MultiOpndStmt
{
 
private:
    CmpStmt(const CmpStmt&);        
    void operator=(const CmpStmt&); 
 
    u32_t predicate;
 
public:
    enum Predicate : unsigned
    {
        // Opcode            U L G E    Intuitive operation
        FCMP_FALSE = 0, 
        FCMP_OEQ = 1,   
        FCMP_OGT = 2,   
        FCMP_OGE = 3,   
        FCMP_OLT = 4,   
        FCMP_OLE = 5,   
        FCMP_ONE = 6,   
        FCMP_ORD = 7,   
        FCMP_UNO = 8,   
        FCMP_UEQ = 9,   
        FCMP_UGT = 10,  
        FCMP_UGE = 11,  
        FCMP_ULT = 12,  
        FCMP_ULE = 13,  
        FCMP_UNE = 14,  
        FCMP_TRUE = 15, 
        FIRST_FCMP_PREDICATE = FCMP_FALSE,
        LAST_FCMP_PREDICATE = FCMP_TRUE,
        BAD_FCMP_PREDICATE = FCMP_TRUE + 1,
        ICMP_EQ = 32,  
        ICMP_NE = 33,  
        ICMP_UGT = 34, 
        ICMP_UGE = 35, 
        ICMP_ULT = 36, 
        ICMP_ULE = 37, 
        ICMP_SGT = 38, 
        ICMP_SGE = 39, 
        ICMP_SLT = 40, 
        ICMP_SLE = 41, 
        FIRST_ICMP_PREDICATE = ICMP_EQ,
        LAST_ICMP_PREDICATE = ICMP_SLE,
        BAD_ICMP_PREDICATE = ICMP_SLE + 1
    };
 
 
    static inline bool classof(const CmpStmt*)
    {
        return true;
    }
    static inline bool classof(const SVFStmt* edge)
    {
        return edge->getEdgeKind() == SVFStmt::Cmp;
    }
    static inline bool classof(const MultiOpndStmt* edge)
    {
        return edge->getEdgeKind() == SVFStmt::Cmp;
    }
    static inline bool classof(const GenericPAGEdgeTy* edge)
    {
        return edge->getEdgeKind() == SVFStmt::Cmp;
    }
 
    CmpStmt(SVFVar* s, const OPVars& opnds, u32_t pre);
 
    u32_t getPredicate() const
    {
        return predicate;
    }
 
    virtual const std::string toString() const override;
};
 
class BinaryOPStmt: public MultiOpndStmt
{
 
private:
    BinaryOPStmt(const BinaryOPStmt&);   
    void operator=(const BinaryOPStmt&); 
    u32_t opcode;
 
public:
    enum OpCode : unsigned
    {
        Add = 13,       // Sum of integers
        FAdd = 14,      // Sum of floats
        Sub = 15,       // Subtraction of integers
        FSub = 16,      // Subtraction of floats
        Mul = 17,       // Product of integers.
        FMul = 18,      // Product of floats.
        UDiv = 19,      // Unsigned division.
        SDiv = 20,      // Signed division.
        FDiv = 21,      // Float division.
        URem = 22,      // Unsigned remainder
        SRem = 23,      // Signed remainder
        FRem = 24,      // Float remainder
        Shl = 25,       // Shift left  (logical)
        LShr = 26,      // Shift right (logical)
        AShr = 27,      // Shift right (arithmetic)
        And = 28,       // Logical and
        Or = 29,        // Logical or
        Xor = 30        // Logical xor
    };
 
 
    static inline bool classof(const BinaryOPStmt*)
    {
        return true;
    }
    static inline bool classof(const SVFStmt* edge)
    {
        return edge->getEdgeKind() == SVFStmt::BinaryOp;
    }
    static inline bool classof(const MultiOpndStmt* edge)
    {
        return edge->getEdgeKind() == SVFStmt::BinaryOp;
    }
    static inline bool classof(const GenericPAGEdgeTy* edge)
    {
        return edge->getEdgeKind() == SVFStmt::BinaryOp;
    }
 
    BinaryOPStmt(SVFVar* s, const OPVars& opnds, u32_t oc);
 
    u32_t getOpcode() const
    {
        return opcode;
    }
 
    virtual const std::string toString() const override;
};
 
class UnaryOPStmt: public SVFStmt
{
 
private:
    UnaryOPStmt(const UnaryOPStmt&);    
    void operator=(const UnaryOPStmt&); 
    SVFVar* getSrcNode(); 
    SVFVar* getDstNode(); 
    NodeID getSrcID();    
    NodeID getDstID();    
 
    u32_t opcode;
 
public:
    enum OpCode : unsigned
    {
        FNeg = 12
    };
 
 
    static inline bool classof(const UnaryOPStmt*)
    {
        return true;
    }
    static inline bool classof(const SVFStmt* edge)
    {
        return edge->getEdgeKind() == SVFStmt::UnaryOp;
    }
    static inline bool classof(const GenericPAGEdgeTy* edge)
    {
        return edge->getEdgeKind() == SVFStmt::UnaryOp;
    }
 
    UnaryOPStmt(SVFVar* s, SVFVar* d, u32_t oc)
        : SVFStmt(s, d, SVFStmt::UnaryOp), opcode(oc)
    {
    }
 
    u32_t getOpcode() const
    {
        return opcode;
    }
    inline const SVFVar* getOpVar() const
    {
        return SVFStmt::getSrcNode();
    }
    inline const SVFVar* getRes() const
    {
        return SVFStmt::getDstNode();
    }
    NodeID getOpVarID() const;
    NodeID getResID() const;
 
    virtual const std::string toString() const override;
};
 
class BranchStmt: public SVFStmt
{
 
public:
    typedef std::vector<std::pair<const ICFGNode*, s32_t>> SuccAndCondPairVec;
 
private:
    BranchStmt(const BranchStmt&);     
    void operator=(const BranchStmt&); 
    SVFVar* getSrcNode();              
    SVFVar* getDstNode();              
    NodeID getSrcID(); 
    NodeID getDstID(); 
 
    SuccAndCondPairVec successors;
    const SVFVar* cond;
    const SVFVar* brInst;
 
public:
 
    static inline bool classof(const BranchStmt*)
    {
        return true;
    }
    static inline bool classof(const SVFStmt* edge)
    {
        return edge->getEdgeKind() == SVFStmt::Branch;
    }
    static inline bool classof(const GenericPAGEdgeTy* edge)
    {
        return edge->getEdgeKind() == SVFStmt::Branch;
    }
 
    BranchStmt(SVFVar* inst, SVFVar* c, const SuccAndCondPairVec& succs)
        : SVFStmt(c, inst, SVFStmt::Branch), successors(succs), cond(c),
          brInst(inst)
    {
    }
 
    bool isUnconditional() const;
    bool isConditional() const;
    const SVFVar* getCondition() const;
    const SVFVar* getBranchInst() const
    {
        return brInst;
    }
 
 
 
    u32_t getNumSuccessors() const
    {
        return successors.size();
    }
    const SuccAndCondPairVec& getSuccessors() const
    {
        return successors;
    }
    const ICFGNode* getSuccessor(u32_t i) const
    {
        return successors.at(i).first;
    }
    s64_t getSuccessorCondValue(u32_t i) const
    {
        return successors.at(i).second;
    }
    virtual const std::string toString() const override;
};
 
class TDForkPE: public CallPE
{
 
private:
    TDForkPE(const TDForkPE&);       
    void operator=(const TDForkPE&); 
 
public:
 
    static inline bool classof(const TDForkPE*)
    {
        return true;
    }
    static inline bool classof(const SVFStmt* edge)
    {
        return edge->getEdgeKind() == SVFStmt::ThreadFork;
    }
    static inline bool classof(const GenericPAGEdgeTy* edge)
    {
        return edge->getEdgeKind() == SVFStmt::ThreadFork;
    }
 
    TDForkPE(SVFVar* s, SVFVar* d, const CallICFGNode* i,
             const FunEntryICFGNode* entry)
        : CallPE(s, d, i, entry, SVFStmt::ThreadFork)
    {
    }
 
    virtual const std::string toString() const;
};
 
class TDJoinPE: public RetPE
{
 
private:
    TDJoinPE(const TDJoinPE&);       
    void operator=(const TDJoinPE&); 
 
public:
 
    static inline bool classof(const TDJoinPE*)
    {
        return true;
    }
    static inline bool classof(const SVFStmt* edge)
    {
        return edge->getEdgeKind() == SVFStmt::ThreadJoin;
    }
    static inline bool classof(const GenericPAGEdgeTy* edge)
    {
        return edge->getEdgeKind() == SVFStmt::ThreadJoin;
    }
 
    TDJoinPE(SVFVar* s, SVFVar* d, const CallICFGNode* i,
             const FunExitICFGNode* e)
        : RetPE(s, d, i, e, SVFStmt::ThreadJoin)
    {
    }
 
    virtual const std::string toString() const;
};
 
} // End namespace SVF
 
#endif /* INCLUDE_SVFIR_SVFSTATEMENT_H_ */