svf-tools 1.0.897 → 1.0.899

package/SVF-doxygen/html/svf_2include_2MTA_2MTAResultValidator_8h_source.html

@@ -545,7 +545,7 @@ $(function() {
 <div class="ttc" id="anamespaceSVF_html_adefcb50414ea999d70cea5ccdbcb98d7"><div class="ttname"><a href="namespaceSVF.html#adefcb50414ea999d70cea5ccdbcb98d7">SVF::ConstantInt</a></div><div class="ttdeci">llvm::ConstantInt ConstantInt</div><div class="ttdef"><b>Definition:</b> <a href="BasicTypes_8h_source.html#l00125">BasicTypes.h:125</a></div></div>
 <div class="ttc" id="aclassSVF_1_1MTAResultValidator_html_a1fc4116b134aa87420d055b193208e68"><div class="ttname"><a href="classSVF_1_1MTAResultValidator.html#a1fc4116b134aa87420d055b193208e68">SVF::MTAResultValidator::collectCallsiteTargets</a></div><div class="ttdeci">bool collectCallsiteTargets()</div><div class="ttdef"><b>Definition:</b> <a href="MTAResultValidator_8cpp_source.html#l00215">MTAResultValidator.cpp:215</a></div></div>
 <div class="ttc" id="aclassSVF_1_1MHP_html_ac30f283cb2ad020a054ee6525ca94025"><div class="ttname"><a href="classSVF_1_1MHP.html#ac30f283cb2ad020a054ee6525ca94025">SVF::MHP::ThreadStmtToThreadInterleav</a></div><div class="ttdeci">Map&lt; CxtThreadStmt, NodeBS &gt; ThreadStmtToThreadInterleav</div><div class="ttdef"><b>Definition:</b> <a href="MHP_8h_source.html#l00054">MHP.h:54</a></div></div>
-<div class="ttc" id="anamespaceSVF_html_ab700523619b089b952498f39a7f5b6b1"><div class="ttname"><a href="namespaceSVF.html#ab700523619b089b952498f39a7f5b6b1">SVF::CallStrCxt</a></div><div class="ttdeci">std::vector&lt; u32_t &gt; CallStrCxt</div><div class="ttdef"><b>Definition:</b> <a href="GeneralType_8h_source.html#l00118">GeneralType.h:118</a></div></div>
+<div class="ttc" id="anamespaceSVF_html_ab700523619b089b952498f39a7f5b6b1"><div class="ttname"><a href="namespaceSVF.html#ab700523619b089b952498f39a7f5b6b1">SVF::CallStrCxt</a></div><div class="ttdeci">std::vector&lt; u32_t &gt; CallStrCxt</div><div class="ttdef"><b>Definition:</b> <a href="GeneralType_8h_source.html#l00122">GeneralType.h:122</a></div></div>
 <div class="ttc" id="aclassSVF_1_1SVFModule_html"><div class="ttname"><a href="classSVF_1_1SVFModule.html">SVF::SVFModule</a></div><div class="ttdef"><b>Definition:</b> <a href="SVFModule_8h_source.html#l00040">SVFModule.h:40</a></div></div>
 <div class="ttc" id="aclassSVF_1_1MTAResultValidator_html_a7382b2759b01b8382c5e59b21e7e262a"><div class="ttname"><a href="classSVF_1_1MTAResultValidator.html#a7382b2759b01b8382c5e59b21e7e262a">SVF::MTAResultValidator::vthdTorthd</a></div><div class="ttdeci">vthdTorthdMap vthdTorthd</div><div class="ttdef"><b>Definition:</b> <a href="svf-llvm_2tools_2MTA_2MTAResultValidator_8h_source.html#l00139">MTAResultValidator.h:139</a></div></div>
 <div class="ttc" id="anamespaceSVF_1_1SVFUtil_html_aed0b0b9f035057552a6a82154fd88e61"><div class="ttname"><a href="namespaceSVF_1_1SVFUtil.html#aed0b0b9f035057552a6a82154fd88e61">SVF::SVFUtil::outs</a></div><div class="ttdeci">std::ostream &amp; outs()</div><div class="ttdoc">Overwrite llvm::outs()</div><div class="ttdef"><b>Definition:</b> <a href="SVFUtil_8h_source.html#l00050">SVFUtil.h:50</a></div></div>
@@ -563,7 +563,7 @@ $(function() {
 <div class="ttc" id="aclassSVF_1_1MTAResultValidator_html_ab3ba3c6d9c40e97febdab0e7d4ad9a3e"><div class="ttname"><a href="classSVF_1_1MTAResultValidator.html#ab3ba3c6d9c40e97febdab0e7d4ad9a3e">SVF::MTAResultValidator::getPreviousMemoryAccessInst</a></div><div class="ttdeci">const Instruction * getPreviousMemoryAccessInst(const Instruction *I)</div><div class="ttdef"><b>Definition:</b> <a href="MTAResultValidator_8cpp_source.html#l00137">MTAResultValidator.cpp:137</a></div></div>
 <div class="ttc" id="aclassSVF_1_1MTAResultValidator_html_afa01b108b67ec2ac05a6444b55dbfe01"><div class="ttname"><a href="classSVF_1_1MTAResultValidator.html#afa01b108b67ec2ac05a6444b55dbfe01">SVF::MTAResultValidator::validateCxtThread</a></div><div class="ttdeci">bool validateCxtThread()</div><div class="ttdef"><b>Definition:</b> <a href="MTAResultValidator_8cpp_source.html#l00372">MTAResultValidator.cpp:372</a></div></div>
 <div class="ttc" id="aclassSVF_1_1RaceResultValidator_1_1AccessPair_html_a7dd2f8afab59ee4d107a6bfdb6c151ea"><div class="ttname"><a href="classSVF_1_1RaceResultValidator_1_1AccessPair.html#a7dd2f8afab59ee4d107a6bfdb6c151ea">SVF::RaceResultValidator::AccessPair::AccessPair</a></div><div class="ttdeci">AccessPair(const Instruction *I1, const Instruction *I2, const RC_FLAG flags)</div><div class="ttdoc">Constructor.</div><div class="ttdef"><b>Definition:</b> <a href="svf_2include_2MTA_2MTAResultValidator_8h_source.html#l00180">MTAResultValidator.h:180</a></div></div>
-<div class="ttc" id="aclassSVF_1_1LLVMModuleSet_html_afdd77bc1fca91f70b2ec362f1dacd392"><div class="ttname"><a href="classSVF_1_1LLVMModuleSet.html#afdd77bc1fca91f70b2ec362f1dacd392">SVF::LLVMModuleSet::getSVFValue</a></div><div class="ttdeci">SVFValue * getSVFValue(const Value *value)</div><div class="ttdef"><b>Definition:</b> <a href="LLVMModule_8cpp_source.html#l01321">LLVMModule.cpp:1321</a></div></div>
+<div class="ttc" id="aclassSVF_1_1LLVMModuleSet_html_afdd77bc1fca91f70b2ec362f1dacd392"><div class="ttname"><a href="classSVF_1_1LLVMModuleSet.html#afdd77bc1fca91f70b2ec362f1dacd392">SVF::LLVMModuleSet::getSVFValue</a></div><div class="ttdeci">SVFValue * getSVFValue(const Value *value)</div><div class="ttdef"><b>Definition:</b> <a href="LLVMModule_8cpp_source.html#l01340">LLVMModule.cpp:1340</a></div></div>
 <div class="ttc" id="aclassSVF_1_1MTAResultValidator_html_aecaf875c6c88f7ba6fa45540e8436f57"><div class="ttname"><a href="classSVF_1_1MTAResultValidator.html#aecaf875c6c88f7ba6fa45540e8436f57">SVF::MTAResultValidator::getModule</a></div><div class="ttdeci">SVFModule * getModule() const</div><div class="ttdef"><b>Definition:</b> <a href="svf_2include_2MTA_2MTAResultValidator_8h_source.html#l00040">MTAResultValidator.h:40</a></div></div>
 <div class="ttc" id="aclassSVF_1_1MTAResultValidator_html_a5a0f25f5718d84f251331a2e2d207108"><div class="ttname"><a href="classSVF_1_1MTAResultValidator.html#a5a0f25f5718d84f251331a2e2d207108">SVF::MTAResultValidator::mod</a></div><div class="ttdeci">SVFModule * mod</div><div class="ttdef"><b>Definition:</b> <a href="svf-llvm_2tools_2MTA_2MTAResultValidator_8h_source.html#l00143">MTAResultValidator.h:143</a></div></div>
 <div class="ttc" id="anamespaceSVF_html_a43a65e0d33af3c743294f7a1139d2301"><div class="ttname"><a href="namespaceSVF.html#a43a65e0d33af3c743294f7a1139d2301">SVF::NodeID</a></div><div class="ttdeci">unsigned NodeID</div><div class="ttdef"><b>Definition:</b> <a href="svf-llvm_2tools_2MTA_2MTAResultValidator_8h_source.html#l00020">MTAResultValidator.h:20</a></div></div>
@@ -574,7 +574,7 @@ $(function() {
 <div class="ttc" id="aclassSVF_1_1SVFInstruction_html"><div class="ttname"><a href="classSVF_1_1SVFInstruction.html">SVF::SVFInstruction</a></div><div class="ttdef"><b>Definition:</b> <a href="SVFValue_8h_source.html#l00631">SVFValue.h:631</a></div></div>
 <div class="ttc" id="aclassSVF_1_1MTAResultValidator_html_a8e26b7fe85478eef7b3d0551ab59d9c7"><div class="ttname"><a href="classSVF_1_1MTAResultValidator.html#a8e26b7fe85478eef7b3d0551ab59d9c7">SVF::MTAResultValidator::INTERLEV_FLAG</a></div><div class="ttdeci">int INTERLEV_FLAG</div><div class="ttdef"><b>Definition:</b> <a href="svf_2include_2MTA_2MTAResultValidator_8h_source.html#l00025">MTAResultValidator.h:25</a></div></div>
 <div class="ttc" id="aclassSVF_1_1MTAResultValidator_html_a9c9baeb57a645b57cc9053b3071f0602"><div class="ttname"><a href="classSVF_1_1MTAResultValidator.html#a9c9baeb57a645b57cc9053b3071f0602">SVF::MTAResultValidator::getOutput</a></div><div class="ttdeci">std::string getOutput(const char *scenario, bool analysisRes)</div><div class="ttdef"><b>Definition:</b> <a href="MTAResultValidator_8cpp_source.html#l00149">MTAResultValidator.cpp:149</a></div></div>
-<div class="ttc" id="anamespaceSVF_html_a8234d4b959abc9123993bcff4eee34c1"><div class="ttname"><a href="namespaceSVF.html#a8234d4b959abc9123993bcff4eee34c1">SVF::Map</a></div><div class="ttdeci">std::unordered_map&lt; Key, Value, Hash, KeyEqual, Allocator &gt; Map</div><div class="ttdef"><b>Definition:</b> <a href="GeneralType_8h_source.html#l00097">GeneralType.h:97</a></div></div>
+<div class="ttc" id="anamespaceSVF_html_a8234d4b959abc9123993bcff4eee34c1"><div class="ttname"><a href="namespaceSVF.html#a8234d4b959abc9123993bcff4eee34c1">SVF::Map</a></div><div class="ttdeci">std::unordered_map&lt; Key, Value, Hash, KeyEqual, Allocator &gt; Map</div><div class="ttdef"><b>Definition:</b> <a href="GeneralType_8h_source.html#l00101">GeneralType.h:101</a></div></div>
 <div class="ttc" id="aclassSVF_1_1RaceResultValidator_html_a90f7d527816acf808e3e54c2a4ed0532"><div class="ttname"><a href="classSVF_1_1RaceResultValidator.html#a90f7d527816acf808e3e54c2a4ed0532">SVF::RaceResultValidator::accessPairs</a></div><div class="ttdeci">std::vector&lt; AccessPair &gt; accessPairs</div><div class="ttdef"><b>Definition:</b> <a href="svf-llvm_2tools_2MTA_2MTAResultValidator_8h_source.html#l00299">MTAResultValidator.h:299</a></div></div>
 <div class="ttc" id="aclassSVF_1_1SVFValue_html_a7effb0f37f486745e0cdc3ae5e9c732b"><div class="ttname"><a href="classSVF_1_1SVFValue.html#a7effb0f37f486745e0cdc3ae5e9c732b">SVF::SVFValue::getSourceLoc</a></div><div class="ttdeci">virtual const std::string getSourceLoc() const</div><div class="ttdef"><b>Definition:</b> <a href="SVFValue_8h_source.html#l00280">SVFValue.h:280</a></div></div>
 <div class="ttc" id="aclassSVF_1_1MTAResultValidator_html_a0e2fb93a69df487606c0eeaeadab805d"><div class="ttname"><a href="classSVF_1_1MTAResultValidator.html#a0e2fb93a69df487606c0eeaeadab805d">SVF::MTAResultValidator::INTERLEV_UNSOUND</a></div><div class="ttdeci">static const INTERLEV_FLAG INTERLEV_UNSOUND</div><div class="ttdef"><b>Definition:</b> <a href="svf-llvm_2tools_2MTA_2MTAResultValidator_8h_source.html#l00148">MTAResultValidator.h:148</a></div></div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.897",
+  "version": "1.0.899",
   "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/BoundedZ3Expr.h

@@ -53,6 +53,8 @@ public:
 
     BoundedZ3Expr(s64_t i) : Z3Expr(getContext().int_val((int64_t)i)) {}
 
+    BoundedZ3Expr(double i) : Z3Expr(getContext().real_val(std::to_string(i).c_str())) {}
+
     BoundedZ3Expr(const BoundedZ3Expr &z3Expr) : Z3Expr(z3Expr) {}
 
     inline BoundedZ3Expr &operator=(const BoundedZ3Expr &rhs)
@@ -345,31 +347,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/include/AE/Core/IntervalValue.h

@@ -101,7 +101,7 @@ public:
 
     explicit IntervalValue(u32_t n) : IntervalValue((s64_t) n) {}
 
-    explicit IntervalValue(double n) : IntervalValue((s64_t) n) {}
+    explicit IntervalValue(double n) : AbstractValue(AbstractValue::IntervalK), _lb(n), _ub(n) {}
 
     explicit IntervalValue(NumericLiteral n) : IntervalValue(n, n) {}
 
@@ -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/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,38 @@ 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();
     }
 
+    /// Return Expr
+    inline Z3Expr getExpr() const
+    {
+        return _n.getExpr();
+    }
+
+    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/include/AE/Core/RelationSolver.h

@@ -54,7 +54,7 @@ public:
 
     IntervalESBase abstract_consequence(const IntervalESBase &lower, const IntervalESBase &upper, const IntervalESBase &domain) const;
 
-    IntervalESBase beta(const Map<u32_t, double> &sigma, const IntervalESBase &exeState) const;
+    IntervalESBase beta(const Map<u32_t, s32_t> &sigma, const IntervalESBase &exeState) const;
 
 
     /// Return Z3 expression lazily based on SVFVar ID

package/svf/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/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/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/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/svf/include/Util/Options.h

@@ -274,6 +274,9 @@ public:
     static const Option<bool> RunUncallFuncs;
 
     static const Option<bool> ICFGMergeAdjacentNodes;
+
+    // float precision for symbolic abstraction
+    static const Option<u32_t> AEPrecision;
 };
 }  // namespace SVF
 

package/svf/include/Util/Z3Expr.h

@@ -44,8 +44,7 @@ public:
 private:
     z3::expr e;
 
-    Z3Expr(float f); // placeholder don't support floating point expression
-    Z3Expr(double f); // placeholder don't support floating point expression
+
 
 public:
 
@@ -65,6 +64,14 @@ public:
     {
     }
 
+    Z3Expr(float f) : Z3Expr((double) f)
+    {
+    }
+
+    Z3Expr(double f): e(getContext().real_val(std::to_string(f).c_str()))
+    {
+    }
+
     virtual ~Z3Expr() = default;
 
     inline Z3Expr &operator=(const Z3Expr &rhs)

package/svf/lib/AE/Core/RelationSolver.cpp

@@ -27,6 +27,9 @@
  *
  */
 #include "AE/Core/RelationSolver.h"
+#include <cmath>
+#include "Util/Options.h"
+
 using namespace SVF;
 using namespace SVFUtil;
 
@@ -59,7 +62,7 @@ IntervalESBase RelationSolver::bilateral(const IntervalESBase &domain, const Z3E
         Z3Expr rhs = !(gamma_hat(consequence, domain));
         solver.push();
         solver.add(phi.getExpr() && rhs.getExpr());
-        Map<u32_t, double> solution;
+        Map<u32_t, s32_t> solution;
         z3::check_result checkRes = solver.check();
         /// find any solution, which is sat
         if (checkRes == z3::sat)
@@ -121,7 +124,7 @@ IntervalESBase RelationSolver::RSY(const IntervalESBase& domain, const Z3Expr& p
         Z3Expr rhs = !(gamma_hat(lower, domain));
         solver.push();
         solver.add(phi.getExpr() && rhs.getExpr());
-        Map<u32_t, double> solution;
+        Map<u32_t, s32_t> solution;
         z3::check_result checkRes = solver.check();
         /// find any solution, which is sat
         if (checkRes == z3::sat)
@@ -238,7 +241,7 @@ Z3Expr RelationSolver::gamma_hat(u32_t id, const IntervalESBase& exeState) const
     return res;
 }
 
-IntervalESBase RelationSolver::beta(const Map<u32_t, double>& sigma,
+IntervalESBase RelationSolver::beta(const Map<u32_t, s32_t>& sigma,
                                     const IntervalESBase& exeState) const
 {
     IntervalESBase res;
@@ -268,7 +271,9 @@ IntervalESBase RelationSolver::BS(const IntervalESBase& domain, const Z3Expr &ph
     /// because key of _varToItvVal is u32_t, -key may out of range for int
     /// so we do key + bias for -key
     u32_t bias = 0;
-    int infinity = (INT32_MAX) - 1;
+    s32_t infinity = INT32_MAX - 1;
+
+    // int infinity = (INT32_MAX) - 1;
     // int infinity = 20;
     Map<u32_t, NumericLiteral> ret;
     Map<u32_t, NumericLiteral> low_values, high_values;
@@ -343,7 +348,7 @@ Map<u32_t, NumericLiteral> RelationSolver::BoxedOptSolver(const Z3Expr& phi, Map
             {
                 NumericLiteral mid = (low_values.at(item.first) + (high_values.at(item.first) - low_values.at(item.first)) / 2);
                 updateMap(mid_values, item.first, mid);
-                Z3Expr expr = ((int)mid.getNumeral() <= v && v <= (int)high_values.at(item.first).getNumeral());
+                Z3Expr expr = (mid.getExpr() <= v && v <= high_values.at(item.first).getExpr());
                 L_phi[item.first] = expr;
             }
         }
@@ -399,7 +404,7 @@ void RelationSolver::decide_cpa_ext(const Z3Expr& phi,
                     updateMap(mid_values, id, mid);
                     Z3Expr v = toZ3Expr(id);
                     // Z3Expr v = Z3Expr::getContext().int_const(std::to_string(id).c_str());
-                    Z3Expr expr = ((int)mid_values.at(id).getNumeral() <= v && v <= (int)high_values.at(id).getNumeral());
+                    Z3Expr expr = (mid_values.at(id).getExpr() <= v && v <= high_values.at(id).getExpr());
                     L_phi[id] = expr;
                 }
                 solver.pop();

package/svf/lib/AE/Svfexe/AbstractExecution.cpp

@@ -168,28 +168,7 @@ void AbstractExecution::handleGlobalNode()
     // Global Node, we just need to handle addr, load, store, copy and gep
     for (const SVFStmt *stmt: node->getSVFStmts())
     {
-        if (const AddrStmt *addr = SVFUtil::dyn_cast<AddrStmt>(stmt))
-        {
-            _svfir2ExeState->translateAddr(addr);
-        }
-        else if (const LoadStmt *load = SVFUtil::dyn_cast<LoadStmt>(stmt))
-        {
-            _svfir2ExeState->translateLoad(load);
-        }
-        else if (const StoreStmt *store = SVFUtil::dyn_cast<StoreStmt>(stmt))
-        {
-            _svfir2ExeState->translateStore(store);
-        }
-        else if (const CopyStmt *copy = SVFUtil::dyn_cast<CopyStmt>(stmt))
-        {
-            _svfir2ExeState->translateCopy(copy);
-        }
-        else if (const GepStmt *gep = SVFUtil::dyn_cast<GepStmt>(stmt))
-        {
-            _svfir2ExeState->translateGep(gep);
-        }
-        else
-            assert(false && "implement this part");
+        handleSVFStatement(stmt);
     }
     // for stmts in global node, exe state will move to global state to lower memory usage
     _svfir2ExeState->moveToGlobal();
@@ -341,7 +320,7 @@ bool AbstractExecution::hasCmpBranchES(const CmpStmt* cmpStmt, s64_t succ, Inter
     // for const X const, we may get concrete resVal instantly
     // for var X const, we may get [0,1] if the intersection of var and const is not empty set
     IntervalValue resVal = new_es[res_id];
-    resVal.meet_with(IntervalValue((int64_t) succ, succ));
+    resVal.meet_with(IntervalValue((s64_t) succ, succ));
     // If Var X const generates bottom value, it means this branch path is not feasible.
     if (resVal.isBottom())
     {
@@ -1139,7 +1118,7 @@ void AbstractExecution::initExtFunMap()
         IntervalExeState &es = _svfir2ExeState->getEs(); \
         u32_t rhs_id = _svfir->getValueNode(cs.getArgument(0)); \
         if (!es.inVarToValTable(rhs_id)) return; \
-        u32_t rhs = _svfir2ExeState->getEs()[rhs_id].lb().getNumeral(); \
+        u32_t rhs = _svfir2ExeState->getEs()[rhs_id].lb().getIntNumeral(); \
         s32_t res = FUNC_NAME(rhs);            \
         u32_t lhsId = _svfir->getValueNode(cs.getInstruction()); \
         _svfir2ExeState->getEs()[lhsId] = IntervalValue(res);           \
@@ -1223,11 +1202,11 @@ std::string AbstractExecution::strRead(const SVFValue* rhs)
         {
             break;
         }
-        if ((char) val.getNumeral() == '\0')
+        if ((char) val.getIntNumeral() == '\0')
         {
             break;
         }
-        str0.push_back((char) val.getNumeral());
+        str0.push_back((char) val.getIntNumeral());
     }
     return str0;
 }
@@ -1345,7 +1324,7 @@ void AbstractExecution::handleStrcpy(const CallICFGNode *call)
     const SVFValue* arg1Val = cs.getArgument(1);
     IntervalValue strLen = getStrlen(arg1Val);
     // no need to -1, since it has \0 as the last byte
-    handleMemcpy(arg0Val, arg1Val, strLen,strLen.lb().getNumeral());
+    handleMemcpy(arg0Val, arg1Val, strLen,strLen.lb().getIntNumeral());
 }
 
 u32_t AbstractExecution::getAllocaInstByteSize(const AddrStmt *addr)
@@ -1372,7 +1351,7 @@ u32_t AbstractExecution::getAllocaInstByteSize(const AddrStmt *addr)
                     _svfir2ExeState->getEs()[_svfir->getValueNode(value)] = IntervalValue(Options::MaxFieldLimit());
                 }
                 IntervalValue itv = _svfir2ExeState->getEs()[_svfir->getValueNode(value)];
-                res = res * itv.ub().getNumeral() > Options::MaxFieldLimit()? Options::MaxFieldLimit(): res * itv.ub().getNumeral();
+                res = res * itv.ub().getIntNumeral() > Options::MaxFieldLimit()? Options::MaxFieldLimit(): res * itv.ub().getIntNumeral();
             }
             return (u32_t)res;
         }
@@ -1522,7 +1501,7 @@ IntervalValue AbstractExecution::getStrlen(const SVF::SVFValue *strValue)
     u32_t elemSize = 1;
     if (_svfir2ExeState->inVarToAddrsTable(dstid))
     {
-        for (u32_t index = 0; index < dst_size.lb().getNumeral(); index++)
+        for (u32_t index = 0; index < dst_size.lb().getIntNumeral(); index++)
         {
             ExeState::Addrs expr0 = _svfir2ExeState->getGepObjAddress(dstid, index);
             IntervalValue val = IntervalValue::bottom();
@@ -1530,7 +1509,7 @@ IntervalValue AbstractExecution::getStrlen(const SVF::SVFValue *strValue)
             {
                 val.join_with(es.load(addr));
             }
-            if (val.is_numeral() && (char) val.getNumeral() == '\0')
+            if (val.is_numeral() && (char) val.getIntNumeral() == '\0')
             {
                 break;
             }
@@ -1582,7 +1561,7 @@ void AbstractExecution::handleStrcat(const SVF::CallICFGNode *call)
         IntervalValue strLen0 = getStrlen(arg0Val);
         IntervalValue strLen1 = getStrlen(arg1Val);
         IntervalValue totalLen = strLen0 + strLen1;
-        handleMemcpy(arg0Val, arg1Val, strLen1, strLen0.lb().getNumeral());
+        handleMemcpy(arg0Val, arg1Val, strLen1, strLen0.lb().getIntNumeral());
         // do memcpy
     }
     else if (std::find(strncatGroup.begin(), strncatGroup.end(), fun->getName()) != strncatGroup.end())
@@ -1594,7 +1573,7 @@ void AbstractExecution::handleStrcat(const SVF::CallICFGNode *call)
         IntervalValue arg2Num = _svfir2ExeState->getEs()[_svfir->getValueNode(arg2Val)];
         IntervalValue strLen0 = getStrlen(arg0Val);
         IntervalValue totalLen = strLen0 + arg2Num;
-        handleMemcpy(arg0Val, arg1Val, arg2Num, strLen0.lb().getNumeral());
+        handleMemcpy(arg0Val, arg1Val, arg2Num, strLen0.lb().getIntNumeral());
         // do memcpy
     }
     else
@@ -1632,7 +1611,7 @@ void AbstractExecution::handleMemcpy(const SVF::SVFValue *dst, const SVF::SVFVal
     {
         assert(false && "we cannot support this type");
     }
-    u32_t size = std::min((u32_t)Options::MaxFieldLimit(), (u32_t) len.lb().getNumeral());
+    u32_t size = std::min((u32_t)Options::MaxFieldLimit(), (u32_t) len.lb().getIntNumeral());
     u32_t range_val = size / elemSize;
     if (_svfir2ExeState->inVarToAddrsTable(srcId) && _svfir2ExeState->inVarToAddrsTable(dstId))
     {
@@ -1681,7 +1660,7 @@ void AbstractExecution::handleMemset(const SVF::SVFValue *dst, SVF::IntervalValu
 {
     IntervalExeState &es = _svfir2ExeState->getEs();
     u32_t dstId = _svfir->getValueNode(dst);
-    u32_t size = std::min((u32_t)Options::MaxFieldLimit(), (u32_t) len.lb().getNumeral());
+    u32_t size = std::min((u32_t)Options::MaxFieldLimit(), (u32_t) len.lb().getIntNumeral());
     u32_t elemSize = 1;
     if (dst->getType()->isArrayTy())
     {

package/svf/lib/AE/Svfexe/BufOverflowChecker.cpp

@@ -42,17 +42,17 @@ std::string IntervalToIntStr(const IntervalValue& inv)
     }
     else
     {
-        int64_t lb_val = inv.lb().getNumeral();
-        int64_t ub_val = inv.ub().getNumeral();
+        s64_t lb_val = inv.lb().getNumeral();
+        s64_t ub_val = inv.ub().getNumeral();
 
         // check lb
-        s32_t lb_s32 = (lb_val < static_cast<int64_t>(INT_MIN)) ? INT_MIN :
-                       (lb_val > static_cast<int64_t>(INT_MAX)) ? INT_MAX :
+        s32_t lb_s32 = (lb_val < static_cast<s64_t>(INT_MIN)) ? INT_MIN :
+                       (lb_val > static_cast<s64_t>(INT_MAX)) ? INT_MAX :
                        static_cast<s32_t>(lb_val);
 
         // check ub
-        s32_t ub_s32 = (ub_val < static_cast<int64_t>(INT_MIN)) ? INT_MIN :
-                       (ub_val > static_cast<int64_t>(INT_MAX)) ? INT_MAX :
+        s32_t ub_s32 = (ub_val < static_cast<s64_t>(INT_MIN)) ? INT_MIN :
+                       (ub_val > static_cast<s64_t>(INT_MAX)) ? INT_MAX :
                        static_cast<s32_t>(ub_val);
 
         return "[" + std::to_string(lb_s32) + ", " + std::to_string(ub_s32) + "]";