Commit f34b4780b7bd52d14df253d0762d9c73db8eb226 | zig

author	Andrew Kelley <andrew@ziglang.org> 2025-07-22 18:40:11+02:00
committer	GitHub <noreply@github.com> 2025-07-22 18:40:11+02:00
log	f34b4780b7bd52d14df253d0762d9c73db8eb226
tree	87b5fc511384829f0f504ef8c649cf9ae5bf1556
parent	c41ac8f19ec96ed854d9ac31a2015006ba3e4657
parent	34d2778239b7eea854385354fd956358ae7cf5a0
signature	Signed by PGP key B5690EEEBB952194

Merge pull request #24521 from ziglang/fs-streaming

std.fs.File: delete writeFileAll and friends

19 files changed, 722 insertions(+), 1945 deletions(-)

lib
- compiler
  - build_runner.zig
  - objcopy.zig
- std
  - Build
    Step
    Run.zig
  - c.zig
  - elf.zig
  - fs
    AtomicFile.zig
    Dir.zig
    File.zig
    test.zig
  - json.zig
  - posix.zig
src
- Builtin.zig
- Compilation.zig
- fmt.zig
- link
  - MachO.zig
- main.zig
test
- incremental
  - fix_many_errors
- standalone
  - stack_iterator
    build.zig
tools
- gen_stubs.zig

lib/compiler/build_runner.zig+1-1

...	@@ -708,7 +708,7 @@ fn runStepNames(	...	@@ -708,7 +708,7 @@ fn runStepNames(
708		708
709	const total_count = success_count + failure_count + pending_count + skipped_count;	709	const total_count = success_count + failure_count + pending_count + skipped_count;
710	ttyconf.setColor(w, .cyan) catch {};	710	ttyconf.setColor(w, .cyan) catch {};
711	w.writeAll("Build Summary:") catch {};	711	w.writeAll("\nBuild Summary:") catch {};
712	ttyconf.setColor(w, .reset) catch {};	712	ttyconf.setColor(w, .reset) catch {};
713	w.print(" {d}/{d} steps succeeded", .{ success_count, total_count }) catch {};	713	w.print(" {d}/{d} steps succeeded", .{ success_count, total_count }) catch {};
714	if (skipped_count > 0) w.print("; {d} skipped", .{skipped_count}) catch {};	714	if (skipped_count > 0) w.print("; {d} skipped", .{skipped_count}) catch {};

lib/compiler/objcopy.zig+62-907

...	@@ -13,6 +13,9 @@ const Server = std.zig.Server;	...	@@ -13,6 +13,9 @@ const Server = std.zig.Server;
13	var stdin_buffer: [1024]u8 = undefined;	13	var stdin_buffer: [1024]u8 = undefined;
14	var stdout_buffer: [1024]u8 = undefined;	14	var stdout_buffer: [1024]u8 = undefined;
15		15
		16	var input_buffer: [1024]u8 = undefined;
		17	var output_buffer: [1024]u8 = undefined;
		18
16	pub fn main() !void {	19	pub fn main() !void {
17	var arena_instance = std.heap.ArenaAllocator.init(std.heap.page_allocator);	20	var arena_instance = std.heap.ArenaAllocator.init(std.heap.page_allocator);
18	defer arena_instance.deinit();	21	defer arena_instance.deinit();
...	@@ -145,13 +148,16 @@ fn cmdObjCopy(gpa: Allocator, arena: Allocator, args: []const []const u8) !void	...	@@ -145,13 +148,16 @@ fn cmdObjCopy(gpa: Allocator, arena: Allocator, args: []const []const u8) !void
145	const input = opt_input orelse fatal("expected input parameter", .{});	148	const input = opt_input orelse fatal("expected input parameter", .{});
146	const output = opt_output orelse fatal("expected output parameter", .{});	149	const output = opt_output orelse fatal("expected output parameter", .{});
147		150
148	var in_file = fs.cwd().openFile(input, .{}) catch \|err\|	151	const input_file = fs.cwd().openFile(input, .{}) catch \|err\| fatal("failed to open {s}: {t}", .{ input, err });
149	fatal("unable to open '{s}': {s}", .{ input, @errorName(err) });	152	defer input_file.close();
150	defer in_file.close();	153
		154	const stat = input_file.stat() catch \|err\| fatal("failed to stat {s}: {t}", .{ input, err });
151		155
152	const elf_hdr = std.elf.Header.read(in_file) catch \|err\| switch (err) {	156	var in: File.Reader = .initSize(input_file, &input_buffer, stat.size);
153	error.InvalidElfMagic => fatal("not an ELF file: '{s}'", .{input}),	157
154	else => fatal("unable to read '{s}': {s}", .{ input, @errorName(err) }),	158	const elf_hdr = std.elf.Header.read(&in.interface) catch \|err\| switch (err) {
		159	error.ReadFailed => fatal("unable to read {s}: {t}", .{ input, in.err.? }),
		160	else => \|e\| fatal("invalid elf file: {t}", .{e}),
155	};	161	};
156		162
157	const in_ofmt = .elf;	163	const in_ofmt = .elf;
...	@@ -168,16 +174,12 @@ fn cmdObjCopy(gpa: Allocator, arena: Allocator, args: []const []const u8) !void	...	@@ -168,16 +174,12 @@ fn cmdObjCopy(gpa: Allocator, arena: Allocator, args: []const []const u8) !void
168	}	174	}
169	};	175	};
170		176
171	const mode = mode: {	177	const mode = if (out_fmt != .elf or only_keep_debug) fs.File.default_mode else stat.mode;
172	if (out_fmt != .elf or only_keep_debug)	178
173	break :mode fs.File.default_mode;	179	var output_file = try fs.cwd().createFile(output, .{ .mode = mode });
174	if (in_file.stat()) \|stat\|	180	defer output_file.close();
175	break :mode stat.mode	181
176	else \|_\|	182	var out = output_file.writer(&output_buffer);
177	break :mode fs.File.default_mode;
178	};
179	var out_file = try fs.cwd().createFile(output, .{ .mode = mode });
180	defer out_file.close();
181		183
182	switch (out_fmt) {	184	switch (out_fmt) {
183	.hex, .raw => {	185	.hex, .raw => {
...	@@ -192,7 +194,7 @@ fn cmdObjCopy(gpa: Allocator, arena: Allocator, args: []const []const u8) !void	...	@@ -192,7 +194,7 @@ fn cmdObjCopy(gpa: Allocator, arena: Allocator, args: []const []const u8) !void
192	if (set_section_flags != null)	194	if (set_section_flags != null)
193	fatal("zig objcopy: ELF to RAW or HEX copying does not support --set_section_flags", .{});	195	fatal("zig objcopy: ELF to RAW or HEX copying does not support --set_section_flags", .{});
194		196
195	try emitElf(arena, in_file, out_file, elf_hdr, .{	197	try emitElf(arena, &in, &out, elf_hdr, .{
196	.ofmt = out_fmt,	198	.ofmt = out_fmt,
197	.only_section = only_section,	199	.only_section = only_section,
198	.pad_to = pad_to,	200	.pad_to = pad_to,
...	@@ -208,22 +210,13 @@ fn cmdObjCopy(gpa: Allocator, arena: Allocator, args: []const []const u8) !void	...	@@ -208,22 +210,13 @@ fn cmdObjCopy(gpa: Allocator, arena: Allocator, args: []const []const u8) !void
208	if (pad_to) \|_\|	210	if (pad_to) \|_\|
209	fatal("zig objcopy: ELF to ELF copying does not support --pad-to", .{});	211	fatal("zig objcopy: ELF to ELF copying does not support --pad-to", .{});
210		212
211	try stripElf(arena, in_file, out_file, elf_hdr, .{	213	fatal("unimplemented", .{});
212	.strip_debug = strip_debug,
213	.strip_all = strip_all,
214	.only_keep_debug = only_keep_debug,
215	.add_debuglink = opt_add_debuglink,
216	.extract_to = opt_extract,
217	.compress_debug = compress_debug_sections,
218	.add_section = add_section,
219	.set_section_alignment = set_section_alignment,
220	.set_section_flags = set_section_flags,
221	});
222	return std.process.cleanExit();
223	},	214	},
224	else => fatal("unsupported output object format: {s}", .{@tagName(out_fmt)}),	215	else => fatal("unsupported output object format: {s}", .{@tagName(out_fmt)}),
225	}	216	}
226		217
		218	try out.end();
		219
227	if (listen) {	220	if (listen) {
228	var stdin_reader = fs.File.stdin().reader(&stdin_buffer);	221	var stdin_reader = fs.File.stdin().reader(&stdin_buffer);
229	var stdout_writer = fs.File.stdout().writer(&stdout_buffer);	222	var stdout_writer = fs.File.stdout().writer(&stdout_buffer);
...	@@ -304,12 +297,12 @@ const SetSectionFlags = struct {	...	@@ -304,12 +297,12 @@ const SetSectionFlags = struct {
304		297
305	fn emitElf(	298	fn emitElf(
306	arena: Allocator,	299	arena: Allocator,
307	in_file: File,	300	in: *File.Reader,
308	out_file: File,	301	out: *File.Writer,
309	elf_hdr: elf.Header,	302	elf_hdr: elf.Header,
310	options: EmitRawElfOptions,	303	options: EmitRawElfOptions,
311	) !void {	304	) !void {
312	var binary_elf_output = try BinaryElfOutput.parse(arena, in_file, elf_hdr);	305	var binary_elf_output = try BinaryElfOutput.parse(arena, in, elf_hdr);
313	defer binary_elf_output.deinit();	306	defer binary_elf_output.deinit();
314		307
315	if (options.ofmt == .elf) {	308	if (options.ofmt == .elf) {
...	@@ -328,8 +321,8 @@ fn emitElf(	...	@@ -328,8 +321,8 @@ fn emitElf(
328	continue;	321	continue;
329	}	322	}
330		323
331	try writeBinaryElfSection(in_file, out_file, section);	324	try writeBinaryElfSection(in, out, section);
332	try padFile(out_file, options.pad_to);	325	try padFile(out, options.pad_to);
333	return;	326	return;
334	}	327	}
335	},	328	},
...	@@ -342,10 +335,10 @@ fn emitElf(	...	@@ -342,10 +335,10 @@ fn emitElf(
342	switch (options.ofmt) {	335	switch (options.ofmt) {
343	.raw => {	336	.raw => {
344	for (binary_elf_output.sections.items) \|section\| {	337	for (binary_elf_output.sections.items) \|section\| {
345	try out_file.seekTo(section.binaryOffset);	338	try out.seekTo(section.binaryOffset);
346	try writeBinaryElfSection(in_file, out_file, section);	339	try writeBinaryElfSection(in, out, section);
347	}	340	}
348	try padFile(out_file, options.pad_to);	341	try padFile(out, options.pad_to);
349	},	342	},
350	.hex => {	343	.hex => {
351	if (binary_elf_output.segments.items.len == 0) return;	344	if (binary_elf_output.segments.items.len == 0) return;
...	@@ -353,15 +346,15 @@ fn emitElf(	...	@@ -353,15 +346,15 @@ fn emitElf(
353	return error.InvalidHexfileAddressRange;	346	return error.InvalidHexfileAddressRange;
354	}	347	}
355		348
356	var hex_writer = HexWriter{ .out_file = out_file };	349	var hex_writer = HexWriter{ .out = out };
357	for (binary_elf_output.segments.items) \|segment\| {	350	for (binary_elf_output.segments.items) \|segment\| {
358	try hex_writer.writeSegment(segment, in_file);	351	try hex_writer.writeSegment(segment, in);
359	}	352	}
360	if (options.pad_to) \|_\| {	353	if (options.pad_to) \|_\| {
361	// Padding to a size in hex files isn't applicable	354	// Padding to a size in hex files isn't applicable
362	return error.InvalidArgument;	355	return error.InvalidArgument;
363	}	356	}
364	try hex_writer.writeEOF();	357	try hex_writer.writeEof();
365	},	358	},
366	else => unreachable,	359	else => unreachable,
367	}	360	}
...	@@ -399,7 +392,7 @@ const BinaryElfOutput = struct {	...	@@ -399,7 +392,7 @@ const BinaryElfOutput = struct {
399	self.segments.deinit(self.allocator);	392	self.segments.deinit(self.allocator);
400	}	393	}
401		394
402	pub fn parse(allocator: Allocator, elf_file: File, elf_hdr: elf.Header) !Self {	395	pub fn parse(allocator: Allocator, in: *File.Reader, elf_hdr: elf.Header) !Self {
403	var self: Self = .{	396	var self: Self = .{
404	.segments = .{},	397	.segments = .{},
405	.sections = .{},	398	.sections = .{},
...	@@ -412,7 +405,7 @@ const BinaryElfOutput = struct {	...	@@ -412,7 +405,7 @@ const BinaryElfOutput = struct {
412	self.shstrtab = blk: {	405	self.shstrtab = blk: {
413	if (elf_hdr.shstrndx >= elf_hdr.shnum) break :blk null;	406	if (elf_hdr.shstrndx >= elf_hdr.shnum) break :blk null;
414		407
415	var section_headers = elf_hdr.section_header_iterator(&elf_file);	408	var section_headers = elf_hdr.iterateSectionHeaders(in);
416		409
417	var section_counter: usize = 0;	410	var section_counter: usize = 0;
418	while (section_counter < elf_hdr.shstrndx) : (section_counter += 1) {	411	while (section_counter < elf_hdr.shstrndx) : (section_counter += 1) {
...	@@ -421,18 +414,13 @@ const BinaryElfOutput = struct {	...	@@ -421,18 +414,13 @@ const BinaryElfOutput = struct {
421		414
422	const shstrtab_shdr = (try section_headers.next()).?;	415	const shstrtab_shdr = (try section_headers.next()).?;
423		416
424	const buffer = try allocator.alloc(u8, @intCast(shstrtab_shdr.sh_size));	417	try in.seekTo(shstrtab_shdr.sh_offset);
425	errdefer allocator.free(buffer);	418	break :blk try in.interface.readAlloc(allocator, shstrtab_shdr.sh_size);
426
427	const num_read = try elf_file.preadAll(buffer, shstrtab_shdr.sh_offset);
428	if (num_read != buffer.len) return error.EndOfStream;
429
430	break :blk buffer;
431	};	419	};
432		420
433	errdefer if (self.shstrtab) \|shstrtab\| allocator.free(shstrtab);	421	errdefer if (self.shstrtab) \|shstrtab\| allocator.free(shstrtab);
434		422
435	var section_headers = elf_hdr.section_header_iterator(&elf_file);	423	var section_headers = elf_hdr.iterateSectionHeaders(in);
436	while (try section_headers.next()) \|section\| {	424	while (try section_headers.next()) \|section\| {
437	if (sectionValidForOutput(section)) {	425	if (sectionValidForOutput(section)) {
438	const newSection = try allocator.create(BinaryElfSection);	426	const newSection = try allocator.create(BinaryElfSection);
...	@@ -451,7 +439,7 @@ const BinaryElfOutput = struct {	...	@@ -451,7 +439,7 @@ const BinaryElfOutput = struct {
451	}	439	}
452	}	440	}
453		441
454	var program_headers = elf_hdr.program_header_iterator(&elf_file);	442	var program_headers = elf_hdr.iterateProgramHeaders(in);
455	while (try program_headers.next()) \|phdr\| {	443	while (try program_headers.next()) \|phdr\| {
456	if (phdr.p_type == elf.PT_LOAD) {	444	if (phdr.p_type == elf.PT_LOAD) {
457	const newSegment = try allocator.create(BinaryElfSegment);	445	const newSegment = try allocator.create(BinaryElfSegment);
...	@@ -539,19 +527,17 @@ const BinaryElfOutput = struct {	...	@@ -539,19 +527,17 @@ const BinaryElfOutput = struct {
539	}	527	}
540	};	528	};
541		529
542	fn writeBinaryElfSection(elf_file: File, out_file: File, section: *BinaryElfSection) !void {	530	fn writeBinaryElfSection(in: File.Reader, out: File.Writer, section: *BinaryElfSection) !void {
543	try out_file.writeFileAll(elf_file, .{	531	try in.seekTo(section.elfOffset);
544	.in_offset = section.elfOffset,	532	_ = try out.interface.sendFileAll(in, .limited(section.fileSize));
545	.in_len = section.fileSize,
546	});
547	}	533	}
548		534
549	const HexWriter = struct {	535	const HexWriter = struct {
550	prev_addr: ?u32 = null,	536	prev_addr: ?u32 = null,
551	out_file: File,	537	out: *File.Writer,
552		538
553	/// Max data bytes per line of output	539	/// Max data bytes per line of output
554	const MAX_PAYLOAD_LEN: u8 = 16;	540	const max_payload_len: u8 = 16;
555		541
556	fn addressParts(address: u16) [2]u8 {	542	fn addressParts(address: u16) [2]u8 {
557	const msb: u8 = @truncate(address >> 8);	543	const msb: u8 = @truncate(address >> 8);
...	@@ -627,13 +613,13 @@ const HexWriter = struct {	...	@@ -627,13 +613,13 @@ const HexWriter = struct {
627	return (sum ^ 0xFF) +% 1;	613	return (sum ^ 0xFF) +% 1;
628	}	614	}
629		615
630	fn write(self: Record, file: File) File.WriteError!void {	616	fn write(self: Record, out: *File.Writer) !void {
631	const linesep = "\r\n";	617	const linesep = "\r\n";
632	// colon, (length, address, type, payload, checksum) as hex, CRLF	618	// colon, (length, address, type, payload, checksum) as hex, CRLF
633	const BUFSIZE = 1 + (1 + 2 + 1 + MAX_PAYLOAD_LEN + 1) * 2 + linesep.len;	619	const BUFSIZE = 1 + (1 + 2 + 1 + max_payload_len + 1) * 2 + linesep.len;
634	var outbuf: [BUFSIZE]u8 = undefined;	620	var outbuf: [BUFSIZE]u8 = undefined;
635	const payload_bytes = self.getPayloadBytes();	621	const payload_bytes = self.getPayloadBytes();
636	assert(payload_bytes.len <= MAX_PAYLOAD_LEN);	622	assert(payload_bytes.len <= max_payload_len);
637		623
638	const line = try std.fmt.bufPrint(&outbuf, ":{0X:0>2}{1X:0>4}{2X:0>2}{3X}{4X:0>2}" ++ linesep, .{	624	const line = try std.fmt.bufPrint(&outbuf, ":{0X:0>2}{1X:0>4}{2X:0>2}{3X}{4X:0>2}" ++ linesep, .{
639	@as(u8, @intCast(payload_bytes.len)),	625	@as(u8, @intCast(payload_bytes.len)),
...	@@ -642,38 +628,37 @@ const HexWriter = struct {	...	@@ -642,38 +628,37 @@ const HexWriter = struct {
642	payload_bytes,	628	payload_bytes,
643	self.checksum(),	629	self.checksum(),
644	});	630	});
645	try file.writeAll(line);	631	try out.interface.writeAll(line);
646	}	632	}
647	};	633	};
648		634
649	pub fn writeSegment(self: HexWriter, segment: const BinaryElfSegment, elf_file: File) !void {	635	pub fn writeSegment(self: HexWriter, segment: const BinaryElfSegment, in: *File.Reader) !void {
650	var buf: [MAX_PAYLOAD_LEN]u8 = undefined;	636	var buf: [max_payload_len]u8 = undefined;
651	var bytes_read: usize = 0;	637	var bytes_read: usize = 0;
652	while (bytes_read < segment.fileSize) {	638	while (bytes_read < segment.fileSize) {
653	const row_address: u32 = @intCast(segment.physicalAddress + bytes_read);	639	const row_address: u32 = @intCast(segment.physicalAddress + bytes_read);
654		640
655	const remaining = segment.fileSize - bytes_read;	641	const remaining = segment.fileSize - bytes_read;
656	const to_read: usize = @intCast(@min(remaining, MAX_PAYLOAD_LEN));	642	const dest = buf[0..@min(remaining, max_payload_len)];
657	const did_read = try elf_file.preadAll(buf[0..to_read], segment.elfOffset + bytes_read);	643	try in.seekTo(segment.elfOffset + bytes_read);
658	if (did_read < to_read) return error.UnexpectedEOF;	644	try in.interface.readSliceAll(dest);
		645	try self.writeDataRow(row_address, dest);
659		646
660	try self.writeDataRow(row_address, buf[0..did_read]);	647	bytes_read += dest.len;
661
662	bytes_read += did_read;
663	}	648	}
664	}	649	}
665		650
666	fn writeDataRow(self: *HexWriter, address: u32, data: []const u8) File.WriteError!void {	651	fn writeDataRow(self: *HexWriter, address: u32, data: []const u8) !void {
667	const record = Record.Data(address, data);	652	const record = Record.Data(address, data);
668	if (address > 0xFFFF and (self.prev_addr == null or record.address != self.prev_addr.?)) {	653	if (address > 0xFFFF and (self.prev_addr == null or record.address != self.prev_addr.?)) {
669	try Record.Address(address).write(self.out_file);	654	try Record.Address(address).write(self.out);
670	}	655	}
671	try record.write(self.out_file);	656	try record.write(self.out);
672	self.prev_addr = @intCast(record.address + data.len);	657	self.prev_addr = @intCast(record.address + data.len);
673	}	658	}
674		659
675	fn writeEOF(self: HexWriter) File.WriteError!void {	660	fn writeEof(self: HexWriter) !void {
676	try Record.EOF().write(self.out_file);	661	try Record.EOF().write(self.out);
677	}	662	}
678	};	663	};
679		664
...	@@ -686,9 +671,9 @@ fn containsValidAddressRange(segments: []*BinaryElfSegment) bool {	...	@@ -686,9 +671,9 @@ fn containsValidAddressRange(segments: []*BinaryElfSegment) bool {
686	return true;	671	return true;
687	}	672	}
688		673
689	fn padFile(f: File, opt_size: ?u64) !void {	674	fn padFile(out: *File.Writer, opt_size: ?u64) !void {
690	const size = opt_size orelse return;	675	const size = opt_size orelse return;
691	try f.setEndPos(size);	676	try out.file.setEndPos(size);
692	}	677	}
693		678
694	test "HexWriter.Record.Address has correct payload and checksum" {	679	test "HexWriter.Record.Address has correct payload and checksum" {
...	@@ -732,836 +717,6 @@ test "containsValidAddressRange" {	...	@@ -732,836 +717,6 @@ test "containsValidAddressRange" {
732	try std.testing.expect(containsValidAddressRange(&buf));	717	try std.testing.expect(containsValidAddressRange(&buf));
733	}	718	}
734		719
735	// -------------
736	// ELF to ELF stripping
737
738	const StripElfOptions = struct {
739	extract_to: ?[]const u8 = null,
740	add_debuglink: ?[]const u8 = null,
741	strip_all: bool = false,
742	strip_debug: bool = false,
743	only_keep_debug: bool = false,
744	compress_debug: bool = false,
745	add_section: ?AddSection,
746	set_section_alignment: ?SetSectionAlignment,
747	set_section_flags: ?SetSectionFlags,
748	};
749
750	fn stripElf(
751	allocator: Allocator,
752	in_file: File,
753	out_file: File,
754	elf_hdr: elf.Header,
755	options: StripElfOptions,
756	) !void {
757	const Filter = ElfFileHelper.Filter;
758	const DebugLink = ElfFileHelper.DebugLink;
759
760	const filter: Filter = filter: {
761	if (options.only_keep_debug) break :filter .debug;
762	if (options.strip_all) break :filter .program;
763	if (options.strip_debug) break :filter .program_and_symbols;
764	break :filter .all;
765	};
766
767	const filter_complement: ?Filter = blk: {
768	if (options.extract_to) \|_\| {
769	break :blk switch (filter) {
770	.program => .debug_and_symbols,
771	.debug => .program_and_symbols,
772	.program_and_symbols => .debug,
773	.debug_and_symbols => .program,
774	.all => fatal("zig objcopy: nothing to extract", .{}),
775	};
776	} else {
777	break :blk null;
778	}
779	};
780	const debuglink_path = path: {
781	if (options.add_debuglink) \|path\| break :path path;
782	if (options.extract_to) \|path\| break :path path;
783	break :path null;
784	};
785
786	switch (elf_hdr.is_64) {
787	inline else => \|is_64\| {
788	var elf_file = try ElfFile(is_64).parse(allocator, in_file, elf_hdr);
789	defer elf_file.deinit();
790
791	if (options.add_section) \|user_section\| {
792	for (elf_file.sections) \|section\| {
793	if (std.mem.eql(u8, section.name, user_section.section_name)) {
794	fatal("zig objcopy: unable to add section '{s}'. Section already exists in input", .{user_section.section_name});
795	}
796	}
797	}
798
799	if (filter_complement) \|flt\| {
800	// write the .dbg file and close it, so it can be read back to compute the debuglink checksum.
801	const path = options.extract_to.?;
802	const dbg_file = std.fs.cwd().createFile(path, .{}) catch \|err\| {
803	fatal("zig objcopy: unable to create '{s}': {s}", .{ path, @errorName(err) });
804	};
805	defer dbg_file.close();
806
807	try elf_file.emit(allocator, dbg_file, in_file, .{ .section_filter = flt, .compress_debug = options.compress_debug });
808	}
809
810	const debuglink: ?DebugLink = if (debuglink_path) \|path\| ElfFileHelper.createDebugLink(path) else null;
811	try elf_file.emit(allocator, out_file, in_file, .{
812	.section_filter = filter,
813	.debuglink = debuglink,
814	.compress_debug = options.compress_debug,
815	.add_section = options.add_section,
816	.set_section_alignment = options.set_section_alignment,
817	.set_section_flags = options.set_section_flags,
818	});
819	},
820	}
821	}
822
823	// note: this is "a minimal effort implementation"
824	// It doesn't support all possibile elf files: some sections type may need fixups, the program header may need fix up, ...
825	// 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++` )
826	// It moves and reoders the sections as little as possible to avoid having to do fixups.
827	// TODO: support non-native endianess
828
829	fn ElfFile(comptime is_64: bool) type {
830	const Elf_Ehdr = if (is_64) elf.Elf64_Ehdr else elf.Elf32_Ehdr;
831	const Elf_Phdr = if (is_64) elf.Elf64_Phdr else elf.Elf32_Phdr;
832	const Elf_Shdr = if (is_64) elf.Elf64_Shdr else elf.Elf32_Shdr;
833	const Elf_Chdr = if (is_64) elf.Elf64_Chdr else elf.Elf32_Chdr;
834	const Elf_Sym = if (is_64) elf.Elf64_Sym else elf.Elf32_Sym;
835	const Elf_OffSize = if (is_64) elf.Elf64_Off else elf.Elf32_Off;
836
837	return struct {
838	raw_elf_header: Elf_Ehdr,
839	program_segments: []const Elf_Phdr,
840	sections: []const Section,
841	arena: std.heap.ArenaAllocator,
842
843	const SectionCategory = ElfFileHelper.SectionCategory;
844	const section_memory_align: std.mem.Alignment = .of(Elf_Sym); // most restrictive of what we may load in memory
845	const Section = struct {
846	section: Elf_Shdr,
847	name: []const u8 = "",
848	segment: ?*const Elf_Phdr = null, // if the section is used by a program segment (there can be more than one)
849	payload: ?[]align(section_memory_align.toByteUnits()) const u8 = null, // if we need the data in memory
850	category: SectionCategory = .none, // should the section be kept in the exe or stripped to the debug database, or both.
851	};
852
853	const Self = @This();
854
855	pub fn parse(gpa: Allocator, in_file: File, header: elf.Header) !Self {
856	var arena = std.heap.ArenaAllocator.init(gpa);
857	errdefer arena.deinit();
858	const allocator = arena.allocator();
859
860	var raw_header: Elf_Ehdr = undefined;
861	{
862	const bytes_read = try in_file.preadAll(std.mem.asBytes(&raw_header), 0);
863	if (bytes_read < @sizeOf(Elf_Ehdr))
864	return error.TRUNCATED_ELF;
865	}
866
867	// program header: list of segments
868	const program_segments = blk: {
869	if (@sizeOf(Elf_Phdr) != header.phentsize)
870	fatal("zig objcopy: unsupported ELF file, unexpected phentsize ({d})", .{header.phentsize});
871
872	const program_header = try allocator.alloc(Elf_Phdr, header.phnum);
873	const bytes_read = try in_file.preadAll(std.mem.sliceAsBytes(program_header), header.phoff);
874	if (bytes_read < @sizeOf(Elf_Phdr) * header.phnum)
875	return error.TRUNCATED_ELF;
876	break :blk program_header;
877	};
878
879	// section header
880	const sections = blk: {
881	if (@sizeOf(Elf_Shdr) != header.shentsize)
882	fatal("zig objcopy: unsupported ELF file, unexpected shentsize ({d})", .{header.shentsize});
883
884	const section_header = try allocator.alloc(Section, header.shnum);
885
886	const raw_section_header = try allocator.alloc(Elf_Shdr, header.shnum);
887	defer allocator.free(raw_section_header);
888	const bytes_read = try in_file.preadAll(std.mem.sliceAsBytes(raw_section_header), header.shoff);
889	if (bytes_read < @sizeOf(Elf_Phdr) * header.shnum)
890	return error.TRUNCATED_ELF;
891
892	for (section_header, raw_section_header) \|*section, hdr\| {
893	section.* = .{ .section = hdr };
894	}
895	break :blk section_header;
896	};
897
898	// load data to memory for some sections:
899	// string tables for access
900	// sections than need modifications when other sections move.
901	for (sections, 0..) \|*section, idx\| {
902	const need_data = switch (section.section.sh_type) {
903	elf.DT_VERSYM => true,
904	elf.SHT_SYMTAB, elf.SHT_DYNSYM => true,
905	else => false,
906	};
907	const need_strings = (idx == header.shstrndx);
908
909	if (need_data or need_strings) {
910	const buffer = try allocator.alignedAlloc(u8, section_memory_align, @intCast(section.section.sh_size));
911	const bytes_read = try in_file.preadAll(buffer, section.section.sh_offset);
912	if (bytes_read != section.section.sh_size) return error.TRUNCATED_ELF;
913	section.payload = buffer;
914	}
915	}
916
917	// fill-in sections info:
918	// resolve the name
919	// find if a program segment uses the section
920	// categorize sections usage (used by program segments, debug datadase, common metadata, symbol table)
921	for (sections) \|*section\| {
922	section.segment = for (program_segments) \|*seg\| {
923	if (sectionWithinSegment(section.section, seg.*)) break seg;
924	} else null;
925
926	if (section.section.sh_name != 0 and header.shstrndx != elf.SHN_UNDEF)
927	section.name = std.mem.span(@as([*:0]const u8, @ptrCast(&sections[header.shstrndx].payload.?[section.section.sh_name])));
928
929	const category_from_program: SectionCategory = if (section.segment != null) .exe else .debug;
930	section.category = switch (section.section.sh_type) {
931	elf.SHT_NOTE => .common,
932	elf.SHT_SYMTAB => .symbols, // "strip all" vs "strip only debug"
933	elf.SHT_DYNSYM => .exe,
934	elf.SHT_PROGBITS => cat: {
935	if (std.mem.eql(u8, section.name, ".comment")) break :cat .exe;
936	if (std.mem.eql(u8, section.name, ".gnu_debuglink")) break :cat .none;
937	break :cat category_from_program;
938	},
939	elf.SHT_LOPROC...elf.SHT_HIPROC => .common, // don't strip unknown sections
940	elf.SHT_LOUSER...elf.SHT_HIUSER => .common, // don't strip unknown sections
941	else => category_from_program,
942	};
943	}
944
945	sections[0].category = .common; // mandatory null section
946	if (header.shstrndx != elf.SHN_UNDEF)
947	sections[header.shstrndx].category = .common; // string table for the headers
948
949	// recursively propagate section categories to their linked sections, so that they are kept together
950	var dirty: u1 = 1;
951	while (dirty != 0) {
952	dirty = 0;
953
954	for (sections) \|*section\| {
955	if (section.section.sh_link != elf.SHN_UNDEF)
956	dirty \|= ElfFileHelper.propagateCategory(&sections[section.section.sh_link].category, section.category);
957	if ((section.section.sh_flags & elf.SHF_INFO_LINK) != 0 and section.section.sh_info != elf.SHN_UNDEF)
958	dirty \|= ElfFileHelper.propagateCategory(&sections[section.section.sh_info].category, section.category);
959	}
960	}
961
962	return Self{
963	.arena = arena,
964	.raw_elf_header = raw_header,
965	.program_segments = program_segments,
966	.sections = sections,
967	};
968	}
969
970	pub fn deinit(self: *Self) void {
971	self.arena.deinit();
972	}
973
974	const Filter = ElfFileHelper.Filter;
975	const DebugLink = ElfFileHelper.DebugLink;
976	const EmitElfOptions = struct {
977	section_filter: Filter = .all,
978	debuglink: ?DebugLink = null,
979	compress_debug: bool = false,
980	add_section: ?AddSection = null,
981	set_section_alignment: ?SetSectionAlignment = null,
982	set_section_flags: ?SetSectionFlags = null,
983	};
984	fn emit(self: *const Self, gpa: Allocator, out_file: File, in_file: File, options: EmitElfOptions) !void {
985	var arena = std.heap.ArenaAllocator.init(gpa);
986	defer arena.deinit();
987	const allocator = arena.allocator();
988
989	// when emitting the stripped exe:
990	// - unused sections are removed
991	// when emitting the debug file:
992	// - all sections are kept, but some are emptied and their types is changed to SHT_NOBITS
993	// the program header is kept unchanged. (`strip` does update it, but `eu-strip` does not, and it still works)
994
995	const Update = struct {
996	action: ElfFileHelper.Action,
997
998	// remap the indexs after omitting the filtered sections
999	remap_idx: u16,
1000
1001	// optionally overrides the payload from the source file
1002	payload: ?[]align(section_memory_align.toByteUnits()) const u8 = null,
1003	section: ?Elf_Shdr = null,
1004	};
1005	const sections_update = try allocator.alloc(Update, self.sections.len);
1006	const new_shnum = blk: {
1007	var next_idx: u16 = 0;
1008	for (self.sections, sections_update) \|section, *update\| {
1009	const action = ElfFileHelper.selectAction(section.category, options.section_filter);
1010	const remap_idx = idx: {
1011	if (action == .strip) break :idx elf.SHN_UNDEF;
1012	next_idx += 1;
1013	break :idx next_idx - 1;
1014	};
1015	update.* = Update{ .action = action, .remap_idx = remap_idx };
1016	}
1017
1018	if (options.debuglink != null)
1019	next_idx += 1;
1020
1021	if (options.add_section != null) {
1022	next_idx += 1;
1023	}
1024
1025	break :blk next_idx;
1026	};
1027
1028	// add a ".gnu_debuglink" to the string table if needed
1029	const debuglink_name: u32 = blk: {
1030	if (options.debuglink == null) break :blk elf.SHN_UNDEF;
1031	if (self.raw_elf_header.e_shstrndx == elf.SHN_UNDEF)
1032	fatal("zig objcopy: no strtab, cannot add the debuglink section", .{}); // TODO add the section if needed?
1033
1034	const strtab = &self.sections[self.raw_elf_header.e_shstrndx];
1035	const update = &sections_update[self.raw_elf_header.e_shstrndx];
1036
1037	const name: []const u8 = ".gnu_debuglink";
1038	const new_offset: u32 = @intCast(strtab.payload.?.len);
1039	const buf = try allocator.alignedAlloc(u8, section_memory_align, new_offset + name.len + 1);
1040	@memcpy(buf[0..new_offset], strtab.payload.?);
1041	@memcpy(buf[new_offset..][0..name.len], name);
1042	buf[new_offset + name.len] = 0;
1043
1044	assert(update.action == .keep);
1045	update.payload = buf;
1046
1047	break :blk new_offset;
1048	};
1049
1050	// add user section to the string table if needed
1051	const user_section_name: u32 = blk: {
1052	if (options.add_section == null) break :blk elf.SHN_UNDEF;
1053	if (self.raw_elf_header.e_shstrndx == elf.SHN_UNDEF)
1054	fatal("zig objcopy: no strtab, cannot add the user section", .{}); // TODO add the section if needed?
1055
1056	const strtab = &self.sections[self.raw_elf_header.e_shstrndx];
1057	const update = &sections_update[self.raw_elf_header.e_shstrndx];
1058
1059	const name = options.add_section.?.section_name;
1060	const new_offset: u32 = @intCast(strtab.payload.?.len);
1061	const buf = try allocator.alignedAlloc(u8, section_memory_align, new_offset + name.len + 1);
1062	@memcpy(buf[0..new_offset], strtab.payload.?);
1063	@memcpy(buf[new_offset..][0..name.len], name);
1064	buf[new_offset + name.len] = 0;
1065
1066	assert(update.action == .keep);
1067	update.payload = buf;
1068
1069	break :blk new_offset;
1070	};
1071
1072	// maybe compress .debug sections
1073	if (options.compress_debug) {
1074	for (self.sections[1..], sections_update[1..]) \|section, *update\| {
1075	if (update.action != .keep) continue;
1076	if (!std.mem.startsWith(u8, section.name, ".debug_")) continue;
1077	if ((section.section.sh_flags & elf.SHF_COMPRESSED) != 0) continue; // already compressed
1078
1079	const chdr = Elf_Chdr{
1080	.ch_type = elf.COMPRESS.ZLIB,
1081	.ch_size = section.section.sh_size,
1082	.ch_addralign = section.section.sh_addralign,
1083	};
1084
1085	const compressed_payload = try ElfFileHelper.tryCompressSection(allocator, in_file, section.section.sh_offset, section.section.sh_size, std.mem.asBytes(&chdr));
1086	if (compressed_payload) \|payload\| {
1087	update.payload = payload;
1088	update.section = section.section;
1089	update.section.?.sh_addralign = @alignOf(Elf_Chdr);
1090	update.section.?.sh_size = @intCast(payload.len);
1091	update.section.?.sh_flags \|= elf.SHF_COMPRESSED;
1092	}
1093	}
1094	}
1095
1096	var cmdbuf = std.ArrayList(ElfFileHelper.WriteCmd).init(allocator);
1097	defer cmdbuf.deinit();
1098	try cmdbuf.ensureUnusedCapacity(3 + new_shnum);
1099	var eof_offset: Elf_OffSize = 0; // track the end of the data written so far.
1100
1101	// build the updated headers
1102	// nb: updated_elf_header will be updated before the actual write
1103	var updated_elf_header = self.raw_elf_header;
1104	if (updated_elf_header.e_shstrndx != elf.SHN_UNDEF)
1105	updated_elf_header.e_shstrndx = sections_update[updated_elf_header.e_shstrndx].remap_idx;
1106	cmdbuf.appendAssumeCapacity(.{ .write_data = .{ .data = std.mem.asBytes(&updated_elf_header), .out_offset = 0 } });
1107	eof_offset = @sizeOf(Elf_Ehdr);
1108
1109	// program header as-is.
1110	// nb: for only-debug files, removing it appears to work, but is invalid by ELF specifcation.
1111	{
1112	assert(updated_elf_header.e_phoff == @sizeOf(Elf_Ehdr));
1113	const data = std.mem.sliceAsBytes(self.program_segments);
1114	assert(data.len == @as(usize, updated_elf_header.e_phentsize) * updated_elf_header.e_phnum);
1115	cmdbuf.appendAssumeCapacity(.{ .write_data = .{ .data = data, .out_offset = updated_elf_header.e_phoff } });
1116	eof_offset = updated_elf_header.e_phoff + @as(Elf_OffSize, @intCast(data.len));
1117	}
1118
1119	// update sections and queue payload writes
1120	const updated_section_header = blk: {
1121	const dest_sections = try allocator.alloc(Elf_Shdr, new_shnum);
1122
1123	{
1124	// the ELF format doesn't specify the order for all sections.
1125	// this code only supports when they are in increasing file order.
1126	var offset: u64 = eof_offset;
1127	for (self.sections[1..]) \|section\| {
1128	if (section.section.sh_type == elf.SHT_NOBITS)
1129	continue;
1130	if (section.section.sh_offset < offset) {
1131	fatal("zig objcopy: unsupported ELF file", .{});
1132	}
1133	offset = section.section.sh_offset;
1134	}
1135	}
1136
1137	dest_sections[0] = self.sections[0].section;
1138
1139	var dest_section_idx: u32 = 1;
1140	for (self.sections[1..], sections_update[1..]) \|section, update\| {
1141	if (update.action == .strip) continue;
1142	assert(update.remap_idx == dest_section_idx);
1143
1144	const src = if (update.section) \|*s\| s else &section.section;
1145	const dest = &dest_sections[dest_section_idx];
1146	const payload = if (update.payload) \|data\| data else section.payload;
1147	dest_section_idx += 1;
1148
1149	dest.* = src.*;
1150
1151	if (src.sh_link != elf.SHN_UNDEF)
1152	dest.sh_link = sections_update[src.sh_link].remap_idx;
1153	if ((src.sh_flags & elf.SHF_INFO_LINK) != 0 and src.sh_info != elf.SHN_UNDEF)
1154	dest.sh_info = sections_update[src.sh_info].remap_idx;
1155
1156	if (payload) \|data\|
1157	dest.sh_size = @intCast(data.len);
1158
1159	const addralign = if (src.sh_addralign == 0 or dest.sh_type == elf.SHT_NOBITS) 1 else src.sh_addralign;
1160	dest.sh_offset = std.mem.alignForward(Elf_OffSize, eof_offset, addralign);
1161	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) {
1162	if (src.sh_offset > dest.sh_offset) {
1163	dest.sh_offset = src.sh_offset; // add padding to avoid modifing the program segments
1164	} else {
1165	fatal("zig objcopy: cannot adjust program segments", .{});
1166	}
1167	}
1168	assert(dest.sh_addr % addralign == dest.sh_offset % addralign);
1169
1170	if (update.action == .empty)
1171	dest.sh_type = elf.SHT_NOBITS;
1172
1173	if (dest.sh_type != elf.SHT_NOBITS) {
1174	if (payload) \|src_data\| {
1175	// update sections payload and write
1176	const dest_data = switch (src.sh_type) {
1177	elf.DT_VERSYM => dst_data: {
1178	const data = try allocator.alignedAlloc(u8, section_memory_align, src_data.len);
1179	@memcpy(data, src_data);
1180
1181	const defs = @as([*]elf.Verdef, @ptrCast(data))[0 .. @as(usize, @intCast(src.sh_size)) / @sizeOf(elf.Verdef)];
1182	for (defs) \|*def\| switch (def.ndx) {
1183	.LOCAL, .GLOBAL => {},
1184	else => def.ndx = @enumFromInt(sections_update[src.sh_info].remap_idx),
1185	};
1186
1187	break :dst_data data;
1188	},
1189	elf.SHT_SYMTAB, elf.SHT_DYNSYM => dst_data: {
1190	const data = try allocator.alignedAlloc(u8, section_memory_align, src_data.len);
1191	@memcpy(data, src_data);
1192
1193	const syms = @as([*]Elf_Sym, @ptrCast(data))[0 .. @as(usize, @intCast(src.sh_size)) / @sizeOf(Elf_Sym)];
1194	for (syms) \|*sym\| {
1195	if (sym.st_shndx != elf.SHN_UNDEF and sym.st_shndx < elf.SHN_LORESERVE)
1196	sym.st_shndx = sections_update[sym.st_shndx].remap_idx;
1197	}
1198
1199	break :dst_data data;
1200	},
1201	else => src_data,
1202	};
1203
1204	assert(dest_data.len == dest.sh_size);
1205	cmdbuf.appendAssumeCapacity(.{ .write_data = .{ .data = dest_data, .out_offset = dest.sh_offset } });
1206	eof_offset = dest.sh_offset + dest.sh_size;
1207	} else {
1208	// direct contents copy
1209	cmdbuf.appendAssumeCapacity(.{ .copy_range = .{ .in_offset = src.sh_offset, .len = dest.sh_size, .out_offset = dest.sh_offset } });
1210	eof_offset = dest.sh_offset + dest.sh_size;
1211	}
1212	} else {
1213	// account for alignment padding even in empty sections to keep logical section order
1214	eof_offset = dest.sh_offset;
1215	}
1216	}
1217
1218	// add a ".gnu_debuglink" section
1219	if (options.debuglink) \|link\| {
1220	const payload = payload: {
1221	const crc_offset = std.mem.alignForward(usize, link.name.len + 1, 4);
1222	const buf = try allocator.alignedAlloc(u8, .@"4", crc_offset + 4);
1223	@memcpy(buf[0..link.name.len], link.name);
1224	@memset(buf[link.name.len..crc_offset], 0);
1225	@memcpy(buf[crc_offset..], std.mem.asBytes(&link.crc32));
1226	break :payload buf;
1227	};
1228
1229	dest_sections[dest_section_idx] = Elf_Shdr{
1230	.sh_name = debuglink_name,
1231	.sh_type = elf.SHT_PROGBITS,
1232	.sh_flags = 0,
1233	.sh_addr = 0,
1234	.sh_offset = eof_offset,
1235	.sh_size = @intCast(payload.len),
1236	.sh_link = elf.SHN_UNDEF,
1237	.sh_info = elf.SHN_UNDEF,
1238	.sh_addralign = 4,
1239	.sh_entsize = 0,
1240	};
1241	dest_section_idx += 1;
1242
1243	cmdbuf.appendAssumeCapacity(.{ .write_data = .{ .data = payload, .out_offset = eof_offset } });
1244	eof_offset += @as(Elf_OffSize, @intCast(payload.len));
1245	}
1246
1247	// --add-section
1248	if (options.add_section) \|add_section\| {
1249	var section_file = fs.cwd().openFile(add_section.file_path, .{}) catch \|err\|
1250	fatal("unable to open '{s}': {s}", .{ add_section.file_path, @errorName(err) });
1251	defer section_file.close();
1252
1253	const payload = try section_file.readToEndAlloc(arena.allocator(), std.math.maxInt(usize));
1254
1255	dest_sections[dest_section_idx] = Elf_Shdr{
1256	.sh_name = user_section_name,
1257	.sh_type = elf.SHT_PROGBITS,
1258	.sh_flags = 0,
1259	.sh_addr = 0,
1260	.sh_offset = eof_offset,
1261	.sh_size = @intCast(payload.len),
1262	.sh_link = elf.SHN_UNDEF,
1263	.sh_info = elf.SHN_UNDEF,
1264	.sh_addralign = 4,
1265	.sh_entsize = 0,
1266	};
1267	dest_section_idx += 1;
1268
1269	cmdbuf.appendAssumeCapacity(.{ .write_data = .{ .data = payload, .out_offset = eof_offset } });
1270	eof_offset += @as(Elf_OffSize, @intCast(payload.len));
1271	}
1272
1273	assert(dest_section_idx == new_shnum);
1274	break :blk dest_sections;
1275	};
1276
1277	// --set-section-alignment: overwrite alignment
1278	if (options.set_section_alignment) \|set_align\| {
1279	if (self.raw_elf_header.e_shstrndx == elf.SHN_UNDEF)
1280	fatal("zig objcopy: no strtab, cannot add the user section", .{}); // TODO add the section if needed?
1281
1282	const strtab = &sections_update[self.raw_elf_header.e_shstrndx];
1283	for (updated_section_header) \|*section\| {
1284	const section_name = std.mem.span(@as([*:0]const u8, @ptrCast(&strtab.payload.?[section.sh_name])));
1285	if (std.mem.eql(u8, section_name, set_align.section_name)) {
1286	section.sh_addralign = set_align.alignment;
1287	break;
1288	}
1289	} else std.log.warn("Skipping --set-section-alignment. Section '{s}' not found", .{set_align.section_name});
1290	}
1291
1292	// --set-section-flags: overwrite flags
1293	if (options.set_section_flags) \|set_flags\| {
1294	if (self.raw_elf_header.e_shstrndx == elf.SHN_UNDEF)
1295	fatal("zig objcopy: no strtab, cannot add the user section", .{}); // TODO add the section if needed?
1296
1297	const strtab = &sections_update[self.raw_elf_header.e_shstrndx];
1298	for (updated_section_header) \|*section\| {
1299	const section_name = std.mem.span(@as([*:0]const u8, @ptrCast(&strtab.payload.?[section.sh_name])));
1300	if (std.mem.eql(u8, section_name, set_flags.section_name)) {
1301	section.sh_flags = std.elf.SHF_WRITE; // default is writable cleared by "readonly"
1302	const f = set_flags.flags;
1303
1304	// Supporting a subset of GNU and LLVM objcopy for ELF only
1305	// GNU:
1306	// alloc: add SHF_ALLOC
1307	// contents: if section is SHT_NOBITS, set SHT_PROGBITS, otherwise do nothing
1308	// load: if section is SHT_NOBITS, set SHT_PROGBITS, otherwise do nothing (same as contents)
1309	// noload: not ELF relevant
1310	// readonly: clear default SHF_WRITE flag
1311	// code: add SHF_EXECINSTR
1312	// data: not ELF relevant
1313	// rom: ignored
1314	// exclude: add SHF_EXCLUDE
1315	// share: not ELF relevant
1316	// debug: not ELF relevant
1317	// large: add SHF_X86_64_LARGE. Fatal error if target is not x86_64
1318	if (f.alloc) section.sh_flags \|= std.elf.SHF_ALLOC;
1319	if (f.contents or f.load) {
1320	if (section.sh_type == std.elf.SHT_NOBITS) section.sh_type = std.elf.SHT_PROGBITS;
1321	}
1322	if (f.readonly) section.sh_flags &= ~@as(@TypeOf(section.sh_type), std.elf.SHF_WRITE);
1323	if (f.code) section.sh_flags \|= std.elf.SHF_EXECINSTR;
1324	if (f.exclude) section.sh_flags \|= std.elf.SHF_EXCLUDE;
1325	if (f.large) {
1326	if (updated_elf_header.e_machine != std.elf.EM.X86_64)
1327	fatal("zig objcopy: 'large' section flag is only supported on x86_64 targets", .{});
1328	section.sh_flags \|= std.elf.SHF_X86_64_LARGE;
1329	}
1330
1331	// LLVM:
1332	// merge: add SHF_MERGE
1333	// strings: add SHF_STRINGS
1334	if (f.merge) section.sh_flags \|= std.elf.SHF_MERGE;
1335	if (f.strings) section.sh_flags \|= std.elf.SHF_STRINGS;
1336	break;
1337	}
1338	} else std.log.warn("Skipping --set-section-flags. Section '{s}' not found", .{set_flags.section_name});
1339	}
1340
1341	// write the section header at the tail
1342	{
1343	const offset = std.mem.alignForward(Elf_OffSize, eof_offset, @alignOf(Elf_Shdr));
1344
1345	const data = std.mem.sliceAsBytes(updated_section_header);
1346	assert(data.len == @as(usize, updated_elf_header.e_shentsize) * new_shnum);
1347	updated_elf_header.e_shoff = offset;
1348	updated_elf_header.e_shnum = new_shnum;
1349
1350	cmdbuf.appendAssumeCapacity(.{ .write_data = .{ .data = data, .out_offset = updated_elf_header.e_shoff } });
1351	}
1352
1353	try ElfFileHelper.write(allocator, out_file, in_file, cmdbuf.items);
1354	}
1355
1356	fn sectionWithinSegment(section: Elf_Shdr, segment: Elf_Phdr) bool {
1357	const file_size = if (section.sh_type == elf.SHT_NOBITS) 0 else section.sh_size;
1358	return segment.p_offset <= section.sh_offset and (segment.p_offset + segment.p_filesz) >= (section.sh_offset + file_size);
1359	}
1360	};
1361	}
1362
1363	const ElfFileHelper = struct {
1364	const DebugLink = struct { name: []const u8, crc32: u32 };
1365	const Filter = enum { all, program, debug, program_and_symbols, debug_and_symbols };
1366
1367	const SectionCategory = enum { common, exe, debug, symbols, none };
1368	fn propagateCategory(cur: *SectionCategory, new: SectionCategory) u1 {
1369	const cat: SectionCategory = switch (cur.*) {
1370	.none => new,
1371	.common => .common,
1372	.debug => switch (new) {
1373	.none, .debug => .debug,
1374	else => new,
1375	},
1376	.exe => switch (new) {
1377	.common => .common,
1378	.none, .debug, .exe => .exe,
1379	.symbols => .exe,
1380	},
1381	.symbols => switch (new) {
1382	.none, .common, .debug, .exe => unreachable,
1383	.symbols => .symbols,
1384	},
1385	};
1386
1387	if (cur.* != cat) {
1388	cur.* = cat;
1389	return 1;
1390	} else {
1391	return 0;
1392	}
1393	}
1394
1395	const Action = enum { keep, strip, empty };
1396	fn selectAction(category: SectionCategory, filter: Filter) Action {
1397	if (category == .none) return .strip;
1398	return switch (filter) {
1399	.all => switch (category) {
1400	.none => .strip,
1401	else => .keep,
1402	},
1403	.program => switch (category) {
1404	.common, .exe => .keep,
1405	else => .strip,
1406	},
1407	.program_and_symbols => switch (category) {
1408	.common, .exe, .symbols => .keep,
1409	else => .strip,
1410	},
1411	.debug => switch (category) {
1412	.exe, .symbols => .empty,
1413	.none => .strip,
1414	else => .keep,
1415	},
1416	.debug_and_symbols => switch (category) {
1417	.exe => .empty,
1418	.none => .strip,
1419	else => .keep,
1420	},
1421	};
1422	}
1423
1424	const WriteCmd = union(enum) {
1425	copy_range: struct { in_offset: u64, len: u64, out_offset: u64 },
1426	write_data: struct { data: []const u8, out_offset: u64 },
1427	};
1428	fn write(allocator: Allocator, out_file: File, in_file: File, cmds: []const WriteCmd) !void {
1429	// consolidate holes between writes:
1430	// by coping original padding data from in_file (by fusing contiguous ranges)
1431	// by writing zeroes otherwise
1432	const zeroes = [1]u8{0} ** 4096;
1433	var consolidated = std.ArrayList(WriteCmd).init(allocator);
1434	defer consolidated.deinit();
1435	try consolidated.ensureUnusedCapacity(cmds.len * 2);
1436	var offset: u64 = 0;
1437	var fused_cmd: ?WriteCmd = null;
1438	for (cmds) \|cmd\| {
1439	switch (cmd) {
1440	.write_data => \|data\| {
1441	assert(data.out_offset >= offset);
1442	if (fused_cmd) \|prev\| {
1443	consolidated.appendAssumeCapacity(prev);
1444	fused_cmd = null;
1445	}
1446	if (data.out_offset > offset) {
1447	consolidated.appendAssumeCapacity(.{ .write_data = .{ .data = zeroes[0..@intCast(data.out_offset - offset)], .out_offset = offset } });
1448	}
1449	consolidated.appendAssumeCapacity(cmd);
1450	offset = data.out_offset + data.data.len;
1451	},
1452	.copy_range => \|range\| {
1453	assert(range.out_offset >= offset);
1454	if (fused_cmd) \|prev\| {
1455	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)) {
1456	fused_cmd = .{ .copy_range = .{
1457	.in_offset = prev.copy_range.in_offset,
1458	.out_offset = prev.copy_range.out_offset,
1459	.len = (range.out_offset + range.len) - prev.copy_range.out_offset,
1460	} };
1461	} else {
1462	consolidated.appendAssumeCapacity(prev);
1463	if (range.out_offset > offset) {
1464	consolidated.appendAssumeCapacity(.{ .write_data = .{ .data = zeroes[0..@intCast(range.out_offset - offset)], .out_offset = offset } });
1465	}
1466	fused_cmd = cmd;
1467	}
1468	} else {
1469	fused_cmd = cmd;
1470	}
1471	offset = range.out_offset + range.len;
1472	},
1473	}
1474	}
1475	if (fused_cmd) \|cmd\| {
1476	consolidated.appendAssumeCapacity(cmd);
1477	}
1478
1479	// write the output file
1480	for (consolidated.items) \|cmd\| {
1481	switch (cmd) {
1482	.write_data => \|data\| {
1483	var iovec = [_]std.posix.iovec_const{.{ .base = data.data.ptr, .len = data.data.len }};
1484	try out_file.pwritevAll(&iovec, data.out_offset);
1485	},
1486	.copy_range => \|range\| {
1487	const copied_bytes = try in_file.copyRangeAll(range.in_offset, out_file, range.out_offset, range.len);
1488	if (copied_bytes < range.len) return error.TRUNCATED_ELF;
1489	},
1490	}
1491	}
1492	}
1493
1494	fn tryCompressSection(allocator: Allocator, in_file: File, offset: u64, size: u64, prefix: []const u8) !?[]align(8) const u8 {
1495	if (size < prefix.len) return null;
1496
1497	try in_file.seekTo(offset);
1498	var section_reader = std.io.limitedReader(in_file.deprecatedReader(), size);
1499
1500	// allocate as large as decompressed data. if the compression doesn't fit, keep the data uncompressed.
1501	const compressed_data = try allocator.alignedAlloc(u8, .@"8", @intCast(size));
1502	var compressed_stream = std.io.fixedBufferStream(compressed_data);
1503
1504	try compressed_stream.writer().writeAll(prefix);
1505
1506	{
1507	var compressor = try std.compress.zlib.compressor(compressed_stream.writer(), .{});
1508
1509	var buf: [8000]u8 = undefined;
1510	while (true) {
1511	const bytes_read = try section_reader.read(&buf);
1512	if (bytes_read == 0) break;
1513	const bytes_written = compressor.write(buf[0..bytes_read]) catch \|err\| switch (err) {
1514	error.NoSpaceLeft => {
1515	allocator.free(compressed_data);
1516	return null;
1517	},
1518	else => return err,
1519	};
1520	std.debug.assert(bytes_written == bytes_read);
1521	}
1522	compressor.finish() catch \|err\| switch (err) {
1523	error.NoSpaceLeft => {
1524	allocator.free(compressed_data);
1525	return null;
1526	},
1527	else => return err,
1528	};
1529	}
1530
1531	const compressed_len: usize = @intCast(compressed_stream.getPos() catch unreachable);
1532	const data = allocator.realloc(compressed_data, compressed_len) catch compressed_data;
1533	return data[0..compressed_len];
1534	}
1535
1536	fn createDebugLink(path: []const u8) DebugLink {
1537	const file = std.fs.cwd().openFile(path, .{}) catch \|err\| {
1538	fatal("zig objcopy: could not open `{s}`: {s}\n", .{ path, @errorName(err) });
1539	};
1540	defer file.close();
1541
1542	const crc = ElfFileHelper.computeFileCrc(file) catch \|err\| {
1543	fatal("zig objcopy: could not read `{s}`: {s}\n", .{ path, @errorName(err) });
1544	};
1545	return .{
1546	.name = std.fs.path.basename(path),
1547	.crc32 = crc,
1548	};
1549	}
1550
1551	fn computeFileCrc(file: File) !u32 {
1552	var buf: [8000]u8 = undefined;
1553
1554	try file.seekTo(0);
1555	var hasher = std.hash.Crc32.init();
1556	while (true) {
1557	const bytes_read = try file.read(&buf);
1558	if (bytes_read == 0) break;
1559	hasher.update(buf[0..bytes_read]);
1560	}
1561	return hasher.final();
1562	}
1563	};
1564
1565	const SectionFlags = packed struct {	720	const SectionFlags = packed struct {
1566	alloc: bool = false,	721	alloc: bool = false,
1567	contents: bool = false,	722	contents: bool = false,

lib/std/Build/Step/Run.zig+14-5

 @@ -169,7 +169,7 @@ pub const Output = struct {
 pub fn create(owner: *std.Build, name: []const u8) *Run {
     const run = owner.allocator.create(Run) catch @panic("OOM");
     run.* = .{
-        .step = Step.init(.{
+        .step = .init(.{
             .id = base_id,
             .name = name,
             .owner = owner,
 @@ -1769,13 +1769,22 @@ fn evalGeneric(run: *Run, child: *std.process.Child) !StdIoResult {
             child.stdin = null;
         },
         .lazy_path => |lazy_path| {
-            const path = lazy_path.getPath2(b, &run.step);
+            const path = lazy_path.getPath3(b, &run.step);
-            const file = b.build_root.handle.openFile(path, .{}) catch |err| {
+            const file = path.root_dir.handle.openFile(path.subPathOrDot(), .{}) catch |err| {
                 return run.step.fail("unable to open stdin file: {s}", .{@errorName(err)});
             };
             defer file.close();
-            child.stdin.?.writeFileAll(file, .{}) catch |err| {
+            // TODO https://github.com/ziglang/zig/issues/23955
-                return run.step.fail("unable to write file to stdin: {s}", .{@errorName(err)});
+            var buffer: [1024]u8 = undefined;
+            var file_reader = file.reader(&buffer);
+            var stdin_writer = child.stdin.?.writer(&.{});
+            _ = stdin_writer.interface.sendFileAll(&file_reader, .unlimited) catch |err| switch (err) {
+                error.ReadFailed => return run.step.fail("failed to read from {f}: {t}", .{
+                    path, file_reader.err.?,
+                }),
+                error.WriteFailed => return run.step.fail("failed to write to stdin: {t}", .{
+                    stdin_writer.err.?,
+                }),
             };
             child.stdin.?.close();
             child.stdin = null;

lib/std/c.zig+2-2

...	@@ -10497,9 +10497,9 @@ pub const sysconf = switch (native_os) {	...	@@ -10497,9 +10497,9 @@ pub const sysconf = switch (native_os) {
10497		10497
10498	pub const sf_hdtr = switch (native_os) {	10498	pub const sf_hdtr = switch (native_os) {
10499	.freebsd, .macos, .ios, .tvos, .watchos, .visionos => extern struct {	10499	.freebsd, .macos, .ios, .tvos, .watchos, .visionos => extern struct {
10500	headers: [*]const iovec_const,	10500	headers: ?[*]const iovec_const,
10501	hdr_cnt: c_int,	10501	hdr_cnt: c_int,
10502	trailers: [*]const iovec_const,	10502	trailers: ?[*]const iovec_const,
10503	trl_cnt: c_int,	10503	trl_cnt: c_int,
10504	},	10504	},
10505	else => void,	10505	else => void,

lib/std/elf.zig+102-171

 @@ -482,6 +482,7 @@ pub const Header = struct {
     is_64: bool,
     endian: std.builtin.Endian,
     os_abi: OSABI,
+    /// The meaning of this value depends on `os_abi`.
     abi_version: u8,
     type: ET,
     machine: EM,
 @@ -494,205 +495,135 @@ pub const Header = struct {
     shnum: u16,
     shstrndx: u16,
-    pub fn program_header_iterator(self: Header, parse_source: anytype) ProgramHeaderIterator(@TypeOf(parse_source)) {
+    pub fn iterateProgramHeaders(h: Header, file_reader: *std.fs.File.Reader) ProgramHeaderIterator {
-        return ProgramHeaderIterator(@TypeOf(parse_source)){
+        return .{
-            .elf_header = self,
+            .elf_header = h,
-            .parse_source = parse_source,
+            .file_reader = file_reader,
         };
     }
-    pub fn section_header_iterator(self: Header, parse_source: anytype) SectionHeaderIterator(@TypeOf(parse_source)) {
+    pub fn iterateSectionHeaders(h: Header, file_reader: *std.fs.File.Reader) SectionHeaderIterator {
-        return SectionHeaderIterator(@TypeOf(parse_source)){
+        return .{
-            .elf_header = self,
+            .elf_header = h,
-            .parse_source = parse_source,
+            .file_reader = file_reader,
         };
     }
-    pub fn read(parse_source: anytype) !Header {
+    pub const ReadError = std.Io.Reader.Error || error{
-        var hdr_buf: [@sizeOf(Elf64_Ehdr)]u8 align(@alignOf(Elf64_Ehdr)) = undefined;
+        InvalidElfMagic,
-        try parse_source.seekableStream().seekTo(0);
+        InvalidElfVersion,
-        try parse_source.deprecatedReader().readNoEof(&hdr_buf);
+        InvalidElfClass,
-        return Header.parse(&hdr_buf);
+        InvalidElfEndian,
-    }
+    };
-    pub fn parse(hdr_buf: *align(@alignOf(Elf64_Ehdr)) const [@sizeOf(Elf64_Ehdr)]u8) !Header {
+    pub fn read(r: *std.Io.Reader) ReadError!Header {
-        const hdr32 = @as(*const Elf32_Ehdr, @ptrCast(hdr_buf));
+        const buf = try r.peek(@sizeOf(Elf64_Ehdr));
-        const hdr64 = @as(*const Elf64_Ehdr, @ptrCast(hdr_buf));
-        if (!mem.eql(u8, hdr32.e_ident[0..4], MAGIC)) return error.InvalidElfMagic;
-        if (hdr32.e_ident[EI_VERSION] != 1) return error.InvalidElfVersion;
-        const is_64 = switch (hdr32.e_ident[EI_CLASS]) {
+        if (!mem.eql(u8, buf[0..4], MAGIC)) return error.InvalidElfMagic;
-            ELFCLASS32 => false,
+        if (buf[EI_VERSION] != 1) return error.InvalidElfVersion;
-            ELFCLASS64 => true,
-            else => return error.InvalidElfClass,
-        };
-        const endian: std.builtin.Endian = switch (hdr32.e_ident[EI_DATA]) {
+        const endian: std.builtin.Endian = switch (buf[EI_DATA]) {
             ELFDATA2LSB => .little,
             ELFDATA2MSB => .big,
             else => return error.InvalidElfEndian,
         };
-        const need_bswap = endian != native_endian;
+        return switch (buf[EI_CLASS]) {
+            ELFCLASS32 => .init(try r.takeStruct(Elf32_Ehdr, endian), endian),
+            ELFCLASS64 => .init(try r.takeStruct(Elf64_Ehdr, endian), endian),
+            else => return error.InvalidElfClass,
+        };
+    }
+    pub fn init(hdr: anytype, endian: std.builtin.Endian) Header {
         // Converting integers to exhaustive enums using `@enumFromInt` could cause a panic.
         comptime assert(!@typeInfo(OSABI).@"enum".is_exhaustive);
-        const os_abi: OSABI = @enumFromInt(hdr32.e_ident[EI_OSABI]);
+        return .{
+            .is_64 = switch (@TypeOf(hdr)) {
+                Elf32_Ehdr => false,
+                Elf64_Ehdr => true,
+                else => @compileError("bad type"),
+            },
+            .endian = endian,
+            .os_abi = @enumFromInt(hdr.e_ident[EI_OSABI]),
+            .abi_version = hdr.e_ident[EI_ABIVERSION],
+            .type = hdr.e_type,
+            .machine = hdr.e_machine,
+            .entry = hdr.e_entry,
+            .phoff = hdr.e_phoff,
+            .shoff = hdr.e_shoff,
+            .phentsize = hdr.e_phentsize,
+            .phnum = hdr.e_phnum,
+            .shentsize = hdr.e_shentsize,
+            .shnum = hdr.e_shnum,
+            .shstrndx = hdr.e_shstrndx,
+        };
+    }
+};
-        // The meaning of this value depends on `os_abi` so just make it available as `u8`.
+pub const ProgramHeaderIterator = struct {
-        const abi_version = hdr32.e_ident[EI_ABIVERSION];
+    elf_header: Header,
+    file_reader: *std.fs.File.Reader,
+    index: usize = 0,
-        const @"type" = if (need_bswap) blk: {
+    pub fn next(it: *ProgramHeaderIterator) !?Elf64_Phdr {
-            comptime assert(!@typeInfo(ET).@"enum".is_exhaustive);
+        if (it.index >= it.elf_header.phnum) return null;
-            const value = @intFromEnum(hdr32.e_type);
+        defer it.index += 1;
-            break :blk @as(ET, @enumFromInt(@byteSwap(value)));
-        } else hdr32.e_type;
-        const machine = if (need_bswap) blk: {
+        if (it.elf_header.is_64) {
-            comptime assert(!@typeInfo(EM).@"enum".is_exhaustive);
+            const offset = it.elf_header.phoff + @sizeOf(Elf64_Phdr) * it.index;
-            const value = @intFromEnum(hdr32.e_machine);
+            try it.file_reader.seekTo(offset);
-            break :blk @as(EM, @enumFromInt(@byteSwap(value)));
+            const phdr = try it.file_reader.interface.takeStruct(Elf64_Phdr, it.elf_header.endian);
-        } else hdr32.e_machine;
+            return phdr;
+        }
-        return @as(Header, .{
+        const offset = it.elf_header.phoff + @sizeOf(Elf32_Phdr) * it.index;
-            .is_64 = is_64,
+        try it.file_reader.seekTo(offset);
-            .endian = endian,
+        const phdr = try it.file_reader.interface.takeStruct(Elf32_Phdr, it.elf_header.endian);
-            .os_abi = os_abi,
+        return .{
-            .abi_version = abi_version,
+            .p_type = phdr.p_type,
-            .type = @"type",
+            .p_offset = phdr.p_offset,
-            .machine = machine,
+            .p_vaddr = phdr.p_vaddr,
-            .entry = int(is_64, need_bswap, hdr32.e_entry, hdr64.e_entry),
+            .p_paddr = phdr.p_paddr,
-            .phoff = int(is_64, need_bswap, hdr32.e_phoff, hdr64.e_phoff),
+            .p_filesz = phdr.p_filesz,
-            .shoff = int(is_64, need_bswap, hdr32.e_shoff, hdr64.e_shoff),
+            .p_memsz = phdr.p_memsz,
-            .phentsize = int(is_64, need_bswap, hdr32.e_phentsize, hdr64.e_phentsize),
+            .p_flags = phdr.p_flags,
-            .phnum = int(is_64, need_bswap, hdr32.e_phnum, hdr64.e_phnum),
+            .p_align = phdr.p_align,
-            .shentsize = int(is_64, need_bswap, hdr32.e_shentsize, hdr64.e_shentsize),
+        };
-            .shnum = int(is_64, need_bswap, hdr32.e_shnum, hdr64.e_shnum),
-            .shstrndx = int(is_64, need_bswap, hdr32.e_shstrndx, hdr64.e_shstrndx),
-        });
     }
 };
-pub fn ProgramHeaderIterator(comptime ParseSource: anytype) type {
+pub const SectionHeaderIterator = struct {
-    return struct {
+    elf_header: Header,
-        elf_header: Header,
+    file_reader: *std.fs.File.Reader,
-        parse_source: ParseSource,
+    index: usize = 0,
-        index: usize = 0,
-        pub fn next(self: *@This()) !?Elf64_Phdr {
-            if (self.index >= self.elf_header.phnum) return null;
-            defer self.index += 1;
-            if (self.elf_header.is_64) {
-                var phdr: Elf64_Phdr = undefined;
-                const offset = self.elf_header.phoff + @sizeOf(@TypeOf(phdr)) * self.index;
-                try self.parse_source.seekableStream().seekTo(offset);
-                try self.parse_source.deprecatedReader().readNoEof(mem.asBytes(&phdr));
-                // ELF endianness matches native endianness.
-                if (self.elf_header.endian == native_endian) return phdr;
-                // Convert fields to native endianness.
-                mem.byteSwapAllFields(Elf64_Phdr, &phdr);
-                return phdr;
-            }
-            var phdr: Elf32_Phdr = undefined;
-            const offset = self.elf_header.phoff + @sizeOf(@TypeOf(phdr)) * self.index;
-            try self.parse_source.seekableStream().seekTo(offset);
-            try self.parse_source.deprecatedReader().readNoEof(mem.asBytes(&phdr));
-            // ELF endianness does NOT match native endianness.
-            if (self.elf_header.endian != native_endian) {
-                // Convert fields to native endianness.
-                mem.byteSwapAllFields(Elf32_Phdr, &phdr);
-            }
-            // Convert 32-bit header to 64-bit.
-            return Elf64_Phdr{
-                .p_type = phdr.p_type,
-                .p_offset = phdr.p_offset,
-                .p_vaddr = phdr.p_vaddr,
-                .p_paddr = phdr.p_paddr,
-                .p_filesz = phdr.p_filesz,
-                .p_memsz = phdr.p_memsz,
-                .p_flags = phdr.p_flags,
-                .p_align = phdr.p_align,
-            };
-        }
-    };
-}
-pub fn SectionHeaderIterator(comptime ParseSource: anytype) type {
+    pub fn next(it: *SectionHeaderIterator) !?Elf64_Shdr {
-    return struct {
+        if (it.index >= it.elf_header.shnum) return null;
-        elf_header: Header,
+        defer it.index += 1;
-        parse_source: ParseSource,
-        index: usize = 0,
-        pub fn next(self: *@This()) !?Elf64_Shdr {
-            if (self.index >= self.elf_header.shnum) return null;
-            defer self.index += 1;
-            if (self.elf_header.is_64) {
-                var shdr: Elf64_Shdr = undefined;
-                const offset = self.elf_header.shoff + @sizeOf(@TypeOf(shdr)) * self.index;
-                try self.parse_source.seekableStream().seekTo(offset);
-                try self.parse_source.deprecatedReader().readNoEof(mem.asBytes(&shdr));
-                // ELF endianness matches native endianness.
-                if (self.elf_header.endian == native_endian) return shdr;
-                // Convert fields to native endianness.
-                mem.byteSwapAllFields(Elf64_Shdr, &shdr);
-                return shdr;
-            }
-            var shdr: Elf32_Shdr = undefined;
-            const offset = self.elf_header.shoff + @sizeOf(@TypeOf(shdr)) * self.index;
-            try self.parse_source.seekableStream().seekTo(offset);
-            try self.parse_source.deprecatedReader().readNoEof(mem.asBytes(&shdr));
-            // ELF endianness does NOT match native endianness.
-            if (self.elf_header.endian != native_endian) {
-                // Convert fields to native endianness.
-                mem.byteSwapAllFields(Elf32_Shdr, &shdr);
-            }
-            // Convert 32-bit header to 64-bit.
-            return Elf64_Shdr{
-                .sh_name = shdr.sh_name,
-                .sh_type = shdr.sh_type,
-                .sh_flags = shdr.sh_flags,
-                .sh_addr = shdr.sh_addr,
-                .sh_offset = shdr.sh_offset,
-                .sh_size = shdr.sh_size,
-                .sh_link = shdr.sh_link,
-                .sh_info = shdr.sh_info,
-                .sh_addralign = shdr.sh_addralign,
-                .sh_entsize = shdr.sh_entsize,
-            };
-        }
-    };
-}
-fn int(is_64: bool, need_bswap: bool, int_32: anytype, int_64: anytype) @TypeOf(int_64) {
+        if (it.elf_header.is_64) {
-    if (is_64) {
+            try it.file_reader.seekTo(it.elf_header.shoff + @sizeOf(Elf64_Shdr) * it.index);
-        if (need_bswap) {
+            const shdr = try it.file_reader.interface.takeStruct(Elf64_Shdr, it.elf_header.endian);
-            return @byteSwap(int_64);
+            return shdr;
-        } else {
-            return int_64;
         }
-    } else {
-        return int32(need_bswap, int_32, @TypeOf(int_64));
-    }
-}
-fn int32(need_bswap: bool, int_32: anytype, comptime Int64: anytype) Int64 {
+        try it.file_reader.seekTo(it.elf_header.shoff + @sizeOf(Elf32_Shdr) * it.index);
-    if (need_bswap) {
+        const shdr = try it.file_reader.interface.takeStruct(Elf32_Shdr, it.elf_header.endian);
-        return @byteSwap(int_32);
+        return .{
-    } else {
+            .sh_name = shdr.sh_name,
-        return int_32;
+            .sh_type = shdr.sh_type,
+            .sh_flags = shdr.sh_flags,
+            .sh_addr = shdr.sh_addr,
+            .sh_offset = shdr.sh_offset,
+            .sh_size = shdr.sh_size,
+            .sh_link = shdr.sh_link,
+            .sh_info = shdr.sh_info,
+            .sh_addralign = shdr.sh_addralign,
+            .sh_entsize = shdr.sh_entsize,
+        };
     }
-}
+};
 pub const ELFCLASSNONE = 0;
 pub const ELFCLASS32 = 1;

lib/std/fs/AtomicFile.zig+52-46

...	@@ -1,6 +1,13 @@	...	@@ -1,6 +1,13 @@
1	file: File,	1	const AtomicFile = @This();
2	// TODO either replace this with rand_buf or use []u16 on Windows	2	const std = @import("../std.zig");
3	tmp_path_buf: [tmp_path_len:0]u8,	3	const File = std.fs.File;
		4	const Dir = std.fs.Dir;
		5	const fs = std.fs;
		6	const assert = std.debug.assert;
		7	const posix = std.posix;
		8
		9	file_writer: File.Writer,
		10	random_integer: u64,
4	dest_basename: []const u8,	11	dest_basename: []const u8,
5	file_open: bool,	12	file_open: bool,
6	file_exists: bool,	13	file_exists: bool,
...	@@ -9,35 +16,24 @@ dir: Dir,	...	@@ -9,35 +16,24 @@ dir: Dir,
9		16
10	pub const InitError = File.OpenError;	17	pub const InitError = File.OpenError;
11		18
12	pub const random_bytes_len = 12;
13	const tmp_path_len = fs.base64_encoder.calcSize(random_bytes_len);
14
15	/// Note that the `Dir.atomicFile` API may be more handy than this lower-level function.	19	/// Note that the `Dir.atomicFile` API may be more handy than this lower-level function.
16	pub fn init(	20	pub fn init(
17	dest_basename: []const u8,	21	dest_basename: []const u8,
18	mode: File.Mode,	22	mode: File.Mode,
19	dir: Dir,	23	dir: Dir,
20	close_dir_on_deinit: bool,	24	close_dir_on_deinit: bool,
		25	write_buffer: []u8,
21	) InitError!AtomicFile {	26	) InitError!AtomicFile {
22	var rand_buf: [random_bytes_len]u8 = undefined;
23	var tmp_path_buf: [tmp_path_len:0]u8 = undefined;
24
25	while (true) {	27	while (true) {
26	std.crypto.random.bytes(rand_buf[0..]);	28	const random_integer = std.crypto.random.int(u64);
27	const tmp_path = fs.base64_encoder.encode(&tmp_path_buf, &rand_buf);	29	const tmp_sub_path = std.fmt.hex(random_integer);
28	tmp_path_buf[tmp_path.len] = 0;	30	const file = dir.createFile(&tmp_sub_path, .{ .mode = mode, .exclusive = true }) catch \|err\| switch (err) {
29
30	const file = dir.createFile(
31	tmp_path,
32	.{ .mode = mode, .exclusive = true },
33	) catch \|err\| switch (err) {
34	error.PathAlreadyExists => continue,	31	error.PathAlreadyExists => continue,
35	else => \|e\| return e,	32	else => \|e\| return e,
36	};	33	};
37		34	return .{
38	return AtomicFile{	35	.file_writer = file.writer(write_buffer),
39	.file = file,	36	.random_integer = random_integer,
40	.tmp_path_buf = tmp_path_buf,
41	.dest_basename = dest_basename,	37	.dest_basename = dest_basename,
42	.file_open = true,	38	.file_open = true,
43	.file_exists = true,	39	.file_exists = true,
...	@@ -48,41 +44,51 @@ pub fn init(	...	@@ -48,41 +44,51 @@ pub fn init(
48	}	44	}
49		45
50	/// Always call deinit, even after a successful finish().	46	/// Always call deinit, even after a successful finish().
51	pub fn deinit(self: *AtomicFile) void {	47	pub fn deinit(af: *AtomicFile) void {
52	if (self.file_open) {	48	if (af.file_open) {
53	self.file.close();	49	af.file_writer.file.close();
54	self.file_open = false;	50	af.file_open = false;
55	}	51	}
56	if (self.file_exists) {	52	if (af.file_exists) {
57	self.dir.deleteFile(&self.tmp_path_buf) catch {};	53	const tmp_sub_path = std.fmt.hex(af.random_integer);
58	self.file_exists = false;	54	af.dir.deleteFile(&tmp_sub_path) catch {};
		55	af.file_exists = false;
59	}	56	}
60	if (self.close_dir_on_deinit) {	57	if (af.close_dir_on_deinit) {
61	self.dir.close();	58	af.dir.close();
62	}	59	}
63	self.* = undefined;	60	af.* = undefined;
64	}	61	}
65		62
66	pub const FinishError = posix.RenameError;	63	pub const FlushError = File.WriteError;
		64
		65	pub fn flush(af: *AtomicFile) FlushError!void {
		66	af.file_writer.interface.flush() catch \|err\| switch (err) {
		67	error.WriteFailed => return af.file_writer.err.?,
		68	};
		69	}
		70
		71	pub const RenameIntoPlaceError = posix.RenameError;
67		72
68	/// On Windows, this function introduces a period of time where some file	73	/// On Windows, this function introduces a period of time where some file
69	/// system operations on the destination file will result in	74	/// system operations on the destination file will result in
70	/// `error.AccessDenied`, including rename operations (such as the one used in	75	/// `error.AccessDenied`, including rename operations (such as the one used in
71	/// this function).	76	/// this function).
72	pub fn finish(self: *AtomicFile) FinishError!void {	77	pub fn renameIntoPlace(af: *AtomicFile) RenameIntoPlaceError!void {
73	assert(self.file_exists);	78	assert(af.file_exists);
74	if (self.file_open) {	79	if (af.file_open) {
75	self.file.close();	80	af.file_writer.file.close();
76	self.file_open = false;	81	af.file_open = false;
77	}	82	}
78	try posix.renameat(self.dir.fd, self.tmp_path_buf[0..], self.dir.fd, self.dest_basename);	83	const tmp_sub_path = std.fmt.hex(af.random_integer);
79	self.file_exists = false;	84	try posix.renameat(af.dir.fd, &tmp_sub_path, af.dir.fd, af.dest_basename);
		85	af.file_exists = false;
80	}	86	}
81		87
82	const AtomicFile = @This();	88	pub const FinishError = FlushError \|\| RenameIntoPlaceError;
83	const std = @import("../std.zig");	89
84	const File = std.fs.File;	90	/// Combination of `flush` followed by `renameIntoPlace`.
85	const Dir = std.fs.Dir;	91	pub fn finish(af: *AtomicFile) FinishError!void {
86	const fs = std.fs;	92	try af.flush();
87	const assert = std.debug.assert;	93	try af.renameIntoPlace();
88	const posix = std.posix;	94	}

lib/std/fs/Dir.zig+71-109

...	@@ -1,3 +1,20 @@	...	@@ -1,3 +1,20 @@
		1	const Dir = @This();
		2	const builtin = @import("builtin");
		3	const std = @import("../std.zig");
		4	const File = std.fs.File;
		5	const AtomicFile = std.fs.AtomicFile;
		6	const base64_encoder = fs.base64_encoder;
		7	const posix = std.posix;
		8	const mem = std.mem;
		9	const path = fs.path;
		10	const fs = std.fs;
		11	const Allocator = std.mem.Allocator;
		12	const assert = std.debug.assert;
		13	const linux = std.os.linux;
		14	const windows = std.os.windows;
		15	const native_os = builtin.os.tag;
		16	const have_flock = @TypeOf(posix.system.flock) != void;
		17
1	fd: Handle,	18	fd: Handle,
2		19
3	pub const Handle = posix.fd_t;	20	pub const Handle = posix.fd_t;
...	@@ -1862,9 +1879,10 @@ pub fn symLinkW(	...	@@ -1862,9 +1879,10 @@ pub fn symLinkW(
1862		1879
1863	/// Same as `symLink`, except tries to create the symbolic link until it	1880	/// Same as `symLink`, except tries to create the symbolic link until it
1864	/// succeeds or encounters an error other than `error.PathAlreadyExists`.	1881	/// succeeds or encounters an error other than `error.PathAlreadyExists`.
1865	/// On Windows, both paths should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).	1882	///
1866	/// On WASI, both paths should be encoded as valid UTF-8.	1883	/// * On Windows, both paths should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
1867	/// On other platforms, both paths are an opaque sequence of bytes with no particular encoding.	1884	/// * On WASI, both paths should be encoded as valid UTF-8.
		1885	/// * On other platforms, both paths are an opaque sequence of bytes with no particular encoding.
1868	pub fn atomicSymLink(	1886	pub fn atomicSymLink(
1869	dir: Dir,	1887	dir: Dir,
1870	target_path: []const u8,	1888	target_path: []const u8,
...	@@ -1880,9 +1898,8 @@ pub fn atomicSymLink(	...	@@ -1880,9 +1898,8 @@ pub fn atomicSymLink(
1880		1898
1881	const dirname = path.dirname(sym_link_path) orelse ".";	1899	const dirname = path.dirname(sym_link_path) orelse ".";
1882		1900
1883	var rand_buf: [AtomicFile.random_bytes_len]u8 = undefined;	1901	const rand_len = @sizeOf(u64) * 2;
1884		1902	const temp_path_len = dirname.len + 1 + rand_len;
1885	const temp_path_len = dirname.len + 1 + base64_encoder.calcSize(rand_buf.len);
1886	var temp_path_buf: [fs.max_path_bytes]u8 = undefined;	1903	var temp_path_buf: [fs.max_path_bytes]u8 = undefined;
1887		1904
1888	if (temp_path_len > temp_path_buf.len) return error.NameTooLong;	1905	if (temp_path_len > temp_path_buf.len) return error.NameTooLong;
...	@@ -1892,8 +1909,8 @@ pub fn atomicSymLink(	...	@@ -1892,8 +1909,8 @@ pub fn atomicSymLink(
1892	const temp_path = temp_path_buf[0..temp_path_len];	1909	const temp_path = temp_path_buf[0..temp_path_len];
1893		1910
1894	while (true) {	1911	while (true) {
1895	crypto.random.bytes(rand_buf[0..]);	1912	const random_integer = std.crypto.random.int(u64);
1896	_ = base64_encoder.encode(temp_path[dirname.len + 1 ..], rand_buf[0..]);	1913	temp_path[dirname.len + 1 ..][0..rand_len].* = std.fmt.hex(random_integer);
1897		1914
1898	if (dir.symLink(target_path, temp_path, flags)) {	1915	if (dir.symLink(target_path, temp_path, flags)) {
1899	return dir.rename(temp_path, sym_link_path);	1916	return dir.rename(temp_path, sym_link_path);
...	@@ -2552,25 +2569,42 @@ pub fn updateFile(	...	@@ -2552,25 +2569,42 @@ pub fn updateFile(
2552	try dest_dir.makePath(dirname);	2569	try dest_dir.makePath(dirname);
2553	}	2570	}
2554		2571
2555	var atomic_file = try dest_dir.atomicFile(dest_path, .{ .mode = actual_mode });	2572	var buffer: [1000]u8 = undefined; // Used only when direct fd-to-fd is not available.
		2573	var atomic_file = try dest_dir.atomicFile(dest_path, .{
		2574	.mode = actual_mode,
		2575	.write_buffer = &buffer,
		2576	});
2556	defer atomic_file.deinit();	2577	defer atomic_file.deinit();
2557		2578
2558	try atomic_file.file.writeFileAll(src_file, .{ .in_len = src_stat.size });	2579	var src_reader: File.Reader = .initSize(src_file, &.{}, src_stat.size);
2559	try atomic_file.file.updateTimes(src_stat.atime, src_stat.mtime);	2580	const dest_writer = &atomic_file.file_writer.interface;
		2581
		2582	_ = dest_writer.sendFileAll(&src_reader, .unlimited) catch \|err\| switch (err) {
		2583	error.ReadFailed => return src_reader.err.?,
		2584	error.WriteFailed => return atomic_file.file_writer.err.?,
		2585	};
		2586	try atomic_file.file_writer.file.updateTimes(src_stat.atime, src_stat.mtime);
2560	try atomic_file.finish();	2587	try atomic_file.finish();
2561	return PrevStatus.stale;	2588	return .stale;
2562	}	2589	}
2563		2590
2564	pub const CopyFileError = File.OpenError \|\| File.StatError \|\|	2591	pub const CopyFileError = File.OpenError \|\| File.StatError \|\|
2565	AtomicFile.InitError \|\| CopyFileRawError \|\| AtomicFile.FinishError;	2592	AtomicFile.InitError \|\| AtomicFile.FinishError \|\|
		2593	File.ReadError \|\| File.WriteError;
2566		2594
2567	/// Guaranteed to be atomic.	2595	/// Atomically creates a new file at `dest_path` within `dest_dir` with the
2568	/// On Linux, until https://patchwork.kernel.org/patch/9636735/ is merged and readily available,	2596	/// same contents as `source_path` within `source_dir`, overwriting any already
2569	/// there is a possibility of power loss or application termination leaving temporary files present	2597	/// existing file.
2570	/// in the same directory as dest_path.	2598	///
2571	/// On Windows, both paths should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).	2599	/// On Linux, until https://patchwork.kernel.org/patch/9636735/ is merged and
2572	/// On WASI, both paths should be encoded as valid UTF-8.	2600	/// readily available, there is a possibility of power loss or application
2573	/// On other platforms, both paths are an opaque sequence of bytes with no particular encoding.	2601	/// termination leaving temporary files present in the same directory as
		2602	/// dest_path.
		2603	///
		2604	/// On Windows, both paths should be encoded as
		2605	/// [WTF-8](https://simonsapin.github.io/wtf-8/). On WASI, both paths should be
		2606	/// encoded as valid UTF-8. On other platforms, both paths are an opaque
		2607	/// sequence of bytes with no particular encoding.
2574	pub fn copyFile(	2608	pub fn copyFile(
2575	source_dir: Dir,	2609	source_dir: Dir,
2576	source_path: []const u8,	2610	source_path: []const u8,
...	@@ -2578,79 +2612,34 @@ pub fn copyFile(	...	@@ -2578,79 +2612,34 @@ pub fn copyFile(
2578	dest_path: []const u8,	2612	dest_path: []const u8,
2579	options: CopyFileOptions,	2613	options: CopyFileOptions,
2580	) CopyFileError!void {	2614	) CopyFileError!void {
2581	var in_file = try source_dir.openFile(source_path, .{});	2615	var file_reader: File.Reader = .init(try source_dir.openFile(source_path, .{}), &.{});
2582	defer in_file.close();	2616	defer file_reader.file.close();
2583		2617
2584	var size: ?u64 = null;
2585	const mode = options.override_mode orelse blk: {	2618	const mode = options.override_mode orelse blk: {
2586	const st = try in_file.stat();	2619	const st = try file_reader.file.stat();
2587	size = st.size;	2620	file_reader.size = st.size;
2588	break :blk st.mode;	2621	break :blk st.mode;
2589	};	2622	};
2590		2623
2591	var atomic_file = try dest_dir.atomicFile(dest_path, .{ .mode = mode });	2624	var buffer: [1024]u8 = undefined; // Used only when direct fd-to-fd is not available.
		2625	var atomic_file = try dest_dir.atomicFile(dest_path, .{
		2626	.mode = mode,
		2627	.write_buffer = &buffer,
		2628	});
2592	defer atomic_file.deinit();	2629	defer atomic_file.deinit();
2593		2630
2594	try copy_file(in_file.handle, atomic_file.file.handle, size);	2631	_ = atomic_file.file_writer.interface.sendFileAll(&file_reader, .unlimited) catch \|err\| switch (err) {
2595	try atomic_file.finish();	2632	error.ReadFailed => return file_reader.err.?,
2596	}	2633	error.WriteFailed => return atomic_file.file_writer.err.?,
2597		2634	};
2598	const CopyFileRawError = error{SystemResources} \|\| posix.CopyFileRangeError \|\| posix.SendFileError;
2599
2600	// Transfer all the data between two file descriptors in the most efficient way.
2601	// The copy starts at offset 0, the initial offsets are preserved.
2602	// No metadata is transferred over.
2603	fn copy_file(fd_in: posix.fd_t, fd_out: posix.fd_t, maybe_size: ?u64) CopyFileRawError!void {
2604	if (builtin.target.os.tag.isDarwin()) {
2605	const rc = posix.system.fcopyfile(fd_in, fd_out, null, .{ .DATA = true });
2606	switch (posix.errno(rc)) {
2607	.SUCCESS => return,
2608	.INVAL => unreachable,
2609	.NOMEM => return error.SystemResources,
2610	// The source file is not a directory, symbolic link, or regular file.
2611	// Try with the fallback path before giving up.
2612	.OPNOTSUPP => {},
2613	else => \|err\| return posix.unexpectedErrno(err),
2614	}
2615	}
2616
2617	if (native_os == .linux) {
2618	// Try copy_file_range first as that works at the FS level and is the
2619	// most efficient method (if available).
2620	var offset: u64 = 0;
2621	cfr_loop: while (true) {
2622	// The kernel checks the u64 value `offset+count` for overflow, use
2623	// a 32 bit value so that the syscall won't return EINVAL except for
2624	// impossibly large files (> 2^64-1 - 2^32-1).
2625	const amt = try posix.copy_file_range(fd_in, offset, fd_out, offset, std.math.maxInt(u32), 0);
2626	// Terminate as soon as we have copied size bytes or no bytes
2627	if (maybe_size) \|s\| {
2628	if (s == amt) break :cfr_loop;
2629	}
2630	if (amt == 0) break :cfr_loop;
2631	offset += amt;
2632	}
2633	return;
2634	}
2635		2635
2636	// Sendfile is a zero-copy mechanism iff the OS supports it, otherwise the	2636	try atomic_file.finish();
2637	// fallback code will copy the contents chunk by chunk.
2638	const empty_iovec = [0]posix.iovec_const{};
2639	var offset: u64 = 0;
2640	sendfile_loop: while (true) {
2641	const amt = try posix.sendfile(fd_out, fd_in, offset, 0, &empty_iovec, &empty_iovec, 0);
2642	// Terminate as soon as we have copied size bytes or no bytes
2643	if (maybe_size) \|s\| {
2644	if (s == amt) break :sendfile_loop;
2645	}
2646	if (amt == 0) break :sendfile_loop;
2647	offset += amt;
2648	}
2649	}	2637	}
2650		2638
2651	pub const AtomicFileOptions = struct {	2639	pub const AtomicFileOptions = struct {
2652	mode: File.Mode = File.default_mode,	2640	mode: File.Mode = File.default_mode,
2653	make_path: bool = false,	2641	make_path: bool = false,
		2642	write_buffer: []u8,
2654	};	2643	};
2655		2644
2656	/// Directly access the `.file` field, and then call `AtomicFile.finish` to	2645	/// Directly access the `.file` field, and then call `AtomicFile.finish` to
...	@@ -2668,9 +2657,9 @@ pub fn atomicFile(self: Dir, dest_path: []const u8, options: AtomicFileOptions)	...	@@ -2668,9 +2657,9 @@ pub fn atomicFile(self: Dir, dest_path: []const u8, options: AtomicFileOptions)
2668	else	2657	else
2669	try self.openDir(dirname, .{});	2658	try self.openDir(dirname, .{});
2670		2659
2671	return AtomicFile.init(fs.path.basename(dest_path), options.mode, dir, true);	2660	return .init(fs.path.basename(dest_path), options.mode, dir, true, options.write_buffer);
2672	} else {	2661	} else {
2673	return AtomicFile.init(dest_path, options.mode, self, false);	2662	return .init(dest_path, options.mode, self, false, options.write_buffer);
2674	}	2663	}
2675	}	2664	}
2676		2665
...	@@ -2768,30 +2757,3 @@ pub fn setPermissions(self: Dir, permissions: Permissions) SetPermissionsError!v	...	@@ -2768,30 +2757,3 @@ pub fn setPermissions(self: Dir, permissions: Permissions) SetPermissionsError!v
2768	const file: File = .{ .handle = self.fd };	2757	const file: File = .{ .handle = self.fd };
2769	try file.setPermissions(permissions);	2758	try file.setPermissions(permissions);
2770	}	2759	}
2771
2772	const Metadata = File.Metadata;
2773	pub const MetadataError = File.MetadataError;
2774
2775	/// Returns a `Metadata` struct, representing the permissions on the directory
2776	pub fn metadata(self: Dir) MetadataError!Metadata {
2777	const file: File = .{ .handle = self.fd };
2778	return try file.metadata();
2779	}
2780
2781	const Dir = @This();
2782	const builtin = @import("builtin");
2783	const std = @import("../std.zig");
2784	const File = std.fs.File;
2785	const AtomicFile = std.fs.AtomicFile;
2786	const base64_encoder = fs.base64_encoder;
2787	const crypto = std.crypto;
2788	const posix = std.posix;
2789	const mem = std.mem;
2790	const path = fs.path;
2791	const fs = std.fs;
2792	const Allocator = std.mem.Allocator;
2793	const assert = std.debug.assert;
2794	const linux = std.os.linux;
2795	const windows = std.os.windows;
2796	const native_os = builtin.os.tag;
2797	const have_flock = @TypeOf(posix.system.flock) != void;

lib/std/fs/File.zig+171-127

...	@@ -1089,113 +1089,6 @@ pub fn copyRangeAll(in: File, in_offset: u64, out: File, out_offset: u64, len: u	...	@@ -1089,113 +1089,6 @@ pub fn copyRangeAll(in: File, in_offset: u64, out: File, out_offset: u64, len: u
1089	return total_bytes_copied;	1089	return total_bytes_copied;
1090	}	1090	}
1091		1091
1092	/// Deprecated in favor of `Writer`.
1093	pub const WriteFileOptions = struct {
1094	in_offset: u64 = 0,
1095	in_len: ?u64 = null,
1096	headers_and_trailers: []posix.iovec_const = &[0]posix.iovec_const{},
1097	header_count: usize = 0,
1098	};
1099
1100	/// Deprecated in favor of `Writer`.
1101	pub const WriteFileError = ReadError \|\| error{EndOfStream} \|\| WriteError;
1102
1103	/// Deprecated in favor of `Writer`.
1104	pub fn writeFileAll(self: File, in_file: File, args: WriteFileOptions) WriteFileError!void {
1105	return self.writeFileAllSendfile(in_file, args) catch \|err\| switch (err) {
1106	error.Unseekable,
1107	error.FastOpenAlreadyInProgress,
1108	error.MessageTooBig,
1109	error.FileDescriptorNotASocket,
1110	error.NetworkUnreachable,
1111	error.NetworkSubsystemFailed,
1112	error.ConnectionRefused,
1113	=> return self.writeFileAllUnseekable(in_file, args),
1114	else => \|e\| return e,
1115	};
1116	}
1117
1118	/// Deprecated in favor of `Writer`.
1119	pub fn writeFileAllUnseekable(self: File, in_file: File, args: WriteFileOptions) WriteFileError!void {
1120	const headers = args.headers_and_trailers[0..args.header_count];
1121	const trailers = args.headers_and_trailers[args.header_count..];
1122	try self.writevAll(headers);
1123	try in_file.deprecatedReader().skipBytes(args.in_offset, .{ .buf_size = 4096 });
1124	var fifo = std.fifo.LinearFifo(u8, .{ .Static = 4096 }).init();
1125	if (args.in_len) \|len\| {
1126	var stream = std.io.limitedReader(in_file.deprecatedReader(), len);
1127	try fifo.pump(stream.reader(), self.deprecatedWriter());
1128	} else {
1129	try fifo.pump(in_file.deprecatedReader(), self.deprecatedWriter());
1130	}
1131	try self.writevAll(trailers);
1132	}
1133
1134	/// Deprecated in favor of `Writer`.
1135	fn writeFileAllSendfile(self: File, in_file: File, args: WriteFileOptions) posix.SendFileError!void {
1136	const count = blk: {
1137	if (args.in_len) \|l\| {
1138	if (l == 0) {
1139	return self.writevAll(args.headers_and_trailers);
1140	} else {
1141	break :blk l;
1142	}
1143	} else {
1144	break :blk 0;
1145	}
1146	};
1147	const headers = args.headers_and_trailers[0..args.header_count];
1148	const trailers = args.headers_and_trailers[args.header_count..];
1149	const zero_iovec = &[0]posix.iovec_const{};
1150	// When reading the whole file, we cannot put the trailers in the sendfile() syscall,
1151	// because we have no way to determine whether a partial write is past the end of the file or not.
1152	const trls = if (count == 0) zero_iovec else trailers;
1153	const offset = args.in_offset;
1154	const out_fd = self.handle;
1155	const in_fd = in_file.handle;
1156	const flags = 0;
1157	var amt: usize = 0;
1158	hdrs: {
1159	var i: usize = 0;
1160	while (i < headers.len) {
1161	amt = try posix.sendfile(out_fd, in_fd, offset, count, headers[i..], trls, flags);
1162	while (amt >= headers[i].len) {
1163	amt -= headers[i].len;
1164	i += 1;
1165	if (i >= headers.len) break :hdrs;
1166	}
1167	headers[i].base += amt;
1168	headers[i].len -= amt;
1169	}
1170	}
1171	if (count == 0) {
1172	var off: u64 = amt;
1173	while (true) {
1174	amt = try posix.sendfile(out_fd, in_fd, offset + off, 0, zero_iovec, zero_iovec, flags);
1175	if (amt == 0) break;
1176	off += amt;
1177	}
1178	} else {
1179	var off: u64 = amt;
1180	while (off < count) {
1181	amt = try posix.sendfile(out_fd, in_fd, offset + off, count - off, zero_iovec, trailers, flags);
1182	off += amt;
1183	}
1184	amt = @as(usize, @intCast(off - count));
1185	}
1186	var i: usize = 0;
1187	while (i < trailers.len) {
1188	while (amt >= trailers[i].len) {
1189	amt -= trailers[i].len;
1190	i += 1;
1191	if (i >= trailers.len) return;
1192	}
1193	trailers[i].base += amt;
1194	trailers[i].len -= amt;
1195	amt = try posix.writev(self.handle, trailers[i..]);
1196	}
1197	}
1198
1199	/// Deprecated in favor of `Reader`.	1092	/// Deprecated in favor of `Reader`.
1200	pub const DeprecatedReader = io.GenericReader(File, ReadError, read);	1093	pub const DeprecatedReader = io.GenericReader(File, ReadError, read);
1201		1094
...	@@ -1242,7 +1135,7 @@ pub const Reader = struct {	...	@@ -1242,7 +1135,7 @@ pub const Reader = struct {
1242	err: ?ReadError = null,	1135	err: ?ReadError = null,
1243	mode: Reader.Mode = .positional,	1136	mode: Reader.Mode = .positional,
1244	/// Tracks the true seek position in the file. To obtain the logical	1137	/// Tracks the true seek position in the file. To obtain the logical
1245	/// position, subtract the buffer size from this value.	1138	/// position, use `logicalPos`.
1246	pos: u64 = 0,	1139	pos: u64 = 0,
1247	size: ?u64 = null,	1140	size: ?u64 = null,
1248	size_err: ?GetEndPosError = null,	1141	size_err: ?GetEndPosError = null,
...	@@ -1335,14 +1228,12 @@ pub const Reader = struct {	...	@@ -1335,14 +1228,12 @@ pub const Reader = struct {
1335	pub fn seekBy(r: *Reader, offset: i64) Reader.SeekError!void {	1228	pub fn seekBy(r: *Reader, offset: i64) Reader.SeekError!void {
1336	switch (r.mode) {	1229	switch (r.mode) {
1337	.positional, .positional_reading => {	1230	.positional, .positional_reading => {
1338	// TODO: make += operator allow any integer types	1231	setPosAdjustingBuffer(r, @intCast(@as(i64, @intCast(r.pos)) + offset));
1339	r.pos = @intCast(@as(i64, @intCast(r.pos)) + offset);
1340	},	1232	},
1341	.streaming, .streaming_reading => {	1233	.streaming, .streaming_reading => {
1342	const seek_err = r.seek_err orelse e: {	1234	const seek_err = r.seek_err orelse e: {
1343	if (posix.lseek_CUR(r.file.handle, offset)) \|_\| {	1235	if (posix.lseek_CUR(r.file.handle, offset)) \|_\| {
1344	// TODO: make += operator allow any integer types	1236	setPosAdjustingBuffer(r, @intCast(@as(i64, @intCast(r.pos)) + offset));
1345	r.pos = @intCast(@as(i64, @intCast(r.pos)) + offset);
1346	return;	1237	return;
1347	} else \|err\| {	1238	} else \|err\| {
1348	r.seek_err = err;	1239	r.seek_err = err;
...	@@ -1358,6 +1249,8 @@ pub const Reader = struct {	...	@@ -1358,6 +1249,8 @@ pub const Reader = struct {
1358	r.pos += n;	1249	r.pos += n;
1359	remaining -= n;	1250	remaining -= n;
1360	}	1251	}
		1252	r.interface.seek = 0;
		1253	r.interface.end = 0;
1361	},	1254	},
1362	.failure => return r.seek_err.?,	1255	.failure => return r.seek_err.?,
1363	}	1256	}
...	@@ -1366,7 +1259,7 @@ pub const Reader = struct {	...	@@ -1366,7 +1259,7 @@ pub const Reader = struct {
1366	pub fn seekTo(r: *Reader, offset: u64) Reader.SeekError!void {	1259	pub fn seekTo(r: *Reader, offset: u64) Reader.SeekError!void {
1367	switch (r.mode) {	1260	switch (r.mode) {
1368	.positional, .positional_reading => {	1261	.positional, .positional_reading => {
1369	r.pos = offset;	1262	setPosAdjustingBuffer(r, offset);
1370	},	1263	},
1371	.streaming, .streaming_reading => {	1264	.streaming, .streaming_reading => {
1372	if (offset >= r.pos) return Reader.seekBy(r, @intCast(offset - r.pos));	1265	if (offset >= r.pos) return Reader.seekBy(r, @intCast(offset - r.pos));
...	@@ -1375,12 +1268,28 @@ pub const Reader = struct {	...	@@ -1375,12 +1268,28 @@ pub const Reader = struct {
1375	r.seek_err = err;	1268	r.seek_err = err;
1376	return err;	1269	return err;
1377	};	1270	};
1378	r.pos = offset;	1271	setPosAdjustingBuffer(r, offset);
1379	},	1272	},
1380	.failure => return r.seek_err.?,	1273	.failure => return r.seek_err.?,
1381	}	1274	}
1382	}	1275	}
1383		1276
		1277	pub fn logicalPos(r: *const Reader) u64 {
		1278	return r.pos - r.interface.bufferedLen();
		1279	}
		1280
		1281	fn setPosAdjustingBuffer(r: *Reader, offset: u64) void {
		1282	const logical_pos = logicalPos(r);
		1283	if (offset < logical_pos or offset >= r.pos) {
		1284	r.interface.seek = 0;
		1285	r.interface.end = 0;
		1286	r.pos = offset;
		1287	} else {
		1288	const logical_delta: usize = @intCast(offset - logical_pos);
		1289	r.interface.seek += logical_delta;
		1290	}
		1291	}
		1292
1384	/// Number of slices to store on the stack, when trying to send as many byte	1293	/// Number of slices to store on the stack, when trying to send as many byte
1385	/// vectors through the underlying read calls as possible.	1294	/// vectors through the underlying read calls as possible.
1386	const max_buffers_len = 16;	1295	const max_buffers_len = 16;
...	@@ -1526,7 +1435,7 @@ pub const Reader = struct {	...	@@ -1526,7 +1435,7 @@ pub const Reader = struct {
1526	}	1435	}
1527	return 0;	1436	return 0;
1528	};	1437	};
1529	const n = @min(size - pos, std.math.maxInt(i64), @intFromEnum(limit));	1438	const n = @min(size - pos, maxInt(i64), @intFromEnum(limit));
1530	file.seekBy(n) catch \|err\| {	1439	file.seekBy(n) catch \|err\| {
1531	r.seek_err = err;	1440	r.seek_err = err;
1532	return 0;	1441	return 0;
...	@@ -1715,7 +1624,6 @@ pub const Writer = struct {	...	@@ -1715,7 +1624,6 @@ pub const Writer = struct {
1715	const pattern = data[data.len - 1];	1624	const pattern = data[data.len - 1];
1716	if (pattern.len == 0 or splat == 0) return 0;	1625	if (pattern.len == 0 or splat == 0) return 0;
1717	const n = windows.WriteFile(handle, pattern, null) catch \|err\| {	1626	const n = windows.WriteFile(handle, pattern, null) catch \|err\| {
1718	std.debug.print("windows write file failed3: {t}\n", .{err});
1719	w.err = err;	1627	w.err = err;
1720	return error.WriteFailed;	1628	return error.WriteFailed;
1721	};	1629	};
...	@@ -1817,18 +1725,141 @@ pub const Writer = struct {	...	@@ -1817,18 +1725,141 @@ pub const Writer = struct {
1817	file_reader: *Reader,	1725	file_reader: *Reader,
1818	limit: std.io.Limit,	1726	limit: std.io.Limit,
1819	) std.io.Writer.FileError!usize {	1727	) std.io.Writer.FileError!usize {
		1728	const reader_buffered = file_reader.interface.buffered();
		1729	if (reader_buffered.len >= @intFromEnum(limit))
		1730	return sendFileBuffered(io_w, file_reader, reader_buffered);
		1731	const writer_buffered = io_w.buffered();
		1732	const file_limit = @intFromEnum(limit) - reader_buffered.len;
1820	const w: *Writer = @alignCast(@fieldParentPtr("interface", io_w));	1733	const w: *Writer = @alignCast(@fieldParentPtr("interface", io_w));
1821	const out_fd = w.file.handle;	1734	const out_fd = w.file.handle;
1822	const in_fd = file_reader.file.handle;	1735	const in_fd = file_reader.file.handle;
1823	// TODO try using copy_file_range on FreeBSD	1736
1824	// TODO try using sendfile on macOS	1737	if (file_reader.size) \|size\| {
1825	// TODO try using sendfile on FreeBSD	1738	if (size - file_reader.pos == 0) {
		1739	if (reader_buffered.len != 0) {
		1740	return sendFileBuffered(io_w, file_reader, reader_buffered);
		1741	} else {
		1742	return error.EndOfStream;
		1743	}
		1744	}
		1745	}
		1746
		1747	if (native_os == .freebsd and w.mode == .streaming) sf: {
		1748	// Try using sendfile on FreeBSD.
		1749	if (w.sendfile_err != null) break :sf;
		1750	const offset = std.math.cast(std.c.off_t, file_reader.pos) orelse break :sf;
		1751	var hdtr_data: std.c.sf_hdtr = undefined;
		1752	var headers: [2]posix.iovec_const = undefined;
		1753	var headers_i: u8 = 0;
		1754	if (writer_buffered.len != 0) {
		1755	headers[headers_i] = .{ .base = writer_buffered.ptr, .len = writer_buffered.len };
		1756	headers_i += 1;
		1757	}
		1758	if (reader_buffered.len != 0) {
		1759	headers[headers_i] = .{ .base = reader_buffered.ptr, .len = reader_buffered.len };
		1760	headers_i += 1;
		1761	}
		1762	const hdtr: ?*std.c.sf_hdtr = if (headers_i == 0) null else b: {
		1763	hdtr_data = .{
		1764	.headers = &headers,
		1765	.hdr_cnt = headers_i,
		1766	.trailers = null,
		1767	.trl_cnt = 0,
		1768	};
		1769	break :b &hdtr_data;
		1770	};
		1771	var sbytes: std.c.off_t = undefined;
		1772	const nbytes: usize = @min(file_limit, maxInt(usize));
		1773	const flags = 0;
		1774	switch (posix.errno(std.c.sendfile(in_fd, out_fd, offset, nbytes, hdtr, &sbytes, flags))) {
		1775	.SUCCESS, .INTR => {},
		1776	.INVAL, .OPNOTSUPP, .NOTSOCK, .NOSYS => w.sendfile_err = error.UnsupportedOperation,
		1777	.BADF => if (builtin.mode == .Debug) @panic("race condition") else {
		1778	w.sendfile_err = error.Unexpected;
		1779	},
		1780	.FAULT => if (builtin.mode == .Debug) @panic("segmentation fault") else {
		1781	w.sendfile_err = error.Unexpected;
		1782	},
		1783	.NOTCONN => w.sendfile_err = error.BrokenPipe,
		1784	.AGAIN, .BUSY => if (sbytes == 0) {
		1785	w.sendfile_err = error.WouldBlock;
		1786	},
		1787	.IO => w.sendfile_err = error.InputOutput,
		1788	.PIPE => w.sendfile_err = error.BrokenPipe,
		1789	.NOBUFS => w.sendfile_err = error.SystemResources,
		1790	else => \|err\| w.sendfile_err = posix.unexpectedErrno(err),
		1791	}
		1792	if (sbytes == 0) {
		1793	file_reader.size = file_reader.pos;
		1794	return error.EndOfStream;
		1795	}
		1796	const consumed = io_w.consume(@intCast(sbytes));
		1797	file_reader.seekTo(file_reader.pos + consumed) catch return error.ReadFailed;
		1798	return consumed;
		1799	}
		1800
		1801	if (native_os.isDarwin() and w.mode == .streaming) sf: {
		1802	// Try using sendfile on macOS.
		1803	if (w.sendfile_err != null) break :sf;
		1804	const offset = std.math.cast(std.c.off_t, file_reader.pos) orelse break :sf;
		1805	var hdtr_data: std.c.sf_hdtr = undefined;
		1806	var headers: [2]posix.iovec_const = undefined;
		1807	var headers_i: u8 = 0;
		1808	if (writer_buffered.len != 0) {
		1809	headers[headers_i] = .{ .base = writer_buffered.ptr, .len = writer_buffered.len };
		1810	headers_i += 1;
		1811	}
		1812	if (reader_buffered.len != 0) {
		1813	headers[headers_i] = .{ .base = reader_buffered.ptr, .len = reader_buffered.len };
		1814	headers_i += 1;
		1815	}
		1816	const hdtr: ?*std.c.sf_hdtr = if (headers_i == 0) null else b: {
		1817	hdtr_data = .{
		1818	.headers = &headers,
		1819	.hdr_cnt = headers_i,
		1820	.trailers = null,
		1821	.trl_cnt = 0,
		1822	};
		1823	break :b &hdtr_data;
		1824	};
		1825	const max_count = maxInt(i32); // Avoid EINVAL.
		1826	var len: std.c.off_t = @min(file_limit, max_count);
		1827	const flags = 0;
		1828	switch (posix.errno(std.c.sendfile(in_fd, out_fd, offset, &len, hdtr, flags))) {
		1829	.SUCCESS, .INTR => {},
		1830	.OPNOTSUPP, .NOTSOCK, .NOSYS => w.sendfile_err = error.UnsupportedOperation,
		1831	.BADF => if (builtin.mode == .Debug) @panic("race condition") else {
		1832	w.sendfile_err = error.Unexpected;
		1833	},
		1834	.FAULT => if (builtin.mode == .Debug) @panic("segmentation fault") else {
		1835	w.sendfile_err = error.Unexpected;
		1836	},
		1837	.INVAL => if (builtin.mode == .Debug) @panic("invalid API usage") else {
		1838	w.sendfile_err = error.Unexpected;
		1839	},
		1840	.NOTCONN => w.sendfile_err = error.BrokenPipe,
		1841	.AGAIN => if (len == 0) {
		1842	w.sendfile_err = error.WouldBlock;
		1843	},
		1844	.IO => w.sendfile_err = error.InputOutput,
		1845	.PIPE => w.sendfile_err = error.BrokenPipe,
		1846	else => \|err\| w.sendfile_err = posix.unexpectedErrno(err),
		1847	}
		1848	if (len == 0) {
		1849	file_reader.size = file_reader.pos;
		1850	return error.EndOfStream;
		1851	}
		1852	const consumed = io_w.consume(@bitCast(len));
		1853	file_reader.seekTo(file_reader.pos + consumed) catch return error.ReadFailed;
		1854	return consumed;
		1855	}
		1856
1826	if (native_os == .linux and w.mode == .streaming) sf: {	1857	if (native_os == .linux and w.mode == .streaming) sf: {
1827	// Try using sendfile on Linux.	1858	// Try using sendfile on Linux.
1828	if (w.sendfile_err != null) break :sf;	1859	if (w.sendfile_err != null) break :sf;
1829	// Linux sendfile does not support headers.	1860	// Linux sendfile does not support headers.
1830	const buffered = limit.slice(file_reader.interface.buffer);	1861	if (writer_buffered.len != 0 or reader_buffered.len != 0)
1831	if (io_w.end != 0 or buffered.len != 0) return drain(io_w, &.{buffered}, 1);	1862	return sendFileBuffered(io_w, file_reader, reader_buffered);
1832	const max_count = 0x7ffff000; // Avoid EINVAL.	1863	const max_count = 0x7ffff000; // Avoid EINVAL.
1833	var off: std.os.linux.off_t = undefined;	1864	var off: std.os.linux.off_t = undefined;
1834	const off_ptr: ?*std.os.linux.off_t, const count: usize = switch (file_reader.mode) {	1865	const off_ptr: ?*std.os.linux.off_t, const count: usize = switch (file_reader.mode) {
...	@@ -1875,6 +1906,7 @@ pub const Writer = struct {	...	@@ -1875,6 +1906,7 @@ pub const Writer = struct {
1875	w.pos += n;	1906	w.pos += n;
1876	return n;	1907	return n;
1877	}	1908	}
		1909
1878	const copy_file_range = switch (native_os) {	1910	const copy_file_range = switch (native_os) {
1879	.freebsd => std.os.freebsd.copy_file_range,	1911	.freebsd => std.os.freebsd.copy_file_range,
1880	.linux => if (std.c.versionCheck(.{ .major = 2, .minor = 27, .patch = 0 })) std.os.linux.wrapped.copy_file_range else {},	1912	.linux => if (std.c.versionCheck(.{ .major = 2, .minor = 27, .patch = 0 })) std.os.linux.wrapped.copy_file_range else {},
...	@@ -1882,8 +1914,8 @@ pub const Writer = struct {	...	@@ -1882,8 +1914,8 @@ pub const Writer = struct {
1882	};	1914	};
1883	if (@TypeOf(copy_file_range) != void) cfr: {	1915	if (@TypeOf(copy_file_range) != void) cfr: {
1884	if (w.copy_file_range_err != null) break :cfr;	1916	if (w.copy_file_range_err != null) break :cfr;
1885	const buffered = limit.slice(file_reader.interface.buffer);	1917	if (writer_buffered.len != 0 or reader_buffered.len != 0)
1886	if (io_w.end != 0 or buffered.len != 0) return drain(io_w, &.{buffered}, 1);	1918	return sendFileBuffered(io_w, file_reader, reader_buffered);
1887	var off_in: i64 = undefined;	1919	var off_in: i64 = undefined;
1888	var off_out: i64 = undefined;	1920	var off_out: i64 = undefined;
1889	const off_in_ptr: ?*i64 = switch (file_reader.mode) {	1921	const off_in_ptr: ?*i64 = switch (file_reader.mode) {
...	@@ -1922,6 +1954,9 @@ pub const Writer = struct {	...	@@ -1922,6 +1954,9 @@ pub const Writer = struct {
1922	if (file_reader.pos != 0) break :fcf;	1954	if (file_reader.pos != 0) break :fcf;
1923	if (w.pos != 0) break :fcf;	1955	if (w.pos != 0) break :fcf;
1924	if (limit != .unlimited) break :fcf;	1956	if (limit != .unlimited) break :fcf;
		1957	const size = file_reader.getSize() catch break :fcf;
		1958	if (writer_buffered.len != 0 or reader_buffered.len != 0)
		1959	return sendFileBuffered(io_w, file_reader, reader_buffered);
1925	const rc = std.c.fcopyfile(in_fd, out_fd, null, .{ .DATA = true });	1960	const rc = std.c.fcopyfile(in_fd, out_fd, null, .{ .DATA = true });
1926	switch (posix.errno(rc)) {	1961	switch (posix.errno(rc)) {
1927	.SUCCESS => {},	1962	.SUCCESS => {},
...	@@ -1942,15 +1977,24 @@ pub const Writer = struct {	...	@@ -1942,15 +1977,24 @@ pub const Writer = struct {
1942	return 0;	1977	return 0;
1943	},	1978	},
1944	}	1979	}
1945	const n = if (file_reader.size) \|size\| size else @panic("TODO figure out how much copied");	1980	file_reader.pos = size;
1946	file_reader.pos = n;	1981	w.pos = size;
1947	w.pos = n;	1982	return size;
1948	return n;
1949	}	1983	}
1950		1984
1951	return error.Unimplemented;	1985	return error.Unimplemented;
1952	}	1986	}
1953		1987
		1988	fn sendFileBuffered(
		1989	io_w: *std.io.Writer,
		1990	file_reader: *Reader,
		1991	reader_buffered: []const u8,
		1992	) std.io.Writer.FileError!usize {
		1993	const n = try drain(io_w, &.{reader_buffered}, 1);
		1994	file_reader.seekTo(file_reader.pos + n) catch return error.ReadFailed;
		1995	return n;
		1996	}
		1997
1954	pub fn seekTo(w: *Writer, offset: u64) SeekError!void {	1998	pub fn seekTo(w: *Writer, offset: u64) SeekError!void {
1955	switch (w.mode) {	1999	switch (w.mode) {
1956	.positional, .positional_reading => {	2000	.positional, .positional_reading => {

lib/std/fs/test.zig+57-29

 @@ -1499,32 +1499,18 @@ test "sendfile" {
     const header2 = "second header\n";
     const trailer1 = "trailer1\n";
     const trailer2 = "second trailer\n";
-    var hdtr = [_]posix.iovec_const{
+    var headers: [2][]const u8 = .{ header1, header2 };
-        .{
+    var trailers: [2][]const u8 = .{ trailer1, trailer2 };
-            .base = header1,
-            .len = header1.len,
-        },
-        .{
-            .base = header2,
-            .len = header2.len,
-        },
-        .{
-            .base = trailer1,
-            .len = trailer1.len,
-        },
-        .{
-            .base = trailer2,
-            .len = trailer2.len,
-        },
-    };
     var written_buf: [100]u8 = undefined;
-    try dest_file.writeFileAll(src_file, .{
+    var file_reader = src_file.reader(&.{});
-        .in_offset = 1,
+    var fallback_buffer: [50]u8 = undefined;
-        .in_len = 10,
+    var file_writer = dest_file.writer(&fallback_buffer);
-        .headers_and_trailers = &hdtr,
+    try file_writer.interface.writeVecAll(&headers);
-        .header_count = 2,
+    try file_reader.seekTo(1);
-    });
+    try testing.expectEqual(10, try file_writer.interface.sendFileAll(&file_reader, .limited(10)));
+    try file_writer.interface.writeVecAll(&trailers);
+    try file_writer.interface.flush();
     const amt = try dest_file.preadAll(&written_buf, 0);
     try testing.expectEqualStrings("header1\nsecond header\nine1\nsecontrailer1\nsecond trailer\n", written_buf[0..amt]);
 }
 @@ -1595,9 +1581,10 @@ test "AtomicFile" {
             ;
             {
-                var af = try ctx.dir.atomicFile(test_out_file, .{});
+                var buffer: [100]u8 = undefined;
+                var af = try ctx.dir.atomicFile(test_out_file, .{ .write_buffer = &buffer });
                 defer af.deinit();
-                try af.file.writeAll(test_content);
+                try af.file_writer.interface.writeAll(test_content);
                 try af.finish();
             }
             const content = try ctx.dir.readFileAlloc(allocator, test_out_file, 9999);
 @@ -2073,7 +2060,7 @@ test "invalid UTF-8/WTF-8 paths" {
 }
 test "read file non vectored" {
-    var tmp_dir = std.testing.tmpDir(.{});
+    var tmp_dir = testing.tmpDir(.{});
     defer tmp_dir.cleanup();
     const contents = "hello, world!\n";
 @@ -2098,6 +2085,47 @@ test "read file non vectored" {
             else => |e| return e,
         };
     }
-    try std.testing.expectEqualStrings(contents, w.buffered());
+    try testing.expectEqualStrings(contents, w.buffered());
-    try std.testing.expectEqual(contents.len, i);
+    try testing.expectEqual(contents.len, i);
+}
+test "seek keeping partial buffer" {
+    var tmp_dir = testing.tmpDir(.{});
+    defer tmp_dir.cleanup();
+    const contents = "0123456789";
+    const file = try tmp_dir.dir.createFile("input.txt", .{ .read = true });
+    defer file.close();
+    {
+        var file_writer: std.fs.File.Writer = .init(file, &.{});
+        try file_writer.interface.writeAll(contents);
+        try file_writer.interface.flush();
+    }
+    var read_buffer: [3]u8 = undefined;
+    var file_reader: std.fs.File.Reader = .init(file, &read_buffer);
+    try testing.expectEqual(0, file_reader.logicalPos());
+    var buf: [4]u8 = undefined;
+    try file_reader.interface.readSliceAll(&buf);
+    if (file_reader.interface.bufferedLen() != 3) {
+        // Pass the test if the OS doesn't give us vectored reads.
+        return;
+    }
+    try testing.expectEqual(4, file_reader.logicalPos());
+    try testing.expectEqual(7, file_reader.pos);
+    try file_reader.seekTo(6);
+    try testing.expectEqual(6, file_reader.logicalPos());
+    try testing.expectEqual(7, file_reader.pos);
+    try testing.expectEqualStrings("0123", &buf);
+    const n = try file_reader.interface.readSliceShort(&buf);
+    try testing.expectEqual(4, n);
+    try testing.expectEqualStrings("6789", &buf);
 }

lib/std/json.zig-1

...	@@ -69,7 +69,6 @@ pub const ArrayHashMap = @import("json/hashmap.zig").ArrayHashMap;	...	@@ -69,7 +69,6 @@ pub const ArrayHashMap = @import("json/hashmap.zig").ArrayHashMap;
69	pub const Scanner = @import("json/Scanner.zig");	69	pub const Scanner = @import("json/Scanner.zig");
70	pub const validate = Scanner.validate;	70	pub const validate = Scanner.validate;
71	pub const Error = Scanner.Error;	71	pub const Error = Scanner.Error;
72	pub const reader = Scanner.reader;
73	pub const default_buffer_size = Scanner.default_buffer_size;	72	pub const default_buffer_size = Scanner.default_buffer_size;
74	pub const Token = Scanner.Token;	73	pub const Token = Scanner.Token;
75	pub const TokenType = Scanner.TokenType;	74	pub const TokenType = Scanner.TokenType;

lib/std/posix.zig-289

...	@@ -6326,295 +6326,6 @@ pub fn send(	...	@@ -6326,295 +6326,6 @@ pub fn send(
6326	};	6326	};
6327	}	6327	}
6328		6328
6329	pub const SendFileError = PReadError \|\| WriteError \|\| SendError;
6330
6331	/// Transfer data between file descriptors, with optional headers and trailers.
6332	///
6333	/// Returns the number of bytes written, which can be zero.
6334	///
6335	/// The `sendfile` call copies `in_len` bytes from one file descriptor to another. When possible,
6336	/// this is done within the operating system kernel, which can provide better performance
6337	/// characteristics than transferring data from kernel to user space and back, such as with
6338	/// `read` and `write` calls. When `in_len` is `0`, it means to copy until the end of the input file has been
6339	/// reached. Note, however, that partial writes are still possible in this case.
6340	///
6341	/// `in_fd` must be a file descriptor opened for reading, and `out_fd` must be a file descriptor
6342	/// opened for writing. They may be any kind of file descriptor; however, if `in_fd` is not a regular
6343	/// file system file, it may cause this function to fall back to calling `read` and `write`, in which case
6344	/// atomicity guarantees no longer apply.
6345	///
6346	/// Copying begins reading at `in_offset`. The input file descriptor seek position is ignored and not updated.
6347	/// If the output file descriptor has a seek position, it is updated as bytes are written. When
6348	/// `in_offset` is past the end of the input file, it successfully reads 0 bytes.
6349	///
6350	/// `flags` has different meanings per operating system; refer to the respective man pages.
6351	///
6352	/// These systems support atomically sending everything, including headers and trailers:
6353	/// * macOS
6354	/// * FreeBSD
6355	///
6356	/// These systems support in-kernel data copying, but headers and trailers are not sent atomically:
6357	/// * Linux
6358	///
6359	/// Other systems fall back to calling `read` / `write`.
6360	///
6361	/// Linux has a limit on how many bytes may be transferred in one `sendfile` call, which is `0x7ffff000`
6362	/// on both 64-bit and 32-bit systems. This is due to using a signed C int as the return value, as
6363	/// well as stuffing the errno codes into the last `4096` values. This is noted on the `sendfile` man page.
6364	/// The limit on Darwin is `0x7fffffff`, trying to write more than that returns EINVAL.
6365	/// The corresponding POSIX limit on this is `maxInt(isize)`.
6366	pub fn sendfile(
6367	out_fd: fd_t,
6368	in_fd: fd_t,
6369	in_offset: u64,
6370	in_len: u64,
6371	headers: []const iovec_const,
6372	trailers: []const iovec_const,
6373	flags: u32,
6374	) SendFileError!usize {
6375	var header_done = false;
6376	var total_written: usize = 0;
6377
6378	// Prevents EOVERFLOW.
6379	const size_t = std.meta.Int(.unsigned, @typeInfo(usize).int.bits - 1);
6380	const max_count = switch (native_os) {
6381	.linux => 0x7ffff000,
6382	.macos, .ios, .watchos, .tvos, .visionos => maxInt(i32),
6383	else => maxInt(size_t),
6384	};
6385
6386	switch (native_os) {
6387	.linux => sf: {
6388	if (headers.len != 0) {
6389	const amt = try writev(out_fd, headers);
6390	total_written += amt;
6391	if (amt < count_iovec_bytes(headers)) return total_written;
6392	header_done = true;
6393	}
6394
6395	// Here we match BSD behavior, making a zero count value send as many bytes as possible.
6396	const adjusted_count = if (in_len == 0) max_count else @min(in_len, max_count);
6397
6398	const sendfile_sym = if (lfs64_abi) system.sendfile64 else system.sendfile;
6399	while (true) {
6400	var offset: off_t = @bitCast(in_offset);
6401	const rc = sendfile_sym(out_fd, in_fd, &offset, adjusted_count);
6402	switch (errno(rc)) {
6403	.SUCCESS => {
6404	const amt: usize = @bitCast(rc);
6405	total_written += amt;
6406	if (in_len == 0 and amt == 0) {
6407	// We have detected EOF from `in_fd`.
6408	break;
6409	} else if (amt < in_len) {
6410	return total_written;
6411	} else {
6412	break;
6413	}
6414	},
6415
6416	.BADF => unreachable, // Always a race condition.
6417	.FAULT => unreachable, // Segmentation fault.
6418	.OVERFLOW => unreachable, // We avoid passing too large of a `count`.
6419	.NOTCONN => return error.BrokenPipe, // `out_fd` is an unconnected socket
6420
6421	.INVAL => {
6422	// EINVAL could be any of the following situations:
6423	// * Descriptor is not valid or locked
6424	// * an mmap(2)-like operation is not available for in_fd
6425	// * count is negative
6426	// * out_fd has the APPEND flag set
6427	// Because of the "mmap(2)-like operation" possibility, we fall back to doing read/write
6428	// manually.
6429	break :sf;
6430	},
6431	.AGAIN => return error.WouldBlock,
6432	.IO => return error.InputOutput,
6433	.PIPE => return error.BrokenPipe,
6434	.NOMEM => return error.SystemResources,
6435	.NXIO => return error.Unseekable,
6436	.SPIPE => return error.Unseekable,
6437	else => \|err\| {
6438	unexpectedErrno(err) catch {};
6439	break :sf;
6440	},
6441	}
6442	}
6443
6444	if (trailers.len != 0) {
6445	total_written += try writev(out_fd, trailers);
6446	}
6447
6448	return total_written;
6449	},
6450	.freebsd => sf: {
6451	var hdtr_data: std.c.sf_hdtr = undefined;
6452	var hdtr: ?*std.c.sf_hdtr = null;
6453	if (headers.len != 0 or trailers.len != 0) {
6454	// Here we carefully avoid `@intCast` by returning partial writes when
6455	// too many io vectors are provided.
6456	const hdr_cnt = cast(u31, headers.len) orelse maxInt(u31);
6457	if (headers.len > hdr_cnt) return writev(out_fd, headers);
6458
6459	const trl_cnt = cast(u31, trailers.len) orelse maxInt(u31);
6460
6461	hdtr_data = std.c.sf_hdtr{
6462	.headers = headers.ptr,
6463	.hdr_cnt = hdr_cnt,
6464	.trailers = trailers.ptr,
6465	.trl_cnt = trl_cnt,
6466	};
6467	hdtr = &hdtr_data;
6468	}
6469
6470	while (true) {
6471	var sbytes: off_t = undefined;
6472	const err = errno(system.sendfile(in_fd, out_fd, @bitCast(in_offset), @min(in_len, max_count), hdtr, &sbytes, flags));
6473	const amt: usize = @bitCast(sbytes);
6474	switch (err) {
6475	.SUCCESS => return amt,
6476
6477	.BADF => unreachable, // Always a race condition.
6478	.FAULT => unreachable, // Segmentation fault.
6479	.NOTCONN => return error.BrokenPipe, // `out_fd` is an unconnected socket
6480
6481	.INVAL, .OPNOTSUPP, .NOTSOCK, .NOSYS => {
6482	// EINVAL could be any of the following situations:
6483	// * The fd argument is not a regular file.
6484	// * The s argument is not a SOCK.STREAM type socket.
6485	// * The offset argument is negative.
6486	// Because of some of these possibilities, we fall back to doing read/write
6487	// manually, the same as ENOSYS.
6488	break :sf;
6489	},
6490
6491	.INTR => if (amt != 0) return amt else continue,
6492
6493	.AGAIN => if (amt != 0) {
6494	return amt;
6495	} else {
6496	return error.WouldBlock;
6497	},
6498
6499	.BUSY => if (amt != 0) {
6500	return amt;
6501	} else {
6502	return error.WouldBlock;
6503	},
6504
6505	.IO => return error.InputOutput,
6506	.NOBUFS => return error.SystemResources,
6507	.PIPE => return error.BrokenPipe,
6508
6509	else => {
6510	unexpectedErrno(err) catch {};
6511	if (amt != 0) {
6512	return amt;
6513	} else {
6514	break :sf;
6515	}
6516	},
6517	}
6518	}
6519	},
6520	.macos, .ios, .tvos, .watchos, .visionos => sf: {
6521	var hdtr_data: std.c.sf_hdtr = undefined;
6522	var hdtr: ?*std.c.sf_hdtr = null;
6523	if (headers.len != 0 or trailers.len != 0) {
6524	// Here we carefully avoid `@intCast` by returning partial writes when
6525	// too many io vectors are provided.
6526	const hdr_cnt = cast(u31, headers.len) orelse maxInt(u31);
6527	if (headers.len > hdr_cnt) return writev(out_fd, headers);
6528
6529	const trl_cnt = cast(u31, trailers.len) orelse maxInt(u31);
6530
6531	hdtr_data = std.c.sf_hdtr{
6532	.headers = headers.ptr,
6533	.hdr_cnt = hdr_cnt,
6534	.trailers = trailers.ptr,
6535	.trl_cnt = trl_cnt,
6536	};
6537	hdtr = &hdtr_data;
6538	}
6539
6540	while (true) {
6541	var sbytes: off_t = @min(in_len, max_count);
6542	const err = errno(system.sendfile(in_fd, out_fd, @bitCast(in_offset), &sbytes, hdtr, flags));
6543	const amt: usize = @bitCast(sbytes);
6544	switch (err) {
6545	.SUCCESS => return amt,
6546
6547	.BADF => unreachable, // Always a race condition.
6548	.FAULT => unreachable, // Segmentation fault.
6549	.INVAL => unreachable,
6550	.NOTCONN => return error.BrokenPipe, // `out_fd` is an unconnected socket
6551
6552	.OPNOTSUPP, .NOTSOCK, .NOSYS => break :sf,
6553
6554	.INTR => if (amt != 0) return amt else continue,
6555
6556	.AGAIN => if (amt != 0) {
6557	return amt;
6558	} else {
6559	return error.WouldBlock;
6560	},
6561
6562	.IO => return error.InputOutput,
6563	.PIPE => return error.BrokenPipe,
6564
6565	else => {
6566	unexpectedErrno(err) catch {};
6567	if (amt != 0) {
6568	return amt;
6569	} else {
6570	break :sf;
6571	}
6572	},
6573	}
6574	}
6575	},
6576	else => {}, // fall back to read/write
6577	}
6578
6579	if (headers.len != 0 and !header_done) {
6580	const amt = try writev(out_fd, headers);
6581	total_written += amt;
6582	if (amt < count_iovec_bytes(headers)) return total_written;
6583	}
6584
6585	rw: {
6586	var buf: [8 * 4096]u8 = undefined;
6587	// Here we match BSD behavior, making a zero count value send as many bytes as possible.
6588	const adjusted_count = if (in_len == 0) buf.len else @min(buf.len, in_len);
6589	const amt_read = try pread(in_fd, buf[0..adjusted_count], in_offset);
6590	if (amt_read == 0) {
6591	if (in_len == 0) {
6592	// We have detected EOF from `in_fd`.
6593	break :rw;
6594	} else {
6595	return total_written;
6596	}
6597	}
6598	const amt_written = try write(out_fd, buf[0..amt_read]);
6599	total_written += amt_written;
6600	if (amt_written < in_len or in_len == 0) return total_written;
6601	}
6602
6603	if (trailers.len != 0) {
6604	total_written += try writev(out_fd, trailers);
6605	}
6606
6607	return total_written;
6608	}
6609
6610	fn count_iovec_bytes(iovs: []const iovec_const) usize {
6611	var count: usize = 0;
6612	for (iovs) \|iov\| {
6613	count += iov.len;
6614	}
6615	return count;
6616	}
6617
6618	pub const CopyFileRangeError = error{	6329	pub const CopyFileRangeError = error{
6619	FileTooBig,	6330	FileTooBig,
6620	InputOutput,	6331	InputOutput,

src/Builtin.zig+2-2

...	@@ -342,9 +342,9 @@ pub fn updateFileOnDisk(file: File, comp: Compilation) !void {	...	@@ -342,9 +342,9 @@ pub fn updateFileOnDisk(file: File, comp: Compilation) !void {
342	}	342	}
343		343
344	// `make_path` matters because the dir hasn't actually been created yet.	344	// `make_path` matters because the dir hasn't actually been created yet.
345	var af = try root_dir.atomicFile(sub_path, .{ .make_path = true });	345	var af = try root_dir.atomicFile(sub_path, .{ .make_path = true, .write_buffer = &.{} });
346	defer af.deinit();	346	defer af.deinit();
347	try af.file.writeAll(file.source.?);	347	try af.file_writer.interface.writeAll(file.source.?);
348	af.finish() catch \|err\| switch (err) {	348	af.finish() catch \|err\| switch (err) {
349	error.AccessDenied => switch (builtin.os.tag) {	349	error.AccessDenied => switch (builtin.os.tag) {
350	.windows => {	350	.windows => {

src/Compilation.zig+117-117

...	@@ -3382,7 +3382,7 @@ pub fn saveState(comp: *Compilation) !void {	...	@@ -3382,7 +3382,7 @@ pub fn saveState(comp: *Compilation) !void {
3382		3382
3383	const gpa = comp.gpa;	3383	const gpa = comp.gpa;
3384		3384
3385	var bufs = std.ArrayList(std.posix.iovec_const).init(gpa);	3385	var bufs = std.ArrayList([]const u8).init(gpa);
3386	defer bufs.deinit();	3386	defer bufs.deinit();
3387		3387
3388	var pt_headers = std.ArrayList(Header.PerThread).init(gpa);	3388	var pt_headers = std.ArrayList(Header.PerThread).init(gpa);
...	@@ -3421,50 +3421,50 @@ pub fn saveState(comp: *Compilation) !void {	...	@@ -3421,50 +3421,50 @@ pub fn saveState(comp: *Compilation) !void {
3421		3421
3422	try bufs.ensureTotalCapacityPrecise(14 + 8 * pt_headers.items.len);	3422	try bufs.ensureTotalCapacityPrecise(14 + 8 * pt_headers.items.len);
3423	addBuf(&bufs, mem.asBytes(&header));	3423	addBuf(&bufs, mem.asBytes(&header));
3424	addBuf(&bufs, mem.sliceAsBytes(pt_headers.items));	3424	addBuf(&bufs, @ptrCast(pt_headers.items));
3425		3425
3426	addBuf(&bufs, mem.sliceAsBytes(ip.src_hash_deps.keys()));	3426	addBuf(&bufs, @ptrCast(ip.src_hash_deps.keys()));
3427	addBuf(&bufs, mem.sliceAsBytes(ip.src_hash_deps.values()));	3427	addBuf(&bufs, @ptrCast(ip.src_hash_deps.values()));
3428	addBuf(&bufs, mem.sliceAsBytes(ip.nav_val_deps.keys()));	3428	addBuf(&bufs, @ptrCast(ip.nav_val_deps.keys()));
3429	addBuf(&bufs, mem.sliceAsBytes(ip.nav_val_deps.values()));	3429	addBuf(&bufs, @ptrCast(ip.nav_val_deps.values()));
3430	addBuf(&bufs, mem.sliceAsBytes(ip.nav_ty_deps.keys()));	3430	addBuf(&bufs, @ptrCast(ip.nav_ty_deps.keys()));
3431	addBuf(&bufs, mem.sliceAsBytes(ip.nav_ty_deps.values()));	3431	addBuf(&bufs, @ptrCast(ip.nav_ty_deps.values()));
3432	addBuf(&bufs, mem.sliceAsBytes(ip.interned_deps.keys()));	3432	addBuf(&bufs, @ptrCast(ip.interned_deps.keys()));
3433	addBuf(&bufs, mem.sliceAsBytes(ip.interned_deps.values()));	3433	addBuf(&bufs, @ptrCast(ip.interned_deps.values()));
3434	addBuf(&bufs, mem.sliceAsBytes(ip.zon_file_deps.keys()));	3434	addBuf(&bufs, @ptrCast(ip.zon_file_deps.keys()));
3435	addBuf(&bufs, mem.sliceAsBytes(ip.zon_file_deps.values()));	3435	addBuf(&bufs, @ptrCast(ip.zon_file_deps.values()));
3436	addBuf(&bufs, mem.sliceAsBytes(ip.embed_file_deps.keys()));	3436	addBuf(&bufs, @ptrCast(ip.embed_file_deps.keys()));
3437	addBuf(&bufs, mem.sliceAsBytes(ip.embed_file_deps.values()));	3437	addBuf(&bufs, @ptrCast(ip.embed_file_deps.values()));
3438	addBuf(&bufs, mem.sliceAsBytes(ip.namespace_deps.keys()));	3438	addBuf(&bufs, @ptrCast(ip.namespace_deps.keys()));
3439	addBuf(&bufs, mem.sliceAsBytes(ip.namespace_deps.values()));	3439	addBuf(&bufs, @ptrCast(ip.namespace_deps.values()));
3440	addBuf(&bufs, mem.sliceAsBytes(ip.namespace_name_deps.keys()));	3440	addBuf(&bufs, @ptrCast(ip.namespace_name_deps.keys()));
3441	addBuf(&bufs, mem.sliceAsBytes(ip.namespace_name_deps.values()));	3441	addBuf(&bufs, @ptrCast(ip.namespace_name_deps.values()));
3442		3442
3443	addBuf(&bufs, mem.sliceAsBytes(ip.first_dependency.keys()));	3443	addBuf(&bufs, @ptrCast(ip.first_dependency.keys()));
3444	addBuf(&bufs, mem.sliceAsBytes(ip.first_dependency.values()));	3444	addBuf(&bufs, @ptrCast(ip.first_dependency.values()));
3445	addBuf(&bufs, mem.sliceAsBytes(ip.dep_entries.items));	3445	addBuf(&bufs, @ptrCast(ip.dep_entries.items));
3446	addBuf(&bufs, mem.sliceAsBytes(ip.free_dep_entries.items));	3446	addBuf(&bufs, @ptrCast(ip.free_dep_entries.items));
3447		3447
3448	for (ip.locals, pt_headers.items) \|*local, pt_header\| {	3448	for (ip.locals, pt_headers.items) \|*local, pt_header\| {
3449	if (pt_header.intern_pool.limbs_len > 0) {	3449	if (pt_header.intern_pool.limbs_len > 0) {
3450	addBuf(&bufs, mem.sliceAsBytes(local.shared.limbs.view().items(.@"0")[0..pt_header.intern_pool.limbs_len]));	3450	addBuf(&bufs, @ptrCast(local.shared.limbs.view().items(.@"0")[0..pt_header.intern_pool.limbs_len]));
3451	}	3451	}
3452	if (pt_header.intern_pool.extra_len > 0) {	3452	if (pt_header.intern_pool.extra_len > 0) {
3453	addBuf(&bufs, mem.sliceAsBytes(local.shared.extra.view().items(.@"0")[0..pt_header.intern_pool.extra_len]));	3453	addBuf(&bufs, @ptrCast(local.shared.extra.view().items(.@"0")[0..pt_header.intern_pool.extra_len]));
3454	}	3454	}
3455	if (pt_header.intern_pool.items_len > 0) {	3455	if (pt_header.intern_pool.items_len > 0) {
3456	addBuf(&bufs, mem.sliceAsBytes(local.shared.items.view().items(.data)[0..pt_header.intern_pool.items_len]));	3456	addBuf(&bufs, @ptrCast(local.shared.items.view().items(.data)[0..pt_header.intern_pool.items_len]));
3457	addBuf(&bufs, mem.sliceAsBytes(local.shared.items.view().items(.tag)[0..pt_header.intern_pool.items_len]));	3457	addBuf(&bufs, @ptrCast(local.shared.items.view().items(.tag)[0..pt_header.intern_pool.items_len]));
3458	}	3458	}
3459	if (pt_header.intern_pool.string_bytes_len > 0) {	3459	if (pt_header.intern_pool.string_bytes_len > 0) {
3460	addBuf(&bufs, local.shared.strings.view().items(.@"0")[0..pt_header.intern_pool.string_bytes_len]);	3460	addBuf(&bufs, local.shared.strings.view().items(.@"0")[0..pt_header.intern_pool.string_bytes_len]);
3461	}	3461	}
3462	if (pt_header.intern_pool.tracked_insts_len > 0) {	3462	if (pt_header.intern_pool.tracked_insts_len > 0) {
3463	addBuf(&bufs, mem.sliceAsBytes(local.shared.tracked_insts.view().items(.@"0")[0..pt_header.intern_pool.tracked_insts_len]));	3463	addBuf(&bufs, @ptrCast(local.shared.tracked_insts.view().items(.@"0")[0..pt_header.intern_pool.tracked_insts_len]));
3464	}	3464	}
3465	if (pt_header.intern_pool.files_len > 0) {	3465	if (pt_header.intern_pool.files_len > 0) {
3466	addBuf(&bufs, mem.sliceAsBytes(local.shared.files.view().items(.bin_digest)[0..pt_header.intern_pool.files_len]));	3466	addBuf(&bufs, @ptrCast(local.shared.files.view().items(.bin_digest)[0..pt_header.intern_pool.files_len]));
3467	addBuf(&bufs, mem.sliceAsBytes(local.shared.files.view().items(.root_type)[0..pt_header.intern_pool.files_len]));	3467	addBuf(&bufs, @ptrCast(local.shared.files.view().items(.root_type)[0..pt_header.intern_pool.files_len]));
3468	}	3468	}
3469	}	3469	}
3470		3470
...	@@ -3482,95 +3482,95 @@ pub fn saveState(comp: *Compilation) !void {	...	@@ -3482,95 +3482,95 @@ pub fn saveState(comp: *Compilation) !void {
3482	try bufs.ensureUnusedCapacity(85);	3482	try bufs.ensureUnusedCapacity(85);
3483	addBuf(&bufs, wasm.string_bytes.items);	3483	addBuf(&bufs, wasm.string_bytes.items);
3484	// TODO make it well-defined memory layout	3484	// TODO make it well-defined memory layout
3485	//addBuf(&bufs, mem.sliceAsBytes(wasm.objects.items));	3485	//addBuf(&bufs, @ptrCast(wasm.objects.items));
3486	addBuf(&bufs, mem.sliceAsBytes(wasm.func_types.keys()));	3486	addBuf(&bufs, @ptrCast(wasm.func_types.keys()));
3487	addBuf(&bufs, mem.sliceAsBytes(wasm.object_function_imports.keys()));	3487	addBuf(&bufs, @ptrCast(wasm.object_function_imports.keys()));
3488	addBuf(&bufs, mem.sliceAsBytes(wasm.object_function_imports.values()));	3488	addBuf(&bufs, @ptrCast(wasm.object_function_imports.values()));
3489	addBuf(&bufs, mem.sliceAsBytes(wasm.object_functions.items));	3489	addBuf(&bufs, @ptrCast(wasm.object_functions.items));
3490	addBuf(&bufs, mem.sliceAsBytes(wasm.object_global_imports.keys()));	3490	addBuf(&bufs, @ptrCast(wasm.object_global_imports.keys()));
3491	addBuf(&bufs, mem.sliceAsBytes(wasm.object_global_imports.values()));	3491	addBuf(&bufs, @ptrCast(wasm.object_global_imports.values()));
3492	addBuf(&bufs, mem.sliceAsBytes(wasm.object_globals.items));	3492	addBuf(&bufs, @ptrCast(wasm.object_globals.items));
3493	addBuf(&bufs, mem.sliceAsBytes(wasm.object_table_imports.keys()));	3493	addBuf(&bufs, @ptrCast(wasm.object_table_imports.keys()));
3494	addBuf(&bufs, mem.sliceAsBytes(wasm.object_table_imports.values()));	3494	addBuf(&bufs, @ptrCast(wasm.object_table_imports.values()));
3495	addBuf(&bufs, mem.sliceAsBytes(wasm.object_tables.items));	3495	addBuf(&bufs, @ptrCast(wasm.object_tables.items));
3496	addBuf(&bufs, mem.sliceAsBytes(wasm.object_memory_imports.keys()));	3496	addBuf(&bufs, @ptrCast(wasm.object_memory_imports.keys()));
3497	addBuf(&bufs, mem.sliceAsBytes(wasm.object_memory_imports.values()));	3497	addBuf(&bufs, @ptrCast(wasm.object_memory_imports.values()));
3498	addBuf(&bufs, mem.sliceAsBytes(wasm.object_memories.items));	3498	addBuf(&bufs, @ptrCast(wasm.object_memories.items));
3499	addBuf(&bufs, mem.sliceAsBytes(wasm.object_relocations.items(.tag)));	3499	addBuf(&bufs, @ptrCast(wasm.object_relocations.items(.tag)));
3500	addBuf(&bufs, mem.sliceAsBytes(wasm.object_relocations.items(.offset)));	3500	addBuf(&bufs, @ptrCast(wasm.object_relocations.items(.offset)));
3501	// TODO handle the union safety field	3501	// TODO handle the union safety field
3502	//addBuf(&bufs, mem.sliceAsBytes(wasm.object_relocations.items(.pointee)));	3502	//addBuf(&bufs, @ptrCast(wasm.object_relocations.items(.pointee)));
3503	addBuf(&bufs, mem.sliceAsBytes(wasm.object_relocations.items(.addend)));	3503	addBuf(&bufs, @ptrCast(wasm.object_relocations.items(.addend)));
3504	addBuf(&bufs, mem.sliceAsBytes(wasm.object_init_funcs.items));	3504	addBuf(&bufs, @ptrCast(wasm.object_init_funcs.items));
3505	addBuf(&bufs, mem.sliceAsBytes(wasm.object_data_segments.items));	3505	addBuf(&bufs, @ptrCast(wasm.object_data_segments.items));
3506	addBuf(&bufs, mem.sliceAsBytes(wasm.object_datas.items));	3506	addBuf(&bufs, @ptrCast(wasm.object_datas.items));
3507	addBuf(&bufs, mem.sliceAsBytes(wasm.object_data_imports.keys()));	3507	addBuf(&bufs, @ptrCast(wasm.object_data_imports.keys()));
3508	addBuf(&bufs, mem.sliceAsBytes(wasm.object_data_imports.values()));	3508	addBuf(&bufs, @ptrCast(wasm.object_data_imports.values()));
3509	addBuf(&bufs, mem.sliceAsBytes(wasm.object_custom_segments.keys()));	3509	addBuf(&bufs, @ptrCast(wasm.object_custom_segments.keys()));
3510	addBuf(&bufs, mem.sliceAsBytes(wasm.object_custom_segments.values()));	3510	addBuf(&bufs, @ptrCast(wasm.object_custom_segments.values()));
3511	// TODO make it well-defined memory layout	3511	// TODO make it well-defined memory layout
3512	// addBuf(&bufs, mem.sliceAsBytes(wasm.object_comdats.items));	3512	// addBuf(&bufs, @ptrCast(wasm.object_comdats.items));
3513	addBuf(&bufs, mem.sliceAsBytes(wasm.object_relocations_table.keys()));	3513	addBuf(&bufs, @ptrCast(wasm.object_relocations_table.keys()));
3514	addBuf(&bufs, mem.sliceAsBytes(wasm.object_relocations_table.values()));	3514	addBuf(&bufs, @ptrCast(wasm.object_relocations_table.values()));
3515	addBuf(&bufs, mem.sliceAsBytes(wasm.object_comdat_symbols.items(.kind)));	3515	addBuf(&bufs, @ptrCast(wasm.object_comdat_symbols.items(.kind)));
3516	addBuf(&bufs, mem.sliceAsBytes(wasm.object_comdat_symbols.items(.index)));	3516	addBuf(&bufs, @ptrCast(wasm.object_comdat_symbols.items(.index)));
3517	addBuf(&bufs, mem.sliceAsBytes(wasm.out_relocs.items(.tag)));	3517	addBuf(&bufs, @ptrCast(wasm.out_relocs.items(.tag)));
3518	addBuf(&bufs, mem.sliceAsBytes(wasm.out_relocs.items(.offset)));	3518	addBuf(&bufs, @ptrCast(wasm.out_relocs.items(.offset)));
3519	// TODO handle the union safety field	3519	// TODO handle the union safety field
3520	//addBuf(&bufs, mem.sliceAsBytes(wasm.out_relocs.items(.pointee)));	3520	//addBuf(&bufs, @ptrCast(wasm.out_relocs.items(.pointee)));
3521	addBuf(&bufs, mem.sliceAsBytes(wasm.out_relocs.items(.addend)));	3521	addBuf(&bufs, @ptrCast(wasm.out_relocs.items(.addend)));
3522	addBuf(&bufs, mem.sliceAsBytes(wasm.uav_fixups.items));	3522	addBuf(&bufs, @ptrCast(wasm.uav_fixups.items));
3523	addBuf(&bufs, mem.sliceAsBytes(wasm.nav_fixups.items));	3523	addBuf(&bufs, @ptrCast(wasm.nav_fixups.items));
3524	addBuf(&bufs, mem.sliceAsBytes(wasm.func_table_fixups.items));	3524	addBuf(&bufs, @ptrCast(wasm.func_table_fixups.items));
3525	if (is_obj) {	3525	if (is_obj) {
3526	addBuf(&bufs, mem.sliceAsBytes(wasm.navs_obj.keys()));	3526	addBuf(&bufs, @ptrCast(wasm.navs_obj.keys()));
3527	addBuf(&bufs, mem.sliceAsBytes(wasm.navs_obj.values()));	3527	addBuf(&bufs, @ptrCast(wasm.navs_obj.values()));
3528	addBuf(&bufs, mem.sliceAsBytes(wasm.uavs_obj.keys()));	3528	addBuf(&bufs, @ptrCast(wasm.uavs_obj.keys()));
3529	addBuf(&bufs, mem.sliceAsBytes(wasm.uavs_obj.values()));	3529	addBuf(&bufs, @ptrCast(wasm.uavs_obj.values()));
3530	} else {	3530	} else {
3531	addBuf(&bufs, mem.sliceAsBytes(wasm.navs_exe.keys()));	3531	addBuf(&bufs, @ptrCast(wasm.navs_exe.keys()));
3532	addBuf(&bufs, mem.sliceAsBytes(wasm.navs_exe.values()));	3532	addBuf(&bufs, @ptrCast(wasm.navs_exe.values()));
3533	addBuf(&bufs, mem.sliceAsBytes(wasm.uavs_exe.keys()));	3533	addBuf(&bufs, @ptrCast(wasm.uavs_exe.keys()));
3534	addBuf(&bufs, mem.sliceAsBytes(wasm.uavs_exe.values()));	3534	addBuf(&bufs, @ptrCast(wasm.uavs_exe.values()));
3535	}	3535	}
3536	addBuf(&bufs, mem.sliceAsBytes(wasm.overaligned_uavs.keys()));	3536	addBuf(&bufs, @ptrCast(wasm.overaligned_uavs.keys()));
3537	addBuf(&bufs, mem.sliceAsBytes(wasm.overaligned_uavs.values()));	3537	addBuf(&bufs, @ptrCast(wasm.overaligned_uavs.values()));
3538	addBuf(&bufs, mem.sliceAsBytes(wasm.zcu_funcs.keys()));	3538	addBuf(&bufs, @ptrCast(wasm.zcu_funcs.keys()));
3539	// TODO handle the union safety field	3539	// TODO handle the union safety field
3540	// addBuf(&bufs, mem.sliceAsBytes(wasm.zcu_funcs.values()));	3540	// addBuf(&bufs, @ptrCast(wasm.zcu_funcs.values()));
3541	addBuf(&bufs, mem.sliceAsBytes(wasm.nav_exports.keys()));	3541	addBuf(&bufs, @ptrCast(wasm.nav_exports.keys()));
3542	addBuf(&bufs, mem.sliceAsBytes(wasm.nav_exports.values()));	3542	addBuf(&bufs, @ptrCast(wasm.nav_exports.values()));
3543	addBuf(&bufs, mem.sliceAsBytes(wasm.uav_exports.keys()));	3543	addBuf(&bufs, @ptrCast(wasm.uav_exports.keys()));
3544	addBuf(&bufs, mem.sliceAsBytes(wasm.uav_exports.values()));	3544	addBuf(&bufs, @ptrCast(wasm.uav_exports.values()));
3545	addBuf(&bufs, mem.sliceAsBytes(wasm.imports.keys()));	3545	addBuf(&bufs, @ptrCast(wasm.imports.keys()));
3546	addBuf(&bufs, mem.sliceAsBytes(wasm.missing_exports.keys()));	3546	addBuf(&bufs, @ptrCast(wasm.missing_exports.keys()));
3547	addBuf(&bufs, mem.sliceAsBytes(wasm.function_exports.keys()));	3547	addBuf(&bufs, @ptrCast(wasm.function_exports.keys()));
3548	addBuf(&bufs, mem.sliceAsBytes(wasm.function_exports.values()));	3548	addBuf(&bufs, @ptrCast(wasm.function_exports.values()));
3549	addBuf(&bufs, mem.sliceAsBytes(wasm.hidden_function_exports.keys()));	3549	addBuf(&bufs, @ptrCast(wasm.hidden_function_exports.keys()));
3550	addBuf(&bufs, mem.sliceAsBytes(wasm.hidden_function_exports.values()));	3550	addBuf(&bufs, @ptrCast(wasm.hidden_function_exports.values()));
3551	addBuf(&bufs, mem.sliceAsBytes(wasm.global_exports.items));	3551	addBuf(&bufs, @ptrCast(wasm.global_exports.items));
3552	addBuf(&bufs, mem.sliceAsBytes(wasm.functions.keys()));	3552	addBuf(&bufs, @ptrCast(wasm.functions.keys()));
3553	addBuf(&bufs, mem.sliceAsBytes(wasm.function_imports.keys()));	3553	addBuf(&bufs, @ptrCast(wasm.function_imports.keys()));
3554	addBuf(&bufs, mem.sliceAsBytes(wasm.function_imports.values()));	3554	addBuf(&bufs, @ptrCast(wasm.function_imports.values()));
3555	addBuf(&bufs, mem.sliceAsBytes(wasm.data_imports.keys()));	3555	addBuf(&bufs, @ptrCast(wasm.data_imports.keys()));
3556	addBuf(&bufs, mem.sliceAsBytes(wasm.data_imports.values()));	3556	addBuf(&bufs, @ptrCast(wasm.data_imports.values()));
3557	addBuf(&bufs, mem.sliceAsBytes(wasm.data_segments.keys()));	3557	addBuf(&bufs, @ptrCast(wasm.data_segments.keys()));
3558	addBuf(&bufs, mem.sliceAsBytes(wasm.globals.keys()));	3558	addBuf(&bufs, @ptrCast(wasm.globals.keys()));
3559	addBuf(&bufs, mem.sliceAsBytes(wasm.global_imports.keys()));	3559	addBuf(&bufs, @ptrCast(wasm.global_imports.keys()));
3560	addBuf(&bufs, mem.sliceAsBytes(wasm.global_imports.values()));	3560	addBuf(&bufs, @ptrCast(wasm.global_imports.values()));
3561	addBuf(&bufs, mem.sliceAsBytes(wasm.tables.keys()));	3561	addBuf(&bufs, @ptrCast(wasm.tables.keys()));
3562	addBuf(&bufs, mem.sliceAsBytes(wasm.table_imports.keys()));	3562	addBuf(&bufs, @ptrCast(wasm.table_imports.keys()));
3563	addBuf(&bufs, mem.sliceAsBytes(wasm.table_imports.values()));	3563	addBuf(&bufs, @ptrCast(wasm.table_imports.values()));
3564	addBuf(&bufs, mem.sliceAsBytes(wasm.zcu_indirect_function_set.keys()));	3564	addBuf(&bufs, @ptrCast(wasm.zcu_indirect_function_set.keys()));
3565	addBuf(&bufs, mem.sliceAsBytes(wasm.object_indirect_function_import_set.keys()));	3565	addBuf(&bufs, @ptrCast(wasm.object_indirect_function_import_set.keys()));
3566	addBuf(&bufs, mem.sliceAsBytes(wasm.object_indirect_function_set.keys()));	3566	addBuf(&bufs, @ptrCast(wasm.object_indirect_function_set.keys()));
3567	addBuf(&bufs, mem.sliceAsBytes(wasm.mir_instructions.items(.tag)));	3567	addBuf(&bufs, @ptrCast(wasm.mir_instructions.items(.tag)));
3568	// TODO handle the union safety field	3568	// TODO handle the union safety field
3569	//addBuf(&bufs, mem.sliceAsBytes(wasm.mir_instructions.items(.data)));	3569	//addBuf(&bufs, @ptrCast(wasm.mir_instructions.items(.data)));
3570	addBuf(&bufs, mem.sliceAsBytes(wasm.mir_extra.items));	3570	addBuf(&bufs, @ptrCast(wasm.mir_extra.items));
3571	addBuf(&bufs, mem.sliceAsBytes(wasm.mir_locals.items));	3571	addBuf(&bufs, @ptrCast(wasm.mir_locals.items));
3572	addBuf(&bufs, mem.sliceAsBytes(wasm.tag_name_bytes.items));	3572	addBuf(&bufs, @ptrCast(wasm.tag_name_bytes.items));
3573	addBuf(&bufs, mem.sliceAsBytes(wasm.tag_name_offs.items));	3573	addBuf(&bufs, @ptrCast(wasm.tag_name_offs.items));
3574		3574
3575	// TODO add as header fields	3575	// TODO add as header fields
3576	// entry_resolution: FunctionImport.Resolution	3576	// entry_resolution: FunctionImport.Resolution
...	@@ -3596,16 +3596,16 @@ pub fn saveState(comp: *Compilation) !void {	...	@@ -3596,16 +3596,16 @@ pub fn saveState(comp: *Compilation) !void {
3596		3596
3597	// Using an atomic file prevents a crash or power failure from corrupting	3597	// Using an atomic file prevents a crash or power failure from corrupting
3598	// the previous incremental compilation state.	3598	// the previous incremental compilation state.
3599	var af = try lf.emit.root_dir.handle.atomicFile(basename, .{});	3599	var write_buffer: [1024]u8 = undefined;
		3600	var af = try lf.emit.root_dir.handle.atomicFile(basename, .{ .write_buffer = &write_buffer });
3600	defer af.deinit();	3601	defer af.deinit();
3601	try af.file.pwritevAll(bufs.items, 0);	3602	try af.file_writer.interface.writeVecAll(bufs.items);
3602	try af.finish();	3603	try af.finish();
3603	}	3604	}
3604		3605
3605	fn addBuf(list: *std.ArrayList(std.posix.iovec_const), buf: []const u8) void {	3606	fn addBuf(list: *std.ArrayList([]const u8), buf: []const u8) void {
3606	// Even when len=0, the undefined pointer might cause EFAULT.
3607	if (buf.len == 0) return;	3607	if (buf.len == 0) return;
3608	list.appendAssumeCapacity(.{ .base = buf.ptr, .len = buf.len });	3608	list.appendAssumeCapacity(buf);
3609	}	3609	}
3610		3610
3611	/// This function is temporally single-threaded.	3611	/// This function is temporally single-threaded.

src/fmt.zig+2-2

...	@@ -348,10 +348,10 @@ fn fmtPathFile(	...	@@ -348,10 +348,10 @@ fn fmtPathFile(
348	try fmt.stdout_writer.interface.print("{s}\n", .{file_path});	348	try fmt.stdout_writer.interface.print("{s}\n", .{file_path});
349	fmt.any_error = true;	349	fmt.any_error = true;
350	} else {	350	} else {
351	var af = try dir.atomicFile(sub_path, .{ .mode = stat.mode });	351	var af = try dir.atomicFile(sub_path, .{ .mode = stat.mode, .write_buffer = &.{} });
352	defer af.deinit();	352	defer af.deinit();
353		353
354	try af.file.writeAll(fmt.out_buffer.getWritten());	354	try af.file_writer.interface.writeAll(fmt.out_buffer.getWritten());
355	try af.finish();	355	try af.finish();
356	try fmt.stdout_writer.interface.print("{s}\n", .{file_path});	356	try fmt.stdout_writer.interface.print("{s}\n", .{file_path});
357	}	357	}

src/link/MachO.zig-1

...	@@ -612,7 +612,6 @@ pub fn flush(	...	@@ -612,7 +612,6 @@ pub fn flush(
612	};	612	};
613	const emit = self.base.emit;	613	const emit = self.base.emit;
614	invalidateKernelCache(emit.root_dir.handle, emit.sub_path) catch \|err\| switch (err) {	614	invalidateKernelCache(emit.root_dir.handle, emit.sub_path) catch \|err\| switch (err) {
615	error.OutOfMemory => return error.OutOfMemory,
616	else => \|e\| return diags.fail("failed to invalidate kernel cache: {s}", .{@errorName(e)}),	615	else => \|e\| return diags.fail("failed to invalidate kernel cache: {s}", .{@errorName(e)}),
617	};	616	};
618	}	617	}

src/main.zig+3-1

 @@ -4624,7 +4624,9 @@ fn cmdTranslateC(
             fatal("unable to open cached translated zig file '{s}{s}{s}': {s}", .{ path, fs.path.sep_str, out_zig_path, @errorName(err) });
         };
         defer zig_file.close();
-        try fs.File.stdout().writeFileAll(zig_file, .{});
+        var stdout_writer = fs.File.stdout().writer(&stdout_buffer);
+        var file_reader = zig_file.reader(&.{});
+        _ = try stdout_writer.interface.sendFileAll(&file_reader, .unlimited);
         return cleanExit();
     }
 }

test/incremental/fix_many_errors deleted-71

...	@@ -1,71 +0,0 @@
1	#target=x86_64-linux-selfhosted
2	#target=x86_64-linux-cbe
3	#target=x86_64-windows-cbe
4	#update=initial version
5	#file=main.zig
6	pub fn main() !void {}
7	comptime { @compileError("c0"); }
8	comptime { @compileError("c1"); }
9	comptime { @compileError("c2"); }
10	comptime { @compileError("c3"); }
11	comptime { @compileError("c4"); }
12	comptime { @compileError("c5"); }
13	comptime { @compileError("c6"); }
14	comptime { @compileError("c7"); }
15	comptime { @compileError("c8"); }
16	comptime { @compileError("c9"); }
17	export fn f0() void { @compileError("f0"); }
18	export fn f1() void { @compileError("f1"); }
19	export fn f2() void { @compileError("f2"); }
20	export fn f3() void { @compileError("f3"); }
21	export fn f4() void { @compileError("f4"); }
22	export fn f5() void { @compileError("f5"); }
23	export fn f6() void { @compileError("f6"); }
24	export fn f7() void { @compileError("f7"); }
25	export fn f8() void { @compileError("f8"); }
26	export fn f9() void { @compileError("f9"); }
27	#expect_error=main.zig:2:12: error: c0
28	#expect_error=main.zig:3:12: error: c1
29	#expect_error=main.zig:4:12: error: c2
30	#expect_error=main.zig:5:12: error: c3
31	#expect_error=main.zig:6:12: error: c4
32	#expect_error=main.zig:7:12: error: c5
33	#expect_error=main.zig:8:12: error: c6
34	#expect_error=main.zig:9:12: error: c7
35	#expect_error=main.zig:10:12: error: c8
36	#expect_error=main.zig:11:12: error: c9
37	#expect_error=main.zig:12:23: error: f0
38	#expect_error=main.zig:13:23: error: f1
39	#expect_error=main.zig:14:23: error: f2
40	#expect_error=main.zig:15:23: error: f3
41	#expect_error=main.zig:16:23: error: f4
42	#expect_error=main.zig:17:23: error: f5
43	#expect_error=main.zig:18:23: error: f6
44	#expect_error=main.zig:19:23: error: f7
45	#expect_error=main.zig:20:23: error: f8
46	#expect_error=main.zig:21:23: error: f9
47	#update=fix all the errors
48	#file=main.zig
49	pub fn main() !void {}
50	comptime {}
51	comptime {}
52	comptime {}
53	comptime {}
54	comptime {}
55	comptime {}
56	comptime {}
57	comptime {}
58	comptime {}
59	comptime {}
60	export fn f0() void {}
61	export fn f1() void {}
62	export fn f2() void {}
63	export fn f3() void {}
64	export fn f4() void {}
65	export fn f5() void {}
66	export fn f6() void {}
67	export fn f7() void {}
68	export fn f8() void {}
69	export fn f9() void {}
70	const std = @import("std");
71	#expect_stdout=""

test/standalone/stack_iterator/build.zig+64-63

...	@@ -65,69 +65,70 @@ pub fn build(b: *std.Build) void {	...	@@ -65,69 +65,70 @@ pub fn build(b: *std.Build) void {
65	test_step.dependOn(&run_cmd.step);	65	test_step.dependOn(&run_cmd.step);
66	}	66	}
67		67
68	// Unwinding through a C shared library without a frame pointer (libc)	68	// https://github.com/ziglang/zig/issues/24522
69	//	69	//// Unwinding through a C shared library without a frame pointer (libc)
70	// getcontext version: libc	70	////
71	//	71	//// getcontext version: libc
72	// Unwind info type:	72	////
73	// - ELF: DWARF .eh_frame + .debug_frame	73	//// Unwind info type:
74	// - MachO: __unwind_info encodings:	74	//// - ELF: DWARF .eh_frame + .debug_frame
75	// - x86_64: STACK_IMMD, STACK_IND	75	//// - MachO: __unwind_info encodings:
76	// - aarch64: FRAMELESS, DWARF	76	//// - x86_64: STACK_IMMD, STACK_IND
77	{	77	//// - aarch64: FRAMELESS, DWARF
78	const c_shared_lib = b.addLibrary(.{	78	//{
79	.linkage = .dynamic,	79	// const c_shared_lib = b.addLibrary(.{
80	.name = "c_shared_lib",	80	// .linkage = .dynamic,
81	.root_module = b.createModule(.{	81	// .name = "c_shared_lib",
82	.root_source_file = null,	82	// .root_module = b.createModule(.{
83	.target = target,	83	// .root_source_file = null,
84	.optimize = optimize,	84	// .target = target,
85	.link_libc = true,	85	// .optimize = optimize,
86	.strip = false,	86	// .link_libc = true,
87	}),	87	// .strip = false,
88	});	88	// }),
89		89	// });
90	if (target.result.os.tag == .windows)	90
91	c_shared_lib.root_module.addCMacro("LIB_API", "__declspec(dllexport)");	91	// if (target.result.os.tag == .windows)
92		92	// c_shared_lib.root_module.addCMacro("LIB_API", "__declspec(dllexport)");
93	c_shared_lib.root_module.addCSourceFile(.{	93
94	.file = b.path("shared_lib.c"),	94	// c_shared_lib.root_module.addCSourceFile(.{
95	.flags = &.{"-fomit-frame-pointer"},	95	// .file = b.path("shared_lib.c"),
96	});	96	// .flags = &.{"-fomit-frame-pointer"},
97		97	// });
98	const exe = b.addExecutable(.{	98
99	.name = "shared_lib_unwind",	99	// const exe = b.addExecutable(.{
100	.root_module = b.createModule(.{	100	// .name = "shared_lib_unwind",
101	.root_source_file = b.path("shared_lib_unwind.zig"),	101	// .root_module = b.createModule(.{
102	.target = target,	102	// .root_source_file = b.path("shared_lib_unwind.zig"),
103	.optimize = optimize,	103	// .target = target,
104	.unwind_tables = if (target.result.os.tag.isDarwin()) .async else null,	104	// .optimize = optimize,
105	.omit_frame_pointer = true,	105	// .unwind_tables = if (target.result.os.tag.isDarwin()) .async else null,
106	}),	106	// .omit_frame_pointer = true,
107	// zig objcopy doesn't support incremental binaries	107	// }),
108	.use_llvm = true,	108	// // zig objcopy doesn't support incremental binaries
109	});	109	// .use_llvm = true,
110		110	// });
111	exe.linkLibrary(c_shared_lib);	111
112		112	// exe.linkLibrary(c_shared_lib);
113	const run_cmd = b.addRunArtifact(exe);	113
114	test_step.dependOn(&run_cmd.step);	114	// const run_cmd = b.addRunArtifact(exe);
115		115	// test_step.dependOn(&run_cmd.step);
116	// Separate debug info ELF file	116
117	if (target.result.ofmt == .elf) {	117	// // Separate debug info ELF file
118	const filename = b.fmt("{s}_stripped", .{exe.out_filename});	118	// if (target.result.ofmt == .elf) {
119	const stripped_exe = b.addObjCopy(exe.getEmittedBin(), .{	119	// const filename = b.fmt("{s}_stripped", .{exe.out_filename});
120	.basename = filename, // set the name for the debuglink	120	// const stripped_exe = b.addObjCopy(exe.getEmittedBin(), .{
121	.compress_debug = true,	121	// .basename = filename, // set the name for the debuglink
122	.strip = .debug,	122	// .compress_debug = true,
123	.extract_to_separate_file = true,	123	// .strip = .debug,
124	});	124	// .extract_to_separate_file = true,
125		125	// });
126	const run_stripped = std.Build.Step.Run.create(b, b.fmt("run {s}", .{filename}));	126
127	run_stripped.addFileArg(stripped_exe.getOutput());	127	// const run_stripped = std.Build.Step.Run.create(b, b.fmt("run {s}", .{filename}));
128	test_step.dependOn(&run_stripped.step);	128	// run_stripped.addFileArg(stripped_exe.getOutput());
129	}	129	// test_step.dependOn(&run_stripped.step);
130	}	130	// }
		131	//}
131		132
132	// Unwinding without libc/posix	133	// Unwinding without libc/posix
133	//	134	//

tools/gen_stubs.zig+2-1

...	@@ -310,7 +310,8 @@ pub fn main() !void {	...	@@ -310,7 +310,8 @@ pub fn main() !void {
310	build_all_path, libc_so_path, @errorName(err),	310	build_all_path, libc_so_path, @errorName(err),
311	});	311	});
312	};	312	};
313	const header = try elf.Header.parse(elf_bytes[0..@sizeOf(elf.Elf64_Ehdr)]);	313	var stream: std.Io.Reader = .fixed(elf_bytes);
		314	const header = try elf.Header.read(&stream);
314		315
315	const parse: Parse = .{	316	const parse: Parse = .{
316	.arena = arena,	317	.arena = arena,