svf-lib 1.0.1650 → 1.0.1652

package/SVF-linux/svf/include/AbstractExecution/SVFIR2ItvExeState.h

@@ -71,23 +71,23 @@ public:
     void narrowVAddrs(IntervalExeState &lhs, const IntervalExeState &rhs);
 
     /// Return the field address given a pointer points to a struct object and an offset
-    VAddrs getGepObjAddress(u32_t pointer, s32_t offset);
+    VAddrs getGepObjAddress(u32_t pointer, APOffset offset);
 
     /// Return the byte offset from one gep param offset
-    std::pair<s32_t, s32_t> getBytefromGepTypePair(const AccessPath::VarAndGepTypePair& gep_pair, const GepStmt *gep, s32_t elem_bytesize);
+    std::pair<APOffset, APOffset> getBytefromGepTypePair(const AccessPath::VarAndGepTypePair& gep_pair, const GepStmt *gep, APOffset elem_bytesize);
 
     /// Return the Index offset from one gep param offset
-    std::pair<s32_t, s32_t> getIndexfromGepTypePair(const AccessPath::VarAndGepTypePair& gep_pair, const GepStmt *gep);
+    std::pair<APOffset, APOffset> getIndexfromGepTypePair(const AccessPath::VarAndGepTypePair& gep_pair, const GepStmt *gep);
 
     /// Return the byte offset expression of a GepStmt
     /// elemBytesize is the element byte size of an static alloc or heap alloc array
     /// e.g. GepStmt* gep = **,
     /// s32_t elemBytesize = LLVMUtil::SVFType2ByteSize(gep->getRHSVar()->getValue()->getType());
     /// std::pair<s32_t, s32_t> byteOffset = getGepByteOffset(gep, elemBytesize);
-    std::pair<s32_t, s32_t> getGepByteOffset(const GepStmt *gep, s32_t elemBytesize);
+    std::pair<APOffset, APOffset> getGepByteOffset(const GepStmt *gep, APOffset elemBytesize);
 
     /// Return the offset expression of a GepStmt
-    std::pair<s32_t, s32_t> getGepOffset(const GepStmt *gep);
+    std::pair<APOffset, APOffset> getGepOffset(const GepStmt *gep);
 
 
     static z3::context &getContext()

package/SVF-osx/svf/include/AbstractExecution/BoundedZ3Expr.h

@@ -51,7 +51,7 @@ public:
 
     BoundedZ3Expr(s32_t i) : Z3Expr(i) {}
 
-    BoundedZ3Expr(int64_t i) : Z3Expr(getContext().int_val(i)) {}
+    BoundedZ3Expr(s64_t i) : Z3Expr(getContext().int_val((int64_t)i)) {}
 
     BoundedZ3Expr(const BoundedZ3Expr &z3Expr) : Z3Expr(z3Expr) {}
 
@@ -345,13 +345,13 @@ public:
     }
 
     /// Return Numeral
-    inline int64_t getNumeral() const
+    inline s64_t getNumeral() const
     {
         if (is_numeral())
         {
             int64_t i;
             if (getExpr().is_numeral_i64(i))
-                return get_numeral_int64();
+                return (s64_t)get_numeral_int64();
             else
             {
                 return (getExpr() < 0).simplify().is_true() ? INT64_MIN : INT64_MAX;
@@ -372,7 +372,7 @@ public:
         }
     }
 
-    int64_t bvLen() const;
+    s64_t bvLen() const;
     //%}
 }; // end class ConZ3Expr
 } // end namespace SVF

package/SVF-osx/svf/include/AbstractExecution/IntervalValue.h

@@ -94,13 +94,13 @@ public:
     explicit IntervalValue() : AbstractValue(AbstractValue::IntervalK), _lb(minus_infinity()), _ub(plus_infinity()) {}
 
     /// Create the IntervalValue [n, n]
-    explicit IntervalValue(int64_t n) : AbstractValue(AbstractValue::IntervalK), _lb(n), _ub(n) {}
+    explicit IntervalValue(s64_t n) : AbstractValue(AbstractValue::IntervalK), _lb(n), _ub(n) {}
 
-    explicit IntervalValue(s32_t n) : IntervalValue((int64_t) n) {}
+    explicit IntervalValue(s32_t n) : IntervalValue((s64_t) n) {}
 
-    explicit IntervalValue(u32_t n) : IntervalValue((int64_t) n) {}
+    explicit IntervalValue(u32_t n) : IntervalValue((s64_t) n) {}
 
-    explicit IntervalValue(double n) : IntervalValue((int64_t) n) {}
+    explicit IntervalValue(double n) : IntervalValue((s64_t) n) {}
 
     explicit IntervalValue(NumericLiteral n) : IntervalValue(n, n) {}
 
@@ -108,15 +108,15 @@ public:
     explicit IntervalValue(NumericLiteral lb, NumericLiteral ub) : AbstractValue(AbstractValue::IntervalK),
         _lb(std::move(lb)), _ub(std::move(ub)) {}
 
-    explicit IntervalValue(int64_t lb, int64_t ub) : IntervalValue(NumericLiteral(lb), NumericLiteral(ub)) {}
+    explicit IntervalValue(s64_t lb, s64_t ub) : IntervalValue(NumericLiteral(lb), NumericLiteral(ub)) {}
 
-    explicit IntervalValue(double lb, double ub) : IntervalValue(NumericLiteral((int64_t) lb), NumericLiteral((int64_t) ub)) {}
+    explicit IntervalValue(double lb, double ub) : IntervalValue(NumericLiteral((s64_t) lb), NumericLiteral((s64_t) ub)) {}
 
-    explicit IntervalValue(s32_t lb, s32_t ub) : IntervalValue((int64_t) lb, (int64_t) ub) {}
+    explicit IntervalValue(s32_t lb, s32_t ub) : IntervalValue((s64_t) lb, (s64_t) ub) {}
 
-    explicit IntervalValue(u32_t lb, u32_t ub) : IntervalValue((int64_t) lb, (int64_t) ub) {}
+    explicit IntervalValue(u32_t lb, u32_t ub) : IntervalValue((s64_t) lb, (s64_t) ub) {}
 
-    explicit IntervalValue(u64_t lb, u64_t ub) : IntervalValue((int64_t) lb, (int64_t) ub) {}
+    explicit IntervalValue(u64_t lb, u64_t ub) : IntervalValue((s64_t) lb, (s64_t) ub) {}
 
     /// Copy constructor
     IntervalValue(const IntervalValue &) = default;
@@ -259,7 +259,7 @@ public:
     }
 
     /// Return
-    int64_t getNumeral() const
+    s64_t getNumeral() const
     {
         assert(is_numeral() && "this IntervalValue is not numeral");
         return _lb.getNumeral();
@@ -797,15 +797,15 @@ inline IntervalValue operator&(const IntervalValue &lhs, const IntervalValue &rh
     }
     else if (lhs.lb().getNumeral() >= 0 && rhs.lb().getNumeral() >= 0)
     {
-        return IntervalValue((int64_t) 0, min(lhs.ub(), rhs.ub()));
+        return IntervalValue((s64_t) 0, min(lhs.ub(), rhs.ub()));
     }
     else if (lhs.lb().getNumeral() >= 0)
     {
-        return IntervalValue((int64_t) 0, lhs.ub());
+        return IntervalValue((s64_t) 0, lhs.ub());
     }
     else if (rhs.lb().getNumeral() >= 0)
     {
-        return IntervalValue((int64_t) 0, rhs.ub());
+        return IntervalValue((s64_t) 0, rhs.ub());
     }
     else
     {
@@ -832,9 +832,9 @@ inline IntervalValue operator|(const IntervalValue &lhs, const IntervalValue &rh
     else if (lhs.lb().getNumeral() >= 0 && !lhs.ub().is_infinity() &&
              rhs.lb().getNumeral() >= 0 && !rhs.ub().is_infinity())
     {
-        int64_t m = std::max(lhs.ub().getNumeral(), rhs.ub().getNumeral());
-        int64_t ub = next_power_of_2(s64_t(m+1));
-        return IntervalValue((int64_t) 0, (int64_t) ub);
+        s64_t m = std::max(lhs.ub().getNumeral(), rhs.ub().getNumeral());
+        s64_t ub = next_power_of_2(s64_t(m+1));
+        return IntervalValue((s64_t) 0, (s64_t) ub);
     }
     else
     {
@@ -861,9 +861,9 @@ inline IntervalValue operator^(const IntervalValue &lhs, const IntervalValue &rh
     else if (lhs.lb().getNumeral() >= 0 && !lhs.ub().is_infinity() &&
              rhs.lb().getNumeral() >= 0 && !rhs.ub().is_infinity())
     {
-        int64_t m = std::max(lhs.ub().getNumeral(), rhs.ub().getNumeral());
-        int64_t ub = next_power_of_2(s64_t(m+1));
-        return IntervalValue((int64_t) 0, (int64_t) ub);
+        s64_t m = std::max(lhs.ub().getNumeral(), rhs.ub().getNumeral());
+        s64_t ub = next_power_of_2(s64_t(m+1));
+        return IntervalValue((s64_t) 0, (s64_t) ub);
     }
     else
     {

package/SVF-osx/svf/include/AbstractExecution/NumericLiteral.h

@@ -54,7 +54,7 @@ public:
 
     NumericLiteral(s32_t i) : _n(i) {}
 
-    NumericLiteral(int64_t i) : _n(i) {}
+    NumericLiteral(s64_t i) : _n(i) {}
 
     NumericLiteral(BoundedZ3Expr z3Expr) : _n(std::move(z3Expr)) {}
 
@@ -117,7 +117,7 @@ public:
     }
 
     /// Return Numeral
-    inline int64_t getNumeral() const
+    inline s64_t getNumeral() const
     {
         return _n.getNumeral();
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-lib",
-  "version": "1.0.1650",
+  "version": "1.0.1652",
   "description": "SVF's npm support",
   "main": "index.js",
   "scripts": {