svf-lib 1.0.1373 → 1.0.1375

package/SVF-linux/{include → svf/include/include}/SVFIR/SVFType.h

@@ -412,27 +412,25 @@ template <> struct Hash<NodePair>
     }
 };
 
-#ifndef DEBUG_WITH_TYPE
-#    ifndef NDBUG
+#if !defined NDBUG && defined USE_SVF_DBOUT
 // TODO: This comes from the following link
 // https://github.com/llvm/llvm-project/blob/75e33f71c2dae584b13a7d1186ae0a038ba98838/llvm/include/llvm/Support/Debug.h#L64
 // The original LLVM implementation makes use of type. But we can get that info,
 // so we can't simulate the full behaviour for now.
-#        define DEBUG_WITH_TYPE(TYPE, X)                                       \
-            do                                                                 \
-            {                                                                  \
-                X;                                                             \
-            } while (false)
-#    else
-#        define DEBUG_WITH_TYPE(TYPE, X)                                       \
-            do                                                                 \
-            {                                                                  \
-            } while (false)
-#    endif
+#    define SVF_DEBUG_WITH_TYPE(TYPE, X)                                       \
+        do                                                                     \
+        {                                                                      \
+            X;                                                                 \
+        } while (false)
+#else
+#    define SVF_DEBUG_WITH_TYPE(TYPE, X)                                       \
+        do                                                                     \
+        {                                                                      \
+        } while (false)
 #endif
 
 /// LLVM debug macros, define type of your DEBUG model of each pass
-#define DBOUT(TYPE, X) DEBUG_WITH_TYPE(TYPE, X)
+#define DBOUT(TYPE, X) SVF_DEBUG_WITH_TYPE(TYPE, X)
 #define DOSTAT(X) X
 #define DOTIMESTAT(X) X
 

package/SVF-osx/svf/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/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