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.zig` and `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;
@@ -243,6 +244,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,
@@ -942,10 +946,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);
 }
@@ -1697,7 +1709,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);
@@ -1795,9 +1807,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,
@@ -1880,8 +1894,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.?;
 }
 
@@ -2122,3 +2137,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.zig

@@ -1794,6 +1794,8 @@ pub const Input = union(enum) {
         needed: bool,
         weak: bool,
         reexport: bool,
+        name: ?[]const u8,
+        lib_directory: Directory,
     };
 
     pub const DsoExact = struct {
@@ -2121,7 +2123,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);
     }
 
     {
@@ -2135,10 +2137,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,
         }
@@ -2159,7 +2161,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
@@ -2175,7 +2177,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;
@@ -2187,6 +2189,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 = .{
@@ -2201,6 +2205,8 @@ fn finishResolveLibInput(
             .needed = query.needed,
             .weak = query.weak,
             .reexport = query.reexport,
+            .name = name,
+            .lib_directory = lib_directory,
         } }),
     }
     return .ok;
@@ -2220,8 +2226,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) });
@@ -2257,10 +2263,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);
 
@@ -2285,7 +2293,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) });
@@ -2351,7 +2359,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 {
@@ -2374,6 +2382,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(),
     };
 }