std.mem.zeroes: Improve handling of extern struct and extern union

`extern struct` will now be recursively initialized, same as `struct`.
The only difference is that the `extern` variant is initially zeroed out
to ensure its padding is also set correctly.

`extern union` is still initialized to its first named member, but its
padding (if any) is also zeroed out.

Fixes #17258

Author: jayschwa

lib/std/mem.zig

@@ -246,19 +246,16 @@ pub fn zeroes(comptime T: type) T {
         },
         .Struct => |struct_info| {
             if (@sizeOf(T) == 0) return undefined;
+            var structure: T = undefined;
             if (struct_info.layout == .Extern) {
-                var item: T = undefined;
-                @memset(asBytes(&item), 0);
-                return item;
-            } else {
-                var structure: T = undefined;
-                inline for (struct_info.fields) |field| {
-                    if (!field.is_comptime) {
-                        @field(structure, field.name) = zeroes(@TypeOf(@field(structure, field.name)));
-                    }
+                @memset(asBytes(&structure), 0); // Zero out padding.
+            }
+            inline for (struct_info.fields) |field| {
+                if (!field.is_comptime) {
+                    @field(structure, field.name) = zeroes(field.type);
                 }
-                return structure;
             }
+            return structure;
         },
         .Pointer => |ptr_info| {
             switch (ptr_info.size) {
@@ -292,13 +289,17 @@ pub fn zeroes(comptime T: type) T {
             return @splat(zeroes(info.child));
         },
         .Union => |info| {
-            if (comptime meta.containerLayout(T) == .Extern) {
-                // The C language specification states that (global) unions
-                // should be zero initialized to the first named member.
-                return @unionInit(T, info.fields[0].name, zeroes(info.fields[0].type));
+            if (info.layout != .Extern) {
+                @compileError("Can't set a " ++ @typeName(T) ++ " to zero.");
             }
-
-            @compileError("Can't set a " ++ @typeName(T) ++ " to zero.");
+            // The C language specification states that (global) unions
+            // have the first named member initialized (recursively),
+            // and any padding is initialized to zero bits.
+            const field = info.fields[0];
+            var u = @unionInit(T, field.name, zeroes(field.type));
+            const padding = asBytes(&u)[@sizeOf(field.type)..];
+            if (padding.len > 0) @memset(padding, 0);
+            return u;
         },
         .ErrorUnion,
         .ErrorSet,
@@ -318,10 +319,14 @@ pub fn zeroes(comptime T: type) T {
 test "zeroes" {
     const C_struct = extern struct {
         x: u32,
-        y: u32,
+        y: u32 align(128),
     };
 
     var a = zeroes(C_struct);
+
+    // Extern structs should have padding zeroed out.
+    try testing.expectEqualSlices(u8, &[_]u8{0} ** @sizeOf(@TypeOf(a)), asBytes(&a));
+
     a.y += 10;
 
     try testing.expect(a.x == 0);
@@ -402,9 +407,11 @@ test "zeroes" {
 
     var c = zeroes(C_union);
     try testing.expectEqual(@as(u8, 0), c.a);
+    try testing.expectEqual(@as(u32, 0), c.b);
 
     comptime var comptime_union = zeroes(C_union);
     try testing.expectEqual(@as(u8, 0), comptime_union.a);
+    try testing.expectEqual(@as(u32, 0), comptime_union.b);
 
     // Ensure zero sized struct with fields is initialized correctly.
     _ = zeroes(struct { handle: void });