Commit fc1c83a363d32e749b9061044db63852ab7255d0 | zig

author	Matthew Lugg <mlugg@mlugg.co.uk> 2026-05-06 11:01:16+01:00
committer	Matthew Lugg <mlugg@mlugg.co.uk> 2026-05-07 06:21:59+02:00
log	fc1c83a363d32e749b9061044db63852ab7255d0
tree	6879df0fe06eab250156898dbf8928cbd8159ff1
parent	0bcf29aff6e4ed536406634f03f7bf61eda1a2b8

Air: fix legalization of packed struct init with OPV field

I have verified that this fixes *both* of the reproductions given in
https://codeberg.org/ziglang/zig/issues/31837 (they were the same bug).

Resolves: https://codeberg.org/ziglang/zig/issues/31837

2 files changed, 38 insertions(+), 10 deletions(-)

src
- Air
  - Legalize.zig
test
- behavior
  - bitcast.zig

src/Air/Legalize.zig+22-10

 @@ -853,14 +853,24 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void {
                     .@"union" => unreachable,
                     .@"struct" => switch (agg_ty.containerLayout(zcu)) {
                         .auto, .@"extern" => {},
-                        .@"packed" => switch (agg_ty.structFieldCount(zcu)) {
+                        .@"packed" => {
-                            0 => unreachable,
+                            // If any field accounts for the full bit size of the struct, this init
-                            // An `aggregate_init` of a packed struct with 1 field is just a fancy bitcast.
+                            // is just equivalent to a bitcast of that field. This usually means the
-                            1 => continue :inst l.replaceInst(inst, .bitcast, .{ .ty_op = .{
+                            // field count is 1, but not always, as there could be zero-bit fields.
-                                .ty = .fromType(agg_ty),
+                            const struct_bits = agg_ty.bitSize(zcu);
-                                .operand = @enumFromInt(l.air_extra.items[ty_pl.payload]),
+                            for (0..agg_ty.structFieldCount(zcu)) |field_index| {
-                            } }),
+                                const field_bits = agg_ty.fieldType(field_index, zcu).bitSize(zcu);
-                            else => continue :inst l.replaceInst(inst, .block, try l.packedAggregateInitBlockPayload(inst)),
+                                if (field_bits == struct_bits) {
+                                    // Just bitcast this field.
+                                    continue :inst l.replaceInst(inst, .bitcast, .{ .ty_op = .{
+                                        .ty = .fromType(agg_ty),
+                                        .operand = @enumFromInt(l.air_extra.items[ty_pl.payload + field_index]),
+                                    } });
+                                }
+                            }
+                            // Otherwise, we will need to use a sequence of bitcasts and shifts to
+                            // combine multiple values' bits.
+                            continue :inst l.replaceInst(inst, .block, try l.packedAggregateInitBlockPayload(inst));
                         },
                     },
                 }
 @@ -2513,8 +2523,10 @@ fn packedAggregateInitBlockPayload(l: *Legalize, orig_inst: Air.Inst.Index) Erro
     while (field_idx > 0) {
         field_idx -= 1;
         const field_ty = agg_ty.fieldType(field_idx, zcu);
-        const field_uint_ty = try pt.intType(.unsigned, @intCast(field_ty.bitSize(zcu)));
+        const field_bits: u16 = @intCast(field_ty.bitSize(zcu));
-        const field_bit_size_ref: Air.Inst.Ref = .fromValue(try pt.intValue(shift_ty, field_ty.bitSize(zcu)));
+        assert(field_bits < num_bits);
+        const field_uint_ty = try pt.intType(.unsigned, field_bits);
+        const field_bit_size_ref: Air.Inst.Ref = .fromValue(try pt.intValue(shift_ty, field_bits));
         const field_val: Air.Inst.Ref = @enumFromInt(l.air_extra.items[orig_ty_pl.payload + field_idx]);
         const shifted = main_block.addBinOp(l, .shl_exact, cur_uint, field_bit_size_ref).toRef();

test/behavior/bitcast.zig+16

...	@@ -591,3 +591,19 @@ test "@bitCast of float to extern struct" {	...	@@ -591,3 +591,19 @@ test "@bitCast of float to extern struct" {
591	try S.doTheTest();	591	try S.doTheTest();
592	try comptime S.doTheTest();	592	try comptime S.doTheTest();
593	}	593	}
		594
		595	test "@bitCast of packed struct with void field to integer" {
		596	const S = packed struct(u8) {
		597	v: void,
		598	x: u8,
		599
		600	fn doTheTest(x: u8) !void {
		601	// Intentionally using `@as` to avoid RLS which masks the bug
		602	const foo = @as(@This(), .{ .v = {}, .x = x });
		603	const as_int: u8 = @bitCast(foo);
		604	try expect(as_int == x);
		605	}
		606	};
		607	try S.doTheTest(123);
		608	try comptime S.doTheTest(123);
		609	}