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

Author: a-khabarov

src/link.zig

@@ -1818,6 +1818,8 @@ pub const Input = union(enum) {
         needed: bool,
         weak: bool,
         reexport: bool,
+        name: ?[]const u8,
+        lib_directory: Directory,
     };
 
     pub const DsoExact = struct {
@@ -2145,7 +2147,7 @@ fn resolveLibInput(
             else => |e| fatal("unable to search for tbd library '{}': {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);
     }
 
     {
@@ -2159,10 +2161,10 @@ fn resolveLibInput(
             }),
         };
         try checked_paths.writer(gpa).print("\n  {}", .{test_path});
-        switch (try resolvePathInputLib(gpa, arena, unresolved_inputs, resolved_inputs, ld_script_bytes, target, .{
+        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,
         }
@@ -2183,7 +2185,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
@@ -2199,7 +2201,7 @@ fn resolveLibInput(
             else => |e| fatal("unable to search for static library '{}': {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;
@@ -2211,6 +2213,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 = .{
@@ -2225,6 +2229,8 @@ fn finishResolveLibInput(
             .needed = query.needed,
             .weak = query.weak,
             .reexport = query.reexport,
+            .name = name,
+            .lib_directory = lib_directory,
         } }),
     }
     return .ok;
@@ -2244,8 +2250,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 {}: {s}", .{ pq.path, @errorName(err) });
@@ -2281,10 +2287,12 @@ fn resolvePathInputLib(
     resolved_inputs: *std.ArrayListUnmanaged(Input),
     /// Allocated via `gpa`.
     ld_script_bytes: *std.ArrayListUnmanaged(u8),
+    lib_directory: Directory,
     target: 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);
 
@@ -2309,7 +2317,7 @@ fn resolvePathInputLib(
             if (n != ld_script_bytes.items.len) break :elf_file;
             if (!mem.eql(u8, ld_script_bytes.items[0..4], "\x7fELF")) break :elf_file;
             // Appears to be an ELF 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 {}: {s}", .{ test_path, @errorName(err) });
@@ -2375,7 +2383,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 {
@@ -2398,6 +2406,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/Elf.zig

@@ -1980,9 +1980,12 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
 
         // Shared libraries.
         if (is_exe_or_dyn_lib) {
-            // Worst-case, we need an --as-needed argument for every lib, as well
-            // as one before and one after.
-            try argv.ensureUnusedCapacity(2 * self.base.comp.link_inputs.len + 2);
+            // Worst-case, we need:
+            // * an --as-needed/--no-as-needed argument for every lib
+            // * -L, lib directory, -l/-weak-l, library name for every lib
+            // * one --as-needed before and one --as-needed after
+            try argv.ensureUnusedCapacity(5 * self.base.comp.link_inputs.len + 2);
+
             argv.appendAssumeCapacity("--as-needed");
             var as_needed = true;
 
@@ -2004,10 +2007,17 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
                     }
 
                     // 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));
+                    }
                 },
             };