Merge pull request #14000 from jacobly0/zero-bit-fields

codegen: fix taking the address of a field in a zero-bit struct

2 files changed, 45 insertions, 13 deletions

diff --git a/test/behavior/bugs/3742.zig b/test/behavior/bugs/3742.zig
index ab5ee92023..a984f0d8e4 100644
--- a/test/behavior/bugs/3742.zig
+++ b/test/behavior/bugs/3742.zig
@@ -39,5 +39,7 @@ test "fixed" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_llvm and
+        builtin.cpu.arch == .aarch64 and builtin.os.tag == .windows) return error.SkipZigTest;
     ArgSerializer.serializeCommand(GET.init("banana"));
 }
diff --git a/test/behavior/struct.zig b/test/behavior/struct.zig
index db7092ab82..b6567b14c3 100644
--- a/test/behavior/struct.zig
+++ b/test/behavior/struct.zig
@@ -1359,23 +1359,53 @@ test "under-aligned struct field" {
     try expect(result == 1234);
 }
 
-test "address of zero-bit field is equal to address of only field" {
+test "fieldParentPtr of a zero-bit field" {
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
-    {
-        const A = struct { b: void = {}, u: u8 };
-        var a = A{ .u = 0 };
-        const a_ptr = @fieldParentPtr(A, "b", &a.b);
-        try std.testing.expectEqual(&a, a_ptr);
-    }
-    {
-        const A = struct { u: u8, b: void = {} };
-        var a = A{ .u = 0 };
-        const a_ptr = @fieldParentPtr(A, "b", &a.b);
-        try std.testing.expectEqual(&a, a_ptr);
-    }
+    const S = struct {
+        fn testStruct(comptime A: type) !void {
+            {
+                const a = A{ .u = 0 };
+                const b_ptr = &a.b;
+                const a_ptr = @fieldParentPtr(A, "b", b_ptr);
+                try std.testing.expectEqual(&a, a_ptr);
+            }
+            {
+                var a = A{ .u = 0 };
+                const b_ptr = &a.b;
+                const a_ptr = @fieldParentPtr(A, "b", b_ptr);
+                try std.testing.expectEqual(&a, a_ptr);
+            }
+        }
+        fn testNestedStruct(comptime A: type) !void {
+            {
+                const a = A{ .u = 0 };
+                const c_ptr = &a.b.c;
+                const b_ptr = @fieldParentPtr(@TypeOf(a.b), "c", c_ptr);
+                try std.testing.expectEqual(&a.b, b_ptr);
+                const a_ptr = @fieldParentPtr(A, "b", b_ptr);
+                try std.testing.expectEqual(&a, a_ptr);
+            }
+            {
+                var a = A{ .u = 0 };
+                const c_ptr = &a.b.c;
+                const b_ptr = @fieldParentPtr(@TypeOf(a.b), "c", c_ptr);
+                try std.testing.expectEqual(&a.b, b_ptr);
+                const a_ptr = @fieldParentPtr(A, "b", b_ptr);
+                try std.testing.expectEqual(&a, a_ptr);
+            }
+        }
+        fn doTheTest() !void {
+            try testStruct(struct { b: void = {}, u: u8 });
+            try testStruct(struct { u: u8, b: void = {} });
+            try testNestedStruct(struct { b: struct { c: void = {} } = .{}, u: u8 });
+            try testNestedStruct(struct { u: u8, b: struct { c: void = {} } = .{} });
+        }
+    };
+    try S.doTheTest();
+    comptime try S.doTheTest();
 }
 
 test "struct field has a pointer to an aligned version of itself" {