Merge pull request #23923 from alexrp/compiler-rt-symbols

Use hidden visibility in compiler-rt and libzigc except when testing

Author: alexrp

build.zig

@@ -437,7 +437,8 @@ pub fn build(b: *std.Build) !void {
         .skip_non_native = skip_non_native,
         .skip_libc = skip_libc,
         .use_llvm = use_llvm,
-        .max_rss = 2 * 1024 * 1024 * 1024,
+        // 2262585344 was observed on an x86_64-linux-gnu host.
+        .max_rss = 2488843878,
     }));
 
     test_modules_step.dependOn(tests.addModuleTests(b, .{

lib/c/common.zig

@@ -9,7 +9,7 @@ else
 /// Determines the symbol's visibility to other objects.
 /// For WebAssembly this allows the symbol to be resolved to other modules, but will not
 /// export it to the host runtime.
-pub const visibility: std.builtin.SymbolVisibility = if (builtin.cpu.arch.isWasm() and linkage != .internal)
+pub const visibility: std.builtin.SymbolVisibility = if (linkage != .internal)
     .hidden
 else
     .default;

lib/compiler_rt/aarch64_outline_atomics.zig

@@ -2,7 +2,8 @@ const std = @import("std");
 const builtin = @import("builtin");
 const arch = builtin.cpu.arch;
 const os = builtin.os.tag;
-pub const panic = @import("common.zig").panic;
+const common = @import("common.zig");
+pub const panic = common.panic;
 
 // Ported from llvm-project d32170dbd5b0d54436537b6b75beaf44324e0c28
 
@@ -174,10 +175,8 @@ fn clear_cache(start: usize, end: usize) callconv(.c) void {
     }
 }
 
-const linkage = if (builtin.is_test) std.builtin.GlobalLinkage.internal else std.builtin.GlobalLinkage.weak;
-
 fn exportIt() void {
-    @export(&clear_cache, .{ .name = "__clear_cache", .linkage = linkage });
+    @export(&clear_cache, .{ .name = "__clear_cache", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 // Darwin-only

lib/compiler_rt/clear_cache.zig

@@ -3,6 +3,9 @@ const builtin = @import("builtin");
 const native_endian = builtin.cpu.arch.endian();
 const ofmt_c = builtin.object_format == .c;
 
+/// For now, we prefer weak linkage because some of the routines we implement here may also be
+/// provided by system/dynamic libc. Eventually we should be more disciplined about this on a
+/// per-symbol, per-target basis: https://github.com/ziglang/zig/issues/11883
 pub const linkage: std.builtin.GlobalLinkage = if (builtin.is_test)
     .internal
 else if (ofmt_c)
@@ -13,8 +16,10 @@ else
 /// Determines the symbol's visibility to other objects.
 /// For WebAssembly this allows the symbol to be resolved to other modules, but will not
 /// export it to the host runtime.
-pub const visibility: std.builtin.SymbolVisibility =
-    if (builtin.target.cpu.arch.isWasm() and linkage != .internal) .hidden else .default;
+pub const visibility: std.builtin.SymbolVisibility = if (linkage != .internal)
+    .hidden
+else
+    .default;
 
 pub const PreferredLoadStoreElement = element: {
     if (std.simd.suggestVectorLength(u8)) |vec_size| {

lib/compiler_rt/common.zig

@@ -1,15 +1,15 @@
 const std = @import("std");
 const testing = std.testing;
 const builtin = @import("builtin");
-const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .internal else .weak;
+const common = @import("common.zig");
 const panic = @import("common.zig").panic;
 
 const have_availability_version_check = builtin.os.tag.isDarwin() and
     builtin.os.version_range.semver.min.order(.{ .major = 10, .minor = 15, .patch = 0 }).compare(.gte);
 
 comptime {
     if (have_availability_version_check) {
-        @export(&__isPlatformVersionAtLeast, .{ .name = "__isPlatformVersionAtLeast", .linkage = linkage });
+        @export(&__isPlatformVersionAtLeast, .{ .name = "__isPlatformVersionAtLeast", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 

lib/compiler_rt/os_version_check.zig

@@ -1,36 +1,35 @@
 const std = @import("std");
 const builtin = @import("builtin");
+const common = @import("common.zig");
 const os_tag = builtin.os.tag;
 const arch = builtin.cpu.arch;
 const abi = builtin.abi;
 const is_test = builtin.is_test;
 
-const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .internal else .weak;
-const strong_linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .internal else .strong;
-pub const panic = @import("common.zig").panic;
+pub const panic = common.panic;
 
 comptime {
     if (builtin.os.tag == .windows) {
         // Default stack-probe functions emitted by LLVM
         if (builtin.target.isMinGW()) {
-            @export(&_chkstk, .{ .name = "_alloca", .linkage = linkage });
-            @export(&___chkstk_ms, .{ .name = "___chkstk_ms", .linkage = linkage });
+            @export(&_chkstk, .{ .name = "_alloca", .linkage = common.linkage, .visibility = common.visibility });
+            @export(&___chkstk_ms, .{ .name = "___chkstk_ms", .linkage = common.linkage, .visibility = common.visibility });
 
             if (arch == .thumb or arch == .aarch64) {
-                @export(&__chkstk, .{ .name = "__chkstk", .linkage = linkage });
+                @export(&__chkstk, .{ .name = "__chkstk", .linkage = common.linkage, .visibility = common.visibility });
             }
         } else if (!builtin.link_libc) {
             // This symbols are otherwise exported by MSVCRT.lib
-            @export(&_chkstk, .{ .name = "_chkstk", .linkage = linkage });
-            @export(&__chkstk, .{ .name = "__chkstk", .linkage = linkage });
+            @export(&_chkstk, .{ .name = "_chkstk", .linkage = common.linkage, .visibility = common.visibility });
+            @export(&__chkstk, .{ .name = "__chkstk", .linkage = common.linkage, .visibility = common.visibility });
         }
     }
 
     switch (arch) {
         .x86,
         .x86_64,
         => {
-            @export(&zig_probe_stack, .{ .name = "__zig_probe_stack", .linkage = linkage });
+            @export(&zig_probe_stack, .{ .name = "__zig_probe_stack", .linkage = common.linkage, .visibility = common.visibility });
         },
         else => {},
     }

lib/compiler_rt/stack_probe.zig

@@ -1,3 +1,4 @@
+const builtin = @import("builtin");
 const std = @import("std");
 const testing = std.testing;
 
@@ -432,6 +433,8 @@ fn test_write_leb128(value: anytype) !void {
 }
 
 test "serialize unsigned LEB128" {
+    if (builtin.cpu.arch == .x86 and builtin.abi == .musl and builtin.link_mode == .dynamic) return error.SkipZigTest;
+
     const max_bits = 18;
 
     comptime var t = 0;
@@ -446,6 +449,8 @@ test "serialize unsigned LEB128" {
 }
 
 test "serialize signed LEB128" {
+    if (builtin.cpu.arch == .x86 and builtin.abi == .musl and builtin.link_mode == .dynamic) return error.SkipZigTest;
+
     // explicitly test i0 because starting `t` at 0
     // will break the while loop
     try test_write_leb128(@as(i0, 0));

lib/std/leb128.zig

@@ -296,17 +296,16 @@ const test_targets = blk: {
             },
             .link_libc = true,
         },
-        // https://github.com/ziglang/zig/issues/7935
-        // .{
-        //     .target = .{
-        //         .cpu_arch = .x86,
-        //         .os_tag = .linux,
-        //         .abi = .musl,
-        //     },
-        //     .linkage = .dynamic,
-        //     .link_libc = true,
-        //     .extra_target = true,
-        // },
+        .{
+            .target = .{
+                .cpu_arch = .x86,
+                .os_tag = .linux,
+                .abi = .musl,
+            },
+            .linkage = .dynamic,
+            .link_libc = true,
+            .extra_target = true,
+        },
         .{
             .target = .{
                 .cpu_arch = .x86,

test/tests.zig

@@ -24,7 +24,7 @@ pub fn main() !void {
         \\//! This file is generated by tools/gen_outline_atomics.zig.
         \\const builtin = @import("builtin");
         \\const std = @import("std");
-        \\const linkage = @import("./common.zig").linkage;
+        \\const common = @import("common.zig");
         \\const always_has_lse = std.Target.aarch64.featureSetHas(builtin.cpu.features, .lse);
         \\
         \\/// This default is overridden at runtime after inspecting CPU properties.
@@ -48,7 +48,7 @@ pub fn main() !void {
                     @tagName(op), n.toBytes(), @tagName(order),
                 });
                 try writeFunction(arena, w, name, op, n, order);
-                try footer.writer().print("    @export(&{s}, .{{ .name = \"{s}\", .linkage = linkage }});\n", .{
+                try footer.writer().print("    @export(&{s}, .{{ .name = \"{s}\", .linkage = common.linkage, .visibility = common.visibility }});\n", .{
                     name, name,
                 });
             }