Commit 09dee744145fc423feb2b74ffa22cc1679a2749e | zig

author	Jakub Konka <kubkon@jakubkonka.com> 2022-12-15 13:32:51+01:00
committer	Jakub Konka <kubkon@jakubkonka.com> 2022-12-16 18:05:58+01:00
log	09dee744145fc423feb2b74ffa22cc1679a2749e
tree	d61d4f49c14890b0dbd8d63956784cf94c7f2fcf
parent	3af6a4e887bb3cd986a52ea94202a0079f442e9b

macho: store LC headers to often updated LINKEDIT sections

5 files changed, 268 insertions(+), 416 deletions(-)

lib
- std
  - macho.zig
src
- link
  - MachO.zig
  - MachO
    DebugSymbols.zig
    load_commands.zig
    zld.zig

lib/std/macho.zig+46-46

...	...	@@ -58,10 +58,10 @@ pub const uuid_command = extern struct {
58	58	cmd: LC = .UUID,
59	59
60	60	/// sizeof(struct uuid_command)
61		cmdsize: u32,
	61	cmdsize: u32 = @sizeOf(uuid_command),
62	62
63	63	/// the 128-bit uuid
64		uuid: [16]u8,
	64	uuid: [16]u8 = undefined,
65	65	};
66	66
67	67	/// The version_min_command contains the min OS version on which this
...	...	@@ -71,7 +71,7 @@ pub const version_min_command = extern struct {
71	71	cmd: LC,
72	72
73	73	/// sizeof(struct version_min_command)
74		cmdsize: u32,
	74	cmdsize: u32 = @sizeOf(version_min_command),
75	75
76	76	/// X.Y.Z is encoded in nibbles xxxx.yy.zz
77	77	version: u32,
...	...	@@ -87,7 +87,7 @@ pub const source_version_command = extern struct {
87	87	cmd: LC = .SOURCE_VERSION,
88	88
89	89	/// sizeof(source_version_command)
90		cmdsize: u32,
	90	cmdsize: u32 = @sizeOf(source_version_command),
91	91
92	92	/// A.B.C.D.E packed as a24.b10.c10.d10.e10
93	93	version: u64,
...	...	@@ -155,13 +155,13 @@ pub const entry_point_command = extern struct {
155	155	cmd: LC = .MAIN,
156	156
157	157	/// sizeof(struct entry_point_command)
158		cmdsize: u32,
	158	cmdsize: u32 = @sizeOf(entry_point_command),
159	159
160	160	/// file (__TEXT) offset of main()
161		entryoff: u64,
	161	entryoff: u64 = 0,
162	162
163	163	/// if not zero, initial stack size
164		stacksize: u64,
	164	stacksize: u64 = 0,
165	165	};
166	166
167	167	/// The symtab_command contains the offsets and sizes of the link-edit 4.3BSD
...	...	@@ -172,19 +172,19 @@ pub const symtab_command = extern struct {
172	172	cmd: LC = .SYMTAB,
173	173
174	174	/// sizeof(struct symtab_command)
175		cmdsize: u32,
	175	cmdsize: u32 = @sizeOf(symtab_command),
176	176
177	177	/// symbol table offset
178		symoff: u32,
	178	symoff: u32 = 0,
179	179
180	180	/// number of symbol table entries
181		nsyms: u32,
	181	nsyms: u32 = 0,
182	182
183	183	/// string table offset
184		stroff: u32,
	184	stroff: u32 = 0,
185	185
186	186	/// string table size in bytes
187		strsize: u32,
	187	strsize: u32 = 0,
188	188	};
189	189
190	190	/// This is the second set of the symbolic information which is used to support
...	...	@@ -230,7 +230,7 @@ pub const dysymtab_command = extern struct {
230	230	cmd: LC = .DYSYMTAB,
231	231
232	232	/// sizeof(struct dysymtab_command)
233		cmdsize: u32,
	233	cmdsize: u32 = @sizeOf(dysymtab_command),
234	234
235	235	// The symbols indicated by symoff and nsyms of the LC_SYMTAB load command
236	236	// are grouped into the following three groups:
...	...	@@ -247,22 +247,22 @@ pub const dysymtab_command = extern struct {
247	247	// table when this is a dynamically linked shared library file).
248	248
249	249	/// index of local symbols
250		ilocalsym: u32,
	250	ilocalsym: u32 = 0,
251	251
252	252	/// number of local symbols
253		nlocalsym: u32,
	253	nlocalsym: u32 = 0,
254	254
255	255	/// index to externally defined symbols
256		iextdefsym: u32,
	256	iextdefsym: u32 = 0,
257	257
258	258	/// number of externally defined symbols
259		nextdefsym: u32,
	259	nextdefsym: u32 = 0,
260	260
261	261	/// index to undefined symbols
262		iundefsym: u32,
	262	iundefsym: u32 = 0,
263	263
264	264	/// number of undefined symbols
265		nundefsym: u32,
	265	nundefsym: u32 = 0,
266	266
267	267	// For the for the dynamic binding process to find which module a symbol
268	268	// is defined in the table of contents is used (analogous to the ranlib
...	...	@@ -272,10 +272,10 @@ pub const dysymtab_command = extern struct {
272	272	// symbols are sorted by name and is use as the table of contents.
273	273
274	274	/// file offset to table of contents
275		tocoff: u32,
	275	tocoff: u32 = 0,
276	276
277	277	/// number of entries in table of contents
278		ntoc: u32,
	278	ntoc: u32 = 0,
279	279
280	280	// To support dynamic binding of "modules" (whole object files) the symbol
281	281	// table must reflect the modules that the file was created from. This is
...	...	@@ -286,10 +286,10 @@ pub const dysymtab_command = extern struct {
286	286	// contains one module so everything in the file belongs to the module.
287	287
288	288	/// file offset to module table
289		modtaboff: u32,
	289	modtaboff: u32 = 0,
290	290
291	291	/// number of module table entries
292		nmodtab: u32,
	292	nmodtab: u32 = 0,
293	293
294	294	// To support dynamic module binding the module structure for each module
295	295	// indicates the external references (defined and undefined) each module
...	...	@@ -300,10 +300,10 @@ pub const dysymtab_command = extern struct {
300	300	// undefined external symbols indicates the external references.
301	301
302	302	/// offset to referenced symbol table
303		extrefsymoff: u32,
	303	extrefsymoff: u32 = 0,
304	304
305	305	/// number of referenced symbol table entries
306		nextrefsyms: u32,
	306	nextrefsyms: u32 = 0,
307	307
308	308	// The sections that contain "symbol pointers" and "routine stubs" have
309	309	// indexes and (implied counts based on the size of the section and fixed
...	...	@@ -315,10 +315,10 @@ pub const dysymtab_command = extern struct {
315	315	// The indirect symbol table is ordered to match the entries in the section.
316	316
317	317	/// file offset to the indirect symbol table
318		indirectsymoff: u32,
	318	indirectsymoff: u32 = 0,
319	319
320	320	/// number of indirect symbol table entries
321		nindirectsyms: u32,
	321	nindirectsyms: u32 = 0,
322	322
323	323	// To support relocating an individual module in a library file quickly the
324	324	// external relocation entries for each module in the library need to be
...	...	@@ -347,20 +347,20 @@ pub const dysymtab_command = extern struct {
347	347	// remaining relocation entries must be local).
348	348
349	349	/// offset to external relocation entries
350		extreloff: u32,
	350	extreloff: u32 = 0,
351	351
352	352	/// number of external relocation entries
353		nextrel: u32,
	353	nextrel: u32 = 0,
354	354
355	355	// All the local relocation entries are grouped together (they are not
356	356	// grouped by their module since they are only used if the object is moved
357	357	// from it staticly link edited address).
358	358
359	359	/// offset to local relocation entries
360		locreloff: u32,
	360	locreloff: u32 = 0,
361	361
362	362	/// number of local relocation entries
363		nlocrel: u32,
	363	nlocrel: u32 = 0,
364	364	};
365	365
366	366	/// The linkedit_data_command contains the offsets and sizes of a blob
...	...	@@ -370,13 +370,13 @@ pub const linkedit_data_command = extern struct {
370	370	cmd: LC,
371	371
372	372	/// sizeof(struct linkedit_data_command)
373		cmdsize: u32,
	373	cmdsize: u32 = @sizeOf(linkedit_data_command),
374	374
375	375	/// file offset of data in __LINKEDIT segment
376		dataoff: u32,
	376	dataoff: u32 = 0,
377	377
378	378	/// file size of data in __LINKEDIT segment
379		datasize: u32,
	379	datasize: u32 = 0,
380	380	};
381	381
382	382	/// The dyld_info_command contains the file offsets and sizes of
...	...	@@ -387,10 +387,10 @@ pub const linkedit_data_command = extern struct {
387	387	/// to interpret it.
388	388	pub const dyld_info_command = extern struct {
389	389	/// LC_DYLD_INFO or LC_DYLD_INFO_ONLY
390		cmd: LC,
	390	cmd: LC = .DYLD_INFO_ONLY,
391	391
392	392	/// sizeof(struct dyld_info_command)
393		cmdsize: u32,
	393	cmdsize: u32 = @sizeOf(dyld_info_command),
394	394
395	395	// Dyld rebases an image whenever dyld loads it at an address different
396	396	// from its preferred address. The rebase information is a stream
...	...	@@ -403,10 +403,10 @@ pub const dyld_info_command = extern struct {
403	403	// bytes.
404	404
405	405	/// file offset to rebase info
406		rebase_off: u32,
	406	rebase_off: u32 = 0,
407	407
408	408	/// size of rebase info
409		rebase_size: u32,
	409	rebase_size: u32 = 0,
410	410
411	411	// Dyld binds an image during the loading process, if the image
412	412	// requires any pointers to be initialized to symbols in other images.
...	...	@@ -420,10 +420,10 @@ pub const dyld_info_command = extern struct {
420	420	// encoded in a few bytes.
421	421
422	422	/// file offset to binding info
423		bind_off: u32,
	423	bind_off: u32 = 0,
424	424
425	425	/// size of binding info
426		bind_size: u32,
	426	bind_size: u32 = 0,
427	427
428	428	// Some C++ programs require dyld to unique symbols so that all
429	429	// images in the process use the same copy of some code/data.
...	...	@@ -440,10 +440,10 @@ pub const dyld_info_command = extern struct {
440	440	// and the call to operator new is then rebound.
441	441
442	442	/// file offset to weak binding info
443		weak_bind_off: u32,
	443	weak_bind_off: u32 = 0,
444	444
445	445	/// size of weak binding info
446		weak_bind_size: u32,
	446	weak_bind_size: u32 = 0,
447	447
448	448	// Some uses of external symbols do not need to be bound immediately.
449	449	// Instead they can be lazily bound on first use. The lazy_bind
...	...	@@ -457,10 +457,10 @@ pub const dyld_info_command = extern struct {
457	457	// to bind.
458	458
459	459	/// file offset to lazy binding info
460		lazy_bind_off: u32,
	460	lazy_bind_off: u32 = 0,
461	461
462	462	/// size of lazy binding info
463		lazy_bind_size: u32,
	463	lazy_bind_size: u32 = 0,
464	464
465	465	// The symbols exported by a dylib are encoded in a trie. This
466	466	// is a compact representation that factors out common prefixes.
...	...	@@ -494,10 +494,10 @@ pub const dyld_info_command = extern struct {
494	494	// edge points to.
495	495
496	496	/// file offset to lazy binding info
497		export_off: u32,
	497	export_off: u32 = 0,
498	498
499	499	/// size of lazy binding info
500		export_size: u32,
	500	export_size: u32 = 0,
501	501	};
502	502
503	503	/// A program that uses a dynamic linker contains a dylinker_command to identify

src/link/MachO.zig+69-120

...	...	@@ -99,10 +99,11 @@ page_size: u16,
99	99	/// fashion (default for LLVM backend).
100	100	mode: enum { incremental, one_shot },
101	101
102		uuid: struct {
103		buf: [16]u8 = undefined,
104		final: bool = false,
105		} = .{},
	102	dyld_info_cmd: macho.dyld_info_command = .{},
	103	symtab_cmd: macho.symtab_command = .{},
	104	dysymtab_cmd: macho.dysymtab_command = .{},
	105	uuid_cmd: macho.uuid_command = .{},
	106	codesig_cmd: macho.linkedit_data_command = .{ .cmd = .CODE_SIGNATURE },
106	107
107	108	dylibs: std.ArrayListUnmanaged(Dylib) = .{},
108	109	dylibs_map: std.StringHashMapUnmanaged(u16) = .{},
...	...	@@ -554,12 +555,17 @@ pub fn flushModule(self: MachO, comp: Compilation, prog_node: *std.Progress.No
554	555	self.logAtoms();
555	556	}
556	557
	558	try self.writeLinkeditSegmentData();
	559
	560	// Write load commands
557	561	var lc_buffer = std.ArrayList(u8).init(arena);
558	562	const lc_writer = lc_buffer.writer();
559		var ncmds: u32 = 0;
560	563
561		try self.writeLinkeditSegmentData(&ncmds, lc_writer);
562		try load_commands.writeDylinkerLC(&ncmds, lc_writer);
	564	try self.writeSegmentHeaders(lc_writer);
	565	try lc_writer.writeStruct(self.dyld_info_cmd);
	566	try lc_writer.writeStruct(self.symtab_cmd);
	567	try lc_writer.writeStruct(self.dysymtab_cmd);
	568	try load_commands.writeDylinkerLC(lc_writer);
563	569
564	570	switch (self.base.options.output_mode) {
565	571	.Exe => blk: {
...	...	@@ -573,33 +579,29 @@ pub fn flushModule(self: MachO, comp: Compilation, prog_node: *std.Progress.No
573	579	else => \|e\| return e,
574	580	};
575	581	const sym = self.getSymbol(global);
576		try load_commands.writeMainLC(@intCast(u32, sym.n_value - seg.vmaddr), &self.base.options, &ncmds, lc_writer);
	582	try lc_writer.writeStruct(macho.entry_point_command{
	583	.entryoff = @intCast(u32, sym.n_value - seg.vmaddr),
	584	.stacksize = self.base.options.stack_size_override orelse 0,
	585	});
577	586	},
578	587	.Lib => if (self.base.options.link_mode == .Dynamic) {
579		try load_commands.writeDylibIdLC(self.base.allocator, &self.base.options, &ncmds, lc_writer);
	588	try load_commands.writeDylibIdLC(self.base.allocator, &self.base.options, lc_writer);
580	589	},
581	590	else => {},
582	591	}
583	592
584		try load_commands.writeRpathLCs(self.base.allocator, &self.base.options, &ncmds, lc_writer);
585
586		{
587		try lc_writer.writeStruct(macho.source_version_command{
588		.cmdsize = @sizeOf(macho.source_version_command),
589		.version = 0x0,
590		});
591		ncmds += 1;
592		}
593
594		try load_commands.writeBuildVersionLC(&self.base.options, &ncmds, lc_writer);
	593	try load_commands.writeRpathLCs(self.base.allocator, &self.base.options, lc_writer);
	594	try lc_writer.writeStruct(macho.source_version_command{
	595	.version = 0,
	596	});
	597	try load_commands.writeBuildVersionLC(&self.base.options, lc_writer);
595	598
596		if (!self.uuid.final) {
597		std.crypto.random.bytes(&self.uuid.buf);
598		self.uuid.final = true;
	599	if (self.cold_start) {
	600	std.crypto.random.bytes(&self.uuid_cmd.uuid);
599	601	}
600		try load_commands.writeUuidLC(&self.uuid.buf, &ncmds, lc_writer);
	602	try lc_writer.writeStruct(self.uuid_cmd);
601	603
602		try load_commands.writeLoadDylibLCs(self.dylibs.items, self.referenced_dylibs.keys(), &ncmds, lc_writer);
	604	try load_commands.writeLoadDylibLCs(self.dylibs.items, self.referenced_dylibs.keys(), lc_writer);
603	605
604	606	const target = self.base.options.target;
605	607	const requires_codesig = blk: {
...	...	@@ -608,7 +610,6 @@ pub fn flushModule(self: MachO, comp: Compilation, prog_node: *std.Progress.No
608	610	break :blk true;
609	611	break :blk false;
610	612	};
611		var codesig_offset: ?u32 = null;
612	613	var codesig: ?CodeSignature = if (requires_codesig) blk: {
613	614	// Preallocate space for the code signature.
614	615	// We need to do this at this stage so that we have the load commands with proper values
...	...	@@ -620,20 +621,18 @@ pub fn flushModule(self: MachO, comp: Compilation, prog_node: *std.Progress.No
620	621	if (self.base.options.entitlements) \|path\| {
621	622	try codesig.addEntitlements(arena, path);
622	623	}
623		codesig_offset = try self.writeCodeSignaturePadding(&codesig, &ncmds, lc_writer);
	624	try self.writeCodeSignaturePadding(&codesig);
	625	try lc_writer.writeStruct(self.codesig_cmd);
624	626	break :blk codesig;
625	627	} else null;
626	628
627		var headers_buf = std.ArrayList(u8).init(arena);
628		try self.writeSegmentHeaders(&ncmds, headers_buf.writer());
	629	try self.base.file.?.pwriteAll(lc_buffer.items, @sizeOf(macho.mach_header_64));
629	630
630		try self.base.file.?.pwriteAll(headers_buf.items, @sizeOf(macho.mach_header_64));
631		try self.base.file.?.pwriteAll(lc_buffer.items, @sizeOf(macho.mach_header_64) + headers_buf.items.len);
632
633		try self.writeHeader(ncmds, @intCast(u32, lc_buffer.items.len + headers_buf.items.len));
	631	const ncmds = load_commands.calcNumOfLCs(lc_buffer.items);
	632	try self.writeHeader(ncmds, @intCast(u32, lc_buffer.items.len));
634	633
635	634	if (codesig) \|*csig\| {
636		try self.writeCodeSignature(comp, csig, codesig_offset.?); // code signing always comes last
	635	try self.writeCodeSignature(comp, csig); // code signing always comes last
637	636	}
638	637
639	638	if (self.d_sym) \|*d_sym\| {
...	...	@@ -3146,18 +3145,17 @@ pub fn getGlobalSymbol(self: *MachO, name: []const u8) !u32 {
3146	3145	return global_index;
3147	3146	}
3148	3147
3149		fn writeSegmentHeaders(self: MachO, ncmds: u32, writer: anytype) !void {
	3148	fn writeSegmentHeaders(self: *MachO, writer: anytype) !void {
3150	3149	for (self.segments.items) \|seg, i\| {
3151	3150	const indexes = self.getSectionIndexes(@intCast(u8, i));
3152	3151	try writer.writeStruct(seg);
3153	3152	for (self.sections.items(.header)[indexes.start..indexes.end]) \|header\| {
3154	3153	try writer.writeStruct(header);
3155	3154	}
3156		ncmds.* += 1;
3157	3155	}
3158	3156	}
3159	3157
3160		fn writeLinkeditSegmentData(self: MachO, ncmds: u32, lc_writer: anytype) !void {
	3158	fn writeLinkeditSegmentData(self: *MachO) !void {
3161	3159	const seg = self.getLinkeditSegmentPtr();
3162	3160	seg.filesize = 0;
3163	3161	seg.vmsize = 0;
...	...	@@ -3172,8 +3170,8 @@ fn writeLinkeditSegmentData(self: MachO, ncmds: u32, lc_writer: anytype) !void
3172	3170	}
3173	3171	}
3174	3172
3175		try self.writeDyldInfoData(ncmds, lc_writer);
3176		try self.writeSymtabs(ncmds, lc_writer);
	3173	try self.writeDyldInfoData();
	3174	try self.writeSymtabs();
3177	3175
3178	3176	seg.vmsize = mem.alignForwardGeneric(u64, seg.filesize, self.page_size);
3179	3177	}
...	...	@@ -3325,7 +3323,7 @@ fn collectExportData(self: MachO, trie: Trie) !void {
3325	3323	try trie.finalize(gpa);
3326	3324	}
3327	3325
3328		fn writeDyldInfoData(self: MachO, ncmds: u32, lc_writer: anytype) !void {
	3326	fn writeDyldInfoData(self: *MachO) !void {
3329	3327	const tracy = trace(@src());
3330	3328	defer tracy.end();
3331	3329
...	...	@@ -3396,21 +3394,14 @@ fn writeDyldInfoData(self: MachO, ncmds: u32, lc_writer: anytype) !void {
3396	3394	const end = start + (math.cast(usize, lazy_bind_size) orelse return error.Overflow);
3397	3395	try self.populateLazyBindOffsetsInStubHelper(buffer[start..end]);
3398	3396
3399		try lc_writer.writeStruct(macho.dyld_info_command{
3400		.cmd = .DYLD_INFO_ONLY,
3401		.cmdsize = @sizeOf(macho.dyld_info_command),
3402		.rebase_off = @intCast(u32, rebase_off),
3403		.rebase_size = @intCast(u32, rebase_size),
3404		.bind_off = @intCast(u32, bind_off),
3405		.bind_size = @intCast(u32, bind_size),
3406		.weak_bind_off = 0,
3407		.weak_bind_size = 0,
3408		.lazy_bind_off = @intCast(u32, lazy_bind_off),
3409		.lazy_bind_size = @intCast(u32, lazy_bind_size),
3410		.export_off = @intCast(u32, export_off),
3411		.export_size = @intCast(u32, export_size),
3412		});
3413		ncmds.* += 1;
	3397	self.dyld_info_cmd.rebase_off = @intCast(u32, rebase_off);
	3398	self.dyld_info_cmd.rebase_size = @intCast(u32, rebase_size);
	3399	self.dyld_info_cmd.bind_off = @intCast(u32, bind_off);
	3400	self.dyld_info_cmd.bind_size = @intCast(u32, bind_size);
	3401	self.dyld_info_cmd.lazy_bind_off = @intCast(u32, lazy_bind_off);
	3402	self.dyld_info_cmd.lazy_bind_size = @intCast(u32, lazy_bind_size);
	3403	self.dyld_info_cmd.export_off = @intCast(u32, export_off);
	3404	self.dyld_info_cmd.export_size = @intCast(u32, export_size);
3414	3405	}
3415	3406
3416	3407	fn populateLazyBindOffsetsInStubHelper(self: *MachO, buffer: []const u8) !void {
...	...	@@ -3512,45 +3503,14 @@ fn populateLazyBindOffsetsInStubHelper(self: *MachO, buffer: []const u8) !void {
3512	3503	}
3513	3504	}
3514	3505
3515		fn writeSymtabs(self: MachO, ncmds: u32, lc_writer: anytype) !void {
3516		var symtab_cmd = macho.symtab_command{
3517		.cmdsize = @sizeOf(macho.symtab_command),
3518		.symoff = 0,
3519		.nsyms = 0,
3520		.stroff = 0,
3521		.strsize = 0,
3522		};
3523		var dysymtab_cmd = macho.dysymtab_command{
3524		.cmdsize = @sizeOf(macho.dysymtab_command),
3525		.ilocalsym = 0,
3526		.nlocalsym = 0,
3527		.iextdefsym = 0,
3528		.nextdefsym = 0,
3529		.iundefsym = 0,
3530		.nundefsym = 0,
3531		.tocoff = 0,
3532		.ntoc = 0,
3533		.modtaboff = 0,
3534		.nmodtab = 0,
3535		.extrefsymoff = 0,
3536		.nextrefsyms = 0,
3537		.indirectsymoff = 0,
3538		.nindirectsyms = 0,
3539		.extreloff = 0,
3540		.nextrel = 0,
3541		.locreloff = 0,
3542		.nlocrel = 0,
3543		};
3544		var ctx = try self.writeSymtab(&symtab_cmd);
	3506	fn writeSymtabs(self: *MachO) !void {
	3507	var ctx = try self.writeSymtab();
3545	3508	defer ctx.imports_table.deinit();
3546		try self.writeDysymtab(ctx, &dysymtab_cmd);
3547		try self.writeStrtab(&symtab_cmd);
3548		try lc_writer.writeStruct(symtab_cmd);
3549		try lc_writer.writeStruct(dysymtab_cmd);
3550		ncmds.* += 2;
	3509	try self.writeDysymtab(ctx);
	3510	try self.writeStrtab();
3551	3511	}
3552	3512
3553		fn writeSymtab(self: MachO, lc: macho.symtab_command) !SymtabCtx {
	3513	fn writeSymtab(self: *MachO) !SymtabCtx {
3554	3514	const gpa = self.base.allocator;
3555	3515
3556	3516	var locals = std.ArrayList(macho.nlist_64).init(gpa);
...	...	@@ -3615,8 +3575,8 @@ fn writeSymtab(self: MachO, lc: macho.symtab_command) !SymtabCtx {
3615	3575	log.debug("writing symtab from 0x{x} to 0x{x}", .{ offset, offset + needed_size });
3616	3576	try self.base.file.?.pwriteAll(buffer.items, offset);
3617	3577
3618		lc.symoff = @intCast(u32, offset);
3619		lc.nsyms = nsyms;
	3578	self.symtab_cmd.symoff = @intCast(u32, offset);
	3579	self.symtab_cmd.nsyms = nsyms;
3620	3580
3621	3581	return SymtabCtx{
3622	3582	.nlocalsym = nlocals,
...	...	@@ -3626,7 +3586,7 @@ fn writeSymtab(self: MachO, lc: macho.symtab_command) !SymtabCtx {
3626	3586	};
3627	3587	}
3628	3588
3629		fn writeStrtab(self: MachO, lc: macho.symtab_command) !void {
	3589	fn writeStrtab(self: *MachO) !void {
3630	3590	const seg = self.getLinkeditSegmentPtr();
3631	3591	const offset = mem.alignForwardGeneric(u64, seg.fileoff + seg.filesize, @alignOf(u64));
3632	3592	const needed_size = self.strtab.buffer.items.len;
...	...	@@ -3636,8 +3596,8 @@ fn writeStrtab(self: MachO, lc: macho.symtab_command) !void {
3636	3596
3637	3597	try self.base.file.?.pwriteAll(self.strtab.buffer.items, offset);
3638	3598
3639		lc.stroff = @intCast(u32, offset);
3640		lc.strsize = @intCast(u32, needed_size);
	3599	self.symtab_cmd.stroff = @intCast(u32, offset);
	3600	self.symtab_cmd.strsize = @intCast(u32, needed_size);
3641	3601	}
3642	3602
3643	3603	const SymtabCtx = struct {
...	...	@@ -3647,7 +3607,7 @@ const SymtabCtx = struct {
3647	3607	imports_table: std.AutoHashMap(SymbolWithLoc, u32),
3648	3608	};
3649	3609
3650		fn writeDysymtab(self: MachO, ctx: SymtabCtx, lc: macho.dysymtab_command) !void {
	3610	fn writeDysymtab(self: *MachO, ctx: SymtabCtx) !void {
3651	3611	const gpa = self.base.allocator;
3652	3612	const nstubs = @intCast(u32, self.stubs_table.count());
3653	3613	const ngot_entries = @intCast(u32, self.got_entries_table.count());
...	...	@@ -3706,21 +3666,16 @@ fn writeDysymtab(self: MachO, ctx: SymtabCtx, lc: macho.dysymtab_command) !voi
3706	3666	assert(buf.items.len == needed_size);
3707	3667	try self.base.file.?.pwriteAll(buf.items, offset);
3708	3668
3709		lc.nlocalsym = ctx.nlocalsym;
3710		lc.iextdefsym = iextdefsym;
3711		lc.nextdefsym = ctx.nextdefsym;
3712		lc.iundefsym = iundefsym;
3713		lc.nundefsym = ctx.nundefsym;
3714		lc.indirectsymoff = @intCast(u32, offset);
3715		lc.nindirectsyms = nindirectsyms;
	3669	self.dysymtab_cmd.nlocalsym = ctx.nlocalsym;
	3670	self.dysymtab_cmd.iextdefsym = iextdefsym;
	3671	self.dysymtab_cmd.nextdefsym = ctx.nextdefsym;
	3672	self.dysymtab_cmd.iundefsym = iundefsym;
	3673	self.dysymtab_cmd.nundefsym = ctx.nundefsym;
	3674	self.dysymtab_cmd.indirectsymoff = @intCast(u32, offset);
	3675	self.dysymtab_cmd.nindirectsyms = nindirectsyms;
3716	3676	}
3717	3677
3718		fn writeCodeSignaturePadding(
3719		self: *MachO,
3720		code_sig: *CodeSignature,
3721		ncmds: *u32,
3722		lc_writer: anytype,
3723		) !u32 {
	3678	fn writeCodeSignaturePadding(self: MachO, code_sig: CodeSignature) !void {
3724	3679	const seg = self.getLinkeditSegmentPtr();
3725	3680	// Code signature data has to be 16-bytes aligned for Apple tools to recognize the file
3726	3681	// https://github.com/opensource-apple/cctools/blob/fdb4825f303fd5c0751be524babd32958181b3ed/libstuff/checkout.c#L271
...	...	@@ -3733,19 +3688,13 @@ fn writeCodeSignaturePadding(
3733	3688	// except for code signature data.
3734	3689	try self.base.file.?.pwriteAll(&[_]u8{0}, offset + needed_size - 1);
3735	3690
3736		try lc_writer.writeStruct(macho.linkedit_data_command{
3737		.cmd = .CODE_SIGNATURE,
3738		.cmdsize = @sizeOf(macho.linkedit_data_command),
3739		.dataoff = @intCast(u32, offset),
3740		.datasize = @intCast(u32, needed_size),
3741		});
3742		ncmds.* += 1;
3743
3744		return @intCast(u32, offset);
	3691	self.codesig_cmd.dataoff = @intCast(u32, offset);
	3692	self.codesig_cmd.datasize = @intCast(u32, needed_size);
3745	3693	}
3746	3694
3747		fn writeCodeSignature(self: MachO, comp: const Compilation, code_sig: *CodeSignature, offset: u32) !void {
	3695	fn writeCodeSignature(self: MachO, comp: const Compilation, code_sig: *CodeSignature) !void {
3748	3696	const seg = self.getSegment(self.text_section_index.?);
	3697	const offset = self.codesig_cmd.dataoff;
3749	3698
3750	3699	var buffer = std.ArrayList(u8).init(self.base.allocator);
3751	3700	defer buffer.deinit();

src/link/MachO/DebugSymbols.zig+28-50

...	...	@@ -26,6 +26,8 @@ dwarf: Dwarf,
26	26	file: fs.File,
27	27	page_size: u16,
28	28
	29	symtab_cmd: macho.symtab_command = .{},
	30
29	31	segments: std.ArrayListUnmanaged(macho.segment_command_64) = .{},
30	32	sections: std.ArrayListUnmanaged(macho.section_64) = .{},
31	33
...	...	@@ -296,28 +298,21 @@ pub fn flushModule(self: DebugSymbols, macho_file: MachO) !void {
296	298	}
297	299	}
298	300
	301	self.finalizeDwarfSegment(macho_file);
	302	try self.writeLinkeditSegmentData(macho_file);
	303
	304	// Write load commands
299	305	var lc_buffer = std.ArrayList(u8).init(self.allocator);
300	306	defer lc_buffer.deinit();
301	307	const lc_writer = lc_buffer.writer();
302		var ncmds: u32 = 0;
303
304		self.finalizeDwarfSegment(macho_file);
305		try self.writeLinkeditSegmentData(macho_file, &ncmds, lc_writer);
306	308
307		try load_commands.writeUuidLC(&macho_file.uuid.buf, &ncmds, lc_writer);
	309	try self.writeSegmentHeaders(macho_file, lc_writer);
	310	try lc_writer.writeStruct(self.symtab_cmd);
	311	try lc_writer.writeStruct(macho_file.uuid_cmd);
308	312
309		var headers_buf = std.ArrayList(u8).init(self.allocator);
310		defer headers_buf.deinit();
311		try self.writeSegmentHeaders(macho_file, &ncmds, headers_buf.writer());
312
313		try self.file.pwriteAll(headers_buf.items, @sizeOf(macho.mach_header_64));
314		try self.file.pwriteAll(lc_buffer.items, @sizeOf(macho.mach_header_64) + headers_buf.items.len);
315
316		try self.writeHeader(
317		macho_file,
318		ncmds,
319		@intCast(u32, lc_buffer.items.len + headers_buf.items.len),
320		);
	313	const ncmds = load_commands.calcNumOfLCs(lc_buffer.items);
	314	try self.file.pwriteAll(lc_buffer.items, @sizeOf(macho.mach_header_64));
	315	try self.writeHeader(macho_file, ncmds, @intCast(u32, lc_buffer.items.len));
321	316
322	317	assert(!self.debug_abbrev_section_dirty);
323	318	assert(!self.debug_aranges_section_dirty);
...	...	@@ -384,7 +379,7 @@ fn finalizeDwarfSegment(self: DebugSymbols, macho_file: MachO) void {
384	379	log.debug("found __LINKEDIT segment free space at 0x{x}", .{linkedit.fileoff});
385	380	}
386	381
387		fn writeSegmentHeaders(self: DebugSymbols, macho_file: MachO, ncmds: *u32, writer: anytype) !void {
	382	fn writeSegmentHeaders(self: DebugSymbols, macho_file: MachO, writer: anytype) !void {
388	383	// Write segment/section headers from the binary file first.
389	384	const end = macho_file.linkedit_segment_cmd_index.?;
390	385	for (macho_file.segments.items[0..end]) \|seg, i\| {
...	...	@@ -414,8 +409,6 @@ fn writeSegmentHeaders(self: DebugSymbols, macho_file: MachO, ncmds: *u32, wri
414	409	out_header.offset = 0;
415	410	try writer.writeStruct(out_header);
416	411	}
417
418		ncmds.* += 1;
419	412	}
420	413	// Next, commit DSYM's __LINKEDIT and __DWARF segments headers.
421	414	for (self.segments.items) \|seg, i\| {
...	...	@@ -424,7 +417,6 @@ fn writeSegmentHeaders(self: DebugSymbols, macho_file: MachO, ncmds: *u32, wri
424	417	for (self.sections.items[indexes.start..indexes.end]) \|header\| {
425	418	try writer.writeStruct(header);
426	419	}
427		ncmds.* += 1;
428	420	}
429	421	}
430	422
...	...	@@ -463,33 +455,19 @@ fn allocatedSize(self: *DebugSymbols, start: u64) u64 {
463	455	return min_pos - start;
464	456	}
465	457
466		fn writeLinkeditSegmentData(
467		self: *DebugSymbols,
468		macho_file: *MachO,
469		ncmds: *u32,
470		lc_writer: anytype,
471		) !void {
	458	fn writeLinkeditSegmentData(self: DebugSymbols, macho_file: MachO) !void {
472	459	const tracy = trace(@src());
473	460	defer tracy.end();
474	461
475		var symtab_cmd = macho.symtab_command{
476		.cmdsize = @sizeOf(macho.symtab_command),
477		.symoff = 0,
478		.nsyms = 0,
479		.stroff = 0,
480		.strsize = 0,
481		};
482		try self.writeSymtab(macho_file, &symtab_cmd);
483		try self.writeStrtab(&symtab_cmd);
484		try lc_writer.writeStruct(symtab_cmd);
485		ncmds.* += 1;
	462	try self.writeSymtab(macho_file);
	463	try self.writeStrtab();
486	464
487	465	const seg = &self.segments.items[self.linkedit_segment_cmd_index.?];
488	466	const aligned_size = mem.alignForwardGeneric(u64, seg.filesize, self.page_size);
489	467	seg.vmsize = aligned_size;
490	468	}
491	469
492		fn writeSymtab(self: DebugSymbols, macho_file: MachO, lc: *macho.symtab_command) !void {
	470	fn writeSymtab(self: DebugSymbols, macho_file: MachO) !void {
493	471	const tracy = trace(@src());
494	472	defer tracy.end();
495	473
...	...	@@ -528,10 +506,10 @@ fn writeSymtab(self: DebugSymbols, macho_file: MachO, lc: *macho.symtab_comman
528	506	const needed_size = nsyms * @sizeOf(macho.nlist_64);
529	507	seg.filesize = offset + needed_size - seg.fileoff;
530	508
531		lc.symoff = @intCast(u32, offset);
532		lc.nsyms = @intCast(u32, nsyms);
	509	self.symtab_cmd.symoff = @intCast(u32, offset);
	510	self.symtab_cmd.nsyms = @intCast(u32, nsyms);
533	511
534		const locals_off = lc.symoff;
	512	const locals_off = @intCast(u32, offset);
535	513	const locals_size = nlocals * @sizeOf(macho.nlist_64);
536	514	const exports_off = locals_off + locals_size;
537	515	const exports_size = nexports * @sizeOf(macho.nlist_64);
...	...	@@ -543,26 +521,26 @@ fn writeSymtab(self: DebugSymbols, macho_file: MachO, lc: *macho.symtab_comman
543	521	try self.file.pwriteAll(mem.sliceAsBytes(exports.items), exports_off);
544	522	}
545	523
546		fn writeStrtab(self: DebugSymbols, lc: macho.symtab_command) !void {
	524	fn writeStrtab(self: *DebugSymbols) !void {
547	525	const tracy = trace(@src());
548	526	defer tracy.end();
549	527
550	528	const seg = &self.segments.items[self.linkedit_segment_cmd_index.?];
551		const symtab_size = @intCast(u32, lc.nsyms * @sizeOf(macho.nlist_64));
552		const offset = mem.alignForwardGeneric(u64, lc.symoff + symtab_size, @alignOf(u64));
	529	const symtab_size = @intCast(u32, self.symtab_cmd.nsyms * @sizeOf(macho.nlist_64));
	530	const offset = mem.alignForwardGeneric(u64, self.symtab_cmd.symoff + symtab_size, @alignOf(u64));
553	531	const needed_size = mem.alignForwardGeneric(u64, self.strtab.buffer.items.len, @alignOf(u64));
554	532
555	533	seg.filesize = offset + needed_size - seg.fileoff;
556		lc.stroff = @intCast(u32, offset);
557		lc.strsize = @intCast(u32, needed_size);
	534	self.symtab_cmd.stroff = @intCast(u32, offset);
	535	self.symtab_cmd.strsize = @intCast(u32, needed_size);
558	536
559		log.debug("writing string table from 0x{x} to 0x{x}", .{ lc.stroff, lc.stroff + lc.strsize });
	537	log.debug("writing string table from 0x{x} to 0x{x}", .{ offset, offset + needed_size });
560	538
561		try self.file.pwriteAll(self.strtab.buffer.items, lc.stroff);
	539	try self.file.pwriteAll(self.strtab.buffer.items, offset);
562	540
563	541	if (self.strtab.buffer.items.len < needed_size) {
564	542	// Ensure we are always padded to the actual length of the file.
565		try self.file.pwriteAll(&[_]u8{0}, lc.stroff + lc.strsize);
	543	try self.file.pwriteAll(&[_]u8{0}, offset + needed_size);
566	544	}
567	545	}
568	546

src/link/MachO/load_commands.zig+20-40

...	...	@@ -131,7 +131,19 @@ pub fn calcMinHeaderPad(gpa: Allocator, options: *const link.Options, ctx: CalcL
131	131	return offset;
132	132	}
133	133
134		pub fn writeDylinkerLC(ncmds: *u32, lc_writer: anytype) !void {
	134	pub fn calcNumOfLCs(lc_buffer: []const u8) u32 {
	135	var ncmds: u32 = 0;
	136	var pos: usize = 0;
	137	while (true) {
	138	if (pos >= lc_buffer.len) break;
	139	const cmd = @ptrCast(align(1) const macho.load_command, lc_buffer.ptr + pos).;
	140	ncmds += 1;
	141	pos += cmd.cmdsize;
	142	}
	143	return ncmds;
	144	}
	145
	146	pub fn writeDylinkerLC(lc_writer: anytype) !void {
135	147	const name_len = mem.sliceTo(default_dyld_path, 0).len;
136	148	const cmdsize = @intCast(u32, mem.alignForwardGeneric(
137	149	u64,
...	...	@@ -148,7 +160,6 @@ pub fn writeDylinkerLC(ncmds: *u32, lc_writer: anytype) !void {
148	160	if (padding > 0) {
149	161	try lc_writer.writeByteNTimes(0, padding);
150	162	}
151		ncmds.* += 1;
152	163	}
153	164
154	165	const WriteDylibLCCtx = struct {
...	...	@@ -159,7 +170,7 @@ const WriteDylibLCCtx = struct {
159	170	compatibility_version: u32 = 0x10000,
160	171	};
161	172
162		fn writeDylibLC(ctx: WriteDylibLCCtx, ncmds: *u32, lc_writer: anytype) !void {
	173	fn writeDylibLC(ctx: WriteDylibLCCtx, lc_writer: anytype) !void {
163	174	const name_len = ctx.name.len + 1;
164	175	const cmdsize = @intCast(u32, mem.alignForwardGeneric(
165	176	u64,
...	...	@@ -182,10 +193,9 @@ fn writeDylibLC(ctx: WriteDylibLCCtx, ncmds: *u32, lc_writer: anytype) !void {
182	193	if (padding > 0) {
183	194	try lc_writer.writeByteNTimes(0, padding);
184	195	}
185		ncmds.* += 1;
186	196	}
187	197
188		pub fn writeDylibIdLC(gpa: Allocator, options: const link.Options, ncmds: u32, lc_writer: anytype) !void {
	198	pub fn writeDylibIdLC(gpa: Allocator, options: *const link.Options, lc_writer: anytype) !void {
189	199	assert(options.output_mode == .Lib and options.link_mode == .Dynamic);
190	200	const emit = options.emit.?;
191	201	const install_name = options.install_name orelse try emit.directory.join(gpa, &.{emit.sub_path});
...	...	@@ -205,18 +215,7 @@ pub fn writeDylibIdLC(gpa: Allocator, options: const link.Options, ncmds: u32,
205	215	.name = install_name,
206	216	.current_version = curr.major << 16 \| curr.minor << 8 \| curr.patch,
207	217	.compatibility_version = compat.major << 16 \| compat.minor << 8 \| compat.patch,
208		}, ncmds, lc_writer);
209		}
210
211		pub fn writeMainLC(entryoff: u32, options: const link.Options, ncmds: u32, lc_writer: anytype) !void {
212		assert(options.output_mode == .Exe);
213		try lc_writer.writeStruct(macho.entry_point_command{
214		.cmd = .MAIN,
215		.cmdsize = @sizeOf(macho.entry_point_command),
216		.entryoff = entryoff,
217		.stacksize = options.stack_size_override orelse 0,
218		});
219		ncmds.* += 1;
	218	}, lc_writer);
220	219	}
221	220
222	221	const RpathIterator = struct {
...	...	@@ -244,7 +243,7 @@ const RpathIterator = struct {
244	243	}
245	244	};
246	245
247		pub fn writeRpathLCs(gpa: Allocator, options: const link.Options, ncmds: u32, lc_writer: anytype) !void {
	246	pub fn writeRpathLCs(gpa: Allocator, options: *const link.Options, lc_writer: anytype) !void {
248	247	var it = RpathIterator.init(gpa, options.rpath_list);
249	248	defer it.deinit();
250	249
...	...	@@ -265,11 +264,10 @@ pub fn writeRpathLCs(gpa: Allocator, options: const link.Options, ncmds: u32,
265	264	if (padding > 0) {
266	265	try lc_writer.writeByteNTimes(0, padding);
267	266	}
268		ncmds.* += 1;
269	267	}
270	268	}
271	269
272		pub fn writeBuildVersionLC(options: const link.Options, ncmds: u32, lc_writer: anytype) !void {
	270	pub fn writeBuildVersionLC(options: *const link.Options, lc_writer: anytype) !void {
273	271	const cmdsize = @sizeOf(macho.build_version_command) + @sizeOf(macho.build_tool_version);
274	272	const platform_version = blk: {
275	273	const ver = options.target.os.version_range.semver.min;
...	...	@@ -299,10 +297,9 @@ pub fn writeBuildVersionLC(options: const link.Options, ncmds: u32, lc_writer:
299	297	.tool = .LD,
300	298	.version = 0x0,
301	299	}));
302		ncmds.* += 1;
303	300	}
304	301
305		pub fn writeLoadDylibLCs(dylibs: []const Dylib, referenced: []u16, ncmds: *u32, lc_writer: anytype) !void {
	302	pub fn writeLoadDylibLCs(dylibs: []const Dylib, referenced: []u16, lc_writer: anytype) !void {
306	303	for (referenced) \|index\| {
307	304	const dylib = dylibs[index];
308	305	const dylib_id = dylib.id orelse unreachable;
...	...	@@ -312,23 +309,6 @@ pub fn writeLoadDylibLCs(dylibs: []const Dylib, referenced: []u16, ncmds: *u32,
312	309	.timestamp = dylib_id.timestamp,
313	310	.current_version = dylib_id.current_version,
314	311	.compatibility_version = dylib_id.compatibility_version,
315		}, ncmds, lc_writer);
	312	}, lc_writer);
316	313	}
317	314	}
318
319		pub fn writeSourceVersionLC(ncmds: *u32, lc_writer: anytype) !void {
320		try lc_writer.writeStruct(macho.source_version_command{
321		.cmdsize = @sizeOf(macho.source_version_command),
322		.version = 0x0,
323		});
324		ncmds.* += 1;
325		}
326
327		pub fn writeUuidLC(uuid: const [16]u8, ncmds: u32, lc_writer: anytype) !void {
328		var uuid_lc = macho.uuid_command{
329		.cmdsize = @sizeOf(macho.uuid_command),
330		.uuid = uuid.*,
331		};
332		try lc_writer.writeStruct(uuid_lc);
333		ncmds.* += 1;
334		}

src/link/MachO/zld.zig+105-160

...	...	@@ -38,6 +38,14 @@ pub const Zld = struct {
38	38	page_size: u16,
39	39	options: *const link.Options,
40	40
	41	dyld_info_cmd: macho.dyld_info_command = .{},
	42	symtab_cmd: macho.symtab_command = .{},
	43	dysymtab_cmd: macho.dysymtab_command = .{},
	44	function_starts_cmd: macho.linkedit_data_command = .{ .cmd = .FUNCTION_STARTS },
	45	data_in_code_cmd: macho.linkedit_data_command = .{ .cmd = .DATA_IN_CODE },
	46	uuid_cmd: macho.uuid_command = .{},
	47	codesig_cmd: macho.linkedit_data_command = .{ .cmd = .CODE_SIGNATURE },
	48
41	49	objects: std.ArrayListUnmanaged(Object) = .{},
42	50	archives: std.ArrayListUnmanaged(Archive) = .{},
43	51	dylibs: std.ArrayListUnmanaged(Dylib) = .{},
...	...	@@ -1728,7 +1736,7 @@ pub const Zld = struct {
1728	1736	return (@intCast(u8, segment_precedence) << 4) + section_precedence;
1729	1737	}
1730	1738
1731		fn writeSegmentHeaders(self: Zld, ncmds: u32, writer: anytype) !void {
	1739	fn writeSegmentHeaders(self: *Zld, writer: anytype) !void {
1732	1740	for (self.segments.items) \|seg, i\| {
1733	1741	const indexes = self.getSectionIndexes(@intCast(u8, i));
1734	1742	var out_seg = seg;
...	...	@@ -1752,16 +1760,14 @@ pub const Zld = struct {
1752	1760	if (header.size == 0) continue;
1753	1761	try writer.writeStruct(header);
1754	1762	}
1755
1756		ncmds.* += 1;
1757	1763	}
1758	1764	}
1759	1765
1760		fn writeLinkeditSegmentData(self: Zld, ncmds: u32, lc_writer: anytype, reverse_lookups: [][]u32) !void {
1761		try self.writeDyldInfoData(ncmds, lc_writer, reverse_lookups);
1762		try self.writeFunctionStarts(ncmds, lc_writer);
1763		try self.writeDataInCode(ncmds, lc_writer);
1764		try self.writeSymtabs(ncmds, lc_writer);
	1766	fn writeLinkeditSegmentData(self: *Zld, reverse_lookups: [][]u32) !void {
	1767	try self.writeDyldInfoData(reverse_lookups);
	1768	try self.writeFunctionStarts();
	1769	try self.writeDataInCode();
	1770	try self.writeSymtabs();
1765	1771
1766	1772	const seg = self.getLinkeditSegmentPtr();
1767	1773	seg.vmsize = mem.alignForwardGeneric(u64, seg.filesize, self.page_size);
...	...	@@ -2150,7 +2156,7 @@ pub const Zld = struct {
2150	2156	try trie.finalize(gpa);
2151	2157	}
2152	2158
2153		fn writeDyldInfoData(self: Zld, ncmds: u32, lc_writer: anytype, reverse_lookups: [][]u32) !void {
	2159	fn writeDyldInfoData(self: *Zld, reverse_lookups: [][]u32) !void {
2154	2160	const gpa = self.gpa;
2155	2161
2156	2162	var rebase_pointers = std.ArrayList(bind.Pointer).init(gpa);
...	...	@@ -2219,21 +2225,14 @@ pub const Zld = struct {
2219	2225	const size = math.cast(usize, lazy_bind_size) orelse return error.Overflow;
2220	2226	try self.populateLazyBindOffsetsInStubHelper(buffer[offset..][0..size]);
2221	2227
2222		try lc_writer.writeStruct(macho.dyld_info_command{
2223		.cmd = .DYLD_INFO_ONLY,
2224		.cmdsize = @sizeOf(macho.dyld_info_command),
2225		.rebase_off = @intCast(u32, rebase_off),
2226		.rebase_size = @intCast(u32, rebase_size),
2227		.bind_off = @intCast(u32, bind_off),
2228		.bind_size = @intCast(u32, bind_size),
2229		.weak_bind_off = 0,
2230		.weak_bind_size = 0,
2231		.lazy_bind_off = @intCast(u32, lazy_bind_off),
2232		.lazy_bind_size = @intCast(u32, lazy_bind_size),
2233		.export_off = @intCast(u32, export_off),
2234		.export_size = @intCast(u32, export_size),
2235		});
2236		ncmds.* += 1;
	2228	self.dyld_info_cmd.rebase_off = @intCast(u32, rebase_off);
	2229	self.dyld_info_cmd.rebase_size = @intCast(u32, rebase_size);
	2230	self.dyld_info_cmd.bind_off = @intCast(u32, bind_off);
	2231	self.dyld_info_cmd.bind_size = @intCast(u32, bind_size);
	2232	self.dyld_info_cmd.lazy_bind_off = @intCast(u32, lazy_bind_off);
	2233	self.dyld_info_cmd.lazy_bind_size = @intCast(u32, lazy_bind_size);
	2234	self.dyld_info_cmd.export_off = @intCast(u32, export_off);
	2235	self.dyld_info_cmd.export_size = @intCast(u32, export_size);
2237	2236	}
2238	2237
2239	2238	fn populateLazyBindOffsetsInStubHelper(self: *Zld, buffer: []const u8) !void {
...	...	@@ -2351,7 +2350,7 @@ pub const Zld = struct {
2351	2350
2352	2351	const asc_u64 = std.sort.asc(u64);
2353	2352
2354		fn writeFunctionStarts(self: Zld, ncmds: u32, lc_writer: anytype) !void {
	2353	fn writeFunctionStarts(self: *Zld) !void {
2355	2354	const text_seg_index = self.getSegmentByName("__TEXT") orelse return;
2356	2355	const text_sect_index = self.getSectionByName("__TEXT", "__text") orelse return;
2357	2356	const text_seg = self.segments.items[text_seg_index];
...	...	@@ -2410,13 +2409,8 @@ pub const Zld = struct {
2410	2409
2411	2410	try self.file.pwriteAll(buffer.items, offset);
2412	2411
2413		try lc_writer.writeStruct(macho.linkedit_data_command{
2414		.cmd = .FUNCTION_STARTS,
2415		.cmdsize = @sizeOf(macho.linkedit_data_command),
2416		.dataoff = @intCast(u32, offset),
2417		.datasize = @intCast(u32, needed_size),
2418		});
2419		ncmds.* += 1;
	2412	self.function_starts_cmd.dataoff = @intCast(u32, offset);
	2413	self.function_starts_cmd.datasize = @intCast(u32, needed_size);
2420	2414	}
2421	2415
2422	2416	fn filterDataInCode(
...	...	@@ -2438,7 +2432,7 @@ pub const Zld = struct {
2438	2432	return dices[start..end];
2439	2433	}
2440	2434
2441		fn writeDataInCode(self: Zld, ncmds: u32, lc_writer: anytype) !void {
	2435	fn writeDataInCode(self: *Zld) !void {
2442	2436	var out_dice = std.ArrayList(macho.data_in_code_entry).init(self.gpa);
2443	2437	defer out_dice.deinit();
2444	2438
...	...	@@ -2488,54 +2482,19 @@ pub const Zld = struct {
2488	2482	log.debug("writing data-in-code from 0x{x} to 0x{x}", .{ offset, offset + needed_size });
2489	2483
2490	2484	try self.file.pwriteAll(mem.sliceAsBytes(out_dice.items), offset);
2491		try lc_writer.writeStruct(macho.linkedit_data_command{
2492		.cmd = .DATA_IN_CODE,
2493		.cmdsize = @sizeOf(macho.linkedit_data_command),
2494		.dataoff = @intCast(u32, offset),
2495		.datasize = @intCast(u32, needed_size),
2496		});
2497		ncmds.* += 1;
	2485
	2486	self.data_in_code_cmd.dataoff = @intCast(u32, offset);
	2487	self.data_in_code_cmd.datasize = @intCast(u32, needed_size);
2498	2488	}
2499	2489
2500		fn writeSymtabs(self: Zld, ncmds: u32, lc_writer: anytype) !void {
2501		var symtab_cmd = macho.symtab_command{
2502		.cmdsize = @sizeOf(macho.symtab_command),
2503		.symoff = 0,
2504		.nsyms = 0,
2505		.stroff = 0,
2506		.strsize = 0,
2507		};
2508		var dysymtab_cmd = macho.dysymtab_command{
2509		.cmdsize = @sizeOf(macho.dysymtab_command),
2510		.ilocalsym = 0,
2511		.nlocalsym = 0,
2512		.iextdefsym = 0,
2513		.nextdefsym = 0,
2514		.iundefsym = 0,
2515		.nundefsym = 0,
2516		.tocoff = 0,
2517		.ntoc = 0,
2518		.modtaboff = 0,
2519		.nmodtab = 0,
2520		.extrefsymoff = 0,
2521		.nextrefsyms = 0,
2522		.indirectsymoff = 0,
2523		.nindirectsyms = 0,
2524		.extreloff = 0,
2525		.nextrel = 0,
2526		.locreloff = 0,
2527		.nlocrel = 0,
2528		};
2529		var ctx = try self.writeSymtab(&symtab_cmd);
	2490	fn writeSymtabs(self: *Zld) !void {
	2491	var ctx = try self.writeSymtab();
2530	2492	defer ctx.imports_table.deinit();
2531		try self.writeDysymtab(ctx, &dysymtab_cmd);
2532		try self.writeStrtab(&symtab_cmd);
2533		try lc_writer.writeStruct(symtab_cmd);
2534		try lc_writer.writeStruct(dysymtab_cmd);
2535		ncmds.* += 2;
	2493	try self.writeDysymtab(ctx);
	2494	try self.writeStrtab();
2536	2495	}
2537	2496
2538		fn writeSymtab(self: Zld, lc: macho.symtab_command) !SymtabCtx {
	2497	fn writeSymtab(self: *Zld) !SymtabCtx {
2539	2498	const gpa = self.gpa;
2540	2499
2541	2500	var locals = std.ArrayList(macho.nlist_64).init(gpa);
...	...	@@ -2618,8 +2577,8 @@ pub const Zld = struct {
2618	2577	log.debug("writing symtab from 0x{x} to 0x{x}", .{ offset, offset + needed_size });
2619	2578	try self.file.pwriteAll(buffer.items, offset);
2620	2579
2621		lc.symoff = @intCast(u32, offset);
2622		lc.nsyms = nsyms;
	2580	self.symtab_cmd.symoff = @intCast(u32, offset);
	2581	self.symtab_cmd.nsyms = nsyms;
2623	2582
2624	2583	return SymtabCtx{
2625	2584	.nlocalsym = nlocals,
...	...	@@ -2629,7 +2588,7 @@ pub const Zld = struct {
2629	2588	};
2630	2589	}
2631	2590
2632		fn writeStrtab(self: Zld, lc: macho.symtab_command) !void {
	2591	fn writeStrtab(self: *Zld) !void {
2633	2592	const seg = self.getLinkeditSegmentPtr();
2634	2593	const offset = mem.alignForwardGeneric(u64, seg.fileoff + seg.filesize, @alignOf(u64));
2635	2594	const needed_size = self.strtab.buffer.items.len;
...	...	@@ -2639,8 +2598,8 @@ pub const Zld = struct {
2639	2598
2640	2599	try self.file.pwriteAll(self.strtab.buffer.items, offset);
2641	2600
2642		lc.stroff = @intCast(u32, offset);
2643		lc.strsize = @intCast(u32, needed_size);
	2601	self.symtab_cmd.stroff = @intCast(u32, offset);
	2602	self.symtab_cmd.strsize = @intCast(u32, needed_size);
2644	2603	}
2645	2604
2646	2605	const SymtabCtx = struct {
...	...	@@ -2650,7 +2609,7 @@ pub const Zld = struct {
2650	2609	imports_table: std.AutoHashMap(SymbolWithLoc, u32),
2651	2610	};
2652	2611
2653		fn writeDysymtab(self: Zld, ctx: SymtabCtx, lc: macho.dysymtab_command) !void {
	2612	fn writeDysymtab(self: *Zld, ctx: SymtabCtx) !void {
2654	2613	const gpa = self.gpa;
2655	2614	const nstubs = @intCast(u32, self.stubs.items.len);
2656	2615	const ngot_entries = @intCast(u32, self.got_entries.items.len);
...	...	@@ -2706,21 +2665,33 @@ pub const Zld = struct {
2706	2665	assert(buf.items.len == needed_size);
2707	2666	try self.file.pwriteAll(buf.items, offset);
2708	2667
2709		lc.nlocalsym = ctx.nlocalsym;
2710		lc.iextdefsym = iextdefsym;
2711		lc.nextdefsym = ctx.nextdefsym;
2712		lc.iundefsym = iundefsym;
2713		lc.nundefsym = ctx.nundefsym;
2714		lc.indirectsymoff = @intCast(u32, offset);
2715		lc.nindirectsyms = nindirectsyms;
	2668	self.dysymtab_cmd.nlocalsym = ctx.nlocalsym;
	2669	self.dysymtab_cmd.iextdefsym = iextdefsym;
	2670	self.dysymtab_cmd.nextdefsym = ctx.nextdefsym;
	2671	self.dysymtab_cmd.iundefsym = iundefsym;
	2672	self.dysymtab_cmd.nundefsym = ctx.nundefsym;
	2673	self.dysymtab_cmd.indirectsymoff = @intCast(u32, offset);
	2674	self.dysymtab_cmd.nindirectsyms = nindirectsyms;
2716	2675	}
2717	2676
2718		fn writeCodeSignaturePadding(
2719		self: *Zld,
2720		code_sig: *CodeSignature,
2721		ncmds: *u32,
2722		lc_writer: anytype,
2723		) !u32 {
	2677	fn writeUuid(self: Zld, comp: const Compilation, offset: u32) !void {
	2678	switch (self.options.optimize_mode) {
	2679	.Debug => {
	2680	// In Debug we don't really care about reproducibility, so put in a random value
	2681	// and be done with it.
	2682	std.crypto.random.bytes(&self.uuid_cmd.uuid);
	2683	},
	2684	else => {
	2685	const seg = self.getLinkeditSegmentPtr();
	2686	const file_size = seg.fileoff + seg.filesize;
	2687	try uuid.calcUuidParallel(comp, self.file, file_size, &self.uuid_cmd.uuid);
	2688	},
	2689	}
	2690	const in_file = @sizeOf(macho.mach_header_64) + offset + @sizeOf(macho.load_command);
	2691	try self.file.pwriteAll(&self.uuid_cmd.uuid, in_file);
	2692	}
	2693
	2694	fn writeCodeSignaturePadding(self: Zld, code_sig: CodeSignature) !void {
2724	2695	const seg = self.getLinkeditSegmentPtr();
2725	2696	// Code signature data has to be 16-bytes aligned for Apple tools to recognize the file
2726	2697	// https://github.com/opensource-apple/cctools/blob/fdb4825f303fd5c0751be524babd32958181b3ed/libstuff/checkout.c#L271
...	...	@@ -2733,23 +2704,11 @@ pub const Zld = struct {
2733	2704	// except for code signature data.
2734	2705	try self.file.pwriteAll(&[_]u8{0}, offset + needed_size - 1);
2735	2706
2736		try lc_writer.writeStruct(macho.linkedit_data_command{
2737		.cmd = .CODE_SIGNATURE,
2738		.cmdsize = @sizeOf(macho.linkedit_data_command),
2739		.dataoff = @intCast(u32, offset),
2740		.datasize = @intCast(u32, needed_size),
2741		});
2742		ncmds.* += 1;
2743
2744		return @intCast(u32, offset);
	2707	self.codesig_cmd.dataoff = @intCast(u32, offset);
	2708	self.codesig_cmd.datasize = @intCast(u32, needed_size);
2745	2709	}
2746	2710
2747		fn writeCodeSignature(
2748		self: *Zld,
2749		comp: *const Compilation,
2750		code_sig: *CodeSignature,
2751		offset: u32,
2752		) !void {
	2711	fn writeCodeSignature(self: Zld, comp: const Compilation, code_sig: *CodeSignature) !void {
2753	2712	const seg_id = self.getSegmentByName("__TEXT").?;
2754	2713	const seg = self.segments.items[seg_id];
2755	2714
...	...	@@ -2760,17 +2719,17 @@ pub const Zld = struct {
2760	2719	.file = self.file,
2761	2720	.exec_seg_base = seg.fileoff,
2762	2721	.exec_seg_limit = seg.filesize,
2763		.file_size = offset,
	2722	.file_size = self.codesig_cmd.dataoff,
2764	2723	.output_mode = self.options.output_mode,
2765	2724	}, buffer.writer());
2766	2725	assert(buffer.items.len == code_sig.size());
2767	2726
2768	2727	log.debug("writing code signature from 0x{x} to 0x{x}", .{
2769		offset,
2770		offset + buffer.items.len,
	2728	self.codesig_cmd.dataoff,
	2729	self.codesig_cmd.dataoff + buffer.items.len,
2771	2730	});
2772	2731
2773		try self.file.pwriteAll(buffer.items, offset);
	2732	try self.file.pwriteAll(buffer.items, self.codesig_cmd.dataoff);
2774	2733	}
2775	2734
2776	2735	/// Writes Mach-O file header.
...	...	@@ -3986,13 +3945,7 @@ pub fn linkWithZld(macho_file: MachO, comp: Compilation, prog_node: *std.Progr
3986	3945	}
3987	3946
3988	3947	try zld.writeAtoms(reverse_lookups);
3989
3990		var lc_buffer = std.ArrayList(u8).init(arena);
3991		const lc_writer = lc_buffer.writer();
3992
3993		var ncmds: u32 = 0;
3994
3995		try zld.writeLinkeditSegmentData(&ncmds, lc_writer, reverse_lookups);
	3948	try zld.writeLinkeditSegmentData(reverse_lookups);
3996	3949
3997	3950	// If the last section of __DATA segment is zerofill section, we need to ensure
3998	3951	// that the free space between the end of the last non-zerofill section of __DATA
...	...	@@ -4017,47 +3970,48 @@ pub fn linkWithZld(macho_file: MachO, comp: Compilation, prog_node: *std.Progr
4017	3970	}
4018	3971	}
4019	3972
4020		try load_commands.writeDylinkerLC(&ncmds, lc_writer);
	3973	// Write load commands
	3974	var lc_buffer = std.ArrayList(u8).init(arena);
	3975	const lc_writer = lc_buffer.writer();
	3976
	3977	try zld.writeSegmentHeaders(lc_writer);
	3978	try lc_writer.writeStruct(zld.dyld_info_cmd);
	3979	try lc_writer.writeStruct(zld.function_starts_cmd);
	3980	try lc_writer.writeStruct(zld.data_in_code_cmd);
	3981	try lc_writer.writeStruct(zld.symtab_cmd);
	3982	try lc_writer.writeStruct(zld.dysymtab_cmd);
	3983	try load_commands.writeDylinkerLC(lc_writer);
4021	3984
4022	3985	if (zld.options.output_mode == .Exe) {
4023	3986	const seg_id = zld.getSegmentByName("__TEXT").?;
4024	3987	const seg = zld.segments.items[seg_id];
4025	3988	const global = zld.getEntryPoint();
4026	3989	const sym = zld.getSymbol(global);
4027		try load_commands.writeMainLC(@intCast(u32, sym.n_value - seg.vmaddr), options, &ncmds, lc_writer);
	3990	try lc_writer.writeStruct(macho.entry_point_command{
	3991	.entryoff = @intCast(u32, sym.n_value - seg.vmaddr),
	3992	.stacksize = options.stack_size_override orelse 0,
	3993	});
4028	3994	} else {
4029	3995	assert(zld.options.output_mode == .Lib);
4030		try load_commands.writeDylibIdLC(zld.gpa, zld.options, &ncmds, lc_writer);
	3996	try load_commands.writeDylibIdLC(zld.gpa, zld.options, lc_writer);
4031	3997	}
4032	3998
4033		try load_commands.writeRpathLCs(zld.gpa, zld.options, &ncmds, lc_writer);
4034		try load_commands.writeSourceVersionLC(&ncmds, lc_writer);
4035		try load_commands.writeBuildVersionLC(zld.options, &ncmds, lc_writer);
4036
4037		// Looking forward into the future, we will want to offer `-no_uuid` support in which case
4038		// there will be nothing to backpatch.
4039		const uuid_offset_backpatch: ?usize = blk: {
4040		const index = lc_buffer.items.len;
4041		var uuid_buf: [16]u8 = [_]u8{0} ** 16;
4042
4043		if (zld.options.optimize_mode == .Debug) {
4044		// In Debug we don't really care about reproducibility, so put in a random value
4045		// and be done with it.
4046		std.crypto.random.bytes(&uuid_buf);
4047		}
	3999	try load_commands.writeRpathLCs(zld.gpa, zld.options, lc_writer);
	4000	try lc_writer.writeStruct(macho.source_version_command{
	4001	.version = 0,
	4002	});
	4003	try load_commands.writeBuildVersionLC(zld.options, lc_writer);
4048	4004
4049		try load_commands.writeUuidLC(&uuid_buf, &ncmds, lc_writer);
4050		break :blk if (zld.options.optimize_mode == .Debug) null else index;
4051		};
	4005	const uuid_offset = @intCast(u32, lc_buffer.items.len);
	4006	try lc_writer.writeStruct(zld.uuid_cmd);
4052	4007
4053		try load_commands.writeLoadDylibLCs(zld.dylibs.items, zld.referenced_dylibs.keys(), &ncmds, lc_writer);
	4008	try load_commands.writeLoadDylibLCs(zld.dylibs.items, zld.referenced_dylibs.keys(), lc_writer);
4054	4009
4055	4010	const requires_codesig = blk: {
4056	4011	if (options.entitlements) \|_\| break :blk true;
4057	4012	if (cpu_arch == .aarch64 and (os_tag == .macos or abi == .simulator)) break :blk true;
4058	4013	break :blk false;
4059	4014	};
4060		var codesig_offset: ?u32 = null;
4061	4015	var codesig: ?CodeSignature = if (requires_codesig) blk: {
4062	4016	// Preallocate space for the code signature.
4063	4017	// We need to do this at this stage so that we have the load commands with proper values
...	...	@@ -4069,29 +4023,20 @@ pub fn linkWithZld(macho_file: MachO, comp: Compilation, prog_node: *std.Progr
4069	4023	if (options.entitlements) \|path\| {
4070	4024	try codesig.addEntitlements(gpa, path);
4071	4025	}
4072		codesig_offset = try zld.writeCodeSignaturePadding(&codesig, &ncmds, lc_writer);
	4026	try zld.writeCodeSignaturePadding(&codesig);
	4027	try lc_writer.writeStruct(zld.codesig_cmd);
4073	4028	break :blk codesig;
4074	4029	} else null;
4075	4030	defer if (codesig) \|*csig\| csig.deinit(gpa);
4076	4031
4077		var headers_buf = std.ArrayList(u8).init(arena);
4078		try zld.writeSegmentHeaders(&ncmds, headers_buf.writer());
	4032	const ncmds = load_commands.calcNumOfLCs(lc_buffer.items);
	4033	try zld.file.pwriteAll(lc_buffer.items, @sizeOf(macho.mach_header_64));
	4034	try zld.writeHeader(ncmds, @intCast(u32, lc_buffer.items.len));
4079	4035
4080		try zld.file.pwriteAll(headers_buf.items, @sizeOf(macho.mach_header_64));
4081		try zld.file.pwriteAll(lc_buffer.items, @sizeOf(macho.mach_header_64) + headers_buf.items.len);
4082		try zld.writeHeader(ncmds, @intCast(u32, lc_buffer.items.len + headers_buf.items.len));
4083
4084		if (uuid_offset_backpatch) \|backpatch\| {
4085		const seg = zld.getLinkeditSegmentPtr();
4086		const file_size = seg.fileoff + seg.filesize;
4087		var uuid_buf: [16]u8 = undefined;
4088		try uuid.calcUuidParallel(comp, zld.file, file_size, &uuid_buf);
4089		const offset = @sizeOf(macho.mach_header_64) + headers_buf.items.len + backpatch + @sizeOf(macho.load_command);
4090		try zld.file.pwriteAll(&uuid_buf, offset);
4091		}
	4036	try zld.writeUuid(comp, uuid_offset);
4092	4037
4093	4038	if (codesig) \|*csig\| {
4094		try zld.writeCodeSignature(comp, csig, codesig_offset.?); // code signing always comes last
	4039	try zld.writeCodeSignature(comp, csig); // code signing always comes last
4095	4040	}
4096	4041	}
4097	4042