Commit cce0b43270a57a884e7d7aeba25bc6953741156e | zig

author	Pavel Verigo <paul.verigo@gmail.com> 2026-08-08 01:43:21+02:00
committer	Pavel Verigo <paul.verigo@gmail.com> 2026-08-11 20:00:12+02:00
log	cce0b43270a57a884e7d7aeba25bc6953741156e
tree	00be505cace3741b3ae69dd98e910302bb0a46ff
parent	9d92d2ce93c52083fe405716a6cf05151384b76e

wasm: change symbol name for function if it uses library name

Fixes bug when `fn "js" log(...)` collide with compiler-rt `log` symbol, to fix I reuse logic/idea from llvm backend.

2 files changed, 28 insertions(+), 13 deletions(-)

src
- link
  - Wasm.zig
  - Wasm
    Flush.zig

src/link/Wasm.zig+24-11

 @@ -187,7 +187,7 @@ overaligned_uavs: std.array_hash_map.Auto(InternPool.Index, Alignment) = .empty,
 zcu_funcs: std.array_hash_map.Auto(InternPool.Index, ZcuFunc) = .empty,
 nav_exports: std.array_hash_map.Auto(NavExport, Zcu.Export.Index) = .empty,
 uav_exports: std.array_hash_map.Auto(UavExport, Zcu.Export.Index) = .empty,
-imports: std.array_hash_map.Auto(InternPool.Nav.Index, void) = .empty,
+imports: std.array_hash_map.Auto(InternPool.Nav.Index, String) = .empty,
 dwarf: ?Dwarf = null,
 @@ -409,7 +409,7 @@ pub const OutputFunctionIndex = enum(u32) {
         const ip = &zcu.intern_pool;
         return switch (ip.indexToKey(ip_index)) {
             .@"extern" => |ext| {
-                const name = wasm.getExistingString(ext.name.toSlice(ip)).?;
+                const name = wasm.imports.get(ext.owner_nav).?;
                 return fromSymbolName(wasm, name);
             },
             else => fromResolution(wasm, .fromIpIndex(wasm, ip_index)).?,
 @@ -479,8 +479,8 @@ pub const OutputDataIndex = enum(u32) {
         const zcu = wasm.base.comp.zcu.?;
         const ip = &zcu.intern_pool;
         const nav = ip.getNav(nav_index);
-        if (nav.getExtern(ip)) |ext| {
+        if (nav.getExtern(ip) != null) {
-            return fromSymbolName(wasm, wasm.getExistingString(ext.name.toSlice(ip)).?);
+            return fromSymbolName(wasm, wasm.imports.get(nav_index).?);
         }
         const resolution: ObjectDataImport.Resolution = if (wasm.base.comp.config.output_mode == .Obj)
             .pack(wasm, .{ .nav_obj = @fromBackingInt(@intCast(wasm.navs_obj.getIndex(nav_index).?)) })
 @@ -2592,6 +2592,10 @@ pub const ZcuImportIndex = enum(u32) {
         return &wasm.imports.keys()[@backingInt(index)];
     }
+    pub fn symbolName(index: ZcuImportIndex, wasm: *const Wasm) String {
+        return wasm.imports.values()[@backingInt(index)];
+    }
     pub fn flags(index: ZcuImportIndex, wasm: *const Wasm) SymbolFlags {
         const zcu = wasm.base.comp.zcu.?;
         const ip = &zcu.intern_pool;
 @@ -2613,7 +2617,7 @@ pub const ZcuImportIndex = enum(u32) {
             },
             .undefined = true,
             .exported = wasm.missing_exports.contains(name_string),
-            .explicit_name = false,
+            .explicit_name = index.symbolName(wasm) != name_string,
             .no_strip = false,
             .tls = ext.is_threadlocal,
             .absolute = false,
 @@ -3683,14 +3687,23 @@ pub fn updateNav(wasm: *Wasm, pt: Zcu.PerThread, nav_index: InternPool.Nav.Index
             } else {
                 assert(!wasm.navs_exe.contains(ext.owner_nav));
             }
-            const name = try wasm.internString(ext.name.toSlice(ip));
+            const name_slice = ext.name.toSlice(ip);
-            if (ext.lib_name.toSlice(ip)) |ext_name| _ = try wasm.internString(ext_name);
+            const name = try wasm.internString(name_slice);
+            const symbol_name = if (ip.isFunctionType(nav.resolved.?.type)) symbol_name: {
+                const lib_name = ext.lib_name.toSlice(ip) orelse break :symbol_name name;
+                _ = try wasm.internString(lib_name);
+                // match llvm backend behavior
+                if (mem.eql(u8, lib_name, "c")) break :symbol_name name;
+                const qualified_name = try std.fmt.allocPrint(gpa, "{s}|{s}", .{ name_slice, lib_name });
+                defer gpa.free(qualified_name);
+                break :symbol_name try wasm.internString(qualified_name);
+            } else name;
             try wasm.imports.ensureUnusedCapacity(gpa, 1);
             try wasm.function_imports.ensureUnusedCapacity(gpa, 1);
             try wasm.data_imports.ensureUnusedCapacity(gpa, 1);
-            const zcu_import = wasm.addZcuImportReserved(ext.owner_nav);
+            const zcu_import = wasm.addZcuImportReserved(ext.owner_nav, symbol_name);
             if (ip.isFunctionType(nav.resolved.?.type)) {
-                wasm.function_imports.putAssumeCapacity(name, .fromZcuImport(zcu_import, wasm));
+                wasm.function_imports.putAssumeCapacity(symbol_name, .fromZcuImport(zcu_import, wasm));
                 // Ensure there is a corresponding function type table entry.
                 const fn_info = zcu.typeToFunc(.fromInterned(ext.ty)).?;
                 _ = try internFunctionType(wasm, fn_info.cc, fn_info.param_types.get(ip), .fromInterned(fn_info.return_type), fn_info.is_var_args, target);
 @@ -5073,9 +5086,9 @@ fn pointerSize(wasm: *const Wasm) u32 {
     };
 }
-fn addZcuImportReserved(wasm: *Wasm, nav_index: InternPool.Nav.Index) ZcuImportIndex {
+fn addZcuImportReserved(wasm: *Wasm, nav_index: InternPool.Nav.Index, symbol_name: String) ZcuImportIndex {
     const gop = wasm.imports.getOrPutAssumeCapacity(nav_index);
-    gop.value_ptr.* = {};
+    gop.value_ptr.* = symbol_name;
     return @fromBackingInt(@intCast(gop.index));
 }

src/link/Wasm/Flush.zig+4-2

 @@ -1472,14 +1472,16 @@ pub fn finish(f: *Flush, wasm: *Wasm) !void {
                 // SYMTAB_FUNCTION
                 {
                     symbol_table_offsets.function = symbol_count;
-                    for (f.function_imports.values(), 0..) |i, function_index| {
+                    for (f.function_imports.keys(), f.function_imports.values(), 0..) |symbol_name, i, function_index| {
                         try binary_bytes.append(gpa, @backingInt(Object.Symbol.Tag.function));
                         const flags = i.flags(wasm);
                         assert(flags.undefined);
                         try appendLeb128(gpa, binary_bytes, flags.toAbiInteger());
                         try appendLeb128(gpa, binary_bytes, @as(u32, @intCast(function_index)));
                         if (flags.explicit_name) {
-                            unreachable; // never set
+                            const name = symbol_name.slice(wasm);
+                            try appendLeb128(gpa, binary_bytes, @as(u32, @intCast(name.len)));
+                            try binary_bytes.appendSlice(gpa, name);
                         }
                         symbol_count += 1;
                     }