authorgravatar for kubkon@jakubkonka.comJakub Konka <kubkon@jakubkonka.com> 2023-10-24 12:12:46+02:00
committergravatar for kubkon@jakubkonka.comJakub Konka <kubkon@jakubkonka.com> 2023-10-24 19:03:00+02:00
log8087ec8e8c9e3abf8cf2f3952127aa97749610a5
tree2d9302cc45c2dc8dde46fd5241902c3f72e4ab57
parent2f3add4f301fb0fd6f72fb6d00a39342a2255c29

elf: improve parsing of ld scripts and actually test linking against them

6 files changed, 78 insertions(+), 167 deletions(-)

src/link/Elf.zig+33-56
...@@ -1353,10 +1353,8 @@ pub fn flushModule(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node...@@ -1353,10 +1353,8 @@ pub fn flushModule(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node
1353 }1353 }
13541354
1355 for (positionals.items) |obj| {1355 for (positionals.items) |obj| {
1356 const in_file = try std.fs.cwd().openFile(obj.path, .{});
1357 defer in_file.close();
1358 var parse_ctx: ParseErrorCtx = .{ .detected_cpu_arch = undefined };1356 var parse_ctx: ParseErrorCtx = .{ .detected_cpu_arch = undefined };
1359 self.parsePositional(in_file, obj.path, obj.must_link, &parse_ctx) catch |err|1357 self.parsePositional(obj.path, obj.must_link, &parse_ctx) catch |err|
1360 try self.handleAndReportParseError(obj.path, err, &parse_ctx);1358 try self.handleAndReportParseError(obj.path, err, &parse_ctx);
1361 }1359 }
13621360
...@@ -1437,9 +1435,7 @@ pub fn flushModule(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node...@@ -1437,9 +1435,7 @@ pub fn flushModule(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node
14371435
1438 for (system_libs.items) |lib| {1436 for (system_libs.items) |lib| {
1439 var parse_ctx: ParseErrorCtx = .{ .detected_cpu_arch = undefined };1437 var parse_ctx: ParseErrorCtx = .{ .detected_cpu_arch = undefined };
1440 const in_file = try std.fs.cwd().openFile(lib.path, .{});1438 self.parseLibrary(lib, false, &parse_ctx) catch |err|
1441 defer in_file.close();
1442 self.parseLibrary(in_file, lib, false, &parse_ctx) catch |err|
1443 try self.handleAndReportParseError(lib.path, err, &parse_ctx);1439 try self.handleAndReportParseError(lib.path, err, &parse_ctx);
1444 }1440 }
14451441
...@@ -1456,10 +1452,8 @@ pub fn flushModule(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node...@@ -1456,10 +1452,8 @@ pub fn flushModule(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node
1456 if (csu.crtn) |v| try positionals.append(.{ .path = v });1452 if (csu.crtn) |v| try positionals.append(.{ .path = v });
14571453
1458 for (positionals.items) |obj| {1454 for (positionals.items) |obj| {
1459 const in_file = try std.fs.cwd().openFile(obj.path, .{});
1460 defer in_file.close();
1461 var parse_ctx: ParseErrorCtx = .{ .detected_cpu_arch = undefined };1455 var parse_ctx: ParseErrorCtx = .{ .detected_cpu_arch = undefined };
1462 self.parsePositional(in_file, obj.path, obj.must_link, &parse_ctx) catch |err|1456 self.parsePositional(obj.path, obj.must_link, &parse_ctx) catch |err|
1463 try self.handleAndReportParseError(obj.path, err, &parse_ctx);1457 try self.handleAndReportParseError(obj.path, err, &parse_ctx);
1464 }1458 }
14651459
...@@ -1679,51 +1673,40 @@ const ParseError = error{...@@ -1679,51 +1673,40 @@ const ParseError = error{
1679 InvalidCharacter,1673 InvalidCharacter,
1680} || LdScript.Error || std.os.AccessError || std.os.SeekError || std.fs.File.OpenError || std.fs.File.ReadError;1674} || LdScript.Error || std.os.AccessError || std.os.SeekError || std.fs.File.OpenError || std.fs.File.ReadError;
16811675
1682fn parsePositional(1676fn parsePositional(self: *Elf, path: []const u8, must_link: bool, ctx: *ParseErrorCtx) ParseError!void {
1683 self: *Elf,
1684 in_file: std.fs.File,
1685 path: []const u8,
1686 must_link: bool,
1687 ctx: *ParseErrorCtx,
1688) ParseError!void {
1689 const tracy = trace(@src());1677 const tracy = trace(@src());
1690 defer tracy.end();1678 defer tracy.end();
16911679 if (try Object.isObject(path)) {
1692 if (Object.isObject(in_file)) {1680 try self.parseObject(path, ctx);
1693 try self.parseObject(in_file, path, ctx);
1694 } else {1681 } else {
1695 try self.parseLibrary(in_file, .{ .path = path }, must_link, ctx);1682 try self.parseLibrary(.{ .path = path }, must_link, ctx);
1696 }1683 }
1697}1684}
16981685
1699fn parseLibrary(1686fn parseLibrary(self: *Elf, lib: SystemLib, must_link: bool, ctx: *ParseErrorCtx) ParseError!void {
1700 self: *Elf,
1701 in_file: std.fs.File,
1702 lib: SystemLib,
1703 must_link: bool,
1704 ctx: *ParseErrorCtx,
1705) ParseError!void {
1706 const tracy = trace(@src());1687 const tracy = trace(@src());
1707 defer tracy.end();1688 defer tracy.end();
17081689
1709 if (Archive.isArchive(in_file)) {1690 if (try Archive.isArchive(lib.path)) {
1710 try self.parseArchive(in_file, lib.path, must_link, ctx);1691 try self.parseArchive(lib.path, must_link, ctx);
1711 } else if (SharedObject.isSharedObject(in_file)) {1692 } else if (try SharedObject.isSharedObject(lib.path)) {
1712 try self.parseSharedObject(in_file, lib, ctx);1693 try self.parseSharedObject(lib, ctx);
1713 } else {1694 } else {
1714 // TODO if the script has a top-level comment identifying it as GNU ld script,1695 // TODO if the script has a top-level comment identifying it as GNU ld script,
1715 // then report parse errors. Otherwise return UnknownFileType.1696 // then report parse errors. Otherwise return UnknownFileType.
1716 self.parseLdScript(in_file, lib, ctx) catch |err| switch (err) {1697 self.parseLdScript(lib, ctx) catch |err| switch (err) {
1717 else => return error.UnknownFileType,1698 else => return error.UnknownFileType,
1718 };1699 };
1719 }1700 }
1720}1701}
17211702
1722fn parseObject(self: *Elf, in_file: std.fs.File, path: []const u8, ctx: *ParseErrorCtx) ParseError!void {1703fn parseObject(self: *Elf, path: []const u8, ctx: *ParseErrorCtx) ParseError!void {
1723 const tracy = trace(@src());1704 const tracy = trace(@src());
1724 defer tracy.end();1705 defer tracy.end();
17251706
1726 const gpa = self.base.allocator;1707 const gpa = self.base.allocator;
1708 const in_file = try std.fs.cwd().openFile(path, .{});
1709 defer in_file.close();
1727 const data = try in_file.readToEndAlloc(gpa, std.math.maxInt(u32));1710 const data = try in_file.readToEndAlloc(gpa, std.math.maxInt(u32));
1728 const index = @as(File.Index, @intCast(try self.files.addOne(gpa)));1711 const index = @as(File.Index, @intCast(try self.files.addOne(gpa)));
1729 self.files.set(index, .{ .object = .{1712 self.files.set(index, .{ .object = .{
...@@ -1740,17 +1723,13 @@ fn parseObject(self: *Elf, in_file: std.fs.File, path: []const u8, ctx: *ParseEr...@@ -1740,17 +1723,13 @@ fn parseObject(self: *Elf, in_file: std.fs.File, path: []const u8, ctx: *ParseEr
1740 if (ctx.detected_cpu_arch != self.base.options.target.cpu.arch) return error.InvalidCpuArch;1723 if (ctx.detected_cpu_arch != self.base.options.target.cpu.arch) return error.InvalidCpuArch;
1741}1724}
17421725
1743fn parseArchive(1726fn parseArchive(self: *Elf, path: []const u8, must_link: bool, ctx: *ParseErrorCtx) ParseError!void {
1744 self: *Elf,
1745 in_file: std.fs.File,
1746 path: []const u8,
1747 must_link: bool,
1748 ctx: *ParseErrorCtx,
1749) ParseError!void {
1750 const tracy = trace(@src());1727 const tracy = trace(@src());
1751 defer tracy.end();1728 defer tracy.end();
17521729
1753 const gpa = self.base.allocator;1730 const gpa = self.base.allocator;
1731 const in_file = try std.fs.cwd().openFile(path, .{});
1732 defer in_file.close();
1754 const data = try in_file.readToEndAlloc(gpa, std.math.maxInt(u32));1733 const data = try in_file.readToEndAlloc(gpa, std.math.maxInt(u32));
1755 var archive = Archive{ .path = try gpa.dupe(u8, path), .data = data };1734 var archive = Archive{ .path = try gpa.dupe(u8, path), .data = data };
1756 defer archive.deinit(gpa);1735 defer archive.deinit(gpa);
...@@ -1773,16 +1752,13 @@ fn parseArchive(...@@ -1773,16 +1752,13 @@ fn parseArchive(
1773 }1752 }
1774}1753}
17751754
1776fn parseSharedObject(1755fn parseSharedObject(self: *Elf, lib: SystemLib, ctx: *ParseErrorCtx) ParseError!void {
1777 self: *Elf,
1778 in_file: std.fs.File,
1779 lib: SystemLib,
1780 ctx: *ParseErrorCtx,
1781) ParseError!void {
1782 const tracy = trace(@src());1756 const tracy = trace(@src());
1783 defer tracy.end();1757 defer tracy.end();
17841758
1785 const gpa = self.base.allocator;1759 const gpa = self.base.allocator;
1760 const in_file = try std.fs.cwd().openFile(lib.path, .{});
1761 defer in_file.close();
1786 const data = try in_file.readToEndAlloc(gpa, std.math.maxInt(u32));1762 const data = try in_file.readToEndAlloc(gpa, std.math.maxInt(u32));
1787 const index = @as(File.Index, @intCast(try self.files.addOne(gpa)));1763 const index = @as(File.Index, @intCast(try self.files.addOne(gpa)));
1788 self.files.set(index, .{ .shared_object = .{1764 self.files.set(index, .{ .shared_object = .{
...@@ -1801,11 +1777,13 @@ fn parseSharedObject(...@@ -1801,11 +1777,13 @@ fn parseSharedObject(
1801 if (ctx.detected_cpu_arch != self.base.options.target.cpu.arch) return error.InvalidCpuArch;1777 if (ctx.detected_cpu_arch != self.base.options.target.cpu.arch) return error.InvalidCpuArch;
1802}1778}
18031779
1804fn parseLdScript(self: *Elf, in_file: std.fs.File, lib: SystemLib, ctx: *ParseErrorCtx) ParseError!void {1780fn parseLdScript(self: *Elf, lib: SystemLib, ctx: *ParseErrorCtx) ParseError!void {
1805 const tracy = trace(@src());1781 const tracy = trace(@src());
1806 defer tracy.end();1782 defer tracy.end();
18071783
1808 const gpa = self.base.allocator;1784 const gpa = self.base.allocator;
1785 const in_file = try std.fs.cwd().openFile(lib.path, .{});
1786 defer in_file.close();
1809 const data = try in_file.readToEndAlloc(gpa, std.math.maxInt(u32));1787 const data = try in_file.readToEndAlloc(gpa, std.math.maxInt(u32));
1810 defer gpa.free(data);1788 defer gpa.free(data);
18111789
...@@ -1871,11 +1849,8 @@ fn parseLdScript(self: *Elf, in_file: std.fs.File, lib: SystemLib, ctx: *ParseEr...@@ -1871,11 +1849,8 @@ fn parseLdScript(self: *Elf, in_file: std.fs.File, lib: SystemLib, ctx: *ParseEr
1871 }1849 }
18721850
1873 const full_path = test_path.items;1851 const full_path = test_path.items;
1874 const scr_file = try std.fs.cwd().openFile(full_path, .{});
1875 defer scr_file.close();
1876
1877 var scr_ctx: ParseErrorCtx = .{ .detected_cpu_arch = undefined };1852 var scr_ctx: ParseErrorCtx = .{ .detected_cpu_arch = undefined };
1878 self.parseLibrary(scr_file, .{1853 self.parseLibrary(.{
1879 .needed = scr_obj.needed,1854 .needed = scr_obj.needed,
1880 .path = full_path,1855 .path = full_path,
1881 }, false, &scr_ctx) catch |err| try self.handleAndReportParseError(full_path, err, &scr_ctx);1856 }, false, &scr_ctx) catch |err| try self.handleAndReportParseError(full_path, err, &scr_ctx);
...@@ -1893,14 +1868,16 @@ fn accessLibPath(...@@ -1893,14 +1868,16 @@ fn accessLibPath(
1893 const sep = fs.path.sep_str;1868 const sep = fs.path.sep_str;
1894 const target = self.base.options.target;1869 const target = self.base.options.target;
1895 test_path.clearRetainingCapacity();1870 test_path.clearRetainingCapacity();
1871 const prefix = if (link_mode != null) "lib" else "";
1872 const suffix = if (link_mode) |mode| switch (mode) {
1873 .Static => target.staticLibSuffix(),
1874 .Dynamic => target.dynamicLibSuffix(),
1875 } else "";
1896 try test_path.writer().print("{s}" ++ sep ++ "{s}{s}{s}", .{1876 try test_path.writer().print("{s}" ++ sep ++ "{s}{s}{s}", .{
1897 lib_dir_path,1877 lib_dir_path,
1898 target.libPrefix(),1878 prefix,
1899 lib_name,1879 lib_name,
1900 if (link_mode) |mode| switch (mode) {1880 suffix,
1901 .Static => target.staticLibSuffix(),
1902 .Dynamic => target.dynamicLibSuffix(),
1903 } else "",
1904 });1881 });
1905 if (checked_paths) |cpaths| {1882 if (checked_paths) |cpaths| {
1906 try cpaths.append(try self.base.allocator.dupe(u8, test_path.items));1883 try cpaths.append(try self.base.allocator.dupe(u8, test_path.items));
src/link/Elf/Archive.zig+3-2
...@@ -62,10 +62,11 @@ const ar_hdr = extern struct {...@@ -62,10 +62,11 @@ const ar_hdr = extern struct {
62 }62 }
63};63};
6464
65pub fn isArchive(file: std.fs.File) bool {65pub fn isArchive(path: []const u8) !bool {
66 const file = try std.fs.cwd().openFile(path, .{});
67 defer file.close();
66 const reader = file.reader();68 const reader = file.reader();
67 const magic = reader.readBytesNoEof(Archive.SARMAG) catch return false;69 const magic = reader.readBytesNoEof(Archive.SARMAG) catch return false;
68 defer file.seekTo(0) catch {};
69 if (!mem.eql(u8, &magic, ARMAG)) return false;70 if (!mem.eql(u8, &magic, ARMAG)) return false;
70 return true;71 return true;
71}72}
src/link/Elf/LdScript.zig+3-105
...@@ -83,7 +83,8 @@ fn doParse(scr: *LdScript, ctx: struct {...@@ -83,7 +83,8 @@ fn doParse(scr: *LdScript, ctx: struct {
83 const cmd = ctx.parser.getCommand(cmd_id);83 const cmd = ctx.parser.getCommand(cmd_id);
84 switch (cmd) {84 switch (cmd) {
85 .output_format => scr.cpu_arch = try ctx.parser.outputFormat(),85 .output_format => scr.cpu_arch = try ctx.parser.outputFormat(),
86 .group => try ctx.parser.group(ctx.args),86 // TODO we should verify that group only contains libraries
87 .input, .group => try ctx.parser.group(ctx.args),
87 else => return error.UnexpectedToken,88 else => return error.UnexpectedToken,
88 }89 }
89 } else break;90 } else break;
...@@ -102,6 +103,7 @@ const LineColumn = struct {...@@ -102,6 +103,7 @@ const LineColumn = struct {
102103
103const Command = enum {104const Command = enum {
104 output_format,105 output_format,
106 input,
105 group,107 group,
106 as_needed,108 as_needed,
107109
...@@ -420,110 +422,6 @@ const TokenIterator = struct {...@@ -420,110 +422,6 @@ const TokenIterator = struct {
420 }422 }
421};423};
422424
423const testing = std.testing;
424
425fn testExpectedTokens(input: []const u8, expected: []const Token.Id) !void {
426 var given = std.ArrayList(Token.Id).init(testing.allocator);
427 defer given.deinit();
428
429 var tokenizer = Tokenizer{ .source = input };
430 while (true) {
431 const tok = tokenizer.next();
432 if (tok.id == .invalid) {
433 std.debug.print(" {s} => '{s}'\n", .{ @tagName(tok.id), tok.get(input) });
434 }
435 try given.append(tok.id);
436 if (tok.id == .eof) break;
437 }
438
439 try testing.expectEqualSlices(Token.Id, expected, given.items);
440}
441
442test "Tokenizer - just comments" {
443 try testExpectedTokens(
444 \\/* GNU ld script
445 \\ Use the shared library, but some functions are only in
446 \\ the static library, so try that secondarily. */
447 , &.{ .comment, .eof });
448}
449
450test "Tokenizer - comments with a simple command" {
451 try testExpectedTokens(
452 \\/* GNU ld script
453 \\ Use the shared library, but some functions are only in
454 \\ the static library, so try that secondarily. */
455 \\OUTPUT_FORMAT(elf64-x86-64)
456 , &.{ .comment, .new_line, .command, .lparen, .literal, .rparen, .eof });
457}
458
459test "Tokenizer - libc.so" {
460 try testExpectedTokens(
461 \\/* GNU ld script
462 \\ Use the shared library, but some functions are only in
463 \\ the static library, so try that secondarily. */
464 \\OUTPUT_FORMAT(elf64-x86-64)
465 \\GROUP ( /a/b/c.so.6 /a/d/e.a AS_NEEDED ( /f/g/h.so.2 ) )
466 , &.{
467 .comment, .new_line, // GNU comment
468 .command, .lparen, .literal, .rparen, .new_line, // output format
469 .command, .lparen, .literal, .literal, // group start
470 .command, .lparen, .literal, .rparen, // as needed
471 .rparen, // group end
472 .eof,
473 });
474}
475
476test "Parser - output format" {
477 const source =
478 \\OUTPUT_FORMAT(elf64-x86-64)
479 ;
480 var tokenizer = Tokenizer{ .source = source };
481 var tokens = std.ArrayList(Token).init(testing.allocator);
482 defer tokens.deinit();
483 while (true) {
484 const tok = tokenizer.next();
485 try testing.expect(tok.id != .invalid);
486 try tokens.append(tok);
487 if (tok.id == .eof) break;
488 }
489 var it = TokenIterator{ .tokens = tokens.items };
490 var parser = Parser{ .source = source, .it = &it };
491 const tok_id = try parser.require(.command);
492 try testing.expectEqual(parser.getCommand(tok_id), .output_format);
493 const cpu_arch = try parser.outputFormat();
494 try testing.expectEqual(cpu_arch, .x86_64);
495}
496
497test "Parser - group with as-needed" {
498 const source =
499 \\GROUP ( /a/b/c.so.6 /a/d/e.a AS_NEEDED ( /f/g/h.so.2 ) )
500 ;
501 var tokenizer = Tokenizer{ .source = source };
502 var tokens = std.ArrayList(Token).init(testing.allocator);
503 defer tokens.deinit();
504 while (true) {
505 const tok = tokenizer.next();
506 try testing.expect(tok.id != .invalid);
507 try tokens.append(tok);
508 if (tok.id == .eof) break;
509 }
510 var it = TokenIterator{ .tokens = tokens.items };
511 var parser = Parser{ .source = source, .it = &it };
512
513 var args = std.ArrayList(Elf.LinkObject).init(testing.allocator);
514 defer args.deinit();
515 const tok_id = try parser.require(.command);
516 try testing.expectEqual(parser.getCommand(tok_id), .group);
517 try parser.group(&args);
518
519 try testing.expectEqualStrings("/a/b/c.so.6", args.items[0].path);
520 try testing.expect(args.items[0].needed);
521 try testing.expectEqualStrings("/a/d/e.a", args.items[1].path);
522 try testing.expect(args.items[1].needed);
523 try testing.expectEqualStrings("/f/g/h.so.2", args.items[2].path);
524 try testing.expect(!args.items[2].needed);
525}
526
527const LdScript = @This();425const LdScript = @This();
528426
529const std = @import("std");427const std = @import("std");
src/link/Elf/Object.zig+3-2
...@@ -22,10 +22,11 @@ num_dynrelocs: u32 = 0,...@@ -22,10 +22,11 @@ num_dynrelocs: u32 = 0,
2222
23output_symtab_size: Elf.SymtabSize = .{},23output_symtab_size: Elf.SymtabSize = .{},
2424
25pub fn isObject(file: std.fs.File) bool {25pub fn isObject(path: []const u8) !bool {
26 const file = try std.fs.cwd().openFile(path, .{});
27 defer file.close();
26 const reader = file.reader();28 const reader = file.reader();
27 const header = reader.readStruct(elf.Elf64_Ehdr) catch return false;29 const header = reader.readStruct(elf.Elf64_Ehdr) catch return false;
28 defer file.seekTo(0) catch {};
29 if (!mem.eql(u8, header.e_ident[0..4], "\x7fELF")) return false;30 if (!mem.eql(u8, header.e_ident[0..4], "\x7fELF")) return false;
30 if (header.e_ident[elf.EI_VERSION] != 1) return false;31 if (header.e_ident[elf.EI_VERSION] != 1) return false;
31 if (header.e_type != elf.ET.REL) return false;32 if (header.e_type != elf.ET.REL) return false;
src/link/Elf/SharedObject.zig+3-2
...@@ -22,10 +22,11 @@ alive: bool,...@@ -22,10 +22,11 @@ alive: bool,
2222
23output_symtab_size: Elf.SymtabSize = .{},23output_symtab_size: Elf.SymtabSize = .{},
2424
25pub fn isSharedObject(file: std.fs.File) bool {25pub fn isSharedObject(path: []const u8) !bool {
26 const file = try std.fs.cwd().openFile(path, .{});
27 defer file.close();
26 const reader = file.reader();28 const reader = file.reader();
27 const header = reader.readStruct(elf.Elf64_Ehdr) catch return false;29 const header = reader.readStruct(elf.Elf64_Ehdr) catch return false;
28 defer file.seekTo(0) catch {};
29 if (!mem.eql(u8, header.e_ident[0..4], "\x7fELF")) return false;30 if (!mem.eql(u8, header.e_ident[0..4], "\x7fELF")) return false;
30 if (header.e_ident[elf.EI_VERSION] != 1) return false;31 if (header.e_ident[elf.EI_VERSION] != 1) return false;
31 if (header.e_type != elf.ET.DYN) return false;32 if (header.e_type != elf.ET.DYN) return false;
test/link/elf.zig+33
...@@ -75,6 +75,7 @@ pub fn build(b: *Build) void {...@@ -75,6 +75,7 @@ pub fn build(b: *Build) void {
75 elf_step.dependOn(testLargeAlignmentExe(b, .{ .target = glibc_target }));75 elf_step.dependOn(testLargeAlignmentExe(b, .{ .target = glibc_target }));
76 elf_step.dependOn(testLargeBss(b, .{ .target = glibc_target }));76 elf_step.dependOn(testLargeBss(b, .{ .target = glibc_target }));
77 elf_step.dependOn(testLinkOrder(b, .{ .target = glibc_target }));77 elf_step.dependOn(testLinkOrder(b, .{ .target = glibc_target }));
78 elf_step.dependOn(testLdScript(b, .{ .target = glibc_target }));
78 // https://github.com/ziglang/zig/issues/1745179 // https://github.com/ziglang/zig/issues/17451
79 // elf_step.dependOn(testNoEhFrameHdr(b, .{ .target = glibc_target }));80 // elf_step.dependOn(testNoEhFrameHdr(b, .{ .target = glibc_target }));
80 elf_step.dependOn(testPie(b, .{ .target = glibc_target }));81 elf_step.dependOn(testPie(b, .{ .target = glibc_target }));
...@@ -1568,6 +1569,38 @@ fn testLinkOrder(b: *Build, opts: Options) *Step {...@@ -1568,6 +1569,38 @@ fn testLinkOrder(b: *Build, opts: Options) *Step {
1568 return test_step;1569 return test_step;
1569}1570}
15701571
1572fn testLdScript(b: *Build, opts: Options) *Step {
1573 const test_step = addTestStep(b, "ld-script", opts);
1574
1575 const dso = addSharedLibrary(b, "bar", opts);
1576 addCSourceBytes(dso, "int foo() { return 42; }", &.{});
1577
1578 const scripts = WriteFile.create(b);
1579 _ = scripts.add("liba.so", "INPUT(libfoo.so)");
1580 _ = scripts.add("libfoo.so", "GROUP(AS_NEEDED(-lbar))");
1581
1582 const exe = addExecutable(b, "main", opts);
1583 addCSourceBytes(exe,
1584 \\int foo();
1585 \\int main() {
1586 \\ return foo() - 42;
1587 \\}
1588 , &.{});
1589 exe.linkSystemLibrary2("a", .{});
1590 exe.addLibraryPath(scripts.getDirectory());
1591 exe.addLibraryPath(dso.getEmittedBinDirectory());
1592 exe.addRPath(dso.getEmittedBinDirectory());
1593 exe.linkLibC();
1594 // https://github.com/ziglang/zig/issues/17619
1595 exe.pie = true;
1596
1597 const run = addRunArtifact(exe);
1598 run.expectExitCode(0);
1599 test_step.dependOn(&run.step);
1600
1601 return test_step;
1602}
1603
1571fn testLinkingC(b: *Build, opts: Options) *Step {1604fn testLinkingC(b: *Build, opts: Options) *Step {
1572 const test_step = addTestStep(b, "linking-c", opts);1605 const test_step = addTestStep(b, "linking-c", opts);
15731606