svf-lib 1.0.2319 → 1.0.2321

package/SVF-osx/Release-build/include/SVF/Util/CoreBitVector.h

@@ -0,0 +1,214 @@
+//===- CoreBitVector.h -- Dynamically sized bit vector data structure ------------//
+
+/*
+ * CoreBitVector.h
+ *
+ * Contiguous bit vector which resizes as required by common operations.
+ *
+ *  Created on: Jan 31, 2021
+ *      Author: Mohamad Barbar
+ */
+
+#ifndef COREBITVECTOR_H_
+#define COREBITVECTOR_H_
+
+#include <assert.h>
+#include <vector>
+
+#include "SVFIR/SVFType.h"
+
+namespace SVF
+{
+
+/// A contiguous bit vector that only contains what it needs according
+/// to the operations carried. For example, when two bit vectors are unioned,
+/// their sizes may be increased to fit all the bits from the other set.
+/// This implementation never shrinks. Since points-to sets (generally) grow
+/// monotonically, does not have too big an impact on points-to analysis and
+/// so it isn't implemented.
+/// Abbreviated CBV.
+class CoreBitVector
+{
+public:
+    typedef unsigned long long Word;
+    static const size_t WordSize;
+
+    class CoreBitVectorIterator;
+    typedef CoreBitVectorIterator const_iterator;
+    typedef const_iterator iterator;
+
+public:
+    /// Construct empty CBV.
+    CoreBitVector(void);
+
+    /// Construct empty CBV with space reserved for n Words.
+    CoreBitVector(size_t n);
+
+    /// Copy constructor.
+    CoreBitVector(const CoreBitVector &cbv);
+
+    /// Move constructor.
+    CoreBitVector(CoreBitVector &&cbv);
+
+    /// Copy assignment.
+    CoreBitVector &operator=(const CoreBitVector &rhs);
+
+    /// Move assignment.
+    CoreBitVector &operator=(CoreBitVector &&rhs);
+
+    /// Returns true if no bits are set.
+    bool empty(void) const;
+
+    /// Returns number of bits set.
+    u32_t count(void) const;
+
+    /// Empty the CBV.
+    void clear(void);
+
+    /// Returns true if bit is set in this CBV.
+    bool test(u32_t bit) const;
+
+    /// Check if bit is set. If it is, returns false.
+    /// Otherwise, sets bit and returns true.
+    bool test_and_set(u32_t bit);
+
+    /// Sets bit in the CBV.
+    void set(u32_t bit);
+
+    /// Resets bit in the CBV.
+    void reset(u32_t bit);
+
+    /// Returns true if this CBV is a superset of rhs.
+    bool contains(const CoreBitVector &rhs) const;
+
+    /// Returns true if this CBV and rhs share any set bits.
+    bool intersects(const CoreBitVector &rhs) const;
+
+    /// Returns true if this CBV and rhs have the same bits set.
+    bool operator==(const CoreBitVector &rhs) const;
+
+    /// Returns true if either this CBV or rhs has a bit set unique to the other.
+    bool operator!=(const CoreBitVector &rhs) const;
+
+    /// Put union of this CBV and rhs into this CBV.
+    /// Returns true if CBV changed.
+    bool operator|=(const CoreBitVector &rhs);
+
+    /// Put intersection of this CBV and rhs into this CBV.
+    /// Returns true if CBV changed.
+    bool operator&=(const CoreBitVector &rhs);
+
+    /// Remove set bits in rhs from this CBV.
+    /// Returns true if CBV changed.
+    bool operator-=(const CoreBitVector &rhs);
+
+    /// Put intersection of this CBV with complement of rhs into this CBV.
+    /// Returns true if this CBV changed.
+    bool intersectWithComplement(const CoreBitVector &rhs);
+
+    /// Put intersection of lhs with complement of rhs into this CBV.
+    void intersectWithComplement(const CoreBitVector &lhs, const CoreBitVector &rhs);
+
+    /// Hash for this CBV.
+    size_t hash(void) const;
+
+    const_iterator begin(void) const;
+    const_iterator end(void) const;
+
+private:
+    /// Add enough words (prepend) to be able to include bit.
+    void extendBackward(u32_t bit);
+
+    /// Add enough words (append) to be able to include bit.
+    void extendForward(u32_t bit);
+
+    /// Add enough words (append xor prepend) to be able to include bit.
+    void extendTo(u32_t bit);
+
+    /// Returns the index into words which would hold bit.
+    size_t indexForBit(u32_t bit) const;
+
+    /// Returns true if bit can fit in this CBV without resizing.
+    bool canHold(u32_t bit) const;
+
+    /// Returns the last bit that this CBV can hold.
+    u32_t finalBit(void) const;
+
+    /// Returns the first bit position that both this CBV and rhs *can* hold.
+    u32_t firstCommonBit(const CoreBitVector &rhs) const;
+
+    /// Returns the next index in the words array at or after start which contains
+    /// set bits. This index and start are indices into the words array not
+    /// accounting for the offset. Returns a value greater than or equal to
+    /// words.size() when there are no more set bits.
+    size_t nextSetIndex(const size_t start) const;
+
+public:
+    class CoreBitVectorIterator
+    {
+    public:
+        using iterator_category = std::forward_iterator_tag;
+        using value_type = u32_t;
+        using difference_type = std::ptrdiff_t;
+        using pointer = u32_t *;
+        using reference = u32_t &;
+
+        CoreBitVectorIterator(void) = delete;
+
+        /// Returns an iterator to the beginning of cbv if end is false, and to
+        /// the end of cbv if end is true.
+        CoreBitVectorIterator(const CoreBitVector *cbv, bool end=false);
+
+        CoreBitVectorIterator(const CoreBitVectorIterator &cbv) = default;
+        CoreBitVectorIterator(CoreBitVectorIterator &&cbv) = default;
+
+        CoreBitVectorIterator &operator=(const CoreBitVectorIterator &cbv) = default;
+        CoreBitVectorIterator &operator=(CoreBitVectorIterator &&cbv) = default;
+
+        /// Pre-increment: ++it.
+        const CoreBitVectorIterator &operator++(void);
+
+        /// Post-increment: it++.
+        const CoreBitVectorIterator operator++(int);
+
+        /// Dereference: *it.
+        u32_t operator*(void) const;
+
+        /// Equality: *this == rhs.
+        bool operator==(const CoreBitVectorIterator &rhs) const;
+
+        /// Inequality: *this != rhs.
+        bool operator!=(const CoreBitVectorIterator &rhs) const;
+
+    private:
+        bool atEnd(void) const;
+
+    private:
+        /// CoreBitVector we are iterating over.
+        const CoreBitVector *cbv;
+        /// Word in words we are looking at.
+        std::vector<Word>::const_iterator wordIt;
+        /// Current bit in wordIt we are looking at
+        /// (index into *wordIt).
+        u32_t bit;
+    };
+
+private:
+    /// The first bit of the first word.
+    u32_t offset;
+    /// Our actual bit vector.
+    std::vector<Word> words;
+};
+
+template <>
+struct Hash<CoreBitVector>
+{
+    size_t operator()(const CoreBitVector &cbv) const
+    {
+        return cbv.hash();
+    }
+};
+
+} // End namespace SVF
+
+#endif  // COREBITVECTOR_H_

package/SVF-osx/Release-build/include/SVF/Util/CxtStmt.h

@@ -0,0 +1,502 @@
+//===- 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_
+
+#include "SVFIR/SVFValue.h"
+
+namespace SVF
+{
+
+class ICFGNode;
+/*!
+ * Context-sensitive thread statement <c,s>
+ */
+class CxtStmt
+{
+public:
+    /// Constructor
+    CxtStmt(const CallStrCxt& c, const ICFGNode* f) :cxt(c), inst(f)
+    {
+    }
+    /// Copy constructor
+    CxtStmt(const CxtStmt& ctm) : cxt(ctm.getContext()),inst(ctm.getStmt())
+    {
+    }
+    /// Destructor
+    virtual ~CxtStmt()
+    {
+    }
+    /// Return current context
+    inline const CallStrCxt& getContext() const
+    {
+        return cxt;
+    }
+    /// Return current statement
+    inline const ICFGNode* getStmt() const
+    {
+        return inst;
+    }
+    /// Enable compare operator to avoid duplicated item insertion in map or set
+    /// to be noted that two vectors can also overload operator()
+    inline bool operator< (const CxtStmt& rhs) const
+    {
+        if(inst!=rhs.getStmt())
+            return inst < rhs.getStmt();
+        else
+            return cxt < rhs.getContext();
+    }
+    /// Overloading operator=
+    inline CxtStmt& operator= (const CxtStmt& rhs)
+    {
+        if(*this!=rhs)
+        {
+            inst = rhs.getStmt();
+            cxt = rhs.getContext();
+        }
+        return *this;
+    }
+    /// Overloading operator==
+    inline bool operator== (const CxtStmt& rhs) const
+    {
+        return (inst == rhs.getStmt() && cxt == rhs.getContext());
+    }
+    /// Overloading operator==
+    inline bool operator!= (const CxtStmt& rhs) const
+    {
+        return !(*this==rhs);
+    }
+    /// Return context in string format
+    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();
+    }
+    /// Dump CxtStmt
+    inline void dump() const
+    {
+        SVFUtil::outs() << "[ Current Stmt: " << inst->toString() << "\t Contexts: " << cxtToStr() << "  ]\n";
+    }
+
+protected:
+    CallStrCxt cxt;
+    const ICFGNode* inst;
+};
+
+
+/*!
+ * Context-sensitive thread statement <t,c,s>
+ */
+class CxtThreadStmt : public CxtStmt
+{
+public:
+    /// Constructor
+    CxtThreadStmt(NodeID t, const CallStrCxt& c, const ICFGNode* f) :CxtStmt(c,f), tid(t)
+    {
+    }
+    /// Copy constructor
+    CxtThreadStmt(const CxtThreadStmt& ctm) :CxtStmt(ctm), tid(ctm.getTid())
+    {
+    }
+    /// Destructor
+    virtual ~CxtThreadStmt()
+    {
+    }
+    /// Return current context
+    inline NodeID getTid() const
+    {
+        return tid;
+    }
+    /// Enable compare operator to avoid duplicated item insertion in map or set
+    /// to be noted that two vectors can also overload operator()
+    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();
+    }
+    /// Overloading operator=
+    inline CxtThreadStmt& operator= (const CxtThreadStmt& rhs)
+    {
+        if(*this!=rhs)
+        {
+            CxtStmt::operator=(rhs);
+            tid = rhs.getTid();
+        }
+        return *this;
+    }
+    /// Overloading operator==
+    inline bool operator== (const CxtThreadStmt& rhs) const
+    {
+        return (tid == rhs.getTid() && inst == rhs.getStmt() && cxt == rhs.getContext());
+    }
+    /// Overloading operator==
+    inline bool operator!= (const CxtThreadStmt& rhs) const
+    {
+        return !(*this==rhs);
+    }
+    /// Dump CxtThreadStmt
+    inline void dump() const
+    {
+        SVFUtil::outs() << "[ Current Thread id: " << tid << "  Stmt: " << inst->toString() << "\t Contexts: " << cxtToStr() << "  ]\n";
+    }
+
+private:
+    NodeID tid;
+};
+
+
+/*!
+ * Context-sensitive thread <c,t>
+ */
+class CxtThread
+{
+public:
+    /// Constructor
+    CxtThread(const CallStrCxt& c, const ICFGNode* fork) : cxt(c), forksite(fork), inloop(false), incycle(false)
+    {
+    }
+    /// Copy constructor
+    CxtThread(const CxtThread& ct) :
+        cxt(ct.getContext()), forksite(ct.getThread()), inloop(ct.isInloop()), incycle(ct.isIncycle())
+    {
+    }
+    /// Destructor
+    virtual ~CxtThread()
+    {
+    }
+    /// Return context of the thread
+    inline const CallStrCxt& getContext() const
+    {
+        return cxt;
+    }
+    /// Return forksite
+    inline const ICFGNode* getThread() const
+    {
+        return forksite;
+    }
+    /// Enable compare operator to avoid duplicated item insertion in map or set
+    /// to be noted that two vectors can also overload operator()
+    inline bool operator< (const CxtThread& rhs) const
+    {
+        if (forksite != rhs.getThread())
+            return forksite < rhs.getThread();
+        else
+            return cxt < rhs.getContext();
+    }
+    /// Overloading operator=
+    inline CxtThread& operator= (const CxtThread& rhs)
+    {
+        if(*this!=rhs)
+        {
+            forksite = rhs.getThread();
+            cxt = rhs.getContext();
+        }
+        return *this;
+    }
+    /// Overloading operator==
+    inline bool operator== (const CxtThread& rhs) const
+    {
+        return (forksite == rhs.getThread() && cxt == rhs.getContext());
+    }
+    /// Overloading operator==
+    inline bool operator!= (const CxtThread& rhs) const
+    {
+        return !(*this==rhs);
+    }
+    /// Return context in string format
+    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();
+    }
+
+    /// inloop, incycle attributes
+    //@{
+    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;
+    }
+    //@}
+
+    /// Dump CxtThread
+    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;
+};
+
+
+/*!
+ * Context-sensitive procedure <c,m>
+ * c represent current context
+ * m represent current procedure
+ */
+class CxtProc
+{
+public:
+    /// Constructor
+    CxtProc(const CallStrCxt& c, const FunObjVar* f) :
+        cxt(c), fun(f)
+    {
+    }
+    /// Copy constructor
+    CxtProc(const CxtProc& ctm) :
+        cxt(ctm.getContext()), fun(ctm.getProc())
+    {
+    }
+    /// Destructor
+    virtual ~CxtProc()
+    {
+    }
+    /// Return current procedure
+    inline const FunObjVar* getProc() const
+    {
+        return fun;
+    }
+    /// Return current context
+    inline const CallStrCxt& getContext() const
+    {
+        return cxt;
+    }
+    /// Enable compare operator to avoid duplicated item insertion in map or set
+    /// to be noted that two vectors can also overload operator()
+    inline bool operator<(const CxtProc& rhs) const
+    {
+        if (fun != rhs.getProc())
+            return fun < rhs.getProc();
+        else
+            return cxt < rhs.getContext();
+    }
+    /// Overloading operator=
+    inline CxtProc& operator=(const CxtProc& rhs)
+    {
+        if (*this != rhs)
+        {
+            fun = rhs.getProc();
+            cxt = rhs.getContext();
+        }
+        return *this;
+    }
+    /// Overloading operator==
+    inline bool operator==(const CxtProc& rhs) const
+    {
+        return (fun == rhs.getProc() && cxt == rhs.getContext());
+    }
+    /// Overloading operator==
+    inline bool operator!=(const CxtProc& rhs) const
+    {
+        return !(*this == rhs);
+    }
+    /// Return context in string format
+    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();
+    }
+    /// Dump CxtProc
+    inline void dump() const
+    {
+        SVFUtil::outs() << "[ Proc: " << fun->getName() << "\t Contexts: " << cxtToStr() << "  ]\n";
+    }
+
+protected:
+    CallStrCxt cxt;
+    const FunObjVar* fun;
+};
+
+
+/*!
+ * Context-sensitive procedure <t,c,m>
+ * t represent current thread during traversing
+ * c represent current context
+ * m represent current procedure
+ */
+class CxtThreadProc : public CxtProc
+{
+public:
+    /// Constructor
+    CxtThreadProc(NodeID t, const CallStrCxt& c, const FunObjVar* f) :CxtProc(c,f),tid(t)
+    {
+    }
+    /// Copy constructor
+    CxtThreadProc(const CxtThreadProc& ctm) : CxtProc(ctm.getContext(),ctm.getProc()), tid(ctm.getTid())
+    {
+    }
+    /// Destructor
+    virtual ~CxtThreadProc()
+    {
+    }
+    /// Return current thread id
+    inline NodeID getTid() const
+    {
+        return tid;
+    }
+    /// Enable compare operator to avoid duplicated item insertion in map or set
+    /// to be noted that two vectors can also overload operator()
+    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();
+    }
+    /// Overloading operator=
+    inline CxtThreadProc& operator= (const CxtThreadProc& rhs)
+    {
+        if(*this!=rhs)
+        {
+            tid = rhs.getTid();
+            fun = rhs.getProc();
+            cxt = rhs.getContext();
+        }
+        return *this;
+    }
+    /// Overloading operator==
+    inline bool operator== (const CxtThreadProc& rhs) const
+    {
+        return (tid == rhs.getTid() && fun == rhs.getProc() && cxt == rhs.getContext());
+    }
+    /// Overloading operator==
+    inline bool operator!= (const CxtThreadProc& rhs) const
+    {
+        return !(*this==rhs);
+    }
+    /// Dump CxtThreadProc
+    inline void dump() const
+    {
+        SVFUtil::outs() << "[ Current Thread id: " << tid << "  Proc: " << fun->getName() << "\t Contexts: " << cxtToStr() << "  ]\n";
+    }
+
+private:
+    NodeID tid;
+};
+
+} // End namespace SVF
+// Specialise has for class defined in this header file
+template <> struct std::hash<SVF::CxtThread>
+{
+    size_t operator()(const SVF::CxtThread& cs) const
+    {
+        std::hash<SVF::CallStrCxt> h;
+        return h(cs.getContext());
+    }
+};
+template <> struct std::hash<SVF::CxtThreadProc>
+{
+    size_t operator()(const SVF::CxtThreadProc& ctp) const
+    {
+        std::hash<SVF::NodeID> h;
+        return h(ctp.getTid());
+    }
+};
+template <> struct std::hash<SVF::CxtThreadStmt>
+{
+    size_t operator()(const SVF::CxtThreadStmt& cts) const
+    {
+        std::hash<SVF::NodeID> h;
+        return h(cts.getTid());
+    }
+};
+template <> struct std::hash<SVF::CxtStmt>
+{
+    size_t operator()(const SVF::CxtStmt& cs) const
+    {
+        std::hash<SVF::ICFGNode*> h;
+        SVF::ICFGNode* inst = const_cast<SVF::ICFGNode*> (cs.getStmt());
+        return h(inst);
+    }
+};
+template <> struct std::hash<SVF::CxtProc>
+{
+    size_t operator()(const SVF::CxtProc& cs) const
+    {
+        std::hash<SVF::FunObjVar*> h;
+        SVF::FunObjVar* fun = const_cast<SVF::FunObjVar*> (cs.getProc());
+        return h(fun);
+    }
+};
+#endif /* INCLUDE_UTIL_CXTSTMT_H_ */