Commit 174de37cefde3b22b02fee5982e7bacead4d200f | zig

author	Jakub Konka <kubkon@jakubkonka.com> 2024-07-10 16:36:32+02:00
committer	Jakub Konka <kubkon@jakubkonka.com> 2024-07-18 09:13:08+02:00
log	174de37cefde3b22b02fee5982e7bacead4d200f
tree	de8e99729e11de1b9116ebd3da5077ad722d9993
parent	5b4c0cc1f9c4cb047064cffb70bc649b83681814

macho: fix compile errors

17 files changed, 352 insertions(+), 281 deletions(-)

src
- arch
  - x86_64
    CodeGen.zig
    Emit.zig
- link
  - MachO.zig
  - MachO
    Atom.zig
    DebugSymbols.zig
    Dylib.zig
    InternalObject.zig
    Object.zig
    Symbol.zig
    UnwindInfo.zig
    ZigObject.zig
    dyld_info
    Rebase.zig
    Trie.zig
    bind.zig
    file.zig
    synthetic.zig
    thunks.zig

src/arch/x86_64/CodeGen.zig+6-4

 @@ -12362,8 +12362,9 @@ fn genCall(self: *Self, info: union(enum) {
                         try self.genSetReg(.rax, Type.usize, .{ .lea_got = sym_index }, .{});
                         try self.asmRegister(.{ ._, .call }, .rax);
                     } else if (self.bin_file.cast(link.File.MachO)) |macho_file| {
-                        const sym_index = try macho_file.getZigObject().?.getOrCreateMetadataForDecl(macho_file, func.owner_decl);
+                        const zo = macho_file.getZigObject().?;
-                        const sym = macho_file.getSymbol(sym_index);
+                        const sym_index = try zo.getOrCreateMetadataForDecl(macho_file, func.owner_decl);
+                        const sym = zo.symbols.items[sym_index];
                         try self.genSetReg(
                             .rax,
                             Type.usize,
 @@ -15396,9 +15397,10 @@ fn genLazySymbolRef(
             else => unreachable,
         }
     } else if (self.bin_file.cast(link.File.MachO)) |macho_file| {
-        const sym_index = macho_file.getZigObject().?.getOrCreateMetadataForLazySymbol(macho_file, pt, lazy_sym) catch |err|
+        const zo = macho_file.getZigObject().?;
+        const sym_index = zo.getOrCreateMetadataForLazySymbol(macho_file, pt, lazy_sym) catch |err|
             return self.fail("{s} creating lazy symbol", .{@errorName(err)});
-        const sym = macho_file.getSymbol(sym_index);
+        const sym = zo.symbols.items[sym_index];
         switch (tag) {
             .lea, .call => try self.genSetReg(
                 reg,

src/arch/x86_64/Emit.zig+1-1

...	@@ -162,7 +162,7 @@ pub fn emitMir(emit: *Emit) Error!void {	...	@@ -162,7 +162,7 @@ pub fn emitMir(emit: *Emit) Error!void {
162	};	162	};
163	const zo = macho_file.getZigObject().?;	163	const zo = macho_file.getZigObject().?;
164	const atom = zo.symbols.items[data.atom_index].getAtom(macho_file).?;	164	const atom = zo.symbols.items[data.atom_index].getAtom(macho_file).?;
165	const sym = zo.symbols.items[data.sym_index];	165	const sym = &zo.symbols.items[data.sym_index];
166	if (sym.flags.needs_zig_got and !is_obj_or_static_lib) {	166	if (sym.flags.needs_zig_got and !is_obj_or_static_lib) {
167	_ = try sym.getOrCreateZigGotEntry(data.sym_index, macho_file);	167	_ = try sym.getOrCreateZigGotEntry(data.sym_index, macho_file);
168	}	168	}

src/link/MachO.zig+36-29

 @@ -529,7 +529,7 @@ pub fn flushModule(self: *MachO, arena: Allocator, tid: Zcu.PerThread.Id, prog_n
         dylib.ordinal = @intCast(ord);
     }
-    try self.claimUnresolved();
+    self.claimUnresolved();
     self.scanRelocs() catch |err| switch (err) {
         error.HasUndefinedSymbols => return error.FlushFailure,
 @@ -603,7 +603,12 @@ pub fn flushModule(self: *MachO, arena: Allocator, tid: Zcu.PerThread.Id, prog_n
         if (has_resolve_error) return error.FlushFailure;
     }
-    try self.writeSectionsAndUpdateLinkeditSizes();
+    self.writeSectionsAndUpdateLinkeditSizes() catch |err| {
+        switch (err) {
+            error.ResolveFailed => return error.FlushFailure,
+            else => |e| return e,
+        }
+    };
     try self.writeSectionsToFile();
     try self.allocateLinkeditSegment();
 @@ -1450,12 +1455,12 @@ pub fn dedupLiterals(self: *MachO) !void {
     }
 }
-fn claimUnresolved(self: *MachO) error{OutOfMemory}!void {
+fn claimUnresolved(self: *MachO) void {
     if (self.getZigObject()) |zo| {
-        try zo.asFile().claimUnresolved(self);
+        zo.claimUnresolved(self);
     }
     for (self.objects.items) |index| {
-        try self.getFile(index).?.claimUnresolved(self);
+        self.getFile(index).?.object.claimUnresolved(self);
     }
 }
 @@ -2402,7 +2407,7 @@ fn writeSectionsAndUpdateLinkeditSizes(self: *MachO) !void {
     }
     if (self.la_symbol_ptr_sect_index) |_| {
-        try self.updatelazyBindSize();
+        try self.updateLazyBindSize();
     }
     try self.rebase.updateSize(self);
 @@ -2412,16 +2417,16 @@ fn writeSectionsAndUpdateLinkeditSizes(self: *MachO) !void {
     try self.data_in_code.updateSize(self);
     if (self.getZigObject()) |zo| {
-        zo.asFile().writeSymtab(self);
+        zo.asFile().writeSymtab(self, self);
     }
     for (self.objects.items) |index| {
-        self.getFile(index).?.writeSymtab(self);
+        self.getFile(index).?.writeSymtab(self, self);
     }
     for (self.dylibs.items) |index| {
-        self.getFile(index).?.writeSymtab(self);
+        self.getFile(index).?.writeSymtab(self, self);
     }
     if (self.getInternalObject()) |obj| {
-        obj.asFile().writeSymtab(self);
+        obj.asFile().writeSymtab(self, self);
     }
 }
 @@ -2484,7 +2489,7 @@ fn writeSectionsToFile(self: *MachO) !void {
     const slice = self.sections.slice();
     for (slice.items(.header), slice.items(.out)) |header, out| {
-        try self.base.file.pwriteAll(out.items, header.offset);
+        try self.base.file.?.pwriteAll(out.items, header.offset);
     }
 }
 @@ -2501,7 +2506,7 @@ fn writeDyldInfo(self: *MachO) !void {
     const tracy = trace(@src());
     defer tracy.end();
-    const gpa = self.base.allocator;
+    const gpa = self.base.comp.gpa;
     const base_off = self.getLinkeditSegment().fileoff;
     const cmd = self.dyld_info_cmd;
     var needed_size: u32 = 0;
 @@ -2527,14 +2532,14 @@ fn writeDyldInfo(self: *MachO) !void {
     try self.lazy_bind.write(writer);
     try stream.seekTo(cmd.export_off - base_off);
     try self.export_trie.write(writer);
-    try self.base.file.pwriteAll(buffer, cmd.rebase_off);
+    try self.base.file.?.pwriteAll(buffer, cmd.rebase_off);
 }
 pub fn writeDataInCode(self: *MachO) !void {
     const tracy = trace(@src());
     defer tracy.end();
     const cmd = self.data_in_code_cmd;
-    try self.base.file.pwriteAll(mem.sliceAsBytes(self.data_in_code.entries.items), cmd.dataoff);
+    try self.base.file.?.pwriteAll(mem.sliceAsBytes(self.data_in_code.entries.items), cmd.dataoff);
 }
 fn writeIndsymtab(self: *MachO) !void {
 @@ -2546,15 +2551,15 @@ fn writeIndsymtab(self: *MachO) !void {
     var buffer = try std.ArrayList(u8).initCapacity(gpa, needed_size);
     defer buffer.deinit();
     try self.indsymtab.write(self, buffer.writer());
-    try self.base.file.pwriteAll(buffer.items, cmd.indirectsymoff);
+    try self.base.file.?.pwriteAll(buffer.items, cmd.indirectsymoff);
 }
 pub fn writeSymtabToFile(self: *MachO) !void {
     const tracy = trace(@src());
     defer tracy.end();
     const cmd = self.symtab_cmd;
-    try self.base.file.pwriteAll(mem.sliceAsBytes(self.symtab.items), cmd.symoff);
+    try self.base.file.?.pwriteAll(mem.sliceAsBytes(self.symtab.items), cmd.symoff);
-    try self.base.file.pwriteAll(self.strtab.items, cmd.stroff);
+    try self.base.file.?.pwriteAll(self.strtab.items, cmd.stroff);
 }
 fn writeUnwindInfo(self: *MachO) !void {
 @@ -2687,18 +2692,20 @@ fn writeLoadCommands(self: *MachO) !struct { usize, usize, u64 } {
     try load_commands.writeDylinkerLC(writer);
     ncmds += 1;
-    if (self.entry_index) |global_index| {
+    if (self.getInternalObject()) |obj| {
-        const sym = self.getSymbol(global_index);
+        if (obj.getEntryRef(self)) |ref| {
-        const seg = self.getTextSegment();
+            const sym = ref.getSymbol(self).?;
-        const entryoff: u32 = if (sym.getFile(self) == null)
+            const seg = self.getTextSegment();
-            0
+            const entryoff: u32 = if (sym.getFile(self) == null)
-        else
+                0
-            @as(u32, @intCast(sym.getAddress(.{ .stubs = true }, self) - seg.vmaddr));
+            else
-        try writer.writeStruct(macho.entry_point_command{
+                @as(u32, @intCast(sym.getAddress(.{ .stubs = true }, self) - seg.vmaddr));
-            .entryoff = entryoff,
+            try writer.writeStruct(macho.entry_point_command{
-            .stacksize = self.base.stack_size,
+                .entryoff = entryoff,
-        });
+                .stacksize = self.base.stack_size,
-        ncmds += 1;
+            });
+            ncmds += 1;
+        }
     }
     if (self.base.isDynLib()) {

src/link/MachO/Atom.zig+19-15

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

 @@ -175,8 +175,9 @@ fn findFreeSpace(self: *DebugSymbols, object_size: u64, min_alignment: u64) u64
 }
 pub fn flushModule(self: *DebugSymbols, macho_file: *MachO) !void {
+    const zo = macho_file.getZigObject().?;
     for (self.relocs.items) |*reloc| {
-        const sym = macho_file.getSymbol(reloc.target);
+        const sym = zo.symbols.items[reloc.target];
         const sym_name = sym.getName(macho_file);
         const addr = switch (reloc.type) {
             .direct_load => sym.getAddress(.{}, macho_file),
 @@ -382,23 +383,22 @@ pub fn writeSymtab(self: *DebugSymbols, off: u32, macho_file: *MachO) !u32 {
     cmd.symoff = off;
     try self.symtab.resize(gpa, cmd.nsyms);
-    try self.strtab.ensureUnusedCapacity(gpa, cmd.strsize - 1);
+    try self.strtab.resize(gpa, cmd.strsize);
+    self.strtab.items[0] = 0;
     if (macho_file.getZigObject()) |zo| {
         zo.writeSymtab(macho_file, self);
     }
     for (macho_file.objects.items) |index| {
-        try macho_file.getFile(index).?.writeSymtab(macho_file, self);
+        macho_file.getFile(index).?.writeSymtab(macho_file, self);
     }
     for (macho_file.dylibs.items) |index| {
-        try macho_file.getFile(index).?.writeSymtab(macho_file, self);
+        macho_file.getFile(index).?.writeSymtab(macho_file, self);
     }
     if (macho_file.getInternalObject()) |internal| {
         internal.writeSymtab(macho_file, self);
     }
-    assert(self.strtab.items.len == cmd.strsize);
     try self.file.pwriteAll(mem.sliceAsBytes(self.symtab.items), cmd.symoff);
     return off + cmd.nsyms * @sizeOf(macho.nlist_64);

src/link/MachO/Dylib.zig+15-9

 @@ -6,7 +6,7 @@ strtab: std.ArrayListUnmanaged(u8) = .{},
 id: ?Id = null,
 ordinal: u16 = 0,
-symbols: std.ArrayListUnmanaged(Symbol.Index) = .{},
+symbols: std.ArrayListUnmanaged(Symbol) = .{},
 symbols_extra: std.ArrayListUnmanaged(u32) = .{},
 globals: std.ArrayListUnmanaged(MachO.SymbolResolver.Index) = .{},
 dependents: std.ArrayListUnmanaged(Id) = .{},
 @@ -516,7 +516,7 @@ pub fn initSymbols(self: *Dylib, macho_file: *MachO) !void {
     }
 }
-pub fn resolveSymbols(self: *Dylib, macho_file: *MachO) void {
+pub fn resolveSymbols(self: *Dylib, macho_file: *MachO) !void {
     const tracy = trace(@src());
     defer tracy.end();
 @@ -584,7 +584,7 @@ pub fn calcSymtabSize(self: *Dylib, macho_file: *MachO) void {
     }
 }
-pub fn writeSymtab(self: Dylib, macho_file: *MachO) void {
+pub fn writeSymtab(self: Dylib, macho_file: *MachO, ctx: anytype) void {
     const tracy = trace(@src());
     defer tracy.end();
 @@ -594,13 +594,13 @@ pub fn writeSymtab(self: Dylib, macho_file: *MachO) void {
         const file = ref.getFile(macho_file) orelse continue;
         if (file.getIndex() != self.index) continue;
         const idx = sym.getOutputSymtabIndex(macho_file) orelse continue;
-        const out_sym = &macho_file.symtab.items[idx];
+        const out_sym = &ctx.symtab.items[idx];
         out_sym.n_strx = n_strx;
         sym.setOutputSym(macho_file, out_sym);
         const name = sym.getName(macho_file);
-        @memcpy(macho_file.strtab.items[n_strx..][0..name.len], name);
+        @memcpy(ctx.strtab.items[n_strx..][0..name.len], name);
         n_strx += @intCast(name.len);
-        macho_file.strtab.items[n_strx] = 0;
+        ctx.strtab.items[n_strx] = 0;
         n_strx += 1;
     }
 }
 @@ -718,10 +718,16 @@ fn formatSymtab(
     _ = unused_fmt_string;
     _ = options;
     const dylib = ctx.dylib;
+    const macho_file = ctx.macho_file;
     try writer.writeAll("  globals\n");
-    for (dylib.symbols.items) |index| {
+    for (dylib.symbols.items, 0..) |sym, i| {
-        const global = ctx.macho_file.getSymbol(index);
+        const ref = dylib.getSymbolRef(@intCast(i), macho_file);
-        try writer.print("    {}\n", .{global.fmt(ctx.macho_file)});
+        if (ref.getFile(macho_file) == null) {
+            // TODO any better way of handling this?
+            try writer.print("    {s} : unclaimed\n", .{sym.getName(macho_file)});
+        } else {
+            try writer.print("    {}\n", .{ref.getSymbol(macho_file).?.fmt(macho_file)});
+        }
     }
 }

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

src/link/MachO/Object.zig+138-116

 @@ -11,10 +11,10 @@ sections: std.MultiArrayList(Section) = .{},
 symtab: std.MultiArrayList(Nlist) = .{},
 strtab: std.ArrayListUnmanaged(u8) = .{},
-symbols: std.ArrayListUnmanaged(Symbol.Index) = .{},
+symbols: std.ArrayListUnmanaged(Symbol) = .{},
 symbols_extra: std.ArrayListUnmanaged(u32) = .{},
 globals: std.ArrayListUnmanaged(MachO.SymbolResolver.Index) = .{},
-atoms: std.ArrayListUnmanaged(Atom.Index) = .{},
+atoms: std.ArrayListUnmanaged(Atom) = .{},
 atoms_indexes: std.ArrayListUnmanaged(Atom.Index) = .{},
 atoms_extra: std.ArrayListUnmanaged(u32) = .{},
 @@ -228,7 +228,7 @@ pub fn parse(self: *Object, macho_file: *MachO) !void {
     // Parse DWARF __TEXT,__eh_frame section
     if (self.eh_frame_sect_index) |index| {
-        try self.initEhFrameRecords(index, macho_file);
+        try self.initEhFrameRecords(gpa, index, handle, macho_file);
     }
     // Parse Apple's __LD,__compact_unwind section
 @@ -261,7 +261,7 @@ pub fn parse(self: *Object, macho_file: *MachO) !void {
     try self.parseDebugInfo(macho_file);
-    for (self.atoms.items) |atom_index| {
+    for (self.getAtoms()) |atom_index| {
         const atom = self.getAtom(atom_index) orelse continue;
         const isec = atom.getInputSection(macho_file);
         if (mem.eql(u8, isec.sectName(), "__eh_frame") or
 @@ -606,7 +606,7 @@ fn initPointerLiterals(self: *Object, allocator: Allocator, macho_file: *MachO)
     }
 }
-pub fn resolveLiterals(self: Object, lp: *MachO.LiteralPool, macho_file: *MachO) !void {
+pub fn resolveLiterals(self: *Object, lp: *MachO.LiteralPool, macho_file: *MachO) !void {
     const tracy = trace(@src());
     defer tracy.end();
 @@ -646,7 +646,7 @@ pub fn resolveLiterals(self: Object, lp: *MachO.LiteralPool, macho_file: *MachO)
                 } else {
                     const lp_sym = lp.getSymbol(res.index, macho_file);
                     const lp_atom = lp_sym.getAtom(macho_file).?;
-                    lp_atom.alignment = @max(lp_atom.alignment, atom.alignment);
+                    lp_atom.alignment = lp_atom.alignment.max(atom.alignment);
                     atom.flags.alive = false;
                 }
                 atom.addExtra(.{ .literal_pool_index = res.index }, macho_file);
 @@ -684,7 +684,7 @@ pub fn resolveLiterals(self: Object, lp: *MachO.LiteralPool, macho_file: *MachO)
                 } else {
                     const lp_sym = lp.getSymbol(res.index, macho_file);
                     const lp_atom = lp_sym.getAtom(macho_file).?;
-                    lp_atom.alignment = @max(lp_atom.alignment, atom.alignment);
+                    lp_atom.alignment = lp_atom.alignment.max(atom.alignment);
                     atom.flags.alive = false;
                 }
                 atom.addExtra(.{ .literal_pool_index = res.index }, macho_file);
 @@ -823,7 +823,7 @@ fn initSymbols(self: *Object, allocator: Allocator, macho_file: *MachO) !void {
         const index = self.addSymbolAssumeCapacity();
         const symbol = &self.symbols.items[index];
         symbol.value = nlist.n_value;
-        symbol.name = .{ .pos = nlist.n_strx, .len = @intCast(self.getNStrx(nlist.n_strx).len + 1) };
+        symbol.name = nlist.n_strx;
         symbol.nlist_idx = @intCast(i);
         symbol.extra = self.addSymbolExtraAssumeCapacity(.{});
 @@ -838,7 +838,9 @@ fn initSymbols(self: *Object, allocator: Allocator, macho_file: *MachO) !void {
         symbol.flags.tentative = nlist.tentative();
         symbol.flags.no_dead_strip = symbol.flags.no_dead_strip or nlist.noDeadStrip();
         symbol.flags.dyn_ref = nlist.n_desc & macho.REFERENCED_DYNAMICALLY != 0;
-        symbol.flags.interposable = nlist.ext() and (nlist.sect() or nlist.abs()) and macho_file.options.dylib and macho_file.options.namespace == .flat and !nlist.pext();
+        symbol.flags.interposable = nlist.ext() and (nlist.sect() or nlist.abs()) and macho_file.base.isDynLib() and !nlist.pext();
+        // TODO
+        // symbol.flags.interposable = nlist.ext() and (nlist.sect() or nlist.abs()) and macho_file.base.isDynLib() and macho_file.options.namespace == .flat and !nlist.pext();
         if (nlist.sect() and
             self.sections.items(.header)[nlist.n_sect - 1].type() == macho.S_THREAD_LOCAL_VARIABLES)
 @@ -869,7 +871,7 @@ fn initSymbolStabs(self: *Object, allocator: Allocator, nlists: anytype, macho_f
         fn find(fs: @This(), addr: u64) ?Symbol.Index {
             // TODO binary search since we have the list sorted
             for (fs.entries) |nlist| {
-                if (nlist.nlist.n_value == addr) return fs.ctx.symbols.items[nlist.idx];
+                if (nlist.nlist.n_value == addr) return @intCast(nlist.idx);
             }
             return null;
         }
 @@ -920,17 +922,17 @@ fn initSymbolStabs(self: *Object, allocator: Allocator, nlists: anytype, macho_f
             switch (nlist.n_type) {
                 macho.N_BNSYM => {
                     stab.is_func = true;
-                    stab.symbol = sym_lookup.find(nlist.n_value);
+                    stab.index = sym_lookup.find(nlist.n_value);
                     // TODO validate
                     i += 3;
                 },
                 macho.N_GSYM => {
                     stab.is_func = false;
-                    stab.symbol = sym_lookup.find(addr_lookup.get(self.getString(nlist.n_strx)).?);
+                    stab.index = sym_lookup.find(addr_lookup.get(self.getString(nlist.n_strx)).?);
                 },
                 macho.N_STSYM => {
                     stab.is_func = false;
-                    stab.symbol = sym_lookup.find(nlist.n_value);
+                    stab.index = sym_lookup.find(nlist.n_value);
                 },
                 else => {
                     try macho_file.reportParseError2(self.index, "unhandled symbol stab type 0x{x}", .{
 @@ -1103,9 +1105,9 @@ fn initUnwindRecords(self: *Object, allocator: Allocator, sect_id: u8, file: Fil
         ctx: *const Object,
         fn find(fs: @This(), addr: u64) ?Symbol.Index {
-            for (fs.ctx.symbols.items, 0..) |sym_index, i| {
+            for (0..fs.ctx.symbols.items.len) |i| {
                 const nlist = fs.ctx.symtab.items(.nlist)[i];
-                if (nlist.ext() and nlist.n_value == addr) return sym_index;
+                if (nlist.ext() and nlist.n_value == addr) return @intCast(i);
             }
             return null;
         }
 @@ -1274,7 +1276,7 @@ fn parseUnwindRecords(self: *Object, allocator: Allocator, cpu_arch: std.Target.
             // Create a null record
             const rec_index = try self.addUnwindRecord(allocator);
             const rec = self.getUnwindRecord(rec_index);
-            const atom = macho_file.getAtom(meta.atom).?;
+            const atom = self.getAtom(meta.atom).?;
             try self.unwind_records_indexes.append(allocator, rec_index);
             rec.length = @intCast(meta.size);
             rec.atom = meta.atom;
 @@ -1468,17 +1470,17 @@ fn findCompileUnit(self: *Object, args: struct {
     };
 }
-pub fn resolveSymbols(self: *Object, macho_file: *MachO) void {
+pub fn resolveSymbols(self: *Object, macho_file: *MachO) !void {
     const tracy = trace(@src());
     defer tracy.end();
-    const gpa = macho_file.base.allocator;
+    const gpa = macho_file.base.comp.gpa;
     for (self.symtab.items(.nlist), self.symtab.items(.atom), self.globals.items, 0..) |nlist, atom_index, *global, i| {
         if (!nlist.ext()) continue;
         if (nlist.sect()) {
             const atom = self.getAtom(atom_index).?;
-            if (!atom.alive.load(.seq_cst)) continue;
+            if (!atom.flags.alive) continue;
         }
         const gop = try macho_file.resolver.getOrPut(gpa, .{
 @@ -1643,7 +1645,7 @@ pub fn claimUnresolved(self: *Object, macho_file: *MachO) void {
         if (self.getSymbolRef(@intCast(i), macho_file).getFile(macho_file) != null) continue;
-        const is_import = switch (macho_file.options.undefined_treatment) {
+        const is_import = switch (macho_file.undefined_treatment) {
             .@"error" => false,
             .warn, .suppress => nlist.weakRef(),
             .dynamic_lookup => true,
 @@ -1682,8 +1684,8 @@ pub fn claimUnresolvedRelocatable(self: *Object, macho_file: *MachO) void {
     }
 }
-fn addSection(self: *Object, allocator: Allocator, segname: []const u8, sectname: []const u8) !u32 {
+fn addSection(self: *Object, allocator: Allocator, segname: []const u8, sectname: []const u8) !u8 {
-    const n_sect = @as(u32, @intCast(try self.sections.addOne(allocator)));
+    const n_sect = @as(u8, @intCast(try self.sections.addOne(allocator)));
     self.sections.set(n_sect, .{
         .header = .{
             .sectname = MachO.makeStaticString(sectname),
 @@ -1799,7 +1801,7 @@ pub fn writeAr(self: Object, ar_format: Archive.Format, macho_file: *MachO, writ
     try writer.writeAll(data);
 }
-pub fn calcSymtabSize(self: *Object, macho_file: *MachO) !void {
+pub fn calcSymtabSize(self: *Object, macho_file: *MachO) void {
     const tracy = trace(@src());
     defer tracy.end();
 @@ -1821,27 +1823,27 @@ pub fn calcSymtabSize(self: *Object, macho_file: *MachO) !void {
             continue;
         sym.flags.output_symtab = true;
         if (sym.isLocal()) {
-            try sym.addExtra(.{ .symtab = self.output_symtab_ctx.nlocals }, macho_file);
+            sym.addExtra(.{ .symtab = self.output_symtab_ctx.nlocals }, macho_file);
             self.output_symtab_ctx.nlocals += 1;
         } else if (sym.flags.@"export") {
-            try sym.addExtra(.{ .symtab = self.output_symtab_ctx.nexports }, macho_file);
+            sym.addExtra(.{ .symtab = self.output_symtab_ctx.nexports }, macho_file);
             self.output_symtab_ctx.nexports += 1;
         } else {
             assert(sym.flags.import);
-            try sym.addExtra(.{ .symtab = self.output_symtab_ctx.nimports }, macho_file);
+            sym.addExtra(.{ .symtab = self.output_symtab_ctx.nimports }, macho_file);
             self.output_symtab_ctx.nimports += 1;
         }
         self.output_symtab_ctx.strsize += @as(u32, @intCast(sym.getName(macho_file).len + 1));
     }
     if (macho_file.base.comp.config.debug_format != .strip and self.hasDebugInfo())
-        try self.calcStabsSize(macho_file);
+        self.calcStabsSize(macho_file);
 }
-pub fn calcStabsSize(self: *Object, macho_file: *MachO) error{Overflow}!void {
+pub fn calcStabsSize(self: *Object, macho_file: *MachO) void {
     if (self.compile_unit) |cu| {
-        const comp_dir = cu.getCompDir(self);
+        const comp_dir = cu.getCompDir(self.*);
-        const tu_name = cu.getTuName(self);
+        const tu_name = cu.getTuName(self.*);
         self.output_symtab_ctx.nstabs += 4; // N_SO, N_SO, N_OSO, N_SO
         self.output_symtab_ctx.strsize += @as(u32, @intCast(comp_dir.len + 1)); // comp_dir
 @@ -1876,12 +1878,12 @@ pub fn calcStabsSize(self: *Object, macho_file: *MachO) error{Overflow}!void {
         for (self.stab_files.items) |sf| {
             self.output_symtab_ctx.nstabs += 4; // N_SO, N_SO, N_OSO, N_SO
-            self.output_symtab_ctx.strsize += @as(u32, @intCast(sf.getCompDir(self).len + 1)); // comp_dir
+            self.output_symtab_ctx.strsize += @as(u32, @intCast(sf.getCompDir(self.*).len + 1)); // comp_dir
-            self.output_symtab_ctx.strsize += @as(u32, @intCast(sf.getTuName(self).len + 1)); // tu_name
+            self.output_symtab_ctx.strsize += @as(u32, @intCast(sf.getTuName(self.*).len + 1)); // tu_name
-            self.output_symtab_ctx.strsize += @as(u32, @intCast(sf.getOsoPath(self).len + 1)); // path
+            self.output_symtab_ctx.strsize += @as(u32, @intCast(sf.getOsoPath(self.*).len + 1)); // path
             for (sf.stabs.items) |stab| {
-                const sym = stab.getSymbol(macho_file) orelse continue;
+                const sym = stab.getSymbol(self.*) orelse continue;
                 const file = sym.getFile(macho_file).?;
                 if (file.getIndex() != self.index) continue;
                 if (!sym.flags.output_symtab) continue;
 @@ -2065,7 +2067,7 @@ pub fn writeCompactUnwindRelocatable(self: *Object, macho_file: *MachO) !void {
     }
 }
-pub fn writeSymtab(self: Object, macho_file: *MachO) void {
+pub fn writeSymtab(self: Object, macho_file: *MachO, ctx: anytype) void {
     const tracy = trace(@src());
     defer tracy.end();
 @@ -2075,21 +2077,21 @@ pub fn writeSymtab(self: Object, macho_file: *MachO) void {
         const file = ref.getFile(macho_file) orelse continue;
         if (file.getIndex() != self.index) continue;
         const idx = sym.getOutputSymtabIndex(macho_file) orelse continue;
-        const out_sym = &macho_file.symtab.items[idx];
+        const out_sym = &ctx.symtab.items[idx];
         out_sym.n_strx = n_strx;
         sym.setOutputSym(macho_file, out_sym);
         const name = sym.getName(macho_file);
-        @memcpy(macho_file.strtab.items[n_strx..][0..name.len], name);
+        @memcpy(ctx.strtab.items[n_strx..][0..name.len], name);
         n_strx += @intCast(name.len);
-        macho_file.strtab.items[n_strx] = 0;
+        ctx.strtab.items[n_strx] = 0;
         n_strx += 1;
     }
     if (macho_file.base.comp.config.debug_format != .strip and self.hasDebugInfo())
-        try self.writeStabs(n_strx, macho_file);
+        self.writeStabs(n_strx, macho_file, ctx);
 }
-pub fn writeStabs(self: *const Object, stroff: u32, macho_file: *MachO) void {
+pub fn writeStabs(self: Object, stroff: u32, macho_file: *MachO, ctx: anytype) void {
     const writeFuncStab = struct {
         inline fn writeFuncStab(
             n_strx: u32,
 @@ -2097,7 +2099,7 @@ pub fn writeStabs(self: *const Object, stroff: u32, macho_file: *MachO) void {
             n_value: u64,
             size: u64,
             index: u32,
-            context: *MachO,
+            context: anytype,
         ) void {
             context.symtab.items[index] = .{
                 .n_strx = 0,
 @@ -2139,7 +2141,7 @@ pub fn writeStabs(self: *const Object, stroff: u32, macho_file: *MachO) void {
         // Open scope
         // N_SO comp_dir
-        macho_file.symtab.items[index] = .{
+        ctx.symtab.items[index] = .{
             .n_strx = n_strx,
             .n_type = macho.N_SO,
             .n_sect = 0,
 @@ -2147,9 +2149,9 @@ pub fn writeStabs(self: *const Object, stroff: u32, macho_file: *MachO) void {
             .n_value = 0,
         };
         index += 1;
-        @memcpy(macho_file.strtab.items[n_strx..][0..comp_dir.len], comp_dir);
+        @memcpy(ctx.strtab.items[n_strx..][0..comp_dir.len], comp_dir);
         n_strx += @intCast(comp_dir.len);
-        macho_file.strtab.items[n_strx] = 0;
+        ctx.strtab.items[n_strx] = 0;
         n_strx += 1;
         // N_SO tu_name
         macho_file.symtab.items[index] = .{
 @@ -2160,12 +2162,12 @@ pub fn writeStabs(self: *const Object, stroff: u32, macho_file: *MachO) void {
             .n_value = 0,
         };
         index += 1;
-        @memcpy(macho_file.strtab.items[n_strx..][0..tu_name.len], tu_name);
+        @memcpy(ctx.strtab.items[n_strx..][0..tu_name.len], tu_name);
         n_strx += @intCast(tu_name.len);
-        macho_file.strtab.items[n_strx] = 0;
+        ctx.strtab.items[n_strx] = 0;
         n_strx += 1;
         // N_OSO path
-        macho_file.symtab.items[index] = .{
+        ctx.symtab.items[index] = .{
             .n_strx = n_strx,
             .n_type = macho.N_OSO,
             .n_sect = 0,
 @@ -2174,20 +2176,20 @@ pub fn writeStabs(self: *const Object, stroff: u32, macho_file: *MachO) void {
         };
         index += 1;
         if (self.in_archive) |ar| {
-            @memcpy(macho_file.strtab.items[n_strx..][0..ar.path.len], ar.path);
+            @memcpy(ctx.strtab.items[n_strx..][0..ar.path.len], ar.path);
             n_strx += @intCast(ar.path.len);
-            macho_file.strtab.items[n_strx] = '(';
+            ctx.strtab.items[n_strx] = '(';
             n_strx += 1;
-            @memcpy(macho_file.strtab.items[n_strx..][0..self.path.len], self.path);
+            @memcpy(ctx.strtab.items[n_strx..][0..self.path.len], self.path);
             n_strx += @intCast(self.path.len);
-            macho_file.strtab.items[n_strx] = ')';
+            ctx.strtab.items[n_strx] = ')';
             n_strx += 1;
-            macho_file.strtab.items[n_strx] = 0;
+            ctx.strtab.items[n_strx] = 0;
             n_strx += 1;
         } else {
-            @memcpy(macho_file.strtab.items[n_strx..][0..self.path.len], self.path);
+            @memcpy(ctx.strtab.items[n_strx..][0..self.path.len], self.path);
             n_strx += @intCast(self.path.len);
-            macho_file.strtab.items[n_strx] = 0;
+            ctx.strtab.items[n_strx] = 0;
             n_strx += 1;
         }
 @@ -2203,17 +2205,17 @@ pub fn writeStabs(self: *const Object, stroff: u32, macho_file: *MachO) void {
             const sect = macho_file.sections.items(.header)[sym.getOutputSectionIndex(macho_file)];
             const sym_n_strx = n_strx: {
                 const symtab_index = sym.getOutputSymtabIndex(macho_file).?;
-                const osym = macho_file.symtab.items[symtab_index];
+                const osym = ctx.symtab.items[symtab_index];
                 break :n_strx osym.n_strx;
             };
             const sym_n_sect: u8 = if (!sym.flags.abs) @intCast(sym.getOutputSectionIndex(macho_file) + 1) else 0;
             const sym_n_value = sym.getAddress(.{}, macho_file);
             const sym_size = sym.getSize(macho_file);
             if (sect.isCode()) {
-                writeFuncStab(sym_n_strx, sym_n_sect, sym_n_value, sym_size, index, macho_file);
+                writeFuncStab(sym_n_strx, sym_n_sect, sym_n_value, sym_size, index, ctx);
                 index += 4;
             } else if (sym.visibility == .global) {
-                macho_file.symtab.items[index] = .{
+                ctx.symtab.items[index] = .{
                     .n_strx = sym_n_strx,
                     .n_type = macho.N_GSYM,
                     .n_sect = sym_n_sect,
 @@ -2222,7 +2224,7 @@ pub fn writeStabs(self: *const Object, stroff: u32, macho_file: *MachO) void {
                 };
                 index += 1;
             } else {
-                macho_file.symtab.items[index] = .{
+                ctx.symtab.items[index] = .{
                     .n_strx = sym_n_strx,
                     .n_type = macho.N_STSYM,
                     .n_sect = sym_n_sect,
 @@ -2235,7 +2237,7 @@ pub fn writeStabs(self: *const Object, stroff: u32, macho_file: *MachO) void {
         // Close scope
         // N_SO
-        macho_file.symtab.items[index] = .{
+        ctx.symtab.items[index] = .{
             .n_strx = 0,
             .n_type = macho.N_SO,
             .n_sect = 0,
 @@ -2246,13 +2248,13 @@ pub fn writeStabs(self: *const Object, stroff: u32, macho_file: *MachO) void {
         assert(self.hasSymbolStabs());
         for (self.stab_files.items) |sf| {
-            const comp_dir = sf.getCombDir(self);
+            const comp_dir = sf.getCompDir(self);
             const tu_name = sf.getTuName(self);
             const oso_path = sf.getOsoPath(self);
             // Open scope
             // N_SO comp_dir
-            macho_file.symtab.items[index] = .{
+            ctx.symtab.items[index] = .{
                 .n_strx = n_strx,
                 .n_type = macho.N_SO,
                 .n_sect = 0,
 @@ -2260,12 +2262,12 @@ pub fn writeStabs(self: *const Object, stroff: u32, macho_file: *MachO) void {
                 .n_value = 0,
             };
             index += 1;
-            @memcpy(macho_file.strtab.items[n_strx..][0..comp_dir.len], comp_dir);
+            @memcpy(ctx.strtab.items[n_strx..][0..comp_dir.len], comp_dir);
             n_strx += @intCast(comp_dir.len);
-            macho_file.strtab.items[n_strx] = 0;
+            ctx.strtab.items[n_strx] = 0;
             n_strx += 1;
             // N_SO tu_name
-            macho_file.symtab.items[index] = .{
+            ctx.symtab.items[index] = .{
                 .n_strx = n_strx,
                 .n_type = macho.N_SO,
                 .n_sect = 0,
 @@ -2273,12 +2275,12 @@ pub fn writeStabs(self: *const Object, stroff: u32, macho_file: *MachO) void {
                 .n_value = 0,
             };
             index += 1;
-            @memcpy(macho_file.strtab.items[n_strx..][0..tu_name.len], tu_name);
+            @memcpy(ctx.strtab.items[n_strx..][0..tu_name.len], tu_name);
             n_strx += @intCast(tu_name.len);
-            macho_file.strtab.items[n_strx] = 0;
+            ctx.strtab.items[n_strx] = 0;
             n_strx += 1;
             // N_OSO path
-            macho_file.symtab.items[index] = .{
+            ctx.symtab.items[index] = .{
                 .n_strx = n_strx,
                 .n_type = macho.N_OSO,
                 .n_sect = 0,
 @@ -2286,29 +2288,29 @@ pub fn writeStabs(self: *const Object, stroff: u32, macho_file: *MachO) void {
                 .n_value = sf.getOsoModTime(self),
             };
             index += 1;
-            @memcpy(macho_file.strtab.items[n_strx..][0..oso_path.len], oso_path);
+            @memcpy(ctx.strtab.items[n_strx..][0..oso_path.len], oso_path);
             n_strx += @intCast(oso_path.len);
-            macho_file.strtab.items[n_strx] = 0;
+            ctx.strtab.items[n_strx] = 0;
             n_strx += 1;
             for (sf.stabs.items) |stab| {
-                const sym = stab.getSymbol(macho_file) orelse continue;
+                const sym = stab.getSymbol(self) orelse continue;
                 const file = sym.getFile(macho_file).?;
                 if (file.getIndex() != self.index) continue;
                 if (!sym.flags.output_symtab) continue;
                 const sym_n_strx = n_strx: {
                     const symtab_index = sym.getOutputSymtabIndex(macho_file).?;
-                    const osym = macho_file.symtab.items[symtab_index];
+                    const osym = ctx.symtab.items[symtab_index];
                     break :n_strx osym.n_strx;
                 };
                 const sym_n_sect: u8 = if (!sym.flags.abs) @intCast(sym.getOutputSectionIndex(macho_file) + 1) else 0;
                 const sym_n_value = sym.getAddress(.{}, macho_file);
                 const sym_size = sym.getSize(macho_file);
                 if (stab.is_func) {
-                    writeFuncStab(sym_n_strx, sym_n_sect, sym_n_value, sym_size, index, macho_file);
+                    writeFuncStab(sym_n_strx, sym_n_sect, sym_n_value, sym_size, index, ctx);
                     index += 4;
                 } else if (sym.visibility == .global) {
-                    macho_file.symtab.items[index] = .{
+                    ctx.symtab.items[index] = .{
                         .n_strx = sym_n_strx,
                         .n_type = macho.N_GSYM,
                         .n_sect = sym_n_sect,
 @@ -2317,7 +2319,7 @@ pub fn writeStabs(self: *const Object, stroff: u32, macho_file: *MachO) void {
                     };
                     index += 1;
                 } else {
-                    macho_file.symtab.items[index] = .{
+                    ctx.symtab.items[index] = .{
                         .n_strx = sym_n_strx,
                         .n_type = macho.N_STSYM,
                         .n_sect = sym_n_sect,
 @@ -2330,7 +2332,7 @@ pub fn writeStabs(self: *const Object, stroff: u32, macho_file: *MachO) void {
             // Close scope
             // N_SO
-            macho_file.symtab.items[index] = .{
+            ctx.symtab.items[index] = .{
                 .n_strx = 0,
                 .n_type = macho.N_SO,
                 .n_sect = 0,
 @@ -2343,7 +2345,7 @@ pub fn writeStabs(self: *const Object, stroff: u32, macho_file: *MachO) void {
 }
 pub fn getAtomRelocs(self: *const Object, atom: Atom, macho_file: *MachO) []const Relocation {
-    const extra = atom.getExtra(macho_file).?;
+    const extra = atom.getExtra(macho_file);
     const relocs = self.sections.items(.relocs)[atom.n_sect];
     return relocs.items[extra.rel_index..][0..extra.rel_count];
 }
 @@ -2402,7 +2404,7 @@ pub fn asFile(self: *Object) File {
 }
 const AddAtomArgs = struct {
-    name: MachO.String,
+    name: u32,
     n_sect: u8,
     off: u64,
     size: u64,
 @@ -2420,7 +2422,7 @@ fn addAtom(self: *Object, allocator: Allocator, args: AddAtomArgs) !Atom.Index {
         .size = args.size,
         .off = args.off,
         .extra = try self.addAtomExtra(allocator, .{}),
-        .alignment = args.alignment,
+        .alignment = Atom.Alignment.fromLog2Units(args.alignment),
     };
     return atom_index;
 }
 @@ -2693,12 +2695,12 @@ fn formatSymtab(
     }
     for (object.stab_files.items) |sf| {
         try writer.print("  stabs({s},{s},{s})\n", .{
-            sf.getCompDir(object),
+            sf.getCompDir(object.*),
-            sf.getTuName(object),
+            sf.getTuName(object.*),
-            sf.getOsoPath(object),
+            sf.getOsoPath(object.*),
         });
         for (sf.stabs.items) |stab| {
-            try writer.print("    {}", .{stab.fmt(object)});
+            try writer.print("    {}", .{stab.fmt(object.*)});
         }
     }
 }
 @@ -2744,33 +2746,33 @@ const StabFile = struct {
     comp_dir: u32,
     stabs: std.ArrayListUnmanaged(Stab) = .{},
-    fn getCompDir(sf: StabFile, object: *const Object) [:0]const u8 {
+    fn getCompDir(sf: StabFile, object: Object) [:0]const u8 {
         const nlist = object.symtab.items(.nlist)[sf.comp_dir];
         return object.getString(nlist.n_strx);
     }
-    fn getTuName(sf: StabFile, object: *const Object) [:0]const u8 {
+    fn getTuName(sf: StabFile, object: Object) [:0]const u8 {
         const nlist = object.symtab.items(.nlist)[sf.comp_dir + 1];
         return object.getString(nlist.n_strx);
     }
-    fn getOsoPath(sf: StabFile, object: *const Object) [:0]const u8 {
+    fn getOsoPath(sf: StabFile, object: Object) [:0]const u8 {
         const nlist = object.symtab.items(.nlist)[sf.comp_dir + 2];
         return object.getString(nlist.n_strx);
     }
-    fn getOsoModTime(sf: StabFile, object: *const Object) u64 {
+    fn getOsoModTime(sf: StabFile, object: Object) u64 {
         const nlist = object.symtab.items(.nlist)[sf.comp_dir + 2];
         return nlist.n_value;
     }
     const Stab = struct {
         is_func: bool = true,
-        symbol: ?Symbol.Index = null,
+        index: ?Symbol.Index = null,
-        fn getSymbol(stab: Stab, object: *const Object) ?*Symbol {
+        fn getSymbol(stab: Stab, object: Object) ?Symbol {
             const index = stab.index orelse return null;
-            return &object.symbols.items[index];
+            return object.symbols.items[index];
         }
         pub fn format(
 @@ -2786,9 +2788,9 @@ const StabFile = struct {
             @compileError("do not format stabs directly");
         }
-        const StabFormatContext = struct { Stab, *const Object };
+        const StabFormatContext = struct { Stab, Object };
-        pub fn fmt(stab: Stab, object: *const Object) std.fmt.Formatter(format2) {
+        pub fn fmt(stab: Stab, object: Object) std.fmt.Formatter(format2) {
             return .{ .data = .{ stab, object } };
         }
 @@ -2817,11 +2819,11 @@ const CompileUnit = struct {
     comp_dir: u32,
     tu_name: u32,
-    fn getCompDir(cu: CompileUnit, object: *const Object) [:0]const u8 {
+    fn getCompDir(cu: CompileUnit, object: Object) [:0]const u8 {
         return object.getString(cu.comp_dir);
     }
-    fn getTuName(cu: CompileUnit, object: *const Object) [:0]const u8 {
+    fn getTuName(cu: CompileUnit, object: Object) [:0]const u8 {
         return object.getString(cu.tu_name);
     }
 };
 @@ -2840,15 +2842,14 @@ const CompactUnwindCtx = struct {
 const x86_64 = struct {
     fn parseRelocs(
-        self: *const Object,
+        self: *Object,
-        n_sect: u8,
         sect: macho.section_64,
         out: *std.ArrayListUnmanaged(Relocation),
+        handle: File.Handle,
         macho_file: *MachO,
     ) !void {
         const gpa = macho_file.base.comp.gpa;
-        const handle = macho_file.getFileHandle(self.file_handle);
         const relocs_buffer = try gpa.alloc(u8, sect.nreloc * @sizeOf(macho.relocation_info));
         defer gpa.free(relocs_buffer);
         {
 @@ -2857,8 +2858,12 @@ const x86_64 = struct {
         }
         const relocs = @as([*]align(1) const macho.relocation_info, @ptrCast(relocs_buffer.ptr))[0..sect.nreloc];
-        const code = try self.getSectionData(@intCast(n_sect), macho_file);
+        const code = try gpa.alloc(u8, sect.size);
         defer gpa.free(code);
+        {
+            const amt = try handle.preadAll(code, sect.offset + self.offset);
+            if (amt != code.len) return error.InputOutput;
+        }
         try out.ensureTotalCapacityPrecise(gpa, relocs.len);
 @@ -2880,8 +2885,9 @@ const x86_64 = struct {
                 .X86_64_RELOC_SIGNED_4 => 4,
                 else => 0,
             };
+            var is_extern = rel.r_extern == 1;
-            const target = if (rel.r_extern == 0) blk: {
+            const target = if (!is_extern) blk: {
                 const nsect = rel.r_symbolnum - 1;
                 const taddr: i64 = if (rel.r_pcrel == 1)
                     @as(i64, @intCast(sect.addr)) + rel.r_address + addend + 4
 @@ -2893,9 +2899,15 @@ const x86_64 = struct {
                     });
                     return error.MalformedObject;
                 };
-                addend = taddr - @as(i64, @intCast(macho_file.getAtom(target).?.getInputAddress(macho_file)));
+                const target_atom = self.getAtom(target).?;
+                addend = taddr - @as(i64, @intCast(target_atom.getInputAddress(macho_file)));
+                const isec = target_atom.getInputSection(macho_file);
+                if (isCstringLiteral(isec) or isFixedSizeLiteral(isec) or isPtrLiteral(isec)) {
+                    is_extern = true;
+                    break :blk target_atom.getExtra(macho_file).literal_symbol_index;
+                }
                 break :blk target;
-            } else self.symbols.items[rel.r_symbolnum];
+            } else rel.r_symbolnum;
             const has_subtractor = if (i > 0 and
                 @as(macho.reloc_type_x86_64, @enumFromInt(relocs[i - 1].r_type)) == .X86_64_RELOC_SUBTRACTOR)
 @@ -2909,7 +2921,7 @@ const x86_64 = struct {
                 break :blk true;
             } else false;
-            const @"type": Relocation.Type = validateRelocType(rel, rel_type) catch |err| {
+            const @"type": Relocation.Type = validateRelocType(rel, rel_type, is_extern) catch |err| {
                 switch (err) {
                     error.Pcrel => try macho_file.reportParseError2(
                         self.index,
 @@ -2936,7 +2948,7 @@ const x86_64 = struct {
             };
             out.appendAssumeCapacity(.{
-                .tag = if (rel.r_extern == 1) .@"extern" else .local,
+                .tag = if (is_extern) .@"extern" else .local,
                 .offset = @as(u32, @intCast(rel.r_address)),
                 .target = target,
                 .addend = addend,
 @@ -2951,7 +2963,7 @@ const x86_64 = struct {
         }
     }
-    fn validateRelocType(rel: macho.relocation_info, rel_type: macho.reloc_type_x86_64) !Relocation.Type {
+    fn validateRelocType(rel: macho.relocation_info, rel_type: macho.reloc_type_x86_64, is_extern: bool) !Relocation.Type {
         switch (rel_type) {
             .X86_64_RELOC_UNSIGNED => {
                 if (rel.r_pcrel == 1) return error.Pcrel;
 @@ -2971,7 +2983,7 @@ const x86_64 = struct {
             => {
                 if (rel.r_pcrel == 0) return error.NonPcrel;
                 if (rel.r_length != 2) return error.InvalidLength;
-                if (rel.r_extern == 0) return error.NonExtern;
+                if (!is_extern) return error.NonExtern;
                 return switch (rel_type) {
                     .X86_64_RELOC_BRANCH => .branch,
                     .X86_64_RELOC_GOT_LOAD => .got_load,
 @@ -3002,15 +3014,14 @@ const x86_64 = struct {
 const aarch64 = struct {
     fn parseRelocs(
-        self: *const Object,
+        self: *Object,
-        n_sect: u8,
         sect: macho.section_64,
         out: *std.ArrayListUnmanaged(Relocation),
+        handle: File.Handle,
         macho_file: *MachO,
     ) !void {
         const gpa = macho_file.base.comp.gpa;
-        const handle = macho_file.getFileHandle(self.file_handle);
         const relocs_buffer = try gpa.alloc(u8, sect.nreloc * @sizeOf(macho.relocation_info));
         defer gpa.free(relocs_buffer);
         {
 @@ -3019,8 +3030,12 @@ const aarch64 = struct {
         }
         const relocs = @as([*]align(1) const macho.relocation_info, @ptrCast(relocs_buffer.ptr))[0..sect.nreloc];
-        const code = try self.getSectionData(@intCast(n_sect), macho_file);
+        const code = try gpa.alloc(u8, sect.size);
         defer gpa.free(code);
+        {
+            const amt = try handle.preadAll(code, sect.offset + self.offset);
+            if (amt != code.len) return error.InputOutput;
+        }
         try out.ensureTotalCapacityPrecise(gpa, relocs.len);
 @@ -3066,8 +3081,9 @@ const aarch64 = struct {
             }
             const rel_type: macho.reloc_type_arm64 = @enumFromInt(rel.r_type);
+            var is_extern = rel.r_extern == 1;
-            const target = if (rel.r_extern == 0) blk: {
+            const target = if (!is_extern) blk: {
                 const nsect = rel.r_symbolnum - 1;
                 const taddr: i64 = if (rel.r_pcrel == 1)
                     @as(i64, @intCast(sect.addr)) + rel.r_address + addend
 @@ -3079,9 +3095,15 @@ const aarch64 = struct {
                     });
                     return error.MalformedObject;
                 };
-                addend = taddr - @as(i64, @intCast(macho_file.getAtom(target).?.getInputAddress(macho_file)));
+                const target_atom = self.getAtom(target).?;
+                addend = taddr - @as(i64, @intCast(target_atom.getInputAddress(macho_file)));
+                const isec = target_atom.getInputSection(macho_file);
+                if (isCstringLiteral(isec) or isFixedSizeLiteral(isec) or isPtrLiteral(isec)) {
+                    is_extern = true;
+                    break :blk target_atom.getExtra(macho_file).literal_symbol_index;
+                }
                 break :blk target;
-            } else self.symbols.items[rel.r_symbolnum];
+            } else rel.r_symbolnum;
             const has_subtractor = if (i > 0 and
                 @as(macho.reloc_type_arm64, @enumFromInt(relocs[i - 1].r_type)) == .ARM64_RELOC_SUBTRACTOR)
 @@ -3095,7 +3117,7 @@ const aarch64 = struct {
                 break :blk true;
             } else false;
-            const @"type": Relocation.Type = validateRelocType(rel, rel_type) catch |err| {
+            const @"type": Relocation.Type = validateRelocType(rel, rel_type, is_extern) catch |err| {
                 switch (err) {
                     error.Pcrel => try macho_file.reportParseError2(
                         self.index,
 @@ -3122,7 +3144,7 @@ const aarch64 = struct {
             };
             out.appendAssumeCapacity(.{
-                .tag = if (rel.r_extern == 1) .@"extern" else .local,
+                .tag = if (is_extern) .@"extern" else .local,
                 .offset = @as(u32, @intCast(rel.r_address)),
                 .target = target,
                 .addend = addend,
 @@ -3137,7 +3159,7 @@ const aarch64 = struct {
         }
     }
-    fn validateRelocType(rel: macho.relocation_info, rel_type: macho.reloc_type_arm64) !Relocation.Type {
+    fn validateRelocType(rel: macho.relocation_info, rel_type: macho.reloc_type_arm64, is_extern: bool) !Relocation.Type {
         switch (rel_type) {
             .ARM64_RELOC_UNSIGNED => {
                 if (rel.r_pcrel == 1) return error.Pcrel;
 @@ -3158,7 +3180,7 @@ const aarch64 = struct {
             => {
                 if (rel.r_pcrel == 0) return error.NonPcrel;
                 if (rel.r_length != 2) return error.InvalidLength;
-                if (rel.r_extern == 0) return error.NonExtern;
+                if (!is_extern) return error.NonExtern;
                 return switch (rel_type) {
                     .ARM64_RELOC_BRANCH26 => .branch,
                     .ARM64_RELOC_PAGE21 => .page,
 @@ -3175,7 +3197,7 @@ const aarch64 = struct {
             => {
                 if (rel.r_pcrel == 1) return error.Pcrel;
                 if (rel.r_length != 2) return error.InvalidLength;
-                if (rel.r_extern == 0) return error.NonExtern;
+                if (!is_extern) return error.NonExtern;
                 return switch (rel_type) {
                     .ARM64_RELOC_PAGEOFF12 => .pageoff,
                     .ARM64_RELOC_GOT_LOAD_PAGEOFF12 => .got_load_pageoff,

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

...	@@ -150,7 +150,7 @@ pub fn getObjcSelrefsAddress(symbol: Symbol, macho_file: *MachO) u64 {	...	@@ -150,7 +150,7 @@ pub fn getObjcSelrefsAddress(symbol: Symbol, macho_file: *MachO) u64 {
150	const file = symbol.getFile(macho_file).?;	150	const file = symbol.getFile(macho_file).?;
151	return switch (file) {	151	return switch (file) {
152	.dylib, .zig_object => unreachable,	152	.dylib, .zig_object => unreachable,
153	.object, .internal => \|x\| x.symbols.items[extra.objc_selrefs].getAddress(.{}, macho_file),	153	inline else => \|x\| x.symbols.items[extra.objc_selrefs].getAddress(.{}, macho_file),
154	};	154	};
155	}	155	}
156		156
...	@@ -186,7 +186,7 @@ pub fn getOutputSymtabIndex(symbol: Symbol, macho_file: *MachO) ?u32 {	...	@@ -186,7 +186,7 @@ pub fn getOutputSymtabIndex(symbol: Symbol, macho_file: *MachO) ?u32 {
186	const symtab_ctx = switch (file) {	186	const symtab_ctx = switch (file) {
187	inline else => \|x\| x.output_symtab_ctx,	187	inline else => \|x\| x.output_symtab_ctx,
188	};	188	};
189	var idx = symbol.getExtra(macho_file).?.symtab;	189	var idx = symbol.getExtra(macho_file).symtab;
190	if (symbol.isLocal()) {	190	if (symbol.isLocal()) {
191	idx += symtab_ctx.ilocal;	191	idx += symtab_ctx.ilocal;
192	} else if (symbol.flags.@"export") {	192	} else if (symbol.flags.@"export") {

src/link/MachO/UnwindInfo.zig+2-2

...	@@ -473,11 +473,11 @@ pub const Record = struct {	...	@@ -473,11 +473,11 @@ pub const Record = struct {
473	}	473	}
474		474
475	pub fn getAtom(rec: Record, macho_file: MachO) Atom {	475	pub fn getAtom(rec: Record, macho_file: MachO) Atom {
476	return macho_file.getAtom(rec.atom).?;	476	return rec.getObject(macho_file).getAtom(rec.atom).?;
477	}	477	}
478		478
479	pub fn getLsdaAtom(rec: Record, macho_file: MachO) ?Atom {	479	pub fn getLsdaAtom(rec: Record, macho_file: MachO) ?Atom {
480	return macho_file.getAtom(rec.lsda);	480	return rec.getObject(macho_file).getAtom(rec.lsda);
481	}	481	}
482		482
483	pub fn getPersonality(rec: Record, macho_file: MachO) ?Symbol {	483	pub fn getPersonality(rec: Record, macho_file: MachO) ?Symbol {

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

...	@@ -343,6 +343,36 @@ pub fn writeAr(self: ZigObject, ar_format: Archive.Format, writer: anytype) !voi	...	@@ -343,6 +343,36 @@ pub fn writeAr(self: ZigObject, ar_format: Archive.Format, writer: anytype) !voi
343	try writer.writeAll(self.data.items);	343	try writer.writeAll(self.data.items);
344	}	344	}
345		345
		346	pub fn claimUnresolved(self: ZigObject, macho_file: MachO) void {
		347	const tracy = trace(@src());
		348	defer tracy.end();
		349
		350	for (self.symbols.items, 0..) \|*sym, i\| {
		351	const nlist = self.symtab.items(.nlist)[i];
		352	if (!nlist.ext()) continue;
		353	if (!nlist.undf()) continue;
		354
		355	if (self.getSymbolRef(@intCast(i), macho_file).getFile(macho_file) != null) continue;
		356
		357	const is_import = switch (macho_file.undefined_treatment) {
		358	.@"error" => false,
		359	.warn, .suppress => nlist.weakRef(),
		360	.dynamic_lookup => true,
		361	};
		362	if (is_import) {
		363	sym.value = 0;
		364	sym.atom_ref = .{ .index = 0, .file = 0 };
		365	sym.flags.weak = false;
		366	sym.flags.weak_ref = nlist.weakRef();
		367	sym.flags.import = is_import;
		368	sym.visibility = .global;
		369
		370	const idx = self.globals.items[i];
		371	macho_file.resolver.values.items[idx - 1] = .{ .index = @intCast(i), .file = self.index };
		372	}
		373	}
		374	}
		375
346	pub fn scanRelocs(self: ZigObject, macho_file: MachO) !void {	376	pub fn scanRelocs(self: ZigObject, macho_file: MachO) !void {
347	for (self.getAtoms()) \|atom_index\| {	377	for (self.getAtoms()) \|atom_index\| {
348	const atom = self.getAtom(atom_index) orelse continue;	378	const atom = self.getAtom(atom_index) orelse continue;
...	@@ -378,7 +408,7 @@ pub fn calcSymtabSize(self: ZigObject, macho_file: MachO) void {	...	@@ -378,7 +408,7 @@ pub fn calcSymtabSize(self: ZigObject, macho_file: MachO) void {
378	}	408	}
379	}	409	}
380		410
381	pub fn writeSymtab(self: ZigObject, macho_file: *MachO) void {	411	pub fn writeSymtab(self: ZigObject, macho_file: *MachO, ctx: anytype) void {
382	const tracy = trace(@src());	412	const tracy = trace(@src());
383	defer tracy.end();	413	defer tracy.end();
384		414
...	@@ -388,13 +418,13 @@ pub fn writeSymtab(self: ZigObject, macho_file: *MachO) void {	...	@@ -388,13 +418,13 @@ pub fn writeSymtab(self: ZigObject, macho_file: *MachO) void {
388	const file = ref.getFile(macho_file) orelse continue;	418	const file = ref.getFile(macho_file) orelse continue;
389	if (file.getIndex() != self.index) continue;	419	if (file.getIndex() != self.index) continue;
390	const idx = sym.getOutputSymtabIndex(macho_file) orelse continue;	420	const idx = sym.getOutputSymtabIndex(macho_file) orelse continue;
391	const out_sym = &macho_file.symtab.items[idx];	421	const out_sym = &ctx.symtab.items[idx];
392	out_sym.n_strx = n_strx;	422	out_sym.n_strx = n_strx;
393	sym.setOutputSym(macho_file, out_sym);	423	sym.setOutputSym(macho_file, out_sym);
394	const name = sym.getName(macho_file);	424	const name = sym.getName(macho_file);
395	@memcpy(macho_file.strtab.items[n_strx..][0..name.len], name);	425	@memcpy(ctx.strtab.items[n_strx..][0..name.len], name);
396	n_strx += @intCast(name.len);	426	n_strx += @intCast(name.len);
397	macho_file.strtab.items[n_strx] = 0;	427	ctx.strtab.items[n_strx] = 0;
398	n_strx += 1;	428	n_strx += 1;
399	}	429	}
400	}	430	}
...	@@ -1098,7 +1128,7 @@ pub fn lowerUnnamedConst(	...	@@ -1098,7 +1128,7 @@ pub fn lowerUnnamedConst(
1098	},	1128	},
1099	};	1129	};
1100	const sym = self.symbols.items[sym_index];	1130	const sym = self.symbols.items[sym_index];
1101	try unnamed_consts.append(gpa, sym.atom);	1131	try unnamed_consts.append(gpa, sym.atom_ref.index);
1102	return sym_index;	1132	return sym_index;
1103	}	1133	}
1104		1134

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

src/link/MachO/dyld_info/Trie.zig+22-24

...	@@ -94,33 +94,31 @@ pub fn updateSize(self: Trie, macho_file: MachO) !void {	...	@@ -94,33 +94,31 @@ pub fn updateSize(self: Trie, macho_file: MachO) !void {
94	const gpa = macho_file.base.comp.gpa;	94	const gpa = macho_file.base.comp.gpa;
95		95
96	try self.init(gpa);	96	try self.init(gpa);
97	// TODO	97	try self.nodes.ensureUnusedCapacity(gpa, macho_file.resolver.values.items.len * 2);
98	// try self.nodes.ensureUnusedCapacity(gpa, macho_file.resolver.values.items.len * 2);	98	try self.edges.ensureUnusedCapacity(gpa, macho_file.resolver.values.items.len * 2);
99	// try self.edges.ensureUnusedCapacity(gpa, macho_file.resolver.values.items.len * 2);
100		99
101	const seg = macho_file.getTextSegment();	100	const seg = macho_file.getTextSegment();
102	for (macho_file.objects.items) \|index\| {	101	for (macho_file.resolver.values.items) \|ref\| {
103	for (macho_file.getFile(index).?.getSymbols()) \|ref\| {	102	if (ref.getFile(macho_file) == null) continue;
104	const sym = macho_file.getSymbol(ref);	103	const sym = ref.getSymbol(macho_file).?;
105	if (!sym.flags.@"export") continue;	104	if (!sym.flags.@"export") continue;
106	if (sym.getAtom(macho_file)) \|atom\| if (!atom.flags.alive) continue;	105	if (sym.getAtom(macho_file)) \|atom\| if (!atom.flags.alive) continue;
107	var flags: u64 = if (sym.flags.abs)	106	var flags: u64 = if (sym.flags.abs)
108	macho.EXPORT_SYMBOL_FLAGS_KIND_ABSOLUTE	107	macho.EXPORT_SYMBOL_FLAGS_KIND_ABSOLUTE
109	else if (sym.flags.tlv)	108	else if (sym.flags.tlv)
110	macho.EXPORT_SYMBOL_FLAGS_KIND_THREAD_LOCAL	109	macho.EXPORT_SYMBOL_FLAGS_KIND_THREAD_LOCAL
111	else	110	else
112	macho.EXPORT_SYMBOL_FLAGS_KIND_REGULAR;	111	macho.EXPORT_SYMBOL_FLAGS_KIND_REGULAR;
113	if (sym.flags.weak) {	112	if (sym.flags.weak) {
114	flags \|= macho.EXPORT_SYMBOL_FLAGS_WEAK_DEFINITION;	113	flags \|= macho.EXPORT_SYMBOL_FLAGS_WEAK_DEFINITION;
115	macho_file.weak_defines = true;	114	macho_file.weak_defines = true;
116	macho_file.binds_to_weak = true;	115	macho_file.binds_to_weak = true;
117	}
118	try self.put(gpa, .{
119	.name = sym.getName(macho_file),
120	.vmaddr_offset = sym.getAddress(.{ .stubs = false }, macho_file) - seg.vmaddr,
121	.export_flags = flags,
122	});
123	}	116	}
		117	try self.put(gpa, .{
		118	.name = sym.getName(macho_file),
		119	.vmaddr_offset = sym.getAddress(.{ .stubs = false }, macho_file) - seg.vmaddr,
		120	.export_flags = flags,
		121	});
124	}	122	}
125		123
126	try self.finalize(gpa);	124	try self.finalize(gpa);

src/link/MachO/dyld_info/bind.zig+27-25

...	@@ -1,17 +1,19 @@	...	@@ -1,17 +1,19 @@
1	pub const Entry = struct {	1	pub const Entry = struct {
2	target: Symbol.Index,	2	target: MachO.Ref,
3	offset: u64,	3	offset: u64,
4	segment_id: u8,	4	segment_id: u8,
5	addend: i64,	5	addend: i64,
6		6
7	pub fn lessThan(ctx: *MachO, entry: Entry, other: Entry) bool {	7	pub fn lessThan(ctx: *MachO, entry: Entry, other: Entry) bool {
		8	_ = ctx;
8	if (entry.segment_id == other.segment_id) {	9	if (entry.segment_id == other.segment_id) {
9	if (entry.target == other.target) {	10	if (entry.target.eql(other.target)) {
10	return entry.offset < other.offset;	11	return entry.offset < other.offset;
11	}	12	}
12	const entry_name = ctx.getSymbol(entry.target).getName(ctx);	13	if (entry.target.file == other.target.file) {
13	const other_name = ctx.getSymbol(other.target).getName(ctx);	14	return entry.target.index < other.target.index;
14	return std.mem.lessThan(u8, entry_name, other_name);	15	}
		16	return entry.target.file < other.target.file;
15	}	17	}
16	return entry.segment_id < other.segment_id;	18	return entry.segment_id < other.segment_id;
17	}	19	}
...	@@ -44,7 +46,7 @@ pub const Bind = struct {	...	@@ -44,7 +46,7 @@ pub const Bind = struct {
44	for (objects.items) \|index\| {	46	for (objects.items) \|index\| {
45	const file = macho_file.getFile(index).?;	47	const file = macho_file.getFile(index).?;
46	for (file.getAtoms()) \|atom_index\| {	48	for (file.getAtoms()) \|atom_index\| {
47	const atom = macho_file.getAtom(atom_index) orelse continue;	49	const atom = file.getAtom(atom_index) orelse continue;
48	if (!atom.flags.alive) continue;	50	if (!atom.flags.alive) continue;
49	if (atom.getInputSection(macho_file).isZerofill()) continue;	51	if (atom.getInputSection(macho_file).isZerofill()) continue;
50	const atom_addr = atom.getAddress(macho_file);	52	const atom_addr = atom.getAddress(macho_file);
...	@@ -55,10 +57,10 @@ pub const Bind = struct {	...	@@ -55,10 +57,10 @@ pub const Bind = struct {
55	if (rel.type != .unsigned or rel.meta.length != 3 or rel.tag != .@"extern") continue;	57	if (rel.type != .unsigned or rel.meta.length != 3 or rel.tag != .@"extern") continue;
56	const rel_offset = rel.offset - atom.off;	58	const rel_offset = rel.offset - atom.off;
57	const addend = rel.addend + rel.getRelocAddend(cpu_arch);	59	const addend = rel.addend + rel.getRelocAddend(cpu_arch);
58	const sym = rel.getTargetSymbol(macho_file);	60	const sym = rel.getTargetSymbol(atom.*, macho_file);
59	if (sym.isTlvInit(macho_file)) continue;	61	if (sym.isTlvInit(macho_file)) continue;
60	const entry = Entry{	62	const entry = Entry{
61	.target = rel.target,	63	.target = rel.getTargetSymbolRef(atom.*, macho_file),
62	.offset = atom_addr + rel_offset - seg.vmaddr,	64	.offset = atom_addr + rel_offset - seg.vmaddr,
63	.segment_id = seg_id,	65	.segment_id = seg_id,
64	.addend = addend,	66	.addend = addend,
...	@@ -74,7 +76,7 @@ pub const Bind = struct {	...	@@ -74,7 +76,7 @@ pub const Bind = struct {
74	const seg_id = macho_file.sections.items(.segment_id)[sid];	76	const seg_id = macho_file.sections.items(.segment_id)[sid];
75	const seg = macho_file.segments.items[seg_id];	77	const seg = macho_file.segments.items[seg_id];
76	for (macho_file.got.symbols.items, 0..) \|ref, idx\| {	78	for (macho_file.got.symbols.items, 0..) \|ref, idx\| {
77	const sym = macho_file.getSymbol(ref);	79	const sym = ref.getSymbol(macho_file).?;
78	const addr = macho_file.got.getAddress(@intCast(idx), macho_file);	80	const addr = macho_file.got.getAddress(@intCast(idx), macho_file);
79	const entry = Entry{	81	const entry = Entry{
80	.target = ref,	82	.target = ref,
...	@@ -93,7 +95,7 @@ pub const Bind = struct {	...	@@ -93,7 +95,7 @@ pub const Bind = struct {
93	const seg_id = macho_file.sections.items(.segment_id)[sid];	95	const seg_id = macho_file.sections.items(.segment_id)[sid];
94	const seg = macho_file.segments.items[seg_id];	96	const seg = macho_file.segments.items[seg_id];
95	for (macho_file.stubs.symbols.items, 0..) \|ref, idx\| {	97	for (macho_file.stubs.symbols.items, 0..) \|ref, idx\| {
96	const sym = macho_file.getSymbol(ref);	98	const sym = ref.getSymbol(macho_file).?;
97	const addr = sect.addr + idx * @sizeOf(u64);	99	const addr = sect.addr + idx * @sizeOf(u64);
98	const bind_entry = Entry{	100	const bind_entry = Entry{
99	.target = ref,	101	.target = ref,
...	@@ -112,7 +114,7 @@ pub const Bind = struct {	...	@@ -112,7 +114,7 @@ pub const Bind = struct {
112	const seg = macho_file.segments.items[seg_id];	114	const seg = macho_file.segments.items[seg_id];
113		115
114	for (macho_file.tlv_ptr.symbols.items, 0..) \|ref, idx\| {	116	for (macho_file.tlv_ptr.symbols.items, 0..) \|ref, idx\| {
115	const sym = macho_file.getSymbol(ref);	117	const sym = ref.getSymbol(macho_file).?;
116	const addr = macho_file.tlv_ptr.getAddress(@intCast(idx), macho_file);	118	const addr = macho_file.tlv_ptr.getAddress(@intCast(idx), macho_file);
117	const entry = Entry{	119	const entry = Entry{
118	.target = ref,	120	.target = ref,
...	@@ -162,7 +164,7 @@ pub const Bind = struct {	...	@@ -162,7 +164,7 @@ pub const Bind = struct {
162	var addend: i64 = 0;	164	var addend: i64 = 0;
163	var count: usize = 0;	165	var count: usize = 0;
164	var skip: u64 = 0;	166	var skip: u64 = 0;
165	var target: ?Symbol.Index = null;	167	var target: ?MachO.Ref = null;
166		168
167	var state: enum {	169	var state: enum {
168	start,	170	start,
...	@@ -173,7 +175,7 @@ pub const Bind = struct {	...	@@ -173,7 +175,7 @@ pub const Bind = struct {
173	var i: usize = 0;	175	var i: usize = 0;
174	while (i < entries.len) : (i += 1) {	176	while (i < entries.len) : (i += 1) {
175	const current = entries[i];	177	const current = entries[i];
176	if (target == null or target.? != current.target) {	178	if (target == null or !target.?.eql(current.target)) {
177	switch (state) {	179	switch (state) {
178	.start => {},	180	.start => {},
179	.bind_single => try doBind(writer),	181	.bind_single => try doBind(writer),
...	@@ -182,7 +184,7 @@ pub const Bind = struct {	...	@@ -182,7 +184,7 @@ pub const Bind = struct {
182	state = .start;	184	state = .start;
183	target = current.target;	185	target = current.target;
184		186
185	const sym = ctx.getSymbol(current.target);	187	const sym = current.target.getSymbol(ctx).?;
186	const name = sym.getName(ctx);	188	const name = sym.getName(ctx);
187	const flags: u8 = if (sym.weakRef(ctx)) macho.BIND_SYMBOL_FLAGS_WEAK_IMPORT else 0;	189	const flags: u8 = if (sym.weakRef(ctx)) macho.BIND_SYMBOL_FLAGS_WEAK_IMPORT else 0;
188	const ordinal: i16 = ord: {	190	const ordinal: i16 = ord: {
...	@@ -296,7 +298,7 @@ pub const WeakBind = struct {	...	@@ -296,7 +298,7 @@ pub const WeakBind = struct {
296	for (objects.items) \|index\| {	298	for (objects.items) \|index\| {
297	const file = macho_file.getFile(index).?;	299	const file = macho_file.getFile(index).?;
298	for (file.getAtoms()) \|atom_index\| {	300	for (file.getAtoms()) \|atom_index\| {
299	const atom = macho_file.getAtom(atom_index) orelse continue;	301	const atom = file.getAtom(atom_index) orelse continue;
300	if (!atom.flags.alive) continue;	302	if (!atom.flags.alive) continue;
301	if (atom.getInputSection(macho_file).isZerofill()) continue;	303	if (atom.getInputSection(macho_file).isZerofill()) continue;
302	const atom_addr = atom.getAddress(macho_file);	304	const atom_addr = atom.getAddress(macho_file);
...	@@ -307,10 +309,10 @@ pub const WeakBind = struct {	...	@@ -307,10 +309,10 @@ pub const WeakBind = struct {
307	if (rel.type != .unsigned or rel.meta.length != 3 or rel.tag != .@"extern") continue;	309	if (rel.type != .unsigned or rel.meta.length != 3 or rel.tag != .@"extern") continue;
308	const rel_offset = rel.offset - atom.off;	310	const rel_offset = rel.offset - atom.off;
309	const addend = rel.addend + rel.getRelocAddend(cpu_arch);	311	const addend = rel.addend + rel.getRelocAddend(cpu_arch);
310	const sym = rel.getTargetSymbol(macho_file);	312	const sym = rel.getTargetSymbol(atom.*, macho_file);
311	if (sym.isTlvInit(macho_file)) continue;	313	if (sym.isTlvInit(macho_file)) continue;
312	const entry = Entry{	314	const entry = Entry{
313	.target = rel.target,	315	.target = rel.getTargetSymbolRef(atom.*, macho_file),
314	.offset = atom_addr + rel_offset - seg.vmaddr,	316	.offset = atom_addr + rel_offset - seg.vmaddr,
315	.segment_id = seg_id,	317	.segment_id = seg_id,
316	.addend = addend,	318	.addend = addend,
...	@@ -326,7 +328,7 @@ pub const WeakBind = struct {	...	@@ -326,7 +328,7 @@ pub const WeakBind = struct {
326	const seg_id = macho_file.sections.items(.segment_id)[sid];	328	const seg_id = macho_file.sections.items(.segment_id)[sid];
327	const seg = macho_file.segments.items[seg_id];	329	const seg = macho_file.segments.items[seg_id];
328	for (macho_file.got.symbols.items, 0..) \|ref, idx\| {	330	for (macho_file.got.symbols.items, 0..) \|ref, idx\| {
329	const sym = macho_file.getSymbol(ref);	331	const sym = ref.getSymbol(macho_file).?;
330	const addr = macho_file.got.getAddress(@intCast(idx), macho_file);	332	const addr = macho_file.got.getAddress(@intCast(idx), macho_file);
331	const entry = Entry{	333	const entry = Entry{
332	.target = ref,	334	.target = ref,
...	@@ -346,7 +348,7 @@ pub const WeakBind = struct {	...	@@ -346,7 +348,7 @@ pub const WeakBind = struct {
346	const seg = macho_file.segments.items[seg_id];	348	const seg = macho_file.segments.items[seg_id];
347		349
348	for (macho_file.stubs.symbols.items, 0..) \|ref, idx\| {	350	for (macho_file.stubs.symbols.items, 0..) \|ref, idx\| {
349	const sym = macho_file.getSymbol(ref);	351	const sym = ref.getSymbol(macho_file).?;
350	const addr = sect.addr + idx * @sizeOf(u64);	352	const addr = sect.addr + idx * @sizeOf(u64);
351	const bind_entry = Entry{	353	const bind_entry = Entry{
352	.target = ref,	354	.target = ref,
...	@@ -365,7 +367,7 @@ pub const WeakBind = struct {	...	@@ -365,7 +367,7 @@ pub const WeakBind = struct {
365	const seg = macho_file.segments.items[seg_id];	367	const seg = macho_file.segments.items[seg_id];
366		368
367	for (macho_file.tlv_ptr.symbols.items, 0..) \|ref, idx\| {	369	for (macho_file.tlv_ptr.symbols.items, 0..) \|ref, idx\| {
368	const sym = macho_file.getSymbol(ref);	370	const sym = ref.getSymbol(macho_file).?;
369	const addr = macho_file.tlv_ptr.getAddress(@intCast(idx), macho_file);	371	const addr = macho_file.tlv_ptr.getAddress(@intCast(idx), macho_file);
370	const entry = Entry{	372	const entry = Entry{
371	.target = ref,	373	.target = ref,
...	@@ -415,7 +417,7 @@ pub const WeakBind = struct {	...	@@ -415,7 +417,7 @@ pub const WeakBind = struct {
415	var addend: i64 = 0;	417	var addend: i64 = 0;
416	var count: usize = 0;	418	var count: usize = 0;
417	var skip: u64 = 0;	419	var skip: u64 = 0;
418	var target: ?Symbol.Index = null;	420	var target: ?MachO.Ref = null;
419		421
420	var state: enum {	422	var state: enum {
421	start,	423	start,
...	@@ -426,7 +428,7 @@ pub const WeakBind = struct {	...	@@ -426,7 +428,7 @@ pub const WeakBind = struct {
426	var i: usize = 0;	428	var i: usize = 0;
427	while (i < entries.len) : (i += 1) {	429	while (i < entries.len) : (i += 1) {
428	const current = entries[i];	430	const current = entries[i];
429	if (target == null or target.? != current.target) {	431	if (target == null or !target.?.eql(current.target)) {
430	switch (state) {	432	switch (state) {
431	.start => {},	433	.start => {},
432	.bind_single => try doBind(writer),	434	.bind_single => try doBind(writer),
...	@@ -435,7 +437,7 @@ pub const WeakBind = struct {	...	@@ -435,7 +437,7 @@ pub const WeakBind = struct {
435	state = .start;	437	state = .start;
436	target = current.target;	438	target = current.target;
437		439
438	const sym = ctx.getSymbol(current.target);	440	const sym = current.target.getSymbol(ctx).?;
439	const name = sym.getName(ctx);	441	const name = sym.getName(ctx);
440	const flags: u8 = 0; // TODO NON_WEAK_DEFINITION	442	const flags: u8 = 0; // TODO NON_WEAK_DEFINITION
441		443
...	@@ -536,7 +538,7 @@ pub const LazyBind = struct {	...	@@ -536,7 +538,7 @@ pub const LazyBind = struct {
536	const seg = macho_file.segments.items[seg_id];	538	const seg = macho_file.segments.items[seg_id];
537		539
538	for (macho_file.stubs.symbols.items, 0..) \|ref, idx\| {	540	for (macho_file.stubs.symbols.items, 0..) \|ref, idx\| {
539	const sym = macho_file.getSymbol(ref);	541	const sym = ref.getSymbol(macho_file).?;
540	const addr = sect.addr + idx * @sizeOf(u64);	542	const addr = sect.addr + idx * @sizeOf(u64);
541	const bind_entry = Entry{	543	const bind_entry = Entry{
542	.target = ref,	544	.target = ref,
...	@@ -565,7 +567,7 @@ pub const LazyBind = struct {	...	@@ -565,7 +567,7 @@ pub const LazyBind = struct {
565	for (self.entries.items) \|entry\| {	567	for (self.entries.items) \|entry\| {
566	self.offsets.appendAssumeCapacity(@intCast(self.buffer.items.len));	568	self.offsets.appendAssumeCapacity(@intCast(self.buffer.items.len));
567		569
568	const sym = ctx.getSymbol(entry.target);	570	const sym = entry.target.getSymbol(ctx).?;
569	const name = sym.getName(ctx);	571	const name = sym.getName(ctx);
570	const flags: u8 = if (sym.weakRef(ctx)) macho.BIND_SYMBOL_FLAGS_WEAK_IMPORT else 0;	572	const flags: u8 = if (sym.weakRef(ctx)) macho.BIND_SYMBOL_FLAGS_WEAK_IMPORT else 0;
571	const ordinal: i16 = ord: {	573	const ordinal: i16 = ord: {

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

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

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

...	@@ -37,7 +37,7 @@ pub fn createThunks(sect_id: u8, macho_file: *MachO) !void {	...	@@ -37,7 +37,7 @@ pub fn createThunks(sect_id: u8, macho_file: *MachO) !void {
37		37
38	// Scan relocs in the group and create trampolines for any unreachable callsite	38	// Scan relocs in the group and create trampolines for any unreachable callsite
39	try scanRelocs(thunk_index, gpa, atoms[start..i], macho_file);	39	try scanRelocs(thunk_index, gpa, atoms[start..i], macho_file);
40	thunk.value = try advance(header, thunk.size(), .@"4");	40	thunk.value = advance(header, thunk.size(), .@"4");
41		41
42	log.debug("thunk({d}) : {}", .{ thunk_index, thunk.fmt(macho_file) });	42	log.debug("thunk({d}) : {}", .{ thunk_index, thunk.fmt(macho_file) });
43	}	43	}
...	@@ -99,8 +99,8 @@ pub const Thunk = struct {	...	@@ -99,8 +99,8 @@ pub const Thunk = struct {
99	return header.addr + thunk.value;	99	return header.addr + thunk.value;
100	}	100	}
101		101
102	pub fn getTargetAddress(thunk: Thunk, sym_index: Symbol.Index, macho_file: *MachO) u64 {	102	pub fn getTargetAddress(thunk: Thunk, ref: MachO.Ref, macho_file: *MachO) u64 {
103	return thunk.getAddress(macho_file) + thunk.symbols.getIndex(sym_index).? * trampoline_size;	103	return thunk.getAddress(macho_file) + thunk.symbols.getIndex(ref).? * trampoline_size;
104	}	104	}
105		105
106	pub fn write(thunk: Thunk, macho_file: *MachO, writer: anytype) !void {	106	pub fn write(thunk: Thunk, macho_file: *MachO, writer: anytype) !void {

...	@@ -213,7 +213,8 @@ pub fn initOutputSection(sect: macho.section_64, macho_file: *MachO) !u8 {	...	@@ -213,7 +213,8 @@ pub fn initOutputSection(sect: macho.section_64, macho_file: *MachO) !u8 {
213	/// File offset relocation happens transparently, so it is not included in	213	/// File offset relocation happens transparently, so it is not included in
214	/// this calculation.	214	/// this calculation.
215	pub fn capacity(self: Atom, macho_file: *MachO) u64 {	215	pub fn capacity(self: Atom, macho_file: *MachO) u64 {
216	const next_addr = if (macho_file.getAtom(self.next_index)) \|next\|	216	const zo = macho_file.getZigObject().?;
		217	const next_addr = if (zo.getAtom(self.next_index)) \|next\|
217	next.getAddress(macho_file)	218	next.getAddress(macho_file)
218	else	219	else
219	std.math.maxInt(u32);	220	std.math.maxInt(u32);
...	@@ -222,7 +223,8 @@ pub fn capacity(self: Atom, macho_file: *MachO) u64 {	...	@@ -222,7 +223,8 @@ pub fn capacity(self: Atom, macho_file: *MachO) u64 {
222		223
223	pub fn freeListEligible(self: Atom, macho_file: *MachO) bool {	224	pub fn freeListEligible(self: Atom, macho_file: *MachO) bool {
224	// No need to keep a free list node for the last block.	225	// No need to keep a free list node for the last block.
225	const next = macho_file.getAtom(self.next_index) orelse return false;	226	const zo = macho_file.getZigObject().?;
		227	const next = zo.getAtom(self.next_index) orelse return false;
226	const cap = next.getAddress(macho_file) - self.getAddress(macho_file);	228	const cap = next.getAddress(macho_file) - self.getAddress(macho_file);
227	const ideal_cap = MachO.padToIdeal(self.size);	229	const ideal_cap = MachO.padToIdeal(self.size);
228	if (cap <= ideal_cap) return false;	230	if (cap <= ideal_cap) return false;
...	@@ -231,6 +233,7 @@ pub fn freeListEligible(self: Atom, macho_file: *MachO) bool {	...	@@ -231,6 +233,7 @@ pub fn freeListEligible(self: Atom, macho_file: *MachO) bool {
231	}	233	}
232		234
233	pub fn allocate(self: Atom, macho_file: MachO) !void {	235	pub fn allocate(self: Atom, macho_file: MachO) !void {
		236	const zo = macho_file.getZigObject().?;
234	const sect = &macho_file.sections.items(.header)[self.out_n_sect];	237	const sect = &macho_file.sections.items(.header)[self.out_n_sect];
235	const free_list = &macho_file.sections.items(.free_list)[self.out_n_sect];	238	const free_list = &macho_file.sections.items(.free_list)[self.out_n_sect];
236	const last_atom_index = &macho_file.sections.items(.last_atom_index)[self.out_n_sect];	239	const last_atom_index = &macho_file.sections.items(.last_atom_index)[self.out_n_sect];
...	@@ -250,7 +253,7 @@ pub fn allocate(self: Atom, macho_file: MachO) !void {	...	@@ -250,7 +253,7 @@ pub fn allocate(self: Atom, macho_file: MachO) !void {
250	var i: usize = free_list.items.len;	253	var i: usize = free_list.items.len;
251	while (i < free_list.items.len) {	254	while (i < free_list.items.len) {
252	const big_atom_index = free_list.items[i];	255	const big_atom_index = free_list.items[i];
253	const big_atom = macho_file.getAtom(big_atom_index).?;	256	const big_atom = zo.getAtom(big_atom_index).?;
254	// We now have a pointer to a live atom that has too much capacity.	257	// We now have a pointer to a live atom that has too much capacity.
255	// Is it enough that we could fit this new atom?	258	// Is it enough that we could fit this new atom?
256	const cap = big_atom.capacity(macho_file);	259	const cap = big_atom.capacity(macho_file);
...	@@ -282,7 +285,7 @@ pub fn allocate(self: Atom, macho_file: MachO) !void {	...	@@ -282,7 +285,7 @@ pub fn allocate(self: Atom, macho_file: MachO) !void {
282	free_list_removal = i;	285	free_list_removal = i;
283	}	286	}
284	break :blk new_start_vaddr;	287	break :blk new_start_vaddr;
285	} else if (macho_file.getAtom(last_atom_index.*)) \|last\| {	288	} else if (zo.getAtom(last_atom_index.*)) \|last\| {
286	const ideal_capacity = MachO.padToIdeal(last.size);	289	const ideal_capacity = MachO.padToIdeal(last.size);
287	const ideal_capacity_end_vaddr = last.value + ideal_capacity;	290	const ideal_capacity_end_vaddr = last.value + ideal_capacity;
288	const new_start_vaddr = self.alignment.forward(ideal_capacity_end_vaddr);	291	const new_start_vaddr = self.alignment.forward(ideal_capacity_end_vaddr);
...	@@ -302,7 +305,7 @@ pub fn allocate(self: Atom, macho_file: MachO) !void {	...	@@ -302,7 +305,7 @@ pub fn allocate(self: Atom, macho_file: MachO) !void {
302	});	305	});
303		306
304	const expand_section = if (atom_placement) \|placement_index\|	307	const expand_section = if (atom_placement) \|placement_index\|
305	macho_file.getAtom(placement_index).?.next_index == 0	308	zo.getAtom(placement_index).?.next_index == 0
306	else	309	else
307	true;	310	true;
308	if (expand_section) {	311	if (expand_section) {
...	@@ -327,15 +330,15 @@ pub fn allocate(self: Atom, macho_file: MachO) !void {	...	@@ -327,15 +330,15 @@ pub fn allocate(self: Atom, macho_file: MachO) !void {
327	// This function can also reallocate an atom.	330	// This function can also reallocate an atom.
328	// In this case we need to "unplug" it from its previous location before	331	// In this case we need to "unplug" it from its previous location before
329	// plugging it in to its new location.	332	// plugging it in to its new location.
330	if (macho_file.getAtom(self.prev_index)) \|prev\| {	333	if (zo.getAtom(self.prev_index)) \|prev\| {
331	prev.next_index = self.next_index;	334	prev.next_index = self.next_index;
332	}	335	}
333	if (macho_file.getAtom(self.next_index)) \|next\| {	336	if (zo.getAtom(self.next_index)) \|next\| {
334	next.prev_index = self.prev_index;	337	next.prev_index = self.prev_index;
335	}	338	}
336		339
337	if (atom_placement) \|big_atom_index\| {	340	if (atom_placement) \|big_atom_index\| {
338	const big_atom = macho_file.getAtom(big_atom_index).?;	341	const big_atom = zo.getAtom(big_atom_index).?;
339	self.prev_index = big_atom_index;	342	self.prev_index = big_atom_index;
340	self.next_index = big_atom.next_index;	343	self.next_index = big_atom.next_index;
341	big_atom.next_index = self.atom_index;	344	big_atom.next_index = self.atom_index;
...	@@ -365,6 +368,7 @@ pub fn free(self: Atom, macho_file: MachO) void {	...	@@ -365,6 +368,7 @@ pub fn free(self: Atom, macho_file: MachO) void {
365		368
366	const comp = macho_file.base.comp;	369	const comp = macho_file.base.comp;
367	const gpa = comp.gpa;	370	const gpa = comp.gpa;
		371	const zo = macho_file.getZigObject().?;
368	const free_list = &macho_file.sections.items(.free_list)[self.out_n_sect];	372	const free_list = &macho_file.sections.items(.free_list)[self.out_n_sect];
369	const last_atom_index = &macho_file.sections.items(.last_atom_index)[self.out_n_sect];	373	const last_atom_index = &macho_file.sections.items(.last_atom_index)[self.out_n_sect];
370	var already_have_free_list_node = false;	374	var already_have_free_list_node = false;
...	@@ -383,9 +387,9 @@ pub fn free(self: Atom, macho_file: MachO) void {	...	@@ -383,9 +387,9 @@ pub fn free(self: Atom, macho_file: MachO) void {
383	}	387	}
384	}	388	}
385		389
386	if (macho_file.getAtom(last_atom_index.*)) \|last_atom\| {	390	if (zo.getAtom(last_atom_index.*)) \|last_atom\| {
387	if (last_atom.atom_index == self.atom_index) {	391	if (last_atom.atom_index == self.atom_index) {
388	if (macho_file.getAtom(self.prev_index)) \|_\| {	392	if (zo.getAtom(self.prev_index)) \|_\| {
389	// TODO shrink the section size here	393	// TODO shrink the section size here
390	last_atom_index.* = self.prev_index;	394	last_atom_index.* = self.prev_index;
391	} else {	395	} else {
...	@@ -394,7 +398,7 @@ pub fn free(self: Atom, macho_file: MachO) void {	...	@@ -394,7 +398,7 @@ pub fn free(self: Atom, macho_file: MachO) void {
394	}	398	}
395	}	399	}
396		400
397	if (macho_file.getAtom(self.prev_index)) \|prev\| {	401	if (zo.getAtom(self.prev_index)) \|prev\| {
398	prev.next_index = self.next_index;	402	prev.next_index = self.next_index;
399	if (!already_have_free_list_node and prev.*.freeListEligible(macho_file)) {	403	if (!already_have_free_list_node and prev.*.freeListEligible(macho_file)) {
400	// The free list is heuristics, it doesn't have to be perfect, so we can	404	// The free list is heuristics, it doesn't have to be perfect, so we can
...	@@ -405,7 +409,7 @@ pub fn free(self: Atom, macho_file: MachO) void {	...	@@ -405,7 +409,7 @@ pub fn free(self: Atom, macho_file: MachO) void {
405	self.prev_index = 0;	409	self.prev_index = 0;
406	}	410	}
407		411
408	if (macho_file.getAtom(self.next_index)) \|next\| {	412	if (zo.getAtom(self.next_index)) \|next\| {
409	next.prev_index = self.prev_index;	413	next.prev_index = self.prev_index;
410	} else {	414	} else {
411	self.next_index = 0;	415	self.next_index = 0;
...	@@ -423,7 +427,7 @@ pub fn addReloc(self: Atom, macho_file: MachO, reloc: Relocation) !void {	...	@@ -423,7 +427,7 @@ pub fn addReloc(self: Atom, macho_file: MachO, reloc: Relocation) !void {
423	const gpa = macho_file.base.comp.gpa;	427	const gpa = macho_file.base.comp.gpa;
424	const file = self.getFile(macho_file);	428	const file = self.getFile(macho_file);
425	assert(file == .zig_object);	429	assert(file == .zig_object);
426	var extra = self.getExtra(macho_file).?;	430	var extra = self.getExtra(macho_file);
427	const rels = &file.zig_object.relocs.items[extra.rel_index];	431	const rels = &file.zig_object.relocs.items[extra.rel_index];
428	try rels.append(gpa, reloc);	432	try rels.append(gpa, reloc);
429	extra.rel_count += 1;	433	extra.rel_count += 1;
...	@@ -432,7 +436,7 @@ pub fn addReloc(self: Atom, macho_file: MachO, reloc: Relocation) !void {	...	@@ -432,7 +436,7 @@ pub fn addReloc(self: Atom, macho_file: MachO, reloc: Relocation) !void {
432		436
433	pub fn freeRelocs(self: Atom, macho_file: MachO) void {	437	pub fn freeRelocs(self: Atom, macho_file: MachO) void {
434	self.getFile(macho_file).zig_object.freeAtomRelocs(self.*, macho_file);	438	self.getFile(macho_file).zig_object.freeAtomRelocs(self.*, macho_file);
435	var extra = self.getExtra(macho_file).?;	439	var extra = self.getExtra(macho_file);
436	extra.rel_count = 0;	440	extra.rel_count = 0;
437	self.setExtra(extra, macho_file);	441	self.setExtra(extra, macho_file);
438	}	442	}
...	@@ -630,7 +634,7 @@ fn resolveRelocInner(	...	@@ -630,7 +634,7 @@ fn resolveRelocInner(
630	const TLS = @as(i64, @intCast(macho_file.getTlsAddress()));	634	const TLS = @as(i64, @intCast(macho_file.getTlsAddress()));
631	const SUB = if (subtractor) \|sub\| @as(i64, @intCast(sub.getTargetAddress(self, macho_file))) else 0;	635	const SUB = if (subtractor) \|sub\| @as(i64, @intCast(sub.getTargetAddress(self, macho_file))) else 0;
632	// Address of the __got_zig table entry if any.	636	// Address of the __got_zig table entry if any.
633	const ZIG_GOT = @as(i64, @intCast(rel.getZigGotTargetAddress(self, macho_file)));	637	const ZIG_GOT = @as(i64, @intCast(rel.getZigGotTargetAddress(macho_file)));
634		638
635	const divExact = struct {	639	const divExact = struct {
636	fn divExact(atom: Atom, r: Relocation, num: u12, den: u12, ctx: *MachO) !u12 {	640	fn divExact(atom: Atom, r: Relocation, num: u12, den: u12, ctx: *MachO) !u12 {

...	@@ -16,7 +16,7 @@ objc_selrefs: [@sizeOf(u64)]u8 = [_]u8{0} ** @sizeOf(u64),	...	@@ -16,7 +16,7 @@ objc_selrefs: [@sizeOf(u64)]u8 = [_]u8{0} ** @sizeOf(u64),
16	force_undefined: std.ArrayListUnmanaged(Symbol.Index) = .{},	16	force_undefined: std.ArrayListUnmanaged(Symbol.Index) = .{},
17	entry_index: ?Symbol.Index = null,	17	entry_index: ?Symbol.Index = null,
18	dyld_stub_binder_index: ?Symbol.Index = null,	18	dyld_stub_binder_index: ?Symbol.Index = null,
19	dyld_private: ?Symbol.Index = null,	19	dyld_private_index: ?Symbol.Index = null,
20	objc_msg_send_index: ?Symbol.Index = null,	20	objc_msg_send_index: ?Symbol.Index = null,
21	mh_execute_header_index: ?Symbol.Index = null,	21	mh_execute_header_index: ?Symbol.Index = null,
22	mh_dylib_header_index: ?Symbol.Index = null,	22	mh_dylib_header_index: ?Symbol.Index = null,
...	@@ -206,7 +206,7 @@ pub fn resolveBoundarySymbols(self: InternalObject, macho_file: MachO) !void {	...	@@ -206,7 +206,7 @@ pub fn resolveBoundarySymbols(self: InternalObject, macho_file: MachO) !void {
206	const nlist_idx: u32 = @intCast(self.symtab.items.len);	206	const nlist_idx: u32 = @intCast(self.symtab.items.len);
207	const nlist = self.symtab.addOneAssumeCapacity();	207	const nlist = self.symtab.addOneAssumeCapacity();
208	nlist.* = .{	208	nlist.* = .{
209	.n_strx = name_off.pos,	209	.n_strx = name_off,
210	.n_type = macho.N_SECT,	210	.n_type = macho.N_SECT,
211	.n_sect = 0,	211	.n_sect = 0,
212	.n_desc = 0,	212	.n_desc = 0,
...	@@ -273,7 +273,7 @@ fn addObjcMethnameSection(self: *InternalObject, methname: []const u8, macho_fil	...	@@ -273,7 +273,7 @@ fn addObjcMethnameSection(self: *InternalObject, methname: []const u8, macho_fil
273	const nlist_idx: u32 = @intCast(self.symtab.items.len);	273	const nlist_idx: u32 = @intCast(self.symtab.items.len);
274	const nlist = try self.symtab.addOne(gpa);	274	const nlist = try self.symtab.addOne(gpa);
275	nlist.* = .{	275	nlist.* = .{
276	.n_strx = name_str.pos,	276	.n_strx = name_str,
277	.n_type = macho.N_SECT,	277	.n_type = macho.N_SECT,
278	.n_sect = @intCast(n_sect + 1),	278	.n_sect = @intCast(n_sect + 1),
279	.n_desc = 0,	279	.n_desc = 0,
...	@@ -286,12 +286,12 @@ fn addObjcMethnameSection(self: *InternalObject, methname: []const u8, macho_fil	...	@@ -286,12 +286,12 @@ fn addObjcMethnameSection(self: *InternalObject, methname: []const u8, macho_fil
286	}	286	}
287		287
288	fn addObjcSelrefsSection(self: InternalObject, methname_sym_index: Symbol.Index, macho_file: MachO) !Symbol.Index {	288	fn addObjcSelrefsSection(self: InternalObject, methname_sym_index: Symbol.Index, macho_file: MachO) !Symbol.Index {
289	const gpa = macho_file.base.allocator;	289	const gpa = macho_file.base.comp.gpa;
290	const atom_index = try self.addAtom(gpa);	290	const atom_index = try self.addAtom(gpa);
291	try self.atoms_indexes.append(gpa, atom_index);	291	try self.atoms_indexes.append(gpa, atom_index);
292	const atom = self.getAtom(atom_index).?;	292	const atom = self.getAtom(atom_index).?;
293	atom.size = @sizeOf(u64);	293	atom.size = @sizeOf(u64);
294	atom.alignment = 3;	294	atom.alignment = .@"8";
295		295
296	const n_sect = try self.addSection(gpa, "__DATA", "__objc_selrefs");	296	const n_sect = try self.addSection(gpa, "__DATA", "__objc_selrefs");
297	const sect = &self.sections.items(.header)[n_sect];	297	const sect = &self.sections.items(.header)[n_sect];
...	@@ -389,7 +389,7 @@ pub fn resolveObjcMsgSendSymbols(self: InternalObject, macho_file: MachO) !voi	...	@@ -389,7 +389,7 @@ pub fn resolveObjcMsgSendSymbols(self: InternalObject, macho_file: MachO) !voi
389	};	389	};
390	sym.nlist_idx = nlist_idx;	390	sym.nlist_idx = nlist_idx;
391	sym.extra = try self.addSymbolExtra(gpa, .{ .objc_selrefs = selrefs_index });	391	sym.extra = try self.addSymbolExtra(gpa, .{ .objc_selrefs = selrefs_index });
392	sym.setSectionFlags(.{ .objc_stubs = true });	392	sym.flags.objc_stubs = true;
393		393
394	const idx = ref.getFile(macho_file).?.object.globals.items[ref.index];	394	const idx = ref.getFile(macho_file).?.object.globals.items[ref.index];
395	try self.globals.append(gpa, idx);	395	try self.globals.append(gpa, idx);
...	@@ -417,7 +417,7 @@ pub fn resolveLiterals(self: InternalObject, lp: MachO.LiteralPool, macho_file	...	@@ -417,7 +417,7 @@ pub fn resolveLiterals(self: InternalObject, lp: MachO.LiteralPool, macho_file
417	const target = rel.getTargetSymbol(atom.*, macho_file).getAtom(macho_file).?;	417	const target = rel.getTargetSymbol(atom.*, macho_file).getAtom(macho_file).?;
418	try buffer.ensureUnusedCapacity(target.size);	418	try buffer.ensureUnusedCapacity(target.size);
419	buffer.resize(target.size) catch unreachable;	419	buffer.resize(target.size) catch unreachable;
420	@memcpy(buffer.items, self.getSectionData(target.n_sect));	420	@memcpy(buffer.items, try self.getSectionData(target.n_sect));
421	const res = try lp.insert(gpa, header.type(), buffer.items);	421	const res = try lp.insert(gpa, header.type(), buffer.items);
422	buffer.clearRetainingCapacity();	422	buffer.clearRetainingCapacity();
423	if (!res.found_existing) {	423	if (!res.found_existing) {
...	@@ -425,7 +425,7 @@ pub fn resolveLiterals(self: InternalObject, lp: MachO.LiteralPool, macho_file	...	@@ -425,7 +425,7 @@ pub fn resolveLiterals(self: InternalObject, lp: MachO.LiteralPool, macho_file
425	} else {	425	} else {
426	const lp_sym = lp.getSymbol(res.index, macho_file);	426	const lp_sym = lp.getSymbol(res.index, macho_file);
427	const lp_atom = lp_sym.getAtom(macho_file).?;	427	const lp_atom = lp_sym.getAtom(macho_file).?;
428	lp_atom.alignment = @max(lp_atom.alignment, atom.alignment);	428	lp_atom.alignment = lp_atom.alignment.max(atom.alignment);
429	atom.flags.alive = false;	429	atom.flags.alive = false;
430	}	430	}
431	atom.addExtra(.{ .literal_pool_index = res.index }, macho_file);	431	atom.addExtra(.{ .literal_pool_index = res.index }, macho_file);
...	@@ -438,7 +438,7 @@ pub fn dedupLiterals(self: InternalObject, lp: MachO.LiteralPool, macho_file:	...	@@ -438,7 +438,7 @@ pub fn dedupLiterals(self: InternalObject, lp: MachO.LiteralPool, macho_file:
438		438
439	for (self.getAtoms()) \|atom_index\| {	439	for (self.getAtoms()) \|atom_index\| {
440	const atom = self.getAtom(atom_index) orelse continue;	440	const atom = self.getAtom(atom_index) orelse continue;
441	if (!atom.alive.load(.seq_cst)) continue;	441	if (!atom.flags.alive) continue;
442		442
443	const relocs = blk: {	443	const relocs = blk: {
444	const extra = atom.getExtra(macho_file);	444	const extra = atom.getExtra(macho_file);
...	@@ -463,7 +463,7 @@ pub fn dedupLiterals(self: InternalObject, lp: MachO.LiteralPool, macho_file:	...	@@ -463,7 +463,7 @@ pub fn dedupLiterals(self: InternalObject, lp: MachO.LiteralPool, macho_file:
463	}	463	}
464		464
465	for (self.symbols.items) \|*sym\| {	465	for (self.symbols.items) \|*sym\| {
466	if (!sym.getSectionFlags().objc_stubs) continue;	466	if (!sym.flags.objc_stubs) continue;
467	const extra = sym.getExtra(macho_file);	467	const extra = sym.getExtra(macho_file);
468	const file = sym.getFile(macho_file).?;	468	const file = sym.getFile(macho_file).?;
469	if (file.getIndex() != self.index) continue;	469	if (file.getIndex() != self.index) continue;
...	@@ -495,14 +495,14 @@ pub fn scanRelocs(self: InternalObject, macho_file: MachO) void {	...	@@ -495,14 +495,14 @@ pub fn scanRelocs(self: InternalObject, macho_file: MachO) void {
495	if (self.getDyldStubBinderRef(macho_file)) \|ref\| {	495	if (self.getDyldStubBinderRef(macho_file)) \|ref\| {
496	if (ref.getFile(macho_file) != null) {	496	if (ref.getFile(macho_file) != null) {
497	const sym = ref.getSymbol(macho_file).?;	497	const sym = ref.getSymbol(macho_file).?;
498	sym.flags.got = true;	498	sym.flags.needs_got = true;
499	}	499	}
500	}	500	}
501	if (self.getObjcMsgSendRef(macho_file)) \|ref\| {	501	if (self.getObjcMsgSendRef(macho_file)) \|ref\| {
502	if (ref.getFile(macho_file) != null) {	502	if (ref.getFile(macho_file) != null) {
503	const sym = ref.getSymbol(macho_file).?;	503	const sym = ref.getSymbol(macho_file).?;
504	// TODO is it always needed, or only if we are synthesising fast stubs	504	// TODO is it always needed, or only if we are synthesising fast stubs
505	sym.flags.got = true;	505	sym.flags.needs_got = true;
506	}	506	}
507	}	507	}
508	}	508	}
...	@@ -569,30 +569,30 @@ pub fn writeAtoms(self: InternalObject, macho_file: MachO) !void {	...	@@ -569,30 +569,30 @@ pub fn writeAtoms(self: InternalObject, macho_file: MachO) !void {
569		569
570	for (self.getAtoms()) \|atom_index\| {	570	for (self.getAtoms()) \|atom_index\| {
571	const atom = self.getAtom(atom_index) orelse continue;	571	const atom = self.getAtom(atom_index) orelse continue;
572	if (!atom.alive.load(.seq_cst)) continue;	572	if (!atom.flags.alive) continue;
573	const sect = atom.getInputSection(macho_file);	573	const sect = atom.getInputSection(macho_file);
574	if (sect.isZerofill()) continue;	574	if (sect.isZerofill()) continue;
575	const off = atom.value;	575	const off = atom.value;
576	const buffer = macho_file.sections.items(.out)[atom.out_n_sect].items[off..][0..atom.size];	576	const buffer = macho_file.sections.items(.out)[atom.out_n_sect].items[off..][0..atom.size];
577	@memcpy(buffer, self.getSectionData(atom.n_sect));	577	@memcpy(buffer, try self.getSectionData(atom.n_sect));
578	try atom.resolveRelocs(macho_file, buffer);	578	try atom.resolveRelocs(macho_file, buffer);
579	}	579	}
580	}	580	}
581		581
582	pub fn writeSymtab(self: InternalObject, macho_file: *MachO) void {	582	pub fn writeSymtab(self: InternalObject, macho_file: *MachO, ctx: anytype) void {
583	var n_strx = self.output_symtab_ctx.stroff;	583	var n_strx = self.output_symtab_ctx.stroff;
584	for (self.symbols.items, 0..) \|sym, i\| {	584	for (self.symbols.items, 0..) \|sym, i\| {
585	const ref = self.getSymbolRef(@intCast(i), macho_file);	585	const ref = self.getSymbolRef(@intCast(i), macho_file);
586	const file = ref.getFile(macho_file) orelse continue;	586	const file = ref.getFile(macho_file) orelse continue;
587	if (file.getIndex() != self.index) continue;	587	if (file.getIndex() != self.index) continue;
588	const idx = sym.getOutputSymtabIndex(macho_file) orelse continue;	588	const idx = sym.getOutputSymtabIndex(macho_file) orelse continue;
589	const out_sym = &macho_file.symtab.items[idx];	589	const out_sym = &ctx.symtab.items[idx];
590	out_sym.n_strx = n_strx;	590	out_sym.n_strx = n_strx;
591	sym.setOutputSym(macho_file, out_sym);	591	sym.setOutputSym(macho_file, out_sym);
592	const name = sym.getName(macho_file);	592	const name = sym.getName(macho_file);
593	@memcpy(macho_file.strtab.items[n_strx..][0..name.len], name);	593	@memcpy(ctx.strtab.items[n_strx..][0..name.len], name);
594	n_strx += @intCast(name.len);	594	n_strx += @intCast(name.len);
595	macho_file.strtab.items[n_strx] = 0;	595	ctx.strtab.items[n_strx] = 0;
596	n_strx += 1;	596	n_strx += 1;
597	}	597	}
598	}	598	}
...	@@ -640,7 +640,7 @@ pub fn asFile(self: *InternalObject) File {	...	@@ -640,7 +640,7 @@ pub fn asFile(self: *InternalObject) File {
640	}	640	}
641		641
642	pub fn getAtomRelocs(self: const InternalObject, atom: Atom, macho_file: MachO) []const Relocation {	642	pub fn getAtomRelocs(self: const InternalObject, atom: Atom, macho_file: MachO) []const Relocation {
643	const extra = atom.getExtra(macho_file).?;	643	const extra = atom.getExtra(macho_file);
644	const relocs = self.sections.items(.relocs)[atom.n_sect];	644	const relocs = self.sections.items(.relocs)[atom.n_sect];
645	return relocs.items[extra.rel_index..][0..extra.rel_count];	645	return relocs.items[extra.rel_index..][0..extra.rel_count];
646	}	646	}

...	@@ -34,7 +34,7 @@ pub fn updateSize(rebase: Rebase, macho_file: MachO) !void {	...	@@ -34,7 +34,7 @@ pub fn updateSize(rebase: Rebase, macho_file: MachO) !void {
34	for (objects.items) \|index\| {	34	for (objects.items) \|index\| {
35	const file = macho_file.getFile(index).?;	35	const file = macho_file.getFile(index).?;
36	for (file.getAtoms()) \|atom_index\| {	36	for (file.getAtoms()) \|atom_index\| {
37	const atom = macho_file.getAtom(atom_index) orelse continue;	37	const atom = file.getAtom(atom_index) orelse continue;
38	if (!atom.flags.alive) continue;	38	if (!atom.flags.alive) continue;
39	if (atom.getInputSection(macho_file).isZerofill()) continue;	39	if (atom.getInputSection(macho_file).isZerofill()) continue;
40	const atom_addr = atom.getAddress(macho_file);	40	const atom_addr = atom.getAddress(macho_file);
...	@@ -43,7 +43,7 @@ pub fn updateSize(rebase: Rebase, macho_file: MachO) !void {	...	@@ -43,7 +43,7 @@ pub fn updateSize(rebase: Rebase, macho_file: MachO) !void {
43	for (atom.getRelocs(macho_file)) \|rel\| {	43	for (atom.getRelocs(macho_file)) \|rel\| {
44	if (rel.type != .unsigned or rel.meta.length != 3) continue;	44	if (rel.type != .unsigned or rel.meta.length != 3) continue;
45	if (rel.tag == .@"extern") {	45	if (rel.tag == .@"extern") {
46	const sym = rel.getTargetSymbol(macho_file);	46	const sym = rel.getTargetSymbol(atom.*, macho_file);
47	if (sym.isTlvInit(macho_file)) continue;	47	if (sym.isTlvInit(macho_file)) continue;
48	if (sym.flags.import) continue;	48	if (sym.flags.import) continue;
49	}	49	}
...	@@ -72,7 +72,7 @@ pub fn updateSize(rebase: Rebase, macho_file: MachO) !void {	...	@@ -72,7 +72,7 @@ pub fn updateSize(rebase: Rebase, macho_file: MachO) !void {
72	const seg_id = macho_file.sections.items(.segment_id)[sid];	72	const seg_id = macho_file.sections.items(.segment_id)[sid];
73	const seg = macho_file.segments.items[seg_id];	73	const seg = macho_file.segments.items[seg_id];
74	for (macho_file.got.symbols.items, 0..) \|ref, idx\| {	74	for (macho_file.got.symbols.items, 0..) \|ref, idx\| {
75	const sym = macho_file.getSymbol(ref);	75	const sym = ref.getSymbol(macho_file).?;
76	const addr = macho_file.got.getAddress(@intCast(idx), macho_file);	76	const addr = macho_file.got.getAddress(@intCast(idx), macho_file);
77	if (!sym.flags.import) {	77	if (!sym.flags.import) {
78	try rebase.entries.append(gpa, .{	78	try rebase.entries.append(gpa, .{
...	@@ -88,7 +88,7 @@ pub fn updateSize(rebase: Rebase, macho_file: MachO) !void {	...	@@ -88,7 +88,7 @@ pub fn updateSize(rebase: Rebase, macho_file: MachO) !void {
88	const seg_id = macho_file.sections.items(.segment_id)[sid];	88	const seg_id = macho_file.sections.items(.segment_id)[sid];
89	const seg = macho_file.segments.items[seg_id];	89	const seg = macho_file.segments.items[seg_id];
90	for (macho_file.stubs.symbols.items, 0..) \|ref, idx\| {	90	for (macho_file.stubs.symbols.items, 0..) \|ref, idx\| {
91	const sym = macho_file.getSymbol(ref);	91	const sym = ref.getSymbol(macho_file).?;
92	const addr = sect.addr + idx * @sizeOf(u64);	92	const addr = sect.addr + idx * @sizeOf(u64);
93	const rebase_entry = Rebase.Entry{	93	const rebase_entry = Rebase.Entry{
94	.offset = addr - seg.vmaddr,	94	.offset = addr - seg.vmaddr,
...	@@ -104,7 +104,7 @@ pub fn updateSize(rebase: Rebase, macho_file: MachO) !void {	...	@@ -104,7 +104,7 @@ pub fn updateSize(rebase: Rebase, macho_file: MachO) !void {
104	const seg_id = macho_file.sections.items(.segment_id)[sid];	104	const seg_id = macho_file.sections.items(.segment_id)[sid];
105	const seg = macho_file.segments.items[seg_id];	105	const seg = macho_file.segments.items[seg_id];
106	for (macho_file.tlv_ptr.symbols.items, 0..) \|ref, idx\| {	106	for (macho_file.tlv_ptr.symbols.items, 0..) \|ref, idx\| {
107	const sym = macho_file.getSymbol(ref);	107	const sym = ref.getSymbol(macho_file).?;
108	const addr = macho_file.tlv_ptr.getAddress(@intCast(idx), macho_file);	108	const addr = macho_file.tlv_ptr.getAddress(@intCast(idx), macho_file);
109	if (!sym.flags.import) {	109	if (!sym.flags.import) {
110	try rebase.entries.append(gpa, .{	110	try rebase.entries.append(gpa, .{

...	@@ -30,10 +30,10 @@ pub const File = union(enum) {	...	@@ -30,10 +30,10 @@ pub const File = union(enum) {
30	}	30	}
31	}	31	}
32		32
33	pub fn resolveSymbols(file: File, macho_file: *MachO) void {	33	pub fn resolveSymbols(file: File, macho_file: *MachO) !void {
34	switch (file) {	34	return switch (file) {
35	inline else => \|x\| x.resolveSymbols(macho_file),	35	inline else => \|x\| x.resolveSymbols(macho_file),
36	}	36	};
37	}	37	}
38		38
39	pub fn scanRelocs(file: File, macho_file: *MachO) !void {	39	pub fn scanRelocs(file: File, macho_file: *MachO) !void {
...	@@ -147,19 +147,19 @@ pub const File = union(enum) {	...	@@ -147,19 +147,19 @@ pub const File = union(enum) {
147	if (ref.getFile(macho_file) == null) continue;	147	if (ref.getFile(macho_file) == null) continue;
148	if (ref.file != file.getIndex()) continue;	148	if (ref.file != file.getIndex()) continue;
149	const sym = ref.getSymbol(macho_file).?;	149	const sym = ref.getSymbol(macho_file).?;
150	if (sym.getSectionFlags().got) {	150	if (sym.flags.needs_got) {
151	log.debug("'{s}' needs GOT", .{sym.getName(macho_file)});	151	log.debug("'{s}' needs GOT", .{sym.getName(macho_file)});
152	try macho_file.got.addSymbol(ref, macho_file);	152	try macho_file.got.addSymbol(ref, macho_file);
153	}	153	}
154	if (sym.getSectionFlags().stubs) {	154	if (sym.flags.stubs) {
155	log.debug("'{s}' needs STUBS", .{sym.getName(macho_file)});	155	log.debug("'{s}' needs STUBS", .{sym.getName(macho_file)});
156	try macho_file.stubs.addSymbol(ref, macho_file);	156	try macho_file.stubs.addSymbol(ref, macho_file);
157	}	157	}
158	if (sym.getSectionFlags().tlv_ptr) {	158	if (sym.flags.tlv_ptr) {
159	log.debug("'{s}' needs TLV pointer", .{sym.getName(macho_file)});	159	log.debug("'{s}' needs TLV pointer", .{sym.getName(macho_file)});
160	try macho_file.tlv_ptr.addSymbol(ref, macho_file);	160	try macho_file.tlv_ptr.addSymbol(ref, macho_file);
161	}	161	}
162	if (sym.getSectionFlags().objc_stubs) {	162	if (sym.flags.objc_stubs) {
163	log.debug("'{s}' needs OBJC STUBS", .{sym.getName(macho_file)});	163	log.debug("'{s}' needs OBJC STUBS", .{sym.getName(macho_file)});
164	try macho_file.objc_stubs.addSymbol(ref, macho_file);	164	try macho_file.objc_stubs.addSymbol(ref, macho_file);
165	}	165	}
...	@@ -171,7 +171,7 @@ pub const File = union(enum) {	...	@@ -171,7 +171,7 @@ pub const File = union(enum) {
171	defer tracy.end();	171	defer tracy.end();
172	for (file.getAtoms()) \|atom_index\| {	172	for (file.getAtoms()) \|atom_index\| {
173	const atom = file.getAtom(atom_index) orelse continue;	173	const atom = file.getAtom(atom_index) orelse continue;
174	if (!atom.alive.load(.seq_cst)) continue;	174	if (!atom.flags.alive) continue;
175	atom.out_n_sect = try Atom.initOutputSection(atom.getInputSection(macho_file), macho_file);	175	atom.out_n_sect = try Atom.initOutputSection(atom.getInputSection(macho_file), macho_file);
176	}	176	}
177	}	177	}
...	@@ -185,18 +185,18 @@ pub const File = union(enum) {	...	@@ -185,18 +185,18 @@ pub const File = union(enum) {
185		185
186	pub fn writeAtoms(file: File, macho_file: *MachO) !void {	186	pub fn writeAtoms(file: File, macho_file: *MachO) !void {
187	return switch (file) {	187	return switch (file) {
188	.dylib => unreachable,	188	.dylib, .zig_object => unreachable,
189	inline else => \|x\| x.writeAtoms(macho_file),	189	inline else => \|x\| x.writeAtoms(macho_file),
190	};	190	};
191	}	191	}
192		192
193	pub fn calcSymtabSize(file: File, macho_file: *MachO) !void {	193	pub fn calcSymtabSize(file: File, macho_file: *MachO) void {
194	return switch (file) {	194	return switch (file) {
195	inline else => \|x\| x.calcSymtabSize(macho_file),	195	inline else => \|x\| x.calcSymtabSize(macho_file),
196	};	196	};
197	}	197	}
198		198
199	pub fn writeSymtab(file: File, macho_file: *MachO, ctx: anytype) !void {	199	pub fn writeSymtab(file: File, macho_file: *MachO, ctx: anytype) void {
200	return switch (file) {	200	return switch (file) {
201	inline else => \|x\| x.writeSymtab(macho_file, ctx),	201	inline else => \|x\| x.writeSymtab(macho_file, ctx),
202	};	202	};

...	@@ -23,7 +23,7 @@ pub const ZigGotSection = struct {	...	@@ -23,7 +23,7 @@ pub const ZigGotSection = struct {
23	const index = try zig_got.allocateEntry(gpa);	23	const index = try zig_got.allocateEntry(gpa);
24	const entry = &zig_got.entries.items[index];	24	const entry = &zig_got.entries.items[index];
25	entry.* = sym_index;	25	entry.* = sym_index;
26	const symbol = zo.getSymbol(sym_index);	26	const symbol = &zo.symbols.items[sym_index];
27	assert(symbol.flags.needs_zig_got);	27	assert(symbol.flags.needs_zig_got);
28	symbol.flags.has_zig_got = true;	28	symbol.flags.has_zig_got = true;
29	symbol.addExtra(.{ .zig_got = index }, macho_file);	29	symbol.addExtra(.{ .zig_got = index }, macho_file);
...	@@ -56,7 +56,7 @@ pub const ZigGotSection = struct {	...	@@ -56,7 +56,7 @@ pub const ZigGotSection = struct {
56	const zo = macho_file.getZigObject().?;	56	const zo = macho_file.getZigObject().?;
57	const off = zig_got.entryOffset(index, macho_file);	57	const off = zig_got.entryOffset(index, macho_file);
58	const entry = zig_got.entries.items[index];	58	const entry = zig_got.entries.items[index];
59	const value = zo.getSymbol(entry).getAddress(.{ .stubs = false }, macho_file);	59	const value = zo.symbols.items[entry].getAddress(.{ .stubs = false }, macho_file);
60		60
61	var buf: [8]u8 = undefined;	61	var buf: [8]u8 = undefined;
62	std.mem.writeInt(u64, &buf, value, .little);	62	std.mem.writeInt(u64, &buf, value, .little);
...	@@ -66,7 +66,7 @@ pub const ZigGotSection = struct {	...	@@ -66,7 +66,7 @@ pub const ZigGotSection = struct {
66	pub fn writeAll(zig_got: ZigGotSection, macho_file: *MachO, writer: anytype) !void {	66	pub fn writeAll(zig_got: ZigGotSection, macho_file: *MachO, writer: anytype) !void {
67	const zo = macho_file.getZigObject().?;	67	const zo = macho_file.getZigObject().?;
68	for (zig_got.entries.items) \|entry\| {	68	for (zig_got.entries.items) \|entry\| {
69	const symbol = zo.getSymbol(entry);	69	const symbol = zo.symbols.items[entry];
70	const value = symbol.address(.{ .stubs = false }, macho_file);	70	const value = symbol.address(.{ .stubs = false }, macho_file);
71	try writer.writeInt(u64, value, .little);	71	try writer.writeInt(u64, value, .little);
72	}	72	}
...	@@ -94,7 +94,7 @@ pub const ZigGotSection = struct {	...	@@ -94,7 +94,7 @@ pub const ZigGotSection = struct {
94	const zo = macho_file.getZigObject().?;	94	const zo = macho_file.getZigObject().?;
95	try writer.writeAll("__zig_got\n");	95	try writer.writeAll("__zig_got\n");
96	for (zig_got.entries.items, 0..) \|entry, index\| {	96	for (zig_got.entries.items, 0..) \|entry, index\| {
97	const symbol = zo.getSymbol(entry);	97	const symbol = zo.symbols.items[entry];
98	try writer.print(" {d}@0x{x} => {d}@0x{x} ({s})\n", .{	98	try writer.print(" {d}@0x{x} => {d}@0x{x} ({s})\n", .{
99	index,	99	index,
100	zig_got.entryAddress(@intCast(index), macho_file),	100	zig_got.entryAddress(@intCast(index), macho_file),
...	@@ -694,7 +694,7 @@ pub const DataInCode = struct {	...	@@ -694,7 +694,7 @@ pub const DataInCode = struct {
694	dices[next_dice].offset < end_off) : (next_dice += 1)	694	dices[next_dice].offset < end_off) : (next_dice += 1)
695	{}	695	{}
696		696
697	if (atom.alive.load(.seq_cst)) for (dices[start_dice..next_dice]) \|d\| {	697	if (atom.flags.alive) for (dices[start_dice..next_dice]) \|d\| {
698	dice.entries.appendAssumeCapacity(.{	698	dice.entries.appendAssumeCapacity(.{
699	.offset = @intCast(atom.getAddress(macho_file) + d.offset - start_off - base_address),	699	.offset = @intCast(atom.getAddress(macho_file) + d.offset - start_off - base_address),
700	.length = d.length,	700	.length = d.length,