svf-lib 1.0.1376 → 1.0.1377

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-lib",
-  "version": "1.0.1376",
+  "version": "1.0.1377",
   "description": "SVF's npm support",
   "main": "index.js",
   "scripts": {

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

@@ -1,79 +0,0 @@
-//===- 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-linux/svf/include/include/AbstractExecution/AddressValue.h

@@ -1,210 +0,0 @@
-//===- 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-linux/svf/include/include/AbstractExecution/ExeState.h

@@ -1,223 +0,0 @@
-//===- 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