svf-tools 1.0.682 → 1.0.684

package/svf/include/AbstractExecution/NumericLiteral.h

@@ -30,70 +30,78 @@
 #ifndef Z3_EXAMPLE_Number_H
 #define Z3_EXAMPLE_Number_H
 
+#include <utility>
+
 #include "SVFIR/SVFType.h"
+#include "AbstractExecution/BoundedZ3Expr.h"
 
 namespace SVF
 {
 class NumericLiteral
 {
 private:
-    double _n;
+    BoundedZ3Expr _n;
 
 public:
     /// Default constructor
     NumericLiteral() = delete;
 
-    /// Create a new NumericLiteral from double
-    NumericLiteral(double n) : _n(n) {}
-
     /// Create a new NumericLiteral from s32_t
-    NumericLiteral(s32_t n) : _n(n) {}
 
-    /// Create a new NumericLiteral from s64_t
-    NumericLiteral(s64_t n) : _n(n) {}
+    NumericLiteral(const Z3Expr &z3Expr) : _n(z3Expr) {}
+
+    NumericLiteral(const z3::expr &e) : _n(e) {}
 
-    /// Create a new NumericLiteral from u32_t
-    NumericLiteral(u32_t n) : _n(n) {}
+    NumericLiteral(s32_t i) : _n(i) {}
 
-    /// Create a new NumericLiteral from u64_t
-    NumericLiteral(u64_t n) : _n(n) {}
+    NumericLiteral(int64_t i) : _n(i) {}
+
+    NumericLiteral(BoundedZ3Expr z3Expr) : _n(std::move(z3Expr)) {}
 
     virtual ~NumericLiteral() = default;
 
     /// Copy Constructor
-    NumericLiteral(const NumericLiteral &) noexcept = default;
+    NumericLiteral(const NumericLiteral &) = default;
 
     /// Move Constructor
-    NumericLiteral(NumericLiteral &&) noexcept = default;
+    NumericLiteral(NumericLiteral &&) = default;
 
     /// Operator = , another Copy Constructor
-    inline NumericLiteral &operator=(const NumericLiteral &) noexcept = default;
+    inline NumericLiteral &operator=(const NumericLiteral &) = default;
 
     /// Operator = , another Move Constructor
-    inline NumericLiteral &operator=(NumericLiteral &&) noexcept = default;
+    inline NumericLiteral &operator=(NumericLiteral &&) = default;
+
+    static NumericLiteral plus_infinity()
+    {
+        return BoundedZ3Expr::plus_infinity();
+    }
 
-    /// Get minus infinity -oo
     static NumericLiteral minus_infinity()
     {
-        return NumericLiteral(INT_MIN);
+        return BoundedZ3Expr::minus_infinity();
     }
 
-    /// Get plus infinity +oo
-    static NumericLiteral plus_infinity()
+    static z3::context &getContext()
     {
-        return NumericLiteral(INT_MAX);
+        return BoundedZ3Expr::getContext();
+    }
+
+    const std::string to_string() const
+    {
+        return _n.to_string();
     }
 
     /// Check if this is minus infinity
     inline bool is_minus_infinity() const
     {
-        return _n == INT_MIN;
+        return _n.is_minus_infinite();
     }
 
     /// Check if this is plus infinity
     inline bool is_plus_infinity() const
     {
-        return _n == INT_MAX;
+        return _n.is_plus_infinite();
     }
 
     /// Check if this is infinity (either of plus/minus)
@@ -105,13 +113,34 @@ public:
     /// Check if this is zero
     inline bool is_zero() const
     {
-        return _n == 0;
+        return _n.is_zero();
     }
 
     /// Return Numeral
-    inline double getNumeral() const
+    inline int64_t getNumeral() const
     {
-        return _n;
+        if (_n.is_numeral())
+        {
+            int64_t i;
+            if(_n.getExpr().is_numeral_i64(i))
+                return _n.get_numeral_int64();
+            else
+            {
+                return leq(0) ? INT64_MIN : INT64_MAX;
+            }
+        }
+        if (is_minus_infinity())
+        {
+            return INT64_MIN;
+        }
+        else if (is_plus_infinity())
+        {
+            return INT64_MAX;
+        }
+        else
+        {
+            assert(false && "other literal?");
+        }
     }
 
     /// Check two object is equal
@@ -134,7 +163,13 @@ public:
                 return rhs.is_plus_infinity();
             }
         }
-        return _n <= rhs._n;
+        if(is_infinity() && rhs.is_infinity())
+        {
+            if(is_minus_infinity()) return true;
+            else return rhs.is_plus_infinity();
+        }
+        else
+            return _n.leq(rhs._n).simplify().is_true();
     }
 
     // Greater than or equal
@@ -151,7 +186,13 @@ public:
                 return rhs.is_minus_infinity();
             }
         }
-        return _n >= rhs._n;
+        if(is_infinity() && rhs.is_infinity())
+        {
+            if(is_plus_infinity()) return true;
+            else return rhs.is_minus_infinity();
+        }
+        else
+            return _n.geq(rhs._n).simplify().is_true();
     }
 
 
@@ -159,38 +200,38 @@ public:
     //{%
     friend NumericLiteral operator==(const NumericLiteral &lhs, const NumericLiteral &rhs)
     {
-        return eq(lhs, rhs);
+        return eq(lhs, rhs) ? 1 : 0;
     }
 
     friend NumericLiteral operator!=(const NumericLiteral &lhs, const NumericLiteral &rhs)
     {
-        return !eq(lhs, rhs);
+        return !eq(lhs, rhs) ? 1 : 0;
     }
 
     friend NumericLiteral operator>(const NumericLiteral &lhs, const NumericLiteral &rhs)
     {
-        return !lhs.leq(rhs);
+        return (!lhs.leq(rhs)) ? 1 : 0;
     }
 
     friend NumericLiteral operator<(const NumericLiteral &lhs, const NumericLiteral &rhs)
     {
-        return !lhs.geq(rhs);
+        return (!lhs.geq(rhs)) ? 1 : 0;
     }
 
     friend NumericLiteral operator<=(const NumericLiteral &lhs, const NumericLiteral &rhs)
     {
-        return lhs.leq(rhs);
+        return lhs.leq(rhs) ? 1 : 0;
     }
 
     friend NumericLiteral operator>=(const NumericLiteral &lhs, const NumericLiteral &rhs)
     {
-        return lhs.geq(rhs);
+        return lhs.geq(rhs) ? 1 : 0;
     }
 
-    friend NumericLiteral operator+(const NumericLiteral& lhs, const NumericLiteral& rhs)
+    friend NumericLiteral operator+(const NumericLiteral &lhs, const NumericLiteral &rhs)
     {
         if (!lhs.is_infinity() && !rhs.is_infinity())
-            return lhs.getNumeral() + rhs.getNumeral();
+            return (lhs._n + rhs._n).simplify();
         else if (!lhs.is_infinity() && rhs.is_infinity())
             return rhs;
         else if (lhs.is_infinity() && !rhs.is_infinity())
@@ -207,7 +248,7 @@ public:
     friend NumericLiteral operator-(const NumericLiteral &lhs, const NumericLiteral &rhs)
     {
         if (!lhs.is_infinity() && !rhs.is_infinity())
-            return lhs.getNumeral() - rhs.getNumeral();
+            return (lhs._n - rhs._n).simplify();
         else if (!lhs.is_infinity() && rhs.is_infinity())
             return -rhs;
         else if (lhs.is_infinity() && !rhs.is_infinity())
@@ -228,11 +269,11 @@ public:
         else if (lhs.is_infinity() && rhs.is_infinity())
             return eq(lhs, rhs) ? plus_infinity() : minus_infinity();
         else if (lhs.is_infinity())
-            return rhs.getNumeral() > 0 ? lhs : -lhs;
+            return !rhs.leq(0) ? lhs : -lhs;
         else if (rhs.is_infinity())
-            return lhs.getNumeral() > 0 ? rhs : -rhs;
+            return !lhs.leq(0) ? rhs : -rhs;
         else
-            return lhs.getNumeral() * rhs.getNumeral();
+            return (lhs._n * rhs._n).simplify();
     }
 
     friend NumericLiteral operator/(const NumericLiteral &lhs, const NumericLiteral &rhs)
@@ -244,11 +285,11 @@ public:
             abort();
         }
         else if (!lhs.is_infinity() && !rhs.is_infinity())
-            return lhs.getNumeral() / rhs.getNumeral();
+            return (lhs._n / rhs._n).simplify();
         else if (!lhs.is_infinity() && rhs.is_infinity())
             return 0;
         else if (lhs.is_infinity() && !rhs.is_infinity())
-            return rhs.getNumeral() > 0 ? lhs : -lhs;
+            return !rhs.leq(0) ? lhs : -lhs;
         else
             // TODO: +oo/-oo L'Hôpital's rule?
             return eq(lhs, rhs) ? plus_infinity() : minus_infinity();
@@ -262,12 +303,12 @@ public:
             abort();
         }
         else if (!lhs.is_infinity() && !rhs.is_infinity())
-            return (s32_t) lhs.getNumeral() % (s32_t) rhs.getNumeral();
+            return (lhs._n % rhs._n).simplify();
         else if (!lhs.is_infinity() && rhs.is_infinity())
             return 0;
         // TODO: not sure
         else if (lhs.is_infinity() && !rhs.is_infinity())
-            return rhs.getNumeral() > 0 ? lhs : -lhs;
+            return !rhs.leq(0) ? lhs : -lhs;
         else
             // TODO: +oo/-oo L'Hôpital's rule?
             return eq(lhs, rhs) ? plus_infinity() : minus_infinity();
@@ -276,17 +317,17 @@ public:
     // TODO: logic operation for infinity?
     friend NumericLiteral operator^(const NumericLiteral &lhs, const NumericLiteral &rhs)
     {
-        return (s32_t) lhs.getNumeral() ^ (s32_t) rhs.getNumeral();
+        return (lhs._n ^ rhs._n).simplify();
     }
 
     friend NumericLiteral operator&(const NumericLiteral &lhs, const NumericLiteral &rhs)
     {
-        return (s32_t) lhs.getNumeral() & (s32_t) rhs.getNumeral();
+        return (lhs._n & rhs._n).simplify();
     }
 
     friend NumericLiteral operator|(const NumericLiteral &lhs, const NumericLiteral &rhs)
     {
-        return (s32_t) lhs.getNumeral() | (s32_t) rhs.getNumeral();
+        return (lhs._n | rhs._n).simplify();
     }
 
     friend NumericLiteral operator>>(const NumericLiteral &lhs, const NumericLiteral &rhs)
@@ -297,7 +338,7 @@ public:
         else if (lhs.is_infinity())
             return lhs;
         else if (rhs.is_infinity())
-            return lhs._n >= 0 ? 0 : -1;
+            return lhs.geq(0) ? 0 : -1;
         else
             return (s32_t) lhs.getNumeral() >> (s32_t) rhs.getNumeral();
     }
@@ -310,35 +351,44 @@ public:
         else if (lhs.is_infinity())
             return lhs;
         else if (rhs.is_infinity())
-            return lhs._n >= 0 ? plus_infinity() : minus_infinity();
+            return lhs.geq(0) ? plus_infinity() : minus_infinity();
         else
             return (s32_t) lhs.getNumeral() << (s32_t) rhs.getNumeral();
     }
 
     friend NumericLiteral operator&&(const NumericLiteral &lhs, const NumericLiteral &rhs)
     {
-        return lhs.getNumeral() && rhs.getNumeral();
+        return (lhs._n && rhs._n).simplify();
     }
 
     friend NumericLiteral operator||(const NumericLiteral &lhs, const NumericLiteral &rhs)
     {
-        return lhs.getNumeral() || rhs.getNumeral();
+        return (lhs._n || rhs._n).simplify();
     }
 
     friend NumericLiteral operator!(const NumericLiteral &lhs)
     {
-        return !lhs.getNumeral();
+        return (!lhs._n).simplify();
     }
 
     friend NumericLiteral operator-(const NumericLiteral &lhs)
     {
-        return -lhs.getNumeral();
+        if (lhs.is_plus_infinity())
+        {
+            return minus_infinity();
+        }
+        else if (lhs.is_minus_infinity())
+        {
+            return plus_infinity();
+        }
+        else
+            return (-lhs._n).simplify();
     }
 
     /// Return ite? lhs : rhs
     friend NumericLiteral ite(const NumericLiteral &cond, const NumericLiteral &lhs, const NumericLiteral &rhs)
     {
-        return cond.getNumeral() ? lhs.getNumeral() : rhs.getNumeral();
+        return ite(cond._n, lhs._n, rhs._n).simplify();
     }
 
     friend std::ostream &operator<<(std::ostream &out, const NumericLiteral &expr)
@@ -348,29 +398,34 @@ public:
         else if (expr.is_minus_infinity())
             out << "-INF";
         else
-            out << std::to_string(expr.getNumeral());
+            out << expr._n;
         return out;
     }
 
     friend bool eq(const NumericLiteral &lhs, const NumericLiteral &rhs)
     {
-        return lhs._n == rhs._n;
+        return eq(lhs._n, rhs._n);
     }
 
     friend NumericLiteral min(const NumericLiteral &lhs, const NumericLiteral &rhs)
     {
-        return std::min(lhs.getNumeral(), rhs.getNumeral());
+        return lhs.leq(rhs) ? lhs : rhs;
     }
 
     friend NumericLiteral max(const NumericLiteral &lhs, const NumericLiteral &rhs)
     {
-        return std::max(lhs.getNumeral(), rhs.getNumeral());
+        return lhs.leq(rhs) ? rhs : lhs;
+    }
+
+    friend NumericLiteral abs(const NumericLiteral &lhs)
+    {
+        return lhs.leq(0) ? -lhs : lhs;
     }
 
     // TODO: how to use initializer_list as argument?
-    friend NumericLiteral min(std::initializer_list<NumericLiteral> _l)
+    static NumericLiteral min(std::vector<NumericLiteral>& _l)
     {
-        NumericLiteral ret(INT_MAX);
+        NumericLiteral ret(plus_infinity());
         for (const auto &it: _l)
         {
             if (it.is_minus_infinity())
@@ -383,9 +438,9 @@ public:
         return ret;
     }
 
-    friend NumericLiteral max(std::initializer_list<NumericLiteral> _l)
+    static NumericLiteral max(std::vector<NumericLiteral>& _l)
     {
-        NumericLiteral ret(INT_MIN);
+        NumericLiteral ret(minus_infinity());
         for (const auto &it: _l)
         {
             if (it.is_plus_infinity())
@@ -401,6 +456,6 @@ public:
     //%}
 
 
-}; // end class IntervalDouble
+}; // end class NumericLiteral
 } // end namespace SVF
 #endif //Z3_EXAMPLE_Number_H

package/svf/lib/SVFIR/SVFIRRW.cpp

@@ -758,6 +758,7 @@ cJSON* jsonCreateString(const char* str)
 cJSON* jsonCreateIndex(size_t index)
 {
     constexpr size_t maxPreciseIntInDouble = (1ull << 53);
+    (void)maxPreciseIntInDouble; // silence unused warning
     assert(index <= maxPreciseIntInDouble);
     return cJSON_CreateNumber(index);
 }
@@ -1099,7 +1100,7 @@ cJSON* SVFIRWriter::toJson(const SVFModule* module)
     cJSON* values = jsonCreateArray();
     for (size_t i = 1; i <= svfModuleWriter.svfValuePool.size(); ++i)
     {
-        cJSON* value = toJson(svfModuleWriter.svfValuePool.getPtr(i));
+        cJSON* value = contentToJson(svfModuleWriter.svfValuePool.getPtr(i));
         jsonAddItemToArray(values, value);
     }
     jsonAddItemToObject(root, "values", values);
@@ -1107,7 +1108,7 @@ cJSON* SVFIRWriter::toJson(const SVFModule* module)
     cJSON* types = jsonCreateArray();
     for (size_t i = 1; i <= svfModuleWriter.svfTypePool.size(); ++i)
     {
-        cJSON* type = toJson(svfModuleWriter.svfTypePool.getPtr(i));
+        cJSON* type = contentToJson(svfModuleWriter.svfTypePool.getPtr(i));
         jsonAddItemToArray(types, type);
     }
     jsonAddItemToObject(root, "types", types);

package/svf-llvm/include/SVF-LLVM/LLVMModule.h

@@ -352,7 +352,7 @@ private:
     /// Invoke llvm passes to modify module
     void prePassSchedule();
     bool preProcessed;
-    void build_symbol_table() const;
+    void buildSymbolTable() const;
 };
 
 } // End namespace SVF