From e1cf2c8346fd16849b7f71f982ddda7adf0fe97b Mon Sep 17 00:00:00 2001 From: Xavier Bouchoux Date: Sun, 12 Mar 2023 12:19:16 +0100 Subject: [PATCH] objcopy: cleanups and extract helper functions to reduce bloat parts of the code are independant of Elf32/Elf64 variant, so avoid generating the code twice by putting them outside of the generic struct. --- src/objcopy.zig | 504 +++++++++++++++++++++++++----------------------- 1 file changed, 263 insertions(+), 241 deletions(-) diff --git a/src/objcopy.zig b/src/objcopy.zig index 063fd63fbd..4a15af88e3 100644 --- a/src/objcopy.zig +++ b/src/objcopy.zig @@ -129,10 +129,6 @@ pub fn cmdObjCopy( fatal("zig objcopy: ELF to RAW or HEX copying does not support --strip", .{}); if (opt_extract != null) fatal("zig objcopy: ELF to RAW or HEX copying does not support --extract-to", .{}); - if (opt_extract != null) - fatal("zig objcopy: ELF to RAW or HEX copying does not support --extract-to", .{}); - if (opt_extract != null) - fatal("zig objcopy: ELF to RAW or HEX copying does not support --extract-to", .{}); try emitElf(arena, in_file, out_file, elf_hdr, .{ .ofmt = out_fmt, @@ -658,7 +654,7 @@ test "containsValidAddressRange" { // ------------- // ELF to ELF stripping -pub const StripElfOptions = struct { +const StripElfOptions = struct { extract_to: ?[]const u8 = null, add_debuglink: ?[]const u8 = null, strip_all: bool = false, @@ -673,72 +669,64 @@ fn stripElf( elf_hdr: elf.Header, options: StripElfOptions, ) !void { + const Filter = ElfFileHelper.Filter; + const DebugLink = ElfFileHelper.DebugLink; + + const filter: Filter = filter: { + if (options.only_keep_debug) break :filter .debug; + if (options.strip_all) break :filter .program; + if (options.strip_debug) break :filter .program_and_symbols; + break :filter .all; + }; + + const filter_complement: ?Filter = blk: { + if (options.extract_to) |_| { + break :blk switch (filter) { + .program => .debug_and_symbols, + .debug => .program_and_symbols, + .program_and_symbols => .debug, + .debug_and_symbols => .program, + .all => fatal("zig objcopy: nothing to extract", .{}), + }; + } else { + break :blk null; + } + }; + const debuglink_path = path: { + if (options.add_debuglink) |path| break :path path; + if (options.extract_to) |path| break :path path; + break :path null; + }; + switch (elf_hdr.is_64) { inline else => |is_64| { - const Elf = ElfContents(is_64); - const Filter = Elf.Filter; - const DebugLink = Elf.DebugLink; + var elf_file = try ElfFile(is_64).parse(allocator, in_file, elf_hdr); + defer elf_file.deinit(); - var elf_contents = try Elf.parse(allocator, in_file, elf_hdr); - defer elf_contents.deinit(); - - const filter: Filter = filter: { - if (options.only_keep_debug) break :filter .debug; - if (options.strip_all) break :filter .program; - if (options.strip_debug) break :filter .program_and_symbols; - break :filter .all; - }; - - if (options.extract_to) |filename| { - const dbg_file = std.fs.cwd().createFile(filename, .{}) catch |err| { - fatal("zig objcopy: unable to create '{s}': {s}", .{ filename, @errorName(err) }); + if (filter_complement) |flt| { + // write the .dbg file and close it, so it can be read back to compute the debuglink checksum. + const path = options.extract_to.?; + const dbg_file = std.fs.cwd().createFile(path, .{}) catch |err| { + fatal("zig objcopy: unable to create '{s}': {s}", .{ path, @errorName(err) }); }; defer dbg_file.close(); - const filter_complement: Filter = switch (filter) { - .program => .debug_and_symbols, - .debug => .program_and_symbols, - .program_and_symbols => .debug, - .debug_and_symbols => .program, - .all => fatal("zig objcopy: nothing to extract", .{}), - }; - - try elf_contents.emit(allocator, dbg_file, in_file, filter_complement, null); + try elf_file.emit(allocator, dbg_file, in_file, .{ .section_filter = flt }); } - const debuglink: ?DebugLink = blk: { - const debuglink_filename = name: { - if (options.add_debuglink) |filename| break :name filename; - if (options.extract_to) |filename| break :name filename; - break :name null; - }; - if (debuglink_filename) |filename| { - const dbg_file = std.fs.cwd().openFile(filename, .{}) catch |err| { - fatal("zig objcopy: could not read `{s}`: {s}\n", .{ filename, @errorName(err) }); - }; - defer dbg_file.close(); - - break :blk .{ - .name = std.fs.path.basename(filename), - .crc32 = try computeFileCrc(dbg_file), - }; - } else { - break :blk null; - } - }; - - try elf_contents.emit(allocator, out_file, in_file, filter, debuglink); + const debuglink: ?DebugLink = if (debuglink_path) |path| ElfFileHelper.createDebugLink(path) else null; + try elf_file.emit(allocator, out_file, in_file, .{ .section_filter = filter, .debuglink = debuglink }); }, } } // note: this is "a minimal effort implementation" // It doesn't support all possibile elf files: some sections type may need fixups, the program header may need fix up, ... -// it was written for a specific use case (strip debug info to a sperate file, for linux 64-bits executables built with `zig` or `zig c++` ) -// It manupulates and reoders the sections as little as possible to avoid having to do fixups. +// It was written for a specific use case (strip debug info to a sperate file, for linux 64-bits executables built with `zig` or `zig c++` ) +// It moves and reoders the sections as little as possible to avoid having to do fixups. // TODO: support non-native endianess -fn ElfContents(comptime is_64: bool) type { +fn ElfFile(comptime is_64: bool) type { const Elf_Ehdr = if (is_64) elf.Elf64_Ehdr else elf.Elf32_Ehdr; const Elf_Phdr = if (is_64) elf.Elf64_Phdr else elf.Elf32_Phdr; const Elf_Shdr = if (is_64) elf.Elf64_Shdr else elf.Elf32_Shdr; @@ -752,27 +740,26 @@ fn ElfContents(comptime is_64: bool) type { sections: []const Section, arena: std.heap.ArenaAllocator, + const SectionCategory = ElfFileHelper.SectionCategory; const section_memory_align = @alignOf(Elf_Sym); // most restrictive of what we may load in memory const Section = struct { section: Elf_Shdr, name: []const u8 = "", segment: ?*const Elf_Phdr = null, // if the section is used by a program segment (there can be more than one) payload: ?[]align(section_memory_align) const u8 = null, // if we need the data in memory - usage: Usage = .none, // should the section be kept in the exe or stripped to the debug database, or both. - - const Usage = enum { common, exe, debug, symbols, none }; + category: SectionCategory = .none, // should the section be kept in the exe or stripped to the debug database, or both. }; const Self = @This(); - pub fn parse(gpa: Allocator, source: File, header: elf.Header) !Self { + pub fn parse(gpa: Allocator, in_file: File, header: elf.Header) !Self { var arena = std.heap.ArenaAllocator.init(gpa); errdefer arena.deinit(); const allocator = arena.allocator(); var raw_header: Elf_Ehdr = undefined; { - const bytes_read = try source.preadAll(std.mem.asBytes(&raw_header), 0); + const bytes_read = try in_file.preadAll(std.mem.asBytes(&raw_header), 0); if (bytes_read < @sizeOf(Elf_Ehdr)) return error.TRUNCATED_ELF; } @@ -783,7 +770,7 @@ fn ElfContents(comptime is_64: bool) type { fatal("zig objcopy: unsuported ELF file, unexpected phentsize ({d})", .{header.phentsize}); const program_header = try allocator.alloc(Elf_Phdr, header.phnum); - const bytes_read = try source.preadAll(std.mem.sliceAsBytes(program_header), header.phoff); + const bytes_read = try in_file.preadAll(std.mem.sliceAsBytes(program_header), header.phoff); if (bytes_read < @sizeOf(Elf_Phdr) * header.phnum) return error.TRUNCATED_ELF; break :blk program_header; @@ -798,7 +785,7 @@ fn ElfContents(comptime is_64: bool) type { const raw_section_header = try allocator.alloc(Elf_Shdr, header.shnum); defer allocator.free(raw_section_header); - const bytes_read = try source.preadAll(std.mem.sliceAsBytes(raw_section_header), header.shoff); + const bytes_read = try in_file.preadAll(std.mem.sliceAsBytes(raw_section_header), header.shoff); if (bytes_read < @sizeOf(Elf_Phdr) * header.shnum) return error.TRUNCATED_ELF; @@ -821,7 +808,7 @@ fn ElfContents(comptime is_64: bool) type { if (need_data or need_strings) { const buffer = try allocator.alignedAlloc(u8, section_memory_align, @intCast(usize, section.section.sh_size)); - const bytes_read = try source.preadAll(buffer, section.section.sh_offset); + const bytes_read = try in_file.preadAll(buffer, section.section.sh_offset); if (bytes_read != section.section.sh_size) return error.TRUNCATED_ELF; section.payload = buffer; } @@ -830,7 +817,7 @@ fn ElfContents(comptime is_64: bool) type { // fill-in sections info: // resolve the name // find if a program segment uses the section - // classify sections usage (used by program segments, debug datadase, common metadata, symbol table) + // categorise sections usage (used by program segments, debug datadase, common metadata, symbol table) for (sections) |*section| { section.segment = for (program_segments) |*seg| { if (sectionWithinSegment(section.section, seg.*)) break seg; @@ -839,65 +826,36 @@ fn ElfContents(comptime is_64: bool) type { if (section.section.sh_name != 0 and header.shstrndx != elf.SHN_UNDEF) section.name = std.mem.span(@ptrCast([*:0]const u8, §ions[header.shstrndx].payload.?[section.section.sh_name])); - const usage_from_program: Section.Usage = if (section.segment != null) .exe else .debug; - section.usage = switch (section.section.sh_type) { + const category_from_program: SectionCategory = if (section.segment != null) .exe else .debug; + section.category = switch (section.section.sh_type) { elf.SHT_NOTE => .common, elf.SHT_SYMTAB => .symbols, // "strip all" vs "strip only debug" elf.SHT_DYNSYM => .exe, - elf.SHT_PROGBITS => usage: { - if (std.mem.eql(u8, section.name, ".comment")) break :usage .exe; - if (std.mem.eql(u8, section.name, ".gnu_debuglink")) break :usage .none; - break :usage usage_from_program; + elf.SHT_PROGBITS => cat: { + if (std.mem.eql(u8, section.name, ".comment")) break :cat .exe; + if (std.mem.eql(u8, section.name, ".gnu_debuglink")) break :cat .none; + break :cat category_from_program; }, elf.SHT_LOPROC...elf.SHT_HIPROC => .common, // don't strip unkonwn sections elf.SHT_LOUSER...elf.SHT_HIUSER => .common, // don't strip unkonwn sections - else => usage_from_program, + else => category_from_program, }; } - sections[0].usage = .common; // mandatory null section + sections[0].category = .common; // mandatory null section if (header.shstrndx != elf.SHN_UNDEF) - sections[header.shstrndx].usage = .common; // string table for the headers + sections[header.shstrndx].category = .common; // string table for the headers // recursive dependencies var dirty: u1 = 1; while (dirty != 0) { dirty = 0; - const Local = struct { - fn propagateUsage(cur: *Section.Usage, new: Section.Usage) u1 { - const use: Section.Usage = switch (cur.*) { - .none => new, - .common => .common, - .debug => switch (new) { - .none, .debug => .debug, - else => new, - }, - .exe => switch (new) { - .common => .common, - .none, .debug, .exe => .exe, - .symbols => .exe, - }, - .symbols => switch (new) { - .none, .common, .debug, .exe => unreachable, - .symbols => .symbols, - }, - }; - - if (cur.* != use) { - cur.* = use; - return 1; - } else { - return 0; - } - } - }; - for (sections) |*section| { if (section.section.sh_link != elf.SHN_UNDEF) - dirty |= Local.propagateUsage(§ions[section.section.sh_link].usage, section.usage); + dirty |= ElfFileHelper.propagateCategory(§ions[section.section.sh_link].category, section.category); if ((section.section.sh_flags & elf.SHF_INFO_LINK) != 0 and section.section.sh_info != elf.SHN_UNDEF) - dirty |= Local.propagateUsage(§ions[section.section.sh_info].usage, section.usage); + dirty |= ElfFileHelper.propagateCategory(§ions[section.section.sh_info].category, section.category); if (section.payload) |data| { switch (section.section.sh_type) { @@ -906,7 +864,7 @@ fn ElfContents(comptime is_64: bool) type { const defs = @ptrCast([*]const Elf_Verdef, data)[0 .. @intCast(usize, section.section.sh_size) / @sizeOf(Elf_Verdef)]; for (defs) |def| { if (def.vd_ndx != elf.SHN_UNDEF) - dirty |= Local.propagateUsage(§ions[def.vd_ndx].usage, section.usage); + dirty |= ElfFileHelper.propagateCategory(§ions[def.vd_ndx].category, section.category); } }, elf.SHT_SYMTAB, elf.SHT_DYNSYM => { @@ -915,7 +873,7 @@ fn ElfContents(comptime is_64: bool) type { for (syms) |sym| { if (sym.st_shndx != elf.SHN_UNDEF and sym.st_shndx < elf.SHN_LORESERVE) - dirty |= Local.propagateUsage(§ions[sym.st_shndx].usage, section.usage); + dirty |= ElfFileHelper.propagateCategory(§ions[sym.st_shndx].category, section.category); } }, else => {}, @@ -936,9 +894,13 @@ fn ElfContents(comptime is_64: bool) type { self.arena.deinit(); } - const DebugLink = struct { name: []const u8, crc32: u32 }; - const Filter = enum { all, program, debug, program_and_symbols, debug_and_symbols }; - fn emit(self: *const Self, gpa: Allocator, output: File, source: File, filter: Filter, debuglink: ?DebugLink) !void { + const Filter = ElfFileHelper.Filter; + const DebugLink = ElfFileHelper.DebugLink; + const EmitElfOptions = struct { + section_filter: Filter = .all, + debuglink: ?DebugLink = null, + }; + fn emit(self: *const Self, gpa: Allocator, out_file: File, in_file: File, options: EmitElfOptions) !void { var arena = std.heap.ArenaAllocator.init(gpa); defer arena.deinit(); const allocator = arena.allocator(); @@ -950,63 +912,37 @@ fn ElfContents(comptime is_64: bool) type { // the program header is kept unchanged. (`strip` does update it, but `eu-strip` does not, and it still works) const Update = struct { - action: enum { keep, strip, empty }, + action: ElfFileHelper.Action, // remap the indexs after omitting the filtered sections remap_idx: u16, // optionally overrides the payload from the source file - payload: ?[]align(section_memory_align) const u8, + payload: ?[]align(section_memory_align) const u8 = null, + section: ?Elf_Shdr = null, }; const sections_update = try allocator.alloc(Update, self.sections.len); const new_shnum = blk: { var next_idx: u16 = 0; for (self.sections, sections_update) |section, *update| { - update.action = action: { - if (section.usage == .none) break :action .strip; - break :action switch (filter) { - .all => switch (section.usage) { - .none => .strip, - else => .keep, - }, - .program => switch (section.usage) { - .common, .exe => .keep, - else => .strip, - }, - .program_and_symbols => switch (section.usage) { - .common, .exe, .symbols => .keep, - else => .strip, - }, - .debug => switch (section.usage) { - .exe, .symbols => .empty, - .none => .strip, - else => .keep, - }, - .debug_and_symbols => switch (section.usage) { - .exe => .empty, - .none => .strip, - else => .keep, - }, - }; - }; - - if (update.action == .strip) { - update.remap_idx = elf.SHN_UNDEF; - } else { - update.remap_idx = next_idx; + const action = ElfFileHelper.selectAction(section.category, options.section_filter); + const remap_idx = idx: { + if (action == .strip) break :idx elf.SHN_UNDEF; next_idx += 1; - } - - update.payload = null; + break :idx next_idx - 1; + }; + update.* = Update{ .action = action, .remap_idx = remap_idx }; } - if (debuglink != null) + if (options.debuglink != null) next_idx += 1; + break :blk next_idx; }; + // add a ".gnu_debuglink" to the string table if needed const debuglink_name: u32 = blk: { - if (debuglink == null) break :blk elf.SHN_UNDEF; + if (options.debuglink == null) break :blk elf.SHN_UNDEF; if (self.raw_elf_header.e_shstrndx == elf.SHN_UNDEF) fatal("zig objcopy: no strtab, cannot add the debuglink section", .{}); // TODO add the section if needed? @@ -1026,11 +962,7 @@ fn ElfContents(comptime is_64: bool) type { break :blk new_offset; }; - const WriteCmd = union(enum) { - copy_range: struct { in_offset: u64, len: u64, out_offset: u64 }, - write_data: struct { data: []const u8, out_offset: u64 }, - }; - var cmdbuf = std.ArrayList(WriteCmd).init(allocator); + var cmdbuf = std.ArrayList(ElfFileHelper.WriteCmd).init(allocator); defer cmdbuf.deinit(); try cmdbuf.ensureUnusedCapacity(3 + new_shnum); var eof_offset: Elf_OffSize = 0; // track the end of the data written so far. @@ -1076,8 +1008,9 @@ fn ElfContents(comptime is_64: bool) type { if (update.action == .strip) continue; std.debug.assert(update.remap_idx == dest_section_idx); - const src = §ion.section; + const src = if (update.section) |*s| s else §ion.section; const dest = &dest_sections[dest_section_idx]; + const payload = if (update.payload) |data| data else section.payload; dest_section_idx += 1; dest.* = src.*; @@ -1087,7 +1020,6 @@ fn ElfContents(comptime is_64: bool) type { if ((src.sh_flags & elf.SHF_INFO_LINK) != 0 and src.sh_info != elf.SHN_UNDEF) dest.sh_info = sections_update[src.sh_info].remap_idx; - const payload = if (update.payload) |data| data else section.payload; if (payload) |data| dest.sh_size = @intCast(Elf_OffSize, data.len); @@ -1108,29 +1040,36 @@ fn ElfContents(comptime is_64: bool) type { if (dest.sh_type != elf.SHT_NOBITS) { if (payload) |src_data| { // update sections payload and write - const data = try allocator.alignedAlloc(u8, section_memory_align, src_data.len); - std.mem.copy(u8, data, src_data); + const dest_data = switch (src.sh_type) { + elf.DT_VERSYM => dst_data: { + const data = try allocator.alignedAlloc(u8, section_memory_align, src_data.len); + std.mem.copy(u8, data, src_data); - switch (src.sh_type) { - elf.DT_VERSYM => { const defs = @ptrCast([*]Elf_Verdef, data)[0 .. @intCast(usize, src.sh_size) / @sizeOf(Elf_Verdef)]; for (defs) |*def| { if (def.vd_ndx != elf.SHN_UNDEF) def.vd_ndx = sections_update[src.sh_info].remap_idx; } + + break :dst_data data; }, - elf.SHT_SYMTAB, elf.SHT_DYNSYM => { + elf.SHT_SYMTAB, elf.SHT_DYNSYM => dst_data: { + const data = try allocator.alignedAlloc(u8, section_memory_align, src_data.len); + std.mem.copy(u8, data, src_data); + const syms = @ptrCast([*]Elf_Sym, data)[0 .. @intCast(usize, src.sh_size) / @sizeOf(Elf_Sym)]; for (syms) |*sym| { if (sym.st_shndx != elf.SHN_UNDEF and sym.st_shndx < elf.SHN_LORESERVE) sym.st_shndx = sections_update[sym.st_shndx].remap_idx; } - }, - else => {}, - } - std.debug.assert(data.len == dest.sh_size); - cmdbuf.appendAssumeCapacity(.{ .write_data = .{ .data = data, .out_offset = dest.sh_offset } }); + break :dst_data data; + }, + else => src_data, + }; + + std.debug.assert(dest_data.len == dest.sh_size); + cmdbuf.appendAssumeCapacity(.{ .write_data = .{ .data = dest_data, .out_offset = dest.sh_offset } }); eof_offset = dest.sh_offset + dest.sh_size; } else { // direct contents copy @@ -1144,7 +1083,7 @@ fn ElfContents(comptime is_64: bool) type { } // add a ".gnu_debuglink" section - if (debuglink) |link| { + if (options.debuglink) |link| { const payload = payload: { const crc_offset = std.mem.alignForward(link.name.len + 1, 4); const buf = try allocator.alignedAlloc(u8, 4, crc_offset + 4); @@ -1188,71 +1127,7 @@ fn ElfContents(comptime is_64: bool) type { cmdbuf.appendAssumeCapacity(.{ .write_data = .{ .data = data, .out_offset = updated_elf_header.e_shoff } }); } - // consolidate holes between writes: - // by coping original padding data from in_file (by fusing contiguous ranges) - // by writing zeroes otherwise - const zeroes = [1]u8{0} ** 4096; - const consolidated_cmdbuf = blk: { - var newbuf = std.ArrayList(WriteCmd).init(allocator); - try newbuf.ensureUnusedCapacity(cmdbuf.items.len * 2); - var offset: u64 = 0; - var fused_cmd: ?WriteCmd = null; - for (cmdbuf.items) |cmd| { - switch (cmd) { - .write_data => |data| { - std.debug.assert(data.out_offset >= offset); - if (fused_cmd) |prev| { - newbuf.appendAssumeCapacity(prev); - fused_cmd = null; - } - if (data.out_offset > offset) { - newbuf.appendAssumeCapacity(.{ .write_data = .{ .data = zeroes[0..@intCast(usize, data.out_offset - offset)], .out_offset = offset } }); - } - newbuf.appendAssumeCapacity(cmd); - offset = data.out_offset + data.data.len; - }, - .copy_range => |range| { - std.debug.assert(range.out_offset >= offset); - if (fused_cmd) |prev| { - if (range.in_offset >= prev.copy_range.in_offset + prev.copy_range.len and (range.out_offset - prev.copy_range.out_offset == range.in_offset - prev.copy_range.in_offset)) { - fused_cmd = .{ .copy_range = .{ - .in_offset = prev.copy_range.in_offset, - .out_offset = prev.copy_range.out_offset, - .len = (range.out_offset + range.len) - prev.copy_range.out_offset, - } }; - } else { - newbuf.appendAssumeCapacity(prev); - if (range.out_offset > offset) { - newbuf.appendAssumeCapacity(.{ .write_data = .{ .data = zeroes[0..@intCast(usize, range.out_offset - offset)], .out_offset = offset } }); - } - fused_cmd = cmd; - } - } else { - fused_cmd = cmd; - } - offset = range.out_offset + range.len; - }, - } - } - if (fused_cmd) |cmd| { - newbuf.appendAssumeCapacity(cmd); - } - break :blk newbuf.items; - }; - - // write the output file - for (consolidated_cmdbuf) |cmd| { - switch (cmd) { - .write_data => |data| { - var iovec = [_]std.os.iovec_const{.{ .iov_base = data.data.ptr, .iov_len = data.data.len }}; - try output.pwritevAll(&iovec, data.out_offset); - }, - .copy_range => |range| { - const copied_bytes = try source.copyRangeAll(range.in_offset, output, range.out_offset, range.len); - if (copied_bytes < range.len) return error.TRUNCATED_ELF; - }, - } - } + try ElfFileHelper.write(allocator, out_file, in_file, cmdbuf.items); } fn sectionWithinSegment(section: Elf_Shdr, segment: Elf_Phdr) bool { @@ -1262,15 +1137,162 @@ fn ElfContents(comptime is_64: bool) type { }; } -fn computeFileCrc(file: File) !u32 { - var buf: [8000]u8 = undefined; +const ElfFileHelper = struct { + const DebugLink = struct { name: []const u8, crc32: u32 }; + const Filter = enum { all, program, debug, program_and_symbols, debug_and_symbols }; - try file.seekTo(0); - var hasher = std.hash.Crc32.init(); - while (true) { - const bytes_read = try file.read(&buf); - if (bytes_read == 0) break; - hasher.update(buf[0..bytes_read]); + const SectionCategory = enum { common, exe, debug, symbols, none }; + fn propagateCategory(cur: *SectionCategory, new: SectionCategory) u1 { + const cat: SectionCategory = switch (cur.*) { + .none => new, + .common => .common, + .debug => switch (new) { + .none, .debug => .debug, + else => new, + }, + .exe => switch (new) { + .common => .common, + .none, .debug, .exe => .exe, + .symbols => .exe, + }, + .symbols => switch (new) { + .none, .common, .debug, .exe => unreachable, + .symbols => .symbols, + }, + }; + + if (cur.* != cat) { + cur.* = cat; + return 1; + } else { + return 0; + } } - return hasher.final(); -} + + const Action = enum { keep, strip, empty }; + fn selectAction(category: SectionCategory, filter: Filter) Action { + if (category == .none) return .strip; + return switch (filter) { + .all => switch (category) { + .none => .strip, + else => .keep, + }, + .program => switch (category) { + .common, .exe => .keep, + else => .strip, + }, + .program_and_symbols => switch (category) { + .common, .exe, .symbols => .keep, + else => .strip, + }, + .debug => switch (category) { + .exe, .symbols => .empty, + .none => .strip, + else => .keep, + }, + .debug_and_symbols => switch (category) { + .exe => .empty, + .none => .strip, + else => .keep, + }, + }; + } + + const WriteCmd = union(enum) { + copy_range: struct { in_offset: u64, len: u64, out_offset: u64 }, + write_data: struct { data: []const u8, out_offset: u64 }, + }; + fn write(allocator: Allocator, out_file: File, in_file: File, cmds: []const WriteCmd) !void { + // consolidate holes between writes: + // by coping original padding data from in_file (by fusing contiguous ranges) + // by writing zeroes otherwise + const zeroes = [1]u8{0} ** 4096; + var consolidated = std.ArrayList(WriteCmd).init(allocator); + defer consolidated.deinit(); + try consolidated.ensureUnusedCapacity(cmds.len * 2); + var offset: u64 = 0; + var fused_cmd: ?WriteCmd = null; + for (cmds) |cmd| { + switch (cmd) { + .write_data => |data| { + std.debug.assert(data.out_offset >= offset); + if (fused_cmd) |prev| { + consolidated.appendAssumeCapacity(prev); + fused_cmd = null; + } + if (data.out_offset > offset) { + consolidated.appendAssumeCapacity(.{ .write_data = .{ .data = zeroes[0..@intCast(usize, data.out_offset - offset)], .out_offset = offset } }); + } + consolidated.appendAssumeCapacity(cmd); + offset = data.out_offset + data.data.len; + }, + .copy_range => |range| { + std.debug.assert(range.out_offset >= offset); + if (fused_cmd) |prev| { + if (range.in_offset >= prev.copy_range.in_offset + prev.copy_range.len and (range.out_offset - prev.copy_range.out_offset == range.in_offset - prev.copy_range.in_offset)) { + fused_cmd = .{ .copy_range = .{ + .in_offset = prev.copy_range.in_offset, + .out_offset = prev.copy_range.out_offset, + .len = (range.out_offset + range.len) - prev.copy_range.out_offset, + } }; + } else { + consolidated.appendAssumeCapacity(prev); + if (range.out_offset > offset) { + consolidated.appendAssumeCapacity(.{ .write_data = .{ .data = zeroes[0..@intCast(usize, range.out_offset - offset)], .out_offset = offset } }); + } + fused_cmd = cmd; + } + } else { + fused_cmd = cmd; + } + offset = range.out_offset + range.len; + }, + } + } + if (fused_cmd) |cmd| { + consolidated.appendAssumeCapacity(cmd); + } + + // write the output file + for (consolidated.items) |cmd| { + switch (cmd) { + .write_data => |data| { + var iovec = [_]std.os.iovec_const{.{ .iov_base = data.data.ptr, .iov_len = data.data.len }}; + try out_file.pwritevAll(&iovec, data.out_offset); + }, + .copy_range => |range| { + const copied_bytes = try in_file.copyRangeAll(range.in_offset, out_file, range.out_offset, range.len); + if (copied_bytes < range.len) return error.TRUNCATED_ELF; + }, + } + } + } + + fn createDebugLink(path: []const u8) DebugLink { + const file = std.fs.cwd().openFile(path, .{}) catch |err| { + fatal("zig objcopy: could not open `{s}`: {s}\n", .{ path, @errorName(err) }); + }; + defer file.close(); + + const crc = ElfFileHelper.computeFileCrc(file) catch |err| { + fatal("zig objcopy: could not read `{s}`: {s}\n", .{ path, @errorName(err) }); + }; + return .{ + .name = std.fs.path.basename(path), + .crc32 = crc, + }; + } + + fn computeFileCrc(file: File) !u32 { + var buf: [8000]u8 = undefined; + + try file.seekTo(0); + var hasher = std.hash.Crc32.init(); + while (true) { + const bytes_read = try file.read(&buf); + if (bytes_read == 0) break; + hasher.update(buf[0..bytes_read]); + } + return hasher.final(); + } +};