svf-tools 1.0.937 → 1.0.939

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.937",
+  "version": "1.0.939",
   "description": "* <b>[TypeClone](https://github.com/SVF-tools/SVF/wiki/TypeClone) published in our [ECOOP paper](https://yuleisui.github.io/publications/ecoop20.pdf) is now available in SVF </b> * <b>SVF now uses a single script for its build. Just type [`source ./build.sh`](https://github.com/SVF-tools/SVF/blob/master/build.sh) in your terminal, that's it!</b> * <b>SVF now supports LLVM-10.0.0! </b> * <b>We thank [bsauce](https://github.com/bsauce) for writing a user manual of SVF ([link1](https://www.jianshu.com/p/068a08ec749c) and [link2](https://www.jianshu.com/p/777c30d4240e)) in Chinese </b> * <b>SVF now supports LLVM-9.0.0 (Thank [Byoungyoung Lee](https://github.com/SVF-tools/SVF/issues/142) for his help!). </b> * <b>SVF now supports a set of [field-sensitive pointer analyses](https://yuleisui.github.io/publications/sas2019a.pdf). </b> * <b>[Use SVF as an external lib](https://github.com/SVF-tools/SVF/wiki/Using-SVF-as-a-lib-in-your-own-tool) for your own project (Contributed by [Hongxu Chen](https://github.com/HongxuChen)). </b> * <b>SVF now supports LLVM-7.0.0. </b> * <b>SVF now supports Docker. [Try SVF in Docker](https://github.com/SVF-tools/SVF/wiki/Try-SVF-in-Docker)! </b> * <b>SVF now supports [LLVM-6.0.0](https://github.com/svf-tools/SVF/pull/38) (Contributed by [Jack Anthony](https://github.com/jackanth)). </b> * <b>SVF now supports [LLVM-4.0.0](https://github.com/svf-tools/SVF/pull/23) (Contributed by Jared Carlson. Thank [Jared](https://github.com/jcarlson23) and [Will](https://github.com/dtzWill) for their in-depth [discussions](https://github.com/svf-tools/SVF/pull/18) about updating SVF!) </b> * <b>SVF now supports analysis for C++ programs.</b> <br />",
   "main": "index.js",
   "scripts": {

package/svf/include/AE/Core/AbstractValue.h

@@ -168,317 +168,36 @@ public:
     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());
+        assert(isInterval() && "Attempting to retrieve an AbstractValue that is not an Interval!");
         return interval;
     }
 
-    //
     const IntervalValue getInterval() const
     {
-        assert(isInterval());
+        assert(isInterval() && "Attempting to retrieve an AbstractValue that is not an Interval!");
         return interval;
     }
 
     AddressValue& getAddrs()
     {
-        assert(isAddr());
+        assert(isAddr() && "Attempting to retrieve an AbstractValue that is not an Address!");
         return addr;
     }
 
     const AddressValue getAddrs() const
     {
-        assert(isAddr());
+        assert(isAddr() && "Attempting to retrieve an AbstractValue that is not an Address!");
         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);
-    }
-
-    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();
-    }
-
-    double getRealNumeral() const
-    {
-        assert(isInterval());
-        return interval.getRealNumeral();
-    }
-
-    bool is_numeral() const
-    {
-        assert(isInterval());
-        return interval.is_numeral();
-    }
-
-    void set_to_bottom()
-    {
-        assert(isInterval());
-        interval.set_to_bottom();
-    }
-
-    void set_to_top()
-    {
-        assert(isInterval());
-        interval.set_to_top();
-    }
 
-    bool leq(const AbstractValue &other) const
-    {
-        assert(isInterval() && other.isInterval());
-        return interval.leq(other.interval);
-    }
-
-    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
+    ~AbstractValue() {};
 
     bool equals(const AbstractValue &rhs) const
     {

package/svf/include/AE/Core/IntervalValue.h

@@ -31,8 +31,8 @@
 #ifndef Z3_EXAMPLE_IntervalValue_H
 #define Z3_EXAMPLE_IntervalValue_H
 
-#include "AE/Core/NumericLiteral.h"
 #include <sstream>
+#include "AE/Core/NumericValue.h"
 
 namespace SVF
 {
@@ -44,10 +44,10 @@ class IntervalValue
 {
 private:
     // Lower bound
-    NumericLiteral _lb;
+    BoundedInt _lb;
 
     // Upper bound
-    NumericLiteral _ub;
+    BoundedInt _ub;
 
     // Invariant: isBottom() <=> _lb = 1 && _ub = 0
 public:
@@ -63,18 +63,18 @@ public:
     }
 
     /// Get minus infinity -oo
-    static NumericLiteral minus_infinity()
+    static BoundedInt minus_infinity()
     {
-        return NumericLiteral::minus_infinity();
+        return BoundedInt::minus_infinity();
     }
 
     /// Get plus infinity +oo
-    static NumericLiteral plus_infinity()
+    static BoundedInt plus_infinity()
     {
-        return NumericLiteral::plus_infinity();
+        return BoundedInt::plus_infinity();
     }
 
-    static bool is_infinite(const NumericLiteral &e)
+    static bool is_infinite(const BoundedInt &e)
     {
         return e.is_infinity();
     }
@@ -103,16 +103,16 @@ public:
 
     explicit IntervalValue(double n) : _lb(n), _ub(n) {}
 
-    explicit IntervalValue(NumericLiteral n) : IntervalValue(n, n) {}
+    explicit IntervalValue(BoundedInt n) : IntervalValue(n, n) {}
 
     /// Create the IntervalValue [lb, ub]
-    explicit IntervalValue(NumericLiteral lb, NumericLiteral ub) : _lb(std::move(lb)), _ub(std::move(ub)) {}
+    explicit IntervalValue(BoundedInt lb, BoundedInt ub) : _lb(std::move(lb)), _ub(std::move(ub)) {}
 
-    explicit IntervalValue(s64_t lb, s64_t ub) : IntervalValue(NumericLiteral(lb), NumericLiteral(ub)) {}
+    explicit IntervalValue(s64_t lb, s64_t ub) : IntervalValue(BoundedInt(lb), BoundedInt(ub)) {}
 
-    explicit IntervalValue(double lb, double ub) : IntervalValue(NumericLiteral(lb), NumericLiteral(ub)) {}
+    explicit IntervalValue(double lb, double ub) : IntervalValue(BoundedInt(lb), BoundedInt(ub)) {}
 
-    explicit IntervalValue(float lb, float ub) : IntervalValue(NumericLiteral(lb), NumericLiteral(ub)) {}
+    explicit IntervalValue(float lb, float ub) : IntervalValue(BoundedInt(lb), BoundedInt(ub)) {}
 
     explicit IntervalValue(s32_t lb, s32_t ub) : IntervalValue((s64_t) lb, (s64_t) ub) {}
 
@@ -203,33 +203,33 @@ public:
     ~IntervalValue()  = default;
 
     /// Return the lower bound
-    const NumericLiteral &lb() const
+    const BoundedInt &lb() const
     {
         assert(!this->isBottom());
         return this->_lb;
     }
 
     /// Return the upper bound
-    const NumericLiteral &ub() const
+    const BoundedInt &ub() const
     {
         assert(!this->isBottom());
         return this->_ub;
     }
 
     /// Set the lower bound
-    void setLb(const NumericLiteral &lb)
+    void setLb(const BoundedInt &lb)
     {
         this->_lb = lb;
     }
 
     /// Set the upper bound
-    void setUb(const NumericLiteral &ub)
+    void setUb(const BoundedInt &ub)
     {
         this->_ub = ub;
     }
 
     /// Set the lower bound
-    void setValue(const NumericLiteral &lb, const NumericLiteral &ub)
+    void setValue(const BoundedInt &lb, const BoundedInt &ub)
     {
         this->_lb = lb;
         this->_ub = ub;
@@ -249,18 +249,14 @@ public:
 
     bool is_int() const
     {
-        bool lb_int = _lb.is_int();
-        bool ub_int = _ub.is_int();
-        assert (lb_int == ub_int && "lb and ub should be both int or both float");
-        return _lb.is_int();
+        return !is_real();
     }
 
     bool is_real() const
     {
         bool lb_real = _lb.is_real();
         bool ub_real = _ub.is_real();
-        assert (lb_real == ub_real && "lb and ub should be both real or both int");
-        return _lb.is_real();
+        return lb_real || ub_real;
     }
 
     /// Return
@@ -539,13 +535,13 @@ inline IntervalValue operator*(const IntervalValue &lhs,
     }
     else
     {
-        NumericLiteral ll = lhs.lb() * rhs.lb();
-        NumericLiteral lu = lhs.lb() * rhs.ub();
-        NumericLiteral ul = lhs.ub() * rhs.lb();
-        NumericLiteral uu = lhs.ub() * rhs.ub();
-        std::vector<NumericLiteral> vec{ll, lu, ul, uu};
-        return IntervalValue(NumericLiteral::min(vec),
-                             NumericLiteral::max(vec));
+        BoundedInt ll = lhs.lb() * rhs.lb();
+        BoundedInt lu = lhs.lb() * rhs.ub();
+        BoundedInt ul = lhs.ub() * rhs.lb();
+        BoundedInt uu = lhs.ub() * rhs.ub();
+        std::vector<BoundedDouble> vec{ll, lu, ul, uu};
+        return IntervalValue(BoundedInt::min(vec),
+                             BoundedInt::max(vec));
     }
 }
 
@@ -564,14 +560,14 @@ inline IntervalValue operator/(const IntervalValue &lhs,
     else
     {
         // Neither the dividend nor the divisor contains 0
-        NumericLiteral ll = lhs.lb() / rhs.lb();
-        NumericLiteral lu = lhs.lb() / rhs.ub();
-        NumericLiteral ul = lhs.ub() / rhs.lb();
-        NumericLiteral uu = lhs.ub() / rhs.ub();
-        std::vector<NumericLiteral> vec{ll, lu, ul, uu};
+        BoundedInt ll = lhs.lb() / rhs.lb();
+        BoundedInt lu = lhs.lb() / rhs.ub();
+        BoundedInt ul = lhs.ub() / rhs.lb();
+        BoundedInt uu = lhs.ub() / rhs.ub();
+        std::vector<BoundedDouble> vec{ll, lu, ul, uu};
 
-        return IntervalValue(NumericLiteral::min(vec),
-                             NumericLiteral::max(vec));
+        return IntervalValue(BoundedInt::min(vec),
+                             BoundedInt::max(vec));
     }
 }
 
@@ -593,9 +589,9 @@ inline IntervalValue operator%(const IntervalValue &lhs,
     }
     else
     {
-        NumericLiteral n_ub = max(abs(lhs.lb()), abs(lhs.ub()));
-        NumericLiteral d_ub = max(abs(rhs.lb()), rhs.ub()) - 1;
-        NumericLiteral ub = min(n_ub, d_ub);
+        BoundedInt n_ub = max(abs(lhs.lb()), abs(lhs.ub()));
+        BoundedInt d_ub = max(abs(rhs.lb()), rhs.ub()) - 1;
+        BoundedInt ub = min(n_ub, d_ub);
 
         if (lhs.lb().getNumeral() < 0)
         {
@@ -864,13 +860,13 @@ inline IntervalValue operator>>(const IntervalValue &lhs, const IntervalValue &r
         }
         else
         {
-            NumericLiteral ll = lhs.lb() >> shift.lb();
-            NumericLiteral lu = lhs.lb() >> shift.ub();
-            NumericLiteral ul = lhs.ub() >> shift.lb();
-            NumericLiteral uu = lhs.ub() >> shift.ub();
-            std::vector<NumericLiteral> vec{ll, lu, ul, uu};
-            return IntervalValue(NumericLiteral::min(vec),
-                                 NumericLiteral::max(vec));
+            BoundedInt ll = lhs.lb() >> shift.lb();
+            BoundedInt lu = lhs.lb() >> shift.ub();
+            BoundedInt ul = lhs.ub() >> shift.lb();
+            BoundedInt uu = lhs.ub() >> shift.ub();
+            std::vector<BoundedDouble> vec{ll, lu, ul, uu};
+            return IntervalValue(BoundedInt::min(vec),
+                                 BoundedInt::max(vec));
         }
     }
 }