Commit b9852d23089a524dafaa2487f207457b2a183af1 | zig

author	Ryan Mehri <ryan.mehri1@gmail.com> 2026-08-04 11:43:46-04:00
committer	Matthew Lugg <mlugg@mlugg.co.uk> 2026-08-07 15:29:04+02:00
log	b9852d23089a524dafaa2487f207457b2a183af1
tree	6f39d844db264505e301b12eb6fabc405fee702f
parent	17e07ffc6381a1650b6bac5948b9f22d24411982

Legalize: fix packed struct with OPV and multiple other fields

In legalization for packed struct init with an OPV field, we first try 
to see if any field accounts for the entire bit size of the struct and
otherwise fall back to a sequence of bitcasts and shifts on each field
(added in fc1c83a363d). However, OPV fields are not accounted for
in the fallback case, which means that codegen eventually panics when
seeing the bit size of 0.

This change makes it so that we ignore all OPV fields in
`packedAggregateInitBlockPayload` since they have no runtime bits.

2 files changed, 24 insertions(+), 1 deletions(-)

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

src/Air/Legalize.zig+8-1

 @@ -2906,12 +2906,18 @@ fn packedAggregateInitBlockPayload(l: *Legalize, orig_inst: Air.Inst.Index) Erro
     const orig_ty_pl = l.air_instructions.items(.data)[@backingInt(orig_inst)].ty_pl;
     const agg_ty = orig_ty_pl.ty.toType();
     const agg_field_count = agg_ty.structFieldCount(zcu);
+    var opv_field_count: u32 = 0;
+    for (0..agg_field_count) |field_idx| {
+        const field_ty = agg_ty.fieldType(field_idx, zcu);
+        const field_bits: u16 = @intCast(field_ty.bitSize(zcu));
+        if (field_bits == 0) opv_field_count += 1;
+    }
     var bfa_buf: [4 * 32 + 2]Air.Inst.Index = undefined;
     var bfa_state: std.heap.BufferFirstAllocator = .init(@ptrCast(&bfa_buf), gpa);
     const bfa = bfa_state.allocator();
-    const inst_buf = try bfa.alloc(Air.Inst.Index, 4 * agg_field_count + 2);
+    const inst_buf = try bfa.alloc(Air.Inst.Index, 4 * (agg_field_count - opv_field_count) + 2);
     defer bfa.free(inst_buf);
     var main_block: Block = .init(inst_buf);
 @@ -2927,6 +2933,7 @@ fn packedAggregateInitBlockPayload(l: *Legalize, orig_inst: Air.Inst.Index) Erro
         field_idx -= 1;
         const field_ty = agg_ty.fieldType(field_idx, zcu);
         const field_bits: u16 = @intCast(field_ty.bitSize(zcu));
+        if (field_bits == 0) continue;
         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));

test/behavior/bitcast.zig+16

...	@@ -432,6 +432,22 @@ test "@bitCast of packed struct with void field to integer" {	...	@@ -432,6 +432,22 @@ test "@bitCast of packed struct with void field to integer" {
432	try comptime S.doTheTest(123);	432	try comptime S.doTheTest(123);
433	}	433	}
434		434
		435	test "@bitCast of packed struct with void field and multiple integers" {
		436	const S = packed struct {
		437	x: u8,
		438	v: void,
		439	y: u8,
		440
		441	fn doTheTest(x: u8, y: u8) !void {
		442	const foo = @as(@This(), .{ .x = x, .v = {}, .y = y });
		443	const as_int: u16 = @bitCast(foo);
		444	try expect(as_int == @as(u16, y) << 8 \| x);
		445	}
		446	};
		447	try S.doTheTest(123, 45);
		448	try comptime S.doTheTest(123, 45);
		449	}
		450
435	test "@bitCast vector to array with different element size" {	451	test "@bitCast vector to array with different element size" {
436	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	452	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
437		453