Partly revert "Simplify initializer to remove byte_update"

This reverts commit ac31213, which can
break dump-c output: the simplified expression may have padding
initialised to non-zero values. This works fine for any analysis, but
breaks dump-c as padding is not included in the output.

Found via tests generated CSmith, a minimised version of which is
included as a regression test.

Author: tautschnig

regression/goto-instrument/dump-union2/main.c

@@ -0,0 +1,27 @@
+#include <assert.h>
+
+struct S2
+{
+  signed char f0;
+  unsigned short f1;
+};
+
+union U10 {
+  unsigned short f0;
+  struct S2 f3;
+};
+
+union U10 g_2110 = {.f0 = 53747};
+
+union U6 {
+  signed f0 : 3;
+};
+
+union U6 g_1197 = {1L};
+
+int main()
+{
+  assert(g_2110.f0 == 53747);
+
+  return 0;
+}

regression/goto-instrument/dump-union2/test.desc

@@ -0,0 +1,11 @@
+CORE
+main.c
+--dump-c
+VERIFICATION SUCCESSFUL
+^EXIT=0$
+^SIGNAL=0$
+--
+^warning: ignoring
+--
+This test must verify successfully also for the output generated using dump-c,
+which previously did not correctly represent the union initializer.

src/ansi-c/c_typecheck_initializer.cpp

@@ -72,10 +72,7 @@ exprt c_typecheck_baset::do_initializer_rec(
   }
 
   if(value.id()==ID_initializer_list)
-  {
-    return simplify_expr(
-      do_initializer_list(value, type, force_constant), *this);
-  }
+    return do_initializer_list(value, type, force_constant);
 
   if(
     value.id() == ID_array && value.get_bool(ID_C_string_constant) &&

src/goto-instrument/dump_c.cpp

@@ -13,6 +13,7 @@ Author: Daniel Kroening, [email protected]
 
 #include <util/byte_operators.h>
 #include <util/config.h>
+#include <util/expr_initializer.h>
 #include <util/find_symbols.h>
 #include <util/get_base_name.h>
 #include <util/invariant.h>
@@ -1467,6 +1468,24 @@ void dump_ct::cleanup_expr(exprt &expr)
         }
       }
     }
+    else if(
+      ns.follow(bu.type()).id() == ID_union &&
+      bu.source_location().get_function().empty() &&
+      bu.op() == zero_initializer(bu.op().type(), source_locationt{}, ns)
+                   .value_or(nil_exprt{}))
+    {
+      const union_typet &union_type = to_union_type(ns.follow(bu.type()));
+
+      for(const auto &comp : union_type.components())
+      {
+        if(bu.value().type() == comp.type())
+        {
+          union_exprt union_expr{comp.get_name(), bu.value(), bu.type()};
+          expr.swap(union_expr);
+          break;
+        }
+      }
+    }
   }
 }