Commit 0789e91eeb08495c5084067df2b2dab410197364 | zig

author	Andrew Kelley <andrew@ziglang.org> 2023-12-12 16:25:28-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2024-01-01 17:51:19-07:00
log	0789e91eeb08495c5084067df2b2dab410197364
tree	bf5bdee3e86bf182abd95c98d6811a3f5beace99
parent	3b6cb257dfbcfe7217cdb00819615d1cf1e6b89c

linkers: update references to "options" field

22 files changed, 511 insertions(+), 429 deletions(-)

src
- Compilation.zig
- Compilation
  - Config.zig
- Sema.zig
- codegen
  - llvm.zig
- libtsan.zig
- link.zig
- link

src/Compilation.zig+50-41

src/Compilation/Config.zig+1-1

...	@@ -335,7 +335,7 @@ pub fn resolve(options: Options) !Config {	...	@@ -335,7 +335,7 @@ pub fn resolve(options: Options) !Config {
335	break :b .Static;	335	break :b .Static;
336	};	336	};
337		337
338	const import_memory = options.import_memory orelse false;	338	const import_memory = options.import_memory orelse (options.output_mode == .Obj);
339	const export_memory = b: {	339	const export_memory = b: {
340	if (link_mode == .Dynamic) {	340	if (link_mode == .Dynamic) {
341	if (options.export_memory == true) return error.ExportMemoryAndDynamicIncompatible;	341	if (options.export_memory == true) return error.ExportMemoryAndDynamicIncompatible;

src/Sema.zig+15-12

 @@ -5742,7 +5742,7 @@ fn zirCImport(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileEr
             const msg = try sema.errMsg(&child_block, src, "C import failed", .{});
             errdefer msg.destroy(gpa);
-            if (!comp.bin_file.options.link_libc)
+            if (!comp.config.link_libc)
                 try sema.errNote(&child_block, src, msg, "libc headers not available; compilation does not link against libc", .{});
             const gop = try mod.cimport_errors.getOrPut(gpa, sema.owner_decl_index);
 @@ -9058,7 +9058,7 @@ fn resolveGenericBody(
 /// Given a library name, examines if the library name should end up in
 /// `link.File.Options.system_libs` table (for example, libc is always
-/// specified via dedicated flag `link.File.Options.link_libc` instead),
+/// specified via dedicated flag `link_libc` instead),
 /// and puts it there if it doesn't exist.
 /// It also dupes the library name which can then be saved as part of the
 /// respective `Decl` (either `ExternFn` or `Var`).
 @@ -9076,7 +9076,7 @@ fn handleExternLibName(
         const target = mod.getTarget();
         log.debug("extern fn symbol expected in lib '{s}'", .{lib_name});
         if (target.is_libc_lib_name(lib_name)) {
-            if (!comp.bin_file.options.link_libc) {
+            if (!comp.config.link_libc) {
                 return sema.fail(
                     block,
                     src_loc,
 @@ -9087,18 +9087,21 @@ fn handleExternLibName(
             break :blk;
         }
         if (target.is_libcpp_lib_name(lib_name)) {
-            if (!comp.bin_file.options.link_libcpp) {
+            if (!comp.config.link_libcpp) return sema.fail(
-                return sema.fail(
+                block,
-                    block,
+                src_loc,
-                    src_loc,
+                "dependency on libc++ must be explicitly specified in the build command",
-                    "dependency on libc++ must be explicitly specified in the build command",
+                .{},
-                    .{},
+            );
-                );
-            }
             break :blk;
         }
         if (mem.eql(u8, lib_name, "unwind")) {
-            comp.bin_file.options.link_libunwind = true;
+            if (!comp.config.link_libunwind) return sema.fail(
+                block,
+                src_loc,
+                "dependency on libunwind must be explicitly specified in the build command",
+                .{},
+            );
             break :blk;
         }
         if (!target.isWasm() and !comp.bin_file.options.pic) {

src/codegen/llvm.zig+1-3

 @@ -3083,9 +3083,7 @@ pub const Object = struct {
         if (comp.unwind_tables) {
             try attributes.addFnAttr(.{ .uwtable = Builder.Attribute.UwTable.default }, &o.builder);
         }
-        if (comp.bin_file.options.skip_linker_dependencies or
+        if (comp.skip_linker_dependencies or comp.bin_file.options.no_builtin) {
-            comp.bin_file.options.no_builtin)
-        {
             // The intent here is for compiler-rt and libc functions to not generate
             // infinite recursion. For example, if we are compiling the memcpy function,
             // and llvm detects that the body is equivalent to memcpy, it may replace the

src/libtsan.zig+1-1

...	@@ -119,7 +119,7 @@ pub fn buildTsan(comp: Compilation, prog_node: std.Progress.Node) !void {	...	@@ -119,7 +119,7 @@ pub fn buildTsan(comp: Compilation, prog_node: std.Progress.Node) !void {
119	});	119	});
120	}	120	}
121		121
122	const to_c_or_not_to_c_sources = if (comp.bin_file.options.link_libc)	122	const to_c_or_not_to_c_sources = if (comp.config.link_libc)
123	&sanitizer_libcdep_sources	123	&sanitizer_libcdep_sources
124	else	124	else
125	&sanitizer_nolibc_sources;	125	&sanitizer_nolibc_sources;

src/link.zig+1-2

...	@@ -133,7 +133,6 @@ pub const File = struct {	...	@@ -133,7 +133,6 @@ pub const File = struct {
133	export_symbol_names: []const []const u8,	133	export_symbol_names: []const []const u8,
134	global_base: ?u64,	134	global_base: ?u64,
135	dll_export_fns: bool,	135	dll_export_fns: bool,
136	skip_linker_dependencies: bool,
137	parent_compilation_link_libc: bool,	136	parent_compilation_link_libc: bool,
138	each_lib_rpath: bool,	137	each_lib_rpath: bool,
139	build_id: std.zig.BuildId,	138	build_id: std.zig.BuildId,
...	@@ -1099,7 +1098,7 @@ pub const File = struct {	...	@@ -1099,7 +1098,7 @@ pub const File = struct {
1099	}	1098	}
1100		1099
1101	pub fn isStatic(self: File) bool {	1100	pub fn isStatic(self: File) bool {
1102	return self.base.comp.config.link_mode == .Static;	1101	return self.comp.config.link_mode == .Static;
1103	}	1102	}
1104		1103
1105	pub fn isObject(self: File) bool {	1104	pub fn isObject(self: File) bool {

src/link/Coff/lld.zig+47-47

...	@@ -48,7 +48,7 @@ pub fn linkWithLLD(self: Coff, comp: Compilation, prog_node: *std.Progress.Nod	...	@@ -48,7 +48,7 @@ pub fn linkWithLLD(self: Coff, comp: Compilation, prog_node: *std.Progress.Nod
48	const is_lib = self.base.comp.config.output_mode == .Lib;	48	const is_lib = self.base.comp.config.output_mode == .Lib;
49	const is_dyn_lib = self.base.comp.config.link_mode == .Dynamic and is_lib;	49	const is_dyn_lib = self.base.comp.config.link_mode == .Dynamic and is_lib;
50	const is_exe_or_dyn_lib = is_dyn_lib or self.base.comp.config.output_mode == .Exe;	50	const is_exe_or_dyn_lib = is_dyn_lib or self.base.comp.config.output_mode == .Exe;
51	const link_in_crt = self.base.options.link_libc and is_exe_or_dyn_lib;	51	const link_in_crt = comp.config.link_libc and is_exe_or_dyn_lib;
52	const target = self.base.comp.root_mod.resolved_target.result;	52	const target = self.base.comp.root_mod.resolved_target.result;
53	const optimize_mode = self.base.comp.root_mod.optimize_mode;	53	const optimize_mode = self.base.comp.root_mod.optimize_mode;
54		54
...	@@ -56,17 +56,17 @@ pub fn linkWithLLD(self: Coff, comp: Compilation, prog_node: *std.Progress.Nod	...	@@ -56,17 +56,17 @@ pub fn linkWithLLD(self: Coff, comp: Compilation, prog_node: *std.Progress.Nod
56	const id_symlink_basename = "lld.id";	56	const id_symlink_basename = "lld.id";
57		57
58	var man: Cache.Manifest = undefined;	58	var man: Cache.Manifest = undefined;
59	defer if (!self.base.options.disable_lld_caching) man.deinit();	59	defer if (!self.base.disable_lld_caching) man.deinit();
60		60
61	var digest: [Cache.hex_digest_len]u8 = undefined;	61	var digest: [Cache.hex_digest_len]u8 = undefined;
62		62
63	if (!self.base.options.disable_lld_caching) {	63	if (!self.base.disable_lld_caching) {
64	man = comp.cache_parent.obtain();	64	man = comp.cache_parent.obtain();
65	self.base.releaseLock();	65	self.base.releaseLock();
66		66
67	comptime assert(Compilation.link_hash_implementation_version == 10);	67	comptime assert(Compilation.link_hash_implementation_version == 10);
68		68
69	for (self.base.options.objects) \|obj\| {	69	for (comp.objects) \|obj\| {
70	_ = try man.addFile(obj.path, null);	70	_ = try man.addFile(obj.path, null);
71	man.hash.add(obj.must_link);	71	man.hash.add(obj.must_link);
72	}	72	}
...	@@ -79,12 +79,12 @@ pub fn linkWithLLD(self: Coff, comp: Compilation, prog_node: *std.Progress.Nod	...	@@ -79,12 +79,12 @@ pub fn linkWithLLD(self: Coff, comp: Compilation, prog_node: *std.Progress.Nod
79	}	79	}
80	}	80	}
81	try man.addOptionalFile(module_obj_path);	81	try man.addOptionalFile(module_obj_path);
82	man.hash.addOptionalBytes(self.base.options.entry);	82	man.hash.addOptionalBytes(comp.config.entry);
83	man.hash.add(self.base.stack_size);	83	man.hash.add(self.base.stack_size);
84	man.hash.addOptional(self.image_base);	84	man.hash.addOptional(self.image_base);
85	man.hash.addListOfBytes(self.base.options.lib_dirs);	85	man.hash.addListOfBytes(self.lib_dirs);
86	man.hash.add(self.base.options.skip_linker_dependencies);	86	man.hash.add(comp.skip_linker_dependencies);
87	if (self.base.options.link_libc) {	87	if (comp.config.link_libc) {
88	man.hash.add(self.base.comp.libc_installation != null);	88	man.hash.add(self.base.comp.libc_installation != null);
89	if (self.base.comp.libc_installation) \|libc_installation\| {	89	if (self.base.comp.libc_installation) \|libc_installation\| {
90	man.hash.addBytes(libc_installation.crt_dir.?);	90	man.hash.addBytes(libc_installation.crt_dir.?);
...	@@ -95,18 +95,18 @@ pub fn linkWithLLD(self: Coff, comp: Compilation, prog_node: *std.Progress.Nod	...	@@ -95,18 +95,18 @@ pub fn linkWithLLD(self: Coff, comp: Compilation, prog_node: *std.Progress.Nod
95	}	95	}
96	}	96	}
97	try link.hashAddSystemLibs(&man, self.base.comp.system_libs);	97	try link.hashAddSystemLibs(&man, self.base.comp.system_libs);
98	man.hash.addListOfBytes(self.base.options.force_undefined_symbols.keys());	98	man.hash.addListOfBytes(self.base.force_undefined_symbols.keys());
99	man.hash.addOptional(self.base.options.subsystem);	99	man.hash.addOptional(self.subsystem);
100	man.hash.add(self.base.options.is_test);	100	man.hash.add(comp.config.is_test);
101	man.hash.add(self.base.options.tsaware);	101	man.hash.add(self.tsaware);
102	man.hash.add(self.base.options.nxcompat);	102	man.hash.add(self.nxcompat);
103	man.hash.add(self.base.options.dynamicbase);	103	man.hash.add(self.dynamicbase);
104	man.hash.addOptional(self.base.allow_shlib_undefined);	104	man.hash.addOptional(self.base.allow_shlib_undefined);
105	// strip does not need to go into the linker hash because it is part of the hash namespace	105	// strip does not need to go into the linker hash because it is part of the hash namespace
106	man.hash.addOptional(self.base.options.major_subsystem_version);	106	man.hash.addOptional(self.major_subsystem_version);
107	man.hash.addOptional(self.base.options.minor_subsystem_version);	107	man.hash.addOptional(self.minor_subsystem_version);
108	man.hash.addOptional(self.base.options.version);	108	man.hash.addOptional(comp.version);
109	try man.addOptionalFile(self.base.options.module_definition_file);	109	try man.addOptionalFile(self.module_definition_file);
110		110
111	// We don't actually care whether it's a cache hit or miss; we just need the digest and the lock.	111	// We don't actually care whether it's a cache hit or miss; we just need the digest and the lock.
112	_ = try man.hit();	112	_ = try man.hit();
...	@@ -141,8 +141,8 @@ pub fn linkWithLLD(self: Coff, comp: Compilation, prog_node: *std.Progress.Nod	...	@@ -141,8 +141,8 @@ pub fn linkWithLLD(self: Coff, comp: Compilation, prog_node: *std.Progress.Nod
141	// here. TODO: think carefully about how we can avoid this redundant operation when doing	141	// here. TODO: think carefully about how we can avoid this redundant operation when doing
142	// build-obj. See also the corresponding TODO in linkAsArchive.	142	// build-obj. See also the corresponding TODO in linkAsArchive.
143	const the_object_path = blk: {	143	const the_object_path = blk: {
144	if (self.base.options.objects.len != 0)	144	if (comp.objects.len != 0)
145	break :blk self.base.options.objects[0].path;	145	break :blk comp.objects[0].path;
146		146
147	if (comp.c_object_table.count() != 0)	147	if (comp.c_object_table.count() != 0)
148	break :blk comp.c_object_table.keys()[0].status.success.object_path;	148	break :blk comp.c_object_table.keys()[0].status.success.object_path;
...	@@ -171,21 +171,21 @@ pub fn linkWithLLD(self: Coff, comp: Compilation, prog_node: *std.Progress.Nod	...	@@ -171,21 +171,21 @@ pub fn linkWithLLD(self: Coff, comp: Compilation, prog_node: *std.Progress.Nod
171		171
172	try argv.append("-ERRORLIMIT:0");	172	try argv.append("-ERRORLIMIT:0");
173	try argv.append("-NOLOGO");	173	try argv.append("-NOLOGO");
174	if (!self.base.options.strip) {	174	if (self.base.debug_format != .strip) {
175	try argv.append("-DEBUG");	175	try argv.append("-DEBUG");
176		176
177	const out_ext = std.fs.path.extension(full_out_path);	177	const out_ext = std.fs.path.extension(full_out_path);
178	const out_pdb = self.base.options.pdb_out_path orelse try allocPrint(arena, "{s}.pdb", .{	178	const out_pdb = self.pdb_out_path orelse try allocPrint(arena, "{s}.pdb", .{
179	full_out_path[0 .. full_out_path.len - out_ext.len],	179	full_out_path[0 .. full_out_path.len - out_ext.len],
180	});	180	});
181		181
182	try argv.append(try allocPrint(arena, "-PDB:{s}", .{out_pdb}));	182	try argv.append(try allocPrint(arena, "-PDB:{s}", .{out_pdb}));
183	try argv.append(try allocPrint(arena, "-PDBALTPATH:{s}", .{out_pdb}));	183	try argv.append(try allocPrint(arena, "-PDBALTPATH:{s}", .{out_pdb}));
184	}	184	}
185	if (self.base.options.version) \|version\| {	185	if (comp.version) \|version\| {
186	try argv.append(try allocPrint(arena, "-VERSION:{}.{}", .{ version.major, version.minor }));	186	try argv.append(try allocPrint(arena, "-VERSION:{}.{}", .{ version.major, version.minor }));
187	}	187	}
188	if (self.base.options.lto) {	188	if (comp.config.lto) {
189	switch (optimize_mode) {	189	switch (optimize_mode) {
190	.Debug => {},	190	.Debug => {},
191	.ReleaseSmall => try argv.append("-OPT:lldlto=2"),	191	.ReleaseSmall => try argv.append("-OPT:lldlto=2"),
...	@@ -209,7 +209,7 @@ pub fn linkWithLLD(self: Coff, comp: Compilation, prog_node: *std.Progress.Nod	...	@@ -209,7 +209,7 @@ pub fn linkWithLLD(self: Coff, comp: Compilation, prog_node: *std.Progress.Nod
209	}	209	}
210	}	210	}
211		211
212	for (self.base.options.force_undefined_symbols.keys()) \|symbol\| {	212	for (self.base.force_undefined_symbols.keys()) \|symbol\| {
213	try argv.append(try allocPrint(arena, "-INCLUDE:{s}", .{symbol}));	213	try argv.append(try allocPrint(arena, "-INCLUDE:{s}", .{symbol}));
214	}	214	}
215		215
...	@@ -217,17 +217,17 @@ pub fn linkWithLLD(self: Coff, comp: Compilation, prog_node: *std.Progress.Nod	...	@@ -217,17 +217,17 @@ pub fn linkWithLLD(self: Coff, comp: Compilation, prog_node: *std.Progress.Nod
217	try argv.append("-DLL");	217	try argv.append("-DLL");
218	}	218	}
219		219
220	if (self.base.options.entry) \|entry\| {	220	if (comp.config.entry) \|entry\| {
221	try argv.append(try allocPrint(arena, "-ENTRY:{s}", .{entry}));	221	try argv.append(try allocPrint(arena, "-ENTRY:{s}", .{entry}));
222	}	222	}
223		223
224	if (self.base.options.tsaware) {	224	if (self.tsaware) {
225	try argv.append("-tsaware");	225	try argv.append("-tsaware");
226	}	226	}
227	if (self.base.options.nxcompat) {	227	if (self.nxcompat) {
228	try argv.append("-nxcompat");	228	try argv.append("-nxcompat");
229	}	229	}
230	if (!self.base.options.dynamicbase) {	230	if (!self.dynamicbase) {
231	try argv.append("-dynamicbase:NO");	231	try argv.append("-dynamicbase:NO");
232	}	232	}
233	if (self.base.allow_shlib_undefined) {	233	if (self.base.allow_shlib_undefined) {
...	@@ -236,12 +236,12 @@ pub fn linkWithLLD(self: Coff, comp: Compilation, prog_node: *std.Progress.Nod	...	@@ -236,12 +236,12 @@ pub fn linkWithLLD(self: Coff, comp: Compilation, prog_node: *std.Progress.Nod
236		236
237	try argv.append(try allocPrint(arena, "-OUT:{s}", .{full_out_path}));	237	try argv.append(try allocPrint(arena, "-OUT:{s}", .{full_out_path}));
238		238
239	if (self.base.options.implib_emit) \|emit\| {	239	if (self.implib_emit) \|emit\| {
240	const implib_out_path = try emit.directory.join(arena, &[_][]const u8{emit.sub_path});	240	const implib_out_path = try emit.directory.join(arena, &[_][]const u8{emit.sub_path});
241	try argv.append(try allocPrint(arena, "-IMPLIB:{s}", .{implib_out_path}));	241	try argv.append(try allocPrint(arena, "-IMPLIB:{s}", .{implib_out_path}));
242	}	242	}
243		243
244	if (self.base.options.link_libc) {	244	if (comp.config.link_libc) {
245	if (self.base.comp.libc_installation) \|libc_installation\| {	245	if (self.base.comp.libc_installation) \|libc_installation\| {
246	try argv.append(try allocPrint(arena, "-LIBPATH:{s}", .{libc_installation.crt_dir.?}));	246	try argv.append(try allocPrint(arena, "-LIBPATH:{s}", .{libc_installation.crt_dir.?}));
247		247
...	@@ -252,12 +252,12 @@ pub fn linkWithLLD(self: Coff, comp: Compilation, prog_node: *std.Progress.Nod	...	@@ -252,12 +252,12 @@ pub fn linkWithLLD(self: Coff, comp: Compilation, prog_node: *std.Progress.Nod
252	}	252	}
253	}	253	}
254		254
255	for (self.base.options.lib_dirs) \|lib_dir\| {	255	for (self.lib_dirs) \|lib_dir\| {
256	try argv.append(try allocPrint(arena, "-LIBPATH:{s}", .{lib_dir}));	256	try argv.append(try allocPrint(arena, "-LIBPATH:{s}", .{lib_dir}));
257	}	257	}
258		258
259	try argv.ensureUnusedCapacity(self.base.options.objects.len);	259	try argv.ensureUnusedCapacity(comp.objects.len);
260	for (self.base.options.objects) \|obj\| {	260	for (comp.objects) \|obj\| {
261	if (obj.must_link) {	261	if (obj.must_link) {
262	argv.appendAssumeCapacity(try allocPrint(arena, "-WHOLEARCHIVE:{s}", .{obj.path}));	262	argv.appendAssumeCapacity(try allocPrint(arena, "-WHOLEARCHIVE:{s}", .{obj.path}));
263	} else {	263	} else {
...	@@ -279,18 +279,18 @@ pub fn linkWithLLD(self: Coff, comp: Compilation, prog_node: *std.Progress.Nod	...	@@ -279,18 +279,18 @@ pub fn linkWithLLD(self: Coff, comp: Compilation, prog_node: *std.Progress.Nod
279	try argv.append(p);	279	try argv.append(p);
280	}	280	}
281		281
282	if (self.base.options.module_definition_file) \|def\| {	282	if (self.module_definition_file) \|def\| {
283	try argv.append(try allocPrint(arena, "-DEF:{s}", .{def}));	283	try argv.append(try allocPrint(arena, "-DEF:{s}", .{def}));
284	}	284	}
285		285
286	const resolved_subsystem: ?std.Target.SubSystem = blk: {	286	const resolved_subsystem: ?std.Target.SubSystem = blk: {
287	if (self.base.options.subsystem) \|explicit\| break :blk explicit;	287	if (self.subsystem) \|explicit\| break :blk explicit;
288	switch (target.os.tag) {	288	switch (target.os.tag) {
289	.windows => {	289	.windows => {
290	if (self.base.comp.module) \|module\| {	290	if (self.base.comp.module) \|module\| {
291	if (module.stage1_flags.have_dllmain_crt_startup or is_dyn_lib)	291	if (module.stage1_flags.have_dllmain_crt_startup or is_dyn_lib)
292	break :blk null;	292	break :blk null;
293	if (module.stage1_flags.have_c_main or self.base.options.is_test or	293	if (module.stage1_flags.have_c_main or comp.config.is_test or
294	module.stage1_flags.have_winmain_crt_startup or	294	module.stage1_flags.have_winmain_crt_startup or
295	module.stage1_flags.have_wwinmain_crt_startup)	295	module.stage1_flags.have_wwinmain_crt_startup)
296	{	296	{
...	@@ -310,8 +310,8 @@ pub fn linkWithLLD(self: Coff, comp: Compilation, prog_node: *std.Progress.Nod	...	@@ -310,8 +310,8 @@ pub fn linkWithLLD(self: Coff, comp: Compilation, prog_node: *std.Progress.Nod
310	const mode: Mode = mode: {	310	const mode: Mode = mode: {
311	if (resolved_subsystem) \|subsystem\| {	311	if (resolved_subsystem) \|subsystem\| {
312	const subsystem_suffix = ss: {	312	const subsystem_suffix = ss: {
313	if (self.base.options.major_subsystem_version) \|major\| {	313	if (self.major_subsystem_version) \|major\| {
314	if (self.base.options.minor_subsystem_version) \|minor\| {	314	if (self.minor_subsystem_version) \|minor\| {
315	break :ss try allocPrint(arena, ",{d}.{d}", .{ major, minor });	315	break :ss try allocPrint(arena, ",{d}.{d}", .{ major, minor });
316	} else {	316	} else {
317	break :ss try allocPrint(arena, ",{d}", .{major});	317	break :ss try allocPrint(arena, ",{d}", .{major});
...	@@ -447,7 +447,7 @@ pub fn linkWithLLD(self: Coff, comp: Compilation, prog_node: *std.Progress.Nod	...	@@ -447,7 +447,7 @@ pub fn linkWithLLD(self: Coff, comp: Compilation, prog_node: *std.Progress.Nod
447	}	447	}
448	} else {	448	} else {
449	try argv.append("-NODEFAULTLIB");	449	try argv.append("-NODEFAULTLIB");
450	if (!is_lib and self.base.options.entry == null) {	450	if (!is_lib and comp.config.entry == null) {
451	if (self.base.comp.module) \|module\| {	451	if (self.base.comp.module) \|module\| {
452	if (module.stage1_flags.have_winmain_crt_startup) {	452	if (module.stage1_flags.have_winmain_crt_startup) {
453	try argv.append("-ENTRY:WinMainCRTStartup");	453	try argv.append("-ENTRY:WinMainCRTStartup");
...	@@ -463,18 +463,18 @@ pub fn linkWithLLD(self: Coff, comp: Compilation, prog_node: *std.Progress.Nod	...	@@ -463,18 +463,18 @@ pub fn linkWithLLD(self: Coff, comp: Compilation, prog_node: *std.Progress.Nod
463	}	463	}
464		464
465	// libc++ dep	465	// libc++ dep
466	if (self.base.options.link_libcpp) {	466	if (comp.config.link_libcpp) {
467	try argv.append(comp.libcxxabi_static_lib.?.full_object_path);	467	try argv.append(comp.libcxxabi_static_lib.?.full_object_path);
468	try argv.append(comp.libcxx_static_lib.?.full_object_path);	468	try argv.append(comp.libcxx_static_lib.?.full_object_path);
469	}	469	}
470		470
471	// libunwind dep	471	// libunwind dep
472	if (self.base.options.link_libunwind) {	472	if (comp.config.link_libunwind) {
473	try argv.append(comp.libunwind_static_lib.?.full_object_path);	473	try argv.append(comp.libunwind_static_lib.?.full_object_path);
474	}	474	}
475		475
476	if (is_exe_or_dyn_lib and !self.base.options.skip_linker_dependencies) {	476	if (is_exe_or_dyn_lib and !comp.skip_linker_dependencies) {
477	if (!self.base.options.link_libc) {	477	if (!comp.config.link_libc) {
478	if (comp.libc_static_lib) \|lib\| {	478	if (comp.libc_static_lib) \|lib\| {
479	try argv.append(lib.full_object_path);	479	try argv.append(lib.full_object_path);
480	}	480	}
...	@@ -492,13 +492,13 @@ pub fn linkWithLLD(self: Coff, comp: Compilation, prog_node: *std.Progress.Nod	...	@@ -492,13 +492,13 @@ pub fn linkWithLLD(self: Coff, comp: Compilation, prog_node: *std.Progress.Nod
492	argv.appendAssumeCapacity(crt_file.full_object_path);	492	argv.appendAssumeCapacity(crt_file.full_object_path);
493	continue;	493	continue;
494	}	494	}
495	if (try findLib(arena, lib_basename, self.base.options.lib_dirs)) \|full_path\| {	495	if (try findLib(arena, lib_basename, self.lib_dirs)) \|full_path\| {
496	argv.appendAssumeCapacity(full_path);	496	argv.appendAssumeCapacity(full_path);
497	continue;	497	continue;
498	}	498	}
499	if (target.abi.isGnu()) {	499	if (target.abi.isGnu()) {
500	const fallback_name = try allocPrint(arena, "lib{s}.dll.a", .{key});	500	const fallback_name = try allocPrint(arena, "lib{s}.dll.a", .{key});
501	if (try findLib(arena, fallback_name, self.base.options.lib_dirs)) \|full_path\| {	501	if (try findLib(arena, fallback_name, self.lib_dirs)) \|full_path\| {
502	argv.appendAssumeCapacity(full_path);	502	argv.appendAssumeCapacity(full_path);
503	continue;	503	continue;
504	}	504	}
...	@@ -582,7 +582,7 @@ pub fn linkWithLLD(self: Coff, comp: Compilation, prog_node: *std.Progress.Nod	...	@@ -582,7 +582,7 @@ pub fn linkWithLLD(self: Coff, comp: Compilation, prog_node: *std.Progress.Nod
582	}	582	}
583	}	583	}
584		584
585	if (!self.base.options.disable_lld_caching) {	585	if (!self.base.disable_lld_caching) {
586	// Update the file with the digest. If it fails we can continue; it only	586	// Update the file with the digest. If it fails we can continue; it only
587	// means that the next invocation will have an unnecessary cache miss.	587	// means that the next invocation will have an unnecessary cache miss.
588	Cache.writeSmallFile(directory.handle, id_symlink_basename, &digest) catch \|err\| {	588	Cache.writeSmallFile(directory.handle, id_symlink_basename, &digest) catch \|err\| {

src/link/Dwarf.zig+6-4

 @@ -1022,16 +1022,18 @@ const min_nop_size = 2;
 /// actual_capacity + (actual_capacity / ideal_factor)
 const ideal_factor = 3;
-pub fn init(allocator: Allocator, bin_file: *File, format: Format) Dwarf {
+pub fn init(lf: *File, format: Format) Dwarf {
-    const target = &bin_file.options.target;
+    const comp = lf.comp;
+    const gpa = comp.gpa;
+    const target = comp.root_mod.resolved_target.result;
     const ptr_width: PtrWidth = switch (target.ptrBitWidth()) {
         0...32 => .p32,
         33...64 => .p64,
         else => unreachable,
     };
     return .{
-        .allocator = allocator,
+        .allocator = gpa,
-        .bin_file = bin_file,
+        .bin_file = lf,
         .format = format,
         .ptr_width = ptr_width,
         .dbg_line_header = switch (target.cpu.arch) {

src/link/Elf.zig+146-149

 @@ -1,5 +1,6 @@
 base: link.File,
 image_base: u64,
+rdynamic: bool,
 ptr_width: PtrWidth,
 @@ -358,19 +359,21 @@ pub fn createEmpty(arena: Allocator, options: link.File.OpenOptions) !*Elf {
             .debug_format = options.debug_format orelse .{ .dwarf = .@"32" },
             .function_sections = options.function_sections,
             .data_sections = options.data_sections,
-            .image_base = b: {
-                if (is_dyn_lib) break :b 0;
-                if (output_mode == .Exe and comp.config.pie) return 0;
-                return options.image_base orelse switch (ptr_width) {
-                    .p32 => 0x1000,
-                    .p64 => 0x1000000,
-                };
-            },
         },
         .ptr_width = ptr_width,
         .page_size = page_size,
         .default_sym_version = default_sym_version,
+        .image_base = b: {
+            if (is_dyn_lib) break :b 0;
+            if (output_mode == .Exe and comp.config.pie) break :b 0;
+            break :b options.image_base orelse switch (ptr_width) {
+                .p32 => 0x1000,
+                .p64 => 0x1000000,
+            };
+        },
+        .rdynamic = options.rdynamic,
     };
     if (use_llvm and comp.config.have_zcu) {
         self.llvm_object = try LlvmObject.create(arena, options);
 @@ -1006,7 +1009,6 @@ pub fn flushModule(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node
             break :blk path;
         }
     } else null;
-    const gc_sections = self.base.gc_sections;
     // --verbose-link
     if (self.base.comp.verbose_link) try self.dumpArgv(comp);
 @@ -1047,14 +1049,14 @@ pub fn flushModule(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node
     var rpath_table = std.StringArrayHashMap(void).init(gpa);
     defer rpath_table.deinit();
-    for (self.base.options.rpath_list) |rpath| {
+    for (self.base.rpath_list) |rpath| {
         _ = try rpath_table.put(rpath, {});
     }
-    if (self.base.options.each_lib_rpath) {
+    if (self.each_lib_rpath) {
         var test_path = std.ArrayList(u8).init(gpa);
         defer test_path.deinit();
-        for (self.base.options.lib_dirs) |lib_dir_path| {
+        for (self.lib_dirs) |lib_dir_path| {
             for (self.base.comp.system_libs.keys()) |link_lib| {
                 if (!(try self.accessLibPath(&test_path, null, lib_dir_path, link_lib, .Dynamic)))
                     continue;
 @@ -1076,9 +1078,7 @@ pub fn flushModule(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node
     }
     // libc
-    if (!self.base.options.skip_linker_dependencies and
+    if (!comp.skip_linker_dependencies and !comp.config.link_libc) {
-        !self.base.options.link_libc)
-    {
         if (comp.libc_static_lib) |lib| {
             try positionals.append(.{ .path = lib.full_object_path });
         }
 @@ -1263,10 +1263,10 @@ pub fn flushModule(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node
         self.entry_index = if (entry) |name| self.globalByName(name) else null;
     }
-    if (gc_sections) {
+    if (self.base.gc_sections) {
         try gc.gcAtoms(self);
-        if (self.base.options.print_gc_sections) {
+        if (self.base.print_gc_sections) {
             try gc.dumpPrunedAtoms(self);
         }
     }
 @@ -1347,13 +1347,13 @@ pub fn flushModule(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node
 }
 pub fn flushStaticLib(self: *Elf, comp: *Compilation, module_obj_path: ?[]const u8) link.File.FlushError!void {
-    const gpa = self.base.comp.gpa;
+    const gpa = comp.gpa;
     var positionals = std.ArrayList(Compilation.LinkObject).init(gpa);
     defer positionals.deinit();
-    try positionals.ensureUnusedCapacity(self.base.options.objects.len);
+    try positionals.ensureUnusedCapacity(comp.objects.len);
-    positionals.appendSliceAssumeCapacity(self.base.options.objects);
+    positionals.appendSliceAssumeCapacity(comp.objects);
     // This is a set of object files emitted by clang in a single `build-exe` invocation.
     // For instance, the implicit `a.o` as compiled by `zig build-exe a.c` will end up
 @@ -1495,8 +1495,8 @@ pub fn flushObject(self: *Elf, comp: *Compilation, module_obj_path: ?[]const u8)
     var positionals = std.ArrayList(Compilation.LinkObject).init(gpa);
     defer positionals.deinit();
-    try positionals.ensureUnusedCapacity(self.base.options.objects.len);
+    try positionals.ensureUnusedCapacity(comp.objects.len);
-    positionals.appendSliceAssumeCapacity(self.base.options.objects);
+    positionals.appendSliceAssumeCapacity(comp.objects);
     // This is a set of object files emitted by clang in a single `build-exe` invocation.
     // For instance, the implicit `a.o` as compiled by `zig build-exe a.c` will end up
 @@ -1606,7 +1606,7 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
     try argv.append(full_out_path);
     if (self.base.isRelocatable()) {
-        for (self.base.options.objects) |obj| {
+        for (comp.objects) |obj| {
             try argv.append(obj.path);
         }
 @@ -1626,28 +1626,28 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
         }
         if (self.base.isDynLib()) {
-            if (self.base.options.soname) |name| {
+            if (self.soname) |name| {
                 try argv.append("-soname");
                 try argv.append(name);
             }
         }
-        if (self.base.options.entry) |entry| {
+        if (comp.config.entry) |entry| {
             try argv.append("--entry");
             try argv.append(entry);
         }
-        for (self.base.options.rpath_list) |rpath| {
+        for (self.base.rpath_list) |rpath| {
             try argv.append("-rpath");
             try argv.append(rpath);
         }
-        if (self.base.options.each_lib_rpath) {
+        if (self.each_lib_rpath) {
-            for (self.base.options.lib_dirs) |lib_dir_path| {
+            for (self.lib_dirs) |lib_dir_path| {
                 try argv.append("-rpath");
                 try argv.append(lib_dir_path);
             }
-            for (self.base.options.objects) |obj| {
+            for (comp.objects) |obj| {
                 if (Compilation.classifyFileExt(obj.path) == .shared_library) {
                     const lib_dir_path = std.fs.path.dirname(obj.path) orelse continue;
                     if (obj.loption) continue;
 @@ -1669,29 +1669,29 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
             try argv.append("--gc-sections");
         }
-        if (self.base.options.print_gc_sections) {
+        if (self.base.print_gc_sections) {
             try argv.append("--print-gc-sections");
         }
-        if (self.base.options.eh_frame_hdr) {
+        if (self.eh_frame_hdr) {
             try argv.append("--eh-frame-hdr");
         }
-        if (self.base.options.rdynamic) {
+        if (self.rdynamic) {
             try argv.append("--export-dynamic");
         }
-        if (self.base.options.z_notext) {
+        if (self.z_notext) {
             try argv.append("-z");
             try argv.append("notext");
         }
-        if (self.base.options.z_nocopyreloc) {
+        if (self.z_nocopyreloc) {
             try argv.append("-z");
             try argv.append("nocopyreloc");
         }
-        if (self.base.options.z_now) {
+        if (self.z_now) {
             try argv.append("-z");
             try argv.append("now");
         }
 @@ -1702,11 +1702,11 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
             try argv.append("-shared");
         }
-        if (self.base.options.pie and self.base.isExe()) {
+        if (comp.config.pie and self.base.isExe()) {
             try argv.append("-pie");
         }
-        if (self.base.options.strip) {
+        if (self.base.debug_format == .strip) {
             try argv.append("-s");
         }
 @@ -1715,12 +1715,12 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
         if (csu.crti) |v| try argv.append(v);
         if (csu.crtbegin) |v| try argv.append(v);
-        for (self.base.options.lib_dirs) |lib_dir| {
+        for (self.lib_dirs) |lib_dir| {
             try argv.append("-L");
             try argv.append(lib_dir);
         }
-        if (self.base.options.link_libc) {
+        if (comp.config.link_libc) {
             if (self.base.comp.libc_installation) |libc_installation| {
                 try argv.append("-L");
                 try argv.append(libc_installation.crt_dir.?);
 @@ -1728,7 +1728,7 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
         }
         var whole_archive = false;
-        for (self.base.options.objects) |obj| {
+        for (comp.objects) |obj| {
             if (obj.must_link and !whole_archive) {
                 try argv.append("-whole-archive");
                 whole_archive = true;
 @@ -1756,15 +1756,12 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
             try argv.append(p);
         }
-        // TSAN
+        if (comp.config.any_sanitize_thread) {
-        if (self.base.options.tsan) {
             try argv.append(comp.tsan_static_lib.?.full_object_path);
         }
         // libc
-        if (!self.base.options.skip_linker_dependencies and
+        if (!comp.skip_linker_dependencies and !comp.config.link_libc) {
-            !self.base.options.link_libc)
-        {
             if (comp.libc_static_lib) |lib| {
                 try argv.append(lib.full_object_path);
             }
 @@ -1799,18 +1796,18 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
         }
         // libc++ dep
-        if (self.base.options.link_libcpp) {
+        if (comp.config.link_libcpp) {
             try argv.append(comp.libcxxabi_static_lib.?.full_object_path);
             try argv.append(comp.libcxx_static_lib.?.full_object_path);
         }
         // libunwind dep
-        if (self.base.options.link_libunwind) {
+        if (comp.config.link_libunwind) {
             try argv.append(comp.libunwind_static_lib.?.full_object_path);
         }
         // libc dep
-        if (self.base.options.link_libc) {
+        if (comp.config.link_libc) {
             if (self.base.comp.libc_installation != null) {
                 const needs_grouping = link_mode == .Static;
                 if (needs_grouping) try argv.append("--start-group");
 @@ -1963,8 +1960,6 @@ fn parseLdScript(self: *Elf, lib: SystemLib) ParseError!void {
     defer script.deinit(gpa);
     try script.parse(data, self);
-    const lib_dirs = self.base.options.lib_dirs;
     var arena_allocator = std.heap.ArenaAllocator.init(gpa);
     defer arena_allocator.deinit();
     const arena = arena_allocator.allocator();
 @@ -1981,7 +1976,7 @@ fn parseLdScript(self: *Elf, lib: SystemLib) ParseError!void {
                 // TODO I think technically we should re-use the mechanism used by the frontend here.
                 // Maybe we should hoist search-strategy all the way here?
-                for (lib_dirs) |lib_dir| {
+                for (self.lib_dirs) |lib_dir| {
                     if (!self.isStatic()) {
                         if (try self.accessLibPath(&test_path, &checked_paths, lib_dir, lib_name, .Dynamic))
                             break :success;
 @@ -1998,7 +1993,7 @@ fn parseLdScript(self: *Elf, lib: SystemLib) ParseError!void {
                 } else |_| {}
                 try checked_paths.append(try gpa.dupe(u8, scr_obj.path));
-                for (lib_dirs) |lib_dir| {
+                for (self.lib_dirs) |lib_dir| {
                     if (try self.accessLibPath(&test_path, &checked_paths, lib_dir, scr_obj.path, null))
                         break :success;
                 }
 @@ -2338,7 +2333,7 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
     const link_mode = self.base.comp.config.link_mode;
     const is_dyn_lib = link_mode == .Dynamic and is_lib;
     const is_exe_or_dyn_lib = is_dyn_lib or output_mode == .Exe;
-    const have_dynamic_linker = self.base.options.link_libc and
+    const have_dynamic_linker = comp.config.link_libc and
         link_mode == .Dynamic and is_exe_or_dyn_lib;
     const target = self.base.comp.root_mod.resolved_target.result;
     const compiler_rt_path: ?[]const u8 = blk: {
 @@ -2358,11 +2353,11 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
     const id_symlink_basename = "lld.id";
     var man: Cache.Manifest = undefined;
-    defer if (!self.base.options.disable_lld_caching) man.deinit();
+    defer if (!self.base.disable_lld_caching) man.deinit();
     var digest: [Cache.hex_digest_len]u8 = undefined;
-    if (!self.base.options.disable_lld_caching) {
+    if (!self.base.disable_lld_caching) {
         man = comp.cache_parent.obtain();
         // We are about to obtain this lock, so here we give other processes a chance first.
 @@ -2370,9 +2365,9 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
         comptime assert(Compilation.link_hash_implementation_version == 10);
-        try man.addOptionalFile(self.base.options.linker_script);
+        try man.addOptionalFile(self.linker_script);
-        try man.addOptionalFile(self.base.options.version_script);
+        try man.addOptionalFile(self.version_script);
-        for (self.base.options.objects) |obj| {
+        for (comp.objects) |obj| {
             _ = try man.addFile(obj.path, null);
             man.hash.add(obj.must_link);
             man.hash.add(obj.loption);
 @@ -2385,34 +2380,34 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
         // We can skip hashing libc and libc++ components that we are in charge of building from Zig
         // installation sources because they are always a product of the compiler version + target information.
-        man.hash.addOptionalBytes(self.base.options.entry);
+        man.hash.addOptionalBytes(comp.config.entry);
         man.hash.addOptional(self.image_base);
         man.hash.add(self.base.gc_sections);
-        man.hash.addOptional(self.base.options.sort_section);
+        man.hash.addOptional(self.sort_section);
-        man.hash.add(self.base.options.eh_frame_hdr);
+        man.hash.add(self.eh_frame_hdr);
-        man.hash.add(self.base.options.emit_relocs);
+        man.hash.add(self.emit_relocs);
-        man.hash.add(self.base.options.rdynamic);
+        man.hash.add(self.rdynamic);
-        man.hash.addListOfBytes(self.base.options.lib_dirs);
+        man.hash.addListOfBytes(self.lib_dirs);
-        man.hash.addListOfBytes(self.base.options.rpath_list);
+        man.hash.addListOfBytes(self.base.rpath_list);
-        man.hash.add(self.base.options.each_lib_rpath);
+        man.hash.add(self.each_lib_rpath);
         if (output_mode == .Exe) {
             man.hash.add(self.base.stack_size);
             man.hash.add(self.base.build_id);
         }
-        man.hash.addListOfBytes(self.base.options.symbol_wrap_set.keys());
+        man.hash.addListOfBytes(self.symbol_wrap_set.keys());
-        man.hash.add(self.base.options.skip_linker_dependencies);
+        man.hash.add(comp.skip_linker_dependencies);
-        man.hash.add(self.base.options.z_nodelete);
+        man.hash.add(self.z_nodelete);
-        man.hash.add(self.base.options.z_notext);
+        man.hash.add(self.z_notext);
-        man.hash.add(self.base.options.z_defs);
+        man.hash.add(self.z_defs);
-        man.hash.add(self.base.options.z_origin);
+        man.hash.add(self.z_origin);
-        man.hash.add(self.base.options.z_nocopyreloc);
+        man.hash.add(self.z_nocopyreloc);
-        man.hash.add(self.base.options.z_now);
+        man.hash.add(self.z_now);
-        man.hash.add(self.base.options.z_relro);
+        man.hash.add(self.z_relro);
-        man.hash.add(self.base.options.z_common_page_size orelse 0);
+        man.hash.add(self.z_common_page_size orelse 0);
-        man.hash.add(self.base.options.z_max_page_size orelse 0);
+        man.hash.add(self.z_max_page_size orelse 0);
-        man.hash.add(self.base.options.hash_style);
+        man.hash.add(self.hash_style);
         // strip does not need to go into the linker hash because it is part of the hash namespace
-        if (self.base.options.link_libc) {
+        if (comp.config.link_libc) {
             man.hash.add(self.base.comp.libc_installation != null);
             if (self.base.comp.libc_installation) |libc_installation| {
                 man.hash.addBytes(libc_installation.crt_dir.?);
 @@ -2421,16 +2416,16 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
                 man.hash.addOptionalBytes(target.dynamic_linker.get());
             }
         }
-        man.hash.addOptionalBytes(self.base.options.soname);
+        man.hash.addOptionalBytes(self.soname);
-        man.hash.addOptional(self.base.options.version);
+        man.hash.addOptional(comp.version);
         try link.hashAddSystemLibs(&man, self.base.comp.system_libs);
-        man.hash.addListOfBytes(self.base.options.force_undefined_symbols.keys());
+        man.hash.addListOfBytes(self.base.force_undefined_symbols.keys());
         man.hash.add(self.base.allow_shlib_undefined);
-        man.hash.add(self.base.options.bind_global_refs_locally);
+        man.hash.add(self.bind_global_refs_locally);
-        man.hash.add(self.base.options.compress_debug_sections);
+        man.hash.add(self.compress_debug_sections);
-        man.hash.add(self.base.options.tsan);
+        man.hash.add(comp.config.any_sanitize_thread);
-        man.hash.addOptionalBytes(self.base.options.sysroot);
+        man.hash.addOptionalBytes(self.sysroot);
-        man.hash.add(self.base.options.linker_optimization);
+        man.hash.add(self.optimization);
         // We don't actually care whether it's a cache hit or miss; we just need the digest and the lock.
         _ = try man.hit();
 @@ -2466,14 +2461,14 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
     // However, because LLD wants to resolve BPF relocations which it shouldn't, it fails
     // before even generating the relocatable.
     if (output_mode == .Obj and
-        (self.base.options.lto or target.isBpfFreestanding()))
+        (comp.config.lto or target.isBpfFreestanding()))
     {
         // In this case we must do a simple file copy
         // here. TODO: think carefully about how we can avoid this redundant operation when doing
         // build-obj. See also the corresponding TODO in linkAsArchive.
         const the_object_path = blk: {
-            if (self.base.options.objects.len != 0)
+            if (comp.objects.len != 0)
-                break :blk self.base.options.objects[0].path;
+                break :blk comp.objects[0].path;
             if (comp.c_object_table.count() != 0)
                 break :blk comp.c_object_table.keys()[0].status.success.object_path;
 @@ -2505,32 +2500,32 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
         try argv.append("--error-limit=0");
-        if (self.base.options.sysroot) |sysroot| {
+        if (self.sysroot) |sysroot| {
             try argv.append(try std.fmt.allocPrint(arena, "--sysroot={s}", .{sysroot}));
         }
-        if (self.base.options.lto) {
+        if (comp.config.lto) {
-            switch (self.base.options.optimize_mode) {
+            switch (comp.root_mod.optimize_mode) {
                 .Debug => {},
                 .ReleaseSmall => try argv.append("--lto-O2"),
                 .ReleaseFast, .ReleaseSafe => try argv.append("--lto-O3"),
             }
         }
         try argv.append(try std.fmt.allocPrint(arena, "-O{d}", .{
-            self.base.options.linker_optimization,
+            self.optimization,
         }));
-        if (self.base.options.entry) |entry| {
+        if (comp.config.entry) |entry| {
             try argv.append("--entry");
             try argv.append(entry);
         }
-        for (self.base.options.force_undefined_symbols.keys()) |sym| {
+        for (self.base.force_undefined_symbols.keys()) |sym| {
             try argv.append("-u");
             try argv.append(sym);
         }
-        switch (self.base.options.hash_style) {
+        switch (self.hash_style) {
             .gnu => try argv.append("--hash-style=gnu"),
             .sysv => try argv.append("--hash-style=sysv"),
             .both => {}, // this is the default
 @@ -2559,12 +2554,12 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
         try argv.append(try std.fmt.allocPrint(arena, "--image-base={d}", .{self.image_base}));
-        if (self.base.options.linker_script) |linker_script| {
+        if (self.linker_script) |linker_script| {
             try argv.append("-T");
             try argv.append(linker_script);
         }
-        if (self.base.options.sort_section) |how| {
+        if (self.sort_section) |how| {
             const arg = try std.fmt.allocPrint(arena, "--sort-section={s}", .{@tagName(how)});
             try argv.append(arg);
         }
 @@ -2573,67 +2568,67 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
             try argv.append("--gc-sections");
         }
-        if (self.base.options.print_gc_sections) {
+        if (self.base.print_gc_sections) {
             try argv.append("--print-gc-sections");
         }
-        if (self.base.options.print_icf_sections) {
+        if (self.print_icf_sections) {
             try argv.append("--print-icf-sections");
         }
-        if (self.base.options.print_map) {
+        if (self.print_map) {
             try argv.append("--print-map");
         }
-        if (self.base.options.eh_frame_hdr) {
+        if (self.eh_frame_hdr) {
             try argv.append("--eh-frame-hdr");
         }
-        if (self.base.options.emit_relocs) {
+        if (self.emit_relocs) {
             try argv.append("--emit-relocs");
         }
-        if (self.base.options.rdynamic) {
+        if (self.rdynamic) {
             try argv.append("--export-dynamic");
         }
-        if (self.base.options.strip) {
+        if (self.base.debug_format == .strip) {
             try argv.append("-s");
         }
-        if (self.base.options.z_nodelete) {
+        if (self.z_nodelete) {
             try argv.append("-z");
             try argv.append("nodelete");
         }
-        if (self.base.options.z_notext) {
+        if (self.z_notext) {
             try argv.append("-z");
             try argv.append("notext");
         }
-        if (self.base.options.z_defs) {
+        if (self.z_defs) {
             try argv.append("-z");
             try argv.append("defs");
         }
-        if (self.base.options.z_origin) {
+        if (self.z_origin) {
             try argv.append("-z");
             try argv.append("origin");
         }
-        if (self.base.options.z_nocopyreloc) {
+        if (self.z_nocopyreloc) {
             try argv.append("-z");
             try argv.append("nocopyreloc");
         }
-        if (self.base.options.z_now) {
+        if (self.z_now) {
             // LLD defaults to -zlazy
             try argv.append("-znow");
         }
-        if (!self.base.options.z_relro) {
+        if (!self.z_relro) {
             // LLD defaults to -zrelro
             try argv.append("-znorelro");
         }
-        if (self.base.options.z_common_page_size) |size| {
+        if (self.z_common_page_size) |size| {
             try argv.append("-z");
             try argv.append(try std.fmt.allocPrint(arena, "common-page-size={d}", .{size}));
         }
-        if (self.base.options.z_max_page_size) |size| {
+        if (self.z_max_page_size) |size| {
             try argv.append("-z");
             try argv.append(try std.fmt.allocPrint(arena, "max-page-size={d}", .{size}));
         }
 @@ -2658,7 +2653,7 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
             try argv.append("-shared");
         }
-        if (self.base.options.pie and output_mode == .Exe) {
+        if (comp.config.pie and output_mode == .Exe) {
             try argv.append("-pie");
         }
 @@ -2683,20 +2678,20 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
         // rpaths
         var rpath_table = std.StringHashMap(void).init(gpa);
         defer rpath_table.deinit();
-        for (self.base.options.rpath_list) |rpath| {
+        for (self.base.rpath_list) |rpath| {
             if ((try rpath_table.fetchPut(rpath, {})) == null) {
                 try argv.append("-rpath");
                 try argv.append(rpath);
             }
         }
-        for (self.base.options.symbol_wrap_set.keys()) |symbol_name| {
+        for (self.symbol_wrap_set.keys()) |symbol_name| {
             try argv.appendSlice(&.{ "-wrap", symbol_name });
         }
-        if (self.base.options.each_lib_rpath) {
+        if (self.each_lib_rpath) {
             var test_path = std.ArrayList(u8).init(arena);
-            for (self.base.options.lib_dirs) |lib_dir_path| {
+            for (self.lib_dirs) |lib_dir_path| {
                 for (self.base.comp.system_libs.keys()) |link_lib| {
                     if (!(try self.accessLibPath(&test_path, null, lib_dir_path, link_lib, .Dynamic)))
                         continue;
 @@ -2706,7 +2701,7 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
                     }
                 }
             }
-            for (self.base.options.objects) |obj| {
+            for (comp.objects) |obj| {
                 if (Compilation.classifyFileExt(obj.path) == .shared_library) {
                     const lib_dir_path = std.fs.path.dirname(obj.path) orelse continue;
                     if (obj.loption) continue;
 @@ -2719,12 +2714,12 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
             }
         }
-        for (self.base.options.lib_dirs) |lib_dir| {
+        for (self.lib_dirs) |lib_dir| {
             try argv.append("-L");
             try argv.append(lib_dir);
         }
-        if (self.base.options.link_libc) {
+        if (comp.config.link_libc) {
             if (self.base.comp.libc_installation) |libc_installation| {
                 try argv.append("-L");
                 try argv.append(libc_installation.crt_dir.?);
 @@ -2739,11 +2734,11 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
         }
         if (is_dyn_lib) {
-            if (self.base.options.soname) |soname| {
+            if (self.soname) |soname| {
                 try argv.append("-soname");
                 try argv.append(soname);
             }
-            if (self.base.options.version_script) |version_script| {
+            if (self.version_script) |version_script| {
                 try argv.append("-version-script");
                 try argv.append(version_script);
             }
 @@ -2751,7 +2746,7 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
         // Positional arguments to the linker such as object files.
         var whole_archive = false;
-        for (self.base.options.objects) |obj| {
+        for (comp.objects) |obj| {
             if (obj.must_link and !whole_archive) {
                 try argv.append("-whole-archive");
                 whole_archive = true;
 @@ -2779,15 +2774,14 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
             try argv.append(p);
         }
-        // TSAN
+        if (comp.config.any_sanitize_thread) {
-        if (self.base.options.tsan) {
             try argv.append(comp.tsan_static_lib.?.full_object_path);
         }
         // libc
         if (is_exe_or_dyn_lib and
-            !self.base.options.skip_linker_dependencies and
+            !comp.skip_linker_dependencies and
-            !self.base.options.link_libc)
+            !comp.config.link_libc)
         {
             if (comp.libc_static_lib) |lib| {
                 try argv.append(lib.full_object_path);
 @@ -2832,19 +2826,19 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
             }
             // libc++ dep
-            if (self.base.options.link_libcpp) {
+            if (comp.config.link_libcpp) {
                 try argv.append(comp.libcxxabi_static_lib.?.full_object_path);
                 try argv.append(comp.libcxx_static_lib.?.full_object_path);
             }
             // libunwind dep
-            if (self.base.options.link_libunwind) {
+            if (comp.config.link_libunwind) {
                 try argv.append(comp.libunwind_static_lib.?.full_object_path);
             }
             // libc dep
             self.error_flags.missing_libc = false;
-            if (self.base.options.link_libc) {
+            if (comp.config.link_libc) {
                 if (self.base.comp.libc_installation != null) {
                     const needs_grouping = link_mode == .Static;
                     if (needs_grouping) try argv.append("--start-group");
 @@ -2884,13 +2878,13 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
             try argv.append("--allow-shlib-undefined");
         }
-        switch (self.base.options.compress_debug_sections) {
+        switch (self.compress_debug_sections) {
             .none => {},
             .zlib => try argv.append("--compress-debug-sections=zlib"),
             .zstd => try argv.append("--compress-debug-sections=zstd"),
         }
-        if (self.base.options.bind_global_refs_locally) {
+        if (self.bind_global_refs_locally) {
             try argv.append("-Bsymbolic");
         }
 @@ -2964,7 +2958,7 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
         }
     }
-    if (!self.base.options.disable_lld_caching) {
+    if (!self.base.disable_lld_caching) {
         // Update the file with the digest. If it fails we can continue; it only
         // means that the next invocation will have an unnecessary cache miss.
         Cache.writeSmallFile(directory.handle, id_symlink_basename, &digest) catch |err| {
 @@ -3101,7 +3095,8 @@ fn writeElfHeader(self: *Elf) !void {
     };
     index += 1;
-    const target = self.base.comp.root_mod.resolved_target.result;
+    const comp = self.base.comp;
+    const target = comp.root_mod.resolved_target.result;
     const endian = target.cpu.arch.endian();
     hdr_buf[index] = switch (endian) {
         .little => elf.ELFDATA2LSB,
 @@ -3120,10 +3115,10 @@ fn writeElfHeader(self: *Elf) !void {
     assert(index == 16);
-    const output_mode = self.base.comp.config.output_mode;
+    const output_mode = comp.config.output_mode;
-    const link_mode = self.base.comp.config.link_mode;
+    const link_mode = comp.config.link_mode;
     const elf_type: elf.ET = switch (output_mode) {
-        .Exe => if (self.base.options.pie) .DYN else .EXEC,
+        .Exe => if (comp.config.pie) .DYN else .EXEC,
         .Obj => .REL,
         .Lib => switch (link_mode) {
             .Static => @as(elf.ET, .REL),
 @@ -3283,7 +3278,7 @@ fn addLinkerDefinedSymbols(self: *Elf) !void {
     self.plt_index = try linker_defined.addGlobal("_PROCEDURE_LINKAGE_TABLE_", self);
     self.end_index = try linker_defined.addGlobal("_end", self);
-    if (self.base.options.eh_frame_hdr) {
+    if (self.eh_frame_hdr) {
         self.gnu_eh_frame_hdr_index = try linker_defined.addGlobal("__GNU_EH_FRAME_HDR", self);
     }
 @@ -3314,7 +3309,8 @@ fn addLinkerDefinedSymbols(self: *Elf) !void {
 }
 fn allocateLinkerDefinedSymbols(self: *Elf) void {
-    const link_mode = self.base.comp.config.link_mode;
+    const comp = self.base.comp;
+    const link_mode = comp.config.link_mode;
     // _DYNAMIC
     if (self.dynamic_section_index) |shndx| {
 @@ -3398,7 +3394,7 @@ fn allocateLinkerDefinedSymbols(self: *Elf) void {
     // __rela_iplt_start, __rela_iplt_end
     if (self.rela_dyn_section_index) |shndx| blk: {
-        if (link_mode != .Static or self.base.options.pie) break :blk;
+        if (link_mode != .Static or comp.config.pie) break :blk;
         const shdr = &self.shdrs.items[shndx];
         const end_addr = shdr.sh_addr + shdr.sh_size;
         const start_addr = end_addr - self.calcNumIRelativeRelocs() * @sizeOf(elf.Elf64_Rela);
 @@ -3445,7 +3441,8 @@ fn initOutputSections(self: *Elf) !void {
 }
 fn initSyntheticSections(self: *Elf) !void {
-    const target = self.base.comp.root_mod.resolved_target.result;
+    const comp = self.base.comp;
+    const target = comp.root_mod.resolved_target.result;
     const ptr_size = self.ptrWidthBytes();
     const needs_eh_frame = for (self.objects.items) |index| {
 @@ -3460,7 +3457,7 @@ fn initSyntheticSections(self: *Elf) !void {
             .offset = std.math.maxInt(u64),
         });
-        if (self.base.options.eh_frame_hdr) {
+        if (self.eh_frame_hdr) {
             self.eh_frame_hdr_section_index = try self.addSection(.{
                 .name = ".eh_frame_hdr",
                 .type = elf.SHT_PROGBITS,
 @@ -3554,7 +3551,7 @@ fn initSyntheticSections(self: *Elf) !void {
         // In this case, if we do generate .interp section and segment, we will get
         // a segfault in the dynamic linker trying to load a binary that is static
         // and doesn't contain .dynamic section.
-        if (self.isStatic() and !self.base.options.pie) break :blk false;
+        if (self.isStatic() and !comp.config.pie) break :blk false;
         break :blk target.dynamic_linker.get() != null;
     };
     if (needs_interp) {
 @@ -3567,7 +3564,7 @@ fn initSyntheticSections(self: *Elf) !void {
         });
     }
-    if (self.base.isDynLib() or self.shared_objects.items.len > 0 or self.base.options.pie) {
+    if (self.base.isDynLib() or self.shared_objects.items.len > 0 or comp.config.pie) {
         self.dynstrtab_section_index = try self.addSection(.{
             .name = ".dynstr",
             .flags = elf.SHF_ALLOC,
 @@ -3859,7 +3856,7 @@ fn setDynamicSection(self: *Elf, rpaths: []const []const u8) !void {
     }
     if (self.base.isDynLib()) {
-        if (self.base.options.soname) |soname| {
+        if (self.soname) |soname| {
             try self.dynamic.setSoname(soname, self);
         }
     }

src/link/Elf/Atom.zig+7-6

...	@@ -543,7 +543,7 @@ fn scanReloc(	...	@@ -543,7 +543,7 @@ fn scanReloc(
543	try self.reportPicError(symbol, rel, elf_file),	543	try self.reportPicError(symbol, rel, elf_file),
544		544
545	.copyrel => {	545	.copyrel => {
546	if (elf_file.base.options.z_nocopyreloc) {	546	if (elf_file.z_nocopyreloc) {
547	if (symbol.isAbs(elf_file))	547	if (symbol.isAbs(elf_file))
548	try self.reportNoPicError(symbol, rel, elf_file)	548	try self.reportNoPicError(symbol, rel, elf_file)
549	else	549	else
...	@@ -553,9 +553,9 @@ fn scanReloc(	...	@@ -553,9 +553,9 @@ fn scanReloc(
553	},	553	},
554		554
555	.dyn_copyrel => {	555	.dyn_copyrel => {
556	if (is_writeable or elf_file.base.options.z_nocopyreloc) {	556	if (is_writeable or elf_file.z_nocopyreloc) {
557	if (!is_writeable) {	557	if (!is_writeable) {
558	if (elf_file.base.options.z_notext) {	558	if (elf_file.z_notext) {
559	elf_file.has_text_reloc = true;	559	elf_file.has_text_reloc = true;
560	} else {	560	} else {
561	try self.reportTextRelocError(symbol, rel, elf_file);	561	try self.reportTextRelocError(symbol, rel, elf_file);
...	@@ -587,7 +587,7 @@ fn scanReloc(	...	@@ -587,7 +587,7 @@ fn scanReloc(
587		587
588	.dynrel, .baserel, .ifunc => {	588	.dynrel, .baserel, .ifunc => {
589	if (!is_writeable) {	589	if (!is_writeable) {
590	if (elf_file.base.options.z_notext) {	590	if (elf_file.z_notext) {
591	elf_file.has_text_reloc = true;	591	elf_file.has_text_reloc = true;
592	} else {	592	} else {
593	try self.reportTextRelocError(symbol, rel, elf_file);	593	try self.reportTextRelocError(symbol, rel, elf_file);
...	@@ -657,11 +657,12 @@ fn dynAbsRelocAction(symbol: const Symbol, elf_file: Elf) RelocAction {	...	@@ -657,11 +657,12 @@ fn dynAbsRelocAction(symbol: const Symbol, elf_file: Elf) RelocAction {
657	}	657	}
658		658
659	fn outputType(elf_file: *Elf) u2 {	659	fn outputType(elf_file: *Elf) u2 {
		660	const comp = elf_file.base.comp;
660	assert(!elf_file.isRelocatable());	661	assert(!elf_file.isRelocatable());
661	return switch (elf_file.base.comp.config.output_mode) {	662	return switch (elf_file.base.comp.config.output_mode) {
662	.Obj => unreachable,	663	.Obj => unreachable,
663	.Lib => 0,	664	.Lib => 0,
664	.Exe => if (elf_file.base.options.pie) 1 else 2,	665	.Exe => if (comp.config.pie) 1 else 2,
665	};	666	};
666	}	667	}
667		668
...	@@ -979,7 +980,7 @@ fn resolveDynAbsReloc(	...	@@ -979,7 +980,7 @@ fn resolveDynAbsReloc(
979	=> try writer.writeInt(i32, @as(i32, @truncate(S + A)), .little),	980	=> try writer.writeInt(i32, @as(i32, @truncate(S + A)), .little),
980		981
981	.dyn_copyrel => {	982	.dyn_copyrel => {
982	if (is_writeable or elf_file.base.options.z_nocopyreloc) {	983	if (is_writeable or elf_file.z_nocopyreloc) {
983	elf_file.addRelaDynAssumeCapacity(.{	984	elf_file.addRelaDynAssumeCapacity(.{
984	.offset = P,	985	.offset = P,
985	.sym = target.extra(elf_file).?.dynamic,	986	.sym = target.extra(elf_file).?.dynamic,

src/link/Elf/Object.zig+1-1

...	@@ -299,7 +299,7 @@ fn skipShdr(self: Object, index: u16, elf_file: Elf) bool {	...	@@ -299,7 +299,7 @@ fn skipShdr(self: Object, index: u16, elf_file: Elf) bool {
299	if (mem.startsWith(u8, name, ".note")) break :blk true;	299	if (mem.startsWith(u8, name, ".note")) break :blk true;
300	if (mem.startsWith(u8, name, ".comment")) break :blk true;	300	if (mem.startsWith(u8, name, ".comment")) break :blk true;
301	if (mem.startsWith(u8, name, ".llvm_addrsig")) break :blk true;	301	if (mem.startsWith(u8, name, ".llvm_addrsig")) break :blk true;
302	if (elf_file.base.options.strip and shdr.sh_flags & elf.SHF_ALLOC == 0 and	302	if (elf_file.base.debug_format == .strip and shdr.sh_flags & elf.SHF_ALLOC == 0 and
303	mem.startsWith(u8, name, ".debug")) break :blk true;	303	mem.startsWith(u8, name, ".debug")) break :blk true;
304	break :blk false;	304	break :blk false;
305	};	305	};

src/link/Elf/ZigObject.zig+1-1

...	@@ -97,7 +97,7 @@ pub fn init(self: ZigObject, elf_file: Elf) !void {	...	@@ -97,7 +97,7 @@ pub fn init(self: ZigObject, elf_file: Elf) !void {
97	symbol_ptr.esym_index = esym_index;	97	symbol_ptr.esym_index = esym_index;
98		98
99	if (elf_file.base.debug_format != .strip) {	99	if (elf_file.base.debug_format != .strip) {
100	self.dwarf = Dwarf.init(gpa, &elf_file.base, .dwarf32);	100	self.dwarf = Dwarf.init(&elf_file.base, .dwarf32);
101	}	101	}
102	}	102	}
103		103

src/link/Elf/synthetic_sections.zig+15-9

src/link/MachO.zig+20-16

...	@@ -252,7 +252,7 @@ pub fn open(arena: Allocator, options: link.File.OpenOptions) !*MachO {	...	@@ -252,7 +252,7 @@ pub fn open(arena: Allocator, options: link.File.OpenOptions) !*MachO {
252		252
253	self.d_sym = .{	253	self.d_sym = .{
254	.allocator = gpa,	254	.allocator = gpa,
255	.dwarf = link.File.Dwarf.init(gpa, &self.base, .dwarf32),	255	.dwarf = link.File.Dwarf.init(&self.base, .dwarf32),
256	.file = d_sym_file,	256	.file = d_sym_file,
257	};	257	};
258	}	258	}
...	@@ -573,7 +573,7 @@ pub fn flushModule(self: MachO, comp: Compilation, prog_node: *std.Progress.No	...	@@ -573,7 +573,7 @@ pub fn flushModule(self: MachO, comp: Compilation, prog_node: *std.Progress.No
573		573
574	try self.writeLinkeditSegmentData();	574	try self.writeLinkeditSegmentData();
575		575
576	var codesig: ?CodeSignature = if (requiresCodeSignature(&self.base.options)) blk: {	576	var codesig: ?CodeSignature = if (self.requiresCodeSignature()) blk: {
577	// Preallocate space for the code signature.	577	// Preallocate space for the code signature.
578	// We need to do this at this stage so that we have the load commands with proper values	578	// We need to do this at this stage so that we have the load commands with proper values
579	// written out to the file.	579	// written out to the file.
...	@@ -619,12 +619,12 @@ pub fn flushModule(self: MachO, comp: Compilation, prog_node: *std.Progress.No	...	@@ -619,12 +619,12 @@ pub fn flushModule(self: MachO, comp: Compilation, prog_node: *std.Progress.No
619	});	619	});
620	},	620	},
621	.Lib => if (self.base.comp.config.link_mode == .Dynamic) {	621	.Lib => if (self.base.comp.config.link_mode == .Dynamic) {
622	try load_commands.writeDylibIdLC(gpa, &self.base.options, lc_writer);	622	try load_commands.writeDylibIdLC(self, lc_writer);
623	},	623	},
624	else => {},	624	else => {},
625	}	625	}
626		626
627	try load_commands.writeRpathLCs(gpa, &self.base.options, lc_writer);	627	try load_commands.writeRpathLCs(self, lc_writer);
628	try lc_writer.writeStruct(macho.source_version_command{	628	try lc_writer.writeStruct(macho.source_version_command{
629	.version = 0,	629	.version = 0,
630	});	630	});
...	@@ -713,7 +713,7 @@ pub fn resolveLibSystem(	...	@@ -713,7 +713,7 @@ pub fn resolveLibSystem(
713	success: {	713	success: {
714	if (self.sdk_layout) \|sdk_layout\| switch (sdk_layout) {	714	if (self.sdk_layout) \|sdk_layout\| switch (sdk_layout) {
715	.sdk => {	715	.sdk => {
716	const dir = try fs.path.join(arena, &[_][]const u8{ self.base.options.sysroot.?, "usr", "lib" });	716	const dir = try fs.path.join(arena, &[_][]const u8{ comp.sysroot.?, "usr", "lib" });
717	if (try accessLibPath(arena, &test_path, &checked_paths, dir, "libSystem")) break :success;	717	if (try accessLibPath(arena, &test_path, &checked_paths, dir, "libSystem")) break :success;
718	},	718	},
719	.vendored => {	719	.vendored => {
...	@@ -1156,7 +1156,8 @@ pub fn parseDependentLibs(self: *MachO, dependent_libs: anytype) !void {	...	@@ -1156,7 +1156,8 @@ pub fn parseDependentLibs(self: *MachO, dependent_libs: anytype) !void {
1156	// 2) afterwards, we parse dependents of the included dylibs	1156	// 2) afterwards, we parse dependents of the included dylibs
1157	// TODO this should not be performed if the user specifies `-flat_namespace` flag.	1157	// TODO this should not be performed if the user specifies `-flat_namespace` flag.
1158	// See ld64 manpages.	1158	// See ld64 manpages.
1159	const gpa = self.base.comp.gpa;	1159	const comp = self.base.comp;
		1160	const gpa = comp.gpa;
1160		1161
1161	while (dependent_libs.readItem()) \|dep_id\| {	1162	while (dependent_libs.readItem()) \|dep_id\| {
1162	defer dep_id.id.deinit(gpa);	1163	defer dep_id.id.deinit(gpa);
...	@@ -1176,7 +1177,7 @@ pub fn parseDependentLibs(self: *MachO, dependent_libs: anytype) !void {	...	@@ -1176,7 +1177,7 @@ pub fn parseDependentLibs(self: *MachO, dependent_libs: anytype) !void {
1176	var checked_paths = std.ArrayList([]const u8).init(arena);	1177	var checked_paths = std.ArrayList([]const u8).init(arena);
1177		1178
1178	success: {	1179	success: {
1179	if (self.base.options.sysroot) \|root\| {	1180	if (comp.sysroot) \|root\| {
1180	const dir = try fs.path.join(arena, &[_][]const u8{ root, dirname });	1181	const dir = try fs.path.join(arena, &[_][]const u8{ root, dirname });
1181	if (try accessLibPath(gpa, &test_path, &checked_paths, dir, stem)) break :success;	1182	if (try accessLibPath(gpa, &test_path, &checked_paths, dir, stem)) break :success;
1182	}	1183	}
...	@@ -1713,12 +1714,12 @@ pub fn resolveSymbols(self: *MachO) !void {	...	@@ -1713,12 +1714,12 @@ pub fn resolveSymbols(self: *MachO) !void {
1713	// we search for it in libraries should there be no object files specified	1714	// we search for it in libraries should there be no object files specified
1714	// on the linker line.	1715	// on the linker line.
1715	if (output_mode == .Exe) {	1716	if (output_mode == .Exe) {
1716	const entry_name = self.base.options.entry orelse load_commands.default_entry_point;	1717	const entry_name = comp.config.entry.?;
1717	_ = try self.addUndefined(entry_name, .{});	1718	_ = try self.addUndefined(entry_name, .{});
1718	}	1719	}
1719		1720
1720	// Force resolution of any symbols requested by the user.	1721	// Force resolution of any symbols requested by the user.
1721	for (self.base.options.force_undefined_symbols.keys()) \|sym_name\| {	1722	for (self.base.force_undefined_symbols.keys()) \|sym_name\| {
1722	_ = try self.addUndefined(sym_name, .{});	1723	_ = try self.addUndefined(sym_name, .{});
1723	}	1724	}
1724		1725
...	@@ -4367,7 +4368,7 @@ fn writeSymtab(self: *MachO) !SymtabCtx {	...	@@ -4367,7 +4368,7 @@ fn writeSymtab(self: *MachO) !SymtabCtx {
4367		4368
4368	// We generate stabs last in order to ensure that the strtab always has debug info	4369	// We generate stabs last in order to ensure that the strtab always has debug info
4369	// strings trailing	4370	// strings trailing
4370	if (!self.base.options.strip) {	4371	if (self.base.debug_format != .strip) {
4371	for (self.objects.items) \|object\| {	4372	for (self.objects.items) \|object\| {
4372	assert(self.d_sym == null); // TODO	4373	assert(self.d_sym == null); // TODO
4373	try self.generateSymbolStabs(object, &locals);	4374	try self.generateSymbolStabs(object, &locals);
...	@@ -5171,7 +5172,8 @@ pub fn getStubsEntryAddress(self: *MachO, sym_with_loc: SymbolWithLoc) ?u64 {	...	@@ -5171,7 +5172,8 @@ pub fn getStubsEntryAddress(self: *MachO, sym_with_loc: SymbolWithLoc) ?u64 {
5171	/// Returns symbol location corresponding to the set entrypoint if any.	5172	/// Returns symbol location corresponding to the set entrypoint if any.
5172	/// Asserts output mode is executable.	5173	/// Asserts output mode is executable.
5173	pub fn getEntryPoint(self: MachO) ?SymbolWithLoc {	5174	pub fn getEntryPoint(self: MachO) ?SymbolWithLoc {
5174	const entry_name = self.base.options.entry orelse load_commands.default_entry_point;	5175	const comp = self.base.comp;
		5176	const entry_name = comp.config.entry orelse return null;
5175	const global = self.getGlobal(entry_name) orelse return null;	5177	const global = self.getGlobal(entry_name) orelse return null;
5176	return global;	5178	return global;
5177	}	5179	}
...	@@ -5189,11 +5191,13 @@ pub inline fn getPageSize(cpu_arch: std.Target.Cpu.Arch) u16 {	...	@@ -5189,11 +5191,13 @@ pub inline fn getPageSize(cpu_arch: std.Target.Cpu.Arch) u16 {
5189	};	5191	};
5190	}	5192	}
5191		5193
5192	pub fn requiresCodeSignature(options: *const link.Options) bool {	5194	pub fn requiresCodeSignature(m: *MachO) bool {
5193	if (options.entitlements) \|_\| return true;	5195	if (m.entitlements) \|_\| return true;
5194	const cpu_arch = options.target.cpu.arch;	5196	const comp = m.base.comp;
5195	const os_tag = options.target.os.tag;	5197	const target = comp.root_mod.resolved_target.result;
5196	const abi = options.target.abi;	5198	const cpu_arch = target.cpu.arch;
		5199	const os_tag = target.os.tag;
		5200	const abi = target.abi;
5197	if (cpu_arch == .aarch64 and (os_tag == .macos or abi == .simulator)) return true;	5201	if (cpu_arch == .aarch64 and (os_tag == .macos or abi == .simulator)) return true;
5198	return false;	5202	return false;
5199	}	5203	}

src/link/MachO/DebugSymbols.zig+3-4

src/link/MachO/dead_strip.zig+1-1

...	@@ -60,7 +60,7 @@ fn collectRoots(macho_file: MachO, roots: AtomTable) !void {	...	@@ -60,7 +60,7 @@ fn collectRoots(macho_file: MachO, roots: AtomTable) !void {
60	}	60	}
61		61
62	// Add all symbols force-defined by the user.	62	// Add all symbols force-defined by the user.
63	for (macho_file.base.options.force_undefined_symbols.keys()) \|sym_name\| {	63	for (macho_file.base.force_undefined_symbols.keys()) \|sym_name\| {
64	const global_index = macho_file.resolver.get(sym_name).?;	64	const global_index = macho_file.resolver.get(sym_name).?;
65	const global = macho_file.globals.items[global_index];	65	const global = macho_file.globals.items[global_index];
66	const sym = macho_file.getSymbol(global);	66	const sym = macho_file.getSymbol(global);

src/link/MachO/load_commands.zig+17-17

 @@ -1,6 +1,3 @@
-/// Default implicit entrypoint symbol name.
-pub const default_entry_point: []const u8 = "_main";
 /// Default path to dyld.
 pub const default_dyld_path: [*:0]const u8 = "/usr/lib/dyld";
 @@ -17,7 +14,9 @@ const CalcLCsSizeCtx = struct {
     wants_function_starts: bool = true,
 };
-fn calcLCsSize(gpa: Allocator, options: *const link.Options, ctx: CalcLCsSizeCtx, assume_max_path_len: bool) !u32 {
+fn calcLCsSize(m: *MachO, ctx: CalcLCsSizeCtx, assume_max_path_len: bool) !u32 {
+    const comp = m.base.comp;
+    const gpa = comp.gpa;
     var has_text_segment: bool = false;
     var sizeofcmds: u64 = 0;
     for (ctx.segments) |seg| {
 @@ -46,15 +45,15 @@ fn calcLCsSize(gpa: Allocator, options: *const link.Options, ctx: CalcLCsSizeCtx
         false,
     );
     // LC_MAIN
-    if (options.output_mode == .Exe) {
+    if (comp.config.output_mode == .Exe) {
         sizeofcmds += @sizeOf(macho.entry_point_command);
     }
     // LC_ID_DYLIB
-    if (options.output_mode == .Lib and options.link_mode == .Dynamic) {
+    if (comp.config.output_mode == .Lib and comp.config.link_mode == .Dynamic) {
         sizeofcmds += blk: {
-            const emit = options.emit.?;
+            const emit = m.base.emit;
-            const install_name = options.install_name orelse try emit.directory.join(gpa, &.{emit.sub_path});
+            const install_name = m.install_name orelse try emit.directory.join(gpa, &.{emit.sub_path});
-            defer if (options.install_name == null) gpa.free(install_name);
+            defer if (m.install_name == null) gpa.free(install_name);
             break :blk calcInstallNameLen(
                 @sizeOf(macho.dylib_command),
                 install_name,
 @@ -64,7 +63,7 @@ fn calcLCsSize(gpa: Allocator, options: *const link.Options, ctx: CalcLCsSizeCtx
     }
     // LC_RPATH
     {
-        var it = RpathIterator.init(gpa, options.rpath_list);
+        var it = RpathIterator.init(gpa, m.rpath_list);
         defer it.deinit();
         while (try it.next()) |rpath| {
             sizeofcmds += calcInstallNameLen(
 @@ -78,7 +77,8 @@ fn calcLCsSize(gpa: Allocator, options: *const link.Options, ctx: CalcLCsSizeCtx
     sizeofcmds += @sizeOf(macho.source_version_command);
     // LC_BUILD_VERSION or LC_VERSION_MIN_ or nothing
     {
-        const platform = Platform.fromTarget(options.target);
+        const target = comp.root_mod.resolved_target.result;
+        const platform = Platform.fromTarget(target);
         if (platform.isBuildVersionCompatible()) {
             // LC_BUILD_VERSION
             sizeofcmds += @sizeOf(macho.build_version_command) + @sizeOf(macho.build_tool_version);
 @@ -100,19 +100,19 @@ fn calcLCsSize(gpa: Allocator, options: *const link.Options, ctx: CalcLCsSizeCtx
         );
     }
     // LC_CODE_SIGNATURE
-    if (MachO.requiresCodeSignature(options)) {
+    if (m.requiresCodeSignature()) {
         sizeofcmds += @sizeOf(macho.linkedit_data_command);
     }
-    return @as(u32, @intCast(sizeofcmds));
+    return @intCast(sizeofcmds);
 }
-pub fn calcMinHeaderPad(gpa: Allocator, options: *const link.Options, ctx: CalcLCsSizeCtx) !u64 {
+pub fn calcMinHeaderPad(m: *MachO, ctx: CalcLCsSizeCtx) !u64 {
-    var padding: u32 = (try calcLCsSize(gpa, options, ctx, false)) + (options.headerpad_size orelse 0);
+    var padding: u32 = (try calcLCsSize(m, ctx, false)) + m.headerpad_size;
     log.debug("minimum requested headerpad size 0x{x}", .{padding + @sizeOf(macho.mach_header_64)});
-    if (options.headerpad_max_install_names) {
+    if (m.headerpad_max_install_names) {
-        const min_headerpad_size: u32 = try calcLCsSize(gpa, options, ctx, true);
+        const min_headerpad_size: u32 = try calcLCsSize(m, ctx, true);
         log.debug("headerpad_max_install_names minimum headerpad size 0x{x}", .{
             min_headerpad_size + @sizeOf(macho.mach_header_64),
         });

src/link/MachO/zld.zig+4-5

 @@ -499,7 +499,7 @@ pub fn linkWithZld(
         }
         // Write code signature padding if required
-        var codesig: ?CodeSignature = if (MachO.requiresCodeSignature(&macho_file.base.options)) blk: {
+        var codesig: ?CodeSignature = if (macho_file.requiresCodeSignature()) blk: {
             // Preallocate space for the code signature.
             // We need to do this at this stage so that we have the load commands with proper values
             // written out to the file.
 @@ -547,12 +547,12 @@ pub fn linkWithZld(
                 });
             },
             .Lib => if (link_mode == .Dynamic) {
-                try load_commands.writeDylibIdLC(gpa, &macho_file.base.options, lc_writer);
+                try load_commands.writeDylibIdLC(macho_file, lc_writer);
             },
             else => {},
         }
-        try load_commands.writeRpathLCs(gpa, &macho_file.base.options, lc_writer);
+        try load_commands.writeRpathLCs(macho_file, lc_writer);
         try lc_writer.writeStruct(macho.source_version_command{
             .version = 0,
         });
 @@ -1072,11 +1072,10 @@ fn calcSectionSizes(macho_file: *MachO) !void {
 }
 fn allocateSegments(macho_file: *MachO) !void {
-    const gpa = macho_file.base.allocator;
     for (macho_file.segments.items, 0..) |*segment, segment_index| {
         const is_text_segment = mem.eql(u8, segment.segName(), "__TEXT");
         const base_size = if (is_text_segment)
-            try load_commands.calcMinHeaderPad(gpa, &macho_file.base.options, .{
+            try load_commands.calcMinHeaderPad(macho_file, .{
                 .segments = macho_file.segments.items,
                 .dylibs = macho_file.dylibs.items,
                 .referenced_dylibs = macho_file.referenced_dylibs.keys(),

src/link/NvPtx.zig+2-1

...	@@ -57,6 +57,7 @@ pub fn createEmpty(arena: Allocator, options: link.File.OpenOptions) !*NvPtx {	...	@@ -57,6 +57,7 @@ pub fn createEmpty(arena: Allocator, options: link.File.OpenOptions) !*NvPtx {
57	.build_id = options.build_id,	57	.build_id = options.build_id,
58	.rpath_list = options.rpath_list,	58	.rpath_list = options.rpath_list,
59	.force_undefined_symbols = options.force_undefined_symbols,	59	.force_undefined_symbols = options.force_undefined_symbols,
		60	.debug_format = options.debug_format orelse .{ .dwarf = .@"32" },
60	.function_sections = options.function_sections,	61	.function_sections = options.function_sections,
61	.data_sections = options.data_sections,	62	.data_sections = options.data_sections,
62	},	63	},
...	@@ -66,7 +67,7 @@ pub fn createEmpty(arena: Allocator, options: link.File.OpenOptions) !*NvPtx {	...	@@ -66,7 +67,7 @@ pub fn createEmpty(arena: Allocator, options: link.File.OpenOptions) !*NvPtx {
66	return nvptx;	67	return nvptx;
67	}	68	}
68		69
69	pub fn open(arena: Allocator, options: link.FileOpenOptions) !*NvPtx {	70	pub fn open(arena: Allocator, options: link.File.OpenOptions) !*NvPtx {
70	const target = options.comp.root_mod.resolved_target.result;	71	const target = options.comp.root_mod.resolved_target.result;
71	assert(target.ofmt == .nvptx);	72	assert(target.ofmt == .nvptx);
72	return createEmpty(arena, options);	73	return createEmpty(arena, options);

src/link/Plan9.zig+21-11

 @@ -295,26 +295,36 @@ pub fn defaultBaseAddrs(arch: std.Target.Cpu.Arch) Bases {
 }
 pub fn createEmpty(arena: Allocator, options: link.File.OpenOptions) !*Plan9 {
-    _ = arena;
+    const comp = options.comp;
-    const target = options.comp.root_mod.resolved_target.result;
+    const target = comp.root_mod.resolved_target.result;
-    const gpa = options.comp.gpa;
+    const gpa = comp.gpa;
+    const optimize_mode = comp.root_mod.optimize_mode;
+    const output_mode = comp.config.output_mode;
-    const sixtyfour_bit: bool = switch (options.target.ptrBitWidth()) {
+    const sixtyfour_bit: bool = switch (target.ptrBitWidth()) {
         0...32 => false,
         33...64 => true,
         else => return error.UnsupportedP9Architecture,
     };
-    const arena_allocator = std.heap.ArenaAllocator.init(gpa);
+    const self = try arena.create(Plan9);
-    const self = try gpa.create(Plan9);
     self.* = .{
-        .path_arena = arena_allocator,
+        .path_arena = std.heap.ArenaAllocator.init(gpa),
         .base = .{
             .tag = .plan9,
-            .options = options,
+            .comp = comp,
-            .allocator = gpa,
+            .emit = options.emit,
+            .gc_sections = options.gc_sections orelse (optimize_mode != .Debug and output_mode != .Obj),
+            .stack_size = options.stack_size orelse 16777216,
+            .allow_shlib_undefined = options.allow_shlib_undefined orelse false,
             .file = null,
+            .disable_lld_caching = options.disable_lld_caching,
+            .build_id = options.build_id,
+            .rpath_list = options.rpath_list,
+            .force_undefined_symbols = options.force_undefined_symbols,
+            .debug_format = options.debug_format orelse .{ .dwarf = .@"32" },
+            .function_sections = options.function_sections,
+            .data_sections = options.data_sections,
         },
         .sixtyfour_bit = sixtyfour_bit,
         .bases = undefined,
 @@ -602,7 +612,7 @@ pub fn flush(self: *Plan9, comp: *Compilation, prog_node: *std.Progress.Node) li
     const use_lld = build_options.have_llvm and self.base.comp.config.use_lld;
     assert(!use_lld);
-    switch (self.base.options.effectiveOutputMode()) {
+    switch (link.File.effectiveOutputMode(use_lld, comp.config.output_mode)) {
         .Exe => {},
         // plan9 object files are totally different
         .Obj => return error.TODOImplementPlan9Objs,

src/link/SpirV.zig+2-1

...	@@ -67,6 +67,7 @@ pub fn createEmpty(arena: Allocator, options: link.File.OpenOptions) !*SpirV {	...	@@ -67,6 +67,7 @@ pub fn createEmpty(arena: Allocator, options: link.File.OpenOptions) !*SpirV {
67	.force_undefined_symbols = options.force_undefined_symbols,	67	.force_undefined_symbols = options.force_undefined_symbols,
68	.function_sections = options.function_sections,	68	.function_sections = options.function_sections,
69	.data_sections = options.data_sections,	69	.data_sections = options.data_sections,
		70	.debug_format = options.debug_format orelse .{ .dwarf = .@"32" },
70	},	71	},
71	.object = codegen.Object.init(gpa),	72	.object = codegen.Object.init(gpa),
72	};	73	};
...	@@ -102,7 +103,7 @@ pub fn open(arena: Allocator, options: link.File.OpenOptions) !*SpirV {	...	@@ -102,7 +103,7 @@ pub fn open(arena: Allocator, options: link.File.OpenOptions) !*SpirV {
102	errdefer spirv.base.destroy();	103	errdefer spirv.base.destroy();
103		104
104	// TODO: read the file and keep valid parts instead of truncating	105	// TODO: read the file and keep valid parts instead of truncating
105	const file = try options.emit.?.directory.handle.createFile(options.emit.sub_path, .{	106	const file = try options.emit.directory.handle.createFile(options.emit.sub_path, .{
106	.truncate = true,	107	.truncate = true,
107	.read = true,	108	.read = true,
108	});	109	});

src/link/Wasm.zig+149-96

 @@ -37,6 +37,13 @@ pub const Relocation = types.Relocation;
 pub const base_tag: link.File.Tag = .wasm;
 base: link.File,
+import_symbols: bool,
+export_symbol_names: []const []const u8,
+rdynamic: bool,
+global_base: ?u64,
+initial_memory: ?u64,
+max_memory: ?u64,
+wasi_emulated_libs: []const wasi_libc.CRTFile,
 /// Output name of the file
 name: []const u8,
 /// If this is not null, an object file is created by LLVM and linked with LLD afterwards.
 @@ -368,13 +375,15 @@ pub const StringTable = struct {
 pub fn open(arena: Allocator, options: link.File.OpenOptions) !*Wasm {
     if (build_options.only_c) unreachable;
-    const gpa = options.comp.gpa;
+    const comp = options.comp;
-    const target = options.comp.root_mod.resolved_target.result;
+    const gpa = comp.gpa;
+    const target = comp.root_mod.resolved_target.result;
     assert(target.ofmt == .wasm);
-    const use_lld = build_options.have_llvm and options.comp.config.use_lld;
+    const use_lld = build_options.have_llvm and comp.config.use_lld;
-    const use_llvm = options.comp.config.use_llvm;
+    const use_llvm = comp.config.use_llvm;
-    const output_mode = options.comp.config.output_mode;
+    const output_mode = comp.config.output_mode;
+    const shared_memory = comp.config.shared_memory;
     const wasm = try createEmpty(arena, options);
     errdefer wasm.base.destroy();
 @@ -395,7 +404,7 @@ pub fn open(arena: Allocator, options: link.File.OpenOptions) !*Wasm {
     };
     // TODO: read the file and keep valid parts instead of truncating
-    const file = try options.emit.?.directory.handle.createFile(sub_path, .{
+    const file = try options.emit.directory.handle.createFile(sub_path, .{
         .truncate = true,
         .read = true,
         .mode = if (fs.has_executable_bit)
 @@ -480,7 +489,7 @@ pub fn open(arena: Allocator, options: link.File.OpenOptions) !*Wasm {
     }
     // shared-memory symbols for TLS support
-    if (wasm.base.options.shared_memory) {
+    if (shared_memory) {
         {
             const loc = try wasm.createSyntheticSymbol("__tls_base", .global);
             const symbol = loc.getSymbol(wasm);
 @@ -522,14 +531,15 @@ pub fn open(arena: Allocator, options: link.File.OpenOptions) !*Wasm {
 }
 pub fn createEmpty(arena: Allocator, options: link.File.OpenOptions) !*Wasm {
-    const use_llvm = options.comp.config.use_llvm;
+    const comp = options.comp;
-    const output_mode = options.comp.config.output_mode;
+    const use_llvm = comp.config.use_llvm;
+    const output_mode = comp.config.output_mode;
     const wasm = try arena.create(Wasm);
     wasm.* = .{
         .base = .{
             .tag = .wasm,
-            .comp = options.comp,
+            .comp = comp,
             .emit = options.emit,
             .gc_sections = options.gc_sections orelse (output_mode != .Obj),
             .stack_size = options.stack_size orelse std.wasm.page_size * 16, // 1MB
 @@ -546,6 +556,13 @@ pub fn createEmpty(arena: Allocator, options: link.File.OpenOptions) !*Wasm {
         .name = undefined,
         .import_table = options.import_table,
         .export_table = options.export_table,
+        .import_symbols = options.import_symbols,
+        .export_symbol_names = options.export_symbol_names,
+        .rdynamic = options.rdynamic,
+        .global_base = options.global_base,
+        .initial_memory = options.initial_memory,
+        .max_memory = options.max_memory,
+        .wasi_emulated_libs = options.wasi_emulated_libs,
     };
     if (use_llvm) {
 @@ -909,7 +926,10 @@ fn writeI32Const(writer: anytype, val: u32) !void {
 }
 fn setupInitMemoryFunction(wasm: *Wasm) !void {
-    const gpa = wasm.base.comp.gpa;
+    const comp = wasm.base.comp;
+    const gpa = comp.gpa;
+    const shared_memory = comp.config.shared_memory;
+    const import_memory = comp.config.import_memory;
     // Passive segments are used to avoid memory being reinitialized on each
     // thread's instantiation. These passive segments are initialized and
 @@ -920,7 +940,7 @@ fn setupInitMemoryFunction(wasm: *Wasm) !void {
         return;
     }
-    const flag_address: u32 = if (wasm.base.options.shared_memory) address: {
+    const flag_address: u32 = if (shared_memory) address: {
         // when we have passive initialization segments and shared memory
         // `setupMemory` will create this symbol and set its virtual address.
         const loc = wasm.findGlobalSymbol("__wasm_init_memory_flag").?;
 @@ -934,7 +954,7 @@ fn setupInitMemoryFunction(wasm: *Wasm) !void {
     // we have 0 locals
     try leb.writeULEB128(writer, @as(u32, 0));
-    if (wasm.base.options.shared_memory) {
+    if (shared_memory) {
         // destination blocks
         // based on values we jump to corresponding label
         try writer.writeByte(std.wasm.opcode(.block)); // $drop
 @@ -968,14 +988,14 @@ fn setupInitMemoryFunction(wasm: *Wasm) !void {
     var segment_index: u32 = 0;
     while (it.next()) |entry| : (segment_index += 1) {
         const segment: Segment = wasm.segments.items[entry.value_ptr.*];
-        if (segment.needsPassiveInitialization(wasm.base.options.import_memory, entry.key_ptr.*)) {
+        if (segment.needsPassiveInitialization(import_memory, entry.key_ptr.*)) {
             // For passive BSS segments we can simple issue a memory.fill(0).
             // For non-BSS segments we do a memory.init.  Both these
             // instructions take as their first argument the destination
             // address.
             try writeI32Const(writer, segment.offset);
-            if (wasm.base.options.shared_memory and std.mem.eql(u8, entry.key_ptr.*, ".tdata")) {
+            if (shared_memory and std.mem.eql(u8, entry.key_ptr.*, ".tdata")) {
                 // When we initialize the TLS segment we also set the `__tls_base`
                 // global.  This allows the runtime to use this static copy of the
                 // TLS data for the first/main thread.
 @@ -1000,7 +1020,7 @@ fn setupInitMemoryFunction(wasm: *Wasm) !void {
         }
     }
-    if (wasm.base.options.shared_memory) {
+    if (shared_memory) {
         // we set the init memory flag to value '2'
         try writeI32Const(writer, flag_address);
         try writeI32Const(writer, 2);
 @@ -1043,12 +1063,12 @@ fn setupInitMemoryFunction(wasm: *Wasm) !void {
     while (it.next()) |entry| : (segment_index += 1) {
         const name = entry.key_ptr.*;
         const segment: Segment = wasm.segments.items[entry.value_ptr.*];
-        if (segment.needsPassiveInitialization(wasm.base.options.import_memory, name) and
+        if (segment.needsPassiveInitialization(import_memory, name) and
             !std.mem.eql(u8, name, ".bss"))
         {
             // The TLS region should not be dropped since its is needed
             // during the initialization of each thread (__wasm_init_tls).
-            if (wasm.base.options.shared_memory and std.mem.eql(u8, name, ".tdata")) {
+            if (shared_memory and std.mem.eql(u8, name, ".tdata")) {
                 continue;
             }
 @@ -1071,11 +1091,13 @@ fn setupInitMemoryFunction(wasm: *Wasm) !void {
 /// Constructs a synthetic function that performs runtime relocations for
 /// TLS symbols. This function is called by `__wasm_init_tls`.
 fn setupTLSRelocationsFunction(wasm: *Wasm) !void {
-    const gpa = wasm.base.comp.gpa;
+    const comp = wasm.base.comp;
+    const gpa = comp.gpa;
+    const shared_memory = comp.config.shared_memory;
     // When we have TLS GOT entries and shared memory is enabled,
     // we must perform runtime relocations or else we don't create the function.
-    if (!wasm.base.options.shared_memory or !wasm.requiresTLSReloc()) {
+    if (!shared_memory or !wasm.requiresTLSReloc()) {
         return;
     }
 @@ -1119,7 +1141,9 @@ fn validateFeatures(
     to_emit: *[@typeInfo(types.Feature.Tag).Enum.fields.len]bool,
     emit_features_count: *u32,
 ) !void {
-    const target = wasm.base.comp.root_mod.resolved_target.result;
+    const comp = wasm.base.comp;
+    const target = comp.root_mod.resolved_target.result;
+    const shared_memory = comp.config.shared_memory;
     const cpu_features = target.cpu.features;
     const infer = cpu_features.isEmpty(); // when the user did not define any features, we infer them from linked objects.
     const known_features_count = @typeInfo(types.Feature.Tag).Enum.fields.len;
 @@ -1190,7 +1214,7 @@ fn validateFeatures(
         return error.InvalidFeatureSet;
     }
-    if (wasm.base.options.shared_memory) {
+    if (shared_memory) {
         const disallowed_feature = disallowed[@intFromEnum(types.Feature.Tag.shared_mem)];
         if (@as(u1, @truncate(disallowed_feature)) != 0) {
             log.err(
 @@ -1255,7 +1279,9 @@ fn validateFeatures(
 /// if one or multiple undefined references exist. When none exist, the symbol will
 /// not be created, ensuring we don't unneccesarily emit unreferenced symbols.
 fn resolveLazySymbols(wasm: *Wasm) !void {
-    const gpa = wasm.base.comp.gpa;
+    const comp = wasm.base.comp;
+    const gpa = comp.gpa;
+    const shared_memory = comp.config.shared_memory;
     if (wasm.string_table.getOffset("__heap_base")) |name_offset| {
         if (wasm.undefs.fetchSwapRemove(name_offset)) |kv| {
 @@ -1273,7 +1299,7 @@ fn resolveLazySymbols(wasm: *Wasm) !void {
         }
     }
-    if (!wasm.base.options.shared_memory) {
+    if (!shared_memory) {
         if (wasm.string_table.getOffset("__tls_base")) |name_offset| {
             if (wasm.undefs.fetchSwapRemove(name_offset)) |kv| {
                 const loc = try wasm.createSyntheticSymbolOffset(name_offset, .global);
 @@ -1306,8 +1332,9 @@ pub fn findGlobalSymbol(wasm: *Wasm, name: []const u8) ?SymbolLoc {
 }
 fn checkUndefinedSymbols(wasm: *const Wasm) !void {
-    if (wasm.base.comp.config.output_mode == .Obj) return;
+    const comp = wasm.base.comp;
-    if (wasm.base.options.import_symbols) return;
+    if (comp.config.output_mode == .Obj) return;
+    if (wasm.import_symbols) return;
     var found_undefined_symbols = false;
     for (wasm.undefs.values()) |undef| {
 @@ -2182,7 +2209,10 @@ const Kind = union(enum) {
 /// Parses an Atom and inserts its metadata into the corresponding sections.
 fn parseAtom(wasm: *Wasm, atom_index: Atom.Index, kind: Kind) !void {
-    const gpa = wasm.base.comp.gpa;
+    const comp = wasm.base.comp;
+    const gpa = comp.gpa;
+    const shared_memory = comp.config.shared_memory;
+    const import_memory = comp.config.import_memory;
     const atom = wasm.getAtomPtr(atom_index);
     const symbol = (SymbolLoc{ .file = null, .index = atom.sym_index }).getSymbol(wasm);
     const do_garbage_collect = wasm.base.gc_sections;
 @@ -2233,7 +2263,7 @@ fn parseAtom(wasm: *Wasm, atom_index: Atom.Index, kind: Kind) !void {
             // we set the entire region of it to zeroes.
             // We do not have to do this when exporting the memory (the default) because the runtime
             // will do it for us, and we do not emit the bss segment at all.
-            if ((wasm.base.comp.config.output_mode == .Obj or wasm.base.options.import_memory) and kind.data == .uninitialized) {
+            if ((wasm.base.comp.config.output_mode == .Obj or import_memory) and kind.data == .uninitialized) {
                 @memset(atom.code.items, 0);
             }
 @@ -2250,7 +2280,7 @@ fn parseAtom(wasm: *Wasm, atom_index: Atom.Index, kind: Kind) !void {
             } else {
                 const index: u32 = @intCast(wasm.segments.items.len);
                 var flags: u32 = 0;
-                if (wasm.base.options.shared_memory) {
+                if (shared_memory) {
                     flags |= @intFromEnum(Segment.Flag.WASM_DATA_SEGMENT_IS_PASSIVE);
                 }
                 try wasm.segments.append(gpa, .{
 @@ -2679,9 +2709,11 @@ fn setupStartSection(wasm: *Wasm) !void {
 }
 fn initializeTLSFunction(wasm: *Wasm) !void {
-    const gpa = wasm.base.comp.gpa;
+    const comp = wasm.base.comp;
+    const gpa = comp.gpa;
+    const shared_memory = comp.config.shared_memory;
-    if (!wasm.base.options.shared_memory) return;
+    if (!shared_memory) return;
     var function_body = std.ArrayList(u8).init(gpa);
     defer function_body.deinit();
 @@ -2940,7 +2972,7 @@ fn setupExports(wasm: *Wasm) !void {
     if (wasm.base.comp.config.output_mode == .Obj) return;
     log.debug("Building exports from symbols", .{});
-    const force_exp_names = wasm.base.options.export_symbol_names;
+    const force_exp_names = wasm.export_symbol_names;
     if (force_exp_names.len > 0) {
         var failed_exports = false;
 @@ -2962,7 +2994,7 @@ fn setupExports(wasm: *Wasm) !void {
     for (wasm.resolved_symbols.keys()) |sym_loc| {
         const symbol = sym_loc.getSymbol(wasm);
-        if (!symbol.isExported(wasm.base.options.rdynamic)) continue;
+        if (!symbol.isExported(wasm.rdynamic)) continue;
         const sym_name = sym_loc.getName(wasm);
         const export_name = if (wasm.export_names.get(sym_loc)) |name| name else blk: {
 @@ -2997,8 +3029,9 @@ fn setupExports(wasm: *Wasm) !void {
 }
 fn setupStart(wasm: *Wasm) !void {
+    const comp = wasm.base.comp;
     // do not export entry point if user set none or no default was set.
-    const entry_name = wasm.base.options.entry orelse return;
+    const entry_name = comp.config.entry orelse return;
     const symbol_loc = wasm.findGlobalSymbol(entry_name) orelse {
         log.err("Entry symbol '{s}' missing, use '-fno-entry' to suppress", .{entry_name});
 @@ -3012,13 +3045,15 @@ fn setupStart(wasm: *Wasm) !void {
     }
     // Ensure the symbol is exported so host environment can access it
-    if (wasm.base.comp.config.output_mode != .Obj) {
+    if (comp.config.output_mode != .Obj) {
         symbol.setFlag(.WASM_SYM_EXPORTED);
     }
 }
 /// Sets up the memory section of the wasm module, as well as the stack.
 fn setupMemory(wasm: *Wasm) !void {
+    const comp = wasm.base.comp;
+    const shared_memory = comp.config.shared_memory;
     log.debug("Setting up memory layout", .{});
     const page_size = std.wasm.page_size; // 64kb
     const stack_alignment: Alignment = .@"16"; // wasm's stack alignment as specified by tool-convention
 @@ -3027,12 +3062,12 @@ fn setupMemory(wasm: *Wasm) !void {
     // Always place the stack at the start by default
     // unless the user specified the global-base flag
     var place_stack_first = true;
-    var memory_ptr: u64 = if (wasm.base.options.global_base) |base| blk: {
+    var memory_ptr: u64 = if (wasm.global_base) |base| blk: {
         place_stack_first = false;
         break :blk base;
     } else 0;
-    const is_obj = wasm.base.comp.config.output_mode == .Obj;
+    const is_obj = comp.config.output_mode == .Obj;
     if (place_stack_first and !is_obj) {
         memory_ptr = stack_alignment.forward(memory_ptr);
 @@ -3059,7 +3094,7 @@ fn setupMemory(wasm: *Wasm) !void {
             }
             if (wasm.findGlobalSymbol("__tls_base")) |loc| {
                 const sym = loc.getSymbol(wasm);
-                wasm.wasm_globals.items[sym.index - wasm.imported_globals_count].init.i32_const = if (wasm.base.options.shared_memory)
+                wasm.wasm_globals.items[sym.index - wasm.imported_globals_count].init.i32_const = if (shared_memory)
                     @as(i32, 0)
                 else
                     @as(i32, @intCast(memory_ptr));
 @@ -3072,7 +3107,7 @@ fn setupMemory(wasm: *Wasm) !void {
     }
     // create the memory init flag which is used by the init memory function
-    if (wasm.base.options.shared_memory and wasm.hasPassiveInitializationSegments()) {
+    if (shared_memory and wasm.hasPassiveInitializationSegments()) {
         // align to pointer size
         memory_ptr = mem.alignForward(u64, memory_ptr, 4);
         const loc = try wasm.createSyntheticSymbol("__wasm_init_memory_flag", .data);
 @@ -3098,7 +3133,7 @@ fn setupMemory(wasm: *Wasm) !void {
     // For now we only support wasm32 by setting the maximum allowed memory size 2^32-1
     const max_memory_allowed: u64 = (1 << 32) - 1;
-    if (wasm.base.options.initial_memory) |initial_memory| {
+    if (wasm.initial_memory) |initial_memory| {
         if (!std.mem.isAlignedGeneric(u64, initial_memory, page_size)) {
             log.err("Initial memory must be {d}-byte aligned", .{page_size});
             return error.MissAlignment;
 @@ -3124,7 +3159,7 @@ fn setupMemory(wasm: *Wasm) !void {
         symbol.virtual_address = @as(u32, @intCast(memory_ptr));
     }
-    if (wasm.base.options.max_memory) |max_memory| {
+    if (wasm.max_memory) |max_memory| {
         if (!std.mem.isAlignedGeneric(u64, max_memory, page_size)) {
             log.err("Maximum memory must be {d}-byte aligned", .{page_size});
             return error.MissAlignment;
 @@ -3139,7 +3174,7 @@ fn setupMemory(wasm: *Wasm) !void {
         }
         wasm.memories.limits.max = @as(u32, @intCast(max_memory / page_size));
         wasm.memories.limits.setFlag(.WASM_LIMITS_FLAG_HAS_MAX);
-        if (wasm.base.options.shared_memory) {
+        if (shared_memory) {
             wasm.memories.limits.setFlag(.WASM_LIMITS_FLAG_IS_SHARED);
         }
         log.debug("Maximum memory pages: {?d}", .{wasm.memories.limits.max});
 @@ -3150,20 +3185,22 @@ fn setupMemory(wasm: *Wasm) !void {
 /// index of the segment within the final data section. When the segment does not yet
 /// exist, a new one will be initialized and appended. The new index will be returned in that case.
 pub fn getMatchingSegment(wasm: *Wasm, object_index: u16, symbol_index: u32) !u32 {
-    const gpa = wasm.base.comp.gpa;
+    const comp = wasm.base.comp;
+    const gpa = comp.gpa;
     const object: Object = wasm.objects.items[object_index];
     const symbol = object.symtable[symbol_index];
     const index: u32 = @intCast(wasm.segments.items.len);
+    const shared_memory = comp.config.shared_memory;
     switch (symbol.tag) {
         .data => {
             const segment_info = object.segment_info[symbol.index];
-            const merge_segment = wasm.base.comp.config.output_mode != .Obj;
+            const merge_segment = comp.config.output_mode != .Obj;
             const result = try wasm.data_segments.getOrPut(gpa, segment_info.outputName(merge_segment));
             if (!result.found_existing) {
                 result.value_ptr.* = index;
                 var flags: u32 = 0;
-                if (wasm.base.options.shared_memory) {
+                if (shared_memory) {
                     flags |= @intFromEnum(Segment.Flag.WASM_DATA_SEGMENT_IS_PASSIVE);
                 }
                 try wasm.segments.append(gpa, .{
 @@ -3445,6 +3482,8 @@ fn linkWithZld(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) l
     defer tracy.end();
     const gpa = wasm.base.comp.gpa;
+    const shared_memory = comp.config.shared_memory;
+    const import_memory = comp.config.import_memory;
     // Used for all temporary memory allocated during flushin
     var arena_instance = std.heap.ArenaAllocator.init(gpa);
 @@ -3509,8 +3548,8 @@ fn linkWithZld(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) l
         man.hash.addOptionalBytes(wasm.base.comp.config.entry);
         man.hash.add(wasm.base.stack_size);
         man.hash.add(wasm.base.build_id);
-        man.hash.add(wasm.base.comp.config.import_memory);
+        man.hash.add(import_memory);
-        man.hash.add(wasm.base.comp.config.shared_memory);
+        man.hash.add(shared_memory);
         man.hash.add(wasm.import_table);
         man.hash.add(wasm.export_table);
         man.hash.addOptional(wasm.initial_memory);
 @@ -3726,8 +3765,12 @@ pub fn flushModule(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Nod
                 } else if (Value.fromInterned(variable.init).isUndefDeep(mod)) {
                     // for safe build modes, we store the atom in the data segment,
                     // whereas for unsafe build modes we store it in bss.
-                    const is_initialized = wasm.base.options.optimize_mode == .Debug or
+                    const decl_namespace = mod.namespacePtr(decl.src_namespace);
-                        wasm.base.options.optimize_mode == .ReleaseSafe;
+                    const optimize_mode = decl_namespace.file_scope.mod.optimize_mode;
+                    const is_initialized = switch (optimize_mode) {
+                        .Debug, .ReleaseSafe => true,
+                        .ReleaseFast, .ReleaseSmall => false,
+                    };
                     try wasm.parseAtom(atom_index, .{ .data = if (is_initialized) .initialized else .uninitialized });
                 } else {
                     // when the decl is all zeroes, we store the atom in the bss segment,
 @@ -3788,9 +3831,13 @@ fn writeToFile(
     feature_count: u32,
     arena: Allocator,
 ) !void {
-    const gpa = wasm.base.comp.gpa;
+    const comp = wasm.base.comp;
-    const use_llvm = wasm.base.comp.config.use_llvm;
+    const gpa = comp.gpa;
-    const use_lld = build_options.have_llvm and wasm.base.comp.config.use_lld;
+    const use_llvm = comp.config.use_llvm;
+    const use_lld = build_options.have_llvm and comp.config.use_lld;
+    const shared_memory = comp.config.shared_memory;
+    const import_memory = comp.config.import_memory;
+    const export_memory = comp.config.export_memory;
     // Size of each section header
     const header_size = 5 + 1;
 @@ -3800,7 +3847,7 @@ fn writeToFile(
     var code_section_index: ?u32 = null;
     // Index of the data section. Used to tell relocation table where the section lives.
     var data_section_index: ?u32 = null;
-    const is_obj = wasm.base.comp.config.output_mode == .Obj or (!use_llvm and use_lld);
+    const is_obj = comp.config.output_mode == .Obj or (!use_llvm and use_lld);
     var binary_bytes = std.ArrayList(u8).init(gpa);
     defer binary_bytes.deinit();
 @@ -3840,8 +3887,6 @@ fn writeToFile(
     }
     // Import section
-    const import_memory = wasm.base.options.import_memory or is_obj;
-    const export_memory = wasm.base.options.export_memory;
     if (wasm.imports.count() != 0 or import_memory) {
         const header_offset = try reserveVecSectionHeader(&binary_bytes);
 @@ -4018,7 +4063,7 @@ fn writeToFile(
     // When the shared-memory option is enabled, we *must* emit the 'data count' section.
     const data_segments_count = wasm.data_segments.count() - @intFromBool(wasm.data_segments.contains(".bss") and !import_memory);
-    if (data_segments_count != 0 and wasm.base.options.shared_memory) {
+    if (data_segments_count != 0 and shared_memory) {
         const header_offset = try reserveVecSectionHeader(&binary_bytes);
         try writeVecSectionHeader(
             binary_bytes.items,
 @@ -4160,11 +4205,11 @@ fn writeToFile(
         if (data_section_index) |data_index| {
             try wasm.emitDataRelocations(&binary_bytes, data_index, symbol_table);
         }
-    } else if (!wasm.base.options.strip) {
+    } else if (wasm.base.debug_format != .strip) {
         try wasm.emitNameSection(&binary_bytes, arena);
     }
-    if (!wasm.base.options.strip) {
+    if (wasm.base.debug_format != .strip) {
         // The build id must be computed on the main sections only,
         // so we have to do it now, before the debug sections.
         switch (wasm.base.build_id) {
 @@ -4193,7 +4238,7 @@ fn writeToFile(
         }
         // if (wasm.dwarf) |*dwarf| {
-        //     const mod = wasm.base.comp.module.?;
+        //     const mod = comp.module.?;
         //     try dwarf.writeDbgAbbrev();
         //     // for debug info and ranges, the address is always 0,
         //     // as locations are always offsets relative to 'code' section.
 @@ -4380,6 +4425,8 @@ fn emitFeaturesSection(binary_bytes: *std.ArrayList(u8), enabled_features: []con
 }
 fn emitNameSection(wasm: *Wasm, binary_bytes: *std.ArrayList(u8), arena: std.mem.Allocator) !void {
+    const comp = wasm.base.comp;
+    const import_memory = comp.config.import_memory;
     const Name = struct {
         index: u32,
         name: []const u8,
 @@ -4418,7 +4465,7 @@ fn emitNameSection(wasm: *Wasm, binary_bytes: *std.ArrayList(u8), arena: std.mem
     for (wasm.data_segments.keys()) |key| {
         // bss section is not emitted when this condition holds true, so we also
         // do not output a name for it.
-        if (!wasm.base.options.import_memory and std.mem.eql(u8, key, ".bss")) continue;
+        if (!import_memory and std.mem.eql(u8, key, ".bss")) continue;
         segments.appendAssumeCapacity(.{ .index = data_segment_index, .name = key });
         data_segment_index += 1;
     }
 @@ -4528,6 +4575,11 @@ fn linkWithLLD(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) !
     const tracy = trace(@src());
     defer tracy.end();
+    const shared_memory = comp.config.shared_memory;
+    const export_memory = comp.config.export_memory;
+    const import_memory = comp.config.import_memory;
+    const target = comp.root_mod.resolved_target.result;
     const gpa = wasm.base.comp.gpa;
     var arena_allocator = std.heap.ArenaAllocator.init(gpa);
     defer arena_allocator.deinit();
 @@ -4560,8 +4612,6 @@ fn linkWithLLD(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) !
         break :blk null;
     };
-    const target = wasm.base.comp.root_mod.resolved_target.result;
     const id_symlink_basename = "lld.id";
     var man: Cache.Manifest = undefined;
 @@ -4577,7 +4627,7 @@ fn linkWithLLD(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) !
         comptime assert(Compilation.link_hash_implementation_version == 10);
-        for (wasm.base.options.objects) |obj| {
+        for (comp.objects) |obj| {
             _ = try man.addFile(obj.path, null);
             man.hash.add(obj.must_link);
         }
 @@ -4589,17 +4639,17 @@ fn linkWithLLD(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) !
         man.hash.addOptionalBytes(wasm.base.comp.config.entry);
         man.hash.add(wasm.base.stack_size);
         man.hash.add(wasm.base.build_id);
-        man.hash.add(wasm.base.options.import_memory);
+        man.hash.add(import_memory);
-        man.hash.add(wasm.base.options.export_memory);
+        man.hash.add(export_memory);
         man.hash.add(wasm.import_table);
         man.hash.add(wasm.export_table);
-        man.hash.addOptional(wasm.base.options.initial_memory);
+        man.hash.addOptional(wasm.initial_memory);
-        man.hash.addOptional(wasm.base.options.max_memory);
+        man.hash.addOptional(wasm.max_memory);
-        man.hash.add(wasm.base.options.shared_memory);
+        man.hash.add(shared_memory);
-        man.hash.addOptional(wasm.base.options.global_base);
+        man.hash.addOptional(wasm.global_base);
-        man.hash.add(wasm.base.options.export_symbol_names.len);
+        man.hash.add(wasm.export_symbol_names.len);
         // strip does not need to go into the linker hash because it is part of the hash namespace
-        for (wasm.base.options.export_symbol_names) |symbol_name| {
+        for (wasm.export_symbol_names) |symbol_name| {
             man.hash.addBytes(symbol_name);
         }
 @@ -4637,8 +4687,8 @@ fn linkWithLLD(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) !
         // here. TODO: think carefully about how we can avoid this redundant operation when doing
         // build-obj. See also the corresponding TODO in linkAsArchive.
         const the_object_path = blk: {
-            if (wasm.base.options.objects.len != 0)
+            if (comp.objects.len != 0)
-                break :blk wasm.base.options.objects[0].path;
+                break :blk comp.objects[0].path;
             if (comp.c_object_table.count() != 0)
                 break :blk comp.c_object_table.keys()[0].status.success.object_path;
 @@ -4666,19 +4716,19 @@ fn linkWithLLD(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) !
         try argv.appendSlice(&[_][]const u8{ comp.self_exe_path.?, linker_command });
         try argv.append("--error-limit=0");
-        if (wasm.base.options.lto) {
+        if (comp.config.lto) {
-            switch (wasm.base.options.optimize_mode) {
+            switch (comp.root_mod.optimize_mode) {
                 .Debug => {},
                 .ReleaseSmall => try argv.append("-O2"),
                 .ReleaseFast, .ReleaseSafe => try argv.append("-O3"),
             }
         }
-        if (wasm.base.options.import_memory) {
+        if (import_memory) {
             try argv.append("--import-memory");
         }
-        if (wasm.base.options.export_memory) {
+        if (export_memory) {
             try argv.append("--export-memory");
         }
 @@ -4698,25 +4748,25 @@ fn linkWithLLD(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) !
             try argv.append("--no-gc-sections");
         }
-        if (wasm.base.options.strip) {
+        if (wasm.base.debug_format == .strip) {
             try argv.append("-s");
         }
-        if (wasm.base.options.initial_memory) |initial_memory| {
+        if (wasm.initial_memory) |initial_memory| {
             const arg = try std.fmt.allocPrint(arena, "--initial-memory={d}", .{initial_memory});
             try argv.append(arg);
         }
-        if (wasm.base.options.max_memory) |max_memory| {
+        if (wasm.max_memory) |max_memory| {
             const arg = try std.fmt.allocPrint(arena, "--max-memory={d}", .{max_memory});
             try argv.append(arg);
         }
-        if (wasm.base.options.shared_memory) {
+        if (shared_memory) {
             try argv.append("--shared-memory");
         }
-        if (wasm.base.options.global_base) |global_base| {
+        if (wasm.global_base) |global_base| {
             const arg = try std.fmt.allocPrint(arena, "--global-base={d}", .{global_base});
             try argv.append(arg);
         } else {
 @@ -4728,16 +4778,16 @@ fn linkWithLLD(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) !
         }
         // Users are allowed to specify which symbols they want to export to the wasm host.
-        for (wasm.base.options.export_symbol_names) |symbol_name| {
+        for (wasm.export_symbol_names) |symbol_name| {
             const arg = try std.fmt.allocPrint(arena, "--export={s}", .{symbol_name});
             try argv.append(arg);
         }
-        if (wasm.base.options.rdynamic) {
+        if (wasm.rdynamic) {
             try argv.append("--export-dynamic");
         }
-        if (wasm.base.options.entry) |entry| {
+        if (comp.config.entry) |entry| {
             try argv.append("--entry");
             try argv.append(entry);
         } else {
 @@ -4749,14 +4799,14 @@ fn linkWithLLD(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) !
             try std.fmt.allocPrint(arena, "stack-size={d}", .{wasm.base.stack_size}),
         });
-        if (wasm.base.options.import_symbols) {
+        if (wasm.import_symbols) {
             try argv.append("--allow-undefined");
         }
         if (wasm.base.comp.config.output_mode == .Lib and wasm.base.comp.config.link_mode == .Dynamic) {
             try argv.append("--shared");
         }
-        if (wasm.base.options.pie) {
+        if (comp.config.pie) {
             try argv.append("--pie");
         }
 @@ -4782,15 +4832,15 @@ fn linkWithLLD(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) !
                     ));
                 }
-                if (wasm.base.options.link_libc) {
+                if (comp.config.link_libc) {
                     try argv.append(try comp.get_libc_crt_file(
                         arena,
-                        wasi_libc.execModelCrtFileFullName(wasm.base.options.wasi_exec_model),
+                        wasi_libc.execModelCrtFileFullName(comp.config.wasi_exec_model),
                     ));
                     try argv.append(try comp.get_libc_crt_file(arena, "libc.a"));
                 }
-                if (wasm.base.options.link_libcpp) {
+                if (comp.config.link_libcpp) {
                     try argv.append(comp.libcxx_static_lib.?.full_object_path);
                     try argv.append(comp.libcxxabi_static_lib.?.full_object_path);
                 }
 @@ -4799,7 +4849,7 @@ fn linkWithLLD(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) !
         // Positional arguments to the linker such as object files.
         var whole_archive = false;
-        for (wasm.base.options.objects) |obj| {
+        for (comp.objects) |obj| {
             if (obj.must_link and !whole_archive) {
                 try argv.append("-whole-archive");
                 whole_archive = true;
 @@ -4822,8 +4872,8 @@ fn linkWithLLD(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) !
         }
         if (wasm.base.comp.config.output_mode != .Obj and
-            !wasm.base.options.skip_linker_dependencies and
+            !comp.skip_linker_dependencies and
-            !wasm.base.options.link_libc)
+            !comp.config.link_libc)
         {
             try argv.append(comp.libc_static_lib.?.full_object_path);
         }
 @@ -5168,10 +5218,13 @@ fn emitDataRelocations(
 }
 fn hasPassiveInitializationSegments(wasm: *const Wasm) bool {
+    const comp = wasm.base.comp;
+    const import_memory = comp.config.import_memory;
     var it = wasm.data_segments.iterator();
     while (it.next()) |entry| {
         const segment: Segment = wasm.segments.items[entry.value_ptr.*];
-        if (segment.needsPassiveInitialization(wasm.base.options.import_memory, entry.key_ptr.*)) {
+        if (segment.needsPassiveInitialization(import_memory, entry.key_ptr.*)) {
             return true;
         }
     }
 @@ -5227,14 +5280,14 @@ fn markReferences(wasm: *Wasm) !void {
     for (wasm.resolved_symbols.keys()) |sym_loc| {
         const sym = sym_loc.getSymbol(wasm);
-        if (sym.isExported(wasm.base.options.rdynamic) or sym.isNoStrip() or !do_garbage_collect) {
+        if (sym.isExported(wasm.rdynamic) or sym.isNoStrip() or !do_garbage_collect) {
             try wasm.mark(sym_loc);
             continue;
         }
         // Debug sections may require to be parsed and marked when it contains
         // relocations to alive symbols.
-        if (sym.tag == .section and !wasm.base.options.strip) {
+        if (sym.tag == .section and wasm.base.debug_format != .strip) {
             const file = sym_loc.file orelse continue; // Incremental debug info is done independently
             const object = &wasm.objects.items[file];
             const atom_index = try Object.parseSymbolIntoAtom(object, file, sym_loc.index, wasm);

...	@@ -76,6 +76,7 @@ framework_dirs: []const []const u8,	...	@@ -76,6 +76,7 @@ framework_dirs: []const []const u8,
76	system_libs: std.StringArrayHashMapUnmanaged(SystemLib),	76	system_libs: std.StringArrayHashMapUnmanaged(SystemLib),
77	version: ?std.SemanticVersion,	77	version: ?std.SemanticVersion,
78	libc_installation: ?*const LibCInstallation,	78	libc_installation: ?*const LibCInstallation,
		79	skip_linker_dependencies: bool,
79		80
80	c_object_table: std.AutoArrayHashMapUnmanaged(*CObject, void) = .{},	81	c_object_table: std.AutoArrayHashMapUnmanaged(*CObject, void) = .{},
81	win32_resource_table: if (build_options.only_core_functionality) void else std.AutoArrayHashMapUnmanaged(*Win32Resource, void) =	82	win32_resource_table: if (build_options.only_core_functionality) void else std.AutoArrayHashMapUnmanaged(*Win32Resource, void) =
...	@@ -940,7 +941,7 @@ pub const InitOptions = struct {	...	@@ -940,7 +941,7 @@ pub const InitOptions = struct {
940	/// * getpid	941	/// * getpid
941	/// * mman	942	/// * mman
942	/// * signal	943	/// * signal
943	wasi_emulated_libs: []const wasi_libc.CRTFile = &[0]wasi_libc.CRTFile{},	944	wasi_emulated_libs: []const wasi_libc.CRTFile = &.{},
944	/// This means that if the output mode is an executable it will be a	945	/// This means that if the output mode is an executable it will be a
945	/// Position Independent Executable. If the output mode is not an	946	/// Position Independent Executable. If the output mode is not an
946	/// executable this field is ignored.	947	/// executable this field is ignored.
...	@@ -1238,7 +1239,7 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {	...	@@ -1238,7 +1239,7 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
1238	const sysroot = options.sysroot orelse libc_dirs.sysroot;	1239	const sysroot = options.sysroot orelse libc_dirs.sysroot;
1239		1240
1240	const include_compiler_rt = options.want_compiler_rt orelse	1241	const include_compiler_rt = options.want_compiler_rt orelse
1241	(!options.skip_linker_dependencies and is_exe_or_dyn_lib);	1242	(!comp.skip_linker_dependencies and is_exe_or_dyn_lib);
1242		1243
1243	if (include_compiler_rt and output_mode == .Obj) {	1244	if (include_compiler_rt and output_mode == .Obj) {
1244	// For objects, this mechanism relies on essentially `_ = @import("compiler-rt");`	1245	// For objects, this mechanism relies on essentially `_ = @import("compiler-rt");`
...	@@ -1639,6 +1640,7 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {	...	@@ -1639,6 +1640,7 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
1639	.objects = options.link_objects,	1640	.objects = options.link_objects,
1640	.framework_dirs = options.framework_dirs,	1641	.framework_dirs = options.framework_dirs,
1641	.llvm_opt_bisect_limit = options.llvm_opt_bisect_limit,	1642	.llvm_opt_bisect_limit = options.llvm_opt_bisect_limit,
		1643	.skip_linker_dependencies = options.skip_linker_dependencies,
1642	};	1644	};
1643		1645
1644	if (bin_file_emit) \|emit\| {	1646	if (bin_file_emit) \|emit\| {
...	@@ -1695,7 +1697,6 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {	...	@@ -1695,7 +1697,6 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
1695	.soname = options.soname,	1697	.soname = options.soname,
1696	.compatibility_version = options.compatibility_version,	1698	.compatibility_version = options.compatibility_version,
1697	.dll_export_fns = dll_export_fns,	1699	.dll_export_fns = dll_export_fns,
1698	.skip_linker_dependencies = options.skip_linker_dependencies,
1699	.parent_compilation_link_libc = options.parent_compilation_link_libc,	1700	.parent_compilation_link_libc = options.parent_compilation_link_libc,
1700	.each_lib_rpath = each_lib_rpath,	1701	.each_lib_rpath = each_lib_rpath,
1701	.build_id = build_id,	1702	.build_id = build_id,
...	@@ -1765,9 +1766,9 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {	...	@@ -1765,9 +1766,9 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
1765	}	1766	}
1766	}	1767	}
1767		1768
1768	const have_bin_emit = comp.bin_file.options.emit != null or comp.whole_bin_sub_path != null;	1769	const have_bin_emit = comp.bin_file != null or comp.whole_bin_sub_path != null;
1769		1770
1770	if (have_bin_emit and !comp.bin_file.options.skip_linker_dependencies and target.ofmt != .c) {	1771	if (have_bin_emit and !comp.skip_linker_dependencies and target.ofmt != .c) {
1771	if (target.isDarwin()) {	1772	if (target.isDarwin()) {
1772	switch (target.abi) {	1773	switch (target.abi) {
1773	.none,	1774	.none,
...	@@ -1808,27 +1809,34 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {	...	@@ -1808,27 +1809,34 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
1808	.{ .musl_crt_file = .crt1_o },	1809	.{ .musl_crt_file = .crt1_o },
1809	.{ .musl_crt_file = .scrt1_o },	1810	.{ .musl_crt_file = .scrt1_o },
1810	.{ .musl_crt_file = .rcrt1_o },	1811	.{ .musl_crt_file = .rcrt1_o },
1811	switch (comp.bin_file.options.link_mode) {	1812	switch (comp.config.link_mode) {
1812	.Static => .{ .musl_crt_file = .libc_a },	1813	.Static => .{ .musl_crt_file = .libc_a },
1813	.Dynamic => .{ .musl_crt_file = .libc_so },	1814	.Dynamic => .{ .musl_crt_file = .libc_so },
1814	},	1815	},
1815	});	1816	});
1816	}	1817	}
1817	if (comp.wantBuildWasiLibcFromSource()) {
1818	if (!target_util.canBuildLibC(target)) return error.LibCUnavailable;
1819		1818
1820	const wasi_emulated_libs = comp.bin_file.options.wasi_emulated_libs;	1819	if (comp.bin_file) \|lf\| {
1821	try comp.work_queue.ensureUnusedCapacity(wasi_emulated_libs.len + 2); // worst-case we need all components	1820	if (lf.cast(link.File.Wasm)) \|wasm\| {
1822	for (wasi_emulated_libs) \|crt_file\| {	1821	if (comp.wantBuildWasiLibcFromSource()) {
1823	comp.work_queue.writeItemAssumeCapacity(.{	1822	if (!target_util.canBuildLibC(target)) return error.LibCUnavailable;
1824	.wasi_libc_crt_file = crt_file,	1823
1825	});	1824	// worst-case we need all components
		1825	try comp.work_queue.ensureUnusedCapacity(wasm.wasi_emulated_libs.len + 2);
		1826
		1827	for (wasm.wasi_emulated_libs) \|crt_file\| {
		1828	comp.work_queue.writeItemAssumeCapacity(.{
		1829	.wasi_libc_crt_file = crt_file,
		1830	});
		1831	}
		1832	comp.work_queue.writeAssumeCapacity(&[_]Job{
		1833	.{ .wasi_libc_crt_file = wasi_libc.execModelCrtFile(options.config.wasi_exec_model) },
		1834	.{ .wasi_libc_crt_file = .libc_a },
		1835	});
		1836	}
1826	}	1837	}
1827	comp.work_queue.writeAssumeCapacity(&[_]Job{
1828	.{ .wasi_libc_crt_file = wasi_libc.execModelCrtFile(options.config.wasi_exec_model) },
1829	.{ .wasi_libc_crt_file = .libc_a },
1830	});
1831	}	1838	}
		1839
1832	if (comp.wantBuildMinGWFromSource()) {	1840	if (comp.wantBuildMinGWFromSource()) {
1833	if (!target_util.canBuildLibC(target)) return error.LibCUnavailable;	1841	if (!target_util.canBuildLibC(target)) return error.LibCUnavailable;
1834		1842
...	@@ -1863,27 +1871,29 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {	...	@@ -1863,27 +1871,29 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
1863	if (comp.wantBuildLibUnwindFromSource()) {	1871	if (comp.wantBuildLibUnwindFromSource()) {
1864	try comp.work_queue.writeItem(.{ .libunwind = {} });	1872	try comp.work_queue.writeItem(.{ .libunwind = {} });
1865	}	1873	}
1866	if (build_options.have_llvm and is_exe_or_dyn_lib and comp.bin_file.options.link_libcpp) {	1874	if (build_options.have_llvm and is_exe_or_dyn_lib and comp.config.link_libcpp) {
1867	try comp.work_queue.writeItem(.libcxx);	1875	try comp.work_queue.writeItem(.libcxx);
1868	try comp.work_queue.writeItem(.libcxxabi);	1876	try comp.work_queue.writeItem(.libcxxabi);
1869	}	1877	}
1870	if (build_options.have_llvm and comp.bin_file.options.tsan) {	1878	if (build_options.have_llvm and comp.config.any_sanitize_thread) {
1871	try comp.work_queue.writeItem(.libtsan);	1879	try comp.work_queue.writeItem(.libtsan);
1872	}	1880	}
1873		1881
1874	if (comp.getTarget().isMinGW() and comp.config.any_non_single_threaded) {	1882	if (comp.bin_file) \|lf\| {
1875	// LLD might drop some symbols as unused during LTO and GCing, therefore,	1883	if (comp.getTarget().isMinGW() and comp.config.any_non_single_threaded) {
1876	// we force mark them for resolution here.	1884	// LLD might drop some symbols as unused during LTO and GCing, therefore,
		1885	// we force mark them for resolution here.
1877		1886
1878	const tls_index_sym = switch (comp.getTarget().cpu.arch) {	1887	const tls_index_sym = switch (comp.getTarget().cpu.arch) {
1879	.x86 => "__tls_index",	1888	.x86 => "__tls_index",
1880	else => "_tls_index",	1889	else => "_tls_index",
1881	};	1890	};
1882		1891
1883	try comp.bin_file.options.force_undefined_symbols.put(comp.gpa, tls_index_sym, {});	1892	try lf.force_undefined_symbols.put(comp.gpa, tls_index_sym, {});
		1893	}
1884	}	1894	}
1885		1895
1886	if (comp.bin_file.options.include_compiler_rt and capable_of_building_compiler_rt) {	1896	if (comp.include_compiler_rt and capable_of_building_compiler_rt) {
1887	if (is_exe_or_dyn_lib) {	1897	if (is_exe_or_dyn_lib) {
1888	log.debug("queuing a job to build compiler_rt_lib", .{});	1898	log.debug("queuing a job to build compiler_rt_lib", .{});
1889	comp.job_queued_compiler_rt_lib = true;	1899	comp.job_queued_compiler_rt_lib = true;
...	@@ -1895,8 +1905,8 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {	...	@@ -1895,8 +1905,8 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
1895	}	1905	}
1896	}	1906	}
1897		1907
1898	if (!comp.bin_file.options.skip_linker_dependencies and is_exe_or_dyn_lib and	1908	if (!comp.skip_linker_dependencies and is_exe_or_dyn_lib and
1899	!comp.bin_file.options.link_libc and capable_of_building_zig_libc)	1909	!comp.config.link_libc and capable_of_building_zig_libc)
1900	{	1910	{
1901	try comp.work_queue.writeItem(.{ .zig_libc = {} });	1911	try comp.work_queue.writeItem(.{ .zig_libc = {} });
1902	}	1912	}
...	@@ -2425,7 +2435,7 @@ fn addNonIncrementalStuffToCacheManifest(comp: Compilation, man: Cache.Manifes	...	@@ -2425,7 +2435,7 @@ fn addNonIncrementalStuffToCacheManifest(comp: Compilation, man: Cache.Manifes
2425	man.hash.add(comp.test_evented_io);	2435	man.hash.add(comp.test_evented_io);
2426	man.hash.addOptionalBytes(comp.test_filter);	2436	man.hash.addOptionalBytes(comp.test_filter);
2427	man.hash.addOptionalBytes(comp.test_name_prefix);	2437	man.hash.addOptionalBytes(comp.test_name_prefix);
2428	man.hash.add(comp.bin_file.options.skip_linker_dependencies);	2438	man.hash.add(comp.skip_linker_dependencies);
2429	man.hash.add(comp.formatted_panics);	2439	man.hash.add(comp.formatted_panics);
2430	man.hash.add(mod.emit_h != null);	2440	man.hash.add(mod.emit_h != null);
2431	man.hash.add(mod.error_limit);	2441	man.hash.add(mod.error_limit);
...	@@ -2477,7 +2487,7 @@ fn addNonIncrementalStuffToCacheManifest(comp: Compilation, man: Cache.Manifes	...	@@ -2477,7 +2487,7 @@ fn addNonIncrementalStuffToCacheManifest(comp: Compilation, man: Cache.Manifes
2477	man.hash.addListOfBytes(comp.bin_file.options.symbol_wrap_set.keys());	2487	man.hash.addListOfBytes(comp.bin_file.options.symbol_wrap_set.keys());
2478	man.hash.add(comp.bin_file.options.each_lib_rpath);	2488	man.hash.add(comp.bin_file.options.each_lib_rpath);
2479	man.hash.add(comp.bin_file.build_id);	2489	man.hash.add(comp.bin_file.build_id);
2480	man.hash.add(comp.bin_file.options.skip_linker_dependencies);	2490	man.hash.add(comp.skip_linker_dependencies);
2481	man.hash.add(comp.bin_file.options.z_nodelete);	2491	man.hash.add(comp.bin_file.options.z_nodelete);
2482	man.hash.add(comp.bin_file.options.z_notext);	2492	man.hash.add(comp.bin_file.options.z_notext);
2483	man.hash.add(comp.bin_file.options.z_defs);	2493	man.hash.add(comp.bin_file.options.z_defs);
...	@@ -2489,7 +2499,7 @@ fn addNonIncrementalStuffToCacheManifest(comp: Compilation, man: Cache.Manifes	...	@@ -2489,7 +2499,7 @@ fn addNonIncrementalStuffToCacheManifest(comp: Compilation, man: Cache.Manifes
2489	man.hash.add(comp.bin_file.options.z_max_page_size orelse 0);	2499	man.hash.add(comp.bin_file.options.z_max_page_size orelse 0);
2490	man.hash.add(comp.bin_file.options.hash_style);	2500	man.hash.add(comp.bin_file.options.hash_style);
2491	man.hash.add(comp.bin_file.options.compress_debug_sections);	2501	man.hash.add(comp.bin_file.options.compress_debug_sections);
2492	man.hash.add(comp.bin_file.options.include_compiler_rt);	2502	man.hash.add(comp.include_compiler_rt);
2493	man.hash.add(comp.bin_file.options.sort_section);	2503	man.hash.add(comp.bin_file.options.sort_section);
2494	if (comp.config.link_libc) {	2504	if (comp.config.link_libc) {
2495	man.hash.add(comp.bin_file.options.libc_installation != null);	2505	man.hash.add(comp.bin_file.options.libc_installation != null);
...	@@ -3836,7 +3846,7 @@ pub fn obtainCObjectCacheManifest(comp: *const Compilation) Cache.Manifest {	...	@@ -3836,7 +3846,7 @@ pub fn obtainCObjectCacheManifest(comp: *const Compilation) Cache.Manifest {
3836	// Also nothing that applies only to compiling .zig code.	3846	// Also nothing that applies only to compiling .zig code.
3837	man.hash.add(comp.sanitize_c);	3847	man.hash.add(comp.sanitize_c);
3838	man.hash.addListOfBytes(comp.clang_argv);	3848	man.hash.addListOfBytes(comp.clang_argv);
3839	man.hash.add(comp.bin_file.options.link_libcpp);	3849	man.hash.add(comp.config.link_libcpp);
3840		3850
3841	// When libc_installation is null it means that Zig generated this dir list	3851	// When libc_installation is null it means that Zig generated this dir list
3842	// based on the zig library directory alone. The zig lib directory file	3852	// based on the zig library directory alone. The zig lib directory file
...	@@ -4909,7 +4919,7 @@ pub fn addCCArgs(	...	@@ -4909,7 +4919,7 @@ pub fn addCCArgs(
4909	try argv.append("-fno-builtin");	4919	try argv.append("-fno-builtin");
4910	}	4920	}
4911		4921
4912	if (comp.bin_file.options.link_libcpp) {	4922	if (comp.config.link_libcpp) {
4913	const libcxx_include_path = try std.fs.path.join(arena, &[_][]const u8{	4923	const libcxx_include_path = try std.fs.path.join(arena, &[_][]const u8{
4914	comp.zig_lib_directory.path.?, "libcxx", "include",	4924	comp.zig_lib_directory.path.?, "libcxx", "include",
4915	});	4925	});
...	@@ -4954,7 +4964,7 @@ pub fn addCCArgs(	...	@@ -4954,7 +4964,7 @@ pub fn addCCArgs(
4954	try argv.append(libunwind_include_path);	4964	try argv.append(libunwind_include_path);
4955	}	4965	}
4956		4966
4957	if (comp.bin_file.options.link_libc and target.isGnuLibC()) {	4967	if (comp.config.link_libc and target.isGnuLibC()) {
4958	const target_version = target.os.version_range.linux.glibc;	4968	const target_version = target.os.version_range.linux.glibc;
4959	const glibc_minor_define = try std.fmt.allocPrint(arena, "-D__GLIBC_MINOR__={d}", .{	4969	const glibc_minor_define = try std.fmt.allocPrint(arena, "-D__GLIBC_MINOR__={d}", .{
4960	target_version.minor,	4970	target_version.minor,
...	@@ -5944,7 +5954,7 @@ fn wantBuildLibCFromSource(comp: Compilation) bool {	...	@@ -5944,7 +5954,7 @@ fn wantBuildLibCFromSource(comp: Compilation) bool {
5944	.Lib => comp.bin_file.options.link_mode == .Dynamic,	5954	.Lib => comp.bin_file.options.link_mode == .Dynamic,
5945	.Exe => true,	5955	.Exe => true,
5946	};	5956	};
5947	return comp.bin_file.options.link_libc and is_exe_or_dyn_lib and	5957	return comp.config.link_libc and is_exe_or_dyn_lib and
5948	comp.bin_file.options.libc_installation == null and	5958	comp.bin_file.options.libc_installation == null and
5949	comp.bin_file.options.target.ofmt != .c;	5959	comp.bin_file.options.target.ofmt != .c;
5950	}	5960	}
...	@@ -6164,6 +6174,7 @@ fn buildOutputFromZig(	...	@@ -6164,6 +6174,7 @@ fn buildOutputFromZig(
6164	.have_zcu = true,	6174	.have_zcu = true,
6165	.emit_bin = true,	6175	.emit_bin = true,
6166	.root_optimize_mode = comp.compilerRtOptMode(),	6176	.root_optimize_mode = comp.compilerRtOptMode(),
		6177	.link_libc = comp.config.link_libc,
6167	});	6178	});
6168		6179
6169	const root_mod = Package.Module.create(.{	6180	const root_mod = Package.Module.create(.{
...	@@ -6224,7 +6235,6 @@ fn buildOutputFromZig(	...	@@ -6224,7 +6235,6 @@ fn buildOutputFromZig(
6224	.verbose_llvm_cpu_features = comp.verbose_llvm_cpu_features,	6235	.verbose_llvm_cpu_features = comp.verbose_llvm_cpu_features,
6225	.clang_passthrough_mode = comp.clang_passthrough_mode,	6236	.clang_passthrough_mode = comp.clang_passthrough_mode,
6226	.skip_linker_dependencies = true,	6237	.skip_linker_dependencies = true,
6227	.link_libc = comp.bin_file.options.link_libc,
6228	.want_structured_cfg = comp.bin_file.options.want_structured_cfg,	6238	.want_structured_cfg = comp.bin_file.options.want_structured_cfg,
6229	});	6239	});
6230	defer sub_compilation.destroy();	6240	defer sub_compilation.destroy();
...	@@ -6305,7 +6315,6 @@ pub fn build_crt_file(	...	@@ -6305,7 +6315,6 @@ pub fn build_crt_file(
6305	.verbose_llvm_cpu_features = comp.verbose_llvm_cpu_features,	6315	.verbose_llvm_cpu_features = comp.verbose_llvm_cpu_features,
6306	.clang_passthrough_mode = comp.clang_passthrough_mode,	6316	.clang_passthrough_mode = comp.clang_passthrough_mode,
6307	.skip_linker_dependencies = true,	6317	.skip_linker_dependencies = true,
6308	.link_libc = comp.bin_file.options.link_libc,
6309	.want_structured_cfg = comp.bin_file.options.want_structured_cfg,	6318	.want_structured_cfg = comp.bin_file.options.want_structured_cfg,
6310	});	6319	});
6311	defer sub_compilation.destroy();	6320	defer sub_compilation.destroy();
...	@@ -6327,7 +6336,7 @@ pub fn addLinkLib(comp: *Compilation, lib_name: []const u8) !void {	...	@@ -6327,7 +6336,7 @@ pub fn addLinkLib(comp: *Compilation, lib_name: []const u8) !void {
6327	// This can happen when the user uses `build-exe foo.obj -lkernel32` and	6336	// This can happen when the user uses `build-exe foo.obj -lkernel32` and
6328	// then when we create a sub-Compilation for zig libc, it also tries to	6337	// then when we create a sub-Compilation for zig libc, it also tries to
6329	// build kernel32.lib.	6338	// build kernel32.lib.
6330	if (comp.bin_file.options.skip_linker_dependencies) return;	6339	if (comp.skip_linker_dependencies) return;
6331		6340
6332	// This happens when an `extern "foo"` function is referenced.	6341	// This happens when an `extern "foo"` function is referenced.
6333	// If we haven't seen this library yet and we're targeting Windows, we need	6342	// If we haven't seen this library yet and we're targeting Windows, we need

...	@@ -32,7 +32,7 @@ pub const DynamicSection = struct {	...	@@ -32,7 +32,7 @@ pub const DynamicSection = struct {
32	fn getFlags(dt: DynamicSection, elf_file: *Elf) ?u64 {	32	fn getFlags(dt: DynamicSection, elf_file: *Elf) ?u64 {
33	_ = dt;	33	_ = dt;
34	var flags: u64 = 0;	34	var flags: u64 = 0;
35	if (elf_file.base.options.z_now) {	35	if (elf_file.z_now) {
36	flags \|= elf.DF_BIND_NOW;	36	flags \|= elf.DF_BIND_NOW;
37	}	37	}
38	for (elf_file.got.entries.items) \|entry\| switch (entry.tag) {	38	for (elf_file.got.entries.items) \|entry\| switch (entry.tag) {
...	@@ -49,15 +49,16 @@ pub const DynamicSection = struct {	...	@@ -49,15 +49,16 @@ pub const DynamicSection = struct {
49	}	49	}
50		50
51	fn getFlags1(dt: DynamicSection, elf_file: *Elf) ?u64 {	51	fn getFlags1(dt: DynamicSection, elf_file: *Elf) ?u64 {
		52	const comp = elf_file.base.comp;
52	_ = dt;	53	_ = dt;
53	var flags_1: u64 = 0;	54	var flags_1: u64 = 0;
54	if (elf_file.base.options.z_now) {	55	if (elf_file.z_now) {
55	flags_1 \|= elf.DF_1_NOW;	56	flags_1 \|= elf.DF_1_NOW;
56	}	57	}
57	if (elf_file.isExe() and elf_file.base.options.pie) {	58	if (elf_file.isExe() and comp.config.pie) {
58	flags_1 \|= elf.DF_1_PIE;	59	flags_1 \|= elf.DF_1_PIE;
59	}	60	}
60	// if (elf_file.base.options.z_nodlopen) {	61	// if (elf_file.z_nodlopen) {
61	// flags_1 \|= elf.DF_1_NOOPEN;	62	// flags_1 \|= elf.DF_1_NOOPEN;
62	// }	63	// }
63	return if (flags_1 > 0) flags_1 else null;	64	return if (flags_1 > 0) flags_1 else null;
...	@@ -246,12 +247,13 @@ pub const ZigGotSection = struct {	...	@@ -246,12 +247,13 @@ pub const ZigGotSection = struct {
246	}	247	}
247		248
248	pub fn addSymbol(zig_got: ZigGotSection, sym_index: Symbol.Index, elf_file: Elf) !Index {	249	pub fn addSymbol(zig_got: ZigGotSection, sym_index: Symbol.Index, elf_file: Elf) !Index {
		250	const comp = elf_file.base.comp;
249	const index = try zig_got.allocateEntry(elf_file.base.allocator);	251	const index = try zig_got.allocateEntry(elf_file.base.allocator);
250	const entry = &zig_got.entries.items[index];	252	const entry = &zig_got.entries.items[index];
251	entry.* = sym_index;	253	entry.* = sym_index;
252	const symbol = elf_file.symbol(sym_index);	254	const symbol = elf_file.symbol(sym_index);
253	symbol.flags.has_zig_got = true;	255	symbol.flags.has_zig_got = true;
254	if (elf_file.isDynLib() or (elf_file.isExe() and elf_file.base.options.pie)) {	256	if (elf_file.isDynLib() or (elf_file.isExe() and comp.config.pie)) {
255	zig_got.flags.needs_rela = true;	257	zig_got.flags.needs_rela = true;
256	}	258	}
257	if (symbol.extra(elf_file)) \|extra\| {	259	if (symbol.extra(elf_file)) \|extra\| {
...	@@ -478,6 +480,7 @@ pub const GotSection = struct {	...	@@ -478,6 +480,7 @@ pub const GotSection = struct {
478	}	480	}
479		481
480	pub fn addGotSymbol(got: GotSection, sym_index: Symbol.Index, elf_file: Elf) !Index {	482	pub fn addGotSymbol(got: GotSection, sym_index: Symbol.Index, elf_file: Elf) !Index {
		483	const comp = elf_file.base.comp;
481	const index = try got.allocateEntry(elf_file.base.allocator);	484	const index = try got.allocateEntry(elf_file.base.allocator);
482	const entry = &got.entries.items[index];	485	const entry = &got.entries.items[index];
483	entry.tag = .got;	486	entry.tag = .got;
...	@@ -485,7 +488,7 @@ pub const GotSection = struct {	...	@@ -485,7 +488,7 @@ pub const GotSection = struct {
485	const symbol = elf_file.symbol(sym_index);	488	const symbol = elf_file.symbol(sym_index);
486	symbol.flags.has_got = true;	489	symbol.flags.has_got = true;
487	if (symbol.flags.import or symbol.isIFunc(elf_file) or	490	if (symbol.flags.import or symbol.isIFunc(elf_file) or
488	((elf_file.isDynLib() or (elf_file.isExe() and elf_file.base.options.pie)) and !symbol.isAbs(elf_file)))	491	((elf_file.isDynLib() or (elf_file.isExe() and comp.config.pie)) and !symbol.isAbs(elf_file)))
489	{	492	{
490	got.flags.needs_rela = true;	493	got.flags.needs_rela = true;
491	}	494	}
...	@@ -561,6 +564,7 @@ pub const GotSection = struct {	...	@@ -561,6 +564,7 @@ pub const GotSection = struct {
561	}	564	}
562		565
563	pub fn write(got: GotSection, elf_file: *Elf, writer: anytype) !void {	566	pub fn write(got: GotSection, elf_file: *Elf, writer: anytype) !void {
		567	const comp = elf_file.base.comp;
564	const is_dyn_lib = elf_file.isDynLib();	568	const is_dyn_lib = elf_file.isDynLib();
565	const apply_relocs = true; // TODO add user option for this	569	const apply_relocs = true; // TODO add user option for this
566		570
...	@@ -576,7 +580,7 @@ pub const GotSection = struct {	...	@@ -576,7 +580,7 @@ pub const GotSection = struct {
576	if (symbol.?.flags.import) break :blk 0;	580	if (symbol.?.flags.import) break :blk 0;
577	if (symbol.?.isIFunc(elf_file))	581	if (symbol.?.isIFunc(elf_file))
578	break :blk if (apply_relocs) value else 0;	582	break :blk if (apply_relocs) value else 0;
579	if ((elf_file.isDynLib() or (elf_file.isExe() and elf_file.base.options.pie)) and	583	if ((elf_file.isDynLib() or (elf_file.isExe() and comp.config.pie)) and
580	!symbol.?.isAbs(elf_file))	584	!symbol.?.isAbs(elf_file))
581	{	585	{
582	break :blk if (apply_relocs) value else 0;	586	break :blk if (apply_relocs) value else 0;
...	@@ -623,6 +627,7 @@ pub const GotSection = struct {	...	@@ -623,6 +627,7 @@ pub const GotSection = struct {
623	}	627	}
624		628
625	pub fn addRela(got: GotSection, elf_file: *Elf) !void {	629	pub fn addRela(got: GotSection, elf_file: *Elf) !void {
		630	const comp = elf_file.base.comp;
626	const is_dyn_lib = elf_file.isDynLib();	631	const is_dyn_lib = elf_file.isDynLib();
627	try elf_file.rela_dyn.ensureUnusedCapacity(elf_file.base.allocator, got.numRela(elf_file));	632	try elf_file.rela_dyn.ensureUnusedCapacity(elf_file.base.allocator, got.numRela(elf_file));
628		633
...	@@ -652,7 +657,7 @@ pub const GotSection = struct {	...	@@ -652,7 +657,7 @@ pub const GotSection = struct {
652	});	657	});
653	continue;	658	continue;
654	}	659	}
655	if ((elf_file.isDynLib() or (elf_file.isExe() and elf_file.base.options.pie)) and	660	if ((elf_file.isDynLib() or (elf_file.isExe() and comp.config.pie)) and
656	!symbol.?.isAbs(elf_file))	661	!symbol.?.isAbs(elf_file))
657	{	662	{
658	elf_file.addRelaDynAssumeCapacity(.{	663	elf_file.addRelaDynAssumeCapacity(.{
...	@@ -725,6 +730,7 @@ pub const GotSection = struct {	...	@@ -725,6 +730,7 @@ pub const GotSection = struct {
725	}	730	}
726		731
727	pub fn numRela(got: GotSection, elf_file: *Elf) usize {	732	pub fn numRela(got: GotSection, elf_file: *Elf) usize {
		733	const comp = elf_file.base.comp;
728	const is_dyn_lib = elf_file.isDynLib();	734	const is_dyn_lib = elf_file.isDynLib();
729	var num: usize = 0;	735	var num: usize = 0;
730	for (got.entries.items) \|entry\| {	736	for (got.entries.items) \|entry\| {
...	@@ -734,7 +740,7 @@ pub const GotSection = struct {	...	@@ -734,7 +740,7 @@ pub const GotSection = struct {
734	};	740	};
735	switch (entry.tag) {	741	switch (entry.tag) {
736	.got => if (symbol.?.flags.import or symbol.?.isIFunc(elf_file) or	742	.got => if (symbol.?.flags.import or symbol.?.isIFunc(elf_file) or
737	((elf_file.isDynLib() or (elf_file.isExe() and elf_file.base.options.pie)) and	743	((elf_file.isDynLib() or (elf_file.isExe() and comp.config.pie)) and
738	!symbol.?.isAbs(elf_file)))	744	!symbol.?.isAbs(elf_file)))
739	{	745	{
740	num += 1;	746	num += 1;

...	@@ -198,10 +198,10 @@ fn findFreeSpace(self: *DebugSymbols, object_size: u64, min_alignment: u64) u64	...	@@ -198,10 +198,10 @@ fn findFreeSpace(self: *DebugSymbols, object_size: u64, min_alignment: u64) u64
198	}	198	}
199		199
200	pub fn flushModule(self: DebugSymbols, macho_file: MachO) !void {	200	pub fn flushModule(self: DebugSymbols, macho_file: MachO) !void {
		201	const comp = macho_file.base.comp;
201	// TODO This linker code currently assumes there is only 1 compilation unit	202	// TODO This linker code currently assumes there is only 1 compilation unit
202	// and it corresponds to the Zig source code.	203	// and it corresponds to the Zig source code.
203	const options = macho_file.base.options;	204	const zcu = comp.module orelse return error.LinkingWithoutZigSourceUnimplemented;
204	const module = options.module orelse return error.LinkingWithoutZigSourceUnimplemented;
205		205
206	for (self.relocs.items) \|*reloc\| {	206	for (self.relocs.items) \|*reloc\| {
207	const sym = switch (reloc.type) {	207	const sym = switch (reloc.type) {
...	@@ -245,7 +245,7 @@ pub fn flushModule(self: DebugSymbols, macho_file: MachO) !void {	...	@@ -245,7 +245,7 @@ pub fn flushModule(self: DebugSymbols, macho_file: MachO) !void {
245	const text_section = macho_file.sections.items(.header)[macho_file.text_section_index.?];	245	const text_section = macho_file.sections.items(.header)[macho_file.text_section_index.?];
246	const low_pc = text_section.addr;	246	const low_pc = text_section.addr;
247	const high_pc = text_section.addr + text_section.size;	247	const high_pc = text_section.addr + text_section.size;
248	try self.dwarf.writeDbgInfoHeader(module, low_pc, high_pc);	248	try self.dwarf.writeDbgInfoHeader(zcu, low_pc, high_pc);
249	self.debug_info_header_dirty = false;	249	self.debug_info_header_dirty = false;
250	}	250	}
251		251
...	@@ -572,6 +572,5 @@ const trace = @import("../../tracy.zig").trace;	...	@@ -572,6 +572,5 @@ const trace = @import("../../tracy.zig").trace;
572	const Allocator = mem.Allocator;	572	const Allocator = mem.Allocator;
573	const Dwarf = @import("../Dwarf.zig");	573	const Dwarf = @import("../Dwarf.zig");
574	const MachO = @import("../MachO.zig");	574	const MachO = @import("../MachO.zig");
575	const Module = @import("../../Module.zig");
576	const StringTable = @import("../StringTable.zig");	575	const StringTable = @import("../StringTable.zig");
577	const Type = @import("../../type.zig").Type;	576	const Type = @import("../../type.zig").Type;