svf-lib 1.0.1907 → 1.0.1909

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

@@ -345,31 +345,42 @@ public:
         return getExpr().is_true();
     }
 
+    inline bool is_int() const
+    {
+        return getExpr().is_int();
+    }
+
+    inline bool is_real() const
+    {
+        return getExpr().is_real();
+    }
+
+    inline s64_t getIntNumeral() const
+    {
+        assert(is_int() && "not an integer");
+        int64_t i;
+        if (getExpr().is_numeral_i64(i))
+            return (s64_t)get_numeral_int64();
+        else
+            return (getExpr() < 0).simplify().is_true() ? INT64_MIN : INT64_MAX;
+    }
+
+    inline double getRealNumeral() const
+    {
+        assert(is_real() && "not a real");
+        std::string decstr = getExpr().get_decimal_string(10);
+        return std::stod(decstr);
+    }
+
     /// Return Numeral
     inline s64_t getNumeral() const
     {
-        if (is_numeral())
-        {
-            int64_t i;
-            if (getExpr().is_numeral_i64(i))
-                return (s64_t)get_numeral_int64();
-            else
-            {
-                return (getExpr() < 0).simplify().is_true() ? INT64_MIN : INT64_MAX;
-            }
-        }
-        if (is_minus_infinite())
-        {
-            return INT64_MIN;
-        }
-        else if (is_plus_infinite())
-        {
-            return INT64_MAX;
-        }
+        int64_t i;
+        if (getExpr().is_numeral_i64(i))
+            return (s64_t)get_numeral_int64();
         else
         {
-            assert(false && "other literal?");
-            abort();
+            return (getExpr() < 0).simplify().is_true() ? INT64_MIN : INT64_MAX;
         }
     }
 

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

@@ -111,7 +111,9 @@ public:
 
     explicit IntervalValue(s64_t lb, s64_t ub) : IntervalValue(NumericLiteral(lb), NumericLiteral(ub)) {}
 
-    explicit IntervalValue(double lb, double ub) : IntervalValue(NumericLiteral((s64_t) lb), NumericLiteral((s64_t) ub)) {}
+    explicit IntervalValue(double lb, double ub) : IntervalValue(NumericLiteral(lb), NumericLiteral(ub)) {}
+
+    explicit IntervalValue(float lb, float ub) : IntervalValue(NumericLiteral(lb), NumericLiteral(ub)) {}
 
     explicit IntervalValue(s32_t lb, s32_t ub) : IntervalValue((s64_t) lb, (s64_t) ub) {}
 
@@ -259,6 +261,22 @@ public:
         return _lb.is_infinity() || _ub.is_infinity();
     }
 
+    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();
+    }
+
+    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
     s64_t getNumeral() const
     {
@@ -266,6 +284,18 @@ public:
         return _lb.getNumeral();
     }
 
+    s64_t getIntNumeral() const
+    {
+        assert(is_numeral() && "this IntervalValue is not numeral");
+        return _lb.getIntNumeral();
+    }
+
+    double getRealNumeral() const
+    {
+        assert(is_numeral() && "this IntervalValue is not numeral");
+        return _lb.getRealNumeral();
+    }
+
     /// Return true if the IntervalValue is a number [num, num]
     bool is_numeral() const
     {
@@ -335,9 +365,31 @@ public:
         }
         else
         {
-            return this->_lb.equal(other._lb) && this->_ub.equal(other._ub);
-            // TODO: IntervalValueZ3Expr equals
-            // TODO: shall we consider expr and solve.
+            if (this->is_real() && other.is_real())
+            {
+                return this->_lb.equal(other._lb) && this->_ub.equal(other._ub);
+            }
+            else if (this->is_int() && other.is_int())
+            {
+                return this->_lb.equal(other._lb) && this->_ub.equal(other._ub);
+            }
+            else if (this->is_int())
+            {
+                double thislb = this->_lb.getIntNumeral();
+                double thisub = this->_ub.getIntNumeral();
+                double otherlb = other._lb.getRealNumeral();
+                double otherub = other._ub.getRealNumeral();
+                return thislb == otherlb && thisub == otherub;
+            }
+            else
+            {
+                double thislb = this->_lb.getRealNumeral();
+                double thisub = this->_ub.getRealNumeral();
+                double otherlb = other._lb.getIntNumeral();
+                double otherub = other._ub.getIntNumeral();
+                return thislb == otherlb && thisub == otherub;
+            }
+            assert(false && "not implemented");
         }
     }
 

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

@@ -50,6 +50,10 @@ public:
 
     NumericLiteral(const z3::expr &e) : _n(e) {}
 
+    NumericLiteral(float i) : _n(getContext().real_val(std::to_string(i).c_str())) {}
+
+    NumericLiteral(double i) : _n(getContext().real_val(std::to_string(i).c_str())) {}
+
     NumericLiteral(s32_t i) : _n(i) {}
 
     NumericLiteral(s64_t i) : _n(i) {}
@@ -114,12 +118,32 @@ public:
         return _n.is_zero();
     }
 
-    /// Return Numeral
+    inline bool is_int() const
+    {
+        return _n.is_int();
+    }
+
+    inline bool is_real() const
+    {
+        return _n.is_real();
+    }
+
+    /// Return Numeral, default type is double in case to support both int and float
     inline s64_t getNumeral() const
     {
         return _n.getNumeral();
     }
 
+    inline double getRealNumeral() const
+    {
+        return _n.getRealNumeral();
+    }
+
+    inline s64_t getIntNumeral() const
+    {
+        return _n.getIntNumeral();
+    }
+
     /// Check two object is equal
     bool equal(const NumericLiteral &rhs) const
     {

package/SVF-linux/Release-build/include/AE/Svfexe/SVFIR2ItvExeState.h

@@ -79,6 +79,15 @@ public:
     /// Return the value range of Integer SVF Type, e.g. unsigned i8 Type->[0, 255], signed i8 Type->[-128, 127]
     IntervalValue getRangeLimitFromType(const SVFType* type);
 
+    IntervalValue getZExtValue(const SVFVar* var);
+    IntervalValue getSExtValue(const SVFVar* var);
+    IntervalValue getFPToSIntValue(const SVFVar* var);
+    IntervalValue getFPToUIntValue(const SVFVar* var);
+    IntervalValue getSIntToFPValue(const SVFVar* var);
+    IntervalValue getUIntToFPValue(const SVFVar* var);
+    IntervalValue getTruncValue(const SVFVar* var, const SVFType* dstType);
+    IntervalValue getFPTruncValue(const SVFVar* var, const SVFType* dstType);
+
     /// 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 = [i32*10], x, and x is [0,3]
@@ -206,6 +215,7 @@ private:
     RelExeState _relEs;
 
     Map<NodeID, IntervalExeState *> _br_cond;
+    IntervalValue getZExtValue(const SVFVar* var, const SVFType*);
 };
 }
 

package/SVF-linux/Release-build/include/SVF-LLVM/SVFIRBuilder.h

@@ -358,16 +358,52 @@ protected:
         return edge;
     }
 
-    /// Add Copy edge
-    inline CopyStmt* addCopyEdge(NodeID src, NodeID dst)
+    inline CopyStmt* addCopyEdge(NodeID src, NodeID dst, CopyStmt::CopyKind kind)
     {
-        if(CopyStmt *edge = pag->addCopyStmt(src, dst))
+        if(CopyStmt *edge = pag->addCopyStmt(src, dst, kind))
         {
             setCurrentBBAndValueForPAGEdge(edge);
             return edge;
         }
         return nullptr;
     }
+
+    inline CopyStmt::CopyKind getCopyKind(const Value* val)
+    {
+        // COPYVAL, ZEXT, SEXT, BITCAST, FPTRUNC, FPTOUI, FPTOSI, UITOFP, SITOFP, INTTOPTR, PTRTOINT
+        if (const Instruction* inst = SVFUtil::dyn_cast<Instruction>(val))
+        {
+            switch (inst->getOpcode())
+            {
+            case Instruction::ZExt:
+                return CopyStmt::ZEXT;
+            case Instruction::SExt:
+                return CopyStmt::SEXT;
+            case Instruction::BitCast:
+                return CopyStmt::BITCAST;
+            case Instruction ::Trunc:
+                return CopyStmt::TRUNC;
+            case Instruction::FPTrunc:
+                return CopyStmt::FPTRUNC;
+            case Instruction::FPToUI:
+                return CopyStmt::FPTOUI;
+            case Instruction::FPToSI:
+                return CopyStmt::FPTOSI;
+            case Instruction::UIToFP:
+                return CopyStmt::UITOFP;
+            case Instruction::SIToFP:
+                return CopyStmt::SITOFP;
+            case Instruction::IntToPtr:
+                return CopyStmt::INTTOPTR;
+            case Instruction::PtrToInt:
+                return CopyStmt::PTRTOINT;
+            default:
+                return CopyStmt::COPYVAL;
+            }
+        }
+        assert (false && "Unknown cast inst!");
+    }
+
     /// Add Copy edge
     inline void addPhiStmt(NodeID res, NodeID opnd, const ICFGNode* pred)
     {

package/SVF-linux/Release-build/include/SVFIR/SVFIR.h

@@ -638,7 +638,8 @@ private:
     /// Add Address edge
     AddrStmt* addAddrStmt(NodeID src, NodeID dst);
     /// Add Copy edge
-    CopyStmt* addCopyStmt(NodeID src, NodeID dst);
+    CopyStmt* addCopyStmt(NodeID src, NodeID dst, CopyStmt::CopyKind type);
+
     /// Add phi node information
     PhiStmt*  addPhiStmt(NodeID res, NodeID opnd, const ICFGNode* pred);
     /// Add SelectStmt

package/SVF-linux/Release-build/include/SVFIR/SVFStatements.h

@@ -365,13 +365,15 @@ class CopyStmt: public AssignStmt
 {
     friend class SVFIRWriter;
     friend class SVFIRReader;
-
 private:
     /// Constructs empty CopyStmt (for SVFIRReader/serialization)
     CopyStmt() : AssignStmt(SVFStmt::Copy) {}
     CopyStmt(const CopyStmt&);       ///< place holder
     void operator=(const CopyStmt&); ///< place holder
 public:
+    enum CopyKind {COPYVAL, ZEXT, SEXT, BITCAST, TRUNC, FPTRUNC,
+                   FPTOUI, FPTOSI, UITOFP, SITOFP, INTTOPTR, PTRTOINT
+                  };
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
     static inline bool classof(const CopyStmt*)
@@ -388,10 +390,18 @@ public:
     }
     //@}
 
+    /// Return the kind of the copy statement
+    inline u32_t getCopyKind() const
+    {
+        return copyKind;
+    }
+
     /// constructor
-    CopyStmt(SVFVar* s, SVFVar* d) : AssignStmt(s, d, SVFStmt::Copy) {}
+    CopyStmt(SVFVar* s, SVFVar* d, CopyKind k) : AssignStmt(s, d, SVFStmt::Copy), copyKind(k) {}
 
     virtual const std::string toString() const override;
+private:
+    u32_t copyKind;
 };
 
 /*!

package/SVF-linux/Release-build/include/Util/GeneralType.h

@@ -47,6 +47,10 @@ typedef unsigned u32_t;
 typedef signed s32_t;
 typedef unsigned long long u64_t;
 typedef signed long long s64_t;
+typedef unsigned char u8_t;
+typedef signed char s8_t;
+typedef unsigned short u16_t;
+typedef signed short s16_t;
 
 typedef u32_t NodeID;
 typedef u32_t EdgeID;

package/package.json

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