Commit 2bef0715c740024c515dce73d267ead5af49d1a9 | zig

author	Andrew Kelley <andrew@ziglang.org> 2023-12-11 21:16:49-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2024-01-01 17:51:18-07:00
log	2bef0715c740024c515dce73d267ead5af49d1a9
tree	0fa39b660ea8f9478fdd04f59ad8a5ece042bce6
parent	12de7e3472cb2292e75578d33a8b8cc91f1ef0b0

move a large chunk of linker logic away from "options"

These options are only supposed to be provided to the initialization
functions, resolved, and then computed values stored in the appropriate
place (base struct or the object-format-specific structs).

Many more to go...

18 files changed, 1245 insertions(+), 962 deletions(-)

src
- Compilation.zig
- Compilation
  - Config.zig
- codegen
  - llvm.zig
- link.zig
- link
  - C.zig
  - Coff.zig
  - Coff
    lld.zig
  - Elf.zig
  - Elf
    ZigObject.zig
  - MachO.zig
  - MachO
    zld.zig
  - NvPtx.zig
  - Plan9.zig
  - SpirV.zig
  - Wasm.zig
- main.zig
- musl.zig
- target.zig

src/Compilation.zig+56-38

src/Compilation/Config.zig+24-12

 @@ -137,7 +137,11 @@ pub fn resolve(options: Options) !Config {
     const use_llvm = b: {
         // If emitting to LLVM bitcode object format, must use LLVM backend.
         if (options.emit_llvm_ir or options.emit_llvm_bc) {
-            if (options.use_llvm == false) return error.EmittingLlvmModuleRequiresLlvmBackend;
+            if (options.use_llvm == false)
+                return error.EmittingLlvmModuleRequiresLlvmBackend;
+            if (!target_util.hasLlvmSupport(target, target.ofmt))
+                return error.LlvmLacksTargetSupport;
             break :b true;
         }
 @@ -147,6 +151,12 @@ pub fn resolve(options: Options) !Config {
             break :b false;
         }
+        // If Zig does not support the target, then we can't use it.
+        if (target_util.zigBackend(target, false) == .other) {
+            if (options.use_llvm == false) return error.ZigLacksTargetSupport;
+            break :b true;
+        }
         if (options.use_llvm) |x| break :b x;
         // If we have no zig code to compile, no need for LLVM.
 @@ -166,16 +176,23 @@ pub fn resolve(options: Options) !Config {
         break :b !target_util.selfHostedBackendIsAsRobustAsLlvm(target);
     };
-    if (!use_lib_llvm and use_llvm and options.emit_bin) {
+    if (options.emit_bin) {
-        // Explicit request to use LLVM to produce an object file, but without
+        if (!use_lib_llvm and use_llvm) {
-        // using LLVM libraries. Impossible.
+            // Explicit request to use LLVM to produce an object file, but without
-        return error.EmittingBinaryRequiresLlvmLibrary;
+            // using LLVM libraries. Impossible.
+            return error.EmittingBinaryRequiresLlvmLibrary;
+        }
+        if (target_util.zigBackend(target, use_llvm) == .other) {
+            // There is no compiler backend available for this target.
+            return error.ZigLacksTargetSupport;
+        }
     }
     // Make a decision on whether to use LLD or our own linker.
     const use_lld = b: {
-        if (target.isDarwin()) {
+        if (!target_util.hasLldSupport(target.ofmt)) {
-            if (options.use_lld == true) return error.LldIncompatibleOs;
+            if (options.use_lld == true) return error.LldIncompatibleObjectFormat;
             break :b false;
         }
 @@ -184,11 +201,6 @@ pub fn resolve(options: Options) !Config {
             break :b false;
         }
-        if (target.ofmt == .c) {
-            if (options.use_lld == true) return error.LldIncompatibleObjectFormat;
-            break :b false;
-        }
         if (options.lto == true) {
             if (options.use_lld == false) return error.LtoRequiresLld;
             break :b true;

src/codegen/llvm.zig+44-30

 @@ -854,15 +854,21 @@ pub const Object = struct {
     pub const DITypeMap = std.AutoArrayHashMapUnmanaged(InternPool.Index, AnnotatedDITypePtr);
     pub fn create(arena: Allocator, options: link.File.OpenOptions) !*Object {
-        const gpa = options.comp.gpa;
+        if (build_options.only_c) unreachable;
-        const llvm_target_triple = try targetTriple(arena, options.target);
+        const comp = options.comp;
+        const gpa = comp.gpa;
+        const target = comp.root_mod.resolved_target.result;
+        const llvm_target_triple = try targetTriple(arena, target);
+        const strip = comp.root_mod.strip;
+        const optimize_mode = comp.root_mod.optimize_mode;
+        const pic = comp.root_mod.pic;
         var builder = try Builder.init(.{
             .allocator = gpa,
-            .use_lib_llvm = options.use_lib_llvm,
+            .use_lib_llvm = comp.config.use_lib_llvm,
-            .strip = options.strip or !options.use_lib_llvm, // TODO
+            .strip = strip or !comp.config.use_lib_llvm, // TODO
-            .name = options.root_name,
+            .name = comp.root_name,
-            .target = options.target,
+            .target = target,
             .triple = llvm_target_triple,
         });
         errdefer builder.deinit();
 @@ -870,10 +876,18 @@ pub const Object = struct {
         var target_machine: if (build_options.have_llvm) *llvm.TargetMachine else void = undefined;
         var target_data: if (build_options.have_llvm) *llvm.TargetData else void = undefined;
         if (builder.useLibLlvm()) {
-            if (!options.strip) {
+            debug_info: {
-                switch (options.target.ofmt) {
+                const debug_format = options.debug_format orelse b: {
-                    .coff => builder.llvm.module.?.addModuleCodeViewFlag(),
+                    if (strip) break :b .strip;
-                    else => builder.llvm.module.?.addModuleDebugInfoFlag(options.dwarf_format == std.dwarf.Format.@"64"),
+                    break :b switch (target.ofmt) {
+                        .coff => .code_view,
+                        else => .{ .dwarf = .@"32" },
+                    };
+                };
+                switch (debug_format) {
+                    .strip => break :debug_info,
+                    .code_view => builder.llvm.module.?.addModuleCodeViewFlag(),
+                    .dwarf => |f| builder.llvm.module.?.addModuleDebugInfoFlag(f == .@"64"),
                 }
                 builder.llvm.di_builder = builder.llvm.module.?.createDIBuilder(true);
 @@ -892,8 +906,8 @@ pub const Object = struct {
                 // TODO: the only concern I have with this is WASI as either host or target, should
                 // we leave the paths as relative then?
                 const compile_unit_dir_z = blk: {
-                    if (options.module) |mod| m: {
+                    if (comp.module) |zcu| m: {
-                        const d = try mod.root_mod.root.joinStringZ(arena, "");
+                        const d = try zcu.root_mod.root.joinStringZ(arena, "");
                         if (d.len == 0) break :m;
                         if (std.fs.path.isAbsolute(d)) break :blk d;
                         break :blk std.fs.realpathAlloc(arena, d) catch d;
 @@ -903,9 +917,9 @@ pub const Object = struct {
                 builder.llvm.di_compile_unit = builder.llvm.di_builder.?.createCompileUnit(
                     DW.LANG.C99,
-                    builder.llvm.di_builder.?.createFile(options.root_name, compile_unit_dir_z),
+                    builder.llvm.di_builder.?.createFile(comp.root_name, compile_unit_dir_z),
                     producer.slice(&builder).?,
-                    options.optimize_mode != .Debug,
+                    optimize_mode != .Debug,
                     "", // flags
                     0, // runtime version
                     "", // split name
 @@ -914,19 +928,19 @@ pub const Object = struct {
                 );
             }
-            const opt_level: llvm.CodeGenOptLevel = if (options.optimize_mode == .Debug)
+            const opt_level: llvm.CodeGenOptLevel = if (optimize_mode == .Debug)
                 .None
             else
                 .Aggressive;
-            const reloc_mode: llvm.RelocMode = if (options.pic)
+            const reloc_mode: llvm.RelocMode = if (pic)
                 .PIC
-            else if (options.link_mode == .Dynamic)
+            else if (comp.config.link_mode == .Dynamic)
                 llvm.RelocMode.DynamicNoPIC
             else
                 .Static;
-            const code_model: llvm.CodeModel = switch (options.machine_code_model) {
+            const code_model: llvm.CodeModel = switch (comp.root_mod.code_model) {
                 .default => .Default,
                 .tiny => .Tiny,
                 .small => .Small,
 @@ -941,15 +955,15 @@ pub const Object = struct {
             target_machine = llvm.TargetMachine.create(
                 builder.llvm.target.?,
                 builder.target_triple.slice(&builder).?,
-                if (options.target.cpu.model.llvm_name) |s| s.ptr else null,
+                if (target.cpu.model.llvm_name) |s| s.ptr else null,
-                options.llvm_cpu_features,
+                comp.root_mod.resolved_target.llvm_cpu_features.?,
                 opt_level,
                 reloc_mode,
                 code_model,
-                options.function_sections,
+                options.function_sections orelse false,
-                options.data_sections,
+                options.data_sections orelse false,
                 float_abi,
-                if (target_util.llvmMachineAbi(options.target)) |s| s.ptr else null,
+                if (target_util.llvmMachineAbi(target)) |s| s.ptr else null,
             );
             errdefer target_machine.dispose();
 @@ -958,15 +972,15 @@ pub const Object = struct {
             builder.llvm.module.?.setModuleDataLayout(target_data);
-            if (options.pic) builder.llvm.module.?.setModulePICLevel();
+            if (pic) builder.llvm.module.?.setModulePICLevel();
-            if (options.pie) builder.llvm.module.?.setModulePIELevel();
+            if (comp.config.pie) builder.llvm.module.?.setModulePIELevel();
             if (code_model != .Default) builder.llvm.module.?.setModuleCodeModel(code_model);
-            if (options.opt_bisect_limit >= 0) {
+            if (comp.llvm_opt_bisect_limit >= 0) {
-                builder.llvm.context.setOptBisectLimit(std.math.lossyCast(c_int, options.opt_bisect_limit));
+                builder.llvm.context.setOptBisectLimit(comp.llvm_opt_bisect_limit);
             }
-            builder.data_layout = try builder.fmt("{}", .{DataLayoutBuilder{ .target = options.target }});
+            builder.data_layout = try builder.fmt("{}", .{DataLayoutBuilder{ .target = target }});
             if (std.debug.runtime_safety) {
                 const rep = target_data.stringRep();
                 defer llvm.disposeMessage(rep);
 @@ -981,13 +995,13 @@ pub const Object = struct {
         obj.* = .{
             .gpa = gpa,
             .builder = builder,
-            .module = options.module.?,
+            .module = comp.module.?,
             .di_map = .{},
             .di_builder = if (builder.useLibLlvm()) builder.llvm.di_builder else null, // TODO
             .di_compile_unit = if (builder.useLibLlvm()) builder.llvm.di_compile_unit else null,
             .target_machine = target_machine,
             .target_data = target_data,
-            .target = options.target,
+            .target = target,
             .decl_map = .{},
             .anon_decl_map = .{},
             .named_enum_map = .{},

src/link.zig+84-49

 @@ -32,13 +32,6 @@ pub const SystemLib = struct {
     path: ?[]const u8,
 };
-/// When adding a new field, remember to update `hashAddFrameworks`.
-pub const Framework = struct {
-    needed: bool = false,
-    weak: bool = false,
-    path: []const u8,
-};
 pub const SortSection = enum { name, alignment };
 pub const CacheMode = enum { incremental, whole };
 @@ -56,14 +49,6 @@ pub fn hashAddSystemLibs(
     }
 }
-pub fn hashAddFrameworks(man: *Cache.Manifest, hm: []const Framework) !void {
-    for (hm) |value| {
-        man.hash.add(value.needed);
-        man.hash.add(value.weak);
-        _ = try man.addFile(value.path, null);
-    }
-}
 pub const producer_string = if (builtin.is_test) "zig test" else "zig " ++ build_options.version;
 pub const HashStyle = enum { sysv, gnu, both };
 @@ -81,6 +66,19 @@ pub const File = struct {
     /// When linking with LLD, this linker code will output an object file only at
     /// this location, and then this path can be placed on the LLD linker line.
     intermediary_basename: ?[]const u8 = null,
+    disable_lld_caching: bool,
+    gc_sections: bool,
+    build_id: std.zig.BuildId,
+    rpath_list: []const []const u8,
+    /// List of symbols forced as undefined in the symbol table
+    /// thus forcing their resolution by the linker.
+    /// Corresponds to `-u <symbol>` for ELF/MachO and `/include:<symbol>` for COFF/PE.
+    force_undefined_symbols: std.StringArrayHashMapUnmanaged(void),
+    allow_shlib_undefined: bool,
+    stack_size: u64,
+    debug_format: DebugFormat,
+    function_sections: bool,
+    data_sections: bool,
     /// Prevents other processes from clobbering files in the output directory
     /// of this linking operation.
 @@ -88,6 +86,12 @@ pub const File = struct {
     child_pid: ?std.ChildProcess.Id = null,
+    pub const DebugFormat = union(enum) {
+        strip,
+        dwarf: std.dwarf.Format,
+        code_view,
+    };
     pub const OpenOptions = struct {
         comp: *Compilation,
         emit: Compilation.Emit,
 @@ -97,7 +101,7 @@ pub const File = struct {
         /// Virtual address of the entry point procedure relative to image base.
         entry_addr: ?u64,
-        stack_size_override: ?u64,
+        stack_size: ?u64,
         image_base_override: ?u64,
         function_sections: bool,
         data_sections: bool,
 @@ -128,7 +132,6 @@ pub const File = struct {
         max_memory: ?u64,
         export_symbol_names: []const []const u8,
         global_base: ?u64,
-        verbose_link: bool,
         dll_export_fns: bool,
         skip_linker_dependencies: bool,
         parent_compilation_link_libc: bool,
 @@ -139,7 +142,7 @@ pub const File = struct {
         sort_section: ?SortSection,
         major_subsystem_version: ?u32,
         minor_subsystem_version: ?u32,
-        gc_sections: ?bool = null,
+        gc_sections: ?bool,
         allow_shlib_undefined: ?bool,
         subsystem: ?std.Target.SubSystem,
         version_script: ?[]const u8,
 @@ -147,11 +150,7 @@ pub const File = struct {
         print_gc_sections: bool,
         print_icf_sections: bool,
         print_map: bool,
-        opt_bisect_limit: i32,
-        /// List of symbols forced as undefined in the symbol table
-        /// thus forcing their resolution by the linker.
-        /// Corresponds to `-u <symbol>` for ELF/MachO and `/include:<symbol>` for COFF/PE.
         force_undefined_symbols: std.StringArrayHashMapUnmanaged(void),
         /// Use a wrapper function for symbol. Any undefined reference to symbol
         /// will be resolved to __wrap_symbol. Any undefined reference to
 @@ -163,7 +162,7 @@ pub const File = struct {
         compatibility_version: ?std.SemanticVersion,
-        dwarf_format: ?std.dwarf.Format,
+        debug_format: ?DebugFormat,
         // TODO: remove this. libraries are resolved by the frontend.
         lib_dirs: []const []const u8,
 @@ -184,8 +183,7 @@ pub const File = struct {
         headerpad_max_install_names: bool,
         /// (Darwin) remove dylibs that are unreachable by the entry point or exported symbols
         dead_strip_dylibs: bool,
-        framework_dirs: []const []const u8,
+        frameworks: []const MachO.Framework,
-        frameworks: []const Framework,
         darwin_sdk_layout: ?MachO.SdkLayout,
         /// (Windows) PDB source path prefix to instruct the linker how to resolve relative
 @@ -228,7 +226,7 @@ pub const File = struct {
             .coff, .elf, .macho, .plan9, .wasm => {
                 if (build_options.only_c) unreachable;
                 if (base.file != null) return;
-                const emit = base.options.emit orelse return;
+                const emit = base.emit;
                 if (base.child_pid) |pid| {
                     if (builtin.os.tag == .windows) {
                         base.cast(Coff).?.ptraceAttach(pid) catch |err| {
 @@ -256,10 +254,13 @@ pub const File = struct {
                         }
                     }
                 }
+                const use_lld = build_options.have_llvm and base.comp.config.use_lld;
+                const output_mode = base.comp.config.output_mode;
+                const link_mode = base.comp.config.link_mode;
                 base.file = try emit.directory.handle.createFile(emit.sub_path, .{
                     .truncate = false,
                     .read = true,
-                    .mode = determineMode(base.options),
+                    .mode = determineMode(use_lld, output_mode, link_mode),
                 });
             },
             .c, .spirv, .nvptx => {},
 @@ -267,9 +268,13 @@ pub const File = struct {
     }
     pub fn makeExecutable(base: *File) !void {
-        switch (base.options.output_mode) {
+        const output_mode = base.comp.config.output_mode;
+        const link_mode = base.comp.config.link_mode;
+        const use_lld = build_options.have_llvm and base.comp.config.use_lld;
+        switch (output_mode) {
             .Obj => return,
-            .Lib => switch (base.options.link_mode) {
+            .Lib => switch (link_mode) {
                 .Static => return,
                 .Dynamic => {},
             },
 @@ -278,7 +283,6 @@ pub const File = struct {
         switch (base.tag) {
             .elf => if (base.file) |f| {
                 if (build_options.only_c) unreachable;
-                const use_lld = build_options.have_llvm and base.options.use_lld;
                 if (base.intermediary_basename != null and use_lld) {
                     // The file we have open is not the final file that we want to
                     // make executable, so we don't have to close it.
 @@ -596,7 +600,7 @@ pub const File = struct {
             return @fieldParentPtr(C, "base", base).flush(comp, prog_node);
         }
         if (comp.clang_preprocessor_mode == .yes) {
-            const emit = base.options.emit orelse return; // -fno-emit-bin
+            const emit = base.emit;
             // TODO: avoid extra link step when it's just 1 object file (the `zig cc -c` case)
             // Until then, we do `lld -r -o output.o input.o` even though the output is the same
             // as the input. For the preprocessing case (`zig cc -E -o foo`) we copy the file
 @@ -610,8 +614,10 @@ pub const File = struct {
             return;
         }
-        const use_lld = build_options.have_llvm and base.options.use_lld;
+        const use_lld = build_options.have_llvm and base.comp.config.use_lld;
-        if (use_lld and base.options.output_mode == .Lib and base.options.link_mode == .Static) {
+        const output_mode = base.comp.config.output_mode;
+        const link_mode = base.comp.config.link_mode;
+        if (use_lld and output_mode == .Lib and link_mode == .Static) {
             return base.linkAsArchive(comp, prog_node);
         }
         switch (base.tag) {
 @@ -845,8 +851,6 @@ pub const File = struct {
     }
     pub fn linkAsArchive(base: *File, comp: *Compilation, prog_node: *std.Progress.Node) FlushError!void {
-        const emit = base.options.emit orelse return;
         const tracy = trace(@src());
         defer tracy.end();
 @@ -854,22 +858,23 @@ pub const File = struct {
         defer arena_allocator.deinit();
         const arena = arena_allocator.allocator();
-        const directory = emit.directory; // Just an alias to make it shorter to type.
+        const directory = base.emit.directory; // Just an alias to make it shorter to type.
-        const full_out_path = try directory.join(arena, &[_][]const u8{emit.sub_path});
+        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;
         // 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.
-        const module_obj_path: ?[]const u8 = if (base.options.module != null) blk: {
+        const zcu_obj_path: ?[]const u8 = if (opt_zcu != null) blk: {
             try base.flushModule(comp, prog_node);
             const dirname = fs.path.dirname(full_out_path_z) orelse ".";
             break :blk try fs.path.join(arena, &.{ dirname, base.intermediary_basename.? });
         } else null;
-        log.debug("module_obj_path={s}", .{if (module_obj_path) |s| s else "(null)"});
+        log.debug("zcu_obj_path={s}", .{if (zcu_obj_path) |s| s else "(null)"});
-        const compiler_rt_path: ?[]const u8 = if (base.options.include_compiler_rt)
+        const compiler_rt_path: ?[]const u8 = if (base.comp.include_compiler_rt)
             comp.compiler_rt_obj.?.full_object_path
         else
             null;
 @@ -881,17 +886,19 @@ pub const File = struct {
         const id_symlink_basename = "llvm-ar.id";
         var man: Cache.Manifest = undefined;
-        defer if (!base.options.disable_lld_caching) man.deinit();
+        defer if (!base.disable_lld_caching) man.deinit();
+        const objects = base.comp.objects;
         var digest: [Cache.hex_digest_len]u8 = undefined;
-        if (!base.options.disable_lld_caching) {
+        if (!base.disable_lld_caching) {
             man = comp.cache_parent.obtain();
             // We are about to obtain this lock, so here we give other processes a chance first.
             base.releaseLock();
-            for (base.options.objects) |obj| {
+            for (objects) |obj| {
                 _ = try man.addFile(obj.path, null);
                 man.hash.add(obj.must_link);
                 man.hash.add(obj.loption);
 @@ -904,7 +911,7 @@ pub const File = struct {
                     _ = try man.addFile(key.status.success.res_path, null);
                 }
             }
-            try man.addOptionalFile(module_obj_path);
+            try man.addOptionalFile(zcu_obj_path);
             try man.addOptionalFile(compiler_rt_path);
             // We don't actually care whether it's a cache hit or miss; we just need the digest and the lock.
 @@ -934,11 +941,11 @@ 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 = base.options.objects.len + comp.c_object_table.count() + win32_resource_table_len + 2;
+        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);
         defer object_files.deinit();
-        for (base.options.objects) |obj| {
+        for (objects) |obj| {
             object_files.appendAssumeCapacity(try arena.dupeZ(u8, obj.path));
         }
         for (comp.c_object_table.keys()) |key| {
 @@ -949,14 +956,14 @@ pub const File = struct {
                 object_files.appendAssumeCapacity(try arena.dupeZ(u8, key.status.success.res_path));
             }
         }
-        if (module_obj_path) |p| {
+        if (zcu_obj_path) |p| {
             object_files.appendAssumeCapacity(try arena.dupeZ(u8, p));
         }
         if (compiler_rt_path) |p| {
             object_files.appendAssumeCapacity(try arena.dupeZ(u8, p));
         }
-        if (base.options.verbose_link) {
+        if (comp.verbose_link) {
             std.debug.print("ar rcs {s}", .{full_out_path_z});
             for (object_files.items) |arg| {
                 std.debug.print(" {s}", .{arg});
 @@ -972,7 +979,7 @@ pub const File = struct {
         const bad = llvm_bindings.WriteArchive(full_out_path_z, object_files.items.ptr, object_files.items.len, os_tag);
         if (bad) return error.UnableToWriteArchive;
-        if (!base.options.disable_lld_caching) {
+        if (!base.disable_lld_caching) {
             Cache.writeSmallFile(directory.handle, id_symlink_basename, &digest) catch |err| {
                 log.warn("failed to save archive hash digest file: {s}", .{@errorName(err)});
             };
 @@ -1090,6 +1097,34 @@ pub const File = struct {
         }
     }
+    pub fn isStatic(self: File) bool {
+        return self.base.options.link_mode == .Static;
+    }
+    pub fn isObject(self: File) bool {
+        const output_mode = self.comp.config.output_mode;
+        return output_mode == .Obj;
+    }
+    pub fn isExe(self: File) bool {
+        const output_mode = self.comp.config.output_mode;
+        return output_mode == .Exe;
+    }
+    pub fn isStaticLib(self: File) bool {
+        const output_mode = self.comp.config.output_mode;
+        return output_mode == .Lib and self.isStatic();
+    }
+    pub fn isRelocatable(self: File) bool {
+        return self.isObject() or self.isStaticLib();
+    }
+    pub fn isDynLib(self: File) bool {
+        const output_mode = self.comp.config.output_mode;
+        return output_mode == .Lib and !self.isStatic();
+    }
     pub const C = @import("link/C.zig");
     pub const Coff = @import("link/Coff.zig");
     pub const Plan9 = @import("link/Plan9.zig");

src/link/C.zig+34-20

 @@ -5,6 +5,7 @@ const Allocator = std.mem.Allocator;
 const fs = std.fs;
 const C = @This();
+const build_options = @import("build_options");
 const Module = @import("../Module.zig");
 const InternPool = @import("../InternPool.zig");
 const Alignment = InternPool.Alignment;
 @@ -91,28 +92,40 @@ pub fn addString(this: *C, s: []const u8) Allocator.Error!String {
     };
 }
-pub fn openPath(gpa: Allocator, sub_path: []const u8, options: link.Options) !*C {
+pub fn open(arena: Allocator, options: link.File.OpenOptions) !*C {
     assert(options.target.ofmt == .c);
+    const optimize_mode = options.comp.root_mod.optimize_mode;
+    const use_lld = build_options.have_llvm and options.comp.config.use_lld;
+    const use_llvm = options.comp.config.use_llvm;
-    if (options.use_llvm) return error.LLVMHasNoCBackend;
+    // These are caught by `Compilation.Config.resolve`.
-    if (options.use_lld) return error.LLDHasNoCBackend;
+    assert(!use_lld);
+    assert(!use_llvm);
-    const file = try options.emit.?.directory.handle.createFile(sub_path, .{
+    const emit = options.emit;
+    const file = try emit.directory.handle.createFile(emit.sub_path, .{
         // Truncation is done on `flush`.
         .truncate = false,
         .mode = link.determineMode(options),
     });
     errdefer file.close();
-    const c_file = try gpa.create(C);
+    const c_file = try arena.create(C);
-    errdefer gpa.destroy(c_file);
     c_file.* = .{
         .base = .{
             .tag = .c,
-            .options = options,
+            .comp = options.comp,
+            .emit = emit,
+            .gc_sections = options.gc_sections orelse optimize_mode != .Debug,
+            .stack_size = options.stack_size orelse 16777216,
+            .allow_shlib_undefined = options.allow_shlib_undefined orelse false,
             .file = file,
-            .allocator = gpa,
+            .disable_lld_caching = options.disable_lld_caching,
+            .build_id = options.build_id,
+            .rpath_list = options.rpath_list,
+            .force_undefined_symbols = options.force_undefined_symbols,
         },
     };
 @@ -120,7 +133,7 @@ pub fn openPath(gpa: Allocator, sub_path: []const u8, options: link.Options) !*C
 }
 pub fn deinit(self: *C) void {
-    const gpa = self.base.allocator;
+    const gpa = self.base.comp.gpa;
     for (self.decl_table.values()) |*db| {
         db.deinit(gpa);
 @@ -141,7 +154,7 @@ pub fn deinit(self: *C) void {
 }
 pub fn freeDecl(self: *C, decl_index: InternPool.DeclIndex) void {
-    const gpa = self.base.allocator;
+    const gpa = self.base.comp.gpa;
     if (self.decl_table.fetchSwapRemove(decl_index)) |kv| {
         var decl_block = kv.value;
         decl_block.deinit(gpa);
 @@ -155,7 +168,7 @@ pub fn updateFunc(
     air: Air,
     liveness: Liveness,
 ) !void {
-    const gpa = self.base.allocator;
+    const gpa = self.base.comp.gpa;
     const func = module.funcInfo(func_index);
     const decl_index = func.owner_decl;
 @@ -223,7 +236,7 @@ pub fn updateFunc(
 }
 fn updateAnonDecl(self: *C, module: *Module, i: usize) !void {
-    const gpa = self.base.allocator;
+    const gpa = self.base.comp.gpa;
     const anon_decl = self.anon_decls.keys()[i];
     const fwd_decl = &self.fwd_decl_buf;
 @@ -285,7 +298,7 @@ pub fn updateDecl(self: *C, module: *Module, decl_index: InternPool.DeclIndex) !
     const tracy = trace(@src());
     defer tracy.end();
-    const gpa = self.base.allocator;
+    const gpa = self.base.comp.gpa;
     const gop = try self.decl_table.getOrPut(gpa, decl_index);
     if (!gop.found_existing) {
 @@ -352,7 +365,8 @@ pub fn flush(self: *C, comp: *Compilation, prog_node: *std.Progress.Node) !void
 }
 fn abiDefines(self: *C, target: std.Target) !std.ArrayList(u8) {
-    var defines = std.ArrayList(u8).init(self.base.allocator);
+    const gpa = self.base.comp.gpa;
+    var defines = std.ArrayList(u8).init(gpa);
     errdefer defines.deinit();
     const writer = defines.writer();
     switch (target.abi) {
 @@ -371,7 +385,7 @@ pub fn flushModule(self: *C, _: *Compilation, prog_node: *std.Progress.Node) !vo
     sub_prog_node.activate();
     defer sub_prog_node.end();
-    const gpa = self.base.allocator;
+    const gpa = self.base.comp.gpa;
     const module = self.base.options.module.?;
     {
 @@ -520,7 +534,7 @@ fn flushCTypes(
     pass: codegen.DeclGen.Pass,
     decl_ctypes: codegen.CType.Store,
 ) FlushDeclError!void {
-    const gpa = self.base.allocator;
+    const gpa = self.base.comp.gpa;
     const mod = self.base.options.module.?;
     const decl_ctypes_len = decl_ctypes.count();
 @@ -601,7 +615,7 @@ fn flushCTypes(
 }
 fn flushErrDecls(self: *C, ctypes: *codegen.CType.Store) FlushDeclError!void {
-    const gpa = self.base.allocator;
+    const gpa = self.base.comp.gpa;
     const fwd_decl = &self.lazy_fwd_decl_buf;
     const code = &self.lazy_code_buf;
 @@ -643,7 +657,7 @@ fn flushLazyFn(
     ctypes: *codegen.CType.Store,
     lazy_fn: codegen.LazyFnMap.Entry,
 ) FlushDeclError!void {
-    const gpa = self.base.allocator;
+    const gpa = self.base.comp.gpa;
     const fwd_decl = &self.lazy_fwd_decl_buf;
     const code = &self.lazy_code_buf;
 @@ -683,7 +697,7 @@ fn flushLazyFn(
 }
 fn flushLazyFns(self: *C, f: *Flush, lazy_fns: codegen.LazyFnMap) FlushDeclError!void {
-    const gpa = self.base.allocator;
+    const gpa = self.base.comp.gpa;
     try f.lazy_fns.ensureUnusedCapacity(gpa, @intCast(lazy_fns.count()));
     var it = lazy_fns.iterator();
 @@ -702,7 +716,7 @@ fn flushDeclBlock(
     export_names: std.AutoHashMapUnmanaged(InternPool.NullTerminatedString, void),
     extern_symbol_name: InternPool.OptionalNullTerminatedString,
 ) FlushDeclError!void {
-    const gpa = self.base.allocator;
+    const gpa = self.base.comp.gpa;
     try self.flushLazyFns(f, decl_block.lazy_fns);
     try f.all_buffers.ensureUnusedCapacity(gpa, 1);
     fwd_decl: {

src/link/Coff.zig+14-11

 @@ -232,7 +232,7 @@ pub fn open(arena: Allocator, options: link.File.OpenOptions) !*Coff {
     errdefer self.base.destroy();
     const use_lld = build_options.have_llvm and options.comp.config.use_lld;
-    const use_llvm = build_options.have_llvm and options.comp.config.use_llvm;
+    const use_llvm = options.comp.config.use_llvm;
     if (use_lld and use_llvm) {
         // LLVM emits the object file; LLD links it into the final product.
 @@ -353,6 +353,7 @@ pub fn open(arena: Allocator, options: link.File.OpenOptions) !*Coff {
 pub fn createEmpty(arena: Allocator, options: link.File.OpenOptions) !*Coff {
     const target = options.comp.root_mod.resolved_target.result;
+    const optimize_mode = options.comp.root_mod.optimize_mode;
     const ptr_width: PtrWidth = switch (target.ptrBitWidth()) {
         0...32 => .p32,
         33...64 => .p64,
 @@ -367,14 +368,24 @@ pub fn createEmpty(arena: Allocator, options: link.File.OpenOptions) !*Coff {
             .tag = .coff,
             .comp = options.comp,
             .emit = options.emit,
+            .stack_size = options.stack_size orelse 16777216,
+            .gc_sections = options.gc_sections orelse (optimize_mode != .Debug),
+            .allow_shlib_undefined = options.allow_shlib_undefined orelse false,
             .file = null,
+            .disable_lld_caching = options.disable_lld_caching,
+            .build_id = options.build_id,
+            .rpath_list = options.rpath_list,
+            .force_undefined_symbols = options.force_undefined_symbols,
+            .debug_format = options.debug_format orelse .code_view,
+            .function_sections = options.function_sections,
+            .data_sections = options.data_sections,
         },
         .ptr_width = ptr_width,
         .page_size = page_size,
         .data_directories = comptime mem.zeroes([coff.IMAGE_NUMBEROF_DIRECTORY_ENTRIES]coff.ImageDataDirectory),
     };
-    const use_llvm = build_options.have_llvm and options.comp.config.use_llvm;
+    const use_llvm = options.comp.config.use_llvm;
     if (use_llvm and options.comp.config.have_zcu) {
         self.llvm_object = try LlvmObject.create(arena, options);
     }
 @@ -1494,8 +1505,6 @@ pub fn updateExports(
     if (self.llvm_object) |llvm_object| return llvm_object.updateExports(mod, exported, exports);
-    if (self.base.options.emit == null) return;
     const gpa = self.base.comp.gpa;
     const metadata = switch (exported) {
 @@ -1645,13 +1654,7 @@ fn resolveGlobalSymbol(self: *Coff, current: SymbolWithLoc) !void {
 }
 pub fn flush(self: *Coff, comp: *Compilation, prog_node: *std.Progress.Node) link.File.FlushError!void {
-    if (self.base.options.emit == null) {
+    const use_lld = build_options.have_llvm and self.base.comp.config.use_lld;
-        if (self.llvm_object) |llvm_object| {
-            return try llvm_object.flushModule(comp, prog_node);
-        }
-        return;
-    }
-    const use_lld = build_options.have_llvm and self.base.options.use_lld;
     if (use_lld) {
         return lld.linkWithLLD(self, comp, prog_node);
     }

src/link/Coff/lld.zig+15-17

 @@ -25,8 +25,8 @@ pub fn linkWithLLD(self: *Coff, comp: *Compilation, prog_node: *std.Progress.Nod
     defer arena_allocator.deinit();
     const arena = arena_allocator.allocator();
-    const directory = self.base.options.emit.?.directory; // Just an alias to make it shorter to type.
+    const directory = self.base.emit.directory; // Just an alias to make it shorter to type.
-    const full_out_path = try directory.join(arena, &[_][]const u8{self.base.options.emit.?.sub_path});
+    const full_out_path = try directory.join(arena, &[_][]const u8{self.base.emit.sub_path});
     // 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.
 @@ -50,6 +50,7 @@ pub fn linkWithLLD(self: *Coff, comp: *Compilation, prog_node: *std.Progress.Nod
     const is_exe_or_dyn_lib = is_dyn_lib or self.base.options.output_mode == .Exe;
     const link_in_crt = self.base.options.link_libc and is_exe_or_dyn_lib;
     const target = self.base.options.target;
+    const optimize_mode = self.base.comp.root_mod.optimize_mode;
     // See link/Elf.zig for comments on how this mechanism works.
     const id_symlink_basename = "lld.id";
 @@ -79,7 +80,7 @@ pub fn linkWithLLD(self: *Coff, comp: *Compilation, prog_node: *std.Progress.Nod
         }
         try man.addOptionalFile(module_obj_path);
         man.hash.addOptionalBytes(self.base.options.entry);
-        man.hash.addOptional(self.base.options.stack_size_override);
+        man.hash.add(self.base.stack_size);
         man.hash.addOptional(self.base.options.image_base_override);
         man.hash.addListOfBytes(self.base.options.lib_dirs);
         man.hash.add(self.base.options.skip_linker_dependencies);
 @@ -93,14 +94,14 @@ pub fn linkWithLLD(self: *Coff, comp: *Compilation, prog_node: *std.Progress.Nod
                 }
             }
         }
-        try link.hashAddSystemLibs(&man, self.base.options.system_libs);
+        try link.hashAddSystemLibs(&man, self.base.comp.system_libs);
         man.hash.addListOfBytes(self.base.options.force_undefined_symbols.keys());
         man.hash.addOptional(self.base.options.subsystem);
         man.hash.add(self.base.options.is_test);
         man.hash.add(self.base.options.tsaware);
         man.hash.add(self.base.options.nxcompat);
         man.hash.add(self.base.options.dynamicbase);
-        man.hash.addOptional(self.base.options.allow_shlib_undefined);
+        man.hash.addOptional(self.base.allow_shlib_undefined);
         // strip does not need to go into the linker hash because it is part of the hash namespace
         man.hash.addOptional(self.base.options.major_subsystem_version);
         man.hash.addOptional(self.base.options.minor_subsystem_version);
 @@ -185,15 +186,14 @@ pub fn linkWithLLD(self: *Coff, comp: *Compilation, prog_node: *std.Progress.Nod
             try argv.append(try allocPrint(arena, "-VERSION:{}.{}", .{ version.major, version.minor }));
         }
         if (self.base.options.lto) {
-            switch (self.base.options.optimize_mode) {
+            switch (optimize_mode) {
                 .Debug => {},
                 .ReleaseSmall => try argv.append("-OPT:lldlto=2"),
                 .ReleaseFast, .ReleaseSafe => try argv.append("-OPT:lldlto=3"),
             }
         }
         if (self.base.options.output_mode == .Exe) {
-            const stack_size = self.base.options.stack_size_override orelse 16777216;
+            try argv.append(try allocPrint(arena, "-STACK:{d}", .{self.base.stack_size}));
-            try argv.append(try allocPrint(arena, "-STACK:{d}", .{stack_size}));
         }
         if (self.base.options.image_base_override) |image_base| {
             try argv.append(try std.fmt.allocPrint(arena, "-BASE:{d}", .{image_base}));
 @@ -232,10 +232,8 @@ pub fn linkWithLLD(self: *Coff, comp: *Compilation, prog_node: *std.Progress.Nod
         if (!self.base.options.dynamicbase) {
             try argv.append("-dynamicbase:NO");
         }
-        if (self.base.options.allow_shlib_undefined) |allow_shlib_undefined| {
+        if (self.base.allow_shlib_undefined) {
-            if (allow_shlib_undefined) {
+            try argv.append("-FORCE:UNRESOLVED");
-                try argv.append("-FORCE:UNRESOLVED");
-            }
         }
         try argv.append(try allocPrint(arena, "-OUT:{s}", .{full_out_path}));
 @@ -419,7 +417,7 @@ pub fn linkWithLLD(self: *Coff, comp: *Compilation, prog_node: *std.Progress.Nod
                         try argv.append(try comp.get_libc_crt_file(arena, "uuid.lib"));
                         for (mingw.always_link_libs) |name| {
-                            if (!self.base.options.system_libs.contains(name)) {
+                            if (!self.base.comp.system_libs.contains(name)) {
                                 const lib_basename = try allocPrint(arena, "{s}.lib", .{name});
                                 try argv.append(try comp.get_libc_crt_file(arena, lib_basename));
                             }
 @@ -429,7 +427,7 @@ pub fn linkWithLLD(self: *Coff, comp: *Compilation, prog_node: *std.Progress.Nod
                             .Dynamic => "",
                             .Static => "lib",
                         };
-                        const d_str = switch (self.base.options.optimize_mode) {
+                        const d_str = switch (optimize_mode) {
                             .Debug => "d",
                             else => "",
                         };
 @@ -489,8 +487,8 @@ pub fn linkWithLLD(self: *Coff, comp: *Compilation, prog_node: *std.Progress.Nod
             if (comp.compiler_rt_lib) |lib| try argv.append(lib.full_object_path);
         }
-        try argv.ensureUnusedCapacity(self.base.options.system_libs.count());
+        try argv.ensureUnusedCapacity(self.base.comp.system_libs.count());
-        for (self.base.options.system_libs.keys()) |key| {
+        for (self.base.comp.system_libs.keys()) |key| {
             const lib_basename = try allocPrint(arena, "{s}.lib", .{key});
             if (comp.crt_files.get(lib_basename)) |crt_file| {
                 argv.appendAssumeCapacity(crt_file.full_object_path);
 @@ -516,7 +514,7 @@ pub fn linkWithLLD(self: *Coff, comp: *Compilation, prog_node: *std.Progress.Nod
             return error.DllImportLibraryNotFound;
         }
-        if (self.base.options.verbose_link) {
+        if (self.base.comp.verbose_link) {
             // Skip over our own name so that the LLD linker name is the first argv item.
             Compilation.dump_argv(argv.items[1..]);
         }

src/link/Elf.zig+169-153

 @@ -206,7 +206,10 @@ pub fn open(arena: Allocator, options: link.File.OpenOptions) !*Elf {
     assert(target.ofmt == .elf);
     const use_lld = build_options.have_llvm and options.comp.config.use_lld;
-    const use_llvm = build_options.have_llvm and options.comp.config.use_llvm;
+    const use_llvm = options.comp.config.use_llvm;
+    const opt_zcu = options.comp.module;
+    const output_mode = options.comp.config.output_mode;
+    const link_mode = options.comp.config.link_mode;
     const self = try createEmpty(arena, options);
     errdefer self.base.destroy();
 @@ -216,8 +219,8 @@ pub fn open(arena: Allocator, options: link.File.OpenOptions) !*Elf {
         return self;
     }
-    const is_obj = options.output_mode == .Obj;
+    const is_obj = output_mode == .Obj;
-    const is_obj_or_ar = is_obj or (options.output_mode == .Lib and options.link_mode == .Static);
+    const is_obj_or_ar = is_obj or (output_mode == .Lib and link_mode == .Static);
     const sub_path = if (!use_lld) options.emit.sub_path else p: {
         // Open a temporary object file, not the final output file because we
 @@ -229,10 +232,10 @@ pub fn open(arena: Allocator, options: link.File.OpenOptions) !*Elf {
         break :p o_file_path;
     };
-    self.base.file = try options.emit.?.directory.handle.createFile(sub_path, .{
+    self.base.file = try options.emit.directory.handle.createFile(sub_path, .{
         .truncate = false,
         .read = true,
-        .mode = link.determineMode(options),
+        .mode = link.File.determineMode(use_lld, output_mode, link_mode),
     });
     const gpa = options.comp.gpa;
 @@ -292,24 +295,34 @@ pub fn open(arena: Allocator, options: link.File.OpenOptions) !*Elf {
         });
     }
-    if (options.module != null and !options.use_llvm) {
+    if (opt_zcu) |zcu| {
-        const index = @as(File.Index, @intCast(try self.files.addOne(gpa)));
+        if (!use_llvm) {
-        self.files.set(index, .{ .zig_object = .{
+            const index: File.Index = @intCast(try self.files.addOne(gpa));
-            .index = index,
+            self.files.set(index, .{ .zig_object = .{
-            .path = try std.fmt.allocPrint(arena, "{s}.o", .{std.fs.path.stem(
+                .index = index,
-                options.module.?.main_mod.root_src_path,
+                .path = try std.fmt.allocPrint(arena, "{s}.o", .{std.fs.path.stem(
-            )}),
+                    zcu.main_mod.root_src_path,
-        } });
+                )}),
-        self.zig_object_index = index;
+            } });
-        try self.zigObjectPtr().?.init(self);
+            self.zig_object_index = index;
-        try self.initMetadata();
+            try self.zigObjectPtr().?.init(self);
+            try self.initMetadata(.{
+                .symbol_count_hint = options.symbol_count_hint,
+                .program_code_size_hint = options.program_code_size_hint,
+            });
+        }
     }
     return self;
 }
 pub fn createEmpty(arena: Allocator, options: link.File.OpenOptions) !*Elf {
+    const use_llvm = options.comp.config.use_llvm;
+    const optimize_mode = options.comp.root_mod.optimize_mode;
     const target = options.comp.root_mod.resolved_target.result;
+    const output_mode = options.comp.config.output_mode;
+    const link_mode = options.comp.config.link_mode;
+    const is_native_os = options.comp.root_mod.resolved_target.is_native_os;
     const ptr_width: PtrWidth = switch (target.ptrBitWidth()) {
         0...32 => .p32,
         33...64 => .p64,
 @@ -322,7 +335,7 @@ pub fn createEmpty(arena: Allocator, options: link.File.OpenOptions) !*Elf {
         .sparc64 => 0x2000,
         else => 0x1000,
     };
-    const is_dyn_lib = options.output_mode == .Lib and options.link_mode == .Dynamic;
+    const is_dyn_lib = output_mode == .Lib and link_mode == .Dynamic;
     const default_sym_version: elf.Elf64_Versym = if (is_dyn_lib or options.rdynamic)
         elf.VER_NDX_GLOBAL
     else
 @@ -333,13 +346,23 @@ pub fn createEmpty(arena: Allocator, options: link.File.OpenOptions) !*Elf {
             .tag = .elf,
             .comp = options.comp,
             .emit = options.emit,
+            .gc_sections = options.gc_sections orelse (optimize_mode != .Debug and output_mode != .Obj),
+            .stack_size = options.stack_size orelse 16777216,
+            .allow_shlib_undefined = options.allow_shlib_undefined orelse !is_native_os,
             .file = null,
+            .disable_lld_caching = options.disable_lld_caching,
+            .build_id = options.build_id,
+            .rpath_list = options.rpath_list,
+            .force_undefined_symbols = options.force_undefined_symbols,
+            .debug_format = options.debug_format orelse .{ .dwarf = .@"32" },
+            .function_sections = options.function_sections,
+            .data_sections = options.data_sections,
         },
         .ptr_width = ptr_width,
         .page_size = page_size,
         .default_sym_version = default_sym_version,
     };
-    if (options.use_llvm and options.comp.config.have_zcu) {
+    if (use_llvm and options.comp.config.have_zcu) {
         self.llvm_object = try LlvmObject.create(arena, options);
     }
 @@ -504,8 +527,13 @@ fn findFreeSpace(self: *Elf, object_size: u64, min_alignment: u64) u64 {
     return start;
 }
+pub const InitMetadataOptions = struct {
+    symbol_count_hint: u64,
+    program_code_size_hint: u64,
+};
 /// TODO move to ZigObject
-pub fn initMetadata(self: *Elf) !void {
+pub fn initMetadata(self: *Elf, options: InitMetadataOptions) !void {
     const gpa = self.base.comp.gpa;
     const ptr_size = self.ptrWidthBytes();
     const target = self.base.comp.root_mod.resolved_target.result;
 @@ -515,7 +543,7 @@ pub fn initMetadata(self: *Elf) !void {
     const fillSection = struct {
         fn fillSection(elf_file: *Elf, shdr: *elf.Elf64_Shdr, size: u64, phndx: ?u16) void {
-            if (elf_file.isRelocatable()) {
+            if (elf_file.base.isRelocatable()) {
                 const off = elf_file.findFreeSpace(size, shdr.sh_addralign);
                 shdr.sh_offset = off;
                 shdr.sh_size = size;
 @@ -530,9 +558,9 @@ pub fn initMetadata(self: *Elf) !void {
     comptime assert(number_of_zig_segments == 5);
-    if (!self.isRelocatable()) {
+    if (!self.base.isRelocatable()) {
         if (self.phdr_zig_load_re_index == null) {
-            const filesz = self.base.options.program_code_size_hint;
+            const filesz = options.program_code_size_hint;
             const off = self.findFreeSpace(filesz, self.page_size);
             self.phdr_zig_load_re_index = try self.addPhdr(.{
                 .type = elf.PT_LOAD,
 @@ -549,7 +577,7 @@ pub fn initMetadata(self: *Elf) !void {
             // We really only need ptr alignment but since we are using PROGBITS, linux requires
             // page align.
             const alignment = if (is_linux) self.page_size else @as(u16, ptr_size);
-            const filesz = @as(u64, ptr_size) * self.base.options.symbol_count_hint;
+            const filesz = @as(u64, ptr_size) * options.symbol_count_hint;
             const off = self.findFreeSpace(filesz, alignment);
             self.phdr_zig_got_index = try self.addPhdr(.{
                 .type = elf.PT_LOAD,
 @@ -613,8 +641,8 @@ pub fn initMetadata(self: *Elf) !void {
             .offset = std.math.maxInt(u64),
         });
         const shdr = &self.shdrs.items[self.zig_text_section_index.?];
-        fillSection(self, shdr, self.base.options.program_code_size_hint, self.phdr_zig_load_re_index);
+        fillSection(self, shdr, options.program_code_size_hint, self.phdr_zig_load_re_index);
-        if (self.isRelocatable()) {
+        if (self.base.isRelocatable()) {
             const rela_shndx = try self.addRelaShdr(".rela.text.zig", self.zig_text_section_index.?);
             try self.output_rela_sections.putNoClobber(gpa, self.zig_text_section_index.?, .{
                 .shndx = rela_shndx,
 @@ -630,7 +658,7 @@ pub fn initMetadata(self: *Elf) !void {
         try self.last_atom_and_free_list_table.putNoClobber(gpa, self.zig_text_section_index.?, .{});
     }
-    if (self.zig_got_section_index == null and !self.isRelocatable()) {
+    if (self.zig_got_section_index == null and !self.base.isRelocatable()) {
         self.zig_got_section_index = try self.addSection(.{
             .name = ".got.zig",
             .type = elf.SHT_PROGBITS,
 @@ -661,7 +689,7 @@ pub fn initMetadata(self: *Elf) !void {
         });
         const shdr = &self.shdrs.items[self.zig_data_rel_ro_section_index.?];
         fillSection(self, shdr, 1024, self.phdr_zig_load_ro_index);
-        if (self.isRelocatable()) {
+        if (self.base.isRelocatable()) {
             const rela_shndx = try self.addRelaShdr(
                 ".rela.data.rel.ro.zig",
                 self.zig_data_rel_ro_section_index.?,
 @@ -690,7 +718,7 @@ pub fn initMetadata(self: *Elf) !void {
         });
         const shdr = &self.shdrs.items[self.zig_data_section_index.?];
         fillSection(self, shdr, 1024, self.phdr_zig_load_rw_index);
-        if (self.isRelocatable()) {
+        if (self.base.isRelocatable()) {
             const rela_shndx = try self.addRelaShdr(
                 ".rela.data.zig",
                 self.zig_data_section_index.?,
 @@ -930,13 +958,7 @@ pub fn markDirty(self: *Elf, shdr_index: u16) void {
 }
 pub fn flush(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) link.File.FlushError!void {
-    if (self.base.options.emit == null) {
+    const use_lld = build_options.have_llvm and self.base.comp.config.use_lld;
-        if (self.llvm_object) |llvm_object| {
-            try llvm_object.flushModule(comp, prog_node);
-        }
-        return;
-    }
-    const use_lld = build_options.have_llvm and self.base.options.use_lld;
     if (use_lld) {
         return self.linkWithLLD(comp, prog_node);
     }
 @@ -950,7 +972,7 @@ pub fn flushModule(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node
     if (self.llvm_object) |llvm_object| {
         try llvm_object.flushModule(comp, prog_node);
-        const use_lld = build_options.have_llvm and self.base.options.use_lld;
+        const use_lld = build_options.have_llvm and self.base.comp.config.use_lld;
         if (use_lld) return;
     }
 @@ -959,13 +981,14 @@ pub fn flushModule(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node
     sub_prog_node.activate();
     defer sub_prog_node.end();
-    var arena_allocator = std.heap.ArenaAllocator.init(self.base.allocator);
+    var arena_allocator = std.heap.ArenaAllocator.init(gpa);
     defer arena_allocator.deinit();
     const arena = arena_allocator.allocator();
     const target = self.base.comp.root_mod.resolved_target.result;
-    const directory = self.base.options.emit.?.directory; // Just an alias to make it shorter to type.
+    const link_mode = self.base.comp.config.link_mode;
-    const full_out_path = try directory.join(arena, &[_][]const u8{self.base.options.emit.?.sub_path});
+    const directory = self.base.emit.directory; // Just an alias to make it shorter to type.
+    const full_out_path = try directory.join(arena, &[_][]const u8{self.base.emit.sub_path});
     const module_obj_path: ?[]const u8 = if (self.base.intermediary_basename) |path| blk: {
         if (fs.path.dirname(full_out_path)) |dirname| {
             break :blk try fs.path.join(arena, &.{ dirname, path });
 @@ -973,10 +996,10 @@ pub fn flushModule(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node
             break :blk path;
         }
     } else null;
-    const gc_sections = self.base.options.gc_sections orelse false;
+    const gc_sections = self.base.gc_sections;
     // --verbose-link
-    if (self.base.options.verbose_link) try self.dumpArgv(comp);
+    if (self.base.comp.verbose_link) try self.dumpArgv(comp);
     const csu = try CsuObjects.init(arena, self.base.options, comp);
     const compiler_rt_path: ?[]const u8 = blk: {
 @@ -986,8 +1009,8 @@ pub fn flushModule(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node
     };
     if (self.zigObjectPtr()) |zig_object| try zig_object.flushModule(self);
-    if (self.isStaticLib()) return self.flushStaticLib(comp, module_obj_path);
+    if (self.base.isStaticLib()) return self.flushStaticLib(comp, module_obj_path);
-    if (self.isObject()) return self.flushObject(comp, module_obj_path);
+    if (self.base.isObject()) return self.flushObject(comp, module_obj_path);
     // Here we will parse input positional and library files (if referenced).
     // This will roughly match in any linker backend we support.
 @@ -1011,7 +1034,7 @@ pub fn flushModule(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node
     if (module_obj_path) |path| try positionals.append(.{ .path = path });
     // rpaths
-    var rpath_table = std.StringArrayHashMap(void).init(self.base.allocator);
+    var rpath_table = std.StringArrayHashMap(void).init(gpa);
     defer rpath_table.deinit();
     for (self.base.options.rpath_list) |rpath| {
 @@ -1019,10 +1042,10 @@ pub fn flushModule(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node
     }
     if (self.base.options.each_lib_rpath) {
-        var test_path = std.ArrayList(u8).init(self.base.allocator);
+        var test_path = std.ArrayList(u8).init(gpa);
         defer test_path.deinit();
         for (self.base.options.lib_dirs) |lib_dir_path| {
-            for (self.base.options.system_libs.keys()) |link_lib| {
+            for (self.base.comp.system_libs.keys()) |link_lib| {
                 if (!(try self.accessLibPath(&test_path, null, lib_dir_path, link_lib, .Dynamic)))
                     continue;
                 _ = try rpath_table.put(lib_dir_path, {});
 @@ -1064,8 +1087,8 @@ pub fn flushModule(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node
     var system_libs = std.ArrayList(SystemLib).init(arena);
-    try system_libs.ensureUnusedCapacity(self.base.options.system_libs.values().len);
+    try system_libs.ensureUnusedCapacity(self.base.comp.system_libs.values().len);
-    for (self.base.options.system_libs.values()) |lib_info| {
+    for (self.base.comp.system_libs.values()) |lib_info| {
         system_libs.appendAssumeCapacity(.{ .needed = lib_info.needed, .path = lib_info.path.? });
     }
 @@ -1127,7 +1150,7 @@ pub fn flushModule(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node
                 .path = try comp.get_libc_crt_file(arena, "libc_nonshared.a"),
             });
         } else if (target.isMusl()) {
-            const path = try comp.get_libc_crt_file(arena, switch (self.base.options.link_mode) {
+            const path = try comp.get_libc_crt_file(arena, switch (link_mode) {
                 .Static => "libc.a",
                 .Dynamic => "libc.so",
             });
 @@ -1224,7 +1247,7 @@ pub fn flushModule(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node
     if (self.entry_index == null) {
         const entry: ?[]const u8 = entry: {
             if (self.base.options.entry) |entry| break :entry entry;
-            if (!self.isDynLib()) break :entry "_start";
+            if (!self.base.isDynLib()) break :entry "_start";
             break :entry null;
         };
         self.entry_index = if (entry) |name| self.globalByName(name) else null;
 @@ -1301,7 +1324,7 @@ pub fn flushModule(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node
     try self.writeAtoms();
     try self.writeSyntheticSections();
-    if (self.entry_index == null and self.isExe()) {
+    if (self.entry_index == null and self.base.isExe()) {
         log.debug("flushing. no_entry_point_found = true", .{});
         self.error_flags.no_entry_point_found = true;
     } else {
 @@ -1531,13 +1554,15 @@ pub fn flushObject(self: *Elf, comp: *Compilation, module_obj_path: ?[]const u8)
 /// --verbose-link output
 fn dumpArgv(self: *Elf, comp: *Compilation) !void {
-    var arena_allocator = std.heap.ArenaAllocator.init(self.base.allocator);
+    const gpa = self.base.comp.gpa;
+    var arena_allocator = std.heap.ArenaAllocator.init(gpa);
     defer arena_allocator.deinit();
     const arena = arena_allocator.allocator();
     const target = self.base.comp.root_mod.resolved_target.result;
-    const directory = self.base.options.emit.?.directory; // Just an alias to make it shorter to type.
+    const link_mode = self.base.comp.config.link_mode;
-    const full_out_path = try directory.join(arena, &[_][]const u8{self.base.options.emit.?.sub_path});
+    const directory = self.base.emit.directory; // Just an alias to make it shorter to type.
+    const full_out_path = try directory.join(arena, &[_][]const u8{self.base.emit.sub_path});
     const module_obj_path: ?[]const u8 = if (self.base.intermediary_basename) |path| blk: {
         if (fs.path.dirname(full_out_path)) |dirname| {
             break :blk try fs.path.join(arena, &.{ dirname, path });
 @@ -1545,7 +1570,6 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
             break :blk path;
         }
     } else null;
-    const gc_sections = self.base.options.gc_sections orelse false;
     const csu = try CsuObjects.init(arena, self.base.options, comp);
     const compiler_rt_path: ?[]const u8 = blk: {
 @@ -1558,20 +1582,20 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
     try argv.append("zig");
-    if (self.isStaticLib()) {
+    if (self.base.isStaticLib()) {
         try argv.append("ar");
     } else {
         try argv.append("ld");
     }
-    if (self.isObject()) {
+    if (self.base.isObject()) {
         try argv.append("-r");
     }
     try argv.append("-o");
     try argv.append(full_out_path);
-    if (self.isRelocatable()) {
+    if (self.base.isRelocatable()) {
         for (self.base.options.objects) |obj| {
             try argv.append(obj.path);
         }
 @@ -1591,7 +1615,7 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
             }
         }
-        if (self.isDynLib()) {
+        if (self.base.isDynLib()) {
             if (self.base.options.soname) |name| {
                 try argv.append("-soname");
                 try argv.append(name);
 @@ -1624,16 +1648,16 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
             }
         }
-        if (self.base.options.stack_size_override) |ss| {
+        try argv.appendSlice(&.{
-            try argv.append("-z");
+            "-z",
-            try argv.append(try std.fmt.allocPrint(arena, "stack-size={d}", .{ss}));
+            try std.fmt.allocPrint(arena, "stack-size={d}", .{self.base.stack_size}),
-        }
+        });
         if (self.base.options.image_base_override) |image_base| {
             try argv.append(try std.fmt.allocPrint(arena, "--image-base={d}", .{image_base}));
         }
-        if (gc_sections) {
+        if (self.base.gc_sections) {
             try argv.append("--gc-sections");
         }
 @@ -1666,11 +1690,11 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
         if (self.isStatic()) {
             try argv.append("-static");
-        } else if (self.isDynLib()) {
+        } else if (self.base.isDynLib()) {
             try argv.append("-shared");
         }
-        if (self.base.options.pie and self.isExe()) {
+        if (self.base.options.pie and self.base.isExe()) {
             try argv.append("-pie");
         }
 @@ -1741,11 +1765,11 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
         // Shared libraries.
         // Worst-case, we need an --as-needed argument for every lib, as well
         // as one before and one after.
-        try argv.ensureUnusedCapacity(self.base.options.system_libs.keys().len * 2 + 2);
+        try argv.ensureUnusedCapacity(self.base.comp.system_libs.keys().len * 2 + 2);
         argv.appendAssumeCapacity("--as-needed");
         var as_needed = true;
-        for (self.base.options.system_libs.values()) |lib_info| {
+        for (self.base.comp.system_libs.values()) |lib_info| {
             const lib_as_needed = !lib_info.needed;
             switch ((@as(u2, @intFromBool(lib_as_needed)) << 1) | @intFromBool(as_needed)) {
                 0b00, 0b11 => {},
 @@ -1780,7 +1804,7 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
         // libc dep
         if (self.base.options.link_libc) {
             if (self.base.options.libc_installation != null) {
-                const needs_grouping = self.base.options.link_mode == .Static;
+                const needs_grouping = link_mode == .Static;
                 if (needs_grouping) try argv.append("--start-group");
                 try argv.appendSlice(target_util.libcFullLinkFlags(target));
                 if (needs_grouping) try argv.append("--end-group");
 @@ -1793,7 +1817,7 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
                 }
                 try argv.append(try comp.get_libc_crt_file(arena, "libc_nonshared.a"));
             } else if (target.isMusl()) {
-                try argv.append(try comp.get_libc_crt_file(arena, switch (self.base.options.link_mode) {
+                try argv.append(try comp.get_libc_crt_file(arena, switch (link_mode) {
                     .Static => "libc.a",
                     .Dynamic => "libc.so",
                 }));
 @@ -2006,6 +2030,7 @@ fn accessLibPath(
     lib_name: []const u8,
     link_mode: ?std.builtin.LinkMode,
 ) !bool {
+    const gpa = self.base.comp.gpa;
     const sep = fs.path.sep_str;
     const target = self.base.comp.root_mod.resolved_target.result;
     test_path.clearRetainingCapacity();
 @@ -2021,7 +2046,7 @@ fn accessLibPath(
         suffix,
     });
     if (checked_paths) |cpaths| {
-        try cpaths.append(try self.base.allocator.dupe(u8, test_path.items));
+        try cpaths.append(try gpa.dupe(u8, test_path.items));
     }
     fs.cwd().access(test_path.items, .{}) catch |err| switch (err) {
         error.FileNotFound => return false,
 @@ -2150,7 +2175,7 @@ fn markImportsExports(self: *Elf) void {
                 }
                 if (file_ptr.index() == file_index) {
                     global.flags.@"export" = true;
-                    if (elf_file.isDynLib() and vis != .PROTECTED) {
+                    if (elf_file.base.isDynLib() and vis != .PROTECTED) {
                         global.flags.import = true;
                     }
                 }
 @@ -2158,7 +2183,7 @@ fn markImportsExports(self: *Elf) void {
         }
     }.mark;
-    if (!self.isDynLib()) {
+    if (!self.base.isDynLib()) {
         for (self.shared_objects.items) |index| {
             for (self.file(index).?.globals()) |global_index| {
                 const global = self.symbol(global_index);
 @@ -2274,12 +2299,13 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
     const tracy = trace(@src());
     defer tracy.end();
-    var arena_allocator = std.heap.ArenaAllocator.init(self.base.allocator);
+    const gpa = self.base.comp.gpa;
+    var arena_allocator = std.heap.ArenaAllocator.init(gpa);
     defer arena_allocator.deinit();
     const arena = arena_allocator.allocator();
-    const directory = self.base.options.emit.?.directory; // Just an alias to make it shorter to type.
+    const directory = self.base.emit.directory; // Just an alias to make it shorter to type.
-    const full_out_path = try directory.join(arena, &[_][]const u8{self.base.options.emit.?.sub_path});
+    const full_out_path = try directory.join(arena, &[_][]const u8{self.base.emit.sub_path});
     // 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.
 @@ -2298,16 +2324,15 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
     sub_prog_node.context.refresh();
     defer sub_prog_node.end();
-    const is_obj = self.base.options.output_mode == .Obj;
+    const output_mode = self.base.comp.config.output_mode;
-    const is_lib = self.base.options.output_mode == .Lib;
+    const is_obj = output_mode == .Obj;
-    const is_dyn_lib = self.base.options.link_mode == .Dynamic and is_lib;
+    const is_lib = output_mode == .Lib;
-    const is_exe_or_dyn_lib = is_dyn_lib or self.base.options.output_mode == .Exe;
+    const link_mode = self.base.comp.config.link_mode;
+    const is_dyn_lib = link_mode == .Dynamic and is_lib;
+    const is_exe_or_dyn_lib = is_dyn_lib or output_mode == .Exe;
     const have_dynamic_linker = self.base.options.link_libc and
-        self.base.options.link_mode == .Dynamic and is_exe_or_dyn_lib;
+        link_mode == .Dynamic and is_exe_or_dyn_lib;
     const target = self.base.comp.root_mod.resolved_target.result;
-    const gc_sections = self.base.options.gc_sections orelse !is_obj;
-    const stack_size = self.base.options.stack_size_override orelse 16777216;
-    const allow_shlib_undefined = self.base.options.allow_shlib_undefined orelse !self.base.options.is_native_os;
     const compiler_rt_path: ?[]const u8 = blk: {
         if (comp.compiler_rt_lib) |x| break :blk x.full_object_path;
         if (comp.compiler_rt_obj) |x| break :blk x.full_object_path;
 @@ -2354,7 +2379,7 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
         // installation sources because they are always a product of the compiler version + target information.
         man.hash.addOptionalBytes(self.base.options.entry);
         man.hash.addOptional(self.base.options.image_base_override);
-        man.hash.add(gc_sections);
+        man.hash.add(self.base.gc_sections);
         man.hash.addOptional(self.base.options.sort_section);
         man.hash.add(self.base.options.eh_frame_hdr);
         man.hash.add(self.base.options.emit_relocs);
 @@ -2362,9 +2387,9 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
         man.hash.addListOfBytes(self.base.options.lib_dirs);
         man.hash.addListOfBytes(self.base.options.rpath_list);
         man.hash.add(self.base.options.each_lib_rpath);
-        if (self.base.options.output_mode == .Exe) {
+        if (output_mode == .Exe) {
-            man.hash.add(stack_size);
+            man.hash.add(self.base.stack_size);
-            man.hash.add(self.base.options.build_id);
+            man.hash.add(self.base.build_id);
         }
         man.hash.addListOfBytes(self.base.options.symbol_wrap_set.keys());
         man.hash.add(self.base.options.skip_linker_dependencies);
 @@ -2390,9 +2415,9 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
         }
         man.hash.addOptionalBytes(self.base.options.soname);
         man.hash.addOptional(self.base.options.version);
-        try link.hashAddSystemLibs(&man, self.base.options.system_libs);
+        try link.hashAddSystemLibs(&man, self.base.comp.system_libs);
         man.hash.addListOfBytes(self.base.options.force_undefined_symbols.keys());
-        man.hash.add(allow_shlib_undefined);
+        man.hash.add(self.base.allow_shlib_undefined);
         man.hash.add(self.base.options.bind_global_refs_locally);
         man.hash.add(self.base.options.compress_debug_sections);
         man.hash.add(self.base.options.tsan);
 @@ -2432,7 +2457,7 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
     // copy when generating relocatables. Normally, we would expect `lld -r` to work.
     // However, because LLD wants to resolve BPF relocations which it shouldn't, it fails
     // before even generating the relocatable.
-    if (self.base.options.output_mode == .Obj and
+    if (output_mode == .Obj and
         (self.base.options.lto or target.isBpfFreestanding()))
     {
         // In this case we must do a simple file copy
 @@ -2459,7 +2484,7 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
         }
     } else {
         // Create an LLD command line and invoke it.
-        var argv = std.ArrayList([]const u8).init(self.base.allocator);
+        var argv = std.ArrayList([]const u8).init(gpa);
         defer argv.deinit();
         // We will invoke ourselves as a child process to gain access to LLD.
         // This is necessary because LLD does not behave properly as a library -
 @@ -2503,15 +2528,17 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
             .both => {}, // this is the default
         }
-        if (self.base.options.output_mode == .Exe) {
+        if (output_mode == .Exe) {
-            try argv.append("-z");
+            try argv.appendSlice(&.{
-            try argv.append(try std.fmt.allocPrint(arena, "stack-size={d}", .{stack_size}));
+                "-z",
+                try std.fmt.allocPrint(arena, "stack-size={d}", .{self.base.stack_size}),
+            });
-            switch (self.base.options.build_id) {
+            switch (self.base.build_id) {
                 .none => {},
                 .fast, .uuid, .sha1, .md5 => {
                     try argv.append(try std.fmt.allocPrint(arena, "--build-id={s}", .{
-                        @tagName(self.base.options.build_id),
+                        @tagName(self.base.build_id),
                     }));
                 },
                 .hexstring => |hs| {
 @@ -2536,7 +2563,7 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
             try argv.append(arg);
         }
-        if (gc_sections) {
+        if (self.base.gc_sections) {
             try argv.append("--gc-sections");
         }
 @@ -2615,7 +2642,7 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
             try argv.append(arg);
         }
-        if (self.base.options.link_mode == .Static) {
+        if (link_mode == .Static) {
             if (target.cpu.arch.isArmOrThumb()) {
                 try argv.append("-Bstatic");
             } else {
 @@ -2625,7 +2652,7 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
             try argv.append("-shared");
         }
-        if (self.base.options.pie and self.base.options.output_mode == .Exe) {
+        if (self.base.options.pie and output_mode == .Exe) {
             try argv.append("-pie");
         }
 @@ -2648,7 +2675,7 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
         if (csu.crtbegin) |v| try argv.append(v);
         // rpaths
-        var rpath_table = std.StringHashMap(void).init(self.base.allocator);
+        var rpath_table = std.StringHashMap(void).init(gpa);
         defer rpath_table.deinit();
         for (self.base.options.rpath_list) |rpath| {
             if ((try rpath_table.fetchPut(rpath, {})) == null) {
 @@ -2664,7 +2691,7 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
         if (self.base.options.each_lib_rpath) {
             var test_path = std.ArrayList(u8).init(arena);
             for (self.base.options.lib_dirs) |lib_dir_path| {
-                for (self.base.options.system_libs.keys()) |link_lib| {
+                for (self.base.comp.system_libs.keys()) |link_lib| {
                     if (!(try self.accessLibPath(&test_path, null, lib_dir_path, link_lib, .Dynamic)))
                         continue;
                     if ((try rpath_table.fetchPut(lib_dir_path, {})) == null) {
 @@ -2763,8 +2790,8 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
         // Shared libraries.
         if (is_exe_or_dyn_lib) {
-            const system_libs = self.base.options.system_libs.keys();
+            const system_libs = self.base.comp.system_libs.keys();
-            const system_libs_values = self.base.options.system_libs.values();
+            const system_libs_values = self.base.comp.system_libs.values();
             // Worst-case, we need an --as-needed argument for every lib, as well
             // as one before and one after.
 @@ -2813,7 +2840,7 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
             self.error_flags.missing_libc = false;
             if (self.base.options.link_libc) {
                 if (self.base.options.libc_installation != null) {
-                    const needs_grouping = self.base.options.link_mode == .Static;
+                    const needs_grouping = link_mode == .Static;
                     if (needs_grouping) try argv.append("--start-group");
                     try argv.appendSlice(target_util.libcFullLinkFlags(target));
                     if (needs_grouping) try argv.append("--end-group");
 @@ -2826,7 +2853,7 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
                     }
                     try argv.append(try comp.get_libc_crt_file(arena, "libc_nonshared.a"));
                 } else if (target.isMusl()) {
-                    try argv.append(try comp.get_libc_crt_file(arena, switch (self.base.options.link_mode) {
+                    try argv.append(try comp.get_libc_crt_file(arena, switch (link_mode) {
                         .Static => "libc.a",
                         .Dynamic => "libc.so",
                     }));
 @@ -2847,7 +2874,7 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
         if (csu.crtend) |v| try argv.append(v);
         if (csu.crtn) |v| try argv.append(v);
-        if (allow_shlib_undefined) {
+        if (self.base.allow_shlib_undefined) {
             try argv.append("--allow-shlib-undefined");
         }
 @@ -2861,7 +2888,7 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
             try argv.append("-Bsymbolic");
         }
-        if (self.base.options.verbose_link) {
+        if (self.base.comp.verbose_link) {
             // Skip over our own name so that the LLD linker name is the first argv item.
             Compilation.dump_argv(argv.items[1..]);
         }
 @@ -3087,10 +3114,12 @@ fn writeElfHeader(self: *Elf) !void {
     assert(index == 16);
-    const elf_type: elf.ET = switch (self.base.options.output_mode) {
+    const output_mode = self.base.comp.config.output_mode;
+    const link_mode = self.base.comp.config.link_mode;
+    const elf_type: elf.ET = switch (output_mode) {
         .Exe => if (self.base.options.pie) .DYN else .EXEC,
         .Obj => .REL,
-        .Lib => switch (self.base.options.link_mode) {
+        .Lib => switch (link_mode) {
             .Static => @as(elf.ET, .REL),
             .Dynamic => .DYN,
         },
 @@ -3216,7 +3245,6 @@ pub fn updateExports(
         @panic("Attempted to compile for object format that was disabled by build configuration");
     }
     if (self.llvm_object) |llvm_object| return llvm_object.updateExports(mod, exported, exports);
-    if (self.base.options.emit == null) return;
     return self.zigObjectPtr().?.updateExports(self, mod, exported, exports);
 }
 @@ -3280,6 +3308,8 @@ fn addLinkerDefinedSymbols(self: *Elf) !void {
 }
 fn allocateLinkerDefinedSymbols(self: *Elf) void {
+    const link_mode = self.base.comp.config.link_mode;
     // _DYNAMIC
     if (self.dynamic_section_index) |shndx| {
         const shdr = &self.shdrs.items[shndx];
 @@ -3362,7 +3392,7 @@ fn allocateLinkerDefinedSymbols(self: *Elf) void {
     // __rela_iplt_start, __rela_iplt_end
     if (self.rela_dyn_section_index) |shndx| blk: {
-        if (self.base.options.link_mode != .Static or self.base.options.pie) break :blk;
+        if (link_mode != .Static or self.base.options.pie) break :blk;
         const shdr = &self.shdrs.items[shndx];
         const end_addr = shdr.sh_addr + shdr.sh_size;
         const start_addr = end_addr - self.calcNumIRelativeRelocs() * @sizeOf(elf.Elf64_Rela);
 @@ -3531,7 +3561,7 @@ fn initSyntheticSections(self: *Elf) !void {
         });
     }
-    if (self.isDynLib() or self.shared_objects.items.len > 0 or self.base.options.pie) {
+    if (self.base.isDynLib() or self.shared_objects.items.len > 0 or self.base.options.pie) {
         self.dynstrtab_section_index = try self.addSection(.{
             .name = ".dynstr",
             .flags = elf.SHF_ALLOC,
 @@ -3716,7 +3746,7 @@ fn initSpecialPhdrs(self: *Elf) !void {
     self.phdr_gnu_stack_index = try self.addPhdr(.{
         .type = elf.PT_GNU_STACK,
         .flags = elf.PF_W | elf.PF_R,
-        .memsz = self.base.options.stack_size_override orelse 0,
+        .memsz = self.base.stack_size,
         .@"align" = 1,
     });
 @@ -3822,7 +3852,7 @@ fn setDynamicSection(self: *Elf, rpaths: []const []const u8) !void {
         try self.dynamic.addNeeded(shared_object, self);
     }
-    if (self.isDynLib()) {
+    if (self.base.isDynLib()) {
         if (self.base.options.soname) |soname| {
             try self.dynamic.setSoname(soname, self);
         }
 @@ -3837,8 +3867,9 @@ fn sortDynamicSymtab(self: *Elf) void {
 }
 fn setVersionSymtab(self: *Elf) !void {
+    const gpa = self.base.comp.gpa;
     if (self.versym_section_index == null) return;
-    try self.versym.resize(self.base.allocator, self.dynsym.count());
+    try self.versym.resize(gpa, self.dynsym.count());
     self.versym.items[0] = elf.VER_NDX_LOCAL;
     for (self.dynsym.entries.items, 1..) |entry, i| {
         const sym = self.symbol(entry.symbol_index);
 @@ -5597,38 +5628,14 @@ const CsuObjects = struct {
 };
 pub fn calcImageBase(self: Elf) u64 {
-    if (self.isDynLib()) return 0;
+    if (self.base.isDynLib()) return 0;
-    if (self.isExe() and self.base.options.pie) return 0;
+    if (self.base.isExe() and self.base.options.pie) return 0;
     return self.base.options.image_base_override orelse switch (self.ptr_width) {
         .p32 => 0x1000,
         .p64 => 0x1000000,
     };
 }
-pub fn isStatic(self: Elf) bool {
-    return self.base.options.link_mode == .Static;
-}
-pub fn isObject(self: Elf) bool {
-    return self.base.options.output_mode == .Obj;
-}
-pub fn isExe(self: Elf) bool {
-    return self.base.options.output_mode == .Exe;
-}
-pub fn isStaticLib(self: Elf) bool {
-    return self.base.options.output_mode == .Lib and self.isStatic();
-}
-pub fn isRelocatable(self: Elf) bool {
-    return self.isObject() or self.isStaticLib();
-}
-pub fn isDynLib(self: Elf) bool {
-    return self.base.options.output_mode == .Lib and !self.isStatic();
-}
 pub fn isZigSection(self: Elf, shndx: u16) bool {
     inline for (&[_]?u16{
         self.zig_text_section_index,
 @@ -5668,8 +5675,9 @@ fn addPhdr(self: *Elf, opts: struct {
     filesz: u64 = 0,
     memsz: u64 = 0,
 }) error{OutOfMemory}!u16 {
+    const gpa = self.base.comp.gpa;
     const index = @as(u16, @intCast(self.phdrs.items.len));
-    try self.phdrs.append(self.base.allocator, .{
+    try self.phdrs.append(gpa, .{
         .p_type = opts.type,
         .p_flags = opts.flags,
         .p_offset = opts.offset,
 @@ -5818,8 +5826,9 @@ pub fn atom(self: *Elf, atom_index: Atom.Index) ?*Atom {
 }
 pub fn addAtom(self: *Elf) !Atom.Index {
+    const gpa = self.base.comp.gpa;
     const index = @as(Atom.Index, @intCast(self.atoms.items.len));
-    const atom_ptr = try self.atoms.addOne(self.base.allocator);
+    const atom_ptr = try self.atoms.addOne(gpa);
     atom_ptr.* = .{ .atom_index = index };
     return index;
 }
 @@ -5841,7 +5850,8 @@ pub fn symbol(self: *Elf, sym_index: Symbol.Index) *Symbol {
 }
 pub fn addSymbol(self: *Elf) !Symbol.Index {
-    try self.symbols.ensureUnusedCapacity(self.base.allocator, 1);
+    const gpa = self.base.comp.gpa;
+    try self.symbols.ensureUnusedCapacity(gpa, 1);
     const index = blk: {
         if (self.symbols_free_list.popOrNull()) |index| {
             log.debug("  (reusing symbol index {d})", .{index});
 @@ -5858,8 +5868,9 @@ pub fn addSymbol(self: *Elf) !Symbol.Index {
 }
 pub fn addSymbolExtra(self: *Elf, extra: Symbol.Extra) !u32 {
+    const gpa = self.base.comp.gpa;
     const fields = @typeInfo(Symbol.Extra).Struct.fields;
-    try self.symbols_extra.ensureUnusedCapacity(self.base.allocator, fields.len);
+    try self.symbols_extra.ensureUnusedCapacity(gpa, fields.len);
     return self.addSymbolExtraAssumeCapacity(extra);
 }
 @@ -5959,8 +5970,9 @@ pub fn getOrCreateComdatGroupOwner(self: *Elf, name: [:0]const u8) !GetOrCreateC
 }
 pub fn addComdatGroup(self: *Elf) !ComdatGroup.Index {
+    const gpa = self.base.comp.gpa;
     const index = @as(ComdatGroup.Index, @intCast(self.comdat_groups.items.len));
-    _ = try self.comdat_groups.addOne(self.base.allocator);
+    _ = try self.comdat_groups.addOne(gpa);
     return index;
 }
 @@ -6023,14 +6035,16 @@ const ErrorWithNotes = struct {
 };
 pub fn addErrorWithNotes(self: *Elf, note_count: usize) error{OutOfMemory}!ErrorWithNotes {
-    try self.misc_errors.ensureUnusedCapacity(self.base.allocator, 1);
+    const gpa = self.base.comp.gpa;
+    try self.misc_errors.ensureUnusedCapacity(gpa, 1);
     return self.addErrorWithNotesAssumeCapacity(note_count);
 }
 fn addErrorWithNotesAssumeCapacity(self: *Elf, note_count: usize) error{OutOfMemory}!ErrorWithNotes {
+    const gpa = self.base.comp.gpa;
     const index = self.misc_errors.items.len;
     const err = self.misc_errors.addOneAssumeCapacity();
-    err.* = .{ .msg = undefined, .notes = try self.base.allocator.alloc(link.File.ErrorMsg, note_count) };
+    err.* = .{ .msg = undefined, .notes = try gpa.alloc(link.File.ErrorMsg, note_count) };
     return .{ .index = index };
 }
 @@ -6040,9 +6054,10 @@ pub fn getShString(self: Elf, off: u32) [:0]const u8 {
 }
 pub fn insertShString(self: *Elf, name: [:0]const u8) error{OutOfMemory}!u32 {
+    const gpa = self.base.comp.gpa;
     const off = @as(u32, @intCast(self.shstrtab.items.len));
-    try self.shstrtab.ensureUnusedCapacity(self.base.allocator, name.len + 1);
+    try self.shstrtab.ensureUnusedCapacity(gpa, name.len + 1);
-    self.shstrtab.writer(self.base.allocator).print("{s}\x00", .{name}) catch unreachable;
+    self.shstrtab.writer(gpa).print("{s}\x00", .{name}) catch unreachable;
     return off;
 }
 @@ -6052,9 +6067,10 @@ pub fn getDynString(self: Elf, off: u32) [:0]const u8 {
 }
 pub fn insertDynString(self: *Elf, name: []const u8) error{OutOfMemory}!u32 {
+    const gpa = self.base.comp.gpa;
     const off = @as(u32, @intCast(self.dynstrtab.items.len));
-    try self.dynstrtab.ensureUnusedCapacity(self.base.allocator, name.len + 1);
+    try self.dynstrtab.ensureUnusedCapacity(gpa, name.len + 1);
-    self.dynstrtab.writer(self.base.allocator).print("{s}\x00", .{name}) catch unreachable;
+    self.dynstrtab.writer(gpa).print("{s}\x00", .{name}) catch unreachable;
     return off;
 }

src/link/Elf/ZigObject.zig+56-45

...	@@ -76,7 +76,7 @@ pub const symbol_mask: u32 = 0x7fffffff;	...	@@ -76,7 +76,7 @@ pub const symbol_mask: u32 = 0x7fffffff;
76	pub const SHN_ATOM: u16 = 0x100;	76	pub const SHN_ATOM: u16 = 0x100;
77		77
78	pub fn init(self: ZigObject, elf_file: Elf) !void {	78	pub fn init(self: ZigObject, elf_file: Elf) !void {
79	const gpa = elf_file.base.allocator;	79	const gpa = elf_file.base.comp.gpa;
80		80
81	try self.atoms.append(gpa, 0); // null input section	81	try self.atoms.append(gpa, 0); // null input section
82	try self.relocs.append(gpa, .{}); // null relocs section	82	try self.relocs.append(gpa, .{}); // null relocs section
...	@@ -96,7 +96,7 @@ pub fn init(self: ZigObject, elf_file: Elf) !void {	...	@@ -96,7 +96,7 @@ pub fn init(self: ZigObject, elf_file: Elf) !void {
96	esym.st_shndx = elf.SHN_ABS;	96	esym.st_shndx = elf.SHN_ABS;
97	symbol_ptr.esym_index = esym_index;	97	symbol_ptr.esym_index = esym_index;
98		98
99	if (!elf_file.base.options.strip) {	99	if (elf_file.base.debug_format != .strip) {
100	self.dwarf = Dwarf.init(gpa, &elf_file.base, .dwarf32);	100	self.dwarf = Dwarf.init(gpa, &elf_file.base, .dwarf32);
101	}	101	}
102	}	102	}
...	@@ -155,13 +155,13 @@ pub fn deinit(self: *ZigObject, allocator: Allocator) void {	...	@@ -155,13 +155,13 @@ pub fn deinit(self: *ZigObject, allocator: Allocator) void {
155	pub fn flushModule(self: ZigObject, elf_file: Elf) !void {	155	pub fn flushModule(self: ZigObject, elf_file: Elf) !void {
156	// Handle any lazy symbols that were emitted by incremental compilation.	156	// Handle any lazy symbols that were emitted by incremental compilation.
157	if (self.lazy_syms.getPtr(.none)) \|metadata\| {	157	if (self.lazy_syms.getPtr(.none)) \|metadata\| {
158	const module = elf_file.base.options.module.?;	158	const zcu = elf_file.base.comp.module.?;
159		159
160	// Most lazy symbols can be updated on first use, but	160	// Most lazy symbols can be updated on first use, but
161	// anyerror needs to wait for everything to be flushed.	161	// anyerror needs to wait for everything to be flushed.
162	if (metadata.text_state != .unused) self.updateLazySymbol(	162	if (metadata.text_state != .unused) self.updateLazySymbol(
163	elf_file,	163	elf_file,
164	link.File.LazySymbol.initDecl(.code, null, module),	164	link.File.LazySymbol.initDecl(.code, null, zcu),
165	metadata.text_symbol_index,	165	metadata.text_symbol_index,
166	) catch \|err\| return switch (err) {	166	) catch \|err\| return switch (err) {
167	error.CodegenFail => error.FlushFailure,	167	error.CodegenFail => error.FlushFailure,
...	@@ -169,7 +169,7 @@ pub fn flushModule(self: ZigObject, elf_file: Elf) !void {	...	@@ -169,7 +169,7 @@ pub fn flushModule(self: ZigObject, elf_file: Elf) !void {
169	};	169	};
170	if (metadata.rodata_state != .unused) self.updateLazySymbol(	170	if (metadata.rodata_state != .unused) self.updateLazySymbol(
171	elf_file,	171	elf_file,
172	link.File.LazySymbol.initDecl(.const_data, null, module),	172	link.File.LazySymbol.initDecl(.const_data, null, zcu),
173	metadata.rodata_symbol_index,	173	metadata.rodata_symbol_index,
174	) catch \|err\| return switch (err) {	174	) catch \|err\| return switch (err) {
175	error.CodegenFail => error.FlushFailure,	175	error.CodegenFail => error.FlushFailure,
...	@@ -182,7 +182,8 @@ pub fn flushModule(self: ZigObject, elf_file: Elf) !void {	...	@@ -182,7 +182,8 @@ pub fn flushModule(self: ZigObject, elf_file: Elf) !void {
182	}	182	}
183		183
184	if (self.dwarf) \|*dw\| {	184	if (self.dwarf) \|*dw\| {
185	try dw.flushModule(elf_file.base.options.module.?);	185	const zcu = elf_file.base.comp.module.?;
		186	try dw.flushModule(zcu);
186		187
187	// TODO I need to re-think how to handle ZigObject's debug sections AND debug sections	188	// TODO I need to re-think how to handle ZigObject's debug sections AND debug sections
188	// extracted from input object files correctly.	189	// extracted from input object files correctly.
...	@@ -195,7 +196,7 @@ pub fn flushModule(self: ZigObject, elf_file: Elf) !void {	...	@@ -195,7 +196,7 @@ pub fn flushModule(self: ZigObject, elf_file: Elf) !void {
195	const text_shdr = elf_file.shdrs.items[elf_file.zig_text_section_index.?];	196	const text_shdr = elf_file.shdrs.items[elf_file.zig_text_section_index.?];
196	const low_pc = text_shdr.sh_addr;	197	const low_pc = text_shdr.sh_addr;
197	const high_pc = text_shdr.sh_addr + text_shdr.sh_size;	198	const high_pc = text_shdr.sh_addr + text_shdr.sh_size;
198	try dw.writeDbgInfoHeader(elf_file.base.options.module.?, low_pc, high_pc);	199	try dw.writeDbgInfoHeader(zcu, low_pc, high_pc);
199	self.debug_info_header_dirty = false;	200	self.debug_info_header_dirty = false;
200	}	201	}
201		202
...	@@ -268,7 +269,7 @@ pub fn addGlobalEsym(self: *ZigObject, allocator: Allocator) !Symbol.Index {	...	@@ -268,7 +269,7 @@ pub fn addGlobalEsym(self: *ZigObject, allocator: Allocator) !Symbol.Index {
268	}	269	}
269		270
270	pub fn addAtom(self: ZigObject, elf_file: Elf) !Symbol.Index {	271	pub fn addAtom(self: ZigObject, elf_file: Elf) !Symbol.Index {
271	const gpa = elf_file.base.allocator;	272	const gpa = elf_file.base.comp.gpa;
272	const atom_index = try elf_file.addAtom();	273	const atom_index = try elf_file.addAtom();
273	const symbol_index = try elf_file.addSymbol();	274	const symbol_index = try elf_file.addSymbol();
274	const esym_index = try self.addLocalEsym(gpa);	275	const esym_index = try self.addLocalEsym(gpa);
...	@@ -411,6 +412,7 @@ pub fn allocateTlvAtoms(self: ZigObject, elf_file: *Elf) void {	...	@@ -411,6 +412,7 @@ pub fn allocateTlvAtoms(self: ZigObject, elf_file: *Elf) void {
411	}	412	}
412		413
413	pub fn scanRelocs(self: ZigObject, elf_file: Elf, undefs: anytype) !void {	414	pub fn scanRelocs(self: ZigObject, elf_file: Elf, undefs: anytype) !void {
		415	const gpa = elf_file.base.comp.gpa;
414	for (self.atoms.items) \|atom_index\| {	416	for (self.atoms.items) \|atom_index\| {
415	const atom = elf_file.atom(atom_index) orelse continue;	417	const atom = elf_file.atom(atom_index) orelse continue;
416	if (!atom.flags.alive) continue;	418	if (!atom.flags.alive) continue;
...	@@ -421,7 +423,7 @@ pub fn scanRelocs(self: ZigObject, elf_file: Elf, undefs: anytype) !void {	...	@@ -421,7 +423,7 @@ pub fn scanRelocs(self: ZigObject, elf_file: Elf, undefs: anytype) !void {
421	// Perhaps it would make sense to save the code until flushModule where we	423	// Perhaps it would make sense to save the code until flushModule where we
422	// would free all of generated code?	424	// would free all of generated code?
423	const code = try self.codeAlloc(elf_file, atom_index);	425	const code = try self.codeAlloc(elf_file, atom_index);
424	defer elf_file.base.allocator.free(code);	426	defer gpa.free(code);
425	try atom.scanRelocs(elf_file, code, undefs);	427	try atom.scanRelocs(elf_file, code, undefs);
426	} else try atom.scanRelocs(elf_file, null, undefs);	428	} else try atom.scanRelocs(elf_file, null, undefs);
427	}	429	}
...	@@ -447,7 +449,7 @@ pub fn markLive(self: ZigObject, elf_file: Elf) void {	...	@@ -447,7 +449,7 @@ pub fn markLive(self: ZigObject, elf_file: Elf) void {
447	/// We need this so that we can write to an archive.	449	/// We need this so that we can write to an archive.
448	/// TODO implement writing ZigObject data directly to a buffer instead.	450	/// TODO implement writing ZigObject data directly to a buffer instead.
449	pub fn readFileContents(self: ZigObject, elf_file: Elf) !void {	451	pub fn readFileContents(self: ZigObject, elf_file: Elf) !void {
450	const gpa = elf_file.base.allocator;	452	const gpa = elf_file.base.comp.gpa;
451	const shsize: u64 = switch (elf_file.ptr_width) {	453	const shsize: u64 = switch (elf_file.ptr_width) {
452	.p32 => @sizeOf(elf.Elf32_Shdr),	454	.p32 => @sizeOf(elf.Elf32_Shdr),
453	.p64 => @sizeOf(elf.Elf64_Shdr),	455	.p64 => @sizeOf(elf.Elf64_Shdr),
...	@@ -465,7 +467,7 @@ pub fn readFileContents(self: ZigObject, elf_file: Elf) !void {	...	@@ -465,7 +467,7 @@ pub fn readFileContents(self: ZigObject, elf_file: Elf) !void {
465	}	467	}
466		468
467	pub fn updateArSymtab(self: ZigObject, ar_symtab: Archive.ArSymtab, elf_file: Elf) error{OutOfMemory}!void {	469	pub fn updateArSymtab(self: ZigObject, ar_symtab: Archive.ArSymtab, elf_file: Elf) error{OutOfMemory}!void {
468	const gpa = elf_file.base.allocator;	470	const gpa = elf_file.base.comp.gpa;
469		471
470	try ar_symtab.symtab.ensureUnusedCapacity(gpa, self.globals().len);	472	try ar_symtab.symtab.ensureUnusedCapacity(gpa, self.globals().len);
471		473
...	@@ -508,7 +510,7 @@ pub fn addAtomsToRelaSections(self: ZigObject, elf_file: *Elf) !void {	...	@@ -508,7 +510,7 @@ pub fn addAtomsToRelaSections(self: ZigObject, elf_file: *Elf) !void {
508	const out_shdr = elf_file.shdrs.items[out_shndx];	510	const out_shdr = elf_file.shdrs.items[out_shndx];
509	if (out_shdr.sh_type == elf.SHT_NOBITS) continue;	511	if (out_shdr.sh_type == elf.SHT_NOBITS) continue;
510		512
511	const gpa = elf_file.base.allocator;	513	const gpa = elf_file.base.comp.gpa;
512	const sec = elf_file.output_rela_sections.getPtr(out_shndx).?;	514	const sec = elf_file.output_rela_sections.getPtr(out_shndx).?;
513	try sec.atom_list.append(gpa, atom_index);	515	try sec.atom_list.append(gpa, atom_index);
514	}	516	}
...	@@ -602,7 +604,7 @@ pub fn asFile(self: *ZigObject) File {	...	@@ -602,7 +604,7 @@ pub fn asFile(self: *ZigObject) File {
602	/// Returns atom's code.	604	/// Returns atom's code.
603	/// Caller owns the memory.	605	/// Caller owns the memory.
604	pub fn codeAlloc(self: ZigObject, elf_file: *Elf, atom_index: Atom.Index) ![]u8 {	606	pub fn codeAlloc(self: ZigObject, elf_file: *Elf, atom_index: Atom.Index) ![]u8 {
605	const gpa = elf_file.base.allocator;	607	const gpa = elf_file.base.comp.gpa;
606	const atom = elf_file.atom(atom_index).?;	608	const atom = elf_file.atom(atom_index).?;
607	assert(atom.file_index == self.index);	609	assert(atom.file_index == self.index);
608	const shdr = &elf_file.shdrs.items[atom.outputShndx().?];	610	const shdr = &elf_file.shdrs.items[atom.outputShndx().?];
...	@@ -668,8 +670,8 @@ pub fn lowerAnonDecl(	...	@@ -668,8 +670,8 @@ pub fn lowerAnonDecl(
668	explicit_alignment: InternPool.Alignment,	670	explicit_alignment: InternPool.Alignment,
669	src_loc: Module.SrcLoc,	671	src_loc: Module.SrcLoc,
670	) !codegen.Result {	672	) !codegen.Result {
671	const gpa = elf_file.base.allocator;	673	const gpa = elf_file.base.comp.gpa;
672	const mod = elf_file.base.options.module.?;	674	const mod = elf_file.base.comp.module.?;
673	const ty = Type.fromInterned(mod.intern_pool.typeOf(decl_val));	675	const ty = Type.fromInterned(mod.intern_pool.typeOf(decl_val));
674	const decl_alignment = switch (explicit_alignment) {	676	const decl_alignment = switch (explicit_alignment) {
675	.none => ty.abiAlignment(mod),	677	.none => ty.abiAlignment(mod),
...	@@ -716,8 +718,8 @@ pub fn getOrCreateMetadataForLazySymbol(	...	@@ -716,8 +718,8 @@ pub fn getOrCreateMetadataForLazySymbol(
716	elf_file: *Elf,	718	elf_file: *Elf,
717	lazy_sym: link.File.LazySymbol,	719	lazy_sym: link.File.LazySymbol,
718	) !Symbol.Index {	720	) !Symbol.Index {
719	const gpa = elf_file.base.allocator;	721	const gpa = elf_file.base.comp.gpa;
720	const mod = elf_file.base.options.module.?;	722	const mod = elf_file.base.comp.module.?;
721	const gop = try self.lazy_syms.getOrPut(gpa, lazy_sym.getDecl(mod));	723	const gop = try self.lazy_syms.getOrPut(gpa, lazy_sym.getDecl(mod));
722	errdefer _ = if (!gop.found_existing) self.lazy_syms.pop();	724	errdefer _ = if (!gop.found_existing) self.lazy_syms.pop();
723	if (!gop.found_existing) gop.value_ptr.* = .{};	725	if (!gop.found_existing) gop.value_ptr.* = .{};
...	@@ -752,25 +754,28 @@ pub fn getOrCreateMetadataForLazySymbol(	...	@@ -752,25 +754,28 @@ pub fn getOrCreateMetadataForLazySymbol(
752	}	754	}
753		755
754	fn freeUnnamedConsts(self: ZigObject, elf_file: Elf, decl_index: InternPool.DeclIndex) void {	756	fn freeUnnamedConsts(self: ZigObject, elf_file: Elf, decl_index: InternPool.DeclIndex) void {
		757	const gpa = elf_file.base.comp.gpa;
755	const unnamed_consts = self.unnamed_consts.getPtr(decl_index) orelse return;	758	const unnamed_consts = self.unnamed_consts.getPtr(decl_index) orelse return;
756	for (unnamed_consts.items) \|sym_index\| {	759	for (unnamed_consts.items) \|sym_index\| {
757	self.freeDeclMetadata(elf_file, sym_index);	760	self.freeDeclMetadata(elf_file, sym_index);
758	}	761	}
759	unnamed_consts.clearAndFree(elf_file.base.allocator);	762	unnamed_consts.clearAndFree(gpa);
760	}	763	}
761		764
762	fn freeDeclMetadata(self: ZigObject, elf_file: Elf, sym_index: Symbol.Index) void {	765	fn freeDeclMetadata(self: ZigObject, elf_file: Elf, sym_index: Symbol.Index) void {
763	_ = self;	766	_ = self;
		767	const gpa = elf_file.base.comp.gpa;
764	const sym = elf_file.symbol(sym_index);	768	const sym = elf_file.symbol(sym_index);
765	sym.atom(elf_file).?.free(elf_file);	769	sym.atom(elf_file).?.free(elf_file);
766	log.debug("adding %{d} to local symbols free list", .{sym_index});	770	log.debug("adding %{d} to local symbols free list", .{sym_index});
767	elf_file.symbols_free_list.append(elf_file.base.allocator, sym_index) catch {};	771	elf_file.symbols_free_list.append(gpa, sym_index) catch {};
768	elf_file.symbols.items[sym_index] = .{};	772	elf_file.symbols.items[sym_index] = .{};
769	// TODO free GOT entry here	773	// TODO free GOT entry here
770	}	774	}
771		775
772	pub fn freeDecl(self: ZigObject, elf_file: Elf, decl_index: InternPool.DeclIndex) void {	776	pub fn freeDecl(self: ZigObject, elf_file: Elf, decl_index: InternPool.DeclIndex) void {
773	const mod = elf_file.base.options.module.?;	777	const gpa = elf_file.base.comp.gpa;
		778	const mod = elf_file.base.comp.module.?;
774	const decl = mod.declPtr(decl_index);	779	const decl = mod.declPtr(decl_index);
775		780
776	log.debug("freeDecl {*}", .{decl});	781	log.debug("freeDecl {*}", .{decl});
...	@@ -780,7 +785,7 @@ pub fn freeDecl(self: ZigObject, elf_file: Elf, decl_index: InternPool.DeclInd	...	@@ -780,7 +785,7 @@ pub fn freeDecl(self: ZigObject, elf_file: Elf, decl_index: InternPool.DeclInd
780	const sym_index = kv.value.symbol_index;	785	const sym_index = kv.value.symbol_index;
781	self.freeDeclMetadata(elf_file, sym_index);	786	self.freeDeclMetadata(elf_file, sym_index);
782	self.freeUnnamedConsts(elf_file, decl_index);	787	self.freeUnnamedConsts(elf_file, decl_index);
783	kv.value.exports.deinit(elf_file.base.allocator);	788	kv.value.exports.deinit(gpa);
784	}	789	}
785		790
786	if (self.dwarf) \|*dw\| {	791	if (self.dwarf) \|*dw\| {
...	@@ -793,15 +798,16 @@ pub fn getOrCreateMetadataForDecl(	...	@@ -793,15 +798,16 @@ pub fn getOrCreateMetadataForDecl(
793	elf_file: *Elf,	798	elf_file: *Elf,
794	decl_index: InternPool.DeclIndex,	799	decl_index: InternPool.DeclIndex,
795	) !Symbol.Index {	800	) !Symbol.Index {
796	const gop = try self.decls.getOrPut(elf_file.base.allocator, decl_index);	801	const gpa = elf_file.base.comp.gpa;
		802	const gop = try self.decls.getOrPut(gpa, decl_index);
797	if (!gop.found_existing) {	803	if (!gop.found_existing) {
798	const single_threaded = elf_file.base.options.single_threaded;	804	const any_non_single_threaded = elf_file.base.comp.config.any_non_single_threaded;
799	const symbol_index = try self.addAtom(elf_file);	805	const symbol_index = try self.addAtom(elf_file);
800	const mod = elf_file.base.options.module.?;	806	const mod = elf_file.base.comp.module.?;
801	const decl = mod.declPtr(decl_index);	807	const decl = mod.declPtr(decl_index);
802	const sym = elf_file.symbol(symbol_index);	808	const sym = elf_file.symbol(symbol_index);
803	if (decl.getOwnedVariable(mod)) \|variable\| {	809	if (decl.getOwnedVariable(mod)) \|variable\| {
804	if (variable.is_threadlocal and !single_threaded) {	810	if (variable.is_threadlocal and any_non_single_threaded) {
805	sym.flags.is_tls = true;	811	sym.flags.is_tls = true;
806	}	812	}
807	}	813	}
...	@@ -820,13 +826,13 @@ fn getDeclShdrIndex(	...	@@ -820,13 +826,13 @@ fn getDeclShdrIndex(
820	code: []const u8,	826	code: []const u8,
821	) error{OutOfMemory}!u16 {	827	) error{OutOfMemory}!u16 {
822	_ = self;	828	_ = self;
823	const mod = elf_file.base.options.module.?;	829	const mod = elf_file.base.comp.module.?;
824	const single_threaded = elf_file.base.options.single_threaded;	830	const any_non_single_threaded = elf_file.base.comp.config.any_non_single_threaded;
825	const shdr_index = switch (decl.ty.zigTypeTag(mod)) {	831	const shdr_index = switch (decl.ty.zigTypeTag(mod)) {
826	.Fn => elf_file.zig_text_section_index.?,	832	.Fn => elf_file.zig_text_section_index.?,
827	else => blk: {	833	else => blk: {
828	if (decl.getOwnedVariable(mod)) \|variable\| {	834	if (decl.getOwnedVariable(mod)) \|variable\| {
829	if (variable.is_threadlocal and !single_threaded) {	835	if (variable.is_threadlocal and any_non_single_threaded) {
830	const is_all_zeroes = for (code) \|byte\| {	836	const is_all_zeroes = for (code) \|byte\| {
831	if (byte != 0) break false;	837	if (byte != 0) break false;
832	} else true;	838	} else true;
...	@@ -846,9 +852,12 @@ fn getDeclShdrIndex(	...	@@ -846,9 +852,12 @@ fn getDeclShdrIndex(
846	}	852	}
847	if (variable.is_const) break :blk elf_file.zig_data_rel_ro_section_index.?;	853	if (variable.is_const) break :blk elf_file.zig_data_rel_ro_section_index.?;
848	if (Value.fromInterned(variable.init).isUndefDeep(mod)) {	854	if (Value.fromInterned(variable.init).isUndefDeep(mod)) {
849	const mode = elf_file.base.options.optimize_mode;	855	// TODO: get the optimize_mode from the Module that owns the decl instead
850	if (mode == .Debug or mode == .ReleaseSafe) break :blk elf_file.zig_data_section_index.?;	856	// of using the root module here.
851	break :blk elf_file.zig_bss_section_index.?;	857	break :blk switch (elf_file.base.comp.root_mod.optimize_mode) {
		858	.Debug, .ReleaseSafe => elf_file.zig_data_section_index.?,
		859	.ReleaseFast, .ReleaseSmall => elf_file.zig_bss_section_index.?,
		860	};
852	}	861	}
853	// TODO I blatantly copied the logic from the Wasm linker, but is there a less	862	// TODO I blatantly copied the logic from the Wasm linker, but is there a less
854	// intrusive check for all zeroes than this?	863	// intrusive check for all zeroes than this?
...	@@ -873,8 +882,8 @@ fn updateDeclCode(	...	@@ -873,8 +882,8 @@ fn updateDeclCode(
873	code: []const u8,	882	code: []const u8,
874	stt_bits: u8,	883	stt_bits: u8,
875	) !void {	884	) !void {
876	const gpa = elf_file.base.allocator;	885	const gpa = elf_file.base.comp.gpa;
877	const mod = elf_file.base.options.module.?;	886	const mod = elf_file.base.comp.module.?;
878	const decl = mod.declPtr(decl_index);	887	const decl = mod.declPtr(decl_index);
879	const decl_name = mod.intern_pool.stringToSlice(try decl.getFullyQualifiedName(mod));	888	const decl_name = mod.intern_pool.stringToSlice(try decl.getFullyQualifiedName(mod));
880		889
...	@@ -971,8 +980,8 @@ fn updateTlv(	...	@@ -971,8 +980,8 @@ fn updateTlv(
971	shndx: u16,	980	shndx: u16,
972	code: []const u8,	981	code: []const u8,
973	) !void {	982	) !void {
974	const gpa = elf_file.base.allocator;	983	const gpa = elf_file.base.comp.gpa;
975	const mod = elf_file.base.options.module.?;	984	const mod = elf_file.base.comp.module.?;
976	const decl = mod.declPtr(decl_index);	985	const decl = mod.declPtr(decl_index);
977	const decl_name = mod.intern_pool.stringToSlice(try decl.getFullyQualifiedName(mod));	986	const decl_name = mod.intern_pool.stringToSlice(try decl.getFullyQualifiedName(mod));
978		987
...	@@ -1026,6 +1035,7 @@ pub fn updateFunc(	...	@@ -1026,6 +1035,7 @@ pub fn updateFunc(
1026	const tracy = trace(@src());	1035	const tracy = trace(@src());
1027	defer tracy.end();	1036	defer tracy.end();
1028		1037
		1038	const gpa = elf_file.base.comp.gpa;
1029	const func = mod.funcInfo(func_index);	1039	const func = mod.funcInfo(func_index);
1030	const decl_index = func.owner_decl;	1040	const decl_index = func.owner_decl;
1031	const decl = mod.declPtr(decl_index);	1041	const decl = mod.declPtr(decl_index);
...	@@ -1034,7 +1044,7 @@ pub fn updateFunc(	...	@@ -1034,7 +1044,7 @@ pub fn updateFunc(
1034	self.freeUnnamedConsts(elf_file, decl_index);	1044	self.freeUnnamedConsts(elf_file, decl_index);
1035	elf_file.symbol(sym_index).atom(elf_file).?.freeRelocs(elf_file);	1045	elf_file.symbol(sym_index).atom(elf_file).?.freeRelocs(elf_file);
1036		1046
1037	var code_buffer = std.ArrayList(u8).init(elf_file.base.allocator);	1047	var code_buffer = std.ArrayList(u8).init(gpa);
1038	defer code_buffer.deinit();	1048	defer code_buffer.deinit();
1039		1049
1040	var decl_state: ?Dwarf.DeclState = if (self.dwarf) \|*dw\| try dw.initDeclState(mod, decl_index) else null;	1050	var decl_state: ?Dwarf.DeclState = if (self.dwarf) \|*dw\| try dw.initDeclState(mod, decl_index) else null;
...	@@ -1117,7 +1127,8 @@ pub fn updateDecl(	...	@@ -1117,7 +1127,8 @@ pub fn updateDecl(
1117	const sym_index = try self.getOrCreateMetadataForDecl(elf_file, decl_index);	1127	const sym_index = try self.getOrCreateMetadataForDecl(elf_file, decl_index);
1118	elf_file.symbol(sym_index).atom(elf_file).?.freeRelocs(elf_file);	1128	elf_file.symbol(sym_index).atom(elf_file).?.freeRelocs(elf_file);
1119		1129
1120	var code_buffer = std.ArrayList(u8).init(elf_file.base.allocator);	1130	const gpa = elf_file.base.comp.gpa;
		1131	var code_buffer = std.ArrayList(u8).init(gpa);
1121	defer code_buffer.deinit();	1132	defer code_buffer.deinit();
1122		1133
1123	var decl_state: ?Dwarf.DeclState = if (self.dwarf) \|*dw\| try dw.initDeclState(mod, decl_index) else null;	1134	var decl_state: ?Dwarf.DeclState = if (self.dwarf) \|*dw\| try dw.initDeclState(mod, decl_index) else null;
...	@@ -1179,8 +1190,8 @@ fn updateLazySymbol(	...	@@ -1179,8 +1190,8 @@ fn updateLazySymbol(
1179	sym: link.File.LazySymbol,	1190	sym: link.File.LazySymbol,
1180	symbol_index: Symbol.Index,	1191	symbol_index: Symbol.Index,
1181	) !void {	1192	) !void {
1182	const gpa = elf_file.base.allocator;	1193	const gpa = elf_file.base.comp.gpa;
1183	const mod = elf_file.base.options.module.?;	1194	const mod = elf_file.base.comp.module.?;
1184		1195
1185	var required_alignment: InternPool.Alignment = .none;	1196	var required_alignment: InternPool.Alignment = .none;
1186	var code_buffer = std.ArrayList(u8).init(gpa);	1197	var code_buffer = std.ArrayList(u8).init(gpa);
...	@@ -1261,8 +1272,8 @@ pub fn lowerUnnamedConst(	...	@@ -1261,8 +1272,8 @@ pub fn lowerUnnamedConst(
1261	typed_value: TypedValue,	1272	typed_value: TypedValue,
1262	decl_index: InternPool.DeclIndex,	1273	decl_index: InternPool.DeclIndex,
1263	) !u32 {	1274	) !u32 {
1264	const gpa = elf_file.base.allocator;	1275	const gpa = elf_file.base.comp.gpa;
1265	const mod = elf_file.base.options.module.?;	1276	const mod = elf_file.base.comp.module.?;
1266	const gop = try self.unnamed_consts.getOrPut(gpa, decl_index);	1277	const gop = try self.unnamed_consts.getOrPut(gpa, decl_index);
1267	if (!gop.found_existing) {	1278	if (!gop.found_existing) {
1268	gop.value_ptr.* = .{};	1279	gop.value_ptr.* = .{};
...	@@ -1308,7 +1319,7 @@ fn lowerConst(	...	@@ -1308,7 +1319,7 @@ fn lowerConst(
1308	output_section_index: u16,	1319	output_section_index: u16,
1309	src_loc: Module.SrcLoc,	1320	src_loc: Module.SrcLoc,
1310	) !LowerConstResult {	1321	) !LowerConstResult {
1311	const gpa = elf_file.base.allocator;	1322	const gpa = elf_file.base.comp.gpa;
1312		1323
1313	var code_buffer = std.ArrayList(u8).init(gpa);	1324	var code_buffer = std.ArrayList(u8).init(gpa);
1314	defer code_buffer.deinit();	1325	defer code_buffer.deinit();
...	@@ -1364,7 +1375,7 @@ pub fn updateExports(	...	@@ -1364,7 +1375,7 @@ pub fn updateExports(
1364	const tracy = trace(@src());	1375	const tracy = trace(@src());
1365	defer tracy.end();	1376	defer tracy.end();
1366		1377
1367	const gpa = elf_file.base.allocator;	1378	const gpa = elf_file.base.comp.gpa;
1368	const metadata = switch (exported) {	1379	const metadata = switch (exported) {
1369	.decl_index => \|decl_index\| blk: {	1380	.decl_index => \|decl_index\| blk: {
1370	_ = try self.getOrCreateMetadataForDecl(elf_file, decl_index);	1381	_ = try self.getOrCreateMetadataForDecl(elf_file, decl_index);
...	@@ -1467,7 +1478,7 @@ pub fn deleteDeclExport(	...	@@ -1467,7 +1478,7 @@ pub fn deleteDeclExport(
1467	name: InternPool.NullTerminatedString,	1478	name: InternPool.NullTerminatedString,
1468	) void {	1479	) void {
1469	const metadata = self.decls.getPtr(decl_index) orelse return;	1480	const metadata = self.decls.getPtr(decl_index) orelse return;
1470	const mod = elf_file.base.options.module.?;	1481	const mod = elf_file.base.comp.module.?;
1471	const exp_name = mod.intern_pool.stringToSlice(name);	1482	const exp_name = mod.intern_pool.stringToSlice(name);
1472	const esym_index = metadata.@"export"(self, exp_name) orelse return;	1483	const esym_index = metadata.@"export"(self, exp_name) orelse return;
1473	log.debug("deleting export '{s}'", .{exp_name});	1484	log.debug("deleting export '{s}'", .{exp_name});
...	@@ -1485,7 +1496,7 @@ pub fn deleteDeclExport(	...	@@ -1485,7 +1496,7 @@ pub fn deleteDeclExport(
1485		1496
1486	pub fn getGlobalSymbol(self: ZigObject, elf_file: Elf, name: []const u8, lib_name: ?[]const u8) !u32 {	1497	pub fn getGlobalSymbol(self: ZigObject, elf_file: Elf, name: []const u8, lib_name: ?[]const u8) !u32 {
1487	_ = lib_name;	1498	_ = lib_name;
1488	const gpa = elf_file.base.allocator;	1499	const gpa = elf_file.base.comp.gpa;
1489	const off = try self.strtab.insert(gpa, name);	1500	const off = try self.strtab.insert(gpa, name);
1490	const lookup_gop = try self.globals_lookup.getOrPut(gpa, off);	1501	const lookup_gop = try self.globals_lookup.getOrPut(gpa, off);
1491	if (!lookup_gop.found_existing) {	1502	if (!lookup_gop.found_existing) {

src/link/MachO.zig+94-51

 @@ -144,6 +144,35 @@ tlv_table: TlvSymbolTable = .{},
 hot_state: if (is_hot_update_compatible) HotUpdateState else struct {} = .{},
 darwin_sdk_layout: ?SdkLayout,
+/// Size of the __PAGEZERO segment.
+pagezero_vmsize: u64,
+/// Minimum space for future expansion of the load commands.
+headerpad_size: u32,
+/// Set enough space as if all paths were MATPATHLEN.
+headerpad_max_install_names: bool,
+/// Remove dylibs that are unreachable by the entry point or exported symbols.
+dead_strip_dylibs: bool,
+frameworks: []const Framework,
+/// Install name for the dylib.
+/// TODO: unify with soname
+install_name: ?[]const u8,
+/// Path to entitlements file.
+entitlements: ?[]const u8,
+/// When adding a new field, remember to update `hashAddFrameworks`.
+pub const Framework = struct {
+    needed: bool = false,
+    weak: bool = false,
+    path: []const u8,
+};
+pub fn hashAddFrameworks(man: *Cache.Manifest, hm: []const Framework) !void {
+    for (hm) |value| {
+        man.hash.add(value.needed);
+        man.hash.add(value.weak);
+        _ = try man.addFile(value.path, null);
+    }
+}
 /// The filesystem layout of darwin SDK elements.
 pub const SdkLayout = enum {
 @@ -156,12 +185,14 @@ pub const SdkLayout = enum {
 pub fn open(arena: Allocator, options: link.File.OpenOptions) !*MachO {
     if (build_options.only_c) unreachable;
     const target = options.comp.root_mod.resolved_target.result;
+    const use_lld = build_options.have_llvm and options.comp.config.use_lld;
+    const use_llvm = options.comp.config.use_llvm;
     assert(target.ofmt == .macho);
     const gpa = options.comp.gpa;
     const emit = options.emit;
     const mode: Mode = mode: {
-        if (options.use_llvm or options.module == null or options.cache_mode == .whole)
+        if (use_llvm or options.module == null or options.cache_mode == .whole)
             break :mode .zld;
         break :mode .incremental;
     };
 @@ -192,7 +223,11 @@ pub fn open(arena: Allocator, options: link.File.OpenOptions) !*MachO {
     const file = try emit.directory.handle.createFile(sub_path, .{
         .truncate = false,
         .read = true,
-        .mode = link.determineMode(options),
+        .mode = link.File.determineMode(
+            use_lld,
+            options.comp.config.output_mode,
+            options.comp.config.link_mode,
+        ),
     });
     self.base.file = file;
 @@ -242,21 +277,37 @@ pub fn open(arena: Allocator, options: link.File.OpenOptions) !*MachO {
 pub fn createEmpty(arena: Allocator, options: link.File.OpenOptions) !*MachO {
     const self = try arena.create(MachO);
+    const optimize_mode = options.comp.root_mod.optimize_mode;
+    const use_llvm = options.comp.config.use_llvm;
     self.* = .{
         .base = .{
             .tag = .macho,
             .comp = options.comp,
             .emit = options.emit,
+            .gc_sections = options.gc_sections orelse (optimize_mode != .Debug),
+            .stack_size = options.stack_size orelse 16777216,
+            .allow_shlib_undefined = options.allow_shlib_undefined orelse false,
             .file = null,
+            .disable_lld_caching = options.disable_lld_caching,
+            .build_id = options.build_id,
+            .rpath_list = options.rpath_list,
+            .force_undefined_symbols = options.force_undefined_symbols,
+            .debug_format = options.debug_format orelse .{ .dwarf = .@"32" },
+            .function_sections = options.function_sections,
+            .data_sections = options.data_sections,
         },
-        .mode = if (options.use_llvm or options.module == null or options.cache_mode == .whole)
+        .mode = if (use_llvm or options.module == null or options.cache_mode == .whole)
             .zld
         else
             .incremental,
+        .pagezero_vmsize = options.pagezero_size orelse default_pagezero_vmsize,
+        .headerpad_size = options.headerpad_size orelse default_headerpad_size,
+        .headerpad_max_install_names = options.headerpad_max_install_names,
+        .dead_strip_dylibs = options.dead_strip_dylibs,
     };
-    if (options.use_llvm and options.module != null) {
+    if (use_llvm and options.module != null) {
         self.llvm_object = try LlvmObject.create(arena, options);
     }
 @@ -267,8 +318,9 @@ pub fn createEmpty(arena: Allocator, options: link.File.OpenOptions) !*MachO {
 pub fn flush(self: *MachO, comp: *Compilation, prog_node: *std.Progress.Node) link.File.FlushError!void {
     const gpa = self.base.comp.gpa;
+    const output_mode = self.base.comp.config.output_mode;
-    if (self.base.options.output_mode == .Lib and self.base.options.link_mode == .Static) {
+    if (output_mode == .Lib and self.base.options.link_mode == .Static) {
         if (build_options.have_llvm) {
             return self.base.linkAsArchive(comp, prog_node);
         } else {
 @@ -303,6 +355,7 @@ pub fn flushModule(self: *MachO, comp: *Compilation, prog_node: *std.Progress.No
     sub_prog_node.activate();
     defer sub_prog_node.end();
+    const output_mode = self.base.comp.config.output_mode;
     const module = self.base.options.module orelse return error.LinkingWithoutZigSourceUnimplemented;
     if (self.lazy_syms.getPtr(.none)) |metadata| {
 @@ -335,7 +388,7 @@ pub fn flushModule(self: *MachO, comp: *Compilation, prog_node: *std.Progress.No
     }
     var libs = std.StringArrayHashMap(link.SystemLib).init(arena);
-    try self.resolveLibSystem(arena, comp, &.{}, &libs);
+    try self.resolveLibSystem(arena, comp, &libs);
     const id_symlink_basename = "link.id";
 @@ -446,7 +499,7 @@ pub fn flushModule(self: *MachO, comp: *Compilation, prog_node: *std.Progress.No
     try self.createDyldPrivateAtom();
     try self.writeStubHelperPreamble();
-    if (self.base.options.output_mode == .Exe and self.getEntryPoint() != null) {
+    if (output_mode == .Exe and self.getEntryPoint() != null) {
         const global = self.getEntryPoint().?;
         if (self.getSymbol(global).undf()) {
             // We do one additional check here in case the entry point was found in one of the dylibs.
 @@ -517,8 +570,8 @@ pub fn flushModule(self: *MachO, comp: *Compilation, prog_node: *std.Progress.No
         // The most important here is to have the correct vm and filesize of the __LINKEDIT segment
         // where the code signature goes into.
         var codesig = CodeSignature.init(getPageSize(self.base.options.target.cpu.arch));
-        codesig.code_directory.ident = self.base.options.emit.?.sub_path;
+        codesig.code_directory.ident = self.base.emit.sub_path;
-        if (self.base.options.entitlements) |path| {
+        if (self.entitlements) |path| {
             try codesig.addEntitlements(gpa, path);
         }
         try self.writeCodeSignaturePadding(&codesig);
 @@ -536,7 +589,7 @@ pub fn flushModule(self: *MachO, comp: *Compilation, prog_node: *std.Progress.No
     try lc_writer.writeStruct(self.dysymtab_cmd);
     try load_commands.writeDylinkerLC(lc_writer);
-    switch (self.base.options.output_mode) {
+    switch (output_mode) {
         .Exe => blk: {
             const seg_id = self.header_segment_cmd_index.?;
             const seg = self.segments.items[seg_id];
 @@ -552,7 +605,7 @@ pub fn flushModule(self: *MachO, comp: *Compilation, prog_node: *std.Progress.No
             try lc_writer.writeStruct(macho.entry_point_command{
                 .entryoff = @as(u32, @intCast(addr - seg.vmaddr)),
-                .stacksize = self.base.options.stack_size_override orelse 0,
+                .stacksize = self.base.stack_size,
             });
         },
         .Lib => if (self.base.options.link_mode == .Dynamic) {
 @@ -591,7 +644,7 @@ pub fn flushModule(self: *MachO, comp: *Compilation, prog_node: *std.Progress.No
     if (codesig) |*csig| {
         try self.writeCodeSignature(comp, csig); // code signing always comes last
-        const emit = self.base.options.emit.?;
+        const emit = self.base.emit;
         try invalidateKernelCache(emit.directory.handle, emit.sub_path);
     }
 @@ -642,34 +695,20 @@ pub fn resolveLibSystem(
     self: *MachO,
     arena: Allocator,
     comp: *Compilation,
-    search_dirs: []const []const u8,
     out_libs: anytype,
 ) !void {
-    const gpa = self.base.comp.gpa;
+    var test_path = std.ArrayList(u8).init(arena);
-    var tmp_arena_allocator = std.heap.ArenaAllocator.init(gpa);
+    var checked_paths = std.ArrayList([]const u8).init(arena);
-    defer tmp_arena_allocator.deinit();
-    const tmp_arena = tmp_arena_allocator.allocator();
-    var test_path = std.ArrayList(u8).init(tmp_arena);
-    var checked_paths = std.ArrayList([]const u8).init(tmp_arena);
     success: {
-        for (search_dirs) |dir| if (try accessLibPath(
-            tmp_arena,
-            &test_path,
-            &checked_paths,
-            dir,
-            "libSystem",
-        )) break :success;
         if (self.base.options.darwin_sdk_layout) |sdk_layout| switch (sdk_layout) {
             .sdk => {
-                const dir = try fs.path.join(tmp_arena, &[_][]const u8{ self.base.options.sysroot.?, "usr", "lib" });
+                const dir = try fs.path.join(arena, &[_][]const u8{ self.base.options.sysroot.?, "usr", "lib" });
-                if (try accessLibPath(tmp_arena, &test_path, &checked_paths, dir, "libSystem")) break :success;
+                if (try accessLibPath(arena, &test_path, &checked_paths, dir, "libSystem")) break :success;
             },
             .vendored => {
-                const dir = try comp.zig_lib_directory.join(tmp_arena, &[_][]const u8{ "libc", "darwin" });
+                const dir = try comp.zig_lib_directory.join(arena, &[_][]const u8{ "libc", "darwin" });
-                if (try accessLibPath(tmp_arena, &test_path, &checked_paths, dir, "libSystem")) break :success;
+                if (try accessLibPath(arena, &test_path, &checked_paths, dir, "libSystem")) break :success;
             },
         };
 @@ -1082,7 +1121,7 @@ fn addDylib(self: *MachO, dylib: Dylib, dylib_options: DylibOpts, ctx: *ParseErr
     try self.dylibs.append(gpa, dylib);
     const should_link_dylib_even_if_unreachable = blk: {
-        if (self.base.options.dead_strip_dylibs and !dylib_options.needed) break :blk false;
+        if (self.dead_strip_dylibs and !dylib_options.needed) break :blk false;
         break :blk !(dylib_options.dependent or self.referenced_dylibs.contains(gop.value_ptr.*));
     };
 @@ -1597,7 +1636,8 @@ fn createThreadLocalDescriptorAtom(self: *MachO, sym_name: []const u8, target: S
 }
 pub fn createMhExecuteHeaderSymbol(self: *MachO) !void {
-    if (self.base.options.output_mode != .Exe) return;
+    const output_mode = self.base.comp.config.output_mode;
+    if (output_mode != .Exe) return;
     const gpa = self.base.comp.gpa;
     const sym_index = try self.allocateSymbol();
 @@ -1647,10 +1687,11 @@ pub fn createDsoHandleSymbol(self: *MachO) !void {
 }
 pub fn resolveSymbols(self: *MachO) !void {
+    const output_mode = self.base.comp.config.output_mode;
     // We add the specified entrypoint as the first unresolved symbols so that
     // we search for it in libraries should there be no object files specified
     // on the linker line.
-    if (self.base.options.output_mode == .Exe) {
+    if (output_mode == .Exe) {
         const entry_name = self.base.options.entry orelse load_commands.default_entry_point;
         _ = try self.addUndefined(entry_name, .{});
     }
 @@ -1867,9 +1908,10 @@ fn resolveSymbolsInDylibs(self: *MachO) !void {
 }
 fn resolveSymbolsAtLoading(self: *MachO) !void {
-    const is_lib = self.base.options.output_mode == .Lib;
+    const output_mode = self.base.comp.config.output_mode;
+    const is_lib = output_mode == .Lib;
     const is_dyn_lib = self.base.options.link_mode == .Dynamic and is_lib;
-    const allow_undef = is_dyn_lib and (self.base.options.allow_shlib_undefined orelse false);
+    const allow_undef = is_dyn_lib and self.base.allow_shlib_undefined;
     var next_sym: usize = 0;
     while (next_sym < self.unresolved.count()) {
 @@ -2674,12 +2716,12 @@ fn getDeclOutputSection(self: *MachO, decl_index: InternPool.DeclIndex) u8 {
     const val = decl.val;
     const mod = self.base.options.module.?;
     const zig_ty = ty.zigTypeTag(mod);
-    const mode = self.base.options.optimize_mode;
+    const any_non_single_threaded = self.base.comp.config.any_non_single_threaded;
-    const single_threaded = self.base.options.single_threaded;
+    const optimize_mode = self.base.comp.root_mod.optimize_mode;
     const sect_id: u8 = blk: {
         // TODO finish and audit this function
         if (val.isUndefDeep(mod)) {
-            if (mode == .ReleaseFast or mode == .ReleaseSmall) {
+            if (optimize_mode == .ReleaseFast or optimize_mode == .ReleaseSmall) {
                 @panic("TODO __DATA,__bss");
             } else {
                 break :blk self.data_section_index.?;
 @@ -2687,7 +2729,7 @@ fn getDeclOutputSection(self: *MachO, decl_index: InternPool.DeclIndex) u8 {
         }
         if (val.getVariable(mod)) |variable| {
-            if (variable.is_threadlocal and !single_threaded) {
+            if (variable.is_threadlocal and any_non_single_threaded) {
                 break :blk self.thread_data_section_index.?;
             }
             break :blk self.data_section_index.?;
 @@ -2796,8 +2838,6 @@ pub fn updateExports(
     if (self.llvm_object) |llvm_object|
         return llvm_object.updateExports(mod, exported, exports);
-    if (self.base.options.emit == null) return;
     const tracy = trace(@src());
     defer tracy.end();
 @@ -3093,7 +3133,7 @@ fn populateMissingMetadata(self: *MachO) !void {
     if (self.header_segment_cmd_index == null) {
         // The first __TEXT segment is immovable and covers MachO header and load commands.
         self.header_segment_cmd_index = @as(u8, @intCast(self.segments.items.len));
-        const ideal_size = @max(self.base.options.headerpad_size orelse 0, default_headerpad_size);
+        const ideal_size = self.headerpad_size;
         const needed_size = mem.alignForward(u64, padToIdeal(ideal_size), getPageSize(cpu_arch));
         log.debug("found __TEXT segment (header-only) free space 0x{x} to 0x{x}", .{ 0, needed_size });
 @@ -3222,13 +3262,13 @@ fn populateMissingMetadata(self: *MachO) !void {
 }
 fn calcPagezeroSize(self: *MachO) u64 {
-    const pagezero_vmsize = self.base.options.pagezero_size orelse default_pagezero_vmsize;
+    const output_mode = self.base.comp.config.output_mode;
     const page_size = getPageSize(self.base.options.target.cpu.arch);
-    const aligned_pagezero_vmsize = mem.alignBackward(u64, pagezero_vmsize, page_size);
+    const aligned_pagezero_vmsize = mem.alignBackward(u64, self.pagezero_vmsize, page_size);
-    if (self.base.options.output_mode == .Lib) return 0;
+    if (output_mode == .Lib) return 0;
     if (aligned_pagezero_vmsize == 0) return 0;
-    if (aligned_pagezero_vmsize != pagezero_vmsize) {
+    if (aligned_pagezero_vmsize != self.pagezero_vmsize) {
-        log.warn("requested __PAGEZERO size (0x{x}) is not page aligned", .{pagezero_vmsize});
+        log.warn("requested __PAGEZERO size (0x{x}) is not page aligned", .{self.pagezero_vmsize});
         log.warn("  rounding down to 0x{x}", .{aligned_pagezero_vmsize});
     }
     return aligned_pagezero_vmsize;
 @@ -4685,6 +4725,7 @@ pub fn writeCodeSignaturePadding(self: *MachO, code_sig: *CodeSignature) !void {
 }
 pub fn writeCodeSignature(self: *MachO, comp: *const Compilation, code_sig: *CodeSignature) !void {
+    const output_mode = self.base.comp.config.output_mode;
     const seg_id = self.header_segment_cmd_index.?;
     const seg = self.segments.items[seg_id];
     const offset = self.codesig_cmd.dataoff;
 @@ -4698,7 +4739,7 @@ pub fn writeCodeSignature(self: *MachO, comp: *const Compilation, code_sig: *Cod
         .exec_seg_base = seg.fileoff,
         .exec_seg_limit = seg.filesize,
         .file_size = offset,
-        .output_mode = self.base.options.output_mode,
+        .output_mode = output_mode,
     }, buffer.writer());
     assert(buffer.items.len == code_sig.size());
 @@ -4712,6 +4753,8 @@ pub fn writeCodeSignature(self: *MachO, comp: *const Compilation, code_sig: *Cod
 /// Writes Mach-O file header.
 pub fn writeHeader(self: *MachO, ncmds: u32, sizeofcmds: u32) !void {
+    const output_mode = self.base.comp.config.output_mode;
     var header: macho.mach_header_64 = .{};
     header.flags = macho.MH_NOUNDEFS | macho.MH_DYLDLINK | macho.MH_PIE | macho.MH_TWOLEVEL;
 @@ -4727,7 +4770,7 @@ pub fn writeHeader(self: *MachO, ncmds: u32, sizeofcmds: u32) !void {
         else => unreachable,
     }
-    switch (self.base.options.output_mode) {
+    switch (output_mode) {
         .Exe => {
             header.filetype = macho.MH_EXECUTE;
         },

src/link/MachO/zld.zig+73-86

 @@ -6,20 +6,21 @@ pub fn linkWithZld(
     const tracy = trace(@src());
     defer tracy.end();
-    const gpa = macho_file.base.allocator;
+    const gpa = macho_file.base.comp.gpa;
-    const options = &macho_file.base.options;
+    const target = macho_file.base.comp.root_mod.resolved_target.result;
-    const target = options.target;
+    const emit = macho_file.base.emit;
     var arena_allocator = std.heap.ArenaAllocator.init(gpa);
     defer arena_allocator.deinit();
     const arena = arena_allocator.allocator();
-    const directory = options.emit.?.directory; // Just an alias to make it shorter to type.
+    const directory = emit.directory; // Just an alias to make it shorter to type.
-    const full_out_path = try directory.join(arena, &[_][]const u8{options.emit.?.sub_path});
+    const full_out_path = try directory.join(arena, &[_][]const u8{emit.?.sub_path});
+    const opt_zcu = macho_file.base.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.
-    const module_obj_path: ?[]const u8 = if (options.module != null) blk: {
+    const module_obj_path: ?[]const u8 = if (opt_zcu != null) blk: {
         try macho_file.flushModule(comp, prog_node);
         if (fs.path.dirname(full_out_path)) |dirname| {
 @@ -34,22 +35,24 @@ pub fn linkWithZld(
     sub_prog_node.context.refresh();
     defer sub_prog_node.end();
+    const output_mode = macho_file.base.comp.config.output_mode;
+    const link_mode = macho_file.base.comp.config.link_mode;
     const cpu_arch = target.cpu.arch;
-    const is_lib = options.output_mode == .Lib;
+    const is_lib = output_mode == .Lib;
-    const is_dyn_lib = options.link_mode == .Dynamic and is_lib;
+    const is_dyn_lib = link_mode == .Dynamic and is_lib;
-    const is_exe_or_dyn_lib = is_dyn_lib or options.output_mode == .Exe;
+    const is_exe_or_dyn_lib = is_dyn_lib or output_mode == .Exe;
-    const stack_size = options.stack_size_override orelse 0;
+    const stack_size = macho_file.base.stack_size;
-    const is_debug_build = options.optimize_mode == .Debug;
-    const gc_sections = options.gc_sections orelse !is_debug_build;
     const id_symlink_basename = "zld.id";
     var man: Cache.Manifest = undefined;
-    defer if (!options.disable_lld_caching) man.deinit();
+    defer if (!macho_file.base.disable_lld_caching) man.deinit();
     var digest: [Cache.hex_digest_len]u8 = undefined;
-    if (!options.disable_lld_caching) {
+    const objects = macho_file.base.comp.objects;
+    if (!macho_file.base.disable_lld_caching) {
         man = comp.cache_parent.obtain();
         // We are about to obtain this lock, so here we give other processes a chance first.
 @@ -57,7 +60,7 @@ pub fn linkWithZld(
         comptime assert(Compilation.link_hash_implementation_version == 10);
-        for (options.objects) |obj| {
+        for (objects) |obj| {
             _ = try man.addFile(obj.path, null);
             man.hash.add(obj.must_link);
         }
 @@ -68,24 +71,22 @@ pub fn linkWithZld(
         // We can skip hashing libc and libc++ components that we are in charge of building from Zig
         // installation sources because they are always a product of the compiler version + target information.
         man.hash.add(stack_size);
-        man.hash.addOptional(options.pagezero_size);
+        man.hash.addOptional(macho_file.pagezero_vmsize);
-        man.hash.addOptional(options.headerpad_size);
+        man.hash.addOptional(macho_file.headerpad_size);
-        man.hash.add(options.headerpad_max_install_names);
+        man.hash.add(macho_file.headerpad_max_install_names);
-        man.hash.add(gc_sections);
+        man.hash.add(macho_file.base.gc_sections);
-        man.hash.add(options.dead_strip_dylibs);
+        man.hash.add(macho_file.dead_strip_dylibs);
-        man.hash.add(options.strip);
+        man.hash.add(macho_file.base.comp.root_mod.strip);
-        man.hash.addListOfBytes(options.lib_dirs);
+        try MachO.hashAddFrameworks(&man, macho_file.frameworks);
-        man.hash.addListOfBytes(options.framework_dirs);
+        man.hash.addListOfBytes(macho_file.rpath_list);
-        try link.hashAddFrameworks(&man, options.frameworks);
-        man.hash.addListOfBytes(options.rpath_list);
         if (is_dyn_lib) {
-            man.hash.addOptionalBytes(options.install_name);
+            man.hash.addOptionalBytes(macho_file.install_name);
-            man.hash.addOptional(options.version);
+            man.hash.addOptional(comp.version);
         }
-        try link.hashAddSystemLibs(&man, options.system_libs);
+        try link.hashAddSystemLibs(&man, comp.system_libs);
-        man.hash.addOptionalBytes(options.sysroot);
+        man.hash.addOptionalBytes(comp.sysroot);
-        man.hash.addListOfBytes(options.force_undefined_symbols.keys());
+        man.hash.addListOfBytes(macho_file.base.force_undefined_symbols.keys());
-        try man.addOptionalFile(options.entitlements);
+        try man.addOptionalFile(macho_file.entitlements);
         // We don't actually care whether it's a cache hit or miss; we just
         // need the digest and the lock.
 @@ -125,13 +126,13 @@ pub fn linkWithZld(
         };
     }
-    if (options.output_mode == .Obj) {
+    if (output_mode == .Obj) {
         // LLD's MachO driver does not support the equivalent of `-r` so we do a simple file copy
         // here. TODO: think carefully about how we can avoid this redundant operation when doing
         // build-obj. See also the corresponding TODO in linkAsArchive.
         const the_object_path = blk: {
-            if (options.objects.len != 0) {
+            if (objects.len != 0) {
-                break :blk options.objects[0].path;
+                break :blk objects[0].path;
             }
             if (comp.c_object_table.count() != 0)
 @@ -150,7 +151,7 @@ pub fn linkWithZld(
             try fs.cwd().copyFile(the_object_path, fs.cwd(), full_out_path, .{});
         }
     } else {
-        const sub_path = options.emit.?.sub_path;
+        const sub_path = emit.?.sub_path;
         const old_file = macho_file.base.file; // TODO is this needed at all?
         defer macho_file.base.file = old_file;
 @@ -158,7 +159,7 @@ pub fn linkWithZld(
         const file = try directory.handle.createFile(sub_path, .{
             .truncate = true,
             .read = true,
-            .mode = link.determineMode(options.*),
+            .mode = link.File.determineMode(false, output_mode, link_mode),
         });
         defer file.close();
         macho_file.base.file = file;
 @@ -175,8 +176,8 @@ pub fn linkWithZld(
         // Positional arguments to the linker such as object files and static archives.
         var positionals = std.ArrayList(Compilation.LinkObject).init(arena);
-        try positionals.ensureUnusedCapacity(options.objects.len);
+        try positionals.ensureUnusedCapacity(objects.len);
-        positionals.appendSliceAssumeCapacity(options.objects);
+        positionals.appendSliceAssumeCapacity(objects);
         for (comp.c_object_table.keys()) |key| {
             try positionals.append(.{ .path = key.status.success.object_path });
 @@ -190,7 +191,7 @@ pub fn linkWithZld(
         if (comp.compiler_rt_obj) |obj| try positionals.append(.{ .path = obj.full_object_path });
         // libc++ dep
-        if (options.link_libcpp) {
+        if (comp.config.link_libcpp) {
             try positionals.ensureUnusedCapacity(2);
             positionals.appendAssumeCapacity(.{ .path = comp.libcxxabi_static_lib.?.full_object_path });
             positionals.appendAssumeCapacity(.{ .path = comp.libcxx_static_lib.?.full_object_path });
 @@ -199,23 +200,23 @@ pub fn linkWithZld(
         var libs = std.StringArrayHashMap(link.SystemLib).init(arena);
         {
-            const vals = options.system_libs.values();
+            const vals = comp.system_libs.values();
             try libs.ensureUnusedCapacity(vals.len);
             for (vals) |v| libs.putAssumeCapacity(v.path.?, v);
         }
         {
-            try libs.ensureUnusedCapacity(options.frameworks.len);
+            try libs.ensureUnusedCapacity(macho_file.frameworks.len);
-            for (options.frameworks) |v| libs.putAssumeCapacity(v.path, .{
+            for (macho_file.frameworks) |v| libs.putAssumeCapacity(v.path, .{
                 .needed = v.needed,
                 .weak = v.weak,
                 .path = v.path,
             });
         }
-        try macho_file.resolveLibSystem(arena, comp, options.lib_dirs, &libs);
+        try macho_file.resolveLibSystem(arena, comp, &libs);
-        if (options.verbose_link) {
+        if (comp.verbose_link) {
             var argv = std.ArrayList([]const u8).init(arena);
             try argv.append("zig");
 @@ -228,14 +229,14 @@ pub fn linkWithZld(
             if (is_dyn_lib) {
                 try argv.append("-dylib");
-                if (options.install_name) |install_name| {
+                if (macho_file.install_name) |install_name| {
                     try argv.append("-install_name");
                     try argv.append(install_name);
                 }
             }
             {
-                const platform = Platform.fromTarget(options.target);
+                const platform = Platform.fromTarget(target);
                 try argv.append("-platform_version");
                 try argv.append(@tagName(platform.os_tag));
                 try argv.append(try std.fmt.allocPrint(arena, "{}", .{platform.version}));
 @@ -248,44 +249,39 @@ pub fn linkWithZld(
                 }
             }
-            if (options.sysroot) |syslibroot| {
+            if (macho_file.sysroot) |syslibroot| {
                 try argv.append("-syslibroot");
                 try argv.append(syslibroot);
             }
-            for (options.rpath_list) |rpath| {
+            for (macho_file.rpath_list) |rpath| {
                 try argv.append("-rpath");
                 try argv.append(rpath);
             }
-            if (options.pagezero_size) |pagezero_size| {
+            try argv.appendSlice(&.{
-                try argv.append("-pagezero_size");
+                "-pagezero_size",  try std.fmt.allocPrint(arena, "0x{x}", .{macho_file.pagezero_size}),
-                try argv.append(try std.fmt.allocPrint(arena, "0x{x}", .{pagezero_size}));
+                "-headerpad_size", try std.fmt.allocPrint(arena, "0x{x}", .{macho_file.headerpad_size}),
-            }
+            });
-            if (options.headerpad_size) |headerpad_size| {
-                try argv.append("-headerpad_size");
-                try argv.append(try std.fmt.allocPrint(arena, "0x{x}", .{headerpad_size}));
-            }
-            if (options.headerpad_max_install_names) {
+            if (macho_file.headerpad_max_install_names) {
                 try argv.append("-headerpad_max_install_names");
             }
-            if (gc_sections) {
+            if (macho_file.base.gc_sections) {
                 try argv.append("-dead_strip");
             }
-            if (options.dead_strip_dylibs) {
+            if (macho_file.dead_strip_dylibs) {
                 try argv.append("-dead_strip_dylibs");
             }
-            if (options.entry) |entry| {
+            if (comp.config.entry) |entry| {
                 try argv.append("-e");
                 try argv.append(entry);
             }
-            for (options.objects) |obj| {
+            for (objects) |obj| {
                 if (obj.must_link) {
                     try argv.append("-force_load");
                 }
 @@ -303,7 +299,7 @@ pub fn linkWithZld(
             if (comp.compiler_rt_lib) |lib| try argv.append(lib.full_object_path);
             if (comp.compiler_rt_obj) |obj| try argv.append(obj.full_object_path);
-            if (options.link_libcpp) {
+            if (comp.config.link_libcpp) {
                 try argv.append(comp.libcxxabi_static_lib.?.full_object_path);
                 try argv.append(comp.libcxx_static_lib.?.full_object_path);
             }
 @@ -313,8 +309,8 @@ pub fn linkWithZld(
             try argv.append("-lSystem");
-            for (options.system_libs.keys()) |l_name| {
+            for (comp.system_libs.keys()) |l_name| {
-                const info = options.system_libs.get(l_name).?;
+                const info = comp.system_libs.get(l_name).?;
                 const arg = if (info.needed)
                     try std.fmt.allocPrint(arena, "-needed-l{s}", .{l_name})
                 else if (info.weak)
 @@ -324,11 +320,7 @@ pub fn linkWithZld(
                 try argv.append(arg);
             }
-            for (options.lib_dirs) |lib_dir| {
+            for (macho_file.frameworks) |framework| {
-                try argv.append(try std.fmt.allocPrint(arena, "-L{s}", .{lib_dir}));
-            }
-            for (options.frameworks) |framework| {
                 const name = std.fs.path.stem(framework.path);
                 const arg = if (framework.needed)
                     try std.fmt.allocPrint(arena, "-needed_framework {s}", .{name})
 @@ -339,11 +331,7 @@ pub fn linkWithZld(
                 try argv.append(arg);
             }
-            for (options.framework_dirs) |framework_dir| {
+            if (is_dyn_lib and macho_file.base.allow_shlib_undefined) {
-                try argv.append(try std.fmt.allocPrint(arena, "-F{s}", .{framework_dir}));
-            }
-            if (is_dyn_lib and (options.allow_shlib_undefined orelse false)) {
                 try argv.append("-undefined");
                 try argv.append("dynamic_lookup");
             }
 @@ -412,7 +400,7 @@ pub fn linkWithZld(
             };
         }
-        if (gc_sections) {
+        if (macho_file.base.gc_sections) {
             try dead_strip.gcAtoms(macho_file);
         }
 @@ -519,7 +507,7 @@ pub fn linkWithZld(
             // where the code signature goes into.
             var codesig = CodeSignature.init(MachO.getPageSize(cpu_arch));
             codesig.code_directory.ident = fs.path.basename(full_out_path);
-            if (options.entitlements) |path| {
+            if (macho_file.entitlements) |path| {
                 try codesig.addEntitlements(gpa, path);
             }
             try macho_file.writeCodeSignaturePadding(&codesig);
 @@ -539,7 +527,7 @@ pub fn linkWithZld(
         try lc_writer.writeStruct(macho_file.dysymtab_cmd);
         try load_commands.writeDylinkerLC(lc_writer);
-        switch (macho_file.base.options.output_mode) {
+        switch (output_mode) {
             .Exe => blk: {
                 const seg_id = macho_file.header_segment_cmd_index.?;
                 const seg = macho_file.segments.items[seg_id];
 @@ -555,10 +543,10 @@ pub fn linkWithZld(
                 try lc_writer.writeStruct(macho.entry_point_command{
                     .entryoff = @as(u32, @intCast(addr - seg.vmaddr)),
-                    .stacksize = macho_file.base.options.stack_size_override orelse 0,
+                    .stacksize = macho_file.base.stack_size,
                 });
             },
-            .Lib => if (macho_file.base.options.link_mode == .Dynamic) {
+            .Lib => if (link_mode == .Dynamic) {
                 try load_commands.writeDylibIdLC(gpa, &macho_file.base.options, lc_writer);
             },
             else => {},
 @@ -598,11 +586,11 @@ pub fn linkWithZld(
         if (codesig) |*csig| {
             try macho_file.writeCodeSignature(comp, csig); // code signing always comes last
-            try MachO.invalidateKernelCache(directory.handle, macho_file.base.options.emit.?.sub_path);
+            try MachO.invalidateKernelCache(directory.handle, macho_file.base.emit.sub_path);
         }
     }
-    if (!options.disable_lld_caching) {
+    if (!macho_file.base.disable_lld_caching) {
         // Update the file with the digest. If it fails we can continue; it only
         // means that the next invocation will have an unnecessary cache miss.
         Cache.writeSmallFile(directory.handle, id_symlink_basename, &digest) catch |err| {
 @@ -622,12 +610,11 @@ pub fn linkWithZld(
 fn createSegments(macho_file: *MachO) !void {
     const gpa = macho_file.base.allocator;
-    const pagezero_vmsize = macho_file.base.options.pagezero_size orelse MachO.default_pagezero_vmsize;
     const page_size = MachO.getPageSize(macho_file.base.options.target.cpu.arch);
-    const aligned_pagezero_vmsize = mem.alignBackward(u64, pagezero_vmsize, page_size);
+    const aligned_pagezero_vmsize = mem.alignBackward(u64, macho_file.pagezero_vmsize, page_size);
     if (macho_file.base.options.output_mode != .Lib and aligned_pagezero_vmsize > 0) {
-        if (aligned_pagezero_vmsize != pagezero_vmsize) {
+        if (aligned_pagezero_vmsize != macho_file.pagezero_vmsize) {
-            log.warn("requested __PAGEZERO size (0x{x}) is not page aligned", .{pagezero_vmsize});
+            log.warn("requested __PAGEZERO size (0x{x}) is not page aligned", .{macho_file.pagezero_vmsize});
             log.warn("  rounding down to 0x{x}", .{aligned_pagezero_vmsize});
         }
         macho_file.pagezero_segment_cmd_index = @intCast(macho_file.segments.items.len);

src/link/NvPtx.zig+29-19

...	@@ -24,46 +24,56 @@ const LlvmObject = @import("../codegen/llvm.zig").Object;	...	@@ -24,46 +24,56 @@ const LlvmObject = @import("../codegen/llvm.zig").Object;
24		24
25	base: link.File,	25	base: link.File,
26	llvm_object: *LlvmObject,	26	llvm_object: *LlvmObject,
27	ptx_file_name: []const u8,
28		27
29	pub fn createEmpty(gpa: Allocator, options: link.Options) !*NvPtx {	28	pub fn createEmpty(arena: Allocator, options: link.File.OpenOptions) !*NvPtx {
30	if (!options.use_llvm) return error.PtxArchNotSupported;	29	if (build_options.only_c) unreachable;
31		30
32	if (!options.target.cpu.arch.isNvptx()) return error.PtxArchNotSupported;	31	const target = options.comp.root_mod.resolved_target.result;
		32	const use_lld = build_options.have_llvm and options.comp.config.use_lld;
		33	const use_llvm = options.comp.config.use_llvm;
33		34
34	switch (options.target.os.tag) {	35	assert(use_llvm); // Caught by Compilation.Config.resolve.
		36	assert(!use_lld); // Caught by Compilation.Config.resolve.
		37	assert(target.cpu.arch.isNvptx()); // Caught by Compilation.Config.resolve.
		38
		39	switch (target.os.tag) {
35	// TODO: does it also work with nvcl ?	40	// TODO: does it also work with nvcl ?
36	.cuda => {},	41	.cuda => {},
37	else => return error.PtxArchNotSupported,	42	else => return error.PtxArchNotSupported,
38	}	43	}
39		44
40	const llvm_object = try LlvmObject.create(gpa, options);	45	const llvm_object = try LlvmObject.create(arena, options);
41	const nvptx = try gpa.create(NvPtx);	46	const nvptx = try arena.create(NvPtx);
42	nvptx.* = .{	47	nvptx.* = .{
43	.base = .{	48	.base = .{
44	.tag = .nvptx,	49	.tag = .nvptx,
45	.options = options,	50	.comp = options.comp,
		51	.emit = options.emit,
		52	.gc_sections = options.gc_sections orelse false,
		53	.stack_size = options.stack_size orelse 0,
		54	.allow_shlib_undefined = options.allow_shlib_undefined orelse false,
46	.file = null,	55	.file = null,
47	.allocator = gpa,	56	.disable_lld_caching = options.disable_lld_caching,
		57	.build_id = options.build_id,
		58	.rpath_list = options.rpath_list,
		59	.force_undefined_symbols = options.force_undefined_symbols,
		60	.function_sections = options.function_sections,
		61	.data_sections = options.data_sections,
48	},	62	},
49	.llvm_object = llvm_object,	63	.llvm_object = llvm_object,
50	.ptx_file_name = try std.mem.join(gpa, "", &[_][]const u8{ options.root_name, ".ptx" }),
51	};	64	};
52		65
53	return nvptx;	66	return nvptx;
54	}	67	}
55		68
56	pub fn openPath(allocator: Allocator, sub_path: []const u8, options: link.Options) !*NvPtx {	69	pub fn open(arena: Allocator, options: link.FileOpenOptions) !*NvPtx {
57	if (!options.use_llvm) return error.PtxArchNotSupported;	70	const target = options.comp.root_mod.resolved_target.result;
58	assert(options.target.ofmt == .nvptx);	71	assert(target.ofmt == .nvptx);
59		72	return createEmpty(arena, options);
60	log.debug("Opening .ptx target file {s}", .{sub_path});
61	return createEmpty(allocator, options);
62	}	73	}
63		74
64	pub fn deinit(self: *NvPtx) void {	75	pub fn deinit(self: *NvPtx) void {
65	self.llvm_object.destroy(self.base.allocator);	76	self.llvm_object.deinit();
66	self.base.allocator.free(self.ptx_file_name);
67	}	77	}
68		78
69	pub fn updateFunc(self: NvPtx, module: Module, func_index: InternPool.Index, air: Air, liveness: Liveness) !void {	79	pub fn updateFunc(self: NvPtx, module: Module, func_index: InternPool.Index, air: Air, liveness: Liveness) !void {
...	@@ -110,7 +120,7 @@ pub fn flushModule(self: NvPtx, comp: Compilation, prog_node: *std.Progress.No	...	@@ -110,7 +120,7 @@ pub fn flushModule(self: NvPtx, comp: Compilation, prog_node: *std.Progress.No
110	comp.emit_asm = .{	120	comp.emit_asm = .{
111	// 'null' means using the default cache dir: zig-cache/o/...	121	// 'null' means using the default cache dir: zig-cache/o/...
112	.directory = null,	122	.directory = null,
113	.basename = self.ptx_file_name,	123	.basename = self.base.emit.sub_path,
114	};	124	};
115	defer {	125	defer {
116	comp.bin_file.options.emit = outfile;	126	comp.bin_file.options.emit = outfile;

src/link/Plan9.zig+89-63

...	@@ -318,12 +318,12 @@ pub fn createEmpty(gpa: Allocator, options: link.Options) !*Plan9 {	...	@@ -318,12 +318,12 @@ pub fn createEmpty(gpa: Allocator, options: link.Options) !*Plan9 {
318	.magic = try aout.magicFromArch(self.base.options.target.cpu.arch),	318	.magic = try aout.magicFromArch(self.base.options.target.cpu.arch),
319	};	319	};
320	// a / will always be in a file path	320	// a / will always be in a file path
321	try self.file_segments.put(self.base.allocator, "/", 1);	321	try self.file_segments.put(gpa, "/", 1);
322	return self;	322	return self;
323	}	323	}
324		324
325	fn putFn(self: *Plan9, decl_index: InternPool.DeclIndex, out: FnDeclOutput) !void {	325	fn putFn(self: *Plan9, decl_index: InternPool.DeclIndex, out: FnDeclOutput) !void {
326	const gpa = self.base.allocator;	326	const gpa = self.base.comp.gpa;
327	const mod = self.base.options.module.?;	327	const mod = self.base.options.module.?;
328	const decl = mod.declPtr(decl_index);	328	const decl = mod.declPtr(decl_index);
329	const fn_map_res = try self.fn_decl_table.getOrPut(gpa, decl.getFileScope(mod));	329	const fn_map_res = try self.fn_decl_table.getOrPut(gpa, decl.getFileScope(mod));
...	@@ -379,6 +379,7 @@ fn putFn(self: *Plan9, decl_index: InternPool.DeclIndex, out: FnDeclOutput) !voi	...	@@ -379,6 +379,7 @@ fn putFn(self: *Plan9, decl_index: InternPool.DeclIndex, out: FnDeclOutput) !voi
379	}	379	}
380		380
381	fn addPathComponents(self: Plan9, path: []const u8, a: std.ArrayList(u8)) !void {	381	fn addPathComponents(self: Plan9, path: []const u8, a: std.ArrayList(u8)) !void {
		382	const gpa = self.base.comp.gpa;
382	const sep = std.fs.path.sep;	383	const sep = std.fs.path.sep;
383	var it = std.mem.tokenizeScalar(u8, path, sep);	384	var it = std.mem.tokenizeScalar(u8, path, sep);
384	while (it.next()) \|component\| {	385	while (it.next()) \|component\| {
...	@@ -386,7 +387,7 @@ fn addPathComponents(self: Plan9, path: []const u8, a: std.ArrayList(u8)) !voi	...	@@ -386,7 +387,7 @@ fn addPathComponents(self: Plan9, path: []const u8, a: std.ArrayList(u8)) !voi
386	try a.writer().writeInt(u16, num, .big);	387	try a.writer().writeInt(u16, num, .big);
387	} else {	388	} else {
388	self.file_segments_i += 1;	389	self.file_segments_i += 1;
389	try self.file_segments.put(self.base.allocator, component, self.file_segments_i);	390	try self.file_segments.put(gpa, component, self.file_segments_i);
390	try a.writer().writeInt(u16, self.file_segments_i, .big);	391	try a.writer().writeInt(u16, self.file_segments_i, .big);
391	}	392	}
392	}	393	}
...	@@ -397,6 +398,7 @@ pub fn updateFunc(self: Plan9, mod: Module, func_index: InternPool.Index, air:	...	@@ -397,6 +398,7 @@ pub fn updateFunc(self: Plan9, mod: Module, func_index: InternPool.Index, air:
397	@panic("Attempted to compile for object format that was disabled by build configuration");	398	@panic("Attempted to compile for object format that was disabled by build configuration");
398	}	399	}
399		400
		401	const gpa = self.base.comp.gpa;
400	const func = mod.funcInfo(func_index);	402	const func = mod.funcInfo(func_index);
401	const decl_index = func.owner_decl;	403	const decl_index = func.owner_decl;
402	const decl = mod.declPtr(decl_index);	404	const decl = mod.declPtr(decl_index);
...	@@ -404,10 +406,10 @@ pub fn updateFunc(self: Plan9, mod: Module, func_index: InternPool.Index, air:	...	@@ -404,10 +406,10 @@ pub fn updateFunc(self: Plan9, mod: Module, func_index: InternPool.Index, air:
404		406
405	const atom_idx = try self.seeDecl(decl_index);	407	const atom_idx = try self.seeDecl(decl_index);
406		408
407	var code_buffer = std.ArrayList(u8).init(self.base.allocator);	409	var code_buffer = std.ArrayList(u8).init(gpa);
408	defer code_buffer.deinit();	410	defer code_buffer.deinit();
409	var dbg_info_output: DebugInfoOutput = .{	411	var dbg_info_output: DebugInfoOutput = .{
410	.dbg_line = std.ArrayList(u8).init(self.base.allocator),	412	.dbg_line = std.ArrayList(u8).init(gpa),
411	.start_line = null,	413	.start_line = null,
412	.end_line = undefined,	414	.end_line = undefined,
413	.pcop_change_index = null,	415	.pcop_change_index = null,
...	@@ -448,14 +450,15 @@ pub fn updateFunc(self: Plan9, mod: Module, func_index: InternPool.Index, air:	...	@@ -448,14 +450,15 @@ pub fn updateFunc(self: Plan9, mod: Module, func_index: InternPool.Index, air:
448	}	450	}
449		451
450	pub fn lowerUnnamedConst(self: *Plan9, tv: TypedValue, decl_index: InternPool.DeclIndex) !u32 {	452	pub fn lowerUnnamedConst(self: *Plan9, tv: TypedValue, decl_index: InternPool.DeclIndex) !u32 {
		453	const gpa = self.base.comp.gpa;
451	_ = try self.seeDecl(decl_index);	454	_ = try self.seeDecl(decl_index);
452	var code_buffer = std.ArrayList(u8).init(self.base.allocator);	455	var code_buffer = std.ArrayList(u8).init(gpa);
453	defer code_buffer.deinit();	456	defer code_buffer.deinit();
454		457
455	const mod = self.base.options.module.?;	458	const mod = self.base.options.module.?;
456	const decl = mod.declPtr(decl_index);	459	const decl = mod.declPtr(decl_index);
457		460
458	const gop = try self.unnamed_const_atoms.getOrPut(self.base.allocator, decl_index);	461	const gop = try self.unnamed_const_atoms.getOrPut(gpa, decl_index);
459	if (!gop.found_existing) {	462	if (!gop.found_existing) {
460	gop.value_ptr.* = .{};	463	gop.value_ptr.* = .{};
461	}	464	}
...	@@ -465,7 +468,7 @@ pub fn lowerUnnamedConst(self: *Plan9, tv: TypedValue, decl_index: InternPool.De	...	@@ -465,7 +468,7 @@ pub fn lowerUnnamedConst(self: *Plan9, tv: TypedValue, decl_index: InternPool.De
465		468
466	const index = unnamed_consts.items.len;	469	const index = unnamed_consts.items.len;
467	// name is freed when the unnamed const is freed	470	// name is freed when the unnamed const is freed
468	const name = try std.fmt.allocPrint(self.base.allocator, "__unnamed_{s}_{d}", .{ decl_name, index });	471	const name = try std.fmt.allocPrint(gpa, "__unnamed_{s}_{d}", .{ decl_name, index });
469		472
470	const sym_index = try self.allocateSymbolIndex();	473	const sym_index = try self.allocateSymbolIndex();
471	const new_atom_idx = try self.createAtom();	474	const new_atom_idx = try self.createAtom();
...	@@ -498,17 +501,18 @@ pub fn lowerUnnamedConst(self: *Plan9, tv: TypedValue, decl_index: InternPool.De	...	@@ -498,17 +501,18 @@ pub fn lowerUnnamedConst(self: *Plan9, tv: TypedValue, decl_index: InternPool.De
498	},	501	},
499	};	502	};
500	// duped_code is freed when the unnamed const is freed	503	// duped_code is freed when the unnamed const is freed
501	const duped_code = try self.base.allocator.dupe(u8, code);	504	const duped_code = try gpa.dupe(u8, code);
502	errdefer self.base.allocator.free(duped_code);	505	errdefer gpa.free(duped_code);
503	const new_atom = self.getAtomPtr(new_atom_idx);	506	const new_atom = self.getAtomPtr(new_atom_idx);
504	new_atom.* = info;	507	new_atom.* = info;
505	new_atom.code = .{ .code_ptr = duped_code.ptr, .other = .{ .code_len = duped_code.len } };	508	new_atom.code = .{ .code_ptr = duped_code.ptr, .other = .{ .code_len = duped_code.len } };
506	try unnamed_consts.append(self.base.allocator, new_atom_idx);	509	try unnamed_consts.append(gpa, new_atom_idx);
507	// we return the new_atom_idx to codegen	510	// we return the new_atom_idx to codegen
508	return new_atom_idx;	511	return new_atom_idx;
509	}	512	}
510		513
511	pub fn updateDecl(self: Plan9, mod: Module, decl_index: InternPool.DeclIndex) !void {	514	pub fn updateDecl(self: Plan9, mod: Module, decl_index: InternPool.DeclIndex) !void {
		515	const gpa = self.base.comp.gpa;
512	const decl = mod.declPtr(decl_index);	516	const decl = mod.declPtr(decl_index);
513		517
514	if (decl.isExtern(mod)) {	518	if (decl.isExtern(mod)) {
...	@@ -517,7 +521,7 @@ pub fn updateDecl(self: Plan9, mod: Module, decl_index: InternPool.DeclIndex)	...	@@ -517,7 +521,7 @@ pub fn updateDecl(self: Plan9, mod: Module, decl_index: InternPool.DeclIndex)
517	}	521	}
518	const atom_idx = try self.seeDecl(decl_index);	522	const atom_idx = try self.seeDecl(decl_index);
519		523
520	var code_buffer = std.ArrayList(u8).init(self.base.allocator);	524	var code_buffer = std.ArrayList(u8).init(gpa);
521	defer code_buffer.deinit();	525	defer code_buffer.deinit();
522	const decl_val = if (decl.val.getVariable(mod)) \|variable\| Value.fromInterned(variable.init) else decl.val;	526	const decl_val = if (decl.val.getVariable(mod)) \|variable\| Value.fromInterned(variable.init) else decl.val;
523	// TODO we need the symbol index for symbol in the table of locals for the containing atom	527	// TODO we need the symbol index for symbol in the table of locals for the containing atom
...	@@ -535,16 +539,17 @@ pub fn updateDecl(self: Plan9, mod: Module, decl_index: InternPool.DeclIndex)	...	@@ -535,16 +539,17 @@ pub fn updateDecl(self: Plan9, mod: Module, decl_index: InternPool.DeclIndex)
535	return;	539	return;
536	},	540	},
537	};	541	};
538	try self.data_decl_table.ensureUnusedCapacity(self.base.allocator, 1);	542	try self.data_decl_table.ensureUnusedCapacity(gpa, 1);
539	const duped_code = try self.base.allocator.dupe(u8, code);	543	const duped_code = try gpa.dupe(u8, code);
540	self.getAtomPtr(self.decls.get(decl_index).?.index).code = .{ .code_ptr = null, .other = .{ .decl_index = decl_index } };	544	self.getAtomPtr(self.decls.get(decl_index).?.index).code = .{ .code_ptr = null, .other = .{ .decl_index = decl_index } };
541	if (self.data_decl_table.fetchPutAssumeCapacity(decl_index, duped_code)) \|old_entry\| {	545	if (self.data_decl_table.fetchPutAssumeCapacity(decl_index, duped_code)) \|old_entry\| {
542	self.base.allocator.free(old_entry.value);	546	gpa.free(old_entry.value);
543	}	547	}
544	return self.updateFinish(decl_index);	548	return self.updateFinish(decl_index);
545	}	549	}
546	/// called at the end of update{Decl,Func}	550	/// called at the end of update{Decl,Func}
547	fn updateFinish(self: *Plan9, decl_index: InternPool.DeclIndex) !void {	551	fn updateFinish(self: *Plan9, decl_index: InternPool.DeclIndex) !void {
		552	const gpa = self.base.comp.gpa;
548	const mod = self.base.options.module.?;	553	const mod = self.base.options.module.?;
549	const decl = mod.declPtr(decl_index);	554	const decl = mod.declPtr(decl_index);
550	const is_fn = (decl.ty.zigTypeTag(mod) == .Fn);	555	const is_fn = (decl.ty.zigTypeTag(mod) == .Fn);
...	@@ -558,7 +563,7 @@ fn updateFinish(self: *Plan9, decl_index: InternPool.DeclIndex) !void {	...	@@ -558,7 +563,7 @@ fn updateFinish(self: *Plan9, decl_index: InternPool.DeclIndex) !void {
558	const sym: aout.Sym = .{	563	const sym: aout.Sym = .{
559	.value = undefined, // the value of stuff gets filled in in flushModule	564	.value = undefined, // the value of stuff gets filled in in flushModule
560	.type = atom.type,	565	.type = atom.type,
561	.name = try self.base.allocator.dupe(u8, mod.intern_pool.stringToSlice(decl.name)),	566	.name = try gpa.dupe(u8, mod.intern_pool.stringToSlice(decl.name)),
562	};	567	};
563		568
564	if (atom.sym_index) \|s\| {	569	if (atom.sym_index) \|s\| {
...	@@ -571,10 +576,11 @@ fn updateFinish(self: *Plan9, decl_index: InternPool.DeclIndex) !void {	...	@@ -571,10 +576,11 @@ fn updateFinish(self: *Plan9, decl_index: InternPool.DeclIndex) !void {
571	}	576	}
572		577
573	fn allocateSymbolIndex(self: *Plan9) !usize {	578	fn allocateSymbolIndex(self: *Plan9) !usize {
		579	const gpa = self.base.comp.gpa;
574	if (self.syms_index_free_list.popOrNull()) \|i\| {	580	if (self.syms_index_free_list.popOrNull()) \|i\| {
575	return i;	581	return i;
576	} else {	582	} else {
577	_ = try self.syms.addOne(self.base.allocator);	583	_ = try self.syms.addOne(gpa);
578	return self.syms.items.len - 1;	584	return self.syms.items.len - 1;
579	}	585	}
580	}	586	}
...	@@ -589,7 +595,8 @@ fn allocateGotIndex(self: *Plan9) usize {	...	@@ -589,7 +595,8 @@ fn allocateGotIndex(self: *Plan9) usize {
589	}	595	}
590		596
591	pub fn flush(self: Plan9, comp: Compilation, prog_node: *std.Progress.Node) link.File.FlushError!void {	597	pub fn flush(self: Plan9, comp: Compilation, prog_node: *std.Progress.Node) link.File.FlushError!void {
592	assert(!self.base.options.use_lld);	598	const use_lld = build_options.have_llvm and self.base.comp.config.use_lld;
		599	assert(!use_lld);
593		600
594	switch (self.base.options.effectiveOutputMode()) {	601	switch (self.base.options.effectiveOutputMode()) {
595	.Exe => {},	602	.Exe => {},
...	@@ -650,7 +657,8 @@ pub fn flushModule(self: Plan9, comp: Compilation, prog_node: *std.Progress.No	...	@@ -650,7 +657,8 @@ pub fn flushModule(self: Plan9, comp: Compilation, prog_node: *std.Progress.No
650	@panic("Attempted to compile for object format that was disabled by build configuration");	657	@panic("Attempted to compile for object format that was disabled by build configuration");
651	}	658	}
652		659
653	_ = comp;	660	const gpa = comp.gpa;
		661
654	const tracy = trace(@src());	662	const tracy = trace(@src());
655	defer tracy.end();	663	defer tracy.end();
656		664
...	@@ -691,12 +699,12 @@ pub fn flushModule(self: Plan9, comp: Compilation, prog_node: *std.Progress.No	...	@@ -691,12 +699,12 @@ pub fn flushModule(self: Plan9, comp: Compilation, prog_node: *std.Progress.No
691	const atom_count = self.atomCount();	699	const atom_count = self.atomCount();
692	assert(self.got_len == atom_count + self.got_index_free_list.items.len);	700	assert(self.got_len == atom_count + self.got_index_free_list.items.len);
693	const got_size = self.got_len * if (!self.sixtyfour_bit) @as(u32, 4) else 8;	701	const got_size = self.got_len * if (!self.sixtyfour_bit) @as(u32, 4) else 8;
694	var got_table = try self.base.allocator.alloc(u8, got_size);	702	var got_table = try gpa.alloc(u8, got_size);
695	defer self.base.allocator.free(got_table);	703	defer gpa.free(got_table);
696		704
697	// + 4 for header, got, symbols, linecountinfo	705	// + 4 for header, got, symbols, linecountinfo
698	var iovecs = try self.base.allocator.alloc(std.os.iovec_const, self.atomCount() + 4 - self.externCount());	706	var iovecs = try gpa.alloc(std.os.iovec_const, self.atomCount() + 4 - self.externCount());
699	defer self.base.allocator.free(iovecs);	707	defer gpa.free(iovecs);
700		708
701	const file = self.base.file.?;	709	const file = self.base.file.?;
702		710
...	@@ -709,7 +717,7 @@ pub fn flushModule(self: Plan9, comp: Compilation, prog_node: *std.Progress.No	...	@@ -709,7 +717,7 @@ pub fn flushModule(self: Plan9, comp: Compilation, prog_node: *std.Progress.No
709	var iovecs_i: usize = 1;	717	var iovecs_i: usize = 1;
710	var text_i: u64 = 0;	718	var text_i: u64 = 0;
711		719
712	var linecountinfo = std.ArrayList(u8).init(self.base.allocator);	720	var linecountinfo = std.ArrayList(u8).init(gpa);
713	defer linecountinfo.deinit();	721	defer linecountinfo.deinit();
714	// text	722	// text
715	{	723	{
...	@@ -901,10 +909,10 @@ pub fn flushModule(self: Plan9, comp: Compilation, prog_node: *std.Progress.No	...	@@ -901,10 +909,10 @@ pub fn flushModule(self: Plan9, comp: Compilation, prog_node: *std.Progress.No
901	}	909	}
902	}	910	}
903	}	911	}
904	var sym_buf = std.ArrayList(u8).init(self.base.allocator);	912	var sym_buf = std.ArrayList(u8).init(gpa);
905	try self.writeSyms(&sym_buf);	913	try self.writeSyms(&sym_buf);
906	const syms = try sym_buf.toOwnedSlice();	914	const syms = try sym_buf.toOwnedSlice();
907	defer self.base.allocator.free(syms);	915	defer gpa.free(syms);
908	assert(2 + self.atomCount() - self.externCount() == iovecs_i); // we didn't write all the decls	916	assert(2 + self.atomCount() - self.externCount() == iovecs_i); // we didn't write all the decls
909	iovecs[iovecs_i] = .{ .iov_base = syms.ptr, .iov_len = syms.len };	917	iovecs[iovecs_i] = .{ .iov_base = syms.ptr, .iov_len = syms.len };
910	iovecs_i += 1;	918	iovecs_i += 1;
...	@@ -985,6 +993,7 @@ fn addDeclExports(	...	@@ -985,6 +993,7 @@ fn addDeclExports(
985	decl_index: InternPool.DeclIndex,	993	decl_index: InternPool.DeclIndex,
986	exports: []const *Module.Export,	994	exports: []const *Module.Export,
987	) !void {	995	) !void {
		996	const gpa = self.base.comp.gpa;
988	const metadata = self.decls.getPtr(decl_index).?;	997	const metadata = self.decls.getPtr(decl_index).?;
989	const atom = self.getAtom(metadata.index);	998	const atom = self.getAtom(metadata.index);
990		999
...	@@ -994,7 +1003,7 @@ fn addDeclExports(	...	@@ -994,7 +1003,7 @@ fn addDeclExports(
994	if (exp.opts.section.unwrap()) \|section_name\| {	1003	if (exp.opts.section.unwrap()) \|section_name\| {
995	if (!mod.intern_pool.stringEqlSlice(section_name, ".text") and !mod.intern_pool.stringEqlSlice(section_name, ".data")) {	1004	if (!mod.intern_pool.stringEqlSlice(section_name, ".text") and !mod.intern_pool.stringEqlSlice(section_name, ".data")) {
996	try mod.failed_exports.put(mod.gpa, exp, try Module.ErrorMsg.create(	1005	try mod.failed_exports.put(mod.gpa, exp, try Module.ErrorMsg.create(
997	self.base.allocator,	1006	gpa,
998	mod.declPtr(decl_index).srcLoc(mod),	1007	mod.declPtr(decl_index).srcLoc(mod),
999	"plan9 does not support extra sections",	1008	"plan9 does not support extra sections",
1000	.{},	1009	.{},
...	@@ -1005,19 +1014,20 @@ fn addDeclExports(	...	@@ -1005,19 +1014,20 @@ fn addDeclExports(
1005	const sym = .{	1014	const sym = .{
1006	.value = atom.offset.?,	1015	.value = atom.offset.?,
1007	.type = atom.type.toGlobal(),	1016	.type = atom.type.toGlobal(),
1008	.name = try self.base.allocator.dupe(u8, exp_name),	1017	.name = try gpa.dupe(u8, exp_name),
1009	};	1018	};
1010		1019
1011	if (metadata.getExport(self, exp_name)) \|i\| {	1020	if (metadata.getExport(self, exp_name)) \|i\| {
1012	self.syms.items[i] = sym;	1021	self.syms.items[i] = sym;
1013	} else {	1022	} else {
1014	try self.syms.append(self.base.allocator, sym);	1023	try self.syms.append(gpa, sym);
1015	try metadata.exports.append(self.base.allocator, self.syms.items.len - 1);	1024	try metadata.exports.append(gpa, self.syms.items.len - 1);
1016	}	1025	}
1017	}	1026	}
1018	}	1027	}
1019		1028
1020	pub fn freeDecl(self: *Plan9, decl_index: InternPool.DeclIndex) void {	1029	pub fn freeDecl(self: *Plan9, decl_index: InternPool.DeclIndex) void {
		1030	const gpa = self.base.comp.gpa;
1021	// TODO audit the lifetimes of decls table entries. It's possible to get	1031	// TODO audit the lifetimes of decls table entries. It's possible to get
1022	// freeDecl without any updateDecl in between.	1032	// freeDecl without any updateDecl in between.
1023	// However that is planned to change, see the TODO comment in Module.zig	1033	// However that is planned to change, see the TODO comment in Module.zig
...	@@ -1029,17 +1039,17 @@ pub fn freeDecl(self: *Plan9, decl_index: InternPool.DeclIndex) void {	...	@@ -1029,17 +1039,17 @@ pub fn freeDecl(self: *Plan9, decl_index: InternPool.DeclIndex) void {
1029	const symidx_and_submap = self.fn_decl_table.get(decl.getFileScope(mod)).?;	1039	const symidx_and_submap = self.fn_decl_table.get(decl.getFileScope(mod)).?;
1030	var submap = symidx_and_submap.functions;	1040	var submap = symidx_and_submap.functions;
1031	if (submap.fetchSwapRemove(decl_index)) \|removed_entry\| {	1041	if (submap.fetchSwapRemove(decl_index)) \|removed_entry\| {
1032	self.base.allocator.free(removed_entry.value.code);	1042	gpa.free(removed_entry.value.code);
1033	self.base.allocator.free(removed_entry.value.lineinfo);	1043	gpa.free(removed_entry.value.lineinfo);
1034	}	1044	}
1035	if (submap.count() == 0) {	1045	if (submap.count() == 0) {
1036	self.syms.items[symidx_and_submap.sym_index] = aout.Sym.undefined_symbol;	1046	self.syms.items[symidx_and_submap.sym_index] = aout.Sym.undefined_symbol;
1037	self.syms_index_free_list.append(self.base.allocator, symidx_and_submap.sym_index) catch {};	1047	self.syms_index_free_list.append(gpa, symidx_and_submap.sym_index) catch {};
1038	submap.deinit(self.base.allocator);	1048	submap.deinit(gpa);
1039	}	1049	}
1040	} else {	1050	} else {
1041	if (self.data_decl_table.fetchSwapRemove(decl_index)) \|removed_entry\| {	1051	if (self.data_decl_table.fetchSwapRemove(decl_index)) \|removed_entry\| {
1042	self.base.allocator.free(removed_entry.value);	1052	gpa.free(removed_entry.value);
1043	}	1053	}
1044	}	1054	}
1045	if (self.decls.fetchRemove(decl_index)) \|const_kv\| {	1055	if (self.decls.fetchRemove(decl_index)) \|const_kv\| {
...	@@ -1047,35 +1057,36 @@ pub fn freeDecl(self: *Plan9, decl_index: InternPool.DeclIndex) void {	...	@@ -1047,35 +1057,36 @@ pub fn freeDecl(self: *Plan9, decl_index: InternPool.DeclIndex) void {
1047	const atom = self.getAtom(kv.value.index);	1057	const atom = self.getAtom(kv.value.index);
1048	if (atom.got_index) \|i\| {	1058	if (atom.got_index) \|i\| {
1049	// TODO: if this catch {} is triggered, an assertion in flushModule will be triggered, because got_index_free_list will have the wrong length	1059	// TODO: if this catch {} is triggered, an assertion in flushModule will be triggered, because got_index_free_list will have the wrong length
1050	self.got_index_free_list.append(self.base.allocator, i) catch {};	1060	self.got_index_free_list.append(gpa, i) catch {};
1051	}	1061	}
1052	if (atom.sym_index) \|i\| {	1062	if (atom.sym_index) \|i\| {
1053	self.syms_index_free_list.append(self.base.allocator, i) catch {};	1063	self.syms_index_free_list.append(gpa, i) catch {};
1054	self.syms.items[i] = aout.Sym.undefined_symbol;	1064	self.syms.items[i] = aout.Sym.undefined_symbol;
1055	}	1065	}
1056	kv.value.exports.deinit(self.base.allocator);	1066	kv.value.exports.deinit(gpa);
1057	}	1067	}
1058	self.freeUnnamedConsts(decl_index);	1068	self.freeUnnamedConsts(decl_index);
1059	{	1069	{
1060	const atom_index = self.decls.get(decl_index).?.index;	1070	const atom_index = self.decls.get(decl_index).?.index;
1061	const relocs = self.relocs.getPtr(atom_index) orelse return;	1071	const relocs = self.relocs.getPtr(atom_index) orelse return;
1062	relocs.clearAndFree(self.base.allocator);	1072	relocs.clearAndFree(gpa);
1063	assert(self.relocs.remove(atom_index));	1073	assert(self.relocs.remove(atom_index));
1064	}	1074	}
1065	}	1075	}
1066	fn freeUnnamedConsts(self: *Plan9, decl_index: InternPool.DeclIndex) void {	1076	fn freeUnnamedConsts(self: *Plan9, decl_index: InternPool.DeclIndex) void {
		1077	const gpa = self.base.comp.gpa;
1067	const unnamed_consts = self.unnamed_const_atoms.getPtr(decl_index) orelse return;	1078	const unnamed_consts = self.unnamed_const_atoms.getPtr(decl_index) orelse return;
1068	for (unnamed_consts.items) \|atom_idx\| {	1079	for (unnamed_consts.items) \|atom_idx\| {
1069	const atom = self.getAtom(atom_idx);	1080	const atom = self.getAtom(atom_idx);
1070	self.base.allocator.free(self.syms.items[atom.sym_index.?].name);	1081	gpa.free(self.syms.items[atom.sym_index.?].name);
1071	self.syms.items[atom.sym_index.?] = aout.Sym.undefined_symbol;	1082	self.syms.items[atom.sym_index.?] = aout.Sym.undefined_symbol;
1072	self.syms_index_free_list.append(self.base.allocator, atom.sym_index.?) catch {};	1083	self.syms_index_free_list.append(gpa, atom.sym_index.?) catch {};
1073	}	1084	}
1074	unnamed_consts.clearAndFree(self.base.allocator);	1085	unnamed_consts.clearAndFree(gpa);
1075	}	1086	}
1076		1087
1077	fn createAtom(self: *Plan9) !Atom.Index {	1088	fn createAtom(self: *Plan9) !Atom.Index {
1078	const gpa = self.base.allocator;	1089	const gpa = self.base.comp.gpa;
1079	const index = @as(Atom.Index, @intCast(self.atoms.items.len));	1090	const index = @as(Atom.Index, @intCast(self.atoms.items.len));
1080	const atom = try self.atoms.addOne(gpa);	1091	const atom = try self.atoms.addOne(gpa);
1081	atom.* = .{	1092	atom.* = .{
...	@@ -1089,7 +1100,8 @@ fn createAtom(self: *Plan9) !Atom.Index {	...	@@ -1089,7 +1100,8 @@ fn createAtom(self: *Plan9) !Atom.Index {
1089	}	1100	}
1090		1101
1091	pub fn seeDecl(self: *Plan9, decl_index: InternPool.DeclIndex) !Atom.Index {	1102	pub fn seeDecl(self: *Plan9, decl_index: InternPool.DeclIndex) !Atom.Index {
1092	const gop = try self.decls.getOrPut(self.base.allocator, decl_index);	1103	const gpa = self.base.comp.gpa;
		1104	const gop = try self.decls.getOrPut(gpa, decl_index);
1093	if (!gop.found_existing) {	1105	if (!gop.found_existing) {
1094	const index = try self.createAtom();	1106	const index = try self.createAtom();
1095	self.getAtomPtr(index).got_index = self.allocateGotIndex();	1107	self.getAtomPtr(index).got_index = self.allocateGotIndex();
...	@@ -1134,7 +1146,8 @@ pub fn updateExports(	...	@@ -1134,7 +1146,8 @@ pub fn updateExports(
1134	}	1146	}
1135		1147
1136	pub fn getOrCreateAtomForLazySymbol(self: *Plan9, sym: File.LazySymbol) !Atom.Index {	1148	pub fn getOrCreateAtomForLazySymbol(self: *Plan9, sym: File.LazySymbol) !Atom.Index {
1137	const gop = try self.lazy_syms.getOrPut(self.base.allocator, sym.getDecl(self.base.options.module.?));	1149	const gpa = self.base.comp.gpa;
		1150	const gop = try self.lazy_syms.getOrPut(gpa, sym.getDecl(self.base.options.module.?));
1138	errdefer _ = if (!gop.found_existing) self.lazy_syms.pop();	1151	errdefer _ = if (!gop.found_existing) self.lazy_syms.pop();
1139		1152
1140	if (!gop.found_existing) gop.value_ptr.* = .{};	1153	if (!gop.found_existing) gop.value_ptr.* = .{};
...	@@ -1160,7 +1173,7 @@ pub fn getOrCreateAtomForLazySymbol(self: *Plan9, sym: File.LazySymbol) !Atom.In	...	@@ -1160,7 +1173,7 @@ pub fn getOrCreateAtomForLazySymbol(self: *Plan9, sym: File.LazySymbol) !Atom.In
1160	}	1173	}
1161		1174
1162	fn updateLazySymbolAtom(self: *Plan9, sym: File.LazySymbol, atom_index: Atom.Index) !void {	1175	fn updateLazySymbolAtom(self: *Plan9, sym: File.LazySymbol, atom_index: Atom.Index) !void {
1163	const gpa = self.base.allocator;	1176	const gpa = self.base.comp.gpa;
1164	const mod = self.base.options.module.?;	1177	const mod = self.base.options.module.?;
1165		1178
1166	var required_alignment: InternPool.Alignment = .none;	1179	var required_alignment: InternPool.Alignment = .none;
...	@@ -1206,8 +1219,8 @@ fn updateLazySymbolAtom(self: *Plan9, sym: File.LazySymbol, atom_index: Atom.Ind	...	@@ -1206,8 +1219,8 @@ fn updateLazySymbolAtom(self: *Plan9, sym: File.LazySymbol, atom_index: Atom.Ind
1206	},	1219	},
1207	};	1220	};
1208	// duped_code is freed when the atom is freed	1221	// duped_code is freed when the atom is freed
1209	const duped_code = try self.base.allocator.dupe(u8, code);	1222	const duped_code = try gpa.dupe(u8, code);
1210	errdefer self.base.allocator.free(duped_code);	1223	errdefer gpa.free(duped_code);
1211	self.getAtomPtr(atom_index).code = .{	1224	self.getAtomPtr(atom_index).code = .{
1212	.code_ptr = duped_code.ptr,	1225	.code_ptr = duped_code.ptr,
1213	.other = .{ .code_len = duped_code.len },	1226	.other = .{ .code_len = duped_code.len },
...	@@ -1215,13 +1228,13 @@ fn updateLazySymbolAtom(self: *Plan9, sym: File.LazySymbol, atom_index: Atom.Ind	...	@@ -1215,13 +1228,13 @@ fn updateLazySymbolAtom(self: *Plan9, sym: File.LazySymbol, atom_index: Atom.Ind
1215	}	1228	}
1216		1229
1217	pub fn deinit(self: *Plan9) void {	1230	pub fn deinit(self: *Plan9) void {
1218	const gpa = self.base.allocator;	1231	const gpa = self.base.comp.gpa;
1219	{	1232	{
1220	var it = self.relocs.valueIterator();	1233	var it = self.relocs.valueIterator();
1221	while (it.next()) \|relocs\| {	1234	while (it.next()) \|relocs\| {
1222	relocs.deinit(self.base.allocator);	1235	relocs.deinit(gpa);
1223	}	1236	}
1224	self.relocs.deinit(self.base.allocator);	1237	self.relocs.deinit(gpa);
1225	}	1238	}
1226	// free the unnamed consts	1239	// free the unnamed consts
1227	var it_unc = self.unnamed_const_atoms.iterator();	1240	var it_unc = self.unnamed_const_atoms.iterator();
...	@@ -1280,24 +1293,36 @@ pub fn deinit(self: *Plan9) void {	...	@@ -1280,24 +1293,36 @@ pub fn deinit(self: *Plan9) void {
1280	}	1293	}
1281	}	1294	}
1282		1295
1283	pub fn openPath(allocator: Allocator, sub_path: []const u8, options: link.Options) !*Plan9 {	1296	pub fn open(arena: Allocator, options: link.File.OpenOptions) !*Plan9 {
1284	if (options.use_llvm)	1297	if (build_options.only_c) unreachable;
1285	return error.LLVMBackendDoesNotSupportPlan9;	1298
1286	assert(options.target.ofmt == .plan9);	1299	const target = options.comp.root_mod.resolved_target.result;
		1300	const use_lld = build_options.have_llvm and options.comp.config.use_lld;
		1301	const use_llvm = options.comp.config.use_llvm;
1287		1302
1288	const self = try createEmpty(allocator, options);	1303	assert(!use_llvm); // Caught by Compilation.Config.resolve.
		1304	assert(!use_lld); // Caught by Compilation.Config.resolve.
		1305	assert(target.ofmt == .plan9);
		1306
		1307	const self = try createEmpty(arena, options);
1289	errdefer self.base.destroy();	1308	errdefer self.base.destroy();
1290		1309
1291	const file = try options.emit.?.directory.handle.createFile(sub_path, .{	1310	const file = try options.emit.directory.handle.createFile(options.emit.sub_path, .{
1292	.read = true,	1311	.read = true,
1293	.mode = link.determineMode(options),	1312	.mode = link.File.determineMode(
		1313	use_lld,
		1314	options.comp.config.output_mode,
		1315	options.comp.config.link_mode,
		1316	),
1294	});	1317	});
1295	errdefer file.close();	1318	errdefer file.close();
1296	self.base.file = file;	1319	self.base.file = file;
1297		1320
1298	self.bases = defaultBaseAddrs(options.target.cpu.arch);	1321	self.bases = defaultBaseAddrs(target.cpu.arch);
		1322
		1323	const gpa = options.comp.gpa;
1299		1324
1300	try self.syms.appendSlice(self.base.allocator, &.{	1325	try self.syms.appendSlice(gpa, &.{
1301	// we include the global offset table to make it easier for debugging	1326	// we include the global offset table to make it easier for debugging
1302	.{	1327	.{
1303	.value = self.getAddr(0, .d), // the global offset table starts at 0	1328	.value = self.getAddr(0, .d), // the global offset table starts at 0
...	@@ -1490,7 +1515,7 @@ pub fn lowerAnonDecl(self: *Plan9, decl_val: InternPool.Index, src_loc: Module.S	...	@@ -1490,7 +1515,7 @@ pub fn lowerAnonDecl(self: *Plan9, decl_val: InternPool.Index, src_loc: Module.S
1490	// be used by more than one function, however, its address is being used so we need	1515	// be used by more than one function, however, its address is being used so we need
1491	// to put it in some location.	1516	// to put it in some location.
1492	// ...	1517	// ...
1493	const gpa = self.base.allocator;	1518	const gpa = self.base.comp.gpa;
1494	const gop = try self.anon_decls.getOrPut(gpa, decl_val);	1519	const gop = try self.anon_decls.getOrPut(gpa, decl_val);
1495	const mod = self.base.options.module.?;	1520	const mod = self.base.options.module.?;
1496	if (!gop.found_existing) {	1521	if (!gop.found_existing) {
...	@@ -1538,11 +1563,12 @@ pub fn getAnonDeclVAddr(self: *Plan9, decl_val: InternPool.Index, reloc_info: li	...	@@ -1538,11 +1563,12 @@ pub fn getAnonDeclVAddr(self: *Plan9, decl_val: InternPool.Index, reloc_info: li
1538	}	1563	}
1539		1564
1540	pub fn addReloc(self: *Plan9, parent_index: Atom.Index, reloc: Reloc) !void {	1565	pub fn addReloc(self: *Plan9, parent_index: Atom.Index, reloc: Reloc) !void {
1541	const gop = try self.relocs.getOrPut(self.base.allocator, parent_index);	1566	const gpa = self.base.comp.gpa;
		1567	const gop = try self.relocs.getOrPut(gpa, parent_index);
1542	if (!gop.found_existing) {	1568	if (!gop.found_existing) {
1543	gop.value_ptr.* = .{};	1569	gop.value_ptr.* = .{};
1544	}	1570	}
1545	try gop.value_ptr.append(self.base.allocator, reloc);	1571	try gop.value_ptr.append(gpa, reloc);
1546	}	1572	}
1547		1573
1548	pub fn getAtom(self: *const Plan9, index: Atom.Index) Atom {	1574	pub fn getAtom(self: *const Plan9, index: Atom.Index) Atom {

src/link/SpirV.zig+36-23

 @@ -47,48 +47,65 @@ base: link.File,
 object: codegen.Object,
-pub fn createEmpty(gpa: Allocator, options: link.Options) !*SpirV {
+pub fn createEmpty(arena: Allocator, options: link.File.OpenOptions) !*SpirV {
-    const self = try gpa.create(SpirV);
+    const gpa = options.comp.gpa;
+    const target = options.comp.root_mod.resolved_target.result;
+    const self = try arena.create(SpirV);
     self.* = .{
         .base = .{
             .tag = .spirv,
-            .options = options,
+            .comp = options.comp,
+            .emit = options.emit,
+            .gc_sections = options.gc_sections orelse false,
+            .stack_size = options.stack_size orelse 0,
+            .allow_shlib_undefined = options.allow_shlib_undefined orelse false,
             .file = null,
-            .allocator = gpa,
+            .disable_lld_caching = options.disable_lld_caching,
+            .build_id = options.build_id,
+            .rpath_list = options.rpath_list,
+            .force_undefined_symbols = options.force_undefined_symbols,
+            .function_sections = options.function_sections,
+            .data_sections = options.data_sections,
         },
         .object = codegen.Object.init(gpa),
     };
     errdefer self.deinit();
-    // TODO: Figure out where to put all of these
+    switch (target.cpu.arch) {
-    switch (options.target.cpu.arch) {
         .spirv32, .spirv64 => {},
-        else => return error.TODOArchNotSupported,
+        else => unreachable, // Caught by Compilation.Config.resolve.
     }
-    switch (options.target.os.tag) {
+    switch (target.os.tag) {
         .opencl, .glsl450, .vulkan => {},
-        else => return error.TODOOsNotSupported,
+        else => unreachable, // Caught by Compilation.Config.resolve.
     }
-    if (options.target.abi != .none) {
+    assert(target.abi != .none); // Caught by Compilation.Config.resolve.
-        return error.TODOAbiNotSupported;
-    }
     return self;
 }
-pub fn openPath(allocator: Allocator, sub_path: []const u8, options: link.Options) !*SpirV {
+pub fn open(arena: Allocator, options: link.File.OpenOptions) !*SpirV {
-    assert(options.target.ofmt == .spirv);
+    if (build_options.only_c) unreachable;
+    const target = options.comp.root_mod.resolved_target.result;
+    const use_lld = build_options.have_llvm and options.comp.config.use_lld;
+    const use_llvm = options.comp.config.use_llvm;
-    if (options.use_llvm) return error.LLVM_BackendIsTODO_ForSpirV; // TODO: LLVM Doesn't support SpirV at all.
+    assert(!use_llvm); // Caught by Compilation.Config.resolve.
-    if (options.use_lld) return error.LLD_LinkingIsTODO_ForSpirV; // TODO: LLD Doesn't support SpirV at all.
+    assert(!use_lld); // Caught by Compilation.Config.resolve.
+    assert(target.ofmt == .spirv); // Caught by Compilation.Config.resolve.
-    const spirv = try createEmpty(allocator, options);
+    const spirv = try createEmpty(arena, options);
     errdefer spirv.base.destroy();
     // TODO: read the file and keep valid parts instead of truncating
-    const file = try options.emit.?.directory.handle.createFile(sub_path, .{ .truncate = true, .read = true });
+    const file = try options.emit.?.directory.handle.createFile(options.emit.sub_path, .{
+        .truncate = true,
+        .read = true,
+    });
     spirv.base.file = file;
     return spirv;
 }
 @@ -150,11 +167,7 @@ pub fn freeDecl(self: *SpirV, decl_index: InternPool.DeclIndex) void {
 }
 pub fn flush(self: *SpirV, comp: *Compilation, prog_node: *std.Progress.Node) link.File.FlushError!void {
-    if (build_options.have_llvm and self.base.options.use_lld) {
+    return self.flushModule(comp, prog_node);
-        return error.LLD_LinkingIsTODO_ForSpirV; // TODO: LLD Doesn't support SpirV at all.
-    } else {
-        return self.flushModule(comp, prog_node);
-    }
 }
 pub fn flushModule(self: *SpirV, comp: *Compilation, prog_node: *std.Progress.Node) link.File.FlushError!void {

src/link/Wasm.zig+398-321

 @@ -191,6 +191,9 @@ synthetic_functions: std.ArrayListUnmanaged(Atom.Index) = .{},
 /// Map for storing anonymous declarations. Each anonymous decl maps to its Atom's index.
 anon_decls: std.AutoArrayHashMapUnmanaged(InternPool.Index, Atom.Index) = .{},
+import_table: bool,
+export_table: bool,
 pub const Alignment = types.Alignment;
 pub const Segment = struct {
 @@ -363,63 +366,71 @@ pub const StringTable = struct {
     }
 };
-pub fn openPath(allocator: Allocator, sub_path: []const u8, options: link.Options) !*Wasm {
+pub fn open(arena: Allocator, options: link.File.OpenOptions) !*Wasm {
-    assert(options.target.ofmt == .wasm);
+    if (build_options.only_c) unreachable;
+    const gpa = options.comp.gpa;
+    const target = options.comp.root_mod.resolved_target.result;
+    assert(target.ofmt == .wasm);
-    if (options.use_llvm and options.use_lld) {
+    const use_lld = build_options.have_llvm and options.comp.config.use_lld;
-        return createEmpty(allocator, options);
+    const use_llvm = options.comp.config.use_llvm;
-    }
+    const output_mode = options.comp.config.output_mode;
-    const wasm_bin = try createEmpty(allocator, options);
+    const wasm = try createEmpty(arena, options);
-    errdefer wasm_bin.base.destroy();
+    errdefer wasm.base.destroy();
-    // We are not using LLD at this point, so ensure we set the intermediary basename
+    if (use_lld and use_llvm) {
-    if (build_options.have_llvm and options.use_llvm and options.module != null) {
+        // LLVM emits the object file; LLD links it into the final product.
-        // TODO this intermediary_basename isn't enough; in the case of `zig build-exe`,
+        return wasm;
-        // we also want to put the intermediary object file in the cache while the
-        // main emit directory is the cwd.
-        wasm_bin.base.intermediary_basename = try std.fmt.allocPrint(allocator, "{s}{s}", .{
-            options.emit.?.sub_path, options.target.ofmt.fileExt(options.target.cpu.arch),
-        });
     }
+    const sub_path = if (!use_lld) options.emit.sub_path else p: {
+        // Open a temporary object file, not the final output file because we
+        // want to link with LLD.
+        const o_file_path = try std.fmt.allocPrint(arena, "{s}{s}", .{
+            options.emit.sub_path, target.ofmt.fileExt(target.cpu.arch),
+        });
+        wasm.base.intermediary_basename = o_file_path;
+        break :p o_file_path;
+    };
     // TODO: read the file and keep valid parts instead of truncating
     const file = try options.emit.?.directory.handle.createFile(sub_path, .{
         .truncate = true,
         .read = true,
         .mode = if (fs.has_executable_bit)
-            if (options.target.os.tag == .wasi and options.output_mode == .Exe)
+            if (target.os.tag == .wasi and output_mode == .Exe)
                 fs.File.default_mode | 0b001_000_000
             else
                 fs.File.default_mode
         else
             0,
     });
-    wasm_bin.base.file = file;
+    wasm.base.file = file;
-    wasm_bin.name = sub_path;
+    wasm.name = sub_path;
     // create stack pointer symbol
     {
-        const loc = try wasm_bin.createSyntheticSymbol("__stack_pointer", .global);
+        const loc = try wasm.createSyntheticSymbol("__stack_pointer", .global);
-        const symbol = loc.getSymbol(wasm_bin);
+        const symbol = loc.getSymbol(wasm);
         // For object files we will import the stack pointer symbol
-        if (options.output_mode == .Obj) {
+        if (output_mode == .Obj) {
             symbol.setUndefined(true);
-            symbol.index = @as(u32, @intCast(wasm_bin.imported_globals_count));
+            symbol.index = @intCast(wasm.imported_globals_count);
-            wasm_bin.imported_globals_count += 1;
+            wasm.imported_globals_count += 1;
-            try wasm_bin.imports.putNoClobber(
+            try wasm.imports.putNoClobber(
-                allocator,
+                gpa,
                 loc,
                 .{
-                    .module_name = try wasm_bin.string_table.put(allocator, wasm_bin.host_name),
+                    .module_name = try wasm.string_table.put(gpa, wasm.host_name),
                     .name = symbol.name,
                     .kind = .{ .global = .{ .valtype = .i32, .mutable = true } },
                 },
             );
         } else {
-            symbol.index = @intCast(wasm_bin.imported_globals_count + wasm_bin.wasm_globals.items.len);
+            symbol.index = @intCast(wasm.imported_globals_count + wasm.wasm_globals.items.len);
             symbol.setFlag(.WASM_SYM_VISIBILITY_HIDDEN);
-            const global = try wasm_bin.wasm_globals.addOne(allocator);
+            const global = try wasm.wasm_globals.addOne(gpa);
             global.* = .{
                 .global_type = .{
                     .valtype = .i32,
 @@ -432,25 +443,25 @@ pub fn openPath(allocator: Allocator, sub_path: []const u8, options: link.Option
     // create indirect function pointer symbol
     {
-        const loc = try wasm_bin.createSyntheticSymbol("__indirect_function_table", .table);
+        const loc = try wasm.createSyntheticSymbol("__indirect_function_table", .table);
-        const symbol = loc.getSymbol(wasm_bin);
+        const symbol = loc.getSymbol(wasm);
         const table: std.wasm.Table = .{
             .limits = .{ .flags = 0, .min = 0, .max = undefined }, // will be overwritten during `mapFunctionTable`
             .reftype = .funcref,
         };
-        if (options.output_mode == .Obj or options.import_table) {
+        if (output_mode == .Obj or options.import_table) {
             symbol.setUndefined(true);
-            symbol.index = @intCast(wasm_bin.imported_tables_count);
+            symbol.index = @intCast(wasm.imported_tables_count);
-            wasm_bin.imported_tables_count += 1;
+            wasm.imported_tables_count += 1;
-            try wasm_bin.imports.put(allocator, loc, .{
+            try wasm.imports.put(gpa, loc, .{
-                .module_name = try wasm_bin.string_table.put(allocator, wasm_bin.host_name),
+                .module_name = try wasm.string_table.put(gpa, wasm.host_name),
                 .name = symbol.name,
                 .kind = .{ .table = table },
             });
         } else {
-            symbol.index = @as(u32, @intCast(wasm_bin.imported_tables_count + wasm_bin.tables.items.len));
+            symbol.index = @as(u32, @intCast(wasm.imported_tables_count + wasm.tables.items.len));
-            try wasm_bin.tables.append(allocator, table);
+            try wasm.tables.append(gpa, table);
-            if (options.export_table) {
+            if (wasm.export_table) {
                 symbol.setFlag(.WASM_SYM_EXPORTED);
             } else {
                 symbol.setFlag(.WASM_SYM_VISIBILITY_HIDDEN);
 @@ -460,8 +471,8 @@ pub fn openPath(allocator: Allocator, sub_path: []const u8, options: link.Option
     // create __wasm_call_ctors
     {
-        const loc = try wasm_bin.createSyntheticSymbol("__wasm_call_ctors", .function);
+        const loc = try wasm.createSyntheticSymbol("__wasm_call_ctors", .function);
-        const symbol = loc.getSymbol(wasm_bin);
+        const symbol = loc.getSymbol(wasm);
         symbol.setFlag(.WASM_SYM_VISIBILITY_HIDDEN);
         // we do not know the function index until after we merged all sections.
         // Therefore we set `symbol.index` and create its corresponding references
 @@ -469,67 +480,76 @@ pub fn openPath(allocator: Allocator, sub_path: []const u8, options: link.Option
     }
     // shared-memory symbols for TLS support
-    if (wasm_bin.base.options.shared_memory) {
+    if (wasm.base.options.shared_memory) {
         {
-            const loc = try wasm_bin.createSyntheticSymbol("__tls_base", .global);
+            const loc = try wasm.createSyntheticSymbol("__tls_base", .global);
-            const symbol = loc.getSymbol(wasm_bin);
+            const symbol = loc.getSymbol(wasm);
             symbol.setFlag(.WASM_SYM_VISIBILITY_HIDDEN);
-            symbol.index = @intCast(wasm_bin.imported_globals_count + wasm_bin.wasm_globals.items.len);
+            symbol.index = @intCast(wasm.imported_globals_count + wasm.wasm_globals.items.len);
-            try wasm_bin.wasm_globals.append(wasm_bin.base.allocator, .{
+            try wasm.wasm_globals.append(gpa, .{
                 .global_type = .{ .valtype = .i32, .mutable = true },
                 .init = .{ .i32_const = undefined },
             });
         }
         {
-            const loc = try wasm_bin.createSyntheticSymbol("__tls_size", .global);
+            const loc = try wasm.createSyntheticSymbol("__tls_size", .global);
-            const symbol = loc.getSymbol(wasm_bin);
+            const symbol = loc.getSymbol(wasm);
             symbol.setFlag(.WASM_SYM_VISIBILITY_HIDDEN);
-            symbol.index = @intCast(wasm_bin.imported_globals_count + wasm_bin.wasm_globals.items.len);
+            symbol.index = @intCast(wasm.imported_globals_count + wasm.wasm_globals.items.len);
-            try wasm_bin.wasm_globals.append(wasm_bin.base.allocator, .{
+            try wasm.wasm_globals.append(gpa, .{
                 .global_type = .{ .valtype = .i32, .mutable = false },
                 .init = .{ .i32_const = undefined },
             });
         }
         {
-            const loc = try wasm_bin.createSyntheticSymbol("__tls_align", .global);
+            const loc = try wasm.createSyntheticSymbol("__tls_align", .global);
-            const symbol = loc.getSymbol(wasm_bin);
+            const symbol = loc.getSymbol(wasm);
             symbol.setFlag(.WASM_SYM_VISIBILITY_HIDDEN);
-            symbol.index = @intCast(wasm_bin.imported_globals_count + wasm_bin.wasm_globals.items.len);
+            symbol.index = @intCast(wasm.imported_globals_count + wasm.wasm_globals.items.len);
-            try wasm_bin.wasm_globals.append(wasm_bin.base.allocator, .{
+            try wasm.wasm_globals.append(gpa, .{
                 .global_type = .{ .valtype = .i32, .mutable = false },
                 .init = .{ .i32_const = undefined },
             });
         }
         {
-            const loc = try wasm_bin.createSyntheticSymbol("__wasm_init_tls", .function);
+            const loc = try wasm.createSyntheticSymbol("__wasm_init_tls", .function);
-            const symbol = loc.getSymbol(wasm_bin);
+            const symbol = loc.getSymbol(wasm);
             symbol.setFlag(.WASM_SYM_VISIBILITY_HIDDEN);
         }
     }
-    // if (!options.strip and options.module != null) {
+    return wasm;
-    //     wasm_bin.dwarf = Dwarf.init(allocator, &wasm_bin.base, .dwarf32);
-    //     try wasm_bin.initDebugSections();
-    // }
-    return wasm_bin;
 }
-pub fn createEmpty(gpa: Allocator, options: link.Options) !*Wasm {
+pub fn createEmpty(arena: Allocator, options: link.File.OpenOptions) !*Wasm {
-    const wasm = try gpa.create(Wasm);
+    const use_llvm = options.comp.config.use_llvm;
-    errdefer gpa.destroy(wasm);
+    const output_mode = options.comp.config.output_mode;
+    const wasm = try arena.create(Wasm);
     wasm.* = .{
         .base = .{
             .tag = .wasm,
-            .options = options,
+            .comp = options.comp,
+            .emit = options.emit,
+            .gc_sections = options.gc_sections orelse (output_mode != .Obj),
+            .stack_size = options.stack_size orelse std.wasm.page_size * 16, // 1MB
+            .allow_shlib_undefined = options.allow_shlib_undefined orelse false,
             .file = null,
-            .allocator = gpa,
+            .disable_lld_caching = options.disable_lld_caching,
+            .build_id = options.build_id,
+            .rpath_list = options.rpath_list,
+            .force_undefined_symbols = options.force_undefined_symbols,
+            .debug_format = options.debug_format orelse .{ .dwarf = .@"32" },
+            .function_sections = options.function_sections,
+            .data_sections = options.data_sections,
         },
         .name = undefined,
+        .import_table = options.import_table,
+        .export_table = options.export_table,
     };
-    if (options.use_llvm) {
+    if (use_llvm) {
-        wasm.llvm_object = try LlvmObject.create(gpa, options);
+        wasm.llvm_object = try LlvmObject.create(arena, options);
     }
     return wasm;
 }
 @@ -537,22 +557,24 @@ pub fn createEmpty(gpa: Allocator, options: link.Options) !*Wasm {
 /// For a given name, creates a new global synthetic symbol.
 /// Leaves index undefined and the default flags (0).
 fn createSyntheticSymbol(wasm: *Wasm, name: []const u8, tag: Symbol.Tag) !SymbolLoc {
-    const name_offset = try wasm.string_table.put(wasm.base.allocator, name);
+    const gpa = wasm.base.comp.gpa;
+    const name_offset = try wasm.string_table.put(gpa, name);
     return wasm.createSyntheticSymbolOffset(name_offset, tag);
 }
 fn createSyntheticSymbolOffset(wasm: *Wasm, name_offset: u32, tag: Symbol.Tag) !SymbolLoc {
     const sym_index = @as(u32, @intCast(wasm.symbols.items.len));
     const loc: SymbolLoc = .{ .index = sym_index, .file = null };
-    try wasm.symbols.append(wasm.base.allocator, .{
+    const gpa = wasm.base.comp.gpa;
+    try wasm.symbols.append(gpa, .{
         .name = name_offset,
         .flags = 0,
         .tag = tag,
         .index = undefined,
         .virtual_address = undefined,
     });
-    try wasm.resolved_symbols.putNoClobber(wasm.base.allocator, loc, {});
+    try wasm.resolved_symbols.putNoClobber(gpa, loc, {});
-    try wasm.globals.put(wasm.base.allocator, name_offset, loc);
+    try wasm.globals.put(gpa, name_offset, loc);
     return loc;
 }
 @@ -589,12 +611,13 @@ fn parseObjectFile(wasm: *Wasm, path: []const u8) !bool {
     const file = try fs.cwd().openFile(path, .{});
     errdefer file.close();
-    var object = Object.create(wasm.base.allocator, file, path, null) catch |err| switch (err) {
+    const gpa = wasm.base.comp.gpa;
+    var object = Object.create(gpa, file, path, null) catch |err| switch (err) {
         error.InvalidMagicByte, error.NotObjectFile => return false,
         else => |e| return e,
     };
-    errdefer object.deinit(wasm.base.allocator);
+    errdefer object.deinit(gpa);
-    try wasm.objects.append(wasm.base.allocator, object);
+    try wasm.objects.append(gpa, object);
     return true;
 }
 @@ -602,7 +625,8 @@ fn parseObjectFile(wasm: *Wasm, path: []const u8) !bool {
 /// When the index was not found, a new `Atom` will be created, and its index will be returned.
 /// The newly created Atom is empty with default fields as specified by `Atom.empty`.
 pub fn getOrCreateAtomForDecl(wasm: *Wasm, decl_index: InternPool.DeclIndex) !Atom.Index {
-    const gop = try wasm.decls.getOrPut(wasm.base.allocator, decl_index);
+    const gpa = wasm.base.comp.gpa;
+    const gop = try wasm.decls.getOrPut(gpa, decl_index);
     if (!gop.found_existing) {
         const atom_index = try wasm.createAtom();
         gop.value_ptr.* = atom_index;
 @@ -611,18 +635,19 @@ pub fn getOrCreateAtomForDecl(wasm: *Wasm, decl_index: InternPool.DeclIndex) !At
         const mod = wasm.base.options.module.?;
         const decl = mod.declPtr(decl_index);
         const full_name = mod.intern_pool.stringToSlice(try decl.getFullyQualifiedName(mod));
-        symbol.name = try wasm.string_table.put(wasm.base.allocator, full_name);
+        symbol.name = try wasm.string_table.put(gpa, full_name);
     }
     return gop.value_ptr.*;
 }
 /// Creates a new empty `Atom` and returns its `Atom.Index`
 fn createAtom(wasm: *Wasm) !Atom.Index {
-    const index = @as(Atom.Index, @intCast(wasm.managed_atoms.items.len));
+    const gpa = wasm.base.comp.gpa;
-    const atom = try wasm.managed_atoms.addOne(wasm.base.allocator);
+    const index: Atom.Index = @intCast(wasm.managed_atoms.items.len);
+    const atom = try wasm.managed_atoms.addOne(gpa);
     atom.* = Atom.empty;
     atom.sym_index = try wasm.allocateSymbol();
-    try wasm.symbol_atom.putNoClobber(wasm.base.allocator, .{ .file = null, .index = atom.sym_index }, index);
+    try wasm.symbol_atom.putNoClobber(gpa, .{ .file = null, .index = atom.sym_index }, index);
     return index;
 }
 @@ -644,6 +669,8 @@ pub inline fn getAtomPtr(wasm: *Wasm, index: Atom.Index) *Atom {
 /// When false, it will only link with object files that contain symbols that
 /// are referenced by other object files or Zig code.
 fn parseArchive(wasm: *Wasm, path: []const u8, force_load: bool) !bool {
+    const gpa = wasm.base.comp.gpa;
     const file = try fs.cwd().openFile(path, .{});
     errdefer file.close();
 @@ -651,25 +678,25 @@ fn parseArchive(wasm: *Wasm, path: []const u8, force_load: bool) !bool {
         .file = file,
         .name = path,
     };
-    archive.parse(wasm.base.allocator) catch |err| switch (err) {
+    archive.parse(gpa) catch |err| switch (err) {
         error.EndOfStream, error.NotArchive => {
-            archive.deinit(wasm.base.allocator);
+            archive.deinit(gpa);
             return false;
         },
         else => |e| return e,
     };
     if (!force_load) {
-        errdefer archive.deinit(wasm.base.allocator);
+        errdefer archive.deinit(gpa);
-        try wasm.archives.append(wasm.base.allocator, archive);
+        try wasm.archives.append(gpa, archive);
         return true;
     }
-    defer archive.deinit(wasm.base.allocator);
+    defer archive.deinit(gpa);
     // In this case we must force link all embedded object files within the archive
     // We loop over all symbols, and then group them by offset as the offset
     // notates where the object file starts.
-    var offsets = std.AutoArrayHashMap(u32, void).init(wasm.base.allocator);
+    var offsets = std.AutoArrayHashMap(u32, void).init(gpa);
     defer offsets.deinit();
     for (archive.toc.values()) |symbol_offsets| {
         for (symbol_offsets.items) |sym_offset| {
 @@ -678,8 +705,8 @@ fn parseArchive(wasm: *Wasm, path: []const u8, force_load: bool) !bool {
     }
     for (offsets.keys()) |file_offset| {
-        const object = try wasm.objects.addOne(wasm.base.allocator);
+        const object = try wasm.objects.addOne(gpa);
-        object.* = try archive.parseObject(wasm.base.allocator, file_offset);
+        object.* = try archive.parseObject(gpa, file_offset);
     }
     return true;
 @@ -695,6 +722,7 @@ fn requiresTLSReloc(wasm: *const Wasm) bool {
 }
 fn resolveSymbolsInObject(wasm: *Wasm, object_index: u16) !void {
+    const gpa = wasm.base.comp.gpa;
     const object: Object = wasm.objects.items[object_index];
     log.debug("Resolving symbols in object: '{s}'", .{object.name});
 @@ -708,7 +736,7 @@ fn resolveSymbolsInObject(wasm: *Wasm, object_index: u16) !void {
         if (mem.eql(u8, sym_name, "__indirect_function_table")) {
             continue;
         }
-        const sym_name_index = try wasm.string_table.put(wasm.base.allocator, sym_name);
+        const sym_name_index = try wasm.string_table.put(gpa, sym_name);
         if (symbol.isLocal()) {
             if (symbol.isUndefined()) {
 @@ -716,17 +744,17 @@ fn resolveSymbolsInObject(wasm: *Wasm, object_index: u16) !void {
                 log.err("  symbol '{s}' defined in '{s}'", .{ sym_name, object.name });
                 return error.UndefinedLocal;
             }
-            try wasm.resolved_symbols.putNoClobber(wasm.base.allocator, location, {});
+            try wasm.resolved_symbols.putNoClobber(gpa, location, {});
             continue;
         }
-        const maybe_existing = try wasm.globals.getOrPut(wasm.base.allocator, sym_name_index);
+        const maybe_existing = try wasm.globals.getOrPut(gpa, sym_name_index);
         if (!maybe_existing.found_existing) {
             maybe_existing.value_ptr.* = location;
-            try wasm.resolved_symbols.putNoClobber(wasm.base.allocator, location, {});
+            try wasm.resolved_symbols.putNoClobber(gpa, location, {});
             if (symbol.isUndefined()) {
-                try wasm.undefs.putNoClobber(wasm.base.allocator, sym_name_index, location);
+                try wasm.undefs.putNoClobber(gpa, sym_name_index, location);
             }
             continue;
         }
 @@ -753,7 +781,7 @@ fn resolveSymbolsInObject(wasm: *Wasm, object_index: u16) !void {
                 return error.SymbolCollision;
             }
-            try wasm.discarded.put(wasm.base.allocator, location, existing_loc);
+            try wasm.discarded.put(gpa, location, existing_loc);
             continue; // Do not overwrite defined symbols with undefined symbols
         }
 @@ -791,7 +819,7 @@ fn resolveSymbolsInObject(wasm: *Wasm, object_index: u16) !void {
             }
             // both undefined so skip overwriting existing symbol and discard the new symbol
-            try wasm.discarded.put(wasm.base.allocator, location, existing_loc);
+            try wasm.discarded.put(gpa, location, existing_loc);
             continue;
         }
 @@ -822,7 +850,7 @@ fn resolveSymbolsInObject(wasm: *Wasm, object_index: u16) !void {
         // symbol is weak and the new one isn't, in which case we *do* overwrite it.
         if (existing_sym.isWeak() and symbol.isWeak()) blk: {
             if (existing_sym.isUndefined() and !symbol.isUndefined()) break :blk;
-            try wasm.discarded.put(wasm.base.allocator, location, existing_loc);
+            try wasm.discarded.put(gpa, location, existing_loc);
             continue;
         }
 @@ -830,10 +858,10 @@ fn resolveSymbolsInObject(wasm: *Wasm, object_index: u16) !void {
         log.debug("Overwriting symbol '{s}'", .{sym_name});
         log.debug("  old definition in '{s}'", .{existing_file_path});
         log.debug("  new definition in '{s}'", .{object.name});
-        try wasm.discarded.putNoClobber(wasm.base.allocator, existing_loc, location);
+        try wasm.discarded.putNoClobber(gpa, existing_loc, location);
         maybe_existing.value_ptr.* = location;
-        try wasm.globals.put(wasm.base.allocator, sym_name_index, location);
+        try wasm.globals.put(gpa, sym_name_index, location);
-        try wasm.resolved_symbols.put(wasm.base.allocator, location, {});
+        try wasm.resolved_symbols.put(gpa, location, {});
         assert(wasm.resolved_symbols.swapRemove(existing_loc));
         if (existing_sym.isUndefined()) {
             _ = wasm.undefs.swapRemove(sym_name_index);
 @@ -842,6 +870,7 @@ fn resolveSymbolsInObject(wasm: *Wasm, object_index: u16) !void {
 }
 fn resolveSymbolsInArchives(wasm: *Wasm) !void {
+    const gpa = wasm.base.comp.gpa;
     if (wasm.archives.items.len == 0) return;
     log.debug("Resolving symbols in archives", .{});
 @@ -860,9 +889,9 @@ fn resolveSymbolsInArchives(wasm: *Wasm) !void {
             // Symbol is found in unparsed object file within current archive.
             // Parse object and and resolve symbols again before we check remaining
             // undefined symbols.
-            const object_file_index = @as(u16, @intCast(wasm.objects.items.len));
+            const object_file_index: u16 = @intCast(wasm.objects.items.len);
-            const object = try archive.parseObject(wasm.base.allocator, offset.items[0]);
+            const object = try archive.parseObject(gpa, offset.items[0]);
-            try wasm.objects.append(wasm.base.allocator, object);
+            try wasm.objects.append(gpa, object);
             try wasm.resolveSymbolsInObject(object_file_index);
             // continue loop for any remaining undefined symbols that still exist
 @@ -880,6 +909,8 @@ fn writeI32Const(writer: anytype, val: u32) !void {
 }
 fn setupInitMemoryFunction(wasm: *Wasm) !void {
+    const gpa = wasm.base.comp.gpa;
     // Passive segments are used to avoid memory being reinitialized on each
     // thread's instantiation. These passive segments are initialized and
     // dropped in __wasm_init_memory, which is registered as the start function
 @@ -896,7 +927,7 @@ fn setupInitMemoryFunction(wasm: *Wasm) !void {
         break :address loc.getSymbol(wasm).virtual_address;
     } else 0;
-    var function_body = std.ArrayList(u8).init(wasm.base.allocator);
+    var function_body = std.ArrayList(u8).init(gpa);
     defer function_body.deinit();
     const writer = function_body.writer();
 @@ -1040,6 +1071,8 @@ fn setupInitMemoryFunction(wasm: *Wasm) !void {
 /// Constructs a synthetic function that performs runtime relocations for
 /// TLS symbols. This function is called by `__wasm_init_tls`.
 fn setupTLSRelocationsFunction(wasm: *Wasm) !void {
+    const gpa = wasm.base.comp.gpa;
     // When we have TLS GOT entries and shared memory is enabled,
     // we must perform runtime relocations or else we don't create the function.
     if (!wasm.base.options.shared_memory or !wasm.requiresTLSReloc()) {
 @@ -1047,7 +1080,7 @@ fn setupTLSRelocationsFunction(wasm: *Wasm) !void {
     }
     // const loc = try wasm.createSyntheticSymbol("__wasm_apply_global_tls_relocs");
-    var function_body = std.ArrayList(u8).init(wasm.base.allocator);
+    var function_body = std.ArrayList(u8).init(gpa);
     defer function_body.deinit();
     const writer = function_body.writer();
 @@ -1221,10 +1254,12 @@ fn validateFeatures(
 /// if one or multiple undefined references exist. When none exist, the symbol will
 /// not be created, ensuring we don't unneccesarily emit unreferenced symbols.
 fn resolveLazySymbols(wasm: *Wasm) !void {
+    const gpa = wasm.base.comp.gpa;
     if (wasm.string_table.getOffset("__heap_base")) |name_offset| {
         if (wasm.undefs.fetchSwapRemove(name_offset)) |kv| {
             const loc = try wasm.createSyntheticSymbolOffset(name_offset, .data);
-            try wasm.discarded.putNoClobber(wasm.base.allocator, kv.value, loc);
+            try wasm.discarded.putNoClobber(gpa, kv.value, loc);
             _ = wasm.resolved_symbols.swapRemove(loc); // we don't want to emit this symbol, only use it for relocations.
         }
     }
 @@ -1232,7 +1267,7 @@ fn resolveLazySymbols(wasm: *Wasm) !void {
     if (wasm.string_table.getOffset("__heap_end")) |name_offset| {
         if (wasm.undefs.fetchSwapRemove(name_offset)) |kv| {
             const loc = try wasm.createSyntheticSymbolOffset(name_offset, .data);
-            try wasm.discarded.putNoClobber(wasm.base.allocator, kv.value, loc);
+            try wasm.discarded.putNoClobber(gpa, kv.value, loc);
             _ = wasm.resolved_symbols.swapRemove(loc);
         }
     }
 @@ -1241,12 +1276,12 @@ fn resolveLazySymbols(wasm: *Wasm) !void {
         if (wasm.string_table.getOffset("__tls_base")) |name_offset| {
             if (wasm.undefs.fetchSwapRemove(name_offset)) |kv| {
                 const loc = try wasm.createSyntheticSymbolOffset(name_offset, .global);
-                try wasm.discarded.putNoClobber(wasm.base.allocator, kv.value, loc);
+                try wasm.discarded.putNoClobber(gpa, kv.value, loc);
                 _ = wasm.resolved_symbols.swapRemove(kv.value);
                 const symbol = loc.getSymbol(wasm);
                 symbol.setFlag(.WASM_SYM_VISIBILITY_HIDDEN);
                 symbol.index = @intCast(wasm.imported_globals_count + wasm.wasm_globals.items.len);
-                try wasm.wasm_globals.append(wasm.base.allocator, .{
+                try wasm.wasm_globals.append(gpa, .{
                     .global_type = .{ .valtype = .i32, .mutable = true },
                     .init = .{ .i32_const = undefined },
                 });
 @@ -1256,7 +1291,7 @@ fn resolveLazySymbols(wasm: *Wasm) !void {
     if (wasm.string_table.getOffset("__zig_errors_len")) |name_offset| {
         if (wasm.undefs.fetchSwapRemove(name_offset)) |kv| {
             const loc = try wasm.createSyntheticSymbolOffset(name_offset, .data);
-            try wasm.discarded.putNoClobber(wasm.base.allocator, kv.value, loc);
+            try wasm.discarded.putNoClobber(gpa, kv.value, loc);
             _ = wasm.resolved_symbols.swapRemove(kv.value);
         }
     }
 @@ -1292,8 +1327,8 @@ fn checkUndefinedSymbols(wasm: *const Wasm) !void {
 }
 pub fn deinit(wasm: *Wasm) void {
-    const gpa = wasm.base.allocator;
+    const gpa = wasm.base.comp.gpa;
-    if (wasm.llvm_object) |llvm_object| llvm_object.destroy(gpa);
+    if (wasm.llvm_object) |llvm_object| llvm_object.deinit();
     for (wasm.func_types.items) |*func_type| {
         func_type.deinit(gpa);
 @@ -1378,7 +1413,9 @@ pub fn deinit(wasm: *Wasm) void {
 /// Allocates a new symbol and returns its index.
 /// Will re-use slots when a symbol was freed at an earlier stage.
 pub fn allocateSymbol(wasm: *Wasm) !u32 {
-    try wasm.symbols.ensureUnusedCapacity(wasm.base.allocator, 1);
+    const gpa = wasm.base.comp.gpa;
+    try wasm.symbols.ensureUnusedCapacity(gpa, 1);
     const symbol: Symbol = .{
         .name = std.math.maxInt(u32), // will be set after updateDecl as well as during atom creation for decls
         .flags = @intFromEnum(Symbol.Flag.WASM_SYM_BINDING_LOCAL),
 @@ -1404,6 +1441,7 @@ pub fn updateFunc(wasm: *Wasm, mod: *Module, func_index: InternPool.Index, air:
     const tracy = trace(@src());
     defer tracy.end();
+    const gpa = wasm.base.comp.gpa;
     const func = mod.funcInfo(func_index);
     const decl_index = func.owner_decl;
     const decl = mod.declPtr(decl_index);
 @@ -1414,7 +1452,7 @@ pub fn updateFunc(wasm: *Wasm, mod: *Module, func_index: InternPool.Index, air:
     // var decl_state: ?Dwarf.DeclState = if (wasm.dwarf) |*dwarf| try dwarf.initDeclState(mod, decl_index) else null;
     // defer if (decl_state) |*ds| ds.deinit();
-    var code_writer = std.ArrayList(u8).init(wasm.base.allocator);
+    var code_writer = std.ArrayList(u8).init(gpa);
     defer code_writer.deinit();
     // const result = try codegen.generateFunction(
     //     &wasm.base,
 @@ -1477,6 +1515,7 @@ pub fn updateDecl(wasm: *Wasm, mod: *Module, decl_index: InternPool.DeclIndex) !
         return;
     }
+    const gpa = wasm.base.comp.gpa;
     const atom_index = try wasm.getOrCreateAtomForDecl(decl_index);
     const atom = wasm.getAtomPtr(atom_index);
     atom.clear();
 @@ -1489,7 +1528,7 @@ pub fn updateDecl(wasm: *Wasm, mod: *Module, decl_index: InternPool.DeclIndex) !
     }
     const val = if (decl.val.getVariable(mod)) |variable| Value.fromInterned(variable.init) else decl.val;
-    var code_writer = std.ArrayList(u8).init(wasm.base.allocator);
+    var code_writer = std.ArrayList(u8).init(gpa);
     defer code_writer.deinit();
     const res = try codegen.generateSymbol(
 @@ -1528,16 +1567,17 @@ pub fn updateDeclLineNumber(wasm: *Wasm, mod: *Module, decl_index: InternPool.De
 }
 fn finishUpdateDecl(wasm: *Wasm, decl_index: InternPool.DeclIndex, code: []const u8, symbol_tag: Symbol.Tag) !void {
+    const gpa = wasm.base.comp.gpa;
     const mod = wasm.base.options.module.?;
     const decl = mod.declPtr(decl_index);
     const atom_index = wasm.decls.get(decl_index).?;
     const atom = wasm.getAtomPtr(atom_index);
     const symbol = &wasm.symbols.items[atom.sym_index];
     const full_name = mod.intern_pool.stringToSlice(try decl.getFullyQualifiedName(mod));
-    symbol.name = try wasm.string_table.put(wasm.base.allocator, full_name);
+    symbol.name = try wasm.string_table.put(gpa, full_name);
     symbol.tag = symbol_tag;
-    try atom.code.appendSlice(wasm.base.allocator, code);
+    try atom.code.appendSlice(gpa, code);
-    try wasm.resolved_symbols.put(wasm.base.allocator, atom.symbolLoc(), {});
+    try wasm.resolved_symbols.put(gpa, atom.symbolLoc(), {});
     atom.size = @intCast(code.len);
     if (code.len == 0) return;
 @@ -1591,6 +1631,7 @@ fn getFunctionSignature(wasm: *const Wasm, loc: SymbolLoc) std.wasm.Type {
 /// Returns the symbol index of the local
 /// The given `decl` is the parent decl whom owns the constant.
 pub fn lowerUnnamedConst(wasm: *Wasm, tv: TypedValue, decl_index: InternPool.DeclIndex) !u32 {
+    const gpa = wasm.base.comp.gpa;
     const mod = wasm.base.options.module.?;
     assert(tv.ty.zigTypeTag(mod) != .Fn); // cannot create local symbols for functions
     const decl = mod.declPtr(decl_index);
 @@ -1599,14 +1640,14 @@ pub fn lowerUnnamedConst(wasm: *Wasm, tv: TypedValue, decl_index: InternPool.Dec
     const parent_atom = wasm.getAtom(parent_atom_index);
     const local_index = parent_atom.locals.items.len;
     const fqn = mod.intern_pool.stringToSlice(try decl.getFullyQualifiedName(mod));
-    const name = try std.fmt.allocPrintZ(wasm.base.allocator, "__unnamed_{s}_{d}", .{
+    const name = try std.fmt.allocPrintZ(gpa, "__unnamed_{s}_{d}", .{
         fqn, local_index,
     });
-    defer wasm.base.allocator.free(name);
+    defer gpa.free(name);
     switch (try wasm.lowerConst(name, tv, decl.srcLoc(mod))) {
         .ok => |atom_index| {
-            try wasm.getAtomPtr(parent_atom_index).locals.append(wasm.base.allocator, atom_index);
+            try wasm.getAtomPtr(parent_atom_index).locals.append(gpa, atom_index);
             return wasm.getAtom(atom_index).getSymbolIndex().?;
         },
         .fail => |em| {
 @@ -1623,24 +1664,25 @@ const LowerConstResult = union(enum) {
 };
 fn lowerConst(wasm: *Wasm, name: []const u8, tv: TypedValue, src_loc: Module.SrcLoc) !LowerConstResult {
+    const gpa = wasm.base.comp.gpa;
     const mod = wasm.base.options.module.?;
     // Create and initialize a new local symbol and atom
     const atom_index = try wasm.createAtom();
-    var value_bytes = std.ArrayList(u8).init(wasm.base.allocator);
+    var value_bytes = std.ArrayList(u8).init(gpa);
     defer value_bytes.deinit();
     const code = code: {
         const atom = wasm.getAtomPtr(atom_index);
         atom.alignment = tv.ty.abiAlignment(mod);
         wasm.symbols.items[atom.sym_index] = .{
-            .name = try wasm.string_table.put(wasm.base.allocator, name),
+            .name = try wasm.string_table.put(gpa, name),
             .flags = @intFromEnum(Symbol.Flag.WASM_SYM_BINDING_LOCAL),
             .tag = .data,
             .index = undefined,
             .virtual_address = undefined,
         };
-        try wasm.resolved_symbols.putNoClobber(wasm.base.allocator, atom.symbolLoc(), {});
+        try wasm.resolved_symbols.putNoClobber(gpa, atom.symbolLoc(), {});
         const result = try codegen.generateSymbol(
             &wasm.base,
 @@ -1663,7 +1705,7 @@ fn lowerConst(wasm: *Wasm, name: []const u8, tv: TypedValue, src_loc: Module.Src
     const atom = wasm.getAtomPtr(atom_index);
     atom.size = @intCast(code.len);
-    try atom.code.appendSlice(wasm.base.allocator, code);
+    try atom.code.appendSlice(gpa, code);
     return .{ .ok = atom_index };
 }
 @@ -1673,8 +1715,9 @@ fn lowerConst(wasm: *Wasm, name: []const u8, tv: TypedValue, src_loc: Module.Src
 /// and then returns the index to it.
 pub fn getGlobalSymbol(wasm: *Wasm, name: []const u8, lib_name: ?[]const u8) !u32 {
     _ = lib_name;
-    const name_index = try wasm.string_table.put(wasm.base.allocator, name);
+    const gpa = wasm.base.comp.gpa;
-    const gop = try wasm.globals.getOrPut(wasm.base.allocator, name_index);
+    const name_index = try wasm.string_table.put(gpa, name);
+    const gop = try wasm.globals.getOrPut(gpa, name_index);
     if (gop.found_existing) {
         return gop.value_ptr.*.index;
     }
 @@ -1691,14 +1734,14 @@ pub fn getGlobalSymbol(wasm: *Wasm, name: []const u8, lib_name: ?[]const u8) !u3
     const sym_index = if (wasm.symbols_free_list.popOrNull()) |index| index else blk: {
         const index: u32 = @intCast(wasm.symbols.items.len);
-        try wasm.symbols.ensureUnusedCapacity(wasm.base.allocator, 1);
+        try wasm.symbols.ensureUnusedCapacity(gpa, 1);
         wasm.symbols.items.len += 1;
         break :blk index;
     };
     wasm.symbols.items[sym_index] = symbol;
     gop.value_ptr.* = .{ .index = sym_index, .file = null };
-    try wasm.resolved_symbols.put(wasm.base.allocator, gop.value_ptr.*, {});
+    try wasm.resolved_symbols.put(gpa, gop.value_ptr.*, {});
-    try wasm.undefs.putNoClobber(wasm.base.allocator, name_index, gop.value_ptr.*);
+    try wasm.undefs.putNoClobber(gpa, name_index, gop.value_ptr.*);
     return sym_index;
 }
 @@ -1709,6 +1752,7 @@ pub fn getDeclVAddr(
     decl_index: InternPool.DeclIndex,
     reloc_info: link.File.RelocInfo,
 ) !u64 {
+    const gpa = wasm.base.comp.gpa;
     const mod = wasm.base.options.module.?;
     const decl = mod.declPtr(decl_index);
 @@ -1725,17 +1769,17 @@ pub fn getDeclVAddr(
         // as function pointers are not allowed to be stored inside the data section.
         // They are instead stored in a function table which are called by index.
         try wasm.addTableFunction(target_symbol_index);
-        try atom.relocs.append(wasm.base.allocator, .{
+        try atom.relocs.append(gpa, .{
             .index = target_symbol_index,
-            .offset = @as(u32, @intCast(reloc_info.offset)),
+            .offset = @intCast(reloc_info.offset),
             .relocation_type = if (is_wasm32) .R_WASM_TABLE_INDEX_I32 else .R_WASM_TABLE_INDEX_I64,
         });
     } else {
-        try atom.relocs.append(wasm.base.allocator, .{
+        try atom.relocs.append(gpa, .{
             .index = target_symbol_index,
-            .offset = @as(u32, @intCast(reloc_info.offset)),
+            .offset = @intCast(reloc_info.offset),
             .relocation_type = if (is_wasm32) .R_WASM_MEMORY_ADDR_I32 else .R_WASM_MEMORY_ADDR_I64,
-            .addend = @as(i32, @intCast(reloc_info.addend)),
+            .addend = @intCast(reloc_info.addend),
         });
     }
     // we do not know the final address at this point,
 @@ -1751,7 +1795,8 @@ pub fn lowerAnonDecl(
     explicit_alignment: Alignment,
     src_loc: Module.SrcLoc,
 ) !codegen.Result {
-    const gop = try wasm.anon_decls.getOrPut(wasm.base.allocator, decl_val);
+    const gpa = wasm.base.comp.gpa;
+    const gop = try wasm.anon_decls.getOrPut(gpa, decl_val);
     if (!gop.found_existing) {
         const mod = wasm.base.options.module.?;
         const ty = Type.fromInterned(mod.intern_pool.typeOf(decl_val));
 @@ -1779,6 +1824,7 @@ pub fn lowerAnonDecl(
 }
 pub fn getAnonDeclVAddr(wasm: *Wasm, decl_val: InternPool.Index, reloc_info: link.File.RelocInfo) !u64 {
+    const gpa = wasm.base.comp.gpa;
     const atom_index = wasm.anon_decls.get(decl_val).?;
     const target_symbol_index = wasm.getAtom(atom_index).getSymbolIndex().?;
 @@ -1793,17 +1839,17 @@ pub fn getAnonDeclVAddr(wasm: *Wasm, decl_val: InternPool.Index, reloc_info: lin
         // as function pointers are not allowed to be stored inside the data section.
         // They are instead stored in a function table which are called by index.
         try wasm.addTableFunction(target_symbol_index);
-        try parent_atom.relocs.append(wasm.base.allocator, .{
+        try parent_atom.relocs.append(gpa, .{
             .index = target_symbol_index,
-            .offset = @as(u32, @intCast(reloc_info.offset)),
+            .offset = @intCast(reloc_info.offset),
             .relocation_type = if (is_wasm32) .R_WASM_TABLE_INDEX_I32 else .R_WASM_TABLE_INDEX_I64,
         });
     } else {
-        try parent_atom.relocs.append(wasm.base.allocator, .{
+        try parent_atom.relocs.append(gpa, .{
             .index = target_symbol_index,
-            .offset = @as(u32, @intCast(reloc_info.offset)),
+            .offset = @intCast(reloc_info.offset),
             .relocation_type = if (is_wasm32) .R_WASM_MEMORY_ADDR_I32 else .R_WASM_MEMORY_ADDR_I64,
-            .addend = @as(i32, @intCast(reloc_info.addend)),
+            .addend = @intCast(reloc_info.addend),
         });
     }
 @@ -1840,8 +1886,6 @@ pub fn updateExports(
     }
     if (wasm.llvm_object) |llvm_object| return llvm_object.updateExports(mod, exported, exports);
-    if (wasm.base.options.emit == null) return;
     const decl_index = switch (exported) {
         .decl_index => |i| i,
         .value => |val| {
 @@ -1880,7 +1924,7 @@ pub fn updateExports(
         };
         const exported_atom_index = try wasm.getOrCreateAtomForDecl(exported_decl_index);
         const exported_atom = wasm.getAtom(exported_atom_index);
-        const export_name = try wasm.string_table.put(wasm.base.allocator, mod.intern_pool.stringToSlice(exp.opts.name));
+        const export_name = try wasm.string_table.put(gpa, mod.intern_pool.stringToSlice(exp.opts.name));
         const sym_loc = exported_atom.symbolLoc();
         const symbol = sym_loc.getSymbol(wasm);
         symbol.setGlobal(true);
 @@ -1915,7 +1959,7 @@ pub fn updateExports(
             if (!existing_sym.isUndefined()) blk: {
                 if (symbol.isWeak()) {
-                    try wasm.discarded.put(wasm.base.allocator, existing_loc, sym_loc);
+                    try wasm.discarded.put(gpa, existing_loc, sym_loc);
                     continue; // to-be-exported symbol is weak, so we keep the existing symbol
                 }
 @@ -1939,18 +1983,18 @@ pub fn updateExports(
             }
             // in this case the existing symbol must be replaced either because it's weak or undefined.
-            try wasm.discarded.put(wasm.base.allocator, existing_loc, sym_loc);
+            try wasm.discarded.put(gpa, existing_loc, sym_loc);
             _ = wasm.imports.remove(existing_loc);
             _ = wasm.undefs.swapRemove(existing_sym.name);
         }
         // Ensure the symbol will be exported using the given name
         if (!mod.intern_pool.stringEqlSlice(exp.opts.name, sym_loc.getName(wasm))) {
-            try wasm.export_names.put(wasm.base.allocator, sym_loc, export_name);
+            try wasm.export_names.put(gpa, sym_loc, export_name);
         }
         try wasm.globals.put(
-            wasm.base.allocator,
+            gpa,
             export_name,
             sym_loc,
         );
 @@ -1959,18 +2003,19 @@ pub fn updateExports(
 pub fn freeDecl(wasm: *Wasm, decl_index: InternPool.DeclIndex) void {
     if (wasm.llvm_object) |llvm_object| return llvm_object.freeDecl(decl_index);
+    const gpa = wasm.base.comp.gpa;
     const mod = wasm.base.options.module.?;
     const decl = mod.declPtr(decl_index);
     const atom_index = wasm.decls.get(decl_index).?;
     const atom = wasm.getAtomPtr(atom_index);
-    wasm.symbols_free_list.append(wasm.base.allocator, atom.sym_index) catch {};
+    wasm.symbols_free_list.append(gpa, atom.sym_index) catch {};
     _ = wasm.decls.remove(decl_index);
     wasm.symbols.items[atom.sym_index].tag = .dead;
     for (atom.locals.items) |local_atom_index| {
         const local_atom = wasm.getAtom(local_atom_index);
         const local_symbol = &wasm.symbols.items[local_atom.sym_index];
         local_symbol.tag = .dead; // also for any local symbol
-        wasm.symbols_free_list.append(wasm.base.allocator, local_atom.sym_index) catch {};
+        wasm.symbols_free_list.append(gpa, local_atom.sym_index) catch {};
         assert(wasm.resolved_symbols.swapRemove(local_atom.symbolLoc()));
         assert(wasm.symbol_atom.remove(local_atom.symbolLoc()));
     }
 @@ -1999,8 +2044,9 @@ pub fn freeDecl(wasm: *Wasm, decl_index: InternPool.DeclIndex) void {
 /// Appends a new entry to the indirect function table
 pub fn addTableFunction(wasm: *Wasm, symbol_index: u32) !void {
-    const index = @as(u32, @intCast(wasm.function_table.count()));
+    const gpa = wasm.base.comp.gpa;
-    try wasm.function_table.put(wasm.base.allocator, .{ .file = null, .index = symbol_index }, index);
+    const index: u32 = @intCast(wasm.function_table.count());
+    try wasm.function_table.put(gpa, .{ .file = null, .index = symbol_index }, index);
 }
 /// Assigns indexes to all indirect functions.
 @@ -2019,7 +2065,7 @@ fn mapFunctionTable(wasm: *Wasm) void {
         }
     }
-    if (wasm.base.options.import_table or wasm.base.options.output_mode == .Obj) {
+    if (wasm.import_table or wasm.base.options.output_mode == .Obj) {
         const sym_loc = wasm.findGlobalSymbol("__indirect_function_table").?;
         const import = wasm.imports.getPtr(sym_loc).?;
         import.kind.table.limits.min = index - 1; // we start at index 1.
 @@ -2048,6 +2094,7 @@ pub fn addOrUpdateImport(
     /// is asserted instead.
     type_index: ?u32,
 ) !void {
+    const gpa = wasm.base.comp.gpa;
     assert(symbol_index != 0);
     // For the import name, we use the decl's name, rather than the fully qualified name
     // Also mangle the name when the lib name is set and not equal to "C" so imports with the same
 @@ -2055,11 +2102,11 @@ pub fn addOrUpdateImport(
     const mangle_name = lib_name != null and
         !std.mem.eql(u8, lib_name.?, "c");
     const full_name = if (mangle_name) full_name: {
-        break :full_name try std.fmt.allocPrint(wasm.base.allocator, "{s}|{s}", .{ name, lib_name.? });
+        break :full_name try std.fmt.allocPrint(gpa, "{s}|{s}", .{ name, lib_name.? });
     } else name;
-    defer if (mangle_name) wasm.base.allocator.free(full_name);
+    defer if (mangle_name) gpa.free(full_name);
-    const decl_name_index = try wasm.string_table.put(wasm.base.allocator, full_name);
+    const decl_name_index = try wasm.string_table.put(gpa, full_name);
     const symbol: *Symbol = &wasm.symbols.items[symbol_index];
     symbol.setUndefined(true);
     symbol.setGlobal(true);
 @@ -2068,12 +2115,12 @@ pub fn addOrUpdateImport(
         // we specified a specific name for the symbol that does not match the import name
         symbol.setFlag(.WASM_SYM_EXPLICIT_NAME);
     }
-    const global_gop = try wasm.globals.getOrPut(wasm.base.allocator, decl_name_index);
+    const global_gop = try wasm.globals.getOrPut(gpa, decl_name_index);
     if (!global_gop.found_existing) {
         const loc: SymbolLoc = .{ .file = null, .index = symbol_index };
         global_gop.value_ptr.* = loc;
-        try wasm.resolved_symbols.put(wasm.base.allocator, loc, {});
+        try wasm.resolved_symbols.put(gpa, loc, {});
-        try wasm.undefs.putNoClobber(wasm.base.allocator, decl_name_index, loc);
+        try wasm.undefs.putNoClobber(gpa, decl_name_index, loc);
     } else if (global_gop.value_ptr.*.index != symbol_index) {
         // We are not updating a symbol, but found an existing global
         // symbol with the same name. This means we always favor the
 @@ -2081,21 +2128,21 @@ pub fn addOrUpdateImport(
         // We can also skip storing the import as we will not output
         // this symbol.
         return wasm.discarded.put(
-            wasm.base.allocator,
+            gpa,
             .{ .file = null, .index = symbol_index },
             global_gop.value_ptr.*,
         );
     }
     if (type_index) |ty_index| {
-        const gop = try wasm.imports.getOrPut(wasm.base.allocator, .{ .index = symbol_index, .file = null });
+        const gop = try wasm.imports.getOrPut(gpa, .{ .index = symbol_index, .file = null });
         const module_name = if (lib_name) |l_name| blk: {
             break :blk l_name;
         } else wasm.host_name;
         if (!gop.found_existing) {
             gop.value_ptr.* = .{
-                .module_name = try wasm.string_table.put(wasm.base.allocator, module_name),
+                .module_name = try wasm.string_table.put(gpa, module_name),
-                .name = try wasm.string_table.put(wasm.base.allocator, name),
+                .name = try wasm.string_table.put(gpa, name),
                 .kind = .{ .function = ty_index },
             };
         }
 @@ -2132,10 +2179,10 @@ const Kind = union(enum) {
 /// Parses an Atom and inserts its metadata into the corresponding sections.
 fn parseAtom(wasm: *Wasm, atom_index: Atom.Index, kind: Kind) !void {
+    const gpa = wasm.base.comp.gpa;
     const atom = wasm.getAtomPtr(atom_index);
     const symbol = (SymbolLoc{ .file = null, .index = atom.sym_index }).getSymbol(wasm);
-    const do_garbage_collect = wasm.base.options.gc_sections orelse
+    const do_garbage_collect = wasm.base.gc_sections;
-        (wasm.base.options.output_mode != .Obj);
     if (symbol.isDead() and do_garbage_collect) {
         // Prevent unreferenced symbols from being parsed.
 @@ -2147,7 +2194,7 @@ fn parseAtom(wasm: *Wasm, atom_index: Atom.Index, kind: Kind) !void {
             const index: u32 = @intCast(wasm.functions.count() + wasm.imported_functions_count);
             const type_index = wasm.atom_types.get(atom_index).?;
             try wasm.functions.putNoClobber(
-                wasm.base.allocator,
+                gpa,
                 .{ .file = null, .index = index },
                 .{ .func = .{ .type_index = type_index }, .sym_index = atom.sym_index },
             );
 @@ -2156,7 +2203,7 @@ fn parseAtom(wasm: *Wasm, atom_index: Atom.Index, kind: Kind) !void {
             if (wasm.code_section_index == null) {
                 wasm.code_section_index = @intCast(wasm.segments.items.len);
-                try wasm.segments.append(wasm.base.allocator, .{
+                try wasm.segments.append(gpa, .{
                     .alignment = atom.alignment,
                     .size = atom.size,
                     .offset = 0,
 @@ -2167,11 +2214,11 @@ fn parseAtom(wasm: *Wasm, atom_index: Atom.Index, kind: Kind) !void {
             break :result wasm.code_section_index.?;
         },
         .data => result: {
-            const segment_name = try std.mem.concat(wasm.base.allocator, u8, &.{
+            const segment_name = try std.mem.concat(gpa, u8, &.{
                 kind.segmentName(),
                 wasm.string_table.get(symbol.name),
             });
-            errdefer wasm.base.allocator.free(segment_name);
+            errdefer gpa.free(segment_name);
             const segment_info: types.Segment = .{
                 .name = segment_name,
                 .alignment = atom.alignment,
 @@ -2188,14 +2235,14 @@ fn parseAtom(wasm: *Wasm, atom_index: Atom.Index, kind: Kind) !void {
             }
             const should_merge = wasm.base.options.output_mode != .Obj;
-            const gop = try wasm.data_segments.getOrPut(wasm.base.allocator, segment_info.outputName(should_merge));
+            const gop = try wasm.data_segments.getOrPut(gpa, segment_info.outputName(should_merge));
             if (gop.found_existing) {
                 const index = gop.value_ptr.*;
                 wasm.segments.items[index].size += atom.size;
                 symbol.index = @intCast(wasm.segment_info.getIndex(index).?);
                 // segment info already exists, so free its memory
-                wasm.base.allocator.free(segment_name);
+                gpa.free(segment_name);
                 break :result index;
             } else {
                 const index: u32 = @intCast(wasm.segments.items.len);
 @@ -2203,7 +2250,7 @@ fn parseAtom(wasm: *Wasm, atom_index: Atom.Index, kind: Kind) !void {
                 if (wasm.base.options.shared_memory) {
                     flags |= @intFromEnum(Segment.Flag.WASM_DATA_SEGMENT_IS_PASSIVE);
                 }
-                try wasm.segments.append(wasm.base.allocator, .{
+                try wasm.segments.append(gpa, .{
                     .alignment = atom.alignment,
                     .size = 0,
                     .offset = 0,
 @@ -2212,7 +2259,7 @@ fn parseAtom(wasm: *Wasm, atom_index: Atom.Index, kind: Kind) !void {
                 gop.value_ptr.* = index;
                 const info_index: u32 = @intCast(wasm.segment_info.count());
-                try wasm.segment_info.put(wasm.base.allocator, index, segment_info);
+                try wasm.segment_info.put(gpa, index, segment_info);
                 symbol.index = info_index;
                 break :result index;
             }
 @@ -2228,6 +2275,7 @@ fn parseAtom(wasm: *Wasm, atom_index: Atom.Index, kind: Kind) !void {
 /// From a given index, append the given `Atom` at the back of the linked list.
 /// Simply inserts it into the map of atoms when it doesn't exist yet.
 pub fn appendAtomAtIndex(wasm: *Wasm, index: u32, atom_index: Atom.Index) !void {
+    const gpa = wasm.base.comp.gpa;
     const atom = wasm.getAtomPtr(atom_index);
     if (wasm.atoms.getPtr(index)) |last_index_ptr| {
         const last = wasm.getAtomPtr(last_index_ptr.*);
 @@ -2235,7 +2283,7 @@ pub fn appendAtomAtIndex(wasm: *Wasm, index: u32, atom_index: Atom.Index) !void
         atom.prev = last_index_ptr.*;
         last_index_ptr.* = atom_index;
     } else {
-        try wasm.atoms.putNoClobber(wasm.base.allocator, index, atom_index);
+        try wasm.atoms.putNoClobber(gpa, index, atom_index);
     }
 }
 @@ -2363,12 +2411,13 @@ fn allocateVirtualAddresses(wasm: *Wasm) void {
 }
 fn sortDataSegments(wasm: *Wasm) !void {
+    const gpa = wasm.base.comp.gpa;
     var new_mapping: std.StringArrayHashMapUnmanaged(u32) = .{};
-    try new_mapping.ensureUnusedCapacity(wasm.base.allocator, wasm.data_segments.count());
+    try new_mapping.ensureUnusedCapacity(gpa, wasm.data_segments.count());
-    errdefer new_mapping.deinit(wasm.base.allocator);
+    errdefer new_mapping.deinit(gpa);
-    const keys = try wasm.base.allocator.dupe([]const u8, wasm.data_segments.keys());
+    const keys = try gpa.dupe([]const u8, wasm.data_segments.keys());
-    defer wasm.base.allocator.free(keys);
+    defer gpa.free(keys);
     const SortContext = struct {
         fn sort(_: void, lhs: []const u8, rhs: []const u8) bool {
 @@ -2388,7 +2437,7 @@ fn sortDataSegments(wasm: *Wasm) !void {
         const segment_index = wasm.data_segments.get(key).?;
         new_mapping.putAssumeCapacity(key, segment_index);
     }
-    wasm.data_segments.deinit(wasm.base.allocator);
+    wasm.data_segments.deinit(gpa);
     wasm.data_segments = new_mapping;
 }
 @@ -2401,8 +2450,9 @@ fn sortDataSegments(wasm: *Wasm) !void {
 /// original functions and their types. We need to know the type to verify it doesn't
 /// contain any parameters.
 fn setupInitFunctions(wasm: *Wasm) !void {
+    const gpa = wasm.base.comp.gpa;
     for (wasm.objects.items, 0..) |object, file_index| {
-        try wasm.init_funcs.ensureUnusedCapacity(wasm.base.allocator, object.init_funcs.len);
+        try wasm.init_funcs.ensureUnusedCapacity(gpa, object.init_funcs.len);
         for (object.init_funcs) |init_func| {
             const symbol = object.symtable[init_func.symbol_index];
             const ty: std.wasm.Type = if (symbol.isUndefined()) ty: {
 @@ -2439,6 +2489,7 @@ fn setupInitFunctions(wasm: *Wasm) !void {
 /// Generates an atom containing the global error set' size.
 /// This will only be generated if the symbol exists.
 fn setupErrorsLen(wasm: *Wasm) !void {
+    const gpa = wasm.base.comp.gpa;
     const loc = wasm.findGlobalSymbol("__zig_errors_len") orelse return;
     const errors_len = wasm.base.options.module.?.global_error_set.count();
 @@ -2456,19 +2507,19 @@ fn setupErrorsLen(wasm: *Wasm) !void {
             prev_atom.next = atom.next;
             atom.prev = null;
         }
-        atom.deinit(wasm.base.allocator);
+        atom.deinit(gpa);
         break :blk index;
     } else new_atom: {
         const atom_index: Atom.Index = @intCast(wasm.managed_atoms.items.len);
-        try wasm.symbol_atom.put(wasm.base.allocator, loc, atom_index);
+        try wasm.symbol_atom.put(gpa, loc, atom_index);
-        try wasm.managed_atoms.append(wasm.base.allocator, undefined);
+        try wasm.managed_atoms.append(gpa, undefined);
         break :new_atom atom_index;
     };
     const atom = wasm.getAtomPtr(atom_index);
     atom.* = Atom.empty;
     atom.sym_index = loc.index;
     atom.size = 2;
-    try atom.code.writer(wasm.base.allocator).writeInt(u16, @intCast(errors_len), .little);
+    try atom.code.writer(gpa).writeInt(u16, @intCast(errors_len), .little);
     try wasm.parseAtom(atom_index, .{ .data = .read_only });
 }
 @@ -2480,16 +2531,17 @@ fn setupErrorsLen(wasm: *Wasm) !void {
 /// references to the function stored in the symbol have been finalized so we end
 /// up calling the resolved function.
 fn initializeCallCtorsFunction(wasm: *Wasm) !void {
+    const gpa = wasm.base.comp.gpa;
     // No code to emit, so also no ctors to call
     if (wasm.code_section_index == null) {
         // Make sure to remove it from the resolved symbols so we do not emit
         // it within any section. TODO: Remove this once we implement garbage collection.
         const loc = wasm.findGlobalSymbol("__wasm_call_ctors").?;
-        std.debug.assert(wasm.resolved_symbols.swapRemove(loc));
+        assert(wasm.resolved_symbols.swapRemove(loc));
         return;
     }
-    var function_body = std.ArrayList(u8).init(wasm.base.allocator);
+    var function_body = std.ArrayList(u8).init(gpa);
     defer function_body.deinit();
     const writer = function_body.writer();
 @@ -2531,6 +2583,7 @@ fn createSyntheticFunction(
     func_ty: std.wasm.Type,
     function_body: *std.ArrayList(u8),
 ) !void {
+    const gpa = wasm.base.comp.gpa;
     const loc = wasm.findGlobalSymbol(symbol_name) orelse
         try wasm.createSyntheticSymbol(symbol_name, .function);
     const symbol = loc.getSymbol(wasm);
 @@ -2541,7 +2594,7 @@ fn createSyntheticFunction(
     // create function with above type
     const func_index = wasm.imported_functions_count + @as(u32, @intCast(wasm.functions.count()));
     try wasm.functions.putNoClobber(
-        wasm.base.allocator,
+        gpa,
         .{ .file = null, .index = func_index },
         .{ .func = .{ .type_index = ty_index }, .sym_index = loc.index },
     );
 @@ -2549,7 +2602,7 @@ fn createSyntheticFunction(
     // create the atom that will be output into the final binary
     const atom_index = @as(Atom.Index, @intCast(wasm.managed_atoms.items.len));
-    const atom = try wasm.managed_atoms.addOne(wasm.base.allocator);
+    const atom = try wasm.managed_atoms.addOne(gpa);
     atom.* = .{
         .size = @as(u32, @intCast(function_body.items.len)),
         .offset = 0,
 @@ -2562,7 +2615,7 @@ fn createSyntheticFunction(
         .original_offset = 0,
     };
     try wasm.appendAtomAtIndex(wasm.code_section_index.?, atom_index);
-    try wasm.symbol_atom.putNoClobber(wasm.base.allocator, loc, atom_index);
+    try wasm.symbol_atom.putNoClobber(gpa, loc, atom_index);
     // `allocateAtoms` has already been called, set the atom's offset manually.
     // This is fine to do manually as we insert the atom at the very end.
 @@ -2582,10 +2635,11 @@ pub fn createFunction(
     function_body: *std.ArrayList(u8),
     relocations: *std.ArrayList(Relocation),
 ) !u32 {
+    const gpa = wasm.base.comp.gpa;
     const loc = try wasm.createSyntheticSymbol(symbol_name, .function);
-    const atom_index = @as(Atom.Index, @intCast(wasm.managed_atoms.items.len));
+    const atom_index: Atom.Index = @intCast(wasm.managed_atoms.items.len);
-    const atom = try wasm.managed_atoms.addOne(wasm.base.allocator);
+    const atom = try wasm.managed_atoms.addOne(gpa);
     atom.* = .{
         .size = @intCast(function_body.items.len),
         .offset = 0,
 @@ -2607,9 +2661,9 @@ pub fn createFunction(
         break :idx index;
     };
     try wasm.appendAtomAtIndex(section_index, atom_index);
-    try wasm.symbol_atom.putNoClobber(wasm.base.allocator, loc, atom_index);
+    try wasm.symbol_atom.putNoClobber(gpa, loc, atom_index);
-    try wasm.atom_types.put(wasm.base.allocator, atom_index, try wasm.putOrGetFuncType(func_ty));
+    try wasm.atom_types.put(gpa, atom_index, try wasm.putOrGetFuncType(func_ty));
-    try wasm.synthetic_functions.append(wasm.base.allocator, atom_index);
+    try wasm.synthetic_functions.append(gpa, atom_index);
     return loc.index;
 }
 @@ -2622,9 +2676,11 @@ fn setupStartSection(wasm: *Wasm) !void {
 }
 fn initializeTLSFunction(wasm: *Wasm) !void {
+    const gpa = wasm.base.comp.gpa;
     if (!wasm.base.options.shared_memory) return;
-    var function_body = std.ArrayList(u8).init(wasm.base.allocator);
+    var function_body = std.ArrayList(u8).init(gpa);
     defer function_body.deinit();
     const writer = function_body.writer();
 @@ -2684,6 +2740,7 @@ fn initializeTLSFunction(wasm: *Wasm) !void {
 }
 fn setupImports(wasm: *Wasm) !void {
+    const gpa = wasm.base.comp.gpa;
     log.debug("Merging imports", .{});
     var discarded_it = wasm.discarded.keyIterator();
     while (discarded_it.next()) |discarded| {
 @@ -2718,12 +2775,12 @@ fn setupImports(wasm: *Wasm) !void {
         // We copy the import to a new import to ensure the names contain references
         // to the internal string table, rather than of the object file.
         const new_imp: types.Import = .{
-            .module_name = try wasm.string_table.put(wasm.base.allocator, object.string_table.get(import.module_name)),
+            .module_name = try wasm.string_table.put(gpa, object.string_table.get(import.module_name)),
-            .name = try wasm.string_table.put(wasm.base.allocator, object.string_table.get(import.name)),
+            .name = try wasm.string_table.put(gpa, object.string_table.get(import.name)),
             .kind = import.kind,
         };
         // TODO: De-duplicate imports when they contain the same names and type
-        try wasm.imports.putNoClobber(wasm.base.allocator, symbol_loc, new_imp);
+        try wasm.imports.putNoClobber(gpa, symbol_loc, new_imp);
     }
     // Assign all indexes of the imports to their representing symbols
 @@ -2764,7 +2821,9 @@ fn setupImports(wasm: *Wasm) !void {
 /// Takes the global, function and table section from each linked object file
 /// and merges it into a single section for each.
 fn mergeSections(wasm: *Wasm) !void {
-    var removed_duplicates = std.ArrayList(SymbolLoc).init(wasm.base.allocator);
+    const gpa = wasm.base.comp.gpa;
+    var removed_duplicates = std.ArrayList(SymbolLoc).init(gpa);
     defer removed_duplicates.deinit();
     for (wasm.resolved_symbols.keys()) |sym_loc| {
 @@ -2791,7 +2850,7 @@ fn mergeSections(wasm: *Wasm) !void {
         switch (symbol.tag) {
             .function => {
                 const gop = try wasm.functions.getOrPut(
-                    wasm.base.allocator,
+                    gpa,
                     .{ .file = sym_loc.file, .index = symbol.index },
                 );
                 if (gop.found_existing) {
 @@ -2800,7 +2859,7 @@ fn mergeSections(wasm: *Wasm) !void {
                     // we only emit a single function, instead of duplicates.
                     symbol.unmark();
                     try wasm.discarded.putNoClobber(
-                        wasm.base.allocator,
+                        gpa,
                         sym_loc,
                         .{ .file = gop.key_ptr.*.file, .index = gop.value_ptr.*.sym_index },
                     );
 @@ -2813,12 +2872,12 @@ fn mergeSections(wasm: *Wasm) !void {
             .global => {
                 const original_global = object.globals[index];
                 symbol.index = @as(u32, @intCast(wasm.wasm_globals.items.len)) + wasm.imported_globals_count;
-                try wasm.wasm_globals.append(wasm.base.allocator, original_global);
+                try wasm.wasm_globals.append(gpa, original_global);
             },
             .table => {
                 const original_table = object.tables[index];
                 symbol.index = @as(u32, @intCast(wasm.tables.items.len)) + wasm.imported_tables_count;
-                try wasm.tables.append(wasm.base.allocator, original_table);
+                try wasm.tables.append(gpa, original_table);
             },
             else => unreachable,
         }
 @@ -2838,10 +2897,11 @@ fn mergeSections(wasm: *Wasm) !void {
 /// 'types' section, while assigning the type index to the representing
 /// section (import, export, function).
 fn mergeTypes(wasm: *Wasm) !void {
+    const gpa = wasm.base.comp.gpa;
     // A map to track which functions have already had their
     // type inserted. If we do this for the same function multiple times,
     // it will be overwritten with the incorrect type.
-    var dirty = std.AutoHashMap(u32, void).init(wasm.base.allocator);
+    var dirty = std.AutoHashMap(u32, void).init(gpa);
     try dirty.ensureUnusedCapacity(@as(u32, @intCast(wasm.functions.count())));
     defer dirty.deinit();
 @@ -2873,6 +2933,7 @@ fn mergeTypes(wasm: *Wasm) !void {
 }
 fn setupExports(wasm: *Wasm) !void {
+    const gpa = wasm.base.comp.gpa;
     if (wasm.base.options.output_mode == .Obj) return;
     log.debug("Building exports from symbols", .{});
 @@ -2903,11 +2964,11 @@ fn setupExports(wasm: *Wasm) !void {
         const sym_name = sym_loc.getName(wasm);
         const export_name = if (wasm.export_names.get(sym_loc)) |name| name else blk: {
             if (sym_loc.file == null) break :blk symbol.name;
-            break :blk try wasm.string_table.put(wasm.base.allocator, sym_name);
+            break :blk try wasm.string_table.put(gpa, sym_name);
         };
         const exp: types.Export = if (symbol.tag == .data) exp: {
             const global_index = @as(u32, @intCast(wasm.imported_globals_count + wasm.wasm_globals.items.len));
-            try wasm.wasm_globals.append(wasm.base.allocator, .{
+            try wasm.wasm_globals.append(gpa, .{
                 .global_type = .{ .valtype = .i32, .mutable = false },
                 .init = .{ .i32_const = @as(i32, @intCast(symbol.virtual_address)) },
             });
 @@ -2926,7 +2987,7 @@ fn setupExports(wasm: *Wasm) !void {
             wasm.string_table.get(exp.name),
             exp.index,
         });
-        try wasm.exports.append(wasm.base.allocator, exp);
+        try wasm.exports.append(gpa, exp);
     }
     log.debug("Completed building exports. Total count: ({d})", .{wasm.exports.items.len});
 @@ -2957,8 +3018,6 @@ fn setupStart(wasm: *Wasm) !void {
 fn setupMemory(wasm: *Wasm) !void {
     log.debug("Setting up memory layout", .{});
     const page_size = std.wasm.page_size; // 64kb
-    // Use the user-provided stack size or else we use 1MB by default
-    const stack_size = wasm.base.options.stack_size_override orelse page_size * 16;
     const stack_alignment: Alignment = .@"16"; // wasm's stack alignment as specified by tool-convention
     const heap_alignment: Alignment = .@"16"; // wasm's heap alignment as specified by tool-convention
 @@ -2974,7 +3033,7 @@ fn setupMemory(wasm: *Wasm) !void {
     if (place_stack_first and !is_obj) {
         memory_ptr = stack_alignment.forward(memory_ptr);
-        memory_ptr += stack_size;
+        memory_ptr += wasm.base.stack_size;
         // We always put the stack pointer global at index 0
         wasm.wasm_globals.items[0].init.i32_const = @as(i32, @bitCast(@as(u32, @intCast(memory_ptr))));
     }
 @@ -3021,7 +3080,7 @@ fn setupMemory(wasm: *Wasm) !void {
     if (!place_stack_first and !is_obj) {
         memory_ptr = stack_alignment.forward(memory_ptr);
-        memory_ptr += stack_size;
+        memory_ptr += wasm.base.stack_size;
         wasm.wasm_globals.items[0].init.i32_const = @as(i32, @bitCast(@as(u32, @intCast(memory_ptr))));
     }
 @@ -3088,29 +3147,30 @@ fn setupMemory(wasm: *Wasm) !void {
 /// index of the segment within the final data section. When the segment does not yet
 /// exist, a new one will be initialized and appended. The new index will be returned in that case.
 pub fn getMatchingSegment(wasm: *Wasm, object_index: u16, symbol_index: u32) !u32 {
+    const gpa = wasm.base.comp.gpa;
     const object: Object = wasm.objects.items[object_index];
     const symbol = object.symtable[symbol_index];
-    const index = @as(u32, @intCast(wasm.segments.items.len));
+    const index: u32 = @intCast(wasm.segments.items.len);
     switch (symbol.tag) {
         .data => {
             const segment_info = object.segment_info[symbol.index];
             const merge_segment = wasm.base.options.output_mode != .Obj;
-            const result = try wasm.data_segments.getOrPut(wasm.base.allocator, segment_info.outputName(merge_segment));
+            const result = try wasm.data_segments.getOrPut(gpa, segment_info.outputName(merge_segment));
             if (!result.found_existing) {
                 result.value_ptr.* = index;
                 var flags: u32 = 0;
                 if (wasm.base.options.shared_memory) {
                     flags |= @intFromEnum(Segment.Flag.WASM_DATA_SEGMENT_IS_PASSIVE);
                 }
-                try wasm.segments.append(wasm.base.allocator, .{
+                try wasm.segments.append(gpa, .{
                     .alignment = .@"1",
                     .size = 0,
                     .offset = 0,
                     .flags = flags,
                 });
-                try wasm.segment_info.putNoClobber(wasm.base.allocator, index, .{
+                try wasm.segment_info.putNoClobber(gpa, index, .{
-                    .name = try wasm.base.allocator.dupe(u8, segment_info.name),
+                    .name = try gpa.dupe(u8, segment_info.name),
                     .alignment = segment_info.alignment,
                     .flags = segment_info.flags,
                 });
 @@ -3183,7 +3243,8 @@ pub fn getMatchingSegment(wasm: *Wasm, object_index: u16, symbol_index: u32) !u3
 /// Appends a new segment with default field values
 fn appendDummySegment(wasm: *Wasm) !void {
-    try wasm.segments.append(wasm.base.allocator, .{
+    const gpa = wasm.base.comp.gpa;
+    try wasm.segments.append(gpa, .{
         .alignment = .@"1",
         .size = 0,
         .offset = 0,
 @@ -3203,6 +3264,7 @@ pub fn getErrorTableSymbol(wasm: *Wasm) !u32 {
     // and then return said symbol's index. The final table will be populated
     // during `flush` when we know all possible error names.
+    const gpa = wasm.base.comp.gpa;
     const atom_index = try wasm.createAtom();
     const atom = wasm.getAtomPtr(atom_index);
     const slice_ty = Type.slice_const_u8_sentinel_0;
 @@ -3210,7 +3272,7 @@ pub fn getErrorTableSymbol(wasm: *Wasm) !u32 {
     atom.alignment = slice_ty.abiAlignment(mod);
     const sym_index = atom.sym_index;
-    const sym_name = try wasm.string_table.put(wasm.base.allocator, "__zig_err_name_table");
+    const sym_name = try wasm.string_table.put(gpa, "__zig_err_name_table");
     const symbol = &wasm.symbols.items[sym_index];
     symbol.* = .{
         .name = sym_name,
 @@ -3222,7 +3284,7 @@ pub fn getErrorTableSymbol(wasm: *Wasm) !u32 {
     symbol.setFlag(.WASM_SYM_VISIBILITY_HIDDEN);
     symbol.mark();
-    try wasm.resolved_symbols.put(wasm.base.allocator, atom.symbolLoc(), {});
+    try wasm.resolved_symbols.put(gpa, atom.symbolLoc(), {});
     log.debug("Error name table was created with symbol index: ({d})", .{sym_index});
     wasm.error_table_symbol = sym_index;
 @@ -3234,6 +3296,7 @@ pub fn getErrorTableSymbol(wasm: *Wasm) !u32 {
 /// This creates a table that consists of pointers and length to each error name.
 /// The table is what is being pointed to within the runtime bodies that are generated.
 fn populateErrorNameTable(wasm: *Wasm) !void {
+    const gpa = wasm.base.comp.gpa;
     const symbol_index = wasm.error_table_symbol orelse return;
     const atom_index = wasm.symbol_atom.get(.{ .file = null, .index = symbol_index }).?;
 @@ -3243,7 +3306,7 @@ fn populateErrorNameTable(wasm: *Wasm) !void {
     const names_atom_index = try wasm.createAtom();
     const names_atom = wasm.getAtomPtr(names_atom_index);
     names_atom.alignment = .@"1";
-    const sym_name = try wasm.string_table.put(wasm.base.allocator, "__zig_err_names");
+    const sym_name = try wasm.string_table.put(gpa, "__zig_err_names");
     const names_symbol = &wasm.symbols.items[names_atom.sym_index];
     names_symbol.* = .{
         .name = sym_name,
 @@ -3269,10 +3332,10 @@ fn populateErrorNameTable(wasm: *Wasm) !void {
         const slice_ty = Type.slice_const_u8_sentinel_0;
         const offset = @as(u32, @intCast(atom.code.items.len));
         // first we create the data for the slice of the name
-        try atom.code.appendNTimes(wasm.base.allocator, 0, 4); // ptr to name, will be relocated
+        try atom.code.appendNTimes(gpa, 0, 4); // ptr to name, will be relocated
-        try atom.code.writer(wasm.base.allocator).writeInt(u32, len - 1, .little);
+        try atom.code.writer(gpa).writeInt(u32, len - 1, .little);
         // create relocation to the error name
-        try atom.relocs.append(wasm.base.allocator, .{
+        try atom.relocs.append(gpa, .{
             .index = names_atom.sym_index,
             .relocation_type = .R_WASM_MEMORY_ADDR_I32,
             .offset = offset,
 @@ -3282,7 +3345,7 @@ fn populateErrorNameTable(wasm: *Wasm) !void {
         addend += len;
         // as we updated the error name table, we now store the actual name within the names atom
-        try names_atom.code.ensureUnusedCapacity(wasm.base.allocator, len);
+        try names_atom.code.ensureUnusedCapacity(gpa, len);
         names_atom.code.appendSliceAssumeCapacity(error_name);
         names_atom.code.appendAssumeCapacity(0);
 @@ -3291,8 +3354,8 @@ fn populateErrorNameTable(wasm: *Wasm) !void {
     names_atom.size = addend;
     const name_loc = names_atom.symbolLoc();
-    try wasm.resolved_symbols.put(wasm.base.allocator, name_loc, {});
+    try wasm.resolved_symbols.put(gpa, name_loc, {});
-    try wasm.symbol_atom.put(wasm.base.allocator, name_loc, names_atom_index);
+    try wasm.symbol_atom.put(gpa, name_loc, names_atom_index);
     // link the atoms with the rest of the binary so they can be allocated
     // and relocations will be performed.
 @@ -3304,7 +3367,8 @@ fn populateErrorNameTable(wasm: *Wasm) !void {
 /// This initializes the index, appends a new segment,
 /// and finally, creates a managed `Atom`.
 pub fn createDebugSectionForIndex(wasm: *Wasm, index: *?u32, name: []const u8) !Atom.Index {
-    const new_index = @as(u32, @intCast(wasm.segments.items.len));
+    const gpa = wasm.base.comp.gpa;
+    const new_index: u32 = @intCast(wasm.segments.items.len);
     index.* = new_index;
     try wasm.appendDummySegment();
 @@ -3312,7 +3376,7 @@ pub fn createDebugSectionForIndex(wasm: *Wasm, index: *?u32, name: []const u8) !
     const atom = wasm.getAtomPtr(atom_index);
     wasm.symbols.items[atom.sym_index] = .{
         .tag = .section,
-        .name = try wasm.string_table.put(wasm.base.allocator, name),
+        .name = try wasm.string_table.put(gpa, name),
         .index = 0,
         .flags = @intFromEnum(Symbol.Flag.WASM_SYM_BINDING_LOCAL),
     };
 @@ -3322,8 +3386,10 @@ pub fn createDebugSectionForIndex(wasm: *Wasm, index: *?u32, name: []const u8) !
 }
 fn resetState(wasm: *Wasm) void {
+    const gpa = wasm.base.comp.gpa;
     for (wasm.segment_info.values()) |segment_info| {
-        wasm.base.allocator.free(segment_info.name);
+        gpa.free(segment_info.name);
     }
     var atom_it = wasm.decls.valueIterator();
 @@ -3358,16 +3424,12 @@ fn resetState(wasm: *Wasm) void {
 }
 pub fn flush(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) link.File.FlushError!void {
-    if (wasm.base.options.emit == null) {
+    const use_lld = build_options.have_llvm and wasm.base.comp.config.use_lld;
-        if (wasm.llvm_object) |llvm_object| {
+    const use_llvm = wasm.base.comp.config.use_llvm;
-            return try llvm_object.flushModule(comp, prog_node);
-        }
-        return;
-    }
-    if (build_options.have_llvm and wasm.base.options.use_lld) {
+    if (use_lld) {
         return wasm.linkWithLLD(comp, prog_node);
-    } else if (wasm.base.options.use_llvm and !wasm.base.options.use_lld) {
+    } else if (use_llvm and !use_lld) {
         return wasm.linkWithZld(comp, prog_node);
     } else {
         return wasm.flushModule(comp, prog_node);
 @@ -3379,21 +3441,22 @@ fn linkWithZld(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) l
     const tracy = trace(@src());
     defer tracy.end();
-    const gpa = wasm.base.allocator;
+    const gpa = wasm.base.comp.gpa;
-    const options = wasm.base.options;
     // Used for all temporary memory allocated during flushin
     var arena_instance = std.heap.ArenaAllocator.init(gpa);
     defer arena_instance.deinit();
     const arena = arena_instance.allocator();
-    const directory = options.emit.?.directory; // Just an alias to make it shorter to type.
+    const directory = wasm.base.emit.directory; // Just an alias to make it shorter to type.
-    const full_out_path = try directory.join(arena, &[_][]const u8{options.emit.?.sub_path});
+    const full_out_path = try directory.join(arena, &[_][]const u8{wasm.base.emit.sub_path});
+    const opt_zcu = wasm.base.comp.module;
+    const use_llvm = wasm.base.comp.config.use_llvm;
     // 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.
-    const module_obj_path: ?[]const u8 = if (options.module != null) blk: {
+    const module_obj_path: ?[]const u8 = if (opt_zcu != null) blk: {
-        assert(options.use_llvm); // `linkWithZld` should never be called when the Wasm backend is used
+        assert(use_llvm); // `linkWithZld` should never be called when the Wasm backend is used
         try wasm.flushModule(comp, prog_node);
         if (fs.path.dirname(full_out_path)) |dirname| {
 @@ -3416,12 +3479,14 @@ fn linkWithZld(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) l
     const id_symlink_basename = "zld.id";
     var man: Cache.Manifest = undefined;
-    defer if (!options.disable_lld_caching) man.deinit();
+    defer if (!wasm.base.disable_lld_caching) man.deinit();
     var digest: [Cache.hex_digest_len]u8 = undefined;
+    const objects = wasm.base.comp.objects;
     // NOTE: The following section must be maintained to be equal
     // as the section defined in `linkWithLLD`
-    if (!options.disable_lld_caching) {
+    if (!wasm.base.disable_lld_caching) {
         man = comp.cache_parent.obtain();
         // We are about to obtain this lock, so here we give other processes a chance first.
 @@ -3429,7 +3494,7 @@ fn linkWithZld(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) l
         comptime assert(Compilation.link_hash_implementation_version == 10);
-        for (options.objects) |obj| {
+        for (objects) |obj| {
             _ = try man.addFile(obj.path, null);
             man.hash.add(obj.must_link);
         }
 @@ -3438,19 +3503,19 @@ fn linkWithZld(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) l
         }
         try man.addOptionalFile(module_obj_path);
         try man.addOptionalFile(compiler_rt_path);
-        man.hash.addOptionalBytes(options.entry);
+        man.hash.addOptionalBytes(wasm.base.comp.config.entry);
-        man.hash.addOptional(options.stack_size_override);
+        man.hash.add(wasm.base.stack_size);
-        man.hash.add(wasm.base.options.build_id);
+        man.hash.add(wasm.base.build_id);
-        man.hash.add(options.import_memory);
+        man.hash.add(wasm.base.comp.config.import_memory);
-        man.hash.add(options.import_table);
+        man.hash.add(wasm.base.comp.config.shared_memory);
-        man.hash.add(options.export_table);
+        man.hash.add(wasm.import_table);
-        man.hash.addOptional(options.initial_memory);
+        man.hash.add(wasm.export_table);
-        man.hash.addOptional(options.max_memory);
+        man.hash.addOptional(wasm.initial_memory);
-        man.hash.add(options.shared_memory);
+        man.hash.addOptional(wasm.max_memory);
-        man.hash.addOptional(options.global_base);
+        man.hash.addOptional(wasm.global_base);
-        man.hash.add(options.export_symbol_names.len);
+        man.hash.add(wasm.export_symbol_names.len);
         // strip does not need to go into the linker hash because it is part of the hash namespace
-        for (options.export_symbol_names) |symbol_name| {
+        for (wasm.export_symbol_names) |symbol_name| {
             man.hash.addBytes(symbol_name);
         }
 @@ -3485,30 +3550,36 @@ fn linkWithZld(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) l
     // Positional arguments to the linker such as object files and static archives.
     var positionals = std.ArrayList([]const u8).init(arena);
-    try positionals.ensureUnusedCapacity(options.objects.len);
+    try positionals.ensureUnusedCapacity(objects.len);
+    const target = wasm.base.comp.root_mod.resolved_target.result;
+    const output_mode = wasm.base.comp.config.output_mode;
+    const link_mode = wasm.base.comp.config.link_mode;
+    const link_libc = wasm.base.comp.config.link_libc;
+    const link_libcpp = wasm.base.comp.config.link_libcpp;
+    const wasi_exec_model = wasm.base.comp.config.wasi_exec_model;
     // When the target os is WASI, we allow linking with WASI-LIBC
-    if (options.target.os.tag == .wasi) {
+    if (target.os.tag == .wasi) {
-        const is_exe_or_dyn_lib = wasm.base.options.output_mode == .Exe or
+        const is_exe_or_dyn_lib = output_mode == .Exe or
-            (wasm.base.options.output_mode == .Lib and wasm.base.options.link_mode == .Dynamic);
+            (output_mode == .Lib and link_mode == .Dynamic);
         if (is_exe_or_dyn_lib) {
-            const wasi_emulated_libs = wasm.base.options.wasi_emulated_libs;
+            for (wasm.wasi_emulated_libs) |crt_file| {
-            for (wasi_emulated_libs) |crt_file| {
                 try positionals.append(try comp.get_libc_crt_file(
                     arena,
                     wasi_libc.emulatedLibCRFileLibName(crt_file),
                 ));
             }
-            if (wasm.base.options.link_libc) {
+            if (link_libc) {
                 try positionals.append(try comp.get_libc_crt_file(
                     arena,
-                    wasi_libc.execModelCrtFileFullName(wasm.base.options.wasi_exec_model),
+                    wasi_libc.execModelCrtFileFullName(wasi_exec_model),
                 ));
                 try positionals.append(try comp.get_libc_crt_file(arena, "libc.a"));
             }
-            if (wasm.base.options.link_libcpp) {
+            if (link_libcpp) {
                 try positionals.append(comp.libcxx_static_lib.?.full_object_path);
                 try positionals.append(comp.libcxxabi_static_lib.?.full_object_path);
             }
 @@ -3519,7 +3590,7 @@ fn linkWithZld(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) l
         try positionals.append(path);
     }
-    for (options.objects) |object| {
+    for (objects) |object| {
         try positionals.append(object.path);
     }
 @@ -3562,7 +3633,7 @@ fn linkWithZld(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) l
     try wasm.setupExports();
     try wasm.writeToFile(enabled_features, emit_features_count, arena);
-    if (!wasm.base.options.disable_lld_caching) {
+    if (!wasm.base.disable_lld_caching) {
         // Update the file with the digest. If it fails we can continue; it only
         // means that the next invocation will have an unnecessary cache miss.
         Cache.writeSmallFile(directory.handle, id_symlink_basename, &digest) catch |err| {
 @@ -3594,15 +3665,18 @@ pub fn flushModule(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Nod
     try wasm.populateErrorNameTable();
     // Used for all temporary memory allocated during flushin
-    var arena_instance = std.heap.ArenaAllocator.init(wasm.base.allocator);
+    const gpa = wasm.base.comp.gpa;
+    var arena_instance = std.heap.ArenaAllocator.init(gpa);
     defer arena_instance.deinit();
     const arena = arena_instance.allocator();
+    const objects = wasm.base.comp.objects;
     // Positional arguments to the linker such as object files and static archives.
     var positionals = std.ArrayList([]const u8).init(arena);
-    try positionals.ensureUnusedCapacity(wasm.base.options.objects.len);
+    try positionals.ensureUnusedCapacity(objects.len);
-    for (wasm.base.options.objects) |object| {
+    for (objects) |object| {
         positionals.appendAssumeCapacity(object.path);
     }
 @@ -3711,6 +3785,10 @@ fn writeToFile(
     feature_count: u32,
     arena: Allocator,
 ) !void {
+    const gpa = wasm.base.comp.gpa;
+    const use_llvm = wasm.base.comp.config.use_llvm;
+    const use_lld = build_options.have_llvm and wasm.base.comp.config.use_lld;
     // Size of each section header
     const header_size = 5 + 1;
     // The amount of sections that will be written
 @@ -3719,9 +3797,9 @@ fn writeToFile(
     var code_section_index: ?u32 = null;
     // Index of the data section. Used to tell relocation table where the section lives.
     var data_section_index: ?u32 = null;
-    const is_obj = wasm.base.options.output_mode == .Obj or (!wasm.base.options.use_llvm and wasm.base.options.use_lld);
+    const is_obj = wasm.base.options.output_mode == .Obj or (!use_llvm and use_lld);
-    var binary_bytes = std.ArrayList(u8).init(wasm.base.allocator);
+    var binary_bytes = std.ArrayList(u8).init(gpa);
     defer binary_bytes.deinit();
     const binary_writer = binary_bytes.writer();
 @@ -3774,8 +3852,8 @@ fn writeToFile(
         if (import_memory) {
             const mem_name = if (is_obj) "__linear_memory" else "memory";
             const mem_imp: types.Import = .{
-                .module_name = try wasm.string_table.put(wasm.base.allocator, wasm.host_name),
+                .module_name = try wasm.string_table.put(gpa, wasm.host_name),
-                .name = try wasm.string_table.put(wasm.base.allocator, mem_name),
+                .name = try wasm.string_table.put(gpa, mem_name),
                 .kind = .{ .memory = wasm.memories.limits },
             };
             try wasm.emitImport(binary_writer, mem_imp);
 @@ -3955,7 +4033,7 @@ fn writeToFile(
         var atom_index = wasm.atoms.get(code_index).?;
         // The code section must be sorted in line with the function order.
-        var sorted_atoms = try std.ArrayList(*const Atom).initCapacity(wasm.base.allocator, wasm.functions.count());
+        var sorted_atoms = try std.ArrayList(*const Atom).initCapacity(gpa, wasm.functions.count());
         defer sorted_atoms.deinit();
         while (true) {
 @@ -3966,7 +4044,7 @@ fn writeToFile(
             sorted_atoms.appendAssumeCapacity(atom); // found more code atoms than functions
             atom_index = atom.prev orelse break;
         }
-        std.debug.assert(wasm.functions.count() == sorted_atoms.items.len);
+        assert(wasm.functions.count() == sorted_atoms.items.len);
         const atom_sort_fn = struct {
             fn sort(ctx: *const Wasm, lhs: *const Atom, rhs: *const Atom) bool {
 @@ -4086,7 +4164,7 @@ fn writeToFile(
     if (!wasm.base.options.strip) {
         // The build id must be computed on the main sections only,
         // so we have to do it now, before the debug sections.
-        switch (wasm.base.options.build_id) {
+        switch (wasm.base.build_id) {
             .none => {},
             .fast => {
                 var id: [16]u8 = undefined;
 @@ -4121,7 +4199,7 @@ fn writeToFile(
         //     try dwarf.writeDbgLineHeader();
         // }
-        var debug_bytes = std.ArrayList(u8).init(wasm.base.allocator);
+        var debug_bytes = std.ArrayList(u8).init(gpa);
         defer debug_bytes.deinit();
         const DebugSection = struct {
 @@ -4362,8 +4440,10 @@ fn emitNameSection(wasm: *Wasm, binary_bytes: *std.ArrayList(u8), arena: std.mem
 }
 fn emitNameSubsection(wasm: *Wasm, section_id: std.wasm.NameSubsection, names: anytype, writer: anytype) !void {
+    const gpa = wasm.base.comp.gpa;
     // We must emit subsection size, so first write to a temporary list
-    var section_list = std.ArrayList(u8).init(wasm.base.allocator);
+    var section_list = std.ArrayList(u8).init(gpa);
     defer section_list.deinit();
     const sub_writer = section_list.writer();
 @@ -4445,12 +4525,13 @@ fn linkWithLLD(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) !
     const tracy = trace(@src());
     defer tracy.end();
-    var arena_allocator = std.heap.ArenaAllocator.init(wasm.base.allocator);
+    const gpa = wasm.base.comp.gpa;
+    var arena_allocator = std.heap.ArenaAllocator.init(gpa);
     defer arena_allocator.deinit();
     const arena = arena_allocator.allocator();
-    const directory = wasm.base.options.emit.?.directory; // Just an alias to make it shorter to type.
+    const directory = wasm.base.emit.directory; // Just an alias to make it shorter to type.
-    const full_out_path = try directory.join(arena, &[_][]const u8{wasm.base.options.emit.?.sub_path});
+    const full_out_path = try directory.join(arena, &[_][]const u8{wasm.base.emit.sub_path});
     // 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.
 @@ -4481,11 +4562,11 @@ fn linkWithLLD(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) !
     const id_symlink_basename = "lld.id";
     var man: Cache.Manifest = undefined;
-    defer if (!wasm.base.options.disable_lld_caching) man.deinit();
+    defer if (!wasm.base.disable_lld_caching) man.deinit();
     var digest: [Cache.hex_digest_len]u8 = undefined;
-    if (!wasm.base.options.disable_lld_caching) {
+    if (!wasm.base.disable_lld_caching) {
         man = comp.cache_parent.obtain();
         // We are about to obtain this lock, so here we give other processes a chance first.
 @@ -4502,13 +4583,13 @@ fn linkWithLLD(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) !
         }
         try man.addOptionalFile(module_obj_path);
         try man.addOptionalFile(compiler_rt_path);
-        man.hash.addOptionalBytes(wasm.base.options.entry);
+        man.hash.addOptionalBytes(wasm.base.comp.config.entry);
-        man.hash.addOptional(wasm.base.options.stack_size_override);
+        man.hash.add(wasm.base.stack_size);
-        man.hash.add(wasm.base.options.build_id);
+        man.hash.add(wasm.base.build_id);
         man.hash.add(wasm.base.options.import_memory);
         man.hash.add(wasm.base.options.export_memory);
-        man.hash.add(wasm.base.options.import_table);
+        man.hash.add(wasm.import_table);
-        man.hash.add(wasm.base.options.export_table);
+        man.hash.add(wasm.export_table);
         man.hash.addOptional(wasm.base.options.initial_memory);
         man.hash.addOptional(wasm.base.options.max_memory);
         man.hash.add(wasm.base.options.shared_memory);
 @@ -4573,7 +4654,7 @@ fn linkWithLLD(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) !
         }
     } else {
         // Create an LLD command line and invoke it.
-        var argv = std.ArrayList([]const u8).init(wasm.base.allocator);
+        var argv = std.ArrayList([]const u8).init(gpa);
         defer argv.deinit();
         // We will invoke ourselves as a child process to gain access to LLD.
         // This is necessary because LLD does not behave properly as a library -
 @@ -4598,22 +4679,20 @@ fn linkWithLLD(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) !
             try argv.append("--export-memory");
         }
-        if (wasm.base.options.import_table) {
+        if (wasm.import_table) {
-            assert(!wasm.base.options.export_table);
+            assert(!wasm.export_table);
             try argv.append("--import-table");
         }
-        if (wasm.base.options.export_table) {
+        if (wasm.export_table) {
-            assert(!wasm.base.options.import_table);
+            assert(!wasm.import_table);
             try argv.append("--export-table");
         }
-        if (wasm.base.options.gc_sections) |gc| {
+        // For wasm-ld we only need to specify '--no-gc-sections' when the user explicitly
-            // For wasm-ld we only need to specify '--no-gc-sections' when the user explicitly
+        // specified it as garbage collection is enabled by default.
-            // specified it as garbage collection is enabled by default.
+        if (!wasm.base.gc_sections) {
-            if (!gc) {
+            try argv.append("--no-gc-sections");
-                try argv.append("--no-gc-sections");
-            }
         }
         if (wasm.base.options.strip) {
 @@ -4662,12 +4741,10 @@ fn linkWithLLD(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) !
             try argv.append("--no-entry");
         }
-        // Increase the default stack size to a more reasonable value of 1MB instead of
+        try argv.appendSlice(&.{
-        // the default of 1 Wasm page being 64KB, unless overridden by the user.
+            "-z",
-        try argv.append("-z");
+            try std.fmt.allocPrint(arena, "stack-size={d}", .{wasm.base.stack_size}),
-        const stack_size = wasm.base.options.stack_size_override orelse std.wasm.page_size * 16;
+        });
-        const arg = try std.fmt.allocPrint(arena, "stack-size={d}", .{stack_size});
-        try argv.append(arg);
         if (wasm.base.options.import_symbols) {
             try argv.append("--allow-undefined");
 @@ -4681,7 +4758,7 @@ fn linkWithLLD(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) !
         }
         // XXX - TODO: add when wasm-ld supports --build-id.
-        // if (wasm.base.options.build_id) {
+        // if (wasm.base.build_id) {
         //     try argv.append("--build-id=tree");
         // }
 @@ -4695,8 +4772,7 @@ fn linkWithLLD(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) !
             const is_exe_or_dyn_lib = wasm.base.options.output_mode == .Exe or
                 (wasm.base.options.output_mode == .Lib and wasm.base.options.link_mode == .Dynamic);
             if (is_exe_or_dyn_lib) {
-                const wasi_emulated_libs = wasm.base.options.wasi_emulated_libs;
+                for (wasm.wasi_emulated_libs) |crt_file| {
-                for (wasi_emulated_libs) |crt_file| {
                     try argv.append(try comp.get_libc_crt_file(
                         arena,
                         wasi_libc.emulatedLibCRFileLibName(crt_file),
 @@ -4753,7 +4829,7 @@ fn linkWithLLD(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) !
             try argv.append(p);
         }
-        if (wasm.base.options.verbose_link) {
+        if (wasm.base.comp.verbose_link) {
             // Skip over our own name so that the LLD linker name is the first argv item.
             Compilation.dump_argv(argv.items[1..]);
         }
 @@ -4838,7 +4914,7 @@ fn linkWithLLD(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) !
         }
     }
-    if (!wasm.base.options.disable_lld_caching) {
+    if (!wasm.base.disable_lld_caching) {
         // Update the file with the digest. If it fails we can continue; it only
         // means that the next invocation will have an unnecessary cache miss.
         Cache.writeSmallFile(directory.handle, id_symlink_basename, &digest) catch |err| {
 @@ -5113,14 +5189,15 @@ pub fn putOrGetFuncType(wasm: *Wasm, func_type: std.wasm.Type) !u32 {
     if (wasm.getTypeIndex(func_type)) |index| {
         return index;
     }
+    const gpa = wasm.base.comp.gpa;
     // functype does not exist.
-    const index = @as(u32, @intCast(wasm.func_types.items.len));
+    const index: u32 = @intCast(wasm.func_types.items.len);
-    const params = try wasm.base.allocator.dupe(std.wasm.Valtype, func_type.params);
+    const params = try gpa.dupe(std.wasm.Valtype, func_type.params);
-    errdefer wasm.base.allocator.free(params);
+    errdefer gpa.free(params);
-    const returns = try wasm.base.allocator.dupe(std.wasm.Valtype, func_type.returns);
+    const returns = try gpa.dupe(std.wasm.Valtype, func_type.returns);
-    errdefer wasm.base.allocator.free(returns);
+    errdefer gpa.free(returns);
-    try wasm.func_types.append(wasm.base.allocator, .{
+    try wasm.func_types.append(gpa, .{
         .params = params,
         .returns = returns,
     });
 @@ -5131,9 +5208,10 @@ pub fn putOrGetFuncType(wasm: *Wasm, func_type: std.wasm.Type) !u32 {
 /// Asserts declaration has an associated `Atom`.
 /// Returns the index into the list of types.
 pub fn storeDeclType(wasm: *Wasm, decl_index: InternPool.DeclIndex, func_type: std.wasm.Type) !u32 {
+    const gpa = wasm.base.comp.gpa;
     const atom_index = wasm.decls.get(decl_index).?;
     const index = try wasm.putOrGetFuncType(func_type);
-    try wasm.atom_types.put(wasm.base.allocator, atom_index, index);
+    try wasm.atom_types.put(gpa, atom_index, index);
     return index;
 }
 @@ -5142,8 +5220,7 @@ pub fn storeDeclType(wasm: *Wasm, decl_index: InternPool.DeclIndex, func_type: s
 fn markReferences(wasm: *Wasm) !void {
     const tracy = trace(@src());
     defer tracy.end();
-    const do_garbage_collect = wasm.base.options.gc_sections orelse
+    const do_garbage_collect = wasm.base.gc_sections;
-        (wasm.base.options.output_mode != .Obj);
     for (wasm.resolved_symbols.keys()) |sym_loc| {
         const sym = sym_loc.getSymbol(wasm);

src/main.zig+21-23

src/musl.zig+1-1

...	@@ -226,7 +226,7 @@ pub fn buildCRTFile(comp: Compilation, crt_file: CRTFile, prog_node: std.Progr	...	@@ -226,7 +226,7 @@ pub fn buildCRTFile(comp: Compilation, crt_file: CRTFile, prog_node: std.Progr
226	.is_native_abi = false,	226	.is_native_abi = false,
227	.self_exe_path = comp.self_exe_path,	227	.self_exe_path = comp.self_exe_path,
228	.verbose_cc = comp.verbose_cc,	228	.verbose_cc = comp.verbose_cc,
229	.verbose_link = comp.bin_file.options.verbose_link,	229	.verbose_link = comp.verbose_link,
230	.verbose_air = comp.verbose_air,	230	.verbose_air = comp.verbose_air,
231	.verbose_llvm_ir = comp.verbose_llvm_ir,	231	.verbose_llvm_ir = comp.verbose_llvm_ir,
232	.verbose_cimport = comp.verbose_cimport,	232	.verbose_cimport = comp.verbose_cimport,

src/target.zig+8

...	@@ -323,6 +323,14 @@ pub fn hasLlvmSupport(target: std.Target, ofmt: std.Target.ObjectFormat) bool {	...	@@ -323,6 +323,14 @@ pub fn hasLlvmSupport(target: std.Target, ofmt: std.Target.ObjectFormat) bool {
323	};	323	};
324	}	324	}
325		325
		326	/// The set of targets that Zig supports using LLD to link for.
		327	pub fn hasLldSupport(ofmt: std.Target.ObjectFormat) bool {
		328	return switch (ofmt) {
		329	.elf, .coff, .wasm => true,
		330	else => false,
		331	};
		332	}
		333
326	/// The set of targets that our own self-hosted backends have robust support for.	334	/// The set of targets that our own self-hosted backends have robust support for.
327	/// Used to select between LLVM backend and self-hosted backend when compiling in	335	/// Used to select between LLVM backend and self-hosted backend when compiling in
328	/// debug mode. A given target should only return true here if it is passing greater	336	/// debug mode. A given target should only return true here if it is passing greater

...	@@ -842,7 +842,7 @@ fn buildOutputType(	...	@@ -842,7 +842,7 @@ fn buildOutputType(
842	var linker_print_gc_sections: bool = false;	842	var linker_print_gc_sections: bool = false;
843	var linker_print_icf_sections: bool = false;	843	var linker_print_icf_sections: bool = false;
844	var linker_print_map: bool = false;	844	var linker_print_map: bool = false;
845	var linker_opt_bisect_limit: i32 = -1;	845	var llvm_opt_bisect_limit: c_int = -1;
846	var linker_z_nocopyreloc = false;	846	var linker_z_nocopyreloc = false;
847	var linker_z_nodelete = false;	847	var linker_z_nodelete = false;
848	var linker_z_notext = false;	848	var linker_z_notext = false;
...	@@ -859,7 +859,7 @@ fn buildOutputType(	...	@@ -859,7 +859,7 @@ fn buildOutputType(
859	var linker_module_definition_file: ?[]const u8 = null;	859	var linker_module_definition_file: ?[]const u8 = null;
860	var test_no_exec = false;	860	var test_no_exec = false;
861	var force_undefined_symbols: std.StringArrayHashMapUnmanaged(void) = .{};	861	var force_undefined_symbols: std.StringArrayHashMapUnmanaged(void) = .{};
862	var stack_size_override: ?u64 = null;	862	var stack_size: ?u64 = null;
863	var image_base_override: ?u64 = null;	863	var image_base_override: ?u64 = null;
864	var link_eh_frame_hdr = false;	864	var link_eh_frame_hdr = false;
865	var link_emit_relocs = false;	865	var link_emit_relocs = false;
...	@@ -892,7 +892,7 @@ fn buildOutputType(	...	@@ -892,7 +892,7 @@ fn buildOutputType(
892	var contains_res_file: bool = false;	892	var contains_res_file: bool = false;
893	var reference_trace: ?u32 = null;	893	var reference_trace: ?u32 = null;
894	var pdb_out_path: ?[]const u8 = null;	894	var pdb_out_path: ?[]const u8 = null;
895	var dwarf_format: ?std.dwarf.Format = null;	895	var debug_format: ?link.File.DebugFormat = null;
896	var error_limit: ?Module.ErrorInt = null;	896	var error_limit: ?Module.ErrorInt = null;
897	var want_structured_cfg: ?bool = null;	897	var want_structured_cfg: ?bool = null;
898	// These are before resolving sysroot.	898	// These are before resolving sysroot.
...	@@ -1129,10 +1129,7 @@ fn buildOutputType(	...	@@ -1129,10 +1129,7 @@ fn buildOutputType(
1129	} else if (mem.eql(u8, arg, "--force_undefined")) {	1129	} else if (mem.eql(u8, arg, "--force_undefined")) {
1130	try force_undefined_symbols.put(arena, args_iter.nextOrFatal(), {});	1130	try force_undefined_symbols.put(arena, args_iter.nextOrFatal(), {});
1131	} else if (mem.eql(u8, arg, "--stack")) {	1131	} else if (mem.eql(u8, arg, "--stack")) {
1132	const next_arg = args_iter.nextOrFatal();	1132	stack_size = parseStackSize(args_iter.nextOrFatal());
1133	stack_size_override = std.fmt.parseUnsigned(u64, next_arg, 0) catch \|err\| {
1134	fatal("unable to parse stack size '{s}': {s}", .{ next_arg, @errorName(err) });
1135	};
1136	} else if (mem.eql(u8, arg, "--image-base")) {	1133	} else if (mem.eql(u8, arg, "--image-base")) {
1137	const next_arg = args_iter.nextOrFatal();	1134	const next_arg = args_iter.nextOrFatal();
1138	image_base_override = std.fmt.parseUnsigned(u64, next_arg, 0) catch \|err\| {	1135	image_base_override = std.fmt.parseUnsigned(u64, next_arg, 0) catch \|err\| {
...	@@ -1487,9 +1484,9 @@ fn buildOutputType(	...	@@ -1487,9 +1484,9 @@ fn buildOutputType(
1487	} else if (mem.eql(u8, arg, "-fno-strip")) {	1484	} else if (mem.eql(u8, arg, "-fno-strip")) {
1488	mod_opts.strip = false;	1485	mod_opts.strip = false;
1489	} else if (mem.eql(u8, arg, "-gdwarf32")) {	1486	} else if (mem.eql(u8, arg, "-gdwarf32")) {
1490	dwarf_format = .@"32";	1487	debug_format = .{ .dwarf = .@"32" };
1491	} else if (mem.eql(u8, arg, "-gdwarf64")) {	1488	} else if (mem.eql(u8, arg, "-gdwarf64")) {
1492	dwarf_format = .@"64";	1489	debug_format = .{ .dwarf = .@"64" };
1493	} else if (mem.eql(u8, arg, "-fformatted-panics")) {	1490	} else if (mem.eql(u8, arg, "-fformatted-panics")) {
1494	formatted_panics = true;	1491	formatted_panics = true;
1495	} else if (mem.eql(u8, arg, "-fno-formatted-panics")) {	1492	} else if (mem.eql(u8, arg, "-fno-formatted-panics")) {
...	@@ -1511,7 +1508,9 @@ fn buildOutputType(	...	@@ -1511,7 +1508,9 @@ fn buildOutputType(
1511	} else if (mem.eql(u8, arg, "-fno-builtin")) {	1508	} else if (mem.eql(u8, arg, "-fno-builtin")) {
1512	no_builtin = true;	1509	no_builtin = true;
1513	} else if (mem.startsWith(u8, arg, "-fopt-bisect-limit=")) {	1510	} else if (mem.startsWith(u8, arg, "-fopt-bisect-limit=")) {
1514	linker_opt_bisect_limit = std.math.lossyCast(i32, parseIntSuffix(arg, "-fopt-bisect-limit=".len));	1511	const next_arg = arg["-fopt-bisect-limit=".len..];
		1512	llvm_opt_bisect_limit = std.fmt.parseInt(c_int, next_arg, 0) catch \|err\|
		1513	fatal("unable to parse '{s}': {s}", .{ arg, @errorName(err) });
1515	} else if (mem.eql(u8, arg, "--eh-frame-hdr")) {	1514	} else if (mem.eql(u8, arg, "--eh-frame-hdr")) {
1516	link_eh_frame_hdr = true;	1515	link_eh_frame_hdr = true;
1517	} else if (mem.eql(u8, arg, "--dynamicbase")) {	1516	} else if (mem.eql(u8, arg, "--dynamicbase")) {
...	@@ -1994,11 +1993,11 @@ fn buildOutputType(	...	@@ -1994,11 +1993,11 @@ fn buildOutputType(
1994	},	1993	},
1995	.gdwarf32 => {	1994	.gdwarf32 => {
1996	mod_opts.strip = false;	1995	mod_opts.strip = false;
1997	dwarf_format = .@"32";	1996	debug_format = .{ .dwarf = .@"32" };
1998	},	1997	},
1999	.gdwarf64 => {	1998	.gdwarf64 => {
2000	mod_opts.strip = false;	1999	mod_opts.strip = false;
2001	dwarf_format = .@"64";	2000	debug_format = .{ .dwarf = .@"64" };
2002	},	2001	},
2003	.sanitize => {	2002	.sanitize => {
2004	if (mem.eql(u8, it.only_arg, "undefined")) {	2003	if (mem.eql(u8, it.only_arg, "undefined")) {
...	@@ -2257,10 +2256,7 @@ fn buildOutputType(	...	@@ -2257,10 +2256,7 @@ fn buildOutputType(
2257	} else if (mem.eql(u8, z_arg, "norelro")) {	2256	} else if (mem.eql(u8, z_arg, "norelro")) {
2258	linker_z_relro = false;	2257	linker_z_relro = false;
2259	} else if (mem.startsWith(u8, z_arg, "stack-size=")) {	2258	} else if (mem.startsWith(u8, z_arg, "stack-size=")) {
2260	const next_arg = z_arg["stack-size=".len..];	2259	stack_size = parseStackSize(z_arg["stack-size=".len..]);
2261	stack_size_override = std.fmt.parseUnsigned(u64, next_arg, 0) catch \|err\| {
2262	fatal("unable to parse stack size '{s}': {s}", .{ next_arg, @errorName(err) });
2263	};
2264	} else if (mem.startsWith(u8, z_arg, "common-page-size=")) {	2260	} else if (mem.startsWith(u8, z_arg, "common-page-size=")) {
2265	linker_z_common_page_size = parseIntSuffix(z_arg, "common-page-size=".len);	2261	linker_z_common_page_size = parseIntSuffix(z_arg, "common-page-size=".len);
2266	} else if (mem.startsWith(u8, z_arg, "max-page-size=")) {	2262	} else if (mem.startsWith(u8, z_arg, "max-page-size=")) {
...	@@ -2285,10 +2281,7 @@ fn buildOutputType(	...	@@ -2285,10 +2281,7 @@ fn buildOutputType(
2285	} else if (mem.eql(u8, arg, "-u")) {	2281	} else if (mem.eql(u8, arg, "-u")) {
2286	try force_undefined_symbols.put(arena, linker_args_it.nextOrFatal(), {});	2282	try force_undefined_symbols.put(arena, linker_args_it.nextOrFatal(), {});
2287	} else if (mem.eql(u8, arg, "--stack") or mem.eql(u8, arg, "-stack_size")) {	2283	} else if (mem.eql(u8, arg, "--stack") or mem.eql(u8, arg, "-stack_size")) {
2288	const stack_size = linker_args_it.nextOrFatal();	2284	stack_size = parseStackSize(linker_args_it.nextOrFatal());
2289	stack_size_override = std.fmt.parseUnsigned(u64, stack_size, 0) catch \|err\| {
2290	fatal("unable to parse stack size override '{s}': {s}", .{ stack_size, @errorName(err) });
2291	};
2292	} else if (mem.eql(u8, arg, "--image-base")) {	2285	} else if (mem.eql(u8, arg, "--image-base")) {
2293	const image_base = linker_args_it.nextOrFatal();	2286	const image_base = linker_args_it.nextOrFatal();
2294	image_base_override = std.fmt.parseUnsigned(u64, image_base, 0) catch \|err\| {	2287	image_base_override = std.fmt.parseUnsigned(u64, image_base, 0) catch \|err\| {
...	@@ -3407,7 +3400,7 @@ fn buildOutputType(	...	@@ -3407,7 +3400,7 @@ fn buildOutputType(
3407	.linker_print_gc_sections = linker_print_gc_sections,	3400	.linker_print_gc_sections = linker_print_gc_sections,
3408	.linker_print_icf_sections = linker_print_icf_sections,	3401	.linker_print_icf_sections = linker_print_icf_sections,
3409	.linker_print_map = linker_print_map,	3402	.linker_print_map = linker_print_map,
3410	.linker_opt_bisect_limit = linker_opt_bisect_limit,	3403	.llvm_opt_bisect_limit = llvm_opt_bisect_limit,
3411	.linker_global_base = linker_global_base,	3404	.linker_global_base = linker_global_base,
3412	.linker_export_symbol_names = linker_export_symbol_names.items,	3405	.linker_export_symbol_names = linker_export_symbol_names.items,
3413	.linker_z_nocopyreloc = linker_z_nocopyreloc,	3406	.linker_z_nocopyreloc = linker_z_nocopyreloc,
...	@@ -3430,7 +3423,7 @@ fn buildOutputType(	...	@@ -3430,7 +3423,7 @@ fn buildOutputType(
3430	.link_eh_frame_hdr = link_eh_frame_hdr,	3423	.link_eh_frame_hdr = link_eh_frame_hdr,
3431	.link_emit_relocs = link_emit_relocs,	3424	.link_emit_relocs = link_emit_relocs,
3432	.force_undefined_symbols = force_undefined_symbols,	3425	.force_undefined_symbols = force_undefined_symbols,
3433	.stack_size_override = stack_size_override,	3426	.stack_size = stack_size,
3434	.image_base_override = image_base_override,	3427	.image_base_override = image_base_override,
3435	.formatted_panics = formatted_panics,	3428	.formatted_panics = formatted_panics,
3436	.function_sections = function_sections,	3429	.function_sections = function_sections,
...	@@ -3459,7 +3452,7 @@ fn buildOutputType(	...	@@ -3459,7 +3452,7 @@ fn buildOutputType(
3459	.test_runner_path = test_runner_path,	3452	.test_runner_path = test_runner_path,
3460	.disable_lld_caching = !output_to_cache,	3453	.disable_lld_caching = !output_to_cache,
3461	.subsystem = subsystem,	3454	.subsystem = subsystem,
3462	.dwarf_format = dwarf_format,	3455	.debug_format = debug_format,
3463	.debug_compile_errors = debug_compile_errors,	3456	.debug_compile_errors = debug_compile_errors,
3464	.enable_link_snapshots = enable_link_snapshots,	3457	.enable_link_snapshots = enable_link_snapshots,
3465	.install_name = install_name,	3458	.install_name = install_name,
...	@@ -7688,3 +7681,8 @@ fn resolveTargetQueryOrFatal(target_query: std.Target.Query) std.Target {	...	@@ -7688,3 +7681,8 @@ fn resolveTargetQueryOrFatal(target_query: std.Target.Query) std.Target {
7688	return std.zig.system.resolveTargetQuery(target_query) catch \|err\|	7681	return std.zig.system.resolveTargetQuery(target_query) catch \|err\|
7689	fatal("unable to resolve target: {s}", .{@errorName(err)});	7682	fatal("unable to resolve target: {s}", .{@errorName(err)});
7690	}	7683	}
		7684
		7685	fn parseStackSize(s: []const u8) u64 {
		7686	return std.fmt.parseUnsigned(u64, s, 0) catch \|err\|
		7687	fatal("unable to parse stack size '{s}': {s}", .{ s, @errorName(err) });
		7688	}

...	@@ -69,6 +69,8 @@ root_name: [:0]const u8,	...	@@ -69,6 +69,8 @@ root_name: [:0]const u8,
69	cache_mode: CacheMode,	69	cache_mode: CacheMode,
70	include_compiler_rt: bool,	70	include_compiler_rt: bool,
71	objects: []Compilation.LinkObject,	71	objects: []Compilation.LinkObject,
		72	/// Needed only for passing -F args to clang.
		73	framework_dirs: []const []const u8,
72	/// These are always dynamically linked. Static libraries will be	74	/// These are always dynamically linked. Static libraries will be
73	/// provided as positional arguments.	75	/// provided as positional arguments.
74	system_libs: std.StringArrayHashMapUnmanaged(SystemLib),	76	system_libs: std.StringArrayHashMapUnmanaged(SystemLib),
...	@@ -133,6 +135,7 @@ verbose_llvm_ir: ?[]const u8,	...	@@ -133,6 +135,7 @@ verbose_llvm_ir: ?[]const u8,
133	verbose_llvm_bc: ?[]const u8,	135	verbose_llvm_bc: ?[]const u8,
134	verbose_cimport: bool,	136	verbose_cimport: bool,
135	verbose_llvm_cpu_features: bool,	137	verbose_llvm_cpu_features: bool,
		138	verbose_link: bool,
136	disable_c_depfile: bool,	139	disable_c_depfile: bool,
137	time_report: bool,	140	time_report: bool,
138	stack_report: bool,	141	stack_report: bool,
...	@@ -220,6 +223,8 @@ emit_llvm_bc: ?EmitLoc,	...	@@ -220,6 +223,8 @@ emit_llvm_bc: ?EmitLoc,
220	work_queue_wait_group: WaitGroup = .{},	223	work_queue_wait_group: WaitGroup = .{},
221	astgen_wait_group: WaitGroup = .{},	224	astgen_wait_group: WaitGroup = .{},
222		225
		226	llvm_opt_bisect_limit: c_int,
		227
223	pub const Emit = struct {	228	pub const Emit = struct {
224	/// Where the output will go.	229	/// Where the output will go.
225	directory: Directory,	230	directory: Directory,
...	@@ -340,7 +345,7 @@ const Job = union(enum) {	...	@@ -340,7 +345,7 @@ const Job = union(enum) {
340	/// one of WASI libc static objects	345	/// one of WASI libc static objects
341	wasi_libc_crt_file: wasi_libc.CRTFile,	346	wasi_libc_crt_file: wasi_libc.CRTFile,
342		347
343	/// The value is the index into `link.File.Options.system_libs`.	348	/// The value is the index into `system_libs`.
344	windows_import_lib: usize,	349	windows_import_lib: usize,
345	};	350	};
346		351
...	@@ -819,6 +824,20 @@ pub const cache_helpers = struct {	...	@@ -819,6 +824,20 @@ pub const cache_helpers = struct {
819	addEmitLoc(hh, optional_emit_loc orelse return);	824	addEmitLoc(hh, optional_emit_loc orelse return);
820	}	825	}
821		826
		827	pub fn addOptionalDebugFormat(hh: *Cache.HashHelper, x: ?link.File.DebugFormat) void {
		828	hh.add(x != null);