Make find_widest_union_component safe for non-constant sizes

This should make it safer to use and enables re-use as part of
pointer_offset_bits.

Author: tautschnig

src/util/pointer_offset_size.cpp

@@ -154,23 +154,16 @@ pointer_offset_bits(const typet &type, const namespacet &ns)
   else if(type.id()==ID_union)
   {
     const union_typet &union_type=to_union_type(type);
-    mp_integer result=0;
-
-    // compute max
-
-    for(const auto &c : union_type.components())
-    {
-      const typet &subtype = c.type();
-      auto sub_size = pointer_offset_bits(subtype, ns);
 
-      if(!sub_size.has_value())
-        return {};
+    if(union_type.components().empty())
+      return mp_integer{0};
 
-      if(*sub_size > result)
-        result = *sub_size;
-    }
+    const auto widest_member = union_type.find_widest_union_component(ns);
 
-    return result;
+    if(widest_member.has_value())
+      return widest_member->second;
+    else
+      return {};
   }
   else if(type.id()==ID_signedbv ||
           type.id()==ID_unsignedbv ||

src/util/std_types.cpp

@@ -294,25 +294,28 @@ union_typet::find_widest_union_component(const namespacet &ns) const
 {
   const union_typet::componentst &comps = components();
 
-  mp_integer max_width = 0;
+  optionalt<mp_integer> max_width;
   typet max_comp_type;
   irep_idt max_comp_name;
 
   for(const auto &comp : comps)
   {
     auto element_width = pointer_offset_bits(comp.type(), ns);
 
-    if(!element_width.has_value() || *element_width <= max_width)
+    if(!element_width.has_value())
+      return {};
+
+    if(max_width.has_value() && *element_width <= *max_width)
       continue;
 
     max_width = *element_width;
     max_comp_type = comp.type();
     max_comp_name = comp.get_name();
   }
 
-  if(max_width == 0)
+  if(!max_width.has_value())
     return {};
   else
     return std::make_pair(
-      struct_union_typet::componentt{max_comp_name, max_comp_type}, max_width);
+      struct_union_typet::componentt{max_comp_name, max_comp_type}, *max_width);
 }

src/util/std_types.h

@@ -401,9 +401,8 @@ class union_typet:public struct_union_typet
   {
   }
 
-  /// Determine the member of maximum fixed bit width in a union type. If no
-  /// member, or no member of fixed and non-zero width can be found, return
-  /// nullopt.
+  /// Determine the member of maximum bit width in a union type. If no member,
+  /// or a member of non-fixed width can be found, return nullopt.
   /// \param union_type: Type to determine the member of.
   /// \param ns: Namespace to resolve tag types.
   /// \return Pair of a componentt pointing to the maximum fixed bit-width