svf-lib 1.0.1375 → 1.0.1376

package/SVF-osx/svf/include/include/AbstractExecution/AbstractValue.h

@@ -0,0 +1,79 @@
+//===- AbstractValue.h --Abstract Value for domains---------------------------//
+//
+//                     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 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/>.
+//
+//===----------------------------------------------------------------------===//
+/*
+ * AbstractValue.h
+ *
+ *  Created on: Aug 4, 2022
+ *      Author: Xiao Cheng, Jiawei Wang
+ *
+ */
+
+#ifndef Z3_EXAMPLE_ABSTRACTVALUE_H
+#define Z3_EXAMPLE_ABSTRACTVALUE_H
+
+#include <type_traits>
+#include <string>
+#include "SVFIR/SVFValue.h"
+
+namespace SVF
+{
+
+class IntervalValue;
+
+/*!
+ * Base class of abstract value
+ */
+class AbstractValue
+{
+public:
+    /// Abstract value kind
+    enum AbstractValueK
+    {
+        IntervalK, ConcreteK, AddressK
+    };
+private:
+    AbstractValueK _kind;
+
+public:
+    AbstractValue(AbstractValueK kind) : _kind(kind) {}
+
+    virtual ~AbstractValue() = default;
+
+    AbstractValue(const AbstractValue &) noexcept = default;
+
+    AbstractValue(AbstractValue &&) noexcept = default;
+
+    AbstractValue &operator=(const AbstractValue &) noexcept = default;
+
+    AbstractValue &operator=(AbstractValue &&) noexcept = default;
+
+    inline AbstractValueK getAbstractValueKind() const
+    {
+        return _kind;
+    }
+
+    virtual bool isTop() const = 0;
+
+    virtual bool isBottom() const = 0;
+}; // end class AbstractValue
+} // end namespace SVF
+#endif //Z3_EXAMPLE_ABSTRACTVALUE_H

package/SVF-osx/svf/include/include/AbstractExecution/AddressValue.h

@@ -0,0 +1,210 @@
+//===- 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 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/>.
+//
+//===----------------------------------------------------------------------===//
+/*
+ * 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)
+
+#include "AbstractExecution/AbstractValue.h"
+#include "SVFIR/SVFIR.h"
+
+namespace SVF
+{
+class AddressValue : public AbstractValue
+{
+public:
+    typedef Set<u32_t> AddrSet;
+private:
+    AddrSet _addrs;
+public:
+    /// Default constructor
+    AddressValue() : AbstractValue(AddressK) {}
+
+    /// Constructor
+    AddressValue(const Set<u32_t> &addrs) : AbstractValue(AddressK), _addrs(addrs) {}
+
+    AddressValue(u32_t addr) : AbstractValue(AddressK), _addrs({addr}) {}
+
+    /// Default destructor
+    ~AddressValue() = default;
+
+    /// Copy constructor
+    AddressValue(const AddressValue &other) : AbstractValue(AddressK), _addrs(other._addrs) {}
+
+    /// Move constructor
+    AddressValue(AddressValue &&other) noexcept: AbstractValue(AddressK), _addrs(std::move(other._addrs)) {}
+
+    /// Copy operator=
+    AddressValue &operator=(const AddressValue &other)
+    {
+        if (!this->equals(other))
+        {
+            _addrs = other._addrs;
+            AbstractValue::operator=(other);
+        }
+        return *this;
+    }
+
+    /// Move operator=
+    AddressValue &operator=(AddressValue &&other) noexcept
+    {
+        if (this != &other)
+        {
+            _addrs = std::move(other._addrs);
+            AbstractValue::operator=(std::move(other));
+        }
+        return *this;
+    }
+
+    bool equals(const AddressValue &rhs) const
+    {
+        return _addrs == rhs._addrs;
+    }
+
+    bool operator==(const AddressValue &rhs) const
+    {
+        return _addrs == rhs._addrs;
+    }
+
+    /// Operator !=
+    bool operator!=(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
+    void join_with(const AddressValue &other)
+    {
+        _addrs.insert(other.begin(), other.end());
+    }
+
+    /// Return a intersected AddressValue
+    void meet_with(const AddressValue &other)
+    {
+        AddrSet s;
+        for (const auto &id: other._addrs)
+        {
+            if (_addrs.find(id) != _addrs.end())
+            {
+                s.insert(id);
+            }
+        }
+        _addrs = std::move(s);
+    }
+
+    /// 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 isTop() const override
+    {
+        return *this == getVirtualMemAddress(PAG::getPAG()->getBlackHoleObj()->getId());
+    }
+
+    inline bool isBottom() const override
+    {
+        return empty();
+    }
+
+    inline void setTop()
+    {
+        *this = getVirtualMemAddress(PAG::getPAG()->getBlackHoleObj()->getId());
+    }
+
+    inline void setBottom()
+    {
+        _addrs.clear();
+    }
+
+    /// The physical address starts with 0x7f...... + idx
+    static inline u32_t getVirtualMemAddress(u32_t idx)
+    {
+        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;
+    }
+
+    /// 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);
+    }
+};
+} // end namespace SVF
+#endif //Z3_EXAMPLE_ADDRESSVALUE_H

package/SVF-osx/svf/include/include/AbstractExecution/ExeState.h

@@ -0,0 +1,223 @@
+//===- ExeState.h ----General Execution States-------------------------//
+//
+//                     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 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/>.
+//
+//===----------------------------------------------------------------------===//
+/*
+ * ExeState.h
+ *
+ *  Created on: Aug 4, 2022
+ *      Author: Xiao Cheng
+ *
+ */
+
+
+#ifndef Z3_EXAMPLE_EXESTATE_H
+#define Z3_EXAMPLE_EXESTATE_H
+
+#include "AbstractExecution/AddressValue.h"
+#include "AbstractExecution/NumericLiteral.h"
+#include "Util/Z3Expr.h"
+
+namespace SVF
+{
+
+class IntervalExeState;
+
+/*!
+ * Base execution state
+ */
+class ExeState
+{
+    friend class SVFIR2ItvExeState;
+
+public:
+
+    typedef AddressValue VAddrs;
+    typedef Map<u32_t, VAddrs> VarToVAddrs;
+    /// Execution state kind
+    enum ExeState_TYPE
+    {
+        IntervalK, ConcreteK
+    };
+private:
+    ExeState_TYPE _kind;
+
+public:
+    ExeState(ExeState_TYPE kind) : _kind(kind) {}
+
+    virtual ~ExeState() = default;
+
+    ExeState(const ExeState &rhs) : _varToVAddrs(rhs._varToVAddrs),
+        _locToVAddrs(rhs._locToVAddrs) {}
+
+    ExeState(ExeState &&rhs) noexcept: _varToVAddrs(std::move(rhs._varToVAddrs)),
+        _locToVAddrs(std::move(rhs._locToVAddrs)) {}
+
+    ExeState &operator=(const ExeState &rhs)
+    {
+        if(*this != rhs)
+        {
+            _varToVAddrs = rhs._varToVAddrs;
+            _locToVAddrs = rhs._locToVAddrs;
+        }
+        return *this;
+    }
+
+    ExeState &operator=(ExeState &&rhs) noexcept
+    {
+        if (this != &rhs)
+        {
+            _varToVAddrs = std::move(rhs._varToVAddrs);
+            _locToVAddrs = std::move(rhs._locToVAddrs);
+        }
+        return *this;
+    }
+
+    bool operator==(const ExeState &rhs) const;
+
+    inline bool operator!=(const ExeState &rhs) const
+    {
+        return !(*this == rhs);
+    }
+
+    bool equals(const ExeState *other) const
+    {
+        return false;
+    }
+
+    /// Make all value join with the other
+    void joinWith(const ExeState &other);
+
+    /// Make all value meet with the other
+    void meetWith(const ExeState &other);
+
+    virtual u32_t hash() const;
+
+    /// Print values of all expressions
+    virtual void printExprValues(std::ostream &oss) const {}
+
+    virtual std::string toString() const
+    {
+        return "";
+    }
+
+    inline ExeState_TYPE getExeStateKind() const
+    {
+        return _kind;
+    }
+
+    inline virtual const VarToVAddrs &getVarToVAddrs() const
+    {
+        return _varToVAddrs;
+    }
+
+    inline virtual const VarToVAddrs &getLocToVAddrs() const
+    {
+        return _locToVAddrs;
+    }
+
+    inline virtual bool inVarToAddrsTable(u32_t id) const
+    {
+        return _varToVAddrs.find(id) != _varToVAddrs.end();
+    }
+
+    inline virtual bool inLocToAddrsTable(u32_t id) const
+    {
+        return _locToVAddrs.find(id) != _locToVAddrs.end();
+    }
+
+    virtual VAddrs &getVAddrs(u32_t id)
+    {
+        return _varToVAddrs[id];
+    }
+
+    inline virtual void storeVAddrs(u32_t addr, const VAddrs &vaddrs)
+    {
+        assert(isVirtualMemAddress(addr) && "not virtual address?");
+        if(isNullPtr(addr)) return;
+        u32_t objId = getInternalID(addr);
+        _locToVAddrs[objId] = vaddrs;
+    }
+
+    inline virtual VAddrs &loadVAddrs(u32_t addr)
+    {
+        assert(isVirtualMemAddress(addr) && "not virtual address?");
+        u32_t objId = getInternalID(addr);
+        return _locToVAddrs[objId];
+    }
+
+    inline bool isNullPtr(u32_t addr)
+    {
+        return getInternalID(addr) == 0;
+    }
+
+protected:
+    VarToVAddrs _varToVAddrs{{0, getVirtualMemAddress(0)}};
+    VarToVAddrs _locToVAddrs;
+
+protected:
+
+    static bool eqVarToVAddrs(const VarToVAddrs &lhs, const VarToVAddrs &rhs)
+    {
+        if (lhs.size() != rhs.size()) return false;
+        for (const auto &item: lhs)
+        {
+            auto it = rhs.find(item.first);
+            if (it == rhs.end())
+                return false;
+            if (item.second != it->second)
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+
+public:
+    static z3::context &getContext()
+    {
+        return Z3Expr::getContext();
+    }
+
+    /// The physical address starts with 0x7f...... + idx
+    static inline u32_t getVirtualMemAddress(u32_t idx)
+    {
+        return AddressValue::getVirtualMemAddress(idx);
+    }
+
+    /// Check bit value of val start with 0x7F000000, filter by 0xFF000000
+    static inline bool isVirtualMemAddress(u32_t val)
+    {
+        return AddressValue::isVirtualMemAddress(val);
+    }
+
+    /// Return the internal index if idx is an address otherwise return the value of idx
+    static inline u32_t getInternalID(u32_t idx)
+    {
+        return AddressValue::getInternalID(idx);
+    }
+
+
+}; // end class ExeState
+
+
+
+} // end namespace SVF
+#endif //Z3_EXAMPLE_EXESTATE_H