Segmentation fault referencing values in anonymous tuple.

[lithdew]

If I un-encapsulate the heap-allocated string out of a struct, the test case passes. EDIT: as @LemonBoy has mentioned, the problem appears to be with printing out structs declared inside an anonymous tuple.

$ zig run test.zig
Segmentation fault at address 0x202b20
/home/lith/Desktop/tests/test.zig:13:49: 0x22d46a in main (test)
    std.debug.print("{s}\n", .{Header{ .value = value }});
                                                ^
/home/lith/Desktop/zig/lib/std/start.zig:345:37: 0x204e44 in std.start.posixCallMainAndExit (test)
            const result = root.main() catch |err| {
                                    ^
/home/lith/Desktop/zig/lib/std/start.zig:163:5: 0x204ce2 in std.start._start (test)
    @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
    ^
Aborted (core dumped)

const std = @import("std");

pub fn main() !void {
    const Header = struct {
        value: []const u8,
    };

    const allocator = std.heap.page_allocator;

    var value = try allocator.dupe(u8, "test");
    defer allocator.free(value);

    std.debug.print("{s}\n", .{Header{ .value = value }});
}

[LemonBoy]

The crash has nothing to do with std.fmt nor with printing strings nor with heap allocations.
Pull Header{ .value = value } out of the anonymous tuple and the code runs just fine, the problem is with the anonymous thing.

const std = @import("std");

pub fn main() !void {
    const Header = struct {
        value: []const u8,
    };

    const allocator = std.heap.page_allocator;

    var value = try allocator.dupe(u8, "test");
    defer allocator.free(value);

    var hdr = Header{ .value = value };
    std.debug.print("{s}\n", .{hdr111});
}

[faraazahmad]

I've noticed this is LLVM behavior. I was implementing print function in my own language and generating LLVM IR, I've noticed that passing anonymous "values" (I don't have a better word) causes segfaults. I was passing in a string without first declaring it, hence the segfault. I then declared the string separately and then passed its pointer in it, and it worked.

I've looked at LLVM IR generated by clang and that's how it does it too. I feel like programmers shouldn't have to worry about this internal implementation detail, but I guess this method also forces the programmer to write better code, i.e. easier to read (when it gets bigger and complicated), easier to catch errors, etc.

[mikdusan]

• unable to repro with latest compiler
• unable to repro with godbolt, back to 0.6.0
• closing because the anon tuple input is correctly output

repro.zig

const std = @import("std");

pub fn main() !void {
    const Header = struct {
        value: []const u8,
    };

    const allocator = std.heap.page_allocator;

    var value = try allocator.dupe(u8, "test");
    defer allocator.free(value);

    std.debug.print("{}\n", .{Header{ .value = value }});
}

$ archlinux▸ uname -a
Linux archlinux 6.1.2-arch1-1 #1 SMP PREEMPT_DYNAMIC Sat, 31 Dec 2022 17:40:35 +0000 x86_64 GNU/Linux

$ zig version
0.11.0-dev.1239+7a2d7ff62

$ zig run repro.zig
repro.main.Header{ .value = { 116, 101, 115, 116 } }