Extracted out logic for when to use a 2 value merge

Previously each abstract object that implemented merge had to correctly
redirect merging top with anything or merging with a bottom.

This is now handled directly in the root merge by checking the three
cases where the base merge must be used.

If this is bottom must still be handled by derived classes as we must
create an abstract object of the same type.

Author: thk123

src/analyses/variable-sensitivity/abstract_object.cpp

@@ -112,6 +112,26 @@ Function: abstract_objectt::merge
 
 abstract_object_pointert abstract_objectt::merge(
   abstract_object_pointert other) const
+{
+  return abstract_object_merge(other);
+}
+
+/*******************************************************************\
+
+Function: abstract_objectt::abstract_object_merge
+
+  Inputs:
+   other - The object to merge with this
+
+ Outputs: Returns the result of the abstract object.
+
+ Purpose: Create a new abstract object that is the result of the merge, unless
+          the object would be unchanged, then would return itself.
+
+\*******************************************************************/
+
+abstract_object_pointert abstract_objectt::abstract_object_merge(
+  const abstract_object_pointert other) const
 {
   if(top)
     return shared_from_this();
@@ -125,7 +145,6 @@ abstract_object_pointert abstract_objectt::merge(
   return merged;
 }
 
-
 /*******************************************************************\
 
 Function: abstract_objectt::expression_transform
@@ -286,10 +305,31 @@ abstract_object_pointert abstract_objectt::merge(
   abstract_object_pointert op2,
   bool &out_modifications)
 {
-  abstract_object_pointert result=op1->merge(op2);
+  abstract_object_pointert result=op1->should_use_base_merge(op2)?
+    op1->abstract_object_merge(op2):op1->merge(op2);
   // If no modifications, we will return the original pointer
   out_modifications=result!=op1;
   return result;
 }
 
+/*******************************************************************\
+
+Function: abstract_objectt::should_use_base_merge
+
+  Inputs:
+   other - the object being merged with
+
+ Outputs: Returns true if the base class is capable of doing a complete merge
+
+ Purpose: To detect the cases where the base merge is sufficient to do a merge
+          We can't do if this->is_bottom() since we want the specific
+
+\*******************************************************************/
+
+bool abstract_objectt::should_use_base_merge(
+  const abstract_object_pointert other) const
+{
+  return is_top() || other->is_bottom() || other->is_top();
+}
+
 

src/analyses/variable-sensitivity/abstract_object.h

@@ -112,6 +112,9 @@ class abstract_objectt:public std::enable_shared_from_this<abstract_objectt>
   // To enforce copy-on-write these are private and have read-only accessors
   typet t;
   bool bottom;
+
+  abstract_object_pointert abstract_object_merge(
+    const abstract_object_pointert other) const;
 protected:
   template<class T>
   using internal_sharing_ptrt=std::shared_ptr<T>;
@@ -130,6 +133,8 @@ class abstract_objectt:public std::enable_shared_from_this<abstract_objectt>
   // The one exception is merge in descendant classes, which needs this
   void make_top() { top=true; }
 
+  bool should_use_base_merge(const abstract_object_pointert other) const;
+
   // Sets the state of this object
   virtual abstract_object_pointert merge(abstract_object_pointert other) const;
 

src/analyses/variable-sensitivity/constant_abstract_value.cpp

@@ -101,11 +101,7 @@ Function: constant_abstract_valuet::merge_constant_constant
 abstract_object_pointert constant_abstract_valuet::merge_constant_constant(
   constant_abstract_value_pointert other) const
 {
-  if(is_top() || other->is_bottom())
-  {
-    return abstract_valuet::merge(other);
-  }
-  else if(is_bottom())
+  if(is_bottom())
   {
     return std::make_shared<constant_abstract_valuet>(*other);
   }

src/analyses/variable-sensitivity/constant_array_abstract_object.cpp

@@ -133,11 +133,7 @@ Function: constant_array_abstract_objectt::constant_array_merge
 abstract_object_pointert constant_array_abstract_objectt::constant_array_merge(
   const constant_array_pointert other) const
 {
-  if(is_top() || other->is_bottom() || other->is_top())
-  {
-    return array_abstract_objectt::merge(other);
-  }
-  else if(is_bottom())
+  if(is_bottom())
   {
     return std::make_shared<constant_array_abstract_objectt>(*other);
   }

src/analyses/variable-sensitivity/constant_pointer_abstract_object.cpp

@@ -168,11 +168,7 @@ abstract_object_pointert
   constant_pointer_abstract_objectt::merge_constant_pointers(
     const constant_pointer_abstract_pointert other) const
 {
-  if(is_top() || other->is_bottom())
-  {
-    return pointer_abstract_objectt::merge(other);
-  }
-  else if(is_bottom())
+  if(is_bottom())
   {
     return std::make_shared<constant_pointer_abstract_objectt>(*other);
   }

src/analyses/variable-sensitivity/full_struct_abstract_object.cpp

@@ -360,11 +360,7 @@ Function: full_struct_abstract_objectt::merge_constant_structs
 abstract_object_pointert full_struct_abstract_objectt::merge_constant_structs(
   constant_struct_pointert other) const
 {
-  if(is_top() || other->is_bottom() || other->is_top())
-  {
-    return struct_abstract_objectt::merge(other);
-  }
-  else if(is_bottom())
+  if(is_bottom())
   {
     return std::make_shared<full_struct_abstract_objectt>(*other);
   }