From 574c80351da46a4ac836504c6591d5db068eaa06 Mon Sep 17 00:00:00 2001 From: David Senoner Date: Thu, 30 Jul 2026 18:38:51 +0200 Subject: [PATCH] elf: remove usages of deprecated Elf64_Phdr --- lib/compiler/objcopy.zig | 14 +-- lib/std/elf.zig | 28 +++--- lib/std/zig/system.zig | 12 +-- src/link/Elf.zig | 202 +++++++++++++++++++-------------------- 4 files changed, 128 insertions(+), 128 deletions(-) diff --git a/lib/compiler/objcopy.zig b/lib/compiler/objcopy.zig index 136b48ef4c0cbadfd6f9309bfda8660fedb613d0..a54c61f5000ff569a7c34461e7db80b515d3d21d 100644 --- a/lib/compiler/objcopy.zig +++ b/lib/compiler/objcopy.zig @@ -435,13 +435,13 @@ const BinaryElfOutput = struct { var program_headers = elf_hdr.iterateProgramHeaders(in); while (try program_headers.next()) |phdr| { - if (phdr.p_type == @backingInt(elf.PT.LOAD)) { + if (phdr.type == .LOAD) { const newSegment = try allocator.create(BinaryElfSegment); - newSegment.physicalAddress = phdr.p_paddr; - newSegment.virtualAddress = phdr.p_vaddr; - newSegment.fileSize = @intCast(phdr.p_filesz); - newSegment.elfOffset = phdr.p_offset; + newSegment.physicalAddress = phdr.paddr; + newSegment.virtualAddress = phdr.vaddr; + newSegment.fileSize = @intCast(phdr.filesz); + newSegment.elfOffset = phdr.offset; newSegment.binaryOffset = 0; newSegment.firstSection = null; @@ -495,8 +495,8 @@ const BinaryElfOutput = struct { return self; } - fn sectionWithinSegment(section: *BinaryElfSection, segment: elf.Elf64_Phdr) bool { - return segment.p_offset <= section.elfOffset and (segment.p_offset + segment.p_filesz) >= (section.elfOffset + section.fileSize); + fn sectionWithinSegment(section: *BinaryElfSection, segment: elf.Elf64.Phdr) bool { + return segment.offset <= section.elfOffset and (segment.offset + segment.filesz) >= (section.elfOffset + section.fileSize); } fn sectionValidForOutput(shdr: anytype) bool { diff --git a/lib/std/elf.zig b/lib/std/elf.zig index 97710d03c175cc48273b8e40c324bff122fc4caa..f2741734812a488ee400a82b7d7c4e159b61baaa 100644 --- a/lib/std/elf.zig +++ b/lib/std/elf.zig @@ -807,11 +807,11 @@ pub const ProgramHeaderIterator = struct { file_reader: *Io.File.Reader, index: usize = 0, - pub fn next(it: *ProgramHeaderIterator) !?Elf64_Phdr { + pub fn next(it: *ProgramHeaderIterator) !?Elf64.Phdr { if (it.index >= it.phnum) return null; defer it.index += 1; - const size: u64 = if (it.is_64) @sizeOf(Elf64_Phdr) else @sizeOf(Elf32.Phdr); + const size: u64 = if (it.is_64) @sizeOf(Elf64.Phdr) else @sizeOf(Elf32.Phdr); const offset = it.phoff + size * it.index; try it.file_reader.seekTo(offset); @@ -828,11 +828,11 @@ pub const ProgramHeaderBufferIterator = struct { buf: []const u8, index: usize = 0, - pub fn next(it: *ProgramHeaderBufferIterator) !?Elf64_Phdr { + pub fn next(it: *ProgramHeaderBufferIterator) !?Elf64.Phdr { if (it.index >= it.phnum) return null; defer it.index += 1; - const size: usize = if (it.is_64) @sizeOf(Elf64_Phdr) else @sizeOf(Elf32.Phdr); + const size: usize = if (it.is_64) @sizeOf(Elf64.Phdr) else @sizeOf(Elf32.Phdr); const offset = @as(usize, @intCast(it.phoff)) + size * it.index; var reader = Io.Reader.fixed(it.buf[offset..]); @@ -840,22 +840,22 @@ pub const ProgramHeaderBufferIterator = struct { } }; -pub fn takeProgramHeader(reader: *Io.Reader, is_64: bool, endian: Endian) !Elf64_Phdr { +pub fn takeProgramHeader(reader: *Io.Reader, is_64: bool, endian: Endian) !Elf64.Phdr { if (is_64) { - const phdr = try reader.takeStruct(Elf64_Phdr, endian); + const phdr = try reader.takeStruct(Elf64.Phdr, endian); return phdr; } const phdr = try reader.takeStruct(Elf32.Phdr, endian); return .{ - .p_type = @backingInt(phdr.type), - .p_offset = phdr.offset, - .p_vaddr = phdr.vaddr, - .p_paddr = phdr.paddr, - .p_filesz = phdr.filesz, - .p_memsz = phdr.memsz, - .p_flags = @backingInt(phdr.flags), - .p_align = phdr.@"align", + .type = phdr.type, + .offset = phdr.offset, + .vaddr = phdr.vaddr, + .paddr = phdr.paddr, + .filesz = phdr.filesz, + .memsz = phdr.memsz, + .flags = phdr.flags, + .@"align" = phdr.@"align", }; } diff --git a/lib/std/zig/system.zig b/lib/std/zig/system.zig index 083e7bb90f0ffb5acabf3470414262834e3cb0b1..4d63d0c995024fa317bb59aca5e0fc2022c63c9b 100644 --- a/lib/std/zig/system.zig +++ b/lib/std/zig/system.zig @@ -603,15 +603,15 @@ fn abiAndDynamicLinkerFromFile( var got_dyn_section: bool = false; { var it = header.iterateProgramHeaders(file_reader); - while (try it.next()) |phdr| switch (phdr.p_type) { - @backingInt(elf.PT.INTERP) => { + while (try it.next()) |phdr| switch (phdr.type) { + .INTERP => { got_dyn_section = true; if (look_for_ld) { - const p_filesz = phdr.p_filesz; + const p_filesz = phdr.filesz; if (p_filesz > result.dynamic_linker.buffer.len) return error.NameTooLong; const filesz: usize = @intCast(p_filesz); - try file_reader.seekTo(phdr.p_offset); + try file_reader.seekTo(phdr.offset); try file_reader.interface.readSliceAll(result.dynamic_linker.buffer[0..filesz]); // PT.INTERP includes a null byte in filesz. const len = filesz - 1; @@ -631,11 +631,11 @@ fn abiAndDynamicLinkerFromFile( } }, // We only need this for detecting glibc version. - @backingInt(elf.PT.DYNAMIC) => { + .DYNAMIC => { got_dyn_section = true; if (builtin.target.os.tag == .linux and result.isGnuLibC() and query.glibc_version == null) { - var dyn_it = header.iterateDynamicSection(file_reader, phdr.p_offset, phdr.p_filesz); + var dyn_it = header.iterateDynamicSection(file_reader, phdr.offset, phdr.filesz); while (try dyn_it.next()) |dyn| { if (dyn.d_tag == elf.DT_RUNPATH) { rpath_offset = dyn.d_val; diff --git a/src/link/Elf.zig b/src/link/Elf.zig index 3f82771d536a6fcc6265b1b0b366943979d2faa7..e22680a44a450739239051ad62d27067d2efe327 100644 --- a/src/link/Elf.zig +++ b/src/link/Elf.zig @@ -127,7 +127,7 @@ const SectionIndexes = struct { symtab: ?u32 = null, }; -const ProgramHeaderList = std.ArrayList(elf.Elf64_Phdr); +const ProgramHeaderList = std.ArrayList(elf.Elf64.Phdr); const OptionalProgramHeaderIndex = enum(u16) { none = std.math.maxInt(u16), @@ -337,7 +337,7 @@ pub fn createEmpty( // Initialize PT.PHDR program header const p_align: u16 = switch (self.ptr_width) { .p32 => @alignOf(elf.Elf32.Phdr), - .p64 => @alignOf(elf.Elf64_Phdr), + .p64 => @alignOf(elf.Elf64.Phdr), }; const ehsize: u64 = switch (self.ptr_width) { .p32 => @sizeOf(elf.Elf32_Ehdr), @@ -345,7 +345,7 @@ pub fn createEmpty( }; const phsize: u64 = switch (self.ptr_width) { .p32 => @sizeOf(elf.Elf32.Phdr), - .p64 => @sizeOf(elf.Elf64_Phdr), + .p64 => @sizeOf(elf.Elf64.Phdr), }; const max_nphdrs = comptime getMaxNumberOfPhdrs(); const reserved: u64 = mem.alignForward(u64, padToIdeal(max_nphdrs * phsize), self.page_size); @@ -514,11 +514,11 @@ fn detectAllocCollision(self: *Elf, start: u64, size: u64) !?u64 { } for (self.phdrs.items) |phdr| { - if (phdr.p_type != @backingInt(elf.PT.LOAD)) continue; - const increased_size = padToIdeal(phdr.p_filesz); - const test_end = phdr.p_offset +| increased_size; + if (phdr.type != .LOAD) continue; + const increased_size = padToIdeal(phdr.filesz); + const test_end = phdr.offset +| increased_size; if (start < test_end) { - if (end > phdr.p_offset) return test_end; + if (end > phdr.offset) return test_end; if (test_end < std.math.maxInt(u64)) at_end = false; } } @@ -538,8 +538,8 @@ pub fn allocatedSize(self: *Elf, start: u64) u64 { if (section.sh_offset < min_pos) min_pos = section.sh_offset; } for (self.phdrs.items) |phdr| { - if (phdr.p_offset <= start) continue; - if (phdr.p_offset < min_pos) min_pos = phdr.p_offset; + if (phdr.offset <= start) continue; + if (phdr.offset < min_pos) min_pos = phdr.offset; } return min_pos - start; } @@ -1471,8 +1471,8 @@ fn writePhdrTable(self: *Elf) !void { const phdr_table = &self.phdrs.items[self.phdr_indexes.table.int().?]; log.debug("writing program headers from 0x{x} to 0x{x}", .{ - phdr_table.p_offset, - phdr_table.p_offset + phdr_table.p_filesz, + phdr_table.offset, + phdr_table.offset + phdr_table.filesz, }); switch (self.ptr_width) { @@ -1486,19 +1486,19 @@ fn writePhdrTable(self: *Elf) !void { mem.byteSwapAllFields(elf.Elf32.Phdr, phdr); } } - try self.pwriteAll(@ptrCast(buf), phdr_table.p_offset); + try self.pwriteAll(@ptrCast(buf), phdr_table.offset); }, .p64 => { - const buf = try gpa.alloc(elf.Elf64_Phdr, self.phdrs.items.len); + const buf = try gpa.alloc(elf.Elf64.Phdr, self.phdrs.items.len); defer gpa.free(buf); for (buf, 0..) |*phdr, i| { phdr.* = self.phdrs.items[i]; if (foreign_endian) { - mem.byteSwapAllFields(elf.Elf64_Phdr, phdr); + mem.byteSwapAllFields(elf.Elf64.Phdr, phdr); } } - try self.pwriteAll(@ptrCast(buf), phdr_table.p_offset); + try self.pwriteAll(@ptrCast(buf), phdr_table.offset); }, } } @@ -1581,7 +1581,7 @@ pub fn writeElfHeader(self: *Elf) !void { const entry_sym = obj.entrySymbol(self) orelse break :blk 0; break :blk @intCast(entry_sym.address(.{}, self)); } else 0; - const phdr_table_offset = if (self.phdr_indexes.table.int()) |phndx| self.phdrs.items[phndx].p_offset else 0; + const phdr_table_offset = if (self.phdr_indexes.table.int()) |phndx| self.phdrs.items[phndx].offset else 0; switch (self.ptr_width) { .p32 => { mem.writeInt(u32, hdr_buf[index..][0..4], @intCast(e_entry), endian); @@ -1623,7 +1623,7 @@ pub fn writeElfHeader(self: *Elf) !void { const e_phentsize: u16 = switch (self.ptr_width) { .p32 => @sizeOf(elf.Elf32.Phdr), - .p64 => @sizeOf(elf.Elf64_Phdr), + .p64 => @sizeOf(elf.Elf64.Phdr), }; mem.writeInt(u16, hdr_buf[index..][0..2], e_phentsize, endian); index += 2; @@ -2260,15 +2260,15 @@ fn setHashSections(self: *Elf) !void { } } -fn phdrRank(phdr: elf.Elf64_Phdr) u8 { - return switch (phdr.p_type) { - @backingInt(elf.PT.NULL) => 0, - @backingInt(elf.PT.PHDR) => 1, - @backingInt(elf.PT.INTERP) => 2, - @backingInt(elf.PT.LOAD) => 3, - @backingInt(elf.PT.DYNAMIC), @backingInt(elf.PT.TLS) => 4, - @backingInt(elf.PT.GNU_EH_FRAME) => 5, - @backingInt(elf.PT.GNU_STACK) => 6, +fn phdrRank(phdr: elf.Elf64.Phdr) u8 { + return switch (phdr.type) { + .NULL => 0, + .PHDR => 1, + .INTERP => 2, + .LOAD => 3, + .DYNAMIC, .TLS => 4, + .GNU_EH_FRAME => 5, + .GNU_STACK => 6, else => 7, }; } @@ -2282,12 +2282,12 @@ fn sortPhdrs( const Entry = struct { phndx: u16, - pub fn lessThan(program_headers: []const elf.Elf64_Phdr, lhs: @This(), rhs: @This()) bool { + pub fn lessThan(program_headers: []const elf.Elf64.Phdr, lhs: @This(), rhs: @This()) bool { const lhs_phdr = program_headers[lhs.phndx]; const rhs_phdr = program_headers[rhs.phndx]; const lhs_rank = phdrRank(lhs_phdr); const rhs_rank = phdrRank(rhs_phdr); - if (lhs_rank == rhs_rank) return lhs_phdr.p_vaddr < rhs_phdr.p_vaddr; + if (lhs_rank == rhs_rank) return lhs_phdr.vaddr < rhs_phdr.vaddr; return lhs_rank < rhs_rank; } }; @@ -2299,7 +2299,7 @@ fn sortPhdrs( } // The `@as` here works around a bug in the C backend. - mem.sort(Entry, entries, @as([]const elf.Elf64_Phdr, phdrs.items), Entry.lessThan); + mem.sort(Entry, entries, @as([]const elf.Elf64.Phdr, phdrs.items), Entry.lessThan); const backlinks = try gpa.alloc(u16, entries.len); defer gpa.free(backlinks); @@ -2673,10 +2673,10 @@ fn allocatePhdrTable(self: *Elf) error{OutOfMemory}!void { }; const phsize: u64 = switch (self.ptr_width) { .p32 => @sizeOf(elf.Elf32.Phdr), - .p64 => @sizeOf(elf.Elf64_Phdr), + .p64 => @sizeOf(elf.Elf64.Phdr), }; const needed_size = self.phdrs.items.len * phsize; - const available_space = self.allocatedSize(phdr_table.p_offset); + const available_space = self.allocatedSize(phdr_table.offset); if (needed_size > available_space) { // In this case, we have two options: @@ -2689,10 +2689,10 @@ fn allocatePhdrTable(self: *Elf) error{OutOfMemory}!void { err.addNote("required 0x{x}, available 0x{x}", .{ needed_size, available_space }); } - phdr_table_load.p_filesz = needed_size + ehsize; - phdr_table_load.p_memsz = needed_size + ehsize; - phdr_table.p_filesz = needed_size; - phdr_table.p_memsz = needed_size; + phdr_table_load.filesz = needed_size + ehsize; + phdr_table_load.memsz = needed_size + ehsize; + phdr_table.filesz = needed_size; + phdr_table.memsz = needed_size; } /// Allocates alloc sections and creates load segments for sections @@ -2758,7 +2758,7 @@ pub fn allocateAllocSections(self: *Elf) !void { // of any section that is contained in a cover and use it to align // the start address of the segement (and first section). const phdr_table = &self.phdrs.items[self.phdr_indexes.table_load.int().?]; - var addr = phdr_table.p_vaddr + phdr_table.p_memsz; + var addr = phdr_table.vaddr + phdr_table.memsz; for (covers) |cover| { if (cover.items.len == 0) continue; @@ -2819,12 +2819,12 @@ pub fn allocateAllocSections(self: *Elf) !void { const first = slice.items(.shdr)[cover.items[0]]; const phndx = self.getPhdr(.{ .type = @backingInt(elf.PT.LOAD), .flags = shdrToPhdrFlags(first.sh_flags) }).unwrap().?; const phdr = &self.phdrs.items[phndx.int()]; - const allocated_size = self.allocatedSize(phdr.p_offset); + const allocated_size = self.allocatedSize(phdr.offset); if (filesz > allocated_size) { - const old_offset = phdr.p_offset; - phdr.p_offset = 0; + const old_offset = phdr.offset; + phdr.offset = 0; var new_offset = try self.findFreeSpace(filesz, @"align"); - phdr.p_offset = new_offset; + phdr.offset = new_offset; log.debug("moving phdr({d}) from 0x{x} to 0x{x}", .{ phndx, old_offset, new_offset }); @@ -2854,11 +2854,11 @@ pub fn allocateAllocSections(self: *Elf) !void { } } - phdr.p_vaddr = first.sh_addr; - phdr.p_paddr = first.sh_addr; - phdr.p_memsz = memsz; - phdr.p_filesz = filesz; - phdr.p_align = @"align"; + phdr.vaddr = first.sh_addr; + phdr.paddr = first.sh_addr; + phdr.memsz = memsz; + phdr.filesz = filesz; + phdr.@"align" = @"align"; addr = mem.alignForward(u64, addr, self.page_size); } @@ -2902,12 +2902,12 @@ fn allocateSpecialPhdrs(self: *Elf) void { if (pair[0].int()) |index| { const shdr = slice.items(.shdr)[pair[1].?]; const phdr = &self.phdrs.items[index]; - phdr.p_align = shdr.sh_addralign; - phdr.p_offset = shdr.sh_offset; - phdr.p_vaddr = shdr.sh_addr; - phdr.p_paddr = shdr.sh_addr; - phdr.p_filesz = shdr.sh_size; - phdr.p_memsz = shdr.sh_size; + phdr.@"align" = shdr.sh_addralign; + phdr.offset = shdr.sh_offset; + phdr.vaddr = shdr.sh_addr; + phdr.paddr = shdr.sh_addr; + phdr.filesz = shdr.sh_size; + phdr.memsz = shdr.sh_size; } } @@ -2924,25 +2924,25 @@ fn allocateSpecialPhdrs(self: *Elf) void { shndx += 1; continue; } - phdr.p_offset = shdr.sh_offset; - phdr.p_vaddr = shdr.sh_addr; - phdr.p_paddr = shdr.sh_addr; - phdr.p_align = shdr.sh_addralign; + phdr.offset = shdr.sh_offset; + phdr.vaddr = shdr.sh_addr; + phdr.paddr = shdr.sh_addr; + phdr.@"align" = shdr.sh_addralign; shndx += 1; - phdr.p_align = @max(phdr.p_align, shdr.sh_addralign); + phdr.@"align" = @max(phdr.@"align", shdr.sh_addralign); if (shdr.sh_type != elf.SHT_NOBITS) { - phdr.p_filesz = shdr.sh_offset + shdr.sh_size - phdr.p_offset; + phdr.filesz = shdr.sh_offset + shdr.sh_size - phdr.offset; } - phdr.p_memsz = shdr.sh_addr + shdr.sh_size - phdr.p_vaddr; + phdr.memsz = shdr.sh_addr + shdr.sh_size - phdr.vaddr; while (shndx < shdrs.len) : (shndx += 1) { const next = shdrs[shndx]; if (next.sh_flags & elf.SHF_TLS == 0) break; - phdr.p_align = @max(phdr.p_align, next.sh_addralign); + phdr.@"align" = @max(phdr.@"align", next.sh_addralign); if (next.sh_type != elf.SHT_NOBITS) { - phdr.p_filesz = next.sh_offset + next.sh_size - phdr.p_offset; + phdr.filesz = next.sh_offset + next.sh_size - phdr.offset; } - phdr.p_memsz = next.sh_addr + next.sh_size - phdr.p_vaddr; + phdr.memsz = next.sh_addr + next.sh_size - phdr.vaddr; } } } @@ -3347,16 +3347,16 @@ pub fn archPtrWidthBytes(self: Elf) u8 { return @intCast(@divExact(self.getTarget().ptrBitWidth(), 8)); } -fn phdrTo32(phdr: elf.Elf64_Phdr) elf.Elf32.Phdr { +fn phdrTo32(phdr: elf.Elf64.Phdr) elf.Elf32.Phdr { return .{ - .type = @fromBackingInt(phdr.p_type), - .flags = @fromBackingInt(phdr.p_flags), - .offset = @intCast(phdr.p_offset), - .vaddr = @intCast(phdr.p_vaddr), - .paddr = @intCast(phdr.p_paddr), - .filesz = @intCast(phdr.p_filesz), - .memsz = @intCast(phdr.p_memsz), - .@"align" = @intCast(phdr.p_align), + .type = phdr.type, + .flags = phdr.flags, + .offset = @intCast(phdr.offset), + .vaddr = @intCast(phdr.vaddr), + .paddr = @intCast(phdr.paddr), + .filesz = @intCast(phdr.filesz), + .memsz = @intCast(phdr.memsz), + .@"align" = @intCast(phdr.@"align"), }; } @@ -3397,7 +3397,7 @@ fn getPhdr(self: *Elf, opts: struct { if (self.phdr_indexes.table_load.int()) |index| { if (phndx == index) continue; } - if (phdr.p_type == opts.type and phdr.p_flags == opts.flags) + if (@backingInt(phdr.type) == opts.type and @backingInt(phdr.flags) == opts.flags) return @fromBackingInt(@intCast(phndx)); } return .none; @@ -3415,14 +3415,14 @@ fn addPhdr(self: *Elf, opts: struct { const gpa = self.base.comp.gpa; const index: ProgramHeaderIndex = @fromBackingInt(@intCast(self.phdrs.items.len)); try self.phdrs.append(gpa, .{ - .p_type = opts.type, - .p_flags = opts.flags, - .p_offset = opts.offset, - .p_vaddr = opts.addr, - .p_paddr = opts.addr, - .p_filesz = opts.filesz, - .p_memsz = opts.memsz, - .p_align = opts.@"align", + .type = @fromBackingInt(opts.type), + .flags = @fromBackingInt(opts.flags), + .offset = opts.offset, + .vaddr = opts.addr, + .paddr = opts.addr, + .filesz = opts.filesz, + .memsz = opts.memsz, + .@"align" = opts.@"align", }); return index; } @@ -3673,9 +3673,9 @@ pub fn tpAddress(self: *Elf) i64 { const index = self.phdr_indexes.tls.int() orelse return 0; const phdr = self.phdrs.items[index]; const addr = switch (self.getTarget().cpu.arch) { - .x86_64 => mem.alignForward(u64, phdr.p_vaddr + phdr.p_memsz, phdr.p_align), - .aarch64, .aarch64_be => mem.alignBackward(u64, phdr.p_vaddr - 16, phdr.p_align), - .riscv64, .riscv64be => phdr.p_vaddr, + .x86_64 => mem.alignForward(u64, phdr.vaddr + phdr.memsz, phdr.@"align"), + .aarch64, .aarch64_be => mem.alignBackward(u64, phdr.vaddr - 16, phdr.@"align"), + .riscv64, .riscv64be => phdr.vaddr, else => |arch| std.debug.panic("TODO implement getTpAddress for {s}", .{@tagName(arch)}), }; return @intCast(addr); @@ -3684,13 +3684,13 @@ pub fn tpAddress(self: *Elf) i64 { pub fn dtpAddress(self: *Elf) i64 { const index = self.phdr_indexes.tls.int() orelse return 0; const phdr = self.phdrs.items[index]; - return @intCast(phdr.p_vaddr); + return @intCast(phdr.vaddr); } pub fn tlsAddress(self: *Elf) i64 { const index = self.phdr_indexes.tls.int() orelse return 0; const phdr = self.phdrs.items[index]; - return @intCast(phdr.p_vaddr); + return @intCast(phdr.vaddr); } pub fn getShString(self: Elf, off: u32) [:0]const u8 { @@ -3886,10 +3886,10 @@ fn formatShdrFlags(sh_flags: u64, writer: *std.Io.Writer) std.Io.Writer.Error!vo const FormatPhdr = struct { elf_file: *Elf, - phdr: elf.Elf64_Phdr, + phdr: elf.Elf64.Phdr, }; -fn fmtPhdr(self: *Elf, phdr: elf.Elf64_Phdr) std.fmt.Alt(FormatPhdr, formatPhdr) { +fn fmtPhdr(self: *Elf, phdr: elf.Elf64.Phdr) std.fmt.Alt(FormatPhdr, formatPhdr) { return .{ .data = .{ .phdr = phdr, .elf_file = self, @@ -3898,28 +3898,28 @@ fn fmtPhdr(self: *Elf, phdr: elf.Elf64_Phdr) std.fmt.Alt(FormatPhdr, formatPhdr) fn formatPhdr(ctx: FormatPhdr, writer: *std.Io.Writer) std.Io.Writer.Error!void { const phdr = ctx.phdr; - const write = phdr.p_flags & elf.PF_W != 0; - const read = phdr.p_flags & elf.PF_R != 0; - const exec = phdr.p_flags & elf.PF_X != 0; + const write = phdr.flags.W; + const read = phdr.flags.R; + const exec = phdr.flags.X; var flags: [3]u8 = @splat('_'); if (exec) flags[0] = 'X'; if (write) flags[1] = 'W'; if (read) flags[2] = 'R'; - const p_type = switch (phdr.p_type) { - @backingInt(elf.PT.LOAD) => "LOAD", - @backingInt(elf.PT.TLS) => "TLS", - @backingInt(elf.PT.GNU_EH_FRAME) => "GNU_EH_FRAME", - @backingInt(elf.PT.GNU_STACK) => "GNU_STACK", - @backingInt(elf.PT.DYNAMIC) => "DYNAMIC", - @backingInt(elf.PT.INTERP) => "INTERP", - @backingInt(elf.PT.NULL) => "NULL", - @backingInt(elf.PT.PHDR) => "PHDR", - @backingInt(elf.PT.NOTE) => "NOTE", + const p_type = switch (phdr.type) { + .LOAD => "LOAD", + .TLS => "TLS", + .GNU_EH_FRAME => "GNU_EH_FRAME", + .GNU_STACK => "GNU_STACK", + .DYNAMIC => "DYNAMIC", + .INTERP => "INTERP", + .NULL => "NULL", + .PHDR => "PHDR", + .NOTE => "NOTE", else => "UNKNOWN", }; try writer.print("{s} : {s} : @{x} ({x}) : align({x}) : filesz({x}) : memsz({x})", .{ - p_type, flags, phdr.p_offset, phdr.p_vaddr, - phdr.p_align, phdr.p_filesz, phdr.p_memsz, + p_type, flags, phdr.offset, phdr.vaddr, + phdr.@"align", phdr.filesz, phdr.memsz, }); } -- 2.54.0