svf-lib 1.0.2319 → 1.0.2321

package/SVF-osx/Release-build/include/SVF/AE/Core/AddressValue.h

@@ -0,0 +1,225 @@
+//===- AddressValue.h ----Address Value Sets-------------------------//
+//
+//                     SVF: Static Value-Flow Analysis
+//
+// Copyright (C) <2013-2022>  <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/>.
+//
+//===----------------------------------------------------------------------===//
+/*
+ * AddressValue.h
+ *
+ *  Created on: Jul 9, 2022
+ *      Author: Xiao Cheng
+ *
+ */
+
+#ifndef Z3_EXAMPLE_ADDRESSVALUE_H
+#define Z3_EXAMPLE_ADDRESSVALUE_H
+
+#define AddressMask 0x7f000000
+#define FlippedAddressMask (AddressMask^0xffffffff)
+// the address of InvalidMem(the black hole), getVirtualMemAddress(2);
+#define InvalidMemAddr 0x7f000000 + 2
+// the address of NullMem, getVirtualMemAddress(0);
+#define NullMemAddr 0x7f000000
+
+
+
+#include "Util/GeneralType.h"
+#include <sstream>
+
+namespace SVF
+{
+class AddressValue
+{
+    friend class AbstractState;
+    friend class RelExeState;
+public:
+    typedef Set<u32_t> AddrSet;
+private:
+    AddrSet _addrs;
+
+    /// Return the internal index if idx is an address otherwise return the value of idx
+    static inline u32_t getInternalID(u32_t idx)
+    {
+        return (idx & FlippedAddressMask);
+    }
+
+public:
+    /// Default constructor
+    AddressValue() {}
+
+    /// Constructor
+    AddressValue(const Set<u32_t> &addrs) :  _addrs(addrs) {}
+
+    AddressValue(u32_t addr) :  _addrs({addr}) {}
+
+    /// Default destructor
+    ~AddressValue() = default;
+
+    /// Copy constructor
+    AddressValue(const AddressValue &other) : _addrs(other._addrs) {}
+
+    /// Move constructor
+    AddressValue(AddressValue &&other) noexcept: _addrs(std::move(other._addrs)) {}
+
+    /// Copy operator=
+    AddressValue &operator=(const AddressValue &other)
+    {
+        if (!this->equals(other))
+        {
+            _addrs = other._addrs;
+        }
+        return *this;
+    }
+
+    /// Move operator=
+    AddressValue &operator=(AddressValue &&other) noexcept
+    {
+        if (this != &other)
+        {
+            _addrs = std::move(other._addrs);
+        }
+        return *this;
+    }
+
+    bool equals(const AddressValue &rhs) const
+    {
+        return _addrs == rhs._addrs;
+    }
+
+    AddrSet::const_iterator begin() const
+    {
+        return _addrs.cbegin();
+    }
+
+    AddrSet::const_iterator end() const
+    {
+        return _addrs.cend();
+    }
+
+    bool empty() const
+    {
+        return _addrs.empty();
+    }
+
+    u32_t size() const
+    {
+        return _addrs.size();
+    }
+
+    std::pair<AddressValue::AddrSet::iterator, bool> insert(u32_t id)
+    {
+        return _addrs.insert(id);
+    }
+
+    const AddrSet &getVals() const
+    {
+        return _addrs;
+    }
+
+    void setVals(const AddrSet &vals)
+    {
+        _addrs = vals;
+    }
+
+    /// Current AddressValue joins with another AddressValue
+    bool join_with(const AddressValue &other)
+    {
+        bool changed = false;
+        for (const auto &addr: other)
+        {
+            if (!_addrs.count(addr))
+            {
+                if (insert(addr).second)
+                    changed = true;
+            }
+        }
+        return changed;
+    }
+
+    /// Return a intersected AddressValue
+    bool meet_with(const AddressValue &other)
+    {
+        AddrSet s;
+        for (const auto &id: other._addrs)
+        {
+            if (_addrs.find(id) != _addrs.end())
+            {
+                s.insert(id);
+            }
+        }
+        bool changed = (_addrs != s);
+        _addrs = std::move(s);
+        return changed;
+    }
+
+    /// Return true if the AddressValue contains n
+    bool contains(u32_t id) const
+    {
+        return _addrs.count(id);
+    }
+
+    bool hasIntersect(const AddressValue &other)
+    {
+        AddressValue v = *this;
+        v.meet_with(other);
+        return !v.empty();
+    }
+
+    inline bool isBottom() const
+    {
+        return empty();
+    }
+
+    const std::string toString() const
+    {
+        std::string str;
+        std::stringstream rawStr(str);
+        if (this->isBottom())
+        {
+            rawStr << "⊥";
+        }
+        else
+        {
+            rawStr << "[";
+            for (auto it = _addrs.begin(), eit = _addrs.end(); it!= eit; ++it)
+            {
+                rawStr << *it << ", ";
+            }
+            rawStr << "]";
+        }
+        return rawStr.str();
+    }
+
+    /// The physical address starts with 0x7f...... + idx
+    static inline u32_t getVirtualMemAddress(u32_t idx)
+    {
+        // 0 is the null address, should not be used as a virtual address
+        assert(idx != 0 && "idx can’t be 0 because it represents a nullptr");
+        return AddressMask + idx;
+    }
+
+    /// Check bit value of val start with 0x7F000000, filter by 0xFF000000
+    static inline bool isVirtualMemAddress(u32_t val)
+    {
+        return (val & 0xff000000) == AddressMask && val != AddressMask + 0;
+    }
+
+};
+} // end namespace SVF
+#endif //Z3_EXAMPLE_ADDRESSVALUE_H

package/SVF-osx/Release-build/include/SVF/AE/Core/ICFGWTO.h

@@ -0,0 +1,135 @@
+//===--------------- ICFGWTO.h -- WTO for ICFG----------------------//
+//
+//                     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 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * ICFGWTO.h
+ *
+ * The implementation is based on F. Bourdoncle's paper:
+ * "Efficient chaotic iteration strategies with widenings", Formal
+ * Methods in Programming and Their Applications, 1993, pages 128-141.
+ *
+ *  Created on: Jan 22, 2024
+ *      Author: Xiao Cheng
+ *
+ */
+#ifndef SVF_ICFGWTO_H
+#define SVF_ICFGWTO_H
+
+#include "Graphs/ICFG.h"
+#include "Graphs/WTO.h"
+#include "Graphs/CallGraph.h"
+
+namespace SVF
+{
+
+typedef WTOComponent<ICFG> ICFGWTOComp;
+typedef WTONode<ICFG> ICFGSingletonWTO;
+typedef WTOCycle<ICFG> ICFGCycleWTO;
+
+class ICFGWTO : public WTO<ICFG>
+{
+public:
+    typedef WTO<ICFG> Base;
+    typedef WTOComponentVisitor<ICFG>::WTONodeT ICFGWTONode;
+
+    explicit ICFGWTO(ICFG* graph, const ICFGNode* node) : Base(graph, node) {}
+
+    virtual ~ICFGWTO()
+    {
+    }
+
+    inline void forEachSuccessor(
+        const ICFGNode* node,
+        std::function<void(const ICFGNode*)> func) const override
+    {
+        if (const auto* callNode = SVFUtil::dyn_cast<CallICFGNode>(node))
+        {
+            const ICFGNode* succ = callNode->getRetICFGNode();
+            func(succ);
+        }
+        else
+        {
+            for (const auto& e : node->getOutEdges())
+            {
+                if (!e->isIntraCFGEdge() ||
+                        node->getFun() != e->getDstNode()->getFun())
+                    continue;
+                func(e->getDstNode());
+            }
+        }
+    }
+};
+
+// Added for IWTO
+class ICFGIWTO : public ICFGWTO
+{
+public:
+    typedef ICFGWTO Base;
+    typedef WTOComponentVisitor<ICFG>::WTONodeT ICFGWTONode;
+    NodeBS &funcPar;
+    CallGraph *cg;
+
+    explicit ICFGIWTO(ICFG* graph, const ICFGNode* node, NodeBS & funcPar, CallGraph* cg) :
+        Base(graph, node), funcPar(funcPar), cg(cg) {}
+
+    virtual ~ICFGIWTO()
+    {
+    }
+
+    inline void forEachSuccessor(
+        const ICFGNode* node,
+        std::function<void(const ICFGNode*)> func) const override
+    {
+        if (const auto* callNode = SVFUtil::dyn_cast<CallICFGNode>(node))
+        {
+
+            for (const auto &e : callNode->getOutEdges())
+            {
+                ICFGNode *calleeEntryICFGNode = e->getDstNode();
+                CallGraphNode * calleeCGNode = cg->getCallGraphNode(calleeEntryICFGNode->getFun());
+
+                const ICFGNode* succ = nullptr;
+                if (funcPar.test(calleeCGNode->getId()))
+                    succ = calleeEntryICFGNode;
+                else
+                    succ = callNode->getRetICFGNode();
+
+                func(succ);
+            }
+        }
+        else
+        {
+            for (const auto& e : node->getOutEdges())
+            {
+                ICFGNode *succ = e->getDstNode();
+                CallGraphNode *succCGNode = cg->getCallGraphNode(succ->getFun());
+                if (!funcPar.test(succCGNode->getId()))
+                    continue;
+                func(succ);
+            }
+        }
+    }
+};
+
+} // namespace SVF
+
+#endif // SVF_ICFGWTO_H