Value set: indirect values.find operations via a helper function

This means when the underlying datastructure changes we don't have to
update several users.

Author: smowton

src/pointer-analysis/value_set.cpp

@@ -51,6 +51,13 @@ bool value_sett::field_sensitive(
   return ns.follow(type).id()==ID_struct;
 }
 
+const value_sett::entryt *value_sett::find_entry(const value_sett::idt &id)
+  const
+{
+  auto found = values.find(id);
+  return found == values.end() ? nullptr : &found->second;
+}
+
 value_sett::entryt &value_sett::get_entry(
   const entryt &e,
   const typet &type,
@@ -429,31 +436,29 @@ void value_sett::get_value_set_rec(
        expr_type.id()==ID_array)
     {
       // look it up
-      valuest::const_iterator v_it=
-        values.find(id2string(identifier)+suffix);
+      const entryt *entry =
+        find_entry(id2string(identifier) + suffix);
 
       // try first component name as suffix if not yet found
-      if(v_it==values.end() &&
-          (expr_type.id()==ID_struct ||
-           expr_type.id()==ID_union))
+      if(!entry && (expr_type.id() == ID_struct || expr_type.id() == ID_union))
       {
         const struct_union_typet &struct_union_type=
           to_struct_union_type(expr_type);
 
         const irep_idt &first_component_name =
           struct_union_type.components().front().get_name();
 
-        v_it = values.find(
+        entry = find_entry(
           id2string(identifier) + "." + id2string(first_component_name) +
           suffix);
       }
 
       // not found? try without suffix
-      if(v_it==values.end())
-        v_it=values.find(identifier);
+      if(!entry)
+        entry = find_entry(identifier);
 
-      if(v_it!=values.end())
-        make_union(dest, v_it->second.object_map);
+      if(entry)
+        make_union(dest, entry->object_map);
       else
         insert(dest, exprt(ID_unknown, original_type));
     }
@@ -857,16 +862,16 @@ void value_sett::get_value_set_rec(
     const std::string full_name=prefix+suffix;
 
     // look it up
-    valuest::const_iterator v_it=values.find(full_name);
+    const entryt *entry = find_entry(full_name);
 
     // not found? try without suffix
-    if(v_it==values.end())
-      v_it=values.find(prefix);
+    if(!entry)
+      entry = find_entry(prefix);
 
-    if(v_it==values.end())
+    if(!entry)
       insert(dest, exprt(ID_unknown, original_type));
     else
-      make_union(dest, v_it->second.object_map);
+      make_union(dest, entry->object_map);
   }
   else if(expr.id()==ID_byte_extract_little_endian ||
           expr.id()==ID_byte_extract_big_endian)

src/pointer-analysis/value_set.h

@@ -317,6 +317,15 @@ class value_sett
     values.clear();
   }
 
+  /// Finds an entry in this value-set. The interface differs from get_entry
+  /// because get_value_set_rec wants to check for a struct's first component
+  /// before stripping the suffix as is done in get_entry.
+  /// \param id: identifier to find.
+  /// \return a constant pointer to an entry if found, or null otherwise.
+  ///   Note the pointer may be invalidated by insert operations, including
+  ///   get_entry.
+  const entryt *find_entry(const idt &id) const;
+
   /// Gets or inserts an entry in this value-set.
   /// \param e: entry to find. Its `id` and `suffix` fields will be used
   ///   to find a corresponding entry; if a fresh entry is created its