Commit 49be02e6d75acd996d9b2a573714552ba081ea13 | zig

src/link/MachO.zig+100-101

...	...	@@ -41,9 +41,9 @@ data_in_code_cmd: macho.linkedit_data_command = .{ .cmd = .DATA_IN_CODE },
41	41	uuid_cmd: macho.uuid_command = .{ .uuid = [_]u8{0} ** 16 },
42	42	codesig_cmd: macho.linkedit_data_command = .{ .cmd = .CODE_SIGNATURE },
43	43
44		pagezero_seg_index: ?u4 = null,
45		text_seg_index: ?u4 = null,
46		linkedit_seg_index: ?u4 = null,
	44	pagezero_seg_index: ?u8 = null,
	45	text_seg_index: ?u8 = null,
	46	linkedit_seg_index: ?u8 = null,
47	47	text_sect_index: ?u8 = null,
48	48	data_sect_index: ?u8 = null,
49	49	got_sect_index: ?u8 = null,
...	...	@@ -76,10 +76,10 @@ unwind_info: UnwindInfo = .{},
76	76	data_in_code: DataInCode = .{},
77	77
78	78	/// Tracked loadable segments during incremental linking.
79		zig_text_seg_index: ?u4 = null,
80		zig_const_seg_index: ?u4 = null,
81		zig_data_seg_index: ?u4 = null,
82		zig_bss_seg_index: ?u4 = null,
	79	zig_text_seg_index: ?u8 = null,
	80	zig_const_seg_index: ?u8 = null,
	81	zig_data_seg_index: ?u8 = null,
	82	zig_bss_seg_index: ?u8 = null,
83	83
84	84	/// Tracked section headers with incremental updates to Zig object.
85	85	zig_text_sect_index: ?u8 = null,
...	...	@@ -591,7 +591,6 @@ pub fn flush(
591	591	error.NoSpaceLeft => unreachable,
592	592	error.OutOfMemory => return error.OutOfMemory,
593	593	error.LinkFailure => return error.LinkFailure,
594		else => unreachable,
595	594	};
596	595	try self.writeHeader(ncmds, sizeofcmds);
597	596	self.writeUuid(uuid_cmd_offset, self.requiresCodeSig()) catch \|err\| switch (err) {
...	...	@@ -1075,7 +1074,7 @@ fn accessLibPath(
1075	1074
1076	1075	for (&[_][]const u8{ ".tbd", ".dylib", "" }) \|ext\| {
1077	1076	test_path.clearRetainingCapacity();
1078		try test_path.print("{s}" ++ sep ++ "lib{s}{s}", .{ search_dir, name, ext });
	1077	try test_path.writer().print("{s}" ++ sep ++ "lib{s}{s}", .{ search_dir, name, ext });
1079	1078	try checked_paths.append(try arena.dupe(u8, test_path.items));
1080	1079	fs.cwd().access(test_path.items, .{}) catch \|err\| switch (err) {
1081	1080	error.FileNotFound => continue,
...	...	@@ -1098,7 +1097,7 @@ fn accessFrameworkPath(
1098	1097
1099	1098	for (&[_][]const u8{ ".tbd", ".dylib", "" }) \|ext\| {
1100	1099	test_path.clearRetainingCapacity();
1101		try test_path.print("{s}" ++ sep ++ "{s}.framework" ++ sep ++ "{s}{s}", .{
	1100	try test_path.writer().print("{s}" ++ sep ++ "{s}.framework" ++ sep ++ "{s}{s}", .{
1102	1101	search_dir,
1103	1102	name,
1104	1103	name,
...	...	@@ -1179,9 +1178,9 @@ fn parseDependentDylibs(self: *MachO) !void {
1179	1178	for (&[_][]const u8{ ".tbd", ".dylib", "" }) \|ext\| {
1180	1179	test_path.clearRetainingCapacity();
1181	1180	if (self.base.comp.sysroot) \|root\| {
1182		try test_path.print("{s}" ++ fs.path.sep_str ++ "{s}{s}", .{ root, path, ext });
	1181	try test_path.writer().print("{s}" ++ fs.path.sep_str ++ "{s}{s}", .{ root, path, ext });
1183	1182	} else {
1184		try test_path.print("{s}{s}", .{ path, ext });
	1183	try test_path.writer().print("{s}{s}", .{ path, ext });
1185	1184	}
1186	1185	try checked_paths.append(try arena.dupe(u8, test_path.items));
1187	1186	fs.cwd().access(test_path.items, .{}) catch \|err\| switch (err) {
...	...	@@ -2132,7 +2131,7 @@ fn initSegments(self: *MachO) !void {
2132	2131
2133	2132	mem.sort(Entry, entries.items, self, Entry.lessThan);
2134	2133
2135		const backlinks = try gpa.alloc(u4, entries.items.len);
	2134	const backlinks = try gpa.alloc(u8, entries.items.len);
2136	2135	defer gpa.free(backlinks);
2137	2136	for (entries.items, 0..) \|entry, i\| {
2138	2137	backlinks[entry.index] = @intCast(i);
...	...	@@ -2146,7 +2145,7 @@ fn initSegments(self: *MachO) !void {
2146	2145	self.segments.appendAssumeCapacity(segments[sorted.index]);
2147	2146	}
2148	2147
2149		for (&[_]*?u4{
	2148	for (&[_]*?u8{
2150	2149	&self.pagezero_seg_index,
2151	2150	&self.text_seg_index,
2152	2151	&self.linkedit_seg_index,
...	...	@@ -2164,7 +2163,7 @@ fn initSegments(self: *MachO) !void {
2164	2163	for (slice.items(.header), slice.items(.segment_id)) \|header, *seg_id\| {
2165	2164	const segname = header.segName();
2166	2165	const segment_id = self.getSegmentByName(segname) orelse blk: {
2167		const segment_id: u4 = @intCast(self.segments.items.len);
	2166	const segment_id = @as(u8, @intCast(self.segments.items.len));
2168	2167	const protection = getSegmentProt(segname);
2169	2168	try self.segments.append(gpa, .{
2170	2169	.cmdsize = @sizeOf(macho.segment_command_64),
...	...	@@ -2527,8 +2526,10 @@ fn writeThunkWorker(self: *MachO, thunk: Thunk) void {
2527	2526
2528	2527	const doWork = struct {
2529	2528	fn doWork(th: Thunk, buffer: []u8, macho_file: *MachO) !void {
2530		var bw: Writer = .fixed(buffer[try macho_file.cast(usize, th.value)..][0..th.size()]);
2531		try th.write(macho_file, &bw);
	2529	const off = try macho_file.cast(usize, th.value);
	2530	const size = th.size();
	2531	var stream = std.io.fixedBufferStream(buffer[off..][0..size]);
	2532	try th.write(macho_file, stream.writer());
2532	2533	}
2533	2534	}.doWork;
2534	2535	const out = self.sections.items(.out)[thunk.out_n_sect].items;
...	...	@@ -2555,15 +2556,15 @@ fn writeSyntheticSectionWorker(self: *MachO, sect_id: u8, out: []u8) void {
2555	2556
2556	2557	const doWork = struct {
2557	2558	fn doWork(macho_file: *MachO, tag: Tag, buffer: []u8) !void {
2558		var bw: Writer = .fixed(buffer);
	2559	var stream = std.io.fixedBufferStream(buffer);
2559	2560	switch (tag) {
2560	2561	.eh_frame => eh_frame.write(macho_file, buffer),
2561		.unwind_info => try macho_file.unwind_info.write(macho_file, &bw),
2562		.got => try macho_file.got.write(macho_file, &bw),
2563		.stubs => try macho_file.stubs.write(macho_file, &bw),
2564		.la_symbol_ptr => try macho_file.la_symbol_ptr.write(macho_file, &bw),
2565		.tlv_ptr => try macho_file.tlv_ptr.write(macho_file, &bw),
2566		.objc_stubs => try macho_file.objc_stubs.write(macho_file, &bw),
	2562	.unwind_info => try macho_file.unwind_info.write(macho_file, buffer),
	2563	.got => try macho_file.got.write(macho_file, stream.writer()),
	2564	.stubs => try macho_file.stubs.write(macho_file, stream.writer()),
	2565	.la_symbol_ptr => try macho_file.la_symbol_ptr.write(macho_file, stream.writer()),
	2566	.tlv_ptr => try macho_file.tlv_ptr.write(macho_file, stream.writer()),
	2567	.objc_stubs => try macho_file.objc_stubs.write(macho_file, stream.writer()),
2567	2568	}
2568	2569	}
2569	2570	}.doWork;
...	...	@@ -2604,8 +2605,8 @@ fn updateLazyBindSizeWorker(self: *MachO) void {
2604	2605	try macho_file.lazy_bind_section.updateSize(macho_file);
2605	2606	const sect_id = macho_file.stubs_helper_sect_index.?;
2606	2607	const out = &macho_file.sections.items(.out)[sect_id];
2607		var bw: Writer = .fixed(out.items);
2608		try macho_file.stubs_helper.write(macho_file, &bw);
	2608	var stream = std.io.fixedBufferStream(out.items);
	2609	try macho_file.stubs_helper.write(macho_file, stream.writer());
2609	2610	}
2610	2611	}.doWork;
2611	2612	doWork(self) catch \|err\|
...	...	@@ -2664,49 +2665,46 @@ fn writeDyldInfo(self: *MachO) !void {
2664	2665	needed_size += cmd.lazy_bind_size;
2665	2666	needed_size += cmd.export_size;
2666	2667
2667		var bw: Writer = .fixed(try gpa.alloc(u8, needed_size));
2668		defer gpa.free(bw.buffer);
2669		@memset(bw.buffer, 0);
	2668	const buffer = try gpa.alloc(u8, needed_size);
	2669	defer gpa.free(buffer);
	2670	@memset(buffer, 0);
2670	2671
2671		try self.rebase_section.write(&bw);
2672		bw.end = cmd.bind_off - base_off;
2673		try self.bind_section.write(&bw);
2674		bw.end = cmd.weak_bind_off - base_off;
2675		try self.weak_bind_section.write(&bw);
2676		bw.end = cmd.lazy_bind_off - base_off;
2677		try self.lazy_bind_section.write(&bw);
2678		bw.end = cmd.export_off - base_off;
2679		try self.export_trie.write(&bw);
2680		try self.pwriteAll(bw.buffer, cmd.rebase_off);
	2672	var stream = std.io.fixedBufferStream(buffer);
	2673	const writer = stream.writer();
	2674
	2675	try self.rebase_section.write(writer);
	2676	try stream.seekTo(cmd.bind_off - base_off);
	2677	try self.bind_section.write(writer);
	2678	try stream.seekTo(cmd.weak_bind_off - base_off);
	2679	try self.weak_bind_section.write(writer);
	2680	try stream.seekTo(cmd.lazy_bind_off - base_off);
	2681	try self.lazy_bind_section.write(writer);
	2682	try stream.seekTo(cmd.export_off - base_off);
	2683	try self.export_trie.write(writer);
	2684	try self.pwriteAll(buffer, cmd.rebase_off);
2681	2685	}
2682	2686
2683		pub fn writeDataInCode(self: *MachO) link.File.FlushError!void {
	2687	pub fn writeDataInCode(self: *MachO) !void {
2684	2688	const tracy = trace(@src());
2685	2689	defer tracy.end();
2686	2690	const gpa = self.base.comp.gpa;
2687	2691	const cmd = self.data_in_code_cmd;
2688
2689		var bw: Writer = .fixed(try gpa.alloc(u8, self.data_in_code.size()));
2690		defer gpa.free(bw.buffer);
2691
2692		try self.data_in_code.write(self, &bw);
2693		assert(bw.end == bw.buffer.len);
2694		try self.pwriteAll(bw.buffer, cmd.dataoff);
	2692	var buffer = try std.ArrayList(u8).initCapacity(gpa, self.data_in_code.size());
	2693	defer buffer.deinit();
	2694	try self.data_in_code.write(self, buffer.writer());
	2695	try self.pwriteAll(buffer.items, cmd.dataoff);
2695	2696	}
2696	2697
2697	2698	fn writeIndsymtab(self: *MachO) !void {
2698	2699	const tracy = trace(@src());
2699	2700	defer tracy.end();
2700
2701	2701	const gpa = self.base.comp.gpa;
2702	2702	const cmd = self.dysymtab_cmd;
2703
2704		var bw: Writer = .fixed(try gpa.alloc(u8, @sizeOf(u32) * cmd.nindirectsyms));
2705		defer gpa.free(bw.buffer);
2706
2707		try self.indsymtab.write(self, &bw);
2708		assert(bw.end == bw.buffer.len);
2709		try self.pwriteAll(bw.buffer, cmd.indirectsymoff);
	2703	const needed_size = cmd.nindirectsyms * @sizeOf(u32);
	2704	var buffer = try std.ArrayList(u8).initCapacity(gpa, needed_size);
	2705	defer buffer.deinit();
	2706	try self.indsymtab.write(self, buffer.writer());
	2707	try self.pwriteAll(buffer.items, cmd.indirectsymoff);
2710	2708	}
2711	2709
2712	2710	pub fn writeSymtabToFile(self: *MachO) !void {
...	...	@@ -2816,12 +2814,15 @@ fn calcSymtabSize(self: *MachO) !void {
2816	2814	}
2817	2815	}
2818	2816
2819		fn writeLoadCommands(self: *MachO) Writer.Error!struct { usize, usize, u64 } {
	2817	fn writeLoadCommands(self: *MachO) !struct { usize, usize, u64 } {
2820	2818	const comp = self.base.comp;
2821	2819	const gpa = comp.gpa;
	2820	const needed_size = try load_commands.calcLoadCommandsSize(self, false);
	2821	const buffer = try gpa.alloc(u8, needed_size);
	2822	defer gpa.free(buffer);
2822	2823
2823		var bw: Writer = .fixed(try gpa.alloc(u8, try load_commands.calcLoadCommandsSize(self, false)));
2824		defer gpa.free(bw.buffer);
	2824	var stream = std.io.fixedBufferStream(buffer);
	2825	const writer = stream.writer();
2825	2826
2826	2827	var ncmds: usize = 0;
2827	2828
...	...	@@ -2830,26 +2831,26 @@ fn writeLoadCommands(self: *MachO) Writer.Error!struct { usize, usize, u64 } {
2830	2831	const slice = self.sections.slice();
2831	2832	var sect_id: usize = 0;
2832	2833	for (self.segments.items) \|seg\| {
2833		try bw.writeStruct(seg);
	2834	try writer.writeStruct(seg);
2834	2835	for (slice.items(.header)[sect_id..][0..seg.nsects]) \|header\| {
2835		try bw.writeStruct(header);
	2836	try writer.writeStruct(header);
2836	2837	}
2837	2838	sect_id += seg.nsects;
2838	2839	}
2839	2840	ncmds += self.segments.items.len;
2840	2841	}
2841	2842
2842		try bw.writeStruct(self.dyld_info_cmd);
	2843	try writer.writeStruct(self.dyld_info_cmd);
2843	2844	ncmds += 1;
2844		try bw.writeStruct(self.function_starts_cmd);
	2845	try writer.writeStruct(self.function_starts_cmd);
2845	2846	ncmds += 1;
2846		try bw.writeStruct(self.data_in_code_cmd);
	2847	try writer.writeStruct(self.data_in_code_cmd);
2847	2848	ncmds += 1;
2848		try bw.writeStruct(self.symtab_cmd);
	2849	try writer.writeStruct(self.symtab_cmd);
2849	2850	ncmds += 1;
2850		try bw.writeStruct(self.dysymtab_cmd);
	2851	try writer.writeStruct(self.dysymtab_cmd);
2851	2852	ncmds += 1;
2852		try load_commands.writeDylinkerLC(&bw);
	2853	try load_commands.writeDylinkerLC(writer);
2853	2854	ncmds += 1;
2854	2855
2855	2856	if (self.getInternalObject()) \|obj\| {
...	...	@@ -2860,7 +2861,7 @@ fn writeLoadCommands(self: *MachO) Writer.Error!struct { usize, usize, u64 } {
2860	2861	0
2861	2862	else
2862	2863	@as(u32, @intCast(sym.getAddress(.{ .stubs = true }, self) - seg.vmaddr));
2863		try bw.writeStruct(macho.entry_point_command{
	2864	try writer.writeStruct(macho.entry_point_command{
2864	2865	.entryoff = entryoff,
2865	2866	.stacksize = self.base.stack_size,
2866	2867	});
...	...	@@ -2869,35 +2870,35 @@ fn writeLoadCommands(self: *MachO) Writer.Error!struct { usize, usize, u64 } {
2869	2870	}
2870	2871
2871	2872	if (self.base.isDynLib()) {
2872		try load_commands.writeDylibIdLC(self, &bw);
	2873	try load_commands.writeDylibIdLC(self, writer);
2873	2874	ncmds += 1;
2874	2875	}
2875	2876
2876	2877	for (self.rpath_list) \|rpath\| {
2877		try load_commands.writeRpathLC(&bw, rpath);
	2878	try load_commands.writeRpathLC(rpath, writer);
2878	2879	ncmds += 1;
2879	2880	}
2880	2881	if (comp.config.any_sanitize_thread) {
2881	2882	const path = try comp.tsan_lib.?.full_object_path.toString(gpa);
2882	2883	defer gpa.free(path);
2883	2884	const rpath = std.fs.path.dirname(path) orelse ".";
2884		try load_commands.writeRpathLC(&bw, rpath);
	2885	try load_commands.writeRpathLC(rpath, writer);
2885	2886	ncmds += 1;
2886	2887	}
2887	2888
2888		try bw.writeStruct(macho.source_version_command{ .version = 0 });
	2889	try writer.writeStruct(macho.source_version_command{ .version = 0 });
2889	2890	ncmds += 1;
2890	2891
2891	2892	if (self.platform.isBuildVersionCompatible()) {
2892		try load_commands.writeBuildVersionLC(&bw, self.platform, self.sdk_version);
	2893	try load_commands.writeBuildVersionLC(self.platform, self.sdk_version, writer);
2893	2894	ncmds += 1;
2894	2895	} else {
2895		try load_commands.writeVersionMinLC(&bw, self.platform, self.sdk_version);
	2896	try load_commands.writeVersionMinLC(self.platform, self.sdk_version, writer);
2896	2897	ncmds += 1;
2897	2898	}
2898	2899
2899		const uuid_cmd_offset = @sizeOf(macho.mach_header_64) + bw.count;
2900		try bw.writeStruct(self.uuid_cmd);
	2900	const uuid_cmd_offset = @sizeOf(macho.mach_header_64) + stream.pos;
	2901	try writer.writeStruct(self.uuid_cmd);
2901	2902	ncmds += 1;
2902	2903
2903	2904	for (self.dylibs.items) \|index\| {
...	...	@@ -2915,19 +2916,20 @@ fn writeLoadCommands(self: *MachO) Writer.Error!struct { usize, usize, u64 } {
2915	2916	.timestamp = dylib_id.timestamp,
2916	2917	.current_version = dylib_id.current_version,
2917	2918	.compatibility_version = dylib_id.compatibility_version,
2918		}, &bw);
	2919	}, writer);
2919	2920	ncmds += 1;
2920	2921	}
2921	2922
2922	2923	if (self.requiresCodeSig()) {
2923		try bw.writeStruct(self.codesig_cmd);
	2924	try writer.writeStruct(self.codesig_cmd);
2924	2925	ncmds += 1;
2925	2926	}
2926	2927
2927		assert(bw.end == bw.buffer.len);
2928		try self.pwriteAll(bw.buffer, @sizeOf(macho.mach_header_64));
	2928	assert(stream.pos == needed_size);
2929	2929
2930		return .{ ncmds, bw.end, uuid_cmd_offset };
	2930	try self.pwriteAll(buffer, @sizeOf(macho.mach_header_64));
	2931
	2932	return .{ ncmds, buffer.len, uuid_cmd_offset };
2931	2933	}
2932	2934
2933	2935	fn writeHeader(self: *MachO, ncmds: usize, sizeofcmds: usize) !void {
...	...	@@ -3010,27 +3012,27 @@ pub fn writeCodeSignaturePadding(self: MachO, code_sig: CodeSignature) !void {
3010	3012	}
3011	3013
3012	3014	pub fn writeCodeSignature(self: MachO, code_sig: CodeSignature) !void {
3013		const gpa = self.base.comp.gpa;
3014	3015	const seg = self.getTextSegment();
3015	3016	const offset = self.codesig_cmd.dataoff;
3016	3017
3017		var bw: Writer = .fixed(try gpa.alloc(u8, code_sig.size()));
3018		defer gpa.free(bw.buffer);
	3018	var buffer = std.ArrayList(u8).init(self.base.comp.gpa);
	3019	defer buffer.deinit();
	3020	try buffer.ensureTotalCapacityPrecise(code_sig.size());
3019	3021	try code_sig.writeAdhocSignature(self, .{
3020	3022	.file = self.base.file.?,
3021	3023	.exec_seg_base = seg.fileoff,
3022	3024	.exec_seg_limit = seg.filesize,
3023	3025	.file_size = offset,
3024	3026	.dylib = self.base.isDynLib(),
3025		}, &bw);
	3027	}, buffer.writer());
	3028	assert(buffer.items.len == code_sig.size());
3026	3029
3027	3030	log.debug("writing code signature from 0x{x} to 0x{x}", .{
3028	3031	offset,
3029		offset + bw.end,
	3032	offset + buffer.items.len,
3030	3033	});
3031	3034
3032		assert(bw.end == bw.buffer.len);
3033		try self.pwriteAll(bw.buffer, offset);
	3035	try self.pwriteAll(buffer.items, offset);
3034	3036	}
3035	3037
3036	3038	pub fn updateFunc(
...	...	@@ -3339,7 +3341,7 @@ fn initMetadata(self: *MachO, options: InitMetadataOptions) !void {
3339	3341	}
3340	3342
3341	3343	const appendSect = struct {
3342		fn appendSect(macho_file: *MachO, sect_id: u8, seg_id: u4) void {
	3344	fn appendSect(macho_file: *MachO, sect_id: u8, seg_id: u8) void {
3343	3345	const sect = &macho_file.sections.items(.header)[sect_id];
3344	3346	const seg = macho_file.segments.items[seg_id];
3345	3347	sect.addr = seg.vmaddr;
...	...	@@ -3598,7 +3600,7 @@ inline fn requiresThunks(self: MachO) bool {
3598	3600	}
3599	3601
3600	3602	pub fn isZigSegment(self: MachO, seg_id: u8) bool {
3601		inline for (&[_]?u4{
	3603	inline for (&[_]?u8{
3602	3604	self.zig_text_seg_index,
3603	3605	self.zig_const_seg_index,
3604	3606	self.zig_data_seg_index,
...	...	@@ -3646,9 +3648,9 @@ pub fn addSegment(self: *MachO, name: []const u8, opts: struct {
3646	3648	fileoff: u64 = 0,
3647	3649	filesize: u64 = 0,
3648	3650	prot: macho.vm_prot_t = macho.PROT.NONE,
3649		}) error{OutOfMemory}!u4 {
	3651	}) error{OutOfMemory}!u8 {
3650	3652	const gpa = self.base.comp.gpa;
3651		const index: u4 = @intCast(self.segments.items.len);
	3653	const index = @as(u8, @intCast(self.segments.items.len));
3652	3654	try self.segments.append(gpa, .{
3653	3655	.segname = makeStaticString(name),
3654	3656	.vmaddr = opts.vmaddr,
...	...	@@ -3698,9 +3700,9 @@ pub fn makeStaticString(bytes: []const u8) [16]u8 {
3698	3700	return buf;
3699	3701	}
3700	3702
3701		pub fn getSegmentByName(self: MachO, segname: []const u8) ?u4 {
	3703	pub fn getSegmentByName(self: MachO, segname: []const u8) ?u8 {
3702	3704	for (self.segments.items, 0..) \|seg, i\| {
3703		if (mem.eql(u8, segname, seg.segName())) return @intCast(i);
	3705	if (mem.eql(u8, segname, seg.segName())) return @as(u8, @intCast(i));
3704	3706	} else return null;
3705	3707	}
3706	3708
...	...	@@ -4028,7 +4030,7 @@ const default_entry_symbol_name = "_main";
4028	4030
4029	4031	const Section = struct {
4030	4032	header: macho.section_64,
4031		segment_id: u4,
	4033	segment_id: u8,
4032	4034	atoms: std.ArrayListUnmanaged(Ref) = .empty,
4033	4035	free_list: std.ArrayListUnmanaged(Atom.Index) = .empty,
4034	4036	last_atom_index: Atom.Index = 0,
...	...	@@ -4353,7 +4355,7 @@ fn inferSdkVersion(comp: *Compilation, sdk_layout: SdkLayout) ?std.SemanticVersi
4353	4355	// The file/property is also available with vendored libc.
4354	4356	fn readSdkVersionFromSettings(arena: Allocator, dir: []const u8) ![]const u8 {
4355	4357	const sdk_path = try fs.path.join(arena, &.{ dir, "SDKSettings.json" });
4356		const contents = try fs.cwd().readFileAlloc(sdk_path, arena, .limited(std.math.maxInt(u16)));
	4358	const contents = try fs.cwd().readFileAlloc(arena, sdk_path, std.math.maxInt(u16));
4357	4359	const parsed = try std.json.parseFromSlice(std.json.Value, arena, contents, .{});
4358	4360	if (parsed.value.object.get("MinimalDisplayName")) \|ver\| return ver.string;
4359	4361	return error.SdkVersionFailure;
...	...	@@ -4369,7 +4371,7 @@ fn parseSdkVersion(raw: []const u8) ?std.SemanticVersion {
4369	4371	};
4370	4372
4371	4373	const parseNext = struct {
4372		fn parseNext(it: *std.mem.SplitIterator(u8, .any)) ?u16 {
	4374	fn parseNext(it: anytype) ?u16 {
4373	4375	const nn = it.next() orelse return null;
4374	4376	return std.fmt.parseInt(u16, nn, 10) catch null;
4375	4377	}
...	...	@@ -5317,11 +5319,8 @@ fn isReachable(atom: const Atom, rel: Relocation, macho_file: MachO) bool {
5317	5319	pub fn pwriteAll(macho_file: *MachO, bytes: []const u8, offset: u64) error{LinkFailure}!void {
5318	5320	const comp = macho_file.base.comp;
5319	5321	const diags = &comp.link_diags;
5320		var fw = macho_file.base.file.?.writer();
5321		fw.pos = offset;
5322		var bw = fw.interface().unbuffered();
5323		bw.writeAll(bytes) catch \|err\| switch (err) {
5324		error.WriteFailed => return diags.fail("failed to write: {s}", .{@errorName(fw.err.?)}),
	5322	macho_file.base.file.?.pwriteAll(bytes, offset) catch \|err\| {
	5323	return diags.fail("failed to write: {s}", .{@errorName(err)});
5325	5324	};
5326	5325	}
5327	5326

src/link/MachO/Archive.zig+49-22

...	...	@@ -71,29 +71,53 @@ pub fn unpack(self: Archive, macho_file: MachO, path: Path, handle_index: File
71	71	.mtime = hdr.date() catch 0,
72	72	};
73	73
74		log.debug("extracting object '{f}' from archive '{f}'", .{ object.path, path });
	74	log.debug("extracting object '{}' from archive '{}'", .{ object.path, path });
75	75
76	76	try self.objects.append(gpa, object);
77	77	}
78	78	}
79	79
80	80	pub fn writeHeader(
81		bw: *Writer,
82	81	object_name: []const u8,
83	82	object_size: usize,
84	83	format: Format,
85		) Writer.Error!void {
86		var hdr: ar_hdr = undefined;
87		@memset(mem.asBytes(&hdr), ' ');
88		inline for (@typeInfo(ar_hdr).@"struct".fields) \|field\| @field(hdr, field.name)[0] = '0';
	84	writer: anytype,
	85	) !void {
	86	var hdr: ar_hdr = .{
	87	.ar_name = undefined,
	88	.ar_date = undefined,
	89	.ar_uid = undefined,
	90	.ar_gid = undefined,
	91	.ar_mode = undefined,
	92	.ar_size = undefined,
	93	.ar_fmag = undefined,
	94	};
	95	@memset(mem.asBytes(&hdr), 0x20);
	96	inline for (@typeInfo(ar_hdr).@"struct".fields) \|field\| {
	97	var stream = std.io.fixedBufferStream(&@field(hdr, field.name));
	98	stream.writer().print("0", .{}) catch unreachable;
	99	}
89	100	@memcpy(&hdr.ar_fmag, ARFMAG);
	101
90	102	const object_name_len = mem.alignForward(usize, object_name.len + 1, ptrWidth(format));
91		_ = std.fmt.bufPrint(&hdr.ar_name, "#1/{d}", .{object_name_len}) catch unreachable;
92	103	const total_object_size = object_size + object_name_len;
93		_ = std.fmt.bufPrint(&hdr.ar_size, "{d}", .{total_object_size}) catch unreachable;
94		try bw.writeStruct(hdr);
95		try bw.writeAll(object_name);
96		try bw.splatByteAll(0, object_name_len - object_name.len);
	104
	105	{
	106	var stream = std.io.fixedBufferStream(&hdr.ar_name);
	107	stream.writer().print("#1/{d}", .{object_name_len}) catch unreachable;
	108	}
	109	{
	110	var stream = std.io.fixedBufferStream(&hdr.ar_size);
	111	stream.writer().print("{d}", .{total_object_size}) catch unreachable;
	112	}
	113
	114	try writer.writeAll(mem.asBytes(&hdr));
	115	try writer.print("{s}\x00", .{object_name});
	116
	117	const padding = object_name_len - object_name.len - 1;
	118	if (padding > 0) {
	119	try writer.writeByteNTimes(0, padding);
	120	}
97	121	}
98	122
99	123	// Archive files start with the ARMAG identifying string. Then follows a
...	...	@@ -177,12 +201,12 @@ pub const ArSymtab = struct {
177	201	return ptr_width + ar.entries.items.len * 2 * ptr_width + ptr_width + mem.alignForward(usize, ar.strtab.buffer.items.len, ptr_width);
178	202	}
179	203
180		pub fn write(ar: ArSymtab, bw: Writer, format: Format, macho_file: MachO) Writer.Error!void {
	204	pub fn write(ar: ArSymtab, format: Format, macho_file: *MachO, writer: anytype) !void {
181	205	const ptr_width = ptrWidth(format);
182	206	// Header
183		try writeHeader(bw, SYMDEF, ar.size(format), format);
	207	try writeHeader(SYMDEF, ar.size(format), format, writer);
184	208	// Symtab size
185		try writeInt(bw, format, ar.entries.items.len * 2 * ptr_width);
	209	try writeInt(format, ar.entries.items.len * 2 * ptr_width, writer);
186	210	// Symtab entries
187	211	for (ar.entries.items) \|entry\| {
188	212	const file_off = switch (macho_file.getFile(entry.file).?) {
...	...	@@ -191,16 +215,19 @@ pub const ArSymtab = struct {
191	215	else => unreachable,
192	216	};
193	217	// Name offset
194		try writeInt(bw, format, entry.off);
	218	try writeInt(format, entry.off, writer);
195	219	// File offset
196		try writeInt(bw, format, file_off);
	220	try writeInt(format, file_off, writer);
197	221	}
198	222	// Strtab size
199	223	const strtab_size = mem.alignForward(usize, ar.strtab.buffer.items.len, ptr_width);
200		try writeInt(bw, format, strtab_size);
	224	const padding = strtab_size - ar.strtab.buffer.items.len;
	225	try writeInt(format, strtab_size, writer);
201	226	// Strtab
202		try bw.writeAll(ar.strtab.buffer.items);
203		try bw.splatByteAll(0, strtab_size - ar.strtab.buffer.items.len);
	227	try writer.writeAll(ar.strtab.buffer.items);
	228	if (padding > 0) {
	229	try writer.writeByteNTimes(0, padding);
	230	}
204	231	}
205	232
206	233	const PrintFormat = struct {
...	...	@@ -248,10 +275,10 @@ pub fn ptrWidth(format: Format) usize {
248	275	};
249	276	}
250	277
251		pub fn writeInt(bw: *Writer, format: Format, value: u64) Writer.Error!void {
	278	pub fn writeInt(format: Format, value: u64, writer: anytype) !void {
252	279	switch (format) {
253		.p32 => try bw.writeInt(u32, std.math.cast(u32, value) orelse return error.Overflow, .little),
254		.p64 => try bw.writeInt(u64, value, .little),
	280	.p32 => try writer.writeInt(u32, std.math.cast(u32, value) orelse return error.Overflow, .little),
	281	.p64 => try writer.writeInt(u64, value, .little),
255	282	}
256	283	}
257	284

src/link/MachO/Atom.zig+45-41

...	...	@@ -580,9 +580,8 @@ pub fn resolveRelocs(self: Atom, macho_file: *MachO, buffer: []u8) !void {
580	580
581	581	relocs_log.debug("{x}: {s}", .{ self.value, name });
582	582
583		var bw: Writer = .fixed(buffer);
584
585	583	var has_error = false;
	584	var stream = std.io.fixedBufferStream(buffer);
586	585	var i: usize = 0;
587	586	while (i < relocs.len) : (i += 1) {
588	587	const rel = relocs[i];
...	...	@@ -593,28 +592,30 @@ pub fn resolveRelocs(self: Atom, macho_file: *MachO, buffer: []u8) !void {
593	592	if (rel.getTargetSymbol(self, macho_file).getFile(macho_file) == null) continue;
594	593	}
595	594
596		bw.end = std.math.cast(usize, rel_offset) orelse return error.Overflow;
597		self.resolveRelocInner(rel, subtractor, buffer, macho_file, &bw) catch \|err\| switch (err) {
598		error.RelaxFail => {
599		const target = switch (rel.tag) {
600		.@"extern" => rel.getTargetSymbol(self, macho_file).getName(macho_file),
601		.local => rel.getTargetAtom(self, macho_file).getName(macho_file),
602		};
603		try macho_file.reportParseError2(
604		file.getIndex(),
605		"{s}: 0x{x}: 0x{x}: failed to relax relocation: type {f}, target {s}",
606		.{
607		name,
608		self.getAddress(macho_file),
609		rel.offset,
610		rel.fmtPretty(macho_file.getTarget().cpu.arch),
611		target,
612		},
613		);
614		has_error = true;
615		},
616		error.RelaxFailUnexpectedInstruction => has_error = true,
617		else => \|e\| return e,
	595	try stream.seekTo(rel_offset);
	596	self.resolveRelocInner(rel, subtractor, buffer, macho_file, stream.writer()) catch \|err\| {
	597	switch (err) {
	598	error.RelaxFail => {
	599	const target = switch (rel.tag) {
	600	.@"extern" => rel.getTargetSymbol(self, macho_file).getName(macho_file),
	601	.local => rel.getTargetAtom(self, macho_file).getName(macho_file),
	602	};
	603	try macho_file.reportParseError2(
	604	file.getIndex(),
	605	"{s}: 0x{x}: 0x{x}: failed to relax relocation: type {}, target {s}",
	606	.{
	607	name,
	608	self.getAddress(macho_file),
	609	rel.offset,
	610	rel.fmtPretty(macho_file.getTarget().cpu.arch),
	611	target,
	612	},
	613	);
	614	has_error = true;
	615	},
	616	error.RelaxFailUnexpectedInstruction => has_error = true,
	617	else => \|e\| return e,
	618	}
618	619	};
619	620	}
620	621
...	...	@@ -637,8 +638,8 @@ fn resolveRelocInner(
637	638	subtractor: ?Relocation,
638	639	code: []u8,
639	640	macho_file: *MachO,
640		bw: *Writer,
641		) Writer.Error!void {
	641	writer: anytype,
	642	) ResolveError!void {
642	643	const t = &macho_file.base.comp.root_mod.resolved_target.result;
643	644	const cpu_arch = t.cpu.arch;
644	645	const rel_offset = math.cast(usize, rel.offset - self.off) orelse return error.Overflow;
...	...	@@ -652,7 +653,7 @@ fn resolveRelocInner(
652	653	const divExact = struct {
653	654	fn divExact(atom: Atom, r: Relocation, num: u12, den: u12, ctx: *MachO) !u12 {
654	655	return math.divExact(u12, num, den) catch {
655		try ctx.reportParseError2(atom.getFile(ctx).getIndex(), "{s}: unexpected remainder when resolving {f} at offset 0x{x}", .{
	656	try ctx.reportParseError2(atom.getFile(ctx).getIndex(), "{s}: unexpected remainder when resolving {s} at offset 0x{x}", .{
656	657	atom.getName(ctx),
657	658	r.fmtPretty(ctx.getTarget().cpu.arch),
658	659	r.offset,
...	...	@@ -689,14 +690,14 @@ fn resolveRelocInner(
689	690	if (rel.tag == .@"extern") {
690	691	const sym = rel.getTargetSymbol(self, macho_file);
691	692	if (sym.isTlvInit(macho_file)) {
692		try bw.writeInt(u64, @intCast(S - TLS), .little);
	693	try writer.writeInt(u64, @intCast(S - TLS), .little);
693	694	return;
694	695	}
695	696	if (sym.flags.import) return;
696	697	}
697		try bw.writeInt(u64, @bitCast(S + A - SUB), .little);
	698	try writer.writeInt(u64, @bitCast(S + A - SUB), .little);
698	699	} else if (rel.meta.length == 2) {
699		try bw.writeInt(u32, @bitCast(@as(i32, @truncate(S + A - SUB))), .little);
	700	try writer.writeInt(u32, @bitCast(@as(i32, @truncate(S + A - SUB))), .little);
700	701	} else unreachable;
701	702	},
702	703
...	...	@@ -704,7 +705,7 @@ fn resolveRelocInner(
704	705	assert(rel.tag == .@"extern");
705	706	assert(rel.meta.length == 2);
706	707	assert(rel.meta.pcrel);
707		try bw.writeInt(i32, @intCast(G + A - P), .little);
	708	try writer.writeInt(i32, @intCast(G + A - P), .little);
708	709	},
709	710
710	711	.branch => {
...	...	@@ -713,7 +714,7 @@ fn resolveRelocInner(
713	714	assert(rel.tag == .@"extern");
714	715
715	716	switch (cpu_arch) {
716		.x86_64 => try bw.writeInt(i32, @intCast(S + A - P), .little),
	717	.x86_64 => try writer.writeInt(i32, @intCast(S + A - P), .little),
717	718	.aarch64 => {
718	719	const disp: i28 = math.cast(i28, S + A - P) orelse blk: {
719	720	const thunk = self.getThunk(macho_file);
...	...	@@ -731,10 +732,10 @@ fn resolveRelocInner(
731	732	assert(rel.meta.length == 2);
732	733	assert(rel.meta.pcrel);
733	734	if (rel.getTargetSymbol(self, macho_file).getSectionFlags().has_got) {
734		try bw.writeInt(i32, @intCast(G + A - P), .little);
	735	try writer.writeInt(i32, @intCast(G + A - P), .little);
735	736	} else {
736	737	try x86_64.relaxGotLoad(self, code[rel_offset - 3 ..], rel, macho_file);
737		try bw.writeInt(i32, @intCast(S + A - P), .little);
	738	try writer.writeInt(i32, @intCast(S + A - P), .little);
738	739	}
739	740	},
740	741
...	...	@@ -745,17 +746,17 @@ fn resolveRelocInner(
745	746	const sym = rel.getTargetSymbol(self, macho_file);
746	747	if (sym.getSectionFlags().tlv_ptr) {
747	748	const S_: i64 = @intCast(sym.getTlvPtrAddress(macho_file));
748		try bw.writeInt(i32, @intCast(S_ + A - P), .little);
	749	try writer.writeInt(i32, @intCast(S_ + A - P), .little);
749	750	} else {
750	751	try x86_64.relaxTlv(code[rel_offset - 3 ..], t);
751		try bw.writeInt(i32, @intCast(S + A - P), .little);
	752	try writer.writeInt(i32, @intCast(S + A - P), .little);
752	753	}
753	754	},
754	755
755	756	.signed, .signed1, .signed2, .signed4 => {
756	757	assert(rel.meta.length == 2);
757	758	assert(rel.meta.pcrel);
758		try bw.writeInt(i32, @intCast(S + A - P), .little);
	759	try writer.writeInt(i32, @intCast(S + A - P), .little);
759	760	},
760	761
761	762	.page,
...	...	@@ -807,7 +808,7 @@ fn resolveRelocInner(
807	808	2 => try divExact(self, rel, @truncate(target), 4, macho_file),
808	809	3 => try divExact(self, rel, @truncate(target), 8, macho_file),
809	810	};
810		try bw.writeInt(u32, inst.toU32(), .little);
	811	try writer.writeInt(u32, inst.toU32(), .little);
811	812	}
812	813	},
813	814
...	...	@@ -885,7 +886,7 @@ fn resolveRelocInner(
885	886	.sf = @as(u1, @truncate(reg_info.size)),
886	887	},
887	888	};
888		try bw.writeInt(u32, inst.toU32(), .little);
	889	try writer.writeInt(u32, inst.toU32(), .little);
889	890	},
890	891	}
891	892	}
...	...	@@ -937,8 +938,11 @@ const x86_64 = struct {
937	938	}
938	939
939	940	fn encode(insts: []const Instruction, code: []u8) !void {
940		var bw: Writer = .fixed(code);
941		for (insts) \|inst\| try inst.encode(&bw, .{});
	941	var stream = std.io.fixedBufferStream(code);
	942	const writer = stream.writer();
	943	for (insts) \|inst\| {
	944	try inst.encode(writer, .{});
	945	}
942	946	}
943	947
944	948	const bits = @import("../../arch/x86_64/bits.zig");

src/link/MachO/CodeSignature.zig+9-11

...	...	@@ -247,7 +247,7 @@ pub fn deinit(self: *CodeSignature, allocator: Allocator) void {
247	247	pub fn addEntitlements(self: *CodeSignature, allocator: Allocator, path: []const u8) !void {
248	248	const file = try fs.cwd().openFile(path, .{});
249	249	defer file.close();
250		const inner = try file.readToEndAlloc(allocator, .unlimited);
	250	const inner = try file.readToEndAlloc(allocator, std.math.maxInt(u32));
251	251	self.entitlements = .{ .inner = inner };
252	252	}
253	253
...	...	@@ -304,11 +304,10 @@ pub fn writeAdhocSignature(
304	304	var hash: [hash_size]u8 = undefined;
305	305
306	306	if (self.requirements) \|*req\| {
307		var aw: std.io.Writer.Allocating = .init(allocator);
308		defer aw.deinit();
309
310		try req.write(&aw.writer);
311		Sha256.hash(aw.getWritten(), &hash, .{});
	307	var buf = std.ArrayList(u8).init(allocator);
	308	defer buf.deinit();
	309	try req.write(buf.writer());
	310	Sha256.hash(buf.items, &hash, .{});
312	311	self.code_directory.addSpecialHash(req.slotType(), hash);
313	312
314	313	try blobs.append(.{ .requirements = req });
...	...	@@ -317,11 +316,10 @@ pub fn writeAdhocSignature(
317	316	}
318	317
319	318	if (self.entitlements) \|*ents\| {
320		var aw: std.io.Writer.Allocating = .init(allocator);
321		defer aw.deinit();
322
323		try ents.write(&aw.writer);
324		Sha256.hash(aw.getWritten(), &hash, .{});
	319	var buf = std.ArrayList(u8).init(allocator);
	320	defer buf.deinit();
	321	try ents.write(buf.writer());
	322	Sha256.hash(buf.items, &hash, .{});
325	323	self.code_directory.addSpecialHash(ents.slotType(), hash);
326	324
327	325	try blobs.append(.{ .entitlements = ents });

src/link/MachO/DebugSymbols.zig+16-11

...	...	@@ -269,14 +269,18 @@ fn finalizeDwarfSegment(self: DebugSymbols, macho_file: MachO) void {
269	269
270	270	fn writeLoadCommands(self: DebugSymbols, macho_file: MachO) !struct { usize, usize } {
271	271	const gpa = self.allocator;
272		var bw: Writer = .fixed(try gpa.alloc(u8, load_commands.calcLoadCommandsSizeDsym(macho_file, self)));
273		defer gpa.free(bw.buffer);
	272	const needed_size = load_commands.calcLoadCommandsSizeDsym(macho_file, self);
	273	const buffer = try gpa.alloc(u8, needed_size);
	274	defer gpa.free(buffer);
	275
	276	var stream = std.io.fixedBufferStream(buffer);
	277	const writer = stream.writer();
274	278
275	279	var ncmds: usize = 0;
276	280
277	281	// UUID comes first presumably to speed up lookup by the consumer like lldb.
278	282	@memcpy(&self.uuid_cmd.uuid, &macho_file.uuid_cmd.uuid);
279		try bw.writeStruct(self.uuid_cmd);
	283	try writer.writeStruct(self.uuid_cmd);
280	284	ncmds += 1;
281	285
282	286	// Segment and section load commands
...	...	@@ -289,11 +293,11 @@ fn writeLoadCommands(self: DebugSymbols, macho_file: MachO) !struct { usize, u
289	293	var out_seg = seg;
290	294	out_seg.fileoff = 0;
291	295	out_seg.filesize = 0;
292		try bw.writeStruct(out_seg);
	296	try writer.writeStruct(out_seg);
293	297	for (slice.items(.header)[sect_id..][0..seg.nsects]) \|header\| {
294	298	var out_header = header;
295	299	out_header.offset = 0;
296		try bw.writeStruct(out_header);
	300	try writer.writeStruct(out_header);
297	301	}
298	302	sect_id += seg.nsects;
299	303	}
...	...	@@ -302,22 +306,23 @@ fn writeLoadCommands(self: DebugSymbols, macho_file: MachO) !struct { usize, u
302	306	// Next, commit DSYM's __LINKEDIT and __DWARF segments headers.
303	307	sect_id = 0;
304	308	for (self.segments.items) \|seg\| {
305		try bw.writeStruct(seg);
	309	try writer.writeStruct(seg);
306	310	for (self.sections.items[sect_id..][0..seg.nsects]) \|header\| {
307		try bw.writeStruct(header);
	311	try writer.writeStruct(header);
308	312	}
309	313	sect_id += seg.nsects;
310	314	}
311	315	ncmds += self.segments.items.len;
312	316	}
313	317
314		try bw.writeStruct(self.symtab_cmd);
	318	try writer.writeStruct(self.symtab_cmd);
315	319	ncmds += 1;
316	320
317		assert(bw.end == bw.buffer.len);
318		try self.file.?.pwriteAll(bw.buffer, @sizeOf(macho.mach_header_64));
	321	assert(stream.pos == needed_size);
	322
	323	try self.file.?.pwriteAll(buffer, @sizeOf(macho.mach_header_64));
319	324
320		return .{ ncmds, bw.end };
	325	return .{ ncmds, buffer.len };
321	326	}
322	327
323	328	fn writeHeader(self: DebugSymbols, macho_file: MachO, ncmds: usize, sizeofcmds: usize) !void {

src/link/MachO/Dwarf.zig+30-18

...	...	@@ -81,7 +81,7 @@ pub const InfoReader = struct {
81	81	.dwarf64 => 12,
82	82	} + cuh_length;
83	83	while (p.pos < end_pos) {
84		const di_code = try p.readLeb128(u64);
	84	const di_code = try p.readUleb128(u64);
85	85	if (di_code == 0) return error.UnexpectedEndOfFile;
86	86	if (di_code == code) return;
87	87
...	...	@@ -174,14 +174,14 @@ pub const InfoReader = struct {
174	174	dw.FORM.block1 => try p.readByte(),
175	175	dw.FORM.block2 => try p.readInt(u16),
176	176	dw.FORM.block4 => try p.readInt(u32),
177		dw.FORM.block => try p.readLeb128(u64),
	177	dw.FORM.block => try p.readUleb128(u64),
178	178	else => unreachable,
179	179	};
180	180	return p.readNBytes(len);
181	181	}
182	182
183	183	pub fn readExprLoc(p: *InfoReader) ![]const u8 {
184		const len: u64 = try p.readLeb128(u64);
	184	const len: u64 = try p.readUleb128(u64);
185	185	return p.readNBytes(len);
186	186	}
187	187
...	...	@@ -191,8 +191,8 @@ pub const InfoReader = struct {
191	191	dw.FORM.data2, dw.FORM.ref2 => try p.readInt(u16),
192	192	dw.FORM.data4, dw.FORM.ref4 => try p.readInt(u32),
193	193	dw.FORM.data8, dw.FORM.ref8, dw.FORM.ref_sig8 => try p.readInt(u64),
194		dw.FORM.udata, dw.FORM.ref_udata => try p.readLeb128(u64),
195		dw.FORM.sdata => @bitCast(try p.readLeb128(i64)),
	194	dw.FORM.udata, dw.FORM.ref_udata => try p.readUleb128(u64),
	195	dw.FORM.sdata => @bitCast(try p.readIleb128(i64)),
196	196	else => return error.UnhandledConstantForm,
197	197	};
198	198	}
...	...	@@ -203,7 +203,7 @@ pub const InfoReader = struct {
203	203	dw.FORM.strx2, dw.FORM.addrx2 => try p.readInt(u16),
204	204	dw.FORM.strx3, dw.FORM.addrx3 => error.UnhandledForm,
205	205	dw.FORM.strx4, dw.FORM.addrx4 => try p.readInt(u32),
206		dw.FORM.strx, dw.FORM.addrx => try p.readLeb128(u64),
	206	dw.FORM.strx, dw.FORM.addrx => try p.readUleb128(u64),
207	207	else => return error.UnhandledIndexForm,
208	208	};
209	209	}
...	...	@@ -272,10 +272,20 @@ pub const InfoReader = struct {
272	272	};
273	273	}
274	274
275		pub fn readLeb128(p: *InfoReader, comptime Type: type) !Type {
276		var r: std.io.Reader = .fixed(p.bytes()[p.pos..]);
277		defer p.pos += r.seek;
278		return r.takeLeb128(Type);
	275	pub fn readUleb128(p: *InfoReader, comptime Type: type) !Type {
	276	var stream = std.io.fixedBufferStream(p.bytes()[p.pos..]);
	277	var creader = std.io.countingReader(stream.reader());
	278	const value: Type = try leb.readUleb128(Type, creader.reader());
	279	p.pos += math.cast(usize, creader.bytes_read) orelse return error.Overflow;
	280	return value;
	281	}
	282
	283	pub fn readIleb128(p: *InfoReader, comptime Type: type) !Type {
	284	var stream = std.io.fixedBufferStream(p.bytes()[p.pos..]);
	285	var creader = std.io.countingReader(stream.reader());
	286	const value: Type = try leb.readIleb128(Type, creader.reader());
	287	p.pos += math.cast(usize, creader.bytes_read) orelse return error.Overflow;
	288	return value;
279	289	}
280	290
281	291	pub fn seekTo(p: *InfoReader, off: u64) !void {
...	...	@@ -297,10 +307,10 @@ pub const AbbrevReader = struct {
297	307
298	308	pub fn readDecl(p: *AbbrevReader) !?AbbrevDecl {
299	309	const pos = p.pos;
300		const code = try p.readLeb128(Code);
	310	const code = try p.readUleb128(Code);
301	311	if (code == 0) return null;
302	312
303		const tag = try p.readLeb128(Tag);
	313	const tag = try p.readUleb128(Tag);
304	314	const has_children = (try p.readByte()) > 0;
305	315	return .{
306	316	.code = code,
...	...	@@ -313,8 +323,8 @@ pub const AbbrevReader = struct {
313	323
314	324	pub fn readAttr(p: *AbbrevReader) !?AbbrevAttr {
315	325	const pos = p.pos;
316		const at = try p.readLeb128(At);
317		const form = try p.readLeb128(Form);
	326	const at = try p.readUleb128(At);
	327	const form = try p.readUleb128(Form);
318	328	return if (at == 0 and form == 0) null else .{
319	329	.at = at,
320	330	.form = form,
...	...	@@ -329,10 +339,12 @@ pub const AbbrevReader = struct {
329	339	return p.bytes()[p.pos];
330	340	}
331	341
332		pub fn readLeb128(p: *AbbrevReader, comptime Type: type) !Type {
333		var r: std.io.Reader = .fixed(p.bytes()[p.pos..]);
334		defer p.pos += r.seek;
335		return r.takeLeb128(Type);
	342	pub fn readUleb128(p: *AbbrevReader, comptime Type: type) !Type {
	343	var stream = std.io.fixedBufferStream(p.bytes()[p.pos..]);
	344	var creader = std.io.countingReader(stream.reader());
	345	const value: Type = try leb.readUleb128(Type, creader.reader());
	346	p.pos += math.cast(usize, creader.bytes_read) orelse return error.Overflow;
	347	return value;
336	348	}
337	349
338	350	pub fn seekTo(p: *AbbrevReader, off: u64) !void {

src/link/MachO/Dylib.zig+58-17

...	...	@@ -158,6 +158,46 @@ fn parseBinary(self: Dylib, macho_file: MachO) !void {
158	158	}
159	159	}
160	160
	161	const TrieIterator = struct {
	162	data: []const u8,
	163	pos: usize = 0,
	164
	165	fn getStream(it: *TrieIterator) std.io.FixedBufferStream([]const u8) {
	166	return std.io.fixedBufferStream(it.data[it.pos..]);
	167	}
	168
	169	fn readUleb128(it: *TrieIterator) !u64 {
	170	var stream = it.getStream();
	171	var creader = std.io.countingReader(stream.reader());
	172	const reader = creader.reader();
	173	const value = try std.leb.readUleb128(u64, reader);
	174	it.pos += math.cast(usize, creader.bytes_read) orelse return error.Overflow;
	175	return value;
	176	}
	177
	178	fn readString(it: *TrieIterator) ![:0]const u8 {
	179	var stream = it.getStream();
	180	const reader = stream.reader();
	181
	182	var count: usize = 0;
	183	while (true) : (count += 1) {
	184	const byte = try reader.readByte();
	185	if (byte == 0) break;
	186	}
	187
	188	const str = @as([*:0]const u8, @ptrCast(it.data.ptr + it.pos))[0..count :0];
	189	it.pos += count + 1;
	190	return str;
	191	}
	192
	193	fn readByte(it: *TrieIterator) !u8 {
	194	var stream = it.getStream();
	195	const value = try stream.reader().readByte();
	196	it.pos += 1;
	197	return value;
	198	}
	199	};
	200
161	201	pub fn addExport(self: *Dylib, allocator: Allocator, name: []const u8, flags: Export.Flags) !void {
162	202	try self.exports.append(allocator, .{
163	203	.name = try self.addString(allocator, name),
...	...	@@ -167,16 +207,16 @@ pub fn addExport(self: *Dylib, allocator: Allocator, name: []const u8, flags: Ex
167	207
168	208	fn parseTrieNode(
169	209	self: *Dylib,
170		br: *std.io.Reader,
	210	it: *TrieIterator,
171	211	allocator: Allocator,
172	212	arena: Allocator,
173	213	prefix: []const u8,
174	214	) !void {
175	215	const tracy = trace(@src());
176	216	defer tracy.end();
177		const size = try br.takeLeb128(u64);
	217	const size = try it.readUleb128();
178	218	if (size > 0) {
179		const flags = try br.takeLeb128(u8);
	219	const flags = try it.readUleb128();
180	220	const kind = flags & macho.EXPORT_SYMBOL_FLAGS_KIND_MASK;
181	221	const out_flags = Export.Flags{
182	222	.abs = kind == macho.EXPORT_SYMBOL_FLAGS_KIND_ABSOLUTE,
...	...	@@ -184,28 +224,29 @@ fn parseTrieNode(
184	224	.weak = flags & macho.EXPORT_SYMBOL_FLAGS_WEAK_DEFINITION != 0,
185	225	};
186	226	if (flags & macho.EXPORT_SYMBOL_FLAGS_REEXPORT != 0) {
187		_ = try br.takeLeb128(u64); // dylib ordinal
188		const name = try br.takeSentinel(0);
	227	_ = try it.readUleb128(); // dylib ordinal
	228	const name = try it.readString();
189	229	try self.addExport(allocator, if (name.len > 0) name else prefix, out_flags);
190	230	} else if (flags & macho.EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER != 0) {
191		_ = try br.takeLeb128(u64); // stub offset
192		_ = try br.takeLeb128(u64); // resolver offset
	231	_ = try it.readUleb128(); // stub offset
	232	_ = try it.readUleb128(); // resolver offset
193	233	try self.addExport(allocator, prefix, out_flags);
194	234	} else {
195		_ = try br.takeLeb128(u64); // VM offset
	235	_ = try it.readUleb128(); // VM offset
196	236	try self.addExport(allocator, prefix, out_flags);
197	237	}
198	238	}
199	239
200		const nedges = try br.takeByte();
	240	const nedges = try it.readByte();
	241
201	242	for (0..nedges) \|_\| {
202		const label = try br.takeSentinel(0);
203		const off = try br.takeLeb128(usize);
	243	const label = try it.readString();
	244	const off = try it.readUleb128();
204	245	const prefix_label = try std.fmt.allocPrint(arena, "{s}{s}", .{ prefix, label });
205		const seek = br.seek;
206		br.seek = off;
207		try self.parseTrieNode(br, allocator, arena, prefix_label);
208		br.seek = seek;
	246	const curr = it.pos;
	247	it.pos = math.cast(usize, off) orelse return error.Overflow;
	248	try self.parseTrieNode(it, allocator, arena, prefix_label);
	249	it.pos = curr;
209	250	}
210	251	}
211	252
...	...	@@ -216,8 +257,8 @@ fn parseTrie(self: Dylib, data: []const u8, macho_file: MachO) !void {
216	257	var arena = std.heap.ArenaAllocator.init(gpa);
217	258	defer arena.deinit();
218	259
219		var r: std.io.Reader = .fixed(data);
220		try self.parseTrieNode(&r, gpa, arena.allocator(), "");
	260	var it: TrieIterator = .{ .data = data };
	261	try self.parseTrieNode(&it, gpa, arena.allocator(), "");
221	262	}
222	263
223	264	fn parseTbd(self: Dylib, macho_file: MachO) !void {

src/link/MachO/InternalObject.zig+1-1

...	...	@@ -261,7 +261,7 @@ fn addObjcMethnameSection(self: *InternalObject, methname: []const u8, macho_fil
261	261
262	262	sect.offset = @intCast(self.objc_methnames.items.len);
263	263	try self.objc_methnames.ensureUnusedCapacity(gpa, methname.len + 1);
264		self.objc_methnames.print(gpa, "{s}\x00", .{methname}) catch unreachable;
	264	self.objc_methnames.writer(gpa).print("{s}\x00", .{methname}) catch unreachable;
265	265
266	266	const name_str = try self.addString(gpa, "ltmp");
267	267	const sym_index = try self.addSymbol(gpa);

src/link/MachO/Object.zig+5-5

...	...	@@ -1069,7 +1069,7 @@ fn initEhFrameRecords(self: *Object, allocator: Allocator, sect_id: u8, file: Fi
1069	1069	}
1070	1070	}
1071	1071
1072		var it: eh_frame.Iterator = .{ .br = .fixed(self.eh_frame_data.items) };
	1072	var it = eh_frame.Iterator{ .data = self.eh_frame_data.items };
1073	1073	while (try it.next()) \|rec\| {
1074	1074	switch (rec.tag) {
1075	1075	.cie => try self.cies.append(allocator, .{
...	...	@@ -1698,11 +1698,11 @@ pub fn updateArSize(self: Object, macho_file: MachO) !void {
1698	1698	};
1699	1699	}
1700	1700
1701		pub fn writeAr(self: Object, bw: Writer, ar_format: Archive.Format, macho_file: MachO) !void {
	1701	pub fn writeAr(self: Object, ar_format: Archive.Format, macho_file: *MachO, writer: anytype) !void {
1702	1702	// Header
1703	1703	const size = try macho_file.cast(usize, self.output_ar_state.size);
1704	1704	const basename = std.fs.path.basename(self.path.sub_path);
1705		try Archive.writeHeader(bw, basename, size, ar_format);
	1705	try Archive.writeHeader(basename, size, ar_format, writer);
1706	1706	// Data
1707	1707	const file = macho_file.getFileHandle(self.file_handle);
1708	1708	// TODO try using copyRangeAll
...	...	@@ -1711,7 +1711,7 @@ pub fn writeAr(self: Object, bw: *Writer, ar_format: Archive.Format, macho_file:
1711	1711	defer gpa.free(data);
1712	1712	const amt = try file.preadAll(data, self.offset);
1713	1713	if (amt != size) return error.InputOutput;
1714		try bw.writeAll(data);
	1714	try writer.writeAll(data);
1715	1715	}
1716	1716
1717	1717	pub fn calcSymtabSize(self: Object, macho_file: MachO) void {
...	...	@@ -1865,7 +1865,7 @@ pub fn writeAtomsRelocatable(self: Object, macho_file: MachO) !void {
1865	1865	}
1866	1866	gpa.free(sections_data);
1867	1867	}
1868		@memset(sections_data, &.{});
	1868	@memset(sections_data, &[0]u8{});
1869	1869	const file = macho_file.getFileHandle(self.file_handle);
1870	1870
1871	1871	for (headers, 0..) \|header, n_sect\| {

src/link/MachO/Symbol.zig+1-1

...	...	@@ -297,7 +297,7 @@ const Format = struct {
297	297	symbol: Symbol,
298	298	macho_file: *MachO,
299	299
300		fn format2(f: Format, w: *Writer) Writer.Error!void {
	300	fn default(f: Format, w: *Writer) Writer.Error!void {
301	301	const symbol = f.symbol;
302	302	try w.print("%{d} : {s} : @{x}", .{
303	303	symbol.nlist_idx,

src/link/MachO/Thunk.zig+4-4

...	...	@@ -20,16 +20,16 @@ pub fn getTargetAddress(thunk: Thunk, ref: MachO.Ref, macho_file: *MachO) u64 {
20	20	return thunk.getAddress(macho_file) + thunk.symbols.getIndex(ref).? * trampoline_size;
21	21	}
22	22
23		pub fn write(thunk: Thunk, macho_file: MachO, bw: Writer) !void {
	23	pub fn write(thunk: Thunk, macho_file: *MachO, writer: anytype) !void {
24	24	for (thunk.symbols.keys(), 0..) \|ref, i\| {
25	25	const sym = ref.getSymbol(macho_file).?;
26	26	const saddr = thunk.getAddress(macho_file) + i * trampoline_size;
27	27	const taddr = sym.getAddress(.{}, macho_file);
28	28	const pages = try aarch64.calcNumberOfPages(@intCast(saddr), @intCast(taddr));
29		try bw.writeInt(u32, aarch64.Instruction.adrp(.x16, pages).toU32(), .little);
	29	try writer.writeInt(u32, aarch64.Instruction.adrp(.x16, pages).toU32(), .little);
30	30	const off: u12 = @truncate(taddr);
31		try bw.writeInt(u32, aarch64.Instruction.add(.x16, .x16, off, false).toU32(), .little);
32		try bw.writeInt(u32, aarch64.Instruction.br(.x16).toU32(), .little);
	31	try writer.writeInt(u32, aarch64.Instruction.add(.x16, .x16, off, false).toU32(), .little);
	32	try writer.writeInt(u32, aarch64.Instruction.br(.x16).toU32(), .little);
33	33	}
34	34	}
35	35

src/link/MachO/UnwindInfo.zig+18-12

...	...	@@ -289,10 +289,13 @@ pub fn calcSize(info: UnwindInfo) usize {
289	289	return total_size;
290	290	}
291	291
292		pub fn write(info: UnwindInfo, macho_file: MachO, bw: Writer) Writer.Error!void {
	292	pub fn write(info: UnwindInfo, macho_file: *MachO, buffer: []u8) !void {
293	293	const seg = macho_file.getTextSegment();
294	294	const header = macho_file.sections.items(.header)[macho_file.unwind_info_sect_index.?];
295	295
	296	var stream = std.io.fixedBufferStream(buffer);
	297	const writer = stream.writer();
	298
296	299	const common_encodings_offset: u32 = @sizeOf(macho.unwind_info_section_header);
297	300	const common_encodings_count: u32 = info.common_encodings_count;
298	301	const personalities_offset: u32 = common_encodings_offset + common_encodings_count * @sizeOf(u32);
...	...	@@ -300,7 +303,7 @@ pub fn write(info: UnwindInfo, macho_file: MachO, bw: Writer) Writer.Error!voi
300	303	const indexes_offset: u32 = personalities_offset + personalities_count * @sizeOf(u32);
301	304	const indexes_count: u32 = @as(u32, @intCast(info.pages.items.len + 1));
302	305
303		try bw.writeStruct(macho.unwind_info_section_header{
	306	try writer.writeStruct(macho.unwind_info_section_header{
304	307	.commonEncodingsArraySectionOffset = common_encodings_offset,
305	308	.commonEncodingsArrayCount = common_encodings_count,
306	309	.personalityArraySectionOffset = personalities_offset,
...	...	@@ -309,11 +312,11 @@ pub fn write(info: UnwindInfo, macho_file: MachO, bw: Writer) Writer.Error!voi
309	312	.indexCount = indexes_count,
310	313	});
311	314
312		try bw.writeAll(mem.sliceAsBytes(info.common_encodings[0..info.common_encodings_count]));
	315	try writer.writeAll(mem.sliceAsBytes(info.common_encodings[0..info.common_encodings_count]));
313	316
314	317	for (info.personalities[0..info.personalities_count]) \|ref\| {
315	318	const sym = ref.getSymbol(macho_file).?;
316		try bw.writeInt(u32, @intCast(sym.getGotAddress(macho_file) - seg.vmaddr), .little);
	319	try writer.writeInt(u32, @intCast(sym.getGotAddress(macho_file) - seg.vmaddr), .little);
317	320	}
318	321
319	322	const pages_base_offset = @as(u32, @intCast(header.size - (info.pages.items.len * second_level_page_bytes)));
...	...	@@ -322,7 +325,7 @@ pub fn write(info: UnwindInfo, macho_file: MachO, bw: Writer) Writer.Error!voi
322	325	for (info.pages.items, 0..) \|page, i\| {
323	326	assert(page.count > 0);
324	327	const rec = info.records.items[page.start].getUnwindRecord(macho_file);
325		try bw.writeStruct(macho.unwind_info_section_header_index_entry{
	328	try writer.writeStruct(macho.unwind_info_section_header_index_entry{
326	329	.functionOffset = @as(u32, @intCast(rec.getAtomAddress(macho_file) - seg.vmaddr)),
327	330	.secondLevelPagesSectionOffset = @as(u32, @intCast(pages_base_offset + i * second_level_page_bytes)),
328	331	.lsdaIndexArraySectionOffset = lsda_base_offset +
...	...	@@ -332,7 +335,7 @@ pub fn write(info: UnwindInfo, macho_file: MachO, bw: Writer) Writer.Error!voi
332	335
333	336	const last_rec = info.records.items[info.records.items.len - 1].getUnwindRecord(macho_file);
334	337	const sentinel_address = @as(u32, @intCast(last_rec.getAtomAddress(macho_file) + last_rec.length - seg.vmaddr));
335		try bw.writeStruct(macho.unwind_info_section_header_index_entry{
	338	try writer.writeStruct(macho.unwind_info_section_header_index_entry{
336	339	.functionOffset = sentinel_address,
337	340	.secondLevelPagesSectionOffset = 0,
338	341	.lsdaIndexArraySectionOffset = lsda_base_offset +
...	...	@@ -341,20 +344,23 @@ pub fn write(info: UnwindInfo, macho_file: MachO, bw: Writer) Writer.Error!voi
341	344
342	345	for (info.lsdas.items) \|index\| {
343	346	const rec = info.records.items[index].getUnwindRecord(macho_file);
344		try bw.writeStruct(macho.unwind_info_section_header_lsda_index_entry{
	347	try writer.writeStruct(macho.unwind_info_section_header_lsda_index_entry{
345	348	.functionOffset = @as(u32, @intCast(rec.getAtomAddress(macho_file) - seg.vmaddr)),
346	349	.lsdaOffset = @as(u32, @intCast(rec.getLsdaAddress(macho_file) - seg.vmaddr)),
347	350	});
348	351	}
349	352
350	353	for (info.pages.items) \|page\| {
351		const start = bw.count;
352		try page.write(info, macho_file, bw);
353		const nwritten = bw.count - start;
354		try bw.splatByteAll(0, math.cast(usize, second_level_page_bytes - nwritten) orelse return error.Overflow);
	354	const start = stream.pos;
	355	try page.write(info, macho_file, writer);
	356	const nwritten = stream.pos - start;
	357	if (nwritten < second_level_page_bytes) {
	358	const padding = math.cast(usize, second_level_page_bytes - nwritten) orelse return error.Overflow;
	359	try writer.writeByteNTimes(0, padding);
	360	}
355	361	}
356	362
357		@memset(bw.unusedCapacitySlice(), 0);
	363	@memset(buffer[stream.pos..], 0);
358	364	}
359	365
360	366	fn getOrPutPersonalityFunction(info: *UnwindInfo, ref: MachO.Ref) error{TooManyPersonalities}!u2 {

src/link/MachO/ZigObject.zig+5-3

...	...	@@ -317,12 +317,12 @@ pub fn updateArSize(self: *ZigObject) void {
317	317	self.output_ar_state.size = self.data.items.len;
318	318	}
319	319
320		pub fn writeAr(self: ZigObject, bw: *Writer, ar_format: Archive.Format) Writer.Error!void {
	320	pub fn writeAr(self: ZigObject, ar_format: Archive.Format, writer: anytype) !void {
321	321	// Header
322	322	const size = std.math.cast(usize, self.output_ar_state.size) orelse return error.Overflow;
323		try Archive.writeHeader(bw, self.basename, size, ar_format);
	323	try Archive.writeHeader(self.basename, size, ar_format, writer);
324	324	// Data
325		try bw.writeAll(self.data.items);
	325	try writer.writeAll(self.data.items);
326	326	}
327	327
328	328	pub fn claimUnresolved(self: ZigObject, macho_file: MachO) void {
...	...	@@ -884,6 +884,7 @@ pub fn updateNav(
884	884	defer debug_wip_nav.deinit();
885	885	dwarf.finishWipNav(pt, nav_index, &debug_wip_nav) catch \|err\| switch (err) {
886	886	error.OutOfMemory => return error.OutOfMemory,
	887	error.Overflow => return error.Overflow,
887	888	else => \|e\| return macho_file.base.cgFail(nav_index, "failed to finish dwarf nav: {s}", .{@errorName(e)}),
888	889	};
889	890	}
...	...	@@ -920,6 +921,7 @@ pub fn updateNav(
920	921
921	922	if (debug_wip_nav) \|*wip_nav\| self.dwarf.?.finishWipNav(pt, nav_index, wip_nav) catch \|err\| switch (err) {
922	923	error.OutOfMemory => return error.OutOfMemory,
	924	error.Overflow => return error.Overflow,
923	925	else => \|e\| return macho_file.base.cgFail(nav_index, "failed to finish dwarf nav: {s}", .{@errorName(e)}),
924	926	};
925	927	} else if (self.dwarf) \|*dwarf\| try dwarf.updateComptimeNav(pt, nav_index);

src/link/MachO/dyld_info/Rebase.zig+45-45

...	...	@@ -3,7 +3,7 @@ buffer: std.ArrayListUnmanaged(u8) = .empty,
3	3
4	4	pub const Entry = struct {
5	5	offset: u64,
6		segment_id: u4,
	6	segment_id: u8,
7	7
8	8	pub fn lessThan(ctx: void, entry: Entry, other: Entry) bool {
9	9	_ = ctx;
...	...	@@ -110,35 +110,33 @@ pub fn updateSize(rebase: Rebase, macho_file: MachO) !void {
110	110	fn finalize(rebase: *Rebase, gpa: Allocator) !void {
111	111	if (rebase.entries.items.len == 0) return;
112	112
113		var aw: std.io.Writer.Allocating = .fromArrayList(gpa, &rebase.buffer);
114		const bw = &aw.writer;
115		defer rebase.buffer = aw.toArrayList();
	113	const writer = rebase.buffer.writer(gpa);
116	114
117	115	log.debug("rebase opcodes", .{});
118	116
119	117	std.mem.sort(Entry, rebase.entries.items, {}, Entry.lessThan);
120	118
121		try setTypePointer(bw);
	119	try setTypePointer(writer);
122	120
123	121	var start: usize = 0;
124	122	var seg_id: ?u8 = null;
125	123	for (rebase.entries.items, 0..) \|entry, i\| {
126	124	if (seg_id != null and seg_id.? == entry.segment_id) continue;
127		try finalizeSegment(rebase.entries.items[start..i], bw);
	125	try finalizeSegment(rebase.entries.items[start..i], writer);
128	126	seg_id = entry.segment_id;
129	127	start = i;
130	128	}
131	129
132		try finalizeSegment(rebase.entries.items[start..], bw);
133		try done(bw);
	130	try finalizeSegment(rebase.entries.items[start..], writer);
	131	try done(writer);
134	132	}
135	133
136		fn finalizeSegment(entries: []const Entry, bw: *Writer) Writer.Error!void {
	134	fn finalizeSegment(entries: []const Entry, writer: anytype) !void {
137	135	if (entries.len == 0) return;
138	136
139	137	const segment_id = entries[0].segment_id;
140	138	var offset = entries[0].offset;
141		try setSegmentOffset(segment_id, offset, bw);
	139	try setSegmentOffset(segment_id, offset, writer);
142	140
143	141	var count: usize = 0;
144	142	var skip: u64 = 0;
...	...	@@ -157,7 +155,7 @@ fn finalizeSegment(entries: []const Entry, bw: *Writer) Writer.Error!void {
157	155	.start => {
158	156	if (offset < current_offset) {
159	157	const delta = current_offset - offset;
160		try addAddr(delta, bw);
	158	try addAddr(delta, writer);
161	159	offset += delta;
162	160	}
163	161	state = .times;
...	...	@@ -177,7 +175,7 @@ fn finalizeSegment(entries: []const Entry, bw: *Writer) Writer.Error!void {
177	175	offset += skip;
178	176	i -= 1;
179	177	} else {
180		try rebaseTimes(count, bw);
	178	try rebaseTimes(count, writer);
181	179	state = .start;
182	180	i -= 1;
183	181	}
...	...	@@ -186,9 +184,9 @@ fn finalizeSegment(entries: []const Entry, bw: *Writer) Writer.Error!void {
186	184	if (current_offset < offset) {
187	185	count -= 1;
188	186	if (count == 1) {
189		try rebaseAddAddr(skip, bw);
	187	try rebaseAddAddr(skip, writer);
190	188	} else {
191		try rebaseTimesSkip(count, skip, bw);
	189	try rebaseTimesSkip(count, skip, writer);
192	190	}
193	191	state = .start;
194	192	offset = offset - (@sizeOf(u64) + skip);
...	...	@@ -201,7 +199,7 @@ fn finalizeSegment(entries: []const Entry, bw: *Writer) Writer.Error!void {
201	199	count += 1;
202	200	offset += @sizeOf(u64) + skip;
203	201	} else {
204		try rebaseTimesSkip(count, skip, bw);
	202	try rebaseTimesSkip(count, skip, writer);
205	203	state = .start;
206	204	i -= 1;
207	205	}
...	...	@@ -212,66 +210,68 @@ fn finalizeSegment(entries: []const Entry, bw: *Writer) Writer.Error!void {
212	210	switch (state) {
213	211	.start => unreachable,
214	212	.times => {
215		try rebaseTimes(count, bw);
	213	try rebaseTimes(count, writer);
216	214	},
217	215	.times_skip => {
218		try rebaseTimesSkip(count, skip, bw);
	216	try rebaseTimesSkip(count, skip, writer);
219	217	},
220	218	}
221	219	}
222	220
223		fn setTypePointer(bw: *Writer) Writer.Error!void {
	221	fn setTypePointer(writer: anytype) !void {
224	222	log.debug(">>> set type: {d}", .{macho.REBASE_TYPE_POINTER});
225		try bw.writeByte(macho.REBASE_OPCODE_SET_TYPE_IMM \| @as(u4, @intCast(macho.REBASE_TYPE_POINTER)));
	223	try writer.writeByte(macho.REBASE_OPCODE_SET_TYPE_IMM \| @as(u4, @truncate(macho.REBASE_TYPE_POINTER)));
226	224	}
227	225
228		fn setSegmentOffset(segment_id: u4, offset: u64, bw: *Writer) Writer.Error!void {
	226	fn setSegmentOffset(segment_id: u8, offset: u64, writer: anytype) !void {
229	227	log.debug(">>> set segment: {d} and offset: {x}", .{ segment_id, offset });
230		try bw.writeByte(macho.REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB \| @as(u4, @truncate(segment_id)));
231		try bw.writeLeb128(offset);
	228	try writer.writeByte(macho.REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB \| @as(u4, @truncate(segment_id)));
	229	try std.leb.writeUleb128(writer, offset);
232	230	}
233	231
234		fn rebaseAddAddr(addr: u64, bw: *Writer) Writer.Error!void {
	232	fn rebaseAddAddr(addr: u64, writer: anytype) !void {
235	233	log.debug(">>> rebase with add: {x}", .{addr});
236		try bw.writeByte(macho.REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB);
237		try bw.writeLeb128(addr);
	234	try writer.writeByte(macho.REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB);
	235	try std.leb.writeUleb128(writer, addr);
238	236	}
239	237
240		fn rebaseTimes(count: usize, bw: *Writer) Writer.Error!void {
	238	fn rebaseTimes(count: usize, writer: anytype) !void {
241	239	log.debug(">>> rebase with count: {d}", .{count});
242	240	if (count <= 0xf) {
243		try bw.writeByte(macho.REBASE_OPCODE_DO_REBASE_IMM_TIMES \| @as(u4, @truncate(count)));
	241	try writer.writeByte(macho.REBASE_OPCODE_DO_REBASE_IMM_TIMES \| @as(u4, @truncate(count)));
244	242	} else {
245		try bw.writeByte(macho.REBASE_OPCODE_DO_REBASE_ULEB_TIMES);
246		try bw.writeLeb128(count);
	243	try writer.writeByte(macho.REBASE_OPCODE_DO_REBASE_ULEB_TIMES);
	244	try std.leb.writeUleb128(writer, count);
247	245	}
248	246	}
249	247
250		fn rebaseTimesSkip(count: usize, skip: u64, bw: *Writer) Writer.Error!void {
	248	fn rebaseTimesSkip(count: usize, skip: u64, writer: anytype) !void {
251	249	log.debug(">>> rebase with count: {d} and skip: {x}", .{ count, skip });
252		try bw.writeByte(macho.REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB);
253		try bw.writeLeb128(count);
254		try bw.writeLeb128(skip);
	250	try writer.writeByte(macho.REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB);
	251	try std.leb.writeUleb128(writer, count);
	252	try std.leb.writeUleb128(writer, skip);
255	253	}
256	254
257		fn addAddr(addr: u64, bw: *Writer) Writer.Error!void {
	255	fn addAddr(addr: u64, writer: anytype) !void {
258	256	log.debug(">>> add: {x}", .{addr});
259		if (std.math.divExact(u64, addr, @sizeOf(u64))) \|scaled\| {
260		if (std.math.cast(u4, scaled)) \|imm_scaled\| return bw.writeByte(
261		macho.REBASE_OPCODE_ADD_ADDR_IMM_SCALED \| imm_scaled,
262		);
263		} else \|_\| {}
264		try bw.writeByte(macho.REBASE_OPCODE_ADD_ADDR_ULEB);
265		try bw.writeLeb128(addr);
	257	if (std.mem.isAlignedGeneric(u64, addr, @sizeOf(u64))) {
	258	const imm = @divExact(addr, @sizeOf(u64));
	259	if (imm <= 0xf) {
	260	try writer.writeByte(macho.REBASE_OPCODE_ADD_ADDR_IMM_SCALED \| @as(u4, @truncate(imm)));
	261	return;
	262	}
	263	}
	264	try writer.writeByte(macho.REBASE_OPCODE_ADD_ADDR_ULEB);
	265	try std.leb.writeUleb128(writer, addr);
266	266	}
267	267
268		fn done(bw: *Writer) Writer.Error!void {
	268	fn done(writer: anytype) !void {
269	269	log.debug(">>> done", .{});
270		try bw.writeByte(macho.REBASE_OPCODE_DONE);
	270	try writer.writeByte(macho.REBASE_OPCODE_DONE);
271	271	}
272	272
273		pub fn write(rebase: Rebase, bw: *Writer) Writer.Error!void {
274		try bw.writeAll(rebase.buffer.items);
	273	pub fn write(rebase: Rebase, writer: anytype) !void {
	274	try writer.writeAll(rebase.buffer.items);
275	275	}
276	276
277	277	test "rebase - no entries" {

src/link/MachO/dyld_info/Trie.zig+37-32

...	...	@@ -31,7 +31,7 @@
31	31
32	32	/// The root node of the trie.
33	33	root: ?Node.Index = null,
34		buffer: []u8 = &.{},
	34	buffer: std.ArrayListUnmanaged(u8) = .empty,
35	35	nodes: std.MultiArrayList(Node) = .{},
36	36	edges: std.ArrayListUnmanaged(Edge) = .empty,
37	37
...	...	@@ -123,7 +123,7 @@ pub fn updateSize(self: Trie, macho_file: MachO) !void {
123	123
124	124	try self.finalize(gpa);
125	125
126		macho_file.dyld_info_cmd.export_size = mem.alignForward(u32, @intCast(self.buffer.len), @alignOf(u64));
	126	macho_file.dyld_info_cmd.export_size = mem.alignForward(u32, @intCast(self.buffer.items.len), @alignOf(u64));
127	127	}
128	128
129	129	/// Finalizes this trie for writing to a byte stream.
...	...	@@ -138,7 +138,7 @@ fn finalize(self: *Trie, allocator: Allocator) !void {
138	138	defer ordered_nodes.deinit();
139	139	try ordered_nodes.ensureTotalCapacityPrecise(self.nodes.items(.is_terminal).len);
140	140
141		var fifo = DeprecatedLinearFifo(Node.Index).init(allocator);
	141	var fifo = std.fifo.LinearFifo(Node.Index, .Dynamic).init(allocator);
142	142	defer fifo.deinit();
143	143
144	144	try fifo.writeItem(self.root.?);
...	...	@@ -164,11 +164,9 @@ fn finalize(self: *Trie, allocator: Allocator) !void {
164	164	}
165	165	}
166	166
167		assert(self.buffer.len == 0);
168		self.buffer = try allocator.alloc(u8, size);
169		var bw: Writer = .fixed(self.buffer);
	167	try self.buffer.ensureTotalCapacityPrecise(allocator, size);
170	168	for (ordered_nodes.items) \|node_index\| {
171		try self.writeNode(node_index, &bw);
	169	try self.writeNode(node_index, self.buffer.writer(allocator));
172	170	}
173	171	}
174	172
...	...	@@ -183,17 +181,17 @@ const FinalizeNodeResult = struct {
183	181
184	182	/// Updates offset of this node in the output byte stream.
185	183	fn finalizeNode(self: *Trie, node_index: Node.Index, offset_in_trie: u32) !FinalizeNodeResult {
186		var buf: [1024]u8 = undefined;
187		var bw: Writer = .discarding(&buf);
	184	var stream = std.io.countingWriter(std.io.null_writer);
	185	const writer = stream.writer();
188	186	const slice = self.nodes.slice();
189	187
190	188	var node_size: u32 = 0;
191	189	if (slice.items(.is_terminal)[node_index]) {
192	190	const export_flags = slice.items(.export_flags)[node_index];
193	191	const vmaddr_offset = slice.items(.vmaddr_offset)[node_index];
194		try bw.writeLeb128(export_flags);
195		try bw.writeLeb128(vmaddr_offset);
196		try bw.writeLeb128(bw.count);
	192	try leb.writeULEB128(writer, export_flags);
	193	try leb.writeULEB128(writer, vmaddr_offset);
	194	try leb.writeULEB128(writer, stream.bytes_written);
197	195	} else {
198	196	node_size += 1; // 0x0 for non-terminal nodes
199	197	}
...	...	@@ -203,13 +201,13 @@ fn finalizeNode(self: *Trie, node_index: Node.Index, offset_in_trie: u32) !Final
203	201	const edge = &self.edges.items[edge_index];
204	202	const next_node_offset = slice.items(.trie_offset)[edge.node];
205	203	node_size += @intCast(edge.label.len + 1);
206		try bw.writeLeb128(next_node_offset);
	204	try leb.writeULEB128(writer, next_node_offset);
207	205	}
208	206
209	207	const trie_offset = slice.items(.trie_offset)[node_index];
210	208	const updated = offset_in_trie != trie_offset;
211	209	slice.items(.trie_offset)[node_index] = offset_in_trie;
212		node_size += @intCast(bw.count);
	210	node_size += @intCast(stream.bytes_written);
213	211
214	212	return .{ .node_size = node_size, .updated = updated };
215	213	}
...	...	@@ -225,11 +223,12 @@ pub fn deinit(self: *Trie, allocator: Allocator) void {
225	223	}
226	224	self.nodes.deinit(allocator);
227	225	self.edges.deinit(allocator);
228		allocator.free(self.buffer);
	226	self.buffer.deinit(allocator);
229	227	}
230	228
231		pub fn write(self: Trie, bw: *Writer) Writer.Error!void {
232		try bw.writeAll(self.buffer);
	229	pub fn write(self: Trie, writer: anytype) !void {
	230	if (self.buffer.items.len == 0) return;
	231	try writer.writeAll(self.buffer.items);
233	232	}
234	233
235	234	/// Writes this node to a byte stream.
...	...	@@ -238,7 +237,7 @@ pub fn write(self: Trie, bw: *Writer) Writer.Error!void {
238	237	/// iterate over `Trie.ordered_nodes` and call this method on each node.
239	238	/// This is one of the requirements of the MachO.
240	239	/// Panics if `finalize` was not called before calling this method.
241		fn writeNode(self: Trie, node_index: Node.Index, bw: Writer) !void {
	240	fn writeNode(self: *Trie, node_index: Node.Index, writer: anytype) !void {
242	241	const slice = self.nodes.slice();
243	242	const edges = slice.items(.edges)[node_index];
244	243	const is_terminal = slice.items(.is_terminal)[node_index];
...	...	@@ -246,28 +245,36 @@ fn writeNode(self: Trie, node_index: Node.Index, bw: Writer) !void {
246	245	const vmaddr_offset = slice.items(.vmaddr_offset)[node_index];
247	246
248	247	if (is_terminal) {
249		const start = bw.count;
	248	// Terminal node info: encode export flags and vmaddr offset of this symbol.
	249	var info_buf: [@sizeOf(u64) * 2]u8 = undefined;
	250	var info_stream = std.io.fixedBufferStream(&info_buf);
250	251	// TODO Implement for special flags.
251	252	assert(export_flags & macho.EXPORT_SYMBOL_FLAGS_REEXPORT == 0 and
252	253	export_flags & macho.EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER == 0);
253		// Terminal node info: encode export flags and vmaddr offset of this symbol.
254		try bw.writeLeb128(export_flags);
255		try bw.writeLeb128(vmaddr_offset);
	254	try leb.writeULEB128(info_stream.writer(), export_flags);
	255	try leb.writeULEB128(info_stream.writer(), vmaddr_offset);
	256
256	257	// Encode the size of the terminal node info.
257		try bw.writeLeb128(bw.count - start);
	258	var size_buf: [@sizeOf(u64)]u8 = undefined;
	259	var size_stream = std.io.fixedBufferStream(&size_buf);
	260	try leb.writeULEB128(size_stream.writer(), info_stream.pos);
	261
	262	// Now, write them to the output stream.
	263	try writer.writeAll(size_buf[0..size_stream.pos]);
	264	try writer.writeAll(info_buf[0..info_stream.pos]);
258	265	} else {
259	266	// Non-terminal node is delimited by 0 byte.
260		try bw.writeByte(0);
	267	try writer.writeByte(0);
261	268	}
262		// Write number of edges (max legal number of edges is 255).
263		try bw.writeByte(@intCast(edges.items.len));
	269	// Write number of edges (max legal number of edges is 256).
	270	try writer.writeByte(@as(u8, @intCast(edges.items.len)));
264	271
265	272	for (edges.items) \|edge_index\| {
266	273	const edge = self.edges.items[edge_index];
267	274	// Write edge label and offset to next node in trie.
268		try bw.writeAll(edge.label);
269		try bw.writeByte(0);
270		try bw.writeLeb128(slice.items(.trie_offset)[edge.node]);
	275	try writer.writeAll(edge.label);
	276	try writer.writeByte(0);
	277	try leb.writeULEB128(writer, slice.items(.trie_offset)[edge.node]);
271	278	}
272	279	}
273	280
...	...	@@ -407,10 +414,8 @@ const macho = std.macho;
407	414	const mem = std.mem;
408	415	const std = @import("std");
409	416	const testing = std.testing;
410		const Writer = std.io.Writer;
411
412	417	const trace = @import("../../../tracy.zig").trace;
413		const DeprecatedLinearFifo = @import("../../../deprecated.zig").LinearFifo;
	418
414	419	const Allocator = mem.Allocator;
415	420	const MachO = @import("../../MachO.zig");
416	421	const Trie = @This();

src/link/MachO/dyld_info/bind.zig+187-155

...	...	@@ -1,7 +1,7 @@
1	1	pub const Entry = struct {
2	2	target: MachO.Ref,
3	3	offset: u64,
4		segment_id: u4,
	4	segment_id: u8,
5	5	addend: i64,
6	6
7	7	pub fn lessThan(ctx: *MachO, entry: Entry, other: Entry) bool {
...	...	@@ -20,12 +20,14 @@ pub const Bind = struct {
20	20	entries: std.ArrayListUnmanaged(Entry) = .empty,
21	21	buffer: std.ArrayListUnmanaged(u8) = .empty,
22	22
23		pub fn deinit(bind: *Bind, gpa: Allocator) void {
24		bind.entries.deinit(gpa);
25		bind.buffer.deinit(gpa);
	23	const Self = @This();
	24
	25	pub fn deinit(self: *Self, gpa: Allocator) void {
	26	self.entries.deinit(gpa);
	27	self.buffer.deinit(gpa);
26	28	}
27	29
28		pub fn updateSize(bind: Bind, macho_file: MachO) !void {
	30	pub fn updateSize(self: Self, macho_file: MachO) !void {
29	31	const tracy = trace(@src());
30	32	defer tracy.end();
31	33
...	...	@@ -54,12 +56,15 @@ pub const Bind = struct {
54	56	const addend = rel.addend + rel.getRelocAddend(cpu_arch);
55	57	const sym = rel.getTargetSymbol(atom.*, macho_file);
56	58	if (sym.isTlvInit(macho_file)) continue;
57		if (sym.flags.import or (!(sym.flags.@"export" and sym.flags.weak) and sym.flags.interposable)) (try bind.entries.addOne(gpa)).* = .{
	59	const entry = Entry{
58	60	.target = rel.getTargetSymbolRef(atom.*, macho_file),
59	61	.offset = atom_addr + rel_offset - seg.vmaddr,
60	62	.segment_id = seg_id,
61	63	.addend = addend,
62	64	};
	65	if (sym.flags.import or (!(sym.flags.@"export" and sym.flags.weak) and sym.flags.interposable)) {
	66	try self.entries.append(gpa, entry);
	67	}
63	68	}
64	69	}
65	70	}
...	...	@@ -70,12 +75,15 @@ pub const Bind = struct {
70	75	for (macho_file.got.symbols.items, 0..) \|ref, idx\| {
71	76	const sym = ref.getSymbol(macho_file).?;
72	77	const addr = macho_file.got.getAddress(@intCast(idx), macho_file);
73		if (sym.flags.import or (sym.flags.@"export" and sym.flags.interposable and !sym.flags.weak)) (try bind.entries.addOne(gpa)).* = .{
	78	const entry = Entry{
74	79	.target = ref,
75	80	.offset = addr - seg.vmaddr,
76	81	.segment_id = seg_id,
77	82	.addend = 0,
78	83	};
	84	if (sym.flags.import or (sym.flags.@"export" and sym.flags.interposable and !sym.flags.weak)) {
	85	try self.entries.append(gpa, entry);
	86	}
79	87	}
80	88	}
81	89
...	...	@@ -86,12 +94,15 @@ pub const Bind = struct {
86	94	for (macho_file.stubs.symbols.items, 0..) \|ref, idx\| {
87	95	const sym = ref.getSymbol(macho_file).?;
88	96	const addr = sect.addr + idx * @sizeOf(u64);
89		if (sym.flags.import and sym.flags.weak) (try bind.entries.addOne(gpa)).* = .{
	97	const bind_entry = Entry{
90	98	.target = ref,
91	99	.offset = addr - seg.vmaddr,
92	100	.segment_id = seg_id,
93	101	.addend = 0,
94	102	};
	103	if (sym.flags.import and sym.flags.weak) {
	104	try self.entries.append(gpa, bind_entry);
	105	}
95	106	}
96	107	}
97	108
...	...	@@ -102,48 +113,49 @@ pub const Bind = struct {
102	113	for (macho_file.tlv_ptr.symbols.items, 0..) \|ref, idx\| {
103	114	const sym = ref.getSymbol(macho_file).?;
104	115	const addr = macho_file.tlv_ptr.getAddress(@intCast(idx), macho_file);
105		if (sym.flags.import or (sym.flags.@"export" and sym.flags.interposable and !sym.flags.weak)) (try bind.entries.addOne(gpa)).* = .{
	116	const entry = Entry{
106	117	.target = ref,
107	118	.offset = addr - seg.vmaddr,
108	119	.segment_id = seg_id,
109	120	.addend = 0,
110	121	};
	122	if (sym.flags.import or (sym.flags.@"export" and sym.flags.interposable and !sym.flags.weak)) {
	123	try self.entries.append(gpa, entry);
	124	}
111	125	}
112	126	}
113	127
114		try bind.finalize(gpa, macho_file);
115		macho_file.dyld_info_cmd.bind_size = mem.alignForward(u32, @intCast(bind.buffer.items.len), @alignOf(u64));
	128	try self.finalize(gpa, macho_file);
	129	macho_file.dyld_info_cmd.bind_size = mem.alignForward(u32, @intCast(self.buffer.items.len), @alignOf(u64));
116	130	}
117	131
118		fn finalize(bind: Bind, gpa: Allocator, ctx: MachO) !void {
119		if (bind.entries.items.len == 0) return;
	132	fn finalize(self: Self, gpa: Allocator, ctx: MachO) !void {
	133	if (self.entries.items.len == 0) return;
120	134
121		var aw: std.io.Writer.Allocating = .fromArrayList(gpa, &bind.buffer);
122		const bw = &aw.writer;
123		defer bind.buffer = aw.toArrayList();
	135	const writer = self.buffer.writer(gpa);
124	136
125	137	log.debug("bind opcodes", .{});
126	138
127		std.mem.sort(Entry, bind.entries.items, ctx, Entry.lessThan);
	139	std.mem.sort(Entry, self.entries.items, ctx, Entry.lessThan);
128	140
129	141	var start: usize = 0;
130	142	var seg_id: ?u8 = null;
131		for (bind.entries.items, 0..) \|entry, i\| {
	143	for (self.entries.items, 0..) \|entry, i\| {
132	144	if (seg_id != null and seg_id.? == entry.segment_id) continue;
133		try finalizeSegment(bind.entries.items[start..i], ctx, bw);
	145	try finalizeSegment(self.entries.items[start..i], ctx, writer);
134	146	seg_id = entry.segment_id;
135	147	start = i;
136	148	}
137	149
138		try finalizeSegment(bind.entries.items[start..], ctx, bw);
139		try done(bw);
	150	try finalizeSegment(self.entries.items[start..], ctx, writer);
	151	try done(writer);
140	152	}
141	153
142		fn finalizeSegment(entries: []const Entry, ctx: MachO, bw: Writer) Writer.Error!void {
	154	fn finalizeSegment(entries: []const Entry, ctx: *MachO, writer: anytype) !void {
143	155	if (entries.len == 0) return;
144	156
145	157	const seg_id = entries[0].segment_id;
146		try setSegmentOffset(seg_id, 0, bw);
	158	try setSegmentOffset(seg_id, 0, writer);
147	159
148	160	var offset: u64 = 0;
149	161	var addend: i64 = 0;
...	...	@@ -163,15 +175,15 @@ pub const Bind = struct {
163	175	if (target == null or !target.?.eql(current.target)) {
164	176	switch (state) {
165	177	.start => {},
166		.bind_single => try doBind(bw),
167		.bind_times_skip => try doBindTimesSkip(count, skip, bw),
	178	.bind_single => try doBind(writer),
	179	.bind_times_skip => try doBindTimesSkip(count, skip, writer),
168	180	}
169	181	state = .start;
170	182	target = current.target;
171	183
172	184	const sym = current.target.getSymbol(ctx).?;
173	185	const name = sym.getName(ctx);
174		const flags: u4 = if (sym.weakRef(ctx)) macho.BIND_SYMBOL_FLAGS_WEAK_IMPORT else 0;
	186	const flags: u8 = if (sym.weakRef(ctx)) macho.BIND_SYMBOL_FLAGS_WEAK_IMPORT else 0;
175	187	const ordinal: i16 = ord: {
176	188	if (sym.flags.interposable) break :ord macho.BIND_SPECIAL_DYLIB_FLAT_LOOKUP;
177	189	if (sym.flags.import) {
...	...	@@ -183,13 +195,13 @@ pub const Bind = struct {
183	195	break :ord macho.BIND_SPECIAL_DYLIB_SELF;
184	196	};
185	197
186		try setSymbol(name, flags, bw);
187		try setTypePointer(bw);
188		try setDylibOrdinal(ordinal, bw);
	198	try setSymbol(name, flags, writer);
	199	try setTypePointer(writer);
	200	try setDylibOrdinal(ordinal, writer);
189	201
190	202	if (current.addend != addend) {
191	203	addend = current.addend;
192		try setAddend(addend, bw);
	204	try setAddend(addend, writer);
193	205	}
194	206	}
195	207
...	...	@@ -198,11 +210,11 @@ pub const Bind = struct {
198	210	switch (state) {
199	211	.start => {
200	212	if (current.offset < offset) {
201		try addAddr(@bitCast(@as(i64, @intCast(current.offset)) - @as(i64, @intCast(offset))), bw);
	213	try addAddr(@bitCast(@as(i64, @intCast(current.offset)) - @as(i64, @intCast(offset))), writer);
202	214	offset = offset - (offset - current.offset);
203	215	} else if (current.offset > offset) {
204	216	const delta = current.offset - offset;
205		try addAddr(delta, bw);
	217	try addAddr(delta, writer);
206	218	offset += delta;
207	219	}
208	220	state = .bind_single;
...	...	@@ -211,7 +223,7 @@ pub const Bind = struct {
211	223	},
212	224	.bind_single => {
213	225	if (current.offset == offset) {
214		try doBind(bw);
	226	try doBind(writer);
215	227	state = .start;
216	228	} else if (current.offset > offset) {
217	229	const delta = current.offset - offset;
...	...	@@ -225,9 +237,9 @@ pub const Bind = struct {
225	237	if (current.offset < offset) {
226	238	count -= 1;
227	239	if (count == 1) {
228		try doBindAddAddr(skip, bw);
	240	try doBindAddAddr(skip, writer);
229	241	} else {
230		try doBindTimesSkip(count, skip, bw);
	242	try doBindTimesSkip(count, skip, writer);
231	243	}
232	244	state = .start;
233	245	offset = offset - (@sizeOf(u64) + skip);
...	...	@@ -236,7 +248,7 @@ pub const Bind = struct {
236	248	count += 1;
237	249	offset += @sizeOf(u64) + skip;
238	250	} else {
239		try doBindTimesSkip(count, skip, bw);
	251	try doBindTimesSkip(count, skip, writer);
240	252	state = .start;
241	253	i -= 1;
242	254	}
...	...	@@ -246,13 +258,13 @@ pub const Bind = struct {
246	258
247	259	switch (state) {
248	260	.start => unreachable,
249		.bind_single => try doBind(bw),
250		.bind_times_skip => try doBindTimesSkip(count, skip, bw),
	261	.bind_single => try doBind(writer),
	262	.bind_times_skip => try doBindTimesSkip(count, skip, writer),
251	263	}
252	264	}
253	265
254		pub fn write(bind: Bind, bw: *Writer) Writer.Error!void {
255		try bw.writeAll(bind.buffer.items);
	266	pub fn write(self: Self, writer: anytype) !void {
	267	try writer.writeAll(self.buffer.items);
256	268	}
257	269	};
258	270
...	...	@@ -260,12 +272,14 @@ pub const WeakBind = struct {
260	272	entries: std.ArrayListUnmanaged(Entry) = .empty,
261	273	buffer: std.ArrayListUnmanaged(u8) = .empty,
262	274
263		pub fn deinit(bind: *WeakBind, gpa: Allocator) void {
264		bind.entries.deinit(gpa);
265		bind.buffer.deinit(gpa);
	275	const Self = @This();
	276
	277	pub fn deinit(self: *Self, gpa: Allocator) void {
	278	self.entries.deinit(gpa);
	279	self.buffer.deinit(gpa);
266	280	}
267	281
268		pub fn updateSize(bind: WeakBind, macho_file: MachO) !void {
	282	pub fn updateSize(self: Self, macho_file: MachO) !void {
269	283	const tracy = trace(@src());
270	284	defer tracy.end();
271	285
...	...	@@ -294,12 +308,15 @@ pub const WeakBind = struct {
294	308	const addend = rel.addend + rel.getRelocAddend(cpu_arch);
295	309	const sym = rel.getTargetSymbol(atom.*, macho_file);
296	310	if (sym.isTlvInit(macho_file)) continue;
297		if (!sym.isLocal() and sym.flags.weak) (try bind.entries.addOne(gpa)).* = .{
	311	const entry = Entry{
298	312	.target = rel.getTargetSymbolRef(atom.*, macho_file),
299	313	.offset = atom_addr + rel_offset - seg.vmaddr,
300	314	.segment_id = seg_id,
301	315	.addend = addend,
302	316	};
	317	if (!sym.isLocal() and sym.flags.weak) {
	318	try self.entries.append(gpa, entry);
	319	}
303	320	}
304	321	}
305	322	}
...	...	@@ -310,12 +327,15 @@ pub const WeakBind = struct {
310	327	for (macho_file.got.symbols.items, 0..) \|ref, idx\| {
311	328	const sym = ref.getSymbol(macho_file).?;
312	329	const addr = macho_file.got.getAddress(@intCast(idx), macho_file);
313		if (sym.flags.weak) (try bind.entries.addOne(gpa)).* = .{
	330	const entry = Entry{
314	331	.target = ref,
315	332	.offset = addr - seg.vmaddr,
316	333	.segment_id = seg_id,
317	334	.addend = 0,
318	335	};
	336	if (sym.flags.weak) {
	337	try self.entries.append(gpa, entry);
	338	}
319	339	}
320	340	}
321	341
...	...	@@ -327,12 +347,15 @@ pub const WeakBind = struct {
327	347	for (macho_file.stubs.symbols.items, 0..) \|ref, idx\| {
328	348	const sym = ref.getSymbol(macho_file).?;
329	349	const addr = sect.addr + idx * @sizeOf(u64);
330		if (sym.flags.weak) (try bind.entries.addOne(gpa)).* = .{
	350	const bind_entry = Entry{
331	351	.target = ref,
332	352	.offset = addr - seg.vmaddr,
333	353	.segment_id = seg_id,
334	354	.addend = 0,
335	355	};
	356	if (sym.flags.weak) {
	357	try self.entries.append(gpa, bind_entry);
	358	}
336	359	}
337	360	}
338	361
...	...	@@ -343,48 +366,49 @@ pub const WeakBind = struct {
343	366	for (macho_file.tlv_ptr.symbols.items, 0..) \|ref, idx\| {
344	367	const sym = ref.getSymbol(macho_file).?;
345	368	const addr = macho_file.tlv_ptr.getAddress(@intCast(idx), macho_file);
346		if (sym.flags.weak) (try bind.entries.addOne(gpa)).* = .{
	369	const entry = Entry{
347	370	.target = ref,
348	371	.offset = addr - seg.vmaddr,
349	372	.segment_id = seg_id,
350	373	.addend = 0,
351	374	};
	375	if (sym.flags.weak) {
	376	try self.entries.append(gpa, entry);
	377	}
352	378	}
353	379	}
354	380
355		try bind.finalize(gpa, macho_file);
356		macho_file.dyld_info_cmd.weak_bind_size = mem.alignForward(u32, @intCast(bind.buffer.items.len), @alignOf(u64));
	381	try self.finalize(gpa, macho_file);
	382	macho_file.dyld_info_cmd.weak_bind_size = mem.alignForward(u32, @intCast(self.buffer.items.len), @alignOf(u64));
357	383	}
358	384
359		fn finalize(bind: WeakBind, gpa: Allocator, ctx: MachO) !void {
360		if (bind.entries.items.len == 0) return;
	385	fn finalize(self: Self, gpa: Allocator, ctx: MachO) !void {
	386	if (self.entries.items.len == 0) return;
361	387
362		var aw: std.io.Writer.Allocating = .fromArrayList(gpa, &bind.buffer);
363		const bw = &aw.writer;
364		defer bind.buffer = aw.toArrayList();
	388	const writer = self.buffer.writer(gpa);
365	389
366	390	log.debug("weak bind opcodes", .{});
367	391
368		std.mem.sort(Entry, bind.entries.items, ctx, Entry.lessThan);
	392	std.mem.sort(Entry, self.entries.items, ctx, Entry.lessThan);
369	393
370	394	var start: usize = 0;
371	395	var seg_id: ?u8 = null;
372		for (bind.entries.items, 0..) \|entry, i\| {
	396	for (self.entries.items, 0..) \|entry, i\| {
373	397	if (seg_id != null and seg_id.? == entry.segment_id) continue;
374		try finalizeSegment(bind.entries.items[start..i], ctx, bw);
	398	try finalizeSegment(self.entries.items[start..i], ctx, writer);
375	399	seg_id = entry.segment_id;
376	400	start = i;
377	401	}
378	402
379		try finalizeSegment(bind.entries.items[start..], ctx, bw);
380		try done(bw);
	403	try finalizeSegment(self.entries.items[start..], ctx, writer);
	404	try done(writer);
381	405	}
382	406
383		fn finalizeSegment(entries: []const Entry, ctx: MachO, bw: Writer) Writer.Error!void {
	407	fn finalizeSegment(entries: []const Entry, ctx: *MachO, writer: anytype) !void {
384	408	if (entries.len == 0) return;
385	409
386	410	const seg_id = entries[0].segment_id;
387		try setSegmentOffset(seg_id, 0, bw);
	411	try setSegmentOffset(seg_id, 0, writer);
388	412
389	413	var offset: u64 = 0;
390	414	var addend: i64 = 0;
...	...	@@ -404,8 +428,8 @@ pub const WeakBind = struct {
404	428	if (target == null or !target.?.eql(current.target)) {
405	429	switch (state) {
406	430	.start => {},
407		.bind_single => try doBind(bw),
408		.bind_times_skip => try doBindTimesSkip(count, skip, bw),
	431	.bind_single => try doBind(writer),
	432	.bind_times_skip => try doBindTimesSkip(count, skip, writer),
409	433	}
410	434	state = .start;
411	435	target = current.target;
...	...	@@ -414,12 +438,12 @@ pub const WeakBind = struct {
414	438	const name = sym.getName(ctx);
415	439	const flags: u8 = 0; // TODO NON_WEAK_DEFINITION
416	440
417		try setSymbol(name, flags, bw);
418		try setTypePointer(bw);
	441	try setSymbol(name, flags, writer);
	442	try setTypePointer(writer);
419	443
420	444	if (current.addend != addend) {
421	445	addend = current.addend;
422		try setAddend(addend, bw);
	446	try setAddend(addend, writer);
423	447	}
424	448	}
425	449
...	...	@@ -428,11 +452,11 @@ pub const WeakBind = struct {
428	452	switch (state) {
429	453	.start => {
430	454	if (current.offset < offset) {
431		try addAddr(@as(u64, @bitCast(@as(i64, @intCast(current.offset)) - @as(i64, @intCast(offset)))), bw);
	455	try addAddr(@as(u64, @bitCast(@as(i64, @intCast(current.offset)) - @as(i64, @intCast(offset)))), writer);
432	456	offset = offset - (offset - current.offset);
433	457	} else if (current.offset > offset) {
434	458	const delta = current.offset - offset;
435		try addAddr(delta, bw);
	459	try addAddr(delta, writer);
436	460	offset += delta;
437	461	}
438	462	state = .bind_single;
...	...	@@ -441,7 +465,7 @@ pub const WeakBind = struct {
441	465	},
442	466	.bind_single => {
443	467	if (current.offset == offset) {
444		try doBind(bw);
	468	try doBind(writer);
445	469	state = .start;
446	470	} else if (current.offset > offset) {
447	471	const delta = current.offset - offset;
...	...	@@ -455,9 +479,9 @@ pub const WeakBind = struct {
455	479	if (current.offset < offset) {
456	480	count -= 1;
457	481	if (count == 1) {
458		try doBindAddAddr(skip, bw);
	482	try doBindAddAddr(skip, writer);
459	483	} else {
460		try doBindTimesSkip(count, skip, bw);
	484	try doBindTimesSkip(count, skip, writer);
461	485	}
462	486	state = .start;
463	487	offset = offset - (@sizeOf(u64) + skip);
...	...	@@ -466,7 +490,7 @@ pub const WeakBind = struct {
466	490	count += 1;
467	491	offset += @sizeOf(u64) + skip;
468	492	} else {
469		try doBindTimesSkip(count, skip, bw);
	493	try doBindTimesSkip(count, skip, writer);
470	494	state = .start;
471	495	i -= 1;
472	496	}
...	...	@@ -476,13 +500,13 @@ pub const WeakBind = struct {
476	500
477	501	switch (state) {
478	502	.start => unreachable,
479		.bind_single => try doBind(bw),
480		.bind_times_skip => try doBindTimesSkip(count, skip, bw),
	503	.bind_single => try doBind(writer),
	504	.bind_times_skip => try doBindTimesSkip(count, skip, writer),
481	505	}
482	506	}
483	507
484		pub fn write(bind: WeakBind, bw: *Writer) Writer.Error!void {
485		try bw.writeAll(bind.buffer.items);
	508	pub fn write(self: Self, writer: anytype) !void {
	509	try writer.writeAll(self.buffer.items);
486	510	}
487	511	};
488	512
...	...	@@ -491,13 +515,15 @@ pub const LazyBind = struct {
491	515	buffer: std.ArrayListUnmanaged(u8) = .empty,
492	516	offsets: std.ArrayListUnmanaged(u32) = .empty,
493	517
494		pub fn deinit(bind: *LazyBind, gpa: Allocator) void {
495		bind.entries.deinit(gpa);
496		bind.buffer.deinit(gpa);
497		bind.offsets.deinit(gpa);
	518	const Self = @This();
	519
	520	pub fn deinit(self: *Self, gpa: Allocator) void {
	521	self.entries.deinit(gpa);
	522	self.buffer.deinit(gpa);
	523	self.offsets.deinit(gpa);
498	524	}
499	525
500		pub fn updateSize(bind: LazyBind, macho_file: MachO) !void {
	526	pub fn updateSize(self: Self, macho_file: MachO) !void {
501	527	const tracy = trace(@src());
502	528	defer tracy.end();
503	529
...	...	@@ -511,35 +537,36 @@ pub const LazyBind = struct {
511	537	for (macho_file.stubs.symbols.items, 0..) \|ref, idx\| {
512	538	const sym = ref.getSymbol(macho_file).?;
513	539	const addr = sect.addr + idx * @sizeOf(u64);
514		if ((sym.flags.import and !sym.flags.weak) or (sym.flags.interposable and !sym.flags.weak)) (try bind.entries.addOne(gpa)).* = .{
	540	const bind_entry = Entry{
515	541	.target = ref,
516	542	.offset = addr - seg.vmaddr,
517	543	.segment_id = seg_id,
518	544	.addend = 0,
519	545	};
	546	if ((sym.flags.import and !sym.flags.weak) or (sym.flags.interposable and !sym.flags.weak)) {
	547	try self.entries.append(gpa, bind_entry);
	548	}
520	549	}
521	550
522		try bind.finalize(gpa, macho_file);
523		macho_file.dyld_info_cmd.lazy_bind_size = mem.alignForward(u32, @intCast(bind.buffer.items.len), @alignOf(u64));
	551	try self.finalize(gpa, macho_file);
	552	macho_file.dyld_info_cmd.lazy_bind_size = mem.alignForward(u32, @intCast(self.buffer.items.len), @alignOf(u64));
524	553	}
525	554
526		fn finalize(bind: LazyBind, gpa: Allocator, ctx: MachO) !void {
527		try bind.offsets.ensureTotalCapacityPrecise(gpa, bind.entries.items.len);
	555	fn finalize(self: Self, gpa: Allocator, ctx: MachO) !void {
	556	try self.offsets.ensureTotalCapacityPrecise(gpa, self.entries.items.len);
528	557
529		var aw: std.io.Writer.Allocating = .fromArrayList(gpa, &bind.buffer);
530		const bw = &aw.writer;
531		defer bind.buffer = aw.toArrayList();
	558	const writer = self.buffer.writer(gpa);
532	559
533	560	log.debug("lazy bind opcodes", .{});
534	561
535	562	var addend: i64 = 0;
536	563
537		for (bind.entries.items) \|entry\| {
538		bind.offsets.appendAssumeCapacity(@intCast(bind.buffer.items.len));
	564	for (self.entries.items) \|entry\| {
	565	self.offsets.appendAssumeCapacity(@intCast(self.buffer.items.len));
539	566
540	567	const sym = entry.target.getSymbol(ctx).?;
541	568	const name = sym.getName(ctx);
542		const flags: u4 = if (sym.weakRef(ctx)) macho.BIND_SYMBOL_FLAGS_WEAK_IMPORT else 0;
	569	const flags: u8 = if (sym.weakRef(ctx)) macho.BIND_SYMBOL_FLAGS_WEAK_IMPORT else 0;
543	570	const ordinal: i16 = ord: {
544	571	if (sym.flags.interposable) break :ord macho.BIND_SPECIAL_DYLIB_FLAT_LOOKUP;
545	572	if (sym.flags.import) {
...	...	@@ -551,116 +578,121 @@ pub const LazyBind = struct {
551	578	break :ord macho.BIND_SPECIAL_DYLIB_SELF;
552	579	};
553	580
554		try setSegmentOffset(entry.segment_id, entry.offset, bw);
555		try setSymbol(name, flags, bw);
556		try setDylibOrdinal(ordinal, bw);
	581	try setSegmentOffset(entry.segment_id, entry.offset, writer);
	582	try setSymbol(name, flags, writer);
	583	try setDylibOrdinal(ordinal, writer);
557	584
558	585	if (entry.addend != addend) {
559		try setAddend(entry.addend, bw);
	586	try setAddend(entry.addend, writer);
560	587	addend = entry.addend;
561	588	}
562	589
563		try doBind(bw);
564		try done(bw);
	590	try doBind(writer);
	591	try done(writer);
565	592	}
566	593	}
567	594
568		pub fn write(bind: LazyBind, bw: *Writer) Writer.Error!void {
569		try bw.writeAll(bind.buffer.items);
	595	pub fn write(self: Self, writer: anytype) !void {
	596	try writer.writeAll(self.buffer.items);
570	597	}
571	598	};
572	599
573		fn setSegmentOffset(segment_id: u4, offset: u64, bw: *Writer) Writer.Error!void {
	600	fn setSegmentOffset(segment_id: u8, offset: u64, writer: anytype) !void {
574	601	log.debug(">>> set segment: {d} and offset: {x}", .{ segment_id, offset });
575		try bw.writeByte(macho.BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB \| segment_id);
576		try bw.writeLeb128(offset);
	602	try writer.writeByte(macho.BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB \| @as(u4, @truncate(segment_id)));
	603	try std.leb.writeUleb128(writer, offset);
577	604	}
578	605
579		fn setSymbol(name: []const u8, flags: u4, bw: *Writer) Writer.Error!void {
	606	fn setSymbol(name: []const u8, flags: u8, writer: anytype) !void {
580	607	log.debug(">>> set symbol: {s} with flags: {x}", .{ name, flags });
581		try bw.writeByte(macho.BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM \| flags);
582		try bw.writeAll(name);
583		try bw.writeByte(0);
	608	try writer.writeByte(macho.BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM \| @as(u4, @truncate(flags)));
	609	try writer.writeAll(name);
	610	try writer.writeByte(0);
584	611	}
585	612
586		fn setTypePointer(bw: *Writer) Writer.Error!void {
	613	fn setTypePointer(writer: anytype) !void {
587	614	log.debug(">>> set type: {d}", .{macho.BIND_TYPE_POINTER});
588		try bw.writeByte(macho.BIND_OPCODE_SET_TYPE_IMM \| @as(u4, @intCast(macho.BIND_TYPE_POINTER)));
	615	try writer.writeByte(macho.BIND_OPCODE_SET_TYPE_IMM \| @as(u4, @truncate(macho.BIND_TYPE_POINTER)));
589	616	}
590	617
591		fn setDylibOrdinal(ordinal: i16, bw: *Writer) Writer.Error!void {
592		switch (ordinal) {
593		else => unreachable, // Invalid dylib special binding
594		macho.BIND_SPECIAL_DYLIB_SELF,
595		macho.BIND_SPECIAL_DYLIB_MAIN_EXECUTABLE,
596		macho.BIND_SPECIAL_DYLIB_FLAT_LOOKUP,
597		=> {
598		log.debug(">>> set dylib special: {d}", .{ordinal});
599		try bw.writeByte(macho.BIND_OPCODE_SET_DYLIB_SPECIAL_IMM \| @as(u4, @bitCast(@as(i4, @intCast(ordinal)))));
600		},
601		1...std.math.maxInt(i16) => {
602		log.debug(">>> set dylib ordinal: {d}", .{ordinal});
603		if (std.math.cast(u4, ordinal)) \|imm\| {
604		try bw.writeByte(macho.BIND_OPCODE_SET_DYLIB_ORDINAL_IMM \| imm);
605		} else {
606		try bw.writeByte(macho.BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB);
607		try bw.writeUleb128(ordinal);
608		}
609		},
	618	fn setDylibOrdinal(ordinal: i16, writer: anytype) !void {
	619	if (ordinal <= 0) {
	620	switch (ordinal) {
	621	macho.BIND_SPECIAL_DYLIB_SELF,
	622	macho.BIND_SPECIAL_DYLIB_MAIN_EXECUTABLE,
	623	macho.BIND_SPECIAL_DYLIB_FLAT_LOOKUP,
	624	=> {},
	625	else => unreachable, // Invalid dylib special binding
	626	}
	627	log.debug(">>> set dylib special: {d}", .{ordinal});
	628	const cast = @as(u16, @bitCast(ordinal));
	629	try writer.writeByte(macho.BIND_OPCODE_SET_DYLIB_SPECIAL_IMM \| @as(u4, @truncate(cast)));
	630	} else {
	631	const cast = @as(u16, @bitCast(ordinal));
	632	log.debug(">>> set dylib ordinal: {d}", .{ordinal});
	633	if (cast <= 0xf) {
	634	try writer.writeByte(macho.BIND_OPCODE_SET_DYLIB_ORDINAL_IMM \| @as(u4, @truncate(cast)));
	635	} else {
	636	try writer.writeByte(macho.BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB);
	637	try std.leb.writeUleb128(writer, cast);
	638	}
610	639	}
611	640	}
612	641
613		fn setAddend(addend: i64, bw: *Writer) Writer.Error!void {
	642	fn setAddend(addend: i64, writer: anytype) !void {
614	643	log.debug(">>> set addend: {x}", .{addend});
615		try bw.writeByte(macho.BIND_OPCODE_SET_ADDEND_SLEB);
616		try bw.writeLeb128(addend);
	644	try writer.writeByte(macho.BIND_OPCODE_SET_ADDEND_SLEB);
	645	try std.leb.writeIleb128(writer, addend);
617	646	}
618	647
619		fn doBind(bw: *Writer) Writer.Error!void {
	648	fn doBind(writer: anytype) !void {
620	649	log.debug(">>> bind", .{});
621		try bw.writeByte(macho.BIND_OPCODE_DO_BIND);
	650	try writer.writeByte(macho.BIND_OPCODE_DO_BIND);
622	651	}
623	652
624		fn doBindAddAddr(addr: u64, bw: *Writer) Writer.Error!void {
	653	fn doBindAddAddr(addr: u64, writer: anytype) !void {
625	654	log.debug(">>> bind with add: {x}", .{addr});
626		if (std.math.divExact(u64, addr, @sizeOf(u64))) \|scaled\| {
627		if (std.math.cast(u4, scaled)) \|imm_scaled\| return bw.writeByte(
628		macho.BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED \| imm_scaled,
629		);
630		} else \|_\| {}
631		try bw.writeByte(macho.BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB);
632		try bw.writeLeb128(addr);
	655	if (std.mem.isAlignedGeneric(u64, addr, @sizeOf(u64))) {
	656	const imm = @divExact(addr, @sizeOf(u64));
	657	if (imm <= 0xf) {
	658	try writer.writeByte(
	659	macho.BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED \| @as(u4, @truncate(imm)),
	660	);
	661	return;
	662	}
	663	}
	664	try writer.writeByte(macho.BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB);
	665	try std.leb.writeUleb128(writer, addr);
633	666	}
634	667
635		fn doBindTimesSkip(count: usize, skip: u64, bw: *Writer) Writer.Error!void {
	668	fn doBindTimesSkip(count: usize, skip: u64, writer: anytype) !void {
636	669	log.debug(">>> bind with count: {d} and skip: {x}", .{ count, skip });
637		try bw.writeByte(macho.BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB);
638		try bw.writeLeb128(count);
639		try bw.writeLeb128(skip);
	670	try writer.writeByte(macho.BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB);
	671	try std.leb.writeUleb128(writer, count);
	672	try std.leb.writeUleb128(writer, skip);
640	673	}
641	674
642		fn addAddr(addr: u64, bw: *Writer) Writer.Error!void {
	675	fn addAddr(addr: u64, writer: anytype) !void {
643	676	log.debug(">>> add: {x}", .{addr});
644		try bw.writeByte(macho.BIND_OPCODE_ADD_ADDR_ULEB);
645		try bw.writeLeb128(addr);
	677	try writer.writeByte(macho.BIND_OPCODE_ADD_ADDR_ULEB);
	678	try std.leb.writeUleb128(writer, addr);
646	679	}
647	680
648		fn done(bw: *Writer) Writer.Error!void {
	681	fn done(writer: anytype) !void {
649	682	log.debug(">>> done", .{});
650		try bw.writeByte(macho.BIND_OPCODE_DONE);
	683	try writer.writeByte(macho.BIND_OPCODE_DONE);
651	684	}
652	685
653		const std = @import("std");
654	686	const assert = std.debug.assert;
655	687	const leb = std.leb;
656	688	const log = std.log.scoped(.link_dyld_info);
657	689	const macho = std.macho;
658	690	const mem = std.mem;
659	691	const testing = std.testing;
660		const Allocator = std.mem.Allocator;
661		const Writer = std.io.Writer;
662
663	692	const trace = @import("../../../tracy.zig").trace;
	693	const std = @import("std");
	694
	695	const Allocator = mem.Allocator;
664	696	const File = @import("../file.zig").File;
665	697	const MachO = @import("../../MachO.zig");
666	698	const Symbol = @import("../Symbol.zig");

src/link/MachO/eh_frame.zig+69-44

...	...	@@ -12,33 +12,36 @@ pub const Cie = struct {
12	12	const tracy = trace(@src());
13	13	defer tracy.end();
14	14
15		var r: std.io.Reader = .fixed(cie.getData(macho_file));
	15	const data = cie.getData(macho_file);
	16	const aug = std.mem.sliceTo(@as([*:0]const u8, @ptrCast(data.ptr + 9)), 0);
16	17
17		try r.discard(9);
18		const aug = try r.takeSentinel(0);
19	18	if (aug[0] != 'z') return; // TODO should we error out?
20	19
21		_ = try r.takeLeb128(u64); // code alignment factor
22		_ = try r.takeLeb128(u64); // data alignment factor
23		_ = try r.takeLeb128(u64); // return address register
24		_ = try r.takeLeb128(u64); // augmentation data length
	20	var stream = std.io.fixedBufferStream(data[9 + aug.len + 1 ..]);
	21	var creader = std.io.countingReader(stream.reader());
	22	const reader = creader.reader();
	23
	24	_ = try leb.readUleb128(u64, reader); // code alignment factor
	25	_ = try leb.readUleb128(u64, reader); // data alignment factor
	26	_ = try leb.readUleb128(u64, reader); // return address register
	27	_ = try leb.readUleb128(u64, reader); // augmentation data length
25	28
26	29	for (aug[1..]) \|ch\| switch (ch) {
27	30	'R' => {
28		const enc = try r.takeByte();
	31	const enc = try reader.readByte();
29	32	if (enc != DW_EH_PE.pcrel \| DW_EH_PE.absptr) {
30	33	@panic("unexpected pointer encoding"); // TODO error
31	34	}
32	35	},
33	36	'P' => {
34		const enc = try r.takeByte();
	37	const enc = try reader.readByte();
35	38	if (enc != DW_EH_PE.pcrel \| DW_EH_PE.indirect \| DW_EH_PE.sdata4) {
36	39	@panic("unexpected personality pointer encoding"); // TODO error
37	40	}
38		_ = try r.takeInt(u32, .little); // personality pointer
	41	_ = try reader.readInt(u32, .little); // personality pointer
39	42	},
40	43	'L' => {
41		const enc = try r.takeByte();
	44	const enc = try reader.readByte();
42	45	switch (enc & DW_EH_PE.type_mask) {
43	46	DW_EH_PE.sdata4 => cie.lsda_size = .p32,
44	47	DW_EH_PE.absptr => cie.lsda_size = .p64,
...	...	@@ -125,16 +128,12 @@ pub const Fde = struct {
125	128	const tracy = trace(@src());
126	129	defer tracy.end();
127	130
	131	const data = fde.getData(macho_file);
128	132	const object = fde.getObject(macho_file);
129	133	const sect = object.sections.items(.header)[object.eh_frame_sect_index.?];
130	134
131		var br: std.io.Reader = .fixed(fde.getData(macho_file));
132
133		try br.discard(4);
134		const cie_ptr = try br.takeInt(u32, .little);
135		const pc_begin = try br.takeInt(i64, .little);
136
137	135	// Parse target atom index
	136	const pc_begin = std.mem.readInt(i64, data[8..][0..8], .little);
138	137	const taddr: u64 = @intCast(@as(i64, @intCast(sect.addr + fde.offset + 8)) + pc_begin);
139	138	fde.atom = object.findAtom(taddr) orelse {
140	139	try macho_file.reportParseError2(object.index, "{s},{s}: 0x{x}: invalid function reference in FDE", .{
...	...	@@ -146,6 +145,7 @@ pub const Fde = struct {
146	145	fde.atom_offset = @intCast(taddr - atom.getInputAddress(macho_file));
147	146
148	147	// Associate with a CIE
	148	const cie_ptr = std.mem.readInt(u32, data[4..8], .little);
149	149	const cie_offset = fde.offset + 4 - cie_ptr;
150	150	const cie_index = for (object.cies.items, 0..) \|cie, cie_index\| {
151	151	if (cie.offset == cie_offset) break @as(Cie.Index, @intCast(cie_index));
...	...	@@ -163,12 +163,14 @@ pub const Fde = struct {
163	163
164	164	// Parse LSDA atom index if any
165	165	if (cie.lsda_size) \|lsda_size\| {
166		try br.discard(8);
167		_ = try br.takeLeb128(u64); // augmentation length
168		fde.lsda_ptr_offset = @intCast(br.seek);
	166	var stream = std.io.fixedBufferStream(data[24..]);
	167	var creader = std.io.countingReader(stream.reader());
	168	const reader = creader.reader();
	169	_ = try leb.readUleb128(u64, reader); // augmentation length
	170	fde.lsda_ptr_offset = @intCast(creader.bytes_read + 24);
169	171	const lsda_ptr = switch (lsda_size) {
170		.p32 => try br.takeInt(i32, .little),
171		.p64 => try br.takeInt(i64, .little),
	172	.p32 => try reader.readInt(i32, .little),
	173	.p64 => try reader.readInt(i64, .little),
172	174	};
173	175	const lsda_addr: u64 = @intCast(@as(i64, @intCast(sect.addr + fde.offset + fde.lsda_ptr_offset)) + lsda_ptr);
174	176	fde.lsda = object.findAtom(lsda_addr) orelse {
...	...	@@ -209,35 +211,56 @@ pub const Fde = struct {
209	211	return fde.getObject(macho_file).getAtom(fde.lsda);
210	212	}
211	213
212		pub fn fmt(fde: Fde, macho_file: *MachO) std.fmt.Formatter(Format, Format.default) {
	214	pub fn format(
	215	fde: Fde,
	216	comptime unused_fmt_string: []const u8,
	217	options: std.fmt.FormatOptions,
	218	writer: anytype,
	219	) !void {
	220	_ = fde;
	221	_ = unused_fmt_string;
	222	_ = options;
	223	_ = writer;
	224	@compileError("do not format FDEs directly");
	225	}
	226
	227	pub fn fmt(fde: Fde, macho_file: *MachO) std.fmt.Formatter(format2) {
213	228	return .{ .data = .{
214	229	.fde = fde,
215	230	.macho_file = macho_file,
216	231	} };
217	232	}
218	233
219		const Format = struct {
	234	const FormatContext = struct {
220	235	fde: Fde,
221	236	macho_file: *MachO,
222
223		fn default(f: Format, w: *Writer) Writer.Error!void {
224		const fde = f.fde;
225		const macho_file = f.macho_file;
226		try w.print("@{x} : size({x}) : cie({d}) : {s}", .{
227		fde.offset,
228		fde.getSize(),
229		fde.cie,
230		fde.getAtom(macho_file).getName(macho_file),
231		});
232		if (!fde.alive) try w.writeAll(" : [*]");
233		}
234	237	};
235	238
	239	fn format2(
	240	ctx: FormatContext,
	241	comptime unused_fmt_string: []const u8,
	242	options: std.fmt.FormatOptions,
	243	writer: anytype,
	244	) !void {
	245	_ = unused_fmt_string;
	246	_ = options;
	247	const fde = ctx.fde;
	248	const macho_file = ctx.macho_file;
	249	try writer.print("@{x} : size({x}) : cie({d}) : {s}", .{
	250	fde.offset,
	251	fde.getSize(),
	252	fde.cie,
	253	fde.getAtom(macho_file).getName(macho_file),
	254	});
	255	if (!fde.alive) try writer.writeAll(" : [*]");
	256	}
	257
236	258	pub const Index = u32;
237	259	};
238	260
239	261	pub const Iterator = struct {
240		reader: *std.io.Reader,
	262	data: []const u8,
	263	pos: u32 = 0,
241	264
242	265	pub const Record = struct {
243	266	tag: enum { fde, cie },
...	...	@@ -246,19 +269,21 @@ pub const Iterator = struct {
246	269	};
247	270
248	271	pub fn next(it: *Iterator) !?Record {
249		const r = it.reader;
250		if (r.seek >= r.storageBuffer().len) return null;
	272	if (it.pos >= it.data.len) return null;
	273
	274	var stream = std.io.fixedBufferStream(it.data[it.pos..]);
	275	const reader = stream.reader();
251	276
252		const size = try r.takeInt(u32, .little);
	277	const size = try reader.readInt(u32, .little);
253	278	if (size == 0xFFFFFFFF) @panic("DWARF CFI is 32bit on macOS");
254	279
255		const id = try r.takeInt(u32, .little);
256		const record: Record = .{
	280	const id = try reader.readInt(u32, .little);
	281	const record = Record{
257	282	.tag = if (id == 0) .cie else .fde,
258		.offset = @intCast(r.seek),
	283	.offset = it.pos,
259	284	.size = size,
260	285	};
261		try r.discard(size);
	286	it.pos += size + 4;
262	287
263	288	return record;
264	289	}

src/link/MachO/file.zig+3-3

...	...	@@ -321,11 +321,11 @@ pub const File = union(enum) {
321	321	};
322	322	}
323	323
324		pub fn writeAr(file: File, bw: Writer, ar_format: Archive.Format, macho_file: MachO) Writer.Error!void {
	324	pub fn writeAr(file: File, ar_format: Archive.Format, macho_file: *MachO, writer: anytype) !void {
325	325	return switch (file) {
326	326	.dylib, .internal => unreachable,
327		.zig_object => \|x\| x.writeAr(bw, ar_format),
328		.object => \|x\| x.writeAr(bw, ar_format, macho_file),
	327	.zig_object => \|x\| x.writeAr(ar_format, writer),
	328	.object => \|x\| x.writeAr(ar_format, macho_file, writer),
329	329	};
330	330	}
331	331

src/link/MachO/load_commands.zig+30-21

...	...	@@ -181,20 +181,23 @@ pub fn calcMinHeaderPadSize(macho_file: *MachO) !u32 {
181	181	return offset;
182	182	}
183	183
184		pub fn writeDylinkerLC(bw: *Writer) Writer.Error!void {
	184	pub fn writeDylinkerLC(writer: anytype) !void {
185	185	const name_len = mem.sliceTo(default_dyld_path, 0).len;
186	186	const cmdsize = @as(u32, @intCast(mem.alignForward(
187	187	u64,
188	188	@sizeOf(macho.dylinker_command) + name_len,
189	189	@sizeOf(u64),
190	190	)));
191		try bw.writeStruct(macho.dylinker_command{
	191	try writer.writeStruct(macho.dylinker_command{
192	192	.cmd = .LOAD_DYLINKER,
193	193	.cmdsize = cmdsize,
194	194	.name = @sizeOf(macho.dylinker_command),
195	195	});
196		try bw.writeAll(mem.sliceTo(default_dyld_path, 0));
197		try bw.splatByteAll(0, cmdsize - @sizeOf(macho.dylinker_command) - name_len);
	196	try writer.writeAll(mem.sliceTo(default_dyld_path, 0));
	197	const padding = cmdsize - @sizeOf(macho.dylinker_command) - name_len;
	198	if (padding > 0) {
	199	try writer.writeByteNTimes(0, padding);
	200	}
198	201	}
199	202
200	203	const WriteDylibLCCtx = struct {
...	...	@@ -205,14 +208,14 @@ const WriteDylibLCCtx = struct {
205	208	compatibility_version: u32 = 0x10000,
206	209	};
207	210
208		pub fn writeDylibLC(ctx: WriteDylibLCCtx, bw: *Writer) !void {
	211	pub fn writeDylibLC(ctx: WriteDylibLCCtx, writer: anytype) !void {
209	212	const name_len = ctx.name.len + 1;
210		const cmdsize: u32 = @intCast(mem.alignForward(
	213	const cmdsize = @as(u32, @intCast(mem.alignForward(
211	214	u64,
212	215	@sizeOf(macho.dylib_command) + name_len,
213	216	@sizeOf(u64),
214		));
215		try bw.writeStruct(macho.dylib_command{
	217	)));
	218	try writer.writeStruct(macho.dylib_command{
216	219	.cmd = ctx.cmd,
217	220	.cmdsize = cmdsize,
218	221	.dylib = .{
...	...	@@ -222,9 +225,12 @@ pub fn writeDylibLC(ctx: WriteDylibLCCtx, bw: *Writer) !void {
222	225	.compatibility_version = ctx.compatibility_version,
223	226	},
224	227	});
225		try bw.writeAll(ctx.name);
226		try bw.writeByte(0);
227		try bw.splatByteAll(0, cmdsize - @sizeOf(macho.dylib_command) - name_len);
	228	try writer.writeAll(ctx.name);
	229	try writer.writeByte(0);
	230	const padding = cmdsize - @sizeOf(macho.dylib_command) - name_len;
	231	if (padding > 0) {
	232	try writer.writeByteNTimes(0, padding);
	233	}
228	234	}
229	235
230	236	pub fn writeDylibIdLC(macho_file: *MachO, writer: anytype) !void {
...	...	@@ -253,23 +259,26 @@ pub fn writeDylibIdLC(macho_file: *MachO, writer: anytype) !void {
253	259	}, writer);
254	260	}
255	261
256		pub fn writeRpathLC(bw: *Writer, rpath: []const u8) !void {
	262	pub fn writeRpathLC(rpath: []const u8, writer: anytype) !void {
257	263	const rpath_len = rpath.len + 1;
258	264	const cmdsize = @as(u32, @intCast(mem.alignForward(
259	265	u64,
260	266	@sizeOf(macho.rpath_command) + rpath_len,
261	267	@sizeOf(u64),
262	268	)));
263		try bw.writeStruct(macho.rpath_command{
	269	try writer.writeStruct(macho.rpath_command{
264	270	.cmdsize = cmdsize,
265	271	.path = @sizeOf(macho.rpath_command),
266	272	});
267		try bw.writeAll(rpath);
268		try bw.writeByte(0);
269		try bw.splatByteAll(0, cmdsize - @sizeOf(macho.rpath_command) - rpath_len);
	273	try writer.writeAll(rpath);
	274	try writer.writeByte(0);
	275	const padding = cmdsize - @sizeOf(macho.rpath_command) - rpath_len;
	276	if (padding > 0) {
	277	try writer.writeByteNTimes(0, padding);
	278	}
270	279	}
271	280
272		pub fn writeVersionMinLC(bw: *Writer, platform: MachO.Platform, sdk_version: ?std.SemanticVersion) Writer.Error!void {
	281	pub fn writeVersionMinLC(platform: MachO.Platform, sdk_version: ?std.SemanticVersion, writer: anytype) !void {
273	282	const cmd: macho.LC = switch (platform.os_tag) {
274	283	.macos => .VERSION_MIN_MACOSX,
275	284	.ios => .VERSION_MIN_IPHONEOS,
...	...	@@ -277,7 +286,7 @@ pub fn writeVersionMinLC(bw: *Writer, platform: MachO.Platform, sdk_version: ?st
277	286	.watchos => .VERSION_MIN_WATCHOS,
278	287	else => unreachable,
279	288	};
280		try bw.writeAll(mem.asBytes(&macho.version_min_command{
	289	try writer.writeAll(mem.asBytes(&macho.version_min_command{
281	290	.cmd = cmd,
282	291	.version = platform.toAppleVersion(),
283	292	.sdk = if (sdk_version) \|ver\|
...	...	@@ -287,9 +296,9 @@ pub fn writeVersionMinLC(bw: *Writer, platform: MachO.Platform, sdk_version: ?st
287	296	}));
288	297	}
289	298
290		pub fn writeBuildVersionLC(bw: *Writer, platform: MachO.Platform, sdk_version: ?std.SemanticVersion) Writer.Error!void {
	299	pub fn writeBuildVersionLC(platform: MachO.Platform, sdk_version: ?std.SemanticVersion, writer: anytype) !void {
291	300	const cmdsize = @sizeOf(macho.build_version_command) + @sizeOf(macho.build_tool_version);
292		try bw.writeStruct(macho.build_version_command{
	301	try writer.writeStruct(macho.build_version_command{
293	302	.cmdsize = cmdsize,
294	303	.platform = platform.toApplePlatform(),
295	304	.minos = platform.toAppleVersion(),
...	...	@@ -299,7 +308,7 @@ pub fn writeBuildVersionLC(bw: *Writer, platform: MachO.Platform, sdk_version: ?
299	308	platform.toAppleVersion(),
300	309	.ntools = 1,
301	310	});
302		try bw.writeAll(mem.asBytes(&macho.build_tool_version{
	311	try writer.writeAll(mem.asBytes(&macho.build_tool_version{
303	312	.tool = .ZIG,
304	313	.version = 0x0,
305	314	}));

src/link/MachO/relocatable.zig+52-24

...	...	@@ -202,30 +202,38 @@ pub fn flushStaticLib(macho_file: MachO, comp: Compilation, module_obj_path: ?
202	202	};
203	203
204	204	if (build_options.enable_logging) {
205		state_log.debug("ar_symtab\n{f}\n", .{ar_symtab.fmt(macho_file)});
	205	state_log.debug("ar_symtab\n{}\n", .{ar_symtab.fmt(macho_file)});
206	206	}
207	207
208		var bw: Writer = .fixed(try gpa.alloc(u8, total_size));
209		defer gpa.free(bw.buffer);
	208	var buffer = std.ArrayList(u8).init(gpa);
	209	defer buffer.deinit();
	210	try buffer.ensureTotalCapacityPrecise(total_size);
	211	const writer = buffer.writer();
210	212
211	213	// Write magic
212		bw.writeAll(Archive.ARMAG) catch unreachable;
	214	try writer.writeAll(Archive.ARMAG);
213	215
214	216	// Write symtab
215		ar_symtab.write(&bw, format, macho_file) catch \|err\| {
216		return diags.fail("failed to write archive symbol table: {s}", .{@errorName(err)});
	217	ar_symtab.write(format, macho_file, writer) catch \|err\| switch (err) {
	218	error.OutOfMemory => return error.OutOfMemory,
	219	else => \|e\| return diags.fail("failed to write archive symbol table: {s}", .{@errorName(e)}),
217	220	};
218	221
219	222	// Write object files
220	223	for (files.items) \|index\| {
221		bw.splatByteAll(0, mem.alignForward(usize, bw.end, 2) - bw.end) catch unreachable;
222		macho_file.getFile(index).?.writeAr(&bw, format, macho_file) catch \|err\|
	224	const aligned = mem.alignForward(usize, buffer.items.len, 2);
	225	const padding = aligned - buffer.items.len;
	226	if (padding > 0) {
	227	try writer.writeByteNTimes(0, padding);
	228	}
	229	macho_file.getFile(index).?.writeAr(format, macho_file, writer) catch \|err\|
223	230	return diags.fail("failed to write archive: {s}", .{@errorName(err)});
224	231	}
225	232
226		assert(bw.end == bw.buffer.len);
227		try macho_file.setEndPos(bw.end);
228		try macho_file.pwriteAll(bw.buffer, 0);
	233	assert(buffer.items.len == total_size);
	234
	235	try macho_file.setEndPos(total_size);
	236	try macho_file.pwriteAll(buffer.items, 0);
229	237
230	238	if (diags.hasErrors()) return error.LinkFailure;
231	239	}
...	...	@@ -664,7 +672,7 @@ fn writeCompactUnwindWorker(macho_file: MachO, object: Object) void {
664	672	diags.addError("failed to write '__LD,__eh_frame' section: {s}", .{@errorName(err)});
665	673	}
666	674
667		fn writeSectionsToFile(macho_file: *MachO) link.File.FlushError!void {
	675	fn writeSectionsToFile(macho_file: *MachO) !void {
668	676	const tracy = trace(@src());
669	677	defer tracy.end();
670	678
...	...	@@ -681,8 +689,12 @@ fn writeSectionsToFile(macho_file: *MachO) link.File.FlushError!void {
681	689
682	690	fn writeLoadCommands(macho_file: *MachO) error{ LinkFailure, OutOfMemory }!struct { usize, usize } {
683	691	const gpa = macho_file.base.comp.gpa;
684		var bw: Writer = .fixed(try gpa.alloc(u8, load_commands.calcLoadCommandsSizeObject(macho_file)));
685		defer gpa.free(bw.buffer);
	692	const needed_size = load_commands.calcLoadCommandsSizeObject(macho_file);
	693	const buffer = try gpa.alloc(u8, needed_size);
	694	defer gpa.free(buffer);
	695
	696	var stream = std.io.fixedBufferStream(buffer);
	697	const writer = stream.writer();
686	698
687	699	var ncmds: usize = 0;
688	700
...	...	@@ -690,31 +702,47 @@ fn writeLoadCommands(macho_file: *MachO) error{ LinkFailure, OutOfMemory }!struc
690	702	{
691	703	assert(macho_file.segments.items.len == 1);
692	704	const seg = macho_file.segments.items[0];
693		bw.writeStruct(seg) catch unreachable;
	705	writer.writeStruct(seg) catch \|err\| switch (err) {
	706	error.NoSpaceLeft => unreachable,
	707	};
694	708	for (macho_file.sections.items(.header)) \|header\| {
695		bw.writeStruct(header) catch unreachable;
	709	writer.writeStruct(header) catch \|err\| switch (err) {
	710	error.NoSpaceLeft => unreachable,
	711	};
696	712	}
697	713	ncmds += 1;
698	714	}
699	715
700		bw.writeStruct(macho_file.data_in_code_cmd) catch unreachable;
	716	writer.writeStruct(macho_file.data_in_code_cmd) catch \|err\| switch (err) {
	717	error.NoSpaceLeft => unreachable,
	718	};
701	719	ncmds += 1;
702		bw.writeStruct(macho_file.symtab_cmd) catch unreachable;
	720	writer.writeStruct(macho_file.symtab_cmd) catch \|err\| switch (err) {
	721	error.NoSpaceLeft => unreachable,
	722	};
703	723	ncmds += 1;
704		bw.writeStruct(macho_file.dysymtab_cmd) catch unreachable;
	724	writer.writeStruct(macho_file.dysymtab_cmd) catch \|err\| switch (err) {
	725	error.NoSpaceLeft => unreachable,
	726	};
705	727	ncmds += 1;
706	728
707	729	if (macho_file.platform.isBuildVersionCompatible()) {
708		load_commands.writeBuildVersionLC(&bw, macho_file.platform, macho_file.sdk_version) catch unreachable;
	730	load_commands.writeBuildVersionLC(macho_file.platform, macho_file.sdk_version, writer) catch \|err\| switch (err) {
	731	error.NoSpaceLeft => unreachable,
	732	};
709	733	ncmds += 1;
710	734	} else {
711		load_commands.writeVersionMinLC(&bw, macho_file.platform, macho_file.sdk_version) catch unreachable;
	735	load_commands.writeVersionMinLC(macho_file.platform, macho_file.sdk_version, writer) catch \|err\| switch (err) {
	736	error.NoSpaceLeft => unreachable,
	737	};
712	738	ncmds += 1;
713	739	}
714	740
715		assert(bw.end == bw.buffer.len);
716		try macho_file.pwriteAll(bw.buffer, @sizeOf(macho.mach_header_64));
717		return .{ ncmds, bw.end };
	741	assert(stream.pos == needed_size);
	742
	743	try macho_file.pwriteAll(buffer, @sizeOf(macho.mach_header_64));
	744
	745	return .{ ncmds, buffer.len };
718	746	}
719	747
720	748	fn writeHeader(macho_file: *MachO, ncmds: usize, sizeofcmds: usize) !void {

src/link/MachO/synthetic.zig+54-54

...	...	@@ -27,13 +27,13 @@ pub const GotSection = struct {
27	27	return got.symbols.items.len * @sizeOf(u64);
28	28	}
29	29
30		pub fn write(got: GotSection, macho_file: MachO, bw: Writer) !void {
	30	pub fn write(got: GotSection, macho_file: *MachO, writer: anytype) !void {
31	31	const tracy = trace(@src());
32	32	defer tracy.end();
33	33	for (got.symbols.items) \|ref\| {
34	34	const sym = ref.getSymbol(macho_file).?;
35	35	const value = if (sym.flags.import) @as(u64, 0) else sym.getAddress(.{}, macho_file);
36		try bw.writeInt(u64, value, .little);
	36	try writer.writeInt(u64, value, .little);
37	37	}
38	38	}
39	39
...	...	@@ -89,7 +89,7 @@ pub const StubsSection = struct {
89	89	return stubs.symbols.items.len * header.reserved2;
90	90	}
91	91
92		pub fn write(stubs: StubsSection, macho_file: MachO, bw: Writer) !void {
	92	pub fn write(stubs: StubsSection, macho_file: *MachO, writer: anytype) !void {
93	93	const tracy = trace(@src());
94	94	defer tracy.end();
95	95	const cpu_arch = macho_file.getTarget().cpu.arch;
...	...	@@ -101,20 +101,20 @@ pub const StubsSection = struct {
101	101	const target = laptr_sect.addr + idx * @sizeOf(u64);
102	102	switch (cpu_arch) {
103	103	.x86_64 => {
104		try bw.writeAll(&.{ 0xff, 0x25 });
105		try bw.writeInt(i32, @intCast(target - source - 2 - 4), .little);
	104	try writer.writeAll(&.{ 0xff, 0x25 });
	105	try writer.writeInt(i32, @intCast(target - source - 2 - 4), .little);
106	106	},
107	107	.aarch64 => {
108	108	// TODO relax if possible
109	109	const pages = try aarch64.calcNumberOfPages(@intCast(source), @intCast(target));
110		try bw.writeInt(u32, aarch64.Instruction.adrp(.x16, pages).toU32(), .little);
	110	try writer.writeInt(u32, aarch64.Instruction.adrp(.x16, pages).toU32(), .little);
111	111	const off = try math.divExact(u12, @truncate(target), 8);
112		try bw.writeInt(
	112	try writer.writeInt(
113	113	u32,
114	114	aarch64.Instruction.ldr(.x16, .x16, aarch64.Instruction.LoadStoreOffset.imm(off)).toU32(),
115	115	.little,
116	116	);
117		try bw.writeInt(u32, aarch64.Instruction.br(.x16).toU32(), .little);
	117	try writer.writeInt(u32, aarch64.Instruction.br(.x16).toU32(), .little);
118	118	},
119	119	else => unreachable,
120	120	}
...	...	@@ -175,11 +175,11 @@ pub const StubsHelperSection = struct {
175	175	return s;
176	176	}
177	177
178		pub fn write(stubs_helper: StubsHelperSection, macho_file: MachO, bw: Writer) !void {
	178	pub fn write(stubs_helper: StubsHelperSection, macho_file: *MachO, writer: anytype) !void {
179	179	const tracy = trace(@src());
180	180	defer tracy.end();
181	181
182		try stubs_helper.writePreamble(macho_file, bw);
	182	try stubs_helper.writePreamble(macho_file, writer);
183	183
184	184	const cpu_arch = macho_file.getTarget().cpu.arch;
185	185	const sect = macho_file.sections.items(.header)[macho_file.stubs_helper_sect_index.?];
...	...	@@ -195,24 +195,24 @@ pub const StubsHelperSection = struct {
195	195	const target: i64 = @intCast(sect.addr);
196	196	switch (cpu_arch) {
197	197	.x86_64 => {
198		try bw.writeByte(0x68);
199		try bw.writeInt(u32, offset, .little);
200		try bw.writeByte(0xe9);
201		try bw.writeInt(i32, @intCast(target - source - 6 - 4), .little);
	198	try writer.writeByte(0x68);
	199	try writer.writeInt(u32, offset, .little);
	200	try writer.writeByte(0xe9);
	201	try writer.writeInt(i32, @intCast(target - source - 6 - 4), .little);
202	202	},
203	203	.aarch64 => {
204	204	const literal = blk: {
205	205	const div_res = try std.math.divExact(u64, entry_size - @sizeOf(u32), 4);
206	206	break :blk std.math.cast(u18, div_res) orelse return error.Overflow;
207	207	};
208		try bw.writeInt(u32, aarch64.Instruction.ldrLiteral(
	208	try writer.writeInt(u32, aarch64.Instruction.ldrLiteral(
209	209	.w16,
210	210	literal,
211	211	).toU32(), .little);
212	212	const disp = math.cast(i28, @as(i64, @intCast(target)) - @as(i64, @intCast(source + 4))) orelse
213	213	return error.Overflow;
214		try bw.writeInt(u32, aarch64.Instruction.b(disp).toU32(), .little);
215		try bw.writeAll(&.{ 0x0, 0x0, 0x0, 0x0 });
	214	try writer.writeInt(u32, aarch64.Instruction.b(disp).toU32(), .little);
	215	try writer.writeAll(&.{ 0x0, 0x0, 0x0, 0x0 });
216	216	},
217	217	else => unreachable,
218	218	}
...	...	@@ -220,7 +220,7 @@ pub const StubsHelperSection = struct {
220	220	}
221	221	}
222	222
223		fn writePreamble(stubs_helper: StubsHelperSection, macho_file: MachO, bw: Writer) !void {
	223	fn writePreamble(stubs_helper: StubsHelperSection, macho_file: *MachO, writer: anytype) !void {
224	224	_ = stubs_helper;
225	225	const obj = macho_file.getInternalObject().?;
226	226	const cpu_arch = macho_file.getTarget().cpu.arch;
...	...	@@ -235,21 +235,21 @@ pub const StubsHelperSection = struct {
235	235	};
236	236	switch (cpu_arch) {
237	237	.x86_64 => {
238		try bw.writeAll(&.{ 0x4c, 0x8d, 0x1d });
239		try bw.writeInt(i32, @intCast(dyld_private_addr - sect.addr - 3 - 4), .little);
240		try bw.writeAll(&.{ 0x41, 0x53, 0xff, 0x25 });
241		try bw.writeInt(i32, @intCast(dyld_stub_binder_addr - sect.addr - 11 - 4), .little);
242		try bw.writeByte(0x90);
	238	try writer.writeAll(&.{ 0x4c, 0x8d, 0x1d });
	239	try writer.writeInt(i32, @intCast(dyld_private_addr - sect.addr - 3 - 4), .little);
	240	try writer.writeAll(&.{ 0x41, 0x53, 0xff, 0x25 });
	241	try writer.writeInt(i32, @intCast(dyld_stub_binder_addr - sect.addr - 11 - 4), .little);
	242	try writer.writeByte(0x90);
243	243	},
244	244	.aarch64 => {
245	245	{
246	246	// TODO relax if possible
247	247	const pages = try aarch64.calcNumberOfPages(@intCast(sect.addr), @intCast(dyld_private_addr));
248		try bw.writeInt(u32, aarch64.Instruction.adrp(.x17, pages).toU32(), .little);
	248	try writer.writeInt(u32, aarch64.Instruction.adrp(.x17, pages).toU32(), .little);
249	249	const off: u12 = @truncate(dyld_private_addr);
250		try bw.writeInt(u32, aarch64.Instruction.add(.x17, .x17, off, false).toU32(), .little);
	250	try writer.writeInt(u32, aarch64.Instruction.add(.x17, .x17, off, false).toU32(), .little);
251	251	}
252		try bw.writeInt(u32, aarch64.Instruction.stp(
	252	try writer.writeInt(u32, aarch64.Instruction.stp(
253	253	.x16,
254	254	.x17,
255	255	aarch64.Register.sp,
...	...	@@ -258,15 +258,15 @@ pub const StubsHelperSection = struct {
258	258	{
259	259	// TODO relax if possible
260	260	const pages = try aarch64.calcNumberOfPages(@intCast(sect.addr + 12), @intCast(dyld_stub_binder_addr));
261		try bw.writeInt(u32, aarch64.Instruction.adrp(.x16, pages).toU32(), .little);
	261	try writer.writeInt(u32, aarch64.Instruction.adrp(.x16, pages).toU32(), .little);
262	262	const off = try math.divExact(u12, @truncate(dyld_stub_binder_addr), 8);
263		try bw.writeInt(u32, aarch64.Instruction.ldr(
	263	try writer.writeInt(u32, aarch64.Instruction.ldr(
264	264	.x16,
265	265	.x16,
266	266	aarch64.Instruction.LoadStoreOffset.imm(off),
267	267	).toU32(), .little);
268	268	}
269		try bw.writeInt(u32, aarch64.Instruction.br(.x16).toU32(), .little);
	269	try writer.writeInt(u32, aarch64.Instruction.br(.x16).toU32(), .little);
270	270	},
271	271	else => unreachable,
272	272	}
...	...	@@ -279,7 +279,7 @@ pub const LaSymbolPtrSection = struct {
279	279	return macho_file.stubs.symbols.items.len * @sizeOf(u64);
280	280	}
281	281
282		pub fn write(laptr: LaSymbolPtrSection, macho_file: MachO, bw: Writer) !void {
	282	pub fn write(laptr: LaSymbolPtrSection, macho_file: *MachO, writer: anytype) !void {
283	283	const tracy = trace(@src());
284	284	defer tracy.end();
285	285	_ = laptr;
...	...	@@ -290,12 +290,12 @@ pub const LaSymbolPtrSection = struct {
290	290	const sym = ref.getSymbol(macho_file).?;
291	291	if (sym.flags.weak) {
292	292	const value = sym.getAddress(.{ .stubs = false }, macho_file);
293		try bw.writeInt(u64, @intCast(value), .little);
	293	try writer.writeInt(u64, @intCast(value), .little);
294	294	} else {
295	295	const value = sect.addr + StubsHelperSection.preambleSize(cpu_arch) +
296	296	StubsHelperSection.entrySize(cpu_arch) * stub_helper_idx;
297	297	stub_helper_idx += 1;
298		try bw.writeInt(u64, @intCast(value), .little);
	298	try writer.writeInt(u64, @intCast(value), .little);
299	299	}
300	300	}
301	301	}
...	...	@@ -329,16 +329,16 @@ pub const TlvPtrSection = struct {
329	329	return tlv.symbols.items.len * @sizeOf(u64);
330	330	}
331	331
332		pub fn write(tlv: TlvPtrSection, macho_file: MachO, bw: Writer) !void {
	332	pub fn write(tlv: TlvPtrSection, macho_file: *MachO, writer: anytype) !void {
333	333	const tracy = trace(@src());
334	334	defer tracy.end();
335	335
336	336	for (tlv.symbols.items) \|ref\| {
337	337	const sym = ref.getSymbol(macho_file).?;
338	338	if (sym.flags.import) {
339		try bw.writeInt(u64, 0, .little);
	339	try writer.writeInt(u64, 0, .little);
340	340	} else {
341		try bw.writeInt(u64, sym.getAddress(.{}, macho_file), .little);
	341	try writer.writeInt(u64, sym.getAddress(.{}, macho_file), .little);
342	342	}
343	343	}
344	344	}
...	...	@@ -400,7 +400,7 @@ pub const ObjcStubsSection = struct {
400	400	return objc.symbols.items.len * entrySize(macho_file.getTarget().cpu.arch);
401	401	}
402	402
403		pub fn write(objc: ObjcStubsSection, macho_file: MachO, bw: Writer) !void {
	403	pub fn write(objc: ObjcStubsSection, macho_file: *MachO, writer: anytype) !void {
404	404	const tracy = trace(@src());
405	405	defer tracy.end();
406	406
...	...	@@ -411,18 +411,18 @@ pub const ObjcStubsSection = struct {
411	411	const addr = objc.getAddress(@intCast(idx), macho_file);
412	412	switch (macho_file.getTarget().cpu.arch) {
413	413	.x86_64 => {
414		try bw.writeAll(&.{ 0x48, 0x8b, 0x35 });
	414	try writer.writeAll(&.{ 0x48, 0x8b, 0x35 });
415	415	{
416	416	const target = sym.getObjcSelrefsAddress(macho_file);
417	417	const source = addr;
418		try bw.writeInt(i32, @intCast(target - source - 3 - 4), .little);
	418	try writer.writeInt(i32, @intCast(target - source - 3 - 4), .little);
419	419	}
420		try bw.writeAll(&.{ 0xff, 0x25 });
	420	try writer.writeAll(&.{ 0xff, 0x25 });
421	421	{
422	422	const target_sym = obj.getObjcMsgSendRef(macho_file).?.getSymbol(macho_file).?;
423	423	const target = target_sym.getGotAddress(macho_file);
424	424	const source = addr + 7;
425		try bw.writeInt(i32, @intCast(target - source - 2 - 4), .little);
	425	try writer.writeInt(i32, @intCast(target - source - 2 - 4), .little);
426	426	}
427	427	},
428	428	.aarch64 => {
...	...	@@ -430,9 +430,9 @@ pub const ObjcStubsSection = struct {
430	430	const target = sym.getObjcSelrefsAddress(macho_file);
431	431	const source = addr;
432	432	const pages = try aarch64.calcNumberOfPages(@intCast(source), @intCast(target));
433		try bw.writeInt(u32, aarch64.Instruction.adrp(.x1, pages).toU32(), .little);
	433	try writer.writeInt(u32, aarch64.Instruction.adrp(.x1, pages).toU32(), .little);
434	434	const off = try math.divExact(u12, @truncate(target), 8);
435		try bw.writeInt(
	435	try writer.writeInt(
436	436	u32,
437	437	aarch64.Instruction.ldr(.x1, .x1, aarch64.Instruction.LoadStoreOffset.imm(off)).toU32(),
438	438	.little,
...	...	@@ -443,18 +443,18 @@ pub const ObjcStubsSection = struct {
443	443	const target = target_sym.getGotAddress(macho_file);
444	444	const source = addr + 2 * @sizeOf(u32);
445	445	const pages = try aarch64.calcNumberOfPages(@intCast(source), @intCast(target));
446		try bw.writeInt(u32, aarch64.Instruction.adrp(.x16, pages).toU32(), .little);
	446	try writer.writeInt(u32, aarch64.Instruction.adrp(.x16, pages).toU32(), .little);
447	447	const off = try math.divExact(u12, @truncate(target), 8);
448		try bw.writeInt(
	448	try writer.writeInt(
449	449	u32,
450	450	aarch64.Instruction.ldr(.x16, .x16, aarch64.Instruction.LoadStoreOffset.imm(off)).toU32(),
451	451	.little,
452	452	);
453	453	}
454		try bw.writeInt(u32, aarch64.Instruction.br(.x16).toU32(), .little);
455		try bw.writeInt(u32, aarch64.Instruction.brk(1).toU32(), .little);
456		try bw.writeInt(u32, aarch64.Instruction.brk(1).toU32(), .little);
457		try bw.writeInt(u32, aarch64.Instruction.brk(1).toU32(), .little);
	454	try writer.writeInt(u32, aarch64.Instruction.br(.x16).toU32(), .little);
	455	try writer.writeInt(u32, aarch64.Instruction.brk(1).toU32(), .little);
	456	try writer.writeInt(u32, aarch64.Instruction.brk(1).toU32(), .little);
	457	try writer.writeInt(u32, aarch64.Instruction.brk(1).toU32(), .little);
458	458	},
459	459	else => unreachable,
460	460	}
...	...	@@ -496,7 +496,7 @@ pub const Indsymtab = struct {
496	496	macho_file.dysymtab_cmd.nindirectsyms = ind.nsyms(macho_file);
497	497	}
498	498
499		pub fn write(ind: Indsymtab, macho_file: MachO, bw: Writer) !void {
	499	pub fn write(ind: Indsymtab, macho_file: *MachO, writer: anytype) !void {
500	500	const tracy = trace(@src());
501	501	defer tracy.end();
502	502
...	...	@@ -505,21 +505,21 @@ pub const Indsymtab = struct {
505	505	for (macho_file.stubs.symbols.items) \|ref\| {
506	506	const sym = ref.getSymbol(macho_file).?;
507	507	if (sym.getOutputSymtabIndex(macho_file)) \|idx\| {
508		try bw.writeInt(u32, idx, .little);
	508	try writer.writeInt(u32, idx, .little);
509	509	}
510	510	}
511	511
512	512	for (macho_file.got.symbols.items) \|ref\| {
513	513	const sym = ref.getSymbol(macho_file).?;
514	514	if (sym.getOutputSymtabIndex(macho_file)) \|idx\| {
515		try bw.writeInt(u32, idx, .little);
	515	try writer.writeInt(u32, idx, .little);
516	516	}
517	517	}
518	518
519	519	for (macho_file.stubs.symbols.items) \|ref\| {
520	520	const sym = ref.getSymbol(macho_file).?;
521	521	if (sym.getOutputSymtabIndex(macho_file)) \|idx\| {
522		try bw.writeInt(u32, idx, .little);
	522	try writer.writeInt(u32, idx, .little);
523	523	}
524	524	}
525	525	}
...	...	@@ -573,7 +573,7 @@ pub const DataInCode = struct {
573	573	macho_file.data_in_code_cmd.datasize = math.cast(u32, dice.size()) orelse return error.Overflow;
574	574	}
575	575
576		pub fn write(dice: DataInCode, macho_file: MachO, bw: Writer) !void {
	576	pub fn write(dice: DataInCode, macho_file: *MachO, writer: anytype) !void {
577	577	const base_address = if (!macho_file.base.isRelocatable())
578	578	macho_file.getTextSegment().vmaddr
579	579	else
...	...	@@ -581,7 +581,7 @@ pub const DataInCode = struct {
581	581	for (dice.entries.items) \|entry\| {
582	582	const atom_address = entry.atom_ref.getAtom(macho_file).?.getAddress(macho_file);
583	583	const offset = atom_address + entry.offset - base_address;
584		try bw.writeStruct(macho.data_in_code_entry{
	584	try writer.writeStruct(macho.data_in_code_entry{
585	585	.offset = @intCast(offset),
586	586	.length = entry.length,
587	587	.kind = entry.kind,

author	Andrew Kelley <andrew@ziglang.org> 2025-07-01 18:40:50-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2025-07-07 22:43:52-07:00
log	49be02e6d75acd996d9b2a573714552ba081ea13
tree	171efca8e110fda0bbbedea433367a7d0e526761
parent	c8fcd2ff2c032b2de8cc1a57e075552d1cab35df

MachO: revert unfinished changes