diff --git a/src/objcopy.zig b/src/objcopy.zig index c3305e8c04..4a15af88e3 100644 --- a/src/objcopy.zig +++ b/src/objcopy.zig @@ -20,8 +20,13 @@ pub fn cmdObjCopy( var opt_out_fmt: ?std.Target.ObjectFormat = null; var opt_input: ?[]const u8 = null; var opt_output: ?[]const u8 = null; + var opt_extract: ?[]const u8 = null; + var opt_add_debuglink: ?[]const u8 = null; var only_section: ?[]const u8 = null; var pad_to: ?u64 = null; + var strip_all: bool = false; + var strip_debug: bool = false; + var only_keep_debug: bool = false; var listen = false; while (i < args.len) : (i += 1) { const arg = args[i]; @@ -67,6 +72,24 @@ pub fn cmdObjCopy( pad_to = std.fmt.parseInt(u64, args[i], 0) catch |err| { fatal("unable to parse: '{s}': {s}", .{ args[i], @errorName(err) }); }; + } else if (mem.eql(u8, arg, "-g") or mem.eql(u8, arg, "--strip-debug")) { + strip_debug = true; + } else if (mem.eql(u8, arg, "-S") or mem.eql(u8, arg, "--strip-all")) { + strip_all = true; + } else if (mem.eql(u8, arg, "--only-keep-debug")) { + only_keep_debug = true; + } else if (mem.startsWith(u8, arg, "--add-gnu-debuglink=")) { + opt_add_debuglink = arg["--add-gnu-debuglink=".len..]; + } else if (mem.eql(u8, arg, "--add-gnu-debuglink")) { + i += 1; + if (i >= args.len) fatal("expected another argument after '{s}'", .{arg}); + opt_add_debuglink = args[i]; + } else if (mem.startsWith(u8, arg, "--extract-to=")) { + opt_extract = arg["--extract-to=".len..]; + } else if (mem.eql(u8, arg, "--extract-to")) { + i += 1; + if (i >= args.len) fatal("expected another argument after '{s}'", .{arg}); + opt_extract = args[i]; } else { fatal("unrecognized argument: '{s}'", .{arg}); } @@ -101,13 +124,37 @@ pub fn cmdObjCopy( }; switch (out_fmt) { - .hex, .raw, .elf => { + .hex, .raw => { + if (strip_debug or strip_all or only_keep_debug) + 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", .{}); + try emitElf(arena, in_file, out_file, elf_hdr, .{ .ofmt = out_fmt, .only_section = only_section, .pad_to = pad_to, }); }, + .elf => { + if (elf_hdr.endian != @import("builtin").target.cpu.arch.endian()) + fatal("zig objcopy: ELF to ELF copying only supports native endian", .{}); + if (elf_hdr.phoff == 0) // no program header + fatal("zig objcopy: ELF to ELF copying only supports programs", .{}); + if (only_section) |_| + fatal("zig objcopy: ELF to ELF copying does not support --only-section", .{}); + if (pad_to) |_| + fatal("zig objcopy: ELF to ELF copying does not support --pad-to", .{}); + + try stripElf(arena, in_file, out_file, elf_hdr, .{ + .strip_debug = strip_debug, + .strip_all = strip_all, + .only_keep_debug = only_keep_debug, + .add_debuglink = opt_add_debuglink, + .extract_to = opt_extract, + }); + return std.process.cleanExit(); + }, else => fatal("unsupported output object format: {s}", .{@tagName(out_fmt)}), } @@ -152,12 +199,17 @@ const usage = \\Usage: zig objcopy [options] input output \\ \\Options: - \\ -h, --help Print this help and exit - \\ --output-target= Format of the output file - \\ -O Alias for --output-target - \\ --only-section=
Remove all but
- \\ -j Alias for --only-section - \\ --pad-to Pad the last section up to address + \\ -h, --help Print this help and exit + \\ --output-target= Format of the output file + \\ -O Alias for --output-target + \\ --only-section=
Remove all but
+ \\ -j Alias for --only-section + \\ --pad-to Pad the last section up to address + \\ --strip-debug, -g Remove all debug sections from the output. + \\ --strip-all, -S Remove all debug sections and symbol table from the output. + \\ --only-keep-debug Strip a file, removing contents of any sections that would not be stripped by --strip-debug and leaving the debugging sections intact. + \\ --add-gnu-debuglink= Creates a .gnu_debuglink section which contains a reference to and adds it to the output file. + \\ --extract-to Extract the removed sections into , and add a .gnu-debuglink section. \\ ; @@ -598,3 +650,649 @@ test "containsValidAddressRange" { segment.fileSize = 1; try std.testing.expect(containsValidAddressRange(&buf)); } + +// ------------- +// ELF to ELF stripping + +const StripElfOptions = struct { + extract_to: ?[]const u8 = null, + add_debuglink: ?[]const u8 = null, + strip_all: bool = false, + strip_debug: bool = false, + only_keep_debug: bool = false, +}; + +fn stripElf( + allocator: Allocator, + in_file: File, + out_file: File, + 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| { + var elf_file = try ElfFile(is_64).parse(allocator, in_file, elf_hdr); + defer elf_file.deinit(); + + 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(); + + try elf_file.emit(allocator, dbg_file, in_file, .{ .section_filter = flt }); + } + + 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 moves and reoders the sections as little as possible to avoid having to do fixups. +// TODO: support non-native endianess + +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; + const Elf_Sym = if (is_64) elf.Elf64_Sym else elf.Elf32_Sym; + const Elf_Verdef = if (is_64) elf.Elf64_Verdef else elf.Elf32_Verdef; + const Elf_OffSize = if (is_64) elf.Elf64_Off else elf.Elf32_Off; + + return struct { + raw_elf_header: Elf_Ehdr, + program_segments: []const Elf_Phdr, + 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 + 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, 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 in_file.preadAll(std.mem.asBytes(&raw_header), 0); + if (bytes_read < @sizeOf(Elf_Ehdr)) + return error.TRUNCATED_ELF; + } + + // program header: list of segments + const program_segments = blk: { + if (@sizeOf(Elf_Phdr) != header.phentsize) + 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 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; + }; + + // section header + const sections = blk: { + if (@sizeOf(Elf_Shdr) != header.shentsize) + fatal("zig objcopy: unsuported ELF file, unexpected shentsize ({d})", .{header.shentsize}); + + const section_header = try allocator.alloc(Section, header.shnum); + + const raw_section_header = try allocator.alloc(Elf_Shdr, header.shnum); + defer allocator.free(raw_section_header); + 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; + + for (section_header, raw_section_header) |*section, hdr| { + section.* = .{ .section = hdr }; + } + break :blk section_header; + }; + + // load data to memory for some sections: + // string tables for access + // sections than need modifications when other sections move. + for (sections, 0..) |*section, idx| { + const need_data = switch (section.section.sh_type) { + elf.DT_VERSYM => true, + elf.SHT_SYMTAB, elf.SHT_DYNSYM => true, + else => false, + }; + const need_strings = (idx == header.shstrndx); + + 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 in_file.preadAll(buffer, section.section.sh_offset); + if (bytes_read != section.section.sh_size) return error.TRUNCATED_ELF; + section.payload = buffer; + } + } + + // fill-in sections info: + // resolve the name + // find if a program segment uses the section + // 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; + } else null; + + 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 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 => 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 => category_from_program, + }; + } + + sections[0].category = .common; // mandatory null section + if (header.shstrndx != elf.SHN_UNDEF) + sections[header.shstrndx].category = .common; // string table for the headers + + // recursive dependencies + var dirty: u1 = 1; + while (dirty != 0) { + dirty = 0; + + for (sections) |*section| { + if (section.section.sh_link != elf.SHN_UNDEF) + 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 |= ElfFileHelper.propagateCategory(§ions[section.section.sh_info].category, section.category); + + if (section.payload) |data| { + switch (section.section.sh_type) { + elf.DT_VERSYM => { + std.debug.assert(section.section.sh_entsize == @sizeOf(Elf_Verdef)); + 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 |= ElfFileHelper.propagateCategory(§ions[def.vd_ndx].category, section.category); + } + }, + elf.SHT_SYMTAB, elf.SHT_DYNSYM => { + std.debug.assert(section.section.sh_entsize == @sizeOf(Elf_Sym)); + const syms = @ptrCast([*]const Elf_Sym, data)[0 .. @intCast(usize, section.section.sh_size) / @sizeOf(Elf_Sym)]; + + for (syms) |sym| { + if (sym.st_shndx != elf.SHN_UNDEF and sym.st_shndx < elf.SHN_LORESERVE) + dirty |= ElfFileHelper.propagateCategory(§ions[sym.st_shndx].category, section.category); + } + }, + else => {}, + } + } + } + } + + return Self{ + .arena = arena, + .raw_elf_header = raw_header, + .program_segments = program_segments, + .sections = sections, + }; + } + + pub fn deinit(self: *Self) void { + self.arena.deinit(); + } + + 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(); + + // when emitting the stripped exe: + // - unused sections are removed + // when emitting the debug file: + // - all sections are kept, but some are emptied and their types is changed to SHT_NOBITS + // the program header is kept unchanged. (`strip` does update it, but `eu-strip` does not, and it still works) + + const Update = struct { + 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 = 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| { + const action = ElfFileHelper.selectAction(section.category, options.section_filter); + const remap_idx = idx: { + if (action == .strip) break :idx elf.SHN_UNDEF; + next_idx += 1; + break :idx next_idx - 1; + }; + update.* = Update{ .action = action, .remap_idx = remap_idx }; + } + + 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 (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? + + const strtab = &self.sections[self.raw_elf_header.e_shstrndx]; + const update = §ions_update[self.raw_elf_header.e_shstrndx]; + + const name: []const u8 = ".gnu_debuglink"; + const new_offset = @intCast(u32, strtab.payload.?.len); + const buf = try allocator.alignedAlloc(u8, section_memory_align, new_offset + name.len + 1); + std.mem.copy(u8, buf[0..new_offset], strtab.payload.?); + std.mem.copy(u8, buf[new_offset .. new_offset + name.len], name); + buf[new_offset + name.len] = 0; + + std.debug.assert(update.action == .keep); + update.payload = buf; + + break :blk new_offset; + }; + + 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. + + // build the updated headers + // nb: updated_elf_header will be updated before the actual write + var updated_elf_header = self.raw_elf_header; + if (updated_elf_header.e_shstrndx != elf.SHN_UNDEF) + updated_elf_header.e_shstrndx = sections_update[updated_elf_header.e_shstrndx].remap_idx; + cmdbuf.appendAssumeCapacity(.{ .write_data = .{ .data = std.mem.asBytes(&updated_elf_header), .out_offset = 0 } }); + eof_offset = @sizeOf(Elf_Ehdr); + + // program header as-is. + // nb: for only-debug files, removing it appears to work, but is invalid by ELF specifcation. + { + std.debug.assert(updated_elf_header.e_phoff == @sizeOf(Elf_Ehdr)); + const data = std.mem.sliceAsBytes(self.program_segments); + std.debug.assert(data.len == @as(usize, updated_elf_header.e_phentsize) * updated_elf_header.e_phnum); + cmdbuf.appendAssumeCapacity(.{ .write_data = .{ .data = data, .out_offset = updated_elf_header.e_phoff } }); + eof_offset = updated_elf_header.e_phoff + @intCast(Elf_OffSize, data.len); + } + + // update sections and queue payload writes + const updated_section_header = blk: { + const dest_sections = try allocator.alloc(Elf_Shdr, new_shnum); + + { + // the ELF format doesn't specify the order for all sections. + // this code only supports when they are in increasing file order. + var offset: u64 = eof_offset; + for (self.sections[1..]) |section| { + if (section.section.sh_offset < offset) { + fatal("zig objcopy: unsuported ELF file", .{}); + } + offset = section.section.sh_offset; + } + } + + dest_sections[0] = self.sections[0].section; + + var dest_section_idx: u32 = 1; + for (self.sections[1..], sections_update[1..]) |section, update| { + if (update.action == .strip) continue; + std.debug.assert(update.remap_idx == dest_section_idx); + + 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.*; + + if (src.sh_link != elf.SHN_UNDEF) + dest.sh_link = sections_update[src.sh_link].remap_idx; + 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; + + if (payload) |data| + dest.sh_size = @intCast(Elf_OffSize, data.len); + + const addralign = if (src.sh_addralign == 0 or dest.sh_type == elf.SHT_NOBITS) 1 else src.sh_addralign; + dest.sh_offset = std.mem.alignForwardGeneric(Elf_OffSize, eof_offset, addralign); + if (src.sh_offset != dest.sh_offset and section.segment != null and update.action != .empty and dest.sh_type != elf.SHT_NOTE) { + if (src.sh_offset > dest.sh_offset) { + dest.sh_offset = src.sh_offset; // add padding to avoid modifing the program segments + } else { + fatal("zig objcopy: cannot adjust program segments", .{}); + } + } + std.debug.assert(dest.sh_addr % addralign == dest.sh_offset % addralign); + + if (update.action == .empty) + dest.sh_type = elf.SHT_NOBITS; + + if (dest.sh_type != elf.SHT_NOBITS) { + if (payload) |src_data| { + // update sections payload and write + 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); + + 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 => 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; + } + + 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 + cmdbuf.appendAssumeCapacity(.{ .copy_range = .{ .in_offset = src.sh_offset, .len = dest.sh_size, .out_offset = dest.sh_offset } }); + eof_offset = dest.sh_offset + dest.sh_size; + } + } else { + // account for alignment padding even in empty sections to keep logical section order + eof_offset = dest.sh_offset; + } + } + + // add a ".gnu_debuglink" section + 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); + std.mem.copy(u8, buf[0..link.name.len], link.name); + std.mem.set(u8, buf[link.name.len..crc_offset], 0); + std.mem.copy(u8, buf[crc_offset..], std.mem.asBytes(&link.crc32)); + break :payload buf; + }; + + dest_sections[dest_section_idx] = Elf_Shdr{ + .sh_name = debuglink_name, + .sh_type = elf.SHT_PROGBITS, + .sh_flags = 0, + .sh_addr = 0, + .sh_offset = eof_offset, + .sh_size = @intCast(Elf_OffSize, payload.len), + .sh_link = elf.SHN_UNDEF, + .sh_info = elf.SHN_UNDEF, + .sh_addralign = 4, + .sh_entsize = 0, + }; + dest_section_idx += 1; + + cmdbuf.appendAssumeCapacity(.{ .write_data = .{ .data = payload, .out_offset = eof_offset } }); + eof_offset += @intCast(Elf_OffSize, payload.len); + } + + std.debug.assert(dest_section_idx == new_shnum); + break :blk dest_sections; + }; + + // write the section header at the tail + { + const offset = std.mem.alignForwardGeneric(Elf_OffSize, eof_offset, @alignOf(Elf_Shdr)); + + const data = std.mem.sliceAsBytes(updated_section_header); + std.debug.assert(data.len == @as(usize, updated_elf_header.e_shentsize) * new_shnum); + updated_elf_header.e_shoff = offset; + updated_elf_header.e_shnum = new_shnum; + + cmdbuf.appendAssumeCapacity(.{ .write_data = .{ .data = data, .out_offset = updated_elf_header.e_shoff } }); + } + + try ElfFileHelper.write(allocator, out_file, in_file, cmdbuf.items); + } + + fn sectionWithinSegment(section: Elf_Shdr, segment: Elf_Phdr) bool { + const file_size = if (section.sh_type == elf.SHT_NOBITS) 0 else section.sh_size; + return segment.p_offset <= section.sh_offset and (segment.p_offset + segment.p_filesz) >= (section.sh_offset + file_size); + } + }; +} + +const ElfFileHelper = struct { + const DebugLink = struct { name: []const u8, crc32: u32 }; + const Filter = enum { all, program, debug, program_and_symbols, debug_and_symbols }; + + 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; + } + } + + 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(); + } +};