authorgravatar for kubkon@jakubkonka.comJakub Konka <kubkon@jakubkonka.com> 2021-06-23 15:11:31+02:00
committergravatar for kubkon@jakubkonka.comJakub Konka <kubkon@jakubkonka.com> 2021-06-24 18:57:11+02:00
log5ac5cd9de7c5387e37baa4f287d609c5d2f34564
tree65d97ee06e85f411493dbef7a5b1688e627f70c6
parent3cb6b6bd90c3b304bf771b37e974dd943c060e2b

zld: naively parse all dylib deps in stubs

6 files changed, 263 insertions(+), 234 deletions(-)

src/link/MachO.zig+1
......@@ -789,6 +789,7 @@ fn linkWithLLD(self: *MachO, comp: *Compilation) !void {
789789 zld.deinit();
790790 }
791791 zld.arch = target.cpu.arch;
792 zld.syslibroot = self.base.options.syslibroot;
792793 zld.stack_size = stack_size;
793794
794795 // Positional arguments to the linker such as object files and static archives.
src/link/MachO/Archive.zig+41-22
......@@ -8,12 +8,13 @@ const macho = std.macho;
88const mem = std.mem;
99
1010const Allocator = mem.Allocator;
11const Arch = std.Target.Cpu.Arch;
1112const Object = @import("Object.zig");
1213
1314usingnamespace @import("commands.zig");
1415
1516allocator: *Allocator,
16arch: ?std.Target.Cpu.Arch = null,
17arch: ?Arch = null,
1718file: ?fs.File = null,
1819header: ?ar_hdr = null,
1920name: ?[]const u8 = null,
......@@ -85,10 +86,36 @@ const ar_hdr = extern struct {
8586 }
8687};
8788
88pub fn init(allocator: *Allocator) Archive {
89 return .{
89pub fn createAndParseFromPath(allocator: *Allocator, arch: Arch, path: []const u8) !?*Archive {
90 const file = fs.cwd().openFile(path, .{}) catch |err| switch (err) {
91 error.FileNotFound => return null,
92 else => |e| return e,
93 };
94 errdefer file.close();
95
96 const archive = try allocator.create(Archive);
97 errdefer allocator.destroy(archive);
98
99 const name = try allocator.dupe(u8, path);
100 errdefer allocator.free(name);
101
102 archive.* = .{
90103 .allocator = allocator,
104 .arch = arch,
105 .name = name,
106 .file = file,
107 };
108
109 archive.parse() catch |err| switch (err) {
110 error.EndOfStream, error.NotArchive => {
111 archive.deinit();
112 allocator.destroy(archive);
113 return null;
114 },
115 else => |e| return e,
91116 };
117
118 return archive;
92119}
93120
94121pub fn deinit(self: *Archive) void {
......@@ -116,15 +143,15 @@ pub fn parse(self: *Archive) !void {
116143 const magic = try reader.readBytesNoEof(SARMAG);
117144
118145 if (!mem.eql(u8, &magic, ARMAG)) {
119 log.err("invalid magic: expected '{s}', found '{s}'", .{ ARMAG, magic });
120 return error.MalformedArchive;
146 log.debug("invalid magic: expected '{s}', found '{s}'", .{ ARMAG, magic });
147 return error.NotArchive;
121148 }
122149
123150 self.header = try reader.readStruct(ar_hdr);
124151
125152 if (!mem.eql(u8, &self.header.?.ar_fmag, ARFMAG)) {
126 log.err("invalid header delimiter: expected '{s}', found '{s}'", .{ ARFMAG, self.header.?.ar_fmag });
127 return error.MalformedArchive;
153 log.debug("invalid header delimiter: expected '{s}', found '{s}'", .{ ARFMAG, self.header.?.ar_fmag });
154 return error.NotArchive;
128155 }
129156
130157 var embedded_name = try parseName(self.allocator, self.header.?, reader);
......@@ -222,23 +249,15 @@ pub fn parseObject(self: Archive, offset: u32) !*Object {
222249 var object = try self.allocator.create(Object);
223250 errdefer self.allocator.destroy(object);
224251
225 object.* = Object.init(self.allocator);
226 object.arch = self.arch.?;
227 object.file = try fs.cwd().openFile(self.name.?, .{});
228 object.name = name;
229 object.file_offset = @intCast(u32, try reader.context.getPos());
252 object.* = .{
253 .allocator = self.allocator,
254 .arch = self.arch.?,
255 .file = try fs.cwd().openFile(self.name.?, .{}),
256 .name = name,
257 .file_offset = @intCast(u32, try reader.context.getPos()),
258 };
230259 try object.parse();
231
232260 try reader.context.seekTo(0);
233261
234262 return object;
235263}
236
237pub fn isArchive(file: fs.File) !bool {
238 const magic = file.reader().readBytesNoEof(Archive.SARMAG) catch |err| switch (err) {
239 error.EndOfStream => return false,
240 else => |e| return e,
241 };
242 try file.seekTo(0);
243 return mem.eql(u8, &magic, Archive.ARMAG);
244}
src/link/MachO/Dylib.zig+129-19
......@@ -8,6 +8,7 @@ const macho = std.macho;
88const mem = std.mem;
99
1010const Allocator = mem.Allocator;
11const Arch = std.Target.Cpu.Arch;
1112const Symbol = @import("Symbol.zig");
1213const LibStub = @import("../tapi.zig").LibStub;
1314
......@@ -15,10 +16,11 @@ usingnamespace @import("commands.zig");
1516
1617allocator: *Allocator,
1718
18arch: ?std.Target.Cpu.Arch = null,
19arch: ?Arch = null,
1920header: ?macho.mach_header_64 = null,
2021file: ?fs.File = null,
2122name: ?[]const u8 = null,
23syslibroot: ?[]const u8 = null,
2224
2325ordinal: ?u16 = null,
2426
......@@ -35,6 +37,11 @@ id: ?Id = null,
3537/// a symbol is referenced by an object file.
3638symbols: std.StringArrayHashMapUnmanaged(void) = .{},
3739
40// TODO we should keep track of already parsed dylibs so that
41// we don't unnecessarily reparse them again.
42// TODO add dylib dep analysis and extraction for .dylib files.
43dylibs: std.ArrayListUnmanaged(*Dylib) = .{},
44
3845pub const Id = struct {
3946 name: []const u8,
4047 timestamp: u32,
......@@ -46,8 +53,57 @@ pub const Id = struct {
4653 }
4754};
4855
49pub fn init(allocator: *Allocator) Dylib {
50 return .{ .allocator = allocator };
56pub const Error = error{
57 OutOfMemory,
58 EmptyStubFile,
59 MismatchedCpuArchitecture,
60 UnsupportedCpuArchitecture,
61} || fs.File.OpenError || std.os.PReadError;
62
63pub fn createAndParseFromPath(
64 allocator: *Allocator,
65 arch: Arch,
66 path: []const u8,
67 syslibroot: ?[]const u8,
68 recurse_libs: bool,
69) Error!?*Dylib {
70 const file = fs.cwd().openFile(path, .{}) catch |err| switch (err) {
71 error.FileNotFound => return null,
72 else => |e| return e,
73 };
74 errdefer file.close();
75
76 const dylib = try allocator.create(Dylib);
77 errdefer allocator.destroy(dylib);
78
79 const name = try allocator.dupe(u8, path);
80 errdefer allocator.free(name);
81
82 dylib.* = .{
83 .allocator = allocator,
84 .arch = arch,
85 .name = name,
86 .file = file,
87 .syslibroot = syslibroot,
88 };
89
90 dylib.parse(recurse_libs) catch |err| switch (err) {
91 error.EndOfStream, error.NotDylib => {
92 try file.seekTo(0);
93
94 var lib_stub = LibStub.loadFromFile(allocator, file) catch {
95 dylib.deinit();
96 allocator.destroy(dylib);
97 return null;
98 };
99 defer lib_stub.deinit();
100
101 try dylib.parseFromStub(lib_stub, recurse_libs);
102 },
103 else => |e| return e,
104 };
105
106 return dylib;
51107}
52108
53109pub fn deinit(self: *Dylib) void {
......@@ -60,6 +116,7 @@ pub fn deinit(self: *Dylib) void {
60116 self.allocator.free(key);
61117 }
62118 self.symbols.deinit(self.allocator);
119 self.dylibs.deinit(self.allocator);
63120
64121 if (self.name) |name| {
65122 self.allocator.free(name);
......@@ -76,15 +133,15 @@ pub fn closeFile(self: Dylib) void {
76133 }
77134}
78135
79pub fn parse(self: *Dylib) !void {
136pub fn parse(self: *Dylib, recurse_libs: bool) !void {
80137 log.debug("parsing shared library '{s}'", .{self.name.?});
81138
82139 var reader = self.file.?.reader();
83140 self.header = try reader.readStruct(macho.mach_header_64);
84141
85142 if (self.header.?.filetype != macho.MH_DYLIB) {
86 log.err("invalid filetype: expected 0x{x}, found 0x{x}", .{ macho.MH_DYLIB, self.header.?.filetype });
87 return error.MalformedDylib;
143 log.debug("invalid filetype: expected 0x{x}, found 0x{x}", .{ macho.MH_DYLIB, self.header.?.filetype });
144 return error.NotDylib;
88145 }
89146
90147 const this_arch: std.Target.Cpu.Arch = switch (self.header.?.cputype) {
......@@ -190,7 +247,7 @@ fn addObjCClassSymbols(self: *Dylib, sym_name: []const u8) !void {
190247 }
191248}
192249
193pub fn parseFromStub(self: *Dylib, lib_stub: LibStub) !void {
250pub fn parseFromStub(self: *Dylib, lib_stub: LibStub, recurse_libs: bool) !void {
194251 if (lib_stub.inner.len == 0) return error.EmptyStubFile;
195252
196253 log.debug("parsing shared library from stub '{s}'", .{self.name.?});
......@@ -236,9 +293,17 @@ pub fn parseFromStub(self: *Dylib, lib_stub: LibStub) !void {
236293 for (reexports) |reexp| {
237294 if (!hasTarget(reexp.targets, target_string)) continue;
238295
239 for (reexp.symbols) |sym_name| {
240 if (self.symbols.contains(sym_name)) continue;
241 try self.symbols.putNoClobber(self.allocator, try self.allocator.dupe(u8, sym_name), {});
296 if (reexp.symbols) |symbols| {
297 for (symbols) |sym_name| {
298 if (self.symbols.contains(sym_name)) continue;
299 try self.symbols.putNoClobber(self.allocator, try self.allocator.dupe(u8, sym_name), {});
300 }
301 }
302
303 if (reexp.objc_classes) |classes| {
304 for (classes) |sym_name| {
305 try self.addObjCClassSymbols(sym_name);
306 }
242307 }
243308 }
244309 }
......@@ -249,6 +314,60 @@ pub fn parseFromStub(self: *Dylib, lib_stub: LibStub) !void {
249314 }
250315 }
251316 }
317
318 for (lib_stub.inner) |stub| {
319 if (!hasTarget(stub.targets, target_string)) continue;
320
321 if (stub.reexported_libraries) |reexports| reexports: {
322 if (!recurse_libs) break :reexports;
323
324 for (reexports) |reexp| {
325 if (!hasTarget(reexp.targets, target_string)) continue;
326
327 outer: for (reexp.libraries) |lib| {
328 const dirname = fs.path.dirname(lib) orelse {
329 log.warn("unable to resolve dependency {s}", .{lib});
330 continue;
331 };
332 const filename = fs.path.basename(lib);
333 const without_ext = if (mem.lastIndexOfScalar(u8, filename, '.')) |index|
334 filename[0..index]
335 else
336 filename;
337
338 for (&[_][]const u8{ "dylib", "tbd" }) |ext| {
339 const with_ext = try std.fmt.allocPrint(self.allocator, "{s}.{s}", .{
340 without_ext,
341 ext,
342 });
343 defer self.allocator.free(with_ext);
344
345 const lib_path = if (self.syslibroot) |syslibroot|
346 try fs.path.join(self.allocator, &.{ syslibroot, dirname, with_ext })
347 else
348 try fs.path.join(self.allocator, &.{ dirname, with_ext });
349
350 log.debug("trying dependency at fully resolved path {s}", .{lib_path});
351
352 const dylib = (try createAndParseFromPath(
353 self.allocator,
354 self.arch.?,
355 lib_path,
356 self.syslibroot,
357 true,
358 )) orelse {
359 continue;
360 };
361
362 try self.dylibs.append(self.allocator, dylib);
363 continue :outer;
364 } else {
365 log.warn("unable to resolve dependency {s}", .{lib});
366 }
367 }
368 }
369 }
370 }
252371}
253372
254373fn hasTarget(targets: []const []const u8, target: []const u8) bool {
......@@ -258,15 +377,6 @@ fn hasTarget(targets: []const []const u8, target: []const u8) bool {
258377 return false;
259378}
260379
261pub fn isDylib(file: fs.File) !bool {
262 const header = file.reader().readStruct(macho.mach_header_64) catch |err| switch (err) {
263 error.EndOfStream => return false,
264 else => |e| return e,
265 };
266 try file.seekTo(0);
267 return header.filetype == macho.MH_DYLIB;
268}
269
270380pub fn createProxy(self: *Dylib, sym_name: []const u8) !?*Symbol {
271381 if (!self.symbols.contains(sym_name)) return null;
272382
src/link/MachO/Object.zig+37-15
......@@ -11,6 +11,7 @@ const mem = std.mem;
1111const reloc = @import("reloc.zig");
1212
1313const Allocator = mem.Allocator;
14const Arch = std.Target.Cpu.Arch;
1415const Relocation = reloc.Relocation;
1516const Symbol = @import("Symbol.zig");
1617const parseName = @import("Zld.zig").parseName;
......@@ -18,7 +19,7 @@ const parseName = @import("Zld.zig").parseName;
1819usingnamespace @import("commands.zig");
1920
2021allocator: *Allocator,
21arch: ?std.Target.Cpu.Arch = null,
22arch: ?Arch = null,
2223header: ?macho.mach_header_64 = null,
2324file: ?fs.File = null,
2425file_offset: ?u32 = null,
......@@ -173,10 +174,36 @@ const DebugInfo = struct {
173174 }
174175};
175176
176pub fn init(allocator: *Allocator) Object {
177 return .{
177pub fn createAndParseFromPath(allocator: *Allocator, arch: Arch, path: []const u8) !?*Object {
178 const file = fs.cwd().openFile(path, .{}) catch |err| switch (err) {
179 error.FileNotFound => return null,
180 else => |e| return e,
181 };
182 errdefer file.close();
183
184 const object = try allocator.create(Object);
185 errdefer allocator.destroy(object);
186
187 const name = try allocator.dupe(u8, path);
188 errdefer allocator.free(name);
189
190 object.* = .{
178191 .allocator = allocator,
192 .arch = arch,
193 .name = name,
194 .file = file,
179195 };
196
197 object.parse() catch |err| switch (err) {
198 error.EndOfStream, error.NotObject => {
199 object.deinit();
200 allocator.destroy(object);
201 return null;
202 },
203 else => |e| return e,
204 };
205
206 return object;
180207}
181208
182209pub fn deinit(self: *Object) void {
......@@ -223,11 +250,15 @@ pub fn parse(self: *Object) !void {
223250 self.header = try reader.readStruct(macho.mach_header_64);
224251
225252 if (self.header.?.filetype != macho.MH_OBJECT) {
226 log.err("invalid filetype: expected 0x{x}, found 0x{x}", .{ macho.MH_OBJECT, self.header.?.filetype });
227 return error.MalformedObject;
253 log.debug("invalid filetype: expected 0x{x}, found 0x{x}", .{
254 macho.MH_OBJECT,
255 self.header.?.filetype,
256 });
257
258 return error.NotObject;
228259 }
229260
230 const this_arch: std.Target.Cpu.Arch = switch (self.header.?.cputype) {
261 const this_arch: Arch = switch (self.header.?.cputype) {
231262 macho.CPU_TYPE_ARM64 => .aarch64,
232263 macho.CPU_TYPE_X86_64 => .x86_64,
233264 else => |value| {
......@@ -533,12 +564,3 @@ pub fn parseDataInCode(self: *Object) !void {
533564 try self.data_in_code_entries.append(self.allocator, dice);
534565 }
535566}
536
537pub fn isObject(file: fs.File) !bool {
538 const header = file.reader().readStruct(macho.mach_header_64) catch |err| switch (err) {
539 error.EndOfStream => return false,
540 else => |e| return e,
541 };
542 try file.seekTo(0);
543 return header.filetype == macho.MH_OBJECT;
544}
src/link/MachO/Zld.zig+53-177
......@@ -16,7 +16,6 @@ const Allocator = mem.Allocator;
1616const Archive = @import("Archive.zig");
1717const CodeSignature = @import("CodeSignature.zig");
1818const Dylib = @import("Dylib.zig");
19const LibStub = @import("../tapi.zig").LibStub;
2019const Object = @import("Object.zig");
2120const Symbol = @import("Symbol.zig");
2221const Trie = @import("Trie.zig");
......@@ -33,6 +32,7 @@ out_path: ?[]const u8 = null,
3332
3433// TODO these args will become obselete once Zld is coalesced with incremental
3534// linker.
35syslibroot: ?[]const u8 = null,
3636stack_size: u64 = 0,
3737
3838objects: std.ArrayListUnmanaged(*Object) = .{},
......@@ -257,214 +257,90 @@ pub fn link(self: *Zld, files: []const []const u8, out_path: []const u8, args: L
257257}
258258
259259fn parseInputFiles(self: *Zld, files: []const []const u8) !void {
260 const Input = struct {
261 kind: union(enum) {
262 object: fs.File,
263 archive: fs.File,
264 dylib: fs.File,
265 stub: LibStub,
266 },
267 name: []const u8,
268
269 fn deinit(input: *@This()) void {
270 switch (input.kind) {
271 .stub => |*stub| {
272 stub.deinit();
273 },
274 else => {},
275 }
276 }
277 };
278 var classified = std.ArrayList(Input).init(self.allocator);
279 defer {
280 for (classified.items) |*input| {
281 input.deinit();
282 }
283 classified.deinit();
284 }
285
286 // First, classify input files: object, archive, dylib or stub (tbd).
287260 for (files) |file_name| {
288 const file = try fs.cwd().openFile(file_name, .{});
289261 const full_path = full_path: {
290262 var buffer: [std.fs.MAX_PATH_BYTES]u8 = undefined;
291263 const path = try std.fs.realpath(file_name, &buffer);
292264 break :full_path try self.allocator.dupe(u8, path);
293265 };
294266
295 try_object: {
296 if (!(try Object.isObject(file))) break :try_object;
297 try classified.append(.{
298 .kind = .{ .object = file },
299 .name = full_path,
300 });
301 continue;
302 }
303
304 try_archive: {
305 if (!(try Archive.isArchive(file))) break :try_archive;
306 try classified.append(.{
307 .kind = .{ .archive = file },
308 .name = full_path,
309 });
267 if (try Object.createAndParseFromPath(self.allocator, self.arch.?, full_path)) |object| {
268 try self.objects.append(self.allocator, object);
310269 continue;
311270 }
312271
313 try_dylib: {
314 if (!(try Dylib.isDylib(file))) break :try_dylib;
315 try classified.append(.{
316 .kind = .{ .dylib = file },
317 .name = full_path,
318 });
272 if (try Archive.createAndParseFromPath(self.allocator, self.arch.?, full_path)) |archive| {
273 try self.archives.append(self.allocator, archive);
319274 continue;
320275 }
321276
322 try_stub: {
323 var lib_stub = LibStub.loadFromFile(self.allocator, file) catch {
324 break :try_stub;
325 };
326 try classified.append(.{
327 .kind = .{ .stub = lib_stub },
328 .name = full_path,
329 });
330 file.close();
277 if (try Dylib.createAndParseFromPath(
278 self.allocator,
279 self.arch.?,
280 full_path,
281 self.syslibroot,
282 true,
283 )) |dylib| {
284 try self.dylibs.append(self.allocator, dylib);
331285 continue;
332286 }
333287
334 file.close();
335288 log.warn("unknown filetype for positional input file: '{s}'", .{file_name});
336289 }
337
338 // Based on our classification, proceed with parsing.
339 for (classified.items) |input| {
340 switch (input.kind) {
341 .object => |file| {
342 const object = try self.allocator.create(Object);
343 errdefer self.allocator.destroy(object);
344
345 object.* = Object.init(self.allocator);
346 object.arch = self.arch.?;
347 object.name = input.name;
348 object.file = file;
349
350 try object.parse();
351 try self.objects.append(self.allocator, object);
352 },
353 .archive => |file| {
354 const archive = try self.allocator.create(Archive);
355 errdefer self.allocator.destroy(archive);
356
357 archive.* = Archive.init(self.allocator);
358 archive.arch = self.arch.?;
359 archive.name = input.name;
360 archive.file = file;
361
362 try archive.parse();
363 try self.archives.append(self.allocator, archive);
364 },
365 .dylib, .stub => {
366 const dylib = try self.allocator.create(Dylib);
367 errdefer self.allocator.destroy(dylib);
368
369 dylib.* = Dylib.init(self.allocator);
370 dylib.arch = self.arch.?;
371 dylib.name = input.name;
372
373 if (input.kind == .dylib) {
374 dylib.file = input.kind.dylib;
375 try dylib.parse();
376 } else {
377 try dylib.parseFromStub(input.kind.stub);
378 }
379
380 try self.dylibs.append(self.allocator, dylib);
381 },
382 }
383 }
384290}
385291
386292fn parseLibs(self: *Zld, libs: []const []const u8) !void {
387 for (libs) |lib| {
388 const file = try fs.cwd().openFile(lib, .{});
389
390 var kind: ?union(enum) {
391 archive,
392 dylib,
393 stub: LibStub,
394 } = kind: {
395 if (try Archive.isArchive(file)) break :kind .archive;
396 if (try Dylib.isDylib(file)) break :kind .dylib;
397 var lib_stub = LibStub.loadFromFile(self.allocator, file) catch {
398 break :kind null;
399 };
400 break :kind .{ .stub = lib_stub };
401 };
402 defer {
403 if (kind) |*kk| {
404 switch (kk.*) {
405 .stub => |*stub| {
406 stub.deinit();
407 },
408 else => {},
409 }
293 const DylibDeps = struct {
294 fn bubbleUp(out: *std.ArrayList(*Dylib), next: *Dylib) error{OutOfMemory}!void {
295 try out.ensureUnusedCapacity(next.dylibs.items.len);
296 for (next.dylibs.items) |dylib| {
297 out.appendAssumeCapacity(dylib);
298 }
299 for (next.dylibs.items) |dylib| {
300 try bubbleUp(out, dylib);
410301 }
411302 }
303 };
412304
413 const unwrapped = kind orelse {
414 file.close();
415 log.warn("unknown filetype for a library: '{s}'", .{lib});
305 for (libs) |lib| {
306 if (try Dylib.createAndParseFromPath(
307 self.allocator,
308 self.arch.?,
309 lib,
310 self.syslibroot,
311 true,
312 )) |dylib| {
313 try self.dylibs.append(self.allocator, dylib);
416314 continue;
417 };
418 switch (unwrapped) {
419 .archive => {
420 const archive = try self.allocator.create(Archive);
421 errdefer self.allocator.destroy(archive);
422
423 archive.* = Archive.init(self.allocator);
424 archive.arch = self.arch.?;
425 archive.name = try self.allocator.dupe(u8, lib);
426 archive.file = file;
427
428 try archive.parse();
429 try self.archives.append(self.allocator, archive);
430 },
431 .dylib, .stub => {
432 const dylib = try self.allocator.create(Dylib);
433 errdefer self.allocator.destroy(dylib);
434
435 dylib.* = Dylib.init(self.allocator);
436 dylib.arch = self.arch.?;
437 dylib.name = try self.allocator.dupe(u8, lib);
438
439 if (unwrapped == .dylib) {
440 dylib.file = file;
441 try dylib.parse();
442 } else {
443 try dylib.parseFromStub(unwrapped.stub);
444 }
445
446 try self.dylibs.append(self.allocator, dylib);
447 },
448315 }
449 }
450}
451316
452fn parseLibSystem(self: *Zld, libc_stub_path: []const u8) !void {
453 const file = try fs.cwd().openFile(libc_stub_path, .{});
454 defer file.close();
317 if (try Archive.createAndParseFromPath(self.allocator, self.arch.?, lib)) |archive| {
318 try self.archives.append(self.allocator, archive);
319 continue;
320 }
455321
456 var lib_stub = try LibStub.loadFromFile(self.allocator, file);
457 defer lib_stub.deinit();
322 log.warn("unknown filetype for a library: '{s}'", .{lib});
323 }
458324
459 const dylib = try self.allocator.create(Dylib);
460 errdefer self.allocator.destroy(dylib);
325 // Flatten out any parsed dependencies.
326 var deps = std.ArrayList(*Dylib).init(self.allocator);
327 defer deps.deinit();
461328
462 dylib.* = Dylib.init(self.allocator);
463 dylib.arch = self.arch.?;
464 dylib.name = try self.allocator.dupe(u8, libc_stub_path);
329 for (self.dylibs.items) |dylib| {
330 try DylibDeps.bubbleUp(&deps, dylib);
331 }
465332
466 try dylib.parseFromStub(lib_stub);
333 try self.dylibs.appendSlice(self.allocator, deps.toOwnedSlice());
334}
467335
336fn parseLibSystem(self: *Zld, libc_stub_path: []const u8) !void {
337 const dylib = (try Dylib.createAndParseFromPath(
338 self.allocator,
339 self.arch.?,
340 libc_stub_path,
341 self.syslibroot,
342 false,
343 )) orelse return error.FailedToParseLibSystem;
468344 self.libsystem_dylib_index = @intCast(u16, self.dylibs.items.len);
469345 try self.dylibs.append(self.allocator, dylib);
470346
src/link/tapi.zig+2-1
......@@ -41,7 +41,8 @@ pub const LibStub = struct {
4141 },
4242 reexports: ?[]const struct {
4343 targets: []const []const u8,
44 symbols: []const []const u8,
44 symbols: ?[]const []const u8,
45 objc_classes: ?[]const []const u8,
4546 },
4647 allowable_clients: ?[]const struct {
4748 targets: []const []const u8,