| ... | ... | @@ -20,8 +20,11 @@ pub fn cmdObjCopy( |
| 20 | 20 | var opt_out_fmt: ?std.Target.ObjectFormat = null; |
| 21 | 21 | var opt_input: ?[]const u8 = null; |
| 22 | 22 | var opt_output: ?[]const u8 = null; |
| 23 | var opt_extract: ?[]const u8 = null; |
| 23 | 24 | var only_section: ?[]const u8 = null; |
| 24 | 25 | var pad_to: ?u64 = null; |
| 26 | var strip_all: bool = false; |
| 27 | var strip_only_debug: bool = false; |
| 25 | 28 | var listen = false; |
| 26 | 29 | while (i < args.len) : (i += 1) { |
| 27 | 30 | const arg = args[i]; |
| ... | ... | @@ -67,6 +70,15 @@ pub fn cmdObjCopy( |
| 67 | 70 | pad_to = std.fmt.parseInt(u64, args[i], 0) catch |err| { |
| 68 | 71 | fatal("unable to parse: '{s}': {s}", .{ args[i], @errorName(err) }); |
| 69 | 72 | }; |
| 73 | } else if (mem.eql(u8, arg, "-g") or mem.eql(u8, arg, "--strip-debug")) { |
| 74 | strip_only_debug = true; |
| 75 | } else if (mem.eql(u8, arg, "-S") or mem.eql(u8, arg, "--strip-all")) { |
| 76 | strip_only_debug = true; |
| 77 | strip_all = true; |
| 78 | } else if (mem.eql(u8, arg, "--extract-to")) { |
| 79 | i += 1; |
| 80 | if (i >= args.len) fatal("expected another argument after '{s}'", .{arg}); |
| 81 | opt_extract = args[i]; |
| 70 | 82 | } else { |
| 71 | 83 | fatal("unrecognized argument: '{s}'", .{arg}); |
| 72 | 84 | } |
| ... | ... | @@ -101,13 +113,39 @@ pub fn cmdObjCopy( |
| 101 | 113 | }; |
| 102 | 114 | |
| 103 | 115 | switch (out_fmt) { |
| 104 | | .hex, .raw, .elf => { |
| 116 | .hex, .raw => { |
| 117 | if (strip_only_debug or strip_all) |
| 118 | fatal("zig objcopy: ELF to RAW or HEX copying does not support --strip", .{}); |
| 119 | if (opt_extract != null) |
| 120 | fatal("zig objcopy: ELF to RAW or HEX copying does not support --extract-to", .{}); |
| 121 | |
| 105 | 122 | try emitElf(arena, in_file, out_file, elf_hdr, .{ |
| 106 | 123 | .ofmt = out_fmt, |
| 107 | 124 | .only_section = only_section, |
| 108 | 125 | .pad_to = pad_to, |
| 109 | 126 | }); |
| 110 | 127 | }, |
| 128 | .elf => { |
| 129 | if (elf_hdr.endian != @import("builtin").target.cpu.arch.endian()) |
| 130 | fatal("zig objcopy: ELF to ELF copying only supports native endian", .{}); |
| 131 | if (!elf_hdr.is_64) |
| 132 | fatal("zig objcopy: ELF to ELF copying only supports 64-bit files", .{}); |
| 133 | if (elf_hdr.phoff == 0) // no program header |
| 134 | fatal("zig objcopy: ELF to ELF copying only supports programs", .{}); |
| 135 | if (only_section) |_| |
| 136 | fatal("zig objcopy: ELF to ELF copying does not support --only-section", .{}); |
| 137 | if (pad_to) |_| |
| 138 | fatal("zig objcopy: ELF to ELF copying does not support --pad-to", .{}); |
| 139 | if (!strip_only_debug and !strip_all) |
| 140 | fatal("zig objcopy: ELF to ELF copying only supports --strip", .{}); |
| 141 | |
| 142 | try stripElf(arena, in_file, out_file, elf_hdr, .{ |
| 143 | .strip_only_debug = strip_only_debug, |
| 144 | .strip_all = strip_all, |
| 145 | .extract_to = opt_extract, |
| 146 | }); |
| 147 | return std.process.cleanExit(); |
| 148 | }, |
| 111 | 149 | else => fatal("unsupported output object format: {s}", .{@tagName(out_fmt)}), |
| 112 | 150 | } |
| 113 | 151 | |
| ... | ... | @@ -158,7 +196,9 @@ const usage = |
| 158 | 196 | \\ --only-section=<section> Remove all but <section> |
| 159 | 197 | \\ -j <value> Alias for --only-section |
| 160 | 198 | \\ --pad-to <addr> Pad the last section up to address <addr> |
| 161 | | \\ |
| 199 | \\ --strip-debug, -g Remove all debug sections from the output.¶ |
| 200 | \\ --strip-all, -S Remove all debug sections and symbol table from the output. |
| 201 | \\ --extract-to <file> Extract the removed sections into <file>, and add a .gnu-debuglink section |
| 162 | 202 | ; |
| 163 | 203 | |
| 164 | 204 | pub const EmitRawElfOptions = struct { |
| ... | ... | @@ -598,3 +638,516 @@ test "containsValidAddressRange" { |
| 598 | 638 | segment.fileSize = 1; |
| 599 | 639 | try std.testing.expect(containsValidAddressRange(&buf)); |
| 600 | 640 | } |
| 641 | |
| 642 | // ------------- |
| 643 | // ELF to ELF stripping |
| 644 | |
| 645 | pub const StripElfOptions = struct { |
| 646 | extract_to: ?[]const u8 = null, |
| 647 | strip_all: bool = false, |
| 648 | strip_only_debug: bool = false, |
| 649 | }; |
| 650 | |
| 651 | fn stripElf( |
| 652 | allocator: Allocator, |
| 653 | in_file: File, |
| 654 | out_file: File, |
| 655 | elf_hdr: elf.Header, |
| 656 | options: StripElfOptions, |
| 657 | ) !void { |
| 658 | std.debug.assert(options.strip_only_debug or options.strip_all); |
| 659 | |
| 660 | var elf_contents = try ElfContents.parse(allocator, in_file, elf_hdr); |
| 661 | defer elf_contents.deinit(); |
| 662 | |
| 663 | if (options.extract_to) |filename| { |
| 664 | const dbg_file = std.fs.cwd().createFile(filename, .{}) catch |err| { |
| 665 | fatal("zig objcopy: unable to create '{s}': {s}", .{ filename, @errorName(err) }); |
| 666 | }; |
| 667 | defer dbg_file.close(); |
| 668 | try elf_contents.emit(allocator, dbg_file, in_file, if (options.strip_only_debug) .debug else .debug_and_symbols, null); |
| 669 | } |
| 670 | |
| 671 | const debuglink: ?ElfContents.DebugLink = blk: { |
| 672 | if (options.extract_to) |filename| { |
| 673 | const dbg_file = std.fs.cwd().openFile(filename, .{}) catch |err| { |
| 674 | fatal("zig objcopy: could not read `{s}`: {s}\n", .{ filename, @errorName(err) }); |
| 675 | }; |
| 676 | defer dbg_file.close(); |
| 677 | |
| 678 | break :blk .{ .name = std.fs.path.basename(filename), .crc32 = try computeFileCrc(dbg_file) }; |
| 679 | } else { |
| 680 | break :blk null; |
| 681 | } |
| 682 | }; |
| 683 | |
| 684 | try elf_contents.emit(allocator, out_file, in_file, if (options.strip_only_debug) .program_and_symbols else .program, debuglink); |
| 685 | } |
| 686 | |
| 687 | // note: this is "a minimal effort implementation" |
| 688 | // It doesn't support all possibile elf files: some sections type may need fixups, the program header may need fix up, ... |
| 689 | // 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++` ) |
| 690 | // It manupulates and reoders the sections as little as possible to avoid having to do fixups. |
| 691 | // TODO: support 32-bit files |
| 692 | // TODO: support non-native endianess |
| 693 | |
| 694 | const ElfContents = struct { |
| 695 | raw_elf_header: elf.Elf64_Ehdr, |
| 696 | program_segments: []const elf.Elf64_Phdr, |
| 697 | sections: []const Section, |
| 698 | arena: std.heap.ArenaAllocator, |
| 699 | |
| 700 | const section_memory_align = @alignOf(elf.Elf64_Sym); // most restrictive of what we may load in memory |
| 701 | const Section = struct { |
| 702 | section: elf.Elf64_Shdr, |
| 703 | name: []const u8 = "", |
| 704 | segment: ?*const elf.Elf64_Phdr = null, // if the section is used by a program segment (there can be more than one) |
| 705 | payload: ?[]align(section_memory_align) const u8 = null, // if we need the data in memory |
| 706 | usage: Usage = .none, // should the section be kept in the exe or stripped to the debug database, or both. |
| 707 | |
| 708 | const Usage = enum { common, exe, debug, symbols, none }; |
| 709 | }; |
| 710 | |
| 711 | const Self = @This(); |
| 712 | |
| 713 | pub fn parse(gpa: Allocator, source: File, header: elf.Header) !Self { |
| 714 | var arena = std.heap.ArenaAllocator.init(gpa); |
| 715 | errdefer arena.deinit(); |
| 716 | const allocator = arena.allocator(); |
| 717 | |
| 718 | var raw_header: elf.Elf64_Ehdr = undefined; |
| 719 | try source.seekableStream().seekTo(0); |
| 720 | try source.reader().readNoEof(std.mem.asBytes(&raw_header)); |
| 721 | |
| 722 | // program header: list of segments |
| 723 | const program_segments = blk: { |
| 724 | const program_header = try allocator.alloc(elf.Elf64_Phdr, header.phnum); |
| 725 | var i: u32 = 0; |
| 726 | var it = header.program_header_iterator(source); |
| 727 | while (try it.next()) |hdr| { |
| 728 | program_header[i] = hdr; |
| 729 | i += 1; |
| 730 | } |
| 731 | break :blk @ptrCast([]const elf.Elf64_Phdr, program_header[0..i]); |
| 732 | }; |
| 733 | |
| 734 | // section header |
| 735 | const sections = blk: { |
| 736 | const section_header = try allocator.alloc(Section, header.shnum); |
| 737 | var it = header.section_header_iterator(source); |
| 738 | var i: u32 = 0; |
| 739 | while (try it.next()) |hdr| { |
| 740 | section_header[i] = .{ .section = hdr }; |
| 741 | i += 1; |
| 742 | } |
| 743 | break :blk section_header[0..i]; |
| 744 | }; |
| 745 | |
| 746 | // load data to memory for some sections: |
| 747 | // string tables for access |
| 748 | // sections than need modifications when other sections move. |
| 749 | for (sections, 0..) |*section, idx| { |
| 750 | const need_data = switch (section.section.sh_type) { |
| 751 | elf.DT_VERSYM => true, |
| 752 | elf.SHT_SYMTAB, elf.SHT_DYNSYM => true, |
| 753 | else => false, |
| 754 | }; |
| 755 | const need_strings = (idx == header.shstrndx); |
| 756 | |
| 757 | if (need_data or need_strings) { |
| 758 | const buffer = try allocator.alignedAlloc(u8, section_memory_align, section.section.sh_size); |
| 759 | const bytes_read = try source.preadAll(buffer, section.section.sh_offset); |
| 760 | if (bytes_read != section.section.sh_size) return error.TRUNCATED_ELF; |
| 761 | section.payload = buffer; |
| 762 | } |
| 763 | } |
| 764 | |
| 765 | // fill-in sections info: |
| 766 | // resolve the name |
| 767 | // find if a program segment uses the section |
| 768 | // classify sections usage (used by program segments, debug datadase, common metadata, symbol table) |
| 769 | for (sections) |*section| { |
| 770 | section.segment = for (program_segments) |*seg| { |
| 771 | if (sectionWithinSegment(section.section, seg.*)) break seg; |
| 772 | } else null; |
| 773 | |
| 774 | if (section.section.sh_name != 0 and header.shstrndx != elf.SHN_UNDEF) |
| 775 | section.name = std.mem.span(@ptrCast([*:0]const u8, §ions[header.shstrndx].payload.?[section.section.sh_name])); |
| 776 | |
| 777 | const usage_from_program: Section.Usage = if (section.segment != null) .exe else .debug; |
| 778 | section.usage = switch (section.section.sh_type) { |
| 779 | elf.SHT_NOTE => .common, |
| 780 | elf.SHT_SYMTAB => .symbols, // "strip all" vs "strip only debug" |
| 781 | elf.SHT_DYNSYM => .exe, |
| 782 | elf.SHT_PROGBITS => usage: { |
| 783 | if (std.mem.eql(u8, section.name, ".comment")) break :usage .exe; |
| 784 | if (std.mem.eql(u8, section.name, ".gnu_debuglink")) break :usage .none; |
| 785 | break :usage usage_from_program; |
| 786 | }, |
| 787 | elf.SHT_LOPROC...elf.SHT_HIPROC => .common, // don't strip unkonwn sections |
| 788 | elf.SHT_LOUSER...elf.SHT_HIUSER => .common, // don't strip unkonwn sections |
| 789 | else => usage_from_program, |
| 790 | }; |
| 791 | } |
| 792 | |
| 793 | sections[0].usage = .common; // mandatory null section |
| 794 | if (header.shstrndx != elf.SHN_UNDEF) |
| 795 | sections[header.shstrndx].usage = .common; // string table for the headers |
| 796 | |
| 797 | // recursive dependencies |
| 798 | var dirty: u1 = 1; |
| 799 | while (dirty != 0) { |
| 800 | dirty = 0; |
| 801 | |
| 802 | const Local = struct { |
| 803 | fn propagateUsage(cur: *Section.Usage, new: Section.Usage) u1 { |
| 804 | const use: Section.Usage = switch (cur.*) { |
| 805 | .none => new, |
| 806 | .common => .common, |
| 807 | .debug => switch (new) { |
| 808 | .none, .debug => .debug, |
| 809 | else => new, |
| 810 | }, |
| 811 | .exe => switch (new) { |
| 812 | .common => .common, |
| 813 | .none, .debug, .exe => .exe, |
| 814 | .symbols => .exe, |
| 815 | }, |
| 816 | .symbols => switch (new) { |
| 817 | .none, .common, .debug, .exe => unreachable, |
| 818 | .symbols => .symbols, |
| 819 | }, |
| 820 | }; |
| 821 | |
| 822 | if (cur.* != use) { |
| 823 | cur.* = use; |
| 824 | return 1; |
| 825 | } else { |
| 826 | return 0; |
| 827 | } |
| 828 | } |
| 829 | }; |
| 830 | |
| 831 | for (sections) |*section| { |
| 832 | if (section.section.sh_link != elf.SHN_UNDEF) |
| 833 | dirty |= Local.propagateUsage(§ions[section.section.sh_link].usage, section.usage); |
| 834 | if ((section.section.sh_flags & elf.SHF_INFO_LINK) != 0 and section.section.sh_info != elf.SHN_UNDEF) |
| 835 | dirty |= Local.propagateUsage(§ions[section.section.sh_info].usage, section.usage); |
| 836 | |
| 837 | if (section.payload) |data| { |
| 838 | switch (section.section.sh_type) { |
| 839 | elf.DT_VERSYM => { |
| 840 | std.debug.assert(section.section.sh_entsize == @sizeOf(elf.Elf64_Verdef)); |
| 841 | const defs = @ptrCast([*]const elf.Elf64_Verdef, data)[0 .. section.section.sh_size / @sizeOf(elf.Elf64_Verdef)]; |
| 842 | for (defs) |def| { |
| 843 | if (def.vd_ndx != elf.SHN_UNDEF) |
| 844 | dirty |= Local.propagateUsage(§ions[def.vd_ndx].usage, section.usage); |
| 845 | } |
| 846 | }, |
| 847 | elf.SHT_SYMTAB, elf.SHT_DYNSYM => { |
| 848 | std.debug.assert(section.section.sh_entsize == @sizeOf(elf.Elf64_Sym)); |
| 849 | const syms = @ptrCast([*]const elf.Elf64_Sym, data)[0 .. section.section.sh_size / @sizeOf(elf.Elf64_Sym)]; |
| 850 | |
| 851 | for (syms) |sym| { |
| 852 | if (sym.st_shndx != elf.SHN_UNDEF and sym.st_shndx < elf.SHN_LORESERVE) |
| 853 | dirty |= Local.propagateUsage(§ions[sym.st_shndx].usage, section.usage); |
| 854 | } |
| 855 | }, |
| 856 | else => {}, |
| 857 | } |
| 858 | } |
| 859 | } |
| 860 | } |
| 861 | |
| 862 | return Self{ |
| 863 | .arena = arena, |
| 864 | .raw_elf_header = raw_header, |
| 865 | .program_segments = program_segments, |
| 866 | .sections = sections, |
| 867 | }; |
| 868 | } |
| 869 | |
| 870 | pub fn deinit(self: *Self) void { |
| 871 | self.arena.deinit(); |
| 872 | } |
| 873 | |
| 874 | const DebugLink = struct { name: []const u8, crc32: u32 }; |
| 875 | const Filter = enum { program, debug, program_and_symbols, debug_and_symbols }; |
| 876 | fn emit(self: *const Self, gpa: Allocator, output: File, source: File, filter: Filter, debuglink: ?DebugLink) !void { |
| 877 | var arena = std.heap.ArenaAllocator.init(gpa); |
| 878 | defer arena.deinit(); |
| 879 | const allocator = arena.allocator(); |
| 880 | |
| 881 | // when emitting the stripped exe: |
| 882 | // - unused sections are removed |
| 883 | // when emitting the debug file: |
| 884 | // - all sections are kept, but some are emptied and their types is changed to SHT_NOBITS |
| 885 | // the program header is kept unchanged. (`strip` does update it, but `eu-strip` does not, and it still works) TODO: maybe it can be omitted altogether from debug? |
| 886 | |
| 887 | const Update = struct { |
| 888 | action: enum { keep, strip, empty }, |
| 889 | |
| 890 | // remap the indexs after omitting the filtered sections |
| 891 | remap_idx: u16, |
| 892 | |
| 893 | // optionally overrides the payload from the source file |
| 894 | payload: ?[]align(section_memory_align) const u8, |
| 895 | }; |
| 896 | const sections_update = try allocator.alloc(Update, self.sections.len); |
| 897 | const new_shnum = blk: { |
| 898 | var next_idx: u16 = 0; |
| 899 | for (self.sections, sections_update) |section, *update| { |
| 900 | update.action = action: { |
| 901 | if (section.usage == .none) break :action .strip; |
| 902 | break :action switch (filter) { |
| 903 | .program => switch (section.usage) { |
| 904 | .common, .exe => .keep, |
| 905 | else => .strip, |
| 906 | }, |
| 907 | .program_and_symbols => switch (section.usage) { |
| 908 | .common, .exe, .symbols => .keep, |
| 909 | else => .strip, |
| 910 | }, |
| 911 | .debug => switch (section.usage) { |
| 912 | .exe, .symbols => .empty, |
| 913 | else => .keep, |
| 914 | }, |
| 915 | .debug_and_symbols => switch (section.usage) { |
| 916 | .exe => .empty, |
| 917 | else => .keep, |
| 918 | }, |
| 919 | }; |
| 920 | }; |
| 921 | |
| 922 | if (update.action == .strip) { |
| 923 | update.remap_idx = elf.SHN_UNDEF; |
| 924 | } else { |
| 925 | update.remap_idx = next_idx; |
| 926 | next_idx += 1; |
| 927 | } |
| 928 | |
| 929 | update.payload = null; |
| 930 | } |
| 931 | |
| 932 | if (debuglink != null) |
| 933 | next_idx += 1; |
| 934 | break :blk next_idx; |
| 935 | }; |
| 936 | |
| 937 | const debuglink_name: elf.Elf64_Word = blk: { |
| 938 | if (debuglink == null) break :blk elf.SHN_UNDEF; |
| 939 | if (self.raw_elf_header.e_shstrndx == elf.SHN_UNDEF) |
| 940 | fatal("zig objcopy: no strtab, cannot add the debuglink section", .{}); // TODO add the section if needed? |
| 941 | |
| 942 | const strtab = &self.sections[self.raw_elf_header.e_shstrndx]; |
| 943 | const update = §ions_update[self.raw_elf_header.e_shstrndx]; |
| 944 | |
| 945 | const name: []const u8 = ".gnu_debuglink"; |
| 946 | const new_offset = @intCast(u32, strtab.payload.?.len); |
| 947 | const buf = try allocator.alignedAlloc(u8, section_memory_align, new_offset + name.len + 1); |
| 948 | std.mem.copy(u8, buf[0..new_offset], strtab.payload.?); |
| 949 | std.mem.copy(u8, buf[new_offset .. new_offset + name.len], name); |
| 950 | buf[new_offset + name.len] = 0; |
| 951 | |
| 952 | std.debug.assert(update.action == .keep); |
| 953 | update.payload = buf; |
| 954 | |
| 955 | break :blk new_offset; |
| 956 | }; |
| 957 | |
| 958 | const WriteCmd = union(enum) { |
| 959 | copy_range: struct { in_offset: u64, len: u64, out_offset: u64 }, |
| 960 | write_data: struct { data: []const u8, out_offset: u64 }, |
| 961 | }; |
| 962 | var cmdbuf = std.ArrayList(WriteCmd).init(allocator); |
| 963 | defer cmdbuf.deinit(); |
| 964 | try cmdbuf.ensureUnusedCapacity(3 + new_shnum); |
| 965 | var eof_offset: u64 = 0; // track the end of the data written so far. |
| 966 | |
| 967 | // build the updated headers |
| 968 | // nb: updated_elf_header will be updated before the actual write |
| 969 | var updated_elf_header = self.raw_elf_header; |
| 970 | if (updated_elf_header.e_shstrndx != elf.SHN_UNDEF) |
| 971 | updated_elf_header.e_shstrndx = sections_update[updated_elf_header.e_shstrndx].remap_idx; |
| 972 | cmdbuf.appendAssumeCapacity(.{ .write_data = .{ .data = std.mem.asBytes(&updated_elf_header), .out_offset = 0 } }); |
| 973 | eof_offset = @sizeOf(elf.Elf64_Ehdr); |
| 974 | |
| 975 | // program header as-is. |
| 976 | { |
| 977 | std.debug.assert(updated_elf_header.e_phoff == @sizeOf(elf.Elf64_Ehdr)); |
| 978 | const data = std.mem.sliceAsBytes(self.program_segments); |
| 979 | std.debug.assert(data.len == @as(usize, updated_elf_header.e_phentsize) * updated_elf_header.e_phnum); |
| 980 | cmdbuf.appendAssumeCapacity(.{ .write_data = .{ .data = data, .out_offset = updated_elf_header.e_phoff } }); |
| 981 | eof_offset = updated_elf_header.e_phoff + data.len; |
| 982 | } |
| 983 | |
| 984 | // update sections and queue payload writes |
| 985 | const updated_section_header = blk: { |
| 986 | const dest_sections = try allocator.alloc(elf.Elf64_Shdr, new_shnum); |
| 987 | |
| 988 | { |
| 989 | // the ELF format doesn't specify the order for all sections. |
| 990 | // this code only supports when they are in increasing file order. |
| 991 | var offset: u64 = eof_offset; |
| 992 | for (self.sections[1..]) |section| { |
| 993 | if (section.section.sh_offset < offset) { |
| 994 | fatal("zig objcopy: unsuported ELF file", .{}); |
| 995 | } |
| 996 | offset = section.section.sh_offset; |
| 997 | } |
| 998 | } |
| 999 | |
| 1000 | dest_sections[0] = self.sections[0].section; |
| 1001 | |
| 1002 | var dest_section_idx: u32 = 1; |
| 1003 | for (self.sections[1..], sections_update[1..]) |section, update| { |
| 1004 | if (update.action == .strip) continue; |
| 1005 | std.debug.assert(update.remap_idx == dest_section_idx); |
| 1006 | |
| 1007 | const src = §ion.section; |
| 1008 | const dest = &dest_sections[dest_section_idx]; |
| 1009 | dest_section_idx += 1; |
| 1010 | |
| 1011 | dest.* = src.*; |
| 1012 | |
| 1013 | if (src.sh_link != elf.SHN_UNDEF) |
| 1014 | dest.sh_link = sections_update[src.sh_link].remap_idx; |
| 1015 | if ((src.sh_flags & elf.SHF_INFO_LINK) != 0 and src.sh_info != elf.SHN_UNDEF) |
| 1016 | dest.sh_info = sections_update[src.sh_info].remap_idx; |
| 1017 | |
| 1018 | const payload = if (update.payload) |data| data else section.payload; |
| 1019 | if (payload) |data| |
| 1020 | dest.sh_size = data.len; |
| 1021 | |
| 1022 | const addralign = if (src.sh_addralign == 0 or dest.sh_type == elf.SHT_NOBITS) 1 else src.sh_addralign; |
| 1023 | dest.sh_offset = std.mem.alignForward(eof_offset, addralign); |
| 1024 | if (src.sh_offset != dest.sh_offset and section.segment != null and update.action != .empty and dest.sh_type != elf.SHT_NOTE) { |
| 1025 | if (src.sh_offset > dest.sh_offset) { |
| 1026 | dest.sh_offset = src.sh_offset; // add padding to avoid modifing the program segments |
| 1027 | } else { |
| 1028 | fatal("zig objcopy: cannot adjust program segments", .{}); |
| 1029 | } |
| 1030 | } |
| 1031 | std.debug.assert(dest.sh_addr % addralign == dest.sh_offset % addralign); |
| 1032 | |
| 1033 | if (update.action == .empty) |
| 1034 | dest.sh_type = elf.SHT_NOBITS; |
| 1035 | |
| 1036 | if (dest.sh_type != elf.SHT_NOBITS) { |
| 1037 | if (payload) |src_data| { |
| 1038 | // update sections payload and write |
| 1039 | const data = try allocator.alignedAlloc(u8, section_memory_align, src_data.len); |
| 1040 | std.mem.copy(u8, data, src_data); |
| 1041 | |
| 1042 | switch (src.sh_type) { |
| 1043 | elf.DT_VERSYM => { |
| 1044 | const defs = @ptrCast([*]elf.Elf64_Verdef, data)[0 .. src.sh_size / @sizeOf(elf.Elf64_Verdef)]; |
| 1045 | for (defs) |*def| { |
| 1046 | if (def.vd_ndx != elf.SHN_UNDEF) |
| 1047 | def.vd_ndx = sections_update[src.sh_info].remap_idx; |
| 1048 | } |
| 1049 | }, |
| 1050 | elf.SHT_SYMTAB, elf.SHT_DYNSYM => { |
| 1051 | const syms = @ptrCast([*]elf.Elf64_Sym, data)[0 .. src.sh_size / @sizeOf(elf.Elf64_Sym)]; |
| 1052 | for (syms) |*sym| { |
| 1053 | if (sym.st_shndx != elf.SHN_UNDEF and sym.st_shndx < elf.SHN_LORESERVE) |
| 1054 | sym.st_shndx = sections_update[sym.st_shndx].remap_idx; |
| 1055 | } |
| 1056 | }, |
| 1057 | else => {}, |
| 1058 | } |
| 1059 | |
| 1060 | std.debug.assert(data.len == dest.sh_size); |
| 1061 | cmdbuf.appendAssumeCapacity(.{ .write_data = .{ .data = data, .out_offset = dest.sh_offset } }); |
| 1062 | eof_offset = dest.sh_offset + dest.sh_size; |
| 1063 | } else { |
| 1064 | // direct contents copy |
| 1065 | cmdbuf.appendAssumeCapacity(.{ .copy_range = .{ .in_offset = src.sh_offset, .len = dest.sh_size, .out_offset = dest.sh_offset } }); |
| 1066 | eof_offset = dest.sh_offset + dest.sh_size; |
| 1067 | } |
| 1068 | } else { |
| 1069 | // account for alignment padding even in empty sections to keep logical section order |
| 1070 | eof_offset = dest.sh_offset; |
| 1071 | } |
| 1072 | } |
| 1073 | |
| 1074 | // add a ".gnu_debuglink" section |
| 1075 | if (debuglink) |link| { |
| 1076 | const payload = payload: { |
| 1077 | const crc_offset = std.mem.alignForward(link.name.len + 1, 4); |
| 1078 | const buf = try allocator.alignedAlloc(u8, 4, crc_offset + 4); |
| 1079 | std.mem.copy(u8, buf[0..link.name.len], link.name); |
| 1080 | std.mem.set(u8, buf[link.name.len..crc_offset], 0); |
| 1081 | std.mem.copy(u8, buf[crc_offset..], std.mem.asBytes(&link.crc32)); |
| 1082 | break :payload buf; |
| 1083 | }; |
| 1084 | |
| 1085 | dest_sections[dest_section_idx] = elf.Elf64_Shdr{ |
| 1086 | .sh_name = debuglink_name, |
| 1087 | .sh_type = elf.SHT_PROGBITS, |
| 1088 | .sh_flags = 0, |
| 1089 | .sh_addr = 0, |
| 1090 | .sh_offset = eof_offset, |
| 1091 | .sh_size = payload.len, |
| 1092 | .sh_link = elf.SHN_UNDEF, |
| 1093 | .sh_info = elf.SHN_UNDEF, |
| 1094 | .sh_addralign = 4, |
| 1095 | .sh_entsize = 0, |
| 1096 | }; |
| 1097 | dest_section_idx += 1; |
| 1098 | |
| 1099 | cmdbuf.appendAssumeCapacity(.{ .write_data = .{ .data = payload, .out_offset = eof_offset } }); |
| 1100 | eof_offset += payload.len; |
| 1101 | } |
| 1102 | |
| 1103 | std.debug.assert(dest_section_idx == new_shnum); |
| 1104 | break :blk dest_sections; |
| 1105 | }; |
| 1106 | |
| 1107 | // write the section header at the tail |
| 1108 | { |
| 1109 | const offset = std.mem.alignForward(eof_offset, @alignOf(elf.Elf64_Shdr)); |
| 1110 | |
| 1111 | const data = std.mem.sliceAsBytes(updated_section_header); |
| 1112 | std.debug.assert(data.len == @as(usize, updated_elf_header.e_shentsize) * new_shnum); |
| 1113 | updated_elf_header.e_shoff = offset; |
| 1114 | updated_elf_header.e_shnum = new_shnum; |
| 1115 | |
| 1116 | cmdbuf.appendAssumeCapacity(.{ .write_data = .{ .data = data, .out_offset = updated_elf_header.e_shoff } }); |
| 1117 | } |
| 1118 | |
| 1119 | // write the target files |
| 1120 | // TODO: pack together contiguous copies (cmdbuf if ordered by construction) |
| 1121 | // TODO: fill the paddings with zero or copy from source file |
| 1122 | for (cmdbuf.items) |cmd| { |
| 1123 | switch (cmd) { |
| 1124 | .write_data => |data| { |
| 1125 | var iovec = [_]std.os.iovec_const{.{ .iov_base = data.data.ptr, .iov_len = data.data.len }}; |
| 1126 | try output.pwritevAll(&iovec, data.out_offset); |
| 1127 | }, |
| 1128 | .copy_range => |range| { |
| 1129 | const copied_bytes = try source.copyRangeAll(range.in_offset, output, range.out_offset, range.len); |
| 1130 | if (copied_bytes < range.len) return error.TRUNCATED_ELF; |
| 1131 | }, |
| 1132 | } |
| 1133 | } |
| 1134 | } |
| 1135 | |
| 1136 | fn sectionWithinSegment(section: elf.Elf64_Shdr, segment: elf.Elf64_Phdr) bool { |
| 1137 | const file_size = if (section.sh_type == elf.SHT_NOBITS) 0 else section.sh_size; |
| 1138 | return segment.p_offset <= section.sh_offset and (segment.p_offset + segment.p_filesz) >= (section.sh_offset + file_size); |
| 1139 | } |
| 1140 | }; |
| 1141 | |
| 1142 | fn computeFileCrc(file: File) !u32 { |
| 1143 | var buf: [8000]u8 = undefined; |
| 1144 | |
| 1145 | try file.seekTo(0); |
| 1146 | var hasher = std.hash.Crc32.init(); |
| 1147 | while (true) { |
| 1148 | const bytes_read = try file.read(&buf); |
| 1149 | if (bytes_read == 0) break; |
| 1150 | hasher.update(buf[0..bytes_read]); |
| 1151 | } |
| 1152 | return hasher.final(); |
| 1153 | } |
Xavier Bouchoux <xavierb@gmail.com> 2023-03-11 16:37:27+01:00