svf-tools 1.0.937 → 1.0.938

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.937",
+  "version": "1.0.938",
   "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

@@ -213,31 +213,31 @@ public:
         return interval.isBottom();
     }
 
-    const NumericLiteral& lb() const
+    const BoundedInt& lb() const
     {
         assert(isInterval());
         return interval.lb();
     }
 
-    const NumericLiteral& ub() const
+    const BoundedInt& ub() const
     {
         assert(isInterval());
         return interval.ub();
     }
 
-    void setLb(const NumericLiteral& lb)
+    void setLb(const BoundedInt& lb)
     {
         assert(isInterval());
         interval.setLb(lb);
     }
 
-    void setUb(const NumericLiteral& ub)
+    void setUb(const BoundedInt& ub)
     {
         assert(isInterval());
         interval.setUb(ub);
     }
 
-    void setValue(const NumericLiteral &lb, const NumericLiteral &ub)
+    void setValue(const BoundedInt &lb, const BoundedInt &ub)
     {
         assert(isInterval());
         interval.setValue(lb, ub);

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));
         }
     }
 }