Commit d12c8db6421f28ca59c03b619c70126c6694b0d4 | zig

author	Jakub Konka <kubkon@jakubkonka.com> 2024-02-09 23:12:04+01:00
committer	GitHub <noreply@github.com> 2024-02-09 23:12:04+01:00
log	d12c8db6421f28ca59c03b619c70126c6694b0d4
tree	803f5500302741169e17e9e5a72a90f28fdb403a
parent	6fb23542fe8503ba5c97bde950b1ebbe8f07f951
parent	83bbc39c1582077cb5385536a04b7bf8bbffbf26
signature	Signed by PGP key B5690EEEBB952194

Merge pull request #18875 from ziglang/macho-zo-dwarf

macho: emit DWARF for ZigObject relocatable

9 files changed, 541 insertions(+), 283 deletions(-)

ci
- x86_64-macos-release.sh
lib
- std
  - builtin.zig
src
- Compilation.zig
- link
test
- link
  - macho.zig

ci/x86_64-macos-release.sh+9

...	@@ -25,6 +25,15 @@ cd $ZIGDIR	...	@@ -25,6 +25,15 @@ cd $ZIGDIR
25	git fetch --unshallow \|\| true	25	git fetch --unshallow \|\| true
26	git fetch --tags	26	git fetch --tags
27		27
		28	# Test building from source without LLVM.
		29	git clean -fd
		30	rm -rf zig-out
		31	cc -o bootstrap bootstrap.c
		32	./bootstrap
		33	./zig2 build -Dno-lib
		34	# In order to run these behavior tests we need to move the `@cImport` ones to somewhere else.
		35	# ./zig-out/bin/zig test test/behavior.zig
		36
28	rm -rf build	37	rm -rf build
29	mkdir build	38	mkdir build
30	cd build	39	cd build

lib/std/builtin.zig+1-1

...	@@ -764,7 +764,7 @@ pub fn default_panic(msg: []const u8, error_return_trace: ?*StackTrace, ret_addr	...	@@ -764,7 +764,7 @@ pub fn default_panic(msg: []const u8, error_return_trace: ?*StackTrace, ret_addr
764	builtin.zig_backend == .stage2_arm or	764	builtin.zig_backend == .stage2_arm or
765	builtin.zig_backend == .stage2_aarch64 or	765	builtin.zig_backend == .stage2_aarch64 or
766	builtin.zig_backend == .stage2_x86 or	766	builtin.zig_backend == .stage2_x86 or
767	(builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) or	767	(builtin.zig_backend == .stage2_x86_64 and (builtin.target.ofmt != .elf and builtin.target.ofmt != .macho)) or
768	builtin.zig_backend == .stage2_riscv64 or	768	builtin.zig_backend == .stage2_riscv64 or
769	builtin.zig_backend == .stage2_sparc64 or	769	builtin.zig_backend == .stage2_sparc64 or
770	builtin.zig_backend == .stage2_spirv64)	770	builtin.zig_backend == .stage2_spirv64)

src/Compilation.zig+2-2

...	@@ -6278,7 +6278,7 @@ fn canBuildLibCompilerRt(target: std.Target, use_llvm: bool) bool {	...	@@ -6278,7 +6278,7 @@ fn canBuildLibCompilerRt(target: std.Target, use_llvm: bool) bool {
6278	}	6278	}
6279	return switch (target_util.zigBackend(target, use_llvm)) {	6279	return switch (target_util.zigBackend(target, use_llvm)) {
6280	.stage2_llvm => true,	6280	.stage2_llvm => true,
6281	.stage2_x86_64 => if (target.ofmt == .elf) true else build_options.have_llvm,	6281	.stage2_x86_64 => if (target.ofmt == .elf or target.ofmt == .macho) true else build_options.have_llvm,
6282	else => build_options.have_llvm,	6282	else => build_options.have_llvm,
6283	};	6283	};
6284	}	6284	}
...	@@ -6296,7 +6296,7 @@ fn canBuildZigLibC(target: std.Target, use_llvm: bool) bool {	...	@@ -6296,7 +6296,7 @@ fn canBuildZigLibC(target: std.Target, use_llvm: bool) bool {
6296	}	6296	}
6297	return switch (target_util.zigBackend(target, use_llvm)) {	6297	return switch (target_util.zigBackend(target, use_llvm)) {
6298	.stage2_llvm => true,	6298	.stage2_llvm => true,
6299	.stage2_x86_64 => if (target.ofmt == .elf) true else build_options.have_llvm,	6299	.stage2_x86_64 => if (target.ofmt == .elf or target.ofmt == .macho) true else build_options.have_llvm,
6300	else => build_options.have_llvm,	6300	else => build_options.have_llvm,
6301	};	6301	};
6302	}	6302	}

src/link/Dwarf.zig+200-82

 @@ -1282,10 +1282,17 @@ pub fn commitDeclState(
                                 try pwriteDbgLineNops(elf_file.base.file.?, file_pos, 0, &[0]u8{}, src_fn.len);
                             },
                             .macho => {
-                                const d_sym = self.bin_file.cast(File.MachO).?.getDebugSymbols().?;
+                                const macho_file = self.bin_file.cast(File.MachO).?;
-                                const debug_line_sect = d_sym.getSectionPtr(d_sym.debug_line_section_index.?);
+                                if (macho_file.base.isRelocatable()) {
-                                const file_pos = debug_line_sect.offset + src_fn.off;
+                                    const debug_line_sect = &macho_file.sections.items(.header)[macho_file.debug_line_sect_index.?];
-                                try pwriteDbgLineNops(d_sym.file, file_pos, 0, &[0]u8{}, src_fn.len);
+                                    const file_pos = debug_line_sect.offset + src_fn.off;
+                                    try pwriteDbgLineNops(macho_file.base.file.?, file_pos, 0, &[0]u8{}, src_fn.len);
+                                } else {
+                                    const d_sym = macho_file.getDebugSymbols().?;
+                                    const debug_line_sect = d_sym.getSectionPtr(d_sym.debug_line_section_index.?);
+                                    const file_pos = debug_line_sect.offset + src_fn.off;
+                                    try pwriteDbgLineNops(d_sym.file, file_pos, 0, &[0]u8{}, src_fn.len);
+                                }
                             },
                             .wasm => {
                                 const wasm_file = self.bin_file.cast(File.Wasm).?;
 @@ -1351,18 +1358,33 @@ pub fn commitDeclState(
                 },
                 .macho => {
-                    const d_sym = self.bin_file.cast(File.MachO).?.getDebugSymbols().?;
+                    const macho_file = self.bin_file.cast(File.MachO).?;
-                    const sect_index = d_sym.debug_line_section_index.?;
+                    if (macho_file.base.isRelocatable()) {
-                    try d_sym.growSection(sect_index, needed_size, true);
+                        const sect_index = macho_file.debug_line_sect_index.?;
-                    const sect = d_sym.getSection(sect_index);
+                        try macho_file.growSection(sect_index, needed_size);
-                    const file_pos = sect.offset + src_fn.off;
+                        const sect = macho_file.sections.items(.header)[sect_index];
-                    try pwriteDbgLineNops(
+                        const file_pos = sect.offset + src_fn.off;
-                        d_sym.file,
+                        try pwriteDbgLineNops(
-                        file_pos,
+                            macho_file.base.file.?,
-                        prev_padding_size,
+                            file_pos,
-                        dbg_line_buffer.items,
+                            prev_padding_size,
-                        next_padding_size,
+                            dbg_line_buffer.items,
-                    );
+                            next_padding_size,
+                        );
+                    } else {
+                        const d_sym = macho_file.getDebugSymbols().?;
+                        const sect_index = d_sym.debug_line_section_index.?;
+                        try d_sym.growSection(sect_index, needed_size, true, macho_file);
+                        const sect = d_sym.getSection(sect_index);
+                        const file_pos = sect.offset + src_fn.off;
+                        try pwriteDbgLineNops(
+                            d_sym.file,
+                            file_pos,
+                            prev_padding_size,
+                            dbg_line_buffer.items,
+                            next_padding_size,
+                        );
+                    }
                 },
                 .wasm => {
 @@ -1459,16 +1481,21 @@ pub fn commitDeclState(
     while (decl_state.exprloc_relocs.popOrNull()) |reloc| {
         switch (self.bin_file.tag) {
             .macho => {
-                const d_sym = self.bin_file.cast(File.MachO).?.getDebugSymbols().?;
+                const macho_file = self.bin_file.cast(File.MachO).?;
-                try d_sym.relocs.append(d_sym.allocator, .{
+                if (macho_file.base.isRelocatable()) {
-                    .type = switch (reloc.type) {
+                    // TODO
-                        .direct_load => .direct_load,
+                } else {
-                        .got_load => .got_load,
+                    const d_sym = macho_file.getDebugSymbols().?;
-                    },
+                    try d_sym.relocs.append(d_sym.allocator, .{
-                    .target = reloc.target,
+                        .type = switch (reloc.type) {
-                    .offset = reloc.offset + self.getAtom(.di_atom, di_atom_index).off,
+                            .direct_load => .direct_load,
-                    .addend = 0,
+                            .got_load => .got_load,
-                });
+                        },
+                        .target = reloc.target,
+                        .offset = reloc.offset + self.getAtom(.di_atom, di_atom_index).off,
+                        .addend = 0,
+                    });
+                }
             },
             .elf => {}, // TODO
             else => unreachable,
 @@ -1511,10 +1538,17 @@ fn updateDeclDebugInfoAllocation(self: *Dwarf, atom_index: Atom.Index, len: u32)
                         try pwriteDbgInfoNops(elf_file.base.file.?, file_pos, 0, &[0]u8{}, atom.len, false);
                     },
                     .macho => {
-                        const d_sym = self.bin_file.cast(File.MachO).?.getDebugSymbols().?;
+                        const macho_file = self.bin_file.cast(File.MachO).?;
-                        const debug_info_sect = d_sym.getSectionPtr(d_sym.debug_info_section_index.?);
+                        if (macho_file.base.isRelocatable()) {
-                        const file_pos = debug_info_sect.offset + atom.off;
+                            const debug_info_sect = macho_file.sections.items(.header)[macho_file.debug_info_sect_index.?];
-                        try pwriteDbgInfoNops(d_sym.file, file_pos, 0, &[0]u8{}, atom.len, false);
+                            const file_pos = debug_info_sect.offset + atom.off;
+                            try pwriteDbgInfoNops(macho_file.base.file.?, file_pos, 0, &[0]u8{}, atom.len, false);
+                        } else {
+                            const d_sym = macho_file.getDebugSymbols().?;
+                            const debug_info_sect = d_sym.getSectionPtr(d_sym.debug_info_section_index.?);
+                            const file_pos = debug_info_sect.offset + atom.off;
+                            try pwriteDbgInfoNops(d_sym.file, file_pos, 0, &[0]u8{}, atom.len, false);
+                        }
                     },
                     .wasm => {
                         const wasm_file = self.bin_file.cast(File.Wasm).?;
 @@ -1597,19 +1631,35 @@ fn writeDeclDebugInfo(self: *Dwarf, atom_index: Atom.Index, dbg_info_buf: []cons
         },
         .macho => {
-            const d_sym = self.bin_file.cast(File.MachO).?.getDebugSymbols().?;
+            const macho_file = self.bin_file.cast(File.MachO).?;
-            const sect_index = d_sym.debug_info_section_index.?;
+            if (macho_file.base.isRelocatable()) {
-            try d_sym.growSection(sect_index, needed_size, true);
+                const sect_index = macho_file.debug_info_sect_index.?;
-            const sect = d_sym.getSection(sect_index);
+                try macho_file.growSection(sect_index, needed_size);
-            const file_pos = sect.offset + atom.off;
+                const sect = macho_file.sections.items(.header)[sect_index];
-            try pwriteDbgInfoNops(
+                const file_pos = sect.offset + atom.off;
-                d_sym.file,
+                try pwriteDbgInfoNops(
-                file_pos,
+                    macho_file.base.file.?,
-                prev_padding_size,
+                    file_pos,
-                dbg_info_buf,
+                    prev_padding_size,
-                next_padding_size,
+                    dbg_info_buf,
-                trailing_zero,
+                    next_padding_size,
-            );
+                    trailing_zero,
+                );
+            } else {
+                const d_sym = macho_file.getDebugSymbols().?;
+                const sect_index = d_sym.debug_info_section_index.?;
+                try d_sym.growSection(sect_index, needed_size, true, macho_file);
+                const sect = d_sym.getSection(sect_index);
+                const file_pos = sect.offset + atom.off;
+                try pwriteDbgInfoNops(
+                    d_sym.file,
+                    file_pos,
+                    prev_padding_size,
+                    dbg_info_buf,
+                    next_padding_size,
+                    trailing_zero,
+                );
+            }
         },
         .wasm => {
 @@ -1670,10 +1720,17 @@ pub fn updateDeclLineNumber(self: *Dwarf, mod: *Module, decl_index: InternPool.D
             try elf_file.base.file.?.pwriteAll(&data, file_pos);
         },
         .macho => {
-            const d_sym = self.bin_file.cast(File.MachO).?.getDebugSymbols().?;
+            const macho_file = self.bin_file.cast(File.MachO).?;
-            const sect = d_sym.getSection(d_sym.debug_line_section_index.?);
+            if (macho_file.base.isRelocatable()) {
-            const file_pos = sect.offset + atom.off + self.getRelocDbgLineOff();
+                const sect = macho_file.sections.items(.header)[macho_file.debug_line_sect_index.?];
-            try d_sym.file.pwriteAll(&data, file_pos);
+                const file_pos = sect.offset + atom.off + self.getRelocDbgLineOff();
+                try macho_file.base.file.?.pwriteAll(&data, file_pos);
+            } else {
+                const d_sym = macho_file.getDebugSymbols().?;
+                const sect = d_sym.getSection(d_sym.debug_line_section_index.?);
+                const file_pos = sect.offset + atom.off + self.getRelocDbgLineOff();
+                try d_sym.file.pwriteAll(&data, file_pos);
+            }
         },
         .wasm => {
             const wasm_file = self.bin_file.cast(File.Wasm).?;
 @@ -1877,12 +1934,21 @@ pub fn writeDbgAbbrev(self: *Dwarf) !void {
             try elf_file.base.file.?.pwriteAll(&abbrev_buf, file_pos);
         },
         .macho => {
-            const d_sym = self.bin_file.cast(File.MachO).?.getDebugSymbols().?;
+            const macho_file = self.bin_file.cast(File.MachO).?;
-            const sect_index = d_sym.debug_abbrev_section_index.?;
+            if (macho_file.base.isRelocatable()) {
-            try d_sym.growSection(sect_index, needed_size, false);
+                const sect_index = macho_file.debug_abbrev_sect_index.?;
-            const sect = d_sym.getSection(sect_index);
+                try macho_file.growSection(sect_index, needed_size);
-            const file_pos = sect.offset + abbrev_offset;
+                const sect = macho_file.sections.items(.header)[sect_index];
-            try d_sym.file.pwriteAll(&abbrev_buf, file_pos);
+                const file_pos = sect.offset + abbrev_offset;
+                try macho_file.base.file.?.pwriteAll(&abbrev_buf, file_pos);
+            } else {
+                const d_sym = macho_file.getDebugSymbols().?;
+                const sect_index = d_sym.debug_abbrev_section_index.?;
+                try d_sym.growSection(sect_index, needed_size, false, macho_file);
+                const sect = d_sym.getSection(sect_index);
+                const file_pos = sect.offset + abbrev_offset;
+                try d_sym.file.pwriteAll(&abbrev_buf, file_pos);
+            }
         },
         .wasm => {
             const wasm_file = self.bin_file.cast(File.Wasm).?;
 @@ -1967,10 +2033,17 @@ pub fn writeDbgInfoHeader(self: *Dwarf, zcu: *Module, low_pc: u64, high_pc: u64)
             try pwriteDbgInfoNops(elf_file.base.file.?, file_pos, 0, di_buf.items, jmp_amt, false);
         },
         .macho => {
-            const d_sym = self.bin_file.cast(File.MachO).?.getDebugSymbols().?;
+            const macho_file = self.bin_file.cast(File.MachO).?;
-            const debug_info_sect = d_sym.getSection(d_sym.debug_info_section_index.?);
+            if (macho_file.base.isRelocatable()) {
-            const file_pos = debug_info_sect.offset;
+                const debug_info_sect = macho_file.sections.items(.header)[macho_file.debug_info_sect_index.?];
-            try pwriteDbgInfoNops(d_sym.file, file_pos, 0, di_buf.items, jmp_amt, false);
+                const file_pos = debug_info_sect.offset;
+                try pwriteDbgInfoNops(macho_file.base.file.?, file_pos, 0, di_buf.items, jmp_amt, false);
+            } else {
+                const d_sym = macho_file.getDebugSymbols().?;
+                const debug_info_sect = d_sym.getSection(d_sym.debug_info_section_index.?);
+                const file_pos = debug_info_sect.offset;
+                try pwriteDbgInfoNops(d_sym.file, file_pos, 0, di_buf.items, jmp_amt, false);
+            }
         },
         .wasm => {
             const wasm_file = self.bin_file.cast(File.Wasm).?;
 @@ -2292,12 +2365,21 @@ pub fn writeDbgAranges(self: *Dwarf, addr: u64, size: u64) !void {
             try elf_file.base.file.?.pwriteAll(di_buf.items, file_pos);
         },
         .macho => {
-            const d_sym = self.bin_file.cast(File.MachO).?.getDebugSymbols().?;
+            const macho_file = self.bin_file.cast(File.MachO).?;
-            const sect_index = d_sym.debug_aranges_section_index.?;
+            if (macho_file.base.isRelocatable()) {
-            try d_sym.growSection(sect_index, needed_size, false);
+                const sect_index = macho_file.debug_aranges_sect_index.?;
-            const sect = d_sym.getSection(sect_index);
+                try macho_file.growSection(sect_index, needed_size);
-            const file_pos = sect.offset;
+                const sect = macho_file.sections.items(.header)[sect_index];
-            try d_sym.file.pwriteAll(di_buf.items, file_pos);
+                const file_pos = sect.offset;
+                try macho_file.base.file.?.pwriteAll(di_buf.items, file_pos);
+            } else {
+                const d_sym = macho_file.getDebugSymbols().?;
+                const sect_index = d_sym.debug_aranges_section_index.?;
+                try d_sym.growSection(sect_index, needed_size, false, macho_file);
+                const sect = d_sym.getSection(sect_index);
+                const file_pos = sect.offset;
+                try d_sym.file.pwriteAll(di_buf.items, file_pos);
+            }
         },
         .wasm => {
             const wasm_file = self.bin_file.cast(File.Wasm).?;
 @@ -2432,16 +2514,29 @@ pub fn writeDbgLineHeader(self: *Dwarf) !void {
                 try elf_file.base.file.?.pwriteAll(buffer, file_pos + delta);
             },
             .macho => {
-                const d_sym = self.bin_file.cast(File.MachO).?.getDebugSymbols().?;
+                const macho_file = self.bin_file.cast(File.MachO).?;
-                const sect_index = d_sym.debug_line_section_index.?;
+                if (macho_file.base.isRelocatable()) {
-                const needed_size: u32 = @intCast(d_sym.getSection(sect_index).size + delta);
+                    const sect_index = macho_file.debug_line_sect_index.?;
-                try d_sym.growSection(sect_index, needed_size, true);
+                    const needed_size: u32 = @intCast(macho_file.sections.items(.header)[sect_index].size + delta);
-                const file_pos = d_sym.getSection(sect_index).offset + first_fn.off;
+                    try macho_file.growSection(sect_index, needed_size);
+                    const file_pos = macho_file.sections.items(.header)[sect_index].offset + first_fn.off;
-                const amt = try d_sym.file.preadAll(buffer, file_pos);
+                    const amt = try macho_file.base.file.?.preadAll(buffer, file_pos);
-                if (amt != buffer.len) return error.InputOutput;
+                    if (amt != buffer.len) return error.InputOutput;
+                    try macho_file.base.file.?.pwriteAll(buffer, file_pos + delta);
+                } else {
+                    const d_sym = macho_file.getDebugSymbols().?;
+                    const sect_index = d_sym.debug_line_section_index.?;
+                    const needed_size: u32 = @intCast(d_sym.getSection(sect_index).size + delta);
+                    try d_sym.growSection(sect_index, needed_size, true, macho_file);
+                    const file_pos = d_sym.getSection(sect_index).offset + first_fn.off;
+                    const amt = try d_sym.file.preadAll(buffer, file_pos);
+                    if (amt != buffer.len) return error.InputOutput;
-                try d_sym.file.pwriteAll(buffer, file_pos + delta);
+                    try d_sym.file.pwriteAll(buffer, file_pos + delta);
+                }
             },
             .wasm => {
                 const wasm_file = self.bin_file.cast(File.Wasm).?;
 @@ -2487,10 +2582,17 @@ pub fn writeDbgLineHeader(self: *Dwarf) !void {
             try pwriteDbgLineNops(elf_file.base.file.?, file_pos, 0, di_buf.items, jmp_amt);
         },
         .macho => {
-            const d_sym = self.bin_file.cast(File.MachO).?.getDebugSymbols().?;
+            const macho_file = self.bin_file.cast(File.MachO).?;
-            const debug_line_sect = d_sym.getSection(d_sym.debug_line_section_index.?);
+            if (macho_file.base.isRelocatable()) {
-            const file_pos = debug_line_sect.offset;
+                const debug_line_sect = macho_file.sections.items(.header)[macho_file.debug_line_sect_index.?];
-            try pwriteDbgLineNops(d_sym.file, file_pos, 0, di_buf.items, jmp_amt);
+                const file_pos = debug_line_sect.offset;
+                try pwriteDbgLineNops(macho_file.base.file.?, file_pos, 0, di_buf.items, jmp_amt);
+            } else {
+                const d_sym = macho_file.getDebugSymbols().?;
+                const debug_line_sect = d_sym.getSection(d_sym.debug_line_section_index.?);
+                const file_pos = debug_line_sect.offset;
+                try pwriteDbgLineNops(d_sym.file, file_pos, 0, di_buf.items, jmp_amt);
+            }
         },
         .wasm => {
             const wasm_file = self.bin_file.cast(File.Wasm).?;
 @@ -2608,9 +2710,15 @@ pub fn flushModule(self: *Dwarf, module: *Module) !void {
                 break :pos debug_info_sect.sh_offset;
             },
             .macho => pos: {
-                const d_sym = self.bin_file.cast(File.MachO).?.getDebugSymbols().?;
+                const macho_file = self.bin_file.cast(File.MachO).?;
-                const debug_info_sect = d_sym.getSectionPtr(d_sym.debug_info_section_index.?);
+                if (macho_file.base.isRelocatable()) {
-                break :pos debug_info_sect.offset;
+                    const debug_info_sect = &macho_file.sections.items(.header)[macho_file.debug_info_sect_index.?];
+                    break :pos debug_info_sect.offset;
+                } else {
+                    const d_sym = macho_file.getDebugSymbols().?;
+                    const debug_info_sect = d_sym.getSectionPtr(d_sym.debug_info_section_index.?);
+                    break :pos debug_info_sect.offset;
+                }
             },
             // for wasm, the offset is always 0 as we write to memory first
             .wasm => 0,
 @@ -2628,8 +2736,13 @@ pub fn flushModule(self: *Dwarf, module: *Module) !void {
                     try elf_file.base.file.?.pwriteAll(&buf, file_pos + atom.off + reloc.offset);
                 },
                 .macho => {
-                    const d_sym = self.bin_file.cast(File.MachO).?.getDebugSymbols().?;
+                    const macho_file = self.bin_file.cast(File.MachO).?;
-                    try d_sym.file.pwriteAll(&buf, file_pos + atom.off + reloc.offset);
+                    if (macho_file.base.isRelocatable()) {
+                        try macho_file.base.file.?.pwriteAll(&buf, file_pos + atom.off + reloc.offset);
+                    } else {
+                        const d_sym = macho_file.getDebugSymbols().?;
+                        try d_sym.file.pwriteAll(&buf, file_pos + atom.off + reloc.offset);
+                    }
                 },
                 .wasm => {
                     const wasm_file = self.bin_file.cast(File.Wasm).?;
 @@ -2653,8 +2766,13 @@ fn addDIFile(self: *Dwarf, mod: *Module, decl_index: InternPool.DeclIndex) !u28
                 elf_file.markDirty(elf_file.debug_line_section_index.?);
             },
             .macho => {
-                const d_sym = self.bin_file.cast(File.MachO).?.getDebugSymbols().?;
+                const macho_file = self.bin_file.cast(File.MachO).?;
-                d_sym.markDirty(d_sym.debug_line_section_index.?);
+                if (macho_file.base.isRelocatable()) {
+                    macho_file.markDirty(macho_file.debug_line_sect_index.?);
+                } else {
+                    const d_sym = macho_file.getDebugSymbols().?;
+                    d_sym.markDirty(d_sym.debug_line_section_index.?, macho_file);
+                }
             },
             .wasm => {},
             else => unreachable,

src/link/MachO.zig+135-45

 @@ -103,6 +103,14 @@ zig_const_sect_index: ?u8 = null,
 zig_data_sect_index: ?u8 = null,
 zig_bss_sect_index: ?u8 = null,
+/// Tracked DWARF section headers that apply only when we emit relocatable.
+/// For executable and loadable images, DWARF is tracked directly by dSYM bundle object.
+debug_info_sect_index: ?u8 = null,
+debug_abbrev_sect_index: ?u8 = null,
+debug_str_sect_index: ?u8 = null,
+debug_aranges_sect_index: ?u8 = null,
+debug_line_sect_index: ?u8 = null,
 has_tlv: bool = false,
 binds_to_weak: bool = false,
 weak_defines: bool = false,
 @@ -255,44 +263,15 @@ pub fn createEmpty(
                 )}),
             } });
             self.zig_object = index;
-            try self.getZigObject().?.init(self);
+            const zo = self.getZigObject().?;
+            try zo.init(self);
             try self.initMetadata(.{
+                .emit = emit,
+                .zo = zo,
                 .symbol_count_hint = options.symbol_count_hint,
                 .program_code_size_hint = options.program_code_size_hint,
             });
-            switch (comp.config.debug_format) {
-                .strip => {},
-                .dwarf => if (!self.base.isRelocatable()) {
-                    // Create dSYM bundle.
-                    log.debug("creating {s}.dSYM bundle", .{emit.sub_path});
-                    const sep = fs.path.sep_str;
-                    const d_sym_path = try std.fmt.allocPrint(
-                        arena,
-                        "{s}.dSYM" ++ sep ++ "Contents" ++ sep ++ "Resources" ++ sep ++ "DWARF",
-                        .{emit.sub_path},
-                    );
-                    var d_sym_bundle = try emit.directory.handle.makeOpenPath(d_sym_path, .{});
-                    defer d_sym_bundle.close();
-                    const d_sym_file = try d_sym_bundle.createFile(emit.sub_path, .{
-                        .truncate = false,
-                        .read = true,
-                    });
-                    self.d_sym = .{
-                        .allocator = gpa,
-                        .dwarf = link.File.Dwarf.init(&self.base, .dwarf32),
-                        .file = d_sym_file,
-                    };
-                    try self.d_sym.?.initMetadata(self);
-                } else {
-                    @panic("TODO: implement generating and emitting __DWARF in .o file");
-                },
-                .code_view => unreachable,
-            }
         }
     }
 @@ -978,7 +957,6 @@ fn parseObject(self: *MachO, path: []const u8) ParseError!void {
     const gpa = self.base.comp.gpa;
     const file = try std.fs.cwd().openFile(path, .{});
-    errdefer file.close();
     const handle = try self.addFileHandle(file);
     const mtime: u64 = mtime: {
         const stat = file.stat() catch break :mtime 0;
 @@ -1015,7 +993,6 @@ fn parseArchive(self: *MachO, lib: SystemLib, must_link: bool, fat_arch: ?fat.Ar
     const gpa = self.base.comp.gpa;
     const file = try std.fs.cwd().openFile(lib.path, .{});
-    errdefer file.close();
     const handle = try self.addFileHandle(file);
     var archive = Archive{};
 @@ -2015,6 +1992,11 @@ pub fn sortSections(self: *MachO) !void {
         &self.eh_frame_sect_index,
         &self.unwind_info_sect_index,
         &self.objc_stubs_sect_index,
+        &self.debug_info_sect_index,
+        &self.debug_str_sect_index,
+        &self.debug_line_sect_index,
+        &self.debug_abbrev_sect_index,
+        &self.debug_info_sect_index,
     }) |maybe_index| {
         if (maybe_index.*) |*index| {
             index.* = backlinks[index.*];
 @@ -2314,11 +2296,11 @@ fn allocateSections(self: *MachO) !void {
             // Must move the entire section.
             const new_offset = self.findFreeSpace(existing_size, page_size);
-            log.debug("new '{s},{s}' file offset 0x{x} to 0x{x}", .{
+            log.debug("moving '{s},{s}' from 0x{x} to 0x{x}", .{
                 header.segName(),
                 header.sectName(),
+                header.offset,
                 new_offset,
-                new_offset + existing_size,
             });
             try self.copyRangeAllZeroOut(header.offset, new_offset, existing_size);
 @@ -3152,7 +3134,7 @@ pub fn updateDecl(self: *MachO, mod: *Module, decl_index: InternPool.DeclIndex)
 pub fn updateDeclLineNumber(self: *MachO, module: *Module, decl_index: InternPool.DeclIndex) !void {
     if (self.llvm_object) |_| return;
-    return self.getZigObject().?.updateDeclLineNumber(self, module, decl_index);
+    return self.getZigObject().?.updateDeclLineNumber(module, decl_index);
 }
 pub fn updateExports(
 @@ -3221,7 +3203,7 @@ fn detectAllocCollision(self: *MachO, start: u64, size: u64) ?u64 {
     for (self.sections.items(.header)) |header| {
         if (header.isZerofill()) continue;
         const increased_size = padToIdeal(header.size);
-        const test_end = header.offset + increased_size;
+        const test_end = header.offset +| increased_size;
         if (end > header.offset and start < test_end) {
             return test_end;
         }
 @@ -3249,7 +3231,7 @@ fn detectAllocCollisionVirtual(self: *MachO, start: u64, size: u64) ?u64 {
     for (self.sections.items(.header)) |header| {
         const increased_size = padToIdeal(header.size);
-        const test_end = header.addr + increased_size;
+        const test_end = header.addr +| increased_size;
         if (end > header.addr and start < test_end) {
             return test_end;
         }
 @@ -3266,27 +3248,39 @@ fn detectAllocCollisionVirtual(self: *MachO, start: u64, size: u64) ?u64 {
     return null;
 }
-fn allocatedSize(self: *MachO, start: u64) u64 {
+pub fn allocatedSize(self: *MachO, start: u64) u64 {
     if (start == 0) return 0;
     var min_pos: u64 = std.math.maxInt(u64);
     for (self.sections.items(.header)) |header| {
         if (header.offset <= start) continue;
         if (header.offset < min_pos) min_pos = header.offset;
     }
     for (self.segments.items) |seg| {
         if (seg.fileoff <= start) continue;
         if (seg.fileoff < min_pos) min_pos = seg.fileoff;
     }
     return min_pos - start;
 }
-fn allocatedSizeVirtual(self: *MachO, start: u64) u64 {
+pub fn allocatedSizeVirtual(self: *MachO, start: u64) u64 {
     if (start == 0) return 0;
     var min_pos: u64 = std.math.maxInt(u64);
+    for (self.sections.items(.header)) |header| {
+        if (header.addr <= start) continue;
+        if (header.addr < min_pos) min_pos = header.addr;
+    }
     for (self.segments.items) |seg| {
         if (seg.vmaddr <= start) continue;
         if (seg.vmaddr < min_pos) min_pos = seg.vmaddr;
     }
     return min_pos - start;
 }
 @@ -3325,6 +3319,8 @@ fn copyRangeAllZeroOut(self: *MachO, old_offset: u64, new_offset: u64, size: u64
 }
 const InitMetadataOptions = struct {
+    emit: Compilation.Emit,
+    zo: *ZigObject,
     symbol_count_hint: u64,
     program_code_size_hint: u64,
 };
 @@ -3393,6 +3389,31 @@ fn initMetadata(self: *MachO, options: InitMetadataOptions) !void {
                 .prot = macho.PROT.READ | macho.PROT.WRITE,
             });
         }
+        if (options.zo.dwarf) |_| {
+            // Create dSYM bundle.
+            log.debug("creating {s}.dSYM bundle", .{options.emit.sub_path});
+            const gpa = self.base.comp.gpa;
+            const sep = fs.path.sep_str;
+            const d_sym_path = try std.fmt.allocPrint(
+                gpa,
+                "{s}.dSYM" ++ sep ++ "Contents" ++ sep ++ "Resources" ++ sep ++ "DWARF",
+                .{options.emit.sub_path},
+            );
+            defer gpa.free(d_sym_path);
+            var d_sym_bundle = try options.emit.directory.handle.makeOpenPath(d_sym_path, .{});
+            defer d_sym_bundle.close();
+            const d_sym_file = try d_sym_bundle.createFile(options.emit.sub_path, .{
+                .truncate = false,
+                .read = true,
+            });
+            self.d_sym = .{ .allocator = gpa, .file = d_sym_file };
+            try self.d_sym.?.initMetadata(self);
+        }
     }
     const appendSect = struct {
 @@ -3470,6 +3491,44 @@ fn initMetadata(self: *MachO, options: InitMetadataOptions) !void {
             appendSect(self, self.zig_bss_sect_index.?, self.zig_bss_seg_index.?);
         }
     }
+    if (self.base.isRelocatable() and options.zo.dwarf != null) {
+        {
+            self.debug_str_sect_index = try self.addSection("__DWARF", "__debug_str", .{
+                .flags = macho.S_ATTR_DEBUG,
+            });
+            try allocSect(self, self.debug_str_sect_index.?, 200);
+        }
+        {
+            self.debug_info_sect_index = try self.addSection("__DWARF", "__debug_info", .{
+                .flags = macho.S_ATTR_DEBUG,
+            });
+            try allocSect(self, self.debug_info_sect_index.?, 200);
+        }
+        {
+            self.debug_abbrev_sect_index = try self.addSection("__DWARF", "__debug_abbrev", .{
+                .flags = macho.S_ATTR_DEBUG,
+            });
+            try allocSect(self, self.debug_abbrev_sect_index.?, 128);
+        }
+        {
+            self.debug_aranges_sect_index = try self.addSection("__DWARF", "__debug_aranges", .{
+                .alignment = 4,
+                .flags = macho.S_ATTR_DEBUG,
+            });
+            try allocSect(self, self.debug_aranges_sect_index.?, 160);
+        }
+        {
+            self.debug_line_sect_index = try self.addSection("__DWARF", "__debug_line", .{
+                .flags = macho.S_ATTR_DEBUG,
+            });
+            try allocSect(self, self.debug_line_sect_index.?, 250);
+        }
+    }
 }
 pub fn growSection(self: *MachO, sect_index: u8, needed_size: u64) !void {
 @@ -3491,11 +3550,11 @@ fn growSectionNonRelocatable(self: *MachO, sect_index: u8, needed_size: u64) !vo
         const alignment = self.getPageSize();
         const new_offset = self.findFreeSpace(needed_size, alignment);
-        log.debug("new '{s},{s}' file offset 0x{x} to 0x{x}", .{
+        log.debug("moving '{s},{s}' from 0x{x} to 0x{x}", .{
             sect.segName(),
             sect.sectName(),
+            sect.offset,
             new_offset,
-            new_offset + existing_size,
         });
         try self.copyRangeAllZeroOut(sect.offset, new_offset, existing_size);
 @@ -3557,6 +3616,22 @@ fn growSectionRelocatable(self: *MachO, sect_index: u8, needed_size: u64) !void
     sect.size = needed_size;
 }
+pub fn markDirty(self: *MachO, sect_index: u8) void {
+    if (self.getZigObject()) |zo| {
+        if (self.debug_info_sect_index.? == sect_index) {
+            zo.debug_info_header_dirty = true;
+        } else if (self.debug_line_sect_index.? == sect_index) {
+            zo.debug_line_header_dirty = true;
+        } else if (self.debug_abbrev_sect_index.? == sect_index) {
+            zo.debug_abbrev_dirty = true;
+        } else if (self.debug_str_sect_index.? == sect_index) {
+            zo.debug_strtab_dirty = true;
+        } else if (self.debug_aranges_sect_index.? == sect_index) {
+            zo.debug_aranges_dirty = true;
+        }
+    }
+}
 pub fn getTarget(self: MachO) std.Target {
     return self.base.comp.root_mod.resolved_target.result;
 }
 @@ -3632,6 +3707,21 @@ pub fn isZigSection(self: MachO, sect_id: u8) bool {
     return false;
 }
+pub fn isDebugSection(self: MachO, sect_id: u8) bool {
+    inline for (&[_]?u8{
+        self.debug_info_sect_index,
+        self.debug_abbrev_sect_index,
+        self.debug_str_sect_index,
+        self.debug_aranges_sect_index,
+        self.debug_line_sect_index,
+    }) |maybe_index| {
+        if (maybe_index) |index| {
+            if (index == sect_id) return true;
+        }
+    }
+    return false;
+}
 pub fn addSegment(self: *MachO, name: []const u8, opts: struct {
     vmaddr: u64 = 0,
     vmsize: u64 = 0,

src/link/MachO/DebugSymbols.zig+35-112

...	@@ -1,5 +1,4 @@	...	@@ -1,5 +1,4 @@
1	allocator: Allocator,	1	allocator: Allocator,
2	dwarf: Dwarf,
3	file: fs.File,	2	file: fs.File,
4		3
5	symtab_cmd: macho.symtab_command = .{},	4	symtab_cmd: macho.symtab_command = .{},
...	@@ -17,12 +16,6 @@ debug_str_section_index: ?u8 = null,	...	@@ -17,12 +16,6 @@ debug_str_section_index: ?u8 = null,
17	debug_aranges_section_index: ?u8 = null,	16	debug_aranges_section_index: ?u8 = null,
18	debug_line_section_index: ?u8 = null,	17	debug_line_section_index: ?u8 = null,
19		18
20	debug_string_table_dirty: bool = false,
21	debug_abbrev_section_dirty: bool = false,
22	debug_aranges_section_dirty: bool = false,
23	debug_info_header_dirty: bool = false,
24	debug_line_header_dirty: bool = false,
25
26	relocs: std.ArrayListUnmanaged(Reloc) = .{},	19	relocs: std.ArrayListUnmanaged(Reloc) = .{},
27		20
28	/// Output synthetic sections	21	/// Output synthetic sections
...	@@ -44,7 +37,7 @@ pub const Reloc = struct {	...	@@ -44,7 +37,7 @@ pub const Reloc = struct {
44	pub fn initMetadata(self: DebugSymbols, macho_file: MachO) !void {	37	pub fn initMetadata(self: DebugSymbols, macho_file: MachO) !void {
45	try self.strtab.append(self.allocator, 0);	38	try self.strtab.append(self.allocator, 0);
46		39
47	if (self.dwarf_segment_cmd_index == null) {	40	{
48	self.dwarf_segment_cmd_index = @as(u8, @intCast(self.segments.items.len));	41	self.dwarf_segment_cmd_index = @as(u8, @intCast(self.segments.items.len));
49		42
50	const page_size = macho_file.getPageSize();	43	const page_size = macho_file.getPageSize();
...	@@ -63,46 +56,19 @@ pub fn initMetadata(self: DebugSymbols, macho_file: MachO) !void {	...	@@ -63,46 +56,19 @@ pub fn initMetadata(self: DebugSymbols, macho_file: MachO) !void {
63	});	56	});
64	}	57	}
65		58
66	if (self.debug_str_section_index == null) {	59	self.debug_str_section_index = try self.allocateSection("__debug_str", 200, 0);
67	assert(self.dwarf.strtab.buffer.items.len == 0);	60	self.debug_info_section_index = try self.allocateSection("__debug_info", 200, 0);
68	try self.dwarf.strtab.buffer.append(self.allocator, 0);	61	self.debug_abbrev_section_index = try self.allocateSection("__debug_abbrev", 128, 0);
69	self.debug_str_section_index = try self.allocateSection(	62	self.debug_aranges_section_index = try self.allocateSection("__debug_aranges", 160, 4);
70	"__debug_str",	63	self.debug_line_section_index = try self.allocateSection("__debug_line", 250, 0);
71	@as(u32, @intCast(self.dwarf.strtab.buffer.items.len)),	64
72	0,	65	self.linkedit_segment_cmd_index = @as(u8, @intCast(self.segments.items.len));
73	);	66	try self.segments.append(self.allocator, .{
74	self.debug_string_table_dirty = true;	67	.segname = makeStaticString("__LINKEDIT"),
75	}	68	.maxprot = macho.PROT.READ,
76		69	.initprot = macho.PROT.READ,
77	if (self.debug_info_section_index == null) {	70	.cmdsize = @sizeOf(macho.segment_command_64),
78	self.debug_info_section_index = try self.allocateSection("__debug_info", 200, 0);	71	});
79	self.debug_info_header_dirty = true;
80	}
81
82	if (self.debug_abbrev_section_index == null) {
83	self.debug_abbrev_section_index = try self.allocateSection("__debug_abbrev", 128, 0);
84	self.debug_abbrev_section_dirty = true;
85	}
86
87	if (self.debug_aranges_section_index == null) {
88	self.debug_aranges_section_index = try self.allocateSection("__debug_aranges", 160, 4);
89	self.debug_aranges_section_dirty = true;
90	}
91
92	if (self.debug_line_section_index == null) {
93	self.debug_line_section_index = try self.allocateSection("__debug_line", 250, 0);
94	self.debug_line_header_dirty = true;
95	}
96
97	if (self.linkedit_segment_cmd_index == null) {
98	self.linkedit_segment_cmd_index = @as(u8, @intCast(self.segments.items.len));
99	try self.segments.append(self.allocator, .{
100	.segname = makeStaticString("__LINKEDIT"),
101	.maxprot = macho.PROT.READ,
102	.initprot = macho.PROT.READ,
103	.cmdsize = @sizeOf(macho.segment_command_64),
104	});
105	}
106	}	72	}
107		73
108	fn allocateSection(self: *DebugSymbols, sectname: []const u8, size: u64, alignment: u16) !u8 {	74	fn allocateSection(self: *DebugSymbols, sectname: []const u8, size: u64, alignment: u16) !u8 {
...	@@ -133,7 +99,13 @@ fn allocateSection(self: *DebugSymbols, sectname: []const u8, size: u64, alignme	...	@@ -133,7 +99,13 @@ fn allocateSection(self: *DebugSymbols, sectname: []const u8, size: u64, alignme
133	return index;	99	return index;
134	}	100	}
135		101
136	pub fn growSection(self: *DebugSymbols, sect_index: u8, needed_size: u32, requires_file_copy: bool) !void {	102	pub fn growSection(
		103	self: *DebugSymbols,
		104	sect_index: u8,
		105	needed_size: u32,
		106	requires_file_copy: bool,
		107	macho_file: *MachO,
		108	) !void {
137	const sect = self.getSectionPtr(sect_index);	109	const sect = self.getSectionPtr(sect_index);
138		110
139	if (needed_size > self.allocatedSize(sect.offset)) {	111	if (needed_size > self.allocatedSize(sect.offset)) {
...	@@ -162,20 +134,22 @@ pub fn growSection(self: *DebugSymbols, sect_index: u8, needed_size: u32, requir	...	@@ -162,20 +134,22 @@ pub fn growSection(self: *DebugSymbols, sect_index: u8, needed_size: u32, requir
162	}	134	}
163		135
164	sect.size = needed_size;	136	sect.size = needed_size;
165	self.markDirty(sect_index);	137	self.markDirty(sect_index, macho_file);
166	}	138	}
167		139
168	pub fn markDirty(self: *DebugSymbols, sect_index: u8) void {	140	pub fn markDirty(self: DebugSymbols, sect_index: u8, macho_file: MachO) void {
169	if (self.debug_info_section_index.? == sect_index) {	141	if (macho_file.getZigObject()) \|zo\| {
170	self.debug_info_header_dirty = true;	142	if (self.debug_info_section_index.? == sect_index) {
171	} else if (self.debug_line_section_index.? == sect_index) {	143	zo.debug_info_header_dirty = true;
172	self.debug_line_header_dirty = true;	144	} else if (self.debug_line_section_index.? == sect_index) {
173	} else if (self.debug_abbrev_section_index.? == sect_index) {	145	zo.debug_line_header_dirty = true;
174	self.debug_abbrev_section_dirty = true;	146	} else if (self.debug_abbrev_section_index.? == sect_index) {
175	} else if (self.debug_str_section_index.? == sect_index) {	147	zo.debug_abbrev_dirty = true;
176	self.debug_string_table_dirty = true;	148	} else if (self.debug_str_section_index.? == sect_index) {
177	} else if (self.debug_aranges_section_index.? == sect_index) {	149	zo.debug_strtab_dirty = true;
178	self.debug_aranges_section_dirty = true;	150	} else if (self.debug_aranges_section_index.? == sect_index) {
		151	zo.debug_aranges_dirty = true;
		152	}
179	}	153	}
180	}	154	}
181		155
...	@@ -201,13 +175,6 @@ fn findFreeSpace(self: *DebugSymbols, object_size: u64, min_alignment: u64) u64	...	@@ -201,13 +175,6 @@ fn findFreeSpace(self: *DebugSymbols, object_size: u64, min_alignment: u64) u64
201	}	175	}
202		176
203	pub fn flushModule(self: DebugSymbols, macho_file: MachO) !void {	177	pub fn flushModule(self: DebugSymbols, macho_file: MachO) !void {
204	const comp = macho_file.base.comp;
205	// TODO This linker code currently assumes there is only 1 compilation unit
206	// and it corresponds to the Zig source code.
207	const zcu = comp.module orelse return error.LinkingWithoutZigSourceUnimplemented;
208
209	try self.dwarf.flushModule(zcu);
210
211	for (self.relocs.items) \|*reloc\| {	178	for (self.relocs.items) \|*reloc\| {
212	const sym = macho_file.getSymbol(reloc.target);	179	const sym = macho_file.getSymbol(reloc.target);
213	const sym_name = sym.getName(macho_file);	180	const sym_name = sym.getName(macho_file);
...	@@ -226,54 +193,12 @@ pub fn flushModule(self: DebugSymbols, macho_file: MachO) !void {	...	@@ -226,54 +193,12 @@ pub fn flushModule(self: DebugSymbols, macho_file: MachO) !void {
226	try self.file.pwriteAll(mem.asBytes(&addr), file_offset);	193	try self.file.pwriteAll(mem.asBytes(&addr), file_offset);
227	}	194	}
228		195
229	if (self.debug_abbrev_section_dirty) {
230	try self.dwarf.writeDbgAbbrev();
231	self.debug_abbrev_section_dirty = false;
232	}
233
234	if (self.debug_info_header_dirty) {
235	// Currently only one compilation unit is supported, so the address range is simply
236	// identical to the main program header virtual address and memory size.
237	const text_section = macho_file.sections.items(.header)[macho_file.zig_text_sect_index.?];
238	const low_pc = text_section.addr;
239	const high_pc = text_section.addr + text_section.size;
240	try self.dwarf.writeDbgInfoHeader(zcu, low_pc, high_pc);
241	self.debug_info_header_dirty = false;
242	}
243
244	if (self.debug_aranges_section_dirty) {
245	// Currently only one compilation unit is supported, so the address range is simply
246	// identical to the main program header virtual address and memory size.
247	const text_section = macho_file.sections.items(.header)[macho_file.zig_text_sect_index.?];
248	try self.dwarf.writeDbgAranges(text_section.addr, text_section.size);
249	self.debug_aranges_section_dirty = false;
250	}
251
252	if (self.debug_line_header_dirty) {
253	try self.dwarf.writeDbgLineHeader();
254	self.debug_line_header_dirty = false;
255	}
256
257	{
258	const sect_index = self.debug_str_section_index.?;
259	if (self.debug_string_table_dirty or self.dwarf.strtab.buffer.items.len != self.getSection(sect_index).size) {
260	const needed_size = @as(u32, @intCast(self.dwarf.strtab.buffer.items.len));
261	try self.growSection(sect_index, needed_size, false);
262	try self.file.pwriteAll(self.dwarf.strtab.buffer.items, self.getSection(sect_index).offset);
263	self.debug_string_table_dirty = false;
264	}
265	}
266
267	self.finalizeDwarfSegment(macho_file);	196	self.finalizeDwarfSegment(macho_file);
268	try self.writeLinkeditSegmentData(macho_file);	197	try self.writeLinkeditSegmentData(macho_file);
269		198
270	// Write load commands	199	// Write load commands
271	const ncmds, const sizeofcmds = try self.writeLoadCommands(macho_file);	200	const ncmds, const sizeofcmds = try self.writeLoadCommands(macho_file);
272	try self.writeHeader(macho_file, ncmds, sizeofcmds);	201	try self.writeHeader(macho_file, ncmds, sizeofcmds);
273
274	assert(!self.debug_abbrev_section_dirty);
275	assert(!self.debug_aranges_section_dirty);
276	assert(!self.debug_string_table_dirty);
277	}	202	}
278		203
279	pub fn deinit(self: *DebugSymbols) void {	204	pub fn deinit(self: *DebugSymbols) void {
...	@@ -281,7 +206,6 @@ pub fn deinit(self: *DebugSymbols) void {	...	@@ -281,7 +206,6 @@ pub fn deinit(self: *DebugSymbols) void {
281	self.file.close();	206	self.file.close();
282	self.segments.deinit(gpa);	207	self.segments.deinit(gpa);
283	self.sections.deinit(gpa);	208	self.sections.deinit(gpa);
284	self.dwarf.deinit();
285	self.relocs.deinit(gpa);	209	self.relocs.deinit(gpa);
286	self.symtab.deinit(gpa);	210	self.symtab.deinit(gpa);
287	self.strtab.deinit(gpa);	211	self.strtab.deinit(gpa);
...	@@ -534,7 +458,6 @@ const padToIdeal = MachO.padToIdeal;	...	@@ -534,7 +458,6 @@ const padToIdeal = MachO.padToIdeal;
534	const trace = @import("../../tracy.zig").trace;	458	const trace = @import("../../tracy.zig").trace;
535		459
536	const Allocator = mem.Allocator;	460	const Allocator = mem.Allocator;
537	const Dwarf = @import("../Dwarf.zig");
538	const MachO = @import("../MachO.zig");	461	const MachO = @import("../MachO.zig");
539	const StringTable = @import("../StringTable.zig");	462	const StringTable = @import("../StringTable.zig");
540	const Type = @import("../../type.zig").Type;	463	const Type = @import("../../type.zig").Type;

src/link/MachO/ZigObject.zig+93-13

...	@@ -46,16 +46,38 @@ tlv_initializers: TlvInitializerTable = .{},	...	@@ -46,16 +46,38 @@ tlv_initializers: TlvInitializerTable = .{},
46	/// A table of relocations.	46	/// A table of relocations.
47	relocs: RelocationTable = .{},	47	relocs: RelocationTable = .{},
48		48
		49	dwarf: ?Dwarf = null,
		50
49	dynamic_relocs: MachO.DynamicRelocs = .{},	51	dynamic_relocs: MachO.DynamicRelocs = .{},
50	output_symtab_ctx: MachO.SymtabCtx = .{},	52	output_symtab_ctx: MachO.SymtabCtx = .{},
51	output_ar_state: Archive.ArState = .{},	53	output_ar_state: Archive.ArState = .{},
52		54
		55	debug_strtab_dirty: bool = false,
		56	debug_abbrev_dirty: bool = false,
		57	debug_aranges_dirty: bool = false,
		58	debug_info_header_dirty: bool = false,
		59	debug_line_header_dirty: bool = false,
		60
53	pub fn init(self: ZigObject, macho_file: MachO) !void {	61	pub fn init(self: ZigObject, macho_file: MachO) !void {
54	const comp = macho_file.base.comp;	62	const comp = macho_file.base.comp;
55	const gpa = comp.gpa;	63	const gpa = comp.gpa;
56		64
57	try self.atoms.append(gpa, 0); // null input section	65	try self.atoms.append(gpa, 0); // null input section
58	try self.strtab.buffer.append(gpa, 0);	66	try self.strtab.buffer.append(gpa, 0);
		67
		68	switch (comp.config.debug_format) {
		69	.strip => {},
		70	.dwarf => \|v\| {
		71	assert(v == .@"32");
		72	self.dwarf = Dwarf.init(&macho_file.base, .dwarf32);
		73	self.debug_strtab_dirty = true;
		74	self.debug_abbrev_dirty = true;
		75	self.debug_aranges_dirty = true;
		76	self.debug_info_header_dirty = true;
		77	self.debug_line_header_dirty = true;
		78	},
		79	.code_view => unreachable,
		80	}
59	}	81	}
60		82
61	pub fn deinit(self: *ZigObject, allocator: Allocator) void {	83	pub fn deinit(self: *ZigObject, allocator: Allocator) void {
...	@@ -101,6 +123,10 @@ pub fn deinit(self: *ZigObject, allocator: Allocator) void {	...	@@ -101,6 +123,10 @@ pub fn deinit(self: *ZigObject, allocator: Allocator) void {
101	tlv_init.deinit(allocator);	123	tlv_init.deinit(allocator);
102	}	124	}
103	self.tlv_initializers.deinit(allocator);	125	self.tlv_initializers.deinit(allocator);
		126
		127	if (self.dwarf) \|*dw\| {
		128	dw.deinit();
		129	}
104	}	130	}
105		131
106	fn addNlist(self: *ZigObject, allocator: Allocator) !Symbol.Index {	132	fn addNlist(self: *ZigObject, allocator: Allocator) !Symbol.Index {
...	@@ -407,6 +433,66 @@ pub fn flushModule(self: ZigObject, macho_file: MachO) !void {	...	@@ -407,6 +433,66 @@ pub fn flushModule(self: ZigObject, macho_file: MachO) !void {
407	if (metadata.text_state != .unused) metadata.text_state = .flushed;	433	if (metadata.text_state != .unused) metadata.text_state = .flushed;
408	if (metadata.const_state != .unused) metadata.const_state = .flushed;	434	if (metadata.const_state != .unused) metadata.const_state = .flushed;
409	}	435	}
		436
		437	if (self.dwarf) \|*dw\| {
		438	const zcu = macho_file.base.comp.module.?;
		439	try dw.flushModule(zcu);
		440
		441	if (self.debug_abbrev_dirty) {
		442	try dw.writeDbgAbbrev();
		443	self.debug_abbrev_dirty = false;
		444	}
		445
		446	if (self.debug_info_header_dirty) {
		447	// Currently only one compilation unit is supported, so the address range is simply
		448	// identical to the main program header virtual address and memory size.
		449	const text_section = macho_file.sections.items(.header)[macho_file.zig_text_sect_index.?];
		450	const low_pc = text_section.addr;
		451	const high_pc = text_section.addr + text_section.size;
		452	try dw.writeDbgInfoHeader(zcu, low_pc, high_pc);
		453	self.debug_info_header_dirty = false;
		454	}
		455
		456	if (self.debug_aranges_dirty) {
		457	// Currently only one compilation unit is supported, so the address range is simply
		458	// identical to the main program header virtual address and memory size.
		459	const text_section = macho_file.sections.items(.header)[macho_file.zig_text_sect_index.?];
		460	try dw.writeDbgAranges(text_section.addr, text_section.size);
		461	self.debug_aranges_dirty = false;
		462	}
		463
		464	if (self.debug_line_header_dirty) {
		465	try dw.writeDbgLineHeader();
		466	self.debug_line_header_dirty = false;
		467	}
		468
		469	if (!macho_file.base.isRelocatable()) {
		470	const d_sym = macho_file.getDebugSymbols().?;
		471	const sect_index = d_sym.debug_str_section_index.?;
		472	if (self.debug_strtab_dirty or dw.strtab.buffer.items.len != d_sym.getSection(sect_index).size) {
		473	const needed_size = @as(u32, @intCast(dw.strtab.buffer.items.len));
		474	try d_sym.growSection(sect_index, needed_size, false, macho_file);
		475	try d_sym.file.pwriteAll(dw.strtab.buffer.items, d_sym.getSection(sect_index).offset);
		476	self.debug_strtab_dirty = false;
		477	}
		478	} else {
		479	const sect_index = macho_file.debug_str_sect_index.?;
		480	if (self.debug_strtab_dirty or dw.strtab.buffer.items.len != macho_file.sections.items(.header)[sect_index].size) {
		481	const needed_size = @as(u32, @intCast(dw.strtab.buffer.items.len));
		482	try macho_file.growSection(sect_index, needed_size);
		483	try macho_file.base.file.?.pwriteAll(dw.strtab.buffer.items, macho_file.sections.items(.header)[sect_index].offset);
		484	self.debug_strtab_dirty = false;
		485	}
		486	}
		487	}
		488
		489	// The point of flushModule() is to commit changes, so in theory, nothing should
		490	// be dirty after this. However, it is possible for some things to remain
		491	// dirty because they fail to be written in the event of compile errors,
		492	// such as debug_line_header_dirty and debug_info_header_dirty.
		493	assert(!self.debug_abbrev_dirty);
		494	assert(!self.debug_aranges_dirty);
		495	assert(!self.debug_strtab_dirty);
410	}	496	}
411		497
412	pub fn getDeclVAddr(	498	pub fn getDeclVAddr(
...	@@ -572,7 +658,7 @@ pub fn updateFunc(	...	@@ -572,7 +658,7 @@ pub fn updateFunc(
572	var code_buffer = std.ArrayList(u8).init(gpa);	658	var code_buffer = std.ArrayList(u8).init(gpa);
573	defer code_buffer.deinit();	659	defer code_buffer.deinit();
574		660
575	var decl_state: ?Dwarf.DeclState = if (macho_file.getDebugSymbols()) \|d_sym\| try d_sym.dwarf.initDeclState(mod, decl_index) else null;	661	var decl_state: ?Dwarf.DeclState = if (self.dwarf) \|*dw\| try dw.initDeclState(mod, decl_index) else null;
576	defer if (decl_state) \|*ds\| ds.deinit();	662	defer if (decl_state) \|*ds\| ds.deinit();
577		663
578	const dio: codegen.DebugInfoOutput = if (decl_state) \|*ds\| .{ .dwarf = ds } else .none;	664	const dio: codegen.DebugInfoOutput = if (decl_state) \|*ds\| .{ .dwarf = ds } else .none;
...	@@ -600,7 +686,7 @@ pub fn updateFunc(	...	@@ -600,7 +686,7 @@ pub fn updateFunc(
600		686
601	if (decl_state) \|*ds\| {	687	if (decl_state) \|*ds\| {
602	const sym = macho_file.getSymbol(sym_index);	688	const sym = macho_file.getSymbol(sym_index);
603	try macho_file.getDebugSymbols().?.dwarf.commitDeclState(	689	try self.dwarf.?.commitDeclState(
604	mod,	690	mod,
605	decl_index,	691	decl_index,
606	sym.getAddress(.{}, macho_file),	692	sym.getAddress(.{}, macho_file),
...	@@ -647,7 +733,7 @@ pub fn updateDecl(	...	@@ -647,7 +733,7 @@ pub fn updateDecl(
647	var code_buffer = std.ArrayList(u8).init(gpa);	733	var code_buffer = std.ArrayList(u8).init(gpa);
648	defer code_buffer.deinit();	734	defer code_buffer.deinit();
649		735
650	var decl_state: ?Dwarf.DeclState = if (macho_file.getDebugSymbols()) \|d_sym\| try d_sym.dwarf.initDeclState(mod, decl_index) else null;	736	var decl_state: ?Dwarf.DeclState = if (self.dwarf) \|*dw\| try dw.initDeclState(mod, decl_index) else null;
651	defer if (decl_state) \|*ds\| ds.deinit();	737	defer if (decl_state) \|*ds\| ds.deinit();
652		738
653	const decl_val = if (decl.val.getVariable(mod)) \|variable\| Value.fromInterned(variable.init) else decl.val;	739	const decl_val = if (decl.val.getVariable(mod)) \|variable\| Value.fromInterned(variable.init) else decl.val;
...	@@ -681,7 +767,7 @@ pub fn updateDecl(	...	@@ -681,7 +767,7 @@ pub fn updateDecl(
681		767
682	if (decl_state) \|*ds\| {	768	if (decl_state) \|*ds\| {
683	const sym = macho_file.getSymbol(sym_index);	769	const sym = macho_file.getSymbol(sym_index);
684	try macho_file.getDebugSymbols().?.dwarf.commitDeclState(	770	try self.dwarf.?.commitDeclState(
685	mod,	771	mod,
686	decl_index,	772	decl_index,
687	sym.getAddress(.{}, macho_file),	773	sym.getAddress(.{}, macho_file),
...	@@ -1257,15 +1343,9 @@ fn updateLazySymbol(	...	@@ -1257,15 +1343,9 @@ fn updateLazySymbol(
1257	}	1343	}
1258		1344
1259	/// Must be called only after a successful call to `updateDecl`.	1345	/// Must be called only after a successful call to `updateDecl`.
1260	pub fn updateDeclLineNumber(	1346	pub fn updateDeclLineNumber(self: ZigObject, mod: Module, decl_index: InternPool.DeclIndex) !void {
1261	self: *ZigObject,	1347	if (self.dwarf) \|*dw\| {
1262	macho_file: *MachO,	1348	try dw.updateDeclLineNumber(mod, decl_index);
1263	mod: *Module,
1264	decl_index: InternPool.DeclIndex,
1265	) !void {
1266	_ = self;
1267	if (macho_file.getDebugSymbols()) \|d_sym\| {
1268	try d_sym.dwarf.updateDeclLineNumber(mod, decl_index);
1269	}	1349	}
1270	}	1350	}
1271		1351

src/link/MachO/relocatable.zig+21-19

test/link/macho.zig+45-9

...	@@ -20,8 +20,11 @@ pub fn testAll(b: Build, build_opts: BuildOptions) Step {	...	@@ -20,8 +20,11 @@ pub fn testAll(b: Build, build_opts: BuildOptions) Step {
20	};	20	};
21		21
22	// Exercise linker with self-hosted backend (no LLVM)	22	// Exercise linker with self-hosted backend (no LLVM)
		23	macho_step.dependOn(testEmptyZig(b, .{ .use_llvm = false, .target = x86_64_target }));
23	macho_step.dependOn(testHelloZig(b, .{ .use_llvm = false, .target = x86_64_target }));	24	macho_step.dependOn(testHelloZig(b, .{ .use_llvm = false, .target = x86_64_target }));
24	macho_step.dependOn(testRelocatableZig(b, .{ .use_llvm = false, .strip = true, .target = x86_64_target }));	25	macho_step.dependOn(testLinkingStaticLib(b, .{ .use_llvm = false, .target = x86_64_target }));
		26	macho_step.dependOn(testReexportsZig(b, .{ .use_llvm = false, .target = x86_64_target }));
		27	macho_step.dependOn(testRelocatableZig(b, .{ .use_llvm = false, .target = x86_64_target }));
25		28
26	// Exercise linker with LLVM backend	29	// Exercise linker with LLVM backend
27	macho_step.dependOn(testDeadStrip(b, .{ .target = default_target }));	30	macho_step.dependOn(testDeadStrip(b, .{ .target = default_target }));
...	@@ -33,6 +36,7 @@ pub fn testAll(b: Build, build_opts: BuildOptions) Step {	...	@@ -33,6 +36,7 @@ pub fn testAll(b: Build, build_opts: BuildOptions) Step {
33	macho_step.dependOn(testHelloZig(b, .{ .target = default_target }));	36	macho_step.dependOn(testHelloZig(b, .{ .target = default_target }));
34	macho_step.dependOn(testLargeBss(b, .{ .target = default_target }));	37	macho_step.dependOn(testLargeBss(b, .{ .target = default_target }));
35	macho_step.dependOn(testLayout(b, .{ .target = default_target }));	38	macho_step.dependOn(testLayout(b, .{ .target = default_target }));
		39	macho_step.dependOn(testLinkingStaticLib(b, .{ .target = default_target }));
36	macho_step.dependOn(testLinksection(b, .{ .target = default_target }));	40	macho_step.dependOn(testLinksection(b, .{ .target = default_target }));
37	macho_step.dependOn(testMhExecuteHeader(b, .{ .target = default_target }));	41	macho_step.dependOn(testMhExecuteHeader(b, .{ .target = default_target }));
38	macho_step.dependOn(testNoDeadStrip(b, .{ .target = default_target }));	42	macho_step.dependOn(testNoDeadStrip(b, .{ .target = default_target }));
...	@@ -843,6 +847,45 @@ fn testLinkDirectlyCppTbd(b: Build, opts: Options) Step {	...	@@ -843,6 +847,45 @@ fn testLinkDirectlyCppTbd(b: Build, opts: Options) Step {
843	return test_step;	847	return test_step;
844	}	848	}
845		849
		850	fn testLinkingStaticLib(b: Build, opts: Options) Step {
		851	const test_step = addTestStep(b, "linking-static-lib", opts);
		852
		853	const obj = addObject(b, opts, .{
		854	.name = "bobj",
		855	.zig_source_bytes = "export var bar: i32 = -42;",
		856	.strip = true, // TODO for self-hosted, we don't really emit any valid DWARF yet since we only export a global
		857	});
		858
		859	const lib = addStaticLibrary(b, opts, .{
		860	.name = "alib",
		861	.zig_source_bytes =
		862	\\export fn foo() i32 {
		863	\\ return 42;
		864	\\}
		865	,
		866	});
		867	lib.addObject(obj);
		868
		869	const exe = addExecutable(b, opts, .{
		870	.name = "testlib",
		871	.zig_source_bytes =
		872	\\const std = @import("std");
		873	\\extern fn foo() i32;
		874	\\extern var bar: i32;
		875	\\pub fn main() void {
		876	\\ std.debug.print("{d}\n", .{foo() + bar});
		877	\\}
		878	,
		879	});
		880	exe.linkLibrary(lib);
		881
		882	const run = addRunArtifact(exe);
		883	run.expectStdErrEqual("0\n");
		884	test_step.dependOn(&run.step);
		885
		886	return test_step;
		887	}
		888
846	fn testLinksection(b: Build, opts: Options) Step {	889	fn testLinksection(b: Build, opts: Options) Step {
847	const test_step = addTestStep(b, "macho-linksection", opts);	890	const test_step = addTestStep(b, "macho-linksection", opts);
848		891
...	@@ -1243,14 +1286,7 @@ fn testRelocatableZig(b: Build, opts: Options) Step {	...	@@ -1243,14 +1286,7 @@ fn testRelocatableZig(b: Build, opts: Options) Step {
1243	const run = addRunArtifact(exe);	1286	const run = addRunArtifact(exe);
1244	run.addCheck(.{ .expect_stderr_match = b.dupe("incrFoo=1") });	1287	run.addCheck(.{ .expect_stderr_match = b.dupe("incrFoo=1") });
1245	run.addCheck(.{ .expect_stderr_match = b.dupe("decrFoo=0") });	1288	run.addCheck(.{ .expect_stderr_match = b.dupe("decrFoo=0") });
1246	if (opts.use_llvm) {	1289	run.addCheck(.{ .expect_stderr_match = b.dupe("panic: Oh no!") });
1247	// TODO: enable this once self-hosted can print panics and stack traces
1248	run.addCheck(.{ .expect_stderr_match = b.dupe("panic: Oh no!") });
1249	}
1250	if (builtin.os.tag == .macos) {
1251	const signal: u32 = if (opts.use_llvm) std.os.darwin.SIG.ABRT else std.os.darwin.SIG.TRAP;
1252	run.addCheck(.{ .expect_term = .{ .Signal = signal } });
1253	}
1254	test_step.dependOn(&run.step);	1290	test_step.dependOn(&run.step);
1255		1291
1256	return test_step;	1292	return test_step;

...	@@ -193,8 +193,8 @@ pub fn flushStaticLib(macho_file: MachO, comp: Compilation, module_obj_path: ?	...	@@ -193,8 +193,8 @@ pub fn flushStaticLib(macho_file: MachO, comp: Compilation, module_obj_path: ?
193	// Update file offsets of contributing objects	193	// Update file offsets of contributing objects
194	const total_size: usize = blk: {	194	const total_size: usize = blk: {
195	var pos: usize = Archive.SARMAG;	195	var pos: usize = Archive.SARMAG;
196	pos += @sizeOf(Archive.ar_hdr) + Archive.SYMDEF.len + 1;	196	pos += @sizeOf(Archive.ar_hdr);
197	pos = mem.alignForward(usize, pos, ptr_width);	197	pos += mem.alignForward(usize, Archive.SYMDEF.len + 1, ptr_width);
198	pos += ar_symtab.size(format);	198	pos += ar_symtab.size(format);
199		199
200	for (files.items) \|index\| {	200	for (files.items) \|index\| {
...	@@ -209,10 +209,10 @@ pub fn flushStaticLib(macho_file: MachO, comp: Compilation, module_obj_path: ?	...	@@ -209,10 +209,10 @@ pub fn flushStaticLib(macho_file: MachO, comp: Compilation, module_obj_path: ?
209	.object => \|x\| x.path,	209	.object => \|x\| x.path,
210	else => unreachable,	210	else => unreachable,
211	};	211	};
212	pos = mem.alignForward(usize, pos, ptr_width);	212	pos = mem.alignForward(usize, pos, 2);
213	state.file_off = pos;	213	state.file_off = pos;
214	pos += @sizeOf(Archive.ar_hdr) + path.len + 1;	214	pos += @sizeOf(Archive.ar_hdr);
215	pos = mem.alignForward(usize, pos, ptr_width);	215	pos += mem.alignForward(usize, path.len + 1, ptr_width);
216	pos += math.cast(usize, state.size) orelse return error.Overflow;	216	pos += math.cast(usize, state.size) orelse return error.Overflow;
217	}	217	}
218		218
...	@@ -236,7 +236,7 @@ pub fn flushStaticLib(macho_file: MachO, comp: Compilation, module_obj_path: ?	...	@@ -236,7 +236,7 @@ pub fn flushStaticLib(macho_file: MachO, comp: Compilation, module_obj_path: ?
236		236
237	// Write object files	237	// Write object files
238	for (files.items) \|index\| {	238	for (files.items) \|index\| {
239	const aligned = mem.alignForward(usize, buffer.items.len, ptr_width);	239	const aligned = mem.alignForward(usize, buffer.items.len, 2);
240	const padding = aligned - buffer.items.len;	240	const padding = aligned - buffer.items.len;
241	if (padding > 0) {	241	if (padding > 0) {
242	try writer.writeByteNTimes(0, padding);	242	try writer.writeByteNTimes(0, padding);
...	@@ -402,7 +402,7 @@ fn calcSectionSizes(macho_file: *MachO) !void {	...	@@ -402,7 +402,7 @@ fn calcSectionSizes(macho_file: *MachO) !void {
402	const atom = macho_file.getAtom(atom_index) orelse continue;	402	const atom = macho_file.getAtom(atom_index) orelse continue;
403	if (!atom.flags.alive) continue;	403	if (!atom.flags.alive) continue;
404	const header = &macho_file.sections.items(.header)[atom.out_n_sect];	404	const header = &macho_file.sections.items(.header)[atom.out_n_sect];
405	if (!macho_file.isZigSection(atom.out_n_sect)) continue;	405	if (!macho_file.isZigSection(atom.out_n_sect) and !macho_file.isDebugSection(atom.out_n_sect)) continue;
406	header.nreloc += atom.calcNumRelocs(macho_file);	406	header.nreloc += atom.calcNumRelocs(macho_file);
407	}	407	}
408	}	408	}
...	@@ -436,18 +436,20 @@ fn calcCompactUnwindSize(macho_file: *MachO, sect_index: u8) void {	...	@@ -436,18 +436,20 @@ fn calcCompactUnwindSize(macho_file: *MachO, sect_index: u8) void {
436		436
437	fn allocateSections(macho_file: *MachO) !void {	437	fn allocateSections(macho_file: *MachO) !void {
438	const slice = macho_file.sections.slice();	438	const slice = macho_file.sections.slice();
439		439	for (slice.items(.header)) \|*header\| {
440	const last_index = for (0..slice.items(.header).len) \|i\| {	440	const needed_size = header.size;
441	if (macho_file.isZigSection(@intCast(i))) break i;	441	header.size = 0;
442	} else slice.items(.header).len;
443
444	for (slice.items(.header)[0..last_index]) \|*header\| {
445	const alignment = try math.powi(u32, 2, header.@"align");	442	const alignment = try math.powi(u32, 2, header.@"align");
446	if (!header.isZerofill()) {	443	if (!header.isZerofill()) {
447	header.offset = math.cast(u32, macho_file.findFreeSpace(header.size, alignment)) orelse	444	if (needed_size > macho_file.allocatedSize(header.offset)) {
448	return error.Overflow;	445	header.offset = math.cast(u32, macho_file.findFreeSpace(needed_size, alignment)) orelse
		446	return error.Overflow;
		447	}
		448	}
		449	if (needed_size > macho_file.allocatedSizeVirtual(header.addr)) {
		450	header.addr = macho_file.findFreeSpaceVirtual(needed_size, alignment);
449	}	451	}
450	header.addr = macho_file.findFreeSpaceVirtual(header.size, alignment);	452	header.size = needed_size;
451	}	453	}
452	}	454	}
453		455
...	@@ -539,7 +541,7 @@ fn writeAtoms(macho_file: *MachO) !void {	...	@@ -539,7 +541,7 @@ fn writeAtoms(macho_file: *MachO) !void {
539	for (slice.items(.header), slice.items(.atoms), 0..) \|header, atoms, i\| {	541	for (slice.items(.header), slice.items(.atoms), 0..) \|header, atoms, i\| {
540	if (atoms.items.len == 0) continue;	542	if (atoms.items.len == 0) continue;
541	if (header.isZerofill()) continue;	543	if (header.isZerofill()) continue;
542	if (macho_file.isZigSection(@intCast(i))) continue;	544	if (macho_file.isZigSection(@intCast(i)) or macho_file.isDebugSection(@intCast(i))) continue;
543		545
544	const size = math.cast(usize, header.size) orelse return error.Overflow;	546	const size = math.cast(usize, header.size) orelse return error.Overflow;
545	const code = try gpa.alloc(u8, size);	547	const code = try gpa.alloc(u8, size);
...	@@ -580,7 +582,7 @@ fn writeAtoms(macho_file: *MachO) !void {	...	@@ -580,7 +582,7 @@ fn writeAtoms(macho_file: *MachO) !void {
580		582
581	for (macho_file.sections.items(.header), 0..) \|header, n_sect\| {	583	for (macho_file.sections.items(.header), 0..) \|header, n_sect\| {
582	if (header.isZerofill()) continue;	584	if (header.isZerofill()) continue;
583	if (!macho_file.isZigSection(@intCast(n_sect))) continue;	585	if (!macho_file.isZigSection(@intCast(n_sect)) and !macho_file.isDebugSection(@intCast(n_sect))) continue;
584	const gop = try relocs.getOrPut(@intCast(n_sect));	586	const gop = try relocs.getOrPut(@intCast(n_sect));
585	if (gop.found_existing) continue;	587	if (gop.found_existing) continue;
586	gop.value_ptr.* = try std.ArrayList(macho.relocation_info).initCapacity(gpa, header.nreloc);	588	gop.value_ptr.* = try std.ArrayList(macho.relocation_info).initCapacity(gpa, header.nreloc);
...	@@ -591,7 +593,7 @@ fn writeAtoms(macho_file: *MachO) !void {	...	@@ -591,7 +593,7 @@ fn writeAtoms(macho_file: *MachO) !void {
591	if (!atom.flags.alive) continue;	593	if (!atom.flags.alive) continue;
592	const header = macho_file.sections.items(.header)[atom.out_n_sect];	594	const header = macho_file.sections.items(.header)[atom.out_n_sect];
593	if (header.isZerofill()) continue;	595	if (header.isZerofill()) continue;
594	if (!macho_file.isZigSection(atom.out_n_sect)) continue;	596	if (!macho_file.isZigSection(atom.out_n_sect) and !macho_file.isDebugSection(atom.out_n_sect)) continue;
595	if (atom.getRelocs(macho_file).len == 0) continue;	597	if (atom.getRelocs(macho_file).len == 0) continue;
596	const atom_size = math.cast(usize, atom.size) orelse return error.Overflow;	598	const atom_size = math.cast(usize, atom.size) orelse return error.Overflow;
597	const code = try gpa.alloc(u8, atom_size);	599	const code = try gpa.alloc(u8, atom_size);