svf-lib 1.0.1925 → 1.0.1927

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

@@ -1,477 +0,0 @@
-//
-// Created by Xiao and Jiawei on 2023/5/29.
-//
-
-#ifndef SVF_SINGLEABSVALUE_H
-#define SVF_SINGLEABSVALUE_H
-
-#include "AE/Core/BoundedZ3Expr.h"
-
-namespace SVF
-{
-
-/*!
- * Atom Z3 expr for constant execution state
- */
-class SingleAbsValue : public BoundedZ3Expr
-{
-public:
-
-    SingleAbsValue() = default;
-
-    SingleAbsValue(const Z3Expr &z3Expr) : BoundedZ3Expr(z3Expr.getExpr()) {}
-
-    SingleAbsValue(const BoundedZ3Expr &z3Bound) : BoundedZ3Expr(z3Bound) {}
-
-    SingleAbsValue(const z3::expr &e) : BoundedZ3Expr(e) {}
-
-    SingleAbsValue(s32_t i) : BoundedZ3Expr(i) {}
-
-    SingleAbsValue(const SingleAbsValue &_z3Expr) : BoundedZ3Expr(_z3Expr) {}
-
-    inline SingleAbsValue &operator=(const SingleAbsValue &rhs)
-    {
-        BoundedZ3Expr::operator=(rhs);
-        return *this;
-    }
-
-    SingleAbsValue(SingleAbsValue &&_z3Expr) : BoundedZ3Expr(_z3Expr)
-    {
-    }
-
-    inline SingleAbsValue &operator=(SingleAbsValue &&rhs)
-    {
-        BoundedZ3Expr::operator=(rhs);
-        return *this;
-    }
-
-    static z3::context &getContext()
-    {
-        return BoundedZ3Expr::getContext();
-    }
-
-    static SingleAbsValue topConstant()
-    {
-        return getContext().int_const("⊤");
-    }
-
-    static SingleAbsValue bottomConstant()
-    {
-        return getContext().int_const("⊥");
-    }
-
-    void join_with(const SingleAbsValue& other)
-    {
-        if (this->isBottom())
-        {
-            if (other.isBottom())
-            {
-                return;
-            }
-            else
-            {
-                *this = other;
-            }
-        }
-        else if (other.isBottom())
-        {
-            return;
-        }
-        else
-        {
-            if (!eq(*this, other))
-            {
-                set_to_top();
-            }
-        }
-    }
-
-    void set_to_top()
-    {
-        *this = topConstant();
-    }
-
-    static bool isTopAbsValue(const SingleAbsValue &expr)
-    {
-        return eq(expr, topConstant());
-    }
-
-    static bool isBottomAbsValue(const SingleAbsValue &expr)
-    {
-        return eq(expr, bottomConstant());
-    }
-
-    inline bool isBottom() const
-    {
-        return isBottomAbsValue(*this);
-    }
-
-    inline bool isTop() const
-    {
-        return isTopAbsValue(*this);
-    }
-
-    inline bool isSym() const
-    {
-        return isSymbolAbsValue(*this);
-    }
-
-    static bool isSymbolAbsValue(const SingleAbsValue &expr)
-    {
-        return !eq(expr, topConstant()) && !eq(expr, bottomConstant()) && !expr.is_numeral();
-    }
-
-    /// Less then or equal
-    bool leq(const SingleAbsValue &rhs) const
-    {
-        assert(is_numeral() && rhs.is_numeral());
-        return (getExpr() <= rhs.getExpr()).simplify().is_true();
-    }
-
-    // Greater than or equal
-    bool geq(const SingleAbsValue &rhs) const
-    {
-        assert(is_numeral() && rhs.is_numeral());
-        return (getExpr() >= rhs.getExpr()).simplify().is_true();
-    }
-
-
-    /// Reload operator
-    //{%
-    friend SingleAbsValue operator==(const SingleAbsValue &lhs, const SingleAbsValue &rhs)
-    {
-        if (isBottomAbsValue(lhs) || isBottomAbsValue(rhs))
-        {
-            return bottomConstant();
-        }
-        else if (isTopAbsValue(lhs) || isTopAbsValue(rhs))
-        {
-            return topConstant();
-        }
-        else
-        {
-            return static_cast<BoundedZ3Expr>(lhs) == static_cast<BoundedZ3Expr>(rhs);
-        }
-    }
-
-    friend SingleAbsValue operator!=(const SingleAbsValue &lhs, const SingleAbsValue &rhs)
-    {
-        if (isBottomAbsValue(lhs) || isBottomAbsValue(rhs))
-        {
-            return bottomConstant();
-        }
-        else if (isTopAbsValue(lhs) || isTopAbsValue(rhs))
-            return topConstant();
-        else
-            return static_cast<BoundedZ3Expr>(lhs) != static_cast<BoundedZ3Expr>(rhs);
-    }
-
-    friend SingleAbsValue operator>(const SingleAbsValue &lhs, const SingleAbsValue &rhs)
-    {
-        if (isBottomAbsValue(lhs) || isBottomAbsValue(rhs))
-        {
-            return bottomConstant();
-        }
-        else if (isTopAbsValue(lhs) || isTopAbsValue(rhs))
-            return topConstant();
-        else
-            return static_cast<BoundedZ3Expr>(lhs) > static_cast<BoundedZ3Expr>(rhs);
-    }
-
-    friend SingleAbsValue operator<(const SingleAbsValue &lhs, const SingleAbsValue &rhs)
-    {
-        if (isBottomAbsValue(lhs) || isBottomAbsValue(rhs))
-        {
-            return bottomConstant();
-        }
-        else if (isTopAbsValue(lhs) || isTopAbsValue(rhs))
-            return topConstant();
-        else
-            return static_cast<BoundedZ3Expr>(lhs) < static_cast<BoundedZ3Expr>(rhs);
-    }
-
-    friend SingleAbsValue operator<=(const SingleAbsValue &lhs, const SingleAbsValue &rhs)
-    {
-        if (isBottomAbsValue(lhs) || isBottomAbsValue(rhs))
-        {
-            return bottomConstant();
-        }
-        else if (isTopAbsValue(lhs) || isTopAbsValue(rhs))
-            return topConstant();
-        else
-            return static_cast<BoundedZ3Expr>(lhs) <= static_cast<BoundedZ3Expr>(rhs);
-    }
-
-    friend SingleAbsValue operator>=(const SingleAbsValue &lhs, const SingleAbsValue &rhs)
-    {
-        if (isBottomAbsValue(lhs) || isBottomAbsValue(rhs))
-        {
-            return bottomConstant();
-        }
-        else if (isTopAbsValue(lhs) || isTopAbsValue(rhs))
-            return topConstant();
-        else
-            return static_cast<BoundedZ3Expr>(lhs) >= static_cast<BoundedZ3Expr>(rhs);
-    }
-
-    friend SingleAbsValue operator+(const SingleAbsValue &lhs, const SingleAbsValue &rhs)
-    {
-        if (isBottomAbsValue(lhs) || isBottomAbsValue(rhs))
-        {
-            return bottomConstant();
-        }
-        else if (isTopAbsValue(lhs) || isTopAbsValue(rhs))
-            return topConstant();
-        else
-            return static_cast<BoundedZ3Expr>(lhs) + static_cast<BoundedZ3Expr>(rhs);
-    }
-
-    friend SingleAbsValue operator-(const SingleAbsValue &lhs, const SingleAbsValue &rhs)
-    {
-        if (isBottomAbsValue(lhs) || isBottomAbsValue(rhs))
-        {
-            return bottomConstant();
-        }
-        else if (isTopAbsValue(lhs) || isTopAbsValue(rhs))
-            return topConstant();
-        else
-            return static_cast<BoundedZ3Expr>(lhs) - static_cast<BoundedZ3Expr>(rhs);
-    }
-
-    friend SingleAbsValue operator*(const SingleAbsValue &lhs, const SingleAbsValue &rhs)
-    {
-        if (isBottomAbsValue(lhs) || isBottomAbsValue(rhs))
-        {
-            return bottomConstant();
-        }
-        else if (isZero(lhs) || isZero(rhs))
-            return 0;
-        else if (isTopAbsValue(lhs) || isTopAbsValue(rhs))
-            return topConstant();
-        else
-            return static_cast<BoundedZ3Expr>(lhs) * static_cast<BoundedZ3Expr>(rhs);
-    }
-
-    friend SingleAbsValue operator/(const SingleAbsValue &lhs, const SingleAbsValue &rhs)
-    {
-        if (isBottomAbsValue(lhs) || isBottomAbsValue(rhs) || isZero(rhs))
-        {
-            return bottomConstant();
-        }
-        else if (isZero(lhs))
-            return 0;
-        else if (isTopAbsValue(lhs) || isTopAbsValue(rhs))
-            return topConstant();
-        else
-            return static_cast<BoundedZ3Expr>(lhs) / static_cast<BoundedZ3Expr>(rhs);
-    }
-
-    friend SingleAbsValue operator%(const SingleAbsValue &lhs, const SingleAbsValue &rhs)
-    {
-        if (isBottomAbsValue(lhs) || isBottomAbsValue(rhs) || isZero(rhs))
-        {
-            return bottomConstant();
-        }
-        else if (isZero(lhs))
-            return 0;
-        else if (isTopAbsValue(lhs) || isTopAbsValue(rhs))
-            return topConstant();
-        else
-            return static_cast<BoundedZ3Expr>(lhs) % static_cast<BoundedZ3Expr>(rhs);
-    }
-
-    friend SingleAbsValue operator^(const SingleAbsValue &lhs, const SingleAbsValue &rhs)
-    {
-        if (isBottomAbsValue(lhs) || isBottomAbsValue(rhs))
-            return bottomConstant();
-        else if (isTopAbsValue(lhs) || isTopAbsValue(rhs))
-            return topConstant();
-        else
-            return static_cast<BoundedZ3Expr>(lhs) ^ static_cast<BoundedZ3Expr>(rhs);
-    }
-
-    friend SingleAbsValue operator&(const SingleAbsValue &lhs, const SingleAbsValue &rhs)
-    {
-        if (isBottomAbsValue(lhs) || isBottomAbsValue(rhs))
-        {
-            return bottomConstant();
-        }
-        else if (isZero(lhs) || isZero(rhs))
-            return 0;
-        else if (isTopAbsValue(lhs) || isTopAbsValue(rhs))
-            return topConstant();
-        else
-            return static_cast<BoundedZ3Expr>(lhs) & static_cast<BoundedZ3Expr>(rhs);
-    }
-
-    friend SingleAbsValue operator|(const SingleAbsValue &lhs, const SingleAbsValue &rhs)
-    {
-        if (isBottomAbsValue(lhs) || isBottomAbsValue(rhs))
-        {
-            return bottomConstant();
-        }
-        else if ((lhs.is_numeral() && eq(lhs, -1)) ||
-                 (rhs.is_numeral() && eq(rhs, -1)))
-            return -1;
-        else if (isTopAbsValue(lhs) || isTopAbsValue(rhs))
-            return topConstant();
-        else
-            return static_cast<BoundedZ3Expr>(lhs) | static_cast<BoundedZ3Expr>(rhs);
-    }
-
-    friend SingleAbsValue ashr(const SingleAbsValue &lhs, const SingleAbsValue &rhs)
-    {
-        if (isBottomAbsValue(lhs) || isBottomAbsValue(rhs) || (rhs.is_numeral() && !rhs.geq(0)))
-            return bottomConstant();
-        else if (isZero(lhs))
-            return 0;
-        else if (isTopAbsValue(lhs) || isTopAbsValue(rhs))
-            return topConstant();
-        else
-            return ashr(static_cast<BoundedZ3Expr>(lhs), static_cast<BoundedZ3Expr>(rhs));
-    }
-
-    friend SingleAbsValue shl(const SingleAbsValue &lhs, const SingleAbsValue &rhs)
-    {
-        if (isBottomAbsValue(lhs) || isBottomAbsValue(rhs) || (rhs.is_numeral() && !rhs.geq(0)))
-            return bottomConstant();
-        else if (isZero(lhs))
-            return 0;
-        else if (isTopAbsValue(lhs) || isTopAbsValue(rhs))
-            return topConstant();
-        else
-            return shl(static_cast<BoundedZ3Expr>(lhs), static_cast<BoundedZ3Expr>(rhs));
-    }
-
-    friend SingleAbsValue lshr(const SingleAbsValue &lhs, const SingleAbsValue &rhs)
-    {
-        if (isBottomAbsValue(lhs) || isBottomAbsValue(rhs) || (rhs.is_numeral() && !rhs.geq(0)))
-            return bottomConstant();
-        else if (isZero(lhs))
-            return 0;
-        else if (isTopAbsValue(lhs) || isTopAbsValue(rhs))
-            return topConstant();
-        else
-            return lshr(static_cast<BoundedZ3Expr>(lhs), static_cast<BoundedZ3Expr>(rhs));
-    }
-
-    friend SingleAbsValue int2bv(u32_t n, const SingleAbsValue &e)
-    {
-        if (isBottomAbsValue(e))
-        {
-            return bottomConstant();
-        }
-        else if (isTopAbsValue(e))
-            return topConstant();
-        else
-            return int2bv(n, static_cast<BoundedZ3Expr>(e));
-    }
-
-    friend SingleAbsValue bv2int(const SingleAbsValue &e, bool isSigned)
-    {
-        if (isBottomAbsValue(e))
-        {
-            return bottomConstant();
-        }
-        else if (isTopAbsValue(e))
-            return topConstant();
-        else
-            return bv2int(static_cast<BoundedZ3Expr>(e), isSigned);
-    }
-
-    friend SingleAbsValue operator&&(const SingleAbsValue &lhs, const SingleAbsValue &rhs)
-    {
-        if (isBottomAbsValue(lhs) || isBottomAbsValue(rhs))
-        {
-            return bottomConstant();
-        }
-        else if (eq(lhs, getContext().bool_val(false)) || eq(rhs, getContext().bool_val(false)))
-            return getContext().bool_val(false);
-        else if (eq(lhs, getContext().bool_val(true)))
-            return rhs;
-        else if (eq(rhs, getContext().bool_val(true)))
-            return lhs;
-        else if (isTopAbsValue(lhs) || isTopAbsValue(rhs))
-            return topConstant();
-        else
-            return static_cast<BoundedZ3Expr>(lhs) && static_cast<BoundedZ3Expr>(rhs);
-    }
-
-    friend SingleAbsValue operator||(const SingleAbsValue &lhs, const SingleAbsValue &rhs)
-    {
-        if (isBottomAbsValue(lhs) || isBottomAbsValue(rhs))
-        {
-            return bottomConstant();
-        }
-        else if (eq(lhs, getContext().bool_val(true)) || eq(rhs, getContext().bool_val(true)))
-            return getContext().bool_val(true);
-        else if (eq(lhs, getContext().bool_val(false)))
-            return rhs;
-        else if (eq(rhs, getContext().bool_val(false)))
-            return lhs;
-        else if (isTopAbsValue(lhs) || isTopAbsValue(rhs))
-            return topConstant();
-        else
-            return static_cast<BoundedZ3Expr>(lhs) || static_cast<BoundedZ3Expr>(rhs);
-    }
-
-    friend SingleAbsValue operator!(const SingleAbsValue &lhs)
-    {
-        if (isBottomAbsValue(lhs))
-        {
-            return bottomConstant();
-        }
-        else if (isTopAbsValue(lhs))
-            return topConstant();
-        else
-            return !static_cast<BoundedZ3Expr>(lhs);
-    }
-
-    friend SingleAbsValue ite(const SingleAbsValue &cond, const SingleAbsValue &lhs, const SingleAbsValue &rhs)
-    {
-        if (isBottomAbsValue(lhs) || isBottomAbsValue(rhs) || isBottomAbsValue(cond))
-        {
-            return bottomConstant();
-        }
-        else if (eq(cond, getContext().bool_val(true)))
-            return lhs;
-        else if (eq(cond, getContext().bool_val(false)))
-            return rhs;
-        else if (isTopAbsValue(lhs) || isTopAbsValue(rhs) || isTopAbsValue(cond))
-            return topConstant();
-        else
-            return ite(static_cast<BoundedZ3Expr>(cond), static_cast<BoundedZ3Expr>(lhs),
-                       static_cast<BoundedZ3Expr>(rhs));
-    }
-
-    friend std::ostream &operator<<(std::ostream &out, const SingleAbsValue &expr)
-    {
-        out << static_cast<BoundedZ3Expr>(expr);
-        return out;
-    }
-
-    friend bool eq(const SingleAbsValue &lhs, const SingleAbsValue &rhs)
-    {
-        return eq(static_cast<BoundedZ3Expr>(lhs), static_cast<BoundedZ3Expr>(rhs));
-    }
-
-    inline SingleAbsValue simplify() const
-    {
-        return getExpr().simplify();
-    }
-    //%}
-}; // end class ConZ3Expr
-} // end namespace SVF
-
-/// Specialise hash for ConZ3Expr
-template<>
-struct std::hash<SVF::SingleAbsValue>
-{
-    size_t operator()(const SVF::SingleAbsValue &z3Expr) const
-    {
-        return z3Expr.hash();
-    }
-};
-
-
-#endif //SVF_SINGLEABSVALUE_H

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

@@ -1,221 +0,0 @@
-//===- SymState.h ----Symbolic State-------------------------//
-//
-//                     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/>.
-//
-//===----------------------------------------------------------------------===//
-
-//
-// Created by jiawei and xiao on 6/1/23.
-//
-
-#ifndef SVF_SYMSTATE_H
-#define SVF_SYMSTATE_H
-
-#include "AE/Core/ConsExeState.h"
-
-namespace SVF
-{
-/*!
- * Symbolic state
- *
- * Execution State + Type State
- */
-class SymState
-{
-
-public:
-    typedef std::string TypeState;
-    typedef std::vector<u32_t> KeyNodes;
-    typedef Set<KeyNodes> KeyNodesSet;
-
-private:
-    ConsExeState _exeState; ///< Execution state: values of variables
-    TypeState _typeState; ///< Type state: FSM node
-
-private:
-    /// Only for bug report
-    KeyNodesSet _keyNodesSet; ///< The nodes where abstract state changes
-    Z3Expr _branchCondition; ///< The branches current state passes
-
-public:
-    /// Constructor
-    SymState() : _exeState(ConsExeState::nullExeState()), _typeState("") {}
-
-    /// Constructor
-    SymState(ConsExeState _es, TypeState _as);
-
-    /// Destructor
-    virtual ~SymState() = default;
-
-    /// Copy Constructor
-    SymState(const SymState &rhs) : _exeState(rhs._exeState), _typeState(rhs._typeState), _keyNodesSet(rhs._keyNodesSet),
-        _branchCondition(rhs._branchCondition)
-    {
-
-    }
-
-    /// Operator=
-    SymState &operator=(const SymState &rhs)
-    {
-        if (*this != rhs)
-        {
-            _typeState = rhs._typeState;
-            _exeState = rhs._exeState;
-            _keyNodesSet = rhs._keyNodesSet;
-            _branchCondition = rhs._branchCondition;
-        }
-        return *this;
-    }
-
-
-    /// Move Constructor
-    SymState(SymState &&rhs) noexcept: _exeState(SVFUtil::move(rhs._exeState)),
-        _typeState(SVFUtil::move(rhs._typeState)),
-        _keyNodesSet(SVFUtil::move(rhs._keyNodesSet)),
-        _branchCondition(rhs._branchCondition)
-    {
-
-    }
-
-    /// Move operator=
-    SymState &operator=(SymState &&rhs) noexcept
-    {
-        if (this != &rhs)
-        {
-            _typeState = SVFUtil::move(rhs._typeState);
-            _exeState = SVFUtil::move(rhs._exeState);
-            _keyNodesSet = SVFUtil::move(rhs._keyNodesSet);
-            _branchCondition = rhs._branchCondition;
-        }
-        return *this;
-    }
-
-    const KeyNodesSet &getKeyNodesSet() const
-    {
-        return _keyNodesSet;
-    }
-
-
-    void insertKeyNode(NodeID id)
-    {
-        if (_keyNodesSet.empty())
-        {
-            _keyNodesSet.insert(KeyNodes{id});
-        }
-        else
-        {
-            for (const auto &df: _keyNodesSet)
-            {
-                const_cast<KeyNodes &>(df).push_back(id);
-            }
-        }
-    }
-
-    void setKeyNodesSet(KeyNodesSet ns)
-    {
-        _keyNodesSet = SVFUtil::move(ns);
-    }
-
-    void clearKeyNodesSet()
-    {
-        _keyNodesSet.clear();
-    }
-
-    inline const Z3Expr &getBranchCondition() const
-    {
-        return _branchCondition;
-    }
-
-    inline void setBranchCondition(const Z3Expr &br)
-    {
-        _branchCondition = br;
-    }
-
-    const TypeState &getAbstractState() const
-    {
-        return _typeState;
-    }
-
-    TypeState &getAbstractState()
-    {
-        return _typeState;
-    }
-
-    void setAbsState(const TypeState &absState)
-    {
-        _typeState = absState;
-    }
-
-    const ConsExeState &getExecutionState() const
-    {
-        return _exeState;
-    }
-
-    ConsExeState &getExecutionState()
-    {
-        return _exeState;
-    }
-
-    /// Overloading Operator==
-    inline bool operator==(const SymState &rhs) const
-    {
-        return _typeState == rhs.getAbstractState() && _exeState == rhs.getExecutionState();
-    }
-
-    /// Overloading Operator!=
-    inline bool operator!=(const SymState &rhs) const
-    {
-        return !(*this == rhs);
-    }
-
-    /// Overloading Operator==
-    inline bool operator<(const SymState &rhs) const
-    {
-        if (_typeState != rhs.getAbstractState())
-            return _typeState < rhs.getAbstractState();
-        if (_exeState != rhs.getExecutionState())
-            return _exeState < rhs.getExecutionState();
-        return false;
-    }
-
-    inline bool isNullSymState() const
-    {
-        return getExecutionState().isNullState() && getAbstractState().empty();
-    }
-
-};
-
-} // end namespace SVF
-
-
-
-/// Specialise hash for SymState
-template<>
-struct std::hash<SVF::SymState>
-{
-    size_t operator()(const SVF::SymState &symState) const
-    {
-
-        SVF::Hash<std::pair<SVF::SymState::TypeState, SVF::ConsExeState>> pairH;
-
-        return pairH(make_pair(symState.getAbstractState(), symState.getExecutionState()));
-    }
-};
-
-#endif // SVF_SYMSTATE_H