Make get_subexpression_at_offset return an exprt for consistency

All other functions declared in that block in pointer_offset_size.h return an
exprt and the comment explicitly states that they return nil_exprt() on failure.
get_subexpression_at_offset used to return "true" on success (and false on
failure), which is the opposite of what most of the code base does. (But the
interpretation of true/false as return values is non-obvious anyway and thus
returning an expression adds clarity.)

Author: tautschnig

src/pointer-analysis/value_set_dereference.cpp

@@ -529,18 +529,18 @@ value_set_dereferencet::valuet value_set_dereferencet::build_reference_to(
       if(ns.follow(result.value.type())!=ns.follow(dereference_type))
         result.value.make_typecast(dereference_type);
     }
-    else if(get_subexpression_at_offset(
-        root_object_subexpression,
-        o.offset(),
-        dereference_type,
-        ns))
-    {
-      // Successfully found a member, array index, or combination thereof
-      // that matches the desired type and offset:
-      result.value=root_object_subexpression;
-    }
     else
     {
+      exprt subexpr = get_subexpression_at_offset(
+        root_object_subexpression, o.offset(), dereference_type, ns);
+      if(subexpr.is_not_nil())
+      {
+        // Successfully found a member, array index, or combination thereof
+        // that matches the desired type and offset:
+        result.value = subexpr;
+        return result;
+      }
+
       // we extract something from the root object
       result.value=o.root_object();
 

src/util/pointer_offset_size.cpp

@@ -621,17 +621,18 @@ exprt build_sizeof_expr(
   return result;
 }
 
-bool get_subexpression_at_offset(
-  exprt &result,
+exprt get_subexpression_at_offset(
+  const exprt &expr,
   mp_integer offset,
   const typet &target_type_raw,
   const namespacet &ns)
 {
+  exprt result = expr;
   const typet &source_type=ns.follow(result.type());
   const typet &target_type=ns.follow(target_type_raw);
 
   if(offset==0 && source_type==target_type)
-    return true;
+    return result;
 
   if(source_type.id()==ID_struct)
   {
@@ -658,7 +659,7 @@ bool get_subexpression_at_offset(
       }
       ++offsets;
     }
-    return false;
+    return nil_exprt();
   }
   else if(source_type.id()==ID_array)
   {
@@ -667,26 +668,27 @@ bool get_subexpression_at_offset(
     const auto &at=to_array_type(source_type);
     mp_integer elem_size=pointer_offset_size(at.subtype(), ns);
     if(elem_size==-1)
-      return false;
+      return nil_exprt();
     mp_integer cellidx=offset/elem_size;
     if(cellidx < 0 || !cellidx.is_long())
-      return false;
+      return nil_exprt();
     offset=offset%elem_size;
     result=index_exprt(result, from_integer(cellidx, unsignedbv_typet(64)));
     return get_subexpression_at_offset(result, offset, target_type, ns);
   }
   else
-    return false;
+    return nil_exprt();
 }
 
-bool get_subexpression_at_offset(
-  exprt &result,
+exprt get_subexpression_at_offset(
+  const exprt &expr,
   const exprt &offset,
   const typet &target_type,
   const namespacet &ns)
 {
   mp_integer offset_const;
   if(to_integer(offset, offset_const))
-    return false;
-  return get_subexpression_at_offset(result, offset_const, target_type, ns);
+    return nil_exprt();
+
+  return get_subexpression_at_offset(expr, offset_const, target_type, ns);
 }

src/util/pointer_offset_size.h

@@ -81,14 +81,14 @@ exprt build_sizeof_expr(
   const constant_exprt &expr,
   const namespacet &ns);
 
-bool get_subexpression_at_offset(
-  exprt &result,
+exprt get_subexpression_at_offset(
+  const exprt &expr,
   mp_integer offset,
   const typet &target_type,
   const namespacet &ns);
 
-bool get_subexpression_at_offset(
-  exprt &result,
+exprt get_subexpression_at_offset(
+  const exprt &expr,
   const exprt &offset,
   const typet &target_type,
   const namespacet &ns);