llvm: implement comptime field lowering

Closes #12963

Author: Vexu

src/codegen.zig

@@ -756,7 +756,14 @@ fn lowerParentPtr(
                 }),
             );
         },
-        .comptime_field => unreachable,
+        .comptime_field => |field_val| try lowerComptimeFieldRef(
+            bin_file,
+            src_loc,
+            Type.fromInterned(ptr.ty),
+            field_val,
+            code,
+            reloc_info,
+        ),
     };
 }
 
@@ -769,6 +776,44 @@ const RelocInfo = struct {
     }
 };
 
+fn lowerComptimeFieldRef(
+    lf: *link.File,
+    src_loc: Module.SrcLoc,
+    ptr_ty: Type,
+    field_val: InternPool.Index,
+    code: *std.ArrayList(u8),
+    reloc_info: RelocInfo,
+) CodeGenError!Result {
+    const zcu = lf.comp.module.?;
+    const target = lf.comp.root_mod.resolved_target.result;
+
+    const ptr_width_bytes = @divExact(target.ptrBitWidth(), 8);
+    const decl_ty = Type.fromInterned(zcu.intern_pool.typeOf(field_val));
+    log.debug("lowerComptimeFieldRef: ty = {}", .{decl_ty.fmt(zcu)});
+
+    const alignment = ptr_ty.ptrAlignment(zcu);
+    const res = try lf.lowerAnonDecl(field_val, alignment, src_loc);
+    switch (res) {
+        .ok => {},
+        .fail => |em| return .{ .fail = em },
+    }
+
+    const vaddr = try lf.getAnonDeclVAddr(field_val, .{
+        .parent_atom_index = reloc_info.parent_atom_index,
+        .offset = code.items.len,
+        .addend = reloc_info.addend orelse 0,
+    });
+    const endian = target.cpu.arch.endian();
+    switch (ptr_width_bytes) {
+        2 => mem.writeInt(u16, try code.addManyAsArray(2), @intCast(vaddr), endian),
+        4 => mem.writeInt(u32, try code.addManyAsArray(4), @intCast(vaddr), endian),
+        8 => mem.writeInt(u64, try code.addManyAsArray(8), vaddr, endian),
+        else => unreachable,
+    }
+
+    return Result.ok;
+}
+
 fn lowerAnonDeclRef(
     lf: *link.File,
     src_loc: Module.SrcLoc,

src/codegen/llvm.zig

@@ -3816,7 +3816,10 @@ pub const Object = struct {
                 .elem,
                 .field,
                 => try o.lowerParentPtr(val),
-                .comptime_field => unreachable,
+                .comptime_field => |field_val| {
+                    const ptr_ty = Type.fromInterned(ptr.ty);
+                    return o.lowerComptimeFieldRef(ptr_ty, field_val);
+                },
             },
             .slice => |slice| return o.builder.structConst(try o.lowerType(ty), &.{
                 try o.lowerValue(slice.ptr),
@@ -4311,7 +4314,10 @@ pub const Object = struct {
 
                 return o.builder.gepConst(.inbounds, try o.lowerType(opt_ty), parent_ptr, null, &.{ .@"0", .@"0" });
             },
-            .comptime_field => unreachable,
+            .comptime_field => |field_val| {
+                const ptr_ty = Type.fromInterned(ptr.ty);
+                return o.lowerComptimeFieldRef(ptr_ty, field_val);
+            },
             .elem => |elem_ptr| {
                 const parent_ptr = try o.lowerParentPtr(Value.fromInterned(elem_ptr.base));
                 const elem_ty = Type.fromInterned(ip.typeOf(elem_ptr.base)).elemType2(mod);
@@ -4388,6 +4394,25 @@ pub const Object = struct {
         };
     }
 
+    fn lowerComptimeFieldRef(o: *Object, ptr_ty: Type, field_val: InternPool.Index) Error!Builder.Constant {
+        const mod = o.module;
+        const target = mod.getTarget();
+        const llvm_addr_space = toLlvmAddressSpace(ptr_ty.ptrAddressSpace(mod), target);
+        const alignment = ptr_ty.ptrAlignment(mod);
+        const llvm_global = (try o.resolveGlobalAnonDecl(field_val, llvm_addr_space, alignment)).ptrConst(&o.builder).global;
+
+        const llvm_val = try o.builder.convConst(
+            .unneeded,
+            llvm_global.toConst(),
+            try o.builder.ptrType(llvm_addr_space),
+        );
+
+        return o.builder.convConst(if (ptr_ty.isAbiInt(mod)) switch (ptr_ty.intInfo(mod).signedness) {
+            .signed => .signed,
+            .unsigned => .unsigned,
+        } else .unneeded, llvm_val, try o.lowerType(ptr_ty));
+    }
+
     /// This logic is very similar to `lowerDeclRefValue` but for anonymous declarations.
     /// Maybe the logic could be unified.
     fn lowerAnonDeclRef(

test/behavior/struct.zig

@@ -2150,3 +2150,17 @@ test "matching captures causes struct equivalence" {
     comptime assert(@TypeOf(a) == @TypeOf(b));
     try expect(a.x == b.x);
 }
+
+test "pointer to comptime field loaded at runtime" {
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
+
+    const T = struct {
+        comptime a: u32 = 2,
+    };
+    var t: T = undefined;
+    const ptr = &t.a;
+    try expect(ptr.* == 2);
+}