svf-lib 1.0.2319 → 1.0.2321

package/SVF-osx/Release-build/include/SVF/MemoryModel/PointsTo.h

@@ -0,0 +1,255 @@
+//===- PointsTo.h -- Wrapper of set-like data structures  ------------//
+
+/*
+ * PointsTo.h
+ *
+ * Abstracts away data structures to be used as points-to sets.
+ *
+ *  Created on: Feb 01, 2021
+ *      Author: Mohamad Barbar
+ */
+
+#ifndef POINTSTO_H_
+#define POINTSTO_H_
+
+#include <vector>
+
+#include "SVFIR/SVFType.h"
+#include "Util/BitVector.h"
+#include "Util/CoreBitVector.h"
+#include "Util/SparseBitVector.h"
+
+namespace SVF
+{
+
+/// Wraps data structures to provide a points-to set.
+/// Underlying data structure can be changed globally.
+/// Includes support for mapping nodes for better internal representation.
+class PointsTo
+{
+public:
+    enum Type
+    {
+        SBV,
+        CBV,
+        BV,
+    };
+
+    class PointsToIterator;
+    typedef PointsToIterator const_iterator;
+    typedef const_iterator iterator;
+
+    typedef std::shared_ptr<std::vector<NodeID>> MappingPtr;
+
+public:
+    /// Construct empty points-to set.
+    PointsTo();
+    /// Copy constructor.
+    PointsTo(const PointsTo &pt);
+    /// Move constructor.
+    PointsTo(PointsTo &&pt) noexcept ;
+
+    ~PointsTo();
+
+    /// Copy assignment.
+    PointsTo &operator=(const PointsTo &rhs);
+
+    /// Move assignment.
+    PointsTo &operator=(PointsTo &&rhs) noexcept ;
+
+    /// Returns true if set is empty.
+    bool empty() const;
+
+    /// Returns number of elements.
+    u32_t count() const;
+
+    /// Empty the set.
+    void clear();
+
+    /// Returns true if n is in this set.
+    bool test(u32_t n) const;
+
+    /// Check if n is in set. If it is, returns false.
+    /// Otherwise, inserts n and returns true.
+    bool test_and_set(u32_t n);
+
+    /// Inserts n in the set.
+    void set(u32_t n);
+
+    /// Removes n from the set.
+    void reset(u32_t n);
+
+    /// Returns true if this set is a superset of rhs.
+    bool contains(const PointsTo &rhs) const;
+
+    /// Returns true if this set and rhs share any elements.
+    bool intersects(const PointsTo &rhs) const;
+
+    /// Returns the first element the set. Returns -1 when the set is empty.
+    /// TODO: should we diverge from LLVM about the int return?
+    int find_first();
+
+    /// Returns true if this set and rhs contain exactly the same elements.
+    bool operator==(const PointsTo &rhs) const;
+
+    /// Returns true if either this set or rhs has an element not in the other.
+    bool operator!=(const PointsTo &rhs) const;
+
+    /// Put union of this set and rhs into this set.
+    /// Returns true if this set changed.
+    bool operator|=(const PointsTo &rhs);
+    bool operator|=(const NodeBS &rhs);
+
+    /// Put intersection of this set and rhs into this set.
+    /// Returns true if this set changed.
+    bool operator&=(const PointsTo &rhs);
+
+    /// Remove elements in rhs from this set.
+    /// Returns true if this set changed.
+    bool operator-=(const PointsTo &rhs);
+
+    /// Put intersection of this set with complement of rhs into this set.
+    /// Returns true if this set changed.
+    bool intersectWithComplement(const PointsTo &rhs);
+
+    /// Put intersection of lhs with complement of rhs into this set (overwrites).
+    void intersectWithComplement(const PointsTo &lhs, const PointsTo &rhs);
+
+    /// Returns this points-to set as a NodeBS.
+    NodeBS toNodeBS() const;
+
+    /// Return a hash of this set.
+    size_t hash() const;
+
+    /// Checks if this points-to set is using the current best mapping.
+    /// If not, remaps.
+    void checkAndRemap();
+
+    const_iterator begin() const
+    {
+        return PointsToIterator(this);
+    }
+    const_iterator end() const
+    {
+        return PointsToIterator(this, true);
+    }
+
+    MappingPtr getNodeMapping() const;
+
+    static MappingPtr getCurrentBestNodeMapping();
+    static MappingPtr getCurrentBestReverseNodeMapping();
+    static void setCurrentBestNodeMapping(MappingPtr newCurrentBestNodeMapping,
+                                          MappingPtr newCurrentBestReverseNodeMapping);
+
+private:
+    /// Returns nodeMapping[n], checking for nullptr and size.
+    NodeID getInternalNode(NodeID n) const;
+
+    /// Returns reverseNodeMapping[n], checking for nullptr and size.
+    NodeID getExternalNode(NodeID n) const;
+
+    /// Returns true if this points-to set and pt have the same type, nodeMapping,
+    /// and reverseNodeMapping
+    bool metaSame(const PointsTo &pt) const;
+
+private:
+    /// Best node mapping we know of the for the analyses at hand.
+    static MappingPtr currentBestNodeMapping;
+    /// Likewise, but reversed.
+    static MappingPtr currentBestReverseNodeMapping;
+
+    /// Holds backing data structure.
+    /// TODO: std::variant when we move to C++17.
+    union
+    {
+        /// Sparse bit vector backing.
+        SparseBitVector<> sbv;
+        /// Core bit vector backing.
+        CoreBitVector cbv;
+        /// Bit vector backing.
+        BitVector bv;
+    };
+
+    /// Type of this points-to set.
+    enum Type type;
+    /// External nodes -> internal nodes.
+    MappingPtr nodeMapping;
+    /// Internal nodes -> external nodes.
+    MappingPtr reverseNodeMapping;
+
+public:
+    class PointsToIterator
+    {
+    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 &;
+
+        /// Deleted because we don't want iterators with null pt.
+        PointsToIterator() = delete;
+        PointsToIterator(const PointsToIterator &pt);
+        PointsToIterator(PointsToIterator &&pt) noexcept ;
+
+        /// Returns an iterator to the beginning of pt if end is false, and to
+        /// the end of pt if end is true.
+        explicit PointsToIterator(const PointsTo *pt, bool end=false);
+
+        PointsToIterator &operator=(const PointsToIterator &rhs);
+        PointsToIterator &operator=(PointsToIterator &&rhs) noexcept ;
+
+        /// Pre-increment: ++it.
+        const PointsToIterator &operator++();
+
+        /// Post-increment: it++.
+        const PointsToIterator operator++(int);
+
+        /// Dereference: *it.
+        u32_t operator*() const;
+
+        /// Equality: *this == rhs.
+        bool operator==(const PointsToIterator &rhs) const;
+
+        /// Inequality: *this != rhs.
+        bool operator!=(const PointsToIterator &rhs) const;
+
+    private:
+        bool atEnd() const;
+
+    private:
+        /// PointsTo we are iterating over.
+        const PointsTo *pt;
+        /// Iterator into the backing data structure. Discriminated by pt->type.
+        /// TODO: std::variant when we move to C++17.
+        union
+        {
+            SparseBitVector<>::iterator sbvIt;
+            CoreBitVector::iterator cbvIt;
+            BitVector::iterator bvIt;
+        };
+    };
+};
+
+/// Returns a new lhs | rhs.
+PointsTo operator|(const PointsTo &lhs, const PointsTo &rhs);
+
+/// Returns a new lhs & rhs.
+PointsTo operator&(const PointsTo &lhs, const PointsTo &rhs);
+
+/// Returns a new lhs - rhs.
+PointsTo operator-(const PointsTo &lhs, const PointsTo &rhs);
+
+} // End namespace SVF
+
+template <>
+struct std::hash<SVF::PointsTo>
+{
+    size_t operator()(const SVF::PointsTo &pt) const
+    {
+        return pt.hash();
+    }
+};
+
+
+#endif  // POINTSTO_H_

package/SVF-osx/Release-build/include/SVF/MemoryModel/SVFLoop.h

@@ -0,0 +1,167 @@
+//===- SVFLoop.h -- SVFLoop of SVF ------------------------------//
+//
+//                     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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * SVFLoop.h
+ *
+ *  Created on: 14, 06, 2022
+ *      Author: Jiawei Wang, Xiao Cheng
+ */
+
+#ifndef SVF_SVFLOOP_H
+#define SVF_SVFLOOP_H
+
+#include "SVFIR/SVFType.h"
+
+namespace SVF
+{
+
+class SVFLoop
+{
+    friend class SVFIRWriter;
+    friend class SVFIRReader;
+
+    typedef Set<const ICFGEdge *> ICFGEdgeSet;
+    typedef Set<const ICFGNode *> ICFGNodeSet;
+private:
+    ICFGEdgeSet entryICFGEdges, backICFGEdges, inICFGEdges, outICFGEdges;
+    ICFGNodeSet icfgNodes;
+    u32_t loopBound;
+
+public:
+    SVFLoop(const ICFGNodeSet &_nodes, u32_t _bound) :
+        icfgNodes(_nodes), loopBound(_bound)
+    {
+
+    }
+
+    virtual ~SVFLoop() = default;
+
+    inline ICFGNodeSet::iterator ICFGNodesBegin()
+    {
+        return icfgNodes.begin();
+    }
+
+    inline ICFGNodeSet::iterator ICFGNodesEnd()
+    {
+        return icfgNodes.end();
+    }
+
+    inline bool isInLoop(const ICFGNode *icfgNode) const
+    {
+        return icfgNodes.find(icfgNode) != icfgNodes.end();
+    }
+
+    inline bool isEntryICFGEdge(const ICFGEdge *edge) const
+    {
+        return entryICFGEdges.find(edge) != entryICFGEdges.end();
+    }
+
+    inline bool isBackICFGEdge(const ICFGEdge *edge) const
+    {
+        return backICFGEdges.find(edge) != backICFGEdges.end();
+    }
+
+    inline bool isInICFGEdge(const ICFGEdge *edge) const
+    {
+        return inICFGEdges.find(edge) != inICFGEdges.end();
+    }
+
+    inline bool isOutICFGEdge(const ICFGEdge *edge) const
+    {
+        return outICFGEdges.find(edge) != outICFGEdges.end();
+    }
+
+    inline void addEntryICFGEdge(const ICFGEdge *edge)
+    {
+        entryICFGEdges.insert(edge);
+    }
+
+    inline ICFGEdgeSet::iterator entryICFGEdgesBegin()
+    {
+        return entryICFGEdges.begin();
+    }
+
+    inline ICFGEdgeSet::iterator entryICFGEdgesEnd()
+    {
+        return entryICFGEdges.end();
+    }
+
+    inline void addOutICFGEdge(const ICFGEdge *edge)
+    {
+        outICFGEdges.insert(edge);
+    }
+
+    inline ICFGEdgeSet::iterator outICFGEdgesBegin()
+    {
+        return outICFGEdges.begin();
+    }
+
+    inline ICFGEdgeSet::iterator outICFGEdgesEnd()
+    {
+        return outICFGEdges.end();
+    }
+
+    inline void addBackICFGEdge(const ICFGEdge *edge)
+    {
+        backICFGEdges.insert(edge);
+    }
+
+    inline ICFGEdgeSet::iterator backICFGEdgesBegin()
+    {
+        return backICFGEdges.begin();
+    }
+
+    inline ICFGEdgeSet::iterator backICFGEdgesEnd()
+    {
+        return backICFGEdges.end();
+    }
+
+    inline void addInICFGEdge(const ICFGEdge *edge)
+    {
+        inICFGEdges.insert(edge);
+    }
+
+    inline ICFGEdgeSet::iterator inEdgesBegin()
+    {
+        return inICFGEdges.begin();
+    }
+
+    inline ICFGEdgeSet::iterator inEdgesEnd()
+    {
+        return inICFGEdges.end();
+    }
+
+    inline void setLoopBound(u32_t _bound)
+    {
+        loopBound = _bound;
+    }
+
+    inline u32_t getLoopBound() const
+    {
+        return loopBound;
+    }
+};
+
+} // End namespace SVF
+
+#endif //SVF_SVFLOOP_H

package/SVF-osx/Release-build/include/SVF/SABER/DoubleFreeChecker.h

@@ -0,0 +1,76 @@
+//===- DoubleFreeChecker.h -- Checking double-free errors---------------------//
+//
+//                     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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * DoubleFreeChecker.h
+ *
+ *  Created on: Apr 24, 2014
+ *      Author: Yulei Sui
+ */
+
+#ifndef DOUBLEFREECHECKER_H_
+#define DOUBLEFREECHECKER_H_
+
+#include "SABER/LeakChecker.h"
+
+namespace SVF
+{
+
+/*!
+ * Double free checker to check deallocations of memory
+ */
+
+class DoubleFreeChecker : public LeakChecker
+{
+
+public:
+    /// Constructor
+    DoubleFreeChecker(): LeakChecker()
+    {
+    }
+
+    /// Destructor
+    virtual ~DoubleFreeChecker()
+    {
+    }
+
+    /// We start from here
+    virtual bool runOnModule(SVFIR* pag) override
+    {
+        /// start analysis
+        analyze();
+        return false;
+    }
+
+    /// Report file/close bugs
+    void reportBug(ProgSlice* slice) override;
+
+
+    /// Validate test cases for regression test purpose
+    void testsValidation(ProgSlice* slice);
+    void validateSuccessTests(ProgSlice* slice, const FunObjVar* fun);
+    void validateExpectedFailureTests(ProgSlice* slice, const FunObjVar* fun);
+};
+
+} // End namespace SVF
+
+#endif /* DOUBLEFREECHECKER_H_ */

package/SVF-osx/Release-build/include/SVF/SABER/FileChecker.h

@@ -0,0 +1,80 @@
+//===- FileChecker.h -- Checking incorrect file-open close errors-------------//
+//
+//                     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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * FileChecker.h
+ *
+ *  Created on: Apr 24, 2014
+ *      Author: Yulei Sui
+ */
+
+#ifndef FILECHECK_H_
+#define FILECHECK_H_
+
+#include "SABER/LeakChecker.h"
+
+namespace SVF
+{
+
+/*!
+ * File open/close checker to check consistency of file operations
+ */
+
+class FileChecker : public LeakChecker
+{
+
+public:
+
+    /// Constructor
+    FileChecker(): LeakChecker()
+    {
+    }
+
+    /// Destructor
+    virtual ~FileChecker()
+    {
+    }
+
+    /// We start from here
+    virtual bool runOnModule(SVFIR* pag)
+    {
+        /// start analysis
+        analyze();
+        return false;
+    }
+
+    inline bool isSourceLikeFun(const FunObjVar* fun)
+    {
+        return SaberCheckerAPI::getCheckerAPI()->isFOpen(fun);
+    }
+    /// Whether the function is a heap deallocator (free/release memory)
+    inline bool isSinkLikeFun(const FunObjVar* fun)
+    {
+        return SaberCheckerAPI::getCheckerAPI()->isFClose(fun);
+    }
+    /// Report file/close bugs
+    void reportBug(ProgSlice* slice);
+};
+
+} // End namespace SVF
+
+#endif /* FILECHECK_H_ */

package/SVF-osx/Release-build/include/SVF/SABER/LeakChecker.h

@@ -0,0 +1,122 @@
+//===- LeakChecker.h -- Detecting memory leaks--------------------------------//
+//
+//                     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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * LeakChecker.h
+ *
+ *  Created on: Apr 1, 2014
+ *      Author: rockysui
+ */
+
+#ifndef LEAKCHECKER_H_
+#define LEAKCHECKER_H_
+
+#include "SABER/SrcSnkDDA.h"
+#include "SABER/SaberCheckerAPI.h"
+
+namespace SVF
+{
+
+/*!
+ * Static Memory Leak Detector
+ */
+class LeakChecker : public SrcSnkDDA
+{
+
+public:
+    typedef Map<const SVFGNode*,const CallICFGNode*> SVFGNodeToCSIDMap;
+    typedef FIFOWorkList<const CallICFGNode*> CSWorkList;
+    typedef ProgSlice::VFWorkList WorkList;
+    typedef NodeBS SVFGNodeBS;
+    enum LEAK_TYPE
+    {
+        NEVER_FREE_LEAK,
+        CONTEXT_LEAK,
+        PATH_LEAK,
+        GLOBAL_LEAK
+    };
+
+    /// Constructor
+    LeakChecker()
+    {
+    }
+    /// Destructor
+    virtual ~LeakChecker()
+    {
+    }
+
+    /// We start from here
+    virtual bool runOnModule(SVFIR* pag)
+    {
+        /// start analysis
+        analyze();
+        return false;
+    }
+
+    /// Initialize sources and sinks
+    //@{
+    /// Initialize sources and sinks
+    virtual void initSrcs() override;
+    virtual void initSnks() override;
+    /// Whether the function is a heap allocator/reallocator (allocate memory)
+    virtual inline bool isSourceLikeFun(const FunObjVar* fun) override
+    {
+        return SaberCheckerAPI::getCheckerAPI()->isMemAlloc(fun);
+    }
+    /// Whether the function is a heap deallocator (free/release memory)
+    virtual inline bool isSinkLikeFun(const FunObjVar* fun) override
+    {
+        return SaberCheckerAPI::getCheckerAPI()->isMemDealloc(fun);
+    }
+    //@}
+
+protected:
+    /// Report leaks
+    //@{
+    virtual void reportBug(ProgSlice* slice) override;
+    //@}
+
+    /// Validate test cases for regression test purpose
+    void testsValidation(const ProgSlice* slice);
+    void validateSuccessTests(const SVFGNode* source, const FunObjVar* fun);
+    void validateExpectedFailureTests(const SVFGNode* source, const FunObjVar* fun);
+
+    /// Record a source to its callsite
+    //@{
+    inline void addSrcToCSID(const SVFGNode* src, const CallICFGNode* cs)
+    {
+        srcToCSIDMap[src] = cs;
+    }
+    inline const CallICFGNode* getSrcCSID(const SVFGNode* src)
+    {
+        SVFGNodeToCSIDMap::iterator it =srcToCSIDMap.find(src);
+        assert(it!=srcToCSIDMap.end() && "source node not at a callsite??");
+        return it->second;
+    }
+    //@}
+private:
+    SVFGNodeToCSIDMap srcToCSIDMap;
+};
+
+} // End namespace SVF
+
+#endif /* LEAKCHECKER_H_ */