authorgravatar for kubkon@jakubkonka.comJakub Konka <kubkon@jakubkonka.com> 2023-08-25 08:45:00+02:00
committergravatar for kubkon@jakubkonka.comJakub Konka <kubkon@jakubkonka.com> 2023-08-29 11:39:34+02:00
logb2af2dc8b751e3a784b10f67314303b4e6514bdc
treebede8e08d0ef6abe2f523355ff11492c573e601e
parent19afd794d08bfbebc57ee1f0cb8ddfb8e5601cdd

macho: move symbol resolver into zld driver's state

3 files changed, 54 insertions(+), 63 deletions(-)

src/link/MachO.zig+3-9
......@@ -297,12 +297,6 @@ pub const SymbolWithLoc = extern struct {
297297 }
298298};
299299
300pub const SymbolResolver = struct {
301 arena: Allocator,
302 table: std.StringHashMap(u32),
303 unresolved: std.AutoArrayHashMap(u32, void),
304};
305
306300const HotUpdateState = struct {
307301 mach_task: ?std.os.darwin.MachTask = null,
308302};
......@@ -4092,15 +4086,15 @@ pub fn getSectionPrecedence(header: macho.section_64) u8 {
40924086 return (@as(u8, @intCast(segment_precedence)) << 4) + section_precedence;
40934087}
40944088
4095pub fn reportUndefined(self: *MachO, ctx: anytype, resolver: *const SymbolResolver) !void {
4096 const count = resolver.unresolved.count();
4089pub fn reportUndefined(self: *MachO, ctx: anytype) !void {
4090 const count = ctx.unresolved.count();
40974091 if (count == 0) return;
40984092
40994093 const gpa = self.base.allocator;
41004094
41014095 try self.misc_errors.ensureUnusedCapacity(gpa, count);
41024096
4103 for (resolver.unresolved.keys()) |global_index| {
4097 for (ctx.unresolved.keys()) |global_index| {
41044098 const global = ctx.globals.items[global_index];
41054099 const sym_name = ctx.getSymbolName(global);
41064100
src/link/MachO/dead_strip.zig+4-5
......@@ -12,13 +12,12 @@ const Allocator = mem.Allocator;
1212const Atom = @import("Atom.zig");
1313const MachO = @import("../MachO.zig");
1414const SymbolWithLoc = MachO.SymbolWithLoc;
15const SymbolResolver = MachO.SymbolResolver;
1615const UnwindInfo = @import("UnwindInfo.zig");
1716const Zld = @import("zld.zig").Zld;
1817
1918const AtomTable = std.AutoHashMap(Atom.Index, void);
2019
21pub fn gcAtoms(zld: *Zld, resolver: *const SymbolResolver) !void {
20pub fn gcAtoms(zld: *Zld) !void {
2221 const gpa = zld.gpa;
2322
2423 var arena = std.heap.ArenaAllocator.init(gpa);
......@@ -30,7 +29,7 @@ pub fn gcAtoms(zld: *Zld, resolver: *const SymbolResolver) !void {
3029 var alive = AtomTable.init(arena.allocator());
3130 try alive.ensureTotalCapacity(@as(u32, @intCast(zld.atoms.items.len)));
3231
33 try collectRoots(zld, &roots, resolver);
32 try collectRoots(zld, &roots);
3433 try mark(zld, roots, &alive);
3534 prune(zld, alive);
3635}
......@@ -48,7 +47,7 @@ fn addRoot(zld: *Zld, roots: *AtomTable, file: u32, sym_loc: SymbolWithLoc) !voi
4847 _ = try roots.getOrPut(atom_index);
4948}
5049
51fn collectRoots(zld: *Zld, roots: *AtomTable, resolver: *const SymbolResolver) !void {
50fn collectRoots(zld: *Zld, roots: *AtomTable) !void {
5251 log.debug("collecting roots", .{});
5352
5453 switch (zld.options.output_mode) {
......@@ -77,7 +76,7 @@ fn collectRoots(zld: *Zld, roots: *AtomTable, resolver: *const SymbolResolver) !
7776
7877 // Add all symbols force-defined by the user.
7978 for (zld.options.force_undefined_symbols.keys()) |sym_name| {
80 const global_index = resolver.table.get(sym_name).?;
79 const global_index = zld.resolver.get(sym_name).?;
8180 const global = zld.globals.items[global_index];
8281 const sym = zld.getSymbol(global);
8382 assert(!sym.undf());
src/link/MachO/zld.zig+47-49
......@@ -34,7 +34,6 @@ const Object = @import("Object.zig");
3434const Section = MachO.Section;
3535const StringTable = @import("../strtab.zig").StringTable;
3636const SymbolWithLoc = MachO.SymbolWithLoc;
37const SymbolResolver = MachO.SymbolResolver;
3837const TableSection = @import("../table_section.zig").TableSection;
3938const Trie = @import("Trie.zig");
4039const UnwindInfo = @import("UnwindInfo.zig");
......@@ -76,6 +75,8 @@ pub const Zld = struct {
7675
7776 locals: std.ArrayListUnmanaged(macho.nlist_64) = .{},
7877 globals: std.ArrayListUnmanaged(SymbolWithLoc) = .{},
78 resolver: std.StringHashMapUnmanaged(u32) = .{},
79 unresolved: std.AutoArrayHashMapUnmanaged(u32, void) = .{},
7980
8081 entry_index: ?u32 = null,
8182 mh_execute_header_index: ?u32 = null,
......@@ -327,53 +328,53 @@ pub const Zld = struct {
327328 }
328329 }
329330
330 fn addUndefined(self: *Zld, name: []const u8, resolver: *SymbolResolver) !void {
331 fn addUndefined(self: *Zld, name: []const u8) !void {
331332 const sym_index = try self.allocateSymbol();
332333 const sym_loc = SymbolWithLoc{ .sym_index = sym_index };
333334 const sym = self.getSymbolPtr(sym_loc);
334335 sym.n_strx = try self.strtab.insert(self.gpa, name);
335336 sym.n_type = macho.N_UNDF;
336337 const global_index = try self.addGlobal(sym_loc);
337 try resolver.table.putNoClobber(name, global_index);
338 try resolver.unresolved.putNoClobber(global_index, {});
338 try self.resolver.putNoClobber(self.gpa, name, global_index);
339 try self.unresolved.putNoClobber(self.gpa, global_index, {});
339340 }
340341
341 fn resolveSymbols(self: *Zld, resolver: *SymbolResolver) !void {
342 fn resolveSymbols(self: *Zld) !void {
342343 // We add the specified entrypoint as the first unresolved symbols so that
343344 // we search for it in libraries should there be no object files specified
344345 // on the linker line.
345346 if (self.options.output_mode == .Exe) {
346347 const entry_name = self.options.entry orelse load_commands.default_entry_point;
347 try self.addUndefined(entry_name, resolver);
348 try self.addUndefined(entry_name);
348349 }
349350
350351 // Force resolution of any symbols requested by the user.
351352 for (self.options.force_undefined_symbols.keys()) |sym_name| {
352 try self.addUndefined(sym_name, resolver);
353 try self.addUndefined(sym_name);
353354 }
354355
355356 for (self.objects.items, 0..) |_, object_id| {
356 try self.resolveSymbolsInObject(@as(u32, @intCast(object_id)), resolver);
357 try self.resolveSymbolsInObject(@as(u32, @intCast(object_id)));
357358 }
358359
359 try self.resolveSymbolsInArchives(resolver);
360 try self.resolveSymbolsInArchives();
360361
361362 // Finally, force resolution of dyld_stub_binder if there are imports
362363 // requested.
363 if (resolver.unresolved.count() > 0) {
364 try self.addUndefined("dyld_stub_binder", resolver);
364 if (self.unresolved.count() > 0) {
365 try self.addUndefined("dyld_stub_binder");
365366 }
366367
367 try self.resolveSymbolsInDylibs(resolver);
368 try self.resolveSymbolsInDylibs();
368369
369 self.dyld_stub_binder_index = resolver.table.get("dyld_stub_binder");
370 self.dyld_stub_binder_index = self.resolver.get("dyld_stub_binder");
370371
371 try self.createMhExecuteHeaderSymbol(resolver);
372 try self.createDsoHandleSymbol(resolver);
373 try self.resolveSymbolsAtLoading(resolver);
372 try self.createMhExecuteHeaderSymbol();
373 try self.createDsoHandleSymbol();
374 try self.resolveSymbolsAtLoading();
374375 }
375376
376 fn resolveSymbolsInObject(self: *Zld, object_id: u32, resolver: *SymbolResolver) !void {
377 fn resolveSymbolsInObject(self: *Zld, object_id: u32) !void {
377378 const object = &self.objects.items[object_id];
378379 const in_symtab = object.in_symtab orelse return;
379380
......@@ -415,11 +416,11 @@ pub const Zld = struct {
415416
416417 const sym_loc = SymbolWithLoc{ .sym_index = sym_index, .file = object_id + 1 };
417418
418 const global_index = resolver.table.get(sym_name) orelse {
419 const global_index = self.resolver.get(sym_name) orelse {
419420 const global_index = try self.addGlobal(sym_loc);
420 try resolver.table.putNoClobber(sym_name, global_index);
421 try self.resolver.putNoClobber(self.gpa, sym_name, global_index);
421422 if (sym.undf() and !sym.tentative()) {
422 try resolver.unresolved.putNoClobber(global_index, {});
423 try self.unresolved.putNoClobber(self.gpa, global_index, {});
423424 }
424425 continue;
425426 };
......@@ -477,7 +478,7 @@ pub const Zld = struct {
477478 const global_object = &self.objects.items[file];
478479 global_object.globals_lookup[global.sym_index] = global_index;
479480 }
480 _ = resolver.unresolved.swapRemove(resolver.table.get(sym_name).?);
481 _ = self.unresolved.swapRemove(self.resolver.get(sym_name).?);
481482 global.* = sym_loc;
482483 } else {
483484 object.globals_lookup[sym_index] = global_index;
......@@ -485,14 +486,14 @@ pub const Zld = struct {
485486 }
486487 }
487488
488 fn resolveSymbolsInArchives(self: *Zld, resolver: *SymbolResolver) !void {
489 fn resolveSymbolsInArchives(self: *Zld) !void {
489490 if (self.archives.items.len == 0) return;
490491
491492 const gpa = self.gpa;
492493
493494 var next_sym: usize = 0;
494 loop: while (next_sym < resolver.unresolved.count()) {
495 const global = self.globals.items[resolver.unresolved.keys()[next_sym]];
495 loop: while (next_sym < self.unresolved.count()) {
496 const global = self.globals.items[self.unresolved.keys()[next_sym]];
496497 const sym_name = self.getSymbolName(global);
497498
498499 for (self.archives.items) |archive| {
......@@ -506,7 +507,7 @@ pub const Zld = struct {
506507 const object_id = @as(u16, @intCast(self.objects.items.len));
507508 const object = try archive.parseObject(gpa, offsets.items[0]);
508509 try self.objects.append(gpa, object);
509 try self.resolveSymbolsInObject(object_id, resolver);
510 try self.resolveSymbolsInObject(object_id);
510511
511512 continue :loop;
512513 }
......@@ -515,12 +516,12 @@ pub const Zld = struct {
515516 }
516517 }
517518
518 fn resolveSymbolsInDylibs(self: *Zld, resolver: *SymbolResolver) !void {
519 fn resolveSymbolsInDylibs(self: *Zld) !void {
519520 if (self.dylibs.items.len == 0) return;
520521
521522 var next_sym: usize = 0;
522 loop: while (next_sym < resolver.unresolved.count()) {
523 const global_index = resolver.unresolved.keys()[next_sym];
523 loop: while (next_sym < self.unresolved.count()) {
524 const global_index = self.unresolved.keys()[next_sym];
524525 const global = self.globals.items[global_index];
525526 const sym = self.getSymbolPtr(global);
526527 const sym_name = self.getSymbolName(global);
......@@ -541,7 +542,7 @@ pub const Zld = struct {
541542 sym.n_desc |= macho.N_WEAK_REF;
542543 }
543544
544 assert(resolver.unresolved.swapRemove(global_index));
545 assert(self.unresolved.swapRemove(global_index));
545546 continue :loop;
546547 }
547548
......@@ -549,14 +550,14 @@ pub const Zld = struct {
549550 }
550551 }
551552
552 fn resolveSymbolsAtLoading(self: *Zld, resolver: *SymbolResolver) !void {
553 fn resolveSymbolsAtLoading(self: *Zld) !void {
553554 const is_lib = self.options.output_mode == .Lib;
554555 const is_dyn_lib = self.options.link_mode == .Dynamic and is_lib;
555556 const allow_undef = is_dyn_lib and (self.options.allow_shlib_undefined orelse false);
556557
557558 var next_sym: usize = 0;
558 while (next_sym < resolver.unresolved.count()) {
559 const global_index = resolver.unresolved.keys()[next_sym];
559 while (next_sym < self.unresolved.count()) {
560 const global_index = self.unresolved.keys()[next_sym];
560561 const global = self.globals.items[global_index];
561562 const sym = self.getSymbolPtr(global);
562563
......@@ -568,7 +569,7 @@ pub const Zld = struct {
568569 .n_desc = 0,
569570 .n_value = 0,
570571 };
571 _ = resolver.unresolved.swapRemove(global_index);
572 _ = self.unresolved.swapRemove(global_index);
572573 continue;
573574 } else if (allow_undef) {
574575 const n_desc = @as(
......@@ -577,7 +578,7 @@ pub const Zld = struct {
577578 );
578579 sym.n_type = macho.N_EXT;
579580 sym.n_desc = n_desc;
580 _ = resolver.unresolved.swapRemove(global_index);
581 _ = self.unresolved.swapRemove(global_index);
581582 continue;
582583 }
583584
......@@ -585,9 +586,9 @@ pub const Zld = struct {
585586 }
586587 }
587588
588 fn createMhExecuteHeaderSymbol(self: *Zld, resolver: *SymbolResolver) !void {
589 fn createMhExecuteHeaderSymbol(self: *Zld) !void {
589590 if (self.options.output_mode != .Exe) return;
590 if (resolver.table.get("__mh_execute_header")) |global_index| {
591 if (self.resolver.get("__mh_execute_header")) |global_index| {
591592 const global = self.globals.items[global_index];
592593 const sym = self.getSymbol(global);
593594 self.mh_execute_header_index = global_index;
......@@ -602,7 +603,7 @@ pub const Zld = struct {
602603 sym.n_type = macho.N_SECT | macho.N_EXT;
603604 sym.n_desc = macho.REFERENCED_DYNAMICALLY;
604605
605 if (resolver.table.get("__mh_execute_header")) |global_index| {
606 if (self.resolver.get("__mh_execute_header")) |global_index| {
606607 const global = &self.globals.items[global_index];
607608 const global_object = &self.objects.items[global.getFile().?];
608609 global_object.globals_lookup[global.sym_index] = global_index;
......@@ -613,8 +614,8 @@ pub const Zld = struct {
613614 }
614615 }
615616
616 fn createDsoHandleSymbol(self: *Zld, resolver: *SymbolResolver) !void {
617 const global_index = resolver.table.get("___dso_handle") orelse return;
617 fn createDsoHandleSymbol(self: *Zld) !void {
618 const global_index = self.resolver.get("___dso_handle") orelse return;
618619 const global = &self.globals.items[global_index];
619620 self.dso_handle_index = global_index;
620621 if (!self.getSymbol(global.*).undf()) return;
......@@ -629,7 +630,7 @@ pub const Zld = struct {
629630
630631 const global_object = &self.objects.items[global.getFile().?];
631632 global_object.globals_lookup[global.sym_index] = global_index;
632 _ = resolver.unresolved.swapRemove(resolver.table.get("___dso_handle").?);
633 _ = self.unresolved.swapRemove(self.resolver.get("___dso_handle").?);
633634 global.* = sym_loc;
634635 }
635636
......@@ -649,6 +650,8 @@ pub const Zld = struct {
649650 self.strtab.deinit(gpa);
650651 self.locals.deinit(gpa);
651652 self.globals.deinit(gpa);
653 self.resolver.deinit(gpa);
654 self.unresolved.deinit(gpa);
652655
653656 for (self.objects.items) |*object| {
654657 object.deinit(gpa);
......@@ -3066,17 +3069,12 @@ pub fn linkWithZld(macho_file: *MachO, comp: *Compilation, prog_node: *std.Progr
30663069 log.err("parsing dependent libraries failed with err {s}", .{@errorName(err)});
30673070 };
30683071
3069 var resolver = SymbolResolver{
3070 .arena = arena,
3071 .table = std.StringHashMap(u32).init(arena),
3072 .unresolved = std.AutoArrayHashMap(u32, void).init(arena),
3073 };
3074 try zld.resolveSymbols(&resolver);
3075 try macho_file.reportUndefined(&zld, &resolver);
3072 try zld.resolveSymbols();
3073 try macho_file.reportUndefined(&zld);
30763074
30773075 if (options.output_mode == .Exe) {
30783076 const entry_name = options.entry orelse load_commands.default_entry_point;
3079 const global_index = resolver.table.get(entry_name).?; // Error was flagged earlier
3077 const global_index = zld.resolver.get(entry_name).?; // Error was flagged earlier
30803078 zld.entry_index = global_index;
30813079 }
30823080
......@@ -3085,7 +3083,7 @@ pub fn linkWithZld(macho_file: *MachO, comp: *Compilation, prog_node: *std.Progr
30853083 }
30863084
30873085 if (gc_sections) {
3088 try dead_strip.gcAtoms(&zld, &resolver);
3086 try dead_strip.gcAtoms(&zld);
30893087 }
30903088
30913089 try zld.createDyldPrivateAtom();