Commit c49957dbe82d7f0db555160b50306335bfa03165 | zig

src/Compilation.zig+95-58

 @@ -884,12 +884,32 @@ const CacheUse = union(CacheMode) {
         docs_sub_path: ?[]u8,
         lf_open_opts: link.File.OpenOptions,
         tmp_artifact_directory: ?Cache.Directory,
+        /// Prevents other processes from clobbering files in the output directory.
+        lock: ?Cache.Lock,
+        fn releaseLock(whole: *Whole) void {
+            if (whole.lock) |*lock| {
+                lock.release();
+                whole.lock = null;
+            }
+        }
     };
     const Incremental = struct {
         /// Where build artifacts and incremental compilation metadata serialization go.
         artifact_directory: Compilation.Directory,
     };
+    fn deinit(cu: CacheUse) void {
+        switch (cu) {
+            .incremental => |incremental| {
+                incremental.artifact_directory.handle.close();
+            },
+            .whole => |whole| {
+                whole.releaseLock();
+            },
+        }
+    }
 };
 pub const LinkObject = struct {
 @@ -916,7 +936,7 @@ pub const InitOptions = struct {
     /// Normally, `main_mod` and `root_mod` are the same. The exception is `zig
     /// test`, in which `root_mod` is the test runner, and `main_mod` is the
     /// user's source file which has the tests.
-    main_mod: ?*Package.Module,
+    main_mod: ?*Package.Module = null,
     /// This is provided so that the API user has a chance to tweak the
     /// per-module settings of the standard library.
     std_mod: *Package.Module,
 @@ -1615,6 +1635,7 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
                     .implib_sub_path = try prepareWholeEmitSubPath(arena, options.emit_implib),
                     .docs_sub_path = try prepareWholeEmitSubPath(arena, options.emit_docs),
                     .tmp_artifact_directory = null,
+                    .lock = null,
                 };
                 comp.cache_use = .{ .whole = whole };
             },
 @@ -1822,13 +1843,7 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
 pub fn destroy(self: *Compilation) void {
     if (self.bin_file) |lf| lf.destroy();
     if (self.module) |zcu| zcu.deinit();
-    switch (self.cache_use) {
+    self.cache_use.deinit();
-        .incremental => |incremental| {
-            incremental.artifact_directory.handle.close();
-        },
-        .whole => {},
-    }
     self.work_queue.deinit();
     self.anon_work_queue.deinit();
     self.c_object_work_queue.deinit();
 @@ -1922,11 +1937,17 @@ pub fn getTarget(self: Compilation) Target {
     return self.root_mod.resolved_target.result;
 }
-pub fn hotCodeSwap(comp: *Compilation, prog_node: *std.Progress.Node, pid: std.ChildProcess.Id) !void {
+/// Only legal to call when cache mode is incremental and a link file is present.
-    comp.bin_file.child_pid = pid;
+pub fn hotCodeSwap(
-    try comp.makeBinFileWritable();
+    comp: *Compilation,
+    prog_node: *std.Progress.Node,
+    pid: std.ChildProcess.Id,
+) !void {
+    const lf = comp.bin_file.?;
+    lf.child_pid = pid;
+    try lf.makeWritable();
     try comp.update(prog_node);
-    try comp.makeBinFileExecutable();
+    try lf.makeExecutable();
 }
 fn cleanupAfterUpdate(comp: *Compilation) void {
 @@ -1941,7 +1962,7 @@ fn cleanupAfterUpdate(comp: *Compilation) void {
                 lf.destroy();
                 comp.bin_file = null;
             }
-            if (whole.tmp_artifact_directory) |directory| {
+            if (whole.tmp_artifact_directory) |*directory| {
                 directory.handle.close();
                 if (directory.path) |p| comp.gpa.free(p);
                 whole.tmp_artifact_directory = null;
 @@ -1967,8 +1988,9 @@ pub fn update(comp: *Compilation, main_progress_node: *std.Progress.Node) !void
     // C source files.
     switch (comp.cache_use) {
         .whole => |whole| {
-            // We are about to obtain this lock, so here we give other processes a chance first.
             assert(comp.bin_file == null);
+            // We are about to obtain this lock, so here we give other processes a chance first.
+            whole.releaseLock();
             man = comp.cache_parent.obtain();
             whole.cache_manifest = &man;
 @@ -1989,8 +2011,8 @@ pub fn update(comp: *Compilation, main_progress_node: *std.Progress.Node) !void
                 comp.wholeCacheModeSetBinFilePath(whole, &digest);
-                assert(comp.bin_file.lock == null);
+                assert(whole.lock == null);
-                comp.bin_file.lock = man.toOwnedLock();
+                whole.lock = man.toOwnedLock();
                 return;
             }
             log.debug("CacheMode.whole cache miss for {s}", .{comp.root_name});
 @@ -2158,7 +2180,7 @@ pub fn update(comp: *Compilation, main_progress_node: *std.Progress.Node) !void
             // Rename the temporary directory into place.
             // Close tmp dir and link.File to avoid open handle during rename.
-            if (whole.tmp_artifact_directory) |tmp_directory| {
+            if (whole.tmp_artifact_directory) |*tmp_directory| {
                 tmp_directory.handle.close();
                 if (tmp_directory.path) |p| comp.gpa.free(p);
                 whole.tmp_artifact_directory = null;
 @@ -2181,8 +2203,8 @@ pub fn update(comp: *Compilation, main_progress_node: *std.Progress.Node) !void
                 log.warn("failed to write cache manifest: {s}", .{@errorName(err)});
             };
-            assert(comp.bin_file.lock == null);
+            assert(whole.lock == null);
-            comp.bin_file.lock = man.toOwnedLock();
+            whole.lock = man.toOwnedLock();
         },
         .incremental => {},
     }
 @@ -2263,13 +2285,15 @@ fn maybeGenerateAutodocs(comp: *Compilation, prog_node: *std.Progress.Node) !voi
 }
 fn flush(comp: *Compilation, prog_node: *std.Progress.Node) !void {
-    // This is needed before reading the error flags.
+    if (comp.bin_file) |lf| {
-    comp.bin_file.flush(comp, prog_node) catch |err| switch (err) {
+        // This is needed before reading the error flags.
-        error.FlushFailure => {}, // error reported through link_error_flags
+        lf.flush(comp, prog_node) catch |err| switch (err) {
-        error.LLDReportedFailure => {}, // error reported via lockAndParseLldStderr
+            error.FlushFailure => {}, // error reported through link_error_flags
-        else => |e| return e,
+            error.LLDReportedFailure => {}, // error reported via lockAndParseLldStderr
-    };
+            else => |e| return e,
-    comp.link_error_flags = comp.bin_file.errorFlags();
+        };
+        comp.link_error_flags = lf.error_flags;
+    }
     if (comp.module) |module| {
         try link.File.C.flushEmitH(module);
 @@ -2445,9 +2469,9 @@ fn addNonIncrementalStuffToCacheManifest(comp: *Compilation, man: *Cache.Manifes
             .wasm => {
                 const wasm = lf.cast(link.File.Wasm).?;
                 man.hash.add(wasm.rdynamic);
-                man.hash.add(wasm.initial_memory);
+                man.hash.addOptional(wasm.initial_memory);
-                man.hash.add(wasm.max_memory);
+                man.hash.addOptional(wasm.max_memory);
-                man.hash.add(wasm.global_base);
+                man.hash.addOptional(wasm.global_base);
             },
             .macho => {
                 const macho = lf.cast(link.File.MachO).?;
 @@ -2626,12 +2650,14 @@ fn reportMultiModuleErrors(mod: *Module) !void {
 /// binary is concerned. This will remove the write flag, or close the file,
 /// or whatever is needed so that it can be executed.
 /// After this, one must call` makeFileWritable` before calling `update`.
-pub fn makeBinFileExecutable(self: *Compilation) !void {
+pub fn makeBinFileExecutable(comp: *Compilation) !void {
-    return self.bin_file.makeExecutable();
+    const lf = comp.bin_file orelse return;
+    return lf.makeExecutable();
 }
-pub fn makeBinFileWritable(self: *Compilation) !void {
+pub fn makeBinFileWritable(comp: *Compilation) !void {
-    return self.bin_file.makeWritable();
+    const lf = comp.bin_file orelse return;
+    return lf.makeWritable();
 }
 const Header = extern struct {
 @@ -2764,8 +2790,9 @@ pub fn totalErrorCount(self: *Compilation) u32 {
     }
     total += @intFromBool(self.link_error_flags.missing_libc);
-    // Misc linker errors
+    if (self.bin_file) |lf| {
-    total += self.bin_file.miscErrors().len;
+        total += lf.misc_errors.items.len;
+    }
     // Compile log errors only count if there are no other errors.
     if (total == 0) {
 @@ -2914,7 +2941,7 @@ pub fn getAllErrorsAlloc(self: *Compilation) !ErrorBundle {
         }));
     }
-    for (self.bin_file.miscErrors()) |link_err| {
+    if (self.bin_file) |lf| for (lf.misc_errors.items) |link_err| {
         try bundle.addRootErrorMessage(.{
             .msg = try bundle.addString(link_err.msg),
             .notes_len = @intCast(link_err.notes.len),
 @@ -2925,7 +2952,7 @@ pub fn getAllErrorsAlloc(self: *Compilation) !ErrorBundle {
                 .msg = try bundle.addString(note.msg),
             }));
         }
-    }
+    };
     if (self.module) |module| {
         if (bundle.root_list.items.len == 0 and module.compile_log_decls.count() != 0) {
 @@ -3246,12 +3273,12 @@ pub fn performAllTheWork(
             // TODO put all the modules in a flat array to make them easy to iterate.
             var seen: std.AutoArrayHashMapUnmanaged(*Package.Module, void) = .{};
             defer seen.deinit(comp.gpa);
-            try seen.put(comp.gpa, comp.root_mod);
+            try seen.put(comp.gpa, comp.root_mod, {});
             var i: usize = 0;
             while (i < seen.count()) : (i += 1) {
                 const mod = seen.keys()[i];
                 for (mod.deps.values()) |dep|
-                    try seen.put(comp.gpa, dep);
+                    try seen.put(comp.gpa, dep, {});
                 const file = mod.builtin_file orelse continue;
 @@ -3459,7 +3486,8 @@ fn processOneJob(comp: *Compilation, job: Job, prog_node: *std.Progress.Node) !v
             const gpa = comp.gpa;
             const module = comp.module.?;
             const decl = module.declPtr(decl_index);
-            comp.bin_file.updateDeclLineNumber(module, decl_index) catch |err| {
+            const lf = comp.bin_file.?;
+            lf.updateDeclLineNumber(module, decl_index) catch |err| {
                 try module.failed_decls.ensureUnusedCapacity(gpa, 1);
                 module.failed_decls.putAssumeCapacityNoClobber(decl_index, try Module.ErrorMsg.create(
                     gpa,
 @@ -3782,7 +3810,7 @@ pub fn obtainCObjectCacheManifest(
     // that apply both to @cImport and compiling C objects. No linking stuff here!
     // Also nothing that applies only to compiling .zig code.
     man.hash.add(owner_mod.sanitize_c);
-    man.hash.addListOfBytes(owner_mod.clang_argv);
+    man.hash.addListOfBytes(owner_mod.cc_argv);
     man.hash.add(comp.config.link_libcpp);
     // When libc_installation is null it means that Zig generated this dir list
 @@ -6099,7 +6127,8 @@ fn buildOutputFromZig(
     const tracy_trace = trace(@src());
     defer tracy_trace.end();
-    var arena_allocator = std.heap.ArenaAllocator.init(comp.gpa);
+    const gpa = comp.gpa;
+    var arena_allocator = std.heap.ArenaAllocator.init(gpa);
     defer arena_allocator.deinit();
     const arena = arena_allocator.allocator();
 @@ -6110,6 +6139,7 @@ fn buildOutputFromZig(
     const config = try Config.resolve(.{
         .output_mode = output_mode,
+        .link_mode = .Static,
         .resolved_target = comp.root_mod.resolved_target,
         .is_test = false,
         .have_zcu = true,
 @@ -6120,7 +6150,8 @@ fn buildOutputFromZig(
         .any_unwind_tables = unwind_tables,
     });
-    const root_mod = Package.Module.create(.{
+    const root_mod = try Package.Module.create(arena, .{
+        .global_cache_directory = comp.global_cache_directory,
         .paths = .{
             .root = .{ .root_dir = comp.zig_lib_directory },
             .root_src_path = src_basename,
 @@ -6139,6 +6170,8 @@ fn buildOutputFromZig(
         },
         .global = config,
         .cc_argv = &.{},
+        .parent = null,
+        .builtin_mod = null,
     });
     const root_name = src_basename[0 .. src_basename.len - std.fs.path.extension(src_basename).len];
     const target = comp.getTarget();
 @@ -6148,23 +6181,21 @@ fn buildOutputFromZig(
         .output_mode = output_mode,
     });
-    const emit_bin = Compilation.EmitLoc{
+    const sub_compilation = try Compilation.create(gpa, .{
-        .directory = null, // Put it in the cache directory.
-        .basename = bin_basename,
-    };
-    const sub_compilation = try Compilation.create(comp.gpa, .{
         .global_cache_directory = comp.global_cache_directory,
         .local_cache_directory = comp.global_cache_directory,
         .zig_lib_directory = comp.zig_lib_directory,
         .self_exe_path = comp.self_exe_path,
-        .resolved = config,
+        .config = config,
         .root_mod = root_mod,
         .cache_mode = .whole,
         .root_name = root_name,
         .thread_pool = comp.thread_pool,
         .libc_installation = comp.libc_installation,
-        .emit_bin = emit_bin,
+        .emit_bin = .{
-        .link_mode = .Static,
+            .directory = null, // Put it in the cache directory.
+            .basename = bin_basename,
+        },
         .function_sections = true,
         .data_sections = true,
         .no_builtin = true,
 @@ -6186,8 +6217,8 @@ fn buildOutputFromZig(
     try comp.updateSubCompilation(sub_compilation, misc_task_tag, prog_node);
     assert(out.* == null);
-    out.* = Compilation.CRTFile{
+    out.* = .{
-        .full_object_path = try sub_compilation.bin_file.?.emit.directory.join(comp.gpa, &[_][]const u8{
+        .full_object_path = try sub_compilation.bin_file.?.emit.directory.join(gpa, &.{
             sub_compilation.bin_file.?.emit.sub_path,
         }),
         .lock = sub_compilation.bin_file.toOwnedLock(),
 @@ -6206,12 +6237,15 @@ pub fn build_crt_file(
     defer tracy_trace.end();
     const gpa = comp.gpa;
-    const basename = try std.zig.binNameAlloc(gpa, .{
+    var arena_allocator = std.heap.ArenaAllocator.init(gpa);
+    defer arena_allocator.deinit();
+    const arena = arena_allocator.allocator();
+    const basename = try std.zig.binNameAlloc(arena, .{
         .root_name = root_name,
         .target = comp.root_mod.resolved_target.result,
         .output_mode = output_mode,
     });
-    errdefer gpa.free(basename);
     const config = try Config.resolve(.{
         .output_mode = output_mode,
 @@ -6227,7 +6261,8 @@ pub fn build_crt_file(
             .Obj, .Exe => false,
         },
     });
-    const root_mod = Package.Module.create(.{
+    const root_mod = try Package.Module.create(arena, .{
+        .global_cache_directory = comp.global_cache_directory,
         .paths = .{
             .root = .{ .root_dir = comp.zig_lib_directory },
             .root_src_path = "",
 @@ -6249,6 +6284,8 @@ pub fn build_crt_file(
         },
         .global = config,
         .cc_argv = &.{},
+        .parent = null,
+        .builtin_mod = null,
     });
     const sub_compilation = try Compilation.create(gpa, .{
 @@ -6257,7 +6294,7 @@ pub fn build_crt_file(
         .zig_lib_directory = comp.zig_lib_directory,
         .self_exe_path = comp.self_exe_path,
         .cache_mode = .whole,
-        .resolved = config,
+        .config = config,
         .root_mod = root_mod,
         .root_name = root_name,
         .thread_pool = comp.thread_pool,
 @@ -6287,7 +6324,7 @@ pub fn build_crt_file(
     try comp.crt_files.ensureUnusedCapacity(gpa, 1);
     comp.crt_files.putAssumeCapacityNoClobber(basename, .{
-        .full_object_path = try sub_compilation.bin_file.?.emit.directory.join(gpa, &[_][]const u8{
+        .full_object_path = try sub_compilation.bin_file.?.emit.directory.join(gpa, &.{
             sub_compilation.bin_file.?.emit.sub_path,
         }),
         .lock = sub_compilation.bin_file.toOwnedLock(),

src/Module.zig+71-56

...	@@ -619,7 +619,7 @@ pub const Decl = struct {	...	@@ -619,7 +619,7 @@ pub const Decl = struct {
619	// Sanitize the name for nvptx which is more restrictive.	619	// Sanitize the name for nvptx which is more restrictive.
620	// TODO This should be handled by the backend, not the frontend. Have a	620	// TODO This should be handled by the backend, not the frontend. Have a
621	// look at how the C backend does it for inspiration.	621	// look at how the C backend does it for inspiration.
622	const cpu_arch = mod.root_mod.resolved_target.cpu.arch;	622	const cpu_arch = mod.root_mod.resolved_target.result.cpu.arch;
623	if (cpu_arch.isNvptx()) {	623	if (cpu_arch.isNvptx()) {
624	for (ip.string_bytes.items[start..]) \|byte\| switch (byte.) {	624	for (ip.string_bytes.items[start..]) \|byte\| switch (byte.) {
625	'{', '}', '', '[', ']', '(', ')', ',', ' ', '\'' => byte. = '_',	625	'{', '}', '', '[', ']', '(', ')', ',', ' ', '\'' => byte. = '_',
...	@@ -3313,7 +3313,8 @@ pub fn ensureFuncBodyAnalyzed(mod: *Module, func_index: InternPool.Index) SemaEr	...	@@ -3313,7 +3313,8 @@ pub fn ensureFuncBodyAnalyzed(mod: *Module, func_index: InternPool.Index) SemaEr
3313		3313
3314	if (no_bin_file and !dump_llvm_ir) return;	3314	if (no_bin_file and !dump_llvm_ir) return;
3315		3315
3316	comp.bin_file.updateFunc(mod, func_index, air, liveness) catch \|err\| switch (err) {	3316	const lf = comp.bin_file.?;
		3317	lf.updateFunc(mod, func_index, air, liveness) catch \|err\| switch (err) {
3317	error.OutOfMemory => return error.OutOfMemory,	3318	error.OutOfMemory => return error.OutOfMemory,
3318	error.AnalysisFail => {	3319	error.AnalysisFail => {
3319	decl.analysis = .codegen_failure;	3320	decl.analysis = .codegen_failure;
...	@@ -3488,25 +3489,29 @@ pub fn semaFile(mod: Module, file: File) SemaError!void {	...	@@ -3488,25 +3489,29 @@ pub fn semaFile(mod: Module, file: File) SemaError!void {
3488	new_decl.owns_tv = true;	3489	new_decl.owns_tv = true;
3489	new_decl.analysis = .complete;	3490	new_decl.analysis = .complete;
3490		3491
3491	if (mod.comp.whole_cache_manifest) \|whole_cache_manifest\| {	3492	const comp = mod.comp;
3492	const source = file.getSource(gpa) catch \|err\| {	3493	switch (comp.cache_use) {
3493	try reportRetryableFileError(mod, file, "unable to load source: {s}", .{@errorName(err)});	3494	.whole => \|whole\| if (whole.cache_manifest) \|man\| {
3494	return error.AnalysisFail;	3495	const source = file.getSource(gpa) catch \|err\| {
3495	};	3496	try reportRetryableFileError(mod, file, "unable to load source: {s}", .{@errorName(err)});
		3497	return error.AnalysisFail;
		3498	};
3496		3499
3497	const resolved_path = std.fs.path.resolve(gpa, &.{	3500	const resolved_path = std.fs.path.resolve(gpa, &.{
3498	file.mod.root.root_dir.path orelse ".",	3501	file.mod.root.root_dir.path orelse ".",
3499	file.mod.root.sub_path,	3502	file.mod.root.sub_path,
3500	file.sub_file_path,	3503	file.sub_file_path,
3501	}) catch \|err\| {	3504	}) catch \|err\| {
3502	try reportRetryableFileError(mod, file, "unable to resolve path: {s}", .{@errorName(err)});	3505	try reportRetryableFileError(mod, file, "unable to resolve path: {s}", .{@errorName(err)});
3503	return error.AnalysisFail;	3506	return error.AnalysisFail;
3504	};	3507	};
3505	errdefer gpa.free(resolved_path);	3508	errdefer gpa.free(resolved_path);
3506		3509
3507	mod.comp.whole_cache_manifest_mutex.lock();	3510	whole.cache_manifest_mutex.lock();
3508	defer mod.comp.whole_cache_manifest_mutex.unlock();	3511	defer whole.cache_manifest_mutex.unlock();
3509	try whole_cache_manifest.addFilePostContents(resolved_path, source.bytes, source.stat);	3512	try man.addFilePostContents(resolved_path, source.bytes, source.stat);
		3513	},
		3514	.incremental => {},
3510	}	3515	}
3511	}	3516	}
3512		3517
...	@@ -4045,12 +4050,16 @@ fn newEmbedFile(	...	@@ -4045,12 +4050,16 @@ fn newEmbedFile(
4045	const actual_read = try file.readAll(ptr);	4050	const actual_read = try file.readAll(ptr);
4046	if (actual_read != size) return error.UnexpectedEndOfFile;	4051	if (actual_read != size) return error.UnexpectedEndOfFile;
4047		4052
4048	if (mod.comp.whole_cache_manifest) \|whole_cache_manifest\| {	4053	const comp = mod.comp;
4049	const copied_resolved_path = try gpa.dupe(u8, resolved_path);	4054	switch (comp.cache_use) {
4050	errdefer gpa.free(copied_resolved_path);	4055	.whole => \|whole\| if (whole.cache_manifest) \|man\| {
4051	mod.comp.whole_cache_manifest_mutex.lock();	4056	const copied_resolved_path = try gpa.dupe(u8, resolved_path);
4052	defer mod.comp.whole_cache_manifest_mutex.unlock();	4057	errdefer gpa.free(copied_resolved_path);
4053	try whole_cache_manifest.addFilePostContents(copied_resolved_path, ptr, stat);	4058	whole.cache_manifest_mutex.lock();
		4059	defer whole.cache_manifest_mutex.unlock();
		4060	try man.addFilePostContents(copied_resolved_path, ptr, stat);
		4061	},
		4062	.incremental => {},
4054	}	4063	}
4055		4064
4056	const array_ty = try ip.get(gpa, .{ .array_type = .{	4065	const array_ty = try ip.get(gpa, .{ .array_type = .{
...	@@ -4393,7 +4402,9 @@ fn deleteDeclExports(mod: *Module, decl_index: Decl.Index) Allocator.Error!void	...	@@ -4393,7 +4402,9 @@ fn deleteDeclExports(mod: *Module, decl_index: Decl.Index) Allocator.Error!void
4393	}	4402	}
4394	},	4403	},
4395	}	4404	}
4396	try mod.comp.bin_file.deleteDeclExport(decl_index, exp.opts.name);	4405	if (mod.comp.bin_file) \|lf\| {
		4406	try lf.deleteDeclExport(decl_index, exp.opts.name);
		4407	}
4397	if (mod.failed_exports.fetchSwapRemove(exp)) \|failed_kv\| {	4408	if (mod.failed_exports.fetchSwapRemove(exp)) \|failed_kv\| {
4398	failed_kv.value.destroy(mod.gpa);	4409	failed_kv.value.destroy(mod.gpa);
4399	}	4410	}
...	@@ -5247,7 +5258,8 @@ fn processExportsInner(	...	@@ -5247,7 +5258,8 @@ fn processExportsInner(
5247	gop.value_ptr.* = new_export;	5258	gop.value_ptr.* = new_export;
5248	}	5259	}
5249	}	5260	}
5250	mod.comp.bin_file.updateExports(mod, exported, exports) catch \|err\| switch (err) {	5261	const lf = mod.comp.bin_file orelse return;
		5262	lf.updateExports(mod, exported, exports) catch \|err\| switch (err) {
5251	error.OutOfMemory => return error.OutOfMemory,	5263	error.OutOfMemory => return error.OutOfMemory,
5252	else => {	5264	else => {
5253	const new_export = exports[0];	5265	const new_export = exports[0];
...	@@ -5403,36 +5415,39 @@ pub fn populateTestFunctions(	...	@@ -5403,36 +5415,39 @@ pub fn populateTestFunctions(
5403	pub fn linkerUpdateDecl(mod: *Module, decl_index: Decl.Index) !void {	5415	pub fn linkerUpdateDecl(mod: *Module, decl_index: Decl.Index) !void {
5404	const comp = mod.comp;	5416	const comp = mod.comp;
5405		5417
5406	const no_bin_file = (comp.bin_file == null and	5418	if (comp.bin_file) \|lf\| {
5407	comp.emit_asm == null and	5419	const decl = mod.declPtr(decl_index);
5408	comp.emit_llvm_ir == null and	5420	lf.updateDecl(mod, decl_index) catch \|err\| switch (err) {
5409	comp.emit_llvm_bc == null);	5421	error.OutOfMemory => return error.OutOfMemory,
5410		5422	error.AnalysisFail => {
5411	const dump_llvm_ir = builtin.mode == .Debug and (comp.verbose_llvm_ir != null or comp.verbose_llvm_bc != null);	5423	decl.analysis = .codegen_failure;
5412		5424	return;
5413	if (no_bin_file and !dump_llvm_ir) return;	5425	},
5414		5426	else => {
5415	const decl = mod.declPtr(decl_index);	5427	const gpa = mod.gpa;
		5428	try mod.failed_decls.ensureUnusedCapacity(gpa, 1);
		5429	mod.failed_decls.putAssumeCapacityNoClobber(decl_index, try ErrorMsg.create(
		5430	gpa,
		5431	decl.srcLoc(mod),
		5432	"unable to codegen: {s}",
		5433	.{@errorName(err)},
		5434	));
		5435	decl.analysis = .codegen_failure_retryable;
		5436	return;
		5437	},
		5438	};
		5439	} else {
		5440	const dump_llvm_ir = builtin.mode == .Debug and
		5441	(comp.verbose_llvm_ir != null or comp.verbose_llvm_bc != null);
5416		5442
5417	comp.bin_file.updateDecl(mod, decl_index) catch \|err\| switch (err) {	5443	if (comp.emit_asm != null or
5418	error.OutOfMemory => return error.OutOfMemory,	5444	comp.emit_llvm_ir != null or
5419	error.AnalysisFail => {	5445	comp.emit_llvm_bc != null or
5420	decl.analysis = .codegen_failure;	5446	dump_llvm_ir)
5421	return;	5447	{
5422	},	5448	@panic("TODO handle emit_asm, emit_llvm_ir, and emit_llvm_bc along with -fno-emit-bin");
5423	else => {	5449	}
5424	const gpa = mod.gpa;	5450	}
5425	try mod.failed_decls.ensureUnusedCapacity(gpa, 1);
5426	mod.failed_decls.putAssumeCapacityNoClobber(decl_index, try ErrorMsg.create(
5427	gpa,
5428	decl.srcLoc(mod),
5429	"unable to codegen: {s}",
5430	.{@errorName(err)},
5431	));
5432	decl.analysis = .codegen_failure_retryable;
5433	return;
5434	},
5435	};
5436	}	5451	}
5437		5452
5438	fn reportRetryableFileError(	5453	fn reportRetryableFileError(

src/arch/aarch64/CodeGen.zig+3-3

...	@@ -344,7 +344,7 @@ pub fn generate(	...	@@ -344,7 +344,7 @@ pub fn generate(
344	assert(fn_owner_decl.has_tv);	344	assert(fn_owner_decl.has_tv);
345	const fn_type = fn_owner_decl.ty;	345	const fn_type = fn_owner_decl.ty;
346	const namespace = zcu.namespacePtr(fn_owner_decl.src_namespace);	346	const namespace = zcu.namespacePtr(fn_owner_decl.src_namespace);
347	const target = &namespace.file_scope.mod.target;	347	const target = &namespace.file_scope.mod.resolved_target.result;
348		348
349	var branch_stack = std.ArrayList(Branch).init(gpa);	349	var branch_stack = std.ArrayList(Branch).init(gpa);
350	defer {	350	defer {
...	@@ -6343,14 +6343,14 @@ fn wantSafety(self: *Self) bool {	...	@@ -6343,14 +6343,14 @@ fn wantSafety(self: *Self) bool {
6343	fn fail(self: *Self, comptime format: []const u8, args: anytype) InnerError {	6343	fn fail(self: *Self, comptime format: []const u8, args: anytype) InnerError {
6344	@setCold(true);	6344	@setCold(true);
6345	assert(self.err_msg == null);	6345	assert(self.err_msg == null);
6346	self.err_msg = try ErrorMsg.create(self.bin_file.allocator, self.src_loc, format, args);	6346	self.err_msg = try ErrorMsg.create(self.gpa, self.src_loc, format, args);
6347	return error.CodegenFail;	6347	return error.CodegenFail;
6348	}	6348	}
6349		6349
6350	fn failSymbol(self: *Self, comptime format: []const u8, args: anytype) InnerError {	6350	fn failSymbol(self: *Self, comptime format: []const u8, args: anytype) InnerError {
6351	@setCold(true);	6351	@setCold(true);
6352	assert(self.err_msg == null);	6352	assert(self.err_msg == null);
6353	self.err_msg = try ErrorMsg.create(self.bin_file.allocator, self.src_loc, format, args);	6353	self.err_msg = try ErrorMsg.create(self.gpa, self.src_loc, format, args);
6354	return error.CodegenFail;	6354	return error.CodegenFail;
6355	}	6355	}
6356		6356

src/arch/aarch64/Emit.zig+17-12

 @@ -218,14 +218,16 @@ pub fn emitMir(
 }
 pub fn deinit(emit: *Emit) void {
+    const comp = emit.bin_file.comp;
+    const gpa = comp.gpa;
     var iter = emit.branch_forward_origins.valueIterator();
     while (iter.next()) |origin_list| {
-        origin_list.deinit(emit.bin_file.allocator);
+        origin_list.deinit(gpa);
     }
-    emit.branch_types.deinit(emit.bin_file.allocator);
+    emit.branch_types.deinit(gpa);
-    emit.branch_forward_origins.deinit(emit.bin_file.allocator);
+    emit.branch_forward_origins.deinit(gpa);
-    emit.code_offset_mapping.deinit(emit.bin_file.allocator);
+    emit.code_offset_mapping.deinit(gpa);
     emit.* = undefined;
 }
 @@ -314,8 +316,9 @@ fn branchTarget(emit: *Emit, inst: Mir.Inst.Index) Mir.Inst.Index {
 }
 fn lowerBranches(emit: *Emit) !void {
+    const comp = emit.bin_file.comp;
+    const gpa = comp.gpa;
     const mir_tags = emit.mir.instructions.items(.tag);
-    const allocator = emit.bin_file.allocator;
     // First pass: Note down all branches and their target
     // instructions, i.e. populate branch_types,
 @@ -329,7 +332,7 @@ fn lowerBranches(emit: *Emit) !void {
             const target_inst = emit.branchTarget(inst);
             // Remember this branch instruction
-            try emit.branch_types.put(allocator, inst, BranchType.default(tag));
+            try emit.branch_types.put(gpa, inst, BranchType.default(tag));
             // Forward branches require some extra stuff: We only
             // know their offset once we arrive at the target
 @@ -339,14 +342,14 @@ fn lowerBranches(emit: *Emit) !void {
             // etc.
             if (target_inst > inst) {
                 // Remember the branch instruction index
-                try emit.code_offset_mapping.put(allocator, inst, 0);
+                try emit.code_offset_mapping.put(gpa, inst, 0);
                 if (emit.branch_forward_origins.getPtr(target_inst)) |origin_list| {
-                    try origin_list.append(allocator, inst);
+                    try origin_list.append(gpa, inst);
                 } else {
                     var origin_list: std.ArrayListUnmanaged(Mir.Inst.Index) = .{};
-                    try origin_list.append(allocator, inst);
+                    try origin_list.append(gpa, inst);
-                    try emit.branch_forward_origins.put(allocator, target_inst, origin_list);
+                    try emit.branch_forward_origins.put(gpa, target_inst, origin_list);
                 }
             }
 @@ -356,7 +359,7 @@ fn lowerBranches(emit: *Emit) !void {
             // putNoClobber may not be used as the put operation
             // may clobber the entry when multiple branches branch
             // to the same target instruction
-            try emit.code_offset_mapping.put(allocator, target_inst, 0);
+            try emit.code_offset_mapping.put(gpa, target_inst, 0);
         }
     }
 @@ -429,7 +432,9 @@ fn writeInstruction(emit: *Emit, instruction: Instruction) !void {
 fn fail(emit: *Emit, comptime format: []const u8, args: anytype) InnerError {
     @setCold(true);
     assert(emit.err_msg == null);
-    emit.err_msg = try ErrorMsg.create(emit.bin_file.allocator, emit.src_loc, format, args);
+    const comp = emit.bin_file.comp;
+    const gpa = comp.gpa;
+    emit.err_msg = try ErrorMsg.create(gpa, emit.src_loc, format, args);
     return error.EmitFail;
 }

src/arch/arm/CodeGen.zig+5-3

 @@ -351,7 +351,7 @@ pub fn generate(
     assert(fn_owner_decl.has_tv);
     const fn_type = fn_owner_decl.ty;
     const namespace = zcu.namespacePtr(fn_owner_decl.src_namespace);
-    const target = &namespace.file_scope.mod.target;
+    const target = &namespace.file_scope.mod.resolved_target.result;
     var branch_stack = std.ArrayList(Branch).init(gpa);
     defer {
 @@ -6292,14 +6292,16 @@ fn wantSafety(self: *Self) bool {
 fn fail(self: *Self, comptime format: []const u8, args: anytype) InnerError {
     @setCold(true);
     assert(self.err_msg == null);
-    self.err_msg = try ErrorMsg.create(self.bin_file.allocator, self.src_loc, format, args);
+    const gpa = self.gpa;
+    self.err_msg = try ErrorMsg.create(gpa, self.src_loc, format, args);
     return error.CodegenFail;
 }
 fn failSymbol(self: *Self, comptime format: []const u8, args: anytype) InnerError {
     @setCold(true);
     assert(self.err_msg == null);
-    self.err_msg = try ErrorMsg.create(self.bin_file.allocator, self.src_loc, format, args);
+    const gpa = self.gpa;
+    self.err_msg = try ErrorMsg.create(gpa, self.src_loc, format, args);
     return error.CodegenFail;
 }

src/arch/arm/Emit.zig+18-12

 @@ -152,14 +152,17 @@ pub fn emitMir(
 }
 pub fn deinit(emit: *Emit) void {
+    const comp = emit.bin_file.comp;
+    const gpa = comp.gpa;
     var iter = emit.branch_forward_origins.valueIterator();
     while (iter.next()) |origin_list| {
-        origin_list.deinit(emit.bin_file.allocator);
+        origin_list.deinit(gpa);
     }
-    emit.branch_types.deinit(emit.bin_file.allocator);
+    emit.branch_types.deinit(gpa);
-    emit.branch_forward_origins.deinit(emit.bin_file.allocator);
+    emit.branch_forward_origins.deinit(gpa);
-    emit.code_offset_mapping.deinit(emit.bin_file.allocator);
+    emit.code_offset_mapping.deinit(gpa);
     emit.* = undefined;
 }
 @@ -231,8 +234,9 @@ fn branchTarget(emit: *Emit, inst: Mir.Inst.Index) Mir.Inst.Index {
 }
 fn lowerBranches(emit: *Emit) !void {
+    const comp = emit.bin_file.comp;
+    const gpa = comp.gpa;
     const mir_tags = emit.mir.instructions.items(.tag);
-    const allocator = emit.bin_file.allocator;
     // First pass: Note down all branches and their target
     // instructions, i.e. populate branch_types,
 @@ -246,7 +250,7 @@ fn lowerBranches(emit: *Emit) !void {
             const target_inst = emit.branchTarget(inst);
             // Remember this branch instruction
-            try emit.branch_types.put(allocator, inst, BranchType.default(tag));
+            try emit.branch_types.put(gpa, inst, BranchType.default(tag));
             // Forward branches require some extra stuff: We only
             // know their offset once we arrive at the target
 @@ -256,14 +260,14 @@ fn lowerBranches(emit: *Emit) !void {
             // etc.
             if (target_inst > inst) {
                 // Remember the branch instruction index
-                try emit.code_offset_mapping.put(allocator, inst, 0);
+                try emit.code_offset_mapping.put(gpa, inst, 0);
                 if (emit.branch_forward_origins.getPtr(target_inst)) |origin_list| {
-                    try origin_list.append(allocator, inst);
+                    try origin_list.append(gpa, inst);
                 } else {
                     var origin_list: std.ArrayListUnmanaged(Mir.Inst.Index) = .{};
-                    try origin_list.append(allocator, inst);
+                    try origin_list.append(gpa, inst);
-                    try emit.branch_forward_origins.put(allocator, target_inst, origin_list);
+                    try emit.branch_forward_origins.put(gpa, target_inst, origin_list);
                 }
             }
 @@ -273,7 +277,7 @@ fn lowerBranches(emit: *Emit) !void {
             // putNoClobber may not be used as the put operation
             // may clobber the entry when multiple branches branch
             // to the same target instruction
-            try emit.code_offset_mapping.put(allocator, target_inst, 0);
+            try emit.code_offset_mapping.put(gpa, target_inst, 0);
         }
     }
 @@ -346,7 +350,9 @@ fn writeInstruction(emit: *Emit, instruction: Instruction) !void {
 fn fail(emit: *Emit, comptime format: []const u8, args: anytype) InnerError {
     @setCold(true);
     assert(emit.err_msg == null);
-    emit.err_msg = try ErrorMsg.create(emit.bin_file.allocator, emit.src_loc, format, args);
+    const comp = emit.bin_file.comp;
+    const gpa = comp.gpa;
+    emit.err_msg = try ErrorMsg.create(gpa, emit.src_loc, format, args);
     return error.EmitFail;
 }

src/arch/riscv64/CodeGen.zig+3-3

...	@@ -232,7 +232,7 @@ pub fn generate(	...	@@ -232,7 +232,7 @@ pub fn generate(
232	assert(fn_owner_decl.has_tv);	232	assert(fn_owner_decl.has_tv);
233	const fn_type = fn_owner_decl.ty;	233	const fn_type = fn_owner_decl.ty;
234	const namespace = zcu.namespacePtr(fn_owner_decl.src_namespace);	234	const namespace = zcu.namespacePtr(fn_owner_decl.src_namespace);
235	const target = &namespace.file_scope.mod.target;	235	const target = &namespace.file_scope.mod.resolved_target.result;
236		236
237	var branch_stack = std.ArrayList(Branch).init(gpa);	237	var branch_stack = std.ArrayList(Branch).init(gpa);
238	defer {	238	defer {
...	@@ -2719,14 +2719,14 @@ fn wantSafety(self: *Self) bool {	...	@@ -2719,14 +2719,14 @@ fn wantSafety(self: *Self) bool {
2719	fn fail(self: *Self, comptime format: []const u8, args: anytype) InnerError {	2719	fn fail(self: *Self, comptime format: []const u8, args: anytype) InnerError {
2720	@setCold(true);	2720	@setCold(true);
2721	assert(self.err_msg == null);	2721	assert(self.err_msg == null);
2722	self.err_msg = try ErrorMsg.create(self.bin_file.allocator, self.src_loc, format, args);	2722	self.err_msg = try ErrorMsg.create(self.gpa, self.src_loc, format, args);
2723	return error.CodegenFail;	2723	return error.CodegenFail;
2724	}	2724	}
2725		2725
2726	fn failSymbol(self: *Self, comptime format: []const u8, args: anytype) InnerError {	2726	fn failSymbol(self: *Self, comptime format: []const u8, args: anytype) InnerError {
2727	@setCold(true);	2727	@setCold(true);
2728	assert(self.err_msg == null);	2728	assert(self.err_msg == null);
2729	self.err_msg = try ErrorMsg.create(self.bin_file.allocator, self.src_loc, format, args);	2729	self.err_msg = try ErrorMsg.create(self.gpa, self.src_loc, format, args);
2730	return error.CodegenFail;	2730	return error.CodegenFail;
2731	}	2731	}
2732		2732

src/arch/riscv64/Emit.zig+3-1

 @@ -80,7 +80,9 @@ fn writeInstruction(emit: *Emit, instruction: Instruction) !void {
 fn fail(emit: *Emit, comptime format: []const u8, args: anytype) InnerError {
     @setCold(true);
     assert(emit.err_msg == null);
-    emit.err_msg = try ErrorMsg.create(emit.bin_file.allocator, emit.src_loc, format, args);
+    const comp = emit.bin_file.comp;
+    const gpa = comp.gpa;
+    emit.err_msg = try ErrorMsg.create(gpa, emit.src_loc, format, args);
     return error.EmitFail;
 }

src/arch/sparc64/CodeGen.zig+3-2

...	@@ -275,7 +275,7 @@ pub fn generate(	...	@@ -275,7 +275,7 @@ pub fn generate(
275	assert(fn_owner_decl.has_tv);	275	assert(fn_owner_decl.has_tv);
276	const fn_type = fn_owner_decl.ty;	276	const fn_type = fn_owner_decl.ty;
277	const namespace = zcu.namespacePtr(fn_owner_decl.src_namespace);	277	const namespace = zcu.namespacePtr(fn_owner_decl.src_namespace);
278	const target = &namespace.file_scope.mod.target;	278	const target = &namespace.file_scope.mod.resolved_target.result;
279		279
280	var branch_stack = std.ArrayList(Branch).init(gpa);	280	var branch_stack = std.ArrayList(Branch).init(gpa);
281	defer {	281	defer {
...	@@ -3546,7 +3546,8 @@ fn errUnionPayload(self: *Self, error_union_mcv: MCValue, error_union_ty: Type)	...	@@ -3546,7 +3546,8 @@ fn errUnionPayload(self: *Self, error_union_mcv: MCValue, error_union_ty: Type)
3546	fn fail(self: *Self, comptime format: []const u8, args: anytype) InnerError {	3546	fn fail(self: *Self, comptime format: []const u8, args: anytype) InnerError {
3547	@setCold(true);	3547	@setCold(true);
3548	assert(self.err_msg == null);	3548	assert(self.err_msg == null);
3549	self.err_msg = try ErrorMsg.create(self.bin_file.allocator, self.src_loc, format, args);	3549	const gpa = self.gpa;
		3550	self.err_msg = try ErrorMsg.create(gpa, self.src_loc, format, args);
3550	return error.CodegenFail;	3551	return error.CodegenFail;
3551	}	3552	}
3552		3553

src/arch/sparc64/Emit.zig+17-12

 @@ -152,14 +152,16 @@ pub fn emitMir(
 }
 pub fn deinit(emit: *Emit) void {
+    const comp = emit.bin_file.comp;
+    const gpa = comp.gpa;
     var iter = emit.branch_forward_origins.valueIterator();
     while (iter.next()) |origin_list| {
-        origin_list.deinit(emit.bin_file.allocator);
+        origin_list.deinit(gpa);
     }
-    emit.branch_types.deinit(emit.bin_file.allocator);
+    emit.branch_types.deinit(gpa);
-    emit.branch_forward_origins.deinit(emit.bin_file.allocator);
+    emit.branch_forward_origins.deinit(gpa);
-    emit.code_offset_mapping.deinit(emit.bin_file.allocator);
+    emit.code_offset_mapping.deinit(gpa);
     emit.* = undefined;
 }
 @@ -511,7 +513,9 @@ fn dbgAdvancePCAndLine(emit: *Emit, line: u32, column: u32) !void {
 fn fail(emit: *Emit, comptime format: []const u8, args: anytype) InnerError {
     @setCold(true);
     assert(emit.err_msg == null);
-    emit.err_msg = try ErrorMsg.create(emit.bin_file.allocator, emit.src_loc, format, args);
+    const comp = emit.bin_file.comp;
+    const gpa = comp.gpa;
+    emit.err_msg = try ErrorMsg.create(gpa, emit.src_loc, format, args);
     return error.EmitFail;
 }
 @@ -537,8 +541,9 @@ fn isBranch(tag: Mir.Inst.Tag) bool {
 }
 fn lowerBranches(emit: *Emit) !void {
+    const comp = emit.bin_file.comp;
+    const gpa = comp.gpa;
     const mir_tags = emit.mir.instructions.items(.tag);
-    const allocator = emit.bin_file.allocator;
     // First pass: Note down all branches and their target
     // instructions, i.e. populate branch_types,
 @@ -552,7 +557,7 @@ fn lowerBranches(emit: *Emit) !void {
             const target_inst = emit.branchTarget(inst);
             // Remember this branch instruction
-            try emit.branch_types.put(allocator, inst, BranchType.default(tag));
+            try emit.branch_types.put(gpa, inst, BranchType.default(tag));
             // Forward branches require some extra stuff: We only
             // know their offset once we arrive at the target
 @@ -562,14 +567,14 @@ fn lowerBranches(emit: *Emit) !void {
             // etc.
             if (target_inst > inst) {
                 // Remember the branch instruction index
-                try emit.code_offset_mapping.put(allocator, inst, 0);
+                try emit.code_offset_mapping.put(gpa, inst, 0);
                 if (emit.branch_forward_origins.getPtr(target_inst)) |origin_list| {
-                    try origin_list.append(allocator, inst);
+                    try origin_list.append(gpa, inst);
                 } else {
                     var origin_list: std.ArrayListUnmanaged(Mir.Inst.Index) = .{};
-                    try origin_list.append(allocator, inst);
+                    try origin_list.append(gpa, inst);
-                    try emit.branch_forward_origins.put(allocator, target_inst, origin_list);
+                    try emit.branch_forward_origins.put(gpa, target_inst, origin_list);
                 }
             }
 @@ -579,7 +584,7 @@ fn lowerBranches(emit: *Emit) !void {
             // putNoClobber may not be used as the put operation
             // may clobber the entry when multiple branches branch
             // to the same target instruction
-            try emit.code_offset_mapping.put(allocator, target_inst, 0);
+            try emit.code_offset_mapping.put(gpa, target_inst, 0);
         }
     }

src/arch/wasm/CodeGen.zig+6-4

 @@ -1210,13 +1210,15 @@ pub fn generate(
     debug_output: codegen.DebugInfoOutput,
 ) codegen.CodeGenError!codegen.Result {
     _ = src_loc;
-    const mod = bin_file.comp.module.?;
+    const comp = bin_file.comp;
+    const gpa = comp.gpa;
+    const mod = comp.module.?;
     const func = mod.funcInfo(func_index);
     const decl = mod.declPtr(func.owner_decl);
     const namespace = mod.namespacePtr(decl.src_namespace);
-    const target = namespace.file_scope.mod.target;
+    const target = namespace.file_scope.mod.resolved_target.result;
     var code_gen: CodeGen = .{
-        .gpa = bin_file.allocator,
+        .gpa = gpa,
         .air = air,
         .liveness = liveness,
         .code = code,
 @@ -7731,7 +7733,7 @@ fn airFence(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     // Only when the atomic feature is enabled, and we're not building
     // for a single-threaded build, can we emit the `fence` instruction.
     // In all other cases, we emit no instructions for a fence.
-    const func_namespace = zcu.namespacePtr(zcu.declPtr(func.decl).namespace);
+    const func_namespace = zcu.namespacePtr(func.decl.src_namespace);
     const single_threaded = func_namespace.file_scope.mod.single_threaded;
     if (func.useAtomicFeature() and !single_threaded) {
         try func.addAtomicTag(.atomic_fence);

src/arch/wasm/Emit.zig+17-7

...	@@ -254,8 +254,10 @@ fn offset(self: Emit) u32 {	...	@@ -254,8 +254,10 @@ fn offset(self: Emit) u32 {
254	fn fail(emit: *Emit, comptime format: []const u8, args: anytype) InnerError {	254	fn fail(emit: *Emit, comptime format: []const u8, args: anytype) InnerError {
255	@setCold(true);	255	@setCold(true);
256	std.debug.assert(emit.error_msg == null);	256	std.debug.assert(emit.error_msg == null);
257	const mod = emit.bin_file.base.comp.module.?;	257	const comp = emit.bin_file.base.comp;
258	emit.error_msg = try Module.ErrorMsg.create(emit.bin_file.base.allocator, mod.declPtr(emit.decl_index).srcLoc(mod), format, args);	258	const zcu = comp.module.?;
		259	const gpa = comp.gpa;
		260	emit.error_msg = try Module.ErrorMsg.create(gpa, zcu.declPtr(emit.decl_index).srcLoc(zcu), format, args);
259	return error.EmitFail;	261	return error.EmitFail;
260	}	262	}
261		263
...	@@ -299,6 +301,8 @@ fn emitLabel(emit: *Emit, tag: Mir.Inst.Tag, inst: Mir.Inst.Index) !void {	...	@@ -299,6 +301,8 @@ fn emitLabel(emit: *Emit, tag: Mir.Inst.Tag, inst: Mir.Inst.Index) !void {
299	}	301	}
300		302
301	fn emitGlobal(emit: *Emit, tag: Mir.Inst.Tag, inst: Mir.Inst.Index) !void {	303	fn emitGlobal(emit: *Emit, tag: Mir.Inst.Tag, inst: Mir.Inst.Index) !void {
		304	const comp = emit.bin_file.base.comp;
		305	const gpa = comp.gpa;
302	const label = emit.mir.instructions.items(.data)[inst].label;	306	const label = emit.mir.instructions.items(.data)[inst].label;
303	try emit.code.append(@intFromEnum(tag));	307	try emit.code.append(@intFromEnum(tag));
304	var buf: [5]u8 = undefined;	308	var buf: [5]u8 = undefined;
...	@@ -308,7 +312,7 @@ fn emitGlobal(emit: *Emit, tag: Mir.Inst.Tag, inst: Mir.Inst.Index) !void {	...	@@ -308,7 +312,7 @@ fn emitGlobal(emit: *Emit, tag: Mir.Inst.Tag, inst: Mir.Inst.Index) !void {
308		312
309	const atom_index = emit.bin_file.decls.get(emit.decl_index).?;	313	const atom_index = emit.bin_file.decls.get(emit.decl_index).?;
310	const atom = emit.bin_file.getAtomPtr(atom_index);	314	const atom = emit.bin_file.getAtomPtr(atom_index);
311	try atom.relocs.append(emit.bin_file.base.allocator, .{	315	try atom.relocs.append(gpa, .{
312	.index = label,	316	.index = label,
313	.offset = global_offset,	317	.offset = global_offset,
314	.relocation_type = .R_WASM_GLOBAL_INDEX_LEB,	318	.relocation_type = .R_WASM_GLOBAL_INDEX_LEB,
...	@@ -356,6 +360,8 @@ fn encodeMemArg(mem_arg: Mir.MemArg, writer: anytype) !void {	...	@@ -356,6 +360,8 @@ fn encodeMemArg(mem_arg: Mir.MemArg, writer: anytype) !void {
356	}	360	}
357		361
358	fn emitCall(emit: *Emit, inst: Mir.Inst.Index) !void {	362	fn emitCall(emit: *Emit, inst: Mir.Inst.Index) !void {
		363	const comp = emit.bin_file.base.comp;
		364	const gpa = comp.gpa;
359	const label = emit.mir.instructions.items(.data)[inst].label;	365	const label = emit.mir.instructions.items(.data)[inst].label;
360	try emit.code.append(std.wasm.opcode(.call));	366	try emit.code.append(std.wasm.opcode(.call));
361	const call_offset = emit.offset();	367	const call_offset = emit.offset();
...	@@ -366,7 +372,7 @@ fn emitCall(emit: *Emit, inst: Mir.Inst.Index) !void {	...	@@ -366,7 +372,7 @@ fn emitCall(emit: *Emit, inst: Mir.Inst.Index) !void {
366	if (label != 0) {	372	if (label != 0) {
367	const atom_index = emit.bin_file.decls.get(emit.decl_index).?;	373	const atom_index = emit.bin_file.decls.get(emit.decl_index).?;
368	const atom = emit.bin_file.getAtomPtr(atom_index);	374	const atom = emit.bin_file.getAtomPtr(atom_index);
369	try atom.relocs.append(emit.bin_file.base.allocator, .{	375	try atom.relocs.append(gpa, .{
370	.offset = call_offset,	376	.offset = call_offset,
371	.index = label,	377	.index = label,
372	.relocation_type = .R_WASM_FUNCTION_INDEX_LEB,	378	.relocation_type = .R_WASM_FUNCTION_INDEX_LEB,
...	@@ -384,6 +390,8 @@ fn emitCallIndirect(emit: *Emit, inst: Mir.Inst.Index) !void {	...	@@ -384,6 +390,8 @@ fn emitCallIndirect(emit: *Emit, inst: Mir.Inst.Index) !void {
384	}	390	}
385		391
386	fn emitFunctionIndex(emit: *Emit, inst: Mir.Inst.Index) !void {	392	fn emitFunctionIndex(emit: *Emit, inst: Mir.Inst.Index) !void {
		393	const comp = emit.bin_file.base.comp;
		394	const gpa = comp.gpa;
387	const symbol_index = emit.mir.instructions.items(.data)[inst].label;	395	const symbol_index = emit.mir.instructions.items(.data)[inst].label;
388	try emit.code.append(std.wasm.opcode(.i32_const));	396	try emit.code.append(std.wasm.opcode(.i32_const));
389	const index_offset = emit.offset();	397	const index_offset = emit.offset();
...	@@ -394,7 +402,7 @@ fn emitFunctionIndex(emit: *Emit, inst: Mir.Inst.Index) !void {	...	@@ -394,7 +402,7 @@ fn emitFunctionIndex(emit: *Emit, inst: Mir.Inst.Index) !void {
394	if (symbol_index != 0) {	402	if (symbol_index != 0) {
395	const atom_index = emit.bin_file.decls.get(emit.decl_index).?;	403	const atom_index = emit.bin_file.decls.get(emit.decl_index).?;
396	const atom = emit.bin_file.getAtomPtr(atom_index);	404	const atom = emit.bin_file.getAtomPtr(atom_index);
397	try atom.relocs.append(emit.bin_file.base.allocator, .{	405	try atom.relocs.append(gpa, .{
398	.offset = index_offset,	406	.offset = index_offset,
399	.index = symbol_index,	407	.index = symbol_index,
400	.relocation_type = .R_WASM_TABLE_INDEX_SLEB,	408	.relocation_type = .R_WASM_TABLE_INDEX_SLEB,
...	@@ -406,7 +414,9 @@ fn emitMemAddress(emit: *Emit, inst: Mir.Inst.Index) !void {	...	@@ -406,7 +414,9 @@ fn emitMemAddress(emit: *Emit, inst: Mir.Inst.Index) !void {
406	const extra_index = emit.mir.instructions.items(.data)[inst].payload;	414	const extra_index = emit.mir.instructions.items(.data)[inst].payload;
407	const mem = emit.mir.extraData(Mir.Memory, extra_index).data;	415	const mem = emit.mir.extraData(Mir.Memory, extra_index).data;
408	const mem_offset = emit.offset() + 1;	416	const mem_offset = emit.offset() + 1;
409	const target = emit.bin_file.comp.root_mod.resolved_target.result;	417	const comp = emit.bin_file.base.comp;
		418	const gpa = comp.gpa;
		419	const target = comp.root_mod.resolved_target.result;
410	const is_wasm32 = target.cpu.arch == .wasm32;	420	const is_wasm32 = target.cpu.arch == .wasm32;
411	if (is_wasm32) {	421	if (is_wasm32) {
412	try emit.code.append(std.wasm.opcode(.i32_const));	422	try emit.code.append(std.wasm.opcode(.i32_const));
...	@@ -423,7 +433,7 @@ fn emitMemAddress(emit: *Emit, inst: Mir.Inst.Index) !void {	...	@@ -423,7 +433,7 @@ fn emitMemAddress(emit: *Emit, inst: Mir.Inst.Index) !void {
423	if (mem.pointer != 0) {	433	if (mem.pointer != 0) {
424	const atom_index = emit.bin_file.decls.get(emit.decl_index).?;	434	const atom_index = emit.bin_file.decls.get(emit.decl_index).?;
425	const atom = emit.bin_file.getAtomPtr(atom_index);	435	const atom = emit.bin_file.getAtomPtr(atom_index);
426	try atom.relocs.append(emit.bin_file.base.allocator, .{	436	try atom.relocs.append(gpa, .{
427	.offset = mem_offset,	437	.offset = mem_offset,
428	.index = mem.pointer,	438	.index = mem.pointer,
429	.relocation_type = if (is_wasm32) .R_WASM_MEMORY_ADDR_LEB else .R_WASM_MEMORY_ADDR_LEB64,	439	.relocation_type = if (is_wasm32) .R_WASM_MEMORY_ADDR_LEB else .R_WASM_MEMORY_ADDR_LEB64,

src/arch/x86_64/CodeGen.zig+23-19

 @@ -795,15 +795,16 @@ pub fn generate(
     code: *std.ArrayList(u8),
     debug_output: DebugInfoOutput,
 ) CodeGenError!Result {
-    const mod = bin_file.comp.module.?;
+    const comp = bin_file.comp;
+    const gpa = comp.gpa;
+    const mod = comp.module.?;
     const func = mod.funcInfo(func_index);
     const fn_owner_decl = mod.declPtr(func.owner_decl);
     assert(fn_owner_decl.has_tv);
     const fn_type = fn_owner_decl.ty;
     const namespace = mod.namespacePtr(fn_owner_decl.src_namespace);
-    const target = namespace.file_scope.mod.target;
+    const target = namespace.file_scope.mod.resolved_target.result;
-    const gpa = bin_file.allocator;
     var function = Self{
         .gpa = gpa,
         .air = air,
 @@ -860,7 +861,7 @@ pub fn generate(
         error.CodegenFail => return Result{ .fail = function.err_msg.? },
         error.OutOfRegisters => return Result{
             .fail = try ErrorMsg.create(
-                bin_file.allocator,
+                gpa,
                 src_loc,
                 "CodeGen ran out of registers. This is a bug in the Zig compiler.",
                 .{},
 @@ -904,22 +905,22 @@ pub fn generate(
     function.gen() catch |err| switch (err) {
         error.CodegenFail => return Result{ .fail = function.err_msg.? },
         error.OutOfRegisters => return Result{
-            .fail = try ErrorMsg.create(bin_file.allocator, src_loc, "CodeGen ran out of registers. This is a bug in the Zig compiler.", .{}),
+            .fail = try ErrorMsg.create(gpa, src_loc, "CodeGen ran out of registers. This is a bug in the Zig compiler.", .{}),
         },
         else => |e| return e,
     };
     var mir = Mir{
         .instructions = function.mir_instructions.toOwnedSlice(),
-        .extra = try function.mir_extra.toOwnedSlice(bin_file.allocator),
+        .extra = try function.mir_extra.toOwnedSlice(gpa),
         .frame_locs = function.frame_locs.toOwnedSlice(),
     };
-    defer mir.deinit(bin_file.allocator);
+    defer mir.deinit(gpa);
     var emit = Emit{
         .lower = .{
             .bin_file = bin_file,
-            .allocator = bin_file.allocator,
+            .allocator = gpa,
             .mir = mir,
             .cc = cc,
             .src_loc = src_loc,
 @@ -940,7 +941,7 @@ pub fn generate(
             };
             return Result{
                 .fail = try ErrorMsg.create(
-                    bin_file.allocator,
+                    gpa,
                     src_loc,
                     "{s} This is a bug in the Zig compiler.",
                     .{msg},
 @@ -964,12 +965,13 @@ pub fn generateLazy(
     code: *std.ArrayList(u8),
     debug_output: DebugInfoOutput,
 ) CodeGenError!Result {
-    const gpa = bin_file.allocator;
+    const comp = bin_file.comp;
-    const zcu = bin_file.comp.module.?;
+    const gpa = comp.gpa;
+    const zcu = comp.module.?;
     const decl_index = lazy_sym.ty.getOwnerDecl(zcu);
     const decl = zcu.declPtr(decl_index);
     const namespace = zcu.namespacePtr(decl.src_namespace);
-    const target = namespace.file_scope.mod.target;
+    const target = namespace.file_scope.mod.resolved_target.result;
     var function = Self{
         .gpa = gpa,
         .air = undefined,
 @@ -996,22 +998,22 @@ pub fn generateLazy(
     function.genLazy(lazy_sym) catch |err| switch (err) {
         error.CodegenFail => return Result{ .fail = function.err_msg.? },
         error.OutOfRegisters => return Result{
-            .fail = try ErrorMsg.create(bin_file.allocator, src_loc, "CodeGen ran out of registers. This is a bug in the Zig compiler.", .{}),
+            .fail = try ErrorMsg.create(gpa, src_loc, "CodeGen ran out of registers. This is a bug in the Zig compiler.", .{}),
         },
         else => |e| return e,
     };
     var mir = Mir{
         .instructions = function.mir_instructions.toOwnedSlice(),
-        .extra = try function.mir_extra.toOwnedSlice(bin_file.allocator),
+        .extra = try function.mir_extra.toOwnedSlice(gpa),
         .frame_locs = function.frame_locs.toOwnedSlice(),
     };
-    defer mir.deinit(bin_file.allocator);
+    defer mir.deinit(gpa);
     var emit = Emit{
         .lower = .{
             .bin_file = bin_file,
-            .allocator = bin_file.allocator,
+            .allocator = gpa,
             .mir = mir,
             .cc = abi.resolveCallingConvention(.Unspecified, function.target.*),
             .src_loc = src_loc,
 @@ -1032,7 +1034,7 @@ pub fn generateLazy(
             };
             return Result{
                 .fail = try ErrorMsg.create(
-                    bin_file.allocator,
+                    gpa,
                     src_loc,
                     "{s} This is a bug in the Zig compiler.",
                     .{msg},
 @@ -16416,14 +16418,16 @@ fn resolveCallingConventionValues(
 fn fail(self: *Self, comptime format: []const u8, args: anytype) InnerError {
     @setCold(true);
     assert(self.err_msg == null);
-    self.err_msg = try ErrorMsg.create(self.bin_file.allocator, self.src_loc, format, args);
+    const gpa = self.gpa;
+    self.err_msg = try ErrorMsg.create(gpa, self.src_loc, format, args);
     return error.CodegenFail;
 }
 fn failSymbol(self: *Self, comptime format: []const u8, args: anytype) InnerError {
     @setCold(true);
     assert(self.err_msg == null);
-    self.err_msg = try ErrorMsg.create(self.bin_file.allocator, self.src_loc, format, args);
+    const gpa = self.gpa;
+    self.err_msg = try ErrorMsg.create(gpa, self.src_loc, format, args);
     return error.CodegenFail;
 }

src/codegen.zig+19-14

src/codegen/llvm.zig+2-2

src/libunwind.zig+1-1

...	@@ -123,7 +123,7 @@ pub fn buildStaticLib(comp: Compilation, prog_node: std.Progress.Node) !void {	...	@@ -123,7 +123,7 @@ pub fn buildStaticLib(comp: Compilation, prog_node: std.Progress.Node) !void {
123	.local_cache_directory = comp.global_cache_directory,	123	.local_cache_directory = comp.global_cache_directory,
124	.global_cache_directory = comp.global_cache_directory,	124	.global_cache_directory = comp.global_cache_directory,
125	.zig_lib_directory = comp.zig_lib_directory,	125	.zig_lib_directory = comp.zig_lib_directory,
126	.resolved = config,	126	.config = config,
127	.root_mod = root_mod,	127	.root_mod = root_mod,
128	.cache_mode = .whole,	128	.cache_mode = .whole,
129	.root_name = root_name,	129	.root_name = root_name,

src/link.zig+28-35

 @@ -69,10 +69,12 @@ pub const File = struct {
     allow_shlib_undefined: bool,
     stack_size: u64,
+    error_flags: ErrorFlags = .{},
+    misc_errors: std.ArrayListUnmanaged(ErrorMsg) = .{},
     /// Prevents other processes from clobbering files in the output directory
     /// of this linking operation.
     lock: ?Cache.Lock = null,
     child_pid: ?std.ChildProcess.Id = null,
     pub const OpenOptions = struct {
 @@ -210,6 +212,8 @@ pub const File = struct {
     }
     pub fn makeWritable(base: *File) !void {
+        const comp = base.comp;
+        const gpa = comp.gpa;
         switch (base.tag) {
             .coff, .elf, .macho, .plan9, .wasm => {
                 if (build_options.only_c) unreachable;
 @@ -225,9 +229,10 @@ pub const File = struct {
                         // it will return ETXTBSY. So instead, we copy the file, atomically rename it
                         // over top of the exe path, and then proceed normally. This changes the inode,
                         // avoiding the error.
-                        const tmp_sub_path = try std.fmt.allocPrint(base.allocator, "{s}-{x}", .{
+                        const tmp_sub_path = try std.fmt.allocPrint(gpa, "{s}-{x}", .{
                             emit.sub_path, std.crypto.random.int(u32),
                         });
+                        defer gpa.free(tmp_sub_path);
                         try emit.directory.handle.copyFile(emit.sub_path, emit.directory.handle, tmp_sub_path, .{});
                         try emit.directory.handle.rename(tmp_sub_path, emit.sub_path);
                         switch (builtin.os.tag) {
 @@ -242,9 +247,9 @@ pub const File = struct {
                         }
                     }
                 }
-                const use_lld = build_options.have_llvm and base.comp.config.use_lld;
+                const use_lld = build_options.have_llvm and comp.config.use_lld;
-                const output_mode = base.comp.config.output_mode;
+                const output_mode = comp.config.output_mode;
-                const link_mode = base.comp.config.link_mode;
+                const link_mode = comp.config.link_mode;
                 base.file = try emit.directory.handle.createFile(emit.sub_path, .{
                     .truncate = false,
                     .read = true,
 @@ -256,9 +261,10 @@ pub const File = struct {
     }
     pub fn makeExecutable(base: *File) !void {
-        const output_mode = base.comp.config.output_mode;
+        const comp = base.comp;
-        const link_mode = base.comp.config.link_mode;
+        const output_mode = comp.config.output_mode;
-        const use_lld = build_options.have_llvm and base.comp.config.use_lld;
+        const link_mode = comp.config.link_mode;
+        const use_lld = build_options.have_llvm and comp.config.use_lld;
         switch (output_mode) {
             .Obj => return,
 @@ -464,8 +470,13 @@ pub const File = struct {
     }
     pub fn destroy(base: *File) void {
+        const gpa = base.comp.gpa;
         base.releaseLock();
         if (base.file) |f| f.close();
+        {
+            for (base.misc_errors.items) |*item| item.deinit(gpa);
+            base.misc_errors.deinit(gpa);
+        }
         switch (base.tag) {
             .coff => {
                 if (build_options.only_c) unreachable;
 @@ -602,9 +613,9 @@ pub const File = struct {
             return;
         }
-        const use_lld = build_options.have_llvm and base.comp.config.use_lld;
+        const use_lld = build_options.have_llvm and comp.config.use_lld;
-        const output_mode = base.comp.config.output_mode;
+        const output_mode = comp.config.output_mode;
-        const link_mode = base.comp.config.link_mode;
+        const link_mode = comp.config.link_mode;
         if (use_lld and output_mode == .Lib and link_mode == .Static) {
             return base.linkAsArchive(comp, prog_node);
         }
 @@ -657,25 +668,6 @@ pub const File = struct {
         }
     }
-    pub fn errorFlags(base: *File) ErrorFlags {
-        switch (base.tag) {
-            .coff => return @fieldParentPtr(Coff, "base", base).error_flags,
-            .elf => return @fieldParentPtr(Elf, "base", base).error_flags,
-            .macho => return @fieldParentPtr(MachO, "base", base).error_flags,
-            .plan9 => return @fieldParentPtr(Plan9, "base", base).error_flags,
-            .c => return .{ .no_entry_point_found = false },
-            .wasm, .spirv, .nvptx => return ErrorFlags{},
-        }
-    }
-    pub fn miscErrors(base: *File) []const ErrorMsg {
-        switch (base.tag) {
-            .elf => return @fieldParentPtr(Elf, "base", base).misc_errors.items,
-            .macho => return @fieldParentPtr(MachO, "base", base).misc_errors.items,
-            else => return &.{},
-        }
-    }
     pub const UpdateExportsError = error{
         OutOfMemory,
         AnalysisFail,
 @@ -781,14 +773,15 @@ pub const File = struct {
         const tracy = trace(@src());
         defer tracy.end();
-        var arena_allocator = std.heap.ArenaAllocator.init(base.allocator);
+        const gpa = comp.gpa;
+        var arena_allocator = std.heap.ArenaAllocator.init(gpa);
         defer arena_allocator.deinit();
         const arena = arena_allocator.allocator();
         const directory = base.emit.directory; // Just an alias to make it shorter to type.
         const full_out_path = try directory.join(arena, &[_][]const u8{base.emit.sub_path});
         const full_out_path_z = try arena.dupeZ(u8, full_out_path);
-        const opt_zcu = base.comp.module;
+        const opt_zcu = comp.module;
         // If there is no Zig code to compile, then we should skip flushing the output file
         // because it will not be part of the linker line anyway.
 @@ -801,7 +794,7 @@ pub const File = struct {
         log.debug("zcu_obj_path={s}", .{if (zcu_obj_path) |s| s else "(null)"});
-        const compiler_rt_path: ?[]const u8 = if (base.comp.include_compiler_rt)
+        const compiler_rt_path: ?[]const u8 = if (comp.include_compiler_rt)
             comp.compiler_rt_obj.?.full_object_path
         else
             null;
 @@ -815,7 +808,7 @@ pub const File = struct {
         var man: Cache.Manifest = undefined;
         defer if (!base.disable_lld_caching) man.deinit();
-        const objects = base.comp.objects;
+        const objects = comp.objects;
         var digest: [Cache.hex_digest_len]u8 = undefined;
 @@ -869,7 +862,7 @@ pub const File = struct {
         const win32_resource_table_len = if (build_options.only_core_functionality) 0 else comp.win32_resource_table.count();
         const num_object_files = objects.len + comp.c_object_table.count() + win32_resource_table_len + 2;
-        var object_files = try std.ArrayList([*:0]const u8).initCapacity(base.allocator, num_object_files);
+        var object_files = try std.ArrayList([*:0]const u8).initCapacity(gpa, num_object_files);
         defer object_files.deinit();
         for (objects) |obj| {

src/link/C.zig+11-1

 @@ -84,7 +84,8 @@ pub fn getString(this: C, s: String) []const u8 {
 }
 pub fn addString(this: *C, s: []const u8) Allocator.Error!String {
-    const gpa = this.base.allocator;
+    const comp = this.base.comp;
+    const gpa = comp.gpa;
     try this.string_bytes.appendSlice(gpa, s);
     return .{
         .start = @intCast(this.string_bytes.items.len - s.len),
 @@ -97,6 +98,15 @@ pub fn open(
     comp: *Compilation,
     emit: Compilation.Emit,
     options: link.File.OpenOptions,
+) !*C {
+    return createEmpty(arena, comp, emit, options);
+}
+pub fn createEmpty(
+    arena: Allocator,
+    comp: *Compilation,
+    emit: Compilation.Emit,
+    options: link.File.OpenOptions,
 ) !*C {
     const target = comp.root_mod.resolved_target.result;
     assert(target.ofmt == .c);

src/link/Coff.zig+2-3

...	@@ -8,7 +8,6 @@ llvm_object: ?*LlvmObject = null,	...	@@ -8,7 +8,6 @@ llvm_object: ?*LlvmObject = null,
8		8
9	base: link.File,	9	base: link.File,
10	image_base: u64,	10	image_base: u64,
11	error_flags: link.File.ErrorFlags = .{},
12	dll_export_fns: bool,	11	dll_export_fns: bool,
13	subsystem: ?std.Target.SubSystem,	12	subsystem: ?std.Target.SubSystem,
14	tsaware: bool,	13	tsaware: bool,
...	@@ -1825,10 +1824,10 @@ pub fn flushModule(self: Coff, comp: Compilation, prog_node: *std.Progress.Nod	...	@@ -1825,10 +1824,10 @@ pub fn flushModule(self: Coff, comp: Compilation, prog_node: *std.Progress.Nod
1825		1824
1826	if (self.entry_addr == null and self.base.comp.config.output_mode == .Exe) {	1825	if (self.entry_addr == null and self.base.comp.config.output_mode == .Exe) {
1827	log.debug("flushing. no_entry_point_found = true\n", .{});	1826	log.debug("flushing. no_entry_point_found = true\n", .{});
1828	self.error_flags.no_entry_point_found = true;	1827	self.base.error_flags.no_entry_point_found = true;
1829	} else {	1828	} else {
1830	log.debug("flushing. no_entry_point_found = false\n", .{});	1829	log.debug("flushing. no_entry_point_found = false\n", .{});
1831	self.error_flags.no_entry_point_found = false;	1830	self.base.error_flags.no_entry_point_found = false;
1832	try self.writeHeader();	1831	try self.writeHeader();
1833	}	1832	}
1834		1833

src/link/Coff/Atom.zig+6-3

src/link/Dwarf.zig+1-1

...	@@ -1205,7 +1205,7 @@ pub fn commitDeclState(	...	@@ -1205,7 +1205,7 @@ pub fn commitDeclState(
1205	const decl = zcu.declPtr(decl_index);	1205	const decl = zcu.declPtr(decl_index);
1206	const ip = &zcu.intern_pool;	1206	const ip = &zcu.intern_pool;
1207	const namespace = zcu.namespacePtr(decl.src_namespace);	1207	const namespace = zcu.namespacePtr(decl.src_namespace);
1208	const target = namespace.file_scope.mod.target;	1208	const target = namespace.file_scope.mod.resolved_target.result;
1209	const target_endian = target.cpu.arch.endian();	1209	const target_endian = target.cpu.arch.endian();
1210		1210
1211	var dbg_line_buffer = &decl_state.dbg_line;	1211	var dbg_line_buffer = &decl_state.dbg_line;

src/link/Elf.zig+25-27

src/link/Elf/Atom.zig+10-4

...	@@ -227,7 +227,8 @@ pub fn grow(self: Atom, elf_file: Elf) !void {	...	@@ -227,7 +227,8 @@ pub fn grow(self: Atom, elf_file: Elf) !void {
227	pub fn free(self: Atom, elf_file: Elf) void {	227	pub fn free(self: Atom, elf_file: Elf) void {
228	log.debug("freeAtom {d} ({s})", .{ self.atom_index, self.name(elf_file) });	228	log.debug("freeAtom {d} ({s})", .{ self.atom_index, self.name(elf_file) });
229		229
230	const gpa = elf_file.base.allocator;	230	const comp = elf_file.base.comp;
		231	const gpa = comp.gpa;
231	const shndx = self.outputShndx().?;	232	const shndx = self.outputShndx().?;
232	const meta = elf_file.last_atom_and_free_list_table.getPtr(shndx).?;	233	const meta = elf_file.last_atom_and_free_list_table.getPtr(shndx).?;
233	const free_list = &meta.free_list;	234	const free_list = &meta.free_list;
...	@@ -352,7 +353,8 @@ pub fn markFdesDead(self: Atom, elf_file: *Elf) void {	...	@@ -352,7 +353,8 @@ pub fn markFdesDead(self: Atom, elf_file: *Elf) void {
352	}	353	}
353		354
354	pub fn addReloc(self: Atom, elf_file: *Elf, reloc: elf.Elf64_Rela) !void {	355	pub fn addReloc(self: Atom, elf_file: *Elf, reloc: elf.Elf64_Rela) !void {
355	const gpa = elf_file.base.allocator;	356	const comp = elf_file.base.comp;
		357	const gpa = comp.gpa;
356	const file_ptr = self.file(elf_file).?;	358	const file_ptr = self.file(elf_file).?;
357	assert(file_ptr == .zig_object);	359	assert(file_ptr == .zig_object);
358	const zig_object = file_ptr.zig_object;	360	const zig_object = file_ptr.zig_object;
...	@@ -747,6 +749,8 @@ fn reportUndefined(	...	@@ -747,6 +749,8 @@ fn reportUndefined(
747	rel: elf.Elf64_Rela,	749	rel: elf.Elf64_Rela,
748	undefs: anytype,	750	undefs: anytype,
749	) !void {	751	) !void {
		752	const comp = elf_file.base.comp;
		753	const gpa = comp.gpa;
750	const rel_esym = switch (self.file(elf_file).?) {	754	const rel_esym = switch (self.file(elf_file).?) {
751	.zig_object => \|x\| x.elfSym(rel.r_sym()).*,	755	.zig_object => \|x\| x.elfSym(rel.r_sym()).*,
752	.object => \|x\| x.symtab.items[rel.r_sym()],	756	.object => \|x\| x.symtab.items[rel.r_sym()],
...	@@ -761,7 +765,7 @@ fn reportUndefined(	...	@@ -761,7 +765,7 @@ fn reportUndefined(
761	{	765	{
762	const gop = try undefs.getOrPut(sym_index);	766	const gop = try undefs.getOrPut(sym_index);
763	if (!gop.found_existing) {	767	if (!gop.found_existing) {
764	gop.value_ptr.* = std.ArrayList(Atom.Index).init(elf_file.base.allocator);	768	gop.value_ptr.* = std.ArrayList(Atom.Index).init(gpa);
765	}	769	}
766	try gop.value_ptr.append(self.atom_index);	770	try gop.value_ptr.append(self.atom_index);
767	}	771	}
...	@@ -957,6 +961,8 @@ fn resolveDynAbsReloc(	...	@@ -957,6 +961,8 @@ fn resolveDynAbsReloc(
957	elf_file: *Elf,	961	elf_file: *Elf,
958	writer: anytype,	962	writer: anytype,
959	) !void {	963	) !void {
		964	const comp = elf_file.base.comp;
		965	const gpa = comp.gpa;
960	const P = self.value + rel.r_offset;	966	const P = self.value + rel.r_offset;
961	const A = rel.r_addend;	967	const A = rel.r_addend;
962	const S = @as(i64, @intCast(target.address(.{}, elf_file)));	968	const S = @as(i64, @intCast(target.address(.{}, elf_file)));
...	@@ -967,7 +973,7 @@ fn resolveDynAbsReloc(	...	@@ -967,7 +973,7 @@ fn resolveDynAbsReloc(
967	.shared_object => unreachable,	973	.shared_object => unreachable,
968	inline else => \|x\| x.num_dynrelocs,	974	inline else => \|x\| x.num_dynrelocs,
969	};	975	};
970	try elf_file.rela_dyn.ensureUnusedCapacity(elf_file.base.allocator, num_dynrelocs);	976	try elf_file.rela_dyn.ensureUnusedCapacity(gpa, num_dynrelocs);
971		977
972	switch (action) {	978	switch (action) {
973	.@"error",	979	.@"error",

src/link/MachO.zig+17-25

 @@ -67,9 +67,6 @@ tlv_ptr_table: TableSection(SymbolWithLoc) = .{},
 thunk_table: std.AutoHashMapUnmanaged(Atom.Index, thunks.Thunk.Index) = .{},
 thunks: std.ArrayListUnmanaged(thunks.Thunk) = .{},
-error_flags: File.ErrorFlags = File.ErrorFlags{},
-misc_errors: std.ArrayListUnmanaged(File.ErrorMsg) = .{},
 segment_table_dirty: bool = false,
 got_table_count_dirty: bool = false,
 got_table_contents_dirty: bool = false,
 @@ -337,8 +334,8 @@ pub fn flush(self: *MachO, comp: *Compilation, prog_node: *std.Progress.Node) li
         if (build_options.have_llvm) {
             return self.base.linkAsArchive(comp, prog_node);
         } else {
-            try self.misc_errors.ensureUnusedCapacity(gpa, 1);
+            try self.base.misc_errors.ensureUnusedCapacity(gpa, 1);
-            self.misc_errors.appendAssumeCapacity(.{
+            self.base.misc_errors.appendAssumeCapacity(.{
                 .msg = try gpa.dupe(u8, "TODO: non-LLVM archiver for MachO object files"),
             });
             return error.FlushFailure;
 @@ -492,7 +489,7 @@ pub fn flushModule(self: *MachO, comp: *Compilation, prog_node: *std.Progress.No
     try self.resolveSymbols();
     if (self.getEntryPoint() == null) {
-        self.error_flags.no_entry_point_found = true;
+        self.base.error_flags.no_entry_point_found = true;
     }
     if (self.unresolved.count() > 0) {
         try self.reportUndefined();
 @@ -2097,11 +2094,6 @@ pub fn deinit(self: *MachO) void {
         bindings.deinit(gpa);
     }
     self.bindings.deinit(gpa);
-    for (self.misc_errors.items) |*err| {
-        err.deinit(gpa);
-    }
-    self.misc_errors.deinit(gpa);
 }
 fn freeAtom(self: *MachO, atom_index: Atom.Index) void {
 @@ -5341,13 +5333,13 @@ fn reportMissingLibraryError(
     args: anytype,
 ) error{OutOfMemory}!void {
     const gpa = self.base.comp.gpa;
-    try self.misc_errors.ensureUnusedCapacity(gpa, 1);
+    try self.base.misc_errors.ensureUnusedCapacity(gpa, 1);
     const notes = try gpa.alloc(File.ErrorMsg, checked_paths.len);
     errdefer gpa.free(notes);
     for (checked_paths, notes) |path, *note| {
         note.* = .{ .msg = try std.fmt.allocPrint(gpa, "tried {s}", .{path}) };
     }
-    self.misc_errors.appendAssumeCapacity(.{
+    self.base.misc_errors.appendAssumeCapacity(.{
         .msg = try std.fmt.allocPrint(gpa, format, args),
         .notes = notes,
     });
 @@ -5361,14 +5353,14 @@ fn reportDependencyError(
     args: anytype,
 ) error{OutOfMemory}!void {
     const gpa = self.base.comp.gpa;
-    try self.misc_errors.ensureUnusedCapacity(gpa, 1);
+    try self.base.misc_errors.ensureUnusedCapacity(gpa, 1);
     var notes = try std.ArrayList(File.ErrorMsg).initCapacity(gpa, 2);
     defer notes.deinit();
     if (path) |p| {
         notes.appendAssumeCapacity(.{ .msg = try std.fmt.allocPrint(gpa, "while parsing {s}", .{p}) });
     }
     notes.appendAssumeCapacity(.{ .msg = try std.fmt.allocPrint(gpa, "a dependency of {s}", .{parent}) });
-    self.misc_errors.appendAssumeCapacity(.{
+    self.base.misc_errors.appendAssumeCapacity(.{
         .msg = try std.fmt.allocPrint(gpa, format, args),
         .notes = try notes.toOwnedSlice(),
     });
 @@ -5381,11 +5373,11 @@ pub fn reportParseError(
     args: anytype,
 ) error{OutOfMemory}!void {
     const gpa = self.base.comp.gpa;
-    try self.misc_errors.ensureUnusedCapacity(gpa, 1);
+    try self.base.misc_errors.ensureUnusedCapacity(gpa, 1);
     var notes = try gpa.alloc(File.ErrorMsg, 1);
     errdefer gpa.free(notes);
     notes[0] = .{ .msg = try std.fmt.allocPrint(gpa, "while parsing {s}", .{path}) };
-    self.misc_errors.appendAssumeCapacity(.{
+    self.base.misc_errors.appendAssumeCapacity(.{
         .msg = try std.fmt.allocPrint(gpa, format, args),
         .notes = notes,
     });
 @@ -5398,11 +5390,11 @@ pub fn reportUnresolvedBoundarySymbol(
     args: anytype,
 ) error{OutOfMemory}!void {
     const gpa = self.base.comp.gpa;
-    try self.misc_errors.ensureUnusedCapacity(gpa, 1);
+    try self.base.misc_errors.ensureUnusedCapacity(gpa, 1);
     var notes = try gpa.alloc(File.ErrorMsg, 1);
     errdefer gpa.free(notes);
     notes[0] = .{ .msg = try std.fmt.allocPrint(gpa, "while resolving {s}", .{sym_name}) };
-    self.misc_errors.appendAssumeCapacity(.{
+    self.base.misc_errors.appendAssumeCapacity(.{
         .msg = try std.fmt.allocPrint(gpa, format, args),
         .notes = notes,
     });
 @@ -5411,7 +5403,7 @@ pub fn reportUnresolvedBoundarySymbol(
 pub fn reportUndefined(self: *MachO) error{OutOfMemory}!void {
     const gpa = self.base.comp.gpa;
     const count = self.unresolved.count();
-    try self.misc_errors.ensureUnusedCapacity(gpa, count);
+    try self.base.misc_errors.ensureUnusedCapacity(gpa, count);
     for (self.unresolved.keys()) |global_index| {
         const global = self.globals.items[global_index];
 @@ -5432,7 +5424,7 @@ pub fn reportUndefined(self: *MachO) error{OutOfMemory}!void {
         };
         err_msg.notes = try notes.toOwnedSlice();
-        self.misc_errors.appendAssumeCapacity(err_msg);
+        self.base.misc_errors.appendAssumeCapacity(err_msg);
     }
 }
 @@ -5442,7 +5434,7 @@ fn reportSymbolCollision(
     other: SymbolWithLoc,
 ) error{OutOfMemory}!void {
     const gpa = self.base.comp.gpa;
-    try self.misc_errors.ensureUnusedCapacity(gpa, 1);
+    try self.base.misc_errors.ensureUnusedCapacity(gpa, 1);
     var notes = try std.ArrayList(File.ErrorMsg).initCapacity(gpa, 2);
     defer notes.deinit();
 @@ -5465,12 +5457,12 @@ fn reportSymbolCollision(
     }) };
     err_msg.notes = try notes.toOwnedSlice();
-    self.misc_errors.appendAssumeCapacity(err_msg);
+    self.base.misc_errors.appendAssumeCapacity(err_msg);
 }
 fn reportUnhandledSymbolType(self: *MachO, sym_with_loc: SymbolWithLoc) error{OutOfMemory}!void {
     const gpa = self.base.comp.gpa;
-    try self.misc_errors.ensureUnusedCapacity(gpa, 1);
+    try self.base.misc_errors.ensureUnusedCapacity(gpa, 1);
     const notes = try gpa.alloc(File.ErrorMsg, 1);
     errdefer gpa.free(notes);
 @@ -5488,7 +5480,7 @@ fn reportUnhandledSymbolType(self: *MachO, sym_with_loc: SymbolWithLoc) error{Ou
     else
         unreachable;
-    self.misc_errors.appendAssumeCapacity(.{
+    self.base.misc_errors.appendAssumeCapacity(.{
         .msg = try std.fmt.allocPrint(gpa, "unhandled symbol type: '{s}' has type {s}", .{
             self.getSymbolName(sym_with_loc),
             sym_type,

src/link/MachO/Atom.zig+8-4

src/link/Plan9.zig-1

...	@@ -28,7 +28,6 @@ pub const base_tag = .plan9;	...	@@ -28,7 +28,6 @@ pub const base_tag = .plan9;
28		28
29	base: link.File,	29	base: link.File,
30	sixtyfour_bit: bool,	30	sixtyfour_bit: bool,
31	error_flags: File.ErrorFlags = File.ErrorFlags{},
32	bases: Bases,	31	bases: Bases,
33		32
34	/// A symbol's value is just casted down when compiling	33	/// A symbol's value is just casted down when compiling

author	Andrew Kelley <andrew@ziglang.org> 2023-12-14 18:47:58-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2024-01-01 17:51:19-07:00
log	c49957dbe82d7f0db555160b50306335bfa03165
tree	529e84e430b27c3e6f13cb7a2c956b0ee445339c
parent	f54471b54c471bb6f8e51a1383be09d01c24d0c3

...	@@ -57,7 +57,7 @@ pub fn generateFunction(	...	@@ -57,7 +57,7 @@ pub fn generateFunction(
57	const func = zcu.funcInfo(func_index);	57	const func = zcu.funcInfo(func_index);
58	const decl = zcu.declPtr(func.owner_decl);	58	const decl = zcu.declPtr(func.owner_decl);
59	const namespace = zcu.namespacePtr(decl.src_namespace);	59	const namespace = zcu.namespacePtr(decl.src_namespace);
60	const target = namespace.file_scope.mod.target;	60	const target = namespace.file_scope.mod.resolved_target.result;
61	switch (target.cpu.arch) {	61	switch (target.cpu.arch) {
62	.arm,	62	.arm,
63	.armeb,	63	.armeb,
...	@@ -87,7 +87,7 @@ pub fn generateLazyFunction(	...	@@ -87,7 +87,7 @@ pub fn generateLazyFunction(
87	const decl_index = lazy_sym.ty.getOwnerDecl(zcu);	87	const decl_index = lazy_sym.ty.getOwnerDecl(zcu);
88	const decl = zcu.declPtr(decl_index);	88	const decl = zcu.declPtr(decl_index);
89	const namespace = zcu.namespacePtr(decl.src_namespace);	89	const namespace = zcu.namespacePtr(decl.src_namespace);
90	const target = namespace.file_scope.mod.target;	90	const target = namespace.file_scope.mod.resolved_target.result;
91	switch (target.cpu.arch) {	91	switch (target.cpu.arch) {
92	.x86_64 => return @import("arch/x86_64/CodeGen.zig").generateLazy(lf, src_loc, lazy_sym, code, debug_output),	92	.x86_64 => return @import("arch/x86_64/CodeGen.zig").generateLazy(lf, src_loc, lazy_sym, code, debug_output),
93	else => unreachable,	93	else => unreachable,
...	@@ -117,12 +117,14 @@ pub fn generateLazySymbol(	...	@@ -117,12 +117,14 @@ pub fn generateLazySymbol(
117	const tracy = trace(@src());	117	const tracy = trace(@src());
118	defer tracy.end();	118	defer tracy.end();
119		119
120	const zcu = bin_file.comp.module.?;	120	const comp = bin_file.comp;
		121	const zcu = comp.module.?;
121	const decl_index = lazy_sym.ty.getOwnerDecl(zcu);	122	const decl_index = lazy_sym.ty.getOwnerDecl(zcu);
122	const decl = zcu.declPtr(decl_index);	123	const decl = zcu.declPtr(decl_index);
123	const namespace = zcu.namespacePtr(decl.src_namespace);	124	const namespace = zcu.namespacePtr(decl.src_namespace);
124	const target = namespace.file_scope.mod.target;	125	const target = namespace.file_scope.mod.resolved_target.result;
125	const endian = target.cpu.arch.endian();	126	const endian = target.cpu.arch.endian();
		127	const gpa = comp.gpa;
126		128
127	log.debug("generateLazySymbol: kind = {s}, ty = {}", .{	129	log.debug("generateLazySymbol: kind = {s}, ty = {}", .{
128	@tagName(lazy_sym.kind),	130	@tagName(lazy_sym.kind),
...	@@ -160,7 +162,7 @@ pub fn generateLazySymbol(	...	@@ -160,7 +162,7 @@ pub fn generateLazySymbol(
160	}	162	}
161	return Result.ok;	163	return Result.ok;
162	} else return .{ .fail = try ErrorMsg.create(	164	} else return .{ .fail = try ErrorMsg.create(
163	bin_file.allocator,	165	gpa,
164	src_loc,	166	src_loc,
165	"TODO implement generateLazySymbol for {s} {}",	167	"TODO implement generateLazySymbol for {s} {}",
166	.{ @tagName(lazy_sym.kind), lazy_sym.ty.fmt(zcu) },	168	.{ @tagName(lazy_sym.kind), lazy_sym.ty.fmt(zcu) },
...	@@ -827,7 +829,7 @@ fn lowerDeclRef(	...	@@ -827,7 +829,7 @@ fn lowerDeclRef(
827	const zcu = lf.comp.module.?;	829	const zcu = lf.comp.module.?;
828	const decl = zcu.declPtr(decl_index);	830	const decl = zcu.declPtr(decl_index);
829	const namespace = zcu.namespacePtr(decl.src_namespace);	831	const namespace = zcu.namespacePtr(decl.src_namespace);
830	const target = namespace.file_scope.mod.target;	832	const target = namespace.file_scope.mod.resolved_target.result;
831		833
832	const ptr_width = target.ptrBitWidth();	834	const ptr_width = target.ptrBitWidth();
833	const is_fn_body = decl.ty.zigTypeTag(zcu) == .Fn;	835	const is_fn_body = decl.ty.zigTypeTag(zcu) == .Fn;
...	@@ -921,7 +923,7 @@ fn genDeclRef(	...	@@ -921,7 +923,7 @@ fn genDeclRef(
921		923
922	const ptr_decl = zcu.declPtr(ptr_decl_index);	924	const ptr_decl = zcu.declPtr(ptr_decl_index);
923	const namespace = zcu.namespacePtr(ptr_decl.src_namespace);	925	const namespace = zcu.namespacePtr(ptr_decl.src_namespace);
924	const target = namespace.file_scope.mod.target;	926	const target = namespace.file_scope.mod.resolved_target.result;
925		927
926	const ptr_bits = target.ptrBitWidth();	928	const ptr_bits = target.ptrBitWidth();
927	const ptr_bytes: u64 = @divExact(ptr_bits, 8);	929	const ptr_bytes: u64 = @divExact(ptr_bits, 8);
...	@@ -944,6 +946,9 @@ fn genDeclRef(	...	@@ -944,6 +946,9 @@ fn genDeclRef(
944	return GenResult.mcv(.{ .immediate = imm });	946	return GenResult.mcv(.{ .immediate = imm });
945	}	947	}
946		948
		949	const comp = lf.comp;
		950	const gpa = comp.gpa;
		951
947	// TODO this feels clunky. Perhaps we should check for it in `genTypedValue`?	952	// TODO this feels clunky. Perhaps we should check for it in `genTypedValue`?
948	if (tv.ty.castPtrToFn(zcu)) \|fn_ty\| {	953	if (tv.ty.castPtrToFn(zcu)) \|fn_ty\| {
949	if (zcu.typeToFunc(fn_ty).?.is_generic) {	954	if (zcu.typeToFunc(fn_ty).?.is_generic) {
...	@@ -958,8 +963,8 @@ fn genDeclRef(	...	@@ -958,8 +963,8 @@ fn genDeclRef(
958		963
959	try zcu.markDeclAlive(decl);	964	try zcu.markDeclAlive(decl);
960		965
961	const decl_namespace = zcu.namespacePtr(decl.namespace_index);	966	const decl_namespace = zcu.namespacePtr(decl.src_namespace);
962	const single_threaded = decl_namespace.file_scope.zcu.single_threaded;	967	const single_threaded = decl_namespace.file_scope.mod.single_threaded;
963	const is_threadlocal = tv.val.isPtrToThreadLocal(zcu) and !single_threaded;	968	const is_threadlocal = tv.val.isPtrToThreadLocal(zcu) and !single_threaded;
964	const is_extern = decl.isExtern(zcu);	969	const is_extern = decl.isExtern(zcu);
965		970
...	@@ -985,8 +990,8 @@ fn genDeclRef(	...	@@ -985,8 +990,8 @@ fn genDeclRef(
985	if (is_extern) {	990	if (is_extern) {
986	// TODO make this part of getGlobalSymbol	991	// TODO make this part of getGlobalSymbol
987	const name = zcu.intern_pool.stringToSlice(decl.name);	992	const name = zcu.intern_pool.stringToSlice(decl.name);
988	const sym_name = try std.fmt.allocPrint(lf.allocator, "_{s}", .{name});	993	const sym_name = try std.fmt.allocPrint(gpa, "_{s}", .{name});
989	defer lf.allocator.free(sym_name);	994	defer gpa.free(sym_name);
990	const global_index = try macho_file.addUndefined(sym_name, .{ .add_got = true });	995	const global_index = try macho_file.addUndefined(sym_name, .{ .add_got = true });
991	return GenResult.mcv(.{ .load_got = link.File.MachO.global_symbol_bit \| global_index });	996	return GenResult.mcv(.{ .load_got = link.File.MachO.global_symbol_bit \| global_index });
992	}	997	}
...	@@ -1005,7 +1010,7 @@ fn genDeclRef(	...	@@ -1005,7 +1010,7 @@ fn genDeclRef(
1005	else	1010	else
1006	null;	1011	null;
1007	const global_index = try coff_file.getGlobalSymbol(name, lib_name);	1012	const global_index = try coff_file.getGlobalSymbol(name, lib_name);
1008	try coff_file.need_got_table.put(lf.allocator, global_index, {}); // needs GOT	1013	try coff_file.need_got_table.put(gpa, global_index, {}); // needs GOT
1009	return GenResult.mcv(.{ .load_got = link.File.Coff.global_symbol_bit \| global_index });	1014	return GenResult.mcv(.{ .load_got = link.File.Coff.global_symbol_bit \| global_index });
1010	}	1015	}
1011	const atom_index = try coff_file.getOrCreateAtomForDecl(decl_index);	1016	const atom_index = try coff_file.getOrCreateAtomForDecl(decl_index);
...	@@ -1016,7 +1021,7 @@ fn genDeclRef(	...	@@ -1016,7 +1021,7 @@ fn genDeclRef(
1016	const atom = p9.getAtom(atom_index);	1021	const atom = p9.getAtom(atom_index);
1017	return GenResult.mcv(.{ .memory = atom.getOffsetTableAddress(p9) });	1022	return GenResult.mcv(.{ .memory = atom.getOffsetTableAddress(p9) });
1018	} else {	1023	} else {
1019	return GenResult.fail(lf.allocator, src_loc, "TODO genDeclRef for target {}", .{target});	1024	return GenResult.fail(gpa, src_loc, "TODO genDeclRef for target {}", .{target});
1020	}	1025	}
1021	}	1026	}
1022		1027
...	@@ -1073,7 +1078,7 @@ pub fn genTypedValue(	...	@@ -1073,7 +1078,7 @@ pub fn genTypedValue(
1073		1078
1074	const owner_decl = zcu.declPtr(owner_decl_index);	1079	const owner_decl = zcu.declPtr(owner_decl_index);
1075	const namespace = zcu.namespacePtr(owner_decl.src_namespace);	1080	const namespace = zcu.namespacePtr(owner_decl.src_namespace);
1076	const target = namespace.file_scope.mod.target;	1081	const target = namespace.file_scope.mod.resolved_target.result;
1077	const ptr_bits = target.ptrBitWidth();	1082	const ptr_bits = target.ptrBitWidth();
1078		1083
1079	if (!typed_value.ty.isSlice(zcu)) switch (zcu.intern_pool.indexToKey(typed_value.val.toIntern())) {	1084	if (!typed_value.ty.isSlice(zcu)) switch (zcu.intern_pool.indexToKey(typed_value.val.toIntern())) {

...	@@ -1785,7 +1785,7 @@ pub const Object = struct {	...	@@ -1785,7 +1785,7 @@ pub const Object = struct {
1785	if (wantDllExports(mod)) global_index.setDllStorageClass(.default, &self.builder);	1785	if (wantDllExports(mod)) global_index.setDllStorageClass(.default, &self.builder);
1786	global_index.setUnnamedAddr(.unnamed_addr, &self.builder);	1786	global_index.setUnnamedAddr(.unnamed_addr, &self.builder);
1787	if (decl.val.getVariable(mod)) \|decl_var\| {	1787	if (decl.val.getVariable(mod)) \|decl_var\| {
1788	const decl_namespace = mod.namespacePtr(decl.namespace_index);	1788	const decl_namespace = mod.namespacePtr(decl.src_namespace);
1789	const single_threaded = decl_namespace.file_scope.mod.single_threaded;	1789	const single_threaded = decl_namespace.file_scope.mod.single_threaded;
1790	global_index.ptrConst(&self.builder).kind.variable.setThreadLocal(	1790	global_index.ptrConst(&self.builder).kind.variable.setThreadLocal(
1791	if (decl_var.is_threadlocal and !single_threaded)	1791	if (decl_var.is_threadlocal and !single_threaded)
...	@@ -3173,7 +3173,7 @@ pub const Object = struct {	...	@@ -3173,7 +3173,7 @@ pub const Object = struct {
3173	variable_index.setLinkage(.external, &o.builder);	3173	variable_index.setLinkage(.external, &o.builder);
3174	variable_index.setUnnamedAddr(.default, &o.builder);	3174	variable_index.setUnnamedAddr(.default, &o.builder);
3175	if (decl.val.getVariable(mod)) \|decl_var\| {	3175	if (decl.val.getVariable(mod)) \|decl_var\| {
3176	const decl_namespace = mod.namespacePtr(decl.namespace_index);	3176	const decl_namespace = mod.namespacePtr(decl.src_namespace);
3177	const single_threaded = decl_namespace.file_scope.mod.single_threaded;	3177	const single_threaded = decl_namespace.file_scope.mod.single_threaded;
3178	variable_index.setThreadLocal(	3178	variable_index.setThreadLocal(
3179	if (decl_var.is_threadlocal and !single_threaded) .generaldynamic else .default,	3179	if (decl_var.is_threadlocal and !single_threaded) .generaldynamic else .default,

...	@@ -94,7 +94,8 @@ pub fn freeListEligible(self: Atom, coff_file: *const Coff) bool {	...	@@ -94,7 +94,8 @@ pub fn freeListEligible(self: Atom, coff_file: *const Coff) bool {
94	}	94	}
95		95
96	pub fn addRelocation(coff_file: *Coff, atom_index: Index, reloc: Relocation) !void {	96	pub fn addRelocation(coff_file: *Coff, atom_index: Index, reloc: Relocation) !void {
97	const gpa = coff_file.base.allocator;	97	const comp = coff_file.base.comp;
		98	const gpa = comp.gpa;
98	log.debug(" (adding reloc of type {s} to target %{d})", .{ @tagName(reloc.type), reloc.target.sym_index });	99	log.debug(" (adding reloc of type {s} to target %{d})", .{ @tagName(reloc.type), reloc.target.sym_index });
99	const gop = try coff_file.relocs.getOrPut(gpa, atom_index);	100	const gop = try coff_file.relocs.getOrPut(gpa, atom_index);
100	if (!gop.found_existing) {	101	if (!gop.found_existing) {
...	@@ -104,7 +105,8 @@ pub fn addRelocation(coff_file: *Coff, atom_index: Index, reloc: Relocation) !vo	...	@@ -104,7 +105,8 @@ pub fn addRelocation(coff_file: *Coff, atom_index: Index, reloc: Relocation) !vo
104	}	105	}
105		106
106	pub fn addBaseRelocation(coff_file: *Coff, atom_index: Index, offset: u32) !void {	107	pub fn addBaseRelocation(coff_file: *Coff, atom_index: Index, offset: u32) !void {
107	const gpa = coff_file.base.allocator;	108	const comp = coff_file.base.comp;
		109	const gpa = comp.gpa;
108	log.debug(" (adding base relocation at offset 0x{x} in %{d})", .{	110	log.debug(" (adding base relocation at offset 0x{x} in %{d})", .{
109	offset,	111	offset,
110	coff_file.getAtom(atom_index).getSymbolIndex().?,	112	coff_file.getAtom(atom_index).getSymbolIndex().?,
...	@@ -117,7 +119,8 @@ pub fn addBaseRelocation(coff_file: *Coff, atom_index: Index, offset: u32) !void	...	@@ -117,7 +119,8 @@ pub fn addBaseRelocation(coff_file: *Coff, atom_index: Index, offset: u32) !void
117	}	119	}
118		120
119	pub fn freeRelocations(coff_file: *Coff, atom_index: Index) void {	121	pub fn freeRelocations(coff_file: *Coff, atom_index: Index) void {
120	const gpa = coff_file.base.allocator;	122	const comp = coff_file.base.comp;
		123	const gpa = comp.gpa;
121	var removed_relocs = coff_file.relocs.fetchOrderedRemove(atom_index);	124	var removed_relocs = coff_file.relocs.fetchOrderedRemove(atom_index);
122	if (removed_relocs) \|*relocs\| relocs.value.deinit(gpa);	125	if (removed_relocs) \|*relocs\| relocs.value.deinit(gpa);
123	var removed_base_relocs = coff_file.base_relocs.fetchOrderedRemove(atom_index);	126	var removed_base_relocs = coff_file.base_relocs.fetchOrderedRemove(atom_index);

...	@@ -196,9 +196,6 @@ resolver: std.AutoArrayHashMapUnmanaged(u32, Symbol.Index) = .{},	...	@@ -196,9 +196,6 @@ resolver: std.AutoArrayHashMapUnmanaged(u32, Symbol.Index) = .{},
196	has_text_reloc: bool = false,	196	has_text_reloc: bool = false,
197	num_ifunc_dynrelocs: usize = 0,	197	num_ifunc_dynrelocs: usize = 0,
198		198
199	error_flags: link.File.ErrorFlags = link.File.ErrorFlags{},
200	misc_errors: std.ArrayListUnmanaged(link.File.ErrorMsg) = .{},
201
202	/// List of atoms that are owned directly by the linker.	199	/// List of atoms that are owned directly by the linker.
203	atoms: std.ArrayListUnmanaged(Atom) = .{},	200	atoms: std.ArrayListUnmanaged(Atom) = .{},
204		201
...	@@ -477,7 +474,6 @@ pub fn deinit(self: *Elf) void {	...	@@ -477,7 +474,6 @@ pub fn deinit(self: *Elf) void {
477	}	474	}
478	self.last_atom_and_free_list_table.deinit(gpa);	475	self.last_atom_and_free_list_table.deinit(gpa);
479		476
480	self.misc_errors.deinit(gpa);
481	self.comdat_groups.deinit(gpa);	477	self.comdat_groups.deinit(gpa);
482	self.comdat_groups_owners.deinit(gpa);	478	self.comdat_groups_owners.deinit(gpa);
483	self.comdat_groups_table.deinit(gpa);	479	self.comdat_groups_table.deinit(gpa);
...	@@ -1168,7 +1164,7 @@ pub fn flushModule(self: Elf, comp: Compilation, prog_node: *std.Progress.Node	...	@@ -1168,7 +1164,7 @@ pub fn flushModule(self: Elf, comp: Compilation, prog_node: *std.Progress.Node
1168	}	1164	}
1169		1165
1170	// libc dep	1166	// libc dep
1171	self.error_flags.missing_libc = false;	1167	self.base.error_flags.missing_libc = false;
1172	if (self.base.comp.config.link_libc) {	1168	if (self.base.comp.config.link_libc) {
1173	if (self.base.comp.libc_installation) \|lc\| {	1169	if (self.base.comp.libc_installation) \|lc\| {
1174	const flags = target_util.libcFullLinkFlags(target);	1170	const flags = target_util.libcFullLinkFlags(target);
...	@@ -1219,7 +1215,7 @@ pub fn flushModule(self: Elf, comp: Compilation, prog_node: *std.Progress.Node	...	@@ -1219,7 +1215,7 @@ pub fn flushModule(self: Elf, comp: Compilation, prog_node: *std.Progress.Node
1219	});	1215	});
1220	try system_libs.append(.{ .path = path });	1216	try system_libs.append(.{ .path = path });
1221	} else {	1217	} else {
1222	self.error_flags.missing_libc = true;	1218	self.base.error_flags.missing_libc = true;
1223	}	1219	}
1224	}	1220	}
1225		1221
...	@@ -1257,7 +1253,7 @@ pub fn flushModule(self: Elf, comp: Compilation, prog_node: *std.Progress.Node	...	@@ -1257,7 +1253,7 @@ pub fn flushModule(self: Elf, comp: Compilation, prog_node: *std.Progress.Node
1257	};	1253	};
1258	}	1254	}
1259		1255
1260	if (self.misc_errors.items.len > 0) return error.FlushFailure;	1256	if (self.base.misc_errors.items.len > 0) return error.FlushFailure;
1261		1257
1262	// Init all objects	1258	// Init all objects
1263	for (self.objects.items) \|index\| {	1259	for (self.objects.items) \|index\| {
...	@@ -1267,7 +1263,7 @@ pub fn flushModule(self: Elf, comp: Compilation, prog_node: *std.Progress.Node	...	@@ -1267,7 +1263,7 @@ pub fn flushModule(self: Elf, comp: Compilation, prog_node: *std.Progress.Node
1267	try self.file(index).?.shared_object.init(self);	1263	try self.file(index).?.shared_object.init(self);
1268	}	1264	}
1269		1265
1270	if (self.misc_errors.items.len > 0) return error.FlushFailure;	1266	if (self.base.misc_errors.items.len > 0) return error.FlushFailure;
1271		1267
1272	// Dedup shared objects	1268	// Dedup shared objects
1273	{	1269	{
...	@@ -1389,14 +1385,14 @@ pub fn flushModule(self: Elf, comp: Compilation, prog_node: *std.Progress.Node	...	@@ -1389,14 +1385,14 @@ pub fn flushModule(self: Elf, comp: Compilation, prog_node: *std.Progress.Node
1389		1385
1390	if (self.entry_index == null and self.base.isExe()) {	1386	if (self.entry_index == null and self.base.isExe()) {
1391	log.debug("flushing. no_entry_point_found = true", .{});	1387	log.debug("flushing. no_entry_point_found = true", .{});
1392	self.error_flags.no_entry_point_found = true;	1388	self.base.error_flags.no_entry_point_found = true;
1393	} else {	1389	} else {
1394	log.debug("flushing. no_entry_point_found = false", .{});	1390	log.debug("flushing. no_entry_point_found = false", .{});
1395	self.error_flags.no_entry_point_found = false;	1391	self.base.error_flags.no_entry_point_found = false;
1396	try self.writeElfHeader();	1392	try self.writeElfHeader();
1397	}	1393	}
1398		1394
1399	if (self.misc_errors.items.len > 0) return error.FlushFailure;	1395	if (self.base.misc_errors.items.len > 0) return error.FlushFailure;
1400	}	1396	}
1401		1397
1402	pub fn flushStaticLib(self: Elf, comp: Compilation, module_obj_path: ?[]const u8) link.File.FlushError!void {	1398	pub fn flushStaticLib(self: Elf, comp: Compilation, module_obj_path: ?[]const u8) link.File.FlushError!void {
...	@@ -1428,7 +1424,7 @@ pub fn flushStaticLib(self: Elf, comp: Compilation, module_obj_path: ?[]const	...	@@ -1428,7 +1424,7 @@ pub fn flushStaticLib(self: Elf, comp: Compilation, module_obj_path: ?[]const
1428	};	1424	};
1429	}	1425	}
1430		1426
1431	if (self.misc_errors.items.len > 0) return error.FlushFailure;	1427	if (self.base.misc_errors.items.len > 0) return error.FlushFailure;
1432		1428
1433	// First, we flush relocatable object file generated with our backends.	1429	// First, we flush relocatable object file generated with our backends.
1434	if (self.zigObjectPtr()) \|zig_object\| {	1430	if (self.zigObjectPtr()) \|zig_object\| {
...	@@ -1540,7 +1536,7 @@ pub fn flushStaticLib(self: Elf, comp: Compilation, module_obj_path: ?[]const	...	@@ -1540,7 +1536,7 @@ pub fn flushStaticLib(self: Elf, comp: Compilation, module_obj_path: ?[]const
1540	try self.base.file.?.setEndPos(total_size);	1536	try self.base.file.?.setEndPos(total_size);
1541	try self.base.file.?.pwriteAll(buffer.items, 0);	1537	try self.base.file.?.pwriteAll(buffer.items, 0);
1542		1538
1543	if (self.misc_errors.items.len > 0) return error.FlushFailure;	1539	if (self.base.misc_errors.items.len > 0) return error.FlushFailure;
1544	}	1540	}
1545		1541
1546	pub fn flushObject(self: Elf, comp: Compilation, module_obj_path: ?[]const u8) link.File.FlushError!void {	1542	pub fn flushObject(self: Elf, comp: Compilation, module_obj_path: ?[]const u8) link.File.FlushError!void {
...	@@ -1571,14 +1567,14 @@ pub fn flushObject(self: Elf, comp: Compilation, module_obj_path: ?[]const u8)	...	@@ -1571,14 +1567,14 @@ pub fn flushObject(self: Elf, comp: Compilation, module_obj_path: ?[]const u8)
1571	};	1567	};
1572	}	1568	}
1573		1569
1574	if (self.misc_errors.items.len > 0) return error.FlushFailure;	1570	if (self.base.misc_errors.items.len > 0) return error.FlushFailure;
1575		1571
1576	// Init all objects	1572	// Init all objects
1577	for (self.objects.items) \|index\| {	1573	for (self.objects.items) \|index\| {
1578	try self.file(index).?.object.init(self);	1574	try self.file(index).?.object.init(self);
1579	}	1575	}
1580		1576
1581	if (self.misc_errors.items.len > 0) return error.FlushFailure;	1577	if (self.base.misc_errors.items.len > 0) return error.FlushFailure;
1582		1578
1583	// Now, we are ready to resolve the symbols across all input files.	1579	// Now, we are ready to resolve the symbols across all input files.
1584	// We will first resolve the files in the ZigObject, next in the parsed	1580	// We will first resolve the files in the ZigObject, next in the parsed
...	@@ -1612,7 +1608,7 @@ pub fn flushObject(self: Elf, comp: Compilation, module_obj_path: ?[]const u8)	...	@@ -1612,7 +1608,7 @@ pub fn flushObject(self: Elf, comp: Compilation, module_obj_path: ?[]const u8)
1612	try self.writeShdrTable();	1608	try self.writeShdrTable();
1613	try self.writeElfHeader();	1609	try self.writeElfHeader();
1614		1610
1615	if (self.misc_errors.items.len > 0) return error.FlushFailure;	1611	if (self.base.misc_errors.items.len > 0) return error.FlushFailure;
1616	}	1612	}
1617		1613
1618	/// --verbose-link output	1614	/// --verbose-link output
...	@@ -2891,7 +2887,7 @@ fn linkWithLLD(self: Elf, comp: Compilation, prog_node: *std.Progress.Node) !v	...	@@ -2891,7 +2887,7 @@ fn linkWithLLD(self: Elf, comp: Compilation, prog_node: *std.Progress.Node) !v
2891	}	2887	}
2892		2888
2893	// libc dep	2889	// libc dep
2894	self.error_flags.missing_libc = false;	2890	self.base.error_flags.missing_libc = false;
2895	if (comp.config.link_libc) {	2891	if (comp.config.link_libc) {
2896	if (self.base.comp.libc_installation != null) {	2892	if (self.base.comp.libc_installation != null) {
2897	const needs_grouping = link_mode == .Static;	2893	const needs_grouping = link_mode == .Static;
...	@@ -2912,7 +2908,7 @@ fn linkWithLLD(self: Elf, comp: Compilation, prog_node: *std.Progress.Node) !v	...	@@ -2912,7 +2908,7 @@ fn linkWithLLD(self: Elf, comp: Compilation, prog_node: *std.Progress.Node) !v
2912	.Dynamic => "libc.so",	2908	.Dynamic => "libc.so",
2913	}));	2909	}));
2914	} else {	2910	} else {
2915	self.error_flags.missing_libc = true;	2911	self.base.error_flags.missing_libc = true;
2916	}	2912	}
2917	}	2913	}
2918	}	2914	}
...	@@ -3135,7 +3131,7 @@ fn writePhdrTable(self: *Elf) !void {	...	@@ -3135,7 +3131,7 @@ fn writePhdrTable(self: *Elf) !void {
3135	}	3131	}
3136		3132
3137	fn writeElfHeader(self: *Elf) !void {	3133	fn writeElfHeader(self: *Elf) !void {
3138	if (self.misc_errors.items.len > 0) return; // We had errors, so skip flushing to render the output unusable	3134	if (self.base.misc_errors.items.len > 0) return; // We had errors, so skip flushing to render the output unusable
3139		3135
3140	var hdr_buf: [@sizeOf(elf.Elf64_Ehdr)]u8 = undefined;	3136	var hdr_buf: [@sizeOf(elf.Elf64_Ehdr)]u8 = undefined;
3141		3137
...	@@ -6067,8 +6063,9 @@ const ErrorWithNotes = struct {	...	@@ -6067,8 +6063,9 @@ const ErrorWithNotes = struct {
6067	comptime format: []const u8,	6063	comptime format: []const u8,
6068	args: anytype,	6064	args: anytype,
6069	) error{OutOfMemory}!void {	6065	) error{OutOfMemory}!void {
6070	const gpa = elf_file.base.allocator;	6066	const comp = elf_file.base.comp;
6071	const err_msg = &elf_file.misc_errors.items[err.index];	6067	const gpa = comp.gpa;
		6068	const err_msg = &elf_file.base.misc_errors.items[err.index];
6072	err_msg.msg = try std.fmt.allocPrint(gpa, format, args);	6069	err_msg.msg = try std.fmt.allocPrint(gpa, format, args);
6073	}	6070	}
6074		6071
...	@@ -6078,8 +6075,9 @@ const ErrorWithNotes = struct {	...	@@ -6078,8 +6075,9 @@ const ErrorWithNotes = struct {
6078	comptime format: []const u8,	6075	comptime format: []const u8,
6079	args: anytype,	6076	args: anytype,
6080	) error{OutOfMemory}!void {	6077	) error{OutOfMemory}!void {
6081	const gpa = elf_file.base.allocator;	6078	const comp = elf_file.base.comp;
6082	const err_msg = &elf_file.misc_errors.items[err.index];	6079	const gpa = comp.gpa;
		6080	const err_msg = &elf_file.base.misc_errors.items[err.index];
6083	assert(err.note_slot < err_msg.notes.len);	6081	assert(err.note_slot < err_msg.notes.len);
6084	err_msg.notes[err.note_slot] = .{ .msg = try std.fmt.allocPrint(gpa, format, args) };	6082	err_msg.notes[err.note_slot] = .{ .msg = try std.fmt.allocPrint(gpa, format, args) };
6085	err.note_slot += 1;	6083	err.note_slot += 1;
...	@@ -6088,14 +6086,14 @@ const ErrorWithNotes = struct {	...	@@ -6088,14 +6086,14 @@ const ErrorWithNotes = struct {
6088		6086
6089	pub fn addErrorWithNotes(self: *Elf, note_count: usize) error{OutOfMemory}!ErrorWithNotes {	6087	pub fn addErrorWithNotes(self: *Elf, note_count: usize) error{OutOfMemory}!ErrorWithNotes {
6090	const gpa = self.base.comp.gpa;	6088	const gpa = self.base.comp.gpa;
6091	try self.misc_errors.ensureUnusedCapacity(gpa, 1);	6089	try self.base.misc_errors.ensureUnusedCapacity(gpa, 1);
6092	return self.addErrorWithNotesAssumeCapacity(note_count);	6090	return self.addErrorWithNotesAssumeCapacity(note_count);
6093	}	6091	}
6094		6092
6095	fn addErrorWithNotesAssumeCapacity(self: *Elf, note_count: usize) error{OutOfMemory}!ErrorWithNotes {	6093	fn addErrorWithNotesAssumeCapacity(self: *Elf, note_count: usize) error{OutOfMemory}!ErrorWithNotes {
6096	const gpa = self.base.comp.gpa;	6094	const gpa = self.base.comp.gpa;
6097	const index = self.misc_errors.items.len;	6095	const index = self.base.misc_errors.items.len;
6098	const err = self.misc_errors.addOneAssumeCapacity();	6096	const err = self.base.misc_errors.addOneAssumeCapacity();
6099	err.* = .{ .msg = undefined, .notes = try gpa.alloc(link.File.ErrorMsg, note_count) };	6097	err.* = .{ .msg = undefined, .notes = try gpa.alloc(link.File.ErrorMsg, note_count) };
6100	return .{ .index = index };	6098	return .{ .index = index };
6101	}	6099	}
...	@@ -6130,7 +6128,7 @@ fn reportUndefinedSymbols(self: *Elf, undefs: anytype) !void {	...	@@ -6130,7 +6128,7 @@ fn reportUndefinedSymbols(self: *Elf, undefs: anytype) !void {
6130	const gpa = self.base.comp.gpa;	6128	const gpa = self.base.comp.gpa;
6131	const max_notes = 4;	6129	const max_notes = 4;
6132		6130
6133	try self.misc_errors.ensureUnusedCapacity(gpa, undefs.count());	6131	try self.base.misc_errors.ensureUnusedCapacity(gpa, undefs.count());
6134		6132
6135	var it = undefs.iterator();	6133	var it = undefs.iterator();
6136	while (it.next()) \|entry\| {	6134	while (it.next()) \|entry\| {

...	@@ -253,7 +253,8 @@ pub fn addRelocation(macho_file: *MachO, atom_index: Index, reloc: Relocation) !	...	@@ -253,7 +253,8 @@ pub fn addRelocation(macho_file: *MachO, atom_index: Index, reloc: Relocation) !
253	}	253	}
254		254
255	pub fn addRelocations(macho_file: *MachO, atom_index: Index, relocs: []const Relocation) !void {	255	pub fn addRelocations(macho_file: *MachO, atom_index: Index, relocs: []const Relocation) !void {
256	const gpa = macho_file.base.allocator;	256	const comp = macho_file.base.comp;
		257	const gpa = comp.gpa;
257	const gop = try macho_file.relocs.getOrPut(gpa, atom_index);	258	const gop = try macho_file.relocs.getOrPut(gpa, atom_index);
258	if (!gop.found_existing) {	259	if (!gop.found_existing) {
259	gop.value_ptr.* = .{};	260	gop.value_ptr.* = .{};
...	@@ -269,7 +270,8 @@ pub fn addRelocations(macho_file: *MachO, atom_index: Index, relocs: []const Rel	...	@@ -269,7 +270,8 @@ pub fn addRelocations(macho_file: *MachO, atom_index: Index, relocs: []const Rel
269	}	270	}
270		271
271	pub fn addRebase(macho_file: *MachO, atom_index: Index, offset: u32) !void {	272	pub fn addRebase(macho_file: *MachO, atom_index: Index, offset: u32) !void {
272	const gpa = macho_file.base.allocator;	273	const comp = macho_file.base.comp;
		274	const gpa = comp.gpa;
273	const atom = macho_file.getAtom(atom_index);	275	const atom = macho_file.getAtom(atom_index);
274	log.debug(" (adding rebase at offset 0x{x} in %{?d})", .{ offset, atom.getSymbolIndex() });	276	log.debug(" (adding rebase at offset 0x{x} in %{?d})", .{ offset, atom.getSymbolIndex() });
275	const gop = try macho_file.rebases.getOrPut(gpa, atom_index);	277	const gop = try macho_file.rebases.getOrPut(gpa, atom_index);
...	@@ -280,7 +282,8 @@ pub fn addRebase(macho_file: *MachO, atom_index: Index, offset: u32) !void {	...	@@ -280,7 +282,8 @@ pub fn addRebase(macho_file: *MachO, atom_index: Index, offset: u32) !void {
280	}	282	}
281		283
282	pub fn addBinding(macho_file: *MachO, atom_index: Index, binding: Binding) !void {	284	pub fn addBinding(macho_file: *MachO, atom_index: Index, binding: Binding) !void {
283	const gpa = macho_file.base.allocator;	285	const comp = macho_file.base.comp;
		286	const gpa = comp.gpa;
284	const atom = macho_file.getAtom(atom_index);	287	const atom = macho_file.getAtom(atom_index);
285	log.debug(" (adding binding to symbol {s} at offset 0x{x} in %{?d})", .{	288	log.debug(" (adding binding to symbol {s} at offset 0x{x} in %{?d})", .{
286	macho_file.getSymbolName(binding.target),	289	macho_file.getSymbolName(binding.target),
...	@@ -307,7 +310,8 @@ pub fn resolveRelocations(	...	@@ -307,7 +310,8 @@ pub fn resolveRelocations(
307	}	310	}
308		311
309	pub fn freeRelocations(macho_file: *MachO, atom_index: Index) void {	312	pub fn freeRelocations(macho_file: *MachO, atom_index: Index) void {
310	const gpa = macho_file.base.allocator;	313	const comp = macho_file.base.comp;
		314	const gpa = comp.gpa;
311	var removed_relocs = macho_file.relocs.fetchOrderedRemove(atom_index);	315	var removed_relocs = macho_file.relocs.fetchOrderedRemove(atom_index);
312	if (removed_relocs) \|*relocs\| relocs.value.deinit(gpa);	316	if (removed_relocs) \|*relocs\| relocs.value.deinit(gpa);
313	var removed_rebases = macho_file.rebases.fetchOrderedRemove(atom_index);	317	var removed_rebases = macho_file.rebases.fetchOrderedRemove(atom_index);

fix a round of compile errors caused by this branch