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

This commit makes the way `zig cc` passes `-l`/`-L` flags for ELF
linking consistent with Clang and GCC.

The fix itself is in `src/link/Elf.zig`.

The new test is in `test/link/elf.zig`. It follows the example from
#19699.

The rest of the changes are new functionality needed for the test:
* `omit_soname` option for `Build.Module`, `OverlayOptions`.
  This passes `-fno-soname` to the linker when enabled.
* `addLibraryPathSpecial` for `Build.Module`, `Build.Step.Compile`.
  Like `addLibraryPath` but for `[]const u8`.
  `addRPathSpecial` is also added for completeness.
* `setCwd` for `Build.Step.Compile`.
  Allows setting current directory for compile steps.
* `opt_cwd` for `evalZigProcess` in `Build.Step`.
  Allows running `evalZigProcess` in a specific directory.
  Needed for setting current directory for compile steps.
* `--zig-lib-dir` is now appended differently in `Build.Step.Compile`.
  This is needed for compatibility with `setCwd`.

Author: a-khabarov

lib/compiler/build_runner.zig

@@ -1496,7 +1496,10 @@ fn createModuleDependenciesForStep(step: *Step) Allocator.Error!void {
 
             .config_header_step => |other| step.dependOn(&other.step),
         };
-        for (mod.lib_paths.items) |lp| lp.addStepDependencies(step);
+        for (mod.lib_paths.items) |lib_path| switch (lib_path) {
+            .lazy_path => |lp| lp.addStepDependencies(step),
+            .special => {},
+        };
         for (mod.rpaths.items) |rpath| switch (rpath) {
             .lazy_path => |lp| lp.addStepDependencies(step),
             .special => {},

lib/std/Build/Module.zig

@@ -12,12 +12,13 @@ dwarf_format: ?std.dwarf.Format,
 
 c_macros: std.ArrayListUnmanaged([]const u8),
 include_dirs: std.ArrayListUnmanaged(IncludeDir),
-lib_paths: std.ArrayListUnmanaged(LazyPath),
+lib_paths: std.ArrayListUnmanaged(LibraryPath),
 rpaths: std.ArrayListUnmanaged(RPath),
 frameworks: std.StringArrayHashMapUnmanaged(LinkFrameworkOptions),
 link_objects: std.ArrayListUnmanaged(LinkObject),
 
 strip: ?bool,
+omit_soname: ?bool,
 unwind_tables: ?std.builtin.UnwindTables,
 single_threaded: ?bool,
 stack_protector: ?bool,
@@ -41,6 +42,11 @@ export_symbol_names: []const []const u8 = &.{},
 /// Use `getGraph` instead of accessing this field directly.
 cached_graph: Graph = .{ .modules = &.{}, .names = &.{} },
 
+pub const LibraryPath = union(enum) {
+    lazy_path: LazyPath,
+    special: []const u8,
+};
+
 pub const RPath = union(enum) {
     lazy_path: LazyPath,
     special: []const u8,
@@ -247,6 +253,7 @@ pub const CreateOptions = struct {
     link_libcpp: ?bool = null,
     single_threaded: ?bool = null,
     strip: ?bool = null,
+    omit_soname: ?bool = null,
     unwind_tables: ?std.builtin.UnwindTables = null,
     dwarf_format: ?std.dwarf.Format = null,
     code_model: std.builtin.CodeModel = .default,
@@ -296,6 +303,7 @@ pub fn init(
                 .frameworks = .{},
                 .link_objects = .{},
                 .strip = options.strip,
+                .omit_soname = options.omit_soname,
                 .unwind_tables = options.unwind_tables,
                 .single_threaded = options.single_threaded,
                 .stack_protector = options.stack_protector,
@@ -513,7 +521,12 @@ pub fn addFrameworkPath(m: *Module, directory_path: LazyPath) void {
 
 pub fn addLibraryPath(m: *Module, directory_path: LazyPath) void {
     const b = m.owner;
-    m.lib_paths.append(b.allocator, directory_path.dupe(b)) catch @panic("OOM");
+    m.lib_paths.append(b.allocator, .{ .lazy_path = directory_path.dupe(b) }) catch @panic("OOM");
+}
+
+pub fn addLibraryPathSpecial(m: *Module, bytes: []const u8) void {
+    const b = m.owner;
+    m.lib_paths.append(b.allocator, .{ .special = b.dupe(bytes) }) catch @panic("OOM");
 }
 
 pub fn addRPath(m: *Module, directory_path: LazyPath) void {
@@ -545,6 +558,7 @@ pub fn appendZigProcessFlags(
     const b = m.owner;
 
     try addFlag(zig_args, m.strip, "-fstrip", "-fno-strip");
+    try addFlag(zig_args, m.omit_soname, "-fno-soname", "-fsoname");
     try addFlag(zig_args, m.single_threaded, "-fsingle-threaded", "-fno-single-threaded");
     try addFlag(zig_args, m.stack_check, "-fstack-check", "-fno-stack-check");
     try addFlag(zig_args, m.stack_protector, "-fstack-protector", "-fno-stack-protector");
@@ -611,10 +625,16 @@ pub fn appendZigProcessFlags(
     try zig_args.appendSlice(m.c_macros.items);
 
     try zig_args.ensureUnusedCapacity(2 * m.lib_paths.items.len);
-    for (m.lib_paths.items) |lib_path| {
-        zig_args.appendAssumeCapacity("-L");
-        zig_args.appendAssumeCapacity(lib_path.getPath2(b, asking_step));
-    }
+    for (m.lib_paths.items) |lib_path| switch (lib_path) {
+        .lazy_path => |lp| {
+            zig_args.appendAssumeCapacity("-L");
+            zig_args.appendAssumeCapacity(lp.getPath2(b, asking_step));
+        },
+        .special => |bytes| {
+            zig_args.appendAssumeCapacity("-L");
+            zig_args.appendAssumeCapacity(bytes);
+        },
+    };
 
     try zig_args.ensureUnusedCapacity(2 * m.rpaths.items.len);
     for (m.rpaths.items) |rpath| switch (rpath) {

lib/std/Build/Step.zig

@@ -371,6 +371,7 @@ pub const ZigProcess = struct {
 /// is the zig compiler - the same version that compiled the build runner.
 pub fn evalZigProcess(
     s: *Step,
+    opt_cwd: ?[]const u8,
     argv: []const []const u8,
     prog_node: std.Progress.Node,
     watch: bool,
@@ -401,7 +402,7 @@ pub fn evalZigProcess(
             };
             s.result_peak_rss = zp.child.resource_usage_statistics.getMaxRss() orelse 0;
             s.clearZigProcess();
-            try handleChildProcessTerm(s, term, null, argv);
+            try handleChildProcessTerm(s, term, opt_cwd, argv);
             return error.MakeFailed;
         }
 
@@ -412,8 +413,8 @@ pub fn evalZigProcess(
     const arena = b.allocator;
     const gpa = arena;
 
-    try handleChildProcUnsupported(s, null, argv);
-    try handleVerbose(s.owner, null, argv);
+    try handleChildProcUnsupported(s, opt_cwd, argv);
+    try handleVerbose(s.owner, opt_cwd, argv);
 
     var child = std.process.Child.init(argv, arena);
     child.env_map = &b.graph.env_map;
@@ -422,6 +423,7 @@ pub fn evalZigProcess(
     child.stderr_behavior = .Pipe;
     child.request_resource_usage_statistics = true;
     child.progress_node = prog_node;
+    child.cwd = opt_cwd;
 
     child.spawn() catch |err| return s.fail("failed to spawn zig compiler {s}: {s}", .{
         argv[0], @errorName(err),
@@ -463,15 +465,15 @@ pub fn evalZigProcess(
             else => {},
         };
 
-        try handleChildProcessTerm(s, term, null, argv);
+        try handleChildProcessTerm(s, term, opt_cwd, argv);
     }
 
     // This is intentionally printed for failure on the first build but not for
     // subsequent rebuilds.
     if (s.result_error_bundle.errorMessageCount() > 0) {
         return s.fail("the following command failed with {d} compilation errors:\n{s}", .{
             s.result_error_bundle.errorMessageCount(),
-            try allocPrintCmd(arena, null, argv),
+            try allocPrintCmd(arena, opt_cwd, argv),
         });
     }
 

lib/std/Build/Step/Compile.zig

@@ -5,6 +5,7 @@ const fs = std.fs;
 const assert = std.debug.assert;
 const panic = std.debug.panic;
 const ArrayList = std.ArrayList;
+const Build = std.Build;
 const StringHashMap = std.StringHashMap;
 const Sha256 = std.crypto.hash.sha2.Sha256;
 const Allocator = mem.Allocator;
@@ -240,6 +241,9 @@ zig_process: ?*Step.ZigProcess,
 /// builtin fuzzer, see the `fuzz` flag in `Module`.
 sanitize_coverage_trace_pc_guard: ?bool = null,
 
+/// Use `setCwd` to set the initial current working directory
+cwd: ?Build.LazyPath = null,
+
 pub const ExpectedCompileErrors = union(enum) {
     contains: []const u8,
     exact: []const []const u8,
@@ -939,10 +943,18 @@ pub fn addLibraryPath(compile: *Compile, directory_path: LazyPath) void {
     compile.root_module.addLibraryPath(directory_path);
 }
 
+pub fn addLibraryPathSpecial(compile: *Compile, bytes: []const u8) void {
+    compile.root_module.addLibraryPathSpecial(bytes);
+}
+
 pub fn addRPath(compile: *Compile, directory_path: LazyPath) void {
     compile.root_module.addRPath(directory_path);
 }
 
+pub fn addRPathSpecial(compile: *Compile, bytes: []const u8) void {
+    compile.root_module.addRPathSpecial(bytes);
+}
+
 pub fn addSystemFrameworkPath(compile: *Compile, directory_path: LazyPath) void {
     compile.root_module.addSystemFrameworkPath(directory_path);
 }
@@ -1691,7 +1703,7 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {
 
     if (opt_zig_lib_dir) |zig_lib_dir| {
         try zig_args.append("--zig-lib-dir");
-        try zig_args.append(zig_lib_dir);
+        try zig_args.append(try fs.cwd().realpathAlloc(arena, zig_lib_dir));
     }
 
     try addFlag(&zig_args, "PIE", compile.pie);
@@ -1789,9 +1801,11 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
     const b = step.owner;
     const compile: *Compile = @fieldParentPtr("step", step);
 
+    const cwd: ?[]const u8 = if (compile.cwd) |lazy_cwd| lazy_cwd.getPath(b) else null;
     const zig_args = try getZigArgs(compile, false);
 
     const maybe_output_dir = step.evalZigProcess(
+        cwd,
         zig_args,
         options.progress_node,
         (b.graph.incremental == true) and options.watch,
@@ -1874,8 +1888,9 @@ pub fn rebuildInFuzzMode(c: *Compile, progress_node: std.Progress.Node) !Path {
     c.step.result_error_bundle.deinit(gpa);
     c.step.result_error_bundle = std.zig.ErrorBundle.empty;
 
+    const cwd: ?[]const u8 = if (c.cwd) |lazy_cwd| lazy_cwd.getPath(c.step.owner) else null;
     const zig_args = try getZigArgs(c, true);
-    const maybe_output_bin_path = try c.step.evalZigProcess(zig_args, progress_node, false);
+    const maybe_output_bin_path = try c.step.evalZigProcess(cwd, zig_args, progress_node, false);
     return maybe_output_bin_path.?;
 }
 
@@ -2116,3 +2131,8 @@ pub fn getCompileDependencies(start: *Compile, chase_dynamic: bool) []const *Com
 
     return compiles.keys();
 }
+
+pub fn setCwd(self: *Compile, cwd: Build.LazyPath) void {
+    cwd.addStepDependencies(&self.step);
+    self.cwd = cwd;
+}

lib/std/Build/Step/ObjCopy.zig

@@ -236,7 +236,7 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
     try argv.appendSlice(&.{ full_src_path, full_dest_path });
 
     try argv.append("--listen=-");
-    _ = try step.evalZigProcess(argv.items, prog_node, false);
+    _ = try step.evalZigProcess(null, argv.items, prog_node, false);
 
     objcopy.output_file.path = full_dest_path;
     if (objcopy.output_file_debug) |*file| file.path = full_dest_path_debug;

lib/std/Build/Step/TranslateC.zig

@@ -200,7 +200,7 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
     const c_source_path = translate_c.source.getPath2(b, step);
     try argv_list.append(c_source_path);
 
-    const output_dir = try step.evalZigProcess(argv_list.items, prog_node, false);
+    const output_dir = try step.evalZigProcess(null, argv_list.items, prog_node, false);
 
     const basename = std.fs.path.stem(std.fs.path.basename(c_source_path));
     translate_c.out_basename = b.fmt("{s}.zig", .{basename});

src/link/Elf.zig

@@ -1986,9 +1986,9 @@ 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
+            // Worst-case, we need --as-needed, -l, -L arguments for every lib, as well
             // as one before and one after.
-            try argv.ensureUnusedCapacity(2 * self.base.comp.link_inputs.len + 2);
+            try argv.ensureUnusedCapacity(5 * self.base.comp.link_inputs.len + 2);
             argv.appendAssumeCapacity("--as-needed");
             var as_needed = true;
 
@@ -2010,10 +2010,15 @@ 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 (fs.path.dirname(try dso.path.toString(arena))) |dir| {
+                        argv.appendAssumeCapacity("-L");
+                        argv.appendAssumeCapacity(dir);
+                    }
+                    const stem = dso.path.stem();
+                    assert(mem.startsWith(u8, stem, "lib"));
+                    argv.appendAssumeCapacity("-l");
+                    argv.appendAssumeCapacity(stem[3..]);
                 },
             };
 

test/link/elf.zig

@@ -82,6 +82,7 @@ pub fn testAll(b: *Build, build_opts: BuildOptions) *Step {
 
         // glibc tests
         elf_step.dependOn(testAsNeeded(b, .{ .target = gnu_target }));
+        elf_step.dependOn(testLibraryPathsCompatibility(b, .{ .target = gnu_target, .use_lld = true }));
         // https://github.com/ziglang/zig/issues/17430
         // elf_step.dependOn(testCanonicalPlt(b, .{ .target = gnu_target }));
         elf_step.dependOn(testCommentString(b, .{ .target = gnu_target }));
@@ -308,6 +309,54 @@ fn testAsNeeded(b: *Build, opts: Options) *Step {
     return test_step;
 }
 
+fn testLibraryPathsCompatibility(b: *Build, opts: Options) *Step {
+    const test_step = addTestStep(b, "library-paths-compatibility", opts);
+
+    const main_o = addObject(b, opts, .{
+        .name = "main",
+        .c_source_bytes =
+        \\#include <stdio.h>
+        \\int foo();
+        \\int main() {
+        \\  printf("%d\n", foo());
+        \\  return 0;
+        \\}
+        \\
+        ,
+    });
+    main_o.linkLibC();
+
+    const libfoo = addSharedLibrary(b, opts, .{ .name = "foo", .omit_soname = true });
+    addCSourceBytes(libfoo, "int foo() { return 42; }", &.{});
+
+    {
+        const scripts = WriteFile.create(b);
+        const path = scripts.addCopyFile(libfoo.getEmittedBin(), "foo/libfoo.so");
+
+        const exe = addExecutable(b, opts, .{ .name = "test" });
+        exe.addObject(main_o);
+
+        exe.setCwd(scripts.getDirectory());
+        exe.addLibraryPathSpecial("foo");
+        exe.addRPath(path.dirname());
+
+        exe.linkSystemLibrary2("foo", .{ .needed = false });
+        exe.linkLibC();
+
+        const run = addRunArtifact(exe);
+        run.expectStdOutEqual("42\n");
+        test_step.dependOn(&run.step);
+
+        const check = exe.checkObject();
+        check.checkInDynamicSection();
+        check.checkExact("NEEDED libfoo.so");
+        check.checkNotPresent("NEEDED foo/libfoo.so");
+        test_step.dependOn(&check.step);
+    }
+
+    return test_step;
+}
+
 fn testCanonicalPlt(b: *Build, opts: Options) *Step {
     const test_step = addTestStep(b, "canonical-plt", opts);
 

test/link/link.zig

@@ -44,6 +44,7 @@ const OverlayOptions = struct {
     zig_source_bytes: ?[]const u8 = null,
     pic: ?bool = null,
     strip: ?bool = null,
+    omit_soname: ?bool = null,
 };
 
 pub fn addExecutable(b: *std.Build, base: Options, overlay: OverlayOptions) *Compile {
@@ -97,6 +98,7 @@ fn createModule(b: *Build, base: Options, overlay: OverlayOptions) *Build.Module
         },
         .pic = overlay.pic,
         .strip = if (base.strip) |s| s else overlay.strip,
+        .omit_soname = overlay.omit_soname,
     });
 
     if (overlay.objcpp_source_bytes) |bytes| {