Commit 7e552dc1e9a8388f71cc32083deb9dd848e79808 | zig

author	Matthew Lugg <mlugg@mlugg.co.uk> 2024-06-29 01:36:25+01:00
committer	Matthew Lugg <mlugg@mlugg.co.uk> 2024-07-04 21:01:41+01:00
log	7e552dc1e9a8388f71cc32083deb9dd848e79808
tree	b1c1086002c91be0e6c1195cc18966906a171ce3
parent	bc8cd135987c7dc7419d034ba31178331d606cfa
signature	Commit is signed but in an unrecognized format.

Zcu: rework exports

This commit reworks our representation of exported Decls and values in
Zcu to be memory-optimized and trivially serialized.

All exports are now stored in the `all_exports` array on `Zcu`. An
`AnalUnit` which performs an export (either through an `export`
annotation or by containing an analyzed `@export`) gains an entry into
`single_exports` if it performs only one export, or `multi_exports` if
it performs multiple.

We no longer store a persistent mapping from a `Decl`/value to all
exports of that entity; this state is not necessary for the majority of
the pipeline. Instead, we construct it in `Zcu.processExports`, just
before flush. This does not affect the algorithmic complexity of
`processExports`, since this function already iterates all exports in
the `Zcu`.

The elimination of `decl_exports` and `value_exports` led to a few
non-trivial backend changes. The LLVM backend has been wrangled into a
more reasonable state in general regarding exports and externs. The C
backend is currently disabled in this commit, because its support for
`export` was quite broken, and that was exposed by this work -- I'm
hoping @jacobly0 will be able to pick this up!

16 files changed, 498 insertions(+), 450 deletions(-)

src
- Sema.zig
- Zcu.zig
- codegen
  - c.zig
  - llvm.zig
- link.zig
- link
  - C.zig
  - Coff.zig
  - Elf.zig
  - Elf
    ZigObject.zig
  - MachO.zig
  - MachO
    ZigObject.zig
  - NvPtx.zig
  - Plan9.zig
  - SpirV.zig
  - Wasm.zig
  - Wasm
    ZigObject.zig

src/Sema.zig+72-42

 @@ -117,6 +117,10 @@ maybe_comptime_allocs: std.AutoHashMapUnmanaged(Air.Inst.Index, MaybeComptimeAll
 /// Backed by gpa.
 comptime_allocs: std.ArrayListUnmanaged(ComptimeAlloc) = .{},
+/// A list of exports performed by this analysis. After this `Sema` terminates,
+/// these are flushed to `Zcu.single_exports` or `Zcu.multi_exports`.
+exports: std.ArrayListUnmanaged(Zcu.Export) = .{},
 const MaybeComptimeAlloc = struct {
     /// The runtime index of the `alloc` instruction.
     runtime_index: Value.RuntimeIndex,
 @@ -186,6 +190,7 @@ const build_options = @import("build_options");
 const Compilation = @import("Compilation.zig");
 const InternPool = @import("InternPool.zig");
 const Alignment = InternPool.Alignment;
+const AnalUnit = InternPool.AnalUnit;
 const ComptimeAllocIndex = InternPool.ComptimeAllocIndex;
 pub const default_branch_quota = 1000;
 @@ -875,6 +880,7 @@ pub fn deinit(sema: *Sema) void {
     sema.base_allocs.deinit(gpa);
     sema.maybe_comptime_allocs.deinit(gpa);
     sema.comptime_allocs.deinit(gpa);
+    sema.exports.deinit(gpa);
     sema.* = undefined;
 }
 @@ -2735,12 +2741,12 @@ fn maybeRemoveOutdatedType(sema: *Sema, ty: InternPool.Index) !bool {
     if (!zcu.comp.debug_incremental) return false;
     const decl_index = Type.fromInterned(ty).getOwnerDecl(zcu);
-    const decl_as_depender = InternPool.AnalUnit.wrap(.{ .decl = decl_index });
+    const decl_as_depender = AnalUnit.wrap(.{ .decl = decl_index });
     const was_outdated = zcu.outdated.swapRemove(decl_as_depender) or
         zcu.potentially_outdated.swapRemove(decl_as_depender);
     if (!was_outdated) return false;
     _ = zcu.outdated_ready.swapRemove(decl_as_depender);
-    zcu.intern_pool.removeDependenciesForDepender(zcu.gpa, InternPool.AnalUnit.wrap(.{ .decl = decl_index }));
+    zcu.intern_pool.removeDependenciesForDepender(zcu.gpa, AnalUnit.wrap(.{ .decl = decl_index }));
     zcu.intern_pool.remove(ty);
     zcu.declPtr(decl_index).analysis = .dependency_failure;
     try zcu.markDependeeOutdated(.{ .decl_val = decl_index });
 @@ -2834,7 +2840,7 @@ fn zirStructDecl(
     if (sema.mod.comp.debug_incremental) {
         try ip.addDependency(
             sema.gpa,
-            InternPool.AnalUnit.wrap(.{ .decl = new_decl_index }),
+            AnalUnit.wrap(.{ .decl = new_decl_index }),
             .{ .src_hash = try ip.trackZir(sema.gpa, block.getFileScope(mod), inst) },
         );
     }
 @@ -3068,7 +3074,7 @@ fn zirEnumDecl(
     if (sema.mod.comp.debug_incremental) {
         try mod.intern_pool.addDependency(
             sema.gpa,
-            InternPool.AnalUnit.wrap(.{ .decl = new_decl_index }),
+            AnalUnit.wrap(.{ .decl = new_decl_index }),
             .{ .src_hash = try mod.intern_pool.trackZir(sema.gpa, block.getFileScope(mod), inst) },
         );
     }
 @@ -3334,7 +3340,7 @@ fn zirUnionDecl(
     if (sema.mod.comp.debug_incremental) {
         try mod.intern_pool.addDependency(
             sema.gpa,
-            InternPool.AnalUnit.wrap(.{ .decl = new_decl_index }),
+            AnalUnit.wrap(.{ .decl = new_decl_index }),
             .{ .src_hash = try mod.intern_pool.trackZir(sema.gpa, block.getFileScope(mod), inst) },
         );
     }
 @@ -3422,7 +3428,7 @@ fn zirOpaqueDecl(
     if (sema.mod.comp.debug_incremental) {
         try ip.addDependency(
             gpa,
-            InternPool.AnalUnit.wrap(.{ .decl = new_decl_index }),
+            AnalUnit.wrap(.{ .decl = new_decl_index }),
             .{ .src_hash = try ip.trackZir(gpa, block.getFileScope(mod), inst) },
         );
     }
 @@ -6423,10 +6429,9 @@ fn zirExportValue(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
         return sema.analyzeExport(block, src, options, decl_index);
     }
-    try addExport(mod, .{
+    try sema.exports.append(mod.gpa, .{
         .opts = options,
         .src = src,
-        .owner_decl = sema.owner_decl_index,
         .exported = .{ .value = operand.toIntern() },
         .status = .in_progress,
     });
 @@ -6469,46 +6474,14 @@ pub fn analyzeExport(
     try sema.maybeQueueFuncBodyAnalysis(exported_decl_index);
-    try addExport(mod, .{
+    try sema.exports.append(gpa, .{
         .opts = options,
         .src = src,
-        .owner_decl = sema.owner_decl_index,
         .exported = .{ .decl_index = exported_decl_index },
         .status = .in_progress,
     });
 }
-fn addExport(mod: *Module, export_init: Module.Export) error{OutOfMemory}!void {
-    const gpa = mod.gpa;
-    try mod.decl_exports.ensureUnusedCapacity(gpa, 1);
-    try mod.value_exports.ensureUnusedCapacity(gpa, 1);
-    try mod.export_owners.ensureUnusedCapacity(gpa, 1);
-    const new_export = try gpa.create(Module.Export);
-    errdefer gpa.destroy(new_export);
-    new_export.* = export_init;
-    const eo_gop = mod.export_owners.getOrPutAssumeCapacity(export_init.owner_decl);
-    if (!eo_gop.found_existing) eo_gop.value_ptr.* = .{};
-    try eo_gop.value_ptr.append(gpa, new_export);
-    errdefer _ = eo_gop.value_ptr.pop();
-    switch (export_init.exported) {
-        .decl_index => |decl_index| {
-            const de_gop = mod.decl_exports.getOrPutAssumeCapacity(decl_index);
-            if (!de_gop.found_existing) de_gop.value_ptr.* = .{};
-            try de_gop.value_ptr.append(gpa, new_export);
-        },
-        .value => |value| {
-            const ve_gop = mod.value_exports.getOrPutAssumeCapacity(value);
-            if (!ve_gop.found_existing) ve_gop.value_ptr.* = .{};
-            try ve_gop.value_ptr.append(gpa, new_export);
-        },
-    }
-}
 fn zirSetAlignStack(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) CompileError!void {
     const mod = sema.mod;
     const extra = sema.code.extraData(Zir.Inst.UnNode, extended.operand).data;
 @@ -8411,6 +8384,9 @@ fn instantiateGenericCall(
     });
     sema.appendRefsAssumeCapacity(runtime_args.items);
+    // `child_sema` is owned by us, so just take its exports.
+    try sema.exports.appendSlice(sema.gpa, child_sema.exports.items);
     if (ensure_result_used) {
         try sema.ensureResultUsed(block, sema.typeOf(result), call_src);
     }
 @@ -35263,6 +35239,8 @@ fn semaBackingIntType(mod: *Module, struct_type: InternPool.LoadedStructType) Co
         const backing_int_ty = try mod.intType(.unsigned, @intCast(fields_bit_sum));
         struct_type.backingIntType(ip).* = backing_int_ty.toIntern();
     }
+    try sema.flushExports();
 }
 fn checkBackingIntType(sema: *Sema, block: *Block, src: LazySrcLoc, backing_int_ty: Type, fields_bit_sum: u64) CompileError!void {
 @@ -36225,6 +36203,8 @@ fn semaStructFields(
     struct_type.clearTypesWip(ip);
     if (!any_inits) struct_type.setHaveFieldInits(ip);
+    try sema.flushExports();
 }
 // This logic must be kept in sync with `semaStructFields`
 @@ -36365,6 +36345,8 @@ fn semaStructFieldInits(
             struct_type.field_inits.get(ip)[field_i] = default_val.toIntern();
         }
     }
+    try sema.flushExports();
 }
 fn semaUnionFields(mod: *Module, arena: Allocator, union_type: InternPool.LoadedUnionType) CompileError!void {
 @@ -36738,6 +36720,8 @@ fn semaUnionFields(mod: *Module, arena: Allocator, union_type: InternPool.Loaded
         const enum_ty = try sema.generateUnionTagTypeSimple(&block_scope, enum_field_names, mod.declPtr(union_type.decl));
         union_type.tagTypePtr(ip).* = enum_ty;
     }
+    try sema.flushExports();
 }
 fn semaUnionFieldVal(sema: *Sema, block: *Block, src: LazySrcLoc, int_tag_ty: Type, tag_ref: Air.Inst.Ref) CompileError!Value {
 @@ -38362,7 +38346,7 @@ pub fn declareDependency(sema: *Sema, dependee: InternPool.Dependee) !void {
         return;
     }
-    const depender = InternPool.AnalUnit.wrap(
+    const depender = AnalUnit.wrap(
         if (sema.owner_func_index != .none)
             .{ .func = sema.owner_func_index }
         else
 @@ -38494,6 +38478,52 @@ fn analyzeUnreachable(sema: *Sema, block: *Block, src: LazySrcLoc, safety_check:
     }
 }
+/// This should be called exactly once, at the end of a `Sema`'s lifetime.
+/// It takes the exports stored in `sema.export` and flushes them to the `Zcu`
+/// to be processed by the linker after the update.
+pub fn flushExports(sema: *Sema) !void {
+    if (sema.exports.items.len == 0) return;
+    const zcu = sema.mod;
+    const gpa = zcu.gpa;
+    const unit: AnalUnit = if (sema.owner_func_index != .none)
+        AnalUnit.wrap(.{ .func = sema.owner_func_index })
+    else
+        AnalUnit.wrap(.{ .decl = sema.owner_decl_index });
+    // There may be existing exports. For instance, a struct may export
+    // things during both field type resolution and field default resolution.
+    //
+    // So, pick up and delete any existing exports. This strategy performs
+    // redundant work, but that's okay, because this case is exceedingly rare.
+    if (zcu.single_exports.get(unit)) |export_idx| {
+        try sema.exports.append(gpa, zcu.all_exports.items[export_idx]);
+    } else if (zcu.multi_exports.get(unit)) |info| {
+        try sema.exports.appendSlice(gpa, zcu.all_exports.items[info.index..][0..info.len]);
+    }
+    zcu.deleteUnitExports(unit);
+    // `sema.exports` is completed; store the data into the `Zcu`.
+    if (sema.exports.items.len == 1) {
+        try zcu.single_exports.ensureUnusedCapacity(gpa, 1);
+        const export_idx = zcu.free_exports.popOrNull() orelse idx: {
+            _ = try zcu.all_exports.addOne(gpa);
+            break :idx zcu.all_exports.items.len - 1;
+        };
+        zcu.all_exports.items[export_idx] = sema.exports.items[0];
+        zcu.single_exports.putAssumeCapacityNoClobber(unit, @intCast(export_idx));
+    } else {
+        try zcu.multi_exports.ensureUnusedCapacity(gpa, 1);
+        const exports_base = zcu.all_exports.items.len;
+        try zcu.all_exports.appendSlice(gpa, sema.exports.items);
+        zcu.multi_exports.putAssumeCapacityNoClobber(unit, .{
+            .index = @intCast(exports_base),
+            .len = @intCast(sema.exports.items.len),
+        });
+    }
+}
 pub const bitCastVal = @import("Sema/bitcast.zig").bitCast;
 pub const bitCastSpliceVal = @import("Sema/bitcast.zig").bitCastSplice;

src/Zcu.zig+160-143

...	@@ -35,6 +35,7 @@ const isUpDir = @import("introspect.zig").isUpDir;	...	@@ -35,6 +35,7 @@ const isUpDir = @import("introspect.zig").isUpDir;
35	const clang = @import("clang.zig");	35	const clang = @import("clang.zig");
36	const InternPool = @import("InternPool.zig");	36	const InternPool = @import("InternPool.zig");
37	const Alignment = InternPool.Alignment;	37	const Alignment = InternPool.Alignment;
		38	const AnalUnit = InternPool.AnalUnit;
38	const BuiltinFn = std.zig.BuiltinFn;	39	const BuiltinFn = std.zig.BuiltinFn;
39	const LlvmObject = @import("codegen/llvm.zig").Object;	40	const LlvmObject = @import("codegen/llvm.zig").Object;
40		41
...	@@ -71,18 +72,22 @@ codegen_prog_node: std.Progress.Node = undefined,	...	@@ -71,18 +72,22 @@ codegen_prog_node: std.Progress.Node = undefined,
71	global_zir_cache: Compilation.Directory,	72	global_zir_cache: Compilation.Directory,
72	/// Used by AstGen worker to load and store ZIR cache.	73	/// Used by AstGen worker to load and store ZIR cache.
73	local_zir_cache: Compilation.Directory,	74	local_zir_cache: Compilation.Directory,
74	/// It's rare for a decl to be exported, so we save memory by having a sparse	75	/// This is where all `Export` values are stored. Not all values here are necessarily valid exports;
75	/// map of Decl indexes to details about them being exported.	76	/// to enumerate all exports, `single_exports` and `multi_exports` must be consulted.
76	/// The Export memory is owned by the `export_owners` table; the slice itself	77	all_exports: ArrayListUnmanaged(Export) = .{},
77	/// is owned by this table. The slice is guaranteed to not be empty.	78	/// This is a list of free indices in `all_exports`. These indices may be reused by exports from
78	decl_exports: std.AutoArrayHashMapUnmanaged(Decl.Index, ArrayListUnmanaged(*Export)) = .{},	79	/// future semantic analysis.
79	/// Same as `decl_exports` but for exported constant values.	80	free_exports: ArrayListUnmanaged(u32) = .{},
80	value_exports: std.AutoArrayHashMapUnmanaged(InternPool.Index, ArrayListUnmanaged(*Export)) = .{},	81	/// Maps from an `AnalUnit` which performs a single export, to the index into `all_exports` of
81	/// This models the Decls that perform exports, so that `decl_exports` can be updated when a Decl	82	/// the export it performs. Note that the key is not the `Decl` being exported, but the `AnalUnit`
82	/// is modified. Note that the key of this table is not the Decl being exported, but the Decl that	83	/// whose analysis triggered the export.
83	/// is performing the export of another Decl.	84	single_exports: std.AutoArrayHashMapUnmanaged(AnalUnit, u32) = .{},
84	/// This table owns the Export memory.	85	/// Like `single_exports`, but for `AnalUnit`s which perform multiple exports.
85	export_owners: std.AutoArrayHashMapUnmanaged(Decl.Index, ArrayListUnmanaged(*Export)) = .{},	86	/// The exports are `all_exports.items[index..][0..len]`.
		87	multi_exports: std.AutoArrayHashMapUnmanaged(AnalUnit, extern struct {
		88	index: u32,
		89	len: u32,
		90	}) = .{},
86	/// The set of all the Zig source files in the Module. We keep track of this in order	91	/// The set of all the Zig source files in the Module. We keep track of this in order
87	/// to iterate over it and check which source files have been modified on the file system when	92	/// to iterate over it and check which source files have been modified on the file system when
88	/// an update is requested, as well as to cache `@import` results.	93	/// an update is requested, as well as to cache `@import` results.
...	@@ -126,9 +131,8 @@ compile_log_decls: std.AutoArrayHashMapUnmanaged(Decl.Index, extern struct {	...	@@ -126,9 +131,8 @@ compile_log_decls: std.AutoArrayHashMapUnmanaged(Decl.Index, extern struct {
126	failed_files: std.AutoArrayHashMapUnmanaged(File, ?ErrorMsg) = .{},	131	failed_files: std.AutoArrayHashMapUnmanaged(File, ?ErrorMsg) = .{},
127	/// The ErrorMsg memory is owned by the `EmbedFile`, using Module's general purpose allocator.	132	/// The ErrorMsg memory is owned by the `EmbedFile`, using Module's general purpose allocator.
128	failed_embed_files: std.AutoArrayHashMapUnmanaged(EmbedFile, ErrorMsg) = .{},	133	failed_embed_files: std.AutoArrayHashMapUnmanaged(EmbedFile, ErrorMsg) = .{},
129	/// Using a map here for consistency with the other fields here.	134	/// Key is index into `all_exports`.
130	/// The ErrorMsg memory is owned by the `Export`, using Module's general purpose allocator.	135	failed_exports: std.AutoArrayHashMapUnmanaged(u32, *ErrorMsg) = .{},
131	failed_exports: std.AutoArrayHashMapUnmanaged(Export, ErrorMsg) = .{},
132	/// If a decl failed due to a cimport error, the corresponding Clang errors	136	/// If a decl failed due to a cimport error, the corresponding Clang errors
133	/// are stored here.	137	/// are stored here.
134	cimport_errors: std.AutoArrayHashMapUnmanaged(Decl.Index, std.zig.ErrorBundle) = .{},	138	cimport_errors: std.AutoArrayHashMapUnmanaged(Decl.Index, std.zig.ErrorBundle) = .{},
...	@@ -140,14 +144,14 @@ global_error_set: GlobalErrorSet = .{},	...	@@ -140,14 +144,14 @@ global_error_set: GlobalErrorSet = .{},
140	error_limit: ErrorInt,	144	error_limit: ErrorInt,
141		145
142	/// Value is the number of PO or outdated Decls which this AnalUnit depends on.	146	/// Value is the number of PO or outdated Decls which this AnalUnit depends on.
143	potentially_outdated: std.AutoArrayHashMapUnmanaged(InternPool.AnalUnit, u32) = .{},	147	potentially_outdated: std.AutoArrayHashMapUnmanaged(AnalUnit, u32) = .{},
144	/// Value is the number of PO or outdated Decls which this AnalUnit depends on.	148	/// Value is the number of PO or outdated Decls which this AnalUnit depends on.
145	/// Once this value drops to 0, the AnalUnit is a candidate for re-analysis.	149	/// Once this value drops to 0, the AnalUnit is a candidate for re-analysis.
146	outdated: std.AutoArrayHashMapUnmanaged(InternPool.AnalUnit, u32) = .{},	150	outdated: std.AutoArrayHashMapUnmanaged(AnalUnit, u32) = .{},
147	/// This contains all `AnalUnit`s in `outdated` whose PO dependency count is 0.	151	/// This contains all `AnalUnit`s in `outdated` whose PO dependency count is 0.
148	/// Such `AnalUnit`s are ready for immediate re-analysis.	152	/// Such `AnalUnit`s are ready for immediate re-analysis.
149	/// See `findOutdatedToAnalyze` for details.	153	/// See `findOutdatedToAnalyze` for details.
150	outdated_ready: std.AutoArrayHashMapUnmanaged(InternPool.AnalUnit, void) = .{},	154	outdated_ready: std.AutoArrayHashMapUnmanaged(AnalUnit, void) = .{},
151	/// This contains a set of Decls which may not be in `outdated`, but are the	155	/// This contains a set of Decls which may not be in `outdated`, but are the
152	/// root Decls of files which have updated source and thus must be re-analyzed.	156	/// root Decls of files which have updated source and thus must be re-analyzed.
153	/// If such a Decl is only in this set, the struct type index may be preserved	157	/// If such a Decl is only in this set, the struct type index may be preserved
...	@@ -158,7 +162,7 @@ outdated_file_root: std.AutoArrayHashMapUnmanaged(Decl.Index, void) = .{},	...	@@ -158,7 +162,7 @@ outdated_file_root: std.AutoArrayHashMapUnmanaged(Decl.Index, void) = .{},
158	/// failure was something like running out of disk space, and trying again may	162	/// failure was something like running out of disk space, and trying again may
159	/// succeed. On the next update, we will flush this list, marking all members of	163	/// succeed. On the next update, we will flush this list, marking all members of
160	/// it as outdated.	164	/// it as outdated.
161	retryable_failures: std.ArrayListUnmanaged(InternPool.AnalUnit) = .{},	165	retryable_failures: std.ArrayListUnmanaged(AnalUnit) = .{},
162		166
163	stage1_flags: packed struct {	167	stage1_flags: packed struct {
164	have_winmain: bool = false,	168	have_winmain: bool = false,
...	@@ -267,8 +271,6 @@ pub const Exported = union(enum) {	...	@@ -267,8 +271,6 @@ pub const Exported = union(enum) {
267	pub const Export = struct {	271	pub const Export = struct {
268	opts: Options,	272	opts: Options,
269	src: LazySrcLoc,	273	src: LazySrcLoc,
270	/// The Decl that performs the export. Note that this is not the Decl being exported.
271	owner_decl: Decl.Index,
272	exported: Exported,	274	exported: Exported,
273	status: enum {	275	status: enum {
274	in_progress,	276	in_progress,
...	@@ -2507,20 +2509,10 @@ pub fn deinit(zcu: *Zcu) void {	...	@@ -2507,20 +2509,10 @@ pub fn deinit(zcu: *Zcu) void {
2507		2509
2508	zcu.compile_log_decls.deinit(gpa);	2510	zcu.compile_log_decls.deinit(gpa);
2509		2511
2510	for (zcu.decl_exports.values()) \|*export_list\| {	2512	zcu.all_exports.deinit(gpa);
2511	export_list.deinit(gpa);	2513	zcu.free_exports.deinit(gpa);
2512	}	2514	zcu.single_exports.deinit(gpa);
2513	zcu.decl_exports.deinit(gpa);	2515	zcu.multi_exports.deinit(gpa);
2514
2515	for (zcu.value_exports.values()) \|*export_list\| {
2516	export_list.deinit(gpa);
2517	}
2518	zcu.value_exports.deinit(gpa);
2519
2520	for (zcu.export_owners.values()) \|*value\| {
2521	freeExportList(gpa, value);
2522	}
2523	zcu.export_owners.deinit(gpa);
2524		2516
2525	zcu.global_error_set.deinit(gpa);	2517	zcu.global_error_set.deinit(gpa);
2526		2518
...	@@ -2590,11 +2582,6 @@ pub fn declIsRoot(mod: *Module, decl_index: Decl.Index) bool {	...	@@ -2590,11 +2582,6 @@ pub fn declIsRoot(mod: *Module, decl_index: Decl.Index) bool {
2590	return decl_index == namespace.decl_index;	2582	return decl_index == namespace.decl_index;
2591	}	2583	}
2592		2584
2593	fn freeExportList(gpa: Allocator, export_list: ArrayListUnmanaged(Export)) void {
2594	for (export_list.items) \|exp\| gpa.destroy(exp);
2595	export_list.deinit(gpa);
2596	}
2597
2598	// TODO https://github.com/ziglang/zig/issues/8643	2585	// TODO https://github.com/ziglang/zig/issues/8643
2599	const data_has_safety_tag = @sizeOf(Zir.Inst.Data) != 8;	2586	const data_has_safety_tag = @sizeOf(Zir.Inst.Data) != 8;
2600	const HackDataLayout = extern struct {	2587	const HackDataLayout = extern struct {
...	@@ -3139,7 +3126,7 @@ fn markPoDependeeUpToDate(zcu: *Zcu, dependee: InternPool.Dependee) !void {	...	@@ -3139,7 +3126,7 @@ fn markPoDependeeUpToDate(zcu: *Zcu, dependee: InternPool.Dependee) !void {
3139		3126
3140	/// Given a AnalUnit which is newly outdated or PO, mark all AnalUnits which may	3127	/// Given a AnalUnit which is newly outdated or PO, mark all AnalUnits which may
3141	/// in turn be PO, due to a dependency on the original AnalUnit's tyval or IES.	3128	/// in turn be PO, due to a dependency on the original AnalUnit's tyval or IES.
3142	fn markTransitiveDependersPotentiallyOutdated(zcu: *Zcu, maybe_outdated: InternPool.AnalUnit) !void {	3129	fn markTransitiveDependersPotentiallyOutdated(zcu: *Zcu, maybe_outdated: AnalUnit) !void {
3143	var it = zcu.intern_pool.dependencyIterator(switch (maybe_outdated.unwrap()) {	3130	var it = zcu.intern_pool.dependencyIterator(switch (maybe_outdated.unwrap()) {
3144	.decl => \|decl_index\| .{ .decl_val = decl_index }, // TODO: also `decl_ref` deps when introduced	3131	.decl => \|decl_index\| .{ .decl_val = decl_index }, // TODO: also `decl_ref` deps when introduced
3145	.func => \|func_index\| .{ .func_ies = func_index },	3132	.func => \|func_index\| .{ .func_ies = func_index },
...	@@ -3166,7 +3153,7 @@ fn markTransitiveDependersPotentiallyOutdated(zcu: *Zcu, maybe_outdated: InternP	...	@@ -3166,7 +3153,7 @@ fn markTransitiveDependersPotentiallyOutdated(zcu: *Zcu, maybe_outdated: InternP
3166	}	3153	}
3167	}	3154	}
3168		3155
3169	pub fn findOutdatedToAnalyze(zcu: *Zcu) Allocator.Error!?InternPool.AnalUnit {	3156	pub fn findOutdatedToAnalyze(zcu: *Zcu) Allocator.Error!?AnalUnit {
3170	if (!zcu.comp.debug_incremental) return null;	3157	if (!zcu.comp.debug_incremental) return null;
3171		3158
3172	if (zcu.outdated.count() == 0 and zcu.potentially_outdated.count() == 0) {	3159	if (zcu.outdated.count() == 0 and zcu.potentially_outdated.count() == 0) {
...	@@ -3197,7 +3184,7 @@ pub fn findOutdatedToAnalyze(zcu: *Zcu) Allocator.Error!?InternPool.AnalUnit {	...	@@ -3197,7 +3184,7 @@ pub fn findOutdatedToAnalyze(zcu: *Zcu) Allocator.Error!?InternPool.AnalUnit {
3197	// `outdated`. This set will be small (number of files changed in this	3184	// `outdated`. This set will be small (number of files changed in this
3198	// update), so it's alright for us to just iterate here.	3185	// update), so it's alright for us to just iterate here.
3199	for (zcu.outdated_file_root.keys()) \|file_decl\| {	3186	for (zcu.outdated_file_root.keys()) \|file_decl\| {
3200	const decl_depender = InternPool.AnalUnit.wrap(.{ .decl = file_decl });	3187	const decl_depender = AnalUnit.wrap(.{ .decl = file_decl });
3201	if (zcu.outdated.contains(decl_depender)) {	3188	if (zcu.outdated.contains(decl_depender)) {
3202	// Since we didn't hit this in the first loop, this Decl must have	3189	// Since we didn't hit this in the first loop, this Decl must have
3203	// pending dependencies, so is ineligible.	3190	// pending dependencies, so is ineligible.
...	@@ -3271,7 +3258,7 @@ pub fn findOutdatedToAnalyze(zcu: *Zcu) Allocator.Error!?InternPool.AnalUnit {	...	@@ -3271,7 +3258,7 @@ pub fn findOutdatedToAnalyze(zcu: *Zcu) Allocator.Error!?InternPool.AnalUnit {
3271	chosen_decl_dependers,	3258	chosen_decl_dependers,
3272	});	3259	});
3273		3260
3274	return InternPool.AnalUnit.wrap(.{ .decl = chosen_decl_idx.? });	3261	return AnalUnit.wrap(.{ .decl = chosen_decl_idx.? });
3275	}	3262	}
3276		3263
3277	/// During an incremental update, before semantic analysis, call this to flush all values from	3264	/// During an incremental update, before semantic analysis, call this to flush all values from
...	@@ -3456,7 +3443,7 @@ pub fn ensureDeclAnalyzed(mod: *Module, decl_index: Decl.Index) SemaError!void {	...	@@ -3456,7 +3443,7 @@ pub fn ensureDeclAnalyzed(mod: *Module, decl_index: Decl.Index) SemaError!void {
3456	// which tries to limit re-analysis to Decls whose previously listed	3443	// which tries to limit re-analysis to Decls whose previously listed
3457	// dependencies are all up-to-date.	3444	// dependencies are all up-to-date.
3458		3445
3459	const decl_as_depender = InternPool.AnalUnit.wrap(.{ .decl = decl_index });	3446	const decl_as_depender = AnalUnit.wrap(.{ .decl = decl_index });
3460	const decl_was_outdated = mod.outdated.swapRemove(decl_as_depender) or	3447	const decl_was_outdated = mod.outdated.swapRemove(decl_as_depender) or
3461	mod.potentially_outdated.swapRemove(decl_as_depender);	3448	mod.potentially_outdated.swapRemove(decl_as_depender);
3462		3449
...	@@ -3485,7 +3472,7 @@ pub fn ensureDeclAnalyzed(mod: *Module, decl_index: Decl.Index) SemaError!void {	...	@@ -3485,7 +3472,7 @@ pub fn ensureDeclAnalyzed(mod: *Module, decl_index: Decl.Index) SemaError!void {
3485	// The exports this Decl performs will be re-discovered, so we remove them here	3472	// The exports this Decl performs will be re-discovered, so we remove them here
3486	// prior to re-analysis.	3473	// prior to re-analysis.
3487	if (build_options.only_c) unreachable;	3474	if (build_options.only_c) unreachable;
3488	try mod.deleteDeclExports(decl_index);	3475	mod.deleteUnitExports(AnalUnit.wrap(.{ .decl = decl_index }));
3489	}	3476	}
3490		3477
3491	const sema_result: SemaDeclResult = blk: {	3478	const sema_result: SemaDeclResult = blk: {
...	@@ -3522,7 +3509,7 @@ pub fn ensureDeclAnalyzed(mod: *Module, decl_index: Decl.Index) SemaError!void {	...	@@ -3522,7 +3509,7 @@ pub fn ensureDeclAnalyzed(mod: *Module, decl_index: Decl.Index) SemaError!void {
3522	else => \|e\| {	3509	else => \|e\| {
3523	decl.analysis = .sema_failure;	3510	decl.analysis = .sema_failure;
3524	try mod.failed_decls.ensureUnusedCapacity(mod.gpa, 1);	3511	try mod.failed_decls.ensureUnusedCapacity(mod.gpa, 1);
3525	try mod.retryable_failures.append(mod.gpa, InternPool.AnalUnit.wrap(.{ .decl = decl_index }));	3512	try mod.retryable_failures.append(mod.gpa, AnalUnit.wrap(.{ .decl = decl_index }));
3526	mod.failed_decls.putAssumeCapacityNoClobber(decl_index, try ErrorMsg.create(	3513	mod.failed_decls.putAssumeCapacityNoClobber(decl_index, try ErrorMsg.create(
3527	mod.gpa,	3514	mod.gpa,
3528	decl.navSrcLoc(mod).upgrade(mod),	3515	decl.navSrcLoc(mod).upgrade(mod),
...	@@ -3581,7 +3568,7 @@ pub fn ensureFuncBodyAnalyzed(zcu: *Zcu, maybe_coerced_func_index: InternPool.In	...	@@ -3581,7 +3568,7 @@ pub fn ensureFuncBodyAnalyzed(zcu: *Zcu, maybe_coerced_func_index: InternPool.In
3581	// that's the case, we should remove this function from the binary.	3568	// that's the case, we should remove this function from the binary.
3582	if (decl.val.ip_index != func_index) {	3569	if (decl.val.ip_index != func_index) {
3583	try zcu.markDependeeOutdated(.{ .func_ies = func_index });	3570	try zcu.markDependeeOutdated(.{ .func_ies = func_index });
3584	ip.removeDependenciesForDepender(gpa, InternPool.AnalUnit.wrap(.{ .func = func_index }));	3571	ip.removeDependenciesForDepender(gpa, AnalUnit.wrap(.{ .func = func_index }));
3585	ip.remove(func_index);	3572	ip.remove(func_index);
3586	@panic("TODO: remove orphaned function from binary");	3573	@panic("TODO: remove orphaned function from binary");
3587	}	3574	}
...	@@ -3607,12 +3594,14 @@ pub fn ensureFuncBodyAnalyzed(zcu: *Zcu, maybe_coerced_func_index: InternPool.In	...	@@ -3607,12 +3594,14 @@ pub fn ensureFuncBodyAnalyzed(zcu: *Zcu, maybe_coerced_func_index: InternPool.In
3607	.complete => {},	3594	.complete => {},
3608	}	3595	}
3609		3596
3610	const func_as_depender = InternPool.AnalUnit.wrap(.{ .func = func_index });	3597	const func_as_depender = AnalUnit.wrap(.{ .func = func_index });
3611	const was_outdated = zcu.outdated.swapRemove(func_as_depender) or	3598	const was_outdated = zcu.outdated.swapRemove(func_as_depender) or
3612	zcu.potentially_outdated.swapRemove(func_as_depender);	3599	zcu.potentially_outdated.swapRemove(func_as_depender);
3613		3600
3614	if (was_outdated) {	3601	if (was_outdated) {
		3602	if (build_options.only_c) unreachable;
3615	_ = zcu.outdated_ready.swapRemove(func_as_depender);	3603	_ = zcu.outdated_ready.swapRemove(func_as_depender);
		3604	zcu.deleteUnitExports(AnalUnit.wrap(.{ .func = func_index }));
3616	}	3605	}
3617		3606
3618	switch (func.analysis(ip).state) {	3607	switch (func.analysis(ip).state) {
...	@@ -3728,16 +3717,13 @@ pub fn ensureFuncBodyAnalyzed(zcu: *Zcu, maybe_coerced_func_index: InternPool.In	...	@@ -3728,16 +3717,13 @@ pub fn ensureFuncBodyAnalyzed(zcu: *Zcu, maybe_coerced_func_index: InternPool.In
3728	.{@errorName(err)},	3717	.{@errorName(err)},
3729	));	3718	));
3730	func.analysis(ip).state = .codegen_failure;	3719	func.analysis(ip).state = .codegen_failure;
3731	try zcu.retryable_failures.append(zcu.gpa, InternPool.AnalUnit.wrap(.{ .func = func_index }));	3720	try zcu.retryable_failures.append(zcu.gpa, AnalUnit.wrap(.{ .func = func_index }));
3732	},	3721	},
3733	};	3722	};
3734	} else if (zcu.llvm_object) \|llvm_object\| {	3723	} else if (zcu.llvm_object) \|llvm_object\| {
3735	if (build_options.only_c) unreachable;	3724	if (build_options.only_c) unreachable;
3736	llvm_object.updateFunc(zcu, func_index, air, liveness) catch \|err\| switch (err) {	3725	llvm_object.updateFunc(zcu, func_index, air, liveness) catch \|err\| switch (err) {
3737	error.OutOfMemory => return error.OutOfMemory,	3726	error.OutOfMemory => return error.OutOfMemory,
3738	error.AnalysisFail => {
3739	func.analysis(ip).state = .codegen_failure;
3740	},
3741	};	3727	};
3742	}	3728	}
3743	}	3729	}
...	@@ -3773,7 +3759,7 @@ pub fn ensureFuncBodyAnalysisQueued(mod: *Module, func_index: InternPool.Index)	...	@@ -3773,7 +3759,7 @@ pub fn ensureFuncBodyAnalysisQueued(mod: *Module, func_index: InternPool.Index)
3773		3759
3774	assert(decl.has_tv);	3760	assert(decl.has_tv);
3775		3761
3776	const func_as_depender = InternPool.AnalUnit.wrap(.{ .func = func_index });	3762	const func_as_depender = AnalUnit.wrap(.{ .func = func_index });
3777	const is_outdated = mod.outdated.contains(func_as_depender) or	3763	const is_outdated = mod.outdated.contains(func_as_depender) or
3778	mod.potentially_outdated.contains(func_as_depender);	3764	mod.potentially_outdated.contains(func_as_depender);
3779		3765
...	@@ -3857,7 +3843,7 @@ fn getFileRootStruct(zcu: *Zcu, decl_index: Decl.Index, namespace_index: Namespa	...	@@ -3857,7 +3843,7 @@ fn getFileRootStruct(zcu: *Zcu, decl_index: Decl.Index, namespace_index: Namespa
3857	if (zcu.comp.debug_incremental) {	3843	if (zcu.comp.debug_incremental) {
3858	try ip.addDependency(	3844	try ip.addDependency(
3859	gpa,	3845	gpa,
3860	InternPool.AnalUnit.wrap(.{ .decl = decl_index }),	3846	AnalUnit.wrap(.{ .decl = decl_index }),
3861	.{ .src_hash = tracked_inst },	3847	.{ .src_hash = tracked_inst },
3862	);	3848	);
3863	}	3849	}
...	@@ -3906,7 +3892,7 @@ fn semaFileUpdate(zcu: Zcu, file: File, type_outdated: bool) SemaError!bool {	...	@@ -3906,7 +3892,7 @@ fn semaFileUpdate(zcu: Zcu, file: File, type_outdated: bool) SemaError!bool {
3906		3892
3907	if (type_outdated) {	3893	if (type_outdated) {
3908	// Invalidate the existing type, reusing the decl and namespace.	3894	// Invalidate the existing type, reusing the decl and namespace.
3909	zcu.intern_pool.removeDependenciesForDepender(zcu.gpa, InternPool.AnalUnit.wrap(.{ .decl = file.root_decl.unwrap().? }));	3895	zcu.intern_pool.removeDependenciesForDepender(zcu.gpa, AnalUnit.wrap(.{ .decl = file.root_decl.unwrap().? }));
3910	zcu.intern_pool.remove(decl.val.toIntern());	3896	zcu.intern_pool.remove(decl.val.toIntern());
3911	decl.val = undefined;	3897	decl.val = undefined;
3912	_ = try zcu.getFileRootStruct(file.root_decl.unwrap().?, decl.src_namespace, file);	3898	_ = try zcu.getFileRootStruct(file.root_decl.unwrap().?, decl.src_namespace, file);
...	@@ -4097,7 +4083,7 @@ fn semaDecl(mod: *Module, decl_index: Decl.Index) !SemaDeclResult {	...	@@ -4097,7 +4083,7 @@ fn semaDecl(mod: *Module, decl_index: Decl.Index) !SemaDeclResult {
4097	break :ip_index .none;	4083	break :ip_index .none;
4098	};	4084	};
4099		4085
4100	mod.intern_pool.removeDependenciesForDepender(gpa, InternPool.AnalUnit.wrap(.{ .decl = decl_index }));	4086	mod.intern_pool.removeDependenciesForDepender(gpa, AnalUnit.wrap(.{ .decl = decl_index }));
4101		4087
4102	decl.analysis = .in_progress;	4088	decl.analysis = .in_progress;
4103		4089
...	@@ -4293,6 +4279,8 @@ fn semaDecl(mod: *Module, decl_index: Decl.Index) !SemaDeclResult {	...	@@ -4293,6 +4279,8 @@ fn semaDecl(mod: *Module, decl_index: Decl.Index) !SemaDeclResult {
4293	try sema.analyzeExport(&block_scope, export_src, .{ .name = decl.name }, decl_index);	4279	try sema.analyzeExport(&block_scope, export_src, .{ .name = decl.name }, decl_index);
4294	}	4280	}
4295		4281
		4282	try sema.flushExports();
		4283
4296	return result;	4284	return result;
4297	}	4285	}
4298		4286
...	@@ -4323,7 +4311,7 @@ fn semaAnonOwnerDecl(zcu: *Zcu, decl_index: Decl.Index) !SemaDeclResult {	...	@@ -4323,7 +4311,7 @@ fn semaAnonOwnerDecl(zcu: *Zcu, decl_index: Decl.Index) !SemaDeclResult {
4323	// with a new Decl.	4311	// with a new Decl.
4324	//	4312	//
4325	// Yes, this does mean that any type owner Decl has a constant value for its entire lifetime.	4313	// Yes, this does mean that any type owner Decl has a constant value for its entire lifetime.
4326	zcu.intern_pool.removeDependenciesForDepender(zcu.gpa, InternPool.AnalUnit.wrap(.{ .decl = decl_index }));	4314	zcu.intern_pool.removeDependenciesForDepender(zcu.gpa, AnalUnit.wrap(.{ .decl = decl_index }));
4327	zcu.intern_pool.remove(decl.val.toIntern());	4315	zcu.intern_pool.remove(decl.val.toIntern());
4328	decl.analysis = .dependency_failure;	4316	decl.analysis = .dependency_failure;
4329	return .{	4317	return .{
...	@@ -4949,63 +4937,44 @@ pub fn finalizeAnonDecl(mod: *Module, decl_index: Decl.Index) Allocator.Error!vo	...	@@ -4949,63 +4937,44 @@ pub fn finalizeAnonDecl(mod: *Module, decl_index: Decl.Index) Allocator.Error!vo
4949	}	4937	}
4950	}	4938	}
4951		4939
4952	/// Delete all the Export objects that are caused by this Decl. Re-analysis of	4940	/// Delete all the Export objects that are caused by this `AnalUnit`. Re-analysis of
4953	/// this Decl will cause them to be re-created (or not).	4941	/// this `AnalUnit` will cause them to be re-created (or not).
4954	fn deleteDeclExports(mod: *Module, decl_index: Decl.Index) Allocator.Error!void {	4942	pub fn deleteUnitExports(zcu: *Zcu, anal_unit: AnalUnit) void {
4955	var export_owners = (mod.export_owners.fetchSwapRemove(decl_index) orelse return).value;	4943	const gpa = zcu.gpa;
4956		4944
4957	for (export_owners.items) \|exp\| {	4945	const exports_base, const exports_len = if (zcu.single_exports.fetchSwapRemove(anal_unit)) \|kv\|
4958	switch (exp.exported) {	4946	.{ kv.value, 1 }
4959	.decl_index => \|exported_decl_index\| {	4947	else if (zcu.multi_exports.fetchSwapRemove(anal_unit)) \|info\|
4960	if (mod.decl_exports.getPtr(exported_decl_index)) \|export_list\| {	4948	.{ info.value.index, info.value.len }
4961	// Remove exports with owner_decl matching the regenerating decl.	4949	else
4962	const list = export_list.items;	4950	return;
4963	var i: usize = 0;	4951
4964	var new_len = list.len;	4952	const exports = zcu.all_exports.items[exports_base..][0..exports_len];
4965	while (i < new_len) {	4953
4966	if (list[i].owner_decl == decl_index) {	4954	// In an only-c build, we're guaranteed to never use incremental compilation, so there are
4967	mem.copyBackwards(*Export, list[i..], list[i + 1 .. new_len]);	4955	// guaranteed not to be any exports in the output file that need deleting (since we only call
4968	new_len -= 1;	4956	// `updateExports` on flush).
4969	} else {	4957	// This case is needed because in some rare edge cases, `Sema` wants to add and delete exports
4970	i += 1;	4958	// within a single update.
4971	}	4959	if (!build_options.only_c) {
4972	}	4960	for (exports, exports_base..) \|exp, export_idx\| {
4973	export_list.shrinkAndFree(mod.gpa, new_len);	4961	if (zcu.comp.bin_file) \|lf\| {
4974	if (new_len == 0) {	4962	lf.deleteExport(exp.exported, exp.opts.name);
4975	assert(mod.decl_exports.swapRemove(exported_decl_index));	4963	}
4976	}	4964	if (zcu.failed_exports.fetchSwapRemove(@intCast(export_idx))) \|failed_kv\| {
4977	}	4965	failed_kv.value.destroy(gpa);
4978	},	4966	}
4979	.value => \|value\| {
4980	if (mod.value_exports.getPtr(value)) \|export_list\| {
4981	// Remove exports with owner_decl matching the regenerating decl.
4982	const list = export_list.items;
4983	var i: usize = 0;
4984	var new_len = list.len;
4985	while (i < new_len) {
4986	if (list[i].owner_decl == decl_index) {
4987	mem.copyBackwards(*Export, list[i..], list[i + 1 .. new_len]);
4988	new_len -= 1;
4989	} else {
4990	i += 1;
4991	}
4992	}
4993	export_list.shrinkAndFree(mod.gpa, new_len);
4994	if (new_len == 0) {
4995	assert(mod.value_exports.swapRemove(value));
4996	}
4997	}
4998	},
4999	}
5000	if (mod.comp.bin_file) \|lf\| {
5001	try lf.deleteDeclExport(decl_index, exp.opts.name);
5002	}
5003	if (mod.failed_exports.fetchSwapRemove(exp)) \|failed_kv\| {
5004	failed_kv.value.destroy(mod.gpa);
5005	}	4967	}
5006	mod.gpa.destroy(exp);
5007	}	4968	}
5008	export_owners.deinit(mod.gpa);	4969
		4970	zcu.free_exports.ensureUnusedCapacity(gpa, exports_len) catch {
		4971	// This space will be reused eventually, so we need not propagate this error.
		4972	// Just leak it for now, and let GC reclaim it later on.
		4973	return;
		4974	};
		4975	for (exports_base..exports_base + exports_len) \|export_idx\| {
		4976	zcu.free_exports.appendAssumeCapacity(@intCast(export_idx));
		4977	}
5009	}	4978	}
5010		4979
5011	pub fn analyzeFnBody(mod: *Module, func_index: InternPool.Index, arena: Allocator) SemaError!Air {	4980	pub fn analyzeFnBody(mod: *Module, func_index: InternPool.Index, arena: Allocator) SemaError!Air {
...	@@ -5026,7 +4995,7 @@ pub fn analyzeFnBody(mod: *Module, func_index: InternPool.Index, arena: Allocato	...	@@ -5026,7 +4995,7 @@ pub fn analyzeFnBody(mod: *Module, func_index: InternPool.Index, arena: Allocato
5026	const decl_prog_node = mod.sema_prog_node.start((try decl.fullyQualifiedName(mod)).toSlice(ip), 0);	4995	const decl_prog_node = mod.sema_prog_node.start((try decl.fullyQualifiedName(mod)).toSlice(ip), 0);
5027	defer decl_prog_node.end();	4996	defer decl_prog_node.end();
5028		4997
5029	mod.intern_pool.removeDependenciesForDepender(gpa, InternPool.AnalUnit.wrap(.{ .func = func_index }));	4998	mod.intern_pool.removeDependenciesForDepender(gpa, AnalUnit.wrap(.{ .func = func_index }));
5030		4999
5031	var comptime_err_ret_trace = std.ArrayList(LazySrcLoc).init(gpa);	5000	var comptime_err_ret_trace = std.ArrayList(LazySrcLoc).init(gpa);
5032	defer comptime_err_ret_trace.deinit();	5001	defer comptime_err_ret_trace.deinit();
...	@@ -5262,6 +5231,8 @@ pub fn analyzeFnBody(mod: *Module, func_index: InternPool.Index, arena: Allocato	...	@@ -5262,6 +5231,8 @@ pub fn analyzeFnBody(mod: *Module, func_index: InternPool.Index, arena: Allocato
5262	};	5231	};
5263	}	5232	}
5264		5233
		5234	try sema.flushExports();
		5235
5265	return .{	5236	return .{
5266	.instructions = sema.air_instructions.toOwnedSlice(),	5237	.instructions = sema.air_instructions.toOwnedSlice(),
5267	.extra = try sema.air_extra.toOwnedSlice(gpa),	5238	.extra = try sema.air_extra.toOwnedSlice(gpa),
...	@@ -5392,33 +5363,89 @@ fn lockAndClearFileCompileError(mod: Module, file: File) void {	...	@@ -5392,33 +5363,89 @@ fn lockAndClearFileCompileError(mod: Module, file: File) void {
5392	/// Called from `Compilation.update`, after everything is done, just before	5363	/// Called from `Compilation.update`, after everything is done, just before
5393	/// reporting compile errors. In this function we emit exported symbol collision	5364	/// reporting compile errors. In this function we emit exported symbol collision
5394	/// errors and communicate exported symbols to the linker backend.	5365	/// errors and communicate exported symbols to the linker backend.
5395	pub fn processExports(mod: *Module) !void {	5366	pub fn processExports(zcu: *Zcu) !void {
		5367	const gpa = zcu.gpa;
		5368
		5369	// First, construct a mapping of every exported value and Decl to the indices of all its different exports.
		5370	var decl_exports: std.AutoArrayHashMapUnmanaged(Decl.Index, ArrayListUnmanaged(u32)) = .{};
		5371	var value_exports: std.AutoArrayHashMapUnmanaged(InternPool.Index, ArrayListUnmanaged(u32)) = .{};
		5372	defer {
		5373	for (decl_exports.values()) \|*exports\| {
		5374	exports.deinit(gpa);
		5375	}
		5376	decl_exports.deinit(gpa);
		5377	for (value_exports.values()) \|*exports\| {
		5378	exports.deinit(gpa);
		5379	}
		5380	value_exports.deinit(gpa);
		5381	}
		5382
		5383	// We note as a heuristic:
		5384	// * It is rare to export a value.
		5385	// * It is rare for one Decl to be exported multiple times.
		5386	// So, this ensureTotalCapacity serves as a reasonable (albeit very approximate) optimization.
		5387	try decl_exports.ensureTotalCapacity(gpa, zcu.single_exports.count() + zcu.multi_exports.count());
		5388
		5389	for (zcu.single_exports.values()) \|export_idx\| {
		5390	const exp = zcu.all_exports.items[export_idx];
		5391	const value_ptr, const found_existing = switch (exp.exported) {
		5392	.decl_index => \|i\| gop: {
		5393	const gop = try decl_exports.getOrPut(gpa, i);
		5394	break :gop .{ gop.value_ptr, gop.found_existing };
		5395	},
		5396	.value => \|i\| gop: {
		5397	const gop = try value_exports.getOrPut(gpa, i);
		5398	break :gop .{ gop.value_ptr, gop.found_existing };
		5399	},
		5400	};
		5401	if (!found_existing) value_ptr.* = .{};
		5402	try value_ptr.append(gpa, export_idx);
		5403	}
		5404
		5405	for (zcu.multi_exports.values()) \|info\| {
		5406	for (zcu.all_exports.items[info.index..][0..info.len], info.index..) \|exp, export_idx\| {
		5407	const value_ptr, const found_existing = switch (exp.exported) {
		5408	.decl_index => \|i\| gop: {
		5409	const gop = try decl_exports.getOrPut(gpa, i);
		5410	break :gop .{ gop.value_ptr, gop.found_existing };
		5411	},
		5412	.value => \|i\| gop: {
		5413	const gop = try value_exports.getOrPut(gpa, i);
		5414	break :gop .{ gop.value_ptr, gop.found_existing };
		5415	},
		5416	};
		5417	if (!found_existing) value_ptr.* = .{};
		5418	try value_ptr.append(gpa, @intCast(export_idx));
		5419	}
		5420	}
		5421
5396	// Map symbol names to `Export` for name collision detection.	5422	// Map symbol names to `Export` for name collision detection.
5397	var symbol_exports: SymbolExports = .{};	5423	var symbol_exports: SymbolExports = .{};
5398	defer symbol_exports.deinit(mod.gpa);	5424	defer symbol_exports.deinit(gpa);
5399		5425
5400	for (mod.decl_exports.keys(), mod.decl_exports.values()) \|exported_decl, exports_list\| {	5426	for (decl_exports.keys(), decl_exports.values()) \|exported_decl, exports_list\| {
5401	const exported: Exported = .{ .decl_index = exported_decl };	5427	const exported: Exported = .{ .decl_index = exported_decl };
5402	try processExportsInner(mod, &symbol_exports, exported, exports_list.items);	5428	try processExportsInner(zcu, &symbol_exports, exported, exports_list.items);
5403	}	5429	}
5404		5430
5405	for (mod.value_exports.keys(), mod.value_exports.values()) \|exported_value, exports_list\| {	5431	for (value_exports.keys(), value_exports.values()) \|exported_value, exports_list\| {
5406	const exported: Exported = .{ .value = exported_value };	5432	const exported: Exported = .{ .value = exported_value };
5407	try processExportsInner(mod, &symbol_exports, exported, exports_list.items);	5433	try processExportsInner(zcu, &symbol_exports, exported, exports_list.items);
5408	}	5434	}
5409	}	5435	}
5410		5436
5411	const SymbolExports = std.AutoArrayHashMapUnmanaged(InternPool.NullTerminatedString, *Export);	5437	const SymbolExports = std.AutoArrayHashMapUnmanaged(InternPool.NullTerminatedString, u32);
5412		5438
5413	fn processExportsInner(	5439	fn processExportsInner(
5414	zcu: *Zcu,	5440	zcu: *Zcu,
5415	symbol_exports: *SymbolExports,	5441	symbol_exports: *SymbolExports,
5416	exported: Exported,	5442	exported: Exported,
5417	exports: []const *Export,	5443	export_indices: []const u32,
5418	) error{OutOfMemory}!void {	5444	) error{OutOfMemory}!void {
5419	const gpa = zcu.gpa;	5445	const gpa = zcu.gpa;
5420		5446
5421	for (exports) \|new_export\| {	5447	for (export_indices) \|export_idx\| {
		5448	const new_export = &zcu.all_exports.items[export_idx];
5422	const gop = try symbol_exports.getOrPut(gpa, new_export.opts.name);	5449	const gop = try symbol_exports.getOrPut(gpa, new_export.opts.name);
5423	if (gop.found_existing) {	5450	if (gop.found_existing) {
5424	new_export.status = .failed_retryable;	5451	new_export.status = .failed_retryable;
...	@@ -5428,40 +5455,41 @@ fn processExportsInner(	...	@@ -5428,40 +5455,41 @@ fn processExportsInner(
5428	new_export.opts.name.fmt(&zcu.intern_pool),	5455	new_export.opts.name.fmt(&zcu.intern_pool),
5429	});	5456	});
5430	errdefer msg.destroy(gpa);	5457	errdefer msg.destroy(gpa);
5431	const other_export = gop.value_ptr.*;	5458	const other_export = zcu.all_exports.items[gop.value_ptr.*];
5432	const other_src_loc = other_export.getSrcLoc(zcu);	5459	const other_src_loc = other_export.getSrcLoc(zcu);
5433	try zcu.errNoteNonLazy(other_src_loc, msg, "other symbol here", .{});	5460	try zcu.errNoteNonLazy(other_src_loc, msg, "other symbol here", .{});
5434	zcu.failed_exports.putAssumeCapacityNoClobber(new_export, msg);	5461	zcu.failed_exports.putAssumeCapacityNoClobber(export_idx, msg);
5435	new_export.status = .failed;	5462	new_export.status = .failed;
5436	} else {	5463	} else {
5437	gop.value_ptr.* = new_export;	5464	gop.value_ptr.* = export_idx;
5438	}	5465	}
5439	}	5466	}
5440	if (zcu.comp.bin_file) \|lf\| {	5467	if (zcu.comp.bin_file) \|lf\| {
5441	try handleUpdateExports(zcu, exports, lf.updateExports(zcu, exported, exports));	5468	try handleUpdateExports(zcu, export_indices, lf.updateExports(zcu, exported, export_indices));
5442	} else if (zcu.llvm_object) \|llvm_object\| {	5469	} else if (zcu.llvm_object) \|llvm_object\| {
5443	if (build_options.only_c) unreachable;	5470	if (build_options.only_c) unreachable;
5444	try handleUpdateExports(zcu, exports, llvm_object.updateExports(zcu, exported, exports));	5471	try handleUpdateExports(zcu, export_indices, llvm_object.updateExports(zcu, exported, export_indices));
5445	}	5472	}
5446	}	5473	}
5447		5474
5448	fn handleUpdateExports(	5475	fn handleUpdateExports(
5449	zcu: *Zcu,	5476	zcu: *Zcu,
5450	exports: []const *Export,	5477	export_indices: []const u32,
5451	result: link.File.UpdateExportsError!void,	5478	result: link.File.UpdateExportsError!void,
5452	) Allocator.Error!void {	5479	) Allocator.Error!void {
5453	const gpa = zcu.gpa;	5480	const gpa = zcu.gpa;
5454	result catch \|err\| switch (err) {	5481	result catch \|err\| switch (err) {
5455	error.OutOfMemory => return error.OutOfMemory,	5482	error.OutOfMemory => return error.OutOfMemory,
5456	error.AnalysisFail => {	5483	error.AnalysisFail => {
5457	const new_export = exports[0];	5484	const export_idx = export_indices[0];
		5485	const new_export = &zcu.all_exports.items[export_idx];
5458	new_export.status = .failed_retryable;	5486	new_export.status = .failed_retryable;
5459	try zcu.failed_exports.ensureUnusedCapacity(gpa, 1);	5487	try zcu.failed_exports.ensureUnusedCapacity(gpa, 1);
5460	const src_loc = new_export.getSrcLoc(zcu);	5488	const src_loc = new_export.getSrcLoc(zcu);
5461	const msg = try ErrorMsg.create(gpa, src_loc, "unable to export: {s}", .{	5489	const msg = try ErrorMsg.create(gpa, src_loc, "unable to export: {s}", .{
5462	@errorName(err),	5490	@errorName(err),
5463	});	5491	});
5464	zcu.failed_exports.putAssumeCapacityNoClobber(new_export, msg);	5492	zcu.failed_exports.putAssumeCapacityNoClobber(export_idx, msg);
5465	},	5493	},
5466	};	5494	};
5467	}	5495	}
...	@@ -5627,16 +5655,13 @@ pub fn linkerUpdateDecl(zcu: *Zcu, decl_index: Decl.Index) !void {	...	@@ -5627,16 +5655,13 @@ pub fn linkerUpdateDecl(zcu: *Zcu, decl_index: Decl.Index) !void {
5627	.{@errorName(err)},	5655	.{@errorName(err)},
5628	));	5656	));
5629	decl.analysis = .codegen_failure;	5657	decl.analysis = .codegen_failure;
5630	try zcu.retryable_failures.append(zcu.gpa, InternPool.AnalUnit.wrap(.{ .decl = decl_index }));	5658	try zcu.retryable_failures.append(zcu.gpa, AnalUnit.wrap(.{ .decl = decl_index }));
5631	},	5659	},
5632	};	5660	};
5633	} else if (zcu.llvm_object) \|llvm_object\| {	5661	} else if (zcu.llvm_object) \|llvm_object\| {
5634	if (build_options.only_c) unreachable;	5662	if (build_options.only_c) unreachable;
5635	llvm_object.updateDecl(zcu, decl_index) catch \|err\| switch (err) {	5663	llvm_object.updateDecl(zcu, decl_index) catch \|err\| switch (err) {
5636	error.OutOfMemory => return error.OutOfMemory,	5664	error.OutOfMemory => return error.OutOfMemory,
5637	error.AnalysisFail => {
5638	decl.analysis = .codegen_failure;
5639	},
5640	};	5665	};
5641	}	5666	}
5642	}	5667	}
...	@@ -5684,14 +5709,6 @@ pub fn addGlobalAssembly(mod: *Module, decl_index: Decl.Index, source: []const u	...	@@ -5684,14 +5709,6 @@ pub fn addGlobalAssembly(mod: *Module, decl_index: Decl.Index, source: []const u
5684	}	5709	}
5685	}	5710	}
5686		5711
5687	pub fn getDeclExports(mod: Module, decl_index: Decl.Index) []const *Export {
5688	if (mod.decl_exports.get(decl_index)) \|l\| {
5689	return l.items;
5690	} else {
5691	return &[0]*Export{};
5692	}
5693	}
5694
5695	pub const Feature = enum {	5712	pub const Feature = enum {
5696	panic_fn,	5713	panic_fn,
5697	panic_unwrap_error,	5714	panic_unwrap_error,

src/codegen/c.zig+2

...	@@ -3081,6 +3081,8 @@ pub fn genDeclValue(	...	@@ -3081,6 +3081,8 @@ pub fn genDeclValue(
3081	}	3081	}
3082		3082
3083	pub fn genHeader(dg: *DeclGen) error{ AnalysisFail, OutOfMemory }!void {	3083	pub fn genHeader(dg: *DeclGen) error{ AnalysisFail, OutOfMemory }!void {
		3084	if (true) @panic("TODO jacobly");
		3085
3084	const tracy = trace(@src());	3086	const tracy = trace(@src());
3085	defer tracy.end();	3087	defer tracy.end();
3086		3088

src/codegen/llvm.zig+109-154

 @@ -848,10 +848,6 @@ pub const Object = struct {
     /// Note that the values are not added until `emit`, when all errors in
     /// the compilation are known.
     error_name_table: Builder.Variable.Index,
-    /// This map is usually very close to empty. It tracks only the cases when a
-    /// second extern Decl could not be emitted with the correct name due to a
-    /// name collision.
-    extern_collisions: std.AutoArrayHashMapUnmanaged(InternPool.DeclIndex, void),
     /// Memoizes a null `?usize` value.
     null_opt_usize: Builder.Constant,
 @@ -1011,7 +1007,6 @@ pub const Object = struct {
             .named_enum_map = .{},
             .type_map = .{},
             .error_name_table = .none,
-            .extern_collisions = .{},
             .null_opt_usize = .no_init,
             .struct_field_map = .{},
         };
 @@ -1029,7 +1024,6 @@ pub const Object = struct {
         self.anon_decl_map.deinit(gpa);
         self.named_enum_map.deinit(gpa);
         self.type_map.deinit(gpa);
-        self.extern_collisions.deinit(gpa);
         self.builder.deinit();
         self.struct_field_map.deinit(gpa);
         self.* = undefined;
 @@ -1121,61 +1115,6 @@ pub const Object = struct {
         try object.builder.finishModuleAsm();
     }
-    fn resolveExportExternCollisions(object: *Object) !void {
-        const mod = object.module;
-        // This map has externs with incorrect symbol names.
-        for (object.extern_collisions.keys()) |decl_index| {
-            const global = object.decl_map.get(decl_index) orelse continue;
-            // Same logic as below but for externs instead of exports.
-            const decl_name = object.builder.strtabStringIfExists(mod.declPtr(decl_index).name.toSlice(&mod.intern_pool)) orelse continue;
-            const other_global = object.builder.getGlobal(decl_name) orelse continue;
-            if (other_global.toConst().getBase(&object.builder) ==
-                global.toConst().getBase(&object.builder)) continue;
-            try global.replace(other_global, &object.builder);
-        }
-        object.extern_collisions.clearRetainingCapacity();
-        for (mod.decl_exports.keys(), mod.decl_exports.values()) |decl_index, export_list| {
-            const global = object.decl_map.get(decl_index) orelse continue;
-            try resolveGlobalCollisions(object, global, export_list.items);
-        }
-        for (mod.value_exports.keys(), mod.value_exports.values()) |val, export_list| {
-            const global = object.anon_decl_map.get(val) orelse continue;
-            try resolveGlobalCollisions(object, global, export_list.items);
-        }
-    }
-    fn resolveGlobalCollisions(
-        object: *Object,
-        global: Builder.Global.Index,
-        export_list: []const *Module.Export,
-    ) !void {
-        const mod = object.module;
-        const global_base = global.toConst().getBase(&object.builder);
-        for (export_list) |exp| {
-            // Detect if the LLVM global has already been created as an extern. In such
-            // case, we need to replace all uses of it with this exported global.
-            const exp_name = object.builder.strtabStringIfExists(exp.opts.name.toSlice(&mod.intern_pool)) orelse continue;
-            const other_global = object.builder.getGlobal(exp_name) orelse continue;
-            if (other_global.toConst().getBase(&object.builder) == global_base) continue;
-            try global.takeName(other_global, &object.builder);
-            try other_global.replace(global, &object.builder);
-            // Problem: now we need to replace in the decl_map that
-            // the extern decl index points to this new global. However we don't
-            // know the decl index.
-            // Even if we did, a future incremental update to the extern would then
-            // treat the LLVM global as an extern rather than an export, so it would
-            // need a way to check that.
-            // This is a TODO that needs to be solved when making
-            // the LLVM backend support incremental compilation.
-        }
-    }
     pub const EmitOptions = struct {
         pre_ir_path: ?[]const u8,
         pre_bc_path: ?[]const u8,
 @@ -1193,7 +1132,6 @@ pub const Object = struct {
     pub fn emit(self: *Object, options: EmitOptions) !void {
         {
-            try self.resolveExportExternCollisions();
             try self.genErrorNameTable();
             try self.genCmpLtErrorsLenFunction();
             try self.genModuleLevelAssembly();
 @@ -1698,8 +1636,7 @@ pub const Object = struct {
             const file = try o.getDebugFile(namespace.file_scope);
             const line_number = decl.navSrcLine(zcu) + 1;
-            const is_internal_linkage = decl.val.getExternFunc(zcu) == null and
+            const is_internal_linkage = decl.val.getExternFunc(zcu) == null;
-                !zcu.decl_exports.contains(decl_index);
             const debug_decl_type = try o.lowerDebugType(decl.typeOf(zcu));
             const subprogram = try o.builder.debugSubprogram(
 @@ -1760,8 +1697,6 @@ pub const Object = struct {
         };
         try fg.wip.finish();
-        try o.updateExports(zcu, .{ .decl_index = decl_index }, zcu.getDeclExports(decl_index));
     }
     pub fn updateDecl(self: *Object, module: *Module, decl_index: InternPool.DeclIndex) !void {
 @@ -1781,66 +1716,25 @@ pub const Object = struct {
             },
             else => |e| return e,
         };
-        try self.updateExports(module, .{ .decl_index = decl_index }, module.getDeclExports(decl_index));
     }
     pub fn updateExports(
         self: *Object,
         mod: *Module,
         exported: Module.Exported,
-        exports: []const *Module.Export,
+        export_indices: []const u32,
     ) link.File.UpdateExportsError!void {
         const decl_index = switch (exported) {
             .decl_index => |i| i,
-            .value => |val| return updateExportedValue(self, mod, val, exports),
+            .value => |val| return updateExportedValue(self, mod, val, export_indices),
         };
-        const gpa = mod.gpa;
         const ip = &mod.intern_pool;
-        // If the module does not already have the function, we ignore this function call
+        const global_index = self.decl_map.get(decl_index).?;
-        // because we call `updateExports` at the end of `updateFunc` and `updateDecl`.
-        const global_index = self.decl_map.get(decl_index) orelse return;
         const decl = mod.declPtr(decl_index);
         const comp = mod.comp;
-        if (decl.isExtern(mod)) {
-            const decl_name = decl_name: {
-                if (mod.getTarget().isWasm() and decl.val.typeOf(mod).zigTypeTag(mod) == .Fn) {
-                    if (decl.getOwnedExternFunc(mod).?.lib_name.toSlice(ip)) |lib_name| {
-                        if (!std.mem.eql(u8, lib_name, "c")) {
-                            break :decl_name try self.builder.strtabStringFmt("{}|{s}", .{ decl.name.fmt(ip), lib_name });
-                        }
-                    }
-                }
-                break :decl_name try self.builder.strtabString(decl.name.toSlice(ip));
-            };
-            if (self.builder.getGlobal(decl_name)) |other_global| {
+        if (export_indices.len != 0) {
-                if (other_global != global_index) {
+            return updateExportedGlobal(self, mod, global_index, export_indices);
-                    try self.extern_collisions.put(gpa, decl_index, {});
-                }
-            }
-            try global_index.rename(decl_name, &self.builder);
-            global_index.setLinkage(.external, &self.builder);
-            global_index.setUnnamedAddr(.default, &self.builder);
-            if (comp.config.dll_export_fns)
-                global_index.setDllStorageClass(.default, &self.builder);
-            if (decl.val.getVariable(mod)) |decl_var| {
-                global_index.ptrConst(&self.builder).kind.variable.setThreadLocal(
-                    if (decl_var.is_threadlocal) .generaldynamic else .default,
-                    &self.builder,
-                );
-                if (decl_var.is_weak_linkage) global_index.setLinkage(.extern_weak, &self.builder);
-            }
-        } else if (exports.len != 0) {
-            const main_exp_name = try self.builder.strtabString(exports[0].opts.name.toSlice(ip));
-            try global_index.rename(main_exp_name, &self.builder);
-            if (decl.val.getVariable(mod)) |decl_var| if (decl_var.is_threadlocal)
-                global_index.ptrConst(&self.builder).kind
-                    .variable.setThreadLocal(.generaldynamic, &self.builder);
-            return updateExportedGlobal(self, mod, global_index, exports);
         } else {
             const fqn = try self.builder.strtabString((try decl.fullyQualifiedName(mod)).toSlice(ip));
             try global_index.rename(fqn, &self.builder);
 @@ -1848,17 +1742,6 @@ pub const Object = struct {
             if (comp.config.dll_export_fns)
                 global_index.setDllStorageClass(.default, &self.builder);
             global_index.setUnnamedAddr(.unnamed_addr, &self.builder);
-            if (decl.val.getVariable(mod)) |decl_var| {
-                const decl_namespace = mod.namespacePtr(decl.src_namespace);
-                const single_threaded = decl_namespace.file_scope.mod.single_threaded;
-                global_index.ptrConst(&self.builder).kind.variable.setThreadLocal(
-                    if (decl_var.is_threadlocal and !single_threaded)
-                        .generaldynamic
-                    else
-                        .default,
-                    &self.builder,
-                );
-            }
         }
     }
 @@ -1866,11 +1749,11 @@ pub const Object = struct {
         o: *Object,
         mod: *Module,
         exported_value: InternPool.Index,
-        exports: []const *Module.Export,
+        export_indices: []const u32,
     ) link.File.UpdateExportsError!void {
         const gpa = mod.gpa;
         const ip = &mod.intern_pool;
-        const main_exp_name = try o.builder.strtabString(exports[0].opts.name.toSlice(ip));
+        const main_exp_name = try o.builder.strtabString(mod.all_exports.items[export_indices[0]].opts.name.toSlice(ip));
         const global_index = i: {
             const gop = try o.anon_decl_map.getOrPut(gpa, exported_value);
             if (gop.found_existing) {
 @@ -1894,32 +1777,57 @@ pub const Object = struct {
             try variable_index.setInitializer(init_val, &o.builder);
             break :i global_index;
         };
-        return updateExportedGlobal(o, mod, global_index, exports);
+        return updateExportedGlobal(o, mod, global_index, export_indices);
     }
     fn updateExportedGlobal(
         o: *Object,
         mod: *Module,
         global_index: Builder.Global.Index,
-        exports: []const *Module.Export,
+        export_indices: []const u32,
     ) link.File.UpdateExportsError!void {
         const comp = mod.comp;
         const ip = &mod.intern_pool;
+        const first_export = mod.all_exports.items[export_indices[0]];
+        // We will rename this global to have a name matching `first_export`.
+        // Successive exports become aliases.
+        // If the first export name already exists, then there is a corresponding
+        // extern global - we replace it with this global.
+        const first_exp_name = try o.builder.strtabString(first_export.opts.name.toSlice(ip));
+        if (o.builder.getGlobal(first_exp_name)) |other_global| replace: {
+            if (other_global.toConst().getBase(&o.builder) == global_index.toConst().getBase(&o.builder)) {
+                break :replace; // this global already has the name we want
+            }
+            try global_index.takeName(other_global, &o.builder);
+            try other_global.replace(global_index, &o.builder);
+            // Problem: now we need to replace in the decl_map that
+            // the extern decl index points to this new global. However we don't
+            // know the decl index.
+            // Even if we did, a future incremental update to the extern would then
+            // treat the LLVM global as an extern rather than an export, so it would
+            // need a way to check that.
+            // This is a TODO that needs to be solved when making
+            // the LLVM backend support incremental compilation.
+        } else {
+            try global_index.rename(first_exp_name, &o.builder);
+        }
         global_index.setUnnamedAddr(.default, &o.builder);
         if (comp.config.dll_export_fns)
             global_index.setDllStorageClass(.dllexport, &o.builder);
-        global_index.setLinkage(switch (exports[0].opts.linkage) {
+        global_index.setLinkage(switch (first_export.opts.linkage) {
             .internal => unreachable,
             .strong => .external,
             .weak => .weak_odr,
             .link_once => .linkonce_odr,
         }, &o.builder);
-        global_index.setVisibility(switch (exports[0].opts.visibility) {
+        global_index.setVisibility(switch (first_export.opts.visibility) {
             .default => .default,
             .hidden => .hidden,
             .protected => .protected,
         }, &o.builder);
-        if (exports[0].opts.section.toSlice(ip)) |section|
+        if (first_export.opts.section.toSlice(ip)) |section|
             switch (global_index.ptrConst(&o.builder).kind) {
                 .variable => |impl_index| impl_index.setSection(
                     try o.builder.string(section),
 @@ -1936,7 +1844,8 @@ pub const Object = struct {
         // The planned solution to this is https://github.com/ziglang/zig/issues/13265
         // Until then we iterate over existing aliases and make them point
         // to the correct decl, or otherwise add a new alias. Old aliases are leaked.
-        for (exports[1..]) |exp| {
+        for (export_indices[1..]) |export_idx| {
+            const exp = mod.all_exports.items[export_idx];
             const exp_name = try o.builder.strtabString(exp.opts.name.toSlice(ip));
             if (o.builder.getGlobal(exp_name)) |global| {
                 switch (global.ptrConst(&o.builder).kind) {
 @@ -1944,7 +1853,13 @@ pub const Object = struct {
                         alias.setAliasee(global_index.toConst(), &o.builder);
                         continue;
                     },
-                    .variable, .function => {},
+                    .variable, .function => {
+                        // This existing global is an `extern` corresponding to this export.
+                        // Replace it with the global being exported.
+                        // This existing global must be replaced with the alias.
+                        try global.rename(.empty, &o.builder);
+                        try global.replace(global_index, &o.builder);
+                    },
                     .replaced => unreachable,
                 }
             }
 @@ -4762,36 +4677,77 @@ pub const DeclGen = struct {
                 else => try o.lowerValue(init_val),
             }, &o.builder);
+            if (decl.val.getVariable(zcu)) |decl_var| {
+                const decl_namespace = zcu.namespacePtr(decl.src_namespace);
+                const single_threaded = decl_namespace.file_scope.mod.single_threaded;
+                variable_index.setThreadLocal(
+                    if (decl_var.is_threadlocal and !single_threaded) .generaldynamic else .default,
+                    &o.builder,
+                );
+            }
             const line_number = decl.navSrcLine(zcu) + 1;
-            const is_internal_linkage = !o.module.decl_exports.contains(decl_index);
             const namespace = zcu.namespacePtr(decl.src_namespace);
             const owner_mod = namespace.file_scope.mod;
-            if (owner_mod.strip) return;
+            if (!owner_mod.strip) {
+                const debug_file = try o.getDebugFile(namespace.file_scope);
+                const debug_global_var = try o.builder.debugGlobalVar(
+                    try o.builder.metadataString(decl.name.toSlice(ip)), // Name
+                    try o.builder.metadataStringFromStrtabString(variable_index.name(&o.builder)), // Linkage name
+                    debug_file, // File
+                    debug_file, // Scope
+                    line_number,
+                    try o.lowerDebugType(decl.typeOf(zcu)),
+                    variable_index,
+                    .{ .local = !decl.isExtern(zcu) },
+                );
-            const debug_file = try o.getDebugFile(namespace.file_scope);
+                const debug_expression = try o.builder.debugExpression(&.{});
-            const debug_global_var = try o.builder.debugGlobalVar(
+                const debug_global_var_expression = try o.builder.debugGlobalVarExpression(
-                try o.builder.metadataString(decl.name.toSlice(ip)), // Name
+                    debug_global_var,
-                try o.builder.metadataStringFromStrtabString(variable_index.name(&o.builder)), // Linkage name
+                    debug_expression,
-                debug_file, // File
+                );
-                debug_file, // Scope
-                line_number,
-                try o.lowerDebugType(decl.typeOf(zcu)),
-                variable_index,
-                .{ .local = is_internal_linkage },
-            );
-            const debug_expression = try o.builder.debugExpression(&.{});
+                variable_index.setGlobalVariableExpression(debug_global_var_expression, &o.builder);
+                try o.debug_globals.append(o.gpa, debug_global_var_expression);
+            }
+        }
-            const debug_global_var_expression = try o.builder.debugGlobalVarExpression(
+        if (decl.isExtern(zcu)) {
-                debug_global_var,
+            const global_index = o.decl_map.get(decl_index).?;
-                debug_expression,
-            );
-            variable_index.setGlobalVariableExpression(debug_global_var_expression, &o.builder);
+            const decl_name = decl_name: {
-            try o.debug_globals.append(o.gpa, debug_global_var_expression);
+                if (zcu.getTarget().isWasm() and decl.typeOf(zcu).zigTypeTag(zcu) == .Fn) {
+                    if (decl.getOwnedExternFunc(zcu).?.lib_name.toSlice(ip)) |lib_name| {
+                        if (!std.mem.eql(u8, lib_name, "c")) {
+                            break :decl_name try o.builder.strtabStringFmt("{}|{s}", .{ decl.name.fmt(ip), lib_name });
+                        }
+                    }
+                }
+                break :decl_name try o.builder.strtabString(decl.name.toSlice(ip));
+            };
+            if (o.builder.getGlobal(decl_name)) |other_global| {
+                if (other_global != global_index) {
+                    // Another global already has this name; just use it in place of this global.
+                    try global_index.replace(other_global, &o.builder);
+                    return;
+                }
+            }
+            try global_index.rename(decl_name, &o.builder);
+            global_index.setLinkage(.external, &o.builder);
+            global_index.setUnnamedAddr(.default, &o.builder);
+            if (zcu.comp.config.dll_export_fns)
+                global_index.setDllStorageClass(.default, &o.builder);
+            if (decl.val.getVariable(zcu)) |decl_var| {
+                if (decl_var.is_weak_linkage) global_index.setLinkage(.extern_weak, &o.builder);
+            }
         }
     }
 };
 @@ -5193,7 +5149,6 @@ pub const FuncGen = struct {
             const fqn = try decl.fullyQualifiedName(zcu);
-            const is_internal_linkage = !zcu.decl_exports.contains(decl_index);
             const fn_ty = try zcu.funcType(.{
                 .param_types = &.{},
                 .return_type = .void_type,
 @@ -5211,7 +5166,7 @@ pub const FuncGen = struct {
                     .sp_flags = .{
                         .Optimized = owner_mod.optimize_mode != .Debug,
                         .Definition = true,
-                        .LocalToUnit = is_internal_linkage,
+                        .LocalToUnit = true, // TODO: we can't know this at this point, since the function could be exported later!
                     },
                 },
                 o.debug_compile_unit,

src/link.zig+6-6

...	@@ -606,12 +606,12 @@ pub const File = struct {	...	@@ -606,12 +606,12 @@ pub const File = struct {
606	base: *File,	606	base: *File,
607	module: *Module,	607	module: *Module,
608	exported: Module.Exported,	608	exported: Module.Exported,
609	exports: []const *Module.Export,	609	export_indices: []const u32,
610	) UpdateExportsError!void {	610	) UpdateExportsError!void {
611	switch (base.tag) {	611	switch (base.tag) {
612	inline else => \|tag\| {	612	inline else => \|tag\| {
613	if (tag != .c and build_options.only_c) unreachable;	613	if (tag != .c and build_options.only_c) unreachable;
614	return @as(*tag.Type(), @fieldParentPtr("base", base)).updateExports(module, exported, exports);	614	return @as(*tag.Type(), @fieldParentPtr("base", base)).updateExports(module, exported, export_indices);
615	},	615	},
616	}	616	}
617	}	617	}
...	@@ -671,11 +671,11 @@ pub const File = struct {	...	@@ -671,11 +671,11 @@ pub const File = struct {
671	}	671	}
672	}	672	}
673		673
674	pub fn deleteDeclExport(	674	pub fn deleteExport(
675	base: *File,	675	base: *File,
676	decl_index: InternPool.DeclIndex,	676	exported: Zcu.Exported,
677	name: InternPool.NullTerminatedString,	677	name: InternPool.NullTerminatedString,
678	) !void {	678	) void {
679	if (build_options.only_c) @compileError("unreachable");	679	if (build_options.only_c) @compileError("unreachable");
680	switch (base.tag) {	680	switch (base.tag) {
681	.plan9,	681	.plan9,
...	@@ -685,7 +685,7 @@ pub const File = struct {	...	@@ -685,7 +685,7 @@ pub const File = struct {
685	=> {},	685	=> {},
686		686
687	inline else => \|tag\| {	687	inline else => \|tag\| {
688	return @as(*tag.Type(), @fieldParentPtr("base", base)).deleteDeclExport(decl_index, name);	688	return @as(*tag.Type(), @fieldParentPtr("base", base)).deleteExport(exported, name);
689	},	689	},
690	}	690	}
691	}	691	}

src/link/C.zig+22-7

 @@ -183,6 +183,8 @@ pub fn updateFunc(
     air: Air,
     liveness: Liveness,
 ) !void {
+    if (true) @panic("TODO jacobly");
     const gpa = self.base.comp.gpa;
     const func = zcu.funcInfo(func_index);
 @@ -250,6 +252,8 @@ pub fn updateFunc(
 }
 fn updateAnonDecl(self: *C, zcu: *Zcu, i: usize) !void {
+    if (true) @panic("TODO jacobly");
     const gpa = self.base.comp.gpa;
     const anon_decl = self.anon_decls.keys()[i];
 @@ -306,6 +310,8 @@ fn updateAnonDecl(self: *C, zcu: *Zcu, i: usize) !void {
 }
 pub fn updateDecl(self: *C, zcu: *Zcu, decl_index: InternPool.DeclIndex) !void {
+    if (true) @panic("TODO jacobly");
     const tracy = trace(@src());
     defer tracy.end();
 @@ -390,6 +396,8 @@ fn abiDefines(self: *C, target: std.Target) !std.ArrayList(u8) {
 }
 pub fn flushModule(self: *C, arena: Allocator, prog_node: std.Progress.Node) !void {
+    if (true) @panic("TODO jacobly");
     _ = arena; // Has the same lifetime as the call to Compilation.update.
     const tracy = trace(@src());
 @@ -451,9 +459,16 @@ pub fn flushModule(self: *C, arena: Allocator, prog_node: std.Progress.Node) !vo
     {
         var export_names: std.AutoHashMapUnmanaged(InternPool.NullTerminatedString, void) = .{};
         defer export_names.deinit(gpa);
-        try export_names.ensureTotalCapacity(gpa, @intCast(zcu.decl_exports.entries.len));
+        try export_names.ensureTotalCapacity(gpa, @intCast(zcu.single_exports.count()));
-        for (zcu.decl_exports.values()) |exports| for (exports.items) |@"export"|
+        for (zcu.single_exports.values()) |export_idx| {
-            try export_names.put(gpa, @"export".opts.name, {});
+            export_names.putAssumeCapacity(gpa, zcu.all_exports.items[export_idx].opts.name, {});
+        }
+        for (zcu.multi_exports.values()) |info| {
+            try export_names.ensureUnusedCapacity(info.len);
+            for (zcu.all_exports.items[info.index..][0..info.len]) |export_idx| {
+                export_names.putAssumeCapacity(gpa, zcu.all_exports.items[export_idx].opts.name, {});
+            }
+        }
         for (self.anon_decls.values()) |*decl_block| {
             try self.flushDeclBlock(zcu, zcu.root_mod, &f, decl_block, export_names, .none);
 @@ -781,10 +796,10 @@ pub fn updateExports(
     self: *C,
     zcu: *Zcu,
     exported: Zcu.Exported,
-    exports: []const *Zcu.Export,
+    export_indices: []const u32,
 ) !void {
-    _ = exports;
-    _ = exported;
-    _ = zcu;
     _ = self;
+    _ = zcu;
+    _ = exported;
+    _ = export_indices;
 }

src/link/Coff.zig+18-17

 @@ -1162,9 +1162,7 @@ pub fn updateFunc(self: *Coff, mod: *Module, func_index: InternPool.Index, air:
     try self.updateDeclCode(decl_index, code, .FUNCTION);
-    // Since we updated the vaddr and the size, each corresponding export
+    // Exports will be updated by `Zcu.processExports` after the update.
-    // symbol also needs to be updated.
-    return self.updateExports(mod, .{ .decl_index = decl_index }, mod.getDeclExports(decl_index));
 }
 pub fn lowerUnnamedConst(self: *Coff, val: Value, decl_index: InternPool.DeclIndex) !u32 {
 @@ -1286,9 +1284,7 @@ pub fn updateDecl(
     try self.updateDeclCode(decl_index, code, .NULL);
-    // Since we updated the vaddr and the size, each corresponding export
+    // Exports will be updated by `Zcu.processExports` after the update.
-    // symbol also needs to be updated.
-    return self.updateExports(mod, .{ .decl_index = decl_index }, mod.getDeclExports(decl_index));
 }
 fn updateLazySymbolAtom(
 @@ -1509,7 +1505,7 @@ pub fn updateExports(
     self: *Coff,
     mod: *Module,
     exported: Module.Exported,
-    exports: []const *Module.Export,
+    export_indices: []const u32,
 ) link.File.UpdateExportsError!void {
     if (build_options.skip_non_native and builtin.object_format != .coff) {
         @panic("Attempted to compile for object format that was disabled by build configuration");
 @@ -1522,7 +1518,8 @@ pub fn updateExports(
     if (comp.config.use_llvm) {
         // Even in the case of LLVM, we need to notice certain exported symbols in order to
         // detect the default subsystem.
-        for (exports) |exp| {
+        for (export_indices) |export_idx| {
+            const exp = mod.all_exports.items[export_idx];
             const exported_decl_index = switch (exp.exported) {
                 .decl_index => |i| i,
                 .value => continue,
 @@ -1552,7 +1549,7 @@ pub fn updateExports(
         }
     }
-    if (self.llvm_object) |llvm_object| return llvm_object.updateExports(mod, exported, exports);
+    if (self.llvm_object) |llvm_object| return llvm_object.updateExports(mod, exported, export_indices);
     const gpa = comp.gpa;
 @@ -1562,7 +1559,7 @@ pub fn updateExports(
             break :blk self.decls.getPtr(decl_index).?;
         },
         .value => |value| self.anon_decls.getPtr(value) orelse blk: {
-            const first_exp = exports[0];
+            const first_exp = mod.all_exports.items[export_indices[0]];
             const res = try self.lowerAnonDecl(value, .none, first_exp.getSrcLoc(mod));
             switch (res) {
                 .ok => {},
 @@ -1570,7 +1567,7 @@ pub fn updateExports(
                     // TODO maybe it's enough to return an error here and let Module.processExportsInner
                     // handle the error?
                     try mod.failed_exports.ensureUnusedCapacity(mod.gpa, 1);
-                    mod.failed_exports.putAssumeCapacityNoClobber(first_exp, em);
+                    mod.failed_exports.putAssumeCapacityNoClobber(export_indices[0], em);
                     return;
                 },
             }
 @@ -1580,12 +1577,13 @@ pub fn updateExports(
     const atom_index = metadata.atom;
     const atom = self.getAtom(atom_index);
-    for (exports) |exp| {
+    for (export_indices) |export_idx| {
+        const exp = mod.all_exports.items[export_idx];
         log.debug("adding new export '{}'", .{exp.opts.name.fmt(&mod.intern_pool)});
         if (exp.opts.section.toSlice(&mod.intern_pool)) |section_name| {
             if (!mem.eql(u8, section_name, ".text")) {
-                try mod.failed_exports.putNoClobber(gpa, exp, try Module.ErrorMsg.create(
+                try mod.failed_exports.putNoClobber(gpa, export_idx, try Module.ErrorMsg.create(
                     gpa,
                     exp.getSrcLoc(mod),
                     "Unimplemented: ExportOptions.section",
 @@ -1596,7 +1594,7 @@ pub fn updateExports(
         }
         if (exp.opts.linkage == .link_once) {
-            try mod.failed_exports.putNoClobber(gpa, exp, try Module.ErrorMsg.create(
+            try mod.failed_exports.putNoClobber(gpa, export_idx, try Module.ErrorMsg.create(
                 gpa,
                 exp.getSrcLoc(mod),
                 "Unimplemented: GlobalLinkage.link_once",
 @@ -1641,13 +1639,16 @@ pub fn updateExports(
     }
 }
-pub fn deleteDeclExport(
+pub fn deleteExport(
     self: *Coff,
-    decl_index: InternPool.DeclIndex,
+    exported: Zcu.Exported,
     name: InternPool.NullTerminatedString,
 ) void {
     if (self.llvm_object) |_| return;
-    const metadata = self.decls.getPtr(decl_index) orelse return;
+    const metadata = switch (exported) {
+        .decl_index => |decl_index| self.decls.getPtr(decl_index) orelse return,
+        .value => |value| self.anon_decls.getPtr(value) orelse return,
+    };
     const mod = self.base.comp.module.?;
     const name_slice = name.toSlice(&mod.intern_pool);
     const sym_index = metadata.getExportPtr(self, name_slice) orelse return;

src/link/Elf.zig+6-6

...	@@ -3011,13 +3011,13 @@ pub fn updateExports(	...	@@ -3011,13 +3011,13 @@ pub fn updateExports(
3011	self: *Elf,	3011	self: *Elf,
3012	mod: *Module,	3012	mod: *Module,
3013	exported: Module.Exported,	3013	exported: Module.Exported,
3014	exports: []const *Module.Export,	3014	export_indices: []const u32,
3015	) link.File.UpdateExportsError!void {	3015	) link.File.UpdateExportsError!void {
3016	if (build_options.skip_non_native and builtin.object_format != .elf) {	3016	if (build_options.skip_non_native and builtin.object_format != .elf) {
3017	@panic("Attempted to compile for object format that was disabled by build configuration");	3017	@panic("Attempted to compile for object format that was disabled by build configuration");
3018	}	3018	}
3019	if (self.llvm_object) \|llvm_object\| return llvm_object.updateExports(mod, exported, exports);	3019	if (self.llvm_object) \|llvm_object\| return llvm_object.updateExports(mod, exported, export_indices);
3020	return self.zigObjectPtr().?.updateExports(self, mod, exported, exports);	3020	return self.zigObjectPtr().?.updateExports(self, mod, exported, export_indices);
3021	}	3021	}
3022		3022
3023	pub fn updateDeclLineNumber(self: Elf, mod: Module, decl_index: InternPool.DeclIndex) !void {	3023	pub fn updateDeclLineNumber(self: Elf, mod: Module, decl_index: InternPool.DeclIndex) !void {
...	@@ -3025,13 +3025,13 @@ pub fn updateDeclLineNumber(self: Elf, mod: Module, decl_index: InternPool.Dec	...	@@ -3025,13 +3025,13 @@ pub fn updateDeclLineNumber(self: Elf, mod: Module, decl_index: InternPool.Dec
3025	return self.zigObjectPtr().?.updateDeclLineNumber(mod, decl_index);	3025	return self.zigObjectPtr().?.updateDeclLineNumber(mod, decl_index);
3026	}	3026	}
3027		3027
3028	pub fn deleteDeclExport(	3028	pub fn deleteExport(
3029	self: *Elf,	3029	self: *Elf,
3030	decl_index: InternPool.DeclIndex,	3030	exported: Zcu.Exported,
3031	name: InternPool.NullTerminatedString,	3031	name: InternPool.NullTerminatedString,
3032	) void {	3032	) void {
3033	if (self.llvm_object) \|_\| return;	3033	if (self.llvm_object) \|_\| return;
3034	return self.zigObjectPtr().?.deleteDeclExport(self, decl_index, name);	3034	return self.zigObjectPtr().?.deleteExport(self, exported, name);
3035	}	3035	}
3036		3036
3037	fn addLinkerDefinedSymbols(self: *Elf) !void {	3037	fn addLinkerDefinedSymbols(self: *Elf) !void {

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

 @@ -1115,9 +1115,7 @@ pub fn updateFunc(
         );
     }
-    // Since we updated the vaddr and the size, each corresponding export
+    // Exports will be updated by `Zcu.processExports` after the update.
-    // symbol also needs to be updated.
-    return self.updateExports(elf_file, mod, .{ .decl_index = decl_index }, mod.getDeclExports(decl_index));
 }
 pub fn updateDecl(
 @@ -1194,9 +1192,7 @@ pub fn updateDecl(
         );
     }
-    // Since we updated the vaddr and the size, each corresponding export
+    // Exports will be updated by `Zcu.processExports` after the update.
-    // symbol also needs to be updated.
-    return self.updateExports(elf_file, mod, .{ .decl_index = decl_index }, mod.getDeclExports(decl_index));
 }
 fn updateLazySymbol(
 @@ -1386,7 +1382,7 @@ pub fn updateExports(
     elf_file: *Elf,
     mod: *Module,
     exported: Module.Exported,
-    exports: []const *Module.Export,
+    export_indices: []const u32,
 ) link.File.UpdateExportsError!void {
     const tracy = trace(@src());
     defer tracy.end();
 @@ -1398,7 +1394,7 @@ pub fn updateExports(
             break :blk self.decls.getPtr(decl_index).?;
         },
         .value => |value| self.anon_decls.getPtr(value) orelse blk: {
-            const first_exp = exports[0];
+            const first_exp = mod.all_exports.items[export_indices[0]];
             const res = try self.lowerAnonDecl(elf_file, value, .none, first_exp.getSrcLoc(mod));
             switch (res) {
                 .ok => {},
 @@ -1406,7 +1402,7 @@ pub fn updateExports(
                     // TODO maybe it's enough to return an error here and let Module.processExportsInner
                     // handle the error?
                     try mod.failed_exports.ensureUnusedCapacity(mod.gpa, 1);
-                    mod.failed_exports.putAssumeCapacityNoClobber(first_exp, em);
+                    mod.failed_exports.putAssumeCapacityNoClobber(export_indices[0], em);
                     return;
                 },
             }
 @@ -1418,11 +1414,12 @@ pub fn updateExports(
     const esym = self.local_esyms.items(.elf_sym)[esym_index];
     const esym_shndx = self.local_esyms.items(.shndx)[esym_index];
-    for (exports) |exp| {
+    for (export_indices) |export_idx| {
+        const exp = mod.all_exports.items[export_idx];
         if (exp.opts.section.unwrap()) |section_name| {
             if (!section_name.eqlSlice(".text", &mod.intern_pool)) {
                 try mod.failed_exports.ensureUnusedCapacity(mod.gpa, 1);
-                mod.failed_exports.putAssumeCapacityNoClobber(exp, try Module.ErrorMsg.create(
+                mod.failed_exports.putAssumeCapacityNoClobber(export_idx, try Module.ErrorMsg.create(
                     gpa,
                     exp.getSrcLoc(mod),
                     "Unimplemented: ExportOptions.section",
 @@ -1437,7 +1434,7 @@ pub fn updateExports(
             .weak => elf.STB_WEAK,
             .link_once => {
                 try mod.failed_exports.ensureUnusedCapacity(mod.gpa, 1);
-                mod.failed_exports.putAssumeCapacityNoClobber(exp, try Module.ErrorMsg.create(
+                mod.failed_exports.putAssumeCapacityNoClobber(export_idx, try Module.ErrorMsg.create(
                     gpa,
                     exp.getSrcLoc(mod),
                     "Unimplemented: GlobalLinkage.LinkOnce",
 @@ -1487,13 +1484,16 @@ pub fn updateDeclLineNumber(
     }
 }
-pub fn deleteDeclExport(
+pub fn deleteExport(
     self: *ZigObject,
     elf_file: *Elf,
-    decl_index: InternPool.DeclIndex,
+    exported: Zcu.Exported,
     name: InternPool.NullTerminatedString,
 ) void {
-    const metadata = self.decls.getPtr(decl_index) orelse return;
+    const metadata = switch (exported) {
+        .decl_index => |decl_index| self.decls.getPtr(decl_index) orelse return,
+        .value => |value| self.anon_decls.getPtr(value) orelse return,
+    };
     const mod = elf_file.base.comp.module.?;
     const exp_name = name.toSlice(&mod.intern_pool);
     const esym_index = metadata.@"export"(self, exp_name) orelse return;

src/link/MachO.zig+7-7

...	@@ -3196,22 +3196,22 @@ pub fn updateExports(	...	@@ -3196,22 +3196,22 @@ pub fn updateExports(
3196	self: *MachO,	3196	self: *MachO,
3197	mod: *Module,	3197	mod: *Module,
3198	exported: Module.Exported,	3198	exported: Module.Exported,
3199	exports: []const *Module.Export,	3199	export_indices: []const u32,
3200	) link.File.UpdateExportsError!void {	3200	) link.File.UpdateExportsError!void {
3201	if (build_options.skip_non_native and builtin.object_format != .macho) {	3201	if (build_options.skip_non_native and builtin.object_format != .macho) {
3202	@panic("Attempted to compile for object format that was disabled by build configuration");	3202	@panic("Attempted to compile for object format that was disabled by build configuration");
3203	}	3203	}
3204	if (self.llvm_object) \|llvm_object\| return llvm_object.updateExports(mod, exported, exports);	3204	if (self.llvm_object) \|llvm_object\| return llvm_object.updateExports(mod, exported, export_indices);
3205	return self.getZigObject().?.updateExports(self, mod, exported, exports);	3205	return self.getZigObject().?.updateExports(self, mod, exported, export_indices);
3206	}	3206	}
3207		3207
3208	pub fn deleteDeclExport(	3208	pub fn deleteExport(
3209	self: *MachO,	3209	self: *MachO,
3210	decl_index: InternPool.DeclIndex,	3210	exported: Zcu.Exported,
3211	name: InternPool.NullTerminatedString,	3211	name: InternPool.NullTerminatedString,
3212	) Allocator.Error!void {	3212	) void {
3213	if (self.llvm_object) \|_\| return;	3213	if (self.llvm_object) \|_\| return;
3214	return self.getZigObject().?.deleteDeclExport(self, decl_index, name);	3214	return self.getZigObject().?.deleteExport(self, exported, name);
3215	}	3215	}
3216		3216
3217	pub fn freeDecl(self: *MachO, decl_index: InternPool.DeclIndex) void {	3217	pub fn freeDecl(self: *MachO, decl_index: InternPool.DeclIndex) void {

src/link/MachO/ZigObject.zig+15-15

 @@ -713,9 +713,7 @@ pub fn updateFunc(
         );
     }
-    // Since we updated the vaddr and the size, each corresponding export
+    // Exports will be updated by `Zcu.processExports` after the update.
-    // symbol also needs to be updated.
-    return self.updateExports(macho_file, mod, .{ .decl_index = decl_index }, mod.getDeclExports(decl_index));
 }
 pub fn updateDecl(
 @@ -790,9 +788,7 @@ pub fn updateDecl(
         );
     }
-    // Since we updated the vaddr and the size, each corresponding export symbol also
+    // Exports will be updated by `Zcu.processExports` after the update.
-    // needs to be updated.
-    try self.updateExports(macho_file, mod, .{ .decl_index = decl_index }, mod.getDeclExports(decl_index));
 }
 fn updateDeclCode(
 @@ -1187,7 +1183,7 @@ pub fn updateExports(
     macho_file: *MachO,
     mod: *Module,
     exported: Module.Exported,
-    exports: []const *Module.Export,
+    export_indices: []const u32,
 ) link.File.UpdateExportsError!void {
     const tracy = trace(@src());
     defer tracy.end();
 @@ -1199,7 +1195,7 @@ pub fn updateExports(
             break :blk self.decls.getPtr(decl_index).?;
         },
         .value => |value| self.anon_decls.getPtr(value) orelse blk: {
-            const first_exp = exports[0];
+            const first_exp = mod.all_exports.items[export_indices[0]];
             const res = try self.lowerAnonDecl(macho_file, value, .none, first_exp.getSrcLoc(mod));
             switch (res) {
                 .ok => {},
 @@ -1207,7 +1203,7 @@ pub fn updateExports(
                     // TODO maybe it's enough to return an error here and let Module.processExportsInner
                     // handle the error?
                     try mod.failed_exports.ensureUnusedCapacity(mod.gpa, 1);
-                    mod.failed_exports.putAssumeCapacityNoClobber(first_exp, em);
+                    mod.failed_exports.putAssumeCapacityNoClobber(export_indices[0], em);
                     return;
                 },
             }
 @@ -1218,11 +1214,12 @@ pub fn updateExports(
     const nlist_idx = macho_file.getSymbol(sym_index).nlist_idx;
     const nlist = self.symtab.items(.nlist)[nlist_idx];
-    for (exports) |exp| {
+    for (export_indices) |export_idx| {
+        const exp = mod.all_exports.items[export_idx];
         if (exp.opts.section.unwrap()) |section_name| {
             if (!section_name.eqlSlice("__text", &mod.intern_pool)) {
                 try mod.failed_exports.ensureUnusedCapacity(mod.gpa, 1);
-                mod.failed_exports.putAssumeCapacityNoClobber(exp, try Module.ErrorMsg.create(
+                mod.failed_exports.putAssumeCapacityNoClobber(export_idx, try Module.ErrorMsg.create(
                     gpa,
                     exp.getSrcLoc(mod),
                     "Unimplemented: ExportOptions.section",
 @@ -1232,7 +1229,7 @@ pub fn updateExports(
             }
         }
         if (exp.opts.linkage == .link_once) {
-            try mod.failed_exports.putNoClobber(mod.gpa, exp, try Module.ErrorMsg.create(
+            try mod.failed_exports.putNoClobber(mod.gpa, export_idx, try Module.ErrorMsg.create(
                 gpa,
                 exp.getSrcLoc(mod),
                 "Unimplemented: GlobalLinkage.link_once",
 @@ -1364,15 +1361,18 @@ pub fn updateDeclLineNumber(self: *ZigObject, mod: *Module, decl_index: InternPo
     }
 }
-pub fn deleteDeclExport(
+pub fn deleteExport(
     self: *ZigObject,
     macho_file: *MachO,
-    decl_index: InternPool.DeclIndex,
+    exported: Zcu.Exported,
     name: InternPool.NullTerminatedString,
 ) void {
     const mod = macho_file.base.comp.module.?;
-    const metadata = self.decls.getPtr(decl_index) orelse return;
+    const metadata = switch (exported) {
+        .decl_index => |decl_index| self.decls.getPtr(decl_index) orelse return,
+        .value => |value| self.anon_decls.getPtr(value) orelse return,
+    };
     const nlist_index = metadata.@"export"(self, name.toSlice(&mod.intern_pool)) orelse return;
     log.debug("deleting export '{}'", .{name.fmt(&mod.intern_pool)});

src/link/NvPtx.zig+2-2

...	@@ -96,12 +96,12 @@ pub fn updateExports(	...	@@ -96,12 +96,12 @@ pub fn updateExports(
96	self: *NvPtx,	96	self: *NvPtx,
97	module: *Module,	97	module: *Module,
98	exported: Module.Exported,	98	exported: Module.Exported,
99	exports: []const *Module.Export,	99	export_indices: []const u32,
100	) !void {	100	) !void {
101	if (build_options.skip_non_native and builtin.object_format != .nvptx)	101	if (build_options.skip_non_native and builtin.object_format != .nvptx)
102	@panic("Attempted to compile for object format that was disabled by build configuration");	102	@panic("Attempted to compile for object format that was disabled by build configuration");
103		103
104	return self.llvm_object.updateExports(module, exported, exports);	104	return self.llvm_object.updateExports(module, exported, export_indices);
105	}	105	}
106		106
107	pub fn freeDecl(self: *NvPtx, decl_index: InternPool.DeclIndex) void {	107	pub fn freeDecl(self: *NvPtx, decl_index: InternPool.DeclIndex) void {

src/link/Plan9.zig+44-22

 @@ -60,6 +60,9 @@ fn_decl_table: std.AutoArrayHashMapUnmanaged(
 ) = .{},
 /// the code is modified when relocated, so that is why it is mutable
 data_decl_table: std.AutoArrayHashMapUnmanaged(InternPool.DeclIndex, []u8) = .{},
+/// When `updateExports` is called, we store the export indices here, to be used
+/// during flush.
+decl_exports: std.AutoArrayHashMapUnmanaged(InternPool.DeclIndex, []u32) = .{},
 /// Table of unnamed constants associated with a parent `Decl`.
 /// We store them here so that we can free the constants whenever the `Decl`
 @@ -770,8 +773,8 @@ pub fn flushModule(self: *Plan9, arena: Allocator, prog_node: std.Progress.Node)
                     mem.writeInt(u64, got_table[atom.got_index.? * 8 ..][0..8], off, target.cpu.arch.endian());
                 }
                 self.syms.items[atom.sym_index.?].value = off;
-                if (mod.decl_exports.get(decl_index)) |exports| {
+                if (self.decl_exports.get(decl_index)) |export_indices| {
-                    try self.addDeclExports(mod, decl_index, exports.items);
+                    try self.addDeclExports(mod, decl_index, export_indices);
                 }
             }
         }
 @@ -836,8 +839,8 @@ pub fn flushModule(self: *Plan9, arena: Allocator, prog_node: std.Progress.Node)
                 mem.writeInt(u64, got_table[atom.got_index.? * 8 ..][0..8], off, target.cpu.arch.endian());
             }
             self.syms.items[atom.sym_index.?].value = off;
-            if (mod.decl_exports.get(decl_index)) |exports| {
+            if (self.decl_exports.get(decl_index)) |export_indices| {
-                try self.addDeclExports(mod, decl_index, exports.items);
+                try self.addDeclExports(mod, decl_index, export_indices);
             }
         }
         // write the unnamed constants after the other data decls
 @@ -1007,20 +1010,21 @@ fn addDeclExports(
     self: *Plan9,
     mod: *Module,
     decl_index: InternPool.DeclIndex,
-    exports: []const *Module.Export,
+    export_indices: []const u32,
 ) !void {
     const gpa = self.base.comp.gpa;
     const metadata = self.decls.getPtr(decl_index).?;
     const atom = self.getAtom(metadata.index);
-    for (exports) |exp| {
+    for (export_indices) |export_idx| {
+        const exp = mod.all_exports.items[export_idx];
         const exp_name = exp.opts.name.toSlice(&mod.intern_pool);
         // plan9 does not support custom sections
         if (exp.opts.section.unwrap()) |section_name| {
             if (!section_name.eqlSlice(".text", &mod.intern_pool) and
                 !section_name.eqlSlice(".data", &mod.intern_pool))
             {
-                try mod.failed_exports.put(mod.gpa, exp, try Module.ErrorMsg.create(
+                try mod.failed_exports.put(mod.gpa, export_idx, try Module.ErrorMsg.create(
                     gpa,
                     mod.declPtr(decl_index).navSrcLoc(mod).upgrade(mod),
                     "plan9 does not support extra sections",
 @@ -1152,15 +1156,23 @@ pub fn updateExports(
     self: *Plan9,
     module: *Module,
     exported: Module.Exported,
-    exports: []const *Module.Export,
+    export_indices: []const u32,
 ) !void {
+    const gpa = self.base.comp.gpa;
     switch (exported) {
         .value => @panic("TODO: plan9 updateExports handling values"),
-        .decl_index => |decl_index| _ = try self.seeDecl(decl_index),
+        .decl_index => |decl_index| {
+            _ = try self.seeDecl(decl_index);
+            if (self.decl_exports.fetchSwapRemove(decl_index)) |kv| {
+                gpa.free(kv.value);
+            }
+            try self.decl_exports.ensureUnusedCapacity(gpa, 1);
+            const duped_indices = try gpa.dupe(u32, export_indices);
+            self.decl_exports.putAssumeCapacityNoClobber(decl_index, duped_indices);
+        },
     }
-    // we do all the things in flush
+    // all proper work is done in flush
     _ = module;
-    _ = exports;
 }
 pub fn getOrCreateAtomForLazySymbol(self: *Plan9, sym: File.LazySymbol) !Atom.Index {
 @@ -1290,6 +1302,10 @@ pub fn deinit(self: *Plan9) void {
         gpa.free(self.syms.items[sym_index].name);
     }
     self.data_decl_table.deinit(gpa);
+    for (self.decl_exports.values()) |export_indices| {
+        gpa.free(export_indices);
+    }
+    self.decl_exports.deinit(gpa);
     self.syms.deinit(gpa);
     self.got_index_free_list.deinit(gpa);
     self.syms_index_free_list.deinit(gpa);
 @@ -1395,10 +1411,13 @@ pub fn writeSyms(self: *Plan9, buf: *std.ArrayList(u8)) !void {
             const atom = self.getAtom(decl_metadata.index);
             const sym = self.syms.items[atom.sym_index.?];
             try self.writeSym(writer, sym);
-            if (self.base.comp.module.?.decl_exports.get(decl_index)) |exports| {
+            if (self.decl_exports.get(decl_index)) |export_indices| {
-                for (exports.items) |e| if (decl_metadata.getExport(self, e.opts.name.toSlice(ip))) |exp_i| {
+                for (export_indices) |export_idx| {
-                    try self.writeSym(writer, self.syms.items[exp_i]);
+                    const exp = mod.all_exports.items[export_idx];
-                };
+                    if (decl_metadata.getExport(self, exp.opts.name.toSlice(ip))) |exp_i| {
+                        try self.writeSym(writer, self.syms.items[exp_i]);
+                    }
+                }
             }
         }
     }
 @@ -1442,13 +1461,16 @@ pub fn writeSyms(self: *Plan9, buf: *std.ArrayList(u8)) !void {
                 const atom = self.getAtom(decl_metadata.index);
                 const sym = self.syms.items[atom.sym_index.?];
                 try self.writeSym(writer, sym);
-                if (self.base.comp.module.?.decl_exports.get(decl_index)) |exports| {
+                if (self.decl_exports.get(decl_index)) |export_indices| {
-                    for (exports.items) |e| if (decl_metadata.getExport(self, e.opts.name.toSlice(ip))) |exp_i| {
+                    for (export_indices) |export_idx| {
-                        const s = self.syms.items[exp_i];
+                        const exp = mod.all_exports.items[export_idx];
-                        if (mem.eql(u8, s.name, "_start"))
+                        if (decl_metadata.getExport(self, exp.opts.name.toSlice(ip))) |exp_i| {
-                            self.entry_val = s.value;
+                            const s = self.syms.items[exp_i];
-                        try self.writeSym(writer, s);
+                            if (mem.eql(u8, s.name, "_start"))
-                    };
+                                self.entry_val = s.value;
+                            try self.writeSym(writer, s);
+                        }
+                    }
                 }
             }
         }

src/link/SpirV.zig+3-2

...	@@ -152,7 +152,7 @@ pub fn updateExports(	...	@@ -152,7 +152,7 @@ pub fn updateExports(
152	self: *SpirV,	152	self: *SpirV,
153	mod: *Module,	153	mod: *Module,
154	exported: Module.Exported,	154	exported: Module.Exported,
155	exports: []const *Module.Export,	155	export_indices: []const u32,
156	) !void {	156	) !void {
157	const decl_index = switch (exported) {	157	const decl_index = switch (exported) {
158	.decl_index => \|i\| i,	158	.decl_index => \|i\| i,
...	@@ -177,7 +177,8 @@ pub fn updateExports(	...	@@ -177,7 +177,8 @@ pub fn updateExports(
177	if ((!is_vulkan and execution_model == .Kernel) or	177	if ((!is_vulkan and execution_model == .Kernel) or
178	(is_vulkan and (execution_model == .Fragment or execution_model == .Vertex)))	178	(is_vulkan and (execution_model == .Fragment or execution_model == .Vertex)))
179	{	179	{
180	for (exports) \|exp\| {	180	for (export_indices) \|export_idx\| {
		181	const exp = mod.all_exports.items[export_idx];
181	try self.object.spv.declareEntryPoint(	182	try self.object.spv.declareEntryPoint(
182	spv_decl_index,	183	spv_decl_index,
183	exp.opts.name.toSlice(&mod.intern_pool),	184	exp.opts.name.toSlice(&mod.intern_pool),

src/link/Wasm.zig+6-6

...	@@ -1542,26 +1542,26 @@ pub fn getAnonDeclVAddr(wasm: *Wasm, decl_val: InternPool.Index, reloc_info: lin	...	@@ -1542,26 +1542,26 @@ pub fn getAnonDeclVAddr(wasm: *Wasm, decl_val: InternPool.Index, reloc_info: lin
1542	return wasm.zigObjectPtr().?.getAnonDeclVAddr(wasm, decl_val, reloc_info);	1542	return wasm.zigObjectPtr().?.getAnonDeclVAddr(wasm, decl_val, reloc_info);
1543	}	1543	}
1544		1544
1545	pub fn deleteDeclExport(	1545	pub fn deleteExport(
1546	wasm: *Wasm,	1546	wasm: *Wasm,
1547	decl_index: InternPool.DeclIndex,	1547	exported: Zcu.Exported,
1548	name: InternPool.NullTerminatedString,	1548	name: InternPool.NullTerminatedString,
1549	) void {	1549	) void {
1550	if (wasm.llvm_object) \|_\| return;	1550	if (wasm.llvm_object) \|_\| return;
1551	return wasm.zigObjectPtr().?.deleteDeclExport(wasm, decl_index, name);	1551	return wasm.zigObjectPtr().?.deleteExport(wasm, exported, name);
1552	}	1552	}
1553		1553
1554	pub fn updateExports(	1554	pub fn updateExports(
1555	wasm: *Wasm,	1555	wasm: *Wasm,
1556	mod: *Module,	1556	mod: *Module,
1557	exported: Module.Exported,	1557	exported: Module.Exported,
1558	exports: []const *Module.Export,	1558	export_indices: []const u32,
1559	) !void {	1559	) !void {
1560	if (build_options.skip_non_native and builtin.object_format != .wasm) {	1560	if (build_options.skip_non_native and builtin.object_format != .wasm) {
1561	@panic("Attempted to compile for object format that was disabled by build configuration");	1561	@panic("Attempted to compile for object format that was disabled by build configuration");
1562	}	1562	}
1563	if (wasm.llvm_object) \|llvm_object\| return llvm_object.updateExports(mod, exported, exports);	1563	if (wasm.llvm_object) \|llvm_object\| return llvm_object.updateExports(mod, exported, export_indices);
1564	return wasm.zigObjectPtr().?.updateExports(wasm, mod, exported, exports);	1564	return wasm.zigObjectPtr().?.updateExports(wasm, mod, exported, export_indices);
1565	}	1565	}
1566		1566
1567	pub fn freeDecl(wasm: *Wasm, decl_index: InternPool.DeclIndex) void {	1567	pub fn freeDecl(wasm: *Wasm, decl_index: InternPool.DeclIndex) void {

src/link/Wasm/ZigObject.zig+11-6

 @@ -833,13 +833,17 @@ pub fn getAnonDeclVAddr(
     return target_symbol_index;
 }
-pub fn deleteDeclExport(
+pub fn deleteExport(
     zig_object: *ZigObject,
     wasm_file: *Wasm,
-    decl_index: InternPool.DeclIndex,
+    exported: Zcu.Exported,
     name: InternPool.NullTerminatedString,
 ) void {
     const mod = wasm_file.base.comp.module.?;
+    const decl_index = switch (exported) {
+        .decl_index => |decl_index| decl_index,
+        .value => @panic("TODO: implement Wasm linker code for exporting a constant value"),
+    };
     const decl_info = zig_object.decls_map.getPtr(decl_index) orelse return;
     if (decl_info.@"export"(zig_object, name.toSlice(&mod.intern_pool))) |sym_index| {
         const sym = zig_object.symbol(sym_index);
 @@ -856,7 +860,7 @@ pub fn updateExports(
     wasm_file: *Wasm,
     mod: *Module,
     exported: Module.Exported,
-    exports: []const *Module.Export,
+    export_indices: []const u32,
 ) !void {
     const decl_index = switch (exported) {
         .decl_index => |i| i,
 @@ -873,9 +877,10 @@ pub fn updateExports(
     const gpa = mod.gpa;
     log.debug("Updating exports for decl '{}'", .{decl.name.fmt(&mod.intern_pool)});
-    for (exports) |exp| {
+    for (export_indices) |export_idx| {
+        const exp = mod.all_exports.items[export_idx];
         if (exp.opts.section.toSlice(&mod.intern_pool)) |section| {
-            try mod.failed_exports.putNoClobber(gpa, exp, try Module.ErrorMsg.create(
+            try mod.failed_exports.putNoClobber(gpa, export_idx, try Module.ErrorMsg.create(
                 gpa,
                 decl.navSrcLoc(mod).upgrade(mod),
                 "Unimplemented: ExportOptions.section '{s}'",
 @@ -908,7 +913,7 @@ pub fn updateExports(
             },
             .strong => {}, // symbols are strong by default
             .link_once => {
-                try mod.failed_exports.putNoClobber(gpa, exp, try Module.ErrorMsg.create(
+                try mod.failed_exports.putNoClobber(gpa, export_idx, try Module.ErrorMsg.create(
                     gpa,
                     decl.navSrcLoc(mod).upgrade(mod),
                     "Unimplemented: LinkOnce",