Commit 897c0b35a92dba851edd2ce49314468d3e1fcaff | zig

author	Jacob Young <jacobly@ziglang.org> 2026-06-28 15:19:23-04:00
committer	Jacob Young <jacobly@ziglang.org> 2026-07-27 14:35:12-04:00
log	897c0b35a92dba851edd2ce49314468d3e1fcaff
tree	d9a869dc8ce9331fdabec5b98595a420bd60e3a5
parent	d01609af2aaf5a3c9ddd2ddf75a5d211e0e94b07

Revert "cbe: improve struct/union defs on 32-bit targets"

This reverts commit 5434f85c47f6412a8d5faf681419c15533bb388c, which was
just hacking around other bugs.

2 files changed, 29 insertions(+), 61 deletions(-)

src
- Type.zig
- codegen
  - c
    type
    render_defs.zig

src/Type.zig+1-1

...	@@ -962,7 +962,7 @@ pub fn abiAlignment(ty: Type, zcu: *const Zcu) Alignment {	...	@@ -962,7 +962,7 @@ pub fn abiAlignment(ty: Type, zcu: *const Zcu) Alignment {
962	const bytes = ((elem_bits * vector_type.len) + 7) / 8;	962	const bytes = ((elem_bits * vector_type.len) + 7) / 8;
963	return .fromByteUnits(std.math.ceilPowerOfTwoAssert(u32, bytes));	963	return .fromByteUnits(std.math.ceilPowerOfTwoAssert(u32, bytes));
964	},	964	},
965	.stage2_c, .stage2_wasm => return Type.fromInterned(vector_type.child).defaultStructFieldAlignment(.auto, zcu),	965	.stage2_c, .stage2_wasm => return Type.fromInterned(vector_type.child).abiAlignment(zcu),
966	.stage2_x86_64 => {	966	.stage2_x86_64 => {
967	if (vector_type.child == .bool_type) {	967	if (vector_type.child == .bool_type) {
968	if (vector_type.len > 256 and target.cpu.has(.x86, .avx512f)) return .@"64";	968	if (vector_type.len > 256 and target.cpu.has(.x86, .avx512f)) return .@"64";

src/codegen/c/type/render_defs.zig+28-60

 @@ -284,9 +284,8 @@ pub fn defineComplete(
             },
         },
         .array => if (ty.hasRuntimeBits(zcu)) {
-            const elem_ty = ty.childType(zcu);
             const name_cty: CType = .{ .arr = ty };
-            const elem_cty: CType = try .lower(elem_ty, deps, arena, zcu);
+            const elem_cty: CType = try .lower(ty.childType(zcu), deps, arena, zcu);
             const array_cty: CType = .{ .array = .{
                 .len = ty.arrayLenIncludingSentinel(zcu),
                 .elem_ty = &elem_cty,
 @@ -296,28 +295,17 @@ pub fn defineComplete(
                     break :nonstring Value.compareHetero(s, .neq, .zero_comptime_int, zcu);
                 },
             } };
-            if (elem_ty.defaultStructFieldAlignment(.auto, zcu) == elem_ty.abiAlignment(zcu)) {
+            try w.print("{f} {{ {f}array{f}; }}; /* {f} */\n", .{
-                try w.print("{f} {{ {f}array{f}; }}; /* {f} */\n", .{
+                name_cty.fmtTypeName(zcu),
-                    name_cty.fmtTypeName(zcu),
+                array_cty.fmtDeclaratorPrefix(zcu),
-                    array_cty.fmtDeclaratorPrefix(zcu),
+                array_cty.fmtDeclaratorSuffix(zcu),
-                    array_cty.fmtDeclaratorSuffix(zcu),
+                ty.fmt(pt),
-                    ty.fmt(pt),
+            });
-                });
-            } else {
-                try w.print("zig_packed({f} {{ zig_under_align({d}) {f}array{f}; }}); /* {f} */\n", .{
-                    name_cty.fmtTypeName(zcu),
-                    elem_ty.abiAlignment(zcu).toByteUnits().?,
-                    array_cty.fmtDeclaratorPrefix(zcu),
-                    array_cty.fmtDeclaratorSuffix(zcu),
-                    ty.fmt(pt),
-                });
-            }
             try writeStaticAssertLayout(ty, name_cty, w, zcu);
         },
         .vector => if (ty.hasRuntimeBits(zcu)) {
-            const elem_ty = ty.childType(zcu);
             const name_cty: CType = .{ .vec = ty };
-            const elem_cty: CType = try .lower(elem_ty, deps, arena, zcu);
+            const elem_cty: CType = try .lower(ty.childType(zcu), deps, arena, zcu);
             const array_cty: CType = .{ .array = .{
                 .len = ty.arrayLenIncludingSentinel(zcu),
                 .elem_ty = &elem_cty,
 @@ -363,39 +351,21 @@ fn defineTuple(
     const ip = &zcu.intern_pool;
     const tuple = ip.indexToKey(ty.toIntern()).tuple_type;
-    const tuple_align = ty.abiAlignment(zcu);
+    // Fields cannot be underaligned, because tuple fields cannot have specified alignments.
+    // However, overaligned fields are possible thanks to intermediate zero-bit fields.
-    // If there are any underaligned fields, we need to byte-pack the tuple.
+    const tuple_align = ty.abiAlignment(zcu);
-    const pack: bool = pack: {
-        var offset: u64 = 0;
-        for (tuple.types.get(ip)) |field_ty_ip| {
-            const field_ty: Type = .fromInterned(field_ty_ip);
-            if (!field_ty.hasRuntimeBits(zcu)) continue;
-            const natural_align = field_ty.defaultStructFieldAlignment(.auto, zcu);
-            const natural_offset = natural_align.forward(offset);
-            offset = field_ty.abiAlignment(zcu).forward(offset);
-            if (offset < natural_offset) break :pack true;
-            // Also pack if any field is more aligned than the tuple should be.
-            if (natural_align.compareStrict(.gt, tuple_align)) break :pack true;
-            offset += field_ty.abiSize(zcu);
-        }
-        break :pack false;
-    };
     // If the alignment of other fields would not give the tuple sufficient alignment, we
     // need to align the first field (which does not affect its offset, because 0 is always
     // well-aligned) to indirectly specify the tuple alignment.
-    const overalign: bool = switch (pack) {
+    const overalign: bool = for (tuple.types.get(ip)) |field_ty_ip| {
-        true => tuple_align.compareStrict(.gt, .@"1"),
+        const field_ty: Type = .fromInterned(field_ty_ip);
-        false => for (tuple.types.get(ip)) |field_ty_ip| {
+        if (!field_ty.hasRuntimeBits(zcu)) continue;
-            const field_ty: Type = .fromInterned(field_ty_ip);
+        const natural_align = field_ty.defaultStructFieldAlignment(.auto, zcu);
-            if (!field_ty.hasRuntimeBits(zcu)) continue;
+        if (natural_align.compareStrict(.gte, tuple_align)) break false;
-            const natural_align = field_ty.defaultStructFieldAlignment(.auto, zcu);
+    } else true;
-            if (natural_align.compareStrict(.gte, tuple_align)) break false;
-        } else true,
-    };
-    if (pack) try w.writeAll("zig_packed(");
     const name_cty: CType = .{ .@"struct" = ty };
     try w.print("{f} {{ /* {f} */\n", .{
         name_cty.fmtTypeName(zcu),
 @@ -406,18 +376,18 @@ fn defineTuple(
     for (tuple.types.get(ip), tuple.values.get(ip), 0..) |field_ty_ip, field_val_ip, field_index| {
         if (field_val_ip != .none) continue; // `comptime` field
         const field_ty: Type = .fromInterned(field_ty_ip);
-        zig_offset = field_ty.abiAlignment(zcu).forward(zig_offset);
+        const field_align = field_ty.abiAlignment(zcu);
+        zig_offset = field_align.forward(zig_offset);
         if (!field_ty.hasRuntimeBits(zcu)) continue;
-        if (!pack) c_offset = field_ty.defaultStructFieldAlignment(.auto, zcu).forward(c_offset);
+        c_offset = field_align.forward(c_offset);
         try w.writeByte(' ');
         if (zig_offset == 0 and overalign) {
             // This is the first field; specify its alignment to align the tuple.
             try writeFieldAlign(field_ty, tuple_align, w, zcu);
         } else if (zig_offset > c_offset) {
-            // This field needs to be underaligned or overaligned compared to what its
+            // This field needs to be overaligned compared to what its offset would otherwise be.
-            // offset would otherwise be.
             const need_align: Alignment = .minStrict(
-                tuple_align, // don't make the tuple more aligned than it should be
+                tuple_align, // don't make the struct more aligned than it should be
                 .fromLog2Units(@ctz(zig_offset)),
             );
             try writeFieldAlign(field_ty, need_align, w, zcu);
 @@ -433,9 +403,7 @@ fn defineTuple(
         zig_offset += field_size;
         c_offset += field_size;
     }
-    try w.writeByte('}');
+    try w.writeAll("};\n");
-    if (pack) try w.writeByte(')');
-    try w.writeAll(";\n");
     try writeStaticAssertLayout(ty, name_cty, w, zcu);
 }
 @@ -553,7 +521,7 @@ fn defineUnionAuto(
     const pack: bool = for (union_type.field_types.get(ip)) |field_ty_ip| {
         const field_ty: Type = .fromInterned(field_ty_ip);
         if (!field_ty.hasRuntimeBits(zcu)) continue;
-        const natural_align = field_ty.defaultStructFieldAlignment(.auto, zcu);
+        const natural_align = field_ty.abiAlignment(zcu);
         if (natural_align.compareStrict(.gt, union_type.alignment)) break true;
         // The tag will immediately follow the payload. This layout may put the tag in what would
         // otherwise be padding on the payload union, because if the most-aligned union field is not
 @@ -571,7 +539,7 @@ fn defineUnionAuto(
         false => for (union_type.field_types.get(ip)) |field_ty_ip| {
             const field_ty: Type = .fromInterned(field_ty_ip);
             if (!field_ty.hasRuntimeBits(zcu)) continue;
-            const natural_align = field_ty.defaultStructFieldAlignment(.auto, zcu);
+            const natural_align = field_ty.abiAlignment(zcu);
             if (natural_align.compareStrict(.gte, union_type.alignment)) break false;
         } else overalign: {
             if (union_type.has_runtime_tag) {
 @@ -642,7 +610,7 @@ fn defineUnionExtern(
     const pack: bool = for (union_type.field_types.get(ip)) |field_ty_ip| {
         const field_ty: Type = .fromInterned(field_ty_ip);
         if (!field_ty.hasRuntimeBits(zcu)) continue;
-        const natural_align = field_ty.defaultStructFieldAlignment(.@"extern", zcu);
+        const natural_align = field_ty.abiAlignment(zcu);
         if (natural_align.compareStrict(.gt, union_type.alignment)) break true;
     } else false;
 @@ -654,7 +622,7 @@ fn defineUnionExtern(
         false => for (union_type.field_types.get(ip)) |field_ty_ip| {
             const field_ty: Type = .fromInterned(field_ty_ip);
             if (!field_ty.hasRuntimeBits(zcu)) continue;
-            const natural_align = field_ty.defaultStructFieldAlignment(.@"extern", zcu);
+            const natural_align = field_ty.abiAlignment(zcu);
             if (natural_align.compareStrict(.gte, union_type.alignment)) break false;
         } else overalign: {
             if (union_type.has_runtime_tag) {
 @@ -704,7 +672,7 @@ fn writeFieldAlign(
     w: *Writer,
     zcu: *const Zcu,
 ) Writer.Error!void {
-    if (alignment.compareStrict(.lt, ty.defaultStructFieldAlignment(.auto, zcu))) {
+    if (alignment.compareStrict(.lt, ty.abiAlignment(zcu))) {
         try w.print("zig_under_align({d}) ", .{alignment.toByteUnits().?});
     } else {
         try w.print("zig_align({d}) ", .{alignment.toByteUnits().?});