authorgravatar for kubkon@jakubkonka.comJakub Konka <kubkon@jakubkonka.com> 2021-07-03 15:30:42+02:00
committergravatar for kubkon@jakubkonka.comJakub Konka <kubkon@jakubkonka.com> 2021-07-15 18:49:47+02:00
log3bd9f3801771189ad1aa9d9b41786026add38075
treec15bd0d54a436a38013644816710cdd2bcbc0860
parent7c82079d2cfb2f8c299707aa4c79455a73601914

zld: reenable entire linker in the new scheme

without the stabs... They are tricky and need a bit more work.

2 files changed, 133 insertions(+), 136 deletions(-)

src/link/MachO/Symbol.zig+13-8
......@@ -58,13 +58,6 @@ pub const Regular = struct {
5858 global,
5959 };
6060
61 pub fn isTemp(regular: Regular) bool {
62 if (regular.linkage == .translation_unit) {
63 return mem.startsWith(u8, regular.base.name, "l") or mem.startsWith(u8, regular.base.name, "L");
64 }
65 return false;
66 }
67
6861 pub fn format(self: Regular, comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
6962 try std.fmt.format(writer, "Regular {{ ", .{});
7063 try std.fmt.format(writer, ".linkage = {s}, ", .{self.linkage});
......@@ -164,7 +157,19 @@ pub fn new(allocator: *Allocator, name: []const u8) !*Symbol {
164157 return new_sym;
165158}
166159
167pub fn asNlist(symbol: *Symbol, strtab: *StringTable) macho.nlist_64 {
160pub fn isTemp(symbol: Symbol) bool {
161 switch (symbol.payload) {
162 .regular => |regular| {
163 if (regular.linkage == .translation_unit) {
164 return mem.startsWith(u8, symbol.name, "l") or mem.startsWith(u8, symbol.name, "L");
165 }
166 },
167 else => {},
168 }
169 return false;
170}
171
172pub fn asNlist(symbol: *Symbol, strtab: *StringTable) !macho.nlist_64 {
168173 const n_strx = try strtab.getOrPut(symbol.name);
169174 const nlist = nlist: {
170175 switch (symbol.payload) {
src/link/MachO/Zld.zig+120-128
......@@ -237,20 +237,19 @@ pub fn link(self: *Zld, files: []const []const u8, output: Output, args: LinkArg
237237 try self.allocateTentativeSymbols();
238238 try self.allocateProxyBindAddresses();
239239
240 log.warn("globals", .{});
241 for (self.globals.values()) |value| {
242 log.warn(" | {s}: {}", .{ value.name, value.payload });
243 }
244
245 for (self.objects.items) |object| {
246 log.warn("object {s}", .{object.name.?});
247 for (object.symbols.items) |sym| {
248 log.warn(" | {s}: {}", .{ sym.name, sym.payload });
249 }
250 }
251
252 return error.TODO;
253 // try self.flush();
240 // log.warn("globals", .{});
241 // for (self.globals.values()) |value| {
242 // log.warn(" | {s}: {}", .{ value.name, value.payload });
243 // }
244
245 // for (self.objects.items) |object| {
246 // log.warn("object {s}", .{object.name.?});
247 // for (object.symbols.items) |sym| {
248 // log.warn(" | {s}: {}", .{ sym.name, sym.payload });
249 // }
250 // }
251
252 try self.flush();
254253}
255254
256255fn parseInputFiles(self: *Zld, files: []const []const u8, syslibroot: ?[]const u8) !void {
......@@ -1226,7 +1225,7 @@ fn writeStubHelperCommon(self: *Zld) !void {
12261225 code[9] = 0xff;
12271226 code[10] = 0x25;
12281227 {
1229 const dyld_stub_binder = self.imports.get("dyld_stub_binder").?;
1228 const dyld_stub_binder = self.globals.get("dyld_stub_binder").?;
12301229 const addr = (got.addr + dyld_stub_binder.got_index.? * @sizeOf(u64));
12311230 const displacement = try math.cast(u32, addr - stub_helper.addr - code_size);
12321231 mem.writeIntLittle(u32, code[11..], displacement);
......@@ -1270,7 +1269,7 @@ fn writeStubHelperCommon(self: *Zld) !void {
12701269 code[10] = 0xbf;
12711270 code[11] = 0xa9;
12721271 binder_blk_outer: {
1273 const dyld_stub_binder = self.imports.get("dyld_stub_binder").?;
1272 const dyld_stub_binder = self.globals.get("dyld_stub_binder").?;
12741273 const this_addr = stub_helper.addr + 3 * @sizeOf(u32);
12751274 const target_addr = (got.addr + dyld_stub_binder.got_index.? * @sizeOf(u64));
12761275 binder_blk: {
......@@ -1789,8 +1788,8 @@ fn resolveRelocsAndWriteSections(self: *Zld) !void {
17891788 break :rebase false;
17901789 }
17911790 if (rel.target == .symbol) {
1792 const final = object.symbols.items[rel.target.symbol].getTopmostAlias();
1793 if (final.cast(Symbol.Proxy)) |_| {
1791 const sym = object.symbols.items[rel.target.symbol];
1792 if (sym.payload == .proxy) {
17941793 break :rebase false;
17951794 }
17961795 }
......@@ -1832,9 +1831,8 @@ fn resolveRelocsAndWriteSections(self: *Zld) !void {
18321831 const dc_seg = self.load_commands.items[self.data_const_segment_cmd_index.?].Segment;
18331832 const got = dc_seg.sections.items[self.got_section_index.?];
18341833 const sym = object.symbols.items[rel.target.symbol];
1835 const final = sym.getTopmostAlias();
1836 const got_index = final.got_index orelse {
1837 log.err("expected GOT index relocating symbol '{s}'", .{final.name});
1834 const got_index = sym.got_index orelse {
1835 log.err("expected GOT index relocating symbol '{s}'", .{sym.name});
18381836 log.err("this is an internal linker error", .{});
18391837 return error.FailedToResolveRelocationTarget;
18401838 };
......@@ -1890,37 +1888,40 @@ fn relocTargetAddr(self: *Zld, object: *const Object, target: reloc.Relocation.T
18901888 switch (target) {
18911889 .symbol => |sym_id| {
18921890 const sym = object.symbols.items[sym_id];
1893 const final = sym.getTopmostAlias();
1894 if (final.cast(Symbol.Regular)) |reg| {
1895 log.debug(" | regular '{s}'", .{sym.name});
1896 break :blk reg.address;
1897 } else if (final.cast(Symbol.Proxy)) |proxy| {
1898 if (mem.eql(u8, sym.name, "__tlv_bootstrap")) {
1899 log.debug(" | symbol '__tlv_bootstrap'", .{});
1900 const segment = self.load_commands.items[self.data_segment_cmd_index.?].Segment;
1901 const tlv = segment.sections.items[self.tlv_section_index.?];
1902 break :blk tlv.addr;
1903 }
1904
1905 log.debug(" | symbol stub '{s}'", .{sym.name});
1906 const segment = self.load_commands.items[self.text_segment_cmd_index.?].Segment;
1907 const stubs = segment.sections.items[self.stubs_section_index.?];
1908 const stubs_index = proxy.base.stubs_index orelse {
1909 if (proxy.bind_info.items.len > 0) {
1910 break :blk 0; // Dynamically bound by dyld.
1891 switch (sym.payload) {
1892 .regular => |reg| {
1893 log.debug(" | regular '{s}'", .{sym.name});
1894 break :blk reg.address;
1895 },
1896 .proxy => |proxy| {
1897 if (mem.eql(u8, sym.name, "__tlv_bootstrap")) {
1898 log.debug(" | symbol '__tlv_bootstrap'", .{});
1899 const segment = self.load_commands.items[self.data_segment_cmd_index.?].Segment;
1900 const tlv = segment.sections.items[self.tlv_section_index.?];
1901 break :blk tlv.addr;
19111902 }
1912 log.err(
1913 "expected stubs index or dynamic bind address when relocating symbol '{s}'",
1914 .{final.name},
1915 );
1903
1904 log.debug(" | symbol stub '{s}'", .{sym.name});
1905 const segment = self.load_commands.items[self.text_segment_cmd_index.?].Segment;
1906 const stubs = segment.sections.items[self.stubs_section_index.?];
1907 const stubs_index = sym.stubs_index orelse {
1908 if (proxy.bind_info.items.len > 0) {
1909 break :blk 0; // Dynamically bound by dyld.
1910 }
1911 log.err(
1912 "expected stubs index or dynamic bind address when relocating symbol '{s}'",
1913 .{sym.name},
1914 );
1915 log.err("this is an internal linker error", .{});
1916 return error.FailedToResolveRelocationTarget;
1917 };
1918 break :blk stubs.addr + stubs_index * stubs.reserved2;
1919 },
1920 else => {
1921 log.err("failed to resolve symbol '{s}' as a relocation target", .{sym.name});
19161922 log.err("this is an internal linker error", .{});
19171923 return error.FailedToResolveRelocationTarget;
1918 };
1919 break :blk stubs.addr + stubs_index * stubs.reserved2;
1920 } else {
1921 log.err("failed to resolve symbol '{s}' as a relocation target", .{sym.name});
1922 log.err("this is an internal linker error", .{});
1923 return error.FailedToResolveRelocationTarget;
1924 },
19241925 }
19251926 },
19261927 .section => |sect_id| {
......@@ -2320,8 +2321,8 @@ fn flush(self: *Zld) !void {
23202321 defer initializers.deinit();
23212322
23222323 for (self.objects.items) |object| {
2323 for (object.initializers.items) |initializer| {
2324 const address = initializer.cast(Symbol.Regular).?.address;
2324 for (object.initializers.items) |sym_id| {
2325 const address = object.symbols.items[sym_id].payload.regular.address;
23252326 try initializers.append(address);
23262327 }
23272328 }
......@@ -2381,7 +2382,10 @@ fn writeGotEntries(self: *Zld) !void {
23812382 var writer = stream.writer();
23822383
23832384 for (self.got_entries.items) |sym| {
2384 const address: u64 = if (sym.cast(Symbol.Regular)) |reg| reg.address else 0;
2385 const address: u64 = switch (sym.payload) {
2386 .regular => |reg| reg.address,
2387 else => 0,
2388 };
23852389 try writer.writeIntLittle(u64, address);
23862390 }
23872391
......@@ -2397,9 +2401,8 @@ fn setEntryPoint(self: *Zld) !void {
23972401 // entrypoint. For now, assume default of `_main`.
23982402 const seg = self.load_commands.items[self.text_segment_cmd_index.?].Segment;
23992403 const sym = self.globals.get("_main") orelse return error.MissingMainEntrypoint;
2400 const entry_sym = sym.cast(Symbol.Regular) orelse unreachable;
24012404 const ec = &self.load_commands.items[self.main_cmd_index.?].Main;
2402 ec.entryoff = @intCast(u32, entry_sym.address - seg.inner.vmaddr);
2405 ec.entryoff = @intCast(u32, sym.payload.regular.address - seg.inner.vmaddr);
24032406 ec.stacksize = self.stack_size;
24042407}
24052408
......@@ -2417,7 +2420,8 @@ fn writeRebaseInfoTable(self: *Zld) !void {
24172420 const segment_id = @intCast(u16, self.data_const_segment_cmd_index.?);
24182421
24192422 for (self.got_entries.items) |sym| {
2420 if (sym.@"type" == .proxy) continue;
2423 if (sym.payload == .proxy) continue;
2424
24212425 try pointers.append(.{
24222426 .offset = base_offset + sym.got_index.? * @sizeOf(u64),
24232427 .segment_id = segment_id,
......@@ -2489,28 +2493,30 @@ fn writeBindInfoTable(self: *Zld) !void {
24892493 const segment_id = @intCast(u16, self.data_const_segment_cmd_index.?);
24902494
24912495 for (self.got_entries.items) |sym| {
2492 if (sym.cast(Symbol.Proxy)) |proxy| {
2493 try pointers.append(.{
2494 .offset = base_offset + proxy.base.got_index.? * @sizeOf(u64),
2495 .segment_id = segment_id,
2496 .dylib_ordinal = proxy.dylibOrdinal(),
2497 .name = proxy.base.name,
2498 });
2499 }
2496 if (sym.payload != .proxy) continue;
2497
2498 const proxy = sym.payload.proxy;
2499 try pointers.append(.{
2500 .offset = base_offset + sym.got_index.? * @sizeOf(u64),
2501 .segment_id = segment_id,
2502 .dylib_ordinal = proxy.dylibOrdinal(),
2503 .name = sym.name,
2504 });
25002505 }
25012506 }
25022507
2503 for (self.imports.values()) |sym| {
2504 if (sym.cast(Symbol.Proxy)) |proxy| {
2505 for (proxy.bind_info.items) |info| {
2506 const seg = self.load_commands.items[info.segment_id].Segment;
2507 try pointers.append(.{
2508 .offset = info.address - seg.inner.vmaddr,
2509 .segment_id = info.segment_id,
2510 .dylib_ordinal = proxy.dylibOrdinal(),
2511 .name = proxy.base.name,
2512 });
2513 }
2508 for (self.globals.values()) |sym| {
2509 if (sym.payload != .proxy) continue;
2510
2511 const proxy = sym.payload.proxy;
2512 for (proxy.bind_info.items) |info| {
2513 const seg = self.load_commands.items[info.segment_id].Segment;
2514 try pointers.append(.{
2515 .offset = info.address - seg.inner.vmaddr,
2516 .segment_id = info.segment_id,
2517 .dylib_ordinal = proxy.dylibOrdinal(),
2518 .name = sym.name,
2519 });
25142520 }
25152521 }
25162522
......@@ -2520,14 +2526,13 @@ fn writeBindInfoTable(self: *Zld) !void {
25202526 const base_offset = sect.addr - seg.inner.vmaddr;
25212527 const segment_id = @intCast(u16, self.data_segment_cmd_index.?);
25222528
2523 const sym = self.imports.get("__tlv_bootstrap") orelse unreachable;
2524 const proxy = sym.cast(Symbol.Proxy) orelse unreachable;
2525
2529 const sym = self.globals.get("__tlv_bootstrap") orelse unreachable;
2530 const proxy = sym.payload.proxy;
25262531 try pointers.append(.{
25272532 .offset = base_offset,
25282533 .segment_id = segment_id,
25292534 .dylib_ordinal = proxy.dylibOrdinal(),
2530 .name = proxy.base.name,
2535 .name = sym.name,
25312536 });
25322537 }
25332538
......@@ -2562,7 +2567,7 @@ fn writeLazyBindInfoTable(self: *Zld) !void {
25622567 try pointers.ensureCapacity(self.stubs.items.len);
25632568
25642569 for (self.stubs.items) |sym| {
2565 const proxy = sym.cast(Symbol.Proxy) orelse unreachable;
2570 const proxy = sym.payload.proxy;
25662571 pointers.appendAssumeCapacity(.{
25672572 .offset = base_offset + sym.stubs_index.? * @sizeOf(u64),
25682573 .segment_id = segment_id,
......@@ -2676,7 +2681,8 @@ fn writeExportInfo(self: *Zld) !void {
26762681 defer sorted_globals.deinit();
26772682
26782683 for (self.globals.values()) |sym| {
2679 const reg = sym.cast(Symbol.Regular) orelse continue;
2684 if (sym.payload != .regular) continue;
2685 const reg = sym.payload.regular;
26802686 if (reg.linkage != .global) continue;
26812687 try sorted_globals.append(sym.name);
26822688 }
......@@ -2685,9 +2691,9 @@ fn writeExportInfo(self: *Zld) !void {
26852691
26862692 for (sorted_globals.items) |sym_name| {
26872693 const sym = self.globals.get(sym_name) orelse unreachable;
2688 const reg = sym.cast(Symbol.Regular) orelse unreachable;
2694 const reg = sym.payload.regular;
26892695
2690 log.debug(" | putting '{s}' defined at 0x{x}", .{ reg.base.name, reg.address });
2696 log.debug(" | putting '{s}' defined at 0x{x}", .{ sym.name, reg.address });
26912697
26922698 try trie.put(.{
26932699 .name = sym.name,
......@@ -2722,50 +2728,33 @@ fn writeSymbolTable(self: *Zld) !void {
27222728
27232729 var locals = std.ArrayList(macho.nlist_64).init(self.allocator);
27242730 defer locals.deinit();
2731 try locals.ensureTotalCapacity(self.locals.items.len);
2732
2733 for (self.locals.items) |symbol| {
2734 if (symbol.isTemp()) continue; // TODO when merging codepaths, this should go into freelist
2735 const nlist = try symbol.asNlist(&self.strtab);
2736 locals.appendAssumeCapacity(nlist);
2737 }
27252738
27262739 var exports = std.ArrayList(macho.nlist_64).init(self.allocator);
27272740 defer exports.deinit();
27282741
2729 for (self.objects.items) |object| {
2730 for (object.stabs.items) |sym| {
2731 const stab = sym.cast(Symbol.Stab) orelse unreachable;
2732
2733 const nlists = try stab.asNlists(self.allocator, &self.strtab);
2734 defer self.allocator.free(nlists);
2735
2736 try locals.appendSlice(nlists);
2737 }
2738
2739 for (object.symbols.items) |sym| {
2740 const final = sym.getTopmostAlias();
2741 if (final.@"type" != .regular) continue;
2742
2743 const reg = final.cast(Symbol.Regular) orelse unreachable;
2744 if (reg.isTemp()) continue;
2745 if (reg.visited) continue;
2746
2747 const nlist = try reg.asNlist(&self.strtab);
2748
2749 switch (reg.linkage) {
2750 .translation_unit => {
2751 try locals.append(nlist);
2752 },
2753 else => {
2754 try exports.append(nlist);
2755 },
2756 }
2757
2758 reg.visited = true;
2759 }
2760 }
2761
27622742 var undefs = std.ArrayList(macho.nlist_64).init(self.allocator);
27632743 defer undefs.deinit();
2744 var undef_dir = std.StringHashMap(u32).init(self.allocator);
2745 defer undef_dir.deinit();
27642746
2765 for (self.imports.values()) |sym| {
2766 const proxy = sym.cast(Symbol.Proxy) orelse unreachable;
2767 const nlist = try proxy.asNlist(&self.strtab);
2768 try undefs.append(nlist);
2747 for (self.globals.values()) |sym| {
2748 const nlist = try sym.asNlist(&self.strtab);
2749 switch (sym.payload) {
2750 .regular => try exports.append(nlist),
2751 .proxy => {
2752 const id = @intCast(u32, undefs.items.len);
2753 try undefs.append(nlist);
2754 try undef_dir.putNoClobber(sym.name, id);
2755 },
2756 else => unreachable,
2757 }
27692758 }
27702759
27712760 const nlocals = locals.items.len;
......@@ -2827,24 +2816,27 @@ fn writeSymbolTable(self: *Zld) !void {
28272816
28282817 stubs.reserved1 = 0;
28292818 for (self.stubs.items) |sym| {
2830 const id = self.imports.getIndex(sym.name) orelse unreachable;
2831 try writer.writeIntLittle(u32, dysymtab.iundefsym + @intCast(u32, id));
2819 const id = undef_dir.get(sym.name) orelse unreachable;
2820 try writer.writeIntLittle(u32, dysymtab.iundefsym + id);
28322821 }
28332822
28342823 got.reserved1 = nstubs;
28352824 for (self.got_entries.items) |sym| {
2836 if (sym.@"type" == .proxy) {
2837 const id = self.imports.getIndex(sym.name) orelse unreachable;
2838 try writer.writeIntLittle(u32, dysymtab.iundefsym + @intCast(u32, id));
2839 } else {
2840 try writer.writeIntLittle(u32, macho.INDIRECT_SYMBOL_LOCAL);
2825 switch (sym.payload) {
2826 .proxy => {
2827 const id = undef_dir.get(sym.name) orelse unreachable;
2828 try writer.writeIntLittle(u32, dysymtab.iundefsym + id);
2829 },
2830 else => {
2831 try writer.writeIntLittle(u32, macho.INDIRECT_SYMBOL_LOCAL);
2832 },
28412833 }
28422834 }
28432835
28442836 la_symbol_ptr.reserved1 = got.reserved1 + ngot_entries;
28452837 for (self.stubs.items) |sym| {
2846 const id = self.imports.getIndex(sym.name) orelse unreachable;
2847 try writer.writeIntLittle(u32, dysymtab.iundefsym + @intCast(u32, id));
2838 const id = undef_dir.get(sym.name) orelse unreachable;
2839 try writer.writeIntLittle(u32, dysymtab.iundefsym + id);
28482840 }
28492841
28502842 try self.file.?.pwriteAll(buf, dysymtab.indirectsymoff);