CxtStmt.h

Go to the documentation of this file.

//===- CxtStmt.h -- Context- and Thread-Sensitive Statement-------------------//
//
//                     SVF: Static Value-Flow Analysis
//
// Copyright (C) <2013-2017>  <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/>.
//
//===----------------------------------------------------------------------===//
 
/*
 * CxtStmt.h
 *
 *  Created on: Jan 21, 2014
 *      Author: Yulei Sui
 */
 
#ifndef INCLUDE_UTIL_CXTSTMT_H_
#define INCLUDE_UTIL_CXTSTMT_H_
 
namespace SVF
{
 
class ICFGNode;
class CxtStmt
{
public:
    CxtStmt(const CallStrCxt& c, const ICFGNode* f) :cxt(c), inst(f)
    {
    }

    CxtStmt(const CxtStmt& ctm) : cxt(ctm.getContext()),inst(ctm.getStmt())
    {
    }

    virtual ~CxtStmt()
    {
    }

    inline const CallStrCxt& getContext() const
    {
        return cxt;
    }

    inline const ICFGNode* getStmt() const
    {
        return inst;
    }

    inline bool operator< (const CxtStmt& rhs) const
    {
        if(inst!=rhs.getStmt())
            return inst < rhs.getStmt();
        else
            return cxt < rhs.getContext();
    }

    inline CxtStmt& operator= (const CxtStmt& rhs)
    {
        if(*this!=rhs)
        {
            inst = rhs.getStmt();
            cxt = rhs.getContext();
        }
        return *this;
    }

    inline bool operator== (const CxtStmt& rhs) const
    {
        return (inst == rhs.getStmt() && cxt == rhs.getContext());
    }

    inline bool operator!= (const CxtStmt& rhs) const
    {
        return !(*this==rhs);
    }

    inline std::string cxtToStr() const
    {
        std::string str;
        std::stringstream rawstr(str);
        rawstr << "[:";
        for(CallStrCxt::const_iterator it = cxt.begin(), eit = cxt.end(); it!=eit; ++it)
        {
            rawstr << *it << " ";
        }
        rawstr << " ]";
        return rawstr.str();
    }

    inline void dump() const
    {
        SVFUtil::outs() << "[ Current Stmt: " << inst->toString() << "\t Contexts: " << cxtToStr() << "  ]\n";
    }
 
protected:
    CallStrCxt cxt;
    const ICFGNode* inst;
};
 

class CxtThreadStmt : public CxtStmt
{
public:
    CxtThreadStmt(NodeID t, const CallStrCxt& c, const ICFGNode* f) :CxtStmt(c,f), tid(t)
    {
    }

    CxtThreadStmt(const CxtThreadStmt& ctm) :CxtStmt(ctm), tid(ctm.getTid())
    {
    }

    virtual ~CxtThreadStmt()
    {
    }

    inline NodeID getTid() const
    {
        return tid;
    }

    inline bool operator< (const CxtThreadStmt& rhs) const
    {
        if (tid != rhs.getTid())
            return tid < rhs.getTid();
        else if(inst!=rhs.getStmt())
            return inst < rhs.getStmt();
        else
            return cxt < rhs.getContext();
    }

    inline CxtThreadStmt& operator= (const CxtThreadStmt& rhs)
    {
        if(*this!=rhs)
        {
            CxtStmt::operator=(rhs);
            tid = rhs.getTid();
        }
        return *this;
    }

    inline bool operator== (const CxtThreadStmt& rhs) const
    {
        return (tid == rhs.getTid() && inst == rhs.getStmt() && cxt == rhs.getContext());
    }

    inline bool operator!= (const CxtThreadStmt& rhs) const
    {
        return !(*this==rhs);
    }

    inline void dump() const
    {
        SVFUtil::outs() << "[ Current Thread id: " << tid << "  Stmt: " << inst->toString() << "\t Contexts: " << cxtToStr() << "  ]\n";
    }
 
private:
    NodeID tid;
};
 

class CxtThread
{
public:
    CxtThread(const CallStrCxt& c, const ICFGNode* fork) : cxt(c), forksite(fork), inloop(false), incycle(false)
    {
    }

    CxtThread(const CxtThread& ct) :
        cxt(ct.getContext()), forksite(ct.getThread()), inloop(ct.isInloop()), incycle(ct.isIncycle())
    {
    }

    virtual ~CxtThread()
    {
    }

    inline const CallStrCxt& getContext() const
    {
        return cxt;
    }

    inline const ICFGNode* getThread() const
    {
        return forksite;
    }

    inline bool operator< (const CxtThread& rhs) const
    {
        if (forksite != rhs.getThread())
            return forksite < rhs.getThread();
        else
            return cxt < rhs.getContext();
    }

    inline CxtThread& operator= (const CxtThread& rhs)
    {
        if(*this!=rhs)
        {
            forksite = rhs.getThread();
            cxt = rhs.getContext();
        }
        return *this;
    }

    inline bool operator== (const CxtThread& rhs) const
    {
        return (forksite == rhs.getThread() && cxt == rhs.getContext());
    }

    inline bool operator!= (const CxtThread& rhs) const
    {
        return !(*this==rhs);
    }

    inline std::string cxtToStr() const
    {
        std::string str;
        std::stringstream rawstr(str);
        rawstr << "[:";
        for(CallStrCxt::const_iterator it = cxt.begin(), eit = cxt.end(); it!=eit; ++it)
        {
            rawstr << *it << " ";
        }
        rawstr << " ]";
        return rawstr.str();
    }


    inline void setInloop(bool in)
    {
        inloop = in;
    }
    inline bool isInloop() const
    {
        return inloop;
    }
    inline void setIncycle(bool in)
    {
        incycle = in;
    }
    inline bool isIncycle() const
    {
        return incycle;
    }


    inline void dump() const
    {
        std::string loop = inloop?", inloop":"";
        std::string cycle = incycle?", incycle":"";
 
        if(forksite)
        {
            SVFUtil::outs() << "[ Thread: "
                            << forksite->toString()  << "\t Contexts: " << cxtToStr()
                            << loop << cycle <<"  ]\n";
        }
        else
        {
            SVFUtil::outs() << "[ Thread: " << "main   "  << "\t Contexts: " << cxtToStr()
                            << loop << cycle <<"  ]\n";
        }
    }
protected:
    CallStrCxt cxt;
    const ICFGNode* forksite;
    bool inloop;
    bool incycle;
};
 

class CxtProc
{
public:
    CxtProc(const CallStrCxt& c, const FunObjVar* f) :
        cxt(c), fun(f)
    {
    }

    CxtProc(const CxtProc& ctm) :
        cxt(ctm.getContext()), fun(ctm.getProc())
    {
    }

    virtual ~CxtProc()
    {
    }

    inline const FunObjVar* getProc() const
    {
        return fun;
    }

    inline const CallStrCxt& getContext() const
    {
        return cxt;
    }

    inline bool operator<(const CxtProc& rhs) const
    {
        if (fun != rhs.getProc())
            return fun < rhs.getProc();
        else
            return cxt < rhs.getContext();
    }

    inline CxtProc& operator=(const CxtProc& rhs)
    {
        if (*this != rhs)
        {
            fun = rhs.getProc();
            cxt = rhs.getContext();
        }
        return *this;
    }

    inline bool operator==(const CxtProc& rhs) const
    {
        return (fun == rhs.getProc() && cxt == rhs.getContext());
    }

    inline bool operator!=(const CxtProc& rhs) const
    {
        return !(*this == rhs);
    }

    inline std::string cxtToStr() const
    {
        std::string str;
        std::stringstream rawstr(str);
        rawstr << "[:";
        for (CallStrCxt::const_iterator it = cxt.begin(), eit = cxt.end(); it != eit; ++it)
        {
            rawstr << *it << " ";
        }
        rawstr << " ]";
        return rawstr.str();
    }

    inline void dump() const
    {
        SVFUtil::outs() << "[ Proc: " << fun->getName() << "\t Contexts: " << cxtToStr() << "  ]\n";
    }
 
protected:
    CallStrCxt cxt;
    const FunObjVar* fun;
};
 

class CxtThreadProc : public CxtProc
{
public:
    CxtThreadProc(NodeID t, const CallStrCxt& c, const FunObjVar* f) :CxtProc(c,f),tid(t)
    {
    }

    CxtThreadProc(const CxtThreadProc& ctm) : CxtProc(ctm.getContext(),ctm.getProc()), tid(ctm.getTid())
    {
    }

    virtual ~CxtThreadProc()
    {
    }

    inline NodeID getTid() const
    {
        return tid;
    }

    inline bool operator< (const CxtThreadProc& rhs) const
    {
        if (tid != rhs.getTid())
            return tid < rhs.getTid();
        else if(fun!=rhs.getProc())
            return fun < rhs.getProc();
        else
            return cxt < rhs.getContext();
    }

    inline CxtThreadProc& operator= (const CxtThreadProc& rhs)
    {
        if(*this!=rhs)
        {
            tid = rhs.getTid();
            fun = rhs.getProc();
            cxt = rhs.getContext();
        }
        return *this;
    }

    inline bool operator== (const CxtThreadProc& rhs) const
    {
        return (tid == rhs.getTid() && fun == rhs.getProc() && cxt == rhs.getContext());
    }

    inline bool operator!= (const CxtThreadProc& rhs) const
    {
        return !(*this==rhs);
    }

    inline void dump() const
    {
        SVFUtil::outs() << "[ Current Thread id: " << tid << "  Proc: " << fun->getName() << "\t Contexts: " << cxtToStr() << "  ]\n";
    }
 
private:
    NodeID tid;
};
 
} // End namespace SVF
// Specialise hash for the classes defined in this header file.
// Each hash must combine every field that operator== compares; hashing only a
// subset (e.g. the tid alone) collapses all keys sharing that field into one
// bucket. IDs are hashed instead of raw pointers so the bucket layout does not
// depend on allocation addresses.
template <> struct std::hash<SVF::CxtThread>
{
    size_t operator()(const SVF::CxtThread& ct) const
    {
        std::hash<SVF::CallStrCxt> ch;
        SVF::Hash<std::pair<SVF::NodeID, size_t>> pairH;
        const SVF::NodeID forksite =
            ct.getThread() != nullptr ? ct.getThread()->getId() : 0;
        return pairH({forksite, ch(ct.getContext())});
    }
};
template <> struct std::hash<SVF::CxtThreadProc>
{
    size_t operator()(const SVF::CxtThreadProc& ctp) const
    {
        std::hash<SVF::CallStrCxt> ch;
        SVF::Hash<std::pair<SVF::NodeID, size_t>> pairH;
        return pairH({ctp.getTid(),
                      pairH({ctp.getProc()->getId(), ch(ctp.getContext())})});
    }
};
template <> struct std::hash<SVF::CxtStmt>
{
    size_t operator()(const SVF::CxtStmt& cs) const
    {
        std::hash<SVF::CallStrCxt> ch;
        SVF::Hash<std::pair<SVF::NodeID, size_t>> pairH;
        return pairH({cs.getStmt()->getId(), ch(cs.getContext())});
    }
};
template <> struct std::hash<SVF::CxtThreadStmt>
{
    size_t operator()(const SVF::CxtThreadStmt& cts) const
    {
        std::hash<SVF::CxtStmt> csH;
        SVF::Hash<std::pair<SVF::NodeID, size_t>> pairH;
        return pairH({cts.getTid(), csH(cts)});
    }
};
template <> struct std::hash<SVF::CxtProc>
{
    size_t operator()(const SVF::CxtProc& cp) const
    {
        std::hash<SVF::CallStrCxt> ch;
        SVF::Hash<std::pair<SVF::NodeID, size_t>> pairH;
        return pairH({cp.getProc()->getId(), ch(cp.getContext())});
    }
};
#endif /* INCLUDE_UTIL_CXTSTMT_H_ */