Allow setting library paths directly for compile steps

`LibraryPath` is implemented by analogy with `RPath`.

We need this to add a test case to `test/link/elf.zig` for checking
`-l`/`-L` behavior compatibility with Clang/GCC for ELF.

Author: a-khabarov

lib/std/Build/Module.zig

@@ -16,7 +16,7 @@ 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),
@@ -41,6 +41,11 @@ link_libcpp: ?bool,
 /// Symbols to be exported when compiling to WebAssembly.
 export_symbol_names: []const []const u8 = &.{},
 
+pub const LibraryPath = union(enum) {
+    lazy_path: LazyPath,
+    special: []const u8,
+};
+
 pub const RPath = union(enum) {
     lazy_path: LazyPath,
     special: []const u8,
@@ -274,7 +279,10 @@ pub fn addImport(m: *Module, name: []const u8, module: *Module) void {
 /// dependencies on `m`'s `depending_steps`.
 fn addShallowDependencies(m: *Module, dependee: *Module) void {
     if (dependee.root_source_file) |lazy_path| addLazyPathDependencies(m, dependee, lazy_path);
-    for (dependee.lib_paths.items) |lib_path| addLazyPathDependencies(m, dependee, lib_path);
+    for (dependee.lib_paths.items) |lib_path| switch (lib_path) {
+        .lazy_path => |lp| addLazyPathDependencies(m, dependee, lp),
+        .special => {},
+    };
     for (dependee.rpaths.items) |rpath| switch (rpath) {
         .lazy_path => |lp| addLazyPathDependencies(m, dependee, lp),
         .special => {},
@@ -603,10 +611,15 @@ 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");
     addLazyPathDependenciesOnly(m, directory_path);
 }
 
+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 {
     const b = m.owner;
     m.rpaths.append(b.allocator, .{ .lazy_path = directory_path.dupe(b) }) catch @panic("OOM");
@@ -725,10 +738,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/Compile.zig

@@ -924,10 +924,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);
 }