introduce pointer_object_exprt

This introduces a class for an expression that is already in use, i.e.,
merely documenting it.

Author: kroening

src/goto-instrument/contracts/instrument_spec_assigns.cpp

@@ -468,7 +468,7 @@ car_exprt instrument_spec_assignst::create_car_expr(
 
   if(target.id() == ID_pointer_object)
   {
-    const auto &arg = to_unary_expr(target).op();
+    const auto &arg = to_pointer_object_expr(target).pointer();
     return {
       condition,
       target,

src/goto-instrument/contracts/utils.cpp

@@ -69,7 +69,8 @@ void havoc_assigns_targetst::append_havoc_code_for_expr(
 {
   if(expr.id() == ID_pointer_object)
   {
-    append_object_havoc_code_for_expr(location, expr.operands().front(), dest);
+    append_object_havoc_code_for_expr(
+      location, to_pointer_object_expr(expr).pointer(), dest);
     return;
   }
 

src/solvers/flattening/bv_pointers.cpp

@@ -713,17 +713,18 @@ bvt bv_pointerst::convert_bitvector(const exprt &expr)
   }
   else if(
     expr.id() == ID_pointer_object &&
-    to_unary_expr(expr).op().type().id() == ID_pointer)
+    to_pointer_object_expr(expr).pointer().type().id() == ID_pointer)
   {
     std::size_t width=boolbv_width(expr.type());
 
     if(width==0)
       return conversion_failed(expr);
 
-    const exprt &op0 = to_unary_expr(expr).op();
-    const bvt &op0_bv = convert_bv(op0);
+    const exprt &pointer = to_pointer_object_expr(expr).pointer();
+    const bvt &pointer_bv = convert_bv(pointer);
 
-    bvt object_bv = object_literals(op0_bv, to_pointer_type(op0.type()));
+    bvt object_bv =
+      object_literals(pointer_bv, to_pointer_type(pointer.type()));
 
     return bv_utils.zero_extension(object_bv, width);
   }

src/solvers/smt2/smt2_conv.cpp

@@ -1589,7 +1589,7 @@ void smt2_convt::convert_expr(const exprt &expr)
   }
   else if(expr.id()==ID_pointer_object)
   {
-    const auto &op = to_unary_expr(expr).op();
+    const auto &op = to_pointer_object_expr(expr).pointer();
 
     DATA_INVARIANT(
       op.type().id() == ID_pointer,

src/util/pointer_expr.h

@@ -931,4 +931,62 @@ inline pointer_offset_exprt &to_pointer_offset_expr(exprt &expr)
   return ret;
 }
 
+/// A numerical identifier for the object a pointer points to
+class pointer_object_exprt : public unary_exprt
+{
+public:
+  explicit pointer_object_exprt(exprt pointer, typet type)
+    : unary_exprt(ID_pointer_object, std::move(pointer), std::move(type))
+  {
+  }
+
+  exprt &pointer()
+  {
+    return op0();
+  }
+
+  const exprt &pointer() const
+  {
+    return op0();
+  }
+};
+
+template <>
+inline bool can_cast_expr<pointer_object_exprt>(const exprt &base)
+{
+  return base.id() == ID_pointer_object;
+}
+
+inline void validate_expr(const pointer_object_exprt &value)
+{
+  validate_operands(value, 1, "pointer_object must have one operand");
+  DATA_INVARIANT(
+    value.pointer().type().id() == ID_pointer,
+    "pointer_object must have pointer-typed operand");
+}
+
+/// \brief Cast an exprt to a \ref pointer_object_exprt
+///
+/// \a expr must be known to be \ref pointer_object_exprt.
+///
+/// \param expr: Source expression
+/// \return Object of type \ref pointer_object_exprt
+inline const pointer_object_exprt &to_pointer_object_expr(const exprt &expr)
+{
+  PRECONDITION(expr.id() == ID_pointer_object);
+  const pointer_object_exprt &ret =
+    static_cast<const pointer_object_exprt &>(expr);
+  validate_expr(ret);
+  return ret;
+}
+
+/// \copydoc to_pointer_object_expr(const exprt &)
+inline pointer_object_exprt &to_pointer_object_expr(exprt &expr)
+{
+  PRECONDITION(expr.id() == ID_pointer_object);
+  pointer_object_exprt &ret = static_cast<pointer_object_exprt &>(expr);
+  validate_expr(ret);
+  return ret;
+}
+
 #endif // CPROVER_UTIL_POINTER_EXPR_H

src/util/pointer_predicates.cpp

@@ -22,7 +22,7 @@ Author: Daniel Kroening, kroening@kroening.com
 
 exprt pointer_object(const exprt &p)
 {
-  return unary_exprt(ID_pointer_object, p, size_type());
+  return pointer_object_exprt(p, size_type());
 }
 
 exprt same_object(const exprt &p1, const exprt &p2)

src/util/simplify_expr.cpp

@@ -2388,7 +2388,7 @@ simplify_exprt::resultt<> simplify_exprt::simplify_node(exprt node)
   }
   else if(expr.id()==ID_pointer_object)
   {
-    r = simplify_pointer_object(to_unary_expr(expr));
+    r = simplify_pointer_object(to_pointer_object_expr(expr));
   }
   else if(expr.id() == ID_is_dynamic_object)
   {

src/util/simplify_expr_class.h

@@ -59,6 +59,7 @@ class mult_exprt;
 class namespacet;
 class not_exprt;
 class plus_exprt;
+class pointer_object_exprt;
 class pointer_offset_exprt;
 class popcount_exprt;
 class refined_string_exprt;
@@ -171,7 +172,7 @@ class simplify_exprt
   NODISCARD resultt<> simplify_member(const member_exprt &);
   NODISCARD resultt<> simplify_byte_update(const byte_update_exprt &);
   NODISCARD resultt<> simplify_byte_extract(const byte_extract_exprt &);
-  NODISCARD resultt<> simplify_pointer_object(const unary_exprt &);
+  NODISCARD resultt<> simplify_pointer_object(const pointer_object_exprt &);
   NODISCARD resultt<> simplify_object_size(const unary_exprt &);
   NODISCARD resultt<> simplify_is_dynamic_object(const unary_exprt &);
   NODISCARD resultt<> simplify_is_invalid_pointer(const unary_exprt &);

src/util/simplify_expr_pointer.cpp

@@ -481,7 +481,7 @@ simplify_exprt::resultt<> simplify_exprt::simplify_inequality_pointer_object(
   forall_operands(it, expr)
   {
     PRECONDITION(it->id() == ID_pointer_object);
-    const exprt &op = to_unary_expr(*it).op();
+    const exprt &op = to_pointer_object_expr(*it).pointer();
 
     if(op.id()==ID_address_of)
     {
@@ -516,9 +516,9 @@ simplify_exprt::resultt<> simplify_exprt::simplify_inequality_pointer_object(
 }
 
 simplify_exprt::resultt<>
-simplify_exprt::simplify_pointer_object(const unary_exprt &expr)
+simplify_exprt::simplify_pointer_object(const pointer_object_exprt &expr)
 {
-  const exprt &op = expr.op();
+  const exprt &op = expr.pointer();
 
   auto op_result = simplify_object(op);