Commit 2c68fb3d7ce077fba711747ee7b05b2fa0df6bcc | zig

author	Jakub Konka <kubkon@jakubkonka.com> 2023-08-27 09:55:24+02:00
committer	Jakub Konka <kubkon@jakubkonka.com> 2023-08-29 11:40:18+02:00
log	2c68fb3d7ce077fba711747ee7b05b2fa0df6bcc
tree	291b3aec840358c08a36c78c468c54fdc34727f0
parent	42e0850d78e63fcc602dd0e167ac90dfb3cfec02

macho: merge Zld state with MachO state

21 files changed, 3042 insertions(+), 4119 deletions(-)

src/link/MachO.zig+1173-218

...	@@ -405,9 +405,7 @@ pub fn flushModule(self: MachO, comp: Compilation, prog_node: *std.Progress.No	...	@@ -405,9 +405,7 @@ pub fn flushModule(self: MachO, comp: Compilation, prog_node: *std.Progress.No
405	const in_file = try std.fs.cwd().openFile(path, .{});	405	const in_file = try std.fs.cwd().openFile(path, .{});
406	defer in_file.close();	406	defer in_file.close();
407		407
408	parseLibrary(	408	self.parseLibrary(
409	self,
410	self.base.allocator,
411	in_file,	409	in_file,
412	path,	410	path,
413	lib,	411	lib,
...	@@ -421,24 +419,15 @@ pub fn flushModule(self: MachO, comp: Compilation, prog_node: *std.Progress.No	...	@@ -421,24 +419,15 @@ pub fn flushModule(self: MachO, comp: Compilation, prog_node: *std.Progress.No
421	};	419	};
422	}	420	}
423		421
424	parseDependentLibs(self, self.base.allocator, &dependent_libs, &self.base.options) catch \|err\| {	422	self.parseDependentLibs(&dependent_libs, &self.base.options) catch \|err\| {
425	// TODO convert to error	423	// TODO convert to error
426	log.err("parsing dependent libraries failed with err {s}", .{@errorName(err)});	424	log.err("parsing dependent libraries failed with err {s}", .{@errorName(err)});
427	};	425	};
428	}	426	}
429		427
430	if (self.dyld_stub_binder_index == null) {
431	self.dyld_stub_binder_index = try self.addUndefined("dyld_stub_binder", .add_got);
432	}
433	if (!self.base.options.single_threaded) {
434	_ = try self.addUndefined("__tlv_bootstrap", .none);
435	}
436
437	try self.createMhExecuteHeaderSymbol();
438
439	var actions = std.ArrayList(ResolveAction).init(self.base.allocator);	428	var actions = std.ArrayList(ResolveAction).init(self.base.allocator);
440	defer actions.deinit();	429	defer actions.deinit();
441	try self.resolveSymbolsInDylibs(&actions);	430	try self.resolveSymbols(&actions);
442		431
443	if (self.getEntryPoint() == null) {	432	if (self.getEntryPoint() == null) {
444	self.error_flags.no_entry_point_found = true;	433	self.error_flags.no_entry_point_found = true;
...	@@ -527,14 +516,7 @@ pub fn flushModule(self: MachO, comp: Compilation, prog_node: *std.Progress.No	...	@@ -527,14 +516,7 @@ pub fn flushModule(self: MachO, comp: Compilation, prog_node: *std.Progress.No
527		516
528	try self.writeLinkeditSegmentData();	517	try self.writeLinkeditSegmentData();
529		518
530	const target = self.base.options.target;	519	var codesig: ?CodeSignature = if (self.requiresCodeSignature()) blk: {
531	const requires_codesig = blk: {
532	if (self.base.options.entitlements) \|_\| break :blk true;
533	if (target.cpu.arch == .aarch64 and (target.os.tag == .macos or target.abi == .simulator))
534	break :blk true;
535	break :blk false;
536	};
537	var codesig: ?CodeSignature = if (requires_codesig) blk: {
538	// Preallocate space for the code signature.	520	// Preallocate space for the code signature.
539	// We need to do this at this stage so that we have the load commands with proper values	521	// We need to do this at this stage so that we have the load commands with proper values
540	// written out to the file.	522	// written out to the file.
...	@@ -596,14 +578,14 @@ pub fn flushModule(self: MachO, comp: Compilation, prog_node: *std.Progress.No	...	@@ -596,14 +578,14 @@ pub fn flushModule(self: MachO, comp: Compilation, prog_node: *std.Progress.No
596		578
597	try load_commands.writeLoadDylibLCs(self.dylibs.items, self.referenced_dylibs.keys(), lc_writer);	579	try load_commands.writeLoadDylibLCs(self.dylibs.items, self.referenced_dylibs.keys(), lc_writer);
598		580
599	if (requires_codesig) {	581	if (codesig != null) {
600	try lc_writer.writeStruct(self.codesig_cmd);	582	try lc_writer.writeStruct(self.codesig_cmd);
601	}	583	}
602		584
603	const ncmds = load_commands.calcNumOfLCs(lc_buffer.items);	585	const ncmds = load_commands.calcNumOfLCs(lc_buffer.items);
604	try self.base.file.?.pwriteAll(lc_buffer.items, @sizeOf(macho.mach_header_64));	586	try self.base.file.?.pwriteAll(lc_buffer.items, @sizeOf(macho.mach_header_64));
605	try self.writeHeader(ncmds, @as(u32, @intCast(lc_buffer.items.len)));	587	try self.writeHeader(ncmds, @as(u32, @intCast(lc_buffer.items.len)));
606	try self.writeUuid(comp, uuid_cmd_offset, requires_codesig);	588	try self.writeUuid(comp, uuid_cmd_offset, codesig != null);
607		589
608	if (codesig) \|*csig\| {	590	if (codesig) \|*csig\| {
609	try self.writeCodeSignature(comp, csig); // code signing always comes last	591	try self.writeCodeSignature(comp, csig); // code signing always comes last
...	@@ -729,8 +711,7 @@ fn resolveLib(	...	@@ -729,8 +711,7 @@ fn resolveLib(
729	}	711	}
730		712
731	pub fn parsePositional(	713	pub fn parsePositional(
732	ctx: anytype,	714	self: *MachO,
733	gpa: Allocator,
734	file: std.fs.File,	715	file: std.fs.File,
735	path: []const u8,	716	path: []const u8,
736	must_link: bool,	717	must_link: bool,
...	@@ -741,9 +722,9 @@ pub fn parsePositional(	...	@@ -741,9 +722,9 @@ pub fn parsePositional(
741	defer tracy.end();	722	defer tracy.end();
742		723
743	if (Object.isObject(file)) {	724	if (Object.isObject(file)) {
744	try parseObject(ctx, gpa, file, path, link_options);	725	try self.parseObject(file, path, link_options);
745	} else {	726	} else {
746	try parseLibrary(ctx, gpa, file, path, .{	727	try self.parseLibrary(file, path, .{
747	.path = null,	728	.path = null,
748	.needed = false,	729	.needed = false,
749	.weak = false,	730	.weak = false,
...	@@ -752,8 +733,7 @@ pub fn parsePositional(	...	@@ -752,8 +733,7 @@ pub fn parsePositional(
752	}	733	}
753		734
754	fn parseObject(	735	fn parseObject(
755	ctx: anytype,	736	self: *MachO,
756	gpa: Allocator,
757	file: std.fs.File,	737	file: std.fs.File,
758	path: []const u8,	738	path: []const u8,
759	link_options: *const link.Options,	739	link_options: *const link.Options,
...	@@ -761,6 +741,7 @@ fn parseObject(	...	@@ -761,6 +741,7 @@ fn parseObject(
761	const tracy = trace(@src());	741	const tracy = trace(@src());
762	defer tracy.end();	742	defer tracy.end();
763		743
		744	const gpa = self.base.allocator;
764	const mtime: u64 = mtime: {	745	const mtime: u64 = mtime: {
765	const stat = file.stat() catch break :mtime 0;	746	const stat = file.stat() catch break :mtime 0;
766	break :mtime @as(u64, @intCast(@divFloor(stat.mtime, 1_000_000_000)));	747	break :mtime @as(u64, @intCast(@divFloor(stat.mtime, 1_000_000_000)));
...	@@ -776,7 +757,7 @@ fn parseObject(	...	@@ -776,7 +757,7 @@ fn parseObject(
776	};	757	};
777	errdefer object.deinit(gpa);	758	errdefer object.deinit(gpa);
778	try object.parse(gpa);	759	try object.parse(gpa);
779	try ctx.objects.append(gpa, object);	760	try self.objects.append(gpa, object);
780		761
781	const cpu_arch: std.Target.Cpu.Arch = switch (object.header.cputype) {	762	const cpu_arch: std.Target.Cpu.Arch = switch (object.header.cputype) {
782	macho.CPU_TYPE_ARM64 => .aarch64,	763	macho.CPU_TYPE_ARM64 => .aarch64,
...	@@ -796,8 +777,7 @@ fn parseObject(	...	@@ -796,8 +777,7 @@ fn parseObject(
796	}	777	}
797		778
798	pub fn parseLibrary(	779	pub fn parseLibrary(
799	ctx: anytype,	780	self: *MachO,
800	gpa: Allocator,
801	file: std.fs.File,	781	file: std.fs.File,
802	path: []const u8,	782	path: []const u8,
803	lib: link.SystemLib,	783	lib: link.SystemLib,
...	@@ -811,16 +791,16 @@ pub fn parseLibrary(	...	@@ -811,16 +791,16 @@ pub fn parseLibrary(
811	const cpu_arch = link_options.target.cpu.arch;	791	const cpu_arch = link_options.target.cpu.arch;
812		792
813	if (fat.isFatLibrary(file)) {	793	if (fat.isFatLibrary(file)) {
814	const offset = parseFatLibrary(ctx, file, path, cpu_arch) catch \|err\| switch (err) {	794	const offset = self.parseFatLibrary(file, path, cpu_arch) catch \|err\| switch (err) {
815	error.MissingArch => return,	795	error.MissingArch => return,
816	else => \|e\| return e,	796	else => \|e\| return e,
817	};	797	};
818	try file.seekTo(offset);	798	try file.seekTo(offset);
819		799
820	if (Archive.isArchive(file, offset)) {	800	if (Archive.isArchive(file, offset)) {
821	try parseArchive(ctx, gpa, path, offset, must_link, cpu_arch);	801	try self.parseArchive(path, offset, must_link, cpu_arch);
822	} else if (Dylib.isDylib(file, offset)) {	802	} else if (Dylib.isDylib(file, offset)) {
823	try parseDylib(ctx, gpa, file, path, offset, dependent_libs, link_options, .{	803	try self.parseDylib(file, path, offset, dependent_libs, link_options, .{
824	.needed = lib.needed,	804	.needed = lib.needed,
825	.weak = lib.weak,	805	.weak = lib.weak,
826	});	806	});
...	@@ -830,14 +810,14 @@ pub fn parseLibrary(	...	@@ -830,14 +810,14 @@ pub fn parseLibrary(
830	return;	810	return;
831	}	811	}
832	} else if (Archive.isArchive(file, 0)) {	812	} else if (Archive.isArchive(file, 0)) {
833	try parseArchive(ctx, gpa, path, 0, must_link, cpu_arch);	813	try self.parseArchive(path, 0, must_link, cpu_arch);
834	} else if (Dylib.isDylib(file, 0)) {	814	} else if (Dylib.isDylib(file, 0)) {
835	try parseDylib(ctx, gpa, file, path, 0, dependent_libs, link_options, .{	815	try self.parseDylib(file, path, 0, dependent_libs, link_options, .{
836	.needed = lib.needed,	816	.needed = lib.needed,
837	.weak = lib.weak,	817	.weak = lib.weak,
838	});	818	});
839	} else {	819	} else {
840	parseLibStub(ctx, gpa, file, path, dependent_libs, link_options, .{	820	self.parseLibStub(file, path, dependent_libs, link_options, .{
841	.needed = lib.needed,	821	.needed = lib.needed,
842	.weak = lib.weak,	822	.weak = lib.weak,
843	}) catch \|err\| switch (err) {	823	}) catch \|err\| switch (err) {
...	@@ -852,12 +832,12 @@ pub fn parseLibrary(	...	@@ -852,12 +832,12 @@ pub fn parseLibrary(
852	}	832	}
853		833
854	pub fn parseFatLibrary(	834	pub fn parseFatLibrary(
855	ctx: anytype,	835	self: *MachO,
856	file: std.fs.File,	836	file: std.fs.File,
857	path: []const u8,	837	path: []const u8,
858	cpu_arch: std.Target.Cpu.Arch,	838	cpu_arch: std.Target.Cpu.Arch,
859	) !u64 {	839	) !u64 {
860	_ = ctx;	840	_ = self;
861	var buffer: [2]fat.Arch = undefined;	841	var buffer: [2]fat.Arch = undefined;
862	const fat_archs = try fat.parseArchs(file, &buffer);	842	const fat_archs = try fat.parseArchs(file, &buffer);
863	const offset = for (fat_archs) \|arch\| {	843	const offset = for (fat_archs) \|arch\| {
...	@@ -871,13 +851,13 @@ pub fn parseFatLibrary(	...	@@ -871,13 +851,13 @@ pub fn parseFatLibrary(
871	}	851	}
872		852
873	fn parseArchive(	853	fn parseArchive(
874	ctx: anytype,	854	self: *MachO,
875	gpa: Allocator,
876	path: []const u8,	855	path: []const u8,
877	fat_offset: u64,	856	fat_offset: u64,
878	must_link: bool,	857	must_link: bool,
879	cpu_arch: std.Target.Cpu.Arch,	858	cpu_arch: std.Target.Cpu.Arch,
880	) !void {	859	) !void {
		860	const gpa = self.base.allocator;
881		861
882	// We take ownership of the file so that we can store it for the duration of symbol resolution.	862	// We take ownership of the file so that we can store it for the duration of symbol resolution.
883	// TODO we shouldn't need to do that and could pre-parse the archive like we do for zld/ELF?	863	// TODO we shouldn't need to do that and could pre-parse the archive like we do for zld/ELF?
...	@@ -929,10 +909,10 @@ fn parseArchive(	...	@@ -929,10 +909,10 @@ fn parseArchive(
929	}	909	}
930	for (offsets.keys()) \|off\| {	910	for (offsets.keys()) \|off\| {
931	const object = try archive.parseObject(gpa, off);	911	const object = try archive.parseObject(gpa, off);
932	try ctx.objects.append(gpa, object);	912	try self.objects.append(gpa, object);
933	}	913	}
934	} else {	914	} else {
935	try ctx.archives.append(gpa, archive);	915	try self.archives.append(gpa, archive);
936	}	916	}
937	}	917	}
938		918
...	@@ -944,8 +924,7 @@ const DylibOpts = struct {	...	@@ -944,8 +924,7 @@ const DylibOpts = struct {
944	};	924	};
945		925
946	fn parseDylib(	926	fn parseDylib(
947	ctx: anytype,	927	self: *MachO,
948	gpa: Allocator,
949	file: std.fs.File,	928	file: std.fs.File,
950	path: []const u8,	929	path: []const u8,
951	offset: u64,	930	offset: u64,
...	@@ -953,6 +932,7 @@ fn parseDylib(	...	@@ -953,6 +932,7 @@ fn parseDylib(
953	link_options: *const link.Options,	932	link_options: *const link.Options,
954	dylib_options: DylibOpts,	933	dylib_options: DylibOpts,
955	) !void {	934	) !void {
		935	const gpa = self.base.allocator;
956	const self_cpu_arch = link_options.target.cpu.arch;	936	const self_cpu_arch = link_options.target.cpu.arch;
957		937
958	const file_stat = try file.stat();	938	const file_stat = try file.stat();
...	@@ -968,7 +948,7 @@ fn parseDylib(	...	@@ -968,7 +948,7 @@ fn parseDylib(
968		948
969	try dylib.parseFromBinary(	949	try dylib.parseFromBinary(
970	gpa,	950	gpa,
971	@intCast(ctx.dylibs.items.len), // TODO defer it till later	951	@intCast(self.dylibs.items.len), // TODO defer it till later
972	dependent_libs,	952	dependent_libs,
973	path,	953	path,
974	contents,	954	contents,
...	@@ -991,7 +971,7 @@ fn parseDylib(	...	@@ -991,7 +971,7 @@ fn parseDylib(
991		971
992	// TODO verify platform	972	// TODO verify platform
993		973
994	addDylib(ctx, gpa, dylib, link_options, .{	974	self.addDylib(dylib, link_options, .{
995	.needed = dylib_options.needed,	975	.needed = dylib_options.needed,
996	.weak = dylib_options.weak,	976	.weak = dylib_options.weak,
997	}) catch \|err\| switch (err) {	977	}) catch \|err\| switch (err) {
...	@@ -1001,14 +981,14 @@ fn parseDylib(	...	@@ -1001,14 +981,14 @@ fn parseDylib(
1001	}	981	}
1002		982
1003	fn parseLibStub(	983	fn parseLibStub(
1004	ctx: anytype,	984	self: *MachO,
1005	gpa: Allocator,
1006	file: std.fs.File,	985	file: std.fs.File,
1007	path: []const u8,	986	path: []const u8,
1008	dependent_libs: anytype,	987	dependent_libs: anytype,
1009	link_options: *const link.Options,	988	link_options: *const link.Options,
1010	dylib_options: DylibOpts,	989	dylib_options: DylibOpts,
1011	) !void {	990	) !void {
		991	const gpa = self.base.allocator;
1012	var lib_stub = try LibStub.loadFromFile(gpa, file);	992	var lib_stub = try LibStub.loadFromFile(gpa, file);
1013	defer lib_stub.deinit();	993	defer lib_stub.deinit();
1014		994
...	@@ -1023,12 +1003,12 @@ fn parseLibStub(	...	@@ -1023,12 +1003,12 @@ fn parseLibStub(
1023	gpa,	1003	gpa,
1024	link_options.target,	1004	link_options.target,
1025	lib_stub,	1005	lib_stub,
1026	@intCast(ctx.dylibs.items.len), // TODO defer it till later	1006	@intCast(self.dylibs.items.len), // TODO defer it till later
1027	dependent_libs,	1007	dependent_libs,
1028	path,	1008	path,
1029	);	1009	);
1030		1010
1031	addDylib(ctx, gpa, dylib, link_options, .{	1011	self.addDylib(dylib, link_options, .{
1032	.needed = dylib_options.needed,	1012	.needed = dylib_options.needed,
1033	.weak = dylib_options.weak,	1013	.weak = dylib_options.weak,
1034	}) catch \|err\| switch (err) {	1014	}) catch \|err\| switch (err) {
...	@@ -1038,8 +1018,7 @@ fn parseLibStub(	...	@@ -1038,8 +1018,7 @@ fn parseLibStub(
1038	}	1018	}
1039		1019
1040	fn addDylib(	1020	fn addDylib(
1041	ctx: anytype,	1021	self: *MachO,
1042	gpa: Allocator,
1043	dylib: Dylib,	1022	dylib: Dylib,
1044	link_options: *const link.Options,	1023	link_options: *const link.Options,
1045	dylib_options: DylibOpts,	1024	dylib_options: DylibOpts,
...	@@ -1055,28 +1034,24 @@ fn addDylib(	...	@@ -1055,28 +1034,24 @@ fn addDylib(
1055	}	1034	}
1056	}	1035	}
1057		1036
1058	const gop = try ctx.dylibs_map.getOrPut(gpa, dylib.id.?.name);	1037	const gpa = self.base.allocator;
		1038	const gop = try self.dylibs_map.getOrPut(gpa, dylib.id.?.name);
1059	if (gop.found_existing) return error.DylibAlreadyExists;	1039	if (gop.found_existing) return error.DylibAlreadyExists;
1060		1040
1061	gop.value_ptr.* = @as(u16, @intCast(ctx.dylibs.items.len));	1041	gop.value_ptr.* = @as(u16, @intCast(self.dylibs.items.len));
1062	try ctx.dylibs.append(gpa, dylib);	1042	try self.dylibs.append(gpa, dylib);
1063		1043
1064	const should_link_dylib_even_if_unreachable = blk: {	1044	const should_link_dylib_even_if_unreachable = blk: {
1065	if (link_options.dead_strip_dylibs and !dylib_options.needed) break :blk false;	1045	if (link_options.dead_strip_dylibs and !dylib_options.needed) break :blk false;
1066	break :blk !(dylib_options.dependent or ctx.referenced_dylibs.contains(gop.value_ptr.*));	1046	break :blk !(dylib_options.dependent or self.referenced_dylibs.contains(gop.value_ptr.*));
1067	};	1047	};
1068		1048
1069	if (should_link_dylib_even_if_unreachable) {	1049	if (should_link_dylib_even_if_unreachable) {
1070	try ctx.referenced_dylibs.putNoClobber(gpa, gop.value_ptr.*, {});	1050	try self.referenced_dylibs.putNoClobber(gpa, gop.value_ptr.*, {});
1071	}	1051	}
1072	}	1052	}
1073		1053
1074	pub fn parseDependentLibs(	1054	pub fn parseDependentLibs(self: MachO, dependent_libs: anytype, link_options: const link.Options) !void {
1075	ctx: anytype,
1076	gpa: Allocator,
1077	dependent_libs: anytype,
1078	link_options: *const link.Options,
1079	) !void {
1080	const tracy = trace(@src());	1055	const tracy = trace(@src());
1081	defer tracy.end();	1056	defer tracy.end();
1082		1057
...	@@ -1085,6 +1060,7 @@ pub fn parseDependentLibs(	...	@@ -1085,6 +1060,7 @@ pub fn parseDependentLibs(
1085	// 2) afterwards, we parse dependents of the included dylibs	1060	// 2) afterwards, we parse dependents of the included dylibs
1086	// TODO this should not be performed if the user specifies `-flat_namespace` flag.	1061	// TODO this should not be performed if the user specifies `-flat_namespace` flag.
1087	// See ld64 manpages.	1062	// See ld64 manpages.
		1063	const gpa = self.base.allocator;
1088	var arena_alloc = std.heap.ArenaAllocator.init(gpa);	1064	var arena_alloc = std.heap.ArenaAllocator.init(gpa);
1089	const arena = arena_alloc.allocator();	1065	const arena = arena_alloc.allocator();
1090	defer arena_alloc.deinit();	1066	defer arena_alloc.deinit();
...	@@ -1092,9 +1068,9 @@ pub fn parseDependentLibs(	...	@@ -1092,9 +1068,9 @@ pub fn parseDependentLibs(
1092	outer: while (dependent_libs.readItem()) \|dep_id\| {	1068	outer: while (dependent_libs.readItem()) \|dep_id\| {
1093	defer dep_id.id.deinit(gpa);	1069	defer dep_id.id.deinit(gpa);
1094		1070
1095	if (ctx.dylibs_map.contains(dep_id.id.name)) continue;	1071	if (self.dylibs_map.contains(dep_id.id.name)) continue;
1096		1072
1097	const weak = ctx.dylibs.items[dep_id.parent].weak;	1073	const weak = self.dylibs.items[dep_id.parent].weak;
1098	const has_ext = blk: {	1074	const has_ext = blk: {
1099	const basename = fs.path.basename(dep_id.id.name);	1075	const basename = fs.path.basename(dep_id.id.name);
1100	break :blk mem.lastIndexOfScalar(u8, basename, '.') != null;	1076	break :blk mem.lastIndexOfScalar(u8, basename, '.') != null;
...	@@ -1121,7 +1097,7 @@ pub fn parseDependentLibs(	...	@@ -1121,7 +1097,7 @@ pub fn parseDependentLibs(
1121	log.debug("trying dependency at fully resolved path {s}", .{full_path});	1097	log.debug("trying dependency at fully resolved path {s}", .{full_path});
1122		1098
1123	const offset: u64 = if (fat.isFatLibrary(file)) blk: {	1099	const offset: u64 = if (fat.isFatLibrary(file)) blk: {
1124	const offset = parseFatLibrary(ctx, file, full_path, link_options.target.cpu.arch) catch \|err\| switch (err) {	1100	const offset = self.parseFatLibrary(file, full_path, link_options.target.cpu.arch) catch \|err\| switch (err) {
1125	error.MissingArch => break,	1101	error.MissingArch => break,
1126	else => \|e\| return e,	1102	else => \|e\| return e,
1127	};	1103	};
...	@@ -1130,12 +1106,12 @@ pub fn parseDependentLibs(	...	@@ -1130,12 +1106,12 @@ pub fn parseDependentLibs(
1130	} else 0;	1106	} else 0;
1131		1107
1132	if (Dylib.isDylib(file, offset)) {	1108	if (Dylib.isDylib(file, offset)) {
1133	try parseDylib(ctx, gpa, file, full_path, offset, dependent_libs, link_options, .{	1109	try self.parseDylib(file, full_path, offset, dependent_libs, link_options, .{
1134	.dependent = true,	1110	.dependent = true,
1135	.weak = weak,	1111	.weak = weak,
1136	});	1112	});
1137	} else {	1113	} else {
1138	parseLibStub(ctx, gpa, file, full_path, dependent_libs, link_options, .{	1114	self.parseLibStub(file, full_path, dependent_libs, link_options, .{
1139	.dependent = true,	1115	.dependent = true,
1140	.weak = weak,	1116	.weak = weak,
1141	}) catch \|err\| switch (err) {	1117	}) catch \|err\| switch (err) {
...	@@ -1394,7 +1370,7 @@ fn markRelocsDirtyByAddress(self: *MachO, addr: u64) void {	...	@@ -1394,7 +1370,7 @@ fn markRelocsDirtyByAddress(self: *MachO, addr: u64) void {
1394	}	1370	}
1395	}	1371	}
1396		1372
1397	pub fn allocateSpecialSymbols(self: anytype) !void {	1373	pub fn allocateSpecialSymbols(self: *MachO) !void {
1398	for (&[_][]const u8{	1374	for (&[_][]const u8{
1399	"___dso_handle",	1375	"___dso_handle",
1400	"__mh_execute_header",	1376	"__mh_execute_header",
...	@@ -1432,24 +1408,82 @@ pub fn createAtom(self: *MachO, sym_index: u32, opts: CreateAtomOpts) !Atom.Inde	...	@@ -1432,24 +1408,82 @@ pub fn createAtom(self: *MachO, sym_index: u32, opts: CreateAtomOpts) !Atom.Inde
1432	return index;	1408	return index;
1433	}	1409	}
1434		1410
		1411	pub fn createTentativeDefAtoms(self: *MachO) !void {
		1412	const gpa = self.base.allocator;
		1413
		1414	for (self.globals.items) \|global\| {
		1415	const sym = self.getSymbolPtr(global);
		1416	if (!sym.tentative()) continue;
		1417	if (sym.n_desc == N_DEAD) continue;
		1418
		1419	log.debug("creating tentative definition for ATOM(%{d}, '{s}') in object({?})", .{
		1420	global.sym_index, self.getSymbolName(global), global.file,
		1421	});
		1422
		1423	// Convert any tentative definition into a regular symbol and allocate
		1424	// text blocks for each tentative definition.
		1425	const size = sym.n_value;
		1426	const alignment = (sym.n_desc >> 8) & 0x0f;
		1427
		1428	if (self.bss_section_index == null) {
		1429	self.bss_section_index = try self.initSection("__DATA", "__bss", .{
		1430	.flags = macho.S_ZEROFILL,
		1431	});
		1432	}
		1433
		1434	sym.* = .{
		1435	.n_strx = sym.n_strx,
		1436	.n_type = macho.N_SECT \| macho.N_EXT,
		1437	.n_sect = self.bss_section_index.? + 1,
		1438	.n_desc = 0,
		1439	.n_value = 0,
		1440	};
		1441
		1442	const atom_index = try self.createAtom(global.sym_index, .{
		1443	.size = size,
		1444	.alignment = alignment,
		1445	});
		1446	const atom = self.getAtomPtr(atom_index);
		1447	atom.file = global.file;
		1448
		1449	self.addAtomToSection(atom_index);
		1450
		1451	assert(global.getFile() != null);
		1452	const object = &self.objects.items[global.getFile().?];
		1453	try object.atoms.append(gpa, atom_index);
		1454	object.atom_by_index_table[global.sym_index] = atom_index;
		1455	}
		1456	}
		1457
1435	fn createDyldPrivateAtom(self: *MachO) !void {	1458	fn createDyldPrivateAtom(self: *MachO) !void {
1436	if (self.dyld_private_atom_index != null) return;	1459	if (self.dyld_private_atom_index != null) return;
1437		1460
1438	const sym_index = try self.allocateSymbol();	1461	const sym_index = try self.allocateSymbol();
1439	const atom_index = try self.createAtom(sym_index, .{});	1462	const atom_index = try self.createAtom(sym_index, .{
		1463	.size = @sizeOf(u64),
		1464	.alignment = 3,
		1465	});
1440	try self.atom_by_index_table.putNoClobber(self.base.allocator, sym_index, atom_index);	1466	try self.atom_by_index_table.putNoClobber(self.base.allocator, sym_index, atom_index);
1441	const atom = self.getAtomPtr(atom_index);
1442	atom.size = @sizeOf(u64);
1443		1467
		1468	if (self.data_section_index == null) {
		1469	self.data_section_index = try self.initSection("__DATA", "__data", .{});
		1470	}
		1471
		1472	const atom = self.getAtom(atom_index);
1444	const sym = atom.getSymbolPtr(self);	1473	const sym = atom.getSymbolPtr(self);
1445	sym.n_type = macho.N_SECT;	1474	sym.n_type = macho.N_SECT;
1446	sym.n_sect = self.data_section_index.? + 1;	1475	sym.n_sect = self.data_section_index.? + 1;
1447	self.dyld_private_atom_index = atom_index;	1476	self.dyld_private_atom_index = atom_index;
1448		1477
1449	sym.n_value = try self.allocateAtom(atom_index, atom.size, @alignOf(u64));	1478	switch (self.mode) {
1450	log.debug("allocated dyld_private atom at 0x{x}", .{sym.n_value});	1479	.zld => self.addAtomToSection(atom_index),
1451	var buffer: [@sizeOf(u64)]u8 = [_]u8{0} ** @sizeOf(u64);	1480	.incremental => {
1452	try self.writeAtom(atom_index, &buffer);	1481	sym.n_value = try self.allocateAtom(atom_index, atom.size, @alignOf(u64));
		1482	log.debug("allocated dyld_private atom at 0x{x}", .{sym.n_value});
		1483	var buffer: [@sizeOf(u64)]u8 = [_]u8{0} ** @sizeOf(u64);
		1484	try self.writeAtom(atom_index, &buffer);
		1485	},
		1486	}
1453	}	1487	}
1454		1488
1455	fn createThreadLocalDescriptorAtom(self: *MachO, sym_name: []const u8, target: SymbolWithLoc) !Atom.Index {	1489	fn createThreadLocalDescriptorAtom(self: *MachO, sym_name: []const u8, target: SymbolWithLoc) !Atom.Index {
...	@@ -1485,7 +1519,7 @@ fn createThreadLocalDescriptorAtom(self: *MachO, sym_name: []const u8, target: S	...	@@ -1485,7 +1519,7 @@ fn createThreadLocalDescriptorAtom(self: *MachO, sym_name: []const u8, target: S
1485	return atom_index;	1519	return atom_index;
1486	}	1520	}
1487		1521
1488	fn createMhExecuteHeaderSymbol(self: *MachO) !void {	1522	pub fn createMhExecuteHeaderSymbol(self: *MachO) !void {
1489	if (self.base.options.output_mode != .Exe) return;	1523	if (self.base.options.output_mode != .Exe) return;
1490		1524
1491	const gpa = self.base.allocator;	1525	const gpa = self.base.allocator;
...	@@ -1501,10 +1535,17 @@ fn createMhExecuteHeaderSymbol(self: *MachO) !void {	...	@@ -1501,10 +1535,17 @@ fn createMhExecuteHeaderSymbol(self: *MachO) !void {
1501	};	1535	};
1502		1536
1503	const gop = try self.getOrPutGlobalPtr("__mh_execute_header");	1537	const gop = try self.getOrPutGlobalPtr("__mh_execute_header");
		1538	if (gop.found_existing) {
		1539	const global = gop.value_ptr.*;
		1540	if (global.getFile()) \|file\| {
		1541	const global_object = &self.objects.items[file];
		1542	global_object.globals_lookup[global.sym_index] = self.getGlobalIndex("__mh_execute_header").?;
		1543	}
		1544	}
1504	gop.value_ptr.* = sym_loc;	1545	gop.value_ptr.* = sym_loc;
1505	}	1546	}
1506		1547
1507	fn createDsoHandleSymbol(self: *MachO) !void {	1548	pub fn createDsoHandleSymbol(self: *MachO) !void {
1508	const global = self.getGlobalPtr("___dso_handle") orelse return;	1549	const global = self.getGlobalPtr("___dso_handle") orelse return;
1509	if (!self.getSymbol(global.*).undf()) return;	1550	if (!self.getSymbol(global.*).undf()) return;
1510		1551
...	@@ -1519,10 +1560,51 @@ fn createDsoHandleSymbol(self: *MachO) !void {	...	@@ -1519,10 +1560,51 @@ fn createDsoHandleSymbol(self: *MachO) !void {
1519	.n_desc = macho.N_WEAK_DEF,	1560	.n_desc = macho.N_WEAK_DEF,
1520	.n_value = 0,	1561	.n_value = 0,
1521	};	1562	};
		1563	const global_index = self.getGlobalIndex("___dso_handle").?;
		1564	if (global.getFile()) \|file\| {
		1565	const global_object = &self.objects.items[file];
		1566	global_object.globals_lookup[global.sym_index] = global_index;
		1567	}
1522	global.* = sym_loc;	1568	global.* = sym_loc;
1523	_ = self.unresolved.swapRemove(self.getGlobalIndex("___dso_handle").?);	1569	_ = self.unresolved.swapRemove(self.getGlobalIndex("___dso_handle").?);
1524	}	1570	}
1525		1571
		1572	pub fn resolveSymbols(self: MachO, actions: std.ArrayList(ResolveAction)) !void {
		1573	// We add the specified entrypoint as the first unresolved symbols so that
		1574	// we search for it in libraries should there be no object files specified
		1575	// on the linker line.
		1576	if (self.base.options.output_mode == .Exe) {
		1577	const entry_name = self.base.options.entry orelse load_commands.default_entry_point;
		1578	_ = try self.addUndefined(entry_name, .none);
		1579	}
		1580
		1581	// Force resolution of any symbols requested by the user.
		1582	for (self.base.options.force_undefined_symbols.keys()) \|sym_name\| {
		1583	_ = try self.addUndefined(sym_name, .none);
		1584	}
		1585
		1586	for (self.objects.items, 0..) \|_, object_id\| {
		1587	try self.resolveSymbolsInObject(@as(u32, @intCast(object_id)));
		1588	}
		1589
		1590	try self.resolveSymbolsInArchives();
		1591
		1592	// Finally, force resolution of dyld_stub_binder if there are imports
		1593	// requested.
		1594	if (self.unresolved.count() > 0 and self.dyld_stub_binder_index == null) {
		1595	self.dyld_stub_binder_index = try self.addUndefined("dyld_stub_binder", .add_got);
		1596	}
		1597	if (!self.base.options.single_threaded and self.mode == .incremental) {
		1598	_ = try self.addUndefined("__tlv_bootstrap", .none);
		1599	}
		1600
		1601	try self.resolveSymbolsInDylibs(actions);
		1602
		1603	try self.createMhExecuteHeaderSymbol();
		1604	try self.createDsoHandleSymbol();
		1605	try self.resolveSymbolsAtLoading();
		1606	}
		1607
1526	fn resolveGlobalSymbol(self: *MachO, current: SymbolWithLoc) !void {	1608	fn resolveGlobalSymbol(self: *MachO, current: SymbolWithLoc) !void {
1527	const gpa = self.base.allocator;	1609	const gpa = self.base.allocator;
1528	const sym = self.getSymbol(current);	1610	const sym = self.getSymbol(current);
...	@@ -1536,6 +1618,7 @@ fn resolveGlobalSymbol(self: *MachO, current: SymbolWithLoc) !void {	...	@@ -1536,6 +1618,7 @@ fn resolveGlobalSymbol(self: *MachO, current: SymbolWithLoc) !void {
1536	}	1618	}
1537	return;	1619	return;
1538	}	1620	}
		1621	const global_index = self.getGlobalIndex(sym_name).?;
1539	const global = gop.value_ptr.*;	1622	const global = gop.value_ptr.*;
1540	const global_sym = self.getSymbol(global);	1623	const global_sym = self.getSymbol(global);
1541		1624
...	@@ -1566,7 +1649,22 @@ fn resolveGlobalSymbol(self: *MachO, current: SymbolWithLoc) !void {	...	@@ -1566,7 +1649,22 @@ fn resolveGlobalSymbol(self: *MachO, current: SymbolWithLoc) !void {
1566	const sym_is_weak = sym.sect() and (sym.weakDef() or sym.pext());	1649	const sym_is_weak = sym.sect() and (sym.weakDef() or sym.pext());
1567	const global_is_weak = global_sym.sect() and (global_sym.weakDef() or global_sym.pext());	1650	const global_is_weak = global_sym.sect() and (global_sym.weakDef() or global_sym.pext());
1568		1651
1569	if (sym_is_strong and global_is_strong) return error.MultipleSymbolDefinitions;	1652	if (sym_is_strong and global_is_strong) {
		1653	log.err("symbol '{s}' defined multiple times", .{sym_name});
		1654	if (global.getFile()) \|file\| {
		1655	log.err(" first definition in '{s}'", .{self.objects.items[file].name});
		1656	}
		1657	if (current.getFile()) \|file\| {
		1658	log.err(" next definition in '{s}'", .{self.objects.items[file].name});
		1659	}
		1660	return error.MultipleSymbolDefinitions;
		1661	}
		1662
		1663	if (current.getFile()) \|file\| {
		1664	const object = &self.objects.items[file];
		1665	object.globals_lookup[current.sym_index] = global_index;
		1666	}
		1667
1570	if (global_is_strong) return;	1668	if (global_is_strong) return;
1571	if (sym_is_weak and global_is_weak) return;	1669	if (sym_is_weak and global_is_weak) return;
1572	if (sym.tentative() and global_sym.tentative()) {	1670	if (sym.tentative() and global_sym.tentative()) {
...	@@ -1574,11 +1672,88 @@ fn resolveGlobalSymbol(self: *MachO, current: SymbolWithLoc) !void {	...	@@ -1574,11 +1672,88 @@ fn resolveGlobalSymbol(self: *MachO, current: SymbolWithLoc) !void {
1574	}	1672	}
1575	if (sym.undf() and !sym.tentative()) return;	1673	if (sym.undf() and !sym.tentative()) return;
1576		1674
1577	_ = self.unresolved.swapRemove(self.getGlobalIndex(sym_name).?);	1675	if (global.getFile()) \|file\| {
		1676	const global_object = &self.objects.items[file];
		1677	global_object.globals_lookup[global.sym_index] = global_index;
		1678	}
		1679	_ = self.unresolved.swapRemove(global_index);
1578		1680
1579	gop.value_ptr.* = current;	1681	gop.value_ptr.* = current;
1580	}	1682	}
1581		1683
		1684	fn resolveSymbolsInObject(self: *MachO, object_id: u32) !void {
		1685	const object = &self.objects.items[object_id];
		1686	const in_symtab = object.in_symtab orelse return;
		1687
		1688	log.debug("resolving symbols in '{s}'", .{object.name});
		1689
		1690	var sym_index: u32 = 0;
		1691	while (sym_index < in_symtab.len) : (sym_index += 1) {
		1692	const sym = &object.symtab[sym_index];
		1693	const sym_name = object.getSymbolName(sym_index);
		1694
		1695	if (sym.stab()) {
		1696	log.err("unhandled symbol type: stab", .{});
		1697	log.err(" symbol '{s}'", .{sym_name});
		1698	log.err(" first definition in '{s}'", .{object.name});
		1699	return error.UnhandledSymbolType;
		1700	}
		1701
		1702	if (sym.indr()) {
		1703	log.err("unhandled symbol type: indirect", .{});
		1704	log.err(" symbol '{s}'", .{sym_name});
		1705	log.err(" first definition in '{s}'", .{object.name});
		1706	return error.UnhandledSymbolType;
		1707	}
		1708
		1709	if (sym.abs()) {
		1710	log.err("unhandled symbol type: absolute", .{});
		1711	log.err(" symbol '{s}'", .{sym_name});
		1712	log.err(" first definition in '{s}'", .{object.name});
		1713	return error.UnhandledSymbolType;
		1714	}
		1715
		1716	if (sym.sect() and !sym.ext()) {
		1717	log.debug("symbol '{s}' local to object {s}; skipping...", .{
		1718	sym_name,
		1719	object.name,
		1720	});
		1721	continue;
		1722	}
		1723
		1724	try self.resolveGlobalSymbol(.{ .sym_index = sym_index, .file = object_id + 1 });
		1725	}
		1726	}
		1727
		1728	fn resolveSymbolsInArchives(self: *MachO) !void {
		1729	if (self.archives.items.len == 0) return;
		1730
		1731	const gpa = self.base.allocator;
		1732	var next_sym: usize = 0;
		1733	loop: while (next_sym < self.unresolved.count()) {
		1734	const global = self.globals.items[self.unresolved.keys()[next_sym]];
		1735	const sym_name = self.getSymbolName(global);
		1736
		1737	for (self.archives.items) \|archive\| {
		1738	// Check if the entry exists in a static archive.
		1739	const offsets = archive.toc.get(sym_name) orelse {
		1740	// No hit.
		1741	continue;
		1742	};
		1743	assert(offsets.items.len > 0);
		1744
		1745	const object_id = @as(u16, @intCast(self.objects.items.len));
		1746	const object = try archive.parseObject(gpa, offsets.items[0]);
		1747	try self.objects.append(gpa, object);
		1748	try self.resolveSymbolsInObject(object_id);
		1749
		1750	continue :loop;
		1751	}
		1752
		1753	next_sym += 1;
		1754	}
		1755	}
		1756
1582	fn resolveSymbolsInDylibs(self: MachO, actions: std.ArrayList(ResolveAction)) !void {	1757	fn resolveSymbolsInDylibs(self: MachO, actions: std.ArrayList(ResolveAction)) !void {
1583	if (self.dylibs.items.len == 0) return;	1758	if (self.dylibs.items.len == 0) return;
1584		1759
...	@@ -1608,6 +1783,7 @@ fn resolveSymbolsInDylibs(self: MachO, actions: std.ArrayList(ResolveAction))	...	@@ -1608,6 +1783,7 @@ fn resolveSymbolsInDylibs(self: MachO, actions: std.ArrayList(ResolveAction))
1608		1783
1609	if (self.unresolved.fetchSwapRemove(global_index)) \|entry\| blk: {	1784	if (self.unresolved.fetchSwapRemove(global_index)) \|entry\| blk: {
1610	if (!sym.undf()) break :blk;	1785	if (!sym.undf()) break :blk;
		1786	if (self.mode == .zld) break :blk;
1611	try actions.append(.{ .kind = entry.value, .target = global });	1787	try actions.append(.{ .kind = entry.value, .target = global });
1612	}	1788	}
1613		1789
...	@@ -1618,6 +1794,42 @@ fn resolveSymbolsInDylibs(self: MachO, actions: std.ArrayList(ResolveAction))	...	@@ -1618,6 +1794,42 @@ fn resolveSymbolsInDylibs(self: MachO, actions: std.ArrayList(ResolveAction))
1618	}	1794	}
1619	}	1795	}
1620		1796
		1797	fn resolveSymbolsAtLoading(self: *MachO) !void {
		1798	const is_lib = self.base.options.output_mode == .Lib;
		1799	const is_dyn_lib = self.base.options.link_mode == .Dynamic and is_lib;
		1800	const allow_undef = is_dyn_lib and (self.base.options.allow_shlib_undefined orelse false);
		1801
		1802	var next_sym: usize = 0;
		1803	while (next_sym < self.unresolved.count()) {
		1804	const global_index = self.unresolved.keys()[next_sym];
		1805	const global = self.globals.items[global_index];
		1806	const sym = self.getSymbolPtr(global);
		1807
		1808	if (sym.discarded()) {
		1809	sym.* = .{
		1810	.n_strx = 0,
		1811	.n_type = macho.N_UNDF,
		1812	.n_sect = 0,
		1813	.n_desc = 0,
		1814	.n_value = 0,
		1815	};
		1816	_ = self.unresolved.swapRemove(global_index);
		1817	continue;
		1818	} else if (allow_undef) {
		1819	const n_desc = @as(
		1820	u16,
		1821	@bitCast(macho.BIND_SPECIAL_DYLIB_FLAT_LOOKUP * @as(i16, @intCast(macho.N_SYMBOL_RESOLVER))),
		1822	);
		1823	sym.n_type = macho.N_EXT;
		1824	sym.n_desc = n_desc;
		1825	_ = self.unresolved.swapRemove(global_index);
		1826	continue;
		1827	}
		1828
		1829	next_sym += 1;
		1830	}
		1831	}
		1832
1621	pub fn deinit(self: *MachO) void {	1833	pub fn deinit(self: *MachO) void {
1622	const gpa = self.base.allocator;	1834	const gpa = self.base.allocator;
1623		1835
...	@@ -1638,7 +1850,6 @@ pub fn deinit(self: *MachO) void {	...	@@ -1638,7 +1850,6 @@ pub fn deinit(self: *MachO) void {
1638	self.thunks.deinit(gpa);	1850	self.thunks.deinit(gpa);
1639		1851
1640	self.strtab.deinit(gpa);	1852	self.strtab.deinit(gpa);
1641
1642	self.locals.deinit(gpa);	1853	self.locals.deinit(gpa);
1643	self.globals.deinit(gpa);	1854	self.globals.deinit(gpa);
1644	self.locals_free_list.deinit(gpa);	1855	self.locals_free_list.deinit(gpa);
...	@@ -1653,6 +1864,14 @@ pub fn deinit(self: *MachO) void {	...	@@ -1653,6 +1864,14 @@ pub fn deinit(self: *MachO) void {
1653	self.resolver.deinit(gpa);	1864	self.resolver.deinit(gpa);
1654	}	1865	}
1655		1866
		1867	for (self.objects.items) \|*object\| {
		1868	object.deinit(gpa);
		1869	}
		1870	self.objects.deinit(gpa);
		1871	for (self.archives.items) \|*archive\| {
		1872	archive.deinit(gpa);
		1873	}
		1874	self.archives.deinit(gpa);
1656	for (self.dylibs.items) \|*dylib\| {	1875	for (self.dylibs.items) \|*dylib\| {
1657	dylib.deinit(gpa);	1876	dylib.deinit(gpa);
1658	}	1877	}
...	@@ -1842,20 +2061,55 @@ fn allocateGlobal(self: *MachO) !u32 {	...	@@ -1842,20 +2061,55 @@ fn allocateGlobal(self: *MachO) !u32 {
1842	return index;	2061	return index;
1843	}	2062	}
1844		2063
1845	fn addGotEntry(self: *MachO, target: SymbolWithLoc) !void {	2064	pub fn addGotEntry(self: *MachO, target: SymbolWithLoc) !void {
1846	if (self.got_table.lookup.contains(target)) return;	2065	if (self.got_table.lookup.contains(target)) return;
1847	const got_index = try self.got_table.allocateEntry(self.base.allocator, target);	2066	const got_index = try self.got_table.allocateEntry(self.base.allocator, target);
1848	try self.writeOffsetTableEntry(got_index);	2067	if (self.got_section_index == null) {
1849	self.got_table_count_dirty = true;	2068	self.got_section_index = try self.initSection("__DATA_CONST", "__got", .{
1850	self.markRelocsDirtyByTarget(target);	2069	.flags = macho.S_NON_LAZY_SYMBOL_POINTERS,
		2070	});
		2071	}
		2072	if (self.mode == .incremental) {
		2073	try self.writeOffsetTableEntry(got_index);
		2074	self.got_table_count_dirty = true;
		2075	self.markRelocsDirtyByTarget(target);
		2076	}
1851	}	2077	}
1852		2078
1853	fn addStubEntry(self: *MachO, target: SymbolWithLoc) !void {	2079	pub fn addStubEntry(self: *MachO, target: SymbolWithLoc) !void {
1854	if (self.stub_table.lookup.contains(target)) return;	2080	if (self.stub_table.lookup.contains(target)) return;
1855	const stub_index = try self.stub_table.allocateEntry(self.base.allocator, target);	2081	const stub_index = try self.stub_table.allocateEntry(self.base.allocator, target);
1856	try self.writeStubTableEntry(stub_index);	2082	if (self.stubs_section_index == null) {
1857	self.stub_table_count_dirty = true;	2083	self.stubs_section_index = try self.initSection("__TEXT", "__stubs", .{
1858	self.markRelocsDirtyByTarget(target);	2084	.flags = macho.S_SYMBOL_STUBS \|
		2085	macho.S_ATTR_PURE_INSTRUCTIONS \|
		2086	macho.S_ATTR_SOME_INSTRUCTIONS,
		2087	.reserved2 = stubs.stubSize(self.base.options.target.cpu.arch),
		2088	});
		2089	self.stub_helper_section_index = try self.initSection("__TEXT", "__stub_helper", .{
		2090	.flags = macho.S_REGULAR \|
		2091	macho.S_ATTR_PURE_INSTRUCTIONS \|
		2092	macho.S_ATTR_SOME_INSTRUCTIONS,
		2093	});
		2094	self.la_symbol_ptr_section_index = try self.initSection("__DATA", "__la_symbol_ptr", .{
		2095	.flags = macho.S_LAZY_SYMBOL_POINTERS,
		2096	});
		2097	}
		2098	if (self.mode == .incremental) {
		2099	try self.writeStubTableEntry(stub_index);
		2100	self.stub_table_count_dirty = true;
		2101	self.markRelocsDirtyByTarget(target);
		2102	}
		2103	}
		2104
		2105	pub fn addTlvPtrEntry(self: *MachO, target: SymbolWithLoc) !void {
		2106	if (self.tlv_ptr_table.lookup.contains(target)) return;
		2107	_ = try self.tlv_ptr_table.allocateEntry(self.gpa, target);
		2108	if (self.tlv_ptr_section_index == null) {
		2109	self.tlv_ptr_section_index = try self.initSection("__DATA", "__thread_ptrs", .{
		2110	.flags = macho.S_THREAD_LOCAL_VARIABLE_POINTERS,
		2111	});
		2112	}
1859	}	2113	}
1860		2114
1861	pub fn updateFunc(self: MachO, mod: Module, func_index: InternPool.Index, air: Air, liveness: Liveness) !void {	2115	pub fn updateFunc(self: MachO, mod: Module, func_index: InternPool.Index, air: Air, liveness: Liveness) !void {
...	@@ -2758,16 +3012,10 @@ const InitSectionOpts = struct {	...	@@ -2758,16 +3012,10 @@ const InitSectionOpts = struct {
2758	reserved2: u32 = 0,	3012	reserved2: u32 = 0,
2759	};	3013	};
2760		3014
2761	pub fn initSection(	3015	pub fn initSection(self: *MachO, segname: []const u8, sectname: []const u8, opts: InitSectionOpts) !u8 {
2762	gpa: Allocator,
2763	ctx: anytype,
2764	segname: []const u8,
2765	sectname: []const u8,
2766	opts: InitSectionOpts,
2767	) !u8 {
2768	log.debug("creating section '{s},{s}'", .{ segname, sectname });	3016	log.debug("creating section '{s},{s}'", .{ segname, sectname });
2769	const index = @as(u8, @intCast(ctx.sections.slice().len));	3017	const index = @as(u8, @intCast(self.sections.slice().len));
2770	try ctx.sections.append(gpa, .{	3018	try self.sections.append(self.base.allocator, .{
2771	.segment_index = undefined, // Segments will be created automatically later down the pipeline	3019	.segment_index = undefined, // Segments will be created automatically later down the pipeline
2772	.header = .{	3020	.header = .{
2773	.sectname = makeStaticString(sectname),	3021	.sectname = makeStaticString(sectname),
...	@@ -2822,7 +3070,7 @@ fn allocateSection(self: *MachO, segname: []const u8, sectname: []const u8, opts	...	@@ -2822,7 +3070,7 @@ fn allocateSection(self: *MachO, segname: []const u8, sectname: []const u8, opts
2822	.cmdsize = @sizeOf(macho.segment_command_64) + @sizeOf(macho.section_64),	3070	.cmdsize = @sizeOf(macho.segment_command_64) + @sizeOf(macho.section_64),
2823	};	3071	};
2824		3072
2825	const sect_id = try initSection(gpa, self, sectname, segname, .{	3073	const sect_id = try self.initSection(sectname, segname, .{
2826	.flags = opts.flags,	3074	.flags = opts.flags,
2827	.reserved2 = opts.reserved2,	3075	.reserved2 = opts.reserved2,
2828	});	3076	});
...	@@ -2918,10 +3166,29 @@ fn growSectionVirtualMemory(self: *MachO, sect_id: u8, needed_size: u64) !void {	...	@@ -2918,10 +3166,29 @@ fn growSectionVirtualMemory(self: *MachO, sect_id: u8, needed_size: u64) !void {
2918	}	3166	}
2919	}	3167	}
2920		3168
		3169	pub fn addAtomToSection(self: *MachO, atom_index: Atom.Index) void {
		3170	assert(self.mode == .zld);
		3171	const atom = self.getAtomPtr(atom_index);
		3172	const sym = self.getSymbol(atom.getSymbolWithLoc());
		3173	var section = self.sections.get(sym.n_sect - 1);
		3174	if (section.header.size > 0) {
		3175	const last_atom = self.getAtomPtr(section.last_atom_index.?);
		3176	last_atom.next_index = atom_index;
		3177	atom.prev_index = section.last_atom_index;
		3178	} else {
		3179	section.first_atom_index = atom_index;
		3180	}
		3181	section.last_atom_index = atom_index;
		3182	section.header.size += atom.size;
		3183	self.sections.set(sym.n_sect - 1, section);
		3184	}
		3185
2921	fn allocateAtom(self: *MachO, atom_index: Atom.Index, new_atom_size: u64, alignment: u64) !u64 {	3186	fn allocateAtom(self: *MachO, atom_index: Atom.Index, new_atom_size: u64, alignment: u64) !u64 {
2922	const tracy = trace(@src());	3187	const tracy = trace(@src());
2923	defer tracy.end();	3188	defer tracy.end();
2924		3189
		3190	assert(self.mode == .incremental);
		3191
2925	const atom = self.getAtom(atom_index);	3192	const atom = self.getAtom(atom_index);
2926	const sect_id = atom.getSymbol(self).n_sect - 1;	3193	const sect_id = atom.getSymbol(self).n_sect - 1;
2927	const segment = self.getSegmentPtr(sect_id);	3194	const segment = self.getSegmentPtr(sect_id);
...	@@ -3048,7 +3315,7 @@ pub fn getGlobalSymbol(self: *MachO, name: []const u8, lib_name: ?[]const u8) !u	...	@@ -3048,7 +3315,7 @@ pub fn getGlobalSymbol(self: *MachO, name: []const u8, lib_name: ?[]const u8) !u
3048	return self.addUndefined(sym_name, .add_stub);	3315	return self.addUndefined(sym_name, .add_stub);
3049	}	3316	}
3050		3317
3051	pub fn writeSegmentHeaders(self: anytype, writer: anytype) !void {	3318	pub fn writeSegmentHeaders(self: *MachO, writer: anytype) !void {
3052	for (self.segments.items, 0..) \|seg, i\| {	3319	for (self.segments.items, 0..) \|seg, i\| {
3053	const indexes = self.getSectionIndexes(@as(u8, @intCast(i)));	3320	const indexes = self.getSectionIndexes(@as(u8, @intCast(i)));
3054	var out_seg = seg;	3321	var out_seg = seg;
...	@@ -3075,7 +3342,7 @@ pub fn writeSegmentHeaders(self: anytype, writer: anytype) !void {	...	@@ -3075,7 +3342,7 @@ pub fn writeSegmentHeaders(self: anytype, writer: anytype) !void {
3075	}	3342	}
3076	}	3343	}
3077		3344
3078	fn writeLinkeditSegmentData(self: *MachO) !void {	3345	pub fn writeLinkeditSegmentData(self: *MachO) !void {
3079	const page_size = getPageSize(self.base.options.target.cpu.arch);	3346	const page_size = getPageSize(self.base.options.target.cpu.arch);
3080	const seg = self.getLinkeditSegmentPtr();	3347	const seg = self.getLinkeditSegmentPtr();
3081	seg.filesize = 0;	3348	seg.filesize = 0;
...	@@ -3092,29 +3359,29 @@ fn writeLinkeditSegmentData(self: *MachO) !void {	...	@@ -3092,29 +3359,29 @@ fn writeLinkeditSegmentData(self: *MachO) !void {
3092	}	3359	}
3093		3360
3094	try self.writeDyldInfoData();	3361	try self.writeDyldInfoData();
		3362	// TODO handle this better
		3363	if (self.mode == .zld) {
		3364	try self.writeFunctionStarts();
		3365	try self.writeDataInCode();
		3366	}
3095	try self.writeSymtabs();	3367	try self.writeSymtabs();
3096		3368
3097	seg.vmsize = mem.alignForward(u64, seg.filesize, page_size);	3369	seg.vmsize = mem.alignForward(u64, seg.filesize, page_size);
3098	}	3370	}
3099		3371
3100	pub fn collectRebaseDataFromTableSection(	3372	fn collectRebaseDataFromTableSection(self: MachO, sect_id: u8, rebase: Rebase, table: anytype) !void {
3101	gpa: Allocator,	3373	const gpa = self.base.allocator;
3102	ctx: anytype,	3374	const header = self.sections.items(.header)[sect_id];
3103	sect_id: u8,	3375	const segment_index = self.sections.items(.segment_index)[sect_id];
3104	rebase: *Rebase,	3376	const segment = self.segments.items[segment_index];
3105	table: anytype,
3106	) !void {
3107	const header = ctx.sections.items(.header)[sect_id];
3108	const segment_index = ctx.sections.items(.segment_index)[sect_id];
3109	const segment = ctx.segments.items[segment_index];
3110	const base_offset = header.addr - segment.vmaddr;	3377	const base_offset = header.addr - segment.vmaddr;
3111	const is_got = if (ctx.got_section_index) \|index\| index == sect_id else false;	3378	const is_got = if (self.got_section_index) \|index\| index == sect_id else false;
3112		3379
3113	try rebase.entries.ensureUnusedCapacity(gpa, table.entries.items.len);	3380	try rebase.entries.ensureUnusedCapacity(gpa, table.entries.items.len);
3114		3381
3115	for (table.entries.items, 0..) \|entry, i\| {	3382	for (table.entries.items, 0..) \|entry, i\| {
3116	if (!table.lookup.contains(entry)) continue;	3383	if (!table.lookup.contains(entry)) continue;
3117	const sym = ctx.getSymbol(entry);	3384	const sym = self.getSymbol(entry);
3118	if (is_got and sym.undf()) continue;	3385	if (is_got and sym.undf()) continue;
3119	const offset = i * @sizeOf(u64);	3386	const offset = i * @sizeOf(u64);
3120	log.debug(" \| rebase at {x}", .{base_offset + offset});	3387	log.debug(" \| rebase at {x}", .{base_offset + offset});
...	@@ -3152,34 +3419,105 @@ fn collectRebaseData(self: MachO, rebase: Rebase) !void {	...	@@ -3152,34 +3419,105 @@ fn collectRebaseData(self: MachO, rebase: Rebase) !void {
3152	}	3419	}
3153	}	3420	}
3154		3421
3155	try collectRebaseDataFromTableSection(gpa, self, self.got_section_index.?, rebase, self.got_table);	3422	// Unpack GOT entries
3156	try collectRebaseDataFromTableSection(gpa, self, self.la_symbol_ptr_section_index.?, rebase, self.stub_table);	3423	if (self.got_section_index) \|sect_id\| {
		3424	try self.collectRebaseDataFromTableSection(sect_id, rebase, self.got_table);
		3425	}
		3426
		3427	// Next, unpack __la_symbol_ptr entries
		3428	if (self.la_symbol_ptr_section_index) \|sect_id\| {
		3429	try self.collectRebaseDataFromTableSection(sect_id, rebase, self.stub_table);
		3430	}
		3431
		3432	// Finally, unpack the rest.
		3433	const cpu_arch = self.base.options.target.cpu.arch;
		3434	for (self.objects.items) \|*object\| {
		3435	for (object.atoms.items) \|atom_index\| {
		3436	const atom = self.getAtom(atom_index);
		3437	const sym = self.getSymbol(atom.getSymbolWithLoc());
		3438	if (sym.n_desc == N_DEAD) continue;
		3439
		3440	const sect_id = sym.n_sect - 1;
		3441	const section = self.sections.items(.header)[sect_id];
		3442	const segment_id = self.sections.items(.segment_index)[sect_id];
		3443	const segment = self.segments.items[segment_id];
		3444	if (segment.maxprot & macho.PROT.WRITE == 0) continue;
		3445	switch (section.type()) {
		3446	macho.S_LITERAL_POINTERS,
		3447	macho.S_REGULAR,
		3448	macho.S_MOD_INIT_FUNC_POINTERS,
		3449	macho.S_MOD_TERM_FUNC_POINTERS,
		3450	=> {},
		3451	else => continue,
		3452	}
		3453
		3454	log.debug(" ATOM({d}, %{d}, '{s}')", .{
		3455	atom_index,
		3456	atom.sym_index,
		3457	self.getSymbolName(atom.getSymbolWithLoc()),
		3458	});
		3459
		3460	const code = Atom.getAtomCode(self, atom_index);
		3461	const relocs = Atom.getAtomRelocs(self, atom_index);
		3462	const ctx = Atom.getRelocContext(self, atom_index);
		3463
		3464	for (relocs) \|rel\| {
		3465	switch (cpu_arch) {
		3466	.aarch64 => {
		3467	const rel_type = @as(macho.reloc_type_arm64, @enumFromInt(rel.r_type));
		3468	if (rel_type != .ARM64_RELOC_UNSIGNED) continue;
		3469	if (rel.r_length != 3) continue;
		3470	},
		3471	.x86_64 => {
		3472	const rel_type = @as(macho.reloc_type_x86_64, @enumFromInt(rel.r_type));
		3473	if (rel_type != .X86_64_RELOC_UNSIGNED) continue;
		3474	if (rel.r_length != 3) continue;
		3475	},
		3476	else => unreachable,
		3477	}
		3478	const target = Atom.parseRelocTarget(self, .{
		3479	.object_id = atom.getFile().?,
		3480	.rel = rel,
		3481	.code = code,
		3482	.base_offset = ctx.base_offset,
		3483	.base_addr = ctx.base_addr,
		3484	});
		3485	const target_sym = self.getSymbol(target);
		3486	if (target_sym.undf()) continue;
		3487
		3488	const base_offset = @as(i32, @intCast(sym.n_value - segment.vmaddr));
		3489	const rel_offset = rel.r_address - ctx.base_offset;
		3490	const offset = @as(u64, @intCast(base_offset + rel_offset));
		3491	log.debug(" \| rebase at {x}", .{offset});
		3492
		3493	try rebase.entries.append(self.gpa, .{
		3494	.offset = offset,
		3495	.segment_id = segment_id,
		3496	});
		3497	}
		3498	}
		3499	}
3157		3500
3158	try rebase.finalize(gpa);	3501	try rebase.finalize(gpa);
3159	}	3502	}
3160		3503
3161	pub fn collectBindDataFromTableSection(	3504	fn collectBindDataFromTableSection(self: *MachO, sect_id: u8, bind: anytype, table: anytype) !void {
3162	gpa: Allocator,	3505	const gpa = self.base.allocator;
3163	ctx: anytype,	3506	const header = self.sections.items(.header)[sect_id];
3164	sect_id: u8,	3507	const segment_index = self.sections.items(.segment_index)[sect_id];
3165	bind: anytype,	3508	const segment = self.segments.items[segment_index];
3166	table: anytype,
3167	) !void {
3168	const header = ctx.sections.items(.header)[sect_id];
3169	const segment_index = ctx.sections.items(.segment_index)[sect_id];
3170	const segment = ctx.segments.items[segment_index];
3171	const base_offset = header.addr - segment.vmaddr;	3509	const base_offset = header.addr - segment.vmaddr;
3172		3510
3173	try bind.entries.ensureUnusedCapacity(gpa, table.entries.items.len);	3511	try bind.entries.ensureUnusedCapacity(gpa, table.entries.items.len);
3174		3512
3175	for (table.entries.items, 0..) \|entry, i\| {	3513	for (table.entries.items, 0..) \|entry, i\| {
3176	if (!table.lookup.contains(entry)) continue;	3514	if (!table.lookup.contains(entry)) continue;
3177	const bind_sym = ctx.getSymbol(entry);	3515	const bind_sym = self.getSymbol(entry);
3178	if (!bind_sym.undf()) continue;	3516	if (!bind_sym.undf()) continue;
3179	const offset = i * @sizeOf(u64);	3517	const offset = i * @sizeOf(u64);
3180	log.debug(" \| bind at {x}, import('{s}') in dylib({d})", .{	3518	log.debug(" \| bind at {x}, import('{s}') in dylib({d})", .{
3181	base_offset + offset,	3519	base_offset + offset,
3182	ctx.getSymbolName(entry),	3520	self.getSymbolName(entry),
3183	@divTrunc(@as(i16, @bitCast(bind_sym.n_desc)), macho.N_SYMBOL_RESOLVER),	3521	@divTrunc(@as(i16, @bitCast(bind_sym.n_desc)), macho.N_SYMBOL_RESOLVER),
3184	});	3522	});
3185	if (bind_sym.weakRef()) {	3523	if (bind_sym.weakRef()) {
...	@@ -3235,13 +3573,105 @@ fn collectBindData(self: *MachO, bind: anytype, raw_bindings: anytype) !void {	...	@@ -3235,13 +3573,105 @@ fn collectBindData(self: *MachO, bind: anytype, raw_bindings: anytype) !void {
3235	}	3573	}
3236	}	3574	}
3237		3575
3238	// Gather GOT pointers	3576	// Unpack GOT pointers
3239	try collectBindDataFromTableSection(gpa, self, self.got_section_index.?, bind, self.got_table);	3577	if (self.got_section_index) \|sect_id\| {
		3578	try self.collectBindDataFromTableSection(sect_id, bind, self.got_table);
		3579	}
		3580
		3581	// Next, unpack TLV pointers section
		3582	if (self.tlv_ptr_section_index) \|sect_id\| {
		3583	try self.collectBindDataFromTableSection(sect_id, bind, self.tlv_ptr_table);
		3584	}
		3585
		3586	// Finally, unpack the rest.
		3587	const cpu_arch = self.base.options.target.cpu.arch;
		3588	for (self.objects.items) \|*object\| {
		3589	for (object.atoms.items) \|atom_index\| {
		3590	const atom = self.getAtom(atom_index);
		3591	const sym = self.getSymbol(atom.getSymbolWithLoc());
		3592	if (sym.n_desc == N_DEAD) continue;
		3593
		3594	const sect_id = sym.n_sect - 1;
		3595	const section = self.sections.items(.header)[sect_id];
		3596	const segment_id = self.sections.items(.segment_index)[sect_id];
		3597	const segment = self.segments.items[segment_id];
		3598	if (segment.maxprot & macho.PROT.WRITE == 0) continue;
		3599	switch (section.type()) {
		3600	macho.S_LITERAL_POINTERS,
		3601	macho.S_REGULAR,
		3602	macho.S_MOD_INIT_FUNC_POINTERS,
		3603	macho.S_MOD_TERM_FUNC_POINTERS,
		3604	=> {},
		3605	else => continue,
		3606	}
		3607
		3608	log.debug(" ATOM({d}, %{d}, '{s}')", .{
		3609	atom_index,
		3610	atom.sym_index,
		3611	self.getSymbolName(atom.getSymbolWithLoc()),
		3612	});
		3613
		3614	const code = Atom.getAtomCode(self, atom_index);
		3615	const relocs = Atom.getAtomRelocs(self, atom_index);
		3616	const ctx = Atom.getRelocContext(self, atom_index);
		3617
		3618	for (relocs) \|rel\| {
		3619	switch (cpu_arch) {
		3620	.aarch64 => {
		3621	const rel_type = @as(macho.reloc_type_arm64, @enumFromInt(rel.r_type));
		3622	if (rel_type != .ARM64_RELOC_UNSIGNED) continue;
		3623	if (rel.r_length != 3) continue;
		3624	},
		3625	.x86_64 => {
		3626	const rel_type = @as(macho.reloc_type_x86_64, @enumFromInt(rel.r_type));
		3627	if (rel_type != .X86_64_RELOC_UNSIGNED) continue;
		3628	if (rel.r_length != 3) continue;
		3629	},
		3630	else => unreachable,
		3631	}
		3632
		3633	const global = Atom.parseRelocTarget(self, .{
		3634	.object_id = atom.getFile().?,
		3635	.rel = rel,
		3636	.code = code,
		3637	.base_offset = ctx.base_offset,
		3638	.base_addr = ctx.base_addr,
		3639	});
		3640	const bind_sym_name = self.getSymbolName(global);
		3641	const bind_sym = self.getSymbol(global);
		3642	if (!bind_sym.undf()) continue;
		3643
		3644	const base_offset = sym.n_value - segment.vmaddr;
		3645	const rel_offset = @as(u32, @intCast(rel.r_address - ctx.base_offset));
		3646	const offset = @as(u64, @intCast(base_offset + rel_offset));
		3647	const addend = mem.readIntLittle(i64, code[rel_offset..][0..8]);
		3648
		3649	const dylib_ordinal = @divTrunc(@as(i16, @bitCast(bind_sym.n_desc)), macho.N_SYMBOL_RESOLVER);
		3650	log.debug(" \| bind at {x}, import('{s}') in dylib({d})", .{
		3651	base_offset,
		3652	bind_sym_name,
		3653	dylib_ordinal,
		3654	});
		3655	log.debug(" \| with addend {x}", .{addend});
		3656	if (bind_sym.weakRef()) {
		3657	log.debug(" \| marking as weak ref ", .{});
		3658	}
		3659	try bind.entries.append(self.gpa, .{
		3660	.target = global,
		3661	.offset = offset,
		3662	.segment_id = segment_id,
		3663	.addend = addend,
		3664	});
		3665	}
		3666	}
		3667	}
		3668
3240	try bind.finalize(gpa, self);	3669	try bind.finalize(gpa, self);
3241	}	3670	}
3242		3671
3243	fn collectLazyBindData(self: *MachO, bind: anytype) !void {	3672	fn collectLazyBindData(self: *MachO, bind: anytype) !void {
3244	try collectBindDataFromTableSection(self.base.allocator, self, self.la_symbol_ptr_section_index.?, bind, self.stub_table);	3673	const sect_id = self.la_symbol_ptr_section_index orelse return;
		3674	try self.collectBindDataFromTableSection(sect_id, bind, self.stub_table);
3245	try bind.finalize(self.base.allocator, self);	3675	try bind.finalize(self.base.allocator, self);
3246	}	3676	}
3247		3677
...	@@ -3259,6 +3689,7 @@ fn collectExportData(self: MachO, trie: Trie) !void {	...	@@ -3259,6 +3689,7 @@ fn collectExportData(self: MachO, trie: Trie) !void {
3259		3689
3260	if (sym.undf()) continue;	3690	if (sym.undf()) continue;
3261	assert(sym.ext());	3691	assert(sym.ext());
		3692	if (sym.n_desc == N_DEAD) continue;
3262		3693
3263	const sym_name = self.getSymbolName(global);	3694	const sym_name = self.getSymbolName(global);
3264	log.debug(" (putting '{s}' defined at 0x{x})", .{ sym_name, sym.n_value });	3695	log.debug(" (putting '{s}' defined at 0x{x})", .{ sym_name, sym.n_value });
...	@@ -3349,12 +3780,7 @@ fn writeDyldInfoData(self: *MachO) !void {	...	@@ -3349,12 +3780,7 @@ fn writeDyldInfoData(self: *MachO) !void {
3349	});	3780	});
3350		3781
3351	try self.base.file.?.pwriteAll(buffer, rebase_off);	3782	try self.base.file.?.pwriteAll(buffer, rebase_off);
3352	try populateLazyBindOffsetsInStubHelper(	3783	try self.populateLazyBindOffsetsInStubHelper(lazy_bind);
3353	self,
3354	self.base.options.target.cpu.arch,
3355	self.base.file.?,
3356	lazy_bind,
3357	);
3358		3784
3359	self.dyld_info_cmd.rebase_off = @as(u32, @intCast(rebase_off));	3785	self.dyld_info_cmd.rebase_off = @as(u32, @intCast(rebase_off));
3360	self.dyld_info_cmd.rebase_size = @as(u32, @intCast(rebase_size_aligned));	3786	self.dyld_info_cmd.rebase_size = @as(u32, @intCast(rebase_size_aligned));
...	@@ -3366,19 +3792,15 @@ fn writeDyldInfoData(self: *MachO) !void {	...	@@ -3366,19 +3792,15 @@ fn writeDyldInfoData(self: *MachO) !void {
3366	self.dyld_info_cmd.export_size = @as(u32, @intCast(export_size_aligned));	3792	self.dyld_info_cmd.export_size = @as(u32, @intCast(export_size_aligned));
3367	}	3793	}
3368		3794
3369	pub fn populateLazyBindOffsetsInStubHelper(	3795	fn populateLazyBindOffsetsInStubHelper(self: *MachO, lazy_bind: anytype) !void {
3370	ctx: anytype,
3371	cpu_arch: std.Target.Cpu.Arch,
3372	file: fs.File,
3373	lazy_bind: anytype,
3374	) !void {
3375	if (lazy_bind.size() == 0) return;	3796	if (lazy_bind.size() == 0) return;
3376		3797
3377	const stub_helper_section_index = ctx.stub_helper_section_index.?;	3798	const stub_helper_section_index = self.stub_helper_section_index.?;
3378	// assert(ctx.stub_helper_preamble_allocated);	3799	// assert(ctx.stub_helper_preamble_allocated);
3379		3800
3380	const header = ctx.sections.items(.header)[stub_helper_section_index];	3801	const header = self.sections.items(.header)[stub_helper_section_index];
3381		3802
		3803	const cpu_arch = self.base.options.target.cpu.arch;
3382	const preamble_size = stubs.stubHelperPreambleSize(cpu_arch);	3804	const preamble_size = stubs.stubHelperPreambleSize(cpu_arch);
3383	const stub_size = stubs.stubHelperSize(cpu_arch);	3805	const stub_size = stubs.stubHelperSize(cpu_arch);
3384	const stub_offset = stubs.stubOffsetInStubHelper(cpu_arch);	3806	const stub_offset = stubs.stubOffsetInStubHelper(cpu_arch);
...	@@ -3389,14 +3811,175 @@ pub fn populateLazyBindOffsetsInStubHelper(	...	@@ -3389,14 +3811,175 @@ pub fn populateLazyBindOffsetsInStubHelper(
3389		3811
3390	log.debug("writing lazy bind offset 0x{x} ({s}) in stub helper at 0x{x}", .{	3812	log.debug("writing lazy bind offset 0x{x} ({s}) in stub helper at 0x{x}", .{
3391	bind_offset,	3813	bind_offset,
3392	ctx.getSymbolName(lazy_bind.entries.items[index].target),	3814	self.getSymbolName(lazy_bind.entries.items[index].target),
3393	file_offset,	3815	file_offset,
3394	});	3816	});
3395		3817
3396	try file.pwriteAll(mem.asBytes(&bind_offset), file_offset);	3818	try self.base.file.?.pwriteAll(mem.asBytes(&bind_offset), file_offset);
3397	}	3819	}
3398	}	3820	}
3399		3821
		3822	const asc_u64 = std.sort.asc(u64);
		3823
		3824	fn addSymbolToFunctionStarts(self: MachO, sym_loc: SymbolWithLoc, addresses: std.ArrayList(u64)) !void {
		3825	const sym = self.getSymbol(sym_loc);
		3826	if (sym.n_strx == 0) return;
		3827	if (sym.n_desc == MachO.N_DEAD) return;
		3828	if (self.symbolIsTemp(sym_loc)) return;
		3829	try addresses.append(sym.n_value);
		3830	}
		3831
		3832	fn writeFunctionStarts(self: *MachO) !void {
		3833	const gpa = self.base.allocator;
		3834	const seg = self.segments.items[self.header_segment_cmd_index.?];
		3835
		3836	// We need to sort by address first
		3837	var addresses = std.ArrayList(u64).init(gpa);
		3838	defer addresses.deinit();
		3839
		3840	for (self.objects.items) \|object\| {
		3841	for (object.exec_atoms.items) \|atom_index\| {
		3842	const atom = self.getAtom(atom_index);
		3843	const sym_loc = atom.getSymbolWithLoc();
		3844	try self.addSymbolToFunctionStarts(sym_loc, &addresses);
		3845
		3846	var it = Atom.getInnerSymbolsIterator(self, atom_index);
		3847	while (it.next()) \|inner_sym_loc\| {
		3848	try self.addSymbolToFunctionStarts(inner_sym_loc, &addresses);
		3849	}
		3850	}
		3851	}
		3852
		3853	mem.sort(u64, addresses.items, {}, asc_u64);
		3854
		3855	var offsets = std.ArrayList(u32).init(gpa);
		3856	defer offsets.deinit();
		3857	try offsets.ensureTotalCapacityPrecise(addresses.items.len);
		3858
		3859	var last_off: u32 = 0;
		3860	for (addresses.items) \|addr\| {
		3861	const offset = @as(u32, @intCast(addr - seg.vmaddr));
		3862	const diff = offset - last_off;
		3863
		3864	if (diff == 0) continue;
		3865
		3866	offsets.appendAssumeCapacity(diff);
		3867	last_off = offset;
		3868	}
		3869
		3870	var buffer = std.ArrayList(u8).init(gpa);
		3871	defer buffer.deinit();
		3872
		3873	const max_size = @as(usize, @intCast(offsets.items.len * @sizeOf(u64)));
		3874	try buffer.ensureTotalCapacity(max_size);
		3875
		3876	for (offsets.items) \|offset\| {
		3877	try std.leb.writeULEB128(buffer.writer(), offset);
		3878	}
		3879
		3880	const link_seg = self.getLinkeditSegmentPtr();
		3881	const offset = link_seg.fileoff + link_seg.filesize;
		3882	assert(mem.isAlignedGeneric(u64, offset, @alignOf(u64)));
		3883	const needed_size = buffer.items.len;
		3884	const needed_size_aligned = mem.alignForward(u64, needed_size, @alignOf(u64));
		3885	const padding = math.cast(usize, needed_size_aligned - needed_size) orelse return error.Overflow;
		3886	if (padding > 0) {
		3887	try buffer.ensureUnusedCapacity(padding);
		3888	buffer.appendNTimesAssumeCapacity(0, padding);
		3889	}
		3890	link_seg.filesize = offset + needed_size_aligned - link_seg.fileoff;
		3891
		3892	log.debug("writing function starts info from 0x{x} to 0x{x}", .{ offset, offset + needed_size_aligned });
		3893
		3894	try self.base.file.?.pwriteAll(buffer.items, offset);
		3895
		3896	self.function_starts_cmd.dataoff = @as(u32, @intCast(offset));
		3897	self.function_starts_cmd.datasize = @as(u32, @intCast(needed_size_aligned));
		3898	}
		3899
		3900	fn filterDataInCode(
		3901	dices: []const macho.data_in_code_entry,
		3902	start_addr: u64,
		3903	end_addr: u64,
		3904	) []const macho.data_in_code_entry {
		3905	const Predicate = struct {
		3906	addr: u64,
		3907
		3908	pub fn predicate(self: @This(), dice: macho.data_in_code_entry) bool {
		3909	return dice.offset >= self.addr;
		3910	}
		3911	};
		3912
		3913	const start = MachO.lsearch(macho.data_in_code_entry, dices, Predicate{ .addr = start_addr });
		3914	const end = MachO.lsearch(macho.data_in_code_entry, dices[start..], Predicate{ .addr = end_addr }) + start;
		3915
		3916	return dices[start..end];
		3917	}
		3918
		3919	pub fn writeDataInCode(self: *MachO) !void {
		3920	const gpa = self.base.allocator;
		3921	var out_dice = std.ArrayList(macho.data_in_code_entry).init(gpa);
		3922	defer out_dice.deinit();
		3923
		3924	const text_sect_id = self.text_section_index orelse return;
		3925	const text_sect_header = self.sections.items(.header)[text_sect_id];
		3926
		3927	for (self.objects.items) \|object\| {
		3928	if (!object.hasDataInCode()) continue;
		3929	const dice = object.data_in_code.items;
		3930	try out_dice.ensureUnusedCapacity(dice.len);
		3931
		3932	for (object.exec_atoms.items) \|atom_index\| {
		3933	const atom = self.getAtom(atom_index);
		3934	const sym = self.getSymbol(atom.getSymbolWithLoc());
		3935	if (sym.n_desc == MachO.N_DEAD) continue;
		3936
		3937	const source_addr = if (object.getSourceSymbol(atom.sym_index)) \|source_sym\|
		3938	source_sym.n_value
		3939	else blk: {
		3940	const nbase = @as(u32, @intCast(object.in_symtab.?.len));
		3941	const source_sect_id = @as(u8, @intCast(atom.sym_index - nbase));
		3942	break :blk object.getSourceSection(source_sect_id).addr;
		3943	};
		3944	const filtered_dice = filterDataInCode(dice, source_addr, source_addr + atom.size);
		3945	const base = math.cast(u32, sym.n_value - text_sect_header.addr + text_sect_header.offset) orelse
		3946	return error.Overflow;
		3947
		3948	for (filtered_dice) \|single\| {
		3949	const offset = math.cast(u32, single.offset - source_addr + base) orelse
		3950	return error.Overflow;
		3951	out_dice.appendAssumeCapacity(.{
		3952	.offset = offset,
		3953	.length = single.length,
		3954	.kind = single.kind,
		3955	});
		3956	}
		3957	}
		3958	}
		3959
		3960	const seg = self.getLinkeditSegmentPtr();
		3961	const offset = seg.fileoff + seg.filesize;
		3962	assert(mem.isAlignedGeneric(u64, offset, @alignOf(u64)));
		3963	const needed_size = out_dice.items.len * @sizeOf(macho.data_in_code_entry);
		3964	const needed_size_aligned = mem.alignForward(u64, needed_size, @alignOf(u64));
		3965	seg.filesize = offset + needed_size_aligned - seg.fileoff;
		3966
		3967	const buffer = try gpa.alloc(u8, math.cast(usize, needed_size_aligned) orelse return error.Overflow);
		3968	defer gpa.free(buffer);
		3969	{
		3970	const src = mem.sliceAsBytes(out_dice.items);
		3971	@memcpy(buffer[0..src.len], src);
		3972	@memset(buffer[src.len..], 0);
		3973	}
		3974
		3975	log.debug("writing data-in-code from 0x{x} to 0x{x}", .{ offset, offset + needed_size_aligned });
		3976
		3977	try self.base.file.?.pwriteAll(buffer, offset);
		3978
		3979	self.data_in_code_cmd.dataoff = @as(u32, @intCast(offset));
		3980	self.data_in_code_cmd.datasize = @as(u32, @intCast(needed_size_aligned));
		3981	}
		3982
3400	fn writeSymtabs(self: *MachO) !void {	3983	fn writeSymtabs(self: *MachO) !void {
3401	var ctx = try self.writeSymtab();	3984	var ctx = try self.writeSymtab();
3402	defer ctx.imports_table.deinit();	3985	defer ctx.imports_table.deinit();
...	@@ -3404,18 +3987,38 @@ fn writeSymtabs(self: *MachO) !void {	...	@@ -3404,18 +3987,38 @@ fn writeSymtabs(self: *MachO) !void {
3404	try self.writeStrtab();	3987	try self.writeStrtab();
3405	}	3988	}
3406		3989
		3990	fn addLocalToSymtab(self: MachO, sym_loc: SymbolWithLoc, locals: std.ArrayList(macho.nlist_64)) !void {
		3991	const sym = self.getSymbol(sym_loc);
		3992	if (sym.n_strx == 0) return; // no name, skip
		3993	if (sym.n_desc == MachO.N_DEAD) return; // garbage-collected, skip
		3994	if (sym.ext()) return; // an export lands in its own symtab section, skip
		3995	if (self.symbolIsTemp(sym_loc)) return; // local temp symbol, skip
		3996	var out_sym = sym;
		3997	out_sym.n_strx = try self.strtab.insert(self.base.allocator, self.getSymbolName(sym_loc));
		3998	try locals.append(out_sym);
		3999	}
		4000
3407	fn writeSymtab(self: *MachO) !SymtabCtx {	4001	fn writeSymtab(self: *MachO) !SymtabCtx {
3408	const gpa = self.base.allocator;	4002	const gpa = self.base.allocator;
3409		4003
3410	var locals = std.ArrayList(macho.nlist_64).init(gpa);	4004	var locals = std.ArrayList(macho.nlist_64).init(gpa);
3411	defer locals.deinit();	4005	defer locals.deinit();
3412		4006
3413	for (self.locals.items, 0..) \|sym, sym_id\| {	4007	for (0..self.locals.items) \|sym_id\| {
3414	if (sym.n_strx == 0) continue; // no name, skip	4008	try self.addLocalToSymtab(.{ .sym_index = @intCast(sym_id) });
3415	const sym_loc = SymbolWithLoc{ .sym_index = @as(u32, @intCast(sym_id)) };	4009	}
3416	if (self.symbolIsTemp(sym_loc)) continue; // local temp symbol, skip	4010
3417	if (self.getGlobal(self.getSymbolName(sym_loc)) != null) continue; // global symbol is either an export or import, skip	4011	for (self.objects.items) \|object\| {
3418	try locals.append(sym);	4012	for (object.atoms.items) \|atom_index\| {
		4013	const atom = self.getAtom(atom_index);
		4014	const sym_loc = atom.getSymbolWithLoc();
		4015	try self.addLocalToSymtab(sym_loc, &locals);
		4016
		4017	var it = Atom.getInnerSymbolsIterator(self, atom_index);
		4018	while (it.next()) \|inner_sym_loc\| {
		4019	try self.addLocalToSymtab(inner_sym_loc, &locals);
		4020	}
		4021	}
3419	}	4022	}
3420		4023
3421	var exports = std.ArrayList(macho.nlist_64).init(gpa);	4024	var exports = std.ArrayList(macho.nlist_64).init(gpa);
...	@@ -3424,6 +4027,7 @@ fn writeSymtab(self: *MachO) !SymtabCtx {	...	@@ -3424,6 +4027,7 @@ fn writeSymtab(self: *MachO) !SymtabCtx {
3424	for (self.globals.items) \|global\| {	4027	for (self.globals.items) \|global\| {
3425	const sym = self.getSymbol(global);	4028	const sym = self.getSymbol(global);
3426	if (sym.undf()) continue; // import, skip	4029	if (sym.undf()) continue; // import, skip
		4030	if (sym.n_desc == N_DEAD) continue;
3427	var out_sym = sym;	4031	var out_sym = sym;
3428	out_sym.n_strx = try self.strtab.insert(gpa, self.getSymbolName(global));	4032	out_sym.n_strx = try self.strtab.insert(gpa, self.getSymbolName(global));
3429	try exports.append(out_sym);	4033	try exports.append(out_sym);
...	@@ -3438,6 +4042,7 @@ fn writeSymtab(self: *MachO) !SymtabCtx {	...	@@ -3438,6 +4042,7 @@ fn writeSymtab(self: *MachO) !SymtabCtx {
3438	const sym = self.getSymbol(global);	4042	const sym = self.getSymbol(global);
3439	if (sym.n_strx == 0) continue; // no name, skip	4043	if (sym.n_strx == 0) continue; // no name, skip
3440	if (!sym.undf()) continue; // not an import, skip	4044	if (!sym.undf()) continue; // not an import, skip
		4045	if (sym.n_desc == N_DEAD) continue;
3441	const new_index = @as(u32, @intCast(imports.items.len));	4046	const new_index = @as(u32, @intCast(imports.items.len));
3442	var out_sym = sym;	4047	var out_sym = sym;
3443	out_sym.n_strx = try self.strtab.insert(gpa, self.getSymbolName(global));	4048	out_sym.n_strx = try self.strtab.insert(gpa, self.getSymbolName(global));
...	@@ -3445,6 +4050,15 @@ fn writeSymtab(self: *MachO) !SymtabCtx {	...	@@ -3445,6 +4050,15 @@ fn writeSymtab(self: *MachO) !SymtabCtx {
3445	try imports_table.putNoClobber(global, new_index);	4050	try imports_table.putNoClobber(global, new_index);
3446	}	4051	}
3447		4052
		4053	// We generate stabs last in order to ensure that the strtab always has debug info
		4054	// strings trailing
		4055	if (!self.base.options.strip) {
		4056	assert(self.d_sym == null); // TODO
		4057	for (self.objects.items) \|object\| {
		4058	try self.generateSymbolStabs(object, &locals);
		4059	}
		4060	}
		4061
3448	const nlocals = @as(u32, @intCast(locals.items.len));	4062	const nlocals = @as(u32, @intCast(locals.items.len));
3449	const nexports = @as(u32, @intCast(exports.items.len));	4063	const nexports = @as(u32, @intCast(exports.items.len));
3450	const nimports = @as(u32, @intCast(imports.items.len));	4064	const nimports = @as(u32, @intCast(imports.items.len));
...	@@ -3478,7 +4092,218 @@ fn writeSymtab(self: *MachO) !SymtabCtx {	...	@@ -3478,7 +4092,218 @@ fn writeSymtab(self: *MachO) !SymtabCtx {
3478	};	4092	};
3479	}	4093	}
3480		4094
3481	fn writeStrtab(self: *MachO) !void {	4095	fn generateSymbolStabs(
		4096	self: *MachO,
		4097	object: Object,
		4098	locals: *std.ArrayList(macho.nlist_64),
		4099	) !void {
		4100	log.debug("generating stabs for '{s}'", .{object.name});
		4101
		4102	const gpa = self.base.allocator;
		4103	var debug_info = object.parseDwarfInfo();
		4104
		4105	var lookup = DwarfInfo.AbbrevLookupTable.init(gpa);
		4106	defer lookup.deinit();
		4107	try lookup.ensureUnusedCapacity(std.math.maxInt(u8));
		4108
		4109	// We assume there is only one CU.
		4110	var cu_it = debug_info.getCompileUnitIterator();
		4111	const compile_unit = while (try cu_it.next()) \|cu\| {
		4112	const offset = math.cast(usize, cu.cuh.debug_abbrev_offset) orelse return error.Overflow;
		4113	try debug_info.genAbbrevLookupByKind(offset, &lookup);
		4114	break cu;
		4115	} else {
		4116	log.debug("no compile unit found in debug info in {s}; skipping", .{object.name});
		4117	return;
		4118	};
		4119
		4120	var abbrev_it = compile_unit.getAbbrevEntryIterator(debug_info);
		4121	const cu_entry: DwarfInfo.AbbrevEntry = while (try abbrev_it.next(lookup)) \|entry\| switch (entry.tag) {
		4122	dwarf.TAG.compile_unit => break entry,
		4123	else => continue,
		4124	} else {
		4125	log.debug("missing DWARF_TAG_compile_unit tag in {s}; skipping", .{object.name});
		4126	return;
		4127	};
		4128
		4129	var maybe_tu_name: ?[]const u8 = null;
		4130	var maybe_tu_comp_dir: ?[]const u8 = null;
		4131	var attr_it = cu_entry.getAttributeIterator(debug_info, compile_unit.cuh);
		4132
		4133	while (try attr_it.next()) \|attr\| switch (attr.name) {
		4134	dwarf.AT.comp_dir => maybe_tu_comp_dir = attr.getString(debug_info, compile_unit.cuh) orelse continue,
		4135	dwarf.AT.name => maybe_tu_name = attr.getString(debug_info, compile_unit.cuh) orelse continue,
		4136	else => continue,
		4137	};
		4138
		4139	if (maybe_tu_name == null or maybe_tu_comp_dir == null) {
		4140	log.debug("missing DWARF_AT_comp_dir and DWARF_AT_name attributes {s}; skipping", .{object.name});
		4141	return;
		4142	}
		4143
		4144	const tu_name = maybe_tu_name.?;
		4145	const tu_comp_dir = maybe_tu_comp_dir.?;
		4146
		4147	// Open scope
		4148	try locals.ensureUnusedCapacity(3);
		4149	locals.appendAssumeCapacity(.{
		4150	.n_strx = try self.strtab.insert(gpa, tu_comp_dir),
		4151	.n_type = macho.N_SO,
		4152	.n_sect = 0,
		4153	.n_desc = 0,
		4154	.n_value = 0,
		4155	});
		4156	locals.appendAssumeCapacity(.{
		4157	.n_strx = try self.strtab.insert(gpa, tu_name),
		4158	.n_type = macho.N_SO,
		4159	.n_sect = 0,
		4160	.n_desc = 0,
		4161	.n_value = 0,
		4162	});
		4163	locals.appendAssumeCapacity(.{
		4164	.n_strx = try self.strtab.insert(gpa, object.name),
		4165	.n_type = macho.N_OSO,
		4166	.n_sect = 0,
		4167	.n_desc = 1,
		4168	.n_value = object.mtime,
		4169	});
		4170
		4171	var stabs_buf: [4]macho.nlist_64 = undefined;
		4172
		4173	var name_lookup: ?DwarfInfo.SubprogramLookupByName = if (object.header.flags & macho.MH_SUBSECTIONS_VIA_SYMBOLS == 0) blk: {
		4174	var name_lookup = DwarfInfo.SubprogramLookupByName.init(gpa);
		4175	errdefer name_lookup.deinit();
		4176	try name_lookup.ensureUnusedCapacity(@as(u32, @intCast(object.atoms.items.len)));
		4177	try debug_info.genSubprogramLookupByName(compile_unit, lookup, &name_lookup);
		4178	break :blk name_lookup;
		4179	} else null;
		4180	defer if (name_lookup) \|*nl\| nl.deinit();
		4181
		4182	for (object.atoms.items) \|atom_index\| {
		4183	const atom = self.getAtom(atom_index);
		4184	const stabs = try self.generateSymbolStabsForSymbol(
		4185	atom_index,
		4186	atom.getSymbolWithLoc(),
		4187	name_lookup,
		4188	&stabs_buf,
		4189	);
		4190	try locals.appendSlice(stabs);
		4191
		4192	var it = Atom.getInnerSymbolsIterator(self, atom_index);
		4193	while (it.next()) \|sym_loc\| {
		4194	const contained_stabs = try self.generateSymbolStabsForSymbol(
		4195	atom_index,
		4196	sym_loc,
		4197	name_lookup,
		4198	&stabs_buf,
		4199	);
		4200	try locals.appendSlice(contained_stabs);
		4201	}
		4202	}
		4203
		4204	// Close scope
		4205	try locals.append(.{
		4206	.n_strx = 0,
		4207	.n_type = macho.N_SO,
		4208	.n_sect = 0,
		4209	.n_desc = 0,
		4210	.n_value = 0,
		4211	});
		4212	}
		4213
		4214	fn generateSymbolStabsForSymbol(
		4215	self: *MachO,
		4216	atom_index: Atom.Index,
		4217	sym_loc: SymbolWithLoc,
		4218	lookup: ?DwarfInfo.SubprogramLookupByName,
		4219	buf: *[4]macho.nlist_64,
		4220	) ![]const macho.nlist_64 {
		4221	const gpa = self.base.allocator;
		4222	const object = self.objects.items[sym_loc.getFile().?];
		4223	const sym = self.getSymbol(sym_loc);
		4224	const sym_name = self.getSymbolName(sym_loc);
		4225	const header = self.sections.items(.header)[sym.n_sect - 1];
		4226
		4227	if (sym.n_strx == 0) return buf[0..0];
		4228	if (self.symbolIsTemp(sym_loc)) return buf[0..0];
		4229
		4230	if (!header.isCode()) {
		4231	// Since we are not dealing with machine code, it's either a global or a static depending
		4232	// on the linkage scope.
		4233	if (sym.sect() and sym.ext()) {
		4234	// Global gets an N_GSYM stab type.
		4235	buf[0] = .{
		4236	.n_strx = try self.strtab.insert(gpa, sym_name),
		4237	.n_type = macho.N_GSYM,
		4238	.n_sect = sym.n_sect,
		4239	.n_desc = 0,
		4240	.n_value = 0,
		4241	};
		4242	} else {
		4243	// Local static gets an N_STSYM stab type.
		4244	buf[0] = .{
		4245	.n_strx = try self.strtab.insert(gpa, sym_name),
		4246	.n_type = macho.N_STSYM,
		4247	.n_sect = sym.n_sect,
		4248	.n_desc = 0,
		4249	.n_value = sym.n_value,
		4250	};
		4251	}
		4252	return buf[0..1];
		4253	}
		4254
		4255	const size: u64 = size: {
		4256	if (object.header.flags & macho.MH_SUBSECTIONS_VIA_SYMBOLS != 0) {
		4257	break :size self.getAtom(atom_index).size;
		4258	}
		4259
		4260	// Since we don't have subsections to work with, we need to infer the size of each function
		4261	// the slow way by scanning the debug info for matching symbol names and extracting
		4262	// the symbol's DWARF_AT_low_pc and DWARF_AT_high_pc values.
		4263	const source_sym = object.getSourceSymbol(sym_loc.sym_index) orelse return buf[0..0];
		4264	const subprogram = lookup.?.get(sym_name[1..]) orelse return buf[0..0];
		4265
		4266	if (subprogram.addr <= source_sym.n_value and source_sym.n_value < subprogram.addr + subprogram.size) {
		4267	break :size subprogram.size;
		4268	} else {
		4269	log.debug("no stab found for {s}", .{sym_name});
		4270	return buf[0..0];
		4271	}
		4272	};
		4273
		4274	buf[0] = .{
		4275	.n_strx = 0,
		4276	.n_type = macho.N_BNSYM,
		4277	.n_sect = sym.n_sect,
		4278	.n_desc = 0,
		4279	.n_value = sym.n_value,
		4280	};
		4281	buf[1] = .{
		4282	.n_strx = try self.strtab.insert(gpa, sym_name),
		4283	.n_type = macho.N_FUN,
		4284	.n_sect = sym.n_sect,
		4285	.n_desc = 0,
		4286	.n_value = sym.n_value,
		4287	};
		4288	buf[2] = .{
		4289	.n_strx = 0,
		4290	.n_type = macho.N_FUN,
		4291	.n_sect = 0,
		4292	.n_desc = 0,
		4293	.n_value = size,
		4294	};
		4295	buf[3] = .{
		4296	.n_strx = 0,
		4297	.n_type = macho.N_ENSYM,
		4298	.n_sect = sym.n_sect,
		4299	.n_desc = 0,
		4300	.n_value = size,
		4301	};
		4302
		4303	return buf;
		4304	}
		4305
		4306	pub fn writeStrtab(self: *MachO) !void {
3482	const gpa = self.base.allocator;	4307	const gpa = self.base.allocator;
3483	const seg = self.getLinkeditSegmentPtr();	4308	const seg = self.getLinkeditSegmentPtr();
3484	const offset = seg.fileoff + seg.filesize;	4309	const offset = seg.fileoff + seg.filesize;
...	@@ -3507,7 +4332,7 @@ const SymtabCtx = struct {	...	@@ -3507,7 +4332,7 @@ const SymtabCtx = struct {
3507	imports_table: std.AutoHashMap(SymbolWithLoc, u32),	4332	imports_table: std.AutoHashMap(SymbolWithLoc, u32),
3508	};	4333	};
3509		4334
3510	fn writeDysymtab(self: *MachO, ctx: SymtabCtx) !void {	4335	pub fn writeDysymtab(self: *MachO, ctx: SymtabCtx) !void {
3511	const gpa = self.base.allocator;	4336	const gpa = self.base.allocator;
3512	const nstubs = @as(u32, @intCast(self.stub_table.lookup.count()));	4337	const nstubs = @as(u32, @intCast(self.stub_table.lookup.count()));
3513	const ngot_entries = @as(u32, @intCast(self.got_table.lookup.count()));	4338	const ngot_entries = @as(u32, @intCast(self.got_table.lookup.count()));
...	@@ -3582,7 +4407,7 @@ fn writeDysymtab(self: *MachO, ctx: SymtabCtx) !void {	...	@@ -3582,7 +4407,7 @@ fn writeDysymtab(self: *MachO, ctx: SymtabCtx) !void {
3582	self.dysymtab_cmd.nindirectsyms = nindirectsyms;	4407	self.dysymtab_cmd.nindirectsyms = nindirectsyms;
3583	}	4408	}
3584		4409
3585	fn writeUuid(self: MachO, comp: const Compilation, uuid_cmd_offset: u32, has_codesig: bool) !void {	4410	pub fn writeUuid(self: MachO, comp: const Compilation, uuid_cmd_offset: u32, has_codesig: bool) !void {
3586	const file_size = if (!has_codesig) blk: {	4411	const file_size = if (!has_codesig) blk: {
3587	const seg = self.getLinkeditSegmentPtr();	4412	const seg = self.getLinkeditSegmentPtr();
3588	break :blk seg.fileoff + seg.filesize;	4413	break :blk seg.fileoff + seg.filesize;
...	@@ -3592,7 +4417,7 @@ fn writeUuid(self: MachO, comp: const Compilation, uuid_cmd_offset: u32, has_c	...	@@ -3592,7 +4417,7 @@ fn writeUuid(self: MachO, comp: const Compilation, uuid_cmd_offset: u32, has_c
3592	try self.base.file.?.pwriteAll(&self.uuid_cmd.uuid, offset);	4417	try self.base.file.?.pwriteAll(&self.uuid_cmd.uuid, offset);
3593	}	4418	}
3594		4419
3595	fn writeCodeSignaturePadding(self: MachO, code_sig: CodeSignature) !void {	4420	pub fn writeCodeSignaturePadding(self: MachO, code_sig: CodeSignature) !void {
3596	const seg = self.getLinkeditSegmentPtr();	4421	const seg = self.getLinkeditSegmentPtr();
3597	// Code signature data has to be 16-bytes aligned for Apple tools to recognize the file	4422	// Code signature data has to be 16-bytes aligned for Apple tools to recognize the file
3598	// https://github.com/opensource-apple/cctools/blob/fdb4825f303fd5c0751be524babd32958181b3ed/libstuff/checkout.c#L271	4423	// https://github.com/opensource-apple/cctools/blob/fdb4825f303fd5c0751be524babd32958181b3ed/libstuff/checkout.c#L271
...	@@ -3609,8 +4434,9 @@ fn writeCodeSignaturePadding(self: MachO, code_sig: CodeSignature) !void {	...	@@ -3609,8 +4434,9 @@ fn writeCodeSignaturePadding(self: MachO, code_sig: CodeSignature) !void {
3609	self.codesig_cmd.datasize = @as(u32, @intCast(needed_size));	4434	self.codesig_cmd.datasize = @as(u32, @intCast(needed_size));
3610	}	4435	}
3611		4436
3612	fn writeCodeSignature(self: MachO, comp: const Compilation, code_sig: *CodeSignature) !void {	4437	pub fn writeCodeSignature(self: MachO, comp: const Compilation, code_sig: *CodeSignature) !void {
3613	const seg = self.getSegment(self.text_section_index.?);	4438	const seg_id = self.header_segment_cmd_index.?;
		4439	const seg = self.segments.items[seg_id];
3614	const offset = self.codesig_cmd.dataoff;	4440	const offset = self.codesig_cmd.dataoff;
3615		4441
3616	var buffer = std.ArrayList(u8).init(self.base.allocator);	4442	var buffer = std.ArrayList(u8).init(self.base.allocator);
...	@@ -3634,14 +4460,10 @@ fn writeCodeSignature(self: MachO, comp: const Compilation, code_sig: *CodeSig	...	@@ -3634,14 +4460,10 @@ fn writeCodeSignature(self: MachO, comp: const Compilation, code_sig: *CodeSig
3634	}	4460	}
3635		4461
3636	/// Writes Mach-O file header.	4462	/// Writes Mach-O file header.
3637	fn writeHeader(self: *MachO, ncmds: u32, sizeofcmds: u32) !void {	4463	pub fn writeHeader(self: *MachO, ncmds: u32, sizeofcmds: u32) !void {
3638	var header: macho.mach_header_64 = .{};	4464	var header: macho.mach_header_64 = .{};
3639	header.flags = macho.MH_NOUNDEFS \| macho.MH_DYLDLINK \| macho.MH_PIE \| macho.MH_TWOLEVEL;	4465	header.flags = macho.MH_NOUNDEFS \| macho.MH_DYLDLINK \| macho.MH_PIE \| macho.MH_TWOLEVEL;
3640		4466
3641	if (!self.base.options.single_threaded) {
3642	header.flags \|= macho.MH_HAS_TLV_DESCRIPTORS;
3643	}
3644
3645	switch (self.base.options.target.cpu.arch) {	4467	switch (self.base.options.target.cpu.arch) {
3646	.aarch64 => {	4468	.aarch64 => {
3647	header.cputype = macho.CPU_TYPE_ARM64;	4469	header.cputype = macho.CPU_TYPE_ARM64;
...	@@ -3666,6 +4488,13 @@ fn writeHeader(self: *MachO, ncmds: u32, sizeofcmds: u32) !void {	...	@@ -3666,6 +4488,13 @@ fn writeHeader(self: *MachO, ncmds: u32, sizeofcmds: u32) !void {
3666	else => unreachable,	4488	else => unreachable,
3667	}	4489	}
3668		4490
		4491	if (self.thread_vars_section_index) \|sect_id\| {
		4492	header.flags \|= macho.MH_HAS_TLV_DESCRIPTORS;
		4493	if (self.sections.items(.header)[sect_id].size > 0) {
		4494	header.flags \|= macho.MH_HAS_TLV_DESCRIPTORS;
		4495	}
		4496	}
		4497
3669	header.ncmds = ncmds;	4498	header.ncmds = ncmds;
3670	header.sizeofcmds = sizeofcmds;	4499	header.sizeofcmds = sizeofcmds;
3671		4500
...	@@ -3830,20 +4659,33 @@ pub fn symbolIsTemp(self: *MachO, sym_with_loc: SymbolWithLoc) bool {	...	@@ -3830,20 +4659,33 @@ pub fn symbolIsTemp(self: *MachO, sym_with_loc: SymbolWithLoc) bool {
3830		4659
3831	/// Returns pointer-to-symbol described by `sym_with_loc` descriptor.	4660	/// Returns pointer-to-symbol described by `sym_with_loc` descriptor.
3832	pub fn getSymbolPtr(self: MachO, sym_with_loc: SymbolWithLoc) macho.nlist_64 {	4661	pub fn getSymbolPtr(self: MachO, sym_with_loc: SymbolWithLoc) macho.nlist_64 {
3833	assert(sym_with_loc.getFile() == null);	4662	if (sym_with_loc.getFile()) \|file\| {
3834	return &self.locals.items[sym_with_loc.sym_index];	4663	const object = &self.objects.items[file];
		4664	return &object.symtab[sym_with_loc.sym_index];
		4665	} else {
		4666	return &self.locals.items[sym_with_loc.sym_index];
		4667	}
3835	}	4668	}
3836		4669
3837	/// Returns symbol described by `sym_with_loc` descriptor.	4670	/// Returns symbol described by `sym_with_loc` descriptor.
3838	pub fn getSymbol(self: *const MachO, sym_with_loc: SymbolWithLoc) macho.nlist_64 {	4671	pub fn getSymbol(self: *const MachO, sym_with_loc: SymbolWithLoc) macho.nlist_64 {
3839	assert(sym_with_loc.getFile() == null);	4672	if (sym_with_loc.getFile()) \|file\| {
3840	return self.locals.items[sym_with_loc.sym_index];	4673	const object = &self.objects.items[file];
		4674	return object.symtab[sym_with_loc.sym_index];
		4675	} else {
		4676	return self.locals.items[sym_with_loc.sym_index];
		4677	}
3841	}	4678	}
3842		4679
3843	/// Returns name of the symbol described by `sym_with_loc` descriptor.	4680	/// Returns name of the symbol described by `sym_with_loc` descriptor.
3844	pub fn getSymbolName(self: *const MachO, sym_with_loc: SymbolWithLoc) []const u8 {	4681	pub fn getSymbolName(self: *const MachO, sym_with_loc: SymbolWithLoc) []const u8 {
3845	const sym = self.getSymbol(sym_with_loc);	4682	if (sym_with_loc.getFile()) \|file\| {
3846	return self.strtab.get(sym.n_strx).?;	4683	const object = self.objects.items[file];
		4684	return object.getSymbolName(sym_with_loc.sym_index);
		4685	} else {
		4686	const sym = self.locals.items[sym_with_loc.sym_index];
		4687	return self.strtab.get(sym.n_strx).?;
		4688	}
3847	}	4689	}
3848		4690
3849	/// Returns pointer to the global entry for `name` if one exists.	4691	/// Returns pointer to the global entry for `name` if one exists.
...	@@ -3945,6 +4787,19 @@ pub inline fn getPageSize(cpu_arch: std.Target.Cpu.Arch) u16 {	...	@@ -3945,6 +4787,19 @@ pub inline fn getPageSize(cpu_arch: std.Target.Cpu.Arch) u16 {
3945	};	4787	};
3946	}	4788	}
3947		4789
		4790	pub inline fn requiresThunks(self: MachO) bool {
		4791	return self.base.options.target.cpu.arch == .aarch64;
		4792	}
		4793
		4794	pub fn requiresCodeSignature(self: MachO) bool {
		4795	if (self.base.options.entitlements) \|_\| return true;
		4796	const cpu_arch = self.base.options.target.cpu.arch;
		4797	const os_tag = self.base.options.target.os.tag;
		4798	const abi = self.base.options.target.abi;
		4799	if (cpu_arch == .aarch64 and (os_tag == .macos or abi == .simulator)) return true;
		4800	return false;
		4801	}
		4802
3948	pub fn getSegmentPrecedence(segname: []const u8) u4 {	4803	pub fn getSegmentPrecedence(segname: []const u8) u4 {
3949	if (mem.eql(u8, segname, "__PAGEZERO")) return 0x0;	4804	if (mem.eql(u8, segname, "__PAGEZERO")) return 0x0;
3950	if (mem.eql(u8, segname, "__TEXT")) return 0x1;	4805	if (mem.eql(u8, segname, "__TEXT")) return 0x1;
...	@@ -3988,24 +4843,26 @@ pub fn getSectionPrecedence(header: macho.section_64) u8 {	...	@@ -3988,24 +4843,26 @@ pub fn getSectionPrecedence(header: macho.section_64) u8 {
3988	return (@as(u8, @intCast(segment_precedence)) << 4) + section_precedence;	4843	return (@as(u8, @intCast(segment_precedence)) << 4) + section_precedence;
3989	}	4844	}
3990		4845
3991	pub fn reportUndefined(self: *MachO, ctx: anytype) !void {	4846	pub fn reportUndefined(self: *MachO) !void {
3992	const count = ctx.unresolved.count();	4847	const count = self.unresolved.count();
3993	if (count == 0) return;	4848	if (count == 0) return;
3994		4849
3995	const gpa = self.base.allocator;	4850	const gpa = self.base.allocator;
3996		4851
3997	try self.misc_errors.ensureUnusedCapacity(gpa, count);	4852	try self.misc_errors.ensureUnusedCapacity(gpa, count);
3998		4853
3999	for (ctx.unresolved.keys()) \|global_index\| {	4854	for (self.unresolved.keys()) \|global_index\| {
4000	const global = ctx.globals.items[global_index];	4855	const global = self.globals.items[global_index];
4001	const sym_name = ctx.getSymbolName(global);	4856	const sym_name = self.getSymbolName(global);
4002		4857
4003	const nnotes: usize = if (global.getFile() == null) @as(usize, 0) else 1;	4858	const nnotes: usize = if (global.getFile() == null) @as(usize, 0) else 1;
4004	var notes = try std.ArrayList(File.ErrorMsg).initCapacity(gpa, nnotes);	4859	var notes = try std.ArrayList(File.ErrorMsg).initCapacity(gpa, nnotes);
4005	defer notes.deinit();	4860	defer notes.deinit();
4006		4861
4007	if (global.getFile()) \|file\| {	4862	if (global.getFile()) \|file\| {
4008	const note = try std.fmt.allocPrint(gpa, "referenced in {s}", .{ctx.objects.items[file].name});	4863	const note = try std.fmt.allocPrint(gpa, "referenced in {s}", .{
		4864	self.objects.items[file].name,
		4865	});
4009	notes.appendAssumeCapacity(.{ .msg = note });	4866	notes.appendAssumeCapacity(.{ .msg = note });
4010	}	4867	}
4011		4868
...	@@ -4051,6 +4908,19 @@ pub fn lsearch(comptime T: type, haystack: []align(1) const T, predicate: anytyp	...	@@ -4051,6 +4908,19 @@ pub fn lsearch(comptime T: type, haystack: []align(1) const T, predicate: anytyp
4051	return i;	4908	return i;
4052	}	4909	}
4053		4910
		4911	pub fn logSegments(self: *MachO) void {
		4912	log.debug("segments:", .{});
		4913	for (self.segments.items, 0..) \|segment, i\| {
		4914	log.debug(" segment({d}): {s} @{x} ({x}), sizeof({x})", .{
		4915	i,
		4916	segment.segName(),
		4917	segment.fileoff,
		4918	segment.vmaddr,
		4919	segment.vmsize,
		4920	});
		4921	}
		4922	}
		4923
4054	pub fn logSections(self: *MachO) void {	4924	pub fn logSections(self: *MachO) void {
4055	log.debug("sections:", .{});	4925	log.debug("sections:", .{});
4056	for (self.sections.items(.header), 0..) \|header, i\| {	4926	for (self.sections.items(.header), 0..) \|header, i\| {
...	@@ -4065,9 +4935,7 @@ pub fn logSections(self: *MachO) void {	...	@@ -4065,9 +4935,7 @@ pub fn logSections(self: *MachO) void {
4065	}	4935	}
4066	}	4936	}
4067		4937
4068	fn logSymAttributes(sym: macho.nlist_64, buf: *[4]u8) []const u8 {	4938	fn logSymAttributes(sym: macho.nlist_64, buf: []u8) []const u8 {
4069	@memset(buf[0..4], '_');
4070	@memset(buf[4..], ' ');
4071	if (sym.sect()) {	4939	if (sym.sect()) {
4072	buf[0] = 's';	4940	buf[0] = 's';
4073	}	4941	}
...	@@ -4090,56 +4958,110 @@ fn logSymAttributes(sym: macho.nlist_64, buf: *[4]u8) []const u8 {	...	@@ -4090,56 +4958,110 @@ fn logSymAttributes(sym: macho.nlist_64, buf: *[4]u8) []const u8 {
4090	pub fn logSymtab(self: *MachO) void {	4958	pub fn logSymtab(self: *MachO) void {
4091	var buf: [4]u8 = undefined;	4959	var buf: [4]u8 = undefined;
4092		4960
4093	log.debug("symtab:", .{});	4961	const scoped_log = std.log.scoped(.symtab);
		4962
		4963	scoped_log.debug("locals:", .{});
		4964	for (self.objects.items, 0..) \|object, id\| {
		4965	scoped_log.debug(" object({d}): {s}", .{ id, object.name });
		4966	if (object.in_symtab == null) continue;
		4967	for (object.symtab, 0..) \|sym, sym_id\| {
		4968	@memset(&buf, '_');
		4969	scoped_log.debug(" %{d}: {s} @{x} in sect({d}), {s}", .{
		4970	sym_id,
		4971	object.getSymbolName(@as(u32, @intCast(sym_id))),
		4972	sym.n_value,
		4973	sym.n_sect,
		4974	logSymAttributes(sym, &buf),
		4975	});
		4976	}
		4977	}
		4978	scoped_log.debug(" object(-1)", .{});
4094	for (self.locals.items, 0..) \|sym, sym_id\| {	4979	for (self.locals.items, 0..) \|sym, sym_id\| {
4095	const where = if (sym.undf() and !sym.tentative()) "ord" else "sect";	4980	if (sym.undf()) continue;
4096	const def_index = if (sym.undf() and !sym.tentative())	4981	scoped_log.debug(" %{d}: {s} @{x} in sect({d}), {s}", .{
4097	@divTrunc(sym.n_desc, macho.N_SYMBOL_RESOLVER)
4098	else
4099	sym.n_sect + 1;
4100	log.debug(" %{d}: {?s} @{x} in {s}({d}), {s}", .{
4101	sym_id,	4982	sym_id,
4102	self.strtab.get(sym.n_strx),	4983	self.strtab.get(sym.n_strx).?,
4103	sym.n_value,	4984	sym.n_value,
4104	where,	4985	sym.n_sect,
4105	def_index,
4106	logSymAttributes(sym, &buf),	4986	logSymAttributes(sym, &buf),
4107	});	4987	});
4108	}	4988	}
4109		4989
4110	log.debug("globals table:", .{});	4990	scoped_log.debug("exports:", .{});
4111	for (self.globals.items) \|global\| {	4991	for (self.globals.items, 0..) \|global, i\| {
4112	const name = self.getSymbolName(global);	4992	const sym = self.getSymbol(global);
4113	log.debug(" {s} => %{d} in object({?d})", .{ name, global.sym_index, global.file });	4993	if (sym.undf()) continue;
		4994	if (sym.n_desc == MachO.N_DEAD) continue;
		4995	scoped_log.debug(" %{d}: {s} @{x} in sect({d}), {s} (def in object({?}))", .{
		4996	i,
		4997	self.getSymbolName(global),
		4998	sym.n_value,
		4999	sym.n_sect,
		5000	logSymAttributes(sym, &buf),
		5001	global.file,
		5002	});
		5003	}
		5004
		5005	scoped_log.debug("imports:", .{});
		5006	for (self.globals.items, 0..) \|global, i\| {
		5007	const sym = self.getSymbol(global);
		5008	if (!sym.undf()) continue;
		5009	if (sym.n_desc == MachO.N_DEAD) continue;
		5010	const ord = @divTrunc(sym.n_desc, macho.N_SYMBOL_RESOLVER);
		5011	scoped_log.debug(" %{d}: {s} @{x} in ord({d}), {s}", .{
		5012	i,
		5013	self.getSymbolName(global),
		5014	sym.n_value,
		5015	ord,
		5016	logSymAttributes(sym, &buf),
		5017	});
4114	}	5018	}
4115		5019
4116	log.debug("GOT entries:", .{});	5020	scoped_log.debug("GOT entries:", .{});
4117	log.debug("{}", .{self.got_table});	5021	scoped_log.debug("{}", .{self.got_table});
		5022
		5023	scoped_log.debug("TLV pointers:", .{});
		5024	scoped_log.debug("{}", .{self.tlv_ptr_table});
4118		5025
4119	log.debug("stubs entries:", .{});	5026	scoped_log.debug("stubs entries:", .{});
4120	log.debug("{}", .{self.stub_table});	5027	scoped_log.debug("{}", .{self.stubs_table});
		5028
		5029	scoped_log.debug("thunks:", .{});
		5030	for (self.thunks.items, 0..) \|thunk, i\| {
		5031	scoped_log.debug(" thunk({d})", .{i});
		5032	const slice = thunk.targets.slice();
		5033	for (slice.items(.tag), slice.items(.target), 0..) \|tag, target, j\| {
		5034	const atom_index = @as(u32, @intCast(thunk.getStartAtomIndex() + j));
		5035	const atom = self.getAtom(atom_index);
		5036	const atom_sym = self.getSymbol(atom.getSymbolWithLoc());
		5037	const target_addr = switch (tag) {
		5038	.stub => self.getStubsEntryAddress(target).?,
		5039	.atom => self.getSymbol(target).n_value,
		5040	};
		5041	scoped_log.debug(" {d}@{x} => {s}({s}@{x})", .{
		5042	j,
		5043	atom_sym.n_value,
		5044	@tagName(tag),
		5045	self.getSymbolName(target),
		5046	target_addr,
		5047	});
		5048	}
		5049	}
4121	}	5050	}
4122		5051
4123	pub fn logAtoms(self: *MachO) void {	5052	pub fn logAtoms(self: *MachO) void {
4124	log.debug("atoms:", .{});	5053	log.debug("atoms:", .{});
4125
4126	const slice = self.sections.slice();	5054	const slice = self.sections.slice();
4127	for (slice.items(.last_atom_index), 0..) \|last_atom_index, i\| {	5055	for (slice.items(.first_atom_index), 0..) \|first_atom_index, sect_id\| {
4128	var atom_index = last_atom_index orelse continue;	5056	var atom_index = first_atom_index orelse continue;
4129	const header = slice.items(.header)[i];	5057	const header = slice.items(.header)[sect_id];
4130
4131	while (true) {
4132	const atom = self.getAtom(atom_index);
4133	if (atom.prev_index) \|prev_index\| {
4134	atom_index = prev_index;
4135	} else break;
4136	}
4137		5058
4138	log.debug("{s},{s}", .{ header.segName(), header.sectName() });	5059	log.debug("{s},{s}", .{ header.segName(), header.sectName() });
4139		5060
4140	while (true) {	5061	while (true) {
4141	self.logAtom(atom_index);
4142	const atom = self.getAtom(atom_index);	5062	const atom = self.getAtom(atom_index);
		5063	self.logAtom(atom_index, log);
		5064
4143	if (atom.next_index) \|next_index\| {	5065	if (atom.next_index) \|next_index\| {
4144	atom_index = next_index;	5066	atom_index = next_index;
4145	} else break;	5067	} else break;
...	@@ -4147,18 +5069,50 @@ pub fn logAtoms(self: *MachO) void {	...	@@ -4147,18 +5069,50 @@ pub fn logAtoms(self: *MachO) void {
4147	}	5069	}
4148	}	5070	}
4149		5071
4150	pub fn logAtom(self: *MachO, atom_index: Atom.Index) void {	5072	pub fn logAtom(self: *MachO, atom_index: Atom.Index, logger: anytype) void {
		5073	if (!build_options.enable_logging) return;
		5074
4151	const atom = self.getAtom(atom_index);	5075	const atom = self.getAtom(atom_index);
4152	const sym = atom.getSymbol(self);	5076	const sym = self.getSymbol(atom.getSymbolWithLoc());
4153	const sym_name = atom.getName(self);	5077	const sym_name = self.getSymbolName(atom.getSymbolWithLoc());
4154	log.debug(" ATOM(%{?d}, '{s}') @ {x} sizeof({x}) in object({?d}) in sect({d})", .{	5078	logger.debug(" ATOM({d}, %{d}, '{s}') @ {x} (sizeof({x}), alignof({x})) in object({?}) in sect({d})", .{
4155	atom.getSymbolIndex(),	5079	atom_index,
		5080	atom.sym_index,
4156	sym_name,	5081	sym_name,
4157	sym.n_value,	5082	sym.n_value,
4158	atom.size,	5083	atom.size,
4159	atom.file,	5084	atom.alignment,
4160	sym.n_sect + 1,	5085	atom.getFile(),
		5086	sym.n_sect,
4161	});	5087	});
		5088
		5089	if (atom.getFile() != null) {
		5090	var it = Atom.getInnerSymbolsIterator(self, atom_index);
		5091	while (it.next()) \|sym_loc\| {
		5092	const inner = self.getSymbol(sym_loc);
		5093	const inner_name = self.getSymbolName(sym_loc);
		5094	const offset = Atom.calcInnerSymbolOffset(self, atom_index, sym_loc.sym_index);
		5095
		5096	logger.debug(" (%{d}, '{s}') @ {x} ({x})", .{
		5097	sym_loc.sym_index,
		5098	inner_name,
		5099	inner.n_value,
		5100	offset,
		5101	});
		5102	}
		5103
		5104	if (Atom.getSectionAlias(self, atom_index)) \|sym_loc\| {
		5105	const alias = self.getSymbol(sym_loc);
		5106	const alias_name = self.getSymbolName(sym_loc);
		5107
		5108	logger.debug(" (%{d}, '{s}') @ {x} ({x})", .{
		5109	sym_loc.sym_index,
		5110	alias_name,
		5111	alias.n_value,
		5112	0,
		5113	});
		5114	}
		5115	}
4162	}	5116	}
4163		5117
4164	const MachO = @This();	5118	const MachO = @This();
...	@@ -4197,6 +5151,7 @@ const Cache = std.Build.Cache;	...	@@ -4197,6 +5151,7 @@ const Cache = std.Build.Cache;
4197	const CodeSignature = @import("MachO/CodeSignature.zig");	5151	const CodeSignature = @import("MachO/CodeSignature.zig");
4198	const Compilation = @import("../Compilation.zig");	5152	const Compilation = @import("../Compilation.zig");
4199	const Dwarf = File.Dwarf;	5153	const Dwarf = File.Dwarf;
		5154	const DwarfInfo = @import("DwarfInfo.zig");
4200	const Dylib = @import("MachO/Dylib.zig");	5155	const Dylib = @import("MachO/Dylib.zig");
4201	const File = link.File;	5156	const File = link.File;
4202	const Object = @import("MachO/Object.zig");	5157	const Object = @import("MachO/Object.zig");

src/link/MachO/Archive.zig+12-12

 @@ -1,15 +1,3 @@
-const Archive = @This();
-const std = @import("std");
-const assert = std.debug.assert;
-const fs = std.fs;
-const log = std.log.scoped(.link);
-const macho = std.macho;
-const mem = std.mem;
-const Allocator = mem.Allocator;
-const Object = @import("Object.zig");
 file: fs.File,
 fat_offset: u64,
 name: []const u8,
 @@ -215,3 +203,15 @@ pub fn parseObject(self: Archive, gpa: Allocator, offset: u32) !Object {
     return object;
 }
+const Archive = @This();
+const std = @import("std");
+const assert = std.debug.assert;
+const fs = std.fs;
+const log = std.log.scoped(.link);
+const macho = std.macho;
+const mem = std.mem;
+const Allocator = mem.Allocator;
+const Object = @import("Object.zig");

src/link/MachO/Atom.zig+174-220

 @@ -105,8 +105,7 @@ pub fn freeListEligible(self: Atom, macho_file: *MachO) bool {
     return surplus >= MachO.min_text_capacity;
 }
-pub fn getOutputSection(zld: *Zld, sect: macho.section_64) !?u8 {
+pub fn getOutputSection(macho_file: *MachO, sect: macho.section_64) !?u8 {
-    const gpa = zld.gpa;
     const segname = sect.segName();
     const sectname = sect.sectName();
     const res: ?u8 = blk: {
 @@ -126,20 +125,14 @@ pub fn getOutputSection(zld: *Zld, sect: macho.section_64) !?u8 {
         }
         if (sect.isCode()) {
-            if (zld.text_section_index == null) {
+            if (macho_file.text_section_index == null) {
-                zld.text_section_index = try MachO.initSection(
+                macho_file.text_section_index = try macho_file.initSection("__TEXT", "__text", .{
-                    gpa,
+                    .flags = macho.S_REGULAR |
-                    zld,
+                        macho.S_ATTR_PURE_INSTRUCTIONS |
-                    "__TEXT",
+                        macho.S_ATTR_SOME_INSTRUCTIONS,
-                    "__text",
+                });
-                    .{
-                        .flags = macho.S_REGULAR |
-                            macho.S_ATTR_PURE_INSTRUCTIONS |
-                            macho.S_ATTR_SOME_INSTRUCTIONS,
-                    },
-                );
             }
-            break :blk zld.text_section_index.?;
+            break :blk macho_file.text_section_index.?;
         }
         if (sect.isDebug()) {
 @@ -151,42 +144,26 @@ pub fn getOutputSection(zld: *Zld, sect: macho.section_64) !?u8 {
             macho.S_8BYTE_LITERALS,
             macho.S_16BYTE_LITERALS,
             => {
-                break :blk zld.getSectionByName("__TEXT", "__const") orelse try MachO.initSection(
+                break :blk macho_file.getSectionByName("__TEXT", "__const") orelse
-                    gpa,
+                    try macho_file.initSection("__TEXT", "__const", .{});
-                    zld,
-                    "__TEXT",
-                    "__const",
-                    .{},
-                );
             },
             macho.S_CSTRING_LITERALS => {
                 if (mem.startsWith(u8, sectname, "__objc")) {
-                    break :blk zld.getSectionByName(segname, sectname) orelse try MachO.initSection(
+                    break :blk macho_file.getSectionByName(segname, sectname) orelse
-                        gpa,
+                        try macho_file.initSection(segname, sectname, .{});
-                        zld,
-                        segname,
-                        sectname,
-                        .{},
-                    );
                 }
-                break :blk zld.getSectionByName("__TEXT", "__cstring") orelse try MachO.initSection(
+                break :blk macho_file.getSectionByName("__TEXT", "__cstring") orelse
-                    gpa,
+                    try macho_file.initSection("__TEXT", "__cstring", .{
-                    zld,
+                    .flags = macho.S_CSTRING_LITERALS,
-                    "__TEXT",
+                });
-                    "__cstring",
-                    .{ .flags = macho.S_CSTRING_LITERALS },
-                );
             },
             macho.S_MOD_INIT_FUNC_POINTERS,
             macho.S_MOD_TERM_FUNC_POINTERS,
             => {
-                break :blk zld.getSectionByName("__DATA_CONST", sectname) orelse try MachO.initSection(
+                break :blk macho_file.getSectionByName("__DATA_CONST", sectname) orelse
-                    gpa,
+                    try macho_file.initSection("__DATA_CONST", sectname, .{
-                    zld,
+                    .flags = sect.flags,
-                    "__DATA_CONST",
+                });
-                    sectname,
-                    .{ .flags = sect.flags },
-                );
             },
             macho.S_LITERAL_POINTERS,
             macho.S_ZEROFILL,
 @@ -195,23 +172,14 @@ pub fn getOutputSection(zld: *Zld, sect: macho.section_64) !?u8 {
             macho.S_THREAD_LOCAL_REGULAR,
             macho.S_THREAD_LOCAL_ZEROFILL,
             => {
-                break :blk zld.getSectionByName(segname, sectname) orelse try MachO.initSection(
+                break :blk macho_file.getSectionByName(segname, sectname) orelse
-                    gpa,
+                    try macho_file.initSection(segname, sectname, .{
-                    zld,
+                    .flags = sect.flags,
-                    segname,
+                });
-                    sectname,
-                    .{ .flags = sect.flags },
-                );
             },
             macho.S_COALESCED => {
-                break :blk zld.getSectionByName(segname, sectname) orelse try MachO.initSection(
+                break :blk macho_file.getSectionByName(segname, sectname) orelse
-                    gpa,
+                    try macho_file.initSection(segname, sectname, .{});
-                    zld,
-                    segname,
-                    sectname,
-                    .{},
-                );
             },
             macho.S_REGULAR => {
                 if (mem.eql(u8, segname, "__TEXT")) {
 @@ -221,13 +189,8 @@ pub fn getOutputSection(zld: *Zld, sect: macho.section_64) !?u8 {
                         mem.eql(u8, sectname, "__gosymtab") or
                         mem.eql(u8, sectname, "__gopclntab"))
                     {
-                        break :blk zld.getSectionByName("__TEXT", sectname) orelse try MachO.initSection(
+                        break :blk macho_file.getSectionByName("__TEXT", sectname) orelse
-                            gpa,
+                            try macho_file.initSection("__TEXT", sectname, .{});
-                            zld,
-                            "__TEXT",
-                            sectname,
-                            .{},
-                        );
                     }
                 }
                 if (mem.eql(u8, segname, "__DATA")) {
 @@ -236,33 +199,17 @@ pub fn getOutputSection(zld: *Zld, sect: macho.section_64) !?u8 {
                         mem.eql(u8, sectname, "__objc_classlist") or
                         mem.eql(u8, sectname, "__objc_imageinfo"))
                     {
-                        break :blk zld.getSectionByName("__DATA_CONST", sectname) orelse try MachO.initSection(
+                        break :blk macho_file.getSectionByName("__DATA_CONST", sectname) orelse
-                            gpa,
+                            try macho_file.initSection("__DATA_CONST", sectname, .{});
-                            zld,
-                            "__DATA_CONST",
-                            sectname,
-                            .{},
-                        );
                     } else if (mem.eql(u8, sectname, "__data")) {
-                        if (zld.data_section_index == null) {
+                        if (macho_file.data_section_index == null) {
-                            zld.data_section_index = try MachO.initSection(
+                            macho_file.data_section_index = try macho_file.initSection("__DATA", "__data", .{});
-                                gpa,
-                                zld,
-                                "__DATA",
-                                "__data",
-                                .{},
-                            );
                         }
-                        break :blk zld.data_section_index.?;
+                        break :blk macho_file.data_section_index.?;
                     }
                 }
-                break :blk zld.getSectionByName(segname, sectname) orelse try MachO.initSection(
+                break :blk macho_file.getSectionByName(segname, sectname) orelse
-                    gpa,
+                    try macho_file.initSection(segname, sectname, .{});
-                    zld,
-                    segname,
-                    sectname,
-                    .{},
-                );
             },
             else => break :blk null,
         }
 @@ -270,29 +217,29 @@ pub fn getOutputSection(zld: *Zld, sect: macho.section_64) !?u8 {
     // TODO we can do this directly in the selection logic above.
     // Or is it not worth it?
-    if (zld.data_const_section_index == null) {
+    if (macho_file.data_const_section_index == null) {
-        if (zld.getSectionByName("__DATA_CONST", "__const")) |index| {
+        if (macho_file.getSectionByName("__DATA_CONST", "__const")) |index| {
-            zld.data_const_section_index = index;
+            macho_file.data_const_section_index = index;
         }
     }
-    if (zld.thread_vars_section_index == null) {
+    if (macho_file.thread_vars_section_index == null) {
-        if (zld.getSectionByName("__DATA", "__thread_vars")) |index| {
+        if (macho_file.getSectionByName("__DATA", "__thread_vars")) |index| {
-            zld.thread_vars_section_index = index;
+            macho_file.thread_vars_section_index = index;
         }
     }
-    if (zld.thread_data_section_index == null) {
+    if (macho_file.thread_data_section_index == null) {
-        if (zld.getSectionByName("__DATA", "__thread_data")) |index| {
+        if (macho_file.getSectionByName("__DATA", "__thread_data")) |index| {
-            zld.thread_data_section_index = index;
+            macho_file.thread_data_section_index = index;
         }
     }
-    if (zld.thread_bss_section_index == null) {
+    if (macho_file.thread_bss_section_index == null) {
-        if (zld.getSectionByName("__DATA", "__thread_bss")) |index| {
+        if (macho_file.getSectionByName("__DATA", "__thread_bss")) |index| {
-            zld.thread_bss_section_index = index;
+            macho_file.thread_bss_section_index = index;
         }
     }
-    if (zld.bss_section_index == null) {
+    if (macho_file.bss_section_index == null) {
-        if (zld.getSectionByName("__DATA", "__bss")) |index| {
+        if (macho_file.getSectionByName("__DATA", "__bss")) |index| {
-            zld.bss_section_index = index;
+            macho_file.bss_section_index = index;
         }
     }
 @@ -383,8 +330,8 @@ const InnerSymIterator = struct {
 /// Returns an iterator over potentially contained symbols.
 /// Panics when called on a synthetic Atom.
-pub fn getInnerSymbolsIterator(zld: *Zld, atom_index: Index) InnerSymIterator {
+pub fn getInnerSymbolsIterator(macho_file: *MachO, atom_index: Index) InnerSymIterator {
-    const atom = zld.getAtom(atom_index);
+    const atom = macho_file.getAtom(atom_index);
     assert(atom.getFile() != null);
     return .{
         .sym_index = atom.inner_sym_index,
 @@ -397,11 +344,11 @@ pub fn getInnerSymbolsIterator(zld: *Zld, atom_index: Index) InnerSymIterator {
 /// An alias symbol is used to represent the start of an input section
 /// if there were no symbols defined within that range.
 /// Alias symbols are only used on x86_64.
-pub fn getSectionAlias(zld: *Zld, atom_index: Index) ?SymbolWithLoc {
+pub fn getSectionAlias(macho_file: *MachO, atom_index: Index) ?SymbolWithLoc {
-    const atom = zld.getAtom(atom_index);
+    const atom = macho_file.getAtom(atom_index);
     assert(atom.getFile() != null);
-    const object = zld.objects.items[atom.getFile().?];
+    const object = macho_file.objects.items[atom.getFile().?];
     const nbase = @as(u32, @intCast(object.in_symtab.?.len));
     const ntotal = @as(u32, @intCast(object.symtab.len));
     var sym_index: u32 = nbase;
 @@ -418,13 +365,13 @@ pub fn getSectionAlias(zld: *Zld, atom_index: Index) ?SymbolWithLoc {
 /// Given an index into a contained symbol within, calculates an offset wrt
 /// the start of this Atom.
-pub fn calcInnerSymbolOffset(zld: *Zld, atom_index: Index, sym_index: u32) u64 {
+pub fn calcInnerSymbolOffset(macho_file: *MachO, atom_index: Index, sym_index: u32) u64 {
-    const atom = zld.getAtom(atom_index);
+    const atom = macho_file.getAtom(atom_index);
     assert(atom.getFile() != null);
     if (atom.sym_index == sym_index) return 0;
-    const object = zld.objects.items[atom.getFile().?];
+    const object = macho_file.objects.items[atom.getFile().?];
     const source_sym = object.getSourceSymbol(sym_index).?;
     const base_addr = if (object.getSourceSymbol(atom.sym_index)) |sym|
         sym.n_value
 @@ -437,14 +384,14 @@ pub fn calcInnerSymbolOffset(zld: *Zld, atom_index: Index, sym_index: u32) u64 {
     return source_sym.n_value - base_addr;
 }
-pub fn scanAtomRelocs(zld: *Zld, atom_index: Index, relocs: []align(1) const macho.relocation_info) !void {
+pub fn scanAtomRelocs(macho_file: *MachO, atom_index: Index, relocs: []align(1) const macho.relocation_info) !void {
-    const arch = zld.options.target.cpu.arch;
+    const arch = macho_file.base.options.target.cpu.arch;
-    const atom = zld.getAtom(atom_index);
+    const atom = macho_file.getAtom(atom_index);
     assert(atom.getFile() != null); // synthetic atoms do not have relocs
     return switch (arch) {
-        .aarch64 => scanAtomRelocsArm64(zld, atom_index, relocs),
+        .aarch64 => scanAtomRelocsArm64(macho_file, atom_index, relocs),
-        .x86_64 => scanAtomRelocsX86(zld, atom_index, relocs),
+        .x86_64 => scanAtomRelocsX86(macho_file, atom_index, relocs),
         else => unreachable,
     };
 }
 @@ -454,11 +401,11 @@ const RelocContext = struct {
     base_offset: i32 = 0,
 };
-pub fn getRelocContext(zld: *Zld, atom_index: Index) RelocContext {
+pub fn getRelocContext(macho_file: *MachO, atom_index: Index) RelocContext {
-    const atom = zld.getAtom(atom_index);
+    const atom = macho_file.getAtom(atom_index);
     assert(atom.getFile() != null); // synthetic atoms do not have relocs
-    const object = zld.objects.items[atom.getFile().?];
+    const object = macho_file.objects.items[atom.getFile().?];
     if (object.getSourceSymbol(atom.sym_index)) |source_sym| {
         const source_sect = object.getSourceSection(source_sym.n_sect - 1);
         return .{
 @@ -475,7 +422,7 @@ pub fn getRelocContext(zld: *Zld, atom_index: Index) RelocContext {
     };
 }
-pub fn parseRelocTarget(zld: *Zld, ctx: struct {
+pub fn parseRelocTarget(macho_file: *MachO, ctx: struct {
     object_id: u32,
     rel: macho.relocation_info,
     code: []const u8,
 @@ -485,7 +432,7 @@ pub fn parseRelocTarget(zld: *Zld, ctx: struct {
     const tracy = trace(@src());
     defer tracy.end();
-    const object = &zld.objects.items[ctx.object_id];
+    const object = &macho_file.objects.items[ctx.object_id];
     log.debug("parsing reloc target in object({d}) '{s}' ", .{ ctx.object_id, object.name });
     const sym_index = if (ctx.rel.r_extern == 0) sym_index: {
 @@ -498,7 +445,7 @@ pub fn parseRelocTarget(zld: *Zld, ctx: struct {
             else
                 mem.readIntLittle(u32, ctx.code[rel_offset..][0..4]);
         } else blk: {
-            assert(zld.options.target.cpu.arch == .x86_64);
+            assert(macho_file.base.options.target.cpu.arch == .x86_64);
             const correction: u3 = switch (@as(macho.reloc_type_x86_64, @enumFromInt(ctx.rel.r_type))) {
                 .X86_64_RELOC_SIGNED => 0,
                 .X86_64_RELOC_SIGNED_1 => 1,
 @@ -517,35 +464,39 @@ pub fn parseRelocTarget(zld: *Zld, ctx: struct {
     } else object.reverse_symtab_lookup[ctx.rel.r_symbolnum];
     const sym_loc = SymbolWithLoc{ .sym_index = sym_index, .file = ctx.object_id + 1 };
-    const sym = zld.getSymbol(sym_loc);
+    const sym = macho_file.getSymbol(sym_loc);
     const target = if (sym.sect() and !sym.ext())
         sym_loc
     else if (object.getGlobal(sym_index)) |global_index|
-        zld.globals.items[global_index]
+        macho_file.globals.items[global_index]
     else
         sym_loc;
     log.debug("  | target %{d} ('{s}') in object({?d})", .{
         target.sym_index,
-        zld.getSymbolName(target),
+        macho_file.getSymbolName(target),
         target.getFile(),
     });
     return target;
 }
-pub fn getRelocTargetAtomIndex(zld: *Zld, target: SymbolWithLoc) ?Index {
+pub fn getRelocTargetAtomIndex(macho_file: *MachO, target: SymbolWithLoc) ?Index {
     if (target.getFile() == null) {
-        const target_sym_name = zld.getSymbolName(target);
+        const target_sym_name = macho_file.getSymbolName(target);
         if (mem.eql(u8, "__mh_execute_header", target_sym_name)) return null;
         if (mem.eql(u8, "___dso_handle", target_sym_name)) return null;
         unreachable; // referenced symbol not found
     }
-    const object = zld.objects.items[target.getFile().?];
+    const object = macho_file.objects.items[target.getFile().?];
     return object.getAtomIndexForSymbol(target.sym_index);
 }
-fn scanAtomRelocsArm64(zld: *Zld, atom_index: Index, relocs: []align(1) const macho.relocation_info) !void {
+fn scanAtomRelocsArm64(
+    macho_file: *MachO,
+    atom_index: Index,
+    relocs: []align(1) const macho.relocation_info,
+) !void {
     for (relocs) |rel| {
         const rel_type = @as(macho.reloc_type_arm64, @enumFromInt(rel.r_type));
 @@ -556,8 +507,8 @@ fn scanAtomRelocsArm64(zld: *Zld, atom_index: Index, relocs: []align(1) const ma
         if (rel.r_extern == 0) continue;
-        const atom = zld.getAtom(atom_index);
+        const atom = macho_file.getAtom(atom_index);
-        const object = &zld.objects.items[atom.getFile().?];
+        const object = &macho_file.objects.items[atom.getFile().?];
         const sym_index = object.reverse_symtab_lookup[rel.r_symbolnum];
         const sym_loc = SymbolWithLoc{
             .sym_index = sym_index,
 @@ -565,35 +516,39 @@ fn scanAtomRelocsArm64(zld: *Zld, atom_index: Index, relocs: []align(1) const ma
         };
         const target = if (object.getGlobal(sym_index)) |global_index|
-            zld.globals.items[global_index]
+            macho_file.globals.items[global_index]
         else
             sym_loc;
         switch (rel_type) {
             .ARM64_RELOC_BRANCH26 => {
                 // TODO rewrite relocation
-                const sym = zld.getSymbol(target);
+                const sym = macho_file.getSymbol(target);
-                if (sym.undf()) try zld.addStubEntry(target);
+                if (sym.undf()) try macho_file.addStubEntry(target);
             },
             .ARM64_RELOC_GOT_LOAD_PAGE21,
             .ARM64_RELOC_GOT_LOAD_PAGEOFF12,
             .ARM64_RELOC_POINTER_TO_GOT,
             => {
                 // TODO rewrite relocation
-                try zld.addGotEntry(target);
+                try macho_file.addGotEntry(target);
             },
             .ARM64_RELOC_TLVP_LOAD_PAGE21,
             .ARM64_RELOC_TLVP_LOAD_PAGEOFF12,
             => {
-                const sym = zld.getSymbol(target);
+                const sym = macho_file.getSymbol(target);
-                if (sym.undf()) try zld.addTlvPtrEntry(target);
+                if (sym.undf()) try macho_file.addTlvPtrEntry(target);
             },
             else => {},
         }
     }
 }
-fn scanAtomRelocsX86(zld: *Zld, atom_index: Index, relocs: []align(1) const macho.relocation_info) !void {
+fn scanAtomRelocsX86(
+    macho_file: *MachO,
+    atom_index: Index,
+    relocs: []align(1) const macho.relocation_info,
+) !void {
     for (relocs) |rel| {
         const rel_type = @as(macho.reloc_type_x86_64, @enumFromInt(rel.r_type));
 @@ -604,8 +559,8 @@ fn scanAtomRelocsX86(zld: *Zld, atom_index: Index, relocs: []align(1) const mach
         if (rel.r_extern == 0) continue;
-        const atom = zld.getAtom(atom_index);
+        const atom = macho_file.getAtom(atom_index);
-        const object = &zld.objects.items[atom.getFile().?];
+        const object = &macho_file.objects.items[atom.getFile().?];
         const sym_index = object.reverse_symtab_lookup[rel.r_symbolnum];
         const sym_loc = SymbolWithLoc{
             .sym_index = sym_index,
 @@ -613,23 +568,23 @@ fn scanAtomRelocsX86(zld: *Zld, atom_index: Index, relocs: []align(1) const mach
         };
         const target = if (object.getGlobal(sym_index)) |global_index|
-            zld.globals.items[global_index]
+            macho_file.globals.items[global_index]
         else
             sym_loc;
         switch (rel_type) {
             .X86_64_RELOC_BRANCH => {
                 // TODO rewrite relocation
-                const sym = zld.getSymbol(target);
+                const sym = macho_file.getSymbol(target);
-                if (sym.undf()) try zld.addStubEntry(target);
+                if (sym.undf()) try macho_file.addStubEntry(target);
             },
             .X86_64_RELOC_GOT, .X86_64_RELOC_GOT_LOAD => {
                 // TODO rewrite relocation
-                try zld.addGotEntry(target);
+                try macho_file.addGotEntry(target);
             },
             .X86_64_RELOC_TLV => {
-                const sym = zld.getSymbol(target);
+                const sym = macho_file.getSymbol(target);
-                if (sym.undf()) try zld.addTlvPtrEntry(target);
+                if (sym.undf()) try macho_file.addTlvPtrEntry(target);
             },
             else => {},
         }
 @@ -637,53 +592,53 @@ fn scanAtomRelocsX86(zld: *Zld, atom_index: Index, relocs: []align(1) const mach
 }
 pub fn resolveRelocs(
-    zld: *Zld,
+    macho_file: *MachO,
     atom_index: Index,
     atom_code: []u8,
     atom_relocs: []align(1) const macho.relocation_info,
 ) !void {
-    const arch = zld.options.target.cpu.arch;
+    const arch = macho_file.base.options.target.cpu.arch;
-    const atom = zld.getAtom(atom_index);
+    const atom = macho_file.getAtom(atom_index);
     assert(atom.getFile() != null); // synthetic atoms do not have relocs
     log.debug("resolving relocations in ATOM(%{d}, '{s}')", .{
         atom.sym_index,
-        zld.getSymbolName(atom.getSymbolWithLoc()),
+        macho_file.getSymbolName(atom.getSymbolWithLoc()),
     });
-    const ctx = getRelocContext(zld, atom_index);
+    const ctx = getRelocContext(macho_file, atom_index);
     return switch (arch) {
-        .aarch64 => resolveRelocsArm64(zld, atom_index, atom_code, atom_relocs, ctx),
+        .aarch64 => resolveRelocsArm64(macho_file, atom_index, atom_code, atom_relocs, ctx),
-        .x86_64 => resolveRelocsX86(zld, atom_index, atom_code, atom_relocs, ctx),
+        .x86_64 => resolveRelocsX86(macho_file, atom_index, atom_code, atom_relocs, ctx),
         else => unreachable,
     };
 }
-pub fn getRelocTargetAddress(zld: *Zld, target: SymbolWithLoc, is_tlv: bool) !u64 {
+pub fn getRelocTargetAddress(macho_file: *MachO, target: SymbolWithLoc, is_tlv: bool) !u64 {
-    const target_atom_index = getRelocTargetAtomIndex(zld, target) orelse {
+    const target_atom_index = getRelocTargetAtomIndex(macho_file, target) orelse {
         // If there is no atom for target, we still need to check for special, atom-less
         // symbols such as `___dso_handle`.
-        const target_name = zld.getSymbolName(target);
+        const target_name = macho_file.getSymbolName(target);
-        const atomless_sym = zld.getSymbol(target);
+        const atomless_sym = macho_file.getSymbol(target);
         log.debug("    | atomless target '{s}'", .{target_name});
         return atomless_sym.n_value;
     };
-    const target_atom = zld.getAtom(target_atom_index);
+    const target_atom = macho_file.getAtom(target_atom_index);
     log.debug("    | target ATOM(%{d}, '{s}') in object({?})", .{
         target_atom.sym_index,
-        zld.getSymbolName(target_atom.getSymbolWithLoc()),
+        macho_file.getSymbolName(target_atom.getSymbolWithLoc()),
         target_atom.getFile(),
     });
-    const target_sym = zld.getSymbol(target_atom.getSymbolWithLoc());
+    const target_sym = macho_file.getSymbol(target_atom.getSymbolWithLoc());
     assert(target_sym.n_desc != MachO.N_DEAD);
     // If `target` is contained within the target atom, pull its address value.
     const offset = if (target_atom.getFile() != null) blk: {
-        const object = zld.objects.items[target_atom.getFile().?];
+        const object = macho_file.objects.items[target_atom.getFile().?];
         break :blk if (object.getSourceSymbol(target.sym_index)) |_|
-            Atom.calcInnerSymbolOffset(zld, target_atom_index, target.sym_index)
+            Atom.calcInnerSymbolOffset(macho_file, target_atom_index, target.sym_index)
         else
             0; // section alias
     } else 0;
 @@ -694,9 +649,9 @@ pub fn getRelocTargetAddress(zld: *Zld, target: SymbolWithLoc, is_tlv: bool) !u6
         // * wrt to __thread_data if defined, then
         // * wrt to __thread_bss
         const sect_id: u16 = sect_id: {
-            if (zld.thread_data_section_index) |i| {
+            if (macho_file.thread_data_section_index) |i| {
                 break :sect_id i;
-            } else if (zld.thread_bss_section_index) |i| {
+            } else if (macho_file.thread_bss_section_index) |i| {
                 break :sect_id i;
             } else {
                 log.err("threadlocal variables present but no initializer sections found", .{});
 @@ -705,20 +660,20 @@ pub fn getRelocTargetAddress(zld: *Zld, target: SymbolWithLoc, is_tlv: bool) !u6
                 return error.FailedToResolveRelocationTarget;
             }
         };
-        break :base_address zld.sections.items(.header)[sect_id].addr;
+        break :base_address macho_file.sections.items(.header)[sect_id].addr;
     } else 0;
     return target_sym.n_value + offset - base_address;
 }
 fn resolveRelocsArm64(
-    zld: *Zld,
+    macho_file: *MachO,
     atom_index: Index,
     atom_code: []u8,
     atom_relocs: []align(1) const macho.relocation_info,
     context: RelocContext,
 ) !void {
-    const atom = zld.getAtom(atom_index);
+    const atom = macho_file.getAtom(atom_index);
-    const object = zld.objects.items[atom.getFile().?];
+    const object = macho_file.objects.items[atom.getFile().?];
     var addend: ?i64 = null;
     var subtractor: ?SymbolWithLoc = null;
 @@ -745,7 +700,7 @@ fn resolveRelocsArm64(
                     atom.getFile(),
                 });
-                subtractor = parseRelocTarget(zld, .{
+                subtractor = parseRelocTarget(macho_file, .{
                     .object_id = atom.getFile().?,
                     .rel = rel,
                     .code = atom_code,
 @@ -757,7 +712,7 @@ fn resolveRelocsArm64(
             else => {},
         }
-        const target = parseRelocTarget(zld, .{
+        const target = parseRelocTarget(macho_file, .{
             .object_id = atom.getFile().?,
             .rel = rel,
             .code = atom_code,
 @@ -770,26 +725,26 @@ fn resolveRelocsArm64(
             @tagName(rel_type),
             rel.r_address,
             target.sym_index,
-            zld.getSymbolName(target),
+            macho_file.getSymbolName(target),
             target.getFile(),
         });
         const source_addr = blk: {
-            const source_sym = zld.getSymbol(atom.getSymbolWithLoc());
+            const source_sym = macho_file.getSymbol(atom.getSymbolWithLoc());
             break :blk source_sym.n_value + rel_offset;
         };
         const target_addr = blk: {
-            if (relocRequiresGot(zld, rel)) break :blk zld.getGotEntryAddress(target).?;
+            if (relocRequiresGot(macho_file, rel)) break :blk macho_file.getGotEntryAddress(target).?;
-            if (relocIsTlv(zld, rel) and zld.getSymbol(target).undf())
+            if (relocIsTlv(macho_file, rel) and macho_file.getSymbol(target).undf())
-                break :blk zld.getTlvPtrEntryAddress(target).?;
+                break :blk macho_file.getTlvPtrEntryAddress(target).?;
-            if (relocIsStub(zld, rel) and zld.getSymbol(target).undf())
+            if (relocIsStub(macho_file, rel) and macho_file.getSymbol(target).undf())
-                break :blk zld.getStubsEntryAddress(target).?;
+                break :blk macho_file.getStubsEntryAddress(target).?;
             const is_tlv = is_tlv: {
-                const source_sym = zld.getSymbol(atom.getSymbolWithLoc());
+                const source_sym = macho_file.getSymbol(atom.getSymbolWithLoc());
-                const header = zld.sections.items(.header)[source_sym.n_sect - 1];
+                const header = macho_file.sections.items(.header)[source_sym.n_sect - 1];
                 break :is_tlv header.type() == macho.S_THREAD_LOCAL_VARIABLES;
             };
-            break :blk try getRelocTargetAddress(zld, target, is_tlv);
+            break :blk try getRelocTargetAddress(macho_file, target, is_tlv);
         };
         log.debug("    | source_addr = 0x{x}", .{source_addr});
 @@ -797,9 +752,9 @@ fn resolveRelocsArm64(
         switch (rel_type) {
             .ARM64_RELOC_BRANCH26 => {
                 log.debug("  source {s} (object({?})), target {s}", .{
-                    zld.getSymbolName(atom.getSymbolWithLoc()),
+                    macho_file.getSymbolName(atom.getSymbolWithLoc()),
                     atom.getFile(),
-                    zld.getSymbolName(target),
+                    macho_file.getSymbolName(target),
                 });
                 const displacement = if (Relocation.calcPcRelativeDisplacementArm64(
 @@ -809,13 +764,13 @@ fn resolveRelocsArm64(
                     log.debug("    | target_addr = 0x{x}", .{target_addr});
                     break :blk disp;
                 } else |_| blk: {
-                    const thunk_index = zld.thunk_table.get(atom_index).?;
+                    const thunk_index = macho_file.thunk_table.get(atom_index).?;
-                    const thunk = zld.thunks.items[thunk_index];
+                    const thunk = macho_file.thunks.items[thunk_index];
-                    const thunk_sym_loc = if (zld.getSymbol(target).undf())
+                    const thunk_sym_loc = if (macho_file.getSymbol(target).undf())
-                        thunk.getTrampoline(zld, .stub, target).?
+                        thunk.getTrampoline(macho_file, .stub, target).?
                     else
-                        thunk.getTrampoline(zld, .atom, target).?;
+                        thunk.getTrampoline(macho_file, .atom, target).?;
-                    const thunk_addr = zld.getSymbol(thunk_sym_loc).n_value;
+                    const thunk_addr = macho_file.getSymbol(thunk_sym_loc).n_value;
                     log.debug("    | target_addr = 0x{x} (thunk)", .{thunk_addr});
                     break :blk try Relocation.calcPcRelativeDisplacementArm64(source_addr, thunk_addr);
                 };
 @@ -944,7 +899,7 @@ fn resolveRelocsArm64(
                     }
                 };
-                var inst = if (zld.tlv_ptr_table.lookup.contains(target)) aarch64.Instruction{
+                var inst = if (macho_file.tlv_ptr_table.lookup.contains(target)) aarch64.Instruction{
                     .load_store_register = .{
                         .rt = reg_info.rd,
                         .rn = reg_info.rn,
 @@ -992,7 +947,7 @@ fn resolveRelocsArm64(
                 const result = blk: {
                     if (subtractor) |sub| {
-                        const sym = zld.getSymbol(sub);
+                        const sym = macho_file.getSymbol(sub);
                         break :blk @as(i64, @intCast(target_addr)) - @as(i64, @intCast(sym.n_value)) + ptr_addend;
                     } else {
                         break :blk @as(i64, @intCast(target_addr)) + ptr_addend;
 @@ -1016,14 +971,14 @@ fn resolveRelocsArm64(
 }
 fn resolveRelocsX86(
-    zld: *Zld,
+    macho_file: *MachO,
     atom_index: Index,
     atom_code: []u8,
     atom_relocs: []align(1) const macho.relocation_info,
     context: RelocContext,
 ) !void {
-    const atom = zld.getAtom(atom_index);
+    const atom = macho_file.getAtom(atom_index);
-    const object = zld.objects.items[atom.getFile().?];
+    const object = macho_file.objects.items[atom.getFile().?];
     var subtractor: ?SymbolWithLoc = null;
 @@ -1041,7 +996,7 @@ fn resolveRelocsX86(
                     atom.getFile(),
                 });
-                subtractor = parseRelocTarget(zld, .{
+                subtractor = parseRelocTarget(macho_file, .{
                     .object_id = atom.getFile().?,
                     .rel = rel,
                     .code = atom_code,
 @@ -1053,7 +1008,7 @@ fn resolveRelocsX86(
             else => {},
         }
-        const target = parseRelocTarget(zld, .{
+        const target = parseRelocTarget(macho_file, .{
             .object_id = atom.getFile().?,
             .rel = rel,
             .code = atom_code,
 @@ -1066,26 +1021,26 @@ fn resolveRelocsX86(
             @tagName(rel_type),
             rel.r_address,
             target.sym_index,
-            zld.getSymbolName(target),
+            macho_file.getSymbolName(target),
             target.getFile(),
         });
         const source_addr = blk: {
-            const source_sym = zld.getSymbol(atom.getSymbolWithLoc());
+            const source_sym = macho_file.getSymbol(atom.getSymbolWithLoc());
             break :blk source_sym.n_value + rel_offset;
         };
         const target_addr = blk: {
-            if (relocRequiresGot(zld, rel)) break :blk zld.getGotEntryAddress(target).?;
+            if (relocRequiresGot(macho_file, rel)) break :blk macho_file.getGotEntryAddress(target).?;
-            if (relocIsStub(zld, rel) and zld.getSymbol(target).undf())
+            if (relocIsStub(macho_file, rel) and macho_file.getSymbol(target).undf())
-                break :blk zld.getStubsEntryAddress(target).?;
+                break :blk macho_file.getStubsEntryAddress(target).?;
-            if (relocIsTlv(zld, rel) and zld.getSymbol(target).undf())
+            if (relocIsTlv(macho_file, rel) and macho_file.getSymbol(target).undf())
-                break :blk zld.getTlvPtrEntryAddress(target).?;
+                break :blk macho_file.getTlvPtrEntryAddress(target).?;
             const is_tlv = is_tlv: {
-                const source_sym = zld.getSymbol(atom.getSymbolWithLoc());
+                const source_sym = macho_file.getSymbol(atom.getSymbolWithLoc());
-                const header = zld.sections.items(.header)[source_sym.n_sect - 1];
+                const header = macho_file.sections.items(.header)[source_sym.n_sect - 1];
                 break :is_tlv header.type() == macho.S_THREAD_LOCAL_VARIABLES;
             };
-            break :blk try getRelocTargetAddress(zld, target, is_tlv);
+            break :blk try getRelocTargetAddress(macho_file, target, is_tlv);
         };
         log.debug("    | source_addr = 0x{x}", .{source_addr});
 @@ -1115,7 +1070,7 @@ fn resolveRelocsX86(
                 log.debug("    | target_addr = 0x{x}", .{adjusted_target_addr});
                 const disp = try Relocation.calcPcRelativeDisplacementX86(source_addr, adjusted_target_addr, 0);
-                if (zld.tlv_ptr_table.lookup.get(target) == null) {
+                if (macho_file.tlv_ptr_table.lookup.get(target) == null) {
                     // We need to rewrite the opcode from movq to leaq.
                     atom_code[rel_offset - 2] = 0x8d;
                 }
 @@ -1170,7 +1125,7 @@ fn resolveRelocsX86(
                 const result = blk: {
                     if (subtractor) |sub| {
-                        const sym = zld.getSymbol(sub);
+                        const sym = macho_file.getSymbol(sub);
                         break :blk @as(i64, @intCast(target_addr)) - @as(i64, @intCast(sym.n_value)) + addend;
                     } else {
                         break :blk @as(i64, @intCast(target_addr)) + addend;
 @@ -1192,10 +1147,10 @@ fn resolveRelocsX86(
     }
 }
-pub fn getAtomCode(zld: *Zld, atom_index: Index) []const u8 {
+pub fn getAtomCode(macho_file: *MachO, atom_index: Index) []const u8 {
-    const atom = zld.getAtom(atom_index);
+    const atom = macho_file.getAtom(atom_index);
     assert(atom.getFile() != null); // Synthetic atom shouldn't need to inquire for code.
-    const object = zld.objects.items[atom.getFile().?];
+    const object = macho_file.objects.items[atom.getFile().?];
     const source_sym = object.getSourceSymbol(atom.sym_index) orelse {
         // If there was no matching symbol present in the source symtab, this means
         // we are dealing with either an entire section, or part of it, but also
 @@ -1216,10 +1171,10 @@ pub fn getAtomCode(zld: *Zld, atom_index: Index) []const u8 {
     return code[offset..][0..code_len];
 }
-pub fn getAtomRelocs(zld: *Zld, atom_index: Index) []const macho.relocation_info {
+pub fn getAtomRelocs(macho_file: *MachO, atom_index: Index) []const macho.relocation_info {
-    const atom = zld.getAtom(atom_index);
+    const atom = macho_file.getAtom(atom_index);
     assert(atom.getFile() != null); // Synthetic atom shouldn't need to unique for relocs.
-    const object = zld.objects.items[atom.getFile().?];
+    const object = macho_file.objects.items[atom.getFile().?];
     const cache = object.relocs_lookup[atom.sym_index];
     const source_sect_id = if (object.getSourceSymbol(atom.sym_index)) |source_sym| blk: {
 @@ -1238,8 +1193,8 @@ pub fn getAtomRelocs(zld: *Zld, atom_index: Index) []const macho.relocation_info
     return relocs[cache.start..][0..cache.len];
 }
-pub fn relocRequiresGot(zld: *Zld, rel: macho.relocation_info) bool {
+pub fn relocRequiresGot(macho_file: *MachO, rel: macho.relocation_info) bool {
-    switch (zld.options.target.cpu.arch) {
+    switch (macho_file.base.options.target.cpu.arch) {
         .aarch64 => switch (@as(macho.reloc_type_arm64, @enumFromInt(rel.r_type))) {
             .ARM64_RELOC_GOT_LOAD_PAGE21,
             .ARM64_RELOC_GOT_LOAD_PAGEOFF12,
 @@ -1257,8 +1212,8 @@ pub fn relocRequiresGot(zld: *Zld, rel: macho.relocation_info) bool {
     }
 }
-pub fn relocIsTlv(zld: *Zld, rel: macho.relocation_info) bool {
+pub fn relocIsTlv(macho_file: *MachO, rel: macho.relocation_info) bool {
-    switch (zld.options.target.cpu.arch) {
+    switch (macho_file.base.options.target.cpu.arch) {
         .aarch64 => switch (@as(macho.reloc_type_arm64, @enumFromInt(rel.r_type))) {
             .ARM64_RELOC_TLVP_LOAD_PAGE21,
             .ARM64_RELOC_TLVP_LOAD_PAGEOFF12,
 @@ -1273,8 +1228,8 @@ pub fn relocIsTlv(zld: *Zld, rel: macho.relocation_info) bool {
     }
 }
-pub fn relocIsStub(zld: *Zld, rel: macho.relocation_info) bool {
+pub fn relocIsStub(macho_file: *MachO, rel: macho.relocation_info) bool {
-    switch (zld.options.target.cpu.arch) {
+    switch (macho_file.base.options.target.cpu.arch) {
         .aarch64 => switch (@as(macho.reloc_type_arm64, @enumFromInt(rel.r_type))) {
             .ARM64_RELOC_BRANCH26 => return true,
             else => return false,
 @@ -1305,4 +1260,3 @@ const Arch = std.Target.Cpu.Arch;
 const MachO = @import("../MachO.zig");
 pub const Relocation = @import("Relocation.zig");
 const SymbolWithLoc = MachO.SymbolWithLoc;
-const Zld = @import("zld.zig").Zld;

src/link/MachO/CodeSignature.zig+182-182

 @@ -1,17 +1,175 @@
-const CodeSignature = @This();
+page_size: u16,
+code_directory: CodeDirectory,
+requirements: ?Requirements = null,
+entitlements: ?Entitlements = null,
+signature: ?Signature = null,
-const std = @import("std");
+pub fn init(page_size: u16) CodeSignature {
-const assert = std.debug.assert;
+    return .{
-const fs = std.fs;
+        .page_size = page_size,
-const log = std.log.scoped(.link);
+        .code_directory = CodeDirectory.init(page_size),
-const macho = std.macho;
+    };
-const mem = std.mem;
+}
-const testing = std.testing;
-const Allocator = mem.Allocator;
+pub fn deinit(self: *CodeSignature, allocator: Allocator) void {
-const Compilation = @import("../../Compilation.zig");
+    self.code_directory.deinit(allocator);
-const Hasher = @import("hasher.zig").ParallelHasher;
+    if (self.requirements) |*req| {
-const Sha256 = std.crypto.hash.sha2.Sha256;
+        req.deinit(allocator);
+    }
+    if (self.entitlements) |*ents| {
+        ents.deinit(allocator);
+    }
+    if (self.signature) |*sig| {
+        sig.deinit(allocator);
+    }
+}
+pub fn addEntitlements(self: *CodeSignature, allocator: Allocator, path: []const u8) !void {
+    const file = try fs.cwd().openFile(path, .{});
+    defer file.close();
+    const inner = try file.readToEndAlloc(allocator, std.math.maxInt(u32));
+    self.entitlements = .{ .inner = inner };
+}
+pub const WriteOpts = struct {
+    file: fs.File,
+    exec_seg_base: u64,
+    exec_seg_limit: u64,
+    file_size: u32,
+    output_mode: std.builtin.OutputMode,
+};
+pub fn writeAdhocSignature(
+    self: *CodeSignature,
+    comp: *const Compilation,
+    opts: WriteOpts,
+    writer: anytype,
+) !void {
+    const gpa = comp.gpa;
+    var header: macho.SuperBlob = .{
+        .magic = macho.CSMAGIC_EMBEDDED_SIGNATURE,
+        .length = @sizeOf(macho.SuperBlob),
+        .count = 0,
+    };
+    var blobs = std.ArrayList(Blob).init(gpa);
+    defer blobs.deinit();
+    self.code_directory.inner.execSegBase = opts.exec_seg_base;
+    self.code_directory.inner.execSegLimit = opts.exec_seg_limit;
+    self.code_directory.inner.execSegFlags = if (opts.output_mode == .Exe) macho.CS_EXECSEG_MAIN_BINARY else 0;
+    self.code_directory.inner.codeLimit = opts.file_size;
+    const total_pages = @as(u32, @intCast(mem.alignForward(usize, opts.file_size, self.page_size) / self.page_size));
+    try self.code_directory.code_slots.ensureTotalCapacityPrecise(gpa, total_pages);
+    self.code_directory.code_slots.items.len = total_pages;
+    self.code_directory.inner.nCodeSlots = total_pages;
+    // Calculate hash for each page (in file) and write it to the buffer
+    var hasher = Hasher(Sha256){ .allocator = gpa, .thread_pool = comp.thread_pool };
+    try hasher.hash(opts.file, self.code_directory.code_slots.items, .{
+        .chunk_size = self.page_size,
+        .max_file_size = opts.file_size,
+    });
+    try blobs.append(.{ .code_directory = &self.code_directory });
+    header.length += @sizeOf(macho.BlobIndex);
+    header.count += 1;
+    var hash: [hash_size]u8 = undefined;
+    if (self.requirements) |*req| {
+        var buf = std.ArrayList(u8).init(gpa);
+        defer buf.deinit();
+        try req.write(buf.writer());
+        Sha256.hash(buf.items, &hash, .{});
+        self.code_directory.addSpecialHash(req.slotType(), hash);
+        try blobs.append(.{ .requirements = req });
+        header.count += 1;
+        header.length += @sizeOf(macho.BlobIndex) + req.size();
+    }
+    if (self.entitlements) |*ents| {
+        var buf = std.ArrayList(u8).init(gpa);
+        defer buf.deinit();
+        try ents.write(buf.writer());
+        Sha256.hash(buf.items, &hash, .{});
+        self.code_directory.addSpecialHash(ents.slotType(), hash);
+        try blobs.append(.{ .entitlements = ents });
+        header.count += 1;
+        header.length += @sizeOf(macho.BlobIndex) + ents.size();
+    }
+    if (self.signature) |*sig| {
+        try blobs.append(.{ .signature = sig });
+        header.count += 1;
+        header.length += @sizeOf(macho.BlobIndex) + sig.size();
+    }
+    self.code_directory.inner.hashOffset =
+        @sizeOf(macho.CodeDirectory) + @as(u32, @intCast(self.code_directory.ident.len + 1 + self.code_directory.inner.nSpecialSlots * hash_size));
+    self.code_directory.inner.length = self.code_directory.size();
+    header.length += self.code_directory.size();
+    try writer.writeIntBig(u32, header.magic);
+    try writer.writeIntBig(u32, header.length);
+    try writer.writeIntBig(u32, header.count);
+    var offset: u32 = @sizeOf(macho.SuperBlob) + @sizeOf(macho.BlobIndex) * @as(u32, @intCast(blobs.items.len));
+    for (blobs.items) |blob| {
+        try writer.writeIntBig(u32, blob.slotType());
+        try writer.writeIntBig(u32, offset);
+        offset += blob.size();
+    }
+    for (blobs.items) |blob| {
+        try blob.write(writer);
+    }
+}
+pub fn size(self: CodeSignature) u32 {
+    var ssize: u32 = @sizeOf(macho.SuperBlob) + @sizeOf(macho.BlobIndex) + self.code_directory.size();
+    if (self.requirements) |req| {
+        ssize += @sizeOf(macho.BlobIndex) + req.size();
+    }
+    if (self.entitlements) |ent| {
+        ssize += @sizeOf(macho.BlobIndex) + ent.size();
+    }
+    if (self.signature) |sig| {
+        ssize += @sizeOf(macho.BlobIndex) + sig.size();
+    }
+    return ssize;
+}
+pub fn estimateSize(self: CodeSignature, file_size: u64) u32 {
+    var ssize: u64 = @sizeOf(macho.SuperBlob) + @sizeOf(macho.BlobIndex) + self.code_directory.size();
+    // Approx code slots
+    const total_pages = mem.alignForward(u64, file_size, self.page_size) / self.page_size;
+    ssize += total_pages * hash_size;
+    var n_special_slots: u32 = 0;
+    if (self.requirements) |req| {
+        ssize += @sizeOf(macho.BlobIndex) + req.size();
+        n_special_slots = @max(n_special_slots, req.slotType());
+    }
+    if (self.entitlements) |ent| {
+        ssize += @sizeOf(macho.BlobIndex) + ent.size() + hash_size;
+        n_special_slots = @max(n_special_slots, ent.slotType());
+    }
+    if (self.signature) |sig| {
+        ssize += @sizeOf(macho.BlobIndex) + sig.size();
+    }
+    ssize += n_special_slots * hash_size;
+    return @as(u32, @intCast(mem.alignForward(u64, ssize, @sizeOf(u64))));
+}
+pub fn clear(self: *CodeSignature, allocator: Allocator) void {
+    self.code_directory.deinit(allocator);
+    self.code_directory = CodeDirectory.init(self.page_size);
+}
 const hash_size = Sha256.digest_length;
 @@ -218,175 +376,17 @@ const Signature = struct {
     }
 };
-page_size: u16,
+const CodeSignature = @This();
-code_directory: CodeDirectory,
-requirements: ?Requirements = null,
-entitlements: ?Entitlements = null,
-signature: ?Signature = null,
-pub fn init(page_size: u16) CodeSignature {
-    return .{
-        .page_size = page_size,
-        .code_directory = CodeDirectory.init(page_size),
-    };
-}
-pub fn deinit(self: *CodeSignature, allocator: Allocator) void {
-    self.code_directory.deinit(allocator);
-    if (self.requirements) |*req| {
-        req.deinit(allocator);
-    }
-    if (self.entitlements) |*ents| {
-        ents.deinit(allocator);
-    }
-    if (self.signature) |*sig| {
-        sig.deinit(allocator);
-    }
-}
-pub fn addEntitlements(self: *CodeSignature, allocator: Allocator, path: []const u8) !void {
-    const file = try fs.cwd().openFile(path, .{});
-    defer file.close();
-    const inner = try file.readToEndAlloc(allocator, std.math.maxInt(u32));
-    self.entitlements = .{ .inner = inner };
-}
-pub const WriteOpts = struct {
-    file: fs.File,
-    exec_seg_base: u64,
-    exec_seg_limit: u64,
-    file_size: u32,
-    output_mode: std.builtin.OutputMode,
-};
-pub fn writeAdhocSignature(
-    self: *CodeSignature,
-    comp: *const Compilation,
-    opts: WriteOpts,
-    writer: anytype,
-) !void {
-    const gpa = comp.gpa;
-    var header: macho.SuperBlob = .{
-        .magic = macho.CSMAGIC_EMBEDDED_SIGNATURE,
-        .length = @sizeOf(macho.SuperBlob),
-        .count = 0,
-    };
-    var blobs = std.ArrayList(Blob).init(gpa);
-    defer blobs.deinit();
-    self.code_directory.inner.execSegBase = opts.exec_seg_base;
-    self.code_directory.inner.execSegLimit = opts.exec_seg_limit;
-    self.code_directory.inner.execSegFlags = if (opts.output_mode == .Exe) macho.CS_EXECSEG_MAIN_BINARY else 0;
-    self.code_directory.inner.codeLimit = opts.file_size;
-    const total_pages = @as(u32, @intCast(mem.alignForward(usize, opts.file_size, self.page_size) / self.page_size));
-    try self.code_directory.code_slots.ensureTotalCapacityPrecise(gpa, total_pages);
-    self.code_directory.code_slots.items.len = total_pages;
-    self.code_directory.inner.nCodeSlots = total_pages;
-    // Calculate hash for each page (in file) and write it to the buffer
-    var hasher = Hasher(Sha256){ .allocator = gpa, .thread_pool = comp.thread_pool };
-    try hasher.hash(opts.file, self.code_directory.code_slots.items, .{
-        .chunk_size = self.page_size,
-        .max_file_size = opts.file_size,
-    });
-    try blobs.append(.{ .code_directory = &self.code_directory });
-    header.length += @sizeOf(macho.BlobIndex);
-    header.count += 1;
-    var hash: [hash_size]u8 = undefined;
-    if (self.requirements) |*req| {
-        var buf = std.ArrayList(u8).init(gpa);
-        defer buf.deinit();
-        try req.write(buf.writer());
-        Sha256.hash(buf.items, &hash, .{});
-        self.code_directory.addSpecialHash(req.slotType(), hash);
-        try blobs.append(.{ .requirements = req });
-        header.count += 1;
-        header.length += @sizeOf(macho.BlobIndex) + req.size();
-    }
-    if (self.entitlements) |*ents| {
-        var buf = std.ArrayList(u8).init(gpa);
-        defer buf.deinit();
-        try ents.write(buf.writer());
-        Sha256.hash(buf.items, &hash, .{});
-        self.code_directory.addSpecialHash(ents.slotType(), hash);
-        try blobs.append(.{ .entitlements = ents });
-        header.count += 1;
-        header.length += @sizeOf(macho.BlobIndex) + ents.size();
-    }
-    if (self.signature) |*sig| {
-        try blobs.append(.{ .signature = sig });
-        header.count += 1;
-        header.length += @sizeOf(macho.BlobIndex) + sig.size();
-    }
-    self.code_directory.inner.hashOffset =
-        @sizeOf(macho.CodeDirectory) + @as(u32, @intCast(self.code_directory.ident.len + 1 + self.code_directory.inner.nSpecialSlots * hash_size));
-    self.code_directory.inner.length = self.code_directory.size();
-    header.length += self.code_directory.size();
-    try writer.writeIntBig(u32, header.magic);
-    try writer.writeIntBig(u32, header.length);
-    try writer.writeIntBig(u32, header.count);
-    var offset: u32 = @sizeOf(macho.SuperBlob) + @sizeOf(macho.BlobIndex) * @as(u32, @intCast(blobs.items.len));
-    for (blobs.items) |blob| {
-        try writer.writeIntBig(u32, blob.slotType());
-        try writer.writeIntBig(u32, offset);
-        offset += blob.size();
-    }
-    for (blobs.items) |blob| {
-        try blob.write(writer);
-    }
-}
-pub fn size(self: CodeSignature) u32 {
-    var ssize: u32 = @sizeOf(macho.SuperBlob) + @sizeOf(macho.BlobIndex) + self.code_directory.size();
-    if (self.requirements) |req| {
-        ssize += @sizeOf(macho.BlobIndex) + req.size();
-    }
-    if (self.entitlements) |ent| {
-        ssize += @sizeOf(macho.BlobIndex) + ent.size();
-    }
-    if (self.signature) |sig| {
-        ssize += @sizeOf(macho.BlobIndex) + sig.size();
-    }
-    return ssize;
-}
-pub fn estimateSize(self: CodeSignature, file_size: u64) u32 {
+const std = @import("std");
-    var ssize: u64 = @sizeOf(macho.SuperBlob) + @sizeOf(macho.BlobIndex) + self.code_directory.size();
+const assert = std.debug.assert;
-    // Approx code slots
+const fs = std.fs;
-    const total_pages = mem.alignForward(u64, file_size, self.page_size) / self.page_size;
+const log = std.log.scoped(.link);
-    ssize += total_pages * hash_size;
+const macho = std.macho;
-    var n_special_slots: u32 = 0;
+const mem = std.mem;
-    if (self.requirements) |req| {
+const testing = std.testing;
-        ssize += @sizeOf(macho.BlobIndex) + req.size();
-        n_special_slots = @max(n_special_slots, req.slotType());
-    }
-    if (self.entitlements) |ent| {
-        ssize += @sizeOf(macho.BlobIndex) + ent.size() + hash_size;
-        n_special_slots = @max(n_special_slots, ent.slotType());
-    }
-    if (self.signature) |sig| {
-        ssize += @sizeOf(macho.BlobIndex) + sig.size();
-    }
-    ssize += n_special_slots * hash_size;
-    return @as(u32, @intCast(mem.alignForward(u64, ssize, @sizeOf(u64))));
-}
-pub fn clear(self: *CodeSignature, allocator: Allocator) void {
+const Allocator = mem.Allocator;
-    self.code_directory.deinit(allocator);
+const Compilation = @import("../../Compilation.zig");
-    self.code_directory = CodeDirectory.init(self.page_size);
+const Hasher = @import("hasher.zig").ParallelHasher;
-}
+const Sha256 = std.crypto.hash.sha2.Sha256;

src/link/MachO/DebugSymbols.zig+23-23

 @@ -1,26 +1,3 @@
-const DebugSymbols = @This();
-const std = @import("std");
-const build_options = @import("build_options");
-const assert = std.debug.assert;
-const fs = std.fs;
-const link = @import("../../link.zig");
-const load_commands = @import("load_commands.zig");
-const log = std.log.scoped(.dsym);
-const macho = std.macho;
-const makeStaticString = MachO.makeStaticString;
-const math = std.math;
-const mem = std.mem;
-const padToIdeal = MachO.padToIdeal;
-const trace = @import("../../tracy.zig").trace;
-const Allocator = mem.Allocator;
-const Dwarf = @import("../Dwarf.zig");
-const MachO = @import("../MachO.zig");
-const Module = @import("../../Module.zig");
-const StringTable = @import("../strtab.zig").StringTable;
-const Type = @import("../../type.zig").Type;
 allocator: Allocator,
 dwarf: Dwarf,
 file: fs.File,
 @@ -569,3 +546,26 @@ pub fn getSection(self: DebugSymbols, sect: u8) macho.section_64 {
     assert(sect < self.sections.items.len);
     return self.sections.items[sect];
 }
+const DebugSymbols = @This();
+const std = @import("std");
+const build_options = @import("build_options");
+const assert = std.debug.assert;
+const fs = std.fs;
+const link = @import("../../link.zig");
+const load_commands = @import("load_commands.zig");
+const log = std.log.scoped(.dsym);
+const macho = std.macho;
+const makeStaticString = MachO.makeStaticString;
+const math = std.math;
+const mem = std.mem;
+const padToIdeal = MachO.padToIdeal;
+const trace = @import("../../tracy.zig").trace;
+const Allocator = mem.Allocator;
+const Dwarf = @import("../Dwarf.zig");
+const MachO = @import("../MachO.zig");
+const Module = @import("../../Module.zig");
+const StringTable = @import("../strtab.zig").StringTable;
+const Type = @import("../../type.zig").Type;

src/link/MachO/DwarfInfo.zig+14-14

 @@ -1,17 +1,3 @@
-const DwarfInfo = @This();
-const std = @import("std");
-const assert = std.debug.assert;
-const dwarf = std.dwarf;
-const leb = std.leb;
-const log = std.log.scoped(.macho);
-const math = std.math;
-const mem = std.mem;
-const Allocator = mem.Allocator;
-pub const AbbrevLookupTable = std.AutoHashMap(u64, struct { pos: usize, len: usize });
-pub const SubprogramLookupByName = std.StringHashMap(struct { addr: u64, size: u64 });
 debug_info: []const u8,
 debug_abbrev: []const u8,
 debug_str: []const u8,
 @@ -501,3 +487,17 @@ fn getString(self: DwarfInfo, off: u64) []const u8 {
     assert(off < self.debug_str.len);
     return mem.sliceTo(@as([*:0]const u8, @ptrCast(self.debug_str.ptr + @as(usize, @intCast(off)))), 0);
 }
+const DwarfInfo = @This();
+const std = @import("std");
+const assert = std.debug.assert;
+const dwarf = std.dwarf;
+const leb = std.leb;
+const log = std.log.scoped(.macho);
+const math = std.math;
+const mem = std.mem;
+const Allocator = mem.Allocator;
+pub const AbbrevLookupTable = std.AutoHashMap(u64, struct { pos: usize, len: usize });
+pub const SubprogramLookupByName = std.StringHashMap(struct { addr: u64, size: u64 });

src/link/MachO/Dylib.zig+20-20

 @@ -1,23 +1,3 @@
-const Dylib = @This();
-const std = @import("std");
-const assert = std.debug.assert;
-const fs = std.fs;
-const fmt = std.fmt;
-const log = std.log.scoped(.link);
-const macho = std.macho;
-const math = std.math;
-const mem = std.mem;
-const fat = @import("fat.zig");
-const tapi = @import("../tapi.zig");
-const Allocator = mem.Allocator;
-const CrossTarget = std.zig.CrossTarget;
-const LibStub = tapi.LibStub;
-const LoadCommandIterator = macho.LoadCommandIterator;
-const MachO = @import("../MachO.zig");
-const Tbd = tapi.Tbd;
 id: ?Id = null,
 weak: bool = false,
 /// Header is only set if Dylib is parsed directly from a binary and not a stub file.
 @@ -546,3 +526,23 @@ pub fn parseFromStub(
         }
     }
 }
+const Dylib = @This();
+const std = @import("std");
+const assert = std.debug.assert;
+const fs = std.fs;
+const fmt = std.fmt;
+const log = std.log.scoped(.link);
+const macho = std.macho;
+const math = std.math;
+const mem = std.mem;
+const fat = @import("fat.zig");
+const tapi = @import("../tapi.zig");
+const Allocator = mem.Allocator;
+const CrossTarget = std.zig.CrossTarget;
+const LibStub = tapi.LibStub;
+const LoadCommandIterator = macho.LoadCommandIterator;
+const MachO = @import("../MachO.zig");
+const Tbd = tapi.Tbd;

src/link/MachO/Object.zig+76-79

 @@ -2,31 +2,6 @@
 //! Each Object is fully loaded into memory for easier
 //! access into different data within.
-const Object = @This();
-const std = @import("std");
-const build_options = @import("build_options");
-const assert = std.debug.assert;
-const dwarf = std.dwarf;
-const eh_frame = @import("eh_frame.zig");
-const fs = std.fs;
-const io = std.io;
-const log = std.log.scoped(.link);
-const macho = std.macho;
-const math = std.math;
-const mem = std.mem;
-const sort = std.sort;
-const trace = @import("../../tracy.zig").trace;
-const Allocator = mem.Allocator;
-const Atom = @import("Atom.zig");
-const DwarfInfo = @import("DwarfInfo.zig");
-const LoadCommandIterator = macho.LoadCommandIterator;
-const MachO = @import("../MachO.zig");
-const SymbolWithLoc = MachO.SymbolWithLoc;
-const UnwindInfo = @import("UnwindInfo.zig");
-const Zld = @import("zld.zig").Zld;
 name: []const u8,
 mtime: u64,
 contents: []align(@alignOf(u64)) const u8,
 @@ -359,25 +334,25 @@ fn sectionLessThanByAddress(ctx: void, lhs: SortedSection, rhs: SortedSection) b
     return lhs.header.addr < rhs.header.addr;
 }
-pub fn splitIntoAtoms(self: *Object, zld: *Zld, object_id: u32) !void {
+pub fn splitIntoAtoms(self: *Object, macho_file: *MachO, object_id: u32) !void {
     log.debug("splitting object({d}, {s}) into atoms", .{ object_id, self.name });
-    try self.splitRegularSections(zld, object_id);
+    try self.splitRegularSections(macho_file, object_id);
-    try self.parseEhFrameSection(zld, object_id);
+    try self.parseEhFrameSection(macho_file, object_id);
-    try self.parseUnwindInfo(zld, object_id);
+    try self.parseUnwindInfo(macho_file, object_id);
-    try self.parseDataInCode(zld.gpa);
+    try self.parseDataInCode(macho_file.base.allocator);
 }
 /// Splits input regular sections into Atoms.
 /// If the Object was compiled with `MH_SUBSECTIONS_VIA_SYMBOLS`, splits section
 /// into subsections where each subsection then represents an Atom.
-pub fn splitRegularSections(self: *Object, zld: *Zld, object_id: u32) !void {
+pub fn splitRegularSections(self: *Object, macho_file: *MachO, object_id: u32) !void {
-    const gpa = zld.gpa;
+    const gpa = macho_file.base.allocator;
     const sections = self.getSourceSections();
     for (sections, 0..) |sect, id| {
         if (sect.isDebug()) continue;
-        const out_sect_id = (try Atom.getOutputSection(zld, sect)) orelse {
+        const out_sect_id = (try Atom.getOutputSection(macho_file, sect)) orelse {
             log.debug("  unhandled section '{s},{s}'", .{ sect.segName(), sect.sectName() });
             continue;
         };
 @@ -397,13 +372,13 @@ pub fn splitRegularSections(self: *Object, zld: *Zld, object_id: u32) !void {
     if (self.in_symtab == null) {
         for (sections, 0..) |sect, id| {
             if (sect.isDebug()) continue;
-            const out_sect_id = (try Atom.getOutputSection(zld, sect)) orelse continue;
+            const out_sect_id = (try Atom.getOutputSection(macho_file, sect)) orelse continue;
             if (sect.size == 0) continue;
             const sect_id = @as(u8, @intCast(id));
             const sym_index = self.getSectionAliasSymbolIndex(sect_id);
             const atom_index = try self.createAtomFromSubsection(
-                zld,
+                macho_file,
                 object_id,
                 sym_index,
                 sym_index,
 @@ -412,7 +387,7 @@ pub fn splitRegularSections(self: *Object, zld: *Zld, object_id: u32) !void {
                 sect.@"align",
                 out_sect_id,
             );
-            zld.addAtomToSection(atom_index);
+            macho_file.addAtomToSection(atom_index);
         }
         return;
     }
 @@ -456,17 +431,17 @@ pub fn splitRegularSections(self: *Object, zld: *Zld, object_id: u32) !void {
         log.debug("splitting section '{s},{s}' into atoms", .{ sect.segName(), sect.sectName() });
         // Get output segment/section in the final artifact.
-        const out_sect_id = (try Atom.getOutputSection(zld, sect)) orelse continue;
+        const out_sect_id = (try Atom.getOutputSection(macho_file, sect)) orelse continue;
         log.debug("  output sect({d}, '{s},{s}')", .{
             out_sect_id + 1,
-            zld.sections.items(.header)[out_sect_id].segName(),
+            macho_file.sections.items(.header)[out_sect_id].segName(),
-            zld.sections.items(.header)[out_sect_id].sectName(),
+            macho_file.sections.items(.header)[out_sect_id].sectName(),
         });
         try self.parseRelocs(gpa, section.id);
-        const cpu_arch = zld.options.target.cpu.arch;
+        const cpu_arch = macho_file.base.options.target.cpu.arch;
         const sect_loc = filterSymbolsBySection(symtab[sect_sym_index..], sect_id + 1);
         const sect_start_index = sect_sym_index + sect_loc.index;
 @@ -482,7 +457,7 @@ pub fn splitRegularSections(self: *Object, zld: *Zld, object_id: u32) !void {
                 const sym_index = self.getSectionAliasSymbolIndex(sect_id);
                 const atom_size = first_sym.n_value - sect.addr;
                 const atom_index = try self.createAtomFromSubsection(
-                    zld,
+                    macho_file,
                     object_id,
                     sym_index,
                     sym_index,
 @@ -492,9 +467,9 @@ pub fn splitRegularSections(self: *Object, zld: *Zld, object_id: u32) !void {
                     out_sect_id,
                 );
                 if (!sect.isZerofill()) {
-                    try self.cacheRelocs(zld, atom_index);
+                    try self.cacheRelocs(macho_file, atom_index);
                 }
-                zld.addAtomToSection(atom_index);
+                macho_file.addAtomToSection(atom_index);
             }
             var next_sym_index = sect_start_index;
 @@ -518,7 +493,7 @@ pub fn splitRegularSections(self: *Object, zld: *Zld, object_id: u32) !void {
                     sect.@"align";
                 const atom_index = try self.createAtomFromSubsection(
-                    zld,
+                    macho_file,
                     object_id,
                     atom_sym_index,
                     atom_sym_index,
 @@ -537,14 +512,14 @@ pub fn splitRegularSections(self: *Object, zld: *Zld, object_id: u32) !void {
                     self.atom_by_index_table[alias_index] = atom_index;
                 }
                 if (!sect.isZerofill()) {
-                    try self.cacheRelocs(zld, atom_index);
+                    try self.cacheRelocs(macho_file, atom_index);
                 }
-                zld.addAtomToSection(atom_index);
+                macho_file.addAtomToSection(atom_index);
             }
         } else {
             const alias_index = self.getSectionAliasSymbolIndex(sect_id);
             const atom_index = try self.createAtomFromSubsection(
-                zld,
+                macho_file,
                 object_id,
                 alias_index,
                 sect_start_index,
 @@ -554,16 +529,16 @@ pub fn splitRegularSections(self: *Object, zld: *Zld, object_id: u32) !void {
                 out_sect_id,
             );
             if (!sect.isZerofill()) {
-                try self.cacheRelocs(zld, atom_index);
+                try self.cacheRelocs(macho_file, atom_index);
             }
-            zld.addAtomToSection(atom_index);
+            macho_file.addAtomToSection(atom_index);
         }
     }
 }
 fn createAtomFromSubsection(
     self: *Object,
-    zld: *Zld,
+    macho_file: *MachO,
     object_id: u32,
     sym_index: u32,
     inner_sym_index: u32,
 @@ -572,9 +547,9 @@ fn createAtomFromSubsection(
     alignment: u32,
     out_sect_id: u8,
 ) !Atom.Index {
-    const gpa = zld.gpa;
+    const gpa = macho_file.base.allocator;
-    const atom_index = try zld.createAtom(sym_index, .{ .size = size, .alignment = alignment });
+    const atom_index = try macho_file.createAtom(sym_index, .{ .size = size, .alignment = alignment });
-    const atom = zld.getAtomPtr(atom_index);
+    const atom = macho_file.getAtomPtr(atom_index);
     atom.inner_sym_index = inner_sym_index;
     atom.inner_nsyms_trailing = inner_nsyms_trailing;
     atom.file = object_id + 1;
 @@ -584,22 +559,22 @@ fn createAtomFromSubsection(
         sym_index,
         self.getSymbolName(sym_index),
         out_sect_id + 1,
-        zld.sections.items(.header)[out_sect_id].segName(),
+        macho_file.sections.items(.header)[out_sect_id].segName(),
-        zld.sections.items(.header)[out_sect_id].sectName(),
+        macho_file.sections.items(.header)[out_sect_id].sectName(),
         object_id,
     });
     try self.atoms.append(gpa, atom_index);
     self.atom_by_index_table[sym_index] = atom_index;
-    var it = Atom.getInnerSymbolsIterator(zld, atom_index);
+    var it = Atom.getInnerSymbolsIterator(macho_file, atom_index);
     while (it.next()) |sym_loc| {
-        const inner = zld.getSymbolPtr(sym_loc);
+        const inner = macho_file.getSymbolPtr(sym_loc);
         inner.n_sect = out_sect_id + 1;
         self.atom_by_index_table[sym_loc.sym_index] = atom_index;
     }
-    const out_sect = zld.sections.items(.header)[out_sect_id];
+    const out_sect = macho_file.sections.items(.header)[out_sect_id];
     if (out_sect.isCode() and
         mem.eql(u8, "__TEXT", out_sect.segName()) and
         mem.eql(u8, "__text", out_sect.sectName()))
 @@ -651,8 +626,8 @@ fn parseRelocs(self: *Object, gpa: Allocator, sect_id: u8) !void {
     self.section_relocs_lookup.items[sect_id] = start;
 }
-fn cacheRelocs(self: *Object, zld: *Zld, atom_index: Atom.Index) !void {
+fn cacheRelocs(self: *Object, macho_file: *MachO, atom_index: Atom.Index) !void {
-    const atom = zld.getAtom(atom_index);
+    const atom = macho_file.getAtom(atom_index);
     const source_sect_id = if (self.getSourceSymbol(atom.sym_index)) |source_sym| blk: {
         break :blk source_sym.n_sect - 1;
 @@ -679,19 +654,19 @@ fn relocGreaterThan(ctx: void, lhs: macho.relocation_info, rhs: macho.relocation
     return lhs.r_address > rhs.r_address;
 }
-fn parseEhFrameSection(self: *Object, zld: *Zld, object_id: u32) !void {
+fn parseEhFrameSection(self: *Object, macho_file: *MachO, object_id: u32) !void {
     const sect_id = self.eh_frame_sect_id orelse return;
     const sect = self.getSourceSection(sect_id);
     log.debug("parsing __TEXT,__eh_frame section", .{});
-    const gpa = zld.gpa;
+    const gpa = macho_file.base.allocator;
-    if (zld.eh_frame_section_index == null) {
+    if (macho_file.eh_frame_section_index == null) {
-        zld.eh_frame_section_index = try MachO.initSection(gpa, zld, "__TEXT", "__eh_frame", .{});
+        macho_file.eh_frame_section_index = try macho_file.initSection("__TEXT", "__eh_frame", .{});
     }
-    const cpu_arch = zld.options.target.cpu.arch;
+    const cpu_arch = macho_file.base.options.target.cpu.arch;
     try self.parseRelocs(gpa, sect_id);
     const relocs = self.getRelocs(sect_id);
 @@ -729,7 +704,7 @@ fn parseEhFrameSection(self: *Object, zld: *Zld, object_id: u32) !void {
                                 @as(macho.reloc_type_arm64, @enumFromInt(rel.r_type)) == .ARM64_RELOC_UNSIGNED)
                                 break rel;
                         } else unreachable;
-                        const target = Atom.parseRelocTarget(zld, .{
+                        const target = Atom.parseRelocTarget(macho_file, .{
                             .object_id = object_id,
                             .rel = rel,
                             .code = it.data[offset..],
 @@ -744,7 +719,7 @@ fn parseEhFrameSection(self: *Object, zld: *Zld, object_id: u32) !void {
                         });
                         const target_sym_index = self.getSymbolByAddress(target_address, null);
                         const target = if (self.getGlobal(target_sym_index)) |global_index|
-                            zld.globals.items[global_index]
+                            macho_file.globals.items[global_index]
                         else
                             SymbolWithLoc{ .sym_index = target_sym_index, .file = object_id + 1 };
                         break :blk target;
 @@ -770,7 +745,7 @@ fn parseEhFrameSection(self: *Object, zld: *Zld, object_id: u32) !void {
                     };
                     log.debug("FDE at offset {x} tracks {s}", .{
                         offset,
-                        zld.getSymbolName(actual_target),
+                        macho_file.getSymbolName(actual_target),
                     });
                     try self.eh_frame_records_lookup.putNoClobber(gpa, actual_target, offset);
                 }
 @@ -779,19 +754,17 @@ fn parseEhFrameSection(self: *Object, zld: *Zld, object_id: u32) !void {
     }
 }
-fn parseUnwindInfo(self: *Object, zld: *Zld, object_id: u32) !void {
+fn parseUnwindInfo(self: *Object, macho_file: *MachO, object_id: u32) !void {
-    const gpa = zld.gpa;
+    const gpa = macho_file.base.allocator;
-    const cpu_arch = zld.options.target.cpu.arch;
+    const cpu_arch = macho_file.base.options.target.cpu.arch;
     const sect_id = self.unwind_info_sect_id orelse {
         // If it so happens that the object had `__eh_frame` section defined but no `__compact_unwind`,
         // we will try fully synthesising unwind info records to somewhat match Apple ld's
         // approach. However, we will only synthesise DWARF records and nothing more. For this reason,
         // we still create the output `__TEXT,__unwind_info` section.
         if (self.hasEhFrameRecords()) {
-            if (zld.unwind_info_section_index == null) {
+            if (macho_file.unwind_info_section_index == null) {
-                zld.unwind_info_section_index = try MachO.initSection(
+                macho_file.unwind_info_section_index = try macho_file.initSection(
-                    gpa,
-                    zld,
                     "__TEXT",
                     "__unwind_info",
                     .{},
 @@ -803,8 +776,8 @@ fn parseUnwindInfo(self: *Object, zld: *Zld, object_id: u32) !void {
     log.debug("parsing unwind info in {s}", .{self.name});
-    if (zld.unwind_info_section_index == null) {
+    if (macho_file.unwind_info_section_index == null) {
-        zld.unwind_info_section_index = try MachO.initSection(gpa, zld, "__TEXT", "__unwind_info", .{});
+        macho_file.unwind_info_section_index = try macho_file.initSection("__TEXT", "__unwind_info", .{});
     }
     const unwind_records = self.getUnwindRecords();
 @@ -839,7 +812,7 @@ fn parseUnwindInfo(self: *Object, zld: *Zld, object_id: u32) !void {
         // Find function symbol that this record describes
         const rel = relocs[rel_pos.start..][rel_pos.len - 1];
-        const target = Atom.parseRelocTarget(zld, .{
+        const target = Atom.parseRelocTarget(macho_file, .{
             .object_id = object_id,
             .rel = rel,
             .code = mem.asBytes(&record),
 @@ -863,7 +836,7 @@ fn parseUnwindInfo(self: *Object, zld: *Zld, object_id: u32) !void {
                 };
                 log.debug("unwind record {d} tracks {s}", .{
                     record_id,
-                    zld.getSymbolName(actual_target),
+                    macho_file.getSymbolName(actual_target),
                 });
                 try self.unwind_records_lookup.putNoClobber(gpa, actual_target, @intCast(record_id));
             }
 @@ -1094,3 +1067,27 @@ pub fn getEhFrameRecordsIterator(self: Object) eh_frame.Iterator {
 pub fn hasDataInCode(self: Object) bool {
     return self.data_in_code.items.len > 0;
 }
+const Object = @This();
+const std = @import("std");
+const build_options = @import("build_options");
+const assert = std.debug.assert;
+const dwarf = std.dwarf;
+const eh_frame = @import("eh_frame.zig");
+const fs = std.fs;
+const io = std.io;
+const log = std.log.scoped(.link);
+const macho = std.macho;
+const math = std.math;
+const mem = std.mem;
+const sort = std.sort;
+const trace = @import("../../tracy.zig").trace;
+const Allocator = mem.Allocator;
+const Atom = @import("Atom.zig");
+const DwarfInfo = @import("DwarfInfo.zig");
+const LoadCommandIterator = macho.LoadCommandIterator;
+const MachO = @import("../MachO.zig");
+const SymbolWithLoc = MachO.SymbolWithLoc;
+const UnwindInfo = @import("UnwindInfo.zig");

src/link/MachO/Trie.zig+242-242

 @@ -28,248 +28,6 @@
 //! After the optional exported symbol information is a byte of how many edges (0-255) that
 //! this node has leaving it, followed by each edge. Each edge is a zero terminated UTF8 of
 //! the addition chars in the symbol, followed by a uleb128 offset for the node that edge points to.
-const Trie = @This();
-const std = @import("std");
-const mem = std.mem;
-const leb = std.leb;
-const log = std.log.scoped(.link);
-const macho = std.macho;
-const testing = std.testing;
-const assert = std.debug.assert;
-const Allocator = mem.Allocator;
-pub const Node = struct {
-    base: *Trie,
-    /// Terminal info associated with this node.
-    /// If this node is not a terminal node, info is null.
-    terminal_info: ?struct {
-        /// Export flags associated with this exported symbol.
-        export_flags: u64,
-        /// VM address offset wrt to the section this symbol is defined against.
-        vmaddr_offset: u64,
-    } = null,
-    /// Offset of this node in the trie output byte stream.
-    trie_offset: ?u64 = null,
-    /// List of all edges originating from this node.
-    edges: std.ArrayListUnmanaged(Edge) = .{},
-    node_dirty: bool = true,
-    /// Edge connecting to nodes in the trie.
-    pub const Edge = struct {
-        from: *Node,
-        to: *Node,
-        label: []u8,
-        fn deinit(self: *Edge, allocator: Allocator) void {
-            self.to.deinit(allocator);
-            allocator.destroy(self.to);
-            allocator.free(self.label);
-            self.from = undefined;
-            self.to = undefined;
-            self.label = undefined;
-        }
-    };
-    fn deinit(self: *Node, allocator: Allocator) void {
-        for (self.edges.items) |*edge| {
-            edge.deinit(allocator);
-        }
-        self.edges.deinit(allocator);
-    }
-    /// Inserts a new node starting from `self`.
-    fn put(self: *Node, allocator: Allocator, label: []const u8) !*Node {
-        // Check for match with edges from this node.
-        for (self.edges.items) |*edge| {
-            const match = mem.indexOfDiff(u8, edge.label, label) orelse return edge.to;
-            if (match == 0) continue;
-            if (match == edge.label.len) return edge.to.put(allocator, label[match..]);
-            // Found a match, need to splice up nodes.
-            // From: A -> B
-            // To: A -> C -> B
-            const mid = try allocator.create(Node);
-            mid.* = .{ .base = self.base };
-            var to_label = try allocator.dupe(u8, edge.label[match..]);
-            allocator.free(edge.label);
-            const to_node = edge.to;
-            edge.to = mid;
-            edge.label = try allocator.dupe(u8, label[0..match]);
-            self.base.node_count += 1;
-            try mid.edges.append(allocator, .{
-                .from = mid,
-                .to = to_node,
-                .label = to_label,
-            });
-            return if (match == label.len) mid else mid.put(allocator, label[match..]);
-        }
-        // Add a new node.
-        const node = try allocator.create(Node);
-        node.* = .{ .base = self.base };
-        self.base.node_count += 1;
-        try self.edges.append(allocator, .{
-            .from = self,
-            .to = node,
-            .label = try allocator.dupe(u8, label),
-        });
-        return node;
-    }
-    /// Recursively parses the node from the input byte stream.
-    fn read(self: *Node, allocator: Allocator, reader: anytype) Trie.ReadError!usize {
-        self.node_dirty = true;
-        const trie_offset = try reader.context.getPos();
-        self.trie_offset = trie_offset;
-        var nread: usize = 0;
-        const node_size = try leb.readULEB128(u64, reader);
-        if (node_size > 0) {
-            const export_flags = try leb.readULEB128(u64, reader);
-            // TODO Parse special flags.
-            assert(export_flags & macho.EXPORT_SYMBOL_FLAGS_REEXPORT == 0 and
-                export_flags & macho.EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER == 0);
-            const vmaddr_offset = try leb.readULEB128(u64, reader);
-            self.terminal_info = .{
-                .export_flags = export_flags,
-                .vmaddr_offset = vmaddr_offset,
-            };
-        }
-        const nedges = try reader.readByte();
-        self.base.node_count += nedges;
-        nread += (try reader.context.getPos()) - trie_offset;
-        var i: usize = 0;
-        while (i < nedges) : (i += 1) {
-            const edge_start_pos = try reader.context.getPos();
-            const label = blk: {
-                var label_buf = std.ArrayList(u8).init(allocator);
-                while (true) {
-                    const next = try reader.readByte();
-                    if (next == @as(u8, 0))
-                        break;
-                    try label_buf.append(next);
-                }
-                break :blk try label_buf.toOwnedSlice();
-            };
-            const seek_to = try leb.readULEB128(u64, reader);
-            const return_pos = try reader.context.getPos();
-            nread += return_pos - edge_start_pos;
-            try reader.context.seekTo(seek_to);
-            const node = try allocator.create(Node);
-            node.* = .{ .base = self.base };
-            nread += try node.read(allocator, reader);
-            try self.edges.append(allocator, .{
-                .from = self,
-                .to = node,
-                .label = label,
-            });
-            try reader.context.seekTo(return_pos);
-        }
-        return nread;
-    }
-    /// Writes this node to a byte stream.
-    /// The children of this node *are* not written to the byte stream
-    /// recursively. To write all nodes to a byte stream in sequence,
-    /// iterate over `Trie.ordered_nodes` and call this method on each node.
-    /// This is one of the requirements of the MachO.
-    /// Panics if `finalize` was not called before calling this method.
-    fn write(self: Node, writer: anytype) !void {
-        assert(!self.node_dirty);
-        if (self.terminal_info) |info| {
-            // Terminal node info: encode export flags and vmaddr offset of this symbol.
-            var info_buf: [@sizeOf(u64) * 2]u8 = undefined;
-            var info_stream = std.io.fixedBufferStream(&info_buf);
-            // TODO Implement for special flags.
-            assert(info.export_flags & macho.EXPORT_SYMBOL_FLAGS_REEXPORT == 0 and
-                info.export_flags & macho.EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER == 0);
-            try leb.writeULEB128(info_stream.writer(), info.export_flags);
-            try leb.writeULEB128(info_stream.writer(), info.vmaddr_offset);
-            // Encode the size of the terminal node info.
-            var size_buf: [@sizeOf(u64)]u8 = undefined;
-            var size_stream = std.io.fixedBufferStream(&size_buf);
-            try leb.writeULEB128(size_stream.writer(), info_stream.pos);
-            // Now, write them to the output stream.
-            try writer.writeAll(size_buf[0..size_stream.pos]);
-            try writer.writeAll(info_buf[0..info_stream.pos]);
-        } else {
-            // Non-terminal node is delimited by 0 byte.
-            try writer.writeByte(0);
-        }
-        // Write number of edges (max legal number of edges is 256).
-        try writer.writeByte(@as(u8, @intCast(self.edges.items.len)));
-        for (self.edges.items) |edge| {
-            // Write edge label and offset to next node in trie.
-            try writer.writeAll(edge.label);
-            try writer.writeByte(0);
-            try leb.writeULEB128(writer, edge.to.trie_offset.?);
-        }
-    }
-    const FinalizeResult = struct {
-        /// Current size of this node in bytes.
-        node_size: u64,
-        /// True if the trie offset of this node in the output byte stream
-        /// would need updating; false otherwise.
-        updated: bool,
-    };
-    /// Updates offset of this node in the output byte stream.
-    fn finalize(self: *Node, offset_in_trie: u64) !FinalizeResult {
-        var stream = std.io.countingWriter(std.io.null_writer);
-        var writer = stream.writer();
-        var node_size: u64 = 0;
-        if (self.terminal_info) |info| {
-            try leb.writeULEB128(writer, info.export_flags);
-            try leb.writeULEB128(writer, info.vmaddr_offset);
-            try leb.writeULEB128(writer, stream.bytes_written);
-        } else {
-            node_size += 1; // 0x0 for non-terminal nodes
-        }
-        node_size += 1; // 1 byte for edge count
-        for (self.edges.items) |edge| {
-            const next_node_offset = edge.to.trie_offset orelse 0;
-            node_size += edge.label.len + 1;
-            try leb.writeULEB128(writer, next_node_offset);
-        }
-        const trie_offset = self.trie_offset orelse 0;
-        const updated = offset_in_trie != trie_offset;
-        self.trie_offset = offset_in_trie;
-        self.node_dirty = false;
-        node_size += stream.bytes_written;
-        return FinalizeResult{ .node_size = node_size, .updated = updated };
-    }
-};
 /// The root node of the trie.
 root: ?*Node = null,
 @@ -611,3 +369,245 @@ test "ordering bug" {
     _ = try trie.write(stream.writer());
     try expectEqualHexStrings(&exp_buffer, buffer);
 }
+pub const Node = struct {
+    base: *Trie,
+    /// Terminal info associated with this node.
+    /// If this node is not a terminal node, info is null.
+    terminal_info: ?struct {
+        /// Export flags associated with this exported symbol.
+        export_flags: u64,
+        /// VM address offset wrt to the section this symbol is defined against.
+        vmaddr_offset: u64,
+    } = null,
+    /// Offset of this node in the trie output byte stream.
+    trie_offset: ?u64 = null,
+    /// List of all edges originating from this node.
+    edges: std.ArrayListUnmanaged(Edge) = .{},
+    node_dirty: bool = true,
+    /// Edge connecting to nodes in the trie.
+    pub const Edge = struct {
+        from: *Node,
+        to: *Node,
+        label: []u8,
+        fn deinit(self: *Edge, allocator: Allocator) void {
+            self.to.deinit(allocator);
+            allocator.destroy(self.to);
+            allocator.free(self.label);
+            self.from = undefined;
+            self.to = undefined;
+            self.label = undefined;
+        }
+    };
+    fn deinit(self: *Node, allocator: Allocator) void {
+        for (self.edges.items) |*edge| {
+            edge.deinit(allocator);
+        }
+        self.edges.deinit(allocator);
+    }
+    /// Inserts a new node starting from `self`.
+    fn put(self: *Node, allocator: Allocator, label: []const u8) !*Node {
+        // Check for match with edges from this node.
+        for (self.edges.items) |*edge| {
+            const match = mem.indexOfDiff(u8, edge.label, label) orelse return edge.to;
+            if (match == 0) continue;
+            if (match == edge.label.len) return edge.to.put(allocator, label[match..]);
+            // Found a match, need to splice up nodes.
+            // From: A -> B
+            // To: A -> C -> B
+            const mid = try allocator.create(Node);
+            mid.* = .{ .base = self.base };
+            var to_label = try allocator.dupe(u8, edge.label[match..]);
+            allocator.free(edge.label);
+            const to_node = edge.to;
+            edge.to = mid;
+            edge.label = try allocator.dupe(u8, label[0..match]);
+            self.base.node_count += 1;
+            try mid.edges.append(allocator, .{
+                .from = mid,
+                .to = to_node,
+                .label = to_label,
+            });
+            return if (match == label.len) mid else mid.put(allocator, label[match..]);
+        }
+        // Add a new node.
+        const node = try allocator.create(Node);
+        node.* = .{ .base = self.base };
+        self.base.node_count += 1;
+        try self.edges.append(allocator, .{
+            .from = self,
+            .to = node,
+            .label = try allocator.dupe(u8, label),
+        });
+        return node;
+    }
+    /// Recursively parses the node from the input byte stream.
+    fn read(self: *Node, allocator: Allocator, reader: anytype) Trie.ReadError!usize {
+        self.node_dirty = true;
+        const trie_offset = try reader.context.getPos();
+        self.trie_offset = trie_offset;
+        var nread: usize = 0;
+        const node_size = try leb.readULEB128(u64, reader);
+        if (node_size > 0) {
+            const export_flags = try leb.readULEB128(u64, reader);
+            // TODO Parse special flags.
+            assert(export_flags & macho.EXPORT_SYMBOL_FLAGS_REEXPORT == 0 and
+                export_flags & macho.EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER == 0);
+            const vmaddr_offset = try leb.readULEB128(u64, reader);
+            self.terminal_info = .{
+                .export_flags = export_flags,
+                .vmaddr_offset = vmaddr_offset,
+            };
+        }
+        const nedges = try reader.readByte();
+        self.base.node_count += nedges;
+        nread += (try reader.context.getPos()) - trie_offset;
+        var i: usize = 0;
+        while (i < nedges) : (i += 1) {
+            const edge_start_pos = try reader.context.getPos();
+            const label = blk: {
+                var label_buf = std.ArrayList(u8).init(allocator);
+                while (true) {
+                    const next = try reader.readByte();
+                    if (next == @as(u8, 0))
+                        break;
+                    try label_buf.append(next);
+                }
+                break :blk try label_buf.toOwnedSlice();
+            };
+            const seek_to = try leb.readULEB128(u64, reader);
+            const return_pos = try reader.context.getPos();
+            nread += return_pos - edge_start_pos;
+            try reader.context.seekTo(seek_to);
+            const node = try allocator.create(Node);
+            node.* = .{ .base = self.base };
+            nread += try node.read(allocator, reader);
+            try self.edges.append(allocator, .{
+                .from = self,
+                .to = node,
+                .label = label,
+            });
+            try reader.context.seekTo(return_pos);
+        }
+        return nread;
+    }
+    /// Writes this node to a byte stream.
+    /// The children of this node *are* not written to the byte stream
+    /// recursively. To write all nodes to a byte stream in sequence,
+    /// iterate over `Trie.ordered_nodes` and call this method on each node.
+    /// This is one of the requirements of the MachO.
+    /// Panics if `finalize` was not called before calling this method.
+    fn write(self: Node, writer: anytype) !void {
+        assert(!self.node_dirty);
+        if (self.terminal_info) |info| {
+            // Terminal node info: encode export flags and vmaddr offset of this symbol.
+            var info_buf: [@sizeOf(u64) * 2]u8 = undefined;
+            var info_stream = std.io.fixedBufferStream(&info_buf);
+            // TODO Implement for special flags.
+            assert(info.export_flags & macho.EXPORT_SYMBOL_FLAGS_REEXPORT == 0 and
+                info.export_flags & macho.EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER == 0);
+            try leb.writeULEB128(info_stream.writer(), info.export_flags);
+            try leb.writeULEB128(info_stream.writer(), info.vmaddr_offset);
+            // Encode the size of the terminal node info.
+            var size_buf: [@sizeOf(u64)]u8 = undefined;
+            var size_stream = std.io.fixedBufferStream(&size_buf);
+            try leb.writeULEB128(size_stream.writer(), info_stream.pos);
+            // Now, write them to the output stream.
+            try writer.writeAll(size_buf[0..size_stream.pos]);
+            try writer.writeAll(info_buf[0..info_stream.pos]);
+        } else {
+            // Non-terminal node is delimited by 0 byte.
+            try writer.writeByte(0);
+        }
+        // Write number of edges (max legal number of edges is 256).
+        try writer.writeByte(@as(u8, @intCast(self.edges.items.len)));
+        for (self.edges.items) |edge| {
+            // Write edge label and offset to next node in trie.
+            try writer.writeAll(edge.label);
+            try writer.writeByte(0);
+            try leb.writeULEB128(writer, edge.to.trie_offset.?);
+        }
+    }
+    const FinalizeResult = struct {
+        /// Current size of this node in bytes.
+        node_size: u64,
+        /// True if the trie offset of this node in the output byte stream
+        /// would need updating; false otherwise.
+        updated: bool,
+    };
+    /// Updates offset of this node in the output byte stream.
+    fn finalize(self: *Node, offset_in_trie: u64) !FinalizeResult {
+        var stream = std.io.countingWriter(std.io.null_writer);
+        var writer = stream.writer();
+        var node_size: u64 = 0;
+        if (self.terminal_info) |info| {
+            try leb.writeULEB128(writer, info.export_flags);
+            try leb.writeULEB128(writer, info.vmaddr_offset);
+            try leb.writeULEB128(writer, stream.bytes_written);
+        } else {
+            node_size += 1; // 0x0 for non-terminal nodes
+        }
+        node_size += 1; // 1 byte for edge count
+        for (self.edges.items) |edge| {
+            const next_node_offset = edge.to.trie_offset orelse 0;
+            node_size += edge.label.len + 1;
+            try leb.writeULEB128(writer, next_node_offset);
+        }
+        const trie_offset = self.trie_offset orelse 0;
+        const updated = offset_in_trie != trie_offset;
+        self.trie_offset = offset_in_trie;
+        self.node_dirty = false;
+        node_size += stream.bytes_written;
+        return FinalizeResult{ .node_size = node_size, .updated = updated };
+    }
+};
+const Trie = @This();
+const std = @import("std");
+const mem = std.mem;
+const leb = std.leb;
+const log = std.log.scoped(.link);
+const macho = std.macho;
+const testing = std.testing;
+const assert = std.debug.assert;
+const Allocator = mem.Allocator;

src/link/MachO/UnwindInfo.zig+69-71

 @@ -1,25 +1,3 @@
-const UnwindInfo = @This();
-const std = @import("std");
-const assert = std.debug.assert;
-const eh_frame = @import("eh_frame.zig");
-const fs = std.fs;
-const leb = std.leb;
-const log = std.log.scoped(.unwind_info);
-const macho = std.macho;
-const math = std.math;
-const mem = std.mem;
-const trace = @import("../../tracy.zig").trace;
-const Allocator = mem.Allocator;
-const Atom = @import("Atom.zig");
-const AtomIndex = @import("zld.zig").AtomIndex;
-const EhFrameRecord = eh_frame.EhFrameRecord;
-const MachO = @import("../MachO.zig");
-const Object = @import("Object.zig");
-const SymbolWithLoc = MachO.SymbolWithLoc;
-const Zld = @import("zld.zig").Zld;
 gpa: Allocator,
 /// List of all unwind records gathered from all objects and sorted
 @@ -203,28 +181,28 @@ pub fn deinit(info: *UnwindInfo) void {
     info.lsdas_lookup.deinit(info.gpa);
 }
-pub fn scanRelocs(zld: *Zld) !void {
+pub fn scanRelocs(macho_file: *MachO) !void {
-    if (zld.unwind_info_section_index == null) return;
+    if (macho_file.unwind_info_section_index == null) return;
-    const cpu_arch = zld.options.target.cpu.arch;
+    const cpu_arch = macho_file.base.options.target.cpu.arch;
-    for (zld.objects.items, 0..) |*object, object_id| {
+    for (macho_file.objects.items, 0..) |*object, object_id| {
         const unwind_records = object.getUnwindRecords();
         for (object.exec_atoms.items) |atom_index| {
-            var inner_syms_it = Atom.getInnerSymbolsIterator(zld, atom_index);
+            var inner_syms_it = Atom.getInnerSymbolsIterator(macho_file, atom_index);
             while (inner_syms_it.next()) |sym| {
                 const record_id = object.unwind_records_lookup.get(sym) orelse continue;
                 if (object.unwind_relocs_lookup[record_id].dead) continue;
                 const record = unwind_records[record_id];
                 if (!UnwindEncoding.isDwarf(record.compactUnwindEncoding, cpu_arch)) {
-                    if (getPersonalityFunctionReloc(zld, @as(u32, @intCast(object_id)), record_id)) |rel| {
+                    if (getPersonalityFunctionReloc(macho_file, @as(u32, @intCast(object_id)), record_id)) |rel| {
                         // Personality function; add GOT pointer.
-                        const target = Atom.parseRelocTarget(zld, .{
+                        const target = Atom.parseRelocTarget(macho_file, .{
                             .object_id = @as(u32, @intCast(object_id)),
                             .rel = rel,
                             .code = mem.asBytes(&record),
                             .base_offset = @as(i32, @intCast(record_id * @sizeOf(macho.compact_unwind_entry))),
                         });
-                        try zld.addGotEntry(target);
+                        try macho_file.addGotEntry(target);
                     }
                 }
             }
 @@ -232,10 +210,10 @@ pub fn scanRelocs(zld: *Zld) !void {
     }
 }
-pub fn collect(info: *UnwindInfo, zld: *Zld) !void {
+pub fn collect(info: *UnwindInfo, macho_file: *MachO) !void {
-    if (zld.unwind_info_section_index == null) return;
+    if (macho_file.unwind_info_section_index == null) return;
-    const cpu_arch = zld.options.target.cpu.arch;
+    const cpu_arch = macho_file.base.options.target.cpu.arch;
     var records = std.ArrayList(macho.compact_unwind_entry).init(info.gpa);
     defer records.deinit();
 @@ -244,7 +222,7 @@ pub fn collect(info: *UnwindInfo, zld: *Zld) !void {
     defer sym_indexes.deinit();
     // TODO handle dead stripping
-    for (zld.objects.items, 0..) |*object, object_id| {
+    for (macho_file.objects.items, 0..) |*object, object_id| {
         log.debug("collecting unwind records in {s} ({d})", .{ object.name, object_id });
         const unwind_records = object.getUnwindRecords();
 @@ -254,7 +232,7 @@ pub fn collect(info: *UnwindInfo, zld: *Zld) !void {
         try sym_indexes.ensureUnusedCapacity(object.exec_atoms.items.len);
         for (object.exec_atoms.items) |atom_index| {
-            var inner_syms_it = Atom.getInnerSymbolsIterator(zld, atom_index);
+            var inner_syms_it = Atom.getInnerSymbolsIterator(macho_file, atom_index);
             var prev_symbol: ?SymbolWithLoc = null;
             while (inner_syms_it.next()) |symbol| {
                 var record = if (object.unwind_records_lookup.get(symbol)) |record_id| blk: {
 @@ -262,14 +240,14 @@ pub fn collect(info: *UnwindInfo, zld: *Zld) !void {
                     var record = unwind_records[record_id];
                     if (UnwindEncoding.isDwarf(record.compactUnwindEncoding, cpu_arch)) {
-                        try info.collectPersonalityFromDwarf(zld, @as(u32, @intCast(object_id)), symbol, &record);
+                        try info.collectPersonalityFromDwarf(macho_file, @as(u32, @intCast(object_id)), symbol, &record);
                     } else {
                         if (getPersonalityFunctionReloc(
-                            zld,
+                            macho_file,
                             @as(u32, @intCast(object_id)),
                             record_id,
                         )) |rel| {
-                            const target = Atom.parseRelocTarget(zld, .{
+                            const target = Atom.parseRelocTarget(macho_file, .{
                                 .object_id = @as(u32, @intCast(object_id)),
                                 .rel = rel,
                                 .code = mem.asBytes(&record),
 @@ -286,8 +264,8 @@ pub fn collect(info: *UnwindInfo, zld: *Zld) !void {
                             UnwindEncoding.setPersonalityIndex(&record.compactUnwindEncoding, personality_index + 1);
                         }
-                        if (getLsdaReloc(zld, @as(u32, @intCast(object_id)), record_id)) |rel| {
+                        if (getLsdaReloc(macho_file, @as(u32, @intCast(object_id)), record_id)) |rel| {
-                            const target = Atom.parseRelocTarget(zld, .{
+                            const target = Atom.parseRelocTarget(macho_file, .{
                                 .object_id = @as(u32, @intCast(object_id)),
                                 .rel = rel,
                                 .code = mem.asBytes(&record),
 @@ -298,7 +276,7 @@ pub fn collect(info: *UnwindInfo, zld: *Zld) !void {
                     }
                     break :blk record;
                 } else blk: {
-                    const sym = zld.getSymbol(symbol);
+                    const sym = macho_file.getSymbol(symbol);
                     if (sym.n_desc == MachO.N_DEAD) continue;
                     if (prev_symbol) |prev_sym| {
                         const prev_addr = object.getSourceSymbol(prev_sym.sym_index).?.n_value;
 @@ -310,7 +288,7 @@ pub fn collect(info: *UnwindInfo, zld: *Zld) !void {
                         if (object.eh_frame_records_lookup.get(symbol)) |fde_offset| {
                             if (object.eh_frame_relocs_lookup.get(fde_offset).?.dead) continue;
                             var record = nullRecord();
-                            try info.collectPersonalityFromDwarf(zld, @as(u32, @intCast(object_id)), symbol, &record);
+                            try info.collectPersonalityFromDwarf(macho_file, @as(u32, @intCast(object_id)), symbol, &record);
                             switch (cpu_arch) {
                                 .aarch64 => UnwindEncoding.setMode(&record.compactUnwindEncoding, macho.UNWIND_ARM64_MODE.DWARF),
                                 .x86_64 => UnwindEncoding.setMode(&record.compactUnwindEncoding, macho.UNWIND_X86_64_MODE.DWARF),
 @@ -323,8 +301,8 @@ pub fn collect(info: *UnwindInfo, zld: *Zld) !void {
                     break :blk nullRecord();
                 };
-                const atom = zld.getAtom(atom_index);
+                const atom = macho_file.getAtom(atom_index);
-                const sym = zld.getSymbol(symbol);
+                const sym = macho_file.getSymbol(symbol);
                 assert(sym.n_desc != MachO.N_DEAD);
                 const size = if (inner_syms_it.next()) |next_sym| blk: {
                     // All this trouble to account for symbol aliases.
 @@ -336,8 +314,8 @@ pub fn collect(info: *UnwindInfo, zld: *Zld) !void {
                     const curr_addr = object.getSourceSymbol(symbol.sym_index).?.n_value;
                     const next_addr = object.getSourceSymbol(next_sym.sym_index).?.n_value;
                     if (next_addr > curr_addr) break :blk next_addr - curr_addr;
-                    break :blk zld.getSymbol(atom.getSymbolWithLoc()).n_value + atom.size - sym.n_value;
+                    break :blk macho_file.getSymbol(atom.getSymbolWithLoc()).n_value + atom.size - sym.n_value;
-                } else zld.getSymbol(atom.getSymbolWithLoc()).n_value + atom.size - sym.n_value;
+                } else macho_file.getSymbol(atom.getSymbolWithLoc()).n_value + atom.size - sym.n_value;
                 record.rangeStart = sym.n_value;
                 record.rangeLength = @as(u32, @intCast(size));
 @@ -518,23 +496,23 @@ pub fn collect(info: *UnwindInfo, zld: *Zld) !void {
 fn collectPersonalityFromDwarf(
     info: *UnwindInfo,
-    zld: *Zld,
+    macho_file: *MachO,
     object_id: u32,
     sym_loc: SymbolWithLoc,
     record: *macho.compact_unwind_entry,
 ) !void {
-    const object = &zld.objects.items[object_id];
+    const object = &macho_file.objects.items[object_id];
     var it = object.getEhFrameRecordsIterator();
     const fde_offset = object.eh_frame_records_lookup.get(sym_loc).?;
     it.seekTo(fde_offset);
     const fde = (try it.next()).?;
-    const cie_ptr = fde.getCiePointerSource(object_id, zld, fde_offset);
+    const cie_ptr = fde.getCiePointerSource(object_id, macho_file, fde_offset);
     const cie_offset = fde_offset + 4 - cie_ptr;
     it.seekTo(cie_offset);
     const cie = (try it.next()).?;
     if (cie.getPersonalityPointerReloc(
-        zld,
+        macho_file,
         @as(u32, @intCast(object_id)),
         cie_offset,
     )) |target| {
 @@ -550,9 +528,9 @@ fn collectPersonalityFromDwarf(
     }
 }
-pub fn calcSectionSize(info: UnwindInfo, zld: *Zld) !void {
+pub fn calcSectionSize(info: UnwindInfo, macho_file: *MachO) !void {
-    const sect_id = zld.unwind_info_section_index orelse return;
+    const sect_id = macho_file.unwind_info_section_index orelse return;
-    const sect = &zld.sections.items(.header)[sect_id];
+    const sect = &macho_file.sections.items(.header)[sect_id];
     sect.@"align" = 2;
     sect.size = info.calcRequiredSize();
 }
 @@ -569,23 +547,23 @@ fn calcRequiredSize(info: UnwindInfo) usize {
     return total_size;
 }
-pub fn write(info: *UnwindInfo, zld: *Zld) !void {
+pub fn write(info: *UnwindInfo, macho_file: *MachO) !void {
-    const sect_id = zld.unwind_info_section_index orelse return;
+    const sect_id = macho_file.unwind_info_section_index orelse return;
-    const sect = &zld.sections.items(.header)[sect_id];
+    const sect = &macho_file.sections.items(.header)[sect_id];
-    const seg_id = zld.sections.items(.segment_index)[sect_id];
+    const seg_id = macho_file.sections.items(.segment_index)[sect_id];
-    const seg = zld.segments.items[seg_id];
+    const seg = macho_file.segments.items[seg_id];
-    const text_sect_id = zld.text_section_index.?;
+    const text_sect_id = macho_file.text_section_index.?;
-    const text_sect = zld.sections.items(.header)[text_sect_id];
+    const text_sect = macho_file.sections.items(.header)[text_sect_id];
     var personalities: [max_personalities]u32 = undefined;
-    const cpu_arch = zld.options.target.cpu.arch;
+    const cpu_arch = macho_file.base.options.target.cpu.arch;
     log.debug("Personalities:", .{});
     for (info.personalities[0..info.personalities_count], 0..) |target, i| {
-        const addr = zld.getGotEntryAddress(target).?;
+        const addr = macho_file.getGotEntryAddress(target).?;
         personalities[i] = @as(u32, @intCast(addr - seg.vmaddr));
-        log.debug("  {d}: 0x{x} ({s})", .{ i, personalities[i], zld.getSymbolName(target) });
+        log.debug("  {d}: 0x{x} ({s})", .{ i, personalities[i], macho_file.getSymbolName(target) });
     }
     for (info.records.items) |*rec| {
 @@ -599,7 +577,7 @@ pub fn write(info: *UnwindInfo, zld: *Zld) !void {
         if (rec.compactUnwindEncoding > 0 and !UnwindEncoding.isDwarf(rec.compactUnwindEncoding, cpu_arch)) {
             const lsda_target = @as(SymbolWithLoc, @bitCast(rec.lsda));
             if (lsda_target.getFile()) |_| {
-                const sym = zld.getSymbol(lsda_target);
+                const sym = macho_file.getSymbol(lsda_target);
                 rec.lsda = sym.n_value - seg.vmaddr;
             }
         }
 @@ -689,11 +667,11 @@ pub fn write(info: *UnwindInfo, zld: *Zld) !void {
         @memset(buffer.items[offset..], 0);
     }
-    try zld.file.pwriteAll(buffer.items, sect.offset);
+    try macho_file.base.file.?.pwriteAll(buffer.items, sect.offset);
 }
-fn getRelocs(zld: *Zld, object_id: u32, record_id: usize) []const macho.relocation_info {
+fn getRelocs(macho_file: *MachO, object_id: u32, record_id: usize) []const macho.relocation_info {
-    const object = &zld.objects.items[object_id];
+    const object = &macho_file.objects.items[object_id];
     assert(object.hasUnwindRecords());
     const rel_pos = object.unwind_relocs_lookup[record_id].reloc;
     const relocs = object.getRelocs(object.unwind_info_sect_id.?);
 @@ -707,11 +685,11 @@ fn isPersonalityFunction(record_id: usize, rel: macho.relocation_info) bool {
 }
 pub fn getPersonalityFunctionReloc(
-    zld: *Zld,
+    macho_file: *MachO,
     object_id: u32,
     record_id: usize,
 ) ?macho.relocation_info {
-    const relocs = getRelocs(zld, object_id, record_id);
+    const relocs = getRelocs(macho_file, object_id, record_id);
     for (relocs) |rel| {
         if (isPersonalityFunction(record_id, rel)) return rel;
     }
 @@ -735,8 +713,8 @@ fn isLsda(record_id: usize, rel: macho.relocation_info) bool {
     return rel_offset == 24;
 }
-pub fn getLsdaReloc(zld: *Zld, object_id: u32, record_id: usize) ?macho.relocation_info {
+pub fn getLsdaReloc(macho_file: *MachO, object_id: u32, record_id: usize) ?macho.relocation_info {
-    const relocs = getRelocs(zld, object_id, record_id);
+    const relocs = getRelocs(macho_file, object_id, record_id);
     for (relocs) |rel| {
         if (isLsda(record_id, rel)) return rel;
     }
 @@ -828,3 +806,23 @@ pub const UnwindEncoding = struct {
         enc.* |= offset;
     }
 };
+const UnwindInfo = @This();
+const std = @import("std");
+const assert = std.debug.assert;
+const eh_frame = @import("eh_frame.zig");
+const fs = std.fs;
+const leb = std.leb;
+const log = std.log.scoped(.unwind_info);
+const macho = std.macho;
+const math = std.math;
+const mem = std.mem;
+const trace = @import("../../tracy.zig").trace;
+const Allocator = mem.Allocator;
+const Atom = @import("Atom.zig");
+const EhFrameRecord = eh_frame.EhFrameRecord;
+const MachO = @import("../MachO.zig");
+const Object = @import("Object.zig");
+const SymbolWithLoc = MachO.SymbolWithLoc;

src/link/MachO/dead_strip.zig+125-126

 @@ -1,89 +1,72 @@
 //! An algorithm for dead stripping of unreferenced Atoms.
-const std = @import("std");
+pub fn gcAtoms(macho_file: *MachO) !void {
-const assert = std.debug.assert;
+    const gpa = macho_file.base.allocator;
-const eh_frame = @import("eh_frame.zig");
-const log = std.log.scoped(.dead_strip);
-const macho = std.macho;
-const math = std.math;
-const mem = std.mem;
-const Allocator = mem.Allocator;
-const Atom = @import("Atom.zig");
-const MachO = @import("../MachO.zig");
-const SymbolWithLoc = MachO.SymbolWithLoc;
-const UnwindInfo = @import("UnwindInfo.zig");
-const Zld = @import("zld.zig").Zld;
-const AtomTable = std.AutoHashMap(Atom.Index, void);
-pub fn gcAtoms(zld: *Zld) !void {
-    const gpa = zld.gpa;
     var arena = std.heap.ArenaAllocator.init(gpa);
     defer arena.deinit();
     var roots = AtomTable.init(arena.allocator());
-    try roots.ensureUnusedCapacity(@as(u32, @intCast(zld.globals.items.len)));
+    try roots.ensureUnusedCapacity(@as(u32, @intCast(macho_file.globals.items.len)));
     var alive = AtomTable.init(arena.allocator());
-    try alive.ensureTotalCapacity(@as(u32, @intCast(zld.atoms.items.len)));
+    try alive.ensureTotalCapacity(@as(u32, @intCast(macho_file.atoms.items.len)));
-    try collectRoots(zld, &roots);
+    try collectRoots(macho_file, &roots);
-    try mark(zld, roots, &alive);
+    try mark(macho_file, roots, &alive);
-    prune(zld, alive);
+    prune(macho_file, alive);
 }
-fn addRoot(zld: *Zld, roots: *AtomTable, file: u32, sym_loc: SymbolWithLoc) !void {
+fn addRoot(macho_file: *MachO, roots: *AtomTable, file: u32, sym_loc: SymbolWithLoc) !void {
-    const sym = zld.getSymbol(sym_loc);
+    const sym = macho_file.getSymbol(sym_loc);
     assert(!sym.undf());
-    const object = &zld.objects.items[file];
+    const object = &macho_file.objects.items[file];
     const atom_index = object.getAtomIndexForSymbol(sym_loc.sym_index).?; // panic here means fatal error
     log.debug("root(ATOM({d}, %{d}, {d}))", .{
         atom_index,
-        zld.getAtom(atom_index).sym_index,
+        macho_file.getAtom(atom_index).sym_index,
         file,
     });
     _ = try roots.getOrPut(atom_index);
 }
-fn collectRoots(zld: *Zld, roots: *AtomTable) !void {
+fn collectRoots(macho_file: *MachO, roots: *AtomTable) !void {
     log.debug("collecting roots", .{});
-    switch (zld.options.output_mode) {
+    switch (macho_file.base.options.output_mode) {
         .Exe => {
             // Add entrypoint as GC root
-            const global: SymbolWithLoc = zld.getEntryPoint();
+            const global: SymbolWithLoc = macho_file.getEntryPoint();
             if (global.getFile()) |file| {
-                try addRoot(zld, roots, file, global);
+                try addRoot(macho_file, roots, file, global);
             } else {
-                assert(zld.getSymbol(global).undf()); // Stub as our entrypoint is in a dylib.
+                assert(macho_file.getSymbol(global).undf()); // Stub as our entrypoint is in a dylib.
             }
         },
         else => |other| {
             assert(other == .Lib);
             // Add exports as GC roots
-            for (zld.globals.items) |global| {
+            for (macho_file.globals.items) |global| {
-                const sym = zld.getSymbol(global);
+                const sym = macho_file.getSymbol(global);
                 if (sym.undf()) continue;
                 if (global.getFile()) |file| {
-                    try addRoot(zld, roots, file, global);
+                    try addRoot(macho_file, roots, file, global);
                 }
             }
         },
     }
     // Add all symbols force-defined by the user.
-    for (zld.options.force_undefined_symbols.keys()) |sym_name| {
+    for (macho_file.base.options.force_undefined_symbols.keys()) |sym_name| {
-        const global_index = zld.resolver.get(sym_name).?;
+        const global_index = macho_file.resolver.get(sym_name).?;
-        const global = zld.globals.items[global_index];
+        const global = macho_file.globals.items[global_index];
-        const sym = zld.getSymbol(global);
+        const sym = macho_file.getSymbol(global);
         assert(!sym.undf());
-        try addRoot(zld, roots, global.getFile().?, global);
+        try addRoot(macho_file, roots, global.getFile().?, global);
     }
-    for (zld.objects.items) |object| {
+    for (macho_file.objects.items) |object| {
         const has_subsections = object.header.flags & macho.MH_SUBSECTIONS_VIA_SYMBOLS != 0;
         for (object.atoms.items) |atom_index| {
 @@ -92,7 +75,7 @@ fn collectRoots(zld: *Zld, roots: *AtomTable) !void {
                 // as a root.
                 if (!has_subsections) break :blk true;
-                const atom = zld.getAtom(atom_index);
+                const atom = macho_file.getAtom(atom_index);
                 const sect_id = if (object.getSourceSymbol(atom.sym_index)) |source_sym|
                     source_sym.n_sect - 1
                 else sect_id: {
 @@ -115,39 +98,39 @@ fn collectRoots(zld: *Zld, roots: *AtomTable) !void {
                 log.debug("root(ATOM({d}, %{d}, {?d}))", .{
                     atom_index,
-                    zld.getAtom(atom_index).sym_index,
+                    macho_file.getAtom(atom_index).sym_index,
-                    zld.getAtom(atom_index).getFile(),
+                    macho_file.getAtom(atom_index).getFile(),
                 });
             }
         }
     }
 }
-fn markLive(zld: *Zld, atom_index: Atom.Index, alive: *AtomTable) void {
+fn markLive(macho_file: *MachO, atom_index: Atom.Index, alive: *AtomTable) void {
     if (alive.contains(atom_index)) return;
-    const atom = zld.getAtom(atom_index);
+    const atom = macho_file.getAtom(atom_index);
     const sym_loc = atom.getSymbolWithLoc();
     log.debug("mark(ATOM({d}, %{d}, {?d}))", .{ atom_index, sym_loc.sym_index, sym_loc.getFile() });
     alive.putAssumeCapacityNoClobber(atom_index, {});
-    const cpu_arch = zld.options.target.cpu.arch;
+    const cpu_arch = macho_file.options.target.cpu.arch;
-    const sym = zld.getSymbol(atom.getSymbolWithLoc());
+    const sym = macho_file.getSymbol(atom.getSymbolWithLoc());
-    const header = zld.sections.items(.header)[sym.n_sect - 1];
+    const header = macho_file.sections.items(.header)[sym.n_sect - 1];
     if (header.isZerofill()) return;
-    const code = Atom.getAtomCode(zld, atom_index);
+    const code = Atom.getAtomCode(macho_file, atom_index);
-    const relocs = Atom.getAtomRelocs(zld, atom_index);
+    const relocs = Atom.getAtomRelocs(macho_file, atom_index);
-    const ctx = Atom.getRelocContext(zld, atom_index);
+    const ctx = Atom.getRelocContext(macho_file, atom_index);
     for (relocs) |rel| {
         const target = switch (cpu_arch) {
             .aarch64 => switch (@as(macho.reloc_type_arm64, @enumFromInt(rel.r_type))) {
                 .ARM64_RELOC_ADDEND => continue,
-                else => Atom.parseRelocTarget(zld, .{
+                else => Atom.parseRelocTarget(macho_file, .{
                     .object_id = atom.getFile().?,
                     .rel = rel,
                     .code = code,
 @@ -155,7 +138,7 @@ fn markLive(zld: *Zld, atom_index: Atom.Index, alive: *AtomTable) void {
                     .base_addr = ctx.base_addr,
                 }),
             },
-            .x86_64 => Atom.parseRelocTarget(zld, .{
+            .x86_64 => Atom.parseRelocTarget(macho_file, .{
                 .object_id = atom.getFile().?,
                 .rel = rel,
                 .code = code,
 @@ -164,50 +147,50 @@ fn markLive(zld: *Zld, atom_index: Atom.Index, alive: *AtomTable) void {
             }),
             else => unreachable,
         };
-        const target_sym = zld.getSymbol(target);
+        const target_sym = macho_file.getSymbol(target);
         if (target_sym.undf()) continue;
         if (target.getFile() == null) {
-            const target_sym_name = zld.getSymbolName(target);
+            const target_sym_name = macho_file.getSymbolName(target);
             if (mem.eql(u8, "__mh_execute_header", target_sym_name)) continue;
             if (mem.eql(u8, "___dso_handle", target_sym_name)) continue;
             unreachable; // referenced symbol not found
         }
-        const object = zld.objects.items[target.getFile().?];
+        const object = macho_file.objects.items[target.getFile().?];
         const target_atom_index = object.getAtomIndexForSymbol(target.sym_index).?;
         log.debug("  following ATOM({d}, %{d}, {?d})", .{
             target_atom_index,
-            zld.getAtom(target_atom_index).sym_index,
+            macho_file.getAtom(target_atom_index).sym_index,
-            zld.getAtom(target_atom_index).getFile(),
+            macho_file.getAtom(target_atom_index).getFile(),
         });
-        markLive(zld, target_atom_index, alive);
+        markLive(macho_file, target_atom_index, alive);
     }
 }
-fn refersLive(zld: *Zld, atom_index: Atom.Index, alive: AtomTable) bool {
+fn refersLive(macho_file: *MachO, atom_index: Atom.Index, alive: AtomTable) bool {
-    const atom = zld.getAtom(atom_index);
+    const atom = macho_file.getAtom(atom_index);
     const sym_loc = atom.getSymbolWithLoc();
     log.debug("refersLive(ATOM({d}, %{d}, {?d}))", .{ atom_index, sym_loc.sym_index, sym_loc.getFile() });
-    const cpu_arch = zld.options.target.cpu.arch;
+    const cpu_arch = macho_file.base.options.target.cpu.arch;
-    const sym = zld.getSymbol(sym_loc);
+    const sym = macho_file.getSymbol(sym_loc);
-    const header = zld.sections.items(.header)[sym.n_sect - 1];
+    const header = macho_file.sections.items(.header)[sym.n_sect - 1];
     assert(!header.isZerofill());
-    const code = Atom.getAtomCode(zld, atom_index);
+    const code = Atom.getAtomCode(macho_file, atom_index);
-    const relocs = Atom.getAtomRelocs(zld, atom_index);
+    const relocs = Atom.getAtomRelocs(macho_file, atom_index);
-    const ctx = Atom.getRelocContext(zld, atom_index);
+    const ctx = Atom.getRelocContext(macho_file, atom_index);
     for (relocs) |rel| {
         const target = switch (cpu_arch) {
             .aarch64 => switch (@as(macho.reloc_type_arm64, @enumFromInt(rel.r_type))) {
                 .ARM64_RELOC_ADDEND => continue,
-                else => Atom.parseRelocTarget(zld, .{
+                else => Atom.parseRelocTarget(macho_file, .{
                     .object_id = atom.getFile().?,
                     .rel = rel,
                     .code = code,
 @@ -215,7 +198,7 @@ fn refersLive(zld: *Zld, atom_index: Atom.Index, alive: AtomTable) bool {
                     .base_addr = ctx.base_addr,
                 }),
             },
-            .x86_64 => Atom.parseRelocTarget(zld, .{
+            .x86_64 => Atom.parseRelocTarget(macho_file, .{
                 .object_id = atom.getFile().?,
                 .rel = rel,
                 .code = code,
 @@ -225,16 +208,16 @@ fn refersLive(zld: *Zld, atom_index: Atom.Index, alive: AtomTable) bool {
             else => unreachable,
         };
-        const object = zld.objects.items[target.getFile().?];
+        const object = macho_file.objects.items[target.getFile().?];
         const target_atom_index = object.getAtomIndexForSymbol(target.sym_index) orelse {
-            log.debug("atom for symbol '{s}' not found; skipping...", .{zld.getSymbolName(target)});
+            log.debug("atom for symbol '{s}' not found; skipping...", .{macho_file.getSymbolName(target)});
             continue;
         };
         if (alive.contains(target_atom_index)) {
             log.debug("  refers live ATOM({d}, %{d}, {?d})", .{
                 target_atom_index,
-                zld.getAtom(target_atom_index).sym_index,
+                macho_file.getAtom(target_atom_index).sym_index,
-                zld.getAtom(target_atom_index).getFile(),
+                macho_file.getAtom(target_atom_index).getFile(),
             });
             return true;
         }
 @@ -243,21 +226,21 @@ fn refersLive(zld: *Zld, atom_index: Atom.Index, alive: AtomTable) bool {
     return false;
 }
-fn mark(zld: *Zld, roots: AtomTable, alive: *AtomTable) !void {
+fn mark(macho_file: *MachO, roots: AtomTable, alive: *AtomTable) !void {
     var it = roots.keyIterator();
     while (it.next()) |root| {
-        markLive(zld, root.*, alive);
+        markLive(macho_file, root.*, alive);
     }
     var loop: bool = true;
     while (loop) {
         loop = false;
-        for (zld.objects.items) |object| {
+        for (macho_file.objects.items) |object| {
             for (object.atoms.items) |atom_index| {
                 if (alive.contains(atom_index)) continue;
-                const atom = zld.getAtom(atom_index);
+                const atom = macho_file.getAtom(atom_index);
                 const sect_id = if (object.getSourceSymbol(atom.sym_index)) |source_sym|
                     source_sym.n_sect - 1
                 else blk: {
 @@ -268,8 +251,8 @@ fn mark(zld: *Zld, roots: AtomTable, alive: *AtomTable) !void {
                 const source_sect = object.getSourceSection(sect_id);
                 if (source_sect.isDontDeadStripIfReferencesLive()) {
-                    if (refersLive(zld, atom_index, alive.*)) {
+                    if (refersLive(macho_file, atom_index, alive.*)) {
-                        markLive(zld, atom_index, alive);
+                        markLive(macho_file, atom_index, alive);
                         loop = true;
                     }
                 }
 @@ -277,26 +260,26 @@ fn mark(zld: *Zld, roots: AtomTable, alive: *AtomTable) !void {
         }
     }
-    for (zld.objects.items, 0..) |_, object_id| {
+    for (macho_file.objects.items, 0..) |_, object_id| {
         // Traverse unwind and eh_frame records noting if the source symbol has been marked, and if so,
         // marking all references as live.
-        try markUnwindRecords(zld, @as(u32, @intCast(object_id)), alive);
+        try markUnwindRecords(macho_file, @as(u32, @intCast(object_id)), alive);
     }
 }
-fn markUnwindRecords(zld: *Zld, object_id: u32, alive: *AtomTable) !void {
+fn markUnwindRecords(macho_file: *MachO, object_id: u32, alive: *AtomTable) !void {
-    const object = &zld.objects.items[object_id];
+    const object = &macho_file.objects.items[object_id];
-    const cpu_arch = zld.options.target.cpu.arch;
+    const cpu_arch = macho_file.base.options.target.cpu.arch;
     const unwind_records = object.getUnwindRecords();
     for (object.exec_atoms.items) |atom_index| {
-        var inner_syms_it = Atom.getInnerSymbolsIterator(zld, atom_index);
+        var inner_syms_it = Atom.getInnerSymbolsIterator(macho_file, atom_index);
         if (!object.hasUnwindRecords()) {
             if (alive.contains(atom_index)) {
                 // Mark references live and continue.
-                try markEhFrameRecords(zld, object_id, atom_index, alive);
+                try markEhFrameRecords(macho_file, object_id, atom_index, alive);
             } else {
                 while (inner_syms_it.next()) |sym| {
                     if (object.eh_frame_records_lookup.get(sym)) |fde_offset| {
 @@ -322,51 +305,51 @@ fn markUnwindRecords(zld: *Zld, object_id: u32, alive: *AtomTable) !void {
             const record = unwind_records[record_id];
             if (UnwindInfo.UnwindEncoding.isDwarf(record.compactUnwindEncoding, cpu_arch)) {
-                try markEhFrameRecords(zld, object_id, atom_index, alive);
+                try markEhFrameRecords(macho_file, object_id, atom_index, alive);
             } else {
-                if (UnwindInfo.getPersonalityFunctionReloc(zld, object_id, record_id)) |rel| {
+                if (UnwindInfo.getPersonalityFunctionReloc(macho_file, object_id, record_id)) |rel| {
-                    const target = Atom.parseRelocTarget(zld, .{
+                    const target = Atom.parseRelocTarget(macho_file, .{
                         .object_id = object_id,
                         .rel = rel,
                         .code = mem.asBytes(&record),
                         .base_offset = @as(i32, @intCast(record_id * @sizeOf(macho.compact_unwind_entry))),
                     });
-                    const target_sym = zld.getSymbol(target);
+                    const target_sym = macho_file.getSymbol(target);
                     if (!target_sym.undf()) {
-                        const target_object = zld.objects.items[target.getFile().?];
+                        const target_object = macho_file.objects.items[target.getFile().?];
                         const target_atom_index = target_object.getAtomIndexForSymbol(target.sym_index).?;
-                        markLive(zld, target_atom_index, alive);
+                        markLive(macho_file, target_atom_index, alive);
                     }
                 }
-                if (UnwindInfo.getLsdaReloc(zld, object_id, record_id)) |rel| {
+                if (UnwindInfo.getLsdaReloc(macho_file, object_id, record_id)) |rel| {
-                    const target = Atom.parseRelocTarget(zld, .{
+                    const target = Atom.parseRelocTarget(macho_file, .{
                         .object_id = object_id,
                         .rel = rel,
                         .code = mem.asBytes(&record),
                         .base_offset = @as(i32, @intCast(record_id * @sizeOf(macho.compact_unwind_entry))),
                     });
-                    const target_object = zld.objects.items[target.getFile().?];
+                    const target_object = macho_file.objects.items[target.getFile().?];
                     const target_atom_index = target_object.getAtomIndexForSymbol(target.sym_index).?;
-                    markLive(zld, target_atom_index, alive);
+                    markLive(macho_file, target_atom_index, alive);
                 }
             }
         }
     }
 }
-fn markEhFrameRecords(zld: *Zld, object_id: u32, atom_index: Atom.Index, alive: *AtomTable) !void {
+fn markEhFrameRecords(macho_file: *MachO, object_id: u32, atom_index: Atom.Index, alive: *AtomTable) !void {
-    const cpu_arch = zld.options.target.cpu.arch;
+    const cpu_arch = macho_file.base.options.target.cpu.arch;
-    const object = &zld.objects.items[object_id];
+    const object = &macho_file.objects.items[object_id];
     var it = object.getEhFrameRecordsIterator();
-    var inner_syms_it = Atom.getInnerSymbolsIterator(zld, atom_index);
+    var inner_syms_it = Atom.getInnerSymbolsIterator(macho_file, atom_index);
     while (inner_syms_it.next()) |sym| {
         const fde_offset = object.eh_frame_records_lookup.get(sym) orelse continue; // Continue in case we hit a temp symbol alias
         it.seekTo(fde_offset);
         const fde = (try it.next()).?;
-        const cie_ptr = fde.getCiePointerSource(object_id, zld, fde_offset);
+        const cie_ptr = fde.getCiePointerSource(object_id, macho_file, fde_offset);
         const cie_offset = fde_offset + 4 - cie_ptr;
         it.seekTo(cie_offset);
         const cie = (try it.next()).?;
 @@ -374,20 +357,20 @@ fn markEhFrameRecords(zld: *Zld, object_id: u32, atom_index: Atom.Index, alive:
         switch (cpu_arch) {
             .aarch64 => {
                 // Mark FDE references which should include any referenced LSDA record
-                const relocs = eh_frame.getRelocs(zld, object_id, fde_offset);
+                const relocs = eh_frame.getRelocs(macho_file, object_id, fde_offset);
                 for (relocs) |rel| {
-                    const target = Atom.parseRelocTarget(zld, .{
+                    const target = Atom.parseRelocTarget(macho_file, .{
                         .object_id = object_id,
                         .rel = rel,
                         .code = fde.data,
                         .base_offset = @as(i32, @intCast(fde_offset)) + 4,
                     });
-                    const target_sym = zld.getSymbol(target);
+                    const target_sym = macho_file.getSymbol(target);
                     if (!target_sym.undf()) blk: {
-                        const target_object = zld.objects.items[target.getFile().?];
+                        const target_object = macho_file.objects.items[target.getFile().?];
                         const target_atom_index = target_object.getAtomIndexForSymbol(target.sym_index) orelse
                             break :blk;
-                        markLive(zld, target_atom_index, alive);
+                        markLive(macho_file, target_atom_index, alive);
                     }
                 }
             },
 @@ -401,7 +384,7 @@ fn markEhFrameRecords(zld: *Zld, object_id: u32, atom_index: Atom.Index, alive:
                     // Mark LSDA record as live
                     const sym_index = object.getSymbolByAddress(lsda_address, null);
                     const target_atom_index = object.getAtomIndexForSymbol(sym_index).?;
-                    markLive(zld, target_atom_index, alive);
+                    markLive(macho_file, target_atom_index, alive);
                 }
             },
             else => unreachable,
 @@ -409,20 +392,20 @@ fn markEhFrameRecords(zld: *Zld, object_id: u32, atom_index: Atom.Index, alive:
         // Mark CIE references which should include any referenced personalities
         // that are defined locally.
-        if (cie.getPersonalityPointerReloc(zld, object_id, cie_offset)) |target| {
+        if (cie.getPersonalityPointerReloc(macho_file, object_id, cie_offset)) |target| {
-            const target_sym = zld.getSymbol(target);
+            const target_sym = macho_file.getSymbol(target);
             if (!target_sym.undf()) {
-                const target_object = zld.objects.items[target.getFile().?];
+                const target_object = macho_file.objects.items[target.getFile().?];
                 const target_atom_index = target_object.getAtomIndexForSymbol(target.sym_index).?;
-                markLive(zld, target_atom_index, alive);
+                markLive(macho_file, target_atom_index, alive);
             }
         }
     }
 }
-fn prune(zld: *Zld, alive: AtomTable) void {
+fn prune(macho_file: *MachO, alive: AtomTable) void {
     log.debug("pruning dead atoms", .{});
-    for (zld.objects.items) |*object| {
+    for (macho_file.objects.items) |*object| {
         var i: usize = 0;
         while (i < object.atoms.items.len) {
             const atom_index = object.atoms.items[i];
 @@ -431,7 +414,7 @@ fn prune(zld: *Zld, alive: AtomTable) void {
                 continue;
             }
-            const atom = zld.getAtom(atom_index);
+            const atom = macho_file.getAtom(atom_index);
             const sym_loc = atom.getSymbolWithLoc();
             log.debug("prune(ATOM({d}, %{d}, {?d}))", .{
 @@ -439,15 +422,15 @@ fn prune(zld: *Zld, alive: AtomTable) void {
                 sym_loc.sym_index,
                 sym_loc.getFile(),
             });
-            log.debug("  {s} in {s}", .{ zld.getSymbolName(sym_loc), object.name });
+            log.debug("  {s} in {s}", .{ macho_file.getSymbolName(sym_loc), object.name });
-            const sym = zld.getSymbolPtr(sym_loc);
+            const sym = macho_file.getSymbolPtr(sym_loc);
             const sect_id = sym.n_sect - 1;
-            var section = zld.sections.get(sect_id);
+            var section = macho_file.sections.get(sect_id);
             section.header.size -= atom.size;
             if (atom.prev_index) |prev_index| {
-                const prev = zld.getAtomPtr(prev_index);
+                const prev = macho_file.getAtomPtr(prev_index);
                 prev.next_index = atom.next_index;
             } else {
                 if (atom.next_index) |next_index| {
 @@ -455,7 +438,7 @@ fn prune(zld: *Zld, alive: AtomTable) void {
                 }
             }
             if (atom.next_index) |next_index| {
-                const next = zld.getAtomPtr(next_index);
+                const next = macho_file.getAtomPtr(next_index);
                 next.prev_index = atom.prev_index;
             } else {
                 if (atom.prev_index) |prev_index| {
 @@ -467,21 +450,37 @@ fn prune(zld: *Zld, alive: AtomTable) void {
                 }
             }
-            zld.sections.set(sect_id, section);
+            macho_file.sections.set(sect_id, section);
             _ = object.atoms.swapRemove(i);
             sym.n_desc = MachO.N_DEAD;
-            var inner_sym_it = Atom.getInnerSymbolsIterator(zld, atom_index);
+            var inner_sym_it = Atom.getInnerSymbolsIterator(macho_file, atom_index);
             while (inner_sym_it.next()) |inner| {
-                const inner_sym = zld.getSymbolPtr(inner);
+                const inner_sym = macho_file.getSymbolPtr(inner);
                 inner_sym.n_desc = MachO.N_DEAD;
             }
-            if (Atom.getSectionAlias(zld, atom_index)) |alias| {
+            if (Atom.getSectionAlias(macho_file, atom_index)) |alias| {
-                const alias_sym = zld.getSymbolPtr(alias);
+                const alias_sym = macho_file.getSymbolPtr(alias);
                 alias_sym.n_desc = MachO.N_DEAD;
             }
         }
     }
 }
+const std = @import("std");
+const assert = std.debug.assert;
+const eh_frame = @import("eh_frame.zig");
+const log = std.log.scoped(.dead_strip);
+const macho = std.macho;
+const math = std.math;
+const mem = std.mem;
+const Allocator = mem.Allocator;
+const Atom = @import("Atom.zig");
+const MachO = @import("../MachO.zig");
+const SymbolWithLoc = MachO.SymbolWithLoc;
+const UnwindInfo = @import("UnwindInfo.zig");
+const AtomTable = std.AutoHashMap(Atom.Index, void);

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

 @@ -1,14 +1,3 @@
-const Rebase = @This();
-const std = @import("std");
-const assert = std.debug.assert;
-const leb = std.leb;
-const log = std.log.scoped(.dyld_info);
-const macho = std.macho;
-const testing = std.testing;
-const Allocator = std.mem.Allocator;
 entries: std.ArrayListUnmanaged(Entry) = .{},
 buffer: std.ArrayListUnmanaged(u8) = .{},
 @@ -572,3 +561,14 @@ test "rebase - composite" {
         macho.REBASE_OPCODE_DONE,
     }, rebase.buffer.items);
 }
+const Rebase = @This();
+const std = @import("std");
+const assert = std.debug.assert;
+const leb = std.leb;
+const log = std.log.scoped(.dyld_info);
+const macho = std.macho;
+const testing = std.testing;
+const Allocator = std.mem.Allocator;

src/link/MachO/dyld_info/bind.zig+9-9

 @@ -1,12 +1,3 @@
-const std = @import("std");
-const assert = std.debug.assert;
-const leb = std.leb;
-const log = std.log.scoped(.dyld_info);
-const macho = std.macho;
-const testing = std.testing;
-const Allocator = std.mem.Allocator;
 pub fn Bind(comptime Ctx: type, comptime Target: type) type {
     return struct {
         entries: std.ArrayListUnmanaged(Entry) = .{},
 @@ -738,3 +729,12 @@ test "lazy bind" {
         macho.BIND_OPCODE_DONE,
     }, bind.buffer.items);
 }
+const std = @import("std");
+const assert = std.debug.assert;
+const leb = std.leb;
+const log = std.log.scoped(.dyld_info);
+const macho = std.macho;
+const testing = std.testing;
+const Allocator = std.mem.Allocator;

src/link/MachO/eh_frame.zig+63-64

 @@ -1,68 +1,52 @@
-const std = @import("std");
+pub fn scanRelocs(macho_file: *MachO) !void {
-const assert = std.debug.assert;
+    const gpa = macho_file.base.allocator;
-const macho = std.macho;
-const math = std.math;
-const mem = std.mem;
-const leb = std.leb;
-const log = std.log.scoped(.eh_frame);
-const Allocator = mem.Allocator;
-const Atom = @import("Atom.zig");
-const MachO = @import("../MachO.zig");
-const Relocation = @import("Relocation.zig");
-const SymbolWithLoc = MachO.SymbolWithLoc;
-const UnwindInfo = @import("UnwindInfo.zig");
-const Zld = @import("zld.zig").Zld;
-pub fn scanRelocs(zld: *Zld) !void {
-    const gpa = zld.gpa;
-    for (zld.objects.items, 0..) |*object, object_id| {
+    for (macho_file.objects.items, 0..) |*object, object_id| {
         var cies = std.AutoHashMap(u32, void).init(gpa);
         defer cies.deinit();
         var it = object.getEhFrameRecordsIterator();
         for (object.exec_atoms.items) |atom_index| {
-            var inner_syms_it = Atom.getInnerSymbolsIterator(zld, atom_index);
+            var inner_syms_it = Atom.getInnerSymbolsIterator(macho_file, atom_index);
             while (inner_syms_it.next()) |sym| {
                 const fde_offset = object.eh_frame_records_lookup.get(sym) orelse continue;
                 if (object.eh_frame_relocs_lookup.get(fde_offset).?.dead) continue;
                 it.seekTo(fde_offset);
                 const fde = (try it.next()).?;
-                const cie_ptr = fde.getCiePointerSource(@intCast(object_id), zld, fde_offset);
+                const cie_ptr = fde.getCiePointerSource(@intCast(object_id), macho_file, fde_offset);
                 const cie_offset = fde_offset + 4 - cie_ptr;
                 if (!cies.contains(cie_offset)) {
                     try cies.putNoClobber(cie_offset, {});
                     it.seekTo(cie_offset);
                     const cie = (try it.next()).?;
-                    try cie.scanRelocs(zld, @as(u32, @intCast(object_id)), cie_offset);
+                    try cie.scanRelocs(macho_file, @as(u32, @intCast(object_id)), cie_offset);
                 }
             }
         }
     }
 }
-pub fn calcSectionSize(zld: *Zld, unwind_info: *const UnwindInfo) !void {
+pub fn calcSectionSize(macho_file: *MachO, unwind_info: *const UnwindInfo) !void {
-    const sect_id = zld.eh_frame_section_index orelse return;
+    const sect_id = macho_file.eh_frame_section_index orelse return;
-    const sect = &zld.sections.items(.header)[sect_id];
+    const sect = &macho_file.sections.items(.header)[sect_id];
     sect.@"align" = 3;
     sect.size = 0;
-    const cpu_arch = zld.options.target.cpu.arch;
+    const cpu_arch = macho_file.base.options.target.cpu.arch;
-    const gpa = zld.gpa;
+    const gpa = macho_file.base.allocator;
     var size: u32 = 0;
-    for (zld.objects.items, 0..) |*object, object_id| {
+    for (macho_file.objects.items, 0..) |*object, object_id| {
         var cies = std.AutoHashMap(u32, u32).init(gpa);
         defer cies.deinit();
         var eh_it = object.getEhFrameRecordsIterator();
         for (object.exec_atoms.items) |atom_index| {
-            var inner_syms_it = Atom.getInnerSymbolsIterator(zld, atom_index);
+            var inner_syms_it = Atom.getInnerSymbolsIterator(macho_file, atom_index);
             while (inner_syms_it.next()) |sym| {
                 const fde_record_offset = object.eh_frame_records_lookup.get(sym) orelse continue;
                 if (object.eh_frame_relocs_lookup.get(fde_record_offset).?.dead) continue;
 @@ -77,7 +61,7 @@ pub fn calcSectionSize(zld: *Zld, unwind_info: *const UnwindInfo) !void {
                 eh_it.seekTo(fde_record_offset);
                 const source_fde_record = (try eh_it.next()).?;
-                const cie_ptr = source_fde_record.getCiePointerSource(@intCast(object_id), zld, fde_record_offset);
+                const cie_ptr = source_fde_record.getCiePointerSource(@intCast(object_id), macho_file, fde_record_offset);
                 const cie_offset = fde_record_offset + 4 - cie_ptr;
                 const gop = try cies.getOrPut(cie_offset);
 @@ -96,14 +80,14 @@ pub fn calcSectionSize(zld: *Zld, unwind_info: *const UnwindInfo) !void {
     }
 }
-pub fn write(zld: *Zld, unwind_info: *UnwindInfo) !void {
+pub fn write(macho_file: *MachO, unwind_info: *UnwindInfo) !void {
-    const sect_id = zld.eh_frame_section_index orelse return;
+    const sect_id = macho_file.eh_frame_section_index orelse return;
-    const sect = zld.sections.items(.header)[sect_id];
+    const sect = macho_file.sections.items(.header)[sect_id];
-    const seg_id = zld.sections.items(.segment_index)[sect_id];
+    const seg_id = macho_file.sections.items(.segment_index)[sect_id];
-    const seg = zld.segments.items[seg_id];
+    const seg = macho_file.segments.items[seg_id];
-    const cpu_arch = zld.options.target.cpu.arch;
+    const cpu_arch = macho_file.base.options.target.cpu.arch;
-    const gpa = zld.gpa;
+    const gpa = macho_file.base.allocator;
     var eh_records = std.AutoArrayHashMap(u32, EhFrameRecord(true)).init(gpa);
     defer {
 @@ -115,7 +99,7 @@ pub fn write(zld: *Zld, unwind_info: *UnwindInfo) !void {
     var eh_frame_offset: u32 = 0;
-    for (zld.objects.items, 0..) |*object, object_id| {
+    for (macho_file.objects.items, 0..) |*object, object_id| {
         try eh_records.ensureUnusedCapacity(2 * @as(u32, @intCast(object.exec_atoms.items.len)));
         var cies = std.AutoHashMap(u32, u32).init(gpa);
 @@ -124,7 +108,7 @@ pub fn write(zld: *Zld, unwind_info: *UnwindInfo) !void {
         var eh_it = object.getEhFrameRecordsIterator();
         for (object.exec_atoms.items) |atom_index| {
-            var inner_syms_it = Atom.getInnerSymbolsIterator(zld, atom_index);
+            var inner_syms_it = Atom.getInnerSymbolsIterator(macho_file, atom_index);
             while (inner_syms_it.next()) |target| {
                 const fde_record_offset = object.eh_frame_records_lookup.get(target) orelse continue;
                 if (object.eh_frame_relocs_lookup.get(fde_record_offset).?.dead) continue;
 @@ -139,7 +123,7 @@ pub fn write(zld: *Zld, unwind_info: *UnwindInfo) !void {
                 eh_it.seekTo(fde_record_offset);
                 const source_fde_record = (try eh_it.next()).?;
-                const cie_ptr = source_fde_record.getCiePointerSource(@intCast(object_id), zld, fde_record_offset);
+                const cie_ptr = source_fde_record.getCiePointerSource(@intCast(object_id), macho_file, fde_record_offset);
                 const cie_offset = fde_record_offset + 4 - cie_ptr;
                 const gop = try cies.getOrPut(cie_offset);
 @@ -147,7 +131,7 @@ pub fn write(zld: *Zld, unwind_info: *UnwindInfo) !void {
                     eh_it.seekTo(cie_offset);
                     const source_cie_record = (try eh_it.next()).?;
                     var cie_record = try source_cie_record.toOwned(gpa);
-                    try cie_record.relocate(zld, @as(u32, @intCast(object_id)), .{
+                    try cie_record.relocate(macho_file, @as(u32, @intCast(object_id)), .{
                         .source_offset = cie_offset,
                         .out_offset = eh_frame_offset,
                         .sect_addr = sect.addr,
 @@ -158,7 +142,7 @@ pub fn write(zld: *Zld, unwind_info: *UnwindInfo) !void {
                 }
                 var fde_record = try source_fde_record.toOwned(gpa);
-                try fde_record.relocate(zld, @as(u32, @intCast(object_id)), .{
+                try fde_record.relocate(macho_file, @as(u32, @intCast(object_id)), .{
                     .source_offset = fde_record_offset,
                     .out_offset = eh_frame_offset,
                     .sect_addr = sect.addr,
 @@ -169,7 +153,7 @@ pub fn write(zld: *Zld, unwind_info: *UnwindInfo) !void {
                     .aarch64 => {}, // relocs take care of LSDA pointers
                     .x86_64 => {
                         // We need to relocate target symbol address ourselves.
-                        const atom_sym = zld.getSymbol(target);
+                        const atom_sym = macho_file.getSymbol(target);
                         try fde_record.setTargetSymbolAddress(atom_sym.n_value, .{
                             .base_addr = sect.addr,
                             .base_offset = eh_frame_offset,
 @@ -229,7 +213,7 @@ pub fn write(zld: *Zld, unwind_info: *UnwindInfo) !void {
         try buffer.appendSlice(record.data);
     }
-    try zld.file.pwriteAll(buffer.items, sect.offset);
+    try macho_file.base.file.?.pwriteAll(buffer.items, sect.offset);
 }
 const EhFrameRecordTag = enum { cie, fde };
 @@ -261,12 +245,12 @@ pub fn EhFrameRecord(comptime is_mutable: bool) type {
         pub fn scanRelocs(
             rec: Record,
-            zld: *Zld,
+            macho_file: *MachO,
             object_id: u32,
             source_offset: u32,
         ) !void {
-            if (rec.getPersonalityPointerReloc(zld, object_id, source_offset)) |target| {
+            if (rec.getPersonalityPointerReloc(macho_file, object_id, source_offset)) |target| {
-                try zld.addGotEntry(target);
+                try macho_file.addGotEntry(target);
             }
         }
 @@ -290,12 +274,12 @@ pub fn EhFrameRecord(comptime is_mutable: bool) type {
         pub fn getPersonalityPointerReloc(
             rec: Record,
-            zld: *Zld,
+            macho_file: *MachO,
             object_id: u32,
             source_offset: u32,
         ) ?SymbolWithLoc {
-            const cpu_arch = zld.options.target.cpu.arch;
+            const cpu_arch = macho_file.base.options.target.cpu.arch;
-            const relocs = getRelocs(zld, object_id, source_offset);
+            const relocs = getRelocs(macho_file, object_id, source_offset);
             for (relocs) |rel| {
                 switch (cpu_arch) {
                     .aarch64 => {
 @@ -317,7 +301,7 @@ pub fn EhFrameRecord(comptime is_mutable: bool) type {
                     },
                     else => unreachable,
                 }
-                const target = Atom.parseRelocTarget(zld, .{
+                const target = Atom.parseRelocTarget(macho_file, .{
                     .object_id = object_id,
                     .rel = rel,
                     .code = rec.data,
 @@ -328,18 +312,18 @@ pub fn EhFrameRecord(comptime is_mutable: bool) type {
             return null;
         }
-        pub fn relocate(rec: *Record, zld: *Zld, object_id: u32, ctx: struct {
+        pub fn relocate(rec: *Record, macho_file: *MachO, object_id: u32, ctx: struct {
             source_offset: u32,
             out_offset: u32,
             sect_addr: u64,
         }) !void {
             comptime assert(is_mutable);
-            const cpu_arch = zld.options.target.cpu.arch;
+            const cpu_arch = macho_file.base.options.target.cpu.arch;
-            const relocs = getRelocs(zld, object_id, ctx.source_offset);
+            const relocs = getRelocs(macho_file, object_id, ctx.source_offset);
             for (relocs) |rel| {
-                const target = Atom.parseRelocTarget(zld, .{
+                const target = Atom.parseRelocTarget(macho_file, .{
                     .object_id = object_id,
                     .rel = rel,
                     .code = rec.data,
 @@ -356,14 +340,14 @@ pub fn EhFrameRecord(comptime is_mutable: bool) type {
                                 // Address of the __eh_frame in the source object file
                             },
                             .ARM64_RELOC_POINTER_TO_GOT => {
-                                const target_addr = zld.getGotEntryAddress(target).?;
+                                const target_addr = macho_file.getGotEntryAddress(target).?;
                                 const result = math.cast(i32, @as(i64, @intCast(target_addr)) - @as(i64, @intCast(source_addr))) orelse
                                     return error.Overflow;
                                 mem.writeIntLittle(i32, rec.data[rel_offset..][0..4], result);
                             },
                             .ARM64_RELOC_UNSIGNED => {
                                 assert(rel.r_extern == 1);
-                                const target_addr = try Atom.getRelocTargetAddress(zld, target, false);
+                                const target_addr = try Atom.getRelocTargetAddress(macho_file, target, false);
                                 const result = @as(i64, @intCast(target_addr)) - @as(i64, @intCast(source_addr));
                                 mem.writeIntLittle(i64, rec.data[rel_offset..][0..8], @as(i64, @intCast(result)));
                             },
 @@ -374,7 +358,7 @@ pub fn EhFrameRecord(comptime is_mutable: bool) type {
                         const rel_type = @as(macho.reloc_type_x86_64, @enumFromInt(rel.r_type));
                         switch (rel_type) {
                             .X86_64_RELOC_GOT => {
-                                const target_addr = zld.getGotEntryAddress(target).?;
+                                const target_addr = macho_file.getGotEntryAddress(target).?;
                                 const addend = mem.readIntLittle(i32, rec.data[rel_offset..][0..4]);
                                 const adjusted_target_addr = @as(u64, @intCast(@as(i64, @intCast(target_addr)) + addend));
                                 const disp = try Relocation.calcPcRelativeDisplacementX86(source_addr, adjusted_target_addr, 0);
 @@ -388,20 +372,20 @@ pub fn EhFrameRecord(comptime is_mutable: bool) type {
             }
         }
-        pub fn getCiePointerSource(rec: Record, object_id: u32, zld: *Zld, offset: u32) u32 {
+        pub fn getCiePointerSource(rec: Record, object_id: u32, macho_file: *MachO, offset: u32) u32 {
             assert(rec.tag == .fde);
-            const cpu_arch = zld.options.target.cpu.arch;
+            const cpu_arch = macho_file.base.options.target.cpu.arch;
             const addend = mem.readIntLittle(u32, rec.data[0..4]);
             switch (cpu_arch) {
                 .aarch64 => {
-                    const relocs = getRelocs(zld, object_id, offset);
+                    const relocs = getRelocs(macho_file, object_id, offset);
                     const maybe_rel = for (relocs) |rel| {
                         if (rel.r_address - @as(i32, @intCast(offset)) == 4 and
                             @as(macho.reloc_type_arm64, @enumFromInt(rel.r_type)) == .ARM64_RELOC_SUBTRACTOR)
                             break rel;
                     } else null;
                     const rel = maybe_rel orelse return addend;
-                    const object = &zld.objects.items[object_id];
+                    const object = &macho_file.objects.items[object_id];
                     const target_addr = object.in_symtab.?[rel.r_symbolnum].n_value;
                     const sect = object.getSourceSection(object.eh_frame_sect_id.?);
                     return @intCast(sect.addr + offset - target_addr + addend);
 @@ -583,8 +567,8 @@ pub fn EhFrameRecord(comptime is_mutable: bool) type {
     };
 }
-pub fn getRelocs(zld: *Zld, object_id: u32, source_offset: u32) []const macho.relocation_info {
+pub fn getRelocs(macho_file: *MachO, object_id: u32, source_offset: u32) []const macho.relocation_info {
-    const object = &zld.objects.items[object_id];
+    const object = &macho_file.objects.items[object_id];
     assert(object.hasEhFrameRecords());
     const urel = object.eh_frame_relocs_lookup.get(source_offset) orelse
         return &[0]macho.relocation_info{};
 @@ -650,3 +634,18 @@ pub const EH_PE = struct {
     pub const indirect = 0x80;
     pub const omit = 0xFF;
 };
+const std = @import("std");
+const assert = std.debug.assert;
+const macho = std.macho;
+const math = std.math;
+const mem = std.mem;
+const leb = std.leb;
+const log = std.log.scoped(.eh_frame);
+const Allocator = mem.Allocator;
+const Atom = @import("Atom.zig");
+const MachO = @import("../MachO.zig");
+const Relocation = @import("Relocation.zig");
+const SymbolWithLoc = MachO.SymbolWithLoc;
+const UnwindInfo = @import("UnwindInfo.zig");

src/link/MachO/fat.zig+6-6

 @@ -1,9 +1,3 @@
-const std = @import("std");
-const assert = std.debug.assert;
-const log = std.log.scoped(.archive);
-const macho = std.macho;
-const mem = std.mem;
 pub fn isFatLibrary(file: std.fs.File) bool {
     const reader = file.reader();
     const hdr = reader.readStructBig(macho.fat_header) catch return false;
 @@ -38,3 +32,9 @@ pub fn parseArchs(file: std.fs.File, buffer: *[2]Arch) ![]const Arch {
     return buffer[0..count];
 }
+const std = @import("std");
+const assert = std.debug.assert;
+const log = std.log.scoped(.archive);
+const macho = std.macho;
+const mem = std.mem;

src/link/MachO/hasher.zig+9-9

 @@ -1,12 +1,3 @@
-const std = @import("std");
-const assert = std.debug.assert;
-const fs = std.fs;
-const mem = std.mem;
-const Allocator = mem.Allocator;
-const ThreadPool = std.Thread.Pool;
-const WaitGroup = std.Thread.WaitGroup;
 pub fn ParallelHasher(comptime Hasher: type) type {
     const hash_size = Hasher.digest_length;
 @@ -69,3 +60,12 @@ pub fn ParallelHasher(comptime Hasher: type) type {
         const Self = @This();
     };
 }
+const std = @import("std");
+const assert = std.debug.assert;
+const fs = std.fs;
+const mem = std.mem;
+const Allocator = mem.Allocator;
+const ThreadPool = std.Thread.Pool;
+const WaitGroup = std.Thread.WaitGroup;

src/link/MachO/load_commands.zig+10-10

 @@ -1,13 +1,3 @@
-const std = @import("std");
-const assert = std.debug.assert;
-const link = @import("../../link.zig");
-const log = std.log.scoped(.link);
-const macho = std.macho;
-const mem = std.mem;
-const Allocator = mem.Allocator;
-const Dylib = @import("Dylib.zig");
 /// Default implicit entrypoint symbol name.
 pub const default_entry_point: []const u8 = "_main";
 @@ -374,3 +364,13 @@ test "parseSdkVersion" {
     try expect(parseSdkVersion("11") == null);
 }
+const std = @import("std");
+const assert = std.debug.assert;
+const link = @import("../../link.zig");
+const log = std.log.scoped(.link);
+const macho = std.macho;
+const mem = std.mem;
+const Allocator = mem.Allocator;
+const Dylib = @import("Dylib.zig");

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

...	@@ -1,8 +1,3 @@	...	@@ -1,8 +1,3 @@
1	const std = @import("std");
2	const aarch64 = @import("../../arch/aarch64/bits.zig");
3
4	const Relocation = @import("Relocation.zig");
5
6	pub inline fn stubHelperPreambleSize(cpu_arch: std.Target.Cpu.Arch) u8 {	1	pub inline fn stubHelperPreambleSize(cpu_arch: std.Target.Cpu.Arch) u8 {
7	return switch (cpu_arch) {	2	return switch (cpu_arch) {
8	.x86_64 => 15,	3	.x86_64 => 15,
...	@@ -167,3 +162,8 @@ pub fn writeStubCode(args: struct {	...	@@ -167,3 +162,8 @@ pub fn writeStubCode(args: struct {
167	else => unreachable,	162	else => unreachable,
168	}	163	}
169	}	164	}
		165
		166	const std = @import("std");
		167	const aarch64 = @import("../../arch/aarch64/bits.zig");
		168
		169	const Relocation = @import("Relocation.zig");

src/link/MachO/thunks.zig+84-85

 @@ -5,22 +5,6 @@
 //! The algorithm works pessimistically and assumes that any reference to an Atom in
 //! another output section is out of range.
-const std = @import("std");
-const assert = std.debug.assert;
-const log = std.log.scoped(.thunks);
-const macho = std.macho;
-const math = std.math;
-const mem = std.mem;
-const aarch64 = @import("../../arch/aarch64/bits.zig");
-const Allocator = mem.Allocator;
-const Atom = @import("Atom.zig");
-const MachO = @import("../MachO.zig");
-const Relocation = @import("Relocation.zig");
-const SymbolWithLoc = MachO.SymbolWithLoc;
-const Zld = @import("zld.zig").Zld;
 /// Branch instruction has 26 bits immediate but 4 byte aligned.
 const jump_bits = @bitSizeOf(i28);
 @@ -74,18 +58,18 @@ pub const Thunk = struct {
         return @alignOf(u32);
     }
-    pub fn getTrampoline(self: Thunk, zld: *Zld, tag: Tag, target: SymbolWithLoc) ?SymbolWithLoc {
+    pub fn getTrampoline(self: Thunk, macho_file: *MachO, tag: Tag, target: SymbolWithLoc) ?SymbolWithLoc {
         const atom_index = self.lookup.get(.{ .tag = tag, .target = target }) orelse return null;
-        return zld.getAtom(atom_index).getSymbolWithLoc();
+        return macho_file.getAtom(atom_index).getSymbolWithLoc();
     }
 };
-pub fn createThunks(zld: *Zld, sect_id: u8) !void {
+pub fn createThunks(macho_file: *MachO, sect_id: u8) !void {
-    const header = &zld.sections.items(.header)[sect_id];
+    const header = &macho_file.sections.items(.header)[sect_id];
     if (header.size == 0) return;
-    const gpa = zld.gpa;
+    const gpa = macho_file.base.allocator;
-    const first_atom_index = zld.sections.items(.first_atom_index)[sect_id].?;
+    const first_atom_index = macho_file.sections.items(.first_atom_index)[sect_id].?;
     header.size = 0;
     header.@"align" = 0;
 @@ -95,8 +79,8 @@ pub fn createThunks(zld: *Zld, sect_id: u8) !void {
     {
         var atom_index = first_atom_index;
         while (true) {
-            const atom = zld.getAtom(atom_index);
+            const atom = macho_file.getAtom(atom_index);
-            const sym = zld.getSymbolPtr(atom.getSymbolWithLoc());
+            const sym = macho_file.getSymbolPtr(atom.getSymbolWithLoc());
             sym.n_value = 0;
             atom_count += 1;
 @@ -115,24 +99,24 @@ pub fn createThunks(zld: *Zld, sect_id: u8) !void {
     var offset: u64 = 0;
     while (true) {
-        const group_start_atom = zld.getAtom(group_start);
+        const group_start_atom = macho_file.getAtom(group_start);
         log.debug("GROUP START at {d}", .{group_start});
         while (true) {
-            const atom = zld.getAtom(group_end);
+            const atom = macho_file.getAtom(group_end);
             offset = mem.alignForward(u64, offset, try math.powi(u32, 2, atom.alignment));
-            const sym = zld.getSymbolPtr(atom.getSymbolWithLoc());
+            const sym = macho_file.getSymbolPtr(atom.getSymbolWithLoc());
             sym.n_value = offset;
             offset += atom.size;
-            zld.logAtom(group_end, log);
+            macho_file.logAtom(group_end, log);
             header.@"align" = @max(header.@"align", atom.alignment);
             allocated.putAssumeCapacityNoClobber(group_end, {});
-            const group_start_sym = zld.getSymbol(group_start_atom.getSymbolWithLoc());
+            const group_start_sym = macho_file.getSymbol(group_start_atom.getSymbolWithLoc());
             if (offset - group_start_sym.n_value >= max_allowed_distance) break;
             if (atom.next_index) |next_index| {
 @@ -142,15 +126,15 @@ pub fn createThunks(zld: *Zld, sect_id: u8) !void {
         log.debug("GROUP END at {d}", .{group_end});
         // Insert thunk at group_end
-        const thunk_index = @as(u32, @intCast(zld.thunks.items.len));
+        const thunk_index = @as(u32, @intCast(macho_file.thunks.items.len));
-        try zld.thunks.append(gpa, .{ .start_index = undefined, .len = 0 });
+        try macho_file.thunks.append(gpa, .{ .start_index = undefined, .len = 0 });
         // Scan relocs in the group and create trampolines for any unreachable callsite.
         var atom_index = group_start;
         while (true) {
-            const atom = zld.getAtom(atom_index);
+            const atom = macho_file.getAtom(atom_index);
             try scanRelocs(
-                zld,
+                macho_file,
                 atom_index,
                 allocated,
                 thunk_index,
 @@ -165,19 +149,19 @@ pub fn createThunks(zld: *Zld, sect_id: u8) !void {
         }
         offset = mem.alignForward(u64, offset, Thunk.getAlignment());
-        allocateThunk(zld, thunk_index, offset, header);
+        allocateThunk(macho_file, thunk_index, offset, header);
-        offset += zld.thunks.items[thunk_index].getSize();
+        offset += macho_file.thunks.items[thunk_index].getSize();
-        const thunk = zld.thunks.items[thunk_index];
+        const thunk = macho_file.thunks.items[thunk_index];
         if (thunk.len == 0) {
-            const group_end_atom = zld.getAtom(group_end);
+            const group_end_atom = macho_file.getAtom(group_end);
             if (group_end_atom.next_index) |next_index| {
                 group_start = next_index;
                 group_end = next_index;
             } else break;
         } else {
             const thunk_end_atom_index = thunk.getEndAtomIndex();
-            const thunk_end_atom = zld.getAtom(thunk_end_atom_index);
+            const thunk_end_atom = macho_file.getAtom(thunk_end_atom_index);
             if (thunk_end_atom.next_index) |next_index| {
                 group_start = next_index;
                 group_end = next_index;
 @@ -189,12 +173,12 @@ pub fn createThunks(zld: *Zld, sect_id: u8) !void {
 }
 fn allocateThunk(
-    zld: *Zld,
+    macho_file: *MachO,
     thunk_index: Thunk.Index,
     base_offset: u64,
     header: *macho.section_64,
 ) void {
-    const thunk = zld.thunks.items[thunk_index];
+    const thunk = macho_file.thunks.items[thunk_index];
     if (thunk.len == 0) return;
     const first_atom_index = thunk.getStartAtomIndex();
 @@ -203,14 +187,14 @@ fn allocateThunk(
     var atom_index = first_atom_index;
     var offset = base_offset;
     while (true) {
-        const atom = zld.getAtom(atom_index);
+        const atom = macho_file.getAtom(atom_index);
         offset = mem.alignForward(u64, offset, Thunk.getAlignment());
-        const sym = zld.getSymbolPtr(atom.getSymbolWithLoc());
+        const sym = macho_file.getSymbolPtr(atom.getSymbolWithLoc());
         sym.n_value = offset;
         offset += atom.size;
-        zld.logAtom(atom_index, log);
+        macho_file.logAtom(atom_index, log);
         header.@"align" = @max(header.@"align", atom.alignment);
 @@ -223,69 +207,69 @@ fn allocateThunk(
 }
 fn scanRelocs(
-    zld: *Zld,
+    macho_file: *MachO,
     atom_index: Atom.Index,
     allocated: std.AutoHashMap(Atom.Index, void),
     thunk_index: Thunk.Index,
     group_end: Atom.Index,
 ) !void {
-    const atom = zld.getAtom(atom_index);
+    const atom = macho_file.getAtom(atom_index);
-    const object = zld.objects.items[atom.getFile().?];
+    const object = macho_file.objects.items[atom.getFile().?];
     const base_offset = if (object.getSourceSymbol(atom.sym_index)) |source_sym| blk: {
         const source_sect = object.getSourceSection(source_sym.n_sect - 1);
         break :blk @as(i32, @intCast(source_sym.n_value - source_sect.addr));
     } else 0;
-    const code = Atom.getAtomCode(zld, atom_index);
+    const code = Atom.getAtomCode(macho_file, atom_index);
-    const relocs = Atom.getAtomRelocs(zld, atom_index);
+    const relocs = Atom.getAtomRelocs(macho_file, atom_index);
-    const ctx = Atom.getRelocContext(zld, atom_index);
+    const ctx = Atom.getRelocContext(macho_file, atom_index);
     for (relocs) |rel| {
         if (!relocNeedsThunk(rel)) continue;
-        const target = Atom.parseRelocTarget(zld, .{
+        const target = Atom.parseRelocTarget(macho_file, .{
             .object_id = atom.getFile().?,
             .rel = rel,
             .code = code,
             .base_offset = ctx.base_offset,
             .base_addr = ctx.base_addr,
         });
-        if (isReachable(zld, atom_index, rel, base_offset, target, allocated)) continue;
+        if (isReachable(macho_file, atom_index, rel, base_offset, target, allocated)) continue;
         log.debug("{x}: source = {s}@{x}, target = {s}@{x} unreachable", .{
             rel.r_address - base_offset,
-            zld.getSymbolName(atom.getSymbolWithLoc()),
+            macho_file.getSymbolName(atom.getSymbolWithLoc()),
-            zld.getSymbol(atom.getSymbolWithLoc()).n_value,
+            macho_file.getSymbol(atom.getSymbolWithLoc()).n_value,
-            zld.getSymbolName(target),
+            macho_file.getSymbolName(target),
-            zld.getSymbol(target).n_value,
+            macho_file.getSymbol(target).n_value,
         });
-        const gpa = zld.gpa;
+        const gpa = macho_file.base.allocator;
-        const target_sym = zld.getSymbol(target);
+        const target_sym = macho_file.getSymbol(target);
-        const thunk = &zld.thunks.items[thunk_index];
+        const thunk = &macho_file.thunks.items[thunk_index];
         const tag: Thunk.Tag = if (target_sym.undf()) .stub else .atom;
         const thunk_target: Thunk.Target = .{ .tag = tag, .target = target };
         const gop = try thunk.lookup.getOrPut(gpa, thunk_target);
         if (!gop.found_existing) {
-            gop.value_ptr.* = try pushThunkAtom(zld, thunk, group_end);
+            gop.value_ptr.* = try pushThunkAtom(macho_file, thunk, group_end);
             try thunk.targets.append(gpa, thunk_target);
         }
-        try zld.thunk_table.put(gpa, atom_index, thunk_index);
+        try macho_file.thunk_table.put(gpa, atom_index, thunk_index);
     }
 }
-fn pushThunkAtom(zld: *Zld, thunk: *Thunk, group_end: Atom.Index) !Atom.Index {
+fn pushThunkAtom(macho_file: *MachO, thunk: *Thunk, group_end: Atom.Index) !Atom.Index {
-    const thunk_atom_index = try createThunkAtom(zld);
+    const thunk_atom_index = try createThunkAtom(macho_file);
-    const thunk_atom = zld.getAtomPtr(thunk_atom_index);
+    const thunk_atom = macho_file.getAtomPtr(thunk_atom_index);
     const end_atom_index = if (thunk.len == 0) group_end else thunk.getEndAtomIndex();
-    const end_atom = zld.getAtomPtr(end_atom_index);
+    const end_atom = macho_file.getAtomPtr(end_atom_index);
     if (end_atom.next_index) |first_after_index| {
-        const first_after_atom = zld.getAtomPtr(first_after_index);
+        const first_after_atom = macho_file.getAtomPtr(first_after_index);
         first_after_atom.prev_index = thunk_atom_index;
         thunk_atom.next_index = first_after_index;
     }
 @@ -308,58 +292,58 @@ inline fn relocNeedsThunk(rel: macho.relocation_info) bool {
 }
 fn isReachable(
-    zld: *Zld,
+    macho_file: *MachO,
     atom_index: Atom.Index,
     rel: macho.relocation_info,
     base_offset: i32,
     target: SymbolWithLoc,
     allocated: std.AutoHashMap(Atom.Index, void),
 ) bool {
-    if (zld.stubs_table.lookup.contains(target)) return false;
+    if (macho_file.stub_table.lookup.contains(target)) return false;
-    const source_atom = zld.getAtom(atom_index);
+    const source_atom = macho_file.getAtom(atom_index);
-    const source_sym = zld.getSymbol(source_atom.getSymbolWithLoc());
+    const source_sym = macho_file.getSymbol(source_atom.getSymbolWithLoc());
-    const target_object = zld.objects.items[target.getFile().?];
+    const target_object = macho_file.objects.items[target.getFile().?];
     const target_atom_index = target_object.getAtomIndexForSymbol(target.sym_index).?;
-    const target_atom = zld.getAtom(target_atom_index);
+    const target_atom = macho_file.getAtom(target_atom_index);
-    const target_sym = zld.getSymbol(target_atom.getSymbolWithLoc());
+    const target_sym = macho_file.getSymbol(target_atom.getSymbolWithLoc());
     if (source_sym.n_sect != target_sym.n_sect) return false;
     if (!allocated.contains(target_atom_index)) return false;
     const source_addr = source_sym.n_value + @as(u32, @intCast(rel.r_address - base_offset));
-    const target_addr = if (Atom.relocRequiresGot(zld, rel))
+    const target_addr = if (Atom.relocRequiresGot(macho_file, rel))
-        zld.getGotEntryAddress(target).?
+        macho_file.getGotEntryAddress(target).?
     else
-        Atom.getRelocTargetAddress(zld, target, false) catch unreachable;
+        Atom.getRelocTargetAddress(macho_file, target, false) catch unreachable;
     _ = Relocation.calcPcRelativeDisplacementArm64(source_addr, target_addr) catch
         return false;
     return true;
 }
-fn createThunkAtom(zld: *Zld) !Atom.Index {
+fn createThunkAtom(macho_file: *MachO) !Atom.Index {
-    const sym_index = try zld.allocateSymbol();
+    const sym_index = try macho_file.allocateSymbol();
-    const atom_index = try zld.createAtom(sym_index, .{ .size = @sizeOf(u32) * 3, .alignment = 2 });
+    const atom_index = try macho_file.createAtom(sym_index, .{ .size = @sizeOf(u32) * 3, .alignment = 2 });
-    const sym = zld.getSymbolPtr(.{ .sym_index = sym_index });
+    const sym = macho_file.getSymbolPtr(.{ .sym_index = sym_index });
     sym.n_type = macho.N_SECT;
-    sym.n_sect = zld.text_section_index.? + 1;
+    sym.n_sect = macho_file.text_section_index.? + 1;
     return atom_index;
 }
-pub fn writeThunkCode(zld: *Zld, thunk: *const Thunk, writer: anytype) !void {
+pub fn writeThunkCode(macho_file: *MachO, thunk: *const Thunk, writer: anytype) !void {
     const slice = thunk.targets.slice();
     for (thunk.getStartAtomIndex()..thunk.getEndAtomIndex(), 0..) |atom_index, target_index| {
-        const atom = zld.getAtom(@intCast(atom_index));
+        const atom = macho_file.getAtom(@intCast(atom_index));
-        const sym = zld.getSymbol(atom.getSymbolWithLoc());
+        const sym = macho_file.getSymbol(atom.getSymbolWithLoc());
         const source_addr = sym.n_value;
         const tag = slice.items(.tag)[target_index];
         const target = slice.items(.target)[target_index];
         const target_addr = switch (tag) {
-            .stub => zld.getStubsEntryAddress(target).?,
+            .stub => macho_file.getStubsEntryAddress(target).?,
-            .atom => zld.getSymbol(target).n_value,
+            .atom => macho_file.getSymbol(target).n_value,
         };
         const pages = Relocation.calcNumberOfPages(source_addr, target_addr);
         try writer.writeIntLittle(u32, aarch64.Instruction.adrp(.x16, pages).toU32());
 @@ -368,3 +352,18 @@ pub fn writeThunkCode(zld: *Zld, thunk: *const Thunk, writer: anytype) !void {
         try writer.writeIntLittle(u32, aarch64.Instruction.br(.x16).toU32());
     }
 }
+const std = @import("std");
+const assert = std.debug.assert;
+const log = std.log.scoped(.thunks);
+const macho = std.macho;
+const math = std.math;
+const mem = std.mem;
+const aarch64 = @import("../../arch/aarch64/bits.zig");
+const Allocator = mem.Allocator;
+const Atom = @import("Atom.zig");
+const MachO = @import("../MachO.zig");
+const Relocation = @import("Relocation.zig");
+const SymbolWithLoc = MachO.SymbolWithLoc;

src/link/MachO/uuid.zig+9-9

 @@ -1,12 +1,3 @@
-const std = @import("std");
-const fs = std.fs;
-const mem = std.mem;
-const Allocator = mem.Allocator;
-const Compilation = @import("../../Compilation.zig");
-const Md5 = std.crypto.hash.Md5;
-const Hasher = @import("hasher.zig").ParallelHasher;
 /// Calculates Md5 hash of each chunk in parallel and then hashes all Md5 hashes to produce
 /// the final digest.
 /// While this is NOT a correct MD5 hash of the contents, this methodology is used by LLVM/LLD
 @@ -43,3 +34,12 @@ inline fn conform(out: *[Md5.digest_length]u8) void {
     out[6] = (out[6] & 0x0F) | (3 << 4);
     out[8] = (out[8] & 0x3F) | 0x80;
 }
+const std = @import("std");
+const fs = std.fs;
+const mem = std.mem;
+const Allocator = mem.Allocator;
+const Compilation = @import("../../Compilation.zig");
+const Md5 = std.crypto.hash.Md5;
+const Hasher = @import("hasher.zig").ParallelHasher;

src/link/MachO/zld.zig+726-2704

...	@@ -1,2584 +1,8 @@	...	@@ -1,2584 +1,8 @@
1	const std = @import("std");	1	pub fn linkWithZld(
2	const build_options = @import("build_options");	2	macho_file: *MachO,
3	const assert = std.debug.assert;	3	comp: *Compilation,
4	const dwarf = std.dwarf;	4	prog_node: *std.Progress.Node,
5	const fs = std.fs;	5	) link.File.FlushError!void {
6	const log = std.log.scoped(.link);
7	const macho = std.macho;
8	const math = std.math;
9	const mem = std.mem;
10
11	const aarch64 = @import("../../arch/aarch64/bits.zig");
12	const calcUuid = @import("uuid.zig").calcUuid;
13	const dead_strip = @import("dead_strip.zig");
14	const eh_frame = @import("eh_frame.zig");
15	const fat = @import("fat.zig");
16	const link = @import("../../link.zig");
17	const load_commands = @import("load_commands.zig");
18	const stubs = @import("stubs.zig");
19	const thunks = @import("thunks.zig");
20	const trace = @import("../../tracy.zig").trace;
21
22	const Allocator = mem.Allocator;
23	const Archive = @import("Archive.zig");
24	const Atom = @import("Atom.zig");
25	const Cache = std.Build.Cache;
26	const CodeSignature = @import("CodeSignature.zig");
27	const Compilation = @import("../../Compilation.zig");
28	const DwarfInfo = @import("DwarfInfo.zig");
29	const Dylib = @import("Dylib.zig");
30	const MachO = @import("../MachO.zig");
31	const Md5 = std.crypto.hash.Md5;
32	const LibStub = @import("../tapi.zig").LibStub;
33	const Object = @import("Object.zig");
34	const Section = MachO.Section;
35	const StringTable = @import("../strtab.zig").StringTable;
36	const SymbolWithLoc = MachO.SymbolWithLoc;
37	const TableSection = @import("../table_section.zig").TableSection;
38	const Trie = @import("Trie.zig");
39	const UnwindInfo = @import("UnwindInfo.zig");
40
41	const Bind = @import("dyld_info/bind.zig").Bind(*const Zld, SymbolWithLoc);
42	const LazyBind = @import("dyld_info/bind.zig").LazyBind(*const Zld, SymbolWithLoc);
43	const Rebase = @import("dyld_info/Rebase.zig");
44
45	pub const Zld = struct {
46	gpa: Allocator,
47	file: fs.File,
48	options: *const link.Options,
49
50	dyld_info_cmd: macho.dyld_info_command = .{},
51	symtab_cmd: macho.symtab_command = .{},
52	dysymtab_cmd: macho.dysymtab_command = .{},
53	function_starts_cmd: macho.linkedit_data_command = .{ .cmd = .FUNCTION_STARTS },
54	data_in_code_cmd: macho.linkedit_data_command = .{ .cmd = .DATA_IN_CODE },
55	uuid_cmd: macho.uuid_command = .{
56	.uuid = [_]u8{0} ** 16,
57	},
58	codesig_cmd: macho.linkedit_data_command = .{ .cmd = .CODE_SIGNATURE },
59
60	objects: std.ArrayListUnmanaged(Object) = .{},
61	archives: std.ArrayListUnmanaged(Archive) = .{},
62	dylibs: std.ArrayListUnmanaged(Dylib) = .{},
63	dylibs_map: std.StringHashMapUnmanaged(u16) = .{},
64	referenced_dylibs: std.AutoArrayHashMapUnmanaged(u16, void) = .{},
65
66	segments: std.ArrayListUnmanaged(macho.segment_command_64) = .{},
67	sections: std.MultiArrayList(Section) = .{},
68
69	pagezero_segment_cmd_index: ?u8 = null,
70	header_segment_cmd_index: ?u8 = null,
71	text_segment_cmd_index: ?u8 = null,
72	data_const_segment_cmd_index: ?u8 = null,
73	data_segment_cmd_index: ?u8 = null,
74	linkedit_segment_cmd_index: ?u8 = null,
75
76	text_section_index: ?u8 = null,
77	data_const_section_index: ?u8 = null,
78	data_section_index: ?u8 = null,
79	bss_section_index: ?u8 = null,
80	thread_vars_section_index: ?u8 = null,
81	thread_data_section_index: ?u8 = null,
82	thread_bss_section_index: ?u8 = null,
83	eh_frame_section_index: ?u8 = null,
84	unwind_info_section_index: ?u8 = null,
85	got_section_index: ?u8 = null,
86	tlv_ptr_section_index: ?u8 = null,
87	stubs_section_index: ?u8 = null,
88	stub_helper_section_index: ?u8 = null,
89	la_symbol_ptr_section_index: ?u8 = null,
90
91	locals: std.ArrayListUnmanaged(macho.nlist_64) = .{},
92	globals: std.ArrayListUnmanaged(SymbolWithLoc) = .{},
93	resolver: std.StringHashMapUnmanaged(u32) = .{},
94	unresolved: std.AutoArrayHashMapUnmanaged(u32, void) = .{},
95
96	locals_free_list: std.ArrayListUnmanaged(u32) = .{},
97	globals_free_list: std.ArrayListUnmanaged(u32) = .{},
98
99	entry_index: ?u32 = null,
100	dyld_stub_binder_index: ?u32 = null,
101	dyld_private_atom_index: ?Atom.Index = null,
102
103	strtab: StringTable(.strtab) = .{},
104
105	tlv_ptr_table: TableSection(SymbolWithLoc) = .{},
106	got_table: TableSection(SymbolWithLoc) = .{},
107	stubs_table: TableSection(SymbolWithLoc) = .{},
108
109	thunk_table: std.AutoHashMapUnmanaged(Atom.Index, thunks.Thunk.Index) = .{},
110	thunks: std.ArrayListUnmanaged(thunks.Thunk) = .{},
111
112	atoms: std.ArrayListUnmanaged(Atom) = .{},
113
114	pub fn addAtomToSection(self: *Zld, atom_index: Atom.Index) void {
115	const atom = self.getAtomPtr(atom_index);
116	const sym = self.getSymbol(atom.getSymbolWithLoc());
117	var section = self.sections.get(sym.n_sect - 1);
118	if (section.header.size > 0) {
119	const last_atom = self.getAtomPtr(section.last_atom_index.?);
120	last_atom.next_index = atom_index;
121	atom.prev_index = section.last_atom_index;
122	} else {
123	section.first_atom_index = atom_index;
124	}
125	section.last_atom_index = atom_index;
126	section.header.size += atom.size;
127	self.sections.set(sym.n_sect - 1, section);
128	}
129
130	const CreateAtomOpts = struct {
131	size: u64 = 0,
132	alignment: u32 = 0,
133	};
134
135	pub fn createAtom(self: *Zld, sym_index: u32, opts: CreateAtomOpts) !Atom.Index {
136	const gpa = self.gpa;
137	const index = @as(Atom.Index, @intCast(self.atoms.items.len));
138	const atom = try self.atoms.addOne(gpa);
139	atom.* = .{};
140	atom.sym_index = sym_index;
141	atom.size = opts.size;
142	atom.alignment = opts.alignment;
143	log.debug("creating ATOM(%{d}) at index {d}", .{ sym_index, index });
144	return index;
145	}
146
147	fn createDyldPrivateAtom(self: *Zld) !void {
148	const sym_index = try self.allocateSymbol();
149	const atom_index = try self.createAtom(sym_index, .{ .size = @sizeOf(u64), .alignment = 3 });
150	const sym = self.getSymbolPtr(.{ .sym_index = sym_index });
151	sym.n_type = macho.N_SECT;
152
153	if (self.data_section_index == null) {
154	self.data_section_index = try MachO.initSection(self.gpa, self, "__DATA", "__data", .{});
155	}
156	sym.n_sect = self.data_section_index.? + 1;
157	self.dyld_private_atom_index = atom_index;
158
159	self.addAtomToSection(atom_index);
160	}
161
162	fn createTentativeDefAtoms(self: *Zld) !void {
163	const gpa = self.gpa;
164
165	for (self.globals.items) \|global\| {
166	const sym = self.getSymbolPtr(global);
167	if (!sym.tentative()) continue;
168	if (sym.n_desc == MachO.N_DEAD) continue;
169
170	log.debug("creating tentative definition for ATOM(%{d}, '{s}') in object({?})", .{
171	global.sym_index, self.getSymbolName(global), global.file,
172	});
173
174	// Convert any tentative definition into a regular symbol and allocate
175	// text blocks for each tentative definition.
176	const size = sym.n_value;
177	const alignment = (sym.n_desc >> 8) & 0x0f;
178
179	if (self.bss_section_index == null) {
180	self.bss_section_index = try MachO.initSection(gpa, self, "__DATA", "__bss", .{
181	.flags = macho.S_ZEROFILL,
182	});
183	}
184
185	sym.* = .{
186	.n_strx = sym.n_strx,
187	.n_type = macho.N_SECT \| macho.N_EXT,
188	.n_sect = self.bss_section_index.? + 1,
189	.n_desc = 0,
190	.n_value = 0,
191	};
192
193	const atom_index = try self.createAtom(global.sym_index, .{
194	.size = size,
195	.alignment = alignment,
196	});
197	const atom = self.getAtomPtr(atom_index);
198	atom.file = global.file;
199
200	self.addAtomToSection(atom_index);
201
202	assert(global.getFile() != null);
203	const object = &self.objects.items[global.getFile().?];
204	try object.atoms.append(gpa, atom_index);
205	object.atom_by_index_table[global.sym_index] = atom_index;
206	}
207	}
208
209	fn addUndefined(self: *Zld, name: []const u8) !u32 {
210	const gop = try self.getOrPutGlobalPtr(name);
211	const global_index = self.getGlobalIndex(name).?;
212
213	if (gop.found_existing) return global_index;
214
215	const sym_index = try self.allocateSymbol();
216	const sym_loc = SymbolWithLoc{ .sym_index = sym_index };
217	gop.value_ptr.* = sym_loc;
218
219	const sym = self.getSymbolPtr(sym_loc);
220	sym.n_strx = try self.strtab.insert(self.gpa, name);
221	sym.n_type = macho.N_UNDF;
222
223	try self.unresolved.putNoClobber(self.gpa, global_index, {});
224
225	return global_index;
226	}
227
228	fn resolveSymbols(self: *Zld) !void {
229	// We add the specified entrypoint as the first unresolved symbols so that
230	// we search for it in libraries should there be no object files specified
231	// on the linker line.
232	if (self.options.output_mode == .Exe) {
233	const entry_name = self.options.entry orelse load_commands.default_entry_point;
234	_ = try self.addUndefined(entry_name);
235	}
236
237	// Force resolution of any symbols requested by the user.
238	for (self.options.force_undefined_symbols.keys()) \|sym_name\| {
239	_ = try self.addUndefined(sym_name);
240	}
241
242	for (self.objects.items, 0..) \|_, object_id\| {
243	try self.resolveSymbolsInObject(@as(u32, @intCast(object_id)));
244	}
245
246	try self.resolveSymbolsInArchives();
247
248	// Finally, force resolution of dyld_stub_binder if there are imports
249	// requested.
250	if (self.unresolved.count() > 0) {
251	self.dyld_stub_binder_index = try self.addUndefined("dyld_stub_binder");
252	}
253
254	try self.resolveSymbolsInDylibs();
255
256	try self.createMhExecuteHeaderSymbol();
257	try self.createDsoHandleSymbol();
258	try self.resolveSymbolsAtLoading();
259	}
260
261	fn resolveGlobalSymbol(self: *Zld, current: SymbolWithLoc) !void {
262	const gpa = self.gpa;
263	const sym = self.getSymbol(current);
264	const sym_name = self.getSymbolName(current);
265
266	const gop = try self.getOrPutGlobalPtr(sym_name);
267	if (!gop.found_existing) {
268	gop.value_ptr.* = current;
269	if (sym.undf() and !sym.tentative()) {
270	try self.unresolved.putNoClobber(gpa, self.getGlobalIndex(sym_name).?, {});
271	}
272	return;
273	}
274	const global_index = self.getGlobalIndex(sym_name).?;
275	const global = gop.value_ptr.*;
276	const global_sym = self.getSymbol(global);
277
278	// Cases to consider: sym vs global_sym
279	// 1. strong(sym) and strong(global_sym) => error
280	// 2. strong(sym) and weak(global_sym) => sym
281	// 3. strong(sym) and tentative(global_sym) => sym
282	// 4. strong(sym) and undf(global_sym) => sym
283	// 5. weak(sym) and strong(global_sym) => global_sym
284	// 6. weak(sym) and tentative(global_sym) => sym
285	// 7. weak(sym) and undf(global_sym) => sym
286	// 8. tentative(sym) and strong(global_sym) => global_sym
287	// 9. tentative(sym) and weak(global_sym) => global_sym
288	// 10. tentative(sym) and tentative(global_sym) => pick larger
289	// 11. tentative(sym) and undf(global_sym) => sym
290	// 12. undf(sym) and * => global_sym
291	//
292	// Reduces to:
293	// 1. strong(sym) and strong(global_sym) => error
294	// 2. * and strong(global_sym) => global_sym
295	// 3. weak(sym) and weak(global_sym) => global_sym
296	// 4. tentative(sym) and tentative(global_sym) => pick larger
297	// 5. undf(sym) and * => global_sym
298	// 6. else => sym
299
300	const sym_is_strong = sym.sect() and !(sym.weakDef() or sym.pext());
301	const global_is_strong = global_sym.sect() and !(global_sym.weakDef() or global_sym.pext());
302	const sym_is_weak = sym.sect() and (sym.weakDef() or sym.pext());
303	const global_is_weak = global_sym.sect() and (global_sym.weakDef() or global_sym.pext());
304
305	if (sym_is_strong and global_is_strong) {
306	log.err("symbol '{s}' defined multiple times", .{sym_name});
307	if (global.getFile()) \|file\| {
308	log.err(" first definition in '{s}'", .{self.objects.items[file].name});
309	}
310	if (current.getFile()) \|file\| {
311	log.err(" next definition in '{s}'", .{self.objects.items[file].name});
312	}
313	return error.MultipleSymbolDefinitions;
314	}
315
316	if (current.getFile()) \|file\| {
317	const object = &self.objects.items[file];
318	object.globals_lookup[current.sym_index] = global_index;
319	}
320
321	if (global_is_strong) return;
322	if (sym_is_weak and global_is_weak) return;
323	if (sym.tentative() and global_sym.tentative()) {
324	if (global_sym.n_value >= sym.n_value) return;
325	}
326	if (sym.undf() and !sym.tentative()) return;
327
328	if (global.getFile()) \|file\| {
329	const global_object = &self.objects.items[file];
330	global_object.globals_lookup[global.sym_index] = global_index;
331	}
332	_ = self.unresolved.swapRemove(global_index);
333
334	gop.value_ptr.* = current;
335	}
336
337	fn resolveSymbolsInObject(self: *Zld, object_id: u32) !void {
338	const object = &self.objects.items[object_id];
339	const in_symtab = object.in_symtab orelse return;
340
341	log.debug("resolving symbols in '{s}'", .{object.name});
342
343	var sym_index: u32 = 0;
344	while (sym_index < in_symtab.len) : (sym_index += 1) {
345	const sym = &object.symtab[sym_index];
346	const sym_name = object.getSymbolName(sym_index);
347
348	if (sym.stab()) {
349	log.err("unhandled symbol type: stab", .{});
350	log.err(" symbol '{s}'", .{sym_name});
351	log.err(" first definition in '{s}'", .{object.name});
352	return error.UnhandledSymbolType;
353	}
354
355	if (sym.indr()) {
356	log.err("unhandled symbol type: indirect", .{});
357	log.err(" symbol '{s}'", .{sym_name});
358	log.err(" first definition in '{s}'", .{object.name});
359	return error.UnhandledSymbolType;
360	}
361
362	if (sym.abs()) {
363	log.err("unhandled symbol type: absolute", .{});
364	log.err(" symbol '{s}'", .{sym_name});
365	log.err(" first definition in '{s}'", .{object.name});
366	return error.UnhandledSymbolType;
367	}
368
369	if (sym.sect() and !sym.ext()) {
370	log.debug("symbol '{s}' local to object {s}; skipping...", .{
371	sym_name,
372	object.name,
373	});
374	continue;
375	}
376
377	try self.resolveGlobalSymbol(.{ .sym_index = sym_index, .file = object_id + 1 });
378	}
379	}
380
381	fn resolveSymbolsInArchives(self: *Zld) !void {
382	if (self.archives.items.len == 0) return;
383
384	const gpa = self.gpa;
385
386	var next_sym: usize = 0;
387	loop: while (next_sym < self.unresolved.count()) {
388	const global = self.globals.items[self.unresolved.keys()[next_sym]];
389	const sym_name = self.getSymbolName(global);
390
391	for (self.archives.items) \|archive\| {
392	// Check if the entry exists in a static archive.
393	const offsets = archive.toc.get(sym_name) orelse {
394	// No hit.
395	continue;
396	};
397	assert(offsets.items.len > 0);
398
399	const object_id = @as(u16, @intCast(self.objects.items.len));
400	const object = try archive.parseObject(gpa, offsets.items[0]);
401	try self.objects.append(gpa, object);
402	try self.resolveSymbolsInObject(object_id);
403
404	continue :loop;
405	}
406
407	next_sym += 1;
408	}
409	}
410
411	fn resolveSymbolsInDylibs(self: *Zld) !void {
412	if (self.dylibs.items.len == 0) return;
413
414	var next_sym: usize = 0;
415	loop: while (next_sym < self.unresolved.count()) {
416	const global_index = self.unresolved.keys()[next_sym];
417	const global = self.globals.items[global_index];
418	const sym = self.getSymbolPtr(global);
419	const sym_name = self.getSymbolName(global);
420
421	for (self.dylibs.items, 0..) \|dylib, id\| {
422	if (!dylib.symbols.contains(sym_name)) continue;
423
424	const dylib_id = @as(u16, @intCast(id));
425	if (!self.referenced_dylibs.contains(dylib_id)) {
426	try self.referenced_dylibs.putNoClobber(self.gpa, dylib_id, {});
427	}
428
429	const ordinal = self.referenced_dylibs.getIndex(dylib_id) orelse unreachable;
430	sym.n_type \|= macho.N_EXT;
431	sym.n_desc = @as(u16, @intCast(ordinal + 1)) * macho.N_SYMBOL_RESOLVER;
432
433	if (dylib.weak) {
434	sym.n_desc \|= macho.N_WEAK_REF;
435	}
436
437	assert(self.unresolved.swapRemove(global_index));
438	continue :loop;
439	}
440
441	next_sym += 1;
442	}
443	}
444
445	fn resolveSymbolsAtLoading(self: *Zld) !void {
446	const is_lib = self.options.output_mode == .Lib;
447	const is_dyn_lib = self.options.link_mode == .Dynamic and is_lib;
448	const allow_undef = is_dyn_lib and (self.options.allow_shlib_undefined orelse false);
449
450	var next_sym: usize = 0;
451	while (next_sym < self.unresolved.count()) {
452	const global_index = self.unresolved.keys()[next_sym];
453	const global = self.globals.items[global_index];
454	const sym = self.getSymbolPtr(global);
455
456	if (sym.discarded()) {
457	sym.* = .{
458	.n_strx = 0,
459	.n_type = macho.N_UNDF,
460	.n_sect = 0,
461	.n_desc = 0,
462	.n_value = 0,
463	};
464	_ = self.unresolved.swapRemove(global_index);
465	continue;
466	} else if (allow_undef) {
467	const n_desc = @as(
468	u16,
469	@bitCast(macho.BIND_SPECIAL_DYLIB_FLAT_LOOKUP * @as(i16, @intCast(macho.N_SYMBOL_RESOLVER))),
470	);
471	sym.n_type = macho.N_EXT;
472	sym.n_desc = n_desc;
473	_ = self.unresolved.swapRemove(global_index);
474	continue;
475	}
476
477	next_sym += 1;
478	}
479	}
480
481	fn createMhExecuteHeaderSymbol(self: *Zld) !void {
482	if (self.options.output_mode != .Exe) return;
483
484	const gpa = self.gpa;
485	const sym_index = try self.allocateSymbol();
486	const sym_loc = SymbolWithLoc{ .sym_index = sym_index };
487	const sym = self.getSymbolPtr(sym_loc);
488	sym.* = .{
489	.n_strx = try self.strtab.insert(gpa, "__mh_execute_header"),
490	.n_type = macho.N_SECT \| macho.N_EXT,
491	.n_sect = 0,
492	.n_desc = macho.REFERENCED_DYNAMICALLY,
493	.n_value = 0,
494	};
495
496	const gop = try self.getOrPutGlobalPtr("__mh_execute_header");
497	if (gop.found_existing) {
498	const global = gop.value_ptr.*;
499	if (global.getFile()) \|file\| {
500	const global_object = &self.objects.items[file];
501	global_object.globals_lookup[global.sym_index] = self.getGlobalIndex("__mh_execute_header").?;
502	}
503	}
504	gop.value_ptr.* = sym_loc;
505	}
506
507	fn createDsoHandleSymbol(self: *Zld) !void {
508	const global = self.getGlobalPtr("___dso_handle") orelse return;
509	if (!self.getSymbol(global.*).undf()) return;
510
511	const sym_index = try self.allocateSymbol();
512	const sym_loc = SymbolWithLoc{ .sym_index = sym_index };
513	const sym = self.getSymbolPtr(sym_loc);
514	sym.* = .{
515	.n_strx = try self.strtab.insert(self.gpa, "___dso_handle"),
516	.n_type = macho.N_SECT \| macho.N_EXT,
517	.n_sect = 0,
518	.n_desc = macho.N_WEAK_DEF,
519	.n_value = 0,
520	};
521	const global_index = self.getGlobalIndex("___dso_handle").?;
522	if (global.getFile()) \|file\| {
523	const global_object = &self.objects.items[file];
524	global_object.globals_lookup[global.sym_index] = global_index;
525	}
526	global.* = sym_loc;
527	_ = self.unresolved.swapRemove(global_index);
528	}
529
530	pub fn deinit(self: *Zld) void {
531	const gpa = self.gpa;
532
533	self.tlv_ptr_table.deinit(gpa);
534	self.got_table.deinit(gpa);
535	self.stubs_table.deinit(gpa);
536	self.thunk_table.deinit(gpa);
537
538	for (self.thunks.items) \|*thunk\| {
539	thunk.deinit(gpa);
540	}
541	self.thunks.deinit(gpa);
542
543	self.strtab.deinit(gpa);
544	self.locals.deinit(gpa);
545	self.globals.deinit(gpa);
546	self.resolver.deinit(gpa);
547	self.unresolved.deinit(gpa);
548	self.locals_free_list.deinit(gpa);
549	self.globals_free_list.deinit(gpa);
550
551	for (self.objects.items) \|*object\| {
552	object.deinit(gpa);
553	}
554	self.objects.deinit(gpa);
555	for (self.archives.items) \|*archive\| {
556	archive.deinit(gpa);
557	}
558	self.archives.deinit(gpa);
559	for (self.dylibs.items) \|*dylib\| {
560	dylib.deinit(gpa);
561	}
562	self.dylibs.deinit(gpa);
563	self.dylibs_map.deinit(gpa);
564	self.referenced_dylibs.deinit(gpa);
565
566	self.segments.deinit(gpa);
567	self.sections.deinit(gpa);
568	self.atoms.deinit(gpa);
569	}
570
571	fn createSegments(self: *Zld) !void {
572	const pagezero_vmsize = self.options.pagezero_size orelse MachO.default_pagezero_vmsize;
573	const page_size = MachO.getPageSize(self.options.target.cpu.arch);
574	const aligned_pagezero_vmsize = mem.alignBackward(u64, pagezero_vmsize, page_size);
575	if (self.options.output_mode != .Lib and aligned_pagezero_vmsize > 0) {
576	if (aligned_pagezero_vmsize != pagezero_vmsize) {
577	log.warn("requested __PAGEZERO size (0x{x}) is not page aligned", .{pagezero_vmsize});
578	log.warn(" rounding down to 0x{x}", .{aligned_pagezero_vmsize});
579	}
580	self.pagezero_segment_cmd_index = @intCast(self.segments.items.len);
581	try self.segments.append(self.gpa, .{
582	.cmdsize = @sizeOf(macho.segment_command_64),
583	.segname = makeStaticString("__PAGEZERO"),
584	.vmsize = aligned_pagezero_vmsize,
585	});
586	}
587
588	// __TEXT segment is non-optional
589	{
590	const protection = MachO.getSegmentMemoryProtection("__TEXT");
591	self.text_segment_cmd_index = @intCast(self.segments.items.len);
592	self.header_segment_cmd_index = self.text_segment_cmd_index.?;
593	try self.segments.append(self.gpa, .{
594	.cmdsize = @sizeOf(macho.segment_command_64),
595	.segname = makeStaticString("__TEXT"),
596	.maxprot = protection,
597	.initprot = protection,
598	});
599	}
600
601	for (self.sections.items(.header), 0..) \|header, sect_id\| {
602	if (header.size == 0) continue; // empty section
603
604	const segname = header.segName();
605	const segment_id = self.getSegmentByName(segname) orelse blk: {
606	log.debug("creating segment '{s}'", .{segname});
607	const segment_id = @as(u8, @intCast(self.segments.items.len));
608	const protection = MachO.getSegmentMemoryProtection(segname);
609	try self.segments.append(self.gpa, .{
610	.cmdsize = @sizeOf(macho.segment_command_64),
611	.segname = makeStaticString(segname),
612	.maxprot = protection,
613	.initprot = protection,
614	});
615	break :blk segment_id;
616	};
617	const segment = &self.segments.items[segment_id];
618	segment.cmdsize += @sizeOf(macho.section_64);
619	segment.nsects += 1;
620	self.sections.items(.segment_index)[sect_id] = segment_id;
621	}
622
623	if (self.getSegmentByName("__DATA_CONST")) \|index\| {
624	self.data_const_segment_cmd_index = index;
625	}
626
627	if (self.getSegmentByName("__DATA")) \|index\| {
628	self.data_segment_cmd_index = index;
629	}
630
631	// __LINKEDIT always comes last
632	{
633	const protection = MachO.getSegmentMemoryProtection("__LINKEDIT");
634	self.linkedit_segment_cmd_index = @intCast(self.segments.items.len);
635	try self.segments.append(self.gpa, .{
636	.cmdsize = @sizeOf(macho.segment_command_64),
637	.segname = makeStaticString("__LINKEDIT"),
638	.maxprot = protection,
639	.initprot = protection,
640	});
641	}
642	}
643
644	pub fn allocateSymbol(self: *Zld) !u32 {
645	try self.locals.ensureUnusedCapacity(self.gpa, 1);
646	log.debug(" (allocating symbol index {d})", .{self.locals.items.len});
647	const index = @as(u32, @intCast(self.locals.items.len));
648	_ = self.locals.addOneAssumeCapacity();
649	self.locals.items[index] = .{
650	.n_strx = 0,
651	.n_type = 0,
652	.n_sect = 0,
653	.n_desc = 0,
654	.n_value = 0,
655	};
656	return index;
657	}
658
659	fn allocateGlobal(self: *Zld) !u32 {
660	try self.globals.ensureUnusedCapacity(self.gpa, 1);
661
662	const index = blk: {
663	if (self.globals_free_list.popOrNull()) \|index\| {
664	log.debug(" (reusing global index {d})", .{index});
665	break :blk index;
666	} else {
667	log.debug(" (allocating symbol index {d})", .{self.globals.items.len});
668	const index = @as(u32, @intCast(self.globals.items.len));
669	_ = self.globals.addOneAssumeCapacity();
670	break :blk index;
671	}
672	};
673
674	self.globals.items[index] = .{ .sym_index = 0 };
675
676	return index;
677	}
678
679	pub fn addGotEntry(self: *Zld, target: SymbolWithLoc) !void {
680	if (self.got_table.lookup.contains(target)) return;
681	_ = try self.got_table.allocateEntry(self.gpa, target);
682	if (self.got_section_index == null) {
683	self.got_section_index = try MachO.initSection(self.gpa, self, "__DATA_CONST", "__got", .{
684	.flags = macho.S_NON_LAZY_SYMBOL_POINTERS,
685	});
686	}
687	}
688
689	pub fn addTlvPtrEntry(self: *Zld, target: SymbolWithLoc) !void {
690	if (self.tlv_ptr_table.lookup.contains(target)) return;
691	_ = try self.tlv_ptr_table.allocateEntry(self.gpa, target);
692	if (self.tlv_ptr_section_index == null) {
693	self.tlv_ptr_section_index = try MachO.initSection(self.gpa, self, "__DATA", "__thread_ptrs", .{
694	.flags = macho.S_THREAD_LOCAL_VARIABLE_POINTERS,
695	});
696	}
697	}
698
699	pub fn addStubEntry(self: *Zld, target: SymbolWithLoc) !void {
700	if (self.stubs_table.lookup.contains(target)) return;
701	_ = try self.stubs_table.allocateEntry(self.gpa, target);
702	if (self.stubs_section_index == null) {
703	self.stubs_section_index = try MachO.initSection(self.gpa, self, "__TEXT", "__stubs", .{
704	.flags = macho.S_SYMBOL_STUBS \|
705	macho.S_ATTR_PURE_INSTRUCTIONS \|
706	macho.S_ATTR_SOME_INSTRUCTIONS,
707	.reserved2 = stubs.stubSize(self.options.target.cpu.arch),
708	});
709	self.stub_helper_section_index = try MachO.initSection(self.gpa, self, "__TEXT", "__stub_helper", .{
710	.flags = macho.S_REGULAR \|
711	macho.S_ATTR_PURE_INSTRUCTIONS \|
712	macho.S_ATTR_SOME_INSTRUCTIONS,
713	});
714	self.la_symbol_ptr_section_index = try MachO.initSection(self.gpa, self, "__DATA", "__la_symbol_ptr", .{
715	.flags = macho.S_LAZY_SYMBOL_POINTERS,
716	});
717	}
718	}
719
720	fn writeAtoms(self: *Zld) !void {
721	const gpa = self.gpa;
722	const slice = self.sections.slice();
723
724	for (slice.items(.first_atom_index), 0..) \|first_atom_index, sect_id\| {
725	const header = slice.items(.header)[sect_id];
726	if (header.isZerofill()) continue;
727
728	var atom_index = first_atom_index orelse continue;
729
730	var buffer = try gpa.alloc(u8, math.cast(usize, header.size) orelse return error.Overflow);
731	defer gpa.free(buffer);
732	@memset(buffer, 0); // TODO with NOPs
733
734	log.debug("writing atoms in {s},{s}", .{ header.segName(), header.sectName() });
735
736	while (true) {
737	const atom = self.getAtom(atom_index);
738	if (atom.getFile()) \|file\| {
739	const this_sym = self.getSymbol(atom.getSymbolWithLoc());
740	const padding_size: usize = if (atom.next_index) \|next_index\| blk: {
741	const next_sym = self.getSymbol(self.getAtom(next_index).getSymbolWithLoc());
742	const size = next_sym.n_value - (this_sym.n_value + atom.size);
743	break :blk math.cast(usize, size) orelse return error.Overflow;
744	} else 0;
745
746	log.debug(" (adding ATOM(%{d}, '{s}') from object({d}) to buffer)", .{
747	atom.sym_index,
748	self.getSymbolName(atom.getSymbolWithLoc()),
749	file,
750	});
751	if (padding_size > 0) {
752	log.debug(" (with padding {x})", .{padding_size});
753	}
754
755	const offset = this_sym.n_value - header.addr;
756	log.debug(" (at offset 0x{x})", .{offset});
757
758	const code = Atom.getAtomCode(self, atom_index);
759	const relocs = Atom.getAtomRelocs(self, atom_index);
760	const size = math.cast(usize, atom.size) orelse return error.Overflow;
761	@memcpy(buffer[offset .. offset + size], code);
762	try Atom.resolveRelocs(
763	self,
764	atom_index,
765	buffer[offset..][0..size],
766	relocs,
767	);
768	}
769
770	if (atom.next_index) \|next_index\| {
771	atom_index = next_index;
772	} else break;
773	}
774
775	log.debug(" (writing at file offset 0x{x})", .{header.offset});
776	try self.file.pwriteAll(buffer, header.offset);
777	}
778	}
779
780	fn writeDyldPrivateAtom(self: *Zld) !void {
781	const atom_index = self.dyld_private_atom_index orelse return;
782	const atom = self.getAtom(atom_index);
783	const sym = self.getSymbol(atom.getSymbolWithLoc());
784	const sect_id = self.data_section_index.?;
785	const header = self.sections.items(.header)[sect_id];
786	const offset = sym.n_value - header.addr + header.offset;
787	log.debug("writing __dyld_private at offset 0x{x}", .{offset});
788	const buffer: [@sizeOf(u64)]u8 = [_]u8{0} ** @sizeOf(u64);
789	try self.file.pwriteAll(&buffer, offset);
790	}
791
792	fn writeThunks(self: *Zld) !void {
793	assert(self.requiresThunks());
794	const gpa = self.gpa;
795
796	const sect_id = self.text_section_index orelse return;
797	const header = self.sections.items(.header)[sect_id];
798
799	for (self.thunks.items, 0..) \|*thunk, i\| {
800	if (thunk.getSize() == 0) continue;
801	var buffer = try std.ArrayList(u8).initCapacity(gpa, thunk.getSize());
802	defer buffer.deinit();
803	try thunks.writeThunkCode(self, thunk, buffer.writer());
804	const thunk_atom = self.getAtom(thunk.getStartAtomIndex());
805	const thunk_sym = self.getSymbol(thunk_atom.getSymbolWithLoc());
806	const offset = thunk_sym.n_value - header.addr + header.offset;
807	log.debug("writing thunk({d}) at offset 0x{x}", .{ i, offset });
808	try self.file.pwriteAll(buffer.items, offset);
809	}
810	}
811
812	fn writePointerEntries(self: *Zld, sect_id: u8, table: anytype) !void {
813	const header = self.sections.items(.header)[sect_id];
814	var buffer = try std.ArrayList(u8).initCapacity(self.gpa, header.size);
815	defer buffer.deinit();
816	for (table.entries.items) \|entry\| {
817	const sym = self.getSymbol(entry);
818	buffer.writer().writeIntLittle(u64, sym.n_value) catch unreachable;
819	}
820	log.debug("writing __DATA_CONST,__got contents at file offset 0x{x}", .{header.offset});
821	try self.file.pwriteAll(buffer.items, header.offset);
822	}
823
824	fn writeStubs(self: *Zld) !void {
825	const gpa = self.gpa;
826	const cpu_arch = self.options.target.cpu.arch;
827	const stubs_header = self.sections.items(.header)[self.stubs_section_index.?];
828	const la_symbol_ptr_header = self.sections.items(.header)[self.la_symbol_ptr_section_index.?];
829
830	var buffer = try std.ArrayList(u8).initCapacity(gpa, stubs_header.size);
831	defer buffer.deinit();
832
833	for (0..self.stubs_table.count()) \|index\| {
834	try stubs.writeStubCode(.{
835	.cpu_arch = cpu_arch,
836	.source_addr = stubs_header.addr + stubs.stubSize(cpu_arch) * index,
837	.target_addr = la_symbol_ptr_header.addr + index * @sizeOf(u64),
838	}, buffer.writer());
839	}
840
841	log.debug("writing __TEXT,__stubs contents at file offset 0x{x}", .{stubs_header.offset});
842	try self.file.pwriteAll(buffer.items, stubs_header.offset);
843	}
844
845	fn writeStubHelpers(self: *Zld) !void {
846	const gpa = self.gpa;
847	const cpu_arch = self.options.target.cpu.arch;
848	const stub_helper_header = self.sections.items(.header)[self.stub_helper_section_index.?];
849
850	var buffer = try std.ArrayList(u8).initCapacity(gpa, stub_helper_header.size);
851	defer buffer.deinit();
852
853	{
854	const dyld_private_addr = blk: {
855	const atom = self.getAtom(self.dyld_private_atom_index.?);
856	const sym = self.getSymbol(atom.getSymbolWithLoc());
857	break :blk sym.n_value;
858	};
859	const dyld_stub_binder_got_addr = blk: {
860	const sym_loc = self.globals.items[self.dyld_stub_binder_index.?];
861	break :blk self.getGotEntryAddress(sym_loc).?;
862	};
863	try stubs.writeStubHelperPreambleCode(.{
864	.cpu_arch = cpu_arch,
865	.source_addr = stub_helper_header.addr,
866	.dyld_private_addr = dyld_private_addr,
867	.dyld_stub_binder_got_addr = dyld_stub_binder_got_addr,
868	}, buffer.writer());
869	}
870
871	for (0..self.stubs_table.count()) \|index\| {
872	const source_addr = stub_helper_header.addr + stubs.stubHelperPreambleSize(cpu_arch) +
873	stubs.stubHelperSize(cpu_arch) * index;
874	try stubs.writeStubHelperCode(.{
875	.cpu_arch = cpu_arch,
876	.source_addr = source_addr,
877	.target_addr = stub_helper_header.addr,
878	}, buffer.writer());
879	}
880
881	log.debug("writing __TEXT,__stub_helper contents at file offset 0x{x}", .{
882	stub_helper_header.offset,
883	});
884	try self.file.pwriteAll(buffer.items, stub_helper_header.offset);
885	}
886
887	fn writeLaSymbolPtrs(self: *Zld) !void {
888	const gpa = self.gpa;
889	const cpu_arch = self.options.target.cpu.arch;
890	const la_symbol_ptr_header = self.sections.items(.header)[self.la_symbol_ptr_section_index.?];
891	const stub_helper_header = self.sections.items(.header)[self.stub_helper_section_index.?];
892
893	var buffer = try std.ArrayList(u8).initCapacity(gpa, la_symbol_ptr_header.size);
894	defer buffer.deinit();
895
896	for (0..self.stubs_table.count()) \|index\| {
897	const target_addr = stub_helper_header.addr + stubs.stubHelperPreambleSize(cpu_arch) +
898	stubs.stubHelperSize(cpu_arch) * index;
899	buffer.writer().writeIntLittle(u64, target_addr) catch unreachable;
900	}
901
902	log.debug("writing __DATA,__la_symbol_ptr contents at file offset 0x{x}", .{
903	la_symbol_ptr_header.offset,
904	});
905	try self.file.pwriteAll(buffer.items, la_symbol_ptr_header.offset);
906	}
907
908	fn pruneAndSortSections(self: *Zld) !void {
909	const Entry = struct {
910	index: u8,
911
912	pub fn lessThan(zld: *Zld, lhs: @This(), rhs: @This()) bool {
913	const lhs_header = zld.sections.items(.header)[lhs.index];
914	const rhs_header = zld.sections.items(.header)[rhs.index];
915	return MachO.getSectionPrecedence(lhs_header) < MachO.getSectionPrecedence(rhs_header);
916	}
917	};
918
919	const gpa = self.gpa;
920
921	var entries = try std.ArrayList(Entry).initCapacity(gpa, self.sections.slice().len);
922	defer entries.deinit();
923
924	for (0..self.sections.slice().len) \|index\| {
925	const section = self.sections.get(index);
926	if (section.header.size == 0) {
927	log.debug("pruning section {s},{s} {?d}", .{
928	section.header.segName(),
929	section.header.sectName(),
930	section.first_atom_index,
931	});
932	for (&[_]*?u8{
933	&self.text_section_index,
934	&self.data_const_section_index,
935	&self.data_section_index,
936	&self.bss_section_index,
937	&self.thread_vars_section_index,
938	&self.thread_data_section_index,
939	&self.thread_bss_section_index,
940	&self.eh_frame_section_index,
941	&self.unwind_info_section_index,
942	&self.got_section_index,
943	&self.tlv_ptr_section_index,
944	&self.stubs_section_index,
945	&self.stub_helper_section_index,
946	&self.la_symbol_ptr_section_index,
947	}) \|maybe_index\| {
948	if (maybe_index.* != null and maybe_index.*.? == index) {
949	maybe_index.* = null;
950	}
951	}
952	continue;
953	}
954	entries.appendAssumeCapacity(.{ .index = @intCast(index) });
955	}
956
957	mem.sort(Entry, entries.items, self, Entry.lessThan);
958
959	var slice = self.sections.toOwnedSlice();
960	defer slice.deinit(gpa);
961
962	const backlinks = try gpa.alloc(u8, slice.len);
963	defer gpa.free(backlinks);
964	for (entries.items, 0..) \|entry, i\| {
965	backlinks[entry.index] = @as(u8, @intCast(i));
966	}
967
968	try self.sections.ensureTotalCapacity(gpa, entries.items.len);
969	for (entries.items) \|entry\| {
970	self.sections.appendAssumeCapacity(slice.get(entry.index));
971	}
972
973	for (&[_]*?u8{
974	&self.text_section_index,
975	&self.data_const_section_index,
976	&self.data_section_index,
977	&self.bss_section_index,
978	&self.thread_vars_section_index,
979	&self.thread_data_section_index,
980	&self.thread_bss_section_index,
981	&self.eh_frame_section_index,
982	&self.unwind_info_section_index,
983	&self.got_section_index,
984	&self.tlv_ptr_section_index,
985	&self.stubs_section_index,
986	&self.stub_helper_section_index,
987	&self.la_symbol_ptr_section_index,
988	}) \|maybe_index\| {
989	if (maybe_index.) \|index\| {
990	index.* = backlinks[index.*];
991	}
992	}
993	}
994
995	fn calcSectionSizes(self: *Zld) !void {
996	const slice = self.sections.slice();
997	for (slice.items(.header), 0..) \|*header, sect_id\| {
998	if (header.size == 0) continue;
999	if (self.text_section_index) \|txt\| {
1000	if (txt == sect_id and self.requiresThunks()) continue;
1001	}
1002
1003	var atom_index = slice.items(.first_atom_index)[sect_id] orelse continue;
1004
1005	header.size = 0;
1006	header.@"align" = 0;
1007
1008	while (true) {
1009	const atom = self.getAtom(atom_index);
1010	const atom_alignment = try math.powi(u32, 2, atom.alignment);
1011	const atom_offset = mem.alignForward(u64, header.size, atom_alignment);
1012	const padding = atom_offset - header.size;
1013
1014	const sym = self.getSymbolPtr(atom.getSymbolWithLoc());
1015	sym.n_value = atom_offset;
1016
1017	header.size += padding + atom.size;
1018	header.@"align" = @max(header.@"align", atom.alignment);
1019
1020	if (atom.next_index) \|next_index\| {
1021	atom_index = next_index;
1022	} else break;
1023	}
1024	}
1025
1026	if (self.text_section_index != null and self.requiresThunks()) {
1027	// Create jump/branch range extenders if needed.
1028	try thunks.createThunks(self, self.text_section_index.?);
1029	}
1030
1031	// Update offsets of all symbols contained within each Atom.
1032	// We need to do this since our unwind info synthesiser relies on
1033	// traversing the symbols when synthesising unwind info and DWARF CFI records.
1034	for (slice.items(.first_atom_index)) \|first_atom_index\| {
1035	var atom_index = first_atom_index orelse continue;
1036
1037	while (true) {
1038	const atom = self.getAtom(atom_index);
1039	const sym = self.getSymbol(atom.getSymbolWithLoc());
1040
1041	if (atom.getFile() != null) {
1042	// Update each symbol contained within the atom
1043	var it = Atom.getInnerSymbolsIterator(self, atom_index);
1044	while (it.next()) \|sym_loc\| {
1045	const inner_sym = self.getSymbolPtr(sym_loc);
1046	inner_sym.n_value = sym.n_value + Atom.calcInnerSymbolOffset(
1047	self,
1048	atom_index,
1049	sym_loc.sym_index,
1050	);
1051	}
1052
1053	// If there is a section alias, update it now too
1054	if (Atom.getSectionAlias(self, atom_index)) \|sym_loc\| {
1055	const alias = self.getSymbolPtr(sym_loc);
1056	alias.n_value = sym.n_value;
1057	}
1058	}
1059
1060	if (atom.next_index) \|next_index\| {
1061	atom_index = next_index;
1062	} else break;
1063	}
1064	}
1065
1066	if (self.got_section_index) \|sect_id\| {
1067	const header = &self.sections.items(.header)[sect_id];
1068	header.size = self.got_table.count() * @sizeOf(u64);
1069	header.@"align" = 3;
1070	}
1071
1072	if (self.tlv_ptr_section_index) \|sect_id\| {
1073	const header = &self.sections.items(.header)[sect_id];
1074	header.size = self.tlv_ptr_table.count() * @sizeOf(u64);
1075	header.@"align" = 3;
1076	}
1077
1078	const cpu_arch = self.options.target.cpu.arch;
1079
1080	if (self.stubs_section_index) \|sect_id\| {
1081	const header = &self.sections.items(.header)[sect_id];
1082	header.size = self.stubs_table.count() * stubs.stubSize(cpu_arch);
1083	header.@"align" = stubs.stubAlignment(cpu_arch);
1084	}
1085
1086	if (self.stub_helper_section_index) \|sect_id\| {
1087	const header = &self.sections.items(.header)[sect_id];
1088	header.size = self.stubs_table.count() * stubs.stubHelperSize(cpu_arch) +
1089	stubs.stubHelperPreambleSize(cpu_arch);
1090	header.@"align" = stubs.stubAlignment(cpu_arch);
1091	}
1092
1093	if (self.la_symbol_ptr_section_index) \|sect_id\| {
1094	const header = &self.sections.items(.header)[sect_id];
1095	header.size = self.stubs_table.count() * @sizeOf(u64);
1096	header.@"align" = 3;
1097	}
1098	}
1099
1100	fn allocateSegments(self: *Zld) !void {
1101	for (self.segments.items, 0..) \|*segment, segment_index\| {
1102	const is_text_segment = mem.eql(u8, segment.segName(), "__TEXT");
1103	const base_size = if (is_text_segment) try load_commands.calcMinHeaderPad(self.gpa, self.options, .{
1104	.segments = self.segments.items,
1105	.dylibs = self.dylibs.items,
1106	.referenced_dylibs = self.referenced_dylibs.keys(),
1107	}) else 0;
1108	try self.allocateSegment(@as(u8, @intCast(segment_index)), base_size);
1109	}
1110	}
1111
1112	fn getSegmentAllocBase(self: Zld, segment_index: u8) struct { vmaddr: u64, fileoff: u64 } {
1113	if (segment_index > 0) {
1114	const prev_segment = self.segments.items[segment_index - 1];
1115	return .{
1116	.vmaddr = prev_segment.vmaddr + prev_segment.vmsize,
1117	.fileoff = prev_segment.fileoff + prev_segment.filesize,
1118	};
1119	}
1120	return .{ .vmaddr = 0, .fileoff = 0 };
1121	}
1122
1123	fn allocateSegment(self: *Zld, segment_index: u8, init_size: u64) !void {
1124	const segment = &self.segments.items[segment_index];
1125
1126	if (mem.eql(u8, segment.segName(), "__PAGEZERO")) return; // allocated upon creation
1127
1128	const base = self.getSegmentAllocBase(segment_index);
1129	segment.vmaddr = base.vmaddr;
1130	segment.fileoff = base.fileoff;
1131	segment.filesize = init_size;
1132	segment.vmsize = init_size;
1133
1134	// Allocate the sections according to their alignment at the beginning of the segment.
1135	const indexes = self.getSectionIndexes(segment_index);
1136	var start = init_size;
1137
1138	const slice = self.sections.slice();
1139	for (slice.items(.header)[indexes.start..indexes.end], 0..) \|*header, sect_id\| {
1140	const alignment = try math.powi(u32, 2, header.@"align");
1141	const start_aligned = mem.alignForward(u64, start, alignment);
1142	const n_sect = @as(u8, @intCast(indexes.start + sect_id + 1));
1143
1144	header.offset = if (header.isZerofill())
1145	0
1146	else
1147	@as(u32, @intCast(segment.fileoff + start_aligned));
1148	header.addr = segment.vmaddr + start_aligned;
1149
1150	if (slice.items(.first_atom_index)[indexes.start + sect_id]) \|first_atom_index\| {
1151	var atom_index = first_atom_index;
1152
1153	log.debug("allocating local symbols in sect({d}, '{s},{s}')", .{
1154	n_sect,
1155	header.segName(),
1156	header.sectName(),
1157	});
1158
1159	while (true) {
1160	const atom = self.getAtom(atom_index);
1161	const sym = self.getSymbolPtr(atom.getSymbolWithLoc());
1162	sym.n_value += header.addr;
1163	sym.n_sect = n_sect;
1164
1165	log.debug(" ATOM(%{d}, '{s}') @{x}", .{
1166	atom.sym_index,
1167	self.getSymbolName(atom.getSymbolWithLoc()),
1168	sym.n_value,
1169	});
1170
1171	if (atom.getFile() != null) {
1172	// Update each symbol contained within the atom
1173	var it = Atom.getInnerSymbolsIterator(self, atom_index);
1174	while (it.next()) \|sym_loc\| {
1175	const inner_sym = self.getSymbolPtr(sym_loc);
1176	inner_sym.n_value = sym.n_value + Atom.calcInnerSymbolOffset(
1177	self,
1178	atom_index,
1179	sym_loc.sym_index,
1180	);
1181	inner_sym.n_sect = n_sect;
1182	}
1183
1184	// If there is a section alias, update it now too
1185	if (Atom.getSectionAlias(self, atom_index)) \|sym_loc\| {
1186	const alias = self.getSymbolPtr(sym_loc);
1187	alias.n_value = sym.n_value;
1188	alias.n_sect = n_sect;
1189	}
1190	}
1191
1192	if (atom.next_index) \|next_index\| {
1193	atom_index = next_index;
1194	} else break;
1195	}
1196	}
1197
1198	start = start_aligned + header.size;
1199
1200	if (!header.isZerofill()) {
1201	segment.filesize = start;
1202	}
1203	segment.vmsize = start;
1204	}
1205
1206	const page_size = MachO.getPageSize(self.options.target.cpu.arch);
1207	segment.filesize = mem.alignForward(u64, segment.filesize, page_size);
1208	segment.vmsize = mem.alignForward(u64, segment.vmsize, page_size);
1209	}
1210
1211	fn writeLinkeditSegmentData(self: *Zld) !void {
1212	const page_size = MachO.getPageSize(self.options.target.cpu.arch);
1213	const seg = self.getLinkeditSegmentPtr();
1214	seg.filesize = 0;
1215	seg.vmsize = 0;
1216
1217	for (self.segments.items, 0..) \|segment, id\| {
1218	if (self.linkedit_segment_cmd_index.? == @as(u8, @intCast(id))) continue;
1219	if (seg.vmaddr < segment.vmaddr + segment.vmsize) {
1220	seg.vmaddr = mem.alignForward(u64, segment.vmaddr + segment.vmsize, page_size);
1221	}
1222	if (seg.fileoff < segment.fileoff + segment.filesize) {
1223	seg.fileoff = mem.alignForward(u64, segment.fileoff + segment.filesize, page_size);
1224	}
1225	}
1226	try self.writeDyldInfoData();
1227	try self.writeFunctionStarts();
1228	try self.writeDataInCode();
1229	try self.writeSymtabs();
1230
1231	seg.vmsize = mem.alignForward(u64, seg.filesize, page_size);
1232	}
1233
1234	fn collectRebaseData(self: Zld, rebase: Rebase) !void {
1235	log.debug("collecting rebase data", .{});
1236
1237	// First, unpack GOT entries
1238	if (self.got_section_index) \|sect_id\| {
1239	try MachO.collectRebaseDataFromTableSection(self.gpa, self, sect_id, rebase, self.got_table);
1240	}
1241
1242	// Next, unpack __la_symbol_ptr entries
1243	if (self.la_symbol_ptr_section_index) \|sect_id\| {
1244	try MachO.collectRebaseDataFromTableSection(self.gpa, self, sect_id, rebase, self.stubs_table);
1245	}
1246
1247	// Finally, unpack the rest.
1248	const cpu_arch = self.options.target.cpu.arch;
1249	for (self.objects.items) \|*object\| {
1250	for (object.atoms.items) \|atom_index\| {
1251	const atom = self.getAtom(atom_index);
1252	const sym = self.getSymbol(atom.getSymbolWithLoc());
1253	if (sym.n_desc == MachO.N_DEAD) continue;
1254
1255	const sect_id = sym.n_sect - 1;
1256	const section = self.sections.items(.header)[sect_id];
1257	const segment_id = self.sections.items(.segment_index)[sect_id];
1258	const segment = self.segments.items[segment_id];
1259	if (segment.maxprot & macho.PROT.WRITE == 0) continue;
1260	switch (section.type()) {
1261	macho.S_LITERAL_POINTERS,
1262	macho.S_REGULAR,
1263	macho.S_MOD_INIT_FUNC_POINTERS,
1264	macho.S_MOD_TERM_FUNC_POINTERS,
1265	=> {},
1266	else => continue,
1267	}
1268
1269	log.debug(" ATOM({d}, %{d}, '{s}')", .{
1270	atom_index,
1271	atom.sym_index,
1272	self.getSymbolName(atom.getSymbolWithLoc()),
1273	});
1274
1275	const code = Atom.getAtomCode(self, atom_index);
1276	const relocs = Atom.getAtomRelocs(self, atom_index);
1277	const ctx = Atom.getRelocContext(self, atom_index);
1278
1279	for (relocs) \|rel\| {
1280	switch (cpu_arch) {
1281	.aarch64 => {
1282	const rel_type = @as(macho.reloc_type_arm64, @enumFromInt(rel.r_type));
1283	if (rel_type != .ARM64_RELOC_UNSIGNED) continue;
1284	if (rel.r_length != 3) continue;
1285	},
1286	.x86_64 => {
1287	const rel_type = @as(macho.reloc_type_x86_64, @enumFromInt(rel.r_type));
1288	if (rel_type != .X86_64_RELOC_UNSIGNED) continue;
1289	if (rel.r_length != 3) continue;
1290	},
1291	else => unreachable,
1292	}
1293	const target = Atom.parseRelocTarget(self, .{
1294	.object_id = atom.getFile().?,
1295	.rel = rel,
1296	.code = code,
1297	.base_offset = ctx.base_offset,
1298	.base_addr = ctx.base_addr,
1299	});
1300	const target_sym = self.getSymbol(target);
1301	if (target_sym.undf()) continue;
1302
1303	const base_offset = @as(i32, @intCast(sym.n_value - segment.vmaddr));
1304	const rel_offset = rel.r_address - ctx.base_offset;
1305	const offset = @as(u64, @intCast(base_offset + rel_offset));
1306	log.debug(" \| rebase at {x}", .{offset});
1307
1308	try rebase.entries.append(self.gpa, .{
1309	.offset = offset,
1310	.segment_id = segment_id,
1311	});
1312	}
1313	}
1314	}
1315
1316	try rebase.finalize(self.gpa);
1317	}
1318
1319	fn collectBindData(
1320	self: *Zld,
1321	bind: *Bind,
1322	) !void {
1323	log.debug("collecting bind data", .{});
1324
1325	// First, unpack GOT section
1326	if (self.got_section_index) \|sect_id\| {
1327	try MachO.collectBindDataFromTableSection(self.gpa, self, sect_id, bind, self.got_table);
1328	}
1329
1330	// Next, unpack TLV pointers section
1331	if (self.tlv_ptr_section_index) \|sect_id\| {
1332	try MachO.collectBindDataFromTableSection(self.gpa, self, sect_id, bind, self.tlv_ptr_table);
1333	}
1334
1335	// Finally, unpack the rest.
1336	const cpu_arch = self.options.target.cpu.arch;
1337	for (self.objects.items) \|*object\| {
1338	for (object.atoms.items) \|atom_index\| {
1339	const atom = self.getAtom(atom_index);
1340	const sym = self.getSymbol(atom.getSymbolWithLoc());
1341	if (sym.n_desc == MachO.N_DEAD) continue;
1342
1343	const sect_id = sym.n_sect - 1;
1344	const section = self.sections.items(.header)[sect_id];
1345	const segment_id = self.sections.items(.segment_index)[sect_id];
1346	const segment = self.segments.items[segment_id];
1347	if (segment.maxprot & macho.PROT.WRITE == 0) continue;
1348	switch (section.type()) {
1349	macho.S_LITERAL_POINTERS,
1350	macho.S_REGULAR,
1351	macho.S_MOD_INIT_FUNC_POINTERS,
1352	macho.S_MOD_TERM_FUNC_POINTERS,
1353	=> {},
1354	else => continue,
1355	}
1356
1357	log.debug(" ATOM({d}, %{d}, '{s}')", .{
1358	atom_index,
1359	atom.sym_index,
1360	self.getSymbolName(atom.getSymbolWithLoc()),
1361	});
1362
1363	const code = Atom.getAtomCode(self, atom_index);
1364	const relocs = Atom.getAtomRelocs(self, atom_index);
1365	const ctx = Atom.getRelocContext(self, atom_index);
1366
1367	for (relocs) \|rel\| {
1368	switch (cpu_arch) {
1369	.aarch64 => {
1370	const rel_type = @as(macho.reloc_type_arm64, @enumFromInt(rel.r_type));
1371	if (rel_type != .ARM64_RELOC_UNSIGNED) continue;
1372	if (rel.r_length != 3) continue;
1373	},
1374	.x86_64 => {
1375	const rel_type = @as(macho.reloc_type_x86_64, @enumFromInt(rel.r_type));
1376	if (rel_type != .X86_64_RELOC_UNSIGNED) continue;
1377	if (rel.r_length != 3) continue;
1378	},
1379	else => unreachable,
1380	}
1381
1382	const global = Atom.parseRelocTarget(self, .{
1383	.object_id = atom.getFile().?,
1384	.rel = rel,
1385	.code = code,
1386	.base_offset = ctx.base_offset,
1387	.base_addr = ctx.base_addr,
1388	});
1389	const bind_sym_name = self.getSymbolName(global);
1390	const bind_sym = self.getSymbol(global);
1391	if (!bind_sym.undf()) continue;
1392
1393	const base_offset = sym.n_value - segment.vmaddr;
1394	const rel_offset = @as(u32, @intCast(rel.r_address - ctx.base_offset));
1395	const offset = @as(u64, @intCast(base_offset + rel_offset));
1396	const addend = mem.readIntLittle(i64, code[rel_offset..][0..8]);
1397
1398	const dylib_ordinal = @divTrunc(@as(i16, @bitCast(bind_sym.n_desc)), macho.N_SYMBOL_RESOLVER);
1399	log.debug(" \| bind at {x}, import('{s}') in dylib({d})", .{
1400	base_offset,
1401	bind_sym_name,
1402	dylib_ordinal,
1403	});
1404	log.debug(" \| with addend {x}", .{addend});
1405	if (bind_sym.weakRef()) {
1406	log.debug(" \| marking as weak ref ", .{});
1407	}
1408	try bind.entries.append(self.gpa, .{
1409	.target = global,
1410	.offset = offset,
1411	.segment_id = segment_id,
1412	.addend = addend,
1413	});
1414	}
1415	}
1416	}
1417
1418	try bind.finalize(self.gpa, self);
1419	}
1420
1421	fn collectLazyBindData(self: Zld, lazy_bind: LazyBind) !void {
1422	const sect_id = self.la_symbol_ptr_section_index orelse return;
1423	try MachO.collectBindDataFromTableSection(self.gpa, self, sect_id, lazy_bind, self.stubs_table);
1424	try lazy_bind.finalize(self.gpa, self);
1425	}
1426
1427	fn collectExportData(self: Zld, trie: Trie) !void {
1428	const gpa = self.gpa;
1429
1430	// TODO handle macho.EXPORT_SYMBOL_FLAGS_REEXPORT and macho.EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER.
1431	log.debug("collecting export data", .{});
1432
1433	const exec_segment = self.segments.items[self.header_segment_cmd_index.?];
1434	const base_address = exec_segment.vmaddr;
1435
1436	for (self.globals.items) \|global\| {
1437	const sym = self.getSymbol(global);
1438	if (sym.undf()) continue;
1439	if (sym.n_desc == MachO.N_DEAD) continue;
1440
1441	const sym_name = self.getSymbolName(global);
1442	log.debug(" (putting '{s}' defined at 0x{x})", .{ sym_name, sym.n_value });
1443	try trie.put(gpa, .{
1444	.name = sym_name,
1445	.vmaddr_offset = sym.n_value - base_address,
1446	.export_flags = macho.EXPORT_SYMBOL_FLAGS_KIND_REGULAR,
1447	});
1448	}
1449
1450	try trie.finalize(gpa);
1451	}
1452
1453	fn writeDyldInfoData(self: *Zld) !void {
1454	const gpa = self.gpa;
1455
1456	var rebase = Rebase{};
1457	defer rebase.deinit(gpa);
1458	try self.collectRebaseData(&rebase);
1459
1460	var bind = Bind{};
1461	defer bind.deinit(gpa);
1462	try self.collectBindData(&bind);
1463
1464	var lazy_bind = LazyBind{};
1465	defer lazy_bind.deinit(gpa);
1466	try self.collectLazyBindData(&lazy_bind);
1467
1468	var trie = Trie{};
1469	defer trie.deinit(gpa);
1470	try trie.init(gpa);
1471	try self.collectExportData(&trie);
1472
1473	const link_seg = self.getLinkeditSegmentPtr();
1474	assert(mem.isAlignedGeneric(u64, link_seg.fileoff, @alignOf(u64)));
1475	const rebase_off = link_seg.fileoff;
1476	const rebase_size = rebase.size();
1477	const rebase_size_aligned = mem.alignForward(u64, rebase_size, @alignOf(u64));
1478	log.debug("writing rebase info from 0x{x} to 0x{x}", .{ rebase_off, rebase_off + rebase_size_aligned });
1479
1480	const bind_off = rebase_off + rebase_size_aligned;
1481	const bind_size = bind.size();
1482	const bind_size_aligned = mem.alignForward(u64, bind_size, @alignOf(u64));
1483	log.debug("writing bind info from 0x{x} to 0x{x}", .{ bind_off, bind_off + bind_size_aligned });
1484
1485	const lazy_bind_off = bind_off + bind_size_aligned;
1486	const lazy_bind_size = lazy_bind.size();
1487	const lazy_bind_size_aligned = mem.alignForward(u64, lazy_bind_size, @alignOf(u64));
1488	log.debug("writing lazy bind info from 0x{x} to 0x{x}", .{
1489	lazy_bind_off,
1490	lazy_bind_off + lazy_bind_size_aligned,
1491	});
1492
1493	const export_off = lazy_bind_off + lazy_bind_size_aligned;
1494	const export_size = trie.size;
1495	const export_size_aligned = mem.alignForward(u64, export_size, @alignOf(u64));
1496	log.debug("writing export trie from 0x{x} to 0x{x}", .{ export_off, export_off + export_size_aligned });
1497
1498	const needed_size = math.cast(usize, export_off + export_size_aligned - rebase_off) orelse
1499	return error.Overflow;
1500	link_seg.filesize = needed_size;
1501	assert(mem.isAlignedGeneric(u64, link_seg.fileoff + link_seg.filesize, @alignOf(u64)));
1502
1503	var buffer = try gpa.alloc(u8, needed_size);
1504	defer gpa.free(buffer);
1505	@memset(buffer, 0);
1506
1507	var stream = std.io.fixedBufferStream(buffer);
1508	const writer = stream.writer();
1509
1510	try rebase.write(writer);
1511	try stream.seekTo(bind_off - rebase_off);
1512
1513	try bind.write(writer);
1514	try stream.seekTo(lazy_bind_off - rebase_off);
1515
1516	try lazy_bind.write(writer);
1517	try stream.seekTo(export_off - rebase_off);
1518
1519	_ = try trie.write(writer);
1520
1521	log.debug("writing dyld info from 0x{x} to 0x{x}", .{
1522	rebase_off,
1523	rebase_off + needed_size,
1524	});
1525
1526	try self.file.pwriteAll(buffer, rebase_off);
1527	try MachO.populateLazyBindOffsetsInStubHelper(
1528	self,
1529	self.options.target.cpu.arch,
1530	self.file,
1531	lazy_bind,
1532	);
1533
1534	self.dyld_info_cmd.rebase_off = @as(u32, @intCast(rebase_off));
1535	self.dyld_info_cmd.rebase_size = @as(u32, @intCast(rebase_size_aligned));
1536	self.dyld_info_cmd.bind_off = @as(u32, @intCast(bind_off));
1537	self.dyld_info_cmd.bind_size = @as(u32, @intCast(bind_size_aligned));
1538	self.dyld_info_cmd.lazy_bind_off = @as(u32, @intCast(lazy_bind_off));
1539	self.dyld_info_cmd.lazy_bind_size = @as(u32, @intCast(lazy_bind_size_aligned));
1540	self.dyld_info_cmd.export_off = @as(u32, @intCast(export_off));
1541	self.dyld_info_cmd.export_size = @as(u32, @intCast(export_size_aligned));
1542	}
1543
1544	const asc_u64 = std.sort.asc(u64);
1545
1546	fn addSymbolToFunctionStarts(self: Zld, sym_loc: SymbolWithLoc, addresses: std.ArrayList(u64)) !void {
1547	const sym = self.getSymbol(sym_loc);
1548	if (sym.n_strx == 0) return;
1549	if (sym.n_desc == MachO.N_DEAD) return;
1550	if (self.symbolIsTemp(sym_loc)) return;
1551	try addresses.append(sym.n_value);
1552	}
1553
1554	fn writeFunctionStarts(self: *Zld) !void {
1555	const gpa = self.gpa;
1556	const seg = self.segments.items[self.header_segment_cmd_index.?];
1557
1558	// We need to sort by address first
1559	var addresses = std.ArrayList(u64).init(gpa);
1560	defer addresses.deinit();
1561
1562	for (self.objects.items) \|object\| {
1563	for (object.exec_atoms.items) \|atom_index\| {
1564	const atom = self.getAtom(atom_index);
1565	const sym_loc = atom.getSymbolWithLoc();
1566	try self.addSymbolToFunctionStarts(sym_loc, &addresses);
1567
1568	var it = Atom.getInnerSymbolsIterator(self, atom_index);
1569	while (it.next()) \|inner_sym_loc\| {
1570	try self.addSymbolToFunctionStarts(inner_sym_loc, &addresses);
1571	}
1572	}
1573	}
1574
1575	mem.sort(u64, addresses.items, {}, asc_u64);
1576
1577	var offsets = std.ArrayList(u32).init(gpa);
1578	defer offsets.deinit();
1579	try offsets.ensureTotalCapacityPrecise(addresses.items.len);
1580
1581	var last_off: u32 = 0;
1582	for (addresses.items) \|addr\| {
1583	const offset = @as(u32, @intCast(addr - seg.vmaddr));
1584	const diff = offset - last_off;
1585
1586	if (diff == 0) continue;
1587
1588	offsets.appendAssumeCapacity(diff);
1589	last_off = offset;
1590	}
1591
1592	var buffer = std.ArrayList(u8).init(gpa);
1593	defer buffer.deinit();
1594
1595	const max_size = @as(usize, @intCast(offsets.items.len * @sizeOf(u64)));
1596	try buffer.ensureTotalCapacity(max_size);
1597
1598	for (offsets.items) \|offset\| {
1599	try std.leb.writeULEB128(buffer.writer(), offset);
1600	}
1601
1602	const link_seg = self.getLinkeditSegmentPtr();
1603	const offset = link_seg.fileoff + link_seg.filesize;
1604	assert(mem.isAlignedGeneric(u64, offset, @alignOf(u64)));
1605	const needed_size = buffer.items.len;
1606	const needed_size_aligned = mem.alignForward(u64, needed_size, @alignOf(u64));
1607	const padding = math.cast(usize, needed_size_aligned - needed_size) orelse return error.Overflow;
1608	if (padding > 0) {
1609	try buffer.ensureUnusedCapacity(padding);
1610	buffer.appendNTimesAssumeCapacity(0, padding);
1611	}
1612	link_seg.filesize = offset + needed_size_aligned - link_seg.fileoff;
1613
1614	log.debug("writing function starts info from 0x{x} to 0x{x}", .{ offset, offset + needed_size_aligned });
1615
1616	try self.file.pwriteAll(buffer.items, offset);
1617
1618	self.function_starts_cmd.dataoff = @as(u32, @intCast(offset));
1619	self.function_starts_cmd.datasize = @as(u32, @intCast(needed_size_aligned));
1620	}
1621
1622	fn filterDataInCode(
1623	dices: []const macho.data_in_code_entry,
1624	start_addr: u64,
1625	end_addr: u64,
1626	) []const macho.data_in_code_entry {
1627	const Predicate = struct {
1628	addr: u64,
1629
1630	pub fn predicate(self: @This(), dice: macho.data_in_code_entry) bool {
1631	return dice.offset >= self.addr;
1632	}
1633	};
1634
1635	const start = MachO.lsearch(macho.data_in_code_entry, dices, Predicate{ .addr = start_addr });
1636	const end = MachO.lsearch(macho.data_in_code_entry, dices[start..], Predicate{ .addr = end_addr }) + start;
1637
1638	return dices[start..end];
1639	}
1640
1641	fn writeDataInCode(self: *Zld) !void {
1642	var out_dice = std.ArrayList(macho.data_in_code_entry).init(self.gpa);
1643	defer out_dice.deinit();
1644
1645	const text_sect_id = self.text_section_index orelse return;
1646	const text_sect_header = self.sections.items(.header)[text_sect_id];
1647
1648	for (self.objects.items) \|object\| {
1649	if (!object.hasDataInCode()) continue;
1650	const dice = object.data_in_code.items;
1651	try out_dice.ensureUnusedCapacity(dice.len);
1652
1653	for (object.exec_atoms.items) \|atom_index\| {
1654	const atom = self.getAtom(atom_index);
1655	const sym = self.getSymbol(atom.getSymbolWithLoc());
1656	if (sym.n_desc == MachO.N_DEAD) continue;
1657
1658	const source_addr = if (object.getSourceSymbol(atom.sym_index)) \|source_sym\|
1659	source_sym.n_value
1660	else blk: {
1661	const nbase = @as(u32, @intCast(object.in_symtab.?.len));
1662	const source_sect_id = @as(u8, @intCast(atom.sym_index - nbase));
1663	break :blk object.getSourceSection(source_sect_id).addr;
1664	};
1665	const filtered_dice = filterDataInCode(dice, source_addr, source_addr + atom.size);
1666	const base = math.cast(u32, sym.n_value - text_sect_header.addr + text_sect_header.offset) orelse
1667	return error.Overflow;
1668
1669	for (filtered_dice) \|single\| {
1670	const offset = math.cast(u32, single.offset - source_addr + base) orelse
1671	return error.Overflow;
1672	out_dice.appendAssumeCapacity(.{
1673	.offset = offset,
1674	.length = single.length,
1675	.kind = single.kind,
1676	});
1677	}
1678	}
1679	}
1680
1681	const seg = self.getLinkeditSegmentPtr();
1682	const offset = seg.fileoff + seg.filesize;
1683	assert(mem.isAlignedGeneric(u64, offset, @alignOf(u64)));
1684	const needed_size = out_dice.items.len * @sizeOf(macho.data_in_code_entry);
1685	const needed_size_aligned = mem.alignForward(u64, needed_size, @alignOf(u64));
1686	seg.filesize = offset + needed_size_aligned - seg.fileoff;
1687
1688	const buffer = try self.gpa.alloc(u8, math.cast(usize, needed_size_aligned) orelse return error.Overflow);
1689	defer self.gpa.free(buffer);
1690	{
1691	const src = mem.sliceAsBytes(out_dice.items);
1692	@memcpy(buffer[0..src.len], src);
1693	@memset(buffer[src.len..], 0);
1694	}
1695
1696	log.debug("writing data-in-code from 0x{x} to 0x{x}", .{ offset, offset + needed_size_aligned });
1697
1698	try self.file.pwriteAll(buffer, offset);
1699
1700	self.data_in_code_cmd.dataoff = @as(u32, @intCast(offset));
1701	self.data_in_code_cmd.datasize = @as(u32, @intCast(needed_size_aligned));
1702	}
1703
1704	fn writeSymtabs(self: *Zld) !void {
1705	var ctx = try self.writeSymtab();
1706	defer ctx.imports_table.deinit();
1707	try self.writeDysymtab(ctx);
1708	try self.writeStrtab();
1709	}
1710
1711	fn addLocalToSymtab(self: Zld, sym_loc: SymbolWithLoc, locals: std.ArrayList(macho.nlist_64)) !void {
1712	const sym = self.getSymbol(sym_loc);
1713	if (sym.n_strx == 0) return; // no name, skip
1714	if (sym.n_desc == MachO.N_DEAD) return; // garbage-collected, skip
1715	if (sym.ext()) return; // an export lands in its own symtab section, skip
1716	if (self.symbolIsTemp(sym_loc)) return; // local temp symbol, skip
1717
1718	var out_sym = sym;
1719	out_sym.n_strx = try self.strtab.insert(self.gpa, self.getSymbolName(sym_loc));
1720	try locals.append(out_sym);
1721	}
1722
1723	fn writeSymtab(self: *Zld) !SymtabCtx {
1724	const gpa = self.gpa;
1725
1726	var locals = std.ArrayList(macho.nlist_64).init(gpa);
1727	defer locals.deinit();
1728
1729	for (self.objects.items) \|object\| {
1730	for (object.atoms.items) \|atom_index\| {
1731	const atom = self.getAtom(atom_index);
1732	const sym_loc = atom.getSymbolWithLoc();
1733	try self.addLocalToSymtab(sym_loc, &locals);
1734
1735	var it = Atom.getInnerSymbolsIterator(self, atom_index);
1736	while (it.next()) \|inner_sym_loc\| {
1737	try self.addLocalToSymtab(inner_sym_loc, &locals);
1738	}
1739	}
1740	}
1741
1742	var exports = std.ArrayList(macho.nlist_64).init(gpa);
1743	defer exports.deinit();
1744
1745	for (self.globals.items) \|global\| {
1746	const sym = self.getSymbol(global);
1747	if (sym.undf()) continue; // import, skip
1748	if (sym.n_desc == MachO.N_DEAD) continue;
1749
1750	var out_sym = sym;
1751	out_sym.n_strx = try self.strtab.insert(gpa, self.getSymbolName(global));
1752	try exports.append(out_sym);
1753	}
1754
1755	var imports = std.ArrayList(macho.nlist_64).init(gpa);
1756	defer imports.deinit();
1757
1758	var imports_table = std.AutoHashMap(SymbolWithLoc, u32).init(gpa);
1759
1760	for (self.globals.items) \|global\| {
1761	const sym = self.getSymbol(global);
1762	if (!sym.undf()) continue; // not an import, skip
1763	if (sym.n_desc == MachO.N_DEAD) continue;
1764
1765	const new_index = @as(u32, @intCast(imports.items.len));
1766	var out_sym = sym;
1767	out_sym.n_strx = try self.strtab.insert(gpa, self.getSymbolName(global));
1768	try imports.append(out_sym);
1769	try imports_table.putNoClobber(global, new_index);
1770	}
1771
1772	// We generate stabs last in order to ensure that the strtab always has debug info
1773	// strings trailing
1774	if (!self.options.strip) {
1775	for (self.objects.items) \|object\| {
1776	try self.generateSymbolStabs(object, &locals);
1777	}
1778	}
1779
1780	const nlocals = @as(u32, @intCast(locals.items.len));
1781	const nexports = @as(u32, @intCast(exports.items.len));
1782	const nimports = @as(u32, @intCast(imports.items.len));
1783	const nsyms = nlocals + nexports + nimports;
1784
1785	const seg = self.getLinkeditSegmentPtr();
1786	const offset = seg.fileoff + seg.filesize;
1787	assert(mem.isAlignedGeneric(u64, offset, @alignOf(u64)));
1788	const needed_size = nsyms * @sizeOf(macho.nlist_64);
1789	seg.filesize = offset + needed_size - seg.fileoff;
1790	assert(mem.isAlignedGeneric(u64, seg.fileoff + seg.filesize, @alignOf(u64)));
1791
1792	var buffer = std.ArrayList(u8).init(gpa);
1793	defer buffer.deinit();
1794	try buffer.ensureTotalCapacityPrecise(needed_size);
1795	buffer.appendSliceAssumeCapacity(mem.sliceAsBytes(locals.items));
1796	buffer.appendSliceAssumeCapacity(mem.sliceAsBytes(exports.items));
1797	buffer.appendSliceAssumeCapacity(mem.sliceAsBytes(imports.items));
1798
1799	log.debug("writing symtab from 0x{x} to 0x{x}", .{ offset, offset + needed_size });
1800	try self.file.pwriteAll(buffer.items, offset);
1801
1802	self.symtab_cmd.symoff = @as(u32, @intCast(offset));
1803	self.symtab_cmd.nsyms = nsyms;
1804
1805	return SymtabCtx{
1806	.nlocalsym = nlocals,
1807	.nextdefsym = nexports,
1808	.nundefsym = nimports,
1809	.imports_table = imports_table,
1810	};
1811	}
1812
1813	fn writeStrtab(self: *Zld) !void {
1814	const seg = self.getLinkeditSegmentPtr();
1815	const offset = seg.fileoff + seg.filesize;
1816	assert(mem.isAlignedGeneric(u64, offset, @alignOf(u64)));
1817	const needed_size = self.strtab.buffer.items.len;
1818	const needed_size_aligned = mem.alignForward(u64, needed_size, @alignOf(u64));
1819	seg.filesize = offset + needed_size_aligned - seg.fileoff;
1820
1821	log.debug("writing string table from 0x{x} to 0x{x}", .{ offset, offset + needed_size_aligned });
1822
1823	const buffer = try self.gpa.alloc(u8, math.cast(usize, needed_size_aligned) orelse return error.Overflow);
1824	defer self.gpa.free(buffer);
1825	@memcpy(buffer[0..self.strtab.buffer.items.len], self.strtab.buffer.items);
1826	@memset(buffer[self.strtab.buffer.items.len..], 0);
1827
1828	try self.file.pwriteAll(buffer, offset);
1829
1830	self.symtab_cmd.stroff = @as(u32, @intCast(offset));
1831	self.symtab_cmd.strsize = @as(u32, @intCast(needed_size_aligned));
1832	}
1833
1834	const SymtabCtx = struct {
1835	nlocalsym: u32,
1836	nextdefsym: u32,
1837	nundefsym: u32,
1838	imports_table: std.AutoHashMap(SymbolWithLoc, u32),
1839	};
1840
1841	fn writeDysymtab(self: *Zld, ctx: SymtabCtx) !void {
1842	const gpa = self.gpa;
1843	const nstubs = @as(u32, @intCast(self.stubs_table.lookup.count()));
1844	const ngot_entries = @as(u32, @intCast(self.got_table.lookup.count()));
1845	const nindirectsyms = nstubs * 2 + ngot_entries;
1846	const iextdefsym = ctx.nlocalsym;
1847	const iundefsym = iextdefsym + ctx.nextdefsym;
1848
1849	const seg = self.getLinkeditSegmentPtr();
1850	const offset = seg.fileoff + seg.filesize;
1851	assert(mem.isAlignedGeneric(u64, offset, @alignOf(u64)));
1852	const needed_size = nindirectsyms * @sizeOf(u32);
1853	const needed_size_aligned = mem.alignForward(u64, needed_size, @alignOf(u64));
1854	seg.filesize = offset + needed_size_aligned - seg.fileoff;
1855
1856	log.debug("writing indirect symbol table from 0x{x} to 0x{x}", .{ offset, offset + needed_size_aligned });
1857
1858	var buf = std.ArrayList(u8).init(gpa);
1859	defer buf.deinit();
1860	try buf.ensureTotalCapacityPrecise(math.cast(usize, needed_size_aligned) orelse return error.Overflow);
1861	const writer = buf.writer();
1862
1863	if (self.stubs_section_index) \|sect_id\| {
1864	const header = &self.sections.items(.header)[sect_id];
1865	header.reserved1 = 0;
1866	for (self.stubs_table.entries.items) \|entry\| {
1867	if (!self.stubs_table.lookup.contains(entry)) continue;
1868	const target_sym = self.getSymbol(entry);
1869	assert(target_sym.undf());
1870	try writer.writeIntLittle(u32, iundefsym + ctx.imports_table.get(entry).?);
1871	}
1872	}
1873
1874	if (self.got_section_index) \|sect_id\| {
1875	const header = &self.sections.items(.header)[sect_id];
1876	header.reserved1 = nstubs;
1877	for (self.got_table.entries.items) \|entry\| {
1878	if (!self.got_table.lookup.contains(entry)) continue;
1879	const target_sym = self.getSymbol(entry);
1880	if (target_sym.undf()) {
1881	try writer.writeIntLittle(u32, iundefsym + ctx.imports_table.get(entry).?);
1882	} else {
1883	try writer.writeIntLittle(u32, macho.INDIRECT_SYMBOL_LOCAL);
1884	}
1885	}
1886	}
1887
1888	if (self.la_symbol_ptr_section_index) \|sect_id\| {
1889	const header = &self.sections.items(.header)[sect_id];
1890	header.reserved1 = nstubs + ngot_entries;
1891	for (self.stubs_table.entries.items) \|entry\| {
1892	if (!self.stubs_table.lookup.contains(entry)) continue;
1893	const target_sym = self.getSymbol(entry);
1894	assert(target_sym.undf());
1895	try writer.writeIntLittle(u32, iundefsym + ctx.imports_table.get(entry).?);
1896	}
1897	}
1898
1899	const padding = math.cast(usize, needed_size_aligned - needed_size) orelse return error.Overflow;
1900	if (padding > 0) {
1901	buf.appendNTimesAssumeCapacity(0, padding);
1902	}
1903
1904	assert(buf.items.len == needed_size_aligned);
1905	try self.file.pwriteAll(buf.items, offset);
1906
1907	self.dysymtab_cmd.nlocalsym = ctx.nlocalsym;
1908	self.dysymtab_cmd.iextdefsym = iextdefsym;
1909	self.dysymtab_cmd.nextdefsym = ctx.nextdefsym;
1910	self.dysymtab_cmd.iundefsym = iundefsym;
1911	self.dysymtab_cmd.nundefsym = ctx.nundefsym;
1912	self.dysymtab_cmd.indirectsymoff = @as(u32, @intCast(offset));
1913	self.dysymtab_cmd.nindirectsyms = nindirectsyms;
1914	}
1915
1916	fn writeUuid(self: Zld, comp: const Compilation, uuid_cmd_offset: u32, has_codesig: bool) !void {
1917	const file_size = if (!has_codesig) blk: {
1918	const seg = self.getLinkeditSegmentPtr();
1919	break :blk seg.fileoff + seg.filesize;
1920	} else self.codesig_cmd.dataoff;
1921	try calcUuid(comp, self.file, file_size, &self.uuid_cmd.uuid);
1922	const offset = uuid_cmd_offset + @sizeOf(macho.load_command);
1923	try self.file.pwriteAll(&self.uuid_cmd.uuid, offset);
1924	}
1925
1926	fn writeCodeSignaturePadding(self: Zld, code_sig: CodeSignature) !void {
1927	const seg = self.getLinkeditSegmentPtr();
1928	// Code signature data has to be 16-bytes aligned for Apple tools to recognize the file
1929	// https://github.com/opensource-apple/cctools/blob/fdb4825f303fd5c0751be524babd32958181b3ed/libstuff/checkout.c#L271
1930	const offset = mem.alignForward(u64, seg.fileoff + seg.filesize, 16);
1931	const needed_size = code_sig.estimateSize(offset);
1932	seg.filesize = offset + needed_size - seg.fileoff;
1933	seg.vmsize = mem.alignForward(u64, seg.filesize, MachO.getPageSize(self.options.target.cpu.arch));
1934	log.debug("writing code signature padding from 0x{x} to 0x{x}", .{ offset, offset + needed_size });
1935	// Pad out the space. We need to do this to calculate valid hashes for everything in the file
1936	// except for code signature data.
1937	try self.file.pwriteAll(&[_]u8{0}, offset + needed_size - 1);
1938
1939	self.codesig_cmd.dataoff = @as(u32, @intCast(offset));
1940	self.codesig_cmd.datasize = @as(u32, @intCast(needed_size));
1941	}
1942
1943	fn writeCodeSignature(self: Zld, comp: const Compilation, code_sig: *CodeSignature) !void {
1944	const seg_id = self.header_segment_cmd_index.?;
1945	const seg = self.segments.items[seg_id];
1946
1947	var buffer = std.ArrayList(u8).init(self.gpa);
1948	defer buffer.deinit();
1949	try buffer.ensureTotalCapacityPrecise(code_sig.size());
1950	try code_sig.writeAdhocSignature(comp, .{
1951	.file = self.file,
1952	.exec_seg_base = seg.fileoff,
1953	.exec_seg_limit = seg.filesize,
1954	.file_size = self.codesig_cmd.dataoff,
1955	.output_mode = self.options.output_mode,
1956	}, buffer.writer());
1957	assert(buffer.items.len == code_sig.size());
1958
1959	log.debug("writing code signature from 0x{x} to 0x{x}", .{
1960	self.codesig_cmd.dataoff,
1961	self.codesig_cmd.dataoff + buffer.items.len,
1962	});
1963
1964	try self.file.pwriteAll(buffer.items, self.codesig_cmd.dataoff);
1965	}
1966
1967	/// Writes Mach-O file header.
1968	fn writeHeader(self: *Zld, ncmds: u32, sizeofcmds: u32) !void {
1969	var header: macho.mach_header_64 = .{};
1970	header.flags = macho.MH_NOUNDEFS \| macho.MH_DYLDLINK \| macho.MH_PIE \| macho.MH_TWOLEVEL;
1971
1972	switch (self.options.target.cpu.arch) {
1973	.aarch64 => {
1974	header.cputype = macho.CPU_TYPE_ARM64;
1975	header.cpusubtype = macho.CPU_SUBTYPE_ARM_ALL;
1976	},
1977	.x86_64 => {
1978	header.cputype = macho.CPU_TYPE_X86_64;
1979	header.cpusubtype = macho.CPU_SUBTYPE_X86_64_ALL;
1980	},
1981	else => return error.UnsupportedCpuArchitecture,
1982	}
1983
1984	switch (self.options.output_mode) {
1985	.Exe => {
1986	header.filetype = macho.MH_EXECUTE;
1987	},
1988	.Lib => {
1989	// By this point, it can only be a dylib.
1990	header.filetype = macho.MH_DYLIB;
1991	header.flags \|= macho.MH_NO_REEXPORTED_DYLIBS;
1992	},
1993	else => unreachable,
1994	}
1995
1996	if (self.thread_vars_section_index) \|sect_id\| {
1997	header.flags \|= macho.MH_HAS_TLV_DESCRIPTORS;
1998	if (self.sections.items(.header)[sect_id].size > 0) {
1999	header.flags \|= macho.MH_HAS_TLV_DESCRIPTORS;
2000	}
2001	}
2002
2003	header.ncmds = ncmds;
2004	header.sizeofcmds = sizeofcmds;
2005
2006	log.debug("writing Mach-O header {}", .{header});
2007
2008	try self.file.pwriteAll(mem.asBytes(&header), 0);
2009	}
2010
2011	pub fn makeStaticString(bytes: []const u8) [16]u8 {
2012	var buf = [_]u8{0} ** 16;
2013	@memcpy(buf[0..bytes.len], bytes);
2014	return buf;
2015	}
2016
2017	pub fn getAtomPtr(self: Zld, atom_index: Atom.Index) Atom {
2018	assert(atom_index < self.atoms.items.len);
2019	return &self.atoms.items[atom_index];
2020	}
2021
2022	pub fn getAtom(self: Zld, atom_index: Atom.Index) Atom {
2023	assert(atom_index < self.atoms.items.len);
2024	return self.atoms.items[atom_index];
2025	}
2026
2027	fn getSegmentByName(self: Zld, segname: []const u8) ?u8 {
2028	for (self.segments.items, 0..) \|seg, i\| {
2029	if (mem.eql(u8, segname, seg.segName())) return @as(u8, @intCast(i));
2030	} else return null;
2031	}
2032
2033	pub fn getSegment(self: Zld, sect_id: u8) macho.segment_command_64 {
2034	const index = self.sections.items(.segment_index)[sect_id];
2035	return self.segments.items[index];
2036	}
2037
2038	pub fn getSegmentPtr(self: Zld, sect_id: u8) macho.segment_command_64 {
2039	const index = self.sections.items(.segment_index)[sect_id];
2040	return &self.segments.items[index];
2041	}
2042
2043	pub fn getLinkeditSegmentPtr(self: Zld) macho.segment_command_64 {
2044	assert(self.segments.items.len > 0);
2045	const seg = &self.segments.items[self.segments.items.len - 1];
2046	assert(mem.eql(u8, seg.segName(), "__LINKEDIT"));
2047	return seg;
2048	}
2049
2050	pub fn getSectionByName(self: Zld, segname: []const u8, sectname: []const u8) ?u8 {
2051	// TODO investigate caching with a hashmap
2052	for (self.sections.items(.header), 0..) \|header, i\| {
2053	if (mem.eql(u8, header.segName(), segname) and mem.eql(u8, header.sectName(), sectname))
2054	return @as(u8, @intCast(i));
2055	} else return null;
2056	}
2057
2058	pub fn getSectionIndexes(self: Zld, segment_index: u8) struct { start: u8, end: u8 } {
2059	var start: u8 = 0;
2060	const nsects = for (self.segments.items, 0..) \|seg, i\| {
2061	if (i == segment_index) break @as(u8, @intCast(seg.nsects));
2062	start += @as(u8, @intCast(seg.nsects));
2063	} else 0;
2064	return .{ .start = start, .end = start + nsects };
2065	}
2066
2067	pub fn symbolIsTemp(self: *Zld, sym_with_loc: SymbolWithLoc) bool {
2068	const sym = self.getSymbol(sym_with_loc);
2069	if (!sym.sect()) return false;
2070	if (sym.ext()) return false;
2071	const sym_name = self.getSymbolName(sym_with_loc);
2072	return mem.startsWith(u8, sym_name, "l") or mem.startsWith(u8, sym_name, "L");
2073	}
2074
2075	/// Returns pointer-to-symbol described by `sym_with_loc` descriptor.
2076	pub fn getSymbolPtr(self: Zld, sym_with_loc: SymbolWithLoc) macho.nlist_64 {
2077	if (sym_with_loc.getFile()) \|file\| {
2078	const object = &self.objects.items[file];
2079	return &object.symtab[sym_with_loc.sym_index];
2080	} else {
2081	return &self.locals.items[sym_with_loc.sym_index];
2082	}
2083	}
2084
2085	/// Returns symbol described by `sym_with_loc` descriptor.
2086	pub fn getSymbol(self: *const Zld, sym_with_loc: SymbolWithLoc) macho.nlist_64 {
2087	if (sym_with_loc.getFile()) \|file\| {
2088	const object = &self.objects.items[file];
2089	return object.symtab[sym_with_loc.sym_index];
2090	} else {
2091	return self.locals.items[sym_with_loc.sym_index];
2092	}
2093	}
2094
2095	/// Returns name of the symbol described by `sym_with_loc` descriptor.
2096	pub fn getSymbolName(self: *const Zld, sym_with_loc: SymbolWithLoc) []const u8 {
2097	if (sym_with_loc.getFile()) \|file\| {
2098	const object = self.objects.items[file];
2099	return object.getSymbolName(sym_with_loc.sym_index);
2100	} else {
2101	const sym = self.locals.items[sym_with_loc.sym_index];
2102	return self.strtab.get(sym.n_strx).?;
2103	}
2104	}
2105
2106	pub fn getGlobalIndex(self: *const Zld, name: []const u8) ?u32 {
2107	return self.resolver.get(name);
2108	}
2109
2110	pub fn getGlobalPtr(self: Zld, name: []const u8) ?SymbolWithLoc {
2111	const global_index = self.resolver.get(name) orelse return null;
2112	return &self.globals.items[global_index];
2113	}
2114
2115	pub fn getGlobal(self: *const Zld, name: []const u8) ?SymbolWithLoc {
2116	const global_index = self.resolver.get(name) orelse return null;
2117	return self.globals.items[global_index];
2118	}
2119
2120	const GetOrPutGlobalPtrResult = struct {
2121	found_existing: bool,
2122	value_ptr: *SymbolWithLoc,
2123	};
2124
2125	pub fn getOrPutGlobalPtr(self: *Zld, name: []const u8) !GetOrPutGlobalPtrResult {
2126	if (self.getGlobalPtr(name)) \|ptr\| {
2127	return GetOrPutGlobalPtrResult{ .found_existing = true, .value_ptr = ptr };
2128	}
2129	const global_index = try self.allocateGlobal();
2130	const global_name = try self.gpa.dupe(u8, name);
2131	_ = try self.resolver.put(self.gpa, global_name, global_index);
2132	const ptr = &self.globals.items[global_index];
2133	return GetOrPutGlobalPtrResult{ .found_existing = false, .value_ptr = ptr };
2134	}
2135
2136	pub fn getGotEntryAddress(self: *Zld, sym_with_loc: SymbolWithLoc) ?u64 {
2137	const index = self.got_table.lookup.get(sym_with_loc) orelse return null;
2138	const header = self.sections.items(.header)[self.got_section_index.?];
2139	return header.addr + @sizeOf(u64) * index;
2140	}
2141
2142	pub fn getTlvPtrEntryAddress(self: *Zld, sym_with_loc: SymbolWithLoc) ?u64 {
2143	const index = self.tlv_ptr_table.lookup.get(sym_with_loc) orelse return null;
2144	const header = self.sections.items(.header)[self.tlv_ptr_section_index.?];
2145	return header.addr + @sizeOf(u64) * index;
2146	}
2147
2148	pub fn getStubsEntryAddress(self: *Zld, sym_with_loc: SymbolWithLoc) ?u64 {
2149	const index = self.stubs_table.lookup.get(sym_with_loc) orelse return null;
2150	const header = self.sections.items(.header)[self.stubs_section_index.?];
2151	return header.addr + stubs.stubSize(self.options.target.cpu.arch) * index;
2152	}
2153
2154	/// Returns symbol location corresponding to the set entrypoint.
2155	/// Asserts output mode is executable.
2156	pub fn getEntryPoint(self: Zld) SymbolWithLoc {
2157	assert(self.options.output_mode == .Exe);
2158	const global_index = self.entry_index.?;
2159	return self.globals.items[global_index];
2160	}
2161
2162	inline fn requiresThunks(self: Zld) bool {
2163	return self.options.target.cpu.arch == .aarch64;
2164	}
2165
2166	pub fn generateSymbolStabs(self: Zld, object: Object, locals: std.ArrayList(macho.nlist_64)) !void {
2167	log.debug("generating stabs for '{s}'", .{object.name});
2168
2169	const gpa = self.gpa;
2170	var debug_info = object.parseDwarfInfo();
2171
2172	var lookup = DwarfInfo.AbbrevLookupTable.init(gpa);
2173	defer lookup.deinit();
2174	try lookup.ensureUnusedCapacity(std.math.maxInt(u8));
2175
2176	// We assume there is only one CU.
2177	var cu_it = debug_info.getCompileUnitIterator();
2178	const compile_unit = while (try cu_it.next()) \|cu\| {
2179	const offset = math.cast(usize, cu.cuh.debug_abbrev_offset) orelse return error.Overflow;
2180	try debug_info.genAbbrevLookupByKind(offset, &lookup);
2181	break cu;
2182	} else {
2183	log.debug("no compile unit found in debug info in {s}; skipping", .{object.name});
2184	return;
2185	};
2186
2187	var abbrev_it = compile_unit.getAbbrevEntryIterator(debug_info);
2188	const cu_entry: DwarfInfo.AbbrevEntry = while (try abbrev_it.next(lookup)) \|entry\| switch (entry.tag) {
2189	dwarf.TAG.compile_unit => break entry,
2190	else => continue,
2191	} else {
2192	log.debug("missing DWARF_TAG_compile_unit tag in {s}; skipping", .{object.name});
2193	return;
2194	};
2195
2196	var maybe_tu_name: ?[]const u8 = null;
2197	var maybe_tu_comp_dir: ?[]const u8 = null;
2198	var attr_it = cu_entry.getAttributeIterator(debug_info, compile_unit.cuh);
2199
2200	while (try attr_it.next()) \|attr\| switch (attr.name) {
2201	dwarf.AT.comp_dir => maybe_tu_comp_dir = attr.getString(debug_info, compile_unit.cuh) orelse continue,
2202	dwarf.AT.name => maybe_tu_name = attr.getString(debug_info, compile_unit.cuh) orelse continue,
2203	else => continue,
2204	};
2205
2206	if (maybe_tu_name == null or maybe_tu_comp_dir == null) {
2207	log.debug("missing DWARF_AT_comp_dir and DWARF_AT_name attributes {s}; skipping", .{object.name});
2208	return;
2209	}
2210
2211	const tu_name = maybe_tu_name.?;
2212	const tu_comp_dir = maybe_tu_comp_dir.?;
2213
2214	// Open scope
2215	try locals.ensureUnusedCapacity(3);
2216	locals.appendAssumeCapacity(.{
2217	.n_strx = try self.strtab.insert(gpa, tu_comp_dir),
2218	.n_type = macho.N_SO,
2219	.n_sect = 0,
2220	.n_desc = 0,
2221	.n_value = 0,
2222	});
2223	locals.appendAssumeCapacity(.{
2224	.n_strx = try self.strtab.insert(gpa, tu_name),
2225	.n_type = macho.N_SO,
2226	.n_sect = 0,
2227	.n_desc = 0,
2228	.n_value = 0,
2229	});
2230	locals.appendAssumeCapacity(.{
2231	.n_strx = try self.strtab.insert(gpa, object.name),
2232	.n_type = macho.N_OSO,
2233	.n_sect = 0,
2234	.n_desc = 1,
2235	.n_value = object.mtime,
2236	});
2237
2238	var stabs_buf: [4]macho.nlist_64 = undefined;
2239
2240	var name_lookup: ?DwarfInfo.SubprogramLookupByName = if (object.header.flags & macho.MH_SUBSECTIONS_VIA_SYMBOLS == 0) blk: {
2241	var name_lookup = DwarfInfo.SubprogramLookupByName.init(gpa);
2242	errdefer name_lookup.deinit();
2243	try name_lookup.ensureUnusedCapacity(@as(u32, @intCast(object.atoms.items.len)));
2244	try debug_info.genSubprogramLookupByName(compile_unit, lookup, &name_lookup);
2245	break :blk name_lookup;
2246	} else null;
2247	defer if (name_lookup) \|*nl\| nl.deinit();
2248
2249	for (object.atoms.items) \|atom_index\| {
2250	const atom = self.getAtom(atom_index);
2251	const stabs = try self.generateSymbolStabsForSymbol(
2252	atom_index,
2253	atom.getSymbolWithLoc(),
2254	name_lookup,
2255	&stabs_buf,
2256	);
2257	try locals.appendSlice(stabs);
2258
2259	var it = Atom.getInnerSymbolsIterator(self, atom_index);
2260	while (it.next()) \|sym_loc\| {
2261	const contained_stabs = try self.generateSymbolStabsForSymbol(
2262	atom_index,
2263	sym_loc,
2264	name_lookup,
2265	&stabs_buf,
2266	);
2267	try locals.appendSlice(contained_stabs);
2268	}
2269	}
2270
2271	// Close scope
2272	try locals.append(.{
2273	.n_strx = 0,
2274	.n_type = macho.N_SO,
2275	.n_sect = 0,
2276	.n_desc = 0,
2277	.n_value = 0,
2278	});
2279	}
2280
2281	fn generateSymbolStabsForSymbol(
2282	self: *Zld,
2283	atom_index: Atom.Index,
2284	sym_loc: SymbolWithLoc,
2285	lookup: ?DwarfInfo.SubprogramLookupByName,
2286	buf: *[4]macho.nlist_64,
2287	) ![]const macho.nlist_64 {
2288	const gpa = self.gpa;
2289	const object = self.objects.items[sym_loc.getFile().?];
2290	const sym = self.getSymbol(sym_loc);
2291	const sym_name = self.getSymbolName(sym_loc);
2292	const header = self.sections.items(.header)[sym.n_sect - 1];
2293
2294	if (sym.n_strx == 0) return buf[0..0];
2295	if (self.symbolIsTemp(sym_loc)) return buf[0..0];
2296
2297	if (!header.isCode()) {
2298	// Since we are not dealing with machine code, it's either a global or a static depending
2299	// on the linkage scope.
2300	if (sym.sect() and sym.ext()) {
2301	// Global gets an N_GSYM stab type.
2302	buf[0] = .{
2303	.n_strx = try self.strtab.insert(gpa, sym_name),
2304	.n_type = macho.N_GSYM,
2305	.n_sect = sym.n_sect,
2306	.n_desc = 0,
2307	.n_value = 0,
2308	};
2309	} else {
2310	// Local static gets an N_STSYM stab type.
2311	buf[0] = .{
2312	.n_strx = try self.strtab.insert(gpa, sym_name),
2313	.n_type = macho.N_STSYM,
2314	.n_sect = sym.n_sect,
2315	.n_desc = 0,
2316	.n_value = sym.n_value,
2317	};
2318	}
2319	return buf[0..1];
2320	}
2321
2322	const size: u64 = size: {
2323	if (object.header.flags & macho.MH_SUBSECTIONS_VIA_SYMBOLS != 0) {
2324	break :size self.getAtom(atom_index).size;
2325	}
2326
2327	// Since we don't have subsections to work with, we need to infer the size of each function
2328	// the slow way by scanning the debug info for matching symbol names and extracting
2329	// the symbol's DWARF_AT_low_pc and DWARF_AT_high_pc values.
2330	const source_sym = object.getSourceSymbol(sym_loc.sym_index) orelse return buf[0..0];
2331	const subprogram = lookup.?.get(sym_name[1..]) orelse return buf[0..0];
2332
2333	if (subprogram.addr <= source_sym.n_value and source_sym.n_value < subprogram.addr + subprogram.size) {
2334	break :size subprogram.size;
2335	} else {
2336	log.debug("no stab found for {s}", .{sym_name});
2337	return buf[0..0];
2338	}
2339	};
2340
2341	buf[0] = .{
2342	.n_strx = 0,
2343	.n_type = macho.N_BNSYM,
2344	.n_sect = sym.n_sect,
2345	.n_desc = 0,
2346	.n_value = sym.n_value,
2347	};
2348	buf[1] = .{
2349	.n_strx = try self.strtab.insert(gpa, sym_name),
2350	.n_type = macho.N_FUN,
2351	.n_sect = sym.n_sect,
2352	.n_desc = 0,
2353	.n_value = sym.n_value,
2354	};
2355	buf[2] = .{
2356	.n_strx = 0,
2357	.n_type = macho.N_FUN,
2358	.n_sect = 0,
2359	.n_desc = 0,
2360	.n_value = size,
2361	};
2362	buf[3] = .{
2363	.n_strx = 0,
2364	.n_type = macho.N_ENSYM,
2365	.n_sect = sym.n_sect,
2366	.n_desc = 0,
2367	.n_value = size,
2368	};
2369
2370	return buf;
2371	}
2372
2373	fn logSegments(self: *Zld) void {
2374	log.debug("segments:", .{});
2375	for (self.segments.items, 0..) \|segment, i\| {
2376	log.debug(" segment({d}): {s} @{x} ({x}), sizeof({x})", .{
2377	i,
2378	segment.segName(),
2379	segment.fileoff,
2380	segment.vmaddr,
2381	segment.vmsize,
2382	});
2383	}
2384	}
2385
2386	fn logSections(self: *Zld) void {
2387	log.debug("sections:", .{});
2388	for (self.sections.items(.header), 0..) \|header, i\| {
2389	log.debug(" sect({d}): {s},{s} @{x} ({x}), sizeof({x})", .{
2390	i + 1,
2391	header.segName(),
2392	header.sectName(),
2393	header.offset,
2394	header.addr,
2395	header.size,
2396	});
2397	}
2398	}
2399
2400	fn logSymAttributes(sym: macho.nlist_64, buf: []u8) []const u8 {
2401	if (sym.sect()) {
2402	buf[0] = 's';
2403	}
2404	if (sym.ext()) {
2405	if (sym.weakDef() or sym.pext()) {
2406	buf[1] = 'w';
2407	} else {
2408	buf[1] = 'e';
2409	}
2410	}
2411	if (sym.tentative()) {
2412	buf[2] = 't';
2413	}
2414	if (sym.undf()) {
2415	buf[3] = 'u';
2416	}
2417	return buf[0..];
2418	}
2419
2420	fn logSymtab(self: *Zld) void {
2421	var buf: [4]u8 = undefined;
2422
2423	const scoped_log = std.log.scoped(.symtab);
2424
2425	scoped_log.debug("locals:", .{});
2426	for (self.objects.items, 0..) \|object, id\| {
2427	scoped_log.debug(" object({d}): {s}", .{ id, object.name });
2428	if (object.in_symtab == null) continue;
2429	for (object.symtab, 0..) \|sym, sym_id\| {
2430	@memset(&buf, '_');
2431	scoped_log.debug(" %{d}: {s} @{x} in sect({d}), {s}", .{
2432	sym_id,
2433	object.getSymbolName(@as(u32, @intCast(sym_id))),
2434	sym.n_value,
2435	sym.n_sect,
2436	logSymAttributes(sym, &buf),
2437	});
2438	}
2439	}
2440	scoped_log.debug(" object(-1)", .{});
2441	for (self.locals.items, 0..) \|sym, sym_id\| {
2442	if (sym.undf()) continue;
2443	scoped_log.debug(" %{d}: {s} @{x} in sect({d}), {s}", .{
2444	sym_id,
2445	self.strtab.get(sym.n_strx).?,
2446	sym.n_value,
2447	sym.n_sect,
2448	logSymAttributes(sym, &buf),
2449	});
2450	}
2451
2452	scoped_log.debug("exports:", .{});
2453	for (self.globals.items, 0..) \|global, i\| {
2454	const sym = self.getSymbol(global);
2455	if (sym.undf()) continue;
2456	if (sym.n_desc == MachO.N_DEAD) continue;
2457	scoped_log.debug(" %{d}: {s} @{x} in sect({d}), {s} (def in object({?}))", .{
2458	i,
2459	self.getSymbolName(global),
2460	sym.n_value,
2461	sym.n_sect,
2462	logSymAttributes(sym, &buf),
2463	global.file,
2464	});
2465	}
2466
2467	scoped_log.debug("imports:", .{});
2468	for (self.globals.items, 0..) \|global, i\| {
2469	const sym = self.getSymbol(global);
2470	if (!sym.undf()) continue;
2471	if (sym.n_desc == MachO.N_DEAD) continue;
2472	const ord = @divTrunc(sym.n_desc, macho.N_SYMBOL_RESOLVER);
2473	scoped_log.debug(" %{d}: {s} @{x} in ord({d}), {s}", .{
2474	i,
2475	self.getSymbolName(global),
2476	sym.n_value,
2477	ord,
2478	logSymAttributes(sym, &buf),
2479	});
2480	}
2481
2482	scoped_log.debug("GOT entries:", .{});
2483	scoped_log.debug("{}", .{self.got_table});
2484
2485	scoped_log.debug("TLV pointers:", .{});
2486	scoped_log.debug("{}", .{self.tlv_ptr_table});
2487
2488	scoped_log.debug("stubs entries:", .{});
2489	scoped_log.debug("{}", .{self.stubs_table});
2490
2491	scoped_log.debug("thunks:", .{});
2492	for (self.thunks.items, 0..) \|thunk, i\| {
2493	scoped_log.debug(" thunk({d})", .{i});
2494	const slice = thunk.targets.slice();
2495	for (slice.items(.tag), slice.items(.target), 0..) \|tag, target, j\| {
2496	const atom_index = @as(u32, @intCast(thunk.getStartAtomIndex() + j));
2497	const atom = self.getAtom(atom_index);
2498	const atom_sym = self.getSymbol(atom.getSymbolWithLoc());
2499	const target_addr = switch (tag) {
2500	.stub => self.getStubsEntryAddress(target).?,
2501	.atom => self.getSymbol(target).n_value,
2502	};
2503	scoped_log.debug(" {d}@{x} => {s}({s}@{x})", .{
2504	j,
2505	atom_sym.n_value,
2506	@tagName(tag),
2507	self.getSymbolName(target),
2508	target_addr,
2509	});
2510	}
2511	}
2512	}
2513
2514	fn logAtoms(self: *Zld) void {
2515	log.debug("atoms:", .{});
2516	const slice = self.sections.slice();
2517	for (slice.items(.first_atom_index), 0..) \|first_atom_index, sect_id\| {
2518	var atom_index = first_atom_index orelse continue;
2519	const header = slice.items(.header)[sect_id];
2520
2521	log.debug("{s},{s}", .{ header.segName(), header.sectName() });
2522
2523	while (true) {
2524	const atom = self.getAtom(atom_index);
2525	self.logAtom(atom_index, log);
2526
2527	if (atom.next_index) \|next_index\| {
2528	atom_index = next_index;
2529	} else break;
2530	}
2531	}
2532	}
2533
2534	pub fn logAtom(self: *Zld, atom_index: Atom.Index, logger: anytype) void {
2535	if (!build_options.enable_logging) return;
2536
2537	const atom = self.getAtom(atom_index);
2538	const sym = self.getSymbol(atom.getSymbolWithLoc());
2539	const sym_name = self.getSymbolName(atom.getSymbolWithLoc());
2540	logger.debug(" ATOM({d}, %{d}, '{s}') @ {x} (sizeof({x}), alignof({x})) in object({?}) in sect({d})", .{
2541	atom_index,
2542	atom.sym_index,
2543	sym_name,
2544	sym.n_value,
2545	atom.size,
2546	atom.alignment,
2547	atom.getFile(),
2548	sym.n_sect,
2549	});
2550
2551	if (atom.getFile() != null) {
2552	var it = Atom.getInnerSymbolsIterator(self, atom_index);
2553	while (it.next()) \|sym_loc\| {
2554	const inner = self.getSymbol(sym_loc);
2555	const inner_name = self.getSymbolName(sym_loc);
2556	const offset = Atom.calcInnerSymbolOffset(self, atom_index, sym_loc.sym_index);
2557
2558	logger.debug(" (%{d}, '{s}') @ {x} ({x})", .{
2559	sym_loc.sym_index,
2560	inner_name,
2561	inner.n_value,
2562	offset,
2563	});
2564	}
2565
2566	if (Atom.getSectionAlias(self, atom_index)) \|sym_loc\| {
2567	const alias = self.getSymbol(sym_loc);
2568	const alias_name = self.getSymbolName(sym_loc);
2569
2570	logger.debug(" (%{d}, '{s}') @ {x} ({x})", .{
2571	sym_loc.sym_index,
2572	alias_name,
2573	alias.n_value,
2574	0,
2575	});
2576	}
2577	}
2578	}
2579	};
2580
2581	pub fn linkWithZld(macho_file: MachO, comp: Compilation, prog_node: *std.Progress.Node) link.File.FlushError!void {
2582	const tracy = trace(@src());	6	const tracy = trace(@src());
2583	defer tracy.end();	7	defer tracy.end();
2584		8
...	@@ -2611,8 +35,6 @@ pub fn linkWithZld(macho_file: MachO, comp: Compilation, prog_node: *std.Progr	...	@@ -2611,8 +35,6 @@ pub fn linkWithZld(macho_file: MachO, comp: Compilation, prog_node: *std.Progr
2611	defer sub_prog_node.end();	35	defer sub_prog_node.end();
2612		36
2613	const cpu_arch = target.cpu.arch;	37	const cpu_arch = target.cpu.arch;
2614	const os_tag = target.os.tag;
2615	const abi = target.abi;
2616	const is_lib = options.output_mode == .Lib;	38	const is_lib = options.output_mode == .Lib;
2617	const is_dyn_lib = options.link_mode == .Dynamic and is_lib;	39	const is_dyn_lib = options.link_mode == .Dynamic and is_lib;
2618	const is_exe_or_dyn_lib = is_dyn_lib or options.output_mode == .Exe;	40	const is_exe_or_dyn_lib = is_dyn_lib or options.output_mode == .Exe;
...	@@ -2730,29 +152,26 @@ pub fn linkWithZld(macho_file: MachO, comp: Compilation, prog_node: *std.Progr	...	@@ -2730,29 +152,26 @@ pub fn linkWithZld(macho_file: MachO, comp: Compilation, prog_node: *std.Progr
2730	} else {	152	} else {
2731	const sub_path = options.emit.?.sub_path;	153	const sub_path = options.emit.?.sub_path;
2732		154
		155	const old_file = macho_file.base.file; // TODO is this needed at all?
		156	defer macho_file.base.file = old_file;
		157
2733	const file = try directory.handle.createFile(sub_path, .{	158	const file = try directory.handle.createFile(sub_path, .{
2734	.truncate = true,	159	.truncate = true,
2735	.read = true,	160	.read = true,
2736	.mode = link.determineMode(options.*),	161	.mode = link.determineMode(options.*),
2737	});	162	});
2738	defer file.close();	163	defer file.close();
2739		164	macho_file.base.file = file;
2740	var zld = Zld{
2741	.gpa = gpa,
2742	.file = file,
2743	.options = options,
2744	};
2745	defer zld.deinit();
2746		165
2747	// Index 0 is always a null symbol.	166	// Index 0 is always a null symbol.
2748	try zld.locals.append(gpa, .{	167	try macho_file.locals.append(gpa, .{
2749	.n_strx = 0,	168	.n_strx = 0,
2750	.n_type = 0,	169	.n_type = 0,
2751	.n_sect = 0,	170	.n_sect = 0,
2752	.n_desc = 0,	171	.n_desc = 0,
2753	.n_value = 0,	172	.n_value = 0,
2754	});	173	});
2755	try zld.strtab.buffer.append(gpa, 0);	174	try macho_file.strtab.buffer.append(gpa, 0);
2756		175
2757	// Positional arguments to the linker such as object files and static archives.	176	// Positional arguments to the linker such as object files and static archives.
2758	var positionals = std.ArrayList(Compilation.LinkObject).init(arena);	177	var positionals = std.ArrayList(Compilation.LinkObject).init(arena);
...	@@ -2930,9 +349,7 @@ pub fn linkWithZld(macho_file: MachO, comp: Compilation, prog_node: *std.Progr	...	@@ -2930,9 +349,7 @@ pub fn linkWithZld(macho_file: MachO, comp: Compilation, prog_node: *std.Progr
2930	const in_file = try std.fs.cwd().openFile(obj.path, .{});	349	const in_file = try std.fs.cwd().openFile(obj.path, .{});
2931	defer in_file.close();	350	defer in_file.close();
2932		351
2933	MachO.parsePositional(	352	macho_file.parsePositional(
2934	&zld,
2935	gpa,
2936	in_file,	353	in_file,
2937	obj.path,	354	obj.path,
2938	obj.must_link,	355	obj.must_link,
...	@@ -2949,9 +366,7 @@ pub fn linkWithZld(macho_file: MachO, comp: Compilation, prog_node: *std.Progr	...	@@ -2949,9 +366,7 @@ pub fn linkWithZld(macho_file: MachO, comp: Compilation, prog_node: *std.Progr
2949	const in_file = try std.fs.cwd().openFile(path, .{});	366	const in_file = try std.fs.cwd().openFile(path, .{});
2950	defer in_file.close();	367	defer in_file.close();
2951		368
2952	MachO.parseLibrary(	369	macho_file.parseLibrary(
2953	&zld,
2954	gpa,
2955	in_file,	370	in_file,
2956	path,	371	path,
2957	lib,	372	lib,
...	@@ -2965,198 +380,199 @@ pub fn linkWithZld(macho_file: MachO, comp: Compilation, prog_node: *std.Progr	...	@@ -2965,198 +380,199 @@ pub fn linkWithZld(macho_file: MachO, comp: Compilation, prog_node: *std.Progr
2965	};	380	};
2966	}	381	}
2967		382
2968	MachO.parseDependentLibs(&zld, gpa, &dependent_libs, options) catch \|err\| {	383	macho_file.parseDependentLibs(&dependent_libs, options) catch \|err\| {
2969	// TODO convert to error	384	// TODO convert to error
2970	log.err("parsing dependent libraries failed with err {s}", .{@errorName(err)});	385	log.err("parsing dependent libraries failed with err {s}", .{@errorName(err)});
2971	};	386	};
2972		387
2973	try zld.resolveSymbols();	388	var actions = std.ArrayList(MachO.ResolveAction).init(gpa);
2974	try macho_file.reportUndefined(&zld);	389	defer actions.deinit();
2975		390	try macho_file.resolveSymbols(&actions);
2976	if (options.output_mode == .Exe) {	391	try macho_file.reportUndefined();
2977	const entry_name = options.entry orelse load_commands.default_entry_point;
2978	const global_index = zld.resolver.get(entry_name).?; // Error was flagged earlier
2979	zld.entry_index = global_index;
2980	}
2981		392
2982	for (zld.objects.items, 0..) \|*object, object_id\| {	393	for (macho_file.objects.items, 0..) \|*object, object_id\| {
2983	try object.splitIntoAtoms(&zld, @as(u32, @intCast(object_id)));	394	try object.splitIntoAtoms(macho_file, @as(u32, @intCast(object_id)));
2984	}	395	}
2985		396
2986	if (gc_sections) {	397	if (gc_sections) {
2987	try dead_strip.gcAtoms(&zld);	398	try dead_strip.gcAtoms(macho_file);
2988	}	399	}
2989		400
2990	try zld.createDyldPrivateAtom();	401	try macho_file.createDyldPrivateAtom();
2991	try zld.createTentativeDefAtoms();	402	try macho_file.createTentativeDefAtoms();
2992		403
2993	if (zld.options.output_mode == .Exe) {	404	if (macho_file.options.output_mode == .Exe) {
2994	const global = zld.getEntryPoint();	405	const global = macho_file.getEntryPoint().?;
2995	if (zld.getSymbol(global).undf()) {	406	if (macho_file.getSymbol(global).undf()) {
2996	// We do one additional check here in case the entry point was found in one of the dylibs.	407	// We do one additional check here in case the entry point was found in one of the dylibs.
2997	// (I actually have no idea what this would imply but it is a possible outcome and so we	408	// (I actually have no idea what this would imply but it is a possible outcome and so we
2998	// support it.)	409	// support it.)
2999	try zld.addStubEntry(global);	410	try macho_file.addStubEntry(global);
3000	}	411	}
3001	}	412	}
3002		413
3003	for (zld.objects.items) \|object\| {	414	for (macho_file.objects.items) \|object\| {
3004	for (object.atoms.items) \|atom_index\| {	415	for (object.atoms.items) \|atom_index\| {
3005	const atom = zld.getAtom(atom_index);	416	const atom = macho_file.getAtom(atom_index);
3006	const sym = zld.getSymbol(atom.getSymbolWithLoc());	417	const sym = macho_file.getSymbol(atom.getSymbolWithLoc());
3007	const header = zld.sections.items(.header)[sym.n_sect - 1];	418	const header = macho_file.sections.items(.header)[sym.n_sect - 1];
3008	if (header.isZerofill()) continue;	419	if (header.isZerofill()) continue;
3009		420
3010	const relocs = Atom.getAtomRelocs(&zld, atom_index);	421	const relocs = Atom.getAtomRelocs(macho_file, atom_index);
3011	try Atom.scanAtomRelocs(&zld, atom_index, relocs);	422	try Atom.scanAtomRelocs(macho_file, atom_index, relocs);
3012	}	423	}
3013	}	424	}
3014		425
3015	try eh_frame.scanRelocs(&zld);	426	try eh_frame.scanRelocs(macho_file);
3016	try UnwindInfo.scanRelocs(&zld);	427	try UnwindInfo.scanRelocs(macho_file);
3017		428
3018	if (zld.dyld_stub_binder_index) \|index\| try zld.addGotEntry(zld.globals.items[index]);	429	if (macho_file.dyld_stub_binder_index) \|index\|
		430	try macho_file.addGotEntry(macho_file.globals.items[index]);
3019		431
3020	try zld.calcSectionSizes();	432	try macho_file.calcSectionSizes();
3021		433
3022	var unwind_info = UnwindInfo{ .gpa = zld.gpa };	434	var unwind_info = UnwindInfo{ .gpa = gpa };
3023	defer unwind_info.deinit();	435	defer unwind_info.deinit();
3024	try unwind_info.collect(&zld);	436	try unwind_info.collect(macho_file);
3025		437
3026	try eh_frame.calcSectionSize(&zld, &unwind_info);	438	try eh_frame.calcSectionSize(macho_file, &unwind_info);
3027	try unwind_info.calcSectionSize(&zld);	439	try unwind_info.calcSectionSize(macho_file);
3028		440
3029	try zld.pruneAndSortSections();	441	try pruneAndSortSections(macho_file);
3030	try zld.createSegments();	442	try createSegments(macho_file);
3031	try zld.allocateSegments();	443	try allocateSegments(macho_file);
3032		444
3033	try MachO.allocateSpecialSymbols(&zld);	445	try macho_file.allocateSpecialSymbols();
3034		446
3035	if (build_options.enable_logging) {	447	if (build_options.enable_logging) {
3036	zld.logSymtab();	448	macho_file.logSymtab();
3037	zld.logSegments();	449	macho_file.logSegments();
3038	zld.logSections();	450	macho_file.logSections();
3039	zld.logAtoms();	451	macho_file.logAtoms();
3040	}	452	}
3041		453
3042	try zld.writeAtoms();	454	try writeAtoms(macho_file);
3043	if (zld.requiresThunks()) try zld.writeThunks();	455	if (macho_file.requiresThunks()) try writeThunks(macho_file);
3044	try zld.writeDyldPrivateAtom();	456	try writeDyldPrivateAtom(macho_file);
3045		457
3046	if (zld.stubs_section_index) \|_\| {	458	if (macho_file.stubs_section_index) \|_\| {
3047	try zld.writeStubs();	459	try writeStubs(macho_file);
3048	try zld.writeStubHelpers();	460	try writeStubHelpers(macho_file);
3049	try zld.writeLaSymbolPtrs();	461	try writeLaSymbolPtrs(macho_file);
3050	}	462	}
3051	if (zld.got_section_index) \|sect_id\| try zld.writePointerEntries(sect_id, &zld.got_table);	463	if (macho_file.got_section_index) \|sect_id\|
3052	if (zld.tlv_ptr_section_index) \|sect_id\| try zld.writePointerEntries(sect_id, &zld.tlv_ptr_table);	464	try macho_file.writePointerEntries(sect_id, &macho_file.got_table);
		465	if (macho_file.tlv_ptr_section_index) \|sect_id\|
		466	try macho_file.writePointerEntries(sect_id, &macho_file.tlv_ptr_table);
3053		467
3054	try eh_frame.write(&zld, &unwind_info);	468	try eh_frame.write(macho_file, &unwind_info);
3055	try unwind_info.write(&zld);	469	try unwind_info.write(macho_file);
3056	try zld.writeLinkeditSegmentData();	470	try macho_file.writeLinkeditSegmentData();
3057		471
3058	// If the last section of __DATA segment is zerofill section, we need to ensure	472	// If the last section of __DATA segment is zerofill section, we need to ensure
3059	// that the free space between the end of the last non-zerofill section of __DATA	473	// that the free space between the end of the last non-zerofill section of __DATA
3060	// segment and the beginning of __LINKEDIT segment is zerofilled as the loader will	474	// segment and the beginning of __LINKEDIT segment is zerofilled as the loader will
3061	// copy-paste this space into memory for quicker zerofill operation.	475	// copy-paste this space into memory for quicker zerofill operation.
3062	if (zld.data_segment_cmd_index) \|data_seg_id\| blk: {	476	if (macho_file.data_segment_cmd_index) \|data_seg_id\| blk: {
3063	var physical_zerofill_start: ?u64 = null;	477	var physical_zerofill_start: ?u64 = null;
3064	const section_indexes = zld.getSectionIndexes(data_seg_id);	478	const section_indexes = macho_file.getSectionIndexes(data_seg_id);
3065	for (zld.sections.items(.header)[section_indexes.start..section_indexes.end]) \|header\| {	479	for (macho_file.sections.items(.header)[section_indexes.start..section_indexes.end]) \|header\| {
3066	if (header.isZerofill() and header.size > 0) break;	480	if (header.isZerofill() and header.size > 0) break;
3067	physical_zerofill_start = header.offset + header.size;	481	physical_zerofill_start = header.offset + header.size;
3068	} else break :blk;	482	} else break :blk;
3069	const start = physical_zerofill_start orelse break :blk;	483	const start = physical_zerofill_start orelse break :blk;
3070	const linkedit = zld.getLinkeditSegmentPtr();	484	const linkedit = macho_file.getLinkeditSegmentPtr();
3071	const size = math.cast(usize, linkedit.fileoff - start) orelse return error.Overflow;	485	const size = math.cast(usize, linkedit.fileoff - start) orelse return error.Overflow;
3072	if (size > 0) {	486	if (size > 0) {
3073	log.debug("zeroing out zerofill area of length {x} at {x}", .{ size, start });	487	log.debug("zeroing out zerofill area of length {x} at {x}", .{ size, start });
3074	var padding = try zld.gpa.alloc(u8, size);	488	var padding = try gpa.alloc(u8, size);
3075	defer zld.gpa.free(padding);	489	defer gpa.free(padding);
3076	@memset(padding, 0);	490	@memset(padding, 0);
3077	try zld.file.pwriteAll(padding, start);	491	try macho_file.base.file.?.pwriteAll(padding, start);
3078	}	492	}
3079	}	493	}
3080		494
3081	// Write code signature padding if required	495	// Write code signature padding if required
3082	const requires_codesig = blk: {	496	var codesig: ?CodeSignature = if (macho_file.requiresCodeSignature()) blk: {
3083	if (options.entitlements) \|_\| break :blk true;
3084	if (cpu_arch == .aarch64 and (os_tag == .macos or abi == .simulator)) break :blk true;
3085	break :blk false;
3086	};
3087	var codesig: ?CodeSignature = if (requires_codesig) blk: {
3088	// Preallocate space for the code signature.	497	// Preallocate space for the code signature.
3089	// We need to do this at this stage so that we have the load commands with proper values	498	// We need to do this at this stage so that we have the load commands with proper values
3090	// written out to the file.	499	// written out to the file.
3091	// The most important here is to have the correct vm and filesize of the __LINKEDIT segment	500	// The most important here is to have the correct vm and filesize of the __LINKEDIT segment
3092	// where the code signature goes into.	501	// where the code signature goes into.
3093	var codesig = CodeSignature.init(MachO.getPageSize(zld.options.target.cpu.arch));	502	var codesig = CodeSignature.init(MachO.getPageSize(cpu_arch));
3094	codesig.code_directory.ident = fs.path.basename(full_out_path);	503	codesig.code_directory.ident = fs.path.basename(full_out_path);
3095	if (options.entitlements) \|path\| {	504	if (options.entitlements) \|path\| {
3096	try codesig.addEntitlements(zld.gpa, path);	505	try codesig.addEntitlements(gpa, path);
3097	}	506	}
3098	try zld.writeCodeSignaturePadding(&codesig);	507	try macho_file.writeCodeSignaturePadding(&codesig);
3099	break :blk codesig;	508	break :blk codesig;
3100	} else null;	509	} else null;
3101	defer if (codesig) \|*csig\| csig.deinit(zld.gpa);	510	defer if (codesig) \|*csig\| csig.deinit(gpa);
3102		511
3103	// Write load commands	512	// Write load commands
3104	var lc_buffer = std.ArrayList(u8).init(arena);	513	var lc_buffer = std.ArrayList(u8).init(arena);
3105	const lc_writer = lc_buffer.writer();	514	const lc_writer = lc_buffer.writer();
3106		515
3107	try MachO.writeSegmentHeaders(&zld, lc_writer);	516	try macho_file.writeSegmentHeaders(lc_writer);
3108	try lc_writer.writeStruct(zld.dyld_info_cmd);	517	try lc_writer.writeStruct(macho_file.dyld_info_cmd);
3109	try lc_writer.writeStruct(zld.function_starts_cmd);	518	try lc_writer.writeStruct(macho_file.function_starts_cmd);
3110	try lc_writer.writeStruct(zld.data_in_code_cmd);	519	try lc_writer.writeStruct(macho_file.data_in_code_cmd);
3111	try lc_writer.writeStruct(zld.symtab_cmd);	520	try lc_writer.writeStruct(macho_file.symtab_cmd);
3112	try lc_writer.writeStruct(zld.dysymtab_cmd);	521	try lc_writer.writeStruct(macho_file.dysymtab_cmd);
3113	try load_commands.writeDylinkerLC(lc_writer);	522	try load_commands.writeDylinkerLC(lc_writer);
3114		523
3115	if (zld.options.output_mode == .Exe) {	524	switch (macho_file.base.options.output_mode) {
3116	const seg_id = zld.header_segment_cmd_index.?;	525	.Exe => blk: {
3117	const seg = zld.segments.items[seg_id];	526	const seg_id = macho_file.header_segment_cmd_index.?;
3118	const global = zld.getEntryPoint();	527	const seg = macho_file.segments.items[seg_id];
3119	const sym = zld.getSymbol(global);	528	const global = macho_file.getEntryPoint() orelse break :blk;
3120		529	const sym = macho_file.getSymbol(global);
3121	const addr: u64 = if (sym.undf())	530
3122	// In this case, the symbol has been resolved in one of dylibs and so we point	531	const addr: u64 = if (sym.undf())
3123	// to the stub as its vmaddr value.	532	// In this case, the symbol has been resolved in one of dylibs and so we point
3124	zld.getStubsEntryAddress(global).?	533	// to the stub as its vmaddr value.
3125	else	534	macho_file.getStubsEntryAddress(global).?
3126	sym.n_value;	535	else
3127		536	sym.n_value;
3128	try lc_writer.writeStruct(macho.entry_point_command{	537
3129	.entryoff = @as(u32, @intCast(addr - seg.vmaddr)),	538	try lc_writer.writeStruct(macho.entry_point_command{
3130	.stacksize = options.stack_size_override orelse 0,	539	.entryoff = @as(u32, @intCast(addr - seg.vmaddr)),
3131	});	540	.stacksize = macho_file.base.options.stack_size_override orelse 0,
3132	} else {	541	});
3133	assert(zld.options.output_mode == .Lib);	542	},
3134	try load_commands.writeDylibIdLC(zld.gpa, zld.options, lc_writer);	543	.Lib => if (macho_file.base.options.link_mode == .Dynamic) {
		544	try load_commands.writeDylibIdLC(gpa, &macho_file.base.options, lc_writer);
		545	},
		546	else => {},
3135	}	547	}
3136		548
3137	try load_commands.writeRpathLCs(zld.gpa, zld.options, lc_writer);	549	try load_commands.writeRpathLCs(gpa, macho_file.base.options, lc_writer);
3138	try lc_writer.writeStruct(macho.source_version_command{	550	try lc_writer.writeStruct(macho.source_version_command{
3139	.version = 0,	551	.version = 0,
3140	});	552	});
3141	try load_commands.writeBuildVersionLC(zld.options, lc_writer);	553	try load_commands.writeBuildVersionLC(macho_file.base.options, lc_writer);
3142		554
3143	const uuid_cmd_offset = @sizeOf(macho.mach_header_64) + @as(u32, @intCast(lc_buffer.items.len));	555	const uuid_cmd_offset = @sizeOf(macho.mach_header_64) + @as(u32, @intCast(lc_buffer.items.len));
3144	try lc_writer.writeStruct(zld.uuid_cmd);	556	try lc_writer.writeStruct(macho_file.uuid_cmd);
3145		557
3146	try load_commands.writeLoadDylibLCs(zld.dylibs.items, zld.referenced_dylibs.keys(), lc_writer);	558	try load_commands.writeLoadDylibLCs(
		559	macho_file.dylibs.items,
		560	macho_file.referenced_dylibs.keys(),
		561	lc_writer,
		562	);
3147		563
3148	if (requires_codesig) {	564	if (codesig != null) {
3149	try lc_writer.writeStruct(zld.codesig_cmd);	565	try lc_writer.writeStruct(macho_file.codesig_cmd);
3150	}	566	}
3151		567
3152	const ncmds = load_commands.calcNumOfLCs(lc_buffer.items);	568	const ncmds = load_commands.calcNumOfLCs(lc_buffer.items);
3153	try zld.file.pwriteAll(lc_buffer.items, @sizeOf(macho.mach_header_64));	569	try macho_file.base.file.?.pwriteAll(lc_buffer.items, @sizeOf(macho.mach_header_64));
3154	try zld.writeHeader(ncmds, @as(u32, @intCast(lc_buffer.items.len)));	570	try macho_file.writeHeader(ncmds, @as(u32, @intCast(lc_buffer.items.len)));
3155	try zld.writeUuid(comp, uuid_cmd_offset, requires_codesig);	571	try macho_file.writeUuid(comp, uuid_cmd_offset, codesig != null);
3156		572
3157	if (codesig) \|*csig\| {	573	if (codesig) \|*csig\| {
3158	try zld.writeCodeSignature(comp, csig); // code signing always comes last	574	try macho_file.writeCodeSignature(comp, csig); // code signing always comes last
3159	try MachO.invalidateKernelCache(directory.handle, zld.options.emit.?.sub_path);	575	try MachO.invalidateKernelCache(directory.handle, macho_file.base.options.emit.?.sub_path);
3160	}	576	}
3161	}	577	}
3162		578
...	@@ -3177,3 +593,609 @@ pub fn linkWithZld(macho_file: MachO, comp: Compilation, prog_node: *std.Progr	...	@@ -3177,3 +593,609 @@ pub fn linkWithZld(macho_file: MachO, comp: Compilation, prog_node: *std.Progr
3177	macho_file.base.lock = man.toOwnedLock();	593	macho_file.base.lock = man.toOwnedLock();
3178	}	594	}
3179	}	595	}
		596
		597	fn createSegments(macho_file: *MachO) !void {
		598	const gpa = macho_file.base.allocator;
		599	const pagezero_vmsize = macho_file.base.options.pagezero_size orelse MachO.default_pagezero_vmsize;
		600	const page_size = MachO.getPageSize(macho_file.base.options.target.cpu.arch);
		601	const aligned_pagezero_vmsize = mem.alignBackward(u64, pagezero_vmsize, page_size);
		602	if (macho_file.base.options.output_mode != .Lib and aligned_pagezero_vmsize > 0) {
		603	if (aligned_pagezero_vmsize != pagezero_vmsize) {
		604	log.warn("requested __PAGEZERO size (0x{x}) is not page aligned", .{pagezero_vmsize});
		605	log.warn(" rounding down to 0x{x}", .{aligned_pagezero_vmsize});
		606	}
		607	macho_file.pagezero_segment_cmd_index = @intCast(macho_file.segments.items.len);
		608	try macho_file.segments.append(gpa, .{
		609	.cmdsize = @sizeOf(macho.segment_command_64),
		610	.segname = MachO.makeStaticString("__PAGEZERO"),
		611	.vmsize = aligned_pagezero_vmsize,
		612	});
		613	}
		614
		615	// __TEXT segment is non-optional
		616	{
		617	const protection = MachO.getSegmentMemoryProtection("__TEXT");
		618	macho_file.text_segment_cmd_index = @intCast(macho_file.segments.items.len);
		619	macho_file.header_segment_cmd_index = macho_file.text_segment_cmd_index.?;
		620	try macho_file.segments.append(gpa, .{
		621	.cmdsize = @sizeOf(macho.segment_command_64),
		622	.segname = MachO.makeStaticString("__TEXT"),
		623	.maxprot = protection,
		624	.initprot = protection,
		625	});
		626	}
		627
		628	for (macho_file.sections.items(.header), 0..) \|header, sect_id\| {
		629	if (header.size == 0) continue; // empty section
		630
		631	const segname = header.segName();
		632	const segment_id = macho_file.getSegmentByName(segname) orelse blk: {
		633	log.debug("creating segment '{s}'", .{segname});
		634	const segment_id = @as(u8, @intCast(macho_file.segments.items.len));
		635	const protection = MachO.getSegmentMemoryProtection(segname);
		636	try macho_file.segments.append(gpa, .{
		637	.cmdsize = @sizeOf(macho.segment_command_64),
		638	.segname = MachO.makeStaticString(segname),
		639	.maxprot = protection,
		640	.initprot = protection,
		641	});
		642	break :blk segment_id;
		643	};
		644	const segment = &macho_file.segments.items[segment_id];
		645	segment.cmdsize += @sizeOf(macho.section_64);
		646	segment.nsects += 1;
		647	macho_file.sections.items(.segment_index)[sect_id] = segment_id;
		648	}
		649
		650	if (macho_file.getSegmentByName("__DATA_CONST")) \|index\| {
		651	macho_file.data_const_segment_cmd_index = index;
		652	}
		653
		654	if (macho_file.getSegmentByName("__DATA")) \|index\| {
		655	macho_file.data_segment_cmd_index = index;
		656	}
		657
		658	// __LINKEDIT always comes last
		659	{
		660	const protection = MachO.getSegmentMemoryProtection("__LINKEDIT");
		661	macho_file.linkedit_segment_cmd_index = @intCast(macho_file.segments.items.len);
		662	try macho_file.segments.append(gpa, .{
		663	.cmdsize = @sizeOf(macho.segment_command_64),
		664	.segname = MachO.makeStaticString("__LINKEDIT"),
		665	.maxprot = protection,
		666	.initprot = protection,
		667	});
		668	}
		669	}
		670
		671	fn writeAtoms(macho_file: *MachO) !void {
		672	const gpa = macho_file.base.allocator;
		673	const slice = macho_file.sections.slice();
		674
		675	for (slice.items(.first_atom_index), 0..) \|first_atom_index, sect_id\| {
		676	const header = slice.items(.header)[sect_id];
		677	if (header.isZerofill()) continue;
		678
		679	var atom_index = first_atom_index orelse continue;
		680
		681	var buffer = try gpa.alloc(u8, math.cast(usize, header.size) orelse return error.Overflow);
		682	defer gpa.free(buffer);
		683	@memset(buffer, 0); // TODO with NOPs
		684
		685	log.debug("writing atoms in {s},{s}", .{ header.segName(), header.sectName() });
		686
		687	while (true) {
		688	const atom = macho_file.getAtom(atom_index);
		689	if (atom.getFile()) \|file\| {
		690	const this_sym = macho_file.getSymbol(atom.getSymbolWithLoc());
		691	const padding_size: usize = if (atom.next_index) \|next_index\| blk: {
		692	const next_sym = macho_file.getSymbol(macho_file.getAtom(next_index).getSymbolWithLoc());
		693	const size = next_sym.n_value - (this_sym.n_value + atom.size);
		694	break :blk math.cast(usize, size) orelse return error.Overflow;
		695	} else 0;
		696
		697	log.debug(" (adding ATOM(%{d}, '{s}') from object({d}) to buffer)", .{
		698	atom.sym_index,
		699	macho_file.getSymbolName(atom.getSymbolWithLoc()),
		700	file,
		701	});
		702	if (padding_size > 0) {
		703	log.debug(" (with padding {x})", .{padding_size});
		704	}
		705
		706	const offset = this_sym.n_value - header.addr;
		707	log.debug(" (at offset 0x{x})", .{offset});
		708
		709	const code = Atom.getAtomCode(macho_file, atom_index);
		710	const relocs = Atom.getAtomRelocs(macho_file, atom_index);
		711	const size = math.cast(usize, atom.size) orelse return error.Overflow;
		712	@memcpy(buffer[offset .. offset + size], code);
		713	try Atom.resolveRelocs(
		714	macho_file,
		715	atom_index,
		716	buffer[offset..][0..size],
		717	relocs,
		718	);
		719	}
		720
		721	if (atom.next_index) \|next_index\| {
		722	atom_index = next_index;
		723	} else break;
		724	}
		725
		726	log.debug(" (writing at file offset 0x{x})", .{header.offset});
		727	try macho_file.base.file.?.pwriteAll(buffer, header.offset);
		728	}
		729	}
		730
		731	fn writeDyldPrivateAtom(macho_file: *MachO) !void {
		732	const atom_index = macho_file.dyld_private_atom_index orelse return;
		733	const atom = macho_file.getAtom(atom_index);
		734	const sym = macho_file.getSymbol(atom.getSymbolWithLoc());
		735	const sect_id = macho_file.data_section_index.?;
		736	const header = macho_file.sections.items(.header)[sect_id];
		737	const offset = sym.n_value - header.addr + header.offset;
		738	log.debug("writing __dyld_private at offset 0x{x}", .{offset});
		739	const buffer: [@sizeOf(u64)]u8 = [_]u8{0} ** @sizeOf(u64);
		740	try macho_file.base.file.?.pwriteAll(&buffer, offset);
		741	}
		742
		743	fn writeThunks(macho_file: *MachO) !void {
		744	assert(macho_file.requiresThunks());
		745	const gpa = macho_file.base.allocator;
		746
		747	const sect_id = macho_file.text_section_index orelse return;
		748	const header = macho_file.sections.items(.header)[sect_id];
		749
		750	for (macho_file.thunks.items, 0..) \|*thunk, i\| {
		751	if (thunk.getSize() == 0) continue;
		752	var buffer = try std.ArrayList(u8).initCapacity(gpa, thunk.getSize());
		753	defer buffer.deinit();
		754	try thunks.writeThunkCode(macho_file, thunk, buffer.writer());
		755	const thunk_atom = macho_file.getAtom(thunk.getStartAtomIndex());
		756	const thunk_sym = macho_file.getSymbol(thunk_atom.getSymbolWithLoc());
		757	const offset = thunk_sym.n_value - header.addr + header.offset;
		758	log.debug("writing thunk({d}) at offset 0x{x}", .{ i, offset });
		759	try macho_file.base.file.?.pwriteAll(buffer.items, offset);
		760	}
		761	}
		762
		763	fn writePointerEntries(macho_file: *MachO, sect_id: u8, table: anytype) !void {
		764	const gpa = macho_file.base.allocator;
		765	const header = macho_file.sections.items(.header)[sect_id];
		766	var buffer = try std.ArrayList(u8).initCapacity(gpa, header.size);
		767	defer buffer.deinit();
		768	for (table.entries.items) \|entry\| {
		769	const sym = macho_file.getSymbol(entry);
		770	buffer.writer().writeIntLittle(u64, sym.n_value) catch unreachable;
		771	}
		772	log.debug("writing __DATA_CONST,__got contents at file offset 0x{x}", .{header.offset});
		773	try macho_file.base.file.?.pwriteAll(buffer.items, header.offset);
		774	}
		775
		776	fn writeStubs(macho_file: *MachO) !void {
		777	const gpa = macho_file.base.allocator;
		778	const cpu_arch = macho_file.base.options.target.cpu.arch;
		779	const stubs_header = macho_file.sections.items(.header)[macho_file.stubs_section_index.?];
		780	const la_symbol_ptr_header = macho_file.sections.items(.header)[macho_file.la_symbol_ptr_section_index.?];
		781
		782	var buffer = try std.ArrayList(u8).initCapacity(gpa, stubs_header.size);
		783	defer buffer.deinit();
		784
		785	for (0..macho_file.stub_table.count()) \|index\| {
		786	try stubs.writeStubCode(.{
		787	.cpu_arch = cpu_arch,
		788	.source_addr = stubs_header.addr + stubs.stubSize(cpu_arch) * index,
		789	.target_addr = la_symbol_ptr_header.addr + index * @sizeOf(u64),
		790	}, buffer.writer());
		791	}
		792
		793	log.debug("writing __TEXT,__stubs contents at file offset 0x{x}", .{stubs_header.offset});
		794	try macho_file.base.file.?.pwriteAll(buffer.items, stubs_header.offset);
		795	}
		796
		797	fn writeStubHelpers(macho_file: *MachO) !void {
		798	const gpa = macho_file.base.allocator;
		799	const cpu_arch = macho_file.base.options.target.cpu.arch;
		800	const stub_helper_header = macho_file.sections.items(.header)[macho_file.stub_helper_section_index.?];
		801
		802	var buffer = try std.ArrayList(u8).initCapacity(gpa, stub_helper_header.size);
		803	defer buffer.deinit();
		804
		805	{
		806	const dyld_private_addr = blk: {
		807	const atom = macho_file.getAtom(macho_file.dyld_private_atom_index.?);
		808	const sym = macho_file.getSymbol(atom.getSymbolWithLoc());
		809	break :blk sym.n_value;
		810	};
		811	const dyld_stub_binder_got_addr = blk: {
		812	const sym_loc = macho_file.globals.items[macho_file.dyld_stub_binder_index.?];
		813	break :blk macho_file.getGotEntryAddress(sym_loc).?;
		814	};
		815	try stubs.writeStubHelperPreambleCode(.{
		816	.cpu_arch = cpu_arch,
		817	.source_addr = stub_helper_header.addr,
		818	.dyld_private_addr = dyld_private_addr,
		819	.dyld_stub_binder_got_addr = dyld_stub_binder_got_addr,
		820	}, buffer.writer());
		821	}
		822
		823	for (0..macho_file.stub_table.count()) \|index\| {
		824	const source_addr = stub_helper_header.addr + stubs.stubHelperPreambleSize(cpu_arch) +
		825	stubs.stubHelperSize(cpu_arch) * index;
		826	try stubs.writeStubHelperCode(.{
		827	.cpu_arch = cpu_arch,
		828	.source_addr = source_addr,
		829	.target_addr = stub_helper_header.addr,
		830	}, buffer.writer());
		831	}
		832
		833	log.debug("writing __TEXT,__stub_helper contents at file offset 0x{x}", .{
		834	stub_helper_header.offset,
		835	});
		836	try macho_file.base.file.?.pwriteAll(buffer.items, stub_helper_header.offset);
		837	}
		838
		839	fn writeLaSymbolPtrs(macho_file: *MachO) !void {
		840	const gpa = macho_file.base.allocator;
		841	const cpu_arch = macho_file.base.options.target.cpu.arch;
		842	const la_symbol_ptr_header = macho_file.sections.items(.header)[macho_file.la_symbol_ptr_section_index.?];
		843	const stub_helper_header = macho_file.sections.items(.header)[macho_file.stub_helper_section_index.?];
		844
		845	var buffer = try std.ArrayList(u8).initCapacity(gpa, la_symbol_ptr_header.size);
		846	defer buffer.deinit();
		847
		848	for (0..macho_file.stub_table.count()) \|index\| {
		849	const target_addr = stub_helper_header.addr + stubs.stubHelperPreambleSize(cpu_arch) +
		850	stubs.stubHelperSize(cpu_arch) * index;
		851	buffer.writer().writeIntLittle(u64, target_addr) catch unreachable;
		852	}
		853
		854	log.debug("writing __DATA,__la_symbol_ptr contents at file offset 0x{x}", .{
		855	la_symbol_ptr_header.offset,
		856	});
		857	try macho_file.base.file.?.pwriteAll(buffer.items, la_symbol_ptr_header.offset);
		858	}
		859
		860	fn pruneAndSortSections(macho_file: *MachO) !void {
		861	const Entry = struct {
		862	index: u8,
		863
		864	pub fn lessThan(ctx: *MachO, lhs: @This(), rhs: @This()) bool {
		865	const lhs_header = ctx.sections.items(.header)[lhs.index];
		866	const rhs_header = ctx.sections.items(.header)[rhs.index];
		867	return MachO.getSectionPrecedence(lhs_header) < MachO.getSectionPrecedence(rhs_header);
		868	}
		869	};
		870
		871	const gpa = macho_file.base.allocator;
		872
		873	var entries = try std.ArrayList(Entry).initCapacity(gpa, macho_file.sections.slice().len);
		874	defer entries.deinit();
		875
		876	for (0..macho_file.sections.slice().len) \|index\| {
		877	const section = macho_file.sections.get(index);
		878	if (section.header.size == 0) {
		879	log.debug("pruning section {s},{s} {?d}", .{
		880	section.header.segName(),
		881	section.header.sectName(),
		882	section.first_atom_index,
		883	});
		884	for (&[_]*?u8{
		885	&macho_file.text_section_index,
		886	&macho_file.data_const_section_index,
		887	&macho_file.data_section_index,
		888	&macho_file.bss_section_index,
		889	&macho_file.thread_vars_section_index,
		890	&macho_file.thread_data_section_index,
		891	&macho_file.thread_bss_section_index,
		892	&macho_file.eh_frame_section_index,
		893	&macho_file.unwind_info_section_index,
		894	&macho_file.got_section_index,
		895	&macho_file.tlv_ptr_section_index,
		896	&macho_file.stubs_section_index,
		897	&macho_file.stub_helper_section_index,
		898	&macho_file.la_symbol_ptr_section_index,
		899	}) \|maybe_index\| {
		900	if (maybe_index.* != null and maybe_index.*.? == index) {
		901	maybe_index.* = null;
		902	}
		903	}
		904	continue;
		905	}
		906	entries.appendAssumeCapacity(.{ .index = @intCast(index) });
		907	}
		908
		909	mem.sort(Entry, entries.items, macho_file, Entry.lessThan);
		910
		911	var slice = macho_file.sections.toOwnedSlice();
		912	defer slice.deinit(gpa);
		913
		914	const backlinks = try gpa.alloc(u8, slice.len);
		915	defer gpa.free(backlinks);
		916	for (entries.items, 0..) \|entry, i\| {
		917	backlinks[entry.index] = @as(u8, @intCast(i));
		918	}
		919
		920	try macho_file.sections.ensureTotalCapacity(gpa, entries.items.len);
		921	for (entries.items) \|entry\| {
		922	macho_file.sections.appendAssumeCapacity(slice.get(entry.index));
		923	}
		924
		925	for (&[_]*?u8{
		926	&macho_file.text_section_index,
		927	&macho_file.data_const_section_index,
		928	&macho_file.data_section_index,
		929	&macho_file.bss_section_index,
		930	&macho_file.thread_vars_section_index,
		931	&macho_file.thread_data_section_index,
		932	&macho_file.thread_bss_section_index,
		933	&macho_file.eh_frame_section_index,
		934	&macho_file.unwind_info_section_index,
		935	&macho_file.got_section_index,
		936	&macho_file.tlv_ptr_section_index,
		937	&macho_file.stubs_section_index,
		938	&macho_file.stub_helper_section_index,
		939	&macho_file.la_symbol_ptr_section_index,
		940	}) \|maybe_index\| {
		941	if (maybe_index.) \|index\| {
		942	index.* = backlinks[index.*];
		943	}
		944	}
		945	}
		946
		947	fn calcSectionSizes(macho_file: *MachO) !void {
		948	const slice = macho_file.sections.slice();
		949	for (slice.items(.header), 0..) \|*header, sect_id\| {
		950	if (header.size == 0) continue;
		951	if (macho_file.text_section_index) \|txt\| {
		952	if (txt == sect_id and macho_file.requiresThunks()) continue;
		953	}
		954
		955	var atom_index = slice.items(.first_atom_index)[sect_id] orelse continue;
		956
		957	header.size = 0;
		958	header.@"align" = 0;
		959
		960	while (true) {
		961	const atom = macho_file.getAtom(atom_index);
		962	const atom_alignment = try math.powi(u32, 2, atom.alignment);
		963	const atom_offset = mem.alignForward(u64, header.size, atom_alignment);
		964	const padding = atom_offset - header.size;
		965
		966	const sym = macho_file.getSymbolPtr(atom.getSymbolWithLoc());
		967	sym.n_value = atom_offset;
		968
		969	header.size += padding + atom.size;
		970	header.@"align" = @max(header.@"align", atom.alignment);
		971
		972	if (atom.next_index) \|next_index\| {
		973	atom_index = next_index;
		974	} else break;
		975	}
		976	}
		977
		978	if (macho_file.text_section_index != null and macho_file.requiresThunks()) {
		979	// Create jump/branch range extenders if needed.
		980	try thunks.createThunks(macho_file, macho_file.text_section_index.?);
		981	}
		982
		983	// Update offsets of all symbols contained within each Atom.
		984	// We need to do this since our unwind info synthesiser relies on
		985	// traversing the symbols when synthesising unwind info and DWARF CFI records.
		986	for (slice.items(.first_atom_index)) \|first_atom_index\| {
		987	var atom_index = first_atom_index orelse continue;
		988
		989	while (true) {
		990	const atom = macho_file.getAtom(atom_index);
		991	const sym = macho_file.getSymbol(atom.getSymbolWithLoc());
		992
		993	if (atom.getFile() != null) {
		994	// Update each symbol contained within the atom
		995	var it = Atom.getInnerSymbolsIterator(macho_file, atom_index);
		996	while (it.next()) \|sym_loc\| {
		997	const inner_sym = macho_file.getSymbolPtr(sym_loc);
		998	inner_sym.n_value = sym.n_value + Atom.calcInnerSymbolOffset(
		999	macho_file,
		1000	atom_index,
		1001	sym_loc.sym_index,
		1002	);
		1003	}
		1004
		1005	// If there is a section alias, update it now too
		1006	if (Atom.getSectionAlias(macho_file, atom_index)) \|sym_loc\| {
		1007	const alias = macho_file.getSymbolPtr(sym_loc);
		1008	alias.n_value = sym.n_value;
		1009	}
		1010	}
		1011
		1012	if (atom.next_index) \|next_index\| {
		1013	atom_index = next_index;
		1014	} else break;
		1015	}
		1016	}
		1017
		1018	if (macho_file.got_section_index) \|sect_id\| {
		1019	const header = &macho_file.sections.items(.header)[sect_id];
		1020	header.size = macho_file.got_table.count() * @sizeOf(u64);
		1021	header.@"align" = 3;
		1022	}
		1023
		1024	if (macho_file.tlv_ptr_section_index) \|sect_id\| {
		1025	const header = &macho_file.sections.items(.header)[sect_id];
		1026	header.size = macho_file.tlv_ptr_table.count() * @sizeOf(u64);
		1027	header.@"align" = 3;
		1028	}
		1029
		1030	const cpu_arch = macho_file.base.options.target.cpu.arch;
		1031
		1032	if (macho_file.stubs_section_index) \|sect_id\| {
		1033	const header = &macho_file.sections.items(.header)[sect_id];
		1034	header.size = macho_file.stub_table.count() * stubs.stubSize(cpu_arch);
		1035	header.@"align" = stubs.stubAlignment(cpu_arch);
		1036	}
		1037
		1038	if (macho_file.stub_helper_section_index) \|sect_id\| {
		1039	const header = &macho_file.sections.items(.header)[sect_id];
		1040	header.size = macho_file.stub_table.count() * stubs.stubHelperSize(cpu_arch) +
		1041	stubs.stubHelperPreambleSize(cpu_arch);
		1042	header.@"align" = stubs.stubAlignment(cpu_arch);
		1043	}
		1044
		1045	if (macho_file.la_symbol_ptr_section_index) \|sect_id\| {
		1046	const header = &macho_file.sections.items(.header)[sect_id];
		1047	header.size = macho_file.stub_table.count() * @sizeOf(u64);
		1048	header.@"align" = 3;
		1049	}
		1050	}
		1051
		1052	fn allocateSegments(macho_file: *MachO) !void {
		1053	const gpa = macho_file.base.allocator;
		1054	for (macho_file.segments.items, 0..) \|*segment, segment_index\| {
		1055	const is_text_segment = mem.eql(u8, segment.segName(), "__TEXT");
		1056	const base_size = if (is_text_segment) try load_commands.calcMinHeaderPad(gpa, macho_file.base.options, .{
		1057	.segments = macho_file.segments.items,
		1058	.dylibs = macho_file.dylibs.items,
		1059	.referenced_dylibs = macho_file.referenced_dylibs.keys(),
		1060	}) else 0;
		1061	try allocateSegment(macho_file, @as(u8, @intCast(segment_index)), base_size);
		1062	}
		1063	}
		1064
		1065	fn getSegmentAllocBase(macho_file: *MachO, segment_index: u8) struct { vmaddr: u64, fileoff: u64 } {
		1066	if (segment_index > 0) {
		1067	const prev_segment = macho_file.segments.items[segment_index - 1];
		1068	return .{
		1069	.vmaddr = prev_segment.vmaddr + prev_segment.vmsize,
		1070	.fileoff = prev_segment.fileoff + prev_segment.filesize,
		1071	};
		1072	}
		1073	return .{ .vmaddr = 0, .fileoff = 0 };
		1074	}
		1075
		1076	fn allocateSegment(macho_file: *MachO, segment_index: u8, init_size: u64) !void {
		1077	const segment = &macho_file.segments.items[segment_index];
		1078
		1079	if (mem.eql(u8, segment.segName(), "__PAGEZERO")) return; // allocated upon creation
		1080
		1081	const base = getSegmentAllocBase(macho_file, segment_index);
		1082	segment.vmaddr = base.vmaddr;
		1083	segment.fileoff = base.fileoff;
		1084	segment.filesize = init_size;
		1085	segment.vmsize = init_size;
		1086
		1087	// Allocate the sections according to their alignment at the beginning of the segment.
		1088	const indexes = macho_file.getSectionIndexes(segment_index);
		1089	var start = init_size;
		1090
		1091	const slice = macho_file.sections.slice();
		1092	for (slice.items(.header)[indexes.start..indexes.end], 0..) \|*header, sect_id\| {
		1093	const alignment = try math.powi(u32, 2, header.@"align");
		1094	const start_aligned = mem.alignForward(u64, start, alignment);
		1095	const n_sect = @as(u8, @intCast(indexes.start + sect_id + 1));
		1096
		1097	header.offset = if (header.isZerofill())
		1098	0
		1099	else
		1100	@as(u32, @intCast(segment.fileoff + start_aligned));
		1101	header.addr = segment.vmaddr + start_aligned;
		1102
		1103	if (slice.items(.first_atom_index)[indexes.start + sect_id]) \|first_atom_index\| {
		1104	var atom_index = first_atom_index;
		1105
		1106	log.debug("allocating local symbols in sect({d}, '{s},{s}')", .{
		1107	n_sect,
		1108	header.segName(),
		1109	header.sectName(),
		1110	});
		1111
		1112	while (true) {
		1113	const atom = macho_file.getAtom(atom_index);
		1114	const sym = macho_file.getSymbolPtr(atom.getSymbolWithLoc());
		1115	sym.n_value += header.addr;
		1116	sym.n_sect = n_sect;
		1117
		1118	log.debug(" ATOM(%{d}, '{s}') @{x}", .{
		1119	atom.sym_index,
		1120	macho_file.getSymbolName(atom.getSymbolWithLoc()),
		1121	sym.n_value,
		1122	});
		1123
		1124	if (atom.getFile() != null) {
		1125	// Update each symbol contained within the atom
		1126	var it = Atom.getInnerSymbolsIterator(macho_file, atom_index);
		1127	while (it.next()) \|sym_loc\| {
		1128	const inner_sym = macho_file.getSymbolPtr(sym_loc);
		1129	inner_sym.n_value = sym.n_value + Atom.calcInnerSymbolOffset(
		1130	macho_file,
		1131	atom_index,
		1132	sym_loc.sym_index,
		1133	);
		1134	inner_sym.n_sect = n_sect;
		1135	}
		1136
		1137	// If there is a section alias, update it now too
		1138	if (Atom.getSectionAlias(macho_file, atom_index)) \|sym_loc\| {
		1139	const alias = macho_file.getSymbolPtr(sym_loc);
		1140	alias.n_value = sym.n_value;
		1141	alias.n_sect = n_sect;
		1142	}
		1143	}
		1144
		1145	if (atom.next_index) \|next_index\| {
		1146	atom_index = next_index;
		1147	} else break;
		1148	}
		1149	}
		1150
		1151	start = start_aligned + header.size;
		1152
		1153	if (!header.isZerofill()) {
		1154	segment.filesize = start;
		1155	}
		1156	segment.vmsize = start;
		1157	}
		1158
		1159	const page_size = MachO.getPageSize(macho_file.base.options.target.cpu.arch);
		1160	segment.filesize = mem.alignForward(u64, segment.filesize, page_size);
		1161	segment.vmsize = mem.alignForward(u64, segment.vmsize, page_size);
		1162	}
		1163
		1164	const std = @import("std");
		1165	const build_options = @import("build_options");
		1166	const assert = std.debug.assert;
		1167	const dwarf = std.dwarf;
		1168	const fs = std.fs;
		1169	const log = std.log.scoped(.link);
		1170	const macho = std.macho;
		1171	const math = std.math;
		1172	const mem = std.mem;
		1173
		1174	const aarch64 = @import("../../arch/aarch64/bits.zig");
		1175	const calcUuid = @import("uuid.zig").calcUuid;
		1176	const dead_strip = @import("dead_strip.zig");
		1177	const eh_frame = @import("eh_frame.zig");
		1178	const fat = @import("fat.zig");
		1179	const link = @import("../../link.zig");
		1180	const load_commands = @import("load_commands.zig");
		1181	const stubs = @import("stubs.zig");
		1182	const thunks = @import("thunks.zig");
		1183	const trace = @import("../../tracy.zig").trace;
		1184
		1185	const Allocator = mem.Allocator;
		1186	const Archive = @import("Archive.zig");
		1187	const Atom = @import("Atom.zig");
		1188	const Cache = std.Build.Cache;
		1189	const CodeSignature = @import("CodeSignature.zig");
		1190	const Compilation = @import("../../Compilation.zig");
		1191	const Dylib = @import("Dylib.zig");
		1192	const MachO = @import("../MachO.zig");
		1193	const Md5 = std.crypto.hash.Md5;
		1194	const LibStub = @import("../tapi.zig").LibStub;
		1195	const Object = @import("Object.zig");
		1196	const Section = MachO.Section;
		1197	const StringTable = @import("../strtab.zig").StringTable;
		1198	const SymbolWithLoc = MachO.SymbolWithLoc;
		1199	const TableSection = @import("../table_section.zig").TableSection;
		1200	const Trie = @import("Trie.zig");
		1201	const UnwindInfo = @import("UnwindInfo.zig");