Use widening_range in value_set_abstract_object widening merge

Means widened ranges are calculated in the same way for both intervals
and value sets, both now handling max & min appropriately.

Author: jezhiggins

src/analyses/variable-sensitivity/interval_abstract_value.cpp

@@ -354,8 +354,8 @@ abstract_object_pointert widening_merge(
   auto widened = widened_ranget(lhs, rhs);
 
   // new interval ...
-  auto new_interval =
-    constant_interval_exprt(widened.lower_bound, widened.upper_bound);
+  auto new_interval = constant_interval_exprt(
+    widened.widened_lower_bound, widened.widened_upper_bound);
   return interval_abstract_valuet::make_interval(new_interval);
 }
 

src/analyses/variable-sensitivity/value_set_abstract_object.cpp

@@ -14,6 +14,7 @@
 #include <analyses/variable-sensitivity/context_abstract_object.h>
 #include <analyses/variable-sensitivity/interval_abstract_value.h>
 #include <analyses/variable-sensitivity/value_set_abstract_object.h>
+#include <analyses/variable-sensitivity/widened_range.h>
 
 #include <util/arith_tools.h>
 #include <util/make_unique.h>
@@ -414,6 +415,7 @@ static abstract_object_sett compact_values(const abstract_object_sett &values)
 }
 
 static exprt eval_expr(const exprt &e);
+static bool is_eq(const exprt &lhs, const exprt &rhs);
 static bool is_le(const exprt &lhs, const exprt &rhs);
 static abstract_object_sett collapse_values_in_intervals(
   const abstract_object_sett &values,
@@ -446,6 +448,8 @@ void collapse_overlapping_intervals(
     intervals.begin(),
     intervals.end(),
     [](constant_interval_exprt const &lhs, constant_interval_exprt const &rhs) {
+      if(is_eq(lhs.get_lower(), rhs.get_lower()))
+        return is_le(lhs.get_upper(), rhs.get_upper());
       return is_le(lhs.get_lower(), rhs.get_lower());
     });
 
@@ -556,10 +560,14 @@ static exprt eval_expr(const exprt &e)
   return simplify_expr(e, ns);
 }
 
+static bool is_eq(const exprt &lhs, const exprt &rhs)
+{
+  return constant_interval_exprt::equal(lhs, rhs);
+}
+
 static bool is_le(const exprt &lhs, const exprt &rhs)
 {
-  auto is_le_expr = binary_relation_exprt(lhs, ID_le, rhs);
-  return eval_expr(is_le_expr).is_true();
+  return constant_interval_exprt::less_than_or_equal(lhs, rhs);
 }
 
 static abstract_object_sett widen_value_set(
@@ -572,41 +580,34 @@ static abstract_object_sett widen_value_set(
 
   auto widened_ends = std::vector<constant_interval_exprt>{};
 
-  auto lower_bound =
-    constant_interval_exprt::get_min(lhs.get_lower(), rhs.get_lower());
-  auto upper_bound =
-    constant_interval_exprt::get_max(lhs.get_upper(), rhs.get_upper());
-  auto range = plus_exprt(
-    minus_exprt(upper_bound, lower_bound), from_integer(1, lhs.type()));
-
-  auto symbol_table = symbol_tablet{};
-  auto ns = namespacet{symbol_table};
+  auto range = widened_ranget(lhs, rhs);
 
   // should extend lower bound?
-  if(rhs.get_lower() < lhs.get_lower())
+  if(range.is_lower_widened)
   {
-    auto widened_lower_bound = constant_interval_exprt(
-      simplify_expr(minus_exprt(lower_bound, range), ns), lower_bound);
-    widened_ends.push_back(widened_lower_bound);
+    auto extended_lower_bound =
+      constant_interval_exprt(range.widened_lower_bound, range.lower_bound);
+
+    widened_ends.push_back(extended_lower_bound);
     for(auto &obj : values)
     {
       auto value = std::dynamic_pointer_cast<const abstract_value_objectt>(obj);
       auto as_expr = value->to_interval();
-      if(is_le(as_expr.get_lower(), lower_bound))
+      if(is_le(as_expr.get_lower(), range.lower_bound))
         widened_ends.push_back(as_expr);
     }
   }
   // should extend upper bound?
-  if(lhs.get_upper() < rhs.get_upper())
+  if(range.is_upper_widened)
   {
-    auto widened_upper_bound = constant_interval_exprt(
-      upper_bound, simplify_expr(plus_exprt(upper_bound, range), ns));
-    widened_ends.push_back(widened_upper_bound);
+    auto extended_upper_bound =
+      constant_interval_exprt(range.upper_bound, range.widened_upper_bound);
+    widened_ends.push_back(extended_upper_bound);
     for(auto &obj : values)
     {
       auto value = std::dynamic_pointer_cast<const abstract_value_objectt>(obj);
       auto as_expr = value->to_interval();
-      if(is_le(upper_bound, as_expr.get_upper()))
+      if(is_le(range.upper_bound, as_expr.get_upper()))
         widened_ends.push_back(as_expr);
     }
   }

src/analyses/variable-sensitivity/widened_range.cpp

@@ -20,32 +20,32 @@ static bool has_overflowed(const exprt &value)
     value, from_integer(0, value.type()));
 }
 
-exprt widened_ranget::make_lower_bound() const
+exprt widened_ranget::widen_lower_bound() const
 {
-  if(!lower_extended)
-    return lower_;
+  if(!is_lower_widened)
+    return lower_bound;
 
-  auto new_lower_bound = simplify_expr(minus_exprt(lower_, range_), ns_);
+  auto new_lower_bound = simplify_expr(minus_exprt(lower_bound, range_), ns_);
 
   if(
     constant_interval_exprt::contains_extreme(new_lower_bound) ||
     has_underflowed(new_lower_bound))
-    return min_exprt(lower_.type());
+    return min_exprt(lower_bound.type());
 
   return new_lower_bound;
 }
 
-exprt widened_ranget::make_upper_bound() const
+exprt widened_ranget::widen_upper_bound() const
 {
-  if(!upper_extended)
-    return upper_;
+  if(!is_upper_widened)
+    return upper_bound;
 
-  auto new_upper_bound = simplify_expr(plus_exprt(upper_, range_), ns_);
+  auto new_upper_bound = simplify_expr(plus_exprt(upper_bound, range_), ns_);
 
   if(
     constant_interval_exprt::contains_extreme(new_upper_bound) ||
     has_overflowed(new_upper_bound))
-    return max_exprt(upper_.type());
+    return max_exprt(upper_bound.type());
 
   return new_upper_bound;
 }

src/analyses/variable-sensitivity/widened_range.h

@@ -20,38 +20,39 @@ class widened_ranget
   widened_ranget(
     const constant_interval_exprt &lhs,
     const constant_interval_exprt &rhs)
-    : lower_extended(
+    : is_lower_widened(
         constant_interval_exprt::less_than(rhs.get_lower(), lhs.get_lower())),
-      upper_extended(
+      is_upper_widened(
         constant_interval_exprt::less_than(lhs.get_upper(), rhs.get_upper())),
-      ns_(symbol_tablet{}),
-      lower_(
+      lower_bound(
         constant_interval_exprt::get_min(lhs.get_lower(), rhs.get_lower())),
-      upper_(
+      upper_bound(
         constant_interval_exprt::get_max(lhs.get_upper(), rhs.get_upper())),
-      range_(
-        plus_exprt(minus_exprt(upper_, lower_), from_integer(1, lhs.type()))),
-      lower_bound(make_lower_bound()),
-      upper_bound(make_upper_bound())
+      ns_(symbol_tablet{}),
+      range_(plus_exprt(
+        minus_exprt(upper_bound, lower_bound),
+        from_integer(1, lhs.type()))),
+      widened_lower_bound(widen_lower_bound()),
+      widened_upper_bound(widen_upper_bound())
   {
   }
 
-  const bool lower_extended;
-  const bool upper_extended;
+  const bool is_lower_widened;
+  const bool is_upper_widened;
+  const exprt lower_bound;
+  const exprt upper_bound;
 
 private:
   namespacet ns_;
-  exprt lower_;
-  exprt upper_;
   exprt range_;
 
 public:
-  const exprt lower_bound;
-  const exprt upper_bound;
+  const exprt widened_lower_bound;
+  const exprt widened_upper_bound;
 
 private:
-  exprt make_lower_bound() const;
-  exprt make_upper_bound() const;
+  exprt widen_lower_bound() const;
+  exprt widen_upper_bound() const;
 };
 
 #endif // CPROVER_ANALYSES_VARIABLE_SENSITIVITY_WIDENED_RANGE_H

unit/analyses/variable-sensitivity/interval_abstract_value/widening_merge.cpp

@@ -44,6 +44,8 @@ SCENARIO(
   const exprt val10minus = from_integer(-10, type);
   auto valMax = max_exprt(type);
   auto valMin = min_exprt(type);
+  auto veryLarge = from_integer(2 << 29, type);
+  auto veryLargeMinus = from_integer(-(2 << 29), type);
 
   auto config = vsd_configt::constant_domain();
   config.context_tracking.data_dependency_context = false;
@@ -320,7 +322,6 @@ SCENARIO(
     }
     WHEN("merging [0, 1] with [1, very_large]")
     {
-      auto veryLarge = from_integer(2 << 29, type);
       auto op1 = make_interval(val0, val1, environment, ns);
       auto op2 = make_interval(val1, veryLarge, environment, ns);
 
@@ -346,7 +347,6 @@ SCENARIO(
     }
     WHEN("merging [0, 1] with [-very_large, 1]")
     {
-      auto veryLargeMinus = from_integer(-(2 << 29), type);
       auto op1 = make_interval(val0, val1, environment, ns);
       auto op2 = make_interval(veryLargeMinus, val1, environment, ns);
 
@@ -384,8 +384,6 @@ SCENARIO(
     }
     WHEN("merging [0, very_large] with [-very_large, 0]")
     {
-      auto veryLarge = from_integer(2 << 29, type);
-      auto veryLargeMinus = from_integer(-(2 << 29), type);
       auto op1 = make_interval(val0, veryLarge, environment, ns);
       auto op2 = make_interval(veryLargeMinus, val0, environment, ns);
 
@@ -398,8 +396,6 @@ SCENARIO(
     }
     WHEN("merging [-very_large, 0] with [0, very_large]")
     {
-      auto veryLarge = from_integer(2 << 29, type);
-      auto veryLargeMinus = from_integer(-(2 << 29), type);
       auto op1 = make_interval(veryLargeMinus, val0, environment, ns);
       auto op2 = make_interval(val0, veryLarge, environment, ns);
 
@@ -413,8 +409,6 @@ SCENARIO(
 
     WHEN("merging [-very_large, very_large] with [0, 1]")
     {
-      auto veryLarge = from_integer(2 << 29, type);
-      auto veryLargeMinus = from_integer(-(2 << 29), type);
       auto op1 = make_interval(veryLargeMinus, veryLarge, environment, ns);
       auto op2 = make_interval(val0, val1, environment, ns);
 
@@ -427,8 +421,6 @@ SCENARIO(
     }
     WHEN("merging [0, 1] with [-very_large, very_large]")
     {
-      auto veryLarge = from_integer(2 << 29, type);
-      auto veryLargeMinus = from_integer(-(2 << 29), type);
       auto op1 = make_interval(val0, val1, environment, ns);
       auto op2 = make_interval(veryLargeMinus, veryLarge, environment, ns);
 

unit/analyses/variable-sensitivity/value_set_abstract_object/widening_merge.cpp

@@ -47,6 +47,10 @@ SCENARIO(
   auto val5minus = from_integer(-5, type);
   auto val8minus = from_integer(-8, type);
   auto val10minus = from_integer(-10, type);
+  auto valMax = max_exprt(type);
+  auto valMin = min_exprt(type);
+  auto veryLarge = from_integer(2 << 29, type);
+  auto veryLargeMinus = from_integer(-(2 << 29), type);
 
   auto config = vsd_configt::constant_domain();
   config.context_tracking.data_dependency_context = false;
@@ -382,5 +386,64 @@ SCENARIO(
            val2minus});
       }
     }
+
+    WHEN("merging {0, very_large} with {-very_large, 0}")
+    {
+      auto op1 = make_value_set({val0, veryLarge}, environment, ns);
+      auto op2 = make_value_set({veryLargeMinus, val0}, environment, ns);
+
+      auto merged = widening_merge(op1, op2);
+
+      THEN("result is {[MIN, -very_large], 0, very_large]")
+      {
+        EXPECT_MODIFIED(
+          merged,
+          {constant_interval_exprt(valMin, veryLargeMinus), val0, veryLarge});
+      }
+    }
+    WHEN("merging {-very_large, 0} with {0, very_large}")
+    {
+      auto op1 = make_value_set({veryLargeMinus, val0}, environment, ns);
+      auto op2 = make_value_set({val0, veryLarge}, environment, ns);
+
+      auto merged = widening_merge(op1, op2);
+
+      THEN("result is {-very_large, 0, [very_large, MAX]}")
+      {
+        EXPECT_MODIFIED(
+          merged,
+          {veryLargeMinus, val0, constant_interval_exprt(veryLarge, valMax)});
+      }
+    }
+
+    WHEN("merging {-very_large, very_large } with {0, 1}")
+    {
+      auto op1 = make_value_set({veryLargeMinus, veryLarge}, environment, ns);
+      auto op2 = make_value_set({val0, val1}, environment, ns);
+
+      auto merged = widening_merge(op1, op2);
+
+      THEN("result is {-very_large, val0, val1, very_large}")
+      {
+        EXPECT_MODIFIED(merged, {veryLargeMinus, val0, val1, veryLarge});
+      }
+    }
+    WHEN("merging {0, 1} with {-very_large, very_large}")
+    {
+      auto op1 = make_value_set({val0, val1}, environment, ns);
+      auto op2 = make_value_set({veryLargeMinus, veryLarge}, environment, ns);
+
+      auto merged = widening_merge(op1, op2);
+
+      THEN("result is {[MIN, 0}, [1, MAX]}")
+      {
+        EXPECT_MODIFIED(
+          merged,
+          {constant_interval_exprt(valMin, veryLargeMinus),
+           val0,
+           val1,
+           constant_interval_exprt(veryLarge, valMax)});
+      }
+    }
   }
 }