authorgravatar for kubkon@jakubkonka.comJakub Konka <kubkon@jakubkonka.com> 2023-04-01 11:51:05+02:00
committergravatar for kubkon@jakubkonka.comJakub Konka <kubkon@jakubkonka.com> 2023-04-01 14:22:44+02:00
loga88c0b4d089d286e36351cf476c8d982fb730541
treea4d985e8a6bd7f7b36b66f24e21e1ff53ff5303a
parent2dd178443abcbd91a923c64a4fd066caef974a82

link: handle -u flag in all linkers

Also clean up parsing of linker args - reuse `ArgsIterator`. In MachO, ensure we add every symbol marked with `-u` as undefined before proceeding with symbol resolution. Additionally, ensure those symbols are never garbage collected. MachO entry_in_dylib test: pass `-u _my_main` when linking executable so that it is not incorrectly garbage collected by the linker.

12 files changed, 185 insertions(+), 246 deletions(-)

lib/std/Build/CompileStep.zig+19
......@@ -202,6 +202,11 @@ subsystem: ?std.Target.SubSystem = null,
202202
203203entry_symbol_name: ?[]const u8 = null,
204204
205/// List of symbols forced as undefined in the symbol table
206/// thus forcing their resolution by the linker.
207/// Corresponds to `-u <symbol>` for ELF/MachO and `/include:<symbol>` for COFF/PE.
208force_undefined_symbols: std.StringHashMap(void),
209
205210/// Overrides the default stack size
206211stack_size: ?u64 = null,
207212
......@@ -386,6 +391,7 @@ pub fn create(owner: *std.Build, options: Options) *CompileStep {
386391 .override_dest_dir = null,
387392 .installed_path = null,
388393 .install_step = null,
394 .force_undefined_symbols = StringHashMap(void).init(owner.allocator),
389395
390396 .output_path_source = GeneratedFile{ .step = &self.step },
391397 .output_lib_path_source = GeneratedFile{ .step = &self.step },
......@@ -568,6 +574,11 @@ pub fn setLinkerScriptPath(self: *CompileStep, source: FileSource) void {
568574 source.addStepDependencies(&self.step);
569575}
570576
577pub fn forceUndefinedSymbol(self: *CompileStep, symbol_name: []const u8) void {
578 const b = self.step.owner;
579 self.force_undefined_symbols.put(b.dupe(symbol_name), {}) catch @panic("OOM");
580}
581
571582pub fn linkFramework(self: *CompileStep, framework_name: []const u8) void {
572583 const b = self.step.owner;
573584 self.frameworks.put(b.dupe(framework_name), .{}) catch @panic("OOM");
......@@ -1266,6 +1277,14 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
12661277 try zig_args.append(entry);
12671278 }
12681279
1280 {
1281 var it = self.force_undefined_symbols.keyIterator();
1282 while (it.next()) |symbol_name| {
1283 try zig_args.append("--force_undefined");
1284 try zig_args.append(symbol_name.*);
1285 }
1286 }
1287
12691288 if (self.stack_size) |stack_size| {
12701289 try zig_args.append("--stack");
12711290 try zig_args.append(try std.fmt.allocPrint(b.allocator, "{}", .{stack_size}));
src/Compilation.zig+4-3
......@@ -602,6 +602,7 @@ pub const InitOptions = struct {
602602 parent_compilation_link_libc: bool = false,
603603 hash_style: link.HashStyle = .both,
604604 entry: ?[]const u8 = null,
605 force_undefined_symbols: std.StringArrayHashMapUnmanaged(void) = .{},
605606 stack_size_override: ?u64 = null,
606607 image_base_override: ?u64 = null,
607608 self_exe_path: ?[]const u8 = null,
......@@ -1523,7 +1524,7 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
15231524 .headerpad_size = options.headerpad_size,
15241525 .headerpad_max_install_names = options.headerpad_max_install_names,
15251526 .dead_strip_dylibs = options.dead_strip_dylibs,
1526 .force_undefined_symbols = .{},
1527 .force_undefined_symbols = options.force_undefined_symbols,
15271528 .pdb_source_path = options.pdb_source_path,
15281529 .pdb_out_path = options.pdb_out_path,
15291530 });
......@@ -2186,7 +2187,7 @@ fn prepareWholeEmitSubPath(arena: Allocator, opt_emit: ?EmitLoc) error{OutOfMemo
21862187/// to remind the programmer to update multiple related pieces of code that
21872188/// are in different locations. Bump this number when adding or deleting
21882189/// anything from the link cache manifest.
2189pub const link_hash_implementation_version = 7;
2190pub const link_hash_implementation_version = 8;
21902191
21912192fn addNonIncrementalStuffToCacheManifest(comp: *Compilation, man: *Cache.Manifest) !void {
21922193 const gpa = comp.gpa;
......@@ -2196,7 +2197,7 @@ fn addNonIncrementalStuffToCacheManifest(comp: *Compilation, man: *Cache.Manifes
21962197 defer arena_allocator.deinit();
21972198 const arena = arena_allocator.allocator();
21982199
2199 comptime assert(link_hash_implementation_version == 7);
2200 comptime assert(link_hash_implementation_version == 8);
22002201
22012202 if (comp.bin_file.options.module) |mod| {
22022203 const main_zig_file = try mod.main_pkg.root_src_directory.join(arena, &[_][]const u8{
src/clang_options_data.zig+9-2
......@@ -1448,7 +1448,7 @@ flagpsl("MT"),
14481448.{
14491449 .name = "u",
14501450 .syntax = .flag,
1451 .zig_equivalent = .other,
1451 .zig_equivalent = .force_undefined_symbol,
14521452 .pd1 = true,
14531453 .pd2 = false,
14541454 .psl = true,
......@@ -7170,7 +7170,14 @@ joinpd1("d"),
71707170 .pd2 = false,
71717171 .psl = true,
71727172},
7173jspd1("u"),
7173.{
7174 .name = "u",
7175 .syntax = .joined_or_separate,
7176 .zig_equivalent = .force_undefined_symbol,
7177 .pd1 = true,
7178 .pd2 = false,
7179 .psl = false,
7180},
71747181.{
71757182 .name = "x",
71767183 .syntax = .joined_or_separate,
src/link.zig+1-2
......@@ -186,8 +186,7 @@ pub const Options = struct {
186186
187187 /// List of symbols forced as undefined in the symbol table
188188 /// thus forcing their resolution by the linker.
189 /// Corresponds to `-u <symbol>` for ELF and `/include:<symbol>` for COFF/PE.
190 /// TODO add handling for MachO.
189 /// Corresponds to `-u <symbol>` for ELF/MachO and `/include:<symbol>` for COFF/PE.
191190 force_undefined_symbols: std.StringArrayHashMapUnmanaged(void),
192191
193192 version: ?std.builtin.Version,
src/link/Coff/lld.zig+1-1
......@@ -63,7 +63,7 @@ pub fn linkWithLLD(self: *Coff, comp: *Compilation, prog_node: *std.Progress.Nod
6363 man = comp.cache_parent.obtain();
6464 self.base.releaseLock();
6565
66 comptime assert(Compilation.link_hash_implementation_version == 7);
66 comptime assert(Compilation.link_hash_implementation_version == 8);
6767
6868 for (self.base.options.objects) |obj| {
6969 _ = try man.addFile(obj.path, null);
src/link/Elf.zig+1-1
......@@ -1305,7 +1305,7 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
13051305 // We are about to obtain this lock, so here we give other processes a chance first.
13061306 self.base.releaseLock();
13071307
1308 comptime assert(Compilation.link_hash_implementation_version == 7);
1308 comptime assert(Compilation.link_hash_implementation_version == 8);
13091309
13101310 try man.addOptionalFile(self.base.options.linker_script);
13111311 try man.addOptionalFile(self.base.options.version_script);
src/link/MachO/dead_strip.zig+30-22
......@@ -12,6 +12,7 @@ const Allocator = mem.Allocator;
1212const AtomIndex = @import("zld.zig").AtomIndex;
1313const Atom = @import("ZldAtom.zig");
1414const SymbolWithLoc = @import("zld.zig").SymbolWithLoc;
15const SymbolResolver = @import("zld.zig").SymbolResolver;
1516const UnwindInfo = @import("UnwindInfo.zig");
1617const Zld = @import("zld.zig").Zld;
1718
......@@ -19,7 +20,7 @@ const N_DEAD = @import("zld.zig").N_DEAD;
1920
2021const AtomTable = std.AutoHashMap(AtomIndex, void);
2122
22pub fn gcAtoms(zld: *Zld) !void {
23pub fn gcAtoms(zld: *Zld, resolver: *const SymbolResolver) !void {
2324 const gpa = zld.gpa;
2425
2526 var arena = std.heap.ArenaAllocator.init(gpa);
......@@ -31,12 +32,25 @@ pub fn gcAtoms(zld: *Zld) !void {
3132 var alive = AtomTable.init(arena.allocator());
3233 try alive.ensureTotalCapacity(@intCast(u32, zld.atoms.items.len));
3334
34 try collectRoots(zld, &roots);
35 try collectRoots(zld, &roots, resolver);
3536 try mark(zld, roots, &alive);
3637 prune(zld, alive);
3738}
3839
39fn collectRoots(zld: *Zld, roots: *AtomTable) !void {
40fn addRoot(zld: *Zld, roots: *AtomTable, file: u32, sym_loc: SymbolWithLoc) !void {
41 const sym = zld.getSymbol(sym_loc);
42 assert(!sym.undf());
43 const object = &zld.objects.items[file];
44 const atom_index = object.getAtomIndexForSymbol(sym_loc.sym_index).?; // panic here means fatal error
45 log.debug("root(ATOM({d}, %{d}, {d}))", .{
46 atom_index,
47 zld.getAtom(atom_index).sym_index,
48 file,
49 });
50 _ = try roots.getOrPut(atom_index);
51}
52
53fn collectRoots(zld: *Zld, roots: *AtomTable, resolver: *const SymbolResolver) !void {
4054 log.debug("collecting roots", .{});
4155
4256 switch (zld.options.output_mode) {
......@@ -44,15 +58,7 @@ fn collectRoots(zld: *Zld, roots: *AtomTable) !void {
4458 // Add entrypoint as GC root
4559 const global: SymbolWithLoc = zld.getEntryPoint();
4660 if (global.getFile()) |file| {
47 const object = zld.objects.items[file];
48 const atom_index = object.getAtomIndexForSymbol(global.sym_index).?; // panic here means fatal error
49 _ = try roots.getOrPut(atom_index);
50
51 log.debug("root(ATOM({d}, %{d}, {?d}))", .{
52 atom_index,
53 zld.getAtom(atom_index).sym_index,
54 zld.getAtom(atom_index).getFile(),
55 });
61 try addRoot(zld, roots, file, global);
5662 } else {
5763 assert(zld.getSymbol(global).undf()); // Stub as our entrypoint is in a dylib.
5864 }
......@@ -64,20 +70,22 @@ fn collectRoots(zld: *Zld, roots: *AtomTable) !void {
6470 const sym = zld.getSymbol(global);
6571 if (sym.undf()) continue;
6672
67 const file = global.getFile() orelse continue; // synthetic globals are atomless
68 const object = zld.objects.items[file];
69 const atom_index = object.getAtomIndexForSymbol(global.sym_index).?; // panic here means fatal error
70 _ = try roots.getOrPut(atom_index);
71
72 log.debug("root(ATOM({d}, %{d}, {?d}))", .{
73 atom_index,
74 zld.getAtom(atom_index).sym_index,
75 zld.getAtom(atom_index).getFile(),
76 });
73 if (global.getFile()) |file| {
74 try addRoot(zld, roots, file, global);
75 }
7776 }
7877 },
7978 }
8079
80 // Add all symbols force-defined by the user.
81 for (zld.options.force_undefined_symbols.keys()) |sym_name| {
82 const global_index = resolver.table.get(sym_name).?;
83 const global = zld.globals.items[global_index];
84 const sym = zld.getSymbol(global);
85 assert(!sym.undf());
86 try addRoot(zld, roots, global.getFile().?, global);
87 }
88
8189 for (zld.objects.items) |object| {
8290 const has_subsections = object.header.flags & macho.MH_SUBSECTIONS_VIA_SYMBOLS != 0;
8391
src/link/MachO/zld.zig+21-11
......@@ -932,20 +932,29 @@ pub const Zld = struct {
932932 }
933933 }
934934
935 fn forceSymbolDefined(self: *Zld, name: []const u8, resolver: *SymbolResolver) !void {
936 const sym_index = try self.allocateSymbol();
937 const sym_loc = SymbolWithLoc{ .sym_index = sym_index };
938 const sym = self.getSymbolPtr(sym_loc);
939 sym.n_strx = try self.strtab.insert(self.gpa, name);
940 sym.n_type = macho.N_UNDF | macho.N_EXT;
941 const global_index = try self.addGlobal(sym_loc);
942 try resolver.table.putNoClobber(name, global_index);
943 try resolver.unresolved.putNoClobber(global_index, {});
944 }
945
935946 fn resolveSymbols(self: *Zld, resolver: *SymbolResolver) !void {
936947 // We add the specified entrypoint as the first unresolved symbols so that
937948 // we search for it in libraries should there be no object files specified
938949 // on the linker line.
939950 if (self.options.output_mode == .Exe) {
940951 const entry_name = self.options.entry orelse load_commands.default_entry_point;
941 const sym_index = try self.allocateSymbol();
942 const sym_loc = SymbolWithLoc{ .sym_index = sym_index };
943 const sym = self.getSymbolPtr(sym_loc);
944 sym.n_strx = try self.strtab.insert(self.gpa, entry_name);
945 sym.n_type = macho.N_UNDF | macho.N_EXT;
946 const global_index = try self.addGlobal(sym_loc);
947 try resolver.table.putNoClobber(entry_name, global_index);
948 try resolver.unresolved.putNoClobber(global_index, {});
952 try self.forceSymbolDefined(entry_name, resolver);
953 }
954
955 // Force resolution of any symbols requested by the user.
956 for (self.options.force_undefined_symbols.keys()) |sym_name| {
957 try self.forceSymbolDefined(sym_name, resolver);
949958 }
950959
951960 for (self.objects.items, 0..) |_, object_id| {
......@@ -3539,7 +3548,7 @@ pub const SymbolWithLoc = extern struct {
35393548 }
35403549};
35413550
3542const SymbolResolver = struct {
3551pub const SymbolResolver = struct {
35433552 arena: Allocator,
35443553 table: std.StringHashMap(u32),
35453554 unresolved: std.AutoArrayHashMap(u32, void),
......@@ -3600,7 +3609,7 @@ pub fn linkWithZld(macho_file: *MachO, comp: *Compilation, prog_node: *std.Progr
36003609 // We are about to obtain this lock, so here we give other processes a chance first.
36013610 macho_file.base.releaseLock();
36023611
3603 comptime assert(Compilation.link_hash_implementation_version == 7);
3612 comptime assert(Compilation.link_hash_implementation_version == 8);
36043613
36053614 for (options.objects) |obj| {
36063615 _ = try man.addFile(obj.path, null);
......@@ -3630,6 +3639,7 @@ pub fn linkWithZld(macho_file: *MachO, comp: *Compilation, prog_node: *std.Progr
36303639 }
36313640 link.hashAddSystemLibs(&man.hash, options.system_libs);
36323641 man.hash.addOptionalBytes(options.sysroot);
3642 man.hash.addListOfBytes(options.force_undefined_symbols.keys());
36333643 try man.addOptionalFile(options.entitlements);
36343644
36353645 // We don't actually care whether it's a cache hit or miss; we just
......@@ -4035,7 +4045,7 @@ pub fn linkWithZld(macho_file: *MachO, comp: *Compilation, prog_node: *std.Progr
40354045 }
40364046
40374047 if (gc_sections) {
4038 try dead_strip.gcAtoms(&zld);
4048 try dead_strip.gcAtoms(&zld, &resolver);
40394049 }
40404050
40414051 try zld.createDyldPrivateAtom();
src/link/Wasm.zig+2-2
......@@ -3059,7 +3059,7 @@ fn linkWithZld(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) l
30593059 // We are about to obtain this lock, so here we give other processes a chance first.
30603060 wasm.base.releaseLock();
30613061
3062 comptime assert(Compilation.link_hash_implementation_version == 7);
3062 comptime assert(Compilation.link_hash_implementation_version == 8);
30633063
30643064 for (options.objects) |obj| {
30653065 _ = try man.addFile(obj.path, null);
......@@ -4086,7 +4086,7 @@ fn linkWithLLD(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) !
40864086 // We are about to obtain this lock, so here we give other processes a chance first.
40874087 wasm.base.releaseLock();
40884088
4089 comptime assert(Compilation.link_hash_implementation_version == 7);
4089 comptime assert(Compilation.link_hash_implementation_version == 8);
40904090
40914091 for (wasm.base.options.objects) |obj| {
40924092 _ = try man.addFile(obj.path, null);
src/main.zig+92-202
......@@ -478,6 +478,7 @@ const usage_build_generic =
478478 \\ --sysroot [path] Set the system root directory (usually /)
479479 \\ --version [ver] Dynamic library semver
480480 \\ --entry [name] Set the entrypoint symbol name
481 \\ --force_undefined [name] Specify the symbol must be defined for the link to succeed
481482 \\ -fsoname[=name] Override the default SONAME value
482483 \\ -fno-soname Disable emitting a SONAME
483484 \\ -fLLD Force using LLD as the linker
......@@ -680,6 +681,28 @@ const Listen = union(enum) {
680681 stdio,
681682};
682683
684const ArgsIterator = struct {
685 resp_file: ?ArgIteratorResponseFile = null,
686 args: []const []const u8,
687 i: usize = 0,
688 fn next(it: *@This()) ?[]const u8 {
689 if (it.i >= it.args.len) {
690 if (it.resp_file) |*resp| return resp.next();
691 return null;
692 }
693 defer it.i += 1;
694 return it.args[it.i];
695 }
696 fn nextOrFatal(it: *@This()) []const u8 {
697 if (it.i >= it.args.len) {
698 if (it.resp_file) |*resp| if (resp.next()) |ret| return ret;
699 fatal("expected parameter after {s}", .{it.args[it.i - 1]});
700 }
701 defer it.i += 1;
702 return it.args[it.i];
703 }
704};
705
683706fn buildOutputType(
684707 gpa: Allocator,
685708 arena: Allocator,
......@@ -784,6 +807,7 @@ fn buildOutputType(
784807 var test_evented_io = false;
785808 var test_no_exec = false;
786809 var entry: ?[]const u8 = null;
810 var force_undefined_symbols: std.StringArrayHashMapUnmanaged(void) = .{};
787811 var stack_size_override: ?u64 = null;
788812 var image_base_override: ?u64 = null;
789813 var use_llvm: ?bool = null;
......@@ -917,28 +941,7 @@ fn buildOutputType(
917941
918942 soname = .yes_default_value;
919943
920 const Iterator = struct {
921 resp_file: ?ArgIteratorResponseFile = null,
922 args: []const []const u8,
923 i: usize = 0,
924 fn next(it: *@This()) ?[]const u8 {
925 if (it.i >= it.args.len) {
926 if (it.resp_file) |*resp| return resp.next();
927 return null;
928 }
929 defer it.i += 1;
930 return it.args[it.i];
931 }
932 fn nextOrFatal(it: *@This()) []const u8 {
933 if (it.i >= it.args.len) {
934 if (it.resp_file) |*resp| if (resp.next()) |ret| return ret;
935 fatal("expected parameter after {s}", .{it.args[it.i - 1]});
936 }
937 defer it.i += 1;
938 return it.args[it.i];
939 }
940 };
941 var args_iter = Iterator{
944 var args_iter = ArgsIterator{
942945 .args = all_args[2..],
943946 };
944947
......@@ -1029,6 +1032,8 @@ fn buildOutputType(
10291032 optimize_mode_string = args_iter.nextOrFatal();
10301033 } else if (mem.eql(u8, arg, "--entry")) {
10311034 entry = args_iter.nextOrFatal();
1035 } else if (mem.eql(u8, arg, "--force_undefined")) {
1036 try force_undefined_symbols.put(gpa, args_iter.nextOrFatal(), {});
10321037 } else if (mem.eql(u8, arg, "--stack")) {
10331038 const next_arg = args_iter.nextOrFatal();
10341039 stack_size_override = std.fmt.parseUnsigned(u64, next_arg, 0) catch |err| {
......@@ -1816,6 +1821,9 @@ fn buildOutputType(
18161821 .entry => {
18171822 entry = it.only_arg;
18181823 },
1824 .force_undefined_symbol => {
1825 try force_undefined_symbols.put(gpa, it.only_arg, {});
1826 },
18191827 .weak_library => try system_libs.put(it.only_arg, .{ .weak = true }),
18201828 .weak_framework => try frameworks.put(gpa, it.only_arg, .{ .weak = true }),
18211829 .headerpad_max_install_names => headerpad_max_install_names = true,
......@@ -1843,17 +1851,14 @@ fn buildOutputType(
18431851 }
18441852 }
18451853 // Parse linker args.
1846 var i: usize = 0;
1847 while (i < linker_args.items.len) : (i += 1) {
1848 const arg = linker_args.items[i];
1854 var linker_args_it = ArgsIterator{
1855 .args = linker_args.items,
1856 };
1857 while (linker_args_it.next()) |arg| {
18491858 if (mem.eql(u8, arg, "-soname") or
18501859 mem.eql(u8, arg, "--soname"))
18511860 {
1852 i += 1;
1853 if (i >= linker_args.items.len) {
1854 fatal("expected linker arg after '{s}'", .{arg});
1855 }
1856 const name = linker_args.items[i];
1861 const name = linker_args_it.nextOrFatal();
18571862 soname = .{ .yes = name };
18581863 // Use it as --name.
18591864 // Example: libsoundio.so.2
......@@ -1881,64 +1886,37 @@ fn buildOutputType(
18811886 }
18821887 provided_name = name[prefix..end];
18831888 } else if (mem.eql(u8, arg, "-rpath")) {
1884 i += 1;
1885 if (i >= linker_args.items.len) {
1886 fatal("expected linker arg after '{s}'", .{arg});
1887 }
1888 try rpath_list.append(linker_args.items[i]);
1889 try rpath_list.append(linker_args_it.nextOrFatal());
18891890 } else if (mem.eql(u8, arg, "--subsystem")) {
1890 i += 1;
1891 if (i >= linker_args.items.len) {
1892 fatal("expected linker arg after '{s}'", .{arg});
1893 }
1894 subsystem = try parseSubSystem(linker_args.items[i]);
1891 subsystem = try parseSubSystem(linker_args_it.nextOrFatal());
18951892 } else if (mem.eql(u8, arg, "-I") or
18961893 mem.eql(u8, arg, "--dynamic-linker") or
18971894 mem.eql(u8, arg, "-dynamic-linker"))
18981895 {
1899 i += 1;
1900 if (i >= linker_args.items.len) {
1901 fatal("expected linker arg after '{s}'", .{arg});
1902 }
1903 target_dynamic_linker = linker_args.items[i];
1896 target_dynamic_linker = linker_args_it.nextOrFatal();
19041897 } else if (mem.eql(u8, arg, "-E") or
19051898 mem.eql(u8, arg, "--export-dynamic") or
19061899 mem.eql(u8, arg, "-export-dynamic"))
19071900 {
19081901 rdynamic = true;
19091902 } else if (mem.eql(u8, arg, "--version-script")) {
1910 i += 1;
1911 if (i >= linker_args.items.len) {
1912 fatal("expected linker arg after '{s}'", .{arg});
1913 }
1914 version_script = linker_args.items[i];
1903 version_script = linker_args_it.nextOrFatal();
19151904 } else if (mem.eql(u8, arg, "-O")) {
1916 i += 1;
1917 if (i >= linker_args.items.len) {
1918 fatal("expected linker arg after '{s}'", .{arg});
1919 }
1920 linker_optimization = std.fmt.parseUnsigned(u8, linker_args.items[i], 10) catch |err| {
1921 fatal("unable to parse optimization level '{s}': {s}", .{ linker_args.items[i], @errorName(err) });
1905 const opt = linker_args_it.nextOrFatal();
1906 linker_optimization = std.fmt.parseUnsigned(u8, opt, 10) catch |err| {
1907 fatal("unable to parse optimization level '{s}': {s}", .{ opt, @errorName(err) });
19221908 };
19231909 } else if (mem.startsWith(u8, arg, "-O")) {
19241910 linker_optimization = std.fmt.parseUnsigned(u8, arg["-O".len..], 10) catch |err| {
19251911 fatal("unable to parse optimization level '{s}': {s}", .{ arg, @errorName(err) });
19261912 };
19271913 } else if (mem.eql(u8, arg, "-pagezero_size")) {
1928 i += 1;
1929 if (i >= linker_args.items.len) {
1930 fatal("expected linker arg after '{s}'", .{arg});
1931 }
1932 const next_arg = linker_args.items[i];
1914 const next_arg = linker_args_it.nextOrFatal();
19331915 pagezero_size = std.fmt.parseUnsigned(u64, eatIntPrefix(next_arg, 16), 16) catch |err| {
19341916 fatal("unable to parse pagezero size '{s}': {s}", .{ next_arg, @errorName(err) });
19351917 };
19361918 } else if (mem.eql(u8, arg, "-headerpad")) {
1937 i += 1;
1938 if (i >= linker_args.items.len) {
1939 fatal("expected linker arg after '{s}'", .{arg});
1940 }
1941 const next_arg = linker_args.items[i];
1919 const next_arg = linker_args_it.nextOrFatal();
19421920 headerpad_size = std.fmt.parseUnsigned(u32, eatIntPrefix(next_arg, 16), 16) catch |err| {
19431921 fatal("unable to parse headerpad size '{s}': {s}", .{ next_arg, @errorName(err) });
19441922 };
......@@ -1961,11 +1939,7 @@ fn buildOutputType(
19611939 } else if (mem.eql(u8, arg, "--print-map")) {
19621940 linker_print_map = true;
19631941 } else if (mem.eql(u8, arg, "--sort-section")) {
1964 i += 1;
1965 if (i >= linker_args.items.len) {
1966 fatal("expected linker arg after '{s}'", .{arg});
1967 }
1968 const arg1 = linker_args.items[i];
1942 const arg1 = linker_args_it.nextOrFatal();
19691943 linker_sort_section = std.meta.stringToEnum(link.SortSection, arg1) orelse {
19701944 fatal("expected [name|alignment] after --sort-section, found '{s}'", .{arg1});
19711945 };
......@@ -1998,28 +1972,16 @@ fn buildOutputType(
19981972 } else if (mem.startsWith(u8, arg, "--export=")) {
19991973 try linker_export_symbol_names.append(arg["--export=".len..]);
20001974 } else if (mem.eql(u8, arg, "--export")) {
2001 i += 1;
2002 if (i >= linker_args.items.len) {
2003 fatal("expected linker arg after '{s}'", .{arg});
2004 }
2005 try linker_export_symbol_names.append(linker_args.items[i]);
1975 try linker_export_symbol_names.append(linker_args_it.nextOrFatal());
20061976 } else if (mem.eql(u8, arg, "--compress-debug-sections")) {
2007 i += 1;
2008 if (i >= linker_args.items.len) {
2009 fatal("expected linker arg after '{s}'", .{arg});
2010 }
2011 const arg1 = linker_args.items[i];
1977 const arg1 = linker_args_it.nextOrFatal();
20121978 linker_compress_debug_sections = std.meta.stringToEnum(link.CompressDebugSections, arg1) orelse {
20131979 fatal("expected [none|zlib] after --compress-debug-sections, found '{s}'", .{arg1});
20141980 };
20151981 } else if (mem.startsWith(u8, arg, "-z")) {
20161982 var z_arg = arg[2..];
20171983 if (z_arg.len == 0) {
2018 i += 1;
2019 if (i >= linker_args.items.len) {
2020 fatal("expected linker extension flag after '{s}'", .{arg});
2021 }
2022 z_arg = linker_args.items[i];
1984 z_arg = linker_args_it.nextOrFatal();
20231985 }
20241986 if (mem.eql(u8, z_arg, "nodelete")) {
20251987 linker_z_nodelete = true;
......@@ -2056,51 +2018,33 @@ fn buildOutputType(
20562018 fatal("unsupported linker extension flag: -z {s}", .{z_arg});
20572019 }
20582020 } else if (mem.eql(u8, arg, "--major-image-version")) {
2059 i += 1;
2060 if (i >= linker_args.items.len) {
2061 fatal("expected linker arg after '{s}'", .{arg});
2062 }
2063 version.major = std.fmt.parseUnsigned(u32, linker_args.items[i], 10) catch |err| {
2064 fatal("unable to parse major image version '{s}': {s}", .{ linker_args.items[i], @errorName(err) });
2021 const major = linker_args_it.nextOrFatal();
2022 version.major = std.fmt.parseUnsigned(u32, major, 10) catch |err| {
2023 fatal("unable to parse major image version '{s}': {s}", .{ major, @errorName(err) });
20652024 };
20662025 have_version = true;
20672026 } else if (mem.eql(u8, arg, "--minor-image-version")) {
2068 i += 1;
2069 if (i >= linker_args.items.len) {
2070 fatal("expected linker arg after '{s}'", .{arg});
2071 }
2072 version.minor = std.fmt.parseUnsigned(u32, linker_args.items[i], 10) catch |err| {
2073 fatal("unable to parse minor image version '{s}': {s}", .{ linker_args.items[i], @errorName(err) });
2027 const minor = linker_args_it.nextOrFatal();
2028 version.minor = std.fmt.parseUnsigned(u32, minor, 10) catch |err| {
2029 fatal("unable to parse minor image version '{s}': {s}", .{ minor, @errorName(err) });
20742030 };
20752031 have_version = true;
20762032 } else if (mem.eql(u8, arg, "-e") or mem.eql(u8, arg, "--entry")) {
2077 i += 1;
2078 if (i >= linker_args.items.len) {
2079 fatal("expected linker arg after '{s}'", .{arg});
2080 }
2081 entry = linker_args.items[i];
2033 entry = linker_args_it.nextOrFatal();
2034 } else if (mem.eql(u8, arg, "-u")) {
2035 try force_undefined_symbols.put(gpa, linker_args_it.nextOrFatal(), {});
20822036 } else if (mem.eql(u8, arg, "--stack") or mem.eql(u8, arg, "-stack_size")) {
2083 i += 1;
2084 if (i >= linker_args.items.len) {
2085 fatal("expected linker arg after '{s}'", .{arg});
2086 }
2087 stack_size_override = std.fmt.parseUnsigned(u64, linker_args.items[i], 0) catch |err| {
2088 fatal("unable to parse stack size override '{s}': {s}", .{ linker_args.items[i], @errorName(err) });
2037 const stack_size = linker_args_it.nextOrFatal();
2038 stack_size_override = std.fmt.parseUnsigned(u64, stack_size, 0) catch |err| {
2039 fatal("unable to parse stack size override '{s}': {s}", .{ stack_size, @errorName(err) });
20892040 };
20902041 } else if (mem.eql(u8, arg, "--image-base")) {
2091 i += 1;
2092 if (i >= linker_args.items.len) {
2093 fatal("expected linker arg after '{s}'", .{arg});
2094 }
2095 image_base_override = std.fmt.parseUnsigned(u64, linker_args.items[i], 0) catch |err| {
2096 fatal("unable to parse image base override '{s}': {s}", .{ linker_args.items[i], @errorName(err) });
2042 const image_base = linker_args_it.nextOrFatal();
2043 image_base_override = std.fmt.parseUnsigned(u64, image_base, 0) catch |err| {
2044 fatal("unable to parse image base override '{s}': {s}", .{ image_base, @errorName(err) });
20972045 };
20982046 } else if (mem.eql(u8, arg, "-T") or mem.eql(u8, arg, "--script")) {
2099 i += 1;
2100 if (i >= linker_args.items.len) {
2101 fatal("expected linker arg after '{s}'", .{arg});
2102 }
2103 linker_script = linker_args.items[i];
2047 linker_script = linker_args_it.nextOrFatal();
21042048 } else if (mem.eql(u8, arg, "--eh-frame-hdr")) {
21052049 link_eh_frame_hdr = true;
21062050 } else if (mem.eql(u8, arg, "--no-eh-frame-hdr")) {
......@@ -2138,130 +2082,74 @@ fn buildOutputType(
21382082 } else if (mem.eql(u8, arg, "--major-os-version") or
21392083 mem.eql(u8, arg, "--minor-os-version"))
21402084 {
2141 i += 1;
2142 if (i >= linker_args.items.len) {
2143 fatal("expected linker arg after '{s}'", .{arg});
2144 }
21452085 // This option does not do anything.
2086 _ = linker_args_it.nextOrFatal();
21462087 } else if (mem.eql(u8, arg, "--major-subsystem-version")) {
2147 i += 1;
2148 if (i >= linker_args.items.len) {
2149 fatal("expected linker arg after '{s}'", .{arg});
2150 }
2151
2088 const major = linker_args_it.nextOrFatal();
21522089 major_subsystem_version = std.fmt.parseUnsigned(
21532090 u32,
2154 linker_args.items[i],
2091 major,
21552092 10,
21562093 ) catch |err| {
2157 fatal("unable to parse major subsystem version '{s}': {s}", .{ linker_args.items[i], @errorName(err) });
2094 fatal("unable to parse major subsystem version '{s}': {s}", .{ major, @errorName(err) });
21582095 };
21592096 } else if (mem.eql(u8, arg, "--minor-subsystem-version")) {
2160 i += 1;
2161 if (i >= linker_args.items.len) {
2162 fatal("expected linker arg after '{s}'", .{arg});
2163 }
2164
2097 const minor = linker_args_it.nextOrFatal();
21652098 minor_subsystem_version = std.fmt.parseUnsigned(
21662099 u32,
2167 linker_args.items[i],
2100 minor,
21682101 10,
21692102 ) catch |err| {
2170 fatal("unable to parse minor subsystem version '{s}': {s}", .{ linker_args.items[i], @errorName(err) });
2103 fatal("unable to parse minor subsystem version '{s}': {s}", .{ minor, @errorName(err) });
21712104 };
21722105 } else if (mem.eql(u8, arg, "-framework")) {
2173 i += 1;
2174 if (i >= linker_args.items.len) {
2175 fatal("expected linker arg after '{s}'", .{arg});
2176 }
2177 try frameworks.put(gpa, linker_args.items[i], .{});
2106 try frameworks.put(gpa, linker_args_it.nextOrFatal(), .{});
21782107 } else if (mem.eql(u8, arg, "-weak_framework")) {
2179 i += 1;
2180 if (i >= linker_args.items.len) {
2181 fatal("expected linker arg after '{s}'", .{arg});
2182 }
2183 try frameworks.put(gpa, linker_args.items[i], .{ .weak = true });
2108 try frameworks.put(gpa, linker_args_it.nextOrFatal(), .{ .weak = true });
21842109 } else if (mem.eql(u8, arg, "-needed_framework")) {
2185 i += 1;
2186 if (i >= linker_args.items.len) {
2187 fatal("expected linker arg after '{s}'", .{arg});
2188 }
2189 try frameworks.put(gpa, linker_args.items[i], .{ .needed = true });
2110 try frameworks.put(gpa, linker_args_it.nextOrFatal(), .{ .needed = true });
21902111 } else if (mem.eql(u8, arg, "-needed_library")) {
2191 i += 1;
2192 if (i >= linker_args.items.len) {
2193 fatal("expected linker arg after '{s}'", .{arg});
2194 }
2195 try system_libs.put(linker_args.items[i], .{ .needed = true });
2112 try system_libs.put(linker_args_it.nextOrFatal(), .{ .needed = true });
21962113 } else if (mem.startsWith(u8, arg, "-weak-l")) {
21972114 try system_libs.put(arg["-weak-l".len..], .{ .weak = true });
21982115 } else if (mem.eql(u8, arg, "-weak_library")) {
2199 i += 1;
2200 if (i >= linker_args.items.len) {
2201 fatal("expected linker arg after '{s}'", .{arg});
2202 }
2203 try system_libs.put(linker_args.items[i], .{ .weak = true });
2116 try system_libs.put(linker_args_it.nextOrFatal(), .{ .weak = true });
22042117 } else if (mem.eql(u8, arg, "-compatibility_version")) {
2205 i += 1;
2206 if (i >= linker_args.items.len) {
2207 fatal("expected linker arg after '{s}'", .{arg});
2208 }
2209 compatibility_version = std.builtin.Version.parse(linker_args.items[i]) catch |err| {
2210 fatal("unable to parse -compatibility_version '{s}': {s}", .{ linker_args.items[i], @errorName(err) });
2118 const compat_version = linker_args_it.nextOrFatal();
2119 compatibility_version = std.builtin.Version.parse(compat_version) catch |err| {
2120 fatal("unable to parse -compatibility_version '{s}': {s}", .{ compat_version, @errorName(err) });
22112121 };
22122122 } else if (mem.eql(u8, arg, "-current_version")) {
2213 i += 1;
2214 if (i >= linker_args.items.len) {
2215 fatal("expected linker arg after '{s}'", .{arg});
2216 }
2217 version = std.builtin.Version.parse(linker_args.items[i]) catch |err| {
2218 fatal("unable to parse -current_version '{s}': {s}", .{ linker_args.items[i], @errorName(err) });
2123 const curr_version = linker_args_it.nextOrFatal();
2124 version = std.builtin.Version.parse(curr_version) catch |err| {
2125 fatal("unable to parse -current_version '{s}': {s}", .{ curr_version, @errorName(err) });
22192126 };
22202127 have_version = true;
22212128 } else if (mem.eql(u8, arg, "--out-implib") or
22222129 mem.eql(u8, arg, "-implib"))
22232130 {
2224 i += 1;
2225 if (i >= linker_args.items.len) {
2226 fatal("expected linker arg after '{s}'", .{arg});
2227 }
2228 emit_implib = .{ .yes = linker_args.items[i] };
2131 emit_implib = .{ .yes = linker_args_it.nextOrFatal() };
22292132 emit_implib_arg_provided = true;
22302133 } else if (mem.eql(u8, arg, "-undefined")) {
2231 i += 1;
2232 if (i >= linker_args.items.len) {
2233 fatal("expected linker arg after '{s}'", .{arg});
2234 }
2235 if (mem.eql(u8, "dynamic_lookup", linker_args.items[i])) {
2134 const lookup_type = linker_args_it.nextOrFatal();
2135 if (mem.eql(u8, "dynamic_lookup", lookup_type)) {
22362136 linker_allow_shlib_undefined = true;
2237 } else if (mem.eql(u8, "error", linker_args.items[i])) {
2137 } else if (mem.eql(u8, "error", lookup_type)) {
22382138 linker_allow_shlib_undefined = false;
22392139 } else {
2240 fatal("unsupported -undefined option '{s}'", .{linker_args.items[i]});
2140 fatal("unsupported -undefined option '{s}'", .{lookup_type});
22412141 }
22422142 } else if (mem.eql(u8, arg, "-install_name")) {
2243 i += 1;
2244 if (i >= linker_args.items.len) {
2245 fatal("expected linker arg after '{s}'", .{arg});
2246 }
2247 install_name = linker_args.items[i];
2143 install_name = linker_args_it.nextOrFatal();
22482144 } else if (mem.eql(u8, arg, "-force_load")) {
2249 i += 1;
2250 if (i >= linker_args.items.len) {
2251 fatal("expected linker arg after '{s}'", .{arg});
2252 }
22532145 try link_objects.append(.{
2254 .path = linker_args.items[i],
2146 .path = linker_args_it.nextOrFatal(),
22552147 .must_link = true,
22562148 });
22572149 } else if (mem.eql(u8, arg, "-hash-style") or
22582150 mem.eql(u8, arg, "--hash-style"))
22592151 {
2260 i += 1;
2261 if (i >= linker_args.items.len) {
2262 fatal("expected linker arg after '{s}'", .{arg});
2263 }
2264 const next_arg = linker_args.items[i];
2152 const next_arg = linker_args_it.nextOrFatal();
22652153 hash_style = std.meta.stringToEnum(link.HashStyle, next_arg) orelse {
22662154 fatal("expected [sysv|gnu|both] after --hash-style, found '{s}'", .{
22672155 next_arg,
......@@ -3219,6 +3107,7 @@ fn buildOutputType(
32193107 .link_eh_frame_hdr = link_eh_frame_hdr,
32203108 .link_emit_relocs = link_emit_relocs,
32213109 .entry = entry,
3110 .force_undefined_symbols = force_undefined_symbols,
32223111 .stack_size_override = stack_size_override,
32233112 .image_base_override = image_base_override,
32243113 .strip = strip,
......@@ -5295,6 +5184,7 @@ pub const ClangArgIterator = struct {
52955184 emit_llvm,
52965185 sysroot,
52975186 entry,
5187 force_undefined_symbol,
52985188 weak_library,
52995189 weak_framework,
53005190 headerpad_max_install_names,
test/link/macho/entry_in_dylib/build.zig+1
......@@ -31,6 +31,7 @@ fn add(b: *std.Build, test_step: *std.Build.Step, optimize: std.builtin.Optimize
3131 exe.linkLibrary(lib);
3232 exe.linkLibC();
3333 exe.entry_symbol_name = "_bootstrap";
34 exe.forceUndefinedSymbol("_my_main");
3435
3536 const check_exe = exe.checkObject();
3637 check_exe.checkStart("segname __TEXT");
tools/update_clang_options.zig+4
......@@ -468,6 +468,10 @@ const known_options = [_]KnownOpt{
468468 .name = "e",
469469 .ident = "entry",
470470 },
471 .{
472 .name = "u",
473 .ident = "force_undefined_symbol",
474 },
471475 .{
472476 .name = "weak-l",
473477 .ident = "weak_library",