type simplify_unary_minus

This improves memory safety.

Author: kroening

src/util/simplify_expr.cpp

@@ -2209,7 +2209,7 @@ bool simplify_exprt::simplify_node(exprt &expr)
   }
   else if(expr.id()==ID_unary_minus)
   {
-    r = simplify_unary_minus(expr);
+    r = simplify_unary_minus(to_unary_minus_expr(expr));
   }
   else if(expr.id()==ID_unary_plus)
   {

src/util/simplify_expr_class.h

@@ -57,6 +57,7 @@ class sign_exprt;
 class tvt;
 class typecast_exprt;
 class unary_exprt;
+class unary_minus_exprt;
 
 #define forall_value_list(it, value_list) \
   for(simplify_exprt::value_listt::const_iterator it=(value_list).begin(); \
@@ -169,7 +170,7 @@ class simplify_exprt
   NODISCARD resultt<> simplify_same_object(const exprt &);
   NODISCARD resultt<> simplify_good_pointer(const exprt &);
   NODISCARD resultt<> simplify_object(const exprt &);
-  NODISCARD resultt<> simplify_unary_minus(const exprt &);
+  NODISCARD resultt<> simplify_unary_minus(const unary_minus_exprt &);
   NODISCARD resultt<> simplify_unary_plus(const exprt &);
   NODISCARD resultt<> simplify_dereference(const dereference_exprt &);
   NODISCARD resultt<> simplify_address_of(const address_of_exprt &);

src/util/simplify_expr_int.cpp

@@ -1120,39 +1120,34 @@ simplify_exprt::resultt<> simplify_exprt::simplify_unary_plus(const exprt &expr)
 }
 
 simplify_exprt::resultt<>
-simplify_exprt::simplify_unary_minus(const exprt &expr)
+simplify_exprt::simplify_unary_minus(const unary_minus_exprt &expr)
 {
-  if(expr.operands().size()!=1)
-    return unchanged(expr);
-
   if(!is_number(expr.type()))
     return unchanged(expr);
 
-  const exprt &operand = expr.op0();
+  const exprt &operand = expr.op();
 
   if(expr.type()!=operand.type())
     return unchanged(expr);
 
   if(operand.id()==ID_unary_minus)
   {
     // cancel out "-(-x)" to "x"
-    if(operand.operands().size()!=1)
-      return unchanged(expr);
-
-    if(!is_number(operand.op0().type()))
+    if(!is_number(to_unary_minus_expr(operand).op().type()))
       return unchanged(expr);
 
-    return expr.op0().op0();
+    return to_unary_minus_expr(operand).op();
   }
   else if(operand.id()==ID_constant)
   {
     const irep_idt &type_id=expr.type().id();
+    const auto &constant_expr = to_constant_expr(operand);
 
     if(type_id==ID_integer ||
        type_id==ID_signedbv ||
        type_id==ID_unsignedbv)
     {
-      const auto int_value = numeric_cast<mp_integer>(expr.op0());
+      const auto int_value = numeric_cast<mp_integer>(constant_expr);
 
       if(!int_value.has_value())
         return unchanged(expr);
@@ -1162,20 +1157,20 @@ simplify_exprt::simplify_unary_minus(const exprt &expr)
     else if(type_id==ID_rational)
     {
       rationalt r;
-      if(to_rational(expr.op0(), r))
+      if(to_rational(constant_expr, r))
         return unchanged(expr);
 
       return from_rational(-r);
     }
     else if(type_id==ID_fixedbv)
     {
-      fixedbvt f(to_constant_expr(expr.op0()));
+      fixedbvt f(constant_expr);
       f.negate();
       return f.to_expr();
     }
     else if(type_id==ID_floatbv)
     {
-      ieee_floatt f(to_constant_expr(expr.op0()));
+      ieee_floatt f(constant_expr);
       f.negate();
       return f.to_expr();
     }