Commit 0a1843452e6d39d4a2adc9c7feefce274a5d30c6 | zig

author	Matthew Lugg <mlugg@mlugg.co.uk> 2026-09-21 21:03:55+01:00
committer	Andrew Kelley <andrew@ziglang.org> 2026-09-21 13:08:49-07:00
log	0a1843452e6d39d4a2adc9c7feefce274a5d30c6
tree	7012d3b9006801793eed12f69dd0b2bbd8fc11aa
parent	cf33f1003fd02abaf91078725d9c972dd51fc5e1

link: clean up and unify shared library input rules

For determining the `DT_NEEDED` value:

* the `DT_SONAME` always takes precedence
* otherwise:
  * `-l` arguments use the resolved path's basename
  * raw `/path/to/libfoo.so` arguments use the full path

All ELF linkers, including LLD, now implement exactly those semantics.

The operand to `-l` is not allowed to contain path separators, because
the behavior of this in other linkers is confusing and likely not
supported. (This is not the case for `-l :path/to/libfoo.so`.)

7 files changed, 161 insertions(+), 82 deletions(-)

src
- link.zig
- link
- main.zig

src/link.zig+103-37

 @@ -1819,11 +1819,14 @@ pub const UnresolvedInput = union(enum) {
     path_query: PathQuery,
     /// Strings that come from GNU ld scripts. Is it a filename? Is it a path?
     /// Who knows! Fuck around and find out.
-    ambiguous_name: NameQuery,
+    ambiguous_name: AmbiguousNameQuery,
     pub const NameQuery = struct {
         name: []const u8,
         query: Query,
+        // Corresponds to GNU ld `-l :path/to/filename`, meaning that `name` is a path relative to
+        // the library search path rather than just a library name.
+        name_done: bool,
     };
     pub const PathQuery = struct {
 @@ -1831,6 +1834,11 @@ pub const UnresolvedInput = union(enum) {
         query: Query,
     };
+    pub const AmbiguousNameQuery = struct {
+        name: []const u8,
+        query: Query,
+    };
     pub const Query = struct {
         needed: bool = false,
         weak: bool = false,
 @@ -1838,14 +1846,6 @@ pub const UnresolvedInput = union(enum) {
         must_link: bool = false,
         hidden: bool = false,
         allow_so_scripts: bool = false,
-        // Corresponds to GNU ld `-l :path/to/filename`:
-        // * No extra rpaths.
-        // * NEEDED entry should be exactly the string
-        //   after the colon. No file system paths prepended.
-        // * The DSO still must be found at compile/link
-        //   time and its entries used to resolve symbols.
-        // CGo compilation depends on this.
-        name_done: bool = false,
         preferred_mode: std.lang.LinkMode,
         search_strategy: SearchStrategy,
 @@ -1891,15 +1891,9 @@ pub const Input = union(enum) {
         needed: bool,
         weak: bool,
         reexport: bool,
-        /// Does not include any ":" prefix. Indicates that this string, exactly, should go into the NEEDED
+        fallback_soname: FallbackSoname,
-        /// entry, without affecting any rpaths.
-        exact_name: ?[]const u8,
-    };
-    pub const DsoExact = struct {
+        pub const FallbackSoname = enum { basename, full_path };
-        /// Includes the ":" prefix. This is intended to be put into the DSO
-        /// section verbatim with no corresponding rpaths.
-        name: []const u8,
     };
     pub fn path(input: Input) Path {
 @@ -1950,7 +1944,7 @@ pub fn hashInputs(man: *Cache.Manifest, link_inputs: []const Input) !void {
                 man.hash.add(dso.needed);
                 man.hash.add(dso.weak);
                 man.hash.add(dso.reexport);
-                man.hash.addOptionalBytes(dso.exact_name);
+                man.hash.add(dso.fallback_soname);
             },
         }
     }
 @@ -2001,7 +1995,7 @@ pub fn resolveInputs(
             .name_query => |name_query| {
                 const query = name_query.query;
-                // Checked in the first pass above while looking for libc libraries.
+                // Checked in the first pass in `main.zig` while looking for libc libraries.
                 assert(!fs.path.isAbsolute(name_query.name));
                 checked_paths.clearRetainingCapacity();
 @@ -2229,7 +2223,7 @@ fn resolveLibInput(
     const lib_name = name_query.name;
-    if (target.os.tag.isDarwin() and link_mode == .dynamic and !name_query.query.name_done) tbd: {
+    if (target.os.tag.isDarwin() and link_mode == .dynamic and !name_query.name_done) tbd: {
         // Prefer .tbd over .dylib.
         const test_path: Path = .{
             .root_dir = lib_directory,
 @@ -2241,13 +2235,22 @@ fn resolveLibInput(
             else => |e| fatal("searching for tbd library {qf}: {t}", .{ test_path, e }),
         };
         errdefer file.close(io);
-        return finishResolveLibInput(io, resolved_inputs, archive_dedup, test_path, file, link_mode, name_query.query);
+        return finishResolveLibInput(
+            io,
+            resolved_inputs,
+            archive_dedup,
+            test_path,
+            file,
+            link_mode,
+            name_query.query,
+            .basename,
+        );
     }
     {
         const test_path: Path = .{
             .root_dir = lib_directory,
-            .sub_path = if (name_query.query.name_done) lib_name else try std.fmt.allocPrint(arena, "{s}{s}{s}", .{
+            .sub_path = if (name_query.name_done) lib_name else try std.fmt.allocPrint(arena, "{s}{s}{s}", .{
                 target.libPrefix(),
                 lib_name,
                 switch (link_mode) {
 @@ -2260,7 +2263,7 @@ fn resolveLibInput(
         switch (try resolvePathInputLib(gpa, arena, io, unresolved_inputs, resolved_inputs, ld_script_bytes, archive_dedup, target, .{
             .path = test_path,
             .query = name_query.query,
-        }, link_mode, color)) {
+        }, link_mode, color, .basename)) {
             .no_match => {},
             .ok => return .ok,
         }
 @@ -2268,7 +2271,7 @@ fn resolveLibInput(
     // In the case of Darwin, the main check will be .dylib, so here we
     // additionally check for .so files.
-    if (target.os.tag.isDarwin() and link_mode == .dynamic and !name_query.query.name_done) so: {
+    if (target.os.tag.isDarwin() and link_mode == .dynamic and !name_query.name_done) so: {
         const test_path: Path = .{
             .root_dir = lib_directory,
             .sub_path = try std.fmt.allocPrint(arena, "lib{s}.so", .{lib_name}),
 @@ -2279,12 +2282,21 @@ fn resolveLibInput(
             else => |e| fatal("unable to search for so library {qf}: {t}", .{ test_path, e }),
         };
         errdefer file.close(io);
-        return finishResolveLibInput(io, resolved_inputs, archive_dedup, test_path, file, link_mode, name_query.query);
+        return finishResolveLibInput(
+            io,
+            resolved_inputs,
+            archive_dedup,
+            test_path,
+            file,
+            link_mode,
+            name_query.query,
+            .basename,
+        );
     }
     // In the case of MinGW, the main check will be .lib but we also need to
     // look for `libfoo.a`.
-    if (target.isMinGW() and link_mode == .static and !name_query.query.name_done) mingw: {
+    if (target.isMinGW() and link_mode == .static and !name_query.name_done) mingw: {
         const test_path: Path = .{
             .root_dir = lib_directory,
             .sub_path = try std.fmt.allocPrint(arena, "lib{s}.a", .{lib_name}),
 @@ -2295,13 +2307,22 @@ fn resolveLibInput(
             else => |e| fatal("unable to search for static library {qf}: {t}", .{ test_path, e }),
         };
         errdefer file.close(io);
-        return finishResolveLibInput(io, resolved_inputs, archive_dedup, test_path, file, link_mode, name_query.query);
+        return finishResolveLibInput(
+            io,
+            resolved_inputs,
+            archive_dedup,
+            test_path,
+            file,
+            link_mode,
+            name_query.query,
+            .basename,
+        );
     }
     // In the case of OpenBSD, dynamic libraries are always versioned, without
     // unversioned symlinks. OpenBSD patches LLD to select the highest-versioned
     // shared library, and this code is intended to match that upstream behavior.
-    if (target.isOpenBSDLibC() and link_mode == .dynamic and !name_query.query.name_done) versioned: {
+    if (target.isOpenBSDLibC() and link_mode == .dynamic and !name_query.name_done) versioned: {
         const prefix = try std.fmt.allocPrint(arena, "lib{s}.so.", .{lib_name});
         var dir = lib_directory.handle.openDir(io, ".", .{ .iterate = true }) catch |err| switch (err) {
 @@ -2347,7 +2368,7 @@ fn resolveLibInput(
             switch (try resolvePathInputLib(gpa, arena, io, unresolved_inputs, resolved_inputs, ld_script_bytes, archive_dedup, target, .{
                 .path = test_path,
                 .query = name_query.query,
-            }, link_mode, color)) {
+            }, link_mode, color, .basename)) {
                 .no_match => {},
                 .ok => return .ok,
             }
 @@ -2388,6 +2409,7 @@ fn finishResolveLibInput(
     file: Io.File,
     link_mode: std.lang.LinkMode,
     query: UnresolvedInput.Query,
+    fallback_soname: Input.Dso.FallbackSoname,
 ) ResolveLibInputResult {
     switch (link_mode) {
         .static => {
 @@ -2413,9 +2435,7 @@ fn finishResolveLibInput(
                 .needed = query.needed,
                 .weak = query.weak,
                 .reexport = query.reexport,
-                // Here we assume that `Path.sub_path` is usable as `exact_name`, however the code after this point
+                .fallback_soname = fallback_soname,
-                // has no business making that assumption.
-                .exact_name = if (query.name_done) path.sub_path else null,
             },
         }),
     }
 @@ -2439,8 +2459,34 @@ fn resolvePathInput(
     color: std.zig.Color,
 ) Allocator.Error!?ResolveLibInputResult {
     switch (Compilation.classifyFileExt(pq.path.sub_path)) {
-        .static_library => return try resolvePathInputLib(gpa, arena, io, unresolved_inputs, resolved_inputs, ld_script_bytes, archive_dedup, target, pq, .static, color),
+        .static_library => return try resolvePathInputLib(
-        .shared_library => return try resolvePathInputLib(gpa, arena, io, unresolved_inputs, resolved_inputs, ld_script_bytes, archive_dedup, target, pq, .dynamic, color),
+            gpa,
+            arena,
+            io,
+            unresolved_inputs,
+            resolved_inputs,
+            ld_script_bytes,
+            archive_dedup,
+            target,
+            pq,
+            .static,
+            color,
+            .full_path,
+        ),
+        .shared_library => return try resolvePathInputLib(
+            gpa,
+            arena,
+            io,
+            unresolved_inputs,
+            resolved_inputs,
+            ld_script_bytes,
+            archive_dedup,
+            target,
+            pq,
+            .dynamic,
+            color,
+            .full_path,
+        ),
         .object => {
             var file = pq.path.root_dir.handle.openFile(io, pq.path.sub_path, .{}) catch |err|
                 fatal("failed to open object {f}: {t}", .{ pq.path, err });
 @@ -2483,6 +2529,7 @@ fn resolvePathInputLib(
     pq: UnresolvedInput.PathQuery,
     link_mode: std.lang.LinkMode,
     color: std.zig.Color,
+    fallback_soname: Input.Dso.FallbackSoname,
 ) Allocator.Error!ResolveLibInputResult {
     try resolved_inputs.ensureUnusedCapacity(gpa, 1);
     try archive_dedup.ensureUnusedCapacity(gpa, 1);
 @@ -2510,7 +2557,16 @@ fn resolvePathInputLib(
             mem.startsWith(u8, buf, std.elf.ARMAG_THIN))
         {
             // Appears to be an ELF or archive file.
-            return finishResolveLibInput(io, resolved_inputs, archive_dedup, test_path, file, link_mode, pq.query);
+            return finishResolveLibInput(
+                io,
+                resolved_inputs,
+                archive_dedup,
+                test_path,
+                file,
+                link_mode,
+                pq.query,
+                fallback_soname,
+            );
         }
         const stat = file.stat(io) catch |err|
             fatal("failed to stat {f}: {t}", .{ test_path, err });
 @@ -2561,6 +2617,7 @@ fn resolvePathInputLib(
                 unresolved_inputs.appendAssumeCapacity(.{ .name_query = .{
                     .name = try arena.dupe(u8, arg.path["-l".len..]),
                     .query = query,
+                    .name_done = false,
                 } });
             } else {
                 unresolved_inputs.appendAssumeCapacity(.{ .ambiguous_name = .{
 @@ -2578,7 +2635,16 @@ fn resolvePathInputLib(
         else => |e| fatal("unable to search for {t} library {f}: {t}", .{ link_mode, test_path, e }),
     };
     errdefer file.close(io);
-    return finishResolveLibInput(io, resolved_inputs, archive_dedup, test_path, file, link_mode, pq.query);
+    return finishResolveLibInput(
+        io,
+        resolved_inputs,
+        archive_dedup,
+        test_path,
+        file,
+        link_mode,
+        pq.query,
+        fallback_soname,
+    );
 }
 pub fn openObject(io: Io, path: Path, must_link: bool, hidden: bool) !Input.Object {
 @@ -2601,7 +2667,7 @@ pub fn openDso(io: Io, path: Path, needed: bool, weak: bool, reexport: bool) !In
         .needed = needed,
         .weak = weak,
         .reexport = reexport,
-        .exact_name = null,
+        .fallback_soname = .full_path,
     };
 }

src/link/Elf.zig+9-4

 @@ -735,7 +735,7 @@ pub fn loadInput(self: *Elf, input: link.Input) !void {
         } else {
             try parseArchive(gpa, io, diags, &self.file_handles, &self.files, target, debug_fmt_strip, default_sym_version, &self.objects, obj);
         },
-        .dso => |dso| try parseDso(gpa, io, diags, dso, &self.shared_objects, &self.files, target),
+        .dso => |dso| try parseDso(gpa, comp.arena, io, diags, dso, &self.shared_objects, &self.files, target),
     }
 }
 @@ -1106,6 +1106,7 @@ fn parseArchive(
 fn parseDso(
     gpa: Allocator,
+    arena: Allocator,
     io: Io,
     diags: *Diags,
     dso: link.Input.Dso,
 @@ -1118,13 +1119,16 @@ fn parseDso(
     const handle = dso.file;
-    if (dso.exact_name != null) @panic("TODO");
     const stat: Stat = .init(try handle.stat(io));
     var header = try SharedObject.parseHeader(gpa, io, diags, dso.path, handle, stat, target);
     defer header.deinit(gpa);
-    const soname = header.soname() orelse dso.path.basename();
+    const fallback_soname: []const u8 = switch (dso.fallback_soname) {
+        .full_path => try dso.path.toString(arena),
+        .basename => fs.path.basename(dso.path.sub_path),
+    };
+    const soname = header.soname() orelse fallback_soname;
     const gop = try shared_objects.getOrPut(gpa, soname);
     if (gop.found_existing) return;
 @@ -1156,6 +1160,7 @@ fn parseDso(
             .symbols_extra = .empty,
             .symbols_resolver = .empty,
             .output_symtab_ctx = .{},
+            .fallback_soname = fallback_soname,
         },
     });
     const so = fileLookup(files.*, index, null).?.shared_object;

src/link/Elf/SharedObject.zig+3-1

...	@@ -31,6 +31,8 @@ alive: bool,	...	@@ -31,6 +31,8 @@ alive: bool,
31		31
32	output_symtab_ctx: Elf.SymtabCtx,	32	output_symtab_ctx: Elf.SymtabCtx,
33		33
		34	fallback_soname: []const u8,
		35
34	pub fn deinit(so: *SharedObject, gpa: Allocator) void {	36	pub fn deinit(so: *SharedObject, gpa: Allocator) void {
35	gpa.free(so.path.sub_path);	37	gpa.free(so.path.sub_path);
36	so.parsed.deinit(gpa);	38	so.parsed.deinit(gpa);
...	@@ -427,7 +429,7 @@ pub fn asFile(self: *SharedObject) File {	...	@@ -427,7 +429,7 @@ pub fn asFile(self: *SharedObject) File {
427	}	429	}
428		430
429	pub fn soname(self: *SharedObject) []const u8 {	431	pub fn soname(self: *SharedObject) []const u8 {
430	return self.parsed.soname() orelse self.path.basename();	432	return self.parsed.soname() orelse self.fallback_soname;
431	}	433	}
432		434
433	pub fn initSymbolAliases(self: SharedObject, elf_file: Elf) !void {	435	pub fn initSymbolAliases(self: SharedObject, elf_file: Elf) !void {

src/link/Elf2.zig+11-11

 @@ -6228,17 +6228,9 @@ fn loadInputInner(elf: *Elf, input: link.Input) (Error || error{BadMagic})!void
         },
         .res => unreachable,
         .dso => |dso| {
-            if (dso.exact_name) |exact_name| {
-                // This means the path field is still valid, but the NEEDED entry must be set to
-                // exactly the `exact_name` string.
-                std.debug.panic("load dso_exact {q}", .{exact_name});
-                if (elf.shndx.dynamic != .UNDEF) {
-                    try elf.needed.put(elf.base.comp.gpa, try elf.string(.dynstr, exact_name), {});
-                }
-            }
             try elf.needed.ensureUnusedCapacity(elf.base.comp.gpa, 1);
             var fr = dso.file.reader(io, &buf);
-            elf.loadDso(dso.path, &fr) catch |err| switch (err) {
+            elf.loadDso(dso.path, dso.fallback_soname, &fr) catch |err| switch (err) {
                 else => |e| return e,
                 error.EndOfStream => return diags.failParse(dso.path, "unexpected eof", .{}),
                 error.AccessDenied, error.Unexpected, error.Unseekable => |e| return diags.fail(
 @@ -6860,7 +6852,12 @@ fn populateArchiveMemberName(elf: *Elf, member_ar_hdr: *std.elf.ar_hdr, member_n
     @memcpy(dest_slice[0 .. dest_slice.len - 2], member_name);
     @memcpy(dest_slice[dest_slice.len - 2 ..], "/\n"); // yes, the terminator is weird
 }
-fn loadDso(elf: *Elf, path: std.Build.Cache.Path, fr: *Io.File.Reader) (LoadParseInputError || error{BadMagic})!void {
+fn loadDso(
+    elf: *Elf,
+    path: std.Build.Cache.Path,
+    fallback_soname: link.Input.Dso.FallbackSoname,
+    fr: *Io.File.Reader,
+) (LoadParseInputError || error{BadMagic})!void {
     const comp = elf.base.comp;
     const gpa = comp.gpa;
     const diags = &comp.link_diags;
 @@ -6956,7 +6953,10 @@ fn loadDso(elf: *Elf, path: std.Build.Cache.Path, fr: *Io.File.Reader) (LoadPars
                     }
                     break std.mem.sliceTo(dynstr[@intCast(val)..], 0);
                 }
-            } else std.fs.path.basename(path.sub_path);
+            } else switch (fallback_soname) {
+                .basename => std.fs.path.basename(path.sub_path),
+                .full_path => try path.toString(comp.arena),
+            };
             try elf.needed.put(gpa, try elf.string(.dynstr, soname), {});
             // Scan the symbol table and populate `elf.dso_globals`.

src/link/Lld.zig+17-18

 @@ -1154,6 +1154,13 @@ fn elfLink(lld: *Lld, arena: Allocator) !void {
             argv.appendAssumeCapacity("--as-needed");
             var as_needed = true;
+            // When we have a DSO input, in order to trick LLD into putting the basename in its
+            // `DT_NEEDED` entry while still allowing us to tell it the exact path to the shared
+            // object, we pass it on the CLI as "-l:/absolute/path/to/libfoo.so". This will treat
+            // the given path not actually as an absolute path, but as relative to the library
+            // search path, so the root directory must therefore be the only library search path.
+            try argv.append("-L/");
             for (base.comp.link_inputs) |link_input| switch (link_input) {
                 .res => unreachable, // Windows-only
                 .object, .archive => continue,
 @@ -1171,24 +1178,16 @@ fn elfLink(lld: *Lld, arena: Allocator) !void {
                         },
                     }
-                    if (dso.exact_name) |exact_name| {
+                    // By this time, we depend on these libs being dynamically linked libraries and
-                        // LLD does not have a way to specify full path to the DSO while also specifying
+                    // not static libraries (the check for that needs to be earlier), but they could
-                        // the exact value for NEEDED, so we have to use a combination of -L and -l args.
+                    // be full file paths, in which case we don't want to use the "-l:" strategy.
-                        assert(mem.endsWith(u8, dso.path.sub_path, exact_name));
+                    switch (dso.fallback_soname) {
-                        const truncated_path: Cache.Path = .{
+                        .basename => try argv.append(try arena.print("-l:{s}", .{try fs.path.resolve(arena, &.{
-                            .root_dir = dso.path.root_dir,
+                            comp.dirs.cwd,
-                            .sub_path = dso.path.sub_path[0 .. dso.path.sub_path.len - exact_name.len],
+                            dso.path.root_dir.path orelse ".",
-                        };
+                            dso.path.sub_path,
-                        try argv.ensureUnusedCapacity(3);
+                        })})),
-                        argv.appendAssumeCapacity("-L");
+                        .full_path => try argv.append(try dso.path.toString(arena)),
-                        argv.appendAssumeCapacity(try truncated_path.toString(arena));
-                        argv.appendAssumeCapacity(try arena.print("-l:{s}", .{exact_name}));
-                    } else {
-                        // By this time, we depend on these libs being dynamically linked
-                        // libraries and not static libraries (the check for that needs to be earlier),
-                        // but they could be full paths to .so files, in which case we
-                        // want to avoid prepending "-l".
-                        argv.appendAssumeCapacity(try dso.path.toString(arena));
                     }
                 },
             };

src/link/MachO.zig+2-10

 @@ -655,11 +655,7 @@ fn dumpArgv(self: *MachO, comp: *Compilation) !void {
             .object, .archive => |obj| try argv.append(try obj.path.toString(arena)),
             .res => |res| try argv.append(try res.path.toString(arena)),
             .dso => |dso| {
-                if (dso.exact_name) |exact_name| {
+                try argv.append(try dso.path.toString(arena));
-                    try argv.appendSlice(&.{ "-l", try arena.print(":{s}", .{exact_name}) });
-                } else {
-                    try argv.append(try dso.path.toString(arena));
-                }
             },
         };
 @@ -789,11 +785,7 @@ fn dumpArgv(self: *MachO, comp: *Compilation) !void {
                 } else {
                     argv.appendAssumeCapacity("-l");
                 }
-                if (dso.exact_name) |exact_name| {
+                argv.appendAssumeCapacity(try dso.path.toString(arena));
-                    argv.appendAssumeCapacity(try arena.print(":{s}", .{exact_name}));
-                } else {
-                    argv.appendAssumeCapacity(try dso.path.toString(arena));
-                }
             },
         };

src/main.zig+16-1

...	@@ -1351,6 +1351,7 @@ fn buildOutputType(	...	@@ -1351,6 +1351,7 @@ fn buildOutputType(
1351	.search_strategy = lib_search_strategy,	1351	.search_strategy = lib_search_strategy,
1352	.allow_so_scripts = allow_so_scripts,	1352	.allow_so_scripts = allow_so_scripts,
1353	},	1353	},
		1354	.name_done = false,
1354	} });	1355	} });
1355	} else if (mem.eql(u8, arg, "--needed-library") or	1356	} else if (mem.eql(u8, arg, "--needed-library") or
1356	mem.eql(u8, arg, "-needed-l") or	1357	mem.eql(u8, arg, "-needed-l") or
...	@@ -1366,6 +1367,7 @@ fn buildOutputType(	...	@@ -1366,6 +1367,7 @@ fn buildOutputType(
1366	.search_strategy = lib_search_strategy,	1367	.search_strategy = lib_search_strategy,
1367	.allow_so_scripts = allow_so_scripts,	1368	.allow_so_scripts = allow_so_scripts,
1368	},	1369	},
		1370	.name_done = false,
1369	} });	1371	} });
1370	} else if (mem.eql(u8, arg, "-weak_library") or mem.eql(u8, arg, "-weak-l")) {	1372	} else if (mem.eql(u8, arg, "-weak_library") or mem.eql(u8, arg, "-weak-l")) {
1371	try create_module.cli_link_inputs.append(arena, .{ .name_query = .{	1373	try create_module.cli_link_inputs.append(arena, .{ .name_query = .{
...	@@ -1377,6 +1379,7 @@ fn buildOutputType(	...	@@ -1377,6 +1379,7 @@ fn buildOutputType(
1377	.search_strategy = lib_search_strategy,	1379	.search_strategy = lib_search_strategy,
1378	.allow_so_scripts = allow_so_scripts,	1380	.allow_so_scripts = allow_so_scripts,
1379	},	1381	},
		1382	.name_done = false,
1380	} });	1383	} });
1381	} else if (mem.eql(u8, arg, "-D")) {	1384	} else if (mem.eql(u8, arg, "-D")) {
1382	try cc_argv.appendSlice(arena, &.{ arg, args_iter.nextOrFatal() });	1385	try cc_argv.appendSlice(arena, &.{ arg, args_iter.nextOrFatal() });
...	@@ -1839,6 +1842,7 @@ fn buildOutputType(	...	@@ -1839,6 +1842,7 @@ fn buildOutputType(
1839	.search_strategy = lib_search_strategy,	1842	.search_strategy = lib_search_strategy,
1840	.allow_so_scripts = allow_so_scripts,	1843	.allow_so_scripts = allow_so_scripts,
1841	},	1844	},
		1845	.name_done = false,
1842	} });	1846	} });
1843	} else if (mem.cutPrefix(u8, arg, "-needed-l")) \|name\| {	1847	} else if (mem.cutPrefix(u8, arg, "-needed-l")) \|name\| {
1844	try create_module.cli_link_inputs.append(arena, .{ .name_query = .{	1848	try create_module.cli_link_inputs.append(arena, .{ .name_query = .{
...	@@ -1850,6 +1854,7 @@ fn buildOutputType(	...	@@ -1850,6 +1854,7 @@ fn buildOutputType(
1850	.search_strategy = lib_search_strategy,	1854	.search_strategy = lib_search_strategy,
1851	.allow_so_scripts = allow_so_scripts,	1855	.allow_so_scripts = allow_so_scripts,
1852	},	1856	},
		1857	.name_done = false,
1853	} });	1858	} });
1854	} else if (mem.cutPrefix(u8, arg, "-weak-l")) \|name\| {	1859	} else if (mem.cutPrefix(u8, arg, "-weak-l")) \|name\| {
1855	try create_module.cli_link_inputs.append(arena, .{ .name_query = .{	1860	try create_module.cli_link_inputs.append(arena, .{ .name_query = .{
...	@@ -1861,6 +1866,7 @@ fn buildOutputType(	...	@@ -1861,6 +1866,7 @@ fn buildOutputType(
1861	.search_strategy = lib_search_strategy,	1866	.search_strategy = lib_search_strategy,
1862	.allow_so_scripts = allow_so_scripts,	1867	.allow_so_scripts = allow_so_scripts,
1863	},	1868	},
		1869	.name_done = false,
1864	} });	1870	} });
1865	} else if (mem.startsWith(u8, arg, "-D")) {	1871	} else if (mem.startsWith(u8, arg, "-D")) {
1866	try cc_argv.append(arena, arg);	1872	try cc_argv.append(arena, arg);
...	@@ -2095,8 +2101,8 @@ fn buildOutputType(	...	@@ -2095,8 +2101,8 @@ fn buildOutputType(
2095	.preferred_mode = lib_preferred_mode,	2101	.preferred_mode = lib_preferred_mode,
2096	.search_strategy = lib_search_strategy,	2102	.search_strategy = lib_search_strategy,
2097	.allow_so_scripts = allow_so_scripts,	2103	.allow_so_scripts = allow_so_scripts,
2098	.name_done = true,
2099	},	2104	},
		2105	.name_done = true,
2100	} });	2106	} });
2101	} else {	2107	} else {
2102	const compiler_rt_classification = target_util.classifyCompilerRtLibName(it.only_arg);	2108	const compiler_rt_classification = target_util.classifyCompilerRtLibName(it.only_arg);
...	@@ -2122,6 +2128,7 @@ fn buildOutputType(	...	@@ -2122,6 +2128,7 @@ fn buildOutputType(
2122	.search_strategy = lib_search_strategy,	2128	.search_strategy = lib_search_strategy,
2123	.allow_so_scripts = allow_so_scripts,	2129	.allow_so_scripts = allow_so_scripts,
2124	},	2130	},
		2131	.name_done = false,
2125	} });	2132	} });
2126	}	2133	}
2127	}	2134	}
...	@@ -2552,6 +2559,7 @@ fn buildOutputType(	...	@@ -2552,6 +2559,7 @@ fn buildOutputType(
2552	.search_strategy = lib_search_strategy,	2559	.search_strategy = lib_search_strategy,
2553	.allow_so_scripts = allow_so_scripts,	2560	.allow_so_scripts = allow_so_scripts,
2554	},	2561	},
		2562	.name_done = false,
2555	} }),	2563	} }),
2556	.weak_framework => try create_module.frameworks.put(arena, it.only_arg, .{ .weak = true }),	2564	.weak_framework => try create_module.frameworks.put(arena, it.only_arg, .{ .weak = true }),
2557	.headerpad_max_install_names => headerpad_max_install_names = true,	2565	.headerpad_max_install_names => headerpad_max_install_names = true,
...	@@ -2921,6 +2929,7 @@ fn buildOutputType(	...	@@ -2921,6 +2929,7 @@ fn buildOutputType(
2921	.search_strategy = lib_search_strategy,	2929	.search_strategy = lib_search_strategy,
2922	.allow_so_scripts = allow_so_scripts,	2930	.allow_so_scripts = allow_so_scripts,
2923	},	2931	},
		2932	.name_done = false,
2924	} });	2933	} });
2925	} else if (mem.cutPrefix(u8, arg, "-weak-l")) \|rest\| {	2934	} else if (mem.cutPrefix(u8, arg, "-weak-l")) \|rest\| {
2926	try create_module.cli_link_inputs.append(arena, .{ .name_query = .{	2935	try create_module.cli_link_inputs.append(arena, .{ .name_query = .{
...	@@ -2932,6 +2941,7 @@ fn buildOutputType(	...	@@ -2932,6 +2941,7 @@ fn buildOutputType(
2932	.search_strategy = lib_search_strategy,	2941	.search_strategy = lib_search_strategy,
2933	.allow_so_scripts = allow_so_scripts,	2942	.allow_so_scripts = allow_so_scripts,
2934	},	2943	},
		2944	.name_done = false,
2935	} });	2945	} });
2936	} else if (mem.eql(u8, arg, "-weak_library")) {	2946	} else if (mem.eql(u8, arg, "-weak_library")) {
2937	try create_module.cli_link_inputs.append(arena, .{ .name_query = .{	2947	try create_module.cli_link_inputs.append(arena, .{ .name_query = .{
...	@@ -2943,6 +2953,7 @@ fn buildOutputType(	...	@@ -2943,6 +2953,7 @@ fn buildOutputType(
2943	.search_strategy = lib_search_strategy,	2953	.search_strategy = lib_search_strategy,
2944	.allow_so_scripts = allow_so_scripts,	2954	.allow_so_scripts = allow_so_scripts,
2945	},	2955	},
		2956	.name_done = false,
2946	} });	2957	} });
2947	} else if (mem.eql(u8, arg, "-compatibility_version")) {	2958	} else if (mem.eql(u8, arg, "-compatibility_version")) {
2948	const compat_version = linker_args_it.nextOrFatal();	2959	const compat_version = linker_args_it.nextOrFatal();
...	@@ -4183,6 +4194,10 @@ fn createModule(	...	@@ -4183,6 +4194,10 @@ fn createModule(
4183	fatal("cannot use absolute path as a system library: {s}", .{lib_name});	4194	fatal("cannot use absolute path as a system library: {s}", .{lib_name});
4184	}	4195	}
4185		4196
		4197	if (!nq.name_done and std.mem.findScalar(u8, nq.name, '/') != null) {
		4198	fatal("cannot use path separator in system library name: {s}", .{lib_name});
		4199	}
		4200
4186	unresolved_link_inputs.appendAssumeCapacity(cli_link_input);	4201	unresolved_link_inputs.appendAssumeCapacity(cli_link_input);
4187	any_name_queries_remaining = true;	4202	any_name_queries_remaining = true;
4188	},	4203	},