zig

commit 6ed0910d6d974750fe65990983d5347ceacc0186 (tree)
parent 40ed6ae8469fd599f0524d294f38365c3bb8a825
Author: Andrew Kelley <andrew@ziglang.org>
Date:   Sun, 18 Dec 2022 13:49:41 -0700

Revert "llvm: fix lowering pointer to final zero-width field of a comptime value"

This reverts commit e0bc5f65b98d154b4318027d56f780b55605e33c.

Caused an assertion failure when running the behavior tests:

```
zig: llvm/lib/IR/Type.cpp:729: static llvm::PointerType* llvm::PointerType::get(llvm::Type*, unsigned int): Assertion `isValidElementType(EltTy) && "Invalid type for pointer element!"' failed.
Aborted (core dumped)
```

Diffstat:
M
src/codegen/llvm.zig
 | 
22
+++++++---------------
M
test/behavior/struct.zig
 | 
36
+++++++++++++-----------------------

2 files changed, 20 insertions(+), 38 deletions(-)
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
@@ -4033,24 +4033,16 @@ pub const DeclGen = struct {
                             const final_llvm_ty = (try dg.lowerType(ptr_child_ty)).pointerType(0);
                             break :blk field_addr.constIntToPtr(final_llvm_ty);
                         }
+                        bitcast_needed = !field_ty.eql(ptr_child_ty, dg.module);
 
                         var ty_buf: Type.Payload.Pointer = undefined;
-
+                        const llvm_field_index = llvmFieldIndex(parent_ty, field_index, target, &ty_buf).?;
+                        const indices: [2]*llvm.Value = .{
+                            llvm_u32.constInt(0, .False),
+                            llvm_u32.constInt(llvm_field_index, .False),
+                        };
                         const parent_llvm_ty = try dg.lowerType(parent_ty);
-                        if (llvmFieldIndex(parent_ty, field_index, target, &ty_buf)) |llvm_field_index| {
-                            bitcast_needed = !field_ty.eql(ptr_child_ty, dg.module);
-                            const indices: [2]*llvm.Value = .{
-                                llvm_u32.constInt(0, .False),
-                                llvm_u32.constInt(llvm_field_index, .False),
-                            };
-                            break :blk parent_llvm_ty.constInBoundsGEP(parent_llvm_ptr, &indices, indices.len);
-                        } else {
-                            bitcast_needed = !parent_ty.eql(ptr_child_ty, dg.module);
-                            const indices: [1]*llvm.Value = .{
-                                llvm_u32.constInt(1, .False),
-                            };
-                            break :blk parent_llvm_ty.constInBoundsGEP(parent_llvm_ptr, &indices, indices.len);
-                        }
+                        break :blk parent_llvm_ty.constInBoundsGEP(parent_llvm_ptr, &indices, indices.len);
                     },
                     .Pointer => {
                         assert(parent_ty.isSlice());
diff --git a/test/behavior/struct.zig b/test/behavior/struct.zig
@@ -1359,33 +1359,23 @@ test "under-aligned struct field" {
     try expect(result == 1234);
 }
 
-test "fieldParentPtr of a zero-bit field" {
+test "address of zero-bit field is equal to address of only 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 S = struct {
-        fn testOneType(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 doTheTest() !void {
-            try testOneType(struct { b: void = {}, u: u8 });
-            try testOneType(struct { u: u8, b: void = {} });
-        }
-    };
-    try S.doTheTest();
-    comptime try S.doTheTest();
+    {
+        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);
+    }
 }
 
 test "struct field has a pointer to an aligned version of itself" {