Merge pull request #6267 from jezhiggins/vsd-to-predicate

VSD - to predicate

Author: martin-cs

src/analyses/variable-sensitivity/abstract_environment.cpp

@@ -408,22 +408,41 @@ void abstract_environmentt::output(
 {
   out << "{\n";
 
-  decltype(map)::viewt view;
-  map.get_view(view);
-  for(const auto &entry : view)
+  for(const auto &entry : map.get_view())
   {
     out << entry.first << " () -> ";
     entry.second->output(out, ai, ns);
     out << "\n";
   }
+
   out << "}\n";
 }
 
+exprt abstract_environmentt::to_predicate() const
+{
+  if(is_bottom())
+    return false_exprt();
+  if(is_top())
+    return true_exprt();
+
+  auto predicates = std::vector<exprt>{};
+  for(const auto &entry : map.get_view())
+  {
+    auto sym = entry.first;
+    auto val = entry.second;
+    auto pred = val->to_predicate(symbol_exprt(sym, val->type()));
+
+    predicates.push_back(pred);
+  }
+
+  if(predicates.size() == 1)
+    return predicates.front();
+  return and_exprt(predicates);
+}
+
 bool abstract_environmentt::verify() const
 {
-  decltype(map)::viewt view;
-  map.get_view(view);
-  for(const auto &entry : view)
+  for(const auto &entry : map.get_view())
   {
     if(entry.second == nullptr)
     {
@@ -460,9 +479,7 @@ abstract_environmentt::modified_symbols(
 {
   // Find all symbols who have different write locations in each map
   std::vector<abstract_environmentt::map_keyt> symbols_diff;
-  decltype(first.map)::viewt view;
-  first.map.get_view(view);
-  for(const auto &entry : view)
+  for(const auto &entry : first.map.get_view())
   {
     const auto &second_entry = second.map.find(entry.first);
     if(second_entry.has_value())
@@ -505,10 +522,8 @@ abstract_environmentt::gather_statistics(const namespacet &ns) const
 {
   abstract_object_statisticst statistics = {};
   statistics.number_of_globals = count_globals(ns);
-  decltype(map)::viewt view;
-  map.get_view(view);
   abstract_object_visitedt visited;
-  for(auto const &object : view)
+  for(auto const &object : map.get_view())
   {
     if(visited.find(object.second) == visited.end())
     {

src/analyses/variable-sensitivity/abstract_environment.h

@@ -224,6 +224,12 @@ class abstract_environmentt
   void output(std::ostream &out, const class ai_baset &ai, const namespacet &ns)
     const;
 
+  /// Gives a boolean condition that is true for all values represented by the
+  /// environment.
+  ///
+  /// \return An exprt describing the environment
+  exprt to_predicate() const;
+
   /// Check the structural invariants are maintained.
   /// In this case this is checking there aren't any null pointer mapped values
   bool verify() const;

src/analyses/variable-sensitivity/abstract_object.cpp

@@ -172,6 +172,21 @@ exprt abstract_objectt::to_constant() const
   return nil_exprt();
 }
 
+exprt abstract_objectt::to_predicate(const exprt &name) const
+{
+  if(is_top())
+    return true_exprt();
+  if(is_bottom())
+    return false_exprt();
+  return to_predicate_internal(name);
+}
+
+exprt abstract_objectt::to_predicate_internal(const exprt &name) const
+{
+  UNREACHABLE;
+  return nil_exprt();
+}
+
 void abstract_objectt::output(
   std::ostream &out,
   const ai_baset &ai,

src/analyses/variable-sensitivity/abstract_object.h

@@ -171,6 +171,17 @@ class abstract_objectt : public std::enable_shared_from_this<abstract_objectt>
   /// that allows an object to be built from a value.
   virtual exprt to_constant() const;
 
+  /// Converts to an invariant expression
+  ///
+  /// \param name - the variable name to substitute into the expression
+  /// \return Returns an exprt representing the object as an invariant.
+  ///
+  /// The the abstract element represents a single value the expression will
+  /// have the form _name = value_, if the value is an interval it will have the
+  /// the form _lower <= name <= upper_, etc.
+  /// If the value is bottom returns false, if top returns true.
+  exprt to_predicate(const exprt &name) const;
+
   /**
    * A helper function to evaluate writing to a component of an
    * abstract object. More precise abstractions may override this to
@@ -352,6 +363,11 @@ class abstract_objectt : public std::enable_shared_from_this<abstract_objectt>
     return shared_from_this() == other;
   }
 
+  /// to_predicate implementation - derived classes will override
+  /// \param name - the variable name to substitute into the expression
+  /// \return Returns an exprt representing the object as an invariant.
+  virtual exprt to_predicate_internal(const exprt &name) const;
+
 private:
   /// To enforce copy-on-write these are private and have read-only accessors
   typet t;

src/analyses/variable-sensitivity/constant_abstract_value.cpp

@@ -144,6 +144,11 @@ abstract_value_pointert constant_abstract_valuet::constrain(
   return as_value(mutable_clone());
 }
 
+exprt constant_abstract_valuet::to_predicate_internal(const exprt &name) const
+{
+  return equal_exprt(name, value);
+}
+
 void constant_abstract_valuet::get_statistics(
   abstract_object_statisticst &statistics,
   abstract_object_visitedt &visited,

src/analyses/variable-sensitivity/constant_abstract_value.h

@@ -81,6 +81,8 @@ class constant_abstract_valuet : public abstract_value_objectt
   abstract_object_pointert
   meet_with_value(const abstract_value_pointert &other) const override;
 
+  exprt to_predicate_internal(const exprt &name) const override;
+
 private:
   exprt value;
 };

src/analyses/variable-sensitivity/constant_pointer_abstract_object.cpp

@@ -388,3 +388,9 @@ exprt constant_pointer_abstract_objectt::ptr_comparison_expr(
     return true_exprt();
   return nil_exprt();
 }
+
+exprt constant_pointer_abstract_objectt::to_predicate_internal(
+  const exprt &name) const
+{
+  return equal_exprt(name, value_stack.to_expression());
+}

src/analyses/variable-sensitivity/constant_pointer_abstract_object.h

@@ -145,6 +145,8 @@ class constant_pointer_abstract_objectt : public abstract_pointer_objectt
 
   CLONE
 
+  exprt to_predicate_internal(const exprt &name) const override;
+
 private:
   bool same_target(abstract_object_pointert other) const;
   exprt offset() const;

src/analyses/variable-sensitivity/context_abstract_object.cpp

@@ -160,6 +160,11 @@ abstract_object_pointert context_abstract_objectt::unwrap_context() const
   return child_abstract_object->unwrap_context();
 }
 
+exprt context_abstract_objectt::to_predicate_internal(const exprt &name) const
+{
+  return child_abstract_object->to_predicate(name);
+}
+
 void context_abstract_objectt::get_statistics(
   abstract_object_statisticst &statistics,
   abstract_object_visitedt &visited,

src/analyses/variable-sensitivity/context_abstract_object.h

@@ -117,6 +117,8 @@ class context_abstract_objectt : public abstract_objectt
     bool merging_write) const override;
 
   bool has_been_modified(const abstract_object_pointert &before) const override;
+
+  exprt to_predicate_internal(const exprt &name) const override;
 };
 
 #endif // CPROVER_ANALYSES_VARIABLE_SENSITIVITY_CONTEXT_ABSTRACT_OBJECT_H