shard: fix COFF anon dups, module-asm routing, cross-shard @export aliases; IES yield

- llvm/Builder.zig + ir.zig: add COMDAT support (MODULE_CODE_COMDAT
  records, Variable.comdat field, addComdat). Required for COFF — without
  comdat any, linkonce_odr emits as a strong def per shard and lld-link
  rejects ~350 duplicate __anon_* symbols.
- codegen/llvm.zig resolveGlobalUav/updateExportedValue: setComdat(.any)
  on COFF for sharded linkonce_odr uavs.
- Zcu.navShard: switch from fqn-hash to file-hash via File.computeShard;
  add analUnitShard mapping comptime/nav/func units to their file's shard.
- codegen/llvm.zig genModuleLevelAssembly: route each global asm block to
  its source file's shard so .set aliases resolve against same-module defs.
- codegen/llvm.zig PartitionSet.updateExports: broadcast to all shards;
  Object.updateExports collapses non-owner extern globals onto one
  canonical decl so InstCombine cannot fold &a==&b to false pre-link.
- Zcu.isClaimedByOther + Sema.resolveInferredErrorSet: when the IES func
  is claimed by another thread, set tls_retry_loop and yield (cap 8)
  instead of parking in claimOrWait. Reuses existing requeue path.

Author: alii

lib/std/zig/llvm/Builder.zig

@@ -42,6 +42,7 @@ next_unique_global_id: std.AutoHashMapUnmanaged(StrtabString, u32),
 aliases: std.ArrayListUnmanaged(Alias),
 variables: std.ArrayListUnmanaged(Variable),
 functions: std.ArrayListUnmanaged(Function),
+comdats: std.ArrayListUnmanaged(Comdat),
 
 strtab_string_map: std.AutoArrayHashMapUnmanaged(void, void),
 strtab_string_indices: std.ArrayListUnmanaged(u32),
@@ -2513,12 +2514,37 @@ pub const Alias = struct {
     };
 };
 
+pub const Comdat = struct {
+    name: StrtabString,
+    kind: SelectionKind,
+
+    /// Matches LLVM's bitc::ComdatSelectionKindCodes.
+    pub const SelectionKind = enum(u3) {
+        any = 1,
+        exactmatch = 2,
+        largest = 3,
+        nodeduplicate = 4,
+        samesize = 5,
+    };
+
+    pub const Index = enum(u32) {
+        /// Stored 1-based to match the bitcode encoding (0 = no comdat).
+        none = 0,
+        _,
+
+        pub fn ptrConst(self: Index, builder: *const Builder) *const Comdat {
+            return &builder.comdats.items[@intFromEnum(self) - 1];
+        }
+    };
+};
+
 pub const Variable = struct {
     global: Global.Index,
     thread_local: ThreadLocal = .default,
     mutability: Mutability = .global,
     init: Constant = .no_init,
     section: String = .none,
+    comdat: Comdat.Index = .none,
     alignment: Alignment = .default,
 
     pub const Index = enum(u32) {
@@ -2595,6 +2621,10 @@ pub const Variable = struct {
             self.ptr(builder).section = section;
         }
 
+        pub fn setComdat(self: Index, comdat: Comdat.Index, builder: *Builder) void {
+            self.ptr(builder).comdat = comdat;
+        }
+
         pub fn setAlignment(self: Index, alignment: Alignment, builder: *Builder) void {
             self.ptr(builder).alignment = alignment;
         }
@@ -8603,6 +8633,7 @@ pub fn init(options: Options) Allocator.Error!Builder {
         .aliases = .{},
         .variables = .{},
         .functions = .{},
+        .comdats = .{},
 
         .strtab_string_map = .{},
         .strtab_string_indices = .{},
@@ -8752,6 +8783,7 @@ pub fn deinit(self: *Builder) void {
     self.variables.deinit(self.gpa);
     for (self.functions.items) |*function| function.deinit(self.gpa);
     self.functions.deinit(self.gpa);
+    self.comdats.deinit(self.gpa);
 
     self.strtab_string_map.deinit(self.gpa);
     self.strtab_string_indices.deinit(self.gpa);
@@ -9007,6 +9039,16 @@ pub fn addAliasAssumeCapacity(
     return alias_index;
 }
 
+pub fn addComdat(
+    self: *Builder,
+    name: StrtabString,
+    kind: Comdat.SelectionKind,
+) Allocator.Error!Comdat.Index {
+    assert(!name.isAnon());
+    try self.comdats.append(self.gpa, .{ .name = name, .kind = kind });
+    return @enumFromInt(self.comdats.items.len);
+}
+
 pub fn addVariable(
     self: *Builder,
     name: StrtabString,
@@ -9564,6 +9606,14 @@ pub fn print(self: *Builder, w: *Writer) (Writer.Error || Allocator.Error)!void
         , .{ id.fmt(self), ty.fmt(self, .default) });
     }
 
+    if (self.comdats.items.len > 0) {
+        if (need_newline) try w.writeByte('\n') else need_newline = true;
+        for (self.comdats.items) |comdat| try w.print(
+            \\${f} = comdat {s}
+            \\
+        , .{ comdat.name.fmt(self, .quote_unless_valid_identifier), @tagName(comdat.kind) });
+    }
+
     if (self.variables.items.len > 0) {
         if (need_newline) try w.writeByte('\n') else need_newline = true;
         for (self.variables.items) |variable| {
@@ -9572,7 +9622,7 @@ pub fn print(self: *Builder, w: *Writer) (Writer.Error || Allocator.Error)!void
             metadata_formatter.need_comma = true;
             defer metadata_formatter.need_comma = undefined;
             try w.print(
-                \\{f} ={f}{f}{f}{f}{f}{f}{f}{f} {s} {f}{f}{f}{f}
+                \\{f} ={f}{f}{f}{f}{f}{f}{f}{f} {s} {f}{f}{s}{f}{f}
                 \\
             , .{
                 variable.global.fmt(self),
@@ -9589,6 +9639,7 @@ pub fn print(self: *Builder, w: *Writer) (Writer.Error || Allocator.Error)!void
                 @tagName(variable.mutability),
                 global.type.fmt(self, .percent),
                 variable.init.fmt(self, .{ .space = true }),
+                if (variable.comdat != .none) ", comdat" else "",
                 variable.alignment.fmt(", "),
                 try metadata_formatter.fmt("!dbg ", global.dbg, null),
             });
@@ -13663,6 +13714,18 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco
             defer section_map.deinit(self.gpa);
             try section_map.ensureUnusedCapacity(self.gpa, globals.count());
 
+            // COMDAT records must precede any global that references them by index.
+            for (self.comdats.items) |comdat| {
+                const name_index = comdat.name.toIndex().?;
+                const offset = self.strtab_string_indices.items[name_index];
+                const size = self.strtab_string_indices.items[name_index + 1] - offset;
+                try module_block.writeAbbrev(Module.Comdat{
+                    .strtab_offset = offset,
+                    .strtab_size = size,
+                    .selection_kind = comdat.kind,
+                });
+            }
+
             for (self.variables.items) |variable| {
                 if (variable.global.getReplacement(self) != .none) continue;
 
@@ -13706,6 +13769,7 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco
                     .unnamed_addr = global.unnamed_addr,
                     .externally_initialized = global.externally_initialized,
                     .dllstorageclass = global.dll_storage_class,
+                    .comdat = @intFromEnum(variable.comdat),
                     .preemption = global.preemption,
                 });
             }

lib/std/zig/llvm/ir.zig

@@ -193,6 +193,7 @@ pub const Module = struct {
         Variable,
         Function,
         Alias,
+        Comdat,
     };
 
     pub const Version = struct {
@@ -211,6 +212,18 @@ pub const Module = struct {
         string: []const u8,
     };
 
+    pub const Comdat = struct {
+        pub const ops = [_]AbbrevOp{
+            .{ .literal = 12 }, // MODULE_CODE_COMDAT
+            .{ .vbr = 16 }, // strtab_offset
+            .{ .vbr = 16 }, // strtab_size
+            .{ .fixed = @bitSizeOf(Builder.Comdat.SelectionKind) },
+        };
+        strtab_offset: usize,
+        strtab_size: usize,
+        selection_kind: Builder.Comdat.SelectionKind,
+    };
+
     pub const Variable = struct {
         const AddrSpaceAndIsConst = packed struct {
             is_const: bool,
@@ -233,7 +246,7 @@ pub const Module = struct {
             .{ .fixed = @bitSizeOf(Builder.UnnamedAddr) },
             .{ .fixed = @bitSizeOf(Builder.ExternallyInitialized) },
             .{ .fixed = @bitSizeOf(Builder.DllStorageClass) },
-            .{ .literal = 0 }, // comdat
+            .{ .vbr = 16 }, // comdat
             .{ .literal = 0 }, // attributes
             .{ .fixed = @bitSizeOf(Builder.Preemption) },
         };
@@ -250,6 +263,7 @@ pub const Module = struct {
         unnamed_addr: Builder.UnnamedAddr,
         externally_initialized: Builder.ExternallyInitialized,
         dllstorageclass: Builder.DllStorageClass,
+        comdat: u32,
         preemption: Builder.Preemption,
     };
 

src/Sema.zig

@@ -35280,7 +35280,30 @@ fn resolveInferredErrorSet(
         // In this case we are dealing with the actual InferredErrorSet object that
         // corresponds to the function, not one created to track an inline/comptime call.
         const orig_func_index = ip.unwrapCoercedFunc(func_index);
-        try sema.addReferenceEntry(block, src, .wrap(.{ .func = orig_func_index }));
+        const ies_unit: AnalUnit = .wrap(.{ .func = orig_func_index });
+        if (zcu.parallel_sema and zcu.isClaimedByOther(ies_unit)) {
+            // The IES owner's body is being analysed by another worker right
+            // now. `ensureFuncBodyUpToDate` would park this thread on
+            // `sema_claim_cond` until that worker finishes — under chained
+            // IES dependencies that idles a core for the bulk of Sema.
+            // Instead, yield: re-queue `sema.owner` and let this thread
+            // pull the next job. Cap retries low because each one re-runs
+            // the caller's body from scratch; once the cap is hit, fall
+            // through to the blocking wait.
+            zcu.sema_retry_mutex.lock();
+            const tries: u8 = blk: {
+                const gop = zcu.sema_retry_counts.getOrPut(zcu.gpa, ies_unit) catch break :blk 255;
+                if (!gop.found_existing) gop.value_ptr.* = 0;
+                gop.value_ptr.* +|= 1;
+                break :blk gop.value_ptr.*;
+            };
+            zcu.sema_retry_mutex.unlock();
+            if (tries < 8) {
+                Zcu.tls_retry_loop = sema.owner;
+                return error.AnalysisFail;
+            }
+        }
+        try sema.addReferenceEntry(block, src, ies_unit);
         try pt.ensureFuncBodyUpToDate(orig_func_index);
     }
 

src/Zcu.zig

@@ -3742,6 +3742,19 @@ pub fn releaseClaim(zcu: *Zcu, unit: AnalUnit) void {
     zcu.sema_claim_cond.broadcast();
 }
 
+/// Returns true if `unit` is currently claimed for analysis by a thread other
+/// than the caller. Used by `Sema.resolveInferredErrorSet` to yield-and-requeue
+/// instead of parking on `sema_claim_cond` when a dependency IES is already in
+/// progress on another worker.
+pub fn isClaimedByOther(zcu: *Zcu, unit: AnalUnit) bool {
+    if (!zcu.parallel_sema) return false;
+    const me = std.Thread.getCurrentId();
+    zcu.unit_claims_mutex.lock();
+    defer zcu.unit_claims_mutex.unlock();
+    const owner = zcu.unit_claims.get(unit) orelse return false;
+    return owner != me;
+}
+
 /// Under parallel Sema, `analysis_in_progress` is per-OS-thread (lock-free).
 threadlocal var tls_aip: std.AutoArrayHashMapUnmanaged(AnalUnit, void) = .empty;
 /// Set by `ensureNavResolved` when a dependency loop is detected under
@@ -4650,10 +4663,27 @@ pub fn navFileScope(zcu: *Zcu, nav: InternPool.Nav.Index) *File {
 }
 
 pub fn navShard(zcu: *Zcu, nav: InternPool.Nav.Index, n: u32) u32 {
+    if (n <= 1) return 0;
+    return zcu.navFileScope(nav).computeShard(n);
+}
+
+/// Returns the LLVM codegen shard that owns `unit`. Module-level assembly is
+/// keyed by `AnalUnit`; routing each asm string to the same shard as the
+/// same-file navs it references (e.g. `.set` alias targets) lets the integrated
+/// assembler resolve those symbols and avoids emitting any string twice.
+pub fn analUnitShard(zcu: *Zcu, unit: AnalUnit, n: u32) u32 {
     if (n <= 1) return 0;
     const ip = &zcu.intern_pool;
-    const fqn = ip.getNav(nav).fqn.toSlice(ip);
-    return @intCast(std.hash.Wyhash.hash(0, fqn) % n);
+    return switch (unit.unwrap()) {
+        .@"comptime" => |cu_id| s: {
+            const cu = ip.getComptimeUnit(cu_id);
+            const resolved = cu.zir_index.resolveFull(ip) orelse break :s 0;
+            break :s zcu.fileByIndex(resolved.file).computeShard(n);
+        },
+        .nav_val, .nav_ty => |nav| zcu.navShard(nav, n),
+        .func => |func| zcu.navShard(zcu.funcInfo(func).owner_nav, n),
+        .type, .memoized_state => 0,
+    };
 }
 
 pub fn fmtAnalUnit(zcu: *Zcu, unit: AnalUnit) std.fmt.Formatter(FormatAnalUnit, formatAnalUnit) {