1 files changed, 28 insertions, 50 deletions

diff --git a/src/link/MachO/DebugSymbols.zig b/src/link/MachO/DebugSymbols.zig
index 22905a520a..a13ad9c9f4 100644
--- a/src/link/MachO/DebugSymbols.zig
+++ b/src/link/MachO/DebugSymbols.zig
@@ -26,6 +26,8 @@ dwarf: Dwarf,
 file: fs.File,
 page_size: u16,
 
+symtab_cmd: macho.symtab_command = .{},
+
 segments: std.ArrayListUnmanaged(macho.segment_command_64) = .{},
 sections: std.ArrayListUnmanaged(macho.section_64) = .{},
 
@@ -296,28 +298,21 @@ pub fn flushModule(self: *DebugSymbols, macho_file: *MachO) !void {
         }
     }
 
+    self.finalizeDwarfSegment(macho_file);
+    try self.writeLinkeditSegmentData(macho_file);
+
+    // Write load commands
     var lc_buffer = std.ArrayList(u8).init(self.allocator);
     defer lc_buffer.deinit();
     const lc_writer = lc_buffer.writer();
-    var ncmds: u32 = 0;
-
-    self.finalizeDwarfSegment(macho_file);
-    try self.writeLinkeditSegmentData(macho_file, &ncmds, lc_writer);
 
-    try load_commands.writeUuidLC(&macho_file.uuid.buf, &ncmds, lc_writer);
+    try self.writeSegmentHeaders(macho_file, lc_writer);
+    try lc_writer.writeStruct(self.symtab_cmd);
+    try lc_writer.writeStruct(macho_file.uuid_cmd);
 
-    var headers_buf = std.ArrayList(u8).init(self.allocator);
-    defer headers_buf.deinit();
-    try self.writeSegmentHeaders(macho_file, &ncmds, headers_buf.writer());
-
-    try self.file.pwriteAll(headers_buf.items, @sizeOf(macho.mach_header_64));
-    try self.file.pwriteAll(lc_buffer.items, @sizeOf(macho.mach_header_64) + headers_buf.items.len);
-
-    try self.writeHeader(
-        macho_file,
-        ncmds,
-        @intCast(u32, lc_buffer.items.len + headers_buf.items.len),
-    );
+    const ncmds = load_commands.calcNumOfLCs(lc_buffer.items);
+    try self.file.pwriteAll(lc_buffer.items, @sizeOf(macho.mach_header_64));
+    try self.writeHeader(macho_file, ncmds, @intCast(u32, lc_buffer.items.len));
 
     assert(!self.debug_abbrev_section_dirty);
     assert(!self.debug_aranges_section_dirty);
@@ -384,7 +379,7 @@ fn finalizeDwarfSegment(self: *DebugSymbols, macho_file: *MachO) void {
     log.debug("found __LINKEDIT segment free space at 0x{x}", .{linkedit.fileoff});
 }
 
-fn writeSegmentHeaders(self: *DebugSymbols, macho_file: *MachO, ncmds: *u32, writer: anytype) !void {
+fn writeSegmentHeaders(self: *DebugSymbols, macho_file: *MachO, writer: anytype) !void {
     // Write segment/section headers from the binary file first.
     const end = macho_file.linkedit_segment_cmd_index.?;
     for (macho_file.segments.items[0..end]) |seg, i| {
@@ -414,8 +409,6 @@ fn writeSegmentHeaders(self: *DebugSymbols, macho_file: *MachO, ncmds: *u32, wri
             out_header.offset = 0;
             try writer.writeStruct(out_header);
         }
-
-        ncmds.* += 1;
     }
     // Next, commit DSYM's __LINKEDIT and __DWARF segments headers.
     for (self.segments.items) |seg, i| {
@@ -424,7 +417,6 @@ fn writeSegmentHeaders(self: *DebugSymbols, macho_file: *MachO, ncmds: *u32, wri
         for (self.sections.items[indexes.start..indexes.end]) |header| {
             try writer.writeStruct(header);
         }
-        ncmds.* += 1;
     }
 }
 
@@ -463,33 +455,19 @@ fn allocatedSize(self: *DebugSymbols, start: u64) u64 {
     return min_pos - start;
 }
 
-fn writeLinkeditSegmentData(
-    self: *DebugSymbols,
-    macho_file: *MachO,
-    ncmds: *u32,
-    lc_writer: anytype,
-) !void {
+fn writeLinkeditSegmentData(self: *DebugSymbols, macho_file: *MachO) !void {
     const tracy = trace(@src());
     defer tracy.end();
 
-    var symtab_cmd = macho.symtab_command{
-        .cmdsize = @sizeOf(macho.symtab_command),
-        .symoff = 0,
-        .nsyms = 0,
-        .stroff = 0,
-        .strsize = 0,
-    };
-    try self.writeSymtab(macho_file, &symtab_cmd);
-    try self.writeStrtab(&symtab_cmd);
-    try lc_writer.writeStruct(symtab_cmd);
-    ncmds.* += 1;
+    try self.writeSymtab(macho_file);
+    try self.writeStrtab();
 
     const seg = &self.segments.items[self.linkedit_segment_cmd_index.?];
     const aligned_size = mem.alignForwardGeneric(u64, seg.filesize, self.page_size);
     seg.vmsize = aligned_size;
 }
 
-fn writeSymtab(self: *DebugSymbols, macho_file: *MachO, lc: *macho.symtab_command) !void {
+fn writeSymtab(self: *DebugSymbols, macho_file: *MachO) !void {
     const tracy = trace(@src());
     defer tracy.end();
 
@@ -528,10 +506,10 @@ fn writeSymtab(self: *DebugSymbols, macho_file: *MachO, lc: *macho.symtab_comman
     const needed_size = nsyms * @sizeOf(macho.nlist_64);
     seg.filesize = offset + needed_size - seg.fileoff;
 
-    lc.symoff = @intCast(u32, offset);
-    lc.nsyms = @intCast(u32, nsyms);
+    self.symtab_cmd.symoff = @intCast(u32, offset);
+    self.symtab_cmd.nsyms = @intCast(u32, nsyms);
 
-    const locals_off = lc.symoff;
+    const locals_off = @intCast(u32, offset);
     const locals_size = nlocals * @sizeOf(macho.nlist_64);
     const exports_off = locals_off + locals_size;
     const exports_size = nexports * @sizeOf(macho.nlist_64);
@@ -543,26 +521,26 @@ fn writeSymtab(self: *DebugSymbols, macho_file: *MachO, lc: *macho.symtab_comman
     try self.file.pwriteAll(mem.sliceAsBytes(exports.items), exports_off);
 }
 
-fn writeStrtab(self: *DebugSymbols, lc: *macho.symtab_command) !void {
+fn writeStrtab(self: *DebugSymbols) !void {
     const tracy = trace(@src());
     defer tracy.end();
 
     const seg = &self.segments.items[self.linkedit_segment_cmd_index.?];
-    const symtab_size = @intCast(u32, lc.nsyms * @sizeOf(macho.nlist_64));
-    const offset = mem.alignForwardGeneric(u64, lc.symoff + symtab_size, @alignOf(u64));
+    const symtab_size = @intCast(u32, self.symtab_cmd.nsyms * @sizeOf(macho.nlist_64));
+    const offset = mem.alignForwardGeneric(u64, self.symtab_cmd.symoff + symtab_size, @alignOf(u64));
     const needed_size = mem.alignForwardGeneric(u64, self.strtab.buffer.items.len, @alignOf(u64));
 
     seg.filesize = offset + needed_size - seg.fileoff;
-    lc.stroff = @intCast(u32, offset);
-    lc.strsize = @intCast(u32, needed_size);
+    self.symtab_cmd.stroff = @intCast(u32, offset);
+    self.symtab_cmd.strsize = @intCast(u32, needed_size);
 
-    log.debug("writing string table from 0x{x} to 0x{x}", .{ lc.stroff, lc.stroff + lc.strsize });
+    log.debug("writing string table from 0x{x} to 0x{x}", .{ offset, offset + needed_size });
 
-    try self.file.pwriteAll(self.strtab.buffer.items, lc.stroff);
+    try self.file.pwriteAll(self.strtab.buffer.items, offset);
 
     if (self.strtab.buffer.items.len < needed_size) {
         // Ensure we are always padded to the actual length of the file.
-        try self.file.pwriteAll(&[_]u8{0}, lc.stroff + lc.strsize);
+        try self.file.pwriteAll(&[_]u8{0}, offset + needed_size);
     }
 }