`std.mem.zeroes` does not zero entire `extern union`

[Jarred-Sumner]

Zig Version

0.12.0-dev.163+6780a6bbf

Steps to Reproduce and Observed Behavior

1. Run zig test repro.zig

const Union = extern union {
 foo: u32,
 bar: f64,
};

const std = @import("std");
test {
 var a = std.mem.zeroes(Union);
 try std.testing.expectEqual(@as(f64, @bitCast(a)), 0.0);
}

2. Test fails:

Test [1/1] test_0... expected 2.121995791e-314, found 0.0e+00
Test [1/1] test_0... FAIL (TestExpectedEqual)
/Users/jarred/zig/0.12.0-dev.163+6780a6bbf/files/lib/std/testing.zig:84:17: 0x10483c7fb in expectEqual__anon_1277 (test)
 return error.TestExpectedEqual;
 ^
/Users/jarred/Desktop/repro.zig:9:5: 0x10483c9a3 in test_0 (test)
 try std.testing.expectEqual(@as(f64, @bitCast(a)), 0.0);
 ^
0 passed; 0 skipped; 1 failed.
error: the following test command failed with exit code 1:
/Users/jarred/Code/bun/zig-cache/o/abfa20c47b954fb9fb1e2825bfe8f879/tes

Expected Behavior

The name zeroes implies it is zero-ing the bytes, but it is not zero-ing the bytes.

For an extern union, it is assigning a default value for the first field and ignoring the rest of the bytes. That causes the test above to fail.

However, it also leaves alignment bytes undefined, causing this test snippet to fail:

const Padded = struct {
 foo: u32,
 bar: f64 align(128),
};

const std = @import("std");
test {
 var a = std.mem.zeroes(Padded);
 var bytes = std.mem.asBytes(&a);
 for (bytes) |b| {
 std.debug.assert(b == 0);
 }
}

Partially relevant issues:

• bun update always change lockb file oven-sh/bun#5888
• bun.lockb always changes on bun install on 0.8.1 oven-sh/bun#4319

I suggest either renaming std.mem.zeroes to std.mem.init to more clearly say what it is doing, or to make it actually do @memset(bytes, 0)

It would be very helpful for serialization code if there was a way to always zero-initialize a struct/union by default (including when using Struct{} ) or to specify a container should always be zero-initialized

[rohlem]

While the first issue of not initializing the largest union member also looks like an implementation flaw of the function to me,

it also leaves alignment bytes undefined

I'm not sure whether there's been a clear decision on whether/how/when accessing padding bits/bytes in Zig is allowed, or to be more precise what the effects are.
For example, in a struct copy a = b;, I think it's valid to assume that the compiler generates code that does the minimal work (only writes bytes it needs to write - which would not have to include padding).
In my mind the same goes for function results - including the result of std.mem.zeroes/init - padding would be undefined (up to the compiler).

Therefore it's not clear to me that this detail could even be implemented in userspace today without answering language design questions.
A workaround might be to change the return type to a union with the full backing storage including padding - then that one could indeed be initialized to all-0-bits.
(The caller would still have to propagate the value as this new type).

[lsculv]

As far as padding is concerned,std.mem.zeroes mentions the C language specification for how it is initializing an extern union. C11 and on explicitly state that:

if [an object that has static duration is not initialized explicitly] is a union, the first named member is initialized (recursively) according to these rules, and any padding is initialized to zero bits;
- Section 6.7.9 Initialization, Point 10

Here's a link to the first freely available standard draft that I can find containing that language.

I don't actually know if this is relevant though, the C langauge specification only mentions these rules relating to objects that are not explicitly initialized. std.mem.zeroes certainly seems like an explicit initializtion so I don't see how conforming to the C langauge spec matters here.

I agree with @Jarred-Sumner that if this is the desired behavior then the function should be renamed to something like init, but an actual zeroes function would be useful. In that case it would be possible to enforce the expected behavior by initializing the largest field of the union instead.

[jayschwa]

For an extern struct, mem.zeroes simply casts it to bytes and zeroes them out without any regard for its fields. Perhaps it should do the same for extern union.

zig/lib/std/mem.zig

Lines 249 to 252 in 2adb932

	if (struct_info.layout == .Extern) {
	var item: T = undefined;
	@memset(asBytes(&item), 0);
	return item;

[jayschwa]

I think the only argument against indiscriminately @memseting the entire thing to zero is if Zig does / will ever support null pointers with internal representations that are non-zero.

[jayschwa]

I think the only argument against indiscriminately @memseting the entire thing to zero is if Zig does / will ever support null pointers with internal representations that are non-zero.

I've drafted PR #17286, which I think will resolve this issue. It initially zeroes out an extern struct or extern union with @memset. Then it recursively initializes the (first) field(s). This should ensure the padding is zeroed out while also doing the correct thing in a probably non-existent, weirdo edge case where null pointers are non-zero.

PR #17215 is a prerequisite that has to be merged first though.