Commit ede0017eb9e72cb5a799ad000ebe45cf326524d6 | zig

author	Matthew Lugg <mlugg@mlugg.co.uk> 2026-08-15 08:59:55+01:00
committer	Matthew Lugg <mlugg@mlugg.co.uk> 2026-08-16 10:37:20+01:00
log	ede0017eb9e72cb5a799ad000ebe45cf326524d6
tree	b003b53a823715fab390ab128702f4128fb4c001
parent	507f2d0ab154fabe3d81c80e74aa82a59fff837b
signature	Commit is signed but in an unrecognized format.

Elf2: include the ehdr in the rodata segment

Although to my knowledge this is not strictly required by the format or
by any OS, it is highly conventional, and not doing so can definitely
break things in practice---including one of the standard library tests!

To achieve this, we add all of the segment nodes *before* the ehdr,
initializing rodata as a fixed "header" node in the `.elf` node, and
then the `.ehdr` node goes within that rodata segment node.

1 files changed, 89 insertions(+), 72 deletions(-)

src
- link
  - Elf2.zig

src/link/Elf2.zig+89-72

 @@ -3645,77 +3645,22 @@ fn initHeaders(
     const entsize: struct { ph: u32, sh: u32 } = switch (class) {
         .NONE, _ => unreachable,
-        inline else => |ct_class| entsize: {
+        inline else => |ct_class| .{
-            const ElfN = ct_class.ElfN();
+            .ph = @sizeOf(ct_class.ElfN().Phdr),
-            elf.ni.ehdr = try elf.mf.addLastChildNode(gpa, elf.ni.elf, .{
+            .sh = @sizeOf(ct_class.ElfN().Shdr),
-                .size = @sizeOf(ElfN.Ehdr),
-                .alignment = addr_align,
-                .fixed = true,
-            });
-            elf.nodes.appendAssumeCapacity(.ehdr);
-            const ehdr: *ElfN.Ehdr = @ptrCast(@alignCast(elf.ni.ehdr.slice(&elf.mf)));
-            ehdr.ident = .{
-                .class = class,
-                .data = data,
-                .version = 1,
-                .osabi = osabi,
-                .abiversion = 0,
-            };
-            ehdr.type = @"type".toElf();
-            ehdr.machine = machine.toElf();
-            ehdr.version = 1;
-            ehdr.entry = 0;
-            ehdr.phoff = 0;
-            ehdr.shoff = 0;
-            ehdr.flags = switch (machine) {
-                .LOONGARCH => .{ .loongarch = .{
-                    .base_abi_modifier = mod: {
-                        const cpu = comp.getTarget().cpu;
-                        if (cpu.has(.loongarch, .d)) break :mod .d;
-                        if (cpu.has(.loongarch, .f)) break :mod .f;
-                        break :mod .s;
-                    },
-                    .abi_extension = .base,
-                    .abi_version = 1,
-                } },
-                .SPARCV9 => .{ .sparc = .{
-                    .mm = .rmo,
-                    .ext = .{
-                        .@"32plus" = false,
-                        .sun_us1 = false,
-                        .hal_r1 = false,
-                        .sun_us3 = false,
-                        .le_data = false,
-                    },
-                } },
-                .X86_64 => .{ .int = 0 },
-                .AARCH64, .PPC64, .RISCV => @panic(@tagName(machine)),
-            };
-            ehdr.ehsize = @sizeOf(ElfN.Ehdr);
-            ehdr.phentsize = @sizeOf(ElfN.Phdr);
-            ehdr.phnum = @min(phnum, std.elf.PN_XNUM);
-            ehdr.shentsize = @sizeOf(ElfN.Shdr);
-            ehdr.shnum = 1; // Only the null shdr initially---will be incremented by `addSection`
-            ehdr.shstrndx = std.elf.SHN_UNDEF;
-            if (elf.targetEndian() != native_endian) std.mem.byteSwapAllFields(ElfN.Ehdr, ehdr);
-            break :entsize .{ .ph = @sizeOf(ElfN.Phdr), .sh = @sizeOf(ElfN.Shdr) };
         },
     };
-    elf.ni.shdr = try elf.mf.addLastChildNode(gpa, elf.ni.elf, .{
+    // We want to create the segment nodes *before* the ehdr, because the ehdr should go inside of
-        .size = 1 * entsize.sh, // as above, only the null shdr initially
+    // the rodata segment. Although to my knowledge neither ELF nor any ELF-based OS strictly
-        .alignment = addr_align.max(node_block_align),
+    // requires this, it is highly conventional and therefore sometimes relied upon.
-        .moved = true,
-        .resized = true,
-    });
-    elf.nodes.appendAssumeCapacity(.shdr);
     if (@"type" != .REL) {
-        elf.ni.rodata = try elf.mf.addLastChildNode(gpa, elf.ni.elf, .{
+        elf.ni.rodata = try elf.mf.addOnlyChildNode(gpa, elf.ni.elf, .{
             // Must be at least `addr_align` for `elf.ni.phdr` to be placed inside this node
             .alignment = node_block_align.max(addr_align),
+            // This node will contain the ehdr, which must be at the start of the ELF file, so this
+            // node must itself be fixed.
+            .fixed = true,
             .moved = true,
             .bubbles_moved = false,
         });
 @@ -3781,6 +3726,79 @@ fn initHeaders(
         elf.phdrs.items[phndx.gnu_stack] = .none;
     }
+    switch (class) {
+        .NONE, _ => unreachable,
+        inline else => |ct_class| {
+            const ElfN = ct_class.ElfN();
+            // In loadable modules, the ehdr goes in the rodata segment, as described above.
+            const parent_ni = switch (@"type") {
+                .REL => elf.ni.elf,
+                .DYN, .EXEC => elf.ni.rodata,
+            };
+            elf.ni.ehdr = try elf.mf.addFirstChildNode(gpa, parent_ni, .{
+                .size = @sizeOf(ElfN.Ehdr),
+                .alignment = addr_align,
+                .fixed = true,
+            });
+            elf.nodes.appendAssumeCapacity(.ehdr);
+            const ehdr: *ElfN.Ehdr = @ptrCast(@alignCast(elf.ni.ehdr.slice(&elf.mf)));
+            ehdr.ident = .{
+                .class = class,
+                .data = data,
+                .version = 1,
+                .osabi = osabi,
+                .abiversion = 0,
+            };
+            ehdr.type = @"type".toElf();
+            ehdr.machine = machine.toElf();
+            ehdr.version = 1;
+            ehdr.entry = 0;
+            ehdr.phoff = 0;
+            ehdr.shoff = 0;
+            ehdr.flags = switch (machine) {
+                .LOONGARCH => .{ .loongarch = .{
+                    .base_abi_modifier = mod: {
+                        const cpu = comp.getTarget().cpu;
+                        if (cpu.has(.loongarch, .d)) break :mod .d;
+                        if (cpu.has(.loongarch, .f)) break :mod .f;
+                        break :mod .s;
+                    },
+                    .abi_extension = .base,
+                    .abi_version = 1,
+                } },
+                .SPARCV9 => .{ .sparc = .{
+                    .mm = .rmo,
+                    .ext = .{
+                        .@"32plus" = false,
+                        .sun_us1 = false,
+                        .hal_r1 = false,
+                        .sun_us3 = false,
+                        .le_data = false,
+                    },
+                } },
+                .X86_64 => .{ .int = 0 },
+                .AARCH64, .PPC64, .RISCV => @panic(@tagName(machine)),
+            };
+            ehdr.ehsize = @sizeOf(ElfN.Ehdr);
+            ehdr.phentsize = @sizeOf(ElfN.Phdr);
+            ehdr.phnum = @min(phnum, std.elf.PN_XNUM);
+            ehdr.shentsize = @sizeOf(ElfN.Shdr);
+            ehdr.shnum = 1; // Only the null shdr initially---will be incremented by `addSection`
+            ehdr.shstrndx = std.elf.SHN_UNDEF;
+            if (elf.targetEndian() != native_endian) std.mem.byteSwapAllFields(ElfN.Ehdr, ehdr);
+        },
+    }
+    elf.ni.shdr = try elf.mf.addLastChildNode(gpa, elf.ni.elf, .{
+        .size = 1 * entsize.sh, // as above, only the null shdr initially
+        .alignment = addr_align.max(node_block_align),
+        .moved = true,
+        .resized = true,
+    });
+    elf.nodes.appendAssumeCapacity(.shdr);
     switch (class) {
         .NONE, _ => unreachable,
         inline else => |ct_class| {
 @@ -3818,7 +3836,9 @@ fn initHeaders(
                 // actually `PT_NULL` for now, because we initialize `filesz` and `memsz` to zero.
                 // Any which end up non-empty will have their size populated (and their type set to
                 // `PT_LOAD`) by the segment virtual address space allocation logic.
-                const phdr: []ElfN.Phdr = @ptrCast(@alignCast(elf.ni.phdr.slice(&elf.mf)));
+                const phdr: []ElfN.Phdr = @ptrCast(@alignCast(
+                    elf.ni.phdr.slice(&elf.mf)[0 .. phnum * @sizeOf(ElfN.Phdr)],
+                ));
                 const ph_phdr = &phdr[phndx.phdr];
                 ph_phdr.* = .{
 @@ -4900,14 +4920,11 @@ const PhdrSlice = union(std.elf.CLASS) {
 };
 fn phdrSlice(elf: *Elf) PhdrSlice {
     assert(elf.ehdrType() != .REL);
-    const slice = elf.ni.phdr.slice(&elf.mf);
     return switch (elf.identClass()) {
         .NONE, _ => unreachable,
-        inline else => |class| @unionInit(
+        inline else => |class| @unionInit(PhdrSlice, @tagName(class), @ptrCast(@alignCast(
-            PhdrSlice,
+            elf.ni.phdr.slice(&elf.mf)[0 .. elf.phdrs.items.len * @sizeOf(class.ElfN().Phdr)],
-            @tagName(class),
+        ))),
-            @ptrCast(@alignCast(slice)),
-        ),
     };
 }