From 2a122576c3042c30f9a78492252cbbc4c0424a40 Mon Sep 17 00:00:00 2001 From: Jacob Young Date: Tue, 11 Aug 2026 10:16:38 -0400 Subject: [PATCH] Sema: avoid using `InternPool.Index` in names These are not planned to ever be deterministic. --- src/Compilation.zig | 1 + src/InternPool.zig | 9 +++++++-- src/Sema.zig | 4 +++- src/Zcu.zig | 3 +++ src/link/Coff.zig | 21 ++++++++++----------- src/link/Elf2.zig | 13 +++---------- src/link/Wasm.zig | 12 ++---------- 7 files changed, 29 insertions(+), 34 deletions(-) diff --git a/src/Compilation.zig b/src/Compilation.zig index 532bad3ac8ff21197395c4c0b6ed664f6bfb5cd9..4866b12ed7c2df92509e891f3625b1332c471e48 100644 --- a/src/Compilation.zig +++ b/src/Compilation.zig @@ -2101,6 +2101,7 @@ pub fn create(gpa: Allocator, arena: Allocator, io: Io, diag: *CreateDiagnostic, .analysis_roots_buffer = undefined, .analysis_roots_len = 0, .codegen_task_pool = try .init(arena), + .anon_name_counter = 0, }; try zcu.init(gpa, io, options.thread_limit); break :blk zcu; diff --git a/src/InternPool.zig b/src/InternPool.zig index 3451106fc2d00ab4be5642d729a7c15784b0d146..a21518c53837621886ebe51f1f92c4badd75536e 100644 --- a/src/InternPool.zig +++ b/src/InternPool.zig @@ -9503,6 +9503,7 @@ pub const GetFuncInstanceKey = struct { is_noinline: bool, generic_owner: Index, inferred_error_set: bool, + anon_name_counter: *u32, }; pub fn getFuncInstance( @@ -9580,6 +9581,7 @@ pub fn getFuncInstance( generic_owner, func_index, func_extra_index, + arg.anon_name_counter, ); return gop.put(); } @@ -9731,6 +9733,7 @@ fn getFuncInstanceIes( generic_owner, func_index, func_extra_index, + arg.anon_name_counter, ); func_gop.putFinal(func_index); @@ -9749,14 +9752,16 @@ fn finishFuncInstance( generic_owner: Index, func_index: Index, func_extra_index: u32, + anon_name_counter: *u32, ) Allocator.Error!void { const fn_owner_nav = ip.getNav(ip.funcDeclInfo(generic_owner).owner_nav); const fn_namespace = fn_owner_nav.analysis.?.namespace; // TODO: improve this name - const nav_name = try ip.getOrPutStringFmt(gpa, io, tid, "{f}__anon_{d}", .{ - fn_owner_nav.name.fmt(ip), @backingInt(func_index), + const nav_name = try ip.getOrPutStringFmt(gpa, io, tid, "{f}__func_{d}", .{ + fn_owner_nav.name.fmt(ip), anon_name_counter.*, }, .no_embedded_nulls); + anon_name_counter.* += 1; const nav_fqn = try ip.namespacePtr(fn_namespace).internFullyQualifiedName(ip, gpa, io, tid, nav_name); const nav_index = try ip.createNav(gpa, io, tid, nav_name, nav_fqn, .{ .type = ip.typeOf(func_index), diff --git a/src/Sema.zig b/src/Sema.zig index 7eda20bf930243883aa8f87d0b454da0b74eb6c6..68e8524b838914d898a8b2b4764aaaba750e0da3 100644 --- a/src/Sema.zig +++ b/src/Sema.zig @@ -7039,6 +7039,7 @@ fn analyzeCall( .inferred_error_set = fn_zir_info.inferred_error_set, .generic_owner = func_val.?.toIntern(), .comptime_args = comptime_args, + .anon_name_counter = &zcu.anon_name_counter, }); if (zcu.comp.debugIncremental()) { const nav = ip.indexToKey(func_instance).func.owner_nav; @@ -35222,9 +35223,10 @@ pub fn setTypeName( io, pt.tid, "{f}__{s}_{d}", - .{ block.type_name_ctx.fmt(ip), anon_prefix, @backingInt(wip.index) }, + .{ block.type_name_ctx.fmt(ip), anon_prefix, zcu.anon_name_counter }, .no_embedded_nulls, ), .none); + zcu.anon_name_counter += 1; }, .parent => wip.setName(ip, block.type_name_ctx, sema.owner.unwrap().nav_val.toOptional()), .func => { diff --git a/src/Zcu.zig b/src/Zcu.zig index 31ea183e8959c7c02391715b34e8743e005129d7..75aada8dd3831cdc7989617febe77000be066104 100644 --- a/src/Zcu.zig +++ b/src/Zcu.zig @@ -348,6 +348,9 @@ codegen_task_pool: CodegenTaskPool, generation: u32 = 0, +/// Only access from the Sema thread. +anon_name_counter: u32, + pub const DependencyReason = struct { src: LazySrcLoc, /// Only populated if this is for a `.type_layout` unit. diff --git a/src/link/Coff.zig b/src/link/Coff.zig index 9a7984de7f0d1d5362e59ce49cc7de028ca8f9b4..5ba57bee9d7ba76c6588f7c3320accc84e0a9c91 100644 --- a/src/link/Coff.zig +++ b/src/link/Coff.zig @@ -3108,7 +3108,7 @@ fn ensureMemberSymbol(coff: *Coff, mi: Member.Index, name: String) !void { coff.member_prog_node.increaseEstimatedTotalItems(1); } -fn flushSymbolTableEntry(coff: *Coff, index: u32, pt: Zcu.PerThread) !void { +fn flushSymbolTableEntry(coff: *Coff, index: u32) !void { assert(!coff.isImage()); const gpa = coff.base.comp.gpa; @@ -3119,7 +3119,6 @@ fn flushSymbolTableEntry(coff: *Coff, index: u32, pt: Zcu.PerThread) !void { assert(sym.ni != .none or sym.gmi != .none); const entry = coff.symbolTableEntryPtr(sti.*) orelse entry: { - var buf: [15]u8 = undefined; const symbol_name, const num_aux_symbols: u8, const complex_type: std.coff.ComplexType = if (sym.gmi != .none) blk: { const name = sym.gmi.name(coff); @@ -3148,21 +3147,22 @@ fn flushSymbolTableEntry(coff: *Coff, index: u32, pt: Zcu.PerThread) !void { }; }, .uav => |umi| { - var w = Io.Writer.fixed(&buf); - w.print("__anon_{x}", .{umi.uavValue(coff)}) catch unreachable; + var name_buf: [std.fmt.count("__anon_{d}", .{std.math.maxInt(u32)})]u8 = undefined; + const name = std.mem.print(&name_buf, "__anon_{d}", .{umi}) catch unreachable; break :blk .{ - try coff.getOrPutSymbolName(w.buffered(), null), + try coff.getOrPutSymbolName(name, null), 0, .NULL, }; }, inline .lazy_code, .lazy_const_data => |mi, tag| { const lazy_sym = mi.lazySymbol(coff); - const name = try gpa.print("__lazy_{s}_{f}", .{ - @tagName(lazy_sym.kind), - Type.fromInterned(lazy_sym.ty).fmt(pt), - }); - defer gpa.free(name); + var name_buf: [ + std.fmt.count("__lazy_const_data_{d}", .{std.math.maxInt(u32)}) + ]u8 = undefined; + const name = std.mem.print(&name_buf, "__lazy_{t}_{d}", .{ + lazy_sym.kind, mi, + }) catch unreachable; const string = try coff.getOrPutString(name); break :blk .{ @@ -6023,7 +6023,6 @@ fn resolve(coff: *Coff, tid: Zcu.PerThread.Id) !bool { defer sub_prog_node.end(); coff.flushSymbolTableEntry( coff.symbol_table.pending_symbol_index, - .{ .zcu = comp.zcu.?, .tid = tid }, ) catch |err| switch (err) { error.OutOfMemory => return error.OutOfMemory, else => |e| return comp.link_diags.fail( diff --git a/src/link/Elf2.zig b/src/link/Elf2.zig index a694aa21c6fff16a98a67c484375c786154fa15f..efd9e71a88ef4a8075d06dacc17b5a98fcd93310 100644 --- a/src/link/Elf2.zig +++ b/src/link/Elf2.zig @@ -3309,11 +3309,8 @@ fn lazySymbolInner(elf: *Elf, pt: Zcu.PerThread, lazy: link.File.LazySymbol) Err }; const node = try shndx.get(elf).ni.addFloatingChild(&elf.mf, gpa, .{}); var name_buf: [std.fmt.count("__lazy_const_data_{d}", .{std.math.maxInt(u32)})]u8 = undefined; - const name = std.mem.print( - &name_buf, - "__lazy_{t}_{d}", - .{ lazy.kind, @backingInt(lazy.ty) }, - ) catch unreachable; + const name = std.mem.print(&name_buf, "__lazy_{t}_{d}", .{ lazy.kind, gop.index }) catch + unreachable; gop.value_ptr.* = .{ .lsi = elf.addLocalSymbolAssumeCapacity(.{ .node = .wrap(node), @@ -5921,11 +5918,7 @@ fn uavMapIndex( .alignment = resolved_align, }); var name_buf: [std.fmt.count("__anon_{d}", .{std.math.maxInt(u32)})]u8 = undefined; - const name = std.mem.print( - &name_buf, - "__anon_{d}", - .{@backingInt(uav_val)}, - ) catch unreachable; + const name = std.mem.print(&name_buf, "__anon_{d}", .{umi}) catch unreachable; uav_gop.value_ptr.* = .{ .lsi = elf.addLocalSymbolAssumeCapacity(.{ .node = .wrap(node), diff --git a/src/link/Wasm.zig b/src/link/Wasm.zig index 42111676dc8081af73ecea74ffe55fa6c5f426c2..56b82fef3b02e2917ec78e5e22c0bd93c3688eae 100644 --- a/src/link/Wasm.zig +++ b/src/link/Wasm.zig @@ -1374,11 +1374,7 @@ pub const GlobalImport = extern struct { .__tls_base => @tagName(Unpacked.__tls_base), .__tls_size => @tagName(Unpacked.__tls_size), .object_global => |i| i.name(wasm).slice(wasm), - inline .uav_obj, .uav_exe => |i| std.mem.print( - buf, - "__anon_{d}", - .{@backingInt(i.key(wasm).*)}, - ) catch unreachable, + inline .uav_obj, .uav_exe => |i| std.mem.print(buf, "__anon_{d}", .{i}) catch unreachable, .nav_obj => |i| i.name(wasm), .nav_exe => |i| i.name(wasm), }; @@ -1997,11 +1993,7 @@ pub const ObjectDataImport = extern struct { .__heap_base => @tagName(.__heap_base), .__heap_end => @tagName(.__heap_end), .__wasm_first_page_end => @tagName(.__wasm_first_page_end), - inline .uav_exe, .uav_obj => |i| std.mem.print( - buf, - "__anon_{d}", - .{@backingInt(i.key(wasm).*)}, - ) catch unreachable, + inline .uav_exe, .uav_obj => |i| std.mem.print(buf, "__anon_{d}", .{i}) catch unreachable, inline .nav_exe, .nav_obj => |i| i.name(wasm), }; } -- 2.54.0