Add InstallRawStep to Zig build system that does a similar job to llvm-objcopy. To use it, do 'exe.installRaw("kernel.bin");' where exe is a LibExeObjStep

Part of #2826

lib/std/build.zig

@@ -21,6 +21,7 @@ pub const TranslateCStep = @import("build/translate_c.zig").TranslateCStep;
 pub const WriteFileStep = @import("build/write_file.zig").WriteFileStep;
 pub const RunStep = @import("build/run.zig").RunStep;
 pub const CheckFileStep = @import("build/check_file.zig").CheckFileStep;
+pub const InstallRawStep = @import("build/emit_raw.zig").InstallRawStep;
 
 pub const Builder = struct {
     install_tls: TopLevelStep,
@@ -824,6 +825,10 @@ pub const Builder = struct {
         self.getInstallStep().dependOn(&self.addInstallFileWithDir(src_path, .Lib, dest_rel_path).step);
     }
 
+    pub fn installRaw(self: *Builder, artifact: *LibExeObjStep, dest_filename: []const u8) void {
+        self.getInstallStep().dependOn(&self.addInstallRaw(artifact, dest_filename).step);
+    }
+
     ///`dest_rel_path` is relative to install prefix path
     pub fn addInstallFile(self: *Builder, src_path: []const u8, dest_rel_path: []const u8) *InstallFileStep {
         return self.addInstallFileWithDir(src_path, .Prefix, dest_rel_path);
@@ -839,6 +844,10 @@ pub const Builder = struct {
         return self.addInstallFileWithDir(src_path, .Lib, dest_rel_path);
     }
 
+    pub fn addInstallRaw(self: *Builder, artifact: *LibExeObjStep, dest_filename: []const u8) *InstallRawStep {
+        return InstallRawStep.create(self, artifact, dest_filename);
+    }
+
     pub fn addInstallFileWithDir(
         self: *Builder,
         src_path: []const u8,
@@ -1407,6 +1416,10 @@ pub const LibExeObjStep = struct {
         self.builder.installArtifact(self);
     }
 
+    pub fn installRaw(self: *LibExeObjStep, dest_filename: [] const u8) void {
+        self.builder.installRaw(self, dest_filename);
+    }
+
     /// Creates a `RunStep` with an executable built with `addExecutable`.
     /// Add command line arguments with `addArg`.
     pub fn run(exe: *LibExeObjStep) *RunStep {

lib/std/build/emit_raw.zig

@@ -0,0 +1,255 @@
+const std = @import("std");
+
+const Allocator = std.mem.Allocator;
+const ArenaAllocator = std.heap.ArenaAllocator;
+const ArrayList = std.ArrayList;
+const Builder = std.build.Builder;
+const File = std.fs.File;
+const InstallDir = std.build.InstallDir;
+const LibExeObjStep = std.build.LibExeObjStep;
+const Step = std.build.Step;
+const elf = std.elf;
+const fs = std.fs;
+const io = std.io;
+const sort = std.sort;
+const warn = std.debug.warn;
+
+const BinOutStream = io.OutStream(anyerror);
+const BinSeekStream = io.SeekableStream(anyerror, anyerror);
+const ElfSeekStream = io.SeekableStream(anyerror, anyerror);
+const ElfInStream = io.InStream(anyerror);
+
+const BinaryElfSection = struct {
+    elfOffset: u64,
+    binaryOffset: u64,
+    fileSize: usize,
+    segment: ?*BinaryElfSegment,
+};
+
+const BinaryElfSegment = struct {
+    physicalAddress: u64,
+    virtualAddress: u64,
+    elfOffset: u64,
+    binaryOffset: u64,
+    fileSize: usize,
+    firstSection: ?*BinaryElfSection,
+};
+
+const BinaryElfOutput = struct {
+    segments: ArrayList(*BinaryElfSegment),
+    sections: ArrayList(*BinaryElfSection),
+
+    const Self = @This();
+
+    pub fn init(allocator: *Allocator) Self {
+        return Self{
+            .segments = ArrayList(*BinaryElfSegment).init(allocator),
+            .sections = ArrayList(*BinaryElfSection).init(allocator),
+        };
+    }
+
+    pub fn deinit(self: *Self) void {
+        self.sections.deinit();
+        self.segments.deinit();
+    }
+
+    pub fn parseElf(self: *Self, elfFile: elf.Elf) !void {
+        const allocator = self.segments.allocator;
+
+        for (elfFile.section_headers) |section, i| {
+            if (sectionValidForOutput(section)) {
+                const newSection = try allocator.create(BinaryElfSection);
+
+                newSection.binaryOffset = 0;
+                newSection.elfOffset = section.sh_offset;
+                newSection.fileSize = @intCast(usize, section.sh_size);
+                newSection.segment = null;
+
+                try self.sections.append(newSection);
+            }
+        }
+
+        for (elfFile.program_headers) |programHeader, i| {
+            if (programHeader.p_type == elf.PT_LOAD) {
+                const newSegment = try allocator.create(BinaryElfSegment);
+
+                newSegment.physicalAddress = if (programHeader.p_paddr != 0) programHeader.p_paddr else programHeader.p_vaddr;
+                newSegment.virtualAddress = programHeader.p_vaddr;
+                newSegment.fileSize = @intCast(usize, programHeader.p_filesz);
+                newSegment.elfOffset = programHeader.p_offset;
+                newSegment.binaryOffset = 0;
+                newSegment.firstSection = null;
+
+                for (self.sections.toSlice()) |section| {
+                    if (sectionWithinSegment(section, programHeader)) {
+                        if (section.segment) |sectionSegment| {
+                            if (sectionSegment.elfOffset > newSegment.elfOffset) {
+                                section.segment = newSegment;
+                            }
+                        } else {
+                            section.segment = newSegment;
+                        }
+
+                        if (newSegment.firstSection == null) {
+                            newSegment.firstSection = section;
+                        }
+                    }
+                }
+
+                try self.segments.append(newSegment);
+            }
+        }
+
+        sort.sort(*BinaryElfSegment, self.segments.toSlice(), segmentSortCompare);
+
+        if (self.segments.len > 0) {
+            const firstSegment = self.segments.at(0);
+            if (firstSegment.firstSection) |firstSection| {
+                const diff = firstSection.elfOffset - firstSegment.elfOffset;
+
+                firstSegment.elfOffset += diff;
+                firstSegment.fileSize += diff;
+                firstSegment.physicalAddress += diff;
+
+                const basePhysicalAddress = firstSegment.physicalAddress;
+
+                for (self.segments.toSlice()) |segment| {
+                    segment.binaryOffset = segment.physicalAddress - basePhysicalAddress;
+                }
+            }
+        }
+
+        for (self.sections.toSlice()) |section| {
+            if (section.segment) |segment| {
+                section.binaryOffset = segment.binaryOffset + (section.elfOffset - segment.elfOffset);
+            }
+        }
+
+        sort.sort(*BinaryElfSection, self.sections.toSlice(), sectionSortCompare);
+    }
+
+    fn sectionWithinSegment(section: *BinaryElfSection, segment: elf.ProgramHeader) bool {
+        return segment.p_offset <= section.elfOffset and (segment.p_offset + segment.p_filesz) >= (section.elfOffset + section.fileSize);
+    }
+
+    fn sectionValidForOutput(section: elf.SectionHeader) bool {
+        return section.sh_size > 0 and section.sh_type != elf.SHT_NOBITS and ((section.sh_flags & elf.SHF_ALLOC) == elf.SHF_ALLOC);
+    }
+
+    fn segmentSortCompare(left: *BinaryElfSegment, right: *BinaryElfSegment) bool {
+        if (left.physicalAddress < right.physicalAddress) {
+            return true;
+        }
+        if (left.physicalAddress > right.physicalAddress) {
+            return false;
+        }
+        return false;
+    }
+
+    fn sectionSortCompare(left: *BinaryElfSection, right: *BinaryElfSection) bool {
+        return left.binaryOffset < right.binaryOffset;
+    }
+};
+
+const WriteContext = struct {
+    inStream: *ElfInStream,
+    inSeekStream: *ElfSeekStream,
+    outStream: *BinOutStream,
+    outSeekStream: *BinSeekStream,
+};
+
+fn writeBinaryElfSection(allocator: *Allocator, context: WriteContext, section: *BinaryElfSection) !void {
+    var readBuffer = try allocator.alloc(u8, section.fileSize);
+    defer allocator.free(readBuffer);
+
+    try context.inSeekStream.seekTo(section.elfOffset);
+    _ = try context.inStream.read(readBuffer);
+
+    try context.outSeekStream.seekTo(section.binaryOffset);
+    try context.outStream.write(readBuffer);
+}
+
+fn emit_raw(allocator: *Allocator, elf_path: []const u8, raw_path: []const u8) !void {
+    var arenaAlloc = ArenaAllocator.init(allocator);
+    errdefer arenaAlloc.deinit();
+    var arena_allocator = &arenaAlloc.allocator;
+
+    const currentDir = fs.cwd();
+
+    var file = try currentDir.openFile(elf_path, File.OpenFlags{});
+    defer file.close();
+
+    var fileInStream = file.inStream();
+    var fileSeekStream = file.seekableStream();
+
+    var elfFile = try elf.Elf.openStream(allocator, @ptrCast(*ElfSeekStream, &fileSeekStream.stream), @ptrCast(*ElfInStream, &fileInStream.stream));
+    defer elfFile.close();
+
+    var outFile = try currentDir.createFile(raw_path, File.CreateFlags{});
+    defer outFile.close();
+
+    var outFileOutStream = outFile.outStream();
+    var outFileSeekStream = outFile.seekableStream();
+
+    const writeContext = WriteContext{
+        .inStream = @ptrCast(*ElfInStream, &fileInStream.stream),
+        .inSeekStream = @ptrCast(*ElfSeekStream, &fileSeekStream.stream),
+        .outStream = @ptrCast(*BinOutStream, &outFileOutStream.stream),
+        .outSeekStream = @ptrCast(*BinSeekStream, &outFileSeekStream.stream),
+    };
+
+    var binaryElfOutput = BinaryElfOutput.init(arena_allocator);
+    defer binaryElfOutput.deinit();
+
+    try binaryElfOutput.parseElf(elfFile);
+
+    for (binaryElfOutput.sections.toSlice()) |section| {
+        try writeBinaryElfSection(allocator, writeContext, section);
+    }
+}
+
+pub const InstallRawStep = struct {
+    step: Step,
+    builder: *Builder,
+    artifact: *LibExeObjStep,
+    dest_dir: InstallDir,
+    dest_filename: [] const u8,
+
+    const Self = @This();
+
+    pub fn create(builder: *Builder, artifact: *LibExeObjStep, dest_filename: [] const u8) *Self {
+        const self = builder.allocator.create(Self) catch unreachable;
+        self.* = Self{
+            .step = Step.init(builder.fmt("install raw binary {}", .{artifact.step.name}), builder.allocator, make),
+            .builder = builder,
+            .artifact = artifact,
+            .dest_dir = switch (artifact.kind) {
+                .Obj => unreachable,
+                .Test => unreachable,
+                .Exe => .Bin,
+                .Lib => unreachable,
+            },
+            .dest_filename = dest_filename,
+        };
+        self.step.dependOn(&artifact.step);
+
+        builder.pushInstalledFile(self.dest_dir, dest_filename);
+        return self;
+    }
+
+    fn make(step: *Step) !void {
+        const self = @fieldParentPtr(Self, "step", step);
+        const builder = self.builder;
+
+        if (self.artifact.target.getObjectFormat() != .elf) {
+            warn("InstallRawStep only works with ELF format.\n", .{});
+            return error.InvalidObjectFormat;
+        }
+
+        const full_src_path = self.artifact.getOutputPath();
+        const full_dest_path = builder.getInstallPath(self.dest_dir, self.dest_filename);
+
+        fs.makePath(builder.allocator, builder.getInstallPath(self.dest_dir, "")) catch unreachable;
+        try emit_raw(builder.allocator, full_src_path, full_dest_path);
+    }
+};

lib/std/debug.zig

@@ -946,8 +946,8 @@ fn readSparseBitVector(stream: var, allocator: *mem.Allocator) ![]usize {
 fn findDwarfSectionFromElf(elf_file: *elf.Elf, name: []const u8) !?DwarfInfo.Section {
     const elf_header = (try elf_file.findSection(name)) orelse return null;
     return DwarfInfo.Section{
-        .offset = elf_header.offset,
-        .size = elf_header.size,
+        .offset = elf_header.sh_offset,
+        .size = elf_header.sh_size,
     };
 }
 
@@ -987,12 +987,12 @@ pub fn openElfDebugInfo(
 
     var di = DwarfInfo{
         .endian = efile.endian,
-        .debug_info = (data[@intCast(usize, debug_info.offset)..@intCast(usize, debug_info.offset + debug_info.size)]),
-        .debug_abbrev = (data[@intCast(usize, debug_abbrev.offset)..@intCast(usize, debug_abbrev.offset + debug_abbrev.size)]),
-        .debug_str = (data[@intCast(usize, debug_str.offset)..@intCast(usize, debug_str.offset + debug_str.size)]),
-        .debug_line = (data[@intCast(usize, debug_line.offset)..@intCast(usize, debug_line.offset + debug_line.size)]),
+        .debug_info = (data[@intCast(usize, debug_info.sh_offset)..@intCast(usize, debug_info.sh_offset + debug_info.sh_size)]),
+        .debug_abbrev = (data[@intCast(usize, debug_abbrev.sh_offset)..@intCast(usize, debug_abbrev.sh_offset + debug_abbrev.sh_size)]),
+        .debug_str = (data[@intCast(usize, debug_str.sh_offset)..@intCast(usize, debug_str.sh_offset + debug_str.sh_size)]),
+        .debug_line = (data[@intCast(usize, debug_line.sh_offset)..@intCast(usize, debug_line.sh_offset + debug_line.sh_size)]),
         .debug_ranges = if (opt_debug_ranges) |debug_ranges|
-            data[@intCast(usize, debug_ranges.offset)..@intCast(usize, debug_ranges.offset + debug_ranges.size)]
+            data[@intCast(usize, debug_ranges.sh_offset)..@intCast(usize, debug_ranges.sh_offset + debug_ranges.sh_size)]
         else
             null,
     };

lib/std/elf.zig

@@ -330,19 +330,8 @@ pub const ET = extern enum(u16) {
     pub const HIPROC = 0xffff;
 };
 
-/// TODO delete this in favor of Elf64_Shdr
-pub const SectionHeader = struct {
-    name: u32,
-    sh_type: u32,
-    flags: u64,
-    addr: u64,
-    offset: u64,
-    size: u64,
-    link: u32,
-    info: u32,
-    addr_align: u64,
-    ent_size: u64,
-};
+pub const SectionHeader = Elf64_Shdr;
+pub const ProgramHeader = Elf64_Phdr;
 
 pub const Elf = struct {
     seekable_stream: *io.SeekableStream(anyerror, anyerror),
@@ -357,6 +346,7 @@ pub const Elf = struct {
     string_section_index: usize,
     string_section: *SectionHeader,
     section_headers: []SectionHeader,
+    program_headers: []ProgramHeader,
     allocator: *mem.Allocator,
 
     /// Call close when done.
@@ -421,14 +411,24 @@ pub const Elf = struct {
         try seekable_stream.seekBy(4);
 
         const header_size = try in.readInt(u16, elf.endian);
-        if ((elf.is_64 and header_size != 64) or (!elf.is_64 and header_size != 52)) {
+        if ((elf.is_64 and header_size != @sizeOf(Elf64_Ehdr)) or (!elf.is_64 and header_size != @sizeOf(Elf32_Ehdr))) {
             return error.InvalidFormat;
         }
 
         const ph_entry_size = try in.readInt(u16, elf.endian);
         const ph_entry_count = try in.readInt(u16, elf.endian);
+
+        if ((elf.is_64 and ph_entry_size != @sizeOf(Elf64_Phdr)) or (!elf.is_64 and ph_entry_size != @sizeOf(Elf32_Phdr))) {
+            return error.InvalidFormat;
+        }
+
         const sh_entry_size = try in.readInt(u16, elf.endian);
         const sh_entry_count = try in.readInt(u16, elf.endian);
+
+        if ((elf.is_64 and sh_entry_size != @sizeOf(Elf64_Shdr)) or (!elf.is_64 and sh_entry_size != @sizeOf(Elf32_Shdr))) {
+            return error.InvalidFormat;
+        }
+
         elf.string_section_index = @as(usize, try in.readInt(u16, elf.endian));
 
         if (elf.string_section_index >= sh_entry_count) return error.InvalidFormat;
@@ -443,47 +443,72 @@ pub const Elf = struct {
             return error.InvalidFormat;
         }
 
+        try seekable_stream.seekTo(elf.program_header_offset);
+
+        elf.program_headers = try elf.allocator.alloc(ProgramHeader, ph_entry_count);
+        errdefer elf.allocator.free(elf.program_headers);
+
+        if (elf.is_64) {
+            for (elf.program_headers) |*elf_program| {
+                elf_program.p_type = try in.readInt(Elf64_Word, elf.endian);
+                elf_program.p_flags = try in.readInt(Elf64_Word, elf.endian);
+                elf_program.p_offset = try in.readInt(Elf64_Off, elf.endian);
+                elf_program.p_vaddr = try in.readInt(Elf64_Addr, elf.endian);
+                elf_program.p_paddr = try in.readInt(Elf64_Addr, elf.endian);
+                elf_program.p_filesz = try in.readInt(Elf64_Xword, elf.endian);
+                elf_program.p_memsz = try in.readInt(Elf64_Xword, elf.endian);
+                elf_program.p_align = try in.readInt(Elf64_Xword, elf.endian);
+            }
+        } else {
+            for (elf.program_headers) |*elf_program| {
+                elf_program.p_type = @as(Elf64_Word, try in.readInt(Elf32_Word, elf.endian));
+                elf_program.p_offset = @as(Elf64_Off, try in.readInt(Elf32_Off, elf.endian));
+                elf_program.p_vaddr = @as(Elf64_Addr, try in.readInt(Elf32_Addr, elf.endian));
+                elf_program.p_paddr = @as(Elf64_Addr, try in.readInt(Elf32_Addr, elf.endian));
+                elf_program.p_filesz = @as(Elf64_Word, try in.readInt(Elf32_Word, elf.endian));
+                elf_program.p_memsz = @as(Elf64_Word, try in.readInt(Elf32_Word, elf.endian));
+                elf_program.p_flags = @as(Elf64_Word, try in.readInt(Elf32_Word, elf.endian));
+                elf_program.p_align = @as(Elf64_Word, try in.readInt(Elf32_Word, elf.endian));
+            }
+        }
+
         try seekable_stream.seekTo(elf.section_header_offset);
 
         elf.section_headers = try elf.allocator.alloc(SectionHeader, sh_entry_count);
         errdefer elf.allocator.free(elf.section_headers);
 
         if (elf.is_64) {
-            if (sh_entry_size != 64) return error.InvalidFormat;
-
             for (elf.section_headers) |*elf_section| {
-                elf_section.name = try in.readInt(u32, elf.endian);
+                elf_section.sh_name = try in.readInt(u32, elf.endian);
                 elf_section.sh_type = try in.readInt(u32, elf.endian);
-                elf_section.flags = try in.readInt(u64, elf.endian);
-                elf_section.addr = try in.readInt(u64, elf.endian);
-                elf_section.offset = try in.readInt(u64, elf.endian);
-                elf_section.size = try in.readInt(u64, elf.endian);
-                elf_section.link = try in.readInt(u32, elf.endian);
-                elf_section.info = try in.readInt(u32, elf.endian);
-                elf_section.addr_align = try in.readInt(u64, elf.endian);
-                elf_section.ent_size = try in.readInt(u64, elf.endian);
+                elf_section.sh_flags = try in.readInt(u64, elf.endian);
+                elf_section.sh_addr = try in.readInt(u64, elf.endian);
+                elf_section.sh_offset = try in.readInt(u64, elf.endian);
+                elf_section.sh_size = try in.readInt(u64, elf.endian);
+                elf_section.sh_link = try in.readInt(u32, elf.endian);
+                elf_section.sh_info = try in.readInt(u32, elf.endian);
+                elf_section.sh_addralign = try in.readInt(u64, elf.endian);
+                elf_section.sh_entsize = try in.readInt(u64, elf.endian);
             }
         } else {
-            if (sh_entry_size != 40) return error.InvalidFormat;
-
             for (elf.section_headers) |*elf_section| {
                 // TODO (multiple occurrences) allow implicit cast from %u32 -> %u64 ?
-                elf_section.name = try in.readInt(u32, elf.endian);
+                elf_section.sh_name = try in.readInt(u32, elf.endian);
                 elf_section.sh_type = try in.readInt(u32, elf.endian);
-                elf_section.flags = @as(u64, try in.readInt(u32, elf.endian));
-                elf_section.addr = @as(u64, try in.readInt(u32, elf.endian));
-                elf_section.offset = @as(u64, try in.readInt(u32, elf.endian));
-                elf_section.size = @as(u64, try in.readInt(u32, elf.endian));
-                elf_section.link = try in.readInt(u32, elf.endian);
-                elf_section.info = try in.readInt(u32, elf.endian);
-                elf_section.addr_align = @as(u64, try in.readInt(u32, elf.endian));
-                elf_section.ent_size = @as(u64, try in.readInt(u32, elf.endian));
+                elf_section.sh_flags = @as(u64, try in.readInt(u32, elf.endian));
+                elf_section.sh_addr = @as(u64, try in.readInt(u32, elf.endian));
+                elf_section.sh_offset = @as(u64, try in.readInt(u32, elf.endian));
+                elf_section.sh_size = @as(u64, try in.readInt(u32, elf.endian));
+                elf_section.sh_link = try in.readInt(u32, elf.endian);
+                elf_section.sh_info = try in.readInt(u32, elf.endian);
+                elf_section.sh_addralign = @as(u64, try in.readInt(u32, elf.endian));
+                elf_section.sh_entsize = @as(u64, try in.readInt(u32, elf.endian));
             }
         }
 
         for (elf.section_headers) |*elf_section| {
             if (elf_section.sh_type != SHT_NOBITS) {
-                const file_end_offset = try math.add(u64, elf_section.offset, elf_section.size);
+                const file_end_offset = try math.add(u64, elf_section.sh_offset, elf_section.sh_size);
                 if (stream_end < file_end_offset) return error.InvalidFormat;
             }
         }
@@ -499,13 +524,14 @@ pub const Elf = struct {
 
     pub fn close(elf: *Elf) void {
         elf.allocator.free(elf.section_headers);
+        elf.allocator.free(elf.program_headers);
     }
 
     pub fn findSection(elf: *Elf, name: []const u8) !?*SectionHeader {
         section_loop: for (elf.section_headers) |*elf_section| {
             if (elf_section.sh_type == SHT_NULL) continue;
 
-            const name_offset = elf.string_section.offset + elf_section.name;
+            const name_offset = elf.string_section.sh_offset + elf_section.sh_name;
             try elf.seekable_stream.seekTo(name_offset);
 
             for (name) |expected_c| {
@@ -523,7 +549,7 @@ pub const Elf = struct {
     }
 
     pub fn seekToSection(elf: *Elf, elf_section: *SectionHeader) !void {
-        try elf.seekable_stream.seekTo(elf_section.offset);
+        try elf.seekable_stream.seekTo(elf_section.sh_offset);
     }
 };
 
@@ -578,6 +604,26 @@ pub const Elf64_Ehdr = extern struct {
     e_shnum: Elf64_Half,
     e_shstrndx: Elf64_Half,
 };
+pub const Elf32_Phdr = extern struct {
+    p_type: Elf32_Word,
+    p_offset: Elf32_Off,
+    p_vaddr: Elf32_Addr,
+    p_paddr: Elf32_Addr,
+    p_filesz: Elf32_Word,
+    p_memsz: Elf32_Word,
+    p_flags: Elf32_Word,
+    p_align: Elf32_Word,
+};
+pub const Elf64_Phdr = extern struct {
+    p_type: Elf64_Word,
+    p_flags: Elf64_Word,
+    p_offset: Elf64_Off,
+    p_vaddr: Elf64_Addr,
+    p_paddr: Elf64_Addr,
+    p_filesz: Elf64_Xword,
+    p_memsz: Elf64_Xword,
+    p_align: Elf64_Xword,
+};
 pub const Elf32_Shdr = extern struct {
     sh_name: Elf32_Word,
     sh_type: Elf32_Word,
@@ -655,26 +701,6 @@ pub const Elf64_Rela = extern struct {
     r_info: Elf64_Xword,
     r_addend: Elf64_Sxword,
 };
-pub const Elf32_Phdr = extern struct {
-    p_type: Elf32_Word,
-    p_offset: Elf32_Off,
-    p_vaddr: Elf32_Addr,
-    p_paddr: Elf32_Addr,
-    p_filesz: Elf32_Word,
-    p_memsz: Elf32_Word,
-    p_flags: Elf32_Word,
-    p_align: Elf32_Word,
-};
-pub const Elf64_Phdr = extern struct {
-    p_type: Elf64_Word,
-    p_flags: Elf64_Word,
-    p_offset: Elf64_Off,
-    p_vaddr: Elf64_Addr,
-    p_paddr: Elf64_Addr,
-    p_filesz: Elf64_Xword,
-    p_memsz: Elf64_Xword,
-    p_align: Elf64_Xword,
-};
 pub const Elf32_Dyn = extern struct {
     d_tag: Elf32_Sword,
     d_un: extern union {
@@ -833,6 +859,17 @@ pub const Elf_MIPS_ABIFlags_v0 = extern struct {
     flags2: Elf32_Word,
 };
 
+comptime {
+    debug.assert(@sizeOf(Elf32_Ehdr) == 52);
+    debug.assert(@sizeOf(Elf64_Ehdr) == 64);
+
+    debug.assert(@sizeOf(Elf32_Phdr) == 32);
+    debug.assert(@sizeOf(Elf64_Phdr) == 56);
+
+    debug.assert(@sizeOf(Elf32_Shdr) == 40);
+    debug.assert(@sizeOf(Elf64_Shdr) == 64);
+}
+
 pub const Auxv = switch (@sizeOf(usize)) {
     4 => Elf32_auxv_t,
     8 => Elf64_auxv_t,

lib/std/target.zig

@@ -972,6 +972,23 @@ pub const Target = union(enum) {
         }
     }
 
+    pub fn getObjectFormat(self: Target) ObjectFormat {
+        switch (self) {
+            .Native => return @import("builtin").object_format,
+            .Cross => blk: {
+                if (self.isWindows() or self.isUefi()) {
+                    return .coff;
+                } else if (self.isDarwin()) {
+                    return .macho;
+                }
+                if (self.isWasm()) {
+                    return .wasm;
+                }
+                return .elf;
+            },
+        }
+    }
+
     pub fn isMinGW(self: Target) bool {
         return self.isWindows() and self.isGnu();
     }

src-self-hosted/codegen.zig

@@ -31,7 +31,7 @@ pub async fn renderToLlvm(comp: *Compilation, fn_val: *Value.Fn, code: *ir.Code)
     llvm.SetTarget(module, comp.llvm_triple.toSliceConst());
     llvm.SetDataLayout(module, comp.target_layout_str);
 
-    if (util.getObjectFormat(comp.target) == .coff) {
+    if (comp.target.getObjectFormat() == .coff) {
         llvm.AddModuleCodeViewFlag(module);
     } else {
         llvm.AddModuleDebugInfoFlag(module);

src-self-hosted/link.zig

@@ -76,7 +76,7 @@ pub fn link(comp: *Compilation) !void {
         std.debug.warn("\n", .{});
     }
 
-    const extern_ofmt = toExternObjectFormatType(util.getObjectFormat(comp.target));
+    const extern_ofmt = toExternObjectFormatType(comp.target.getObjectFormat());
     const args_slice = ctx.args.toSlice();
 
     {
@@ -128,7 +128,7 @@ fn toExternObjectFormatType(ofmt: ObjectFormat) c.ZigLLVM_ObjectFormatType {
 }
 
 fn constructLinkerArgs(ctx: *Context) !void {
-    switch (util.getObjectFormat(ctx.comp.target)) {
+    switch (ctx.comp.target.getObjectFormat()) {
         .unknown => unreachable,
         .coff => return constructLinkerArgsCoff(ctx),
         .elf => return constructLinkerArgsElf(ctx),

src-self-hosted/util.zig

@@ -32,23 +32,6 @@ pub fn getFloatAbi(self: Target) FloatAbi {
     };
 }
 
-pub fn getObjectFormat(target: Target) Target.ObjectFormat {
-    switch (target) {
-        .Native => return @import("builtin").object_format,
-        .Cross => blk: {
-            if (target.isWindows() or target.isUefi()) {
-                return .coff;
-            } else if (target.isDarwin()) {
-                return .macho;
-            }
-            if (target.isWasm()) {
-                return .wasm;
-            }
-            return .elf;
-        },
-    }
-}
-
 pub fn getDynamicLinkerPath(self: Target) ?[]const u8 {
     const env = self.getAbi();
     const arch = self.getArch();