svf-lib 1.0.1925 → 1.0.1926

package/SVF-linux/Release-build/include/AE/Core/AbstractValue.h

@@ -1,4 +1,4 @@
-//===- AbstractValue.h --Abstract Value for domains---------------------------//
+//===- AbstractValue.h ----AbstractValue-------------------------//
 //
 //                     SVF: Static Value-Flow Analysis
 //
@@ -19,60 +19,535 @@
 // 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 "AE/Core/IntervalValue.h"
+#include "AE/Core/AddressValue.h"
 
 namespace SVF
 {
 
-class IntervalValue;
-
-/*!
- * Base class of abstract value
- */
-class AbstractValue
+struct AbstractValue
 {
-public:
-    /// Abstract value kind
-    enum AbstractValueK
+    enum DataType
     {
-        IntervalK, ConcreteK, AddressK
+        IntervalType,
+        AddressType,
+        UnknownType,
     };
-private:
-    AbstractValueK _kind;
+    DataType type;
+    IntervalValue interval;
+    AddressValue addr;
+
+    AbstractValue() : type(IntervalType)
+    {
+        interval = IntervalValue::top();
+    }
+    AbstractValue(DataType type) : type(type)
+    {
+        switch (type)
+        {
+        case IntervalType:
+            interval = IntervalValue::top();
+            break;
+        case AddressType:
+            addr = AddressValue();
+            break;
+        case UnknownType:
+            break;
+        }
+    }
+
+    AbstractValue(const AbstractValue& other): type(other.type)
+    {
+        switch (type)
+        {
+        case IntervalType:
+            interval = other.interval;
+            break;
+        case AddressType:
+            addr = other.addr;
+            break;
+        case UnknownType:
+            break;
+        }
+    }
+
+    inline bool isInterval() const
+    {
+        return type == IntervalType;
+    }
+    inline bool isAddr() const
+    {
+        return type == AddressType;
+    }
+    inline bool isUnknown() const
+    {
+        return type == UnknownType;
+    }
+
+    inline DataType getType() const
+    {
+        return type;
+    }
+
+    AbstractValue(AbstractValue &&other) : type(other.type)
+    {
+        switch (type)
+        {
+        case IntervalType:
+            interval = other.interval;
+            break;
+        case AddressType:
+            addr = other.addr;
+            break;
+        case UnknownType:
+            break;
+        }
+    }
+
+    // operator overload, supporting both interval and address
+    AbstractValue& operator=(const AbstractValue& other)
+    {
+        type = other.type;
+        switch (type)
+        {
+        case IntervalType:
+            interval = other.interval;
+            break;
+        case AddressType:
+            addr = other.addr;
+            break;
+        case UnknownType:
+            break;
+        }
+        return *this;
+    }
+    AbstractValue operator==(const AbstractValue& other) const
+    {
+        assert(isInterval() && other.isInterval());
+        return interval == other.interval;
+    }
+
+    AbstractValue operator==(const IntervalValue& other) const
+    {
+        assert(isInterval());
+        return interval == other;
+    }
+
+    AbstractValue operator!=(const AbstractValue& other) const
+    {
+        assert(isInterval());
+        return interval != other.interval;
+    }
+
+    AbstractValue operator!=(const IntervalValue& other) const
+    {
+        assert(isInterval());
+        return interval != other;
+    }
+
+
+    AbstractValue(const IntervalValue& ival) : type(IntervalType), interval(ival) {}
+
+    AbstractValue(const AddressValue& addr) : type(AddressType), addr(addr) {}
+    // TODO: move constructor
+    IntervalValue& getInterval()
+    {
+        if (isUnknown())
+        {
+            interval = IntervalValue::top();
+        }
+        assert(isInterval());
+        return interval;
+    }
+
+    //
+    const IntervalValue getInterval() const
+    {
+        assert(isInterval());
+        return interval;
+    }
+
+    AddressValue& getAddrs()
+    {
+        assert(isAddr());
+        return addr;
+    }
 
-public:
-    AbstractValue(AbstractValueK kind) : _kind(kind) {}
+    const AddressValue getAddrs() const
+    {
+        assert(isAddr());
+        return addr;
+    }
+    ~AbstractValue() {};
+
+
+    // interval visit funcs
+    bool isTop() const
+    {
+        assert(isInterval());
+        return interval.isTop();
+    }
+
+    bool isBottom() const
+    {
+        assert(isInterval());
+        return interval.isBottom();
+    }
+
+    const NumericLiteral& lb() const
+    {
+        assert(isInterval());
+        return interval.lb();
+    }
+
+    const NumericLiteral& ub() const
+    {
+        assert(isInterval());
+        return interval.ub();
+    }
+
+    void setLb(const NumericLiteral& lb)
+    {
+        assert(isInterval());
+        interval.setLb(lb);
+    }
+
+    void setUb(const NumericLiteral& ub)
+    {
+        assert(isInterval());
+        interval.setUb(ub);
+    }
+
+    void setValue(const NumericLiteral &lb, const NumericLiteral &ub)
+    {
+        assert(isInterval());
+        interval.setValue(lb, ub);
+    }
 
-    virtual ~AbstractValue() = default;
+    bool is_zero() const
+    {
+        assert(isInterval());
+        return interval.is_zero();
+    }
+
+    bool is_infinite() const
+    {
+        assert(isInterval());
+        return interval.is_infinite();
+    }
+
+    bool is_int() const
+    {
+        assert(isInterval());
+        return interval.is_int();
+    }
+
+    bool is_real() const
+    {
+        assert(isInterval());
+        return interval.is_real();
+    }
+
+    s64_t getIntNumeral() const
+    {
+        assert(isInterval());
+        return interval.getIntNumeral();
+    }
 
-    AbstractValue(const AbstractValue &) noexcept = default;
+    double getRealNumeral() const
+    {
+        assert(isInterval());
+        return interval.getRealNumeral();
+    }
 
-    AbstractValue(AbstractValue &&) noexcept = default;
+    bool is_numeral() const
+    {
+        assert(isInterval());
+        return interval.is_numeral();
+    }
 
-    AbstractValue &operator=(const AbstractValue &) noexcept = default;
+    void set_to_bottom()
+    {
+        assert(isInterval());
+        interval.set_to_bottom();
+    }
 
-    AbstractValue &operator=(AbstractValue &&) noexcept = default;
+    void set_to_top()
+    {
+        assert(isInterval());
+        interval.set_to_top();
+    }
 
-    inline AbstractValueK getAbstractValueKind() const
+    bool leq(const AbstractValue &other) const
     {
-        return _kind;
+        assert(isInterval() && other.isInterval());
+        return interval.leq(other.interval);
     }
 
-    virtual bool isTop() const = 0;
+    bool geq(const AbstractValue &other) const
+    {
+        assert(isInterval() && other.isInterval());
+        return interval.geq(other.interval);
+    }
+
+    bool contains(s64_t n) const
+    {
+        assert(isInterval());
+        return interval.contains(n);
+    }
+    // operator +-*/%>< >= <= << >> & | ^
+    AbstractValue operator+(const AbstractValue &other) const
+    {
+        assert(isInterval() && other.isInterval());
+        return interval + other.interval;
+    }
+    AbstractValue operator+(const IntervalValue &other) const
+    {
+        assert(isInterval());
+        return interval + other;
+    }
+
+    AbstractValue operator-(const AbstractValue &other) const
+    {
+        assert(isInterval() && other.isInterval());
+        return interval - other.interval;
+    }
+    AbstractValue operator-(const IntervalValue &other) const
+    {
+        assert(isInterval());
+        return interval - other;
+    }
+
+    AbstractValue operator*(const AbstractValue &other) const
+    {
+        assert(isInterval() && other.isInterval());
+        return interval * other.interval;
+    }
+    AbstractValue operator*(const IntervalValue &other) const
+    {
+        assert(isInterval());
+        return interval * other;
+    }
+
+    AbstractValue operator/(const AbstractValue &other) const
+    {
+        assert(isInterval() && other.isInterval());
+        return interval / other.interval;
+    }
+    AbstractValue operator/(const IntervalValue &other) const
+    {
+        assert(isInterval());
+        return interval / other;
+    }
+
+    AbstractValue operator%(const AbstractValue &other) const
+    {
+        assert(isInterval() && other.isInterval());
+        return interval % other.interval;
+    }
+    AbstractValue operator%(const IntervalValue &other) const
+    {
+        assert(isInterval());
+        return interval % other;
+    }
+
+    AbstractValue operator>>(const AbstractValue &other) const
+    {
+        assert(isInterval() && other.isInterval());
+        return interval >> other.interval;
+    }
+    AbstractValue operator>>(const IntervalValue &other) const
+    {
+        assert(isInterval());
+        return interval >> other;
+    }
+
+    AbstractValue operator<<(const AbstractValue &other) const
+    {
+        assert(isInterval() && other.isInterval());
+        return interval << other.interval;
+    }
+    AbstractValue operator<<(const IntervalValue &other) const
+    {
+        assert(isInterval());
+        return interval << other;
+    }
+
+    AbstractValue operator&(const AbstractValue &other) const
+    {
+        assert(isInterval() && other.isInterval());
+        return interval & other.interval;
+    }
+    AbstractValue operator&(const IntervalValue &other) const
+    {
+        assert(isInterval());
+        return interval & other;
+    }
+
+    AbstractValue operator|(const AbstractValue &other) const
+    {
+        assert(isInterval() && other.isInterval());
+        return interval | other.interval;
+    }
+    AbstractValue operator|(const IntervalValue &other) const
+    {
+        assert(isInterval());
+        return interval | other;
+    }
+
+    AbstractValue operator^(const AbstractValue &other) const
+    {
+        assert(isInterval() && other.isInterval());
+        return interval ^ other.interval;
+    }
+    AbstractValue operator^(const IntervalValue &other) const
+    {
+        assert(isInterval());
+        return interval ^ other;
+    }
+
+    AbstractValue operator>(const AbstractValue &other) const
+    {
+        assert(isInterval() && other.isInterval());
+        return interval > other.interval;
+    }
+    AbstractValue operator>(const IntervalValue &other) const
+    {
+        assert(isInterval());
+        return interval > other;
+    }
+
+    AbstractValue operator<(const AbstractValue &other) const
+    {
+        assert(isInterval() && other.isInterval());
+        return interval < other.interval;
+    }
+    AbstractValue operator<(const IntervalValue &other) const
+    {
+        assert(isInterval());
+        return interval < other;
+    }
+
+    AbstractValue operator>=(const AbstractValue &other) const
+    {
+        assert(isInterval() && other.isInterval());
+        return interval >= other.interval;
+    }
+    AbstractValue operator>=(const IntervalValue &other) const
+    {
+        assert(isInterval());
+        return interval >= other;
+    }
+
+    AbstractValue operator<=(const AbstractValue &other) const
+    {
+        assert(isInterval() && other.isInterval());
+        return interval <= other.interval;
+    }
+    AbstractValue operator<=(const IntervalValue &other) const
+    {
+        assert(isInterval());
+        return interval <= other;
+    }
+
+
+    // address visit funcs
+    std::pair<AddressValue::AddrSet::iterator, bool> insertAddr(u32_t id)   // insertAddr
+    {
+        assert(isAddr());
+        return addr.insert(id);
+    }
+
+    // TODO: equals, join_with, meet_with, widen_with, narrow_with, toString,
+    // These should be merged with AddressValue
+
+    bool equals(const AbstractValue &rhs) const
+    {
+        if (type != rhs.type)
+        {
+            return false;
+        }
+        if (isInterval())
+        {
+            return interval.equals(rhs.interval);
+        }
+        if (isAddr())
+        {
+            return addr.equals(rhs.addr);
+        }
+        return false;
+    }
+
+    void join_with(const AbstractValue &other)
+    {
+        if (isUnknown())
+        {
+            *this = other;
+            return;
+        }
+        else if (type != other.type)
+        {
+            return;
+        }
+        if (isInterval() && other.isInterval())
+        {
+            interval.join_with(other.interval);
+        }
+        if (isAddr() && other.isAddr())
+        {
+            addr.join_with(other.addr);
+        }
+        return;
+    }
+
+    void meet_with(const AbstractValue &other)
+    {
+        if (type != other.type)
+        {
+            return;
+        }
+        if (isInterval() && other.isInterval())
+        {
+            interval.meet_with(other.interval);
+        }
+        if (isAddr() && other.isAddr())
+        {
+            addr.meet_with(other.addr);
+        }
+        return;
+    }
+
+    void widen_with(const AbstractValue &other)
+    {
+        // widen_with only in interval
+        if (isInterval() && other.isInterval())
+        {
+            interval.widen_with(other.interval);
+        }
+    }
+
+    void narrow_with(const AbstractValue &other)
+    {
+        // narrow_with only in interval
+        if (isInterval() && other.isInterval())
+        {
+            interval.narrow_with(other.interval);
+        }
+    }
+
+    std::string toString() const
+    {
+        if (isInterval())
+        {
+            return interval.toString();
+        }
+        else if (isAddr())
+        {
+            return addr.toString();
+        }
+        return "";
+    }
 
-    virtual bool isBottom() const = 0;
-}; // end class AbstractValue
-} // end namespace SVF
-#endif //Z3_EXAMPLE_ABSTRACTVALUE_H
+};
+}

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

@@ -33,14 +33,14 @@
 #define AddressMask 0x7f000000
 #define FlippedAddressMask (AddressMask^0xffffffff)
 // the address of the black hole, getVirtualMemAddress(2);
-#define BlackHoleAddr 0x7f000000 + 2;
+#define BlackHoleAddr 0x7f000000 + 2
 
-#include "AE/Core/AbstractValue.h"
 #include "Util/GeneralType.h"
+#include <sstream>
 
 namespace SVF
 {
-class AddressValue : public AbstractValue
+class AddressValue
 {
 public:
     typedef Set<u32_t> AddrSet;
@@ -48,21 +48,21 @@ private:
     AddrSet _addrs;
 public:
     /// Default constructor
-    AddressValue() : AbstractValue(AddressK) {}
+    AddressValue() {}
 
     /// Constructor
-    AddressValue(const Set<u32_t> &addrs) : AbstractValue(AddressK), _addrs(addrs) {}
+    AddressValue(const Set<u32_t> &addrs) :  _addrs(addrs) {}
 
-    AddressValue(u32_t addr) : AbstractValue(AddressK), _addrs({addr}) {}
+    AddressValue(u32_t addr) :  _addrs({addr}) {}
 
     /// Default destructor
     ~AddressValue() = default;
 
     /// Copy constructor
-    AddressValue(const AddressValue &other) : AbstractValue(AddressK), _addrs(other._addrs) {}
+    AddressValue(const AddressValue &other) : _addrs(other._addrs) {}
 
     /// Move constructor
-    AddressValue(AddressValue &&other) noexcept: AbstractValue(AddressK), _addrs(std::move(other._addrs)) {}
+    AddressValue(AddressValue &&other) noexcept: _addrs(std::move(other._addrs)) {}
 
     /// Copy operator=
     AddressValue &operator=(const AddressValue &other)
@@ -70,7 +70,6 @@ public:
         if (!this->equals(other))
         {
             _addrs = other._addrs;
-            AbstractValue::operator=(other);
         }
         return *this;
     }
@@ -81,7 +80,6 @@ public:
         if (this != &other)
         {
             _addrs = std::move(other._addrs);
-            AbstractValue::operator=(std::move(other));
         }
         return *this;
     }
@@ -91,17 +89,6 @@ public:
         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();
@@ -181,19 +168,19 @@ public:
         return !v.empty();
     }
 
-    inline bool isTop() const override
+    inline bool isTop() const
     {
-        return *this == BlackHoleAddr;
+        return *this->begin() == BlackHoleAddr;
     }
 
-    inline bool isBottom() const override
+    inline bool isBottom() const
     {
         return empty();
     }
 
     inline void setTop()
     {
-        *this = BlackHoleAddr;
+        *this = AddressValue(BlackHoleAddr);
     }
 
     inline void setBottom()
@@ -201,6 +188,26 @@ public:
         _addrs.clear();
     }
 
+    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)
     {

package/SVF-linux/Release-build/include/AE/Core/ExeState.h

@@ -39,7 +39,7 @@
 namespace SVF
 {
 
-class IntervalExeState;
+class SparseAbstractState;
 
 /*!
  * Base execution state
@@ -196,7 +196,7 @@ protected:
             auto it = rhs.find(item.first);
             if (it == rhs.end())
                 return false;
-            if (item.second != it->second)
+            if (item.second.equals(it->second))
             {
                 return false;
             }