svf-tools 1.0.849 → 1.0.850

package/svf/lib/AbstractExecution/IntervalExeState.cpp

@@ -33,13 +33,12 @@
 using namespace SVF;
 using namespace SVFUtil;
 
-IntervalExeState IntervalExeState::globalES;
-bool IntervalExeState::equals(const IntervalExeState &other) const
+bool IntervalESBase::equals(const IntervalESBase &other) const
 {
     return *this == other;
 }
 
-u32_t IntervalExeState::hash() const
+u32_t IntervalESBase::hash() const
 {
     size_t h = getVarToVal().size() * 2;
     Hash<u32_t> hf;
@@ -56,9 +55,9 @@ u32_t IntervalExeState::hash() const
     return pairH(std::make_pair(std::make_pair(h, h2), (u32_t) ExeState::hash()));
 }
 
-IntervalExeState IntervalExeState::widening(const IntervalExeState& other)
+IntervalESBase IntervalESBase::widening(const IntervalESBase& other)
 {
-    IntervalExeState es = *this;
+    IntervalESBase es = *this;
     for (auto it = es._varToItvVal.begin(); it != es._varToItvVal.end(); ++it)
     {
         auto key = it->first;
@@ -74,9 +73,9 @@ IntervalExeState IntervalExeState::widening(const IntervalExeState& other)
     return es;
 }
 
-IntervalExeState IntervalExeState::narrowing(const IntervalExeState& other)
+IntervalESBase IntervalESBase::narrowing(const IntervalESBase& other)
 {
-    IntervalExeState es = *this;
+    IntervalESBase es = *this;
     for (auto it = es._varToItvVal.begin(); it != es._varToItvVal.end(); ++it)
     {
         auto key = it->first;
@@ -94,7 +93,7 @@ IntervalExeState IntervalExeState::narrowing(const IntervalExeState& other)
 }
 
 /// domain widen with other, important! other widen this.
-void IntervalExeState::widenWith(const IntervalExeState& other)
+void IntervalESBase::widenWith(const IntervalESBase& other)
 {
     for (auto it = _varToItvVal.begin(); it != _varToItvVal.end(); ++it)
     {
@@ -111,7 +110,7 @@ void IntervalExeState::widenWith(const IntervalExeState& other)
 }
 
 /// domain join with other, important! other widen this.
-void IntervalExeState::joinWith(const IntervalExeState& other)
+void IntervalESBase::joinWith(const IntervalESBase& other)
 {
     ExeState::joinWith(other);
     for (auto it = other._varToItvVal.begin(); it != other._varToItvVal.end(); ++it)
@@ -143,7 +142,7 @@ void IntervalExeState::joinWith(const IntervalExeState& other)
 }
 
 /// domain narrow with other, important! other widen this.
-void IntervalExeState::narrowWith(const IntervalExeState& other)
+void IntervalESBase::narrowWith(const IntervalESBase& other)
 {
     for (auto it = _varToItvVal.begin(); it != _varToItvVal.end(); ++it)
     {
@@ -162,7 +161,7 @@ void IntervalExeState::narrowWith(const IntervalExeState& other)
 }
 
 /// domain meet with other, important! other widen this.
-void IntervalExeState::meetWith(const IntervalExeState& other)
+void IntervalESBase::meetWith(const IntervalESBase& other)
 {
     ExeState::meetWith(other);
     for (auto it = other._varToItvVal.begin(); it != other._varToItvVal.end(); ++it)
@@ -186,7 +185,7 @@ void IntervalExeState::meetWith(const IntervalExeState& other)
 }
 
 /// Print values of all expressions
-void IntervalExeState::printExprValues(std::ostream &oss) const
+void IntervalESBase::printExprValues(std::ostream &oss) const
 {
     oss << "-----------Var and Value-----------\n";
     printTable(_varToItvVal, oss);
@@ -196,7 +195,7 @@ void IntervalExeState::printExprValues(std::ostream &oss) const
     oss << "-----------------------------------------\n";
 }
 
-void IntervalExeState::printTable(const VarToValMap &table, std::ostream &oss) const
+void IntervalESBase::printTable(const VarToValMap &table, std::ostream &oss) const
 {
     oss.flags(std::ios::left);
     std::set<NodeID> ordered;
@@ -219,7 +218,7 @@ void IntervalExeState::printTable(const VarToValMap &table, std::ostream &oss) c
     }
 }
 
-void IntervalExeState::printTable(const VarToAddrs &table, std::ostream &oss) const
+void IntervalESBase::printTable(const VarToAddrs &table, std::ostream &oss) const
 {
     oss.flags(std::ios::left);
     std::set<NodeID> ordered;
@@ -239,3 +238,75 @@ void IntervalExeState::printTable(const VarToAddrs &table, std::ostream &oss) co
         oss << "]\n";
     }
 }
+
+IntervalExeState IntervalExeState::globalES;
+bool IntervalExeState::equals(const IntervalExeState &other) const
+{
+    return *this == other;
+}
+
+u32_t IntervalExeState::hash() const
+{
+    return IntervalESBase::hash();
+}
+
+IntervalExeState IntervalExeState::widening(const IntervalExeState& other)
+{
+    IntervalExeState es = *this;
+    for (auto it = es._varToItvVal.begin(); it != es._varToItvVal.end(); ++it)
+    {
+        auto key = it->first;
+        if (other._varToItvVal.find(key) != other._varToItvVal.end())
+            it->second.widen_with(other._varToItvVal.at(key));
+    }
+    for (auto it = es._locToItvVal.begin(); it != es._locToItvVal.end(); ++it)
+    {
+        auto key = it->first;
+        if (other._locToItvVal.find(key) != other._locToItvVal.end())
+            it->second.widen_with(other._locToItvVal.at(key));
+    }
+    return es;
+}
+
+IntervalExeState IntervalExeState::narrowing(const IntervalExeState& other)
+{
+    IntervalExeState es = *this;
+    for (auto it = es._varToItvVal.begin(); it != es._varToItvVal.end(); ++it)
+    {
+        auto key = it->first;
+        if (other._varToItvVal.find(key) != other._varToItvVal.end())
+            it->second.narrow_with(other._varToItvVal.at(key));
+    }
+    for (auto it = es._locToItvVal.begin(); it != es._locToItvVal.end(); ++it)
+    {
+        auto key = it->first;
+        if (other._locToItvVal.find(key) != other._locToItvVal.end())
+            it->second.narrow_with(other._locToItvVal.at(key));
+    }
+    return es;
+
+}
+
+/// domain widen with other, important! other widen this.
+void IntervalExeState::widenWith(const IntervalExeState& other)
+{
+    IntervalESBase::widenWith(other);
+}
+
+/// domain join with other, important! other widen this.
+void IntervalExeState::joinWith(const IntervalExeState& other)
+{
+    IntervalESBase::joinWith(other);
+}
+
+/// domain narrow with other, important! other widen this.
+void IntervalExeState::narrowWith(const IntervalExeState& other)
+{
+    IntervalESBase::narrowWith(other);
+}
+
+/// domain meet with other, important! other widen this.
+void IntervalExeState::meetWith(const IntervalExeState& other)
+{
+    IntervalESBase::meetWith(other);
+}

package/svf/lib/AbstractExecution/RelationSolver.cpp

@@ -30,19 +30,19 @@
 using namespace SVF;
 using namespace SVFUtil;
 
-IntervalExeState RelationSolver::bilateral(const IntervalExeState &domain, const Z3Expr& phi,
+IntervalESBase RelationSolver::bilateral(const IntervalESBase &domain, const Z3Expr& phi,
         u32_t descend_check)
 {
     /// init variables
-    IntervalExeState upper = domain.top();
-    IntervalExeState lower = domain.bottom();
+    IntervalESBase upper = domain.top();
+    IntervalESBase lower = domain.bottom();
     u32_t meets_in_a_row = 0;
     z3::solver solver = Z3Expr::getSolver();
     z3::params p(Z3Expr::getContext());
     /// TODO: add option for timeout
     p.set(":timeout", static_cast<unsigned>(600)); // in milliseconds
     solver.set(p);
-    IntervalExeState consequence;
+    IntervalESBase consequence;
 
     /// start processing
     while (lower != upper)
@@ -82,9 +82,9 @@ IntervalExeState RelationSolver::bilateral(const IntervalExeState &domain, const
                 }
             }
             solver.pop();
-            IntervalExeState newLower = domain.bottom();
+            IntervalESBase newLower = domain.bottom();
             newLower.joinWith(lower);
-            IntervalExeState rhs = beta(solution, domain);
+            IntervalESBase rhs = beta(solution, domain);
             newLower.joinWith(rhs);
             lower = newLower;
             meets_in_a_row = 0;
@@ -98,7 +98,7 @@ IntervalExeState RelationSolver::bilateral(const IntervalExeState &domain, const
                 if (solver.reason_unknown() == "timeout")
                     return upper;
             }
-            IntervalExeState newUpper = domain.top();
+            IntervalESBase newUpper = domain.top();
             newUpper.meetWith(upper);
             newUpper.meetWith(consequence);
             upper = newUpper;
@@ -108,9 +108,9 @@ IntervalExeState RelationSolver::bilateral(const IntervalExeState &domain, const
     return upper;
 }
 
-IntervalExeState RelationSolver::RSY(const IntervalExeState& domain, const Z3Expr& phi)
+IntervalESBase RelationSolver::RSY(const IntervalESBase& domain, const Z3Expr& phi)
 {
-    IntervalExeState lower = domain.bottom();
+    IntervalESBase lower = domain.bottom();
     z3::solver& solver = Z3Expr::getSolver();
     z3::params p(Z3Expr::getContext());
     /// TODO: add option for timeout
@@ -144,7 +144,7 @@ IntervalExeState RelationSolver::RSY(const IntervalExeState& domain, const Z3Exp
                 }
             }
             solver.pop();
-            IntervalExeState newLower = domain.bottom();
+            IntervalESBase newLower = domain.bottom();
             newLower.joinWith(lower);
             newLower.joinWith(beta(solution, domain));
             lower = newLower;
@@ -164,8 +164,8 @@ IntervalExeState RelationSolver::RSY(const IntervalExeState& domain, const Z3Exp
     return lower;
 }
 
-IntervalExeState RelationSolver::abstract_consequence(
-    const IntervalExeState& lower, const IntervalExeState& upper, const IntervalExeState& domain) const
+IntervalESBase RelationSolver::abstract_consequence(
+    const IntervalESBase& lower, const IntervalESBase& upper, const IntervalESBase& domain) const
 {
     /*Returns the "abstract consequence" of lower and upper.
 
@@ -181,7 +181,7 @@ IntervalExeState RelationSolver::abstract_consequence(
             it != domain.getVarToVal().end(); ++it)
         /// for variable in self.variables:
     {
-        IntervalExeState proposed = domain.top(); /// proposed = self.top.copy()
+        IntervalESBase proposed = domain.top(); /// proposed = self.top.copy()
         proposed._varToItvVal[it->first] = lower._varToItvVal.at(it->first);
         /// proposed.set_interval(variable, lower.interval_of(variable))
         /// proposed._locToItvVal
@@ -193,7 +193,7 @@ IntervalExeState RelationSolver::abstract_consequence(
     return lower; /// return lower.copy()
 }
 
-Z3Expr RelationSolver::gamma_hat(const IntervalExeState& exeState) const
+Z3Expr RelationSolver::gamma_hat(const IntervalESBase& exeState) const
 {
     Z3Expr res(Z3Expr::getContext().bool_val(true));
     for (auto& item : exeState.getVarToVal())
@@ -209,8 +209,8 @@ Z3Expr RelationSolver::gamma_hat(const IntervalExeState& exeState) const
     return res;
 }
 
-Z3Expr RelationSolver::gamma_hat(const IntervalExeState& alpha,
-                                 const IntervalExeState& exeState) const
+Z3Expr RelationSolver::gamma_hat(const IntervalESBase& alpha,
+                                 const IntervalESBase& exeState) const
 {
     Z3Expr res(Z3Expr::getContext().bool_val(true));
     for (auto& item : exeState.getVarToVal())
@@ -227,7 +227,7 @@ Z3Expr RelationSolver::gamma_hat(const IntervalExeState& alpha,
     return res;
 }
 
-Z3Expr RelationSolver::gamma_hat(u32_t id, const IntervalExeState& exeState) const
+Z3Expr RelationSolver::gamma_hat(u32_t id, const IntervalESBase& exeState) const
 {
     auto it = exeState.getVarToVal().find(id);
     assert(it != exeState.getVarToVal().end() && "id not in varToVal?");
@@ -238,10 +238,10 @@ Z3Expr RelationSolver::gamma_hat(u32_t id, const IntervalExeState& exeState) con
     return res;
 }
 
-IntervalExeState RelationSolver::beta(const Map<u32_t, double>& sigma,
-                                      const IntervalExeState& exeState) const
+IntervalESBase RelationSolver::beta(const Map<u32_t, double>& sigma,
+                                    const IntervalESBase& exeState) const
 {
-    IntervalExeState res;
+    IntervalESBase res;
     for (const auto& item : exeState.getVarToVal())
     {
         res._varToItvVal[item.first] = IntervalValue(
@@ -263,7 +263,7 @@ void RelationSolver::updateMap(Map<u32_t, NumericLiteral>& map, u32_t key, const
     }
 }
 
-IntervalExeState RelationSolver::BS(const IntervalExeState& domain, const Z3Expr &phi)
+IntervalESBase RelationSolver::BS(const IntervalESBase& domain, const Z3Expr &phi)
 {
     /// because key of _varToItvVal is u32_t, -key may out of range for int
     /// so we do key + bias for -key
@@ -307,7 +307,7 @@ IntervalExeState RelationSolver::BS(const IntervalExeState& domain, const Z3Expr
     /// optimize each object
     BoxedOptSolver(new_phi.simplify(), ret, low_values, high_values);
     /// fill in the return values
-    IntervalExeState retInv;
+    IntervalESBase retInv;
     for (const auto& item: ret)
     {
         if (item.first >= bias)