Replace unsound struct-cast simplification

Previously the simplifier would simplify ((struct A)x) into (x) if x.type() and A
were structurally compatible (i.e. had the same named and typed fields). However this
isn't really a sound simplification, as it changes the type of the expression. I therefore
replace the rule with one that only applies within the common-case member expression, i.e.
simplifiying ((struct A)x).y -> x.y, which does not change the type of the outer expression.

Author: smowton

src/util/simplify_expr.cpp

@@ -25,6 +25,7 @@ Author: Daniel Kroening, [email protected]
 #include "rational_tools.h"
 #include "config.h"
 #include "base_type.h"
+#include "type_eq.h"
 #include "namespace.h"
 #include "threeval.h"
 #include "pointer_predicates.h"
@@ -214,7 +215,7 @@ bool simplify_exprt::simplify_typecast(exprt &expr)
   }
 
   // eliminate redundant typecasts
-  if(base_type_eq(expr.type(), expr.op0().type(), ns))
+  if(type_eq(expr.type(), expr.op0().type(), ns))
   {
     exprt tmp;
     tmp.swap(expr.op0());

src/util/simplify_expr_struct.cpp

@@ -15,6 +15,7 @@ Author: Daniel Kroening, [email protected]
 #include "std_expr.h"
 #include "pointer_offset_size.h"
 #include "arith_tools.h"
+#include "base_type.h"
 
 bool simplify_exprt::simplify_member(exprt &expr)
 {
@@ -208,6 +209,17 @@ bool simplify_exprt::simplify_member(exprt &expr)
       }
     }
   }
+  else if(op.id() == ID_typecast)
+  {
+    // Try to look through member(cast(x)) if the cast is between structurally
+    // identical types:
+    if(base_type_eq(op_type, op.op0().type(), ns))
+    {
+      expr.op0() = op.op0();
+      simplify_member(expr);
+      return false;
+    }
+  }
   else if(op.id()==ID_if)
   {
     const if_exprt &if_expr=to_if_expr(op);