Commit 33de937fd91c64cd65894369cf7d92665a8e582e | zig

author	Andrew Kelley <andrew@ziglang.org> 2024-03-02 16:01:29-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2024-03-02 21:22:45-08:00
log	33de937fd91c64cd65894369cf7d92665a8e582e
tree	2395cdb339174596c05cb1ab10d8a59fc24ff8ce
parent	aa688567f556f9d24cae25f087adf90d96f6906f

move `zig objcopy` command to be lazily built

part of #19063

3 files changed, 1372 insertions(+), 1358 deletions(-)

lib
- compiler
  - objcopy.zig
src
- main.zig
- objcopy.zig

lib/compiler/objcopy.zig created+1368

...	@@ -0,0 +1,1368 @@
1	const builtin = @import("builtin");
2	const std = @import("std");
3	const mem = std.mem;
4	const fs = std.fs;
5	const elf = std.elf;
6	const Allocator = std.mem.Allocator;
7	const File = std.fs.File;
8	const assert = std.debug.assert;
9
10	const fatal = std.zig.fatal;
11	const Server = std.zig.Server;
12
13	pub fn main() !void {
14	var arena_instance = std.heap.ArenaAllocator.init(std.heap.page_allocator);
15	defer arena_instance.deinit();
16	const arena = arena_instance.allocator();
17
18	var general_purpose_allocator: std.heap.GeneralPurposeAllocator(.{}) = .{};
19	const gpa = general_purpose_allocator.allocator();
20
21	const args = try std.process.argsAlloc(arena);
22	return cmdObjCopy(gpa, arena, args[1..]);
23	}
24
25	fn cmdObjCopy(
26	gpa: Allocator,
27	arena: Allocator,
28	args: []const []const u8,
29	) !void {
30	var i: usize = 0;
31	var opt_out_fmt: ?std.Target.ObjectFormat = null;
32	var opt_input: ?[]const u8 = null;
33	var opt_output: ?[]const u8 = null;
34	var opt_extract: ?[]const u8 = null;
35	var opt_add_debuglink: ?[]const u8 = null;
36	var only_section: ?[]const u8 = null;
37	var pad_to: ?u64 = null;
38	var strip_all: bool = false;
39	var strip_debug: bool = false;
40	var only_keep_debug: bool = false;
41	var compress_debug_sections: bool = false;
42	var listen = false;
43	while (i < args.len) : (i += 1) {
44	const arg = args[i];
45	if (!mem.startsWith(u8, arg, "-")) {
46	if (opt_input == null) {
47	opt_input = arg;
48	} else if (opt_output == null) {
49	opt_output = arg;
50	} else {
51	fatal("unexpected positional argument: '{s}'", .{arg});
52	}
53	} else if (mem.eql(u8, arg, "-h") or mem.eql(u8, arg, "--help")) {
54	return std.io.getStdOut().writeAll(usage);
55	} else if (mem.eql(u8, arg, "-O") or mem.eql(u8, arg, "--output-target")) {
56	i += 1;
57	if (i >= args.len) fatal("expected another argument after '{s}'", .{arg});
58	const next_arg = args[i];
59	if (mem.eql(u8, next_arg, "binary")) {
60	opt_out_fmt = .raw;
61	} else {
62	opt_out_fmt = std.meta.stringToEnum(std.Target.ObjectFormat, next_arg) orelse
63	fatal("invalid output format: '{s}'", .{next_arg});
64	}
65	} else if (mem.startsWith(u8, arg, "--output-target=")) {
66	const next_arg = arg["--output-target=".len..];
67	if (mem.eql(u8, next_arg, "binary")) {
68	opt_out_fmt = .raw;
69	} else {
70	opt_out_fmt = std.meta.stringToEnum(std.Target.ObjectFormat, next_arg) orelse
71	fatal("invalid output format: '{s}'", .{next_arg});
72	}
73	} else if (mem.eql(u8, arg, "-j") or mem.eql(u8, arg, "--only-section")) {
74	i += 1;
75	if (i >= args.len) fatal("expected another argument after '{s}'", .{arg});
76	only_section = args[i];
77	} else if (mem.eql(u8, arg, "--listen=-")) {
78	listen = true;
79	} else if (mem.startsWith(u8, arg, "--only-section=")) {
80	only_section = arg["--only-section=".len..];
81	} else if (mem.eql(u8, arg, "--pad-to")) {
82	i += 1;
83	if (i >= args.len) fatal("expected another argument after '{s}'", .{arg});
84	pad_to = std.fmt.parseInt(u64, args[i], 0) catch \|err\| {
85	fatal("unable to parse: '{s}': {s}", .{ args[i], @errorName(err) });
86	};
87	} else if (mem.eql(u8, arg, "-g") or mem.eql(u8, arg, "--strip-debug")) {
88	strip_debug = true;
89	} else if (mem.eql(u8, arg, "-S") or mem.eql(u8, arg, "--strip-all")) {
90	strip_all = true;
91	} else if (mem.eql(u8, arg, "--only-keep-debug")) {
92	only_keep_debug = true;
93	} else if (mem.eql(u8, arg, "--compress-debug-sections")) {
94	compress_debug_sections = true;
95	} else if (mem.startsWith(u8, arg, "--add-gnu-debuglink=")) {
96	opt_add_debuglink = arg["--add-gnu-debuglink=".len..];
97	} else if (mem.eql(u8, arg, "--add-gnu-debuglink")) {
98	i += 1;
99	if (i >= args.len) fatal("expected another argument after '{s}'", .{arg});
100	opt_add_debuglink = args[i];
101	} else if (mem.startsWith(u8, arg, "--extract-to=")) {
102	opt_extract = arg["--extract-to=".len..];
103	} else if (mem.eql(u8, arg, "--extract-to")) {
104	i += 1;
105	if (i >= args.len) fatal("expected another argument after '{s}'", .{arg});
106	opt_extract = args[i];
107	} else {
108	fatal("unrecognized argument: '{s}'", .{arg});
109	}
110	}
111	const input = opt_input orelse fatal("expected input parameter", .{});
112	const output = opt_output orelse fatal("expected output parameter", .{});
113
114	var in_file = fs.cwd().openFile(input, .{}) catch \|err\|
115	fatal("unable to open '{s}': {s}", .{ input, @errorName(err) });
116	defer in_file.close();
117
118	const elf_hdr = std.elf.Header.read(in_file) catch \|err\| switch (err) {
119	error.InvalidElfMagic => fatal("not an ELF file: '{s}'", .{input}),
120	else => fatal("unable to read '{s}': {s}", .{ input, @errorName(err) }),
121	};
122
123	const in_ofmt = .elf;
124
125	const out_fmt: std.Target.ObjectFormat = opt_out_fmt orelse ofmt: {
126	if (mem.endsWith(u8, output, ".hex") or std.mem.endsWith(u8, output, ".ihex")) {
127	break :ofmt .hex;
128	} else if (mem.endsWith(u8, output, ".bin")) {
129	break :ofmt .raw;
130	} else if (mem.endsWith(u8, output, ".elf")) {
131	break :ofmt .elf;
132	} else {
133	break :ofmt in_ofmt;
134	}
135	};
136
137	const mode = mode: {
138	if (out_fmt != .elf or only_keep_debug)
139	break :mode fs.File.default_mode;
140	if (in_file.stat()) \|stat\|
141	break :mode stat.mode
142	else \|_\|
143	break :mode fs.File.default_mode;
144	};
145	var out_file = try fs.cwd().createFile(output, .{ .mode = mode });
146	defer out_file.close();
147
148	switch (out_fmt) {
149	.hex, .raw => {
150	if (strip_debug or strip_all or only_keep_debug)
151	fatal("zig objcopy: ELF to RAW or HEX copying does not support --strip", .{});
152	if (opt_extract != null)
153	fatal("zig objcopy: ELF to RAW or HEX copying does not support --extract-to", .{});
154
155	try emitElf(arena, in_file, out_file, elf_hdr, .{
156	.ofmt = out_fmt,
157	.only_section = only_section,
158	.pad_to = pad_to,
159	});
160	},
161	.elf => {
162	if (elf_hdr.endian != builtin.target.cpu.arch.endian())
163	fatal("zig objcopy: ELF to ELF copying only supports native endian", .{});
164	if (elf_hdr.phoff == 0) // no program header
165	fatal("zig objcopy: ELF to ELF copying only supports programs", .{});
166	if (only_section) \|_\|
167	fatal("zig objcopy: ELF to ELF copying does not support --only-section", .{});
168	if (pad_to) \|_\|
169	fatal("zig objcopy: ELF to ELF copying does not support --pad-to", .{});
170
171	try stripElf(arena, in_file, out_file, elf_hdr, .{
172	.strip_debug = strip_debug,
173	.strip_all = strip_all,
174	.only_keep_debug = only_keep_debug,
175	.add_debuglink = opt_add_debuglink,
176	.extract_to = opt_extract,
177	.compress_debug = compress_debug_sections,
178	});
179	return std.process.cleanExit();
180	},
181	else => fatal("unsupported output object format: {s}", .{@tagName(out_fmt)}),
182	}
183
184	if (listen) {
185	var server = try Server.init(.{
186	.gpa = gpa,
187	.in = std.io.getStdIn(),
188	.out = std.io.getStdOut(),
189	.zig_version = builtin.zig_version_string,
190	});
191	defer server.deinit();
192
193	var seen_update = false;
194	while (true) {
195	const hdr = try server.receiveMessage();
196	switch (hdr.tag) {
197	.exit => {
198	return std.process.cleanExit();
199	},
200	.update => {
201	if (seen_update) {
202	std.debug.print("zig objcopy only supports 1 update for now\n", .{});
203	std.process.exit(1);
204	}
205	seen_update = true;
206
207	try server.serveEmitBinPath(output, .{
208	.flags = .{ .cache_hit = false },
209	});
210	},
211	else => {
212	std.debug.print("unsupported message: {s}", .{@tagName(hdr.tag)});
213	std.process.exit(1);
214	},
215	}
216	}
217	}
218	return std.process.cleanExit();
219	}
220
221	const usage =
222	\\Usage: zig objcopy [options] input output
223	\\
224	\\Options:
225	\\ -h, --help Print this help and exit
226	\\ --output-target=<value> Format of the output file
227	\\ -O <value> Alias for --output-target
228	\\ --only-section=<section> Remove all but <section>
229	\\ -j <value> Alias for --only-section
230	\\ --pad-to <addr> Pad the last section up to address <addr>
231	\\ --strip-debug, -g Remove all debug sections from the output.
232	\\ --strip-all, -S Remove all debug sections and symbol table from the output.
233	\\ --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.
234	\\ --add-gnu-debuglink=<file> Creates a .gnu_debuglink section which contains a reference to <file> and adds it to the output file.
235	\\ --extract-to <file> Extract the removed sections into <file>, and add a .gnu-debuglink section.
236	\\ --compress-debug-sections Compress DWARF debug sections with zlib
237	\\
238	;
239
240	pub const EmitRawElfOptions = struct {
241	ofmt: std.Target.ObjectFormat,
242	only_section: ?[]const u8 = null,
243	pad_to: ?u64 = null,
244	};
245
246	fn emitElf(
247	arena: Allocator,
248	in_file: File,
249	out_file: File,
250	elf_hdr: elf.Header,
251	options: EmitRawElfOptions,
252	) !void {
253	var binary_elf_output = try BinaryElfOutput.parse(arena, in_file, elf_hdr);
254	defer binary_elf_output.deinit();
255
256	if (options.ofmt == .elf) {
257	fatal("zig objcopy: ELF to ELF copying is not implemented yet", .{});
258	}
259
260	if (options.only_section) \|target_name\| {
261	switch (options.ofmt) {
262	.hex => fatal("zig objcopy: hex format with sections is not implemented yet", .{}),
263	.raw => {
264	for (binary_elf_output.sections.items) \|section\| {
265	if (section.name) \|curr_name\| {
266	if (!std.mem.eql(u8, curr_name, target_name))
267	continue;
268	} else {
269	continue;
270	}
271
272	try writeBinaryElfSection(in_file, out_file, section);
273	try padFile(out_file, options.pad_to);
274	return;
275	}
276	},
277	else => unreachable,
278	}
279
280	return error.SectionNotFound;
281	}
282
283	switch (options.ofmt) {
284	.raw => {
285	for (binary_elf_output.sections.items) \|section\| {
286	try out_file.seekTo(section.binaryOffset);
287	try writeBinaryElfSection(in_file, out_file, section);
288	}
289	try padFile(out_file, options.pad_to);
290	},
291	.hex => {
292	if (binary_elf_output.segments.items.len == 0) return;
293	if (!containsValidAddressRange(binary_elf_output.segments.items)) {
294	return error.InvalidHexfileAddressRange;
295	}
296
297	var hex_writer = HexWriter{ .out_file = out_file };
298	for (binary_elf_output.segments.items) \|segment\| {
299	try hex_writer.writeSegment(segment, in_file);
300	}
301	if (options.pad_to) \|_\| {
302	// Padding to a size in hex files isn't applicable
303	return error.InvalidArgument;
304	}
305	try hex_writer.writeEOF();
306	},
307	else => unreachable,
308	}
309	}
310
311	const BinaryElfSection = struct {
312	elfOffset: u64,
313	binaryOffset: u64,
314	fileSize: usize,
315	name: ?[]const u8,
316	segment: ?*BinaryElfSegment,
317	};
318
319	const BinaryElfSegment = struct {
320	physicalAddress: u64,
321	virtualAddress: u64,
322	elfOffset: u64,
323	binaryOffset: u64,
324	fileSize: u64,
325	firstSection: ?*BinaryElfSection,
326	};
327
328	const BinaryElfOutput = struct {
329	segments: std.ArrayListUnmanaged(*BinaryElfSegment),
330	sections: std.ArrayListUnmanaged(*BinaryElfSection),
331	allocator: Allocator,
332	shstrtab: ?[]const u8,
333
334	const Self = @This();
335
336	pub fn deinit(self: *Self) void {
337	if (self.shstrtab) \|shstrtab\|
338	self.allocator.free(shstrtab);
339	self.sections.deinit(self.allocator);
340	self.segments.deinit(self.allocator);
341	}
342
343	pub fn parse(allocator: Allocator, elf_file: File, elf_hdr: elf.Header) !Self {
344	var self: Self = .{
345	.segments = .{},
346	.sections = .{},
347	.allocator = allocator,
348	.shstrtab = null,
349	};
350	errdefer self.sections.deinit(allocator);
351	errdefer self.segments.deinit(allocator);
352
353	self.shstrtab = blk: {
354	if (elf_hdr.shstrndx >= elf_hdr.shnum) break :blk null;
355
356	var section_headers = elf_hdr.section_header_iterator(&elf_file);
357
358	var section_counter: usize = 0;
359	while (section_counter < elf_hdr.shstrndx) : (section_counter += 1) {
360	_ = (try section_headers.next()).?;
361	}
362
363	const shstrtab_shdr = (try section_headers.next()).?;
364
365	const buffer = try allocator.alloc(u8, @intCast(shstrtab_shdr.sh_size));
366	errdefer allocator.free(buffer);
367
368	const num_read = try elf_file.preadAll(buffer, shstrtab_shdr.sh_offset);
369	if (num_read != buffer.len) return error.EndOfStream;
370
371	break :blk buffer;
372	};
373
374	errdefer if (self.shstrtab) \|shstrtab\| allocator.free(shstrtab);
375
376	var section_headers = elf_hdr.section_header_iterator(&elf_file);
377	while (try section_headers.next()) \|section\| {
378	if (sectionValidForOutput(section)) {
379	const newSection = try allocator.create(BinaryElfSection);
380
381	newSection.binaryOffset = 0;
382	newSection.elfOffset = section.sh_offset;
383	newSection.fileSize = @intCast(section.sh_size);
384	newSection.segment = null;
385
386	newSection.name = if (self.shstrtab) \|shstrtab\|
387	std.mem.span(@as([*:0]const u8, @ptrCast(&shstrtab[section.sh_name])))
388	else
389	null;
390
391	try self.sections.append(allocator, newSection);
392	}
393	}
394
395	var program_headers = elf_hdr.program_header_iterator(&elf_file);
396	while (try program_headers.next()) \|phdr\| {
397	if (phdr.p_type == elf.PT_LOAD) {
398	const newSegment = try allocator.create(BinaryElfSegment);
399
400	newSegment.physicalAddress = if (phdr.p_paddr != 0) phdr.p_paddr else phdr.p_vaddr;
401	newSegment.virtualAddress = phdr.p_vaddr;
402	newSegment.fileSize = @intCast(phdr.p_filesz);
403	newSegment.elfOffset = phdr.p_offset;
404	newSegment.binaryOffset = 0;
405	newSegment.firstSection = null;
406
407	for (self.sections.items) \|section\| {
408	if (sectionWithinSegment(section, phdr)) {
409	if (section.segment) \|sectionSegment\| {
410	if (sectionSegment.elfOffset > newSegment.elfOffset) {
411	section.segment = newSegment;
412	}
413	} else {
414	section.segment = newSegment;
415	}
416
417	if (newSegment.firstSection == null) {
418	newSegment.firstSection = section;
419	}
420	}
421	}
422
423	try self.segments.append(allocator, newSegment);
424	}
425	}
426
427	mem.sort(*BinaryElfSegment, self.segments.items, {}, segmentSortCompare);
428
429	for (self.segments.items, 0..) \|firstSegment, i\| {
430	if (firstSegment.firstSection) \|firstSection\| {
431	const diff = firstSection.elfOffset - firstSegment.elfOffset;
432
433	firstSegment.elfOffset += diff;
434	firstSegment.fileSize += diff;
435	firstSegment.physicalAddress += diff;
436
437	const basePhysicalAddress = firstSegment.physicalAddress;
438
439	for (self.segments.items[i + 1 ..]) \|segment\| {
440	segment.binaryOffset = segment.physicalAddress - basePhysicalAddress;
441	}
442	break;
443	}
444	}
445
446	for (self.sections.items) \|section\| {
447	if (section.segment) \|segment\| {
448	section.binaryOffset = segment.binaryOffset + (section.elfOffset - segment.elfOffset);
449	}
450	}
451
452	mem.sort(*BinaryElfSection, self.sections.items, {}, sectionSortCompare);
453
454	return self;
455	}
456
457	fn sectionWithinSegment(section: *BinaryElfSection, segment: elf.Elf64_Phdr) bool {
458	return segment.p_offset <= section.elfOffset and (segment.p_offset + segment.p_filesz) >= (section.elfOffset + section.fileSize);
459	}
460
461	fn sectionValidForOutput(shdr: anytype) bool {
462	return shdr.sh_type != elf.SHT_NOBITS and
463	((shdr.sh_flags & elf.SHF_ALLOC) == elf.SHF_ALLOC);
464	}
465
466	fn segmentSortCompare(context: void, left: BinaryElfSegment, right: BinaryElfSegment) bool {
467	_ = context;
468	if (left.physicalAddress < right.physicalAddress) {
469	return true;
470	}
471	if (left.physicalAddress > right.physicalAddress) {
472	return false;
473	}
474	return false;
475	}
476
477	fn sectionSortCompare(context: void, left: BinaryElfSection, right: BinaryElfSection) bool {
478	_ = context;
479	return left.binaryOffset < right.binaryOffset;
480	}
481	};
482
483	fn writeBinaryElfSection(elf_file: File, out_file: File, section: *BinaryElfSection) !void {
484	try out_file.writeFileAll(elf_file, .{
485	.in_offset = section.elfOffset,
486	.in_len = section.fileSize,
487	});
488	}
489
490	const HexWriter = struct {
491	prev_addr: ?u32 = null,
492	out_file: File,
493
494	/// Max data bytes per line of output
495	const MAX_PAYLOAD_LEN: u8 = 16;
496
497	fn addressParts(address: u16) [2]u8 {
498	const msb: u8 = @truncate(address >> 8);
499	const lsb: u8 = @truncate(address);
500	return [2]u8{ msb, lsb };
501	}
502
503	const Record = struct {
504	const Type = enum(u8) {
505	Data = 0,
506	EOF = 1,
507	ExtendedSegmentAddress = 2,
508	ExtendedLinearAddress = 4,
509	};
510
511	address: u16,
512	payload: union(Type) {
513	Data: []const u8,
514	EOF: void,
515	ExtendedSegmentAddress: [2]u8,
516	ExtendedLinearAddress: [2]u8,
517	},
518
519	fn EOF() Record {
520	return Record{
521	.address = 0,
522	.payload = .EOF,
523	};
524	}
525
526	fn Data(address: u32, data: []const u8) Record {
527	return Record{
528	.address = @intCast(address % 0x10000),
529	.payload = .{ .Data = data },
530	};
531	}
532
533	fn Address(address: u32) Record {
534	assert(address > 0xFFFF);
535	const segment: u16 = @intCast(address / 0x10000);
536	if (address > 0xFFFFF) {
537	return Record{
538	.address = 0,
539	.payload = .{ .ExtendedLinearAddress = addressParts(segment) },
540	};
541	} else {
542	return Record{
543	.address = 0,
544	.payload = .{ .ExtendedSegmentAddress = addressParts(segment << 12) },
545	};
546	}
547	}
548
549	fn getPayloadBytes(self: *const Record) []const u8 {
550	return switch (self.payload) {
551	.Data => \|d\| d,
552	.EOF => @as([]const u8, &.{}),
553	.ExtendedSegmentAddress, .ExtendedLinearAddress => \|*seg\| seg,
554	};
555	}
556
557	fn checksum(self: Record) u8 {
558	const payload_bytes = self.getPayloadBytes();
559
560	var sum: u8 = @intCast(payload_bytes.len);
561	const parts = addressParts(self.address);
562	sum +%= parts[0];
563	sum +%= parts[1];
564	sum +%= @intFromEnum(self.payload);
565	for (payload_bytes) \|byte\| {
566	sum +%= byte;
567	}
568	return (sum ^ 0xFF) +% 1;
569	}
570
571	fn write(self: Record, file: File) File.WriteError!void {
572	const linesep = "\r\n";
573	// colon, (length, address, type, payload, checksum) as hex, CRLF
574	const BUFSIZE = 1 + (1 + 2 + 1 + MAX_PAYLOAD_LEN + 1) * 2 + linesep.len;
575	var outbuf: [BUFSIZE]u8 = undefined;
576	const payload_bytes = self.getPayloadBytes();
577	assert(payload_bytes.len <= MAX_PAYLOAD_LEN);
578
579	const line = try std.fmt.bufPrint(&outbuf, ":{0X:0>2}{1X:0>4}{2X:0>2}{3s}{4X:0>2}" ++ linesep, .{
580	@as(u8, @intCast(payload_bytes.len)),
581	self.address,
582	@intFromEnum(self.payload),
583	std.fmt.fmtSliceHexUpper(payload_bytes),
584	self.checksum(),
585	});
586	try file.writeAll(line);
587	}
588	};
589
590	pub fn writeSegment(self: HexWriter, segment: const BinaryElfSegment, elf_file: File) !void {
591	var buf: [MAX_PAYLOAD_LEN]u8 = undefined;
592	var bytes_read: usize = 0;
593	while (bytes_read < segment.fileSize) {
594	const row_address: u32 = @intCast(segment.physicalAddress + bytes_read);
595
596	const remaining = segment.fileSize - bytes_read;
597	const to_read: usize = @intCast(@min(remaining, MAX_PAYLOAD_LEN));
598	const did_read = try elf_file.preadAll(buf[0..to_read], segment.elfOffset + bytes_read);
599	if (did_read < to_read) return error.UnexpectedEOF;
600
601	try self.writeDataRow(row_address, buf[0..did_read]);
602
603	bytes_read += did_read;
604	}
605	}
606
607	fn writeDataRow(self: *HexWriter, address: u32, data: []const u8) File.WriteError!void {
608	const record = Record.Data(address, data);
609	if (address > 0xFFFF and (self.prev_addr == null or record.address != self.prev_addr.?)) {
610	try Record.Address(address).write(self.out_file);
611	}
612	try record.write(self.out_file);
613	self.prev_addr = @intCast(record.address + data.len);
614	}
615
616	fn writeEOF(self: HexWriter) File.WriteError!void {
617	try Record.EOF().write(self.out_file);
618	}
619	};
620
621	fn containsValidAddressRange(segments: []*BinaryElfSegment) bool {
622	const max_address = std.math.maxInt(u32);
623	for (segments) \|segment\| {
624	if (segment.fileSize > max_address or
625	segment.physicalAddress > max_address - segment.fileSize) return false;
626	}
627	return true;
628	}
629
630	fn padFile(f: File, opt_size: ?u64) !void {
631	const size = opt_size orelse return;
632	try f.setEndPos(size);
633	}
634
635	test "HexWriter.Record.Address has correct payload and checksum" {
636	const record = HexWriter.Record.Address(0x0800_0000);
637	const payload = record.getPayloadBytes();
638	const sum = record.checksum();
639	try std.testing.expect(sum == 0xF2);
640	try std.testing.expect(payload.len == 2);
641	try std.testing.expect(payload[0] == 8);
642	try std.testing.expect(payload[1] == 0);
643	}
644
645	test "containsValidAddressRange" {
646	var segment = BinaryElfSegment{
647	.physicalAddress = 0,
648	.virtualAddress = 0,
649	.elfOffset = 0,
650	.binaryOffset = 0,
651	.fileSize = 0,
652	.firstSection = null,
653	};
654	var buf: [1]*BinaryElfSegment = .{&segment};
655
656	// segment too big
657	segment.fileSize = std.math.maxInt(u32) + 1;
658	try std.testing.expect(!containsValidAddressRange(&buf));
659
660	// start address too big
661	segment.physicalAddress = std.math.maxInt(u32) + 1;
662	segment.fileSize = 2;
663	try std.testing.expect(!containsValidAddressRange(&buf));
664
665	// max address too big
666	segment.physicalAddress = std.math.maxInt(u32) - 1;
667	segment.fileSize = 2;
668	try std.testing.expect(!containsValidAddressRange(&buf));
669
670	// is ok
671	segment.physicalAddress = std.math.maxInt(u32) - 1;
672	segment.fileSize = 1;
673	try std.testing.expect(containsValidAddressRange(&buf));
674	}
675
676	// -------------
677	// ELF to ELF stripping
678
679	const StripElfOptions = struct {
680	extract_to: ?[]const u8 = null,
681	add_debuglink: ?[]const u8 = null,
682	strip_all: bool = false,
683	strip_debug: bool = false,
684	only_keep_debug: bool = false,
685	compress_debug: bool = false,
686	};
687
688	fn stripElf(
689	allocator: Allocator,
690	in_file: File,
691	out_file: File,
692	elf_hdr: elf.Header,
693	options: StripElfOptions,
694	) !void {
695	const Filter = ElfFileHelper.Filter;
696	const DebugLink = ElfFileHelper.DebugLink;
697
698	const filter: Filter = filter: {
699	if (options.only_keep_debug) break :filter .debug;
700	if (options.strip_all) break :filter .program;
701	if (options.strip_debug) break :filter .program_and_symbols;
702	break :filter .all;
703	};
704
705	const filter_complement: ?Filter = blk: {
706	if (options.extract_to) \|_\| {
707	break :blk switch (filter) {
708	.program => .debug_and_symbols,
709	.debug => .program_and_symbols,
710	.program_and_symbols => .debug,
711	.debug_and_symbols => .program,
712	.all => fatal("zig objcopy: nothing to extract", .{}),
713	};
714	} else {
715	break :blk null;
716	}
717	};
718	const debuglink_path = path: {
719	if (options.add_debuglink) \|path\| break :path path;
720	if (options.extract_to) \|path\| break :path path;
721	break :path null;
722	};
723
724	switch (elf_hdr.is_64) {
725	inline else => \|is_64\| {
726	var elf_file = try ElfFile(is_64).parse(allocator, in_file, elf_hdr);
727	defer elf_file.deinit();
728
729	if (filter_complement) \|flt\| {
730	// write the .dbg file and close it, so it can be read back to compute the debuglink checksum.
731	const path = options.extract_to.?;
732	const dbg_file = std.fs.cwd().createFile(path, .{}) catch \|err\| {
733	fatal("zig objcopy: unable to create '{s}': {s}", .{ path, @errorName(err) });
734	};
735	defer dbg_file.close();
736
737	try elf_file.emit(allocator, dbg_file, in_file, .{ .section_filter = flt, .compress_debug = options.compress_debug });
738	}
739
740	const debuglink: ?DebugLink = if (debuglink_path) \|path\| ElfFileHelper.createDebugLink(path) else null;
741	try elf_file.emit(allocator, out_file, in_file, .{ .section_filter = filter, .debuglink = debuglink, .compress_debug = options.compress_debug });
742	},
743	}
744	}
745
746	// note: this is "a minimal effort implementation"
747	// It doesn't support all possibile elf files: some sections type may need fixups, the program header may need fix up, ...
748	// 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++` )
749	// It moves and reoders the sections as little as possible to avoid having to do fixups.
750	// TODO: support non-native endianess
751
752	fn ElfFile(comptime is_64: bool) type {
753	const Elf_Ehdr = if (is_64) elf.Elf64_Ehdr else elf.Elf32_Ehdr;
754	const Elf_Phdr = if (is_64) elf.Elf64_Phdr else elf.Elf32_Phdr;
755	const Elf_Shdr = if (is_64) elf.Elf64_Shdr else elf.Elf32_Shdr;
756	const Elf_Chdr = if (is_64) elf.Elf64_Chdr else elf.Elf32_Chdr;
757	const Elf_Sym = if (is_64) elf.Elf64_Sym else elf.Elf32_Sym;
758	const Elf_Verdef = if (is_64) elf.Elf64_Verdef else elf.Elf32_Verdef;
759	const Elf_OffSize = if (is_64) elf.Elf64_Off else elf.Elf32_Off;
760
761	return struct {
762	raw_elf_header: Elf_Ehdr,
763	program_segments: []const Elf_Phdr,
764	sections: []const Section,
765	arena: std.heap.ArenaAllocator,
766
767	const SectionCategory = ElfFileHelper.SectionCategory;
768	const section_memory_align = @alignOf(Elf_Sym); // most restrictive of what we may load in memory
769	const Section = struct {
770	section: Elf_Shdr,
771	name: []const u8 = "",
772	segment: ?*const Elf_Phdr = null, // if the section is used by a program segment (there can be more than one)
773	payload: ?[]align(section_memory_align) const u8 = null, // if we need the data in memory
774	category: SectionCategory = .none, // should the section be kept in the exe or stripped to the debug database, or both.
775	};
776
777	const Self = @This();
778
779	pub fn parse(gpa: Allocator, in_file: File, header: elf.Header) !Self {
780	var arena = std.heap.ArenaAllocator.init(gpa);
781	errdefer arena.deinit();
782	const allocator = arena.allocator();
783
784	var raw_header: Elf_Ehdr = undefined;
785	{
786	const bytes_read = try in_file.preadAll(std.mem.asBytes(&raw_header), 0);
787	if (bytes_read < @sizeOf(Elf_Ehdr))
788	return error.TRUNCATED_ELF;
789	}
790
791	// program header: list of segments
792	const program_segments = blk: {
793	if (@sizeOf(Elf_Phdr) != header.phentsize)
794	fatal("zig objcopy: unsuported ELF file, unexpected phentsize ({d})", .{header.phentsize});
795
796	const program_header = try allocator.alloc(Elf_Phdr, header.phnum);
797	const bytes_read = try in_file.preadAll(std.mem.sliceAsBytes(program_header), header.phoff);
798	if (bytes_read < @sizeOf(Elf_Phdr) * header.phnum)
799	return error.TRUNCATED_ELF;
800	break :blk program_header;
801	};
802
803	// section header
804	const sections = blk: {
805	if (@sizeOf(Elf_Shdr) != header.shentsize)
806	fatal("zig objcopy: unsuported ELF file, unexpected shentsize ({d})", .{header.shentsize});
807
808	const section_header = try allocator.alloc(Section, header.shnum);
809
810	const raw_section_header = try allocator.alloc(Elf_Shdr, header.shnum);
811	defer allocator.free(raw_section_header);
812	const bytes_read = try in_file.preadAll(std.mem.sliceAsBytes(raw_section_header), header.shoff);
813	if (bytes_read < @sizeOf(Elf_Phdr) * header.shnum)
814	return error.TRUNCATED_ELF;
815
816	for (section_header, raw_section_header) \|*section, hdr\| {
817	section.* = .{ .section = hdr };
818	}
819	break :blk section_header;
820	};
821
822	// load data to memory for some sections:
823	// string tables for access
824	// sections than need modifications when other sections move.
825	for (sections, 0..) \|*section, idx\| {
826	const need_data = switch (section.section.sh_type) {
827	elf.DT_VERSYM => true,
828	elf.SHT_SYMTAB, elf.SHT_DYNSYM => true,
829	else => false,
830	};
831	const need_strings = (idx == header.shstrndx);
832
833	if (need_data or need_strings) {
834	const buffer = try allocator.alignedAlloc(u8, section_memory_align, @intCast(section.section.sh_size));
835	const bytes_read = try in_file.preadAll(buffer, section.section.sh_offset);
836	if (bytes_read != section.section.sh_size) return error.TRUNCATED_ELF;
837	section.payload = buffer;
838	}
839	}
840
841	// fill-in sections info:
842	// resolve the name
843	// find if a program segment uses the section
844	// categorize sections usage (used by program segments, debug datadase, common metadata, symbol table)
845	for (sections) \|*section\| {
846	section.segment = for (program_segments) \|*seg\| {
847	if (sectionWithinSegment(section.section, seg.*)) break seg;
848	} else null;
849
850	if (section.section.sh_name != 0 and header.shstrndx != elf.SHN_UNDEF)
851	section.name = std.mem.span(@as([*:0]const u8, @ptrCast(&sections[header.shstrndx].payload.?[section.section.sh_name])));
852
853	const category_from_program: SectionCategory = if (section.segment != null) .exe else .debug;
854	section.category = switch (section.section.sh_type) {
855	elf.SHT_NOTE => .common,
856	elf.SHT_SYMTAB => .symbols, // "strip all" vs "strip only debug"
857	elf.SHT_DYNSYM => .exe,
858	elf.SHT_PROGBITS => cat: {
859	if (std.mem.eql(u8, section.name, ".comment")) break :cat .exe;
860	if (std.mem.eql(u8, section.name, ".gnu_debuglink")) break :cat .none;
861	break :cat category_from_program;
862	},
863	elf.SHT_LOPROC...elf.SHT_HIPROC => .common, // don't strip unknown sections
864	elf.SHT_LOUSER...elf.SHT_HIUSER => .common, // don't strip unknown sections
865	else => category_from_program,
866	};
867	}
868
869	sections[0].category = .common; // mandatory null section
870	if (header.shstrndx != elf.SHN_UNDEF)
871	sections[header.shstrndx].category = .common; // string table for the headers
872
873	// recursively propagate section categories to their linked sections, so that they are kept together
874	var dirty: u1 = 1;
875	while (dirty != 0) {
876	dirty = 0;
877
878	for (sections) \|*section\| {
879	if (section.section.sh_link != elf.SHN_UNDEF)
880	dirty \|= ElfFileHelper.propagateCategory(&sections[section.section.sh_link].category, section.category);
881	if ((section.section.sh_flags & elf.SHF_INFO_LINK) != 0 and section.section.sh_info != elf.SHN_UNDEF)
882	dirty \|= ElfFileHelper.propagateCategory(&sections[section.section.sh_info].category, section.category);
883	}
884	}
885
886	return Self{
887	.arena = arena,
888	.raw_elf_header = raw_header,
889	.program_segments = program_segments,
890	.sections = sections,
891	};
892	}
893
894	pub fn deinit(self: *Self) void {
895	self.arena.deinit();
896	}
897
898	const Filter = ElfFileHelper.Filter;
899	const DebugLink = ElfFileHelper.DebugLink;
900	const EmitElfOptions = struct {
901	section_filter: Filter = .all,
902	debuglink: ?DebugLink = null,
903	compress_debug: bool = false,
904	};
905	fn emit(self: *const Self, gpa: Allocator, out_file: File, in_file: File, options: EmitElfOptions) !void {
906	var arena = std.heap.ArenaAllocator.init(gpa);
907	defer arena.deinit();
908	const allocator = arena.allocator();
909
910	// when emitting the stripped exe:
911	// - unused sections are removed
912	// when emitting the debug file:
913	// - all sections are kept, but some are emptied and their types is changed to SHT_NOBITS
914	// the program header is kept unchanged. (`strip` does update it, but `eu-strip` does not, and it still works)
915
916	const Update = struct {
917	action: ElfFileHelper.Action,
918
919	// remap the indexs after omitting the filtered sections
920	remap_idx: u16,
921
922	// optionally overrides the payload from the source file
923	payload: ?[]align(section_memory_align) const u8 = null,
924	section: ?Elf_Shdr = null,
925	};
926	const sections_update = try allocator.alloc(Update, self.sections.len);
927	const new_shnum = blk: {
928	var next_idx: u16 = 0;
929	for (self.sections, sections_update) \|section, *update\| {
930	const action = ElfFileHelper.selectAction(section.category, options.section_filter);
931	const remap_idx = idx: {
932	if (action == .strip) break :idx elf.SHN_UNDEF;
933	next_idx += 1;
934	break :idx next_idx - 1;
935	};
936	update.* = Update{ .action = action, .remap_idx = remap_idx };
937	}
938
939	if (options.debuglink != null)
940	next_idx += 1;
941
942	break :blk next_idx;
943	};
944
945	// add a ".gnu_debuglink" to the string table if needed
946	const debuglink_name: u32 = blk: {
947	if (options.debuglink == null) break :blk elf.SHN_UNDEF;
948	if (self.raw_elf_header.e_shstrndx == elf.SHN_UNDEF)
949	fatal("zig objcopy: no strtab, cannot add the debuglink section", .{}); // TODO add the section if needed?
950
951	const strtab = &self.sections[self.raw_elf_header.e_shstrndx];
952	const update = &sections_update[self.raw_elf_header.e_shstrndx];
953
954	const name: []const u8 = ".gnu_debuglink";
955	const new_offset: u32 = @intCast(strtab.payload.?.len);
956	const buf = try allocator.alignedAlloc(u8, section_memory_align, new_offset + name.len + 1);
957	@memcpy(buf[0..new_offset], strtab.payload.?);
958	@memcpy(buf[new_offset..][0..name.len], name);
959	buf[new_offset + name.len] = 0;
960
961	assert(update.action == .keep);
962	update.payload = buf;
963
964	break :blk new_offset;
965	};
966
967	// maybe compress .debug sections
968	if (options.compress_debug) {
969	for (self.sections[1..], sections_update[1..]) \|section, *update\| {
970	if (update.action != .keep) continue;
971	if (!std.mem.startsWith(u8, section.name, ".debug_")) continue;
972	if ((section.section.sh_flags & elf.SHF_COMPRESSED) != 0) continue; // already compressed
973
974	const chdr = Elf_Chdr{
975	.ch_type = elf.COMPRESS.ZLIB,
976	.ch_size = section.section.sh_size,
977	.ch_addralign = section.section.sh_addralign,
978	};
979
980	const compressed_payload = try ElfFileHelper.tryCompressSection(allocator, in_file, section.section.sh_offset, section.section.sh_size, std.mem.asBytes(&chdr));
981	if (compressed_payload) \|payload\| {
982	update.payload = payload;
983	update.section = section.section;
984	update.section.?.sh_addralign = @alignOf(Elf_Chdr);
985	update.section.?.sh_size = @intCast(payload.len);
986	update.section.?.sh_flags \|= elf.SHF_COMPRESSED;
987	}
988	}
989	}
990
991	var cmdbuf = std.ArrayList(ElfFileHelper.WriteCmd).init(allocator);
992	defer cmdbuf.deinit();
993	try cmdbuf.ensureUnusedCapacity(3 + new_shnum);
994	var eof_offset: Elf_OffSize = 0; // track the end of the data written so far.
995
996	// build the updated headers
997	// nb: updated_elf_header will be updated before the actual write
998	var updated_elf_header = self.raw_elf_header;
999	if (updated_elf_header.e_shstrndx != elf.SHN_UNDEF)
1000	updated_elf_header.e_shstrndx = sections_update[updated_elf_header.e_shstrndx].remap_idx;
1001	cmdbuf.appendAssumeCapacity(.{ .write_data = .{ .data = std.mem.asBytes(&updated_elf_header), .out_offset = 0 } });
1002	eof_offset = @sizeOf(Elf_Ehdr);
1003
1004	// program header as-is.
1005	// nb: for only-debug files, removing it appears to work, but is invalid by ELF specifcation.
1006	{
1007	assert(updated_elf_header.e_phoff == @sizeOf(Elf_Ehdr));
1008	const data = std.mem.sliceAsBytes(self.program_segments);
1009	assert(data.len == @as(usize, updated_elf_header.e_phentsize) * updated_elf_header.e_phnum);
1010	cmdbuf.appendAssumeCapacity(.{ .write_data = .{ .data = data, .out_offset = updated_elf_header.e_phoff } });
1011	eof_offset = updated_elf_header.e_phoff + @as(Elf_OffSize, @intCast(data.len));
1012	}
1013
1014	// update sections and queue payload writes
1015	const updated_section_header = blk: {
1016	const dest_sections = try allocator.alloc(Elf_Shdr, new_shnum);
1017
1018	{
1019	// the ELF format doesn't specify the order for all sections.
1020	// this code only supports when they are in increasing file order.
1021	var offset: u64 = eof_offset;
1022	for (self.sections[1..]) \|section\| {
1023	if (section.section.sh_type == elf.SHT_NOBITS)
1024	continue;
1025	if (section.section.sh_offset < offset) {
1026	fatal("zig objcopy: unsuported ELF file", .{});
1027	}
1028	offset = section.section.sh_offset;
1029	}
1030	}
1031
1032	dest_sections[0] = self.sections[0].section;
1033
1034	var dest_section_idx: u32 = 1;
1035	for (self.sections[1..], sections_update[1..]) \|section, update\| {
1036	if (update.action == .strip) continue;
1037	assert(update.remap_idx == dest_section_idx);
1038
1039	const src = if (update.section) \|*s\| s else &section.section;
1040	const dest = &dest_sections[dest_section_idx];
1041	const payload = if (update.payload) \|data\| data else section.payload;
1042	dest_section_idx += 1;
1043
1044	dest.* = src.*;
1045
1046	if (src.sh_link != elf.SHN_UNDEF)
1047	dest.sh_link = sections_update[src.sh_link].remap_idx;
1048	if ((src.sh_flags & elf.SHF_INFO_LINK) != 0 and src.sh_info != elf.SHN_UNDEF)
1049	dest.sh_info = sections_update[src.sh_info].remap_idx;
1050
1051	if (payload) \|data\|
1052	dest.sh_size = @intCast(data.len);
1053
1054	const addralign = if (src.sh_addralign == 0 or dest.sh_type == elf.SHT_NOBITS) 1 else src.sh_addralign;
1055	dest.sh_offset = std.mem.alignForward(Elf_OffSize, eof_offset, addralign);
1056	if (src.sh_offset != dest.sh_offset and section.segment != null and update.action != .empty and dest.sh_type != elf.SHT_NOTE and dest.sh_type != elf.SHT_NOBITS) {
1057	if (src.sh_offset > dest.sh_offset) {
1058	dest.sh_offset = src.sh_offset; // add padding to avoid modifing the program segments
1059	} else {
1060	fatal("zig objcopy: cannot adjust program segments", .{});
1061	}
1062	}
1063	assert(dest.sh_addr % addralign == dest.sh_offset % addralign);
1064
1065	if (update.action == .empty)
1066	dest.sh_type = elf.SHT_NOBITS;
1067
1068	if (dest.sh_type != elf.SHT_NOBITS) {
1069	if (payload) \|src_data\| {
1070	// update sections payload and write
1071	const dest_data = switch (src.sh_type) {
1072	elf.DT_VERSYM => dst_data: {
1073	const data = try allocator.alignedAlloc(u8, section_memory_align, src_data.len);
1074	@memcpy(data, src_data);
1075
1076	const defs = @as([*]Elf_Verdef, @ptrCast(data))[0 .. @as(usize, @intCast(src.sh_size)) / @sizeOf(Elf_Verdef)];
1077	for (defs) \|*def\| {
1078	if (def.vd_ndx != elf.SHN_UNDEF)
1079	def.vd_ndx = sections_update[src.sh_info].remap_idx;
1080	}
1081
1082	break :dst_data data;
1083	},
1084	elf.SHT_SYMTAB, elf.SHT_DYNSYM => dst_data: {
1085	const data = try allocator.alignedAlloc(u8, section_memory_align, src_data.len);
1086	@memcpy(data, src_data);
1087
1088	const syms = @as([*]Elf_Sym, @ptrCast(data))[0 .. @as(usize, @intCast(src.sh_size)) / @sizeOf(Elf_Sym)];
1089	for (syms) \|*sym\| {
1090	if (sym.st_shndx != elf.SHN_UNDEF and sym.st_shndx < elf.SHN_LORESERVE)
1091	sym.st_shndx = sections_update[sym.st_shndx].remap_idx;
1092	}
1093
1094	break :dst_data data;
1095	},
1096	else => src_data,
1097	};
1098
1099	assert(dest_data.len == dest.sh_size);
1100	cmdbuf.appendAssumeCapacity(.{ .write_data = .{ .data = dest_data, .out_offset = dest.sh_offset } });
1101	eof_offset = dest.sh_offset + dest.sh_size;
1102	} else {
1103	// direct contents copy
1104	cmdbuf.appendAssumeCapacity(.{ .copy_range = .{ .in_offset = src.sh_offset, .len = dest.sh_size, .out_offset = dest.sh_offset } });
1105	eof_offset = dest.sh_offset + dest.sh_size;
1106	}
1107	} else {
1108	// account for alignment padding even in empty sections to keep logical section order
1109	eof_offset = dest.sh_offset;
1110	}
1111	}
1112
1113	// add a ".gnu_debuglink" section
1114	if (options.debuglink) \|link\| {
1115	const payload = payload: {
1116	const crc_offset = std.mem.alignForward(usize, link.name.len + 1, 4);
1117	const buf = try allocator.alignedAlloc(u8, 4, crc_offset + 4);
1118	@memcpy(buf[0..link.name.len], link.name);
1119	@memset(buf[link.name.len..crc_offset], 0);
1120	@memcpy(buf[crc_offset..], std.mem.asBytes(&link.crc32));
1121	break :payload buf;
1122	};
1123
1124	dest_sections[dest_section_idx] = Elf_Shdr{
1125	.sh_name = debuglink_name,
1126	.sh_type = elf.SHT_PROGBITS,
1127	.sh_flags = 0,
1128	.sh_addr = 0,
1129	.sh_offset = eof_offset,
1130	.sh_size = @intCast(payload.len),
1131	.sh_link = elf.SHN_UNDEF,
1132	.sh_info = elf.SHN_UNDEF,
1133	.sh_addralign = 4,
1134	.sh_entsize = 0,
1135	};
1136	dest_section_idx += 1;
1137
1138	cmdbuf.appendAssumeCapacity(.{ .write_data = .{ .data = payload, .out_offset = eof_offset } });
1139	eof_offset += @as(Elf_OffSize, @intCast(payload.len));
1140	}
1141
1142	assert(dest_section_idx == new_shnum);
1143	break :blk dest_sections;
1144	};
1145
1146	// write the section header at the tail
1147	{
1148	const offset = std.mem.alignForward(Elf_OffSize, eof_offset, @alignOf(Elf_Shdr));
1149
1150	const data = std.mem.sliceAsBytes(updated_section_header);
1151	assert(data.len == @as(usize, updated_elf_header.e_shentsize) * new_shnum);
1152	updated_elf_header.e_shoff = offset;
1153	updated_elf_header.e_shnum = new_shnum;
1154
1155	cmdbuf.appendAssumeCapacity(.{ .write_data = .{ .data = data, .out_offset = updated_elf_header.e_shoff } });
1156	}
1157
1158	try ElfFileHelper.write(allocator, out_file, in_file, cmdbuf.items);
1159	}
1160
1161	fn sectionWithinSegment(section: Elf_Shdr, segment: Elf_Phdr) bool {
1162	const file_size = if (section.sh_type == elf.SHT_NOBITS) 0 else section.sh_size;
1163	return segment.p_offset <= section.sh_offset and (segment.p_offset + segment.p_filesz) >= (section.sh_offset + file_size);
1164	}
1165	};
1166	}
1167
1168	const ElfFileHelper = struct {
1169	const DebugLink = struct { name: []const u8, crc32: u32 };
1170	const Filter = enum { all, program, debug, program_and_symbols, debug_and_symbols };
1171
1172	const SectionCategory = enum { common, exe, debug, symbols, none };
1173	fn propagateCategory(cur: *SectionCategory, new: SectionCategory) u1 {
1174	const cat: SectionCategory = switch (cur.*) {
1175	.none => new,
1176	.common => .common,
1177	.debug => switch (new) {
1178	.none, .debug => .debug,
1179	else => new,
1180	},
1181	.exe => switch (new) {
1182	.common => .common,
1183	.none, .debug, .exe => .exe,
1184	.symbols => .exe,
1185	},
1186	.symbols => switch (new) {
1187	.none, .common, .debug, .exe => unreachable,
1188	.symbols => .symbols,
1189	},
1190	};
1191
1192	if (cur.* != cat) {
1193	cur.* = cat;
1194	return 1;
1195	} else {
1196	return 0;
1197	}
1198	}
1199
1200	const Action = enum { keep, strip, empty };
1201	fn selectAction(category: SectionCategory, filter: Filter) Action {
1202	if (category == .none) return .strip;
1203	return switch (filter) {
1204	.all => switch (category) {
1205	.none => .strip,
1206	else => .keep,
1207	},
1208	.program => switch (category) {
1209	.common, .exe => .keep,
1210	else => .strip,
1211	},
1212	.program_and_symbols => switch (category) {
1213	.common, .exe, .symbols => .keep,
1214	else => .strip,
1215	},
1216	.debug => switch (category) {
1217	.exe, .symbols => .empty,
1218	.none => .strip,
1219	else => .keep,
1220	},
1221	.debug_and_symbols => switch (category) {
1222	.exe => .empty,
1223	.none => .strip,
1224	else => .keep,
1225	},
1226	};
1227	}
1228
1229	const WriteCmd = union(enum) {
1230	copy_range: struct { in_offset: u64, len: u64, out_offset: u64 },
1231	write_data: struct { data: []const u8, out_offset: u64 },
1232	};
1233	fn write(allocator: Allocator, out_file: File, in_file: File, cmds: []const WriteCmd) !void {
1234	// consolidate holes between writes:
1235	// by coping original padding data from in_file (by fusing contiguous ranges)
1236	// by writing zeroes otherwise
1237	const zeroes = [1]u8{0} ** 4096;
1238	var consolidated = std.ArrayList(WriteCmd).init(allocator);
1239	defer consolidated.deinit();
1240	try consolidated.ensureUnusedCapacity(cmds.len * 2);
1241	var offset: u64 = 0;
1242	var fused_cmd: ?WriteCmd = null;
1243	for (cmds) \|cmd\| {
1244	switch (cmd) {
1245	.write_data => \|data\| {
1246	assert(data.out_offset >= offset);
1247	if (fused_cmd) \|prev\| {
1248	consolidated.appendAssumeCapacity(prev);
1249	fused_cmd = null;
1250	}
1251	if (data.out_offset > offset) {
1252	consolidated.appendAssumeCapacity(.{ .write_data = .{ .data = zeroes[0..@intCast(data.out_offset - offset)], .out_offset = offset } });
1253	}
1254	consolidated.appendAssumeCapacity(cmd);
1255	offset = data.out_offset + data.data.len;
1256	},
1257	.copy_range => \|range\| {
1258	assert(range.out_offset >= offset);
1259	if (fused_cmd) \|prev\| {
1260	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)) {
1261	fused_cmd = .{ .copy_range = .{
1262	.in_offset = prev.copy_range.in_offset,
1263	.out_offset = prev.copy_range.out_offset,
1264	.len = (range.out_offset + range.len) - prev.copy_range.out_offset,
1265	} };
1266	} else {
1267	consolidated.appendAssumeCapacity(prev);
1268	if (range.out_offset > offset) {
1269	consolidated.appendAssumeCapacity(.{ .write_data = .{ .data = zeroes[0..@intCast(range.out_offset - offset)], .out_offset = offset } });
1270	}
1271	fused_cmd = cmd;
1272	}
1273	} else {
1274	fused_cmd = cmd;
1275	}
1276	offset = range.out_offset + range.len;
1277	},
1278	}
1279	}
1280	if (fused_cmd) \|cmd\| {
1281	consolidated.appendAssumeCapacity(cmd);
1282	}
1283
1284	// write the output file
1285	for (consolidated.items) \|cmd\| {
1286	switch (cmd) {
1287	.write_data => \|data\| {
1288	var iovec = [_]std.os.iovec_const{.{ .iov_base = data.data.ptr, .iov_len = data.data.len }};
1289	try out_file.pwritevAll(&iovec, data.out_offset);
1290	},
1291	.copy_range => \|range\| {
1292	const copied_bytes = try in_file.copyRangeAll(range.in_offset, out_file, range.out_offset, range.len);
1293	if (copied_bytes < range.len) return error.TRUNCATED_ELF;
1294	},
1295	}
1296	}
1297	}
1298
1299	fn tryCompressSection(allocator: Allocator, in_file: File, offset: u64, size: u64, prefix: []const u8) !?[]align(8) const u8 {
1300	if (size < prefix.len) return null;
1301
1302	try in_file.seekTo(offset);
1303	var section_reader = std.io.limitedReader(in_file.reader(), size);
1304
1305	// allocate as large as decompressed data. if the compression doesn't fit, keep the data uncompressed.
1306	const compressed_data = try allocator.alignedAlloc(u8, 8, @intCast(size));
1307	var compressed_stream = std.io.fixedBufferStream(compressed_data);
1308
1309	try compressed_stream.writer().writeAll(prefix);
1310
1311	{
1312	var compressor = try std.compress.zlib.compressor(compressed_stream.writer(), .{});
1313
1314	var buf: [8000]u8 = undefined;
1315	while (true) {
1316	const bytes_read = try section_reader.read(&buf);
1317	if (bytes_read == 0) break;
1318	const bytes_written = compressor.write(buf[0..bytes_read]) catch \|err\| switch (err) {
1319	error.NoSpaceLeft => {
1320	allocator.free(compressed_data);
1321	return null;
1322	},
1323	else => return err,
1324	};
1325	std.debug.assert(bytes_written == bytes_read);
1326	}
1327	compressor.finish() catch \|err\| switch (err) {
1328	error.NoSpaceLeft => {
1329	allocator.free(compressed_data);
1330	return null;
1331	},
1332	else => return err,
1333	};
1334	}
1335
1336	const compressed_len: usize = @intCast(compressed_stream.getPos() catch unreachable);
1337	const data = allocator.realloc(compressed_data, compressed_len) catch compressed_data;
1338	return data[0..compressed_len];
1339	}
1340
1341	fn createDebugLink(path: []const u8) DebugLink {
1342	const file = std.fs.cwd().openFile(path, .{}) catch \|err\| {
1343	fatal("zig objcopy: could not open `{s}`: {s}\n", .{ path, @errorName(err) });
1344	};
1345	defer file.close();
1346
1347	const crc = ElfFileHelper.computeFileCrc(file) catch \|err\| {
1348	fatal("zig objcopy: could not read `{s}`: {s}\n", .{ path, @errorName(err) });
1349	};
1350	return .{
1351	.name = std.fs.path.basename(path),
1352	.crc32 = crc,
1353	};
1354	}
1355
1356	fn computeFileCrc(file: File) !u32 {
1357	var buf: [8000]u8 = undefined;
1358
1359	try file.seekTo(0);
1360	var hasher = std.hash.Crc32.init();
1361	while (true) {
1362	const bytes_read = try file.read(&buf);
1363	if (bytes_read == 0) break;
1364	hasher.update(buf[0..bytes_read]);
1365	}
1366	return hasher.final();
1367	}
1368	};

src/main.zig+4-1

 @@ -297,7 +297,10 @@ fn mainArgs(gpa: Allocator, arena: Allocator, args: []const []const u8) !void {
             .root_src_path = "fmt.zig",
         });
     } else if (mem.eql(u8, cmd, "objcopy")) {
-        return @import("objcopy.zig").cmdObjCopy(gpa, arena, cmd_args);
+        return jitCmd(gpa, arena, cmd_args, .{
+            .cmd_name = "objcopy",
+            .root_src_path = "objcopy.zig",
+        });
     } else if (mem.eql(u8, cmd, "fetch")) {
         return cmdFetch(gpa, arena, cmd_args);
     } else if (mem.eql(u8, cmd, "libc")) {

src/objcopy.zig deleted-1357

...	@@ -1,1357 +0,0 @@
1	const std = @import("std");
2	const mem = std.mem;
3	const fs = std.fs;
4	const elf = std.elf;
5	const Allocator = std.mem.Allocator;
6	const File = std.fs.File;
7	const assert = std.debug.assert;
8
9	const main = @import("main.zig");
10	const fatal = main.fatal;
11	const Server = std.zig.Server;
12	const build_options = @import("build_options");
13
14	pub fn cmdObjCopy(
15	gpa: Allocator,
16	arena: Allocator,
17	args: []const []const u8,
18	) !void {
19	var i: usize = 0;
20	var opt_out_fmt: ?std.Target.ObjectFormat = null;
21	var opt_input: ?[]const u8 = null;
22	var opt_output: ?[]const u8 = null;
23	var opt_extract: ?[]const u8 = null;
24	var opt_add_debuglink: ?[]const u8 = null;
25	var only_section: ?[]const u8 = null;
26	var pad_to: ?u64 = null;
27	var strip_all: bool = false;
28	var strip_debug: bool = false;
29	var only_keep_debug: bool = false;
30	var compress_debug_sections: bool = false;
31	var listen = false;
32	while (i < args.len) : (i += 1) {
33	const arg = args[i];
34	if (!mem.startsWith(u8, arg, "-")) {
35	if (opt_input == null) {
36	opt_input = arg;
37	} else if (opt_output == null) {
38	opt_output = arg;
39	} else {
40	fatal("unexpected positional argument: '{s}'", .{arg});
41	}
42	} else if (mem.eql(u8, arg, "-h") or mem.eql(u8, arg, "--help")) {
43	return std.io.getStdOut().writeAll(usage);
44	} else if (mem.eql(u8, arg, "-O") or mem.eql(u8, arg, "--output-target")) {
45	i += 1;
46	if (i >= args.len) fatal("expected another argument after '{s}'", .{arg});
47	const next_arg = args[i];
48	if (mem.eql(u8, next_arg, "binary")) {
49	opt_out_fmt = .raw;
50	} else {
51	opt_out_fmt = std.meta.stringToEnum(std.Target.ObjectFormat, next_arg) orelse
52	fatal("invalid output format: '{s}'", .{next_arg});
53	}
54	} else if (mem.startsWith(u8, arg, "--output-target=")) {
55	const next_arg = arg["--output-target=".len..];
56	if (mem.eql(u8, next_arg, "binary")) {
57	opt_out_fmt = .raw;
58	} else {
59	opt_out_fmt = std.meta.stringToEnum(std.Target.ObjectFormat, next_arg) orelse
60	fatal("invalid output format: '{s}'", .{next_arg});
61	}
62	} else if (mem.eql(u8, arg, "-j") or mem.eql(u8, arg, "--only-section")) {
63	i += 1;
64	if (i >= args.len) fatal("expected another argument after '{s}'", .{arg});
65	only_section = args[i];
66	} else if (mem.eql(u8, arg, "--listen=-")) {
67	listen = true;
68	} else if (mem.startsWith(u8, arg, "--only-section=")) {
69	only_section = arg["--only-section=".len..];
70	} else if (mem.eql(u8, arg, "--pad-to")) {
71	i += 1;
72	if (i >= args.len) fatal("expected another argument after '{s}'", .{arg});
73	pad_to = std.fmt.parseInt(u64, args[i], 0) catch \|err\| {
74	fatal("unable to parse: '{s}': {s}", .{ args[i], @errorName(err) });
75	};
76	} else if (mem.eql(u8, arg, "-g") or mem.eql(u8, arg, "--strip-debug")) {
77	strip_debug = true;
78	} else if (mem.eql(u8, arg, "-S") or mem.eql(u8, arg, "--strip-all")) {
79	strip_all = true;
80	} else if (mem.eql(u8, arg, "--only-keep-debug")) {
81	only_keep_debug = true;
82	} else if (mem.eql(u8, arg, "--compress-debug-sections")) {
83	compress_debug_sections = true;
84	} else if (mem.startsWith(u8, arg, "--add-gnu-debuglink=")) {
85	opt_add_debuglink = arg["--add-gnu-debuglink=".len..];
86	} else if (mem.eql(u8, arg, "--add-gnu-debuglink")) {
87	i += 1;
88	if (i >= args.len) fatal("expected another argument after '{s}'", .{arg});
89	opt_add_debuglink = args[i];
90	} else if (mem.startsWith(u8, arg, "--extract-to=")) {
91	opt_extract = arg["--extract-to=".len..];
92	} else if (mem.eql(u8, arg, "--extract-to")) {
93	i += 1;
94	if (i >= args.len) fatal("expected another argument after '{s}'", .{arg});
95	opt_extract = args[i];
96	} else {
97	fatal("unrecognized argument: '{s}'", .{arg});
98	}
99	}
100	const input = opt_input orelse fatal("expected input parameter", .{});
101	const output = opt_output orelse fatal("expected output parameter", .{});
102
103	var in_file = fs.cwd().openFile(input, .{}) catch \|err\|
104	fatal("unable to open '{s}': {s}", .{ input, @errorName(err) });
105	defer in_file.close();
106
107	const elf_hdr = std.elf.Header.read(in_file) catch \|err\| switch (err) {
108	error.InvalidElfMagic => fatal("not an ELF file: '{s}'", .{input}),
109	else => fatal("unable to read '{s}': {s}", .{ input, @errorName(err) }),
110	};
111
112	const in_ofmt = .elf;
113
114	const out_fmt: std.Target.ObjectFormat = opt_out_fmt orelse ofmt: {
115	if (mem.endsWith(u8, output, ".hex") or std.mem.endsWith(u8, output, ".ihex")) {
116	break :ofmt .hex;
117	} else if (mem.endsWith(u8, output, ".bin")) {
118	break :ofmt .raw;
119	} else if (mem.endsWith(u8, output, ".elf")) {
120	break :ofmt .elf;
121	} else {
122	break :ofmt in_ofmt;
123	}
124	};
125
126	const mode = mode: {
127	if (out_fmt != .elf or only_keep_debug)
128	break :mode fs.File.default_mode;
129	if (in_file.stat()) \|stat\|
130	break :mode stat.mode
131	else \|_\|
132	break :mode fs.File.default_mode;
133	};
134	var out_file = try fs.cwd().createFile(output, .{ .mode = mode });
135	defer out_file.close();
136
137	switch (out_fmt) {
138	.hex, .raw => {
139	if (strip_debug or strip_all or only_keep_debug)
140	fatal("zig objcopy: ELF to RAW or HEX copying does not support --strip", .{});
141	if (opt_extract != null)
142	fatal("zig objcopy: ELF to RAW or HEX copying does not support --extract-to", .{});
143
144	try emitElf(arena, in_file, out_file, elf_hdr, .{
145	.ofmt = out_fmt,
146	.only_section = only_section,
147	.pad_to = pad_to,
148	});
149	},
150	.elf => {
151	if (elf_hdr.endian != @import("builtin").target.cpu.arch.endian())
152	fatal("zig objcopy: ELF to ELF copying only supports native endian", .{});
153	if (elf_hdr.phoff == 0) // no program header
154	fatal("zig objcopy: ELF to ELF copying only supports programs", .{});
155	if (only_section) \|_\|
156	fatal("zig objcopy: ELF to ELF copying does not support --only-section", .{});
157	if (pad_to) \|_\|
158	fatal("zig objcopy: ELF to ELF copying does not support --pad-to", .{});
159
160	try stripElf(arena, in_file, out_file, elf_hdr, .{
161	.strip_debug = strip_debug,
162	.strip_all = strip_all,
163	.only_keep_debug = only_keep_debug,
164	.add_debuglink = opt_add_debuglink,
165	.extract_to = opt_extract,
166	.compress_debug = compress_debug_sections,
167	});
168	return std.process.cleanExit();
169	},
170	else => fatal("unsupported output object format: {s}", .{@tagName(out_fmt)}),
171	}
172
173	if (listen) {
174	var server = try Server.init(.{
175	.gpa = gpa,
176	.in = std.io.getStdIn(),
177	.out = std.io.getStdOut(),
178	.zig_version = build_options.version,
179	});
180	defer server.deinit();
181
182	var seen_update = false;
183	while (true) {
184	const hdr = try server.receiveMessage();
185	switch (hdr.tag) {
186	.exit => {
187	return std.process.cleanExit();
188	},
189	.update => {
190	if (seen_update) {
191	std.debug.print("zig objcopy only supports 1 update for now\n", .{});
192	std.process.exit(1);
193	}
194	seen_update = true;
195
196	try server.serveEmitBinPath(output, .{
197	.flags = .{ .cache_hit = false },
198	});
199	},
200	else => {
201	std.debug.print("unsupported message: {s}", .{@tagName(hdr.tag)});
202	std.process.exit(1);
203	},
204	}
205	}
206	}
207	return std.process.cleanExit();
208	}
209
210	const usage =
211	\\Usage: zig objcopy [options] input output
212	\\
213	\\Options:
214	\\ -h, --help Print this help and exit
215	\\ --output-target=<value> Format of the output file
216	\\ -O <value> Alias for --output-target
217	\\ --only-section=<section> Remove all but <section>
218	\\ -j <value> Alias for --only-section
219	\\ --pad-to <addr> Pad the last section up to address <addr>
220	\\ --strip-debug, -g Remove all debug sections from the output.
221	\\ --strip-all, -S Remove all debug sections and symbol table from the output.
222	\\ --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.
223	\\ --add-gnu-debuglink=<file> Creates a .gnu_debuglink section which contains a reference to <file> and adds it to the output file.
224	\\ --extract-to <file> Extract the removed sections into <file>, and add a .gnu-debuglink section.
225	\\ --compress-debug-sections Compress DWARF debug sections with zlib
226	\\
227	;
228
229	pub const EmitRawElfOptions = struct {
230	ofmt: std.Target.ObjectFormat,
231	only_section: ?[]const u8 = null,
232	pad_to: ?u64 = null,
233	};
234
235	fn emitElf(
236	arena: Allocator,
237	in_file: File,
238	out_file: File,
239	elf_hdr: elf.Header,
240	options: EmitRawElfOptions,
241	) !void {
242	var binary_elf_output = try BinaryElfOutput.parse(arena, in_file, elf_hdr);
243	defer binary_elf_output.deinit();
244
245	if (options.ofmt == .elf) {
246	fatal("zig objcopy: ELF to ELF copying is not implemented yet", .{});
247	}
248
249	if (options.only_section) \|target_name\| {
250	switch (options.ofmt) {
251	.hex => fatal("zig objcopy: hex format with sections is not implemented yet", .{}),
252	.raw => {
253	for (binary_elf_output.sections.items) \|section\| {
254	if (section.name) \|curr_name\| {
255	if (!std.mem.eql(u8, curr_name, target_name))
256	continue;
257	} else {
258	continue;
259	}
260
261	try writeBinaryElfSection(in_file, out_file, section);
262	try padFile(out_file, options.pad_to);
263	return;
264	}
265	},
266	else => unreachable,
267	}
268
269	return error.SectionNotFound;
270	}
271
272	switch (options.ofmt) {
273	.raw => {
274	for (binary_elf_output.sections.items) \|section\| {
275	try out_file.seekTo(section.binaryOffset);
276	try writeBinaryElfSection(in_file, out_file, section);
277	}
278	try padFile(out_file, options.pad_to);
279	},
280	.hex => {
281	if (binary_elf_output.segments.items.len == 0) return;
282	if (!containsValidAddressRange(binary_elf_output.segments.items)) {
283	return error.InvalidHexfileAddressRange;
284	}
285
286	var hex_writer = HexWriter{ .out_file = out_file };
287	for (binary_elf_output.segments.items) \|segment\| {
288	try hex_writer.writeSegment(segment, in_file);
289	}
290	if (options.pad_to) \|_\| {
291	// Padding to a size in hex files isn't applicable
292	return error.InvalidArgument;
293	}
294	try hex_writer.writeEOF();
295	},
296	else => unreachable,
297	}
298	}
299
300	const BinaryElfSection = struct {
301	elfOffset: u64,
302	binaryOffset: u64,
303	fileSize: usize,
304	name: ?[]const u8,
305	segment: ?*BinaryElfSegment,
306	};
307
308	const BinaryElfSegment = struct {
309	physicalAddress: u64,
310	virtualAddress: u64,
311	elfOffset: u64,
312	binaryOffset: u64,
313	fileSize: u64,
314	firstSection: ?*BinaryElfSection,
315	};
316
317	const BinaryElfOutput = struct {
318	segments: std.ArrayListUnmanaged(*BinaryElfSegment),
319	sections: std.ArrayListUnmanaged(*BinaryElfSection),
320	allocator: Allocator,
321	shstrtab: ?[]const u8,
322
323	const Self = @This();
324
325	pub fn deinit(self: *Self) void {
326	if (self.shstrtab) \|shstrtab\|
327	self.allocator.free(shstrtab);
328	self.sections.deinit(self.allocator);
329	self.segments.deinit(self.allocator);
330	}
331
332	pub fn parse(allocator: Allocator, elf_file: File, elf_hdr: elf.Header) !Self {
333	var self: Self = .{
334	.segments = .{},
335	.sections = .{},
336	.allocator = allocator,
337	.shstrtab = null,
338	};
339	errdefer self.sections.deinit(allocator);
340	errdefer self.segments.deinit(allocator);
341
342	self.shstrtab = blk: {
343	if (elf_hdr.shstrndx >= elf_hdr.shnum) break :blk null;
344
345	var section_headers = elf_hdr.section_header_iterator(&elf_file);
346
347	var section_counter: usize = 0;
348	while (section_counter < elf_hdr.shstrndx) : (section_counter += 1) {
349	_ = (try section_headers.next()).?;
350	}
351
352	const shstrtab_shdr = (try section_headers.next()).?;
353
354	const buffer = try allocator.alloc(u8, @intCast(shstrtab_shdr.sh_size));
355	errdefer allocator.free(buffer);
356
357	const num_read = try elf_file.preadAll(buffer, shstrtab_shdr.sh_offset);
358	if (num_read != buffer.len) return error.EndOfStream;
359
360	break :blk buffer;
361	};
362
363	errdefer if (self.shstrtab) \|shstrtab\| allocator.free(shstrtab);
364
365	var section_headers = elf_hdr.section_header_iterator(&elf_file);
366	while (try section_headers.next()) \|section\| {
367	if (sectionValidForOutput(section)) {
368	const newSection = try allocator.create(BinaryElfSection);
369
370	newSection.binaryOffset = 0;
371	newSection.elfOffset = section.sh_offset;
372	newSection.fileSize = @intCast(section.sh_size);
373	newSection.segment = null;
374
375	newSection.name = if (self.shstrtab) \|shstrtab\|
376	std.mem.span(@as([*:0]const u8, @ptrCast(&shstrtab[section.sh_name])))
377	else
378	null;
379
380	try self.sections.append(allocator, newSection);
381	}
382	}
383
384	var program_headers = elf_hdr.program_header_iterator(&elf_file);
385	while (try program_headers.next()) \|phdr\| {
386	if (phdr.p_type == elf.PT_LOAD) {
387	const newSegment = try allocator.create(BinaryElfSegment);
388
389	newSegment.physicalAddress = if (phdr.p_paddr != 0) phdr.p_paddr else phdr.p_vaddr;
390	newSegment.virtualAddress = phdr.p_vaddr;
391	newSegment.fileSize = @intCast(phdr.p_filesz);
392	newSegment.elfOffset = phdr.p_offset;
393	newSegment.binaryOffset = 0;
394	newSegment.firstSection = null;
395
396	for (self.sections.items) \|section\| {
397	if (sectionWithinSegment(section, phdr)) {
398	if (section.segment) \|sectionSegment\| {
399	if (sectionSegment.elfOffset > newSegment.elfOffset) {
400	section.segment = newSegment;
401	}
402	} else {
403	section.segment = newSegment;
404	}
405
406	if (newSegment.firstSection == null) {
407	newSegment.firstSection = section;
408	}
409	}
410	}
411
412	try self.segments.append(allocator, newSegment);
413	}
414	}
415
416	mem.sort(*BinaryElfSegment, self.segments.items, {}, segmentSortCompare);
417
418	for (self.segments.items, 0..) \|firstSegment, i\| {
419	if (firstSegment.firstSection) \|firstSection\| {
420	const diff = firstSection.elfOffset - firstSegment.elfOffset;
421
422	firstSegment.elfOffset += diff;
423	firstSegment.fileSize += diff;
424	firstSegment.physicalAddress += diff;
425
426	const basePhysicalAddress = firstSegment.physicalAddress;
427
428	for (self.segments.items[i + 1 ..]) \|segment\| {
429	segment.binaryOffset = segment.physicalAddress - basePhysicalAddress;
430	}
431	break;
432	}
433	}
434
435	for (self.sections.items) \|section\| {
436	if (section.segment) \|segment\| {
437	section.binaryOffset = segment.binaryOffset + (section.elfOffset - segment.elfOffset);
438	}
439	}
440
441	mem.sort(*BinaryElfSection, self.sections.items, {}, sectionSortCompare);
442
443	return self;
444	}
445
446	fn sectionWithinSegment(section: *BinaryElfSection, segment: elf.Elf64_Phdr) bool {
447	return segment.p_offset <= section.elfOffset and (segment.p_offset + segment.p_filesz) >= (section.elfOffset + section.fileSize);
448	}
449
450	fn sectionValidForOutput(shdr: anytype) bool {
451	return shdr.sh_type != elf.SHT_NOBITS and
452	((shdr.sh_flags & elf.SHF_ALLOC) == elf.SHF_ALLOC);
453	}
454
455	fn segmentSortCompare(context: void, left: BinaryElfSegment, right: BinaryElfSegment) bool {
456	_ = context;
457	if (left.physicalAddress < right.physicalAddress) {
458	return true;
459	}
460	if (left.physicalAddress > right.physicalAddress) {
461	return false;
462	}
463	return false;
464	}
465
466	fn sectionSortCompare(context: void, left: BinaryElfSection, right: BinaryElfSection) bool {
467	_ = context;
468	return left.binaryOffset < right.binaryOffset;
469	}
470	};
471
472	fn writeBinaryElfSection(elf_file: File, out_file: File, section: *BinaryElfSection) !void {
473	try out_file.writeFileAll(elf_file, .{
474	.in_offset = section.elfOffset,
475	.in_len = section.fileSize,
476	});
477	}
478
479	const HexWriter = struct {
480	prev_addr: ?u32 = null,
481	out_file: File,
482
483	/// Max data bytes per line of output
484	const MAX_PAYLOAD_LEN: u8 = 16;
485
486	fn addressParts(address: u16) [2]u8 {
487	const msb: u8 = @truncate(address >> 8);
488	const lsb: u8 = @truncate(address);
489	return [2]u8{ msb, lsb };
490	}
491
492	const Record = struct {
493	const Type = enum(u8) {
494	Data = 0,
495	EOF = 1,
496	ExtendedSegmentAddress = 2,
497	ExtendedLinearAddress = 4,
498	};
499
500	address: u16,
501	payload: union(Type) {
502	Data: []const u8,
503	EOF: void,
504	ExtendedSegmentAddress: [2]u8,
505	ExtendedLinearAddress: [2]u8,
506	},
507
508	fn EOF() Record {
509	return Record{
510	.address = 0,
511	.payload = .EOF,
512	};
513	}
514
515	fn Data(address: u32, data: []const u8) Record {
516	return Record{
517	.address = @intCast(address % 0x10000),
518	.payload = .{ .Data = data },
519	};
520	}
521
522	fn Address(address: u32) Record {
523	assert(address > 0xFFFF);
524	const segment: u16 = @intCast(address / 0x10000);
525	if (address > 0xFFFFF) {
526	return Record{
527	.address = 0,
528	.payload = .{ .ExtendedLinearAddress = addressParts(segment) },
529	};
530	} else {
531	return Record{
532	.address = 0,
533	.payload = .{ .ExtendedSegmentAddress = addressParts(segment << 12) },
534	};
535	}
536	}
537
538	fn getPayloadBytes(self: *const Record) []const u8 {
539	return switch (self.payload) {
540	.Data => \|d\| d,
541	.EOF => @as([]const u8, &.{}),
542	.ExtendedSegmentAddress, .ExtendedLinearAddress => \|*seg\| seg,
543	};
544	}
545
546	fn checksum(self: Record) u8 {
547	const payload_bytes = self.getPayloadBytes();
548
549	var sum: u8 = @intCast(payload_bytes.len);
550	const parts = addressParts(self.address);
551	sum +%= parts[0];
552	sum +%= parts[1];
553	sum +%= @intFromEnum(self.payload);
554	for (payload_bytes) \|byte\| {
555	sum +%= byte;
556	}
557	return (sum ^ 0xFF) +% 1;
558	}
559
560	fn write(self: Record, file: File) File.WriteError!void {
561	const linesep = "\r\n";
562	// colon, (length, address, type, payload, checksum) as hex, CRLF
563	const BUFSIZE = 1 + (1 + 2 + 1 + MAX_PAYLOAD_LEN + 1) * 2 + linesep.len;
564	var outbuf: [BUFSIZE]u8 = undefined;
565	const payload_bytes = self.getPayloadBytes();
566	assert(payload_bytes.len <= MAX_PAYLOAD_LEN);
567
568	const line = try std.fmt.bufPrint(&outbuf, ":{0X:0>2}{1X:0>4}{2X:0>2}{3s}{4X:0>2}" ++ linesep, .{
569	@as(u8, @intCast(payload_bytes.len)),
570	self.address,
571	@intFromEnum(self.payload),
572	std.fmt.fmtSliceHexUpper(payload_bytes),
573	self.checksum(),
574	});
575	try file.writeAll(line);
576	}
577	};
578
579	pub fn writeSegment(self: HexWriter, segment: const BinaryElfSegment, elf_file: File) !void {
580	var buf: [MAX_PAYLOAD_LEN]u8 = undefined;
581	var bytes_read: usize = 0;
582	while (bytes_read < segment.fileSize) {
583	const row_address: u32 = @intCast(segment.physicalAddress + bytes_read);
584
585	const remaining = segment.fileSize - bytes_read;
586	const to_read: usize = @intCast(@min(remaining, MAX_PAYLOAD_LEN));
587	const did_read = try elf_file.preadAll(buf[0..to_read], segment.elfOffset + bytes_read);
588	if (did_read < to_read) return error.UnexpectedEOF;
589
590	try self.writeDataRow(row_address, buf[0..did_read]);
591
592	bytes_read += did_read;
593	}
594	}
595
596	fn writeDataRow(self: *HexWriter, address: u32, data: []const u8) File.WriteError!void {
597	const record = Record.Data(address, data);
598	if (address > 0xFFFF and (self.prev_addr == null or record.address != self.prev_addr.?)) {
599	try Record.Address(address).write(self.out_file);
600	}
601	try record.write(self.out_file);
602	self.prev_addr = @intCast(record.address + data.len);
603	}
604
605	fn writeEOF(self: HexWriter) File.WriteError!void {
606	try Record.EOF().write(self.out_file);
607	}
608	};
609
610	fn containsValidAddressRange(segments: []*BinaryElfSegment) bool {
611	const max_address = std.math.maxInt(u32);
612	for (segments) \|segment\| {
613	if (segment.fileSize > max_address or
614	segment.physicalAddress > max_address - segment.fileSize) return false;
615	}
616	return true;
617	}
618
619	fn padFile(f: File, opt_size: ?u64) !void {
620	const size = opt_size orelse return;
621	try f.setEndPos(size);
622	}
623
624	test "HexWriter.Record.Address has correct payload and checksum" {
625	const record = HexWriter.Record.Address(0x0800_0000);
626	const payload = record.getPayloadBytes();
627	const sum = record.checksum();
628	try std.testing.expect(sum == 0xF2);
629	try std.testing.expect(payload.len == 2);
630	try std.testing.expect(payload[0] == 8);
631	try std.testing.expect(payload[1] == 0);
632	}
633
634	test "containsValidAddressRange" {
635	var segment = BinaryElfSegment{
636	.physicalAddress = 0,
637	.virtualAddress = 0,
638	.elfOffset = 0,
639	.binaryOffset = 0,
640	.fileSize = 0,
641	.firstSection = null,
642	};
643	var buf: [1]*BinaryElfSegment = .{&segment};
644
645	// segment too big
646	segment.fileSize = std.math.maxInt(u32) + 1;
647	try std.testing.expect(!containsValidAddressRange(&buf));
648
649	// start address too big
650	segment.physicalAddress = std.math.maxInt(u32) + 1;
651	segment.fileSize = 2;
652	try std.testing.expect(!containsValidAddressRange(&buf));
653
654	// max address too big
655	segment.physicalAddress = std.math.maxInt(u32) - 1;
656	segment.fileSize = 2;
657	try std.testing.expect(!containsValidAddressRange(&buf));
658
659	// is ok
660	segment.physicalAddress = std.math.maxInt(u32) - 1;
661	segment.fileSize = 1;
662	try std.testing.expect(containsValidAddressRange(&buf));
663	}
664
665	// -------------
666	// ELF to ELF stripping
667
668	const StripElfOptions = struct {
669	extract_to: ?[]const u8 = null,
670	add_debuglink: ?[]const u8 = null,
671	strip_all: bool = false,
672	strip_debug: bool = false,
673	only_keep_debug: bool = false,
674	compress_debug: bool = false,
675	};
676
677	fn stripElf(
678	allocator: Allocator,
679	in_file: File,
680	out_file: File,
681	elf_hdr: elf.Header,
682	options: StripElfOptions,
683	) !void {
684	const Filter = ElfFileHelper.Filter;
685	const DebugLink = ElfFileHelper.DebugLink;
686
687	const filter: Filter = filter: {
688	if (options.only_keep_debug) break :filter .debug;
689	if (options.strip_all) break :filter .program;
690	if (options.strip_debug) break :filter .program_and_symbols;
691	break :filter .all;
692	};
693
694	const filter_complement: ?Filter = blk: {
695	if (options.extract_to) \|_\| {
696	break :blk switch (filter) {
697	.program => .debug_and_symbols,
698	.debug => .program_and_symbols,
699	.program_and_symbols => .debug,
700	.debug_and_symbols => .program,
701	.all => fatal("zig objcopy: nothing to extract", .{}),
702	};
703	} else {
704	break :blk null;
705	}
706	};
707	const debuglink_path = path: {
708	if (options.add_debuglink) \|path\| break :path path;
709	if (options.extract_to) \|path\| break :path path;
710	break :path null;
711	};
712
713	switch (elf_hdr.is_64) {
714	inline else => \|is_64\| {
715	var elf_file = try ElfFile(is_64).parse(allocator, in_file, elf_hdr);
716	defer elf_file.deinit();
717
718	if (filter_complement) \|flt\| {
719	// write the .dbg file and close it, so it can be read back to compute the debuglink checksum.
720	const path = options.extract_to.?;
721	const dbg_file = std.fs.cwd().createFile(path, .{}) catch \|err\| {
722	fatal("zig objcopy: unable to create '{s}': {s}", .{ path, @errorName(err) });
723	};
724	defer dbg_file.close();
725
726	try elf_file.emit(allocator, dbg_file, in_file, .{ .section_filter = flt, .compress_debug = options.compress_debug });
727	}
728
729	const debuglink: ?DebugLink = if (debuglink_path) \|path\| ElfFileHelper.createDebugLink(path) else null;
730	try elf_file.emit(allocator, out_file, in_file, .{ .section_filter = filter, .debuglink = debuglink, .compress_debug = options.compress_debug });
731	},
732	}
733	}
734
735	// note: this is "a minimal effort implementation"
736	// It doesn't support all possibile elf files: some sections type may need fixups, the program header may need fix up, ...
737	// 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++` )
738	// It moves and reoders the sections as little as possible to avoid having to do fixups.
739	// TODO: support non-native endianess
740
741	fn ElfFile(comptime is_64: bool) type {
742	const Elf_Ehdr = if (is_64) elf.Elf64_Ehdr else elf.Elf32_Ehdr;
743	const Elf_Phdr = if (is_64) elf.Elf64_Phdr else elf.Elf32_Phdr;
744	const Elf_Shdr = if (is_64) elf.Elf64_Shdr else elf.Elf32_Shdr;
745	const Elf_Chdr = if (is_64) elf.Elf64_Chdr else elf.Elf32_Chdr;
746	const Elf_Sym = if (is_64) elf.Elf64_Sym else elf.Elf32_Sym;
747	const Elf_Verdef = if (is_64) elf.Elf64_Verdef else elf.Elf32_Verdef;
748	const Elf_OffSize = if (is_64) elf.Elf64_Off else elf.Elf32_Off;
749
750	return struct {
751	raw_elf_header: Elf_Ehdr,
752	program_segments: []const Elf_Phdr,
753	sections: []const Section,
754	arena: std.heap.ArenaAllocator,
755
756	const SectionCategory = ElfFileHelper.SectionCategory;
757	const section_memory_align = @alignOf(Elf_Sym); // most restrictive of what we may load in memory
758	const Section = struct {
759	section: Elf_Shdr,
760	name: []const u8 = "",
761	segment: ?*const Elf_Phdr = null, // if the section is used by a program segment (there can be more than one)
762	payload: ?[]align(section_memory_align) const u8 = null, // if we need the data in memory
763	category: SectionCategory = .none, // should the section be kept in the exe or stripped to the debug database, or both.
764	};
765
766	const Self = @This();
767
768	pub fn parse(gpa: Allocator, in_file: File, header: elf.Header) !Self {
769	var arena = std.heap.ArenaAllocator.init(gpa);
770	errdefer arena.deinit();
771	const allocator = arena.allocator();
772
773	var raw_header: Elf_Ehdr = undefined;
774	{
775	const bytes_read = try in_file.preadAll(std.mem.asBytes(&raw_header), 0);
776	if (bytes_read < @sizeOf(Elf_Ehdr))
777	return error.TRUNCATED_ELF;
778	}
779
780	// program header: list of segments
781	const program_segments = blk: {
782	if (@sizeOf(Elf_Phdr) != header.phentsize)
783	fatal("zig objcopy: unsuported ELF file, unexpected phentsize ({d})", .{header.phentsize});
784
785	const program_header = try allocator.alloc(Elf_Phdr, header.phnum);
786	const bytes_read = try in_file.preadAll(std.mem.sliceAsBytes(program_header), header.phoff);
787	if (bytes_read < @sizeOf(Elf_Phdr) * header.phnum)
788	return error.TRUNCATED_ELF;
789	break :blk program_header;
790	};
791
792	// section header
793	const sections = blk: {
794	if (@sizeOf(Elf_Shdr) != header.shentsize)
795	fatal("zig objcopy: unsuported ELF file, unexpected shentsize ({d})", .{header.shentsize});
796
797	const section_header = try allocator.alloc(Section, header.shnum);
798
799	const raw_section_header = try allocator.alloc(Elf_Shdr, header.shnum);
800	defer allocator.free(raw_section_header);
801	const bytes_read = try in_file.preadAll(std.mem.sliceAsBytes(raw_section_header), header.shoff);
802	if (bytes_read < @sizeOf(Elf_Phdr) * header.shnum)
803	return error.TRUNCATED_ELF;
804
805	for (section_header, raw_section_header) \|*section, hdr\| {
806	section.* = .{ .section = hdr };
807	}
808	break :blk section_header;
809	};
810
811	// load data to memory for some sections:
812	// string tables for access
813	// sections than need modifications when other sections move.
814	for (sections, 0..) \|*section, idx\| {
815	const need_data = switch (section.section.sh_type) {
816	elf.DT_VERSYM => true,
817	elf.SHT_SYMTAB, elf.SHT_DYNSYM => true,
818	else => false,
819	};
820	const need_strings = (idx == header.shstrndx);
821
822	if (need_data or need_strings) {
823	const buffer = try allocator.alignedAlloc(u8, section_memory_align, @intCast(section.section.sh_size));
824	const bytes_read = try in_file.preadAll(buffer, section.section.sh_offset);
825	if (bytes_read != section.section.sh_size) return error.TRUNCATED_ELF;
826	section.payload = buffer;
827	}
828	}
829
830	// fill-in sections info:
831	// resolve the name
832	// find if a program segment uses the section
833	// categorize sections usage (used by program segments, debug datadase, common metadata, symbol table)
834	for (sections) \|*section\| {
835	section.segment = for (program_segments) \|*seg\| {
836	if (sectionWithinSegment(section.section, seg.*)) break seg;
837	} else null;
838
839	if (section.section.sh_name != 0 and header.shstrndx != elf.SHN_UNDEF)
840	section.name = std.mem.span(@as([*:0]const u8, @ptrCast(&sections[header.shstrndx].payload.?[section.section.sh_name])));
841
842	const category_from_program: SectionCategory = if (section.segment != null) .exe else .debug;
843	section.category = switch (section.section.sh_type) {
844	elf.SHT_NOTE => .common,
845	elf.SHT_SYMTAB => .symbols, // "strip all" vs "strip only debug"
846	elf.SHT_DYNSYM => .exe,
847	elf.SHT_PROGBITS => cat: {
848	if (std.mem.eql(u8, section.name, ".comment")) break :cat .exe;
849	if (std.mem.eql(u8, section.name, ".gnu_debuglink")) break :cat .none;
850	break :cat category_from_program;
851	},
852	elf.SHT_LOPROC...elf.SHT_HIPROC => .common, // don't strip unknown sections
853	elf.SHT_LOUSER...elf.SHT_HIUSER => .common, // don't strip unknown sections
854	else => category_from_program,
855	};
856	}
857
858	sections[0].category = .common; // mandatory null section
859	if (header.shstrndx != elf.SHN_UNDEF)
860	sections[header.shstrndx].category = .common; // string table for the headers
861
862	// recursively propagate section categories to their linked sections, so that they are kept together
863	var dirty: u1 = 1;
864	while (dirty != 0) {
865	dirty = 0;
866
867	for (sections) \|*section\| {
868	if (section.section.sh_link != elf.SHN_UNDEF)
869	dirty \|= ElfFileHelper.propagateCategory(&sections[section.section.sh_link].category, section.category);
870	if ((section.section.sh_flags & elf.SHF_INFO_LINK) != 0 and section.section.sh_info != elf.SHN_UNDEF)
871	dirty \|= ElfFileHelper.propagateCategory(&sections[section.section.sh_info].category, section.category);
872	}
873	}
874
875	return Self{
876	.arena = arena,
877	.raw_elf_header = raw_header,
878	.program_segments = program_segments,
879	.sections = sections,
880	};
881	}
882
883	pub fn deinit(self: *Self) void {
884	self.arena.deinit();
885	}
886
887	const Filter = ElfFileHelper.Filter;
888	const DebugLink = ElfFileHelper.DebugLink;
889	const EmitElfOptions = struct {
890	section_filter: Filter = .all,
891	debuglink: ?DebugLink = null,
892	compress_debug: bool = false,
893	};
894	fn emit(self: *const Self, gpa: Allocator, out_file: File, in_file: File, options: EmitElfOptions) !void {
895	var arena = std.heap.ArenaAllocator.init(gpa);
896	defer arena.deinit();
897	const allocator = arena.allocator();
898
899	// when emitting the stripped exe:
900	// - unused sections are removed
901	// when emitting the debug file:
902	// - all sections are kept, but some are emptied and their types is changed to SHT_NOBITS
903	// the program header is kept unchanged. (`strip` does update it, but `eu-strip` does not, and it still works)
904
905	const Update = struct {
906	action: ElfFileHelper.Action,
907
908	// remap the indexs after omitting the filtered sections
909	remap_idx: u16,
910
911	// optionally overrides the payload from the source file
912	payload: ?[]align(section_memory_align) const u8 = null,
913	section: ?Elf_Shdr = null,
914	};
915	const sections_update = try allocator.alloc(Update, self.sections.len);
916	const new_shnum = blk: {
917	var next_idx: u16 = 0;
918	for (self.sections, sections_update) \|section, *update\| {
919	const action = ElfFileHelper.selectAction(section.category, options.section_filter);
920	const remap_idx = idx: {
921	if (action == .strip) break :idx elf.SHN_UNDEF;
922	next_idx += 1;
923	break :idx next_idx - 1;
924	};
925	update.* = Update{ .action = action, .remap_idx = remap_idx };
926	}
927
928	if (options.debuglink != null)
929	next_idx += 1;
930
931	break :blk next_idx;
932	};
933
934	// add a ".gnu_debuglink" to the string table if needed
935	const debuglink_name: u32 = blk: {
936	if (options.debuglink == null) break :blk elf.SHN_UNDEF;
937	if (self.raw_elf_header.e_shstrndx == elf.SHN_UNDEF)
938	fatal("zig objcopy: no strtab, cannot add the debuglink section", .{}); // TODO add the section if needed?
939
940	const strtab = &self.sections[self.raw_elf_header.e_shstrndx];
941	const update = &sections_update[self.raw_elf_header.e_shstrndx];
942
943	const name: []const u8 = ".gnu_debuglink";
944	const new_offset: u32 = @intCast(strtab.payload.?.len);
945	const buf = try allocator.alignedAlloc(u8, section_memory_align, new_offset + name.len + 1);
946	@memcpy(buf[0..new_offset], strtab.payload.?);
947	@memcpy(buf[new_offset..][0..name.len], name);
948	buf[new_offset + name.len] = 0;
949
950	assert(update.action == .keep);
951	update.payload = buf;
952
953	break :blk new_offset;
954	};
955
956	// maybe compress .debug sections
957	if (options.compress_debug) {
958	for (self.sections[1..], sections_update[1..]) \|section, *update\| {
959	if (update.action != .keep) continue;
960	if (!std.mem.startsWith(u8, section.name, ".debug_")) continue;
961	if ((section.section.sh_flags & elf.SHF_COMPRESSED) != 0) continue; // already compressed
962
963	const chdr = Elf_Chdr{
964	.ch_type = elf.COMPRESS.ZLIB,
965	.ch_size = section.section.sh_size,
966	.ch_addralign = section.section.sh_addralign,
967	};
968
969	const compressed_payload = try ElfFileHelper.tryCompressSection(allocator, in_file, section.section.sh_offset, section.section.sh_size, std.mem.asBytes(&chdr));
970	if (compressed_payload) \|payload\| {
971	update.payload = payload;
972	update.section = section.section;
973	update.section.?.sh_addralign = @alignOf(Elf_Chdr);
974	update.section.?.sh_size = @intCast(payload.len);
975	update.section.?.sh_flags \|= elf.SHF_COMPRESSED;
976	}
977	}
978	}
979
980	var cmdbuf = std.ArrayList(ElfFileHelper.WriteCmd).init(allocator);
981	defer cmdbuf.deinit();
982	try cmdbuf.ensureUnusedCapacity(3 + new_shnum);
983	var eof_offset: Elf_OffSize = 0; // track the end of the data written so far.
984
985	// build the updated headers
986	// nb: updated_elf_header will be updated before the actual write
987	var updated_elf_header = self.raw_elf_header;
988	if (updated_elf_header.e_shstrndx != elf.SHN_UNDEF)
989	updated_elf_header.e_shstrndx = sections_update[updated_elf_header.e_shstrndx].remap_idx;
990	cmdbuf.appendAssumeCapacity(.{ .write_data = .{ .data = std.mem.asBytes(&updated_elf_header), .out_offset = 0 } });
991	eof_offset = @sizeOf(Elf_Ehdr);
992
993	// program header as-is.
994	// nb: for only-debug files, removing it appears to work, but is invalid by ELF specifcation.
995	{
996	assert(updated_elf_header.e_phoff == @sizeOf(Elf_Ehdr));
997	const data = std.mem.sliceAsBytes(self.program_segments);
998	assert(data.len == @as(usize, updated_elf_header.e_phentsize) * updated_elf_header.e_phnum);
999	cmdbuf.appendAssumeCapacity(.{ .write_data = .{ .data = data, .out_offset = updated_elf_header.e_phoff } });
1000	eof_offset = updated_elf_header.e_phoff + @as(Elf_OffSize, @intCast(data.len));
1001	}
1002
1003	// update sections and queue payload writes
1004	const updated_section_header = blk: {
1005	const dest_sections = try allocator.alloc(Elf_Shdr, new_shnum);
1006
1007	{
1008	// the ELF format doesn't specify the order for all sections.
1009	// this code only supports when they are in increasing file order.
1010	var offset: u64 = eof_offset;
1011	for (self.sections[1..]) \|section\| {
1012	if (section.section.sh_type == elf.SHT_NOBITS)
1013	continue;
1014	if (section.section.sh_offset < offset) {
1015	fatal("zig objcopy: unsuported ELF file", .{});
1016	}
1017	offset = section.section.sh_offset;
1018	}
1019	}
1020
1021	dest_sections[0] = self.sections[0].section;
1022
1023	var dest_section_idx: u32 = 1;
1024	for (self.sections[1..], sections_update[1..]) \|section, update\| {
1025	if (update.action == .strip) continue;
1026	assert(update.remap_idx == dest_section_idx);
1027
1028	const src = if (update.section) \|*s\| s else &section.section;
1029	const dest = &dest_sections[dest_section_idx];
1030	const payload = if (update.payload) \|data\| data else section.payload;
1031	dest_section_idx += 1;
1032
1033	dest.* = src.*;
1034
1035	if (src.sh_link != elf.SHN_UNDEF)
1036	dest.sh_link = sections_update[src.sh_link].remap_idx;
1037	if ((src.sh_flags & elf.SHF_INFO_LINK) != 0 and src.sh_info != elf.SHN_UNDEF)
1038	dest.sh_info = sections_update[src.sh_info].remap_idx;
1039
1040	if (payload) \|data\|
1041	dest.sh_size = @intCast(data.len);
1042
1043	const addralign = if (src.sh_addralign == 0 or dest.sh_type == elf.SHT_NOBITS) 1 else src.sh_addralign;
1044	dest.sh_offset = std.mem.alignForward(Elf_OffSize, eof_offset, addralign);
1045	if (src.sh_offset != dest.sh_offset and section.segment != null and update.action != .empty and dest.sh_type != elf.SHT_NOTE and dest.sh_type != elf.SHT_NOBITS) {
1046	if (src.sh_offset > dest.sh_offset) {
1047	dest.sh_offset = src.sh_offset; // add padding to avoid modifing the program segments
1048	} else {
1049	fatal("zig objcopy: cannot adjust program segments", .{});
1050	}
1051	}
1052	assert(dest.sh_addr % addralign == dest.sh_offset % addralign);
1053
1054	if (update.action == .empty)
1055	dest.sh_type = elf.SHT_NOBITS;
1056
1057	if (dest.sh_type != elf.SHT_NOBITS) {
1058	if (payload) \|src_data\| {
1059	// update sections payload and write
1060	const dest_data = switch (src.sh_type) {
1061	elf.DT_VERSYM => dst_data: {
1062	const data = try allocator.alignedAlloc(u8, section_memory_align, src_data.len);
1063	@memcpy(data, src_data);
1064
1065	const defs = @as([*]Elf_Verdef, @ptrCast(data))[0 .. @as(usize, @intCast(src.sh_size)) / @sizeOf(Elf_Verdef)];
1066	for (defs) \|*def\| {
1067	if (def.vd_ndx != elf.SHN_UNDEF)
1068	def.vd_ndx = sections_update[src.sh_info].remap_idx;
1069	}
1070
1071	break :dst_data data;
1072	},
1073	elf.SHT_SYMTAB, elf.SHT_DYNSYM => dst_data: {
1074	const data = try allocator.alignedAlloc(u8, section_memory_align, src_data.len);
1075	@memcpy(data, src_data);
1076
1077	const syms = @as([*]Elf_Sym, @ptrCast(data))[0 .. @as(usize, @intCast(src.sh_size)) / @sizeOf(Elf_Sym)];
1078	for (syms) \|*sym\| {
1079	if (sym.st_shndx != elf.SHN_UNDEF and sym.st_shndx < elf.SHN_LORESERVE)
1080	sym.st_shndx = sections_update[sym.st_shndx].remap_idx;
1081	}
1082
1083	break :dst_data data;
1084	},
1085	else => src_data,
1086	};
1087
1088	assert(dest_data.len == dest.sh_size);
1089	cmdbuf.appendAssumeCapacity(.{ .write_data = .{ .data = dest_data, .out_offset = dest.sh_offset } });
1090	eof_offset = dest.sh_offset + dest.sh_size;
1091	} else {
1092	// direct contents copy
1093	cmdbuf.appendAssumeCapacity(.{ .copy_range = .{ .in_offset = src.sh_offset, .len = dest.sh_size, .out_offset = dest.sh_offset } });
1094	eof_offset = dest.sh_offset + dest.sh_size;
1095	}
1096	} else {
1097	// account for alignment padding even in empty sections to keep logical section order
1098	eof_offset = dest.sh_offset;
1099	}
1100	}
1101
1102	// add a ".gnu_debuglink" section
1103	if (options.debuglink) \|link\| {
1104	const payload = payload: {
1105	const crc_offset = std.mem.alignForward(usize, link.name.len + 1, 4);
1106	const buf = try allocator.alignedAlloc(u8, 4, crc_offset + 4);
1107	@memcpy(buf[0..link.name.len], link.name);
1108	@memset(buf[link.name.len..crc_offset], 0);
1109	@memcpy(buf[crc_offset..], std.mem.asBytes(&link.crc32));
1110	break :payload buf;
1111	};
1112
1113	dest_sections[dest_section_idx] = Elf_Shdr{
1114	.sh_name = debuglink_name,
1115	.sh_type = elf.SHT_PROGBITS,
1116	.sh_flags = 0,
1117	.sh_addr = 0,
1118	.sh_offset = eof_offset,
1119	.sh_size = @intCast(payload.len),
1120	.sh_link = elf.SHN_UNDEF,
1121	.sh_info = elf.SHN_UNDEF,
1122	.sh_addralign = 4,
1123	.sh_entsize = 0,
1124	};
1125	dest_section_idx += 1;
1126
1127	cmdbuf.appendAssumeCapacity(.{ .write_data = .{ .data = payload, .out_offset = eof_offset } });
1128	eof_offset += @as(Elf_OffSize, @intCast(payload.len));
1129	}
1130
1131	assert(dest_section_idx == new_shnum);
1132	break :blk dest_sections;
1133	};
1134
1135	// write the section header at the tail
1136	{
1137	const offset = std.mem.alignForward(Elf_OffSize, eof_offset, @alignOf(Elf_Shdr));
1138
1139	const data = std.mem.sliceAsBytes(updated_section_header);
1140	assert(data.len == @as(usize, updated_elf_header.e_shentsize) * new_shnum);
1141	updated_elf_header.e_shoff = offset;
1142	updated_elf_header.e_shnum = new_shnum;
1143
1144	cmdbuf.appendAssumeCapacity(.{ .write_data = .{ .data = data, .out_offset = updated_elf_header.e_shoff } });
1145	}
1146
1147	try ElfFileHelper.write(allocator, out_file, in_file, cmdbuf.items);
1148	}
1149
1150	fn sectionWithinSegment(section: Elf_Shdr, segment: Elf_Phdr) bool {
1151	const file_size = if (section.sh_type == elf.SHT_NOBITS) 0 else section.sh_size;
1152	return segment.p_offset <= section.sh_offset and (segment.p_offset + segment.p_filesz) >= (section.sh_offset + file_size);
1153	}
1154	};
1155	}
1156
1157	const ElfFileHelper = struct {
1158	const DebugLink = struct { name: []const u8, crc32: u32 };
1159	const Filter = enum { all, program, debug, program_and_symbols, debug_and_symbols };
1160
1161	const SectionCategory = enum { common, exe, debug, symbols, none };
1162	fn propagateCategory(cur: *SectionCategory, new: SectionCategory) u1 {
1163	const cat: SectionCategory = switch (cur.*) {
1164	.none => new,
1165	.common => .common,
1166	.debug => switch (new) {
1167	.none, .debug => .debug,
1168	else => new,
1169	},
1170	.exe => switch (new) {
1171	.common => .common,
1172	.none, .debug, .exe => .exe,
1173	.symbols => .exe,
1174	},
1175	.symbols => switch (new) {
1176	.none, .common, .debug, .exe => unreachable,
1177	.symbols => .symbols,
1178	},
1179	};
1180
1181	if (cur.* != cat) {
1182	cur.* = cat;
1183	return 1;
1184	} else {
1185	return 0;
1186	}
1187	}
1188
1189	const Action = enum { keep, strip, empty };
1190	fn selectAction(category: SectionCategory, filter: Filter) Action {
1191	if (category == .none) return .strip;
1192	return switch (filter) {
1193	.all => switch (category) {
1194	.none => .strip,
1195	else => .keep,
1196	},
1197	.program => switch (category) {
1198	.common, .exe => .keep,
1199	else => .strip,
1200	},
1201	.program_and_symbols => switch (category) {
1202	.common, .exe, .symbols => .keep,
1203	else => .strip,
1204	},
1205	.debug => switch (category) {
1206	.exe, .symbols => .empty,
1207	.none => .strip,
1208	else => .keep,
1209	},
1210	.debug_and_symbols => switch (category) {
1211	.exe => .empty,
1212	.none => .strip,
1213	else => .keep,
1214	},
1215	};
1216	}
1217
1218	const WriteCmd = union(enum) {
1219	copy_range: struct { in_offset: u64, len: u64, out_offset: u64 },
1220	write_data: struct { data: []const u8, out_offset: u64 },
1221	};
1222	fn write(allocator: Allocator, out_file: File, in_file: File, cmds: []const WriteCmd) !void {
1223	// consolidate holes between writes:
1224	// by coping original padding data from in_file (by fusing contiguous ranges)
1225	// by writing zeroes otherwise
1226	const zeroes = [1]u8{0} ** 4096;
1227	var consolidated = std.ArrayList(WriteCmd).init(allocator);
1228	defer consolidated.deinit();
1229	try consolidated.ensureUnusedCapacity(cmds.len * 2);
1230	var offset: u64 = 0;
1231	var fused_cmd: ?WriteCmd = null;
1232	for (cmds) \|cmd\| {
1233	switch (cmd) {
1234	.write_data => \|data\| {
1235	assert(data.out_offset >= offset);
1236	if (fused_cmd) \|prev\| {
1237	consolidated.appendAssumeCapacity(prev);
1238	fused_cmd = null;
1239	}
1240	if (data.out_offset > offset) {
1241	consolidated.appendAssumeCapacity(.{ .write_data = .{ .data = zeroes[0..@intCast(data.out_offset - offset)], .out_offset = offset } });
1242	}
1243	consolidated.appendAssumeCapacity(cmd);
1244	offset = data.out_offset + data.data.len;
1245	},
1246	.copy_range => \|range\| {
1247	assert(range.out_offset >= offset);
1248	if (fused_cmd) \|prev\| {
1249	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)) {
1250	fused_cmd = .{ .copy_range = .{
1251	.in_offset = prev.copy_range.in_offset,
1252	.out_offset = prev.copy_range.out_offset,
1253	.len = (range.out_offset + range.len) - prev.copy_range.out_offset,
1254	} };
1255	} else {
1256	consolidated.appendAssumeCapacity(prev);
1257	if (range.out_offset > offset) {
1258	consolidated.appendAssumeCapacity(.{ .write_data = .{ .data = zeroes[0..@intCast(range.out_offset - offset)], .out_offset = offset } });
1259	}
1260	fused_cmd = cmd;
1261	}
1262	} else {
1263	fused_cmd = cmd;
1264	}
1265	offset = range.out_offset + range.len;
1266	},
1267	}
1268	}
1269	if (fused_cmd) \|cmd\| {
1270	consolidated.appendAssumeCapacity(cmd);
1271	}
1272
1273	// write the output file
1274	for (consolidated.items) \|cmd\| {
1275	switch (cmd) {
1276	.write_data => \|data\| {
1277	var iovec = [_]std.os.iovec_const{.{ .iov_base = data.data.ptr, .iov_len = data.data.len }};
1278	try out_file.pwritevAll(&iovec, data.out_offset);
1279	},
1280	.copy_range => \|range\| {
1281	const copied_bytes = try in_file.copyRangeAll(range.in_offset, out_file, range.out_offset, range.len);
1282	if (copied_bytes < range.len) return error.TRUNCATED_ELF;
1283	},
1284	}
1285	}
1286	}
1287
1288	fn tryCompressSection(allocator: Allocator, in_file: File, offset: u64, size: u64, prefix: []const u8) !?[]align(8) const u8 {
1289	if (size < prefix.len) return null;
1290
1291	try in_file.seekTo(offset);
1292	var section_reader = std.io.limitedReader(in_file.reader(), size);
1293
1294	// allocate as large as decompressed data. if the compression doesn't fit, keep the data uncompressed.
1295	const compressed_data = try allocator.alignedAlloc(u8, 8, @intCast(size));
1296	var compressed_stream = std.io.fixedBufferStream(compressed_data);
1297
1298	try compressed_stream.writer().writeAll(prefix);
1299
1300	{
1301	var compressor = try std.compress.zlib.compressor(compressed_stream.writer(), .{});
1302
1303	var buf: [8000]u8 = undefined;
1304	while (true) {
1305	const bytes_read = try section_reader.read(&buf);
1306	if (bytes_read == 0) break;
1307	const bytes_written = compressor.write(buf[0..bytes_read]) catch \|err\| switch (err) {
1308	error.NoSpaceLeft => {
1309	allocator.free(compressed_data);
1310	return null;
1311	},
1312	else => return err,
1313	};
1314	std.debug.assert(bytes_written == bytes_read);
1315	}
1316	compressor.finish() catch \|err\| switch (err) {
1317	error.NoSpaceLeft => {
1318	allocator.free(compressed_data);
1319	return null;
1320	},
1321	else => return err,
1322	};
1323	}
1324
1325	const compressed_len: usize = @intCast(compressed_stream.getPos() catch unreachable);
1326	const data = allocator.realloc(compressed_data, compressed_len) catch compressed_data;
1327	return data[0..compressed_len];
1328	}
1329
1330	fn createDebugLink(path: []const u8) DebugLink {
1331	const file = std.fs.cwd().openFile(path, .{}) catch \|err\| {
1332	fatal("zig objcopy: could not open `{s}`: {s}\n", .{ path, @errorName(err) });
1333	};
1334	defer file.close();
1335
1336	const crc = ElfFileHelper.computeFileCrc(file) catch \|err\| {
1337	fatal("zig objcopy: could not read `{s}`: {s}\n", .{ path, @errorName(err) });
1338	};
1339	return .{
1340	.name = std.fs.path.basename(path),
1341	.crc32 = crc,
1342	};
1343	}
1344
1345	fn computeFileCrc(file: File) !u32 {
1346	var buf: [8000]u8 = undefined;
1347
1348	try file.seekTo(0);
1349	var hasher = std.hash.Crc32.init();
1350	while (true) {
1351	const bytes_read = try file.read(&buf);
1352	if (bytes_read == 0) break;
1353	hasher.update(buf[0..bytes_read]);
1354	}
1355	return hasher.final();
1356	}
1357	};