link: make zig cc pass -l/-L like Clang/GCC for ELF

Author: a-khabarov

src/link.zig

@@ -1609,6 +1609,8 @@ pub const Input = union(enum) {
         needed: bool,
         weak: bool,
         reexport: bool,
+        name: ?[]const u8,
+        lib_directory: Directory,
     };
 
     pub const DsoExact = struct {
@@ -1661,6 +1663,8 @@ 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.name);
+                man.hash.addOptionalBytes(dso.lib_directory.path);
             },
             .dso_exact => |dso_exact| {
                 man.hash.addBytes(dso_exact.name);
@@ -1936,7 +1940,7 @@ fn resolveLibInput(
             else => |e| fatal("unable to search for tbd library '{f}': {s}", .{ test_path, @errorName(e) }),
         };
         errdefer file.close();
-        return finishResolveLibInput(resolved_inputs, test_path, file, link_mode, name_query.query);
+        return finishResolveLibInput(resolved_inputs, test_path, file, link_mode, name_query.query, name_query.name, lib_directory);
     }
 
     {
@@ -1949,11 +1953,11 @@ fn resolveLibInput(
                 },
             }),
         };
-        try checked_paths.writer(gpa).print("\n  {f}", .{test_path});
-        switch (try resolvePathInputLib(gpa, arena, unresolved_inputs, resolved_inputs, ld_script_bytes, target, .{
+        try checked_paths.writer(gpa).print("\n  {}", .{test_path});
+        switch (try resolvePathInputLib(gpa, arena, unresolved_inputs, resolved_inputs, ld_script_bytes, lib_directory, target, .{
             .path = test_path,
             .query = name_query.query,
-        }, link_mode, color)) {
+        }, link_mode, color, name_query.name)) {
             .no_match => {},
             .ok => return .ok,
         }
@@ -1974,7 +1978,7 @@ fn resolveLibInput(
             }),
         };
         errdefer file.close();
-        return finishResolveLibInput(resolved_inputs, test_path, file, link_mode, name_query.query);
+        return finishResolveLibInput(resolved_inputs, test_path, file, link_mode, name_query.query, name_query.name, lib_directory);
     }
 
     // In the case of MinGW, the main check will be .lib but we also need to
@@ -1990,7 +1994,7 @@ fn resolveLibInput(
             else => |e| fatal("unable to search for static library '{f}': {s}", .{ test_path, @errorName(e) }),
         };
         errdefer file.close();
-        return finishResolveLibInput(resolved_inputs, test_path, file, link_mode, name_query.query);
+        return finishResolveLibInput(resolved_inputs, test_path, file, link_mode, name_query.query, name_query.name, lib_directory);
     }
 
     return .no_match;
@@ -2002,6 +2006,8 @@ fn finishResolveLibInput(
     file: std.fs.File,
     link_mode: std.builtin.LinkMode,
     query: UnresolvedInput.Query,
+    name: ?[]const u8,
+    lib_directory: Directory,
 ) ResolveLibInputResult {
     switch (link_mode) {
         .static => resolved_inputs.appendAssumeCapacity(.{ .archive = .{
@@ -2016,6 +2022,8 @@ fn finishResolveLibInput(
             .needed = query.needed,
             .weak = query.weak,
             .reexport = query.reexport,
+            .name = name,
+            .lib_directory = lib_directory,
         } }),
     }
     return .ok;
@@ -2035,8 +2043,8 @@ fn resolvePathInput(
     color: std.zig.Color,
 ) Allocator.Error!?ResolveLibInputResult {
     switch (Compilation.classifyFileExt(pq.path.sub_path)) {
-        .static_library => return try resolvePathInputLib(gpa, arena, unresolved_inputs, resolved_inputs, ld_script_bytes, target, pq, .static, color),
-        .shared_library => return try resolvePathInputLib(gpa, arena, unresolved_inputs, resolved_inputs, ld_script_bytes, target, pq, .dynamic, color),
+        .static_library => return try resolvePathInputLib(gpa, arena, unresolved_inputs, resolved_inputs, ld_script_bytes, Directory.cwd(), target, pq, .static, color, null),
+        .shared_library => return try resolvePathInputLib(gpa, arena, unresolved_inputs, resolved_inputs, ld_script_bytes, Directory.cwd(), target, pq, .dynamic, color, null),
         .object => {
             var file = pq.path.root_dir.handle.openFile(pq.path.sub_path, .{}) catch |err|
                 fatal("failed to open object {f}: {s}", .{ pq.path, @errorName(err) });
@@ -2072,10 +2080,12 @@ fn resolvePathInputLib(
     resolved_inputs: *std.ArrayListUnmanaged(Input),
     /// Allocated via `gpa`.
     ld_script_bytes: *std.ArrayListUnmanaged(u8),
+    lib_directory: Directory,
     target: *const std.Target,
     pq: UnresolvedInput.PathQuery,
     link_mode: std.builtin.LinkMode,
     color: std.zig.Color,
+    name: ?[]const u8,
 ) Allocator.Error!ResolveLibInputResult {
     try resolved_inputs.ensureUnusedCapacity(gpa, 1);
 
@@ -2100,7 +2110,7 @@ fn resolvePathInputLib(
         const buf = ld_script_bytes.items[0..n];
         if (mem.startsWith(u8, buf, std.elf.MAGIC) or mem.startsWith(u8, buf, std.elf.ARMAG)) {
             // Appears to be an ELF or archive file.
-            return finishResolveLibInput(resolved_inputs, test_path, file, link_mode, pq.query);
+            return finishResolveLibInput(resolved_inputs, test_path, file, link_mode, pq.query, name, lib_directory);
         }
         const stat = file.stat() catch |err|
             fatal("failed to stat {f}: {s}", .{ test_path, @errorName(err) });
@@ -2166,7 +2176,7 @@ fn resolvePathInputLib(
         }),
     };
     errdefer file.close();
-    return finishResolveLibInput(resolved_inputs, test_path, file, link_mode, pq.query);
+    return finishResolveLibInput(resolved_inputs, test_path, file, link_mode, pq.query, name, lib_directory);
 }
 
 pub fn openObject(path: Path, must_link: bool, hidden: bool) !Input.Object {
@@ -2189,6 +2199,8 @@ pub fn openDso(path: Path, needed: bool, weak: bool, reexport: bool) !Input.Dso
         .needed = needed,
         .weak = weak,
         .reexport = reexport,
+        .name = null,
+        .lib_directory = Directory.cwd(),
     };
 }
 

src/link/Lld.zig

@@ -1179,10 +1179,17 @@ fn elfLink(lld: *Lld, arena: Allocator) !void {
                     }
 
                     // 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));
+                    // libraries and not static libraries (the check for that needs to be earlier).
+                    if (dso.name) |name| {
+                        if (dso.lib_directory.path) |path| {
+                            argv.appendAssumeCapacity("-L");
+                            argv.appendAssumeCapacity(path);
+                        }
+                        argv.appendAssumeCapacity(if (dso.weak) "-weak-l" else "-l");
+                        argv.appendAssumeCapacity(name);
+                    } else {
+                        argv.appendAssumeCapacity(try dso.path.toString(arena));
+                    }
                 },
             };