Merge pull request diffblue#316 from diffblue/owen-jones-diffblue/pull-out-recency-demotion-to-avoid-duplication

Remove duplicated code to demote most recent DOs

Author: owen-jones-diffblue

regression/LVSA/recent_alloc_clear_from_callees/test_recent_alloc_clear_from_callees.py

@@ -168,7 +168,6 @@ def test_should_not_be_most_recent_caller_1(tmpdir):
     value_set_expectation.check_contains_dynamic_object(1, False)
 
 
-@pytest.mark.xfail(strict=True)
 def test_should_not_be_most_recent_caller_2(tmpdir):
     """
     [13] Checks whether 'is_most_recent_allocation' flag is cleared when

src/pointer-analysis/local_value_set.cpp

@@ -338,92 +338,99 @@ void local_value_sett::apply_assign_side_effects(
   const exprt &rhs,
   const namespacet &ns)
 {
-  if(rhs.id()==ID_side_effect &&
-    rhs.get(ID_statement)==ID_allocate)
+  if(rhs.id() == ID_side_effect && rhs.get(ID_statement) == ID_allocate)
+    demote_most_recent_dynamic_objects(location_number);
+}
+
+void local_value_sett::demote_most_recent_dynamic_objects(
+  const unsigned loc_number)
+{
+  // Replace all the current most-recent-allocation dynamic-objects
+  // with the corresponding any-allocation ones
+  for(auto &value : values)
   {
-    const typet &dynamic_type=
-      static_cast<const typet &>(rhs.find(ID_C_cxx_alloc_type));
+    entryt &entry = value.second;
+    object_map_dt &object_map = entry.object_map.write();
 
-    // Replace all the current most-recent-allocation dynamic-objects
-    // with the corresponding any-allocation ones
-    for(auto &value : values)
-    {
-      entryt &entry=value.second;
-      object_map_dt &object_map=entry.object_map.write();
-
-      // Look-up for the first appearance of the current
-      // most-recent dynamic-object in the current object-map
-      object_map_dt::iterator it=boost::range::find_if(
-        object_map,
-        [this] (const object_map_dt::value_type &object)
-        {
-          const exprt &o=object_numbering[object.first];
-          if(o.id()!=ID_dynamic_object)
-            return false;
+    // Look-up for the first appearance of the current
+    // most-recent dynamic-object in the current object-map
+    object_map_dt::iterator it = boost::range::find_if(
+      object_map, [this, loc_number](const object_map_dt::value_type &object) {
+        const exprt &o = object_numbering[object.first];
+        if(o.id() != ID_dynamic_object)
+          return false;
 
-          const dynamic_object_exprt &dynamic_object=to_dynamic_object_expr(o);
+        const dynamic_object_exprt &dynamic_object = to_dynamic_object_expr(o);
 
-          return dynamic_object.get_instance()==location_number &&
-            dynamic_object.get_recency()==
-              dynamic_object_exprt::recencyt::MOST_RECENT_ALLOCATION;
-        });
+        return dynamic_object.get_instance() == loc_number &&
+               dynamic_object.get_recency() ==
+                 dynamic_object_exprt::recencyt::MOST_RECENT_ALLOCATION;
+      });
 
-      if(it==object_map.end())
-        continue;
+    if(it == object_map.end())
+      continue;
 
-      // Delete the most-recent dynamic-object from the current object_map
-      object_map.erase(it);
+    // Delete the most-recent dynamic-object from the current object_map
+    object_map.erase(it);
 
-      int index_dynamic_object_recent=it->first;
+    const int index_dynamic_object_recent = it->first;
 
-      // Create the any-allocation dynamic-object
-      // by copying the existing most-recent one and adjusting the recency flag
-      dynamic_object_exprt dynamic_object_any_allocation=
-        to_dynamic_object_expr(object_numbering[index_dynamic_object_recent]);
-      dynamic_object_any_allocation.set_recency(false);
+    // Create the any-allocation dynamic-object
+    // by copying the existing most-recent one and adjusting the recency flag
+    dynamic_object_exprt dynamic_object_any_allocation =
+      to_dynamic_object_expr(object_numbering[index_dynamic_object_recent]);
+    dynamic_object_any_allocation.set_recency(false);
 
-      // Add the newly created any-allocation dynamic-object
-      // in the current rhs' object_map
-      insert(entry.object_map, dynamic_object_any_allocation, 0);
-    }
+    // Add the newly created any-allocation dynamic-object
+    // in the current rhs' object_map
+    insert(entry.object_map, dynamic_object_any_allocation, 0);
+  }
 
-    const std::string name_most_recent=
-      prefix_dynamic_object+
-      std::to_string(location_number)+
-      id2string(ID_most_recent_allocation);
-    const std::string name_any_allocation=
-      prefix_dynamic_object+
-      std::to_string(location_number)+
-      id2string(ID_any_allocation);
-
-    // Iterates over the domain's entries and when we find the current
-    // most-recent-allocation dynamic-object, add its object-map
-    // to its correspondent any-allocation dynamic-object's object-map
-    for(auto &value : values)
-    {
-      entryt &entry=value.second;
+  const std::string name_most_recent = prefix_dynamic_object +
+                                       std::to_string(loc_number) +
+                                       id2string(ID_most_recent_allocation);
+  const std::string name_any_allocation = prefix_dynamic_object +
+                                          std::to_string(loc_number) +
+                                          id2string(ID_any_allocation);
+
+  // Iterates over the domain's entries and when we find the current
+  // most-recent-allocation dynamic-object, add its object-map to the
+  // corresponding any-allocation dynamic-object's object-map and remove it
+  // from the domain
+  std::vector<valuest::iterator> to_remove;
+  for(auto it = values.begin(); it != values.end(); ++it)
+  {
+    auto &value = *it;
+    entryt &entry = value.second;
 
-      if(entry.identifier==name_most_recent)
-      {
-        DATA_INVARIANT(
-          can_cast_expr<dynamic_object_exprt>(entry.structured_lhs),
-          "If identifier of entryt begins with dynamic object prefix then its "
-          "structured_lhs should be castable to a dynamic_object_exprt");
-        dynamic_object_exprt expr_any_allocation =
-          to_dynamic_object_expr(entry.structured_lhs);
-        expr_any_allocation.set_recency(false);
-
-        entryt &entry_any_allocation = get_entry(
-          entryt(name_any_allocation, entry.suffix, expr_any_allocation),
-          dynamic_type,
-          ns);
-
-        // Add into the any-allocation dynamic-object's object_map
-        // the most-recent-allocation dynamic-object's object_map
-        make_union(entry_any_allocation.object_map, entry.object_map);
-      }
+    if(entry.identifier == name_most_recent)
+    {
+      DATA_INVARIANT(
+        can_cast_expr<dynamic_object_exprt>(entry.structured_lhs),
+        "If identifier of entryt begins with dynamic object prefix then its "
+        "structured_lhs should be castable to a dynamic_object_exprt");
+      dynamic_object_exprt expr_any_allocation =
+        to_dynamic_object_expr(entry.structured_lhs);
+      expr_any_allocation.set_recency(false);
+
+      /// The second and third arguments to get_entry() are only used for
+      /// field_sensitive(), and that will always returns true without using
+      /// them because name_any_allocation starts with the prefix for a
+      /// dynamic object, so we can use an empty type and namespace.
+      entryt &entry_any_allocation = get_entry(
+        entryt(name_any_allocation, entry.suffix, expr_any_allocation),
+        nil_typet(),
+        namespacet(symbol_tablet()));
+
+      // Add into the any-allocation dynamic-object's object_map
+      // the most-recent-allocation dynamic-object's object_map
+      make_union(entry_any_allocation.object_map, entry.object_map);
+      to_remove.push_back(it);
     }
   }
+
+  for(auto it : to_remove)
+    values.erase(it);
 }
 
 void local_value_sett::demote_initializers(object_mapt &values_rhs) const

src/pointer-analysis/local_value_set.h

@@ -139,6 +139,12 @@ class local_value_sett:public value_sett
     const exprt &lhs,
     const exprt &rhs,
     const namespacet &ns) override;
+
+  /// Replace most recent dynamic objects allocated at a given location with
+  /// any allocation dynamic objects allocated at the given location.
+  /// \param loc_number: the location number for the dynamic objects we are
+  ///   looking for
+  void demote_most_recent_dynamic_objects(const unsigned loc_number);
 };
 
 #endif

src/pointer-analysis/local_value_set_analysis.cpp

@@ -339,79 +339,9 @@ void local_value_set_analysist::transform_function_stub(
       const auto rhs_num=valuesets.object_numbering.get_number(rhs_expr);
       if(can_cast_expr<dynamic_object_exprt>(rhs_expr) && rhs_num)
       {
-        // Replace all the current most-recent-allocation dynamic-objects
-        // with the corresponding any-allocation ones
-        for(auto &value : valuesets.values)
-        {
-          local_value_sett::entryt &entry=value.second;
-          local_value_sett::object_map_dt &object_map=entry.object_map.write();
-
-          // Look-up for the first appearance of the current
-          // most-recent dynamic-object in the current object-map
-          const auto it=object_map.find(*rhs_num);
-          if(it==object_map.end())
-            continue;
-
-          const int index_dynamic_object_recent=it->first;
-
-          // Delete the most-recent dynamic-object from the current object_map
-          object_map.erase(it);
-
-          // Create the any-allocation dynamic-object by copying
-          // the existing most-recent one and adjusting the recency flag
-          dynamic_object_exprt dynamic_object_any_allocation=
-            to_dynamic_object_expr(
-              valuesets.object_numbering[index_dynamic_object_recent]);
-          dynamic_object_any_allocation.set_recency(false);
-
-          // Add the newly created any-allocation dynamic-object
-          // in the current rhs' object_map
-          valuesets.insert(entry.object_map, dynamic_object_any_allocation, 0);
-        }
-
-        const std::string name_most_recent=
-          prefix_dynamic_object+
-          std::to_string(
-            expr_try_dynamic_cast<dynamic_object_exprt>(rhs_expr)
-              ->get_instance())+
-          id2string(ID_most_recent_allocation);
-        const std::string name_any_allocation=
-          prefix_dynamic_object+
-          std::to_string(
-            expr_try_dynamic_cast<dynamic_object_exprt>(rhs_expr)
-              ->get_instance())+
-          id2string(ID_any_allocation);
-        const typet &dynamic_type=
-          static_cast<const typet &>(rhs_expr.find(ID_C_cxx_alloc_type));
-
-        std::vector<local_value_sett::valuest::iterator> to_remove;
-        for(auto it=valuesets.values.begin(); it!=valuesets.values.end(); ++it)
-        {
-          auto &value=*it;
-          local_value_sett::entryt &entry=value.second;
-
-          if(entry.identifier==name_most_recent)
-          {
-            DATA_INVARIANT(
-              can_cast_expr<dynamic_object_exprt>(entry.structured_lhs),
-              "If identifier of entryt begins with dynamic object prefix then "
-              "its structured_lhs should be castable to a "
-              "dynamic_object_exprt");
-            dynamic_object_exprt expr_any_allocation =
-              to_dynamic_object_expr(entry.structured_lhs);
-            expr_any_allocation.set_recency(false);
-            local_value_sett::entryt &entry_any_allocation =
-              valuesets.get_entry(
-                local_value_sett::entryt(
-                  name_any_allocation, entry.suffix, expr_any_allocation),
-                dynamic_type,
-                ns);
-            valuesets.make_union(entry_any_allocation.object_map, entry.object_map);
-            to_remove.push_back(it);
-          }
-        }
-        for(auto it : to_remove)
-          valuesets.values.erase(it);
+        unsigned loc_number =
+          expr_try_dynamic_cast<dynamic_object_exprt>(rhs_expr)->get_instance();
+        valuesets.demote_most_recent_dynamic_objects(loc_number);
       }
 
       valuesets.insert(rhs_map, rhs_expr);