cbe: fix some miscompilations

The change to `codegen.c` is a blatant hack, but the thing it's working
around isn't a regression: it's an existing miscompilation. This branch
happened to *expose* that miscompilation in a behavior test by changing
how an incorrect result is *used*.

Author: mlugg

src/Type.zig

@@ -3556,7 +3556,7 @@ pub fn packedStructFieldPtrInfo(
     } else .{
         switch (zcu.comp.getZigBackend()) {
             else => (running_bits + 7) / 8,
-            .stage2_x86_64 => @intCast(struct_ty.abiSize(zcu)),
+            .stage2_x86_64, .stage2_c => @intCast(struct_ty.abiSize(zcu)),
         },
         bit_offset,
     };

src/codegen/c.zig

@@ -4098,9 +4098,24 @@ fn airStore(f: *Function, inst: Air.Inst.Index, safety: bool) !CValue {
     if (val_is_undef) {
         try reap(f, inst, &.{ bin_op.lhs, bin_op.rhs });
         if (safety and ptr_info.packed_offset.host_size == 0) {
+            // If the thing we're initializing is a packed struct/union, we set to 0 instead of
+            // 0xAA. This is a hack to work around a problem with partially-undefined packed
+            // aggregates. If we used 0xAA here, then a later initialization through RLS would
+            // not zero the high padding bits (for a packed type which is not 8/16/32/64/etc bits),
+            // so we would get a miscompilation. Using 0x00 here avoids this bug in some cases. It
+            // is *not* a correct fix; for instance it misses any case where packed structs are
+            // nested in other aggregates. A proper fix for this will involve changing the language,
+            // such as to remove RLS. This just prevents miscompilations in *some* common cases.
+            const byte_str: []const u8 = switch (src_ty.zigTypeTag(zcu)) {
+                else => "0xaa",
+                .@"struct", .@"union" => switch (src_ty.containerLayout(zcu)) {
+                    .auto, .@"extern" => "0xaa",
+                    .@"packed" => "0x00",
+                },
+            };
             try w.writeAll("memset(");
             try f.writeCValue(w, ptr_val, .FunctionArgument);
-            try w.writeAll(", 0xaa, sizeof(");
+            try w.print(", {s}, sizeof(", .{byte_str});
             try f.renderType(w, .fromInterned(ptr_info.child));
             try w.writeAll("));");
             try f.object.newline();

test/behavior/union.zig

@@ -1547,7 +1547,7 @@ test "packed union field pointer has correct alignment" {
 
     const host_size = switch (builtin.zig_backend) {
         else => comptime std.math.divCeil(comptime_int, @bitSizeOf(S), 8) catch unreachable,
-        .stage2_x86_64 => @sizeOf(S),
+        .stage2_x86_64, .stage2_c => @sizeOf(S),
     };
     comptime assert(@TypeOf(ap) == *align(4:2:host_size) u20);
     comptime assert(@TypeOf(bp) == *align(1:2:host_size) u20);